[Lyla] WEEK 03

combination-sum/pmjuu.py

@@ -0,0 +1,33 @@
+from typing import List
+
+
+class Solution:
+    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
+        result = []
+
+        def backtrack(start, target, current_combination):
+            # 종료 조건
+            if target == 0:
+                result.append(list(current_combination))
+                return
+            if target < 0:
+                return
+
+            # 백트래킹
+            for i in range(start, len(candidates)):
+                current_combination.append(candidates[i])
+                backtrack(i, target - candidates[i], current_combination)  # 같은 원소를 여러 번 쓸 수 있도록 i를 그대로 둡니다.
+                current_combination.pop()  # 돌아가서 다시 시도할 수 있도록 원소를 제거합니다.
+
+        backtrack(0, target, [])
+
+        return result
+
+
+# 시간 복잡도: O(n^t)
+# - 후보 리스트에서 각 숫자를 선택할 수 있기 때문에, n개의 후보를 사용해 t번의 탐색을 할 수 있습니다.
+# - 따라서 최악의 경우 탐색 횟수는 O(n^t)로 볼 수 있습니다.
+#
+# 공간 복잡도: O(t)
+# - 재귀 호출 스택의 깊이는 최대 target 값인 t에 비례하므로, 공간 복잡도는 O(t)입니다.
+# - 또한, 현재까지 선택된 숫자들의 조합을 저장하는 공간도 최대 t개까지 저장하므로, 공간 복잡도는 O(t)입니다.

maximum-subarray/pmjuu.py

@@ -0,0 +1,20 @@
+from typing import List
+
+
+class Solution:
+    def maxSubArray(self, nums: List[int]) -> int:
+        largest_sum = -float('inf')
+        current_sum = -float('inf')
+
+        for num in nums:
+            current_sum = max(current_sum + num, num)
+            largest_sum = max(largest_sum, current_sum)
+
+        return largest_sum
+
+
+# 시간 복잡도: O(n)
+# - nums 배열을 한 번 순회하며 각 요소에 대해 최대 부분 배열 합을 계산하므로 시간 복잡도는 O(n)입니다.
+#
+# 공간 복잡도: O(1)
+# - 추가로 사용하는 변수는 largest_sum과 current_sum 두 개뿐이므로 공간 복잡도는 O(1)입니다.

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

@@ -0,0 +1,27 @@
+from typing import List
+
+
+class Solution:
+    def productExceptSelf(self, nums: List[int]) -> List[int]:
+        n = len(nums)
+        result = [1] * n
+
+        prefix = 1
+        for i in range(n):
+            result[i] *= prefix
+            prefix *= nums[i]
+
+        suffix = 1
+        for i in range(-1, -n-1, -1):
+            result[i] *= suffix
+            suffix *= nums[i]
+
+        return result
+
+
+# 시간 복잡도: O(n)
+# - 입력 배열 nums를 두 번 순회합니다.
+#
+# 공간 복잡도: O(1)
+# - 추가 공간으로 사용하는 변수는 prefix와 suffix뿐이며,
+#   출력 배열(result)은 추가 공간으로 계산하지 않습니다.

reverse-bits/pmjuu.py

@@ -0,0 +1,42 @@
+class Solution:
+    def reverseBits(self, n: int) -> int:
+        # 이진수로 변환한 후 '0b' 제거
+        binary = bin(n)[2:]
+        # 32비트 길이에 맞게 앞쪽에 0을 채움
+        binary = binary.zfill(32)
+        # 이진수를 뒤집음
+        reversed_binary = binary[::-1]
+        # 뒤집힌 이진수를 정수로 변환하여 반환
+        return int(reversed_binary, 2)
+
+
+# 시간 복잡도: O(32)
+# - bin(): O(32)
+# - zfill(32): O(32)
+# - 문자열 뒤집기 [::-1]: O(32)
+# - int(문자열, 2): O(32)
+# 총합: O(32) (상수 시간으로 간주 가능)
+
+# 공간 복잡도: O(32)
+# - 이진 문자열(binary)와 뒤집힌 문자열(reversed_binary)을 저장하므로 O(32).
+
+
+class Solution:
+    def reverseBits(self, n: int) -> int:
+        result = 0
+
+        for i in range(32):
+            # result를 왼쪽으로 1비트 이동하고 n의 마지막 비트를 추가
+            result = (result << 1) | n & 1
+            # n을 오른쪽으로 1비트 이동
+            n >>= 1
+
+        return result
+
+
+# 시간 복잡도: O(32)
+# - 반복문이 32번 실행되며 각 작업(비트 이동 및 OR 연산)은 O(1).
+# 총합: O(32) (상수 시간으로 간주 가능)
+
+# 공간 복잡도: O(1)
+# - 추가로 사용하는 변수 result와 n만 저장하므로 상수 공간.

two-sum/pmjuu.py

@@ -0,0 +1,20 @@
+from typing import List
+
+
+class Solution:
+    def twoSum(self, nums: List[int], target: int) -> List[int]:
+        subtract_map = {}
+
+        for i, num in enumerate(nums):
+            if num in subtract_map:
+                return [i, subtract_map[num]]
+            else:
+                subtract_map[target - num] = i
+
+
+# 시간 복잡도: O(n)
+# - nums 배열을 한 번 순회하며 각 요소를 확인하므로 시간 복잡도는 O(n)입니다.
+#
+# 공간 복잡도: O(n)
+# - 추가로 사용하는 subtract_map 딕셔너리에는 최악의 경우 nums 배열의 모든 요소가 저장되므로
+#   공간 복잡도는 O(n)입니다.