private static int traverse(List<List<int>> petrolpumps, int start)
    {
        int curr_pet = petrolpumps[start][0] - petrolpumps[start][1];
        if (curr_pet <= 0) { return traverse(petrolpumps, start + 1); }
        int i = start + 1 > petrolpumps.Count - 1 ? 0 : start + 1;
        while (i != start)
        {
            curr_pet += (petrolpumps[i][0] - petrolpumps[i][1]);
            if (curr_pet <= 0) { break; }
            i++;
            if (i == petrolpumps.Count) { i = 0; }
        }
        if (i != start) { return traverse(petrolpumps, start + 1); }
        else { return start; }

    }
    public static int truckTour(List<List<int>> petrolpumps)
    {
return traverse(petrolpumps, 0);
    }

def truckTour(petrolpumps):
    N = len(petrolpumps)

    for i in range(N):
        j = 0
        tank_cap = 0
        valid_tour = True

        while j < N:
            liters, dist = petrolpumps[(j + i) % N]
            tank_cap += liters - dist
            j += 1

            if tank_cap < 0:
                valid_tour = False
                break

        if valid_tour:
            return i

def truckTour(petrolpumps):
    if len(petrolpumps) == 1:
        return 0
    
    for start in range(len(petrolpumps)):
        tank, dist = petrolpumps[start]
        complete = True
        
        if tank < dist:
            continue
        else:
            tank -= dist
        
        if start == len(petrolpumps) - 1:
            i = 0
        else:
            i = start + 1
        
        while i != start:
            tank += petrolpumps[i][0]
            dist = petrolpumps[i][1]
            
            if tank < dist:
                complete = False
                break
            else:
                tank -= dist
            
            if i == len(petrolpumps) - 1:
                i = 0
            else:
                i += 1
        
        if complete:
            return start

int truckTour(vector<vector<int>> petrolpumps) {
    int sum;
    int startPoint = 0;
    int len = (int)petrolpumps.size();
    
    while(startPoint < len) {
        sum = 0;
        for(int i=0; i<len; ++i) {
            int ii = (startPoint+i) % len;      //circle
            sum += petrolpumps[ii][0] - petrolpumps[ii][1];
            if(sum<0) {
                ++startPoint;
                break;
            }
        }
            
        if(sum>0)   // I think `if(sum>=0)` is ok, but test cases fail
        {
            return startPoint;
        }
    }
    
    return -1;
}