#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <sstream>
#include <vector>
#include <complex>
#include <ctime>
#include <stack>

using namespace std;

typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> VI;
typedef vector< VI > VVI;
typedef pair<int, int> PII;
typedef vector<PII> VPII;

#define REP(i, n) for(int i = 0; i < n; ++i)
#define RREP(i, n) for(int i = n - 1; i >= 0; --i)
#define FOR(i, x, y) for(int i = x; i <= y; ++i)
#define RFOR(i, x, y) for(int i = x; i >= y; --i)
#define SZ(a) (int)(a).size()
#define ALL(a) (a).begin(),(a).end()
#define SORT(a) sort(ALL(a))
#define CLEAR(x) memset(x, 0, sizeof x);
#define COPY(FROM, TO) memcpy(TO, FROM, sizeof TO);
#define UNIQUE(c) SORT(c),(c).resize(unique(ALL(c))-(c).begin())
#define pb push_back
#define sqr(x) (x)*(x)
#define X first
#define Y second
const long double pi=acos(-1.0);
const long double eps = 1e-9;
const int INF = 2 * (1e+9);

PII dp[51][51][51];
class TaroFriends {
	public:
	int getNumber(vector <int> c, int x) {
    int n = SZ(c);
    if (n == 1) return 0;
    SORT (c);
    dp[1][0][1] = make_pair(c[0] + x, c[0] + x);
    dp[1][1][0] = make_pair(c[0] - x, c[0] - x);
    FOR (cnt, 2, n) {
		  FOR (i, 0, cnt) {
        int j = cnt - i;
        int l = c[cnt - 1] - x, r = c[cnt - 1] + x;
        VI res (2, 0);
        res[0] = l, res[1] = r;
        int ans = INF, left = -INF, right = INF;
        int i1 = i - 1, j1 = j;
        if (i - 1 >= 0) {
            int cur_l = dp[cnt - 1][i1][j1].X, cur_r = dp[cnt - 1][i1][j1].Y;
            int new_l = min (cur_l, res[0]), new_r = max (cur_r, res[0]);
            int dist = abs(new_l - new_r);
            if (dist < ans) {
              ans = dist, left = new_l, right = new_r;
            }
        }
        i1 = i, j1 = j - 1;
        if (j - 1 >= 0) {
            int cur_l = dp[cnt - 1][i1][j1].X, cur_r = dp[cnt - 1][i1][j1].Y;
            int new_l = min (cur_l, res[1]), new_r = max (cur_r, res[1]);
            int dist = abs(new_l - new_r);
            if (dist < ans) {
              ans = dist, left = new_l, right = new_r;
            }
        }
        dp[cnt][i][j] = make_pair(left, right);
      }
    }
    int minn = INF;
    FOR (i, 0, n) {
      int j = n - i;
        minn = min (minn, abs(dp[n][i][j].X - dp[n][i][j].Y));
    }
    return minn;
	}
};