Exercise 22 12

Author: HarryDulaney

ch_22/Exercise22_09.java

@@ -40,7 +40,12 @@ public static void main(String[] args) {
             }
         }
         scanner.close();
-        System.out.println("The convex hull is " + getConvexHull(points));
+        List<Point2D> convexHull = getConvexHull(points);
+        System.out.println("The convex hull is: ");
+        for (Point2D point : convexHull) {
+            System.out.print("(" + point.getX() + ", " + point.getY() + ") ");
+        }
+
 
     }
 

ch_22/Exercise22_11.java

@@ -55,9 +55,11 @@ public static void main(String[] args) {
 
         double[][] points = new double[numPoints][2];
         System.out.print("Enter " + numPoints + " points: ");
+
         for (int i = 0; i < points.length; i++) {
-            points[i][0] = scanner.nextDouble();
-            points[i][1] = scanner.nextDouble();
+            for (int j = 0; j < 2; j++) {
+                points[i][j] = scanner.nextDouble();
+            }
         }
         List<MyPoint> result = getConvexHull(points);
         System.out.println("The convex hull is: ");
@@ -69,11 +71,11 @@ public static ArrayList<MyPoint> getConvexHull(double[][] s) {
         double yMin = s[0][1];
         int minPos = 0;
         // Find the bottom most point
-        for (int i = 1; i < s[0].length; i++) {
+        for (int i = 1; i < s.length; i++) {
             double y = s[i][1];
             // Pick the bottom-most or chose the right
             // most point in case of tie
-            if ((y < yMin) || (yMin == y && s[i][0] < s[minPos][0])) {
+            if ((y < yMin) || (yMin == y && s[i][0] > s[minPos][0])) {
                 yMin = s[i][1];
                 minPos = i;
 
@@ -161,8 +163,7 @@ static double distSq(MyPoint p1, MyPoint p2) {
      * A utility function to find next to top in a stack
      */
     static MyPoint nextToTop(Stack<MyPoint> s) {
-        MyPoint p = s.peek();
-        s.pop();
+        MyPoint p = s.pop();
         MyPoint res = s.peek();
         s.push(p);
         return res;
@@ -194,7 +195,7 @@ public int compareTo(MyPoint o) {
             // Find orientation
             int orientation = orientation(rightMostLowestPoint, this, o);
             if (orientation == 0) {
-                return (distSq(rightMostLowestPoint, o) >= distSq(rightMostLowestPoint, this)) ? -1 : 1;
+                return distSq(rightMostLowestPoint, o) >= distSq(rightMostLowestPoint, this) ? -1 : 1;
             }
             return (orientation == 2) ? -1 : 1;
         }

ch_22/Exercise22_12.java

@@ -0,0 +1,57 @@
+package ch_22;
+
+import ch_22.exercise22_08.Exercise22_08;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.RandomAccessFile;
+import java.util.Arrays;
+
+/**
+ * 22.12 (Last 100 prime numbers) Programming Exercise 22.8 stores the prime numbers
+ * in a file named PrimeNumbers.dat.
+ * Write an efficient program that reads
+ * the last 100 numbers in the file. (Hint: Don’t read all numbers from the file.
+ * Skip all numbers before the last 100 numbers in the file.)
+ * <p>
+ */
+public class Exercise22_12 {
+    private static final String[] packageParts = Exercise22_08.class.getPackage().getName().split("\\.");
+    private static final String PATH = packageParts[0] + File.separator + packageParts[1] + File.separator + "PrimeNumbers.dat";
+    private static final long UPPER_BOUND = 10_000_000_000L;
+    private static final long BYTE_PER_LONG = 8;
+
+    public static void main(String[] args) throws Exception {
+        File dataFile = new File(PATH);
+        boolean createdOrExists = dataFile.exists();
+        /* If file does not exist, this is the first run, starting from first prime number */
+        if (!createdOrExists) {
+            System.out.println("Prime Storage File from Exercise 22 08 does not exist. Please run Exercise 22 08 first.");
+            System.exit(0);
+        } else {
+            /* Need file channel to be: Closable, seekable, readable, writable */
+            try (RandomAccessFile randomAccessFile = new RandomAccessFile(dataFile, "rws")) {
+                long[] last100Primes = new long[100];
+                long endOfFilePointer = randomAccessFile.length(); // Get pointer to end of the last byte in the file
+                /* Calc pointer to start point for reading the last 100 numbers in the file */
+                long bytePointer = endOfFilePointer - (BYTE_PER_LONG * 100); // bytes per long * 100 numbers from end
+                randomAccessFile.seek(bytePointer);
+                int readCount = 0;
+                long nextPrime = 0;
+                while (nextPrime < UPPER_BOUND && readCount < 100) {
+                    nextPrime = randomAccessFile.readLong();
+                    last100Primes[readCount] = nextPrime;
+                    readCount++;
+                }
+                System.out.println("Last 100 primes in the file: ");
+                System.out.println("================================");
+                System.out.println(Arrays.toString(last100Primes));
+
+            } catch (IOException ioException) {
+                throw new Exception("IOException while creating in and out file stream: \n" + ioException.getMessage());
+            }
+
+
+        }
+    }
+}

ch_22/exercise22_08/PrimeStorage.java

@@ -1,10 +1,17 @@
 package ch_22.exercise22_08;
 
+import ch_22.Exercise22_12;
+
 import java.io.EOFException;
 import java.io.File;
 import java.io.IOException;
 import java.io.RandomAccessFile;
 
+/**
+ * PrimeStorage class is used to store prime numbers in a file.
+ * Used in {@link Exercise22_08} and {@link Exercise22_12 } to read/write/evaluate prime numbers
+ * from the filesystem.
+ */
 public class PrimeStorage {
     protected File dataFile;
     private boolean firstRun;