Update solutions

Author: Sven97

src/Chapter06/Exercise0624_Display_current_date_and_time.java

@@ -227,7 +227,7 @@ public static String getDayName(int dayOfWeek) {
             case 6:
                 dayName = "Friday";
                 break;
-            case 7:
+            case 0:
                 dayName = "Saturday";
                 break;
         }

src/Chapter06/Exercise0626_Palindromic_prime.java

@@ -0,0 +1,56 @@
+/**
+ * (Palindromic prime) A palindromic prime is a prime number and also palindromic.
+ * For example, 131 is a prime and also a palindromic prime, as are 313 and 757.
+ * Write a program that displays the first 120 palindromic prime numbers. Display
+ * 10 numbers per line, separated by exactly one space, as follows:
+ * 2 3 5 7 11 101 131 151 181 191
+ * 313 353 373 383 727 757 787 797 919 929
+ *
+ * Created by Sven on 07/27/19.
+ */
+package Chapter06;
+
+public class Exercise0626_Palindromic_prime {
+    public static void main(String[] args) {
+        int count = 0;
+        for (int i = 0; count < 120; i++) {
+            // It's slow to compute the last five numbers
+            if (isPrime(i) && isPalindrome(i)) {
+                if (count != 0 && count % 10 == 0) {
+                    System.out.println();
+                }
+                System.out.print(i + " ");
+                count++;
+            }
+        }
+    }
+
+    /**
+     * Check whether number is prime
+     */
+    public static boolean isPrime(int number) {
+        for (int divisor = 2; divisor <= number / 2; divisor++) {
+            if (number % divisor == 0) { // If true, number is not prime
+                return false; // number is not a prime
+            }
+        }
+        return true; // number is prime
+    }
+
+    /**
+     * Check whether number is palindromic
+     */
+    public static int reverse(int number) {
+        int reverse = 0;
+        while (number != 0) {
+            reverse *= 10;
+            reverse += number % 10;
+            number /= 10;
+        }
+        return reverse;
+    }
+
+    public static boolean isPalindrome(int number) {
+        return number == reverse(number);
+    }
+}

src/Chapter06/Exercise0627_Emirp.java

@@ -0,0 +1,46 @@
+/**
+ * (Emirp) An emirp (prime spelled backward) is a nonpalindromic prime number
+ * whose reversal is also a prime. For example, 17 is a prime and 71 is a prime, so
+ * 17 and 71 are emirps. Write a program that displays the first 120 emirps. Display
+ * 10 numbers per line, separated by exactly one space, as follows:
+ * 13 17 31 37 71 73 79 97 107 113
+ * 149 157 167 179 199 311 337 347 359 389
+ *
+ * Created by Sven on 07/27/19.
+ */
+package Chapter06;
+
+public class Exercise0627_Emirp {
+    public static void main(String[] args) {
+        int count = 0;
+        for (int i = 2; count < 120; i++) {
+            // It's slow to compute the last five numbers
+            if (isPrime(i) && isPrime(reverse(i))) {
+                if (count != 0 && count % 10 == 0) {
+                    System.out.println();
+                }
+                System.out.print(i + " ");
+                count++;
+            }
+        }
+    }
+
+    public static boolean isPrime(int number) {
+        for (int divisor = 2; divisor <= number / 2; divisor++) {
+            if (number % divisor == 0) { // If true, number is not prime
+                return false; // number is not a prime
+            }
+        }
+        return true; // number is prime
+    }
+
+    public static int reverse(int number) {
+        int reverse = 0;
+        while (number != 0) {
+            reverse *= 10;
+            reverse += number % 10;
+            number /= 10;
+        }
+        return reverse;
+    }
+}

src/Chapter06/Exercise0628_Mersenne_prime.java

@@ -0,0 +1,34 @@
+/**
+ * (Mersenne prime) A prime number is called a Mersenne prime if it can be written
+ * in the form 2 p - 1 for some positive integer p. Write a program that finds all
+ * Mersenne primes with p … 31 and displays the output as follows:
+ * p 2^p – 1
+ * 2 3
+ * 3 7
+ * 5 31
+ * ...
+ *
+ * Created by Sven on 07/27/19.
+ */
+package Chapter06;
+
+public class Exercise0628_Mersenne_prime {
+    public static void main(String[] args) {
+        System.out.println("p        2^p - 1");
+        System.out.println("----------------");
+        for (int p = 2; p <= 31; p++) {
+            if (isPrime((int) Math.pow(2, p) - 1)) {
+                System.out.printf("%-9d%d\n", p, (int) Math.pow(2, p) - 1);
+            }
+        }
+    }
+
+    public static boolean isPrime(int number) {
+        for (int divisor = 2; divisor <= number / 2; divisor++) {
+            if (number % divisor == 0) { // If true, number is not prime
+                return false; // number is not a prime
+            }
+        }
+        return true; // number is prime
+    }
+}

src/Chapter06/Exercise0629_Twin_primes.java

@@ -0,0 +1,31 @@
+/**
+ * (Twin primes) Twin primes are a pair of prime numbers that differ by 2. For
+ * example, 3 and 5 are twin primes, 5 and 7 are twin primes, and 11 and 13 are
+ * twin primes. Write a program to find all twin primes less than 1,200. Display the
+ * output as follows:
+ * (3, 5)
+ * (5, 7)
+ * ...
+ *
+ * Created by Sven on 07/27/19.
+ */
+package Chapter06;
+
+public class Exercise0629_Twin_primes {
+    public static void main(String[] args) {
+        for (int i = 2; i < 1200; i++) {
+            if (isPrime(i) && isPrime(i + 2)) {
+                System.out.println("(" + i + ", " + (i + 2) + ")");
+            }
+        }
+    }
+
+    public static boolean isPrime(int number) {
+        for (int divisor = 2; divisor <= number / 2; divisor++) {
+            if (number % divisor == 0) { // If true, number is not prime
+                return false; // number is not a prime
+            }
+        }
+        return true; // number is prime
+    }
+}

src/Chapter06/Exercise0630_Game_craps.java

@@ -0,0 +1,62 @@
+/**
+ * (Game: craps) Craps is a popular dice game played in casinos. Write a program
+ * to play a variation of the game, as follows:
+ * Roll two dice. Each die has six faces representing values 1, 2, . . ., and 6, respectively.
+ * Check the sum of the two dice. If the sum is 2, 3, or 12 (called craps), you
+ * lose; if the sum is 7 or 11 (called natural), you win; if the sum is another value
+ * (i.e., 4, 5, 6, 8, 9, or 10), a point is established. Continue to roll the dice until either
+ * a 7 or the same point value is rolled. If 7 is rolled, you lose. Otherwise, you win.
+ * Your program acts as a single player. Here are some sample runs.
+ * You rolled 5 + 6 = 11
+ * You win
+ * You rolled 1 + 2 = 3
+ * You lose
+ * You rolled 4 + 4 = 8
+ * point is 8
+ * You rolled 6 + 2 = 8
+ * You win
+ * You rolled 3 + 2 = 5
+ * point is 5
+ * You rolled 2 + 5 = 7
+ * You lose
+ *
+ * Created by Sven on 07/27/19.
+ */
+package Chapter06;
+
+public class Exercise0630_Game_craps {
+    public static void main(String[] args) {
+        int point = rollDice();
+        System.out.println(getStatus(point) ? "You win" : "You lose");
+    }
+
+    public static boolean getStatus(int point) {
+        if (point == 7 || point == 11) {
+            return true;
+        } else if (point == 2 || point == 3 || point == 12) {
+            return false;
+        } else {
+            System.out.println("point is " + point);
+            int secondPoint = rollDice();
+            while (true) {
+                if (secondPoint == point) {
+                    return true;
+                } else if (secondPoint == 7) {
+                    return false;
+                } else {
+                    System.out.println("point is " + secondPoint);
+                    secondPoint = rollDice();
+                }
+            }
+        }
+    }
+
+
+    public static int rollDice() {
+        int dice1 = (int) (Math.random() * 6 + 1);
+        int dice2 = (int) (Math.random() * 6 + 1);
+        int point = dice1 + dice2;
+        System.out.println("You rolled " + dice1 + " + " + dice2 + " = " + point);
+        return point;
+    }
+}

src/Chapter06/Exercise0631_Financial_credit_card_number_validation.java

@@ -0,0 +1,142 @@
+/**
+ * (Financial: credit card number validation) Credit card numbers follow certain
+ * patterns. A credit card number must have between 13 and 16 digits. It must start
+ * with
+ * ■■ 4 for Visa cards
+ * ■■ 5 for Master cards
+ * ■■ 37 for American Express cards
+ * ■■ 6 for Discover cards
+ * In 1954, Hans Luhn of IBM proposed an algorithm for validating credit card
+ * numbers. The algorithm is useful to determine whether a card number is entered
+ * correctly, or whether a credit card is scanned correctly by a scanner. Credit card
+ * numbers are generated following this validity check, commonly known as the
+ * Luhn check or the Mod 10 check, which can be described as follows (for illustration,
+ * consider the card number 4388576018402626):
+ * 1. Double every second digit from right to left. If doubling of a digit results in a
+ * two-digit number, add up the two digits to get a single-digit number.
+ * 2. Now add all single-digit numbers from Step 1.
+ * 4 + 4 + 8 + 2 + 3 + 1 + 7 + 8 = 3 7
+ * 3. Add all digits in the odd places from right to left in the card number.
+ * 6 + 6 + 0 + 8 + 0 + 7 + 8 + 3 = 3 8
+ * 4. Sum the results from Step 2 and Step 3.
+ * 3 7 + 3 8 = 7 5
+ * 5. If the result from Step 4 is divisible by 10, the card number is valid; otherwise,
+ * it is invalid. For example, the number 4388576018402626 is invalid, but the
+ * number 4388576018410707 is valid.
+ * Write a program that prompts the user to enter a credit card number as a long
+ * integer. Display whether the number is valid or invalid. Design your program to
+ * use the following methods:
+ * Here are sample runs of the program: (You may also implement this program by
+ * reading the input as a string and processing the string to validate the credit card.)
+ * Enter a credit card number as a long integer:
+ * 4388576018410707
+ * 4388576018410707 is valid
+ * Enter a credit card number as a long integer:
+ * 4388576018402626
+ * 4388576018402626 is invalid
+ *
+ * Created by Sven on 07/27/19.
+ */
+package Chapter06;
+
+import java.util.Scanner;
+
+public class Exercise0631_Financial_credit_card_number_validation {
+    public static void main(String[] args) {
+        Scanner input = new Scanner(System.in);
+        System.out.println("Enter a credit card number as a long integer:");
+        long number = input.nextLong();
+        System.out.println(isValid(number) ? (number + " is valid") : (number + " is invalid"));
+    }
+
+    /**
+     * Return true if the card number is valid
+     */
+    public static boolean isValid(long number) {
+        final int PREFIX_VISA = 4;
+        final int PREFIX_MASTER = 5;
+        final int PREFIX_AMERICAN_XP = 37;
+        final int PREFIX_DISCOVERS = 6;
+        if (prefixMatched(number, PREFIX_VISA) ||
+                prefixMatched(number, PREFIX_MASTER) ||
+                prefixMatched(number, PREFIX_AMERICAN_XP) ||
+                prefixMatched(number, PREFIX_DISCOVERS)) {
+            if (getSize(number) >= 13 && getSize(number) <= 16) {
+                int sum = sumOfDoubleEvenPlace(number) + sumOfOddPlace(number);
+                return sum % 10 == 0;
+            } else {
+                return false;
+            }
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * Get the result from Step 2
+     */
+    public static int sumOfDoubleEvenPlace(long number) {
+        int sum = 0;
+        while (number > 0) {
+            number /= 10;
+            int digit = getDigit((int) (number % 10) * 2);
+            sum += digit;
+            number /= 10;
+        }
+        return sum;
+    }
+
+    /**
+     * Return this number if it is a single digit, otherwise,
+     * return the sum of the two digits
+     */
+    public static int getDigit(int number) {
+        return (number > 9) ? (number % 10 + number / 10) : number;
+    }
+
+    /**
+     * Return sum of odd-place digits in number
+     */
+    public static int sumOfOddPlace(long number) {
+        int sum = 0;
+        while (number > 0) {
+            int digit = (int) (number % 10);
+            digit = getDigit(digit);
+            sum += digit;
+            number /= 100;
+        }
+        return sum;
+    }
+
+    /**
+     * Return true if the number d is a prefix for number
+     */
+    public static boolean prefixMatched(long number, int d) {
+        return getPrefix(number, getSize(d)) == d;
+    }
+
+    /**
+     * Return the number of digits in d
+     */
+    public static int getSize(long d) {
+        int size = 0;
+        while (d > 0) {
+            size++;
+            d /= 10;
+        }
+        return size;
+    }
+
+    /**
+     * Return the first k number of digits from number. If the
+     * number of digits in number is less than k, return number.
+     */
+    public static long getPrefix(long number, int k) {
+        if (getSize(number) < k) {
+            return number;
+        } else {
+            long difference = getSize(number) - k;
+            return (int) (number / Math.pow(10, difference));
+        }
+    }
+}