Go: package main

import (
	"fmt"
	"math"
)

func main() {
	n := scanInt()
	for i := 0; i < n; i++ {
		cal()
	}
}

func scanInt() int {
	var n int
	fmt.Scanf("%d", &n)
	return n
}

func cal() {
	var x1, y1, x2, y2, x3, y3 float64
	fmt.Scanf("%f%f%f%f%f%f", &x1, &y1, &x2, &y2, &x3, &y3)
	a := 2 * (x1 - x2)
	b := 2 * (y1 - y2)
	c := 2 * (x1 - x3)
	d := 2 * (y1 - y3)
	e := x1*x1 - x2*x2 + y1*y1 - y2*y2
	f := x1*x1 - x3*x3 + y1*y1 - y3*y3

	px := (d*e - b*f) / (a*d - b*c)
	py := (a*f - c*e) / (a*d - b*c)

	r := math.Sqrt((x1-px)*(x1-px) + (y1-py)*(y1-py))
	fmt.Printf("%.3f %.3f %.3f\n", px, py, r)
}

C++: #include <iostream>
#include <cmath>
#include <stdio.h>

using namespace std;

struct point{
     double x, y;
};

void renritu(point p1, point p2, double *a, double *b, double *c){
    *a=2*(p2.x-p1.x);
    *b=2*(p2.y-p1.y);
    *c=p1.x*p1.x+p1.y*p1.y-(p2.x*p2.x+p2.y*p2.y);
}

int main(void){
    int i,n;
    point p1,p2,p3;
    cin >> n;
    for(i=0;i<n;i++){
        double a1,b1,c1,a2,b2,c2,r;
        cin >> p1.x >> p1.y >> p2.x >> p2.y >> p3.x >> p3.y;
        renritu(p1,p2,&a1,&b1,&c1);
        renritu(p1,p3,&a2,&b2,&c2);
        p3.x=-(b2*c1-b1*c2)/(a1*b2-a2*b1);
        p3.y=-(a1*c2-a2*c1)/(a1*b2-a2*b1);
        r=sqrt((p3.x-p1.x)*(p3.x-p1.x)+(p3.y-p1.y)*(p3.y-p1.y));
        printf("%.3lf %.3lf %.3lf\n",round(p3.x*1000)/1000,round(p3.y*1000)/1000, round(r*1000)/1000);
    }
    return 0;
}

C++: #include<complex>
#include<cstdio>
#include<cmath>
using namespace std;
typedef complex<double> P;
double F(double a,double b,double c){
	return acos((b*b+c*c-a*a)/(2*b*c));
}
int main(){
	int n;
	double d,e,f,g,h,i;
	for(scanf("%d",&n);n--;){
		scanf("%lf%lf%lf%lf%lf%lf",&d,&g,&e,&h,&f,&i);
		P a(d,g),b(e,h),c(f,i);
		double A=abs(b-c),B=abs(c-a),C=abs(a-b),
		s=sin(2*F(A,B,C)),t=sin(2*F(B,C,A)),u=sin(2*F(C,A,B)),v=s+t+u;
		printf("%.3f %.3f %.3f\n",(d*s+e*t+f*u)/v,(g*s+h*t+i*u)/v,A/sin(F(A,B,C))/2.);
	}
}

C++: #include <iostream>
#include<string>
#include<cmath>
#include<algorithm>
#include<cctype>
#include<queue>
#include<stack>
#include<stdio.h>
#include<vector>
#include<set>
#include<map>
#include<iomanip>
#define rep(i,n) for(int i=0;i<n;i++)
typedef int long long ll;
 
using namespace std;
int main(){
    int n;
    cin>>n;
    for(int i=0;i<n;i++){
    double a,b,c,d,e,f;
    cin>>a>>b>>c>>d>>e>>f;
    double x,y;
    y=((e-a)*(a*a+b*b-c*c-d*d)-(c-a)*(a*a+b*b-e*e-f*f))/(2*(e-a)*(b-d)-2*(c-a)*(b-f));
    if(c-a!=0){
         x=(2*(b-d)*y-a*a-b*b+c*c+d*d)/(2*(c-a));
    }else{
        x=(2*(b-f)*y-a*a-b*b+e*e+f*f)/(2*(e-a));
    }
    double r=sqrt(pow(x-a,2)+pow(y-b,2));
    printf("%.3f %.3f %.3f\n",x,y,r);
    }
     
     
    return 0;
}

C++: #include<iostream>
#include<cmath>
#include<algorithm>
#include<iomanip>
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() {
	cout << setprecision(4);
	int n;
	cin >> n;
	for (int i = 0; i < n; i++) {
		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);
		double k = distance(p[0], s);
		s.x = round(s.x * 1000) / 1000;
		s.y = round(s.y * 1000) / 1000;
		k = round(k * 1000) / 1000;
		cout << s.x << " " << s.y << " " << k << endl;
	}
	return 0;
}

C++: #include <iostream>
#include <cstdio>
#include <complex>
#include <cmath>

using namespace std;

typedef complex<double> Point;

bool eqv(double d1, double d2) {
    return abs(d1-d2) < 1e-10;
}

double r_(double x) {
    if(abs(x) < 0.001) return 0;
    return x;
}

int main() {
    int N;

    cin >> N;
    while(N--) {
        double x1, x2, x3, y1, y2, y3;
        cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
        Point p1(x1, y1), p2(x2, y2), p3(x3, y3);

        //³·è
        double R = abs(abs(p3-p2) / sin(arg(p2-p1) - arg(p3-p1))) / 2;

        Point vb = p3-p2;
        double len = sqrt(R*R - norm(vb)/4.0);
        Point vbh = vb * Point(0, 1);
        Point center = p2 + vb/2.0 + vbh*len/abs(vbh);
        if(eqv(abs(center-p1), R) && eqv(abs(center-p2), R) && eqv(abs(center-p3), R)) {}
        else center = p2 + vb/2.0 - vbh*len/abs(vbh);
        printf("%.3f %.3f %.3f\n", center.real(), center.imag(), R);
    }
    return 0;
}

C++: #include <iostream>
#include <iomanip>
#include <vector>
#include <string>
#include <stack>
#include <queue>
#include <deque>
#include <set>
#include <map>
#include <algorithm>
#include <sstream>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <numeric>
#include <cmath>
#include <climits>
#include <limits>
#include <cfloat>
#include <fstream>
using namespace std;

int main()
{
//	cut here before submit 
//	freopen("testcase.cct", "r", stdin);
	string str = "";
	string res = "";
	int n;

	getline (cin, str );
	stringstream ssn(str);
	ssn >> n;

	int i,j;
	for (i = 0; i < n; ++i){
		getline (cin, str );
		stringstream ss(str);
		vector <double> X(3, 0.);
		vector <double> Y(3, 0.);
		for (j = 0; j < 3; ++j){
			double x, y;
			ss >> x >> y;
//			cout << '(' << x << ',' << y << ')' << endl;
			X[j] = x; Y[j] = y;
		} // end for
		vector <double> mx(3, 0.);
		vector <double> my(3, 0.);

		for (j = 0; j < 3; ++j){
			mx[j] = (X[j] + X[(j+1) % 3])/2.;
			my[j] = (Y[j] + Y[(j+1) % 3])/2.;
//			cout << '(' << mx[j]<< ',' << my[j] << ')' << endl;
		} // end for
		vector <double> a(3, 0.);
		vector <double> b(3, 0.);
		vector <double> c(3, 0.);

		for (j = 0; j < 3; ++j){
			if (X[(j+1) % 3] == X[j]){
				a[j] = 0.0;
				b[j] = 1.0;
				c[j] = -my[j];
			}else if (Y[(j+1) % 3] == Y[j]){
				a[j] = 1.0;
				b[j] = 0.0;
				c[j] = -mx[j];
			}else{
				a[j] = (X[(j+1) % 3] - X[j]);
				b[j] = (Y[(j+1) % 3] - Y[j]);
 				c[j] = -a[j]*mx[j] - b[j]*my[j];
			} // end if
		} // end for
		vector <double> cx (3, X[0]);
		vector <double> cy (3, Y[0]);
		set <double> Cx, Cy;
		for (j = 0; j < 3; ++j){
			//cout << a[j] << ' ' << b[j] << ' ' << c[j] << endl;
			if (a[j] == 0. && b[j] != 0.) {
				cy[j] = -c[j]/b[j];
			}else if (a[(j+1) % 3] == 0. && b[(j+1) % 3] != 0.){
				cy[j] = -c[(j+1) % 3]/b[(j+1) % 3];
			} // end if
			if (a[j] != 0. && b[j] == 0.){
				cx[j] = -c[j]/a[j];
			}else if (a[(j+1) % 3] != 0. && b[(j+1) % 3] == 0.){
				cx[j] = -c[(j+1) % 3]/a[(j+1) % 3];
			} // end if
			if (cx[j] == X[0] || cy[j] == Y[0] ){
				double D = a[j]*b[(j+1) % 3] - b[j]*a[(j+1) % 3];
				if (cx[j] == X[0]){
					cx[j] = ( -b[(j+1) % 3]*c[j] + b[j]*c[(j+1) % 3])/D;
				} // end if
				if (cy[j] == Y[0]){
					cy[j] = (  a[(j+1) % 3]*c[j] - a[j]*c[(j+1) % 3])/D;
				} // end if
			} // end if
			Cx.insert (cx[j]);
			Cy.insert (cy[j]);
	//		cout << '(' << cx[j] << ',' << cy[j] << ')' << endl;	
		} // end for
		double CX = *(Cx.begin() );
		double CY = *(Cy.begin() );
		double R = sqrt( (CX - X[0])*(CX - X[0]) + (CY - Y[0])*(CY - Y[0]) );

		cout.setf( ios::fixed ); 
		cout.precision(3);
		cout <<  CX << ' ' << CY << ' ' << R << endl;
 	} // end for

		
	return 0;
}

C++: #include<complex>
#include<cstdio>
#include<cmath>
using namespace std;
typedef complex<double> P;
#define F(a,b,c) acos((b*b+c*c-a*a)/2/b/c)
int main(){
	double n,d,e,f,g,h,i;
	for(scanf("%d",&n);n--;){
		scanf("%lf%lf%lf%lf%lf%lf",&d,&g,&e,&h,&f,&i);
		P a(d,g),b(e,h),c(f,i);
		double A=abs(b-c),B=abs(c-a),C=abs(a-b),
		s=sin(2*F(A,B,C)),t=sin(2*F(B,C,A)),u=sin(2*F(C,A,B)),v=s+t+u;
		printf("%.3f %.3f %.3f\n",(d*s+e*t+f*u)/v,(g*s+h*t+i*u)/v,A/sin(F(A,B,C))/2);
	}
}