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 <stdio.h>
#include <math.h>
 
int main()
{
    int i, n;
    double x1, x2, x3, y1, y2, y3;
    double a, b, c, d, e, f;
    double X1, Y1, r;
     
    scanf("%d", &n);
    for (i = 0; i < n; i++){
        scanf("%lf %lf %lf %lf %lf %lf",&x1, &y1, &x2, &y2, &x3, &y3);
        a = 2 * (x2 - x1);
        b = 2 * (y2 - y1);
        c = x1*x1 - x2*x2 + y1*y1 - y2*y2;
        d = 2 * (x3 - x1);
        e = 2 * (y3 - y1);
        f = x1*x1 - x3*x3 + y1*y1 - y3*y3;
         
        X1 = (b*f - e*c) / (a*e - d*b);
        Y1 = (c*d - f*a) / (a*e - d*b);
        r  = sqrt((X1-x1)*(X1-x1) + (Y1-y1)*(Y1-y1));
         
        // X1 *= 1000;
        // Y1 *= 1000;
        // r  *= 1000;
         
        // X1 = (int)(X1 > 0.0 ? X1+0.5 : X1-0.5);
        // Y1 = (int)(Y1 > 0.0 ? Y1+0.5 : Y1-0.5);
        // r  = (int)(r  > 0.0 ? r +0.5 : r -0.5);
         
        // X1 = (double)X1/1000;
        // Y1 = (double)Y1/1000;
        // r  = (double)r /1000;
         
        printf("%.3f %.3f %.3f\n", X1, Y1, r);
         
         
    }
     
    return 0;
}

C++: 
#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <cmath>
#include <stack>
#include <cctype>
#include <complex>
#include <vector>
#include <algorithm>

using namespace std;


bool solve(){
	complex<double> Ans;
	complex<double> P[3];
	for(int i=0;i<3;i++){
		cin>> P[i].real()>> P[i].imag();
	}
	complex<double> T[2];
	complex<double> K[2];
	double katamuki[2];
	for(int i=0;i<2;i++){
		T[i].real() = (P[i].real() + P[i+1].real()) / 2;
		T[i].imag() = (P[i].imag() + P[i+1].imag()) / 2;
		complex<double> N;
		N = (P[i+1]-P[i])/abs(P[i+1]-P[i]);
		K[i].real() =  N.imag();
		K[i].imag() = -N.real();
	}
	int a = (T[1]-T[0]).real();
	int b = (T[1]-T[0]).imag();
	int x0 = K[0].real();
	int y0 = K[0].imag();
	int x1 = K[1].real();
	int y1 = K[1].imag();
	int m = ( a * y0 - b * x0 ) / ( x0 * y1 - x1 * y0);
	K[1] *= m;
	Ans = K[1] + T[1];


	printf("%.3f %.3f %.3f", Ans.real(), Ans.imag(), abs(Ans-P[0]));
	printf("\n");
	
	return true;
}

int main(){
	cout.setf(ios::fixed);
	cout.precision(5);
	int n;
	cin>> n;
	for(int i=0;i<n;i++){
		solve();
	}
	return 0;
}

C++: #include<bits/stdc++.h>
using namespace std;
#define mp make_pair
#define fi first
#define se second
#define ll long long
#define pb push_back

# define inOut(a,b) freopen(a,"r",stdin);freopen(b,"w",stdout);
# define RESET(a) memset(a,0,sizeof(a))
# define MEMO(a) memset(a,-1,sizeof(a))
# define DEBUG puts("Debug-Has-Come-Until-Here")


typedef pair<int,int> ii;
typedef vector<int> vi;
typedef vector<ii> vii;

int main(){
	cin.tie(NULL);

	double x1, x2, x3, y1, y2, y3;
	double a,b,c,d,e,f;
	double x,y;
	int dummy;
	
	scanf("%d", &dummy);
	while(scanf("%lf %lf %lf %lf %lf %lf", &x1, &y1, &x2, &y2, &x3, &y3) != EOF){
		a = -2*x1 + 2*x2;
		b = -2*y1 + 2*y2;
		c = (x2*x2 - x1*x1) + (y2*y2 - y1*y1);
		d = -2*x2 + 2*x3;
		e = -2*y2 + 2*y3;
		f = (x3*x3 - x2*x2) + (y3*y3-y2*y2);
		
		x = (c*e - b*f)/(a*e-b*d);
		y = (c*d - a*f)/(b*d-e*a);
		printf("%.3lf %.3lf %.3lf\n", x, y, sqrt((x-x1)*(x-x1)+(y-y1)*(y-y1)));
	}

	return 0;
}

C++: using namespace std;
 
int main(){
   
 int cnt;
    cin >> cnt;
   ??? double x1, y1, x2, y2, x3, y3;
    ???double a1, a2, b1, b2, c1, c2;
    ???double xp, yp, r;

    while (cnt > 0 && 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;
        xp = (double)((b1*c2 - b2*c1) / (a1*b2 - a2*b1) * 1000) / 1000.0;
        yp = (double)((c1*a2 - c2*a1) / (a1*b2 - a2*b1) * 1000) / 1000.0;
//

        r = hypot(xp - x1, yp - y1);
 
        cout<< setprecision(3)<< xp << " " << yp << " " << r << endl;
        cnt -= 1;
    }
    return 0;
}