Blind 75 LeetCode Problems: Complete Guide with Patterns and Strategy

The Blind 75 exists because a former Blind engineer realized most people waste time grinding 500+ LeetCode problems when about 75 carefully chosen ones cover every major pattern you'll see in interviews. No redundancy, no filler. Just the patterns that actually show up.

Here's the thing — the list isn't magic. It works because it forces you to learn patterns, not memorize solutions. Once you've internalized the 14 categories, new problems start looking like variations of ones you've already solved.

Why the Blind 75 Works

Most LeetCode problems are variations of about 14 core patterns. The Blind 75 picks the most representative problems from each pattern so you build recognition, not rote memory. Solve Two Sum and you understand hash map lookups. Solve Merge Intervals and you understand interval sorting. The transfer is the point.

Let's be honest: if you try to grind 300 problems without structure, you'll burn out and retain maybe 20% of it. The Blind 75 gives you structure.

The 14 Categories

1. Arrays and Hashing

The pattern: Use hash maps to trade space for time. Sort when order doesn't matter. Two-pointer when the array is sorted.

Key problems: Two Sum, Best Time to Buy and Sell Stock, Contains Duplicate, Product of Array Except Self.

# Two Sum — the quintessential hash map problem
def two_sum(nums, target):
    seen = {}
    for i, num in enumerate(nums):
        complement = target - num
        if complement in seen:
            return [seen[complement], i]
        seen[num] = i
    return []

One pass, O(n) time. The hash map stores what you've seen so far and lets you look up complements in O(1). This pattern — "have I seen the thing I need?" — shows up constantly.

Time to spend: 3-4 days. These are warm-up problems but the patterns are foundational.

2. Two Pointers

The pattern: One pointer at each end, moving inward based on a condition. Works on sorted arrays or when you need to compare pairs.

Key problems: Valid Palindrome, 3Sum, Container With Most Water.

# Container With Most Water — classic two-pointer
def max_area(height):
    left, right = 0, len(height) - 1
    result = 0
    while left < right:
        area = min(height[left], height[right]) * (right - left)
        result = max(result, area)
        if height[left] < height[right]:
            left += 1
        else:
            right -= 1
    return result

Move the shorter side inward because that's the only way to potentially increase the area. Greedy + two pointers.

Time to spend: 2 days.

3. Sliding Window

The pattern: Maintain a window over a contiguous subarray/substring. Expand the right side, shrink the left when a condition breaks.

Key problems: Longest Substring Without Repeating Characters, Minimum Window Substring.

# Longest Substring Without Repeating Characters
def length_of_longest_substring(s):
    seen = {}
    left = 0
    result = 0
    for right, char in enumerate(s):
        if char in seen and seen[char] >= left:
            left = seen[char] + 1
        seen[char] = right
        result = max(result, right - left + 1)
    return result

Time to spend: 2 days.

4. Stack

The pattern: Last-in-first-out for matching (parentheses) or maintaining monotonic order.

Key problems: Valid Parentheses, Min Stack.

Time to spend: 1 day.

5. Binary Search

The pattern: Halve the search space each step. Not just for sorted arrays — works anywhere you can define a monotonic condition.

Key problems: Search in Rotated Sorted Array, Find Minimum in Rotated Sorted Array.

Time to spend: 2 days.

6. Linked List

The pattern: Two-pointer (fast/slow), dummy head nodes, and reversing in-place.

Key problems: Reverse Linked List, Merge Two Sorted Lists, Linked List Cycle.

# Reverse Linked List — iterative
def reverse_list(head):
    prev = None
    curr = head
    while curr:
        next_node = curr.next
        curr.next = prev
        prev = curr
        curr = next_node
    return prev

Three pointers, one pass. This reversal pattern is a building block for more complex linked list problems like Reverse Nodes in k-Group.

Time to spend: 2 days.

7. Trees

The pattern: Recursion. Almost every tree problem is "do something with root, then recurse on left and right subtrees."

Key problems: Maximum Depth, Same Tree, Invert Binary Tree, Validate BST, Binary Tree Level Order Traversal.

# Validate BST — pass down valid range
def is_valid_bst(root, lo=float('-inf'), hi=float('inf')):
    if not root:
        return True
    if root.val <= lo or root.val >= hi:
        return False
    return (is_valid_bst(root.left, lo, root.val) and
            is_valid_bst(root.right, root.val, hi))

The trick is passing down the valid range. Each node must be within (lo, hi), and the range narrows as you recurse.

Time to spend: 4 days. Trees are heavily tested.

8. Tries

The pattern: Prefix tree for string operations. Each node represents a character, paths represent words.

Key problems: Implement Trie, Word Search II.

Time to spend: 1-2 days.

9. Heap / Priority Queue

The pattern: When you need the k-th largest/smallest, or need to efficiently track min/max of a dynamic set.

Key problems: Top K Frequent Elements, Find Median from Data Stream.

import heapq

# Top K Frequent Elements
def top_k_frequent(nums, k):
    count = {}
    for num in nums:
        count[num] = count.get(num, 0) + 1
    return heapq.nlargest(k, count.keys(), key=count.get)

Time to spend: 2 days.

10. Backtracking

The pattern: Build candidates incrementally, abandon ("backtrack") as soon as a constraint is violated.

Key problems: Combination Sum, Word Search.

Time to spend: 2 days.

11. Graphs

The pattern: BFS for shortest paths, DFS for exhaustive exploration, Union-Find for connected components.

Key problems: Clone Graph, Course Schedule, Number of Islands.

# Course Schedule — cycle detection with DFS
def can_finish(num_courses, prerequisites):
    graph = {i: [] for i in range(num_courses)}
    for course, pre in prerequisites:
        graph[course].append(pre)

# 0 = unvisited, 1 = in current path, 2 = done
    state = [0] * num_courses

def has_cycle(node):
        if state[node] == 1:
            return True
        if state[node] == 2:
            return False
        state[node] = 1
        for neighbor in graph[node]:
            if has_cycle(neighbor):
                return True
        state[node] = 2
        return False

return not any(has_cycle(i) for i in range(num_courses))

Three-state DFS coloring: unvisited, in-progress, completed. If you revisit an in-progress node, that's a cycle.

Time to spend: 3 days.

12. Dynamic Programming

The pattern: Overlapping subproblems + optimal substructure. Start with recursion, add memoization.

Key problems: Climbing Stairs, Coin Change, Longest Increasing Subsequence, Word Break.

Time to spend: 5 days. DP gets its own extended period because the patterns are diverse.

13. Intervals

The pattern: Sort by start time, then merge or compare adjacent intervals.

Key problems: Merge Intervals, Non-overlapping Intervals.

# Merge Intervals
def merge(intervals):
    intervals.sort(key=lambda x: x[0])
    merged = [intervals[0]]
    for start, end in intervals[1:]:
        if start <= merged[-1][1]:
            merged[-1][1] = max(merged[-1][1], end)
        else:
            merged.append([start, end])
    return merged

Sort, then sweep. If the current interval overlaps with the last merged one, extend it. Otherwise, start a new merged interval. This pattern handles almost every interval problem.

Time to spend: 1-2 days.

14. Bit Manipulation

The pattern: XOR for finding unique elements, bit shifts for multiplication/division by 2.

Key problems: Sum of Two Integers, Number of 1 Bits, Counting Bits.

Time to spend: 1 day.

The 5-Week Study Plan

At 2 problems per day, you can finish the entire Blind 75 in about 5 weeks:

• Week 1: Arrays, Two Pointers, Sliding Window (14 problems)
• Week 2: Stack, Binary Search, Linked List (10 problems)
• Week 3: Trees, Tries (12 problems)
• Week 4: Heap, Backtracking, Graphs (14 problems)
• Week 5: Dynamic Programming, Intervals, Bit Manipulation (15 problems)

Spend 45-60 minutes per problem max. If you can't solve it in that time, read the solution, understand the pattern, and re-solve it from scratch the next day. The goal isn't to suffer — it's to build pattern recognition.

Common Mistakes

Grinding without reviewing. Solving a problem and never looking at it again is wasted effort. Review problems you struggled with after 3 days and again after a week. Jumping to hard problems. If you can't solve the easy version of a pattern, the medium version won't click either. Go in order within each category. Memorizing solutions instead of patterns. If you can explain why Two Sum uses a hash map (trading space for time to avoid O(n^2) nested loops), you understand the pattern. If you just memorized the code, you'll freeze on a slight variation. Skipping behavioral prep. Most FAANG rejections are behavioral, not technical. Don't spend 100% of your time on LeetCode.

If you want a structured environment to work through these patterns with hints and explanations instead of just raw LeetCode, CodeUp organizes problems by pattern and gives you step-by-step guidance when you're stuck — which is way more effective than staring at a blank editor for an hour.