From 0d73a285600021dbffe6b7b8598a48c49ec9d767 Mon Sep 17 00:00:00 2001 From: AYo Secu Date: Sun, 30 Mar 2025 16:51:35 -0700 Subject: [PATCH 1/5] - Solution for "217. Contains Duplicate". --- contains-duplicate/ayosecu.py | 30 ++++++++++++++++++++++++++++++ 1 file changed, 30 insertions(+) create mode 100644 contains-duplicate/ayosecu.py diff --git a/contains-duplicate/ayosecu.py b/contains-duplicate/ayosecu.py new file mode 100644 index 000000000..0babe5de3 --- /dev/null +++ b/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}") From 1343e82d82eaa44a62de70cea0c364de62db2c26 Mon Sep 17 00:00:00 2001 From: AYo Secu Date: Sun, 30 Mar 2025 17:39:45 -0700 Subject: [PATCH 2/5] - Solution for Two Sum #219 --- two-sum/ayosecu.py | 34 ++++++++++++++++++++++++++++++++++ 1 file changed, 34 insertions(+) create mode 100644 two-sum/ayosecu.py diff --git a/two-sum/ayosecu.py b/two-sum/ayosecu.py new file mode 100644 index 000000000..f650433cf --- /dev/null +++ b/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}") From 192ef041eb7c3d0c749ce2068f46c0984457224d Mon Sep 17 00:00:00 2001 From: AYo Secu Date: Sun, 30 Mar 2025 18:53:02 -0700 Subject: [PATCH 3/5] - Solution for "Top K Frequent Elements #237" --- top-k-frequent-elements/ayosecu.py | 27 +++++++++++++++++++++++++++ 1 file changed, 27 insertions(+) create mode 100644 top-k-frequent-elements/ayosecu.py diff --git a/top-k-frequent-elements/ayosecu.py b/top-k-frequent-elements/ayosecu.py new file mode 100644 index 000000000..bca2e0ef9 --- /dev/null +++ b/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}") From 91e2247fe97d2297276f2ff9e58cb756a1a8c0e9 Mon Sep 17 00:00:00 2001 From: AYo Secu Date: Sun, 30 Mar 2025 20:45:08 -0700 Subject: [PATCH 4/5] - Solution for "Longest Consecutive Sequence #240". --- longest-consecutive-sequence/ayosecu.py | 33 +++++++++++++++++++++++++ 1 file changed, 33 insertions(+) create mode 100644 longest-consecutive-sequence/ayosecu.py diff --git a/longest-consecutive-sequence/ayosecu.py b/longest-consecutive-sequence/ayosecu.py new file mode 100644 index 000000000..9b0f5bb5a --- /dev/null +++ b/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}") From bcbb7f8d86fa3de15b64fb5b082abbad6805288a Mon Sep 17 00:00:00 2001 From: AYo Secu Date: Mon, 31 Mar 2025 13:48:40 -0700 Subject: [PATCH 5/5] - Solution for "House Robber #264". --- house-robber/ayosecu.py | 30 ++++++++++++++++++++++++++++++ 1 file changed, 30 insertions(+) create mode 100644 house-robber/ayosecu.py diff --git a/house-robber/ayosecu.py b/house-robber/ayosecu.py new file mode 100644 index 000000000..fa15a19d8 --- /dev/null +++ b/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}")