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 <cstdio>
#include <cmath>

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

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

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

    while(true) {
        cin >> N;
        if(!N) break;

        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 pc1 = (p1+p2) / 2.;
        Point ph1 = (pc1-p1) * Point(0, 1);
        Point pc2 = (p1+p3) / 2.;
        Point ph2 = (pc2-p1) * Point(0, 1);

        Point d = pc2-pc1;
        double ratio = ph2.real() / ph2.imag();
        double a = (d.real()-d.imag()*ratio) / (ph1.real()-ph1.imag()*ratio);
        Point center = pc1 + ph1 * a / abs(ph1);

        int i1 = (int)center.real(), d1 = ((int)((center.real()-i1)*10000)+5)/10;
        int i2 = (int)center.imag(), d2 = ((int)((center.imag()-i2)*10000)+5)/10;
        int i3 = (int)R, d3 = ((int)((R-i3)*10000)+5)/10;
        printf("%d.%03d %d.%03d %d.%03d\n", i1, d1, i2, d2, i3, d3);
    }
    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,x,y,r;
	scanf("%d",&n);
	for(;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=F(A,B,C),t=F(B,C,A),u=F(C,A,B);
		r = A/sin(s)/2.;
		x = ( d*sin(2*s) + e*sin(2*t) + f*sin(2*u) ) /
			( sin(2*s) + sin(2*t) + sin(2*u) );
		y = ( g*sin(2*s) + h*sin(2*t) + i*sin(2*u) ) /
			( sin(2*s) + sin(2*t) + sin(2*u) );
		printf("%.3f %.3f %.3f\n",x,y,r);
	}
}

C++: #include <stdio.h>
#include <math.h>
 
int main()
{
    int n;
    double x1, x2, x3, y1, y2, y3, r, Px, Py;
    
    scanf("%d", &n);
    for(int i = 0; i < n; i++)
    {
        scanf("%lf %lf %lf %lf %lf %lf", &x1, &y1, &x2, &y2, &x3, &y3);
        Px = ((y2-y3)*(x1*x1+y1*y1) + (y3-y1)*(x2*x2+y2*y2) + (y1-y2)*(x3*x3+y3*y3))/(2*(x1*(y2-y3)+x2*(y3-y1)+x3*(y1-y2)));
        Py = ((x2-x3)*(x1*x1+y1*y1) + (x3-x1)*(x2*x2+y2*y2) + (x1-x2)*(x3*x3+y3*y3))/(2*(y1*(x2-x3)+y2*(x3-x1)+y3*(x1-x2)));
        r = sqrt((x1-Px)*(x1-Px)+(y1-Py)*(y1-Py));
        printf("%.3lf %.3lf %.3lf\n",Px, Py, r);
    }
    return 0;
}

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

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

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

		if(y1-y2==0.0 || y1-y3==0.0){
			swap(x1, x2);
			swap(y1, y2);
		}
		if(y1-y2==0.0 || y1-y3==0.0){
			swap(x1, x3);
			swap(y1, y3);
		}

		double a12, b12, a13, b13;
		a12 = -(x1-x2)/(y1-y2);
		a13 = -(x1-x3)/(y1-y3);

		double x12, y12, x13, y13;
		x12 = (x1+x2)/2.0;
		y12 = (y1+y2)/2.0;
		x13 = (x1+x3)/2.0;
		y13 = (y1+y3)/2.0;

		b12 = y12 - a12 * x12;
		b13 = y13 - a13 * x13;

		double xp, yp;
		xp = -(b12-b13)/(a12-a13);
		yp = a12*xp + b12;

		double r;
		r = sqrt(pow((x1-xp),2.0) + pow((y1-yp),2.0));

		printf("%.3f %.3f %.3f\n", xp, yp, r);
	}


	return(0);
}

C++: #include <iostream>
#include <cmath>
#include <algorithm>
#include <string>
#include <stdio.h>
using namespace std;
int main(){
    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 x,y,r1,r;
    double a,b,c,d,e,f;
    a=2*x1-2*x2;
    b=2*y1-2*y2;
    c=x1*x1-x2*x2+y1*y1-y2*y2;
    d=2*x2-2*x3;
    e=2*y2-2*y3;
    f=x2*x2-x3*x3+y2*y2-y3*y3;
        x=(b*f-e*c)/(a*e-d*b);
        y=(c*d-f*a)/(a*e-d*b);
        
    r1=(x1-x)*(x1-x)+(y1-y)*(y1-y);
        r=sqrt(r1);
    
    printf("%.3f %.3f %.3f\n",x,y,r);
}
}

C++: #include <iostream>
#include <stdio.h>
#include <math.h>
using namespace std;
#define ep 0.00001

int main()
{
	double a, b, c, d, p, q;
	double x1, y1, x2, y2, x3, y3;
	double x, y, r;
	double det;
	int n;
	
	/*
	(x - x1)^2 + (y - y1)^2 = (x - x3)^2 + (y - y3)^2
	(x - x2)^2 + (y - y2)^2 = (x - x3)^2 + (y - y3)^2
	
	2(x3 - x1)x + 2(y3 - y1)y = (x3)^2 + (y3)^2 - (x1)^2 - (y1)^2
	2(x3 - x2)x + 2(y3 - y2)y = (x3)^2 + (y3)^2 - (x2)^2 - (y2)^2
	*/
	
	cin >> n;
	for (int i = 0; i < n; i++) {
		cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
		a = 2 * (x3 - x1);
		b = 2 * (y3 - y1);
		c = 2 * (x3 - x2);
		d = 2 * (y3 - y2);
		p = x3 * x3 + y3 * y3 - x1 * x1 - y1 * y1;
		q = x3 * x3 + y3 * y3 - x2 * x2 - y2 * y2;
		
		det = a * d - b * c;
		x = (d * p - b * q) / det + ep;
		y = (a * q - c * p) / det + ep;
		
		r = hypot(x - x1, y - y1);
		printf("%.3f %.3f %.3f\n", x, y, r);
	}
	return 0;
}

C++: #include <iomanip>
#include <iostream>
#include <vector>
#include <string>
#include <map>
#include <algorithm>
#include <complex>

#define REP(i,n) for(int i=0;i<(int)(n);i++)

using namespace std;

typedef long double ld;
typedef complex<ld> P;
typedef vector<P> VP;
const ld eps = 1e-8, pi = acos(-1.0);

#define EQ(a,b) (abs((a)-(b))<eps)

class C { public: P p; ld r; };

ld dot (P a, P b) { return real(conj(a) * b); }
ld cross (P a, P b) { return imag(conj(a) * b); }

VP is_cc(C c1, C c2){
  VP res;
  ld d = abs(c1.p - c2.p);
  ld rc = (d * d + c1.r * c1.r - c2.r * c2.r) / (2 * d);
  ld dfr = c1.r * c1.r - rc * rc;
  if (abs(dfr) < eps) dfr = 0.0;
  else if (dfr < 0.0) return res; // no intersection
  ld rs = sqrt(dfr);
  P diff = (c2.p-c1.p)/d;
  res.push_back(c1.p + diff * P(rc, rs));
  if (dfr != 0.0) res.push_back(c1.p + diff * P(rc, -rs));
  return res;
}

ld circumradius(VP tri) {
  P x = tri[1] - tri[0];
  P y = tri[2] - tri[0];
  ld sxy = cross(x,y)/abs(x)/abs(y);
  return abs(x-y)/sxy/2;
}

P circumcenter(VP tri) {
  ld r = circumradius(tri);
  C c0 = {tri[0], r};
  C c1 = {tri[1], r};
  VP vcc = is_cc(c0, c1);
  if (abs(abs(vcc[0] - tri[2]) - r) < eps) return vcc[0];
  return vcc[1];
}

int main() {
  int n;
  cin>>n;
  REP(i,n) {
    VP p(3);
    REP(j,3) {
      ld x,y;
      cin>>x>>y;
      p[j] = P(x,y);
    }
    P cc = circumcenter(p);
    ld r = circumradius(p);
    cout<<setprecision(3)<<fixed<<real(cc)<<' '<<imag(cc)<<' '<<r<<endl;
  }
  return 0;
}