void calc(vector<int> q)
{
    int ans = 0;
    for (int i = q.size() - 1; i >= 0; i--) {
        if (q[i] - (i + 1) > 2) {
            cout << "Too chaotic" << endl;
            return;
        }
        for (int j = max(0, q[i] - 2); j < i; j++)
            if (q[j] > q[i]) ans++;
    }
    cout << ans << endl;
}

def minimumBribes(Q):
    #
    # initialize the number of moves
    moves = 0 
    #
    # decrease Q by 1 to make index-matching more intuitive
    # so that our values go from 0 to N-1, just like our
    # indices.  (Not necessary but makes it easier to
    # understand.)
    Q = [P-1 for P in Q]
    #
    # Loop through each person (P) in the queue (Q)
    for i,P in enumerate(Q):
        # i is the current position of P, while P is the
        # original position of P.
        #
        # First check if any P is more than two ahead of 
        # its original position
        if P - i > 2:
            print("Too chaotic")
            return
        #
        # From here on out, we don't care if P has moved
        # forwards, it is better to count how many times
        # P has RECEIVED a bribe, by looking at who is
        # ahead of P.  P's original position is the value
        # of P.
        # Anyone who bribed P cannot get to higher than
        # one position in front if P's original position,
        # so we need to look from one position in front
        # of P's original position to one in front of P's
        # current position, and see how many of those 
        # positions in Q contain a number large than P.
        # In other words we will look from P-1 to i-1,
        # which in Python is range(P-1,i-1+1), or simply
        # range(P-1,i).  To make sure we don't try an
        # index less than zero, replace P-1 with
        # max(P-1,0)
        for j in range(max(P-1,0),i):
            if Q[j] > P:
                moves += 1
    print(moves)

Current position : 5 1 2 3 7 8 6 4
Initial position : 1 2 3 4 5 6 7 8

Current position : 1 2 5 3 7 8 6 4
Initial position : 1 2 3 4 5 6 7 8

1 2 3 4 5 6 7 8  : 0 swap (initial)
1 2 3 5 4 6 7 8  : 1 swap (5 and 4)
1 2 3 5 6 4 7 8  : 1 swap (6 and 4)
1 2 3 5 6 7 4 8  : 1 swap (7 and 4)
1 2 3 5 6 7 8 4  : 1 swap (8 and 4)
1 2 5 3 6 7 8 4  : 1 swap (5 and 3)
1 2 5 3 7 6 8 4  : 1 swap (7 and 6)
1 2 5 3 7 8 6 4  : 1 swap (8 and 6)

let test = Int(readLine()!)!

extern: for i in 1...test {
    let itemCount = Int(readLine()!)!
    var items = readLine()!.characters.split(" ").map{Int(String($0))!}
    var swaps = 0
    
    for j in 0 ..< items.count {
        let myPos = items[j]
        var dif = myPos - (j + 1)
        
        if dif < 0 {
            dif *= -1
        }
        
        if (dif > 2) {
            print("Too chaotic")
            continue extern
        }
    }

    var it = 0 // 0 = pos 1
    swapsLoop: while it < itemCount {
        for k in 0 ..< itemCount {
            if it + 1 == items[it] {
                it += 1
                continue swapsLoop
            }

            if items[k] == it + 1 {
                var aux = items[k]
                items[k] = items[k - 1]
                items[k - 1] = aux
                swaps += 1
            }
        }
    }
    print(swaps)
}

2
8
5 1 2 3 7 8 6 4
8
1 2 5 3 7 8 6 4

Too chaotic
7

void calc(vector<int> q)
{
    int ans = 0;
    for (int i = q.size() - 1; i >= 0; i--) {
        if (q[i] - (i + 1) > 2) {
            cout << "Too chaotic" << endl;
            return;
        }
        for (int j = max(0, q[i] - 2); j < i; j++)
            if (q[j] > q[i]) ans++;
    }
    cout << ans << endl;
}

def NewYearChaos(queue):
    lastIndex = len(queue) - 1
    swaps = 0
    swaped = False
    
    # check if the queue is too chaotic
    for i, v in enumerate(queue):
        if (v - 1) - i > 2:
            return "Too chaotic"
    # bubble sorting to find the answer
    for i in xrange(0, lastIndex):
        for j in xrange(0, lastIndex):
            comps += 1
            if queue[j] > queue[j+1]:
                temp = queue[j]
                queue[j] = queue[j+1]
                queue[j+1] = temp
                swaps += 1
                swaped = True
        
        if swaped:
            swaped = False
        else:
            break
    return swaps

def minimumBribes(q):
    bribes = 0
    for i in range(len(q)-1,-1,-1):
        if q[i] - (i + 1) > 2:
            print('Too chaotic')
            return
        for j in range(max(0, q[i] - 2),i):
            if q[j] > q[i]:
                bribes+=1
    print(bribes)

// Complete the minimumBribes function below.
void minimumBribes(vector<int> q) {
    int totalBribes = 0;
    
    int expectedFirst = 1;
    int expectedSecond = 2;
    int expectedThird = 3;
    
    for (unsigned int i = 0; i < q.size(); ++i) {
        if (q[i] == expectedFirst) {
            expectedFirst = expectedSecond;
            expectedSecond = expectedThird;
            ++expectedThird;
        } else if (q[i] == expectedSecond) {
            ++totalBribes;
            expectedSecond = expectedThird;
            ++expectedThird;
        } else if (q[i] == expectedThird) {
            totalBribes += 2;
            ++expectedThird;
        } else {
            cout << "Too chaotic" << endl;
            return;
        }
    }
    
    cout << totalBribes << endl;
}

static void minimumBribes(int[] q) {
        //if value at (index+1), index starts at zero, minus the index > 2, then it is
        // a chaotic situation
        for(int i=0;i<q.length;i++){
            if((q[i] - (i+1)) > 2){
                System.out.println("Too chaotic");
                return; 
            }
        }
               
        //now we just need to count number of Swaps
        int swaps=0;
        for(int i=0;i< q.length;i++){
            for(int j=i+1;j<q.length;j++){
                if(q[i] > q[j]){ 
                    int tmp=q[j];
                    q[j]=q[i];
                    q[i]=tmp;
                    swaps++;
                }
            }
        }
        
        System.out.println(swaps);
    
    }