The Roadmap
A topic-clustered, difficulty-tiered path through all 105 problems. Designed so a learner with zero algorithmic background can finish in order and end with the toolkit a working software engineer needs to direct AI agents, audit their output, and ship correct systems in the agentic era.
The new bargain
You will not spend your career typing for-loops. AI agents will. What you will spend your career doing is:
- Reading a problem and recognising, in seconds, which of about 15 patterns it belongs to.
- Specifying the work to an agent in the vocabulary of that pattern (sliding window, monotonic stack, topo sort).
- Reading the agent's code and noticing where it picked the wrong pattern, the wrong invariant, the wrong complexity class.
- Refusing wrong answers before they reach production.
Every problem in this bank trains one or more of those four. The code you type while learning is throwaway; the pattern-recognition reflex you build is permanent.
Reading order matters
Topics are placed in dependency order. Hashing comes before two pointers because sorted arrays use hashing in proofs. Stacks come before trees because tree traversal is "stack with names". Graphs come after trees because a tree is a graph with one extra rule. Dynamic programming comes last among the "core" topics because DP is built from recursion plus memoization, both of which you've already seen by then.
Do not skip ahead. Each topic earns its slot.
The enterprise reality check
Every topic primer in this roadmap names the named systems where its pattern shows up: not "social networks", but Slack, Twitter/X, Discord. Not "rate limiting", but Stripe, Cloudflare, Fastly. Not "search", but Google, Bing, Elasticsearch. The reason is that you will be employed at, or competing with, those companies; the patterns must be tied to the systems you will actually maintain.
Each problem's deep article includes a "Where this shows up in the enterprise" section with six to ten named products and teams. That list is the gap between "I learned this algorithm" and "I know which production system needs it". Closing that gap is the entire point.
The integrated learning loop
The 105 problems are not exercises sitting in a folder. They are entry points into a six-stage loop that the parikshan platform runs end-to-end:
- Concept article sets the pattern.
- Practice mode in the parikshan editor lets you attempt with no penalty and free AI chat.
- Exam mode runs the strict engine: full-screen lock, dual-camera proctoring (laptop + phone side-view), per-session dynamic tests so memorisation fails, graduated integrity penalties for each AI invocation.
- AI training assistant, available in both modes, is a sparring partner with graduated cost: free in practice, integrity-deducting in exam.
- Hints are levelled; each costs more integrity than the last.
- Dispute flow lets you appeal a verdict to a human reviewer if you believe it is wrong.
These features are not separate. They are one continuous loop, and the recorded data from all six (which hint, which AI intent, which violation, which override) is what makes a parikshan score trustworthy to a hiring manager. A score from a memorisation farm has none of this signal; a parikshan score carries the entire behavioural transcript.
How long it takes
Honest estimates for a learner doing one focused hour per day:
| Tier | Topics | Hours |
|---|---|---|
| Foundations | Arrays & Hashing, Two Pointers, Sliding Window, Stack | ~25h |
| Search & Structures | Binary Search, Linked List, Trees | ~20h |
| Combinatorial & Network | Backtracking, Graphs | ~20h |
| Optimization | 1-D DP, 2-D DP, Greedy | ~25h |
| Specialty | Intervals, Math/Matrix/Heaps, Bits | ~10h |
Total: about 100 hours of deliberate practice. People who try to do it in 20 hours bounce off DP and quit; people who give it 100 hours leave with a permanent skill.
What to do for each problem
- Read the topic primer (in
_topics/). - Read the concept article for the problem (
seed/concepts/{problem-id}.md). - Close the article. Open parikshan. Solve the problem from scratch. If you peek, restart.
- After you get AC, re-read the article and check: did you find the same insight, or a different one? Either is fine. The skill is the insight, not the code.
Tier 1: Foundations
1. Arrays & Hashing (14 problems)
Primer. The single most useful pattern in this entire bank: trade memory for time by remembering what you've seen.
| Problem | Difficulty | Why it's here |
|---|---|---|
| contains-duplicate | Easy | The hashing primer: set-membership in O(n). |
| valid-anagram | Easy | Counting characters with a frequency map. |
| two-sum | Easy | Hash the complement; the canonical "remember what you've seen" trick. |
| majority-element | Easy | Counting + Boyer-Moore vote (a pattern you'll see again). |
| first-unique-character | Easy | Two-pass frequency counting. |
| happy-number | Easy | Cycle detection in a sequence using a set. |
| missing-number | Easy | Sum trick or XOR; bridge to bit manipulation. |
| find-pivot-index | Easy | Prefix sums in their simplest form. |
| group-anagrams | Medium | Hashing with a canonical key. |
| top-k-frequent-elements | Medium | Hash count + bucket sort or heap. |
| product-of-array-except-self | Medium | Prefix and suffix passes; no division. |
| encode-decode-strings | Medium | Length-prefix encoding; small but everywhere in real protocols. |
| subarray-sum-equals-k | Medium | Prefix sum + hash map; the "running total + memory" pattern. |
| longest-consecutive-sequence | Medium | Hash set with "only start from sequence heads"; O(n) without sorting. |
2. Two Pointers (11 problems)
Primer. When the input is sorted (or can be), two indices walking inward or in tandem replace an O(n²) brute force with O(n).
| Problem | Difficulty | Why |
|---|---|---|
| reverse-string | Easy | The simplest meeting-in-the-middle pattern. |
| valid-palindrome | Easy | Two pointers with skip rules. |
| merge-sorted-array | Easy | Two pointers from the back to avoid an extra buffer. |
| remove-duplicates-from-sorted-array | Easy | The "slow/fast" overwrite pattern. |
| move-zeroes | Easy | Same slow/fast pattern, different invariant. |
| two-sum-ii-sorted | Easy | The two-sum problem when the array is sorted: O(n), no hash map. |
| three-sum | Medium | Sort, fix one, two-pointer the rest. |
| container-with-most-water | Medium | The "move the smaller side" invariant. |
| sort-colors | Medium | Dutch National Flag: three pointers in one pass. |
| reverse-words-in-string | Medium | Reverse-then-reverse trick; in-place string manipulation. |
| trapping-rain-water | Hard | Two pointers tracking running maxima; a small classic. |
3. Sliding Window (8 problems)
Primer. A contiguous range you grow and shrink as it walks down the array. Comes up any time the question is about a subarray or substring with a property.
| Problem | Difficulty | Why |
|---|---|---|
| maximum-average-subarray-i | Easy | Fixed-size window: the warm-up. |
| best-time-to-buy-and-sell-stock | Easy | A min-so-far is a degenerate window; same single-pass mindset. |
| longest-substring-without-repeating | Medium | Variable-size window with a hash set. |
| longest-repeating-character-replacement | Medium | Window + invariant on max frequency. |
| permutation-in-string | Medium | Window with frequency comparison. |
| minimum-size-subarray-sum | Medium | Shrinking from the left once the property is met. |
| minimum-window-substring | Hard | The boss-level window problem; demands two counters. |
| sliding-window-maximum | Hard | Window plus a monotonic deque. |
4. Stack (7 problems)
Primer. The LIFO data structure shows up wherever you need to remember the most recent unfinished thing: parentheses, expressions, "next greater" patterns.
| Problem | Difficulty | Why |
|---|---|---|
| valid-parentheses | Easy | The canonical LIFO matching problem. |
| next-greater-element-i | Easy | First taste of monotonic stack. |
| implement-queue-using-stacks | Easy | Amortised analysis through structural transformation. |
| min-stack | Medium | Auxiliary stack to maintain a running invariant. |
| evaluate-reverse-polish-notation | Medium | Stack as the abstract machine for postfix expressions. |
| generate-parentheses | Medium | Stack-shaped recursion with pruning. |
| daily-temperatures | Medium | Monotonic decreasing stack for "next greater". |
Tier 2: Search & Structures
5. Binary Search (6 problems)
Primer. Halve the search space each step. The "answer is in [lo, hi]" template generalises far beyond sorted arrays.
| Problem | Difficulty | Why |
|---|---|---|
| binary-search | Easy | The textbook. Spend extra time on the invariant; the rest is variations. |
| search-insert-position | Easy | Lower-bound search. |
| first-bad-version | Easy | Binary search on a predicate, not an array. |
| sqrt-x | Easy | Binary search on the answer space (the integers). |
| find-min-in-rotated-sorted-array | Medium | Binary search when the array is broken but locally sorted. |
| search-in-rotated-sorted-array | Medium | Same shape, harder predicate. |
6. Linked List (7 problems)
Primer. Pointer surgery. Most problems reduce to "use two pointers" or "build a new list". Always carry a dummy node.
| Problem | Difficulty | Why |
|---|---|---|
| reverse-linked-list | Easy | The pointer-swap pattern. |
| merge-two-sorted-lists | Easy | Dummy-head construction. |
| middle-of-linked-list | Easy | Slow/fast pointers (the tortoise and hare). |
| palindrome-linked-list | Easy | Reverse half, compare halves. |
| remove-nth-from-end | Medium | Lookahead pointer; single-pass. |
| add-two-numbers | Medium | Carry propagation in linked-list arithmetic. |
| lru-cache | Medium | Doubly-linked list + hash map. The first "design" problem. |
7. Trees (10 problems)
Primer. Almost every tree problem is solved by one of three recursions: DFS returning a value, DFS with an accumulator, or BFS by level.
| Problem | Difficulty | Why |
|---|---|---|
| maximum-depth-of-binary-tree | Easy | The cleanest DFS. |
| invert-binary-tree | Easy | Recursion on shape. |
| same-tree | Easy | Two-tree recursion. |
| symmetric-tree | Easy | Mirror recursion. |
| balanced-binary-tree | Easy | DFS returning two facts at once. |
| diameter-of-binary-tree | Easy | DFS with a side effect on a global. |
| path-sum | Easy | DFS with a running accumulator. |
| binary-tree-level-order-traversal | Medium | BFS with explicit levels. |
| validate-bst | Medium | DFS with bounds. |
| lowest-common-ancestor-bst | Medium | Walk down using BST ordering. |
Tier 3: Combinatorial & Network
8. Backtracking (4 problems)
Primer. Recursion that explores choices and undoes them. The shape is identical across problems; only the choice and the constraint change.
| Problem | Difficulty | Why |
|---|---|---|
| letter-combinations-phone | Medium | The friendly intro; one digit, multiple choices. |
| subsets | Medium | Pick-or-skip recursion. |
| permutations | Medium | Choice with used-set. |
| combination-sum | Medium | Backtracking with reuse and pruning. |
9. Graphs (10 problems)
Primer. Once you have BFS and DFS, almost everything else follows. Grid problems are graphs; topological sort is DFS with state.
| Problem | Difficulty | Why |
|---|---|---|
| flood-fill | Easy | The smallest BFS/DFS on a grid. |
| number-of-islands | Medium | Counting connected components. |
| max-area-of-island | Medium | Same shape; return a sum. |
| clone-graph | Medium | DFS with a memoisation map. |
| rotting-oranges | Medium | Multi-source BFS. |
| pacific-atlantic-water-flow | Medium | Reverse BFS from the borders. |
| course-schedule | Medium | Cycle detection in a directed graph. |
| course-schedule-ii | Medium | Topological sort. |
| detect-cycle | Medium | 3-colour DFS, an industry-strength pattern. |
| word-ladder | Hard | BFS over an implicit graph. |
Tier 4: Optimization
10. 1-D Dynamic Programming (10 problems)
Primer. When greedy choices fail, when the answer at position i depends on the answer at smaller positions, DP is the tool. Always start from the recurrence, not the loop.
| Problem | Difficulty | Why |
|---|---|---|
| climbing-stairs | Easy | The gateway DP; Fibonacci in disguise. |
| min-cost-climbing-stairs | Easy | Add a cost; same recurrence. |
| house-robber | Medium | Pick-or-skip with a constraint. |
| maximum-subarray | Medium | Kadane's algorithm. |
| maximum-product-subarray | Medium | Kadane with two states (min and max). |
| jump-game | Medium | DP made obsolete by greedy; you'll learn both. |
| jump-game-ii | Medium | BFS-flavoured greedy. |
| coin-change | Medium | Unbounded-knapsack flavour. |
| longest-increasing-subsequence | Medium | The classic O(n²) DP, then patience sorting for O(n log n). |
| longest-palindromic-substring | Medium | Expand around centre, or 2-D DP. |
11. 2-D Dynamic Programming (3 problems)
Primer. Two inputs, two indices, a 2-D table. The state-transition diagram is the entire problem.
| Problem | Difficulty | Why |
|---|---|---|
| unique-paths | Medium | The cleanest 2-D DP. |
| longest-common-subsequence | Medium | The string-DP template. |
| edit-distance | Hard | The boss; three operations, three transitions. |
12. Greedy (3 problems)
Primer. Make the locally best choice; prove it's globally optimal. Half the difficulty is recognising when greed works.
| Problem | Difficulty | Why |
|---|---|---|
| last-stone-weight | Medium | Greedy with a heap. |
| gas-station | Medium | The "if from A you can't reach B, neither can anyone between" argument. |
| partition-labels | Medium | Greedy on last-occurrence indices. |
Tier 5: Specialty
13. Intervals (2 problems)
Primer. Sort by start, then sweep. Most calendar and scheduling problems live here.
| Problem | Difficulty | Why |
|---|---|---|
| meeting-rooms | Easy | Detect overlap. |
| merge-intervals | Medium | Merge overlapping runs. |
14. Math, Matrix & Heaps (8 problems)
Primer. A bucket for problems that don't fit elsewhere but share a flavour: a precise transformation or a careful counting argument.
| Problem | Difficulty | Why |
|---|---|---|
| plus-one | Easy | Digit-array arithmetic. |
| roman-to-integer | Easy | Single-pass parsing with peek. |
| longest-common-prefix | Easy | Vertical scan. |
| implement-strstr | Easy | Naive substring search; gateway to KMP. |
| spiral-matrix | Medium | Boundary walking. |
| rotate-image | Medium | Transpose + reverse, or layer-by-layer. |
| k-closest-points-to-origin | Medium | Heap; quickselect alternative. |
| kth-largest-element | Medium | Heap or quickselect. |
15. Bit Manipulation (2 problems)
Primer. XOR tricks and bit counting. Small topic, big interview footprint.
| Problem | Difficulty | Why |
|---|---|---|
| number-of-1-bits | Easy | Brian Kernighan's trick. |
| single-number | Easy | XOR's "everything cancels" property. |
After you finish
You will have solved 105 problems across 15 patterns. The patterns are not a list; they are a reflex. When you next read a problem statement at work or in an interview, you will catch yourself thinking "this is a sliding-window question" before you finish reading it. That reflex is the entire skill, and it is hard to fake. The 100 hours buy you that reflex.
In the agentic-AI workspace this reflex is what makes you irreplaceable. The agent will write the code. You will name the pattern, set the invariant, and refuse the wrong answer. The candidate who can do this in 30 seconds will ship 20 features in the time the candidate who cannot ships one.
From here, you can extend in any of three directions: harder problems in the same patterns, classic algorithms you didn't need here (KMP, Dijkstra, Union-Find, segment trees), or system design. All three reward the same kind of thinking you just trained.