Question

Java question for two classes:

Given the upper limit n as a parameter, the result of both methods is a
boolean[] array of n elements that reveals the answers to that problem for all natural numbers
below n in one swoop.

public static boolean[] sumOfTwoDistinctSquares(int n)

Determines which natural numbers can be expressed in the form a 2 + b 2 so that a and b are two
distinct positive integers. In the boolean array returned as result, the i :th element should be true
if and only if such a breakdown is possible. The infinite sequence of positive integers that allow
such breakdown begins with 5, 10, 13, 17, 20, 25, 26, 29, 34, 37, 40, 41, 45, 50, 52, ...
You may have previously seen a version of this problem where the breakdown to two distinct
squares was done separately for one number at the time. However, now that we are dealing with
numbers in bulk so that the answers to these numbers are highly interrelated, you might want to
loop through all possible combinations of values of a and b whose squares are less than n and fill
the result table that way, instead of looping through all numbers less than n separately, and for each
such number in turn, try to construct a breakdown as two squares from scratch...

public static boolean[] subtractSquare(int n)

Subtract a square is an interesting impartial game of mental arithmetic for two players. The players
take turns moving from the current number n into any smaller natural number that can be reached
by subtracting some square of a positive integer from n without going below zero. For example, if
the current number n = 15, the player whose turn it is to play must move into one of the three
possible states 14, 11, and 6 of his choice. The player who moves to zero wins the game, since the
opponent cannot make a move.

Using the standard terminology of this sort of impartial combinatorial games, the state 0 in which
no moves are possible is losing or cold . In general, each state is winning or hot if there exists a
move into some cold state, and cold if no such move exists. This rule makes n = 1 to be hot, since
subtracting 1 wins the game, and n = 2 to be cold, since the one possible move from there moves
into a cold state. The infinite sequence of cold states in this game begins with 0, 2, 5, 7, 10, 12, 15,
17, 20, 22, 34, 39, ...

This method should create and return an n -element array of truth values so that the element in
position i is true if the state i is hot, and false if it is cold. Notice that this method should be filling
the result array from left to right, since to determine whether the current position is hot or cold, all
the information needed to make that decision is laid out in the open in the lower-numbered states
whose heat values we have already filled in...

> Hi guys, I don’t have much to say right now rather than to say thank you to Dr Amber for rescuing me and my family from poverty. I love playing the lottery but winning big is always the issue for me. I will never forget the day I came in contact with Dr Amber whose lottery spell made me a winner of $360,000,000 million dollars cash prize on the jackpot lottery game I played just by giving me sure winning numbers within 3 days to play the lottery game after he prepared the lottery spell for me. My financial status has changed for good and I’ve started to live my dream life after 14 years of playing the lottery. Thank you Dr Amber for I’m very grateful for all you’ve done for me and my family. You can TELEGRAM or call or message Dr Amber via +1 808 481-5132 or email: [email protected] or visit: amberlottotemple.com for more information.

Answer 1

All the explanation is in the code comments. Hope this helps!

Code:

public class Main
{
// required function 1
public static boolean[] sumOfTwoDistinctSquares(int n) {
  
// initialise a boolean array of size n
// the array is 0 indexed and natural numbers start from 1,
// hence the first value is of signifcance
// also the values are evaluted till n-1
// initially all values are false by default
boolean res[] = new boolean[n];
// variables for loop counters
int i=1, j=i+1;
  
// start i loop
while((i*i + j*j) < n) {
  
// set the value at index (i*i + j*j) = true
res[(i*i + j*j)] = true;
  
// update counters
// incease j by 1
j++;
// for overflow, update i and reset j
if((i*i + j*j) >= n) {
i++;
j = i+1;
}
}
// return the boolean array
return res;
}
  
// required function 2
public static boolean[] subtractSquare(int n) {
// initialise a boolean array of size n
// the values are evaluted till n-1, if till n is required use size as n+1
// initially all values are false by default
boolean res[] = new boolean[n];
int move;
  
// loop for all indexes, 0th index is cold by default
for(int i=1; i<n; i++) {
  
// find if ith state can be hot => find a winning move
// loop for hot move till overflow
move = 1;
while((i - move*move) >= 0) {
// the state after move is cold => i is hot state
if(!res[(i - move*move)]) {
res[i] = true;
break;
}
// update move
move++;
}
}
// return results
return res;
}
  
   public static void main(String[] args) {
       // sample run
       // #1
       int n = 55;
       boolean func1[] = sumOfTwoDistinctSquares(n);
       // print results
       System.out.println("Numbers below 55 which are sum of 2 distinct squares:");
       for(int i=0; i<n; i++) {
       if(func1[i])
       System.out.print(i + ", ");
       }
       // #2
       boolean func2[] = subtractSquare(n);
       // print results
       System.out.println("\nCold states are :");
       for(int i=0; i<n; i++) {
       if(!func2[i])
       System.out.print(i + ", ");
       }
   }
}

Sample run:

Numbers below 55 which are sum of 2 distinct squares: 5, 10, 13, 17, 20, 25, 26, 29, 34, 37, 40, 41, 45, 50, 52, 53, Cold states are : 0, 2, 5, 7, 10, 12, 15, 17, 20, 22, 34, 39, 44, 52,

Code screenshot:

public class Main { // required function 1 public static boolean() sumofTwoDistinctSquares(int n) { // initialise a boolean array of size n // the array is indexed and natural numbers start from 1, // hence the first value is of signifcance // also the values are evaluted till n-1 // initially all values are false by default boolean res[] = new boolean[n]; // variables for loop counters int i=1, j=i+1; // start i loop while((i*i + j*j) < n) { // set the value at index (i*i + j*j) = true res[(i*i + j*j)] = true; // update counters // incease j by 1 j++; // for overflow, update i and reset j if((i*i + j*j) >= n) { i++; j = i+1; } } // return the boolean array return res; } // required function 2 public static boolean() subtractSquare(int n) { // initialise a boolean array of size n // the values are evaluted till n-1, if till n is required use size as n+1 // initially all values are false by default boolean res[] = new boolean[n]; int move; // loop for all indexes, oth index is cold by default for(int i=1; i<n; i++) { // find if ith state can be hot => find a winning move // loop for hot move till overflow move 1; while((i move "move) >= 0) { // the state after move is cold => i is hot state if(!res[(i move "move)]) { res[i] = true; break; } // update move move++; } } // return results return res; } public static void main(String[] args) { // sample run // # int n = 55; boolean func1[] sumOfTwoDistinctSquares(n); // print results System.out.println("Numbers below 55 which are sum of 2 distinct squares:"); for(int i=0; i<n; i++) { if(func1[i]) System.out.print(i + ", "); // #2 boolean func2[] = subtractSquare(n); // print results System.out.println("\nCold states are :"); for(int i=0; i<n; i++) { if(!func2[i]) System.out.print(i + ", "); } -