Problem: 2052A - Adrenaline Rush
Language: C++20 (GCC 13-64)


Submission (verdict: Wrong answer on test 1):
#include<bits/stdc++.h>
using namespace std;
#define int long long int
#define endl "\n"
#define fast ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
#define pb push_back
#define debug cout<<"T"<<"\n";
int int_max = 9223372036854775807;
int int_min = -9223372036854775807;
int mod = 1000000007;
int bexp(int x, int n){
    if(n == 0) return 1;
    if(n == 1) return x;
    if(n%2 == 1){
        int temp = (bexp(x, (n-1)/2))%mod;
        int a = (temp*temp)%mod;
        return (a*x)%mod;
    }
    else{
        int temp = (bexp(x, n/2))%mod;
        return (temp*temp)%mod;
    }
}
 
int ncr(int n, int r, vector<int> &factorial){
    int num = factorial[n];
    int den = (factorial[r]*factorial[n-r])%mod;
    return (num*bexp(den, mod - 2))%mod;
}
 
int npr(int n, int r){
    int ans = 1;
    for(int i = n - r + 1; i<=n; i++)
        ans = (ans*i)%mod;
    return ans;
}
 
// int find(int v, vector<int> &parent){
//     if(v == parent[v]) return v;
//     return parent[v] = find(parent[v], parent);
// }
// void Union(int a, int b, vector<int> &parent, vector<int> &size){
//     a = find(a, parent);
//     b = find(b, parent);
//     if(a == b) return;
//     if(size[a] < size[b]) swap(a, b);
//     parent[b] = a;
//     size[a] += size[b];
// }
 
int gcd(int a, int b){
    if(b > a) return gcd(b, a);
    if(a%b == 0) return b;
    return gcd(b, a%b);
}
// int lcm(int a, int b){
//     int g = gcd(a, b);
//     a = a/g;
//     b = b/g;
//     return a*b*g;
// }
 
// int seg(vector<int> &v, int l, int r){
//     int ans = LLONG_MIN;
//     while(l <= r){
//         if(l%2 == 1){
//             ans = max(ans, v[l]);
//             l++;
//         }
//         if(r%2 == 0){
//             ans = max(ans, v[r]);
//             r--;
//         }
 
//         l /= 2;
//         r /= 2;
//     }
//     return ans;
// }
// int seg2(vector<int> &v, int l, int r){
//     int ans = LLONG_MAX;
//     while(l <= r){
//         if(l%2 == 1){
//             ans = min(ans, v[l]);
//             l++;
//         }
//         if(r%2 == 0){
//             ans = min(ans, v[r]);
//             r--;
//         }
 
//         l /= 2;
//         r /= 2;
//     }
//     return ans;
// }
int ceil2(int a, int b) {
    return (a + b - 1) / b;
}
 
// int bsearch(vector<int> &v, int x){
//     int l = 0;
//     int r = v.size() - 1;
//     int mid = (l+r)/2;
//     int ans = 0;
//     while(l <= r){
//         if(v[mid] < x){
//             ans = mid;
//             l = mid + 1;
//         }
//         else r = mid - 1;
//         mid = (l+r)/2;
//     }
//     return ans;
// }
 
int mmi(int a){
    int temp = bexp(a, mod - 2);
    return temp%mod;
}

// void blift(vector<int> adj[], int node, int parent, vector<vector<int>> &boses, int count, vector<int> &depth){
//     if(parent != -1){
//         boses[node][0] = parent;
//         for(int i = 1; i<19; i++){
//             int tpar = boses[node][i-1];
//             int tgpar = boses[tpar][i-1];
//             if(tgpar == -1) break;
//             boses[node][i] = tgpar;
//         }
//     }
//     depth[node] = count;
//     for(int i : adj[node]) blift(adj, i, node, boses, count + 1, depth);
// }
// int findlca(vector<vector<int>> &boses, int a, int b){
//     if(a == b) return a;
//     for(int i = 18; i>=0; i--){
//         if(boses[a][i] != boses[b][i]){
//             a = boses[a][i];
//             b = boses[b][i];
//         }
//     }
//     return boses[a][0];
// }
 
// int gcdfunc(int a, int b){
//     if(a == 0) return 0;
//     if(b == 0) return 1;
//     if(a < b){
//         return 1 + gcdfunc(b, b-a);
//     }
//     int temp = a/b;
//     //temp can be even or odd
//     int ans = 0;
//     if(temp%2 == 1){
//         int temp2 = (temp-1)/2;
//         temp2 *= 3;
//         temp2++;
//         ans += temp2 + gcdfunc(b, a%b);
//     }
//     else{
//         int temp2 = temp/2;
//         temp2 *= 3;
//         ans += temp2 + gcdfunc(a%b, b);
//     }
//     return ans;
// }
// int isans(int f1, int f2, int k){
//     int num = f2;
//     for(int i = 3; i<=k; i++){
//         num = f1 + f2;
//         f1 = f2;
//         f2 = num;
//     }
//     return num;
// }
 
// int boss(int node, int levels, vector<vector<int>> &boses){
//     int ans = node;
//     for(int i = 0; i<19; i++){
//         if((levels>>i)&1 == 1) ans = boses[ans][i];
//     }
//     return ans;
// }
// int treedfs(vector<int> adj[], int node, int parent, int &ans){
//     int count = 0;
//     vector<int> v;
//     for(int i : adj[node]){
//         if(i != parent){
//             int temp = treedfs(adj, i, node, ans);
//             count += temp;
//             v.pb(temp);
//         }
//     }
 
//     if(v.size() == 0) return 1;
//     vector<vector<bool>> dp(v.size(), vector<bool> (count+1, false));
//     int n = v.size();
//     dp[0][v[0]] = true;
//     for(int i = 1; i<n; i++){
//         dp[i][v[i]] = true;
//         for(int j = 0; j<=count; j++){
//             dp[i][j] = dp[i-1][j];
//             if(j-v[i] >= 0)
//                 dp[i][j] = (dp[i][j])|(dp[i-1][j-v[i]]);
//         }
//     }
//     int maxi = 0;
//     for(int i = 0; i<=count; i++){
//         int temp = i*(count - i);
//         if(dp[n-1][i])
//             maxi = max(maxi, temp);
//     }
//     ans += maxi;
//     count++;
//     return count;
// }
// class trie{
// public:
//     int data;
//     trie* arr[2];
// };
// bool check(string a, string b){
//     int n = b.size() - a.size() + 1;
//     for(int i = 0; i<n; i++){
//         bool flag = true;
//         for(int j = 0; j<a.size(); j++){
//             if(a[j] != b[i+j]) flag = false;
//         }
//         if(flag) return true;
//     }
//     return false;
// }
 
// void bitudpate(vector<int> &bit, int index, int x){
//     int n = bit.size() - 1;
//     while(index <= n && index > 0){
//         bit[index] += x;
//         index += (index&-index);
//     }
//     return;
// }
// int bitprefix(vector<int> &bit, int index){
//     int n = bit.size() - 1;
//     int sum = 0;
//     while(index > 0 && index <= n){
//         sum += bit[index];
//         index -= (index&-index);
//     }
//     return sum;
// 

void solve(){
    int n;
    cin>>n;
    vector<int> v(n);
    for(int i = 0; i<n; i++) cin>>v[i];

    vector<pair<int, int>> arr;
    
    for(int i = 0; i<n; i++){
        for(int j = i + 1; j<n; j++){
            if(v[i] < v[j]){
                arr.push_back({v[i], v[j]});
                arr.push_back({v[j], v[i]});
            }
            else arr.push_back({v[i], v[j]});
        }
    }
    cout<<arr.size()<<endl;
    for(auto i : arr){
        cout<<i.first<<" "<<i.second<<endl;
    }
}

int32_t main(){
    fast
    // int t;
    // cin>>t;
    // while(t--){
        solve();
    // }
    return 0;
}