[BEMELON] WEEK 3 Solution

climbing-stairs/bemelon.py

@@ -0,0 +1,17 @@
+class Solution:
+    # Space complexity: O(1)
+    # Tiem complexity: O(n)
+    def climbStairs(self, n: int) -> int:
+        # dp[0] is n - 2
+        # dp[1] is n - 1
+        dp = [1, 2]
+
+        if n <= 2: 
+            return dp[n - 1]
+
+        for i in range(3, n + 1): 
+            # dp[n] = dp[n - 1] + dp[n - 2]
+            #       = dp[1] + dp[0]
+            dp[(i - 1) % 2] = sum(dp)
+
+        return dp[(n - 1) % 2]

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

@@ -0,0 +1,46 @@
+class Solution:
+    # Space complexity: O(n)
+    # Time complexity: O(n)
+    def _v1(self, nums: list[int]) -> list[int]:
+        prefix = [1]
+        for num in nums[:-1]:
+            prefix.append(prefix[-1] * num)
+
+        reverse_nums = nums[::-1]        
+        postfix = [1]
+        for num in reverse_nums[:-1]:
+            postfix.append(postfix[-1] * num)
+        postfix = postfix[::-1]
+
+        return [prefix[i] * postfix[i] for i in range(len(nums))]
+
+    # Space complexity: O(1)
+    # Time complexity: O(n)
+    def _v2(self, nums: list[int]) -> list[int]:
+        n = len(nums)
+        answer = [1] * n
+
+        # 1. save prefix product to temp 
+        temp = 1
+        for i in range(1, n):
+            temp *= nums[i - 1]
+            answer[i] *= temp 
+
+        # 2. save postfix product to temp 
+        temp = 1
+        for i in range(n - 2, -1, -1):
+            temp *= nums[i + 1]
+            answer[i] *= temp
+
+        return answer
+
+
+    def productExceptSelf(self, nums: List[int]) -> List[int]:
+        # index -> product
+        # 0 ->  - [1, 2, 3] 
+        # 1 -> [0] - [2, 3]
+        # 2 -> [0, 1] - [3] 
+        # 3 -> [0, 1, 2] -
+        return self._v2(nums)
+
+

two-sum/bemelon.py

@@ -0,0 +1,13 @@
+class Solution:
+    # Space complexity: O(n)
+    # Time complexity: O(n)
+    def twoSum(self, nums: list[int], target: int) -> list[int]:
+        num_index = {} 
+        for curr, num in enumerate(nums): 
+            rest = target - num 
+            if rest in num_index: 
+                return [num_index[rest], curr]
+            else: 
+                num_index[num] = curr 
+        return [0, 0]
+