Go: package main

import (
	"fmt"
	"math"
)

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

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

func circleTriangle() {
	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 <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;

        // ?????\????????????????±???????
        a = sqrt(pow(x2-x3, 2.0) + pow(y2-y3, 2.0));
        b = sqrt(pow(x1-x3, 2.0) + pow(y1-y3, 2.0));
        c = sqrt(pow(x1-x2, 2.0) + pow(y1-y2, 2.0));
        A = acos((b*b+c*c-a*a)/(2.0*b*c));
        r = a/(sin(A)*2.0);

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

C++: #include <iostream>
#include <math.h>
#include <iomanip>
using namespace std;

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

// ?°???°????¬¬??????????????¨?????\
double round(double d) {
    if (d < 0) {
        d *= 1000;
        d -= 0.5;
        int i = d;
        d = i / 1000.0;
    } else {
        d *= 1000;
        d += 0.5;
        int i = d;
        d = i / 1000.0;
    }

    return d;
}

int main() {

    int n;
    cin >> n;

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

        px = ((y1 - y3) * (pow(x1, 2) - pow(x2, 2) + pow(y1, 2) - pow(y2, 2)) - (y1 - y2) * (pow(x1, 2) - pow(x3, 2) + pow(y1, 2) - pow(y3, 2))) / ((x1 - x2) * (y1 - y3) - (x1 - x3) * (y1 - y2)) / 2.0;
        py = ((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))) / ((x1 - x3) * (y1 - y2) - (x1 - x2) * (y1 - y3)) / 2.0;
        r = length(x1, x2, px, py);

        px = round(px);
        py = round(py);
        r = round(r);

        cout << fixed << setprecision(3) << px << " " << py << " " << r << endl;
    }

    return 0;
}

C++: #include <iostream>
#include <iomanip>
#include <cmath>
using namespace std;
int main()
{
	int n;
	double x1, x2, x3;
	double y1, y2, y3;
	cin >> n;
	cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
	double px, py, r;
	double A = (x2 - x1)*(y3 - y2) - (y2 - y1)*(x3 - x2);
	px = 0.5*((y3 - y2)*(x2*x2 - x1*x1 + y2*y2 - y1*y1) - (y2 - y1)*(x3*x3 - x2*x2 + y3*y3 - y2*y2)) / A;
	py = 0.5*(-(x3 - x2)*(x2*x2 - x1*x1 + y2*y2 - y1*y1) + (x2 - x1)*(x3*x3 - x2*x2 + y3*y3 - y2*y2)) / A;
	double a = px - x1;
	double b = py - y1;
	double r0 = (a*a + b*b);
	double r1 = sqrt(r0);
	cout << fixed << setprecision(10) << px << " " << py << " " << r1 <<  endl;
}

C++: #include<complex>
#include<stdio.h>
#define F(a,b,c) 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);std::complex<double> a(d,g),b(e,h),c(f,i);float A=abs(b-c),B=abs(c-a),C=abs(a-b),L=F(A,B,C),s=sin(2*L),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(L)/2);}}

C++: #include <cstdio>
#include <cstring>
#include <algorithm>
#include <string>
#include <cmath>

using namespace std;

int main()
{
	int n;
	scanf("%d", &n);
	for (int i = 0; i < n; ++i)
	{
		double x[3], y[3];
		for (int j = 0; j < 3; ++j)
			scanf("%lf %lf", x+j, y+j);
		
		double a[2], b[2];
		for (int j = 0, c = 0; j < 3 && c < 2; ++j)
		{
			for (int k = j+1; k < 3 && c < 2; ++k)
			{
				if (y[j] == y[k])
					continue;

				a[c] = -(x[k]-x[j])/(y[k]-y[j]);
				b[c] = (y[k]+y[j] - (x[k]+x[j])*a[c])/2;
				++c;
			}
		}
		double px = (b[0]-b[1])/(a[1]-a[0]);
		double py = a[0] * px + b[0];
		double r = sqrt((px-x[0])*(px-x[0])+(py-y[0])*(py-y[0]));
		printf("%f %f %f\n", px, py, r);
	}

	return 0;
}

C++: #include<iostream>
#include<cstdio>
#include<math.h>
using namespace std;
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;
      double  d1 = x1*x1+y1*y1;
      double  d2 = x2*x2+y2*y2;
      double  d3 = x3*x3+y3*y3;
      double  u = 0.5/(x1*y2-x2*y1+x2*y3-x3*y2+x3*y1-x1*y3);
      double  xp = u*(d1*y2-d2*y1+d2*y3-d3*y2+d3*y1-d1*y3);
      double  yp = u*(x1*d2-x2*d1+x2*d3-x3*d2+x3*d1-x1*d3);
      double  r = sqrt((xp-x1)*(xp-x1)+(yp-y1)*(yp-y1));
      printf("%.3f %.3f %.3f\n",xp,yp,r);
   }
   return 0;
}

C++: #include<iostream>
#include<math.h>
#include<iomanip>
using namespace std;

int main()
{
	int i,n,flg=0;
	double x1,x2,x3,y1,y2,y3;
	double m1,m2,xm1,xm2,ym1,ym2,xo,yo,r;
	//m1,m2…辺の法線　xm1,ym1…辺の中点の座標

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

		xm1=(x1+x2)/2;
		xm2=(x2+x3)/2;
		ym1=(y1+y2)/2;
		ym2=(y2+y3)/2;
		if(y1-y2!=0){
			m1=(-1)*(x1-x2)/(y1-y2);
		}else if(y1-y2==0) flg=1;
		if(y2-y3!=0){
			m2=(-1)*(x2-x3)/(y2-y3);
		}else flg=2;
		if(flg==0){
			xo=(m1*xm1-m2*xm2+ym2-ym1)/(m1-m2);
		}else if(flg==1) xo=xm1;
		else if(flg=2) xo=xm2;
		if(flg==1) yo=m2*(xo-xm2)+ym2;
		r=sqrt((x1-xo)*(x1-xo)+(y1-yo)*(y1-yo));
//		cout<<fixed<<setprecision(5)<<m1<<" "<<m2<<endl;
		printf("%.3lf %.3lf %.3lf \n",xo,yo,r);
	}
}

C++: #include <algorithm>
#include <functional>
#include <cmath>
#include <cstdio>
#include <cstdint>
#include <cstdlib>
#include <cstring>
#include <string>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <vector>
#include <list>
#include <stack>
#include <queue>
#include <map>
#include <set>
#include <bitset>
#include <climits>
#include <complex>
  
#define all(c) (c).begin(), (c).end()
#define rep(i,n) for(int i=0;i<(n);i++)
#define pb(e) push_back(e)
#define mp(a, b) make_pair(a, b)
#define fr first
#define sc second
  
const int INF=100000000;
int dx[4]={1,0,-1,0};
int dy[4]={0,1,0,-1};
using namespace std;
typedef complex<double> P;
int n;
  
double cross(P p1,P p2) {
    return (real(p1)*imag(p2) - imag(p1)*real(p2));
}
double calc_S(P p1,P p2,P p3) {
    double ret = 0.0;
    p1 -= p3;
    p2 -= p3;
  
    ret = cross(p1,p2)/2.0;
      
    return abs(ret);
}
  
int main() {
    cin>>n;
    while(n-->0) {
        double x1_,y1_;
        double x2_,y2_;
        double x3_,y3_;
        cin>>x1_>>y1_>>x2_>>y2_>>x3_>>y3_;
        P p1(x1_,y1_);
        P p2(x2_,y2_);
        P p3(x3_,y3_);
        P A = p1-p2;
        P B = p2-p3;
        P C = p1-p3;
        double S = calc_S(p1,p2,p3);
        double R = abs(A)*abs(B)*abs(C)/S;
        R /= 4.0;
          
        P A1 = 2.0*(p2-p1);
        P B1 = 2.0*(p3-p1);
        P C1 = P(norm(p1)-norm(p2),norm(p1)-norm(p3));
        double X = cross(P(imag(A1),imag(B1)),C1)/cross(A1,B1);
        double Y = cross(C1,P(real(A1),real(B1)))/cross(A1,B1);
        printf("%.3lf %.3lf %.3lf\n",X,Y,R);
  
    }
    return 0;
}