Go: package main

import (
	"fmt"
	"math"
)

func main() {
	var num int
	fmt.Scan(&num)
	for i := 0; i < num; i++ {
		var x1, y1, x2, y2, x3, y3 float64
		fmt.Scanf("%f%f%f%f%f%f", &x1, &y1, &x2, &y2, &x3, &y3)

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

		// 直線1: ax + by - e = 0
		// 直線2: cx + dy - f = 0
		px := (d*e - b*f) / (a*d - b*c)
		py := (c*e - a*f) / (b*c - a*d)
		r := math.Sqrt((px-x1)*(px-x1) + (py-y1)*(py-y1))
		fmt.Printf("%.3f %.3f %.3f\n", px, py, r)
	}
}

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

int main()
{
    using namespace std;
    int n;

    cin >> n;
    for( int i=0; i<n; ++i ) {
        double x1, y1, x2, y2, x3, y3;
        cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;

        double const a = sqrt( pow( x2 - x3, 2 ) + pow( y2 - y3, 2 ) );
        double const b = sqrt( pow( x3 - x1, 2 ) + pow( y3 - y1, 2 ) );
        double const c = sqrt( pow( x3 - x2, 2 ) + pow( y3 - y2, 2 ) );

        double const r
            = a * b * c
            / sqrt( ( a + b + c ) * ( -a + b + c ) * ( a - b + c ) * ( a + b - c ) );
        
        double const p
            = ( ( y1 - y3 ) * ( y1 * y1 - y2 * y2 + x1 * x1 - x2 * x2 ) - ( y1 - y2 ) * ( y1 * y1 - y3 * y3 + x1 * x1 - x3 * x3 ) )
            / ( 2 * ( y1 - y3 ) * ( x1 - x2 ) - 2 * ( y1 - y2 ) * ( x1 - x3 ) );

        double const q
            = ( ( x1 - x3 ) * ( x1 * x1 - x2 * x2 + y1 * y1 - y2 * y2 ) - ( x1 - x2 ) * ( x1 * x1 - x3 * x3 + y1 * y1 - y3 * y3 ) )
            / ( 2 * ( x1 - x3 ) * ( y1 - y2 ) - 2 * ( x1 - x2 ) * ( y1 - y3 ) );

        

        cout << showpoint << fixed << setprecision( 3 );
        cout << p << " " << q << " " << r << endl;
    }
}

C++: #include <stdio.h>

int main(void){
	int n , i;
	float x1,x2,x3,y1,y2,y3,a1,a2,b1,b2,c1,c2,xp,yp,r;
	scanf("%d" , &n);
	for(i=1;i<=n;i++){
		scanf("%f %f %f %f %f %f" , &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 - y1);
		b2 = 2 * (y3 - y1);
		c2 = x1 * x1 - x3 * x3 + y1 * y1 - y3 * y3;
		xp = (b1 * c2 - b2 * c1) / (a1 * b2 - a2 * b1);
		yp = (c1 * a2 - c2 * a1) / (a1 * b2 - a2 * b1);
		r = sqrt((xp - x1) * (xp - x1) + (yp - y1) * (yp - y1));
		printf("%.3f %.3f %.3f\n" , xp , yp , r);
	}
	return 0;
}

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

void CulculateCoordinateAndRadius(double&, double&, double&, double, double, double, double, double, double);
double slope(const double[2], const double[2]);
double n_slope(const double[2], const double[2]);
double intercept(const double, const double[2]);
double center(const double, const double);
double mySqrt(double, const int&);
double myRound(double, const int&);

int main(){

	int NumberOfDataset;  //データセットの数
	double x1, y1, x2, y2, x3, y3; //入力される座標
	double px, py, r;

	std::cin >> NumberOfDataset;

	for (int i = 0; i < NumberOfDataset; i++)
	{
		std::cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
		CulculateCoordinateAndRadius(px, py, r, x1, y1, x2, y2, x3, y3);
		/*px = myRound(px, 4);
		py = myRound(py, 4);
		r = myRound(r, 4);*/
		//std::cout << px << ' ' << py << ' ' << r << std::endl;
		printf("%0.3f %0.3f %0.3f\n", px, py, r);
	}
}

void CulculateCoordinateAndRadius(double& px, double&py, double&r, double x1, double y1, double x2, double y2, double x3, double y3){
	double point1[2] = { x1, y1 };
	double point2[2] = { x2, y2 };
	double point3[2] = { x3, y3 };
	double center1[2] = { center(point1[0], point2[0]), center(point1[1], point2[1]) };
	double center2[2] = { center(point2[0], point3[0]), center(point2[1], point3[1]) };
	double n_slope_1 = n_slope(point1, point2);
	double n_slope_2 = n_slope(point2, point3);
	double intercept_1 = intercept(n_slope_1, center1);
	double intercept_2 = intercept(n_slope_2, center2);
	if (y1 == y2){
		px = center1[0];
		py = n_slope_2 * px + intercept_2;
	}
	else if (y2 == y3){
		px = center2[0];
		py = n_slope_1 * px + intercept_1;
	}else{
		px = (intercept_2 - intercept_1) / (n_slope_1 - n_slope_2);
		py = n_slope_1 * px + intercept_1;
	}
	r = mySqrt((px - x1) * (px - x1) + (py - y1) * (py - y1), 5);
}


double slope(const double point1[2], const double point2[2]){
	return (point2[1] - point1[1]) / (point2[0] - point1[0]);
}

double n_slope(const double point1[2], const double point2[2]){
	double x1 = -point1[1];
	double y1 = point1[0];
	double x2 = -point2[1];
	double y2 = point2[0];
	return (y2 - y1) / (x2 - x1);
}

double intercept(const double slope, const double POINT1[2]){
	return -slope * POINT1[0] + POINT1[1];
}

double center(const double COODINATE1, const double COODINATE2){
	return (COODINATE1 + COODINATE2) / 2;
}

double mySqrt(double number, const int& SIGNIFICANT_DIGITS){
	double result = 0;
	double digitsOffset = 1;

	for (int i = 0; i < SIGNIFICANT_DIGITS + 1; i++){
		while (number >= (result + digitsOffset) * (result + digitsOffset)){
			result += digitsOffset;
		}
		digitsOffset /= 10;
	}
	return result;
}

double myRound(double number, const int& SIGNIFICANT_DIGITS){
	for (int i = 0; i < SIGNIFICANT_DIGITS; i++){
		number *= 10;
	}
	int targetDigits = static_cast<int>(number) % 10;
	if (targetDigits >= 5){
		number = static_cast<int>(number) + 10 - targetDigits;
	}
	else{
		number = static_cast<int>(number) - targetDigits;
	}
	for (int i = 0; i < SIGNIFICANT_DIGITS; i++){
		number /= 10;
	}
	return number;
}

C++: // AOJ 0010 (http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0010&lang=jp)
#include<cstdio>
#include<cmath>
#define rep(i,a) for(int i=0;i<(a);++i)

int n;

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

int main()
{
	scanf( "%d", &n );
	while( n-- )
	{
		double x1, y1, x2, y2, x3, y3;
		scanf( "%lf%lf%lf%lf%lf%lf", &x1, &y1, &x2, &y2, &x3, &y3 );

		double a = sqrt(sqr(x3-x2)+sqr(y3-y2)), b = sqrt(sqr(x1-x3)+sqr(y1-y3)), c = sqrt(sqr(x2-x1)+sqr(y2-y1));
		double cosA = (sqr(b)+sqr(c)-sqr(a))/(2*b*c), cosB = (sqr(c)+sqr(a)-sqr(b))/(2*c*a), cosC = (sqr(a)+sqr(b)-sqr(c))/(2*a*b);
		double sinA = sqrt(1-sqr(cosA)), sinB = sqrt(1-sqr(cosB)), sinC = sqrt(1-sqr(cosC));
		double sin2A = 2*sinA*cosA, sin2B = 2*sinB*cosB, sin2C = 2*sinC*cosC;
		double px = (sin2A*x1+sin2B*x2+sin2C*x3)/(sin2A+sin2B+sin2C), py = (sin2A*y1+sin2B*y2+sin2C*y3)/(sin2A+sin2B+sin2C);

		printf( "%.3f %.3f %.3f\n", px, py, sqrt(sqr(x1-px)+sqr(y1-py)) );
	}

	return 0;
}

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

int main(){
	int n;
	double x1, y1, x2, y2, x3, y3, m1, m2, m3, b1, b2, b3, px, py, r;
	double d[2], e[2], f[2];
	cin >> n;
	for(int i = 0; i < n; i++){
		cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
		d[0] = (x2 + x3) / 2;
		d[1] = (y2 + y3) / 2;
		e[0] = (x3 + x1) / 2;
		e[1] = (y3 + y1) / 2;
		f[0] = (x1 + x2) / 2;
		f[1] = (y1 + y2) / 2;
		m1 = (y3 - y2) / (x3 - x2);
		m2 = (y1 - y3) / (x1 - x3);
		m3 = (y2 - y1) / (x2 - x1);
		b1 = d[1] + d[0] / m1;
		b2 = e[1] + e[0] / m2;
		b3 = f[1] + f[0] / m3;
		px = -(b1 - b2) / ((1 / m2) - (1 / m1));
		py = -(1 / m1) * px + b1;
		r = (double)sqrt((x1 - px) * (x1 - px) + (y1 - py) * (y1 - py));
		px = floor(1000 * (px + 0.0005)) / 1000;
		py = floor(1000 * (py + 0.0005)) / 1000;
		r = floor(1000 * (r + 0.0005)) / 1000;
		cout << fixed << setprecision(3) << px << " " <<  py << " " << r << endl;
	}
	return 0;
}