refactor 593

Author: fishercoder1534

src/main/java/com/fishercoder/solutions/_593.java

@@ -21,70 +21,74 @@ A valid square has four equal sides with positive length and four equal angles (
 
  */
 public class _593 {
-    /**Note: I don't need to use backtracking to find all permutations, this is an overkill.
-     * This is the most easy one: https://leetcode.com/articles/kill-process-2/#approach-3-checking-every-case-accepted*/
+    public static class Solution1 {
+        /**
+         * Note: I don't need to use backtracking to find all permutations, this is an overkill.
+         * This is the most easy one: https://leetcode.com/articles/kill-process-2/#approach-3-checking-every-case-accepted
+         */
 
-    public boolean validSquare(int[] p1, int[] p2, int[] p3, int[] p4) {
-        List<int[]> input = new ArrayList<>(Arrays.asList(p1, p2, p3, p4));
-        List<List<int[]>> allPermuations = getAllPermutations(input);
-        for (List<int[]> eachPermutation : allPermuations) {
-            if (isValid(eachPermutation)) {
-                return true;
+        public boolean validSquare(int[] p1, int[] p2, int[] p3, int[] p4) {
+            List<int[]> input = new ArrayList<>(Arrays.asList(p1, p2, p3, p4));
+            List<List<int[]>> allPermuations = getAllPermutations(input);
+            for (List<int[]> eachPermutation : allPermuations) {
+                if (isValid(eachPermutation)) {
+                    return true;
+                }
             }
+            return false;
         }
-        return false;
-    }
-
-    private List<List<int[]>> getAllPermutations(List<int[]> input) {
-        List<List<int[]>> result = new ArrayList();
-        List<int[]> init = new ArrayList<>();
-        result.add(init);
-        return backTracking(result, input, 0);
-    }
 
-    private List<List<int[]>> backTracking(List<List<int[]>> result, List<int[]> input, int pos) {
-        if (pos == input.size()) {
-            return result;
+        private List<List<int[]>> getAllPermutations(List<int[]> input) {
+            List<List<int[]>> result = new ArrayList();
+            List<int[]> init = new ArrayList<>();
+            result.add(init);
+            return backTracking(result, input, 0);
         }
-        List<List<int[]>> newResult = new ArrayList<>();
-        for (List<int[]> eachList : result) {
-            for (int i = 0; i <= eachList.size(); i++) {
-                List<int[]> newList = new ArrayList<>(eachList);
-                newList.add(i, input.get(pos));
-                newResult.add(newList);
+
+        private List<List<int[]>> backTracking(List<List<int[]>> result, List<int[]> input, int pos) {
+            if (pos == input.size()) {
+                return result;
+            }
+            List<List<int[]>> newResult = new ArrayList<>();
+            for (List<int[]> eachList : result) {
+                for (int i = 0; i <= eachList.size(); i++) {
+                    List<int[]> newList = new ArrayList<>(eachList);
+                    newList.add(i, input.get(pos));
+                    newResult.add(newList);
+                }
             }
+            result = newResult;
+            return backTracking(result, input, pos + 1);
         }
-        result = newResult;
-        return backTracking(result, input, pos + 1);
-    }
 
-    private boolean isValid(List<int[]> points) {
-        int[] p1 = points.get(0);
-        int[] p2 = points.get(1);
-        int[] p3 = points.get(2);
-        int[] p4 = points.get(3);
-        double distance = (Math.pow(p1[0] - p2[0], 2) + Math.pow(p1[1] - p2[1], 2));
-        return distance == (Math.pow(p2[0] - p3[0], 2) + Math.pow(p2[1] - p3[1], 2))
-                && distance == (Math.pow(p3[0] - p4[0], 2) + Math.pow(p3[1] - p4[1], 2))
-                && distance == (Math.pow(p4[0] - p1[0], 2) + Math.pow(p4[1] - p1[1], 2))
-                && isRightAngle(p1, p2, p3)
-                && noDuplicate(p1, p2, p3, p4);
-    }
+        private boolean isValid(List<int[]> points) {
+            int[] p1 = points.get(0);
+            int[] p2 = points.get(1);
+            int[] p3 = points.get(2);
+            int[] p4 = points.get(3);
+            double distance = (Math.pow(p1[0] - p2[0], 2) + Math.pow(p1[1] - p2[1], 2));
+            return distance == (Math.pow(p2[0] - p3[0], 2) + Math.pow(p2[1] - p3[1], 2))
+                    && distance == (Math.pow(p3[0] - p4[0], 2) + Math.pow(p3[1] - p4[1], 2))
+                    && distance == (Math.pow(p4[0] - p1[0], 2) + Math.pow(p4[1] - p1[1], 2))
+                    && isRightAngle(p1, p2, p3)
+                    && noDuplicate(p1, p2, p3, p4);
+        }
 
-    public boolean noDuplicate(int[] p1, int[] p2, int[] p3, int[] p4) {
-        return !Arrays.equals(p1, p2)
-                && !Arrays.equals(p1, p3)
-                && !Arrays.equals(p1, p4)
-                && !Arrays.equals(p2, p3)
-                && !Arrays.equals(p2, p4)
-                && !Arrays.equals(p3, p4);
-    }
+        public boolean noDuplicate(int[] p1, int[] p2, int[] p3, int[] p4) {
+            return !Arrays.equals(p1, p2)
+                    && !Arrays.equals(p1, p3)
+                    && !Arrays.equals(p1, p4)
+                    && !Arrays.equals(p2, p3)
+                    && !Arrays.equals(p2, p4)
+                    && !Arrays.equals(p3, p4);
+        }
 
-    public boolean isRightAngle(int[] p1, int[] p2, int[] p3) {
-        double angle1 = Math.atan2(p2[1] - p1[1], p2[0] - p1[0]);
-        double angle2 = Math.atan2(p3[1] - p1[1], p3[0] - p1[0]);
-        double degree = Math.toDegrees(angle1 - angle2);
-        return degree % 45 == 0;
+        public boolean isRightAngle(int[] p1, int[] p2, int[] p3) {
+            double angle1 = Math.atan2(p2[1] - p1[1], p2[0] - p1[0]);
+            double angle2 = Math.atan2(p3[1] - p1[1], p3[0] - p1[0]);
+            double degree = Math.toDegrees(angle1 - angle2);
+            return degree % 45 == 0;
+        }
     }
 
 }

src/test/java/com/fishercoder/_593Test.java

@@ -10,15 +10,15 @@
  * Created by fishercoder on 5/22/17.
  */
 public class _593Test {
-    private static _593 test;
+    private static _593.Solution1 solution1;
     private static int[] p1;
     private static int[] p2;
     private static int[] p3;
     private static int[] p4;
 
     @BeforeClass
     public static void setup() {
-        test = new _593();
+        solution1 = new _593.Solution1();
     }
 
     @Test
@@ -27,7 +27,7 @@ public void test1() {
         p2 = new int[]{1, 1};
         p3 = new int[]{1, 0};
         p4 = new int[]{0, 1};
-        assertEquals(true, test.validSquare(p1, p2, p3, p4));
+        assertEquals(true, solution1.validSquare(p1, p2, p3, p4));
     }
 
     @Test
@@ -36,7 +36,7 @@ public void test2() {
         p2 = new int[]{5, 3};
         p3 = new int[]{3, 5};
         p4 = new int[]{7, 7};
-        assertEquals(false, test.validSquare(p1, p2, p3, p4));
+        assertEquals(false, solution1.validSquare(p1, p2, p3, p4));
     }
 
     @Test
@@ -45,7 +45,7 @@ public void test3() {
         p2 = new int[]{0, 0};
         p3 = new int[]{0, 0};
         p4 = new int[]{0, 0};
-        System.out.println(test.noDuplicate(p1, p2, p3, p4));
-        assertEquals(false, test.validSquare(p1, p2, p3, p4));
+        System.out.println(solution1.noDuplicate(p1, p2, p3, p4));
+        assertEquals(false, solution1.validSquare(p1, p2, p3, p4));
     }
 }