The Practical Coding Round

Scale AI's coding screen is a build. It runs on HackerRank for around fifty minutes and hands you a realistic task with a written spec. You parse some structured input, compute something specific over it, and print output in an exact shape. Nobody hides a named-algorithm trick in it, though collections, dictionaries, and interval logic still sit underneath the realistic framing. The screen checks how closely you read. Build exactly what the spec asks, named edges included, and print it in exactly the shape it wants.

The Scale AI angle

Most of the test is comprehension, and it happens before you write a line. Candidates lose this round in two ways. Some pattern-match the prompt to a LeetCode archetype that isn't there. Others over-optimize a solution that only needed to be correct and clear. The screen rewards the ordinary engineering loop done well. Read the whole spec, model the data, write straightforward code, and reach a working, well-formatted result with time left to clean it. A later requirement often reuses an earlier one's output, so misreading the first line quietly breaks the second. In your strongest language, drill collections, dates, strings, and intervals, and rehearse hitting an exact output contract. The trick to a hard graph problem won't come up.

Read the spec before you type

Run the same loop on every practical prompt, in order. Read the whole spec first. The second part usually consumes the first part's result, and the ending decides how you model the start. Then name the input model out loud. It might be records grouped by a key, intervals you sort and sweep, or commands applied to a small piece of state. Only then write plain code for that model, and walk the edge cases the spec names by hand. Skip ahead to code from the surface story and you'll build the wrong data model, then discover at minute forty that the output shape never fit.

Green tests don't end the grading. A candidate can solve every part, watch each case pass, and still be turned down, because Scale grades the engineering under the checkmark. The interviewer is asking whether a teammate could own the code, whether the data model fits the domain, and whether your choices hold up when they ask why. Progress is weighted heavily, so get a working solution early and make it legible after. Each problem below is an ordinary structure dressed as a realistic build, with the output contract treated as law.

Event records and quiet time per zone

The most representative Scale shape hands you structured records with timestamps and identifiers and asks for one specific quantity. Here the records are activity events, each tagged with a zone and an active window, and you want to know how long each zone sits with nothing active. Strip the framing and you're grouping by a key, merging overlapping intervals inside each group, and summing the gaps. It's a first-year interval sweep inside a reporting task. Precision is won or lost on the output contract, a sorted list of zone and quiet-time pairs.

1

Event Records: Quiet Time Per Zone

MediumSometimes asked

Problem

You are given a list events where events[i] = [zone, start, end]. zone is a string, and start and end are integers with start < end, describing a half-open window [start, end) during which something is active in that zone.

For each zone, consider its observation span, from the earliest start to the latest end among that zone's events. Return the total time inside that span when none of the zone's events are active. That's the sum of the gaps between the zone's merged active windows.

Return a list of [zone, quiet_time] pairs sorted by zone in ascending order. Windows that merely touch, like [0,2] and [2,5], count as continuous and leave no gap between them. A zone with a single event has no gaps, so its quiet time is 0. If events is empty, return an empty list.

Input: events = [["downtown",0,4],["downtown",6,10],["harbor",0,5],["harbor",2,3]]

Output: [["downtown",2],["harbor",0]]

Downtown is active over [0,4] and [6,10] inside the span [0,10], leaving one gap of length 2 from time 4 to 6. Harbor merges to [0,5] with no gap, so its quiet time is 0.

Input: events = [["z",0,2],["z",2,5],["z",7,8]]

Output: [["z",2]]

[0,2] and [2,5] touch and merge to [0,5]. The span runs to 8, so the gap from 5 to 7 is 2.

How this uses the pattern

Group the events by zone into a dictionary. Inside each zone, sort by start, sweep once to merge touching or overlapping windows, and add up the active length. Quiet time is the full span, last end minus first start, minus the total active length. Read the zones out in sorted order.

Event Records: Quiet Time Per Zone

Python

Focus Mode

Loading...

OutputSubmissions

Run

Submit

Click "Run" to execute your code

Test Cases

Input: [[["downtown",0,4],["downtown",6,10],["harbor",0,5],["harbor",2,3]]]Expected: [["downtown",2],["harbor",0]]

Input: [[]]Expected: []

Input: [[["a",5,9]]]Expected: [["a",0]]

Input: [[["z",0,2],["z",2,5],["z",7,8]]]Expected: [["z",2]]

Input: [[["b",0,1],["a",0,1],["c",0,3],["c",5,6]]]Expected: [["a",0],["b",0],["c",2]]

Input: [[["x",0,10],["x",1,2],["x",3,4]]]Expected: [["x",0]]

Need a hint? (3 available)

The Scale AI angle

Timestamped records in, a derived quantity out, in a rigid shape. That's the signature Scale practical. The grade turns on the endpoint rule. Touching windows count as continuous, so the merge test is start at or before the held end, a less-than-or-equal. Use a strict less-than and you quietly invent a zero-width gap between two adjoining windows. The sorted-pairs contract matters just as much. Return a correct computation in insertion order and it fails the exact-match check with every number right.

Take it further

Now report the busiest zone instead. Suppose the interviewer asks mid-round for the zone with the most active time, ties broken by name. You already compute active length per zone, so track a running best during the sweep and skip a second pass. The practical screen leans on moving-constraint extensions like this. Keep the per-zone computation factored cleanly enough to reuse.

Show solution & walkthrough

A stateful command processor to spec

A second recurring shape asks for several small pieces of functionality over shared state, each with a defined return. Here the state is an in-memory inventory with four commands. You add stock, remove stock without going negative, report the grand total, and name the item with the most stock. The round runs a sequence of commands and checks every return in order. Underneath, it's a dictionary of counts. What's tested is whether each command does exactly what the spec says, and the two edge rules it calls out matter most.

2

Inventory: A Stateful Command Processor

MediumCommonly asked

Problem

Write an Inventory class that tracks integer stock counts per item, starting empty. It supports four operations, each with an exact return value:

- add(item, qty): increase item's count by qty (a positive integer) and return the item's new count.
- remove(item, qty): decrease item's count by qty, but never below 0, and return the item's new count. Removing from an item not yet seen leaves it at 0.
- total(): return the sum of all item counts.
- top(): return the item with the highest count. Break ties by returning the lexicographically smallest item name. Ignore items whose count is 0, and return the empty string "" when no item has a positive count.

Input: ops = [add("apple",3), add("banana",5), add("apple",2), remove("banana",10), total(), top()]

Output: [3, 5, 5, 0, 5, "apple"]

Apple reaches 5, banana is floored at 0 by the oversized remove, the total is 5, and apple is the only item with a positive count.

Input: ops = [add("c",1), add("a",1), add("b",1), top()]

Output: [1, 1, 1, "a"]

All three tie at 1, so top returns the lexicographically smallest name, "a".

How this uses the pattern

Keep a dictionary from item to its count. The add and remove commands read, adjust, and write back the count, with remove clamped at 0. The total command sums the values. For top, scan items in sorted name order and keep the first that strictly beats the running best count. That yields the smallest name among the highest counts.

Inventory: A Stateful Command Processor

Python

Focus Mode

Loading...

OutputSubmissions

Run

Submit

Click "Run" to execute your code

Test Cases

Input: [["Inventory",[]],["add",["apple",3]],["add",["banana",5]],["add",["apple",2]],["remove",["banana",10]],["total",[]],["top",[]]]Expected: [null,3,5,5,0,5,"apple"]

Input: [["Inventory",[]],["top",[]],["total",[]]]Expected: [null,"",0]

Input: [["Inventory",[]],["add",["c",1]],["add",["a",1]],["add",["b",1]],["top",[]]]Expected: [null,1,1,1,"a"]

Input: [["Inventory",[]],["add",["x",2]],["remove",["x",5]],["add",["x",1]],["top",[]]]Expected: [null,2,0,1,"x"]

Input: [["Inventory",[]],["remove",["ghost",3]],["total",[]]]Expected: [null,0,0]

Need a hint? (3 available)

The Scale AI angle

The practical screen is known for this shape, a few features built under time with exact returns, here wearing a class costume. Two edge rules decide the score. Remove must clamp at zero instead of going negative. Top must break ties toward the smallest name and skip any item sitting at zero. Miss the clamp and an oversized remove poisons every later total. Miss the tie rule and top returns whichever item the dictionary hashed first, so walk both edges by hand against the spec before you call it done.

Take it further

Add undo() that reverts the most recent add or remove. Push each mutating operation's before-state onto a stack as you apply it, so undo pops and restores in O(1) with no history replay. It's a common mid-round escalation. It rewards keeping add and remove small and symmetric, with the count write-back in one place you can wrap.

Show solution & walkthrough

Parse and format to an exact contract

Candidates underestimate the third shape, a straightforward transform whose whole difficulty is the output format. You process a sequence of ledger entries and keep a running balance per account. A stated rule rejects some entries. Each entry produces one status line with exact wording and spacing. The computation is a dictionary of running totals and a comparison. The grade is whether every line matches the contract to the character, because the checker compares strings.

3

Ledger: Running Balance with an Exact Output

EasyCommonly asked

Problem

You are given a list entries where entries[i] = [account, action, amount]. account is a string, action is either "credit" or "debit", and amount is a positive integer. Each account's balance starts at 0, and entries are processed in order.

A credit always applies, adding amount to the account's balance. A debit applies only if it would not take the balance below 0; a debit that would overdraw is rejected and leaves the balance unchanged. A debit that lands the balance exactly at 0 is allowed.

Return a list of status strings, one per entry in order, in this exact format. For an applied entry: " -> ". For a rejected debit: " -> REJECTED". The tokens are separated by single spaces, and the arrow is a space, hyphen, greater-than, space.

Input: entries = [["ana","credit",100],["ana","debit",30],["ana","debit",90],["bob","debit",10]]

Output: ["ana credit 100 -> 100","ana debit 30 -> 70","ana debit 90 -> REJECTED","bob debit 10 -> REJECTED"]

Ana rises to 100, drops to 70, then the 90 debit would overdraw to -20 and is rejected. Bob starts at 0, so any debit is rejected.

Input: entries = [["a","credit",10],["a","debit",10],["a","debit",1]]

Output: ["a credit 10 -> 10","a debit 10 -> 0","a debit 1 -> REJECTED"]

The debit to exactly 0 is allowed; the next debit would go to -1 and is rejected.

How this uses the pattern

Keep a dictionary from account to running balance. For a credit, add and print the new balance. For a debit, check whether balance minus amount is at least 0. If so, apply it and print the new balance. Otherwise print REJECTED and leave the balance untouched. Build each line by joining the fixed tokens exactly.

Ledger: Running Balance with an Exact Output

Python

Focus Mode

Loading...

OutputSubmissions

Run

Submit

Click "Run" to execute your code

Test Cases

Input: [[["ana","credit",100],["ana","debit",30],["ana","debit",90],["bob","debit",10]]]Expected: ["ana credit 100 -> 100","ana debit 30 -> 70","ana debit 90 -> REJECTED","bob debit 10 -> REJECTED"]

Input: [[]]Expected: []

Input: [[["x","credit",50]]]Expected: ["x credit 50 -> 50"]

Input: [[["x","debit",5]]]Expected: ["x debit 5 -> REJECTED"]

Input: [[["a","credit",10],["b","credit",20],["a","debit",5],["b","debit",25]]]Expected: ["a credit 10 -> 10","b credit 20 -> 20","a debit 5 -> 5","b debit 25 -> REJECTED"]

Input: [[["a","credit",10],["a","debit",10],["a","debit",1]]]Expected: ["a credit 10 -> 10","a debit 10 -> 0","a debit 1 -> REJECTED"]

Need a hint? (3 available)

The Scale AI angle

The screen is known for exact output under time, and this problem is that feature with nothing else around it. A correct computation can still fail on wrong spacing around "-> " or a balance printed on a rejected debit. Two rules carry the grade. The overdraw guard rejects anything that would go below zero, while a debit to exactly zero is allowed. Then the string contract has to hold. Assemble the line from the spec's tokens with single spaces and the literal arrow, and never emit a balance on a rejected line.

Take it further

Emit a final summary line per account. After the per-entry lines, append one line per account, sorted by name, in the form ": " for each. The balances already sit in the dictionary, so it's a sorted pass at the end. It rehearses a common pattern, a detail section followed by an ordered summary under one output contract.

Show solution & walkthrough

Spending the fifty minutes

All three problems are built the same way. An ordinary data structure, whether a dictionary of groups, a small piece of state, or a running total, sits inside a realistic task with a rigid output contract. No trick is hidden. The hard part is scope and precision with the clock running, which is why how you spend the fifty minutes matters more than raw speed.

Common questions