#include "sorting.h"
#include <algorithm>
#include <iostream>
#include <numeric>
#include <vector>

const int __MAXN = 500000 + 10;

int __compareCnt;
int __n, __p[__MAXN];
bool compare(int x, int y)
{
    __compareCnt++;
    if (!(1 <= x && x <= __n && 1 <= y && y <= __n))
    {
        std::cerr << "Invalid compare query!\n";
        exit(0);
    }

    return __p[x] < __p[y];
}

bool divisible(int x, int y, int d)
{
    if (!(1 <= x && x <= __n && 1 <= y && y <= __n && 1 <= d && d <= __n))
    {
        std::cerr << "Invalid divisible query!\n";
        exit(0);
    }

    return abs(__p[x] - __p[y]) % d == 0;
}

void read()
{
    std::cin >> __n;
    for (int i = 1 ; i <= __n ; ++i)
    {
        std::cin >> __p[i];
    }
}

double score()
{
    int logn = 0;
    while ((1 << logn) < __n) ++logn;
    if (__compareCnt <= __n/2) return 1.;
    if (__compareCnt <= 2*__n/2) return 0.7;
    if (__compareCnt <= 2*__n) return 0.5;
    if (__compareCnt <= __n * logn) return 0.15;
    if (__compareCnt <= __n * (1+logn)) return 0.1;
    return 0.05;
}

void fastIO()
{
    std::ios_base :: sync_with_stdio(0);
    std::cin.tie(nullptr);
    std::cout.tie(nullptr);
}

int main ()
{
    // fastIO();
    read();

    std::vector < int > res = solve(__n);
    if (res.size() != __n)
    {
        std::cout << "Invalid result! WA!\n";
        exit(0);
    }

    for (int i = 1 ; i <= __n ; ++i)
    {
        if (res[i-1] != __p[i])
        {
            std::cout << "Incorrect element! WA!\n";
            exit(0);
        }
    }

    std::cout << "Correct!: " << score() << "%\n";
    return 0;
}
