[sangbeenmoon] WEEK 02 solutions

3sum/sangbeenmoon.py

@@ -0,0 +1,32 @@
+# time : O(n^2)
+# space : O(n)
+class Solution:
+    def threeSum(self, nums: list[int]) -> list[list[int]]:
+        nums.sort()
+        answer = []
+
+        for i, num in enumerate(nums):
+            # 중복 제거
+            if i > 0 and nums[i] == nums[i-1]:
+                continue
+
+            target = num * -1
+
+            visited = dict()    # 중복 제거
+            left = i + 1
+            right = len(nums) - 1
+
+            while left < right:
+                sum_ = nums[left] + nums[right]
+                if sum_ < target:
+                    left = left + 1
+                elif sum_ > target:
+                    right = right - 1
+                else:
+                    if nums[left] not in visited:     # 중복 제거
+                        answer.append([num, nums[left], nums[right]])
+                        visited[nums[left]] = True
+
+                    left = left + 1
+                    right = right - 1
+        return answer

climbing-stairs/sangbeenmoon.py

@@ -0,0 +1,15 @@
+# dp[i] = dp[i-2] + dp[i-1]
+# time : O(n)
+# complexity : O(n)
+
+class Solution:
+    def climbStairs(self, n: int) -> int:
+        dp = [0] * n
+        dp[0] = 1
+        if n == 1:
+            return dp[0]
+        dp[1] = 2
+        for i in range(2, n):
+            dp[i] = dp[i-2] + dp[i-1]
+
+        return dp[n-1]        

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

@@ -0,0 +1,26 @@
+# idea
+# 1. left[i] = left[0] * left[1] * ... * left[i-1]
+# 2. right[i] = right[i+1] * right[i+2] * ... * right[n-1]
+# 3. answer[i] = left[i-1] * right[i+1]
+
+# time : O(n)
+# space : O(n)
+
+class Solution:
+    def productExceptSelf(self, nums: List[int]) -> List[int]:
+        left = [1] * len(nums)
+        left[0] = nums[0]
+        for i in range(1, len(nums)):
+            left[i] = left[i-1] * nums[i]
+
+        right = [1] * len(nums)
+        right[len(nums) - 1] = nums[len(nums) - 1]
+        for i in range(len(nums) - 2, 0, -1):
+            right[i] = right[i+1] * nums[i]
+
+        answer = []
+        answer.append(right[1])
+        for i in range(1, len(nums) - 1):
+            answer.append(left[i-1] * right[i+1])
+        answer.append(left[len(nums) - 2])
+        return answer

valid-anagram/sangbeenmoon.py

@@ -0,0 +1,6 @@
+# time : O(nlogn)
+# space : O(n)
+
+class Solution:
+    def isAnagram(self, s: str, t: str) -> bool:
+        return sorted(s) == sorted(t)

validate-binary-search-tree/sangbeenmoon.py

@@ -0,0 +1,40 @@
+# time: O(n)
+# space: O(h) : 추가 자료구조는 없지만 재귀 스택으로 인해 트리 높이만큼 공간 사용.
+
+# 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:
+    answer = True
+    def isValidBST(self, root: Optional[TreeNode]) -> bool:
+
+        if root:
+            if root.left:
+                self.go_left(root.left, -2**31 - 1, root.val )
+            if root.right:
+                self.go_right(root.right, root.val, 2**31)
+
+        return self.answer
+
+    def go_left(self, cur:TreeNode, mm:int, MM:int):
+        if mm >= cur.val or cur.val >= MM :
+            self.answer = False
+            return
+        if cur.left:
+            self.go_left(cur.left, mm, cur.val)
+        if cur.right:
+            self.go_right(cur.right, cur.val, MM)
+
+    def go_right(self, cur:TreeNode, mm:int, MM:int):
+        if mm >= cur.val or cur.val >= MM :
+            self.answer = False
+            return
+        if cur.left:
+            self.go_left(cur.left, mm, cur.val)
+        if cur.right:
+            self.go_right(cur.right, cur.val, MM)
+