IN-501 Bevezetés a programozásba

Oktatási segédlet, példatár

Szerkesztette: Dr. Vida Károly

DUNAÚJVÁROSI FŐISKOLA INFORMATIKAI INTÉZET

2006.

IN-501 2

Tananyag, előadás fóliák IN-501 Bevezetés a programozásba A tantárgy célja: - alapismeretek adása a számítógépes feladatmegoldáshoz,

- programtervezési, programozási elvek és módszerek tanítása 1. Számítógépes feladatmegoldás,

programozási nyelvek Egy feladat számítógépes megoldásának lépései: - A feladat egyértelmű megfogalmazása - A matematikai modell kialakítása - Adatstruktúra kialakítása, input és output adatok tervezése - Az algoritmus elkészítése és leírása - A program megírása - A program tesztelése - A program dokumentálása ”Algoritmusok + Adatstruktúrák = Programok” [1] 1.1. Az algoritmus - fogalma - követelmények - fajtái 1.2. Alapfogalmak - adatok(konstansok, változók), adattípusok - alaptevékenységek (input, output, értékadás) - vezérlőtevékenységek (szekvencia, szelekció, iteráció) 1.3. Az algoritmus megadási módjai - szöveges - folyamatábra - struktogram - szerkezeti ábra 1.4. Alapalgoritmusok 1.5. Programozási nyelvek Programnyelv: kommunikációs eszköz az ember és a

számítógép között

IN-501 3

Szg.-es program: utasítások sorozata ( szintaktika, szemantika )

A magas szintű nyelvekről: forrásprogram fordítás szintaktikai hibák tárgyprogram szerkesztés végrehajtható program pr. végrehajtás, futtatás szemantikai hibák A fejlesztő rendszerek funkciói: - szövegszerkesztés - programfordítás - programszerkesztés - nyomkövetés, hibakeresés - on-line help - programkönyvtárak kezelése - egyéb támogatások 2. A Pascal program felépítése, szerkezete A Pascal program részei: - programfej - deklarációs rész - programtörzs Az első feladat: - olvassunk be két számot - ha egyenlők, akkor adjuk össze azokat, egyébként az első kétszereséhez adjuk hozzá a másodikat program elso; var x,y: integer; z: real; begin { x és Y beolvasása } Write(’Kérem az első számot:’); ReadLn(x); Write(’Kérem a második számot:’); Readln(y); { Számítás } if x=y then z:=x+y else z:=2*x+y; { Az eredmény kiírása } Write(’z=’,z); end.

IN-501 4

2.1. A nyelv elemei Jelkészlet Betűk: a...z, A... Z Számok: 0...9 Speciális jelek: + - * / = . , : ; ’ ^ _ @ $

# < > [ ] { } szóköz ASCII vez.karakterek(0..31) Karakterpárok: <= >= <> := .. (* *) Foglalt alapszavak deklarációk, utasítások, operátorok kulcsszavai Pl. var, integer, if, then, else, and, or, end Konstansok egész szám decimális 123 -12 hexadecimális $FF $A1B valós szám -23.45E-3 0.55 8e5 karakter (jel) #32 #65 vagy ’ ’ ’A’ szöveg ’Informatika’ (0..255 hosszú) ’csengetés’ #7#7 Azonosítók változók, konstansok, típusok, eljárások, függvények

egyedi nevei képzési szabályok: - első kar betű vagy _ - másodiktól betű, szám vagy _ - első 63 kar. a meghatározó - kis és nagybetű nem különbözik hibátlan azonosítók: x, b12, B12, Max_elem, WriteLn hibás azonosítók: 2B x/y END B.5 Operátorok aritmetikai + - * / div mod logikai not and or xor összehasonlító < > = <= >= <> A program írásmódja 2.2. A program szerkezete

(modulok, blokkok, utasítások) A Turbo Pascal program egymástól független modulokból áll. A modulok egymás mellé és alá rendelt (egymásbaágyazott) blokkokból állnak. Egy modul max. 64 Kbyte méretű lehet. A lefordított pr. max. 640 Kbyte lehet.

IN-501 5

{ programfej } Program programnév; { globális hatású fordítási direktívák } { deklarációk } uses ... ; { unitok } const... ; { konstansok } type ... ; { típusok } var ... ; { változók } Procedure ...; { eljárások } Function ...; { függvények } begin { programtörzs, végrehajtási rész } { utasítások } . . end.

IN-501 6

3. Adattípusok és deklarációk 3.1. Változók deklarálása var x,y: integer; z: real; A program a változókban adatokat tárol. A változónak azonosítója, típusa és értéke van. A típus írja le a változó tulajdonságát ( a lefoglalt memóriaterület hossza és értelmezése) 3.2. Adattípusok és csoportosításuk Egyszerű adattípusok: a./ sorszámozott - egész - logikai - karakter - felsorolt - intervallum b./ valós c./ szöveg Mutató adattípus Strukturált adattípusok a./ halmaz b./ tömb c./ rekord d./ fájl e./ objektum 3.2.1. Egyszerű adattípusok a./ sorszámozott típusok - egész típusok:

típus tartomány

hely (bájt)

Byte 0 .. 255 1 Word 0 .. 65535 2 ShortInt -128 .. 127 1 Integer -32768 .. 32767 2 LongInt -2147483648 .. 2147483647 4

- logikai típus: Boolean true, false 1 bájt - karakter: Char #0 .. # 255 1 bájt - felsorolt: var irany: (fel, le, jobbra, balra); fel < le < jobbra < balra - intervallum (résztartomány) típus: var kisbetu: ’a’..’z’; ketjegyu: 10..99;

IN-501 7

b./ valós típusok

típus tartomány

pontosság hely (bájt)

Real 2.9E-39 .. 1.7E+38 11-12 6 Single 1.5E-45 .. 3.4E+38 7-8 4 Double 5.0E-324 .. 1.7E+308 15-16 8 Extended 3.4E-4932 .. 1.1E+4932 19-20 10 Comp -9.2E+18 .. 9.2E+18 19-20 8

a Real kivételével társprocesszor vagy a {$E+} direktíva kell c./ szöveg adattípus String String[hossz] 1<= hossz <= 255 var sz : String[10]; sz:=’ABC-129’;

0 1 2 3 4 5 6 7 8 9 10 #7 A B C - 1 2 9

3.3. Felhasználói típus (type) deklarálása type új_típus = létező típus ; type egesz = Integer; valos = Real; kar20 = String[20]; var x,y,z : egesz; a,b,c : valos; sz20,s : kar20; 3.4. Konstans és típusos konstans deklarálása (const) const max = 1000; ev = 1996; varos = ’Dunaújváros’; cim = ’1. Feladat’; e12 = 1.3e3; h22 = $22; const e1 : Integer = 123; k : Char = ’A’; b1 : Boolean = true;

IN-501 8

3.5. Adattípusok viszonya, konverzió Két típus között a következő reláció állhat fenn: - egyenlőség - kompatibilitás - értékadási kompatibilitás - idegen típus

IN-501 9

4. Értékadás, kifejezések Az értékadó utasítás általános alakja: változó := kifejezés ; 4.1. Műveletek - aritmetikai (+ , - , * , / , div , mod)

xa ba b

=+− x:=(a+b)/(a-b);

xa b d

a b cd=

+ ⋅ −

⋅ ⋅+ ⋅

24 5

x:=(a+2*b-d/4)/(a*b*c)+5*d x:=13; y:=3; z:= x div y; (z:=4;) c:= x mod y; (c:=1;) - bitenkénti logikai (not, and, or, xor, shl, shr) not negáció ( tagadás ) and aritmetikai és or aritmetikai vagy xor aritmetikai kizáró vagy shl eltolás balra ( shift left ) shr eltolás jobbra ( shift right ) példák: 77 = 0100 1101 41 = 0010 1001 not 41 = -42 214 = 1101 0110 77 and 41 = 9 9 = 0000 1001 77 or 41 = 109 109 = 0110 1101 77 xor 41 = 100 100 = 0110 0100 41 shl 2 = 164 164 = 1010 0100 41 shr 2 = 10 10 = 0000 1010

IN-501 10

- logikai (not, and, or, xor) not logikai negálás ( tagadás ) and logikai és ( logikai szorzás ) or logikai vagy ( logikai összeadás ) xor logikai kizáró vagy

A B not A A and B A or B A xor B false false true false false false false true true false true true true false false false true true true true false true true false

x:=true; a:=false; y:=false; b:=true; b1:= x or y and a; ( true ) b2:= (y and b) or (a or not b);( false ) - összehasonlító (< , > , = , <= , >= , <> , in) a:=22; b:=-10; c:=4.5; k:=’A’; s1:=’xyz’; (2*a-b) >= 54 true b <> -10 false k=#65 true s1 < ’xyx’ false +123 <> 123 false ’+123’ <> ’123’ true k in [’a’,’b’,’A’..’F’] true (k értéke benne van-e a halmazban?) - sztringek összekapcsolása ( + ) Műveletek rangsora (precedencia szintek)

Rangsor Operátor Operátor típusa 1. not + - előjel egyoperandusú 2. * / div mod and shl shr multiplikatív 3. + - or xor additív 4. < > = <= >= <> in összehasonlító

- az operandus a magasabb precedenciájú operátorhoz tartozik - azonos precedenciájú operátorok között a tőle balra állóhoz tartozik - a zárójelben lévő műveleteknek van elsőbbségük

IN-501 11

Az eredmény típusa:

művelet 1. operandus 2. operandus eredmény + - * egész egész egész egész valós valós valós valós valós / egész egész valós egész valós valós valós valós valós div mod egész egész egész shl shr egész egész egész not and egész egész egész or xor logikai logikai logikai + szöveg karakter szöveg = <> egész egész logikai <= >= egész valós logikai < > valós valós logikai logikai logikai logikai szöveg karakter logikai felsorolt felsorolt logikai

példák: i:=4; j:=10; b1:=true; i j w b1 4 10 true i:=i+11; 15 10 true j:=j+2*i; 15 40 true b1:=j<i; 15 40 false i és j cseréje: w:=i; 15 40 15 false i:=j; 40 40 15 false j:=w; 40 15 15 false

IN-501 12

4.2. Standard függvények és eljárások A SYSTEM unit-ban találhatók, a programból bárhol elérhetők Matematikai függvények:

Hivatkozás Jelentés argum. típusa

eredm. típusa

Abs(x) abszolút érték egész valós

argum. típusa

ArcTan(x) arkusztangens valós valós Cos(x) koszinusz x (x radiánban) valós valós Exp(x) ex valós valós

Frac(x) tört rész valós valós Int(x) egész rész valós valós Ln(x) természetes alapú logaritmus valós valós Odd(x) ha páratlan:true, ha páros:false egész logikai Pi Pi értéke valós Random véletlen számot ad vissza

a [0,1) intervallumban valós

Random(n) véletlen számot ad vissza a [0,n) intervallumban ( 0<= x <n)

egész egész

Round(x) kerekítés a legközelebbi egészre valós egész Sin(x) szinusz x (x radiánban) valós valós Sqr(x) x négyzete egész

valós argum. típusa

Sqrt(x) x négyzetgyöke valós valós Trunc(x) törtrész levágása (a 0 felé kerekítés) valós egész

Matematikai eljárás:Randomize kezdőértéket ad a véletlenszám generátornak

Megszámlálható adattípusok függvényei: Hivatkozás Jelentés argum.

típusa eredm. típusa

Chr(x) karakterképzés (#x) egész char Ord(x) x sorszáma sorsz. egész Pred(x) előző sorszámú elem sorsz. x típusa Succ(x) következő sorszámú elem sorsz. x típusa

Megszámlálható adattípusok eljárásai: Dec(x) (x:=x-1;) Dec(x,n) (x:=x-n;) Inc(x) (x:=x+1;) Inc(x,n) (x:=x+n;)

IN-501 13

Szöveg adattípus függvényei: Hivatkozás Jelentés argum.

típusa eredm. típusa

Concat(s1,s2,..) karaktrláncok összefűzése szöveg szöveg Length(s) s aktuális hossza szöveg egész Pos(s1,s) s1 kezdőpozíciója s-ben szöveg egész Copy(s,k,h) s-ből k-adik pozíciótól

h hosszú rész s:szöv. k és h egész

szöveg

Szöveg adattípus eljárásai: Delete(s,k,h) s-ből k-adik pozíciótól h hosszú rész törlése Insert(s1,s,k) s-be k-adik pozíciótól s1 beszúrása Str(x,s) x konverziója s-be Str(x:w:d,s) x konverziója s-be w hosszon, d tizedesjeggyel Upcase(ch) kisbetű konvertálása nagybetűvé (ch:char) Val(s,x,c) s szöveg konvertálása x-be c:hibakód(egész) hibátlan konverziónál c=0 (s,s1:szöveg, k,h,w,d,x,c:egész, ch:karakter)

utasítások eredmény s:=’DFK1996’; Delete(s,4,2); s ’DFK96’ s:=’DF1996’; Insert(s,3,’K-’); s ’DFK-1996’ s:=’-123.45’; Val(s,x,c); x -123.45 s:=’DF1996’; h:=Length(s); h 6 s:=’abcdabcd’; kp:=Pos(’cd’,s); kp 3 s:=’abcd’ kp:=Pos(’xy’,s); kp 0 s:=’abcdabcd’ s1:=Copy(s,3,4); s1 ’cdab’

IN-501 14

5. Standard input/output Standard perifériák input: billentyűzet output:képernyő (szöveges) 5.1. Jelbeolvasás (ReadKey, KeyPressed) A leütött billentyűknek megfelelő jelek a billentyűzetpufferbe kerülnek, az input eljárások onnan veszik át azokat. Bizonyos billentyűk leütésekor két jel kerül a pufferbe. Ilyenkor az első mindig #0. pl. Ins #0#82 F2 #0#60 function ReadKey: Char; ReadKey függvény (char típusú eredményt ad) Kiolvassa a billentyűzetpufferből a következő karaktert. Ha az üres, akkor billentyűleütésre vár. pl. ch:=ReadKey; function KeyPressed: Boolean; KeyPressed függvény (Boolean típusú eredményt ad) A függvény értéke true, ha a billentyűpufferben van kiolvasásra várakozó karakter, egyébként false. 5.2. Adatbeolvasás (Read, ReadLn) Read(paraméterlista); ReadLn(paraméterlista); ReadLn; Paraméterlista: egymástól vesszővel elválasztott változók. típusuk lehet: egész, valós, char, string Felfüggesztik a pr. futását és a változókba a billentyűzetről adatokat olvasnak be az ENTER leütéséig. Numerikus adatoknál csak a decimális formátum megengedett. beolvasandó konstansok értelmezése: egész elválasztójelig (szóköz, vagy TAB(#9)) valós elválszatójelig char a következő jel string a következő sorvége(ENTER) jelig A ReadLn a záró ENTER-t is beolvassa, a Read nem. Read-nél: kevés adat várakozás további adatokra sok adat a felesleg átadása a köv. beolvasásnak

IN-501 15

ReadLn-nél: kevés adat várakozás további adatokra sok adat a felesleg elvész ReadLn; alak : ENTER-re várás. 5.3. A CRT unit 1 x 80 1 (1,1) (80,1) y (x,y) 25 (1,25) (80,25) A képernyő koordináták értelmezése pozícionálás procedure GotoXY(X,Y: Byte); function WhereX: Byte; function WhereY: Byte; procedure ClrScr; procedure ClrEol; procedure InsLine; procedure DelLine; színek kezelése const { Háttér és előtér(írás) színek konstansai } Black = 0; { fekete } Blue = 1; { kék } Green = 2; { zöld } Cyan = 3; { türkiz } Red = 4; { piros } Magenta = 5; { lila } Brown = 6; { barna } LightGray = 7; { világosszürke } { Előtér(írás) színek konstansai } DarkGray = 8; { sötétszürke } LightBlue = 9; { világoskék } LightGreen = 10; { világoszöld } LightCyan = 11; { világostürkiz } LightRed = 12; { világospiros } LightMagenta= 13; { világoslila } Yellow = 14; { sárga } White = 15; { fehér } { Villogásnál hozzáadandó a színkódhoz } Blink =128; { villogás }

IN-501 16

procedure TextColor(Color: Byte); procedure TextBackground(Color: Byte); procedure LowVideo; procedure HighVideo; procedure NormVideo; ablakkezelés procedure Window(X1,Y1,X2,Y2: Byte); hagkeltés procedure Delay(MS: Word); procedure Sound(Hz: Word); procedure NoSound; Pl. Töröljük a képernyőt, majd a kurzort állítsuk vissza az eredeti pozícióba. x:=Wherex; y:=WhereY; ClrScr; GotoXY(x,y); 5.4. Adatkiírás (Write, Writeln) Write(paraméterlista); WriteLn(paraméterlista); WriteLn; Paraméterlista: egymástól vesszővel elválasztott kifejezések 3 féle alakban: kifejezés kifejezés:w (w:egész szám, kiírási hossz) kifejezés:w:d (d:egész szám, tizedesek száma) standard kiírási formák: var i,j,k:integer; a,b :real; i:=123; j:=-98; k:=435; a:=12.3; b:=-34e-4; WriteLn(i,j,k); 123-98435 WriteLn(i,’ ’,j,’ ’,k); 123 -98 435 WriteLn(’i=’,i); i=123 WriteLn(a); 1.2300000000E+01 WriteLn(b); -3.4000000000E-03 WriteLn(3 < 7); TRUE

IN-501 17

kiírás formátummegadással: var b: boolean; i: integer; a: real; c: char; s: string[6]; b:=true; i:=196; a:=-23.56; c:=’X’; s:=’Pascal’; utasítás 123456789012 ---------------------------------- write(b:2); TRUE write(not b:7); FALSE write(i:2); 196 write(i:6); 196 write(a:1); -2.4E+01 write(-a:8); 2.4E+01 write(a:11); -2.3560E+01 write(a:1:1); -23.6 write(a:1:3); -23.560 write(a:8:1); -23.6 write(a:11:3); -23.560 write(a:5:0); -24 write(c:1); X write(c:3); X write(s:2); Pascal write(s:6); Pascal write(s:9); Pascal Különböző típusú adatok beolvasása párbeszédes formában: var nev: string[25]; atl: real; od: integer; begin ClrScr; Write(’Név :’); ReadLn(nev); Write(’Átlag :’); ReadLn(atl); Write(’Ösztöndíj:’); ReadLn(od);

IN-501 18

6. Vezérlő szerkezetek (Strukturált utasítások) Az utasítások csoportosítása: Egyszerű utasítások: üres, értékadó, goto, eljáráshívás Strukturált utasítások: - összetett : begin .. end; - feltételes : if .. then .. else..; case .. of .. end; - ciklusszervező : for .. to .. do .. ; while .. do ..; repeat .. until .. ; - with 6.1. Összetett utasítás (begin .. end) Egynél több utasítás összefogása egy blokkba. 6.2. Feltételes utasítások 6.2.1. Elágazás két irányba (if utasítás) if logikai kifejezés then utasítás1 else utasítás2; Az if utasítás egyszerű alakja: az else ág hiányzik. if logikai kifejezés then utasítás1; utasítás1 és utasítás2 helyén állhat: - egyetlen utasítás - begin ... end blokk if x=y then write(’x = y’) else write(’x <> y’); if x<0 then x:=-x; ReadLn(pont); if pont<51 then jegy:=1 else if pont<61 then jegy:=2 else if pont<71 then jegy:=3 else if pont<81 then jegy:=4 else jegy:=5; if x<=10 then begin k:=100; t:=7; end else begin k:=-100; t:=-7; end; if (x>=-5) and (x<=5) then write(’-5 <= x <= +5’) else write(’x < -5 vagy x > +5’);

IN-501 19

6.2.2. Elágazás több irányba, választás (case utasítás) case szelektor of eset1: utasítás1; . . esetn: utasításn; else utasítás; end; szelektor: sorszámozott eredményt adó kifejezés lehet eset1,2.. : a szelektor típusával egyező típusú konstans az else ág elmaradhat case targykod of ’i’:WriteLn(’Informatika’); ’m’:WriteLn(’Matematika’); ’f’:WriteLn(’Fizika’); end; ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯ ReadLn(pont); case pont of 0..50 : jegy:=1; 51..60 : jegy:=2; 61..70 : jegy:=3; 71..80 : jegy:=4; 81..100: jegy:=5; else WriteLn(’Hibás pont érték!’); end; ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯ case k of 1,3,5,7,9 : d:=0; 10..19,91..99: begin h:=0; j:=8; end; end; 6.3. Ciklusszervezés 6.3.1. For utasítás cv : ciklusváltozó k : kezdőérték v : végérték for cv :=k to v do utasítás; { növekvő cv, k<=v } for cv:=k downto v do utasítás; { csökkenő cv, k>=v } ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯ for i:=1 to 10 do write(i*10:4); 10 20 30 40 50 60 70 80 90 100 ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯

IN-501 20

for i:=10 downto 1 do write(i*10:4); 100 90 80 70 60 50 40 30 20 10 ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯ for c:=’a’ to ’f’ do write(c); abcdef ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯ x:=10; y:=0; for i:=-2 to 2 do {-2,-1,0,1,2} begin x:=x+i; y:=y+5; for j:=1 to 6 do {1,2,3,4,5,6} begin x:=x+j; y:=y+10; end; end; WriteLn(’x:=’,x:5); { x:= 115 } WriteLn(’y:=’,y:5); { y:= 325 } ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯ { N faktoriális számítása } var fakt:longint; i :integer; begin Fakt:=1; for i:=1 to N do fakt:=fakt*i; write(’N!=’,fakt); end. 6.3.2. While utasítás While feltétel do ciklusmag; x:=10; while x < 100 do begin Write(x:4); x:=x+10; end; 10 20 30 40 50 60 70 80 90 100 ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯ Számítsuk ki a kétjegyű számok összegét! var o,sz:integer; begin o:=0; sz:=10; while sz <= 99 do begin o:=o+sz; sz:=sz+1; end;

IN-501 21

6.3.3. Repeat utasítás Repeat ciklusmag until feltétel; x:=10; Repeat Write(x:4); x:=x+10; until x > 100; 10 20 30 40 50 60 70 80 90 100 ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯ Beolvasásnál : -100 <= x <= 200 ellenőrzés ClrScr; Write('x='); Repeat GotoXY(3,1); ClrEol; ReadLn(x); Until (x >=-100) and (x <= 200);

IN-501 22

7. Összetett adattípusok 7.1. Halmazok, tömbök, rekordok deklarálása

(Set , Array, Record) 7.1.1. Halmaz deklarálása: Var változó : set of típus; max. 256 elemet tartalmazhat byte, boolean, char, felsorolt, intervallum var ketjegyu : set of 10..99; kisbetu : set of ’a’..’z’; 7.1.2. Tömb deklarálása var tömbnév:array[indextípus lista] of elemtípus; indextípus :megszámlálható(sorszámozott) típus résztartomány(intervallum) elemtípus :elemi, összetett, felhasználó által definiált Hivatkozás a tömb elmére: tömbnév[indexlista] index: konstans, változó, kifejezés Egyindexű tömb(vektor) deklarálása: var v : array[1..20] of integer ; v[1], v[2], v[3], ... ,v[20] valamennyi típusa integer var x : array[-5..5] of byte; x[-5], x[-4], x[-3], x[-2], x[-1], x[0], x[1], x[2], x[3], x[4], x[5] Kétindexű tömb(mátrix) deklarálása

oszlopok 1 2 3 4 1 m1,1 m1,2 m1,3 m1,4

sorok 2 m2,1 m2,2 m2,3 m2,4

3 m3,1 m3,2 m3,3 m3,4

var m : array[1..3,1..4] of byte; ugyanez a deklaráció type használatával: type matrix = array]1..3,1..4] of byte; var m : matrix; hivatkozás az m tömb általános elemére: m[i,j] (i:sorindex, j:oszlopindex)

IN-501 23

7.1.3. Rekord deklarálása var rekordnév : record mezőnév1: mezőtípus1; . . mezőnévn: mezőtípusn; end; hivatkozás a rekord egy mezőjére: rekordnév.mezőnév var hallgato : record nev : string[25]; tankor : string[6]; oszt_dij:integer; atlag :real; end; 7.2. Konstans tömb megadása (tömb típusú típusos konstans) const ho_nap:array[1..12] of byte=

(31,29,31,30,31,30,31,31,30,31,30,31); ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯

3 5 7 9 1 2 3 4 9 8 7 6

const m:array[1..3,1..4] of byte =

((3,5,7,9),(1,2,3,4),(9,8,7,6)); 7.3. Adatbeolvasás tömbökbe Var v:array[1..10] of integer; for i:=1 to 10 do begin Write(’v(’,i,’)=’); ReadLn(v[i]); end; ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯ { csak 5-tel osztható elemeket fogadunk el: } for i:=1 to 10 do repeat Write(’Kérem az ’,i,’. elemet:’); ReadLn(v[i]); until (v[i] mod 5)=0; ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯

IN-501 24

Var m:array[1..5,1..10] of integer; i:byte; { sorindex } j:byte; { oszlopindex } begin { sorfolytonos beolvasás } for i:=1 to 5 do for j:=1 to 10 do begin Write(’M(’,i,’,’,j,’)=’); ReadLn(m[i,j]); end; { oszlopfolytonos beolvasás } for j:=1 to 10 do for i:=1 to 5 do begin Write(’M(’,i,’,’,j,’)=’); ReadLn(m[i,j]); end; 7.4. Műveletek tömbökkel const N=10; var a,b,c :array[1..N] of integer; max,min:integer; i,j,ind:byte; atl :real; begin for i:=1 to N do a[i]:=i; for i:=1 to N do b[i]:=Random(10)+1; { egy ciklusban: for i:=1 to N do begin a[i]:=i; b[i]:=Random(10)+1; end; } for j:=1 to N do { c-ben a nagyobb érték lesz } if a[j]>b[j] then c[j]:=a[j] else c[j]:= b[j];

1 2 3 4 5 6 7 8 9 10a 1 2 3 4 5 6 7 8 9 10 b 3 1 8 6 5 2 10 6 4 7 c 3 2 8 6 5 6 10 8 9 10

IN-501 25

S c atl S

Nii

N

= ==∑

1

{ c vektor elemeinek összege és átlaga } S:=0; { S kezdőértéke } for i:=1 to N do {elemek szekvenciális bejárása} S:=S+c[i] { művelet c[i] elemekre } ; { ciklus vége } atl:=S/N; { c vektor páros és páratlan elemeinek száma } pr:=0; pl:=0; for i:=1 to N do if odd(c[i]) then pl:=pl+1 else pr:=pr+1; { az előbbi két feladat egy ciklusban } S:=0; pr:=0; pl:=0; for i:=1 to N do begin S:=S+c[i]; if odd(c[i]) then pl:=pl+1 else pr:=pr+1; end; atl:=S/N; { c vektor elemei közül a legnagyobb } max:=c[1]; { max induló értéke } for j:=2 to N do if c[j]>max then max:=c[j]; { c vektor elemei közül a legkisebb és indexe } min:=c[1]; ind:=1; for j:=2 to N do if c[j]<min then begin min:=c[j]; ind:=j; end; ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯

IN-501 26

type matr:array[1..4,1..3] of integer; var a,b,c:matr; i,j :byte; begin for i:=1 to 4 do for j:=1 to 3 do begin a[i,j]:=i+j; b[i,j]:=Random(10); c[i,j]:=a[i,j]+b[i,j]; end;

2 3 4 2 4 0 4 7 4 3 4 5 4 6 3 7 10 8 4 5 6 9 3 7 13 8 13 5 6 7 6 3 8 11 9 15

a b c ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯ var m:array[1..10,1..10] of byte; sz:longint; { főátló elemeinek szorzata } sz:=1; for i:=1 to 10 do sz:=sz*m[i,i]; 7.5. Tömbök kiírása képernyőre const v:array[1..5] of byte=(22,13,44,67,32); Write(’v vektor :’); for i:=1 to 5 do Write(v[i]:3);

v v e k t o r : 2 2 1 3 4 4 6 7 3 2 for i:=1 to 5 do WriteLn(’v(’,i,’)=’,v[i]:3);

v ( 1 ) = 2 2 v ( 2 ) = 1 3 v ( 3 ) = 4 4 v ( 4 ) = 6 7 v ( 5 ) = 3 2

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯

IN-501 27

const m:array[1..3,1..4] of integer= ((31,-5,17,-9),(11,22,33,44),(9,88,-57,-36)); WriteLn(’az m mátrix:’); for i:=1 to 3 do begin WriteLn; for j:=1 to 4 do Write(m[i,j]:4); end;

a z m m á t r i x : 3 1 - 5 1 7 - 9 1 1 2 2 3 3 4 4 9 8 8 - 5 7 - 3 6

IN-501 28

8. Alprogramok (szubrutinok) Alprogram: formailag és tartalmilag önálló programrész, amely a kapcsolatot a program többi részével a paramétereken keresztül tartja. Alkalmazásának előnyei: - áttekinthetőbb, strukturáltabb, rövidebb program - csoportmunka lehetősége - más által írt alprogramok felhasználásának lehetősége Alprogramok fajtái: - eljárás : procedure - függvény : function 8.1. Alapfogalmak (deklaráció, hívás, paraméterek) Az alprogram kétféle formai előfordulása: - deklarációja alprogram neve formális paraméterek listája saját (lokális) deklarációk utasítások - hívása alprogram neve aktuális paraméterek listája Az információáramlás iránya szerint lehetnek: - input paraméterek - output paraméterek - input/output paraméterek Az információátadás lehet: - érték szerint - cím szerint Ez a paraméter jellemzője, melyet a formális paraméterek deklarációjánál adunk meg. Érték szerinti paraméterátadás - deklarálásuknál a típus(egyszerű vagy felhasználói) megadása kötelező Pl.Procedure alpr1(x,y:integer; z:real); - az aktuális paraméterek értéke átmásolódik a formális paramétereknek lefogalt helyre - csak input paraméter lehet - az aktuális paraméter lehet konstans, változó vagy kifejezés Cím szerinti paraméterátadás - az alprogram az aktuális paraméter címét veszi át - a formális paramétert a var kulcsszó után kell megadni Pl.Procedure alpr2(var a,b:real; c:integer); - input és output paraméter is lehet - az aktuális paraméter csak változó lehet

IN-501 29

Egyéb tudnivalók a paraméterekről: - a formális és aktuális paramétereknek meg kell, hogy egyezzen a számuk, logikai sorrendjük és páronkénti típusuk - strukturált adattípusú formális paramétert (array, set, record, file) csak előre definiált (type) típusnévvel adhatunk meg - egy paraméterlistában lehetnek érték szerinti(u,v) és cím szerinti (w) paraméterek is Pl.Procedure alpr3(u,v:byte; var w:real); 8.2. Eljárások (Procedure), függvények (Function) Eljárások (Procedure) procedure eljárásnév(formális paraméterek listája); { lokális deklarációk } { const ...; type ...; var ...; procedure ...; function ...; } begin utasítások { az eljárás törzse } end; Pl. Henger felszínét és térfogatát számító eljárás input(érték szerinti) paraméterek: sugár s : integer magasság m : integer output(cím szerinti) paraméterek: felszín f : real terület t : real Procedure szamit(s,m:integer; var f,t:real); var kter:real; begin kter:=s*s*pi; f:=2*kter+2*s*pi*m; t:=kter*m; end; Pl. henger sugarát és magasságát beolvasó eljárás procedure olvas(var s,m:integer); begin ClrScr; Write(’sugár =’); ReadLn(s); Write(’magasság=’); ReadLn(m); end; Pl. a beolvasott és számított értékeket kiíró eljárás procedure kiir(s,m:integer; f,t:real); begin ClrScr; WriteLn(’Henger felszíne és térfogata’); WriteLn; WriteLn(’Sugár :’,s:8); WriteLn(’Magasság:’,m:8); WriteLn(’Felszín :’,f:8:2); WriteLn(’Térfogat:’,t:8:2); end;

IN-501 30

program henger; uses crt; var sugar,magassag :integer; felszin,terfogat:real; procedure szamit(s,m:integer; var f,t:real); var kter:real; begin kter:=s*s*pi; f:=2*kter+2*s*pi*m; t:=kter*m; end; procedure olvas(var s,m:integer); begin ClrScr; Write(’sugár =’); ReadLn(s); Write(’magasság=’); ReadLn(m); end; procedure kiir(s,m:integer; f,t:real); begin ClrScr; WriteLn(’Henger felszíne és térfogata’); WriteLn; WriteLn(’Sugár :’,s:8); WriteLn(’Magasság:’,m:8); WriteLn(’Felszín :’,f:8:2); WriteLn(’Térfogat:’,t:8:2); end; { főprogram kezdete } begin olvas(sugar,magassag); szamit(sugar,magassag,felszin,terfogat); kiir(sugar,magassag,felszin,terfogat); end. Függvények (Function) function függvénynév(formális par.-ek listája):függvény típusa; { lokális deklarációk } { const ...; type ...; var ...; procedure ...; function ...; } begin utasítások { a függvény törzse } függvénynév:=.......; end;

IN-501 31

program fuggveny; uses crt; var x:real; i:integer; function f1(x1:real):real; begin f1:=sin(2*x1)+cos(x1/2); end; { főprogram kezdete } begin ClrScr; WriteLn(’ x f1 ’); WriteLn(’================’); for i:=1 to 20 do begin x:=i*pi/180; WriteLn(i:4,f1(x):12:8); end; end. program p1; uses crt; const N=15; type vekt=array[1..N] of integer; var a,b:vekt; procedure general(var v:vekt;ah,fh:integer); var j:integer; begin for j:=1 to N do v[j]:=Random(fh-ah+1)+ah; end; procedure kiir(szov:string[20]; var v:vekt); var j:integer; begin WriteLn(szov); for j:=1 to N do Write(v[j]:5); WriteLn; end { kiir };

IN-501 32

procedure rendez(var v:vekt); var i,w :integer; csere:Boolean; begin repeat csere:=false; for i:=1 to N-1 do if v[i]<v[i+1] then begin { csere } w:=v[i]; v[i]:=v[i+1]; v[i+1]:=w; csere:=true; end; until not csere; end { rendez }; function osszeg(var v:vekt):longint; var i:integer; s:longint; begin s:=0; for i:=1 to N do s:=s+v[i]; osszeg:=s; end; { főprogram kezdete } begin Randomize; general(a,-10,20); kiir(’rendezetlen a vektor:’,a); rendez(a); kiir(’rendezett a vektor:’,a); general(b,100,200) kiir(’b vektor elemei:’,b); WriteLn; WriteLn(’az elemek osszege:’,osszeg(b)); ReadKey; end. Forward deklaráció procedure beker(var x:byte); Forward; procedure szamit(var a2,afel:word); var a:byte; begin beker(a); a2:=2*a; afel:=a div 2; end; procedure beker; begin Write(’x=’); ReadLn(x); end;

IN-501 33

A rekurzió

Egy eljárás vagy egy függvény önmagából történő hívását rekurzív hívásnak nevezzük.

function fakt(n:longint):longint; begin if n=0 then fakt:=1 else fakt:=n*fakt(n-1); end; 5!=5*4! 4*3! 3*2! 2*1! 1*0! 1 5!=5*4*3*2*1*1 5!=120 Deklarációk hatásköre, a programok memóriatérképe Program p; var x,y:integer; { p globális változói } procedure a; var i,j:byte; { a lokális változói } procedure b; var i,k:integer; { b lokális változói } begin { b blokkja, ismertek:x,y,j,k } { és a b-ben deklarált i } { a és b hívható, c nem } end {b}; begin { a blokkja, ismertek:x,y,j } { és az a-ban deklarált i } { a,b és c hívható } end {a}; procedure c; var z:byte; { c lokális változója } begin { c blokkja, ismertek:x,y,z } { a és c hívható, b nem } end {c}; begin { főprogram blokkja, ismertek:x,y } { a és c hívható, b nem } end {p};

IN-501 34

Heap dinamikus változók A D Stack lokális változók A Data globális változók T típusos konstansok System unit modul unit 1 modul P unit 2 modul EXE R .... file O .... tartal- G unit n modul ma R Főprogram modul A M PSP (256 byte) $00000

Egy modul max 64 K. A Data mérete fordításkor meghatározódik, max. 64 K. A Stack és Heap mérete fordítási opcióval beállítható. Statikus változók(Data és Stack): - közvetlenül deklaráltak a programban - címük a fordításkor meghatározódik - Data: a globális változók és a típusos konstansok helye a program futása során

változatlan felosztás - Stack: lokális változók időben átlapolva Dinamikus változók(Heap): - deklarálásuk a pr. futása során történik

IN-501 35

9. A programkészítés lépései, módszertana. Algoritmusok és Pascal programok. program prmenu; { egyszerű menü programozása } uses crt; const menu:array[1..4] of string[25]= (’1 első feladat’, ’2 második feladat’, ’3 harmadik feladat’, ’ESC v é g e ’); var i:integer; c:char; procedure menuir; var i:integer; begin textbackground(green); clrscr; textcolor(blue); gotoxy(25,5); for i:=1 to 4 do begin gotoxy(25,wherey); writeln(menu[i]); end; gotoxy(25,wherey+3); write(’V á l a s z ?’); end { menuir }; procedure feladat1; begin end {feladat1}; procedure feladat2; begin end {feladat2}; procedure feladat3; begin end {feladat3}; { főprogram } begin repeat menuir;

IN-501 36

repeat c:=readkey; until c in [’1’,’2’,’3’,#27]; case c of ’1’:feladat1; ’2’:feladat2; ’3’:feladat3; end; until c=#27; end.

IN-501 37

program prbeszur; { új érték beszúrása növekvő sorrendbe } { rendezett vektorba } uses crt; const N=15; type vekt=array[1..N] of integer; var x:vekt; i,ujx:integer; procedure kiir(var v:vekt); var i:integer; begin for i:=1 to N do write(v[i]:4); writeln; writeln; end; procedure rendez(var v:vekt); var i,j,w:integer; begin for i:=1 to N-1 do for j:=i+1 to N do if v[j]<v[i] then begin w:=v[i]; v[i]:=v[j]; v[j]:=w; end; end; procedure beszur (var v:vekt;ujelem:integer); var i:integer; begin i:=N; while (i>=1) and (ujelem<v[i]) do begin if i<>N then v[i+1]:=v[i]; i:=i-1; end; if i<>N then v[i+1]:=ujelem; end; begin Randomize; for i:=1 to N do x[i]:=Random(50); Clrscr; writeln(’Az eredeti adatok:’); kiir(x); rendez(x); writeln(’A rendezett adatok:’); kiir(x); Write(’Kérem az új értéket:’); readln(ujx);

IN-501 38

writeln; beszur(x,ujx); writeln(’Az új vektor:’); kiir(x); readkey; end.

IN-501 39

program keres; { lineáris és bináris keresés } uses crt; const N=15; type vekt=array[1..N] of integer; var adatok : vekt; ertek : integer; megvan : boolean; hely : integer; i : integer; procedure linker(v:vekt; x:integer; var van:boolean; var hol:integer); {lineáris keresés rendezetlen adatsorban} { v : N elemű vektor (adatsor) } { x : a keresett érték } { van : logikai változó } { hol : a megtalált elem indexe } var i:integer; begin i:=1; van:=false; while (i <= N) and (not van) do begin if v[i]=x then begin van:=true; hol:=i; end; i:=i+1; end; end; procedure binker(v:vekt; x:integer; var van:boolean; var hol:integer); { bináris keresés növekvő sorrendbe rendezett adatsorban } var ai:integer; {intervallum alsó indexe} fi:integer; {intervallum felső indexe} ki:integer; {középső elem indexe } i :integer; {ciklusváltozó } begin ai:=1; fi:=N; van:=false; while (ai<=fi) do begin ki:=(ai+fi) div 2; if x=v[ki] then begin van:=true; hol:=ki; end; if x < v[ki] then fi:=ki-1; if x > v[ki] then ai:=ki+1; end; end;

IN-501 40

procedure rendez(var v:vekt); var i,w,db:integer; csere:boolean; begin db:=N; repeat csere:=false; db:=db-1; for i:=1 to db do if v[i+1] < v[i] then begin w:=v[i]; v[i]:=v[i+1]; v[i+1]:=w; csere:=true; end; until not csere; end; procedure vektorir(var v:vekt); var i:integer; begin for i:=1 to N do write(v[i]:5); writeln; end; procedure eredmenyir; begin if megvan then writeln(’van a ’,hely:3,’. helyen’) else writeln(’nincs meg’); end; begin clrscr; for i:=1 to N do adatok[i]:=random(20); Writeln(’A vektor elemei:’); vektorir(adatok); writeln; Write(’A keresett érték:’); Readln(ertek); linker(adatok,ertek,megvan,hely); eredmenyir; rendez(adatok); writeln; writeln; vektorir(adatok); binker(adatok,ertek,megvan,hely); eredmenyir; readkey; end.

IN-501 41

program f46; { 5x10-es m mátrix sorösszegének és oszlopösszegének számítása -99 <= m(i,j) <= 99 m y x s} uses crt; var m:array[1..5,1..10] of integer; x:array[1..10] of integer; y:array[1..5] of integer; i,j,s,kx,ky: integer; begin { A mátrix elemeinek beolvasása } ClrScr; WriteLn(’Kérem a mátrix elemeit’, ’-99 és 99 között’); WriteLn; for i:=1 to 5 do for j:=1 to 10 do begin Write(’m(’,i,’,’,j,’)=?’); kx:=WhereX; ky:=WhereY; repeat GotoXY(kx,ky); ClrEol; ReadLn(m[i,j]); until (-99<=m[i,j]) and (m[i,j]<=99); end; for i:=1 to 5 do y[i]:=0; for j:=1 to 10 do x[j]:=0; s:=0; { Kiírás és számítás } ClrScr; GotoXY(5,8); for i:=1 to 5 do begin GotoXY(5,WhereY); for j:=1 to 10 do begin Write(m[i,j]:5); y[i]:=y[i]+m[i,j]; x[j]:=x[j]+m[i,j]; end; WriteLn(y[i]:10); s:=s+y[i]; end; GotoXY(5,14);

IN-501 42

for j:=1 to 10 do Write(x[j]:5); Write(s:10); ReadKey; end. ---------------------------------------- program f49; uses crt; type m10=array[1..10,1..10] of real; procedure transzp(var M:m10); var i,j:integer; w :real; begin for i:=2 to 10 do for j:=1 to i-1 do begin w:=M[i,j]; M[i,j]:=M[j,i]; M[j,i]:=w; end; end { transzp }; ... ---------------------------------------- program f50; uses crt; type m1 = array[1..5,1..10] of integer; m2 = array[1..10,1..20] of integer; m3 = array[1..5,1..20] of integer; procedure matr_szor(A:m1; B:m2; var C:m3); var i,j,k:integer; for i:=1 to 5 do for k:=1 to 20 do begin C[i,k]:=0; for j:=1 to 10 do C[i,k]:=C[i,k]+A[i,j]*B[j,k]; end; end { matr };

IN-501 43

10. Programmodulok

Unit: önállóan lefordítható programegység, amely egy jól definiált kapcsolófelületen (interface) keresztül érhető el. A unit-ok felépítése: unit unitnév; interface { kapcsolódási rész } uses ... const ... type ... var ... procedure ... function ... implementation { implementációs rész } uses ... const ... type ... var ... procedure ... function ... begin { inicializációs rész } { Pascal utasítások } end.

IN-501 44

11. FÁJLOK 11.1. Alapfogalmak, a record adattípus és a With utasítás

0 1 2 n

↑ fájlmutató EOF Fizikai fájl, logikai fájl fogalma. A fájlkezelés alapvető lépései: - kijelölés - nyitás - feldolgozás ( írás, olvasás, pozícionálás ) - zárás Fájl alaptípusok a Pascal-ban: - típusos fájl var f : file of tipus; - szövegfájl var f : text; - típus nélküli fájl var f : file; Feldolgozási módok: - szekvenciális - direkt A record adattípus: type típusnév : record mezőnév1: mezőtípus1; . . mezőnévn: mezőtípusn; end; var rekordnév : típusnév; hivatkozás a rekord egy mezőjére: rekordnév.mezőnév type t1 : record nev :string[25]; oszt_dij:integer; atlag :real; end; var hrek: t1;

IN-501 45

A With utasítás: With rekordnév do utasítás; with hrek do begin writeln(nev); writeln(atlag); end; más megoldás: writeln(hrek.nev);

writeln(hrek.atlag); Hibakezelés { $I- } < i/o művelet > if ioresult<>0 then ..... { hibaüzenet ill. teendők } { $I+ } 11.2. Típusos fájlok Deklarálás és megnyitás: var filenév : file of típus; assign(fájlnév, fájl fizikai név); reset(fájlnév); rewrite(fájlnév); 11.3. Műveletek fájlokkal read(fájlnév, adatlista); eof(f) write(fájlnév, adatlista); seek(fájlnév, n); filesize(fájlnév) filepos(fájlnév) pl. visszalépés az előző pozícióra: seek(fájlnév, filepos(fájlnév)-1); truncate(fájlnév); close(fájlnév);

IN-501 46

program pf0; {********************************************} { A program feladata: } { Hallgatói adatokat tartalmazó típusos fájl } { létrehozása, az adatok bekérése } { (adatellenőrzés nélkül ! ) } {********************************************} uses crt; type t1=record {rekordszerkezet deklarálása} nev :string[20]; od :integer; atl :real; end; var r1 :t1; { r1 I/O terület } f1 :file of t1; { f1 nevű fájl dekl.} i :integer; ch :char; begin { logikai fájl - fizikai fájl kapcsolat} assign(f1,'adat1.dat'); rewrite(f1);{ fájl létrehozása és megnyitása } repeat repeat clrscr; Writeln('Van még adat ? I/N'); ch:=Upcase(readkey); writeln; until (ch='I') or (ch='N'); if ch='I' then begin with r1 do begin write('N é v : '); readln(nev); write('Tanulm. átlag: '); readln(atl); write('Ösztöndíj : '); readln(od); write(f1,r1);{rekord kiírása a fájlba} end; end; until ch='N'; close(f1); { fájl lezárása } end.

IN-501 47

program pf1; {**********************************************} { A program feladata: } { Hallgatói adatokat tartalmazó típusos fájl } { rekordjainak kiírása képernyőre szekvenciális} { sorrendben, egyszerű formában } {**********************************************} uses crt; type rtip=record{ rekordszerkezet dekl.} nev :string[20]; osztd :integer; atlag :real; end; var rekord :rtip; { I/O terület } f :file of rtip; { f fájl dekl.} ch :char; od_atl :real; begin assign(f,'adat1.dat'); { logikai fájl - fizikai fájl } reset(f); { létező fájl megnyitása } clrscr; writeln('Név Ösztöndíj Átlag'); writeln('===================================='); while not eof(f) do begin read(f,rekord);{ következő rekord olvasása } write(rekord.nev); gotoxy(22,wherey); writeln(rekord.osztd:8,rekord.atlag:7:2); end; writeln('===================================='); close(f); ch:=readkey; end.

IN-501 48

program pf2; {Rekordszerkezet átalakítása} uses crt; type t1=record { input rekordtípus deklarálása } nev:string[20]; od1:integer; atl:real; end; type t2=record { output rekordtípus deklarálása } sorsz:byte; nev:string[20]; kol:char; atl:real; od2:integer; end; var r1:t1; { I/O területek } r2:t2; { f1 és f2 fájlok deklarálása } f1:file of t1; f2:file of t2; ch:char; sor:byte; begin clrscr; { logikai fájl - fizikai fájl kapcsolatok} assign(f1,'adat1.dat'); assign(f2,'adat2.dat'); { fájl megnyitások } reset(f1); rewrite(f2); sor:=1; while not eof(f1) do begin read(f1,r1); { olvasás f1-ből } r2.nev:=r1.nev; r2.od2:=r1.od1; r2.atl:=r1.atl; r2.sorsz:=sor; repeat write(r1.nev, ' Kollégista? (I/N)'); readln(ch); ch:=upcase(ch); until ch in ['I','N']; r2.kol:=ch;

IN-501 49

write(f2,r2); { kiírás f2-re } sor:=sor+1; end; { fájlok lezárása } close(f1); close(f2); end.

IN-501 50

Program pf3; {**********************************************} { A program feladata: } { az első 20 rekord olvasása, } { kiírása képernyőre eredeti sorrendben, } { rendezés, kiírás rendezetten } {**********************************************} uses crt; type t2=record { rekordszerkezet deklarálása } sorsz : byte; nev : string[20]; koll : char; atlag : real; od : integer; end; var r2 :t2; { I/O terület } f2 :file of t2; { f2 fájl dekl.} i,j,N :integer; ch :char; T:array[1..20] of t2; w:t2; begin { logikai fájl - fizikai fájl kapcsolat} assign(f2,'adat2.dat'); { f2 fájl megnyitása } reset(f2); clrscr; Writeln('Kiírás eredeti sorrendben'); writeln('Rsz Név Koll'); writeln('==========================='); i:=0; while (not eof(f2)) and (i<20) do begin read(f2,r2); { következő rekord olvasása } write(r2.sorsz); gotoxy(4,wherey); write(r2.nev); gotoxy(26,wherey); writeln(r2.koll); i:=i+1; T[i]:=r2; end; N:=i; ch:=readkey; { rendezés névsor szerint } for i:=1 to N-1 do for j:=i+1 to N do if T[j].nev<T[i].nev then begin { csere } w:=T[i]; T[i]:=T[j]; T[j]:=w; end;

IN-501 51

window(41,1,80,25); writeln('Kiírás névsor szerint'); writeln('Rsz Név Koll'); writeln('==========================='); for i:=1 to N do begin write(T[i].sorsz); gotoxy(4,wherey); write(T[i].nev); gotoxy(26,wherey); writeln(T[i].koll); end; close(f2); ch:=readkey; end.

IN-501 52

program pf4; {***********************************************} { A program feladata: } { Hallgatói adatokat tartalmazó típusos fájl } { rekordjainak kiírása képernyőre szekvenciális } { sorrendben, átlagos ösztöndíj ill. max. átlag } { számítása } {***********************************************} uses crt; type t2=record { rekordszerkezet deklarálása } sorsz:byte; nev :string[20]; koll :char; atl :real; od :integer; end; var r2 :t2; { I/O terület } f2 :file of t2; { f2 nevű fájl dekl.} fo :integer; ch :char; od_ossz:integer; od_atl :real; max_atlag:real; begin { logikai fájl - fizikai fájl kapcsolat } assign(f2,'adat2.dat'); reset(f2); { létező fájl megnyitása } max_atlag:=0; od_ossz:=0; fo:=0; clrscr; writeln('Név Ösztöndíj Átlag'); writeln('===================================='); while not eof(f2) do begin read(f2,r2); { következő rekord olvasása } write(r2.nev); gotoxy(22,wherey); writeln(r2.od:8,r2.atl:7:2); od_ossz:=od_ossz+r2.od; fo:=fo+1; if max_atlag<r2.atl then max_atlag:=r2.atl; end; od_atl:=round(od_ossz/fo);

IN-501 53

writeln('===================================='); writeln('Összes ösztöndíj: ',od_ossz:7); Writeln('Hallgatók létszáma: ',fo:6); writeln('Átlagos ösztöndíj: ',od_atl:7:0); writeln; writeln('A legjobb tanulmányi átlag:', max_atlag:9:2); close(f2); ch:=readkey; end.

IN-501 54

Kérdések, feladatok

Teszt ( T ) (Jelölje meg a jó választ) T1) Melyik utasítás felel meg a következő kifejezésnek ?

( )

xx y y

c da b

=⋅ + −

⋅⋅

sin cos23

a./ x:=sqrt(sin(2*x+y)-cos(y)/3)/abs(c*d/(a*b)); b./ x:=sqrt(sin(2x+y)-cos(y)/3)/abs(c*d/a*b); c./ x:=sqrt(sin(2*x+y)-cos(y/3))/abs(c*d/a/b); d./ x:=sqr(sin(2*x+y)-cos(y/3))/abs(c*d/a*b);

T2) Melyik állítás helytelen? a./ Egy sorban több utasítás is állhat. b./ A Case utasítással többirányú elágaztatás lehetséges. c./ A Pascal programban max. 3 dimenziós tömbök deklarálhatók. d./ A deklarációknak a blokk elején kell lenniük.

T3) Mennyi lesz az x változó értéke a következő programrész végrehajtása után ? x:=-5; y:=10; if y<>10 then if x<-5 then x:=x+5 else x:=x+10 else if x*y>0 then x:=x+15 else x:=x+20; a./ 5 b./ 10 c./ 20 d./ 15

T4) Hányszor kerül végrehajtásra a v:=v-3; utasítás ? v:=10; while (v>0) do begin v:=v-3; end; a./ 4 b./ 0 c./ 5 d./ 1

T5) Mennyi lesz a v vektor első elemének az értéke ? var v:array[1..10] of integer; i,j:integer; begin v[10]:=0; for i:=9 downto 1 do begin v[i]:=v[i+1]+10; if (i mod 3)=1 then v[i]:=v[i]+5; end; a./ 0 b./ 105 c./ 100 d./ 110

T6) Milyen típusú eredményt ad vissza a KeyPressed függvény? a./ integer b./ char c./ string d./ boolean

T7) Milyen határok között lehet x értéke ? Randomize; x:=(Random(50)+ (60 div 40)) mod 60; a./ 0-59 b./ 0-49 c./ 0-50 d./ 1-50

T8) Mi a következő utasítások végrehajtásának eredménye? a:=a+b; b:=a-b; a:=a-b; ( a és b integer ) a./ a és b értéke változatlan marad b./ a és b értéke b-vel csökken c./ a és b értéke felcserélt d./ a és b értéke növekvő sorrendbe rendezett

T9) Melyik függvény/eljárás nem része a CRT unit-nak? a./ Sound b. Delete c./ WhereY d./ ClrEol

T10) Melyik nem függvény? a./ Ord(x) b./ Val(s,x,j) c./Round(x) d./Copy(s,k,h)

IN-501 55

Rövid ellenőrző kérdések ( K ) ( Válaszoljon írásban, kérdésenként 1 perc alatt )

K1) Egy változó hogy kaphat értéket? K2) Milyen műveletek végezhetők a Boolean típusú változókkal? K3) Deklaráljon minimális helyfoglalású típusos konstansként egy M(2x3) mátrixot, amelynek

elemei: 11 5 20 0 23 8

K4) Mi lesz az eredmény típusa és értéke? x:=(5<>+5)<(+6=6); K5) Mi lesz az eredmény? x:= pred(30) div 3 mod round(5.4); K6) Adott az S szöveges változó. Határozza meg a Db változóban a szövegben található ”E”

betűk számát! K7) Milyen típusú és tartalmú értékeket adnak vissza a következő függvények: ReadKey,

KeyPressed ? K8) A képernyő 12. sorába középre igazítva írassa ki a nevét! K9) Hol nem szabad az END után sem ;-t sem .-t tenni? K10) N adott. Határozza meg Fakt-ban az N! értékét! K11) Írassa a képernyőre egymás mellé a következő számokat 5-5 pozíciónként: 5,10,15,....85!

Ciklusszervezésre alkalmazza a While utasítást! K12) Írassa a képernyőre egymás alá az 5-tel osztható kétjegyű számokat.

Ciklusszervezésre alkalmazza a Repeat utasítást! K13) Írjon programrészt amely az S változóban megadja a kétjegyű páros számok összegét! K14) Az X,Y és Z változók tartalmát rendezzük át úgy, hogy az értékek csökkenő sorrendben

legyenek X >= Y >= Z K15) A program a 'T ' vagy a 't' billentyű lenyomására várjon! K16) D-ből számítsa ki a kör területét(TER) és írassa ki a képernyő 10. sorának 5.

pozíciójától:Terület=XXXXXX.XXX alakban K17) Generáljon véletlen páros számot -100 < sz < 200 K18) Adott az M 5x10-es mátrix. A 4. sor minden elemének adjuk a 0 értéket! K19) Mit nevezünk rekurzív függvényhívásnak? K20) Milyen kapcsolat van a formális és az aktuális paraméterek között ?

IN-501 56

Programrészek elemzése, kiértékelése ( E )

E1) Mennyi lesz X és Y értéke? x:=-5; y:=5; for i:=-5 to 5 do begin x:=x+i; y:=y+5; for j:=0 to 5 do begin x:=x-j; y:=y-i-5; end; end; Writeln(’x=’,x:8,’y=’,y:8);

E2) Milyen kiírás jelenik meg a képernyőn? clrscr; x:=0; for i:=1 to 3 do begin gotoxy(3,i+1); x:=x+10+i; write('i=',i:2,' j='); for j:=8 downto 5 do write(i+j:4); writeln; writeln; end; writeln('x=',x:10);

E3) Milyen kiírás jelenik meg a képernyőn? const sz:String[20] = 'DUNAÚJVÁROS'; var i :byte; begin ClrScr; for i:=1 to Length(sz) do begin GotoXY(3,i); Write(Copy(sz,1,i)); GotoXY(5+Length(sz),i); Write(Copy(sz,Length(sz)+1-i,i)); end; end.

E4) Mi lesz a következő programrész eredménye? Var v:array[1..100] of integer; for i:=1 to 50 do begin j:=101-i; w:=v[i]; v[i]:=v[j]; v[j]:=w; end;

E5) Egy programozási versenyen kiadott feladat: Az alábbi rekurzív függvényeljárás bemenő paraméterei az X, M, A és B változók. X és M csak pozitív értékek lehetnek. a. Milyen értéket számít ki a függvény ? b. Mi M szerepe ? c. Mi A és B szerepe ? d. Tetszőleges pozitív X és M esetén adjon meg olyan A és B kezdőértékpárt, amely biztosan jó ! Function Rekurziv(X,M,A,B:real):real; Var C:real; Begin C:=(A+B)/2; If C-A < M Then Rekurziv:=C Else If C*C > X Then Rekurziv:=Rekurziv(X,M,A,C) Else Rekurziv:=Rekurziv(X,M,C,B); End { Rekurziv }

IN-501 57

Programozási feladatok ( F ) ( Írjon Pascal programot a következő feladatok megoldására )

F1) Eldöntendő, hogy a,b,c értékek lehetnek-e egy háromszög oldalai. F2) Másodfokú egyenlet megoldása. F3) A háromszög oldalainak (a,b,c) ismeretében a Heron képlet segítségével

számítsa ki a háromszög területét! T= s s a s b s c( )( )(− − − ) , ahol s:=(a+b+c)/2

F4) Írassa ki a Fibonacci számsor első N tagját! ( 1<= N <= 35) ( 1, 1, 2, 3, 5, 8, 13, ... )

F5) Határozza meg a következő sor első 10 tagjának összegét!

F x x x= + + + +1

1 2 3

2 3

! ! !. . .

F6) Hány tagot kell összeadni a következő sor elemeiből, hogy az összeg átlépje a 11-es értéket?

Sn

= + + + + +1 12

13

14

1. . .

F7) Számítsa ki x értékét a következő képlet szerint:

xi

j

i

j

=+

−

=

=−

∑

∑

( )2

20

2

1

100

10

20

F8) Táblázatos formában, fejléccel írassa ki a henger felszínét és térfogatát ( 3 tizedes pontossággal) az R=10,20,30,40 és M=60,65,70,75,80 értékek valamennyi lehetséges párosításában!

F9) Írassa ki háromszor a következő számsort a három különböző ciklusszervezési utasítás alkalmazásával: 120 110 100 90 80 70 60 50 40 30 20

F10) Határozza meg egy tetszőleges szövegben a magánhangzók számát! F11) Olvasson be egy szöveget, amelyben négy kétjegyű szám van szóközökkel

elválasztva. Határozza meg a négy szám összegét! F12) Olvasson be egy mondatot, majd a mondat szavait külön-külön sorba, középre igazítva, más-

más színnel írassa ki! F13) Olvasson be egy mondatot és határozza meg hány szóból áll! F14) Olvasson be egy szöveget, majd írja ki fordítva! F15) Olvasson be egy max. 50 karakter hosszú szöveget és írassa ki a képernyő valamennyi

sorába, középre igazítva, véletlen színnel. F16) Olvasson be egy szöveget (hossza max. 70 karakter)! A program bármely billentyű

lenyomásáig ismételje a következőket: a szöveget (lassítva), karakterenként bővítve kiírja, majd jobbról hasonló módon törli.

F17) Generáljon 1000 kockadobást! Határozza meg az egyes dobások gyakoriságát! F18) Generáljon véletlen számokat az 5-ös Lottó egy szelvényének kitöltéséhez!

IN-501 58

F19) A képernyő X,Y koordinátájú helyére írjon ki egy SZ színű K karaktert. A kurzormozgató billentyűk (a négy nyíl) segítségével a karakter legyen mozgatható. A képernyő szélénél a program a hibás lépésnél adjon hangjelzést. Befejezés az ESC billentyű leütésére.

F20) Input: N, Nev(1),Od(1),Nev(2),Od(2),....,Nev(N),Od(N) N <= 20 Nev(i) név (max. 25 karakter) Od(i) ösztöndíj (1000 és 15000 közé eső érték) Írassa ki az adatokat a képernyőre az eredeti sorrendben és névsor szerint nö-vekvő sorrendben! Számítsa ki az átlagos ösztöndíjat!

F21) Input: N, Nev(1),Atl(1),Nev(2),Atl(2),....,Nev(N),Atl(N) N <= 20 Nev(i) név (max. 25 karakter) Atl(i) tanulmányi átlag (1 egész, 2 tizedes jegy) Írassa ki az adatokat a képernyőre az eredeti sorrendben és átlag szerint csök-kenő sorrendben helyezési számokkal!

F22) A Nev 10 elemű egydimenziós tömb max. 25 karakter hosszú neveket tar-talmazzon. Cserélje fel a vezeték- és keresztneveket! Írassa ki az eredeti formát, majd a felcseréltet.

F23) Olvasson be egy mondatot és írja ki az eredeti szavakat fordított sorrendben! F24) Átalakítás 10-es számrendszerről 2-es és 16-os számrendszerre! F25) Input: x(1), x(2), ... x(100) -50 <= x(i) <=150

Határozza meg az elemek átlagát! Beolvasásnál csak a feltételnek megfelelő értékeket fogadjon el.

F26) Egy 50 elemű V tömb elemeit számítsa ki véletlen szám generálással! (-10 < v(i) <=20) Az elemeket írassa ki 5-5 pozíciónként! Egy sorban 10 elem lehet. Határozza meg a pozitív, negatív és zérus elemek számát!

F27) Egy N elemű egydimenziós tömb elemeiről eldöntendő, hogy: - növekvő sorrendbe rendezettek, - csökkenő sorrendbe rendezettek, - rendezetlenek, - valamennyi egyforma.

F28) Egy N elemű egydimenziós tömb elemeiről eldöntendő, hogy számtani sorozatot alkotnak-e? F29) Input : N, a(1), a(2), ... a(N) N <= 100

Válasszon ki egy véletlen indexű elemet és határozza meg a nála nagyobb és kisebb elemek számát! Határozza meg a negatív elemek átlagát!

F30) Input: N, x(1), ... x(N) ahol 1<=N<=100 Határozza meg a minimális elem nagyságát és első előfordulásának indexét!

F31) Input: x(1), x(2), .... x(50), K Határozza meg, hogy K értéke megtalálható-e az x vektor elemei között! A fela- datot oldja meg a szekvenciális keresés és a bináris keresés módszerével is.

F32) Rendezze az N elemű V vektor elemeit növekvő sorrendbe! A feladatot oldja meg többféle rendezési módszerrel!

F33) Számítsa ki egy 20 elemű egydimenziós tömb szomszédos elemeinek összegét a következő párokra: (1,2), (3,4),...stb.

F34) Egy egydimenziós tömbbe szúrjon be egy elemet egy adott indexű helyre!

IN-501 59

F35) Egy egydimenziós tömbből töröljön egy adott indexű elemet! F36) Egy növekvő sorrendbe rendezett egydimenziós tömbbe szúrjon be egy adott értékű elemet

úgy, hogy a rendezettség megmaradjon! F37) Egy csökkenő sorrendbe rendezett egydimenziós tömbből töröljön egy adott értékű elemet! F38) A 10 elemű X és 20 elemű Y vektorok elemeit írassa a képernyőre külön-külön sorba!

Határozza meg, hogy X elemei között van-e 2 vagy több egyforma! Írassa ki azokat az elemeket, amelyek X-ben is és Y-ban is megtalálhatók.

F39) Egy 10 elemű egydimenziós tömb elemeit írja ki a képernyőre, majd a V billentyű lenyomásáig ismétlődjön a következő: J billentyű leütésekor: az elemek eggyel jobbra lépnek B billentyű leütésekor: az elemek eggyel balra lépnek.

F40) Olvasson be szövegként egy 1996-os dátumot EEHHNN formában. Írassa ki a dátumot az évszak, a hónap és nap szöveges megadásával. Számítsa ki, hogy az adott nap az év hányadik napja! Január 1-én hétfő volt. A hónapok napjai 1996-ban:31,29,31,30,31,30,31,31,30,31,30,31

F41) Az 5x10-es M mátrix elemeit adja meg véletlen szám generálásával sorfolytonosan! ( -500 <= M(i,j) <= 999 ) Határozza meg, hogy az elemek között hány db. egy- , két- és háromjegyű van! A mátrixot és a számított értékeket írassa ki!

F42) A 8x10-es M mátrix elemeit adja meg véletlen szám generálásával oszlopfolytonosan ( 0 <= M(i,j) <=9 )! Írassa ki a mátrix sorai mellé a következő üzenetek valamelyikét :a sorban van 0 elem ill. a sorban nincs 0 elem.

F43) Az 5X10-es M mátrix minden elemét csökkentse a mátrix legkisebb abszolút értékű elemével. F44) Az 5x10-es M mátrix elemeit írja át oszlopfolytonosan az 50 elemű V vektorba fordított

sorrendben ( V(1) értéke M(5,10) legyen) ! F45) Az 5x5-ös A mátrix elemeit írja át a 10x10-es B mátrix ”jobb felső” részébe! F46) Számítsa ki az 5x10-es M mátrix sorösszegeit és oszlopösszegeit! A mátrixot és az

összegeket írassa ki a képernyőre! F47) A 10x10-es M mátrixban cserélje fel az 5. és 10. sor elemeit! Írassa ki az eredeti és az új

adatokat! F48) Egy 10X15-ös mátrixból válasszon ki egy elemet, és azt írja ki más színnel. Ezt a más színt a

kurzormozgató billentyűkkel mozgassuk. Az "M" billentyű leütésével "megfogjuk" az elemet és ezt követôen az egész sor ill. oszlop mozdul a kurzormozgató billentyűkre. A "megfogás" az "F" billentyű leütésével feloldható.

F49) Állítsa elő a 10x10-es M mátrix transzponáltját (az elemek tükrözése a főátlóra)! F50) Számítsa ki az 5x10-es A és 10x20-as B mátrixok szorzatát! Az eredményt az 5x20-as C

mátrixban tárolja!

IN-501 60

Irodalomjegyzék: Felhasznált és ajánlott irodalom: [1] Wirth: Algoritmusok + Adatstruktúrák=Programok, Műszaki Könyvkiadó, Bp., 1982.

[2] Marton László: Bevezetés a Pascal nyelvű programozásba, NOVADAT, 1994.

[3] Benkő Tiborné, Benkő László, Tóth Bertalan, Varga Balázs:

Programozzunk Turbo Pascal nyelven, ComputerBooks, Bp., 1998.

[4] Marton-Fehérvári: Algoritmusok és adatstruktúrák, NOVADAT Könyvkiadó, Győr, 2002.