Comprehensive evaluation system for measuring progress through the algorithm learning journey. This assessment framework provides structured checkpoints from beginner to expert level.
| Assessment | Level | Problems | Time | Passing | Patterns Tested |
|---|---|---|---|---|---|
| Entry | Beginner | 12 (6+6) | 90 min | 58% | Fundamentals & basics |
| Phase 1 | Foundation | 7 | 75 min | 71% | Two Pointers, Sliding Window, Binary Search |
| Phase 2 | Intermediate | 7 | 85 min | 71% | Prefix Sum, Cyclic Sort, Monotonic Stack, Intervals |
| Phase 3 | Advanced | 7 | 90 min | 71% | Heaps, K-way Merge, BFS/DFS, Topological Sort |
| Phase 4 | Expert | 6 | 100 min | 67% | DP, Backtracking, Greedy, Divide & Conquer |
Each assessment builds on previous knowledge. You must pass one level before advancing to the next. This ensures:
- Strong foundational understanding
- No knowledge gaps
- Confidence at each level
- Systematic skill development
Assessments focus on:
- Pattern Recognition: Can you identify which technique to apply?
- Understanding: Can you explain why your solution works?
- Implementation: Can you code it correctly and efficiently?
- Optimization: Do you know the optimal complexity?
- Edge Cases: Do you handle boundary conditions?
Passing scores are calibrated to real interview standards:
- 58-71% passing for foundation levels (learning phase)
- 67% for expert level (harder problems, lower threshold)
- Partial credit for correct approach with minor issues
- Focus on quality over speed (but time awareness matters)
Start here regardless of experience level. This assessment:
- Evaluates fundamental knowledge
- Places you in the appropriate track
- Identifies gaps in understanding
- Takes 90 minutes (12 questions)
Scoring Guide:
- 11-12 (92-100%): Skip to Phase 2
- 9-10 (75-83%): Start Phase 1, move quickly
- 7-8 (58-67%): Complete Phase 1 thoroughly
- 0-6 (<58%): Review fundamentals first
Progress through phases sequentially:
Phase 1: Foundation Patterns (7 problems, 75 min)
- Two Pointers (opposite, same direction, fast/slow)
- Sliding Window (fixed, variable size)
- Binary Search (standard, boundaries)
- Hash Table patterns
Phase 2: Intermediate Patterns (7 problems, 85 min)
- Prefix Sum / Range queries
- Cyclic Sort / In-place techniques
- Monotonic Stack
- Merge Intervals
Phase 3: Advanced Patterns (7 problems, 90 min)
- Heap / Priority Queue
- K-way Merge
- Two Heaps (median finding)
- BFS/DFS graph traversal
- Topological Sort
Phase 4: Expert Patterns (6 problems, 100 min)
- Dynamic Programming (1D, 2D, string)
- Backtracking (generation, constraint satisfaction)
- Greedy Algorithms (with proof)
- Divide and Conquer
After each assessment:
-
Immediate Review (Day 1):
- Check all solutions
- Understand mistakes
- Re-solve incorrect problems
-
Targeted Practice (Week 1):
- 5-10 problems per weak pattern
- Focus on understanding, not speed
- Use strategy guides actively
-
Spaced Repetition:
- Day 3: Retry assessment problems
- Day 7: Mixed practice
- Day 14: Explain to someone else
-
Advancement:
- If passed: Move to next phase
- If not: More practice, retake in 1-2 weeks
Preparation:
- Review relevant pattern guides
- Solve 20-30 practice problems
- Understand time/space complexity
- Get good sleep the night before
Environment:
- Quiet space, no interruptions
- Paper/whiteboard for planning
- Timer ready
- Coding environment set up
Mindset:
- It's a learning tool, not a test
- Partial credit is okay
- Focus on understanding
- Retakes are encouraged
Time Management:
- Spend 2-3 minutes understanding each problem
- Identify pattern before coding
- If stuck >15 minutes, move on
- Leave time for review (5-10 min)
Problem-Solving Process:
- Read carefully, identify edge cases
- Identify the pattern/technique
- Plan approach and complexity
- Code solution
- Test with examples
- Move to next problem
What's Allowed:
- Paper for planning/diagrams
- Your own code editor/IDE
- Language documentation (syntax only)
What's NOT Allowed:
- Looking up solutions
- AI assistance
- Algorithm references
- Previous problem solutions
Self-Scoring:
- Be honest about partial credit
- Complexity matters as much as correctness
- Edge case handling affects score
Analysis:
- Which patterns were easy?
- Which patterns need work?
- Was it pattern recognition or implementation?
- Time management issues?
Action Plan:
- Create focused practice schedule
- Use weak pattern guides
- Join study group if struggling
- Schedule retake if needed
- ✓ Correct pattern identified
- ✓ Optimal time complexity
- ✓ Optimal space complexity
- ✓ Handles all edge cases
- ✓ Clean, working code
- ✓ Can explain the approach
- ✓ Right pattern, wrong implementation
- ✓ Working but suboptimal complexity
- ✗ Misses some edge cases
- ✓ Core logic correct
- ✗ Wrong pattern
- ✗ Significantly wrong approach
- ✗ Far from optimal
- ✗ Major bugs or incomplete
When to Retake:
- Failed to meet passing score
- Want to improve understanding
- Preparing for specific interview
- Measuring progress over time
Retake Guidelines:
- Wait at least 1 week between attempts
- Complete recommended practice first
- Review all patterns, not just weak ones
- Use different examples to test
Improvement Expectations:
- First → Second attempt: +15-25%
- After targeted practice: +30-40%
- If no improvement: Review prerequisites
Based on entry assessment score:
Focus: Data structures and complexity basics
Timeline: 4-6 weeks
- Week 1-2: Arrays, linked lists, stacks, queues
- Week 3-4: Hash tables, trees basics
- Week 5-6: Complexity analysis, basic patterns
Resources:
- Prerequisites
- Time Complexity
- Data Structures (arrays, hash tables, trees, etc.)
Goal: Score 7+ on Entry Assessment
Focus: Core algorithmic patterns
Timeline: 3-4 weeks
- Week 1: Two Pointers (10-12 problems)
- Week 2: Sliding Window + Binary Search (12-15 problems)
- Week 3: Hash Table patterns (8-10 problems)
- Week 4: Mixed practice + Phase 1 Assessment
Resources:
Goal: Pass Phase 1 Assessment
Focus: Intermediate patterns
Timeline: 4-5 weeks
- Week 1: Phase 1 review + assessment
- Week 2: Prefix Sum, Cyclic Sort (10-12 problems)
- Week 3: Monotonic Stack, Intervals (10-12 problems)
- Week 4: Mixed practice
- Week 5: Phase 2 Assessment
Resources:
Goal: Pass Phase 2 Assessment
Focus: Advanced and expert patterns
Timeline: 6-8 weeks
- Week 1-2: Phase 2 patterns (quick review)
- Week 3-4: Heaps, Graph Traversal, Topo Sort (15-20 problems)
- Week 5: Phase 3 Assessment
- Week 6-8: DP, Backtracking, Greedy (25-30 problems)
- Week 8: Phase 4 Assessment
Resources:
Goal: Pass Phase 3 and 4 Assessments
- ❌ Not reading problems carefully
- ❌ Jumping to code without planning
- ❌ Ignoring edge cases
- ❌ Not testing with examples
- ❌ Spending too long on one problem
- ❌ Not reviewing at the end
- ❌ Only solving easy problems
- ❌ Looking at solutions too quickly
- ❌ Not understanding why solution works
- ❌ Skipping complexity analysis
- ❌ Not practicing pattern recognition
- ❌ Rushing through phases
- ❌ Treating assessments as pass/fail tests
- ❌ Getting discouraged by low scores
- ❌ Comparing progress to others
- ❌ Not retaking when needed
- ❌ Memorizing solutions instead of patterns
- ❌ Focusing on speed over understanding
Track your progress with these metrics:
- Pattern Recognition Rate: Can you identify the pattern in <3 minutes?
- Implementation Speed: Can you code the solution in 10-15 minutes?
- Optimization Rate: Do you achieve optimal complexity on first try?
- Edge Case Coverage: Do you identify edge cases without prompts?
- Explanation Quality: Can you teach the pattern to someone else?
- Retention: Can you solve similar problems days/weeks later?
- Variation Handling: Can you solve variations of learned patterns?
- Debugging Speed: How fast can you find and fix bugs?
- Communication: Can you explain while coding?
- Alternatives: Can you discuss multiple approaches?
- Trade-offs: Can you explain time/space trade-offs?
- Confidence: Do you feel ready for real interviews?
For complete beginners or part-time learners
- Months 1-2: Fundamentals + Entry Assessment
- Months 3-4: Phase 1 + Phase 2
- Months 5-6: Phase 3
- Months 7-8: Phase 4
- Total: 300-400 problems solved
For those with some programming experience
- Month 1: Entry + Phase 1
- Month 2: Phase 2 + Phase 3 start
- Month 3: Phase 3 completion
- Month 4-5: Phase 4
- Total: 200-300 problems solved
For experienced developers or full-time study
- Weeks 1-2: Entry + Phase 1
- Weeks 3-4: Phase 2
- Weeks 5-6: Phase 3
- Weeks 7-10: Phase 4
- Total: 150-200 problems solved
Remember: Slower, deeper learning beats fast, shallow progress.
All assessment problems reference actual problems in:
/problems/easy/- E001 to E264/problems/medium/- M001 to M570/problems/hard/- H001 to H117
Each assessment links to pattern guides in:
/strategies/patterns/- Pattern-specific deep dives/strategies/fundamentals/- Probability and specialized topics/prerequisites/- Data structures, time/space complexity, number theory
Assessments integrate with:
/tracks/roadmap.md- Overall learning roadmap- Problem tags and difficulty ratings
- Spaced repetition schedules
Based on assessment performance, use these curated lists:
Two Pointers:
- E067, E016, E108, E006, E010, E011, M004
Sliding Window:
- M002, M067, M184, M174, E206, E159
Binary Search:
- E021, E020, M008, M026, H001
Heaps:
- E219, H003, Top K problems
Graph Traversal:
- E205, E099, M568, M055, M136
Dynamic Programming:
- M011, M024, M022, H014, M015
Consider joining or forming study groups:
- Weekly problem-solving sessions
- Mock interview practice
- Pattern discussion groups
- Accountability partners
Complement assessments with:
- Books: "Cracking the Coding Interview", "Elements of Programming Interviews"
- Courses: Coursera Algorithms, MIT 6.006
- Platforms: LeetCode, HackerRank (for practice only)
- YouTube: NeetCode, Back to Back SWE
Q: Can I skip assessments if I'm experienced? A: Start with Entry Assessment. If you score 11-12, you can move quickly through Phase 1-2, but don't skip completely. Assessments identify hidden gaps.
Q: How many times can I retake an assessment? A: Unlimited, but wait at least 1 week and complete recommended practice between attempts.
Q: What if I pass but feel unprepared? A: Passing is just the minimum. If you scored exactly 71%, consider more practice before advancing.
Q: Can I use these assessments for interview prep? A: Yes! They're designed to match real interview difficulty and patterns.
Q: How do these compare to real interviews? A: Phase 1-2: Junior/mid-level roles Phase 3: Senior roles Phase 4: Senior+ and competitive programming
Q: Should I time myself strictly? A: Yes for realism, but understanding matters more than speed. If you need 10-20 extra minutes to finish, that's okay during learning.
Q: What if I can't solve any problems? A: Go back to fundamentals. Review data structures, solve easier problems, then retry Entry Assessment.
This assessment system is versioned and may be updated:
Version 1.0 (Current):
- Initial release
- 5 comprehensive assessments
- 39 total problems
- Progressive difficulty
Future Enhancements (Planned):
- Auto-grading for common languages
- Detailed analytics and progress tracking
- Adaptive difficulty based on performance
- Company-specific assessment tracks
Found issues or have suggestions?
- File issues in repository
- Suggest additional problems
- Share your experience
- Help improve clarity
- Take Entry Assessment → Determine your starting level
- Follow recommended track → Based on your score
- Study patterns → Use strategy guides
- Practice problems → 20-30 per pattern
- Take phase assessment → Validate understanding
- Review and iterate → Focus on weak areas
- Advance → Move to next phase when ready
- Repeat → Until Phase 4 completion
Upon passing Phase 4, you will have:
- ✓ Solved 150-400 algorithm problems
- ✓ Mastered 40+ algorithmic patterns
- ✓ Achieved interview readiness for senior roles
- ✓ Developed systematic problem-solving skills
- ✓ Built confidence in coding interviews
You're ready for:
- Technical interviews at top companies
- Competitive programming contests
- Teaching and mentoring others
- Advanced algorithm study
Start your journey: Entry Assessment
Good luck on your algorithm learning journey!