Merge pull request #1304 from jinhyungrhee/week3

[jinhyungrhee] Week 03 solutions

Author: jinhyungrhee

combination-sum/jinhyungrhee.java

@@ -0,0 +1,28 @@
+import java.util.*;
+class Solution {
+    public List<List<Integer>> output;
+    public List<List<Integer>> combinationSum(int[] candidates, int target) {
+        output = new ArrayList<>();
+        Deque<Integer> stack = new ArrayDeque<>();
+        dfs(candidates, target, stack, 0, 0);
+        return output;
+
+    }
+
+    public void dfs(int[] candidates, int target, Deque<Integer> stack, int start, int total) {
+
+        if (total > target) return;
+
+        if (total == target) {
+            output.add(new ArrayList<>(stack));
+            return;
+        }
+
+        for (int i = start; i < candidates.length; i++) {
+            int num = candidates[i];
+            stack.push(num);
+            dfs(candidates, target, stack, i, total + num);
+            stack.pop();
+        }
+    }
+}

decode-ways/jinhyungrhee.java

@@ -0,0 +1,33 @@
+import java.util.*;
+class Solution {
+
+    public List<Integer> nums;
+    public int numDecodings(String s) {
+        nums = new ArrayList<>();
+        for (int i = 0; i < s.length(); i++) {
+            nums.add(s.charAt(i) - 48);
+        }
+
+        int[] memo = new int[nums.size() + 1];
+        Arrays.fill(memo, -1);
+        return dfs(0, memo);
+    }
+
+    public int dfs(int start, int[] memo) {
+
+        if (start == nums.size()) return 1;
+
+        if (memo[start] != -1) {
+            return memo[start];
+        }
+        if (nums.get(start) == 0) {
+            memo[start] = 0;
+        }
+        else if (start + 1 < nums.size() && nums.get(start) * 10 + nums.get(start + 1) < 27) {
+            memo[start] = dfs(start + 1, memo) + dfs(start + 2, memo);
+        } else {
+            memo[start] = dfs(start + 1, memo);
+        }
+        return memo[start];
+    }
+}

maximum-subarray/jinhyungrhee.java

@@ -0,0 +1,18 @@
+class Solution {
+    public int maxSubArray(int[] nums) {
+
+        int[] dp = new int[nums.length];
+        dp[0] = nums[0];
+        for (int i = 1; i < nums.length; i++) {
+            dp[i] = Math.max(dp[i-1]+nums[i], nums[i]);
+        }
+
+        int maxVal = -987654321;
+        for (int num : dp) {
+            if (num > maxVal) {
+                maxVal = num;
+            }
+        }
+        return maxVal;
+    }
+}

number-of-1-bits/jinhyungrhee.java

@@ -0,0 +1,17 @@
+class Solution {
+    public int hammingWeight(int n) {
+
+        String bin = "";
+        while(n != 1) {
+            bin += (n % 2);
+            n /= 2;
+        }
+        bin += "1";
+
+        int result = 0;
+        for (int i = 0; i < bin.length(); i++) {
+            if (bin.charAt(i) == '1') result++;
+        }
+        return result;
+    }
+}

valid-palindrome/jinhyungrhee.java

@@ -0,0 +1,26 @@
+class Solution {
+    public boolean isPalindrome(String s) {
+
+        int len = s.length();
+
+        String target = "";
+        for (int i = 0; i < len; i++) {
+            if (Character.isLetterOrDigit(s.charAt(i))) {
+                target += Character.toLowerCase(s.charAt(i));
+            }
+        }
+
+        String reversedTarget = "";
+        for (int i = len - 1; i >= 0; i--) {
+            if (Character.isLetterOrDigit(s.charAt(i))) {
+                reversedTarget += Character.toLowerCase(s.charAt(i));
+            }
+        }
+
+        if (target.length() == 0) return true;
+        for (int i = 0; i < target.length(); i++) {
+            if (target.charAt(i) != reversedTarget.charAt(i)) return false;
+        }
+        return true;
+    }
+}