Compute courier pay and implement load balancing

Q: Compute courier pay and implement load balancing

This problem evaluates skills in interval arithmetic and aggregation for time-based pay computation alongside routing and load-balancing knowledge covering round-robin and consistent hashing with virtual nodes, testing time-interval handling, rate mapping, hashing, and data-structure design for high-volume inputs.

Q: How do I practice coding and algorithm questions?

Use PracHub's coding console to write, test, and debug your solutions in Python or JavaScript. View hints, test against sample inputs, and compare with official solutions.

Q: What difficulty level is this coding question?

This is a medium difficulty Coding & Algorithms question, commonly asked during Onsite rounds at DoorDash.

Q: What role is this question designed for?

This question is commonly asked for Software Engineer candidates at DoorDash during technical interviews.

Question

Compute courier pay and implement load balancing

PracHub · Accepted Answer

def solution(rate_intervals, trips):
    diff = [0] * 1442

for start, end, rate in rate_intervals:
        diff[start] += rate
        diff[end] -= rate

per_minute = [0] * 1440
    running = 0
    for minute in range(1440):
        running += diff[minute]
        per_minute[minute] = running

prefix_pay = [0] * 1441
    for minute in range(1440):
        prefix_pay[minute + 1] = prefix_pay[minute] + per_minute[minute]

total = 0
    for pickup, dropoff, bonus in trips:
        total += prefix_pay[dropoff] - prefix_pay[pickup] + bonus

return total

def solution(operations):
    class Node:
        __slots__ = ('sid', 'prev', 'next')

def __init__(self, sid):
            self.sid = sid
            self.prev = self
            self.next = self

nodes = {}
    tail = None
    cursor = None
    result = []

for op in operations:
        action = op[0]

if action == 'addServer':
            sid = op[1]
            if sid in nodes:
                continue

node = Node(sid)
            nodes[sid] = node

if tail is None:
                tail = node
                cursor = node
            else:
                head = tail.next
                node.prev = tail
                node.next = head
                tail.next = node
                head.prev = node
                tail = node

elif action == 'removeServer':
            sid = op[1]
            node = nodes.pop(sid, None)
            if node is None:
                continue

if node.next is node:
                tail = None
                cursor = None
                continue

if cursor is node:
                cursor = node.next

node.prev.next = node.next
            node.next.prev = node.prev

if tail is node:
                tail = node.prev

else:  # route
            if cursor is None:
                result.append(None)
            else:
                result.append(cursor.sid)
                cursor = cursor.next

return result

def solution(operations, virtual_nodes):
    from bisect import bisect_left, insort

def ring_hash(s):
        total = 0
        for i, ch in enumerate(s):
            total += (i + 1) * ord(ch)
        return total

ring = []
    server_to_nodes = {}
    result = []

for op in operations:
        action = op[0]

if action == 'addServer':
            sid = op[1]
            if sid in server_to_nodes:
                continue

nodes = []
            for i in range(virtual_nodes):
                entry = (ring_hash(f'{sid}#{i}'), sid, i)
                insort(ring, entry)
                nodes.append(entry)
            server_to_nodes[sid] = nodes

elif action == 'removeServer':
            sid = op[1]
            nodes = server_to_nodes.pop(sid, None)
            if not nodes:
                continue

for entry in nodes:
                idx = bisect_left(ring, entry)
                if idx < len(ring) and ring[idx] == entry:
                    ring.pop(idx)

else:  # route
            request_id = op[1]
            if not ring:
                result.append(None)
                continue

key = (ring_hash(request_id), '', -1)
            idx = bisect_left(ring, key)
            if idx == len(ring):
                idx = 0
            result.append(ring[idx][1])

return result

Quick Overview

Examples

Solution

Hints

Part 2: Implement Request Routing with Round Robin

Constraints

Examples

Solution

Hints

Part 3: Implement Request Routing with Consistent Hashing

Constraints

Examples

Solution

Hints

Quick Overview