Language: C++

#include <iostream>
#include <sstream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <ctime>
#include <cstring>
#include <climits>
#include <algorithm>
#include <map>
#include <set>
#include <stack>
#include <vector>
#include <queue>
#include <bitset>
#include <string>
#include <complex>
using namespace std;
 
#define rep(i,n) for(int i=0; i<n; i++)
#define repa(i,s,e) for(int i=s; i<=e; i++)
#define repd(i,s,e) for(int i=s; i>=e; i--)
 
typedef long long ll;
typedef vector<int> vi;
typedef pair<int, int> pii;

// geometry library

const double EPS = 1.0e-8;
const double INF = 1.0e12;
typedef complex<double> P;
namespace std {
	bool operator<(const P& p, const P& q) {
		return p.real() != q.real() ? p.real() < q.real() : p.imag() < q.imag(); 
	}
}

double cross(const P& p, const P& q) {
	return imag(conj(p) * q); 
}

double dot(const P& p, const P& q) {
	return real(conj(p) * q);
}

struct L : public vector<P> {
public:
	L(const P& p, const P& q) {
		this->push_back(p);
		this->push_back(q);
	}
};

struct C {
public:
	P p;
	double r;
	C() : p(0.0, 0.0), r(0.0) {}
	C(const P& _p, double _r) : p(_p), r(_r) {} 
};

// code for problem

int x, y, r;
P tr[3];
C cc;

// compute distance between 2 points
double distP2P(P& p, P& q) {
	P d = p - q;
	return sqrt(norm(d));
}

// compute shortest distance to line
double distP2L(P& p, L& l) {
	double a = l[1].real() - l[0].real();
	double b = l[0].imag() - l[1].imag();
	double c = - a * l[0].real() - b * l[0].imag();
	double de = abs(a * p.real() + b * p.imag() + c);
	double nm = sqrt(a * a + b * b);
	return de / nm;
}

// compute shortest distance to line segment
double distP2LS(P& p, L& l) {
	double d1 = dot(p - l[0], l[1] - l[0]);
	double d2 = dot(p - l[1], l[0] - l[1]);
	if(d1 < 0 || d2 < 0) {
		return min(distP2P(p, l[0]), distP2P(p, l[1]));
	}

	double a = l[1].real() - l[0].real();
	double b = l[0].imag() - l[1].imag();
	double c = - a * l[0].real() - b * l[0].imag();
	double de = abs(a * p.real() + b * p.imag() + c);
	double nm = sqrt(a * a + b * b);
	return de / nm;
}

bool isPinT(P& p, P t[3]) {
	P e0 = t[0] - p;
	P e1 = t[1] - p;
	P e2 = t[2] - p;
	double d0 = cross(e0, e1);
	double d1 = cross(e1, e2);
	double d2 = cross(e2, e0);
	if(d0 * d1 >= 0 && d1 * d2 >= 0 && d2 * d0 >= 0) return true;
	return false;
}

void solve() {
	// triangle is in circle ?
	vector<double> d(6);
	d[0] = distP2P(tr[0], cc.p);
	d[1] = distP2P(tr[1], cc.p);
	d[2] = distP2P(tr[2], cc.p);
	printf("%f %f %f\n", d[0], d[1], d[2]);
	if(d[0] <= cc.r && d[1] <= cc.r && d[2] <= cc.r) {
		printf("b\n");
		return;
	}

	// circle is in triangle ?
	bool in = isPinT(cc.p, tr);
	d[3] = distP2LS(cc.p, L(tr[0], tr[1]));
	d[4] = distP2LS(cc.p, L(tr[1], tr[2]));
	d[5] = distP2LS(cc.p, L(tr[2], tr[0]));
	if(in && d[3] >= cc.r && d[4] >= cc.r && d[5] >= cc.r) {
		printf("a\n");
		return;
	}

	// intersects each other ?
	sort(d.begin(), d.end());
	if(d[0] <= cc.r) {
		printf("c\n");
		return;
	}

	// not intersect
	printf("d\n");
}

int main() {
	while( 1 ) {
		scanf("%d%d", &x, &y);
		if(x == 0 && y == 0) break;
		tr[0] = P(x, y);

		scanf("%d%d", &x, &y);
		tr[1] = P(x, y);

		scanf("%d%d", &x, &y);
		tr[2] = P(x, y);

		scanf("%d%d%d", &x, &y, &r);
		cc = C(P(x, y), r);

		solve();
	}
}

Compiler output:
a.cc: In function 'void solve()':
a.cc:126:31: error: cannot bind non-const lvalue reference of type 'L&' to an rvalue of type 'L'
  126 |         d[3] = distP2LS(cc.p, L(tr[0], tr[1]));
      |                               ^~~~~~~~~~~~~~~
a.cc:86:26: note:   initializing argument 2 of 'double distP2LS(P&, L&)'
   86 | double distP2LS(P& p, L& l) {
      |                       ~~~^
a.cc:127:31: error: cannot bind non-const lvalue reference of type 'L&' to an rvalue of type 'L'
  127 |         d[4] = distP2LS(cc.p, L(tr[1], tr[2]));
      |                               ^~~~~~~~~~~~~~~
a.cc:86:26: note:   initializing argument 2 of 'double distP2LS(P&, L&)'
   86 | double distP2LS(P& p, L& l) {
      |                       ~~~^
a.cc:128:31: error: cannot bind non-const lvalue reference of type 'L&' to an rvalue of type 'L'
  128 |         d[5] = distP2LS(cc.p, L(tr[2], tr[0]));
      |                               ^~~~~~~~~~~~~~~
a.cc:86:26: note:   initializing argument 2 of 'double distP2LS(P&, L&)'
   86 | double distP2LS(P& p, L& l) {
      |                       ~~~^