Understanding the problem

You are handed a sorted list of prices and asked, repeatedly, whether two of them add up to a given budget. It sounds like a lookup. The first solution almost everyone writes is to try every pair:

for i in range(n):
    for j in range(i + 1, n):
        if a[i] + a[j] == target:
            return (i, j)

for (int i = 0; i < n; ++i)
    for (int j = i + 1; j < n; ++j)
        if (a[i] + a[j] == target)
            return {i, j};

for (int i = 0; i < n; i++)
    for (int j = i + 1; j < n; j++)
        if (a[i] + a[j] == target)
            return new int[] {i, j};

for (let i = 0; i < n; i++)
    for (let j = i + 1; j < n; j++)
        if (a[i] + a[j] === target)
            return [i, j];

for i in 0..n {
    for j in i + 1..n {
        if a[i] + a[j] == target {
            return Some((i, j));
        }
    }
}

pairSum :: Int -> [Int] -> Maybe (Int, Int)
pairSum target a = listToMaybe [ (i, j) | (i, x) <- ixs, (j, y) <- ixs, i < j, x + y == target ]
  where ixs = zip [0 ..] a

That is correct, and on the ten-element example in the question it returns instantly. The interviewer then says the array holds a hundred thousand prices and the service answers a thousand queries a second, and the solution falls apart.

There are n(n−1)/2 pairs. The table is worth holding in your head, because it is the reason interviewers keep asking this question.

Each time the input grows tenfold, the work grows a hundredfold. No faster machine fixes that; the shape of the algorithm has to change.

Look again at the input: the array is sorted. The brute force never uses that. It compares 2 with 15 as eagerly as it compares 7 with 11, even though the ordering already tells you a great deal about which pairs are worth looking at.

That is the real lesson, and it generalises far beyond this question: when a question hands you a property you are not using, that property is usually the solution. Sorted input, a fixed alphabet, values bounded by 100, "each element appears at most twice" — every one of those is a hint, not decoration.

The brute force asks "is this pair the answer?" — a question about one pair, repeated n²/2 times. The scan above asks "can this value be in any answer?" — a question about one value, repeated n times. That shift, from testing candidates to eliminating them, is what the two-pointer pattern is.

If you can argue that one comparison rules a value out for ever, you can usually walk the array once instead of squaring it.