devdcores
diff --git a/‎src/main/java/com/fishercoder/solutions/_525.java
Lines changed: 19 additions & 18 deletions b/‎src/main/java/com/fishercoder/solutions/_525.java
Lines changed: 19 additions & 18 deletions
diff --git a/‎src/test/java/com/fishercoder/_525Test.java
Lines changed: 6 additions & 5 deletions b/‎src/test/java/com/fishercoder/_525Test.java
Lines changed: 6 additions & 5 deletions
@@ -22,25 +22,26 @@
  */
 public class _525 {
 
-    //credit: https://leetcode.com/articles/contiguous-array/#approach-3-using-hashmap-accepted
-    public int findMaxLength(int[] nums) {
-        if (nums == null || nums.length == 0) {
-            return 0;
-        }
-        int count = 0;
-        int max = 0;
-        Map<Integer, Integer> map = new HashMap();
-        map.put(0, -1);//initialize the map, which means at index zero, the length of contiguous subarray is -1
-        for (int i = 0; i < nums.length; i++) {
-            count += nums[i] == 1 ? 1 : -1;
-            if (map.containsKey(count)) {
-                max = Math.max(i - map.get(count), max);
-            } else {
-                map.put(count, i);//only when the map does not have this key, we put it in the map, this avoids overwriting the map
-                //also, it helps us keep the most leftside value in the map to help us compute the longest contigous array length
+    public static class Solution1 {
+        //credit: https://leetcode.com/articles/contiguous-array/#approach-3-using-hashmap-accepted
+        public int findMaxLength(int[] nums) {
+            if (nums == null || nums.length == 0) {
+                return 0;
+            }
+            int count = 0;
+            int max = 0;
+            Map<Integer, Integer> map = new HashMap();
+            map.put(0, -1);//initialize the map, which means at index zero, the length of contiguous subarray is -1
+            for (int i = 0; i < nums.length; i++) {
+                count += nums[i] == 1 ? 1 : -1;
+                if (map.containsKey(count)) {
+                    max = Math.max(i - map.get(count), max);
+                } else {
+                    map.put(count, i);//only when the map does not have this key, we put it in the map, this avoids overwriting the map
+                    //also, it helps us keep the most leftside value in the map to help us compute the longest contigous array length
+                }
             }
+            return max;
         }
-        return max;
     }
-
 }
@@ -1,20 +1,21 @@
 package com.fishercoder;
 
+import com.fishercoder.solutions._525;
 import org.junit.Before;
 import org.junit.BeforeClass;
 import org.junit.Test;
 
 import static junit.framework.Assert.assertEquals;
 
 public class _525Test {
-    private static com.fishercoder.solutions._525 test;
+    private static _525.Solution1 solution1;
     private static int expected;
     private static int actual;
     private static int[] nums;
 
     @BeforeClass
     public static void setup() {
-        test = new com.fishercoder.solutions._525();
+        solution1 = new _525.Solution1();
     }
 
     @Before
@@ -25,23 +26,23 @@ public void setupForEachTest() {
     public void test1() {
         nums = new int[]{0, 1};
         expected = 2;
-        actual = test.findMaxLength(nums);
+        actual = solution1.findMaxLength(nums);
         assertEquals(expected, actual);
     }
 
     @Test
     public void test2() {
         nums = new int[]{0, 1, 0};
         expected = 2;
-        actual = test.findMaxLength(nums);
+        actual = solution1.findMaxLength(nums);
         assertEquals(expected, actual);
     }
 
     @Test
     public void test3() {
         nums = new int[]{0, 0, 1, 0, 0, 0, 1, 1};
         expected = 6;
-        actual = test.findMaxLength(nums);
+        actual = solution1.findMaxLength(nums);
         assertEquals(expected, actual);
     }