## Exercises

**2.1.1**Write a static method`max3()`that takes three`int`arguments and returns the value of the largest one. Add an overloaded function that does the same thing with three`double`values.**2.1.2**Write a static method`odd()`that takes three`boolean`arguments and returns`true`if an odd number of the argument values are`true`, and`false`otherwise.**2.1.3**Write a static method`majority()`that takes three`boolean`arguments and returns`true`if at least two of the argument values are`true`, and`false`otherwise. Do not use an`if`statement.**2.1.4**Write a static method`eq()`that takes two`int`arrays as arguments and returns`true`if the arrays have the same length and all corresponding pairs of of elements are equal, and`false`otherwise.**2.1.5**Write a static method`areTriangular()`that takes three`double`arguments and returns`true`if they could be the sides of a triangle (none of them is greater than or equal to the sum of the other two). See EXERCISE 1.2.15.**2.1.6**Write a static method`sigmoid()`that takes a`double`argument*x*and returns the`double`value obtained from the formula 1 / (1 +*e*^{–x}).**2.1.7**Write a static method`sqrt()`that takes a`double`argument and returns the square root of that number. Use Newton’s method (see PROGRAM 1.3.6) to compute the result.**2.1.8**Give the function-call trace for`java Harmonic 3 5`**2.1.9**Write a static method`lg()`that takes a`double`argument`n`and returns the base-2 logarithm of`n`. You may use Java’s`Math`library.**2.1.10**Write a static method`lg()`that takes an`int`argument`n`and returns the largest integer not larger than the base-2 logarithm of`n`. Do*not*use the`Math`library.**2.1.11**Write a static method`signum()`that takes an`int`argument`n`and returns`-1`if`n`is less than`0`,`0`if`n`is equal to`0`, and`+1`if`n`is greater than`0`.**2.1.12**Consider the static method`duplicate()`below.`public static String duplicate(String s)`

{

String t = s + s;

return t;

}What does the following code fragment do?

`String s = "Hello";`

s = duplicate(s);

String t = "Bye";

t = duplicate(duplicate(duplicate(t)));

StdOut.println(s + t);**2.1.13**Consider the static method`cube()`below.`public static void cube(int i)`

{

i = i * i * i;

}How many times is the following

`for`loop iterated?`for (int i = 0; i < 1000; i++)`

cube(i);*Answer*: Just 1,000 times. A call to`cube()`has no effect on the client code. It changes the value of its local parameter variable`i`, but that change has no effect on the`i`in the`for`loop, which is a different variable. If you replace the call to`cube(i)`with the statement`i = i * i * i;`(maybe that was what you were thinking), then the loop is iterated five times, with`i`taking on the values`0`,`1`,`2`,`9`, and`730`at the beginning of the five iterations.**2.1.14**The following*checksum*formula is widely used by banks and credit card companies to validate legal account numbers:*d*_{0}+*f*(*d*_{1}) +*d*_{2}+*f*(*d*_{3}) +*d*_{4}+*f*(*d*_{5}) + ... = 0 (mod 10)The

*d*are the decimal digits of the account number and_{i}*f*(*d*) is the sum of the decimal digits of 2*d*(for example,*f*(7) = 5 because 2 × 7 = 14 and 1 + 4 = 5). For example, 17,327 is valid because 1 + 5 + 3 + 4 + 7 = 20, which is a multiple of 10. Implement the function*f*and write a program to take a 10-digit integer as a command-line argument and print a valid 11-digit number with the given integer as its first 10 digits and the checksum as the last digit.**2.1.15**Given two stars with angles of*declination*and*right ascension*(*d*_{1},*a*_{1}) and (*d*_{2},*a*_{2}), the angle they subtend is given by the formula2 arcsin((sin

^{2}(*d*/2) + cos (*d*_{1})cos(*d*_{2})sin^{2}(*a*/2))^{1/2})where

*a*_{1}and*a*_{2}are angles between –180 and 180 degrees,*d*_{1}and*d*_{2}are angles between –90 and 90 degrees,*a*=*a*_{2}–*a*_{1}, and*d*=*d*_{2}–*d*_{1}. Write a program to take the declination and right ascension of two stars as command-line arguments and print the angle they subtend.*Hint*: Be careful about converting from degrees to radians.**2.1.16**Write a static method`scale()`that takes a`double`array as its argument and has the side effect of scaling the array so that each element is between 0 and 1 (by subtracting the minimum value from each element and then dividing each element by the difference between the minimum and maximum values). Use the`max()`method defined in the table in the text, and write and use a matching`min()`method.**2.1.17**Write a static method`reverse()`that takes an array of strings as its argument and returns a new array with the strings in reverse order. (Do not change the order of the strings in the argument array.) Write a static method`reverseInplace()`that takes an array of strings as its argument and produces the side effect of reversing the order of the strings in the argument array.**2.1.18**Write a static method`readBoolean2D()`that reads a two-dimensional boolean matrix (with dimensions) from standard input and returns the resulting two-dimensional array.**2.1.19**Write a static method`histogram()`that takes an`int`array`a[]`and an integer`m`as arguments and returns an array of length`m`whose`i`th element is the number of times the integer`i`appeared in`a[]`. Assuming the values in`a[]`are all between`0`and`m-1`, the sum of the values in the returned array should equal`a.length`.**2.1.20**Assemble code fragments in this section and in SECTION 1.4 to develop a program that takes an integer command-line argument*n*and prints*n*five-card hands, separated by blank lines, drawn from a randomly shuffled card deck, one card per line using card names like`Ace of Clubs`.**2.1.21**Write a static method m`ultiply()`that takes two square matrices of the same dimension as arguments and produces their product (another square matrix of that same dimension).*Extra credit*: Make your program work whenever the number of columns in the first matrix is equal to the number of rows in the second matrix.**2.1.22**Write a static method`any()`that takes a`boolean`array as its argument and returns`true`if any of the elements in the array is`true`, and`false`otherwise. Write a static method`all()`that takes an array of`boolean`values as its argument and returns`true`if all of the elements in the array are`true`, and`false`otherwise.**2.1.23**Develop a version of`getCoupon()`that better models the situation when one of the coupons is rare: choose one of the*n*values at random, return that value with probability 1 /(1,000*n*), and return all other values with equal probability.*Extra credit*: How does this change affect the expected number of coupons that need to be collected in the coupon collector problem?**2.1.24**Modify`PlayThatTune`to add harmonics two octaves away from each note, with half the weight of the one-octave harmonics.