refactor 57

Author: fishercoder1534

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

@@ -1,31 +1,39 @@
 package com.fishercoder.solutions;
 
-import com.fishercoder.common.classes.Interval;
-
 import java.util.ArrayList;
 import java.util.List;
 
 public class _57 {
 
     public static class Solution1 {
-        public List<Interval> insert(List<Interval> intervals, Interval newInterval) {
-            List<Interval> result = new ArrayList<>();
+        public int[][] insert(int[][] intervals, int[] newInterval) {
+            List<int[]> list = new ArrayList<>();
             int i = 0;
             // add all the intervals ending before newInterval starts
-            while (i < intervals.size() && intervals.get(i).end < newInterval.start) {
-                result.add(intervals.get(i++));
+            while (i < intervals.length && intervals[i][intervals[i].length - 1] < newInterval[0]) {
+                list.add(intervals[i++]);
             }
             // merge all overlapping intervals to one considering newInterval
-            while (i < intervals.size() && intervals.get(i).start <= newInterval.end) {
-                newInterval = new Interval( // we could mutate newInterval here also
-                        Math.min(newInterval.start, intervals.get(i).start),
-                        Math.max(newInterval.end, intervals.get(i).end));
+            while (i < intervals.length && intervals[i][0] <= newInterval[newInterval.length - 1]) {
+                newInterval = new int[]{ // we could mutate newInterval here also
+                        Math.min(newInterval[0], intervals[i][0]),
+                        Math.max(newInterval[newInterval.length - 1], intervals[i][intervals[i].length - 1])};
                 i++;
             }
-            result.add(newInterval);
+            list.add(newInterval);
             // add all the rest
-            while (i < intervals.size()) {
-                result.add(intervals.get(i++));
+            while (i < intervals.length) {
+                list.add(intervals[i++]);
+            }
+            return convertToArray(list);
+        }
+
+        private int[][] convertToArray(List<int[]> list) {
+            int[][] result = new int[list.size()][list.get(0).length];
+            for (int i = 0; i < list.size(); i++) {
+                for (int j = 0; j < list.get(i).length; j++) {
+                    result[i][j] = list.get(i)[j];
+                }
             }
             return result;
         }

src/test/java/com/fishercoder/_57Test.java

@@ -1,22 +1,13 @@
 package com.fishercoder;
 
-import com.fishercoder.common.classes.Interval;
-import com.fishercoder.common.utils.CommonUtils;
 import com.fishercoder.solutions._57;
 import org.junit.BeforeClass;
 import org.junit.Test;
 
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-
 import static org.junit.Assert.assertEquals;
 
 public class _57Test {
     private static _57.Solution1 solution1;
-    private static List<Interval> intervals;
-    private static List<Interval> expected;
-    private static List<Interval> actual;
 
     @BeforeClass
     public static void setup() {
@@ -25,92 +16,28 @@ public static void setup() {
 
     @Test
     public void test1() {
-        intervals = new ArrayList<>(Arrays.asList(new Interval(1, 3), new Interval(6, 9)));
-        expected = new ArrayList<>(Arrays.asList(new Interval(1, 5), new Interval(6, 9)));
-        CommonUtils.printIntervals(intervals);
-        actual = solution1.insert(intervals, new Interval(2, 5));
-        CommonUtils.printIntervals(actual);
-        assertEquals(expected, actual);
+        assertEquals(new int[][]{
+                {1, 5},
+                {6, 9}
+        }, solution1.insert(new int[][]{
+                {1, 3},
+                {6, 9}
+        }, new int[]{2, 5}));
     }
 
 
     @Test
     public void test2() {
-        intervals = new ArrayList<>(Arrays.asList(new Interval(1, 2), new Interval(3, 5), new Interval(6, 7), new Interval(8, 10), new Interval(12, 16)));
-        CommonUtils.printIntervals(intervals);
-        expected = new ArrayList<>(Arrays.asList(new Interval(1, 2), new Interval(3, 10), new Interval(12, 16)));
-        actual = solution1.insert(intervals, new Interval(4, 9));
-        CommonUtils.printIntervals(actual);
-        assertEquals(expected, actual);
-    }
-
-    @Test
-    public void test3() {
-        intervals = new ArrayList<>(Arrays.asList(new Interval(1, 5)));
-        CommonUtils.printIntervals(intervals);
-        expected = new ArrayList<>(Arrays.asList(new Interval(1, 5)));
-        actual = solution1.insert(intervals, new Interval(2, 3));
-        CommonUtils.printIntervals(actual);
-        assertEquals(expected, actual);
-    }
-
-    @Test
-    public void test4() {
-        intervals = new ArrayList<>(Arrays.asList());
-        CommonUtils.printIntervals(intervals);
-        expected = new ArrayList<>(Arrays.asList(new Interval(5, 7)));
-        actual = solution1.insert(intervals, new Interval(5, 7));
-        CommonUtils.printIntervals(actual);
-        assertEquals(expected, actual);
-    }
-
-    @Test
-    public void test5() {
-        intervals = new ArrayList<>(Arrays.asList(new Interval(1, 5)));
-        expected = new ArrayList<>(Arrays.asList(new Interval(1, 5), new Interval(6, 8)));
-        CommonUtils.printIntervals(intervals);
-        actual = solution1.insert(intervals, new Interval(6, 8));
-        CommonUtils.printIntervals(actual);
-        assertEquals(expected, actual);
-    }
-
-    @Test
-    public void test6() {
-        intervals = new ArrayList<>(Arrays.asList(new Interval(1, 5)));
-        expected = new ArrayList<>(Arrays.asList(new Interval(0, 5)));
-        CommonUtils.printIntervals(intervals);
-        actual = solution1.insert(intervals, new Interval(0, 3));
-        CommonUtils.printIntervals(actual);
-        assertEquals(expected, actual);
-    }
-
-    @Test
-    public void test7() {
-        intervals = new ArrayList<>(Arrays.asList(new Interval(1, 5)));
-        expected = new ArrayList<>(Arrays.asList(new Interval(0, 0), new Interval(1, 5)));
-        CommonUtils.printIntervals(intervals);
-        actual = solution1.insert(intervals, new Interval(0, 0));
-        CommonUtils.printIntervals(actual);
-        assertEquals(expected, actual);
-    }
-
-    @Test
-    public void test8() {
-        intervals = new ArrayList<>(Arrays.asList(new Interval(2, 5), new Interval(6, 7), new Interval(8, 9)));
-        expected = new ArrayList<>(Arrays.asList(new Interval(0, 1), new Interval(2, 5), new Interval(6, 7), new Interval(8, 9)));
-        CommonUtils.printIntervals(intervals);
-        actual = solution1.insert(intervals, new Interval(0, 1));
-        CommonUtils.printIntervals(actual);
-        assertEquals(expected, actual);
-    }
-
-    @Test
-    public void test9() {
-        intervals = new ArrayList<>(Arrays.asList(new Interval(2, 4), new Interval(5, 7), new Interval(8, 10), new Interval(11, 13)));
-        expected = new ArrayList<>(Arrays.asList(new Interval(2, 7), new Interval(8, 10), new Interval(11, 13)));
-        CommonUtils.printIntervals(intervals);
-        actual = solution1.insert(intervals, new Interval(3, 6));
-        CommonUtils.printIntervals(actual);
-        assertEquals(expected, actual);
+        assertEquals(new int[][]{
+                {1, 2},
+                {3, 10},
+                {12, 16}
+        }, solution1.insert(new int[][]{
+                {1, 2},
+                {3, 5},
+                {6, 7},
+                {8, 10},
+                {12, 16}
+        }, new int[]{4, 9}));
     }
 }