[xeulbn] WEEK 03 Solutions

combination-sum/xeulbn.java

@@ -0,0 +1,30 @@
+import java.util.*;
+
+class Solution {
+    public List<List<Integer>> combinationSum(int[] candidates, int target) {
+        List<List<Integer>> result = new ArrayList<>();
+
+        backtrack(candidates, target, 0, new ArrayList<>(), result);
+
+        return result;
+    }
+
+    private void backtrack(int[] candidates, int remain, int start, List<Integer> current, List<List<Integer>> result) {
+        if (remain == 0) {
+            result.add(new ArrayList<>(current));
+            return;
+        }
+
+        if (remain < 0) {
+            return;
+        }
+
+        for (int i=start; i<candidates.length; i++) {
+            int candidate = candidates[i];
+
+            current.add(candidate);
+            backtrack(candidates, remain - candidate, i, current, result);
+            current.remove(current.size() - 1);
+        }
+    }
+}

decode-ways/xeulbn.java

@@ -0,0 +1,29 @@
+import java.util.*;
+
+class Solution {
+    public int numDecodings(String s) {
+        int n = s.length();
+        int[] dp = new int[n + 1];
+
+        dp[0] = 1;
+
+        dp[1] = s.charAt(0) == '0' ? 0 : 1;
+
+        for (int i=2; i<=n; i++) {
+            char current = s.charAt(i - 1);
+
+            if (current != '0') {
+                dp[i] += dp[i - 1];
+            }
+            int twoDigit =
+                    (s.charAt(i - 2) - '0') * 10
+                            + (s.charAt(i - 1) - '0');
+
+            if (twoDigit >= 10 && twoDigit <= 26) {
+                dp[i] += dp[i - 2];
+            }
+        }
+
+        return dp[n];
+    }
+}

maximum-subarray/xeulbn.java

@@ -0,0 +1,21 @@
+import java.util.*;
+
+class Solution {
+    public int maxSubArray(int[] nums) {
+        int currentSum = nums[0];
+        int maxSum = nums[0];
+
+        for (int i=1; i<nums.length; i++) {
+            if (nums[i] > currentSum + nums[i]) {
+                currentSum = nums[i];
+            } else {
+                currentSum += nums[i];
+            }
+
+            if (currentSum > maxSum) {
+                maxSum = currentSum;
+            }
+        }
+        return maxSum;
+    }
+}

number-of-1-bits/xeulbn.java

@@ -0,0 +1,17 @@
+import java.util.*;
+
+class Solution {
+    public int hammingWeight(int n) {
+        int count = 0;
+
+        while (n > 0) {
+            if ((n & 1) == 1) {
+                count++;
+            }
+
+            n = n >> 1;
+        }
+
+        return count;
+    }
+}

valid-palindrome/xeulbn.java

@@ -0,0 +1,32 @@
+import java.util.*;
+
+class Solution {
+    public boolean isPalindrome(String s) {
+        int left =0;
+        int right = s.length()-1;
+
+        while (left < right) {
+
+            while (left < right && !Character.isLetterOrDigit(s.charAt(left))) {
+                left++;
+            }
+
+            while (left < right && !Character.isLetterOrDigit(s.charAt(right))) {
+                right--;
+            }
+
+            char leftChar = Character.toLowerCase(s.charAt(left));
+            char rightChar = Character.toLowerCase(s.charAt(right));
+
+            if (leftChar != rightChar) {
+                return false;
+            }
+
+            left++;
+            right--;
+        }
+
+
+        return true;
+    }
+}