Question

public static List sumOfDistinctCubes(int n)

Determine whether the given positive integer n can be expressed as a sum of cubes of positive integers greater than zero so that all these integers are distinct. For example, the integer n = 1456 can be expressed as sum 11 3 + 5 3 . This method should return the list of these distinct integers as a list [11, 5] with the elements given in descending order. If n cannot be broken into a sum of distinct cubes, this method should return the empty list.

Many integers can be broken down into a sum of cubes in several different ways. This method must always return the breakdown that is lexicographically highest, that is, starts with the largest possible working value for the first element, and then follow the same principle for the remaining elements that break down the rest of the number into a list of distinct cubes. For example, when called with n = 1072, this method must return the list [10, 4, 2] instead of [9, 7], even though 9 3 + 7 3 = 1072.

Hint: the easiest way to implement this recursion is again to have a second private method

private static boolean sumOfDistinctCubes(int n, int c, LinkedList soFar)

that receives two extra parameters c and soFar from the original method. The parameter c gives you the highest number that you are still allowed to use (initially this should equal the largest possible integer whose cube is less than equal to n, easily found with a while-loop), and the parameter soFar contains the list of numbers that have already been taken in. The recursion has two base cases, one for success and one for failure. If n == 0, the problem is solved and you can just return true. If c == 0, there are no numbers remaining that you can use, and you simply return false. Otherwise, try taking c into the sum (also adding c to soFar) and recursively solve the problem for new parameters n-c*c*c and c-1. If that one was not a success, remove c from soFar, and try to recursively solve the problem without using c, which makes the parameters of the second recursive call to be n and c-1.

Note how, since this method is supposed to find only one solution, once the recursive call returns true, the caller can also immediately return true without exploring the remaining possibilities. The first success will therefore cause the entire recursion to immediately roll back all the way to the top level where the breakdown of n into distinct cubes can then be read from the list soFar.

Here is the tester for this method assuming it is in a class named Main:

import static org.junit.Assert.*;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import java.util.Random;

import java.io.*;
import java.util.*;
import java.util.zip.CRC32;

public class SumOfDistinctSquaresTest {

private static final int SEED = 12345;
  
@Test public void testSumOfDistinctCubes() {
CRC32 check = new CRC32();
Random rng = new Random(SEED);
int c = 1, step = 2, next = 10;
while(c > 0) {
List<Integer> result = Main.sumOfDistinctCubes(c);
check.update(result.toString().getBytes());
c += rng.nextInt(step) + 1;
if(c > next) {
next = 2 * next;
step = 2 * step;
}
}
assertEquals(4219145223L, check.getValue());
}
  
private String createString(String alphabet, Random rng, int n) {
String result = "";
for(int i = 0; i < n; i++) {
result += alphabet.charAt(rng.nextInt(alphabet.length()));
}
return result;
}
  
  
}

The program must pass the tester to work (it can't run for too long)

Answer 1

        private static boolean sumOfDistinctCubes(int n, int c, LinkedList<Integer> soFar) {
            if(n == 0) {
                return true;
            }
            if(c == 0) {
                return false;
            }
            soFar.add(c);
            boolean subProblem = sumOfDistinctCubes(n-c*c*c, c-1, soFar);
            if(subProblem) {
                return true;
            }
            
            // we were unable to solve.
            soFar.remove(new Integer(c));
            return sumOfDistinctCubes(n, c-1, soFar);
        }

        public static List<Integer> sumOfDistinctCubes(int c) {
            LinkedList<Integer> result = new LinkedList<Integer>();
            
            int a = (int) Math.pow(c, 1.0/3);
            
            sumOfDistinctCubes(c, a, result);
                    
            return result;
        }

**************************************************

Thanks for your question. We try our best to help you with detailed answers, But in any case, if you need any modification or have a query/issue with respect to above answer, Please ask that in the comment section. We will surely try to address your query ASAP and resolve the issue.

Please consider providing a thumbs up to this question if it helps you. by Doing that, You will help other students, who are facing similar issue.