[chrisjune] WEEK 02 Solutions

3sum/chrisjune.py

@@ -0,0 +1,17 @@
+from typing import List
+
+
+class Solution:
+    def threeSum(self, nums: List[int]) -> List[List[int]]:
+        if len(nums) >= 3 and set(nums) == set([0]):
+            return [[0, 0, 0]]
+        triplets = set()
+        for i in range(len(nums) - 2):
+            seen = set()
+            for j in range(i + 1, len(nums)):
+                f = -(nums[i] + nums[j])
+                if f in seen:
+                    triplet = [nums[i], nums[j], f]
+                    triplets.add(tuple(sorted(triplet)))
+                seen.add(nums[j])
+        return list(triplets)

climbing-stairs/chrisjune.py

@@ -0,0 +1,10 @@
+class Solution:
+    def climbStairs(self, n: int) -> int:
+        if n <= 1:
+            return 1
+        dp = [0] * n
+        dp[0] = 1
+        dp[1] = 2
+        for i in range(3, n + 1):
+            dp[i - 1] = dp[i - 2] + dp[i - 3]
+        return dp[n - 1]

contains-duplicate/chrisjune.py

@@ -0,0 +1,9 @@
+class Solution:
+    def containsDuplicate(self, nums) -> bool:
+        dic = {}
+        for num in nums:
+            dic[num] = dic.get(num, 0) + 1
+        for v in dic.values():
+            if v > 1:
+                return True
+        return False

house-robber/chrisjune.py

@@ -0,0 +1,12 @@
+from typing import List
+
+
+class Solution:
+    def rob(self, nums: List[int]) -> int:
+        if len(nums) <= 1:
+            return nums[0]
+        dp = [0] * len(nums)
+        dp[0], dp[1] = nums[0], max(nums[0], nums[1])
+        for i in range(2, len(nums)):
+            dp[i] = max(dp[i - 1], nums[i] + dp[i - 2])
+        return dp[-1]

longest-consecutive-sequence/chrisjune.py

@@ -0,0 +1,18 @@
+from typing import List
+
+
+class Solution:
+    def longestConsecutive(self, nums: List[int]) -> int:
+        if len(nums) < 1:
+            return 0
+        nums = list(set(nums))
+        nums.sort()
+        dp = [0] * len(nums)
+        dp[0] = 1
+        for i in range(1, len(nums)):
+            if nums[i - 1] + 1 == nums[i]:
+                dp[i] = dp[i - 1] + 1
+            else:
+                dp[i] = 1
+        print(dp)
+        return max(dp)

product-of-array-except-self/chrisjune.py

@@ -0,0 +1,19 @@
+from typing import List
+
+
+class Solution:
+    def productExceptSelf(self, nums: List[int]) -> List[int]:
+        len_n = len(nums)
+        front_cum = [1] * len_n
+        back_cum = [1] * len_n
+
+        for i in range(1, len_n):
+            front_cum[i] = front_cum[i - 1] * nums[i - 1]
+
+        for j in range(1, len_n):
+            idx = len_n - j - 1
+            back_cum[idx] = back_cum[idx + 1] * nums[idx + 1]
+
+        final = [front_cum[i] * back_cum[i] for i in range(len_n)]
+
+        return final

top-k-frequent-elements/chrisjune.py

@@ -0,0 +1,12 @@
+from typing import List
+
+
+class Solution:
+    def topKFrequent(self, nums: List[int], k: int) -> List[int]:
+        dic = {}
+        for num in nums:
+            dic[num] = dic.get(num, 0) + 1
+        l = [(k, v) for k, v in dic.items()]
+        l.sort(reverse=True, key=lambda x: x[1])
+        l = [i for i, _ in l]
+        return l[:k]

two-sum/chrisjune.py

@@ -0,0 +1,11 @@
+from typing import List
+
+
+class Solution:
+    def twoSum(self, nums: List[int], target: int) -> List[int]:
+        nums_dic = {num: idx for idx, num in enumerate(nums)}
+        for i in range(len(nums)):
+            remain = target - nums[i]
+            exists_idx = nums_dic.get(remain)
+            if exists_idx and exists_idx != i:
+                return i, exists_idx

valid-anagram/chrisjune.py

@@ -0,0 +1,3 @@
+class Solution:
+    def isAnagram(self, s: str, t: str) -> bool:
+        return sorted(s) == sorted(t)