Two Sum

Why is a hash table preferred over a two-pointer technique for the "Two Sum" problem?

- A two-pointer approach requires the array to be sorted, which takes O(n log n) time. - Using a hash table allows you to find the solution in one pass O(n) by storing and looking up the complement of each number, making it more efficient.

What would you change if the input array could contain multiple valid pairs for the "Two Sum" problem?

If multiple pairs are possible, instead of returning immediately upon finding one, store all valid pairs in a list and return that list. Adapt the code to keep searching for other pairs after finding one.

What is the goal of the "Two Sum" problem?

The goal is to find two indices in an array nums such that the values at those indices add up to a given target. Return the indices as [index1, index2]. Each input will have exactly one solution, and you cannot use the same element twice.

What makes a hash table efficient for the "Two Sum" problem?

The hash table allows for constant time O(1) lookups and insertions, enabling quick checks for the complement of each number, which helps find the solution in one pass through the array.

What are the time and space complexities of the hash table approach for the "Two Sum" problem?

Time Complexity: O(n), where n is the length of the array, since each element is processed once. Space Complexity: O(n), because the hash table can store up to n elements.

What is a code implementation of the "Two Sum" problem using a hash table?

var twoSum = function(nums, target) { // To store the value and index const map = {}; for(let i = 0; i < nums.length; i++){ let complement = target - nums[i] // Check if the complement exists in the map if(map[complement] !== undefined){ return [map[complement], i] } // Otherwise, store the current number and its index map[nums[i]]= i } };

How can you use a hash table (object) to solve the "Two Sum" problem?

1. Iterate through the array, keeping track of each number's index. 2. For each number, calculate the difference needed to reach the target (i.e., target - nums[i]). 3. Check if this difference is already in the hash table. - If it is, return the current index and the index of the difference. - Otherwise, add the current number and its index to the hash table.

What are some edge cases to consider when solving the "Two Sum" problem?

1. Negative numbers: Make sure the solution works when the array has negative numbers. 2. Duplicates: Ensure the function does not return the same index twice. 3. Small arrays: Handle small arrays (length 2 or less) correctly.

How would the hash table approach solve nums = [2, 7, 11, 15], target = 9?

Step 1: numMap = {}, nums[0] = 2, complement = 7. Store 2 in numMap.numMap = {2: 0} Step 2: nums[1] = 7, complement = 2. 2 exists in numMap at index 0.Return [0, 1] because nums[0] + nums[1] = 9.