arrays

A classic that rewards the two-pointer insight over brute force. The signal is realizing water at each position is bounded by the min of the max walls on each side, then computing it in one pass. Here is the answer.

The canonical warm-up that screens for the hash-map instinct: trade space for time to turn O(n squared) into O(n). The signal is the one-pass complement lookup. Here is the pattern.

Maximum subarray is the gateway 1D DP problem, and Kadane's is the O(n) one-liner. The signal is the 'extend or restart' decision at each element and the all-negative edge case most people botch. Here is the answer.

Rotating a matrix in place tests index manipulation and the transpose-then-reverse trick. The signal is decomposing the rotation into two simple passes rather than juggling four-way swaps. Here is the answer.

Gas Station rewards 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 inside it.

Jump Game rewards spotting that a greedy reachability scan beats DP. The signal is tracking the farthest reachable index in one pass, and detecting the exact moment you fall behind it.

This problem bans the obvious division trick, forcing the prefix/suffix-product insight. The signal is computing left and right products in two passes with O(1) extra space. Here is the answer.

Sorting an array of three values in one pass tests the three-pointer partition (Dutch National Flag). The signal is the low/mid/high invariant and knowing when not to advance mid. Here is the answer.

Spiral traversal tests careful boundary management more than algorithmic insight. The signal is shrinking four boundaries layer by layer without double-visiting a row or column. Here is the answer.

This famously-hard problem wants better than the O(m+n) merge: an O(log) binary search on the partition. The signal is binary-searching the split point so the left halves stay below the right halves. Here is the answer.

Finding the max of every window of size k naively is O(n*k). The trick that drops it to O(n) is a monotonic deque of indices, and the reason it stays linear surprises most candidates.

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

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

The naive triple loop is 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.

Checking every subarray is O(n squared). Prefix sums plus a remainder-frequency map does it in one O(n) pass: two prefixes with the same remainder mod k bracket a divisible subarray. The trap is negative remainders. Here is the clean answer.