Algorithms are transitions. Watch the transitions.

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.

Telling a fast producer to slow down — and what happens to latency when you do not.

"Definitely not there" for a few bits per item — and why the other answer is only a maybe.

Where the copy lives, who writes it, and the two hard problems underneath.

The choice you only make during a partition — and the one you make the rest of the time.

The speed of light is the constraint — and the only fix is to already be there.

Getting a majority to agree on one value — and the two rules that make it safe.

Why adding a shard should move 1/n of the keys and not all of them.

Why a B-tree and not a hash map — and the column order that decides whether your index is used at all.

Store what happened, derive the current state — and the migration problem you inherit.

Making retries safe — because in a distributed system the client cannot tell failure from a lost reply.

Picking one node to be in charge — and the fencing token that makes it actually safe.

Spreading requests across servers — and why counting them is not the same as spreading work.

Decoupling producers from consumers — and the delivery guarantee you actually get.

Asking questions you did not plan for — and why averaging latency hides the outage.

Four algorithms, and the boundary bug that makes the simplest one allow double.

Copies for durability and read capacity — and the lag that makes users see their own writes disappear.

Splitting data across machines — and the key choice you cannot easily take back.

Write the intention before the change — and get durability, replication and time travel from one idea.

One owner per piece of state, reachable only by message — and what that buys you across a network.

The part you cannot parallelise sets a ceiling — and it is lower than you think.

Indivisible operations in hardware — and the loop that turns one into any update you like.

Waiting for a state, not a lock — and why the check has to be a while loop.

Don't communicate by sharing memory; share memory by communicating.

Four conditions, all required — so breaking any one of them is a complete fix.

One thread, no blocking — and the queue ordering that decides what actually runs next.

Two threads with no shared variable, made slow by sharing 64 bytes.

The relation that decides what one thread is allowed to see of another.

Progress guarantees, and the memory-reclamation problem that makes them hard.

What the hardware and the compiler are allowed to reorder — and why x86 lets bad code pass.

One holder at a time — and why the lost update happens on the line you thought was atomic.

Readers pay nothing at all — and the writer waits for them to leave before freeing anything.

A counter with a queue attached — and why it is not a mutex with extra steps.

Tasks that cannot outlive the block that started them — goto, but for threads.

Reuse the workers, queue the work — and the two questions that decide the size.

What is shared decides everything else — cost, safety, and how a crash spreads.

Idle workers take from the busy — and the end of the deque they take from is the whole trick.

Whole families that must match — and the cost of adding one more kind of thing.

Making an incompatible interface fit — and the one file that should know the vendor's vocabulary.

Two things that vary independently, kept from multiplying.

Assembling a complicated object step by step — and the validation you can only do at the end.

Pass the request along until somebody claims it — and the case nobody handles.

A request as an object — and the undo stack you get almost for free.

Treating one thing and many things identically — and the method that does not belong on a leaf.

Adding behaviour by wrapping rather than subclassing — and why the order of the wrappers is a real decision.

One door into a subsystem — and why the door must not become the only way in.

Letting a subclass decide what to construct — and why a plain function is usually enough.

Sharing the heavy part between many objects — and the split that makes it possible.

A grammar as a class hierarchy — and why you should almost always use a parser generator instead.

Walking a collection without knowing its shape — and why laziness is the part that matters.

A hub instead of a mesh — and the risk that the hub becomes the program.

A snapshot that only its owner can read — and why undo usually wants commands instead.

One-to-many notification without the sender knowing who is listening — and the leak it invites.

Copying an existing object instead of constructing one — and the depth of the copy.

A stand-in with the same interface — and the fact that callers cannot tell is both the feature and the hazard.

One instance, globally reachable — and why the second half of that is the problem.

Behaviour that follows the mode — and how the illegal transitions stop being reachable.

The algorithm as a parameter — and why in most languages it is now just a function.

The skeleton fixed, the steps varied — inheritance's one genuinely good use, and its limits.

Adding an operation without editing the classes — and the price it charges for that.