Program Serad;
Uses Crt;
Const Pocet = 100;      {Delka pole}
      MaxHodnota = 100; {Maximalni hodnota, ktere muze nabyvat prvek}

Type TPole = array[1..Pocet] of Integer; {Je lepe vsechny pouzivane typy definovat v sekci Type}
Var  Hodnoty    : TPole;

Procedure Prohod(var PrA,PrB:Integer);
{Prohodi dve promenne, snad jiz netreba komentovat,
jen si rozmyslete, co se stane, pokud zavolate Prohod(A,A);}
Var PomProm : Integer; {Pomocna promenna}
Begin
 PomProm:=PrA;
 PrA:=PrB;
 PrB:=PomProm;
End;

Procedure Generuj(var Pole:TPole;Delka,Maximum:Integer);
{Procedura vyplni pole nahodnymi hodnotami}
Var I:Integer;
Begin
 Randomize;
 For I:=1 to Delka do
  Pole[I]:=Random(Maximum);
End;

Procedure Vypis(var Pole:TPole;Delka:Integer);
{Procedura vypise pole dane delky na obrazovku}
Var I:Integer;
Begin
 For I:=1 to Delka do
  Write(Pole[I]:4);
 Writeln;
End;

Procedure InsertSort(var Pole:TPole;DelkaPole:Integer);
{Procedura seradi pole hodnot typu Integer podle velikosti,
pouzije pritom metodu primeho vkladani - nejprve najde nejmensi a da ho na zacatek,
pak najde druhy nejmensi a da ho na druhe misto...,
at se neco naucime, zkusime vyuzit ukazatele}
Type PInteger = ^Integer;
Var Start,Kde:Integer; {Odkud zaciname s hledanim daneho prvku + kde prave pri hledani jsme}
    Ukazatel: PInteger; {Ted nam bude ukazovat na nejmensi prvek}
Begin
 Ukazatel:=nil;
 Start:=1;
 repeat
  Ukazatel:=@Pole[Start];
  for Kde:=Start+1 to DelkaPole do
   if Pole[Kde]<Ukazatel^ then Ukazatel:=@Pole[Kde];
  {Nyni ukazatel ukazuje na nejmensi prvek mezi Startem a DelkouPole,
  prvek pole na miste Start prohodime s prvkem, na ktery ukazuje ukazatel}
  Prohod(Pole[Start],Ukazatel^);
  Start:=Start+1;
 until Start>=DelkaPole;
End;

Begin {Vlastni telo programu, snad neni treba prilis komentovat}
 ClrScr;
 Generuj(Hodnoty,Pocet,Maxhodnota);
 Vypis(Hodnoty,Pocet);
 InsertSort(Hodnoty,Pocet);
 Vypis(Hodnoty,Pocet);
 Readln;
End.

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

Program VypocetFaktorialu;
Var N : Longint;
{Bohuzel i longint je maly, pro n = 17 jiz pretece!!!}
Function Faktorial(N:LongInt):Longint; {Integer je prilis maly, N nema s N z hlavniho programu nic spolecneho}
var I: Longint;
    Vysledek : Longint;
Begin
 {Nebudeme pouzivat rekurzi, ta je v tomhle pripade zbytecne pomala a
 zere pamet, dlouho trva, nez se v pameti najde misto pro novou fuknci,
 nez si ta vytvori sve vlastni promenne, nez se spusti vypocet, ...}
 Vysledek:=1;
 for I:=N downto 1 do
  Vysledek:=Vysledek*I;
 Faktorial:=Vysledek;
End;

Begin
 Write('Zadej cislo :');
 Readln(N);
 Writeln;
 Writeln(N,'! =',Faktorial(N));
 Readln;
End.

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

Program Prohod;
{Prohodi obsah dvou promennych bez vyuziti treti,
pro dany typ promenne musi byt definovan bitovy XOR}
{Z duvodu prehlednosti neni prohozeni realizovano v samostatne procedure.}
Var S1,S2 : Integer;
Begin
 Write('Zadej dve promenne :');
 Readln(S1,S2);

 S1:=S1 xor S2; {Prohodime pomoci bitovych operaci, obsah promenne nas nezajima}
 S2:=S1 xor S2; {Proverte si, ze to tak skutecne je!!!!}
 S1:=S1 xor S2;

 Writeln;
 Writeln('Zadal jsi :',S1,' , ',S2);
 Readln;
End.
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

Program JeToPrvocislo;
Var N:LongInt;

Function Prvocislo(N:Longint):Boolean;
{Funkce zjisti, zda je zadane cislo prvocislem,
jednoduse tak, ze se pokusi projit vsechny mozne delitele,
je to pomala, ale pro longint staci}
Var  I:Integer;
   Pom:Boolean;
Begin
 Pom:=True;
 if N<2 then Pom:=False;
 For I:=2 to Round(Sqrt(N)) do  {Proverime vsechna cisla az do odmocniny,
                                jestli nahodou dane cislo nedeli,
                                nenajdeme-li delitele, je cislo prvocislem,
                                protoze jiz zrejme jine delitele nema.
                                Round je pouzit protoze odmocnina z neceho
                                velkeho muze vyjit 189.999999
                                misto spravnych 190}
   if N mod I = 0 then
    begin
     Pom:=False;
     Break; {Nasli jsme nevlastniho delitele, neni treba dale proverovat,
            zadane cislo urcite neni prvocislem, tedy Breakem ukoncime for}
    end;
 Prvocislo:=Pom;
End;

Begin
 Write('Zadej cislo : ');
 Readln(N);
 Writeln;
 Write('Cislo ', N,' ');
 if Prvocislo(N) then Write('je') else Write('neni');
 Write(' prvocislem');
 Readln;
End.

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

Program NajdiDelitele;
Var a,b: Longint;

Function Delitel(a,b:LongInt):LongInt;
{Funkce najde nejvetsiho spolecneho delitele pomoci deliciho Euklidova algoritmu
je to o dost rychlejsi, nez prochazet vsechny mozne delitele}
Begin
 if (b=0) or (a=0) then
  begin
   Delitel:=a or b;
    {Pozn. Je-li a nebo b nula, znamena a or b to druhe, nenulove cislo, vite proc?
    Bohuzel nevime, jak jsou dana cisla reprezentovana v pameti pocitace, muze se
    stat, ze ne na vsech strojich to bude fungovat, radeji bychom se tomu meli vyhnout pomoci Delitel:=a+b;}
   Exit;{Nasli jsme nejvetsiho spolecneho delitele, proceduru muzeme ukoncit}
  end;
 if a > b then a:=a mod b else b:=b mod a; {Delitel obou cisel bude i delitelem zbytku po deleni}
 Delitel:=Delitel(a,b);
 {Nekde to skoncit musi}
End;

Begin
 Writeln('Zadej dve cisla :');
 Readln(a,b);
 writeln('D(',a,',',b,') = ',Delitel(a,b));
 Readln;
End.

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

Program NajdiNasobek;
Var a,b,I : Longint;

Function Delitel(a,b:LongInt):LongInt;
{Funkce najde nejvetsiho spolecneho delitele pomoci deliciho Euklidova algoritmu
je to o dost rychlejsi, nez prochazet vsechny mozne delitele}
Begin
 if (b=0) or (a=0) then {Takhle podminka jde sice napsat jako a*b=0, ale to vyzaduje nasobeni a to je pomale.}
  begin
   Delitel:=a + b;
   Exit;
  end;
 if a > b then a:=a mod b else b:=b mod a;
 Delitel:=Delitel(a,b);
End;

Function Nasobek(a,b:LongInt):Longint;
Begin
 Nasobek:= A div Delitel(a,b) * B; {Tenhle vztah plati a Delitel deli a.}
 {Prvne je deleni a az pak nasobeni, abychom snizili moznost, ze nam vysledek pretece}
End;

Begin
 Writeln('Zadej dve cisla :');
 Readln(a,b);
 writeln('n(',a,',',b,') = ',Nasobek(a,b));
 Readln;
End.

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

Program SetrideniSeznamu;
{Program vytvori jednostranne zretezeny seznam a seradi jmena podle abecedy 
Pro skonceni zadavani dat zadajte ENTER}
type PSeznam = ^TSeznam;
     TSeznam = record
                Jmeno : string;
                Dalsi : PSeznam;
               end;
var Seznam   : PSeznam;
    Prohozeni: LongInt; {Udava setridenost seznamu}

function Vytvor:PSeznam; {Vytvori dynamicky seznam, vrati ukazatel na nej}
var Prvni,Soucasny: PSeznam;
    ZJmeno: string;
begin
 New(Prvni); {Vytvorime novou dynamickou promennou, na kterou bude ukazovat Prvni}
 Soucasny:=Prvni; {Soucasny ukazuje tamtez}
 Soucasny^.Dalsi:=nil; {Nic dalsiho zatim neni}
 Soucasny^.Jmeno:='nikdo';
 {Tim bychom meli hotove jakesi drzadlo a muzeme zacit s tvorbou samotneho seznamu}
 repeat
  Write('Jmeno : ');
  Readln(ZJmeno);
  if ZJmeno <> '' then
   begin
    New(Soucasny^.Dalsi);      {Nova dynamicka promenna}
    Soucasny:=Soucasny^.Dalsi; {Ukazatel soucasny presmerujeme na ni}
    Soucasny^.Jmeno:=ZJmeno;
    Soucasny^.Dalsi:=nil;
   end;
 until ZJmeno='';
 Vytvor:=Prvni;
end;

function Setrid(Prvni:PSeznam):PSeznam;
{Setridi dynamicky seznam pomoci BubbleSortu,
tj. prohazuje dvojice, ktere jsou serazeny opacne,
neni to moc efektivni, ale pro demonstraci staci}
var Prohozeni:Longint; {Udava setridenost seznamu}
    Soucasny:PSeznam;
    ZJmeno:string;
begin
 repeat
  Prohozeni:=0;
  Soucasny:=Prvni^.Dalsi;
  if Soucasny <> nil then
   While Soucasny^.Dalsi<>nil do {Prohodi vsechny prehozene dvojice}
    Begin
     if Soucasny^.Jmeno > Soucasny^.Dalsi^.Jmeno then
      Begin
       ZJmeno:=Soucasny^.Jmeno; {Prohrazujeme pouze hodnoty, ne ukazatele!!!}
       Soucasny^.Jmeno:=Soucasny^.Dalsi^.Jmeno;
       Soucasny^.Dalsi^.Jmeno:=ZJmeno;
       Inc(Prohozeni);
      End;
     Soucasny:=Soucasny^.Dalsi;
    End;
 until Prohozeni=0; {Opakujeme, dokud se meni poradi prvku}
 Setrid:=Prvni;
End;

Procedure Vypis(Soucasny:PSeznam);
{Vypise seznam}
{Soucasny neni volan odkazem (tj. pomoci var), takze ho muzeme vesele menit,
aniz se to projevi ve zbytku programu, nepotrebujeme tedy dve pomocne promenne,
ale vystacime s jednou}
Begin {Vypis seznamu}
 Soucasny:=Soucasny^.Dalsi;
 While Soucasny<>nil do
  Begin
   Writeln(Soucasny^.Jmeno);
   Soucasny:=Soucasny^.Dalsi;
  End;
End;

Begin {Samotne telo programu snad komentar nepotrebuje}
 Seznam:=Vytvor;
 Seznam:=Setrid(Seznam);
 Vypis(Seznam);
 Readln;
End.

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

program Adresar;
{Program vytvori oboustranne zretezeny seznam kontaku,
je to jen ukazka, chybi podrobne informovani uzivatele o tom, co se prave
deje, graficky design je sileny, program neni moc uzivatelsky prijemny,
chybi vyhledavani, import/export kontaktu, v abeceda rozhoduji velka/mala
pismena... Nejsou osetreny pripady blbeho uzivatele - zadani neexistujiciho
jmena souboru, ulozeni prazdneho adresare...}

{Pro ukonceni zadavani dat zadejte prazdne jmeno}
type PSeznam = ^TSeznam;
     TData   = record
                    Jmeno : string[50];
		   Telefon: string[12];
		    Email : string[50];
		   end;
     TSeznam = record
                Data  : TData;
            Predchozi : PSeznam;
                Dalsi : PSeznam;
               end;
const UData : TData = (Jmeno:'nikdo';Telefon:'nema';Email:'zadny'); {Data hlavicky}
var Hlavicka,Soucasny : PSeznam;
    Seznam : TSeznam;
    ZData   : TData;
    r       : char;

procedure Inicializace; {Drzadlo}
begin
 New(Hlavicka);
 Hlavicka^.Dalsi:=Hlavicka;
 Hlavicka^.Predchozi:=Hlavicka;
 Hlavicka^.Data:=UData;
 Soucasny:=Hlavicka;
end;

procedure Zadej; {Vytvori kruhovy oboustranne zretezeny seznam}
begin
 repeat
 Write('Jmeno : ');
 Readln(ZData.Jmeno);
 if ZData.Jmeno <> '' then
  begin
   Write('Telefon : ');
   Readln(ZData.Telefon);
   Write('Email : ');
   Readln(ZData.Email);

   New(Soucasny^.Dalsi);
   Soucasny^.Dalsi^.Predchozi:=Soucasny;
   Soucasny:=Soucasny^.Dalsi;
   Soucasny^.Data:=ZData;
   Soucasny^.Dalsi:=Hlavicka;
   Writeln;
  end;
 until ZData.Jmeno='';
end;

procedure Vypis; {Vypise cely seznam}
var Zobrazeno : Byte; {Aby se vse veslo na obrazovku}
begin
 Zobrazeno:=0;
 Writeln('Cely seznam :');
 Soucasny:=Hlavicka;
 Writeln;

 repeat
 Inc(Zobrazeno);
 Soucasny:=Soucasny^.Dalsi;
 Writeln(Soucasny^.Data.Jmeno);
 Writeln('Telefon :',Soucasny^.Data.Telefon:12,'    Email : ',Soucasny^.Data.Email);
 Writeln; {Pro prehlednost}
 if Zobrazeno = 7 then
  begin
   Writeln;
   Writeln('Press ENTER to continue');
   Readln;
  end;
 until Soucasny^.Dalsi=Hlavicka;
 Writeln('To je vse - Press ENTER to continue');
 Readln;
end;

procedure Zmen; {Vypise vsechny prvky a zepta se na moznost zmeny}
var c:char;
begin
 Writeln('Cely seznam :');
 Soucasny:=Hlavicka;
 repeat
 Soucasny:=Soucasny^.Dalsi;
 Writeln(Soucasny^.Data.Jmeno,Soucasny^.Data.Telefon:15,Soucasny^.Data.Email:30, ' Zmenit(A/N):');
 Readln(c);
 c:=UpCase(c);
 if C='A' then
  begin
   Write('Nove jmeno :');
   Readln(ZData.Jmeno);
   Write('Novy telefon :');
   Readln(ZData.Telefon);
   Write('Novy email :');
   Readln(ZData.Email);
   Soucasny^.Data:=ZData;
  end;
 until Soucasny^.Dalsi=Hlavicka;
 Writeln('To je vse');
end;

procedure Odstran; {Odstrani vybrane prvky ze seznamu}
var Smaz:PSeznam;
    c   :char;
begin
 Writeln('Cely seznam :');
 Soucasny:=Hlavicka;
 repeat
 Soucasny:=Soucasny^.Dalsi;
 Writeln(Soucasny^.Data.Jmeno,Soucasny^.Data.Telefon:15,Soucasny^.Data.Email:30,' Odstranit(A/N)');
 Readln(c);
 c:=UpCase(c);
 if C='A' then
  begin
   Smaz:=Soucasny;
   Soucasny^.Predchozi^.Dalsi:=Soucasny^.Dalsi;
   Smaz^.Dalsi^.Predchozi:=Smaz^.Predchozi;
   Soucasny:=Smaz^.Predchozi;
   Dispose(Smaz); {Mazeme az ted!!}
  end;
  until Soucasny^.Dalsi=Hlavicka;
 Writeln('To je vse');
end;

procedure Pridej; {Prida novy prvke}
var Novy:PSeznam;
    c   :char;
begin
 Writeln('Cely seznam :');
 Soucasny:=Hlavicka;
 repeat
 Soucasny:=Soucasny^.Dalsi;
 Writeln(Soucasny^.Data.Jmeno:20,Soucasny^.Data.Telefon:15,Soucasny^.Data.Email,' Pridat pred(A/N)');
 Readln(c);
 c:=UpCase(c);
 if C='A' then
  begin
   Write('Nove jmeno : ');
   Readln(ZData.Jmeno);
   Write('telefon : ');
   Readln(ZData.telefon);
   Write('email : ');
   Readln(ZData.Email);
   New(Novy);
   Novy^.Data:=ZData;

   Novy^.Dalsi:=Soucasny;
   Novy^.Predchozi:=Soucasny^.Predchozi;
   Soucasny^.Predchozi:=Novy;
   Novy^.Predchozi^.Dalsi:=Novy; {To jsou snad cary, ale je to tak, ukazatele ted sedi}

  end;
  until Soucasny^.Dalsi=Hlavicka;
 Writeln('To je vse');
end;

procedure Serad; {Seradi data podle abecedy}
var Zmen : LongInt; {Pocet dvojic prehozenych pri jednom pruchodu}
    Konec: Boolean;
begin
 Zmen:=0;
 Soucasny:=Hlavicka;
 repeat
 if Konec then
  begin
   Zmen:=0;
   Konec:=false;
  end;
 Konec:=Soucasny^.Dalsi=Hlavicka;
 if (Soucasny=Hlavicka) or (Soucasny^.Dalsi=Hlavicka) then {if then else lze takto pouzit}
  else
   if Soucasny^.Data.Jmeno > Soucasny^.Dalsi^.Data.Jmeno then
   Begin
    Inc(Zmen);
    Zdata:=Soucasny^.Data;
    Soucasny^.Data:=Soucasny^.Dalsi^.Data;
    Soucasny^.Dalsi^.Data:=ZData;
   End;
 Soucasny:=Soucasny^.Dalsi;
 until Konec and (Zmen=0);
end;

procedure Nahraj; {Nacte oboustranne zretezeny seznam}
var JmenoSouboru : string;
    fData        : Text;
begin
 Write('Nacist ze souboru (udavejte bez pripony) : ');
 Readln(JmenoSouboru);
 JmenoSouboru:=JmenoSouboru+'.adr';
 Assign(fData,JmenoSouboru);
 Reset(fData);
 repeat
  New(Soucasny^.Dalsi);
  Readln(fData,Soucasny^.Dalsi^.Data.Jmeno);
  Readln(fData,Soucasny^.Dalsi^.Data.Telefon);
  Readln(fData,Soucasny^.Dalsi^.Data.Email);
  Readln(fData); {V souboru je prazdny radek kvuli prehlednosti}
  Soucasny^.Dalsi^.Predchozi:=Soucasny;
  Soucasny:=Soucasny^.Dalsi;
  Soucasny^.Dalsi:=Hlavicka;
 until Eof(fData);
 Close(fData);
end;

procedure Uloz; {Ulozi oboustranne zretezeny seznam}
var JmenoSouboru : string;
    fData        : Text;
begin
 Write('Ulozit do souboru (jmeno udavejte bez pripony) : ');
 Readln(JmenoSouboru);
 JmenoSouboru:=JmenoSouboru+'.adr';
 Assign(fData,JmenoSouboru);
 Rewrite(fData);
 Soucasny:=Hlavicka;
 repeat
  Soucasny:=Soucasny^.Dalsi;
  Writeln(fData,Soucasny^.Data.Jmeno);
  Writeln(fData,Soucasny^.Data.Telefon);
  Writeln(fData,Soucasny^.Data.Email);
  Writeln(fData);{Prazdny radek kvuli prehlednosti}
 until Soucasny^.Dalsi=Hlavicka;
 Close(fData); {Jinak by se soubor neulozil na disk}
end;


begin                   {A jako obvykle pri dobrem navrhu, samotne telo
                        nepotrebuje moc komentaru}
 Inicializace;
 repeat
 writeln('Co chcete delat : ');
 writeln;
 writeln('V - Vytvorit novy adresar');
 writeln('Z - Zobrazit seznam');
 writeln('O - Opravit udaje');
 writeln('S - Smazat nektera data');
 writeln('P - Pridat nove prvky');
 writeln('E - Seradit podle abecedy');
 writeln('N - Nahrat ze souboru');
 writeln('U - Ulozit do souboru');
 writeln('K - Koncit');
 Readln(R);
 R:=UpCase(R);
 case R of
  'V': Zadej;
  'Z': Vypis;
  'O': Zmen;
  'S': Odstran;
  'P': Pridej;
  'E': Serad;
  'N': Nahraj;
  'U': Uloz;
 end;
 until R='K';
end.

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

Program ZkouskaZMatiky;
const PocetPrikladu = 20;
var PocetChyb   : Integer;
    T,A,B,V,Z,I : Integer; {Typ prikladu,a,b, vysledek, zadani - zde vidite ukazku chybne pojmenovych promennych...}
    {Na vysvetleni jejich vyznamu je zapotrebi pouzit komentaru!!!}
Begin
 Randomize;
 for I:=1 to PocetPrikladu do
  begin
   T:=Random(4);
   case T of
   0: begin
       A:=Random(100);
       B:=Random(200)-100;
       Write(A);
       if B < 0 then Write(' - ',-B,' = ') else Write(' + ',B,' = ');
       V:=A+B;
      end;
   1: begin
       A:=Random(10);
       B:=Random(10);
       V:=A*B;
       Write(A,' * ',B,' = ');
      end;
   2: begin
       V:=Random(10);
       B:=Random(10);
       if B=0 then Inc(B); {Nulou nelze delit}
       A:=V*B;
       Write(A,' / ',B,' = ');
      end;
   3: begin
       A:=Random(20);
       B:=2;
       V:=A*A;
       Write(A,' ^ 2 = '); {Umocnovani na druhou}
      end;
  end;
  Readln(Z);
  if Z<>V then
   Begin
    Writeln('Chyba, je to : ',V);
    Inc(PocetChyb);
   End
  else
   Writeln('Spravne'); {Neskodilo by hlasky trochu obmenovat}
 end;
 Writeln;
 Writeln('Pocet prikladu  : ',PocetPrikladu);
 Writeln('Pocet chyb      : ',PocetChyb);
 PocetChyb:=(PocetChyb * 5) div PocetPrikladu+1; {Snad je to dobre, nebyl cas testovat}
 if PocetChyb > 5 then PocetChyb:=5;
 Writeln;
 Writeln('Vysledna znamka : ',PocetChyb);
 Readln;
End.

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

Program Hra21;
{Pocitac si s vami zahraje hru 21, samozrejme vzdy vyhraje}
Const MaxOdeber = 3;
      PocetKol  = 5;
      PocetSirek:integer = PocetKol*MaxOdeber + PocetKol +1;
Var Odeber : 1..3;
Begin
 Randomize;
 Repeat {Ale muze byt i for, takovy je tahle hra podfuk}
  Writeln('Pocet zbyvajicich sirek : ',PocetSirek);
  Write('Kolik odeberes? ');
  Readln(Odeber);                              {Odeber je typu 1..3 takze pokud bude chtit uzivatel svindlovat, program spadne :) }
  if (Odeber < 1) or (Odeber > MaxOdeber) then
   begin
    Odeber:=Random(MaxOdeber)+1;
    Writeln('To je podvod. Odeberes : ',Odeber);
   end;
  Writeln('Ja odeberu ',MaxOdeber-Odeber+1);  {Pocet dohromady odebranych sirek je vzdy MaxOdber+1}
  Writeln;
  PocetSirek:=PocetSirek-(MaxOdeber+1);
  {Pocitac odebira tak, aby pocet dohromady odebranych sirek byl vzdy stejny,
  takze vzdy vyhraje}
 Until PocetSirek=1;
 Writeln('Zbyva posledni sirka. Prohral jsi!');
 Readln;
End.
