DoorDash Interview Questions

DoorDash needs to cache the most frequently accessed delivery routes to improve API response time.
Problem Statement: Implement an LRUCache class with the following methods:
- __init__(self, capacity: int): Initialize the LRU cache with positive size capacity.
- get(self, key: int) -> int: Return the value of the key if the key exists, otherwise return -1.
- put(self, key: int, value: int) -> None: Update the value of the key if the key exists, or add the key-value pair if the key does not exist. When the cache reaches its capacity, it should invalidate the least recently used item before inserting a new item.Example 1:
Input: cache = LRUCache(2)
cache.put(1, 1)
cache.put(2, 2)
cache.get(1)
Output: 1
Explanation: The cache contains 1 and 2, and the value for key 1 is 1.Constraints:
- 1 <= capacity <= 3000
- 0 <= key, value <= 10000

DoorDash needs to effectively match drivers to delivery requests based on location and time constraints.
Problem Statement: Given a grid of 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:
Input: orders = [[0,0,0],[0,1,0],[0,0,0]], start = (1, 1)
Output: 1
Explanation: The only reachable order is at (1,1).Constraints:
- 1 <= orders.length, orders[i].length <= 20
- 0 <= start[0] < orders.length
- 0 <= start[1] < orders[i].length

DoorDash needs a robust method to track orders and ensure timely deliveries based on real-time traffic data.
Problem Statement: Given an array of integers representing the estimated delivery times for incoming orders, implement a function maxDeliveryTime(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:
Input: orders = [2, 1, 3, 5, 6, 4], k = 3
Output: 14
Explanation: The best sub-array is [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.length