[njngwn] WEEK 01 solutions

contains-duplicate/njngwn.py

@@ -0,0 +1,11 @@
+class Solution:
+    # Time Complexity: O(nlogn), n: len(nums)
+    # Space Complexity: O(1)
+    def containsDuplicate(self, nums: List[int]) -> bool:
+        nums.sort()  # O(nlogn)
+
+        for i in range(len(nums)):
+            if i > 0 and nums[i] == nums[i - 1]:
+                return True
+
+        return False

house-robber/njngwn.py

@@ -0,0 +1,17 @@
+class Solution:
+    # Time Complexity: O(n), n: len(nums)
+    # Space Complextiy: O(1)
+    def rob(self, nums: List[int]) -> int:
+        if not nums:
+            return 0
+        if len(nums) == 1:
+            return nums[0]
+
+        two_ago = nums[0]
+        one_ago = max(nums[0], nums[1])
+
+        for i in range(2, len(nums)):
+            current = max(one_ago, two_ago + nums[i])
+            two_ago, one_ago = one_ago, current
+
+        return one_ago

longest-consecutive-sequence/njngwn.py

@@ -0,0 +1,19 @@
+class Solution:
+    # Time Complexity: O(nlogn), n: len(nums)
+    # Space Complexity: O(n), n: len(nums)
+    def longestConsecutive(self, nums: List[int]) -> int:
+        if not nums:
+            return 0
+
+        nums = sorted(set(nums)) # O(nlogn)
+        longest = 1
+        length = 1
+
+        for i in range(1, len(nums)):
+            if nums[i] - nums[i-1] == 1:
+                length += 1
+                longest = max(longest, length)
+            else:
+                length = 1
+
+        return longest

top-k-frequent-elements/njngwn.py

@@ -0,0 +1,28 @@
+from collections import Counter
+
+
+class Solution:
+    # Solution 1
+    # Time Complexity: O(nlogn), n: len(nums)
+    # Space Complexity: O(n), n:len(nums)
+    def topKFrequent(self, nums: List[int], k: int) -> List[int]:
+        counter = {}
+        for num in nums:
+            counter[num] = counter.get(num, 0) + 1
+            sorted_nums = sorted(counter, key=lambda num: counter[num])
+
+        return sorted_nums[-k:]
+
+    # Solution 2
+    # Time Complexity: O(n), n: len(nums)
+    # Space Complexity: O(n), n: len(nums)
+    def topKFrequent(self, nums: List[int], k: int) -> List[int]:
+        counter = Counter(nums)
+        buckets = [[] for _ in range(len(nums) + 1)]
+
+        for num, cnt in counter.items():
+            buckets[cnt].append(num)
+
+        sorted_nums = [item for bucket in buckets for item in bucket]
+
+        return sorted_nums[-k:]

two-sum/njngwn.py

@@ -0,0 +1,11 @@
+class Solution:
+    # Time Complexity: O(nlogn), n: len(nums)
+    # Space Complexity: O(1)
+    def containsDuplicate(self, nums: List[int]) -> bool:
+        nums.sort()  # O(nlogn)
+
+        for i in range(len(nums)):
+            if i > 0 and nums[i] == nums[i - 1]:
+                return True
+
+        return False