The problem, part of the Codility Prime and composite numbers section, is not complicated, however I needed to spend some time thinking over it to understand what really was its point. As usual, I found helpful writing test cases, here are a few of them:

TEST(Peaks, Given) // 1 { std::vector<int> input { 1, 2, 3, 4, 3, 4, 1, 2, 3, 4, 6, 2 }; ASSERT_EQ(3, solution(input)); } TEST(Peaks, ThreeSpikes) // 2 { std::vector<int> input { 0, 1, 0, 0, 1, 0, 0, 1, 0 }; ASSERT_EQ(3, solution(input)); } TEST(Peaks, ElevenSaw) // 3 { std::vector<int> input { 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0 }; EXPECT_EQ(1, solution(input)); } TEST(Peaks, TwelveSaw) // 4 { std::vector<int> input { 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1 }; EXPECT_EQ(4, solution(input)); } TEST(Peaks, NoPeak) // 5 { std::vector<int> input(10); std::iota(input.begin(), input.end(), 1); ASSERT_EQ(0, solution(input)); } TEST(Peaks, MaxPlain) // 6 { std::vector<int> input(100000); for(unsigned i = 1; i < input.size(); i += 2) input[i] = 1; ASSERT_EQ(25000, solution(input)); }1. Codility provided test case. In this case the smallest size we can chose to have subsequences of the same size, each of them containing a peak, is four. Leading to a solution of 3.

2. Very plain case. Three blocks sized three are the optimal solution.

3. The input sequence is sized 11. That is, a prime number, we can't find any subinterval in this case, we just have to check if there is at least a peak, to decide to return 0 or 1.

4. Twelve could be split in 2, 3, 4, 6 sized units.

5. I have used iota() to generate a monotone function. No peak in it.

6. This test case is to check the algorithm performance. It should be easy to see that the minimum acceptable block size is four (two won't work because of the last interval).

Here is my C++11 solution:

int solution(std::vector<int>& input) { if(input.size() < 3) // 1 return 0; std::vector<unsigned> peaks(input.size() + 1); // 2 for(std::size_t i = 1; i < input.size() - 1; ++i) { if(input[i] > input[i - 1] && input[i] > input[i + 1]) peaks[i+1] = 1; } std::partial_sum(peaks.begin(), peaks.end(), peaks.begin()); for(std::size_t size = 3; size <= input.size() / 2; ++size) // 3 { if(input.size() % size) // 4 continue; bool hasPeaks = true; for(std::size_t end = size; end < peaks.size(); end += size) // 5 { if(peaks[end - size] == peaks[end]) { hasPeaks = false; break; } } if(hasPeaks) // 6 return input.size() / size; } return peaks.back() ? 1 : 0; // 7 }1. Get rid of trivial cases.

2. I am going to use partial sum to check if there is any peak in a give interval (some more detail on this STL function and its mathematical meaning in a previous post). To simplify the code, I add a spurious element at the beginning, set to zero, and shift all the partial sums one position to the right.

3. Check all the possible subsequence, from 3 to half the size of the input sequence. It won't make sense to check for subsequences sized less than three, since it is not possible to conceive a to have a local maximum in this case - see comments for more details.

4. We want all-equal blocks, so we accept only sizes that are divisor of the input sequence size.

5. Check all the subsequence to ensure they contain at least a peak.

6. If the current block size is good, return the number of them in the input sequence.

7. We couldn't find any way of splitting the sequence, return 1 if there is at least a peak, 0 otherwise.

You don't need to check for size 2 divisions, it's impossible to have peaks in all of them because they'd have to be all on the left side of each division or all in the right side meaning one of the peaks would be either at index 0 or at index length-1 and index 0 or index length-1 cannot be peaks right, because they miss a neighbour and thus cannot be larger than something inexistent.

ReplyDeleteSo in line 14 you can start at index 3. One less iteration for perfection's sake :)

ReplyDeleteRight! Thank you for pointing it out, I have corrected code and comment.

Delete