arrays

A classic that pays off the two-pointer insight over brute force. Interviewers look for realizing that water at each position is capped by the min of the max walls on each side, then computing it in a single pass. The answer follows.

The textbook warm-up that tests for the hash-map instinct: swap space for time to turn O(n squared) into O(n). Interviewers look for the one-pass complement lookup. The pattern follows.

Maximum subarray is the entry-point 1D DP problem, and Kadane's is the O(n) one-liner. What interviewers watch for: the 'extend or restart' call at each element and the all-negative edge case most people fumble. Here is the answer.

Rotating a matrix in place probes index manipulation and the transpose-then-reverse trick. What interviewers watch for: splitting the rotation into two simple passes instead of juggling four-way swaps. Here is the answer.

Gas Station pays off spotting a greedy invariant that turns O(n²) into O(n). Two facts carry the whole solution: total feasibility, and that a failed prefix lets you skip every start within it.

Jump Game pays off spotting that a greedy reachability scan beats DP. Interviewers look for tracking the farthest reachable index in one pass, and catching the exact moment you fall behind it.

This problem outlaws the obvious division trick, forcing the prefix/suffix-product insight. Interviewers look for computing left and right products in two passes with O(1) extra space. The answer follows.

Sorting an array of three values in one pass probes the three-pointer partition (Dutch National Flag). Interviewers look for the low/mid/high invariant and knowing when not to advance mid. The answer follows.

Spiral traversal probes careful boundary management more than algorithmic insight. Interviewers look for shrinking four boundaries layer by layer without double-visiting a row or column. The answer follows.

This notoriously hard problem demands better than the O(m+n) merge: an O(log) binary search on the partition. Interviewers look for binary-searching the split point so the left halves stay below the right halves. The answer follows.

Computing the max of each size-k window the obvious way costs O(n*k). The move that cuts it to O(n) is a monotonic deque of indices, and why it stays linear catches most candidates off guard.

Finding the longest run of consecutive integers without sorting divides candidates who reach for O(n log n) from those who spot the hash-set trick. The signal is one loop invariant that eliminates redundant work. Here is the answer.

The brute force runs O(n squared) nested scans. A monotonic stack solves it in one O(n) pass by holding only the candidates that can still become a future answer. Here is the pattern and why each element is pushed and popped exactly once.

The naive triple loop runs O(n cubed). Sort first, then fix one element and converge two pointers for O(n squared). The real test is deduplication: returning unique triplets without a set. Here is the clean template.

Testing every subarray costs O(n squared). Prefix sums with a remainder-frequency map solve it in a single O(n) pass: two prefixes sharing a remainder mod k enclose a divisible subarray. The pitfall is negative remainders. Here is the clean answer.