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<iomanip>
#include<cmath>
using namespace std;
int main()
{
	int n,i;
	double x1,y1,x2,y2,x3,y3,x0,y0,r;
	while(cin>>n)
	{
		for(i = 0;i < n;i++)
		{
			cin>>x1>>y1>>x2>>y2>>x3>>y3;
			x0=((y3-y1)*(y2*y2-y1*y1)+(y3-y1)*(x2*x2-x1*x1)-(y1-y2)*(y1*y1-y3*y3)-(y1-y2)*(x1*x1-x3*x3))/(2*(y1-y2)*(x3-x1)-2*(y3-y1)*(x1-x2));  
        	y0=(y3*y3-y1*y1-2*x0*(x3-x1)-x1*x1+x3*x3)/(2*(y3-y1));  
        	r=sqrt((y0-y2)*(y0-y2)+(x0-x2)*(x0-x2));
        	cout<<setprecision(3)<<setiosflags(ios::fixed|ios::showpoint)<<x0<<' '<<y0<<' '<<r<<endl;
		}
	}
	return 0;
}

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;
}

C++: #include <iostream>
#include <cstdio>
#include <queue>
#include <algorithm>
#include <cmath>
#define INF 100000000
using namespace std;
#define pw(a) (a)*(a)

int main(){
  double x1,x2,x3,y1,y2,y3;
  int n;
  cin >> n;
  while(n--){
    cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
    double a,b,l,m,n;
    a = -1*(pw(x1) - pw(x2) + pw(y1) - pw(y2));
    b = -1*(pw(x1) - pw(x3) + pw(y1) - pw(y3));
    l = (a*(y1-y3)+b*(y1-y2))/((y1-y3)*(x1-x2)-(x1-x3)*(y1-y2));
    m = (b-(x1-x3)*l)/(y1-y3);
    n = (x1*l + y1*m) - (pw(x1) + pw(y1));
    printf("%.3f %.3f %.3f\n",(float)-l/2,(float)-m/2,(float)sqrt((pw(l) + pw(m) - 4*n))/2);
  }
  return 0;
}

C++: #include<cstdio>
#include<iostream>
#include<cmath>
#include<algorithm>
#define SQ(x) ((x)*(x))
using namespace std;

int main(){
  int n;
  double x1,y1,x2,y2,x3,y3;
  double a,b,c,d,e,f,l,C,r,xp,yp,m; // 3辺
  cin >> n;
    for(int i=0;i<n;i++){
      cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
      a = sqrt((x2-x1)*(x2-x1)+(y2-y1)*(y2-y1));
      b = sqrt((x2-x3)*(x2-x3)+(y2-y3)*(y2-y3));
      c = sqrt((x3-x1)*(x3-x1)+(y3-y1)*(y3-y1));
      C = fabs(1.0-C*C);
      if(C == 0)C = 1;
      if(c == 0)c = 1;
      C = (sqrt(C)); // sinθに変更
      r = (c/2*C); // 接弦定理
    
      a = (x1 - x2);
      b = (y1 - y2);
      c = -1 * (SQ(x1) - SQ(x2) + SQ(y1) - SQ(y2));
      d = (x1 - x3);
      e = (y1 - y3);
      f = -1 * (SQ(x1) - SQ(x3) + SQ(y1) - SQ(y3));
    
      l = (c * e - b * f) / (e * a - b * d);
      m = (d * c - a * f) / (d * b - e * a);
    
      printf("%.3f %.3f %.3f\n", l / -2.0, m / -2.0, r);
  }
}

C++: #include<iostream>
#include<iomanip>
#include<cmath>
using namespace std;

int main ()
{
    int num;
    double x1,y1,x2,y2,x3,y3;

    cin >> num;

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

        py = (-x2*x3*x3+x2*x2*x3-x2*y3*y3+y2*y2*x3) / (2*x3*y2-2*x2*y3);
        px = (2*(y1-y2)*py+x2*x2-x1*x1+y2*y2-y1*y1) / (2*x2-2*x1);
        r = (px-x1)*(px-x1) + (py-y1)*(py-y1);

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

    }



    return 0;
}

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

#define t(a) (a)*(a)

using namespace std;

int main(){
    double x[3],y[3],a1,a2,b1,b2,c1,c2,rx,ry,r;
    int n;
    cin >> n;
    for(int j=0;j<n;j++){
        for(int i=0;i<3;i++) cin >> x[i] >> y[i];
        a1 = 2*(x[1]-x[0]);
        b1 = 2*(y[1]-y[0]);
        c1 = t(x[0])-t(x[1])+t(y[0])-t(y[1]);
        a2 = 2*(x[2]-x[0]);
        b2 = 2*(y[2]-y[0]);
        c2 = t(x[0])-t(x[2])+t(y[0])-t(y[2]);
        rx = (b1*c2-b2*c1)/(a1*b2-a2*b1);
        ry = (c1*a2-c2*a1)/(a1*b2-a2*b1);
        r=sqrt(t(x[0]-rx)+t(y[0]-ry));
        printf("%.3f %.3f %.3f\n",rx,ry,r);
    }
    return 0;
}

C++: #include <iostream>
#include <math.h>

using namespace std;

int main(){
	int n;
	cin >> n;

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

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

		px = (x1 + x2 + x3) / 3;
		py = (y1 + y2 + y3) / 3;
		r = sqrt((x1-px)*(x1-px) + (y1-py)*(y1-py));

		printf("%.3f %.3f %.3f\n", px, py, r);
	}

	return 0;
}

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

using namespace std;

const double eps = 1e-12;

int main() {
    int n;
    cin >> n;
    for (int i = 0; i < n; i++) {
        complex<double> p1, p2, p3, m1, m2, d1, d2;
        cin >> p1.real() >> p1.imag() >> p2.real() >> p2.imag() >> p3.real() >> p3.imag();
        m1 = (p1 + p2) / 2.0;
        m2 = (p2 + p3) / 2.0;
        d1 = polar(1.0, arg(p2 - p1) + M_PI_2);
        d2 = polar(1.0, arg(p3 - p2) + M_PI_2);
        
        double t;
        t = (d1.real() * m1.imag() + d1.imag() * m2.real() - m1.real() * d1.imag() - d1.real() * m2.imag()) / (d1.real() * d2.imag() - d2.real() * d1.imag());
        
        double x = m2.real() + t * d2.real();
        double y = m2.imag() + t * d2.imag();
        double r = abs(complex<double>(x,y) - p1);
        
        printf("%.3lf %.3lf %.3lf\n", x, y, r);
    }
    return 0;
}

C++: #include <iostream>
#include <iomanip>
#include <algorithm>
#include <cmath>
#include <string>

using namespace std;

int main() {
  int n;
  double x1, x2, x3, y1, y2, y3;
  double a1, a2, b1, b2, c1, c2;
  double x, y, r;
  cin >> n;
  for (int i = 0; i < n; i++) {
    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;

    x = (b1*c2 - b2 * c1) / (a1*b2 - a2*b1);
    y = (c1*a2 - c2*a1) / (a1*b2 - a2*b1);
    r = sqrt((x-x1)*(x-x1) + (y-y1)*(y-y1));

    x += 0.0005;
    y += 0.0005;
    r += 0.0005;

    x *= 1000;
    y *= 1000;
    r *= 1000;

    cout << fixed << setprecision(3) << ((double)((int)x))/1000 << " " << ((double)((int)y))/1000 << " " << ((double)((int)r))/1000 << endl;
  }
  return 0;
}