AI InterviewSearch…Search problems, topics, or pages…Ctrl KGet started

Walk the road

DSA roadmap for placements

A curriculum drawn as a road: stages of catalogue problems, from arrays to the capstone. Clear a stage and the next one opens — or sooner, once your skill profile shows you already know the stages before it.

— stages cleared— problems solved— of the road

Where you are

Continue

· Stage 1 of 19

In progress

Problems

0

AI InterviewGet started

DSA roadmap for placements

A data-structures-and-algorithms roadmap for placements: 19 stages, a tutorial for every topic with code in four languages, and about 150 curated problems.

What is the CodeKairo DSA roadmap?

The DSA roadmap is a guided path through data structures and algorithms: 19 stages in four tiers — Foundations, Core techniques, Advanced and Mastery — over about 150 curated problems, from Arrays 101, Hashing and Two Pointers through Binary Search, Heaps, Graphs and Dynamic Programming to a Capstone. A stage is cleared by getting accepted submissions on its required number of problems (usually 6 of 8), and a stage opens only when the one before it is cleared. Progress is derived from your real submissions, wherever they were made. Every tier ends in a chest paying XP and one to three bonus mock-interview sessions; finishing the road unlocks a certificate. Every stage also has its lessons — about 35 tutorials, from Big-O notation and Two Pointers to Dijkstra's Algorithm and the 0/1 Knapsack Problem — each explaining its technique with a dry run and runnable code in C++, Java, Python and JavaScript. The map and every lesson can be read without an account.

A week-by-week plan

At about 2 problems a day, five days a week, the road takes 19 weeks — about 5 months — counting only the solves each stage needs to clear. Most placement seasons start in the final year, so starting in the pre-final year's second half leaves room to revise.

WeeksStageSolves to clear
Week 11. Arrays 1016
Week 22. Hashing6
Week 33. Strings6
Week 44. Two Pointers6
Week 55. Sliding Window6
Week 66. Prefix Sums6
Week 77. Stacks6
Week 88. Binary Search6
Week 99. Sorting & Greedy6
Week 1010. Intervals6
Week 1111. Heaps6
Week 1212. Matrix & Grids6
Week 1313. Bit Manipulation6
Week 1414. Recursion & Backtracking6
Week 1515. Graphs: BFS & DFS6
Week 1616. Graphs: Advanced6
Week 1717. Dynamic Programming I6
Week 1818. Dynamic Programming II6
Week 1919. Capstone4

The road, stage by stage

Foundations

Arrays, hashing, strings and the two-pointer family. Everything after this assumes them. The chest at the end pays 30 XP and 1 bonus mock interview.

Stage 1: Arrays 101

Indexing, running totals, single passes — the habits every later stage relies on. Cleared at 6 of 8 solved.

Learn: Time and Space Complexity (Big-O Notation) · Arrays

Stage 2: Hashing

Trade memory for time: counting, lookups and the one-pass two-sum. Cleared at 6 of 8 solved.

Learn: Hashing: Hash Maps and Hash Sets

Stage 3: Strings

Scanning, building and comparing text without allocating your way out of it. Cleared at 6 of 8 solved.

Learn: Strings

Stage 4: Two Pointers

Two indices, one pass: the technique behind most sorted-array problems. Cleared at 6 of 8 solved.

Learn: Two Pointers Technique

Stage 5: Sliding Window

Grow and shrink a window over the input instead of restarting the scan. Cleared at 6 of 8 solved.

Learn: Sliding Window Technique

Stage 6: Prefix Sums

Precompute once, answer range questions in constant time. Cleared at 6 of 8 solved.

Learn: Prefix Sum · Kadane's Algorithm (Maximum Subarray Sum)

Core techniques

The data structures and search patterns most interview rounds are built on. The chest at the end pays 50 XP and 1 bonus mock interview.

Stage 7: Stacks

Last in, first out — matching, evaluating and the monotonic stack. Cleared at 6 of 8 solved.

Learn: Linked Lists · Stack Data Structure · Queues and Deques · Monotonic Stack

Stage 8: Binary Search

Halve the space every step — on arrays, on answers, on rotated inputs. Cleared at 6 of 8 solved.

Learn: Binary Search · Binary Search on the Answer

Stage 9: Sorting & Greedy

Order the input, then take the locally best step and prove it holds. Cleared at 6 of 8 solved.

Learn: Sorting Algorithms · Greedy Algorithms

Stage 10: Intervals

Sort by start, sweep, merge — the pattern behind every scheduling question. Cleared at 6 of 8 solved.

Learn: Interval Problems: Merge, Insert and Sweep

Stage 11: Heaps

Keep the k best in reach: priority queues for top-k, scheduling and streams. Cleared at 6 of 8 solved.

Learn: Binary Trees and Tree Traversals · Binary Search Tree (BST) · Heaps and Priority Queues · Trie (Prefix Tree)

Stage 12: Matrix & Grids

Two-dimensional indexing, in-place transforms and the first grid walks. Cleared at 6 of 8 solved.

Learn: Matrix and Grid Traversal

Advanced

Bits, recursion and graphs — where the harder rounds start. The chest at the end pays 80 XP and 2 bonus mock interviews.

Stage 13: Bit Manipulation

Masks, shifts and XOR tricks — small problems with elegant answers. Cleared at 6 of 8 solved.

Learn: Bit Manipulation

Stage 14: Recursion & Backtracking

Build the answer one choice at a time and undo the ones that fail. Cleared at 6 of 8 solved.

Learn: Recursion · Backtracking

Stage 15: Graphs: BFS & DFS

Islands, rooms and reachability — the two traversals every graph question starts from. Cleared at 6 of 8 solved.

Learn: Graph Data Structure · Breadth-First Search (BFS) · Depth-First Search (DFS)

Stage 16: Graphs: Advanced

Topological order, union-find, shortest paths and spanning trees. Cleared at 6 of 8 solved.

Learn: Topological Sort · Union-Find (Disjoint Set Union) · Dijkstra's Algorithm · Minimum Spanning Tree: Kruskal's and Prim's Algorithms

Mastery

Dynamic programming and the capstone: the problems that decide the final round. The chest at the end pays 100 XP and 3 bonus mock interviews.

Stage 17: Dynamic Programming I

One-dimensional state: stairs, robbers, coins and the longest increasing run. Cleared at 6 of 8 solved.

Learn: Dynamic Programming · Longest Increasing Subsequence (LIS)

Stage 18: Dynamic Programming II

Grids and two strings: paths, edit distance, subsequences and palindromes. Cleared at 6 of 8 solved.

Learn: 0/1 Knapsack Problem · Longest Common Subsequence and Edit Distance

Stage 19: Capstone

Hard problems only. Clear four of these and the road is yours. Cleared at 4 of 8 solved.

How it works

  1. Read the stage's lessons. Each stage lists its tutorials above its problems: the idea, why it works, a dry run, code in four languages, common mistakes and what to practise. Lessons are never locked, so you can read ahead.
  2. Start at Foundations. Only the first stage is open. Its problems open from the road, and the workbench keeps a link back to it with previous and next problems walking the stage.
  3. Clear stages in order. An accepted solution on enough of a stage's problems clears it and opens the next one. Solves made from the catalogue, a duel, the daily contest or a pair room count too.
  4. Open the chests. When every stage of a tier is cleared its chest opens once, paying the tier's XP to both XP and rating plus bonus mock-interview credits that never expire. Each chest is a badge on your profile and a frame on your avatar.

Who it is for

Learners who want an order to the DSA syllabus instead of a flat list of problems, and interview candidates who want to know exactly which topics are left.

Frequently asked questions

What is on the road?
Four tiers — Foundations, Core techniques, Advanced and Mastery — holding 19 stages: Arrays 101, Hashing, Strings, Two Pointers, Sliding Window, Prefix Sums, Stacks, Binary Search, Sorting & Greedy, Intervals, Heaps, Matrix & Grids, Bit Manipulation, Recursion & Backtracking, two Graphs stages, two Dynamic Programming stages and a Capstone. About 150 problems in all.
How does a stage unlock?
By clearing the one before it. A stage is cleared once you have accepted submissions on its required number of problems — usually 6 of 8. Progress is derived from your real submissions: a solve made from the catalogue, a duel, the daily contest or a pair room counts too.
What is in a chest?
Every tier ends in one. It opens the moment every stage in the tier is cleared and pays, once, the tier's XP (30, 50, 80 or 100) to both XP and rating, plus one to three bonus mock-interview sessions that never expire. Each opened chest is a badge on your profile and a frame around your avatar.
Is there a certificate?
Yes, once the last chest is open: an A4 certificate naming you, the completion date and the date each tier was cleared, exported as a PNG from the site.
Does the roadmap teach the topics too?
Yes. Every stage has its lessons — about 35 tutorials such as Two Pointers Technique, Sliding Window, Binary Search, Greedy Algorithms, Dijkstra's Algorithm and Dynamic Programming. Each explains the idea and why it works, traces an example step by step, and shows runnable code in C++, Java, Python and JavaScript. Lessons are free, need no account and are never locked.