Data Structures & Algorithms

Why contiguity is the whole advantage, and what it costs when you insert in the middle.

Trying every possibility without trying every possibility — how one rejection prunes a whole branch.

Why halving beats scanning, and the one sentence that has to stay true for the loop to be correct.

What integers actually look like in memory, and the handful of tricks worth memorising.

Plant as early as possible — and the function that quietly rewrites its caller's garden.

A three-line problem that is really about Go slices — capacity, copying, and who owns the array.

The first problem where a set beats a nested loop — and what Go uses for a set.

Recursion that stops repeating itself — and how to find the state that makes it work.

Four algorithms, and the one property of your graph that decides which of them is allowed.

Take the best option in front of you — and the proof you owe before you are allowed to.

A canonical key turns grouping into one map insert — and Go lets the key be an array.

Why average O(1) is a statement about spread, and what happens when the spread fails.

A tree hidden inside an array, and why knowing less is cheaper than knowing everything.

Two pointers that only move forward — and the byte-versus-rune slip that crashes it.

A consistent one-to-one substitution — and why checking one direction is not enough.

Two lines with the standard library, or one backwards scan — and why the trailing space is the whole problem.

Pointer surgery without losing the list, and the dummy node that removes every edge case.

Compare down the columns, not along the words — and stop at the first disagreement.

Boyer-Moore voting — constant space, and only correct because the problem promises something.

Grids are graphs with invisible edges — and the direction array that keeps the code honest.

Divide until trivial, then merge — and why the recursion tree gives you the running time for free.

Sort by start, sweep once — and the off-by-one that decides whether touching ranges count.

How a monotonic stack turns a quadratic scan into one pass, and why the stack can never stop being decreasing.

Each row from the one above it — the smallest dynamic programming table there is.

Removing in place without shifting — one boundary, one pass, and what the return value really is.

Walk backwards and the quadratic scan disappears — the smallest suffix-aggregate problem.

Why the window never moves backwards, and how that turns a quadratic scan linear.

Two rules for "what next", and why the choice changes which order you explore.

Four orders, one recursion, and what each one is actually for.

Paying per character instead of per string, and when that trade is worth it.

One pass instead of two loops, and the ordering property that makes discarding safe.

Store what you need, not what you have — the inversion that makes one pass enough.

Keeping track of who is connected to whom, and the two one-line tricks that make it nearly free.

Normalise, then count the set — and the one part of the address you must not touch.

One tally instead of two — and the Unicode bug hiding in the obvious Go solution.