Diving score array program

Question

I have a dive scoring program. However, I am having difficulty getting the lowest score and handling the input after an error has been made. Could someone advise? Thank you for any help you could give. Yours truly, Quang Pham

 Is there code to get the lowest and highest scores?  How come I get 0 for the lowest score instead of 5?  Also, after an error is made, can the user reenter a different score and get the correct answer?   divingScores[i - 1] = divingScores[i];  Is there a way to go back on an array and enter another value?  The dive scoring program takes the evaluative scores of seven judges and arrives at a final score for a dive. Any help is most greatly appreciated.

Problem Description: *
* In the sport of diving, seven judges award a score between 0 and 10, * where each score may be a floating-point value. The highest and lowest * scores are thrown out and the remaining scores are added together. The * sum is then multiplied by the degree of difficulty for that dive. (The * degree of difficulty ranges from 1.2 to 3.8 points.) The total is then * multiplied by 0.6 to determine the diver’s score. * Write a program that asks a user to enter a dive's degree of difficulty * and seven judges’ scores, then displays the overall score for that dive. * The program should ensure that all inputs are within the allowable data * ranges. * The judges scores should be stored in array. * Please perform error checking on all user entries (degree of * difficulty and each judge's score), verifying that the entry from the * user is between a minimum and maximum values. * A sample dialog is given below: * * ** Diving Score Calculator ** * * Enter the score from Judge #1 (0 – 10): 5 * Enter the score from Judge #2 (0 – 10): 8.5 * Enter the score from Judge #3 (0 – 10): 7 * Enter the score from Judge #4 (0 – 10): 11 * ** Please enter a number from 0 to 10. * Enter the score from Judge #4 (0 – 10): 10 * Enter the score from Judge #5 (0 – 10): 9.9 * Enter the score from Judge #6 (0 – 10): 8.1 * Enter the score from Judge #7 (0 – 10): 6.3 * Enter the degree of difficulty (1.2 – 3.8): 4 * ** Please enter a number from 1.2 to 3.8). * Enter the degree of difficulty (1.2 – 3.8): 3.3
* * The total of all scores: 54.8 * Minus high and low: 39.8 * Final Score: 78.80 *

import java.util.Scanner ;
/**
 * The dive scoring program takes the evaluative scores of seven judges and 
 * arrives at a final score for a dive.
 *
 * @author Quang Pham
 * @version Module8, Homework Project 1, 4/1/20
 * 
 *    Algorithm:
 *    
 *    1. Seven judge's scores are entered into an array.
 *    2. The scores are checked to see if they are between the minimum and
 *       maximum values.
 *    3. The total of all the scores, the degree of difficulty, the scores 
 *       minus the high and low scores, and the final score are outputted.
 *    
 *    
 *    Problem Description:
 *    
 *        In the sport of diving, seven judges award a score between 0 and 10,
 *   where each score may be a floating-point value.  The highest and lowest 
 *   scores are thrown out and the remaining scores are added together.  The 
 *   sum is then multiplied by the degree of difficulty for that dive.  (The 
 *   degree of difficulty ranges from 1.2 to 3.8 points.)  The total is then 
 *   multiplied by 0.6 to determine the diver’s score.
 *        Write a program that asks a user to enter a dive's degree of difficulty
 *   and seven judges’ scores, then displays the overall score for that dive.
 *   The program should ensure that all inputs are within the allowable data 
 *   ranges.
 *        The judges scores should be stored in array.
 *        Please perform error checking on all user entries (degree of 
 *   difficulty and each judge's score), verifying that the entry from the
 *   user is between a minimum and maximum values.
 *        A sample dialog is given below:
 *
 *       ** Diving Score Calculator **
 *
 *   Enter the score from Judge #1 (0 – 10): 5
 *   Enter the score from Judge #2 (0 – 10): 8.5
 *   Enter the score from Judge #3 (0 – 10): 7
 *   Enter the score from Judge #4 (0 – 10): 11
 *       ** Please enter a number from 0 to 10. 
 *   Enter the score from Judge #4 (0 – 10): 10
 *   Enter the score from Judge #5 (0 – 10): 9.9
 *   Enter the score from Judge #6 (0 – 10): 8.1
 *   Enter the score from Judge #7 (0 – 10): 6.3
 *   Enter the degree of difficulty (1.2 – 3.8): 4
 *       ** Please enter a number from 1.2 to 3.8).
 *   Enter the degree of difficulty (1.2 – 3.8): 3.3  
 *
 *   The total of all scores:  54.8
 *   Minus high and low:       39.8
 *   Final Score:              78.80
 *
 *        Format your final score to 2 digits.  You may write this assignment
 *   as a single class, where you use helper (private) methods to main instead 
 *   of putting them in a separate class.
 *        Test your program with several different input dives and print
 *   screen or screen snip of the results.
 *    
 */
public class DiveScoringProgram {
    public static void main(String[] args) {

        Scanner keyboard = new Scanner(System.in);

        double divingScores[] = new double[7] ;
        double input ;
        double difficultyInput = 0 ;
        double high = 0 ;
        double low = 0 ;
        double totalAllScores = 0 ;
        double totalMinusHighLow = 0 ;
        double totalFinalScore = 0 ;
        double Arrays = 0 ;

        for (int i = 0; i < divingScores.length; i++) 
        {
            System.out.println("Enter the score from Judge #" + (i + 1) + " (0-10):  ") ;
            input = keyboard.nextDouble();

            if(input < 0 || input > 10) 
            {
                System.out.println("Invalid score.  Please enter a number from 0 to 10") ;
                divingScores[i - 1] = divingScores[i];
                input = keyboard.nextDouble() ;
            }
            else 
            {
                totalAllScores += input ; 
                divingScores[i] = input;
            } 
        }

        while (difficultyInput < 1.2 || difficultyInput > 3.8) 
        {
            System.out.println("Enter the degree of difficulty (1.2- 3.8):  ") ;
            difficultyInput = keyboard.nextDouble() ;
            if (difficultyInput < 1.2 || difficultyInput > 3.8)
            {
                System.out.println("Invalid difficulty input.  Please enter a number from 1.2 to 3.8.") ;
                difficultyInput = keyboard.nextDouble() ;
            }
        }
        //determine high and low values 
        for(int i = 0; i < divingScores.length; i++)
        {
            if(divingScores[i] > high)
            {high = divingScores[i];}
            if(divingScores[i] < low)
            {low = divingScores[i];}
        }

        System.out.println("low is " + low) ;
        System.out.println("high is " + high) ;

        totalMinusHighLow = totalAllScores - high - low ;
        totalFinalScore = totalMinusHighLow * difficultyInput * 0.6 ;

        System.out.println("The total of all scores:  " + totalAllScores) ;
        System.out.println("Minus high and low:  " + totalMinusHighLow) ;
        System.out.printf("The overall final score for the dive: %.2f\n", totalFinalScore);

    } //end main
} //end class

Answer 1

I will try to break this down as much as possible while I refactor your code. Kindly read the code comments for explanation.

/** Diving Score Calculator **/

// For easier understanding, let's re-declare your variables 
// making sure their names are related to the logic at hand 
// because this is where I think most of your problem started.

////Constants
final int MIN_SCORE = 0;
final int MAX_SCORE = 10;
final int JUDGE_COUNT = 7;
final float MIN_DIFFICULTY = 1.2f;
final float MAX_DIFFICULTY = 3.8f;
final float SCORE_DETERMINANT = 0.6f;
//// Non-constants
float[ ] diver_scores;
float sum_total, sum_high_low;
float diff_total_high_low, final_score;
float difficulty;

//// Initialize the non-constants using helper methods
// Get the array of scores by judges from the user
diver_scores = getDiverScores(MIN_SCORE, MAX_SCORE, JUDGE_COUNT);
// Get the sum of all values in the array
sum_total = getSumTotal(diver_scores);
// Get the sum of highest and lowest score in the array
sum_high_low = getSumHighLow(diver_scores);
// Subtract the highest and lowest score from total score
diff_total_high_low = sum_total - sum_high_low;
// Get the difficulty level from the user
difficulty = getDifficulty(MIN_DIFFICULTY, MAX_DIFFICULTY);
// Calculate final score
final_score = getFinalScore(diff_total_high_low, difficulty, SCORE_DETERMINANT);
// Print out the results
System.out.println("The total of all scores: %.1f", sum_total) ;
System.out.println("Minus high and low: %.1f", diff_total_high_low) ;
System.out.printf("Final score: %.2f", final_score);

... Your helper methods

public float[] getDiverScores(int min, int max, int count){
   float[] scores = new float[count];
   for(int i = 0; i < count; i++){
      float score = getInputScore(i+1)
      while (score < min || score > max){
         // User entered an invalid range for score
         // Show error message
         System.out.println("    ** Please enter a number from %d to %d", min, max);
         // Request for score again
         score = getInputScore(i+1);
       }
      scores[i] = score;
    }
    return scores;
}

public float getInputScore(int index){
  Scanner keyboard = new Scanner(System.in);
  System.out.println("Enter the score from Judge #" + (index) + " (0-10):  ");
  // Get and return inputted value from the user
  return keyboard.nextFloat();
 }

public float getSumTotal(float[ ] scores){
  // Sum array using helper method from java8
  return java.util.stream.FloatStream.of(scores).sum();
}

public float getSumHighLow(float [ ] scores){
  Arrays.sort(scores);
  // Sum the highest and lowest values
  return scores[0] + scores[scores.length - 1];
}

public float getDifficulty(float min, float max){
  float level = getInputDifficulty();
  while (level < min || level > max){
      System.out.println("    ** Please enter a number from %.1f to %.1f", min, max);
       level = getInputDifficulty();
   }
   return level;
}

public float getInputDifficulty(float min, float max){
  Scanner keyboard = new Scanner(System.in);
  System.out.println("Enter the degree of difficulty (%.1f - %.1f):  ", min, max);
  // Value from the user
  return keyboard.nextFloat();
 }

public float getFinalScore(float diff, float difficulty, float dter){
   return diff * difficulty * dter;
}

Answer 2

My fixed answer is (however, I'm open to suggestions):

import java.util.Scanner ;
/**
 * The dive scoring program takes the evaluative scores of seven judges and 
 * arrives at a final score for a dive.
 *
 * @author Quang Pham
 * @version Module8, Homework Project 1, 4/1/20
 * 
 *    Algorithm:
 *    
 *    1. Seven judge's scores are entered into an array.
 *    2. The scores are checked to see if they are between the minimum and
 *       maximum values.
 *    3. The total of all the scores, the degree of difficulty, the scores 
 *       minus the high and low scores, and the final score are outputted.
 *    
 *    
 *    Problem Description:
 *    
 *        In the sport of diving, seven judges award a score between 0 and 10,
 *   where each score may be a floating-point value.  The highest and lowest 
 *   scores are thrown out and the remaining scores are added together.  The 
 *   sum is then multiplied by the degree of difficulty for that dive.  (The 
 *   degree of difficulty ranges from 1.2 to 3.8 points.)  The total is then 
 *   multiplied by 0.6 to determine the diver’s score.
 *        Write a program that asks a user to enter a dive's degree of difficulty
 *   and seven judges’ scores, then displays the overall score for that dive.
 *   The program should ensure that all inputs are within the allowable data 
 *   ranges.
 *        The judges scores should be stored in array.
 *        Please perform error checking on all user entries (degree of 
 *   difficulty and each judge's score), verifying that the entry from the
 *   user is between a minimum and maximum values.
 *        A sample dialog is given below:
 *
 *       ** Diving Score Calculator **
 *
 *   Enter the score from Judge #1 (0 – 10): 5
 *   Enter the score from Judge #2 (0 – 10): 8.5
 *   Enter the score from Judge #3 (0 – 10): 7
 *   Enter the score from Judge #4 (0 – 10): 11
 *       ** Please enter a number from 0 to 10. 
 *   Enter the score from Judge #4 (0 – 10): 10
 *   Enter the score from Judge #5 (0 – 10): 9.9
 *   Enter the score from Judge #6 (0 – 10): 8.1
 *   Enter the score from Judge #7 (0 – 10): 6.3
 *   Enter the degree of difficulty (1.2 – 3.8): 4
 *       ** Please enter a number from 1.2 to 3.8).
 *   Enter the degree of difficulty (1.2 – 3.8): 3.3  
 *
 *   The total of all scores:  54.8
 *   Minus high and low:       39.8
 *   Final Score:              78.80
 *
 *        Format your final score to 2 digits.  You may write this assignment
 *   as a single class, where you use helper (private) methods to main instead 
 *   of putting them in a separate class.
 *        Test your program with several different input dives and print
 *   screen or screen snip of the results.
 *    
 */
public class DiveScoringProgram {
    public static void main(String[] args) {

        Scanner keyboard = new Scanner(System.in);

        double divingScores[] = new double[7] ;
        double input ;
        double difficultyInput = 0 ;
        double highest = 0 ;
        double lowest = 10 ;
        double totalAllScores = 0 ;
        double totalMinusHighLow = 0 ;
        double totalFinalScore = 0 ;
        double Arrays = 0 ;

        for (int i = 0; i < divingScores.length; i++) 
        {
            System.out.println("Enter the score from Judge #" + (i + 1) + " (0-10):  ") ;
            input = keyboard.nextDouble();

            if(input < 0 || input > 10) 
            {
                System.out.println("Invalid score.  Please enter a number from 0 to 10") ;
                input = keyboard.nextDouble() ;
                divingScores[i] = input ;
            }
            //else 
            {
                totalAllScores += input ; 
                divingScores[i] = input;
            } 
        }

        while (difficultyInput < 1.2 || difficultyInput > 3.8) 
        {
            System.out.println("Enter the degree of difficulty (1.2- 3.8):  ") ;
            difficultyInput = keyboard.nextDouble() ;
            if (difficultyInput < 1.2 || difficultyInput > 3.8)
            {
                System.out.println("Invalid difficulty input.  Please enter a number from 1.2 to 3.8.") ;
                difficultyInput = keyboard.nextDouble() ;
            }
        }
        //determine high and low values 
        for(int i = 0; i < divingScores.length; i++)
        {
            if(divingScores[i] > highest)
            {highest = divingScores[i] ;}
        }

        for(int i = 0; i < divingScores.length; i++)
        {
            if(divingScores[i] < lowest)
            {lowest = divingScores[i] ;}
            System.out.println(" " + divingScores[i] + " ");
        }

        System.out.println("highest is " + highest) ;
        System.out.println("lowest is " + lowest) ;

        totalMinusHighLow = totalAllScores - highest - lowest ;
        totalFinalScore = totalMinusHighLow * difficultyInput * 0.6 ;

        System.out.println("The total of all scores:  " + totalAllScores) ;
        System.out.println("Minus high and low:  " + totalMinusHighLow) ;
        System.out.printf("The overall final score for the dive: %.2f\n", totalFinalScore);

    } //end main
} //end class