[bhyun-kim, bh_kim] Solution for week1 assignments

best-time-to-buy-and-sell-stock/bhyun-kim.py

@@ -0,0 +1,43 @@
+"""
+Solution
+
+Algorithm:
+    1. Iterate through the list in reverse.
+    2. Keep track of the maximum value seen so far.
+    3. Calculate the profit by subtracting the current value from the maximum value.
+    4. Update the profit if it is greater than the current profit.
+
+Time complexity: O(n)
+Space complexity: O(1)
+"""
+
+
+from typing import List
+
+class Solution:
+    def maxProfit(self, prices: List[int]) -> int:
+        profit = 0
+        prev_max = 0
+
+        for i in reversed(range(len(prices)-1)):
+            prev_max = max(prev_max, prices[i+1])
+            profit = max(profit, prev_max-prices[i])
+
+        return profit
+
+
+
+def main():
+    test_cases = [
+        [[7,1,5,3,6,4], 5],
+        [[7,6,4,3,1], 0]
+    ]
+    s = Solution()
+
+    for test_case in test_cases:
+        prices_input, expected = test_case
+        assert s.maxProfit(prices_input) == expected
+
+if __name__ == '__main__':
+    main()
+

contains-duplicate/bhyun-kim.py

@@ -0,0 +1,34 @@
+"""
+Solution
+
+Algorithm:
+    1. Create a set from the list.
+    2. If the length of the set is not equal to the length of the list, return True.
+    3. Otherwise, return False.
+
+Time complexity: O(n)
+Space complexity: O(n)
+"""
+
+
+from typing import List
+
+class Solution:
+    def containsDuplicate(self, nums: List[int]) -> bool:
+        return len(set(nums)) != len(nums)
+
+def main():
+    test_cases = [
+        [[1,2,3,1], True,]
+        [[1,2,3,4], False],
+        [[1,1,1,3,3,4,3,2,4,2], True]
+    ]
+    s = Solution()
+
+    for test_case in test_cases:
+        nums_input, expected = test_case
+        assert s.containsDuplicate(nums_input) == expected
+
+if __name__ == '__main__':
+    main()
+

two-sum/bhyun-kim.py

@@ -0,0 +1,42 @@
+"""
+Solution
+
+Algorithm:
+    1. Create a hashmap to store the index of each element.
+    2. Iterate through the list.
+    3. Check if the remaining value is in the hashmap.
+    4. If it is, return the current index and the index of the remaining value in the hashmap.
+
+Time complexity: O(n)
+Space complexity: O(n)
+"""
+
+from typing import List
+
+class Solution:
+    def twoSum(self, nums: List[int], target: int) -> List[int]:
+
+        hashmap = {}
+
+        for i in range(len(nums)):
+            remaining = target - nums[i]
+            if remaining in hashmap:
+                return [i, hashmap[remaining]]
+
+            hashmap[nums[i]] = i
+
+def main():
+    test_cases = [
+        [2,7,11,15], 9, [0,1],
+        [3,2,4], 6, [1,2],
+        [3,3], 6, [0,1]
+    ]
+    s = Solution()
+
+    for test_case in test_cases:
+        nums_input, target_input, expected = test_case
+        assert sorted(s.twoSum(nums_input, target_input)) == expected
+
+if __name__ == '__main__':
+    main()
+

valid-anagram/bhyun-kim.py

@@ -0,0 +1,34 @@
+"""
+Solution
+
+Algorithm:
+    1. Sort the strings and compare them.
+    2. If they are equal, return True. Otherwise, return False.
+
+Time complexity: O(nlogn)
+Space complexity: O(1)
+"""
+
+class Solution:
+    def isAnagram(self, s: str, t: str) -> bool:
+
+        if sorted(s) == sorted(t):
+            return True
+        else:
+            return False
+
+
+def main():
+    test_cases = [
+        ["anagram", "nagaram", True],
+        ["rat", "car", False]
+    ]
+    s = Solution()
+
+    for test_case in test_cases:
+        s_input, t_input, expected = test_case
+        assert s.isAnagram(s_input, t_input) == expected
+
+if __name__ == '__main__':
+    main()
+

valid-palindrome/bhyun-kim.py

@@ -0,0 +1,35 @@
+"""
+Solution:
+
+Algorithm: 
+    1. Convert the string to lowercase.
+    2. Remove all non-alphanumeric characters.
+    3. Check if the string is equal to its reverse.
+
+Time complexity: O(n)
+Space complexity: O(n) 
+"""
+
+
+class Solution:
+    def isPalindrome(self, s: str) -> bool:
+        s = s.lower()
+        s = list([c for c in s
+            if c.isalpha() or c.isnumeric()])
+        s = "".join(s)
+        return s == s[::-1]
+
+def main():
+    test_cases = [
+        ["A man, a plan, a canal: Panama", True],
+        ["race a car", False],
+        [" ", True]
+    ]
+    s = Solution()
+
+    for test_case in test_cases:
+        s_input, expected = test_case
+        assert s.isPalindrome(s_input) == expected
+
+if __name__ == '__main__':
+    main()