Add the solutions for #118, #120, #239, #981

Author: rayworks

src/main/java/org/sean/array/PascalTriangle.java

@@ -0,0 +1,51 @@
+package org.sean.array;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.LinkedList;
+import java.util.List;
+
+// 118. Pascal's Triangle
+public class PascalTriangle {
+    public static void main(String[] args) {
+        PascalTriangle solution = new PascalTriangle();
+        System.out.println(Arrays.toString(solution.generate(5).toArray()));
+    }
+
+    public List<List<Integer>> generate(int numRows) {
+        List<List<Integer>> lists = new LinkedList<>();
+        if (numRows == 0) return lists;
+
+        List<Integer> firstList = new ArrayList<>();
+        firstList.add(1);
+        lists.add(firstList);
+        if (numRows == 1) {
+            return lists;
+        }
+
+        List<Integer> secondList = new ArrayList<>();
+        secondList.add(1);
+        secondList.add(1);
+        lists.add(secondList);
+
+        if (numRows == 2) {
+            return lists;
+        }
+
+        for (int i = 2; i < numRows; i++) {
+            ArrayList<Integer> list = new ArrayList<>(i + 1);
+            for (int k = 0; k < (i + 1); k++) {
+                list.add(1);
+            }
+
+            List<Integer> preList = lists.get(i - 1);
+            for (int j = 1; j < i; j++) {
+                list.set(j, preList.get(j - 1) + preList.get(j));
+            }
+
+            lists.add(list);
+        }
+
+        return lists;
+    }
+}

src/main/java/org/sean/array/SlidingWindowMax.java

@@ -0,0 +1,42 @@
+package org.sean.array;
+
+import java.util.LinkedList;
+
+// 239. Sliding Window Maximum
+public class SlidingWindowMax {
+    public int[] maxSlidingWindow(int[] nums, int k) {
+        if(nums == null || nums.length == 0) {
+            return new int[0];
+        }
+
+        if (k == 1) {
+            return nums;
+        }
+
+        LinkedList<Integer> deque = new LinkedList<>();
+        int len = nums.length;
+
+        // replace List with raw Array
+        int[] res = new int[len - k + 1];
+        for (int i = 0; i < len ; i++) {
+            int elem = nums[i];
+            // delete the left-out element
+            if(i >= k && deque.peek() < i - k + 1) {
+                deque.pop();
+            }
+
+            // remove the left smaller elements
+            while (!deque.isEmpty() && nums[deque.peekLast()] <= elem) {
+                deque.removeLast();
+            }
+
+            deque.add(i); // index
+
+            if(i >= k - 1 && !deque.isEmpty()) {
+                res[i - (k - 1)] = nums[deque.peek()];
+            }
+        }
+
+        return res;
+    }
+}

src/main/java/org/sean/array/TimeMap.java

@@ -0,0 +1,59 @@
+package org.sean.array;
+
+import java.util.*;
+
+// 981. Time Based Key-Value Store
+public class TimeMap {
+    private static final String EMPTY = "";
+    private HashMap<String, SortedMap<Integer, String>> map;
+
+    /** Initialize your data structure here. */
+    public TimeMap() {
+        map = new HashMap<>();
+    }
+
+    // [foo, bar 1]
+    // [foo, bar 3]
+    // [foo, bar2, 4]
+    // -> (foo, 1) // (foo, 3) // (foo, 4) // (foo, 5)
+    public void set(String key, String value, int timestamp) {
+        if (map.containsKey(key)) {
+            SortedMap<Integer, String> valMap = map.get(key);
+            valMap.put(timestamp, value); // with timestamps increasing strictly
+        } else {
+            TreeMap<Integer, String> subMap = new TreeMap<>();
+            subMap.put(timestamp, value);
+            map.put(key, subMap);
+        }
+    }
+
+    public String get(String key, int timestamp) {
+        if (!map.containsKey(key)) return EMPTY;
+
+        TreeMap<Integer, String> sortedMap = (TreeMap<Integer, String>) map.get(key);
+        if (sortedMap.containsKey(timestamp)) {
+            return sortedMap.get(timestamp);
+        } else {
+            Integer lowerKey = sortedMap.lowerKey(timestamp);
+            if (lowerKey == null) {
+                return EMPTY;
+            } else {
+                return sortedMap.get(lowerKey);
+            }
+        }
+    }
+}
+
+/**
+ * Your TimeMap object will be instantiated and called as such:
+ * TimeMap obj = new TimeMap();
+ * obj.set(key,value,timestamp);
+ * String param_2 = obj.get(key,timestamp);
+ */
+
+/*Note:
+All key/value strings are lowercase.
+All key/value strings have length in the range [1, 100]
+The timestamps for all TimeMap.set operations are strictly increasing.
+1 <= timestamp <= 10^7
+TimeMap.set and TimeMap.get functions will be called a total of 120000 times (combined) per test case.*/

src/main/java/org/sean/array/Triangle.java

@@ -0,0 +1,72 @@
+package org.sean.array;
+
+import java.util.*;
+
+// 120. Triangle
+public class Triangle {
+    private int minSum = Integer.MAX_VALUE;
+
+    public int minimumTotal(List<List<Integer>> triangle) {
+        if (triangle == null || triangle.size() == 0) {
+            return 0;
+        }
+
+        // dfs(triangle, 0, 0, "", 0);
+        int row = triangle.size();
+        for (int i = row - 2; i >= 0; i--) {
+            for (int j = 0; j < triangle.get(i).size(); j++) {
+                triangle.get(i)
+                        .set(
+                                j,
+                                triangle.get(i).get(j)
+                                        + Math.min(
+                                                triangle.get(i + 1).get(j),
+                                                triangle.get(i + 1).get(j + 1)));
+            }
+        }
+
+        System.out.println(String.format(">>> minSum is %d", triangle.get(0).get(0)));
+
+        List<Integer> integers = new ArrayList<Integer>(5);
+        Collections.fill(integers, 1);
+
+        return 0;
+    }
+
+    // brute force : time out
+    private void dfs(List<List<Integer>> triangle, int row, int col, String path, int sum) {
+        if (row == triangle.size()) {
+            if (minSum > sum) {
+                minSum = sum;
+            }
+
+            System.out.println(path);
+            return;
+        }
+
+        path += " -> ";
+
+        path += triangle.get(row).get(col);
+        sum += triangle.get(row).get(col);
+
+        dfs(triangle, row + 1, col, path, sum);
+        dfs(triangle, row + 1, col + 1, path, sum);
+    }
+
+    public static <T> List<T> asList(T... items) {
+        List<T> list = new ArrayList<T>();
+        for (T item : items) {
+            list.add(item);
+        }
+
+        return list;
+    }
+
+    public static void main(String[] args) {
+        Triangle solution = new Triangle();
+        List<List<Integer>> triangle =
+                asList(asList(2), asList(3, 4), asList(6, 5, 7), asList(4, 1, 8, 3));
+
+        solution.minimumTotal(triangle);
+    }
+}

src/test/java/org/sean/array/SlidingWindowMaxTest.java

@@ -0,0 +1,21 @@
+package org.sean.array;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+public class SlidingWindowMaxTest {
+
+    private SlidingWindowMax slidingWindowMax;
+
+    @Before
+    public void setUp() throws Exception {
+        slidingWindowMax = new SlidingWindowMax();
+    }
+
+    @Test
+    public void maxSlidingWindow() {
+        int[] ints = slidingWindowMax.maxSlidingWindow(new int[] {1, 3, -1, -3, 5, 3, 6, 7}, 3);
+        Assert.assertArrayEquals(new int[] {3, 3, 5, 5, 6, 7}, ints);
+    }
+}