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 <cmath>
#include <cstdio>
#include <iomanip>

using namespace std;

int main(void){
	int num;
	cin >> num;
	for (int i=1; i<=num; ++i){
		double x1, y1, x2, y2, x3, y3;
		cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
		double e1_2 = sqrt(pow((x2-x1), 2) + pow((y2-y1), 2));
		double e2_3 = sqrt(pow((x2-x3), 2) + pow((y2-y3), 2));
		double e3_1 = sqrt(pow((x3-x1), 2) + pow((y3-y1), 2));
		double theta = acos((e1_2*e1_2 + e2_3*e2_3 - e3_1*e3_1) / (2*e1_2*e2_3));
		//正弦定理により
		double r = e3_1 / (2*sin(theta));
		double a1 = 2*(x2-x1);
		double b1 = 2*(y2-y1);
		double c1 = x1*x1 - x2*x2 + y1*y1 -y2*y2;
		double a2 = 2*(x3-x1);
		double b2 = 2*(y3-y1);
		double c2 = x1*x1 - x3*x3 + y1*y1 - y3*y3;
		double x = (b1*x2 - b2*c1) / (a1*b2 - a2*b1);
		double y = (c1*a2 - c2*a1) / (a1*b2 - a2*b1);
		cout << fixed << setprecision(3) << x << " " << y << " " << r << endl;
	}
	return 0;
}

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

double fpx(double a, double b, double c, double d, double e, double f);
double fpy(double a, double b, double c, double d, double e, double f);
double  fr(double a, double b, double c, double d);
string toStr(double a);
string intToString(int a);

int main() {
  int n;
  double x1, y1, x2, y2, x3, y3;

  cin >> n;
  
  for (int i = 0; i < n; i++) {
    cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
    double px = fpx(x1, y1, x2, y2, x3, y3);
    double py = fpy(x1, y1, x2, y2, x3, y3);
    double  r =  fr(x1, y1, px, py);

    cout << toStr(px) << " " << toStr(py) << " " << toStr(r) << endl;
  }
}


double fpx(double x1, double y1, double x2, double y2, double x3, double y3) {
  double a1, a2, b1, b2, c1, c2;

  a1 = 2 * (x2 - x1);
  b1 = 2 * (y2 - y1);
  c1 = x1 * x1 - x2 * x2 + y1 * y1 - y2 * y2;

  a2 = 2 * (x3 - x1);
  b2 = 2 * (y3 - y1);
  c2 = x1 * x1 - x3 * x3 + y1 * y1 - y3 * y3;

  return (b1 * c2 - b2 * c1) / (a1 * b2 - a2 * b1);
}

double fpy(double x1, double y1, double x2, double y2, double x3, double y3) {
  double a1, a2, b1, b2, c1, c2;

  a1 = 2 * (x2 - x1);
  b1 = 2 * (y2 - y1);
  c1 = x1 * x1 - x2 * x2 + y1 * y1 - y2 * y2;

  a2 = 2 * (x3 - x1);
  b2 = 2 * (y3 - y1);
  c2 = x1 * x1 - x3 * x3 + y1 * y1 - y3 * y3;

  return (c1 * a2 - c2 * a1) / (a1 * b2 - a2 * b1);
}

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

string toStr(double d) {
  string pm = "", val = "";
  if (d < 0) {
    pm = "-";
    d = -d;
  }

  int ipart = (int)d;
  int fpart = (int)( (d - (double)ipart) * 10000) + 10000;

  val = pm + intToString(ipart) + "." + intToString(fpart).substr(1, 3);
  return val;
}

string intToString(int n) {
  stringstream ss;
  ss << n;
  return ss.str();
}

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

int main(void){
  int n;
  double x1, y1, x2, y2, x3, y3;
  cin >> n;
  for(int i = 0; i < n; i++){
    cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
    double xp1 = x1 - x3, yp1 = y1 - y3, xp2 = x2 - x3, yp2 = y2 - y3;
    double A, B, C;
    double cx, cy, r;
    A = (xp1 / yp1 - xp2 / yp2);
    B = (xp1 * xp1 / yp1 + yp1) / 2;
    C = (xp2 * xp2 / yp2 + yp2) / 2;
    cx = (B - C) / A;
    cy = (xp1 * xp1 / yp1 + yp1) / 2 - cx * xp1 / yp1;
    cx += x3; cy += y3;
    r = hypot(cx - x1, cy - y1);
    printf("%.3lf %.3lf %.3lf\n", cx + 0.0005, cy + 0.0005, r + 0.0005);
  }
  return 0;
}

C++: #include<bits/stdc++.h>
using namespace std;
typedef complex<double> point;
typedef pair<point, point> line;
double cross(point a, point b){
  return imag(conj(a) * b);
}


point cross_point(line a, line b){
  double d1 = cross(b.second - b.first,
                    b.first - a.first);
  double d2 = cross(b.second - b.first,
                    a.second - a.first);
  return a.first + (a.second - a.first) * (d1/d2);
}

int main(int argc, char *argv[]){
  int n;
  cin >> n;
  for (int i = 0; i < n; i++) {
    point x[3];
    for (int j = 0; j < 3; j++) {
      double real, imag;
      cin >> real >> imag;
      x[j] = point(real, imag);
    }
    point m1 = (x[0] - x[1]), m2 = (x[1] - x[2]);
    m1 = point(m1.real()/2, m1.imag()/2);
    m2 = point(m2.real()/2, m2.imag()/2);
    line n1 = line(m1*point(0, 1), m1*point(0, -1)),
      n2 = line(m2*point(0, 1), m2*point(0, -1));
    n1.first += m1 + x[1];
    n1.second += m1 + x[1];
    n2.first += m2 + x[2];
    n2.second += m2 + x[2];
    point center = cross_point(n1, n2);
    center -= 
      printf("%5lf %5lf %5lf\n", center.real(), center.imag(),
             abs(center - x[0]));
  }
  return 0;
}

C++: #include <bits/stdc++.h>

using namespace std;

#define EPS (1e-6)

struct Point {
    double x, y;

    Point(){}
    Point(double x, double y) : x(x), y(y) {}

    Point operator + (const Point &p) const {
        return Point(x + p.x, y + p.y);
    }

    Point operator - (const Point &p) const {
        return Point(x - p.x, y - p.y);
    }
    
    Point operator * (const double &k) const {
        return Point(x * k, y * k);
    }
};

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

double norm(const Point &p)
{
    return dot(p, p);
} 

double abs(const Point &p)
{
    return sqrt(norm(p));
}

typedef vector<Point> Polygon;

struct Circle {
    Point p;
    double r;
    Circle(){}
    Circle(Point p, double r) : p(p), r(r) {}
};

Circle smallest_enclosing_circle(const Polygon &pg)
{    
    Point p(0, 0);
    int N = pg.size();
    for (int i = 0; i < (int)pg.size(); i++) {
	p = p + pg[i];
    }
    p = p * (1. / pg.size());
    double d = 0.5;
    for (int k = 1; k <= 30; k++) {
	for (int i = 0; i < 100; i++) {
	    int s = 0;
	    for (int j = 0; j < N; j++) {
		if (abs(pg[s] - p) - abs(pg[j] - p) < -EPS) {
		    s = j;
		}
	    }
	    p = p + (pg[s] - p) * d;
	}
	d *= 0.5;
    }
    double r = 0;
    for (int i = 0; i < N; i++) {
	if (r - abs(pg[i] - p) < -EPS) {
	    r = abs(pg[i] - p);
	}
    }
    return Circle(p, r);
}

int main()
{
    Polygon pg(3);
    int N;
    cin >> N;
    while (N--) {
        for (int i = 0; i < 3; i++) {
            cin >> pg[i].x >> pg[i].y;
        }
        auto c = smallest_enclosing_circle(pg);
        printf("%.3f %.3f %.3f\n", c.p.x, c.p.y, c.r);
    }
    return 0;
}