[alphaorderly] WEEK 02 Solutions (#2673)

* week 1

* [alphaorderly] WEEK 02 Solutions

* fix: description에 맞게 코드 수정

* fix: 좀 더 간결하게 수정

Author: alphaorderly

3sum/alphaorderly.py

@@ -0,0 +1,37 @@
+class Solution:
+    def threeSum(self, nums: list[int]) -> list[list[int]]:
+        """
+        O(N^2)
+        """
+        cntr = Counter(nums)
+
+        ans = []
+
+        # First case -> [0, 0, 0] Triplet
+        if cntr[0] >= 3:
+            ans.append([0, 0, 0])
+
+        # Second case -> two same numbers + one diff number
+        for k, v in cntr.items():
+            if k == 0:
+                continue
+            if v >= 2 and -(k * 2) in cntr:
+                ans.append([k, k, -(k * 2)])
+
+        s = set(nums)
+        nums = list(s)
+        nums.sort()
+
+        pos = {k: v for v, k in enumerate(nums)}
+        N = len(nums)
+
+        # Third case -> all different numbers
+        for i in range(N - 2):
+            for j in range(i + 1, N - 1):
+                target = -(nums[i] + nums[j])
+                if target in pos:
+                    k = pos[target]
+                    if k > j:
+                        ans.append([nums[i], nums[j], nums[k]])
+
+        return ans

climbing-stairs/alphaorderly.py

@@ -0,0 +1,66 @@
+# class Solution:
+#     def climbStairs(self, n: int) -> int:
+#         """
+#             O(N) with additional space
+#         """
+#         if n <= 2:
+#             return n
+
+#         dp = [0] * (n + 1)
+#         dp[1] = 1
+#         dp[2] = 2
+
+#         for i in range(3, n + 1):
+#             dp[i] = dp[i - 1] + dp[i - 2]
+
+#         return dp[-1]
+
+# class Solution:
+#     """
+#         O(N) Found that solution is fibonacci number
+#     """
+#     def climbStairs(self, n: int) -> int:
+#         if n <= 2:
+#             return n
+
+#         p1, p2 = 1, 2
+#         for i in range(3, n + 1):
+#             p1, p2 = p2, p1 + p2
+
+#         return p2
+
+
+# Fibonacci hack
+class Solution:
+    def climbStairs(self, n: int) -> int:
+        """
+            O(Log N)
+        """
+
+        # O(1) operation
+        def mat_mul(a: List[List[int]], b: List[List[int]]) -> List[List[int]]:
+            ans = [[0] * 2 for _ in range(2)]
+
+            for i in range(2):
+                for j in range(2):
+                    for k in range(2):
+                        ans[i][j] += a[i][k] * b[k][j]
+
+            return ans
+
+        # O(Log N) operation
+        def mat_pow(a: List[List[int]], n: int) -> List[List[int]]:
+            if n == 1:
+                return [[1, 1], [1, 0]]
+
+            half = mat_pow(a, n // 2)
+            multed = mat_mul(half, half)
+
+            if n % 2:
+                return mat_mul(multed, [[1, 1], [1, 0]])
+            else:
+                return multed
+
+        ans = mat_pow([[1, 1], [1, 0]], n)
+
+        return ans[0][0]

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

@@ -0,0 +1,22 @@
+class Solution:
+    def productExceptSelf(self, nums: List[int]) -> List[int]:
+        """
+        O(N) Time complexity
+        """
+        N = len(nums)
+
+        ans = [0] * N
+
+        acc = 1
+
+        for i in range(N):
+            ans[i] = acc
+            acc *= nums[i]
+
+        acc = 1
+
+        for i in range(N - 1, -1, -1):
+            ans[i] *= acc
+            acc *= nums[i]
+
+        return ans

valid-anagram/alphaorderly.py

@@ -0,0 +1,13 @@
+class Solution:
+    def isAnagram(self, s: str, t: str) -> bool:
+        """
+            O(N Log N)
+        """
+        return sorted(s) == sorted(t)
+
+# class Solution:
+#     """
+#         O(N)
+#     """
+#     def isAnagram(self, s: str, t: str) -> bool:
+#         return Counter(s) == Counter(t)

validate-binary-search-tree/alphaorderly.py

@@ -0,0 +1,38 @@
+# 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], lower: Optional[int] = -float('inf'), upper: Optional[int] = float('inf')) -> bool:
+#         if not root:
+#             return True
+
+#         if root.val <= lower or root.val >= upper:
+#             return False
+
+#         return self.isValidBST(root.left, lower, root.val) and self.isValidBST(root.right, root.val, upper)
+
+
+class Solution:
+    def isValidBST(self, root: Optional[TreeNode]) -> bool:
+        """
+        O(N)
+        """
+        s = [(root, -float("inf"), float("inf"))]
+
+        while s:
+            node, lower, upper = s.pop()
+
+            if node.val <= lower or node.val >= upper:
+                return False
+
+            if node.left:
+                s.append((node.left, lower, node.val))
+
+            if node.right:
+                s.append((node.right, node.val, upper))
+
+        return True