How do you find two numbers that add up to a target?

LET'S MAKE IT SIMPLE

First, the idea in plain English

A slow approach checks every possible pair, which repeats work as the list grows. Instead, while looking at a number, ask what other number would complete the target and whether you have already seen it. A dictionary makes that lookup fast on average. You store indices so the answer can refer to the original positions, and check before adding the current value so one element is not used twice.

FOLLOW THE JOURNEY

Remember seen values to avoid checking every pair

Trace the complement lookup that reduces pair search from quadratic to linear expected time.

How to read this visual
Checking before storing prevents the current array position from pairing with itself. A dictionary assignment can overwrite duplicate values, so consider the contract if all pairs are required.

UNDER THE HOOD

How it works, step by step

OUTSIDE THE TEXTBOOK

A practical example

GO A LITTLE DEEPER

Technical details that matter

• A brute-force solution checks all pairs in O(n²) time and O(1) extra space; the dictionary trades memory for expected linear time.
• If the input is sorted and only values are required, two pointers can use O(1) extra space after sorting, though sorting costs O(n log n) and changes index handling.
• For duplicate values, checking before insertion allows a pair such as target 6 from [3, 3].
• Python dictionaries use hashing; O(1) lookup is expected, not a strict worst-case guarantee for every possible key distribution.

def two_sum(numbers: list[int], target: int) -> tuple[int, int] | None:
    seen: dict[int, int] = {}

    for index, value in enumerate(numbers):
        complement = target - value
        if complement in seen:
            return seen[complement], index
        seen[value] = index

    return None

MAKE A GOOD CHOICE

When is this useful?

• Finding pairs that meet a target in a single-pass data stream.
• Recognizing when a hash map can replace repeated nested-loop searches.
• Practicing how to explain a brute-force baseline and a time-space optimization.

WATCH OUT FOR

Common misunderstandings

• Returning values when the problem specifically asks for indices.
• Adding the current value before checking and accidentally using one element twice.
• Claiming worst-case O(1) hash lookup without qualification.

REAL-WORLD TRADE-OFFS

Limitations and failure cases

• The dictionary requires O(n) additional memory.
• The first pair found may not be the only pair; output requirements can change the solution.
• If input values are not hashable or arrive under a different constraint, the approach must change.

WHAT TO REMEMBER

Key takeaways

1. 1Use target minus current value to find the required complement.
2. 2Store previously seen values and their indices in a dictionary.
3. 3Check before storing to avoid reusing one array position.
4. 4Explain expected O(n) time and O(n) space.

PRACTICE THE FOLLOW-UP

What might an interviewer ask next?