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(void){
  int n;
  cin>>n;
  long double x1,y1,x2,y2,x3,y3;
  for(int i=0;i<n;i++){
    cin>>x1>>y1>>x2>>y2>>x3>>y3;
    long double a,b,c,d,px,py,R,det;
    a=x3-x1;
    b=y3-y1;
    c=x2-x1;
    d=y2-y1;
    det=a*d-b*c;
    px=(a*a*d+b*b*d-b*c*c-b*d*d)/(2*det);
    py=(-1*c*a*a-c*b*b+a*c*c+a*d*d)/(2*det);
    R=sqrt(px*px+py*py);
    printf("%.3Lf %.3Lf %.3Lf\n",round((px+x1)*1000)/1000.0,round((py+y1)*1000)/1000.0,round(R*1000)/1000.0);
  }
  return 0;
}

C++: #include <iostream>
#include <fstream>
#include <algorithm>
#include <vector>
#include <string>
#include <functional>
#include <array>
#include <stack>
#include <queue>
#include <chrono>
#include <numeric>
#include <memory.h>
#include <map>
#include <math.h>
#include <utility>


#pragma warning(disable:4996)
using namespace std;
#define REP(i,n) for(int i = 0 ; i < n ; ++i)
typedef long long Int;
const double PI = 3.141592653589793238;
const Int INF = 999999999999;
typedef pair<int, int> P;


double A[2][2];
double C[2];


int main()
{
	int n;
	cin >> n;
	REP(i, n){
		double x1, x2, x3, y1, y2, y3;
		cin >> x1>> x2 >> x3 >> y1 >> y2 >> y3;

		double x21 = x2 - x1;
		double x31 = x3 - x1;
		double y21 = y2 - y1;
		double y31 = y3 - y1;

		double xc = ((y31*(x21*x21 + y21*y21)) - (y21*(x31*x31 + y31*y31))) /
			(2 * (x21*y31 - y21*x31));

		double yc = ((x21*(x31*x31 + y31*y31)) - (x31*(x21*x21 + y21*y21))) /
			(2 * (x21*y31 - y21*x31));	
		
		double d = (xc - x1)*(xc - x1) + (yc - y1)*(yc - y1);
		printf("%.3lf %.3lf %.3lf", xc, yc, sqrt(d));


	}

}

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

using namespace std;

int main(){
	int n;
	double p,q,r;
	double a1,a2,b1,b2,c1,c2;
	double x1,x2,x3,y1,y2,y3;
	
	scanf("%d",&n);
	for(int i=0;i<n;i++){
		scanf("%lf%lf%lf%lf%lf%lf",&x1,&y1,&x2,&y2,&x3,&y3);
		a1 = 2*(x2-x1);
		b1 = 2*(y2-y1);
		c1 = (x1*x1)+(y1*y1)-(x2*x2)-(y2*y2);
		a2 = 2*(x3-x1);
		b2 = 2*(y3-y1);
		c2 = (x1*x1)+(y1*y1)-(x3*x3)-(y3*y3);
		p = ((b1*c2)-(b2*c1))/((a1*b2)-(a2*b1));
		q = ((a2*c1)-(a1*c2))/((a1*b2)-(a2*b1));
		r = sqrt(((x1-p)*(x1-p))+((y1-q)*(y1-q)));
		printf("%.3f %.3f %.3f\n",p,q,r);
	}
}

C++: #include <bits/stdc++.h>
using namespace std;
#define all(c) (c).begin(),(c).end()
#define rep(i,n) for(int i=0; i<(int)(n); i++)
#define iter(c) __typeof((c).begin())
#define tr(it,c) for(iter(c) it=(c).begin(); it!=(c).end(); it++)
#define pb(a) push_back(a)
#define mp(a,b) make_pair(a,b)
#define pr(a) cout << (a) << endl
#define F first
#define S second

const double EPS = 1e-10;
const double INF = 1e12;
typedef complex<double> P; //Point
namespace std {
  bool operator < (const P& a, const P& b) {
    return real(a) != real(b) ? real(a) < real(b) : imag(a) < imag(b);
  }
}
double cross(const P& a, const P& b) {//外積
  return imag(conj(a)*b);
}
double dot(const P& a, const P& b) {//内積
  return real(conj(a)*b);
}
struct L : public vector<P> { // Line
  L(const P &a, const P &b) {
    push_back(a); push_back(b);
  }
};
typedef vector<P> G;
struct C {  //Circle
  P p; double r;
  C(const P &p, double r) : p(p), r(r) { }
};

int ccw(P a, P b, P c) {
  b -= a; c -= a;
  if (cross(b, c) > EPS)   return +1;       // counter clockwise
  if (cross(b, c) < -EPS)   return -1;       // clockwise
  if (dot(b, c) < -EPS)     return +2;       // c--a--b on line
  if (norm(b) < norm(c)) return -2;       // a--b--c on line
  return 0;                               // a--c--b on line
}

//cross  L line  S senbun  P point
bool intersectLL(const L &l, const L &m) {
  return abs(cross(l[1]-l[0], m[1]-m[0])) > EPS || // non-parallel
         abs(cross(l[1]-l[0], m[0]-l[0])) < EPS;   // same line
}
bool intersectLS(const L &l, const L &s) {
  return cross(l[1]-l[0], s[0]-l[0])*       // s[0] is left of l
         cross(l[1]-l[0], s[1]-l[0]) < EPS; // s[1] is right of l
}
bool intersectLP(const L &l, const P &p) {
  return abs(cross(l[1]-p, l[0]-p)) < EPS;
}
bool intersectSS(const L &s, const L &t) {
  return ccw(s[0],s[1],t[0])*ccw(s[0],s[1],t[1]) <= 0 &&
         ccw(t[0],t[1],s[0])*ccw(t[0],t[1],s[1]) <= 0;
}
bool intersectSP(const L &s, const P &p) {
  return abs(s[0]-p)+abs(s[1]-p)-abs(s[1]-s[0]) < EPS; // triangle inequality
}

//distance
P projection(const L &l, const P &p) {
  double t = dot(p-l[0], l[0]-l[1]) / norm(l[0]-l[1]);
  return l[0] + t*(l[0]-l[1]);
}
P reflection(const L &l, const P &p) {
  return p + 2.0*(projection(l, p) - p);
}
double distanceLP(const L &l, const P &p) {
  return abs(p - projection(l, p));
}
double distanceLL(const L &l, const L &m) {
  return intersectLL(l, m) ? 0 : distanceLP(l, m[0]);
}
double distanceLS(const L &l, const L &s) {
  if (intersectLS(l, s)) return 0;
  return min(distanceLP(l, s[0]), distanceLP(l, s[1]));
}
double distanceSP(const L &s, const P &p) {
  const P r = projection(s, p);
  if (intersectSP(s, r)) return abs(r - p);
  return min(abs(s[0] - p), abs(s[1] - p));
}
double distanceSS(const L &s, const L &t) {
  if (intersectSS(s, t)) return 0;
  return min(min(distanceSP(s, t[0]), distanceSP(s, t[1])),
             min(distanceSP(t, s[0]), distanceSP(t, s[1])));
}
P crosspoint(const L &l, const L &m) {
  double A = cross(l[1] - l[0], m[1] - m[0]);
  double B = cross(l[1] - l[0], l[1] - m[0]);
  if (fabs(A) < EPS && fabs(B) < EPS) return m[0]; // same line
  if (fabs(A) < EPS) assert(false); // !!!PRECONDITION NOT SATISFIED!!!
  return m[0] + B / A * (m[1] - m[0]);
}

double abs2(const P &a){ return a.real()*a.real()+a.imag()*a.imag(); }
C circumcircle(const P &a,P b,P c){
  b-=a; c-=a;
  double A2=abs2(b-c),B2=abs2(b),C2=abs2(c);
  double d=2*cross(b,c);
  double nx=c.imag()*B2-b.imag()*C2;
  double ny=b.real()*C2-c.real()*B2;
  double r2=A2*B2*C2/(d*d);
  return C{a+P{nx/d,ny/d},sqrt(r2)};
}
int main() {
  int T;
  cin >> T;
  while(T--) {
    P a,b,c;
    double z[6];
    for(int i=0; i<6; i++) cin >> z[i];
    a.real(z[0]);
    a.imag(z[1]);
    b.real(z[2]);
    b.imag(z[3]);
    c.real(z[4]);
    c.imag(z[5]);
    C x=circumcircle(a,b,c);
    printf("%.3f %.3f %.3f\n",x.p.real(),x.p.imag(),x.r);
  }
  return 0;
}

C++: #include<stdio.h>
#include<math.h>
#define P(x) pow(double(x),2)



void c_xpypr(){


}


int main(){


	int i,j,k;
	int n;
	double x[3],y[3];
	double xp,yp,r;
	double a1,a2,b1,b2,c1,c2;
	
	while((scanf("%d",&n))!=EOF){
		for(i=0;i<3;i++){
			scanf("%lf",&x[i]);
			scanf("%lf",&y[i]);
		}
		a1=2*(x[1]-x[0]);
		a2=2*(x[2]-x[1]);
		b1=2*(y[1]-y[0]);
		b2=2*(y[2]-y[1]);
		c1=(P(x[0])-P(x[1])+P(y[0])-P(y[1]));
		c2=(P(x[1])-P(x[2])+P(y[1])-P(y[2]));
	
		xp=(b1*c2-b2*c1)/(a1*b2-a2*b1);
		yp=(c1*a2-c2*a1)/(a1*b2-a2*b1);
		r=(double)(sqrt((long double)(((xp-x[0])*(xp-x[0]))+((yp-y[0])*(yp-y[0])))));	


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

	}



}