MASTER THE
ALGORITHM.
A structured curriculum, not a problem dump. Every topic unlocks the next, every solution is animated step by step, and every submission tells you exactly which case broke.
Most people fail at
the order, not the ideas.
Almost nobody bounces off algorithms because dynamic programming is intrinsically beyond them. They bounce off it because they started there — it is what interviews ask about, so it is where people begin.
Dynamic programming assumes you can read a recursion. Recursion assumes you can trace a call stack. Dijkstra assumes a heap. Sliding window assumes two pointers. Attempt any of them out of order and the problem is not hard, it is arbitrary — and arbitrary is what makes people quit.
So the order is the product. Everything else here exists to make one ordered path through the material actually followable.
It is a graph,
not a list.
Twelve tracks, arranged by what they depend on. A track opens when every prerequisite sits at 80% or better, so you are never stuck on a problem you had no business attempting.
Four steps, then repeat.
Tell us where you are
A four-question setup: your goal, your starting point, your weekly hours, your language. It orders the roadmap — it never locks anything.
Follow one path
Twelve tracks in dependency order. A track opens when its prerequisites are at 80%, so you are never attempting a problem you had no business attempting.
Watch it run
Solve in a real editor beside a visualizer that steps through your algorithm frame by frame, with the call stack and watch panel moving with it.
Prove it under pressure
Weekly rated contests and timed sets. A checkpoint quiz closes each track. Your rating is a number you can actually move.
Six things, built properly.
Every one of these exists because something in the ordinary way of learning this material was broken.
A curriculum, not a problem dump
383 problems arranged into 12 tracks and 5 chapters, each chapter a pattern plus the problems that drill it. The order is the product.
61 hand-built visualizers
Not generic animations. Each one is written for the specific algorithm it explains, and it drives the execution pointer in your editor.
Editorials a person wrote
The brute force, why it fails, and the single observation that unlocks the optimal solution. Written by the instructors, not scraped from comments.
Feedback that names the case
A failing submission tells you which test broke and what shape of input it was, so debugging is reading rather than guessing.
Rated weekly contests
Ninety minutes, four problems, Sunday morning. Rated against everyone in your division, with full standings and upsolving afterwards.
A forum with a house rule
Post the reasoning, not just the code. Answers that are only a code block get collapsed. Instructors answer in the same threads you do.
Statement, editor,
and the picture.
Three panes, no tab-hunting. Drag the divider, pin the visualizer, run against any test case you write yourself. On a phone the same three panes become a switcher.
target = 9
→ [0,1]
9 − 7 = 2 ∈ seen
match at index 0
Four ways in.
Students
You are taking the course and the lectures move faster than the understanding. Use the tracks to fill in what the syllabus assumed.
Career switchers
You can build things but never learned this formally. Start at Arrays and do not skip — the whole point is that the order carries you.
Working engineers
You knew this once. Take the diagnostic, let it mark what has decayed, and drill only what comes back red.
Campuses
Run a cohort with real visibility: assignment completion, at-risk flags, where the class is stuck, and structural plagiarism review.
People, not a pipeline.
Every editorial, every visualizer and every contest problem is authored and signed. They answer in the same forum threads you post in.
Dr. Lena Hoff
Curriculum lead · Trees, Graphs, Shortest PathsSpent nine years teaching second-year algorithms and watching the same three misconceptions survive every semester. The curriculum is built around killing them.
Nina Verma
Editorials · Sliding Window, HashingWrites the editorials. Believes most sliding-window bugs are invariant bugs that were never written down, and has the thread history to prove it.
Kenji Tanaka
Problem setting · Recursion, ComplexitySets the contest problems and argues about constant factors. Answers more forum threads than anyone else on staff.
Priya Sharma
Interview track · Mock roundsRuns the mock interviews. Reports that the data structure is table stakes and the signal is whether you can name what breaks first at scale.
What actually changed.
“The dependency graph is the thing. I had bounced off algorithms twice before, both times by starting at dynamic programming because that is what interviews ask about. Being told 'no, do two pointers first' is the whole product.”
“I used the visualizer on validate-BST and finally saw why a parent check passes shallow tests. Reading it in an editorial had not done it. Watching an ancestor three levels up get violated did.”
“We run two cohorts on the campus plan. The at-risk flag caught six students who had gone quiet inside the same chapter — that is a lecture I would otherwise have given three weeks too late.”
From the blog.
Why your BST validation passes the samples and dies on depth
A local check is never a tree invariant. The classic validate-BST bug, why every shallow test misses it, and why the two standard fixes are secretly the same fix.
The sliding window invariant you should write down before you code
Most sliding-window bugs are not loop bugs. They happen because nobody ever stated, in one sentence, what must be true of the window between iterations.
Two pointers: the exchange argument, properly
Everyone says 'move the smaller one'. Here is why discarding that element can never discard a valid answer — and how to reuse the argument on problems that look nothing like Two Sum.
Before you start.
Yes. All 383 problems, all 12 tracks, and the community solutions are on the free Audit plan forever, with no card. What you pay for is the written editorials, the visualizers, rated contests, and the interview simulator.
Start at Arrays.
Finish at Dynamic Programming.
157 hours of curriculum, in the only order that works. The whole path is free — pay only if you want the editorials, the visualizers and the rated rounds.