Go: package main

import (
	"fmt"
	"math"
)

func main() {
	n := scanInt()
	for i := 0; i < n; i++ {
		circleTriangle()
	}
}

func scanInt() int {
	var n int
	fmt.Scanf("%d", &n)
	return n
}

func circleTriangle() {
	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;

double sisya(double x)
{
	int a = static_cast<int>(x * 10000);
	x = static_cast<double>(static_cast<int>(x * 1000)) / 1000;
	if(a < 0 && a%10 <= -5)
		return x-0.001;
	else if(a%10 >= 5)
		return x+0.001;
	return x;
}

double dif(double x,double y,double xx, double yy)
{
	return sqrt((x-xx)*(x-xx)+(y-yy)*(y-yy));
}

int main()
{
	int n;
	double x1,x2,x3,y1,y2,y3;
	cin >> n;
	for(int i=0;i<n;i++){
		cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
		double maxx = max(x1,max(x2,x3));
		double maxy = max(y1,max(y2,y3));
		double minx = min(x1,min(x2,x3));
		double miny = min(y1,min(y2,y3));
		cout << setprecision(3) << fixed << sisya(maxx - (maxx - minx) / 2 )  << " ";
		cout << setprecision(3) << fixed << sisya(maxy - (maxy - miny) / 2 )  << " ";
		cout << setprecision(3) << fixed << sisya(dif(x1,y1,(maxx - minx)/2,(maxy - miny)/2)) << endl;
	}
	return 0;
}

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

using namespace std;

struct point{
	double x;
	double y;
};

struct linear{
	double a;
	double b;
	double c;
};

linear get_linear(point a, point b){
	linear l;

	if (a.x == b.x){
		l.a = 1;
		l.b = 0;
		l.c = a.x;
	}
	else if (a.y == b.y){
		l.a = 0;
		l.b = 1;
		l.c = a.y;
	}
	else{
		l.a = (b.x - a.x) / (b.y - a.y);
		l.b = -1;
		l.c = a.x * l.a - a.y;
	}
	return l;
}

linear get_linear_vertical(point p, linear l){
	linear lv;
	lv.a = (-1)*l.b;
	lv.b = l.a;
	lv.c = lv.a*p.x + lv.b*p.y;
	return lv;
}

point get_cross_point(linear l1, linear l2){
	point p;
	p.x = (l1.b*l2.c - l1.c*l2.b) / (l1.b*l2.a - l1.a*l2.b);
	p.y = (l1.c*l2.a - l1.a*l2.c) / (l1.b*l2.a - l1.a*l2.b);
	return p;
}

double point_distance(point s, point e){
	double d;
	d = (e.x - s.x)*(e.x - s.x) + (e.y - s.y)*(e.y - s.y);
	d = sqrt(d);
	return d;
}

int main()
{
	int n=1;
	double r;
	point p[3], mp, cp;
	linear l1, l2;

	cin >> n;
	vector<point> *v = new vector<point>[n];
	for (int i = 0; i < n; ++i){
		cin >> p[0].x >> p[0].y >> p[1].x >> p[1].y >> p[2].x >> p[2].y;
		v[i].push_back(p[0]);
		v[i].push_back(p[1]);
		v[i].push_back(p[2]);
	}
	for (int i = 0; i < n; ++i){
		l1 = get_linear(v[i].at(0), v[i].at(1));
		mp.x = (v[i].at(1).x + v[i].at(0).x) / 2;
		mp.y = (v[i].at(1).y + v[i].at(0).y) / 2;
		l1 = get_linear_vertical(mp, l1);

		l2 = get_linear(v[i].at(0), v[i].at(2));
		mp.x = (v[i].at(2).x + v[i].at(0).x) / 2;
		mp.y = (v[i].at(2).y + v[i].at(0).y) / 2;
		l2 = get_linear_vertical(mp, l2);

		cp = get_cross_point(l1, l2);
		r = point_distance(v[i].at(0), cp);

		cout << setprecision(3);
		cout << setiosflags(ios::fixed);
		cout << round(cp.x*1000.0)/1000.0 << ' '
			 << round(cp.y*1000.0)/1000.0 << ' '
			 << round(r*1000.0)/1000.0 << endl;
	}
	return 0;
}

C++: #include <cassert>
#include <cmath>
#include <cstdio>

int main() {
  int n = 0;
  scanf("%d", &n);

  for (int i = 0; i < n; ++i) {
    float x1, y1, x2, y2, x3, y3;
    scanf("%f %f %f %f %f %f", &x1, &y1, &x2, &y2, &x3, &y3);

    // x^2 + y^2 + lx + my + n = 0

    float A[3][3] = { {x1, y1, 1}, {x2, y2, 1}, {x3, y3, 1} };
    // detA = a00a11a22 + a10a21a02 + a20a01a12 - a00a21a12 - a20a11a02 - a10a01a22
    float detA =
        A[0][0] * A[1][1] * A[2][2]
      + A[1][0] * A[2][1] * A[0][2]
      + A[2][0] * A[0][1] * A[1][2]
      - A[0][0] * A[2][1] * A[1][2]
      - A[2][0] * A[1][1] * A[0][2]
      - A[1][0] * A[0][1] * A[2][2];

    assert(detA != 0);
    float invA[3][3] = {
        { (A[1][1] * A[2][2] - A[1][2] * A[2][1]) / detA,
          (A[0][2] * A[2][1] - A[0][1] * A[2][2]) / detA,
          (A[0][1] * A[1][2] - A[0][2] * A[1][1]) / detA },
        { (A[1][2] * A[2][0] - A[1][0] * A[2][2]) / detA,
          (A[0][0] * A[2][2] - A[0][2] * A[2][0]) / detA,
          (A[0][2] * A[1][0] - A[0][0] * A[1][2]) / detA },
        { (A[1][0] * A[2][1] - A[1][1] * A[2][0]) / detA,
          (A[0][1] * A[2][0] - A[0][0] * A[2][1]) / detA,
          (A[0][0] * A[1][1] - A[0][1] * A[1][0]) / detA }
    }; 

    float b[3] = {-(x1 * x1 + y1 * y1), -(x2 * x2 + y2 * y2), -(x3 * x3 + y3 * y3)};
    
    float l = invA[0][0] * b[0] + invA[0][1] * b[1] + invA[0][2] * b[2];
    float m = invA[1][0] * b[0] + invA[1][1] * b[1] + invA[1][2] * b[2];
    float n = invA[2][0] * b[0] + invA[2][1] * b[1] + invA[2][2] * b[2];
      
    // (x + l/2)^2 - l^2/4 + (y + m/2)^2 - m^2/4 + n = 0;
    // (x, y) = (-l/2, -m/2)
    // r = l^2/4 + m^2/4 - n
    float px = -l / 2;
    float py = -m / 2;
    float r = std::sqrt(l * l / 4.0 + m * m / 4.0 - n);
    
    printf("%.3f %.3f %.3f\n", px, py, r);
  }
}

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

void swap(double &x,double &y){
	double t;
	t=x;
	x=y;
	y=t;
}

double cut4(double x){
	double temp=x*pow(10,3);
	temp=double(int(temp+0.5));
	return temp*pow(10,-3);
}

int main(){
	int n;
	double x1,x2,x3,y1,y2,y3,px,py;
	double a,b,c,d,r;
	cin>>n;
	for(int i=0;i<n;i++){
		cin>>x1>>y1>>x2>>y2>>x3>>y3;
		if(x1==x2){
			swap(x2,x3);
			swap(y2,y3);
		}else if(x2==x3){
			swap(x1,x2);
			swap(y1,y2);
		}
		a=(y2-y1)/(x2-x1);
		c=(y3-y2)/(x3-x2);
		if(a&&c){
			a=-1/a;
			c=-1/c;
			b=(y1+y2)/2-a*(x1+x2)/2;
			d=(y2+y3)/2-c*(x2+x3)/2;
			px=(b-d)/(c-a);
			py=(b*c-a*d)/(c-a);
		}else if(!a){
			c=-1/c;
			d=(y2+y3)/2-c*(x2+x3)/2;
			px=(x1+x2)/2;
			py=c*(x1+x2)/2+d;
		}else if(!c){
			a=-1/a;
			b=(y1+y2)/2-a*(x1+x2)/2;
			px=(x2+x3)/2;
			py=a*(x2+x3)/2+b;
		}

		r=sqrt((px-x1)*(px-x1)+(py-y1)*(py-y1));
		px=(px==0.000?0.000:px);
		py=(py==0.000?0.000:px);
		printf("%.3lf %.3lf %.3lf\n",cut4(px),cut4(py),cut4(r));
	}
	return 0;
}

C++: #include <iostream>
#include <cmath>
#include <cstdio>
#include <string>
#include <sstream>

using namespace std;

long double sisya(long double a) {
	a *= 1000.0;
	//cout << a << endl;
	a += 0.5;
	a = (int)a;
	a /= 1000.0;
	return a; 
}

double ll(double x1, double y1, double x2, double y2) {
	return sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2));
}

int main() {
	int n;
	cin >> n;
	for (int i = 0; i < n; i++) {
		double x[3], y[3];
		for (int j = 0; j < 3; j++) {
			cin >> x[j] >> y[j];
		}
		double a1, a2, b1, b2, c1, c2;
		a1 = 2.0 * (x[1]-x[0]);
		a2 = 2.0 * (x[2]-x[0]);
		b1 = 2.0 * (y[1]-y[0]);
		b2 = 2.0 * (y[2]-y[0]);
		c1 = x[0]*x[0]-x[1]*x[1]+y[0]*y[0]-y[1]*y[1];
		c2 = x[0]*x[0]-x[2]*x[2]+y[0]*y[0]-y[2]*y[2];
		double X, Y, R;
		X = (b1*c2-b2*c1)/(a1*b2-a2*b1);
		Y = (c1*a2-c2*a1)/(a1*b2-a2*b1);
		R = ll(X, Y, x[0], y[0]);
		//X = sisya(X);
		//Y = sisya(Y);
		//R = sisya(R);
		printf("%.3f %.3f %.3f\n", X, Y, R);
	}
	return 0;
}

C++: 
#include<iostream>
#include<math.h>
using namespace std;

int main()
{
    int n;
    int x1,x2,x3,y1,y2,y3;
    cin>>n;
    while(n--)
    {
        double x,y,r,dx,dy;
        cin>>x1>>y1>>x2>>y2>>x3>>y3;
        dx=(x2+x3-2*x1)/2;
        dy=(y2+y3-2*y1)/2;
        x=x1+dx;
        y=y1+dy;
        r=sqrt(dx*dx+dy*dy);
        printf("%.3f %.3f %.3f\n",x,y,r);
    }
    return 0;
}