sportprog........

//#pragma GCC optimize("Ofast,no-stack-protector")
//#pragma GCC target("avx")
#include <iostream>
#include <vector>
#include <algorithm>
#include <fstream>
#include <functional>
#include <cmath>
#include <set>
#include <deque>
#include <queue>
#include <utility>
#include <map>
#include <string>
#include <iomanip>
#include <utility>
#include <ctype.h>
#include <stdio.h>
#include <random>
#include <ctime>
#include <unordered_map>
#include <unordered_set>

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

typedef long long ll;

using namespace std;
/*vector<set<int>> g;
vector<int> used;
vector<int> pre;
int cnt, st, en;
bool f;

const ll MOD = (ll)1e9 + 7;


ll pow(ll a, int n) {
    ll ans = 1;
    while (n) {
        if (n & 1) ans = (ans * a) % MOD;
        a = (a * a) % MOD;
        n >>= 1;
    }
    return ans;
}


void dfs(int h, int pr) {
    used[h] = 1;
    cnt++;
    for (auto e: g[h]) {
        if ((e == pr) || (used[e] == 2)) continue;
        if (used[e] == 1) {
            if (!f) {
                en = h;
                st = e;
                f = 1;
            }
        } else {
            pre[e] = h;
            dfs(e, h);
        }
    }
    used[h] = 2;
}*/

vector<ll> dpl;
vector<ll> dpr;
vector<ll> a;


long double my_abs(long double q) {
    if (q > 1.0) return q;
    return 0;
}


bool test(long double n) {
    int l1 = -1;
    int r1 = (int)dpl.size();
    while (r1 - l1 > 1) {
        int m = (r1 + l1) / 2;
        if ((long double)dpl[m] <= my_abs(n - 1)) l1 = m;
        else r1 = m;
    }
    int l2 = -1;
    int r2 = (int)dpr.size();
    while (r2 - l2 > 1) {
        int m = (r2 + l2) / 2;
        if ((long double)dpr[m] > my_abs(n - 1)) l2 = m;
        else r2 = m;
    }
    return ((a[r2] - a[l1]) <= 2 * n);
}


int main() {
    iostream::sync_with_stdio(false);
    /*int n;
    cin >> n;
    vector<ll> a(n);
    ll mx = 0;
    for (auto e : a) cin >> e;
    sort(a.begin(), a.end());
    for (int i = 0; i < n - 1; i++) {
        mx = max(mx, a[i + 1] - a[i]);
    }*/
    /*int n, k;
    cin >> n >> k;
    g.resize(n);
    int f1 = 1;
    for (int i = 0; i < n; i++) {
        int x;
        cin >> x;
        if (i == x - 1) continue;
        f1 = 0;
        g[x - 1].insert(i);
        g[i].insert(x - 1);
    }
    if (k == 1) {
        cout << f1;
        return 0;
    }
    used.assign(n, 0);
    ll answ = 1;
    pre.assign(n, -1);
    for (int i = 0; i < n; i++) {
        if (!used[i]) {
            dfs(i, -1);
            if (!f) answ = (answ * k * pow((ll)k - 1, cnt - 1)) % MOD;
            else {
                int ncnt = 1;
                int cur = en;
                while (cur != st) {
                    cur = pre[cur];
                    ncnt++;
                }
                vector<ll> dp(ncnt + 1, 0);
                dp[0] = 1;
                dp[1] = k;
                //for (int i = 2; i <= ncnt; i++) dp[i] = (dp[i - 2] * (k - 1) + dp[i - 1] * (k - 2)) % MOD;
                //answ = (answ * dp[ncnt]) % MOD;
                answ = (answ * (ll)(pow((ll)k - 1, ncnt) + pow(-1, ncnt) * (k - 1))) % MOD;
                answ = (answ * pow((ll)k - 1, cnt - ncnt)) % MOD;
            }
        }
    }
    cout << answ;*/
    int n;
    cin >> n;
    a.resize(n);
    ll mn = (ll)1e9 + 1;
    ll mx = -1;
    for (auto& e : a) {
        cin >> e;
        mn = min(mn, e);
        mx = max(mx, e);
    }
    ll rst = mx - mn + 1;
    sort(a.begin(), a.end());
    dpl.assign(n, 0);
    dpr.assign(n, 0);
    for (int i = 1; i < n; i++) {
        int l = -1;
        int r = i;
        while (r - l > 2) {
            int f = (l * 2 + r) / 3;
            int s = (l + r * 2) / 3;
            if (max(a[i] - a[f], dpl[f] + 1) >= max(a[i] - a[s], dpl[s] + 1)) l = f;
            else r = s;
        }
        dpl[i] = max(a[i] - a[(l + r) / 2], dpl[(l + r) / 2] + 1);
    }
    for (int i = n - 2; i >= 0; i--) {
        int l = i;
        int r = n;
        while (r - l > 2) {
            int f = (l * 2 + r) / 3;
            int s = (l + r * 2) / 3;
            if (max(a[f] - a[i], dpr[f] + 1) >= max(a[s] - a[i], dpr[s] + 1)) l = f;
            else r = s;
        }
        dpr[i] = max(a[(l + r) / 2] - a[i], dpr[(l + r) / 2] + 1);
    }
    /*for (auto e : dpl) cout << e << ' ';
    cout << '\n';
    for (auto e : dpr) cout << e << ' ';
    cout << '\n';*/
    ll l = -1;
    ll r = rst * 2;
    while (r - l > 1) {
        ll m = (l + r) / 2;
        if (test(m / 2.0)) r = m;
        else l = m;
    }
    if (r % 2) cout << r / 2.0;
    else cout << r / 2 << ".0";
    return 0;
}