Merge pull request #1185 from sounmind/main

[sounmind] WEEK 1 solutions

Author: sounmind

house-robber/sounmind.py

@@ -1,20 +1,29 @@
-from typing import List
-
-
 class Solution:
     def rob(self, nums: List[int]) -> int:
-        house_length = len(nums)
+        # 예외 처리: 집이 2개 이하일 경우 그 중 큰 값이 최대 도둑질 금액
+        if len(nums) < 3:
+            return max(nums)
+
+        # DP(Dynamic Programming)를 위한 메모이제이션 배열
+        # memo[0]: 첫 번째 집까지 고려했을 때 최대 도둑질 금액
+        # memo[1]: 두 번째 집까지 고려했을 때 최대 도둑질 금액
+        memo = [nums[0], max(nums[0], nums[1])]
 
-        if house_length == 0:
-            return 0
-        if house_length == 1:
-            return nums[0]
-        if house_length == 2:
-            return max(nums[0], nums[1])
+        # 세 번째 집부터 순차적으로 도둑질 시나리오 검토
+        # 매 집마다 두 가지 선택이 있음: 현재 집을 털거나 vs 털지 않거나
+        for num in nums[2:]:
+            # 현재 집을 털 경우: 현재 집 금액 + 전전 집까지의 최대 금액
+            # (인접한 집은 털 수 없으므로 바로 이전 집은 건너뜀)
+            robbed = memo[0] + num
 
-        dp = [nums[0], max(nums[0], nums[1])]
+            # 현재 집을 털지 않는 경우: 이전 집까지의 최대 금액을 그대로 유지
+            not_robbed = memo[1]
 
-        for index in range(2, house_length):
-            dp.append(max(dp[index - 1], dp[index - 2] + nums[index]))
+            # 메모이제이션 배열 업데이트
+            # 다음 반복을 위해 memo[0]은 이전까지의 최대값으로 갱신
+            memo[0] = memo[1]
+            # memo[1]은 현재까지의 최대값(현재 집을 털거나 안 털거나 중 더 큰 값)으로 갱신
+            memo[1] = max(robbed, not_robbed)
 
-        return dp[-1]
+        # 마지막 집까지 고려했을 때의 최대 도둑질 금액 반환
+        return memo[1]

longest-consecutive-sequence/sounmind.js

@@ -0,0 +1,30 @@
+from typing import List
+
+
+class Solution:
+    def longestConsecutive(self, nums: List[int]) -> int:
+        # Time Complexity: O(n) where n is the length of nums
+        # Strategy: Use a set for O(1) lookups and only extend sequences from their starting points
+        if not nums:
+            return 0
+
+        max_streak = 0
+        num_set = set(nums)
+
+        # Only check sequences from their starting points to avoid redundant work
+        for num in num_set:
+            current_streak = 0
+
+            # Check if this number is the start of a sequence (no left neighbor)
+            if num - 1 not in num_set:
+                # Found a sequence start - extend it as far as possible
+                current_num = num
+
+                while current_num in num_set:
+                    current_streak += 1
+                    current_num += 1
+
+                # Update the longest streak found so far
+                max_streak = max(max_streak, current_streak)
+
+        return max_streak

longest-consecutive-sequence/sounmind.py

@@ -0,0 +1,28 @@
+from collections import Counter
+
+
+def top_k_frequent(nums, k):
+    # Count the frequency of each number in the input list
+    counter = Counter(nums)
+
+    # Find the maximum frequency among all numbers
+    max_freq = max(counter.values())
+
+    # Create a list of empty lists (buckets) where index represents frequency
+    buckets = [[] for _ in range(max_freq + 1)]
+
+    # Place each number into the bucket corresponding to its frequency
+    for num, freq in counter.items():
+        buckets[freq].append(num)
+
+    # Initialize an empty list to store the result
+    result = []
+
+    # Iterate over the buckets in reverse order (from highest frequency to lowest)
+    for freq in range(max_freq, 0, -1):
+        # Add all numbers in the current bucket to the result
+        result.extend(buckets[freq])
+
+        # If we have collected at least k elements, return the first k elements
+        if len(result) >= k:
+            return result[:k]