#include<bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define HUGE_NUM 4000000000000000000 //オーバーフローに注意
#define MOD 1000000007
//#define EPS 0.000000001



#define EPS 0.0000000001
#define SIZE 1005

struct Point{
	Point(double arg_x,double arg_y){
		x = arg_x;
		y = arg_y;
	}

	Point(){
		x = y = 0.0;
	}

	Point operator + (Point p){ return Point(x+p.x,y+p.y); }
	Point operator - (Point p){ return Point(x-p.x,y-p.y);}
	Point operator * (double a){ return Point(a*x,a*y); }
	Point operator / (double a){ return Point(x/a,y/a); }

	double abs(){ return sqrt(norm()); }
	double norm(){ return x*x + y*y; }

	bool operator<(const Point &p) const{

		if(fabs(x-p.x) > EPS){

			return x < p.x;
		}else{

			return y < p.y;
		}
	}

	bool operator == (const Point &p) const{
		return fabs(x-p.x) < EPS && fabs(y-p.y) < EPS;
	}


	void debug(){

		printf("(%.3lf,%.3lf)\n",x,y);
	}

	double x,y;
};

typedef Point Vector;
typedef vector<Point> Polygon;

struct Line{
	Line(){

	}
	Line(Point a,Point b){
		p[0] = a;
		p[1] = b;
	}
	/*void outPut(){

		printf("(%.3lf,%.3lf)-(%.3lf,%.3lf)\n",p[0].x,p[0].y,p[1].x,p[1].y);
	}*/
	Point p[2];
};

struct Circle{
	Point center;
	double r;
};

int N;
double X[SIZE];


double calc_dist(Point A,Point B){

	return sqrt((A.x-B.x)*(A.x-B.x)+(A.y-B.y)*(A.y-B.y));
}


double norm(Vector a){
	return a.x*a.x+a.y*a.y;
}

double abs(Vector a){
	return sqrt(norm(a));
}

double cross(Vector a,Vector b){
    return a.x*b.y-a.y*b.x;
}

double dot(Vector a,Vector b){
    return a.x*b.x + a.y*b.y;
}

static const int COUNTER_CLOCKWISE = 1;
static const int CLOCKWISE = -1;
static const int ONLINE_BACK = 2;
static const int ONLINE_FRONT = -2;
static const int ON_SEGMENT = 0;

/*
 * p0を基準点として、p1から見てp2が
 * 反時計回り側にあれば
 * COUNTER_CLOCKWISE
 * */
int ccw(Point p0,Point p1,Point p2){

	Vector a = p1 - p0;
	Vector b = p2 - p0;

	if(cross(a,b) > EPS)return COUNTER_CLOCKWISE;
	if(cross(a,b) < -EPS)return CLOCKWISE;
	if(dot(a,b) < -EPS)return ONLINE_BACK;
	if(a.norm() < b.norm())return ONLINE_FRONT;

	return ON_SEGMENT;
}

double arg(Vector p){
	return atan2(p.y,p.x);
}

Vector polar(double a,double r){
	return Point(cos(r)*a,sin(r)*a);
}

//円と円の交点
vector<Point> getCrossPoints(Circle c1,Circle c2){

	vector<Point> res;

	double d = abs(c1.center-c2.center);
	double a = acos((c1.r*c1.r+d*d-c2.r*c2.r)/(2*c1.r*d));
	double t = arg(c2.center-c1.center);

	res.push_back(Point(c1.center+polar(c1.r,t+a)));
	res.push_back(Point(c1.center+polar(c1.r,t-a)));

	return res;
}

//点のradを求める関数
double calc_rad(Point p){

	if(p.y == 0){

		if(p.x > 0){

			return 0;

		}else{ //p.x < 0

			return M_PI;
		}

	}else if(p.x == 0){

		if(p.y > 0){

			return M_PI/2.0;
		}else{


			return 3*M_PI/2.0;
		}

	}else{

		double base = atan(fabs(p.y)/fabs(p.x));

		if(p.x > 0){

			if(p.y > 0){

				return base;

			}else{ //p.y < 0

				return 2*M_PI-base;
			}

		}else{ //p.x < 0

			if(p.y > 0){

				return M_PI-base;

			}else{

				return base+M_PI;
			}
		}
	}
}


bool is_large(double R){

	Circle C;
	C.center = Point(0,0);
	C.r = R;

	Point P = Point(R,0);
	double pre_rad = 0;

	for(int i = 0; i < N; i++){

		Circle work;
		work.center = P;
		work.r = X[i];

		double tmp_dist = calc_dist(C.center,P);
		if(tmp_dist+R+EPS < X[i]){ //workの円が、基準円を内部に含む場合

			return false;
		}

		vector<Point> vec = getCrossPoints(C,work);
		Point next_P;

		if(ccw(C.center,P,vec[0]) == COUNTER_CLOCKWISE){

			next_P = vec[0];
		}else{

			next_P = vec[1];
		}

		double next_rad = calc_rad(next_P);
		if(next_rad < pre_rad){
			if(next_rad > EPS){ //■1周した
				return false;
			}
		}
		pre_rad = next_rad;
		P = next_P;
	}

	return true;
}

bool isOK(double R){

	double maxi = 0;

	double sum = 0;
	for(int i = 0; i < N; i++){

		double tmp = 2*asin(X[i]/(2*R));
		if(tmp > maxi){
			maxi = tmp;
		}
		sum += tmp;
	}

	return sum-maxi >= maxi;
}

int main(){

	scanf("%d",&N);

	double maxi = 0;
	for(int i = 0; i < N; i++){

		scanf("%lf",&X[i]);
		maxi = max(maxi,X[i]);
	}

	double R = maxi/2;
	double base = 0;

	for(int i = 0; i < N; i++){

		base += 2*asin(X[i]/(2*R));
	}

	if(base >= 2*M_PI){

		double left = maxi/2-EPS,right = maxi*1000,mid = (left+right)/2;
		double ans = right;

		for(int loop = 0; loop < 100; loop++){
			if(is_large(mid)){

				ans = mid;
				right = mid;

			}else{

				left = mid;
			}
			mid = (left+right)/2;
		}

		printf("%.12lf\n",ans);

	}else{

		double left = maxi/2-EPS,right = maxi*1000,mid = (left+right)/2;
		double ans = right;

		for(int loop = 0; loop < 100; loop++){
			if(isOK(mid)){

				ans = mid;
				right = mid;

			}else{

				left = mid;
			}
			mid = (left+right)/2;
		}

		printf("%.12lf\n",ans);
	}

	return 0;
}