Question

a) Read the problem statement. b) Formulate the algorithm using pseudocode and top-down, stepwise refinement. c) Write a Java program. d) Test, debug and execute the Java program. e) Process three complete sets of data. Drivers are concerned with the mileage their automobiles get. One driver has kept track of several tankfuls of gasoline by recording the miles driven and gallons used for each tankful. Develop a Java application that will input the miles driven and gallons used (both as integers) for each tankful. The program should calculate and display the miles per gallon obtained for each tankful and print the combined miles per gallon obtained for all tankfuls up to this point. All averaging calculations should produce floating-point results. Use class Scanner and sentinel-controlled repetition to obtain the data from the user.

Short answer

The Java program calculates the miles per gallon for each tankful and cumulatively using sentinel-controlled input.

Step-by-step solution

Understand the Problem

We need to develop a Java program that calculates and displays the miles per gallon (MPG) for each tankful and the combined MPG for all tankfuls. The program will input the miles driven and gallons used for each tankful.

Formulate the Algorithm using Pseudocode

1. Initialize total miles and total gallons to zero. 2. Repeat until sentinel value (e.g., -1) is entered: a. Input miles driven and check for sentinel value. b. Input gallons used. c. If gallons are not zero, calculate MPG for the tankful as miles/gallons. d. Print the MPG for the tankful. e. Add miles to total miles and gallons to total gallons. f. Calculate combined MPG as total miles/total gallons. g. Print the combined MPG so far.

Write the Java Program

```java import java.util.Scanner; public class MileageCalculator { public static void main(String[] args) { Scanner input = new Scanner(System.in); int totalMiles = 0; int totalGallons = 0; while (true) { System.out.print("Enter miles driven (-1 to quit): "); int miles = input.nextInt(); if (miles == -1) break; System.out.print("Enter gallons used: "); int gallons = input.nextInt(); if (gallons != 0) { double mpg = (double) miles / gallons; System.out.printf("Miles per gallon for this tank: %.2f%n", mpg); totalMiles += miles; totalGallons += gallons; double combinedMpg = (double) totalMiles / totalGallons; System.out.printf("Combined miles per gallon: %.2f%n", combinedMpg); } else { System.out.println("Gallons cannot be zero."); } } input.close(); } } ```

Test and Debug the Java Program

Execute the program and input multiple sets of miles driven and gallons used. Verify that the output correctly displays both the MPG for each tankful and the combined MPG. Check edge cases, such as negative values or zero gallons.

Process Three Complete Sets of Data

Run the Java program three times with different inputs to ensure it handles varied data correctly. Example inputs could be: (200 miles, 10 gallons), (300 miles, 15 gallons), (250 miles, 12 gallons). Review if results are accurate and program handles each scenario as expected.

Key concepts

Miles Per Gallon Calculation

The task of calculating miles per gallon (MPG) involves determining how many miles a vehicle can travel using one gallon of gasoline. This is important for drivers to assess fuel efficiency.
In simple terms, the formula to find MPG is:

• MPG = Miles Driven ÷ Gallons Used

To calculate this for multiple tankfuls, you perform this calculation individually for each tank and then compute a combined MPG for all tankfuls.
This helps evaluate the overall efficiency over a period of driving.

In the given exercise, the program reads inputs for miles driven and gallons used for each tankful, calculates the MPG per tankful, and displays it. Additionally, it aggregates these values to show the combined efficiency, important for a big-picture understanding of fuel efficiency.

Pseudocode Algorithm

Before writing actual code, creating a pseudocode is a crucial step. Pseudocode is a plain language description of the steps to solve a problem.

It bridges the gap between the problem statement and the actual code, providing a structured approach to programming. In this exercise, the pseudocode helps outline the logic needed to calculate MPG with each tankful and overall miles.

The key steps in the pseudocode algorithm for our problem can be outlined as:

• Initialize total miles and total gallons to zero.
• Loop until the sentinel value is entered.
• Input miles driven and check if it's the sentinel value.
• Input gallons used. If not zero, calculate MPG for the current tank and display it.
• Update total miles and total gallons. Calculate and display combined MPG.

The pseudocode acts as a blueprint, guiding the structure and flow of the eventual Java program.

Scanner Class in Java

The Scanner class in Java is part of the `java.util` package and is utilized to read input data more easily from various input sources such as keyboard input.
In this particular exercise, the Scanner class is used to allow the user to input miles driven and gallons used directly into the program during its execution.

This approach simplifies data entry for the user and keeps the program interactive. A Scanner object is created and associated with `System.in` to read input from the keyboard.

• Example: `Scanner input = new Scanner(System.in);`
• The `nextInt()` method is used to read integer inputs, critical for accepting miles and gallons in this problem.

At the end of input operations, it is a good practice to call the `close()` method on a Scanner object to free up the resources.

Sentinel-Controlled Loop

A sentinel-controlled loop is a repetition structure used to perform operations until a predetermined value, known as the sentinel value, is encountered. This is commonly used when the number of iterations is not known beforehand.

In the problem exercise, a sentinel value of `-1` is used. This signals to the program that it should terminate the loop and stop requesting further input.

• Example usage: `while (true) { ... if (miles == -1) break; ... }`

The advantage of using a sentinel-controlled loop is its simplicity and flexibility to process an unknown amount of data until the user wishes to exit by entering the sentinel, ensuring user-controlled termination.

Floating-Point Arithmetic

Floating-point arithmetic is used in programming to handle numbers that require decimal precision. This is essential when it's important to maintain accuracy in calculations involving fractions or real numbers.

In the MPG calculation task, floating-point arithmetic allows the program to calculate and display the MPG as a decimal number, such as 24.35, instead of truncating to integer values.

To achieve this, results are explicitly cast to a double type, ensuring precision.
In Java, this can be done using syntax like:

• `double mpg = (double) miles / gallons;`
• Ensuring a precision output with `System.out.printf("%.2f", mpg);` for formatting.

Floating-point operations are powerful as they allow for more detailed calculations, although they might introduce slight precision errors due to the way computers handle floating-point math.