Average Waiting Time

class Solution {
public:
    double calculateAverageWaitTime(vector<vector<int>>& customerData) {
        int chefIdleTime = 0;
        long long totalWaitTime = 0;

        for (int idx = 0; idx < customerData.size(); idx++) {
            chefIdleTime = max(customerData[idx][0], chefIdleTime) + customerData[idx][1];
            totalWaitTime += chefIdleTime - customerData[idx][0];
        }

        double avgWaitTime = static_cast<double>(totalWaitTime) / customerData.size();
        return avgWaitTime;
    }
};

This solution calculates the average waiting time given a list of customer data where each customer's data is represented as a pair containing their arrival time and the time taken for their order to be prepared. Written in C++, the code defines a function named calculateAverageWaitTime within a class named Solution. Here’s a breakdown of the key elements of the implementation:

• Variables Initialization:

  • chefIdleTime tracks the next available time when the chef can start preparing the next order.
  • totalWaitTime accumulates the waiting times of all customers.

• Iteration through Customer Data:

  • The loop iterates through each customer in customerData.
  • For each customer, chefIdleTime is updated to be the maximum of the current chefIdleTime or the customer's arrival time, incremented by the time it takes to prepare their order.
  • totalWaitTime includes the difference between chefIdleTime and the customer's arrival time, effectively calculating how long the customer waited.

• Average Waiting Time Calculation:

  • The average waiting time is calculated by dividing totalWaitTime by the number of customers.
  • The method uses static_cast<double> to ensure the division is done in floating-point rather than integer division, for accuracy.

• Return Value:

  • The function returns the calculated average waiting time as a double.

This method provides a direct and efficient way to compute the average waiting time, taking advantage of simple arithmetic operations and iterating through customer data only once, thus maintaining a linear time complexity relative to the number of customers.

class Solution {

    public double calculateAverageWait(int[][] people) {
        int readyAt = 0;
        long totalWaitTime = 0;

        for (int index = 0; index < people.length; index++) {
            readyAt = Math.max(people[index][0], readyAt) + people[index][1];
            totalWaitTime += readyAt - people[index][0];
        }

        double avgWaitTime = (double) totalWaitTime / people.length;
        return avgWaitTime;
    }
}

This solution determines the average waiting time of patrons at a restaurant, provided their arrival times and the time taken to serve them, following a batch processing method where only one person can be served at a time.

The calculateAverageWait method performs the following calculations:

• Initializes readyAt to track when the chef is ready to serve the next person.

• Initializes totalWaitTime to accumulate the total waiting time.

• Iterates through the people array containing each person's arrival time and the time required to serve them:

  • Updates readyAt to be the maximum of the current time or the person's arrival time, then adds the time required to serve them.
  • Adds the difference between readyAt and the person's arrival time to totalWaitTime.

• Finally, calculates the average waiting time by dividing totalWaitTime by the number of people and returns this value.

This approach efficiently computes the sum of waiting times and then divides by the number of arrivals, yielding the average waiting time. The solution handles each patron one-by-one, updating the service readiness and total wait times accordingly.

class Solution:
    def calculateAvgWaitTime(self, clients: List[List[int]]) -> float:
        time_free = 0
        total_waiting_time = 0

        for visitor in clients:
            time_free = max(visitor[0], time_free) + visitor[1]
            total_waiting_time += time_free - visitor[0]

        average_time = total_waiting_time / len(clients)
        return average_time

This solution calculates the average waiting time of a series of client visits to a restaurant. It assumes that each visitor in the clients list provides two values: the arrival time and the time taken for service. The solution processes each client one by one to compute the ending time of their service based on when the prior service was completed (time_free). The waiting time for each client is then calculated by subtracting the arrival time from this service completion time, and the total waiting time is accumulated. Finally, the average waiting time is derived by dividing the total waiting time by the number of clients.

Follow these steps to understand the computation:

1. Initialize time_free to zero to track when the restaurant can start serving the next client.
2. Initialize total_waiting_time to zero to accumulate the total waiting time of all clients.
3. Iterate through each visitor in the clients list:
   • Update time_free to the maximum of the current client's arrival time or the restaurant's free time plus the service duration.
   • Add the difference between time_free and the client's arrival time to total_waiting_time.
4. Compute the average waiting time by dividing total_waiting_time by the number of clients.
5. Return the average_time.

This algorithm efficiently calculates the required average by iterating through the list of clients just once.