Two Sum

Brute force — check every pair

Fix the first index i, then scan every later index j asking whether nums[i] + nums[j] == target. The inner scan starts at i + 1, so no pair is checked twice and no element pairs with itself.

def two_sum(nums: list[int], target: int) -> list[int]:
    n = len(nums)
    for i in range(n - 1):
        for j in range(i + 1, n):
            if nums[i] + nums[j] == target:
                return [i, j]
    return []  # unreachable: exactly one solution is guaranteed

Time O(n²) — about n²/2 pair-checks; at n = 10,000 that's ~50 million, which is why the big hidden tests refuse this one in the slower languages. Space O(1).

One-pass hash map — remember what you've seen

The brute force keeps re-answering the same question by re-scanning: "is the partner of nums[i] somewhere in the array?" Flip the direction: as you walk the array once, record every value you've passed in a map from value → index. Before recording nums[i], ask the map whether its partner target - nums[i] was already seen.

def two_sum(nums: list[int], target: int) -> list[int]:
    seen: dict[int, int] = {}
    for i, x in enumerate(nums):
        partner = target - x
        if partner in seen:
            return [seen[partner], i]
        seen[x] = i
    return []  # unreachable

Look up before you insert: that ordering is the whole correctness argument. It makes pairing an index with itself impossible, and duplicate values just work — when the second 3 of [3, 3] arrives, the first is already in the map.

Time O(n) — one pass, O(1) expected per lookup. Space O(n) for the map.

That single trade — a map's worth of memory for a linear scan — is the founding move of the whole Arrays & Hashing pattern. You'll spend it again and again.