Speed Round

How it works

Each run deals ten questions drawn at random from a larger pool covering four topics: complexity (count the work), dynamic programming (reuse the states), Monte Carlo (price the error), and Python/pandas (move the data). Both the question order and each question's answer-choice order are shuffled every run, so repeat runs never play the same.

Every question gives you 20 seconds. A countdown runs in the corner and turns red in the last 5 seconds. Some questions include a code snippet to read. Click a choice to answer - the choice locks immediately, the correct answer is highlighted, and an explanation appears. If the clock hits zero before you answer, the question is marked as a timeout, which counts as wrong.

After each question you advance manually to the next. After the tenth, a results screen lists every question with a CORRECT or REVIEW tag, the prompt, and its explanation, so the misses become a study list. Run it again deals a fresh shuffled deck.

How scoring works

100 points per correct answer, for a maximum of 1,000 over the ten questions. The results screen shows your point total and the count of correct answers out of ten.

There is no speed bonus - answering with 19 seconds left and answering with 1 second left score the same 100. Timeouts score zero and are recorded as a miss in the review list.

Each answer is also recorded against the site-wide skill it maps to - complexity, dynamic-programming, monte-carlo, or coding-implementation for the pandas questions - so Speed Round attempts feed the same progress tracking as the rest of the site. A timeout is recorded as a revealed attempt rather than a wrong guess.

Twenty seconds is enough if you classify first

Every question here belongs to one of four topics, and the topic label is printed above the prompt. Let it set your mental toolkit before you read a word of the question: on a complexity question you are counting loop nests and data-structure operation costs; on a DP question you are looking for overlapping subproblems and state definitions; on a Monte Carlo question the answer almost always routes through the 1 over root N error law; on a pandas question you are matching an operation - groupby, merge, vectorized arithmetic - to a described data movement.

Since there is no speed bonus, the clock is a ceiling, not a target. The winning pace is deliberate reading for the first 10 to 12 seconds, then a decision - not a snap answer at second three. The timer punishes only indecision past twenty seconds, and a timeout is strictly worse than a guess: both score zero, but a guess is right some of the time.

Complexity questions: count operations, not lines

The reliable method under time pressure is to find the loops and multiply their trip counts, then price any non-trivial operation inside them - a sort is n log n, a hash lookup is constant, an array search or splice is linear. Nested loops over the same n multiply to n squared; a loop that halves its range each iteration is log n; a loop over n doing a log n operation inside is n log n.

When a snippet is shown, resist simulating it element by element - twenty seconds does not allow it and the question never requires it. Structure is the answer: how many times does the innermost line run, as a function of input size? That single number is the complexity.

Turn the review screen into the actual training

The results list tags every miss REVIEW and prints the explanation beside the prompt. That list, not the score, is the product of a run: each miss identifies a specific fact or pattern you reached for and did not have at speed. Read every REVIEW explanation before rerunning - the pool is finite, so misses you study genuinely come back around.

Rerun until the constraint is reading speed rather than knowledge. Because questions and choice orders reshuffle each run, a repeated question still tests recall of the idea rather than memory of which button was correct - the shuffle is what makes grinding this game honest.

A worked example

A representative complexity question: the topic tag reads Complexity, and the prompt shows a snippet with an outer loop over n elements which, for each element, calls .includes() on an array that grows to size n, with choices O(n), O(n log n), O(n squared), and O(1).

Classify first: complexity, so count the work. The outer loop runs n times. The inner operation, .includes() on an array, is a linear scan - not a constant-time lookup, which is exactly the trap the choices are built around. Linear work done n times is O(n squared). Lock it in at around second ten.

The explanation confirms it and typically adds the fix - a Set makes membership checks constant time, dropping the whole thing to O(n). That fix is itself a recurring answer elsewhere in the pool, which is how the deck teaches: the correction to one question is the answer to another. Score so far: 100, clock never mattered.

Common mistakes

• Letting the clock expire. A timeout scores zero, same as a wrong answer, but a wrong guess had a chance - always click something by second eighteen.

• Rushing because the timer exists. There is no speed bonus; only accuracy scores. Use the full time when you need it.

• Ignoring the topic tag and reading the question cold. The tag halves the search space before you start.

• Skipping the review screen. The misses-with-explanations list is the training payload; the score is just the receipt.

• Simulating code snippets line by line instead of reading their structure. Trip counts times inner-operation cost answers every complexity question in the pool.

Why interviews test this

Rapid-fire technical screens - phone rounds, online assessments, the opening minutes of an onsite - test recognition speed rather than derivation depth: can you see that a snippet is quadratic, that a problem is DP-shaped, that a simulation needs 4x the paths, without warm-up time. Speed Round is a direct rehearsal for that format, including the pressure of a visible clock.

The pandas questions earn their place because quant dev and quant research interviews increasingly include data-manipulation questions alongside classic algorithms - moving a groupby or a merge through your head at speed is now table stakes.