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 <iostream>
#include <iomanip>
#include <cmath>
using namespace std;

int main()
{
	double x1, y1, x2, y2, x3, y3;
	int n;
	cin >> n;
	double distanceA, distanceB, distanceC, sinA, r, p, q;
	for (int i = 0; i < n; ++i) 
	{
		cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;

		distanceA = sqrt((x1 - x3)*(x1 - x3) + (y1 - y3)*(y1 - y3)), distanceB = sqrt((x2 - x3)*(x2 - x3) + (y2 - y3)*(y2 - y3)), distanceC = sqrt((x1 - x2)*(x1 - x2) + (y1 - y2)*(y1 - y2));
	    sinA = sqrt(1.0 - pow((pow(distanceB, 2) + pow(distanceC, 2) - pow(distanceA, 2)) / (distanceB*distanceC * 2), 2));
		r = distanceA / (2 * sinA);
		p = ((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));
		q = ((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));

		cout << fixed << setprecision(3) << p << " " << q << " " << r << endl;
	}

	return 0;
}

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

int main(void) {
  int i, n, j, k;
  double x1, y1, x2, y2, x3, y3;
  scanf("%d", &n);
  for(i = 0; i < n; ++i) {
    scanf("%lf%lf%lf%lf%lf%lf", &x1, &y1, &x2, &y2, &x3, &y3);
    double xt1 = (x1 + x2) / 2, xt2 = (x3 + x2) / 2, yt1 = (y1 + y2) / 2, yt2 = (y3 + y2) / 2;
    double t1 = y1 - y2, t2 = y2 - y3;
    double x, y, k1, k2;
    if(!t1) {
      x = xt1;
      k2 = (x2 - x3) / (y2 - y3);
      y = k2 * (x - xt2) + yt2;
    } else if(!t2) {
      x = xt2;
      k1 = (x1 - x2) / (y1 - y2);
      y = k1 * (x - xt1) + yt1;
    } else {
      k1 = (x1 - x2) / (y1 - y2), k2 = (x2 - x3) / (y2 - y3);
      x = ((k1 * xt1 - k2 * xt2) - (yt1 - yt2)) / (k1 - k2);
      y = k1 * (x - xt1) + yt1;
    }
    double r = sqrt((x - x1) * (x - x1) + (y - y1) * (y - y1));
    //printf("%f %f %f %f \n", xt1, yt1, xt2, yt2);
    printf("%.3f %.3f %.3f\n", x, y, r);
  }
  return 0;
}

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

using namespace std;

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

  cin >> datasetnum;

  for (int loopcount = 0; loopcount < datasetnum; loopcount++) {
    double px,py,r;

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

    double len_1 = sqrt(pow(x3-x2,2)+pow(y3-y2,2));
    double len_2 = sqrt(pow(x1-x3,2)+pow(y1-y3,2));
    double len_3 = sqrt(pow(x2-x1,2)+pow(y2-y1,2));

    double s = (len_1+len_2+len_3)/2;
    double area = sqrt(s*(s-len_1)*(s-len_2)*(s-len_3));

    double sin_1 = 2*area/(len_2*len_3);

    r = len_1/(2*sin_1);

    double a = x1 - x3;
    double b = y1 - y3;
    double c = pow(x1,2)-pow(x3,2)+pow(y1,2)-pow(y3,2);
    double d = x2 - x3;
    double e = y2 - y3;
    double f = pow(x2,2)-pow(x3,2)+pow(y2,2)-pow(y3,2);

    px = (c*e-b*f)/(2*(a*e-b*d));
    py = (c*d-a*f)/(2*(b*d-a*e));

    cout << fixed << setprecision(3) << px << " " << py << " " << r << endl;
  }

  return 0;
}

C++: #include<iostream>
#include<stdio.h>
#include<cmath>

using namespace std;

int main()
{
	int i;
	cin >> i;
	while (i--)
	{
		float x1, y1, x2, y2, x3, y3, x_1, y_1,x_2,y_2,x,y,r;
		cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
		x_1 = x2 - x1; y_1 = y2 - y1;
		x_1 /= 2; y_1 /= 2;
		x_2 = x3 - x1; y_2 = y3 - y1;
		x_2 /= 2; y_2 /= 2;
		x = (y_1 * y_2*(y_2 - y_1) + (y_1*x_2*x_2 - x_1*x_1*y_2)) / (y_1*x_2 - x_1*y_2);
		y = (x_1 * x_2*(x_2 - x_1) + (x_1*y_2*y_2 - y_1*y_1*x_2)) / (x_1*y_2 - y_1*x_2);
		r = sqrt((x - x1)*(x - x1) + (y - y1)*(y - y1));
		printf("%.3f %.3f %.3f\n", x, y,r);
	}
	return 0;
}

C++: #include <iostream>
#include <vector>
#include <cmath>
#include <iomanip>

using namespace std;

struct point{
    double x;
    double y;
};

struct linear{
    double a;
    double b;
    double c;
};

linear get_linear(point a, point b){
    linear l;

    if(a.x == b.x){
        l.a = 1;
        l.b = 0;
        l.c = a.x;
    }else if(a.y == b.y){
        l.a = 0;
        l.b = 1;
        l.c = a.y;
    }else{
        l.a = (b.x-a.x)/(b.y-a.y);
        l.b = -1;
        l.c = a.x * l.a - a.y;
    }
    return l;
}

linear get_linear_vertical(point p, linear l){
    linear lv;
    lv.a = (-1)*l.b;
    lv.b = l.a;
    lv.c = lv.a*p.x + lv.b*p.y;
    return lv;
}

point get_cross_point(linear l1, linear l2){
    point p;
    p.x = (l1.b*l2.c - l1.c*l2.b)/(l1.b*l2.a - l1.a*l2.b);
    p.y = (l1.c*l2.a - l1.a*l2.c)/(l1.b*l2.a - l1.a*l2.b);
    return p;
}

double point_distance(point s, point e){
    double d;
    d = (e.x - s.x)*(e.x - s.x)+(e.y - s.y)*(e.y - s.y);
    d = sqrt(d);
    return d;
}

int main()
{
    int n;
    double r;
    point p[3], mp, cp;
    linear l1, l2;

    cin >> n;
    vector< point > v[n];
    for(int i = 0; i < n; ++i){
        cin >> p[0].x >> p[0].y >> p[1].x >> p[1].y >> p[2].x >> p[2].y;
        v[i].push_back(p[0]);
        v[i].push_back(p[1]);
        v[i].push_back(p[2]);
    }
    for(int i = 0; i < n; ++i){
        l1 = get_linear(v[i].at(0), v[i].at(1));
        mp.x = (v[i].at(1).x + v[i].at(0).x)/2;
        mp.y = (v[i].at(1).y + v[i].at(0).y)/2;
        l1 = get_linear_vertical(mp, l1);

        l2 = get_linear(v[i].at(0), v[i].at(2));
        mp.x = (v[i].at(2).x + v[i].at(0).x)/2;
        mp.y = (v[i].at(2).y + v[i].at(0).y)/2;
        l2 = get_linear_vertical(mp, l2);

        cp = get_cross_point(l1, l2);
        r = point_distance(v[i].at(0), cp);

        cout << fixed << setprecision(3)
             << cp.x << ' ' << cp.y << ' ' << r << endl;
    }
    return 0;
}