[dolphinflow86] WEEK 03 Solutions

combination-sum/dolphinflow86.py

@@ -0,0 +1,27 @@
+# 1) Backtrack every possible combination to find subsets that match the target condition.
+# TC: O(N^(T/M)) where N is the length of candidates, M is the minimum value in candidates, and T is the target number.
+# SC: O(T/M) - The maximum depth of the recursion stack.
+class Solution:
+    def backtrack(self, candidates: List[int], remain: int, start_index: int, path:List[int], answer: List[List[int]]):
+        if remain == 0:
+            answer.append(path[:])
+            return
+
+        cur = candidates[start_index]
+
+        for i in range(start_index, len(candidates)):
+            if remain < candidates[i]:
+                break
+
+            path.append(candidates[i])
+            self.backtrack(candidates, remain - candidates[i], i, path, answer)
+            path.pop()
+
+    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
+        path = []
+        answer = []
+
+        candidates.sort()
+        self.backtrack(candidates, target, 0, path, answer)
+
+        return answer

number-of-1-bits/dolphinflow86.py

@@ -0,0 +1,11 @@
+# 1) Divide by 2 and count set bit.
+# TC: O(logN) where N is the given number.
+# SC: O(1)
+class Solution:
+    def hammingWeight(self, n: int) -> int:
+        setbit_count = 1
+
+        while n >= 2:
+           if n % 2 == 1: setbit_count += 1
+           n = n // 2
+        return setbit_count

valid-palindrome/dolphinflow86.py

@@ -0,0 +1,42 @@
+# 1) Iterate through the string using two-pointers, skipping non-alphanumeric characters and comparing them in lowercase to validate the palindrome in-place.
+# TC: O(N) where N is the length of s
+# SC: O(1)
+class Solution:
+    def isPalindrome(self, s: str) -> bool:
+        left = 0
+        right = len(s) - 1
+
+        while left < right:
+            if not s[left].isalnum():
+                left += 1
+                continue
+            if not s[right].isalnum():
+                right -= 1
+                continue
+
+            if s[left].lower() != s[right].lower(): return False
+            left += 1
+            right -= 1 
+
+        return True
+
+# 2) Filter alphanumeric characters and conver them to lowercase to create a new string and then simply validate palindrome using two-pointers
+# TC: O(N) where N is the length of s
+# SC: O(N) where N is the length of s
+class Solution:
+    def isPalindrome(self, s: str) -> bool:
+        new_str = ""
+        for ch in s:
+            if ch.isalnum():
+                new_str += ch.lower()
+
+        n = len(new_str)
+        left = 0
+        right = n - 1
+
+        while left < right:
+            if new_str[left] != new_str[right]: return False
+            left += 1
+            right -= 1 
+
+        return True