Two Sum

easyFREEArrays & HashingBlind 75

Given an array of integers and a target, return the indices of the two numbers that add up to the target.

Assume exactly one solution exists. Return the two indices as a list [i, j] with i < j; the tests print them space-separated (e.g. 0 1).

Example

Input

2,7,11,15
9

Output

0 1

Reasoning

nums is the list of integers $[2, 7, 11, 15]$ and target is the single integer $9$ . Positions count from $0$ : $2$ sits at index $0$ , $7$ at $1$ , $11$ at $2$ and $15$ at $3$ .
We need two different positions $i < j$ with $\text{nums}_i + \text{nums}_j = 9$ . Pairing the first element with each of the others gives $2 + 7 = 9$ , $2 + 11 = 13$ and $2 + 15 = 17$ , so only the pair at positions $0$ and $1$ hits the target.
The remaining pairs all overshoot: $7 + 11 = 18$ , $7 + 15 = 22$ , $11 + 15 = 26$ . So $(0, 1)$ is the single answer the constraints promise.
The output is the two indices, not the values $2$ and $7$ . With the smaller index first they print as 0 1.
Notice that one position can't be used twice, but equal values at different positions are fine: for $[3, 3]$ with target $6$ the answer is 0 1, because the two $3$ s are separate elements.

Constraints

2 <= len(nums) <= 10^4
-10^9 <= nums[i] <= 10^9
Exactly one valid answer exists

More from Blind 75

Alien Dictionaryhard Clone Graphmedium Combination Summedium Word Search IIhard Merge K Sorted Listshard

Concept primer

Background Knowledge

The "Two Sum" problem is a classic example of a problem that can be solved using hash maps. A hash map is a data structure that stores key-value pairs in a way that allows for efficient lookup, insertion, and deletion of elements. In the context of this problem, we can use a hash map to store the numbers in the array as keys and their indices as values. This allows us to quickly look up the index of a number in the array.

The problem also involves the concept of array indexing, where we need to return the indices of the two numbers that add up to the target. This requires us to keep track of the indices of the numbers as we iterate through the array. Additionally, the problem assumes that exactly one solution exists, which means that we can stop searching as soon as we find a pair of numbers that add up to the target.

The "Two Sum" problem is often used to introduce the concept of trade-offs in algorithm design. In this case, we can trade off time complexity for space complexity by using a hash map to store the numbers and their indices. This allows us to solve the problem in linear time, but it requires us to use extra space to store the hash map.

Algorithm/Approach

The general approach to solving this type of problem is to use a single pass through the array, where we iterate through the numbers and use a hash map to keep track of the numbers we have seen so far and their indices. We can use the hash map to look up the index of a number in constant time, which allows us to solve the problem in linear time.

Step-by-Step Strategy

To solve this problem, we can follow these steps:

Create an empty hash map to store the numbers and their indices.
Iterate through the array, and for each number, calculate the complement (i.e., the target minus the current number).
Check if the complement is in the hash map. If it is, return the indices of the current number and its complement.
If the complement is not in the hash map, add the current number and its index to the hash map.
Repeat the process until we find a pair of numbers that add up to the target.

Common Pitfalls

Some common pitfalls to watch out for when implementing this solution include:

Forgetting to handle the case where the two numbers are the same (i.e., the target is twice the number).
Using a data structure that is not suitable for the problem, such as a sorted array or a linked list.
Not checking if the complement is in the hash map before adding the current number to the hash map.

Time & Space Complexity

The expected time complexity of this solution is $O(n)$ , where $n$ is the length of the array, since we only need to make a single pass through the array. The expected space complexity is also $O(n)$ , since in the worst case, we need to store all the numbers in the hash map.

solution.py

Python 3.13

Test results