[hyeri0903] WEEK 01 solutions

contains-duplicate/hyeri0903.py

@@ -0,0 +1,13 @@
+class Solution:
+    def containsDuplicate(self, nums: List[int]) -> bool:
+        ans = False
+        dic = dict()
+
+        for n in nums:
+            if n in dic:
+                return True
+            else:
+                dic[n] = 1
+        return ans
+
+

house-robber/hyeri0903.py

@@ -0,0 +1,14 @@
+class Solution:
+    def rob(self, nums: List[int]) -> int:
+        dp = {}
+        dp[0] = nums[0]
+        if len(nums) >= 2:
+            dp[1] = max(nums[0], nums[1])
+        else:
+            return nums[0]
+
+        for i in range(2, len(nums)):
+            dp[i] = max(dp[i-1], dp[i-2] + nums[i])
+
+        res = list(dp.values())[-1]
+        return res

longest-consecutive-sequence/hyeri0903.py

@@ -0,0 +1,36 @@
+class Solution:
+    def longestConsecutive(self, nums: List[int]) -> int:
+        if len(nums) <= 0:
+            return 0
+
+        res = 0
+        length = 1
+        nums.sort()
+
+        for i in range(len(nums)-1):
+            if nums[i] == nums[i+1]:
+                continue
+            if nums[i] + 1 == nums[i+1]:
+                length += 1
+            else:
+                res = max(res, length)
+                length = 1
+
+        res = max(res, length)
+        return res
+
+        #set을 사용한 풀이
+        # if len(nums) <= 0:
+        #     return 0
+        # res, cnt = 1, 1
+        # sorted_nums = list(set(nums))
+        # sorted_nums.sort()
+        # print(sorted_nums)
+
+        # for i in range(len(sorted_nums) - 1):
+        #     if sorted_nums[i + 1] - sorted_nums[i] == 1:
+        #         cnt += 1
+        #     else:
+        #         cnt = 1
+        #     res = max(res, cnt)
+        # return res

top-k-frequent-elements/hyeri0903.py

@@ -0,0 +1,24 @@
+import heapq
+
+class Solution:
+    def topKFrequent(self, nums: List[int], k: int) -> List[int]:
+        table = {}
+        for n in nums:
+            if n in table:
+                table[n] += 1
+            else:
+                table[n] = 1
+        #sol 1) sorting 사용한 case
+        # sorted_table = sorted(table.items(), key=lambda x:x[1], reverse = True)
+        # return [ key for key, freq in sorted_table[:k]]
+
+        #sol 2) min heap 사용한 case
+        #convert the frequencies to negative values so it return first
+        heap = [(-freq, key) for key, freq in table.items()]
+        heapq.heapify(heap)
+
+        res = []
+        for _ in range(k):
+            freq, key = heapq.heappop(heap)
+            res.append(key)
+        return res

two-sum/hyeri0903.py

@@ -0,0 +1,8 @@
+class Solution:
+    def twoSum(self, nums: List[int], target: int) -> List[int]:
+
+        for i in range(len(nums)):
+            for j in range(i+1, len(nums)):
+                if nums[i] + nums[j] == target:
+                    return [i, j]
+