Go: package main

import (
	"fmt"
	"math"
)

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

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

func cal() {
	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 <stdio.h>
#include <string>
#include <queue>
#include <cmath>

#define int64 long long int

using namespace std;

int main()
{
	int n;
	double x1,y1,x2,y2,x3,y3,x,y,r;
	double det,a1,b1,a2,b2,c1,c2;
	cin >> n;
	for(int i=0; i<n; i++){
		cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
		a1 = 2 * (x1 - x2), b1 = 2 * (y1 - y2);
		a2 = 2 * (x2 - x3), b2 = 2 * (y2 - y3);
		det = a1 * b2 - a2 * b1;
		c1 = (x1*x1 - x2*x2) + (y1*y1 - y2*y2);
		c2 = (x2*x2 - x3*x3) + (y2*y2 - y3*y3);
		x = (a1 * c1 + b1 * c2) / det;
		y = (a2 * c1 + b2 * c2) / det;
		r = sqrt((x - x1)*(x - x1) + (y - y1)*(y - y1));
		printf("%.3f %.3f %.3f\n", x, y, r);
	}
	return 0;
}

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

double a, b, c, d, e, f;
double x, y;

double RoundNumber(double f) {
  int tf = (int)(10000 * f);
  if (tf % 10 >= 5) {
    tf += 10;
  }
  tf /= 10;
  return (double)tf / 1000.0f;
}

void solve(){
  /*
  double tmp1 = f-(c*d/a);
  double tmp2 = e-(b*d/a);
  y = tmp1/tmp2;
  x = (c - b * y) / a;
  */
  x = (c*e-b*f) / (a*e-b*d);
  y = (c*d-a*f) / (b*d-a*e);
  printf("%.3f %.3f ", RoundNumber(x), RoundNumber(y));        
}

int main(int argc, char const* argv[]) {
  int n;
  cin>>n;
  for (int i = 0; i < n; i += 1) {
    double x1, y1, x2, y2, x3, y3;
    cin>>x1>>y1>>x2>>y2>>x3>>y3;
    a = -2*x1 + 2*x2;
    b = -2*y1 + 2*y2;
    c = x2*x2 + y2*y2 - x1*x1 - y1*y1;
    d = -2*x1 + 2*x3;
    e = -2*y1 + 2*y3;
    f = x3*x3 + y3*y3 - x1*x1 - y1*y1;

    solve();
    
    double r = (x - x1)*(x - x1) + (y - y1)*(y - y1);
    r = sqrt(r);
    printf("%.3f\n", RoundNumber(r));
  }  
  return 0;
}

C++: 
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <ctime>
#include <cassert>
#include <iostream>
#include <cctype>
#include <sstream>
#include <string>
#include <list>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <utility>
#include <numeric>
#include <algorithm>
#include <bitset>
#include <complex>
#include <fstream>
using namespace std;
typedef long long ll;
const double EPS = 1e-9;
typedef vector<int> vint;
typedef pair<int, int> pint;
#define rep(i, n) REP(i, 0, n)
#define ALL(v) v.begin(), v.end()
#define MSG(a) cout << #a << " " << a << endl;
#define REP(i, x, n) for(int i = x; i < n; i++)
template<class T> T RoundOff(T a){ return int(a+.5-(a<0)); }
template<class T, class C> void chmax(T& a, C b){ if(a < b) a = b; }
template<class T, class C> void chmin(T& a, C b){ if(b < a) a = b; }
template<class T, class C> pair<T, C> mp(T a, C b){ return make_pair(a, b); }


struct P{ double x, y; };


int main()
{
	int n;
	cin >> n;
	
	rep(i, n)
	{
		vector<P> v(3);

		rep(i, 3)
			cin >> v[i].x >> v[i].y;

		double a = v[0].x - v[1].x;
		double b = v[0].y - v[1].y;
		double c = v[1].x - v[2].x;
		double d = v[1].y - v[2].y;

		double A = pow(v[1].x, 2.0) - pow(v[0].x, 2.0) + pow(v[1].y, 2.0) + pow(v[0].y, 2.0);
		double B = pow(v[2].x, 2.0) - pow(v[1].x, 2.0) + pow(v[2].y, 2.0) + pow(v[1].y, 2.0);

		double acbd = a * d - b * c;

		double l = -(A * d - B * b) / acbd / 2;
		double m = -(B * a - A * c) / acbd / 2;

		double r = sqrt(pow(l - v[0].x, 2.0) + pow(m - v[0].y, 2.0));

		printf("%.3f %.3f %.3f\n", l, m, r);
	}
}

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

int main(){
	int n;
	double x1, y1, x2, y2, x3, y3, m1, m2, m3, b1, b2, b3, px, py, r;
	double d[2], e[2], f[2];
	cin >> n;
	for(int i = 0; i < n; i++){
		cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
		d[0] = (x2 + x3) / 2;
		d[1] = (y2 + y3) / 2;
		e[0] = (x3 + x1) / 2;
		e[1] = (y3 + y1) / 2; int count = 0;
        for(int i = 0; i <= n; i++){
            if(num[i]){
                count++;
            }
        }
        cout << count << endl;
    }

		f[0] = (x1 + x2) / 2;
		f[1] = (y1 + y2) / 2;
		m1 = (y3 - y2) / (x3 - x2);
		m2 = (y1 - y3) / (x1 - x3);
		m3 = (y2 - y1) / (x2 - x1);
		b1 = d[1] + d[0] / m1;
		b2 = e[1] + e[0] / m2;
		b3 = f[1] + f[0] / m3;
		px = -(b1 - b2) / ((1 / m2) - (1 / m1));
		py = -(1 / m1) * px + b1;
		r = (double)sqrt((x1 - px) * (x1 - px) + (y1 - py) * (y1 - py));
		px = floor(1000 * (px + 0.0005)) / 1000;
		py = floor(1000 * (py + 0.0005)) / 1000;
		r = floor(1000 * (r + 0.0005)) / 1000;
		cout << fixed << setprecision(3) << px << " " <<  py << " " << r << endl;
	}
	return 0;
}

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

using namespace std;

float round(float val){return ((int)(val*1000+0.5)/1000.0);}

int main(void){
	int n;
	float x[3],y[3],a,b,c,d,X,Y,px,py;

	cin >> n;
	for(int i=0;i<n;i++){
		for(int j=0;j<3;j++)
			cin >> x[j] >> y[j];

		a=x[0]-x[1];
		b=y[0]-y[1];
		c=x[0]-x[2];
		d=y[0]-y[2];
		X=pow(x[0],2)-pow(x[1],2)+pow(y[0],2)-pow(y[1],2);
		Y=pow(x[0],2)-pow(x[2],2)+pow(y[0],2)-pow(y[2],2);
		px=(d*X-b*Y)/(a*d-b*c)/2;
		py=(-c*X+a*Y)/(a*d-b*c)/2;

		printf("%.3f %.3f %.3f\n",round(px),round(py),round(sqrt(pow(x[0]-px,2)+pow(y[0]-py,2))));
	}
	return 0;
}

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

//line is ax + by = c
struct Line{
  double a, b, c;
};

struct Node{
  double x, y;
};

Line perpendicular_bisector(Node a, Node b){
  Line result;
  result.a = a.x - b.x;
  result.b = a.y - b.y;
  result.c = (a.x * a.x - b.x * b.x + a.y * a.y - b.y * b.y) / 2;
  return result;
}

Node intersection(Line l, Line m){
  Node result;
  result.x = (m.b * l.c - l.b * m.c) / (l.a * m.b - m.a * l.b);
  result.y = (m.a * l.c - l.a * m.c) / (m.a * l.b - l.a * m.b);
  return result;
}

double distance(Node a, Node b){
  return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
}

void solve(){
  Node A, B, C;
  cin >> A.x >> A.y;
  cin >> B.x >> B.y;
  cin >> C.x >> C.y;
  Line l = perpendicular_bisector(A, B);
  Line m = perpendicular_bisector(A, C);
  Node center = intersection(l, m);
  double raidus = distance(center, A);
  printf("%.3lf %.3lf %.3lf", center.x, center.y, raidus);
}

int main(){
  int N;
  cin >> N;
  while(N--){
    solve();
  }
}

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

using namespace std;
double a, b, c, d, e, f;
double x, y;


void function(){
	if(c/b == f/e){
		x = 0;
		y = c/b;
	}else if(c/a == f/d){
		y = 0;
		x = c/a;
	}else{
		y = (c*d - a*f)/(d*b - a*e);
		x = (c - b*y)/a;
	}
	return;
}


int main(){
	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;

		if((y2-y1) == 0){
			a = 2*(x3 - x1);
			b = 2*(y3 - y1);
			c = (x3 - x1)*(x1 + x3) + (y3 - y1)*(y1 + y3);

			d = 2*(x3 - x2);
			e = 2*(y3 - y2);
			f = (x3 - x2)*(x2 + x3) + (y3 - y2)*(y2 + y3);
		}else if((y3-y1) == 0){

			a = 2*(x2 - x3);
			b = 2*(y2 - y3);
			c = (x2 - x3)*(x2 + x3) + (y2 - y3)*(y2 + y3);

			d = 2*(x2 - x1);
			e = 2*(y2 - y1);
			f = (x2 - x1)*(x1 + x2) + (y2 - y1)*(y1 + y2);
		}else{

			a = 2*(x3 - x1);
			b = 2*(y3 - y1);
			c = (x3 - x1)*(x1 + x3) + (y3 - y1)*(y1 + y3);

			d = 2*(x2 - x1);
			e = 2*(y2 - y1);
			f = (x2 - x1)*(x1 + x2) + (y2 - y1)*(y1 + y2);
		}
		function();
		double r;
		r = sqrt((x - x1)*(x - x1) + (y - y1)*(y - y1));

		printf("%.3lf %.3lf %.3lf\n",x, y, r);
	}
	return 0;
}