Algorithm Arena · Speed Round
Algorithm Speed Round - Timed CS Quiz Guide
Ten multiple-choice questions, twenty seconds each, drawn from a shuffled pool spanning complexity, dynamic programming, Monte Carlo, and pandas.
What is a technical screen?
A technical screen is an early-stage interview round, typically 30 to 45 minutes, held by phone, video, or an online assessment platform, designed to filter candidates before a company commits the much larger cost of a full onsite interview loop. It sits ahead of the deeper, open-ended problem-solving rounds, and its job is narrower: confirm baseline competence quickly, across many candidates, at low cost per candidate.
The format reflects that purpose. Screens favor short, self-contained questions - multiple choice, brief coding exercises, quick definitions - graded automatically or scanned quickly by a reviewer, over the extended, exploratory problems that define an onsite round. A candidate is rarely asked to design a system end to end in a screen; they are asked to demonstrate that foundational pieces are already fluent.
What a screen measures is recognition speed. An experienced practitioner sees a nested loop and knows it is quadratic without consciously re-deriving why, sees a check-then-act sequence and knows it can race, sees a recurrence and knows it is DP-shaped - all near-instantly, because the pattern is already internalized. A screen under a visible clock is built to distinguish that fluency from someone who could work out the same answer given unlimited time.
Firms rely on screens because they are cheap to run at scale and correlate reasonably well with the baseline competence an onsite round assumes going in; a candidate who cannot clear a screen's narrow, well-defined questions is unlikely to have the deeper skills the onsite round is designed to probe.
Performance on a screen improves through repetition of the underlying patterns. Reviewing exactly which questions were missed and why converts an unfamiliar pattern into something recognized on sight the next time, which is the skill being tested.
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. The winning pace is deliberate reading for the first 10 to 12 seconds, then a decision. 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
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 training
The results list tags every miss REVIEW and prints the explanation beside the prompt. That list 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 come back around.
Rerun until reading speed is the only thing holding you back. Because questions and choice orders reshuffle each run, a repeated question still tests recall of the idea, since you cannot remember which button was correct. The shuffle is what makes grinding this game work.
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: 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.
Play Speed Round on Outcry
Speed Round is free to play on Outcry, in the Algorithm Arena section, and every run is timed and scored. Read the guide once, then play Speed Round and check your score against the strategy above. The guide book has a written guide for every other game, and the practice hub and mock assessments put the same skills under a real screen's clock.