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 <cstdio>
#include <cassert>
#include <cmath>
#include <complex>
#include <vector>
#include <utility>
using namespace std;

typedef complex<double> Point;
#define X real()
#define Y imag()
#define EPS 10e-8

namespace std {
  bool operator < (Point a, Point b) {
    if (a.X != b.X) return a.X < b.X;
    return a.Y < b.Y;
  }
}

double cross(Point a, Point b) {
  return (conj(a)*b).Y;
}

double dot(Point a, Point b) {
  return (conj(a)*b).X;
}

double dist2(Point a, Point b) {
  return dot(a-b, a-b);
}

struct Line : public vector<Point> {
  Line(Point a, Point b) {push_back(a); push_back(b);}
};

int n;
Point ps[3];

Line PerpendBisect(Line l) {
  Point mid = (l[0]+l[1])/2.0;
  return Line(mid, mid+(l[1]-l[0])*Point(0, 1));
}

Point GetCrossPoint(Line l, Line m) {
  double A = cross(l[1]-l[0], m[1]-m[0]);
  double B = cross(l[1]-l[0], l[1]-m[0]);
  if (abs(A) < EPS && abs(B) < EPS) return m[0];
  if (abs(A) < EPS) assert(false);
  return m[0] + B / A * (m[1]-m[0]);
}

double round3(double t) {
  return floor(t*1000+0.5)/1000.0;
}

int main() {
  scanf("%d", &n);
  while (n--) {
    for (int i=0; i<3; i++) {
      double x, y;
      scanf("%lf%lf", &x, &y);
      ps[i] = Point(x, y);
    }

    Line l(ps[0], ps[1]);
    Line m(ps[1], ps[2]);
    Point p = GetCrossPoint(PerpendBisect(l), PerpendBisect(m));
    double r = sqrt(dist2(p, ps[0]));
    printf("%.3f %.3f %.3f\n", round3(p.X), round3(p.Y), round3(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));
		px[i]=LOSER(px[i]);
		py[i]=LOSER(py[i]);
		r[i]=LOSER(r[i]);
		i++;
		printf("%.3f %.3f %.3f",px[i],py[i],r[i]);
	}

	return 0;
}

C++: #include<stdio.h>
#include<math.h>
double sisyagonyuu3(double moto){
	if(moto>0){
		return (moto+0.0005)/100*100;
	}else if(moto==0){
		return 0;
	}else{
		return (moto-0.0005)/100*100;
	}
}
int main()
{
	int n;
	double x1[32],x2[32],x3[32],y1[32],y2[32],y3[32],p,q,r,coa,sna;
	double ac,ab,bc;
	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=sisyagonyuu3(((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]))/(2*(y1[i]-y3[i])*(x1[i]-x2[i])-2*(y1[i]-y2[i])*(x1[i]-x3[i])));
		q=sisyagonyuu3(((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]))/(2*(x1[i]-x3[i])*(y1[i]-y2[i])-2*(x1[i]-x2[i])*(y1[i]-y3[i])));
		ab=sqrt(fabs((x3[i]-x1[i])*(x3[i]-x1[i])+(y3[i]-y1[i])*(y3[i]-y1[i])));
		ac=sqrt(fabs((x3[i]-x2[i])*(x3[i]-x2[i])+(y3[i]-y2[i])*(y3[i]-y2[i])));
		bc=sqrt(fabs((x2[i]-x1[i])*(x2[i]-x1[i])+(y2[i]-y1[i])*(y2[i]-y1[i])));
		coa=(ac*ac+ab*ab-bc*bc)/(2*ac*ab);
		sna=1-coa*coa;
		r=sisyagonyuu3(bc/(sna*2));
		printf("%.3lf %.3lf %.3lf\n",p,q,r);
	}
	return 0;
}
/*?????\???*/

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

#define SQ(x) (x * x)

int main(void)
{
  int N, i;
  double x1, x2, x3;
  double y1, y2, y3;
  double a, b, c, d, e, f;
  double l, m, n;
  double xp,yp, r;

  cin >> N;
  for (i = 0; i < N; i++){
    cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
    
    a = x1 - x2;
    b = y1 - y2;
    c = -1 * (SQ(x1) - SQ(x2) + SQ(y1) - SQ(y2));
    d = x1 - x3;
    e = y1 - y3;
    f = -1 * (SQ(x1) - SQ(x3) + SQ(y1) - SQ(y3));
    
    l = (c * e - b * f) / (e * a - b * d);
    m = (d * c - a * f) / (d * b - e * a);
    
    n = -1 * (SQ(x1) + SQ(y1) + l * x1 + m * y1);
    
    xp = l / -2.0;
    yp = m / -2.0;
    r = sqrt(SQ(l) + SQ(m) - 4 * n) / 2.0;
    
    printf("%.3f %.3f %.3f\n", xp, yp, r);
  }
  return 0;
}

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

using namespace std;

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

C++: #include<iostream>
#include<math.h>
using namespace std;
int main() {
	double x1, x2, x3, px, y1, y2, y3, py,r;
	int n;
	cin >> n;
	for (int i = 0; i < n; i++) {
		cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
		if (y1 == y2) {
			px = (x1 + x2) / 2;
			py = (x1 - x3)*(x2 - x3) / (2 * (y3 - y1)) + (y1 + y3) / 2;
		}
		else if (y1 == y3) {
			px = (x1 + x3) / 2;
			py = (x1 - x2)*(x3 - x2) / (2 * (y2 - y1)) + (y1 + y2) / 2;
		}
		else {
			px = ((x1*x1 - x2*x2) / (y2 - y1) - (x1*x1 - x3*x3) / (y3 - y1) + y3 - y2) / (2 * ((x1 - x2) / (y2 - y1) - (x1 - x3) / (y3 - y1)));
			py = (px - (x1 + x2) / 2)*(x1 - x2) / (y2 - y1) + (y1 + y2) / 2;
		}
		r = sqrt((px - x1)*(px - x1) + (py - y1)*(py - y1));
		px = double(int(1000 * px + 0.5)) / 1000;
		py = double(int(1000 * py + 0.5)) / 1000;
		r = double(int(1000 * r + 0.5)) / 1000;
		cout << px << " " << py << " " << r << endl;
	}
	return 0;
}

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

typedef long long ll;
#define rep(i,n) for(int i=0;i<(n);++i)
#define dbg(x) cout << #x"="<< (x) << endl
#define fi first
#define se second
#define square(x) (x)*(x)

int main(){
	int n;
	cin >> n;
	vector<pair<double,double> > x(3);
	vector<double> d(3),r(3);
	pair<double,double> ans;
	double R;
	rep(j,n){
		rep(i,3){
			cin >> x[i].fi >> x[i].se;
		}
		d[0] = square(x[2].fi-x[1].fi) + square(x[2].se-x[1].se);
		d[1] = square(x[2].fi-x[0].fi) + square(x[2].se-x[0].se);
		d[2] = square(x[0].fi-x[1].fi) + square(x[0].se-x[1].se);
		r[0] = d[0]*(d[1]+d[2]-d[0]);
		r[1] = d[1]*(d[2]+d[0]-d[1]);
		r[2] = d[2]*(d[0]+d[1]-d[2]);
		R = r[0]+r[1]+r[2];
		ans.fi = (r[0]*x[0].fi+r[1]*x[1].fi+r[2]*x[2].fi)/R;
		ans.se = (r[0]*x[0].se+r[1]*x[1].se+r[2]*x[2].se)/R;
		R = square(x[0].fi-ans.fi) + square(x[0].se-ans.se);
		printf("%.3f %.3f %.3f\n",ans.fi,ans.se, sqrt(R));
	}
}