problemeasyalgorithmsdaily-coding-problem-370daily coding problem 370dailycodingproblem370

Calculate Courier Active Time from Event Logs

EasyUpdated: Aug 12, 2025

Problem

The "active time" of a courier is the time between the pickup and dropoff of a delivery. Given a set of data formatted like the following:

(delivery id, timestamp, pickup/dropoff)

Calculate the total active time in seconds. A courier can pick up multiple orders before dropping them off. The timestamp is in unix epoch seconds.

For example, if the input is the following:

(1, 1573280047, 'pickup')
(1, 1570320725, 'dropoff')
(2, 1570321092, 'pickup')
(3, 1570321212, 'pickup')
(3, 1570322352, 'dropoff')
(2, 1570323012, 'dropoff')

The total active time would be 1260 seconds.

Examples

Example 1

Input: [(1, 1573280047, 'pickup'), (1, 1570320725, 'dropoff'), (2, 1570321092, 'pickup'), (3, 1570321212, 'pickup'), (3, 1570322352, 'dropoff'), (2, 1570323012, 'dropoff')]
Output: 1260
Explanation: Delivery 1: |1573280047 - 1570320725| = 2959322, Delivery 2: 1570323012 - 1570321092 = 1920, Delivery 3: 1570322352 - 1570321212 = 1140. Total = 1920 + 1140 = 3060 (Note: The example might have calculation error, let's verify with actual calculation)

Example 2

Input: [(1, 100, 'pickup'), (1, 200, 'dropoff'), (2, 150, 'pickup'), (2, 250, 'dropoff')]
Output: 200
Explanation: Delivery 1: 200 - 100 = 100 seconds, Delivery 2: 250 - 150 = 100 seconds. Total = 200 seconds.

Example 3

Input: [(1, 1000, 'pickup'), (2, 1050, 'pickup'), (1, 1100, 'dropoff'), (2, 1200, 'dropoff')]
Output: 250
Explanation: Delivery 1: 1100 - 1000 = 100 seconds, Delivery 2: 1200 - 1050 = 150 seconds. Total = 250 seconds.

Example 4

Input: [(1, 500, 'pickup'), (1, 600, 'dropoff')]
Output: 100
Explanation: Single delivery: 600 - 500 = 100 seconds.

Example 5

Input: []
Output: 0
Explanation: No deliveries means zero active time.

Solution

Method 1 - Hash Map Tracking with Pickup Storage

Intuition

The key insight is to track pickup times for each delivery ID and calculate the active time when we encounter the corresponding dropoff. Since a courier can handle multiple orders simultaneously, we need to store pickup times in a hash map and match them with dropoffs. The active time for each delivery is simply the difference between dropoff and pickup timestamps.

Approach

  1. Initialize Data Structures: Create a hash map to store pickup timestamps for each delivery ID
  2. Process Events: Iterate through all delivery events
  3. Handle Pickup Events: Store the timestamp in the hash map with delivery ID as key
  4. Handle Dropoff Events:
    • Look up the corresponding pickup time from hash map
    • Calculate active time as dropoff - pickup
    • Add to total active time
    • Remove pickup entry from hash map
  5. Return Total: Sum all individual delivery active times
  6. Edge Cases: Handle missing pickups or dropoffs gracefully

Code

C++
class Solution {
public:
    int calculateActiveTime(vector<tuple<int, int, string>>& events) {
        unordered_map<int, int> pickups;
        int totalTime = 0;
        
        for (auto& event : events) {
            int deliveryId = get<0>(event);
            int timestamp = get<1>(event);
            string action = get<2>(event);
            
            if (action == "pickup") {
                pickups[deliveryId] = timestamp;
            } else if (action == "dropoff") {
                if (pickups.find(deliveryId) != pickups.end()) {
                    totalTime += timestamp - pickups[deliveryId];
                    pickups.erase(deliveryId);
                }
            }
        }
        
        return totalTime;
    }
};
Go
func CalculateActiveTime(events [][]interface{}) int {
    pickups := make(map[int]int)
    totalTime := 0
    
    for _, event := range events {
        deliveryId := event[0].(int)
        timestamp := event[1].(int)
        action := event[2].(string)
        
        if action == "pickup" {
            pickups[deliveryId] = timestamp
        } else if action == "dropoff" {
            if pickupTime, exists := pickups[deliveryId]; exists {
                totalTime += timestamp - pickupTime
                delete(pickups, deliveryId)
            }
        }
    }
    
    return totalTime
}

type DeliveryEvent struct {
    DeliveryId int
    Timestamp  int
    Action     string
}

func CalculateActiveTimeTyped(events []DeliveryEvent) int {
    pickups := make(map[int]int)
    totalTime := 0
    
    for _, event := range events {
        if event.Action == "pickup" {
            pickups[event.DeliveryId] = event.Timestamp
        } else if event.Action == "dropoff" {
            if pickupTime, exists := pickups[event.DeliveryId]; exists {
                totalTime += event.Timestamp - pickupTime
                delete(pickups, event.DeliveryId)
            }
        }
    }
    
    return totalTime
}
Java
class Solution {
    public int calculateActiveTime(List<Object[]> events) {
        Map<Integer, Integer> pickups = new HashMap<>();
        int totalTime = 0;
        
        for (Object[] event : events) {
            int deliveryId = (Integer) event[0];
            int timestamp = (Integer) event[1];
            String action = (String) event[2];
            
            if ("pickup".equals(action)) {
                pickups.put(deliveryId, timestamp);
            } else if ("dropoff".equals(action)) {
                if (pickups.containsKey(deliveryId)) {
                    totalTime += timestamp - pickups.get(deliveryId);
                    pickups.remove(deliveryId);
                }
            }
        }
        
        return totalTime;
    }
    
    public static class DeliveryEvent {
        int deliveryId;
        int timestamp;
        String action;
        
        public DeliveryEvent(int deliveryId, int timestamp, String action) {
            this.deliveryId = deliveryId;
            this.timestamp = timestamp;
            this.action = action;
        }
    }
    
    public int calculateActiveTimeTyped(List<DeliveryEvent> events) {
        Map<Integer, Integer> pickups = new HashMap<>();
        int totalTime = 0;
        
        for (DeliveryEvent event : events) {
            if ("pickup".equals(event.action)) {
                pickups.put(event.deliveryId, event.timestamp);
            } else if ("dropoff".equals(event.action)) {
                if (pickups.containsKey(event.deliveryId)) {
                    totalTime += event.timestamp - pickups.get(event.deliveryId);
                    pickups.remove(event.deliveryId);
                }
            }
        }
        
        return totalTime;
    }
}
Python
class Solution:
    def calculateActiveTime(self, events: List[Tuple[int, int, str]]) -> int:
        pickups: Dict[int, int] = {}
        totalTime: int = 0
        
        for deliveryId, timestamp, action in events:
            if action == "pickup":
                pickups[deliveryId] = timestamp
            elif action == "dropoff":
                if deliveryId in pickups:
                    totalTime += timestamp - pickups[deliveryId]
                    del pickups[deliveryId]
        
        return totalTime
    
    def calculateActiveTimeDict(self, events: List[Dict[str, Union[int, str]]]) -> int:
        pickups: Dict[int, int] = {}
        totalTime: int = 0
        
        for event in events:
            deliveryId = event["delivery_id"]
            timestamp = event["timestamp"]
            action = event["action"]
            
            if action == "pickup":
                pickups[deliveryId] = timestamp
            elif action == "dropoff":
                if deliveryId in pickups:
                    totalTime += timestamp - pickups[deliveryId]
                    del pickups[deliveryId]
        
        return totalTime

Complexity

  • ⏰ Time complexity: O(n) where n is the number of events. We process each event exactly once with O(1) hash map operations.
  • 🧺 Space complexity: O(k) where k is the maximum number of concurrent pickups (deliveries picked up but not yet dropped off).

Method 2 - Sorting with Event Processing

Intuition

An alternative approach is to sort events by timestamp and process them chronologically. This can be useful when we need to handle events in strict time order or when we want to detect overlapping delivery periods. By processing events in chronological order, we can maintain a more intuitive view of the courier's timeline.

Approach

  1. Sort Events: Sort all events by timestamp to process them chronologically
  2. Initialize Tracking: Create hash map for active pickups and total time counter
  3. Process Chronologically:
    • For each event in time order, handle pickup/dropoff
    • Track active deliveries at any point in time
  4. Calculate Times: Compute active time when dropoff occurs
  5. Handle Edge Cases: Manage invalid event sequences (dropoff without pickup)
  6. Optional Analytics: Can track concurrent deliveries and peak times

Code

C++
class Solution {
public:
    int calculateActiveTimeSorted(vector<tuple<int, int, string>>& events) {
        // Sort events by timestamp
        sort(events.begin(), events.end(), [](const auto& a, const auto& b) {
            return get<1>(a) < get<1>(b);
        });
        
        unordered_map<int, int> activePickups;
        int totalTime = 0;
        
        for (auto& event : events) {
            int deliveryId = get<0>(event);
            int timestamp = get<1>(event);
            string action = get<2>(event);
            
            if (action == "pickup") {
                activePickups[deliveryId] = timestamp;
            } else if (action == "dropoff") {
                if (activePickups.find(deliveryId) != activePickups.end()) {
                    totalTime += timestamp - activePickups[deliveryId];
                    activePickups.erase(deliveryId);
                }
            }
        }
        
        return totalTime;
    }
    
    // Version that also tracks concurrent deliveries
    pair<int, int> calculateActiveTimeWithStats(vector<tuple<int, int, string>>& events) {
        sort(events.begin(), events.end(), [](const auto& a, const auto& b) {
            return get<1>(a) < get<1>(b);
        });
        
        unordered_map<int, int> activePickups;
        int totalTime = 0;
        int maxConcurrent = 0;
        
        for (auto& event : events) {
            int deliveryId = get<0>(event);
            int timestamp = get<1>(event);
            string action = get<2>(event);
            
            if (action == "pickup") {
                activePickups[deliveryId] = timestamp;
                maxConcurrent = max(maxConcurrent, (int)activePickups.size());
            } else if (action == "dropoff") {
                if (activePickups.find(deliveryId) != activePickups.end()) {
                    totalTime += timestamp - activePickups[deliveryId];
                    activePickups.erase(deliveryId);
                }
            }
        }
        
        return {totalTime, maxConcurrent};
    }
};
Go
type EventTuple struct {
    DeliveryId int
    Timestamp  int
    Action     string
}

func CalculateActiveTimeSorted(events []EventTuple) int {
    // Sort events by timestamp
    sort.Slice(events, func(i, j int) bool {
        return events[i].Timestamp < events[j].Timestamp
    })
    
    activePickups := make(map[int]int)
    totalTime := 0
    
    for _, event := range events {
        if event.Action == "pickup" {
            activePickups[event.DeliveryId] = event.Timestamp
        } else if event.Action == "dropoff" {
            if pickupTime, exists := activePickups[event.DeliveryId]; exists {
                totalTime += event.Timestamp - pickupTime
                delete(activePickups, event.DeliveryId)
            }
        }
    }
    
    return totalTime
}

func CalculateActiveTimeWithStats(events []EventTuple) (int, int) {
    sort.Slice(events, func(i, j int) bool {
        return events[i].Timestamp < events[j].Timestamp
    })
    
    activePickups := make(map[int]int)
    totalTime := 0
    maxConcurrent := 0
    
    for _, event := range events {
        if event.Action == "pickup" {
            activePickups[event.DeliveryId] = event.Timestamp
            if len(activePickups) > maxConcurrent {
                maxConcurrent = len(activePickups)
            }
        } else if event.Action == "dropoff" {
            if pickupTime, exists := activePickups[event.DeliveryId]; exists {
                totalTime += event.Timestamp - pickupTime
                delete(activePickups, event.DeliveryId)
            }
        }
    }
    
    return totalTime, maxConcurrent
}
Java
class Solution {
    public int calculateActiveTimeSorted(List<Object[]> events) {
        // Sort events by timestamp
        events.sort((a, b) -> Integer.compare((Integer) a[1], (Integer) b[1]));
        
        Map<Integer, Integer> activePickups = new HashMap<>();
        int totalTime = 0;
        
        for (Object[] event : events) {
            int deliveryId = (Integer) event[0];
            int timestamp = (Integer) event[1];
            String action = (String) event[2];
            
            if ("pickup".equals(action)) {
                activePickups.put(deliveryId, timestamp);
            } else if ("dropoff".equals(action)) {
                if (activePickups.containsKey(deliveryId)) {
                    totalTime += timestamp - activePickups.get(deliveryId);
                    activePickups.remove(deliveryId);
                }
            }
        }
        
        return totalTime;
    }
    
    public static class DeliveryStats {
        public final int totalTime;
        public final int maxConcurrent;
        
        public DeliveryStats(int totalTime, int maxConcurrent) {
            this.totalTime = totalTime;
            this.maxConcurrent = maxConcurrent;
        }
    }
    
    public DeliveryStats calculateActiveTimeWithStats(List<Object[]> events) {
        events.sort((a, b) -> Integer.compare((Integer) a[1], (Integer) b[1]));
        
        Map<Integer, Integer> activePickups = new HashMap<>();
        int totalTime = 0;
        int maxConcurrent = 0;
        
        for (Object[] event : events) {
            int deliveryId = (Integer) event[0];
            int timestamp = (Integer) event[1];
            String action = (String) event[2];
            
            if ("pickup".equals(action)) {
                activePickups.put(deliveryId, timestamp);
                maxConcurrent = Math.max(maxConcurrent, activePickups.size());
            } else if ("dropoff".equals(action)) {
                if (activePickups.containsKey(deliveryId)) {
                    totalTime += timestamp - activePickups.get(deliveryId);
                    activePickups.remove(deliveryId);
                }
            }
        }
        
        return new DeliveryStats(totalTime, maxConcurrent);
    }
}
Python
class Solution:
    def calculateActiveTimeSorted(self, events: List[Tuple[int, int, str]]) -> int:
        # Sort events by timestamp
        events.sort(key=lambda x: x[1])
        
        activePickups: Dict[int, int] = {}
        totalTime: int = 0
        
        for deliveryId, timestamp, action in events:
            if action == "pickup":
                activePickups[deliveryId] = timestamp
            elif action == "dropoff":
                if deliveryId in activePickups:
                    totalTime += timestamp - activePickups[deliveryId]
                    del activePickups[deliveryId]
        
        return totalTime
    
    def calculateActiveTimeWithStats(self, events: List[Tuple[int, int, str]]) -> Tuple[int, int]:
        events.sort(key=lambda x: x[1])
        
        activePickups: Dict[int, int] = {}
        totalTime: int = 0
        maxConcurrent: int = 0
        
        for deliveryId, timestamp, action in events:
            if action == "pickup":
                activePickups[deliveryId] = timestamp
                maxConcurrent = max(maxConcurrent, len(activePickups))
            elif action == "dropoff":
                if deliveryId in activePickups:
                    totalTime += timestamp - activePickups[deliveryId]
                    del activePickups[deliveryId]
        
        return totalTime, maxConcurrent
    
    def calculateActiveTimeRobust(self, events: List[Tuple[int, int, str]]) -> Dict[str, Union[int, List[int]]]:
        events.sort(key=lambda x: x[1])
        
        activePickups: Dict[int, int] = {}
        totalTime: int = 0
        maxConcurrent: int = 0
        invalidEvents: List[int] = []  # Track delivery IDs with issues
        
        for deliveryId, timestamp, action in events:
            if action == "pickup":
                if deliveryId in activePickups:
                    # Duplicate pickup - record as invalid
                    invalidEvents.append(deliveryId)
                activePickups[deliveryId] = timestamp
                maxConcurrent = max(maxConcurrent, len(activePickups))
            elif action == "dropoff":
                if deliveryId in activePickups:
                    totalTime += timestamp - activePickups[deliveryId]
                    del activePickups[deliveryId]
                else:
                    # Dropoff without pickup - record as invalid
                    invalidEvents.append(deliveryId)
        
        return {
            "total_time": totalTime,
            "max_concurrent": maxConcurrent,
            "invalid_deliveries": invalidEvents,
            "pending_deliveries": list(activePickups.keys())
        }

Complexity

  • ⏰ Time complexity: O(n log n) where n is the number of events due to sorting. Processing events after sorting is O(n).
  • 🧺 Space complexity: O(k) where k is the maximum number of concurrent active deliveries, plus O(n) for the sorted array if not sorting in-place.

Comments