The 27 DSA patterns coding interviews actually test

You do not need to solve a thousand problems for a coding interview. You need to recognise which of about thirty shapes a new problem has, and know the template for that shape well enough to adapt it under time pressure. That is the whole game, and it is why the pattern track on this site exists.

What a pattern is

A pattern is a reusable shape of solution. "Sliding window" is not one problem; it is the idea that a contiguous window over an array can be moved by its edges instead of rebuilt from scratch, and that idea solves Longest Substring Without Repeating Characters, Minimum Window Substring, Permutation in String and dozens more that are worded nothing alike. Once the shape is familiar, a new problem stops being new.

Interviews reuse a small set of these shapes because interviewers reuse a small set of problems. That makes patterns the highest-value thing to study, and the reason so many candidates plateau: solving problems one at a time never builds the recognition step.

The 27, in learning order

The track has 27 patterns, each with a runnable template and six LeetCode problems chosen to teach it, easiest first. The order matters. Arrays and strings come first because sliding window, two pointers and hashing turn up inside almost every later pattern. Graphs and dynamic programming come last because they assume the earlier ones.

1. Arrays and strings: sliding window, two pointers, hashing and frequency maps, prefix sum, difference array.
2. Searching: binary search on sorted data, binary search on the answer.
3. Stacks, queues and heaps: monotonic stack, monotonic queue, heap and top K.
4. Sorting-based: intervals, greedy scheduling.
5. Linked lists: fast and slow pointers, linked list manipulation.
6. Trees: tree DFS, tree BFS, binary search tree problems.
7. Recursion: backtracking basics, backtracking with constraints.
8. Graphs: BFS and DFS, topological sort, union find, shortest path, minimum spanning tree.
9. Specialised: trie, bit manipulation, 1D dynamic programming.

That is 161 distinct problems (Top K Frequent Elements appears twice because it teaches both hashing and heaps). 110 of them are in the curated 370 on this site, with their own write-up, worked examples and an in-browser editor.

How to use it

Pick one pattern. Read the "when to reach for it" signals until you could name them from memory, then read the template and run it in the editor with the sample input. Only then open the six problems, in order. The first two should feel like the template with a twist; by the fifth or sixth you should be adapting the template without looking at it. If you cannot, go back to the template rather than forward to the next problem.

Signed in, every pattern page shows which of its six you have already solved, so the track doubles as a checklist.

Where the list came from

Every problem number on these pages was checked against LeetCode's own public problem index before it went on the site, and every template was executed against the sample cases of the problem it was written for. Seven of the 161 are LeetCode Premium problems; they are labelled, not hidden, because they are the standard problem for that pattern and a candidate should know they exist.

What patterns do not replace

Patterns build recognition. They do not build the habit of reading a problem carefully, working an example by hand, or stating complexity before coding. Those come from doing the problems, which is why each pattern ships with six of them rather than a summary you could read in a minute. Start at pattern one.