Go: package main

import (
        "fmt"
        "bufio"
        "os"
)

func main() {
        var a, b, c, d, e, f float64
        sc := bufio.NewScanner(os.Stdin)
        for sc.Scan() {
                fmt.Sscanf(sc.Text(), "%f %f %f %f %f %f", &a, &b, &c, &d, &e, &f)

                det := a*e - b*d
                x := (e*c - b*f) / det
                y := (a*f - c*d) / det
                fmt.Printf("%.3f %.3f\n", x, y)
        }
}

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

int main(){
  int i = 0;
  while(1){
  i++;
  int a, b, c, d, e, f;
  scanf("%d ",&a);
  scanf("%d ",&b);
  scanf("%d ",&c);
  scanf("%d ",&d);
  scanf("%d ",&e);
  scanf("%d ",&f);
  
  double x, y;
  x = (double)(c*e-b*f) / (double)(a*e-b*d);
  y = (double)(a*f-c*d) / (double)(a*e-b*d);
  x = (double)round(x*10000.0) / 10000.0;
  y = (double)round(y*10000.0) / 10000.0;
  printf("%.3f %.3f\n", x, y);
  
  if(scanf("%d", &a)==EOF) break;
  else{
    int line = i * 6;
    fseek(stdin, lineL, SEEK_SET);
  }
  }
  
  return 0;
}

C++: import sys

for line in sys.stdin:
    a,b,c,d,e,f = [float(w) for w in line.split()]
    
    print("{:.3f} {:.3f}".format((e*c-b*f)/(a*e-a*b), (d*c-a*f)/(b*d-a*e)))

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

int main(){
	double a,b,c,d,e,f;
	while(cin >> a >> b >> c >> d >> e >> f){
		double denom = a * e - b * d;
		double x = (c * e - b * f) / denom;
		double y = (a * f - c * d) / denom;
		printf("%.3lf ", x);
		printf("%.3lf\n", y);
	}
	return 0;
}

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

using namespace std;

int main(){
	double a, b, c, d, e, f, A, B, C, x, y;
	int xx, yy;

	while(cin >> a >> b >> c >> d >> e >> f){
		A = a * e - b * d;
		B = c * e - b * f;
		C = c * d - a * f;

		x = B / A + 0.0005;
		y = (-1) * C / A + 0.0005;
		xx = x * 1000;
		yy = y * 1000;
		x = xx * 0.001;
		y = yy * 0.001;
		printf("%.3f %.3f?\n", x, y);
	}
	return 0;
}

C++: #include<iostream>
#include<stdio.h>
using namespace std;
int main()
{
  double a,b,c,d,e,f;
  while( cin >> a >> b >> c >> d >> e >> f ){
    double x = (c/b - f/e) / (a/b - d/e);
    double y = (c - a*x) / b;
    if(x == -0) x = 0;
    if(y == -0) y = 0;
    printf("%.3lf %.3lf\n", x, y);
  }
}

C++: #include <cstdio>
#include <cstring>
#include <algorithm>

using namespace std;

int main()
{
	double a, b, c, d, e, f;
	while (scanf("%lf %lf %lf %lf %lf %lf", &a, &b, &c, &d, &e, &f) != EOF)
	{
		double x = (f-c*e/b)/(d-e*a/b);
		x = -0.001 < x && x <= -0 ? x = 0 : x;
		double y = (c-a*x)/b;
		printf("%.3f %.3f\n", x, y);
	}

	return 0;
}

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

int main(){
	double a,b,c,d,e,f,x,y;
	cout<<setprecision(3);
	cout<<fixed;
	while(cin>>a>>b>>c>>d>>e>>f){
		if(e==0){
			x=d/f;
		}else{
			x=(c-b*f/e)/(a-b*d/e);
		}
		y=(c-a*x)/b;
		cout<<x<<" "<<y<<endl;
	}
	return 0;
}

C++: /**
 * @bfief LUP分解について扱う
 * @date  2016/03/09
 */



//****************************************
// 必要なヘッダファイルのインクルード
//****************************************

#include <iostream>
#include <cmath>
#include <cassert>
#include <vector>
#include <functional>



//****************************************
// 型シノニム
//****************************************

using elem_t    = double;
using vec_t     = std::vector<elem_t>;
using mat_t     = std::vector<vec_t>;
using index_t   = std::int32_t;
using indices_t = std::vector<index_t>;


//****************************************
// 関数の定義
//****************************************

/**
 * @brief  正則行列AのLUP分解を行う
 *
 * @note   置換行列Pは配列πとして動的に管理する. ここでπ[i] = jはPの第i行は第j列に1を持つことを意味する
 *         さらに、A上でLとUを「その場で」計算する. したがって、手続きが終了したときは
 *           aij = { lij i >  jのとき
 *                   uij i <= jのとき }
 *         が成立する
 *
 * @note   LUP-DECOMPOSITIONの実行時間はΘ(n^3)である
 *
 * @param[inout] mat_t& A  nxn型の正則行列A
 * @return indices_t pi    置換行列Pの配列表現
 */
indices_t lup_decomposition(mat_t& A)
{
    index_t n = A.size();       // n = A.rows
    
    indices_t pi(n);            // π[0..n-1]を新しい配列とする

    for (index_t i = 0; i < n; i++) {
        pi[i] = i;
    }

    for (index_t k = 0; k < n; k++) {
        // 0による除算および数値的不安定性を避けるため、できるだけ大きい数をピボットとして選択する
        elem_t p = 0.0; index_t k_ = -1;
        for (index_t i = k; i < n; i++) {
            if (std::abs(A[i][k]) > std::abs(p)) {
                p = A[i][k];
                k_ = i;
            }
        }
        if (k_ < 0) { assert(false); }     // p == 0.0のとき、Aは特異行列

        // 要素ak'kをピボットの位置(k, k)に移すために、
        std::swap(pi[k], pi[k_]);          // π[k]とπ[k_]を交換し、
        for (index_t i = 0; i < n; i++) {  // 行全体を入れ換えるために、
            std::swap(A[k][i], A[k_][i]);  // akiとak'iを交換していく
        }

        // Schurの補行列を計算する
        for (index_t i = k + 1; i < n; i++) {
            A[i][k] = A[i][k] / A[k][k];
            for (index_t j = k + 1; j < n; j++) {
                A[i][j] = A[i][j] - A[i][k] * A[k][j];
            }
        }
    }
    return pi;
}


/**
 * @brief  与えられたP, L, Uおよびbに対して、手続きLUP-SOLVEは前進代入と後進代入を組み合わせて解xを得る
 * @note   ただし、置換行列Pは配列πで表現される
 *
 * @note   LUP-SOLVEは引数にLおよびUの2つをとる必要があった. そこで、Aに直接LおよびUを計算した値を代入した行列Aのみを
 *         引数にとるように修正を施す
 *
 * @note   手続きの実行時間はΘ(n^2)である
 *
 * @param  const mat_t& A       aij = { lij (i > j)、 uij (i <= j) }を満たすnxn型行列A
 * @param  const indices_t& pi  置換行列Pの配列表現(i=0,1,..n-1に対してpi[i]はP(i,pi[i])=1で、j!=pi[i]ならばPij=0)
 * @param  const vec_t& b       入力ベクトルb
 * @return vec_t x              LUx = Pbを満たすようなx
 */
vec_t lup_solve(const mat_t& A, const indices_t& pi, const vec_t& b)
{
    index_t n = A.size();                   // n = A.rows

    vec_t x(n, 0.0), y(n, 0.0);             // x, yを長さnの新しいベクトルとする

    for (index_t i = 0; i < n; i++) {       // 前進代入(forward substitution)を行ってyを計算する
        elem_t sigma = 0.0;
        for (index_t j = 0; j < i; j++) { sigma += A[i][j] * y[j]; }  // Σ[j=0, i-1](lij * yj)を計算
        y[i] = b[pi[i]] - sigma;            // y0,y1,...,y(i-1)をi番目の式に"前の方から順々に"代入することでyiの値を得る
    }

    for (index_t i = n - 1; i >= 0; i--) {  // 後進代入(back subsititusion)を行ってxを得る
        elem_t sigma = 0.0;
        for (index_t j = i; j < n; j++) { sigma += A[i][j] * x[j]; }  // Σ[j=i, n-1](uij * xj)を計算
        x[i] = (y[i] - sigma) / A[i][i];    // この方法は前進代入法と似ているが、対角成分で要素を割る必要がある
    }
    
    return x;


    // y[n - 1] /= A[n - 1][n - 1];            // i = n - 1の場合をループの外で先に行う
    // for (index_t i = n - 2; i >= 0; i--) {  // 後進代入(back subsititusion)を行ってxを得る
    //     elem_t sigma = y[i];
    //     for (index_t j = i + 1; j < n; j++) { sigma -= A[i][j] * y[j]; }  // Σ[j=i+1, n-1](uij * xj)を計算
    //     y[i] = sigma / A[i][i];             // この方法は前進代入法と似ているが、対角成分で要素を割る必要がある
    // }
    // return y;
}



//****************************************
// エントリポイント
//****************************************

int main()
{
    using namespace std;

    const int n = 2;
    
    int a, b, c, d, e, f;
    while (cin >> a >> b >> c >> d >> e >> f) {
        vec_t _b(n);
        _b[0] = c; _b[1] = f;

        mat_t A(n, vec_t(2));

        A[0][0] = a;
        A[0][1] = b;
        A[1][0] = d;
        A[1][1] = e;

        indices_t pi = lup_decomposition(A);

        vec_t x = lup_solve(A, pi, _b);

        cout.setf(ios::fixed);
        cout.precision(3);

        cout << x[0] << " " << x[1] << endl;
    }
    
    return 0;
}

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


int main(void) {
    double a, b, c, d, e, f;
    double x, y;
    
    while(cin >> a >> b >> c >> d >> e >> f) {
        x = (c*e - b*f) / (a*e - b*d);
        y = (c*d - a*f) / (b*d - a*e);
        
        if(x == 0) x = 0;
        if(y == 0) y = 0;
        printf("%.3lf %.3lf", x, y);
        cout << endl;
    }
}