Java sample code

Author: Fr4nc3

java/Test.java

@@ -0,0 +1,17 @@
+public class Test {
+    public static void main(String[] args) {
+
+        System.out.println(3%9);
+        System.out.println(foo(3, 9));
+
+    }
+
+    public static int  foo(int a, int b){
+        if(a%b == 0 ){
+            return b;
+        }
+        else return foo(b,a%b);
+
+
+    }
+}

java/sample1/Problem1.java

@@ -0,0 +1,57 @@
+/* 
+* @Fr4nc3
+* Programing Q1
+*/
+public class Problem1 {
+    public static final int ARRAY_SIZE = 5;
+
+    public static <AnyType extends Comparable<AnyType>> AnyType findMax(AnyType[] arr) {
+        int maxIndex = 0;
+        for (int i = 0; i < arr.length; ++i) {
+            if (arr[i].compareTo(arr[maxIndex]) > 0) {
+                maxIndex = i;
+            }
+        }
+        return arr[maxIndex];
+    }
+
+    public static void main(String[] args) {
+        /*
+         * First test of findMax with a simple Array
+		*/
+
+        Rectangle[] a = new Rectangle[ARRAY_SIZE];
+        a[0] = new Rectangle(1, 2);
+        a[1] = new Rectangle(2, 2);
+        a[2] = new Rectangle(2, 3);
+        a[3] = new Rectangle(3, 3);
+        a[4] = new Rectangle(3, 4);
+
+        Rectangle maxRectangle = findMax(a);
+        System.out.println("Found max Rectangle" + maxRectangle.toString());
+
+		/*
+		 * second test creating the dimensions of the array dynamically.
+		*/
+        System.out.println("\n\n\nSecond test with random Rectangles:\n");
+
+        Rectangle[] a2 = new Rectangle[ARRAY_SIZE];
+
+        for (int i = 0; i < ARRAY_SIZE; ++i) {
+            int width = (int) (Math.random() * 50 + 1);  //from1,50
+            int length = (int) (Math.random() * 50 + 1);
+            a2[i] = new Rectangle(length, width);
+
+        }
+
+        System.out.println("New Array Rectangles Dimensions:\n");
+
+        for (int i = 0; i < ARRAY_SIZE; ++i) {
+            System.out.println("Rectangle " + i);
+            System.out.println(a2[i].toString() + "\n");
+        }
+
+        Rectangle newMaxRectangle = findMax(a2);
+        System.out.println("Found max Rectangle" + newMaxRectangle.toString());
+    }
+}

java/sample1/Problem2.java

@@ -0,0 +1,68 @@
+/* 
+* @Fr4nc3
+* Problem2 class
+* Programing Q2
+*/
+import java.util.Arrays;
+
+public class Problem2 {
+    public static final int ARRAY_SIZE = 5;
+
+    public static <AnyType extends Comparable<AnyType>> int binarySearch(AnyType[] a, AnyType x) {
+        return binarySearch(a, x, 0, a.length - 1);
+    }
+
+    public static <AnyType extends Comparable<AnyType>> int binarySearch(AnyType[] a, AnyType x,
+                                                                         int low, int high) {
+        if (low > high) return -1;
+        int mid = (low + high) / 2;
+        if (a[mid].compareTo(x) == 0) return mid;
+        else if (a[mid].compareTo(x) < 0)
+            return binarySearch(a, x, mid + 1, high);
+        else // last possibility
+            return binarySearch(a, x, low, mid - 1);
+    }
+
+    public static void main(String[] args) {
+
+        Rectangle[] a = new Rectangle[ARRAY_SIZE];
+        //create an empty rectangle that we will use to find after the sort
+        Rectangle findRectangle = new Rectangle(0, 0);
+        for (int i = 0; i < ARRAY_SIZE; ++i) {
+            // generate dimensions randomly
+            int width = (int) (Math.random() * 50 + 1);
+            int length = (int) (Math.random() * 50 + 1);
+
+            // we give real dimension to our rectangle
+            // this means it always will appear in this test case
+            if (findRectangle.getLength() == 0) {
+                findRectangle.setLength(length);
+                findRectangle.setWidth(width);
+            }
+
+            a[i] = new Rectangle(length, width);
+        }
+        Arrays.sort(a);
+        System.out.println("New Array Rectangles Dimensions:\n");
+
+        for (int i = 0; i < ARRAY_SIZE; ++i) {
+            System.out.println("Rectangle " + i);
+            System.out.println(a[i].toString() + "\n");
+        }
+
+        System.out.println("Found Rectangle" + findRectangle.toString());
+        System.out.println("Rectangle Index: " + binarySearch(a, findRectangle));
+
+        /*
+        * Second test we create a rectangle with random dimensions and
+        * it may or may not exist
+        * */
+        int width = (int) (Math.random() * 50 + 1);
+        int length = (int) (Math.random() * 50 + 1);
+        Rectangle doExistRectangle = new Rectangle(length, width);
+
+        System.out.println("\n\nNew  Rectangle to find" + doExistRectangle.toString());
+        System.out.println("Rectangle Index? " + binarySearch(a, doExistRectangle));
+
+    }
+}

java/sample1/Problem3.java

@@ -0,0 +1,77 @@
+/* 
+* @Fr4nc3
+* Problem3 class
+* Programing Q3
+*/
+public class Problem3 {
+    public static final int MAX_TEST_POWER = 9;
+
+    public static void methodA(int n) {
+        int sum = 0;
+        for (int i = 0; i < 23; i++) {
+            for (int j = 0; j < n; j++) {
+                sum = sum + 1;
+            }
+        }
+    }
+
+    public static void methodB(int n) {
+        int sum = 0;
+        for (int i = 0; i < n; i++) {
+            for (int k = i; k < n; k++) {
+                sum = sum + 1;
+            }
+        }
+    }
+
+    public static int foo(int n, int k) {
+        if (n <= k)
+            return 1;
+        else
+            return foo(n / k, k) + 1;
+    }
+
+    public static int getTheN(int n) {
+        return (int) Math.pow(10, n);
+    }
+
+    public static void main(String[] args) {
+
+        long startTime, endTime;
+        /*
+        * TEST METHOD A
+        * */
+        for (int i = 0; i <= MAX_TEST_POWER; ++i) {
+            startTime = System.nanoTime();
+            int testN = getTheN(i);
+            System.out.println("methodA N: " + testN);
+            methodA(testN);
+            endTime = System.nanoTime();
+            System.out.println(endTime - startTime);
+        }
+
+        /*
+        * TEST METHOD B
+        * */
+        for (int i = 0; i <= MAX_TEST_POWER; ++i) {
+            startTime = System.nanoTime();
+            int testN = getTheN(i);
+            System.out.println("methodB N: " + testN);
+            methodB(testN);
+            endTime = System.nanoTime();
+            System.out.println(endTime - startTime);
+        }
+
+        /*
+        * TEST FOO
+        * */
+        for (int i = 0; i <= MAX_TEST_POWER; ++i) {
+            startTime = System.nanoTime();
+            int testN = getTheN(i);
+            System.out.println("foo N: " + testN);
+            int fooTest = foo(testN, 2); // k = 2 as requested in the hw description
+            endTime = System.nanoTime();
+            System.out.println(endTime - startTime);
+        }
+    }
+}

java/sample1/Problem3.txt

@@ -0,0 +1,77 @@
+methodA N: 1
+172429
+methodA N: 10
+17243
+methodA N: 100
+43518
+methodA N: 1000
+258644
+methodA N: 10000
+1011586
+methodA N: 100000
+539457
+methodA N: 1000000
+74720
+methodA N: 10000000
+60760
+methodA N: 100000000
+48444
+methodA N: 1000000000
+46802
+
+methodB N: 1
+15190
+methodB N: 10
+11906
+methodB N: 100
+68150
+methodB N: 1000
+1701714
+methodB N: 10000
+655642
+methodB N: 100000
+986132
+methodB N: 1000000
+13138
+methodB N: 10000000
+11085
+methodB N: 100000000
+10675
+methodB N: 1000000000
+10674
+
+
+foo N: 1
+13959
+foo N: 10
+11906
+foo N: 100
+9853
+foo N: 1000
+10263
+foo N: 10000
+14779
+foo N: 100000
+10674
+foo N: 1000000
+10264
+foo N: 10000000
+10674
+foo N: 100000000
+11085
+foo N: 1000000000
+12727
+
+The numbers in nanoseconds don't seem to be accurate and my theory (and after some googling)
+it is because JVM optimize the process, also my results may be different for reason such as
+
+1) Laptop setup
+2) Program that I am running parallel to the test (AKA memory available for the test)
+
+I found this online
+http://stackoverflow.com/questions/9724950/java-system-nanotime-elapsed-average-time-keeps-getting-smaller
+
+and I am basing my results in this theory.
+Java's JIT(Just-in-time compilation) optimizes code that gets run extensively -- the more it's run,
+the more effort the JIT puts into optimizing it.
+

java/sample1/README.txt

@@ -0,0 +1,46 @@
+@Fr4nc3
+==========
+
+Problem1.java
+Rectangle.java
+Problem2.java
+Problem3.java
+Problem3.txt
+README.txt
+
+
+Problem 1
+=========
+- Rectangle class
+  - Implement comparable
+- Problem1 class
+ - has two arrays to test the findMax method
+ - one array was created hard code rectangles
+ - second array was created with rectangles with random width and length.
+ - random dimension number goes between 1 to 50
+
+Problem 2
+=========
+- uses Rectangle class from Problem 1
+- test with an array  created with rectangles with random width and length.
+- BinarySearch was convert from book example to recursive
+- one rectangle to used to find was explicitly created in the array
+- other test rectangle was created randomly and may or may not appear in the array
+ - random dimension number goes between 1 to 50 too
+
+
+Problem 3
+=========
+- Used  System.nanoTime() instead of System.currentTimeMillis() as it was suggested
+- Used N = 10^n  where n goes 1 to 9
+- Numbers for the benchmark can be not representative for the writing #3 because
+ JAVA optimize the method. (see longer answer in Problem3.txt)
+
+
+HW CODE ENVIRONMENT
+==================
+Intel(R) Core(TM) i7-48070HQ CPU @ 2.50 GHz
+RAM 16GB
+Windows 10 Pro
+Java 1.8.0_72
+IntelliJ IDEA 15.0.3