ShaysXIA/CodeInsightBench huggingface dataset:
Problem: 2052A - Adrenaline Rush
Language: python

Solution 1 (runtime: 2249 ms):
import sys


def readline(type):
    return list(map(type, sys.stdin.readline().split(' ')))


def add_ans(a, b, ans, check):
    if check[a - 1][b - 1] != 0:
        return

    ans.append((a, b))
    check[a - 1][b - 1] = 1

# 1 2 3 4
# 1 2 3 4


def apply_stacked(stacked, ans, check):
    for a, b in reversed(stacked):
        add_ans(b, a, ans, check)


def useless_swaps(i_a, i_b, order, ans, check):
    if i_a == i_b:
        return

    for i in range(i_a, i_b):
        first = []
        last = []

        for next_i in range(i + 1, i_b + 1):
            a = order[i]
            b = order[next_i]

            if (
                check[a - 1][b - 1] + check[b - 1][a - 1] == 0
            ):
                first.append((a, b))
                last.append((a, b))
            else:
                break

        for a, b in first:
            ans.append((a, b))
            check[a - 1][b - 1] = 1
        for b, a in reversed(last):
            ans.append((a, b))
            check[a - 1][b - 1] = 1
# 1 2 3 4
# 1 3 2 4
# 1 2 3 4
# 1 2 4 3
# 4 1 2 3

def main():
    n, = readline(int)
    order = readline(int)

    check = [[0] * n for _ in range(n)]
    ans = []

    flag = True

    while flag:
        i_a = n - 1
        i_b = n - 1
        flag = False

        for i in range(n - 1, 0, -1):
            a = order[i - 1]
            b = order[i]

            if a < b:
                i_a = i - 1
            else:
                useless_swaps(i_a, i_b, order, ans, check)
                flag = True
                order[i - 1] = b
                order[i] = a
                ans.append((a, b))
                check[a - 1][b - 1] = 1
                break
        if not flag:
            useless_swaps(i_a, i_b, order, ans, check)

    print(len(ans))
    for a, b in reversed(ans):
        print(a, b, sep=' ')

if __name__ == '__main__':
    main()


Solution 2 (runtime: 702 ms):
def sol():
    n = int(input())
    a = list(map(int, input().split()))
    rev_a = [None] * n
    for i, x in enumerate(a):
        rev_a[x-1] = i+1
    # print(rev_a)
    steps = []
    orig = list(range(1, n+1))
    for i in range(n):
        x = i + 1
        for p, w in enumerate(rev_a):
            if w == x:
                x_index = p
                break
        
        for j in range(x_index, n-1):
            steps.append((orig[j+1], orig[j]))
            orig[j+1], orig[j] = orig[j], orig[j+1]
            rev_a[j+1], rev_a[j] = rev_a[j], rev_a[j+1]
        for j in range(n-2, x_index-1, -1):
            steps.append((orig[j+1], orig[j]))
            orig[j+1], orig[j] = orig[j], orig[j+1]
            rev_a[j+1], rev_a[j] = rev_a[j], rev_a[j+1]
        if x_index > i:
            for j in range(x_index-1, x-2, -1):
                steps.append((orig[j+1], orig[j]))
                orig[j+1], orig[j] = orig[j], orig[j+1]
                rev_a[j+1], rev_a[j] = rev_a[j], rev_a[j+1]

    print(len(steps))
    for x in steps:
        print(*x)


sol()
Problem: 2052A - Adrenaline Rush
Language: python

Solution 1 (runtime: 2249 ms):
import sys


def readline(type):
    return list(map(type, sys.stdin.readline().split(' ')))


def add_ans(a, b, ans, check):
    if check[a - 1][b - 1] != 0:
        return

    ans.append((a, b))
    check[a - 1][b - 1] = 1

# 1 2 3 4
# 1 2 3 4


def apply_stacked(stacked, ans, check):
    for a, b in reversed(stacked):
        add_ans(b, a, ans, check)


def useless_swaps(i_a, i_b, order, ans, check):
    if i_a == i_b:
        return

    for i in range(i_a, i_b):
        first = []
        last = []

        for next_i in range(i + 1, i_b + 1):
            a = order[i]
            b = order[next_i]

            if (
                check[a - 1][b - 1] + check[b - 1][a - 1] == 0
            ):
                first.append((a, b))
                last.append((a, b))
            else:
                break

        for a, b in first:
            ans.append((a, b))
            check[a - 1][b - 1] = 1
        for b, a in reversed(last):
            ans.append((a, b))
            check[a - 1][b - 1] = 1
# 1 2 3 4
# 1 3 2 4
# 1 2 3 4
# 1 2 4 3
# 4 1 2 3

def main():
    n, = readline(int)
    order = readline(int)

    check = [[0] * n for _ in range(n)]
    ans = []

    flag = True

    while flag:
        i_a = n - 1
        i_b = n - 1
        flag = False

        for i in range(n - 1, 0, -1):
            a = order[i - 1]
            b = order[i]

            if a < b:
                i_a = i - 1
            else:
                useless_swaps(i_a, i_b, order, ans, check)
                flag = True
                order[i - 1] = b
                order[i] = a
                ans.append((a, b))
                check[a - 1][b - 1] = 1
                break
        if not flag:
            useless_swaps(i_a, i_b, order, ans, check)

    print(len(ans))
    for a, b in reversed(ans):
        print(a, b, sep=' ')

if __name__ == '__main__':
    main()


Solution 2 (runtime: 999 ms):
import sys
from queue import deque
from bisect import bisect_left, bisect_right
from heapq import *
from collections import *

sys.setrecursionlimit(10**5)

input = lambda: sys.stdin.readline().rstrip('\r\n')
iint = lambda: int(input())
mint = lambda: map(int, input().split())
aint = lambda: list(map(int, input().split()))

MOD = 10**9 + 7

def solve():
    n = iint()
    a = aint()
    rank = [0] * (n + 1)
    for i in range(n):
        rank[a[i]] = i+1
   
    mx_len = n * (n-1) // 2
    curr = list(range(n, 0, -1))
    sq = []
    for i in range(n):
        j = i
        while j>0 and rank[curr[j]] < rank[curr[j-1]]:
            sq.append([curr[j], curr[j-1]])
            curr[j], curr[j-1] = curr[j-1], curr[j]
            mx_len += 1
            j -= 1

    print(mx_len)
    for i in range(1, n+1):
        for j in range(i+1, n+1):
            print(j, i)
    for a, b in sq:
        print(a, b)

solve()
Problem: 2052A - Adrenaline Rush
Language: python

Solution 1 (runtime: 2249 ms):
import sys


def readline(type):
    return list(map(type, sys.stdin.readline().split(' ')))


def add_ans(a, b, ans, check):
    if check[a - 1][b - 1] != 0:
        return

    ans.append((a, b))
    check[a - 1][b - 1] = 1

# 1 2 3 4
# 1 2 3 4


def apply_stacked(stacked, ans, check):
    for a, b in reversed(stacked):
        add_ans(b, a, ans, check)


def useless_swaps(i_a, i_b, order, ans, check):
    if i_a == i_b:
        return

    for i in range(i_a, i_b):
        first = []
        last = []

        for next_i in range(i + 1, i_b + 1):
            a = order[i]
            b = order[next_i]

            if (
                check[a - 1][b - 1] + check[b - 1][a - 1] == 0
            ):
                first.append((a, b))
                last.append((a, b))
            else:
                break

        for a, b in first:
            ans.append((a, b))
            check[a - 1][b - 1] = 1
        for b, a in reversed(last):
            ans.append((a, b))
            check[a - 1][b - 1] = 1
# 1 2 3 4
# 1 3 2 4
# 1 2 3 4
# 1 2 4 3
# 4 1 2 3

def main():
    n, = readline(int)
    order = readline(int)

    check = [[0] * n for _ in range(n)]
    ans = []

    flag = True

    while flag:
        i_a = n - 1
        i_b = n - 1
        flag = False

        for i in range(n - 1, 0, -1):
            a = order[i - 1]
            b = order[i]

            if a < b:
                i_a = i - 1
            else:
                useless_swaps(i_a, i_b, order, ans, check)
                flag = True
                order[i - 1] = b
                order[i] = a
                ans.append((a, b))
                check[a - 1][b - 1] = 1
                break
        if not flag:
            useless_swaps(i_a, i_b, order, ans, check)

    print(len(ans))
    for a, b in reversed(ans):
        print(a, b, sep=' ')

if __name__ == '__main__':
    main()


Solution 2 (runtime: 1186 ms):
n = int(input())

a = [int(i) for i in input().split()]

inds = [0 for i in range(n+1)]

for i in range(n):

    inds[a[i]] = i



total = 0

changes = []



l = [i+1 for i in range(n)]

for i in range(n):

    ind = l.index(a[i])



    for j in range(ind+1, n):

        changes.append([l[j], a[i]])

    for j in range(n-1, ind, -1):

        changes.append([a[i], l[j]])



    for j in range(ind-1, i-1, -1):

        changes.append([a[i], l[j]])



    l = [l[ind]] + l[:ind] + l[ind+1:]





print(len(changes))

for i in changes:

    print(*i)
Problem: 2052A - Adrenaline Rush
Language: python

Solution 1 (runtime: 2249 ms):
import sys


def readline(type):
    return list(map(type, sys.stdin.readline().split(' ')))


def add_ans(a, b, ans, check):
    if check[a - 1][b - 1] != 0:
        return

    ans.append((a, b))
    check[a - 1][b - 1] = 1

# 1 2 3 4
# 1 2 3 4


def apply_stacked(stacked, ans, check):
    for a, b in reversed(stacked):
        add_ans(b, a, ans, check)


def useless_swaps(i_a, i_b, order, ans, check):
    if i_a == i_b:
        return

    for i in range(i_a, i_b):
        first = []
        last = []

        for next_i in range(i + 1, i_b + 1):
            a = order[i]
            b = order[next_i]

            if (
                check[a - 1][b - 1] + check[b - 1][a - 1] == 0
            ):
                first.append((a, b))
                last.append((a, b))
            else:
                break

        for a, b in first:
            ans.append((a, b))
            check[a - 1][b - 1] = 1
        for b, a in reversed(last):
            ans.append((a, b))
            check[a - 1][b - 1] = 1
# 1 2 3 4
# 1 3 2 4
# 1 2 3 4
# 1 2 4 3
# 4 1 2 3

def main():
    n, = readline(int)
    order = readline(int)

    check = [[0] * n for _ in range(n)]
    ans = []

    flag = True

    while flag:
        i_a = n - 1
        i_b = n - 1
        flag = False

        for i in range(n - 1, 0, -1):
            a = order[i - 1]
            b = order[i]

            if a < b:
                i_a = i - 1
            else:
                useless_swaps(i_a, i_b, order, ans, check)
                flag = True
                order[i - 1] = b
                order[i] = a
                ans.append((a, b))
                check[a - 1][b - 1] = 1
                break
        if not flag:
            useless_swaps(i_a, i_b, order, ans, check)

    print(len(ans))
    for a, b in reversed(ans):
        print(a, b, sep=' ')

if __name__ == '__main__':
    main()


Solution 2 (runtime: 483 ms):
from sys import stdin

input = lambda: stdin.readline().strip()



n = int(input())

a = list(map(int, input().split()))

ans = []



for _ in range(n):

    for i in range(n - 1):

        if a[i] < a[i + 1]:

            ans.append((a[i], a[i + 1]))

            a[i], a[i + 1] = a[i + 1], a[i]

for _ in range(n):

    for i in range(n - 1):

        if a[i] > a[i + 1]:

            ans.append((a[i], a[i + 1]))

            a[i], a[i + 1] = a[i + 1], a[i]

ans.reverse()

print(len(ans))

for x, y in ans:

    print(f'{x} {y}')
Problem: 2052A - Adrenaline Rush
Language: python

Solution 1 (runtime: 2249 ms):
import sys


def readline(type):
    return list(map(type, sys.stdin.readline().split(' ')))


def add_ans(a, b, ans, check):
    if check[a - 1][b - 1] != 0:
        return

    ans.append((a, b))
    check[a - 1][b - 1] = 1

# 1 2 3 4
# 1 2 3 4


def apply_stacked(stacked, ans, check):
    for a, b in reversed(stacked):
        add_ans(b, a, ans, check)


def useless_swaps(i_a, i_b, order, ans, check):
    if i_a == i_b:
        return

    for i in range(i_a, i_b):
        first = []
        last = []

        for next_i in range(i + 1, i_b + 1):
            a = order[i]
            b = order[next_i]

            if (
                check[a - 1][b - 1] + check[b - 1][a - 1] == 0
            ):
                first.append((a, b))
                last.append((a, b))
            else:
                break

        for a, b in first:
            ans.append((a, b))
            check[a - 1][b - 1] = 1
        for b, a in reversed(last):
            ans.append((a, b))
            check[a - 1][b - 1] = 1
# 1 2 3 4
# 1 3 2 4
# 1 2 3 4
# 1 2 4 3
# 4 1 2 3

def main():
    n, = readline(int)
    order = readline(int)

    check = [[0] * n for _ in range(n)]
    ans = []

    flag = True

    while flag:
        i_a = n - 1
        i_b = n - 1
        flag = False

        for i in range(n - 1, 0, -1):
            a = order[i - 1]
            b = order[i]

            if a < b:
                i_a = i - 1
            else:
                useless_swaps(i_a, i_b, order, ans, check)
                flag = True
                order[i - 1] = b
                order[i] = a
                ans.append((a, b))
                check[a - 1][b - 1] = 1
                break
        if not flag:
            useless_swaps(i_a, i_b, order, ans, check)

    print(len(ans))
    for a, b in reversed(ans):
        print(a, b, sep=' ')

if __name__ == '__main__':
    main()


Solution 2 (runtime: 2265 ms):
n=int(input())

l=list(map(int,input().split()))

liste=[]

if n==1:

    print(0)

else:

    lcurrent=[]

    lchange=[0]*n

    for i in range(n):

        lcurrent.append(i+1)

    for  i in range(n):

        j=n-1-i

        val=l[j]

        y=lcurrent.index(val)

        if y<j:

            lchange[j]=1

            for k in range(y+1,j+1):

                liste.append((lcurrent[k],val))

                lcurrent[k-1]=lcurrent[k]

            lcurrent[j]=val

        if y>j:

            lchange[j]=1

            for k in range(j,y):

                h=y-k

                liste.append((val,lcurrent[h]))

                lcurrent[h+1]=lcurrent[h]

            lcurrent[j]=val

    

    for  i in range(1,n):

     

        j=n-1-i+1

        

        if  lchange[j]==0:

            liste.append((lcurrent[j],lcurrent[j-1]))

            liste.append((lcurrent[j-1],lcurrent[j]))

    print(len(liste))

    for i in liste:

        a,b=i[0],i[1]

        print(a,b)
Problem: 2052A - Adrenaline Rush
Language: python

Solution 1 (runtime: 2249 ms):
import sys


def readline(type):
    return list(map(type, sys.stdin.readline().split(' ')))


def add_ans(a, b, ans, check):
    if check[a - 1][b - 1] != 0:
        return

    ans.append((a, b))
    check[a - 1][b - 1] = 1

# 1 2 3 4
# 1 2 3 4


def apply_stacked(stacked, ans, check):
    for a, b in reversed(stacked):
        add_ans(b, a, ans, check)


def useless_swaps(i_a, i_b, order, ans, check):
    if i_a == i_b:
        return

    for i in range(i_a, i_b):
        first = []
        last = []

        for next_i in range(i + 1, i_b + 1):
            a = order[i]
            b = order[next_i]

            if (
                check[a - 1][b - 1] + check[b - 1][a - 1] == 0
            ):
                first.append((a, b))
                last.append((a, b))
            else:
                break

        for a, b in first:
            ans.append((a, b))
            check[a - 1][b - 1] = 1
        for b, a in reversed(last):
            ans.append((a, b))
            check[a - 1][b - 1] = 1
# 1 2 3 4
# 1 3 2 4
# 1 2 3 4
# 1 2 4 3
# 4 1 2 3

def main():
    n, = readline(int)
    order = readline(int)

    check = [[0] * n for _ in range(n)]
    ans = []

    flag = True

    while flag:
        i_a = n - 1
        i_b = n - 1
        flag = False

        for i in range(n - 1, 0, -1):
            a = order[i - 1]
            b = order[i]

            if a < b:
                i_a = i - 1
            else:
                useless_swaps(i_a, i_b, order, ans, check)
                flag = True
                order[i - 1] = b
                order[i] = a
                ans.append((a, b))
                check[a - 1][b - 1] = 1
                break
        if not flag:
            useless_swaps(i_a, i_b, order, ans, check)

    print(len(ans))
    for a, b in reversed(ans):
        print(a, b, sep=' ')

if __name__ == '__main__':
    main()


Solution 2 (runtime: 1093 ms):

n=int(input())
a=[int(i) for i in input().split()]
res=n*(n-1)//2
j=n
r=[]
for i in range(2,n+1):
    for j in range(1,i):
        r.append([i,j])
b=[None]*n
for i in range(n):
    b[a[i]-1]=i+1
c=[n-i for i in range(n)]

for i in range(n-1):
    for j in range(1,n-i):
        if b[c[j]-1]<b[c[j-1]-1]:
            res+=1
            r.append([c[j],c[j-1]])
            c[j],c[j-1]=c[j-1],c[j]
print(res)
for i in r:
    print(i[0],i[1])
Problem: 2052A - Adrenaline Rush
Language: python

Solution 1 (runtime: 749 ms):
len_, lst, op = int(input()), list(map(int, input().split())), []
if len_ == 1: print(0); exit()
for i in range(1, len_ + 1):
    if (index_ := lst.index(i)) != len_ - 1:
        for j in lst[index_ + 1:]:
            if j > i: op.append(f'{i} {j}')
    for k in range(1, i): op.append(f'{i} {k}')
print(len(op), *op[::-1], sep='\n')


Solution 2 (runtime: 374 ms):
I = lambda : list(map(int, input().split(' ')))
R = lambda : (int(input()))

import sys
import math
from collections import deque, defaultdict
from bisect import bisect_left, bisect_right

for kp in range(1):

    n = R()
    a = I()

    c = [-1 for i in range(n+1)]
    for i,x in enumerate(a): c[x] = i+1

    initial = [(c[i],i) for i in range(1,n+1)]
    overtakes = []

    all_overtakes = set()
    new_overtakes = []

    # for i in range(1,n+1):
    #     for j in range(i+1,n+1):
    #         all_overtakes.add((i,j))
    #         all_overtakes.add((j,i))

    final = []

    for i in range(n):

        pos, curr = initial[i]
        insert_pos = i

        for j in range(i-1,-1,-1):

            if final[j][0] > pos:
                insert_pos -= 1
                # all_overtakes.remove( (final[j][1], curr) )
                new_overtakes.append(f"{curr} {final[j][1]}")

            else: break

        for j in range(insert_pos-1, -1, -1):
            new_overtakes.append(f"{curr} {final[j][1]}")

        for j in range(0, insert_pos, 1):
            new_overtakes.append(f"{final[j][1]} {curr}")

        final.insert(insert_pos, (pos, curr))

    # print(len(all_overtakes))
    # print("\n".join([f"{x} {y}" for x,y in list(all_overtakes)]))

    print(len(new_overtakes))
    print("\n".join(new_overtakes))
Problem: 2052A - Adrenaline Rush
Language: python

Solution 1 (runtime: 749 ms):
len_, lst, op = int(input()), list(map(int, input().split())), []
if len_ == 1: print(0); exit()
for i in range(1, len_ + 1):
    if (index_ := lst.index(i)) != len_ - 1:
        for j in lst[index_ + 1:]:
            if j > i: op.append(f'{i} {j}')
    for k in range(1, i): op.append(f'{i} {k}')
print(len(op), *op[::-1], sep='\n')


Solution 2 (runtime: 515 ms):
n=int(input())
L=list(map(int,input().split()))
s=set()
OUT=[]
m=0
for i in L :
    for j in range(i+1,n+1):
        if not j in s :
            
            OUT.append(str(j)+" "+str(i))
            m+=1
    for k in range(n,i,-1):
        if not k in s :
            
            OUT.append(str(i)+" "+str(k))
            m+=1
    for r in range(i-1,0,-1):
        if not r in s :
            
            OUT.append(str(i)+" "+str(r))
            m+=1
    s.add(i)

print(m)
for i in OUT :
    print(i)
Problem: 2052A - Adrenaline Rush
Language: python

Solution 1 (runtime: 749 ms):
len_, lst, op = int(input()), list(map(int, input().split())), []
if len_ == 1: print(0); exit()
for i in range(1, len_ + 1):
    if (index_ := lst.index(i)) != len_ - 1:
        for j in lst[index_ + 1:]:
            if j > i: op.append(f'{i} {j}')
    for k in range(1, i): op.append(f'{i} {k}')
print(len(op), *op[::-1], sep='\n')


Solution 2 (runtime: 593 ms):
a = int(input())
b = list(map(int, input().split()))
s= [int(i) for i in range(1,a+1)]
co = 0
obg = []
if a == 1:
    print(0)
else:
    for i in range(a-1):
        for j in range(a-1-i):
            if s[j] < s[j+1]:
                s[j],s[j+1]=s[j+1],s[j]
                co += 1
                obg.append(s[j])
                obg.append(s[j+1])
    for i in range(a-1):
        for j in range(a-1-i):
            if s[j] == b[a-1-i]:
                s[j],s[j+1]=s[j+1],s[j]
                co += 1
                obg.append(s[j])
                obg.append(s[j+1])
    print(co)   
    for i in range(0,co*2,2):
        print(obg[i], obg[i+1])
Problem: 2052A - Adrenaline Rush
Language: python

Solution 1 (runtime: 749 ms):
len_, lst, op = int(input()), list(map(int, input().split())), []
if len_ == 1: print(0); exit()
for i in range(1, len_ + 1):
    if (index_ := lst.index(i)) != len_ - 1:
        for j in lst[index_ + 1:]:
            if j > i: op.append(f'{i} {j}')
    for k in range(1, i): op.append(f'{i} {k}')
print(len(op), *op[::-1], sep='\n')


Solution 2 (runtime: 655 ms):
import io,os
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline




def main():
    n = int(input())
    arr = list(map(int,input().split()))
    for i in range(n):
        arr[i] -= 1


    curr = [i for i in range(n)]

    ans = []


    for i in range(n):
        index = -1
        for j in range(n):
            if curr[j]==arr[i]:  
                index = j   
                break

        for j in range(index,n-1):
            curr[j],curr[j+1] = curr[j+1],curr[j]
            ans.append((curr[j]+1,curr[j+1]+1))
        for j in range(n-2,i-1,-1):
            curr[j],curr[j+1] = curr[j+1],curr[j]
            ans.append((curr[j]+1,curr[j+1]+1))        



    print(len(ans))
    for ele in ans:
        print(*ele)



main()
Problem: 2052A - Adrenaline Rush
Language: python

Solution 1 (runtime: 749 ms):
len_, lst, op = int(input()), list(map(int, input().split())), []
if len_ == 1: print(0); exit()
for i in range(1, len_ + 1):
    if (index_ := lst.index(i)) != len_ - 1:
        for j in lst[index_ + 1:]:
            if j > i: op.append(f'{i} {j}')
    for k in range(1, i): op.append(f'{i} {k}')
print(len(op), *op[::-1], sep='\n')


Solution 2 (runtime: 2484 ms):
import sys

def max_num(order, n):
    counted = set()
    m = 0
    string = ""
    for i in order:
        before = ""
        after = ""
        m += n - len(counted)-1
        for j in reversed(range(1,n+1)):
            if j not in counted and j != i:
                if i < j:
                    m += 1
                    before = f"\n{j} {i}"+before
                before += f"\n{i} {j}"
        string += before + after
        counted.add(i)
    print(f"{m}{string}")
    return m, string

i = 0
for line in sys.stdin.readlines():
    if i==0:
        n = int(line)
    else:
        order = [int(x) for x in line.split(" ")]
        max_num(order, n)
    i+=1
Problem: 2052A - Adrenaline Rush
Language: python

Solution 1 (runtime: 749 ms):
len_, lst, op = int(input()), list(map(int, input().split())), []
if len_ == 1: print(0); exit()
for i in range(1, len_ + 1):
    if (index_ := lst.index(i)) != len_ - 1:
        for j in lst[index_ + 1:]:
            if j > i: op.append(f'{i} {j}')
    for k in range(1, i): op.append(f'{i} {k}')
print(len(op), *op[::-1], sep='\n')


Solution 2 (runtime: 702 ms):
def sol():
    n = int(input())
    c = [0] + list(map(int, input().split()))
    mp = [i for i in range(n + 1)]
    pos = [i for i in range(n + 1)]
    ans = []
    for i in range(1, n + 1):
        for j in range(mp[c[i]] + 1, n + 1):
            ans.append((pos[j], c[i]))
        for j in range(n, mp[c[i]], -1):
            ans.append((c[i], pos[j]))
        for j in range(mp[c[i]] - 1, i - 1, -1):
            ans.append((c[i], pos[j]))
            mp[pos[j]] = j + 1
            pos[j + 1] = pos[j]
    
    print(len(ans))
    for a, b in ans:
        print(a, b)

sol()