cpp/kata/4kyu/525c7c5ab6aecef16e0001a5.h

@@ -0,0 +1,102 @@
+#pragma once
+
+#include <map>
+#include <string>
+#include <sstream>
+
+long toNum(std::string const & number) {
+	static const std::map<std::string,int> data = {
+		{"one", 1}, {"two", 2}, {"three", 3}, {"four", 4}, {"five", 5}, {"six", 6}, {"seven", 7}, {"eight", 8}, {"nine", 9}, {"ten", 10},
+		{"eleven", 11}, {"twelve", 12}, {"thirteen", 13}, {"fourteen", 14}, {"fifteen", 15},
+		{"sixteen", 16}, {"seventeen", 17}, {"eighteen", 18}, {"nineteen", 19}, {"twenty", 20},
+		{"thirty", 30}, {"forty", 40}, {"fifty", 50}, {"sixty", 60}, {"seventy", 70}, {"eighty", 80}, {"eighty", 80}, {"ninety", 90},
+		{"hundred", 100}, {"thousand", 1000}, {"million", 1000000}, {"and", 0}, {"zero", 0}
+	};
+	size_t pos = number.find('-');
+	if( pos != std::string::npos ){
+		return data.at(number.substr(0, pos)) + data.at(number.substr(pos + 1));
+	} else
+		return data.at(number);
+}
+
+long parse_int(std::string number) {
+	std::istringstream ss(number);
+	long res = 0;
+	long tmp = 0;
+	std::string first;
+	while( !ss.eof() ){
+		ss >> first;
+		switch( toNum(first) ){
+			case 100:
+				tmp *= toNum(first);
+				break;
+			case 1000:
+			case 1000000:
+				res += tmp;
+				res *= toNum(first);
+				tmp = 0;
+				break;
+			default:
+				if( tmp % 10 == 0 ){
+					res += tmp;
+					tmp = 0;
+				}
+				tmp += toNum(first);
+		}
+	}
+	res += tmp;
+	return res;
+}
+
+long parse_int2(const std::string& number) {
+  std::map<std::string, int> mapping = {
+    {"zero", 0}, {"and", 0}, {"hundred", 100},  {"thousand", 1000}, {"million", 1000000},  
+    {"one", 1}, {"two",   2}, {"three",  3}, {"four", 4}, {"five", 5}, 
+    {"six", 6}, {"seven", 7}, {"eight",  8}, {"nine", 9}, {"ten", 10},
+    {"eleven",  11}, {"twelve",    12}, {"thirteen", 13}, {"fourteen", 14}, {"fifteen", 15},
+    {"sixteen", 16}, {"seventeen", 17}, {"eighteen", 18}, {"nineteen", 19}, 
+    {"twenty",  20}, {"thirty",  30},   {"forty",    40}, {"fifty",    50}, 
+    {"sixty",   60}, {"seventy", 70},   {"eighty",   80}, {"ninety", 90}
+    
+  };
+  
+  long result = 0;
+  auto add = [&] (auto& w) {
+    if (w.empty()) return;
+    auto i = mapping[w];
+    if      (i > 0 && i < 100) result += i;
+    else if (i == 1000 || i == 1000000) result *= i;
+    else if (i == 100) result += 99 * (result % 100);
+    w = "";
+  };
+  
+  std::string word;
+  for (auto c : number) {
+    if (word.size() > 0 && (c == ' ' || c == '-')) add(word);
+    else word.push_back(c);
+  }
+  add(word);
+  
+  return result;
+}
+
+long parse_int3(std::string number) {
+	std::istringstream ss(number);
+	long res = 0;
+	std::string first;
+	while( !ss.eof() ){
+		ss >> first;
+		switch( toNum(first) ){
+			case 100:
+				res += 99 * ( res % 100 );
+				break;
+			case 1000:
+			case 1000000:
+				res *= toNum(first);
+				break;
+			default:
+				res += toNum(first);
+		}
+	}
+	return res;
+}

cpp/kata/4kyu/525f4206b73515bffb000b21.h

@@ -0,0 +1,36 @@
+#pragma once
+#include <string>
+
+std::string add(const std::string& a, const std::string& b) {
+	std::string res;
+
+	std::string::const_reverse_iterator ItA = a.rbegin();
+	std::string::const_reverse_iterator ItB = b.rbegin();
+
+	char ca, cb;
+	bool over = false;
+	for( ; ItA != a.rend() && ItB != b.rend(); ++ItA, ++ItB ){
+		ca = *ItA + over;
+		cb = *ItB;
+		over = ca - 48 + cb - 48 > 9;
+		res.insert(res.begin(), ca - 48 + cb - (over ? 10 : 0));
+	}
+
+	for( ; ItA != a.rend(); ++ItA ){
+		ca = *ItA + over;
+		over = ca - 48 > 9;
+		res.insert(res.begin(), ca - (over ? 10 : 0));
+	}
+	for( ; ItB != b.rend(); ++ItB ){
+		cb = *ItB + over;
+		over = cb - 48 > 9;
+		res.insert(res.begin(), cb - (over ? 10 : 0));
+	}
+
+	if( over )
+		res.insert(res.begin(), '1');
+
+	return res;
+}
+
+

cpp/kata/4kyu/5324945e2ece5e1f32000370.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#include <string>
+#include <vector>
+
+std::string sum_strings( const std::string & a, const std::string & b ) {
+    std::vector<char> sum;
+    const std::string &shorter = a.size() > b.size() ? b : a, &longer = a.size() > b.size() ? a : b;
+    auto itShorter = shorter.rbegin(), itLonger = longer.rbegin();
+    bool moreThanNine = false;
+    auto addToSum = [&]( char value ) {
+        value += moreThanNine;
+        moreThanNine = value > 9;
+        sum.push_back( value + '0' - 10 * moreThanNine );
+    };
+    for ( ; itShorter != shorter.rend(); ++itShorter, ++itLonger )
+    { addToSum( *itShorter + *itLonger - 2 * '0' ); }
+    for ( ; itLonger != longer.rend(); ++itLonger )
+    { addToSum( *itLonger - '0' ); }
+    if ( moreThanNine )
+        sum.push_back( '1' );
+    return std::string( sum.rbegin(), sum.rend() );
+}

cpp/kata/4kyu/549ee8b47111a81214000941.h

@@ -0,0 +1,57 @@
+#pragma once
+
+#include <string>
+#include <limits>
+#include <cmath>
+#include <algorithm>
+
+struct point
+{
+    explicit point( const std::string & s )
+        : x( s.at( 0 ) - 'a' )
+        , y( s.at( 1 ) - '1' ) {}
+    constexpr point( int a, int b )
+        : x( b )
+        , y( a ) {}
+    constexpr bool operator==( const point & other ) const {
+        return x == other.x && y == other.y;
+    }
+    constexpr bool belongs( const point & min, const point & max ) const {
+        return x >= min.x && x <= max.x && y >= min.y && y <= max.y;
+    }
+    static double length( const point & p1, const point & p2 ) {
+        return std::sqrt( std::pow( ( p2.x - p1.x ), 2 ) + std::pow( ( p2.y - p1.y ), 2 ) );
+    }
+    const int x;
+    const int y;
+};
+
+constexpr point minPoint{ 0, 0 }, maxPoint{ 7, 7 };
+constexpr std::array<point, 8> knightMoves{ { { -1, -2 }, { 1, 2 }, { -2, 1 }, { -1, 2 }, { 2, -1 }, { 1, -2 }, { 2, 1 }, { -2, -1 } } };
+
+template <class M, class P>
+int find( int step, int max, const point & start, const point & finish, P && path, const M & moves ) {
+    if ( finish == start || step >= max )
+    { return step; }
+
+    for ( const auto & m : moves )
+    {
+        point next{ start.y + m.y, start.x + m.x };
+        if ( next.belongs( minPoint, maxPoint ) && std::find( path.begin(), path.end(), next ) == path.end()
+             && ( point::length( start, finish ) <= 2 || point::length( next, finish ) < point::length( start, finish ) ) )
+        {
+            path.push_back( next );
+            max = find( step + 1, max, next, finish, path, moves );
+            path.pop_back();
+        }
+    }
+    return max != std::numeric_limits<decltype( max )>::max() ? max : step;
+}
+
+int knight( std::string start, std::string finish ) {
+    if( finish == "a1" || finish == "a8" || finish == "h1" || finish == "h8" ){
+        return find( 0, std::numeric_limits<int>::max(), point( finish ), point( start ), std::vector<point>{}, knightMoves );
+    } else {
+        return find( 0, std::numeric_limits<int>::max(), point( start ), point( finish ), std::vector<point>{}, knightMoves );
+    }
+}

cpp/kata/4kyu/55911ef14065454c75000062.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include <string>
+
+std::string multiply(std::string a, std::string b) {
+    std::string mul;
+    const std::string & shorter = a.size() <= b.size() ? a : b;
+    const std::string longer = std::string(shorter.size(), '0') + ( std::addressof(shorter) == std::addressof(a) ? b : a);
+    int result = 0;
+    for( auto idx = 0; idx < longer.size(); idx++ ){
+        for( auto longIdx = idx, shortIdx = 0; longIdx >= 0 && shortIdx < shorter.size() ; shortIdx++, longIdx-- ){
+            result += ( longer[longer.size() - 1 - longIdx] - '0' ) * ( shorter[shorter.size() - 1 - shortIdx] - '0' );
+        }
+        mul.push_back(result % 10 + '0');
+        result /= 10;
+    }
+    mul.erase(mul.find_last_not_of('0') == std::string::npos ? 1 : mul.find_last_not_of('0') + 1);
+    return std::string(mul.rbegin() , mul.rend());
+}

cpp/kata/5kyu/544047f0cf362503e000036e.h

@@ -0,0 +1,147 @@
+#pragma once
+#include <vector>
+
+#include <algorithm>
+#include <array>
+#include <random>
+#include <cmath>
+#include <tuple>
+
+size_t getRandomIdx( size_t max ) {
+    static std::random_device r;
+    static std::default_random_engine e1( r() );
+    std::uniform_int_distribution<size_t> uniform_dist( 0, max );
+    return uniform_dist( e1 );
+}
+
+size_t getMaxCount( size_t size ) {
+    return std::ceil( std::log( size ) / std::log( 3 ) );
+}
+
+template <class T = size_t>
+struct ScalesN
+{
+    using DataT = std::vector<T>;
+    ScalesN( size_t correctIndex, size_t ballCount )
+        : count(getMaxCount(ballCount)), answer( correctIndex ), size(ballCount){
+        if( correctIndex > ballCount - 1 ){
+            throw std::logic_error{"impossible!"};
+        }
+        data = std::vector<T>(ballCount, 1);
+        data[answer]++;
+    };
+    ScalesN( const ScalesN & ) = delete;
+    ScalesN( ScalesN && ) = delete;
+
+    int getWeight( const std::vector<T> & left, const std::vector<T> & right ) {
+        if ( !count )
+        { throw std::runtime_error{ "broken" }; }
+        count--;
+        auto getWeight = [this]( const auto & indexes ) {
+            T weight{ 0 };
+            for ( const auto & idx : indexes )
+            { weight += data[idx]; }
+            return weight;
+        };
+        T leftWeight = getWeight( left ), rightWeight = getWeight( right );
+        if ( leftWeight > rightWeight )
+        {
+            return -1;
+        } else if ( rightWeight > leftWeight )
+        {
+            return 1;
+        } else
+            return 0;
+    }
+
+    size_t getAnswer() const { return answer; }
+    size_t getSize() const { return size; }
+    size_t getCount() const { return count; }
+
+private:
+    size_t count;
+    size_t answer;
+    const size_t size;
+    std::vector<T> data{};
+};
+
+namespace eightBalls
+{
+    // https://www.codewars.com/kata/544047f0cf362503e000036e/train/cpp
+    // https://www.codewars.com/kata/54404a06cf36258b08000364/train/cpp
+    // https://www.codewars.com/kata/544034f426bc6adda200000e/train/cpp
+    using Scales = ScalesN<int>;
+    using DataT = Scales::DataT;
+    int helper( Scales & scales, const DataT & left, const DataT & right, const DataT & remain ) {
+        DataT answer = remain;
+        switch ( scales.getWeight( left, right ) )
+        {
+            case 1:
+                answer = right;
+                break;
+            case -1:
+                answer = left;
+                break;
+        }
+        if ( answer.size() == 1 )
+            return answer.front();
+        return helper( scales, { answer[0] }, { answer[1] }, { answer[2] } );
+    }
+
+    unsigned int findBall( Scales scales ) {
+        return helper( scales, { 0, 1, 2 }, { 3, 4, 5 }, { 6, 7 } );
+    }
+} // namespace eightBalls  
+
+namespace dynamicBalls
+{
+    // https://www.codewars.com/kata/545c4f7682e55d3c6e0011a1
+    using Scales = ScalesN<int>;
+    using DataT = Scales::DataT;
+
+    auto splitData(const DataT& data){
+
+        DataT left{};
+        DataT right{};
+        DataT remain{};
+        size_t count = (data.size() + 1 )/ 3;
+        for( size_t n = 0; n < count; ++n ){
+            left.push_back(data[n]);
+        }
+        for( size_t n = count; n < count * 2; ++n ){
+            right.push_back(data[n]);
+        }
+        for( size_t n = count * 2; n < data.size(); ++n ){
+            remain.push_back(data[n]);
+        }
+        return std::make_tuple(std::move(left), std::move(right), std::move(remain));
+    }
+
+    int helper(Scales & scales, const DataT & data){
+        if( data.size() == 1 ){
+            return data.front();
+        }
+        auto [left, right, remain] = splitData(data);
+        switch( scales.getWeight(left, right) ){
+            case 1: return helper(scales, right);
+            case -1: return helper(scales, left);
+            default: return helper(scales, remain);
+        }
+    }
+
+    unsigned int findBall( Scales scales ) {
+        DataT indexes(scales.getSize());
+        std::iota(indexes.begin(), indexes.end(), 0);
+        return helper(scales, indexes);
+    }
+
+    void test(){
+        for ( size_t balls = 3; balls < 512; ++balls ){
+            for( size_t idx = 0; idx < balls; ++idx ){
+                if( idx != findBall({idx, balls}) ){
+                    throw std::runtime_error{"wrong answer!"};
+                }
+            }
+        }
+    }
+}

cpp/kata/6kyu/5287e858c6b5a9678200083c.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include <cmath>
+#include <iostream>
+
+namespace codewar {
+	bool narcissistic( int value ){
+		int testvalue = 0;
+		const int expBase = std::log10(value);
+		const int x = value;
+
+		
+		for( int exp = expBase; exp >= 0; exp-- ){
+			int topDigit = value / std::pow(10, exp);
+			testvalue += std::pow(topDigit, expBase + 1);
+			value -= std::pow(10, exp) * topDigit;
+		}
+
+		// best
+// 		while( value ){
+// 			testvalue += pow( value % 10 , expBase + 1  );
+// 			value /= 10;
+// 		}
+
+		return testvalue == x;
+	}
+}

cpp/kata/6kyu/54da5a58ea159efa38000836.h

@@ -4,18 +4,10 @@
 #include <map>
 #include <algorithm>
 
-int findOdd( std::vector<int> const & numbers ) {
-    std::map<int, size_t> check;
-    for ( auto var : numbers )
-    {
-        check[var]++;
-    }
-    return std::find_if( check.cbegin(), check.cend(), []( std::pair<int, size_t> x ) { return x.second % 2 == 1; } )->first;
-}
-
-int findOdd( std::vector<int> const & numbers ) {
-    int a = 0;
-    for ( auto n : numbers )
-        a ^= n;
-    return a;
+int findOdd(std::vector<int> const & numbers){
+	std::map<int,size_t> check;
+	for( auto var : numbers ){
+		check[var]++;
+	}
+	return std::find_if(check.cbegin(), check.cend(), [](std::pair<int, size_t> x){ return x.second % 2 == 1; })->first;
 }

cpp/kata/6kyu/5592e3bd57b64d00f3000047.h

@@ -0,0 +1,20 @@
+#pragma once
+
+namespace codewar {
+
+class ASum
+{
+	public:
+	static long long findNb(long long m){
+		long long  count = 0;
+		while( m > 0 ){
+			count++;
+			m -= count * count * count;
+		}
+
+		return m == 0 ? count : -1;
+	}
+};
+
+}
+