refactor 454

fishercoder1534 · fishercoder1534 · commit 7fdadb16fd10 · 2019-04-16T07:53:51.000-07:00
diff --git a/src/main/java/com/fishercoder/solutions/_454.java b/src/main/java/com/fishercoder/solutions/_454.java
@@ -3,9 +3,13 @@
 import java.util.HashMap;
 import java.util.Map;
 
-/**Given four lists A, B, C, D of integer values, compute how many tuples (i, j, k, l) there are such that A[i] + B[j] + C[k] + D[l] is zero.
-
- To make problem a bit easier, all A, B, C, D have same length of N where 0 ≤ N ≤ 500. All integers are in the range of -228 to 228 - 1 and the result is guaranteed to be at most 231 - 1.
+/**
+ * 454. 4Sum II
+ *
+ * Given four lists A, B, C, D of integer values,
+ * compute how many tuples (i, j, k, l) there are such that A[i] + B[j] + C[k] + D[l] is zero.
+ * To make problem a bit easier, all A, B, C, D have same length of N where 0 ≤ N ≤ 500.
+ * All integers are in the range of -228 to 228 - 1 and the result is guaranteed to be at most 231 - 1.
 
  Example:
 
@@ -25,30 +29,32 @@
 
 public class _454 {
 
-    public static int fourSumCount(int[] A, int[] B, int[] C, int[] D) {
-        Map<Integer, Integer> map = new HashMap();
-        int result = 0;
-        int len = A.length;
-        for (int i = 0; i < len; i++) {
-            for (int j = 0; j < len; j++) {
-                int sum = A[i] + B[j];
-                if (map.containsKey(sum)) {
-                    map.put(sum, map.get(sum) + 1);
-                } else {
-                    map.put(sum, 1);
+    public static class Solution1 {
+        public int fourSumCount(int[] A, int[] B, int[] C, int[] D) {
+            Map<Integer, Integer> map = new HashMap();
+            int result = 0;
+            int len = A.length;
+            for (int i = 0; i < len; i++) {
+                for (int j = 0; j < len; j++) {
+                    int sum = A[i] + B[j];
+                    if (map.containsKey(sum)) {
+                        map.put(sum, map.get(sum) + 1);
+                    } else {
+                        map.put(sum, 1);
+                    }
                 }
             }
-        }
 
-        for (int i = 0; i < len; i++) {
-            for (int j = 0; j < len; j++) {
-                int sum = -(C[i] + D[j]);
-                if (map.containsKey(sum)) {
-                    result += map.get(sum);
+            for (int i = 0; i < len; i++) {
+                for (int j = 0; j < len; j++) {
+                    int sum = -(C[i] + D[j]);
+                    if (map.containsKey(sum)) {
+                        result += map.get(sum);
+                    }
                 }
             }
-        }
 
-        return result;
+            return result;
+        }
     }
 }
diff --git a/src/test/java/com/fishercoder/_454Test.java b/src/test/java/com/fishercoder/_454Test.java
@@ -1,14 +1,13 @@
 package com.fishercoder;
 
 import com.fishercoder.solutions._454;
-import org.junit.Before;
 import org.junit.BeforeClass;
 import org.junit.Test;
 
 import static junit.framework.Assert.assertEquals;
 
 public class _454Test {
-    private static _454 test;
+    private static _454.Solution1 solution1;
     private static int expected;
     private static int actual;
     private static int[] A;
@@ -18,28 +17,17 @@ public class _454Test {
 
     @BeforeClass
     public static void setup() {
-        test = new _454();
-    }
-
-    @Before
-    public void setupForEachTest() {
-        expected = 0;
-        actual = 0;
-        A = new int[1000];
-        B = new int[1000];
-        C = new int[1000];
-        D = new int[1000];
+        solution1 = new _454.Solution1();
     }
 
     @Test
     public void test1() {
-
         A = new int[]{1, 2};
         B = new int[]{-2, -1};
         C = new int[]{-1, 2};
         D = new int[]{0, 2};
         expected = 2;
-        actual = test.fourSumCount(A, B, C, D);
+        actual = solution1.fourSumCount(A, B, C, D);
         assertEquals(expected, actual);
 
     }
