Easy to Hard
in 30 Minutes
A Rust-focused LeetCode roadmap. Five stages, 97 problems, engineered to take you from “confident with arrays” to “solving hards under a timer.”
No pattern memorization. Every problem has a why — the insight it teaches and where else that insight shows up.
Loading progress…
The Roadmap
Five stages, structured so each one makes the next one feel inevitable.
Foundations
Learn the tools before building anything
Every hard problem is built from basic data structures used cleverly. This stage ensures you can implement each structure from scratch in Rust and understand its time complexity intuitively — not from memorization, but from understanding WHY each operation costs what it does.
Solve every problem here in under 15 minutes. If you can’t, the data structure isn’t internalized yet.
Recursive Thinking
Learn to break big problems into smaller ones
The leap from ‘I can use data structures’ to ‘I can solve novel problems’ happens when you internalize recursion and tree thinking. Trees are the perfect training ground because every problem naturally decomposes into subproblems on left and right children.
Dynamic Programming
The skill that separates medium solvers from hard solvers
DP is where most people get stuck, and it’s the core of ~35% of hard problems. The secret: DP is just recursion + memoization. If you completed Stage 2’s backtracking problems, you already think recursively — now you’re just caching results. Start by writing the brute-force recursion, THEN add memoization, THEN convert to bottom-up if needed.
Advanced Techniques
The building blocks of hard problems
Each technique here is a ‘power-up’ that transforms a class of seemingly impossible problems into solvable ones. You don’t need to master all of these — focus on the ones most relevant to your target companies (crypto, trading, systems). Segment trees and binary search on answer are highest ROI.
Interview Simulation
From solving to performing under pressure
Knowing how to solve a problem and solving it in 30 minutes under pressure are different skills. This stage is about speed, communication, and composure. Every problem here should be attempted with a 30-minute timer, and you should practice explaining your approach out loud — the Cybereason experience taught you this gap matters.
All 5 Stages
Click a stage to open its problemsWhy This Exists
Most LeetCode roadmaps are giant unordered problem lists. You grind through them, pattern-match your way to green checkmarks, and then freeze in real interviews when the problem doesn't match a template.
This roadmap is built differently. Every problem is chosen for a why — a single insight it teaches. The stages stack: recursion is DP without memoization; DP is backtracking with a cache; segment trees are just recursion over ranges. Once you see the lineage, “hard” stops being a label and becomes a composition of things you already know.
Every data structure template is written in idiomatic Rust — because knowing how Option<Box<Node>> behaves under ownership is the difference between passing and failing a systems-company interview.
If you're aiming at HFT, crypto infrastructure, or systems roles, the final stage is the real test: 30 minutes, random hards, out loud.
Follow the Journey
This roadmap is tracked alongside the 52-week HFT build. Same engineer, different skill tree.