Merge pull request #1792 from yhkee0404/main

[yhkee0404] WEEK 03 solutions

Author: yhkee0404

combination-sum/yhkee0404.ts

@@ -0,0 +1,24 @@
+function combinationSum(candidates: number[], target: number, dp = new Map()): number[][] {
+    if (target <= 0) {
+        return [];
+    }
+    let ans = dp.get(target);
+    if (ans !== undefined) {
+        return ans;
+    }
+    ans = [];
+    for (const candidate of candidates) {
+        if (target == candidate) {
+            ans.push([candidate]);
+            continue;
+        }
+        for (const combination of combinationSum(candidates, target - candidate, dp)) {
+            if (combination[combination.length - 1] > candidate) {
+                continue;
+            }
+            ans.push([...combination, candidate]);
+        }
+    }
+    dp.set(target, ans);
+    return ans;
+};

decode-ways/yhkee0404.go

@@ -0,0 +1,20 @@
+func numDecodings(s string) int {
+    dp := make([]int, len(s) + 1)
+    dp[0] = 1
+    const cnt = rune('Z') - rune('A') + 1
+    for i, c := range s {
+        a := 0
+        if i != 0 {
+            b := (rune(s[i - 1]) - rune('0')) * 10 + rune(c) - rune('0')
+            if b > 9 && b <= cnt {
+                a += dp[i - 1]
+            }
+        }
+        b := rune(c) - rune('0')
+        if b != 0 && b < cnt {
+            a += dp[i]
+        }
+        dp[i + 1] = a
+    }
+    return dp[len(s)]
+}

maximum-subarray/yhkee0404.rs

@@ -0,0 +1,35 @@
+impl Solution {
+    pub fn max_sub_array(nums: Vec<i32>) -> i32 {
+        return Self::solve(&nums, 0, nums.len()).unwrap_or(0);
+    }
+    fn solve(nums: &Vec<i32>, l: usize, r: usize) -> Option<i32> {
+        if l >= r {
+            return None
+        }
+        if l + 1 == r {
+            return Some(nums[l])
+        }
+        let mid = l + ((r - l) >> 1);
+        let a = Self::solve(nums, l, mid);
+        let b = Self::solve(nums, mid, r);
+        if a.is_none() || b.is_none() {
+            return a.or(b)
+        }
+        let mut ans = a.max(b);
+        let mut c = 0;
+        let mut d = 0;
+        for i in (l..mid).rev() {
+            c += nums[i];
+            d = d.max(c);
+        }
+        if d == 0 {
+            return ans
+        }
+        c = d;
+        for i in mid..r {
+            c += nums[i];
+            d = d.max(c);
+        }
+        ans.max(Some(d))
+    }
+}

number-of-1-bits/yhkee0404.py

@@ -0,0 +1,4 @@
+class Solution:
+    @lru_cache
+    def hammingWeight(self, n: int) -> int:
+        return 1 + self.hammingWeight(n - (n & - n)) if n else 0

valid-palindrome/yhkee0404.ts

@@ -0,0 +1,19 @@
+function isPalindrome(s: string): boolean {
+    const isAlpha = x => x.toLowerCase() >= 'a' && x.toLowerCase() <= 'z';
+    const isNumeric = x => x >= '0' && x <= '9';
+    const isAlphanumeric = x => isAlpha(x) || isNumeric(x);
+    let i = 0, j = s.length - 1;
+    while (i < j) {
+        while (i !== j && ! isAlphanumeric(s[i])) {
+            i++;
+        }
+        while (i !== j && ! isAlphanumeric(s[j])) {
+            j--;
+        }
+        if (s[i].toLowerCase() !== s[j].toLowerCase()) {
+            return false;
+        }
+        i++, j--;
+    }
+    return true;
+};