Here's another solution, which uses elementary number theory (in particular the Fundamental Theorem of Arithmetic) to substantially reduce the search space, and thus get the answer in under 0.1 seconds.

**restart;**

**st:= time():**

If we multiply each of *a,b,c,d* by 100, then the sum is 711, and the product is

**N:= 711*100^3:**

and now the problem is strictly about positive integers. Henceforth, *a,b,c,d* will only refer to these integerized values.

Each of *a,b,c,d* must be a divisor of **N**, so let's look at the prime factorization of **N**:

**ifactor(N);**

6 2 6

(2) (3) (5) (79)

There is a prime factor that only appears to the first power. That will speed this up a lot. Let's get the divisors of **N**, which will be our search space.

**divs:= numtheory:-divisors(N):**

Since the sum is 711, we restrict the search to divisors less than 711.

**divs:= select(`\<`, divs, 711)**

(Ignore the backslash in the above line. Maple ignores it, and the MaplePrimes editor in my web browser won't display the rest of the line without it.)

Exactly one of *a,b,c,d* must be a multiple of 79---we'll make it *a*---so we partition the remaining divisors based on that.

**d79, divs:= selectremove(x-> x mod 79 = 0, divs):**

Now loop through these sets. After each *x* is chosen, the remaining solutions must divide **N***/x*, so we reduce the search space accordingly in each inner loop.

**proc()**

** local Na, divsa, divsb, Nb, a, b, c, d, sol;**

** for a in d79 do**

** Na:= N/a;**

** divsa:= divs intersect numtheory:-divisors(Na);**

** for b in divsa do**

** Nb:= Na/b;**

** divsb:= divsa intersect numtheory:-divisors(Nb);**

** for c in divsb do**

**if a+b+c+Nb/c = 711 then sol[a,b,c]:= {a,b,c,Nb/c} fi**

** od**

** od**

** od;**

convert(sol, set)

**end proc**

**();**

{ {120, 125, 150, 316} }

Finally, divide each of those by 100 to get the desired answers. I put each solution in a set so that permutations would be condensed. If there was a solution with repeated values, it would appear as a set with fewer than four members, and we'd have to do a little work to figure out which values were repeated. But, there is no such solution.

**time()-st;**

0.031

In a separate run, I counted the number of executions of the innermost loop. It was 8520. I also tried the above without separating the multiple-of-79 divisors as special. Then I got 58,938 iterations in 0.109 seconds, so maybe it wasn't worth it to separate them.

A note on coding style: I use an anonymous procedure above,* i.e.* a procdeure with no name. I invoke the procedure immediately by placing **()** after its definition.