[WHYjun] WEEK 01 solutions

contains-duplicate/WHYjun.py

@@ -0,0 +1,3 @@
+class Solution:
+    def containsDuplicate(self, nums: List[int]) -> bool:
+        return len(set(nums)) != len(nums)

house-robber/WHYjun.py

@@ -0,0 +1,21 @@
+class Solution:
+    def rob(self, nums: List[int]) -> int:
+        # memo for DP
+        dp = {}
+        return self.robs(nums, dp, len(nums) - 1)
+
+    def robs(self, nums: List[int], dp: Dict[int, int], houseToRob: int) -> int:
+        if houseToRob < 0:
+            return 0
+
+        if houseToRob - 2 not in dp:
+            dp[houseToRob - 2] = self.robs(nums, dp, houseToRob - 2)
+
+        if houseToRob - 1 not in dp:
+            dp[houseToRob - 1] = self.robs(nums, dp, houseToRob - 1)
+
+
+        return max(
+            dp[houseToRob - 2] + nums[houseToRob],
+            dp[houseToRob - 1]    
+        )

longest-consecutive-sequence/WHYjun.py

@@ -0,0 +1,44 @@
+import heapq
+
+class Solution:
+    def longestConsecutive(self, nums: List[int]) -> int:
+        # remove duplicates by using set
+        numsSet = set(nums)
+
+        if len(numsSet) == 0 or len(numsSet) == 1:
+            return len(numsSet)
+
+        # Use priority queue to sort in O(n)
+        pq = heapq.heapify(list(numsSet))
+
+        prev = heapq.heappop(pq)
+        answer, count = 1, 1
+        for i in range(len(numsSet) - 1):
+            popped = heapq.heappop(pq)
+            if prev + 1 == popped:
+                count += 1
+            else:
+                count = 1
+
+            prev = popped
+            answer = max(answer, count)
+
+        return answer
+
+    def longestConsecutiveUsingSetOnly(self, nums: List[int]) -> int:
+        # remove duplicates by using set
+        numsSet = set(nums)
+
+        answer = 0
+
+        for num in numsSet:
+            # continue if it's not the longest consecutive
+            if num - 1 in numsSet:
+                continue
+            else:
+                count = 1
+                while num + count in numsSet:
+                    count += 1
+                answer = max(answer, count)
+
+        return answer

top-k-frequent-elements/WHYjun.py

@@ -0,0 +1,17 @@
+class Solution:
+    def topKFrequent(self, nums: List[int], k: int) -> List[int]:
+        # Time complexity: O(nlog(n))
+        # Space Complexity: O(n)
+
+        if len(nums) <= k:
+            return list(set(nums))
+
+        counts = {}
+        for num in nums:
+            if num not in counts:
+                counts[num] = 0
+            counts[num] += 1
+
+        # The key of dictionary is unique.
+        sortedKeys = sorted(list(counts.keys()), key=lambda key: counts[key], reverse = True)
+        return sortedKeys[:k]

two-sum/WHYjun.py

@@ -0,0 +1,12 @@
+class Solution:
+    def twoSum(self, nums: List[int], target: int) -> List[int]:
+        memo = {}
+
+        for i, num in enumerate(nums):
+            diff = target - num
+            if diff in memo:
+                # Each input would have exactly one solution
+                return [memo[diff], i]
+            memo[num] = i    
+
+        return []