Merge pull request #2019 from Donghae0230/main

[Donghae0230] WEEK 01 solutions

Author: dalestudy[bot]

contains-duplicate/Donghae0230.py

@@ -0,0 +1,12 @@
+# 시간 복잡도
+# 입력 list를 set으로 변환 -> 최대 O(n)
+# 공간 복잡도
+# 입력 list를 set으로 변환 -> 최대 O(n)
+class Solution:
+    def containsDuplicate(self, nums: List[int]) -> bool:
+        set_nums = set(nums)
+        list_nums = list(set_nums)
+        if len(nums) != len(list_nums):
+            return True
+        else:
+            return False

house-robber/Donghae0230.py

@@ -0,0 +1,23 @@
+# 시간 복잡도
+# nums의 길이에 여러 분기로 나뉨 -> O(2^n) -> Time Limit Exceeded로 실패
+# 공간 복잡도
+# 재귀 깊이에 따라 늘어남 -> 최대 O(n)
+
+class Solution:
+    def temp(self, n, nums, val, lst):
+        if n+2 >= len(nums):
+            lst.append(val)
+            lst = max(lst)
+            return lst
+        for i in range(n+2, len(nums)):
+            self.temp(i, nums, val+nums[i], lst)
+        lst = max(lst)
+        return lst
+
+    def rob(self, nums: List[int]) -> int:
+        if len(nums) > 1:
+            start_0 = self.temp(0, nums, nums[0], [])
+            start_1 = self.temp(1, nums, nums[1], [])
+            return max(start_0, start_1)
+        else:
+            return nums[0]

longest-consecutive-sequence/Donghae0230.py

@@ -0,0 +1,21 @@
+# 시간 복잡도
+# 입력 list를 정렬해서 사용 -> 최대 O(n log n)
+# 공간 복잡도
+# 입력 list를 set으로 변환 -> 최대 O(n)
+
+class Solution:
+    def longestConsecutive(self, nums: List[int]) -> int:
+        if len(nums) == 0:
+            return 0
+        sorted_nums = list(sorted(set(nums)))
+        temp = 1
+        result = 0
+        # print(sorted_nums)
+        for i in range(0, len(sorted_nums) - 1):
+            if sorted_nums[i] + 1 == sorted_nums[i+1]:
+                temp += 1
+            else:
+                result = max(result, temp)
+                temp = 1
+        result = max(result, temp)
+        return result

top-k-frequent-elements/Donghae0230.py

@@ -0,0 +1,26 @@
+# 시간 복잡도
+# 입력 list를 정렬해서 사용 -> 최대 O(n log n)
+# 공간 복잡도
+# 입력 list를 set으로 변환 -> 최대 O(n)
+class Solution:
+    def topKFrequent(self, nums: List[int], k: int) -> List[int]:
+        nums.sort()
+        items = {}
+        n = nums[0]
+        cnt = 1
+        if len(nums) > 1:
+            for i in range(1, len(nums)):
+                if n != nums[i]:
+                    items[n] = cnt
+                    n = nums[i]
+                    cnt = 1
+                else:
+                    cnt += 1
+            items[n] = cnt
+        else:
+            items[n] = 1
+        sorted_items_desc = sorted(items.items(), key=lambda item: item[1], reverse=True)
+        result = []
+        for i in sorted_items_desc[:k]:
+            result.append(i[0])
+        return result

two-sum/Donghae0230.py

@@ -0,0 +1,12 @@
+# 시간 복잡도
+# 입력 list를 이중 for문에서 사용 -> O(n^2)
+# 공간 복잡도
+# 크기가 고정된 리스트 사용 -> O(1)
+class Solution:
+    def twoSum(self, nums: List[int], target: int) -> List[int]:
+        for i in range(0, len(nums)):
+            for l in range(0, len(nums)):
+                if i == l:
+                    continue
+                if nums[i] + nums[l] == target:
+                    return [i, l]