Merge pull request #1327 from sora0319/main

[sora0319] Week 03 solutions

Author: sora0319

combination-sum/sora0319.java

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

decode-ways/sora0319.java

@@ -0,0 +1,24 @@
+public class Solution {
+    public int numDecodings(String s) {
+        if (s == null || s.length() == 0 || 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 twoNum = Integer.parseInt(s.substring(i - 2, i));
+            if (twoNum >= 10 && twoNum <= 26) {
+                dp[i] += dp[i - 2];
+            }
+        }
+
+        return dp[n];
+    }
+}
+

maximum-subarray/sora0319.java

@@ -0,0 +1,18 @@
+class Solution {
+    public int maxSubArray(int[] nums) {
+        int n = nums.length;
+        int[] dp = new int[n];
+
+        dp[0] = nums[0];
+        int maxSum = dp[0];
+
+        for (int i = 1; i < n; i++) {
+            dp[i] = Math.max(nums[i], dp[i - 1] + nums[i]);
+            maxSum = Math.max(maxSum, dp[i]); // 최대값 갱신
+        }
+
+        return maxSum;
+    }
+
+}
+

number-of-1-bits/sora0319.java

@@ -0,0 +1,12 @@
+class Solution {
+    public int hammingWeight(int n) {
+        int cnt = 0;
+        String binary = Integer.toBinaryString(n);
+
+        for(int i = 0; i < binary.length(); i++){
+            if(binary.charAt(i) == '1') cnt++;
+        }
+        return cnt;
+    }
+}
+

valid-palindrome/sora0319.java

@@ -0,0 +1,27 @@
+class Solution {
+    public boolean isPalindrome(String s) {
+        int start = 0;
+        int end = s.length()-1;
+
+        boolean isPalindrome = true;
+        s = s.toLowerCase();
+
+        while(start <= end){
+            if((s.charAt(start) < 'a' || s.charAt(start) > 'z') && (s.charAt(start) < '0' || s.charAt(start) > '9')){
+                start++;
+                continue;
+            }
+            if((s.charAt(end) < 'a' || s.charAt(end) > 'z') && (s.charAt(end) < '0' || s.charAt(end) > '9')){
+                end--;
+                continue;
+            }
+            if(s.charAt(start) != s.charAt(end)) return false;
+            start++;
+            end--;
+
+        }
+
+        return isPalindrome;
+    }
+}
+