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 <map>
#include <vector>
#include <cmath>
#include <iomanip>
#include <string>
#include <queue>
#include <algorithm>
#include <cctype>
#define shosu(x) fixed<<setprecision(x)
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
typedef pair<double,double> pdd;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<P> vp;
typedef vector<vp> vvp;
typedef pair<int,P> pip;
typedef vector<pip> vip;
const int inf=1<<30;
const double pi=acos(-1);
const double eps=1e-8;

struct point{
	double x,y;
	point operator+(point Gep){
		return point{x+Gep.x,y+Gep.y};
	}
	point operator-(point Gep){
		return point{x-Gep.x,y-Gep.y};
	}
	point operator*(double Gex){
		return point{x*Gex,y*Gex};
	}
	point operator/(double Gex){
		if(!Gex) return point{0,0}; 
		return point{x/Gex,y/Gex};
	}
	bool operator==(point Gep){
		return fabs(x-Gep.x)<eps&&fabs(y-Gep.y)<eps;
	}
};

class Geom{
	private:
	vector<point> Ge;
	vector<pair<point,point> > Geseg,Geline;
	public:
	void line_push(point Gex,point Gey){
		Geline.push_back(make_pair(Gex,Gey));
	}
	void seg_push(point Gex,point Gey){
		Geseg.push_back(make_pair(Gex,Gey));
	}
	void point_push(point Gex){
		Ge.push_back(Gex);
	}
	point DIP(pair<point,point> Gex,pdd Gey){
		double Gea=Gey.first,Geb=Gey.second;
		point Ge1=Gex.first,Ge2=Gex.second;
		return (Ge1*Geb+Ge2*Gea)/(Gea+Geb);
	}
	point POI(pair<point,point>Gex,pair<point,point> Gey){
		pair<point,point> Ge1(PRO(Gex,Gey.first),PRO(Gex,Gey.second));
		pdd Ger(EXTLEN(Gey.first,Ge1.first),EXTLEN(Gey.second,Ge1.second));
		return DIP(Ge1,Ger);
	}
	double IP(point Gex,point Gey){
		return Gex.x*Gey.x+Gex.y*Gey.y;
	}
	double CP(point Gex,point Gey){
		return Gex.x*Gey.y-Gey.x*Gex.y;
	}
	double LEN(point Gex){
		return sqrt(Gex.x*Gex.x+Gex.y*Gex.y);
	}
	double EXTLEN(point Gex,point Gey){
		return LEN(Gex-Gey);
	}
/*	double SLEN(pair<point,point> Gex,pair<point,point> Gey){
		double Getmp=PJUD(Gex,Gey);
		if(Getmp==inf) return 0;
		point Ge1=Gex.first,Ge2=Gex.second,Ge3=Gey.first,Ge4=Gey.second;
		if(Getmp==-1) return min(min(EXTLEN(Ge1,Ge3),EXTLEN(Ge1,Ge4)),min(EXTLEN(Ge2,Ge3),EXTLEN(Ge2,Ge4)));
		if()
	}*/
	double HELON(point Gex,point Gey,point Gez){
		double Gea=EXTLEN(Gex,Gey),Geb=EXTLEN(Gey,Gez),Gec=EXTLEN(Gey,Gez);
		double Ges=(Gea+Geb+Gec)/2;
		return sqrt(Ges*(Ges-Gea)*(Ges-Geb)*(Ges-Gec));
	}
	point PRO(pair<point,point> Gea,point Gex){
		point Ge1=Gex-Gea.second,Ge2=Gea.first-Gea.second;
		return Ge2*(IP(Ge1,Ge2)/(LEN(Ge2)*LEN(Ge2)))+Gea.second;
	}
	point REF(pair<point,point> Gea,point Gex){
		point Ge1=PRO(Gea,Gex);
		return Ge1*2-Gex;
	}
	point REVO(point Gex,point Ger,double Gey){
		point Getmp=Gex-Ger;
		return point{Getmp.x*cos(Gey)-Getmp.y*sin(Gey)+Ger.x,Getmp.x*sin(Gey)+Getmp.y*cos(Gey)+Ger.y};
	}
	point CIR(point Gex,point Gey,point Gez){
		point Ge1=(Gex+Gey)/2,Ge2=(Gey+Gez)/2;
		pair<point,point> Gea(REVO(Gex,Ge1,pi/2),REVO(Gey,Ge1,pi/2)),Geb(REVO(Gey,Ge2,pi/2),REVO(Gez,Ge2,pi/2));
		return POI(Gea,Geb);
	}
	int PJUD(point Gea,point Geb,point Gex){
		if(Gea==Geb||Gex==Geb) return 0;
		point Ge1=Gea-Gex,Ge2=Geb-Gex;
		double Getmp=CP(Ge1,Ge2);
		if(Getmp>eps) return 1;
		if(Getmp<-eps) return 2;
		if(IP(Ge1,Ge2)<eps) return 3;
		if(LEN(Ge1)<LEN(Ge2)) return 4;
		return 5;
	}
	int SJUD(pair<point,point> Gex,pair<point,point> Gey){
		if(four_JUD(Gex.first,Gex.second,Gey.first,Gey.second)){
			int Ge1=PJUD(Gex.first,Gey.first,Gex.second),Ge2=PJUD(Gex.first,Gey.second,Gex.second),Ge3=PJUD(Gey.first,Gex.first,Gey.second),Ge4=PJUD(Gey.first,Gex.second,Gey.second);
			if((Ge1==3||Ge1==4)&&(Ge2==3||Ge2==4)&&(Ge3==3||Ge3==4)&&(Ge4==3||Ge4==4)) return -1;
			return inf;
		}
		if(LJUD(Gex,Gey)==2) return 0;
		point Getmp=POI(Gex,Gey);
		int Ge1=PJUD(Gex.first,Getmp,Gex.second),Ge2=PJUD(Gey.first,Getmp,Gey.second);
		if((!Ge1||Ge1==5)&&(!Ge2||Ge2==5)) return 1;
		return 0;
	}
	int LJUD(pair<point,point> Gex,pair<point,point> Gey){
		point Ge1=Gex.first-Gex.second,Ge2=Gey.first-Gey.second;
		if(!CP(Ge1,Ge2)) return 2;
		if(!IP(Ge1,Ge2)) return 1;
		return 0;
	}
	bool four_JUD(point Gea,point Geb,point Gec,point Ged){
		int Ge1=PJUD(Gea,Geb,Gec),Ge2=PJUD(Gea,Geb,Ged);
		if(Ge1!=1&&Ge1!=2&&Ge2!=1&&Ge2!=2) return 1;
		return 0;
	}
/*	double AREA(){
		double Geans=0;
		for(int i=1;i<Ge.size()-1;i++){
			Geans+=HELON(Ge[0],Ge[i],Ge[i+1]);
		}
		return Geans;
	}*/
	pair<point,point> line_open(int Gex){
		return Geline[Gex];
	}
	point point_open(int Gex){
		return Ge[Gex];
	}
	pair<point,point> seg_open(int Gex){
		return Geseg[Gex];
	}
};

int q;

int main(){
	cout<<shosu(3);
	cin>>q;
	for(int i=0;i<q;i++){
		Geom geo;
		for(int j=0;j<3;j++){
			double x,y;
			cin>>x>>y;
			geo.point_push(point{x,y});
		}
		point ans=geo.CIR(geo.point_open(0),geo.point_open(1),geo.point_open(2));
		cout<<ans.x<<' '<<ans.y<<' '<<geo.EXTLEN(geo.point_open(0),ans)<<endl;
	}
}

C++: //#define _USE_MATH_DEFINES
//#include <cmath>
#include <iostream>
#include <stdio.h>
//#include <stdlib.h>
//#include <iomanip>
//#include <vector>
//#include <string>
//#include <algorithm>
//#include <functional>
//#include <time.h>
//#include <sstream>
//#include <queue>

using namespace std;


int main(){

	int n;
	double ax, ay, bx, by, cx, cy;
	double A, B, C,S2;
	double x, y,r;

	cin >> n;

	while (n--){
		cin >> ax >> ay >> bx >> by >> cx >> cy;

		A = (bx - cx)*(bx - cx) + (by - cy)*(by - cy);
		B = (cx - ax)*(cx - ax) + (cy - ay)*(cy - ay);
		C = (bx - ax)*(bx - ax) + (by - ay)*(by - ay);
		S2 = A*(B + C - A) + B*(C + A - B) + C*(A + B - C);

		x = (A*(B + C - A)*ax + B*(C + A - B)*bx + C*(A + B - C)*cx) / S2;
		y = (A*(B + C - A)*ay + B*(C + A - B)*by + C*(A + B - C)*cy) / S2;

		r = sqrt((x - ax)*(x - ax) + (y - ay)*(y - ay));

		printf("%.3f %.3f %.3f\n", x, y, r);
	}
}

C++: #include <iostream>
#include <cmath>
#include <iomanip>
#define sqr(n) ((n) * (n))
using namespace std;

void equation(double a, double b, double c, double d, double e, double f, double *x, double *y)
{
  *x = (c * e - b * f) / (a * e - b * d);
  *y = (a * f - c * d) / (a * e - b * d);   
}

int main()
{
  int n;
  double x1, y1, x2, y2, x3, y3, x, y;
  cin >> n;
  for(int i = 0; i < n; i++){
    cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
    x = y = 0;
    equation((2.0 * (x2 - x1)), (2.0 * (y2 - y1)), (sqr(x2) + sqr(y2) - sqr(x1) - sqr(y1)), (2.0 * (x3 - x2)), (2.0 * (y3 - y2)), (sqr(x3) + sqr(y3) - sqr(x2) - sqr(y2)), &x, &y);
    cout << fixed << setprecision(3) << x + 0.0001 << ' ' <<  y + 0.0001 << ' ' << sqrt(sqr(x1 - x) + sqr(y1 - y)) + 0.0001 << endl;
  }
}

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

using namespace std;

int main() {
    int n;
    double a, b, c, d, e, f;
    double x1, x2, x3, y1, y2, y3, px, py, r;
    cin >> n;
    while (n--) {
        cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
        a = 2 * (x1 - x2);
        b = 2 * (y1 - y2);
        c = x1*x1 + y1*y1 - x2*x2 - y2*y2;
        d = 2 * (x1 - x3);
        e = 2 * (y1 - y3);
        f = x1*x1 + y1*y1 - x3*x3 - y3*y3;
        px = (c*e - b*f) / (a*e - b*d);
        py = (c*d - a*f) / (b*d - a*e);
        r = sqrt((px - x1)*(px - x1) + (py - y1)*(py - y1));
        printf("%.3f %.3f %.3f\n", px, py, r);
    }
    
    return 0;
}