Algorithms, taught right.

Three forces have changed what an algorithm interview is actually measuring.

The keystrokes are free.AI coding assistants—Copilot, Cursor, Claude Code—will type out a sliding window before you finish reading the prompt. What survives is whether you can name the pattern, justify the complexity, and explain why a deque beats a sorted multiset. The mechanical layer is gone. The reasoning layer is the whole interview.

The bar moved earlier. Two-pointer, sliding window, prefix sum, hash-map — these used to be senior-grade tooling. They are now expected on day one. Internship rounds ask DP. New-grad loops ask graph traversals. The interview level you prep for matters less than whether you can teach the pattern back at a whiteboard.

The pattern set settled. Open up any of the modern prep curricula — Grokking the Coding Interview, NeetCode 150, the AlgoMaster patterns — and you will see the same shortlist: somewhere between fifteen and thirty patterns, depending on how finely you slice them. The overlap is the canon. It isn't a secret. It is textbook material. This handbook treats it that way.

Pattern recognition compounds. Memorising solutions does not.

The DSA-prep landscape is enormous and uneven. Some resources are solution dumps — thousands of accepted answers with no organising idea behind them, where every problem feels like a one-off trick. Some are video courses behind a paywall — a free trailer, then a $400 funnel, with the actual teaching gated. Some are language-locked — the explanation assumes Python; if you write Java, C++, or Go, you translate as you go and lose the idiom. And some are pattern-dogmatic — a fixed list of N patterns, each forced onto problems it does not actually fit, until the framework starts lying to you.

This handbook is none of those things.

Written as inline Markdown in a public Git repository. Rendered by a static site generator. Every chapter is peer-reviewable, forkable, and translatable. Nothing is paywalled. Every algorithm is taught in plain prose first — the mental model, the invariant, why it works — then implemented in Python, Java, C++, and Go side by side, with animated visualisations where they earn their place.

Every chapter follows the same arc. A mental model gives you intuition — the invariant, the picture, the shape of the problem before any code is written. Multi-language code implements the pattern in Python, Java, C++, and Go side by side, so the algorithm reads cleanly in whichever language you write. A problem ladder walks from a representative easy problem to the hard variant interviewers actually ask, with the recognition cue spelled out at every rung. A complexity and pitfalls section names the mistakes that fail submissions and the edge cases that fail interviews.

Animated visualisations appear where a static diagram lies — binary-search step-throughs, sliding-window state, recursion trees, heap reshuffles, partition under quickselect. They are optional; the prose stands without them. Reduce-motion preferences are respected everywhere.

This project stands on the shoulders of others. We do not copy from any of them. We teach the same algorithms in our own words, with our own diagrams, and we cite them.