added array and hashing questions

Author: david-legend

leetcode/src/array/README.md renamed to leetcode/src/array&hashing/README.md

@@ -0,0 +1,39 @@
+# [LC 1. Two Sum - Easy](https://leetcode.com/problems/maximum-product-subarray/)
+
+Given an array of integers nums and an integer target, return indices of the two numbers such that they add up to target.
+
+You may assume that each input would have exactly one solution, and you may not use the same element twice.
+
+You can return the answer in any order.
+
+ 
+### Example 1
+```
+Input: nums = [2,7,11,15], target = 9
+Output: [0,1]
+Explanation: Because nums[0] + nums[1] == 9, we return [0, 1].
+```
+
+### Example 2
+```
+Input: nums = [3,2,4], target = 6
+Output: [1,2]
+```
+
+### Example 3
+```
+Input: nums = [3,3], target = 6
+Output: [0,1]
+```
+
+### Constraints:
+
+- 2 <= nums.length <= 104
+- -10^9 <= nums[i] <= 10^9
+- -10^9 <= target <= 10^9
+- Only one valid answer exists.
+
+
+<br>
+
+- Follow-up: Can you come up with an algorithm that is less than O(n2) time complexity?

leetcode/src/array/lc_152_max_product_subarray/README.md renamed to leetcode/src/array&hashing/lc_152_max_product_subarray/README.md

@@ -0,0 +1,15 @@
+def two_sum(nums, target):
+    num_idx = {}
+    for i in range(len(nums)):
+        diff = target - nums[i]
+        if diff in num_idx:
+            return [num_idx[diff], i]
+
+        num_idx[nums[i]] = i
+    
+    return []
+
+
+print(two_sum([2,7,11,15], 9))
+print(two_sum([3,2,4], 6))
+print(two_sum([3,3], 6))

leetcode/src/array/lc_152_max_product_subarray/max_product_brute_force.py renamed to leetcode/src/array&hashing/lc_152_max_product_subarray/max_product_brute_force.py

@@ -0,0 +1,27 @@
+# [LC 217. Contains Duplicate - Easy](https://leetcode.com/problems/contains-duplicate/description/)
+
+Given an integer array nums, return true if any value appears at least twice in the array, and return false if every element is distinct.
+
+ 
+### Example 1
+```
+Input: nums = [1,2,3,1]
+Output: true
+```
+
+### Example 2
+```
+Input: nums = [1,2,3,4]
+Output: false
+```
+
+### Example 3
+```
+Input: nums = [1,1,1,3,3,4,3,2,4,2]
+Output: true
+```
+
+### Constraints:
+
+- 1 <= nums.length <= 10^5
+- -10^9 <= nums[i] <= 10^9

leetcode/src/array/lc_152_max_product_subarray/max_product_subarray.py renamed to leetcode/src/array&hashing/lc_152_max_product_subarray/max_product_subarray.py

@@ -0,0 +1,23 @@
+
+# Time: O(n)
+# Space: O(n)
+def containsDuplicate(nums) -> bool:
+        hash_set = set()
+        for val in nums:
+            if val in hash_set:
+                return True
+            hash_set.add(val)
+        
+        return False
+
+
+# Time: O(n)
+# Space: O(n)
+def containsDuplicate2(nums) -> bool:
+        num_freq = {}
+        for val in nums:
+            if val in num_freq:
+                return True
+            num_freq[val] = 1
+        
+        return False

leetcode/src/array&hashing/lc_1_two_sum/README.md

@@ -0,0 +1,33 @@
+# [LC 238. Product of Array Except Self- Medium](https://leetcode.com/problems/product-of-array-except-self/description/)
+
+Given an integer array nums, return an array answer such that answer[i] is equal to the product of all the elements of nums except nums[i].
+
+The product of any prefix or suffix of nums is guaranteed to fit in a 32-bit integer.
+
+You must write an algorithm that runs in O(n) time and without using the division operation.
+
+### Example 1
+```
+Input: nums = [1,2,3,4]
+Output: [24,12,8,6]
+```
+
+### Example 2
+```
+Input: nums = [-1,1,0,-3,3]
+Output: [0,0,9,0,0]
+```
+
+
+### Constraints:
+
+- 2 <= nums.length <= 10^5
+- -30 <= nums[i] <= 30
+- The product of any prefix or suffix of nums is guaranteed to fit in a 32-bit integer.
+ 
+
+
+
+<br>
+
+Follow up: Can you solve the problem in O(1) extra space complexity? (The output array does not count as extra space for space complexity analysis.)

leetcode/src/array&hashing/lc_1_two_sum/two_sum.py

@@ -0,0 +1,13 @@
+def productExceptSelf(nums):
+    result = [1] * len(nums)
+    prefix = 1
+    for i in range(len(nums)):
+        result[i] = prefix
+        prefix *= nums[i]
+    
+    postfix = 1
+    for i in range(len(nums) - 1, -1, -1):
+        result[i] *= postfix
+        postfix *= nums[i]
+    
+    return result

leetcode/src/array&hashing/lc_217_contains_duplicate/README.md

@@ -0,0 +1,32 @@
+# [LC 242. Valid Anagram - Easy](https://leetcode.com/problems/valid-anagram/description/)
+
+Given two strings s and t, return true if t is an anagram of s, and false otherwise.
+
+An Anagram is a word or phrase formed by rearranging the letters of a different word or phrase, typically using all the original letters exactly once.
+
+### Example 1
+```
+Input: s = "anagram", t = "nagaram"
+Output: true
+```
+
+### Example 2
+```
+Input: s = "rat", t = "car"
+Output: false
+```
+
+### Example 3
+```
+Input: nums = [1,1,1,3,3,4,3,2,4,2]
+Output: true
+```
+
+### Constraints:
+
+- 1 <= s.length, t.length <= 5 * 10^4
+- s and t consist of lowercase English letters.
+
+<br>
+
+Follow up: What if the inputs contain Unicode characters? How would you adapt your solution to such a case?

leetcode/src/array&hashing/lc_217_contains_duplicate/contains_duplicate.py

@@ -0,0 +1,29 @@
+def isAnagram(s, t) -> bool:
+    if len(s) != len(t): return False
+    char_freq = {}
+
+    for i in range(len(s)):
+        st_1, st_2 = s[i], t[i]
+        char_freq[st_1] = char_freq.get(st_1, 0) + 1
+        char_freq[st_2] = char_freq.get(st_2, 0) - 1
+        
+        if st_2 in char_freq and char_freq.get(st_1, 0) == 0: 
+            del char_freq[st_1]
+        if st_2 in char_freq and char_freq[st_2] == 0: 
+            del char_freq[st_2]
+    
+    return True if len(char_freq) == 0 else False
+
+
+def isAnagram2(s, t) -> bool:
+    if len(s) != len(t): return False
+
+    char_count = {}
+    for i in range(len(s)):
+        char_count[s[i]] = char_count.get(s[i], 0) + 1
+        char_count[t[i]] = char_count.get(t[i], 0) - 1
+
+    for count in char_count.values():
+        if count != 0: return False
+
+    return True

leetcode/src/array&hashing/lc_238_product_of_array_except_itself/README.md

@@ -0,0 +1,26 @@
+# [LC 347. Top K Frequent Elements - Medium](https://leetcode.com/problems/top-k-frequent-elements/description/)
+
+Given an integer array nums and an integer k, return the k most frequent elements. You may return the answer in any order.
+
+### Example 1
+```
+Input: nums = [1,1,1,2,2,3], k = 2
+Output: [1,2]
+```
+
+### Example 2
+```
+Input: nums = [1], k = 1
+Output: [1]
+```
+
+### Constraints:
+
+- 1 <= nums.length <= 10^5
+- -10^4 <= nums[i] <= 10^4
+- k is in the range [1, the number of unique elements in the array].
+- It is guaranteed that the answer is unique.
+
+<br>
+
+Follow up: Your algorithm's time complexity must be better than O(n log n), where n is the array's size.

leetcode/src/array&hashing/lc_238_product_of_array_except_itself/product_of_array.py

@@ -0,0 +1,41 @@
+from heapq import *
+
+# Time: O(n)
+# Space: O(n)
+def topKFrequent(nums, k):
+    num_count = {}
+    freq_bucket = [[] for _ in range(len(nums) + 1)] 
+
+    for num in nums:
+        num_count[num] = num_count.get(num, 0) + 1
+
+    for num, count in num_count.items():
+        freq_bucket[count].append(num)
+    
+    result = []
+    for i in range(len(freq_bucket)-1, 0, -1):
+        for num in freq_bucket[i]:
+            result.append(num)
+            if len(result) == k:
+                return result
+
+
+
+# Time: O(n + n + nlog(n) + n) ----> O(n + nlog(n))
+# Space: O(n)
+def topKFrequent2(nums, k):
+    num_freq, max_heap = {}, []
+    for num in nums:
+        num_freq[num] = num_freq.get(num, 0) + 1
+    
+    for num, count in num_freq.items():
+        max_heap.append((-count, num))
+    
+    heapify(max_heap)
+    result = []
+    while max_heap and k > 0:
+        _, num = heappop(max_heap)
+        result.append(num)
+        k -= 1
+    
+    return result

leetcode/src/array&hashing/lc_242_valid_anagram/README.md

@@ -5,6 +5,38 @@ def __init__(self, val=0, next=None):
         self.next = next
 
 def reorderList(head) -> None:
+    if not head or not head.next: return
+
+    last_node_of_first_half, slow, fast = None, head, head
+    while fast and fast.next:
+        last_node_of_first_half = slow
+        slow, fast = slow.next, fast.next.next
+
+    last_node_of_first_half.next = None
+    first_half, second_half = head, reverse(slow)
+
+    while first_half and second_half:
+        first_half_next_node = first_half.next
+        second_half_next_node = second_half.next
+        first_half.next, second_half.next = second_half, first_half.next
+
+        if not first_half_next_node:
+            second_half.next = second_half_next_node
+
+        first_half, second_half = first_half_next_node, second_half_next_node
+
+
+def reverse(node):
+    prev, curr = None, node
+    while curr:
+        next_node = curr.next
+        curr.next = prev
+        prev, curr = curr, next_node
+    
+    return prev
+    
+
+def reorderList2(head) -> None:
     if not head and not head.next: return head
     slow = fast = head
     while fast and fast.next:
@@ -23,11 +55,3 @@ def reorderList(head) -> None:
     if head_of_first_half:
         head_of_first_half.next = None
 
-    def reverse(node):
-        prev, curr = None, node
-        while curr:
-            next_node = curr.next
-            curr.next = prev
-            prev, curr = curr, next_node
-        
-        return prev

leetcode/src/array&hashing/lc_242_valid_anagram/valid_anagram.py

@@ -6,18 +6,18 @@ def __init__(self, val=0, next=None):
 
 
 def addTwoNumbers(l1, l2):
-    sentinel = result = ListNode(0)
+    result_iter = result = ListNode(0)
     remainder = 0
     while l1 or l2 or remainder:
         l1_val = l1.val if l1 else 0
         l2_val = l2.val if l2 else 0
 
         curr_sum = l1_val + l2_val + remainder
-        sentinel.next = ListNode(curr_sum % 10)
+        result_iter.next = ListNode(curr_sum % 10)
         remainder = curr_sum // 10
 
         l1 = l1.next if l1 else None
         l2 = l2.next if l2 else None
-        sentinel = sentinel.next
+        result_iter = result_iter.next
 
     return result.next