add solutions for contains duplicate, two sum, valid anagram

Author: JoyJaewon

contains-duplicate/JoyJaewon.py

@@ -0,0 +1,30 @@
+'''
+Brainstrom
+- brute force: double for-loop (O^2)
+- efficient approach: use set O(N)
+
+Plan
+1. Initialize the set
+2. Iterate over the array
+    2-1. For each element, check if it's in the set. If it is, return True
+    2-2. If not, add the num to the set
+3. Return False since no duplicates are found
+'''
+
+def containsDuplicate(nums):
+    num_set=set()
+    for num in nums:
+        if num in num_set:
+            return True
+        num_set.add(num)
+    return False
+
+#TC: O(N), SC: O(N)
+
+#Normal case
+print(containsDuplicate([1, 2, 3, 1]) == True)
+print(containsDuplicate([1, 2, 3, 4]) == False)
+
+#Edge case
+print(containsDuplicate([1]) == False)
+print(containsDuplicate([]) == False) 

two-sum/JoyJaewon.py

@@ -0,0 +1,32 @@
+'''
+Brainstorm
+- Brute force: double for-loop / recursion - O(N^2)
+- Two Pointer: O(nlogn) - sorting
+- Efficient approach: use hashmap to go through the array once O(N)
+
+Plan
+1. Initialize the dictionary
+2. Iterate over the array
+    2-1. For each number, calculate the complement
+    2-2. check if the complement exists in the dictionary
+        2-3. Return the indices if it exists
+    2-4. If not, add the current number and its index to the dictionary
+'''
+
+def twoSum(nums, target):
+    memo = {}  
+    for i in range(len(nums)):
+        diff = target - nums[i]
+        if diff in memo:           
+            return [memo[diff], i]
+        memo[nums[i]] = i 
+
+#TC:O(N), SC:O(N)
+
+#Normal case
+print(twoSum([2, 7, 11, 15], 9) == [0, 1])
+print(twoSum([3, 2, 4], 6) == [1, 2])
+
+#Edge case
+print(twoSum([1, 2], 3) == [0, 1])
+print(twoSum([1, 5, 10], 20) == None) 

valid-anagram/JoyJaewon.py

@@ -0,0 +1,43 @@
+'''
+Brainstorm
+- brute force: double for-loop O(N^2)
+- efficient: use hash map O(N)
+
+plan
+1. check the string lengths. Return false if different
+2. Initialize the dictionary
+3. Check the dictionary
+    3-1. If all counts are zero, strings are anagrams. Return True
+    3-2. If not, return False
+'''
+def isAnagram(s, t):
+    if len(s) != len(t):
+        return False
+    
+    count = {}
+    for char in s:
+        if char in count:
+            count[char] += 1
+        else:
+            count[char] = 1
+    
+    for char in t:
+        if char in count:
+            count[char] -= 1
+            if count[char] < 0:
+                return False
+        else:
+            return False
+    
+    return all(x == 0 for x in count.values())
+
+#TC: O(N), SC: O(N) 
+
+#Normal case
+print(isAnagram("anagram", "nagaram") == True) 
+print(isAnagram("rat", "car") == False) 
+
+#Edge case
+print(isAnagram("", "") == True) 
+
+