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

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

using namespace std;

// Rekurencyjna funkcja
// obliczania wyznacznika
//-----------------------
long double det(int stopien,
                int wiersz,
                int wk[],
                double A[][9])
{
  int i,j,k,m;
  // wektor kolumn
  // dla podmacierzy
  int kolumny[8];
  long double suma;

  if(stopien == 1)
    return A[wiersz][wk[0]];
  else
  {
    suma = 0;
    m = 1;
    for(i = 0; i < stopien; i++)
    {
      k = 0;
      for(j = 0; j < stopien - 1; j++)
      {
        if(k == i) k++;
        kolumny[j] = wk[k++];
      }
      suma += m * A[wiersz][wk[i]] *
              det(stopien - 1,
                  wiersz + 1,
                  kolumny,
                  A);
      m = -m;
    }
  return suma;
  }
}

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

int main()
{
  // dokładność porównania z zerem
  const double EPS = 0.0000000001;
  ifstream fin;  // Plik wejściowy
  ofstream fout; // Plik wyjściowy
  int i,j,n,WK[8];
  double AB[8][9],X[8];
  long double W;

  cout << setprecision(2)
       << fixed;

  cout << "  Uklad rownan liniowych\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 <= 8)
  {
    for(i = 0; i < n; i++)
      for(j = 0; j <= n; j++)
        fin >> AB[i][j];
    fin.close();

    // Wyświetlamy wczytany układ
    // równań w oknie konsoli
    for(i = 0; i < n; i++)
      for(j = 0; j <= n; j++)
      {
        if(!j)
          cout << setw(5) << AB[i][j];
        else if(j == n)
          cout << "= "
               << setw(5) << AB[i][j]
               << endl;
        else
        {
          if(AB[i][j] > 0)
            cout << "+"
                 << setw(5) << AB[i][j];
          else
            cout << "-"
                 << setw(5)
                 << fabs(AB[i][j]);
        }
        if(j < n)
          cout << "*x" << j + 1 << " ";
      }
    cout << "\n\nWyniki:\n\n";

    // Otwieramy plik wyników out.txt
    fout.open("out.txt");

    // Obliczamy wyznacznik główny
    for(i = 0; i < n; i++)
      WK[i] = i;
    W = det(n,0,WK,AB);
    if(fabs(W) < EPS)
      cout << "Brak rozwiazania\n";
    else
    {
      // Obliczamy kolejne
      // wyznaczniki Wi
      for(i = 0; i < n; i++)
      {
        // podmieniamy kolumnę
        // współczynnikami bi
        WK[i] = n;
        X[i]  = det(n,0,WK,AB) / W;
        // przywracamy kolumnę
        // współczynników ai
        WK[i] = i;
      }

      // Wypisujemy wyniki
      // do okna konsoli oraz
      // do pliku out.txt
      for(i = 0; i < n; i++)
      {
        cout << "x"
             << i + 1
             << " = "
             << setw(10)
             << X[i]
             << endl;
        fout << X[i] << endl;
      }
      fout.close();
    }
  }
  else
  {
    fin.close();
    cout << "Zbyt wiele rownan!\n";
  }
  cout << endl << endl;
  system("pause");
  return 0;
}

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

program mzfl4;

{$APPTYPE CONSOLE}

const
  // dokładność porównania z zerem
  EPS = 0.0000000001;

type
  kwektor = array[1..8] of integer;
  macierz = array[1..8,1..9] of double;

// Rekurencyjna funkcja
// obliczania wyznacznika
//-----------------------
function det(stopien, wiersz : integer;
             var wk : kwektor;
             var A  : macierz) : extended;
var
  i,j,k,m : integer;
  // wektor kolumn dla podmacierzy
  kolumny : kwektor;
begin
  if stopien = 1 then
    Result := A[wiersz,wk[1]]
  else
  begin
    Result := 0; m := 1;
    for i := 1 to stopien do
    begin
      k := 1;
      for j := 1 to stopien - 1 do
      begin
        if k = i then inc(k);
        kolumny[j] := wk[k];
        inc(k);
      end;
      Result := Result + m *
                A[wiersz,wk[i]] *
                det(stopien - 1,
                    wiersz +1 ,
                    kolumny,
                    A);
      m := -m;
    end;
  end;
end;

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

var
  f     : Text;
  i,j,n : integer;
  AB    : macierz;
  W     : extended;
  X     : array[1..8] of double;
  WK    : kwektor;
begin
  writeln('  Uklad rownan liniowych');
  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 <= 8 then
  begin
    for i := 1 to n do
      for j := 1 to n + 1 do
        read(f,AB[i,j]);
    closefile(f);

    // Wyświetlamy wczytany układ
    // równań w oknie konsoli
    for i := 1 to n do
      for j := 1 to n + 1 do
      begin
        if j = 1 then
          write(AB[i,j]:5:2)
        else if j = n + 1 then
          writeln('= ',AB[i,j]:5:2)
        else
        begin
          if AB[i,j] > 0 then
              write('+',AB[i,j]:5:2)
            else
              write('-',abs(AB[i,j]):5:2);
        end;
        if j <= n then write('*x',j,' ');
      end;
    writeln;
    writeln('Wyniki:');
    writeln;

    // Otwieramy plik wyników out.txt
    assignfile(f,'out.txt');
    rewrite(f);

    // Obliczamy wyznacznik główny
    for i := 1 to n do
      WK[i] := i;
    W := det(n,1,WK,AB);
    if abs(W) < EPS then
      writeln('Brak rozwiazania')
    else
    begin

      // Obliczamy kolejne
      // wyznaczniki Wi
      for i := 1 to n do
      begin
        // Podmieniamy kolumnę
        // współczynnikami bi
        WK[i] := n + 1;
        X[i]  := det(n,1,WK,AB) / W;
        // przywracamy kolumnę
        // współczynników ai
        WK[i] := i
      end;

      // Wypisujemy wyniki do okna
      // konsoli oraz do pliku out.txt
      for i := 1 to n do
      begin
        writeln('x',i,' = ',X[i]:10:5);
        writeln(f,X[i]);
      end;
    end;
  end
  else writeln('Za wiele rownan!');
  closefile(f);
  writeln;
  writeln('Nacisnij Enter...');
  readln;
end.

' Program rozwiązuje układ równań
' liniowych o n niewiadomych za
' pomocą metody wyznacznikowej
' Cramera. n <= 8
'--------------------------------
' (C)2006 mgr J.Wałaszek     I LO

Declare Function det(stopien As Integer, _
                     wiersz As Integer, _
                     wk() As Integer, _
                     A() As Double) _
                     As Double

' dokładność porównania z zerem
Const EPS As Double = 0.0000000001

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

Dim As Integer i,j,n,WK(7)
Dim As Double AB(7,8),X(7),W

Print "  Uklad rownan liniowych"
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 <= 8 Then
  For i = 0 To n - 1
    For j = 0 To n
      Input #1, AB(i,j)
    Next
  Next

  ' Wyświetlamy wczytany układ
  ' równań w oknie konsoli
  For i = 0 To n - 1
    For j = 0 To n
      If j = 0 Then
        Print Using "##.##";AB(i,j);
      Elseif j = n Then
        Print Using " = ##.##";AB(i,j)
      Else
        Print Using " +##.##";AB(i,j);
      End If
      If j < n Then Print Using "*X#";j+1;
    Next
  Next
  Print
  Print "Wyniki:"
  Print

  ' Otwieramy plik wyników out.txt
  Open "out.txt" For Output As #2

  ' Obliczamy wyznacznik główny
  For i = 0 To n-1
    WK(i) = i
  Next
  W = det(n,0,WK(),AB())
  If Abs(W) < EPS Then
    Print #2,"Brak rozwiazania"
    Print "Brak rozwiazania"
  Else
 
    ' Obliczamy kolejne wyznaczniki Wi
    For i = 0 To n - 1
      ' Podmieniamy kolumnę
      ' współczynnikami bi
      WK(i) = n
      X(i)  = det(n,0,WK(),AB()) / W
      ' Przywracamy kolumnę
      ' współczynników ai
      WK(i) = i
    Next

    ' Wypisujemy wyniki do okna
    ' konsoli oraz do pliku out.txt
    For i = 0 To n - 1
      Print #2,Using _
        "x# = ####.#####";i;X(i)
      Print Using _
        "x# = ####.#####";i;X(i)
    Next
    Close #2
  End If
Else
  Print "Za wiele rownan!"
End If
Close #1
Print
Print "Koniec. Nacisnij klawisz Enter..."
Sleep
End

' Rekurencyjna funkcja
' obliczania wyznacznika
'-----------------------
Function det(stopien As Integer, _
             wiersz As Integer, _
             wk() As Integer, _
             A() As Double) _
             As Double
    Dim As Integer i, j, k, m
    ' wektor kolumn dla podmacierzy
    Dim kolumny(7) As Integer
    Dim suma As Double

    If stopien = 1 Then
      Return A(wiersz, wk(0))
    Else
      suma = 0 : m = 1
      For i = 0 To stopien - 1
        k = 0
        For j = 0 To stopien - 2
          If k = i Then k += 1
          kolumny(j) = wk(k)
          k += 1
        Next
        suma += m * _
                A(wiersz, wk(i)) * _
                det(stopien - 1, _
                    wiersz + 1, _
                    kolumny(), A())
        m = -m
      Next
      Return suma
    End If
  End Function

# Program rozwiązuje układ równań
# liniowych o n niewiadomych za
# pomocą metody wyznacznikowej
# Cramera. n <= 8
#--------------------------------
# (C)2026 mgr J.Wałaszek     I LO

# Stała dokładności
EPS = 0.0000000001

# Rekurencyjna funkcja obliczania
# wyznacznika
def det(stopien, wiersz, wk, a):
    if stopien == 1:
        return a[wiersz][wk[0]]
    else:
        suma,m = 0.0, 1
        
        for i in range(stopien):
            # Tworzymy wektor kolumn
            # dla podmacierzy
            kolumny = []
            for j in range(stopien):
                if j != i:
                    kolumny.append(wk[j])
            suma += m * a[wiersz][wk[i]] * \
                    det(stopien - 1,
                        wiersz + 1,
                        kolumny, a)
            m = -m
        return suma

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

print("  Układ równań liniowych")
print("      Metoda Cramera")
print("  ----------------------")
print("(C)2026 mgr Jerzy Wałaszek")
print()

# Inicjalizacja struktur
ab = [[0.0 for _ in range(9)] 
      for _ in range(8)]
x = [0.0 for _ in range(8)]
wk = [0 for _ in range(8)]

# 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
    n = int(dane[it]) 
    if n <= 8:
        # Wczytywanie danych
        for i in range(n):
            for j in range(n + 1):
                it += 1
                ab[i][j] = float(dane[it])

        # Wyświetlanie układu
        for i in range(n):
            linia = ""
            for j in range(n + 1):
                if j == 0:
                    linia += f"{ab[i][j]:5.2f}"
                elif j == n:
                    linia += f" = {ab[i][j]:5.2f}"
                else:
                    if ab[i][j] <  0:
                        linia += f" -{-ab[i][j]:5.2f}"
                    else:
                        linia += f" +{ab[i][j]:5.2f}"
                if j < n:
                    linia += f"*X{j+1}"
            print(linia)

        print("\nWyniki:\n")

        # Obliczanie wyznacznika głównego
        for i in range(n): wk[i] = i
        w = det(n, 0, wk[:n], ab)
        with open("out.txt", "w",
                  encoding="utf-8") as f2:
            if abs(w) < EPS:
                komunikat = "Brak rozwiązania"
                print(komunikat)
                f2.write(komunikat + "\n")
            else:
                # Obliczanie kolejnych
                # wyznaczników metodą Cramera
                for i in range(n):
                    wk[i] = n
                    x[i] = det(n, 0, wk[:n], ab) / w
                    wk[i] = i

                # Wypisywanie wyników
                for i in range(n):
                    wynik = f"X{i+1} = {x[i]:10.5f}"
                    print(wynik)
                    f2.write(wynik + "\n")
    else:
        print("Za wiele równań!")
input("\nNaciś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ń<br>
          metodą Cramera</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 wyznacznikowej
// Cramera. n <= 8
//----------------------------------
// (C)2006 mgr J.Wałaszek
// I LO w Tarnowie

// Rekurencyjna funkcja
// obliczania wyznacznika
//-----------------------
function det(stopien, wiersz, wk, A)
{
  var i,j,k,m
  // wektor kolumn dla podmacierzy
  var kolumny = new Array(8)
  var suma

  if(stopien == 1)
    return A[wiersz][wk[0]]
  else
  {
    suma = 0
    m = 1
    for(i = 0; i < stopien; i++)
    {
      k = 0
      for(j = 0; j < stopien - 1; j++)
      {
        if(k == i) k++
        kolumny[j] = wk[k++]
      }
      suma += m * A[wiersz][wk[i]] *
              det(stopien - 1,
                  wiersz + 1,
                  kolumny,
                  A)
      m = -m
    }
    return suma
  }
}

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

function main()
{
  // dokładność porównania z zerem
  var EPS = 0.0000000001;
  var MAXEQ = 8
  var i,j,k,n,W,t,s,z;
  var WK = new Array(8)
  var AB = new Array(8)
  var X =  new Array(8)

  // 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)
        {
          // Wyświetlamy układ równań
          t = "<table border='0' " +
              "cellpadding='4' " +
              "style='border-collapse: " +
              "collapse'>" +
              "<tr><td nowrap>"

          for(i = 0; i < n; i++)
          {
            for(j = 0; j <= n; j++)
            {
              if(!j)
                t += AB[i][j]
              else if (j == n)
                t += " = " + AB[i][j]
              else
                t += (AB[i][j] < 0) ?
                " - " + Math.abs(AB[i][j]):
                " + " + AB[i][j]
              if(j < n)
                t += "x<sub>" +
                     (j + 1) + "</sub>"
            }
            t += "<br>"
          }
          t += "</td></tr><tr><td nowrap>"

          // Obliczamy wyznacznik główny
          for(i = 0; i < n; i++) WK[i] = i
          W = det(n, 0, WK, AB)
          if(Math.abs(W) < EPS)
            t += "<font color=red><b>" +
                 "Brak rozwiazania" +
                 "</b></font>"
          else
          {
            // Obliczamy kolejne
            // wyznaczniki Wi
            for(i = 0; i < n; i++)
            {
              // podmieniamy kolumnę
              // współczynnikami bi
              WK[i] = n;
              X[i] = det(n, 0, WK, AB) / W
              // przywracamy kolumnę
              // współczynników ai
              WK[i] = i;
            }

            // Wypisujemy wyniki
            for(i = 0; i < n; i++)
              t += "x<sub>" +
                   (i + 1) + "</sub> = " +
                   X[i] + "<br>"
            t += "</td></tr></table>"
          } 
        }
      }
    }
  }
  document.getElementById("out")
  .innerHTML = t
}

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