• 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.