#include <bits/stdc++.h>
#define ll long long
#define pii pair<int, int>
#define pll pair<ll, ll>
#define pdd pair<double, double>
#define F first
#define S second 
#define all(x) x.begin(), x.end()
using namespace std;

const double eps = 1e-9;
pdd operator+(pdd a, pdd b)
{
    return pdd(a.F + b.F, a.S + b.S);
}
pdd operator-(pdd a)
{
    return pdd(-a.F, -a.S);
}
pdd operator-(pdd a, pdd b)
{
    return a + (-b);
}
pdd operator*(pdd a, double b)
{
    return pdd(a.F * b, a.S * b);
}
pdd operator/(pdd a, double b)
{
    return pdd(a.F / b, a.S / b);
}
double dot(pdd a, pdd b)
{
    return a.F * b.F + a.S * b.S;
}
double abs2(pdd a)
{
    return dot(a, a);
}
int sign(double d)
{
    return fabs(d) < eps ? 0 : (d < 0 ? -1 : 1);
}
double cross(pdd a, pdd b)
{
    return a.F * b.S - a.S * b.F;
}
int ori(pdd a, pdd b, pdd c)
{
    return sign(cross(b - a, c - a));
}
void convex(vector<pdd> &dots)
{
    sort(all(dots));
    vector<pdd> ans(1, dots[0]);
    for (int ct = 0; ct < 2; ++ct, reverse(all(dots)))
        for (int i = 1, t = ans.size(); i < dots.size(); ans.emplace_back(dots[i++]))
            while(ans.size() > t && ori(ans.end()[-2], ans.back(), dots[i]) <= 0)
                ans.pop_back();
    ans.pop_back(), ans.swap(dots);
}
bool collinear(pdd p1, pdd p2, pdd p3)
{
    return ori(p1, p2, p3) == 0;
}
bool btw(pdd p1, pdd p2, pdd p3)
{
    return collinear(p1, p2, p3) && sign(dot(p1 - p3, p2 - p3)) <= 0;
}
bool seg_intersect(pdd p1, pdd p2, pdd p3, pdd p4)
{
    int a123 = ori(p1, p3, p4);
    int a124 = ori(p1, p2, p4);
    int a341 = ori(p3, p4, p1);
    int a342 = ori(p3, p4, p2);
    if (a123 == 0 && a124 == 0)
        return btw(p1, p2, p3) || btw(p1, p2, p4) || btw(p3, p4, p1) || btw(p3, p4, p2);
    return a123 * a124 <= 0 && a341 * a342 <= 0;
}


int n;
vector<int> d[2], v;

signed main()
{
    ios::sync_with_stdio(0);
    cin.tie(0), cout.tie(0);
    
    cin >> n;
    d[0].resize(n);
    for (auto &i : d[0])
        cin >> i;
    cin >> n;
    d[1].resize(n);
    for (auto &i : d[1])
        cin >> i;

    for (int i : d[0]) 
        v.emplace_back(max(1, i - 1)), 
        v.emplace_back(i),
        v.emplace_back(i + 1);
    for (int i : d[1]) 
        v.emplace_back(max(1, i - 1)), 
        v.emplace_back(i),
        v.emplace_back(i + 1);

    sort(all(d[0]));
    sort(all(d[1]));
    sort(all(v));
    v.resize(unique(all(v)) - v.begin());
    auto count = [&](int x, int i)
    {
        int win = lower_bound(all(d[i]), x) - d[i].begin();
        int tie = upper_bound(all(d[i]), x) - d[i].begin();
        return (ll)(win + tie);
    };

    ll rate = 0;
    for (auto x : d[1])
        rate += count(x, 0);
    if (rate >= (ll)d[0].size() * (ll)d[1].size())
        swap(d[0], d[1]);

    vector<pdd> hull;
    for (auto i : v)
    {
        pdd p;
        auto &[x, y] = p;
        x = count(i, 0) / double(d[0].size() * 2);
        y = count(i, 1) / double(d[1].size() * 2);
        hull.emplace_back(p);
    }
    convex(hull);
    double mi = 1, mx = 0;
    for (int i = 0; i < (int)hull.size(); i++)
    {
        int j = (i + 1) % (int)hull.size();
        if (sign(hull[i].F - 0.5) * sign(hull[j].F - 0.5) <= 0)
        {
            double y = (hull[i].S * (0.5 - hull[j].F) + hull[j].S * (hull[i].F - 0.5)) / (hull[i].F - hull[j].F);
            mi = min(mi, y);
        }
        if (sign(hull[i].S - 0.5) * sign(hull[j].S - 0.5) <= 0)
        {
            double x = (hull[i].F * (0.5 - hull[j].S) + hull[j].F * (hull[i].S - 0.5)) / (hull[i].S - hull[j].S);
            mx = max(mx, x);
        }
    }
    cout << fixed << setprecision(10) << mi << ' ' << mx << '\n';
    
}