DoorDash software engineer interviews cover algorithms, data structures, system design, and coding problems drawn from real interview rounds.
Question You are tasked with implementing a Bootstrap API that aggregates data from multiple services for a given user. Given a userId, you...
Question You are in charge of implementing the Dasher payment model. Given the sequence of accepted/fulfilled order activities from a given dasher...
Input: ListQuestion You are given an m × n board representing a delivery area. The board contains: - 'X' - blockers (obstacles) - 'D' - DashMarts...
Question You are given two tree structures representing an old menu and a new menu. Each tree node has: - key: identifier for the menu...
LocationIndex class that stores a set of named points on a 2D grid. The constructor takes three arrays: names (list of location name...Input: 2D gridm x n matrices: coverage and demand. A cell in demand is active if its value is 1. Active cells that are...Input: Number(s)template string consisting only of the characters '0', '1', and '?', and a list of integers run_lengths. A '?' in the...Input: Array of integersvalues. At each step, identify all eligible values: a value is eligible if it is strictly greater than...Input: ListDirectoryRegistry class that manages a hierarchical key-value store modeled as a tree of paths. The root path "/" always exists with...Input: Stringrecords, a list of ride events. Each record is a list of three strings: [ride_id, timestamp, status]. Possible statuses are...Input: Liststart time and an end time, generate all meeting check-in slots at 5-minute intervals after start up to and including end. The...Input: Listkey...Input: Listdelivery_id, dasher_id, accepted_min, completed_min, wait_minutes, and tip. Times are integer minute offsets on one shared timeline; money is a decimal string with exactly two fractional digits.[accepted_min, completed_min). For each Dasher, BASE_PAY is $0.30 per minute multiplied by min(2, active_delivery_count). Three simultaneous deliveries therefore earn $0.60 per minute, not $0.90. Inactive time earns nothing.WAIT_BONUS is computed independently for every delivery: $0.20 × max(0, wait_minutes - 10). This bonus is additional to base pay.TIPS is the sum of all tips and is never capped or reduced.dasher_id, containing base pay, wait bonus, tips, and total pay. Empty input returns an empty result. The return type is up to you; the examples show the required information as JSON. Represent monetary results exactly, without floating-point arithmetic.calculate_payout(deliveries: list[dict[str, str]])Example 1:{
"deliveries": [
{"delivery_id":"a","dasher_id":"d1","accepted_min":"0","completed_min":"20","wait_minutes":"12","tip":"2.00"},
{"delivery_id":"b","dasher_id":"d1","accepted_min":"10","completed_min":"30","wait_minutes":"10","tip":"1.00"},
{"delivery_id":"c","dasher_id":"d1","accepted_min":"15","completed_min":"25","wait_minutes":"0","tip":"0.00"},
{"delivery_id":"d","dasher_id":"d2","accepted_min":"0","completed_min":"10","wait_minutes":"0","tip":"3.00"},
{"delivery_id":"e","dasher_id":"d2","accepted_min":"10","completed_min":"20","wait_minutes":"10","tip":"0.00"}
]
}[
{"dasher_id":"d1","base_pay":"13.50","wait_bonus":"0.40","tips":"3.00","total_pay":"16.90"},
{"dasher_id":"d2","base_pay":"6.00","wait_bonus":"0.00","tips":"3.00","total_pay":"9.00"}
]10×1 + 5×2 + 5×2 + 5×2 + 5×1 = 45, giving $13.50. Only delivery a exceeds the wait threshold, earning 2×$0.20 = $0.40; total pay is $13.50 + $0.40 + $3.00 = $16.90. For d2, the touching intervals contribute 20 active minutes, giving $6.00 + $3.00 = $9.00.Part 2 — Apply independently configured promotionspromotions. Every promotion applies independently to every Dasher appearing in the delivery input. Discuss how the return type changes to explain adjustments before implementing this extension. The approach must be flexible enough to support future promotion types without rewriting the Part 1 earnings rules.PEAK map contains rule_id, type, start_min, end_min, rate, and cap. Its raw reward is rate × capped active-delivery minutes within [start_min, end_min), using the same min(2, active_delivery_count) as base pay. Its credited reward is min(raw reward, cap). The cap applies separately to each Dasher and each rule. Overlapping PEAK rules stack; neither consumes another's cap.GUARANTEE map contains rule_id, type, min_deliveries, and amount. A Dasher qualifies when their number of input delivery records is at least min_deliveries. A qualifying rule credits max(0, amount - eligible_earnings), where eligible earnings include base pay, wait bonus, all PEAK rewards, and previously credited GUARANTEE adjustments, but exclude tips. A nonqualifying rule credits $0.00.rule_id order, then all GUARANTEE rules in lexicographic rule_id order. Consequently, multiple guarantees establish a floor rather than being summed as separate bonuses.adjustments list to each result whenever the promotions argument is supplied, even if that argument is empty. Include every configured rule, including zero-dollar adjustments, in evaluation order. Each adjustment identifies rule_id and credited amount. Final total pay includes all adjustments and tips.calculate_payout(deliveries: list[dict[str, str]], promotions: list[dict[str, str]] | None = None)Example 2:{
"deliveries": [
{"delivery_id":"a","dasher_id":"d1","accepted_min":"0","completed_min":"20","wait_minutes":"12","tip":"2.00"},
{"delivery_id":"b","dasher_id":"d1","accepted_min":"10","completed_min":"30","wait_minutes":"10","tip":"1.00"},
{"delivery_id":"d","dasher_id":"d2","accepted_min":"0","completed_min":"10","wait_minutes":"0","tip":"3.00"},
{"delivery_id":"e","dasher_id":"d2","accepted_min":"10","completed_min":"20","wait_minutes":"10","tip":"0.00"}
],
"promotions": [
{"rule_id":"G_SHIFT","type":"GUARANTEE","min_deliveries":"2","amount":"15.00"},
{"rule_id":"P_LUNCH","type":"PEAK","start_min":"10","end_min":"25","rate":"0.10","cap":"2.00"}
]
}[
{"dasher_id":"d1","base_pay":"12.00","wait_bonus":"0.40","tips":"3.00","adjustments":[{"rule_id":"P_LUNCH","amount":"2.00"},{"rule_id":"G_SHIFT","amount":"0.60"}],"total_pay":"18.00"},
{"dasher_id":"d2","base_pay":"6.00","wait_bonus":"0.00","tips":"3.00","adjustments":[{"rule_id":"P_LUNCH","amount":"1.00"},{"rule_id":"G_SHIFT","amount":"8.00"}],"total_pay":"18.00"}
]10×2 + 5×1 = 25 capped minutes yield $2.50, capped at $2.00. Eligible earnings become $12.00 + $0.40 + $2.00 = $14.40, so the guarantee adds $0.60; tips bring the total to $18.00. d2 has 10 capped minutes inside the PEAK window, earning $1.00; eligible earnings are $7.00, so the guarantee adds $8.00, followed by $3.00 in tips.Example 3:{
"deliveries": [
{"delivery_id":"x","dasher_id":"d1","accepted_min":"0","completed_min":"20","wait_minutes":"11","tip":"1.00"},
{"delivery_id":"y","dasher_id":"d1","accepted_min":"0","completed_min":"20","wait_minutes":"12","tip":"2.00"},
{"delivery_id":"z","dasher_id":"d1","accepted_min":"0","completed_min":"20","wait_minutes":"10","tip":"0.00"}
],
"promotions": [
{"rule_id":"G_C","type":"GUARANTEE","min_deliveries":"4","amount":"100.00"},
{"rule_id":"P_B","type":"PEAK","start_min":"5","end_min":"15","rate":"0.20","cap":"2.00"},
{"rule_id":"G_B","type":"GUARANTEE","min_deliveries":"3","amount":"20.00"},
{"rule_id":"P_A","type":"PEAK","start_min":"0","end_min":"20","rate":"0.10","cap":"3.00"},
{"rule_id":"G_A","type":"GUARANTEE","min_deliveries":"3","amount":"18.00"}
]
}[
{"dasher_id":"d1","base_pay":"12.00","wait_bonus":"0.60","tips":"3.00","adjustments":[{"rule_id":"P_A","amount":"3.00"},{"rule_id":"P_B","amount":"2.00"},{"rule_id":"G_A","amount":"0.40"},{"rule_id":"G_B","amount":"2.00"},{"rule_id":"G_C","amount":"0.00"}],"total_pay":"23.00"}
]20×2 = 40 minutes, so base pay is $12.00. Deliveries x and y exceed the wait threshold, earning $0.20 + $0.40 = $0.60. Both PEAK rules fire on overlapping work: P_A earns 40×$0.10 = $4.00, capped at $3.00; P_B earns 10×2×$0.20 = $4.00, capped at $2.00. Eligible earnings are $17.60. G_A adds $0.40 to reach $18.00, G_B adds $2.00 to reach $20.00, and G_C adds nothing because there are only three deliveries. Tips are excluded from both guarantee calculations and bring total pay to $23.00.Notes:0 <= accepted_min < completed_min <= 10^9, 0 <= start_min < end_min <= 10^9, and wait minutes do not exceed delivery duration.min_deliveries is a positive integer. There are no cancellations, duplicate records, time-zone conversions, or fractional minutes.None if the tree contains fewer than two live nodes.Function or class signatureTreeNode(val: int, left: Optional[TreeNode] = None, right: Optional[TreeNode] = None) — binary-tree node representation.max_live_node_path_sum(root: Optional[TreeNode]) -> Optional[int] — return the maximum valid path sum, or None when no valid path exists.root = [5, 2, -3, 4, -6, null, 7], using level-order serialization with null for missing children.5
/ \
2 -3
/ \ \
4 -6 7Output: 15Explanation: The live nodes are 4, -6, and 7. The best path is 4 → 2 → 5 → -3 → 7, with sum 4 + 2 + 5 - 3 + 7 = 15. The other two leaf-to-leaf paths have sums 0 and 5.Example 2:Input: root = [-5, -2, -3].-5
/ \
-2 -3Output: -10Explanation: There are exactly two live nodes, so the only valid path is -2 → -5 → -3. Returning -2 would be incorrect because a single node is not a path between two distinct live nodes.Constraints:0 and 200000 nodes.[-1000000000, 1000000000].O(n) time, where n is the number of nodes.O(n) time. If multiple paths tie, any one is acceptable. Explain how to avoid copying a complete path at every node.LRUCache that supports the following operations: get(key) and put(key, value). The get method retrieves the value associated with the key if it exists, and also marks that key as recently used. The put method stores or updates the value associated with a specific key. If the cache exceeds its capacity, it should evict the least recently used item.Function/class signature:def get(self, key: int) -> int:def put(self, key: int, value: int) -> None:cache = LRUCache(2); cache.put(1, 1); cache.put(2, 2); cache.get(1);1 (Explanation: returns 1 as it is the value for key 1)cache.put(3, 3) (evicts key 2); cache.get(2);-1 (Explanation: returns -1 since key 2 was evicted)1 <= capacity <= 30000 <= key <= 10^40 <= value <= 10^4get and put operations will be called at most 3 * 10^4 times in total.MedianFinder that supports the addition of numbers and can return the median of all added numbers efficiently. Ensure that the implementation uses two heaps to keep track of the lower half and the upper half of the numbers. def addNum(self, num: int) -> None: def findMedian(self) -> float: medianFinder = MedianFinder() medianFinder.addNum(1) medianFinder.addNum(2) medianFinder.findMedian() 1.5 medianFinder.addNum(3) medianFinder.findMedian() 2.0 10000 calls to addNum and findMedian. findMedian.def optimal_dasher_route(locations: List[Tuple[float, float]]) -> List[Tuple[float, float]]:[(1.0, 1.0), (2.0, 2.0), (3.0, 1.5)] Output: [(1.0, 1.0), (2.0, 2.0), (3.0, 1.5)] Explanation: The optimal path starts from the first location, goes to the second, and finally to the third.[(5.0, 5.0), (1.0, 1.0), (2.0, 2.0)] Output: [(1.0, 1.0), (2.0, 2.0), (5.0, 5.0)] Explanation: The optimal path starts from the closest location at (1.0, 1.0).def compute_driver_payout(events: List[Tuple[datetime, float]], bonus_multipliers: List[Tuple[str, float]]) -> float:events = [('2023-05-01T08:00:00', 10.0), ('2023-05-01T09:00:00', 5.0)], bonus_multipliers = [('peak_hour', 2.0), ('completing_5_deliveries', 1.5)]37.5events = [('2023-05-01T10:00:00', 20.0), ('2023-05-01T11:00:00', 15.0)], bonus_multipliers = [('non_peak', 1.0), ('bonus_for_10_deliveries', 2.0)]70.00 <= len(events) <= 1000 <= len(bonus_multipliers) <= 10compute_payout(driver_id: int, events: List[Tuple[int, float, int]]) -> float, which takes the driver's ID and a list of events where each event is a tuple containing: event_time (int): The timestamp of the event in seconds.base_payout (float): The base payout for the delivery.bonus_multiplier (int): A bonus multiplier applied if certain conditions are met (e.g., if two deliveries are made within a specific time frame).def compute_payout(driver_id: int, events: List[Tuple[int, float, int]]) -> float:driver_id = 1, events = [(1, 10.0, 1), (2, 15.0, 2)] 35.0 driver_id = 2, events = [(1, 5.0, 1), (10, 8.0, 2)]13.0 driver_id ≤ 10000 event_time ≤ 10^6 base_payout ≤ 1000 bonus_multiplier ≤ 5 events can be at most 1000.YYYY-MM-DD HH:MM:SS and each driver can have multiple deliveries at the same timestamp.def count_unique_deliveries(drivers: List[str], timestamps: List[str]) -> Dict[str, int]:drivers = ['A', 'A', 'B', 'A', 'B'], timestamps = ['2023-10-01 14:00:00', '2023-10-01 14:00:00', '2023-10-01 14:05:00', '2023-10-01 14:10:00', '2023-10-01 14:05:00'] {'A': 3, 'B': 1} drivers = ['C', 'C', 'C', 'C'], timestamps = ['2023-10-01 14:00:00', '2023-10-01 15:00:00', '2023-10-01 14:00:00', '2023-10-01 15:00:00'] {'C': 2} 1 <= len(drivers) <= 10^4 1 <= len(timestamps) <= 10^4 n x m representing a map where 1 represents an order location and 0 represents an empty space, implement a function maxDrivers(orders: List[List[int]], start: Tuple[int, int]) -> int that returns the maximum number of deliveries that can be assigned to drivers originating from start position.Example 1:orders = [[0,0,0],[0,1,0],[0,0,0]], start = (1, 1) 1 1 <= orders.length, orders[i].length <= 20 0 <= start[0] < orders.length 0 <= start[1] < orders[i].lengthmaxDeliveryTime(orders: List[int], k: int) -> int that returns the maximum possible delivery time over any sub-array of size k, where k is the number of concurrent deliveries.Example 1:orders = [2, 1, 3, 5, 6, 4], k = 3 14 [5, 6, 4], which yields a delivery time of 5 + 6 + 4 = 15.Constraints: 1 <= orders.length <= 100000 1 <= orders[i] <= 1000 1 <= k <= orders.lengthSign up for free to access walkthroughs, AI-generated questions, and more.
Get Started Free