Letting the comparison steer you

On sorted input, the current value tells you which pointer to move. That is the entire technique.

Why it works

The steering rule

Compare the current sum to the target. Too small means the only useful move is to increase it, so advance left. Too large means decrease it, so retreat right. Equal means you are done.

The move is forced. There is never a choice about which pointer to move, which is what makes this pattern feel mechanical once you have seen it.

1def closest_pair_sum(sorted_values, target):2    """Return the pair sum closest to target."""3    left, right = 0, len(sorted_values) - 14    best = sorted_values[left] + sorted_values[right]5 6    while left < right:7        total = sorted_values[left] + sorted_values[right]8        if abs(total - target) < abs(best - target):9            best = total10        if total < target:11            left += 1                 # only way to get a bigger sum12        elif total > target:13            right -= 1                # only way to get a smaller sum14        else:15            return total16    return best17 18print(closest_pair_sum([1, 3, 6, 10], 8))19print(closest_pair_sum([1, 3, 6, 10], 100))

Trace it· 8 min

Trace the steering

Run the two-pointer search on the sorted list [2, 4, 7, 11, 15] looking for a pair summing to 18. For each step give the sum of the two ends and which pointer moves next. Write the move as left, right, or done.

step	left value	right value
1	2	15
2	4	15
3	4	11
4	7	11

Quick check· 5 min

Why is the discard safe?

In the sorted two-pointer search, the sum at left and right is smaller than the target, so you advance left. What justifies never reconsidering the old left value?

Because the list is sorted, so the old left value is the smallest and small values are never part of an answerBecause pairing the old left with right already gave it the largest sum it could ever reach, and that was still too smallBecause each value may only be used once, so the old left is now spentIt is not strictly safe, but the error is rare enough to ignore

Problem· 15 min

Two Sum Ii Input Array Is Sorted

Read the constraints first and let them tell you what complexity is expected. Derive the approach, implement it, run the tests, and submit when it passes.

1def closest_pair_sum(sorted_values, target):2 """Return the pair sum closest to target."""3 left, right = 0, len(sorted_values) - 14 best = sorted_values[left] + sorted_values[right]5 6 while left < right:7 total = sorted_values[left] + sorted_values[right]8 if abs(total - target) < abs(best - target):9 best = total10 if total < target:11 left += 1 # only way to get a bigger sum12 elif total > target:13 right -= 1 # only way to get a smaller sum14 else:15 return total16 return best17 18print(closest_pair_sum([1, 3, 6, 10], 8))19print(closest_pair_sum([1, 3, 6, 10], 100))

step

left value

right value

sum

move