Question

Need help figuring this out

Write a program that reads in a sequence of numbers (doubles) from standard input until 0 is read, and stores them in an array, This part is done using iteration (loop). You may assume that the maximum size of the array will not be more than 100.

Your program computes the maximum number stored in the array, the count of negative numbers, and computes the sum of positive numbers, using recursion.

You need to have the following recursive methods findMax,  countNegative, and computeSumPositive in the class and they will be called in the main method.

Specifically, the following recursive methods must be implemented (You should not use loops to implement the following methods):

           public static double findMax(double[] numbers, int count)

     //finds the maximum number in the array, count is the number of numbers stored in the array

     public static int countNegative(double[] numbers, int count) -> returns the count of negative numbers

     public static double computeSumPositive(double[] numbers, int count) -> returns the sum of positive numbers

Do not implement using loops, do not use any static variables either.

The program should output the results of those calculations to standard output. Your program will continue to read in numbers until the number 0 is entered. At this point, the calculations will be outputted in the following format:

The maximum number is 0.##
The total number of negative numbers is 0
The sum of positive numbers is 0.##

To format numbers as above, you should use the DecimalFormat class (java.text package).

Do not prompt the user for the numbers.

Answer 1

Dear student , please find the solution below.

Please feel free to ask any doubt in comment section.

import java.util.Scanner;

public class NOV11 {

   //Maximum number stored in the array
   public static double findMax(double[] numbers, int len) {
       if (len == 1) {
           return numbers[0];
       } else {
           return Math.max(numbers[len - 1], findMax(numbers, len - 1));
       }
   }

   // Count of negative numbers
   public static int countNegative(double[] arr, int n, int count) {

       if (n < 0) {
           return count;
       }

       // If current element is negative then increase the count
       if ((arr[n]) < 0) {
           count++;
       }

       return countNegative(arr, n - 1, count);
   }

   // Computes the sum of positive numbers, using recursion
   public static double computeSumPositive(double[] arr, int len) {

       if (len == 0)
           return 0;
       else {
           // Using ternary operator ,finding +ve numbers
           return ((arr[len - 1] >= 0 ? arr[len - 1] : 0) + computeSumPositive(
                   arr, len - 1));
       }
   }

   // Driver Code
   public static void main(String[] args) {

       Scanner in = new Scanner(System.in);
       double[] userInputArr = new double[100];
       int i = 0;
       double val;

       for (i = 0; i < 100; i++) {

           val = in.nextDouble();

           if (val == 0d) {
               break;
           } else {
               userInputArr[i] = val;
           }
       }
      
       // Closing scanner class
       in.close();

       System.out.println("Sum of positive numbers : "
               + computeSumPositive(userInputArr, userInputArr.length));
       System.out.println("Count of negative numbers : "
               + countNegative(userInputArr, userInputArr.length - 1, 0));
       System.out.println("Max Number : "
               + findMax(userInputArr, userInputArr.length));
   }
}