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<iomanip>
    #include<cmath>
    using namespace std;

    int main ()
    {
        int num;
        double x1,y1,x2,y2,x3,y3;

        cin >> num;

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

            px = ((x1*x1-x3*x3+y1*y1-y3*y3)*(y2-y1)-(x1*x1-x2*x2+y1*y1-y2*y2)*(y3-y1)) / (2*(x2-x1)*(y3-y1)-2*(x3-x1)*(y2-y1));
            py = ((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));
            //py = ((2*(x1-x2)*px+x2*x2-x1*x1+y2*y2-y1*y1)) / (2*(y2-y1));
            r = sqrt((px-x1)*(px-x1) + (py-y1)*(py-y1));

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

        return 0;
    }

C++: #include <iostream>
#include <algorithm>
#include <cassert>
#include <cmath>
#include <stdio.h>

using namespace std;

//-------------------------------------------------------------------------
// geometric library

namespace geometry {

struct point {
	double x;
	double y;
};

struct circle {
	point center;
	double radius;
};

struct line { // ax + by + c = 0
	double a;
	double b;
	double c;
};

std::istream& operator >> (std::istream& is, point& p)
{
	is >> p.x >> p.y;
	return is;
}

bool operator == (const point& p1, const point& p2)
{
	return p1.x == p2.x && p1.y == p2.y;
}

///! 2点の距離
double get_distance(const point& p1, const point& p2)
{
	return sqrt(pow(p1.x - p2.x, 2) + pow(p1.y - p2.y, 2));
}

///! 2直線の交点
bool get_crosspoint(const line& l1, const line& l2, point *result)
{
	double denominator = l1.a * l2.b - l1.b * l2.a;
	if (denominator == 0) {
		return false;
	}
	result->x = (l1.b * l2.c - l2.b * l1.c) / denominator;
	result->y = (l2.a * l1.c - l1.a * l2.c) / denominator;
	return true;
}

///! 2点の垂直2等分線
bool get_bisector(const point& p1, const point& p2, line *result)
{
	if (p1 == p2) {
		return false;
	}
	result->a = 2 * (p1.x - p2.x);
	result->b = 2 * (p1.y - p2.y);
	result->c = -(p1.y - p2.y) * (p1.y + p2.y) - (p1.x - p2.x) * (p1.x + p2.x);
	return true;
}

///! 外接円を求める
bool get_circum_circle(const point& p1, const point& p2, const point& p3, circle *result)
{
	double a = get_distance(p1, p2);
	double b = get_distance(p2, p3);
	double c = get_distance(p3, p1);

	// 半径の公式
	result->radius = a * b * c / sqrt((a + b + c) * (-a + b + c) * (a - b + c) * (a + b - c));

	line line_p1p2;
	line line_p2p3;

	// 頂点の垂直2等分線の交点が外心
	return get_bisector(p1, p2, &line_p1p2) &&
		   get_bisector(p2, p3, &line_p2p3) &&
		   get_crosspoint(line_p1p2, line_p2p3, &result->center);
}

} // namespace geometry

//-------------------------------------------------------------------------
// solution

using namespace geometry;

circle get_circum_circle(istream& is)
{
	point p1, p2, p3;
	circle result;
	is >> p1 >> p2 >> p3;

	if (get_circum_circle(p1, p2, p3, &result)) {
		return result;
	} else {
		assert(!"invalid input");
	}
}

int main(void)
{
	int num_cases;

	std::cin >> num_cases;

	for (int i = 0; i < num_cases; i++) {		
		circle result = get_circum_circle(std::cin);
		printf("%.3f %.3f %.3f\n", result.center.x, result.center.y, result.radius);
	}
	return 0;
}

C++: #include <algorithm>
#include <functional>
#include <cmath>
#include <cstdio>
#include <cstdint>
#include <cstdlib>
#include <cstring>
#include <string>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <vector>
#include <list>
#include <stack>
#include <queue>
#include <map>
#include <set>
#include <bitset>
#include <climits>
#include <complex>

#define all(c) (c).begin(), (c).end()
#define rep(i,n) for(int i=0;i<(n);i++)
#define pb(e) push_back(e)
#define mp(a, b) make_pair(a, b)
#define fr first
#define sc second

const int INF=100000000;
int dx[4]={1,0,-1,0};
int dy[4]={0,1,0,-1};
using namespace std;
typedef complex<double> P;
int n;

double cross(P p1,P p2) {
    return abs(real(p1)*imag(p2) - imag(p1)*real(p2));
}
double calc_S(P p1,P p2,P p3) {
    double ret = 0.0;
    p1 -= p3;
    p2 -= p3;

    ret = cross(p1,p2)/2.0;
    return ret;
}
double f(P p1,P p2) {
    double ret = 0.0;
    ret += real(p1)*real(p1);
    ret += imag(p1)*imag(p1);
    ret -= real(p2)*real(p2);
    ret -= imag(p2)*imag(p2);
    return ret;
}

int main() {
    cin>>n;
    while(n-->0) {
        double x1_,y1_;
        double x2_,y2_;
        double x3_,y3_;
        cin>>x1_>>y1_>>x2_>>y2_>>x3_>>y3_;
        P p1(x1_,y1_);
        P p2(x2_,y2_);
        P p3(x3_,y3_);
        P A = p1-p2;
        P B = p2-p3;
        P C = p1-p3;
        double S = calc_S(p1,p2,p3);
        double R = abs(A)*abs(B)*abs(C)/S;
        R /= 4.0;
        
        P A1 = 2.0*(p2-p1);
        P B1 = 2.0*(p3-p1);
        P C1 = P(norm(p1)-norm(p2),norm(p1)-norm(p3));
        double X = cross(P(imag(A1),imag(B1)),C1)/cross(A1,B1);
        double Y = cross(C1,P(real(A1),real(B1)))/cross(A1,B1);
        printf("%.3lf %.3lf %.3lf\n",X,Y,R);

    }
    return 0;
}