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 <cstdio>
using namespace std;

int main(void){
  int money = 100000, weeks;
  cin >> weeks;
  for(int i = 0; i < weeks; i++){
    money += (money / 100) * 5;
    int underTp = money % 1000;
    if(underTp != 0){
      money -= underTp;
      money += 1000;
    }
  }
  cout << money << endl; 
  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辺
  while(cin >> n){
    for(int i=0;i<n;i++){
      cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
      a = sqrt((x2-x1)*(x2-x1)+(y2-y1)*(y2-y1));
      b = sqrt((x2-x3)*(x2-x3)+(y2-y3)*(y2-y3));
      c = sqrt((x3-x1)*(x3-x1)+(y3-y1)*(y3-y1));
      C = (sqrt(fabs(1.0-C*C))); // sinθに変更
      r = (c/2*C); // 接弦定理
    
      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);
    
      printf("%.3f %.3f %.3f\n", l / -2.0, m / -2.0, r);
    }
  }
}

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

using namespace std;

struct point{
    double x;
    double y;
};

int main(){
    int n;
    struct point points[3];

    cin>>n;
    for (int j = 0; j < n; ++j) {
        double s,a,b,c;
        for (int i = 0; i < 3; ++i) {
            cin >> points[i].x >> points[i].y;
        }
        a  = sqrt(pow(points[0].x-points[1].x,2)+pow(points[0].y-points[1].y,2));
        b  = sqrt(pow(points[1].x-points[2].x,2)+pow(points[1].y-points[2].y,2));
        c  = sqrt(pow(points[2].x-points[0].x,2)+pow(points[2].y-points[0].y,2));
        s  = (a+b+c)/2;
        printf("%.3f %.3f %.3f\n",
               ((points[0].y - points[2].y)*(pow(points[0].y,2) - pow(points[1].y,2) + pow(points[0].x,2) - pow(points[1].x,2)) - (points[0].y - points[1].y)*(pow(points[0].y,2) - pow(points[2].y,2) + pow(points[0].x,2) - pow(points[2].x,2))) / (2*(points[0].y - points[2].y)*(points[0].x - points[1].x) - 2*(points[0].y - points[1].y)*(points[0].x - points[2].x))+5e-5,
               ((points[0].x - points[2].x)*(pow(points[0].x,2) - pow(points[1].x,2) + pow(points[0].y,2) - pow(points[1].y,2)) - (points[0].x - points[1].x)*(pow(points[0].x,2) - pow(points[2].x,2) + pow(points[0].y,2) - pow(points[2].y,2))) / (2*(points[0].x - points[2].x)*(points[0].y - points[1].y) - 2*(points[0].x - points[1].x)*(points[0].y - points[2].y))+5e-5,
               a*b*c/(4*sqrt(s*(s-a)*(s-b)*(s-c)))+5e-5
        );
    }
    return 0;
}

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

typedef complex<double> P;

double cross(P a, P b){
  return (a.real()*b.imag() - a.imag()*b.real());
}

int main()
{
  int i,j;
  int n;
  P point[3],ans;

  cin >> n;
  for(i=0;i<n;i++){

    for(j=0;j<3;j++){
      cin >> point[j].real() >> point[j].imag();
    }

    P p01 = point[0] + point[1];
    P p12 = point[1] + point[2];
    P h01 = P(p01.real()/2 , p01.imag()/2);
    P h12 = P(p12.real()/2 , p12.imag()/2);
    P n1 = (point[0] - h01) * P(0,1) + h01;
    P n2 = (point[1] - h12) * P(0,1) + h12;

    ans = n1 + (h01-n1) * cross(h12-n2,n2-n1) / cross(h12-n2,h01-n1);


    printf("%.3lf %.3lf %.3lf\n",real(ans) + EPS,imag(ans) + EPS,abs(point[0]-ans) );
  }
  return 0;
}

C++: #include <algorithm>
#include <cmath>
#include <ctime>
#include <climits>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <set>
#include <sstream>
#include <string>
#include <utility>
#include <vector>
#include <cstring>
#include <tuple>
#include <bitset>
#include <unordered_map>
using namespace std;
typedef long long ll;
int main() {
    int n;
    cin >> n;
    double x1, y1, x2, y2, x3, y3;
    for (int i=0; i<n; ++i) {
        cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
        if (y1 == y2) {
            swap(x2, x3);
            swap(y2, y3);
        } else if (y2 == y3) {
            swap(x1, x2);
            swap(y1, y2);
        }
        double a = (x1 - x2) / (y1 - y2) * (-1);
        double b = (y1 - y2) / 2 - (x1 - x2) / 2 * a;
        double c = (x2 - x3) / (y2 - y3) * (-1);
        double d = (y2 - y3) / 2 - (x2 - x3) / 2 * a;
        double px = (a - b) / (c - a);
        double py = (a * d - b * c) / (c - a);
        double r = hypot(x1 - px, y1 - py);
        cout.precision(3);
        cout << fixed << px << " " << py << " " << r << endl;
    }
    return 0;
}

C++: #include<iostream>
#include<cstdio>
#include<cmath>
#include<algorithm>
using namespace std;
double hoge(double x1,double y1,double x2,double y2){
  return sqrt((max(x1,x2)-min(x1,x2))*(max(x1,x2)-min(x1,x2))+(max(y1,y2)-min(y1,y2))*(max(y1,y2)-min(y1,y2)));
}
int main(void){
  int n;
  double x1,y1,x2,y2,x3,y3,xp,yp,a,b,c,r,a1,b1,c1,a2,b2,c2;
  cin >> n;
  for(int i=0;i<n;i++){
    cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
    a=hoge(x1,y1,x2,y2);
    b=hoge(x2,y2,x3,y3);
    c=hoge(x1,y1,x3,y3);
    r=(a*b*c)/sqrt((a+b+c)*(-a+b+c)*(a-b+c)*(a+b-c));
    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;
    xp=(b1*c2-b2*c1)/(a1*b2-a2*b1);
    yp=(c1*a2-c2*a1)/(a1*b2-a2*b1);
    printf("%.3f %.3f %.3f\n",xp,yp,r);
  }
}

C++: #include<iostream>
#include<cmath>
#include<algorithm>
#include<iomanip>
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() {
	cout << setprecision(4);
	int n;
	cin >> n;
	for (int i = 0; i < n; i++) {
		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);
		double k = distance(p[0], s);
		s.x = round(s.x * 1000) / 1000;
		s.y = round(s.y * 1000) / 1000;
		k = round(k * 1000) / 1000;
		cout << s.x << " " << s.y << " " << k << endl;
	}
	return 0;
}

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

int main()
{
    int n;
    double x1,x2,x3,y1,y2,y3,A1,B1,C1,A2,B2,C2,X,Y;
    cin>>n;
    while(n!=0){
        scanf("%lf%lf%lf%lf%lf%lf",&x1,&x2,&x3,&y1,&y2,&y3);
        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;
        X=(B1*C2-B2*C1)/(A1*B2-A2*B1);
        Y=(C1*A2-C2*A1)/(A1*B2-A2*B1);
        printf("%.3f %.3f %.3f\n",X,Y,sqrt((X-x1)*(X-x1)+(Y-y1)*(Y-y1)));
        n--;
    }
    return 0;
}