VEZERLESI MODOK:
-szekvencialis
-szelekcios
-ismetleses
-eljaras

Szekvencialis: p1; p2; p3; ....; pn  (p -parancs)
Szelekcios: (1) if F then A
    (2) if F then A else B
tobbszoros szelekcio: if F1 then A1
else if F2 then A2
...
else if Fn then An
      else B
Esetkiv. szel. vez.:
case K of
H1: A1;
H2: A2;
...
Hn: An;
else B;
end

MUVELETEK:
 Boolean(B):
B -> B
not (negalas)
pred (negalas)
succ (negalas)
BxB -> B
and
or
xor (kizaro VAGY): A B xor
   i i h
   i h i
   h i i
   h h h
B x B ->B
=, <>, <=, >=, <, >

 Integer (Z):
Z -> Z
-, +
succ
pred
abs
sqr

Z x Z -> Z
+, -, *
div, mod
pl: 13 div 5 =2
    13 mod 5 =3
=, <>, <, >
<=, >=
Z ->B
odd
pl: odd(7)= true
    odd(8)= false

 Valos (R):
R
pi
R-> R
+, -, abs, sqr, Sqrt, Sin, cos, ArcTan, en, exp
R x R-> R
+, -,*,/
R -> Z
Trunc (elhagyja a tizedestortet)
Round (kerekit)
        R x R -> B
<, >, =, <=, >=, <>


KONSTANSOK:
-nem valtozik az erteke
-uj erteket nem kaphat
pl: const
ar=1000;               {integer}
igaz=true;             {bool}
szoveg='Szeged')       {string}

ISMETLESES VEZERLES:
-Kezdo felteteles:
while F do M
-Vegfelteteles:
repeat M until F


1.Feladat:
Be -> (x, y)
A dekart koordinata melyik ternegyedeben van benne.
Ki -> 1, 2, 3, 4, tengely

Otlet: x  y
       1  1  ->
       1 -1  ->
      -1  1  ->
      -1 -1  ->

x/abs(x) = +-1
x-hez, y-hoz +1
2 2 -> 22
2 0 -> 20
0 2 -> 2
0 0 -> 0
CASE utasitas hasznalata

Program: bekeres
x=0: igen -> l=100
      nem: sigx=(x/abs(x))+1
y=0 igen -> l=100
    nem: sigy
l=sigx*10+sigy
kiertekeles: l=0 Ki: 'III negyedben van a pont"
     l=2        Ki: '....'
     l=...
     l=else      Ki: tengely

cp /home/hpke/koord.pas  koord.pas

program koordinata;

var
x, y: Integer;
sigx, sigy: Integer;
l: Integer;

begin
write('x koordinata: ');
readln(x);
write('y koordinata: ');
readln(y);


if (x=0) then
l:=100
else
begin
sigx:=(x div abs(x))+1;
if (y=0) then
l:=100
else
begin
sigy:=(y div abs(y))+1;
l:=sigx*10+sigy;
end;
end;


case l of
0  : writeln('3. negyed');
2  : writeln('2. negyed');
20 : writeln('4. negyed');
22 : writeln('1. negyed');
else writeln('Tengelyen van!')
end;

end.
fpc koord.pas
./koord


2.Feladat:
beadot szamok min, max, atlag, a beadott parmeterek tetszoleges
szamuak lehetnek (bevitel megszakithato legyen).

cp /home/hpke/pral063.txt pral063.txt
cp /home/hpke/pral065.txt pral065.txt

roblémafelvetés: Határozzuk meg egy valós számsorozat legkisebb
                  és legnagyobb elemét, valamint a sorozat átlagát!
Specifikáció:
A probléma inputja a valós számsorozat. Az input számsorozat végét
egy végjel fogja jelezni, amit a felhasználó ad meg inputként,
nyilván a számsorozat elött.

!!!Inicializalas: elso szam: max=min.
Algoritmustervezés:      +---------+
                         | Minimax |
                         +----+----+
       +----------------------+--------------------+
       |                      |                    |
+------+------+        -------+--------        +---+----+
|Inicializálás|       ( Szám <> Végjel )       |Kiíratás|
+-------------+        -------+--------        +--------+
                              |
                   +----------+-------+
                   |                  |
         +---------+---------+    +---+----+
         | Szám feldolgozása |    |Be(Szám)|
         +---------+---------+    +--------+
                   |
          +--------+--------+
          |                 |
+---------+----------+ +----+----+
|Összeg:=Összeg+Szám;| |Szám<Min |
|    Db:=Db+1        | |----+----|
+--------------------+ | i  | n  |
                       +-+--+--+-+
                 +-------+     |
                 |             |
            +----+----+   +----+---+
            |Min:=Szám|   |Szám>Max|
            +---------+   |----+---|
                          | i  | n |
                          +-+--+---+
                            |
                       +----+----+
                       |Max:=Szám|
                       +---------+

                      +-------------+
                      |Inicializálás|
                      +------+------+
                             |
     +------------+----------+-----------+-----------+---------+
     |            |          |           |           |         |
+----+-----+ +----+---+ +----+----+ +----+----+ +----+----+ +--+--+
|Be(Végjel)| |Be(Szám)| |Min:=Szám| |Max:=Szám| |Összeg:=0| |Db:=0|
+----------+ +--------+ +---------+ +---------+ +---------+ +-----+

                      +----------+
                      | Kiíratás |
                      +-----+----+
                            |
                       +----+----+
                       |  Db = 0 |
                       |----+----|
                       | i  | n  |
                       +--+-+-+--+
                          |   |
                  +-------+   +-------+
                  |                   |
           +------+------+    +-------+-----+
           |Ki( üres     |    |Ki(Min,Max,  |
           |    sorozat) |    |    Átlag )  |
           +-------------+    +-------------+

program minimax;
const
maxdata=5
  Var
    Vegjel, Szam, Osszeg : Real;
    Min, Max, Atlag      : Real;
    Db : Integer;                  { az összegzett elemek száma }

  Begin
    WriteLn('Ez a program valós számsorozat minimális,');
    WriteLn('maximális elemét és átlagát számolja.');
    WriteLn('Az input sorozatot végjel zárja.');
    WriteLn('Kérem a végjelet!');               { inicializálás }
    ReadLn(Vegjel);
    WriteLn('Kérem az input számsorozatot!');
    Write('?'); ReadLn(Szam);         { az elsö szám beolvasása }
    Min := Szam; Max := Szam;
    Osszeg := 0.0; Db := 0;

    While Szam <> Vegjel and (Db/maxdata-1)Do                  { a ciklus
kezdete }
    Begin
      Osszeg := Osszeg + Szam;                      { összegzés }
      Db := Db + 1;                          { számláló növelés }

      If Szam < Min Then                     { min-max számítás }
        Min := Szam
      Else If Szam > Max Then
        Max := Szam;
                                  { a következ? szám beolvasása }
      Write('?'); ReadLn(Szam);
    End ;                                       { a ciklus vége }

    If Db = 0 Then
       WriteLn('Üres számsorozat érkezett.')
    Else
       Begin
         Atlag := Osszeg / Db;
         WriteLn('Minimum  = ',Min:10:3,' Maximum= ',Max:10:3);
         WriteLn('Az átlag = ',Atlag : 10 : 3)
       End
  End.


ÁTNÉZNI!!!!
read/write
szintaktika
logikai muveletek
aritmetrikai muveletek
konstansok
whilem repeat
case
if