Question

Perform each of these steps: a. Read the problem statement. b. Formulate the algorithm using pseudocode and top-down, stepwise refinement. c. Write a \(C++\) program. d. Test, debug and execute the \(C++\) program. One large chemical company pays its salespeople on a commission basis. The salespeople each receive \(\$ 200\) per week plus 9 percent of their gross sales for that week. For example, a salesperson who sells \(\$ 5000\) worth of chemicals in a week receives \(\$ 200\) plus 9 percent of \(\$ 5000,\) or a total of \(\$ 650 .\) Develop a \(\mathrm{C}++\) program that uses a while statement to input each salesperson's gross sales for last week and calculates and displays that salesperson's earnings. Process one salesperson's figures at a time.

Short answer

Use a loop to calculate and display earnings from weekly sales inputs.

Step-by-step solution

Problem Understanding

We need to create a program that calculates the earnings of a salesperson based on their weekly sales. The salesperson earns a base pay of $200 per week plus 9% of their weekly sales. Our program will take inputs of sales figures and output earnings until there are no more sales figures to input.

Algorithm Formulation

Formulating the algorithm involves creating pseudocode which helps to outline the program. Here's the breakdown: 1. Initialize the base pay to $200. 2. Repeat these steps until there are no more sales: - Prompt the user to input gross sales of salesperson. - Calculate earnings as base pay plus 9% of the gross sales. - Display the calculated earnings.

Pseudocode Design

The pseudocode for the problem can be designed as follows: ``` 1. Initialize BASE_PAY to 200. 2. While there are more sales data to process: a. Read input for grossSales. b. If grossSales is less than 0, exit loop. c. Compute earnings as BASE_PAY + 0.09 * grossSales. d. Output earnings. ```

Write a C++ Program

``` #include using namespace std; int main() { const double BASE_PAY = 200.0; double grossSales, earnings; cout << "Enter sales in dollars (-1 to end): "; cin >> grossSales; while (grossSales != -1) { earnings = BASE_PAY + 0.09 * grossSales; cout << "Earnings for the week: $" << earnings << endl; cout << "Enter sales in dollars (-1 to end): "; cin >> grossSales; } return 0; } ```

Test and Debug the Program

To test the program: 1. Run the program and input sample sales figures like 5000, 3000, and -1. 2. Verify the outputs correspond to calculated earnings of $650 and $470. 3. Ensure the program exits correctly when entering -1.

Key concepts

Pseudocode Development

Pseudocode is a powerful tool for planning a program and is written in plain human language. It bridges the gap between problem understanding and coding by converting a problem solution into a series of detailed steps without worrying about syntax. This method allows programmers to focus on the logic and structure of a problem before coding.

In our exercise, the pseudocode for calculating a salesperson's commission begins with defining the base pay and then iteratively processing sales data. This example highlights the pseudocode's role in ensuring each step is clear:

• Initialize a constant base pay.
• Continuously read sales data entered by the user.
• Calculate earnings by adding base pay and commission, and display result.
• Include an exit condition for the loop when no more data is available.

Choosing pseudocode for initial planning helps avoid potential errors and lays a solid foundation for the actual programming phase.

Algorithm Formulation

Algorithm formulation involves defining a clear set of instructions to solve a problem, in this case, calculating commission-oriented earnings. It focuses on identifying key processes, decisions, and calculations required to achieve the correct results.

The algorithm is methodically formulated as follows:

• Begin with a fixed base pay set at $200.
• Use a loop to process sales figures sequentially.
• Prompt the user for gross sales input, checking for a termination condition in each iteration.
• Calculate total earnings as base pay plus 9% of gross sales.
• Display the computed earnings, then request the next sales figure.

This careful step-by-step planning is fundamental for ensuring that the program's computations and flow align with the problem statement and objectives.

Commission Calculation

Calculating a salesperson's earnings requires applying percentage mathematics to determine how much commission they earn on their sales. This part of the program involves precise calculations with both fixed and variable components.

In our program, each salesperson receives a base salary of \(200 per week, regardless of sales. The commission adds another layer. For each sales input:

• Calculate the commission as 9% of the gross sales amount.
• Add this commission to the base pay to get total earnings.
• For instance, with \)5000 in sales: \[ \text{Earnings} = 200 + (0.09 \times 5000) = 200 + 450 = 650 \]

Accurate calculation ensures reliable output, rewarding salespeople correctly based on performance.

Program Debugging

Debugging is an essential part of the program development process. It involves identifying and fixing errors in both logic and syntax to ensure the program runs smoothly as expected. Debugging helps to refine the program and enhance its reliability.

In this exercise, debugging focuses on:

• Ensuring inputs are handled correctly, exiting the loop upon receiving -1.
• Checking for math errors in the commission calculation to confirm correct earnings display.
• Making sure the program handles various input scenarios accurately, such as different sales amounts or incorrect entries.

Using test cases such as $5000 and $3000 helps validate that the program outputs expected earnings of $650 and $470, respectively. Regular debugging and testing streamline the program and guarantee it performs its intended functionality seamlessly.