// Rekurencyjne obliczanie silni
//------------------------------
// (C)2012 mgr Jerzy Wałaszek
// I LO w Tarnowie
//------------------------------

program silnia_rek;

function silnia(n : integer) : extended;
begin
  if n < 2 then silnia := 1 else silnia := n * silnia(n - 1);
end;

var
  n : cardinal;

begin
  writeln('Program oblicza rekurencyjnie silnie z liczby n');
  writeln('------------------------------------------------------');
  writeln('(C)2005 mgr Jerzy Walaszek I LO w Tarnowie');
  writeln;
  write('Podaj n = '); readln(n);
  writeln;
  writeln(n,'! = ',silnia(n):0:0);
  writeln;
  write('Nacisnij Enter...'); readln;
end.

// Sortowanie przez scalanie
//--------------------------------------------------------
// (C)2012 mgr Jerzy Wałaszek
// I Liceum Ogólnokształcące
// im. K. Brodzińskiego
// w Tarnowie
//--------------------------------------------------------

#include <cmath>
#include <iostream>
#include <iomanip>
#include <cstdlib>
#include <time.h>

using namespace std;

const int N = 20; // Liczebność zbioru.

int d[N],p[N];

// Procedura sortująca
//--------------------

void MergeSort(int i_p, int i_k)
{
  int i_s,i1,i2,i;

  i_s = (i_p + i_k + 1) / 2;
  if(i_s - i_p > 1) MergeSort(i_p, i_s - 1);
  if(i_k - i_s > 0) MergeSort(i_s, i_k);
  i1 = i_p; i2 = i_s;
  for(i = i_p; i <= i_k; i++)
    p[i] = ((i1 == i_s) || ((i2 <= i_k) && (d[i1] > d[i2]))) ? d[i2++] : d[i1++];
  for(i = i_p; i <= i_k; i++) d[i] = p[i];
}

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

int main()
{
  int i;
  
  cout << " Sortowanie przez scalanie\n"
          "---------------------------\n"
          "  (C)2005  Jerzy Walaszek\n\n"
          "Przed sortowaniem:\n\n";

// Najpierw wypełniamy tablicę d[] liczbami pseudolosowymi
// a następnie wyświetlamy jej zawartość

  srand((unsigned)time(NULL));

  for(i = 0; i < N; i++) d[i] = rand() % 100;
  for(i = 0; i < N; i++) cout << setw(4) << d[i];
  cout << endl;

// Sortujemy

  MergeSort(0,N-1);
  
// Wyświetlamy wynik sortowania

  cout << "Po sortowaniu:\n\n";
  for(i = 0; i < N; i++) cout << setw(4) << d[i];
  cout << endl;
  return 0;
}

// Sortowanie Przez Scalanie
//--------------------------------------------------------
// (C)2012 mgr Jerzy Wałaszek
// I Liceum Ogólnokształcące
// im. K. Brodzińskiego
// w Tarnowie
//--------------------------------------------------------

program Merge_Sort;

const N = 20; // Liczebność zbioru.

var
  d,p : array[1..N] of integer;

// Procedura sortująca
//--------------------
procedure MergeSort(i_p,i_k : integer);
var
  i_s,i1,i2,i : integer;
begin
  i_s := (i_p + i_k + 1) div 2;
  if i_s - i_p > 1 then MergeSort(i_p, i_s - 1);
  if i_k - i_s > 0 then MergeSort(i_s, i_k);
  i1 := i_p; i2 := i_s;
  for i := i_p to i_k do
    if (i1 = i_s) or ((i2 <= i_k) and (d[i1] > d[i2])) then
    begin
      p[i] := d[i2]; inc(i2);
    end
    else
    begin
      p[i] := d[i1]; inc(i1);
    end;
  for i := i_p to i_k do d[i] := p[i];
end;

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

var
  i : integer;
begin
  writeln(' Sortowanie przez scalanie ');
  writeln('---------------------------');
  writeln('  (C)2005  Jerzy Walaszek  ');
  writeln;

// Najpierw wypełniamy tablicę d[] liczbami pseudolosowymi
// a następnie wyświetlamy jej zawartość

  randomize;
  for i := 1 to N do d[i] := random(100);
  writeln('Przed sortowaniem:'); writeln;
  for i := 1 to N do write(d[i] : 4);
  writeln;

// Sortujemy

  MergeSort(1,N);

// Wyświetlamy wynik sortowania

  writeln('Po sortowaniu:'); writeln;
  for i := 1 to N do write(d[i] : 4);
  writeln;
  writeln('Nacisnij Enter...');
  readln;
end.

' Sortowanie Przez Scalanie
'--------------------------------------------------------
' (C)2012 Jerzy Wałaszek
' I Liceum Ogólnokształcące
' im. K. Brodzińskiego
' w Tarnowie
'--------------------------------------------------------

  OPTION EXPLICIT
  
  CONST N = 20 ' Liczebność zbioru.

  DIM SHARED d(1 TO N) AS INTEGER
  DIM SHARED p(1 TO N) AS INTEGER

  DECLARE SUB MergeSort(BYVAL i_p AS INTEGER, BYVAL i_k AS INTEGER)

  DIM i AS INTEGER

  PRINT " Sortowanie przez scalanie "
  PRINT "---------------------------"
  PRINT "  (C)2005  Jerzy Walaszek  "
  PRINT

' Najpierw wypełniamy tablicę d() liczbami pseudolosowymi
' a następnie wyświetlamy jej zawartość

  RANDOMIZE TIMER
  FOR i = 1 TO N: d(i) = INT(RND * 100): NEXT
  PRINT "Przed sortowaniem:"
  PRINT
  FOR i = 1 TO N: PRINT USING "####"; d(i);: NEXT
  PRINT

' Sortujemy

  MergeSort 1, N

' Wyświetlamy wynik sortowania

  PRINT "Po sortowaniu:"
  PRINT
  FOR i = 1 TO N: PRINT USING "####"; d(i);: NEXT
  PRINT
  PRINT "Nacisnij Enter..."
  SLEEP
  END

' Procedura sortująca
'--------------------
PUBLIC SUB MergeSort(BYVAL i_p AS INTEGER, BYVAL i_k AS INTEGER)

  DIM i_s AS INTEGER, i1 AS INTEGER, i2 AS INTEGER, i AS INTEGER

  i_s = INT((i_p + i_k + 1) / 2)
  IF i_s - i_p > 1 THEN MergeSort i_p, i_s - 1
  IF i_k - i_s > 0 THEN MergeSort i_s, i_k
  i1 = i_p: i2 = i_s
  FOR i = i_p TO i_k
    IF (i1 = i_s) OR ((i2 <= i_k) AND (d(i1) > d(i2))) THEN
      p(i) = d(i2): i2 = i2 + 1
    ELSE
      p(i) = d(i1): i1 = i1 + 1
    END IF
  NEXT
  FOR i = i_p TO i_k: d(i) = p(i): NEXT
END SUB

<html>
  <head>
  </head>
  <body>
    <form style="BORDER-RIGHT: #ff9933 1px outset;
                 PADDING-RIGHT: 4px; BORDER-TOP: #ff9933 1px outset;
                 PADDING-LEFT: 4px; PADDING-BOTTOM: 1px;
                 BORDER-LEFT: #ff9933 1px outset; PADDING-TOP: 1px;
                 BORDER-BOTTOM: #ff9933 1px outset;
                 BACKGROUND-COLOR: #ffcc66" name="frmmergesort">
      <h3 style="text-align: center">Sortowanie Przez Scalanie</h3>
      <p style="TEXT-ALIGN: center">
        (C)2012 mgr Jerzy Wałaszek - I LO w Tarnowie
      </p>
      <hr>
      <p style="TEXT-ALIGN: center">
        <input onclick="main()" type="button" value="Sortuj" name="B1">
      </p>
      <p id="t_out" style="TEXT-ALIGN: center">...</p>
    </form>

<script language=javascript>

// Sortowanie Przez Scalanie
//--------------------------------------------------------
// (C)2012 mgr Jerzy Wałaszek
// I Liceum Ogólnokształcące
// im. K. Brodzińskiego
// w Tarnowie
//--------------------------------------------------------

var N = 20; // Liczebność zbioru.
var d = new Array(N);
var p = new Array(N);

// Procedura sortująca
//--------------------

function MergeSort(i_p, i_k)
{
  var i_s,i1,i2,i;

  i_s = Math.floor((i_p + i_k + 1) / 2);
  if(i_s - i_p > 1) MergeSort(i_p, i_s - 1);
  if(i_k - i_s > 0) MergeSort(i_s, i_k);
  i1 = i_p; i2 = i_s;
  for(i = i_p; i <= i_k; i++)
    p[i] = ((i1 == i_s) || ((i2 <= i_k) && (d[i1] > d[i2]))) ? d[i2++] : d[i1++];
  for(i = i_p; i <= i_k; i++) d[i] = p[i];
}

function main()
{
  var i,t;

  // Najpierw wypełniamy tablicę d[] liczbami pseudolosowymi

  for(i = 0; i < N; i++) d[i] = Math.floor(Math.random() * 100);
  t = "Przed sortowaniem:<BR><BR>";
  for(i = 0; i < N; i++) t += d[i] + " ";
  t += "<BR><BR>";

  // Sortujemy

  MergeSort(0,N-1);

  // Wyświetlamy wynik sortowania

  t += "Po sortowaniu:<BR><BR>";
  for(i = 0; i < N; i++) t += d[i] + " ";
  document.getElementById("t_out").innerHTML = t;
}

</script> 

  </body>
</html>

// Program testujący czas sortowania dla
// danego algorytmu sortującego
//--------------------------------------
// (C)2012 mgr Jerzy Wałaszek
// I Liceum Ogólnokształcące
// w Tarnowie
//--------------------------------------

program TestCzasuSortowania;

uses Windows;

const
  NAZWA = 'Sortowanie przez scalanie';
  K1    = '-----------------------------------------------------------';
  K2    = '(C)2011/2012 I Liceum Ogolnoksztalcace  w Tarnowie';
  K3    = '------n---------tpo---------tod---------tpp---------tpk---------tnp';
  K4    = '-------------------------------------------------------------------';
  MAX_LN = 8; // określa ostatnie LN
  LN : array[1..8] of integer = (1000,2000,4000,8000,16000,32000,64000,128000);

var
  d,p       : array[1..128000] of real; // sortowana tablica
  n         : integer;                  // liczba elementów
  qpf,tqpc  : int64;                    // dane dla pomiaru czasu
  qpc1,qpc2 : int64;

// Tutaj umieszczamy procedurę sortującą tablicę d
//-------------------------------------------------------

procedure MergeSort(i_p,i_k : integer);
var
  i_s,i1,i2,i : integer;
begin
  i_s := (i_p + i_k + 1) div 2;
  if i_s - i_p > 1 then MergeSort(i_p, i_s - 1);
  if i_k - i_s > 0 then MergeSort(i_s, i_k);
  i1 := i_p; i2 := i_s;
  for i := i_p to i_k do
    if (i1 = i_s) or ((i2 <= i_k) and (d[i1] > d[i2])) then
    begin
      p[i] := d[i2]; inc(i2);
    end
    else
    begin
      p[i] := d[i1]; inc(i1);
    end;
  for i := i_p to i_k do d[i] := p[i];
end;

function Sort : extended;
begin
  QueryPerformanceCounter(addr(qpc1));
  MergeSort(1,n);
  QueryPerformanceCounter(addr(qpc2));
  Sort := (qpc2 - qpc1 - tqpc) / qpf;
end;

// Program główny
//---------------
var
  i,j,k               : integer;
  tpo,tod,tpp,tpk,tnp : extended;
  f                   : Text;
begin
  if QueryPerformanceFrequency(addr(qpf)) then
  begin
    QueryPerformanceCounter(addr(qpc1));
    QueryPerformanceCounter(addr(qpc2));
    tqpc := qpc2 - qpc1;

    assignfile(f,'wyniki.txt'); rewrite(f);

// Wydruk na ekran

    writeln('Nazwa: ',NAZWA);
    writeln(K1);
    writeln(K2);
    writeln;
    writeln(K3);

// Wydruk do pliku

    writeln(f,'Nazwa: ',NAZWA);
    writeln(f,K1);
    writeln(f,K2);
    writeln(f,'');
    writeln(f,K3);
    for i := 1 to MAX_LN do
    begin
      n := LN[i];

// Czas sortowania zbioru posortowanego

      for j := 1 to n do d[j] := j;
      tpo := Sort;

// Czas sortowania zbioru posortowanego odwrotnie

      for j := 1 to n do d[j] := n - j;
      tod := Sort;

// Czas sortowania zbioru posortowanego
// z przypadkowym elementem na początku - średnia z 10 obiegów

      tpp := 0;
      for j := 1 to 10 do
      begin
        for k := 1 to n do d[k] := k;
        d[1] := random * n + 1;
        tpp += Sort;
      end;
      tpp /= 10;

// Czas sortowania zbioru posortowanego
// z przypadkowym elementem na końcu - średnia z 10 obiegów

      tpk := 0;
      for j := 1 to 10 do
      begin
        for k := 1 to n do d[k] := k;
        d[n] := random * n + 1;
        tpk += Sort;
      end;
      tpk /= 10;

// Czas sortowania zbioru nieuporządkowanego - średnia z 10 obiegów

      tnp := 0;
      for j := 1 to 10 do
      begin
        for k := 1 to n do d[k] := random;
        tnp += Sort;
      end;
      tnp /= 10;

      writeln(n:7,tpo:12:6,tod:12:6,tpp:12:6,tpk:12:6,tnp:12:6);
      writeln(f,n:7,tpo:12:6,tod:12:6,tpp:12:6,tpk:12:6,tnp:12:6);
    end;
    writeln(K4);
    writeln(f,K4);
    writeln(f,'Koniec');
    closefile(f);
    writeln;
    writeln('Koniec. Wyniki w pliku WYNIKI.TXT');
  end
  else writeln('Na tym komputerze program testowy nie pracuje !');
  writeln;
  write('Nacisnij klawisz ENTER...'); readln;
end.