refactor 163

Author: fishercoder1534

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

@@ -5,28 +5,30 @@
 
 /**
  * 163. Missing Ranges
+ *
  * Given a sorted integer array where the range of elements are in the inclusive range [lower, upper], return its missing ranges.
  * For example, given [0, 1, 3, 50, 75], lower = 0 and upper = 99, return ["2", "4->49", "51->74", "76->99"].
  */
 public class _163 {
-
-    public List<String> findMissingRanges(int[] nums, int lower, int upper) {
-        List<String> result = new ArrayList<>();
-        long low = (long) lower - 1;
-        long up = 0;
-        for (int i = 0; i <= nums.length; i++) {
-            if (i == nums.length) {
-                up = (long) upper + 1;
-            } else {
-                up = nums[i];
-            }
-            if (up == low + 2) {
-                result.add(low + 1 + "");
-            } else if (up > low + 2) {
-                result.add((low + 1) + "->" + (up - 1));
+    public static class Solution1 {
+        public List<String> findMissingRanges(int[] nums, int lower, int upper) {
+            List<String> result = new ArrayList<>();
+            long low = (long) lower - 1;
+            long up = 0;
+            for (int i = 0; i <= nums.length; i++) {
+                if (i == nums.length) {
+                    up = (long) upper + 1;
+                } else {
+                    up = nums[i];
+                }
+                if (up == low + 2) {
+                    result.add(low + 1 + "");
+                } else if (up > low + 2) {
+                    result.add((low + 1) + "->" + (up - 1));
+                }
+                low = up;
             }
-            low = up;
+            return result;
         }
-        return result;
     }
 }

src/test/java/com/fishercoder/_163Test.java

@@ -10,97 +10,78 @@
 
 import static junit.framework.Assert.assertEquals;
 
-/**
- * Created by fishercoder on 12/31/16.
- */
 public class _163Test {
 
-    private static _163 test;
-    private static List<String> expected;
-    private static List<String> actual;
-    private static int lower;
-    private static int upper;
-    private static int[] nums;
+  private static _163.Solution1 solution1;
+  private static List<String> expected;
+  private static List<String> actual;
+  private static int[] nums;
 
-    @BeforeClass
-    public static void setup() {
-        test = new _163();
-        expected = new ArrayList();
-        actual = new ArrayList();
-    }
+  @BeforeClass
+  public static void setup() {
+    solution1 = new _163.Solution1();
+    expected = new ArrayList();
+    actual = new ArrayList();
+  }
 
-    @Before
-    public void setupForEachTest() {
-        expected.clear();
-        actual.clear();
-    }
+  @Before
+  public void setupForEachTest() {
+    expected.clear();
+    actual.clear();
+  }
 
-    @Test
-    public void test1() {
+  @Test
+  public void test1() {
+    //solution1 case 1: should return ["0->2147483646"]
+    nums = new int[] {2147483647};
+    expected.add("0->2147483646");
+    actual = solution1.findMissingRanges(nums, 0, 2147483647);
+    assertEquals(expected, actual);
+  }
 
-        //test case 1: should return ["0->2147483646"]
-        lower = 0;
-        upper = 2147483647;
-        nums = new int[]{2147483647};
-        expected.add("0->2147483646");
-        actual = test.findMissingRanges(nums, lower, upper);
-        assertEquals(expected, actual);
+  @Test
+  public void test2() {
+    //solution1 case 2: should return ["-2147483647->-1","1->2147483646"]
+    nums = new int[] {-2147483648, -2147483648, 0, 2147483647, 2147483647};
+    expected.add("-2147483647->-1");
+    expected.add("1->2147483646");
+    actual = solution1.findMissingRanges(nums, -2147483648, 2147483647);
+    assertEquals(expected, actual);
+  }
 
-    }
+  @Test
+  public void test3() {
+    //solution1 case 3: should return ["-2147483648->2147483647"]
+    nums = new int[] {};
+    expected.add("-2147483648->2147483647");
+    actual = solution1.findMissingRanges(nums, -2147483648, 2147483647);
+    assertEquals(expected, actual);
+  }
 
-    @Test
-    public void test2() {
-        //test case 2: should return ["-2147483647->-1","1->2147483646"]
-        lower = -2147483648;
-        upper = 2147483647;
-        nums = new int[]{-2147483648, -2147483648, 0, 2147483647, 2147483647};
-        expected.add("-2147483647->-1");
-        expected.add("1->2147483646");
-        actual = test.findMissingRanges(nums, lower, upper);
-        assertEquals(expected, actual);
-    }
+  @Test
+  public void test4() {
+    //solution1 case 4: should return ["-2147483648->2147483646"]
+    nums = new int[] {2147483647};
+    expected.add("-2147483648->2147483646");
+    actual = solution1.findMissingRanges(nums, -2147483648, 2147483647);
+    assertEquals(expected, actual);
+  }
 
-    @Test
-    public void test3() {
-        //test case 3: should return ["-2147483648->2147483647"]
-        lower = -2147483648;
-        upper = 2147483647;
-        nums = new int[]{};
-        expected.add("-2147483648->2147483647");
-        actual = test.findMissingRanges(nums, lower, upper);
-        assertEquals(expected, actual);
-    }
+  @Test
+  public void test5() {
+    //solution1 case 5: should return ["0->2147483647"]
+    nums = new int[] {};
+    expected.add("0->2147483647");
+    actual = solution1.findMissingRanges(nums, 0, 2147483647);
+    assertEquals(expected, actual);
+  }
 
-    @Test
-    public void test4() {
-        //test case 4: should return ["-2147483648->2147483646"]
-        lower = -2147483648;
-        upper = 2147483647;
-        nums = new int[]{2147483647};
-        expected.add("-2147483648->2147483646");
-        actual = test.findMissingRanges(nums, lower, upper);
-        assertEquals(expected, actual);
-    }
-
-    @Test
-    public void test5() {
-        //test case 5: should return ["0->2147483647"]
-        lower = 0;
-        upper = 2147483647;
-        nums = new int[]{};
-        expected.add("0->2147483647");
-        actual = test.findMissingRanges(nums, lower, upper);
-        assertEquals(expected, actual);
-    }
-
-    @Test
-    public void test6() {
-        //test case 6: should return ["-2147483647->2147483647"]
-        lower = -2147483648;
-        upper = 2147483647;
-        nums = new int[]{-2147483648};
-        expected.add("-2147483647->2147483647");
-        actual = test.findMissingRanges(nums, lower, upper);
-        assertEquals(expected, actual);
-    }
+  @Test
+  public void test6() {
+    //solution1 case 6: should return ["-2147483647->2147483647"]
+    nums = new int[] {-2147483648};
+    expected.add("-2147483647->2147483647");
+    actual = solution1.findMissingRanges(nums, -2147483648, 2147483647);
+    assertEquals(expected, actual);
+  }
 }