Refactor

Author: ex01tus

.DS_Store

@@ -1,4 +1,4 @@
-package w1;
+package array;
 
 /**
  * Description: https://leetcode.com/problems/best-time-to-buy-and-sell-stock

src/.DS_Store

@@ -0,0 +1,43 @@
+package array;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Description: https://leetcode.com/problems/combination-sum
+ * Difficulty: Medium
+ * Time complexity: O(n * n!)
+ * Space complexity: O(n)
+ */
+public class CombinationSum {
+
+    public List<List<Integer>> combinationSum(int[] candidates, int target) {
+        List<List<Integer>> result = new ArrayList<>();
+        backtrack(candidates, target, new ArrayList<>(), 0, result);
+
+        return result;
+    }
+
+    private void backtrack(
+            int[] candidates,
+            int remains,
+            List<Integer> permutation,
+            int start,
+            List<List<Integer>> result) {
+        if (remains == 0) {
+            result.add(permutation);
+            return;
+        }
+
+        if (remains < 0) {
+            return;
+        }
+
+        for (int i = start; i < candidates.length; i++) {
+            List<Integer> newPermutation = new ArrayList<>(permutation);
+            newPermutation.add(candidates[i]);
+
+            backtrack(candidates, remains - candidates[i], newPermutation, i, result);
+        }
+    }
+}

src/w1/BestTimeToBuyAndSellStock.java renamed to src/array/BestTimeToBuyAndSellStock.java

@@ -1,4 +1,4 @@
-package w2;
+package array;
 
 import java.util.HashSet;
 import java.util.Set;

src/array/CombinationSum.java

@@ -1,4 +1,4 @@
-package w3;
+package array;
 
 import java.util.ArrayList;
 import java.util.List;

src/w2/ContainsDuplicate.java renamed to src/array/ContainsDuplicate.java

@@ -1,4 +1,4 @@
-package w2;
+package array;
 
 import java.util.Arrays;
 

src/w3/InsertInterval.java renamed to src/array/InsertInterval.java

@@ -0,0 +1,38 @@
+package array;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * Description: https://leetcode.com/problems/merge-intervals
+ * Difficulty: Medium
+ * Time complexity: O(nlog n)
+ * Space complexity: O(n)
+ */
+public class MergeIntervals {
+
+    public int[][] merge(int[][] intervals) {
+        if (intervals.length < 2) return intervals;
+
+        Arrays.sort(intervals, (i1, i2) -> Integer.compare(i1[0], i2[0]));
+
+        int start = intervals[0][0];
+        int end = intervals[0][1];
+
+        List<int[]> result = new ArrayList<>();
+        for (int[] current : intervals) {
+            if (current[0] > end) {
+                result.add(new int[]{start, end});
+                start = current[0];
+                end = current[1];
+            } else {
+                end = Math.max(current[1], end);
+            }
+        }
+
+        result.add(new int[]{start, end});
+
+        return result.toArray(new int[0][]);
+    }
+}

src/w2/MajorityElement.java renamed to src/array/MajorityElement.java

@@ -0,0 +1,28 @@
+package array;
+
+/**
+ * Description: https://leetcode.com/problems/product-of-array-except-self
+ * Difficulty: Medium
+ * Time complexity: O(n)
+ * Space complexity: O(1)
+ */
+public class ProductOfArrayExceptSelf {
+
+    public int[] productExceptSelf(int[] nums) {
+        int[] result = new int[nums.length];
+
+        int left = 1;
+        for (int i = 0; i < nums.length; i++) {
+            result[i] = left;
+            left *= nums[i];
+        }
+
+        int right = 1;
+        for (int i = nums.length - 1; i >= 0; i--) {
+            result[i] *= right;
+            right *= nums[i];
+        }
+
+        return result;
+    }
+}

src/array/MergeIntervals.java

@@ -0,0 +1,93 @@
+package array;
+
+/**
+ * Description: https://leetcode.com/problems/sort-colors
+ * Difficulty: Medium
+ */
+public class SortColors {
+
+    private static final int RED = 0;
+    private static final int WHITE = 1;
+    private static final int BLUE = 2;
+
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(1)
+     */
+    public void sortColorsViaDutchFlagAlgo(int[] nums) {
+        int red = 0;
+        int white = 0;
+        int blue = nums.length - 1;
+
+        while (white <= blue) {
+            if (nums[white] == WHITE) {
+                white++;
+            } else if (nums[white] == RED) {
+                swap(nums, white, red);
+                white++;
+                red++;
+            } else { // nums[white] == BLUE
+                swap(nums, white, blue);
+                blue--;
+            }
+        }
+    }
+
+    /**
+     * Time complexity: O(n * k)
+     * Space complexity: O(k)
+     */
+    public void sortColorsViaCountingSort(int[] nums) {
+        int[] count = new int[3];
+
+        for (int color : nums) {
+            count[color]++;
+        }
+
+        int k = 0;
+        for (int i = 0; i < count.length; i++) {
+            int colorCount = count[i];
+            for (int j = 0; j < colorCount; j++) {
+                nums[k] = i;
+                k++;
+            }
+        }
+    }
+
+    /**
+     * Time complexity: O(nlog n)
+     * Space complexity: O(log n)
+     */
+    public void sortColorsViaInPlaceQuickSort(int[] nums) {
+        quickSort(nums, 0, nums.length - 1);
+    }
+
+    private void quickSort(int[] nums, int left, int right) {
+        if (left >= right) return;
+
+        int l = left;
+        int r = right;
+        int pivot = nums[l + (r - l) / 2];
+
+        while (l <= r) {
+            if (nums[l] < pivot) {
+                l++;
+            } else if (nums[r] > pivot) {
+                r--;
+            } else {
+                swap(nums, l, r);
+                l++;
+                r--;
+            }
+        }
+
+        quickSort(nums, left, r);
+        quickSort(nums, l, right);
+    }
+
+    private void swap(int[] nums, int i, int j) {
+        int tmp = nums[i];
+        nums[i] = nums[j];
+        nums[j] = tmp;
+    }
+}

src/array/ProductOfArrayExceptSelf.java

@@ -1,4 +1,4 @@
-package w3;
+package array;
 
 import java.util.*;
 

src/array/SortColors.java

@@ -1,4 +1,4 @@
-package w1;
+package array;
 
 import java.util.HashMap;
 import java.util.Map;

src/w3/TreeSum.java renamed to src/array/TreeSum.java

@@ -1,4 +1,4 @@
-package w2;
+package binary;
 
 /**
  * Description: https://leetcode.com/problems/add-binary

src/w1/TwoSum.java renamed to src/array/TwoSum.java

@@ -1,4 +1,4 @@
-package w1;
+package binary_search;
 
 /**
  * Description: https://leetcode.com/problems/binary-search

src/w2/AddBinary.java renamed to src/binary/AddBinary.java

@@ -1,4 +1,4 @@
-package w2;
+package binary_search;
 
 /**
  * Description: https://leetcode.com/problems/first-bad-version

src/w1/BinarySearch.java renamed to src/binary_search/BinarySearch.java

@@ -0,0 +1,53 @@
+package binary_search;
+
+/**
+ * Description: https://leetcode.com/problems/search-in-rotated-sorted-array
+ * Difficulty: Medium
+ * Time complexity: O(log n)
+ * Space complexity: O(1)
+ */
+public class SearchInRotatedSortedArray {
+
+    public int findTarget(int[] nums, int target) {
+        int pivot = findPivot(nums);
+
+        return target >= nums[pivot] && target <= nums[nums.length - 1]
+                ? findTarget(nums, pivot, nums.length - 1, target)
+                : findTarget(nums, 0, pivot - 1, target);
+    }
+
+    private int findPivot(int[] nums) {
+        int left = 0;
+        int right = nums.length - 1;
+
+        while (left < right) {
+            int mid = (left + right) / 2;
+
+            if (nums[mid] >= nums[0]) {
+                left = mid + 1;
+            } else {
+                right = mid;
+            }
+        }
+
+        return left;
+    }
+
+    private int findTarget(int[] nums, int left, int right, int target) {
+        while (left <= right) {
+            int mid = (left + right) / 2;
+
+            if (nums[mid] == target) {
+                return mid;
+            }
+
+            if (nums[mid] > target) {
+                right = mid - 1;
+            } else {
+                left = mid + 1;
+            }
+        }
+
+        return -1;
+    }
+}

src/w2/FirstBadVersion.java renamed to src/binary_search/FirstBadVersion.java

@@ -0,0 +1,65 @@
+package binary_search;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Description: https://leetcode.com/problems/time-based-key-value-store
+ * Difficulty: Medium
+ * Time complexity: O(log n)
+ * Space complexity: O(n)
+ */
+public class TimeBasedKeyValueStore {
+
+    private final Map<String, List<Node>> map;
+
+    public TimeBasedKeyValueStore() {
+        map = new HashMap<>();
+    }
+
+    public void set(String key, String value, int timestamp) {
+        map.computeIfAbsent(key, k -> new ArrayList<>())
+                .add(new Node(value, timestamp));
+    }
+
+    public String get(String key, int timestamp) {
+        List<Node> list = map.get(key);
+        if (list == null) return "";
+
+        return search(list, timestamp);
+    }
+
+    private String search(List<Node> list, int target) {
+        int left = 0;
+        int right = list.size() - 1;
+
+        String result = "";
+        while (left <= right) {
+            int mid = (left + right) / 2;
+            if (list.get(mid).timestamp == target) {
+                return list.get(mid).value;
+            }
+
+            if (list.get(mid).timestamp > target) {
+                right = mid - 1;
+            } else {
+                result = list.get(mid).value;
+                left = mid + 1;
+            }
+        }
+
+        return result;
+    }
+
+    private static class Node {
+        String value;
+        int timestamp;
+
+        public Node(String v, int t) {
+            value = v;
+            timestamp = t;
+        }
+    }
+}

src/binary_search/SearchInRotatedSortedArray.java

@@ -1,4 +1,4 @@
-package w1;
+package binary_search_tree;
 
 /**
  * Description: https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-search-tree