The two-pointer pattern

Two pointers walk through an array with two indices instead of nested loops, turning many O(n^2) scans into O(n). The pattern comes in two flavors: pointers moving toward each other from both ends, and pointers moving in the same direction at different speeds.

• Converging (opposite ends): start left = 0, right = n-1, and move them inward based on a condition. Classic on sorted arrays.
• Fast/slow (same direction): one pointer scans ahead while another marks a boundary — used for in-place filtering and dedup.

Example: pair sum in a sorted array

Given a sorted array, find two numbers that add up to a target. Brute force checks every pair in O(n^2). With two pointers you exploit the sort: if the current sum is too small, the only way to grow it is to move left right; if too big, move right left.

def two_sum_sorted(a, target):
    left, right = 0, len(a) - 1
    while left < right:
        s = a[left] + a[right]
        if s == target:
            return [left, right]
        if s < target:
            left += 1      # need a bigger sum
        else:
            right -= 1     # need a smaller sum
    return []

The same idea extends to reversing in place, palindrome checks, merging two sorted arrays, and 3-sum (fix one element, two-point the rest).