## Pages

### Codility CountFactors

Return the number of factors for a given positive integer.

You can find this problem in the Codility Prime and composite numbers section. In the pdf associated to this block of exercises it is explained why we shouldn't check all the possible factors, but we could stop at the square root of the examined number.

Still, the solution there is written in Python. If you want to use a strong typed language, you'd better pay attention to large int's, because overflow is a risk we should directly take care of.

That's the reason why I added to the test case provided with the problem also an explicit check on the biggest integer that could be passed in input:
```TEST(CountFactors, Given)
{
ASSERT_EQ(8, solution(24));
}

TEST(CountFactors, Simple)
{
EXPECT_EQ(1, solution(1));
EXPECT_EQ(2, solution(2));
EXPECT_EQ(2, solution(3));
EXPECT_EQ(3, solution(4));
EXPECT_EQ(2, solution(5));
}

TEST(CountFactors, Max)
{
ASSERT_EQ(2, solution(std::numeric_limits<int>::max()));
}
```
Here is my C++ solution. Since this is a problem almost completely based on numbers properties, it is very simple to port this piece of code to other languages:
```int solution(int input)
{
assert(input > 0);
if(input == 1) // 1
return 1;

int result = 2; // 2
unsigned i = 2; // 3
for(; i * i < static_cast<unsigned>(input); ++i)
if(input % i == 0)
result += 2;
if(i * i == static_cast<unsigned>(input))
++result;

return result;
}
```
1. Trivial case.
2. The algorithm is designed to be symmetric, any factor we find has its own double that has to be considered. Here we are considering 1, that implies also input itself.
3. Let's loop on all the other possible factors, starting from 2, up to the root of the input value. As I hinted above, I should pay attention to possible overflow, this is why I am using unsigned int instead of plain int.