//.at(i)を[i]と書いても警告が出るように
#ifndef ONLINE_JUDGE
#define _GLIBCXX_DEBUG
#endif

#include <bits/stdc++.h>
using namespace std;



//all マクロ
#define all(v) (v).begin(), (v).end()

//ループマクロ
#define re(n) for (int64_t re_i = 0; re_i < int64_t(n); re_i++)
#define rep(i, n) for (int64_t i = 0; i < int64_t(n); i++)
#define repp(i, n) for (int64_t i = 0; i <= int64_t(n); i++)
#define rrep(i, a, b) for (int64_t i = a; i < int64_t(b); i++)
#define per(i, n) for (int64_t i = int64_t(n) - 1; i >= 0; i--)

//sizeをint64_t型に
#define sz(x) ((int64_t)x.size())


#define pb push_back
#define pob pop_back
#define mp make_pair
#define fi first
#define se second

//int64_t
using lint = int64_t;

//long double
using ld = long double;

//ベクター
template<typename T> using vc = vector<T>;
template<typename T> using vv = vector<vector<T>>;
template<typename T> using vvv = vector<vector<vector<T>>>;
template<typename T> using vvvv = vector<vector<vector<vector<T>>>>;

//ペア
using pll = pair<int64_t, int64_t>;

//プライオリティーキュー
template<typename T> using pq = priority_queue<T, vector<T>>; // 大きい順
template<typename T> using pqg = priority_queue<T, vector<T>, greater<T>>; // 小さい順


//cin cout オーバーロード
//vector
template <typename T>
istream &operator>>(istream &is, vector<T> &v) {
    for (T & in : v) is >> in;
    return is;
}
template <typename T>
ostream &operator<<(ostream & os, const vector<T> &v) {
    for (int64_t i = 0; i < (int64_t)v.size(); i++) {
        os << v[i] << (i + 1 != (int64_t)v.size() ? " " : "");
    }
    return os;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<vector<T>> &v) {
    for (int64_t i = 0; i < (int64_t)v.size(); i++) {
        os << v[i] << endl;
    }
    return os;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<vector<vector<T>>> &v) {
    for (int64_t i = 0; i < (int64_t)v.size(); i++) {
        os << "i = " << i << endl;
        os << v[i];
    }
    return os;
}

//pair
template <typename T1, typename T2>
istream &operator>>(istream &is, pair<T1, T2> &p) {
    is >> p.first >> p.second;
    return is;
}
template <typename T1, typename T2>
ostream &operator<<(ostream & os, const pair<T1, T2> & p) {
    os << "(" << p.first << "," << p.second << ")";
    return os;
}


//Yes No出力
#define YES cout << "YES" << endl;
#define Yes cout << "Yes" << endl;
#define NO cout << "NO" << endl;
#define No cout << "No" << endl;
#define dame cout << -1 << endl;

void YN (bool b) {
    if (b) cout << "YES" << endl;
    else cout << "NO" << endl;
    return;
}
void yn (bool b) {
    if (b) cout << "Yes" << endl;
    else cout << "No" << endl;
    return;
}


// 値の更新
template<typename T1, typename T2>
bool chmax(T1 &x, const T2 &y) {
    bool compare = x < y;
    if (compare) x = y;
    return compare;
}
template<typename T1, typename T2>
bool chmin(T1 &x, T2 y) {
    bool compare = x > y;
    if (compare) x = y;
    return compare;
}

//next_permutation
#define next_p(v) next_permutation((v).begin(), (v).end())

//小数の桁
#define dlfix(n) cout << fixed << setprecision(n);

//無限
int64_t inf = 1001001001;
int64_t INF = 1001001001001001001;

//モッド
int64_t MOD = 998244353;

//パイ
long double pi = 3.14159265358979323846264338327950;

//ネイピア数
long double e = 2.718281828459045235360287471352;


//移動
vector<int64_t> dh = {1, 0, -1, 0};
vector<int64_t> dw = {0, 1, 0, -1};
vector<int64_t> ddh = {1, 1, 0, -1, -1, -1, 0, 1};
vector<int64_t> ddw = {0, 1, 1, 1, 0, -1, -1, -1};

//範囲内チェック
#define in_grid(h, w, H, W) if (!(0 <= h && 0 <= w && h < H && w < W)) continue;

//上下反転
void UDflip (vector<vector<int64_t>> &v) {
    reverse(v.begin(), v.end());
    return;
}

//左右反転
void LRflip (vector<vector<int64_t>> &v) {
    for (auto &x : v) {
        reverse(x.begin(), x.end());
    }
    return;
}

//nPr
int64_t nPr (int64_t n, int64_t r) {
    int64_t Ans = 1;
    for (int64_t i = 0; i < r; i++) {
        Ans *= n - i;
    }
    return Ans;
}

//nCr
vector<vector<int64_t>> nCr_memo;
int64_t nCr (int64_t n, int64_t r) {
    if (n < r) {
        cout << "Error nCrのrがnより大きいです" << endl;
        return 0;
    }
    for (int64_t i = (int64_t)nCr_memo.size(); i <= n; i++) {
        nCr_memo.push_back(vector<int64_t>(i + 1, 1));
        for (int64_t j = 1; j < i; j++) {
            nCr_memo[i][j] = nCr_memo[i - 1][j - 1] + nCr_memo[i - 1][j];
        }
    }
    return nCr_memo[n][r];
}

//経過時間
long double Time () {
    return 1.0 * (clock()) / CLOCKS_PER_SEC;
}

/*----------------------------------------------------------*/


//小さい順
template<typename T>
void Vsort (vector<T> &v) {
    sort(v.begin(), v.end());
    return;
}
//大きい順
template<typename T>
void Vsortg (vector<T> &v) {
    sort(v.rbegin(), v.rend());
    return;
}

//リバース
template<typename T>
void Vreverse (vector<T> &v) {
    reverse(v.begin(), v.end());
    return;
}

//重複の削除
template<typename T>
void Vunique (vector<T> &v) {
    v.erase(unique(v.begin(), v.end()), v.end());
    return;
}

//リストの移動
void Vrotate (vector<int64_t> &v, int64_t n) {
    if (v.empty()) return;
    n %= v.size();
    rotate(v.begin(), v.begin() + n, v.end());
    return;
}

//累乗
int64_t power (int64_t a, int64_t b) {
    int64_t Ans = 1;
    while (b > 0) {
        if (b & 1) Ans *= a;
        a *= a;
        b >>= 1;
    }
    return Ans;
} 

//階乗
int64_t factorial(int64_t n) {
    int64_t Ans = 1;
    for (int64_t i = 1; i <= n; i++) Ans *= i;
    return Ans;
}

//2次元距離
double distan (int64_t x1, int64_t y1, int64_t x2, int64_t y2) {
    return sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
}
//2次元距離の2乗
int64_t distan2 (int64_t x1, int64_t y1, int64_t x2, int64_t y2) {
    return (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2);
}

//数値のN桁目
int64_t digit(int64_t x, int64_t k) {
    while (k--) x /= 10;
    return x % 10;
}

//----------------------------------------------------------

//二分探索
template <typename Func>
int64_t binarch(int64_t ok, int64_t ng, Func F) {
    while (llabs(ok - ng) > 1) {
        int64_t mid = ok + (ng - ok) / 2;
        if (F(mid)) ok = mid;
        else ng = mid;
    }
    return ok;
}

// Union-Find
struct unionfind {
    vector<int64_t> par, rank, siz;

    // 初期化(コンストラクタ)
    unionfind(int64_t n) {
        par = vector<int64_t>(n);
        for (int i = 0; i < n; i++) par[i] = i;
        rank = vector<int64_t>(n, 0);
        siz = vector<int64_t>(n, 1);
    }

    //根(親)を探す
    int64_t find(int64_t x) {
        if (par[x] == x) return x;
        else return par[x] = find(par[x]);
    }

    // x と y が同じグループであるか
    bool same(int64_t x, int64_t y) {
        return find(x) == find(y);
    }

    // x と y を同じグループにする
    bool unite(int64_t x, int64_t y) {
        int64_t px = find(x), py = find(y);
        if (px == py) return false;
        if (rank[px] < rank[py]) swap(px, py);
        par[py] = px;
        if (rank[px] == rank[py]) rank[px]++;
        siz[px] += siz[py];
        return true;
    }

    // サイズを求める
    int64_t size(int64_t x) {
        return siz[find(x)];
    }
};

int64_t farthest (int64_t N, int64_t u, vector<vector<int64_t>> adj) {
    queue<int64_t> Q; Q.push(u);
    vector<int64_t> D(N, -1); D[u] = 0;
    while (Q.size()) {
        int64_t u = Q.front();
        Q.pop();
        for (auto v : adj[u]) {
            if (D[v] != -1) continue;
            D[v] = D[u] + 1;
            Q.push(v);
        }
    }
    int64_t Max = 0, ans = -1;
    for (int64_t i = 0; i < N; i++) {
        if (D[i] > Max) {
            Max = D[i];
            ans = i;
        }
    }
    return ans;
}

int64_t farthest_d (int64_t N, int64_t u, vector<vector<int64_t>> adj) {
    queue<int64_t> Q; Q.push(u);
    vector<int64_t> D(N, -1); D[u] = 0;
    while (Q.size()) {
        int64_t u = Q.front();
        Q.pop();
        for (auto v : adj[u]) {
            if (D[v] != -1) continue;
            D[v] = D[u] + 1;
            Q.push(v);
        }
    }
    sort(D.begin(), D.end());
    return D[N - 1];
}

/*----------------------------------------------------------*/

void solve () {
    lint N; cin >> N;
    vc<lint> A(N), B(N); cin >> A >> B;
    lint C = 0;
    Vsort(A);
    Vsort(B);
    do {
        lint c = 0;
        rep (i, N) {
            if (A[i] > B[i]) {
                c++;
            }
        }
        if (c > N / 2) C++;
    } while (next_p(A));
    dlfix(20);
    cout << 1.0 * C / factorial(N) << endl;
    return;
}

int main () {
    solve();
}