coding-interview-preparation

A collection of reusable code snippets that can be used for code interview problems

Pattern Implementation Status

✅ = Fully Implemented 🔄 = In Progress ⏳ = Planned

Core Patterns

1. ✅ Prefix Sum
2. ✅ Two Pointers
3. ✅ Sliding Window
4. ✅ Fast & Slow Pointers
5. ✅ LinkedList Reversal
6. ✅ Monotonic Stack
7. ✅ Top K Elements
8. ✅ Overlapping Intervals
9. ✅ Modified Binary Search
10. ✅ Tree Traversal
11. ✅ DFS
12. ✅ BFS
13. ✅ Matrix Traversal
14. ✅ Backtracking
15. ✅ Basic Dynamic Programming

Dynamic Programming Patterns

16. ✅ Fibonacci Sequence
17. ✅ Kadane's Algorithm
18. ✅ 0/1 Knapsack
19. ✅ Unbounded Knapsack
20. ✅ LCS
21. ✅ LIS
22. ✅ Palindromic Subsequence
23. ✅ Edit Distance
24. ✅ Subset Sum
25. ✅ String Partition
26. ✅ Catalan Numbers
27. ✅ Matrix Chain Multiplication
28. ✅ Count Distinct Ways
29. ✅ Grid DP
30. ✅ Tree DP
31. ✅ Graph DP
32. ✅ Digit DP
33. ✅ Bitmasking DP
34. ✅ Probability DP
35. ✅ State Machine DP

Resources

Official Documentation

• Python Documentation
• Time Complexity Guide

Inspirational Articles

1. 15 LeetCode Patterns by Ashish Pratap Singh
2. 20 Patterns to Master Dynamic Programming by Ashish Pratap Singh

Practice Platforms

• LeetCode
• HackerRank
• CodeForces

📖 Resources & Inspiration

Primary Sources

1. "LeetCode was HARD until I Learned these 15 Patterns" by Ashish Pratap Singh

   • Comprehensive coverage of core algorithmic patterns
   • Practical examples and problem classifications
   • Pattern-based problem-solving approach

2. "20 Patterns to Master Dynamic Programming" by Ashish Pratap Singh

   • In-depth coverage of DP patterns
   • Pattern categorization from basic to advanced
   • Problem-pattern mapping for DP

Additional Learning Resources

Official Documentation

• Python Documentation
• Google Python Style Guide

Practice Platforms

• LeetCode
• HackerRank
• CodeForces

Books & Articles

• "Introduction to Algorithms" (CLRS)
• "Algorithms" by Robert Sedgewick
• "Dynamic Programming for Coding Interviews"

Video Resources

• AlgoMaster YouTube Channel
• Back To Back SWE
• Tech Interview Pro

🤝 Contributing

We welcome contributions! Please see our CONTRIBUTING.md for details on:

• Adding new patterns
• Improving implementations
• Adding problem solutions
• Enhancing documentation

Pattern Selection Guide

How to Choose the Right Pattern

1. Identify Key Characteristics:

   • Sorted array? → Two Pointers
   • Substring/Subarray? → Sliding Window
   • Optimal substructure? → Dynamic Programming

2. Consider Constraints:

   • Time complexity requirements
   • Space complexity limits
   • Input size ranges

3. Common Pattern Indicators:

   def select_pattern(characteristics: Dict[str, bool]) -> str:
       if characteristics.get('sorted_array'):
           return 'Two Pointers'
       elif characteristics.get('subarray_sum'):
           return 'Prefix Sum'
       elif characteristics.get('optimization'):
           return 'Dynamic Programming'
       # ... more conditions

Best Practices

1. Time Complexity:

   • Always consider the most efficient solution
   • Document complexity in comments
   • Explain trade-offs

2. Space Optimization:

   • Consider in-place algorithms when possible
   • Use space-time trade-offs wisely
   • Document space complexity

3. Code Style:

   • Follow Google Python Style Guide
   • Use meaningful variable names
   • Add comprehensive docstrings

Contributing

Contributions are welcome! Please:

1. Follow the code style guide
2. Add comprehensive tests
3. Document complexity analysis
4. Include example problems
5. Update implementation status

License

MIT License - see LICENSE file for details.

---

Happy Coding! 🚀

Ultimate Algorithm Patterns Guide

A comprehensive collection of coding interview patterns combining algorithmic techniques and dynamic programming approaches.

📚 Table of Contents

1. Introduction

   • Purpose
   • How to Use This Guide
   • Repository Structure

2. Core Algorithm Patterns

   • Array & String Patterns
     • Prefix Sum
     • Two Pointers
     • Sliding Window
   • Linked List Patterns
     • Fast & Slow Pointers
     • In-place Reversal
   • Stack & Queue Patterns
     • Monotonic Stack
     • Priority Queue (Top K)
   • Binary Search Patterns
     • Modified Binary Search
     • Search Space Reduction
   • Tree & Graph Patterns
     • Tree Traversals (PreOrder, InOrder, PostOrder)
     • BFS/DFS
     • Matrix Traversal
   • Advanced Patterns
     • Backtracking
     • Intervals
     • Cyclic Sort

3. Dynamic Programming Patterns

   • Basic Patterns
     • Fibonacci Style
     • Kadane's Algorithm
   • Knapsack Patterns
     • 0/1 Knapsack
     • Unbounded Knapsack
   • String Patterns
     • LCS (Longest Common Subsequence)
     • LIS (Longest Increasing Subsequence)
     • Palindromic Subsequences
     • Edit Distance
   • Grid & Graph Patterns
     • Grid Traversal
     • Tree DP
     • Graph DP
   • Advanced DP Patterns
     • State Machine
     • Probability DP
     • Digit DP
     • Bitmask DP

4. Pattern Recognition Guide

   • How to Identify Patterns
   • Common Problem Types
   • Pattern Selection Flowchart

5. Implementation Guidelines

   • Code Style
   • Best Practices
   • Complexity Analysis
   • Testing Strategies

6. Problem Collection

   • LeetCode Problems by Pattern
   • Common Variations
   • Solution Templates

7. Study Guide

   • Learning Path
   • Practice Strategy
   • Interview Preparation Tips