practice

Author: metanet

src/problems/leetcode/CombinationSum.java

@@ -0,0 +1,51 @@
+package problems.leetcode;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+// https://leetcode.com/problems/combination-sum/
+public class CombinationSum {
+
+    // runtime: O(2 ^ N) where N is number of candidates
+    // space: O(N)
+    public static List<List<Integer>> combinationSum(int[] candidates, int target) {
+        if (candidates == null || candidates.length < 1) {
+            return Collections.emptyList();
+        }
+        Arrays.sort(candidates);
+        List<List<Integer>> result = new ArrayList<>();
+        combinationSum(candidates, target, 0, 0, new ArrayList<>(), result);
+        return result;
+    }
+
+    private static void combinationSum(int[] candidates, int target, int i, int currentSum, List<Integer> current,
+            List<List<Integer>> result) {
+        if (i >= candidates.length) {
+            return;
+        }
+
+        int candidate = candidates[i];
+        if (currentSum + candidate == target) {
+            current.add(candidate);
+            result.add(new ArrayList<>(current));
+            current.remove(current.size() - 1);
+            return;
+        } else if (currentSum + candidate < target) {
+            current.add(candidate);
+            combinationSum(candidates, target, i, currentSum + candidate, current, result);
+            current.remove(current.size() - 1);
+        } else {
+            return;
+        }
+
+        combinationSum(candidates, target, i + 1, currentSum, current, result);
+    }
+
+    public static void main(String[] args) {
+        System.out.println(combinationSum(new int[] { 2, 3, 6, 7 }, 6));
+        System.out.println(combinationSum(new int[] { 4, 2, 8 }, 8));
+    }
+
+}

src/problems/leetcode/CountAndSay.java

@@ -0,0 +1,37 @@
+package problems.leetcode;
+
+// https://leetcode.com/problems/count-and-say/
+public class CountAndSay {
+
+    // runtime: O(N)
+    // space: O(N) due to recursive call stack
+    public static String countAndSay(int n) {
+        if (n < 2) {
+            return "1";
+        }
+
+        String s = countAndSay(n - 1);
+        StringBuilder sb = new StringBuilder();
+        int current = s.charAt(0) - '0', count = 1;
+        
+        for (int i = 1; i < s.length(); i++) {
+            int num = s.charAt(i) - '0';
+            if (current == num) {
+                count++;
+            } else {
+                sb.append(count).append(current);
+                current = num;
+                count = 1;
+            }
+        }
+
+        sb.append(count).append(current);
+
+        return sb.toString();
+    }
+
+    public static void main(String[] args) {
+        System.out.println(countAndSay(2));
+    }
+    
+}

src/problems/leetcode/FirstMissingPositive.java

@@ -0,0 +1,65 @@
+package problems.leetcode;
+
+import java.util.Arrays;
+
+// https://leetcode.com/problems/first-missing-positive/
+public class FirstMissingPositive {
+
+    public static int firstMissingPositive(int[] nums) {
+        // https://leetcode.com/problems/first-missing-positive/solutions/17214/Java-simple-solution-with-documentation/
+
+        // Ignore all numbers <=0 and >n since they are outside the range of possible
+        // answers (which we proved was [1..n]). We do this by replacing them with the
+        // value n+1.
+        // For all other integers <n+1, mark their bucket (cell) to indicate the integer
+        // exists. (*see below)
+        // Find the first cell not marked, that is the first missing integer. If you did
+        // not find an unmarked cell, there was no missing integer, so return n+1.
+
+        int n = nums.length;
+
+        // 1. mark numbers (num < 0) and (num > n) with a special marker number (n+1)
+        // (we can ignore those because if all number are > n then we'll simply return
+        // 1)
+        for (int i = 0; i < n; i++) {
+            if (nums[i] < 1 || nums[i] > n) {
+                nums[i] = n + 1;
+            }
+        }
+        System.out.println(Arrays.toString(nums));
+        // note: all number in the array are now positive, and on the range 1..n+1
+
+        // 2. mark each cell appearing in the array, by converting the index for that
+        // number to negative
+        for (int i = 0; i < n; i++) {
+            int num = Math.abs(nums[i]);
+            if (num > n) {
+                continue;
+            }
+            int numIndex = num - 1;
+            if (nums[numIndex] > 0) { // prevents double negative operations
+                nums[numIndex] = -1 * nums[numIndex];
+            }
+        }
+        System.out.println(Arrays.toString(nums));
+
+        // 3. find the first cell which isn't negative (doesn't appear in the array)
+        for (int i = 0; i < n; i++) {
+            if (nums[i] >= 0) {
+                return i + 1;
+            }
+        }
+
+        // 4. no positive numbers were found, which means the array contains all numbers
+        // 1..n
+        return n + 1;
+    }
+
+    public static void main(String[] args) {
+        System.out.println(firstMissingPositive(new int[] { 1, 2, 0 }));
+        System.out.println(firstMissingPositive(new int[] { 3, 4, -1, 1 }));
+        System.out.println(firstMissingPositive(new int[] { 7, 8, 9, 11, 12 }));
+        System.out.println(firstMissingPositive(new int[] { 1, 8, 9, 11, 12 }));
+    }
+
+}

src/problems/leetcode/JumpGame.java

@@ -6,26 +6,44 @@
 public class JumpGame {
 
     public static void main(String[] args) {
-//        int[] nums = {2, 3, 1, 1, 4};
-        int[] nums = {3, 2, 1, 0, 4};
-        System.out.println(canJump(nums));
+        // int[] nums = {2, 3, 1, 1, 4};
+        int[] nums = { 3, 2, 1, 0, 4 };
+        System.out.println(canJumpON(nums));
     }
 
-    public static boolean canJump(int[] nums) {
-        if (nums == null) {
+    // runtime: O(N)
+    // space: O(1)
+    public static boolean canJumpON(int[] nums) {
+        for (int i = 0, boundary = 0; i <= boundary; i++) {
+            boundary = Math.max(boundary, i + nums[i]);
+            if (boundary >= nums.length - 1) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    // runtime: O(N^2)
+    // space: O(N)
+    public static boolean canJumpDP(int[] nums) {
+        if (nums == null || nums.length < 1) {
             return false;
         }
 
-        int n = nums.length;
-        boolean[] jumps = new boolean[n];
-        jumps[n - 1] = true;
-        for (int i = n - 2; i >= 0; i--) {
-            for (int j = 1, maxJump = nums[i]; j <= maxJump; j++) {
-                jumps[i] |= jumps[i + j];
+        boolean[] success = new boolean[nums.length];
+        int i = nums.length - 1;
+        success[i--] = true;
+        for (; i >= 0; i--) {
+            for (int j = 1; j <= nums[i] && i + j < nums.length; j++) {
+                if (success[i + j]) {
+                    success[i] = true;
+                    break;
+                }
             }
         }
 
-        return jumps[0];
+        return success[0];
     }
 
 }

src/problems/leetcode/JumpGameII.java

@@ -5,6 +5,49 @@
  */
 public class JumpGameII {
 
+    // runtime: O(N^2)
+    // space: O(N)
+    public static int jumpON2(int[] nums) {
+        int n = nums.length;
+        int[] counts = new int[n];
+        for (int i = n - 2; i >= 0; i--) {
+            int jumps = Integer.MAX_VALUE;
+            for (int j = 1; j <= nums[i] && i + j < n; j++) {
+                int c = counts[i + j];
+                if (c != Integer.MAX_VALUE) {
+                    jumps = Math.min(jumps, 1 + c);
+                }
+
+            }
+            counts[i] = jumps;
+        }
+
+        return counts[0];
+    }
+
+    // runtime: O(N)
+    // space: O(1)
+    // https://leetcode.com/problems/jump-game-ii/editorial/
+    public static int jumpGreedy(int[] nums) {
+        // The starting range of the first jump is [0, 0]
+        int answer = 0, n = nums.length;
+        int curEnd = 0, curFar = 0;
+
+        for (int i = 0; i < n - 1; ++i) {
+            // Update the farthest reachable index of this jump.
+            curFar = Math.max(curFar, i + nums[i]);
+
+            // If we finish the starting range of this jump,
+            // Move on to the starting range of the next jump.
+            if (i == curEnd) {
+                answer++;
+                curEnd = curFar;
+            }
+        }
+
+        return answer;
+    }
+
     public static int jumpON(int[] nums) {
         if (nums == null) {
             return 0;
@@ -32,31 +75,33 @@ public static int jumpON(int[] nums) {
         return jumpCount;
     }
 
+    // https://leetcode.com/problems/jump-game-ii/editorial/comments/1776566
     public static int jump(int[] nums) {
         if (nums == null) {
             return 0;
         }
 
-        int steps = 0;
-        for (int l = 0, r = 0; r < nums.length - 1; steps++) {
-            int next = r;
-            for (int i = l; i <= r; i++) {
-                next = Math.max(next, nums[i] + i);
+        int steps = 0, low = 0, high = 0, n = nums.length;
+        while (high < n - 1) {
+            int maxJump = 0;
+            for (int i = low; i <= high; i++) {
+                maxJump = Math.max(maxJump, i + nums[i]);
             }
-            l = r + 1;
-            r = next;
+            low = high + 1;
+            high = maxJump;
+            steps++;
         }
 
         return steps;
     }
 
     public static void main(String[] args) {
-//        int[] jumps = {2, 3, 1, 1, 4};
-        int[] jumps = {4, 1, 1, 3, 1, 1, 1};
-//        int[] jumps = {1, 2, 1, 1, 1};
-//        int[] jumps = {10,9,8,7,6,5,4,3,2,1,1,0};
-        System.out.println(jump(jumps));
-        System.out.println(jumpON(jumps));
+        // int[] jumps = {2, 3, 1, 1, 4};
+        int[] jumps = { 4, 1, 1, 3, 1, 1, 1 };
+        // int[] jumps = {1, 2, 1, 1, 1};
+        // int[] jumps = {10,9,8,7,6,5,4,3,2,1,1,0};
+        System.out.println(jumpGreedy(jumps));
+        // System.out.println(jumpON(jumps));
     }
 
 }

src/problems/leetcode/MultiplyStrings.java

@@ -1,18 +1,18 @@
 package problems.leetcode;
 
+import java.util.Arrays;
+
 /**
  * https://leetcode.com/problems/multiply-strings/
  */
 public class MultiplyStrings {
 
     public static void main(String[] args) {
-        String num1 = "12512";
-        String num2 = "0";
-
-        String res = multiply(num1, num2);
-        System.out.println(res);
+        System.out.println(multiply("123456789", "987654321"));
     }
 
+    // runtime: O(A * B) where A and B are number of digits of the numbers
+    // space: O(M) where M is number of digits of the greater number
     public static String multiply(String num1, String num2) {
         num1 = new StringBuilder(num1).reverse().toString();
         num2 = new StringBuilder(num2).reverse().toString();