## Pages

### Codility MaxSliceSum

Check the passed integer vector for the maximum sum of any non empty possible slice in it. You should expect also possible negative results.

This is a slight variation on the well known Kadane's algorithm, that you can find in the Maximum slice Codility section.

To stress the difference against the standard behavior, I have written a couple of test case that I added to the one provided in the problem definition itself:
```TEST(MaxSliceSum, Given)
{
std::vector<int> input { 3, 2, -6, 4, 0 }; // 1
ASSERT_EQ(5, solution(input));
}

TEST(MaxSliceSum, Minimal)
{
std::vector<int> input { -1000000 }; // 2
ASSERT_EQ(-1000000, solution(input));
}

TEST(MaxSliceSum, Minimal2)
{
std::vector<int> input { -1000000, -1000000 };
ASSERT_EQ(-1000000, solution(input));
}
```
1. As in the normal case, the winning slice is the one including the first two elements.
2. At least an element should be considered. Here the input collection contains just an element, so the winning slice contains it.

And here is my C++11 solution:
```int solution(std::vector<int>& input)
{
assert(!input.empty()); // 1

int result = input.front(); // 2
int candidate = input.front();
for(auto it = input.begin() + 1; it != input.end(); ++it) // 3
{
candidate = std::max(*it, candidate + *it); // 4
result = std::max(result, candidate);
}

return result;
}
```
1. Not required by codility, just to stress the fact that it is assumed the input collection is not empty.
2. The first candidate is a slice that include only the first element.
3. Let's loop on all the other elements.
4. As for the standard Kadane's algorithm, but here the new candidate comes from the comparison against the current element and the sum between it and the previously candidate.