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

#include "stdafx.h"
#include <iostream>
#include <iomanip>
#include <math.h>

using namespace std;

int main(){
	int cnt;
	cin >> cnt;
	double x1, y1, x2, y2, x3, y3;
	double a1, a2, b1, b2, c1, c2;
	double a, b, c;
	double A;
	double xp, yp, r;
	while (cnt > 0 && cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3) {
		// ?????\??????????????§?¨?????±???????
		a1 = 2 * (x2 - x1);
		b1 = 2 * (y2 - y1);
		c1 = x1 * x1 - x2 * x2 + y1 * y1 - y2 * y2;
		a2 = 2 * (x3 - x1);
		b2 = 2 * (y3 - y1);
		c2 = x1 * x1 - x3 * x3 + y1 * y1 - y3 * y3;
		xp = (double)((b1*c2 - b2*c1) / (a1*b2 - a2*b1) * 1000) / 1000.0;
		yp = (double)((c1*a2 - c2*a1) / (a1*b2 - a2*b1) * 1000) / 1000.0;

		// ?????\????????????????±???????
		r = hypot(xp - x1, yp - y1);

		cout << fixed << setprecision(3);
		cout << xp << " " << yp << " " << r << endl;
		cnt -= 1;
	}
	return 0;
}

Compiler output:
a.cc:1:10: fatal error: stdafx.h: No such file or directory
    1 | #include "stdafx.h"
      |          ^~~~~~~~~~
compilation terminated.
Language: C++

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

double marume( double x ){
	long long t = x * 1000 + 0.5;
	return t/1000.0;
}

int main(){
	int n;
	double tx, ty, x1, y1, x2, y2;
	
	cin >> n;
	while(n--){
		cin >> tx >> ty >> x1 >> y1 >> x2 >> y2;
		x1 -= tx; y1 -= ty;
		x2 -= tx; y2 -= ty;
		
		double dist1 = x1 * x1 + y1 * y1;
		double dist2 = x2 * x2 + y2 * y2;
		x1 *= 2; y1 *= 2;
		y1 *= 2; y2 *= 2;
		
		double detA = x1 * y2 - x2 * y1;
		double detX = dist1 * y2 - y1 * dist2;
		double detY = x1 * dist2 - dist1 * x1;
		double x = detX / detA;
		double y = detY / detA;
		double r = hypot(x, y);
		
		x = marume(x);
		y = marume(y);
		r = marume(r);
		printf("%.3f %.3f %.3f\n", x, y, r);
	}
	return 0;
}

Compiler output:
a.cc: In function 'int main()':
a.cc:30:28: error: 'hypot' was not declared in this scope
   30 |                 double r = hypot(x, y);
      |                            ^~~~~
Language: C++

#include<iostream>
#include<string>
#include <iomanip>
using namespace std;
int main() {
	int n;
	cin >> n;
	float x1, y1, x2, y2, x3, y3;
	cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;

	float px, py, r;
	float A1, B1, C1, A2, B2, C2;
	A1 = 2 * (x2 - y2);
	B1 = 2*(y2 - y1);
	C1 = x1*x1 - x2*x2 + y1*y1 - y2*y2;
	A2 = 2 * (x3 - x1);
	B2 = 2 * (y3 - y1);
	C2 = x1*x1 - x3*x3 + y1*y1 - y3*y3;
	
	px = (B1*C2 - B2*C1) / (A1*B2 - A2*B1);
	py = (C1*A2 - C2*A1) / (A1*B2 - A2*B1);

	r = sqrt((x1-px)*(x1-px)+(y1-py)*(y1-py));

	px = round(px * 1000) / 1000;
	py = round(py * 1000) / 1000;
	r = round(r * 1000) / 1000;
	cout <<fixed << setprecision(4) << px << " ";
	cout << fixed << setprecision(4) << py << " ";
	cout<< fixed << setprecision(4) << r << endl;

	return 0;

}

Compiler output:
a.cc: In function 'int main()':
a.cc:23:13: error: 'sqrt' was not declared in this scope
   23 |         r = sqrt((x1-px)*(x1-px)+(y1-py)*(y1-py));
      |             ^~~~
a.cc:25:14: error: 'round' was not declared in this scope
   25 |         px = round(px * 1000) / 1000;
      |              ^~~~~
Language: C++

#! -*- coding:utf-8 -*-
import math
n = input()
for x in xrange(n):
    x1,y1,x2,y2,x3,y3 = map(float,raw_input().split())
    a1 = 2.0*(x2-x1)
    b1 = 2.0*(y2-y1)
    x12 = x1**2
    y12 = y1**2
    c1 = x12-x2**2+y12+y2**2
    a2 = 2.0*(x3-x1)
    b2 = 2.0*(y3-y1)
    c2 = x12-x3**2+y12-y3**2
    denom=(a1*b2-a2*b1)
    x = (b1*c2-b2*c1)/denom
    y = (c1*a2-c2*a1)/denom
    r = math.sqrt((x-x1)**2+(y-y1)**2)

    print "%.3f %.3f %.3f"%(x,y,r)

Compiler output:
a.cc:1:2: error: invalid preprocessing directive #!
    1 | #! -*- coding:utf-8 -*-
      |  ^
a.cc:2:1: error: 'import' does not name a type
    2 | import math
      | ^~~~~~
a.cc:2:1: note: C++20 'import' only available with '-fmodules-ts'
Language: C++

#include <iostream>
#include <cmath>
#include <cstdio>
using namespace std;

int w(int n)
{
  return n * n;
}

int main()
{
  double x1, y1, x2, y2, x3, y3;
  int n;
  double a, b, c;
  double px, py, r;

  cin >> n;

  for (int i = 0; i < n; i++){
    cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;

    a = sqrt(w(x1 - x2) + w(y1 - y2));
    b = sqrt(w(x2 - x3) + w(y2 - y3));
    c = sqrt(w(x3 - x1) + w(y3 - y1));
    px = ((y1 - y3) * (w(y1) - w(y2) + w(x1) - w(x2)) - (y1 - y2) * (w(y1) - w(y3) + w(x1) - w(x3))) / (2 * (y1 - y3) * (x1 - x2) - 2 * (y1 - y2) * (x1 - x3));
    py = ((x1 - x3) * (w(x1) - w(x2) + w(y1) - w(y2)) - (x1 - x2) * (w(x1) - w(x3) + w(y1) - w(y3))) / (2 * (x1 - x3) * (y1 - y2) - 2 * (x1 - x2) * (y1 - y3));
    //r = (a * b * c) / sqrt((a + b + c) * (b + c - a) * (a - b + c) * (a + b - c));
    x = ((a*a)-((b*b)+(c*c)))/(-2*b*c);
    y = sqrt(1-x*x);
    r = a/(2*y);
    printf("%.3f %.3f %.3f\n", px, py, r);
  }

  return 0;
}

Compiler output:
a.cc: In function 'int main()':
a.cc:29:5: error: 'x' was not declared in this scope
   29 |     x = ((a*a)-((b*b)+(c*c)))/(-2*b*c);
      |     ^
a.cc:30:5: error: 'y' was not declared in this scope
   30 |     y = sqrt(1-x*x);
      |     ^
Language: C++

#include <iostream>

int main(){
  int n;
  double a,b,c,d,e,f;
  double x1,x2,x3,y1,y2,y3;
  double px,py;
  double r;

  cin >> n;

  for(int i=0;i<n;i++){
    cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
    a = (x2-x1)*2.0;
    b = (y2-y1)*2.0;
    c = (x2*x2 + y2*y2 - x1*x1 - y1*y1);
    d = (x3-x1)*2.0;
    e = (y3-y1)*2.0;
    f = (x3*x3 + y3*y3 - x1*x1 - y1*y1);
    px = (c*e-b*f)/(a*e-b*d);
    py = (a*f-c*d)/(a*e-b*d);
    r = sqrt((px-x1)*(px-x1) + (py-y1)*(py-y1));
    printf("%.3f %.3f %.3f\n",px,py,r);



  }

  return 0;
}

Compiler output:
a.cc: In function 'int main()':
a.cc:10:3: error: 'cin' was not declared in this scope; did you mean 'std::cin'?
   10 |   cin >> n;
      |   ^~~
      |   std::cin
In file included from a.cc:1:
/usr/include/c++/14/iostream:62:18: note: 'std::cin' declared here
   62 |   extern istream cin;           ///< Linked to standard input
      |                  ^~~
a.cc:22:9: error: 'sqrt' was not declared in this scope
   22 |     r = sqrt((px-x1)*(px-x1) + (py-y1)*(py-y1));
      |         ^~~~
Language: C++

#include<iostream>
using namespace std;
class Point {
public:
	double x, y;
};
double distance(Point x, Point y) {
	return pow(pow(fabs(x.x - y.x), 2) + pow(fabs(x.y - y.y), 2), 0.5);
}
int main() {
	Point p[3],s;
	for (int i = 0; i < 3; i++) {
		cin >> p[i].x >> p[i].y;
	}
	double a, b, c, d, e, f;
	a = (-2)*p[0].x + 2 * p[1].x;
	b = (-2)*p[0].y + 2 * p[1].y;
	c = (-2)*p[0].x + 2 * p[2].x;
	d = (-2)*p[0].y + 2 * p[2].y;
	e = pow(p[0].x, 2) + pow(p[0].y, 2) - pow(p[1].x, 2) - pow(p[1].y, 2);
	f = pow(p[0].x, 2) + pow(p[0].y, 2) - pow(p[2].x, 2) - pow(p[2].y, 2);
	s.x = (b*f - d*e) / (a*d - b*c);
	s.y = (a*f - c*e) / (b*c - a*d);
	cout << s.x << " " << s.y << " " << distance(p[0], s) << endl;
	
	return 0;
}

Compiler output:
a.cc: In function 'double distance(Point, Point)':
a.cc:8:24: error: 'fabs' was not declared in this scope; did you mean 'labs'?
    8 |         return pow(pow(fabs(x.x - y.x), 2) + pow(fabs(x.y - y.y), 2), 0.5);
      |                        ^~~~
      |                        labs
a.cc:8:20: error: 'pow' was not declared in this scope
    8 |         return pow(pow(fabs(x.x - y.x), 2) + pow(fabs(x.y - y.y), 2), 0.5);
      |                    ^~~
a.cc:8:16: error: 'pow' was not declared in this scope
    8 |         return pow(pow(fabs(x.x - y.x), 2) + pow(fabs(x.y - y.y), 2), 0.5);
      |                ^~~
a.cc: In function 'int main()':
a.cc:20:13: error: 'pow' was not declared in this scope
   20 |         e = pow(p[0].x, 2) + pow(p[0].y, 2) - pow(p[1].x, 2) - pow(p[1].y, 2);
      |             ^~~
Language: C++

#include<iostream>
#include<cmath>
using namespace std;
int main(){
int k;
double x[3], y[3], a, b, c, d, e, f, l , m, n;
cin >> k;
while(k--){
cin>> x[0] >> y[0] >> x[1] >> y[1] >> x[2] >> y[2];
a = 2 * (x[1] - x[0]);
b = 2 * (y[1] - y[0]);
c = ( (x[1]*x[1]) + (y[1]*y[1]) ) -( (x[0]*x[0]) + (y[0]*y[0]) );
d = 2 * (x[2] - x[0]);
e = 2 * (y[2] - y[0]);
f = ( (x[2]*x[2]) + (y[2]*y[2]) ) -( (x[0]*x[0]) + (y[0]*y[0]) );
l = (c*e - f*b) / (a*e - d*b);
m = (c*d - f*a) / (b*d - e*a);
n = sqrt((l - x[0])*(l - x[0]) + (m - y[0])*(m - y[0]));
cout << fixed << setprecision(3) << l << " " << m << " " << n << endl;
}
}

Compiler output:
a.cc: In function 'int main()':
a.cc:19:18: error: 'setprecision' was not declared in this scope
   19 | cout << fixed << setprecision(3) << l << " " << m << " " << n << endl;
      |                  ^~~~~~~~~~~~
a.cc:3:1: note: 'std::setprecision' is defined in header '<iomanip>'; this is probably fixable by adding '#include <iomanip>'
    2 | #include<cmath>
  +++ |+#include <iomanip>
    3 | using namespace std;
Language: C++

#include<iostream>
#include<cmath>
using namespace std;
int main(){
int k;
double x[3], y[3], a, b, c, d, e, f, l , m, n;
cin >> k;
while(k--){
cin>> x[0] >> y[0] >> x[1] >> y[1] >> x[2] >> y[2];
a = 2 * (x[1] - x[0]);
b = 2 * (y[1] - y[0]);
c = ( (x[1]*x[1]) + (y[1]*y[1]) ) -( (x[0]*x[0]) + (y[0]*y[0]) );
d = 2 * (x[2] - x[0]);
e = 2 * (y[2] - y[0]);
f = ( (x[2]*x[2]) + (y[2]*y[2]) ) -( (x[0]*x[0]) + (y[0]*y[0]) );
l = (c*e - f*b) / (a*e - d*b);
m = (c*d - f*a) / (b*d - e*a);
n = sqrt((l - x[0])*(l - x[0]) + (m - y[0])*(m - y[0]));
cout << fixed <<setprecision(3) << l << " " << m << " " << n << endl;
}
}

Compiler output:
a.cc: In function 'int main()':
a.cc:19:17: error: 'setprecision' was not declared in this scope
   19 | cout << fixed <<setprecision(3) << l << " " << m << " " << n << endl;
      |                 ^~~~~~~~~~~~
a.cc:3:1: note: 'std::setprecision' is defined in header '<iomanip>'; this is probably fixable by adding '#include <iomanip>'
    2 | #include<cmath>
  +++ |+#include <iomanip>
    3 | using namespace std;
Language: C++

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

int d(int x1,int y1,int x2,int y2) {
    int k;
    k = sqrt((x1 - x2)*(x1 - x2) + (y1 - y2)*(y1 - y2));
    return k;
}
int main()
{
    int n;
    cin >> n;
    for (int k = 0; k < n; k++) {
        int A[3][2];
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 2; j++) {
                cin >> A[i][j];
            }
        }
        cout << d(A[0][0], A[0][1], A[1][0], A[1][1]) << endl;
        cout << d(A[1][0], A[1][1], A[2][0], A[2][1]) << endl;
        cout << d(A[2][0], A[2][1], A[0][0], A[0][1]) << endl;
    }
    
    return 0;
}

Compiler output:
a.cc: In function 'int d(int, int, int, int)':
a.cc:7:9: error: 'sqrt' was not declared in this scope
    7 |     k = sqrt((x1 - x2)*(x1 - x2) + (y1 - y2)*(y1 - y2));
      |         ^~~~
Language: C++

#include <iostream>
#include <cstdio>

#define MAX 1000000

using namespace std;

int main() {
	double x1, y1, x2, y2, x3, y3;
	int n;
	cin >> n;

	for (int i = 0; i < n; i++) {
		cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
		double x = ((y1-y3)*(y1*y1-y2*y2+x1*x1-x2*x2)-(y1-y2)*(y1*y1-y3*y3+x1*x1-x3*x3))/(2*(y1-y3)*(x1-x2)-2*(y1-y2)*(x1-x3));
		double y = ((x1-x3)*(x1*x1-x2*x2+y1*y1-y2*y2)-(x1-x2)*(x1*x1-x3*x3+y1*y1-y3*y3))/(2*(x1-x3)*(y1-y2)-2*(x1-x2)*(y1-y3));

		printf("%.3f %.3f %.3f\n", x, y, sqrt(pow((x1 - x), 2) + pow((y1 - y), 2)));
	}
	return 0;
}

Compiler output:
a.cc: In function 'int main()':
a.cc:18:55: error: 'pow' was not declared in this scope
   18 |                 printf("%.3f %.3f %.3f\n", x, y, sqrt(pow((x1 - x), 2) + pow((y1 - y), 2)));
      |                                                       ^~~
a.cc:18:50: error: 'sqrt' was not declared in this scope
   18 |                 printf("%.3f %.3f %.3f\n", x, y, sqrt(pow((x1 - x), 2) + pow((y1 - y), 2)));
      |                                                  ^~~~
Language: C++

#include <iostream>
#include <stdio.h>

#define MAX 1000000

using namespace std;

int main() {
	double x1, y1, x2, y2, x3, y3;
	int n;
	cin >> n;

	for (int i = 0; i < n; i++) {
		cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
		double x = ((y1-y3)*(y1*y1-y2*y2+x1*x1-x2*x2)-(y1-y2)*(y1*y1-y3*y3+x1*x1-x3*x3))/(2*(y1-y3)*(x1-x2)-2*(y1-y2)*(x1-x3));
		double y = ((x1-x3)*(x1*x1-x2*x2+y1*y1-y2*y2)-(x1-x2)*(x1*x1-x3*x3+y1*y1-y3*y3))/(2*(x1-x3)*(y1-y2)-2*(x1-x2)*(y1-y3));

		printf("%.3f %.3f %.3f\n", x, y, sqrt(pow((x1 - x), 2) + pow((y1 - y), 2)));
	}
	return 0;
}

Compiler output:
a.cc: In function 'int main()':
a.cc:18:55: error: 'pow' was not declared in this scope
   18 |                 printf("%.3f %.3f %.3f\n", x, y, sqrt(pow((x1 - x), 2) + pow((y1 - y), 2)));
      |                                                       ^~~
a.cc:18:50: error: 'sqrt' was not declared in this scope
   18 |                 printf("%.3f %.3f %.3f\n", x, y, sqrt(pow((x1 - x), 2) + pow((y1 - y), 2)));
      |                                                  ^~~~
Language: C++

#include <iostream>
#include "stdio.h"

#define MAX 1000000

using namespace std;

int main() {
	double x1, y1, x2, y2, x3, y3;
	int n;
	cin >> n;

	for (int i = 0; i < n; i++) {
		cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
		double x = ((y1-y3)*(y1*y1-y2*y2+x1*x1-x2*x2)-(y1-y2)*(y1*y1-y3*y3+x1*x1-x3*x3))/(2*(y1-y3)*(x1-x2)-2*(y1-y2)*(x1-x3));
		double y = ((x1-x3)*(x1*x1-x2*x2+y1*y1-y2*y2)-(x1-x2)*(x1*x1-x3*x3+y1*y1-y3*y3))/(2*(x1-x3)*(y1-y2)-2*(x1-x2)*(y1-y3));

		printf("%.3f %.3f %.3f\n", x, y, sqrt(pow((x1 - x), 2) + pow((y1 - y), 2)));
	}
	return 0;
}

Compiler output:
a.cc: In function 'int main()':
a.cc:18:55: error: 'pow' was not declared in this scope
   18 |                 printf("%.3f %.3f %.3f\n", x, y, sqrt(pow((x1 - x), 2) + pow((y1 - y), 2)));
      |                                                       ^~~
a.cc:18:50: error: 'sqrt' was not declared in this scope
   18 |                 printf("%.3f %.3f %.3f\n", x, y, sqrt(pow((x1 - x), 2) + pow((y1 - y), 2)));
      |                                                  ^~~~
Language: C++

#include <iostream>
#include <cstdio>

using namespace std;

int main() {
	double x1, y1, x2, y2, x3, y3;
	int n;
	cin >> n;

	for (int i = 0; i < n; i++) {
		cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
		double x = ((y1-y3)*(y1*y1-y2*y2+x1*x1-x2*x2)-(y1-y2)*(y1*y1-y3*y3+x1*x1-x3*x3))/(2*(y1-y3)*(x1-x2)-2*(y1-y2)*(x1-x3));
		double y = ((x1-x3)*(x1*x1-x2*x2+y1*y1-y2*y2)-(x1-x2)*(x1*x1-x3*x3+y1*y1-y3*y3))/(2*(x1-x3)*(y1-y2)-2*(x1-x2)*(y1-y3));

		printf("%.3f %.3f %.3f\n", x, y, sqrt(pow((x1 - x), 2) + pow((y1 - y), 2)));
	}
	return 0;
}

Compiler output:
a.cc: In function 'int main()':
a.cc:16:55: error: 'pow' was not declared in this scope
   16 |                 printf("%.3f %.3f %.3f\n", x, y, sqrt(pow((x1 - x), 2) + pow((y1 - y), 2)));
      |                                                       ^~~
a.cc:16:50: error: 'sqrt' was not declared in this scope
   16 |                 printf("%.3f %.3f %.3f\n", x, y, sqrt(pow((x1 - x), 2) + pow((y1 - y), 2)));
      |                                                  ^~~~
Language: C++

#include<iostream>
#include<stdio,h>
#include<math.h>

using namespace std;

#define MAX 256

float LOSER(float x){
	if((int)(x*10000)%10 > 4)return x + 0.001;
	return x;
}

int main(void){
	int n,i = 0;
	float x1,y1,x2,y2,x3,y3;
	float px[MAX],py[MAX],r[MAX];
	
	cin >> n;
	while(i < n){
		cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
		px[i] = ((y1-y3)*(y1*y1-y2*y2+x1*x1-x2*x2)+(y1-y2)*(y1*y1-y3*y3+x1*x1-x3*x3))/(2*(y1-y3)*(x1-x2)+2*(y1-y2)*(x1-x3));
		py[i] = ((x1-x3)*(x1*x1-x2*x2+y1*y1-y2*y2)+(x1-x2)*(x1*x1-x3*x3+y1*y1-y3*y3))/(2*(x1-x3)*(y1-y2)+2*(x1-x2)*(y1-y3));
		r[i] = sqrt((px[i]-x1)*(px[i]-x1)+(py[i]-y1)*(py[i]-y1));
		px[i]=LOSER(px[i]);
		py[i]=LOSER(py[i]);
		r[i]=LOSER(r[i]);
		i++;
		printf("%.3f %.3f %.3f",px[i],py[i],r[i]);
	}

	return 0;
}

Compiler output:
a.cc:2:9: fatal error: stdio,h: No such file or directory
    2 | #include<stdio,h>
      |         ^~~~~~~~~
compilation terminated.
Language: C++

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


class vec{
public:
	double x;
	double y;
	double normEXP2() const{
		return x*x + y*y;
	}
	vec& operator+(const vec& v){
		x += v.x;
		y += v.y;
		return *this;
	}
	vec& operator-(const vec& v){
		x -= v.x;
		y -= v.y;
		return *this;
	}
	vec& operator*(double scala){
		x *= scala;
		y *= scala;
		return *this;
	}
	double operator*(const vec& v) const{
		return x*v.x + y*v.y;
	}
};


istream& operator>>(istream& i, vec& v){
	i >> v.x >> v.y;
	return i;
}


pair<double, double> cramer(const vec& a, const vec& b){
	pair<double, double> solve;
	solve.first = (2 * a.normEXP2()*b.normEXP2() - 2 * b.normEXP2()*(a*b)) / (4 * a.normEXP2()*b.normEXP2() - 4 * ((a*b)*(a*b)));
	solve.second = (2 * a.normEXP2()*b.normEXP2() - 2 * a.normEXP2()*(a*b)) / (4 * a.normEXP2()*b.normEXP2() - 4 * ((a*b)*(a*b)));

	return solve;
}


int main(){
	int n;
	vec v1, v2, v3;
	vec b, c;
	vec solveVec;
	pair<double, double> solve;
	double x, y;
	double r;

	cin >> n;
	for (int i = 0; i < n; i++){
		cin >> v1 >> v2 >> v3;
		b = v2 - v1;
		c = v3 - v1;
		
		solve = cramer(b, c);
		solveVec = (b*solve.first) + (c*solve.second);

		solveVec = v1 + solveVec;
		r = sqrt(solveVec.normEXP2());

		y = (double)((int)((solveVec.y * 1000) + 0.5)) / 1000;
		r = (double)((int)((r * 1000) + 0.5)) / 1000;
		x = (double)((int)((solveVec.x * 1000) + 0.5)) / 1000;

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

	return 0;
}

Compiler output:
a.cc: In function 'int main()':
a.cc:68:21: error: 'sqrt' was not declared in this scope
   68 |                 r = sqrt(solveVec.normEXP2());
      |                     ^~~~
Language: C++

#include <iostream>
#include <algorism>
#include <stdio.h>
#include <cmath>

using namespace std;
double min(double x0, double x1, double x2){ return min(min(x0, x1), x2); }
double max(double x0, double x1, double x2){ return max(max(x0, x1), x2); }
double d(double x, double y, double p, double q){ return sqrt((p-x)*(p-x)+(q-y)*(q-y)); }
double diff(double x0, double x1, double x2){ return max(x0,x1,x2)-min(x0,x1,x2); }
int main(){
	double x[3], y[3];
	cin >> x[0] >> y[0] >> x[1] >> y[1] >> x[2] >> y[2];

	double ax,ay, r;
	double p, q;
	ax = (max(x[0],x[1],x[2]) + min(x[0],x[1],x[2]))/2;
	ay = (max(y[0],x[1],x[2]) + min(x[0],x[1],x[2]))/2;
	p = (max(x[0],x[1],x[2]) + min(x[0],x[1],x[2]))/4;
	q = (max(y[0],x[1],x[2]) + min(x[0],x[1],x[2]))/4;

	for(int i=0; i<10; i++){
		p = (max(x[0],x[1],x[2]) + min(x[0],x[1],x[2]))/4;
		q = (max(y[0],x[1],x[2]) + min(x[0],x[1],x[2]))/4;
		while(1){
		if(diff(d(x[0],y[0],ax+p,ay),d(x[1],y[1],ax+p,ay),d(x[2],y[2],ax+p,ay)) > diff(d(x[0],y[0],ax-p,ay),d(x[1],y[1],ax-p,ay),d(x[2],y[2],ax-p,ay))){
			ax -= p;
		}
		else if(diff(d(x[0],y[0],ax+p,ay),d(x[1],y[1],ax+p,ay),d(x[2],y[2],ax+p,ay)) < diff(d(x[0],y[0],ax-p,ay),d(x[1],y[1],ax-p,ay),d(x[2],y[2],ax-p,ay)) ){
			ax += p;
		}
		if(p<0.0001) break;

		p /= 2;
		}

		while(1){
		if(diff(d(x[0],y[0],ax,ay+q),d(x[1],y[1],ax,ay+q),d(x[2],y[2],ax,ay+q)) > diff(d(x[0],y[0],ax,ay-q),d(x[1],y[1],ax,ay-q),d(x[2],y[2],ax,ay-q))){
			ax -= q;
		}
		else if(diff(d(x[0],y[0],ax,ay+q),d(x[1],y[1],ax,ay+q),d(x[2],y[2],ax,ay+q)) < diff(d(x[0],y[0],ax,ay-q),d(x[1],y[1],ax,ay-q),d(x[2],y[2],ax,ay-q))){
			ax += q;
		}
		if(q<0.0001) break;

		q /= 2;
		}
	}

	double a, b, c;
	a = d(x[0],y[0],x[1],y[1]); b = d(x[1],y[1],x[2],y[2]); c = d(x[2],y[2],x[0],y[0]);
	r = sqrt((a*a+b*b+c*c)*(a*a+b*b+c*c) - (a*a*a*a + b*b*b*b + c*c*c*c))/4;
	r *= 2/(a+b+c);

	printf("%.3f %.3f %.3f\n",ax, ay, r);
	return 0;
}

Compiler output:
a.cc:2:10: fatal error: algorism: No such file or directory
    2 | #include <algorism>
      |          ^~~~~~~~~~
compilation terminated.
Language: C++

int main(void){

  int n;
  cin >> n;

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

    double x1,y1,x2,y2,x3,y3;
    cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;

    double a = sqrt(pow(x2-x1,2) + pow(y2-y1,2));
    double b = sqrt(pow(x3-x2,2) + pow(y3-y2,2));
    double c = sqrt(pow(x3-x1,2) + pow(y3-y1,2));

    double r = a*b*c / sqrt((a+b+c)*(-a+b+c)*(a-b+c)*(a+b-c));

    double A = pow(x2-x1,2) + pow(y2-y1,2);
    double B = pow(x3-x2,2) + pow(y3-y2,2);
    double C = pow(x3-x1,2) + pow(y3-y1,2);
    double s = 4*((x2-x1)*(y3-y1) -(x3-x1)*(y2-y1));

    double x = A*(B+C-A) / s;
    double y = B*(C+A-B) / s;

    printf("%.3f %.3f %.3f\n");

  }




  return 0;
}

Compiler output:
a.cc: In function 'int main()':
a.cc:4:3: error: 'cin' was not declared in this scope
    4 |   cin >> n;
      |   ^~~
a.cc:11:21: error: 'pow' was not declared in this scope
   11 |     double a = sqrt(pow(x2-x1,2) + pow(y2-y1,2));
      |                     ^~~
a.cc:11:16: error: 'sqrt' was not declared in this scope
   11 |     double a = sqrt(pow(x2-x1,2) + pow(y2-y1,2));
      |                ^~~~
a.cc:25:5: error: 'printf' was not declared in this scope
   25 |     printf("%.3f %.3f %.3f\n");
      |     ^~~~~~
a.cc:1:1: note: 'printf' is defined in header '<cstdio>'; this is probably fixable by adding '#include <cstdio>'
  +++ |+#include <cstdio>
    1 | int main(void){
Language: C++

#include <iostream>
#include <vector>
//#include <math.h>
//#include <string>
#include <cmath>
#include <iomanip>

int main();
double round(double dSrc, int iLen);

int main(){
	int cnt = 0;		//データセットの個数
	double x1, y1, x2, y2, x3, y3;
	std::vector<double> p;		//外接円の中心のx座標
	std::vector<double> q;		//外接円の中心のy座標
	std::vector<double> r;		//外接円の半径
	
	std::cin >> cnt;
	for (int i = 0; i < cnt; i++){
		std::cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
		p.push_back(((y1 - y3) * (pow(y1, 2) - pow(y2, 2) + pow(x1, 2) - pow(x2, 2)) - (y1 - y2) * (pow(y1, 2) - pow(y3, 2) + pow(x1, 2) - pow(x3, 2))) / (2 * (y1 - y3) * (x1 - x2) - 2 * (y1 - y2) * (x1 - x3)));
		q.push_back(((x1 - x3) * (pow(x1, 2) - pow(x2, 2) + pow(y1, 2) - pow(y2, 2)) - (x1 - x2) * (pow(x1, 2) - pow(x3, 2) + pow(y1, 2) - pow(y3, 2))) / (2 * (x1 - x3) * (y1 - y2) - 2 * (x1 - x2) * (y1 - y3)));
		r.push_back(sqrt((pow((p[i] - x1), 2) + pow((q[i] - y1), 2))));
		
//#define AAA
#ifdef AAA
		int temp = p[i];
		if (p[i] - temp != 0){
			p[i] = round(p[i], 3);
		}

		temp = q[i];
		if (q[i] - temp != 0){
			q[i] = round(q[i], 3);
		}
		
		temp = r[i];
		if (r[i] - temp != 0){
			r[i] = round(r[i], 3);
		}

		std::cout << std::fixed << std::setprecision(3) << p[i] << " " << q[i] << " " << r[i] << std::endl;
	}
#endif
#ifndef	AAA
	for (int i = 0; i < cnt; i++){
		int temp = p[i];
		if (p[i] - temp != 0){
			p[i] = round(p[i], 3);
		}

		temp = q[i];
		if (q[i] - temp != 0){
			q[i] = round(q[i], 3);
		}
		
		temp = r[i];
		if (r[i] - temp != 0){
			r[i] = round(r[i], 3);
		}

		std::cout << std::fixed << std::setprecision(3) << p[i] << " " << q[i] << " " << r[i] << std::endl;
	}
#endif
	//while (1);
	return 0;
}

/**
* 指定桁で四捨五入を行う
* args:数値, 四捨五入する桁数
* return:結果
* 参考:http://oresi.hatenablog.com/entry/2014/06/23/【C%2CC%2B%2B】指定桁数で端数処理%EF%BC%88切り上げ、切り下げ
*/
double round(double dSrc, int iLen)
{
	double	dRet;

	dRet = dSrc * pow(10.0, iLen);
	dRet = (double)(int)(dRet + 0.5);

	return dRet * pow(10.0, -iLen);
}


Compiler output:
a.cc: In function 'int main()':
a.cc:76:1: error: a function-definition is not allowed here before '{' token
   76 | {
      | ^
a.cc:83:2: error: expected '}' at end of input
   83 | }
      |  ^
a.cc:11:11: note: to match this '{'
   11 | int main(){
      |           ^
Language: C++

#include<stdio.h>
#include<math.h>
int main(){
    int a;
    cin >>a;
    while(a--){
        double x1,y1,x2,y2,x3,y3;
        cin >>x1 >>y1 >>x2 >> y2 >> x3 >> y3;
        double a1=2*(x2-x1);
        double b1=2*(y2-y1);
        double c1=x1*x1-x2*x2+y1*y1-y2*y2;
        double a2=2*(x3-x1);
        double b2=2*(y3-y1);
        double c2=x1*x1-x3*x3+y1*y1-y3*y3;
        double x=(b1*c2-b2*c1)/(a1*b2-a2*b1);
        double y=(c1*a2-c2*a1)/(a1*b2-a2*b1);
        double r=hypot(x-x1,y-y1);
        printf("%.3lf %.3lf %.3lf\n",x,y,r);
    }
}


Compiler output:
a.cc: In function 'int main()':
a.cc:5:5: error: 'cin' was not declared in this scope; did you mean 'sin'?
    5 |     cin >>a;
      |     ^~~
      |     sin
Language: C++

#include<stdio.h>
#include<math.h>
using namespace std;
int main(){
    int a;
    cin >>a;
    while(a--){
        double x1,y1,x2,y2,x3,y3;
        cin >>x1 >>y1 >>x2 >> y2 >> x3 >> y3;
        double a1=2*(x2-x1);
        double b1=2*(y2-y1);
        double c1=x1*x1-x2*x2+y1*y1-y2*y2;
        double a2=2*(x3-x1);
        double b2=2*(y3-y1);
        double c2=x1*x1-x3*x3+y1*y1-y3*y3;
        double x=(b1*c2-b2*c1)/(a1*b2-a2*b1);
        double y=(c1*a2-c2*a1)/(a1*b2-a2*b1);
        double r=hypot(x-x1,y-y1);
        printf("%.3lf %.3lf %.3lf\n",x,y,r);
    }
}


Compiler output:
a.cc: In function 'int main()':
a.cc:6:5: error: 'cin' was not declared in this scope
    6 |     cin >>a;
      |     ^~~
a.cc:3:1: note: 'std::cin' is defined in header '<iostream>'; this is probably fixable by adding '#include <iostream>'
    2 | #include<math.h>
  +++ |+#include <iostream>
    3 | using namespace std;
Language: C++

#include <iostream>
#include <vector>
#include<iomanip>
using namespace std;

struct Circles {
	double x;
	double y;
	double r;
};

Circles countCircle(double x1,double y1, double x2, double y2, double x3, double y3){
	double a = ((y2 - y1)*(y3*y3 - y1 * y1 + x3 * x3 - x1 * x1) - (y3 - y1)*(y2*y2 - y1 * y1 + x2 * x2 - x1 * x1)) / (2.0*((x3 - x1)*(y2 - y1) - (x2 - x1)*(y3 - y1)));
	double b = ((x2 - x1)*(x3*x3 - x1 * x1 + y3 * y3 - y1 * y1) - (x3 - x1)*(x2*x2 - x1 * x1 + y2 * y2 - y1 * y1)) / (2.0*((y3 - y1)*(x2 - x1) - (y2 - y1)*(x3 - x1)));
	double r = sqrt((x1 - a)*(x1 - a) + (y1 - b)*(y1 - b));
	return Circles{ a,b,r };
}


int main() {
	vector<Circles> dst;
	int n;
	double x1, y1, x2, y2, x3, y3;
	cin >> n;
	while (n-->0) {
		cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
		dst.push_back(countCircle(x1, y1, x2, y2, x3, y3));
	}
	for (vector<Circles>::iterator it = dst.begin(); it < dst.end(); it++) {
		cout.setf(ios::fixed);
		cout << fixed << setprecision(3) << (*it).x << " " << (*it).y << " " << (*it).r << endl;
	}
	return 0;
}


Compiler output:
a.cc: In function 'Circles countCircle(double, double, double, double, double, double)':
a.cc:15:20: error: 'sqrt' was not declared in this scope
   15 |         double r = sqrt((x1 - a)*(x1 - a) + (y1 - b)*(y1 - b));
      |                    ^~~~
Language: C++

# -*- coding: utf-8 -*-
from math import sqrt
# import numpy as np


n = int(input())

for i in range(n):
    tmp = input().split(' ')
    
    a, b, c = [(float(tmp[i]), float(tmp[i+1])) for i in range(0, len(tmp), 2)]
    
    #A = np.array(((a[0], a[1], 1),
    #              (b[0], b[1], 1),
    #              (c[0], c[1], 1)))
    A_tmp1 = 1/(a[0]*b[1] + a[1]*c[0] + b[0]*c[1] - b[1]*c[0] - a[1]*b[0] - a[0]*c[1])
    A_tmp2 = [[b[1]-c[1], -(a[1]-c[1]), a[1]-b[1]],
              [-(b[0]-c[0]),  (a[0]-c[0]), -(a[0]-b[0])],
              [b[0]*c[1] - b[1]*c[0], -(a[0]*c[1] - a[1]*c[0]), a[0]*b[1] - a[1]*b[0]]]
    A = [list(map(lambda x: A_tmp1*x, A_tmp2[i])) for i in range(3)]
    
    #B = np.array((((-(a[0]**2 + a[1]**2))),
    #              ((-(b[0]**2 + b[1]**2))),
    #              ((-(c[0]**2 + c[1]**2)))))
    B = [[-(a[0]**2 + a[1]**2)],
         [-(b[0]**2 + b[1]**2)],
         [-(c[0]**2 + c[1]**2)]]
    
    
    tmp = [sum([A[i][j]*B[j][0] for j in range(3)]) for i in range(3)]
    # tmp = np.dot(np.linalg.inv(A), B)
    print(tmp)
    
    x = -tmp[0]/2
    y = -tmp[1]/2
    r = sqrt((tmp[0]**2 + tmp[1]**2 - 4*tmp[2])/4)
    
    print('{:.3} {:.3} {:.3}'.format(x, y, r))


Compiler output:
a.cc:1:3: error: invalid preprocessing directive #-
    1 | # -*- coding: utf-8 -*-
      |   ^
a.cc:3:3: warning: #import is a deprecated GCC extension [-Wdeprecated]
    3 | # import numpy as np
      |   ^~~~~~
a.cc:3:10: error: #import expects "FILENAME" or <FILENAME>
    3 | # import numpy as np
      |          ^~~~~
a.cc:13:6: error: invalid preprocessing directive #A
   13 |     #A = np.array(((a[0], a[1], 1),
      |      ^
a.cc:14:20: error: invalid preprocessing directive #(
   14 |     #              (b[0], b[1], 1),
      |                    ^
a.cc:15:20: error: invalid preprocessing directive #(
   15 |     #              (c[0], c[1], 1)))
      |                    ^
a.cc:22:6: error: invalid preprocessing directive #B
   22 |     #B = np.array((((-(a[0]**2 + a[1]**2))),
      |      ^
a.cc:23:20: error: invalid preprocessing directive #(
   23 |     #              ((-(b[0]**2 + b[1]**2))),
      |                    ^
a.cc:24:20: error: invalid preprocessing directive #(
   24 |     #              ((-(c[0]**2 + c[1]**2)))))
      |                    ^
a.cc:31:7: error: invalid preprocessing directive #tmp
   31 |     # tmp = np.dot(np.linalg.inv(A), B)
      |       ^~~
a.cc:38:11: warning: multi-character literal with 17 characters exceeds 'int' size of 4 bytes
   38 |     print('{:.3} {:.3} {:.3}'.format(x, y, r))
      |           ^~~~~~~~~~~~~~~~~~~
a.cc:2:1: error: 'from' does not name a type
    2 | from math import sqrt
      | ^~~~
Language: C++

#!/usr/bin/env python
from math import *
def g(x):
	y = (int((1000 * abs(x)) * 2 + 1) // 2) / 1000
	if x < 0:
		y *= -1
	return y
def func(x):
	x1, y1, x2, y2, x3, y3 = x
	
	a = x1 - x2
	b = y1 - y2
	c = (x1 * x1 + y1 * y1 - x2 * x2 - y2 * y2) / 2
	d = x1 - x3
	e = y1 - y3
	f = (x1 * x1 + y1 * y1 - x3 * x3 - y3 * y3) / 2
	x = (e * c - b * f) / (a * e - b * d)
	y = (a * f - d * c) / (a * e - b * d)
	r = sqrt((x1 - x) * (x1 - x) + (y1 - y) * (y1 - y))
	x = "{0:.3f}".format(g(x))
	y = "{0:.3f}".format(g(y))
	r = "{0:.3f}".format(g(r))
	print(x + " " + y + " " + r)
n = int(input())
a = []
for _ in range(n):
	a.append(list((map(float, input().split()))))
for i in a:
	func(i)


Compiler output:
a.cc:1:2: error: invalid preprocessing directive #!
    1 | #!/usr/bin/env python
      |  ^
a.cc:2:1: error: 'from' does not name a type
    2 | from math import *
      | ^~~~
Language: C++

#include<stdio.h>
#include<iostream>

using namespace std;

struct Line{
    bool isRightX, isRightY;
    double x, y, a, b;
};

Line getBisector(double x1, double y1, double x2, double y2){
    Line bisector;
    bisector.isRightX = bisector.isRightY = false;
    if ( y1 == y2 ){   
	bisector.isRightY = true;
	bisector.x = ( x1 + x2 ) / 2;
    } else if ( x1 == x2 ){    
	bisector.isRightX = true;
	bisector.y = ( y1 + y2 ) / 2;
    } else {
	bisector.a = ( x2 - x1 ) / ( y1 - y2 );
	bisector.b = ( y1 + y2 ) / 2 - bisector.a * (( x1 + x2 ) / 2);
    }

    return bisector;
}

void compute(){
    double x1, y1, x2, y2, x3, y3, x, y, r;
    cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
    Line AB = getBisector(x1, y1, x2, y2);
    Line AC = getBisector(x1, y1, x3, y3);
    if ( AB.isRightX ){
	if ( AC.isRightY ){
	    x = AC.x; y = AB.y;
	} else {
	    y = AB.y; x = (y - AC.b) / AC.a;
	}
    } else if ( AB.isRightY ){ //y ツ篠イツづ可閉スツ行
	if ( AC.isRightX ){
	    x = AB.x; y = AC.y;
	} else {
	    x = AB.x; y = AC.a * x + AC.b;
	}
    } else {
	if ( AC.isRightX ) {
	    y = AC.y; x = (y - AB.b) / AB.a;
	} else if ( AC.isRightY ) {
	    x = AC.x; y = AB.a * x + AB.b;			
	} else {
	    x = (AC.b - AB.b) / (AB.a - AC.a); 
	    y = AB.a * x + AB.b;
	}	
    }
    r = sqrt( (x - x1)*(x - x1) + (y - y1)*(y - y1) );

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

int main(){
    int tcase; cin >> tcase;
    for ( int i = 0; i < tcase; i++ ){
	compute();
    }
    return 0;
}

Compiler output:
a.cc: In function 'void compute()':
a.cc:55:9: error: 'sqrt' was not declared in this scope
   55 |     r = sqrt( (x - x1)*(x - x1) + (y - y1)*(y - y1) );
      |         ^~~~
Language: C++

    }else{
      P max = point[0];
      P min = point[0];
      if(max.real() < point[1].real())max=point[1];
      if(min.real() > point[1].real())min=point[1];
      if(max.real() < point[1].real())max=point[2];
      if(min.real() > point[1].real())min=point[2];
      ans = max + min;
      ans = (ans.real()/2,ans.imag()/2);
    }

Compiler output:
a.cc:1:5: error: expected declaration before '}' token
    1 |     }else{
      |     ^
a.cc:1:6: error: expected unqualified-id before 'else'
    1 |     }else{
      |      ^~~~
Language: C++

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

double get_num(double x){
	x = x * 1000;
	if(x >= 0){
		x = (int)(x + 0.5);
		return ((double)x / 1000);
	} else {
		x = (int)(x - 0.5);
		return ((double)x / 1000);
	}
}

int main()
{
	int n;
	cin >> n;
	for(int i = 0; i < n; i++){
		double x1, y1;
		double x2, y2;
		double x3, y3;
		double m12x, m12y;
		double m13x, m13y;
		double dx12, dy12;
		double dx13, dy13;
		double c12, c13;
		double xp, yp;
		double r;
		cin >> x1 >> y1 >> x2
			>> y2 >> x3 >> y3;
		m12x = (x1 + x2) / 2;
		m12y = (y1 + y2) / 2;
		m13x = (x1 + x3) / 2;
		m13y = (y1 + y3) / 2;
		dx12 = x2 - x1;
		dy12 = y2 - y1;
		dx13 = x3 - x1;
		dy13 = y3 - y1;
		c12 = m12x * dx12 + m12y * dy12;
		c13 = m13x * dx13 + m13y * dy13;
		yp = (c12 * dx13 - c13 * dx12) / (dy12 * dx13 - dy13 * dx12);
		if(dx12 == 0){
			xp = (c13 - (dy13 * yp)) / dx13;
		}else{
			xp = (c12 - (dy12 * yp)) / dx12;
		}
		r = sqrt((xp - x1) * (xp - x1) + ((yp - y1) * (yp - y1)));
		xp = get_num(xp);
		yp = get_num(yp);
		r = get_num(r);
		cout << fixed << setprecision(3) << xp << " " << yp << " " << r << endl;

	}
	return 0;
}

Compiler output:
a.cc: In function 'int main()':
a.cc:49:21: error: 'sqrt' was not declared in this scope
   49 |                 r = sqrt((xp - x1) * (xp - x1) + ((yp - y1) * (yp - y1)));
      |                     ^~~~
Language: C++

#include <iostream>
#include <iomanip>
#include <stdlib>
using namespace std;

double get_num(double x){
	x = x * 1000;
	if(x >= 0){
		x = (int)(x + 0.5);
		return ((double)x / 1000);
	} else {
		x = (int)(x - 0.5);
		return ((double)x / 1000);
	}
}

int main()
{
	int n;
	cin >> n;
	for(int i = 0; i < n; i++){
		double x1, y1;
		double x2, y2;
		double x3, y3;
		double m12x, m12y;
		double m13x, m13y;
		double dx12, dy12;
		double dx13, dy13;
		double c12, c13;
		double xp, yp;
		double r;
		cin >> x1 >> y1 >> x2
			>> y2 >> x3 >> y3;
		m12x = (x1 + x2) / 2;
		m12y = (y1 + y2) / 2;
		m13x = (x1 + x3) / 2;
		m13y = (y1 + y3) / 2;
		dx12 = x2 - x1;
		dy12 = y2 - y1;
		dx13 = x3 - x1;
		dy13 = y3 - y1;
		c12 = m12x * dx12 + m12y * dy12;
		c13 = m13x * dx13 + m13y * dy13;
		yp = (c12 * dx13 - c13 * dx12) / (dy12 * dx13 - dy13 * dx12);
		if(dx12 == 0){
			xp = (c13 - (dy13 * yp)) / dx13;
		}else{
			xp = (c12 - (dy12 * yp)) / dx12;
		}
		r = sqrt((xp - x1) * (xp - x1) + ((yp - y1) * (yp - y1)));
		xp = get_num(xp);
		yp = get_num(yp);
		r = get_num(r);
		cout << fixed << setprecision(3) << xp << " " << yp << " " << r << endl;

	}
	return 0;
}

Compiler output:
a.cc:3:10: fatal error: stdlib: No such file or directory
    3 | #include <stdlib>
      |          ^~~~~~~~
compilation terminated.
Language: C++

#include <iostream>
#include <cstdlib>
#include <numeric>
#include <iomanip>
using namespace std;

double get_num(double x){
	x = x * 1000;
	if(x >= 0){
		x = (int)(x + 0.5);
		return ((double)x / 1000);
	} else {
		x = (int)(x - 0.5);
		return ((double)x / 1000);
	}
};

int main()
{
	int n;
	cin >> n;
	for(int i = 0; i < n; i++){
		double x1, y1;
		double x2, y2;
		double x3, y3;
		double m12x, m12y;
		double m13x, m13y;
		double dx12, dy12;
		double dx13, dy13;
		double c12, c13;
		double xp, yp;
		double r;
		cin >> x1 >> y1 >> x2
			>> y2 >> x3 >> y3;
		m12x = (x1 + x2) / 2;
		m12y = (y1 + y2) / 2;
		m13x = (x1 + x3) / 2;
		m13y = (y1 + y3) / 2;
		dx12 = x2 - x1;
		dy12 = y2 - y1;
		dx13 = x3 - x1;
		dy13 = y3 - y1;
		c12 = m12x * dx12 + m12y * dy12;
		c13 = m13x * dx13 + m13y * dy13;
		yp = (c12 * dx13 - c13 * dx12) / (dy12 * dx13 - dy13 * dx12);
		if(dx12 == 0){
			xp = (c13 - (dy13 * yp)) / dx13;
		}else{
			xp = (c12 - (dy12 * yp)) / dx12;
		}
		r = sqrt((xp - x1) * (xp - x1) + ((yp - y1) * (yp - y1)));
		xp = get_num(xp);
		yp = get_num(yp);
		r = get_num(r);
		cout << fixed << setprecision(3) << xp << " " << yp << " " << r << endl;

	}
	return 0;
}

Compiler output:
a.cc: In function 'int main()':
a.cc:51:21: error: 'sqrt' was not declared in this scope
   51 |                 r = sqrt((xp - x1) * (xp - x1) + ((yp - y1) * (yp - y1)));
      |                     ^~~~
Language: C++

#include <iostream>
#include <cstdio>
#include <complex>
#include <vector>
#include <algorithm>
using namespace std;

#define EPS 1.0e-6

const double EPS = 1e-7;
typedef complex<double> P; /* _ */
struct L {                 /* üª */
	P p, q;
	L(P p, P q) : p(p), q(q) {}
};

double cross(P a, P b) { return imag(conj(a)*b); }

// ¼üaÆ¼übÌð_ðvZ·éDæÉð·»èªK{D
P crossPointLL(L a, L b){
	double A = cross(a.q-a.p, b.q-b.p);
	double B = cross(a.q-a.p, a.q-b.p);
	return b.p + B/A * (b.q-b.p);
}

// _pÆ_qÌ¼ñªüðÔ·
L pointBisector(P p, P q) {
	P cen = (p+q)*0.5;
	return L(cen, cen+(q-p)*P(0,1));
}

int main(){
	int n;
	cin>>n;
	double x1, y1, x2, y2, x3, y3;
	while(cin>>x1>>y1>>x2>>y2>>x3>>y3){
		// Cuè@
		P p1 = P(x1, y1);
		P p2 = P(x2, y2);
		P p3 = P(x3, y3);
		L l1 = pointBisector(p1, p2);
		L l2 = pointBisector(p2, p3);
		P cen = crossPointLL(l1, l2);
		double r = abs(p1-cen);

		// Êè@
		double a1 = 2*(x2-x1);
		double b1 = 2*(y2-y1);
		double c1 = x1*x1-x2*x2+y1*y1-y2*y2;
		double a2 = 2*(x3-x1);
		double b2 = 2*(y3-y1);
		double c2 = x1*x1-x3*x3+y1*y1-y3*y3;
		double cx = (b1*c2-b2*c1)/(a1*b2-a2*b1);
		double cy = (c1*a2-c2*a1)/(a1*b2-a2*b1);
		P cen2 = P(cx, cy);
		double r2 = abs(p1-cen2);

		// ÜÆß
		int x1000 = 1000*cen2.real()+0.5;
		int y1000 = 1000*cen2.imag()+0.5;
		int r1000 = 1000*r2+0.5;
		printf("%.3f %.3f %.3f", 1.0*x1000/1000+EPS, 1.0*y1000/1000+EPS, 1.0*r1000/1000+EPS);
		cout<<endl;
	}
	return 0;
}

Compiler output:
a.cc:8:13: error: expected unqualified-id before numeric constant
    8 | #define EPS 1.0e-6
      |             ^~~~~~
a.cc:10:14: note: in expansion of macro 'EPS'
   10 | const double EPS = 1e-7;
      |              ^~~
Language: C++

#include <iostream>
#include <cstdio>
#include <complex>
#include <vector>
#include <algorithm>
using namespace std;

typedef complex<double> P; /* ツ点 */

int main(){
	int n;
	cin>>n;
	double x1, y1, x2, y2, x3, y3;
	while(cin>>x1>>y1>>x2>>y2>>x3>>y3){
		double a1 = 2*(x2-x1);
		double b1 = 2*(y2-y1);
		double c1 = x1*x1-x2*x2+y1*y1-y2*y2;
		double a2 = 2*(x3-x1);
		double b2 = 2*(y3-y1);
		double c2 = x1*x1-x3*x3+y1*y1-y3*y3;
		double cx = (b1*c2-b2*c1)/(a1*b2-a2*b1);
		double cy = (c1*a2-c2*a1)/(a1*b2-a2*b1);
		P cen2 = P(cx, cy);
		double r2 = abs(p1-cen2);

		printf("%.3f %.3f %.3f\n", real(cen2), imag(cen2), r2);
	}
	return 0;
}

Compiler output:
a.cc: In function 'int main()':
a.cc:24:33: error: 'p1' was not declared in this scope; did you mean 'c1'?
   24 |                 double r2 = abs(p1-cen2);
      |                                 ^~
      |                                 c1
Language: C++

#include <stdio.h>

int main(void){
	int n , i;
	float x1,x2,x3,y1,y2,y3,a1,a2,b1,b2,c1,c2,xp,yp,r;
	scanf("%d" , &n);
	for(i=1;i<=n;i++){
		scanf("%f %f %f %f %f %f" , &x1 , &y1 , &x2 , &y2 , &x3 , &y3);
		a1 = 2 * (x2 - x1);
		b1 = 2 * (y2 - y1);
		c1 = x1 * x1 - x2 * x2 + y1 * y1 - y2 * y2;
		a2 = 2 * (x3 - y1);
		b2 = 2 * (y3 - y1);
		c2 = x1 * x1 - x3 * x3 + y1 * y1 - y3 * y3;
		xp = (b1 * c2 - b2 * c1) / (a1 * b2 - a2 * b1);
		yp = (c1 * a2 - c2 * a1) / (a1 * b2 - a2 * b1);
		r = sqrt((xp - x1) * (xp - x1) + (yp - y1) * (yp - y1));
		printf("%.3f %.3f %.3f\n" , xp , yp , r);
	}
	return 0;
}

Compiler output:
a.cc: In function 'int main()':
a.cc:17:21: error: 'sqrt' was not declared in this scope
   17 |                 r = sqrt((xp - x1) * (xp - x1) + (yp - y1) * (yp - y1));
      |                     ^~~~
Language: C++

 /*
Write a program which prints the central coordinate (px, py) and the radius r of a circumscribed circle of a triangle which is constructed by three points (x1, y1)(x2, y2)(x3, y3) on the plane surface.
 */

void solve(double a, double b, double c, double d, double e, double f) {
	double px,py,r;
	// ¼ñªüñÂÌð_ y-y1 = y2-y1 / x2-x1 * x-x1 -> y2-y1=a, x2-x1=b, y = a/b*x - a/b*x1-y1 -> y = -b/a*x + c
	double sl1 = -1*(c-a)/(d-b);			// (x1, y1)-(x2, y2)Ì¼ñªüÌX«
	double sl2 = -1*(e-c)/(f-d);			// (x2, y2)-(x3, y3)Ì¼ñªüÌX«
	double mid1x = (a+c)/2; double mid1y = (b+d)/2;
	double mid2x = (c+e)/2; double mid2y = (d+f)/2;
	double t1 = mid1y-sl1*mid1x;
	double t2 = mid2y-sl2*mid2x;
	// y = sl1*x - t1 Æ y = sl2*x - t2 ðA§B -> sl1*x - t1 = sl2*x - t2 -> (sl1-sl2)*x = t1 - t2
	px = (t1-t2)/(sl1-sl2);
	py = sl1*px - t1;
	r = sqr(px,py,a,b);
	printf("%4.3f %4.3f %4.3f",px,py,r);
}

double sqr(double a, double b, double c, double d) {
	// ñÂÌ_Ì£ðßé\bh
	double s = sqrt(pow(max(a,c)-min(a,c), 2) + pow(max(b,d)-min(b,d), 2));
	return s;
}

int main() {
	int n; cin >> n;
	double x1, y1, x2, y2, x3, y3;
	for (int i=0; i<n; i++) {
		cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
		solve(x1,y1,x2,y2,x3,y3);
	}
	return 0;
}

Compiler output:
a.cc: In function 'void solve(double, double, double, double, double, double)':
a.cc:17:13: error: 'sqr' was not declared in this scope
   17 |         r = sqr(px,py,a,b);
      |             ^~~
a.cc:18:9: error: 'printf' was not declared in this scope
   18 |         printf("%4.3f %4.3f %4.3f",px,py,r);
      |         ^~~~~~
a.cc:1:1: note: 'printf' is defined in header '<cstdio>'; this is probably fixable by adding '#include <cstdio>'
  +++ |+#include <cstdio>
    1 |  /*
a.cc: In function 'double sqr(double, double, double, double)':
a.cc:23:29: error: 'max' was not declared in this scope
   23 |         double s = sqrt(pow(max(a,c)-min(a,c), 2) + pow(max(b,d)-min(b,d), 2));
      |                             ^~~
a.cc:23:38: error: 'min' was not declared in this scope
   23 |         double s = sqrt(pow(max(a,c)-min(a,c), 2) + pow(max(b,d)-min(b,d), 2));
      |                                      ^~~
a.cc:23:25: error: 'pow' was not declared in this scope
   23 |         double s = sqrt(pow(max(a,c)-min(a,c), 2) + pow(max(b,d)-min(b,d), 2));
      |                         ^~~
a.cc:23:20: error: 'sqrt' was not declared in this scope; did you mean 'sqr'?
   23 |         double s = sqrt(pow(max(a,c)-min(a,c), 2) + pow(max(b,d)-min(b,d), 2));
      |                    ^~~~
      |                    sqr
a.cc: In function 'int main()':
a.cc:28:16: error: 'cin' was not declared in this scope
   28 |         int n; cin >> n;
      |                ^~~
Language: C++

 /*
Write a program which prints the central coordinate (px, py) and the radius r of a circumscribed circle of a triangle which is constructed by three points (x1, y1)(x2, y2)(x3, y3) on the plane surface.
 */

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

using namespace std;

 /*
http://zo3kirin3.net/?p=297
http://detail.chiebukuro.yahoo.co.jp/qa/question_detail/q104383420
http://www.nn.iij4u.or.jp/~hsat/misc/math/centre/circumcentre.html
 */

int main() {
	int n; cin >> n;
	vector<double> x(3), y(3), x2(3), y2(3);		// x,yªÀWÌXgAx2,y2ªÀWÌñæÌXg
	
	for (int p=0; p<n; p++) {
		cin >> x[0] >> y[0] >> x[1] >> y[1] >> x[2] >> y[2];
		for (int i=0; i<3; i++) {
			x2[i] = pow(x[i], 2);
			y2[i] = pow(y[i], 2);
		}
		
		// eÓÌ·³ðßéBO½ûÌèðp
		double a, b, c, a2, b2, c2;
		a2 = abs(pow(x[2]-x[1], 2) + pow(y[2]-y[1], 2));
        b2 = abs(pow(x[0]-x[2], 2) + pow(y[0]-y[2], 2));
        c2 = abs(pow(x[1]-x[0], 2) + pow(y[1]-y[0], 2));
		a = sqrt(a2); b = sqrt(b2); c = sqrt(c2);
		
		// ÊÏBwÌö®ðpB
		double s, S2;
		s = (a+b+c) / 2;
		S2 = s*(s-a)*(s-b)*(s-c);
		
		// OSðßéBö®ÍWeby[WðQÆ©xNgâÁÄÈ¢©çà¾Å«È¢c
		double px, py;
		px = (a2*(b2+c2-a2)*x[0] + b2*(c2+a2-b2)*x[1] + c2*(a2+b2-c2)*x[2]) / (16 * S2);
        py = (a2*(b2+c2-a2)*y[0] + b2*(c2+a2-b2)*y[1] + c2*(a2+b2-c2)*y[2]) / (16 * S2);
        
        // oÍB®`µÄoÍ·éB¼aÍ¼üÌûö®ÅB
        cout << setprecision(3) << fixed << px << " " << py << " " << sqrt(abs(pow(px-x[0], 2)+pow(py-y[0], 2)) << endl;
	}
	
	return 0;
}

Compiler output:
a.cc: In function 'int main()':
a.cc:47:113: error: invalid operands of types 'double' and '<unresolved overloaded function type>' to binary 'operator<<'
   47 |         cout << setprecision(3) << fixed << px << " " << py << " " << sqrt(abs(pow(px-x[0], 2)+pow(py-y[0], 2)) << endl;
      |                                                                            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~~~~~
Language: C++

 /*
Write a program which prints the central coordinate (px, py) and the radius r of a circumscribed circle of a triangle which is constructed by three points (x1, y1)(x2, y2)(x3, y3) on the plane surface.
 */

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

using namespace std;

 /*
http://zo3kirin3.net/?p=297
http://detail.chiebukuro.yahoo.co.jp/qa/question_detail/q104383420
http://www.nn.iij4u.or.jp/~hsat/misc/math/centre/circumcentre.html
 */

int main() {
	int n; cin >> n;
	vector<double> x(3), y(3), x2(3), y2(3);		// x,yªÀWÌXgAx2,y2ªÀWÌñæÌXg
	
	for (int p=0; p<n; p++) {
		cin >> x[0] >> y[0] >> x[1] >> y[1] >> x[2] >> y[2];
		for (int i=0; i<3; i++) {
			x2[i] = pow(x[i], 2);
			y2[i] = pow(y[i], 2);
		}
		
		// eÓÌ·³ðßéBO½ûÌèðp
		double a, b, c, a2, b2, c2;
		a2 = abs(pow(x[2]-x[1], 2) + pow(y[2]-y[1], 2));
        b2 = abs(pow(x[0]-x[2], 2) + pow(y[0]-y[2], 2));
        c2 = abs(pow(x[1]-x[0], 2) + pow(y[1]-y[0], 2));
		a = sqrt(a2); b = sqrt(b2); c = sqrt(c2);
		
		// ÊÏBwÌö®ðpB
		double s, S2;
		s = (a+b+c) / 2;
		S2 = s*(s-a)*(s-b)*(s-c);
		
		// OSðßéBö®ÍWeby[WðQÆ©xNgâÁÄÈ¢©çà¾Å«È¢c
		double px, py;
		px = (a2*(b2+c2-a2)*x[0] + b2*(c2+a2-b2)*x[1] + c2*(a2+b2-c2)*x[2]) / (16 * S2);
        py = (a2*(b2+c2-a2)*y[0] + b2*(c2+a2-b2)*y[1] + c2*(a2+b2-c2)*y[2]) / (16 * S2);
        
        // oÍB®`µÄoÍ·éB¼aÍ¼üÌûö®ÅB
        cout << setprecision(3) << fixed << px << " " << py << " " << sqrt(abs((px-x[0])*(px-x[0])+(py-y[0])*(py-y[0])) << endl;
	}
	
	return 0;
}

Compiler output:
a.cc: In function 'int main()':
a.cc:47:121: error: invalid operands of types 'double' and '<unresolved overloaded function type>' to binary 'operator<<'
   47 |         cout << setprecision(3) << fixed << px << " " << py << " " << sqrt(abs((px-x[0])*(px-x[0])+(py-y[0])*(py-y[0])) << endl;
      |                                                                            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~~~~~
Language: C++

 /*
Write a program which prints the central coordinate (px, py) and the radius r of a circumscribed circle of a triangle which is constructed by three points (x1, y1)(x2, y2)(x3, y3) on the plane surface.
 */

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

using namespace std;

 /*
http://zo3kirin3.net/?p=297
http://detail.chiebukuro.yahoo.co.jp/qa/question_detail/q104383420
http://www.nn.iij4u.or.jp/~hsat/misc/math/centre/circumcentre.html
 */

int main() {
	int n; cin >> n;
	vector<double> x(3), y(3), x2(3), y2(3);		// x,yªÀWÌXgAx2,y2ªÀWÌñæÌXg
	
	for (int p=0; p<n; p++) {
		cin >> x[0] >> y[0] >> x[1] >> y[1] >> x[2] >> y[2];
		for (int i=0; i<3; i++) {
			x2[i] = x[i]*x[i];
			y2[i] = y[i]*y[i];
		}
		
		// eÓÌ·³ðßéBO½ûÌèðp
		double a, b, c, a2, b2, c2;
		a2 = abs((x[2]-x[1])*(x[2]-x[1]) + (y[2]-y[1])*(y[2]-y[1]));
        b2 = abs((x[0]-x[2])*(x[0]-x[2]) + (y[0]-y[2])*(y[0]-y[2]));
        c2 = abs((x[1]-x[0])*(x[1]-x[0]) + (y[1]-y[0])*(y[1]-y[0]));
		a = sqrt(a2); b = sqrt(b2); c = sqrt(c2);
		
		// ÊÏBwÌö®ðpB
		double s, S2;
		s = (a+b+c) / 2;
		S2 = s*(s-a)*(s-b)*(s-c);
		
		// OSðßéBö®ÍWeby[WðQÆ©xNgâÁÄÈ¢©çà¾Å«È¢c
		double px, py;
		px = (a2*(b2+c2-a2)*x[0] + b2*(c2+a2-b2)*x[1] + c2*(a2+b2-c2)*x[2]) / (16 * S2);
        py = (a2*(b2+c2-a2)*y[0] + b2*(c2+a2-b2)*y[1] + c2*(a2+b2-c2)*y[2]) / (16 * S2);
        
        // oÍB®`µÄoÍ·éB¼aÍ¼üÌûö®ÅB
        cout << setprecision(3) << fixed << px << " " << py << " " << sqrt(abs((px-x[0])*(px-x[0])+(py-y[0])*(py-y[0])) << endl;
	}
	
	return 0;
}

Compiler output:
a.cc: In function 'int main()':
a.cc:47:121: error: invalid operands of types 'double' and '<unresolved overloaded function type>' to binary 'operator<<'
   47 |         cout << setprecision(3) << fixed << px << " " << py << " " << sqrt(abs((px-x[0])*(px-x[0])+(py-y[0])*(py-y[0])) << endl;
      |                                                                            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~~~~~