[HodaeSsi] Week3

combination-sum/HodaeSsi.py

@@ -0,0 +1,16 @@
+# 시간복잡도 : O(n * m) (n: target, m: len(candidates))
+# 공간복잡도 : O(n * m)
+class Solution:
+    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
+        dp = [[] for _ in range(target + 1)]
+        dp[0] = [[]]
+
+        for candidate in candidates:
+            for num in range(candidate, target + 1):
+                for combination in dp[num - candidate]:
+                    temp = combination.copy()
+                    temp.extend([candidate])
+                    dp[num].append(temp)
+
+        return dp[target]
+

maximum-subarray/HodaeSsi.py

@@ -0,0 +1,13 @@
+# 시간복잡도 : O(N)
+# 공간복잡도 : O(1)
+class Solution:
+    def maxSubArray(self, nums: List[int]) -> int:
+        global_sum = nums[0]
+        local_sum = nums[0]
+
+        for i in range(1, len(nums)):
+            local_sum = max(nums[i], local_sum + nums[i])
+            global_sum = max(local_sum, global_sum)
+
+        return global_sum
+

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

@@ -0,0 +1,30 @@
+# 시간복잡도: O(n)
+# 공간복잡도: O(n)
+class Solution:
+    def productExceptSelf(self, nums: List[int]) -> List[int]:
+        prefix = [1] * len(nums)
+        suffix = [1] * len(nums)
+        product = [1] * len(nums)
+
+        for idx in range(len(nums)):
+            if idx == 0:
+                prefix[idx] = nums[idx]
+            else:
+                prefix[idx] = prefix[idx - 1] * nums[idx]
+
+        for idx in range(len(nums) - 1, -1, -1):
+            if idx == len(nums) - 1:
+                suffix[idx] = nums[idx]
+            else:
+                suffix[idx] = suffix[idx + 1] * nums[idx]
+
+        for idx in range(len(nums)):
+            if idx == 0:
+                product[idx] = suffix[idx + 1]
+            elif idx == len(nums) - 1:
+                product[idx] = prefix[idx - 1]
+            else:
+                product[idx] = prefix[idx - 1] * suffix[idx + 1]
+
+        return product
+

reverse-bits/HodaeSsi.py

@@ -0,0 +1,5 @@
+# 시간복잡도: O(1) (32bit)
+class Solution:
+    def reverseBits(self, n: int) -> int:
+        return int(bin(n)[2:].zfill(32)[::-1], 2)
+

two-sum/HodaeSsi.py

@@ -0,0 +1,13 @@
+# 시간복잡도 : O(n)
+# 공간복잡도 : O(n)
+class Solution:
+    def twoSum(self, nums: List[int], target: int) -> List[int]:
+        seen = {} # {num: idx, ...}
+
+        for i, num in enumerate(nums):
+            if target - num in seen:
+                return [seen[target - num], i]
+            seen[num] = i
+
+        return []
+