6 weeks to confident DSA: patterns, spaced repetition, results

6 weeks to confident DSA: patterns, spaced repetition, results

TL;DR

  • Completed NeetCode Beginners + Advanced track (~120 LeetCode problems) in 6 weeks across various subjects.
  • Built a spaced-repetition tracker -> stopped remembering solutions, started explaining them.

The first time I heard about data structures and algorithms was in my second year of college. We had an introductory course that covered the main principles. And then in the following years, nothing. In my first three-year position as a software engineer, there was no need to implement very complex algorithms. My work was more focused on system design. When I started exploring new challenges elsewhere and looked at the hiring processes, the importance of DSA became obvious.

I took a methodical approach. Like listening to a sports coach, sometimes you trust people who’ve already been there. I followed advice from the AlgoMaster blog and NeetCode, and used research from Interviewing to structure my plan.

Methodology

I subscribed to NeetCode for a progressive roadmap by difficulty. After work, I put in ~5 hours a day, tracking both new problems and reviews. I kept a simple spreadsheet:

ID Name Topic Difficulty Status Date Review Next Date Time Spent
48 LRU Cache Hashing Medium Done 07/29/25 0 07/30/25 10min

For each exercise, I timed myself. But the key columns are Review and Next Date. Detecting the pattern behind a problem is the real unlock. So I set up a spaced repetition mechanism. If the exercise is Done, the Next Review column indicates to redo the exercise at a later date based on the number of times you have already reviewed the exercise. It was a game changer because it allowed me to forget an exercise and its solution, and come back to it with a better understanding of related topics. The calculation is very simple:

Spaced Repetition System

If I spent more than 45 minutes searching without finding the answer, then I peeked at the solution. I would then replay it step by step, either in my head or on paper, to make sure I understood why it worked. After a month of work, I finished the first course. But I encountered a difficulty that I hadn’t identified.

Why solving ≠ understanding

After a month of hard work and reaching the end of the beginner’s course, I could solve most problems, but I couldn’t always justify them. A professor once told me that, when compiling was expensive, he would “execute” code on paper first. I adopted that: tracing state on paper to visualize algorithms. I stopped caring about speed for these passes: the goal was the thought process.

Paper-tracing cut my re-attempt time on graph problems noticeably.

Advanced Algorithms

I started the Advanced Algorithms course in the second month. The concepts are tougher, but the first course prepares you well. The same routines: reviews, paper-tracing, strict timing, kept me efficient.

I found this course more interesting, especially the part on Prefix Trees / Tries and Dijkstra’s algorithm. My most challenging topic was Segment Trees. At the end of these courses, I’ve covered the following topics:

Topics covered

What actually worked (so you can copy it)

During these two intensive months, I learned a lot.

  • Prioritize review over speed: it’s more important to fully understand a problem, even if it takes more time, than to be stressed by time constraints.

  • Track everything: I think it’s vital to be aware of your learning progress, your strengths, and your weaknesses. Keeping track of your progress is important for improving your skills.

  • Don’t be afraid to peek at solutions: it’s okay to fail. Everyone fails. The important thing is to keep going and improve. Sometimes you may feel like a failure when you mess up an exercise, take longer than expected, etc. But that’s when the real learning happens. Believe in yourself and keep going.

  • Be consistent: keep up your momentum, even if you are tired sometimes. That doesn’t mean you shouldn’t rest, but you shouldn’t make excuses for yourself.

  • Think in patterns, not problems: I have read many stories from people learning DSA on the web. But I have noticed that many try to memorize each exercise. Thinking in patterns allows you to be more efficient and confident on a variety of exercises that you may not have anticipated.

Conclusion

These last two months taught me new topics, reinforced old ones, and honestly, built grit.

Failure and frustration are emotionally expensive, but worth it.

Today, I feel more confident.

I’m keeping the habit alive with daily reviews. I’m also reading Grokking Algorithms as a lighter wrap-up and starting a System Design course to sharpen what I already used in previous roles.

Thank you for reading this far, and see you soon!