Week 1 Solutions: containsDuplicate, validPalindrome, topKFrequentElements and longestConsecutiveSequence

Author: GaggleHelena

contains-duplicate/yolophg.py

@@ -0,0 +1,18 @@
+# Time Complexity: O(n)
+# Space Complexity: O(n)
+
+class Solution:
+    def containsDuplicate(self, nums: List[int]) -> bool:
+        # set to keep track of duplicates.
+        duplicates = set()
+
+        # go through each number in the list
+        for num in nums:
+            # if it's a duplicate, return true.
+            if num in duplicates:
+                return True
+            # otherwise, add it to the set to check for duplicates.
+            duplicates.add(num)
+
+        # if finish the loop and don't find duplicates, return false.
+        return False

longest-consecutive-sequence/yolophg.py

@@ -0,0 +1,25 @@
+# Time Complexity: O(n)
+# Space Complexity: O(n)
+
+class Solution:
+    def longestConsecutive(self, nums: List[int]) -> int:
+        # convert list to set to remove duplicates and allow quick lookups
+        num_set = set(nums)
+        longest_streak = 0
+
+        # loop through each number in the set
+        for num in num_set:
+            # only start counting if it's the beginning of a sequence
+            if num - 1 not in num_set:
+                current_num = num
+                current_streak = 1
+
+                # keep counting while the next number in the sequence exists
+                while current_num + 1 in num_set:
+                    current_num += 1
+                    current_streak += 1
+
+                # update the longest streak found so far
+                longest_streak = max(longest_streak, current_streak)
+
+        return longest_streak

top-k-frequent-elements/yolophg.py

@@ -0,0 +1,16 @@
+# Time Complexity: O(n log n)
+# Space Complexity: O(n)
+
+class Solution:
+    def topKFrequent(self, nums: List[int], k: int) -> List[int]:
+        # count how many times each number appears
+        counts = {}
+        for num in nums:
+            counts[num] = counts.get(num, 0) + 1
+
+        # sort numbers by their count (most frequent first) and grab top k
+        # counts.get gets the count of num
+        # reverse=True sorts in descending order
+        # [:k] gets the first k elements
+        top_nums = sorted(counts, key=counts.get, reverse=True)
+        return top_nums[:k]

valid-palindrome/yolophg.py

@@ -0,0 +1,12 @@
+# Time Complexity: O(n)
+# Space Complexity: O(n)
+
+class Solution:
+    def isPalindrome(self, s: str) -> bool:
+        # clean up the string: remove non-alphanumeric chars and convert to lowercase
+        # isalnum() checks if the character is alphanumeric
+        filtered = ''.join(filter(str.isalnum, s)).lower()
+        
+        # check if it reads the same forwards and backwards
+        # filtered[::-1] flips the string
+        return filtered == filtered[::-1]