Coding interview patterns interviews

Work in the tool while you explain your decisions.

Choose a role and level. Role rehearsals use named course-bank problems, with follow-up questions and a report on your code and explanation.

Take the assessment Choose an interview

Speak or type. Sign in to save your results across devices.

Timed assessment

Foundation: 2 problems · 70 minutes
Foundation: 3 problems · 90 minutes
Full course: 2 problems · 70 minutes
Full course: 3 problems · 90 minutes

Questions are drawn from a bank of 186. Your report includes a skill breakdown and lessons to practice next.

Start assessment

Practice interviews

Junior tasks cover the fundamentals. Mid and senior tasks add debugging, changing requirements and review decisions.

Position

50 interviews

New graduate engineer
Junior
20 min

Longest unchanged status run

North Quay records one integer status after each poll. Return the length of the longest contiguous run of equal statuses. The same status in separate runs doesn't join up. Return 0 for an empty log.

Start interview

Skills and rubricContiguous run invariant

Separates contiguous runs from total status frequencies.
States the suffix invariant and updates the maximum on every poll.
Runs an example and names one boundary result before calling the implementation complete.

New graduate engineer
Junior
20 min

Reconcile two pick lists

Orchard Parts has a requested list and a packed list of integer part codes. Return the codes that can be matched, in requested-list order. Each packed entry can be used once. Keep repeated matches when both lists contain enough copies. Don't sort either input.

Start interview

Skills and rubricFrequency-limited stable matching

Names requested order and one-use packed multiplicity.
Maintains a remaining-copy frequency map.
Runs an example and names one boundary result before calling the implementation complete.

New graduate engineer
Junior
20 min

Reverse the letters in a tag

Pine Studio masks a tag by reversing only its ASCII letters. Keep every digit, space and punctuation mark at its original index. Preserve each moved letter's case. Return the masked string.

Start interview

Skills and rubricSelective two-pointer reversal

Keeps nonletter indexes and letter case unchanged.
Moves both pointers safely and swaps only letters.
Runs an example and names one boundary result before calling the implementation complete.

New graduate engineer
Mid
28 min

Longest batch inside a time budget

Fieldglass Jobs records nonnegative task durations in order. Return the largest number of contiguous tasks whose total duration is at most budget. Tasks can't be reordered. An empty batch is allowed and has length zero.

Start interview

Skills and rubricNonnegative budget window

Restores the affordable-window invariant with repeated shrinking.
Checks large totals and uses a Java long.
Proves amortized linear time and states the nonnegative-value limit.

New graduate engineer
Mid
28 min

Cancel repeated token groups

Moss Relay cancels a run as soon as k equal adjacent lowercase tokens accumulate. Read the token string from left to right, remove each group of k, and let newly adjacent tokens combine. Return the remaining token string.

Start interview

Skills and rubricCounted stack reduction

Maintains a reduced-prefix counted stack.
Checks remainders, non-pair groups and cascades.
Explains linear stack work and linear output construction.

New graduate engineer
Mid
28 min

Find the kth unissued ticket

Birch Desk stores issued positive ticket numbers in strictly increasing order. Return the kth positive ticket number that is missing. Missing numbers before the first issued ticket count, and the answer can be larger than every issued ticket.

Start interview

Skills and rubricMissing-count boundary search

Finds the first missing count at least k with a half-open bound.
Tests empty, before-first, equality and beyond-end cases.
Justifies k plus boundary and casts before Java addition.

New graduate engineer
Mid
28 min

Partition a priority chain

Raven Repairs stores task priorities in a singly linked list. Put all nodes with value less than threshold before nodes with value at least threshold. Preserve the original relative order within both groups. Reuse the nodes, reconnect their next links, and return the new head.

Start interview

Skills and rubricStable linked-list partition

Saves following links, appends existing nodes and joins tails safely.
Tests all-low, all-high, equality and stale-link cases.
Distinguishes value-based evidence from node identity and allocation claims.

New graduate engineer
Senior
35 min

Nearest terminal route

Willow Routing stores routes in a binary tree. Return the number of nodes on the shortest path from root to a leaf. A leaf has no children. An empty tree has depth 0. A missing child isn't a leaf route.

Start interview

Skills and rubricFirst-leaf breadth-first search

Checks absent-child chains, empty trees and competing branch depths.
Compares O(w) frontier and O(h) recursion memory without linear-time queue shifts.
Supports correctness with an invariant and identifies a changed input assumption that would require another algorithm.

New graduate engineer
Senior
35 min

Longest balanced handoff segment

Harbor Dispatch encodes inbound handoffs as 0 and outbound handoffs as 1. Return the length of the longest contiguous segment with equal numbers of both kinds. An empty segment has length 0.

Start interview

Skills and rubricEarliest prefix-balance index

Tests whole-log, internal, repeated-balance and one-kind cases.
Explains expected linear time, linear map space and boundary recovery.
Supports correctness with an invariant and identifies a changed input assumption that would require another algorithm.

New graduate engineer
Senior
35 min

Level with the largest signed total

Cedar Systems stores signed capacity adjustments in a binary tree. Return the 1-based level whose node values have the greatest total. Choose the shallower level when totals tie. Return 0 for an empty tree. Negative totals still compete.

Start interview

Skills and rubricMaximum level sum with deterministic ties

Checks all-negative levels, ties, sparse branches and overflowing int sums.
Explains width-based memory and the supported numeric bounds.
Supports correctness with an invariant and identifies a changed input assumption that would require another algorithm.

Backend engineer
Junior
25 min

Registered tag lookup

Rehearsal from the course bank: Registered tag lookup. Cedar Dispatch registers distinct lowercase tags. Return a boolean for each requested tag, true only when the entire tag is registered. A path through a longer tag doesn't register its prefixes. Empty strings are valid tags.

Start interview

Skills and rubricTrie paths and terminal states

The function registeredTags returns boolean[]. At most 500 stored words and 500 queries, each at most 60 characters. Words and queries contain lowercase English letters only. Empty strings are allowed only where the statement explicitly permits them.
For {"tags":[],"queries":["","x"]}, the expected result is [false,false]. An empty trie has no terminal root.
Run registeredTags on the example and state the expected output before checking it.

Backend engineer
Junior
25 min

Largest parcel weights

Rehearsal from the course bank: Largest parcel weights. Oriole Freight needs the k largest parcel weights in descending order. Repeated weights remain separate parcels. Return an empty list when k is zero.

Start interview

Skills and rubricHeap boundaries and repeated choices

The function largestParcels returns int[]. `0 <= k <= weights.length <= 2,000` Weights are integers between -10,000 and 10,000; negative values are correction records.
For {"weights":[],"k":0}, the expected result is []. Zero requested parcels need no heap root.
Run largestParcels on the example and state the expected output before checking it.

Backend engineer
Junior
25 min

Ranked response time

Rehearsal from the course bank: Ranked response time. Harbor Hosting records response times. Return the kth largest recorded time, counting repeated measurements separately. k is one based and always valid.

Start interview

Skills and rubricHeap boundaries and repeated choices

The function rankedTime returns int. `1 <= k <= times.length <= 2,000` Every time is an integer between -10,000 and 10,000.
For {"times":[6],"k":1}, the expected result is 6. A single record is its own first rank.
Run rankedTime on the example and state the expected output before checking it.

Backend engineer
Mid
35 min

Catalog prefix counts

Rehearsal from the course bank: Catalog prefix counts. Moss Catalog stores lowercase product tags, including repeated tags. For each prefix in prefixes, return how many tag occurrences begin with it. An empty prefix matches every tag.

Start interview

Skills and rubricTrie paths and terminal states

Each insertion increments a pass count at the root and every character node it visits. Therefore a node counts exactly the tag occurrences with that prefix. A failed edge means zero matches; the empty query stays at the root. If L is the total tag length and Q the total query length, this takes O(L + Q) time and O(L) space. Repeated tags increment counts again.
For {"tags":[],"prefixes":["a",""]}, the expected result is [0,0]. An empty catalog has no matching occurrences.
Explain why this alternative fails: Deduplicating the catalog loses repeated tag occurrences. Count each insertion on its entire path.

Backend engineer
Mid
35 min

Shortest routing prefix

Rehearsal from the course bank: Shortest routing prefix. Rill Logistics defines lowercase routing roots. For each address token, return its shortest registered prefix. If none exists, keep the original token. Return answers in token order. Roots and tokens are nonempty.

Start interview

Skills and rubricTrie paths and terminal states

Insert routing roots into a trie, then scan each token until the first terminal node or absent edge. The first terminal gives the shortest registered prefix. An absent edge can't lead to any later match. With L root characters and T token characters, the algorithm takes O(L + T) time and O(L) space. Don't shorten an unmatched token.
For {"roots":[],"tokens":["dock"]}, the expected result is ["dock"]. No root means the token stays unchanged.
Explain why this alternative fails: The matching character belongs in the replacement root. A slice ending at i drops that last character.

Backend engineer
Mid
35 min

Prefix-free labels

Rehearsal from the course bank: Prefix-free labels. Nacre Media wants labels that can be read without a separator. Return true if no label is a prefix of another and no label is repeated. Labels contain lowercase letters and are nonempty. An empty collection is valid.

Start interview

Skills and rubricTrie paths and terminal states

A trie detects both directions of the prefix relation without sorting labels. Encountering a terminal while consuming a label finds an earlier shorter label. Finishing at a node that already has children finds an earlier longer label; finishing at a terminal finds a repeat. Inserting L characters takes O(L) time and O(L) space.
For {"labels":[]}, the expected result is true. There are no conflicts in an empty collection.
Explain why this alternative fails: A shorter label inserted after a longer one still conflicts. Check for children at the final node.

Backend engineer
Mid
35 min

One-letter directory search

Rehearsal from the course bank: One-letter directory search. Sable Support stores distinct lowercase directory words. For each query, return true if some stored word has the same length and differs in exactly one position. A word identical to the query isn't sufficient. Empty strings are allowed.

Start interview

Skills and rubricTrie paths and terminal states

Each trie state records a position and a mismatch count. Equal characters retain the budget; a different edge consumes it. Query end succeeds only on a terminal with exactly one replacement. Search visits at most the trie nodes at relevant depths, O(L) per query in the worst case for L total stored characters, with O(m) recursion space for query length m, plus O(L) trie storage.
For {"words":[],"queries":["x",""]}, the expected result is [false,false]. No stored word can match.
Explain why this alternative fails: An identical word uses zero replacements. Require exactly one mismatch at the terminal node.

Backend engineer
Senior
40 min

Live duration medians

Rehearsal from the course bank: Live duration medians. Tern Media receives clip durations one at a time. After each arrival, return the median of all durations received so far. For an even count, average the two middle values.

Start interview

Skills and rubricHeap boundaries and repeated choices

Two heaps retain the order boundary: every lower-half value is at most every upper-half value. Moving the lower maximum upward after insertion preserves that order, and moving one value back keeps the sizes equal or gives the lower half one extra. Each arrival takes O(log n), for O(n log n) total time and O(n) storage. Fractional medians require floating division.
This change needs a new proof: The lower half needs a max heap so its largest value borders the upper half. A min heap loses that boundary. State which constraint the current implementation uses and give a test that invalidates the alternative.
Defend the time and space cost under this bound: Treat distinct occurrences separately unless the statement says to deduplicate.

Backend engineer
Senior
40 min

Longest dependency chains

Rehearsal from the course bank: Longest dependency chains. Solstice Analytics has n numbered processing stages and directed dependencies edges=[before,after]. A chain is a directed path and its length is its number of stages. Return the number of distinct longest chains modulo 1,000,000,007. Isolated stages count as length-one chains. Return 0 for n=0 or a dependency cycle.

Start interview

Skills and rubricTopological order and path aggregation

Carry both best chain length and its count. Replace on a longer predecessor and add on a tie, then sum only maximum-length endpoints. O(n² + m) time and O(n + m) space.
This change needs a new proof: Count only endpoints of a globally longest chain. Summing every endpoint includes shorter paths. State which constraint the current implementation uses and give a test that invalidates the alternative.
Defend the time and space cost under this bound: Each [a,b] means a must finish before b. Edges are distinct; self dependencies are allowed.

Backend engineer
Senior
40 min

Courier cost with a transfer cap

Rehearsal from the course bank: Courier cost with a transfer cap. Plover Express offers directed legs edges=[from,to,cost]. A route may use at most maxEdges legs, including the final leg. Return its cheapest cost from source to target, or -1 if no such route exists. Costs may be zero.

Start interview

Skills and rubricShortest paths and resource layers

Copy the previous cost layer before relaxing edges so each round introduces at most one new leg. O(maxEdges × m + maxEdges × n) time and O(n) extra space.
This change needs a new proof: maxEdges counts every leg. Running one extra round accepts routes beyond the stated cap. State which constraint the current implementation uses and give a test that invalidates the alternative.
Defend the time and space cost under this bound: 0 <= cost <= 100,000; endpoints lie in [0,n).

Frontend engineer
Junior
25 min

Best run of sales days

Rehearsal from the course bank: Best run of sales days. Saltmarsh Wholesale records each day's net sales in cents in sales; a negative day means refunds beat sales. Return the largest total over any days consecutive days. days is at least 1 and never more than the number of days in sales.

Start interview

Skills and rubricFixed and variable windows with a running summary

The function bestWindowTotal returns long. `1 <= days <= sales.length <= 100,000` `-1,000,000,000 <= sales[i] <= 1,000,000,000` A total can be larger than a 32-bit integer.
For {"sales":[-7],"days":1}, the expected result is -7. One day makes one window, and its total is the answer, even when it is negative.
Run bestWindowTotal on the example and state the expected output before checking it.

Frontend engineer
Junior
25 min

Balanced message templates

Rehearsal from the course bank: Balanced message templates. Wrenfield Mail builds customer emails from templates that use three kinds of brackets: (), [] and {}. Each opener must be closed by the same kind, and pairs must nest, never cross: {[]} is fine, {[}] isn't. Every other character is text and doesn't matter. Return true if every bracket in template is balanced.

Start interview

Skills and rubricStacks for matching, evaluating and next greater values

The function isBalanced returns boolean. `0 <= template.length <= 100,000` `template` holds printable ASCII characters.
For {"template":""}, the expected result is true. A template with no brackets is balanced.
Run isBalanced on the example and state the expected output before checking it.

Frontend engineer
Junior
25 min

Cancel repeated switch presses

Rehearsal from the course bank: Cancel repeated switch presses. Juniper Lane Lighting's control panel logs every switch press in log, one lowercase letter per switch. Two presses of the same switch in a row cancel each other out, and the presses on either side of them then count as neighbors, so they can cancel too. Remove cancelling pairs until no two neighbors match, and return the presses that remain. Return an empty string if every press cancels.

Start interview

Skills and rubricStacks for matching, evaluating and next greater values

The function collapsePairs returns string. `0 <= log.length <= 100,000` `log` holds lowercase letters.
For {"log":""}, the expected result is "". An empty log stays empty.
Run collapsePairs on the example and state the expected output before checking it.

Frontend engineer
Mid
35 min

Longest run without a repeat

Rehearsal from the course bank: Longest run without a repeat. Cobalt Bay Radio logs its playlist as a string text, one character per song code. Return the length of the longest stretch of consecutive songs in which no song plays twice. Song codes are case-sensitive: a and A are different songs.

Start interview

Skills and rubricFixed and variable windows with a running summary

Grow the window one character at a time and keep a map from each character to its last position. When the new character already sits inside the window, jump `left` to one past its earlier copy, and the window holds no repeat again. Both edges only move forward, so the work is **O(n) time**, and the map holds one entry per distinct character: **O(k) space** for k distinct codes. A copy that sits left of the window isn't a repeat, so never move `left` backward (`kttk` has a best of 2, not 3). Update the best after every step, so a stretch that ends on the last character counts. An empty log gives 0, a log of one repeated song gives 1, and `a` and `A` are different codes. Restarting a scan at every position also works, but it reads the same characters again for each start.
For {"text":""}, the expected result is 0. An empty log has no songs: return 0.
Explain why this alternative fails: You move `left` to one past every earlier copy, even a copy that is already outside the window, so `left` can jump backward. Only move it forward.

Frontend engineer
Mid
35 min

Shortest span that fills a truck

Rehearsal from the course bank: Shortest span that fills a truck. At Redfern Gravel, a conveyor drops loads onto a truck in order, and loads[i] is the weight of load i in kilograms, always positive. Return the length of the shortest run of consecutive loads whose total is at least target, or 0 if no run reaches it.

Start interview

Skills and rubricFixed and variable windows with a running summary

Because every load is positive, a window's total rises when it grows and falls when it shrinks. Grow the right edge one load at a time; whenever the total reaches `target`, record the length and shrink from the left until it no longer does. Each load enters and leaves the window once, so this is **O(n) time and O(1) extra space**. Use `>=`, since a run that hits the target exactly counts; keep shrinking with a loop, not a single step; and return 0 when no run reaches the target, including for an empty list. The shrinking rule depends on positive values: with negative loads, a longer window can have a smaller total, and you would need prefix sums instead. In Java, the total of 100,000 loads of 10,000 kilograms is 1,000,000,000, which still fits in an `int`.
For {"loads":[],"target":5}, the expected result is 0. No loads means no run: return 0.
Explain why this alternative fails: "At least `target`" includes a total equal to it. With `>` instead of `>=`, a run that hits the target exactly is skipped.

Frontend engineer
Mid
35 min

Longest clean run with retries

Rehearsal from the course bank: Longest clean run with retries. Larkspur Labs runs a nightly batch of test jobs in order. results[i] is 1 if job i passed and 0 if it failed. The team may re-run up to budget failed jobs and count them as passed. Return the length of the longest stretch of consecutive jobs that can all count as passed.

Start interview

Skills and rubricFixed and variable windows with a running summary

A stretch can count as passed exactly when it holds at most `budget` failures, so the task is the longest window with at most `budget` zeros. Grow the right edge, count failures as they enter, and when the count goes over the budget, move `left` forward until a failure has left the window. Record the length only after shrinking. Both edges move forward only: **O(n) time and O(1) extra space**. Edge cases: an empty list gives 0; a budget of 0 gives the longest run of passes as it stands; when everything failed, the answer is the smaller of the budget and the length; and a budget larger than the number of failures covers the whole list. Adding the budget to the longest run of passes fails when the failures are spread out.
For {"results":[],"budget":3}, the expected result is 0. No jobs means no stretch: return 0.
Explain why this alternative fails: When the window holds too many failures, you subtract a failure for every job you drop, even a job that passed. Only subtract when the job leaving the window failed.

Frontend engineer
Mid
35 min

Days until a warmer reading

Rehearsal from the course bank: Days until a warmer reading. Hollowbrook Orchards logs one frost-sensor reading per day in temps, in tenths of a degree; readings can be negative. For each day, return how many days the grower waits until a strictly warmer reading. Use 0 if no later day is warmer.

Start interview

Skills and rubricStacks for matching, evaluating and next greater values

Keep a stack of the days still waiting for a warmer reading. Their readings never rise from the bottom of the stack to the top, because a warmer day pops every cooler one before it is pushed. So each new reading only needs to look at the top: pop while the top is cooler, recording `day - top` for each, then push the new day. Each day is pushed once and popped at most once, so the loop inside the loop still costs **O(n) time** in total, with **O(n) space** for the stack and the answer. Use a strict `<`: equal readings aren't warmer. Days still on the stack at the end keep 0, an empty list gives an empty answer, and negative readings need no special case. Scanning forward from every day is O(n^2) when readings keep falling.
For {"temps":[]}, the expected result is []. No readings: return an empty list.
Explain why this alternative fails: An equal reading is not warmer. Pop a waiting day only when the new reading is strictly higher: `<`, not `<=`.

Frontend engineer
Senior
40 min

Target downward ledgers

Rehearsal from the course bank: Target downward ledgers. Pine Ledger stores adjustments in a binary tree. Count all nonempty downward paths whose values sum to target. A path may start at any node and must follow parent-to-child links. Paths in separate branches are distinct.

Start interview

Skills and rubricTree contributions and search order

If the current root-to-node total is S, any earlier prefix totaling S - target starts a valid downward path. The count map stores only prefixes on the current ancestor chain. Add before descending and remove after both children so sibling branches never combine. Seeding zero counts paths starting at the root. Expected time is O(n), with O(h) active prefixes and recursion space.
This change needs a new proof: The empty prefix is needed to count paths beginning at the root. Seed its count with one. State which constraint the current implementation uses and give a test that invalidates the alternative.
Defend the time and space cost under this bound: Trees use level-order arrays with null for missing children.

Frontend engineer
Senior
40 min

Best service route

Rehearsal from the course bank: Best service route. Aspen Network assigns a signed gain to each node in a binary service tree. Return the largest sum on any nonempty simple path. The path may turn once at a node and can begin and end anywhere. Return 0 for an empty tree.

Start interview

Skills and rubricTree contributions and search order

A path with its highest node at the current node can include one positive arm from each child. Its sum is a candidate for the global best. The parent can extend only one arm, so the recursive return uses the larger child contribution. Ignoring negative arms helps the sum, while a negative initial best preserves nonempty all-negative answers. Time is O(n) and recursion space is O(h).
This change needs a new proof: An arm returned to a parent can use only one child. Returning both creates a branched shape rather than a simple path. State which constraint the current implementation uses and give a test that invalidates the alternative.
Defend the time and space cost under this bound: Trees use level-order arrays with null for missing children.

Frontend engineer
Senior
40 min

Warehouse skyline rectangle

Rehearsal from the course bank: Warehouse skyline rectangle. Heron Storage has adjacent unit-width columns of nonnegative heights. Return the largest rectangular area that fits beneath the skyline across a contiguous run of columns. An empty skyline has area zero.

Start interview

Skills and rubricMonotonic stacks and deques

A stack entry records a height and the earliest start where every column meets that height. Encountering a shorter column closes its widest possible rectangle, so compute its area before popping. The shorter column inherits earlier starts. A zero sentinel closes the remaining positive heights. Every column is pushed and popped once, O(n) time and O(n) space.
This change needs a new proof: Increasing columns stay on the stack until a shorter sentinel arrives. Without that final flush their areas are never measured. State which constraint the current implementation uses and give a test that invalidates the alternative.
Defend the time and space cost under this bound: `0 <= heights[i] <= 10,000`

Data engineer
Junior
25 min

Coalesce loading slots

Rehearsal from the course bank: Coalesce loading slots. Plover Freight records half-open loading slots [start, end). Merge overlapping or touching slots and return disjoint slots ordered by start. Every slot has start < end.

Start interview

Skills and rubricIntervals and greedy frontiers

The function mergeSlots returns int[][]. `0 <= slots.length <= 2,000` Each slot contains two integers with `start < end`. Endpoints are between -10,000 and 10,000.
For {"slots":[]}, the expected result is []. No slots produce no merged ranges.
Run mergeSlots on the example and state the expected output before checking it.

Data engineer
Junior
25 min

Interior fence markers

Rehearsal from the course bank: Interior fence markers. Oak Survey draws a straight segment from start to finish, two integer coordinate pairs. Return the number of integer grid points strictly between its endpoints. Return zero for a segment of zero length.

Start interview

Skills and rubricGeometry and matrix coordinates

The function fenceMarkers returns int. `-1,000,000 <= each coordinate <= 1,000,000` Both arrays contain exactly two coordinates.
For {"start":[3,3],"finish":[3,3]}, the expected result is 0. Zero-length segments have no interior markers. Clamp the gcd-minus-one result at zero.
Run fenceMarkers on the example and state the expected output before checking it.

Data engineer
Junior
25 min

Rotated shelf display

Rehearsal from the course bank: Rotated shelf display. At Hazel Displays, shelf is a square matrix. Return a new matrix rotated 90 degrees clockwise. Preserve the source values; no in-place mutation is required.

Start interview

Skills and rubricGeometry and matrix coordinates

The function rotatedShelves returns int[][]. `0 <= shelf.length <= 90` Every row length equals shelf.length. Entries are integers between -10,000 and 10,000.
For {"shelf":[]}, the expected result is []. Map source (r,c) to destination (c,n-1-r).
Run rotatedShelves on the example and state the expected output before checking it.

Data engineer
Mid
35 min

Merge sorted feeds

Rehearsal from the course bank: Merge sorted feeds. Juniper News receives sorted integer timestamps from several feeds. Merge all occurrences into one ascending list. Feeds may be empty, and equal timestamps remain separate events.

Start interview

Skills and rubricHeap boundaries and repeated choices

A min heap stores the next unread timestamp from every nonempty feed. The minimum is therefore the next event globally. Replacing it with the following timestamp from the same feed preserves the invariant. For N total events and k feeds, time is O(N log(k + 1)); auxiliary heap space is O(k), excluding the O(N) answer.
For {"feeds":[]}, the expected result is []. There are no feed heads to seed.
Explain why this alternative fails: The heap needs the smallest available timestamp. Reversing its order emits later events too early.

Data engineer
Mid
35 min

Cheapest bundle merges

Rehearsal from the course bank: Cheapest bundle merges. Aster Archives combines file bundles. Merging two bundles costs the sum of their sizes and creates one bundle of that size. Return the minimum total cost to combine all bundles. Zero or one bundle costs zero. Sizes are nonnegative.

Start interview

Skills and rubricHeap boundaries and repeated choices

The two smallest bundles can be placed together at the deepest leaves of an optimal merge tree. Exchanging them with larger deepest bundles can't increase cost. Merge that pair, then apply the same argument to the reduced instance. A min heap implements the repeated choice in O(n log n) time and O(n) space. The total uses a long in Java.
For {"sizes":[]}, the expected result is 0. No merge is needed.
Explain why this alternative fails: A new bundle can be merged again later. Failing to put it back stops the process before every file is combined.

Data engineer
Mid
35 min

Maximum training sessions

Rehearsal from the course bank: Maximum training sessions. Wren Labs can attend one training session at a time. Given half-open sessions [start, end), return the maximum number you can attend in full. A session may start exactly when another ends.

Start interview

Skills and rubricIntervals and greedy frontiers

The earliest finishing compatible session leaves at least as much room as any alternative first session. Replacing another first choice with it can't reduce the number of later choices, so repeating the argument proves the greedy schedule optimal. Sorting takes O(n log n) time, scanning takes O(n), and extra scan space is O(1), apart from sorting or a copied input.
For {"sessions":[]}, the expected result is 0. An empty schedule has zero choices.
Explain why this alternative fails: A session can start at the previous end. Requiring a positive gap rejects compatible sessions.

Data engineer
Mid
35 min

Minimum call rooms

Rehearsal from the course bank: Minimum call rooms. Fable Health schedules calls as half-open intervals [start, end). Return the minimum number of rooms needed so overlapping calls use different rooms. A room is free at its call end time.

Start interview

Skills and rubricIntervals and greedy frontiers

The heap holds end times of precisely the active calls. Releasing all ends at or before the next start implements half-open intervals. The largest active count is a lower bound on required rooms, and reusing a released room achieves it. Sorting and heap operations take O(n log n) time with O(n) heap storage.
For {"calls":[]}, the expected result is 0. No calls need no rooms.
Explain why this alternative fails: Rooms become free at the end time itself. A strict release comparison counts back-to-back calls as overlap.

Data engineer
Senior
40 min

Connectivity after cable removals

Rehearsal from the course bank: Connectivity after cable removals. Wren Hosting starts with n servers and undirected cables edges. removals lists distinct cable indices to delete in order. Return the number of connected components after each deletion, preserving that order. Parallel cables and self loops are allowed.

Start interview

Skills and rubricMixed graph reasoning

Process deletions backward as insertions. Initialize the final surviving network, record its count, then restore each cable in reverse order. O((n + m + q) α(n)) time and O(n + m + q) space with path compression and union by size.
This change needs a new proof: Record the component count before restoring a removed cable. Recording it afterward answers the previous network state. State which constraint the current implementation uses and give a test that invalidates the alternative.
Defend the time and space cost under this bound: 0 <= removals.length <= 9,000.

Data engineer
Senior
40 min

Mutually reachable service clusters

Rehearsal from the course bank: Mutually reachable service clusters. Birch Services lists directed requests edges=[from,to] among n services. Two services belong to one cluster when each can reach the other, possibly through other services. Return the number of these strongly connected clusters, including isolated services.

Start interview

Skills and rubricMixed graph reasoning

Kosaraju search first records finish order, then explores the reversed graph in descending finish order to isolate strongly connected components. O(n + m) time and space; n is capped so recursion stays shallow.
This change needs a new proof: Process finishing order backward. Forward order can spread through several clusters in the reversed graph. State which constraint the current implementation uses and give a test that invalidates the alternative.
Defend the time and space cost under this bound: Every endpoint lies in [0,n); repeated edges and self loops are allowed.

Data engineer
Senior
40 min

Single-cable failure points

Rehearsal from the course bank: Single-cable failure points. Dogwood Systems has n sites and undirected cables edges=[a,b]. Return how many individual cables would increase the number of connected components if removed. Parallel cables and self loops are separate cables and must be handled correctly.

Start interview

Skills and rubricMixed graph reasoning

A DFS tree edge is a bridge exactly when its child can't reach the parent or an earlier ancestor without using that specific edge. O(n + m) time and space; edge identifiers distinguish parallel cables.
This change needs a new proof: Visited neighbors supply back edges. Ignoring them misses the alternate routes that protect cables from failure. State which constraint the current implementation uses and give a test that invalidates the alternative.
Defend the time and space cost under this bound: Endpoints lie in [0,n); individual cable indices distinguish parallel cables.

Senior software engineer
Junior
25 min

Terminal account total

Rehearsal from the course bank: Terminal account total. Birch Cooperative stores balances in a binary account tree. Only leaf accounts represent payable balances. Return the sum of leaf values. A leaf has neither a left nor a right child. Empty trees total zero.

Start interview

Skills and rubricTree contributions and search order

The function leafBalance returns long. `0 <= node count <= 2,000`; tree depth is at most 300. Node values are integers between -10,000 and 10,000. Trees use level-order arrays with null for missing children.
For {"root":[]}, the expected result is 0. An empty tree contributes zero.
Run leafBalance on the example and state the expected output before checking it.

Senior software engineer
Junior
25 min

Delivery stair choices

Rehearsal from the course bank: Delivery stair choices. At Alder Dispatch, a robot reaches shelf n by moves of exactly 1 or 3 shelves. Return the number of ordered move sequences. Staying at shelf 0 counts as one empty sequence.

Start interview

Skills and rubricOne-dimensional dynamic programming

The function stairDelivery returns int. `0 <= n <= 40` Return an exact integer.
For {"n":0}, the expected result is 1. The empty route seeds every later count. Set the number of ways to reach shelf 0 to one.
Run stairDelivery on the example and state the expected output before checking it.

Senior software engineer
Junior
25 min

Nonadjacent pickup value

Rehearsal from the course bank: Nonadjacent pickup value. Moss Couriers can accept any subset of daily pickup offers in values, but two accepted offers can't occupy adjacent positions. Return the greatest total value; accepting none is allowed.

Start interview

Skills and rubricOne-dimensional dynamic programming

The function restedPickups returns int. `0 <= values.length <= 100,000` `-10,000 <= values[i] <= 10,000`
For {"values":[]}, the expected result is 0. Update both states from the old values and return their maximum.
Run restedPickups on the example and state the expected output before checking it.

Senior software engineer
Mid
35 min

Rightmost service view

Rehearsal from the course bank: Rightmost service view. Bramble Hosting draws a binary service tree. Return the value of the rightmost existing node at each depth, starting with the root. A left child can be visible when no node lies farther right on that level.

Start interview

Skills and rubricTree contributions and search order

Breadth-first traversal visits each depth in left-to-right order. The last node in that level is the rightmost existing node, even when it belongs to a left subtree. Keeping a level boundary prevents children from contaminating the current choice. Time is O(n), and auxiliary space is O(w) for maximum tree width, excluding the view output.
For {"root":[]}, the expected result is []. An empty tree has no visible levels.
Explain why this alternative fails: The right view needs the last node in left-to-right level order. Taking the first produces the left view.

Senior software engineer
Mid
35 min

Ranked inventory key

Rehearsal from the course bank: Ranked inventory key. Meridian Parts stores distinct integer stock keys in a valid binary search tree. Return the kth smallest key using one-based k. Return -1 if k is out of range, including k <= 0. Stock keys are nonnegative.

Start interview

Skills and rubricTree contributions and search order

Inorder traversal of a strict BST yields keys in ascending order. Decrementing the one-based rank at each visit selects the requested key. The loop returns -1 when the rank is invalid or larger than the node count. It visits O(h + k) nodes before a valid answer, bounded by O(n), and uses O(h) stack space.
For {"root":[],"k":1}, the expected result is -1. There is no first key in an empty tree.
Explain why this alternative fails: One-based k must be reduced before comparing with zero. Comparing against one returns the preceding rank.

Senior software engineer
Mid
35 min

First redundant cable

Rehearsal from the course bank: First redundant cable. Mallow Networks connects n offices using cables in the given order. Return the zero-based index of the first cable whose endpoints were already connected, or -1 if none is redundant. A repeated cable or self loop can be redundant.

Start interview

Skills and rubricDisjoint sets and spanning trees

Compare representatives before each union. Equal representatives mean this cable closes an existing path. O((n + m) α(n)) time and O(n) space, where α is the inverse Ackermann function.
For {"n":1,"edges":[[0,0]]}, the expected result is 0. Compare representatives before each union. Equal representatives mean this cable closes an existing path. Check the boundary and disconnected cases before returning.
Explain why this alternative fails: The contract asks for a zero-based cable index. Counting from one shifts the first redundant cable.

Senior software engineer
Mid
35 min

Additional network joins

Rehearsal from the course bank: Additional network joins. Teasel Travel has n booking servers and existing two-way links edges. You may add a link between any two servers. Return the fewest additional links needed to connect the whole network.

Start interview

Skills and rubricDisjoint sets and spanning trees

A successful union reduces the component count by one; after the existing links, join the remaining components with a tree. O((n + m) α(n)) time and O(n) space, where α is the inverse Ackermann function.
For {"n":1,"edges":[]}, the expected result is 0. A successful union reduces the component count by one; after the existing links, join the remaining components with a tree. Check the boundary and disconnected cases before returning.
Explain why this alternative fails: Connecting c components takes c minus one new links. Counting one link per component adds an unnecessary final link.

Senior software engineer
Senior
40 min

Strict cable limits

Rehearsal from the course bank: Strict cable limits. Finch Freight has n hubs and weighted two-way lanes edges=[a,b,weight]. For each query [a,b,limit], return 1 if a route exists using only lanes with weight strictly less than limit, otherwise 0. A hub always reaches itself. Preserve query order.

Start interview

Skills and rubricDisjoint sets and spanning trees

Sort queries by their limit and incrementally union lanes below that limit; store each result at the query's original index. O(m log m + q log q + (n + m + q) α(n)) time and O(n + m + q) space.
This change needs a new proof: Offline sorting changes processing order, so write every answer back to its original query index. State which constraint the current implementation uses and give a test that invalidates the alternative.
Defend the time and space cost under this bound: Endpoints lie in [0,n). All costs and limits are integers in [0,100,000].

Senior software engineer
Senior
40 min

One complimentary courier leg

Rehearsal from the course bank: One complimentary courier leg. Larch Medical Courier has directed priced legs edges=[from,to,cost]. You may waive the cost of at most one leg. Return the minimum cost from source to target, or -1 if impossible. The waiver is optional and source to itself costs 0.

Start interview

Skills and rubricShortest paths and resource layers

Keep two distances per station: waiver available and waiver spent. Paying preserves the state; waiving moves only from available to spent. Python and Java use O((n + m) log n) time with a heap; the JavaScript references use O(n² + m) for n<=200. All use O(n + m) space.
This change needs a new proof: The waiver can be saved for a later expensive leg. Disabling it forces the full-price route. State which constraint the current implementation uses and give a test that invalidates the alternative.
Defend the time and space cost under this bound: Each directed edge has a cost in [0,100,000]; endpoints lie in [0,n).

Senior software engineer
Senior
40 min

Number of cheapest routes

Rehearsal from the course bank: Number of cheapest routes. Gannet Events has directed roads edges=[from,to,cost] with strictly positive costs and no duplicate directed edges. Return the number of minimum-cost routes from source to target modulo 1,000,000,007. Return 0 when unreachable. The empty route from a station to itself counts once.

Start interview

Skills and rubricShortest paths and resource layers

Track a count with each shortest distance: replace the count on improvement and add counts on ties. Strictly positive costs ensure predecessors settle first. O(n² + m) time and O(n + m) space; n is bounded at 200, so scanning a dense frontier is appropriate. A binary heap gives O((n + m) log n) on larger sparse networks.
This change needs a new proof: Equal-cost routes are distinct and both count. Replacing on a tie loses valid cheapest paths. State which constraint the current implementation uses and give a test that invalidates the alternative.
Defend the time and space cost under this bound: All shortest path costs fit in a 32-bit signed integer.