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

using T = long long;
struct p3 {
    T x,y,z;
    p3 operator+(p3 p) {return {x+p.x, y+p.y, z+p.z};}
    p3 operator-(p3 p) {return {x-p.x, y-p.y, z-p.z};}
    p3 operator*(T d) {return {x*d, y*d, z*d};}
    p3 operator/(T d) {return {x/d, y/d, z/d};}
    bool operator==(p3 p) {
        return tie(x,y,z) == tie(p.x,p.y,p.z);
    }
    bool operator!=(p3 p) {return !operator==(p);}
};
T operator|(p3 v, p3 w) { // dot product
    return v.x*w.x + v.y*w.y + v.z*w.z;
}
p3 operator*(p3 v, p3 w) { // cross product
    return {v.y*w.z - v.z*w.y,
        v.z*w.x - v.x*w.z,
        v.x*w.y - v.y*w.x};
}
T norm(p3 v) {return v|v;} //modulo^2
long double abs(p3 v) {return sqrtl(norm(v));} //modulo
p3 unit(p3 v) {return v/abs(v);} //versore ($|v|\neq 0$)

//>0 sse s è sopra il piano pqr, nella direzione di $\overrightarrow{PQ}\times\overrightarrow{PR}$
T orient(p3 p, p3 q, p3 r, p3 s) {
    return (q-p) * (r-p) | (s-p); //0 sse p,q,r,s coplanari
}
// orientamento 2D delle proiezioni di p, q, r
// rispetto al piano perpendicolare a n
T orientByNormal(p3 p, p3 q, p3 r, p3 n) {
    return (q-p) * (r-p) | n;
}
struct plane {
    p3 n; T d;
    // From normal n and offset d
    plane(p3 n, T d) : n(n), d(d) {}
    // From normal n and point P
    plane(p3 n, p3 p) : n(n), d(n|p) {}
    // From three non-collinear points P,Q,R
    plane(p3 p, p3 q, p3 r) : plane((q-p)*(r-p), p) {}
    T side(p3 p) {return (n|p)-d;}
    long double dist(p3 p) {return ((long double)(abs(side(p))))/abs(n);}
    plane translate(p3 t) {return {n, d+(n|t)};}
    // requires double
    plane shiftUp(T dist) {return {n, d+dist*abs(n)};}
    p3 proj(p3 p) {return p - n*side(p)/norm(n);}
    p3 refl(p3 p) {return p - n*2*side(p)/norm(n);}
};

const int MAXN = 55;
int n;
p3 v[MAXN];

bool all(p3 a,p3 b,p3 c){
    return (b-a)*(c-a)==p3(0,0,0);
}

bool check(plane p1,plane p2){
    
    for(int i=0;i<n;i++){
        if(p1.side(v[i])>0 && p2.side(v[i])>0)return false;
        if(p1.side(v[i])<0 && p2.side(v[i])<0)return false;
    }
    
    return true;
}

void solve(){
    cin>>n;
    
    for(int i=0;i<n;i++){
        cin>>v[i].x>>v[i].y>>v[i].z;
    }
    
    bool ok=true;
    for(int i=0;i+2<n;i++){
        if(!all(v[i],v[i+1],v[i+2]))ok=false;
    }
    
    if(ok){
        cout<<"0.0\n";
        return;
    }
    
    long double ans=2e5;
    for(int i=0;i<n;i++){
        for(int j=0;j<n;j++){
            for(int k=0;k<n;k++){
                for(int l=0;l<n;l++){
                    if(i==j || i==k || i==l || j==k || j==l || k==l)continue;
                    
                    auto a=v[i],b=v[j],c=v[k],d=v[l];
                    
                    if(!all(a,b,c)){
                        plane pl1(a,b,c);
                        plane pl2 = pl1.translate(d-a);

                        if(check(pl1,pl2)){
                            ans=min(ans,pl1.dist(d));
                        }
                    }
                    
                    if(!all(a,b,b+(d-c))){
                        plane pl1(a,b,b+(d-c));
                        plane pl2 = pl1.translate(d-a);
                        
                        if(check(pl1,pl2)){
                            ans=min(ans,pl1.dist(d));
                        }
                    }
                }
            }
        }
    }
    
    cout<<setprecision(20)<<ans<<"\n";
}

int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    
    int t=1;
    //cin>>t;
    for(int i=1;i<=t;i++)solve();
    
    return 0;
}