[N-0] refactor 370

fishercoder1534 · fishercoder1534 · commit a7c1b09c5037 · 2017-11-04T09:40:16.000-07:00
diff --git a/README.md b/README.md
@@ -295,7 +295,7 @@ Your ideas/fixes/algorithms are more than welcome!
 |373|[Find K Pairs with Smallest Sums](https://leetcode.com/problems/find-k-pairs-with-smallest-sums/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_373.java)| O(klogk)|O(k) | Medium| Heap
 |372|[Super Pow](https://leetcode.com/problems/super-pow/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_372.java)| O(n)|O(1) | Medium| Math
 |371|[Sum of Two Integers](https://leetcode.com/problems/sum-of-two-integers/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_371.java)| O(n)|O(1) | Easy| 
-|370|[Range Addition](https://leetcode.com/problems/range-addition/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_370.java)| O(n+k)|O(1) | Medium| 
+|370|[Range Addition](https://leetcode.com/problems/range-addition/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_370.java)| O(n+k)|O(1) | Medium|Array 
 |369|[Plus One Linked List](https://leetcode.com/problems/plus-one-linked-list/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_369.java)| O(n)|O(1) | Medium| Linked List
 |368|[Largest Divisible Subset](https://leetcode.com/problems/largest-divisible-subset/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_368.java)| O(n^2)|O(n) | Medium| DP
 |367|[Valid Perfect Square](https://leetcode.com/problems/valid-perfect-square/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_367.java)| O(n)|O(1) | Medium| 
diff --git a/src/main/java/com/fishercoder/solutions/_370.java b/src/main/java/com/fishercoder/solutions/_370.java
@@ -1,10 +1,12 @@
 package com.fishercoder.solutions;
 
-/**Assume you have an array of length n initialized with all 0's and are given k update operations.
-
- Each operation is represented as a triplet: [startIndex, endIndex, inc] which increments each element of subarray A[startIndex ... endIndex] (startIndex and endIndex inclusive) with inc.
-
- Return the modified array after all k operations were executed.
+/**
+ * 370. Range Addition
+ *
+ * Assume you have an array of length n initialized with all 0's and are given k update operations.
+ * Each operation is represented as a triplet: [startIndex, endIndex, inc]
+ * which increments each element of subarray A[startIndex ... endIndex] (startIndex and endIndex inclusive) with inc.
+ * Return the modified array after all k operations were executed.
 
  Example:
 
@@ -33,65 +35,35 @@
 
  After applying operation [0, 2, -2]:
  [-2, 0, 3, 5, 3 ]
- Hint:
 
+ Hint:
  Thinking of using advanced data structures? You are thinking it too complicated.
  For each update operation, do you really need to update all elements between i and j?
  Update only the first and end element is sufficient.
- The optimal time complexity is O(k + n) and uses O(1) extra space.*/
+ The optimal time complexity is O(k + n) and uses O(1) extra space.
+ */
 
 public class _370 {
-    /**Previously AC'ed brute force solution results in TLE now.*/
-    public static int[] getModifiedArray_TLE(int length, int[][] updates) {
-        int[] nums = new int[length];
-        int k = updates.length;
-        for (int i = 0; i < k; i++) {
-            int start = updates[i][0];
-            int end = updates[i][1];
-            int inc = updates[i][2];
-            for (int j = start; j <= end; j++) {
-                nums[j] += inc;
+    public static class Solution1 {
+        public int[] getModifiedArray(int length, int[][] updates) {
+            int[] nums = new int[length];
+            int k = updates.length;
+            for (int i = 0; i < k; i++) {
+                int start = updates[i][0];
+                int end = updates[i][1];
+                int inc = updates[i][2];
+                nums[start] += inc;
+                if (end < length - 1) {
+                    nums[end + 1] -= inc;
+                }
             }
-        }
-        return nums;
-    }
 
-    /**
-     * Looked at this post: https://discuss.leetcode.com/topic/49691/java-o-k-n-time-complexity-solution and one OJ official article: https://leetcode.com/articles/range-addition/
-     */
-    public static int[] getModifiedArray(int length, int[][] updates) {
-        int[] nums = new int[length];
-        int k = updates.length;
-        for (int i = 0; i < k; i++) {
-            int start = updates[i][0];
-            int end = updates[i][1];
-            int inc = updates[i][2];
-            nums[start] += inc;
-            if (end < length - 1) {
-                nums[end + 1] -= inc;
+            int sum = 0;
+            for (int i = 0; i < length; i++) {
+                sum += nums[i];
+                nums[i] = sum;
             }
-        }
-
-        int sum = 0;
-        for (int i = 0; i < length; i++) {
-            sum += nums[i];
-            nums[i] = sum;
-        }
-        return nums;
-    }
-
-    public static void main(String... args) {
-        /**5
-         [[1,3,2],[2,4,3],[0,2,-2]]*/
-        int length = 5;
-        int[][] updates = new int[][]{
-                {1, 3, 2},
-                {2, 4, 3},
-                {0, 2, -2},
-        };
-        int[] result = getModifiedArray(length, updates);
-        for (int i : result) {
-            System.out.print(i + "\t");
+            return nums;
         }
     }
 }
diff --git a/src/test/java/com/fishercoder/_370Test.java b/src/test/java/com/fishercoder/_370Test.java
@@ -0,0 +1,32 @@
+package com.fishercoder;
+
+import com.fishercoder.solutions._370;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static org.junit.Assert.assertArrayEquals;
+
+public class _370Test {
+    private static _370.Solution1 solution1;
+    private static int[][] updates;
+    private static int length;
+    private static int[] expected;
+
+    @BeforeClass
+    public static void setup() {
+        solution1 = new _370.Solution1();
+    }
+
+    @Test
+    public void test1() {
+        updates = new int[][]{
+                {1, 3, 2},
+                {2, 4, 3},
+                {0, 2, -2},
+        };
+        length = 5;
+        expected = new int[]{-2, 0, 3, 5, 3};
+        assertArrayEquals(expected, solution1.getModifiedArray(length, updates));
+    }
+
+}
