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<bits/stdc++.h>
using namespace std;
int main()
{
    int t;
    cin >> t;
    while(t--)
    {
        double x1,x2,x3,y1,y2,y3,a,b,c,r,d,p1,p2;
        cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
        c = sqrt(pow(x2-x1,2)+pow(y2-y1,2));
        b = sqrt(pow(x3-x1,2)+pow(y3-y1,2));
        a = sqrt(pow(x3-x2,2)+pow(y3-y2,2));
        r = (a*b*c) / (sqrt((a+b+c)*(b+c-a)*(c+a-b)*(a+b-c)));
        d = 2*(x1*(y2-y3) + x2*(y3-y1) + x3*(y1-y2));
        p1 =((pow(x1,2)+pow(y1,2))*(y2-y3)+(pow(x2,2)+pow(y2,2))*(y3-y1)+(pow(x3,2)+pow(y3,2))*(y1-y2))/d;
        p2 =((pow(x1,2)+pow(y1,2))*(x3-x2)+(pow(x2,2)+pow(y2,2))*(x1-x3)+(pow(x3,2)+pow(y3,2))*(x2-x1))/d;
        cout << fixed << setprecision(3) << p1 <<" "<< p2 <<" "<< r << endl;
    }
}

C++: import java.util.Scanner;
import java.lang.Math;

class Main {
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		
		int n = scan.nextInt();
		for(int i = 0; i < n; i++) {
			double x1,y1,x2,y2,x3,y3;
			
			x1 = scan.nextDouble();
			y1 = scan.nextDouble();
			x2 = scan.nextDouble();
			y2 = scan.nextDouble();
			x3 = scan.nextDouble();
			y3 = scan.nextDouble();
			
			double a1, a2, b1, b2, c1, c2, px, py;

			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;
			
			double temp = a1*b2 - a2*b1;
			
			px = (b1*c2 - b2*c1) / temp;
			py = (c1*a2 - c2*a1) / temp;
			
			double r = Math.sqrt((x1-px)*(x1-px) + (y1-py)*(y1-py));
			
			System.out.printf("%.3f %.3f %.3f", px, py, r);
		}
	}
}

C++: #include<iostream>
#include<stdio.h>
#include<math.h>
using namespace std;
 struct vect{
    double x,y;
 };
int main(){
  vect a,b,c,p,l1,l2,M1,M2;
  double t1,r;
  int n;
  cin >> n;
  for(int i = 0;i < n;i++){
    cin >> a.x >> a.y >> b.x >> b.y >> c.x >> c.y;
    M1.x = (a.x + b.x) /2;
    M1.y = (a.y + b.y) /2;
    M2.x = (b.x + c.x)/2;
    M2.y = (b.y + c.y)/2;
    l1.y = -(b.x - a.x);
    l1.x = b.y -a.y;
    l2.y = -(c.x-b.x);
    l2.x = c.y -b.y;
    t1 = 1/(-l1.x * l2.y + l2.x * l1.y) *( -l2.y * (M2.x -M1.x) + l2.x * (M2.y -M1.y));
    p.x = M1.x + l1.x * t1;
    p.y = M1.y + l1.y * t1;
    r = sqrt((p.x - a.x)*(p.x - a.x) +(p.y - a.y)*(p.y -a.y));
    printf("%.3f %.3f %.3f\n",p.x,p.y,r);
  }
}

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

using namespace std;

#define EPS 1e-9

struct P {
	double x, y;
};

double abs(P p) {
	return sqrt(p.x * p.x + p.y * p.y);
}
double dot(P p1, P p2) {
	return p1.x * p2.x + p1.y * p2.y;
}
double xx(double r) {
	return r*r;
}

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

		P a = (P){ x2 - x1, y2 - y1 };
		P b = (P){ x3 - x2, y3 - y2 };
		P c = (P){ x1 - x3, y1 - y3 };

		double R =  abs(a) / (sqrt(1 - xx(dot(b, c) / abs(b) / abs(c))) * 2);
		double l = sqrt( R*R - xx(abs(c)/2) );
		double gx = (x1+x3)/2, gy = (y1+y3)/2;
		P e = (P){ -c.y/abs(c), c.x/abs(c) };
		P eg = (P){ e.x * l, e.y * l };
		P g1 = (P){ gx + eg.x, gy + eg.y };
		P g2 = (P){ gx - eg.x, gy - eg.y };
		if ( abs(xx(x1-g1.x) + xx(y1-g1.y) - R*R) < EPS ) gx = g1.x, gy = g1.y;
		else gx = g2.x, gy = g2.y;
		if ( abs(gx) < EPS ) gx = abs(gx);
		if ( abs(gy) < EPS ) gy = abs(gy);
		printf("%.3f %.3f %.3f\n", gx, gy, R);
	}
}

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

inline double square(double x) { return x * x;}
inline double distance2d(double x1, double y1, double x2, double y2)
{
    return sqrt(square(x1 - x2) + square(y1 - y2));
}
int main()
{
    int n;

    cin >> n;
    for (double x1, y1, x2, y2, x3, y3; n-- && cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;) {
        // r
        double d1 = distance2d(x1, y1, x2, y2);
        double d2 = distance2d(x2, y2, x3, y3);
        double d3 = distance2d(x3, y3, x1, y1);

        double r = d1 * d2 * d3 / sqrt((d1 + d2 + d3) *
                                       (-d1 + d2 + d3) *
                                       ( d1 - d2 + d3) *
                                       ( d1 + d2 - d3));

        // positions
        double d = 2 * (x1 * (y2 - y3) + x2 *(y3 - y1) + x3 * (y1 - y2));
        double px = ((x1 * x1 + y1 * y1) * (y2 - y3) +
                     (x2 * x2 + y2 * y2) * (y3 - y1) +
                     (x3 * x3 + y3 * y3) * (y1 - y2))/ d;
        double py = ((x1 * x1 + y1 * y1) * (x3 - x2) +
                     (x2 * x2 + y2 * y2) * (x1 - x3) +
                     (x3 * x3 + y3 * y3) * (x2 - x1)) / d;

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

    return 0;
}

C++: #include <iostream>
#include <iomanip>
#include <stdlib>
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<iostream>
#include<cmath>
#include<algorithm>
using namespace std;
class Point {
public:
	double x, y;
};
double distance(Point x, Point y) {
	return pow(pow(fabs(x.x - y.x), 2) + pow(fabs(x.y - y.y), 2), 0.5);
}
int main() {
	Point p[3],s;
	for (int i = 0; i < 3; i++) {
		cin >> p[i].x >> p[i].y;
	}
	double a, b, c, d, e, f;
	a = (-2)*p[0].x + 2 * p[1].x;
	b = (-2)*p[0].y + 2 * p[1].y;
	c = (-2)*p[0].x + 2 * p[2].x;
	d = (-2)*p[0].y + 2 * p[2].y;
	e = pow(p[0].x, 2) + pow(p[0].y, 2) - pow(p[1].x, 2) - pow(p[1].y, 2);
	f = pow(p[0].x, 2) + pow(p[0].y, 2) - pow(p[2].x, 2) - pow(p[2].y, 2);
	s.x = (b*f - d*e) / (a*d - b*c);
	s.y = (a*f - c*e) / (b*c - a*d);
	cout << s.x << " " << s.y << " " << distance(p[0], s) << endl;
	
	return 0;
}

C++: #include<bits/stdc++.h>
#define rep(i,n)for(int i=0;i<(n);i++)
using namespace std;

int main() {
	int n; scanf("%d", &n);
	rep(i, n) {
		double x1, y1, x2, y2, x3, y3;
		cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
		double a = -x1 + x2, b = -y1 + y2, c = (-pow(x1, 2) - pow(y1, 2) + pow(x2, 2) + pow(y2, 2)) / 2;
		double d = -x2 + x3, e = -y2 + y3, f = (-pow(x2, 2) - pow(y2, 2) + pow(x3, 2) + pow(y3, 2)) / 2;
		double y = (c*d - a*f) / (b*d - a*e);
		double x = (c - b*y) / a;
		printf("%.3lf %.3lf %.3lf\n", x, y, hypot(x1 - x, y1 - y));
	}
}