Go: package main

import (
	"fmt"
	"math"
)

func main() {
	n := scanInt()
	for i := 0; i < n; i++ {
		circleTriangle()
	}
}

func scanInt() int {
	var n int
	fmt.Scanf("%d", &n)
	return n
}

func circleTriangle() {
	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 <iomanip>
#include <cmath>
using namespace std;

int main(){
	int n;
	double x1 , y1 , x2 , y2 , x3 , y3;
	double a1 , b1 , c1 , a2 , b2 , c2;
	double a , b , c;
	double px , py , r;
	double tmp;
	cin >> n;
	while(1){
		if(n==0) break;
		n--;
		cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
		a1=2*(x2-x1);
		b1=2*(y2-y1);
		c1=(x1*x1-x2*x2+y1*y1-y2*y2);
		a2=2*(x3-x1);
		b2=2*(y3-y1);
		c2=(x1*x1-x3*x3+y1*y1-y3*y3);
		px=(b1*c2-b2*c1)/(a1*b2-a2*b1);
		py=(c1*a2-c2*a1)/(a1*b2-a2*b1);
		a=sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2));
		b=sqrt((x2-x3)*(x2-x3)+(y2-y3)*(y2-y3));
		c=sqrt((x3-x1)*(x3-x1)+(y3-y1)*(y3-y1));
		r=a/(2*sqrt(1-((b*b+c*c-a*a)/(2*b*c))*((b*b+c*c-a*a)/(2*b*c))));
		tmp=px*1000+0.5;
		px=(int)tmp;
		px/=1000;
		tmp=px*1000+0.5;
		py=(int)tmp;
		py/=1000;
		tmp=r*1000+0.5;
		r=(int)tmp;
		r/=1000;
		cout << fixed << setprecision(3) << px << " " << py << " " << r << endl;
	}
	return 0;
}

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

using namespace std;

int main()
{
    int num;
    cin >> num;
    double x1, x2, x3, y1, y2, y3;
    double xp, yp, r;

    while(cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3)
    {
        xp = (1/2.0)*((x1*x1+y1*y1)*(y3-y2)+(x2*x2+y2*y2)*(y1-y3)+(x3*x3+y3*y3)*(y2-y1))/(x1*(y3-y1)+x2*(y1-y3)+x3*(y2-y1));
        yp = -(x3-x2)/(y3-y2)*xp+(1/2.0)*(x3*x3-x2*x2+y3*y3-y2*y2)/(y3-y2);
        r = sqrt((x1 - xp)*(x1 - xp) + (y1 - yp)*(y1 - yp));

        cout << fixed << setprecision(3) << xp << " " << yp << " " << 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 if(p2.y - p1.y == 0){
		
		FLG += plus;
		return a;
	}	
	
	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 <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;


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

		double x21 = x2 - x1;
		double x31 = x3 - x1;
		double y21 = y2 - y1;
		double y31 = y3 - y1;
		
		double xc = 1.0*((y31*(x21*x21 + y21*y21)) - (y21*(x31*x31 + y31*y31))) /
			(2 * (x21*y31 - y21*x31));

		double yc = 1.0*((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);
		d = sqrt(d);

		printf("%.3lf %.3lf %.3lf\n", xc, yc, d);
	}
	return 0;
}