// Eliminacja Gaussa
// Data: 15.02.2010
// (C)2020 mgr Jerzy Wałaszek
//-----------------------------

program gauss;

type
  NReal = array of double; // typ tablic wierszy
  MReal = array of NReal; // typ tablicy wskaźników

const

  eps = 1e-12; // stała przybliżenia zera

// Funkcja realizuje algorytm eliminacji Gaussa
//---------------------------------------------
function gauss(n : integer;
               var AB : MReal;
               var X : NReal)
               : boolean;
var
  i, j, k : integer;
  m, s   : double;
begin

  // eliminacja współczynników
  for i := 0 to n-2 do
  begin
    for j := i+1 to n-1 do
    begin
      if abs(AB[i][i]) < eps then
        exit(false);
      m := -AB[j][i]/AB[i][i];
      for k := i+1 to n do
        AB[j][k] := AB[j][k]+m*AB[i][k];
    end;
  end;

  // wyliczanie niewiadomych
  for i := n-1 downto 0 do
  begin
    s := AB[i][n];
    for j := n-1 downto i+1 do
      s := s-AB[i][j]*X[j];
    if abs(AB[i][i]) < eps then
      exit(false);
    X[i] := s/AB[i][i];
  end;
  gauss := true;
end;

// Program główny
//---------------

var
  AB    : MReal;
  X     : NReal;
  n, i, j : integer;
begin

  // odczytujemy liczbę niewiadomych
  read(n);

  // tworzymy macierze AB i X
  SetLength(AB, n);
  SetLength(X, n);

  for i := 0 to n-1 do SetLength(AB[i], n+1);

  // odczytujemy dane dla macierzy AB
  for i := 0 to n-1 do
    for j := 0 to n do
      read(AB[i][j]);

  writeln;

  if gauss(n, AB, X) then
  begin
    for i := 0 to n-1 do
      writeln('x', i+1, ' = ', X[i]:9:4);
  end
  else
    writeln('DZIELNIK ZERO');

  // usuwamy macierze z pamięci
  for i := 0 to n-1 do
    SetLength(AB[i], 0);
  SetLength(AB, 0);
  SetLength(X, 0);

end.

// Eliminacja Gaussa
// Data: 15.02.2010
// (C)2020 mgr Jerzy Wałaszek
//-----------------------------

#include <iostream>
#include <iomanip>
#include <cmath>

using namespace std;

// stała przybliżenia zera
const double eps = 1e-12

// Funkcja realizuje algorytm
// eliminacji Gaussa
//---------------------------
bool gauss(int n, 
           double ** AB, 
           double * X)
{

  int i, j, k;
  double m, s;

  // eliminacja współczynników
  for(i = 0; i < n-1; i++)
  {
    for(j = i+1; j < n; j++)
    {
      if(fabs(AB[i][i]) < eps)
        return false;
      m = -AB[j][i]/AB[i][i];
      for(k = i+1; k <= n; k++)
        AB[j][k] += m*AB[i][k];
    }
  }

  // wyliczanie niewiadomych
  for(i = n-1; i >= 0; i--)
  {
    s = AB[i][n];
    for(j = n-1; j >= i+1; j--)
      s -= AB[i][j]*X[j];
    if(fabs(AB[i][i]) < eps)
      return false;
    X[i] = s/AB[i][i];
  }
  return true;
}

// Program główny
//---------------

int main()
{
  double **AB, *X;
  int n, i, j;

  cout << setprecision(4) << fixed;
 
  // odczytujemy liczbę niewiadomych
  cin >> n;

  // tworzymy macierze AB i X
  AB = new double * [n];
  X  = new double[n];
  for(i = 0; i < n; i++)
    AB[i] = new double[n+1];

  // odczytujemy dane dla macierzy AB
  for(i = 0; i < n; i++)
    for(j = 0; j <= n; j++)
      cin >> AB[i][j];

  cout << endl;

  if(gauss(n, AB, X))
  {
    for(i = 0; i < n; i++)
      cout << "x" << i+1
           << " = " << setw(9) << X[i]
           << endl;
  }
  else
    cout << "DZIELNIK ZERO\n";

  // usuwamy macierze z pamięci
  for(i = 0; i < n; i++)
    delete [] AB[i];
  delete [] AB;
  delete [] X;

  return 0;
}

' Eliminacja Gaussa
' Data: 15.02.2010
' (C)2020 mgr Jerzy Wałaszek
'-----------------------------

 ' stała przybliżenia zera
Const eps As Double = 1e-12

' Funkcja realizuje algorytm
' eliminacji Gaussa
'---------------------------

Function gauss(n As Integer, _
               AB As Double Ptr Ptr, _
               X As Double Ptr) _
               As Integer

  Dim As Integer i, j, k
  Dim As Double m, s

  ' eliminacja współczynników
  For i = 0 To n-2
    For j = i+1 To n-1
      If Abs(AB[i][i]) < eps Then _
        Return 0
      m = -AB[j][i]/AB[i][i]
      For k = i+1 To n
        AB[j][k] += m*AB[i][k]
      Next
    Next
  Next

  ' wyliczanie niewiadomych
  For i = n-1 To 0 Step -1
    s = AB[i][n]
    For j = n-1 To i+1 Step -1
      s -= AB[i][j]*X[j]
    Next
    If Abs(AB[i][i]) < eps Then _
      Return 0
    X[i] = s/AB[i][i]
  Next
  gauss = 1
End Function

Dim AB As Double Ptr Ptr
Dim X  As Double Ptr
Dim As Integer n, i, j

Open Cons For Input As #1

' odczytujemy liczbę niewiadomych
Input #1, n

' tworzymy macierze AB i X
AB = New Double Ptr[n]
X  = New Double[n]

For i = 0 To n-1
  AB[i] = New Double[n+1]
Next

' odczytujemy dane dla macierzy AB
For i = 0 To n-1
  For j = 0 To n
    Input #1, AB[i][j]
  Next
Next

Close #1

Print

If gauss(n, AB, X) = 1 Then
  For i = 0 To n-1
    Print Using "x# = ####.####";i+1;X[i]
  Next
Else
  Print "DZIELNIK ZERO"
End If

' usuwamy macierze z pamięci
For i = 0 To n-1
  Delete [] AB[i]
Next
Delete [] AB
Delete [] X

End

# Eliminacja Gaussa
# Data: 18.04.2024
# (C)2024 mgr Jerzy Wałaszek
#-----------------------------

EPS = 1e-12 # stała przybliżenia zera


# Funkcja realizuje algorytm
# eliminacji Gaussa
#---------------------------
def gauss(ab, x):

    # eliminacja współczynników
    n = len(x)
    for i in range(n-1):
        for j in range(i+1, n):
            if abs(ab[i][i]) < EPS:
                return False
            m = -ab[j][i]/ab[i][i]
            for k in range(i+1, n+1):
                ab[j][k] += m*ab[i][k]
    # wyliczanie niewiadomych
    for i in reversed(range(n)):
        s = ab[i][n]
        for j in reversed(range(n)):
            s -= ab[i][j]*x[j]
        if abs(ab[i][i]) < EPS:
            return False
        x[i] = s/ab[i][i]
    return True


# Program główny
#---------------

# odczytujemy liczbę niewiadomych
n = int(input())
# tworzymy macierze ab i x
ab = []
x  = [0 for i in range(n)]
# odczytujemy dane dla macierzy ab
for i in range(n):
    arr = input().split()
    arr = [float(arr[j]) for j in range(n+1)]
    ab.append(arr)
print()
if gauss(ab, x):
    for i in range(n):
        print("x%d = %9.4f" % (i+1, x[i]))
else:
    print("DZIELNIK ZERO")
# usuwamy macierze z pamięci
ab = None
x = None