What is blind 75?

The Blind 75 is a curated list of 75 essential coding problems that are widely regarded as highly representative of the types of questions commonly asked in technical interviews at top-tier tech companies like Google, Amazon, Facebook, Microsoft, and others. This collection is designed to cover a broad spectrum of fundamental data structures and algorithms, providing a solid foundation for candidates preparing for software engineering roles.

Why the Blind 75 is Important

1. Comprehensive Coverage: The Blind 75 encompasses a variety of problem types, ensuring that candidates are well-versed in different aspects of computer science fundamentals.
2. Efficiency in Preparation: By focusing on a concise set of problems, candidates can optimize their study time, targeting the most impactful questions that are likely to appear in interviews.
3. Confidence Building: Regularly practicing these problems helps build problem-solving speed and accuracy, which are crucial under the time constraints of real interviews.
4. Community Endorsement: The Blind 75 has gained significant traction and endorsement within the coding interview preparation community, making it a trusted resource.

Components of the Blind 75

The Blind 75 problems are typically categorized based on the data structures and algorithms they cover. Here's an overview of the key areas:

1. Arrays and Strings

• Example Problems:
  • Two Sum
  • Best Time to Buy and Sell Stock
  • Longest Substring Without Repeating Characters

2. Linked Lists

• Example Problems:
  • Reverse a Linked List
  • Merge Two Sorted Lists
  • Linked List Cycle

3. Trees and Graphs

• Example Problems:
  • Binary Tree Inorder Traversal
  • Validate Binary Search Tree
  • Number of Islands

4. Dynamic Programming

• Example Problems:
  • Climbing Stairs
  • Coin Change
  • Longest Increasing Subsequence

5. Backtracking

• Example Problems:
  • Subsets
  • Permutations
  • Sudoku Solver

6. Sorting and Searching

• Example Problems:
  • Merge Intervals
  • Top K Frequent Elements
  • Search in Rotated Sorted Array

7. Heap/Priority Queue

• Example Problems:
  • Kth Largest Element in an Array
  • Find Median from Data Stream

8. Bit Manipulation

• Example Problems:
  • Single Number
  • Counting Bits

9. Miscellaneous

• Example Problems:
  • Valid Parentheses
  • Maximum Depth of Binary Tree

List of Blind 75 Problems

While the exact list may vary slightly depending on the source, here's a representative selection of the Blind 75 problems:

1. Two Sum (Arrays)
2. Best Time to Buy and Sell Stock (Arrays)
3. Contains Duplicate (Arrays)
4. Product of Array Except Self (Arrays)
5. Maximum Subarray (Arrays)
6. Merge Intervals (Arrays)
7. Number of Islands (Graphs)
8. Valid Parentheses (Strings)
9. Longest Substring Without Repeating Characters (Strings)
10. Median of Two Sorted Arrays (Binary Search)
11. Longest Palindromic Substring (Strings)
12. Reverse Linked List (Linked Lists)
13. Merge Two Sorted Lists (Linked Lists)
14. Binary Tree Inorder Traversal (Trees)
15. Validate Binary Search Tree (Trees)
16. Symmetric Tree (Trees)
17. Maximum Depth of Binary Tree (Trees)
18. Same Tree (Trees)
19. Path Sum (Trees)
20. Lowest Common Ancestor of a Binary Search Tree (Trees)
21. Climbing Stairs (Dynamic Programming)
22. Coin Change (Dynamic Programming)
23. Longest Increasing Subsequence (Dynamic Programming)
24. House Robber (Dynamic Programming)
25. Unique Paths (Dynamic Programming)
26. Subsets (Backtracking)
27. Permutations (Backtracking)
28. Word Search (Backtracking)
29. Combination Sum (Backtracking)
30. Number of Connected Components in an Undirected Graph (Graphs)
31. Find Minimum in Rotated Sorted Array (Binary Search)
32. Search in Rotated Sorted Array (Binary Search)
33. Top K Frequent Elements (Heap/Priority Queue)
34. Kth Largest Element in an Array (Heap/Priority Queue)
35. Find Median from Data Stream (Heap/Priority Queue)
36. Valid Sudoku (Arrays)
37. Product of Array Except Self (Arrays)
38. Longest Consecutive Sequence (Arrays)
39. Find All Anagrams in a String (Strings)
40. Sudoku Solver (Backtracking)
41. Reverse Nodes in k-Group (Linked Lists)
42. LRU Cache (Design)
43. Clone Graph (Graphs)
44. Word Ladder (Graphs)
45. Graph Valid Tree (Graphs)
46. Binary Tree Level Order Traversal (Trees)
47. Construct Binary Tree from Preorder and Inorder Traversal (Trees)
48. Path Sum II (Trees)
49. Serialize and Deserialize Binary Tree (Trees)
50. Maximum Product Subarray (Arrays)
51. Number of Digit One (Math)
52. Sliding Window Maximum (Queues)
53. Binary Tree Zigzag Level Order Traversal (Trees)
54. Longest Consecutive Path in Binary Tree (Trees)
55. Rectangle Area (Math)
56. Count Primes (Math)
57. Divide Two Integers (Math)
58. Sort Colors (Arrays)
59. Find Peak Element (Binary Search)
60. Find First and Last Position of Element in Sorted Array (Binary Search)
61. Pow(x, n) (Math)
62. Plus One (Arrays)
63. Remove Nth Node From End of List (Linked Lists)
64. Reorder List (Linked Lists)
65. Palindrome Linked List (Linked Lists)
66. Reverse Nodes in k-Group (Linked Lists)
67. Detect Cycle in a Linked List (Linked Lists)
68. Convert Sorted Array to Binary Search Tree (Trees)
69. Flatten Binary Tree to Linked List (Trees)
70. Unique Binary Search Trees (Dynamic Programming)
71. Valid Number (Strings)
72. Basic Calculator (Strings)
73. Longest Valid Parentheses (Strings)
74. Decode Ways (Dynamic Programming)
75. Regular Expression Matching (Strings)

Note: The above list is indicative and may vary slightly based on different sources.

3. Strategies to Master the Blind 75

a. Understand the Fundamentals

• Data Structures: Ensure a deep understanding of arrays, linked lists, stacks, queues, trees, graphs, hash tables, and heaps.
• Algorithms: Master sorting algorithms, searching algorithms, dynamic programming, recursion, backtracking, and graph traversal techniques.

b. Practice Consistently

• Daily Problem Solving: Aim to solve at least one problem a day from the Blind 75 to build and maintain momentum.
• Variety: Tackle problems across different categories to ensure balanced proficiency.

c. Time Management

• Timed Sessions: Simulate interview conditions by solving problems within a set timeframe (typically 45 minutes to an hour).
• Prioritize Difficult Problems: Allocate more time to challenging problems to improve problem-solving speed and accuracy.

d. Review and Reflect

• Analyze Solutions: After solving a problem, review the optimal solutions to understand different approaches.
• Identify Patterns: Recognize common problem patterns to apply similar strategies in future questions.

e. Utilize Multiple Resources

• LeetCode Discuss: Engage with the community to gain insights, alternative solutions, and tips.
• Books and Courses: Complement your practice with reading materials like Cracking the Coding Interview and courses that reinforce key concepts.

f. Mock Interviews

• Peer Practice: Conduct mock interviews with friends or study partners to simulate real interview scenarios.
• Professional Services: Use platforms like DsignGurus.io for structured mock interviews with feedback.

g. Maintain a Study Log

• Track Progress: Document the problems you've solved, the strategies you used, and the areas where you struggled.
• Set Milestones: Define weekly and monthly goals to stay on track and measure your improvement over time.

4. Additional Tips for Success

a. Choose the Right Programming Language

• Familiarity: Use a language you're most comfortable with to minimize syntax errors and maximize coding speed.
• Efficiency: Leverage language-specific features and libraries to write clean and efficient code.

b. Enhance Communication Skills

• Think Aloud: Practice verbalizing your thought process while solving problems to improve clarity during interviews.
• Explain Solutions: Be prepared to discuss your approach, the trade-offs involved, and how you arrived at your solution.

c. Focus on Problem-Solving Over Memorization

• Deep Understanding: Strive to understand the underlying principles behind each problem rather than memorizing specific solutions.
• Adaptability: Develop the ability to adapt known solutions to new and varied problems.

d. Take Care of Your Well-Being

• Regular Breaks: Incorporate short breaks into your study schedule to prevent burnout.
• Healthy Lifestyle: Maintain a balanced diet, exercise regularly, and ensure sufficient sleep to keep your mind sharp.

5. Resources to Access the Blind 75

• LeetCode Blind 75 List: Many users have created custom lists titled "Blind 75" that you can follow.
• DsignGurus.io's Grokking the Coding Interview: An interactive course that covers many of the Blind 75 problems with detailed explanations.
• Blind 75: Repository containing solutions to the Blind 75 problems in various programming languages.
• Reddit’s r/cscareerquestions: Community discussions and tips related to the Blind 75 and interview preparation.

6. Sample Study Schedule for the Blind 75

Here's a 3-month study plan to tackle the Blind 75 effectively:

Month 1: Foundation and Easy Problems

• Weeks 1-2:
  • Focus Areas: Arrays, Strings, Linked Lists
  • Activities: Solve 2 easy problems daily
  • Resources: Cracking the Coding Interview, LeetCode
• Weeks 3-4:
  • Focus Areas: Stacks, Queues, Trees
  • Activities: Solve 2-3 medium problems daily
  • Resources: Elements of Programming Interviews, LeetCode

Month 2: Intermediate Problems and Algorithms

• Weeks 5-6:
  • Focus Areas: Graphs, Heaps, Hash Tables
  • Activities: Solve 3 medium problems daily
  • Resources: Online tutorials, LeetCode Discuss
• Weeks 7-8:
  • Focus Areas: Dynamic Programming, Backtracking
  • Activities: Solve 2 medium and 1 hard problem weekly
  • Resources: Coursera courses, LeetCode

Month 3: Advanced Problems and Mock Interviews

• Weeks 9-10:
  • Focus Areas: System Design Basics (if applicable), Advanced Algorithms
  • Activities: Solve 2-3 hard problems weekly, begin mock interviews
  • Resources: Grokking the System Design Interview
• Weeks 11-12:
  • Focus Areas: Review all topics, conduct full-scale mock interviews
  • Activities: Solve mixed difficulty problems, participate in mock interviews twice a week
  • Resources: DsignGurus.io, Gainlo

7. Final Thoughts

Clearing a Google coding interview demands a combination of strong technical skills, effective problem-solving abilities, and excellent communication. By systematically working through the Blind 75, leveraging the right resources, and engaging in consistent practice, you can significantly enhance your preparedness and confidence.

Key Takeaways:

• Structured Preparation: Follow a well-organized study plan that balances learning, practice, and review.
• Consistent Practice: Regularly solve a variety of problems to build and maintain your problem-solving skills.
• Deep Understanding: Focus on truly understanding each problem and its solution, rather than just memorizing answers.
• Effective Communication: Practice explaining your thought process clearly and confidently.
• Mock Interviews: Simulate real interview scenarios to build confidence and receive constructive feedback.
• Holistic Approach: Address all aspects of the interview process, including technical, behavioral, and system design components.