Coding Interview Prep Checklist

Track 14 data structure and algorithm topics for coding interviews, with patterns, complexities and a 7-step method. Progress saves in your browser.

The interactive tool loads here when JavaScript runs.

About this tool

What is Coding Interview Prep?

This checklist covers the 14 topic areas that most coding interview problems are drawn from: strings, arrays, heaps, binary search, two pointers, sliding window, BFS and DFS, hash tables, linked lists, trees, graphs, dynamic programming, greedy algorithms and backtracking. Each card opens a short reference with the common problem patterns, how to practise the topic and its typical time complexity.

Above the checklist is a seven-step problem-solving method, from restating the problem to optimizing the finished code. Tick a topic when you can solve its standard problems without hints, and the progress bar shows how many of the 14 you have covered.

It is a study tracker, not a problem bank or a code runner. You still need to solve real problems in an editor, out loud, against a clock. Ticks are stored in this browser only, so they will not follow you to another device.

  • 14 topic cards with common patterns, practice advice and time complexity
  • Seven-step problem-solving framework for any coding question
  • Progress bar and percentage based on ticked topics
  • Reset Progress and Mark All Complete buttons
  • Progress saved in your browser, no account needed
Read the guide: Coding Interview Prep: What Gets Scored and a 6-Week Plan

Updated

How to use Coding Interview Prep

  1. Read the Systematic Problem-Solving Framework once and practise saying each of the seven steps out loud on your next problem.
  2. Click the info icon on a topic card to see its common patterns, how to master it and its time complexity.
  3. Solve three to five standard problems for that topic in your own editor, timed.
  4. Tick the topic's checkbox when you can solve a new problem of that type without hints. The badge and progress bar update immediately.
  5. Use Reset Progress to start a fresh pass before a new interview cycle, or Mark All Complete if you only want the reference cards.

Worked examples

Halfway through the list

Input

Tick Arrays, Hash Tables, Two Pointer, Sliding Window, Binary Search, Linked Lists and Trees

Output

7 / 14 in Progress Overview, 50% Complete in the header badge

Progress counts only the 14 topics on the page, so the percentage is always done divided by 14, rounded to the nearest whole number. One topic is worth about 7%.

Recognising a pattern from the cards

Input

Problem: longest substring without repeating characters

Output

Sliding Window card: variable window, hash map of last-seen index, O(n) time

The Sliding Window card lists this exact problem under Common Patterns. Expand the right edge, and when a character repeats, move the left edge past its previous position.

Background and insight

Coding rounds test a narrower set of things than people fear. An interviewer is usually scoring four signals: did you understand and clarify the problem, did you find a workable approach and explain it, did you write correct code that someone else could read, and did you test it yourself before being told about the bug. Getting the optimal solution helps, but a clean brute force with a clear explanation of how to improve it often scores better than a half-finished clever one.

Pattern recognition is what separates a 45-minute struggle from a 20-minute solve. "Longest substring with some property" is almost always a sliding window. "Sorted input, find a pair" is two pointers or binary search. "Shortest path with equal edge weights" is BFS. "Count the ways" or "minimum cost" over choices that overlap is dynamic programming. The topic cards are grouped that way on purpose.

Know your complexities cold, and know the worst cases people get wrong. Quicksort averages O(n log n) but degrades to O(n²) on bad pivots. Hash table lookups are O(1) on average and O(n) in the worst case. Building a heap from an array is O(n), not O(n log n). Dijkstra with a binary heap is O((V + E) log V) and does not work with negative edge weights.

Common use cases

  • Planning a four to eight week study plan

    Use the 14 topics as the syllabus and aim for two or three per week, leaving the last week for mixed mock interviews.

  • Finding your weak areas

    Topics you cannot tick honestly after a first pass are where your next week of practice should go.

  • Last-minute review

    Open the cards the night before to refresh patterns and complexities without starting new problems.

  • Mentoring a candidate

    Walk a junior engineer through the seven-step framework and use the topic list to agree on what they practise next.

Tips and limitations

  • Talk while you think. Silence for five minutes gives the interviewer nothing to score, even if you get the answer.
  • Write the brute force first if the optimal approach is not obvious, state its complexity, then improve it.
  • Test your own code with a small example and one edge case (empty input, one element, duplicates) before saying you are done.
  • Dynamic programming and graphs take the longest to learn. Start them early rather than leaving them for the last week.
  • Ticks live in this browser's localStorage. Clearing site data or switching browsers resets them.

Sources and further reading

  1. Quicksort, The Computer Journal. C. A. R. Hoare's 1962 paper
  2. A note on two problems in connexion with graphs, Numerische Mathematik. Dijkstra's 1959 shortest-path algorithm
  3. Algorithm 245: Treesort, Communications of the ACM. Floyd's bottom-up heap construction, the source of linear-time heapify

Frequently asked questions

How many weeks do I need to prepare for a coding interview?

Most working engineers need four to eight weeks of steady practice, around 8 to 10 hours a week. If you already solve algorithm problems regularly, two to three weeks of review and mock interviews is often enough. Spend the first half learning patterns topic by topic and the second half on mixed, timed problems.

How many LeetCode problems should I solve before an interview?

There is no magic number, but 100 to 150 well-chosen problems spread across all 14 topics covers most of what interviews ask. Solving 300 problems from two topics is worse preparation than 120 spread evenly. Review problems you failed a few days later and solve them again from scratch.

What is the worst-case time complexity of quicksort?

Quicksort is O(n²) in the worst case, which happens when pivots repeatedly split the array very unevenly, for example a naive first-element pivot on already sorted input. Its average case is O(n log n). Randomized or median-of-three pivots make the worst case very unlikely in practice.

Is it fine to start with a brute force solution in a coding interview?

Yes, if you say that it is a brute force, state its complexity and then look for improvements. Interviewers would rather see a working O(n²) solution and a clear path to O(n) than ten minutes of silence. Do not code the brute force fully if you already see the better approach.

Which programming language should I use for coding interviews?

Use the language you write fastest and most correctly. Python is popular because its syntax is short and it has built-in heaps, deques and dictionaries, but a fluent Java or C++ solution is just as good. Check that the company allows your choice and that you know its standard library.

Where does Coding Interview Prep save my progress?

Your ticks are saved in your browser's localStorage under the key coding-interview-prep. Nothing is sent to a server, so progress does not sync across devices and is lost if you clear site data for this website.

Is there an in-depth guide to Coding Interview Prep?

Yes. “Coding Interview Prep: What Gets Scored and a 6-Week Plan” covers the background, how it works, common pitfalls and worked examples. Read the full guide.