update 163

Author: fishercoder1534

Diff for: src/main/java/com/fishercoder/solutions/_163.java

@@ -1,34 +1,33 @@
 package com.fishercoder.solutions;
 
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.List;
 
-/**
- * 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 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));
+        public List<List<Integer>> findMissingRanges(int[] nums, int lower, int upper) {
+            List<List<Integer>> missingRanges = new ArrayList<>();
+            if (nums == null || nums.length == 0) {
+                missingRanges.add(Arrays.asList(lower, upper));
+                return missingRanges;
+            }
+            //check for missing numbers between lower and nums[0]
+            if (lower < nums[0]) {
+                missingRanges.add(Arrays.asList(lower, nums[0] - 1));
+            }
+            //check for missing numbers between nums
+            for (int i = 0; i < nums.length - 1; i++) {
+                if (nums[i] + 1 == nums[i + 1]) {
+                    continue;
                 }
-                low = up;
+                missingRanges.add(Arrays.asList(nums[i] + 1, nums[i + 1] - 1));
+            }
+            //check for any missing numbers between nums[n - 1] and upper
+            if (nums[nums.length - 1] < upper) {
+                missingRanges.add(Arrays.asList(nums[nums.length - 1] + 1, upper));
             }
-            return result;
+            return missingRanges;
         }
     }
 }

Diff for: src/test/java/com/fishercoder/_163Test.java

@@ -1,87 +1,78 @@
 package com.fishercoder;
 
 import com.fishercoder.solutions._163;
-import org.junit.Before;
-import org.junit.BeforeClass;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.List;
 
-import static junit.framework.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class _163Test {
 
-  private static _163.Solution1 solution1;
-  private static List<String> expected;
-  private static List<String> actual;
-  private static int[] nums;
+    private static _163.Solution1 solution1;
+    private static List<List<Integer>> expected;
+    private static List<List<Integer>> actual;
+    private static int[] nums;
 
-  @BeforeClass
-  public static void setup() {
-    solution1 = new _163.Solution1();
-    expected = new ArrayList();
-    actual = new ArrayList();
-  }
+    @BeforeEach
+    public void setup() {
+        solution1 = new _163.Solution1();
+        expected = new ArrayList();
+        actual = new ArrayList();
 
-  @Before
-  public void setupForEachTest() {
-    expected.clear();
-    actual.clear();
-  }
+        expected.clear();
+        actual.clear();
+    }
 
-  @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
+    public void test1() {
+        nums = new int[]{2147483647};
+        expected.add(Arrays.asList(0, 2147483646));
+        actual = solution1.findMissingRanges(nums, 0, 2147483647);
+        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 test2() {
+        nums = new int[]{-2147483648, 0, 2147483647};
+        expected.add(Arrays.asList(-2147483647, -1));
+        expected.add(Arrays.asList(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 test3() {
+        nums = new int[]{};
+        expected.add(Arrays.asList(-2147483648, 2147483647));
+        actual = solution1.findMissingRanges(nums, -2147483648, 2147483647);
+        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 test4() {
+        nums = new int[]{2147483647};
+        expected.add(Arrays.asList(-2147483648, 2147483646));
+        actual = solution1.findMissingRanges(nums, -2147483648, 2147483647);
+        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 test5() {
+        nums = new int[]{};
+        expected.add(Arrays.asList(0, 2147483647));
+        actual = solution1.findMissingRanges(nums, 0, 2147483647);
+        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);
-  }
+    @Test
+    public void test6() {
+        nums = new int[]{-2147483648};
+        expected.add(Arrays.asList(-2147483647, 2147483647));
+        actual = solution1.findMissingRanges(nums, -2147483648, 2147483647);
+        assertEquals(expected, actual);
+    }
 }