Dasher Payout Engine

PracticalhardPremium

45:00

Desktop only

Coding Challenges are optimized for Desktop

Come back on a wider screen - the live editor needs room to breathe. You can still read the problem brief above.

Problem

A delivery platform pays couriers ("dashers") for the time they spend actively delivering. Instead of receiving clean shifts, the payout system receives a stream of raw events and has to reconstruct what each dasher actually did before any money moves.

Every event is a record with exactly these fields:

{
    "event_id": str,      # unique id, e.g. "e1"
    "dasher_id": str,     # courier identity, e.g. "d1"
    "kind": str,          # "started" | "ended" | "cancelled"
    "minute": int,        # integer minute of the event
    "delivery_id": str,   # the delivery this event refers to
}

A delivery begins with a "started" event and normally ends with an "ended" event carrying the same delivery_id for the same dasher_id. That pair forms one active interval [start_minute, end_minute). A "cancelled" event marks its delivery as never paying out. Payout is per active minute, with a bonus for minutes when a dasher juggles two or more deliveries at once.

You will build this in five levels: pair events into intervals, price them, add the concurrency bonus, harden against messy event streams, and emit an audit report.

Level 1 - Active intervals from events

def parse_events(events: list[dict], close_open: bool = False) -> dict[str, list[tuple[int, int]]]: ...

Convert the raw event stream into, per dasher, the list of active intervals. Match each "started" with the "ended" (or the cancelling event) that carries the same delivery_id for the same dasher. Events whose kind is not one of the three known kinds are ignored silently. Return a dict (or Map) keyed by dasher_id, each value a list of (start, end) tuples sorted by start.

Example:

events = [
    e1: dasher d1 started  delivery dv1 at minute 0
    e2: dasher d1 ended    delivery dv1 at minute 10
    e3: dasher d1 started  delivery dv2 at minute 15
    e4: dasher d1 ended    delivery dv2 at minute 20
]
parse_events(events)  -> {"d1": [(0, 10), (15, 20)]}
 
# e1 pairs with e2, e3 pairs with e4.

Level 2 - Base payout

def payout(events: list[dict], rate: float) -> float: ...

Total pay across all dashers: sum every active interval's duration in minutes, multiply by rate. A cancelled delivery contributes nothing, and a "started" that never sees its "ended" contributes nothing at this level.

Example:

rate = 2
# d1 active 0..10 and 15..20 (two intervals)
payout(events, rate)  -> (10 + 5) * 2 = 30

Level 3 - Concurrency bonus

def payout_with_bonus(events: list[dict], rate: float, multiplier: float = 2) -> float: ...

Minutes where a dasher has two or more deliveries active simultaneously pay rate * multiplier instead of rate, and only for the overlapping portion. Walk each dasher's minute coverage: a minute covered exactly once pays base, a minute covered two or more times pays the doubled rate.

Example:

rate = 1, multiplier = 2
# d1: delivery A active [0, 10), delivery B active [5, 15)
# minutes 0..4   covered once -> 5 * 1 = 5
# minutes 5..9   covered twice -> 5 * 2 = 10
# minutes 10..14 covered once -> 5 * 1 = 5
payout_with_bonus(events, rate, multiplier)  -> 20

Level 4 - Messy event streams

Real streams are dirty. parse_events gains its close_open flag here and must survive all of the following:

Duplicate event_ids. The same event_id arriving twice is an ingest retry: the second occurrence is dropped entirely, whatever its payload. First one wins.
Out-of-order events. An "ended" may appear in the list before its "started". Pairing must not depend on list order.
Cancellation semantics. A "cancelled" voids its delivery: that delivery never pays out, even if its "started" is still open. If "ended" already arrived for that delivery, "cancelled" is ignored because the delivery was already closed and paid.
Open deliveries. A "started" with no matching "ended" at the end of the batch is treated as ended at events_end, the maximum minute seen anywhere in the batch, but only when close_open=True. With close_open=False an unmatched start is ignored and contributes nothing.

Example:

events = [ended dv1 at 20, started dv1 at 5]     # out of order
parse_events(events)  -> {"d1": [(5, 20)]}
 
events = [started dv1 at 5, duplicate started at 5 with same event_id]
# the duplicate is dropped, one interval forms
 
events = [started dv1 at 5]  with close_open=True and batch max minute 30
# -> interval (5, 30)

Level 5 - Audit breakdown

def payout_report(events: list[dict], rate: float, multiplier: float = 2) -> dict[str, float]: ...

Ops wants to see exactly which minutes were paid at which rate. Return a dict (or object) with:

"base_minutes": minutes covered by exactly one active delivery
"bonus_minutes": minutes covered by two or more active deliveries
"base_payout": base_minutes * rate
"bonus_payout": bonus_minutes * rate * multiplier
"total": base_payout + bonus_payout

Example:

rate = 1, multiplier = 2
# d1 active [0, 10) and [5, 15)
# coverage 2 minutes: 5 (minutes 5..9)   -> bonus_minutes = 5
# coverage 1 minutes: 10 (0..4 and 10..14) -> base_minutes = 10
payout_report(events, 1, 2)  ->
    {"base_minutes": 10, "bonus_minutes": 5,
     "base_payout": 10, "bonus_payout": 10, "total": 20}

Patterns used

Foundations primers this challenge draws on.

Greedy

Hash Maps

Loading editor...

The live editor for this challenge unlocks with Premium.

Browse free problems

0/0 passed