DoorDash Mobile Engineer Interview Questions

DoorDash relies on drivers to fulfill user orders on time while maximizing efficiency. We want to ensure that drivers can cover as many orders as possible within a certain time window.
Problem Statement: Given an array of integers representing the times taken to deliver each order and an integer t for the total time available, return the maximum number of orders that can be delivered in that time frame.
Example 1:
Input: orders = [2, 3, 1, 5, 4], t = 7
Output: 4
Explanation: The maximum number of orders within the time frame is 4 (taking 1+2+3+1 = 7).Constraints:
- 1 <= orders.length <= 10000
- 1 <= orders[i] <= 1000
- 1 <= t <= 10000

DoorDash calls various APIs to fetch restaurant data. To improve performance and reduce unnecessary network calls, we need an efficient LRU (Least Recently Used) caching mechanism.
Problem Statement: Implement an LRUCache class that supports the following operations:
- get(key: int) -> int: Returns the value of the key if the key exists in the cache, otherwise returns -1.
- put(key: int, value: int) -> None: Updates the value of the key if the key exists, otherwise adds the key-value pair to the cache. 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) # returns 1
cache.put(3, 3) # evicts key 2
cache.get(2) # returns -1 (not found)Output:
1
-1Constraints:
- 1 <= capacity <= 3000
- 0 <= key <= 10000
- 0 <= value <= 10000

To ensure that users can continue placing orders even when they are offline, DoorDash requires a robust data synchronization system that prioritizes data consistency and user experience, especially in areas with poor connectivity.
Problem Statement: Create an OfflineSyncEngine class that handles data synchronization between local user actions and the remote server.
- queueAction(action: UserAction): Queues a user action to be executed when the device goes online.
- sync(): Syncs all queued actions with the remote server.
- getPendingActions(): Returns all actions that are queued but not yet synced.Example 1:
Input: queueAction(new UserAction('placeOrder', orderDetails))
Output: Action queued successfullyConstraints:
- The system must handle conflicts when syncing actions performed offline.
- Keep track of queued actions for resending if sync fails.

As DoorDash generates various real-time events like order updates, the mobile app needs a way to efficiently deliver push notifications to users, enhancing user engagement and information delivery accuracy.
Problem Statement: Implement a PushNotificationManager class that handles the scheduling, sending, and managing of push notifications to users.
- sendNotification(userId: String, message: String): This method sends a notification to a specified user.
- scheduleNotification(userId: String, message: String, time: Date): This schedules a notification to be sent in the future.
- cancelScheduledNotification(notificationId: String): This cancels a previously scheduled notification.Example 1:
Input: sendNotification('user1', 'Your order has been delivered!')
Output: Notification sent to user1Constraints:
- The manager must scale to handle thousands of notifications per second.
- User can receive multiple notifications simultaneously.