{"id":806,"date":"2024-09-22T12:26:01","date_gmt":"2024-09-22T12:26:01","guid":{"rendered":"https:\/\/algocademy.com\/blog\/mastering-the-blind-75-your-ultimate-guide-to-leetcode-success\/"},"modified":"2026-10-15T10:34:49","modified_gmt":"2026-10-15T10:34:49","slug":"mastering-the-blind-75-your-ultimate-guide-to-leetcode-success","status":"publish","type":"post","link":"https:\/\/algocademy.com\/blog\/mastering-the-blind-75-your-ultimate-guide-to-leetcode-success\/","title":{"rendered":"The Blind 75: What It Is and How to Work Through It"},"content":{"rendered":"<p>The Blind 75 is a list of 75 LeetCode problems chosen to cover the main data structures and algorithm patterns that come up in coding interviews. Its author, Yangshun Tay (a former Facebook engineer who also wrote the Tech Interview Handbook), published it as a shortlist for people with limited time. This guide explains what is on the list, how to work through it in about eight weeks, and where it stops being enough.<\/p>\n<h2>What the list is, and what it is not<\/h2>\n<p>The list was shared on the anonymous forum Blind, which is where the name comes from. It is a set of problems, not a course: it does not teach you the techniques, and it assumes you already know the basics of arrays, hash maps, recursion and trees. It leans toward medium problems (roughly 19 easy, 49 medium and 7 hard, by one count on GitHub), and about six of the problems require LeetCode Premium (Alien Dictionary, Graph Valid Tree, Number of Connected Components in an Undirected Graph, Meeting Rooms, Meeting Rooms II, and Encode and Decode Strings). Free alternatives for those exist on other sites, or you can skip them.<\/p>\n<p>Yangshun Tay later released Grind 75, a customizable successor that lets you set how many weeks you have and how many hours per week, and draws from a larger pool of problems. If you are starting fresh and want a schedule built for you, Grind 75 is worth a look. The Blind 75 remains popular because it is short and well known.<\/p>\n<p>Finishing the list does not guarantee an offer. It gives you exposure to the common patterns, which helps you recognize new problems. Interviewers also test communication and handling of problems you have not seen.<\/p>\n<h2>The problems by topic<\/h2>\n<p>These are the problems in the commonly circulated version of the list, grouped by topic. Some copies of the list differ by a problem or two, so treat the topic counts as approximate.<\/p>\n<ul>\n<li><strong>Array (10):<\/strong> Two Sum, Best Time to Buy and Sell Stock, Contains Duplicate, Product of Array Except Self, Maximum Subarray, Maximum Product Subarray, Find Minimum in Rotated Sorted Array, Search in Rotated Sorted Array, 3Sum, Container With Most Water.<\/li>\n<li><strong>Binary (5):<\/strong> Sum of Two Integers, Number of 1 Bits, Counting Bits, Missing Number, Reverse Bits.<\/li>\n<li><strong>Dynamic programming (11):<\/strong> Climbing Stairs, Coin Change, Longest Increasing Subsequence, Longest Common Subsequence, Word Break, Combination Sum, House Robber, House Robber II, Decode Ways, Unique Paths, Jump Game.<\/li>\n<li><strong>Graph (8):<\/strong> Clone Graph, Course Schedule, Pacific Atlantic Water Flow, Number of Islands, Longest Consecutive Sequence, Alien Dictionary, Graph Valid Tree, Number of Connected Components in an Undirected Graph.<\/li>\n<li><strong>Interval (5):<\/strong> Insert Interval, Merge Intervals, Non-overlapping Intervals, Meeting Rooms, Meeting Rooms II.<\/li>\n<li><strong>Linked list (6):<\/strong> Reverse Linked List, Linked List Cycle, Merge Two Sorted Lists, Merge k Sorted Lists, Remove Nth Node From End of List, Reorder List.<\/li>\n<li><strong>Matrix (4):<\/strong> Set Matrix Zeroes, Spiral Matrix, Rotate Image, Word Search.<\/li>\n<li><strong>String (10):<\/strong> Longest Substring Without Repeating Characters, Longest Repeating Character Replacement, Minimum Window Substring, Valid Anagram, Group Anagrams, Valid Parentheses, Valid Palindrome, Longest Palindromic Substring, Palindromic Substrings, Encode and Decode Strings.<\/li>\n<li><strong>Tree (14):<\/strong> Maximum Depth of Binary Tree, Same Tree, Invert Binary Tree, Binary Tree Maximum Path Sum, Binary Tree Level Order Traversal, Serialize and Deserialize Binary Tree, Subtree of Another Tree, Construct Binary Tree from Preorder and Inorder Traversal, Validate Binary Search Tree, Kth Smallest Element in a BST, Lowest Common Ancestor of a BST, Implement Trie, Add and Search Word, Word Search II.<\/li>\n<li><strong>Heap (2):<\/strong> Top K Frequent Elements, Find Median from Data Stream.<\/li>\n<\/ul>\n<h2>Are you ready for it?<\/h2>\n<p>You can start the Blind 75 when you can write loops, use lists and dictionaries, and write a simple recursive function in your chosen language without looking things up. If not, spend a few weeks on fundamentals first. Our lessons on <a href=\"https:\/\/algocademy.com\/link\/?lang=py&amp;problem=hash-map&amp;solution=1\">hash maps<\/a>, <a href=\"https:\/\/algocademy.com\/link\/?lang=py&amp;problem=recursion&amp;solution=1\">recursion<\/a> and <a href=\"https:\/\/algocademy.com\/link\/?lang=py&amp;problem=time-complexity&amp;solution=0\">time complexity<\/a> cover the prerequisites. Use whichever language you will interview in; Python is the shortest to write, but Java, C++ and JavaScript are all accepted by most companies.<\/p>\n<h2>An 8-week plan, by pattern<\/h2>\n<p>Do the problems grouped by technique, not in random order. Doing five similar problems in a row is what makes a pattern stick. This plan assumes about 5 to 6 problems a week for the first weeks and 10 later, which adds up to 75; adjust it to your time.<\/p>\n<table>\n<thead>\n<tr>\n<th>Week<\/th>\n<th>Topics<\/th>\n<th>Focus<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td>1<\/td>\n<td>Arrays, hashing (Contains Duplicate, Valid Anagram, Two Sum, Group Anagrams, Top K Frequent, Product of Array Except Self)<\/td>\n<td>Hash maps, counting<\/td>\n<\/tr>\n<tr>\n<td>2<\/td>\n<td>Two pointers, sliding window, stack (Valid Palindrome, 3Sum, Container With Most Water, Best Time to Buy and Sell Stock, Longest Substring Without Repeating, Valid Parentheses)<\/td>\n<td>Pointers moving over one array<\/td>\n<\/tr>\n<tr>\n<td>3<\/td>\n<td>Binary search, linked lists<\/td>\n<td>Rotated arrays, pointer manipulation<\/td>\n<\/tr>\n<tr>\n<td>4<\/td>\n<td>Trees (depth, same tree, invert, level order, validate BST)<\/td>\n<td>Recursion, DFS and BFS<\/td>\n<\/tr>\n<tr>\n<td>5<\/td>\n<td>More trees, tries, heap, intervals<\/td>\n<td>Trie structure, sorting intervals<\/td>\n<\/tr>\n<tr>\n<td>6<\/td>\n<td>Graphs and matrix problems<\/td>\n<td>BFS, DFS on grids, topological sort<\/td>\n<\/tr>\n<tr>\n<td>7<\/td>\n<td>Dynamic programming<\/td>\n<td>State, recurrence, base cases<\/td>\n<\/tr>\n<tr>\n<td>8<\/td>\n<td>Remaining problems, bit manipulation, review<\/td>\n<td>Redo the ones you failed<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<h2>How to work through a problem<\/h2>\n<ol>\n<li><strong>Try for 20 to 30 minutes.<\/strong> Restate the problem, work a small example by hand, and write the brute-force idea first.<\/li>\n<li><strong>Look at a hint, not the solution.<\/strong> A hint usually names the pattern (&#8220;use a hash map&#8221;, &#8220;two pointers&#8221;).<\/li>\n<li><strong>Read the solution and understand why it works<\/strong>, including its time and space complexity.<\/li>\n<li><strong>Close it and write it yourself.<\/strong> Without this step you only remember that you read something.<\/li>\n<li><strong>Repeat the problem after a few days<\/strong> and again after two weeks. Keep a list of the ones you failed.<\/li>\n<li><strong>Write down the pattern<\/strong> in one line (&#8220;longest substring with a constraint: sliding window with a map of last positions&#8221;).<\/li>\n<\/ol>\n<h2>Two examples<\/h2>\n<p>These show what &#8220;learn the pattern, not the answer&#8221; looks like in practice. Both are Python and were run to produce the outputs shown.<\/p>\n<h3>Two Sum: trade space for time<\/h3>\n<p>The brute force checks every pair in O(n&sup2;). A hash map storing the values you have seen lets you check, for each number, whether its complement already appeared, in O(n) time. The same &#8220;remember what you have seen&#8221; idea powers Contains Duplicate, Group Anagrams and Longest Consecutive Sequence.<\/p>\n<pre><code class=\"language-python\">def two_sum(nums, target):\n    seen = {}                      # value -> index\n    for i, x in enumerate(nums):\n        if target - x in seen:\n            return [seen[target - x], i]\n        seen[x] = i\n    return []\n\nprint(two_sum([2, 7, 11, 15], 9))  # [0, 1]\nprint(two_sum([3, 2, 4], 6))       # [1, 2]\n<\/code><\/pre>\n<h3>Longest substring without repeating characters: sliding window<\/h3>\n<p>Keep a window <code>[start, i]<\/code> with no repeated character. When the new character already appears inside the window, move <code>start<\/code> just past its previous position. Each character is visited once, so it is O(n).<\/p>\n<pre><code class=\"language-python\">def length_of_longest_substring(s):\n    last = {}                      # char -> last index\n    start = best = 0\n    for i, ch in enumerate(s):\n        if ch in last and last[ch] >= start:\n            start = last[ch] + 1\n        last[ch] = i\n        best = max(best, i - start + 1)\n    return best\n\nprint(length_of_longest_substring(\"abcabcbb\"))  # 3\nprint(length_of_longest_substring(\"bbbbb\"))     # 1\nprint(length_of_longest_substring(\"pwwkew\"))    # 3\n<\/code><\/pre>\n<p>The condition <code>last[ch] &gt;= start<\/code> is the part people forget: a character seen earlier but outside the current window must not move the start. If you want more practice with this pattern, there is a <a href=\"https:\/\/algocademy.com\/link\/?lang=py&amp;problem=longest-subarray-without-reapeating&amp;solution=4\">sliding window version of this problem<\/a> in our Python course.<\/p>\n<h2>Common mistakes<\/h2>\n<ul>\n<li><strong>Memorizing solutions.<\/strong> If you can only reproduce the code, a small twist in the interview breaks you. Be able to explain why each line is there.<\/li>\n<li><strong>Doing the list in order.<\/strong> Group by pattern instead, as in the plan above.<\/li>\n<li><strong>Skipping hard topics.<\/strong> Many people leave dynamic programming and graphs for last and then rush them. Give them real weeks.<\/li>\n<li><strong>Never repeating problems.<\/strong> One pass is not enough for most people. The second attempt, a week later, is where the learning shows.<\/li>\n<li><strong>Ignoring complexity.<\/strong> For every solution, state time and space complexity out loud.<\/li>\n<li><strong>Practicing silently.<\/strong> In the interview you must talk. Explain your approach as you code, and add a few mock interviews near the end. See <a href=\"https:\/\/algocademy.com\/blog\/top-online-platforms-for-practicing-coding-interview-questions-a-comprehensive-guide\/\">platforms for practicing coding interview questions<\/a> for ways to do that.<\/li>\n<\/ul>\n<h2>After the Blind 75<\/h2>\n<p>If you still have time, do the company-tagged problems for the companies you are interviewing at (this needs LeetCode Premium or another source), add more problems on your weakest topics, and practice under a timer with 45 minutes per problem. Also keep in mind that many companies ask more than algorithm questions: system design, behavioral rounds and sometimes practical coding. Our post on <a href=\"https:\/\/algocademy.com\/blog\/does-leetcode-actually-prepare-you-for-real-world-coding\/\">whether LeetCode prepares you for real-world coding<\/a> discusses what the problems do and do not test. If you want guided practice on the same patterns, <a href=\"https:\/\/app.algocademy.com\/\">AlgoCademy<\/a> has lessons on two pointers, sliding window, hash tables, trees, graphs and dynamic programming, where problems are introduced with explanations before the harder versions.<\/p>\n","protected":false},"excerpt":{"rendered":"<p>What the Blind 75 LeetCode list contains, who it suits, an 8-week study plan by topic, two worked Python examples, and what to do after finishing it.<\/p>\n","protected":false},"author":1,"featured_media":804,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[23],"tags":[],"class_list":["post-806","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-problem-solving"],"_links":{"self":[{"href":"https:\/\/algocademy.com\/blog\/wp-json\/wp\/v2\/posts\/806"}],"collection":[{"href":"https:\/\/algocademy.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/algocademy.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/algocademy.com\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/algocademy.com\/blog\/wp-json\/wp\/v2\/comments?post=806"}],"version-history":[{"count":2,"href":"https:\/\/algocademy.com\/blog\/wp-json\/wp\/v2\/posts\/806\/revisions"}],"predecessor-version":[{"id":8703,"href":"https:\/\/algocademy.com\/blog\/wp-json\/wp\/v2\/posts\/806\/revisions\/8703"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/algocademy.com\/blog\/wp-json\/wp\/v2\/media\/804"}],"wp:attachment":[{"href":"https:\/\/algocademy.com\/blog\/wp-json\/wp\/v2\/media?parent=806"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/algocademy.com\/blog\/wp-json\/wp\/v2\/categories?post=806"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/algocademy.com\/blog\/wp-json\/wp\/v2\/tags?post=806"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}