Question

Can you please help me with creating this Java Code using the following pseudocode?

Make Change Calculator (100 points + 5 ex.cr.)                                                                                                                                  2019

In this program (closely related to the change calculator done as the prior assignment) you will make “change for a dollar” using the most efficient set of coins possible. In Part A you will give the fewest quarters, dimes, nickels, and pennies possible (i.e., without regard to any ‘limits’ on coin counts), but in Part B you will re-do the program to give change from a specific number of available coins.

Part A: Basic Change for a dollar:

In this version of the program you will give change for up to a dollar in the most efficient manner (i.e., fewest number of coins of each type).

A sample run of the program might look as follows:

Welcome to the Make Change calculator!

What value would you like change for? (1-100 cents, or 0=quit): 23

For 23 cent(s) I give: 0 quarters, 2 dimes, 0 nickels, 3 pennies

What value would you like change for? (1-100 cents, or 0=quit): 1

For: 1 cent(s) I give: 0 quarters, 0 dime, 0 nickels, 1 pennies

What value would you like change for? (1-100 cents, or 0=quit): 100

For: 100 cent(s) I give: 4 quarters, 0 dime, 0 nickels, 0 pennies

What value would you like change for? (1-100 cents, or 0=quit): 0

Thanks for using the Make Change calculator!

Part A Required Elements: the following features must be present for full credit:

• Declare as global only those items that must be used across methods
• Minimize the code inside main, but include a loop so the user can enter change values multiple times (entry of a zero terminates the loop)
• Code a separate method to obtain and validate the input value as being from 0 to 100
  • Validation should include a try/catch structure to avoid crashing the program on non-integer input
• Code a separate method to determine and print the actual change returned

Part B: Perfect change with specific coin counts:

   The claim has been made that when receiving change for any amount up to and including $1 you can always make that change with only the following coins: 3 quarters, 1 dime, 2 nickels, and 5 pennies. You will write a program to test that assumption. To do this, you will add a method to the program that runs at the beginning to ask if a specific set of coins is being used (but note that the program may still run in the old way also).   The user will then have the option, during operation, to switch back and forth between using a ‘coin set’ or not (i.e., just running the Part A method). A sample run might be as follows:

Welcome to the Make Change calculator!

Do you have a specific set of coins for making change? (Y/N): Y

No. of Quarters: 3

No. of Dimes: 1

No. of Nickels: 2

No. of Pennies: 5

What value would you like change for? (1-100 cents, 101=New Coin set, or 0=quit): 23

For 23 cent(s) I give:

0 quarters, 1 dime, 2 nickels, 3 pennies leaving

3 quarters, 0 dime, 0 nickels, 2 pennies

What value would you like change for? (1-100 cents, 101=New Coin set, or 0=quit): 100

For: 100 cent(s) I give:

3 quarters, 1 dime, 2 nickels, 5 pennies leaving:

0 quarters, 0 dime, 0 nickels, 0 pennies

What value would you like change for? (1-100 cents, 101=New Coin set, or 0=quit): 101

Do you have a specific set of coins for making change? (Y/N): Y

No. of Quarters: 3

No. of Dimes: 1

No. of Nickels: 2

No. of Pennies: 2

What value would you like change for? (1-100 cents, 101=New Coin set, or 0=quit): 4

I could not make change for: 4 cents (I am short: 2 cents)

What value would you like change for? (1-100 cents, 101=New Coin set, or 0=quit): 0

Thanks for using the Make Change calculator!

In this version the ‘how much change’ question now has a new option: 101. If the user selects this option, the program should run the method that asks if a coin set is being used and, if the operator answers yes, then asks for the specific coin counts (i.e., the same method that now runs at the beginning of the program). If the operator says no, the program returns to the ‘Part A’ version (i.e., giving the fewest possible coins as change for $1).  

Now during operation, the program must know if a specific set of coins has been entered: if so, then a new method called ‘PerfectChange’ will be used to determine the coins to be given. This also means that the user may go back and forth between using a coin set and not. By using option 101 but answering ‘N’ to the ‘Do you have a specific set of coins’ the user effectively turns off the PerfectChange feature and returns to making change in the most efficient way possible.

Also note that in the ‘specific coins’ scenario, it is possible that perfect change cannot be given (see sample run above).

Call the program MakeChange.java and zip the finished netbeans project from the top-level folder. Submit it through blackboard as a separate zip file, as discussed in class.

Extra Credit (5 points):

Add another option to the ‘how much change’ question (i.e., add an item 102) that produces an ‘all’ output result. Thus, if the user enters 102, the program should loop to produce results for all values 1 through 100 (using the coin counts if entered or the original ‘most efficient’ method – whichever is currently selected in the program).   This option should not fundamentally modify any of the existing methods in the program, but merely add a new method to loop through all possible values from 1 – 100 (making use of the other program methods, as needed). New parameter passing may be needed for this operation, depending on program structure

--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

Make Change Program (Part A)

Imports:

                java.util.Scanner

Global Variables:

                Scanner sc – scanner object to read System.in

Methods:

                static void main(String[] args) – process control with loop for multiple runs

                static int getCents() – obtain and validate input of change being requested

                static void makeChange(int cents) – calculate and display coins given in change

Process:

                main(String[] args):

                                local variables: int cents – variable for change amount being requested

1. Display welcome message
2. getCents à cents
3. while loop on cents != 0
   1. makeChange(cents)
   2. getCents à cents
4. Display end message

                getCents():

                                local variables: int c – cents input value to return

1. do - loop to control input/validation process
   1. Try
      1. How much change? à c
      2. c < 0? à error message
      3. c > 100? à error message
   2. Catch
      1. Illegal input message
      2. Clear input buffer
      3. Set c to sentinel value (to force loop to repeat)

         while (c < 0 or c > 100)

2. return c;

makeChangeAddMethod(int cents):

                local variables: int q,d,n,p – for quarters, dimes, nickels, pennies to give

                                                int t – working variable for total cents

1. set all variables = 0
2. Determine Quarters to give:
   1. While (t+25) <= cents:
      1. q = q + 1;
      2. t = t + 25;
3. Determine Dimes to give:
   1. While (t+10) <= cents:
      1. d = d + 1;
      2. t = t + 10;
4. Determine Nickels to give:
   1. While (t+5) <= cents:
      1. n = n + 1;
      2. t = t + 5;
5. Pennies to give = any amount left:
   1. P = cents – t;
6. Print results

makeChangeDivMethod(int cents):

                local variables: int q,d,n,p – for quarters, dimes, nickels, pennies to give

                                                int r – working variable for ‘remaining cents’ to give

7. set r = cents
8. Determine Quarters to give:
   1. q = r / 25 (integer division)
   2. adjust r to new remaining value: r = r – (q * 25)
9. Repeat step 2 for dimes, nickels (in that order)
10. Remaining r after step 3 is given as pennies
11. Print results

Part B

Global Variables:

                Add: int qoh, doh, noh, and poh for Quarters-on-Hand, Dimes-on-Hand, Nickels-on-Hand, and Pennies-on-Hand

Methods:

                Add: boolean getCoinSet() – to determine if a coinset is being used and

to validate and return coins on hand for each ‘cointype’ (if yes)

                Add: int getCoins(String cointype) – to obtain a specific value for a type of coin on hand

Specific method changes:

main():

1. Add logic to call getCoinSet() returning a Boolean if a coinset is used
2. Modify while loop to call makechange if no coinset but to call ‘perfectChange’ if a coinset is being used.

Boolean getCoinSet():

1. Ask: does user have a coinset?
2. No:
   1. Set Boolean return value to false
   2. Set all ‘on hand’ variables to zero
3. Yes:
   1. Set Boolean return value to true
   2. Qoh = Call to getCoins(“Quarters”)
   3. Repeat for all other coin types

Int getCoins(String cointype):

                Code is virtually the same as getCoins method from prior assignment (calcChange)

perfectChange(int cents):

                Changes to algorithm: basic process is the same, except after determining each coin count, value must be checked against coins on hand, and adjusted accordingly. So, for prior step 2 you would now have:

Determine Quarters to give:

1. q = r /25 (integer division)
2. if q > qoh, adjust q to equal qoh
3. adjust r as: r = r – (q * 25)

The final step (print results) must also check that r has been worked down to zero: if not, perfect change could not be given from the available set of coins.

Answer 1

import java.util.*;
class ChangeMaker
{
static int quarters;
static int dimes;
static int pennies;
static int nickels;
public static void makeChange(int cents)
{
quarters = cents / 25;
cents %= 25;
dimes = cents / 10;
cents %= 10;
nickels = cents / 10;
cents %= 5;
pennies = cents;
}
public static void main(String[] args)
{
System.out.println("Welcome to the Make Change calculator!");
System.out.print("What value would you like change for? (1-100 cents, or 0=quit): ");
Scanner sc = new Scanner(System.in);
int cents = sc.nextInt();
while(cents != 0)
{
makeChange(cents);
System.out.println("For " + cents + " cent(s) I give: " + quarters + " quarters, " + dimes + " dimes, " + nickels + " nickels, " + pennies + " pennies");
System.out.print("What value would you like change for? (1-100 cents, or 0=quit): ");
cents = sc.nextInt();
}
}
}