Roadmap · Foundations
DSA and problem solving (Java)
Opens with creditsFor developers and students who can write code but freeze when a problem has no obvious library call. By the end you reason about cost before coding, pick the right data structure, recognise common problem shapes, and work an unfamiliar problem to a correct, efficient solution under time pressure, which also carries you through coding rounds.
Curated by Tauseef Fayyaz8 stages, 52 topics~14 months at a few hours a weekBy the end, you will be able to
- State the time and space complexity of your own code and spot the quadratic loop before it ships
- Implement lists, stacks, queues, hash maps, heaps, trees and graphs from scratch and explain their costs
- Name the pattern behind an unseen problem (sliding window, two pointers, BFS, backtracking, dynamic programming and more) and apply it
- Solve a medium problem in about 35 minutes, with a brute force first, an optimised version after, and edge cases tested
The path
8 stages, in the order to learn them. Open one to start.
1Complexity and Big-OLearn to say what a piece of code costs in time and memory before you run it. Every later stage is about trading one cost for another, so this is the vocabulary for all of it.6 topics · ~3 weeks
- 1What Big-O means and the common growth ratesBig-O notation describes how much more work code does as its input gets bigger.
- 2Counting operations in loopsMost complexity questions are answered by counting operations in loops.
- 3Best, worst and average caseThe same algorithm can do very different amounts of work on two inputs of the same size.
- 4Space complexity and the call stackSpace complexity is the extra memory an algorithm needs as its input grows.
- 5Amortised costSome operations are cheap most of the time and expensive once in a while.
- 6Reading constraints to guess the target complexityThe limits in a problem statement, called constraints, tell you how fast your solution must be.
6 in this stageOpen this stage2Arrays, hashing, linked lists, stacks and queuesLearn the linear structures and hash maps that most problems are built on, and exactly what your language gives you for each. Counting, grouping and lookup problems all start here.6 topics · ~2 months
- 1Arrays, dynamic arrays and stringsAn array stores items side by side in memory, like numbered boxes in a row.
- 2Singly and doubly linked listsA linked list stores each item in its own node, and each node points to the next one, like a trail of clues where each tells you where the next is.
- 3Stacks, queues and dequesA stack is last in, first out, like a pile of plates: you add and remove at the top only.
- 4Hash maps and setsA hash map stores pairs of keys and values, like a dictionary that links each word to its meaning.
- 5Prefix sums and frequency countsTwo small techniques, built on arrays and hash maps, solve a surprising number of problems.
- 6Your language's built-in collections and their costsYou build each structure once to understand it.
6 in this stageOpen this stage- Recursion, sorting and searchingLearn to trust recursion, then use it to understand the classic sorts and binary search. Divide and conquer starts here and comes back in trees, graphs, backtracking and dynamic programming.6 topics · ~6 weeksOpens with credits
- Trees and heapsHierarchical structures and the traversals that answer most questions about them, plus heaps for anything that needs the smallest or largest item fast. Most tree problems are one recursive function.6 topics · ~7 weeksOpens with credits
- GraphsModel relationships as nodes and edges, then search, order and connect them. Many problems that look like grids, schedules or dependency lists are graph problems in disguise.6 topics · ~7 weeksOpens with credits
- Coding patternsTurn the structures and algorithms you know into a toolkit of recognisable problem shapes. This is the stage where unfamiliar problems start to feel familiar, because you see the pattern before the details.10 topics · ~3 monthsOpens with credits
- Dynamic programmingLearn dynamic programming as recursion plus a cache, then group problems into a few families you can recognise. It looks like the hardest topic mostly because people start from the table instead of the recursion.6 topics · ~2 monthsOpens with credits
- Timed practice and coding-round habitsTest everything with mixed, timed problems where the topic is not given to you, and build the habits that make you reliable under a clock: clarify, plan, talk, test and analyse.6 topics · ~2 monthsOpens with credits
6 more stages, 40 more topics, free with an account.
You have seen the open stages of the DSA and problem solving roadmap. Every topic it covers is listed above, and an account opens the rest: what each topic means, a question to check yourself, the courses, the practice and Tauseef's advice for every stage. Early access is open: sign up and your account is active shortly after.
Everything here is free to learn from. A few things, like adding a roadmap, keeping a cheat sheet or asking Tauseef a question, use credits. You get 15 when you join, your first roadmap is free, and if you are learning seriously and run out, you can ask for more. Credits only make sure the platform goes to people who are actually learning.
Related on Sefism
Picked from the other libraries by shared topics.
Career questions
See all- Is DSA still worth learning when AI can write code?Yes, but for a different reason than before. AI can produce a sorting function; it cannot tell you whether your design will fall over at scale or whether the code it wrote is quietly quadratic. DSA teaches you to judge code, and many companies still test it. Learn the core patterns well, skip the endless grind.
- I understand tutorials but cannot build anything myself. Why does coding feel so different when I am alone?Tutorials train recognition, not production. When you follow along, someone else makes every decision. Building alone requires you to break a problem down and make choices, which is a separate skill. Build it with small projects, planning on paper first, and a rule to struggle before you look anything up.
- How many LeetCode problems are enough, and how do I practise them properly?For most junior and mid-level interviews, 150 to 250 well-understood problems, organised by pattern, are enough. The number matters far less than whether you can recognise the pattern, explain your approach aloud and solve a similar problem a week later without help.
Cheat sheets
See allStuck on something specific?
Writing only gets you so far. If you want an answer to your situation rather than the general case, book a session and we will work through it together. Sessions are free for approved Sefism members, and a few slots open each week.
- 1:1 Mentorship
- Fresh Graduate Mentorship
- Career Guidance
Brand deals, promos and partnerships: tauseeffayyaz@gmail.com