30/90-Day Learning Plans & Practice Strategy

0/12 in this phase0/57 across the roadmap

📖 Concept

A structured learning plan is the difference between spending 6 months going in circles and mastering DSA in 90 days. Here's a battle-tested roadmap.

30-Day Plan (Crash Course — 3-4 hours/day):

Week 1: Big-O, Arrays, Strings, Hash Maps, Two Pointers
Week 2: Linked Lists, Stacks, Queues, Binary Search, Sliding Window
Week 3: Trees, BST, DFS/BFS, Recursion, Dynamic Programming basics
Week 4: Graphs, Heaps, Greedy, Advanced DP, Mock Interviews

90-Day Plan (Deep Mastery — 2-3 hours/day):

Month 1: Foundations + Core Data Structures (Phases 1-2)
Month 2: Algorithmic Patterns + Advanced Structures (Phases 3-4)
Month 3: Interview Practice + System Design + Mock Interviews (Phase 5)

How to use LeetCode effectively:

Don't jump to hard problems — Start with Easy, master patterns
Time-box: 25 min for Easy, 40 min for Medium, 60 min for Hard
If stuck after time limit: Read the editorial, understand the pattern, then solve from scratch without looking
Track patterns, not problems — "I solved a sliding window problem" is better than "I solved problem #3"
Spaced repetition — Re-solve problems after 3 days, 1 week, 2 weeks
Focus on 150-200 curated problems (Blind 75, NeetCode 150) not 2000+ random ones

Mock Interview Strategy:

Do at least 2 mock interviews per week in Month 3
Use: Pramp (free), Interviewing.io, or practice with a friend
Simulate real conditions: 45 min, webcam on, think out loud
Get feedback on: communication, approach, code quality, edge cases

Revision Strategy:

Keep a mistake journal — write down every mistake and the correct pattern
Review mistakes weekly
Re-solve your weakest pattern every Saturday
Teach concepts to someone else — best way to solidify understanding

Weekly Milestone Template:

Week N:
- [ ] 10 LeetCode problems (pattern: ___)
- [ ] 1 new data structure learned
- [ ] Review mistake journal
- [ ] 1 mock interview
- [ ] Teach one concept

🏠 Real-world analogy: You wouldn't train for a marathon by running 42km on day one. You build up: walking → jogging → running → race pace. Same with DSA: easy → medium → hard, pattern by pattern.

💻 Code Example

codeTap to expand ⛶

1// PROGRESS TRACKING TEMPLATE
2const weeklyPlan = {
3  week: 1,
4  focus: "Arrays & Hash Maps",
5  problems: [
6    { name: "Two Sum", difficulty: "easy", pattern: "hash map", solved: false },
7    { name: "Best Time to Buy and Sell Stock", difficulty: "easy", pattern: "kadane", solved: false },
8    { name: "Contains Duplicate", difficulty: "easy", pattern: "hash set", solved: false },
9    { name: "Product of Array Except Self", difficulty: "medium", pattern: "prefix sum", solved: false },
10    { name: "Maximum Subarray", difficulty: "medium", pattern: "kadane/DP", solved: false },
11  ],
12  mockInterview: false,
13  conceptsReviewed: [],
14  mistakesLogged: [],
15};
16
17// SPACED REPETITION TRACKER
18interface ProblemLog {
19  name: string;
20  pattern: string;
21  firstSolved: Date;
22  nextReview: Date;
23  reviewCount: number;
24  difficulty: "easy" | "medium" | "hard";
25  notes: string;
26}
27
28function scheduleReview(log: ProblemLog): Date {
29  const intervals = [3, 7, 14, 30]; // days
30  const idx = Math.min(log.reviewCount, intervals.length - 1);
31  const next = new Date(log.firstSolved);
32  next.setDate(next.getDate() + intervals[idx]);
33  return next;
34}
35
36// PATTERN TRACKER — organize by pattern, not by number
37const patternTracker = {
38  "Two Pointers": { solved: 0, target: 10, problems: [] },
39  "Sliding Window": { solved: 0, target: 8, problems: [] },
40  "Binary Search": { solved: 0, target: 8, problems: [] },
41  "DFS/BFS": { solved: 0, target: 12, problems: [] },
42  "Dynamic Programming": { solved: 0, target: 15, problems: [] },
43  "Hash Map": { solved: 0, target: 10, problems: [] },
44  "Stack": { solved: 0, target: 6, problems: [] },
45  "Heap": { solved: 0, target: 6, problems: [] },
46  "Greedy": { solved: 0, target: 8, problems: [] },
47  "Backtracking": { solved: 0, target: 6, problems: [] },
48};
49
50// INTERVIEW SIMULATION TIMER
51function startInterviewTimer(minutes: number = 45): void {
52  console.log(`⏱️ Interview started — ${minutes} min`);
53  console.log("0-5 min: Understand & clarify");
54  console.log("5-10 min: Plan approach & discuss complexity");
55  console.log("10-35 min: Implement solution");
56  console.log("35-40 min: Test with examples & edge cases");
57  console.log("40-45 min: Optimize & discuss alternatives");
58}

🏋️ Practice Exercise

Action Items:

Create your own 30-day study plan based on the template above
Sign up for LeetCode and solve the first 10 problems from Blind 75
Set up a mistake journal (Notion, Google Doc, or markdown file)
Time yourself solving an Easy problem — stay under 25 minutes
Find a study partner or join a Discord for accountability
Schedule your first mock interview (Pramp is free)
Create a pattern tracker spreadsheet
Set weekly goals: problems solved, concepts learned, mock interviews
Review the constraint → complexity mapping and memorize it
Practice explaining your solution out loud to a rubber duck (or friend)

⚠️ Common Mistakes

Solving 500+ random LeetCode problems without tracking patterns — you'll forget most of them
Spending 3 hours on one hard problem — time-box and learn from editorials
Only solving Easy problems and never progressing to Medium — Medium is the interview standard
Not doing mock interviews — solving problems alone is different from explaining your approach
Cramming the week before interviews instead of consistent daily practice — consistency wins

💼 Interview Questions

🎤 Mock Interview

Practice a live interview for 30/90-Day Learning Plans & Practice Strategy

Was this topic helpful?

← PreviousInput/Output Patterns & Edge Cases Next →Arrays — Deep Dive & Internal Implementation