Question

JAVA

PROBLEM #1:

The British have been shelling the Revolutionary forces with a large cannon from within their camp. You have been assigned a dangerous reconnaissance mission -- to infiltrate the enemy camp and determine the amount of ammunition available for that cannon.

Fortunately for you, the British (being relatively neat and orderly) have stacked the cannonballs into a single pyramid-shaped stack. At the top is a single cannonball resting on a square of 8 cannonballs, which is itself resting on a square of 27 cannonballs, which is itself resting on a square of 64 cannonballs, and so forth. Given the danger in your situation, you only have a chance to count the number of layers before you escape back to your own encampment.

Your assignment, upon your return, is to write a method which will return the number of cannonballs in the stack, given the number of layers. Good luck!

Requirements:

Come up with a recurrence relation (mathematical expression of the recursive function) for the method. Do this before you start coding.

Put the recurrence relation (including the base case) in the comments for this method.

Write a recursive static Java method to solve the problem

Write a main method which will prompt the spy to type in the number of layers, call the method and display the results.

Make sure the method is never called with a negative number.

Allow the user to enter several values (loop). Use a sentinel to stop the program.

No credit will be awarded for a non-recursive solution.

PROBLEM #2:

The spy also wants to tell General Washington how many troops to send. To protect the information, the spy encoded it. To decode the number, add all the individual digits. For example, the coded number, 1234, sums to the real number, 10.

Requirements:

Come up with a recurrence relation (mathematical expression of the recursive function) for the method. Do this before you start coding.

Put the recurrence relation (including the base case) in the comments for this method.

Write a recursive static Java method to solve the problem

Write a main method which will prompt the spy to type in the encoded number of troops, call the method and display the results.

Make sure the method is never called with a negative number.

Allow the user to enter several values (loop). Use a sentinel to stop the program.

No credit will be awarded for a non-recursive solution.

Grading

Requirements (approximate points)	Possible Points
Problem #1 - Cannonballs The method correctly calculates the number of cannonballs in a stack of N layers using recursion (13 pts) A recurrence relation (including base case) is included in the comments (4 pts)	17 pts
Problem #2 – Sum digits The method correctly calculates the sum of the digits in a number using recursion (13 pts) A recurrence relation (including base case) is included in the comments (4 pts)	17 pts
main() main() prompts for the number of layers the stack of cannonballs and calls the cannonball method main() displays the number of cannonballs in the stack main() does not permit negative numbers to be passed to the cannonballs method main() includes a sentinel controlled loop which allows the user to call the cannonballs method repeatedly main() prompts for the number of troops and calls the sum method main() displays the sum of the digits main() does not permit negative numbers to be passed to the reverse method main() includes a sentinel controlled loop which allows the user to call the reverse method repeatedly	6 pts

  

Answer 1

For the following problem, we need to have following consideration in mind.

Following is the program for problem 1:

1. We need to make both the function recursive so the base cases and the recurrence relation for both the function are as follows.

   1. Base case: T(1) = 1

      Reccurrence: T(n) = T(n-1) + n*n*n

   2. Base case T(0) = 0

      Recurrence: T(n) = n%10 + T(n/10)

2. After this we need to make the main function for both the problems, have a sentinel and let it stop when user presses the -1.

import java.util.Scanner;

class Balls {
   public static int cannonballs(int n) {
      // Base case: T(1) = 1
      // Reccurrence: T(n) = T(n-1) + n*n*n
      // applying the recurrence relation in the code
      if(n == 1) {
         return 1;
      }else {
         return n*n*n + cannonballs(n-1);
      }
   }
   
   public static void main(String args[]) {
   
      Scanner scan = new Scanner(System.in);
      System.out.println("Enter number of layers");
      // taking input the first no. of layers
      int layers = scan.nextInt();
      while(layers != -1) {
         // check for negative layers
         if(layers < 0) {
            System.out.println("Enter the positive value");
            layers = scan.nextInt();
            continue;
         }
         // finding the number of balls using recursive method
         int balls = cannonballs(layers);
         // printing and asking for next layer
         System.out.println("Cannolballs for " + String.valueOf(layers) + " layers are: " + String.valueOf(balls));
         System.out.println("Enter next layer or -1 to exit");
         // taking input for the next layer
         layers = scan.nextInt();
         
      }
      
      System.out.println("Stopped");
   }
}

Following is the output after filling it the random numbers.

Following is the program to the problem 2:

import java.util.Scanner;

class Number {
   public static int sumDigits(int n) {
      // Base case T(0) = 0
      // Recurrence: T(n) = n%10 + T(n/10)
      // applying the recurrence relation in the code
      if(n==0) {
         return 0;
      }else {
         return n%10 + sumDigits(n/10);
      }
   }
   public static void main(String args[]) {
      
      Scanner scan = new Scanner(System.in);
      System.out.println("Enter a positive number");
      // taking input the number
      int number = scan.nextInt();
      while(number != -1) {
         // checking if the number entered is negative
         if(number < 0) {
            System.out.println("Enter the positive value");
            number = scan.nextInt();
            continue;
         }
         // calling the recursive function
         int sum = sumDigits(number);
         // printing the returned values
         System.out.println("Sum of Digits of the number " + String.valueOf(number) + " is: " + String.valueOf(sum));
         System.out.println("Enter next positive number or -1 to exit");
         // taking input for the next number
         number = scan.nextInt();
      }
      System.out.println("Stopped");
   }
}

After running the code i got the following output.

If you have any problem regarding understanding of the solution, do let me know in the comment section.

Thanks.