Language: C++

#include<bits/stdc++.h>

#define pb push_back
#define vi vector < int >
#define ii pair < int, int >
#define vii vector < pair < int, int > >
#define vvi vector < vector < int > >
#define ll long long
#define X first
#define Y second
#define mp make_pair
#define FOR( i, lo, hi ) for( int i = (lo);i < (hi);i++ )
#define DFOR( i, hi, lo ) for( int i = (hi);i >= (lo);i-- )
#define pqueue priority_queue

using namespace std;

//MODULAR ARITHMETIC
const long long int MOD = 1e9 + 7;

ll REM( ll a )
{
	a %= MOD;
	if ( a < 0 )
	   a += MOD;
	return a;
}

ll ADD( ll a, ll b )
{
	return REM( REM( a ) + REM( b ) );
}

ll SUB( ll a, ll b )
{
	return REM( REM( a ) - REM( b ) );
}

ll MUL( ll a, ll b )
{
	return REM( REM( a ) * REM( b ) );
}

ll POT( ll n, ll k )
{
	if ( k == 0 )
		return 1;

	ll ret = POT( n, k / 2 );
	ret = MUL( ret, ret );

	if ( k % 2 )
		return MUL( ret, n );
	return ret;
}

ll DIV( ll a, ll b )
{
	return MUL( a, POT( b, MOD - 2 ) );
}

//PRIME TEST
bool isPrime( ll x )
{
	for ( ll i = 2;i <= sqrt( x ); i++ )
		if ( x % i == 0 )
			return false;
	return true;
}

//GEOMETRY STUFF
const double EPS = 1e-9, PI = acos( -1 );

//POINTS
struct point {
	double x, y;
	point( double x, double y )
	{
		this->x = x;
		this->y = y;
	}
	friend bool operator < ( point a, point b )
	{
		if ( fabs( a.x - b.x ) > EPS )
			return a.y < b.y;
		return a.x < b.x;
	}
	
	friend bool operator == ( point a, point b )
	{
		return ( fabs( a.x - b.x ) < EPS && fabs( a.y - b.y ) < EPS );
	}
};

double dist( point a, point b )
{
	return hypot( a.x - b.x, a.y - b.y );
}

point rotate( point o, point p, double theta )
{
	double rad = theta * PI / 180.0;
	p.x -= o.x;
	p.y -= o.y;
	point ret = point( p.x * cos( rad ) - p.y * sin( rad ), p.x * sin( rad ) + p.y * cos( rad ) );
	p.x += o.x;
	p.y += p.y;
	return ret;
}

//LINES
struct line {
	double a, b, c;
	line( double a, double b, double c )
	{
		this->a = a;
		this->b = b;
		this->c = c;
	}
};

void pointsToLine( point p1, point p2, line &l )
{
	if ( fabs( p1.x - p2.x ) < EPS )
	{
		l.a = 1.0;
		l.b = 0.0;
		l.c = 0 - p1.x;
	}
	else
	{
		l.a = 0 - ( double )( p1.y - p2.y ) / ( p1.x - p2.x ); 
		l.b = 1.0;
		l.c = 0 - ( double )( l.a * p1.x ) - p1.y;
	}
}

bool areParallel( line l1, line l2 )
{
	return ( fabs( l1.a - l2.a ) < EPS && fabs( l1.b - l2.b ) < EPS );
}

bool areSame( line l1, line l2 )
{
	return( areParallel( l1, l2 ) && fabs( l1.c - l2.c ) < EPS );
}

bool areIntersect( line l1, line l2, point &p )
{
	if ( areParallel( l1, l2 ) )
		return false;
	
	p.x = ( l2.b * l1.c - l1.b * l2.c ) / ( l2.a * l1.b - l1.a * l2.b );
	if ( fabs( l1.b ) < EPS )
		p.y = 0 - (l1.a * p.x + l1.c); 
	else
		p.y = 0 - (l2.a * p.x + l2.c);
	
	return true;
}

//VECTORS
struct vec {
	double x, y;
	vec( double x, double y )
	{
		this->x = x;
		this->y = y;
	}
};
vec toVec( point a, point b )
{
	return vec( b.x - a.x, b.y - a.y );
}

vec scale( vec v, double s )
{
	return vec( v.x * s, v.y * s );
}

point translate( point p, vec v )
{
	return point( p.x + v.x , p.y + v.y );
}

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

double norm_sq( vec v )
{
	return v.x * v.x + v.y * v.y;
} 

double distToLine( point p, point a, point b, point &c ) 
{
	vec ap = toVec( a, p ), ab = toVec( a, b ); 
	double u = dot( ap, ab ) / norm_sq( ab );
	c = translate( a, scale( ab, u ) ); 
	return dist( p, c );
}

double angle( point a, point o, point b ) //rads
{ 
	vec oa = toVec( o, a ), ob = toVec( o, b ); 
	return acos( dot( oa, ob ) / sqrt( norm_sq( oa ) * norm_sq( ob ) ) ); 
}

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

bool ccw( point p, point q, point r ) 
{
	return cross( toVec( p, q ), toVec( p, r ) ) > 0; 
}

bool collinear( point p, point q, point r ) 
{
 return fabs( cross( toVec( p, q ), toVec( p, r ) ) ) < EPS; 
}

const int MAXN = 60;

int n;
vector < point > A;
double ans;

double maxd( point p )
{
	double ret = 0.0;
	FOR( i, 0, n )
	{
		ret = max( ret, dist( p, A[ i ] ) );
	}
	return ret;
}

point middle( point a, point b )
{
	vec v = toVec( a, b );
	v = scale( v, 0.5 );
	return translate( a, v );
}

point circump( point a, point b, point c )
{
	point m1 = middle( a, b );
	point p1 = rotate( m1, a, 90.0 );
	line l1 = line( 0.0, 0.0, 0.0 );
	pointsToLine( m1, p1, l1 );
	
	point m2 = middle( b, c );
	point p2 = rotate( m2, b, 90.0 );
	line l2 = line( 0.0, 0.0, 0.0 );
	pointsToLine( m2, p2, l2 );
	
	point ret = point( 0.0, 0.0 );
	areIntersect( l1, l2, ret );
	return ret;
}

int main()
{
	ans = 1e18.0;
	cin >> n;
	FOR( i, 0, n )
	{
		double x, y;cin >> x >> y;
		A.pb( point( x, y ) );
	}
	
	FOR( i, 0, n )
	{
		FOR( j, 0, n )
		{
			point p = middle( A[ i ], A[ j ] );
			ans = min( ans, maxd( p ) ); 
		}
	}

	FOR( i, 0, n )
	{
		FOR( j, 0, n )
		{
			FOR( k, 0, n )
			{
				point p = circump( A[ i ], A[ j ], A[ k ] );
				ans = min( ans, maxd( p ) );
			}
		}
	}
	
	printf( "%.11lf\n", ans );
	return 0;
}


Compiler output:
a.cc: In function 'int main()':
a.cc:267:15: error: unable to find numeric literal operator 'operator"".0'
  267 |         ans = 1e18.0;
      |               ^~~~~~