Merge pull request #2358 from TreeStone94/main

[TreeStone94] WEEK 1 Solutions

Author: TreeStone94

contains-duplicate/TreeStone94.py

@@ -0,0 +1,6 @@
+class Solution:
+    def containsDuplicate(self, nums: List[int]) -> bool:
+        if len(set(nums)) == len(nums):
+            return False
+        else:
+            return True

house-robber/TreeStone94.py

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

longest-consecutive-sequence/TreeStone94.py

@@ -0,0 +1,20 @@
+class Solution:
+    def longestConsecutive(self, nums: List[int]) -> int:
+        answer = []
+        count = 0
+        pre_num = -9999999999999999999
+        for n in sorted(set(nums)):
+            if pre_num + 1 == n:
+                count += 1
+            else:
+                answer.append(count)
+                count = 0
+            pre_num = n
+
+        if count != 0:
+            answer.append(count)
+
+        if answer:
+            return max(answer) + 1
+        else:
+            return 0

top-k-frequent-elements/TreeStone94.py

@@ -0,0 +1,16 @@
+class Solution:
+    def topKFrequent(self, nums: List[int], k: int) -> List[int]:
+        frequent = {}
+        for n in nums:
+            if n not in frequent:
+                frequent[n] = 1
+            else:
+                frequent[n] += 1
+
+        answer = []
+        for f in sorted(frequent.items(), key=lambda item: item[1], reverse=True):
+            if k > 0:
+                answer.append(f[0])
+            k -= 1
+        return answer
+

two-sum/TreeStone94.py

@@ -0,0 +1,8 @@
+class Solution:
+    def twoSum(self, nums: List[int], target: int) -> List[int]:
+        answer = []
+        for i,n in enumerate(nums):
+            t = target - n
+            if t in nums[i+1:]:
+                answer = [i, (i+1) +nums[i+1:].index(t)]
+                return answers