[Yiseull] WEEK 03 Solutions (#2720)

* feat: 125. Valid Palindrome solution

(cherry picked from commit d881c4d)

* feat: 191. Number of 1 Bits solution

* feat: 39. Combination Sum solution

* feat: 191. Number of 1 Bits solution2

* feat: 91. Decode Ways solution

* feat: 53. Maximum Subarray solution

Author: Yiseull

combination-sum/Yiseull.java

@@ -0,0 +1,27 @@
+class Solution {
+
+    private List<List<Integer>> answer = new ArrayList<>();
+
+    public List<List<Integer>> combinationSum(int[] candidates, int target) {
+        Arrays.sort(candidates);
+        dfs(candidates, target, 0, new ArrayList<>());
+        return answer;
+    }
+
+    private void dfs(int[] candidates, int target, int start, List<Integer> combination) {
+        if (target == 0) {
+            answer.add(new ArrayList<>(combination));
+            return;
+        }
+
+        for (int i = start; i < candidates.length; i++) {
+            if (candidates[i] > target) {
+                break;
+            }
+
+            combination.add(candidates[i]);
+            dfs(candidates, target - candidates[i], i, combination);
+            combination.removeLast();
+        }
+    }
+}

decode-ways/Yiseull.java

@@ -0,0 +1,26 @@
+class Solution {
+
+    public int numDecodings(String s) {
+        if (s.charAt(0) == '0') {
+            return 0;
+        }
+
+        int n = s.length();
+        int[] dp = new int[n + 1];
+        dp[0] = 1;
+        dp[1] = 1;
+
+        for (int i = 2; i <= n; i++) {
+            if (s.charAt(i - 1) != '0') {
+                dp[i] += dp[i - 1];
+            }
+
+            int two = Integer.parseInt(s.substring(i - 2, i));
+            if (two >= 10 && two <= 26) {
+                dp[i] += dp[i - 2];
+            }
+        }
+
+        return dp[n];
+    }
+}

maximum-subarray/Yiseull.java

@@ -0,0 +1,13 @@
+class Solution {
+    public int maxSubArray(int[] nums) {
+        int answer = -10001, tmp = 0;
+
+        for (int i = 0; i < nums.length; i++) {
+            tmp += nums[i];
+            answer = Math.max(answer, tmp);
+            tmp = Math.max(tmp, 0);
+        }
+
+        return answer;
+    }
+}

number-of-1-bits/Yiseull.java

@@ -0,0 +1,12 @@
+class Solution {
+    public int hammingWeight(int n) {
+        // return Integer.bitCount(n);
+
+        int answer = 0;
+        while (n != 0) {
+            n &= n-1;
+            answer++;
+        }
+        return answer;
+    }
+}

valid-palindrome/Yiseull.java

@@ -0,0 +1,31 @@
+class Solution {
+    public boolean isPalindrome(String s) {
+        /**
+        첫 번째 풀이: 시간복잡도 O(n), 공간복잡도 O(n)
+        String letters = s.replaceAll("[^a-zA-Z0-9]", "").toLowerCase();
+        String reverse = new StringBuilder(letters).reverse().toString();
+        return letters.equals(reverse);
+         */
+
+        // 두 번째 풀이: 시간복잡도 O(n), 공간복잡도 O(1)
+         int left = 0, 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--;
+            }
+
+            if (Character.toLowerCase(s.charAt(left)) != Character.toLowerCase(s.charAt(right))) {
+                return false;
+            }
+
+            left++;
+            right--;
+         }
+
+         return true;
+    }
+}