├── 00-prewritten_algorithms
    ├── array2D.cpp
    ├── counting_sort.cpp
    ├── factorial.cpp
    ├── factorization.cpp
    ├── fibonacci.cpp
    ├── gcd.cpp
    ├── getLeader.cpp
    ├── log.cpp
    └── make_next_index_array.cpp
├── 03-TimeComplexity
    ├── FrogJmp.cpp
    ├── PermMissingElem.cpp
    └── TapeEquilibrium.cpp
├── 04-CountingElements
    ├── FrogRiverOne.cpp
    ├── MaxCounters.cpp
    ├── MissingInteger.cpp
    └── PermCheck.cpp
├── 05-PrefixSums
    ├── CountDiv.cpp
    ├── GenomicRangeQuery.cpp
    ├── MinAvgTwoSlice.cpp
    └── PassingCars.cpp
├── 06-Sorting
    ├── Distinct.cpp
    ├── MaxProductOfThree.cpp
    ├── NumberofDiscIntersections.cpp
    └── Triangle.cpp
├── 07-StacksAndQueues
    ├── Brackets.cpp
    ├── Fish.cpp
    ├── Nesting.cpp
    └── StoneWall.cpp
├── 08-Leader
    ├── Dominator.cpp
    └── EquiLeader.cpp
├── 09-MaximumSliceProblem
    ├── MaxDoubleSliceSum.cpp
    ├── MaxProfit.cpp
    └── MaxSliceSum.cpp
├── 10-PrimeAndCompositeNumbers
    ├── CountFactors.cpp
    ├── Flags.cpp
    └── MinPerimeterRectangle.cpp
├── 11-SieveOfEratosthenes
    ├── CountNonDivisible.cpp
    └── CountSemiprimes.cpp
├── 12-EuclideanAlgorithm
    ├── ChocolatesByNumbers.cpp
    └── CommonPrimeDivisors.cpp
├── 13-Fibonaccinumbers
    ├── FibFrog.cpp
    └── Ladder.cpp
├── 14-BinarySearchAlgorithm
    ├── MinMaxDivision.cpp
    └── NailingPlanks.cpp
├── 15-CaterpillarMethod
    ├── AbsDistinct.cpp
    ├── CountDistinctSlices.cpp
    ├── CountTriangles.cpp
    └── MinAbsSumOfTwo.cpp
├── 16-GreedyAlgorithms
    ├── MaxNonoverlappingSegments.cpp
    └── TieRopes.cpp
├── 17-DynamicProgramming
    ├── MinAbsSum.cpp
    └── NumberSolitaire.cpp
├── 90-TasksFromIndeedPrime-2015-Challenge
    ├── FloodDepth.cpp
    └── LongestPassword.cpp
├── 99-FutureTraining
    ├── StrSymmetryPoint.cpp
    └── TreeHeight.cpp
├── Docs
    ├── 1-Iterations.pdf
    ├── 10-PrimeNumbers.pdf
    ├── 11-Sieve.pdf
    ├── 12-Gcd.pdf
    ├── 13-Fibonacci.pdf
    ├── 14-BinarySearch.pdf
    ├── 15-CaterpillarMethod.pdf
    ├── 16-GreedyAlgorithms.pdf
    ├── 17-DynamicProgramming.pdf
    ├── 2-Arrays.pdf
    ├── 3-TimeComplexity.pdf
    ├── 4-CountingElements.pdf
    ├── 5-PrefixSums.pdf
    ├── 6-Sorting.pdf
    ├── 7-Stacks.pdf
    ├── 8-Leader.pdf
    ├── 9-MaxSlice.pdf
    └── solutions
    │   ├── solution-cannonballs.pdf
    │   ├── solution-clocks.pdf
    │   ├── solution-count-bounded-slices.pdf
    │   ├── solution-double-median.pdf
    │   ├── solution-flags.pdf
    │   ├── solution-min-abs-sum.pdf
    │   └── solution-prefix-set.pdf
├── README.md
├── TestUnitForCodility.h
└── Todo.md


/00-prewritten_algorithms/array2D.cpp:
--------------------------------------------------------------------------------
 1 | #include <memory>
 2 | 
 3 | class Array2D {
 4 |     size_t _rows;
 5 |     size_t _columns;
 6 |     std::unique_ptr<int[]> data;
 7 | 
 8 | public:
 9 |     Array2D(size_t rows, size_t columns)
10 |         : _rows{ rows },
11 |         _columns{ columns },
12 |         data{ std::make_unique<int[]>(rows * columns) } {}
13 | 
14 |     size_t rows() const { return _rows; }
15 | 
16 |     size_t columns() const { return _columns; }
17 | 
18 |     int* operator[](size_t row) { return row * _columns + data.get(); }
19 | 
20 |     int& operator()(size_t row, size_t column) {
21 |         return data[row * _columns + column];
22 |     }
23 | };


--------------------------------------------------------------------------------
/00-prewritten_algorithms/counting_sort.cpp:
--------------------------------------------------------------------------------
 1 | void counting_sort(vector<int> &A, int min, int max) {
 2 |     int offset = 0;
 3 |     if(min < 0)
 4 |         offset = -min;
 5 |     int size = max - min + 1;
 6 |     vector<int> count(size, 0);
 7 |     for(int i : A)
 8 |         count[i + offset] +=1;
 9 |         
10 |     int p = 0;
11 |     for(size_t j = 0; j<count.size(); j++)
12 |     {
13 |         for(int i=0; i<count[j]; i++)
14 |             A[p++] = j - offset;
15 |     }
16 | }


--------------------------------------------------------------------------------
/00-prewritten_algorithms/factorial.cpp:
--------------------------------------------------------------------------------
1 | vector<uint64_t> getFactorial(int n) {
2 |     vector<uint64_t> f(n+1, 0);
3 |     f[0] = 1;
4 |     for (int i = 1; i <= n; i++)
5 |         f[i] = f[i - 1] * i;
6 |     return f;
7 | }
8 | 


--------------------------------------------------------------------------------
/00-prewritten_algorithms/factorization.cpp:
--------------------------------------------------------------------------------
 1 | vector<int> getFactArr(int n) {
 2 |     vector<int> f(n+1, 0);
 3 |     int i = 2;
 4 |     while (i * i <= n) {
 5 |         if (f[i] == 0) {
 6 |             int k = i * i;
 7 |             while (k <= n) {
 8 |                 if (f[k] == 0)
 9 |                     f[k] = i;
10 |                 k+=i;
11 |             }
12 |         }
13 |         i++;
14 |     }
15 |     return f;
16 | }
17 | 
18 | vector<int> factorization(int x) {
19 |     vector<int> primeFactors;
20 |     vector<int> F = getFactArr(x);
21 |     while (F[x] > 0) {
22 |         primeFactors.push_back(F[x]);
23 |         x /= F[x];
24 |     }
25 |     primeFactors.push_back(x);
26 |     
27 |     return primeFactors;
28 | }
29 | 


--------------------------------------------------------------------------------
/00-prewritten_algorithms/fibonacci.cpp:
--------------------------------------------------------------------------------
 1 | vector<int> fibs={0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946, 17711, 28657, 46368, 75025};
 2 | 
 3 | // only for N <=46
 4 | uint64_t getFibonacci(size_t N) {
 5 |     return static_cast<uint64_t>((pow((1.0 + sqrt(5)) / 2.0, N) - pow((1.0 - sqrt(5)) / 2.0, N)) / sqrt(5));
 6 | }
 7 | 
 8 | vector<uint64_t> getFibonacciArray(size_t N) {
 9 |     vector<uint64_t> fib(N + 2, 0);
10 |     fib[1] = 1;
11 |     for (size_t i = 2; i <= N + 1; i++)
12 |         fib[i] = fib[i - 1] + fib[i - 2];
13 |     return fib;
14 | }
15 | 
16 | vector<int> getFibonacciArrayMax(int MaxNum) {
17 |     if (MaxNum == 0)
18 |         return vector<int>(1, 0);
19 |     vector<int> fib(2, 0);
20 |     fib[1] = 1;
21 |     for (int i = 2; fib[fib.size()-1] + fib[fib.size() - 2] <= MaxNum; i++)
22 |         fib.push_back(fib[i - 1] + fib[i - 2]);
23 |     return fib;
24 | }


--------------------------------------------------------------------------------
/00-prewritten_algorithms/gcd.cpp:
--------------------------------------------------------------------------------
 1 | // call it with gcd(a, b, 1) to calculate gcd(a,b)
 2 | 
 3 | int gcd(int a, int b, int res) {
 4 |     if (a == b)
 5 |         return res * a;
 6 |     else if ((a % 2 == 0) and (b % 2 == 0))
 7 |         return gcd(a / 2, b / 2, 2 * res);
 8 |     else if (a % 2 == 0)
 9 |         return gcd(a / 2, b, res);
10 |     else if (b % 2 == 0)
11 |         return gcd(a, b / 2, res);
12 |     else if (a > b)
13 |         return gcd(a - b, b, res);
14 |     else
15 |         return gcd(a, b - a, res);
16 | }
17 | 
18 | int gcd(int a, int b) {
19 |     return gcd(a, b, 1);
20 | }
21 | 
22 | int gcdByDivision(int A, int B) {
23 |     if (A % B == 0)
24 |         return B;
25 |     else
26 |         return gcdByDivision(B, A % B);
27 | }
28 | 


--------------------------------------------------------------------------------
/00-prewritten_algorithms/getLeader.cpp:
--------------------------------------------------------------------------------
 1 | #include <utility>
 2 | // #define debug
 3 | 
 4 | #ifdef debug
 5 |     #define LOG(X) cout << X << endl
 6 | #else
 7 |     #define LOG(X) (void)0
 8 | #endif
 9 | 
10 | pair<int,int> getLeader(vector<int> &A) {
11 |     int candidate = -1;
12 |     int size = 0;
13 |     
14 |     for(size_t i=0; i<A.size(); i++) {
15 |         if(size == 0) {
16 |             size++;
17 |             candidate = A[i];
18 |         } else {
19 |             if(candidate == A[i])
20 |                 size++;
21 |             else
22 |                 size--;
23 |         }
24 |     }
25 |     
26 |     if(size > 0)
27 |     {
28 |         size_t count = 0;
29 |         for(size_t i=0; i<A.size() ; i++) {
30 |             if(A[i] == candidate) {
31 |                 count++;
32 |             }
33 |         }
34 |         
35 |         if(count > A.size() / 2) {
36 |             LOG("candidate = " << candidate << " count = " << count);
37 |             return make_pair(candidate, count);
38 |         }
39 |     }
40 |     LOG("No candidate");
41 |     return make_pair(-1,0);
42 | }


--------------------------------------------------------------------------------
/00-prewritten_algorithms/log.cpp:
--------------------------------------------------------------------------------
1 | #define debug
2 | 
3 | #ifdef debug
4 |     #define LOG(X) cout << X << endl
5 | #else
6 |     #define LOG(X) (void)0
7 | #endif
8 | 


--------------------------------------------------------------------------------
/00-prewritten_algorithms/make_next_index_array.cpp:
--------------------------------------------------------------------------------
 1 | vector<int> getNext(vector<int>& A) {
 2 |     int n = A.size();
 3 |     vector<int> next(n+1, 0);
 4 |     next[n] = -1;
 5 |     for (int i = n - 1; i >= 0; i--)
 6 |         if (A[i] > 0)
 7 |             next[i] = i;
 8 |         else
 9 |             next[i] = next[i + 1];
10 |     return next;
11 | }
12 | 


--------------------------------------------------------------------------------
/03-TimeComplexity/FrogJmp.cpp:
--------------------------------------------------------------------------------
1 | #include <math.h>
2 | 
3 | int solution(int X, int Y, int D) {
4 |     return ceil((Y - X) / (double)D);
5 | }
6 | 
7 | int solution2(int X, int Y, int D) {
8 |     return (Y - X + D - 1) / D;
9 | }


--------------------------------------------------------------------------------
/03-TimeComplexity/PermMissingElem.cpp:
--------------------------------------------------------------------------------
 1 | int solution(vector<int> &A) {
 2 |     vector<int> B(A.size()+1, 0);
 3 |     
 4 |     for(size_t i = 0; i < A.size(); i++)
 5 |         B[A[i]-1] = 1;
 6 |     
 7 |     for(size_t i=0; i < B.size(); i++)
 8 |         if(B[i] == 0)
 9 |             return i+1;
10 |         
11 |     return 0;
12 | }
13 | 


--------------------------------------------------------------------------------
/03-TimeComplexity/TapeEquilibrium.cpp:
--------------------------------------------------------------------------------
 1 | #include <numeric>
 2 | #include <math.h>
 3 | #include <limits.h>
 4 | 
 5 | int solution(vector<int> &A) {
 6 |     int sum_r = std::accumulate(A.begin(), A.end(), 0);
 7 |     int min = INT_MAX;
 8 |     int sum_l = 0;
 9 |     for(size_t p=1; p<A.size(); p++)
10 |     {
11 |         sum_l += A[p-1];
12 |         sum_r -= A[p-1];
13 |         int dif = (int)abs(sum_l - sum_r);
14 |         if(dif < min)
15 |             min = dif;
16 |     }
17 |     return min;
18 | }
19 | 


--------------------------------------------------------------------------------
/04-CountingElements/FrogRiverOne.cpp:
--------------------------------------------------------------------------------
 1 | 
 2 | int solution(int X, vector<int> &A) {
 3 |     vector<int> B(X+1,0);
 4 |     for(size_t i=0; i<A.size(); i++)
 5 |     {
 6 |         if(B[A[i]] == 0) {
 7 |             X--;
 8 |             if(X == 0)
 9 |                 return i;
10 |         }
11 |         B[A[i]] += 1;
12 |     }
13 |     return -1;
14 | }


--------------------------------------------------------------------------------
/04-CountingElements/MaxCounters.cpp:
--------------------------------------------------------------------------------
 1 | vector<int> solution(int N, vector<int> &A) {
 2 | 
 3 |     vector<int> c(N, 0);
 4 |     
 5 |     int max_c_val = 0;
 6 |     int max_current_c = 0;
 7 |     for(size_t i=0; i<A.size(); i++)
 8 |     {
 9 |         if(A[i] <= N) {
10 |             c[A[i]-1] = max(max_current_c, c[A[i]-1]) + 1;
11 |             if(c[A[i]-1] > max_c_val)
12 |                 max_c_val = c[A[i]-1];
13 |         }
14 |         else {
15 |             max_current_c = max_c_val;
16 |         }
17 |     
18 |     }
19 |     
20 |     for(int j=0; j<N; j++)
21 |         c[j] = max(max_current_c, c[j]);
22 |     return c;
23 | }
24 | 


--------------------------------------------------------------------------------
/04-CountingElements/MissingInteger.cpp:
--------------------------------------------------------------------------------
 1 | int solution(vector<int> &A) {
 2 | 
 3 |     vector<bool> c(1'000'000 + 1, false);
 4 |     for(int i : A) {
 5 |         if(i>0)
 6 |             c[i] = true;
 7 |     }
 8 |     for(int i=1; i<=1'000'000; i++)
 9 |         if(c[i] == false)
10 |             return i;
11 |     return 1;
12 | }
13 | 


--------------------------------------------------------------------------------
/04-CountingElements/PermCheck.cpp:
--------------------------------------------------------------------------------
 1 | int solution(vector<int> &A) {
 2 | 
 3 |     int N = A.size();
 4 |     vector<int> B(N+1, 0);
 5 |     
 6 |     for(int i=0; i<N; i++)
 7 |     {
 8 |         if(A[i] <= N)
 9 |             B[A[i]] += 1;
10 |     }
11 |     
12 |     for(size_t j=1; j<B.size(); j++) {
13 |         // cout << "B[" << j << "]=" << B[j] << endl;
14 |         if(B[j] != 1)
15 |             return 0;
16 |     }
17 |     return 1;
18 | }
19 | 


--------------------------------------------------------------------------------
/05-PrefixSums/CountDiv.cpp:
--------------------------------------------------------------------------------
 1 | 
 2 | int solution(int A, int B, int K) {
 3 |     if(A == B)
 4 |         return A % K == 0 ? 1 : 0;
 5 |         
 6 |     int b = B / K;
 7 |     int a = 0;
 8 |     
 9 | 	if(A > 0)
10 |         a = (A - 1) / K;
11 |     else
12 |         b++;
13 | 
14 |     return b - a;
15 | }
16 | 
17 | 


--------------------------------------------------------------------------------
/05-PrefixSums/GenomicRangeQuery.cpp:
--------------------------------------------------------------------------------
 1 | //result: https://app.codility.com/demo/results/trainingNVUJ8Y-WWA/
 2 | 
 3 | vector<int> solution(string &S, vector<int> &P, vector<int> &Q) {
 4 |     vector<int> res;
 5 |     int N = S.size();
 6 |     vector<int> A(N + 1, 0);
 7 |     vector<int> C(N + 1, 0);
 8 |     vector<int> G(N + 1, 0);
 9 |     vector<int> T(N + 1, 0);
10 | 
11 |     for (int i = 0; i < N; i++) {
12 |         A[i + 1] = A[i] + (S[i] == 'A' ? 1 : 0);
13 |         C[i + 1] = C[i] + (S[i] == 'C' ? 1 : 0);
14 |         G[i + 1] = G[i] + (S[i] == 'G' ? 1 : 0);
15 |         T[i + 1] = T[i] + (S[i] == 'T' ? 1 : 0);
16 |     }
17 |     for (size_t i = 0; i < P.size(); i++) {
18 |         if (A[Q[i]+1]-A[P[i]] > 0)
19 |             res.push_back(1);
20 |         else if (C[Q[i] + 1] - C[P[i]] > 0)
21 |             res.push_back(2);
22 |         else if (G[Q[i] + 1] - G[P[i]] > 0)
23 |             res.push_back(3);
24 |         else if (T[Q[i] + 1] - T[P[i]] > 0)
25 |             res.push_back(4);
26 |     }
27 |     return res;
28 | }
29 | 


--------------------------------------------------------------------------------
/05-PrefixSums/MinAvgTwoSlice.cpp:
--------------------------------------------------------------------------------
 1 | // #define debug
 2 | 
 3 | #ifdef debug
 4 |     #define LOG(X) cout << X << endl
 5 | #else
 6 |     #define LOG(X) (void)0
 7 | #endif
 8 | 
 9 | int solution(vector<int> &A) {
10 |     vector<int> pre_sum(A.size() + 1, 0);
11 | 
12 |     for(size_t i=1; i<=A.size(); i++)
13 |         pre_sum[i] = (pre_sum[i-1] + A[i-1]);
14 |     
15 |     double min_av = 20000;
16 |     int min_ix = -1;
17 |     for(size_t i=1; i<A.size(); i++)
18 |     {
19 |         double avg = (pre_sum[i+1] - pre_sum[i-1]) / 2.0d;
20 |         if(avg < min_av)
21 |         {
22 |             min_ix = i-1;
23 |             min_av = avg;
24 |             LOG("min_av=" << min_av << ", min-ix=" << min_ix << " i=" << i);
25 |         }
26 |         if(i+2 < pre_sum.size()) {
27 |             avg = (pre_sum[i+2] - pre_sum[i-1]) / 3.0d;
28 |             if(avg < min_av)
29 |             {
30 |                 min_ix = i-1;
31 |                 min_av = avg;
32 |                 LOG("min_av=" << min_av << ", min-ix=" << min_ix << " i=" << i);
33 |             }   
34 |         }
35 |     }
36 | 
37 |     return min_ix;
38 | }
39 | /*
40 |     // O(N**2) solution for test purpose
41 |     vector<int> pre_sum(A.size() + 1, 0);
42 | 
43 |     for(size_t i=1; i<=A.size(); i++)
44 |         pre_sum[i] = (pre_sum[i-1] + A[i-1]);
45 |     
46 |     double min_av = 20000;
47 |     int min_ix = -1;
48 |     for(size_t i=1; i<A.size(); i++)
49 |     {
50 |         for(size_t j=i+1; j<=A.size(); j++)
51 |         {
52 |             float avg = (pre_sum[j] - pre_sum[i-1]) / (j-i+1);
53 |             if(avg < min_av)
54 |             {
55 |                 LOG("pre_sum[" << j << "]=" << pre_sum[j] << " pre_sum[" << i-1 << "]=" << pre_sum[i-1]);
56 |                 min_av = avg;
57 |                 min_ix = i-1;
58 |                 LOG("min_av=" << min_av << ", min-ix=" << min_ix << " i=" << i << " j="<< j);
59 |             }
60 |         }
61 |     }*/


--------------------------------------------------------------------------------
/05-PrefixSums/PassingCars.cpp:
--------------------------------------------------------------------------------
 1 | // #define debug
 2 | 
 3 | #ifdef debug
 4 |     #define LOG(X) cout << X << endl
 5 | #else
 6 |     #define LOG(X) (void)0
 7 | #endif
 8 | 
 9 | int solution1(vector<int> &A) {
10 |     if(A.size() == 1)
11 |         return 0;
12 |         
13 |     if(A.size() == 2) {
14 |         if(A[0] == 0 && A[1] == 1)
15 |             return 1;
16 |         else
17 |             return 0;
18 |     }
19 |     vector<int> suffix_sum(A.size()+1, 0);
20 |     
21 |     int one_counts = 0;
22 |     for(int i=suffix_sum.size()-2; i>=0; i--)
23 |     {
24 |         if(A[i] == 1)
25 |             one_counts++;
26 |             
27 |         suffix_sum[i] =  suffix_sum[i+1] + ((A[i] == 0) ? one_counts : 0);
28 |         
29 |         if(suffix_sum[i] > 1'000'000'000)
30 |             return -1;
31 |             
32 |         LOG("suffix_sum[" << i << "]=" << suffix_sum[i]);
33 |     }
34 |     return suffix_sum[0];
35 |     
36 | }
37 | 
38 | int solution2(vector<int> &A) {
39 |     size_t v_size = A.size();
40 |     size_t pairs_passed_by = 0;
41 |     size_t zeroes = 0;
42 |     for(size_t i = 0; i < v_size; ++i) {
43 |         if(0 == A[i]) {
44 |             ++zeroes;
45 |         }
46 |         else if(1 == A[i]) {
47 |             pairs_passed_by += zeroes;
48 |             if(pairs_passed_by > 1'000'000'000) {
49 |                 return -1;
50 |             }
51 |         }
52 |     }
53 |     return pairs_passed_by;
54 | }


--------------------------------------------------------------------------------
/06-Sorting/Distinct.cpp:
--------------------------------------------------------------------------------
 1 | int solution1(vector<int> &A) {
 2 |     vector<bool> count(2000001, 0);
 3 |     for(size_t i=0; i<A.size(); i++)
 4 |         count[A[i] + 1000000] = true;
 5 |     
 6 |     int dis = 0;
 7 |     for(size_t i=0; i<count.size(); i++)
 8 |         if(count[i])
 9 |             dis++;
10 |             
11 |     return dis;
12 | }
13 | 
14 | #include <unordered_set.h>
15 | 
16 | int solution2(vector<int> &v) {
17 |     return std::unordered_set<int>(v.begin(), v.end()).size();
18 | }
19 | 


--------------------------------------------------------------------------------
/06-Sorting/MaxProductOfThree.cpp:
--------------------------------------------------------------------------------
 1 | // Source: https://molchevskyi.medium.com/best-solutions-for-codility-lessons-lesson-6-sorting-770f931b65ad
 2 | 
 3 | int solution(vector<int> &v) {
 4 | 
 5 |     vector<int> max_num(3,-1000);
 6 |     vector<int> min_neg(2,0);    
 7 | 	const int v_size = v.size();    
 8 | 	for (auto i = 0; i < v_size; ++i) {
 9 |         if (v[i] < min_neg[0] ) {
10 |             min_neg[1]=min_neg[0];
11 |             min_neg[0]=v[i];
12 |         }
13 |         else if (v[i] < min_neg[1]) {
14 |             min_neg[1]=v[i];
15 |         }
16 |         if (v[i] > max_num[0]) {
17 |             max_num[2]=max_num[1];
18 |             max_num[1]=max_num[0];
19 |             max_num[0]=v[i];
20 |         }
21 |         else if (v[i] > max_num[1]) {
22 |             max_num[2]=max_num[1];
23 |             max_num[1]=v[i];
24 |         }
25 |         else if (v[i] > max_num[2]) {
26 |             max_num[2]=v[i];
27 |         }
28 |     }  
29 | 	
30 | 	auto res_neg = max_num[0] * min_neg[0] * min_neg[1];
31 |     auto res_pos = max_num[0] * max_num[1] * max_num[2];
32 |     return max (res_pos, res_neg);
33 | }
34 | 


--------------------------------------------------------------------------------
/06-Sorting/NumberofDiscIntersections.cpp:
--------------------------------------------------------------------------------
 1 | #include <algorithm>
 2 | // Source: https://molchevskyi.medium.com/best-solutions-for-codility-lessons-lesson-6-sorting-770f931b65ad
 3 | 
 4 | int solution(vector<int> &v) {
 5 |     const auto MAX_INTERSECTIONS = 10000000;
 6 |     size_t v_size = v.size();
 7 | 
 8 |     vector<int> start(v_size, 0), end(v_size, 0);
 9 | 
10 |     // Assume circles as segments on the coordinate axis.
11 |     // Count all start and end points of the segments intersects on each point of the axis
12 |     for (size_t i = 0; i < v_size; ++i) {
13 |         // If radius of the circle is bigger than distance to the origin 
14 |         // of the coordinate axis or
15 |         // the radius is bigger than length of the given array
16 |         // add this segment to the first point or to the last point.
17 |         // We do this to avoid of scanning from MIN_INT to MAX_INT
18 |         // because the task defines the range started from 0 to end of the given array.
19 |         // We don't need to work outside of this range        
20 |         start[max(0, static_cast<int>(i) - v[i])]++;
21 |         end[min(v_size - 1, i + v[i])]++;
22 |     }
23 | 
24 |      // Number of "active" segments that is segments which intersect at the point i
25 |     int active = 0;
26 |      // Total number of intersections.
27 |     int intersections = 0;
28 |     for (size_t i = 0; i < v_size; i++) {
29 | /*
30 |  Walk by the array and count the segments which contain the current point “i” on the axis.
31 |  Whenever a new segment starts at location “i”, it intersects with all existing segment (disks) at that location.
32 |  That's why we have “active * start[i]” part in the formula. We also need to add the number of intersections for all
33 |  the segments that just started at location “i”, i.e., the number of intersections within themselves excluding whatever
34 |  already existed “(start[i] * (start[i] - 1)) / 2”.  For example if started 5 segments (disks) in one point,
35 |  it will increased by (1+2+3+4+5 intersections, or 5*(5-1) / 2.
36 |  */
37 |         intersections += active * start[i] + (start[i] * (start[i] - 1)) / 2;
38 |         if (intersections > MAX_INTERSECTIONS) {
39 |             return -1;
40 |         }
41 |         active += start[i] - end[i];
42 |     }
43 |     return intersections;
44 | }
45 | 


--------------------------------------------------------------------------------
/06-Sorting/Triangle.cpp:
--------------------------------------------------------------------------------
 1 | // Reference: https://molchevskyi.medium.com/best-solutions-for-codility-lessons-lesson-6-sorting-770f931b65ad
 2 | 
 3 | #include <algorithm>
 4 | 
 5 | int solution(vector<int> &v) {
 6 | 
 7 |     const int v_size = v.size();
 8 |     if(v_size < 3)
 9 | 		return 0;   
10 | 	std::sort(v.begin(), v.end());
11 |     for (auto i = 2; i < v_size; ++i) {
12 |         if (v[i - 2] > v[i] - v[i - 1]) {
13 |             return 1;
14 |         }
15 |     }
16 |     return 0;
17 | }
18 | 


--------------------------------------------------------------------------------
/07-StacksAndQueues/Brackets.cpp:
--------------------------------------------------------------------------------
 1 | #include <stack>
 2 | 
 3 | int solution(string &S) {
 4 |     if(S.empty())
 5 |         return 1;
 6 |         
 7 |     if(S.size() % 2)
 8 |         return 0;
 9 |         
10 |     stack<char> st;
11 |     for(char c : S)
12 |     {
13 |         switch(c)
14 |         {
15 |             case '}':
16 |                 if(st.empty() || st.top() != '{')
17 |                     return 0;
18 |                 st.pop();
19 |                 break;
20 |             case ']':
21 |                 if(st.empty() || st.top() != '[')
22 |                     return 0;
23 |                 st.pop();
24 |                 break;
25 |             case ')':
26 |                 if(st.empty() || st.top() != '(')
27 |                     return 0;
28 |                 st.pop();
29 |                 break;
30 |             default:
31 |                 st.push(c);
32 |         }
33 |     }
34 |     return st.empty() ? 1 : 0;
35 | }
36 | 


--------------------------------------------------------------------------------
/07-StacksAndQueues/Fish.cpp:
--------------------------------------------------------------------------------
 1 | #include <stack>
 2 | 
 3 | int solution(vector<int> &A, vector<int> &B) {
 4 | 
 5 |     if(A.size() == 1)
 6 |         return 1;
 7 |     int alive = A.size();
 8 |     
 9 |     stack<int> F;
10 |     
11 |     for(size_t i = 0; i<A.size(); i++) {
12 |         if(B[i] == 1) {
13 |             F.push(i);
14 |         }
15 |         else if(B[i] == 0 && !F.empty()) {
16 |             while(!F.empty() && A[F.top()] < A[i]) {
17 |                 F.pop();
18 |                 alive--;
19 |             }
20 |             
21 |             if(!F.empty() && A[F.top()] > A[i])
22 |                 alive--;
23 |         }
24 |     }
25 |     
26 |     return alive;
27 | }
28 | 


--------------------------------------------------------------------------------
/07-StacksAndQueues/Nesting.cpp:
--------------------------------------------------------------------------------
 1 | int solution(string &S) {
 2 | 
 3 |     if(S.empty())
 4 |         return 1;
 5 |     if(S.size() % 2)
 6 |         return 0;
 7 |         
 8 |     int open = 0;
 9 |     for(auto c : S) {
10 |         if(c == '(') {
11 |             open++;
12 |         } else {
13 |             if(open > 0)
14 |                 open--;
15 |             else
16 |                 return 0;
17 |         }
18 |     }
19 |     
20 |     return open==0;
21 | }


--------------------------------------------------------------------------------
/07-StacksAndQueues/StoneWall.cpp:
--------------------------------------------------------------------------------
 1 | #include <stack>
 2 | 
 3 | // #define debug
 4 | 
 5 | #ifdef debug
 6 |     #define LOG(X) cout << X << endl
 7 | #else
 8 |     #define LOG(X) (void)0
 9 | #endif
10 | 
11 | int solution(vector<int> &H) {
12 |     if(H.size() == 1)
13 |         return 1;
14 |     
15 |     int count = 0;
16 |     stack<int> W;
17 |     int current_h = 0;
18 |     
19 |     for(auto h : H) {
20 |         if(W.empty()) {
21 |             W.push(h);
22 |             current_h = h;
23 |             LOG(current_h);
24 |             count++;
25 |         } else if(current_h == h) {
26 |             continue;
27 |         } else if(current_h < h) {
28 |             LOG(h - current_h);
29 |             W.push(h - current_h);
30 |             current_h = h;
31 |             count++;
32 |         } else {
33 |             while(!W.empty() && current_h > h) {
34 |                 current_h -= W.top();
35 |                 W.pop();
36 |             }
37 |             if(!W.empty() && current_h < h) {
38 |                 LOG(h - current_h);
39 |                 W.push(h - current_h);
40 |                 current_h = h;
41 |                 count++;
42 |             }
43 |             if(W.empty()) {
44 |                 W.push(h);
45 |                 current_h = h;
46 |                 LOG(current_h);
47 |                 count++;
48 |             }
49 |         }
50 |     }
51 |     return count;
52 | }
53 | 
54 | // ref: https://molchevskyi.medium.com/best-solutions-for-codility-lessons-lesson-7-stacks-and-queues-ef1415898cb
55 | int solution2(const vector<int> &v) {
56 |     std::stack<int> stack;
57 |     int stones = 0;
58 | 	for (auto height : v) {
59 |         while (!stack.empty() && stack.top() > height) {
60 |             stack.pop();
61 |         }
62 |         if (!stack.empty() && stack.top() == height) {
63 |             continue;
64 |         }
65 |         stones++;
66 |         stack.push(height);
67 |     }
68 |     return stones;
69 | }
70 | 


--------------------------------------------------------------------------------
/08-Leader/Dominator.cpp:
--------------------------------------------------------------------------------
 1 | // #define debug
 2 | 
 3 | #ifdef debug
 4 |     #define LOG(X) cout << X << endl
 5 | #else
 6 |     #define LOG(X) (void)0
 7 | #endif
 8 | 
 9 | int solution(vector<int> &A) {
10 |     // write your code in C++14 (g++ 6.2.0)
11 |     int candidate = -1;
12 |     int size = 0;
13 |     
14 |     for(auto a : A) {
15 |         if(size == 0) {
16 |             size++;
17 |             candidate = a;
18 |         } else {
19 |             if(candidate == a)
20 |                 size++;
21 |             else
22 |                 size--;
23 |         }
24 |     }
25 |     LOG("Size = " << size);
26 |     LOG("candidate = " << candidate);
27 |     if(size > 0)
28 |     {
29 |         int index = -1;
30 |         size_t count = 0;
31 |         for(size_t i=0; i<A.size() ; i++) {
32 |             if(A[i] == candidate) {
33 |                 count++;
34 |                 if(index == -1)
35 |                     index = i;
36 |             }
37 |         }
38 |         
39 |         if(count > A.size() / 2)
40 |             return index;
41 |     }
42 |     return -1;
43 | }
44 | 


--------------------------------------------------------------------------------
/08-Leader/EquiLeader.cpp:
--------------------------------------------------------------------------------
 1 | #include <stack>
 2 | #include <utility>
 3 | // #define debug
 4 | 
 5 | #ifdef debug
 6 |     #define LOG(X) cout << X << endl
 7 | #else
 8 |     #define LOG(X) (void)0
 9 | #endif
10 | 
11 | 
12 | pair<int,int> getLeader(vector<int> &A) {
13 |     int candidate = -1;
14 |     int size = 0;
15 |     
16 |     for(size_t i=0; i<A.size(); i++) {
17 |         if(size == 0) {
18 |             size++;
19 |             candidate = A[i];
20 |         } else {
21 |             if(candidate == A[i])
22 |                 size++;
23 |             else
24 |                 size--;
25 |         }
26 |     }
27 |     
28 |     if(size > 0)
29 |     {
30 |         size_t count = 0;
31 |         for(size_t i=0; i<A.size() ; i++) {
32 |             if(A[i] == candidate) {
33 |                 count++;
34 |             }
35 |         }
36 |         
37 |         if(count > A.size() / 2) {
38 |             LOG("candidate = " << candidate << " count = " << count);
39 |             return make_pair(candidate, count);
40 |         }
41 |     }
42 |     LOG("No candidate");
43 |     return make_pair(-1,0);
44 | }
45 | 
46 | 
47 | int solution(vector<int> &A) {
48 |     if(A.size() == 1)
49 |         return 0;
50 |     
51 |     int equi_count = 0;
52 |     pair<int,int> leader = getLeader(A);
53 |     if(leader == make_pair(-1, 0))
54 |         return 0;
55 |         
56 |     size_t leader_count_left = 0;
57 |     size_t leader_count_right = leader.second;
58 |     
59 |     for(size_t i=0; i<A.size(); i++)
60 |     {
61 |         if(A[i] == leader.first) {
62 |             leader_count_left++;
63 |             leader_count_right--;
64 |             LOG("leader_count_left=" << leader_count_left << "\tleader_count_right=" << leader_count_right);
65 |         }
66 |         
67 |         if(leader_count_left > (i+1)/2 &&
68 |             leader_count_right > (A.size()-i-1)/2)
69 |             equi_count++;
70 |     }
71 |     
72 |     return equi_count;
73 | }
74 | 


--------------------------------------------------------------------------------
/09-MaximumSliceProblem/MaxDoubleSliceSum.cpp:
--------------------------------------------------------------------------------
 1 | int solution(vector<int> &A) {
 2 |     vector<int> sum_pref(A.size(), 0);
 3 |     vector<int> sum_suff(A.size(), 0);
 4 |     if (A.size() == 3)
 5 |         return 0;
 6 | 
 7 |     for (size_t a = 1; a < A.size() - 1; a++) {
 8 |         sum_pref[a] = max(sum_pref[a - 1] + A[a], 0);
 9 |     }
10 | 
11 |     for (size_t a = A.size() - 2; a > 0; a--) {
12 |         sum_suff[a] = max(sum_suff[a + 1] + A[a], 0);
13 |     }
14 | 
15 |     int double_slice = 0;
16 |     for (size_t a = 1; a < A.size() - 1; a++) {
17 |         double_slice = max(double_slice, sum_pref[a - 1] + sum_suff[a + 1]);
18 |     }
19 |     return double_slice;
20 | }


--------------------------------------------------------------------------------
/09-MaximumSliceProblem/MaxProfit.cpp:
--------------------------------------------------------------------------------
 1 | int solution(vector<int> &A) {
 2 |     size_t n = A.size();
 3 |     if (n == 0)
 4 |         return 0;
 5 |     int max_profit = 0;
 6 |     int profit_sum = 0;
 7 |     for (size_t i = 1; i < n; i++) {
 8 |         profit_sum = max(0, profit_sum + A[i] - A[i - 1]);
 9 |         max_profit = max(max_profit, profit_sum);
10 |     }
11 | 
12 |     return max_profit;
13 | }


--------------------------------------------------------------------------------
/09-MaximumSliceProblem/MaxSliceSum.cpp:
--------------------------------------------------------------------------------
 1 | #include <climits>
 2 | 
 3 | int solution(vector<int> &A) {
 4 |     size_t n = A.size();
 5 |     if (n == 0)
 6 |         return 0;
 7 |     int max_sum = INT_MIN;
 8 |     int sum_pre = 0;
 9 | 
10 |     for (size_t i = 1; i <= n; i++) {
11 |         sum_pre = max(sum_pre + A[i-1], A[i-1]);
12 |         max_sum = max(max_sum, sum_pre);
13 |     }
14 | 
15 |     return max_sum;
16 | }
17 | 


--------------------------------------------------------------------------------
/10-PrimeAndCompositeNumbers/CountFactors.cpp:
--------------------------------------------------------------------------------
 1 | int solution(int n) {
 2 |     if (n == 1)
 3 |         return 1;
 4 |     if (n == 2)
 5 |         return 2;
 6 |     int div = 2; // one and itself
 7 |     long long x = 2;
 8 |     for (; x*x < n; x++)
 9 |     {
10 |         if (n % x == 0)
11 |             div += 2;
12 |     }
13 |     if (x * x == n)
14 |         div++;
15 |     return div;
16 | }


--------------------------------------------------------------------------------
/10-PrimeAndCompositeNumbers/Flags.cpp:
--------------------------------------------------------------------------------
 1 | vector<bool> getPeaks(vector<int>& A)
 2 | {
 3 |     int n = A.size();
 4 |     vector<bool> P(A.size(), false);
 5 |     
 6 |     for (int x = 1; x < n - 1; x++)
 7 |         if (A[x] > A[x - 1] && A[x] > A[x + 1])
 8 |             P[x] = true;
 9 | 
10 |     return P;
11 | }
12 | 
13 | vector<int> getNext(vector<int> &A, vector<bool> &peaks) {
14 |     vector<int> next(A.size(), 0);
15 |     next[A.size()-1] = -1;
16 |     for (int i = A.size() - 2; i >= 0; i--) {
17 |         if (peaks[i])
18 |             next[i] = i;
19 |         else
20 |             next[i] = next[i + 1];
21 |     }
22 |     return next;
23 | }
24 | 
25 | int solution(vector<int>& A) {
26 |     if (A.size() < 3) return 0;
27 |     const int N = A.size();
28 |     vector<bool> P = getPeaks(A);
29 |     vector<int> next = getNext(A, P);
30 |     int max_flags = 0;
31 |     for (int d = 1; d * (d-1) <= N; d++)
32 |     {
33 |         int current_flags = 0;
34 |         int pos = 0;
35 |         while (pos < N && current_flags < d) {
36 |             pos = next[pos];
37 |             if (pos == -1)   //end
38 |                 break;
39 |             pos += d;
40 |             current_flags++;
41 |         }
42 |         max_flags = max(max_flags, current_flags);
43 |     }
44 | 
45 |     return max_flags;
46 | }


--------------------------------------------------------------------------------
/10-PrimeAndCompositeNumbers/MinPerimeterRectangle.cpp:
--------------------------------------------------------------------------------
 1 | #include <algorithm>
 2 | #include <climits>
 3 | #include <cmath>
 4 | 
 5 | int solution(int N) {
 6 |     int min_p = INT_MAX;
 7 |     int i = (int)sqrt(N) + 1;
 8 |     while(i >= 1) {
 9 |         if(N % i == 0) {
10 |             min_p = min(min_p, N / i + i);
11 |         }
12 |         i--;
13 |     }
14 |     return 2 * min_p;
15 | }
16 | 


--------------------------------------------------------------------------------
/11-SieveOfEratosthenes/CountNonDivisible.cpp:
--------------------------------------------------------------------------------
 1 | // ref: https://stackoverflow.com/a/21916916/365229
 2 | #include <algorithm>
 3 | 
 4 | vector<int> solution(vector<int> &A) {
 5 |     int N = A.size();
 6 |     vector<int> counts (*std::max_element(A.begin(), A.end()) + 1,0);
 7 | 
 8 |     // Calculate occurences of each number in the array
 9 |     for (int i = 0; i < N; ++i)
10 |         counts[A[i]] += 1;
11 | 
12 | 
13 |     std::vector<int> answer(N,0);
14 | 
15 |     // For each element of the array
16 |     for (int i = 0; i < N; ++i)	{
17 |         // Calulate how many of its divisors are in the array
18 |         int divisors = 0;
19 | 		const int num = A[i];
20 |         for (int j = 1; j * j <= num; ++j)	{
21 |             if (num % j == 0)	{
22 |                 divisors += counts[j];
23 |                 if (num / j != j) {
24 |                     divisors += counts[num / j];
25 | 				}
26 |             }
27 |         }
28 | 
29 |         // Subtract the number of divisors from the number of elements in the array
30 |         answer[i] = N - divisors;
31 |     }
32 | 
33 |     return answer;
34 | }


--------------------------------------------------------------------------------
/11-SieveOfEratosthenes/CountSemiprimes.cpp:
--------------------------------------------------------------------------------
 1 | 
 2 | vector<int> getFactArr(int n) {
 3 |     vector<int> f(n+1, 0);
 4 |     f[1] = 1;
 5 |     int i = 2;
 6 |     while (i * i <= n) {
 7 |         if (f[i] == 0) {
 8 |             int k = i * i;
 9 |             while (k <= n) {
10 |                 if (f[k] == 0)
11 |                     f[k] = i;
12 |                 k+=i;
13 |             }
14 |         }
15 |         i++;
16 |     }
17 | 
18 |     return f;
19 | }
20 | 
21 | vector<int> solution(int N, vector<int> &P, vector<int> &Q) {
22 |     vector<int> F = getFactArr(N);
23 |     vector<int> prefix_semi_primes(N + 1, 0);
24 | 
25 |     for (int x = 1; x <= N; x++) {
26 |         if (F[x] > 0 && F[x / F[x]] == 0)
27 |             prefix_semi_primes[x]++;
28 |         prefix_semi_primes[x] += prefix_semi_primes[x - 1];
29 |     }
30 | 
31 |     const int M = P.size();
32 |     vector<int> ans(M, 0);
33 |     for (int i = 0; i < M; i++) {
34 |         ans[i] = prefix_semi_primes[Q[i]] - prefix_semi_primes[P[i] - 1];
35 |     }
36 | 
37 |     return ans;
38 | }
39 | 


--------------------------------------------------------------------------------
/12-EuclideanAlgorithm/ChocolatesByNumbers.cpp:
--------------------------------------------------------------------------------
 1 | int gcdByDivision(int A, int B) {
 2 |     if (A % B == 0)
 3 |         return B;
 4 |     else
 5 |         return gcdByDivision(B, A % B);
 6 | }
 7 | 
 8 | int solution(int N, int M) {
 9 |     return N / gcdByDivision(N, M);
10 | }
11 | 


--------------------------------------------------------------------------------
/12-EuclideanAlgorithm/CommonPrimeDivisors.cpp:
--------------------------------------------------------------------------------
 1 | // ref https://github.com/ZRonchy/Codility/blob/master/Lesson10/CommonPrimeDivisors.java
 2 | 
 3 | int gcd(int a, int b, int res) {
 4 |     if (a == b)
 5 |         return res * a;
 6 |     else if ((a % 2 == 0) and (b % 2 == 0))
 7 |         return gcd(a / 2, b / 2, 2 * res);
 8 |     else if (a % 2 == 0)
 9 |         return gcd(a / 2, b, res);
10 |     else if (b % 2 == 0)
11 |         return gcd(a, b / 2, res);
12 |     else if (a > b)
13 |         return gcd(a - b, b, res);
14 |     else
15 |         return gcd(a, b - a, res);
16 | }
17 | 
18 | int gcd(int a, int b) {
19 |     return gcd(a, b, 1);
20 | }
21 | 
22 | bool hasSamePrimeDivisors(int a, int b) {
23 |     int gcdValue = gcd(a, b);
24 |     int gcdA;
25 |     int gcdB;
26 |     while (a != 1) {
27 |         gcdA = gcd(a, gcdValue);
28 |         if (gcdA == 1)
29 |             break;
30 |         a = a / gcdA;
31 |     }
32 |     if (a != 1) {
33 |         return false;
34 |     }
35 |     while (b != 1) {
36 |         gcdB = gcd(b, gcdValue);
37 |         if (gcdB == 1)
38 |             break;
39 |         b = b / gcdB;
40 |     }
41 |     return b == 1;
42 | }
43 | 
44 | int solution(vector<int>& A, vector<int>& B) {
45 |     int count = 0;
46 |     for (size_t i = 0; i < A.size(); i++) {
47 |         if (hasSamePrimeDivisors(A[i], B[i])) {
48 |             count++;
49 |         }
50 |     }
51 |     return count;
52 | }
53 | 


--------------------------------------------------------------------------------
/13-Fibonaccinumbers/FibFrog.cpp:
--------------------------------------------------------------------------------
 1 | vector<int> getFibonacciArrayMax(int MaxNum) {
 2 |     if (MaxNum == 0)
 3 |         return vector<int>(1, 0);
 4 |     vector<int> fib(2, 0);
 5 |     fib[1] = 1;
 6 |     for (int i = 2; fib[fib.size()-1] + fib[fib.size() - 2] <= MaxNum; i++)
 7 |         fib.push_back(fib[i - 1] + fib[i - 2]);
 8 |     return fib;
 9 | }
10 | 
11 | int solution1(vector<int>& A) {
12 |     int N = A.size();
13 |     if (N == 0)
14 |         return 1;
15 |     A.push_back(1);
16 |     N++;
17 |     vector<int> f = getFibonacciArrayMax(N);
18 |     const int oo = 1'000'000;
19 |     vector<int> moves(N, oo);
20 |     
21 |     for (auto i : f)
22 |         if (i - 1 >= 0 && A[i-1])
23 |             moves[i-1] = 1;
24 |     
25 |     for (int pos = 0; pos < N; pos++) {
26 |         if (A[pos] == 0)
27 |             continue;
28 | 
29 |         for (int i = f.size()-1; i >= 0; i--) {
30 |             if (pos + f[i] < N && A[pos + f[i]]) {
31 |                 moves[pos + f[i]] = min(moves[pos]+1, moves[pos + f[i]]);
32 |             }
33 |         }
34 |     }
35 |     if (moves[N - 1] != oo) {
36 |         return moves[N - 1];
37 |     }
38 |     return -1;
39 | }
40 | 
41 | #include <set>
42 | 
43 | int solution2(vector<int>& A) {
44 |     int N = A.size();
45 | 
46 |     vector<int> fib = getFibonacciArrayMax(N);
47 | 
48 |     set<int> positions;
49 |     positions.insert(N);
50 |     for (int jumps = 1; ; jumps++)
51 |     {
52 |         set<int> new_positions;
53 |         for (int pos : positions)
54 |         {
55 |             for (int f : fib)
56 |             {
57 |                 // return jumps if we reach to the start point
58 |                 if (pos - (f - 1) == 0)
59 |                     return jumps;
60 |                 
61 |                 int prev_pos = pos - f;
62 |                 
63 |                 // we do not need to calculate bigger jumps.
64 |                 if (prev_pos < 0)
65 |                     break;
66 |                 
67 |                 if (prev_pos < A.size() && A[prev_pos])
68 |                     new_positions.insert(prev_pos);
69 |             }
70 |         }
71 |         if (new_positions.size() == 0)
72 |             return -1;
73 |         positions = new_positions;
74 |     }
75 | 
76 |     return -1;
77 | }


--------------------------------------------------------------------------------
/13-Fibonaccinumbers/Ladder.cpp:
--------------------------------------------------------------------------------
 1 | #include <algorithm>
 2 | 
 3 | // result: https://app.codility.com/demo/results/training36DCSY-F7Q/
 4 | 
 5 | vector<int> solution(vector<int> &A, vector<int> &B) {
 6 |     size_t maxB = *std::max_element(B.begin(), B.end());
 7 |     size_t maxA = *std::max_element(A.begin(), A.end());
 8 | 	
 9 |     vector<int> L(A.size(), 0);
10 |     vector<size_t> fib(maxA + 2, 0);
11 |     fib[1] = 1;
12 | 	
13 |     for (size_t i = 2; i < maxA + 2; i++)
14 |         fib[i] = (fib[i - 1] + fib[i - 2]) & ((1 << maxB)-1);
15 | 
16 |     for (size_t i = 0; i < A.size(); i++) {
17 |         size_t mask = (1 << B[i]) - 1;
18 |         L[i] = fib[A[i] + 1] & mask;
19 |     }
20 | 
21 |     return L;
22 | }
23 | 


--------------------------------------------------------------------------------
/14-BinarySearchAlgorithm/MinMaxDivision.cpp:
--------------------------------------------------------------------------------
 1 | #include <numeric>
 2 | #include <algorithm>
 3 | 
 4 | // result: https://app.codility.com/demo/results/training4NW8N5-TKB/
 5 | 
 6 | bool check(vector<int>& A, int K_MaxBlockCount, int MidSumCandidate) {
 7 |     int blocks = 1;
 8 |     int sum = 0;
 9 |     for (auto i : A) {
10 |         sum += i;
11 |         if (sum > MidSumCandidate) {
12 |             blocks++;
13 |             sum = i;
14 |         }
15 |         if (blocks > K_MaxBlockCount)
16 |             return false;
17 |     }
18 |     return true;
19 | }
20 | 
21 | // NOTE: do not use M, it is incorrect in some test cases.
22 | //       you need to calculate it yourself
23 | 
24 | int solution(int K_MaxBlockCount, int /*M*/, vector<int> &A) {
25 |     // using binary search to find optimum block counts
26 |     // minimum large sum
27 |     int min_sum = *std::max_element(A.begin(), A.end());
28 |     // maximum large sum
29 |     int max_sum = std::accumulate(A.begin(), A.end(), 0);
30 | 
31 |     if (A.size() == 1)
32 |         return min_sum;
33 |     if (K_MaxBlockCount == 1)
34 |         return max_sum;
35 | 
36 | 	int result = min_sum;
37 | 	
38 |     while (min_sum <= max_sum) {
39 |         int mid_sum_candidate = (min_sum + max_sum) / 2;
40 |         // check if we can make maximum possible blocks (<K) that have maximum large sum up to mid_sum_candidate
41 |         if (check(A, K_MaxBlockCount, mid_sum_candidate)) {    
42 | 			result = mid_sum_candidate;
43 |             max_sum = mid_sum_candidate - 1;
44 |         }
45 |         else {
46 |             min_sum = mid_sum_candidate + 1;
47 |         }
48 |     }
49 |     return result;
50 | }
51 | 


--------------------------------------------------------------------------------
/14-BinarySearchAlgorithm/NailingPlanks.cpp:
--------------------------------------------------------------------------------
 1 | // result: https://app.codility.com/demo/results/trainingQVHXNU-A92/
 2 | 
 3 | bool CheckAllPlanksNailed(vector<int>& A, vector<int>& B, vector<int>& C, int nail_count) {
 4 | 
 5 |     vector<int> presum_nailed_status(2 * C.size() + 1, 0);
 6 | 
 7 |     for (int i = 0; i < nail_count; i++) {
 8 |         presum_nailed_status[C[i]] = 1;
 9 |     }
10 | 
11 |     for (size_t i = 1; i < presum_nailed_status.size(); i++) {
12 |         presum_nailed_status[i] += presum_nailed_status[i - 1];
13 |     }
14 | 
15 |     bool all_nailed = true;
16 |     for (size_t i = 0; i < A.size() && all_nailed; i++) {
17 |         all_nailed = presum_nailed_status[B[i]] - presum_nailed_status[A[i] - 1] > 0;
18 |     }
19 |     return all_nailed;
20 | }
21 | 
22 | int solution(vector<int>& A, vector<int>& B, vector<int>& C) {
23 |     
24 |     int result = -1;
25 | 
26 |     int minNails = 1;
27 |     int maxNails = C.size();
28 | 
29 |     while (minNails <= maxNails) {
30 |         int mid = (maxNails + minNails) / 2;
31 |         if (CheckAllPlanksNailed(A, B, C, mid)) {
32 |             result = mid;
33 |             maxNails = mid - 1;
34 |         }
35 |         else {
36 |             minNails = mid + 1;
37 |         }
38 |     }
39 | 
40 |     return result;
41 | }
42 | 


--------------------------------------------------------------------------------
/15-CaterpillarMethod/AbsDistinct.cpp:
--------------------------------------------------------------------------------
 1 | // Result: https://app.codility.com/demo/results/training37M7VV-A7W/
 2 | 
 3 | #include <cmath>
 4 | #include <climits>
 5 | 
 6 | int solution1(vector<int> &A) {
 7 |     auto begin = A.begin();
 8 |     auto end = A.end()-1;
 9 |     int dist_count = 1;
10 |     int64_t last = INT64_MAX;
11 |     while (begin <= end) {
12 | 	 // using int64_t to avoid arithmatic overflow in test cases!
13 |         int64_t abs_begin = abs(static_cast<int64_t>(*begin));
14 |         int64_t abs_end = abs(static_cast<int64_t>(*end));
15 |         if (abs_begin != abs_end && *begin != last && *end != last) {
16 |             dist_count++;
17 |             if (abs_begin > abs_end) {
18 |                 last = *begin;
19 |                 begin++;
20 |             }
21 |             else {
22 |                 last = *end;
23 |                 end--;
24 |             }
25 |         }
26 |         else {
27 |             if (begin == end)
28 |                 break;
29 |             if (*begin == last || last == INT64_MAX)
30 |                 begin++;
31 |             else if (*end == last)
32 |                 end--;
33 |             else
34 |                 last = INT64_MAX;
35 |         }
36 |     }
37 | 
38 |     return dist_count;
39 | }
40 | 
41 | 
42 | #include <unordered_set>
43 | 
44 | int solution2(vector<int> &A) {
45 |     unordered_set<int64_t> s;
46 |     s.reserve(A.size());
47 |     for(auto i : A)
48 |         s.insert(abs(static_cast<int64_t>(i)));
49 |         
50 |     return s.size();
51 | }
52 | 
53 | 


--------------------------------------------------------------------------------
/15-CaterpillarMethod/CountDistinctSlices.cpp:
--------------------------------------------------------------------------------
 1 | int solution(int M, vector<int> &A) {
 2 |     int count = 0;
 3 |     const int max_count = 1'000'000'000;
 4 |     auto begin = A.begin();
 5 |     auto end = A.begin();
 6 |     vector<bool> visited(M + 1, false);
 7 |     while (end < A.end() && begin < A.end()) {
 8 |         if (visited[*end]) {
 9 |             visited[*begin] = false;
10 |             begin++;
11 |         }
12 |         else {
13 |             //calc count
14 |             count += end - begin + 1;
15 |             visited[*end] = true;
16 |             if (end + 1 < A.end())
17 |                 end++;
18 |             else
19 |                 begin++;
20 |         }
21 |         if (count > max_count)
22 |             return max_count;
23 |     }
24 |     return min(count, max_count);
25 | }
26 | 


--------------------------------------------------------------------------------
/15-CaterpillarMethod/CountTriangles.cpp:
--------------------------------------------------------------------------------
 1 | // result: https://app.codility.com/demo/results/training2XYSK7-EK7/
 2 | 
 3 | #include <algorithm>
 4 | 
 5 | int solution(vector<int> &A) {
 6 |     if (A.size() < 3)
 7 |         return 0;
 8 |     int count = 0;
 9 |     sort(A.begin(), A.end());
10 |     auto P = A.begin();
11 | 
12 |     while (P <= A.end()-3) {
13 |         auto Q = P + 1;
14 |         auto R = Q + 1;
15 |         while (R < A.end()) {
16 |             if (*P + *Q > *R) {
17 |                 count += R - Q;
18 |                 R++;
19 |             }
20 |             else if (Q < R - 1)
21 |                 Q++;
22 |             else
23 |                 R++;
24 |         }
25 |         P++;
26 |     }
27 |     return count;
28 | }
29 | 


--------------------------------------------------------------------------------
/15-CaterpillarMethod/MinAbsSumOfTwo.cpp:
--------------------------------------------------------------------------------
 1 | //result: https://app.codility.com/demo/results/trainingU93EQN-9A2/
 2 | 
 3 | #include <algorithm>
 4 | #include <climits>
 5 | 
 6 | int solution(vector<int> &A) {
 7 |     if (A.size() == 1)
 8 |         return abs(A[0] + A[0]);
 9 | 
10 |     sort(A.begin(), A.end());
11 | 
12 |     int total_min = *min_element(A.begin(), A.end());
13 |     if (total_min >= 0)
14 |         return 2 * A[0];
15 | 
16 |     int minimal_sum = INT_MAX;
17 |     auto P = A.begin();
18 |     auto Q = A.end()-1;
19 |     while (P < Q) {
20 |         minimal_sum = min(minimal_sum, abs(*P + *Q));
21 |         minimal_sum = min(minimal_sum, abs(*P + *P));
22 |         minimal_sum = min(minimal_sum, abs(*Q + *Q));
23 | 
24 |         if (abs(*(P + 1) + *Q) <= abs(*P + *(Q - 1)))
25 |             P++;
26 |         else      
27 |             Q--;
28 |     }
29 |     minimal_sum = min(minimal_sum, abs(*P + *Q));
30 |     return minimal_sum;
31 | }
32 | 


--------------------------------------------------------------------------------
/16-GreedyAlgorithms/MaxNonoverlappingSegments.cpp:
--------------------------------------------------------------------------------
 1 | // result: https://app.codility.com/demo/results/trainingZRX235-MH6/
 2 | 
 3 | int solution(vector<int>& A, vector<int>& B) {
 4 |     if (A.size() == 0)
 5 |         return 0;
 6 |     int count = 1;
 7 |     int prev_end = B[0];
 8 |     for (int i = 1; i < A.size(); i++)
 9 |         if (A[i] > prev_end) {
10 |             count++;
11 |             prev_end = B[i];
12 |         }
13 | 
14 |     return count;
15 | }


--------------------------------------------------------------------------------
/16-GreedyAlgorithms/TieRopes.cpp:
--------------------------------------------------------------------------------
 1 | // result: https://app.codility.com/demo/results/trainingAF5XHH-VBA/
 2 | 
 3 | int solution(vector<int>& A, int K) {
 4 |     int count = 0;
 5 |     int rop_sum = 0;
 6 |     for (int i = 0; i < A.size(); i++)
 7 |     {
 8 |         rop_sum += A[i];
 9 |         if (rop_sum >= K) {
10 |             count++;
11 |             rop_sum = 0;
12 |         }
13 | 
14 |     }
15 |     return count;
16 | }


--------------------------------------------------------------------------------
/17-DynamicProgramming/MinAbsSum.cpp:
--------------------------------------------------------------------------------
 1 | // reference: https://stackoverflow.com/a/44901707/365229
 2 | #include <vector>
 3 | #include <set> 
 4 | 
 5 | int solution1(vector<int> &A) {
 6 |     if (A.size() == 0) return 0;
 7 | 
 8 |     set<int> sums, tmpSums;        
 9 |     sums.insert(abs(A[0]));
10 |     for (auto it = begin(A) + 1; it != end(A); ++it)
11 |     {        
12 |         for (auto s : sums)
13 |         {
14 |             tmpSums.insert(abs(s + abs(*it)));
15 |             tmpSums.insert(abs(s - abs(*it)));            
16 |         }
17 |         sums = tmpSums;
18 |         tmpSums.clear();
19 |     }
20 | 
21 |     return *sums.begin();
22 | }
23 | 
24 | // reference: https://github.com/Behrouz-m/Codility/blob/master/Docs/solutions/solution-min-abs-sum.pdf
25 | // O(N^2.M)
26 | // result=72% : https://app.codility.com/demo/results/trainingQW8QE8-SDF/
27 | int solution2(vector<int>& A) {
28 |     const int N = A.size();
29 |     if (N == 0)
30 |         return 0;
31 | 
32 |     int MaxVal = 0;
33 |     for (int i = 0; i < N; i++) {
34 |         A[i] = abs(A[i]);
35 |         MaxVal = max(MaxVal, A[i]);
36 |     }
37 | 
38 |     const int Sum = std::accumulate(A.begin(), A.end(), 0);
39 |     
40 |     vector<int> dp(Sum + 1, 0);
41 |     dp[0] = 1;
42 |     for (int j = 0; j < N; j++)
43 |         for (int i = Sum; i > -1; i--)
44 |             if (dp[i] == 1 and i + A[j] <= Sum)
45 |                 dp[i + A[j]] = 1;
46 |     int result = Sum;
47 |     for (int i = 0; i < Sum / 2 + 1; i++)
48 |         if (dp[i] == 1)
49 |             result = min(result, Sum - 2 * i);
50 |     return result;
51 | }
52 | 
53 | // O(N.M^2)
54 | // result=100% = https://app.codility.com/demo/results/training226XH9-8VA/
55 | 
56 | int solution_golden(vector<int>& A) {
57 |     const int N = A.size();
58 |     if (N == 0)
59 |         return 0;
60 |    
61 |     int MaxVal = 0;
62 |     for (int i = 0; i < N; i++) {
63 |         A[i] = abs(A[i]);
64 |         MaxVal = max(MaxVal, A[i]);
65 |     }
66 | 
67 |     const int Sum = std::accumulate(A.begin(), A.end(), 0);
68 |     vector<int> count(MaxVal + 1, 0);
69 |     for (int i = 0; i < N; i++)
70 |         count[A[i]]++;
71 | 
72 |     vector<int> dp(Sum + 1, -1);
73 |     dp[0] = 0;
74 |     for (int a = 1; a <= MaxVal; a++) {
75 |         if (count[a]>0) {
76 |             for (int j = 0; j < Sum; j++) {
77 |                 if (dp[j] >= 0)
78 |                     dp[j] = count[a];
79 |                 else if (j >= a && dp[j - a] > 0)
80 |                     dp[j] = dp[j - a] - 1;
81 |             }
82 |         }
83 |     }
84 |     int result = Sum;
85 |     for (int i = 0; i < Sum / 2 + 1; i++) {
86 |         if (dp[i] >= 0)
87 |             result = min(result, Sum - 2 * i);
88 |     }
89 | 
90 |     return result;
91 | }


--------------------------------------------------------------------------------
/17-DynamicProgramming/NumberSolitaire.cpp:
--------------------------------------------------------------------------------
 1 | #include <climits>
 2 | // results (100%):  https://app.codility.com/demo/results/training8JYZDW-UFC/
 3 | 
 4 | int solution(vector<int>& A) {
 5 |     const int N = A.size();
 6 |     if (N == 2)
 7 |         return A[0] + A[1];
 8 | 
 9 |     vector<int> MaxSum(N, INT_MIN);
10 |     MaxSum[0] = A[0];
11 |     for (int i = 1; i < N; i++) {
12 |         for (int dice = 1; dice <= 6; dice++) {
13 |             if (dice > i)
14 |                 break;
15 |             MaxSum[i] = max(MaxSum[i], A[i] + MaxSum[i - dice]);
16 |         }
17 |     }
18 |     return MaxSum[N-1];
19 | }


--------------------------------------------------------------------------------
/90-TasksFromIndeedPrime-2015-Challenge/FloodDepth.cpp:
--------------------------------------------------------------------------------
 1 | // result: https://app.codility.com/demo/results/trainingT77WKP-39N/
 2 | // reference: https://github.com/wtsanshou/Coding/blob/master/Algorithm/Greedy/CodilityFloodDepth.md
 3 | 
 4 | int solution(vector<int> &A) {
 5 |     int n = A.size(), res = 0;
 6 |     vector<int> depths(n);
 7 |     int wall = A[0];
 8 |     for(int i=1; i<n-1; ++i)
 9 |     {
10 |         if(A[i] > wall) wall = A[i];
11 |         else depths[i] = wall - A[i];
12 |     }
13 |     
14 |     wall = A[n-1];
15 |     for(int i= n-2; i>0; --i)
16 |     {
17 |         if(A[i] > wall) 
18 |         {
19 |             wall = A[i];
20 |             depths[i] = 0;
21 |         }
22 |         else depths[i] = min(wall-A[i], depths[i]);
23 |         
24 |         res = max(res, depths[i]);
25 |     }
26 |     return res;
27 | }


--------------------------------------------------------------------------------
/90-TasksFromIndeedPrime-2015-Challenge/LongestPassword.cpp:
--------------------------------------------------------------------------------
 1 | // result: https://app.codility.com/demo/results/trainingG63GWF-RXZ/
 2 | 
 3 | int solution(string &S) {
 4 |     int let = 0;
 5 |     int dig = 0;
 6 |     int max_len = -1;
 7 |     S += ' ';
 8 |     bool valid = true;
 9 |     for (char s : S) {
10 |         if (s >= 'a' && s <= 'z' ||
11 |             s >= 'A' && s <= 'Z')
12 |             let++;
13 |         else if (s >= '0' && s <= '9')
14 |             dig++;
15 |         else if (s == ' ')
16 |         {
17 |             if (let % 2 == 0 and dig % 2 == 1 and valid) {
18 |                 max_len = max(let + dig, max_len);
19 |             }
20 |             let = 0;
21 |             dig = 0;
22 |             valid = true;
23 |         }
24 |         else {
25 |             valid = false;
26 |         }
27 |     }
28 |     return max_len;
29 | }
30 | 


--------------------------------------------------------------------------------
/99-FutureTraining/StrSymmetryPoint.cpp:
--------------------------------------------------------------------------------
 1 | 
 2 | int solution(string &S) {
 3 |     int N = S.size();
 4 |     if(N == 0)
 5 |         return -1;
 6 |     if(N == 1)
 7 |         return 0;
 8 |     if(N%2 == 0)
 9 |         return -1;
10 | 	
11 |     int mid = N / 2;
12 |     for(int i = 1; i <= mid + 1; i++)
13 |         if(S[mid + i] != S[mid - i])
14 |             return -1;
15 |     return mid;
16 | }
17 | 


--------------------------------------------------------------------------------
/99-FutureTraining/TreeHeight.cpp:
--------------------------------------------------------------------------------
 1 | int traverse(tree * t, int h) {
 2 |     if(t->l || t->r)
 3 |         h++;
 4 |     int h_l = h;
 5 |     int h_r = h;
 6 |     if(t->l)
 7 |         h_l = traverse(t->l, h);
 8 |     if(t->r)
 9 |         h_r = traverse(t->r, h);
10 |     return max(h_l, h_r);
11 | }
12 | 
13 | int solution(tree * T) {
14 |     int h = 0;
15 |     if(T)
16 |         h = traverse(T, h);
17 |     return h;
18 | }
19 | 


--------------------------------------------------------------------------------
/Docs/1-Iterations.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Behrouz-m/Codility/c68f8a0cafda812f583b11974d70def8c39618af/Docs/1-Iterations.pdf


--------------------------------------------------------------------------------
/Docs/10-PrimeNumbers.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Behrouz-m/Codility/c68f8a0cafda812f583b11974d70def8c39618af/Docs/10-PrimeNumbers.pdf


--------------------------------------------------------------------------------
/Docs/11-Sieve.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Behrouz-m/Codility/c68f8a0cafda812f583b11974d70def8c39618af/Docs/11-Sieve.pdf


--------------------------------------------------------------------------------
/Docs/12-Gcd.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Behrouz-m/Codility/c68f8a0cafda812f583b11974d70def8c39618af/Docs/12-Gcd.pdf


--------------------------------------------------------------------------------
/Docs/13-Fibonacci.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Behrouz-m/Codility/c68f8a0cafda812f583b11974d70def8c39618af/Docs/13-Fibonacci.pdf


--------------------------------------------------------------------------------
/Docs/14-BinarySearch.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Behrouz-m/Codility/c68f8a0cafda812f583b11974d70def8c39618af/Docs/14-BinarySearch.pdf


--------------------------------------------------------------------------------
/Docs/15-CaterpillarMethod.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Behrouz-m/Codility/c68f8a0cafda812f583b11974d70def8c39618af/Docs/15-CaterpillarMethod.pdf


--------------------------------------------------------------------------------
/Docs/16-GreedyAlgorithms.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Behrouz-m/Codility/c68f8a0cafda812f583b11974d70def8c39618af/Docs/16-GreedyAlgorithms.pdf


--------------------------------------------------------------------------------
/Docs/17-DynamicProgramming.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Behrouz-m/Codility/c68f8a0cafda812f583b11974d70def8c39618af/Docs/17-DynamicProgramming.pdf


--------------------------------------------------------------------------------
/Docs/2-Arrays.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Behrouz-m/Codility/c68f8a0cafda812f583b11974d70def8c39618af/Docs/2-Arrays.pdf


--------------------------------------------------------------------------------
/Docs/3-TimeComplexity.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Behrouz-m/Codility/c68f8a0cafda812f583b11974d70def8c39618af/Docs/3-TimeComplexity.pdf


--------------------------------------------------------------------------------
/Docs/4-CountingElements.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Behrouz-m/Codility/c68f8a0cafda812f583b11974d70def8c39618af/Docs/4-CountingElements.pdf


--------------------------------------------------------------------------------
/Docs/5-PrefixSums.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Behrouz-m/Codility/c68f8a0cafda812f583b11974d70def8c39618af/Docs/5-PrefixSums.pdf


--------------------------------------------------------------------------------
/Docs/6-Sorting.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Behrouz-m/Codility/c68f8a0cafda812f583b11974d70def8c39618af/Docs/6-Sorting.pdf


--------------------------------------------------------------------------------
/Docs/7-Stacks.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Behrouz-m/Codility/c68f8a0cafda812f583b11974d70def8c39618af/Docs/7-Stacks.pdf


--------------------------------------------------------------------------------
/Docs/8-Leader.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Behrouz-m/Codility/c68f8a0cafda812f583b11974d70def8c39618af/Docs/8-Leader.pdf


--------------------------------------------------------------------------------
/Docs/9-MaxSlice.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Behrouz-m/Codility/c68f8a0cafda812f583b11974d70def8c39618af/Docs/9-MaxSlice.pdf


--------------------------------------------------------------------------------
/Docs/solutions/solution-cannonballs.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Behrouz-m/Codility/c68f8a0cafda812f583b11974d70def8c39618af/Docs/solutions/solution-cannonballs.pdf


--------------------------------------------------------------------------------
/Docs/solutions/solution-clocks.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Behrouz-m/Codility/c68f8a0cafda812f583b11974d70def8c39618af/Docs/solutions/solution-clocks.pdf


--------------------------------------------------------------------------------
/Docs/solutions/solution-count-bounded-slices.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Behrouz-m/Codility/c68f8a0cafda812f583b11974d70def8c39618af/Docs/solutions/solution-count-bounded-slices.pdf


--------------------------------------------------------------------------------
/Docs/solutions/solution-double-median.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Behrouz-m/Codility/c68f8a0cafda812f583b11974d70def8c39618af/Docs/solutions/solution-double-median.pdf


--------------------------------------------------------------------------------
/Docs/solutions/solution-flags.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Behrouz-m/Codility/c68f8a0cafda812f583b11974d70def8c39618af/Docs/solutions/solution-flags.pdf


--------------------------------------------------------------------------------
/Docs/solutions/solution-min-abs-sum.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Behrouz-m/Codility/c68f8a0cafda812f583b11974d70def8c39618af/Docs/solutions/solution-min-abs-sum.pdf


--------------------------------------------------------------------------------
/Docs/solutions/solution-prefix-set.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Behrouz-m/Codility/c68f8a0cafda812f583b11974d70def8c39618af/Docs/solutions/solution-prefix-set.pdf


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | Codility answers in C++
 2 | ========
 3 | ## Lesson 3 [Time Complexity](https://app.codility.com/programmers/lessons/3-time_complexity)
 4 | - [TapeEquilibrium](https://github.com/Behrouz-m/Codility/blob/master/03-TimeComplexity/TapeEquilibrium.cpp)
 5 | - [FrogJmp](https://github.com/Behrouz-m/Codility/blob/master/03-TimeComplexity/FrogJmp.cpp)
 6 | - [PermMissingElem](https://github.com/Behrouz-m/Codility/blob/master/03-TimeComplexity/PermMissingElem.cpp)
 7 | 
 8 | ## Lesson 4 [Counting Elements](https://codility.com/programmers/lessons/2)
 9 | - [PermCheck](https://github.com/Behrouz-m/Codility/blob/master/04-CountingElements/PermCheck.cpp)
10 | - [FrogRiverOne](https://github.com/Behrouz-m/Codility/blob/master/04-CountingElements/FrogRiverOne.cpp)
11 | - [MaxCounters](https://github.com/Behrouz-m/Codility/blob/master/04-CountingElements/MaxCounters.cpp)
12 | - [MissingInteger](https://github.com/Behrouz-m/Codility/blob/master/04-CountingElements/MissingInteger.cpp)
13 | 
14 | ## Lesson 5 [Prefix Sums](https://codility.com/programmers/lessons/3)
15 | - [PassingCars](https://github.com/Behrouz-m/Codility/blob/master/05-PrefixSums/PassingCars.cpp)
16 | - [CountDiv](https://github.com/Behrouz-m/Codility/blob/master/05-PrefixSums/CountDiv.cpp)
17 | - [MinAvgTwoSlice](https://github.com/Behrouz-m/Codility/blob/master/05-PrefixSums/MinAvgTwoSlice.cpp)
18 | - [GenomicRangeQuery](https://github.com/Behrouz-m/Codility/blob/master/05-PrefixSums/GenomicRangeQuery.cpp)
19 | 
20 | ## Lesson 6 [Sorting](https://codility.com/programmers/lessons/4)
21 | - [MaxProductOfThree](https://github.com/Behrouz-m/Codility/blob/master/06-Sorting/MaxProductOfThree.cpp)
22 | - [Distinct](https://github.com/Behrouz-m/Codility/blob/master/06-Sorting/Distinct.cpp)
23 | - [Triangle](https://github.com/Behrouz-m/Codility/blob/master/06-Sorting/Triangle.cpp)
24 | - [NumberOfDiscIntersections]<!--(https://github.com/Behrouz-m/Codility/blob/master/06-Sorting/NumberOfDiscIntersections.cpp)-->
25 | 
26 | ## Lesson 7 [Stacks and Queues](https://codility.com/programmers/lessons/5)
27 | - [Brackets](https://github.com/Behrouz-m/Codility/blob/master/07-StacksAndQueues/Brackets.cpp)
28 | - [Nesting](https://github.com/Behrouz-m/Codility/blob/master/07-StacksAndQueues/Nesting.cpp)
29 | - [Fish](https://github.com/Behrouz-m/Codility/blob/master/07-StacksAndQueues/Fish.cpp)
30 | - [StoneWall](https://github.com/Behrouz-m/Codility/blob/master/07-StacksAndQueues/StoneWall.cpp)
31 | 
32 | ## Lesson 8 [Leader](https://codility.com/programmers/lessons/6)
33 | - [EquiLeader](https://github.com/Behrouz-m/Codility/blob/master/08-Leader/EquiLeader.cpp)
34 | - [Dominator](https://github.com/Behrouz-m/Codility/blob/master/08-Leader/Dominator.cpp)
35 | 
36 | ## Lesson 9 [Maximum slice problem](https://codility.com/programmers/lessons/7)
37 | - [MaxProfit](https://github.com/Behrouz-m/Codility/blob/master/09-MaximumSliceProblem/MaxProfit.cpp)
38 | - [MaxSliceSum](https://github.com/Behrouz-m/Codility/blob/master/09-MaximumSliceProblem/MaxSliceSum.cpp)
39 | - [MaxDoubleSliceSum](https://github.com/Behrouz-m/Codility/blob/master/09-MaximumSliceProblem/MaxDoubleSliceSum.cpp)
40 | 
41 | ## Lesson 10 [Prime and composite numbers](https://codility.com/programmers/lessons/8)
42 | - [MinPerimeterRectangle](https://github.com/Behrouz-m/Codility/blob/master/10-PrimeAndCompositeNumbers/MinPerimeterRectangle.cpp)
43 | - [CountFactors](https://github.com/Behrouz-m/Codility/blob/master/10-PrimeAndCompositeNumbers/CountFactors.cpp)
44 | - [Flags](https://github.com/Behrouz-m/Codility/blob/master/10-PrimeAndCompositeNumbers/Flags.cpp)
45 | - [Peaks]
46 | <!--
47 | - [Peaks](https://github.com/Behrouz-m/Codility/blob/master/10-PrimeAndCompositeNumbers/Peaks.cpp)
48 | -->
49 | 
50 | ## Lesson 11 [Sieve of Eratosthenes](https://codility.com/programmers/lessons/9)
51 | - [CountNonDivisible](https://github.com/Behrouz-m/Codility/blob/master/11-SieveOfEratosthenes/CountNonDivisible.cpp)
52 | - [CountSemiprimes](https://github.com/Behrouz-m/Codility/blob/master/11-SieveOfEratosthenes/CountSemiprimes.cpp)
53 | 
54 | 
55 | ## Lesson 12 [Euclidean algorithm](https://codility.com/programmers/lessons/10)
56 | - [ChocolatesByNumbers](https://github.com/Behrouz-m/Codility/blob/master/12-EuclideanAlgorithm/ChocolatesByNumbers.cpp)
57 | - [CommonPrimeDivisors](https://github.com/Behrouz-m/Codility/blob/master/12-EuclideanAlgorithm/CommonPrimeDivisors.cpp)
58 | 
59 | ## Lesson 13 [Fibonacci numbers](https://codility.com/programmers/lessons/11)
60 | - [FibFrog](https://github.com/Behrouz-m/Codility/blob/master/13-Fibonaccinumbers/FibFrog.cpp)
61 | - [Ladder](https://github.com/Behrouz-m/Codility/blob/master/13-Fibonaccinumbers/Ladder.cpp)
62 | 
63 | ## Lesson 14 [Binary search algorithm](https://codility.com/programmers/lessons/12)
64 | - [MinMaxDivision](https://github.com/Behrouz-m/Codility/blob/master/14-BinarySearchAlgorithm/MinMaxDivision.cpp)
65 | - [NailingPlanks](https://github.com/Behrouz-m/Codility/blob/master/14-BinarySearchAlgorithm/NailingPlanks.cpp)
66 | 
67 | ## Lesson 15 [Caterpillar method](https://codility.com/programmers/lessons/13)
68 | - [AbsDistinct](https://github.com/Behrouz-m/Codility/blob/master/15-CaterpillarMethod/AbsDistinct.cpp)
69 | - [CountDistinctSlices](https://github.com/Behrouz-m/Codility/blob/master/15-CaterpillarMethod/CountDistinctSlices.cpp)
70 | - [CountTriangles](https://github.com/Behrouz-m/Codility/blob/master/15-CaterpillarMethod/CountTriangles.cpp)
71 | - [MinAbsSumOfTwo](https://github.com/Behrouz-m/Codility/blob/master/15-CaterpillarMethod/MinAbsSumOfTwo.cpp)
72 | 
73 | ## Lesson 16 [Greedy algorithms](https://codility.com/programmers/lessons/15)
74 | - [MaxNonoverlappingSegments](https://github.com/Behrouz-m/Codility/blob/master/16-GreedyAlgorithms/MaxNonoverlappingSegments.cpp)
75 | - [TieRopes](https://github.com/Behrouz-m/Codility/blob/master/16-GreedyAlgorithms/TieRopes.cpp)
76 | 
77 | ## Lesson 17 [Dynamic programming](https://codility.com/programmers/lessons/16)
78 | - [MinAbsSum](https://github.com/Behrouz-m/Codility/blob/master/17-DynamicProgramming/MinAbsSum.cpp)
79 | - [NumberSolitaire](https://github.com/Behrouz-m/Codility/blob/master/17-DynamicProgramming/NumberSolitaire.cpp)
80 | 
81 | ## Lesson 90 [Tasks from Indeed Prime 2015 challenge](https://app.codility.com/programmers/lessons/90-tasks_from_indeed_prime_2015_challenge/)
82 | - [LongestPassword](https://github.com/Behrouz-m/Codility/blob/master/90-TasksFromIndeedPrime-2015-Challenge/LongestPassword.cpp)
83 | 
84 | ## Lesson 99 [Future training](https://app.codility.com/programmers/lessons/99-future_training/)
85 | - [StrSymmetryPoint](https://github.com/Behrouz-m/Codility/blob/master/99-FutureTraining/StrSymmetryPoint.cpp)
86 | - [TreeHeight](https://github.com/Behrouz-m/Codility/blob/master/99-FutureTraining/TreeHeight.cpp)
87 | <!--
88 | -->
89 | 


--------------------------------------------------------------------------------
/TestUnitForCodility.h:
--------------------------------------------------------------------------------
   1 | #pragma once
   2 | 
   3 | // this test unit has been developed specially for Codility
   4 | // by Behrouz Mohammadi
   5 | 
   6 | #include <iostream>
   7 | #include <cmath>
   8 | #include <vector>
   9 | #include <set>
  10 | #include <map>
  11 | #include <unordered_map>
  12 | #include <unordered_set>
  13 | #include <algorithm>
  14 | #include <climits>
  15 | #include <time.h>
  16 | #include <functional>
  17 | #include <numeric>
  18 | #include <random>
  19 | #include <memory>
  20 | #include <array>
  21 | 
  22 | using namespace std;
  23 | 
  24 | #define debug
  25 | 
  26 | #ifdef debug
  27 | #define LOG(X) cout << X << endl
  28 | #else
  29 | #define LOG(X) (void)0
  30 | #endif
  31 | 
  32 | template<typename T>
  33 | T random(const T range_from, const T range_to) {
  34 |     std::random_device                  rand_dev;
  35 |     std::mt19937                        generator(rand_dev());
  36 |     std::uniform_int_distribution<T>    distr(range_from, range_to);
  37 |     return distr(generator);
  38 | }
  39 | 
  40 | template<typename T>
  41 | ostream& operator<<(ostream& s, vector<T> v) {
  42 |     cout << "[";
  43 |     for (size_t i = 0; i < v.size(); i++) {
  44 |         s << v[i];
  45 |         if (i < v.size() - 1)
  46 |             s << ", ";
  47 |     }
  48 |     cout << "]";
  49 |     return s;
  50 | }
  51 | 
  52 | template<typename T>
  53 | void log_array(vector<T>& A) {
  54 |     cout << "array = " << A << endl;
  55 | }
  56 | 
  57 | class Array2D {
  58 |     size_t _rows;
  59 |     size_t _columns;
  60 |     std::unique_ptr<int[]> data;
  61 | 
  62 | public:
  63 |     Array2D(size_t rows, size_t columns)
  64 |         : _rows{ rows },
  65 |         _columns{ columns },
  66 |         data{ std::make_unique<int[]>(rows * columns) } {}
  67 | 
  68 |     size_t rows() const { return _rows; }
  69 | 
  70 |     size_t columns() const { return _columns; }
  71 | 
  72 |     int* operator[](size_t row) { return row * _columns + data.get(); }
  73 | 
  74 |     int& operator()(size_t row, size_t column) {
  75 |         return data[row * _columns + column];
  76 |     }
  77 | };
  78 | 
  79 | template<typename T=int>
  80 | class ArrayInfo {
  81 | public:
  82 |     using AfterInit = std::function<void(vector<T>& init_vector)>;
  83 | 
  84 |     ArrayInfo() = default;
  85 | 
  86 |     ArrayInfo(const T minV, const T maxV, bool unique = false, const AfterInit afterInit = nullptr) {
  87 |         _minV = minV;
  88 |         _maxV = maxV;
  89 |         _unique = unique;
  90 |         _afterInit = afterInit;
  91 |     }
  92 | 
  93 |     vector<T> Make(size_t size) {
  94 |         return Make(size, _minV, _maxV);
  95 |     }
  96 | 
  97 |     vector<T> Make(size_t size, T minV, T maxV)
  98 |     {
  99 |         if (_unique && static_cast<size_t>(_maxV - _minV + 1) < size)
 100 |             throw exception("Invalid range");
 101 | 
 102 |         vector<T> a(size);
 103 |         for (size_t i = 0; i < size; i++) {
 104 |             a[i] = static_cast<T>(random(static_cast<int64_t>(_minV), static_cast<int64_t>(_maxV)));
 105 |             if (_unique) {
 106 |                 for (size_t j = 0; j < i; j++)
 107 |                     if (a[j] == a[i])
 108 |                         i--;
 109 |             }
 110 |         }
 111 |         if (_afterInit)
 112 |             _afterInit(a);
 113 |         return a;
 114 |     }
 115 | 
 116 |     T Max() { return _maxV; }
 117 |     T Min() { return _minV; }
 118 |     bool UniqueValues() { return _unique; }
 119 | 
 120 | private:
 121 |     AfterInit _afterInit = nullptr;
 122 |     T _minV = T();
 123 |     T _maxV = T();
 124 |     bool _unique = false;
 125 | };
 126 | 
 127 | template<typename T=int>
 128 | class VarInfo {
 129 | public:
 130 |     using AfterInit = function<void(T&)>;
 131 | 
 132 |     VarInfo(const T minV, const T maxV, const AfterInit afterInit = nullptr) {
 133 |         _minV = minV;
 134 |         _maxV = maxV;
 135 |         _afterInit = afterInit;
 136 |     }
 137 | 
 138 |     T Make() {
 139 |         return Make(_minV, _maxV);
 140 |     }
 141 | 
 142 |     T Make(T minV, T maxV) {
 143 |         T v = random(_minV, _maxV);
 144 |         if (_afterInit)
 145 |             _afterInit(v);
 146 |         return v;
 147 |     }
 148 |     
 149 |     T Max() { return _maxV; }
 150 |     T Min() { return _minV; }
 151 | 
 152 | private:
 153 |     AfterInit _afterInit;
 154 |     T _minV;
 155 |     T _maxV;
 156 | };
 157 | 
 158 | template<typename RET>
 159 | class TestBase {
 160 | public:
 161 |     bool virtual AutoTest(size_t test_count, size_t minN, size_t maxN) = 0;
 162 |     bool virtual IsEqual(RET& sln, RET& dummy) { return sln == dummy; }
 163 | };
 164 | 
 165 | template<typename A1=int, typename RET=int>
 166 | class Test_1a : public TestBase<RET> {
 167 | public:
 168 |     using Sln = function<RET(vector<A1>&)>;
 169 |     using BeforeRunningEachTest = function<void(vector<A1>&, const ArrayInfo<A1>&)>;
 170 | 
 171 |     Test_1a(const Sln& dummy_sln, const Sln& sln, const ArrayInfo<A1>& arr_info) :
 172 |         _dummy_sln(dummy_sln),
 173 |         _sln(sln),
 174 |         _arr_info(arr_info)
 175 |     {}
 176 |     
 177 |     void SetBeforeRunningEachTestCallback(const BeforeRunningEachTest beforeRunningEachTest) {
 178 |         _beforeRunningEachTest = beforeRunningEachTest;
 179 |     }
 180 | 
 181 |     bool Test(vector<A1> a1) {
 182 |         RET rdum = _dummy_sln(a1);
 183 |         LOG("Dummy test passed.");
 184 |         RET rsln = _sln(a1);
 185 |         if (rsln != rdum) {
 186 |             LOG("Manual test failed: Dummy: " << rdum << " != " << rsln << " :solution");
 187 |             log_array(a1);
 188 |             return false;
 189 |         }
 190 |         LOG("Manual test passed.");
 191 |         return true;
 192 |     }
 193 |     
 194 | 
 195 |     bool Test(vector<A1> a1, RET result) {
 196 |         RET rdum = _dummy_sln(a1);
 197 |         if (rdum != result) {
 198 |             LOG("Dummy test failed: Dummy: " << rdum << " != " << result << " :answer");
 199 |             log_array(a1);
 200 |             return false;
 201 |         }
 202 |         else {
 203 |             LOG("Dummy test passed.");
 204 |             RET rsln = _sln(a1);
 205 |             if (rsln != rdum) {
 206 |                 LOG("Manual test failed: Dummy: " << rdum << " != " << rsln << " :solution");
 207 |                 log_array(a1);
 208 |                 return false;
 209 |             }
 210 |             LOG("Manual test passed.");
 211 |             return true;
 212 |         }
 213 |     }
 214 | 
 215 |     bool AutoTest(size_t test_count, size_t minN, size_t maxN) {
 216 | #ifdef debug
 217 |         size_t test_number = 100000;
 218 |         const size_t test_groups = 3;
 219 |         // check low boundry
 220 |         for (size_t test = 0; test <= 5; test++) {
 221 |             vector<A1> a = _arr_info.Make(minN + test);
 222 |             if (!caller(a, test_number))
 223 |                 return false;
 224 |             test_number++;
 225 |         }
 226 | 
 227 |         test_number = 200000;
 228 |         for (size_t test = 1; test <= test_count / test_groups; test++) {
 229 |             size_t n = rand() % maxN + minN;
 230 |             vector<A1> a = _arr_info.Make(n);
 231 |             if (!caller(a, test_number))
 232 |                 return false;
 233 |             test_number++;
 234 |         }
 235 |         // All Max
 236 |         test_number = 300000;
 237 |         for (size_t test = 1; test <= test_count / test_groups; test++) {
 238 |             size_t n = rand() % maxN + minN;
 239 |             vector<A1> a = _arr_info.Make(n, _arr_info.Max()-n, _arr_info.Max());
 240 |             if (!caller(a, test_number))
 241 |                 return false;
 242 |             test_number++;
 243 |         }
 244 | 
 245 |         // All Min
 246 |         test_number = 400000;
 247 |         for (size_t test = 1; test <= test_count / test_groups; test++) {
 248 |             size_t n = rand() % maxN + minN;
 249 |             vector<A1> a = _arr_info.Make(n, _arr_info.Min(), _arr_info.Min() + n);
 250 |             if (!caller(a, test_number))
 251 |                 return false;
 252 |             test_number++;
 253 |         }
 254 |         LOG("All Tests Passed :-)");
 255 | #endif
 256 |         return true;
 257 |     }
 258 | private:
 259 |     bool caller(vector<A1> &a, size_t test_number) {
 260 |         if (_beforeRunningEachTest)
 261 |             _beforeRunningEachTest(a, _arr_info);
 262 | 
 263 |         RET ret_sln = _sln(a);
 264 |         RET ret_dummy = _dummy_sln(a);
 265 | 
 266 |         if (!this->IsEqual(ret_sln, ret_dummy)) {
 267 |             LOG("[x] Test(" << test_number << ") FAILED.");
 268 |             LOG("solution = (" << ret_sln << ") != (" << ret_dummy << ") dummy_solution");
 269 |             LOG("failed on:");
 270 |             log_array(a);
 271 |             return false;
 272 |         }
 273 |         else {
 274 |             LOG("[+] Test(" << test_number << ") Passed.");
 275 |         }
 276 |         return true;
 277 |     }
 278 | 
 279 |     ArrayInfo<A1>           _arr_info;
 280 |     Sln                     _dummy_sln;
 281 |     Sln                     _sln;
 282 |     BeforeRunningEachTest   _beforeRunningEachTest = NULL;
 283 | };
 284 | 
 285 | 
 286 | template<typename V1 = int, typename RET = int>
 287 | class Test_1v : public TestBase<RET> {
 288 | public:
 289 |     using Sln = function<RET(V1)>;
 290 |     using BeforeRunningEachTest = function<void(V1&, const VarInfo<V1>&)>;
 291 | 
 292 |     Test_1v(const Sln& dummy_sln, const Sln& sln, const VarInfo<V1>& var_info) : 
 293 |         _dummy_sln(dummy_sln),
 294 |         _sln(sln),
 295 |         _var_info(var_info)
 296 |     {}
 297 | 
 298 |     void SetBeforeRunningEachTestCallback(const BeforeRunningEachTest beforeRunningEachTest) {
 299 |         _beforeRunningEachTest = beforeRunningEachTest;
 300 |     }
 301 | 
 302 |     bool Test(V1 v1) {
 303 |         RET rdum = _dummy_sln(v1);
 304 |         LOG("Dummy test passed.");
 305 |         RET rsln = _sln(v1);
 306 |         if (rsln != rdum) {
 307 |             LOG("Manual test failed: Dummy: " << rdum << " != " << rsln << " :solution");
 308 |             return false;
 309 |         }
 310 |         LOG("Manual test passed.");
 311 |         return true;
 312 |     }
 313 |     
 314 |     bool Test(V1 v1,  RET result) {
 315 |         RET rdum = _dummy_sln(v1);
 316 |         if (rdum != result) {
 317 |             LOG("Dummy test failed: Dummy: " << rdum << " != " << result << " :answer");
 318 |             return false;
 319 |         }
 320 |         else {
 321 |             LOG("Dummy test passed.");
 322 |             RET rsln = _sln(v1);
 323 |             if (rsln != rdum) {
 324 |                 LOG("Manual test failed: Dummy: " << rdum << " != " << rsln << " :solution");
 325 |                 return false;
 326 |             }
 327 |             LOG("Manual test passed.");
 328 |             return true;
 329 |         }
 330 |     }
 331 | 
 332 |     bool AutoTest(size_t test_count, size_t minN, size_t maxN) {
 333 | #ifdef debug
 334 |         size_t test_number = 100000;
 335 |         const size_t test_groups = 3;
 336 |         // check low boundry
 337 |         for (size_t test = 0; test <= 5; test++) {
 338 |             V1 v1 = _var_info.Make();
 339 |             if (!caller(v1, test_number))
 340 |                 return false;
 341 |             test_number++;
 342 |         }
 343 | 
 344 |         test_number = 200000;
 345 |         for (size_t test = 1; test <= test_count / test_groups; test++) {
 346 |             size_t n = rand() % maxN + minN;
 347 |             V1 v1 = _var_info.Make();
 348 |             if (!caller(v1, test_number))
 349 |                 return false;
 350 |             test_number++;
 351 |         }
 352 |         // All Max
 353 |         test_number = 300000;
 354 |         for (size_t test = 1; test <= test_count / test_groups; test++) {
 355 |             size_t n = rand() % maxN + minN;
 356 |             V1 v1 = _var_info.Make(_var_info.Max() - n, _var_info.Max());
 357 |             if (!caller(v1, test_number))
 358 |                 return false;
 359 |             test_number++;
 360 |         }
 361 | 
 362 |         // All Min
 363 |         test_number = 400000;
 364 |         for (size_t test = 1; test <= test_count / test_groups; test++) {
 365 |             size_t n = rand() % maxN + minN;
 366 |             V1 v1 = _var_info.Make(_var_info.Min(), _var_info.Min() + n);
 367 |             if (!caller(v1, test_number))
 368 |                 return false;
 369 |             test_number++;
 370 |         }
 371 |         LOG("All Tests Passed :-)");
 372 | #endif
 373 |         return true;
 374 |     }
 375 | 
 376 | private:
 377 |     bool caller(V1& v1, size_t test_number) {
 378 |         if (_beforeRunningEachTest)
 379 |             _beforeRunningEachTest(v1, _var_info);
 380 | 
 381 |         RET ret_sln = _sln(v1);
 382 |         RET ret_dummy = _dummy_sln(v1);
 383 |         if (!this->IsEqual(ret_sln, ret_dummy)) {
 384 |             LOG("[x] Test(" << test_number << ") FAILED.");
 385 |             LOG("solution = (" << ret_sln << ") != (" << ret_dummy << ") dummy_solution");
 386 |             LOG("failed on: " << v1);
 387 |             return false;
 388 |         }
 389 |         else {
 390 |             LOG("[+] Test(" << test_number << ") Passed.");
 391 |         }
 392 |         return true;
 393 |     }
 394 | 
 395 |     VarInfo<V1>             _var_info;
 396 |     Sln                     _dummy_sln;
 397 |     Sln                     _sln;
 398 |     BeforeRunningEachTest   _beforeRunningEachTest = nullptr;
 399 | };
 400 | 
 401 | template<typename V1 = int, typename V2 = int, typename RET = int>
 402 | class Test_2v : public TestBase<RET> {
 403 | public:
 404 |     using Sln = function<RET(V1, V2)>;
 405 |     using BeforeRunningEachTest = function<void(V1&, const VarInfo<V1>&, V2&, const VarInfo<V2>&)>;
 406 | 
 407 |     Test_2v(const Sln& dummy_sln, const Sln& sln, const VarInfo<V1>& var_info1, const VarInfo<V2>& var_info2) :
 408 |         _dummy_sln(dummy_sln),
 409 |         _sln(sln),
 410 |         _var_info1(var_info1),
 411 |         _var_info2(var_info2)
 412 |     {}
 413 | 
 414 |     void SetBeforeRunningEachTestCallback(const BeforeRunningEachTest beforeRunningEachTest) {
 415 |         _beforeRunningEachTest = beforeRunningEachTest;
 416 |     }
 417 | 
 418 |     bool Test(V1 v1, V2 v2) {
 419 |         RET rdum = _dummy_sln(v1, v2);
 420 | 
 421 |         RET rsln = _sln(v1, v2);
 422 |         if (rsln != rdum) {
 423 |             LOG("Manual test failed: Dummy: " << rdum << " != " << rsln << " :solution");
 424 |             return false;
 425 |         }
 426 |         LOG("Manual test passed.");
 427 |         return true;
 428 |     }
 429 |     
 430 |     bool Test(V1 v1, V2 v2, RET result) {
 431 |         RET rdum = _dummy_sln(v1, v2);
 432 |         if (rdum != result) {
 433 |             LOG("Dummy test failed: Dummy: " << rdum << " != " << result << " :answer");
 434 |             return false;
 435 |         }
 436 |         else {
 437 |             LOG("Dummy test passed.");
 438 |             RET rsln = _sln(v1, v2);
 439 |             if (rsln != rdum) {
 440 |                 LOG("Manual test failed: Dummy: " << rdum << " != " << rsln << " :solution");
 441 |                 return false;
 442 |             }
 443 |             LOG("Manual test passed.");
 444 |             return true;
 445 |         }
 446 |     }
 447 | 
 448 |     bool AutoTest(size_t test_count, size_t minN, size_t maxN) {
 449 | #ifdef debug
 450 |         size_t test_number = 100000;
 451 |         const size_t test_groups = 3;
 452 |         // check low boundry
 453 |         for (size_t test = 0; test <= 5; test++) {
 454 |             V1 v1 = _var_info1.Make();
 455 |             V2 v2 = _var_info2.Make();
 456 |             if (!caller(v1, v2, test_number))
 457 |                 return false;
 458 |             test_number++;
 459 |         }
 460 | 
 461 |         test_number = 200000;
 462 |         for (size_t test = 1; test <= test_count / test_groups; test++) {
 463 |             size_t n = rand() % maxN + minN;
 464 |             V1 v1 = _var_info1.Make();
 465 |             V2 v2 = _var_info2.Make();
 466 |             if (!caller(v1, v2, test_number))
 467 |                 return false;
 468 |             test_number++;
 469 |         }
 470 |         // All Max
 471 |         test_number = 300000;
 472 |         for (size_t test = 1; test <= test_count / test_groups; test++) {
 473 |             size_t n = rand() % maxN + minN;
 474 |             V1 v1 = _var_info1.Make(_var_info1.Max() - n, _var_info1.Max());
 475 |             V2 v2 = _var_info2.Make(_var_info2.Max() - n, _var_info2.Max());
 476 |             if (!caller(v1, v2, test_number))
 477 |                 return false;
 478 |             test_number++;
 479 |         }
 480 | 
 481 |         // All Min
 482 |         test_number = 400000;
 483 |         for (size_t test = 1; test <= test_count / test_groups; test++) {
 484 |             size_t n = rand() % maxN + minN;
 485 |             V1 v1 = _var_info1.Make(_var_info1.Min(), _var_info1.Min() + n);
 486 |             V2 v2 = _var_info2.Make(_var_info2.Min(), _var_info2.Min() + n);
 487 |             if (!caller(v1, v2, test_number))
 488 |                 return false;
 489 |             test_number++;
 490 |         }
 491 |         LOG("All Tests Passed :-)");
 492 | #endif
 493 |         return true;
 494 |     }
 495 | 
 496 | private:
 497 |     bool caller(V1& v1, V2& v2, size_t test_number) {
 498 |         if (_beforeRunningEachTest)
 499 |             _beforeRunningEachTest(v1, _var_info1, v2, _var_info2);
 500 | 
 501 |         RET ret_sln = _sln(v1, v2);
 502 |         RET ret_dummy = _dummy_sln(v1, v2);
 503 |         if (!this->IsEqual(ret_sln, ret_dummy)) {
 504 |             LOG("[x] Test(" << test_number << ") FAILED.");
 505 |             LOG("solution = (" << ret_sln << ") != (" << ret_dummy << ") dummy_solution");
 506 |             LOG("failed on: " << v1);
 507 |             return false;
 508 |         }
 509 |         else {
 510 |             LOG("[+] Test(" << test_number << ") Passed.");
 511 |         }
 512 |         return true;
 513 |     }
 514 | 
 515 |     VarInfo<V1>             _var_info1;
 516 |     VarInfo<V2>             _var_info2;
 517 |     Sln                     _dummy_sln;
 518 |     Sln                     _sln;
 519 |     BeforeRunningEachTest   _beforeRunningEachTest = nullptr;
 520 | };
 521 | 
 522 | template<typename A1=int, typename V1=int, typename RET=int>
 523 | class Test_1a_1v : public TestBase<RET> {
 524 | public:
 525 |     using Sln = function<RET(vector<A1>&, V1&)> ;
 526 |     using BeforeRunningEachTest = function<void(vector<A1>&, const ArrayInfo<A1>&, V1&, const VarInfo<V1>&)> ;
 527 | 
 528 |     Test_1a_1v(const Sln& dummy_sln, const Sln& sln, const ArrayInfo<A1>& arr_info, const VarInfo<V1>& var_info) :
 529 |         _dummy_sln(dummy_sln),
 530 |         _sln(sln),
 531 |         _arr_info(arr_info),
 532 |         _var_info(var_info)
 533 |         {}
 534 | 
 535 |     void SetBeforeRunningEachTestCallback(const BeforeRunningEachTest beforeRunningEachTest) {
 536 |         _beforeRunningEachTest = beforeRunningEachTest;
 537 |     }
 538 | 
 539 |     bool Test(vector<A1> a1, V1 v1) {
 540 |         RET rdum = _dummy_sln(a1, v1);
 541 |         LOG("Dummy test passed.");
 542 |         RET rsln = _sln(a1, v1);
 543 |         if (rsln != rdum) {
 544 |             LOG("Manual test failed: Dummy: " << rdum << " != " << rsln << " :solution");
 545 |             log_array(a1);
 546 |             return false;
 547 |         }
 548 |         LOG("Manual test passed.");
 549 |         return true;
 550 |     }
 551 | 
 552 |     bool Test(vector<A1> a1, V1 v1, RET result) {
 553 |         RET rdum = _dummy_sln(a1, v1);
 554 |         if (rdum != result) {
 555 |             LOG("Dummy test failed: Dummy: " << rdum << " != " << result << " :answer");
 556 |             log_array(a1);
 557 |             return false;
 558 |         }
 559 |         else {
 560 |             LOG("Dummy test passed.");
 561 |             RET rsln = _sln(a1, v1);
 562 |             if (rsln != rdum) {
 563 |                 LOG("Manual test failed: Dummy: " << rdum << " != " << rsln << " :solution");
 564 |                 log_array(a1);
 565 |                 return false;
 566 |             }
 567 |             LOG("Manual test passed.");
 568 |             return true;
 569 |         }
 570 |     }
 571 | 
 572 |     bool AutoTest(size_t test_count, size_t minN, size_t maxN) {
 573 | #ifdef debug
 574 |         size_t test_number = 100000;
 575 |         const size_t test_groups = 3;
 576 |         // check low boundry
 577 |         for (size_t test = 0; test <= 5; test++) {
 578 |             vector<A1> a = _arr_info.Make(minN + test);
 579 |             V1 v1 = _var_info.Make();
 580 |             if (!caller(a, v1, test_number))
 581 |                 return false;
 582 |             test_number++;
 583 |         }
 584 | 
 585 |         test_number = 200000;
 586 |         for (size_t test = 1; test <= test_count / test_groups; test++) {
 587 |             size_t n = rand() % maxN + minN;
 588 |             vector<A1> a = _arr_info.Make(n);
 589 |             V1 v1 = _var_info.Make();
 590 |             if (!caller(a, v1, test_number))
 591 |                 return false;
 592 |             test_number++;
 593 |         }
 594 |         // All Max
 595 |         test_number = 300000;
 596 |         for (size_t test = 1; test <= test_count / test_groups; test++) {
 597 |             size_t n = rand() % maxN + minN;
 598 |             vector<A1> a = _arr_info.Make(n, _arr_info.Max() - n, _arr_info.Max());
 599 |             V1 v1 = _var_info.Make(_var_info.Max() - n, _var_info.Max());
 600 |             if (!caller(a, v1, test_number))
 601 |                 return false;
 602 |             test_number++;
 603 |         }
 604 | 
 605 |         // All Min
 606 |         test_number = 400000;
 607 |         for (size_t test = 1; test <= test_count / test_groups; test++) {
 608 |             size_t n = rand() % maxN + minN;
 609 |             vector<A1> a = _arr_info.Make(n, _arr_info.Min(), _arr_info.Min() + n);
 610 |             V1 v1 = _var_info.Make(_var_info.Min(), _var_info.Min() + n);
 611 |             if (!caller(a, v1, test_number))
 612 |                 return false;
 613 |             test_number++;
 614 |         }
 615 |         LOG("All Tests Passed :-)");
 616 | #endif
 617 |         return true;
 618 |     }
 619 | 
 620 | private:
 621 |     bool caller(vector<A1>& a, V1& v1, size_t test_number) {
 622 |         if (_beforeRunningEachTest)
 623 |             _beforeRunningEachTest(a, _arr_info, v1, _var_info);
 624 | 
 625 |         RET ret_sln = _sln(a, v1);
 626 |         RET ret_dummy = _dummy_sln(a, v1);
 627 |         if ( !this->IsEqual(ret_sln, ret_dummy)) {
 628 |             LOG("[x] Test(" << test_number << ") FAILED.");
 629 |             LOG("solution = (" << ret_sln << ") != (" << ret_dummy << ") dummy_solution");
 630 |             LOG("failed on: variable=" << v1 << " and the array:");
 631 |             log_array(a);
 632 |             return false;
 633 |         }
 634 |         else {
 635 |             LOG("[+] Test(" << test_number << ") Passed.");
 636 |         }
 637 |         return true;
 638 |     }
 639 | 
 640 |     ArrayInfo<A1>           _arr_info;
 641 |     VarInfo<V1>             _var_info;
 642 |     Sln                     _dummy_sln;
 643 |     Sln                     _sln;
 644 |     BeforeRunningEachTest   _beforeRunningEachTest = nullptr;
 645 | };
 646 | 
 647 | template<typename A1 = int, typename V1 = int, typename V2 = int, typename RET = int>
 648 | class Test_1a_2v : public TestBase<RET> {
 649 | public:
 650 |     using Sln = function<RET(vector<A1>&, V1&, V2&)>;
 651 |     using BeforeRunningEachTest = function<void(vector<A1>&, const ArrayInfo<A1>&, V1&, const VarInfo<V1>&, V2&, const VarInfo<V2>&)>;
 652 | 
 653 |     Test_1a_2v(const Sln& dummy_sln, const Sln& sln, const ArrayInfo<A1>& arr_info, const VarInfo<V1>& var_info1, const VarInfo<V2>& var_info2) :
 654 |         _dummy_sln(dummy_sln),
 655 |         _sln(sln),
 656 |         _arr_info(arr_info),
 657 |         _var_info1(var_info1),
 658 |         _var_info2(var_info2)
 659 |     {}
 660 | 
 661 |     void SetBeforeRunningEachTestCallback(const BeforeRunningEachTest beforeRunningEachTest) {
 662 |         _beforeRunningEachTest = beforeRunningEachTest;
 663 |     }
 664 | 
 665 |     bool Test(vector<A1> a1, V1 v1, V2 v2) {
 666 |         RET rdum = _dummy_sln(a1, v1, v2);
 667 |         LOG("Dummy test passed.");
 668 |         RET rsln = _sln(a1, v1, v2);
 669 |         if (rsln != rdum) {
 670 |             LOG("Manual test failed: Dummy: " << rdum << " != " << rsln << " :solution");
 671 |             log_array(a1);
 672 |             return false;
 673 |         }
 674 |         LOG("Manual test passed.");
 675 |         return true;
 676 | 
 677 |     }
 678 | 
 679 |     bool Test(vector<A1> a1, V1 v1, V2 v2, RET result) {
 680 |         RET rdum = _dummy_sln(a1, v1, v2);
 681 |         if (rdum != result) {
 682 |             LOG("Dummy test failed: Dummy: " << rdum << " != " << result << " :answer");
 683 |             log_array(a1);
 684 |             return false;
 685 |         }
 686 |         else {
 687 |             LOG("Dummy test passed.");
 688 |             RET rsln = _sln(a1, v1, v2);
 689 |             if (rsln != rdum) {
 690 |                 LOG("Manual test failed: Dummy: " << rdum << " != " << rsln << " :solution");
 691 |                 log_array(a1);
 692 |                 return false;
 693 |             }
 694 |             LOG("Manual test passed.");
 695 |             return true;
 696 |         }
 697 |     }
 698 | 
 699 |     bool AutoTest(size_t test_count, size_t minN, size_t maxN) {
 700 | #ifdef debug
 701 |         size_t test_number = 100000;
 702 |         const size_t test_groups = 3;
 703 |         // check low boundry
 704 |         for (size_t test = 0; test <= 5; test++) {
 705 |             vector<A1> a = _arr_info.Make(minN + test);
 706 |             V1 v1 = _var_info1.Make();
 707 |             V2 v2 = _var_info2.Make();
 708 |             if (!caller(a, v1, v2, test_number))
 709 |                 return false;
 710 |             test_number++;
 711 |         }
 712 | 
 713 |         test_number = 200000;
 714 |         for (size_t test = 1; test <= test_count / test_groups; test++) {
 715 |             size_t n = rand() % maxN + minN;
 716 |             vector<A1> a = _arr_info.Make(n);
 717 |             V1 v1 = _var_info1.Make();
 718 |             V2 v2 = _var_info2.Make();
 719 |             if (!caller(a, v1, v2, test_number))
 720 |                 return false;
 721 |             test_number++;
 722 |         }
 723 |         // All Max
 724 |         test_number = 300000;
 725 |         for (size_t test = 1; test <= test_count / test_groups; test++) {
 726 |             size_t n = rand() % maxN + minN;
 727 |             vector<A1> a = _arr_info.Make(n, _arr_info.Max() - n, _arr_info.Max());
 728 |             V1 v1 = _var_info1.Make(_var_info1.Max() - n, _var_info1.Max());
 729 |             V2 v2 = _var_info2.Make(_var_info2.Max() - n, _var_info2.Max());
 730 |             if (!caller(a, v1, v2, test_number))
 731 |                 return false;
 732 |             test_number++;
 733 |         }
 734 | 
 735 |         // All Min
 736 |         test_number = 400000;
 737 |         for (size_t test = 1; test <= test_count / test_groups; test++) {
 738 |             size_t n = rand() % maxN + minN;
 739 |             vector<A1> a = _arr_info.Make(n, _arr_info.Min(), _arr_info.Min() + n);
 740 |             V1 v1 = _var_info1.Make(_var_info1.Min(), _var_info1.Min() + n);
 741 |             V2 v2 = _var_info2.Make(_var_info2.Min(), _var_info2.Min() + n);
 742 |             if (!caller(a, v1, v2, test_number))
 743 |                 return false;
 744 |             test_number++;
 745 |         }
 746 |         LOG("All Tests Passed :-)");
 747 | #endif
 748 |         return true;
 749 |     }
 750 | 
 751 | private:
 752 |     bool caller(vector<A1>& a, V1& v1, V2& v2, size_t test_number) {
 753 |         if (_beforeRunningEachTest)
 754 |             _beforeRunningEachTest(a, _arr_info, v1, _var_info1, v2, _var_info2);
 755 | 
 756 |         RET ret_sln = _sln(a, v1, v2);
 757 |         RET ret_dummy = _dummy_sln(a, v1, v2);
 758 |         if (!this->IsEqual(ret_sln, ret_dummy)) {
 759 |             LOG("[x] Test(" << test_number << ") FAILED.");
 760 |             LOG("solution = (" << ret_sln << ") != (" << ret_dummy << ") dummy_solution");
 761 |             LOG("failed on: variable=" << v1 << ", " << v2 << ", and the array:");
 762 |             log_array(a);
 763 |             return false;
 764 |         }
 765 |         else {
 766 |             LOG("[+] Test(" << test_number << ") Passed.");
 767 |         }
 768 |         return true;
 769 |     }
 770 | 
 771 |     ArrayInfo<A1>           _arr_info;
 772 |     VarInfo<V1>             _var_info1;
 773 |     VarInfo<V2>             _var_info2;
 774 |     Sln                     _dummy_sln;
 775 |     Sln                     _sln;
 776 |     BeforeRunningEachTest   _beforeRunningEachTest = nullptr;
 777 | };
 778 | 
 779 | template<typename A1 = int, typename A2 = int, typename RET = int>
 780 | class Test_2a : public TestBase<RET> {
 781 | public:
 782 |     using Sln = function<RET(vector<A1>&, vector<A2>&)>;
 783 |     using BeforeRunningEachTest = function<void(vector<A1>&, const ArrayInfo<A1>&, vector<A2>&, const ArrayInfo<A2>&)>;
 784 | 
 785 |     Test_2a(const Sln& dummy_sln, const Sln& sln, const ArrayInfo<A1>& arr_info1, const ArrayInfo<A2>& arr_info2) :
 786 |         _dummy_sln(dummy_sln),
 787 |         _sln(sln),
 788 |         _arr_info1(arr_info1),
 789 |         _arr_info2(arr_info2)
 790 |     {}
 791 | 
 792 |     void SetBeforeRunningEachTestCallback(const BeforeRunningEachTest beforeRunningEachTest) {
 793 |         _beforeRunningEachTest = beforeRunningEachTest;
 794 |     }
 795 | 
 796 |     bool Test(vector<A1> a1, vector<A2> a2) {
 797 |         RET rdum = _dummy_sln(a1, a2);
 798 |         LOG("Dummy test passed.");
 799 |         RET rsln = _sln(a1, a2);
 800 |         if (rsln != rdum) {
 801 |             LOG("Manual test failed: Dummy: " << rdum << " != " << rsln << " :solution");
 802 |             log_array(a1);
 803 |             log_array(a2);
 804 |             return false;
 805 |         }
 806 |         LOG("Manual test passed.");
 807 |         return true;
 808 |     }
 809 | 
 810 |     bool Test(vector<A1> a1, vector<A2> a2, const RET result) {
 811 |         RET rdum = _dummy_sln(a1, a2);
 812 |         if (rdum != result) {
 813 |             LOG("Dummy test failed: Dummy: " << rdum << " != " << result << " :answer");
 814 |             log_array(a1);
 815 |             log_array(a2);
 816 |             return false;
 817 |         }
 818 |         else {
 819 |             LOG("Dummy test passed.");
 820 |             RET rsln = _sln(a1, a2);
 821 |             if (rsln != rdum) {
 822 |                 LOG("Manual test failed: Dummy: " << rdum << " != " << rsln << " :solution");
 823 |                 log_array(a1);
 824 |                 log_array(a2);
 825 |                 return false;
 826 |             }
 827 |             LOG("Manual test passed.");
 828 |             return true;
 829 |         }
 830 |     }
 831 | 
 832 |     bool AutoTest(size_t test_count, size_t minN, size_t maxN) {
 833 | #ifdef debug
 834 |         size_t test_number = 100000;
 835 |         const size_t test_groups = 3;
 836 |         // check low boundry
 837 |         for (size_t test = 0; test <= 5; test++) {
 838 |             vector<A1> a1 = _arr_info1.Make(minN + test);
 839 |             vector<A2> a2 = _arr_info2.Make(minN + test);
 840 |             if (!caller(a1, a2, test_number))
 841 |                 return false;
 842 |             test_number++;
 843 |         }
 844 | 
 845 |         test_number = 200000;
 846 |         for (size_t test = 1; test <= test_count / test_groups; test++) {
 847 |             size_t n = rand() % maxN + minN;
 848 |             vector<A1> a1 = _arr_info1.Make(n);
 849 |             vector<A2> a2 = _arr_info2.Make(n);
 850 |             if (!caller(a1, a2, test_number))
 851 |                 return false;
 852 |             test_number++;
 853 |         }
 854 |         // All Max
 855 |         test_number = 300000;
 856 |         for (size_t test = 1; test <= test_count / test_groups; test++) {
 857 |             size_t n = rand() % maxN + minN;
 858 |             vector<A1> a1 = _arr_info1.Make(n, _arr_info1.Max() - n, _arr_info1.Max());
 859 |             vector<A2> a2 = _arr_info2.Make(n, _arr_info2.Max() - n, _arr_info2.Max());
 860 |             if (!caller(a1, a2, test_number))
 861 |                 return false;
 862 |             test_number++;
 863 |         }
 864 | 
 865 |         // All Min
 866 |         test_number = 400000;
 867 |         for (size_t test = 1; test <= test_count / test_groups; test++) {
 868 |             size_t n = rand() % maxN + minN;
 869 |             vector<A1> a1 = _arr_info1.Make(n, _arr_info1.Min(), _arr_info1.Min() + n);
 870 |             vector<A2> a2 = _arr_info2.Make(n, _arr_info2.Min(), _arr_info2.Min() + n);
 871 |             if (!caller(a1, a2, test_number))
 872 |                 return false;
 873 |             test_number++;
 874 |         }
 875 |         LOG("All Tests Passed :-)");
 876 | #endif
 877 |         return true;
 878 |     }
 879 | 
 880 | private:
 881 |     bool caller(vector<A1>& a1, vector<A2>& a2, size_t test_number) {
 882 |         if (_beforeRunningEachTest)
 883 |             _beforeRunningEachTest(a1, _arr_info1, a2, _arr_info2);
 884 | 
 885 |         RET ret_sln = _sln(a1, a2);
 886 |         RET ret_dummy = _dummy_sln(a1, a2);
 887 |         if (!this->IsEqual(ret_sln, ret_dummy)) {
 888 |             LOG("[x] Test(" << test_number << ") FAILED.");
 889 |             LOG("solution = (" << ret_sln << ") != (" << ret_dummy << ") dummy_solution");
 890 |             log_array(a1);
 891 |             log_array(a2);
 892 |             return false;
 893 |         }
 894 |         else {
 895 |             LOG("[+] Test(" << test_number << ") Passed.");
 896 |         }
 897 |         return true;
 898 |     }
 899 | 
 900 |     ArrayInfo<A1>           _arr_info1;
 901 |     ArrayInfo<A2>           _arr_info2;
 902 |     Sln                     _dummy_sln;
 903 |     Sln                     _sln;
 904 |     BeforeRunningEachTest   _beforeRunningEachTest = nullptr;
 905 | };
 906 | 
 907 | template<typename A1=int, typename A2 = int, typename V1 = int, typename RET = int>
 908 | class Test_2a_1v : public TestBase<RET> {
 909 | public:
 910 |     using Sln = function<RET(vector<A1>&, vector<A2>&, V1&)>;
 911 |     using BeforeRunningEachTest = function<void(vector<A1>&, const ArrayInfo<A1>&, vector<A2>&, const ArrayInfo<A2>&, V1&, const VarInfo<V1>&)>;
 912 | 
 913 |     Test_2a_1v(const Sln& dummy_sln, const Sln& sln, const ArrayInfo<A1>& arr_info1, const ArrayInfo<A2>& arr_info2, const VarInfo<V1>& var_info) :
 914 |         _dummy_sln(dummy_sln),
 915 |         _sln(sln),
 916 |         _arr_info1(arr_info1),
 917 |         _arr_info2(arr_info2),
 918 |         _var_info(var_info)
 919 |     {}
 920 | 
 921 |     void SetBeforeRunningEachTestCallback(const BeforeRunningEachTest beforeRunningEachTest) {
 922 |         _beforeRunningEachTest = beforeRunningEachTest;
 923 |     }
 924 | 
 925 |     bool Test(vector<A1> a1, vector<A2> a2, V1 v1) {
 926 |         RET rdum = _dummy_sln(a1, a2, v1);
 927 |         LOG("Dummy test passed.");
 928 |         RET rsln = _sln(a1, a2, v1);
 929 |         if (rsln != rdum) {
 930 |             LOG("Manual test failed: Dummy: " << rdum << " != " << rsln << " :solution");
 931 |             log_array(a1);
 932 |             log_array(a2);
 933 |             return false;
 934 |         }
 935 |         LOG("Manual test passed.");
 936 |         return true;
 937 |     }
 938 |     
 939 | 
 940 |     bool Test(vector<A1> a1, vector<A2> a2, V1 v1, RET result) {
 941 |         RET rdum = _dummy_sln(a1, a2, v1);
 942 |         if (rdum != result) {
 943 |             LOG("Dummy test failed: Dummy: " << rdum << " != " << result << " :answer");
 944 |             log_array(a1);
 945 |             log_array(a2);
 946 |             return false;
 947 |         }
 948 |         else {
 949 |             LOG("Dummy test passed.");
 950 |             RET rsln = _sln(a1, a2, v1);
 951 |             if (rsln != rdum) {
 952 |                 LOG("Manual test failed: Dummy: " << rdum << " != " << rsln << " :solution");
 953 |                 log_array(a1);
 954 |                 log_array(a2);
 955 |                 return false;
 956 |             }
 957 |             LOG("Manual test passed.");
 958 |             return true;
 959 |         }
 960 |     }
 961 | 
 962 |     bool AutoTest(size_t test_count, size_t minN, size_t maxN) {
 963 | #ifdef debug
 964 |         size_t test_number = 100000;
 965 |         const size_t test_groups = 3;
 966 |         // check low boundry
 967 |         for (size_t test = 0; test <= 5; test++) {
 968 |             vector<A1> a1 = _arr_info1.Make(minN + test);
 969 |             vector<A2> a2 = _arr_info2.Make(minN + test);
 970 |             V1 v1 = _var_info.Make();
 971 |             if (!caller(a1, a2, v1, test_number))
 972 |                 return false;
 973 |             test_number++;
 974 |         }
 975 | 
 976 |         test_number = 200000;
 977 |         for (size_t test = 1; test <= test_count / test_groups; test++) {
 978 |             size_t n = rand() % maxN + minN;
 979 |             vector<A1> a1 = _arr_info1.Make(n);
 980 |             vector<A2> a2 = _arr_info2.Make(n);
 981 |             V1 v1 = _var_info.Make();
 982 |             if (!caller(a1, a2, v1, test_number))
 983 |                 return false;
 984 |             test_number++;
 985 |         }
 986 |         // All Max
 987 |         test_number = 300000;
 988 |         for (size_t test = 1; test <= test_count / test_groups; test++) {
 989 |             size_t n = rand() % maxN + minN;
 990 |             vector<A1> a1 = _arr_info1.Make(n, _arr_info1.Max() - n, _arr_info1.Max());
 991 |             vector<A2> a2 = _arr_info2.Make(n, _arr_info2.Max() - n, _arr_info2.Max());
 992 |             V1 v1 = _var_info.Make(_var_info.Max() - n, _var_info.Max());
 993 |             if (!caller(a1, a2, v1, test_number))
 994 |                 return false;
 995 |             test_number++;
 996 |         }
 997 | 
 998 |         // All Min
 999 |         test_number = 400000;
1000 |         for (size_t test = 1; test <= test_count / test_groups; test++) {
1001 |             size_t n = rand() % maxN + minN;
1002 |             vector<A1> a1 = _arr_info1.Make(n, _arr_info1.Min(), _arr_info1.Min() + n);
1003 |             vector<A2> a2 = _arr_info2.Make(n, _arr_info2.Min(), _arr_info2.Min() + n);
1004 |             V1 v1 = _var_info.Make(_var_info.Min(), _var_info.Min() + n);
1005 |             if (!caller(a1, a2, v1, test_number))
1006 |                 return false;
1007 |             test_number++;
1008 |         }
1009 |         LOG("All Tests Passed :-)");
1010 | #endif
1011 |         return true;
1012 |     }
1013 | 
1014 | private:
1015 |     bool caller(vector<A1>& a1, vector<A2>& a2, V1& v1, size_t test_number) {
1016 |         if (_beforeRunningEachTest)
1017 |             _beforeRunningEachTest(a1, _arr_info1, a2, _arr_info2, v1, _var_info);
1018 | 
1019 |         RET ret_sln = _sln(a1, a2, v1);
1020 |         RET ret_dummy = _dummy_sln(a1, a2, v1);
1021 |         if (!this->IsEqual(ret_sln, ret_dummy)) {
1022 |             LOG("[x] Test(" << test_number << ") FAILED.");
1023 |             LOG("solution = (" << ret_sln << ") != (" << ret_dummy << ") dummy_solution");
1024 |             LOG("failed on: variable=" << v1 << " and the array:");
1025 |             log_array(a1);
1026 |             log_array(a2);
1027 |             return false;
1028 |         }
1029 |         else {
1030 |             LOG("[+] Test(" << test_number << ") Passed.");
1031 |         }
1032 |         return true;
1033 |     }
1034 | 
1035 |     ArrayInfo<A1>           _arr_info1;
1036 |     ArrayInfo<A2>           _arr_info2;
1037 |     VarInfo<V1>             _var_info;
1038 |     Sln                     _dummy_sln;
1039 |     Sln                     _sln;
1040 |     BeforeRunningEachTest   _beforeRunningEachTest = nullptr;
1041 | };
1042 | 
1043 | template<typename A1 = int, typename A2 = int, typename A3 = int, typename RET = int>
1044 | class Test_3a : public TestBase<RET> {
1045 | public:
1046 |     using Sln = function<RET(vector<A1>&, vector<A2>&, vector<A3>&)>;
1047 |     using BeforeRunningEachTest = function<void(vector<A1>&, const ArrayInfo<A1>&, vector<A2>&, const ArrayInfo<A2>&, vector<A3>&, const ArrayInfo<A3>&)>;
1048 | 
1049 |     Test_3a(const Sln& dummy_sln, const Sln& sln, const ArrayInfo<A1>& arr_info1, const ArrayInfo<A2>& arr_info2, const ArrayInfo<A3>& arr_info3) :
1050 |         _dummy_sln(dummy_sln),
1051 |         _sln(sln),
1052 |         _arr_info1(arr_info1),
1053 |         _arr_info2(arr_info2),
1054 |         _arr_info3(arr_info3)
1055 |     {}
1056 | 
1057 |     void SetBeforeRunningEachTestCallback(const BeforeRunningEachTest beforeRunningEachTest) {
1058 |         _beforeRunningEachTest = beforeRunningEachTest;
1059 |     }
1060 | 
1061 |     bool Test(vector<A1> a1, vector<A2> a2, vector<A3> a3) {
1062 |         RET rdum = _dummy_sln(a1, a2, a3);
1063 |         LOG("Dummy test passed.");
1064 |         RET rsln = _sln(a1, a2, a3);
1065 |         if (rsln != rdum) {
1066 |             LOG("Manual test failed: Dummy: " << rdum << " != " << rsln << " :solution");
1067 |             log_array(a1);
1068 |             log_array(a2);
1069 |             log_array(a3);
1070 |             return false;
1071 |         }
1072 |         LOG("Manual test passed.");
1073 |         return true;
1074 |     }
1075 | 
1076 |     bool Test(vector<A1> a1, vector<A2> a2, vector<A3> a3, const RET result) {
1077 |         RET rdum = _dummy_sln(a1, a2, a3);
1078 |         if (rdum != result) {
1079 |             LOG("Dummy test failed: Dummy: " << rdum << " != " << result << " :answer");
1080 |             log_array(a1);
1081 |             log_array(a2);
1082 |             log_array(a3);
1083 |             return false;
1084 |         }
1085 |         else {
1086 |             LOG("Dummy test passed.");
1087 |             RET rsln = _sln(a1, a2, a3);
1088 |             if (rsln != rdum) {
1089 |                 LOG("Manual test failed: Dummy: " << rdum << " != " << rsln << " :solution");
1090 |                 log_array(a1);
1091 |                 log_array(a2);
1092 |                 log_array(a3);
1093 |                 return false;
1094 |             }
1095 |             LOG("Manual test passed.");
1096 |             return true;
1097 |         }
1098 |     }
1099 | 
1100 |     bool AutoTest(size_t test_count, size_t minN, size_t maxN) {
1101 | #ifdef debug
1102 |         size_t test_number = 100000;
1103 |         const size_t test_groups = 3;
1104 |         // check low boundry
1105 |         for (size_t test = 0; test <= 5; test++) {
1106 |             vector<A1> a1 = _arr_info1.Make(minN + test);
1107 |             vector<A2> a2 = _arr_info2.Make(minN + test);
1108 |             vector<A3> a3 = _arr_info3.Make(minN + test);
1109 |             if (!caller(a1, a2, a3, test_number))
1110 |                 return false;
1111 |             test_number++;
1112 |         }
1113 | 
1114 |         test_number = 200000;
1115 |         for (size_t test = 1; test <= test_count / test_groups; test++) {
1116 |             size_t n = rand() % maxN + minN;
1117 |             vector<A1> a1 = _arr_info1.Make(n);
1118 |             vector<A2> a2 = _arr_info2.Make(n);
1119 |             vector<A3> a3 = _arr_info3.Make(minN + test);
1120 |             if (!caller(a1, a2, a3, test_number))
1121 |                 return false;
1122 |             test_number++;
1123 |         }
1124 |         // All Max
1125 |         test_number = 300000;
1126 |         for (size_t test = 1; test <= test_count / test_groups; test++) {
1127 |             size_t n = rand() % maxN + minN;
1128 |             vector<A1> a1 = _arr_info1.Make(n, _arr_info1.Max() - n, _arr_info1.Max());
1129 |             vector<A2> a2 = _arr_info2.Make(n, _arr_info2.Max() - n, _arr_info2.Max());
1130 |             vector<A3> a3 = _arr_info3.Make(n, _arr_info3.Max() - n, _arr_info3.Max());
1131 |             if (!caller(a1, a2, a3, test_number))
1132 |                 return false;
1133 |             test_number++;
1134 |         }
1135 | 
1136 |         // All Min
1137 |         test_number = 400000;
1138 |         for (size_t test = 1; test <= test_count / test_groups; test++) {
1139 |             size_t n = rand() % maxN + minN;
1140 |             vector<A1> a1 = _arr_info1.Make(n, _arr_info1.Min(), _arr_info1.Min() + n);
1141 |             vector<A2> a2 = _arr_info2.Make(n, _arr_info2.Min(), _arr_info2.Min() + n);
1142 |             vector<A3> a3 = _arr_info3.Make(n, _arr_info3.Min(), _arr_info3.Min() + n);
1143 |             if (!caller(a1, a2, a3, test_number))
1144 |                 return false;
1145 |             test_number++;
1146 |         }
1147 |         LOG("All Tests Passed :-)");
1148 | #endif
1149 |         return true;
1150 |     }
1151 | 
1152 | private:
1153 |     bool caller(vector<A1>& a1, vector<A2>& a2, vector<A3>& a3, size_t test_number) {
1154 |         if (_beforeRunningEachTest)
1155 |             _beforeRunningEachTest(a1, _arr_info1, a2, _arr_info2, a3, _arr_info3);
1156 | 
1157 |         RET ret_sln = _sln(a1, a2, a3);
1158 |         RET ret_dummy = _dummy_sln(a1, a2, a3);
1159 |         if (!this->IsEqual(ret_sln, ret_dummy)) {
1160 |             LOG("[x] Test(" << test_number << ") FAILED.");
1161 |             LOG("solution = (" << ret_sln << ") != (" << ret_dummy << ") dummy_solution");
1162 |             log_array(a1);
1163 |             log_array(a2);
1164 |             log_array(a3);
1165 |             return false;
1166 |         }
1167 |         else {
1168 |             LOG("[+] Test(" << test_number << ") Passed.");
1169 |         }
1170 |         return true;
1171 |     }
1172 | 
1173 |     ArrayInfo<A1>           _arr_info1;
1174 |     ArrayInfo<A2>           _arr_info2;
1175 |     ArrayInfo<A3>           _arr_info3;
1176 |     Sln                     _dummy_sln;
1177 |     Sln                     _sln;
1178 |     BeforeRunningEachTest   _beforeRunningEachTest = nullptr;
1179 | };


--------------------------------------------------------------------------------
/Todo.md:
--------------------------------------------------------------------------------
1 | [ ] NumberOfDiscIntersections
2 | [ ] 10/Peaks
3 | 
4 | 


--------------------------------------------------------------------------------