7.7 What is the value of the double
variable x
after each of the following statements is executed?
x = Math.Abs(7.5);
x = Math.Floor(7.5);
x = Math.Abs(0.0);
x = Math.Ceiling(0.0);
x = Math.Abs(-6.4);
x = Math.Ceiling(-6.4);
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:
RoundToInteger(number)
RoundToTenths(number)
RoundToHundredths(number)
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:
What does it mean to choose numbers “at random”?
Why is the Random
class useful for simulating games of chance?
Why is it often necessary to scale or shift the values produced by a Random
object?
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 ≤ n ≤ 2
1 ≤ n ≤ 100
0 ≤ n ≤ 9
1000 ≤ n ≤ 1112
–1 ≤ n ≤ 1
–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
.
2, 4, 6, 8, 10.
3, 5, 7, 9, 11.
6, 10, 14, 18, 22.
7.14 (Exponentiation) Write a method IntegerPower(base, exponent)
that returns the value of baseexponent
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.
Triangle | Side 1 | Side 2 |
---|---|---|
1 | 3.0 | 4.0 |
2 | 5.0 | 12.0 |
3 | 8.0 | 15.0 |
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:
Calculate the integer part of the quotient when integer a
is divided by integer b
.
Calculate the integer remainder when integer a
is divided by integer b
.
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.
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:
Expression-bodied method Celsius
returns the Celsius equivalent of a Fahrenheit temperature, using the calculation
5.0 / 9.0 * (f - 32);
Expression-bodied method Fahrenheit
returns the Fahrenheit equivalent of a Celsius temperature, using the calculation
9.0 / 5.0 * c + 32;
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.
Write a method that determines whether a number is prime.
Use this method in an app that displays all the prime numbers less than 10,000.
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:
Move n – 1 disks from peg 1 to peg 2, using peg 3 as a temporary holding area.
Move the last disk (the largest) from peg 1 to peg 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:
the number of disks to be moved,
the peg on which these disks are initially threaded,
the peg to which this stack of disks is to be moved, and
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);
}
}