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

using ld = long double;
#define double ld
#define all(v) (v).begin(), (v).end()
#define pb push_back

void dbg_out() { cerr << endl; }
template <typename H, typename... T>
void dbg_out(H h, T... t) { cerr << ' ' << h; dbg_out(t...); }
#define dbg(...) { cerr << #__VA_ARGS__ << ':'; dbg_out(__VA_ARGS__); }

const double EPS = 1e-8;
bool zero(double x) { return abs(x) < EPS; }

struct point {
	double x, y, z;
	point(): x(0), y(0), z(0) {}
	point(double _x, double _y, double _z): x(_x), y(_y), z(_z) {}
	bool operator==(const point rhs) const {
		return zero(x-rhs.x) && zero(y-rhs.y) && zero(z-rhs.z);
	}
	point operator+(const point rhs) const { return point(x+rhs.x, y+rhs.y, z+rhs.z); }
	point operator-(const point rhs) const { return point(x-rhs.x, y-rhs.y, z-rhs.z); }
	point operator*(const double c) const { return point(c*x, c*y, c*z); }
	point operator/(const double c) const { return point(x/c, y/c, z/c); }
	point operator^(const point rhs) const { return point(y*rhs.z-z*rhs.y, z*rhs.x-x*rhs.z, x*rhs.y - y*rhs.x); }
	double operator*(const point rhs) const { return x * rhs.x + y*rhs.y + z*rhs.z; }
};

struct plane {
	array<point, 3> p;
	array<double, 4> eq;

	plane() {}
	plane(point _p, point _q, point _r): p({_p, _q, _r}) {
		point dir = (p[1] - p[0]) ^ (p[2] - p[0]);
		dir = dir / sqrt((dir * dir));
		eq = {dir.x, dir.y, dir.z, dir * (p[0]) * (-1) };
	};
};

double sdist(point p, plane P) {
	return P.eq[0] * p.x + P.eq[1] * p.y + P.eq[2] * p.z + P.eq[3];
}

double dist(point p, plane P) {
	return abs(P.eq[0] * p.x + P.eq[1] * p.y + P.eq[2] * p.z + P.eq[3]);
}

const double INF = 1e10;

void solve() {
	int n; cin >> n;
	vector<point> pts(n);
	double ans = numeric_limits<int>::max();
	for(auto &[x, y, z]: pts) cin >> x >> y >> z;
	for(int i=0;i<n;i++) for(int j=i+1;j<n;j++) for(int k=j+1;k<n;k++) {
		if( ((pts[j] - pts[i]) ^ (pts[k] - pts[i])) == point() ) 
			continue;
		plane P(pts[i], pts[j], pts[k]);
		double mn = INF, mx = -INF;
		for(point p: pts) {
			double d = sdist(p, P);
			mn = min(d, mn);
			mx = max(d, mx);
		}
		assert(!zero(mx - mn));
		ans = min(ans, mx - mn);
	}
	for(int i=0;i<n;i++) for(int j=i+1;j<n;j++) for(int k=0;k<n;k++) for(int l=k+1;l<n;l++) {
		array<int, 4> v = {i, j, k, l};
		sort(all(v));
		if(v[0] == v[1] || v[1] == v[2] || v[2] == v[3]) continue;
		plane P;
		point dir = (pts[j] - pts[i]) ^ (pts[l] - pts[k]);
		if(dir == point()) continue;
		P.eq[0] = dir.x; P.eq[1] = dir.y; P.eq[2] = dir.z; P.eq[3] = 0;
		double mn = INF, mx = -INF;
		for(point p: pts) {
			double d = sdist(p, P);
			mn = min(d, mn);
			mx = max(d, mx);
		}
		assert(!zero(mx - mn));
		ans = min(ans, mx - mn);
	}

	cout << ans << '\n';
}

signed main() {
	ios::sync_with_stdio(false);
	cin.tie(0);
	cout << fixed << setprecision(10);
	solve();
}