Merge pull request #1140 from ayosecu/main

[ayosecu] WEEK 01 solutions

Author: ayosecu

contains-duplicate/ayosecu.py

@@ -0,0 +1,30 @@
+from typing import List
+
+class Solution:
+    """
+        - Time Complexity: O(n), n = len(nums)
+        - Space Complexity: O(N)
+            - N = len(set_check) = The number of unique numbers
+            - If there is no duplicated numbers, N = n
+    """
+    def containsDuplicate(self, nums: List[int]) -> bool:
+        set_check = set()
+
+        for num in nums:
+            if num in set_check:
+                return True
+            else:
+                set_check.add(num)
+        
+        return False
+
+tc = [
+        ([1, 2, 3, 1], True),
+        ([1, 2, 3, 4], False),
+        ([1,1,1,3,3,4,3,2,4,2], True)
+    ]
+
+for i, (t, e) in enumerate(tc, 1):
+    sol = Solution()
+    result = sol.containsDuplicate(t)
+    print(f"TC {i} is Passed!" if result == e else f"TC {i} is Failed! - Expected: {e}, Result: {result}")

house-robber/ayosecu.py

@@ -0,0 +1,30 @@
+from typing import List
+
+class Solution:
+    """
+        - Time Complexity: O(n), n = len(nums)
+        - Space Complexity: O(n), n = len(nums)
+    """
+    def rob(self, nums: List[int]) -> int:
+        # DP Formation
+        # money[0] = 0
+        # money[1] = nums[0]
+        # money[i+1] = max(money[i-1] + nums[i], money[i])
+
+        money = [0] * (len(nums) + 1)
+        money[1] = nums[0]
+        for i in range(1, len(nums)):
+            money[i+1] = max(money[i-1] + nums[i], money[i])
+        
+        return money[-1]
+
+tc = [
+        ([1, 2, 3, 1], 4),
+        ([2, 7, 9, 3, 1], 12),
+        ([1, 2, 0, 5, 10], 12)
+    ]
+
+for i, (nums, e) in enumerate(tc, 1):
+    sol = Solution()
+    result = sol.rob(nums)
+    print(f"TC {i} is Passed!" if result == e else f"TC {i} is Failed! - Expected: {e}, Result: {result}")

longest-consecutive-sequence/ayosecu.py

@@ -0,0 +1,33 @@
+from typing import List
+
+class Solution:
+    """
+        - Time Complexity: O(n), n = len(set_nums) = The number of unique numbers.
+        - Space Complexity: O(n)
+    """
+    def longestConsecutive(self, nums: List[int]) -> int:
+        set_nums = set(nums)
+        longest = 0
+
+        for num in set_nums:
+            if num - 1 not in set_nums:
+                # Only check for the start number
+                cnt = 1
+                next_num = num + 1
+                while next_num in set_nums:
+                    cnt += 1
+                    next_num += 1
+                longest = max(longest, cnt)
+        
+        return longest
+
+tc = [
+        ([100,4,200,1,3,2], 4),
+        ([0,3,7,2,5,8,4,6,0,1], 9),
+        ([1,0,1,2], 3)
+]
+
+for i, (nums, e) in enumerate(tc, 1):
+    sol = Solution()
+    result = sol.longestConsecutive(nums)
+    print(f"TC {i} is Passed!" if result == e else f"TC {i} is Failed!, Expected: {e}, Result: {result}")

top-k-frequent-elements/ayosecu.py

@@ -0,0 +1,27 @@
+from typing import List
+from collections import Counter
+
+class Solution:
+    """
+        - Time Complexity: O(nlogk), n = len(nums)
+            - Counter(nums) => O(n)
+            - Counter.most_common(k) => O(nlogk)
+            - O(n) + O(nlogk) => O(nlogk)
+        - Space Complexity: O(N)
+            - N = len(counter_nums) = The number of unique numbers
+            - Worst case => No duplicated numbers => N = n
+    """
+    def topKFrequent(self, nums: List[int], k: int) -> List[int]:
+        c = Counter(nums)
+        return [key for (key, val) in c.most_common(k)]
+
+tc = [
+        ([1,1,1,2,2,3], 2, [1, 2]),
+        ([1], 1, [1])
+]
+
+for i, (nums, k, e) in enumerate(tc, 1):
+    sol = Solution()
+    result = sol.topKFrequent(nums, k)
+    result.sort()
+    print(f"TC {i} is Passed!" if result == e else f"TC {i} is Failed! - Expected: {e}, Result: {result}")

two-sum/ayosecu.py

@@ -0,0 +1,34 @@
+from typing import List
+
+class Solution:
+    """
+        - Time Complexity: O(n), n = len(nums)
+        - Space Complexity: O(N)
+            - N = len(dic) = The number of unique numbers
+            - Worst case, it would be n. => O(N) => O(n)
+    """
+    def twoSum(self, nums: List[int], target: int) -> List[int]:
+        # Save "num:index" key-value to a dictionary
+        dic = {}
+       
+        for i, num in enumerate(nums):
+            # Check diff value is already in a dictionary
+            diff = target - num
+            if diff in dic:
+                # If there is a diff value, return indices of pair
+                return [dic[diff], i]
+            dic[num] = i
+
+        return []
+
+tc = [
+        ([2, 7, 11, 15], 9, [0, 1]),
+        ([3, 2, 4], 6, [1, 2]),
+        ([3, 3], 6, [0, 1])
+    ]
+
+for i, (nums, target, e) in enumerate(tc, 1):
+    sol = Solution()
+    result = sol.twoSum(nums, target)
+    result.sort()
+    print(f"TC {i} is Passed!" if result == e else f"TC {i} is Failed! - Expected: {e}, Result: {result}")