DoorDash Data Scientist Interview Questions

To enhance profitability, DoorDash intends to implement a dynamic pricing model based on demand and supply in various areas. Understanding the dynamics of pricing can improve revenue during peak times significantly.
Problem statement: Design a class to calculate the pricing for delivery based on real-time factors such as demand and supply in a specified area.
Class Signature: class DynamicPricing:
- def __init__(self): initializes the dynamic pricing model.
- def set_demand(self, area: str, demand: int) -> None: sets the demand level for an area.
- def set_supply(self, area: str, supply: int) -> None: sets the supply level for an area.
- def calculate_price(self, area: str) -> float: returns the calculated price based on current demand and supply levels.Example 1:
Input: `set_demand(

DoorDash is constantly looking to enhance customer experience through personalized recommendations based on previous orders. Implementing a recommendation system can optimize user engagement and satisfaction.
Problem statement: Design a class that allows users to add orders and retrieve recommendations based on the user's previous orders. The recommendations should prioritize items that have been ordered by similar users.
Class Signature: class RecommendationSystem:
- def __init__(self): initializes the recommendation system.
- def add_order(self, user_id: int, item_id: int) -> None: adds an order to the system.
- def recommend(self, user_id: int) -> List[int]: suggests items based on similar user orders.Example 1:
Input order: (user_id=1, item_id=101)
Input order: (user_id=1, item_id=102)
Recommended: Item 102
Explanation: If user 1 frequently orders item 101 and 102, item 102 would be prioritized in recommendations for user 1.Example 2:
Recommended for user 2 when they have no previous orders: []
Constraints:
- User ID and Item ID will always be positive integers.
- There will be at most 100000 different users.
- There will be at most 200000 different items.

To improve delivery efficiency, DoorDash wants to analyze how many restaurants per square mile lead to faster delivery times. This problem can be approached using binary search over a range of possible densities.
Problem statement: Given an array of integers where each integer denotes the delivery time for different restaurant densities, and an integer target that represents the maximum acceptable delivery time, find the highest restaurant density that results in a delivery time less than or equal to the target.
Method Signature: def max_density(delivery_times: List[int], target: int) -> int: - Returns the highest feasible restaurant density.Example 1:
Input: [3, 1, 4, 2, 2, 5], target = 3
Output: 2
Explanation: A density of 2 corresponds to delivery times within the acceptable limit.Example 2:
Input: [5, 3, 6, 9, 2], target = 5
Output: 1
Explanation: The best density maintaining a delivery time under or equal to the target is 1.Constraints:
- 1 <= len(delivery_times) <= 100000
- 1 <= delivery_times[i] <= 10000
- 1 <= target <= 10000

In the fast-paced world of food delivery, DoorDash aims to minimize delivery times while optimizing routes based on real-time traffic data. This involves keeping track of delivery estimates dynamically based on recent data.
Problem statement: Given an array of integers representing the time taken for each segment of a route, return the minimum time required to complete the delivery after analyzing k continuous segments using a sliding window approach.
Method Signature: def min_delivery_time(route: List[int], k: int) -> int: - Returns the minimum time for k continuous segments.Example 1:
Input: [2, 3, 1, 5, 3, 7, 2], k = 3
Output: 6
Explanation: The segments [1, 5, 3] provide the minimum delivery time of 6.Example 2:
Input: [4, 2, 6, 3, 5], k = 2
Output: 5
Explanation: The segments [2, 3] provide the minimum delivery time of 5.Constraints:
- 1 <= len(route) <= 100000
- 1 <= route[i] <= 1000
- 1 <= k <= len(route)