Problem

Link to the LeetCode Problem: https://leetcode.com/problems/two-sum/.

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 <= 10^4

• -10^9 <= nums[i] <= 10^9

• -10^9 <= target <= 10^9

• Only one valid answer exists.

---

Solution

For every number (say x) in nums, we want to be able to tell if there is another number in the list so that they add up to target. In other words, we want to tell if target - x is also in the list. And if so, we also want to know its index. Therefore, we will use a dict to store the index of every number we've already checked mapped to the number itself. This will make it easy to check if a certain number is already in the dict.

So, we iterate through the numbers and do two things:

• check whether target - x is already in the dict and if it is, then we've found our two numbers, else

• insert the current number (x) with its index to the dict.

def twoSum(self, nums: List[int], target: int) -> List[int]:
    indices = {}

    for i, x in enumerate(nums):
        if target - x in indices:
            return [i, indices[target-x]]

        indices[x] = i

Space complexity

We use a dict to store every value of nums, which takes 𝒪(n) space where we define that n = nums.length.

Time complexity

We iterate at most n times and perform a lookup and an insert every time, both being in the 𝒪(1) complexity. That is 𝒪(n) * 𝒪(1) or simply 𝒪(n).