Binary search is not about finding numbers

Searching for a boundary, not a value

Every intro course teaches binary search the same way: sorted array, target number, halve the range until you find it. Clean, simple, and — crucially — incomplete.

That framing handles maybe 20% of binary search problems. The other 80% involve no target number at all. They involve rotated arrays, mountain peaks, minimum shipping capacities, eating speeds. And engineers fail them not because they don't know the template, but because they haven't understood what binary search is really doing.

Imagine a hidden boolean array. Binary search doesn't care that it's "hidden" — it just halves the search space on each step until it pinpoints the boundary:

That's the whole game. The condition could be anything — "is this element less than the last element?", "can we ship all packages with this capacity?", "are we on the descending slope?" — but the shape of the answer is always that same row of F's followed by T's.

Try the classic version first

Before we get abstract, here's an interactive classic binary search. Pick a target and watch it find the boundary between "too small" and "found it":

Every binary search problem fits one of five shapes

Once you can identify which shape a problem is, you know which template to reach for. The condition differs — the structure doesn't.

The templates

Two templates handle patterns 2–4. Pick one and stick to it — mixing them causes infinite loops and off-by-one bugs.

// ── FIRST TRUE (AlgoMonster style) ──────────────────────────
int left = 0, right = n - 1, boundary = -1;

while (left <= right) {
    int mid = left + (right - left) / 2;

    if (condition(mid)) {
        boundary = mid;   // save — this might be the answer
        right = mid - 1; // but search left for an earlier one
    } else {
        left = mid + 1;  // definitely not here, go right
    }
}
return boundary;

// ── LAST TRUE ────────────────────────────────────────────────
int left = 0, right = n - 1, boundary = -1;

while (left <= right) {
    int mid = left + (right - left) / 2;

    if (condition(mid)) {
        boundary = mid;   // save — this might be the answer
        left = mid + 1;  // but search right for a later one
    } else {
        right = mid - 1;
    }
}
return boundary;

The skill that unlocks every problem

Converting a problem into an F/T boolean array is the hardest skill to teach and the most valuable to have. Once you can look at a problem and immediately visualise the underlying boolean pattern, the algorithm becomes mechanical.

Here's the conversion for four classic problems. Notice the pattern is always the same — only the condition changes:

The three-question test

When you read a problem, run through this mentally:

Search in Rotated Sorted Array — the variant everyone struggles with

LC 153 (find minimum in rotated array) maps cleanly to First True. LC 33 (search for a target in a rotated array) is slightly different — you're not finding a boundary, you're exploiting the invariant that one half is always sorted.

At any mid, either the left half or the right half is guaranteed sorted. You check which half is sorted, then check whether the target lives inside that sorted half. If yes, go there. If no, go to the other half.

int left = 0, right = nums.length - 1;

while (left <= right) {
    int mid = left + (right - left) / 2;

    if (nums[mid] == target) return mid;

    // Determine which half is sorted
    if (nums[left] <= nums[mid]) {
        // Left half is sorted
        if (target >= nums[left] && target < nums[mid])
            right = mid - 1; // target is in left half
        else
            left = mid + 1;  // target must be in right half
    } else {
        // Right half is sorted
        if (target > nums[mid] && target <= nums[right])
            left = mid + 1;  // target is in right half
        else
            right = mid - 1; // target must be in left half
    }
}
return -1;

The mental model: think of the rotated array as two sorted segments stuck together. At each step you figure out which segment your mid is in, and whether the target is inside the sorted range you can see. You discard the half that can't contain the target.

The pattern map — 25 problems, 5 patterns

Every binary search problem on LeetCode fits one of the five patterns. Here's the full map. Sort by pattern, find the problem, know the approach.

The 6-problem learning path

If you want to master binary search in the shortest time, do these six problems in order. They cover every pattern and build on each other:

One sentence that covers everything

The number-in-sorted-array case is just the simplest version of this. Once you've internalised the boundary-finding frame, you'll start seeing binary search opportunities everywhere — in problems that never mention arrays at all.

The engineers who solve these problems in interviews in under ten minutes are not smarter. They've just seen the F→T pattern enough times that converting a new problem takes seconds, not minutes. Build that pattern recognition through deliberate practice on the six problems above, and the rest follows.