(idea) by Clipsy Sun Apr 18 2004 at 3:54:22

In case you don't like using precious CPU cycles to solve these types of problems, there is a way of simplifying the solution set greatly:

First, let's multiply everything by 100 to work entirely on integers. That means A+B+C+D = 711, and A*B*C*D = 711000000. Now take the prime factorization of A*B*C*D, which comes out to 2^6 * 3^2 * 5^6 * 79^1. This tells you that each variable must have prime factorizations consisting of only these numbers (eg they are all of the form 2^x * 3^y * 5^z * 79^w). Now you can shorten the number of solutions quite a bit by applying some basic rules of arithmetic.

For the 2^x terms, we know that either 1 or 3 of the terms must be 1 because you need an odd number of odd terms to sum to an odd number. That leaves us with:

64, 1, 1, 1
16, 2, 2, 1
8, 4, 2, 1
4, 4, 4, 1

For the 3^y terms, it only breaks up two ways and both of them are valid.

9, 1, 1, 1
3, 3, 1, 1

For the 5^z terms, you can note that 711 is not a multiple of 5 and therefore k <= 3.

125 125 1 1
125 25 5 1
25 25 25 1

The 79^w terms are (hopefully) obvious.

79 1 1 1

Now that still leaves the problem of reordering all these sets, and testing them. For this, we'll fix the order of the 2's because they can vary the most. The rest add up to a much smaller number than the initial 100,000,000 checks you would have to make. You can only rearrange the 3's set (4+6) = 10 ways. The 5's set is a bit larger at (6 + 24 + 4) = 34 arrangements. The 79's of course have 4 different arrangements. That leaves the total number of checks to be made at 10*34*4*4 = 5440. (The last 4 is for the two's, which are not reordered at all).

Now, having done the math (which probably took longer than just having a computer brute force a solution, but oh well), it's simple to setup the possible solutions for a, b, c, and d. Here's the resulting program in C++:

#include <iostream.h>

int twos[] = {4,4,4,1, 2,4,8,1, 2,2,16,1, 64,1,1,1};
int threes[] = {3,3,1,1, 3,1,3,1, 3,1,1,3, 1,3,3,1,
                1,3,1,3, 1,1,3,3, 9,1,1,1, 1,9,1,1,
                1,1,9,1, 1,1,1,9};
int fives[] =  {25,25,25,1, 25,25,1,25, 25,1,25,25, 1,25,25,25,
                125,125,1,1, 125,1,125,1, 125,1,1,125, 1,125,125,1,
                1,125,1,125, 1,1,125,125, 125,25,5,1, 125,25,1,5,  
                125,5,25,1,  125,5,1,25,  125,1,25,5, 125,1,5,25,
                25,125,5,1,  25,125,1,5,  25,5,125,1,  25,5,1,125,  
                25,1,125,5, 25,1,5,125, 5,125,25,1,  5,125,1,25,  
                5,25,125,1,  5,25,125,1,  5,1,125,25, 5,1,25,125,
                1,125,25,5,  1,125,5,25,  1,25,125,5,  1,25,125,5,  
                1,5,125,25, 1,5,25,125};
int sns[] =       {79,1,1,1, 1,79,1,1, 1,1,79,1, 1,1,1,79};

void main() {
    int two, three, five, sn, i, total, partialsums[4];
    for(two=0; two<16; two+=4) {
        for(three=0; three<40; three+=4) {
            for(five=0; five<136; five+=4) {
                for(sn=0; sn<16; sn+=4) {
                    total = 0;
                    for(i=0; i<4; i++) {
                        partialsums[i] = (twos[two+i] * threes[three+i] * 
                        fives[five+i] * sns[sn+i]);
                        total += partialsums[i];
                    }
                    if(total == 711) {
                        cout << partialsums[0] << "\t" << partialsums[1] << "\t";
                        cout << partialsums[2] << "\t" << partialsums[3] << endl;
                    }
                }
            }
        }
    }
}

Its output is the four numbers, multiplied by 100. And it only took 5440 possible checks (only 1582 if you break out of the loops after finding a solution).

I like it!