Merge pull request #2448 from jylee2033/main

[jylee2033] WEEK 03 solutions

Author: jylee2033

combination-sum/jylee2033.py

@@ -0,0 +1,22 @@
+class Solution:
+    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
+        output = []
+
+        def backtrack(remain, comb, start):
+            if remain == 0:
+                output.append(list(comb))
+                return
+
+            elif remain < 0:
+                return
+
+            for i in range(start, len(candidates)):
+                comb.append(candidates[i])
+                backtrack(remain - candidates[i], comb, i)
+                comb.pop()
+
+        backtrack(target, [], 0)
+        return output
+
+# Time Complexity : O(N^T/M) N - number of candidates, T - target, M - minimum value in candidates
+# Space Complexity : O(T/M) - maximum depth of the recursion tree

number-of-1-bits/jylee2033.py

@@ -0,0 +1,40 @@
+class Solution:
+    def hammingWeight(self, n: int) -> int:
+        # # 1. Find highest power of 2 range that covers n
+        # # 2. Greedily subtract from largest power of 2 to smallest
+
+        # # powers : 1 + 2 + 4 +  8 + 16 + ...
+        # # total  : 1 + 3 + 7 + 15 + 31 + ...
+        # # index  : 0   1   2    3    4
+
+        # i = 0
+        # total = 1
+
+        # while n > total:
+        #     i += 1
+        #     total += 2 ** i
+
+        # count = 0
+
+        # for j in range(i, -1, -1):
+        #     if n >= 2 ** j:
+        #         n -= 2 ** j
+        #         count += 1
+
+        # return count
+
+# Time Complexity : O(log n)
+# Space Complexity : O(1)
+
+        count = 0
+
+        while n > 0:
+            if n % 2 == 1:
+                count += 1
+
+            n //= 2
+
+        return count
+
+# Time Complexity : O(log n)
+# Space Complexity : O(1)

valid-palindrome/jylee2033.py

@@ -0,0 +1,33 @@
+class Solution:
+    def isPalindrome(self, s: str) -> bool:
+        # 1. Remove non-alphanumeric characters and convert to lowercase
+        # 2. Compare with reversed string
+
+        # cleaned_s = ""
+        # for ch in s:
+        #     if ch.isalnum():
+        #         cleaned_s += ch.lower()
+
+        # return cleaned_s == cleaned_s[::-1]
+
+# Time Complexity : O(n)
+# Space Complexity : O(n)
+
+        left = 0
+        right = len(s) - 1
+
+        while left < right:
+            if not s[left].isalnum():
+                left += 1
+            elif not s[right].isalnum():
+                right -= 1
+            elif s[left].lower() != s[right].lower():
+                return False
+            else:
+                left += 1
+                right -= 1
+
+        return True
+
+# Time Complexity : O(n)
+# Space Complexity : O(1)