Threes, finding 23 sets of x y z values satisfy the condition x^3+y^3=1+z^3

Question

Now I have completed the finding 23 sets of x y z values satisfy the condition x^3+y^3=1+z^3 & x

int setsFound = 0;
System.out.println("The first 23 sets ordered by increasing x.");
for (long x = 1; setsFound < 23; x++) {
  for (long z = x + 1; z<x*x; z++) {
    long y = (long) Math.pow((1 + z*z*z - x*x*x), 1f/3f);
    if (x * x * x == 1 + z * z * z - y * y *y && x<y && y<z) {
      setsFound++;
      System.out.println("X: " + x + ", Y: " + y + ", Z: " + z);
    }
  }
}

But the code I have is very inefficient, can anyone help me to fix this please?

Maybe you should try printing a line every 100 iterations, just so you know the thing is still going. It might be that it's just so slow it hasn't found the first set by the time you give up. Also, using a `long` to hold the value of `long*long*long` is not the best of ideas. You should use BigInteger for those. — , Aug 02 '11 at 07:09

Petar Ivanov · Answer 1 · 2011-08-02T07:48:35.457

2

Here is a working code:

  int setsFound = 0;
  System.out.println("The first 23 sets ordered by increasing x.");
  for (long z = 1; setsFound < 23; z++) {
     for (long y = z - 1; y > 0; y--) {
        long x = (long) Math.pow((1 + z * z * z - y * y * y), 1f/3f);
        if(y <= x) break;
        if (x * x * x == 1 + z * z * z - y * y *y) {
           setsFound++;
           System.out.println("X: " + x + ", Y: " + y + ", Z: " + z);
        }
     }
  }

Couple of problems in the old one:

1/3 == 0 (because it's integer division) //use 1f/3f
x and z are swapped - you want z > x, not the other way around
(long)Math.pow(4*4*4, 1.0/3) == (long)3.9999999999999996 == 3 // use round

edited Aug 02 '11 at 07:48

answered Aug 02 '11 at 07:17

Petar Ivanov

91,536
11
82
95

Alternatively `1d/3d` or `1f/3f`. The `y^3` could be expressed as variable as well. – Aleksi Yrttiaho Aug 02 '11 at 07:22
@Jeff, I fixed it... However, it might take a while to find 23 this way – Petar Ivanov Aug 02 '11 at 07:49

score 2 · Answer 2 · edited Apr 19 '23 at 12:22

If you start the other way, with X < Y < Z by incrementing Y and Z up to a limit, you can gain some efficiencies. Once Z^3 > X^3 + Y^3 + 1, you can skip to the next Y value due to the concavity of the cubic function.

This implementation in C# works pretty fast on a laptop:

        UInt64 setsFound = 0;
        UInt64 xlim = 10000;
        UInt64 ylim = 1000000;
        UInt64 zlim = 10000000;

        //int ctr = 0;
        Console.WriteLine("The first 23 sets ordered by increasing x.");

        Parallel.For(1, (long)xlim, new ParallelOptions { MaxDegreeOfParallelism = 4 }, i =>
        //for (UInt64 i = 0; i < xlim; i++)
        {
            UInt64 x = (UInt64)i;
            UInt64 xCu = x * x * x;
            int zFails = 0;
            for (UInt64 y = x + 1; y < ylim; y++)
            {
                UInt64 yCu = y * y * y;
                zFails = 0;
                for (UInt64 z = y + 1; z < zlim & zFails < 1; z++)
                {
                    UInt64 zCu = z * z * z;
                    if (xCu + yCu - zCu == 1)
                    {
                        Console.WriteLine(String.Format("{0}: {1}^3 + {2}^3 - {3}^3 = 1", setsFound, x, y, z));
                        setsFound++;
                    }
                    else if (zCu > xCu + yCu - 1)
                    {
                        zFails++;
                    }
                }
            }
        }
        );

Obviously you can take out the parallelization. Also, here are the first 19 elements in that set (computer is still running, I'll try to post the last 4 later):

_{(source: yfrog.com)}

Threes, finding 23 sets of x y z values satisfy the condition x^3+y^3=1+z^3

2 Answers2