Pascal I.      Pascal II.      Delphi       Linkek     
Pascal I.
01. A program szerkez...
01. Gyakorló feladatok
02. Változók használata
02. Gyakorló feladatok
03. A FOR ciklus
03. Gyakorló feladatok
04. Egymásba ágyazo...
04. Gyakorló feladatok
05. Karakterláncok ...
05. Gyakorló feladatok
06. Az IF feltételvizsgálat
06. Gyakorló feladatok
07. A CASE elágazás
07. Gyakorló feladatok
08. A WHILE..DO ciklus
08. Gyakorló feladatok
09. A REPEAT..UNTIL ...
09. Gyakorló feladatok
10. Tömbök (ARRAY ...
10. Gyakorló feladatok
11. Műveletek tömbökkel
11. Gyakorló feladatok
12. Kétdimenziós töm...
12. Gyakorló feladatok
13. Műveletek kétdime...
13. Gyakorló feladatok
Programozás 1 (Pascal)
     
11 Műveletek tömbökkel
   
  • legkisebb, legnagyobb elem megkeresése

  • tömb elemeinek összeadása

  • tömb tükrözése

  • két rendezett tömb összefésülése

   
     11.1 Legkisebb, legnagyobb elem megkeresése

     Készítsünk programot, amely egy 20 elemű tömbbe kigenerál 1 és 150 közötti véletlen számokat, majd az elemek kiírása után megkeresi a tömbben található legkisebb és legnagyobb elemet.

     Ehhez bevezetünk két változót: min és max. Kezdetben beállítjuk mindkét változó értékét a tömb első elemének értékére - feltételezve hogy ez a legkisebb és legnagyobb elem is a tömbben, majd a második elemtől a tömb végéig végignézzük az elemeket (van-e a beállított első elemnél nagyobb vagy kisebb). Ha bármelyik elem kisebb mint a min változó értéke, akkor az új elem értékét megjegyezzük a min változóban. Hasonlóan, ha olyan elemet találunk, amely nagyobb mint a max értéke, akkor azt  megjegyezzük a max változóban. Így a ciklus lefutása (tömb elemeinek átnézése) után a min és a max változók a tömb legkisebb ill. a legnagyobb elemét fogja tartalmazni. Programunk így néz ki:

program Pelda27a;
const n=20;
{a tömb elemeinek a száma}
var a: array[1..n] of integer;
    i,min,max: integer;
begin
 randomize;
 for i:=1 to n do a[i]:=random(150)+1;
 for i:=1 to n do write(a[i],', ');
 writeln;
 {a tömb legkisebb és legnagyobb elemének keresése...}
 min:=a[1];
 max:=a[1];
 for i:=2 to n do begin
                  if a[i]<min then min:=a[i];
                  if a[i]>max then max:=a[i];
                  end;
 writeln('Legkisebb: ',min);
 writeln('Legnagyobb: ',max);
end.

  
     11.2 Tömb elemeinek összeadása

     Bővítsük tovább az előző programunkat. Egészítsük ki egy olyan programrésszel, amely összeadja a tömb elemeit, majd kiírja az összeget.

     Ehhez bevezetünk egy újabb változót - osszeg, melynek kezdeti értékét beállítjuk 0-ra, majd a ciklus segítségével (amit módosítottunk, hogy 1-től menjen) végigmegyünk a tömb elemein és ehhez a változóhoz sorban hozzáadjuk a tömb első, második, ... utolsó elemét. Így a ciklus lefutása után az osszeg változó a tömb eleminek összegét fogja tartalmazni. Módosított programunk így néz ki:

program Pelda27b;
const n=20;
{a tömb elemeinek a száma}
var a: array[1..n] of integer;
    i,min,max,osszeg: integer;
begin
 randomize;
 for i:=1 to n do a[i]:=random(100)+1;
 for i:=1 to n do write(a[i],', ');
 writeln;
 {a tömb legkisebb és legnagyobb elemének keresése }
 {az
összeadással kibővítve... }
 min:=a[1];
 max:=a[1];
 osszeg:=0;
 for i:=1 to n do begin
                  if a[i]<min then min:=a[i];
                  if a[i]>max then max:=a[i];
                  osszeg:=osszeg+a[i];
                  end;
 writeln('Legkisebb: ',min);
 writeln('Legnagyobb: ',max);
 writeln('Az elemek osszege: ',osszeg);
end.

  
     11.3 Tömb tükrözése

     Most készítsünk egy újabb programot. A program elején egy N=20 elemű tömbbe (N egy konstans legyen) generáljunk 10 és 99 közötti véletlen számokat, majd írjuk ki a tömböt. Ezek után tükrözzük a tömböt, tehát az első elemet cseréljük ki az utolsóval, a másodikat az utolsó előttivel, stb. Az így módosított tömböt írjuk ki újból a képernyőre.

     A tömb elemeinek cseréjét (a tükrözést) egy 8 és egy 9 elemű tömbön az alábbi ábra szemlélteni:

     Ebben is láthatjuk, hogy a tükrözéshez valójában egy olyan ciklusra van szükségünk, amely páros számú elemek esetében egytől a tömb feléig, páratlan számú elemek esetében a felénél eggyel kevesebbig megy (az ábrán a kék elemek) és elvégzik a megfelelő cserét. Ezt egyszerűen egy olyan for ciklussal tudjuk elvégezni, melynek ciklusváltozója 1-től (n div 2)-ig megy.
     A cikluson belül valójában melyik elemeket kell cserélni melyikkel? Az 1. elemet az n-dik elemmel, a 2. elemet az (n-1)-dik elemmel, a 3. elemet az (n-2)-dik elemmel, stb. Tehát ha vesszünk az említett for ciklus ciklusváltozóját (i), akkor az i-dik elemet mindig az (n-i+1)-dik elemmel kell kicserélnünk (a cserét egy x segédváltozó segítségével végezzük el). Programunk tehát így néz ki:

program Pelda28;
const n=20;

var a: array[1..n] of integer;
    i,x: integer;
begin
 randomize;
 for i:=1 to n do a[i]:=random(90)+10;
 
{a tömb elemeinek kiírása...}
 for i:=1 to n do write(a[i]:3);
 writeln;
 {a tömb tükrözése...}
 for i:=1 to n div 2 do begin
                        x:=a[i];
                        a[i]:=a[n-i+1];
                        a[n-i+1]:=x;
                        end;
 {a tömb elemeinek kiírása...}
 for i:=1 to n do write(a[i]:3);
 writeln;
end.

  
     11.4 Két rendezett tömb összefésülése

     A következő példában legyen két tömbünk - a és b, melyek közül az elsőnek van na, a másodikak nb darab eleme. Mindkét tömbünk rendezett, növekvő sorrendben (ehhez a program elején a tömbök deklarálásánál megadjuk az tömbök elemeinek értékét). Készítsünk egy olyan programot, amely az a és b tömböt összefésüli egy új - c tömbbe, tehát veszi az a és b tömb elemeit és azokat sorban egymás után átrakja a c tömbbe úgy, hogy a c tömb is rendezett legyen.

     Nézzük a feladat tömbjeit ábrán szemléltetve (az a és b tömbök a program elején adottak, melyek elemeiből a program hozza létre a c tömböt):

     A programban fogunk használni további két változót - ai és bi, melyek fogják jelölni, hogy az a ill. b tömb éppen melyik eleménél járunk.
     Az ai, bi változókat a program elején beállítjuk 1-re, majd a programban (a c tömb létrehozására szolgáló ciklusban) mindig az a tömb ai-dik eleme vagy a b tömb bi-dik eleme közöl a kisebbet tesszük át a c tömbbe (és növeljük az ai vagy bi értékét egyel attól föggően melyik tömbből raktuk át az elemet a c tömbbe). A c tömbhöz is bevezetünk egy ci változót, mely azt fogja jelölni, hogy éppen hol járunk a c tömbben (kezdetben ennek az értéke is 1 lesz, majd minen egyes átrakásnál növeljük egyel).
     A fent leírt, elemek átrakására szolgáló algoritmust addig fogjuk ismételni, amíg nem érünk az a vagy a b tömb végére (ai vagy bi nem éri el a tömb végét, tehát amíg nem lesz több, mint az adott tömb elemeinek száma - an, bn). Ehhez egy repeat..until ciklust haszn
álunk. Ez után már csak a másik tömbből (amelyiknél még nem értünk a tömb végére) átrakjuk az összes megmaradt elemet a c tömbbe (ci-től kezdve a végéig).
     Végül ellenőrzésképpen kiírjuk a képernyőre az eredeti a, b és az általunk létrehozott c tömböt. Programunk így néz ki:

program Pelda29;
const an=5;
      bn=5;
      cn=an+bn;
var a: array[1..an] of integer = (8,10,12,17,21);
    b: array[1..an] of integer = (9,15,19,28,57);
    c: array[1..cn] of integer;
    i,ai,bi,ci: integer;
begin
 ai:=1;
 bi:=1;
 ci:=1;
 repeat
  if a[ai]<b[bi] then begin
                      c[ci]:=a[ai];
                      inc(ai);
                      end
                 else begin
                      c[ci]:=b[bi];
                      inc(bi);
                      end;
  inc(ci);
 until (ai>an) or (bi>bn);
 if (ai>an) then begin
                 for i:=bi to bn do c[ci+(i-bi)]:=b[i];
                 end
            else begin
                 for i:=ai to an do c[ci+(i-ai)]:=a[i];
                 end;
 write('A tomb: ');
 for i:=1 to an do write(a[i],', ');
 writeln;
 write('B tomb: ');
 for i:=1 to bn do write(b[i],', ');
 writeln;
 write('C tomb: ');
 for i:=1 to cn do write(c[i],', ');
 writeln;
end.

     A programban gondolkozzunk el többek között a  for i:=bi to bn do c[ci+(i-bi)]:=b[i];  soron.

     Itt valójában egy ciklus segítségével, amelyben az i ciklusváltozó értéke bi-től bn-ig megy átrakjuk a maradék elemeket a b tömbből a c tömbbe. Ha jobban megfigyeljük, akkor a c[ci+(i-bi)] kifejezésben az (i-bi) értéke először 0 (hiszen az i kezdeti értéke bi), majd 1, 2, ... Tehát a b tömb maradék elemeit (b[bi], b[bi+1], b[bi+2], ...) a c[ci], c[ci+1], c[ci+2], ... elemekbe rakjuk át, ami a valódi célunk volt.

     A for i:=ai to an do c[ci+(i-ai)]:=a[i];  sor hasonlóan működik, csak itt az a tömb maradék elemét rakjuk át a c tömbbe.

   

(C) 2004-2013, PaedDr. Végh Ladislav, Komárno, Szlovákia