Merge pull request #2086 from ppxyn1/main

[ppxyn1] WEEK 03 solutions

Author: ppxyn1

combination-sum/ppxyn1.py

@@ -0,0 +1,27 @@
+# idea: brute force
+# Complexity: O(len(candidates)^(target / min(candidates)))
+
+class Solution:
+    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
+        candidates.sort()
+        result = []
+        nums = []
+
+        def dfs(start: int, total: int):
+            if total > target:
+                return
+            if total == target:
+                result.append(nums.copy())
+                return
+            for i in range(start, len(candidates)):
+                num = candidates[i]
+                if total + num > target:
+                    break
+                nums.append(num)
+                dfs(i, total + num) 
+                nums.pop()
+        dfs(0, 0)
+        return result
+    
+
+

decode-ways/ppxyn1.py

@@ -0,0 +1,19 @@
+# idea : Tree
+class Solution:
+    def numDecodings(self, s: str) -> int:
+        # recurisve : top-down
+        # DP : bottom-up can be another way to solve it, but it is not clear for me. 
+        memo = {len(s):1}
+        def dfs(start):
+            if start in memo:
+                return memo[start]
+            if s[start] == '0':
+                memo[start] = 0
+            elif start+1 < len(s) and int(s[start:start+2]) < 27:
+                memo[start] = dfs(start+1) + dfs(start+2)
+            else:
+                memo[start] = dfs(start+1)
+            return memo[start]
+        return dfs(0)
+
+

maximum-subarray/ppxyn1.py

@@ -0,0 +1,21 @@
+# idea : DP
+class Solution:
+    def maxSubArray(self, nums: List[int]) -> int:
+        # The solution must run in O(N^2) or better.
+        '''
+        1. Idea: Sorting + Two Pointers (x) — This problem does not allow changing the original order of the array.
+        2. Subarrays (TLE) — O(N^3), too slow.
+        3. DP (o)
+        '''
+        max_total = nums[0]
+        total = nums[0]
+        # dp = [0]*len(nums) 
+        # dp[0] = nums[0]
+        for i in range(1,len(nums)):
+            # dp[i] = max(nums[i], dp[i-1]+nums[i])
+            total = max(nums[i], total+nums[i])
+            max_total = max(total, max_total)
+        return max_total 
+
+
+

number-of-1-bits/ppxyn1.py

@@ -0,0 +1,10 @@
+# idea: - 
+
+from collections import Counter
+class Solution:
+    def hammingWeight(self, n: int) -> int:
+        bits = bin(n).split('0b')[-1]
+        return Counter(bits)['1']
+
+
+

valid-palindrome/ppxyn1.py

@@ -0,0 +1,11 @@
+# idea : regex
+import re 
+
+class Solution:
+    def isPalindrome(self, s: str) -> bool:
+        alphabet = re.sub(r'[^A-Za-z0-9]', '', s).lower()
+
+        return alphabet == alphabet[::-1]
+
+        
+