Go: package main

import (
	"fmt"
	"math"
)

func main() {
	var num int
	fmt.Scan(&num)
	for i := 0; i < num; i++ {
		var x1, y1, x2, y2, x3, y3 float64
		fmt.Scanf("%f%f%f%f%f%f", &x1, &y1, &x2, &y2, &x3, &y3)

		a := 2 * (x2 - x1)
		b := 2 * (y2 - y1)
		c := 2 * (x3 - x1)
		d := 2 * (y3 - y1)
		e := x2*x2 - x1*x1 + y2*y2 - y1*y1
		f := x3*x3 - x1*x1 + y3*y3 - y1*y1

		// 直線1: ax + by - e = 0
		// 直線2: cx + dy - f = 0
		px := (d*e - b*f) / (a*d - b*c)
		py := (c*e - a*f) / (b*c - a*d)
		r := math.Sqrt((px-x1)*(px-x1) + (py-y1)*(py-y1))
		fmt.Printf("%.3f %.3f %.3f\n", px, py, r)
	}
}

C++: #include<stdio.h>
#include<math.h>
using namespace std;
int main(){
    int a;
    cin >>a;
    while(a--){
        double x1,y1,x2,y2,x3,y3;
        cin >>x1 >>y1 >>x2 >> y2 >> x3 >> y3;
        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*c2-b2*c1)/(a1*b2-a2*b1);
        double y=(c1*a2-c2*a1)/(a1*b2-a2*b1);
        double r=hypot(x-x1,y-y1);
        printf("%.3lf %.3lf %.3lf\n",x,y,r);
    }
}

C++: #include<stdio.h>
#include<iostream>
#include<cmath>
using namespace std;

struct Line{
    bool isRightX, isRightY;
    double x, y, a, b;
};

Line getBisector(double x1, double y1, double x2, double y2){
    Line bisector;
    bisector.isRightX = bisector.isRightY = false;
    if ( y1 == y2 ){   
	bisector.isRightY = true;
	bisector.x = ( x1 + x2 ) / 2;
    } else if ( x1 == x2 ){    
	bisector.isRightX = true;
	bisector.y = ( y1 + y2 ) / 2;
    } else {
	bisector.a = ( x2 - x1 ) / ( y1 - y2 );
	bisector.b = ( y1 + y2 ) / 2 - bisector.a * (( x1 + x2 ) / 2);
    }

    return bisector;
}

void compute(){
    double x1, y1, x2, y2, x3, y3, x, y, r;
    cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
    Line AB = getBisector(x1, y1, x2, y2);
    Line AC = getBisector(x1, y1, x3, y3);
    if ( AB.isRightX ){
	if ( AC.isRightY ){
	    x = AC.x; y = AB.y;
	} else {
	    y = AB.y; x = (y - AC.b) / AC.a;
	}
    } else if ( AB.isRightY ){ //y ツ篠イツづ可閉スツ行
	if ( AC.isRightX ){
	    x = AB.x; y = AC.y;
	} else {
	    x = AB.x; y = AC.a * x + AC.b;
	}
    } else {
	if ( AC.isRightX ) {
	    y = AC.y; x = (y - AB.b) / AB.a;
	} else if ( AC.isRightY ) {
	    x = AC.x; y = AB.a * x + AB.b;			
	} else {
	    x = (AC.b - AB.b) / (AB.a - AC.a); 
	    y = AB.a * x + AB.b;
	}	
    }
    r = sqrt( (x - x1)*(x - x1) + (y - y1)*(y - y1) );

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

int main(){
    int tcase; cin >> tcase;
    for ( int i = 0; i < tcase; i++ ){
	compute();
    }
    return 0;
}

C++: #include<cstdio>
#include<iostream>
#include<cmath>
#include<algorithm>
#define SQ(x) ((x)*(x))
using namespace std;

int main(){
  int n;
  double x1,y1,x2,y2,x3,y3;
  double a,b,c,d,e,f,l,C,r,xp,yp,m; // 3辺
  cin >> n;
  for(int i=0;i<n;i++){
    cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;

    a = (x1 - x2);
    b = (y1 - y2);
    c = -1 * (SQ(x1) - SQ(x2) + SQ(y1) - SQ(y2));
    d = (x1 - x3);
    e = (y1 - y3);
    f = -1 * (SQ(x1) - SQ(x3) + SQ(y1) - SQ(y3));
    
    l = (c * e - b * f) / (e * a - b * d);
    m = (d * c - a * f) / (d * b - e * a);

    n = -1 * (SQ(x1) + SQ(y1) + l * x1 + m * y1);
	
    printf("%.3f %.3f %.3f\n", l / -2.0, m / -2.0, sqrt(SQ(l) + SQ(m) - 4 * n) / 2.0);
  }
}

C++: //
//  main.cpp
//  adsfdsgsg
//
//  Created by h3037175 on 2017/07/31.
//  Copyright ?? 2017??´ h3037175. All rights reserved.
//

#include <iostream>
#include <cstdio>
#include <math.h>
#include<algorithm>
#include <utility>
#define nan -100000
using namespace std;
bool isY(double y1,double y2,double y3){
    if(y1==y2 || y1==y3 || y2==y3 ){
        return true;
    }
    else {
        return false;
    }
}
bool isX(double x1,double x2,double x3){
    if(x1==x2 || x1==x3 || x2==x3 ){
        return true;
    }
    else {
        return false;
    }
}
int main() {
    int n;
    double a,x1,x2,x3,y1,y2,y3,px,py,r;
    cin>>n;
    for(int i=0;i<n;i++){
        cin>>x1>>y1>>x2>>y2>>x3>>y3;
        double X[3]={x1,x2,x3},Y[3]={y1,y2,y3};
        sort(X,X+3);sort(Y,Y+3);
        px=2/(X[2]-X[0]);
        py=2/(Y[2]-Y[0]);
        a=(px*px)+(py*py);
            r=sqrt(a);
        printf("%.3f %.3f %.3f",px,py,r);
        cout<<endl;
    }
    return 0;
}
//3633
/*
 
 
 
 
                                  /
                                 /|
                                / |
                               /  |
                              /   |
                             /    |
                            / |   |
                           /  |   |
                          /   |   |
                         /    |   |
                        /     |   |
                       /      |   |
                      /       |   |
                     /-------------








*/

C++: #include<iostream>
#include<cmath>
#define EPS 1e-10
using namespace std;

double simulx(double a, double b, double c, double d, double e, double f){
	return (double)(c*e - f*b) / (a*e - d*b) + EPS;
}

double simuly(double a, double b, double c, double d, double e, double f){
	return (double)(c*d - f*a) / (b*d - e*a) + EPS;
}

int main(void){
	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;
		double px, py;
		double a, b, c, d, e, f;
		a = 2*(x1-x2); b = 2*(y1-y2); c=x1*x1-x2*x2+y1*y1-y2*y2;
		d = 2*(x1-x3); e = 2*(y1-y3); f=x1*x1-x3*x3+y1*y1-y3*y3;
		px = simulx(a, b, c, d, e, f);
		py = simuly(a, b, c, d, e, f);
		cout.setf(ios::fixed);
		cout.precision(3);
		cout << px << " " << py << " " << sqrt((x1-px)*(x1-px)+(y1-py)*(y1-py)) << endl;
	}
	return 0;
}

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

using namespace std;

#define LOG(...) fprintf(stderr, __VA_ARGS__)
//#define LOG(...)
#define FOR(i, a, b) for(int i=(int)(a); i<(int)(b); ++i)
#define REP(i, n) for(int i=0; i<(int)(n); ++i)
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define EXIST(s, e) ((s).find(e)!=(s).end())
#define SORT(c) sort(ALL(c))
#define RSORT(c) sort(RALL(c))
#define SQ(n) (n) * (n)

typedef long long ll;
typedef unsigned long long ull;
typedef vector<bool> vb;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<vb> vvb;
typedef vector<vi> vvi;
typedef vector<vll> vvll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;

int main() {
  int n;
  float x1, y1, x2, y2, x3, y3;
  cin >> n;
  REP(i, n){
    cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
    float a = 2 * (x2 - x1);
    float b = 2 * (y2 - y1);
    float e = x2 * x2 + y2 * y2 - x1 * x1 - y1 * y1;
    float c = 2 * (x3 - x2);
    float d = 2 * (y3 - y2);
    float f = x3 * x3 + y3 * y3 - x2 * x2 - y2 * y2;
    LOG("%f %f %f\n%f %f %f\n", a, b, e, c, d, f);

    float D = 1 / (a * d - b * c);
    float A = (d * e - b * f) * D;
    float B = (-c * e + a * f) * D;
    printf("%.3f %.3f %.3f\n", A, B, sqrt(SQ(x1-A)+SQ(x1-B)));
  }
}