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;
		printf("%.3f %.3f %.3f\n",ans.x,ans.y,geo.EXTLEN(geo.point_open(0),ans));
	}
}

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

struct Circles {
	double x;
	double y;
	double r;
};

Circles countCircle(double x1,double y1, double x2, double y2, double x3, double y3){
	double a = ((y2 - y1)*(y3*y3 - y1 * y1 + x3 * x3 - x1 * x1) - (y3 - y1)*(y2*y2 - y1 * y1 + x2 * x2 - x1 * x1)) / (2.0*((x3 - x1)*(y2 - y1) - (x2 - x1)*(y3 - y1)));
	double b = ((x2 - x1)*(x3*x3 - x1 * x1 + y3 * y3 - y1 * y1) - (x3 - x1)*(x2*x2 - x1 * x1 + y2 * y2 - y1 * y1)) / (2.0*((y3 - y1)*(x2 - x1) - (y2 - y1)*(x3 - x1)));
	double r = sqrt((x1 - a)*(x1 - a) + (y1 - b)*(y1 - b));
	return Circles{ a,b,r };
}


int main() {
	vector<Circles> dst;
	int n;
	double x1, y1, x2, y2, x3, y3;
	cin >> n;
	while (n-->0) {
		cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
		dst.push_back(countCircle(x1, y1, x2, y2, x3, y3));
	}
	for (vector<Circles>::iterator it = dst.begin(); it < dst.end(); it++) {
		cout.setf(ios::fixed);
		cout << fixed << setprecision(3) << (*it).x << " " << (*it).y << " " << (*it).r << endl;
	}
	return 0;
}

C++: #include <iostream>
#include <cstdio>
#include <complex>
#include <vector>
#include <algorithm>
using namespace std;

typedef complex<double> P; /* ツ点 */

int main(){
	int n;
	cin>>n;
	double x1, y1, x2, y2, x3, y3;
	while(cin>>x1>>y1>>x2>>y2>>x3>>y3){
		double a1 = 2*(x2-x1);
		double b1 = 2*(y2-y1);
		double c1 = x1*x1-x2*x2+y1*y1-y2*y2;
		double a2 = 2*(x3-x1);
		double b2 = 2*(y3-y1);
		double c2 = x1*x1-x3*x3+y1*y1-y3*y3;
		double cx = (b1*c2-b2*c1)/(a1*b2-a2*b1);
		double cy = (c1*a2-c2*a1)/(a1*b2-a2*b1);
		P cen2 = P(cx, cy);
		double r2 = abs(p1-cen2);

		printf("%.3f %.3f %.3f\n", real(cen2), imag(cen2), r2);
	}
	return 0;
}