The classic two-pointer template starts pointers at the extremes and moves them inward based on the comparison. Because the array is sorted, increasing lo strictly increases the sum and decreasing hi strictly decreases it, so each move makes monotonic progress toward the target. The total runtime is O(n) because each pointer can move at most n steps. Reach for this whenever the input is sorted and the answer involves a pair (sum, difference, product) compared against a target.

When both pointers move forward, the pattern becomes 'fast read, slow write'. The fast pointer scans every element once; the slow pointer only advances when a write actually happens. The result is an in-place compaction in O(n) time and O(1) extra space, which is what the LeetCode 'remove duplicates from sorted array' family expects. The same shape applies to 'move zeros to the end', 'remove all instances of a value', and 'partition by predicate': only the equality check inside the if changes.

3-sum reduces to a fixed outer index plus a two-pointer inner loop on the remaining sorted suffix. Sorting first costs O(n log n), and the inner sweep is O(n), so the total is O(n^2): better than the O(n^3) brute force. The duplicate-skip lines are the trickiest part: skip the outer index when it repeats a previous value, and skip both inner pointers after a hit so the same triplet does not get reported twice. The same outer-fix-plus-inner-two-pointer pattern handles 4-sum and the 'closest 3-sum' variants.