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<cstdio>
#include<cmath>
using namespace std;
double x1,Y1,x2,y2,x3,y3;
double px, py,r;
int main()
{
    int n;
    scanf("%d",&n);
    while(n--)
    {
        scanf("%lf%lf%lf%lf%lf%lf",&x1,&Y1,&x2,&y2,&x3,&y3);
        double A1 =(x2*x2+y2*y2-x1*x1-Y1*Y1)*(y3-Y1);
        double B1 =(x3*x3+y3*y3-x1*x1-Y1*Y1)*(y2-Y1);
        double A2 =(x3*x3+y3*y3-x1*x1-Y1*Y1)*(x2-x1);
        double B2 =(x2*x2+y2*y2-x1*x1-Y1*Y1)*(x3-x1);
        double D = (x2-x1)*(y3-Y1)-(y2-Y1)*(x3-x1);
         px=(A1-B1)/D/2;
         py=(A2-B2)/D/2;
         r = sqrt((px-x1)*(px-x1)+(py-Y1)*(py-Y1));
        printf("%.3f %.3f %.3f\n",px,py,r);
    }
    return 0;
}

C++: #include <iostream>
#include <string>
#include <vector>
#include <cmath>
#include <algorithm>
#include <cstdlib>
#include <ctime>
#include <stdio.h>

#define MAX 1000000

using namespace std;

int main()
{
	double x1,y1,x2,y2,x3,y3,X1,Y1,X2,Y2,a1,b1,a2,b2;
	double xp,yp,r;
	int n,f;

	cin>>n;
	while(n--){
		cin>>x1>>y1>>x2>>y2>>x3>>y3;
		f=0;

		X1=(x1+x2)/2.0; Y1=(y1+y2)/2.0;
		X2=(x1+x3)/2.0; Y2=(y1+y3)/2.0;
	
		if(y2-y1!=0){
			if(x2!=x1)a1=-(y2-y1)/(x2-x1);
			else a1=0;
			b1=X1*(-a1)+Y1;
		}else f=1;

		if(y3-y1!=0){
			if(x3!=x1)a1=-(y3-y1)/(x3-x1);
			else a2=0;
			b2=X2*(-a2)+Y2;
		}else f=2;

		if(f==1){ 
			xp=X1;yp=a2*xp+b2;
		}else if(f==2){
			xp=X2; yp=a1*xp+b1;
		}else{
			xp=(b2-b1)/(a1-a2);
			yp=a1*xp+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<string>
#include<algorithm>
#include<vector>
#include<queue>
#include<map>
#include<math.h>
#include<iomanip>
#include<set>
#include<numeric>
#include<cstring>
#include<cstdio>
#include<functional>
#include<bitset>
#include<limits.h>
#include<cassert>
#include<iterator>
#include<complex>
#include<stack>
#include<sstream>
#include<iterator>
using namespace std;
typedef  long long int lint;
typedef pair<int, int> IP;
typedef pair<lint, lint> LLP;
typedef pair<char, char>CP;
#define rep(i, n) for (int i = 0; i < n; i++)
#define repr(i, n) for (int i = n; i >= 0; i--)
#define sort(v) sort((v).begin(), (v).end())
#define reverse(v) reverse((v).begin(), (v).end())
#define upper(v,hoge) upper_bound(v.begin(),v.end(),hoge)
#define lower(v,hoge) lower_bound(v.begin(),v.end(),hoge)
#define llower(v,hoge) *lower_bound(v.begin(), v.end(), hoge)
#define lupper(v,hoge) *upper_bound(v.begin(), v.end(), hoge)

double a(double x1, double y1, double x2, double y2) {
	double a = 0;
	if (y1 == y2) {
		a = 114514;
	}
	else {
		a = -(x1 - x2) / (y1 - y2);
	}
	return a;
}
double b(double x1, double y1, double x2, double y2) {
	double b = 0;
	if (y1 == y2) {
		b = 114514;
	}
	else {
		b = ((x1 - x2) * (x1 + x2) / (y1 - y2) + (y1 + y2)) / 2;
	}
	return b;
}

double cal_X(double a, double b, double c, double d, double e, double f) {
	double Y = (c * d - a * f) / (b * d - a * e);
	double X;
	if (a != 0) {
		X = (c - b * Y) / a;
	}
	else {
		X = (f - e * Y) / d;
	}
	return X;
}

double cal_Y(double a, double b, double c, double d, double e, double f) {
	double Y = (c * d - a * f) / (b * d - a * e);
	double X;
	if (a != 0) {
		X = (c - b * Y) / a;
	}
	else {
		X = (f - e * Y) / d;
	}
	return Y;
}

int main() {
	int N;
	cin >> N;
	rep(i, N) {
		double x1, y1, x2, y2, x3, y3;
		cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
		double a1 = a(x3, y3, x2, y2);
		double b1 = b(x3, y3, x2, y2);
		double a2 = a(x1, y1, x2, y2);
		double b2 = b(x1, y1, x2, y2);
		double a3 = a(x1, y1, x3, y3);
		double b3 = b(x1, y1, x3, y3);
		vector<double>V;
		if (a1 != 114514) {
			V.push_back(a1);
		}
		if (b1 != 114514) {
			V.push_back(b1);
		}
		if (a2 != 114514) {
			V.push_back(a2);
		}
		if (b2 != 114514) {
			V.push_back(b2);
		}
		if (a3 != 114514) {
			V.push_back(a3);
		}
		if (b3 != 114514) {
			V.push_back(b3);
		}
		double X = cal_X(V[0] * (-1), 1, V[1], V[2] * (-1), 1, V[3]);
		double Y = cal_Y(V[0] * (-1), 1, V[1], V[2] * (-1), 1, V[3]);
		double R = sqrt(pow(X - x1, 2) + pow(Y - y1, 2));
		cout <<fixed<<setprecision(3)<< X << ' ' << Y <<' '<< R << endl;
	}
}

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

int main()
{
	int n;
	double x1[32],x2[32],x3[32],y1[32],y2[32],y3[32],p,q,r;
	double a,b,c;
	scanf("%d",&n);
	for(int i=0;i<n;i++){
		scanf("%lf%lf%lf%lf%lf%lf",&x1[i],&x2[i],&x3[i],&y1[i],&y2[i],&y3[i]);
		p=((y1[i]-y3[i])*(y1[i]*y1[i]-y2[i]*y2[i]+x1[i]*x1[i]-x2[i]*x2[i])-(y1[i]-y2[i])*(y1[i]*y1[i]-y3[i]*y3[i]+x1[i]*x1[i]-x3[i]*x3[i]));
		p/=(2*(y1[i]-y3[i])*(x1[i]-x2[i])-2*(y1[i]-y2[i])*(x1[i]-x3[i]));
		q=((x1[i]-x3[i])*(x1[i]*x1[i]-x2[i]*x2[i]+y1[i]*y1[i]-y2[i]*y2[i])-(x1[i]-x2[i])*(x1[i]*x1[i]-x3[i]*x3[i]+y1[i]*y1[i]-y3[i]*y3[i]));
		q/=(2*(x1[i]-x3[i])*(y1[i]-y2[i])-2*(x1[i]-x2[i])*(y1[i]-y3[i]));
		c=sqrt(fabs((x3[i]-x1[i])*(x3[i]-x1[i])+(y3[i]-y1[i])*(y3[i]-y1[i])));
		b=sqrt(fabs((x3[i]-x2[i])*(x3[i]-x2[i])+(y3[i]-y2[i])*(y3[i]-y2[i])));
		a=sqrt(fabs((x2[i]-x1[i])*(x2[i]-x1[i])+(y2[i]-y1[i])*(y2[i]-y1[i])));
		r=a*b*c/sqrt((a+b+c)*(-a+b+c)*(a-b+c)*(a+b-c));
		printf("%.3f %.3f %.3f\n",p,q,r);
	}
	return 0;
}

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

using namespace std;

typedef struct st_point {
	double x;
	double y;
} Point;

void calcVerticalBisector(Point &p1, Point &p2, double &a, double &b, double &c);
void SolvSimultaneousEquations(double a, double b, double c, double d, double e, double f, double &ansX, double &ansY);

int main(void)
{
	int n = 0;
	cin >> n;
	
	for(int i = 0; i < n; i++){
		Point p1 = {0};
		Point p2 = {0};
		Point p3 = {0};
		
		cin >> p1.x >> p1.y >> p2.x >> p2.y >> p3.x >> p3.y;
		
		double a1 = 0.0, b1 = 0.0, c1 = 0.0;
		double a2 = 0.0, b2 = 0.0, c2 = 0.0;
		
		//隣り合う頂点から垂直2等分線を2本求め、それらの交点を中点とする
		if(p1.y == p2.y){
			calcVerticalBisector(p1, p3, a1, b1, c1);
			calcVerticalBisector(p2, p3, a2, b2, c2);
		}
		else if(p2.y == p3.y){
			calcVerticalBisector(p1, p2, a1, b1, c1);
			calcVerticalBisector(p1, p3, a2, b2, c2);
		}
		else{
			calcVerticalBisector(p1, p2, a1, b1, c1);
			calcVerticalBisector(p2, p3, a2, b2, c2);
		}
		
		Point center = {0};
		SolvSimultaneousEquations(a1, b1, c1, a2, b2, c2, center.x, center.y);
		
		double radius = sqrt( (p1.x - center.x) * (p1.x - center.x) + (p1.y - center.y) * (p1.y - center.y) );
		
		cout << showpoint << setprecision(4) << center.x << " " << center.y << " " << radius << endl;
	}
	
	return 0;
}

void SolvSimultaneousEquations(double a, double b, double c, double d, double e, double f, double &ansX, double &ansY)
{
	//detが0になることはない
	double det = a * e - b * d;
	
	ansX = (c * e - b * f) / det;
	ansY = (a * f - c * d) / det;
}

void calcVerticalBisector(Point &p1, Point &p2, double &a, double &b, double &c)
{
	Point center = {0};
	center.x = (p1.x + p2.x) / 2.0;
	center.y = (p1.y + p2.y) / 2.0;
	
	//0割りが発生する場合は、slope=infとなり、a=0, c=-center.y となる
	double slope = (p1.y - p2.y) / (p1.x - p2.x);
	
	a = - 1.0 / slope;
	b = -1.0;
	c = - center.y - 1.0 / slope * center.x;
}