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<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((x1[i]-x3[i])*(x1[i]-x3[i])+(y1[i]-y3[i])*(y1[i]-y3[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",q,p,r);
	}
	return 0;
}
/*?????\???*/

C++: #include<iostream>
#include<vector>
#include<complex>
#define EPS 1e-10
using namespace std;    

typedef complex<double> P;

double cross(P a, P b){
  return (a.real()*b.imag() - a.imag()*b.real());
}

int main()
{
  int i,j;
  int n;
  P point[3],ans;

  cin >> n;
  for(i=0;i<n;i++){

    for(j=0;j<3;j++){
      cin >> point[j].real() >> point[j].imag();
    }

    P p01 = point[0] + point[1];
    P p12 = point[1] + point[2];
    P h01 = P(p01.real()/2 , p01.imag()/2);
    P h12 = P(p12.real()/2 , p12.imag()/2);
    P n1 = (point[0] - h01) * P(0,1) + h01;
    P n2 = (point[1] - h12) * P(0,1) + h12;

    ans = n1 + (h01-n1) * cross(h12-n2,n2-n1) / cross(h12-n2,h01-n1);

    cout.precision(4);
    cout << showpoint << real(ans) + EPS << " " << imag(ans) + EPS << " ";
    cout << abs(point[0]-ans) << endl;
  }
  return 0;
}

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

int main() {
	int n;
	cin>>n;
	for(int h=0;h<n;h++){
double x1,y1,x2,y2,x3,y3,x2m,x3m,y2m,y3m,x21,y21,x31,y31,xy21,xans,yans;
cin>>x1>>y1>>x2>>y2>>x3>>y3;
	x2m=(x1+x2)/2;
	y2m=(y1+y2)/2;
	x3m=(x1+x3)/2;
	y3m=(y1+y3)/2;
	x21=x2-x1;
	x31=x3-x1;
	y21=y2-y1;
	y31=y3-y1;
	
	
if(y1!=y2){
	xy21=x21/y21;
	xans=(x31*x3m+y31*xy21*x2m+y3m-y2m)/(x31+y31*xy21);
	yans=xy21*(xans-x2m)+y2m;
}	
else{
	xans=x2m;
	yans=(x3m-xans)*x31/y31+y3m;
}
double r;
r=sqrt((xans-x1)*(xans-x1)+(yans-y1)*(yans-y1));
	printf("%.3f %.3f %.3f\n",xans,yans,r);
}

	return 0;
}

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

int main()
{
	std::uint32_t n;
	std::cin >> n;
	for (std::uint32_t i = 0; i < n; ++i) {
		double x1, y1, x2, y2, x3, y3;
		std::cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;

		double const a = x1 - x2, b = y1 - y2;
		double const c = x1 - x3, d = y1 - y3;
		double const e = a * (x1 + x2) / 2 + b * (y1 + y2) / 2;
		double const f = c * (x1 + x3) / 2 + d * (y1 + y3) / 2;
		double const denominator = a * d - b * c;
		double const px = (e * d - b * f) / denominator;
		double const py = (a * f - e * c) / denominator;
		std::cout.setf(std::ios::fixed | std::ios::showpoint);
		std::cout.precision(3);
		std::cout << px << ' ' << py << ' '
			      << std::hypot(px - x1, py - y1) << std::endl;
	}
	return 0;
}

C++: #include <iostream>
#include <algorithm>
#include <complex>
#include <vector>
#include <cmath>
#include <cstdio>
using namespace std;
typedef complex<double> P;

const double eps = 1e-5;
vector<P> ps(3);
double R;

double eval(P p) {
  double sum = 0;
  for(int i = 0; i < ps.size(); ++i)
    sum += abs(R-abs(p-ps[i]));
  return sum;
}

P getBestP(P o, double r) {
  double s = 200;
  double mini = 1e100;
  P bestP;
  double begin = -r;
  double end = r;
  for(int i = 0; i < s; ++i) {
    for(int j = 0; j < s; ++j) {
      P v(begin + j/s*(end-begin), begin + i/s*(end-begin));
      P p = o+v;
      double tmp = eval(p);
      if(tmp < mini) {
	mini = tmp;
	bestP = p;
      }
    }
  }
  return bestP;
}

int main() {
  int Tc;
  cin >> Tc;
  for(int tc = 0; tc < Tc; ++tc) {
    for(int i = 0; i < ps.size(); ++i) cin >> ps[i].real() >> ps[i].imag();
    R = abs(ps[1]-ps[2])/abs(sin(arg(ps[1]-ps[0])-arg(ps[2]-ps[0])))/2.0;
    P res(0,0);
    for(double r = 100.0; r > eps; r *= 0.1) {
      res = getBestP(res, r);
    }
    printf("%.3f %.3f %.3f\n", res.real(), res.imag(), R);
  }
  return 0;
}

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

double get_num(double x){
	x = x * 1000;
	if(x >= 0){
		x = (int)(x + 0.5);
		return ((double)x / 1000);
	} else {
		x = (int)(x - 0.5);
		return ((double)x / 1000);
	}
}

int main()
{
	int n;
	cin >> n;
	for(int i = 0; i < n; i++){
		double x1, y1;
		double x2, y2;
		double x3, y3;
		double m12x, m12y;
		double m13x, m13y;
		double dx12, dy12;
		double dx13, dy13;
		double c12, c13;
		double xp, yp;
		double r;
		cin >> x1 >> y1 >> x2
			>> y2 >> x3 >> y3;
		m12x = (x1 + x2) / 2;
		m12y = (y1 + y2) / 2;
		m13x = (x1 + x3) / 2;
		m13y = (y1 + y3) / 2;
		dx12 = x2 - x1;
		dy12 = y2 - y1;
		dx13 = x3 - x1;
		dy13 = y3 - y1;
		c12 = m12x * dx12 + m12y * dy12;
		c13 = m13x * dx13 + m13y * dy13;
		yp = (c12 * dx13 - c13 * dx12) / (dy12 * dx13 - dy13 * dx12);
		if(dx12 == 0){
			xp = (c13 - (dy13 * yp)) / dx13;
		}else{
			xp = (c12 - (dy12 * yp)) / dx12;
		}
		r = sqrt((xp - x1) * (xp - x1) + ((yp - y1) * (yp - y1)));
		xp = get_num(xp);
		yp = get_num(yp);
		r = get_num(r);
		cout << fixed << setprecision(3) << xp << " " << yp << " " << r << endl;

	}
	return 0;
}

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

int main()
{
	int n;
	double x1,x2,x3,y1,y2,y3,x,y,r;
	double a,b,c;
	scanf("%d",&n);
	for(int i=0;i<n;i++){
		scanf("%lf%lf%lf%lf%lf%lf",&x1,&x2,&x3,&y1,&y2,&y3);
	    x=(y1-y3)*(y1*y1-y2*y2+x1*x1-x2*x2)-(y1-y2)*(y1*y1-y3*y3+x1*x1-x3*x3);
	    x/=(2*(y1-y3)*(x1-x2)-2*(y1-y2)*(x1-x3));
	 
	    y=(x1-x3)*(x1*x1-x2*x2+y1*y1-y2*y2)-(x1-x2)*(x1*x1-x3*x3+y1*y1-y3*y3);
	    y/=(2*(x1-x3)*(y1-y2)-2*(x1-x2)*(y1-y3));

		c=sqrt((x1-x3)*(x1-x3)+(y1-y3)*(y1-y3));
		b=sqrt((x3-x2)*(x3-x2)+(y3-y2)*(y3-y2));
		a=sqrt((x2-x1)*(x2-x1)+(y2-y1)*(y2-y1));
		r=a*b*c/sqrt((a+b+c)*(-a+b+c)*(a-b+c)*(a+b-c));
		printf("%.3f %.3f %.3f\n",x,y,r);
	}
	return 0;
}
/*?????\???*/