Refactored Chapter 7

Author: RodneyShag

src/chapter1/OnePoint1.java

@@ -28,7 +28,7 @@ public static boolean uniqueCharacters_1(String string){
 
 	/* O(n) runtime, O(1) space: using Array */
 	public static boolean uniqueCharacters_2(String string){
-		if (string.length() > 256)
+		if (string.length() > 256) // here we assume it's an ASCII string. Should ask interviewer if string is ASCII or Unicode
 			return false;
 
 		boolean [] array = new boolean[256];

src/chapter7/Chapter7.java

@@ -1,9 +1,55 @@
 package chapter7;
 
 public class Chapter7 {
-	public static void main (String [] args){
-		/*** 7.4 ***/
-		System.out.println("*** Test 7.4");
+	public static void main(String [] args){
+		test_Prime();
+		// 7.1: no code required
+		// 7.2: no code required
+		test_SevenPoint3();
+		test_SevenPoint4();
+		// 7.5: Skip (no new concepts in this problem. Only trick: line goes through center of 2 squares
+		test_SevenPoint6();
+		test_SevenPoint7();
+	}
+	
+	public static void test_Prime(){
+		System.out.println("*** Test Primes");
+		System.out.println("Is 11 prime? " + Prime.isPrime(11));
+		System.out.println("Is 12 prime? " + Prime.isPrime(12));
+		System.out.println("Is 13 prime? " + Prime.isPrime(13));
+		boolean [] primes = Prime.generatePrimes(50);
+		System.out.print("Primes from 1-50: ");
+		for (int i = 0; i < primes.length; i++){
+			if (primes[i])
+				System.out.print(i + " ");
+		}
+	}
+
+	public static void test_SevenPoint3(){
+		System.out.println("\n\n*** Test 7.3: Intersecting Lines");
+		Line line1 = new Line(new Point(2,0), new Point(2,3));
+		Line line2 = new Line(new Point(2,5), new Point(2,7));
+		Line line3 = new Line(new Point(1,2), new Point(3,3));
+		Line line4 = new Line(new Point(2,3), new Point(4,4));
+
+		System.out.println("Lines intersect? (should be true):  " + LineFunctions.intersect(line1, line2));
+		System.out.println("Lines intersect? (should be true):  " + LineFunctions.intersect(line1, line3));
+		System.out.println("Lines intersect? (should be true):  " + LineFunctions.intersect(line1, line4));
+		System.out.println("Lines intersect? (should be true):  " + LineFunctions.intersect(line2, line3));
+		System.out.println("Lines intersect? (should be true):  " + LineFunctions.intersect(line2, line4));
+		System.out.println("Lines intersect? (should be false): " + LineFunctions.intersect(line3, line4));
+		
+		// Tests our Line, LineFunctions classes for functions used in 7.6
+		System.out.println("\nLines intersect? (should be true):  " + LineFunctions.sameLine(line1, line2));
+		System.out.println("Lines intersect? (should be false): " + LineFunctions.sameLine(line1, line3));
+		System.out.println("Lines intersect? (should be false): " + LineFunctions.sameLine(line1, line4));
+		System.out.println("Lines intersect? (should be false): " + LineFunctions.sameLine(line2, line3));
+		System.out.println("Lines intersect? (should be false): " + LineFunctions.sameLine(line2, line4));
+		System.out.println("Lines intersect? (should be false): " + LineFunctions.sameLine(line3, line4));
+	}
+
+	public static void test_SevenPoint4(){
+		System.out.println("\n*** Test 7.4: Subtraction, Multiplication, Division");
 		int result = SevenPoint4.subtract(4, 7);
 		System.out.println(" 4 -  7 = " + result + "\n");
 
@@ -15,39 +61,37 @@ public static void main (String [] args){
 		System.out.println(" 2 * -3 = " + result);
 		result = SevenPoint4.multiply(-2, -3);
 		System.out.println("-2 * -3 = " + result + "\n");
-		
-		result = SevenPoint4.divide(7, 2);
-		System.out.println(" 7 /  2 = " + result);
-		result = SevenPoint4.divide(-7, 2);
-		System.out.println("-7 /  2 = " + result);
-		result = SevenPoint4.divide(7, -2);
-		System.out.println(" 7 / -2 = " + result);
-		result = SevenPoint4.divide(-7, -2);
-		System.out.println("-7 / -2 = " + result);
-		
-		//7.6 -- I know how to code it, so I skipped it. Book's code/explanation is weird cuz they do line segments and complicate stuff.
-		//Things to remember: ( y = mx + b) (The solution line must go through middle of squares)
+		try{
+			result = SevenPoint4.divide(7, 2);
+			System.out.println(" 7 /  2 = " + result);
+			result = SevenPoint4.divide(-7, 2);
+			System.out.println("-7 /  2 = " + result);
+			result = SevenPoint4.divide(7, -2);
+			System.out.println(" 7 / -2 = " + result);
+			result = SevenPoint4.divide(-7, -2);
+			System.out.println("-7 / -2 = " + result);
+		}
+		catch(Exception e){
+			System.out.println(e.getMessage());
+		}
+	}
 
-		/*** 7.6 ***/		
-		System.out.println("\n*** Test 7.6");
+	public static void test_SevenPoint6(){
+		System.out.println("\n*** Test 7.6: Find line passing through most provided points");
 		Point [] points = new Point[4];
 		points[0] = new Point(1, 3);
 		points[1] = new Point(2, 4);
 		points[2] = new Point(3, 5);
 		points[3] = new Point(13, 7);
 
-		Line bestLine= SevenPoint6.findBestLine(points);
-		System.out.println("bestLine:   Slope = " + bestLine.slope + "   Intercept = " + bestLine.intercept);
-		
-		/*** 7.7 ***/		
-		System.out.println("\n*** Test 7.7");
-		System.out.println("\n Solution 1");
+		Line bestLine = SevenPoint6.findBestLine(points);
+		System.out.println("bestLine = " + bestLine);
+	}
+
+	public static void test_SevenPoint7(){
+		System.out.println("\n*** Test 7.7: find kth magic number");
 		for (int i = 1; i <= 6; i++){
 			System.out.println(i + ": magic number = " + SevenPoint7.getKthMagicNumber(i));
 		}
-		System.out.println("\n Solution 2");
-		for (int i = 1; i <= 6; i++){
-			System.out.println(i + ": magic number = " + SevenPoint7.getKthMagicNumber2(i));
-		}
 	}
 }

src/chapter7/Line.java

@@ -1,53 +1,84 @@
 package chapter7;
-/* Used in 7.6. I did it slightly differently than book */
-public class Line {
-	public static double epsilon = 0.0001;	//notice slightly more efficient to make this static.
 
-	public double intercept = 0;	//usually y-intercept, but if infiniteSlope==true, it will be x-intercept.
-	public double slope = 0;
-	public boolean infiniteSlope;	//IMPORTANT
+/* Useful equations:
+ * - Line: y = mx + b
+ * - Slope: (y2 - y1) / (x2 - x1)
+ * 
+ * Tricks:
+ * - We represent a Line in 2 different ways
+ *       1) Vertical Lines: infiniteSlope and x_intercept (We treat vertical lines separately to avoid div-by-0 errors)
+ *       2) Non-vertical Lines: slope and y_intercept
+ * - Must use epsilon to see if 2 doubles are equal to each other (within a margin of error)
+ * - Make Line's variables "final" so they don't change when Lines are hashed, making Line (basically) immutable
+ */
+public class Line {
+	private static final double epsilon = 0.0001;
+	public final Double slope;          // I use Double instead of double to be able to set it to null.
+	public final Double y_intercept;
+	public final boolean infiniteSlope;	// Important
+	public final double  x_intercept;   // We want to know x_intercept in case line has infinite slope
 
-	public Line(Point p, Point q){
-		/* y = mx + b */
-		if (Math.abs(p.x - q.x) < epsilon){
+	/* Constructor */
+	public Line(double slope, double y_intercept){
+		this.slope       = slope;
+		this.y_intercept = y_intercept;
+		infiniteSlope    = false;
+		/* Set x_intercept */
+		if (y_intercept == 0)
+			x_intercept = 0;
+		else
+			x_intercept = (-1 * slope) / y_intercept;  // y = mx + b   -->   0 = mx + b   -->  b = -mx
+	}
+
+	/* Constructor */
+	public Line(Point p1, Point p2){
+		if (areEquivalent(p1.x, p2.x)){
+			slope         = null;
+			y_intercept   = null;
 			infiniteSlope = true;
-			intercept = floorEpsilon(p.x);	
+			x_intercept   = p1.x;
 		}
 		else{
 			infiniteSlope = false;
-			slope = (p.y - q.y) / (p.x - q.x);
-			intercept = p.y - slope * p.x;	//from y = mx + b ----> b = y - mx
-			slope = floorEpsilon(slope);
-			intercept = floorEpsilon(intercept);
+			slope         = (p1.y - p2.y) / (p1.x - p2.x);
+			y_intercept   = p1.y - slope * p1.x; // to find y_intercept, we just plug in 1 of the Points into equation of line
+			if (y_intercept == 0)
+				x_intercept = 0;
+			else
+				x_intercept = (-1 * slope) / y_intercept;
 		}
 	}
-
-	/*** Must override both .equals() and .hashCode() for code to work properly. Surprised I got this to work. ***/
+	
+	/* Can't simply compare doubles using == */
+	public static boolean areEquivalent(double a, double b){
+		return Math.abs(a - b) < epsilon;
+	}
+	
+	/* Must override both .equals() and .hashCode() for Lines to be hashed properly:
+	 * http://stackoverflow.com/questions/27581/what-issues-should-be-considered-when-overriding-equals-and-hashcode-in-java */
 	@Override
 	public boolean equals(Object obj){
 		if (obj == this)
 			return true;
-		if (obj == null || obj.getClass() != this.getClass())
+		if (obj == null || !(obj instanceof Line))
 			return false;
+		
 		Line otherLine = (Line) obj;
-		if (infiniteSlope && otherLine.infiniteSlope && areEquivalent(intercept, otherLine.intercept))
-			return true;	//same vertical lines
-		if (!infiniteSlope && !otherLine.infiniteSlope && areEquivalent(slope, otherLine.slope) && areEquivalent(intercept, otherLine.intercept))
-			return true;
-		return false;
+		return LineFunctions.sameLine(this, otherLine);
 	}
 
 	@Override
 	public int hashCode(){
-		return (int) (7 * intercept + 31 * slope);
+		return (int) (2 * x_intercept
+				    + 3 * (y_intercept == null ? 0 : y_intercept)
+				    + 5 * (slope == null ? 0 : slope));
 	}
 
-	private double floorEpsilon(double num){	//cool trick from book.
-		int r = (int) (num / epsilon);	//typecast is necessary
-		return (double) (r * epsilon);
-	}
-	
-	private boolean areEquivalent(double a, double b){
-		return Math.abs(a - b) < epsilon;		//do I even need this?...since I round everything to nearest epsilon before saving it.
+	@Override
+	public String toString(){
+		if (infiniteSlope)
+			return "Line: Vertical line at x = " + x_intercept;
+		else
+			return "Line: slope = " + slope + "   y-intercept = " + y_intercept;
 	}
 }

src/chapter7/LineFunctions.java

@@ -0,0 +1,28 @@
+package chapter7;
+
+public class LineFunctions {
+	public static boolean intersect(Line line1, Line line2){ // Fact: 2 non-parallel lines intersect
+		
+		/* Handles vertical lines */
+		if (line1.infiniteSlope && line2.infiniteSlope && !Line.areEquivalent(line1.x_intercept, line2.x_intercept))
+			return false; // parallel vertical lines
+		else if (line1.infiniteSlope || line2.infiniteSlope)
+			return true;
+		
+		/* Handles non-vertical lines */
+		if (Line.areEquivalent(line1.slope, line2.slope) && ! Line.areEquivalent(line1.y_intercept, line2.y_intercept))
+			return false; // parallel non-vertical lines
+		return true;
+	}
+	
+	public static boolean sameLine(Line line1, Line line2){
+		/* Handles vertical lines */
+		if (line1.infiniteSlope && line2.infiniteSlope)
+			return Line.areEquivalent(line1.x_intercept, line2.x_intercept); // Vertical lines with same x-intercepts are equal
+		else if (line1.infiniteSlope || line2.infiniteSlope)
+			return false; // If only 1 line is vertical, it cannot be equal to the other line
+		
+		/* Handles non-vertical lines: Non-vertical lines with equivalent slopes and y_intercepts are equal */
+		return Line.areEquivalent(line1.slope, line2.slope) && Line.areEquivalent(line1.y_intercept, line2.y_intercept);
+	}
+}

src/chapter7/Point.java

@@ -1,5 +1,6 @@
 package chapter7;
-/* Used in 7.7 */
+
+/* Used in Point and Line class for 7.3, 7.7 */
 public class Point {
 	double x;
 	double y;

src/chapter7/Prime.java

@@ -0,0 +1,47 @@
+package chapter7;
+
+public class Prime {
+	public static boolean isPrime(int n){
+		for (int i = 2; i <= (int) Math.sqrt(n); i++){
+			if (n % i == 0)
+				return false;
+		}
+		return true;
+	}
+	
+	public static boolean[] generatePrimes(int max){
+		boolean [] flags = new boolean[max + 1];
+		initialize(flags);
+		int prime = 2;
+		while (prime < flags.length && prime <= Math.sqrt(max)){ // see comment in crossOff() to see why we stop at sqrt(max) here
+			crossOff(flags, prime);
+			prime = getNextPrime(flags, prime);
+		}
+		return flags;
+	}
+	
+	private static void initialize(boolean [] flags){
+		flags[0] = false;
+		flags[1] = false;
+		for (int i = 2; i < flags.length; i++){
+			flags[i] = true;
+		}
+	}
+	
+	/* Cross off multiples of prime from our array */
+	private static void crossOff(boolean[] flags, int prime) {
+		/* We can start with (prime*prime), because if we have a k * prime, where , < prime,
+		   this value would have already been crossed off in a prior call to this function */
+		for (int i = prime*prime; i < flags.length; i += prime){
+			flags[i] = false;
+		}
+	}
+	
+	private static int getNextPrime(boolean[] flags, int prime) {
+		for (int i = prime + 1; i < flags.length; i++){
+			if (flags[i] == true)
+				return i;
+		}
+		return -1; // our boolean[] wasn't big enough so we couldn't find the next prime.
+	}
+}