I - ATW.huusers.atw.hu/infokaracs/2014-15/pascal_peldak_tervezes.doc · Web viewA sorozat további elemeit végignézzük, és ha valamelyik nagyobb, mint az eddig megjegyzett,

BevezetésA feladatgyűjtemény szerkezetileg 3 nagy részből áll. Minden rész elején

mintapéldák találhatók, majd feladatok.

Az első fejezet a programozási alapismereteket elmélyítő feladatokat tartalmaz.

Itt találhatók:

Az elemi és összetett adattípusokat feldolgozó feladatok.

Adatok kiíratása képernyőre, adatok beolvasása billentyűzetről

Iterációk és szelekciók

Egyszerű példák az eljárások és függvények használatára.

A második fejezet a programozási tételek elmélyítését segítő példákat tartalmaz. Az

egyes programozási tételeknél az általános megoldó algoritmus is megtalálható.

A harmadik fejezetben a szöveges és típusos állománykezeléshez kapcsolódó

példák találhatók.

1

I Elemi programozás

I.1 Elemi utasításokMintapéldák:1.) Számítsuk ki és írassuk ki 5 szám átlagát!

i. Feladatvizsgálat:

Bemenő adatok:a, b, c, d, e: egész számok

Kimenő adat: f: számok átlaga, valós szám

A megoldás logikája:Először számoljuk ki a számok összegét, és tároljuk az f változóban, majd az f –et elosztjuk öttel, így a számok átlagát kapjuk

ii. Feladat megoldása:

Folyamatábra

Start

F:=a+b+c+d+e

f:=f/5

Be: a,b,c,d,e

Ki: F

Stop

2

Mondatszerű leírás:

Változóka,b,c,d,e: egészf: valós

Program átlagBe: a,b,c,d,ef:=a+b+c+d+ef:=f/5 Ki: f

Program vége.

Feladat pascal kódja:

program atlag; uses crt;

vara,b,c,d,e: byte;f: real;

beginclrscr; {ezzel a paranccsal a képernyőt töröljük}

writeln ('Öt szám átlaga');writeln ('kérem az első számot');readln (a);writeln ('kérem a második számot');readln (b);writeln ('kérem a harmadik számot');readln (c);writeln ('kérem a negyedik számot');readln (d);writeln ('kérem az ötödik számot'); readln (e);f:=a+b+c+d+e;f:=f/5;writeln ('a keresett átlag:',f:10:2); {két tizedesnyi pontossággal írja ki a számot}readkey;

end.2.) Almát szeretnénk vásárolni. Írjunk egy programot, amely billentyűzetről kérje be először azt, hogy mennyibe kerül egy kilogramm alma, majd azt, hogy hány kilogramm almát szeretnénk venni. A program számolja ki, hogy ennyi almáért hány forintot fogunk fizetni.


Bemenő adatok:N: hány kg almát veszünk, egész számEar: 1 kg alma ára, egész szám

Kimenő adatok:Ar:a fizetendő összeg, egész szám

A megoldás logikája:A vásárolni kívánt alma árát úgy kapjuk meg, hogy az egységárat összeszorozzuk a mennyiséggel

3


Folyamatábra:


Változók:N,Ear,Ar: egész

Program almaBe: N, EarAr:=N*EarKi: Ar

Program vége


program alma;uses crt;

varEar,N,Ar:integer;

beginclrscr;write ('Egy kg alma ára: ');readln (Ear);write ('Hány kg almát veszel: ');readln (N);Ar:=Ear*N;writeln ('Ennyi alma ára ',ar,' forint.');

end.

Start

Ar:=Ear*N

Be: N,Ear

Ki: Ar

Stop

4

3.) Írjunk programot, amely beolvas két természetes számot, az elsőként megadott számot maradékosan osszuk a másodikkal. A program írja ki a két szám hányadosát és maradékát. A program a beolvasás után hagyjon ki egy üres sort.

i. Feladatvizsgálat

Bemenő adatok:a,b: a két szám, természetes számok

Kimenő adatok:m: a két szám maradéka, természetes számh: a két szám hányadosa, természetes szám

A megoldás logikája:A megoldáshoz a div és a mod függvényeket használjuk. A div függvény két szám hányadosát, míg a mod függvény két szám maradékát számolja.


Folyamatábra:

Mondatszerű leírás

Változóka,b: egészm,h: egész

Program osztasBe: a,bm:=a mod bh:=a div bKi: m,h

Program vége.

Start

m:=a mod b

h:=a div b

Be: a,b

Ki: h,m

Stop

5


program osztas;uses crt;var

a,b: integer;m,h: integer;

beginclrscr;write ('Első szám: ');readln (a);write ('Második szám: ');readln (b);writeln; {üres sort hagy ki}h:= a div b; {a és b hányadosát számolja}m:=a mod b; {a és b maradékát számolja}writeln (a,':',b,'=',h,', maradék ',m);

end.

6

FeladatokKérj be két, egy napon belüli, időpontot (először az órát, aztán a percet, végül a

másodpercet). Számítsd ki a két időpont közti különbséget másodpercekben és írasd ki!Írj programot, amely bekér egy számot, majd kiírja a kis szorzótáblát erre a számra

(1-től 5-ig). A program a beolvasás után hagyjon ki egy üres sort.Kérj be három természetes számot, ezek rendre 5, 2 és 1 koronásaink számát

jelentik. Határozd meg, és írasd ki a teljes összeget.Kérj be három természetes számot, ezek rendre 5, 2 és 1 forintosaink számát

jelentik. Határozd meg, és írasd ki a teljes összeget.Írj programot, amely bekéri egy téglalap adatait, és kiszámolja a területét, és a

kerületét.Írj programot, amely szögmértéket vált át fokról radiánra.Adott egy valós szám, határozd meg az abszolút értékét!Adott a síkban két pont. Számold ki a távolságukat!A következő program számítógépbe írása nélkül határozd meg, hogy mit ír ki a

képernyőre. Írj egy rövidebb (egyszerűbb) programot, amely változó használata nélkül kiírja ugyanezt az üzenetet a képernyőre. A teljes program maximum 5 soros legyen!Program valtozo;var

x: integer;begin

x:=12;write (x,'-');x:=3;write (x,'=');writeln (12-x);write (x+6,'+',x,'=');x:=4*x;writeln(x);

end.Az alábbi program begépelése nélkül próbáld meg meghatározni, mit fog kiírni a

képernyőre. Ellenőrzésképpen a programot beírhatod a számítógépbe.program szamok;var

k:integer;begin

k:=1;writeln (k);k:=k+1;write (k);k:=k+1;writeln (k);k:=k+1;write (k);k:=k+1;write (k);k:=k+1;writeln (k);

end.

7

I.2 Elágazások

A Kétirányú elágazás

Mintapéldák1.) Készítsünk programot, amely bekér két egész számot, majd kiírja szavakkal, hogy az első szám kisebb, nagyobb, vagy egyenlő, mint a második szám.


Bemenő adatok:a,b: egész számok

Kimenő adatok:Nincs kimenő változó, szöveges választ adunk

A megoldás logikája:A két számot összehasonlítjuk, és a kapott eredményt kiíratjuk a képernyőre.


Folyamatábra:

Start

Ki: az a nagyobb

Be: a,b

Stop

Ki: az a kisebba<b

a>b

A két szám egyenlő

igaz

hamis

8


Változók:a,b: egész

program eldöntbe: a,bha a>b akkor ki: ’ az első szám a nagyobb’különben

ha a<b akkor ki: ’ az első szám a kisebb’különben

ki: ’a két szám egyenlő’elágazás vége

program vége.

A feladat pascal kódja:

program osszehasonlit;var

a,b:integer;begin

write ('Kérem az első számot: ');readln (a);write ('Kérem a második számot: ');readln (b);if a<b then writeln ('Az 1. szám a kisebb.')else

if a>b then writeln ('Az 1. szám a nagyobb.')else writeln ('A két szám egyenlő.');

end.2.) A háromszög három oldalának ismeretében számítsuk ki a kerületét, majd a megadott Héron-képlet segítségével a területét! Először vizsgáljuk meg az adatokat, hogy lehetnek-e egy háromszög oldalai! Ha hibás adatokat adtunk meg, akkor írassunk ki egy tájékoztató üzenetet!


Bemenő adatok:a, b, c: a háromszög három oldala, legyenek egész számok

Kimenő adatok:k: a háromszög kerülete, mivel az oldalak egészek, így a kerület is egész számt: a háromszög terület, valós szám

Megoldás logikája:Három szakaszból akkor szerkeszthető háromszög, ha bármelyik kettőnek az összege nagyobb a harmadik szakasz hosszánál. Először ezt vizsgáljuk. Ha nem teljesül, akkor hibajelzést küldünk a felhasználónak, különben matematikai képleteket alkalmazva kiszámoljuk a háromszög kerületét, majd a területét.

9


Folyamatábra:


Változóka,b,c: egészt,k,s: egész

ProgramBe: a,b,cHa (a+b<c) vagy (a+c<b) vagy (b+c<a) akkor

ki:’ hibás adat’különben

k:=a+b+cs:=t/2t:=sqrt(s*(s-a)*(s-b)*(s-c))

elágazás végeki: t,k

program vége.

a+b<=c vagya+c<=b vagy

b+c<=a

Start

k:=a+b+c

Be: a,b,c

Stop

t:=sgrt(s*(s-a)*(s-b)*(s-c))

nem

igen

s:=k/2

Ki: k,t

10


program haromszog ;uses crt ;

vara,b,c : byte ;k : byte ;s,t : real;

beginclrscr ;writeln ('Kérem az a oldal értékét: ');readln (a) ;writeln ('Kérem a b oldal értékét: ');readln (b);writeln ('Kérem a c oldal értékét: ');readln (c) ;if (a+b<=c) or (a+c<=b) or (b+c<=a) then

writeln ('Sajnos hibásak az adatok!');k:=a+b+c ;s:=k/2 ;t:=sqrt (s*(s-a)*(s-b)*(s-c)) ; writeln ('A háromszög kerülete: ',k);writeln ('A háromszög területe: ',t:10:2);readkey;

end.

B Többágú elágazás

Mintapéldák3.) Olvassunk be egy ember életkorát, és ettől függően írjuk ki a következő szöveget:

0 - 13 gyerek14 – 17 fiatalkorú18 – 23 ifjú24 – 59 felnőtt60 évtől idős

i. Feladat vizsgálata:

Bemenő adatok:Kor: egész szám

Kimenő adatok:Nincs kimenő változónk, a program a személy korcsoportjának megnevezését adja vissza.

Megoldás logikája:Beolvassuk a személy életkorát, majd végignézzük, hogy melyik korcsoportba tartozik, majd kiíratjuk a korcsoportnak megfelelő elnevezést.

11


Folyamatábra:


VáltozókKor: egész

Program korcsoportBe: korElágazás

Kor=0..13 esetén ki: ’ gyerek’Kor=14..17 esetén: ki:’ fiatalkorú’Kor=18..23 esetén: ki:’ ifjú’Kor=24..59 esetén ki:’ felnőtt’

Különben ki: ’ idős’Elágazás vége

Program vége.

Start

Be: kor

Kor=14..17

Kor=0..13igaz

hamis

igaz

Kor=14..17

Kor=14..17

Start

igaz

igaz

hamis

hamis

hamis

Ki:gyerek

Ki: fiatalkorú

Ki: ifjú

Ki: felnőtt

Ki: idős

12


program korcsoport ;var

kor: integer;begin

write ('kérem a keresett életkort! ');readln (kor);case kor of

0..13: write (' gyerek');14..17: write ('fiatalkorú');18..23: write ('ifjú');24..59: write ('felnőtt');

else write ('idős');end;

end.4.) Írjunk programot, amely bekéri az éppen aktuális hónap számát, és kiírja a hónap nevét. Ha nem 1 és 12 közötti számot adunk meg, akkor a program jelzi, hogy 'Nincs ilyen hónap'.


Bemenő adatok:Honap: egész szám, a hónap számát adjuk meg benne.

Kimenő adatokNincs kimenő változónk, a hónap nevét írja ki a programunk.

A megoldás logikája:Ellenőrizzük, hogy a bekért hónapszám melyik hónapnak felel meg, ha nem hónapszámot adtunk meg, akkor írjuk ki, azt, hogy nem hónapszám.



VáltozóHonap: egész

Program honapokbe: hónapElágazás

honap=1 esetén ki: ’ január’honap=2 esetén ki: ’ február’honap=3 esetén ki: ’ március’honap=4 esetén ki: ’ április’honap=5 esetén ki: ’ május’honap=6 esetén ki: ’ június’honap=7 esetén ki: ’ július’honap=8 esetén ki: ’ augusztus’honap=9 esetén ki: ’ szeptember’honap=10 esetén ki: ’ október’honap=11 esetén ki: ’ november’honap=12 esetén ki: ’ december’

különben ki: ’ nem hónapszám’Elágazás vége

Program vége

13


program honapok;var

honap:integer;begin

Write ('Adja meg az aktuális hónap számát: ');Readln (honap);case honap of

1: Write ('Január');2: Write ('Február');3: Write ('Március');4: Write ('Április');5: Write ('Május');6: Write ('Június');7: Write ('Július');8: Write ('Augusztus');9: Write ('Szeptember');10: Write ('Október');11: Write ('November');12:Write ('December');

else Write ('Nincs ilyen hónap');end;

end.5.) Olvassunk be egy karaktert a billentyűzetről. Döntsük el, hogy számjegyet, magánhangzót, vagy mássalhangzót olvastunk be! Elég, ha az angol ABC betűit vizsgálja a program! Ha ezek közül egyik se, akkor írjuk ezt válasznak!


Bemenő adatok:a: ebbe változóba olvassuk be a karaktert a billentyűzetről, karakter típusú

Kimenő adatok:Nincs kimenő változónk, szöveges választ adunk

Megoldás logikája:Beolvasunk a billentyűzetről egy karaktert, majd ellenőrizzük, hogy melyik csoportba tartozik a karakter, majd ezt adjuk válaszul!



Változó:a: karakter

Program karakterbe: a

Elágazása=’0’..’9’ esetén ki: ’ számjegy’a=’a’,’A’,’e’,’E’,’i’,’I’,’o’,’O’,’u’,’U’ esetén ki: ’ magánhangzó’a=’b’..’d’,’f’..’h’,’j’..’n’,’p’..’t’,’v’..’z’ esetén ki: ’ mássalhangzó’a=’B’..’D’,’F’..’H’,’J’..’N’,’P’..’T’,’V’..’Z’ esetén ki: ’ mássalhangzó’

különben ki: ’a beolvasott karakter nem betű, és nem számjegy’Elágazás vége

Program vége

14

A feladat pascal kódja

program karakter;uses crt;

vara: char;

beginclrscr;write ('olvass be egy tetszőleges karaktert');readln (a);case a of

'0'..'9':writeln('számjegy');'a','e','i','o','u','A','E','I','O','U': writeln ('magánhangzó');'b'..'d','f'..'h','j'..'n','p'..'t','v'..'z': writeln ('mássalhangzó');'B'..'D','F'..'H','J'..'N','P'..'T','V'..'Z': writeln ('mássalhangzó');else

writeln ('a beolvasott karakter nem számjegy és nem betű');end;readkey;

end.

15

FeladatokOlvass be egy számot! Írj programot, amely eldönti, hogy -30 és 40 között van-e?Írj programot, amely kiszámolja két tetszőleges szám hányadosát! Vigyázza 0-val

való osztásra!Írj programot, amely bekér két számot, ha azonos előjelűek, akkor írja ki a

számokat, különben kérjen újabb számpárt!Írj programot, amely egy tetszőleges valós számról eldönti, hogy egész szám – e,

ebben az esetben írassuk ki!Írj programot,amely egyetlen if utasítás segítségével eldönti, hogy egy tetszőleges

szám egyenlő-e 1, 2, 3 számok valamelyikével!Írj programot, amely egy tetszőleges pozitív, de 1 milliónál kisebb számról,

megállapítja, hogy hány jegyű a szám?Írj programot a másodfokú egyenlet megoldására. A lehetséges eseteket vizsgáld!

(a<>0, a diszkrimináns pozitív vagy nulla kell legyen).Írj programot, amely egy hónapszáma alapján, eldönti, hogy melyik évszakhoz

tartozik?Írj programot, amely egy beolvasott nap számáról eldönti, hogy a hónap melyik

negyedébe esik! (1-10: I. negyed, 11 – 20: II. negyed, 21.-30: III. negyed, 31: IV. negyed)

Írj programot, amely adott évszámról eldönti, hogy szökőév-e? Írj programot, amely bekér egy dátumot, majd eldönti hogy helyes – e? Februárt

tekintsd 28 naposnak!Egészítsd ki az előző programot, úgy hogy vizsgálja, hogy az év szökőév-e!Írj egy dátum-átalakító programot! Nemzetközi formában megadott dátumot

alakítsa át magyar formájú dátummá, úgy hogy a hónap nevét írja ki! (Pl.: 02.04.2006 helyett: 2006. április 02.)

Számold ki a következő függvény értékét!

16

I.3 Ciklusok

A Számláló ciklus

Mintapéldák:1.) Írjunk programot, amely 1-től 10-ig kiírja az összes számot és mellé a szám négyzetét!


Bemeneti adatok:i: egész szám, értékei 1-től 10-ig változnak

Kimeneti adatok:Nincs kimeneti változó, a műveleteket a bemeneti változóval végezzük, és kiíratjuk a képernyőre.

Megoldás logikája:Számláló ciklus segítségével 1-től 10-ig kiszámoljuk a számok négyzetét, és kiíratjuk a képernyőre.


Folyamatábra:


Változóki: egész

Program négyzetCiklus i:=1-től 10-ig

ki: iki: i*i

Ciklus végeProgram vége.

Start

Be: N

Stop

I:=1..10

Ki: i

Ki: i*i

17


program negyzetszamok;uses crt;

vari:integer;

beginclrscr;for i:=1 to 10 do writeln (i,' négyzete = ',i*i);

end.2.) Számítsuk ki egy tetszőlegesen választott pozitív egész szám hatványait egy választott pozitív egész kitevőig!


Bemenő adatok:a: hatványalap, egész számb: a választott legmagasabb hatványkitevő, egész szám.

Kimenő adatok: i: egész szám, mutatja, hogy hányadik hatványt képezzük, egész számh: az aktuális hatványérték, minden lépésben kiíratjuk, egész szám

Megoldás logikája:Beolvassuk a hatványalapot, majd a maximális kitevőt. A hatványérték első lépésben legyen 1. Utána rendre 1-től a megadott kitevőig szorozzuk az alappal, így megkapjuk hatvány értékét és kiíratjuk a képernyőre.



Változóka,b: egészi,h: egész

program hatvanyozasbe: abe: bh:=1

ciklus i:=1-től b-igh:=h*aki: h

ciklus végeprogram vége

18


program hatvany; uses crt;

var a,b,i: byte;h: longint;

beginwriteln ('Írd le, mely számnak keresed a hatványát! ');readln (a);writeln ('Hányadik hatványig írjam ki? ');writeln ('Vigyázz, hogy az eredmény 10-nél kevesebb számjegyű legyen ');readln (b);h:=1;for i:=1 to b do begin

h:=h*a;writeln (' Tehát az ',a,' alap ',i,'. hatványa: ',h);

end;readkey;

end.3.) Írassuk ki az angol nagy abc-t oda, majd a kis abc-t vissza!


Bemenő adatok:nincsenek.

Kimenő adatok:nincsenek

Megoldás logikája:Két számláló ciklust használunk, az egyikben elölről a másikban visszafele íratjuk ki az abc-t.



Változói: karakter

Program abcCiklus i:=’A’ - tól ’Z’ – ig

Ki: iCiklus végeCiklus i:= ’z’ – től ’a’ – ig

Ki:iCiklus vége

Program vége.

19


Program abc;uses crt;

vari:char;

beginclrscr;for i:='A' to 'Z' do

write (i,' ');writeln;for i:='Z' downto 'A' do

write (i,' ');readkey;

end.

20

B Elöltesztelő ciklus

Mintapéldák4.) Olvassuk be körök sugarait addig, amíg egy nullát nem ütnek be. Minden esetben írjuk ki a kör kerületét! Ha végjelet ütnek, fejezzük be a játékot!


Bemenő adatok:sugar: a körök sugarai, egész szám

Kimenő adatok:Nincs, az eredményt a bemenő adat segítségével számoljuk

Megoldás logikája:Beolvassuk a kör sugarát, minden beolvasásnál ellenőrizzük, hogy a beírt szám 0-e? Ha nem kiszámoljuk a kör kerületét, ha 0, akkor befejezzük a programot.


Folyamatábra


Változók:Sugar: egész

Program korokbe: sugarciklus amíg sugar <> 0

ki: sugar*2*pibe: sugar

ciklus végeprogram vége.

sugar<>0

Start

Be: sugar

Stop

Igaz

ham

is

ki: sugar*2*pi

be: sugar

21


program korokuses crt;var

Sugar: integer;begin

clrscr;write (’a kör sugara: ’);readln (sugar);while sugar <> 0 dobegin

write (’a kör kerülete: ’,2*sugar*pi);write (’a kör sugara: ’);readln (sugar);

end;end.5.) Készítsünk programot, amely kiszámolja két általunk megadott egész szám legkisebb közös többszörösét és legnagyobb közös osztóját!


Bemenő adatoka,b: két egész szám

Kimenő adatokLnko, lkkt: a két szám legnagyobb közös osztója, illetve legkisebb közös többszöröse, egész számok

Megoldás logikája:A számoláshoz a matematikából ismert Euklideszi algoritmust alkalmazzuk. Első lépésben ellenőrizzük, hogy az első szám legyen a nagyobb, ha nem így van, akkor felcseréljük a két szám értékét. Utána képezzük a két szám szorzatát és a két szám osztási maradékát, egészen addig, míg az osztási maradék nem nulla. a nagyobb szám értékének a kisebb szám értékét adjuk, a kisebbnek az osztási maradékot vesszük,majd újra kiszámoljuk e két szám osztási maradékát. Ha a maradék 0 lesz, a feladatunk végére jutottunk. A két szám legnagyobb közös osztója kisebb változóban megőrzött érték, míg a legkisebb közös többszöröse a két szám szorzatának és a legnagyobb közös osztójának a hányadosa.

22



Változók:a, b: egészlnko, lkkt: egészs, h, m: egész

program lnko_lkktbe: a,bha a<b akkor

s:=a, a:=b, b:=selágazás végeh:=a*b, m:=a mod bciklus amíg m<>0

b:=a;a:=m;m:=a mod b

ciklus végelnko:= blkkt:=h div bki: lnkoki: lkkt

program vége.


program lnko_lkkt;uses crt;var

a,b: integer;lnko, lkkt: integer;s,h,m: integer;

beginclrscr;write (’ Kérem a két természetes számot: ’);read (a, b);if a<b then

begins:=a; a:=b; b:=s; {felcseréljük az a és b értékét}

end;h:=a*b;m:=a mod b;while m<>0 do begin

b:=a;a:=m;m:=a mod b;

end;lnko:= b;lkkt:=h div b;writeln (’ a két szám legnagyobb közös osztója: ’,lnko);writeln (’ a két szám legkisebb közös többszöröse: ’,lkkt);readkey;

end.23

C Hátultesztelő ciklus

Mintapéldák6.) A számítógép véletlenszerűen válasszon (gondoljon) egy számot 1-től 10-ig. Kérdezze meg a felhasználótól melyik ez a szám. A felhasználó addig találgathat, amíg nem találja el ezt a számot. A számítógép csak annyit írjon neki ki: "eltaláltad, ez az a szám", vagy "sajnos nem ez az a szám".


Bemenő adatok:a: a gondolt szám

Kimenő adatok:Nincs, szöveges választ adunk


Folyamatábra:

Start

Stop

b:=véletlen szám (1..10)

b=a

b=a

igaz

igaz

hamis

hamis

Be: a

Ki: eltaláltadKi: nem talált

24


Változóka,b: egész

Program talalgatasb:=véletlen szám (1..10)ciklus

be: aha b=a akkor ki:’ Eltaláltad ez a szám!’különben

ki: ’ sajnos nem ez a szám’elágazás vége

amíg b=aciklus vége

program vége.


program talalgatas;uses crt;var

a,b:integer;begin

clrscr;randomize;b:=random (10)+1; { egy egész számot generál 1-tol 10-ig }repeat

write ('Melyik számra gondoltam? ');readln (a);if b=a then writeln ('Eltaláltad, ez az a szám!')

else writeln ('Sajnos nem ez az a szám.');until b=a;writeln ('Nyomd meg az ENTER billentyűt.');readkey;

end.7.) Írjunk programot, mely segítségével menüből lehet választani, hogy hasáb, henger vagy gömb térfogatát akarjuk számolni. Amelyik funkciót választottuk, az ahhoz tartozó adatokat kérje be, majd írja ki az eredményt!


Bemenő adatok:c: a menü betűjele, karakter típusúr: jelentse a henger, illetve a gömb sugarát, egész számm: jelentse a hasáb, illetve a henger magasságát, egész száma,b: a hasáb alaplapjának szélessége, illetve hosszúsága, egész számok

Kimenő adatok:v: a keresett térfogatok, valós szám

A megoldás logikája:A lehetőségeket ismételten felkínáljuk, míg a felhasználó úgy dönt, hogy nem akar több lehetőséget igénybe venni. Annak függvényében, hogy melyik funkciót választotta, a program kérje be a megfelelő adatokat, majd a matematikai képleteket felhasználva számolja ki a testek térfogatát!

25

ii. Feladat megoldása


Változók:c: karakterr,m,a,b: egészv: valós

program menuciklus

ki: ‘ H: Henger térfogata’ki: ’ T: Hasáb térfogata’ki: ’ G: Gömb térfogata’ki: ’ V: Vége’be: celágazás

c= ’H’ esetén be: r,mv:= r*r*m*piki: v

c= ’T’ eseténbe: m, a,bv:=a*b*mki: v

c=’G’ eseténbe: rv:=(4*pi*r*r*r)/3;ki: v

elágazás végeamíg c=’V’ciklus vége

program vége.

26


program menu;uses crt;

varc:char;r,m,a,b: integer;v: real;

beginrepeat

clrscr;gotoxy (20,10); write ('H: henger térfogata '); {a képernyő pozicionálás}gotoxy (20,11); write ('T: hasáb térfogata ');gotoxy (20,12); write ('G: gömb térfogata ');gotoxy (20,13); write ('V: vége ');readln(c);c:=upcase (c); {átalakítjuk a karaktert nagybetűssé}case c of'H': begin

clrscr;write ('A henger sugara= '); readln (r);write ('A henger magassága= '); readln (m);v:=r*r*m*pi;writeln;writeln ('A henger térfogata= ',v:0:2);readkey;

end;'T': begin

clrscr;write ('a hasáb magassága= '); readln (m);write ('a hasáb alaplapjának hosszúsága= '); readln (a);write ('a hasáb alaplapjának szélessége= '); readln (b);v:=a*b*m;writeln;writeln ('a hasáb térfogata= ',v:0:0);readkey;

end;'G': begin

clrscr;write ('a gömb sugara= '); readln (r);v:=(4*pi*r*r*r)/3;writeln;writeln ('a gömb térfogata= ',v:0:2);readkey;

end;end;until c='V';

end.

27

FeladatokKészíts programot, amely kiírja 1-től 10-ig az egész számok négyzetét egymás alá.

Ez után az egész kiírás után rakjon ki egy mínuszjelekből álló vonalat és ez alá a vonal alá írja ki a program, hogy mennyi a kiírt négyzetszámok összege, tehát hogy mennyi az 1+4+9+16+25+36+...+100 összeg

Készíts programot, amely bekér egy n természetes számot, majd kihagy egy üres sort, és kiírja egymás mellé n-től 0-ig az egész számokat és mindegyik szám után egy szóközt rak.

Írj programot, mely a képernyőre írja a tízes szorzótáblát!Írj programot, amely bekér egy számot, ellenőrzi, hogy a szám pozitív-e, ha nem

megismétli a beolvasást, majd kiszámítja a szám faktoriálisát! (n!=1*2*..*n)Készíts programot, amely bekér egy N természetes számot, majd kirajzol a

képernyőre egymás mellé N-szer az "XO" betűket és a kiírás után a kurzort a következő sor elejére teszi.(Például N=3-ra XOXOXO).

Egészítsd ki az előző programot úgy, hogy az előző kiírás alá írja ki N-szer az "OX" betűket is egymás mellé, majd a kurzort ismét a következő sor elejére tegye. (Például N=3-ra XOXOXOOXOXOX)

Készíts programot, amely kiszámolja az első N db. páros szám összegét.Készíts programot, amely kiszámolja az első N db. páratlan szám összegét.Kérj be két természetes számot (M,N), majd rajzoljunk ki a képernyőre egy MxN méretű

téglalapot csillag (*) jelekből.(Például M=8 és N=3-ra:************************

Írj programot, mely bekéri, hogy mennyi pénzt akarunk betenni a takarékba, mennyi az éves kamat és mennyi időre szeretnénk lekötni a pénzünket. A program számolja ki, hogy mennyi pénzünk lesz, mikor kivesszük a pénzünket.

Készíts programot, amely végjelig bekér egész számokat (a végjel legyen 0). A program határozza meg és írja ki a beadott egész számok közül a legkisebbet és a legnagyobbat. (A 0-t ne számítsa bele a beadott számokba, ez csak a bevitel végét jelzi.)

Olvassunk be pozitív egész számokat 0 végjelig. Írjuk ki a számok számát és a számok átlagát.

Készíts programot, amely ki fogja kérdezni a matematikát (két szám összeadását, kivonását és szorzását az (1,10) intervallumból). A két számot és a műveletet a számítógép véletlenszerűen válassza ki. A program akkor fejeződjön be, ha a felhasználó 10 példát kiszámolt helyesen. Rossz válasz esetén kérdezze újra ugyanazt a példát. A program végén írja ki az eredményességet százalékokban.

Készíts programot, amely bekér egy egész számot és felbontja prímtényezők szorzatára. (Pl. 12 = 2*2*3 - a szorzatban csak prímszámok vannak.)

Készíts programot, amely kiszámolja a/b+c/d (két tört összegét), majd az eredmény törzsalakú törté alakítja (amely már nem egyszerűsíthető tovább).

28

I.4 Adattípusok

A Szövegfeldolgozás

Mintapéldák:1.) Készítsünk programot, amely beolvas egy mondatot, majd kiírja hány karakterből áll a mondat.


Bemenő adatok:s: szöveg típusú

Kimenő adatok:h: a szöveg hossza, egész szám

Megoldás logikája:Először beolvassuk a mondatot. Beolvasás után ennek a változónak a hosszát a length() függvénnyel kapjuk meg.


Folyamatábra:


Változóks: szövegh: egész

Program MondatHosszabe: sh:=hossz (s)ki: h

Program vége

start

stop

H:=hossz (s)

Be:s

Ki:h

29


program MondatHossza;uses crt;

vars:string;h: integer;

beginclrscr;write ('Írj be egy mondatot: ');readln (s);h:=length(s);writeln ('A mondat hossza: ',h,' karakter.');readkey;

end.2.) Készítsünk programot, amely beolvas egy mondatot, majd kiírja a mondatot nagy betűkkel.


Bemenő adatok:s: a megadott mondatot tartalmazza, szöveg típusú

Kimenő adatok:Nincs, a bemenő változóban adjuk meg az eredményt

A megoldás logikája:Először beolvassuk a mondatot. Beolvasás után a mondat minden egyes karakterét egy cikluson belül megváltoztatjuk nagybetűre. Az s változóban levő mondat első betűjét az s[1] adja meg, második betűjét az s[2] adja meg, stb. Egy karaktert nagybetűre az upcase() függvény segítségével változtathatunk meg.

ii. Faladat megoldása:


Változóks: szövegi: egész

Program MondatNagyBetukkel;be: sciklus i:= 1-től hossz(s)-ig

s(i):=nagybetűre(s(i))ciklus végeki: s

Program vége.

30


program MondatNagyBetukkel;uses crt;var

s: string;i:integer;

beginclrscr;write ('Írj be egy mondatot: ');readln (s);for i:=1 to length(s) do

s[i]:=upcase (s[i]);writeln (s);

end.3.) Készítsünk programot, amely bekér egy mondatot, majd kiírja ugyanezt a mondatot úgy, hogy mindegyik betű (karakter) után kirak egy szóközt.


Bemenő adtok:s: a beolvasott mondat, szöveg típusú

Kimenő adatok:Nincs, a bemenő adatok segítségével adjuk meg az eredményt

Megoldás logikája:Először beolvassuk a mondatot. Beolvasás után a mondat minden egyes karakterét egy cikluson belül kiíratjuk, és utána egy szóközt írunk.



Változók:s:szöveg;i: egész

Program szethuzott_mondatbe: sciklus i:=1-től hossz (s) –ig

ki: s(i),’ ’ciklus vége

Program vége.


Program szethuzott_mondat;uses crt;

vars: string;i: integer;

beginclrscr;write ('Írj be egy mondatot: ');readln (s);for i:=1 to length (s) do write (s[i],' ');

end.

31

FeladatokÍrj mese (vagy vicc) választó programot kistestvéred számára, mellyel három rövid

mese (illetve vicc) közül egyet vagy egymás után többet is választhat tetszőlegesen!Készíts programot, amely bekér egy mondatot, majd kiírja ugyanezt a mondatot

fordítva. Például, ha beírjuk "Szép napunk van ma.", kiírja ezt: ".am nav knupan pézS"

Olvass be egy karaktert, majd írasd ki a sorszámát, az előtte és az utána álló karaktert, valamint a karakter nagybetűs formáját.

Olvass be két nevet egymás után. Írd ki a neveket névsorban!Olvass be neveket „*” végjelig! Írd ki ezek közül a névsorban az elsőt!Olvass be egy karakterláncot. Cseréld ki az összes szóközt a 250-es ASCII kódú

pici karikáraOlvass be egy karakterláncot. Cseréld ki az összes „kutya” szót „eb”-re.Olvass be egy nevet. Írd ki az illető monogramját! (Vigyázz, van akinek 2-nél több

neve van, pl.: Nagy Ilona Mária).Számold meg egy szövegben az „s” betűket!Írj programot, amely egy tetszőleges karaktersorozatban, megszámolja, hogy hány

betűt, hány számjegyet és hány egyéb karaktert tartalmaz!

32

B Tömb

Egydimenziós tömb

Mintapéldák1.) Készítsünk programot, amely beolvas 10 egész számot egy tömbbe, majd kiírja őket fordított sorrendben.


Bemenő adatok:10 egész típusú bemenő adatra van szükségünk. Ne találjunk ki az elemeknek egyedi neveket, hanem adjunk egy gyűjtőnevet az egész csoportnak, és az elemekre hivatkozzunk indexekkel.t: az egész számokat tartalmazó adatcsoport neve, az elemeket 1-től 10-ig indexeljük, elemei egész számok.

Kimenő adatok:Nincs, a beolvasott adatokat íratjuk ki.

Megoldás logikája:A tömb egyes elemeit úgy használjuk, mint ha azok egyedi változók lennének. Például a t(3) a 3. egész számot jelenti. Vigyázzunk, hogy az elemre való hivatkozáskor az indexnek olyan értéke legyen, mely egy létező tömbelemre hivatkozik. A t(11) például helytelen hivatkozás.A 2. fejezetben megismert for ciklust használjuk. Az indexelési technikával az egész tömböt egyetlen iterációval fel tudjuk tölteni.


Folyamatábra:

Start

Stop

I:=1..10

Be: t(i)

I:=10..1

ki: t(i)

33


Változók:t: tömb (1..10: egész) {tömb deklarációja}i: egész {a ciklusban a tömb aktuális elemét fogja jelenteni}

program szamokPrciklus i:=1-től 10.ig

be: t(i) {10 beolvasást hajt végre, rendre az 1., 2. ...10. egészet olvassuk be}ciklus végeképernyőtörlésciklus i:=10-től 1-ig

ki: sulyok(i) {10 kiírást hajt végre, rendre a 10.,9.,...1. számot írjuk ki}ciklus vége

program vége.


program szamokPr;uses crt;

vara:array [1..10] of integer;i: integer;

beginclrscr;for i:=1 to 10 do begin

write (i,'. szam: ');readln (a[i]);

end;writeln ('A szamok fordított sorrendben:');for i:=10 downto 1 do write (a[i]:6);{6 karakternyi távolságot hagy ki a számok között}readkey;

end.2.) Mérjük meg 10 gyerek testsúlyát, és a mért értékeket sorban vigyük be a számítógépbe, majd töröljük le a képernyőt, és írjuk ki a gyerekek testsúlyát!


Bemenő adatok:súlyok: a súlyokat tartalmazó adatcsoport neve, az elemeket 1-től 10-ig indexeljük, elemei egész számok

Kimenő adatok:Nincs, a beolvasott adatokat íratjuk ki.

Megoldás logikája:Hasonlóan az előző mintapéldához, két for ciklust használunk, egyet a beolvasáshoz, és egyet a kiíratáshoz.

34


Folyamatábra:


Változók:sulyok: tömb (1..10: egész) {tömb deklarációja}i: egész {a ciklusban a tömb aktuális elemét fogja jelenteni}

program SulyokPrciklus i:=1-től 10.ig

be: sulyok(i) {10 beolvasást hajt végre, rendre az 1., 2. ...10. gyerek súlyát olvassuk be}

ciklus végeképernyőtörlésciklus i:=1-től 10-ig

ki: sulyok(i) {10 kiírást hajt végre, rendre az 1., 2. ...10. gyerek súlyát írjuk ki}ciklus vége

program vége.

Start

Stop

I:=1..10

Be: sulyok(i)

I:=1..10

ki: sulyok(i)

35


Program SulyokPr;Uses crt;var

sulyok: array[1..10] of integer; {tömb deklarációja}i: integer;

beginclrscr;for i:=1 to 10 do begin

write (i,’. gyerek súlya: ’);readln (sulyok[i]);

end;clrscr;for i:=1 to 10 do begin

write (i,’. gyerek súlya: ’);writeln (sulyok[i]);

end;readkey;

end.4.) Alakítsuk át a 2-es programot, úgy, hogy számoljuk ki a gyerekek súlyának átlagát, és az átlagot írja ki a program!


Bemenő adatok:sulyok: a súlyokat tartalmazó adatcsoport neve, az elemeket 1-től 10-ig indexeljük, elemei egész számok

Kimenő adatok:a: a gyerekek súlyának átlaga

Megoldás logikája:Egy ciklus segítségével olvassuk be az adatokat, és számoljuk az átlagot. A beolvasást ugyanúgy tesszük, mint az első feladatban. Az átlagot lépésenként számoljuk, a változót (a gyerekek átlaga) tegyük egyenlővé nullával, majd minden lépésnél hozzáadjuk az aktuálisan beolvasott értéket.



Változók:sulyok: tömb (1..10: egész) {tömb deklarációja}i: egész {a ciklusban a tömb aktuális elemét fogja jelenteni}

program SulyokPra:=0ciklus i:=1-től 10.ig

be: sulyok(i) {10 beolvasást hajt végre, rendre az 1., 2. ...10. gyerek súlyát olvassuk be}a:=a+sulyok(i)

ciklus végeképernyőtörléski: a

program vége.

36

A feladta pascal kódja:

Program SulyokPr;Uses crt;var

sulyok: array[1..10] of integer; {tömb deklarációja}i: integer;

beginclrscr;a:=0;for i:=1 to 10 do begin

write (i,’. gyerek súlya: ’);readln (sulyok[i]);a:=a+sulyok[i];

end;clrscr;

write (’a gyerekek átlagsúlya: ’);writeln (a/10); {a ciklusban az a változóban a gyerekek súlyainak összegét számoltuk}

readkey;end.5.) Írjunk programot, amely egy egyszerű pénztárgép működését mutatja be! Tároljuk a vásárolandó áruk mennyiségét (darabszámát), és az egységárát, majd számoljuk ki, hogy mennyit kell fizessünk! Maximum 20 árufélére számítunk, a 0 végjelig.


Bemenő adatok: db:a vásárolandó áruk mennyiségét tartalmazó sorozat, elemei valós számok.ear : a vásárolandó áruk egységárát tartalmazó sorozat, elemei valós számok

Kimenő adatok: fizet:valós szám, a fizetendő összeg

Megoldás logikája:Az adatok beolvasásánál ellenőrizzük, hogy 20 terméknél többet ne vigyünk be, illetve a végjelnél fejezzük be az adatok bekérését!A megfelelő árú egységárát és a vásárolt mennyiséget összeszorozzuk, majd ezeket az értékeket összeadjuk, így a végösszeget kapjuk. A megoldásban

37



Változókdb, ear: tömb(1..20: valós)fizet: valósi,j: egész

Program vasarlasi:=0ciklus

i:=i+1be: db(i)ha db(1)=0 akkor ear(i)=0 különben

be: ear(i)elágazás vége

amíg (i=20) vagy (db(i)=0)ciklus végeha db(i)=0 akkor j:=i-1fizet:=0ciklus i:=1-től j-ig

fizet:=fizet+db(i)*ear(i)ciklus végeki: fizet

program vége.


program vasarlas;uses crt;

vardb,ear: array [1..10] of real;i,j: integer;fizet:real;

beginclrscr;i:=0;write ('A pénztárgép max. 20 árúra és 0 végjelre működik');writeln ('Ezen a pénztárgépen tizedes vessző helyett pontot használunk.');repeat

i:=i+1;write ('Kérem a(z) ',i,' . árú mennyiségét: ');readln (db[i]);if (db[i]=0) then ear[i]:=0 else {a megadott végjel miatt kell ellenőrizni}begin

write ('egységára: ');readln (ear[i]);

end;until (db[i]=0) or (i=20); {addig ismételjük, míg elértük a 20 árút, vagy 0-t ütöttünk}if db[i]=0 then j:=i-1;fizet:=0;for i:=1 to j do fizet:=fizet;writeln;writeln (' A fizetendő összeg: ',fizet:10:2);

end.38

Feladatok:Írj programot, amely egy tanév alatt összegyűlt zsebpénzünket számolja ki a havi

adatokból.Olvass be egész számokat 0 végjelig egy maximum 100 elemű tömbbe. Írj ki a

számokat a beolvasás sorrendjében majd fordítva.Állíts elő egy 30 elemű tömböt véletlen egész számokból (0-tól 99-ig), majd írd ki a

tömböt a képernyőre.Olvass be, hogy menyi pénzt költött ruhára évenként Márti és Gábor 1981 és 1994

között. Írj programot, amely lehetővé teszi azt, hogy lekérdezzük, hogy mennyi pénzt költött adott évben Gábor, Márti illetve közösen.

Írj programot, mely kiválasztja az 5-ös lottó nyerő számait, és egy tömbben tárolja őket!

Számold ki 1-től 20-ig a minden szám négyzetét, köbét, negyedik hatványát! Írasd ki a képernyőre átlátható formában!

Írasd ki, a kettes szám 1-től 25-dik hatványait!A négyes mintapéldát alakítsd át úgy, hogy a pénztárgépet mi szúrópróbaszerűen

tudjuk ellenőrizni, hogy adott árucikkből hány darabot vettünk és az mennyibe került?Egy iskola két osztályát összevonják. A két osztály névsora két külön tömbben volt

tárolva. Írj programot, amely a két névsorból egyet formál!Egy börtönben 1000 cella van, mindenikben 1 rab ül. Kezdetben minden cella zárva

van. A börtönőr végigmegy az összes ajtó előtt és minden ajtó zárján fordít egyet (ha nyitva volt bezárja, ha zárva volt kinyitja). Ha végigment elkezdi elölről és minden második ajtó zárján fordít egyet, majd minden harmadikon fordít, és így tovább. Legvégül fordít egyet az ezrediken, és kész. Ezután amelyik cella nyitva van abból a rab elmehet. Kik a szerencsés rabok?

Az alábbi program begépelése nélkül javítsd ki a hibákat és próbáld meg előre meghatározni, mi lesz a program eredménye! Ellenőrzésképpen a programot beírhatod a számítógépbe.Program sok_hiba;

uses crt; var

jegy: array [1…10] of real;i:byte;

beginclrscr;writeln (’ Ebben a programban rengeteg hiba van. Javítsd ki!’)writeln (’Most kérek 10 darabot a matek osztályzataidból!’);writeln (’Találd ki, hogy mit teszek velük! Rajzold meg a folyamatábráját!’),for i=1 to 10 dobegin

write (’ Kérem a(z) ’,i., jegyet: ’);readln (jegy[i];if jegy[i]<5 then jegy[i]:=jegy[i]+1;

else jegy[i]:=jegy[i];end.Writeln (’A jegyeid a következők lettek: ’,jegy[i]);

end.

39

Kétdimenziós tömb

Mintapéldák:1.) Olvassunk be egy N egész számot (1<N<10), majd egy NxN-es kétdimenziós tömbbe generáljunk véletlen egész számokat 10-tol 99-ig.- Írassuk ki a generált tömböt, pl. N=3-ra:

34 58 1985 50 1199 25 17


Bemenő adatok:n: egész szám (a tömb sorainak és oszlopainak a száma)t: n sorra és n oszloppal rendelkező tömb, elemei egész számok

Kimenő adatok:Nincs, a tömböt íratjuk ki

Megoldás logikája:Először fel kell tölteni a tömbünket. Hasonlóan járunk el, mint az egydimenziós tömb esetében, itt két úgynevezett futóváltozóra van szükség, az egyik az aktuális sort, a másik pedig az aktuális oszlopot jelenti. Például t(1,2) az első sor második eleme. Véletlenszám generálásához a már megismert randomize függvényt használjuk. Ha a beolvasással kész vagyunk ki kell írassuk a tömböt a képernyőre.


Folyamatábra:

Start

Be: n

Stop

i:=1..nj:=1..n

t(i,j):= véletlenszám (10..99)

i:=1..nj:=1..n

ki t(i,j)

40


Változók:n: egészt,: tömb(1..n,1..n: egész)

program tomb1be: n{a következő ciklussal a t tömböt töltjük fel, véletlen számokkal}ciklus i:=1-től n-ig

ciklus j:=1-től n-igt(i,j):= véletlenszám (10..99)

ciklus vége{a következő ciklussal a t tömb elemeit íratjuk ki}ciklus i:=1-től n-ig

ciklus j:=1-től n-igki: t(i,j)



program tomb1;uses crt;

vart:array [1..9,1..9] of integer;n,i,j:integer;

beginclrscr;write (’Add meg az N értékét (1<N<10): ’);readln (n);writeln;randomize;{NxN-es tömb feltöltése}for i:=1 to n dofor j:=1 to n do begin

t[i,j]:=random(89)+10;end;writeln;{tömb kiírása }for i:=1 to n do begin

for j:=1 to n do write(t[i,j]:3);writeln;

end;writeln;readkey;

end.

41

2.) Olvassunk be egy N egész számot (1<N<10), majd egy NxN-es kétdimenziós tömbbe olvassunk be tetszőleges természetes számokat

Írjuk ki a tömböt a képernyőre, pl. N=4-re és a következő számokra ilyen formában:60 19 17 5317 82 26 10 8 11 29 9064 77 19 70

Írjunk a tömb átlójába 0-kat, majd írjuk ki a tömböt újra a képernyőre: 0 19 17 5317 0 26 10 8 11 0 9064 77 19 0


Bemenő adatok:n: egész szám (a tömb sorainak és oszlopainak a száma)t: n sorra és n oszloppal rendelkező tömb, elemei egész számok

Kimenő adatok:kt: n sorra és n oszloppal rendelkező tömb, elemei egész számok

Megoldás logikája:Töltsük fel a t tömböt, ha ezzel kész vagyunk, fel kell tölteni a kimenő tömböt. Ezt 16 értékadással tesszük meg, a főátló elemei 0-k, minden más elem a bemenő tömbünk megfelelő elemének értékével lesz egyenlő. Azok az elemek vannak a főátlóban, amelyeknek a sor és oszlop indexük megegyezik (itt a t(1,1), t(2,2), t(3,3), és a t(4,4)).



Változók:n: egészt, kt: tömb(1..n,1..n: egész)

program tomb2be: n{a következő ciklussal a t tömböt töltjük fel, általunk megadott elemekkel}ciklus i:=1-től n-ig

ciklus j:=1-től n-igbe: t(i,j)

ciklus vége{a következő ciklussal a t tömb elemeit íratjuk ki}ciklus i:=1-től n-ig

ciklus j:=1-től n-igki: t(i,j)

ciklus vége{most a kt tömböt töltjük fel}ciklus i:=1-től n-ig

ciklus j:=1-től n-igha i=j akkor kt(i,j):=0 {a főátló elemeit nullázzuk}különben

kt(i,j):=t(i,j) {a többi elemet egyenlővé tesszük a bemenő értékekkel}elágazás vége

ciklus vége

42

{kt tömb elemeit íratjuk ki}ciklus i:=1-től n-ig

ciklus j:=1-től n-igki: kt(i,j)




vart, kt: array [1..9,1..9] of integer;n,i,j:integer;

beginclrscr;write ('Add meg az n értékét (1<n<10): ');readln (n);writeln;{ NxN-es tömb beolvasása }for i:=1 to n do

for j:=1 to n do beginwrite ('T[',i,',',j,'] = ');read (t[i,j]);

end;writeln;{tömb kiírása}for i:=1 to n do begin

for j:=1 to n do write (t[i,j]:3);writeln;end;writeln;{tömbben a 0-k beírása az átlóba}for i:=1 to n do

for j:=1 to n doif i=j then kt[i,j]:=0

else kt[i,j]:=t[i,j];{tömb kiírása}for i:=1 to n do begin

for j:=1 to n do write (kt[i,j]:3);writeln;

end;writeln;readkey;

end.

43

3.) Határozza meg egy kétdimenziós tömb elemeinek soronkénti, oszloponkénti teljes átlagát!


Bemenő adatok:n,m: egész számok (a tömb sorainak és oszlopainak a száma)t: n sorral és m oszloppal rendelkező tömb, elemei egész számok

Kimenő adatok:soratlag: a sorok átlagát tartalmazó n elemű valós vektoroszlopatlag: az oszlopok átlagát tartalmazó m elemű valós vektor

Megoldás logikája:A beolvasást végezzük a már megismert módón. Utána számoljuk ki a soratlag vektor elemeit tegyük egyenlővé a sorok átlagával, ugyanezt tegyük meg az oszlopatlaggal is.



Változók:n,m: egésztomb: tömb(1..10,1..10: egész)soratl, oszlatl: tömb (1..10: valós)i,j: egész

program tomb3be: n,m{a következő ciklussal a tomb tömböt töltjük fel, általunk megadott elemekkel}ciklus i:=1-től n-ig

ciklus j:=1-től m-igbe: tomb(i,j)

ciklus vége{a sorok átlagait }ciklus i:=1-től n-ig

soratl[i]:=0ciklus j:=1-től m-ig

soratl[i]:=soratl[i]+tomb[i,j]soratl[i]:=soratl[i]/m

ciklus végeciklus i:=1-től n-ig

oszlatl[j]:=0;ciklus j:=1-től m-ig

oszlatl[j]:=oszlatl[j]+tomb[i,j]oszlatl[j]:=oszlatl[j]/n


ki: soratl[i]ciklus végeciklus i:=1-től n-ig

ki: oszlatl[i]ciklus végeprogram vége.

44



vartomb: array [1..10, 1..10] of integer;soratl, oszlatl: array [1..10] of real;n,m,i,j: integer;

beginclrscr;writeln ('hány sora van a tömbnek? ');readln (n);writeln ('hány oszlopa van a tömbnek?');readln (m);for i:=1 to n do

for j:=1 to m do beginwrite ('T(',i,',',j,') = ');readln (tomb[i,j]);

end;for i:=1 to n do begin

soratl[i]:=0;for j:=1 to m do

soratl[i]:=soratl[i]+tomb[i,j];soratl[i]:=soratl[i]/m;

end;for j:=1 to m do begin

oszlatl[j]:=0;for i:=1 to n do

oszlatl[j]:=oszlatl[j]+tomb[i,j];oszlatl[j]:=oszlatl[j]/n;

end;writeln ('a sorok: ');for i:=1 to n do write (soratl[i]:0:2,' ');writeln;writeln ('az oszlopok átlagai: ');for j:=1 to m do write (oszlatl[j]:0:2,' ');readkey;

end.

45

FeladatokAz 1-es mintapéldát alakítsd át úgy, hogy a program keresse meg a tömb legkisebb

elemét, és cserélje ki az első sor első elemével.Írj programot, amely egy kétdimenziós tömb adott két sorát, majd két oszlopát

felcseréli!Írj programot, amely meghatározza egy mátrix soraiban az elemek minimumát,

majd a minimális elemek maximumát! Ugyanezt végezd el az oszlopokkal is!Határozd meg, hogy egy adott mátrixnak van-e nyeregpontja (nyeregpontnak olyan

elemet nevezünk, amelyik legkisebb a saját sorában, és legnagyobb az oszlopában.)Írj programot, mely bekér 25 számot egy 5x5-ös mátrixba, és megszámolja a

pozitív és negatív számokat!Írj programot, amely egy 11x11-es mátrix első sorában és oszlopában tárolja a

számokat 1-től 10-ig, majd kiírja a szorzótáblát!

46

C Rekord típus

Mintapéldák1.) Írjunk programot, amely lehetőséget ad 1 tanuló nevének, osztályának és átlagának bekérésére. A tetszőleges adatok beolvasása után írassa ki a képernyőre formázottan az első sortól kezdődően középre igazítva.


Bemenő adatok:tanulo: rekord típusú változó, három mezője van:

nev: szöveg típusú változó, a tanuló nevét tartalmazzaoszt: egész szám, a tanuló osztályát tartalmazzaatl: valós szám, a tanuló átlagát tartalmazzaKimenő adatok:

Nincs, a bemenő adatot íratjuk ki a képernyőreMegoldás logikája:

A tanulo rekordnak három mezője van. Az elemekre úgy hivatkozhatunk, hogy a rekord azonosítója után ponttal elválasztva írjuk a mező nevét. A rekord egyes mezőire úgy hivatkozunk, mint ha azok egyedi változók lennének. Például tanulo.nev a tanuló rekord nev mezőjét jelenti.



Változóktanulo: rekord

(nev: szövegoszt: egészatl:valós)

program rekord1{adatok beolvasása: }be: tanulo.nevbe: tanulo.osztbe: tanulo.atl{adatok kiírása: }ki: tanulo.nevki: tanulo.osztki: tanulo.atl

program vége.


program rekord1;uses crt;

var{a tanuló rekord definiálása:}

tanulo: recordnev: string;oszt:integer;atl: real;

end;

47

beginclrscr;{adatok beolvasása:}Write ('Kérem a nevét: ');Readln (tanulo.nev);Write ('Melyik osztályba jár?: ');Readln (tanulo.oszt);Write ('kérem az átlagát: ');Readln (tanulo.atl);clrscr;{adatok kiírása:}Writeln ('név: ':33, tanulo.nev);Writeln ('osztály: ':33, tanulo.oszt);Writeln ('átlag: ':33, tanulo.atl);Readkey;

end.2.) Hozzunk létre egy datum (ev, ho, nap) nevű változót! Beolvasáskor ellenőrizzük, hogy dátumnak megfelelő adatot írtunk-e! (Minden hónapot tekintsünk 31 naposnak!)


Bemenő adatok:datum: rekord típusú változó, három mezője van:

ev: egész szám, az évet jelentiho: egész szám, a hónapok számát jelentinap: egész szám, a napot jelentiKimenő adatok:

Nincs, a bemenő adatot íratjuk ki a képernyőreA megoldás logikája:

Beolvassuk a dátum három mezőjét, (év/ hó/ nap), majd rendre ellenőrizzük, hogy a megfelelő intervallumban vannak-e. Ha nem, akkor újra beolvassuk a hibás adatot, és újra ellenőrizzük, egészen addig, amíg helyes adatokat írunk.



Változók:datum: rekord

(ev, ho, nap: egész)program rekord2;

be: datum.ev, datum.ho, datum.nap{év ellenőrzése}ha (datum.ev<1970) vagy (datum.ev>2010) akkor

ki: 'biztos jó évet írtál?'ciklus

be: datum.evamíg (datum.ev<=2010) és (datum.ev >=1970)ciklus vége

elágazás vége

48

{hónap ellenőrzése}ha (datum.ho<1) vagy (datum.ho>12) akkor

ki: 'biztos jó a hónap száma?'ciklus

be: datum.hoamíg (datum.ho<=12) és (datum.ho>=1);ciklus vége

elágazás vége{nap ellenőrzése}ha (datum.nap<1) vagy (datum.nap>31) akkor

ki: 'biztos jó napot írtál?'ciklus

be: datum.napamíg (datum.nap<=31) és (datum.nap>=1);ciklus vége

elágazás vége{hónap kiírása a képernyőre}ki: datum.ev, datum.ho, datum.nap

program vége


program rekord2;uses crt;

vardatum : record

ev, ho, nap: word;end;

beginclrscr;writeln ('kérem a dátumot év/hó/nap formában, 1970 és 2010 közötti évet tudsz beírni! ');read (datum.ev, datum.ho, datum.nap);{év ellenőrzése}if (datum.ev<1970) or (datum.ev>2010) thenbegin

writeln ('biztos jó évet írtál?');repeat

write ('év: ');read (datum.ev);

until (datum.ev<=2010) and (datum.ev >=1970);end;{hónap ellenőrzése}if (datum.ho<1) or (datum.ho>12) thenbegin

writeln ('biztos jó a hónap száma? ');repeat

write ('hó:');read (datum.ho);

until (datum.ho<=12) and (datum.ho>=1);end;

49

{nap ellenőrzése}if (datum.nap<1) or (datum.nap>31) thenbegin

writeln ('biztos jó napot írt l? ');repeat

write ('nap:');read (datum.nap);

until (datum.nap<=31) and (datum.nap>=1);end;{hónap kiírása a képernyőre, pozicionálással}writeln;writeln ('a beírt hónap: ':30,datum.ev,'.', datum.ho,'.', datum.nap,'.');readkey;

end.

50

D Definiált típusJellemzők:A Pascalban lehetőség van az alaptípusokon kívül saját, ún. felhasználói típusok definiálására. Ehhez a type kulcsszót kell használni a program deklarációs részében:

type sajáttípus=alaptípus;

Először a létrehozandó új típus azonosítóját kell megadni, majd egyenlőségjel után egy már létező típus azonosítója következik. Ezután kell az új típust változókhoz hozzárendelni. A saját típus létrehozását elsősorban összetett típusok esetében alkalmazzuk.

Rekordtípus

Mintapéldák:1.) Írjunk programot, amely lehetőséget ad egy személy nevének, születési dátumának és születési helyének bekérésére. A tetszőleges adatok beolvasása után írassa ki a képernyőre!


Bemenő adatok:datum: rekord típusú változó, három mezője van:

ev: egész szám, az évet jelentiho: egész szám, a hónapok számát jelentinap: egész szám, a napot jelenti

szem: rekord típusú változó, három mezője van: nev: szöveg típusú változó, a személy nevét tartalmazzaszd: datum típusú változó, a személy születési dátumaszh: szöveg típusú változó, a személy születési helyeKimenő adatok:


A C alfejezetben megismert rekord típust használjuk! Két rekord együttes használatára van szükség, a szem rekordban használnunk kell a datum –ot, ezért létrehozzuk a datum típust, a fejezet elején bemutatott módon!



Típusdatum: rekord

(ev, ho, nap: egész)Változók:

diak: rekord(nev: szövegszd: datum { datum típust az szd változóhoz rendeli}szh: szöveg)

51

program tipus1ki: ’ kérem a személy adatait: ’be: diak.nev{praktikus lehet itt is a dátum ellenőrzése, segítségül lásd a C.2-es mintapéldát! }be: diak.szd.evbe: diak.szd.hobe: diak.szd.napbe: diak.szhki: ’a személy adatai: ’ki: diak.nevki: diak.szd.evki: diak.szd.hoki: diak.szd.napki: diak.szh

program vége.


program tipus1;uses crt;

typedatum = record

ev,ho,nap: word;end;

vardiak: record

nev: string[20];szd: datum; { datum típust az szd változóhoz rendeli}szh: string[20];

end;begin

clrscr;writeln ('kérem a személy adatait! ');writeln ('a születési dátumot év/hó/nap formában írd! ');writeln; {üres sor}{ A with utasítás magjában nem kell kiírnunk a rekord azonosítóját:}with diak dobegin

write ('Név: ');readln (nev);write ('születési dátuma: ');readln (szd.ev, szd.ho, szd.ev);write ('születési helye: ');readln (szh);

end;writeln;writeln ('a beírt személy adatai: ');with diak dobegin

writeln (nev);writeln (szd.ev, szd.ho, szd.nap);writeln (szh);

end;end.

52

2.) Írjunk programot, amely egy osztály tanulóinak adatait (név/ anyja neve/ születési dátum/ születési hely) kéri be, majd kiírja az osztályban járó tanulók nevét!


Bemenő adatok:n: egész szám, az osztály létszámadatum: rekord típusú változó, három mezője van:

ev: egész szám, az évet jelentiho: egész szám, a hónapok számát jelentinap: egész szám, a napot jelenti

szem: rekord típusú változó, három mezője van: nev: szöveg típusú változó, a tanuló nevét tartalmazzaan: szöveg típusú változó, a tanuló anyja nevét tartalmazzaszd: datum típusú változó, a tanuló születési dátumaszh: szöveg típusú változó, a tanuló születési helye

diakok: n elemű sorozat, a tanulók személyes adataival, elemei szem típusúakKimenő adatok:


Az előző példához hasonlóan létrehozzuk a szem típust, majd a már megismert módon definiálunk egy tömböt, aminek elemei szem típusúak lesznek. A tömb elemeire való hivatkozásnál meg kell adjuk, hogy a tömb hányadik elemének, melyik mezőjére vagyunk kíváncsiak, például a harmadik diák nevét a diakok(i).nev adja.



Típusdatum: rekord

(ev, ho, nap: egész)diak: rekord

(nev: szövegan: szövegszd: datum { datum típust az szd változóhoz rendeli}szh: szöveg)

Változók:n,i: egészdiakok: tomb(1..n: diak)

program típus2be: nciklus i:=1-től n-ig

be: diakok(i).nev, diakok(i).an{praktikus lehet itt is a dátum ellenőrzése, segítségül lásd a C.2-es mintapéldát! }be: diakok(i).szd.evbe: diakok(i).szd.hobe: diakok(i).szd.napbe: diakok(i).szh


ki: diakok(i).nevciklus végeprogram vége.

53


program tipus2;uses crt;

typedatum = record

ev, ho, nap: word;end;diak= record

nev: string [20];an: string [20];szd: datum;szh: string [20];

end;var

i,n: integer;diakok: array [1..50] of diak;

beginclrscr;write ('hány diák jár az osztályba? ');readln (n);clrscr;writeln ('kérem a diákok adatait! ');writeln ('a születési dátumot év/hó/nap formában írd! ');writeln; {üres sor}for i:=1 to n do

with diakok[i] dobegin

write ('Név: ');readln (nev);write ('Anyja neve: ');readln (an);write ('születési dátuma: ');readln (szd.ev, szd.ho, szd.ev);write ('születési helye: ');readln (szh);

end;writeln;writeln ('az osztályba járó diákok: ');writeln;for i:=1 to n do

with diakok[i] do writeln (nev);readkey;

end.

54

Halmaztípus:

Mintapéldák1.) Írjunk programot, mely bekér egy számot, és eldönti, hogy a szám 1 és 5 között van-e?


Bemenő adatok:i: a beolvasott szám, egész típusú változó,

Kimenő adatoknincs, szöveges választ adunk

A megoldás logikája:Az eddig megismert módtól eltérően oldjuk meg a feladatot. Létrehozunk egy felsorolt típust, melynek elemei 1-től 5-ig terjedő egész számok. Ellenőrizzük, hogy a beolvasott szám eleme-e (in) ennek a halmaznak. Ha igen, akkor, kiíratjuk, hogy a szám megfelel a követelménynek, különben meg azt, hogy nem megfelelő a szám.



Konstans jegy=[1..5]

változóki: egész

program halmazok1be: iha (i eleme jegy) akkor ki: ’ a szám megfelel a feltételeknek’

különben ki: ’ nem megfelelő a szám’elágazás vége

program vége.


program halmazok1;uses crt;

constjegy=[1..5];

vari: integer;

beginclrscr;write ('kérem a jegyet: ');readln (i);if (i in jegy) then write ('a szám megfelel a feltételeknek’)

elsewriteln (’ nem megfelelő a szám’);readkey;

end.

55

2.) Írjunk programot, amely egy beolvasott szövegben felhasznált betűket írja ki ABC sorrendben, egy betű csak egyszer szerepeljen!


Bemenő adatok:s: a beolvasott szöveg, szöveg típusú változó,

Kimenő adatoknincs, képernyőre íratjuk ki az eredményt

A megoldás logikája:A feladathoz definiálunk egy halmazt, amelyet először beállítunk üresre, majd a betűket sorban belerakjuk ebbe a halmazba. Végül egy for ciklus segítségével végignézzük, hogy az ABC melyik betűje van ebben a halmazban (in). Ha az adott betű benne van a halmazban, kiírjuk a képernyőre.



Konstans betu = ['A'..'Z','a'..'z']; {az ABC kis és nagybetűit tartalmazó felsorolt típus}

Típusnagybetu = 'A'..'Z';

Változók:h: halmaz(nagybetu); {halmaz definiálása}s: szöveg;i: egész;ch: karakter;

program halmaz1ki: 'Írj be egy mondatot: 'be: süres (h)ciklus i:=1-töl hossz(s)- ig

ha s[i] eleme betu akkor h:=h+[nagybetűvé(s[i])]elágazás vége

ciklus végeki: 'A felhasznált betűk: 'ciklus ch:='A' –től 'Z' -ig

ha ch eleme h akkor ki: ch:2elágazás vége


56


program halmazok1;uses crt;

constbetu = ['A'..'Z','a'..'z'];

typenagybetu = 'A'..'Z';

varh: set of nagybetu; {halmaz definiálása}s: string;i: integer;ch: char;

beginclrscr;write ('Írj be egy mondatot: ');readln (s);h:=[]; {a h halmaz legyen üreshalmaz}for i:=1 to length (s) do {végignézzük az s szöveg betűit}

{ha a karakter betű, akkor átváltjuk nagybetűvé és betesszük a h halmazba}if s[i] in betu then h:=h+[upcase(s[i])];

write ('Felhasznált betűk:');for ch:='A' to 'Z' do {vizsgálunk minden karaktert a-tól z-ig}

{ha a vizsgált betű benne van a h halmazban, kiíratjuk a képernyőre}if ch in h then write (ch:2);

writeln;readkey;

end.

57

FeladatokÍrj programot, mely autók adatait (rendszám, típus, szín) tartja nyílván egy 100

elemű tömbben!Készíts programot, amely kiír egy menüt:

névsor kiírásaúj diák hozzáadásadiák törlésekilépés a programból

majd a választott menüpont alapján végrehajtja az adott műveletet utána ismét kiírja ezt a menüt. A diákokról tárold a nevüket, születési évüket és a nemüket (fiú, lány). A diákokat a programban egy 100 elemű tömbben tárold.

Minden munkatársnak feljegyezzük a nevét és azt, hogy milyen munkát képes elvégezni. Az egyes sorozatokat rendezve tároljuk. Készíts egy összesítést, arról, hogy milyen munkát kik tudnak elvégezni a munkacsoportban!

Hat barát megvitatja ki melyik évben járt 1960 és 1994 között Spanyolországban. Mindenki bediktálja a nevét, és az évszámot, amikor ott járt. Mely években nem járt senki Spanyolországban a megadott időszakban? Van-e a barátok között 2, aki ugyanabban az évbe járt ott. Ha igen írja ki az évszámot, és a nevüket!

Kérj be karaktereket billentyűzetről, mindaddig, míg ESC-et nem ütnek. Ekkor jelenítsd meg ABC sorrendben először azokat a betűket, amelyeket leütöttek, majd azokat amelyeket nem ütöttek le. Minden betűt csak egyszer írj ki, és a nagy és kisbetűket ne különböztesd meg!

Olvass be három szöveget. Írd ki azokat a betűket, melyek Szerepelnek valamelyik szövegbenMindenik szövegben szerepelnekEgyik szövegben sem szerepelnek

Írj programot, mely beolvassa és kiértékeli a tippelt lottószámokat. Tippelni 1 és max között lehet, és Húzásszám darabszámot lehet beütni. (A program ötös, hatos lottóra is használható). A nyerő számokat konstansként adjuk meg. Beolvasáskor csak akkor fogadjuk el a beütött tippet, ha az tényleg szám és 1 és max között van. Két egyforma tippet ne engedjünk beütni!

Három játékos mindegyike mond 10 számot, 100 és 200 között. Kérd be ezeket a számokat, de ügyelj arra, hogy minden játékosnak pontosan 10 darab 100 és közötti száma legyen! A program írja ki, hogy mely számok hangzottak el, majd írja ki azokat a számokat, melyeket mindegyik játékos mondott!

58

I.5 Eljárások és függvényekJellemzők:A Pascalban lehetőség van arra, hogy ha a program futása során, több helyen is ugyanazt az utasítássorozatot kell végrehajtani, akkor ezt az utasításcsoportot egy alprogramba foglalhassuk. Kétféle alprogramot hozhatunk létre: eljárást vagy függvényt. Az eljárások és függvények megadása a program deklarációs részében történik.

A Eljárások

Mintapéldák:1.) Írjunk programot, mely bemutatja, hogy mit tesz a program, ha ugyanolyan nevű a lokális és globális változónk is!


Bemenő adatok:v: tetszőleges változó, legyen egész szám

Kimenő adatokNincs, a bemenő változót íratjuk ki a képernyőre



Változók:v: egész

Eljárás alprVáltozók

v: egészv:=888ki: v

Eljárás végeProgram proba

v:=555ki: valprki:v

Program vége


program proba;uses crt;

varv: integer;

procedure alprg;var

v: integer;begin

v:=888; {a változó értéke legyen 888, és írassuk is ki}writeln ( 'Lokális V nevű változó értéke: ',v);

end;

59

begin {főprogram}clrscr;v:=555; {a változó értéke legyen 888, és írassuk is ki}writeln ('Globális V nevű változó értéke: ',v);alprg; {hívjuk meg az eljárást}writeln (''Globális V nevű változó értéke: ',v);readkey;

end.

Megoldás eredménye:

A program kiírja először az 555-t, majd a 888-at végül ismét az 555-t.2.) Írjunk eljárást, mely kiszámítja egy kör területét és kerületét!


Bemenő adatok:r: a kör sugara, valós szám

Kimenő adatokk: a kör kerülete, valós számt: a kör területe, valós szám

A megoldás logikája:Külön alprogramban (eljárásban) kiszámoljuk a kör kerületét, és a területét. A főprogramunkban a megfelelő adatokkal, erre az eljárásra hivatkozunk.



Változók:r: valóskerulet, terulet: valós

Eljárás kor (r: valós, változó k,t: valós)k:=0;t:=0;ha r>0 akkor

t:=r*r*pi;ki: 'a kör területe: 'ki: tk:=2*r*pi;ki: 'a kör kerülete: 'ki: k

elágazás végeProgram korok

be: rkor (r,kerulet,terulet); {eljárás hívása}

Program vége.


program korok;uses crt;

varr: real;terulet,kerulet: real;

60

{a kimenő változókat a var után kell deklaráljuk }procedure kor (r: real;var k,t: real);begin

k:=0;t:=0;if r>0 then begin

t:=Sqr (r)*pi;writeln ('a kör területe: ',t:0:2);k:=2*r*pi;writeln ('a kör kerülete: ',k:0:2);

end;end;begin

write ('kérem a kör sugarát');readln(r);kor(r,kerulet,terulet); {eljárás hívása}

end.3.) Írjunk eljárást, amely felcseréli két tetszőleges változó értékét!


Bemenő adatok:x,y: 2 egész szám

Kimenő adatokNincs, a bemenő adatot íratjuk ki a képernyőre

A megoldás logikája:A cseréhez szükségünk van egy segédváltóra, legyen ez s. Az s-értéke legyen egyenlő x értékével, ezután az x értéke legyen egyenlő y értékével, végül y legyen egyenlő s –el!

4.) Írjunk programot, amely létrehoz egy véletlen számokból álló 10 elemű tömböt, kiírja az elemeit, majd minden elemét megszorozza 2-vel, és újra kiírja azokat!


Bemenő adatok:a: 10 egész számból álló sorozat

Kimenő adatokNincs, a bemenő adatot íratjuk ki a képernyőre

A megoldás logikája:Külön alprogramban (eljárásban) beolvassuk a tömb elemeit. A főprogramunkban a megfelelő adatokkal, erre az eljárásra hivatkozunk.



Változók:i: egésza:tömb (1..10: egész)

Eljárás kiírciklus i:=1.től 10-ig

ki: a(i)ciklus vége

Eljárás vége

61

Program tombkiiras_alprogrammal;ciklus i:=1-től n-ig

a(i):=véletlenszám(99)+1ciklus végekiírciklus i:=1-től n-ig

a(i):=2*a(i)ciklus végekiír

program vége.


program tombkiiras_alprogrammal;uses crt;

constn=10;

vari:integer;a:array [1..n] of integer;

procedure kiir; begin

write ('A tömb elemei: ');for i:=1 to n do write (a[i],' ');writeln;

end;begin

for i:=1 to n do a[i]:=random (99)+1; {tömb előállítása}kiir; {tömb kiírása alprogrammal: }for i:=1 to n do a[i]:=2*a[i]; { tömb megváltoztatása}kiir; { tömb kiírása ismét alprogrammal: }

end.5.) Írjunk eljárást amely egy beolvasott dátumot ellenőriz!


Bemenő adatok:d: a beolvasott dátum

Kimenő adatokNincs, szöveges választ adunk

Megoldás logikájaEgy eljárást írunk, amiben beolvassuk a dátumot, és egyben ellenőrzünk is.



Konstans {30 illetve 31 napos hónapok számai}hho=[1,3,5,7,8,10,12];rho=[4,6,9,11];

Típusdatum = rekord

(ev, ho, nap: egész)Változók:

d: datum;

62

Eljárás datumolvas (változó d: datum)Be: d.ev, d.ho, d.napha (d.ev<1970) vagy (d.ev>2010) akkor {Először az évet ellenőrizzük}

ki: 'biztos jó évet írtál?'ciklus

be: d.ev;amíg (d.ev<2010) és (d.ev >1970)ciklus vége

elágazás végeha (d.ho<1) vagy (d.ho>12) akkor {a hónap száma 1 és 12 között kell legyen!}

ki: 'biztos jó a hónap száma? 'ciklus

be: d.hoamíg (d.ho<=12) és (d.ho>=1)ciklus vége

elágazás végeha (d.ho eleme hho) akkor max:=31 különben {beállítjuk a hónap max napját}

ha (d.ho eleme rho) akkor max:=30 különbenha (d.ho =2) és (d.ev mod 4 = 0) akkor max:=29 különben {szökőév vizsgálata}ha (d.ho=2) és (d.ev mod 4 <>0) akkor max:=28

elágazás végeha (d.nap<1) vagy (d.nap>max) akkor

ki: 'biztos jó napot írtál? ';ciklus

be: d.napamíg (d.nap<=max) és (d.nap>=1)ciklus vége

elágazás végeki: 'a beolvasott dátum: 'ki: d.ev,'. ',d.ho,'. ',d.nap,'

eljárás vége.Program datumell

datumolvas (d)Program vége.


program datumell;uses crt;

consthho=[1,3,5,7,8,10,12];rho=[4,6,9,11];

typedatum = record

ev,ho,nap: word;end;

vard: datum;

63

procedure datumolvas (var d: datum);begin

read (d.ev, d.ho, d.nap);if (d.ev<1970) or (d.ev>2010) thenbegin

writeln ('biztos jó évet írtál?');repeat

write ('év: ');read (d.ev);

until (d.ev<2010) and (d.ev >1970);end;if (d.ho<1) or (d.ho>12) thenbegin

writeln ('biztos jó a hónap száma? ');repeat

write ('hó:');read (d.ho);

until (d.ho<=12) and(d.ho>=1);end;if (d.ho in hho) then max:=31 elseif (d.ho in rho) then max:=30 elseif (d.ho =2) and (d.ev mod 4 = 0) then max:=29 elseif (d.ho=2) and (d.ev mod 4 <>0) then max:=28;if (d.nap<1) or (d.nap>max) thenbegin

writeln ('biztos jó napot írtál? ');repeat

write ('nap:');read (d.nap);

until (d.nap<=max) and (d.nap>=1);end;writeln;write ('a beolvasott dátum: ') ;writeln (d.ev,'. ',d.ho,'. ',d.nap,'.');

end;begin

clrscr;write ('kérem a dátumot!');datumolvas(d);readkey;

end.

64

B Függvények

Mintapéldák1.) Írjunk függvényt, mely eldönti egy valós számról, hogy pozitív-e, vagy sem! Írjunk programot, amely eldönti egy másodfokú egyenletről, hogy van-e két megoldása!


Bemenő adatok:a,b,c: a beolvasott valós számok

Kimenő adatokketgyok: logikai változó, igaz, ha az egyenletnek két megoldása van

Megoldás logikája:A pozitív függvény egy logikai értéket ad vissza, igaz, ha a szám pozitív, ellenkező esetben pedig hamis lesz.



Változóka,b,c: valósketgyok: logikai

függvény pozitiv (szam: valós): logikaipozitiv:=szam>0

függvény végeprogram pozitiv

be: a,b,cketgyok:=pozitiv(b*b-4*a*c)ha ketgyok akkor ki: ’két megoldása lesz az egyenletnek!’

program vége.


program pozitivPR;uses crt;

vara,b,c: real;ketgyok: boolean;

function pozitiv (szam: real):boolean;begin

pozitiv:=szam>0;end;begin {főprogram}

clrscr;writeln ('kérem az együtthatókat');read (a,b,c);ketgyok:=pozitiv (sqr(b)-4*a*c);if ketgyok then writeln ('a feladatnak két megoldása van!')

else writeln ('nincs két megoldás’);readkey;

end.

65

2.) Készítsünk egy függvényt, amely megszámolja, hogy egy megadott szövegben hány szóköz van és ezt a számot adja vissza!


Bemenő adatok:s: a beolvasott szöveg

Kimenő adatokA függvény által visszaadott érték lesz az eredmény.

Megoldás logikájaA h változó jelentse a szóközök számát! A h-t tegyük egyenlővé 0-val, majd nézzük végig a szöveget, ha találunk szóközt benne, akkor h értékét növeljük 1-gyel! Ha a teljes szöveget megvizsgáltuk, a függvény visszaadott értékét tegyük egyenlővé h-val.



Változóks: szöveg

függvény helyekszama (x:szöveg):egész;(változó i,h:egész) {lokális változók}

h:=0;ciklus i:=1-től hoszz(x) –ig {a mondatunk minden karakterét ellenőrizzük}

ha x[i]=' ' akkor h:=h+1helyekszama:=h

elágazás végeciklus vége

függvény végeprogram szokozok {főprogram}

be: ski: 'A mondatban ',helyekszama(s),' szóköz van.' {függvény meghívása}

program vége.


program szokozok;uses crt;

vars: string;

{Írjuk meg a helyekszama nevű függvényt! Bemenő paramétere egy szöveg, visszaadott értéke pedig egész szám lesz}function helyekszama (x: string):integer;var

i,h:integer; {lokális változók}begin

h:=0;for i:=1 to length(x) do {a mondatunk minden karakterét ellenőrizzük}

if x[i]=' ' then h:=h+1;helyekszama:=h;

end;

66

begin {főprogram}clrscr;write ('Írj be egy mondatot: ');readln (s);writeln ('A mondatban ',helyekszama(s),' szóköz van.'); {függvény meghívása}readkey;

end.3.) Írjunk függvényt egy szám faktoriálisának kiszámítására!


Bemenő adatok:n: egész szám

Kimenő adatokA fakt függvény által visszaadott érték lesz az eredmény



változókn: egész

függvény fakt (szam: egész): valós;(változók i: egész;f: valós)f:=1ciklus i:=1 –től szam –ig f:=f*ifakt:=f

függvény végeprogram faktorialis {Főprogram}

be: nki: 'n! = 'ki: fakt(n):8:1

program vége.


Program faktorialis;uses crt;

Varn: integer;

Function fakt (szam: integer): real;Var

i: integer;f: real;

beginf:=1;for i:=1 to szam do f:=f*i;fakt:=f;

end;Begin {Főprogram}

write ('Írj be egy számot: ');read (n);write ('n! = ');writeln (fakt (n):8:1);readkey;

end.67

FeladatokÍrj eljárást mely, az átadott karakterláncból kitörli az összes megadottal egyező

részláncot!Írj egy eljárást, mely egy szorzótáblát jelenít meg a képernyőn! A tényezők 1 és 10

közötti számok.Írj egy eljárást, mely paraméterként megkap három számot, és

Azokat rendezve kiírja a képernyőreAzokat rendeziVisszaad egy logikai értéket, hogy a három szám rendezett-e!

Írj Nyújt eljárást, amely a megadott számot megnyújtja (megszorozza) a megadott értékkel!

Írj eljárást, mely bekér három nevet, és rendezi ezeket növekvő sorrendbe!Írj eljárást és/vagy függvényt a következő feladatok megoldására:

Egy téglalap területének számítása, a téglalap oldalai alapjánValós szám köbgyökének számításaInch konvertálása centiméterréKét karakterlánc közös karaktereinek meghatározásaKarakterlánc kiírása fordítvaKarakterlánc tömörítése, szóközöket kivesszük belőle

Írj 3 függvényt:Signum(x), a szám előjelét adja vissza,Reciprok(x), egy szám reciprokát adja visszaNegyzet(x) .egy szám négyzetét adja vissza!

Írj 2 függvényt:VektAbs(x,y), egy vektor (x,y) koordinátájú vektor abszolutértékét adja vissza.Hatvany(a,n), egy valós alap egész kitevőjű hatványát adja vissza.

Írj függvényt, melynek bemeneti változója egy szám, és visszaadja az első nála nagyobb prímszámot!

Írj UPPER azonosítójú függvényt, amely egy betű karaktert nagybetűre konvertál Ha a bemenő paraméter nagybetű, akkor változatlanul hagyja, ha kisbetű, akkor annak nagybetű megfelelőjét adja vissza.

Írj KICSI azonosítójú függvényt, amely egy betű karaktert kisbetűre konvertál. Ha a bemenő paraméter kisbetű, akkor változatlanul hagyja, ha nagybetű, akkor annak kisbetű megfelelőjét adja vissza.

Írj függvényt, mely visszaadja a paraméterként megkapott karakterlánc utolsó 5 karakterét!

Írj MAX2(x,y) kétváltozós függvényt, amely a két adott szám értéke közül a nagyobbikat adja vissza!

Írj MAX3(x,y,z) háromváltozós függvényt, amely a három adott szám értéke közül a legnagyobbikat adja vissza!

Írj függvényt, amely bemenete egy háromszög három oldalának hossza, és igaz logikai értékkel tér vissza, ha a háromszög derékszögű!

Írj függvényt mely visszaadja, hogy egy megadott karakterláncban a megadott karakterekből mennyi szerepel!

68

II Elemi programozási tételekAz elemi programozási tételek egy sorozathoz egy elemet rendel.A feladatoknak csak a feldolgozó eljárását találod itt. Az adatok beolvasására, illetve kiírására csak a Beolvas és Kiír eljárással utalunk. Lásd: I fejezet

II.1 SorozatszámításMintapéldák1.) Egy osztály tanulóinak egyéni átlageredményei ismeretében adjuk meg az osztály átlagát!


Bemenő adatok:n: az osztály tanulóinak száma, egész számva: a tanulók átlageredményeit tartalmazó n elemű valós sorozat

Kimenő adatok: atlag: az osztály átlaga, valós szám.

A program (megoldás) logikája: Az atlag nevű változó kezdőértéke legyen 0, ezt a ciklus előtt állítjuk be, cikluslépésenként egy-egy tömbelemet hozzáadunk. A ciklus befejezése után a változót elosztjuk n-nel, így az átlagot kapjuk


Folyamatábra:

Start

atlag:=0

I:=1..n

atlag:=atlag+va[i]

Be: n,va

Ki: atlag / n

Stop

atlag:=atlag / n

69


változókn,i: egészva: tömb (1..n: valós)atlag: tömb (1..n: valós)

Program átlagbeolvas (N,va)összegzés (N, Va, atlag)ki: atlag

Program vége.Összegzés (n: egész, Va: tömb, változó atlag: valós)

atlag:=0ciklus i:=1-től n-ig

atlag:=atlag+va[i]ciklus végeatlag:=atlag/n

eljárás vége.


program atlag;uses crt;

typejegyek=array [1..30] of real;

varn,i: byte;va:jegyek;atlag: real;

Procedure beolvas (var N: integer; var Va: jegyek);begin

.............................................................{a megvalósítását lásd 1.4.B, 1.5 fejezetben}

end;Procedure atlagol (n: integer; va: jegyek; var atlag: real);begin

atlag:=0; for i:=1 to n do atlag:=atlag+va[i]; {a jegyek összegét adja}atlag:=atlag/N;

end;begin {ez a főprogram rész}

clrscr;beolvas (N,Va);atlagol (N,Va,atlag);writeln (’a jegyek átlaga: ’,atlag); {az eredmény kiíratása}

end.

70

2.) Adott egy lista, amiben egy étel receptjét tároljuk, egy másikban a megadott nyersanyagok árát! Írjunk programot, amely az kiszámolja elkészítendő étel nyersanyag költségét!


Bemenő adatok:N: a készítendő ételhez szükséges nyersanyagok száma, egész szám.X: az ételhez szükséges nyersanyag mennyiségeket tartalmazó valós sorozat.Y: nyersanyagok egységárait tartalmazó valós sorozat;

Kimenő adatok:kolt: az étel költsége, valós szám

A program logikája: a kolt nevű változó kezdőértékét legyen nulla, cikluslépésenként a két tömb egy-egy elemét összeszorozzuk, majd hozzáadjuk a kolt változóhoz. A ciklus befejezése után a változónk a keresett költséget tartalmazza.



Típuselemek= tömb (1..n: valós)

Változókn: egészx, y: elemekkolt: valós

Program koltsegBeolvas (N, X, Y)Nyersanyag (N, X, Y, kolt)Ki: kolt

program vége.Eljárás nyersanyag (N: egész, változó x,y: elemek, kolt: valós)

(változó i: egész)kolt:=0ciklus i:= 1-töl n-ig

kolt := kolt+x[i]*y[i]ciklus vége

eljárás vége;

A pascal kód:

program koltseg;uses crt;

typeelemek =array[1..100] of real;

varN: byte;kolt: real;x, y:tomb;

71

Procedure beolvas (var N:byte; var X: elemek; var Y: elemek);(Var i: byte)Begin

.............................................................{megvalósításához segítséget az 1.4.B, 1.5 fejezetekben találsz}

end;Procedure szamol (N:integer; X,Y: elemek; var kolt: real);begin

kolt:=0;for i:=1 to n do kolt:=kolt+x[i]*y[i];

end;begin {főprogram}

clrscr;beolvas (N,X,Y);szamol (N,X,Y,kolt);write (’az étel költsége: ’,kolt);

end.

72

Közös jellemzők:Egy sorozathoz hozzárendeljük az elemein végzett valamilyen művelet eredményét. Például: N szám összegét, szorzatát. A feladatok egy részénél az így kiszámított értékkel esetleg még egyszerű műveletet kell végezni. (Lásd 1-es mintapélda).

Ehhez a feladattípushoz az alábbi általános feldolgozó eljárás tartozik:


Bemenő adatok:N: egy adott sorozat elemeinek a száma, egész szám

tomb: a sorozat elemeit tartalmazó tömb, típusa a feladattól függően változikKimenő adatok:

E: a keresett értéket tartalmazza, típusa a feladattól függően változikA program logikája:

az E nevű változónak a ciklus előtt kezdőértéket adunk, cikluslépésenként egy-egy tömbelemet dolgozunk fel, például hozzáadjuk, szorozzuk. A ciklus befejezése után a változóban az eredményt kapjuk.


Folyamatábra:

Start

E:=kezdoertek

I:=1..N

E:=E muv tomb[i]

Be: N,tomb

Ki: E

Stop

73


Program sorozatszámításBeolvas (N, T)Sorozatszámítás (N, T, E)Kiír (E)

Program vége.Eljárás számítás (N:egész, T:tomb, változó E:eredmény)

E:=kezdőértékCiklus I:=1-től N-ig

E:=E művelet A(i)Ciklus vége;

Eljárás vége.

74

Feladatok1.) Határozd meg K db egész szám köbének összegét!2.) N hónapon át törlesztettünk egy kölcsönt, havonkénti fizetéssel. (Havonta különböző összegeket is fizethetünk.) Írj programot, mely megadja az eddig kifizetett összeget!3.) Adott egy tekéző sorozata (melyik fordulóban hány fát ütött. Írj programot, amely meghatározza a versenyző összesített eredményét!4.) Egy labdarugó bajnokságon ismerjük minden csapatról, hogy hányszor győzött és hányszor játszott döntetlent. Írj programot, mely megadja, melyik csapatnak hány pontja van! (győzelemért 2, döntetlenért 1 pont jár)5.) Mérjük meg N napig a lehullott csapadék mennyiséget (mm-ben). Határozd meg, hogy mennyi eső esett összesen!6.) Adott egy táblázat, amely tartalmazza az egyes városok közúton mért távolságát, valamint adott a gépkocsink átlagos fogyasztása és a használt üzemanyag egységára. Írj programot, amely bekéri az útvonalat, majd meghatározza az átlagos üzemanyag költséget!7.) Egy horgászverseny adatait egy mátrixban táruljuk, M(i,j) jelenti, hogy az i. horgász j. halfajtából mennyit fogott. Írj programot, amely kiszámítja, hogy az egyes horgászok összesen mennyit fogtak!

75

II.2 EldöntésMintapéldák1.) Döntsük el egy tanuló év végi jegyei alapján, hogy kitűnő tanuló-e!


Bemenő adatok:N: a tanuló év végi jegyeinek száma, egész szám,jegy: a tanuló tantárgyi jegyeit tartalmazó egész sorozat,

Kimenő adatok:kituno: logikai változó, igen esetén kitűnő, nem esetén nem kitűnő a tanuló,

A program logikája: Nézzük végig a jegyeket, először az elsőt, majd sorra a többit és ellenőrizzük, hogy ötös-e. Ha találtunk olyat, ami nem ötös, akkor nem kell megnézni a további jegyeket, mert van nem ötös osztályzat, azaz nem kitűnő.


Folyamatábra:

i<=N és jegy[i]=5

Start

i:=i+1

Be: N, jegy

Stop

I:=1

mind=(i>N)

Igaz

ham

is

Ki: mind

76


Típusjegyek= tömb(1..n: egész)

Program kitűnőBeolvas (N,jegy)Kitűnő (N, jegy, kitűnő)Ki: kitűnő

Program végeEljárás kitűnő (N:egész, jegy: jegyek, változó kitűnő: logikai);(változó i: egész)

i:=1;ciklus amíg (i<=n) és (jegy[i]=5)

i:=i+1;ciklus vége;mind:=(i>N);

Eljárás vége


program kituno;uses crt;

type jegyek=array[1..100] of integer;

var jegy: jegyek;i,N: integer;mind: boolean;

procedure beolvas (var N:integer; var jegy:jegyek);begin..................................................................end;procedure kituno (N:integer; jegy: jegyek; var mind:boolean);

begini:=1;while (i<=N) and (jegy[i]=5) do i:=i+1;mind:=(i>N);

end;begin

clrscr;beolvas (N,jegy);kituno (N,jegy,mind);if mind then writeln ('a tanuló kitűnő’)

else write ('a tanuló nem kitűnő');readkey;

end.

77

2.) Írjunk programot, amely bekéri egy középiskolai negyedikes osztály tanulóinak nevét, és születési dátumát, valamint az aktuális nap dátumát. Ezek alapján eldönti, hogy az adott osztály tanulói között van-e nagykorú!


Bemenő adatok:N: a tanulók száma, egész szám,d: a tanulók adatait tartalmazó sorozat,

elemei rekordok, név, dátum mezővela dátum mező is rekord, év, hó, nap mezőkkel

anap: aktuális dátum, dátum típusú (év/hó/nap)Kimenő adatok:

nk: logikai változó, igen esetén van nagykorú diák, nem esetén nincs.A program logikája:

Hasonlóan az előző mintapéldánkhoz, nézzük végig a diákok életkorát. Most azt vizsgáljuk, hogy ne legyen nagykorú. A ciklus addig fut, amíg talál egy nagykorút, vagy minden diákot megvizsgáltunk. Tehát, akkor van nagykorú diák az osztályban, ha nem kellett minden elemet megvizsgáljunk.


Folyamatábra

i<=N és d[i] nem nagykorú

Start

i:=i+1

Be: N, d

Stop

I:=1

nk:=(i<=N)

Igaz

ham

is

Ki: nk

78


típusdatum = rekord

(ev,ho,nap: egész)diak= record

(nev: szövegszd: datum)

diakok = tömb(1..n: diak)Program nagykorúBeolvas dátum (anap) {a dátumot célszerű ellenőrizni, ezért ajánlott a külön eljárás}Beolvas adatok (N, d)Eldönt (N, d, nk)Ki: nkProgram vége.Eljárás eldönt (N:egész, d: diakok, anap: dátum, változó nk: logikai)

i:=1ciklus amíg (i<=N) és (anap.ev-d[i].szd.ev<18) vagy (anap.ho- d[i].szd.ho)>0) vagy (anap.nap-d[i].szd.nap)>0) {nagykorúság ellenőrzése }

i:=i+1ciklus végenk=(i<=N)

eljárás vége.

Feladat pascal kódja

Program nagykoru;uses crt;

typedatum = record

ev,ho,nap: word;end;diak= record

nev: string[20];szd: datum

end;diakok = array[1..50] of diak;

varN,i:integer;d: diakok;nk: boolean;anap: datum;

procedure datumolvas (var anap: datum);begin..................................................................end;procedure beolvas (var N:integer; var d: diakok);begin..................................................................end;

79

procedure eldont(N:integer; d:diakok; var anap:datum; var nk:boolean);begin

write('írd be a mai dátumot: ');datumolvas(anap);i:=1;while (i<=N) and ((anap.ev-d[i].szd.ev<18) or (anap.ho-d[i].szd.ho<0) or (anap.nap-d[i].szd.nap<0)) do

i:=i+1;nk:=(i<=N);if nk then writeln('van az osztályban nagykorú')

else writeln('nincs nagykorú az osztályban');end;begin

clrscr;beolvas(N,d);eldont(N,d, anap, nk);readkey;

end.

80

Közös jellemzőkA bemenetként megadott sorozathoz egy logikai értéket kell rendelni. A vizsgált sorozat elemeiről feltételezzük: mindegyikről eldönthető, hogy rendelkezik egy bizonyos tulajdonsággal vagy nem.Ezek a feladatok 2 csoportba sorolhatók aszerint, hogy azt kell eldönteni, hogya sorozatban létezik-e egy bizonyos tulajdonságú elem, (2-es mintapélda) vagymindegyik elem rendelkezik-e ezzel a tulajdonsággal.(1-es mintapélda)

Az első csoport általános megoldása:

i. feladatvizsgálat:

Bemenő adatok:N: egy adott sorozat elemeinek a száma, egész számX: a sorozat elemeit tartalmazó tömb, típusa a feladattól függően változikT: a sorozat elemeire vonatkozó tulajdonság

Kimenő adatok: van: logikai változó, értéke igaz, ha létezik a sorozatban keresett tulajdonságú elem.

A megoldás logikája: Tesztelő ciklust használunk, vizsgáljuk, hogy van-e sorozatban adott tulajdonságú elem. Amint találtunk egyet, a ciklus leáll. Tehát, akkor van T tulajdonságú elem a sorozatban, ha a nem kellett minden elemét megvizsgáljuk.


Folyamatábra:

i<=N és nem T(X[i])

Start

i:=i+1

Be: N, X

Stop

I:=1

Van:=(i<=N)

Igaz

ham

is

Ki: van

81


TípusT=tömb(1..N: elemtípus)

Program keresBeolvas (N, X)Eldönt (N, X, van)Kiír (van)

Program vége.Eljárás eldönt (N:egész, X: T, változó van: logikai)

I:=1Ciklus amíg i<= N és nem T(tomb[i])

I:=i+1Ciklus végeVan:=(i<=N)

Eljárás vége.A második csoport általános megoldása:


Bemenő adatok:N: egy adott sorozat elemeinek a száma, egész számX: a sorozat elemeit tartalmazó tömb, típusa a feladattól függően változikT: a sorozat elemeire vonatkozó tulajdonság

Kimenő adatok: mind: logikai változó, értéke igaz, ha a sorozat minden eleme rendelkezik az adott tulajdonsággal

A program logikája: Ennél a csoportnál olyan elemet keresünk, ami nem T tulajdonságú. Ha egyet találtunk nem kell tovább vizsgálni a sorozatunkat, mivel biztosan nem lesz minden elem T tulajdonságú.


Folyamatábra:

i<=N és T(X[i])

Start

i:=i+1

Be: N, X

Stop

I:=1

Mind:=(i>N)

Igaz

ham

is

Ki: Mind

82


TípusT=tömb(1..N: elemtípus)

Program mindBeolvas (N, X)Eldönt (N, X, mind)Kiír (mind)

Program vége.Eljárás eldönt (N:egész, X: T, változó mind: logikai)

I:=1Ciklus amíg i<= N és T(X[i])

I:=i+1Ciklus végeMind:=(i>N)

Eljárás vége.

83

FeladatokAdott egy szám, írj programot, mely eldönti, hogy prímszám-e?Írj programot, mely eldönti egy szóról a hét napjainak sorozata alapján, hogy nap

neve-e!Szeptemberben minden nap megmértük a déli hőmérsékletet. Írj programot, mely

eldönti, hogy a hőmérsékletek sorozata monoton fogyó-e!A vasúti nyilvántartás tartalmazza a Savaria expresszre kiadott helyjegyeket. Írj

programot, mely eldönti hogy van-e még szabadhely a vonaton!Egy színház pénztárának nyilvántartása tartalmazza, hogy egy adott előadásra mely

helyekre keltek már el jegyek. (Jelentse pl. a B(i,j) tömbelem az i. sor j. helyét a baloldalon, J(i,j) ugyanezt a jobboldalon. A tömbelemek értéke 1, ha az adott helyre szóló jegy már elkelt, 0, ha nem). Írj programot, mely eldönti, hogy van-e két szomszédos szabad hely az előadásra!

Egy bűnügyi nyilvántartásban a zsebtolvajokról négy adatot tárolnak: magasság, szemszín, hajszín, eddig letöltött büntetés. Írj programot, mely eldönti, hogy van-e két olyan zsebtolvaj, akinek legalább két nyilvántartott adata megegyezik!

Egy bűnügyi nyilvántartásban a zsebtolvajokról négy adatot tárolnak: magasság, szemszín, hajszín, eddig letöltött büntetés. Írj programot, mely eldönti, hogy van-e két olyan zsebtolvaj, akiket a nyilvántartás nem különböztet meg!

Egy bűnügyi nyilvántartásban a zsebtolvajokról négy adatot tárolnak: magasság, szemszín, hajszín, eddig letöltött büntetés. Írj programot, mely eldönti, hogy van-e olyan zsebtolvaj, akit ez a négy adat a nyilvántartásban számon tartott minden más személytől megkülönböztet!

Adott a tanulók neve és magassága névsor szerint rendezve. Döntsük el, hogy a névsor és a magasság szerinti sorrend megegyezik-e?

84

II.3 KiválasztásMintapéldák1.) Adjuk meg egy pozitív egész számokból álló tömb első, 9-cel osztható elemének sorszámát, ha tudjuk, hogy ilyen biztosan van!


Bemenő adatok:N: A sorozat elemeinek a száma, egész számX: az egész számokat tartalmazó tömb

Kimenő adatok:sz: az első, 9-cel osztható szám indexe a tömbben.

A program logikája:A sorozat minden elemére képezzük a 9-cel való osztás maradékát mindaddig, amíg ez nagyobb 0-nál. Az első olyan elem, sorszáma, amelyre ez a feltétel nem teljesül, a feladat megoldása lesz. Ilyen elem biztosan van, ezért nem foglalkozunk azzal, hogy nincs.


Folyamatábra:


Típusszamok=tömb(1..N: egész)

Program kiválasztásBeolvas (N, X)Kiválaszt (N, X, sz)Kiír (sz)

Program vége

X[i] mod 9>0

Start

i:=i+1

Be: N, X

Stop

I:=1

Sz:=i

Igaz

ham

is

Ki: sz

85

Eljárás kiválaszt (N: egész, X: szamok, változó sz: egész)i:=1ciklus amíg X[i] mod 9 > 0

i:=i+1ciklus végesz:=i

eljárás vége


program kivalasztas;uses crt;

type szamok=array [1..100] of integer;

varX: szamok;N,sz,i: integer;

procedure beolvas (var N:integer; var X: szamok);begin..................................................................end;procedure kivalaszt(N: integer; X: szamok; var sz: integer);begin

i:=1;while(X[i] mod 9 > 0) do i:=i+1;

sz:=i;write('a sorozat ',i,'. eleme osztható kilenccel');

end;begin

clrscr;beolvas (N,X);kivalaszt (N,X,sz);readkey;

end.2.) Határozzuk meg az N (N>=1) természetes szám, legnagyobb önmagától különböző osztóját!


Bemenő adatok:N: természetes szám

Kimenő adatok:o: az N szám legnagyobb osztója

A program logikája:A számokat 1-től N-ig egy olyan sorozatnak tekintjük, amiben az elemek sorszáma megegyezik az elemek értékével. Mivel a legnagyobb osztót keressük, így az elemeket az hátulról visszafelé dolgozzuk fel. Tudjuk, hogy egy számnak a legnagyobb, önmagától különböző osztója biztos kisebb, mint a szám fele, elég csak N/2 egészrészétől vizsgálni az elemeket. N-nek képezzük a sorozat elemeivel való osztás maradékát mindaddig, amíg ez nagyobb 0-nál. Az első olyan elem, amelyre ez a feltétel nem teljesül, a feladat megoldása lesz.

86



Program osztóBeolvas (N)Kiválaszt (N, o)Kiír(o)

Program vége.Eljárás Kiválaszt (N: egész, változó o: egész)

i:=egészrész(N/2) Ciklus amíg (N mod i)>0

i:=i-1Ciklus végeo:=i

Eljárás vége.


program oszto;uses crt;

varN, i, o: integer;

procedure beolvas (var N: integer);begin..................................................................end;procedure kivalaszt (N: integer; var o: integer);begin

i:= N div 2;while N mod i >0 do i:=i-1;o:=i;write ('a legnagyobb osztó: ',o);

end;

beginclrscr;beolvas (N);kivalaszt (N,o);readkey;

end.

87

Közös jellemzőkAdott egy N elemű sorozat, és egy a sorozat elemein értelmezett T tulajdonság. Tudjuk, hogy a sorozatban van legalább egy T tulajdonságú elem A feladat, ezen elem sorszámának vagy értékének meghatározása. Az elem sorszámából az értéke nagyon könnyen meghatározható.

A feladathoz tartozó általános feldolgozó eljárás:


Bemenő adatok:N: A sorozat elemeinek a számaX: N elemű sorozat, típusa a feladattól függően változikT: A sorozat elemeire vonatkozó tulajdonág

Kimenő adatok:sorsz: az első,T tulajdonsággal rendelkező elem indexe a tömbben.

A program logikája:Tesztelő ciklust használunk, keressük a sorozat T tulajdonságú elemét. Az első ilyen elem, sorszáma lesz a feladat megoldása. Ha az elem értékére vagyunk kíváncsiak, akkor a sorozat sorszám –adik eleme lesz a megoldás. Ilyen elem biztosan van, ezért nem foglalkozunk azzal, hogy nincs.


Folyamatábra

nem T(X[i])

Start

i:=i+1

Be: N, X

Stop

I:=1

Sorsz:=i

Igaz

ham

is

Ki: sorsz

88


Program kiválasztásBeolvas (N, X)Kiválaszt (N, X, sorsz)Kiír(sz) {ha az értéke is kell: X(sorsz)}

Program vége.Eljárás kiválaszt (N:egész, X: tömb, változó sorsz: egész)

I:=1Ciklus amíg nem T(X[i])

i:=i+1ciklus végesorsz:=i

Eljárás vége.

89

FeladatokHatározd meg, egy természetes szám legkisebb, 1-től különböző pozitív osztóját!Határozd meg, az első 1 – re végződő négyjegyű prímszámot!Határozd meg azt a legnagyobb, legfeljebb háromjegyű számot, amely

számjegyeinek összege négyzetszám!Egy klubdélutánra 17 órától lehet jönni. Állapítsd meg hánykor érkezett az első

lány, ha a vendégeket érkezési sorrendben regisztrálták.Készíts egy ’hazugság-vizsgáló gépet’, amely érzékeli a figyelt személy

pulzusszámát, és ezek alapján megadja hogy mekkora volt a pulzusa, amikor először hazudott. (Valaki hazudik, ha a pulzusszáma meghalad egy adott K értéket)

Az órarend ismeretében határozd meg, mikor lesz az első informatika óra a héten!Júniusban minden nap megmértük Siófoknál a Balaton hőmérsékletét. Adj meg egy

napot, amikor a víz hőmérséklete nem érte el a 20 fokot!Ismerjük egy hónap nevét. A hónapnevek sorozata alapján mondd meg a sorszámát!A november havi névnapok sorozata alapján mondd meg, hogy hányadikán van

Katalin névnap!Egy tömbben fontos, magyar, történelmi események és évszámai szerepelnek.

Mikor mondta ki a román népgyűlés Magyarországtól való elszakadást? Írj programot történelmi évszámok keresésére!

90

II.4 Lineáris keresésMintapéldák1.) Írjunk programot, amely bekér egy természetes számot, majd kiírja a legkisebb valódi osztóját!


Bemenő adatok:N: egy természetes szám

Kimenő adatok:van: logikai változó, megmutatja, hogy van-e valódi osztója a számnaksorsz: az első valódi osztó indexe a számsorban.

A program logikája:Tesztelő ciklust használunk. Tudjuk, hogy egy számnak a legnagyobb, önmagától különböző osztója biztos kisebb, mint a szám fele, ezért elég 2-től N/2 egészrészéig vizsgálni az elemeket. N-nek képezzük a sorozat elemeivel való osztás maradékát. Ha találtunk olyat, ahol a maradék nulla, akkor van megoldás, és a megoldás a megtalált szám sorszáma, ami ez esetben megegyezik a számmal, különben nincs megoldás.

ii. Feladat megoldás


Program valódi_osztóBeolvas (N)Keres (N, sorsz)Ki: sorsz

Program végeEljárás keres (N: egész, sorsz:egész, változó van: logikai)

I:=2Ciklus amíg (i<=egészrész(N/2)) és (N mod i>0)

i:=i+1Ciklus végeVan:=(i<=N)Ha van akkor sorsz:=i

Eljárás vége.

91

Folyamatábra


program oszto;uses crt;

vari: integer;N: integer;sorsz: integer;van: boolean;

procedure beolvas (var N: integer);begin..................................................................end;

(i<=N div 2) és(N mod i>0)

Start

i:=i+1

Be: N

Stop

I:=2

Van:=(i<=N)

Igaz

ham

is

Ki: vansorsz

Van

Sorsz:= i

igaz

hamis

92

procedure keres(N: integer; var sorsz: integer; var van: boolean);begin

i:=2;while (i<= (N div 2)) and ((N mod i) >0) do i:=i+1;van:=(i<=N div 2);if van thenbegin

sorsz:=i;writeln ('a szám legkisebb valódi osztója: ',sorsz);

endelse writeln ('a szám prímszám');

end;begin

clrscr;beolvas (N);keres (N,sorsz, van);readkey;

end.2.) Egy kosárlabda csapat nyilvántartása többek között tartalmazza a játékosok nevét és magasságát. Írjunk olyan programot, amely kiírja egy 210 cm-nél magasabb játékos nevét!


Bemenő adatok:N: a csapat tagjainak száma, egész szám,k: a tanulók adatait tartalmazó sorozat,

elemei rekordok, név: szöveg, mag: egész típusú mezőkkel, melyek a játékosok nevét, illetve magasságát tartalmazzákKimenő adatok:

van: logikai változó, megmutatja, hogy van-e 210 cm-nél magasabb játékosneve: az első ilyen magas játékos neve, ha van ilyen.

A program logikája: Nézzük végig a sorozat elemeit, amíg találunk 210 cm -nél magasabb játékost. Ha találtunk ilyet, akkor a megoldás ennek a játékosnak a neve, különben nincs ilyen játékos.

ii. Feladat megoldás:


Típusjatekosok = rekord

(nev: szövegmag: egész)

Program magasságBeolvas (N,k)Keres (N, k, van, neve)Ki :van, neve

Program vége.

93

Eljárás keres(N: egész, K: jatekosok, változók van: logikai, neve:szöveg)i:=1ciklus amíg (i<=N) és (k(i).mag<=210)

i:=i+1ciklus végevan:=(i<=N)ha van akkor neve:=k(i).nevki: neve

eljárás vége.


program magassag;uses crt;

typeszoveg=string[10];jatekos=record

nev:szoveg;mag:integer;

end;jatekosok=array[1..100] of jatekos;

vark: jatekosok;i: integer;N: integer;van: boolean;neve: szoveg;

procedure beolvas(var n: integer; var k: jatekosok);begin..................................................................end;procedure keres(N: integer; k: jatekosok; var van: boolean; var neve: szoveg);begin

i:=1;while (i<=N) and (k[i].mag-210 <=0) do i:=i+1;van:=(i<=N);if van thenbegin

neve:=k[i].nev;writeln(k[i].nev,' játékos magasabb, mint 210 cm');

endelse writeln('nincs ilyen magas játékos a csapatban');

end;beginclrscr;beolvas(n,k);keres(N,k,van,neve);readkey;

end.

94

Közös jellemzőkAdott egy N elemű sorozat, és egy a sorozat elemein értelmezett T tulajdonság. Egy T tulajdonságú elem sorszámának vagy értékének meghatározása a feladat, ha egyáltalán van ilyen.



Bemenő adatok : N: A sorozat elemeinek a számaX: N elemű sorozat, típusa a feladattól függően változikT: A sorozat elemeire vonatkozó tulajdonság

Kimenő adatok:van: logikai változó, megmutatja, hogy van-e a sorozatban T tulajdonságú elemsorsz: az első,T tulajdonsággal rendelkező elem indexe a tömbben.

A program logikája:Tesztelő ciklus segítségével nézzük végig a sorozat elemeit, amíg találunk egy T tulajdonságú elemet. Ha találtunk ilyet, akkor a megoldás ennek az elemnek a sorszáma, különben nincs megoldása a feladnak.



Program keresésBeolvas (N)Keres (N, sorsz)

Program vége.Eljárás keres (N: egész, sorsz: egész, van: logikai)

I:=1Ciklus amíg (i<=N) és (nem T(X(i))

i:=i+1Ciklus végeVan:=(i<=N)Ha van akkor sorsz:=iKi: sorsz

Eljárás vége.

95

Folyamatábra

(i<=N) ésNem T(X(i))

Start

i:=i+1

Be: N

Stop

I:=1

Van:=(i<=N)

Igaz

ham

is

Ki: vansorsz

Van

Sorsz:= i

igaz

hamis

96

FeladatokA november havi névnapok sorozata alapján mondd meg, hogy van-e Botond

névnap, és ha van hányadikán!Ismerjük egy üzlet egy havi forgalmát, napi bevételét és kiadását. Adj meg egy

olyan napot, ha van, amelyik nem volt nyereséges!A Bp. Batthyány tér - Szentendre HÉV menetrend reggeli érkezési adatai alapján

adj meg egy olyan érkezési időpontot, amely 1/2 8 és 3/4 8 között van Szentendrén!Írj olyan programot, amely egy szabászat személyi nyilvántartásából kideríti az

egyik férfi dolgozó személyi számátEgy házi telefonkönyvben keress egy adott névhez tartozó telefonszámot!A véradók nyilvántartásában szerepel a személyi szám, az értesítési cím és a

vércsoport. Egy balesetet szenvedett A pozitív vércsoportú emberhez keress megfelelő donort! Írjuk át úgy a programot, hogy tetszőleges vércsoportra is működjön!

Egy elektronikus osztálykönyv tárolja a tanulók tantárgyait, a tantárgyakból szerzett osztályzatainak számát és az osztályzatokat. Írj olyan programot, amely megkeres egy olyan tanulót, akinek adott tantárgyból kevesebb, mint 2 jegye van!

Alakítsd át a programot, úgy hogy olyan tanulót keressen, akinek az adott tantárgyból van legalább egy egyese!

Egy csomag kártyát összekevertünkAdd meg, hol van egymás mellett két egyforma színű kártyaAdd meg, hol van egymás mellett két azonos figuraAdd meg, hogy hol van benne joker.Dolgozatíráskor a tanár ülési sorrendben szedte össze a dolgozatokat, és jegyezte

fel az érdemjegyeket. Keress olyan tanulót, aki ugyanúgy teljesített, mint a szomszédja.

97

II.5 MegszámolásMintapéldák1.) Adott egy pozitív egész számokból álló számsorozat. Hány páros szám van benne?


Bemenő adatok:N: A sorozat elemeinek a számaX: N elemű egész sorozat

Kimenő adatok:db: a páros számok darabszáma

A program logikája:A db változó kezdőértéke legyen nulla. Vizsgáljuk a sorozat minden elemét, ha találunk olyat, ami osztható kettővel, (ekkor páros egy szám), akkor növeljük eggyel a db értékét. A db tartalmazza a páros számok darabszámát, ha megvizsgáltuk a sorozat minden elemét.



Program páros_számokBeolvas (N, X)Számolás (N, X, db)

Program végeEljárás számolás ( N: egész, változó db: egész ) (Változó i: egész)

DB : = 0 ciklus i : = 1 -től N -ig

ha ( N mod 2) = 0 akkor DB : = DB + 1ciklus vége ki:DB

Eljárás vége

98

Folyamatábra


program paros_szamok;uses crt;

typeszamok=array[1..50] of integer;var

N, i: integer;X: szamok;db: integer;

procedure beolvas ( var N: integer; var X: szamok);begin..................................................................end;procedure szamol (N: integer; X: szamok; var db: integer);

begindb:=0;for i:=1 to N do

if X[i] mod 2 = 0 then db:=db + 1;write (' a számsorban ',db,' páros szám van');

end;begin

clrscr;beolvas (N, X);szamol (N, X, db);readkey;

end.

Start

Be: N,X

Stop

Db:=0

Db:=db + 1

ham

is

Ki: db

N mod 2 =0

igaz

hamis

I:=1..N

igaz

99

2.) Egy iskola nyilvántartásában szerepel a tanulók családjának létszáma, és átlagos havi jövedelme. Írjunk programot, amely meghatározza, hogy hány diáknak jár étkezési támogatás! Akkor jár támogatás, ha az egy főre eső havi jövedelem nem haladja meg a 60 000 forintot.


Bemenő adatok:N: Az iskolába járó tanulók létszámaX: N elemű sorozatelemei rekordok,

név: szöveg, lsz: egész, jov: egész típusú mezőkkel, melyek a diákok nevét, családjuk létszámát és családra eső átlagjövedelmét tartalmazzákKimenő adatok:

db: a támogatásra jogosult diákok száma, egész szám A program logikája:

A db változó kezdőértéke legyen nulla. Vizsgáljuk rendre a családokban az egy főre eső jövedelmet (átlagjövedelem osztva a család létszámával), ha találunk olyat, ahol ez kisebb, mint 60 000, akkor növeljük eggyel a db értékét. A db tartalmazza a támogatásra jogosult diákok számát, ha megvizsgáltuk a sorozat minden elemét.

ii. Feladat megoldás:


Program támogatásTípus

diákok = rekord(nev: szövegLsz, jov: egész)Beolvas (N, X)Számolás (N, X, db)

Program végeEljárás számolás (N: egész, X: diákok, változó db: egész)(Változó i: egész)

DB : = 0 ciklus i : = 1 -től N -ig ha ( X(i).jov div X(i).lsz <= 60 000) akkor DB : = DB + 1ciklus vége ki:DB

Eljárás vége


program paros_szamok;uses crt;

typediak=rekord

nev: string[20];lsz: integer;jov: longint;

end;diakok=array[1..100] of diak;

varN, i: integer;X: diakok;db: integer;

100

procedure beolvas( var N: integer; var X: diakok);begin

end;procedure szamol(N: integer; X: diakok; var db: integer);begin

db:=0;for i:=1 to N do

if X[i].jov div X[i].lsz <= 60000 then db:=db + 1;write (' az iskolában ',db,' diák jogosult támogatásra');

end;begin

clrscr;beolvas (N, X);szamol (N, X, db);readkey;

end.

101

Közös jellemzőkAdott egy N elemű sorozat, és egy a sorozat elemein értelmezett T tulajdonság. A feladatunk az, hogy a T tulajdonsággal rendelkező elemeket számoljuk össze.



Bemenő adatok:N: A sorozat elemeinek a számaX: N elemű sorozat, típusa a feladattól függően változikT: A sorozat elemeire vonatkozó tulajdonság

Kimenő adatok:db: egész szám, T tulajdonságú elemek száma a tömbben

A program logikája:Számláló ciklust használunk. A db változó kezdőértéke legyen nulla. Vizsgáljuk rendre a sorozat elemeit, hogy rendelkeznek-e T tulajdonsággal, ha találunk ilyet, akkor növeljük eggyel a db értékét. A db tartalmazza T tulajdonságú elemek számát, ha megvizsgáltuk a sorozat minden elemét.


Folyamatábra

Start

Be: N,X

Stop

Db:=0

Db:=db + 1

ham

is

Ki: db

T(X(i))igaz

hamis

I:=1..N

igaz

102


Típuselemek= tömb(1..N : elemtípus)

Program számolBeolvas (N, X)Számolás (N, X, db)

Program végeEljárás számolás ( N: egész, X: elemek, változó db: egész ) Változó

i: egészDB : = 0 ciklus i : = 1 -től N -ig

ha (TX(i)) akkor DB : = DB + 1ciklus vége ki:DB

Eljárás vége.

103

FeladatokHatározd meg egy adott N természetes szám osztóinak a számát!Adott egy valós számokból álló számsorozat. Számold meg, hány pozitív, nulla

illetve negatív eleme van a sorozatnak!Határozd meg, hogy hány olyan legfeljebb ötjegyű természetes szám van, aminek

az első két jegyéből alkotott szám osztója az eredeti számnak!Egy futóverseny eredményei alapján határozd meg, hányan futottak az egyéni

legjobb eredményükhöz képest jobbat!Adott egy osztály tanulóinak év végi osztályzatai. Írj programot amely

meghatározza, hogy hány tanuló bukott, illetve hány kitűnő volt az osztályban.Dobókockával százszor dobunk. Add meg , hogy hányszor dobtunk páros számot.

Alakítsd át a programot úgy hogy, meg tudja adni egy adott szám előfordulásának számát!

Egy budapesti középiskolai másodikos osztály nyilvántartásában tároljuk a diákok nevét, születési dátumát, lakcímét. Határozd meg:

Hány diák töltötte be a 16 évet!Hány diák nem budapesti!Hány diáknak lesz születésnapja az év adott hónapjában. A hónapot a felhasználó

tudja megadni!Egy informatikai cég álláspályázatot ír ki. Adottak a pályázóktól elvárt képességek,

és a pályázók által felsorolt ismeretek. Készíts programot, amely megadja, hogy hány pályázó felel meg a kritériumoknak!

104

II.6 MaximumkiválasztásMintapéldák1.) Ismerjük egy család havi kiadásait és bevételeit döntsük el, hogy melyik hónapban takarították meg a legtöbbet!


Bemenő adatok:N: A vizsgált hónapok számaX: N elemű egész sorozat elemei rekordok,

kiad: egész szám, bev: egész szám típusú mezőkkel, melyek a havi bevételt és a kiadást tartalmazzákKimenő adatok:

max: a keresett hónap sorszáma A program logikája:

Kiszámoljuk az első hónapban megtakarított összeget. A max változóban megjegyezzük az első hónap sorszámát. A többi hónap megtakarításait is végignézzük, és ha valamelyik nagyobb, mint az eddig megjegyzett, akkor azt jegyezzük meg. Ha minden elemet megvizsgáltunk, akkor a max változó a keresett hónap sorszámát fogja tartalmazni.



Típusnyilvántart = rekord

(kiad: egészbev: egész)

Program kiadásokBeolvas (N, X)Kivalasztas (N, X, max)

Program végeEljárás kivalasztas ( N: egész, X: nyilvántart, változó max: egész ) (Változó i: egész)

max : = 1 ciklus i : = 2 -től N -ig

ha ( X(max).bev - X(max).kiad < X(i).bev - X(i).kiad ) akkor max : = i ciklus vége

Eljárás vége

105

Folyamatábra


program maxkeres;uses crt;

typenyilvantart=record

bev: longint;kiad: longint;

end;osszeg = array [1..24] of nyilvantart;var

N, i: integer;X: osszeg;max: integer;

procedure beolvas(var X: osszeg; var N: integer);begin..................................................................end;

Start

Be: N,X

Stop

Max:=1

Max:=i

ham

is

Ki: max

Megtakarít(max)<megtakarít(i)

igaz

hamis

I:=2..N

igaz

106

procedure kivalaszt(N:integer; X: osszeg; var max: integer);begin

max:=1;for i:=2 to N do

if X[i].bev-X[i].kiad >X[max].bev-X[max].kiad then max:=i;write (max,'. hónapban tudtak a legtöbbet félretenni: ',X[max].bev-X[max].kiad);

end;begin

clrscr;beolvas (X,N);kivalaszt (N,X,max);readkey;

end.2.) Egy rádió reggeli időjárás jelentéséből, állapítsuk meg, melyik városban volt a leghidegebb!


Bemenő adatok:N: A felsorolt városok számaX: N elemű egész sorozat elemei rekordok,

Nev: szöveg, fok: egész típusú mezők melyek a városok nevét, illetve a mért hőfokot tartalmazzákKimenő adatok:

min: a leghidegebb város neve, szöveg típusúA program logikája:

A min változóban megjegyezzük az első város nevét. A többi városban mért hőmérsékletet is végignézzük, és ha valamelyik kisebb, mint az eddig megjegyzett, akkor azt jegyezzük meg. Ha minden elemet megvizsgáltunk, akkor a min változó a leghidegebb város nevét fogja tartalmazni.



Típushofok = rekord

(nev: szövegfok: egész)

hofokok= tömb(1..N: hofok)Program hofokok

Beolvas (N, X)Kiválasztás (N, X, min)

Program végeEljárás kiválasztás ( N: egész, X: hofokok, változó max: egész ) (Változó i: egész)

min : = 1 ciklus i : = 2 -től N -ig

ha ( X(min).fok>X(i).fok) akkor min : = i ciklus vége ki: X(min).nev

Eljárás vége

107

Folyamatábra


Program hofokokPr;uses crt;

typehofok = record

nev: string [20];fok: integer;

end;hofokok= array [1..100] of hofok;

varN: integer;X: hofokok;min: integer;

procedure beolvas (var X: hofokok; var N: integer);begin..................................................................end;procedure kivalasztas ( N: integer;X: hofokok; var min: integer);var i: integer;begin

min := 1;for i := 2 to N do

if( X[min].fok>X[i].fok) then min := i;writeln('a leghidegebb város: ',X[min].nev);

end;begin

clrscr;Beolvas ( X,N);Kivalasztas (N, X, min);readkey;

end.

Start

Be: N,X

Stop

min:=1

Min:=i

ham

is

Ki: X(min).nev

X(min).fok > X(i).fok

igazham

is

I:=2..N

igaz

108

Közös jellemzőkAdott egy N elemű sorozat A feladat ezen legnagyobb elemének meghatározása (néha csupán az értékére van szükség). Hasonló feladat – csupán a relációt kell megfordítani – a minimum-kiválasztás.



Bemenő adatok:N: A sorozat elemeinek a számaX: N elemű sorozat, típusa a feladattól függően változik

Kimenő adatok:max: egy olyan index, amelyre a max-adik elem a sorozat minden más eleménél nagyobb vagy egyenlő.

A program logikája:A max változóban megjegyezzük az első sorszámot. A sorozat további elemeit végignézzük, és ha valamelyik nagyobb, mint az eddig megjegyzett, akkor annak a sorszámát jegyezzük meg. Ha minden elemet megvizsgáltunk, akkor a max változó a legnagyobb elem sorszámát fogja tartalmazni. A sorozat legnagyobb eleme pedig a max-adik elem lesz.


Folyamatábra

Start

Be: N,X

Stop

Max:=1

Max:=i

ham

is

Ki: maxX(max)

X(max) > X(i)igaz

hamis

I:=2..N

igaz

109


Típuselemek= tömb(1..N: elemtípus)

Program maxPrBeolvasas (N,X)Maxvalasztas (N, X,max)Ki: max

Program végeEljárás Maxvalasztas (N:egész, X: elemek, változó max: egész) változó i:egész

max : = 1 ciklus i : = 2 -től N -ig

ha ( X(max) < X( i )) akkor max : = i

elágazás végeciklus vége

eljárás vége

110

FeladatokAdott egy osztályban tanuló diákok ülésrendje. Írj programot, mely megkeresi az

elsőt a névsorban!Egy kosárlabdacsapat minden játékosáról tudjuk a magasságát. Írj programot, mely

megkeresi ki a legmagasabb!Egy kézilabdacsapat minden játékosáról tudjuk az életkorát. Ki a legfiatalabb? Egy kézilabdacsapat minden játékosáról tudjuk az életkorát. Mekkora a

korkülönbség a legidősebb és a legfiatalabb játékos között?Írj programot, mely a tavalyi villanyszámlák ismeretében eldönti, hogy mikor

fizettünk a legkevesebbet!Influenzajárvány idején az osztályból otthon maradt 10 diáktól telefonon

megkérdeztük az előző napi legmagasabb hőmérsékletét. Kinek volt közülük legmagasabb?

Dobókockával százszor dobunk, melyik számot dobtuk a legtöbbször?Adott egy n elemű, egész számokból álló sorozat. Határozd meg ezt a legnagyobb

elemét – ha van- amely n-nel osztva 1-et ad maradékul!Ismerjük egy osztály tanulóinak átlagát. Írj programot, mely meghatározza a

legjobb tanuló átlagát, valamint azt, hogy a többiek mennyivel maradnak le mögötte!

111

IIIÁllományok

III.1 Szöveges állományokMintapéldák1.) Írjunk programot, mely egy létező proba.txt nevű állomány tartalmát kiírja a képernyőre!


Bemenő adatok:Poba.txt: szöveges állomány, melynek a tartalmát kiíratjuk a képernyőre

Kimenő adatok:Nincs, az állomány tartalmát íratjuk ki a képernyőre

Megoldás lépései:A szöveges állományt a változók deklarálásánál text típusként kell deklaráljuk. Az assign(f,'proba.txt'); parancs hozzárendeli az f állományhoz a merevlemezen található proba.txt állományt. Ha az állomány nem az aktuális könyvtárban található, mg kell adni az elérési útvonalát! Ezek után nyissuk meg az állományt olvasásra a reset(f); paranccsal. A {$I-} és {$I+} utasítások kikapcsolják/bekapcsolják a Pascal hibaellenőrzését, tehát azt, hogy ha a file megnyitásánál hiba keletkezik, akkor azt ne a Pascal értékelje ki, hanem mi. A megnyitás után az IOResult változó értéke 0, ha sikerült megnyitni az állományt, különben a hiba kódját tartalmazza. Ha sikerült megnyitni az állományt, akkor egy ciklus segítségével kiolvasunk belőle egy sort a readln(f,s); paranccsal, majd ezt kiírjuk a képernyőre. A ciklus ezt a két utasítást addig ismétli, amíg nem értünk az állomány végére - not eof(f). (eof = end of file). Végül a close(f) paranccsal bezárjuk az állományt.



program allomanyPr1;uses crt;var

f:text;s: string;

beginassign (f,'proba.txt'); {proba.txt f-hez való rendelése}{$I-}reset (f); {f megnyitása olvasásra}{$I+}if ioresult=0 then begin {hiba ellenőrzése}

while not eof(f) do beginreadln (f, s); {soronként olvassuk ki f tartalmát}writeln(s);

end;close(f); {f bezárása}

end;readkey;

end.

112

2.) Írjunk programot, amely az 1-es példában megadott állományhoz, hozzáfűz még néhány sort ’/’ végjelig! Ellenőrizzük le, hogy a fájl létezik-e!


Bemenő adatok:Poba.txt: szöveges állomány, melynek a tartalmát kiíratjuk a képernyőres: szöveg, melyet a proba.txt-be beírunk

Kimenő adatok:Nincs, az állomány tartalmát változtatjuk

Megoldás lépései:Először rendeljük hozzá a proba.txt állományt az f állományhoz, majd nyissuk meg az append(f) paranccsal, az így megnyitott fájlban file-mutató mely az aktuális pozíciót mutatja a file-ban az állomány végén áll. Utána ellenőrizzük, hogy sikerült-e megnyitni állományt. A végjelig való beolvasás, a már megismert módon történik. Fájlba a write(file_változó, szöveg) vagy a writeln(file_változó, szöveg) parancsokkal tudunk beírni szöveget.


Pascal kódprogram szovegtovabb;

uses crt;var

f: text;ujsor:string;

begin clrscr; assign(f,'proba.txt');{$I-} reset(f);{$I+} if ioresult=0 then begin

append(f);{f-et megnyitjuk továbbírásra}writeln('Megtaláltam a szoveg.txt fájlt,'); writeln('Most néhány sort hozzá írhatsz.');writeln('Ha vége, akkor a következő sor elejére "/" jelet írj!'); readln(ujsor);

while ujsor <> '/' do begin

writeln(f,ujsor);readln(ujsor);

end; close(f);end;

end.

113

3.) Írjunk programot, mely létrehoz egy szoveg.txt nevű text állományt az aktuális könyvtárban. Írjunk bele sorokat az üres sor végjelig. Ezután a letörölt képernyőre írassuk ki a file tartalmát, végül zárjuk be!


Bemenő adatok:s: szöveg, melyet a szoveg.txt-be beírunk

Kimenő adatok:Szoveg.txt állomány.

Megoldás lépései:Először rendeljük hozzá a szoveg.txt állományt az f állományhoz, majd hozzuk létre a rewrite(f) paranccsal, ez a parancs új állományt hoz létre, vagy egy már meglévő tartalmát kitörli és újra írásra teszi alkalmassá. A feladat többi részét a már megismert módon oldjuk meg!


Pascal kód:

program filekezeles; uses crt;

var f:text;sor: string;

beginAssign (f,'szoveg.txt');Rewrite (f); {létrehozza a filet}Clrscr;writeln ('szoveg.txt állomány feltöltése: ');writeln('ha nem akarsz már új adatot bevinni, hagyj ki egy üres sort!');repeat

Readln(sor); {bekérés billentyűzetről}Writeln(f,sor); {írás file-ba}

until sor='';Clrscr;

Reset(f); {megnyitja a filet olvasásra}while not eof(f) dobegin

Readln(f,sor); {olvasás file-ból}Writeln(sor); {írás képernyőre}

end;Close(f);

end.

114

III.2 Típusos állományokMintapéldák1.) Írjunk programot, mely egy iskola tanulóinak személyes adatait (név, születési dátum) egy állományban tárolja! Az adatokat * végjelig olvassuk be!


Bemenő adatok:diak: rekord, nev és szul mezőkkel, melyek a diákok nevét, illetve születési dátumát jelentik

Kimenő adatok:nyilv.dat, egy állomány az aktuális könyvtárban, melyben a diak típusú adatok vannak

Megoldás menete:A típusos állományok deklarációjában azt kell megadni, hogy a file soraiban tárolt adatok milyen típusúak legyenek. Az állomány file_változóhoz való rendelése, és megnyitása, illetve bezárása ugyanúgy működik, mint a szöveges állományoknál. Típusos állományba való írásnál, és olvasásnál a readln és writeln parancsokat nem használhatjuk. A végjelig való beolvasást a már megismert módon valósítjuk meg.



program tipusos_allomany;type

diak=Recordnev:string[20];szul:integer;

End;var

f: file of diak;r:diak;

beginassign (f,'nyilv.dat');rewrite (f);writeln ('Ha nincs több diák üss csillagot');Repeat

Write('Név: ');Readln(r.nev);If r.nev<>'*' then begin

Write('Született: '); Readln(r.szul);Write(f,r);

End;Until r.nev='*';Close(f);

end.

115

2.) Írjunk programot, amely a nyilv.dat file adatait beolvassa egy tömbbe!


Bemenő adatok:Nyilv.dat diak típusú állomány

Kimenő adatok:T: sorozat, elemei diak típusúak

Megoldás menete:T sorozat hosszát úgy válasszuk meg, hogy nagyobb legyen a file várható hosszánál. Ennek ellenére a ciklusfeltételben vizsgáljuk, hogy fér-e még adat a tömbbe, így a program túl hosszú file esetén sem áll le, csak nem olvassa be a file fennmaradó részét. i változó tartja nyilván, hogy hány elemet olvastunk be a file-ból. Azért használtunk elöltesztelõ ciklust, hogy ha a file üres, akkor a program ne próbáljon meg olvasni belőle.


program tipusos_allomanybol;const

Max=1000;type

diak=Recordnev:string[20];szul:integer;

End;var

f:file of diak;t:Array[1..Max] of diak;i:integer;

beginAssign(f,'nyilv.dat');Reset(f);i:=0;write(max+i);While (not Eof(f)) and (max>i) do begin

i:=i+1;Read (f,t[i]);

End;Close(f);

end.

116

Feladatok:Írj programot, mely egy szöveges állományból kitörli az üres sorokat!Írj programot, mely megszámolja egy szöveges állományban a karakterek számát!Hozz létre egy szöveges állományt, szoveg.txt néven, olvass be sorokat ’/’ végjelig.

Írasd ki a képernyőre az állomány tartalmát, majd nyomtasd ki!Írj programot, mely állományban tárolja egy vállalat havi díjas dolgozóinak

törzsadatait. A törzsadatok:Családi névUtónévBesorolásAlapfizetésPótlékTúlóraLevonásAdóelőlegAzonosító

Írj programot, mely állományban tárolja egy vállalat leltárát. A leltár adatai:Termék kódjaTermék neveEgységárMértékegység

Írj programot, mely létrehoz egy vállalat eladásaiból egy típusos állományt. A rekordokban a következő mezők vannak:

Berendezés típusaGaranciális időMegnevezésÁrEladott darabszám

Ellenőrizd, garanciális idő, ár, eladott darabszám mezőket! A helyes rekordokat írd be az állományba, a hibákat a hiba okának megjelölésével listázd!

Egy törzsállomány létrehozásához 2 féle adatot használunk:1-es típus:

TípusjelzőCikkszámMennyiségEgységárAlsó határFelső határEgyéb2-es típus

TípusjelzőCikkszámEgyéb

Írj programot, mely az adatokat egy állományban tárolja, és a hibás rekordokról listát készít!

Írj programot, mely vasútállomás menetrendjét tárolja. A program tudjon menetrendet elhelyezni a lemezen, tudjon vonatot törölni, új vonatot beírni a menetrendbe, illetve lehessen módosítani az indulási és az érkezési időket!

117

Irodalomjegyzék:

Dr. Hetényi Pálné: Számításteknikai feladtok 2000-ig I,II kötetOMIKK Budapest 1988

Angster Erzsébet: Programozás tankönyv I.,II. kötet4KÖR Bt. 1998

Kása Zoltán: Algoritmusok tervezéseStúdium Könyvkiadó, Kolozsvár, 1994

Szlávi Péter, Zakó László: Mikrológia 18,19Doina Rancea: Limbajul turbo Pascal I,II kötet

Libris, Cluj 1993Dr. Florin Muntean: Programarea calculatoarelor

Editura Didactica si Pedagocica R-A-Bucuresti, 1993

118

Bevezetés...........................................................................................................................1I Elemi programozás....................................................................................................2

I.1 Elemi utasítások.................................................................................................2Mintapéldák:..........................................................................................................2Feladatok...............................................................................................................7

I.2 Elágazások.........................................................................................................8A Kétirányú elágazás.............................................................................................8

Mintapéldák...........................................................................................................8B Többágú elágazás............................................................................................11

Mintapéldák.........................................................................................................11Feladatok.............................................................................................................16

I.3 Ciklusok...........................................................................................................17A Számláló ciklus................................................................................................17

Mintapéldák:........................................................................................................17B Elöltesztelő ciklus............................................................................................21

Mintapéldák.........................................................................................................21C Hátultesztelő ciklus.........................................................................................24


I.4 Adattípusok......................................................................................................29A Szövegfeldolgozás...........................................................................................29

Mintapéldák:........................................................................................................29Feladatok.............................................................................................................32

B Tömb................................................................................................................33Mintapéldák.........................................................................................................33Feladatok:............................................................................................................39Mintapéldák:........................................................................................................40Feladatok.............................................................................................................46

C Rekord típus.....................................................................................................47Mintapéldák.........................................................................................................47

D Definiált típus..................................................................................................51Mintapéldák:........................................................................................................51Mintapéldák.........................................................................................................55Feladatok.............................................................................................................58

I.5 Eljárások és függvények..................................................................................59A Eljárások..........................................................................................................59

Mintapéldák:........................................................................................................59B Függvények.....................................................................................................65


II Elemi programozási tételek.....................................................................................69II.1 Sorozatszámítás...............................................................................................69

Mintapéldák.........................................................................................................69Közös jellemzők:.................................................................................................73Feladatok.............................................................................................................75

II.2 Eldöntés...........................................................................................................76Mintapéldák.........................................................................................................76Közös jellemzők..................................................................................................81Feladatok.............................................................................................................84

II.3 Kiválasztás.......................................................................................................85Mintapéldák.........................................................................................................85Közös jellemzők..................................................................................................88

119

Feladatok.............................................................................................................90II.4 Lineáris keresés...............................................................................................91

Mintapéldák.........................................................................................................91Közös jellemzők..................................................................................................95Feladatok.............................................................................................................97

II.5 Megszámolás...................................................................................................98Mintapéldák.........................................................................................................98Közös jellemzők................................................................................................102Feladatok...........................................................................................................104

II.6 Maximumkiválasztás.....................................................................................105Mintapéldák.......................................................................................................105Közös jellemzők................................................................................................109Feladatok...........................................................................................................111

III Állományok.......................................................................................................112III.1 Szöveges állományok....................................................................................112

Mintapéldák.......................................................................................................112III.2 Típusos állományok.......................................................................................115

Mintapéldák.......................................................................................................115Feladatok:..........................................................................................................117

120

Documents

I - ATW.huusers.atw.hu/infokaracs/2014-15/pascal_peldak_tervezes.doc · Web viewA sorozat további elemeit végignézzük, és ha valamelyik nagyobb, mint az eddig megjegyzett,