Java Programming Exercises part 3 : 10 Questions

Stopping Distance *:

If you follow too close behind another car and that other car stops suddenly, you will not be able to stop in time, and you will crash into the rear of that other car. The following formula gives the distance between you and the car in front which allows you to stop safely:

stoppingDistance = speed * (2.25 + speed / 21)

a)  Write a program which determines whether a vehicle’s tailgating distance is safe. The program should read in the speed of the vehicle and the vehicle’s tailgating distance. The program should then calculate the distance that would be required to stop the vehicle. 

If the stopping distance is less than the tailgating distance, your program should print “No problem.” If the stopping distance equals the tailgating distance, your program should print “Minor wreck.” If the stopping distance is greater than the tailgating distance, your program should print “Major wreck!”

Notice that the expression on the right side of the formula above will force the compiler to convert everything to type double. Use type double for your working variables.

Write your program so that it is able to produce the following screen display:

Sample session:

Enter your speed (in mph): 60.0
Enter your tailgate distance (in feet): 240.0
Major wreck!

b)  Notice that one of the tests is a comparison for equality. Since the probability of two real numbers being exactly equal is zero, if you use floating point numbers there will never be an input that produces a minor wreck. Modify the program so that it allows a range of uncertainty of plus or minus 20 feet, within which the result will be a minor wreck. To facilitate adjustment of this range of uncertainty, use a named constant, that is:

RANGE = 40.0


Column Safety **:

In designing a building, structural engineers must determine whether each of the building’s support columns is thick enough to support the column’s expected load. Assume the column is wooden and has a solid square cross section. To be safe, all three of these conditions must be met:

• The column should be sufficiently thick, that is: 
height / width ≤ 50, where 50 is a special value called the slenderness limit,

• To prevent the column from buckling, make sure this requirement is met:
expected load ≤ (0.3*E*area) / (height/width)2,
where E = 1,700,000 psi is a special value called the modulus of elasticity.

• To prevent the column from compressing, make sure this requirement is met:
expected load ≤ area * stress,
where stress = 1450 psi = maximum allowable stress parallel to the grain.

In the above formulas,
height is the height of the column in inches,
width is the width of the beam in inches, and
area = cross-sectional area = width * width.

a)  [after §4.3] Evaluation:

Write a program that determines whether a wooden column with a given height is thick enough to support a given expected load. More specifically, read in height, width, and expected load values and then print “The column is safe.” or “The column is unsafe.” Use named constants for slenderness limit, modulus of elasticity, and maximum stress. In the sample sessions, note that the user enters height in units of feet, whereas the formulas require height in units of inches.

Sample session:

Enter column width in inches: 4.0
Enter column height in feet: 15.0
Enter expected load in pounds: 5000.0
The column is unsafe.

Another sample session:

Enter column width in inches: 5
Enter column height in feet: 15
Enter expected load in pounds: 5000
The column is safe.

b)  [after §4.9] Design:

Create a separate program that enhances your original program. Your enhanced program should calculate the minimum safe column width for a given height and expected load. After inputting the height and expected load, your program must use a loop to test and increment column width values until a satisfactory width is reached. Consider only standard American widths. The smallest standard width is .625”. The next standard widths are 1.625", 3.625", 5.625", 7.625”, and so on, with larger widths at 2” intervals.

Background information: You should use the widths shown above for your program. Those widths are actual widths. They correspond to the “nominal” widths of 1”, 2”, 4”, 6”, 8”, and so on. Nominal widths are what you ask for in a lumber store, and actual widths are what you get. Nominal width values refer to the width of the rough-cut boards, whose size is reduced due to drying and planing.

Sample session:

Enter column height in feet: 15.0
Enter expected load in pounds: 5000.0
Square column width = 5.625 inches


Economic Policy *:

The following rules illustrate traditional economic policy theory in terms of regulating a government’s economy.

a)  If the annual growth rate is less than 1%:
• If inflation is less than 3%, recommended economic policy is:
Increase welfare spending, reduce personal taxes, and decrease discount rate.
• Otherwise, recommended economic policy is:
Reduce business taxes.

b)  If the annual growth rate is greater than 4%:
• If inflation is less than 1%, recommended economic policy is:
Increase personal and business taxes, and decrease discount rate.
• If inflation is greater than 3%, recommended economic policy is:
Increase discount rate.

Write a program that applies these economic policy practices. More specifically, read in growthRate and inflation values and output the recommended economic policy for the given economic situation. If there is no recommended economic policy for the given economic situation, then output “No change in economic policy.”


Bank Balance **:

The First National Bank of Parkville recently opened up a new “So You Want to Be a Millionaire” savings account. The new account works as follows:

• The bank doubles the customer’s balance every year until the customer’s balance reaches one million.
• The customer isn’t allowed to touch the money (no deposits or withdrawals) until the customer’s balance reaches one million.
• If the customer dies before becoming a millionaire, the bank keeps the customer’s balance.
• Note: Customers close to $1,000,000 tend to get “accidentally” run over in the bank’s parking lot.

Write a program that prompts the user for a starting balance and then prints the number of years it takes to reach $100,000 and also the number of years it takes to reach $1,000,000.

Sample session:

Enter starting balance: 10000
It takes 4 years to reach $100,000.
It takes 7 years to reach $1,000,000.


Game of NIM ***:

Write a program that plays the ancient Chinese game of NIM. Actually, this is a simplified version of the game. Each game starts with a user-specified number of stones in a pile. The user and the computer take turns removing either one or two stones from the pile. The player who takes the last stone loses. Your program should have the computer use the optimal playing strategy. The optimal strategy is as follows:

Divide the remaining number of stones by three. If the remainder is zero, then two stones are removed, or else one stone is removed. For example, if the remaining number of stones is nine or fifteen, then two stones are removed; if the remaining number of stones is eight or ten, then one stone is removed.

a)  [after §4.9] Your program should allow the user to play additional games of NIM as long as he/she enters a “y” or “yes” (lowercase or uppercase) in response to a “Do you want to play again?” prompt. See the sample session for required wording.

Sample session:

T H E   G A M E   O F   N I M  Enter number of starting stones: 7
Would you like to go first? (y/n): yEs
How many would you like to remove – 1 or 2? 1
The number of stones left is 6. The computer removes 2 stones. The number of stones left is 4. How many would you like to remove – 1 or 2? 2
The number of stones left is 2. The computer removes 1 stone. The number of stones left is 1. How many would you like to remove – 1 or 2? 1
The number of stones left is 0. The computer wins! Do you want to play again? (y/n): Y

Enter the number of starting stones: 4
Would you like to go first? (y/n): n
The computer removes 1 stone. The number of stones left is 3. How many would you like to remove – 1 or 2? 2
The number of stones left is 1. The computer removes 1 stone. The number of stones left is 0. You win! Do you want to play again? (y/n): n

b)  [after §4.14] Add input validation to your Nim program. More specifically, (1) ask the user to re-enter the number of starting stones if he/she doesn’t enter a positive number, and (2) ask the user to re-enter the number of stones to be removed if he/she doesn’t enter an appropriate number.

Sample session:

T H E   G A M E   O F   N I M  Enter the number of starting stones: 7
Would you like to go first? (y/n): yEs
How many would you like to remove – 1 or 2? 1
The number of stones left is 6. The computer removes 2 stones. The number of stones left is 4. How many would you like to remove – 1 or 2? 2
The number of stones left is 2. The computer removes 1 stone. The number of stones left is 1. How many would you like to remove – 1 or 2? 2
You cannot remove 2 stones. How many would you like to remove – 1 or 2? 1
The number of stones left is 0. The computer wins! Do you want to play again? (y/n): Y

Enter the number of starting stones: 0
You cannot start with 0 stones. Enter the number of starting stones: 4
Would you like to go first? (y/n): n
The computer removes 1 stone. The number of stones left is 3. How many would you like to remove – 1 or 2? 0
You cannot remove 0 stones. How many would you like to remove – 1 or 2? 3
You cannot remove 3 stones. How many would you like to remove – 1 or 2? 2
The number of stones left is 1. The computer removes 1 stone. The number of stones left is 0. You win! Do you want to play again? (y/n): n

 
Triangle *:

Write a Java program that generates an isosceles triangle made of asterisks. The program should prompt the user to specify the size of the triangle. Make sure variable names are appropriate, and make sure there are comments for the weird variables like sideSize. Use good style. 

Sample session:

Enter the size of the equal sides in an isosceles triangle: 6
* ** * * *  * *   * ******


Mayan Calendar *:

The ancient Mayans, who maintained a civilization for more than 1,000 years in Central America, counted toes as well as fingers and used 20 (instead of our 10) for their number base. Because it was place-based and included zero, the Mayan numbering system was inherently more advanced than the numbering system used by their contemporaries, the ancient Romans. The Mayan month, called a “uinal,” a word derived from their word for “human,” had 20 days. One of their sacred numbers was 13, and they had a sacred calendar, called the “Tzolkin” whose period was 20 * 13 = 260 days. To represent the natural year of 365 days, they also had another calendar, called the “Haab” composed of eighteen 20-day months plus one short 5-day month for resting. Every day was identified as a particular date in both of these calendars. This gave different identifications to the same dates in different years, but eventually the combination of Tzolkin-date and Haab-date repeated in a cycle called the “Calendar Round.” Here is pseudocode for an algorithm that determines the number of Tzolkins and the number of Haabs in one Calendar Round:
 
set haabs to 0
while haabs is less than 260
  set haabs to haabs + 1
  set tzolkins to 0
  while tzolkins * 365 is less than or equal to haabs * 260
    set tzolkins to tzolkins + 1
    if tzolkins * 365 is equal to haabs * 260
      print “Haabs = ” haabs “, Tzolkins = ” tzolkins
      exit

Write a Java program that implements this algorithm.


Input Validation *:

An input prompt can include limit specification, and if the data is not acceptable, the program can implement input validation by simply repeating the input prompt.

The following algorithm computes the average of several input values:

set MIN to 0.5
set MAX to 5.0
set cumulativeValue to 0
set count to 0
set more to ‘y’
while more is equal to ‘y’
  set count to count + 1
  print “Item number ” count “:”
  set value to MIN - 1.0
  while value is less than MIN  or greater than Max
    print “Enter value (” MIN “ < value < ” MAX “): ”
    input value
  set cumulativeValue to cumulativeValue + value
  print “more? (y/n): ”
  input more
set value to cumulativeValue / count
print “Average value = ” value

Sample session:

Item number 1:
Enter value (0.5 < value < 5.0): 50
Enter value (0.5 < value < 5.0): 3.7
more? (y/n): y
Item number 2:
Enter value (0.5 < value < 5.0): .2
Enter value (0.5 < value < 5.0): 2.2
more? (y/n): n
Average value = 2.95

Write Java code that implements the algorithm, except use a for loop instead of the outer while loop in the pseudocode, and use a do loop instead of the inner while loop in the pseudocode. It should be able to generate the above display.


Write a program that calculates customers’ income taxes using the following rules:
  
•  The amount of taxes owed equals the taxable income times the tax rate.
•  Taxable income equals gross income minus $1,000 for each exemption.
•  The taxable income cannot be less than zero.
  
  The tax rate is computed using the following table:
  
    Filing Status Taxable Income    Tax Rate
    single    irrelevant    20%
    married   irrelevant    25%
    cohabiting  less than $20,000 10%
        $20,000 ─ $50,000  15%
        more than $50,000 30%
  
  For each customer processed, the program should print the customer’s tax rate, taxable income, and taxes owed using the format shown in the sample session below.
  
  The program should allow the user to process additional customers as long as he/she enters ‘y’ or ‘Y’ in response to a “Process another customer? (y/n): ” prompt.
  
  The program should perform input validation for the customer’s filing status (only ‘s’, ‘S’, ‘m’, ‘M’, ‘c’, and ‘C’ are acceptable). 
  
  Use a switch statement when calculating a customer’s tax rate. Combine related case choices by putting them on the same line. For example, since the user may enter either ‘s’ or ‘S’ to indicate “single,” use the following line of code inside your switch statement:
  
   case 's': case 'S':
  
  Use an appropriate do loop.
  
a) Write and debug a Java program for this algorithm. It should be able to produce the following screen display.

b) As an option, perform input validation for the other input entities: gross income (greater than or equal to 0.0), number of exemptions (greater than or equal to 0), process another query (‘y’, ‘Y’, ‘n’, and ‘N’).
  
  Sample session:

J O H N ' S   T A X   P R E P A R E R

Are you (s)ingle, (m)arried, or (c)ohabiting?
Enter s, m, or c ==> M
Gross income ==> 70000
Number of exemptions ==> 2

INCOME TAX SUMMARY
tax rate: 25.0%
taxable income: $68000.0
taxes owed: $17000.0

Process another customer? (y/n): Y

Are you (s)ingle, (m)arried, or (c)ohabiting?
Enter s, m, or c ==> m
Gross income ==> 10000
Number of exemptions ==> 12

INCOME TAX SUMMARY
tax rate: 25.0%
taxable income: $0.0
taxes owed: $0.0

Process another customer? (y/n): y

Are you (s)ingle, (m)arried, or (c)ohabiting?
Enter s, m, or c ==> x

Invalid entry.
Are you (s)ingle, (m)arried, or (c)ohabiting?
Enter s, m, or c ==> s
Gross income ==> 20000
Number of exemptions ==> 0

INCOME TAX SUMMARY
tax rate: 20.0%
taxable income: $20000.0
taxes owed: $4000.0

Process another customer? (y/n): y

Are you (s)ingle, (m)arried, or (c)ohabiting?
Enter s, m, or c ==> c
Gross income ==> 13000
Number of exemptions ==> 4

INCOME TAX SUMMARY
tax rate: 10.0%
taxable income: $9000.0
taxes owed: $900.0

Process another customer? (y/n): y

Are you (s)ingle, (m)arried, or (c)ohabiting?
Enter s, m, or c ==> c
Gross income ==> 51000
Number of exemptions ==> 1

INCOME TAX SUMMARY
tax rate: 15.0%
taxable income: $50000.0
taxes owed: $7500.0

Process another customer? (y/n): n

  This sample session is rather lengthy. Because of the length, it may seem like a hassle to mimic it precisely and then print the entire thing out. However, a good sample-session specification helps you check your program for many different special cases.
  
  Due to inherent imprecision in converting the fractional portion of a decimal number (the portion to the right of the decimal point) to the fractional portion of a binary number, certain floating point numbers (such as 0.15) cannot be stored perfectly in the computer. Therefore, since this program does happen to use 0.15, be prepared to see slight imprecision in your answers for calculations that use 0.15. For example, if you attempt to print the percentage form of 0.15, it may display as 15.000001%. If that happens, don’t worry about it. Later, you’ll be able to solve the problem by using the DecimalFormat class.


Text Parsing **:

Write a program that converts words to pig Latin. Words that begin with a vowel are unchanged. Words that begin with a consonant have the starting consonant moved to the end of the word and “ay” is appended after the consonant. If the input is only the single letter “q” or “Q,” the program quits. Given the inputs “open,” “door,” and “q,” make the program produce the following display:

Sample session:

PIG LATIN WORD CONVERTER

Enter a word: open
In Pig Latin, that's "open"
Enter a word: door
In Pig Latin, that's "oorday"
Enter a word: q
I hope you enjoyed your porcine experience! Please come again.

Here is the algorithm:

print “Enter a word: ”
input line
while line is not equal to “q”
  set okInput to true
  step through characters in input line
    if any one is not a letter
      set okInput to false
      print “Invalid input ─ can’t process this character” badCharacter
  if okInput is still true
    set pigWord to “”
    if first character is a vowel
      append first character to pigWord
      set suffix to “”
       else
         set suffix to firstCharacter “ay”
       append remaining characters to pigWord
       append suffix to pigWord
       print “in Pig Latin, that’s ” pigWord
     ask for next word
   print sign-off message 
  

Java Programming Exercise :

Tags:

• Previous Java Programming
• Next On Java Programming