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<cmath>
#include<cstdio>
using namespace std;
int main(){
	double a[2],b[2],c[2];
	double matrix[2][2],ans[2],reverse[2][2],det;
	double r,o[2];
	int n;
	cin >>n;
	for(int i=0; i<n; i++){
		cin >>a[0]>>a[1]>>b[0]>>b[1]>>c[0]>>c[1];
		b[0] = b[0]-a[0];
		b[1] = b[1]-a[1];
		c[0] = c[0]-a[0];
		c[1] = c[1]-a[1];
		matrix[0][0] = 2*b[0];
		matrix[1][0] = 2*b[1];
		matrix[0][1] = 2*c[0];
		matrix[1][1] = 2*c[1];
		ans[0] = b[0]*b[0]+b[1]*b[1];
		ans[1] = c[0]*c[0]+c[1]*c[1];
		det = matrix[0][0]*matrix[1][1]-matrix[0][1]*matrix[1][0];
		reverse[0][0] = matrix[1][1]/det;
		reverse[1][0] = -matrix[1][0]/det;
		reverse[0][1] = -matrix[0][1]/det;
		reverse[1][1] = matrix[0][0]/det;
		o[0] = ans[0]*reverse[0][0]+ans[1]*reverse[1][0];
		o[1] = ans[0]*reverse[0][1]+ans[1]*reverse[1][1];
		r = sqrt(o[0]*o[0]+o[1]*o[1]);
		o[0]+=a[0];
		o[1]+=a[1];
		printf("%.3lf %.3lf %.3lf\n",o[0],o[1],r);
	}
	return 0;
}

C++: // clang-format off
#include <bits/stdc++.h>
#define int long long
#define main signed main()
// #define main int main()
#define loop(i, a, n) for (int i = (a); i < (n); i++)
#define rep(i, n) loop(i, 0, n)
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#define prec(n) fixed << setprecision(n)
#define stlice(from, to) substr(from, (to) - (from) + 1)
#define pb push_back
#define mp make_pair
#define mt make_tuple
#define fi first
#define se second
using namespace std;
using pii = pair<int, int>;
using vi = vector<int>;
using vd = vector<double>;
using vc = vector<char>;
using vb = vector<bool>;
using vs = vector<string>;
using vpii = vector<pii>;
using vvi = vector<vi>;
using vvb = vector<vb>;
using vvpii = vector<vpii>;
template<typename A> using fn = function<A>;
constexpr int INF = sizeof(int) == sizeof(long long) ? 1000000000000000000LL : 1000000000;
constexpr int MOD = 1000000007;
constexpr double PI = acos(-1);
template<typename A, typename B> bool cmin(A &a, const B &b) { return a > b ? (a = b, true) : false; }
template<typename A, typename B> bool cmax(A &a, const B &b) { return a < b ? (a = b, true) : false; }
constexpr bool odd(const int &n) { return n & 1; }
constexpr bool even(const int &n) { return !odd(n); }
template<typename V> constexpr typename V::value_type sum(const V &v) { return accumulate(all(v), 0); }
void solve();
main { solve(); return 0; }
// clang-format on

double roundPrec(double x, int prec) {
  double t = pow(10, prec);
  return double((int) (x * t + 0.5)) / t;
}

double f(double x) {
  return x * x;
}

template<typename T>
constexpr T det2(const T &a1, const T &a2, const T &b1, const T &b2) {
  return a1 * b2 - b1 * a2;
}

void solve() {
  int n;
  cin >> n;
  rep(i, n) {
    double x1, y1, x2, y2, x3, y3;
    cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
    double npx = det2(y2 - y1, y3 - y1, f(x1) - f(x2) + f(y1) - f(y2), f(x1) - f(x3) + f(y1) - f(y3));
    double npy = det2(y2 - y1, y3 - y1, f(x1) - f(x2) + f(y1) - f(y2), f(x1) - f(x3) + f(y1) - f(y3));
    double dp  = 2 * det2(x2 - x1, x3 - x1, y2 - y1, y3 - y1);
    double px = npx / dp, py = npy / dp;
    double r = roundPrec(sqrt(f(px - x1) + f(py - y1)), 3);
    cout << prec(3) << roundPrec(px, 3) << ' ' << fixed << roundPrec(py, 3) << ' ' << fixed << r << endl;
  }
}

C++: #include<stdio.h>
#include<math.h>

int FLG = 0;

typedef struct{
	double x,y;
}POINT;
	
POINT point(POINT p1,POINT p2);
double incl(POINT p1,POINT p2,int);
double cept(double x,double y,double a);

int main(){
	POINT p1,p2,p3,lp1,lp2;
	int n;
	double la1,la2,lb1,lb2;
	double x,y,r,tmp;
	
	scanf("%d",&n);	
	
	while(n>0){
	scanf("%lf %lf %lf %lf %lf %lf",&p1.x,&p1.y,&p2.x,&p2.y,&p3.x,&p3.y);
	
	lp1 = point(p1,p2);
	la1 = incl(p1,p2,1);
	lb1 = cept(lp1.x,lp1.y,la1);
	
	lp2 = point(p1,p3);
	la2 = incl(p1,p3,2);
	lb2 = cept(lp2.x,lp2.y,la2);
	
	if(FLG == 0){
		x = -1*(lb1-lb2)/(la1-la2);
		y = la1*x+lb1;
		tmp = ((x - p1.x)*(x - p1.x))+((y - p1.y)*(y - p1.y));
		r = sqrt(tmp);
	}
	
	
	//la1が無限
	else if(FLG == 1){
		
		x = lp1.x;
		y = la2 * x + lb2;
		tmp = ((x - p1.x)*(x - p1.x))+((y - p1.y)*(y - p1.y));
		r = sqrt(tmp);		
		
	}
	
	else if(FLG == 2){
		
		x = lp2.x;
		y = la1 * x + lb1;
		tmp = ((x - p1.x)*(x - p1.x))+((y - p1.y)*(y - p1.y));
		r = sqrt(tmp);		
		
	}
	
	
	
	printf("%.3f %.3f %.3f\n",x,y,r);
	
	n--;
	
	}
	
	return 0;
}

//中点座標
POINT point(POINT p1,POINT p2){
	POINT P;
	
	P.x = (p1.x + p2.x)/2;
	P.y = (p1.y + p2.y)/2;
	
	return (P);
}

//傾き
double incl(POINT p1,POINT p2,int plus){
	double a;
	
	double tmp;
	
	tmp = p2.x - p1.x;
	
	if(tmp != 0 ) a = (p2.y - p1.y)/tmp;
	
	else return 0;
		
	if(a==0) FLG += plus;
	else{
	a = -1*(1/a);
	}
	
	return a;
}

//切片
double cept(double x,double y,double a){
	double b;
	
	b = y-(a*x);
	
	return (b);
}

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

int main() {
	int t;
	cin >> t;

	while (t--) {
		double x1, y1, x2, y2, x3, y3;
		cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;

		double a = y2 - y1;
		double b = x2 - x1;
		double c = (x2*x2 - x1*x1 + y2*y2 - y1*y1)/2;
		double d = y3 - y2;
		double e = x3 - x2;
		double f = (x3*x3 - x2*x2 + y3*y3 - y2*y2)/2;

		double px = (c*d - a*f) / (b*d - a*e);
		double py = (c*e - b*f) / (a*e - d*b);

		double r = sqrt((px - x1)*(px - x1) + 
			(py - y1)*(py - y1));

		cout << fixed << setprecision(3);
		cout << px << " " << py << " " << r << endl;
	}

	return 0;
}

C++: #include <iostream>
#include <math.h>

struct Point {
	double x, y;
};

double roundDig(double, int);

int main ()
{
	int num;
	Point a, b, c, p, mb, mc;
	double r;

	scanf("%d", &num);
	
	for (int i=0; i<num; i++) {
		scanf("%lf %lf %lf %lf %lf %lf", &a.x, &a.y, &b.x, &b.y, &c.x, &c.y);
		double A1 = 2 * (b.x - a.x), B1 = 2 * (b.y - a.y), C1 = a.x*a.x - b.x*b.x + a.y*a.y - b.y*b.y,
			   A2 = 2 * (c.x - a.x), B2 = 2 * (c.y - a.y), C2 = a.x*a.x - c.x*c.x + a.y*a.y - c.y*c.y;
		
		p.x = (B1*C1 - B2*C1) / (A1*B2 - A2*B1);
		p.y = (C1*A2 - C2*A1) / (A1*B2 - A2*B1);
		
		mb.x = (a.x + b.x) / 2; mb.y = (a.y + b.y) / 2;
		mc.x = (a.x + c.x) / 2; mc.y = (a.y + c.y) / 2;
		
		r = sqrt((p.x - a.x)*(p.x - a.x) + (p.y - a.y)*(p.x - a.y));
		 
		printf("%.3lf %.3lf %.3lf\n", roundDig(p.x, 4), roundDig(p.y, 4), roundDig(r, 4));
	}
	
    return 0;
}

double roundDig(double n, int dig)
{
	int multi = pow(10, dig);
	
	return (floor(n*multi + 5) / multi);
}

C++: #include<bits/stdc++.h>
using namespace std;
 
#define REP(i,s,n) for(int i=s;i<n;++i)
#define rep(i,n) REP(i,0,n)
#define SORT(c) sort((c).begin(),(c).end())
#define IINF INT_MAX
#define LLINF LLONG_MAX
 
typedef long long ll;
typedef pair<int, int> ii;
 
int main(){

	int n;
	cin >> n;
	rep(i, n){
		double x1, y1, x2, y2, x3, y3;
		cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
		double vx21, vx31, vy21, vy31, tmp1, tmp2;
		vx21 = (x1 - x2);
		vx31 = (x1 - x3);
		vy21 = (y1 - y2);
		vy31 = (y1 - y3);
		tmp1 = x1 * x1 + y1 * y1 - x2 * x2 - y2 * y2;
		tmp2 = x1 * x1 + y1 * y1 - x3 * x3 - y3 * y3;
		
		double x, y, r;
		x = -(vy21 * tmp2 - vy31 * tmp1) / (2.0 * (vy31 * vx21 - vy21 * vx31));
		y = -(vx21 * tmp2 - vx31 * tmp1) / (2.0 * (vx31 * vy21 - vx21 * vy31));
		r = sqrt((x1 - x) * (x1 - x) + (y1 - y) * (y1 - y));
		
		printf("%.3lf %.3lf %.3lf\n", x, y, r);
		
	}
 
	return 0;
}