{Pristupu k programovani je cela rada, zde vam nektere z nich ukazu.
Sami si vyberte styl, ktery vam bude vyhovovat nejvic.}

Program Trojuhelniky;
{Program zjisti vzajemnou pozici dvou trojuhelniku,
pro ukazku pouzito objektu, i kdyz v tomhle pripade
neni jejich vyuziti zrovna smysluplne, bez nich
by to bylo kratsi a slo by to napsat i trosku prehledneji}

{Je take zvlastni, ze kdyz tvorime usecku, predpokladame, ze
jiz mame dane dva body a jenom je spojime,
kdezto u trojuhelniku se rozhodneme: budiz trojuhelnik a body
dodame az pak, takova trosku schizofrenie,
asi by bylo lepsi mit k Zadej jeste metodu Importuj}


Const Zacatek='A';
      Konec = 'C'; {standardni pojmenovani vrcholu trojuhelnika}
      Hranice = 0.00001; {Rozlisovaci schopnosti pocitace}

Type TPopis = string[3];
     TNazvy = Zacatek..Konec;
     TKde   = -1..1;

     PVrchol = ^TVrchol; {Plati zlate pravidlo, ze k objektu bychom meli
                         pristupovat pouze pres ukazatele}
     TVrchol = object    {Bod je objekt, ktery bude casti trojuhelniku, ci usecky}
                jmeno:TPopis; {Jmeno daneho bodu}
                X:Real;
                Y:Real;
                constructor Init(nazev:TPopis);

                procedure Zadej;
                function Vypis(presnost,desetinnych:integer):string;

                function GetName:TPopis;
                function GetX:Real;
                function GetY:Real;

                destructor Done;
               end;

     PUsecka = ^TUsecka;
     TKonce = array[1..2] of PVrchol;
     TUsecka = object
                vrcholy: TKonce;
                constructor Init(A,B:PVrchol);
                function Delka:Real;
                function IsLeft(Point:PVrchol):TKde;
                destructor Done;
               end;


     TVrcholy = array[TNazvy] of PVrchol;  {Trojuhelnik se sklada ze tri vrcholu}
     TStrany = array[TNazvy] of PUsecka;   {A ze tri stran}
     PTrojuhelnik =^TTrojuhelnik;
     TTrojuhelnik = object
                jmeno:string;
                vrcholy:TVrcholy;
                strany:TStrany;
                constructor Init(nazev:string);

                procedure Zadej;
                function Vypis(presnost,desetinnych:integer):string;

                function GetName:string;
                function GetPoint(nazev:Tnazvy):PVrchol;

                function IsOk:Boolean;
                function IsIn(Point:Pvrchol):Boolean;

                destructor Done;
               end;


{Nejprve napiseme metody tridy TVrchol}
constructor TVrchol.Init(nazev:TPopis);
{I kdyz staci uvadet zkracene hlavicky,
mnohem lepe se v tom vyzname, pokud je opiseme cele}
begin
 jmeno:=nazev;
 x:=0;
 y:=0;
end;

procedure TVrchol.Zadej;
begin
 Write('Zadejte x-ovou souradnici vrcholu ',jmeno, ': ');
 Readln(X);
 Write('Zadejte y-ovou souradnici vrcholu ',jmeno, ': ');
 Readln(Y);
end;

function TVrchol.Vypis(presnost,desetinnych:integer):string;
var s:string;
    c:string;
begin
 s:=jmeno + '[';
 Str(X:presnost:desetinnych,c);
 s:=s+c+',';
 Str(Y:presnost:desetinnych,c);
 s:=s+c+']';
 Vypis:=s;
end;

function TVrchol.GetName:TPopis;
begin
 GetName:=jmeno;
end;

function TVrchol.GetX:Real;
begin
 GetX:=X;
end;

function TVrchol.GetY:Real;
begin
 GetY:=Y;
end;

destructor TVrchol.Done;
{Kazdy objekt by mel mit destructor, i kdyz nic nedela}
begin
end;

{Metody tridy TUsecka}
constructor TUsecka.Init(A,B:PVrchol);
begin
 vrcholy[1]:=A; {Tady misto pro promenne nealokujeme, tudiz je nesmime v destructoru nicit}
 vrcholy[2]:=B;
end;

function TUsecka.IsLeft(Point:PVrchol):TKde;
{Zjisti, zda je zadany bod "vlevo" od usecky}
var c: Real;
begin
 if (vrcholy[1]^.GetX-vrcholy[2]^.GetX<>0) then
    c:=Point^.GetY-
          ((vrcholy[1]^.GetY-vrcholy[2]^.GetY)/(vrcholy[1]^.GetX-vrcholy[2]^.GetX)*
          (Point^.GetX-vrcholy[1]^.GetX)+vrcholy[1]^.GetY)
 else
  c:=Point^.GetX-Vrcholy[1]^.GetX;

 if c>0 then IsLeft:=1;
 if c<0 then IsLeft:=-1;
 if Abs(c)<Hranice then IsLeft:=0; {Realna cisla nikdy nesrovnavame pomoci =}

end;

function TUsecka.Delka;
var X,Y:Real;
begin
 X:=vrcholy[1]^.GetX - vrcholy[2]^.GetX;
 Y:=vrcholy[1]^.GetY - vrcholy[2]^.GetY;
 Delka:=Sqrt(sqr(X)+sqr(Y)); {Delku usecky vypocteme pomoci pythagorovy vety}
end;

destructor TUsecka.Done;
begin
end;


{Metody tridy TTrojuhelnik}
constructor TTrojuhelnik.Init(nazev:string);
var c:char;
begin
 jmeno:=nazev;
 for c:=Zacatek to Konec do vrcholy[c]:=nil;
end;

procedure TTrojuhelnik.Zadej;
var c:char;
begin
 for c:=Zacatek to Konec do
  begin
   new(vrcholy[c],Init(c+jmeno)); {Bacha tady zabirame pamet, musime ji v destructoru uvolnit}
   vrcholy[c]^.zadej;
   writeln;
  end;

 new(strany['A'],Init(vrcholy['B'],vrcholy['C']));
 new(strany['B'],Init(vrcholy['A'],vrcholy['C']));
 new(strany['C'],Init(vrcholy['C'],vrcholy['B']));
 {tohle teke musime uvolnit}
 {bohuzel tuhle cast bychom museli mirne prepsat, pokud chceme, at
 jsou konstanty Zacatek a Konec pouzitelne}
end;

function TTrojuhelnik.Vypis(presnost,desetinnych:integer):string;
var c:char;
    s:string;
begin
 s:=jmeno+': ';
 for c:=Zacatek to Konec do
  s:=s+vrcholy[c]^.vypis(presnost,desetinnych)+'; ';
 Vypis:=s;
end;

function TTrojuhelnik.GetName:string;
begin
 GetName:=jmeno;
end;

function TTrojuhelnik.GetPoint(nazev:TNazvy):PVrchol;
begin
 GetPoint:=vrcholy[nazev];
end;

function TTrojuhelnik.IsOk:Boolean;
var a,b,c:Real;
begin
 IsOk:=strany[Zacatek]^.IsLeft(vrcholy[Zacatek])<>0;
end;

function TTrojuhelnik.IsIn(Point:PVrchol):Boolean;
{Zjisti, zda je dany bod uvnitr trojuhelnika,
vyuziva pritom faktu, ze trojuhelnik je prunik
tri polorovin zadanych hranicni primkou a zbylym
vrcholem trojuhelnika}
var pom:Boolean;
    c  : TNazvy;
begin
 pom:=True;
 for c:=Zacatek to Konec do
  pom:=pom and (strany[c]^.IsLeft(vrcholy[c])*strany[c]^.IsLeft(Point)>=0);
 IsIn:=pom;
end;


destructor TTrojuhelnik.Done;
var c:char;
begin
 jmeno:='';
 for c:=Zacatek to Konec do
  begin
   Dispose(vrcholy[c],Done);
   Dispose(strany[c],Done);
  end;
  {Pri niceni objektu pomoci dispose nikdy nezapomeneme volat destructor
  niceneho objektu, jinak se muze stat, ze sice zrusime ukazatel na
  gigovy seznam, ale ten nam bude dal zabirat pamet}
end;

Var A,B:PTrojuhelnik;

function Pozice(A,B:PTrojuhelnik):string;
{Zjisti, vzajemnou pozici trojuhelniku}
var c:TNazvy;
    BinA:Boolean;
    partBinA:Boolean;
    AinB:Boolean;
    partAinB:Boolean;
    t:Boolean;
    s:string;
begin
 if not (A^.IsOk and B^.IsOk) then
 begin
  if A^.IsOk then s:=B^.GetName+ ' neni trojuhelnik, ale usecka.'
  else s:=A^.GetName+ ' neni trojuhelnik, ale usecka.';
  Pozice:=s+#10+#13+'Nemuzu urcit pozici trojuhelniku.';
  Exit;
 end;

 BinA:=True;
 partBinA:=false;
 for c:=Zacatek to Konec do
  begin
   t:=(A^.IsIn(B^.GetPoint(c)));
   BinA:=BinA and t;
   partBinA:=partBinA or t;
  end;

 AinB:=True;
 partAinB:=False;
 for c:=Zacatek to Konec do
  begin
   t:=(B^.IsIn(A^.GetPoint(c)));
   AinB:=AinB and t;
   partAinB:=partAinB or t;
  end;

if (AinB) then
   begin
    if (BinA) then s:='Trojuhelniky '+A^.GetName+' a '+B^.GetName+' jsou identicke.'
    else
    s:='Trojuhelnik '+A^.GetName+ ' je obsazen v trojuhelniku '+B^.GetName;
   end
   else
   if BinA then s:='Trojuhelnik '+B^.GetName+ ' je obsazen v trojuhelniku '+B^.GetName
   else
   if partBinA then s:='Trojuhelniky '+A^.GetName+' a '+B^.GetName+' se protinaji.'
   else
   if partAinB then s:='Trojuhelniky '+A^.GetName+' a '+B^.GetName+' se protinaji.'
   else s:='Trojuhelniky '+A^.GetName+' a '+B^.GetName+' nemaji spolecny bod.';
   Pozice:=s;
end;

Begin
 New(A,Init('1'));
 A^.Zadej;

 New(B,Init('2'));
 B^.Zadej;

 writeln(Pozice(A,B));

 Dispose(A,Done);
 Dispose(B,Done);
 readln;
End.
*****************************************************************************
Program Trojuhelniky;
{Jde to napsat i takhle.}
{Male cvicenicko na hledani chyb:Napsal jsem blbe zavorku, najdete ji?}
var a,b,c,d,e,f,g,h,i,j,k,l:Real;

procedure Hodnot; {Takhle napsane to zabira tolik pameti,
ze tech par bitu, ktere jsme usetrili tim, ze nemame
zadne pomocne promenn, je uplne nanic}
label konec;
begin
 if (((f-((b-d)/(a-c)*(e-a)+b))*(h-((b-d)/(a-c)*(g-a)+b))>=0)and
 ((b-((d-f)/(c-e)*(a-c)+d))*(h-((d-f)/(c-e)*(g-c)+d))>=0)and
 ((d-((f-b)/(e-a)*(c-e)+f))*(h-((f-b)/(e-a)*(g-a)+d))>=0)) and (((f-((b-d)/(a-c)*(e-a)+b))*(j-((b-d)/(a-c)*(i-a)+b))>=0)and
 ((b-((d-f)/(c-e)*(a-c)+d))*(j-((d-f)/(c-e)*(i-c)+d))>=0)and
 ((d-((f-b)/(e-a)*(c-e)+f))*(j-((f-b)/(e-a)*(i-a)+d))>=0)) and (((f-((b-d)/(a-c)*(e-a)+b))*(l-((b-d)/(a-c)*(k-a)+b))>=0)and
 ((b-((d-f)/(c-e)*(a-c)+d))*(l-((d-f)/(c-e)*(k-c)+d))>=0)and
 ((d-((f-b)/(e-a)*(c-e)+f))*(l-((f-b)/(e-a)*(k-a)+d))>=0)) and (((l-((h-j)/(g-i)*(k-g)+h))*(b-((h-j)/(g-i)*(a-g)+h))>=0)and
 ((h-((j-l)/(i-k)*(g-i)+j))*(b-((j-l)/(i-k)*(a-i)+j))>=0)and
 ((j-((l-h)/(k-g)*(i-k)+l))*(b-((l-h)/(k-g)*(a-g)+j))>=0)) and (((l-((h-j)/(g-i)*(k-g)+h))*(d-((h-j)/(g-i)*(c-g)+h))>=0)and
 ((h-((j-l)/(i-k)*(g-i)+j))*(d-((j-l)/(i-k)*(c-i)+j))>=0)and
 ((j-((l-h)/(k-g)*(i-k)+l))*(d-((l-h)/(k-g)*(c-g)+j))>=0)) and (((l-((h-j)/(g-i)*(k-g)+h))*(f-((h-j)/(g-i)*(e-g)+h))>=0)and
 ((h-((j-l)/(i-k)*(g-i)+j))*(f-((j-l)/(i-k)*(e-i)+j))>=0)and
 ((j-((l-h)/(k-g)*(i-k)+l))*(f-((l-h)/(k-g)*(e-g)+j))>=0)) then begin writeln('Identicke');goto konec;end;

 if ((((f-((b-d)/(a-c)*(e-a)+b))*(h-((b-d)/(a-c)*(g-a)+b))>=0)and
 ((b-((d-f)/(c-e)*(a-c)+d))*(h-((d-f)/(c-e)*(g-c)+d))>=0)and
 ((d-((f-b)/(e-a)*(c-e)+f))*(h-((f-b)/(e-a)*(g-a)+d))>=0)) and (((f-((b-d)/(a-c)*(e-a)+b))*(j-((b-d)/(a-c)*(i-a)+b))>=0)and
 ((b-((d-f)/(c-e)*(a-c)+d))*(j-((d-f)/(c-e)*(i-c)+d))>=0)and
 ((d-((f-b)/(e-a)*(c-e)+f))*(j-((f-b)/(e-a)*(i-a)+d))>=0)) and (((f-((b-d)/(a-c)*(e-a)+b))*(l-((b-d)/(a-c)*(k-a)+b))>=0)and
 ((b-((d-f)/(c-e)*(a-c)+d))*(l-((d-f)/(c-e)*(k-c)+d))>=0)and
 ((d-((f-b)/(e-a)*(c-e)+f))*(l-((f-b)/(e-a)*(k-a)+d))>=0))) and not((((l-((h-j)/(g-i)*(k-g)+h))*(b-((h-j)/(g-i)*(a-g)+h))>=0)
 and((h-((j-l)/(i-k)*(g-i)+j))*(b-((j-l)/(i-k)*(a-i)+j))>=0)and
 ((j-((l-h)/(k-g)*(i-k)+l))*(b-((l-h)/(k-g)*(a-g)+j))>=0))and (((l-((h-j)/(g-i)*(k-g)+h))*(d-((h-j)/(g-i)*(c-g)+h))>=0)and
 ((h-((j-l)/(i-k)*(g-i)+j))*(d-((j-l)/(i-k)*(c-i)+j))>=0)and
 ((j-((l-h)/(k-g)*(i-k)+l))*(d-((l-h)/(k-g)*(c-g)+j))>=0)) and (((l-((h-j)/(g-i)*(k-g)+h))*(f-((h-j)/(g-i)*(e-g)+h))>=0)and
 ((h-((j-l)/(i-k)*(g-i)+j))*(f-((j-l)/(i-k)*(e-i)+j))>=0)and
 ((j-((l-h)/(k-g)*(i-k)+l))*(f-((l-h)/(k-g)*(e-g)+j))>=0))) then begin writeln('1. ve 2.');goto konec;end;

 if not((((f-((b-d)/(a-c)*(e-a)+b))*(h-((b-d)/(a-c)*(g-a)+b))>=0)and
 ((b-((d-f)/(c-e)*(a-c)+d))*(h-((d-f)/(c-e)*(g-c)+d))>=0)and
 ((d-((f-b)/(e-a)*(c-e)+f))*(h-((f-b)/(e-a)*(g-a)+d))>=0)) and (((f-((b-d)/(a-c)*(e-a)+b))*(j-((b-d)/(a-c)*(i-a)+b))>=0)and
 ((b-((d-f)/(c-e)*(a-c)+d))*(j-((d-f)/(c-e)*(i-c)+d))>=0)and
 ((d-((f-b)/(e-a)*(c-e)+f))*(j-((f-b)/(e-a)*(i-a)+d))>=0)) and (((f-((b-d)/(a-c)*(e-a)+b))*(l-((b-d)/(a-c)*(k-a)+b))>=0)and
 ((b-((d-f)/(c-e)*(a-c)+d))*(l-((d-f)/(c-e)*(k-c)+d))>=0)and
 ((d-((f-b)/(e-a)*(c-e)+f))*(l-((f-b)/(e-a)*(k-a)+d))>=0))) and ((((l-((h-j)/(g-i)*(k-g)+h))*(b-((h-j)/(g-i)*(a-g)+h))>=0)and
 ((h-((j-l)/(i-k)*(g-i)+j))*(b-((j-l)/(i-k)*(a-i)+j))>=0)and
 ((j-((l-h)/(k-g)*(i-k)+l))*(b-((l-h)/(k-g)*(a-g)+j))>=0)) and (((l-((h-j)/(g-i)*(k-g)+h))*(d-((h-j)/(g-i)*(c-g)+h))>=0)and
 ((h-((j-l)/(i-k)*(g-i)+j))*(d-((j-l)/(i-k)*(c-i)+j))>=0)and
 ((j-((l-h)/(k-g)*(i-k)+l))*(d-((l-h)/(k-g)*(c-g)+j))>=0)) and (((l-((h-j)/(g-i)*(k-g)+h))*(f-((h-j)/(g-i)*(e-g)+h))>=0)and
 ((h-((j-l)/(i-k)*(g-i)+j))*(f-((j-l)/(i-k)*(e-i)+j))>=0)and
 ((j-((l-h)/(k-g)*(i-k)+l))*(f-((l-h)/(k-g)*(e-g)+j))>=0))) then begin writeln('2. v 1.');goto konec;end;

 if (((f-((b-d)/(a-c)*(e-a)+b))*(h-((b-d)/(a-c)*(g-a)+b))>=0)and((b-((d-f)/(c-e)*(a-c)+d))*(h-((d-f)/(c-e)*(g-c)+d))>=0)and
 ((d-((f-b)/(e-a)*(c-e)+f))*(h-((f-b)/(e-a)*(g-a)+d))>=0))or(((f-((b-d)/(a-c)*(e-a)+b))*(j-((b-d)/(a-c)*(i-a)+b))>=0)and
 ((b-((d-f)/(c-e)*(a-c)+d))*(j-((d-f)/(c-e)*(i-c)+d))>=0)and((d-((f-b)/(e-a)*(c-e)+f))*(j-((f-b)/(e-a)*(i-a)+d))>=0))or
 (((f-((b-d)/(a-c)*(e-a)+b))*(l-((b-d)/(a-c)*(k-a)+b))>=0)and((b-((d-f)/(c-e)*(a-c)+d))*(l-((d-f)/(c-e)*(k-c)+d))>=0)and
 ((d-((f-b)/(e-a)*(c-e)+f))*(l-((f-b)/(e-a)*(k-a)+d))>=0))or(((l-((h-j)/(g-i)*(k-g)+h))*(b-((h-j)/(g-i)*(a-g)+h))>=0)and
 ((h-((j-l)/(i-k)*(g-i)+j))*(b-((j-l)/(i-k)*(a-i)+j))>=0)and((j-((l-h)/(k-g)*(i-k)+l))*(b-((l-h)/(k-g)*(a-g)+j))>=0))or
 (((l-((h-j)/(g-i)*(k-g)+h))*(d-((h-j)/(g-i)*(c-g)+h))>=0)and((h-((j-l)/(i-k)*(g-i)+j))*(d-((j-l)/(i-k)*(c-i)+j))>=0)and
 ((j-((l-h)/(k-g)*(i-k)+l))*(d-((l-h)/(k-g)*(c-g)+j))>=0))or(((l-((h-j)/(g-i)*(k-g)+h))*(f-((h-j)/(g-i)*(e-g)+h))>=0)and
 ((h-((j-l)/(i-k)*(g-i)+j))*(f-((j-l)/(i-k)*(e-i)+j))>=0)and((j-((l-h)/(k-g)*(i-k)+l))*(f-((l-h)/(k-g)*(e-g)+j))>=0)) then
 begin writeln('Protinaji se');goto konec;end;
 writeln('Nemaji spolecny zadny bod');
 konec:
end;

begin
 Writeln('Dva vrcholy trojuhelnika nesmi mit stejnou x-ovou souradnici');
            {Proste prasarna}
 Write('Zadej x,y 1.vrcholu 1.trojuhelnika:');
 Readln(a,b);
 Write('Zadej x,y 2.vrcholu 1.trojuhelnika:');
 Readln(c,d);
 Write('Zadej x,y 3.vrcholu 1.trojuhelnika:');
 Readln(e,f);

 Write('Zadej x,y 1.vrcholu 2.trojuhelnika:');
 Readln(g,h);
 Write('Zadej x,y 2.vrcholu 2.trojuhelnika:');
 Readln(i,j);
 Write('Zadej x,y 3.vrcholu 2.trojuhelnika:');
 Readln(k,l);
 Hodnot;
 Readln;
end.
*****************************************************************************
{Tohle je ten samy program prepsany s pouzitim pomocnych promennych
a par komentaru, prehlednost vzrostla milionkrat, ale u normalniho
programu by mela byt o hodne lepsi}
Program Trojuhelniky;
{Program zjisti vzajemnou pozici dvou trojuhelniku}

label konec;
var a,b,c,d,e,f,g,h,i,j,k,l:Real; {Souradnice vrcholu}
    AIn,BIn,CIn,DIn,EIn,FIn:Boolean; {Pomocne promenne}

begin
 Writeln('Z algoritmickych duvodu nesmi zadne dva vrcholy trojuhelnika '+
            'mit stejnou x-ovou souradnici, kdyztak ji u jednoho z nich '+
            'malinko soupnete - treba o 0.001');
            {Tohle si ma osetrit programator sam! A navic nejakym inteligentnejsim
            zpusobem}
 Write('Zadej x,y souradnice 1.vrcholu 1.trojuhelnika:');
 Readln(a,b);
 Write('Zadej x,y souradnice 2.vrcholu 1.trojuhelnika:');
 Readln(c,d);
 Write('Zadej x,y souradnice 3.vrcholu 1.trojuhelnika:');
 Readln(e,f);

 Write('Zadej x,y souradnice 1.vrcholu 2.trojuhelnika:');
 Readln(g,h);
 Write('Zadej x,y souradnice 2.vrcholu 2.trojuhelnika:');
 Readln(i,j);
 Write('Zadej x,y souradnice 3.vrcholu 2.trojuhelnika:');
 Readln(k,l);

 AIn:=
 ((f-((b-d)/(a-c)*(e-a)+b))*(h-((b-d)/(a-c)*(g-a)+b))>=0)and
 ((b-((d-f)/(c-e)*(a-c)+d))*(h-((d-f)/(c-e)*(g-c)+d))>=0)and
 ((d-((f-b)/(e-a)*(c-e)+f))*(h-((f-b)/(e-a)*(g-a)+d))>=0);
 {ta prvni radka znamena, ze dosadime
 do rovnice primky prochazejici bodem [a,b] a [c,d] cisla e a g a
 vysledek odecteme od y-ove souradnice bodu [e,f] ci [g,h],
 vyjde-li kladne cislo, lezi bod nad primkou, vyjde-li zaporne je pod ni.
 Pokud oba body lezi ve stejne polorovine je dany soucin nezaporny,
 vsechny tri radky pak znamenaji, ze bod [g,h] lezi ve vsech polorovinach
 ktere urcuji dany trojuhelnik, tudiz lezi uvnitr daneho trojuhelnika,
 dale jiz jen opakujeme stejny postup}

 BIn:= ((f-((b-d)/(a-c)*(e-a)+b))*(j-((b-d)/(a-c)*(i-a)+b))>=0)and
 ((b-((d-f)/(c-e)*(a-c)+d))*(j-((d-f)/(c-e)*(i-c)+d))>=0)and
 ((d-((f-b)/(e-a)*(c-e)+f))*(j-((f-b)/(e-a)*(i-a)+d))>=0);

 CIn:= ((f-((b-d)/(a-c)*(e-a)+b))*(l-((b-d)/(a-c)*(k-a)+b))>=0)and
 ((b-((d-f)/(c-e)*(a-c)+d))*(l-((d-f)/(c-e)*(k-c)+d))>=0)and
 ((d-((f-b)/(e-a)*(c-e)+f))*(l-((f-b)/(e-a)*(k-a)+d))>=0);


 DIn:= ((l-((h-j)/(g-i)*(k-g)+h))*(b-((h-j)/(g-i)*(a-g)+h))>=0)and
 ((h-((j-l)/(i-k)*(g-i)+j))*(b-((j-l)/(i-k)*(a-i)+j))>=0)and
 ((j-((l-h)/(k-g)*(i-k)+l))*(b-((l-h)/(k-g)*(a-g)+j))>=0);

 EIn:=((l-((h-j)/(g-i)*(k-g)+h))*(d-((h-j)/(g-i)*(c-g)+h))>=0)and
 ((h-((j-l)/(i-k)*(g-i)+j))*(d-((j-l)/(i-k)*(c-i)+j))>=0)and
 ((j-((l-h)/(k-g)*(i-k)+l))*(d-((l-h)/(k-g)*(c-g)+j))>=0);

 FIn:=((l-((h-j)/(g-i)*(k-g)+h))*(f-((h-j)/(g-i)*(e-g)+h))>=0)and
 ((h-((j-l)/(i-k)*(g-i)+j))*(f-((j-l)/(i-k)*(e-i)+j))>=0)and
 ((j-((l-h)/(k-g)*(i-k)+l))*(f-((l-h)/(k-g)*(e-g)+j))>=0);

 if AIn and BIn and CIn and DIn and EIn and FIn then begin writeln('Jsou identicke');goto konec;end;
 if (AIn and BIn and CIn) and not(DIn and EIn and FIn) then begin writeln('1. je ve 2.');goto konec;end;
 if not(AIn and BIn and CIn) and (DIn and EIn and FIn) then begin writeln('2. je v 1.');goto konec;end;

 if AIn or BIn or CIn or DIn or EIn or FIn then begin writeln('Trojuhelniky se protinaji');goto konec;end;
 writeln('Nemaji spolecny zadny bod');

 konec:
 Readln;
end.
*****************************************************************************

program abeceda;
{Vypise vsechny permutace prvnich n pismen abecedy}
type tpouzito=set of char; {seznam pouzitych pismen}
     tvysledek=array['a'..'z'] of 'a'..'z';
const pouzito:tpouzito=[]; {inicializovana promenna}


procedure generuj(var s:tvysledek;var pouzito:tpouzito;n:char;depth:char);
var c:char;
begin
 for c:='a' to n do {projdu vsechny moznosti, co dat na aktualni pozici}
  if not (c in pouzito) then
    begin
     s[depth]:=c;
     Include(pouzito,c);               {tohle pismeno je jiz obsazeno}
     generuj(s,pouzito,n,Succ(depth));
     Exclude(pouzito,c);               {uvolnim dane pismeno}
    end;

 if depth>n then      {vse je obsazeno, vygenerovali jsme nejakou permutaci}
  begin
   for c:='a' to n do {tak ji vypiseme}
    write(s[c]);
   writeln;
  end;
end;

var c:char;
    s:tvysledek;
begin
 writeln('Vygeneruji vsechny permutace pismen od ''a'' do zadaneho pismene');
 writeln('Zadejte male pismeno:');
 readln(c);
 writeln;

 if (c<'a') or (c>'z') then
  begin
   writeln('Spatne zadani');
   readln;
   Exit;
  end;

 FillChar(s,ord(c)-ord('a')+1,'#');
 generuj(s,pouzito,c,'a');
 readln;
end.

****************************************************************************************************

program Sachy;
{Dalsi ukazka toho, jak by program nemel vypadat.
Hned na zacatku zvolena spatna reprezentace dat,
navic neni dusledna (v pripada takoveto reprezentace
by se melo uvazovat spise o objektech).
Citelnost hlavni procedury programu je temer nulova...
Na druhou stranu program nacita vstupni data ze souboru,
coz je velke plus -- umoznuje mit testovaci balik na miliarde dat,
to by nikdo nikdy rucne neklepal...}

{Program urci, zda se uvedene figurky na sachovnici ohrozuji}
{Vstupem je jmeno souboru, ktery na prvni radce obsahuje seznam obsazenych
policek oddelenych mezerou (tedy a1 a2 c3 d1 b4 h8), tato radka
musi byt neprazdna (obsahuje aspon policka, na kterych stoji figurky, o ktere se zajimame),
na druhe radce soubor obsahuje nazev bile figurky + policko, na kterem stoji,
a mezerou oddelenou druhou figurku - pesec se znaci P, jezdec J (Ja1 Ph8).
Je mozne zadat vice dat, jsou pak oddelena prazdnou radkou.

Vystupem je soubor, ktery obsahuje ty same informace + na druhem radku
'+' pokud prvni ohrozuje druhou '-' pokud druha ohrozuje prvni, '0' pokud
ani jedna neni v ohrozeni, '=' pokud se ohrozuji navzajem,
CHYBNE ZADANI, pokud je zadany udaj neplatny, tj. napr. pokud je zadan
neplatny nazev figurky, ci pokud obe figurky stoji na stejnem miste apod.
program neuvazuje moznost brani mimochodem}

type tsloupec='a'..'h';
     tradka  =1..8;
     tpozice =record
                    sloupec:tsloupec;
                    radka:tradka;
              end;
     tSachovnice=array[tsloupec,tradka] of Boolean; {obsazeno x neobsazeno}
     tfigurka=set of char;
     tkamen=record
             druh:char;
             pozice:tpozice;
            end;
     tdata=record
            sachovnice:tsachovnice;
            kameny:array[1..2] of tkamen;
            pod:boolean; {prvni ohrozuje druhou}
            dop:boolean; {druha ohrozuje prvni}
            chyba:boolean; {chybny vstup}
           end;
     tsmer=array[1..2] of -1..1;
const figurka:tfigurka=['P','J','S','V','D','K'];

var fin:text;
    fout:text;
    soubor:string;
    data:tdata;

function Sgn(i:integer):integer;
{Signum, tuhle funkci urcite budeme potrebovat}
begin
 if i<0 then sgn:=-1;
 if i=0 then sgn:=0;
 if i>0 then sgn:=1;
end;

procedure Init(var data:tdata);
{Nastavi data pro pouziti}
var c:tsloupec;
    t:tradka;
begin
 for c:=low(tsloupec) to high(tsloupec) do
  for t:=low(tradka) to high(tradka) do
   data.sachovnice[c,t]:=false;
 data.chyba:=false;
 data.pod:=false;
 data.dop:=false;
end;

procedure Nacti(var data:tdata;var fin:text);
var f,c:char;
    t:integer;
begin
 Init(data);
 while not SeekEoln(fin) do {funkce seekeoln vynechava mezery}
  begin
   read(fin,c); {diky seekeoln neni nutne cist mezeru}
   read(fin,t);
   if (c<'a') or (c>'h') or (t<1) or (t>8) then
      begin
       data.chyba:=true;
       Exit;
      end;
   data.sachovnice[c,t]:=true;
  end;
 readln(fin); {Prechod na dalsi radku}

 read(fin,f);
 read(fin,c);
 read(fin,t);
 if (not (f in figurka)) or (c<'a') or (c>'h') or (t<1) or (t>8) then
  begin
   data.chyba:=true;
   Exit;
  end;
 data.kameny[1].druh:=f;
 data.kameny[1].pozice.sloupec:=c;
 data.kameny[1].pozice.radka:=t;

 read(fin,c); {precteme mezeru, nebot jsme nepouzili seekeoln}
 read(fin,f); {spravne by tu mela byt nejaka kontrola}
 read(fin,c);
 read(fin,t);
 if (not (f in figurka)) or (c<'a') or (c>'h') or (t<1) or (t>8) then
  begin
   data.chyba:=true;
   Exit;
  end;
 data.kameny[2].druh:=f;
 data.kameny[2].pozice.sloupec:=c;
 data.kameny[2].pozice.radka:=t;
end;

function ohrozuje(fig1:tkamen;policko:tpozice;dir:boolean):boolean; {dir znaci, zda je na tahu cerny ci bily}
{hlavni funkce programu, pekne zprasene, ale odpovida sachovym pravidlum}
var i1,i2:word;
    j1,j2:word;
    sance:boolean;
    i,j:integer;
    r,s:integer;
begin
 i1:=ord(fig1.pozice.sloupec)-ord('a')+1;
 i2:=ord(policko.sloupec)-ord('a')+1;
 j1:=fig1.pozice.radka;
 j2:=policko.radka; {Jelikoz mame blbe pojmenovane promenne,
                    musime je prevest na vhodny tvar}

 ohrozuje:=false;
 case fig1.druh of
  'P': if dir then
        if (j1+1 = j2) and ((i1+1=i2) or (i1=i2+1)) then
           ohrozuje:=true else ohrozuje:=false
        else
        if (j1 = j2+1) and ((i1+1=i2) or (i1=i2+1)) then
           ohrozuje:=true else ohrozuje:=false;

  'J': if ((j1+1 = j2) and ((i1 = i2+2) or (i1+2=i2)))
          or ((j1=j2+2) and ((i1=i2+1)or(i1+1=i2)))
          or ((j1+2=j2) and ((i1=i2+1)or(i1+1=i2))) then
           ohrozuje:=true else ohrozuje:=false;

  'S': begin
         sance:=true;
         if abs((i1-i2))<>abs(j1-j2) then sance:=false;
         r:=sgn(i2-i1);
         s:=sgn(j2-j1);
         i:=i1+r;
         j:=j1+s;
         while (i<>i2) do
          begin
           sance:=sance and not data.sachovnice[chr(ord('a')+i-1),j];
           writeln(i,j);
           Inc(i,r);
           Inc(j,s);
          end;
        ohrozuje:=sance;
       end;
  'V': begin
        sance:=true;
        if (i1<>i2) and (j1<>j2) then sance:=false;
        r:=sgn(i2-i1);
        s:=sgn(j2-j1);
        i:=i1+r;
        j:=j1+s;
        while (i<>i2) do
          begin
           sance:=sance and not data.sachovnice[chr(ord('a')+i-1),j];
           writeln(i,j);
           Inc(i,r);
           Inc(j,s);
          end;
        ohrozuje:=sance; {Ach ta kontrola obsazenosti policek}
       end;
  'D': begin
         sance:=true;
         if (abs((i1-i2))<>abs(j1-j2)) and (i1<>i2) and (j1<>j2)then sance:=false;
         r:=sgn(i2-i1);
         s:=sgn(j2-j1);
         i:=i1+r;
         j:=j1+s;
         while (i<>i2) do
          begin
           sance:=sance and not data.sachovnice[chr(ord('a')+i-1),j];
           writeln(i,j);
           Inc(i,r);
           Inc(j,s);
          end;

        ohrozuje:=sance;
       end;
  'K': if ((i1=i2)or(i1+1=i2)or(i1=i2+1))
        and ((j1=j2)or(j1+1=j2)or(j1=j2+1))
         then ohrozuje:=true;
  else ohrozuje:=false;
 end;
end;

procedure Zpracuj(var data:tdata);
begin
 with data do
  begin
   if (kameny[1].pozice.radka=kameny[2].pozice.radka)
     and (kameny[1].pozice.sloupec=kameny[2].pozice.sloupec)
      then
       begin
        data.chyba:=true;
        Exit;
       end;
 pod:=ohrozuje(kameny[1],kameny[2].pozice,true);
 dop:=ohrozuje(kameny[2],kameny[1].pozice,false);
 end;
end;

procedure Zapis(var data:tdata;var fout:text);
const symbol:array[boolean,boolean] of char=((('0'),('-')),(('+'),('=')));
var c:char;
    t:word;
begin
 for t:=high(tradka) downto low(tradka) do {tento zpusob vypisu odpovida bezne konvenci}
  begin
   for c:=low(tsloupec) to high(tsloupec) do
    if data.sachovnice[c,t] then write(fout,c,t,' ');
  end;
 writeln(fout);
 with data.kameny[1] do
  write(fout,druh,pozice.sloupec,pozice.radka,' ');
 with data.kameny[2] do
  write(fout,druh,pozice.sloupec,pozice.radka,' ');
 writeln(fout,symbol[data.pod,data.dop]);
 writeln(fout);
end;

begin
 writeln('Zadejte jmeno vstupniho souboru:');
 readln(soubor);
 assign(fin,soubor);
 writeln('Zadajte jmeno vystupniho souboru:');
 readln(soubor);
 assign(fout,soubor);
 reset(fin);    {Chybi kontrola, zda soubor existuje!!!}

 rewrite(fout);

 while not SeekEof(fin) do {Preskakujeme mezery a prazdne radky}
  begin
   Nacti(data,fin);
   Zpracuj(data);
   Zapis(data,fout);
  end;

 close(fin);
 close(fout);
 readln;
end.

***********************************************************************************************************************

program delitele;
{Najde nejvetsiho spolecneho delitele vice cisel jednoduchym algoritmem}
type tpole=array[1..5] of integer;

Function Delitel(a,b:LongInt):LongInt;
{Pro dve cisla}
Begin
 if (b=0) or (a=0) then
  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 delvic(pole:tpole;delka:integer):longint;
{Najde delitele vice cisel, zadani v poli}
var pozice:integer;
    vysledek:longint;
begin
 vysledek:=pole[1];
 for pozice:=1 to delka do
  vysledek:=delitel(vysledek,pole[pozice]);
  delvic:=vysledek;
end;

const a:tpole=(10,10,10,10,10);

begin
 writeln(delvic(a,5));
 readln;
end.

*********************************************************************************************
program sifra;
{Program zasifruje textovy soubor jmeno.txt jednoduchou metodou
a vytvori soubor jmeno_s.txt
{Sifruje a desifruje se stejnym algoritmem.
K desifrovani tedy staci zadat nazev zasifrovaneho souboru.}
{Program vyuziva generator nahodnych cisel,
vysledna sifra je tak mnohem bezpecnejsi,
nez kdybychom sifrovali pomoci nejakeho predem
daneho hesla. Generator nahodnych cisel se ale po case opakuje,
takze neni vhodne tento algoritmus pouzivat na dlouhe zpravy.}
var fin:text;
    fout:text;
    fname:string;
    kod:word;
    c:char;
begin
 {INICIALIZACE}
 writeln('Zadejte nazev souboru (bez pripony):');
 readln(fname);
 Assign(fin,fname+'.txt');
 Assign(fout,fname+'_s.txt');
 {$I-} {Vypneme kontrolu IO operaci, to aby nam program nespadl}
  Reset(fin);
  Rewrite(fout);
 {$I+}
 if IOResult<>0 then
  begin
   writeln('Spatne jmeno souboru -- vstupni soubor neexistuje,',
   'ci neni mozne vytvorit vystup.');
   readln;
   Exit;
  end;

 writeln('Zadejte kod (cislo od 0 do 65535):');
 readln(kod);
 randseed:=kod;

 while not eof(fin) do
  begin
   read(fin,c);
   c:=chr(ord(c) xor (170+random(86)));
   {Nesmi se stat, ze bychom znak vyxorovali napr. na znak smazani radky,
   ta by pak byla v zasifrovanem souboru skutecne smazana.}
   write(fout,c);
  end;

 close(fout);
 close(fin);
end.

*******************************************************************************************************************

program vypis_parametru;
{Program vypise parametry, s jakymi byl spusten,
pak je abecedne seradi,
vzhledem k tomu, ze parametru je malo, radi je jednoduchym
pomalym algoritmem}
type tpole=array[1..10] of string;
var i,j:word;
    a:tpole;

procedure prohod(var pra:string;var prb:string);
var pom:string;
begin
 pom:=pra;
 pra:=prb;
 prb:=pom;
end;

procedure bubblesort(pole:tpole;delka:word);
{Nejpomalejsi, ale snadno zapamatovatelny algoritmus,
avsak v pripade parametru na rychlosti nezalezi.}
var i,j:word;
begin
 for i:=0 to delka-1 do
  for j:=i to delka-1 do
   if a[j]>a[j+1] then prohod(a[j],a[j+1]);
end;

{TELO PROGRAMU}
begin
 writeln('Parametry programu v poradi, v jakem byly zadany:');
 for i:=0 to Paramcount do
  begin
   a[i]:=paramstr(i);
   writeln(a[i]);
  end;
 writeln;
 bubblesort(a,paramcount);
 writeln('Parametry programu razene abecedne: ');

 for i:=0 to Paramcount do
  writeln(a[i]);
  readln;
end.

program vypis_parametru;
{Druha verze razeni parametru, tentokrat je k jejich razeni pouzit
jeden z nejefektivnejsich radicich algoritmu. Pro takhle malo promennych
je ale az zbytecne slozity}
type tpole=array[1..10] of string;
var i,j:word;
    a:tpole;

procedure prohod(var pra:string;var prb:string);
var pom:string;
begin
 pom:=pra;
 pra:=prb;
 prb:=pom;
end;

procedure QuickSort(Start,Cil:longint;var P:Tpole);
{Jeden z nejefektivnejsich tridicich algoritmu. Je zalozen na metode
rozdel a panuj. Jeho presnemu rozboru se budeme venovat v sekci pro experty.
Funguje tak, ze vybere nejaky prvek (pivota) a pole rozdeli na dve casti -
- na prvky, co jsou mensi nebo rovny pivotovi a na prvky, co jsou vetsi nez pivot.
Pak zavola sam sebe na jednu a pote na druhou cast pole.
Jakmile se dostane k jednoprvkovym polim, je cele pole setrizene.}
var piv:string;
    i,j:Word;
begin
 if Cil>Start then
  begin
   j:=start;
   piv:=P[cil];
   for i:=start to cil do
    if piv>=P[i] then
     begin
      prohod(p[i],p[j]);
      j:=j+1;
     end;
   QuickSort(Start,J-2,P);
   QuickSort(J,Cil,P);
  end;
end;

{TELO PROGRAMU}
begin
 writeln('Parametry programu v poradi, v jakem byly zadany:');
 for i:=0 to Paramcount do
  begin
   a[i]:=paramstr(i);
   writeln(a[i]);
  end;
 writeln;
 quicksort(0,paramcount,a);
 writeln('Parametry programu razene abecedne: ');

 for i:=0 to Paramcount do
  writeln(a[i]);
  readln;
end.