Merge pull request #1263 from Sung-Heon/main

[Sung-Heon]WEEK 02 solution

Author: Sung-Heon

3sum/Sung-Heon.py

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

climbing-stairs/Sung-Heon.py

@@ -0,0 +1,15 @@
+class Solution:
+    def climbStairs(self, n: int) -> int:
+        temp = {}
+        if n == 1:
+            return 1
+        if n == 2:
+            return 2
+        temp[1] = 1
+        temp[2] = 2
+        a = 2
+        while a != n:
+            a += 1
+            temp[a] = temp[a - 1] + temp[a - 2]
+        return temp[a]
+

product-of-array-except-self/Sung-Heon.py

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

valid-anagram/Sung-Heon.py

@@ -0,0 +1,15 @@
+class Solution:
+    def isAnagram(self, s: str, t: str) -> bool:
+        s = list(s)
+        t = list(t)
+        try:
+            for i in s:
+                if len(t) == 0:
+                    return False
+                t.remove(i)
+        except:
+            return False
+        if len(t) == 0:
+            return True
+        else:
+            return False

validate-binary-search-tree/Sung-Heon.py

@@ -0,0 +1,12 @@
+class Solution:
+    def isValidBST(self, root):
+        def validate(node, min_val, max_val):
+            if not node:
+                return True
+
+            if node.val <= min_val or node.val >= max_val:
+                return False
+
+            return validate(node.left, min_val, node.val) and validate(node.right, node.val, max_val)
+
+        return validate(root, float('-inf'), float('inf'))