Explanation

First, a short explanation on important aspects of the problem.

1. Orders may not come in the right order, meaning they may not be sorted by arrival time. So, make sure to sort them by arrival time first.
2. It's important to realise that out of waiting orders, the cook must pick the one with the minimum cooking time. This way, the resulting waiting time will always be minimal.
3. Additionally, if there are no orders for the cook to process, the "current" time can be played out till the next arriving order.

Code

In addition to the accepted answer, a C++ solution (since the question is marked with a C++ tag) may look as below.

#include <bits/stdc++.h>

using namespace std;

struct customer {
    uint64_t arrivalTime;
    uint64_t cookingTime;    
};

/*
 * Complete the minimumAverage function below.
 */
uint64_t minimumAverage(std::deque<customer> clients, uint32_t numberOfClients) {
    auto compareByArrivalTime = 
            {
                return client1.arrivalTime < client2.arrivalTime;
            };
    
    auto compareByCookingTime = 
            {
                return client1.cookingTime > client2.cookingTime;
            };
    
    std::sort(clients.begin(), clients.end(), compareByArrivalTime);
    
    std::priority_queue<customer, std::vector<customer>, decltype(compareByCookingTime)> clientPriorityQueue(compareByCookingTime);
    
    uint64_t minWaitingTime = 0;
    uint64_t currentTime = clients.front().arrivalTime;
    for (auto servedClient = 1; servedClient <= numberOfClients; servedClient++) {
        while (!clients.empty() && currentTime >= clients.front().arrivalTime) {
            clientPriorityQueue.push(clients.front());
            clients.pop_front();
        } 
        
        customer bestClient = clientPriorityQueue.top();
        clientPriorityQueue.pop();
        
        uint64_t arrivalTime = bestClient.arrivalTime;
        uint64_t cookingTime = bestClient.cookingTime;
        minWaitingTime += (currentTime - arrivalTime + cookingTime);
        currentTime += cookingTime;
        
        if (!clients.empty()) {
            currentTime = std::max(currentTime, clients.front().arrivalTime);    
        }
    }
    
    return minWaitingTime / numberOfClients;
}

int main()
{
    uint32_t n;
    std::cin >> n;

    std::deque<customer> clients;
    for (auto i = 0; i < n; i++) {
        customer client;
        std::cin >> client.arrivalTime >> client.cookingTime;
        clients.push_back(client);
    }

    uint64_t result = minimumAverage(clients, n);

    std::cout << result << "\n";

    return 0;
}