refactor 149

fishercoder1534 · fishercoder1534 · commit 4de36430d246 · 2020-04-11T10:11:08.000-07:00
diff --git a/src/main/java/com/fishercoder/solutions/_149.java b/src/main/java/com/fishercoder/solutions/_149.java
@@ -1,30 +1,71 @@
-**Updated solution** [credits](https://leetcode.com/problems/max-points-on-a-line/discuss/328269/A-Java-solution-with-my-understanding)
+package com.fishercoder.solutions;
 
-class Solution {
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * 149. Max Points on a Line
+ *
+ * Given n points on a 2D plane, find the maximum number of points that lie on the same straight line.
+ *
+ * Example 1:
+ * Input: [[1,1],[2,2],[3,3]]
+ * Output: 3
+ * Explanation:
+ * ^
+ * |
+ * |        o
+ * |     o
+ * |  o
+ * +------------->
+ * 0  1  2  3  4
+ *
+ * Example 2:
+ * Input: [[1,1],[3,2],[5,3],[4,1],[2,3],[1,4]]
+ * Output: 4
+ * Explanation:
+ * ^
+ * |
+ * |  o
+ * |     o        o
+ * |        o
+ * |  o        o
+ * +------------------->
+ * 0  1  2  3  4  5  6
+ *
+ * NOTE: input types have been changed on April 15, 2019. Please reset to default code definition to get new method signature.
+ */
+public class _149 {
+
+  /**
+   * credits: https://leetcode.com/problems/max-points-on-a-line/discuss/328269/A-Java-solution-with-my-understanding
+   */
+  public static class Solution1 {
     public int maxPoints(int[][] points) {
-        if(points.length < 3)return points.length;
-        int max = 0;
-        HashMap<Long, Integer> map = new HashMap<Long, Integer>();
-        for(int i = 0;i < points.length;i++) {
-            int dup = 1;
-            map.clear();
-            for(int j = i + 1;j < points.length;j++) {
-                int dx = points[j][0] - points[i][0], dy = points[j][1] - points[i][1];
-                if(dx == 0 && dy == 0)dup++;
-                else {
-                    int gcd = getGcd(dx, dy);
-                    long slope = ((long)(dy / gcd) << 32) + (dx / gcd);
-                    map.put(slope, map.getOrDefault(slope, 0) + 1);
-                }               
-            }
-            max = Math.max(max, dup);
-            for(Map.Entry<Long, Integer> entry : map.entrySet())
-                max = Math.max(max, entry.getValue() + dup);
+      if (points.length < 3) return points.length;
+      int max = 0;
+      Map<Long, Integer> map = new HashMap<>();
+      for (int i = 0; i < points.length; i++) {
+        int dup = 1;
+        map.clear();
+        for (int j = i + 1; j < points.length; j++) {
+          int dx = points[j][0] - points[i][0], dy = points[j][1] - points[i][1];
+          if (dx == 0 && dy == 0) dup++;
+          else {
+            int gcd = getGcd(dx, dy);
+            long slope = ((long) (dy / gcd) << 32) + (dx / gcd);
+            map.put(slope, map.getOrDefault(slope, 0) + 1);
+          }
         }
-        return max;
+        max = Math.max(max, dup);
+        for (Map.Entry<Long, Integer> entry : map.entrySet())
+          max = Math.max(max, entry.getValue() + dup);
+      }
+      return max;
     }
-    
+
     int getGcd(int a, int b) {
-        return b == 0 ? a : getGcd(b, a % b);
+      return b == 0 ? a : getGcd(b, a % b);
     }
+  }
 }
diff --git a/src/test/java/com/fishercoder/_149Test.java b/src/test/java/com/fishercoder/_149Test.java
@@ -1,24 +1,27 @@
 package com.fishercoder;
 
-import com.fishercoder.common.classes.Point;
 import com.fishercoder.solutions._149;
 import org.junit.BeforeClass;
 import org.junit.Test;
 
 import static org.junit.Assert.assertEquals;
 
 public class _149Test {
-  private static _149.Solution1 solution1;
-  private static Point[] points;
+    private static _149.Solution1 solution1;
+    private static int[][] points;
 
-  @BeforeClass
-  public static void setup() {
-    solution1 = new _149.Solution1();
-  }
+    @BeforeClass
+    public static void setup() {
+        solution1 = new _149.Solution1();
+    }
 
-  @Test
-  public void test1() {
-    points = new Point[] {new Point(0, 0), new Point(1, 65536), new Point(65536, 0)};
-    assertEquals(2, solution1.maxPoints(points));
-  }
+    @Test
+    public void test1() {
+        points = new int[][]{
+                {1, 1},
+                {2, 2},
+                {3, 3}
+        };
+        assertEquals(3, solution1.maxPoints(points));
+    }
 }
