7.7 What is the value of the double variable x after each of the following statements is executed?

1. x = Math.Abs(7.5);

2. x = Math.Floor(7.5);

3. x = Math.Abs(0.0);

4. x = Math.Ceiling(0.0);

5. x = Math.Abs(-6.4);

6. x = Math.Ceiling(-6.4);

7. x = Math.Ceiling(-Math.Abs(-8 + Math.Floor(-5.5)));

7.8 (Parking Charges) A parking garage charges a $2.00 minimum fee to park for up to three hours. The garage charges an additional $0.50 per hour for each hour or part thereof in excess of three hours. The maximum charge for any given 24-hour period is $10.00. Assume that no car parks for longer than 24 hours at a time. Write an app that calculates and displays the parking charges for each customer who parked in the garage yesterday. You should enter the hours parked for each customer. The app should display the charge for the current customer and should calculate and display the running total of yesterday’s receipts. The app should use method CalculateCharges to determine the charge for each customer.

7.9 (Rounding to Nearest Integer) An app of method Math.Floor is rounding a value to the nearest integer. The statement

y = Math.Floor(x + 0.5);

will round the number x to the nearest integer and assign the result to y. Write an app that reads double values and uses the preceding statement to round each of the numbers to the nearest integer. For each number processed, display both the original number and the rounded number.

7.10 (Rounding to a Specific Decimal Place) Math.Floor may be used to round a number to a specific decimal place. The statement

y = Math.Floor(x * 10 + 0.5) / 10;

rounds x to the tenths position (i.e., the first position to the right of the decimal point). The statement

y = Math.Floor(x * 100 + 0.5) / 100;

rounds x to the hundredths position (i.e., the second position to the right of the decimal point). Write an app that defines four expression-bodied methods for rounding a number x in various ways:

1. RoundToInteger(number)

2. RoundToTenths(number)

3. RoundToHundredths(number)

4. RoundToThousandths(number)

For each value read, your app should display the original value, the number rounded to the nearest integer, the number rounded to the nearest tenth, the number rounded to the nearest hundredth and the number rounded to the nearest thousandth.

7.11 Answer each of the following questions:

1. What does it mean to choose numbers “at random”?

2. Why is the Random class useful for simulating games of chance?

3. Why is it often necessary to scale or shift the values produced by a Random object?

4. Why is computerized simulation of real-world situations a useful technique?

7.12 Write statements that assign random integers to the variable n in the following ranges. Assume Random randomNumbers = new Random() has been defined and use the two-parameter version of the method Random.Next.

1. 1 ≤ n ≤ 2

2. 1 ≤ n ≤ 100

3. 0 ≤ n ≤ 9

4. 1000 ≤ n ≤ 1112

5. –1 ≤ n ≤ 1

6. –3 ≤ n ≤ 11

7.13 For each of the following sets of integers, write a single statement that will display a number at random from the set. Assume Random randomNumbers = new Random() has been defined and use the one-parameter version of method Random.Next.

1. 2, 4, 6, 8, 10.

2. 3, 5, 7, 9, 11.

3. 6, 10, 14, 18, 22.

7.14 (Exponentiation) Write a method IntegerPower(base, exponent) that returns the value of base^exponent

For example, IntegerPower(3, 4) calculates 34 (or 3 * 3 * 3 * 3). Assume that exponent is a positive integer and that base is an integer. Method IntegerPower should use a for or while loop to control the calculation. Do not use any Math-library methods. Incorporate this method into an app that reads integer values for base and exponent and performs the calculation with the IntegerPower method.

7.15 (Hypotenuse of a Right Triangle) Write expression-bodied method Hypotenuse that calculates the length of the hypotenuse of a right triangle when the lengths of the other two sides are given. The method should take two double arguments and return the hypotenuse as a double. Incorporate this method into an app that reads values for side1 and side2 and performs the calculation with the Hypotenuse method. Determine the length of the hypotenuse for each of the triangles in Fig. 7.23.

7.16 (Multiples) Write expression-bodied method Multiple that determines, for a pair of integers, whether the second integer is a multiple of the first. The method should take two integer arguments and return true if the second is a multiple of the first and false otherwise. Incorporate this method into an app that inputs a series of pairs of integers (one pair at a time) and determines whether the second value in each pair is a multiple of the first.

7.17 (Even or Odd) Write expression-bodied method IsEven that uses the remainder operator (%) to determine whether an integer is even. The method should take an integer argument and return true if the integer is even and false otherwise. Incorporate this method into an app that inputs a sequence of integers (one at a time) and determines whether each is even or odd.

7.18 (Displaying a Square of Asterisks) Write method SquareOfAsterisks that displays a solid square (the same number of rows and columns) of asterisks whose side length is specified in integer parameter side. For example, if side is 4, the method should display

****
****
****
****

Incorporate this method into an app that reads an integer value for side from the user and outputs the asterisks with the SquareOfAsterisks method.

7.19 (Displaying a Square of Any Character) Modify the method created in Exercise 7.18 to form the square out of whatever character is contained in character parameter fillCharacter and provide '*' as the default value. If side is 5 and fillCharacter is '#', the method should display

#####
#####
#####
#####
#####

[Hint: Use the expression char.Parse(Console.ReadLine()) to read a character from the user. A variable of type char can store a single character’s value.]

7.20 (Circle Area) Write an app that prompts the user for the radius of a circle and uses expression-bodied method CircleArea to calculate the area of the circle.

7.21 (Separating Digits) Write code segments that accomplish each of the following tasks:

1. Calculate the integer part of the quotient when integer a is divided by integer b.

2. Calculate the integer remainder when integer a is divided by integer b.

3. Use the app pieces developed in parts (a) and (b) to write a method DisplayDigits that receives an integer between 1 and 99999 and displays it as a sequence of digits, separating each pair of digits by two spaces. For example, the integer 4562 should appear as:

   
   4 5 6 2.
   

4. Incorporate the method developed in part (c) into an app that inputs an integer and calls DisplayDigits by passing the method the integer entered. Display the results.

7.22 (Temperature Conversions) Implement the following integer methods:

1. Expression-bodied method Celsius returns the Celsius equivalent of a Fahrenheit temperature, using the calculation

   
   5.0 / 9.0 * (f - 32);
   

2. Expression-bodied method Fahrenheit returns the Fahrenheit equivalent of a Celsius temperature, using the calculation

   
   9.0 / 5.0 * c + 32;
   

3. Use the methods from parts (a) and (b) to write an app that enables the user either to enter a Fahrenheit temperature and display the Celsius equivalent or to enter a Celsius temperature and display the Fahrenheit equivalent.

7.23 (Find the Minimum) Write a method Minimum3 that returns the smallest of three floatingpoint numbers. Use the Math.Min method to implement Minimum3. Incorporate the method into an app that reads three values from the user, determines the smallest value and displays the result.

7.24 (Perfect Numbers) An integer number is said to be a perfect number if its factors, including 1 (but not the number itself), sum to the number. For example, 6 is a perfect number, because 6 = 1 + 2 + 3. Write method Perfect that determines whether parameter value is a perfect number. Use this method in an app that determines and displays all the perfect numbers between 2 and 1000. Display the factors of each perfect number to confirm that the number is indeed perfect.

7.25 (Prime Numbers) An integer is said to be prime if it’s greater than 1 and divisible by only 1 and itself. For example, 2, 3, 5 and 7 are prime, but 4, 6, 8 and 9 are not.

1. Write a method that determines whether a number is prime.

2. Use this method in an app that displays all the prime numbers less than 10,000.

3. Initially, you might think that n/2 is the upper limit for which you must test to see whether a number is prime, but you need go only as high as the square root of n. Rewrite the app, and run it both ways.

7.26 (Reversing Digits) Write a method that takes an integer value and returns the number with its digits reversed. For example, given the number 7631, the method should return 1367. Incorporate the method into an app that reads a value from the user and displays the method’s result.

7.27 (Greatest Common Divisor) The greatest common divisor (GCD) of two integers is the largest integer that evenly divides each of the two numbers. Write method Gcd that returns the greatest common divisor of two integers. Incorporate the method into an app that reads two values from the user and displays the result.

7.28 (Converting Grade Averages to a Four-Point Scale) Write method QualityPoints that inputs a student’s average and returns 4 if the student’s average is 90–100, 3 if the average is 80–89, 2 if the average is 70–79, 1 if the average is 60–69 and 0 if the average is lower than 60. Incorporate the method into an app that reads a value from the user and displays the result.

7.29 (Coin Tossing) Write an app that simulates coin tossing. Let the app toss a coin each time the user chooses the “Toss Coin” menu option. Count the number of times each side of the coin appears. Display the results. The app should call a separate method Flip that takes no arguments and returns false for tails and true for heads. [Note: If the app realistically simulates coin tossing, each side of the coin should appear approximately half the time.]

7.30 (Guess-the-Number Game) Write an app that plays “guess the number” as follows: Your app chooses the number to be guessed by selecting a random integer in the range 1 to 1000. The app displays the prompt Guess a number between 1 and 1000. The player inputs a first guess. If the player’s guess is incorrect, your app should display Too high. Try again. or Too low. Try again. to help the player “zero in” on the correct answer. The app should prompt the user for the next guess. When the user enters the correct answer, display Congratulations. You guessed the number! and allow the user to choose whether to play again. [Note: The guessing technique employed in this problem is similar to a binary search, which is discussed in Chapter 18.]

7.31 (Enhanced Guess-the-Number Game) Modify the app of Exercise 7.30 to count the number of guesses the player makes. If the number is 10 or fewer, display Either you know the secret or you got lucky! If the player guesses the number in 10 tries, display Aha! You know the secret! If the player makes more than 10 guesses, display You should be able to do better! Why should it take no more than 10 guesses? Well, with each “good guess,” the player should be able to eliminate half of the numbers. Now show why any number from 1 to 1000 can be guessed in 10 or fewer tries.

7.32 (Distance Between Two Points) Write method Distance to calculate the distance between two points (x1, y1) and (x2, y2). All numbers and return values should be of type double. Incorporate this method into an app that enables the user to enter the coordinates of the points.

7.33 (Craps Game Modification) Modify the craps app of Fig. 7.8 to allow wagering. Initialize variable balance to 1000 dollars. Prompt the player to enter a wager. Check that wager is less than or equal to balance, and if it’s not, have the user reenter wager until a valid wager is entered. After a correct wager is entered, run one game of craps. If the player wins, increase balance by wager and display the new balance. If the player loses, decrease balance by wager, display the new balance, check whether balance has become zero and, if so, display the message "Sorry. You busted!"

7.34 (Binary, Octal and Hexadecimal) Write an app that displays a table of the binary, octal, and hexadecimal equivalents of the decimal numbers in the range 1–256. If you’re not familiar with these number systems, read online Appendix D first.

7.35 (Recursive Power Calculation) Write recursive method Power(base, exponent) that, when called, returns

baseexponent

For example, Power(3, 4) = 3 * 3 * 3 * 3. Assume that exponent is an integer greater than or equal to 1. The recursion step should use the relationship

baseexponent = base · baseexponent – 1

The terminating condition occurs when exponent is equal to 1, because

base1 = base

Incorporate this method into an app that enables the user to enter the base and exponent.

7.36 (Towers of Hanoi) Every budding computer scientist must grapple with certain classic problems, and the Towers of Hanoi (see Fig. 7.24) is one of the most famous. Legend has it that in a temple in the Far East, priests are attempting to move a stack of disks from one peg to another. The initial stack has 64 disks threaded onto one peg and arranged from bottom to top by decreasing size. The priests are attempting to move the stack from this peg to a second peg under the constraints that exactly one disk is moved at a time and at no time may a larger disk be placed above a smaller disk. A third peg is available for temporarily holding disks. Supposedly, the world will end when the priests complete their task, so there’s little incentive for us to facilitate their efforts.

Let’s assume that the priests are attempting to move the disks from peg 1 to peg 3. We wish to develop an algorithm that will display the precise sequence of peg-to-peg disk transfers.

If we were to approach this problem with conventional methods, we’d rapidly find ourselves hopelessly knotted up in managing the disks. Instead, if we attack the problem with recursion in mind, it immediately becomes tractable. Moving n disks can be viewed in terms of moving only n – 1 disks (hence the recursion) as follows:

1. Move n – 1 disks from peg 1 to peg 2, using peg 3 as a temporary holding area.

2. Move the last disk (the largest) from peg 1 to peg 3.

3. Move the n – 1 disks from peg 2 to peg 3, using peg 1 as a temporary holding area.

The process ends when the last task involves moving n = 1 disk (i.e., the base case). This task is accomplished by simply moving the disk, without the need for a temporary holding area.

Write an app to solve the Towers of Hanoi problem. Allow the user to enter the number of disks. Use a recursive Tower method with four parameters:

1. the number of disks to be moved,

2. the peg on which these disks are initially threaded,

3. the peg to which this stack of disks is to be moved, and

4. the peg to be used as a temporary holding area.

Your app should display the precise instructions it will take to move the disks from the starting peg to the destination peg. For example, to move a stack of three disks from peg 1 to peg 3, your app should display the following series of moves:

1 --> 3 (This notation means “Move one disk from peg 1 to peg 3.”)
1 --> 2
3 --> 2
1 --> 3
2 --> 1
2 --> 3
1 --> 3

7.37 (What Does This Code Do?) What does the following method do?

// Parameter b must be positive to prevent infinite recursion
static int Mystery(int a, int b)
{
   if (b == 1)
      return a;
   else
      return a + Mystery(a, b - 1);
}

7.38 (Find the Error) Find the error(s) in the following recursive method, and explain how to correct it:

static int Sum(int n)
{
   if (n == 0)
   {
      return 0;
   }
   else
   {
      return n + Sum(n);
   }
}