function minimumBribes(queue) {
    let bribes = "Too chaotic";
    if (! queue.some((value, index) => value - index > 3)) {
        bribes = 0;
        for (let _ in [undefined, undefined]) {
            for (let index = queue.length - 1; index > 0; index--) {
                if (queue[index] < queue[index - 1]) {
                    [queue[index], queue[index - 1]] = [queue[index - 1], queue[index]];
                    bribes++;
                }
            }
        }
    }
    console.log(bribes);
}

# Approach
# Start with a queue that has zero bribes - with everyone in order
# Move towards the current state of the bribed queue as you count the number of bribes done by someone
# If they exceed three, stop and print 'Too chaotic'
# Otherwise continue with bribing until you reach the final state of the bribed queue
numBribes = {}
positions = {}

rideQueue = None

def bribe(briberPos):
    global rideQueue
    
    bribeePos = briberPos - 1
    # Set the position of the briber to the one infront of him
    briber = rideQueue[briberPos]
    bribee = rideQueue[briberPos - 1]
    positions[briber] = briberPos - 1
    # Set the position of the bribed to the briber's position
    positions[bribee] = briberPos
    
    # Update number of bribes
    numBribes[briber] = numBribes.get(briber, 0) + 1

    # Switch places, bribe the person infront of the briber
    rideQueue[briberPos], rideQueue[bribeePos] = bribee, briber
    
    #print(rideQueue)
    
def isFinalPosBribed(finalPos, currPos):
    # currPos is the position currently held in the queue as the bribes take place
    return currPos > finalPos
    
    
def hasBriberExceededMaxBribes(briberId):
    return numBribes.get(briberId, 0) > 2

def minimumBribes(q):
    global rideQueue
    global numBribes
    global positions
    
    numBribes = {}
    positions = {}
    rideQueue = sorted(q)
    
    i = 0
    while i < len(q):
        finalPos = i
        briberId = q[i]
        unbribedPos = q[i] - 1
        # Get the current position of the person. Remember as the bribes take place, positions change, person 6 may endup infront of 4
        # Implying a person 4 can bribe 6 for as long as they are infront of them
        currPos = positions.get(q[i]) or unbribedPos
        if isFinalPosBribed(finalPos, currPos):
            #print(f"Person: {briberId} bribed")
            while currPos > finalPos:
                # Progress the person towards their bribed position
                bribe(currPos)
                currPos -= 1
                if hasBriberExceededMaxBribes(briberId):
                    print("Too chaotic")
                    return
        else:
            ...
            #print(f"Person: {briberId} didn't bribe")
        i+=1
    #print(rideQueue)
    print(sum(numBribes.values()))

void minimumBribes(vector<int> q) {
    int totalBribes = 0;

    for (int i = 0; i < q.size(); i++) {
        if (q[i] - (i + 1) > 2) { // If the difference between an elements' initial position and it's final position is greater than 2,
            // that means it moved to the left more than twice, which means it bribed more than twice. That means the line's Too Chaotic.
            cout << "Too chaotic" << endl;
            return;
        }

        // Start from one position ahead (in the line) of where q[i] *could* have started (i.e at an index of either index 0 or q[i] - 2, whichever is higher). 
        // Count how many people with a higher position than q[i] are in front of q[i] in the queue (i.e behind q[i] in the array), 
        // because each of those people must have bribed their way past q[i].
        for (int j = max(0, q[i] - 2); j < i; j++) {
            if (q[j] > q[i]) { 
                totalBribes++;
            }
        }
    }

    cout << totalBribes << endl;
}