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 <set>
#include <map>
#include <list>
#include <queue>
#include <stack>
#include <cmath>
#include <ctype.h>
#include <ctime>
#include <cstdio>
#include <vector>
#include <string>
#include <bitset>
#include <cctype>
#include <cstdlib>
#include <cstring>
#include <utility>
#include <numeric>
#include <complex>
#include <sstream>
#include <fstream>
#include <iomanip>
#include <cassert>
#include <iostream>
#include <iterator>
#include <algorithm>

using namespace std;

#define REP(i, x, n) for(int i = x; i < n; i++)
#define rep(i, n) REP(i, 0, n)
#define lengthof(x) (sizeof(x) / sizeof(*(x)))
#define FILL(ptr, value) FILL_((ptr), sizeof(ptr)/sizeof(value), (value))
template <typename T>
void FILL_(void * ptr, size_t size, T value){
  std::fill((T*)ptr, (T*)ptr+size, value);
}
//4方向ベクトル→↑←↓
int dx[] ={1,0,-1,0};
int dy[] ={0,-1,0,1};

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 a =(x1-x2);
    double b =(y1-y2);
    double c = -(pow(x1,2)+pow(y1,2))+(pow(x2,2)+pow(y2,2));
    double d =(x2-x3);
    double e =(y2-y3);
    double f =-(pow(x2,2)+pow(y2,2))+(pow(x3,2)+pow(y3,2));
    double l =(c*e-f*b)/(a*e-d*b);
    double m =(c*d-a*f)/(b*d-a*e);
    double n =-(pow(x1,2)+pow(y1,2))-(l*x1+m*y1);
    double x = -l/2;
    x +=0.0005;
    x =x*1000;
    x =(int)x;
    x =x/1000;
    double y =-m/2;
    y +=0.0005;
    y =y*1000;
    y =(int)y;
    y =y/1000;
    double r =sqrt(pow(l,2)+pow(m,2)-4*n)/2;
    r +=0.0005;
    r =r*1000;
    r =(int)r;
    r =r/1000;
    printf("%.3f %.3f %.3f",x,y,r);
  }
  
  return 0;
}

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