[freemjstudio] WEEK 02 Solutions

3sum/freemjstudio.py

@@ -0,0 +1,29 @@
+class Solution:
+    def threeSum(self, nums: list[int]) -> list[list[int]]:
+        answer = []
+        nums.sort() 
+
+        for i in range(len(nums)):
+            # 중복된 원소가 있는 경우 똑같이 검사할 필요가 없으므로 건너뛴다.
+            if i > 0 and nums[i] == nums[i-1]:
+                continue 
+
+            left, right = i+1, len(nums) - 1
+
+            while left < right: 
+                total = nums[i] + nums[left] + nums[right]
+                if total == 0:
+                    answer.append([nums[i], nums[left], nums[right]])
+                    # left, right 포인터를 둘다 한칸씩 이동시켜 다음 조합을 검사한다.
+                    left += 1
+                    right -= 1
+
+                    # 중복된 원소가 있는 경우 같은 정답 조합을 방지한다 
+                    while left < right and nums[left] == nums[left -1]:
+                        left += 1
+
+                elif total < 0:
+                    left += 1
+                else: 
+                    right -= 1
+        return answer

climbing-stairs/freemjstudio.py

@@ -0,0 +1,17 @@
+class Solution:
+    def climbStairs(self, n: int) -> int:
+        answer = 0 
+        if n == 1: # ways(1) = 1
+            return 1
+
+        if n == 2: # ways(2) = 2
+            return 2
+
+        dp = [0] * 46 # 1 <= n <= 45
+        dp[1] = 1
+        dp[2] = 2
+
+        # 점화식 : ways(n) = ways(n-1) + ways(n-2)
+        for i in range(3, n+1):
+            dp[i] = dp[i-1] + dp[i-2]
+        return dp[n]

contains-duplicate/freemjstudio.py

@@ -0,0 +1,8 @@
+class Solution:
+    def containsDuplicate(self, nums: List[int]) -> bool:
+        first = len(nums) # O(1) : 리스트 객체는 이미 자기자신의 길이를 저장하고 있음 
+        set_nums = set(nums) # O(N)
+        second = len(set_nums)
+        return (first != second)
+
+# 시간 복잡도 : O(N)

top-k-frequent-elements/freemjstudio.py

@@ -0,0 +1,29 @@
+import heapq
+
+class Solution:
+    def topKFrequent(self, nums: List[int], k: int) -> List[int]:
+        answer = []
+        count = dict()
+        heap = []
+        if len(nums) <= 1: 
+            return nums
+        # O(N)    
+        for num in nums: 
+            count[num] = count.get(num, 0) + 1
+
+        # heap 의 크기는 최대 k 로 제한함. 
+        # unique 한 M개의 숫자를 선형 순회 O(M)
+        for num, freq in count.items():
+            if len(heap) < k: 
+                heapq.heappush(heap, (freq, num))         # O(logK)
+            else: 
+                if heap[0][0] < freq:
+                    heapq.heappop(heap)         # O(logK)
+                    heapq.heappush(heap, (freq, num))         # O(logK)
+
+        for _ in range(k):
+            k, v = heapq.heappop(heap)
+            answer.append(v)
+
+        return answer 
+

two-sum/freemjstudio.py

@@ -0,0 +1,12 @@
+class Solution:
+    def twoSum(self, nums: List[int], target: int) -> List[int]:
+        answer = []
+        hashmap = dict()
+        for i in range(len(nums)):
+            current_num = nums[i]
+            diff = target - current_num
+            if diff in hashmap.keys(): 
+                return [i, hashmap[diff]] 
+            hashmap[current_num] = i # store the index of current num
+
+        return answer

valid-anagram/freemjstudio.py

@@ -0,0 +1,32 @@
+"""
+첫번째 풀이 
+시간 복잡도 : O(n log n)
+"""
+
+class Solution:
+    def isAnagram(self, s: str, t: str) -> bool:
+        return sorted(s) == sorted(t)
+
+"""
+두번째 풀이
+시간 복잡도 : O(n)
+"""
+
+class Solution:
+    def isAnagram(self, s: str, t: str) -> bool:
+        # 반례 : s = ab, t = a 
+        # 이 경우에는 t에 없는 b가 존재하므로 False를 반환해야 한다.
+        if len(s) != len(t):
+            return False 
+        counter = {}
+
+        for ch in s: 
+            counter[ch] = counter.get(ch, 0) + 1
+
+        for ch in t: 
+            if ch not in counter:
+                return False 
+            counter[ch] -= 1
+            if counter[ch] < 0:
+                return False 
+        return True