[parkhojeong] WEEK 02 Solutions

3sum/parkhojeong.py

@@ -0,0 +1,31 @@
+class Solution:
+    def threeSum(self, nums: list[int]) -> list[list[int]]:
+        result_arr = []
+        n = len(nums)
+        nums.sort()
+
+        for i in range(n - 2):
+            if nums[i] > 0:
+                break
+            if i > 0 and nums[i] == nums[i - 1]:
+                continue
+
+            j = i + 1
+            k = n - 1
+            while j < k:
+                total = nums[i] + nums[j] + nums[k]
+
+                if total == 0:
+                    result_arr.append([nums[i], nums[j], nums[k]])
+                    while j < k and nums[j] == nums[j + 1]:
+                        j += 1
+                    while j < k and nums[k] == nums[k - 1]:
+                        k -= 1
+                    j += 1
+                    k -= 1
+                elif total > 0:
+                    k -= 1
+                else:
+                    j += 1
+
+        return result_arr

climbing-stairs/parkhojeong.py

@@ -0,0 +1,13 @@
+class Solution:
+    def climbStairs(self, n: int) -> int:
+        if n == 1:
+            return 1
+
+        arr = [0] * n
+        arr[0], arr[1] = 1, 2
+
+        for i in range(2, n):
+            arr[i] = arr[i - 1] + arr[i - 2]
+
+        return arr[-1]
+

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

@@ -0,0 +1,14 @@
+class Solution:
+    def productExceptSelf(self, nums: List[int]) -> List[int]:
+        n = len(nums)
+        answer = [1] * n
+
+        for i in range(1, n):
+            answer[i] = answer[i -1] * nums[i - 1]
+
+        R = 1
+        for i in range(n - 1, -1, -1):
+            answer[i] *= R
+            R *= nums[i]
+
+        return answer

valid-anagram/parkhojeong.py

@@ -0,0 +1,5 @@
+from collections import Counter
+
+class Solution:
+    def isAnagram(self, s: str, t: str) -> bool:
+        return Counter(s) == Counter(t)

validate-binary-search-tree/parkhojeong.py

@@ -0,0 +1,24 @@
+# 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 isValidBST(self, root: Optional[TreeNode]) -> bool:
+        return self.dfs(root, ~sys.maxsize, sys.maxsize)
+
+    def dfs(self, root, min_val, max_val) -> bool:
+        val = root.val
+        if val <= min_val or val >= max_val:
+            return False
+
+        if root.left:
+            if not self.dfs(root.left, min_val, val):
+                return False
+        if root.right:
+            if not self.dfs(root.right, val, max_val):
+                return False
+
+        return True
+