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 <bits/stdc++.h>
#include <chrono>
using namespace std;

using _i64 = int64_t;
using _u64 = uint64_t;
using _f64 = double;

#define _for(i, start, end) for(_i64 i = (_i64)start; i < (_i64)end; ++i)
#define _rep(i, number) _for(i, 0, number)
#define _foreach(e, data) for(auto& e : data)
#define _all(data) data.begin(), data.end()

template<typename type>
_i64 _size(const type& data) { return static_cast<_i64>(data.size()); }
template<typename type, size_t size>
_i64 _size(const type (&)[size]) { return static_cast<_i64>(size); }

enum _flag : bool { able = true, disable = false };

struct _time {
    _time(_flag flag) { check = flag; if(!check) { return; } gettime(start); }
    ~_time() {
        if(!check) { return; }; gettime(end);
        _i64 elapse = chrono::duration_cast<chrono::milliseconds>(end - start).count();
        cout << endl << "Time: " << elapse << " ms" << endl;
    }
    private:
    using _timer = chrono::time_point<chrono::system_clock>;
    _timer start, end; bool check;
    void gettime(_timer& time) { time = chrono::system_clock::now(); }
};

struct _ini { _ini() { ios::sync_with_stdio(false); cin.tie(nullptr); } } _ini;

int main() {
    {
        _time time(disable);
        _f64 n, x1, y1, x2, y2, x3, y3, px, py, r, a, b, c, d, e, f;
        cin >> n;
        _rep(i, n) {
            cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
            a = x1 * 2 - x2 * 2;
            b = y1 * 2 - y2 * 2;
            c = pow(x1, 2) + pow(y1, 2) - pow(x2, 2) - pow(y2, 2);
            d = x2 * 2 - x3 * 2;
            e = y2 * 2 - y3 * 2;
            f = pow(x2, 2) + pow(y2, 2) - pow(x3, 2) - pow(y3, 2);
            px = (c * e - f * b) / (a * e - d * b) + DBL_EPSILON;
            py = (c * d - f * a) / (b * d - e * a) + DBL_EPSILON;
            r = sqrt(pow((px - x1), 2) + pow((py - y1), 2)) + DBL_EPSILON;
            cout << fixed << setprecision(3) << px << " " << py << " " << r << endl;
        }
    }
    return 0;
}

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

double marume( double x ){
	long long t = x * 1000 + ((x > 0) ? 1 : -1) * 0.5;
	return t/1000.0;
}

int main(){
	int n;
	double tx, ty, x1, y1, x2, y2;
	
	cin >> n;
	while(n--){
		cin >> tx >> ty >> x1 >> y1 >> x2 >> y2;
		x1 -= tx; y1 -= ty;
		x2 -= tx; y2 -= ty;
		
		double dist1 = x1 * x1 + y1 * y1;
		double dist2 = x2 * x2 + y2 * y2;
		x1 *= 2; y1 *= 2;
		x2 *= 2; y2 *= 2;
		
		double detA = x1 * y2 - y1 * x2;
		double detX = dist1 * y2 - y1 * dist1;
		double detY = x1 * dist2 - dist2 * x1;
		double x = detX / detA; //if(x < 0){ x -= 1e-5; } else { x += 1e-5; }
		double y = detY / detA; //if(y < 0){ y -= 1e-5; } else { y += 1e-5; }
		double r = hypot(x, y) + 1e-7;
		
		x += tx;
		y += ty;
		
		//x = marume(x);
		//y = marume(y);
		//r = marume(r);
		printf("%.3Lf %.3Lf %.3Lf\n", x, y, r);
	}
	return 0;
}

C++: #include <iostream>
#include <cstdio>
#include <cmath>
using namespace std;
int main(){
  double x1,x2,x3,y1,y2,y3;
  int n;
  while(cin >> n){
    for(int i = 0 ; i < n ; i++){
      cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3; 
      double a = 2*(x2 - x1),b = 2*(y2 - y1),c = x1*x1 - x2*x2 + y1*y1 - y2*y2;
      double a2 = 2*(x3 - x1),b2 = 2*(y3 - y1),c2 = x1*x1 - x3*x3 + y1*y1 - y3*y3;
      double x = (b*c2 - b2*c)/(a*b2 - a2*b);
      double y = (c*a2 - c2*a)/(a*b2 - a2*b);
      double r = sqrt(pow(x-x1,2) + pow(y-y1,2));

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

C++: #include<iostream>
#include<cstdio>
#include<math.h>

using namespace std;

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

C++: #include <bits/stdc++.h>
using namespace std;

double eps = 1e-10;

class Point {
public:
	double x, y;
	
	Point(double x = 0, double y = 0) : x(x), y(y) {}
	
	Point operator + (const Point& p) {
		return Point(x + p.x, y + p.y);
	}
	Point operator - (const Point& p) {
		return Point(x - p.x, y - p.y);
	}
	Point operator * (const double& a) {
		return Point(x * a, y * a);
	}
	Point operator / (const double& a) {
		return Point(x / a, y / a);
	}
	
	bool operator < (const Point& p) const {
		return x != p.x ? x < p.x : y < p.y;
	}
	bool operator == (const Point &p) const {
		return fabs(x - p.x) < eps && fabs(y - p.y) < eps;
	}
	
	double abs() {
		return sqrt(norm());
	}
	double norm() {
		return x * x + y * y;
	}
	
};

typedef Point Vector;

bool equals(const double& a, const double& b) {
	return fabs(a - b) < eps;
}

double dot(const Vector& a, const Vector& b){
	return a.x * b.x + a.y * b.y;	
}

double cross(const Vector& a, const Vector& b){
	return a.x * b.y - a.y * b.x;
}

class Triangle {
public:
	Point p1, p2, p3; // ??????
	Vector v1, v2, v3; // ??????????????????
	double e1, e2, e3; // ????????§??????
	double a1, a2, a3; // ?§????(????????¢???)
	
	Triangle(Point a, Point b, Point c) : p1(a), p2(b), p3(c) {
		v1 = p3 - p2; v2 = p3 - p1; v3 = p2 - p1;
		e1 = v1.abs(); e2 = v2.abs(); e3 = v3.abs();
		a1 = law_of_cosines(e1, e2, e3); a2 = law_of_cosines(e2, e1, e3);
		a3 = law_of_cosines(e3, e2, e1);
	}
	
	// ????????????(?????????:?§????)
	double law_of_cosines(const double& a, const double& b, const double& c) { 
		return acos((b * b + c * c - a * a) / (2.0 * b * c));
	}
	
	Vector calc_circumcenter() {
		return (v1 * sin(2.0 * a1) + v2 * sin(2.0 * a2) + v3 * sin(2.0 * a3))
		       / (sin(2.0 * a1) + sin(2.0 * a2) + sin(2.0 * a3));
	}
};

int main() {
	int n;
	cin >> n;
	double x1, x2, x3, y1, y2, y3;
	for(int i = 0; i < n; ++i){
		cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
		Triangle t = Triangle(Point(x1, y1), Point(x2, y2), Point(x3, y3));
		Vector p = t.calc_circumcenter();
		printf("%.3f %.3f %.3f\n", p.x, p.y, (t.p3 - p).abs());
	}
	return 0;
}

C++: #include <iostream>
#include <string>
#include <vector>
#include <cmath>
#include <algorithm>
#include <cstdlib>
#include <ctime>
#include <cstdio>
#include <functional>

using namespace std;

int main()
{

	int n;
	double a,b,c,d,e,f,x1,x2,x3,y1,y2,y3;
	double ans_x,ans_y,ans_r;

	cin>>n;

	for(int i=0;i<n;i++){

		cin>>x1>>y1>>x2>>y2>>x3>>y3;


		if(y1==y2){
			ans_x=(x1+x2)/2.0;
			a=-(x3-x2)/(y3-y2);
			b=(x2+x3)/2.0; c=(y2+y3)/2.0;

		}else if(y2==y3){
			ans_x=(x2+x3)/2.0;
			a=-(x2-x1)/(y2-y1);
			b=(x1+x2)/2.0; c=(y1+y2)/2.0;

		}else{
			a=-(x2-x1)/(y2-y1);
			b=(x1+x2)/2.0; c=(y2+y1)/2.0;
			
			d=-(x3-x2)/(y3-y2);
			e=(x2+x3)/2.0; f=(y2+y3)/2.0;

			ans_x=(a*b-d*e-c+f)/(a-b);
		}
		
		ans_y=a*(ans_x-b)+c;

		ans_r=sqrt( (x1-ans_x)*(x1-ans_x) + (y1-ans_y)*(y1-ans_y) );

		printf("%.3f %.3f %.3f\n",ans_x,ans_y,ans_r);

	}

	return 0;

}