Every interview problem can be solved with the same 5-step process. The steps take 2–3 minutes of thinking before you write a single line of code — and they prevent the most common interview failure: jumping into code without a plan.

Read the problem statement. Look for these signals. Each signal maps to exactly one pattern (or a small set of candidates). This table covers every common interview pattern — the ones with dedicated pages and the ones covered below.

Build an auxiliary array where prefix[i] = sum of elements from index 0 to i-1. Any subarray sum arr[l..r] becomes prefix[r+1] - prefix[l] in O(1). This transforms range sum queries from O(n) per query to O(1) per query after O(n) preprocessing. Combined with a HashMap, it solves "subarray sum equals k" (LC 560) in O(n).

• Easy prefix Running Sum of 1D Array — LC 1480 — Pure prefix sum construction.
• Medium prefix+hash Subarray Sum Equals K — LC 560 — Prefix sum + HashMap: count prefixes where prefix - k was seen before.
• Medium prefix Product of Array Except Self — LC 238 — Prefix product from left × suffix product from right.

A stack that maintains a monotonic order (always increasing or always decreasing from bottom to top). When pushing an element, pop all elements that violate the monotonic property — the popped elements have just found their "next greater" or "next smaller" element. This solves "next greater element" (LC 496/503), "daily temperatures" (LC 739), and "largest rectangle in histogram" (LC 84) in O(n).

• Easy mono-stack Next Greater Element I — LC 496 — Decreasing stack on the second array + HashMap for lookup.
• Medium mono-stack Daily Temperatures — LC 739 — Decreasing stack of indices. When popped, distance = i - popped index.
• Hard mono-stack Largest Rectangle in Histogram — LC 84 — Increasing stack. When popped, compute area with popped height × (right boundary - left boundary).

Union-Find maintains a collection of disjoint sets supporting two operations: find(x) — which set does x belong to? and union(x, y) — merge the sets containing x and y. With path compression and union by rank, both operations run in amortised O(α(n)) ≈ O(1). Union-Find is the tool for dynamic connectivity — when edges are added incrementally and you need to check "are x and y in the same component?"

• Medium union-find Number of Provinces — LC 547 — Union all friends. Component count = number of provinces.
• Medium union-find Redundant Connection — LC 684 — Process edges in order. First edge where union returns false (already connected) = the redundant edge.
• Medium union-find Accounts Merge — LC 721 — Union emails by account. Group by root to merge accounts.

Bit manipulation uses bitwise operators (&, |, ^, ~, <<, >>) to solve problems in O(1) space and often O(n) or O(1) time. The key insight: XOR (^) cancels identical values — a ^ a = 0 and a ^ 0 = a. This is why "find the single number" (LC 136) is solvable by XORing all elements. Other common tricks: n & (n-1) removes the lowest set bit (useful for counting bits), and n & (-n) isolates the lowest set bit.

• Easy bits Single Number — LC 136 — XOR all elements. Pairs cancel to 0, leaving the unique one.
• Easy bits Number of 1 Bits — LC 191 — n & (n-1) loop, count iterations. Or use Integer.bitCount(n).
• Medium bits Counting Bits — LC 338 — dp[i] = dp[i & (i-1)] + 1 — remove lowest bit, add one.
• Medium bits Single Number III — LC 260 — XOR all to get a^b. Use lowest differing bit to split into two groups, XOR each group.

Interval problems involve ranges [start, end]. Almost all of them start with the same step: sort by start time (or end time for scheduling). Then sweep left to right, merging overlapping intervals, counting conflicts, or inserting new intervals. The mental model: intervals on a number line, sorted so you process them left to right.

• Medium intervals Merge Intervals — LC 56 — Sort by start. Merge if current.start ≤ prev.end.
• Medium intervals Insert Interval — LC 57 — Find insertion point, merge overlapping, collect non-overlapping.
• Medium intervals Meeting Rooms II — LC 253 — Min-heap of end times. For each meeting, if it starts after the earliest end, reuse that room; else add a new room.

If you solve 50 well-chosen problems — 3–5 per pattern — you'll recognise every interview pattern. Quality over quantity: understand WHY a pattern applies, not just HOW to code it. Here's a curated order that builds each pattern on the previous: