Question

Problem: “An algorithm to find the number of six digit numbers where the sum of the first three digits is equal to the sum of the last three digits.”

I came across this problem in an interview and want to know the best solution. This is what I have till now.

Approach 1: The Brute force solution is, of course, to check for each number (between 100,000 and 999,999) whether the sum of its first three and last three digits are equal. If yes, then increment certain counter which keeps count of all such numbers.

But this checks for all 900,000 numbers and so is inefficient.

Approach 2: Since we are asked “how many” such numbers and not “which numbers”, we could do better. Divide the number into two parts: First three digits (these go from 100 to 999) and Last three digits (these go from 000 to 999). Thus, the sum of three digits in either part of a candidate number can range from 1 to 27.
* Maintain a std::map<int, int> for each part where key is the sum and value is number of numbers (3 digit) having that sum in the corresponding part.
* Now, for each number in the first part find out its sum and update the corresponding map.
* Similarly, we can get updated map for the second part.
* Now by multiplying the corresponding pairs (e.g. value in map 1 of key 4 and value in map 2 of key 4) and adding them up we get the answer.

In this approach, we end up checking 1K numbers.

My question is how could we further optimize? Is there a better solution?

Answer 1

For 0 <= s <= 18, there are exactly 10 - |s - 9| ways to obtain s as the sum of two digits.

So, for the first part

int first[28] = {0};
for(int s = 0; s <= 18; ++s) {
    int c = 10 - (s < 9 ? (9 - s) : (s - 9));
    for(int d = 1; d <= 9; ++d) {
        first[s+d] += c;
    }
}

That’s 19*9 = 171 iterations, for the second half, do it similarly, with the inner loop starting at 0 instead of 1, that’s 19*10 = 190 iterations. Then sum first[i]*second[i] for 1 <= i <= 27.