Merge pull request #2050 from radiantchoi/main

[radiantchoi] WEEK 02 Solutions

Author: radiantchoi

.github/workflows/integration.yaml

@@ -2,10 +2,12 @@ name: Integration 🔄
 
 on:
   pull_request:
+  merge_group:
 
 jobs:
   linelint:
     runs-on: ubuntu-latest
+    if: github.event_name == 'pull_request'
     steps:
       - uses: actions/checkout@v4
         with:

3sum/radiantchoi.py

@@ -0,0 +1,45 @@
+class Solution:
+    def twoSum(self, target: int, nums: List[int], starting: int) -> List[List[int]]:
+        left = starting
+        right = len(nums) - 1
+
+        result = []
+
+        while left < right:
+            if nums[left] + nums[right] == target:
+                result.append([nums[left], nums[right]])
+                left += 1
+                right -= 1
+
+                while left < right and nums[left] == nums[left - 1]:
+                    left += 1
+                
+                while left < right and nums[right] == nums[right + 1]:
+                    right -= 1
+            elif nums[left] + nums[right] > target:
+                right -= 1
+            else:
+                left += 1
+        
+        return result
+    
+    def kSum(self, n: int, target: int, nums: List[int], starting: int) -> List[List[int]]:
+        if n < 2 or starting == len(nums):
+            return []
+        elif n == 2:
+            return self.twoSum(target, nums, starting)
+        
+        result = []
+
+        for i in range(starting, len(nums) - n + 1):
+            if i > starting and nums[i] == nums[i - 1]:
+                continue
+            
+            for tail in self.kSum(n - 1, target - nums[i], nums, i + 1):
+                result.append([nums[i]] + tail)
+        
+        return result
+
+    def threeSum(self, nums: List[int]) -> List[List[int]]:
+        nums.sort()
+        return self.kSum(3, 0, nums, 0)

climbing-stairs/radiantchoi.py

@@ -0,0 +1,9 @@
+class Solution:
+    def climbStairs(self, n: int) -> int:
+        stairs = [1, 1]
+
+        if n > 1:
+            for i in range(2, n+1):
+                stairs.append(stairs[i - 1] + stairs[i - 2])
+        
+        return stairs[-1]

product-of-array-except-self/radiantchoi.py

@@ -0,0 +1,20 @@
+class Solution:
+    def productExceptSelf(self, nums: List[int]) -> List[int]:
+        reduced = 1
+        zeroes = 0
+
+        for num in nums:
+            if num != 0:
+                reduced *= num
+            else:
+                zeroes += 1
+        
+        result = []
+
+        for num in nums:
+            if num == 0:
+                result.append(0 if zeroes - 1 > 0 else reduced)
+            else:
+                result.append(0 if zeroes else reduced // num)
+        
+        return result

valid-anagram/radiantchoi.py

@@ -0,0 +1,12 @@
+class Solution:
+    def isAnagram(self, s: str, t: str) -> bool:
+        s_letters = {}
+        t_letters = {}
+
+        for letter in s:
+            s_letters[letter] = s_letters.get(letter, 0) + 1
+        
+        for letter in t:
+            t_letters[letter] = t_letters.get(letter, 0) + 1
+
+        return s_letters == t_letters 

validate-binary-search-tree/radiantchoi.py

@@ -0,0 +1,21 @@
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def check(self, root: Optional[TreeNode], minimum: int, maximum: int) -> bool:
+        if root is None:
+            return True
+
+        if root.val <= minimum or root.val >= maximum:
+            return False
+
+        return self.check(root.left, minimum, root.val) and self.check(root.right, root.val, maximum)
+
+    def isValidBST(self, root: Optional[TreeNode]) -> bool:
+        minimum_constraint = ((-2) ** 31) - 1
+        maximum_constraint = 2 ** 31
+
+        return self.check(root, minimum_constraint, maximum_constraint)