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<stdio.h>
#include<cmath>
using namespace std;
long double ff(long double a){
  
  a*=10000.0;
  //  cout<<a<<endl;
  long long c = a;
  if(c%10>4)c+=10;
  c/=10;
  return (long double)c/1000.0;
}



long double ax,ay,bx,by,cx,cy,ox,oy,dx,dy,ex,ey;
//ack はACの傾き  eos はEOの切片
long double abk,ack,dok,eok,eos,dos,eps=0.0;
int n;
int main(){

  cin>>n;
  for(int i=0;i<n;i++){
    cin>>ax>>ay>>bx>>by>>cx>>cy;
    //ABの中点をD,  ACの中点をE 外接円の中心をO とする
    dx=(ax+bx)/2.0;
    dy=(ay+by)/2.0;
    ex=(ax+cx)/2.0;
    ey=(ay+cy)/2.0;
    
    if(ax==bx){
      abk=(ay-by)/0.000000000001;
    }else{
      abk=(ay-by)/(ax-bx);
    }
    if(abk==0.0)abk=0.000000000001;
    dok=-1.0/abk;
    dos=dy-dx*dok;
    
    
    if(ax==cx){
      ack=(ay-cy)/0.000000000001;
    }else{
      ack=(ay-cy)/(ax-cx);
    }
    if(ack==0.0)ack=0.000000000001;
    eok=-1.0/ack;
    eos=ey-ex*eok;
    
    //Y  =  dok X  + dos
    //Y  =  eok X  + eos
    //dok X + dos = eok X + eos
    
    long double Y,X;
    if(dok-eok==0.0){
      X=(eos-dos)/0.000000000001;
    }else{
      X=(eos-dos)/(dok-eok);
    }
    Y= dok * X + dos;
    
    printf("%.3Lf %.3Lf ",ff(X),ff(Y));
    //cout<<ax<<' '<<X<<' '<<ay<<' '<<Y<<endl;
    printf("%.3Lf\n" , ff(  sqrt( pow(ax-X,2) + pow(ay-Y,2)) ));

    
    
  }
  return 0;
}

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

double get_num(double x){
	x = x * 1000;
	if(x >= 0){
		x = (int)(x + 0.5);
		return ((double)x / 1000);
	} else {
		x = (int)(x - 0.5);
		return ((double)x / 1000);
	}
};

int main()
{
	int n;
	cin >> n;
	for(int i = 0; i < n; i++){
		double x1, y1;
		double x2, y2;
		double x3, y3;
		double m12x, m12y;
		double m13x, m13y;
		double dx12, dy12;
		double dx13, dy13;
		double c12, c13;
		double xp, yp;
		double r;
		cin >> x1 >> y1 >> x2
			>> y2 >> x3 >> y3;
		m12x = (x1 + x2) / 2;
		m12y = (y1 + y2) / 2;
		m13x = (x1 + x3) / 2;
		m13y = (y1 + y3) / 2;
		dx12 = x2 - x1;
		dy12 = y2 - y1;
		dx13 = x3 - x1;
		dy13 = y3 - y1;
		c12 = m12x * dx12 + m12y * dy12;
		c13 = m13x * dx13 + m13y * dy13;
		yp = (c12 * dx13 - c13 * dx12) / (dy12 * dx13 - dy13 * dx12);
		if(dx12 == 0){
			xp = (c13 - (dy13 * yp)) / dx13;
		}else{
			xp = (c12 - (dy12 * yp)) / dx12;
		}
		r = sqrt((xp - x1) * (xp - x1) + ((yp - y1) * (yp - y1)));
		xp = get_num(xp);
		yp = get_num(yp);
		r = get_num(r);
		cout << fixed << setprecision(3) << xp << " " << yp << " " << r << endl;

	}
	return 0;
}

C++: #include <algorithm>
#include <cmath>
#include <climits>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
#include <cassert>
#include <functional>

using namespace std;

#define LOG(...) printf(__VA_ARGS__)
//#define LOG(...)
#define FOR(i,a,b) for(int i=(int)(a);i<(int)(b);++i)
#define REP(i,n) for(int i=0;i<(int)(n);++i)
#define ALL(a) (a).begin(),(a).end()
#define RALL(a) (a).rbegin(),(a).rend()
#define EXIST(s,e) ((s).find(e)!=(s).end())
#define SORT(c) sort((c).begin(),(c).end())
#define RSORT(c) sort((c).rbegin(),(c).rend())
#define CLR(a) memset((a), 0 ,sizeof(a))

typedef long long ll;
typedef unsigned long long ull;
typedef vector<bool> vb;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<vb> vvb;
typedef vector<vi> vvi;
typedef vector<vll> vvll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;

const int dx[] = { -1, 0, 1, 0 }; const int dy[] = { 0, 1, 0, -1 };

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

C++: #define _USE_MATH_DEFINES

#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <cmath>
#include <algorithm>
#include <vector>
#include <queue>
#include <map>

using namespace std;

typedef pair<long long int, long long int> P;
long long int INF = 1e18;
int main()
{
    const double EPS = 1.0e-10;
    double a,b,c,d,e,f;
    double x1,x2,x3,y1,y2,y3;
    double x,y;
    int n;
	cin >> n;
    for(int i = 0; i < n; i++){
    	cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
        a = x1 - x2;
        b = y1 - y2;
        c = (x1 * x1 + y1 * y1 - x2 * x2 - y2 * y2) / 2;
        d = x1 - x3;
        e = y1 - y3;
        f = (x1 * x1 + y1 * y1 - x3 * x3 - y3 * y3) / 2;
        x = (e * c - b * f) / (a * e - b * d);
        y = (a * f - d * c) / (a * e - b * d);
        if(-0.0005 < x && x < 0.0+EPS) x = 0.0;
        if(-0.0005 < y && y < 0.0+EPS) y = 0.0;
 
        printf("%.3f %.3f %.3f\n",x,y,sqrt((x1 - x) * (x1 - x) + (y1 - y) * (y1 - y)));
    }
    return 0;
}

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

struct Zahyou
{
	float x, y;
};

int main()
{
	int n;
	Zahyou de[4];

	scanf("%d", &n);
	for (int i = 0; i < n; i++)
	{
		for (int j = 1; j < 4; j++)
		{
			scanf("%f %f", &de[j].x, &de[j].y);
		}
		de[0].x = ((de[1].y - de[3].y)*(pow(de[1].y, 2) - pow(de[2].y, 2) + pow(de[1].x, 2) - pow(de[2].x, 2)) + (de[1].y - de[2].y)*(pow(de[1].y, 2) - pow(de[3].y, 2) + pow(de[1].x, 2) - pow(de[3].x, 2))) / (2 * (de[1].y - de[3].y)*(de[1].x - de[2].x) + 2 * (de[1].y - de[2].y)*(de[1].x - de[3].x));
		de[0].y = ((de[1].x - de[3].x)*(pow(de[1].x, 2) - pow(de[2].x, 2) + pow(de[1].y, 2) - pow(de[2].y, 2)) + (de[1].x - de[2].y)*(pow(de[1].x, 2) - pow(de[3].x, 2) + pow(de[1].y, 2) - pow(de[3].y, 2))) / (2 * (de[1].x - de[3].x)*(de[1].y - de[2].y) + 2 * (de[1].x - de[2].x)*(de[1].y - de[3].y));
		
		printf("%.3f %.3f %.3f\n",de[0].x,de[0].y,sqrt(pow((de[0].x-de[1].x),2)+pow((de[0].y-de[1].y),2)));
	}
	return 0;
}