5
2 -2  2 -7  6 -4
7 -3 -2  7  2 11
2  2 -1  1  4  9
9  8 -2  2 -2 21
4  8 -3  3 -1 16

// Program rozwiązuje układ
// równań liniowych o n
// niewiadomych za pomocą
// metody eliminacji Gaussa
//-------------------------
// (C)2006 mgr J.Wałaszek

#include <iostream>
#include <iomanip>
#include <fstream>
#include <cmath>
#include <cstdlib>

using namespace std;

// dokładność porównania z zerem
const double EPS   = 0.0000000001;
// maksymalna ilość równań
// w układzie
const int MAXEQ = 100;

// Funkcja dokonująca eliminacji
// niewiadomych. Jeśli operacja
// się powiedzie, zwraca true.
// Inaczej zwraca false.
bool EliminujX(int n,
               double AB[][MAXEQ+1])
{
  int    i,j,k;
  double m;

  for(i = 0; i < n - 1; i++)
  {
    if(fabs(AB[i][i]) < EPS)
      return false;

    for(j = i + 1; j < n; j++)
    {
      m = -AB[j][i] / AB[i][i];
      for(k = i + 1; k <= n; k++)
        AB[j][k] += m * AB[i][k];
    }
  }
  return true;
}

// Funkcja oblicza kolejne
// niewiadome x z macierzy AB
// przetworzonej przez funkcję
// Eliminuj_X(). Jeśli operacja
// się powiedzie, zwraca true.
// Inaczej zwraca false.
bool ObliczX(int n,
             double X[],
             double AB[][MAXEQ+1])
{
  int    i,j;
  double s;

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

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

int main()
{
  ifstream fin;
  ofstream fout;
  int i,j,n;
  double AB[MAXEQ][MAXEQ+1],
         X[MAXEQ];

  cout << setprecision(5)
       << fixed;

  cout << "  Uklad rownan liniowych\n"
          " metoda eliminacji Gaussa\n"
          " ------------------------\n"
          "(C)2006 mgr Jerzy Walaszek\n\n";

  // Dane dla programu odczytujemy
  // z pliku tekstowego o nazwie in.txt,
  // który musi się znajdować w tym samym
  // katalogu co program. Pierwszy wiersz
  // pliku powinien zawierać liczbę n.
  // Następne n kolejnych wierszy powinno
  // zawierać współczynniki ai dla tego
  // wiersza, a na końcu współczynnik bi.
  // Kolejne współczynniki oddzielone są
  // od siebie przynajmniej jedną spacją.

  fin.open("in.txt");
  fin >> n;
  if(n <= MAXEQ)
  {
    for(i = 0; i < n; i++)
      for(j = 0; j <= n; j++)
        fin >> AB[i][j];
    fin.close();

    // Dokonujemy eliminacji oraz
    // obliczania niewiadomych x

    cout << "Wyniki:\n\n";

    if(EliminujX(n,AB) &&
       ObliczX(n,X,AB))
    {
      fout.open("out.txt");
      for(i = 0; i < n; i++)
      {
        cout << "x" << i + 1
             << " = " << setw(12)
             << X[i] << endl;
        fout << X[i] << endl;
      }
      fout.close();
    }
    else cout << "Rozwiazanie ukladu "
                 "rownan nie powiodlo "
                 "sie\n";
  }
  else
  {
    fin.close();
    cout << "Zbyt wiele rownan!\n";
  }
  cout << endl;
  system("pause");
  return 0;
}

// Program rozwiązuje układ
// równań liniowych o n
// niewiadomych za pomocą
// metody eliminacji Gaussa
//-------------------------
// (C)2006 mgr J.Wałaszek

program mzfl5;

const
  // dokładność porównania z zerem
  EPS   = 0.0000000001;
  // maksymalna ilość równań w układzie
  MAXEQ = 100;

type
  xwektor = array[1..MAXEQ] of double;
  macierz = array[1..MAXEQ,1..MAXEQ + 1]
            of double;

// Funkcja dokonująca eliminacji
// niewiadomych. Jeśli operacja
// się powiedzie, zwraca true.
// Inaczej zwraca false.
function EliminujX(n : integer;
                   var AB : macierz)
                   : boolean;
var
  i,j,k : integer;
  m     : double;
begin
  for i := 1 to n - 1 do
  begin
    if abs(AB[i,i]) < EPS then
    begin
      Result := false; exit;
    end;
    for j := i + 1 to n do
    begin
      m := -AB[j,i] / AB[i,i];
      for k := i + 1 to n + 1 do
        AB[j,k] := AB[j,k] +
                   m * AB[i,k];
    end;
  end;
  Result := true;
end;

// Funkcja oblicza kolejne
// niewiadome x z macierzy AB
// przetworzonej przez funkcję
// Eliminuj_X(). Jeśli operacja
// się powiedzie, zwraca true.
// Inaczej zwraca false.
function ObliczX(n : integer;
                 var X : xwektor;
                 var AB : macierz)
                 : boolean;
var
  i,j : integer;
  s   : double;
begin
  for i := n downto 1 do
  begin
    if abs(AB[i,i]) < EPS then
    begin
      Result := false; exit;
    end;
    s := AB[i,n + 1];
    for j := n downto i + 1 do
      s := s - AB[i,j] * X[j];
    X[i] := s / AB[i,i];
  end;
  Result := true;
end;

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

var
  f     : Text;
  i,j,n : integer;
  AB    : macierz;
  X     : xwektor;

begin
  writeln('  Uklad rownan liniowych');
  writeln(' Metoda eliminacji Gaussa');
  writeln(' ------------------------');
  writeln('(C)2006 mgr Jerzy Walaszek');
  writeln;

  // Dane dla programu odczytujemy
  // z pliku tekstowego o nazwie in.txt,
  // który musi się znajdować w tym samym
  // katalogu co program. Pierwszy wiersz
  // pliku powinien zawierać liczbę n.
  // Następne n kolejnych wierszy powinno
  // zawierać współczynniki ai dla tego
  // wiersza, a na końcu współczynnik bi.
  // Kolejne współczynniki oddzielone są
  // od siebie przynajmniej jedną spacją.

  assignfile(f,'in.txt');
  reset(f);
  readln(f,n);
  if n <= MAXEQ then
  begin
    for i := 1 to n do
      for j := 1 to n + 1 do
        read(f,AB[i,j]);
    closefile(f);

    // Dokonujemy eliminacji oraz
    // obliczania niewiadomych x

    writeln('Wyniki:');
    writeln;
    if EliminujX(n,AB) and
       ObliczX(n,X,AB) then
    begin
      assignfile(f,'out.txt');
      rewrite(f);
      for i := 1 to n do
      begin
        writeln('x',i,' = ',X[i]:12:5);
        writeln(f,X[i]);
      end;
      closefile(f);
    end
    else writeln('Rozwiazanie ukladu ',
                 'rownan nie powiodlo ',
                 'sie');
  end
  else
  begin
    writeln('Zbyt wiele rownan!');
    closefile(f);
  end;
  writeln;
  writeln('Nacisnij klawisz Enter...');
  readln;
end.

' Program rozwiązuje układ
' równań liniowych o n
' niewiadomych za pomocą
' metody eliminacji Gaussa
'-------------------------
' (C)2006 mgr J.Wałaszek

Declare Function _
  EliminujX(n As Integer, _
            AB() As Double) _
            As Integer
Declare Function _
  ObliczX(n As Integer, _
          X() As Double, _
          AB() As Double) _
          As Integer

' dokładność porównania z zerem
Const EPS As Double = 0.0000000001
' maksymalna ilość równań w układzie
Const MAXEQ As Integer = 100

'---------------
' Program główny
'---------------

Dim As integer i, j, n
Dim As double AB(MAXEQ - 1, MAXEQ), _
              X(MAXEQ - 1)

Print "  Uklad rownan liniowych"
Print " Metoda eliminacji Gaussa"
Print " ------------------------"
Print "(C)2006 mgr Jerzy Walaszek"
Print

' Dane dla programu odczytujemy
' z pliku tekstowego o nazwie in.txt,
' który musi się znajdować w tym samym
' katalogu co program. Pierwszy wiersz
' pliku powinien zawierać liczbę n.
' Następne n kolejnych wierszy powinno
' zawierać współczynniki ai dla tego
' wiersza, a na końcu współczynnik bi.
' Kolejne współczynniki oddzielone są
' od siebie przynajmniej jedną spacją.
Open "in.txt" For Input as #1
Input #1, n
If n <= MAXEQ Then
  For i = 0 To n - 1
    For j = 0 To n
      Input #1, AB(i, j)
    Next
  Next
  Close #1

  ' Dokonujemy eliminacji oraz
  ' obliczania niewiadomych x
  Print
  Print "Wyniki:"
  Print

  If EliminujX(n, AB()) And _
     ObliczX(n, X(), AB()) Then
    Open "out.txt" For Output as #1

    ' Wypisujemy wyniki do okna
    ' konsoli oraz do pliku out.txt
    For i = 0 To n - 1
      Print "X";i + 1;
      Print Using " = ######.#####"; X(i)
      Print #1,Using "######.#####"; X(i)
    Next
    Close #1
  Else
    Print "Rozwiazanie ukladu ";
    Print "rownan nie powiodlo sie"
  End If
Else
  Print "Zbyt wiele rownan!"
  Close #1
End If

Print
Print "Nacisnij Enter..."
Sleep
End

' Funkcja dokonująca eliminacji
' niewiadomych. Jeśli operacja
' się powiedzie, zwraca true.
' Inaczej zwraca false.
Function EliminujX(n As Integer, _
                   AB() As Double) _
                   As Integer
  Dim As Integer i, j, k
  Dim m As Double

  For i = 0 To n - 2
    If Abs(AB(i, i)) < EPS Then Return 0
    For j = i + 1 To n - 1
      m = -AB(j, i) / AB(i, i)
      For k = i + 1 To n
        AB(j, k) += m * AB(i, k)
      Next
    Next
  Next
  Return 1
End Function

' Funkcja oblicza kolejne
' niewiadome x z macierzy AB
' przetworzonej przez funkcję
' Eliminuj_X(). Jeśli operacja
' się powiedzie, zwraca true.
' Inaczej zwraca false.
Function ObliczX(n As Integer, _
                 X() As Double, _
                 AB() As Double) _
                 As Integer
  Dim As Integer i, j
  Dim s As Double

  For i = n - 1 To 0 Step -1
    If Abs(AB(i, i)) < EPS Then Return 0
    s = AB(i, n)
    For j = n - 1 To i + 1 Step -1
      s -= AB(i, j) * X(j)
    Next
    X(i) = s / AB(i, i)
  Next
  Return 1
End Function

# Program rozwiązuje układ
# równań liniowych o n
# niewiadomych za pomocą
# metody eliminacji Gaussa
#-------------------------
# (C)2026 mgr J.Wałaszek

# Dokładność porównania z zerem
EPS = 0.0000000001
# Maksymalna ilość równań w układzie
MAXEQ = 100

# Funkcja dokonująca eliminacji
# niewiadomych. Jeśli operacja
# się powiedzie, zwraca True.
# Inaczej zwraca False.
def eliminujx(n, ab):
    for i in range(n - 1):
        if abs(ab[i][i]) < EPS:
            return False
        for j in range(i + 1, n):
            m = -ab[j][i] / ab[i][i]
            for k in range(i + 1, n + 1):
                ab[j][k] += m * ab[i][k]
    return True

# Funkcja oblicza kolejne
# niewiadome x z macierzy AB
# przetworzonej przez funkcję
# Eliminuj_X(). Jeśli operacja
# się powiedzie, zwraca true.
# Inaczej zwraca false.
def obliczx(n, x, ab):
    for i in reversed(range(n)):
        if abs(ab[i][i]) < EPS:
            return False
        s = ab[i][n]
        for j in reversed(range(i + 1, n)):
            s -= ab[i][j] * x[j]
        x[i] = s / ab[i][i]
    return True

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

print("  Układ równań liniowych")
print(" Metoda eliminacji Gaussa")
print(" ------------------------")
print("(C)2026 mgr Jerzy Walaszek")
print

# Dane dla programu odczytujemy
# z pliku tekstowego o nazwie in.txt,
# który musi się znajdować w tym samym
# katalogu co program. Pierwszy wiersz
# pliku powinien zawierać liczbę n.
# Następne n kolejnych wierszy powinno
# zawierać współczynniki ai dla tego
# wiersza, a na końcu współczynnik bi.
# Kolejne współczynniki oddzielone są
# od siebie przynajmniej jedną spacją.
with open("in.txt", "r",
          encoding="utf-8") as f1:
    dane = f1.read().split() # tworzymy listę
    it = 0 # numeruje kolejne elementy listy
    n = int(dane[it])
    if n <= MAXEQ:
        # Inicjalizacja macierzy AB zerami
        ab = [[0.0 for _ in range(n + 1)]
              for _ in range(n)]
        for i in range(n):
            for j in range(n + 1):
                it += 1 # następny element
                ab[i][j] = float(dane[it])

        print("\nWyniki:\n")

        x = [0.0] * n

        if eliminujx(n, ab) and \
           obliczx(n, x, ab):
            with open("out.txt", "w",
                      encoding="utf-8") as f2:
                for i in range(n):
                    f = f"{x[i]:12.5f}"
                    print(f"X{i+1} = {f}")
                    f2.write(f"{f}\n")
        else:
            print("\nRozwiązanie układu",
                  "równań nie powiodło się")
    else:
        print("\nZbyt wiele równań!")
print()
input("Naciśnij Enter...")

<html>
  <head>
  </head>
  <body>
<div style="overflow-x: auto;"
     align="center">
  <table
  border="0"
  cellpadding="4"
  style="border-collapse:
         collapse">
    <tr>
      <td nowrap>
        <form
        name="frmbincode"
        style="text-align: center;
               background-color: #E7E7DA">
          <big><b>
          Demonstracja rozwiązywania<br>
          układu równań za pomocą<br>
          Eliminacji Gaussa</b>
          </big><br>
          <br>
          &nbsp;&nbsp;
          (C)2026
          mgr Jerzy Wałaszek
          I LO w Tarnowie
          &nbsp;&nbsp;
          <hr>
          Tutaj wprowadź wiersze<br>
          ze współczynnikami<br>
          układu równań:<br>
          <br>
          <textarea
          rows="9"
          name="input"
          cols="50">
5
2 -2 2 -7 6 -4
7 -3 -2 7 2 11
2 2 -1 1 4 9
9 8 -2 2 -2 21
4 8 -3 3 -1 16
          </textarea>
          <hr>
          <input
          type="button"
          value="Licz"
          name="B1"
          onclick="main()">
          <hr>
          <b>Wyniki:</b>
          <div
          id="out"
          align="center">.</div>
        </form>
      </td>
    </tr>
  </table>
</div>

<script language=javascript>

// Program rozwiązuje układ
// równań liniowych o n niewiadomych
// za pomocą metody eliminacji Gaussa.
//------------------------------------
// (C)2006 mgr J.Wałaszek
// I LO w Tarnowie

// Dokładność porównania z zerem
var EPS   = 0.0000000001
// Maksymalna ilość równań w układzie
var MAXEQ = 100

// Funkcja dokonująca eliminacji
// niewiadomych. Jeśli operacja
// się powiedzie, zwraca true.
// Inaczej zwraca false.
function EliminujX(n, AB)
{
  var i,j,k,m

  for(i = 0; i < n - 1; i++)
  {
    if(Math.abs(AB[i][i]) < EPS)
      return false
    for(j = i + 1; j < n; j++)
    {
      m = -AB[j][i] / AB[i][i]
      for(k = i + 1; k <= n; k++)
        AB[j][k] += m * AB[i][k]
    }
  }
  return true
}

// Funkcja oblicza kolejne
// niewiadome x z macierzy AB
// przetworzonej przez
// funkcję Eliminuj_X().
// Jeśli operacja się powiedzie,
// zwraca true. Inaczej
// zwraca false.
function ObliczX(n, X, AB)
{
  var i,j,s

  for(i = n - 1; i >= 0; i--)
  {
    if(Math.abs(AB[i][i]) < EPS)
      return false
    s = AB[i][n]
    for(j = n - 1; j > i; j--)
      s -= AB[i][j] * X[j]
    X[i] = s / AB[i][i]
  }
  return true
}

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

function main()
{
  var i,j,n,s,t,z
  var AB = new Array(MAXEQ)
  var X =  new Array(MAXEQ)

  // Dane dla programu odczytujemy
  // z pola tekstowego. Pierwszy
  // wiersz pola powinien zawierać
  // liczbę n. Następne n kolejnych
  // wierszy powinno zawierać
  // współczynniki ai dla tego
  // wiersza, a na końcu
  // współczynnik bi. Kolejne
  // współczynniki oddzielone są od
  // siebie przynajmniej jedną spacją.
  t = "<font color=red>" +
      "<b>Złe dane</b></font>"
  s = document.frmbincode.input
      .value
  if(s.length > 0)
  {
    // Odczytujemy współczynniki
    // z pola tekstowego formularza
    while((j = s.indexOf('\n')) != -1)
      s = s.substring(0,j) + " " +
          s.substring(j + 1,s.length)
    while((j = s.indexOf('\r')) != -1)
      s = s.substring(0,j) + " " +
          s.substring(j + 1,s.length)
    while((j = s.indexOf('\t')) != -1)
      s = s.substring(0,j) + " " +
          s.substring(j + 1,s.length)
    while(s.length > 0 &&
         (s.charAt(0) == " "))
      s = s.substring(1,s.length)
    while(s.length > 0 &&
         (s.charAt(s.length-1) == " "))
      s = s.substring(0,s.length - 1)
    while(s.length > 0 &&
         ((j = s.indexOf("  ")) != -1))
      s = s.substring(0,j) +
          s.substring(j+1,s.length)
    s = s.split(' ')
    if(s.length > 0)
    {
      n = parseInt(s[0])
      if((!isNaN(n)) &&
        (s.length >= n * (n + 1) + 1) &&
        (n <= MAXEQ))
      {
        k = 1
        z = true
        for(i = 0; i < n; i++)
        {
          AB[i] = new Array(n + 1)
          for(j = 0; j <= n; j++)
            z = z && !isNaN(AB[i][j] =
                parseFloat(s[k++]))
        }
        if(z)
        {
          // Dokonujemy eliminacji oraz
          // obliczania niewiadomych x
          t = "<table border='0' " +
              "cellpadding='4'" +
              "style='border-collapse: " +
              "collapse'><tr><td nowrap>"

          if(EliminujX(n,AB) &&
             ObliczX(n,X,AB))
            for(i = 0; i < n; i++)
              t += "x<sub>" + (i + 1) +
                   "</sub> = " + X[i] +
                   "<br>"
          else
            t += "<font color=red><b>" +
                 "Rozwiązanie układu " +
                 "równań nie powiodło się" +
                 "</b></font>"
          t += "</td></tr></table>"
        }
      }
    }
  }
  document.getElementById("out")
  .innerHTML = t
}

</script>
  </body>
</html>