(* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *)
(*  Soubor: MINIMAX.PAS                                                    *)
(*  Obsah: programek na hledani nejmensiho a nejvetsiho prvku v poli       *)
(*         a jednoduche trideni algoritmem bubblesort                      *)
(*  Autor: Mircosoft (http://mircosoft.mzf.cz)                             *)
(*  Posledni uprava: 1.6.2008                                              *)
(*  Pro kompilaci: nic                                                     *)
(*  Pro spusteni: nic                                                      *)
(*  Upozorneni: tyto zdrojove kody pouzivate na vlastni nebezpeci          *)
(* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *)
program minimum_maximum_a_trideni;

const pocet=10; {pocet prvku v poli, lze libovolne menit}

var pole:array[1..pocet] of integer; {pole, se kterym budeme pracovat}

    Index:integer; {pomocny index pro prochazeni pole}

    NejmensiPrvek,IndexNejmensiho:integer; {promenne pro hledani minima a maxima}
    NejvetsiPrvek,IndexNejvetsiho:integer;

    PresouvaloSe:boolean;    {promenne pro trideni}
    PomocnaPromenna:integer;


procedure VypisPole; {procedura pro vypsani obsahu pole na obrazovku}
var i:integer; {pomocny index}
Begin
write('Pole = ('); {vypiseme hlavicku}
write(pole[1]); {vypiseme prvni prvek pole (aby nam vysly carky mezi cisly)}
for i:=2 to pocet do write(', ',pole[i]); {vypiseme ostatni prvky pole, pred kazdym udelame carku}
writeln(')'); {vypiseme ukoncovaci zavorku}
End;{vypispole}


BEGIN
writeln('***************** zacatek programu ******************');


{nejdriv naplnime pole nahodnymi hodnotami, aby bylo s cim pracovat:}
write('Plnim pole nahodnymi cisly... ');
randomize; {inicializace generatoru nahodnych cisel, nutno provest jednou na zacatku}
for index:=1 to pocet do pole[index]:=random(100);
{ted mame v poli ulozena nahodna cisla od 0 do 99}
writeln('naplneno.');
vypispole; {zobrazime ho}


{ted najdeme nejmensi prvek v poli a jeho pozici:}
write('Hledam nejmensi prvek... ');
nejmensiprvek:=pole[1];
indexnejmensiho:=1;
{pro zacatek za nejmensi prohlasime prvni prvek pole (jde to i s kterymkoli
jinym, prvni jsem vybral jen tak pro nazornost)}
for index:=1 to pocet do {pro kazdy prvek pole}
 if pole[index]<nejmensiprvek then begin {pokud narazime na mensi hodnotu nez jakou mame ulozenou...}
                                   nejmensiprvek:=pole[index];{...ulozime ji misto ni...}
                                   indexnejmensiho:=index;{...a zapamatujeme si, na ktere pozici byla}
                                   end;
{ted mame v promenne Nejmensiprvek ulozenu hodnotu nejmensiho prvku a v
promenne Indexnejmensiho jeho pozici}
writeln('hotovo.');
writeln('Nejmensi prvek ma hodnotu ',nejmensiprvek,' a nachazi se na ',indexnejmensiho,'. pozici.');
{Muze byt samozrejme nekolik stejnych nejmensich prvku, v takovem pripade se
najde ten prvni. Kdybychom znamenko "<" prepsali na "<=", nasel by se ten
posledni.}


{podobnym zpusobem najdeme nejvetsi prvek:}
write('Hledam nejvetsi prvek... ');
nejvetsiprvek:=pole[1];
indexnejvetsiho:=1;
for index:=1 to pocet do {pro kazdy prvek pole}
 if pole[index]>nejvetsiprvek then begin {pokud narazime na vetsi hodnotu nez jakou mame ulozenou...}
                                   nejvetsiprvek:=pole[index];{...ulozime ji misto ni...}
                                   indexnejvetsiho:=index;{...a zapamatujeme si, na ktere pozici byla}
                                   end;
writeln('hotovo.');
writeln('Nejvetsi prvek ma hodnotu ',nejvetsiprvek,' a nachazi se na ',indexnejvetsiho,'. pozici.');
{Opet - pokud je nejvetsich prvku vic, najde se ten prvni. Po prepsani ">"
na ">=" se najde posledni.}


{ted pole setridime podle velikosti prvku od nejmensiho po nejvetsi:}
write('Tridim pole... ');
 repeat
 presouvalose:=false;
 for index:=1 to pocet-1 do {pro kazdou dvojici prvku v poli}
  if pole[index]>pole[index+1] then begin {kdyz najdeme dva prvky v nespravnem poradi...}
                                    {...prohodime je:}
                                    pomocnapromenna:=pole[index];
                                    pole[index]:=pole[index+1];
                                    pole[index+1]:=pomocnapromenna;
                                    {a zapamatujeme si, ze jsme to udelali:}
                                    presouvalose:=true;
                                    end;
 until not presouvalose; {koncime ve chvili, kdy pri pruchodu polem nebylo
          treba nic presouvat, coz znamena, ze vsechno je ve spravnem poradi}
writeln('hotovo.');
{pole je setridene}
vypispole; {zobrazime ho}
{pro trideni od nejvetsiho do nejmensiho staci znamenko ">" prepsat na "<"}


writeln('Konec po stisknuti enteru.');
readln; {cekani na enter}
END.