criyle/codenet-compile-errors huggingface dataset:
Language: C++

#include <iostream>
#include <vector>
#include <iomanip>

using namespace std;

int main()
{
	int n;
	cin >> n;
	vector<double> x(n);
	vector<double> y(n);

	cout << setprecision(10);
	for (int i = 0; i < n; i++)
	{
		cin >> x[i] >> y[i];
	}
	if (n == 2)
	{
		cout << sqrt((x[0] - x[1]) * (x[0] - x[1]) + (y[0] - y[1]) * (y[0] - y[1])) / 2 << endl;
	}
	else
	{
		double min_of_max = 10e9;
		for (int i = 0; i < n; i++)
		{
			for (int j = i + 1; j < n; j++)
			{
				for (int k = j + 1; k < n; k++)
				{
					double a = (x[j] - x[i]) * (x[j] - x[i]) + (y[j] - y[i]) * (y[j] - y[i]); //kの対辺の長さの二乗
					double b = (x[k] - x[i]) * (x[k] - x[i]) + (y[k] - y[i]) * (y[k] - y[i]); //jの対辺の長さの二乗
					double c = (x[j] - x[k]) * (x[j] - x[k]) + (y[j] - y[k]) * (y[j] - y[k]); //iの対辺の長さの二乗

					double ux = (a * (b + c - a) * x[k] + b * (c + a - b) * x[j] + c * (a + b - c) * x[i]) / (a * (b + c - a) + b * (c + a - b) + c * (a + b - c));;
					double uy = (a * (b + c - a) * y[k] + b * (c + a - b) * y[j] + c * (a + b - c) * y[i]) / (a * (b + c - a) + b * (c + a - b) + c * (a + b - c));;

					//cout << ux << " " << uy << endl;

					double max = 0;

					for (int v = 0; v < n; v++)
					{
						double d = sqrt((x[v] - ux) * (x[v] - ux) + (y[v] - uy) * (y[v] - uy));
						if (max < d)
							max = d;
					}
					if (max != 0 && max < min_of_max)
						min_of_max = max;
				}
			}
		}
		cout << min_of_max << endl;
	}
}

Compiler output:
a.cc: In function 'int main()':
a.cc:21:25: error: 'sqrt' was not declared in this scope
   21 |                 cout << sqrt((x[0] - x[1]) * (x[0] - x[1]) + (y[0] - y[1]) * (y[0] - y[1])) / 2 << endl;
      |                         ^~~~
a.cc:45:60: error: 'sqrt' was not declared in this scope
   45 |                                                 double d = sqrt((x[v] - ux) * (x[v] - ux) + (y[v] - uy) * (y[v] - uy));
      |                                                            ^~~~
Language: C++

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
template<class T,class U> using P = pair<T,U>;
template<class T> using vec = vector<T>;
template<class T> using vvec = vector<vec<T>>;
#define rep(i_macro, n_macro) for (int i_macro=0; i_macro<n_macro; i_macro++)

template<class T>
double dist(P<T, T> x1, P<T, T> x2){
  return sqrt(pow((x1.first-x2.first),2) + pow((x1.second-x2.second),2));
}

struct CircleInfo{
  P<double, double> center;
  double radius;
  CircleInfo(P<double, double> center, double radius):center(center), radius(radius){
  }
};

CircleInfo calcCircle(P<int, int> x1, P<int, int> x2, P<int, int> x3){
  double a11 = x2.first - x1.first;
  double a12 = x2.second - x1.second;
  double a21 = x3.first - x2.first;
  double a22 = x3.second - x2.second;
  double b1 = (pow(x2.first,2) - pow(x1.first,2) + pow(x2.second,2) - pow(x1.second,2))/2.0;
  double b2 = (pow(x3.first,2) - pow(x2.first,2) + pow(x3.second,2) - pow(x2.second,2))/2.0;
  P<double, double> center;
  center.first = (a22*b1 - a12*b2) / (a11*a22 - a12*a21);
  center.second = (-a21*b1 + a11*b2) / (a11*a22 - a12*a21);
  double radius = sqrt(pow((center.first-x1.first),2) + pow((center.second-x1.second),2));
  return CircleInfo(center, radius);
}

int main(){
  int N;
  double error = 1e-3;
  cin >> N;
  vec<P<int, int>> pos;
  for (int i=0; i<N; i++){
    int x,y;
    cin >> x >> y;
    pos.push_back(P<int, int>(x, y));
  }
  double ans = 1001001009;
  if (N==2) {
    ans = dist(pos[0], pos[1])/2.0;
  } else {
    for (int i=0; i<N; i++){
      for (int j=i+1; j<N; j++){
        for (int k=j+1; k<N; k++){
          CircleInfo cInfo = calcCircle(pos[i], pos[j], pos[k]);
          //cout << cInfo.center.first << " " << cInfo.center.second << " " << cInfo.radius <<  endl;
          P<double, double> c = cInfo.center;
          bool is_valid = true;
          rep(in, N) {
            P<double, double> c = cInfo.center;
            if (sqrt(pow((c.first-pos[in].first),2) + pow((c.second-pos[in].second),2))-cInfo.radius > error) {
              is_valid = false;
            }
          }
          if (is_valid==true && ans>cInfo.radius) {
            ans = cInfo.radius;
          }4
        }
      }
    }
  }
  cout << ans << endl;
}

Compiler output:
a.cc: In function 'int main()':
a.cc:64:13: error: expected ';' before '}' token
   64 |           }4
      |             ^
      |             ;
   65 |         }
      |         ~
Language: C++

#include<iostream>
#include<string>
using namespace std;

double calcKyori(double x1,double x2,double  y1,double y2) {
	return sqrt(pow(x1 - x2, 2) + pow(y1 - y2, 2));
}


void calcCircle(double *cx,double *cy,double x1, double x2, double x3, double y1, double y2, double y3)
{
	double G;
	G = (y2*x1 - y1 * x2 + y3 * x2 - y2 * x3 + y1 * x3 - y3 * x1);
	*cx = ((x1*x1 + y1 * y1)*(y2 - y3) + (x2*x2 + y2 * y2)*(y3 - y1) + (x3*x3 + y3 * y3)*(y1 - y2)) / (2 * G);
	*cy = -((x1*x1 + y1 * y1)*(x2 - x3) + (x2*x2 + y2 * y2)*(x3 - x1) + (x3*x3 + y3 * y3)*(x1 - x2)) / (2 * G);

	
}


int main() {
	string s;
	int N;
	double min_r=1000000;
	double **data;
	cin >> N;
	data = new double*[N];
	for (int i = 0; i <N; i++) {
		data[i] = new double[N];
	}
	for (int i = 0;i < N;i++) {
		cin >> data[i][0] >> data[i][1];
	}
	
	if (N == 2) {
		double x, y;
		x = (data[0][0] + data[1][0]) / 2;
		y = (data[0][1] + data[1][1]) / 2;
		min_r = sqrt(pow(x-data[0][0],2)+pow(y-data[0][1],2));
	}
	else {
		
		for (int i = 0;i < N;i++) {
			for (int j = 0;j < i;j++) {
				for (int k = 0;k < j;k++) {
					double x, y,r;
					bool flag = true;
					
					calcCircle(&x, &y, data[i][0], data[j][0], data[k][0], data[i][1], data[j][1], data[k][1]);
					r = sqrt(pow(x - data[i][0], 2) + pow(y - data[i][1], 2));
					
					for (int m = 0;m < N;m++) {
						if (m!=i && m!=j && m!=k) {
							if (r<=calcKyori(x,data[m][0],y,data[m][1])) {
								flag = false;
								break;
							}
						}
					}
					if (flag == true && min_r > r)min_r = r;
				}
			}
		}
	}
	double a, b;
	cout << min_r << endl;
	
}

Compiler output:
a.cc: In function 'double calcKyori(double, double, double, double)':
a.cc:6:21: error: 'pow' was not declared in this scope
    6 |         return sqrt(pow(x1 - x2, 2) + pow(y1 - y2, 2));
      |                     ^~~
a.cc:6:16: error: 'sqrt' was not declared in this scope
    6 |         return sqrt(pow(x1 - x2, 2) + pow(y1 - y2, 2));
      |                ^~~~
a.cc: In function 'int main()':
a.cc:39:30: error: 'pow' was not declared in this scope
   39 |                 min_r = sqrt(pow(x-data[0][0],2)+pow(y-data[0][1],2));
      |                              ^~~
a.cc:39:25: error: 'sqrt' was not declared in this scope
   39 |                 min_r = sqrt(pow(x-data[0][0],2)+pow(y-data[0][1],2));
      |                         ^~~~
a.cc:50:50: error: 'pow' was not declared in this scope
   50 |                                         r = sqrt(pow(x - data[i][0], 2) + pow(y - data[i][1], 2));
      |                                                  ^~~
a.cc:50:45: error: 'sqrt' was not declared in this scope
   50 |                                         r = sqrt(pow(x - data[i][0], 2) + pow(y - data[i][1], 2));
      |                                             ^~~~
Language: C++

#include <bits/stdc++.h>
#define rep(i,n) for (int i=0;i<(n);++i)
using namespace std;

double distance(double a, double b){
  return (a**2 + b**2)**0.5
    
}

int main(){
  int n;
  double max = 0;
  
  rep(i,n){
    double a, b;
    cin >> a >> b;
    max = max(distance(a,b), max) 
  }
  cout << max / 2 << endl;
}
  
  
  

Compiler output:
a.cc: In function 'double distance(double, double)':
a.cc:6:13: error: invalid type argument of unary '*' (have 'int')
    6 |   return (a**2 + b**2)**0.5
      |             ^~
a.cc:6:20: error: invalid type argument of unary '*' (have 'int')
    6 |   return (a**2 + b**2)**0.5
      |                    ^~
a.cc:6:24: error: invalid type argument of unary '*' (have 'double')
    6 |   return (a**2 + b**2)**0.5
      |                        ^~~~
a.cc:6:28: error: expected ';' before '}' token
    6 |   return (a**2 + b**2)**0.5
      |                            ^
      |                            ;
    7 | 
    8 | }
      | ~                           
a.cc: In function 'int main()':
a.cc:17:14: error: 'max' cannot be used as a function
   17 |     max = max(distance(a,b), max)
      |           ~~~^~~~~~~~~~~~~~~~~~~~
Language: C++

#include <bits/stdc++.h>
 
using namespace std;
 
struct coord {
	double x;
	double y;
};

bool added;

void Add(vector < coord > &inter, coord a, coord b, double r) {
	double d = hypot(a.x - b.x, a.y - b.y);
	if (d - 2 * r > 0.0000000001) return;
	double h = sqrt(r * r - (d / 2) * (d / 2));
	if (fabs(h) < 0.0000000001) {
		inter.push_back({(a.x + b.x) / 2.0, (a.y + b.y) / 2.0});
		added = 1;
		return;
	}
	double mx = (a.x + b.x) / 2.0;
	double my = (a.y + b.y) / 2.0;
	if (fabs(a.x - b.x) < 0.0000000001) {
		double j = 0.0;
		double i = sqrt(h);
		inter.push_back({mx + i, my + j});
		inter.push_back({mx - i, my - j});
		added = 1
		
	} else {
		double g = (b.y - a.y) / (b.x - a.x);
		double j = sqrt(h * h / (1 + g * g));
		double i = -j * g;
		inter.push_back({mx + i, my + j});
		inter.push_back({mx - i, my - j});
		added = 1;
	}
}
 
int main() {
	ios::sync_with_stdio(false);
	int n;
	cin>>n;
	vector < coord > v(n);
	for (int i = 0; i < n; i++)
		cin>>v[i].x>>v[i].y;
		
	double leftr = 0.0, rightr = 1000000.0, midr;
	while (rightr - leftr > 0.0000000001) {
		midr = (leftr + rightr) / 2.0;
		double R = midr;
		vector < coord > inter;
		added = 0;
		for (int i = 0; i < n; i++)
		for (int j = i + 1; j < n; j++)
			Add(inter, v[i], v[j], R);
		
		/*cout<<setprecision(10)<<"R = "<<R<<"; inter:\n";
		for (int i = 0; i < inter.size(); i++)
			cout<<setprecision(10)<<inter[i].x<<" "<<setprecision(10)<<inter[i].y<<endl;
		cout<<"inter end\n";*/
		
		//bool equal = false;
		bool f = false;
		if (added)
		for (int i = 0; i < inter.size(); i++) {
			bool curr = true;
			for (int j = 0; j < n && curr; j++) {
				if (hypot(inter[i].x - v[j].x, inter[i].y- v[j].y) - R > 0.0000000001) {
					curr = false;
					continue;	
				}
				//if (fabs(hypot(inter[i].x - v[j].x, inter[i].y - v[j].y) - R) < 0.0000001)
				//	equal == true;
			}
			if (curr) {
				f = true;
				break;
			}
		}
		if (inter.size() == 0) f = false;
		if (f == false) leftr = R; else rightr = R;
	}
	printf("%0.10lf\n", leftr);
}

Compiler output:
a.cc: In function 'void Add(std::vector<coord>&, coord, coord, double)':
a.cc:28:26: error: expected ';' before '}' token
   28 |                 added = 1
      |                          ^
      |                          ;
   29 | 
   30 |         } else {
      |         ~
Language: C++

#include<bits/stdc++.h>

using namespace std;

int main(void) {
    long n;
    cin >> n;
    
    constexpr double eps = 1e-11;

    using P = pair<double,double>;

    vector<P> xy(n);
    for(auto &t: xy) cin >> t.first >> t.second;

    auto dis = [&] (P &p1, P &p2) {
        return sqrt(pow(p1.first - p2.first, 2) + pow(p1.second - p2.second, 2));
    };
    
    double r = 1e9;

    for(int i=0; i<n; i++)
        for(int j=i+1; j<n; j++)
            for(int k=j+1; k<n; k++) {
                P pa = xy[i], pb = xy[j], pc = xy[k];
                double a = dis(pb, pc), b = dis(pc, pa), c = dis(pa, pb);

                P pu = {
                    (a*a)*(b*b+c*c-a*a)*pa.first + (b*b)*(c*c+a*a-b*b)*pb.first + (c*c)*(a*a+b*b-c*c)*pc.first / ((a*a)*(b*b+c*c-a*a) + (b*b)*(c*c+a*a-b*b) + (c*c)*(a*a+b*b-c*c)),
                    (a*a)*(b*b+c*c-a*a)*pa.second + (b*b)*(c*c+a*a-b*b)*pb.second + (c*c)*(a*a+b*b-c*c)*pc.second / ((a*a)*(b*b+c*c-a*a) + (b*b)*(c*c+a*a-b*b) + (c*c)*(a*a+b*b-c*c)),
                };

                double d = max(dis(pa, pu), max(dis(pb, pu), dis(pc, pu));

                for(int l=0; l<n; l++) {
                    if(dis(xy[l], pu) > d+eps)
                        goto bad;
                }

                r = min(d, r);
bad:
                continue;
            }

    for(int i=0; i<n; i++)
        for(int j=i+1; j<n; j++) {
            P pa = xy[i], pb = xy[j];
            P pu = {
                (pa.first + pb.first)/2,
                (pa.second + pb.second)/2,
            };

            double d = max(dis(pa, pu), dis(pb, pu));

            for(int l=0; l<n; l++) {
                if(dis(xy[l], pu) > d+eps)
                    goto bad2;
            }

            r = min(d, r);
bad2:
            continue;
        }

    cout << setprecision(16) << r << endl;

}


Compiler output:
a.cc: In function 'int main()':
a.cc:33:74: error: expected ')' before ';' token
   33 |                 double d = max(dis(pa, pu), max(dis(pb, pu), dis(pc, pu));
      |                               ~                                          ^
      |                                                                          )
Language: C++

#include <cstdio>
#include <cmath>
int n;
double x[1005], y[1005], X, Y, d, e;
double dist(double a, double b) {
	return a*a + b*b;
}
int main() {
	scanf("%d", &n);
	for (int i = 0; i < n; i++) {
		scanf("%lf%lf", &x[i], &y[i]);
		X += x[i]; Y += y[i];
	}
	X /= n; Y /= n;
	double P = 0.1;
	for (int i = 0; i < 30000; i++) {
		int f = 0;
		d = dist(X - x[0], Y - y[0]);
		for (int j = 1; j < n; j++) {
			e = dist(X - x[j], Y - y[j]);
			if (d < e) { d = e; f = j; }
		}
		X += (x[f] - X)*P;
		Y += (y[f] - Y)*P;
		P *= 0.999;
	}
  	cout<<fixed<<setprecision(10)<<sqrtl(d)<<endl;
}

Compiler output:
a.cc: In function 'int main()':
a.cc:27:9: error: 'cout' was not declared in this scope
   27 |         cout<<fixed<<setprecision(10)<<sqrtl(d)<<endl;
      |         ^~~~
a.cc:27:15: error: 'fixed' was not declared in this scope
   27 |         cout<<fixed<<setprecision(10)<<sqrtl(d)<<endl;
      |               ^~~~~
a.cc:27:22: error: 'setprecision' was not declared in this scope
   27 |         cout<<fixed<<setprecision(10)<<sqrtl(d)<<endl;
      |                      ^~~~~~~~~~~~
a.cc:27:50: error: 'endl' was not declared in this scope
   27 |         cout<<fixed<<setprecision(10)<<sqrtl(d)<<endl;
      |                                                  ^~~~
Language: C++

#include<bits/stdc++.h>
int n;
double x[1<<10],y[1<<10],X,Y,d,e,i,j,P=0.1,f;
int main(){
	auto dist=[](double a,double b){return a*a+b*b;};
	scanf("%d",&n);
	for(i=0;i<n;i++){
		scanf("%lf%lf",&x[i],&y[i]);
		X+=x[i];Y+=y[i];
	}
	X/=n;Y/=n;
	for(i=0;i<30000;i++){
		f=0;
		d=dist(X-x[0],Y-y[0]);
		for(j=1;j<n;j++){
			e=dist(X-x[j],Y-y[j]);
			if(d<e)d=e,f=j;
		}
		X+=(x[f]-X)*P;
		Y+=(y[f]-Y)*P;
		P*=0.999;
	}
	printf("%.10lf",sqrt(d));
}


Compiler output:
a.cc: In function 'int main()':
a.cc:8:34: error: invalid types 'double [1024][double]' for array subscript
    8 |                 scanf("%lf%lf",&x[i],&y[i]);
      |                                  ^
a.cc:8:40: error: invalid types 'double [1024][double]' for array subscript
    8 |                 scanf("%lf%lf",&x[i],&y[i]);
      |                                        ^
a.cc:9:21: error: invalid types 'double [1024][double]' for array subscript
    9 |                 X+=x[i];Y+=y[i];
      |                     ^
a.cc:9:29: error: invalid types 'double [1024][double]' for array subscript
    9 |                 X+=x[i];Y+=y[i];
      |                             ^
a.cc:16:35: error: invalid types 'double [1024][double]' for array subscript
   16 |                         e=dist(X-x[j],Y-y[j]);
      |                                   ^
a.cc:16:42: error: invalid types 'double [1024][double]' for array subscript
   16 |                         e=dist(X-x[j],Y-y[j]);
      |                                          ^
a.cc:19:22: error: invalid types 'double [1024][double]' for array subscript
   19 |                 X+=(x[f]-X)*P;
      |                      ^
a.cc:20:22: error: invalid types 'double [1024][double]' for array subscript
   20 |                 Y+=(y[f]-Y)*P;
      |                      ^
Language: C++

//#include "pch.h"
#include <iostream>
#include <algorithm>
#include <map>
#include <set>
#include <queue>
#include <bitset>
#include <limits.h>
#include <string>
#include <deque>
#include <cmath>
#include <bitset>
#include <complex>
#include <time.h>
#include <stdio.h>

using namespace std;
typedef long long ll;
typedef pair<double, double> P;

#define rip(i, n, s) for (int i = (s);i < (int)( n ); i++)
#define mpa make_pair
#define all(a) a.begin(), a.end()

template<typename T>
void vdeb(vector<T> &da) {
	int size = da.size();
	for (int i = 0;i < size;i++) {
		if (i == size - 1) {
			cout << da[i] << endl;
		}
		else {
			cout << da[i] << ' ';
		}
	}
}
template<typename T>
void vvdeb(vector<T> &da) {
	int size = da.size();
	for (int i = 0;i < size;i++) {
		vdeb(da[i]);
	}
}

using namespace std;

struct complex_triangle{
    complex<double> a,b,c;

    complex_triangle(complex<double> &_a, complex<double> &_b, complex<double> &_c){
        a = _a;b = _b;c = _c;
    }
    
    double edge_lenth(int x){ //x= 0->bc, 1->ca, 2->ab  
        if(x==0) return abs(b-c);
        else if(x==1) return abs(c-a);
        else if(x==2) return abs(a-b);
    }

    double area(){ //面積
        complex<double> A = b - c, B = c - a;
        return abs(A.real()*B.imag() - A.imag()*B.real())/2;
    }

    double o_radi(){ //外接円の半径
        double ret = 1;
        for(int i=0;i<3;i++) ret *= edge_lenth(i);
        return ret/(4*area());
    }

    complex<double> o_cent(){ //外心
        complex<double> B = b - a, C = c - a,ret;
        double ss = (B.real()*C.imag() - B.imag()*C.real())*2;
        ret.real((C.imag()*norm(B) - B.imag()*norm(C))/ss);
        ret.imag((B.real()*norm(C) - C.real()*norm(B))/ss);
        ret += a;
        return ret;
    }

    complex<double> g_cent(){ //重心
        return (a+b+c)/3.0;
    }
};


int n;

bool checker(complex<double> cen, double orb, vector<complex<double>> &da){
	rip(i,n,0){
		if(abs(cen - da[i]) > orb){
			return false;
		}
	}
	return true;
}

int main(){
	cin >> n;
	vector<complex<double>> da(n);
	rip(i,n,0){
		double real, imag;
		cin >> real >> imag;
		da[i].real(real);da[i].imag(imag);
	}
	double ans = 1000000;
	rip(i,n-2,0){
		rip(j,n-1,i){
			rip(k, n, j){
				complex_triangle now(da[i], da[j], da[k]);
				if(now.area()){
					double cand = now.o_radi();
					if(checker(now.o_cent(), cand, da)){
						ans = min(ans, cand);
					}
				}
			}
		}
	}
	rip(i,n-1,0){
		rip(j,n,i){
			double cand = abs(da[i]-da[j])/2;
			if(checker((da[i]+da[j])/2.0, cand, da)){
				ans = min(ans, cand);
			}
		}
	}printf("%.07f\n",ans)
}




Compiler output:
a.cc: In function 'int main()':
a.cc:126:31: error: expected ';' before '}' token
  126 |         }printf("%.07f\n",ans)
      |                               ^
      |                               ;
  127 | }
      | ~                              
a.cc: In member function 'double complex_triangle::edge_lenth(int)':
a.cc:58:5: warning: control reaches end of non-void function [-Wreturn-type]
   58 |     }
      |     ^
Language: C++

#include <bits/stdc++.h>

using namespace std;

int n;
pair<int, int> a[100];

int main(){
  scanf("%d", &n);
  double x = 0, y = 0;
  for(int i=0;i<n;++i){
    scanf("%d %d", &a[i].first, &a[i].second);
    x += a[i].first / n;
    y += a[i].second / n;
  }
  double maxd = 0;
  for(int i=0;i<n;++i){
    maxd = max(maxd, sqrt(pow(a[i].first - x, 2) + pow(a[i].second - y, 2));
  }
  printf("%.9lf\n", maxd);
  return 0;
}

Compiler output:
a.cc: In function 'int main()':
a.cc:18:76: error: expected ')' before ';' token
   18 |     maxd = max(maxd, sqrt(pow(a[i].first - x, 2) + pow(a[i].second - y, 2));
      |               ~                                                            ^
      |                                                                            )
Language: C++

#include<bits/stdc++.h
using namespace std;
int main()
{
  int n;
  cin>>n;
  double avg[2];
  avg[0]=0;
  avg[1]=0;
  int x[n],y[n],t;
  t=n;
  for(int i=0;i<n;i++)
  {
    cin>>x[i]>>y[i];
    avg[0]+=x;
    avg[1]+=y;
  }
  avg[0]/=(t*1.0);
  avg[1]/=(t*1.0);double max=0;
  for(int i=0;i<n;i++)
  {
    double r=sqrt(pow((avg[0]-x[i]),2)+pow((avg[1]-y[i]),2);
    if(r<max)
                  max=r;
                  }
                  cout<<max;
                  return 0;
                  }
  

Compiler output:
a.cc:1:23: error: missing terminating > character
    1 | #include<bits/stdc++.h
      |                       ^
a.cc: In function 'int main()':
a.cc:15:11: error: invalid operands of types 'double' and 'int*' to binary 'operator+'
   15 |     avg[0]+=x;
      |     ~~~~~~^~~
a.cc:15:11: note:   in evaluation of 'operator+=(double, int*)'
a.cc:16:11: error: invalid operands of types 'double' and 'int*' to binary 'operator+'
   16 |     avg[1]+=y;
      |     ~~~~~~^~~
a.cc:16:11: note:   in evaluation of 'operator+=(double, int*)'
a.cc:22:60: error: expected ')' before ';' token
   22 |     double r=sqrt(pow((avg[0]-x[i]),2)+pow((avg[1]-y[i]),2);
      |                  ~                                         ^
      |                                                            )
Language: C++

// C++ program to find minimum radius  
// such that atleast k point lie inside 
// the circle 
#include<bits/stdc++.h> 
using namespace std; 
  
// Return minumum distance required so that 
// aleast k point lie inside the circle. 
int minRadius(int k, int x[], int y[], int n) 
{ 
   int dis[n]; 
      
   // Finding distance between of each 
   // point from origin 
   for (int i = 0; i < n; i++) 
       dis[i] = x[i] * x[i] + y[i] * y[i]; 
      
    // Sorting the distance 
    sort(dis, dis + n); 
      
    return dis[k - 1]; 
} 
  
// Driven Program 
int main() 
{ 
  long long n;
  cin >> n;
  vector<long long> x(n);
  vector<long long> y(n);
  for(int i = 0; i < n; ++i){
   	cin >> x[i] >> y[i]; 
  }
  int tmp = sizeof(x)/sizeof(x[0]); 
      
  cout << minRadius(n, x, y, tmp) << endl; 
      
  return 0; 
} 

Compiler output:
a.cc: In function 'int main()':
a.cc:36:24: error: cannot convert 'std::vector<long long int>' to 'int*'
   36 |   cout << minRadius(n, x, y, tmp) << endl;
      |                        ^
      |                        |
      |                        std::vector<long long int>
a.cc:9:26: note:   initializing argument 2 of 'int minRadius(int, int*, int*, int)'
    9 | int minRadius(int k, int x[], int y[], int n)
      |                      ~~~~^~~
Language: C++

#include <cassert>
#include <iomanip>
#include <iostream>
#include <vector>
#include "2d.hpp"

// 外心
// https://ja.wikipedia.org/wiki/%E5%A4%96%E6%8E%A5%E5%86%86
Vector2 Circumcenter(Vector2 a, Vector2 b, Vector2 c) {
  using T = Vector2::value_type;
  T ab2 = Dot(b - a, b - a), bc2 = Dot(c - b, c - b), ca2 = Dot(a - c, a - c);
  T x = bc2 * (ca2 + ab2 - bc2), y = ca2 * (ab2 + bc2 - ca2), z = ab2 * (bc2 + ca2 - ab2);
  return (x * a + y * b + z * c) / (x + y + z);
}

// test
// https://atcoder.jp/contests/abc151/tasks/abc151_f
int main() {
  int n;
  std::cin >> n;
  std::vector<Vector2> v(n);
  for (auto &e : v) {
    int x, y;
    std::cin >> x >> y;
    e.real(x);
    e.imag(y);
  }

  double r = 1e9;
  for (int i = 0; i < n; i++) {
    for (int j = i + 1; j < n; j++) {
      {
        auto p = (v[i] + v[j]) / 2.0;
        double t = 0;
        for (auto e : v) t = std::max(t, std::abs(e - p));
        r = std::min(r, t);
      }
      for (int k = j + 1; k < n; k++) {
        if (EQ(Cross(v[j] - v[i], v[k] - v[i]), 0.0)) continue;
        auto p = Circumcenter(v[i], v[j], v[k]);
        double t = 0;
        for (auto e : v) t = std::max(t, std::abs(e - p));
        r = std::min(r, t);
      }
    }
  }
  std::cout << std::fixed << std::setprecision(7);
  std::cout << r << std::endl;
}


Compiler output:
a.cc:5:10: fatal error: 2d.hpp: No such file or directory
    5 | #include "2d.hpp"
      |          ^~~~~~~~
compilation terminated.
Language: Java

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.Scanner;

public class Enclose_All_151F {
    public static void main(String[] args) {
        Scanner in = new Scanner(new BufferedReader(new InputStreamReader(System.in)));
        int n = in.nextInt(); // Scanner has functions to read ints, longs, strings, chars, etc.

        int[][] arr = new int[n][2];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < 2; j++) {
                arr[i][j] = in.nextInt();
            }
        }
        System.out.println(getMinR(arr));
    }

    private static double getMinR(int[][] arr) {
        double max = 0;
        for (int i = 0; i < arr.length; i++) {
            for (int j = i + 1; j < arr.length; j++) {
                max = Math.max(max, getDist(arr[i], arr[j]));
            }
        }
        return max / 2;
    }

    private static double getDist(int[] p1, int[] p2) {
        return Math.sqrt((p1[0] - p2[0]) * (p1[0] - p2[0]) + (p1[1] - p2[1]) * (p1[1] - p2[1]));
    }
}


Compiler output:
Main.java:5: error: class Enclose_All_151F is public, should be declared in a file named Enclose_All_151F.java
public class Enclose_All_151F {
       ^
1 error
Language: C++

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define For(i,n,k) for(ll i=(n);i<(k);i++)
#define ALL(a)  (a).begin(),(a).end()
ll ans=0;
double dist(double x,double y,double a,double b){
    return sqrt((x-a)*(x-a)+(y-b)*(y-b));
}
void Main(){
    ll n;cin>>n;
    vector<double> x(n),y(n);
    For(i,0,n) cin>>x[i]>>y[i];
    double xmin=10000,xmax=-10000,ymin=10000,ymax=-10000;
    For(i,0,n){
        xmin=min(xmin,x[i]);
        xmax=max(xmax,x[i]);
        ymin=min(ymin,y[i]);
        ymax=max(ymax,y[i]);
    }
    double xdist=(xmax-xmin)/500,ydist=(ymax-ymin)/500;
    vector<pair<double,pair<double,double>>> plot;
    For(i,0,500){
        For(j,0,500){
            double X=xmin+i*xdist;
            double Y=ymin+j*ydist;
            double R=0;
            For(k,0,n){
                R=max(R,dist(X,Y,x[k],y[k]));
            }
            plot.push_back(make_pair(R,make_pair(X,Y)));
        }
    }
    sort(ALL(plot));
    int count=0;
    random_device seed_gen;
    mt19937 engine(seed_gen());
    uniform_real_distribution<> dist(-0.001, 0.001);
    count=0;
    while(true){
        count++;
        double X=0,Y=0;
        For(i,0,1){
            X+=plot[i].second.first;
            Y+=plot[i].second.second;
        }
        X+=dist(engine);
        Y+=dist(engine);
        double R=0;
        For(k,0,n) R=max(R,dist(X,Y,x[k],y[k]));
        double D=plot[0].first-R;
        if(D>0) plot[0]=make_pair(R,make_pair(X,Y));
        if(count>1000000) break;
    }
    cout<<fixed<<setprecision(16)<<plot[0].first<<endl;
}
int main(){
    Main();
    return 0;
}


Compiler output:
a.cc: In function 'void Main()':
a.cc:50:32: error: no match for call to '(std::uniform_real_distribution<>) (double&, double&, __gnu_cxx::__alloc_traits<std::allocator<double>, double>::value_type&, __gnu_cxx::__alloc_traits<std::allocator<double>, double>::value_type&)'
   50 |         For(k,0,n) R=max(R,dist(X,Y,x[k],y[k]));
      |                            ~~~~^~~~~~~~~~~~~~~
In file included from /usr/include/c++/14/random:48,
                 from /usr/include/x86_64-linux-gnu/c++/14/bits/stdc++.h:179,
                 from a.cc:1:
/usr/include/c++/14/bits/random.h:2001:9: note: candidate: 'template<class _UniformRandomNumberGenerator> std::uniform_real_distribution<_RealType>::result_type std::uniform_real_distribution<_RealType>::operator()(_UniformRandomNumberGenerator&) [with _RealType = double]'
 2001 |         operator()(_UniformRandomNumberGenerator& __urng)
      |         ^~~~~~~~
/usr/include/c++/14/bits/random.h:2001:9: note:   candidate expects 1 argument, 4 provided
/usr/include/c++/14/bits/random.h:2006:9: note: candidate: 'template<class _UniformRandomNumberGenerator> std::uniform_real_distribution<_RealType>::result_type std::uniform_real_distribution<_RealType>::operator()(_UniformRandomNumberGenerator&, const param_type&) [with _RealType = double]'
 2006 |         operator()(_UniformRandomNumberGenerator& __urng,
      |         ^~~~~~~~
/usr/include/c++/14/bits/random.h:2006:9: note:   candidate expects 2 arguments, 4 provided
Language: C++

#include <bits/stdc++.h>
using namespace std;
typedef long long  ll;
#define FOR(i,a,n) for(ll i=(ll)a;i<(ll)n;i++)
#define RFOR(i,a,n) for(ll i=(ll)n-1;i >= (ll)a;i--)
#define rep(i,n) FOR(i,0,n)
#define rrep(i,n) RFOR(i,0,n)
#define ALL(v) v.begin(), v.end()
#define bra(x,y) '(' << x << ',' << y << ')'
ll MOD = 1000000007;
ll INF = 214748364700000000;
double EPS = 1e-7;
double PI = 3.141592653589793238;
template<typename T>
void remove(std::vector<T>& vector, unsigned int index){
    vector.erase(vector.begin() + index);
}

using Graph = vector<vector<pair<ll,ll>>>;

int main(){
   cout << setprecision(30) << fixed;
   ll N;cin >> N;
   vector<double> X(N),Y(N);
   rep(i,N) cin >> X[i] >> Y[i];
   double ans = 100000000000.0;
   if(N == 2){
      double R = sqrt((X[0]-X[1])*(X[0]-X[1]) + (Y[0]-Y[1])*(Y[0]-Y[1])) / 2;
      cout << R << endl;
      return 0; 
   }
   rep(i,N) rep(j,N) rep(k,N){
      if(i == j || j == k || i == k) continue;
      double x1 = X[i],y1 = Y[i],x2 = X[j],y2 = Y[j],x3 = X[k],y3 = Y[k],r = 0,a = 0,b = 0;
      a = (((x2*x2+y2*y2)-(x3*x3+y3*y3))/(2*y2-2*y3) - ((x1*x1+y1*y1)-(x2*x2+y2*y2))/(2*y1-2*y2))/((x1-x2)/(y1-y2) - (x2-x3)/(y2-y3));
      b = a * (x1-x2)/(y1-y2) + ((x1*x1+y1*y1)-(x2*x2+y2*y2))/(2*y1-2*y2);
      r = sqrt((x1-a)*(x1-a)+(y1-b)*(y1-b));
      bool frag = 1;
      rep(l,N){
         //if(i == l || j == l || k == l) continue;
         if((X[l]-a)*(X[l]-a)+(Y[l]-b)*(Y[l]-b) > r * r){
            frag = 0;
         } 
      }
      if(frag) ans = min(ans,r);
   }
   rep(i,N) rep(j,N){
      if(i == j) continue;
      double x1 = X[i],y1 = Y[i],x2 = X[j],y2 = Y[j],r = 0,a = 0,b = 0;
      a = (x1 + x2)/2;b = (y1+y2)/2;
      r = sqrt((x1-a)*(x1-a)+(y1-b)*(y1-b));
      bool frag = 1;
      rep(l,N){
         if(i == l || j == l || k == l) continue;
         if((X[l]-a)*(X[l]-a)+(Y[l]-b)*(Y[l]-b) > r * r){
            frag = 0;
         } 
      }
      if(frag) ans = min(ans,r);
   }
   cout << ans << endl;
}


Compiler output:
a.cc: In function 'int main()':
a.cc:54:33: error: 'k' was not declared in this scope
   54 |          if(i == l || j == l || k == l) continue;
      |                                 ^
Language: C++

#include<iostream>
#include<vector>
#include<algorithm>
#include<string>
#include<queue>
#include<math.h>
using namespace std;
#define int long long
#define rep(i,n) for(int i=0;i<n;++i)
#define rep1(i,n) for(int i=1;i<=n;++i)
int inf=1000000007;

struct Point{
  int x;
  int y;
  int dist(Point c){
    int dx=x-c.x;
    int dy=y-c.y;
    int res=dx*dx+dy*dy;
    return res;
  };
  double dist2(double cx,double cy){
    double dx=(double)x-cx;
    double dy=(double)y-cy;
    double res=dx*dx+dy*dy;
    res=sqrt(res);
    return res;
  }
};
double rr(Point a,Point b, Point c,double& ox,double& oy){
  int n=3;
  double x1,x2,x3,y1,y2,y3,r;
  x1=a.x;x2=b.x;x3=c.x;
  y1=a.y;y2=b.y;y3=c.y;
		//scanf("%lf %lf %lf %lf %lf %lf",&x1,&y1,&x2,&y2,&x3,&y3);
		ox=((y2-y1)*((y3*y3-y1*y1)+(x3*x3-x1*x1))-(y3-y1)*((y2*y2-y1*y1)+(x2*x2-x1*x1)))/
				(2*((x3-x1)*(y2-y1)-(x2-x1)*(y3-y1)));
		if(y2 != y1){
			oy=(2*(x1-x2)*ox+(y2*y2-y1*y1)+(x2*x2-x1*x1))/(2*(y2-y1));
		}else{
			oy=(2*(x1-x3)*ox+(y3*y3-y1*y1)+(x3*x3-x1*x1))/(2*(y3-y1));
		}
		r = sqrt((ox-x1)*(ox-x1)+(oy-y1)*(oy-y1));
    return r;
}
bool judge(int i,int j,int k,double r,double ox,double oy,vector<Point>& p,int n){
  bool ans=true;
  rep(i,n){
    if(p[i].dist2(ox,oy)>r)ans=false;
    }
return ans;
}
signed main(){
  int n;cin>>n;
  vector<Point> p(n);
  double cx=0;
  double cy=0;
  rep(i,n){
    Point buf;
    cin>>buf.x>>buf.y;
    p[i]=buf;
  }
  double min=inf;
  for(int i=0;i<n;i++){
    for(int j=i+1;j<n;j++){
      for(int k=j+1;k<n;k++){
        Point buf[3];
        buf[0]=p[i];
        buf[1]=p[j];
        buf[2]=p[k];
        double ox,oy;
        double tmp=rr(buf[0],buf[1],buf[2],ox,oy,n);
        if(min>tmp&&judge(i,j,k,tmp,ox,oy,p,n))min=tmp;
      }
    }
  }
  if(n==2)min=p[0].dist(p[1].x,p[1].y)/2;
  printf("%.12lf\n",min);
  return 0;
}


Compiler output:
a.cc: In function 'int main()':
a.cc:72:22: error: too many arguments to function 'double rr(Point, Point, Point, double&, double&)'
   72 |         double tmp=rr(buf[0],buf[1],buf[2],ox,oy,n);
      |                    ~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
a.cc:30:8: note: declared here
   30 | double rr(Point a,Point b, Point c,double& ox,double& oy){
      |        ^~
a.cc:77:24: error: no matching function for call to 'Point::dist(long long int&, long long int&)'
   77 |   if(n==2)min=p[0].dist(p[1].x,p[1].y)/2;
      |               ~~~~~~~~~^~~~~~~~~~~~~~~
a.cc:16:7: note: candidate: 'long long int Point::dist(Point)'
   16 |   int dist(Point c){
      |       ^~~~
a.cc:16:7: note:   candidate expects 1 argument, 2 provided
Language: C++

template <class iter>
std::pair<P, ld> min_ball(iter left, iter right, int seed = 1333) {
    const int n = right - left;

    assert(n >= 1);
    if (n == 1) {
        return {*left, ld(0)};
    }

    std::mt19937 mt(seed);
    std::shuffle(left, right, mt);
    // std::random_shuffle(left, right); // simple but deprecated

    iter ps = left;
    using circle = std::pair<P, ld>;

    auto make_circle_3 = [](const P &a, const P &b, const P &c) -> circle {
        ld A = std::norm(b - c), B = std::norm(c - a), C = std::norm(a - b),
           S = cross(b - a, c - a);
        P p = (A * (B + C - A) * a + B * (C + A - B) * b + C * (A + B - C) * c) / (4 * S * S);
        ld r2 = std::norm(p - a);
        return {p, r2};
    };

    auto make_circle_2 = [](const P &a, const P &b) -> circle {
        P c = (a + b) / (ld)2;
        ld r2 = std::norm(a - c);
        return {c, r2};
    };

    auto in_circle = [](const P &a, const circle &c) -> bool {
        return std::norm(a - c.first) <= c.second + eps;
    };

    circle c = make_circle_2(ps[0], ps[1]);

    // MiniDisc
    for (int i = 2; i < n; ++i) {
        if (!in_circle(ps[i], c)) {
            // MiniDiscWithPoint
            c = make_circle_2(ps[0], ps[i]);
            for (int j = 1; j < i; ++j) {
                if (!in_circle(ps[j], c)) {
                    // MiniDiscWith2Points
                    c = make_circle_2(ps[i], ps[j]);
                    for (int k = 0; k < j; ++k) {
                        if (!in_circle(ps[k], c)) {
                            c = make_circle_3(ps[i], ps[j], ps[k]);
                        }
                    }
                }
            }
        }
    }
    return c;
}

Compiler output:
a.cc:2:6: error: 'pair' in namespace 'std' does not name a template type
    2 | std::pair<P, ld> min_ball(iter left, iter right, int seed = 1333) {
      |      ^~~~
a.cc:1:1: note: 'std::pair' is defined in header '<utility>'; this is probably fixable by adding '#include <utility>'
  +++ |+#include <utility>
    1 | template <class iter>
Language: C++

#include <bits/stdc++.h>
using namespace std;
//http://blog.livedoor.jp/dgd17/archives/11821338.html
inline complex<double> Circumcenter(complex<double> a, complex<double> b, complex<double> c) {

	//辺
	double eAB = abs(b - a);
	double eBC = abs(c - b);
	double eCA = abs(a - c);

	//角度(余弦定理)
	double aCAB = acos((eCA*eCA + eAB*eAB - eBC*eBC) / (2 * eCA*eAB));
	double aABC = acos((eAB*eAB + eBC*eBC - eCA*eCA) / (2 * eAB*eBC));
	double aBCA = acos((eBC*eBC + eCA*eCA - eAB*eAB) / (2 * eBC*eCA));

	double A = sin(2 * aCAB);
	double B = sin(2 * aABC);
	double C = sin(2 * aBCA);

	//外心の位置ベクトル(ベクトルの面積比の公式)
	complex<double> ans;
	ans.real((A*a.real() + B*b.real() + C*c.real()) / (A + B + C));
	ans.imag((A*a.imag() + B*b.imag() + C*c.imag()) / (A + B + C));
	return(ans);
} 

inline double Circumradius(complex<double> a, complex<double> b, complex<double> c) {

	//辺
	double eAB = abs(b - a);
	double eBC = abs(c - b);
	double eCA = abs(a - c);

	//角度(余弦定理)
	double aCAB = acos((eCA*eCA + eAB*eAB - eBC*eBC) / (2 * eCA*eAB));

	//外接円の半径(正弦定理)
	double R = 0.5*eBC / sin(aCAB);

	return(R);

}

int main(void){
  cout << fixed << setprecision(20);
  int N;
  cin >> N;
  vector<int> x(N), y(N);
  for (int i = 0; i < N; i++){
    cin >> x[i] >> y[i];
  }
  vector<complex<double>> c(N);
  for (int i = 0; i < N; i++){
    c[i].real(x[i]);
    c[i].imag(y[i]);
  }
  if (N == 2){
    cout << abs(c[0]-c[1])/2;
  } else {
    double minrad = 10000;
    for (int i = 0; i < N; i++){
      for (int j = i + 1; j < N; j++){
        for (int k = j + 1; k < N; k++){
          complex<double> cc = Circumcenter(c[i],c[j],c[k]);
          double cr = Circumradius(c[i],c[j],c[k]);
          
          cout << cc.real() << endl;
          cout << cc.imag() << endl;
          cout << cr << endl;
          if (((c[i]-c[j])/(c[i]-c[k])).imag() < 1e-7){
            cr = max((abs(c[i]-c[j]))/2,(abs(c[j]-c[k]))/2,(abs(c[k]-c[i]))/2);
          }
          if (cr < minrad){
            bool flg = true;
            for (int n = 0; n < N; n++){
              if (abs(cc - c[n]) > cr + 1e-7) flg = false;
            }
            if (flg) minrad = cr;
          }
        }
      }
    }
    cout << minrad;
  }
}

Compiler output:
In file included from /usr/include/c++/14/algorithm:60,
                 from /usr/include/x86_64-linux-gnu/c++/14/bits/stdc++.h:51,
                 from a.cc:1:
/usr/include/c++/14/bits/stl_algobase.h: In instantiation of 'constexpr const _Tp& std::max(const _Tp&, const _Tp&, _Compare) [with _Tp = double; _Compare = double]':
a.cc:71:21:   required from here
   71 |             cr = max((abs(c[i]-c[j]))/2,(abs(c[j]-c[k]))/2,(abs(c[k]-c[i]))/2);
      |                  ~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_algobase.h:306:17: error: '__comp' cannot be used as a function
  306 |       if (__comp(__a, __b))
      |           ~~~~~~^~~~~~~~~~
Language: C++

#define pb push_back
#define ff first
#define ss second
#define ll long long
#define maxn 100005
#define mod 1000000007
#include <bits/stdc++.h>
using namespace std;

vector< pair< ll , ll > > v;
ll dist(ll x1, ll y1, ll x2, ll ly2){
    ll res = (x1-x2) * (x1-x2);
    res += (y1-y2) * (y1-y2);
    return res;
}

int main() {
    ll x, y, mx;
    mx = 0;
    int n;
    cin >> n;
    for(int i=0;i<n;i++){
        cin >> x >> y;
        v.pb({x, y});
    }
    for(int i=0;i<n;i++){
        for(int j=0;j<n;j++){
            auto p1 = v[i];
            auto p2 = v[j];
            double dis = dist(p1.ff, p1.ss, p2.ff, p2.ss);
            mx = max(mx, dis);
        }
    }
    double res;
    res = sqrt(mx);
    res = res / (double)2.0;
    printf("%.20lf\n", res);
    //cout << setprecision(10) << mx << endl;
    return 0;
}


Compiler output:
a.cc: In function 'long long int dist(long long int, long long int, long long int, long long int)':
a.cc:13:16: error: 'y2' was not declared in this scope; did you mean 'y1'?
   13 |     res += (y1-y2) * (y1-y2);
      |                ^~
      |                y1
a.cc: In function 'int main()':
a.cc:31:21: error: no matching function for call to 'max(long long int&, double&)'
   31 |             mx = max(mx, dis);
      |                  ~~~^~~~~~~~~
In file included from /usr/include/c++/14/algorithm:60,
                 from /usr/include/x86_64-linux-gnu/c++/14/bits/stdc++.h:51,
                 from a.cc:7:
/usr/include/c++/14/bits/stl_algobase.h:257:5: note: candidate: 'template<class _Tp> constexpr const _Tp& std::max(const _Tp&, const _Tp&)'
  257 |     max(const _Tp& __a, const _Tp& __b)
      |     ^~~
/usr/include/c++/14/bits/stl_algobase.h:257:5: note:   template argument deduction/substitution failed:
a.cc:31:21: note:   deduced conflicting types for parameter 'const _Tp' ('long long int' and 'double')
   31 |             mx = max(mx, dis);
      |                  ~~~^~~~~~~~~
/usr/include/c++/14/bits/stl_algobase.h:303:5: note: candidate: 'template<class _Tp, class _Compare> constexpr const _Tp& std::max(const _Tp&, const _Tp&, _Compare)'
  303 |     max(const _Tp& __a, const _Tp& __b, _Compare __comp)
      |     ^~~
/usr/include/c++/14/bits/stl_algobase.h:303:5: note:   candidate expects 3 arguments, 2 provided
In file included from /usr/include/c++/14/algorithm:61:
/usr/include/c++/14/bits/stl_algo.h:5706:5: note: candidate: 'template<class _Tp> constexpr _Tp std::max(initializer_list<_Tp>)'
 5706 |     max(initializer_list<_Tp> __l)
      |     ^~~
/usr/include/c++/14/bits/stl_algo.h:5706:5: note:   candidate expects 1 argument, 2 provided
/usr/include/c++/14/bits/stl_algo.h:5716:5: note: candidate: 'template<class _Tp, class _Compare> constexpr _Tp std::max(initializer_list<_Tp>, _Compare)'
 5716 |     max(initializer_list<_Tp> __l, _Compare __comp)
      |     ^~~
/usr/include/c++/14/bits/stl_algo.h:5716:5: note:   template argument deduction/substitution failed:
a.cc:31:21: note:   mismatched types 'std::initializer_list<_Tp>' and 'long long int'
   31 |             mx = max(mx, dis);
      |                  ~~~^~~~~~~~~
Language: C++

#include <bits/stdc++.h>
using namespace std;
//http://blog.livedoor.jp/dgd17/archives/11821338.html
inline complex<double> Circumcenter(complex<double> a, complex<double> b, complex<double> c) {

	//辺
	double eAB = abs(b - a);
	double eBC = abs(c - b);
	double eCA = abs(a - c);

	//角度(余弦定理)
	double aCAB = acos((eCA*eCA + eAB*eAB - eBC*eBC) / (2 * eCA*eAB));
	double aABC = acos((eAB*eAB + eBC*eBC - eCA*eCA) / (2 * eAB*eBC));
	double aBCA = acos((eBC*eBC + eCA*eCA - eAB*eAB) / (2 * eBC*eCA));

	double A = sin(2 * aCAB);
	double B = sin(2 * aABC);
	double C = sin(2 * aBCA);

	//外心の位置ベクトル(ベクトルの面積比の公式)
	complex<double> ans;
	ans.real((A*a.real() + B*b.real() + C*c.real()) / (A + B + C));
	ans.imag((A*a.imag() + B*b.imag() + C*c.imag()) / (A + B + C));
	return(ans);
} 

inline double Circumradius(complex<double> a, complex<double> b, complex<double> c) {

	//辺
	double eAB = abs(b - a);
	double eBC = abs(c - b);
	double eCA = abs(a - c);

	//角度(余弦定理)
	double aCAB = acos((eCA*eCA + eAB*eAB - eBC*eBC) / (2 * eCA*eAB));

	//外接円の半径(正弦定理)
	double R = 0.5*eBC / sin(aCAB);

	return(R);

}

int main(void){
  cout << fixed << setprecision(20);
  int N;
  cin >> N;
  vector<int> x(N), y(N);
  for (int i = 0; i < N; i++){
    cin >> x[i] >> y[i];
  }
  vector<complex<double>> c(N);
  for (int i = 0; i < N; i++){
    c[i].real(x[i]);
    c[i].imag(y[i]);
  }
  if (N == 2){
    cout << abs(c[0]-c[1])/2;
  } else {
    double minrad = 10000;
    for (int i = 0; i < N; i++){
      for (int j = i + 1; j < N; j++){
        for (int k = j + 1; k < N; k++){
          complex<double> cc = Circumcenter(c[i],c[j],c[k]);
          double cr = Circumradius(c[i],c[j],c[k]);
          
          cout << cc.real() << endl;
          cout << cc.imag() << endl;
          cout << cr << endl;
          if (((c[i]-c[j])/(c[i]-c[k])).imag < 1e-7){
            cr = (abs(c[i]-c[j]))/2;
          }
          if (cr < minrad){
            bool flg = true;
            for (int n = 0; n < N; n++){
              if (abs(cc - c[n]) > cr + 1e-7) flg = false;
            }
            if (flg) minrad = cr;
          }
        }
      }
    }
    cout << minrad;
  }
}

Compiler output:
a.cc: In function 'int main()':
a.cc:70:46: error: invalid operands of types '<unresolved overloaded function type>' and 'double' to binary 'operator<'
   70 |           if (((c[i]-c[j])/(c[i]-c[k])).imag < 1e-7){
      |               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ^ ~~~~
      |                                         |      |
      |                                         |      double
      |                                         <unresolved overloaded function type>
Language: C++

#include <bits/stdc++.h>

using namespace std;

int n;
int calcCircleOf2Point(int x1, int y1, int x2, int y2, int x3, int y3, double *cx, double *cy, double *r)
{
	double 	ox, oy, a, b, c, d ;
	double 	r1, r2, r3 ;
	int		stat ;

	a = x2 - x1 ;
	b = y2 - y1 ;
	c = x3 - x1 ;
	d = y3 - y1 ;

	stat = -1 ;

	if  ((a && d) || (b && c)) {
		ox = x1 + (d * (a * a + b * b) - b * (c * c + d * d)) / (a * d - b * c) / 2 ;
		if  (b) {
			oy = (a * (x1 + x2 - ox - ox) + b * (y1 + y2)) / b / 2 ;
		} else {
			oy = (c * (x1 + x3 - ox - ox) + d * (y1 + y3)) / d / 2 ;
		}
		r1   = sqrt((ox - x1) * (ox - x1) + (oy - y1) * (oy - y1)) ;
		r2   = sqrt((ox - x2) * (ox - x2) + (oy - y2) * (oy - y2)) ;
		r3   = sqrt((ox - x3) * (ox - x3) + (oy - y3) * (oy - y3)) ;
		*cx = ox ;
		*cy = oy ;
		*r  = (r1 + r2 + r3) / 3 ;
		stat = 0 ;
	}

	return stat ;
}
void solve(){
    int i,j;
    string str;
    cin >> n;
    vector<int> x(n),y(n);
    for(i = 0;i < n;i++) cin >> x[i] >> y[i];
    double ans = 99999;
    for(i = 0;i < n;i++){
        for(j = i+1;j < n;j++){
            double cx,cy,r;
            cx = x[i]+x[j];
            cy = y[i]+y[j];
            cx /= 2; cy /= 2;
            r = sqrt(pow(abs(x[i]-x[j]),2)+pow(abs(y[i]-y[j]),2));
            for(k = 0;k < n;k++){
                if(k == i || k == j) continue;
                if(r < sqrt(pow(abs(x[k]-cx),2)+pow(abs(y[k]-cy)))){
                    calcCircleOf2Point(x[i],y[i],x[j],y[j],x[k],y[k],&cx,&cy,&r);
                }
            }
            if(r < ans) ans = r;
        }
    }
    cout << ans << endl;
}

int main(){
    solve();
}


Compiler output:
a.cc: In function 'void solve()':
a.cc:51:17: error: 'k' was not declared in this scope
   51 |             for(k = 0;k < n;k++){
      |                 ^
Language: C++

while (true){
		long double ang = 0, minn = 9999999999;
		int dir;
		for (int i = 0; i < 8; i++){
			long double d = rad(cx + 0.000000000000000001 * dx[i], cy + 0.000000000000000001 * dy[i]);
			if (d < minn){
				minn = d;
				dir = i;
			}
		}
		cx += 0.000000000000000001 * dx[dir];
		cy += 0.000000000000000001 * dy[dir];
		if (now <= minn){
			break;
		}
		now = minn;
	}

Compiler output:
a.cc:1:1: error: expected unqualified-id before 'while'
    1 | while (true){
      | ^~~~~
Language: C++

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

int main(){
    int n;
    cin >> n;
    vector<int> x(n);
    vector<int> y(n);
    int p = 0;
    int q = 0;
    for (int i = 0; i < n; i++) cin >> x[i] >> y[i];
    double ans = 0;
    for (int i = 0; i < n; i++){
        for (int j = 0; j < n; j++){
            double tmp = max(ans, sqrt(abs(x[i] - x[j]) * abs(x[i] - x[j]) + abs(y[i] - y[j]) * abs(y[i] - y[j])));
            if (tmp > ans){
                ans = tmp;
                p = (x[i] - x[j]) / 2;
                q = (y[i] - y[j]) / 2;
            }
    }
    for (int i = 0; i < n; i++){
        ans = max(ans, sqrt(abs(x[i] - p) * abs(x[i] - p) + abs(y[i] - q) * abs(y[i] - q)));
    }
    cout << setprecision(15) << ans / 2 << endl;
}

Compiler output:
a.cc: In function 'int main()':
a.cc:26:2: error: expected '}' at end of input
   26 | }
      |  ^
a.cc:4:11: note: to match this '{'
    4 | int main(){
      |           ^