From Zero to 3-Star: My 8-Month Journey to 2100+ LeetCode Rating & 1000+ DSA Problems

Eight months ago, I couldn't solve a simple two-pointer problem. Today, I'm a 3-star coder on CodeChef with a 2100+ rating on LeetCode and over 1000 DSA problems under my belt. This isn't a story about natural talent or shortcuts—it's about consistency, strategy, and learning from countless failures.

If you're starting your DSA journey or feeling stuck, this post is for you. I'll share exactly what worked, what didn't, and the mindset shifts that made all the difference.

April 2025: The Starting Line

I had programming experience—I'd built AI/ML projects, worked with Python and Java, and understood basic syntax. But competitive programming? That was a different beast entirely. My first LeetCode Easy problem took me 30 minutes and 2-3 wrong submissions. I didn't even know what time complexity meant beyond "make it fast."

The wake-up call came during a coding interview. I froze on a medium-level array problem that the interviewer said was "standard." That's when I realized: building projects and solving algorithmic problems require completely different skill sets. I needed to get serious about DSA.

Starting Stats (April 2025):

• LeetCode: ~100 problems solved (mostly Easy)
• CodeChef: Unrated
• Understanding: Could implement basic loops and conditionals, struggled with anything beyond that
• Confidence: Rock bottom

The Strategy: Building a Foundation (April - June)

I spent the first two months building fundamentals. No contests, no hard problems—just focused learning. Here's what worked:

1. Pattern Recognition Over Random Solving

Instead of randomly picking problems, I followed a structured approach. I focused on one pattern at a time:

• Week 1-2: Arrays and Hashing (Two Sum, Contains Duplicate, Group Anagrams)
• Week 3-4: Two Pointers (Container With Most Water, 3Sum, Trapping Rain Water)
• Week 5-6: Sliding Window (Longest Substring Without Repeating Characters, Minimum Window Substring)
• Week 7-8: Binary Search (Search in Rotated Sorted Array, Find Minimum in Rotated Sorted Array)

For each pattern, I'd solve 15-20 problems, starting with Easy, moving to Medium, and attempting 1-2 Hard problems. The key was understanding why a pattern worked, not just memorizing solutions.

2. The 20-Minute Rule

If I couldn't solve a problem in 20 minutes, I'd look at the solution. But here's the crucial part: I wouldn't just read it—I'd:

1. Understand the approach conceptually
2. Close the solution and implement it myself
3. Come back to the same problem 3 days later and solve it from scratch
4. Revisit it again after a week

This spaced repetition was game-changing. Problems I struggled with became second nature.

3. Daily Consistency Over Marathon Sessions

I committed to solving 3-5 problems daily, no matter what. Some days I'd spend 3 hours, other days just 45 minutes. But I never skipped a day. By June, I'd solved 300+ problems and my LeetCode rating crossed 1600.

The Breakthrough: Entering Contests (July - August)

July was when I started participating in contests. My first CodeChef contest? I solved 1 out of 5 problems and ranked in the bottom 30%. It was humbling, but I learned more from that one contest than from solving 50 practice problems.

Contest Strategy That Worked:

• LeetCode Weekly Contests: Every Sunday, without fail. Even if I could only solve 1-2 problems, I participated.
• CodeChef Weekly Contests: I will try to solve atleast 3 problems in CodeChef contest
• Post-Contest Analysis: After every contest, I'd spend 2-3 hours understanding problems I couldn't solve during the contest.

By August, I was consistently solving 2-3 problems in LeetCode contests and reached 1-star on CodeChef. My rating was around 1800 on LeetCode.

The Mental Game

Contests taught me something crucial: competitive programming is 50% algorithms and 50% mental game. I learned to stay calm when stuck, manage time effectively, and not panic when I saw others solving problems faster. This mindset shift was as important as any algorithm I learned.

The Grind: Pushing to 2100+ (September - November)

The jump from 1800 to 2100+ was the hardest part of my journey. At this level, you're competing with people who've been doing this for years. Here's what made the difference:

1. Advanced Topics Deep Dive

I spent September mastering advanced topics:

• Dynamic Programming: Solved 100+ DP problems. Started with 1D DP, moved to 2D, then tackled state machine DP and DP on trees.
• Graphs: BFS, DFS, Dijkstra's, Union-Find, Topological Sort. Solved every graph problem I could find.
• Trees: Binary trees, BSTs, segment trees, and Fenwick trees.
• Advanced Data Structures: Heaps, tries, and monotonic stacks/queues.

2. Problem Difficulty Progression

I started attempting more Hard problems. My approach:

• Spend 30-45 minutes trying to solve it myself
• If stuck, read hints (not full solution)
• Implement and debug thoroughly
• Study optimal solutions and learn new techniques

3. Contest Performance Optimization

I analyzed my contest performance and identified patterns:

• I was spending too much time on problem 1-2, leaving less time for harder problems
• I wasn't reading all problems before starting to code
• I was making silly mistakes under time pressure

I adjusted my strategy: quickly scan all problems, identify the easiest ones, solve those first, then tackle harder problems. This simple change improved my contest ranking significantly.

4. The Final Push

October and November were intense. I was solving 5-7 problems daily, participating in 3-4 contests per week, and reviewing my mistakes religiously. By mid-November:

• LeetCode rating: 2100+
• CodeChef: 3-star (1600+ rating)
• Total problems solved: 1000+
• Contest performance: Consistently solving 3-4 problems in LeetCode contests

Key Lessons & Mistakes to Avoid

What Worked:

• Consistency over intensity: Daily practice beats weekend marathons
• Pattern-based learning: Understanding patterns > memorizing solutions
• Contest participation: Real pressure teaches you things practice never will
• Spaced repetition: Revisiting problems after days/weeks solidifies understanding
• Community learning: Discussing approaches with others on Discord and forums

What Didn't Work:

• Random problem solving: Jumping between topics without structure
• Only solving Easy problems: Comfort zone is the enemy of growth
• Skipping contests: "I'll participate when I'm ready" is a trap
• Not reviewing mistakes: Making the same error twice is inexcusable
• Comparing with others: Focus on your own progress, not others' speed

Resources That Helped Me

• Striver's A2Z DSA Sheet: Comprehensive coverage of all topics
• LeetCode Discuss: Reading others' solutions taught me new approaches
• CodeChef Practice: Great for building contest stamina
• TakeUForward YouTube: Excellent explanations for complex problems

The Reality Check

Let me be honest: this journey was hard. There were days I wanted to quit. Days when I couldn't solve a single problem. Days when I saw others progressing faster and felt inadequate.

But here's what I learned: everyone's journey is different. Some people reach 2100+ in 3 months, others take a year. What matters is that you keep showing up.

The skills I've gained go beyond just solving problems. I think more clearly, debug faster, and approach complex problems with confidence. These skills have already helped me in technical interviews and will continue to benefit my career.

What's Next?

I'm not stopping here. My goals for the next 6 months:

• Reach 4-star on CodeChef
• Cross 2150+ on LeetCode
• Solve 1500+ total problems
• Participate in Codeforces and reach Expert level
• Help others on their DSA journey through mentoring

Final Thoughts

If you're reading this and thinking "I could never do that," you're wrong. Eight months ago, I thought the same thing. The difference between where I was and where I am now isn't talent—it's consistency, strategy, and refusing to give up.

Start today. Solve one problem. Then another. Then another. In 8 months, you'll look back and be amazed at how far you've come.

The journey from zero to 3-star isn't about being the smartest person in the room. It's about being the most persistent. And that's something anyone can choose to be.