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 <stdio.h>
#include <string>
#include <map>
#include <vector>
#include <set>
#include <iomanip>
#include <fstream>
#include <cstdint>
#include <cmath>
#include <algorithm>
#include <utility>
#include <numeric>
#include <functional>
using namespace std;

constexpr int INF       = 1000000000;/* 1e+9a */
constexpr int MODULO    = 1000000007;

#define int long

#define REP(i,f,n) for(int i=(f); i < (n); ++i)
#define PER(i,f,n) for(int i=(n-1); i >= f; --i)

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

//----------------------------------
//----------------------------------

template<typename STL> inline void print_STL(STL c, string ab = ""){
	cout << ab << c[0];
	for(int i = 1; i < c.size(); ++i) cout << ' ' << c[i]; }

template<typename STL> inline void import_STL(STL& c, int n){
	typename STL::value_type tmp;
	for(int i = 0; i < n; ++i){	cin >> tmp; c.push_back(tmp);} }

istream& operator>>(istream& os, pair<double,double>& x)
{
	double tmp;
	os >> tmp;
	x.first = tmp;
	os >> tmp;
	x.second = tmp;
	return os;
}

ostream& operator<<(ostream& os, pair<double,double>& x)
{
	return os << x.first << ' ' << x.second;
}

pair<double, double> operator-(pair<double,double> a, pair<double,double> b)
{
	return {a.first - b.first, a.second - b.second};
}
pair<double, double> operator+(pair<double,double> a, pair<double,double> b)
{
	return {a.first + b.first, a.second + b.second};
}

double operator*(pair<double, double> a, pair<double,double> b)
{
	return a.first * b.first + a.second * b.second;
}
double sq(double a)
{
	return a * a;
}

double round4(double x)
{
	x *= 1000;
	x = (int)(x + 0.5);
	return x / 1000;
}

signed main()
{
	pair<double,double> a, b, c;
	int n;
	cin >>n;
	while(cin >> a >> b >> c)
	{
		pair<double, double> va = b-c, vb = c-a;
		/* cout << va <<' ' << vb << '\n'; */
		auto m = b + c, n = c + a;
		m = {m.first / 2, m.second/2};
		n = {n.first / 2, n.second/2};
		double norm = va.first * vb.second - va.second * vb.first;
		double cx = va * m , cy = vb * n ;
		double sx = cx * vb.second - cy * va.second;
		double sy = va.first * cy - cx * vb.first;
		sx /= norm;
		sy /= norm;

		double r = sqrt(sq(c.first - sx)+ sq(c.second - sy));
		sx = round4(sx);
		sy = round4(sy);
		r = round4(r);
		printf("%.3lf %.3lf %.3lf\n", sx, sy, r);
	}
}

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

using namespace std;

#define MAX 256

float LOSER(float x){
	if((int)(x*10000)%10 > 4)return x + 0.001;
	return x;
}

int main(void){
	int n,i = 0;
	float x1,y1,x2,y2,x3,y3;
	float px[MAX],py[MAX],r[MAX];
	
	cin >> n;
	while(i < n){
		cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
		px[i] = ((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));
		py[i] = ((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));
		r[i] = sqrt((px[i]-x1)*(px[i]-x1)+(py[i]-y1)*(py[i]-y1));
		LOSER(px[i]);
		LOSER(py[i]);
		LOSER(r[i]);
		i++;
	}
	
	for(int i = 0;i < n;i++){
		scanf("%.3f %.3f %.3f",px[i],py[i],r[i]);
	}

	return 0;
}

C++: #include <cstdio>
#include <cstdlib>
#include <iostream>
#include <string>
#include <cmath>
#include <algorithm>
#include <vector>
#include <queue>
#include <stack>

using namespace std;
typedef long long ll;

#define PI 3.141592653

int main(){
    int n;
    double x_1,y_1,x_2,y_2,x_3,y_3,x_4,y_4,x_5,y_5,slope_1,slope_2,x,y,r;
    scanf("%d",&n);
    
    for(int i=0;i<n;i++){
        scanf("%lf%lf%lf%lf%lf%lf",&x_1,&y_1,&x_2,&y_2,&x_3,&y_3);
        
        if(y_1 == y_2){
            swap(x_2,x_3);
            swap(y_2,y_3);
        }
        if(y_2 == y_3){
            swap(x_1,x_2);
            swap(y_1,y_2);
        }
        
        slope_1=-(x_1-x_2)/(y_1-y_2);
        slope_2=-(x_3-x_2)/(y_3-y_2);
        
        x_4 = (x_1+x_2)/2;
        y_4 = (y_1+y_2)/2;
        
        x_5 = (x_3+x_2)/2;
        y_5 = (y_3+y_2)/2;

        x = ((slope_1*x_4-slope_2*x_5)-y_4+y_5)/(slope_1-slope_2);
        
        y = slope_1*x-slope_1*x_4+y_4;
        
        r = (x_1-x)*(x_1-x)+(y_1-y)*(y_1-y);
        
        printf("%lf %lf %lf\n",x,y,sqrt(r));
    }
    
    return 0;
}

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


int main(void){

  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 a = sqrt(pow(x2-x1,2) + pow(y2-y1,2));
    double b = sqrt(pow(x3-x2,2) + pow(y3-y2,2));
    double c = sqrt(pow(x3-x1,2) + pow(y3-y1,2));

    double r = a*b*c / sqrt((a+b+c)*(-a+b+c)*(a-b+c)*(a+b-c));

    double A = pow(x2-x1,2) + pow(y2-y1,2);
    double B = pow(x3-x2,2) + pow(y3-y2,2);
    double C = pow(x3-x1,2) + pow(y3-y1,2);
    double s = 4*((x2-x1)*(y3-y1) -(x3-x1)*(y2-y1));
    


    double x = A*(B+C-A) / (2*s);
    double y = B*(C+A-B) / (2*s);

    printf("%.3f %.3f %.3f\n",x,y,r);

  }




  return 0;
}

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

int main(){
  int n;
  double x1, x2, x3, y1, y2, y3, px, py, r, a1, a2, b1, b2, c1, c2;

  cin >> n;

  for(int i = 0;i < n; i++){
    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);
    r = sqrt((px - x1) * (px - x1) + (py - y1) * (py - y1));

    printf("%.3f %.3f %.3f\n", px, py, r);
  }

  return 0;
}