Everything the patterns assume you already know

The pattern pages move fast: they expect you to know what O(n) means, when to reach for a dict, and how a recursive function unwinds. This page teaches exactly those basics, from zero, with the same step-through visualizers. Skip any section you already know.

1. How this site teaches

Most interview problems are variations of about two dozen ideas called patterns: two pointers, sliding window, BFS, dynamic programming and so on. Each pattern has its own page with the same ten sections: what it's for, how it works, how to spot it, when not to use it, a Python template, memory hooks, solved LeetCode problems, common mistakes, a quiz and a practice list.

1. Learn the foundations here. Big-O, the data structures, recursion and the Python you'll actually type.
2. Follow the beginner path. It orders the 24 patterns from gentlest to hardest.
3. On each pattern page, solve the Start here problems first. They're the gentlest 2–3 problems for that pattern.
4. Press Play on every visualizer. Watching the pointers, windows and stacks move is faster than reading about them. Inside a visualizer, ← → step and space plays.
5. Hover or tap a dotted word on any page to see a one-line definition. They're all collected in the glossary.

2. Big-O: is my solution fast enough?

Big-O describes how the number of steps grows as the input size n grows. It ignores constants and small terms, because for big inputs only the shape of the growth matters. You find it by counting how many times the work repeats:

def has_duplicate_slow(nums):          # O(n²): compares every pair
    for i in range(len(nums)):
        for j in range(i + 1, len(nums)):
            if nums[i] == nums[j]:
                return True
    return False

def has_duplicate_fast(nums):          # O(n): one pass, O(1) set lookups
    seen = set()
    for x in nums:
        if x in seen:
            return True
        seen.add(x)
    return False

Drag the slider to see why this matters. Python does roughly ten million simple steps per second, and LeetCode usually allows a second or two.

Space complexity is the same idea for memory: how much extra storage you use as n grows. has_duplicate_fast trades O(n) memory (the set) for O(n) time. That trade, spending memory to save time, is behind half the patterns on this site.

3. The core data structures

A data structure is a way of storing values so that the operations you need are cheap. Picking the right one is often the whole solution. These are the ones interviews use, and what they cost:

Stack and queue

Both hold items in a line. A stack adds and removes at the same end, so the newest item leaves first. A queue adds at the back and removes from the front, so the oldest leaves first.

Hash map: counting and remembering

A dict jumps straight to a key's value instead of searching for it. That turns "have I seen this before?" from a loop into one step, which is why it fixes so many slow nested loops.

Linked list: rewiring pointers

Each node knows only its value and the next node. There's no index, so you walk from the head. In exchange, inserting needs no shifting: just change two pointers, in the right order.

Heap: the smallest item, always on top

A heap is a binary tree stored in a plain list, where every parent is smaller than its children. The smallest item is always at index 0. A push adds at the end and swaps upward; a pop moves the last item to the top and swaps it down. Each takes O(log n) because the tree's height is log n.

Trees and graphs

4. Recursion, one call at a time

A recursive function solves a problem by calling itself on a smaller version of it. Every recursive function has the same three parts:

1. Base case: the smallest input, answered directly. Without it the calls never stop.
2. Smaller step: call yourself on a smaller input (n − 1, the left child, the rest of the list).
3. Combine: trust that the smaller call returns the right answer, and build yours from it.

def factorial(n):
    if n == 1:                    # base case: answer directly
        return 1
    return n * factorial(n - 1)   # smaller step, then combine

Each call waits for the one it made. Python keeps the waiting calls on the call stack, a stack of paused calls with the newest on top:

When a function calls itself twice, the calls form a tree. Fibonacci is the classic example: fib(n) = fib(n − 1) + fib(n − 2). Watch how fib(2) is computed twice: that repeated work is exactly what dynamic programming removes by remembering answers (memoization).

def fib(n):
    if n <= 1:                    # base cases: fib(0) = 0, fib(1) = 1
        return n
    return fib(n - 1) + fib(n - 2)

Where you'll use it: tree traversal, DFS, backtracking and dynamic programming are all recursion with a twist.

5. The Python toolkit for interviews

You don't need much Python, but you need these few tools at your fingertips:

from collections import Counter, defaultdict, deque
import heapq

counts = Counter("banana")              # {'a': 3, 'n': 2, 'b': 1}
by_len = defaultdict(list)
for w in ["hi", "yo", "hey"]:
    by_len[len(w)].append(w)            # {2: ['hi', 'yo'], 3: ['hey']}

q = deque([1])                          # queue: add right, remove left
q.append(2)
first = q.popleft()                     # 1

h = []                                  # heap: smallest always at h[0]
for x in [5, 1, 4]:
    heapq.heappush(h, x)
smallest = heapq.heappop(h)             # 1

grid = [[0] * 3 for _ in range(2)]      # 2 rows x 3 columns, rows independent

6. How to read a LeetCode problem

Every LeetCode problem has the same parts, and each one gives you information:

1. The statement. Underline the input, the output and any words like sorted, contiguous, unique, at most k. Those words point to the pattern; the pattern finder lists them.
2. The examples. Work one by hand before coding. If you can't do it on paper, you can't code it.
3. The constraints. The size of n tells you the Big-O you need (see section 2). Value ranges tell you about negatives, zeros and overflow.
4. The function signature. You fill in a method of a class called Solution. LeetCode calls it with each test.

from typing import List, Optional

class Solution:                                  # LeetCode gives you this shell
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        ...                                      # your code goes here

# LeetCode's types, if you want to run tree or list problems yourself:
class ListNode:
    def __init__(self, val=0, next=None):
        self.val, self.next = val, next

class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val, self.left, self.right = val, left, right

# To test on your own computer, call it like LeetCode does:
print(Solution().twoSum([2, 7, 11, 15], 9))

• self is just there because it's a method; you can ignore it.
• List[int], Optional[TreeNode] and -> int are type hints: notes about what goes in and comes out. Python doesn't enforce them.
• "Return the answer modulo 10⁹ + 7" means return ans % 1_000_000_007; it keeps huge counts small.
• Problems marked Premium need a LeetCode subscription; on this site their statement and examples are written out so you can still learn them.

7. Your first problem: Two Sum, start to finish

Problem: given a list of numbers and a target, return the indices of the two numbers that add up to the target. Example: nums = [2, 7, 11, 15], target = 9 → [0, 1], because 2 + 7 = 9.

1. Understand. Exactly one answer exists; you can't use the same element twice; return indices, not values.
2. Brute force first. Try every pair: two nested loops, O(n²). Say it out loud in an interview; it shows you can solve it, and it gives you something to improve.
3. Find the wasted work. For each number x, the inner loop searches for target − x. Searching is what a hash map makes instant.
4. Improve. Walk once; for each x, check whether its partner target − x was already seen; otherwise remember x's index. O(n) time, O(n) space.
5. Test on the example and the edge cases: negatives, duplicates like [3, 3], the pair at the very end.

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        # Brute force, O(n²):
        # for i in range(len(nums)):
        #     for j in range(i + 1, len(nums)):
        #         if nums[i] + nums[j] == target:
        #             return [i, j]
        seen = {}                          # value -> index where we saw it
        for i, x in enumerate(nums):
            if target - x in seen:         # partner seen earlier: done
                return [seen[target - x], i]
            seen[x] = i                    # remember x for later numbers

That move, from "search again every time" to "remember what you've seen", is the Hash Map & Set pattern. Step through this exact solution, line by line, on its pattern page. This 5-step routine is the UMPIRE method: use it on every problem.

8. Self-check quiz

9. Glossary

Every dotted word on the site comes from this list. Hover or tap one anywhere to see its definition.

10. Where to go next