programozas i-ii kidolgozott peldak es peldatar

7/24/2019 Programozas I-II Kidolgozott Peldak Es Peldatar

http://slidepdf.com/reader/full/programozas-i-ii-kidolgozott-peldak-es-peldatar 1/75

Programozás I-II

Kidolgozott példák és példatár

Dávid András

ÓE-AREK-8004

Budapest, 2013

ÓBUDAI EGYETEM



Tartalom jegyzék 1. Kidolgozott példák C++ programozásra ...................................................................................... 5

1.1. Vezérlési szerkezetek és egyszerű adattípusok .......................................................................... 5

1.1.1. Szekvencia és elágazás ............................................................................................................... 5

1.1.2. Ismétlés, ciklus ............................................................................................................................ 7

1.1.3. Egy különleges adattípus, a pointer vagy mutató .................................................................... 11

1.2. Összetett adattípusok ............................................................................................................... 11

1.2.1. Egydimenziós tömbök, vektorok .............................................................................................. 11

1.2.2. Gyakorisági tömbök .................................................................................................................. 17

1.2.3. Karaktertömbök ........................................................................................................................ 18

1.2.4. Kétdimenziós tömbök, mátrixok .............................................................................................. 20

1.3. Függvények, paraméterátadás ................................................................................................. 24

1.3.1. Érték szerinti paraméterátadás ................................................................................................ 241.3.2. Cím szerinti paraméterátadás .................................................................................................. 25

1.3.3. Érték szerint pointerváltozó (memória cím) átadás ................................................................. 25

1.3.4. A tömb, mint paraméter:.......................................................................................................... 26

1.4. Önállóan kidolgozandó feladatok C .......................................................................................... 33

1.4.1. Kis programrészletek visszafejtése ........................................................................................... 33

1.4.2. Egyszerű programok (egyszerű adattípusok) ........................................................................... 34

1.4.3. Egydimenziós tömbök (vektorok), karaktertömbök ................................................................. 36

1.4.4. Gyakorisági tömbök .................................................................................................................. 37

1.4.5. Kétdimenziós tömbök, mátrixok .............................................................................................. 38

1.4.6. Függvények, paraméterátadás ................................................................................................. 38

2. Kidolgozott feladatok ASM programozásra .............................................................................. 41

2.1. Adatmozgató, aritmetikai és vezérlésátadó utasítások ........................................................... 41

2.2. Bitműveletek, logikai utasítások ............................................................................................... 46

2.3. Léptető (shift) és forgató (rotate) műveletek .......................................................................... 48

2.4. Input/output műveletek ........................................................................................................... 49

2.5. Konverziók ................................................................................................................................ 53

2.6. Sztringműveletek ...................................................................................................................... 57

2.7. Procedúrák, makrók használata ............................................................................................... 58

2.7.1. Procedúrák ............................................................................................................................... 58

2.7.2. Makrók ...................................................................................................................................... 62

2.8. Gépi kódos példák .................................................................................................................... 63

2.9. Önállóan kidolgozandó feladatok ASM .................................................................................... 71

2.9.1. Címzési módok, aritmetikai utasítások, ciklusok ...................................................................... 71

2.9.2. Klaviatúra - képernyő I/O, összehasonlítás, vezérlés átadás .................................................... 72

2.9.3. Bitműveletek - logikai utasítások .............................................................................................. 72

2.9.4. Alprogramok ............................................................................................................................. 74



Bevezetés

Nagyon sok programozási nyelv (pl. C#, php) C alapú, ezért ebben a jegyzetben nagyhangsúlyt fektetek arra, hogy C nyelv alapjait minél jobban megismerjék kidolgozottfeladatokon keresztül.

Bevezetésképpen szeretnék a kedves Olvasónak, programozást tanuló kollégánaknéhány gondolatot, tanácsot leírni.

Az első fontos kérdés, hogy hogyan lehet, szabad, érdemes programozást tanulni.Véleményem szerint „programozást tanulni” nem lehet (csak) könyvből. A legtöbb könyv egyadott programozási nyelv részletes taglalásával, utasításainak ismertetésével foglalkozik. Nemazt állítom, hogy lehetetlen így megtanulni bizonyos dolgokat, fogásokat, de véleményemszerint így „csőlátású” lesz az Illető. Ha „megtanul” C- ben fogásokat, kínkeservvel vált majdPascalra, vagy bármely más programozási nyelvre.

Mivel Önök talán most tanulnak először programozást, szeretném, ha a programozás

lényegét megízlelnék, problémacentrikus szemléletmódra tennének szert. Ehhez szeretnéksegítséget adni ezzel a kis példatárral. Mivel Önök az Egyetemünkön C alapú és IntelAssembly alapú programozási nyelveket tanulnak, ezért ez a segédlet C++ és I8086 assemblynyelvű kidolgozott feladatokat tartalmaz. A példatár végén találhatók önállóan kidolgozandó

példák mindkét programozási nyelvre. A magas szintű nyelvek összetett utasításokkal, azalacsonyszintű nyelvek egyszerű utasításokkal operálnak, így a példatár végén az önállóankidolgozandó feladatok is programozási nyelv szerint elkülönítve találhatók.

Továbbá figyelmükbe ajánlom a Bevezetés az algoritmustanba és programozási tételekcímű segédletemet, amelyben röviden ismertetem az algoritmustan alapfogalmait, az

algoritmus-leíró módszereket, eszközöket, a strukturált programozás alapelveit, illetve atanulmányaik során gyakran használt programozási tételeket. A jegyzet felépítése példatárszerkezetű, vagyis az elméleti ismeretek rövid közlése után kidolgozott példák, és Önök általönállóan kidolgozandó feladatok találhatók.

A C nyelv alapjainak megismeréséhez Benkő Tiborné, Benkő László, Tóth Bertalan:Programozzunk C nyelven1 című könyvét, az Intel assembly programozás alapjainak

megismeréséhez pedig Pethő Ádám: Assembly alapismeretek 2

című könyvét ajánlom afigyelmükbe. A jegyzet végén található irodalomjegyzékben további segédleteket és ajánlottkönyveket találnak.

1 Benkő Tiborné, Benkő László, Tóth Bertalan: Programozzunk C nyelven, ComputerBooks, 2003

2 Pethő Ádám: Assembly alapismeretek 1. kötet, Számalk, 1992



5

1.

Kidolgozott példák C++ programozásra

1.1. Vezérlési szerkezetek és egyszerű adattípusok

1.1.1. Szekvencia és elágazás

A programkészítés során törekednünk kell arra, hogy a „strukturált programozás” alapelveit betartsuk. A strukturált programozás 3 vezérlési szerkezetet enged meg:

Szekvencia: A programutasítások egymás után (a leírás sorrendjében) hajtódnakvégre.

Elágazás: Egy vagy több feltételtől függően a program végrehajtása két vagy többágon folytatódhat az elágazás végéig, és aztán újra egy ágon történik az utasításvégrehajtás.

Ismétlés, ciklus: Egy vagy több programutasítást ismételten többször kell végrehajtani. A programkészítés során elemi vagy egyszerű, illetve összetett adattípusokkal fogunkdolgozni. Az elemi adattípusok azok az adattípusok, amelyek nem bonthatók kisebbegységekre. Pl. egész, valós, karakter, pointer típus. Az összetett adattípus az az adattípus,

amely több elemi (vagy összetett) adattípusból épül fel. Pl. a tömb olyan összetett adattípus,amely azonos típusú adatokból épül fel. Az összetett adattípus felbontható kisebb egységekre.Az egyszerű adattípusokról részletesen olvashat Benkő Tiborné, Benkő László, Tóth Bertalan:Programozzunk C nyelven című könyvében3.

Első lépésként nézzünk olyan feladatokat, ahol elágazást tartalmaz a program. A szekvenciára

nem oldunk meg külön feladatot, mivel szekvenciát minden egyes programunk tartalmaznifog.

1.1.1.1. Készítsen programot, amely meghatározza egy egész számot reciprokát!

A matematikai modell: areciprokaa /1: , ahol „a” beolvasott egész szám.

Beolvasunk egy számot (pl. a), kiszámol juk és kiírat juk a reciprokát. Ha a beolvasott szám 0,akkor számolhatunk reciprokot? Nem. Egy elágazás feltétele lesz az a=0. Ha a feltétel hamis,

ak kor számolunk reciprokot, ha igaz, akkor kiírunk egy üzenetet (0-val való osztás nemértelmezett).

A C programkódban találhatjuk a következő sort: „r=1/(float)a”. A programban az „a” változóegész típusú, az „r” változó valós típusú. Az „r=1/a” értékadó utasítás során a jobb oldalkiértékelődik, és az eredmény az „r” változóban megjelenik. Mivel az „a” egész típusú (az 1

pedig konstans), ezért a „/” egész osztást jelent. Ha pl. a=2, akkor az eredmény 0 lesz, az „r”változó a 0 értéket veszi fel. Ez hiba természetesen, mert a 2 reciproka 0.5. Az „ r=1/(float)a”

utasítássor esetén típuskényszerítés történik. Az „a” változót valósként kezeli a compiler,vagyis értéke 2.0. Az osztás valós osztás lesz, így az eredmény 0.5 lesz.

3 Benkő Tiborné, Benkő László, Tóth Bertalan: Programozzunk C nyelven 38-55. oldal



6

Start

a, b, cBe:

(a+b>c) és

(a+c>b) és

(b+c>a)Hamis

Igaz

Stop

"Nem szerkeszthetõ

háromszög"Ki:

k:=a+b+c

s:=k/2

t:=gyök((s*(s-a)*(s-b)*(s-c))

k, tKi:

Elágazás

2. ábra. Az 1.1.1.2. feladat folyamatábrája

Start

aBe:

a=0 Igaz "Hiba!"Ki:

Hamis

r:=1/a

r Ki:

Stop

Reciprok(a,r)

1. read a2.

if a=03. then 4.

write „Hibás adat,0-val való osztás” 5.

else

6. r 1/a : write r

int _tmain(int argc, _TCHAR* argv[]){int a; float r;// a szám beolvasása printf("\n a= "); scanf("%d",&a);// reciprok képzés if (a==0) {printf("\n Hibás adat"};} else {r=1/(float)a;

printf("\nA %d reciproka%5.4f",a,r);}}

1. ábra. Az 1.1.1.1. feladat folyamatábrával, peszeudokóddal és a programlista

1.1.1.2. Készítsen programot , amely kiszámítja egy háromszög kerületét és területét a HERON képlet segítségével !

A matematikai modell: )(*)(*)(*;2/; c sb sa s sT K scba K , ahol az „a”, „ b”, „c”

a háromszög három oldala, „K ” a kerülete, „T” a területe.

Be kell olvasnunk a háromszög oldaladatait

(a, b, c), meg kell határoznunk, hogy

szerkeszthető-e háromszög. Ha igen, akkor ki kell számolni a kerületét és a területét a

matematikai modellben megadott képlet segítségével. A háromszög megszerkeszthető,ha igaz az a feltétel, hogy bármely két oldalösszege nagyobb, mint harmadik oldal. Az előző példában az elágazás feltétele egyegyszerű feltétel volt (a=0). Ebben a

példában az elágazás feltétele egy összetettfeltétel (a+b>c és a+c>b és b+c>a). A

feltételek között „és” kapcsolat van, vagyis

akkor igaz az összetett feltétel, ha mindenrészfeltétel igaz. A tesztelés során próbáljuk ki a programotkülönböző adatokkal! Pl. ha a=2, b=3, c=5,

akkor nem szerkeszthető háromszög. Önállófeladatként módosítsa a programot úgy, hogyírjon ki egy üzenetet a program, ha aháromszög derékszögű.



7

Háromszög() 1.

read a,b,c2.

if (a+b>c) and(a+c>b) and (b+c>a)

3.

then

4.

k a+b+c5.

s k/2

6.

t gyök((s*(s-a)*(s-b)*(s-c))

7. write k,t

8. else

9.

write „Nem szer-keszthető három-

szög”

int _tmain(int argc, _TCHAR* argv[]){float a, b, c, s, k, t;printf("\nKerem a haromszög harom

oldaladatat!");printf("\na="); scanf("%f",&a);

printf("\nb="); scanf("%f",&b);printf("\nc="); scanf("%f",&c);if ((a+b>c)&&(a+c>b)&&(b+c>a))//igaz, szerkeszthető háromszög { k=a+b+c;s=k/2;

t=sqrt(s*(s-a)*(s-b)*(s-c));printf("\nK=%6.2f,T=%6.2f",k,t); }

else printf("\n Nem szerkeszthetoharomszog.");}return 0;}

3. ábra. Az 1.1.1.2. feladat pszeudokódja és programlistája

zsebpenz -koltopenz

>=0

nap:=nap+1

Igaz

H a m i s

Start

koltopenz:=10

nap:=0

Be:zsebpenz

zsebpenz:=

zsebpenz-

koltopenz

koltopenz:=

koltopenz+5

Stop

E l ö l t e s z t e l ő

c i k l u s

Költekezés() 1. read zsebpenz

2. nap 0 : koltopenz 103.

while zsebpenz-koltopenz >= 0

4.

do

5. nap nap+1 : zsebpenz zsebpenz-koltopenz

6. koltopenz koltopenz+57.

write nap, zsebpenz

int _tmain(int argc, _TCHAR* argv[]){int zsebpenz, koltopenz=10, nap=0;printf("\nZsebpenz=");scanf("%i",&zsebpenz);while(zsebpenz-koltopenz>=0){nap++; zsebpenz=zsebpenz-koltopenz;koltopenz=koltopenz+5;}

printf("\n%inapig tud vasarolni,%iFt-ja marad",nap,zsebpenz);}

4. ábra. Az 1.1.2.1. feladat folyamatábrája, pszeudokódja és programlistája

1.1.2. Ismétlés, ciklus

A következő néhány feladat a ciklusműveletekre mutat be példákat.

1.1.2.1. Egy gyerek a szüleitől P Ft zsebpénzt kapott. Az első napon 10 Ft - ot költött, majdezután minden nap 5 Ft- tal többet. Készítsen programot, amely meghatározza, hogy hánynapig tudta ezt a költekezést folytatni, és mennyi „töredék” pénzemaradt? A Zsebpénzt olvassa be, az eredményt írja ki!

Próbáljuk a gyerek helyébe képzelni magunkat. Kapunk„zseb pénz” Ft-t, elköltünk belőle az első napon 10 Ft-ot. A

következő nap már 15 Ft-ot fogunk elkölteni. Hány napig tudunkígy a büfében étkezni? Addig, amíg a maradék pénzünk több vagyéppen egyenlő a következő nap elköltendő pénzzel. A megoldásegy ismétlődő műveletsor , ciklus lesz. A ciklus elöltesztelő ciklus,mivel először megvizsgáljuk, hogy van-e elegendő pénzünk, haigen, akkor végrehajtjuk a ciklusmagot.



8

LNKO()

1.

read a, b

2. while a b

3.

do

4. if a>b

5. then a a-b6.

else b b-a7.

write a

Start

a, bBe:

a nem

egyenlõ b

Igaz

a>b

Igaz

a:=a-b

Hamis

b:=b-a

Hamis aKi:

Stop

int _tmain(int argc, _TCHAR* argv[]){ int a,b;

printf("a="); scanf("%i",&a);printf("b="); scanf("%i",&b);while(a!=b){ if(a>b) a=a-b; else b=b-a;}

printf("\n A legnagyobb kozos oszto= %i",a);}



Átlag()

1. összeg 0 : db 02.

repeat

3. read szám : összeg összeg+szám : db db+1

4. until szám 0

5. átlag összeg/db : write átlag

int _tmain(int argc, _TCHAR* argv[]){ int szam,osszeg=0,db=0;

float atlag;do {printf("\nSzám=");scanf("%i",&szam);

osszeg=osszeg+szam; db++;}while(szam!=0);

db--; atlag=(float)osszeg/(float)db;

Start

számBe:

összeg:=0

db:=0

összeg:=

összeg+szám

db:=db+1

szám

nem 0Igaz

Hamis

db:=db-1

átlag:=összeg/db

átlagKi:

Stop

H á t u l - t e s z t e l ő

c i k l u s

1.1.2.2. Készítsen programot, amely meghatározza két természetes szám legnagyobb közösosztóját az Euklideszi algoritmus segítségével!

Az Euklideszi algoritmus a következő: Megvizsgáljuk, hogy a két szám közül melyik anagyobb. A nagyobból kivonjuk a kisebbet, ez lesz a

szám új értéke. A vizsgálatot és a kivonást addigismételjük, amíg a két szám értéke egyenlő nem lesz.Ekkor a két szám értéke a legnagyobb közös osztó. A megoldás lépései: Be kell olvasnunk két számot (a, b),meg kell határoznunk a legnagyobb közös osztót a fentismertetett algoritmus segítségével. Ismételt, ciklikusműveletet kell ehhez végeznünk , de nem használhatunknövekményes ciklust (bár a C++ - ban ezt megtehetnénk),mivel nem tudjuk, hogy hányszor kell az ismétlést

végrehajtanunk. A ciklus végrehajtását egy feltételvezérli (a b), így tesztelő ciklust fogunk használni. A

feladat megoldását elől-tesztelő ciklussal mutatjuk be.

1.1.2.3. Kérjünk be a billentyűzetről egész számokat 0 végjelig,határozzuk meg az átlagukat!

Számokat kell beolvasnunk 0 végjelig. (a legutolsó szám a 0, ez

jelzi az input végét).



9


int _tmain(int argc, _TCHAR* argv[]){ int a,b,i,osszeg=0;

printf("\na=");scanf("%i",&a);printf("\nb=");scanf("%i",&b);for(i=a;i<=b;i++){ if(i%2!=0){ osszeg=osszeg+i; } }printf("\n Az osszeg= %i",osszeg); return 0;}

Start

a, bBe:

i:=a-tól b-ig

1-sével

összeg:=0

i páratlan

Igaz

összeg:=összeg+i

Hamis

összegKi:

Stop

N ö v e k m é n y e s

c i k l u s

Páratlanösszeg() 1. read a, b2.

osszeg 03.

for i a to b4.

do 5.

if i páratlan then osszeg osszeg+i6.

write összeg

Ismételt, ciklikus műveletet kell végeznünk , de nem használhatunk növekményes ciklust,mivel nem tudjuk, hogy hányszor kell az ismétlést végrehajtanunk. A ciklus végrehajtását egyfeltétel vezérli (szám 0), így tesztelő ciklust fogunk használni. Megoldjuk a feladatot hátul-tesztelő ciklussal, az olvasóra bízom, hogy oldja meg elől-tesztelő ciklussal is, ekkor

előolvasást is kell végezni. Ez a feladat tipikus „hátul-tesztelős feladat”. Az átlagképzéshezszükség van a beolvasott számok összegére és darabszámára.

1.1.2.4. Készít sen programot, amely megh atározza a páratlan számok összegét a- tól b-ig! (aés b bármelyike lehet páros illetve páratlan is)

A feladat szerint k ét érték (a, mint alsó érték és b, mint felső érték ) közötti páratlan számokösszegét kell képeznünk.

A matematikai modell: , ahol „a” és „ b” a kétintervallumhatár.

Be kell olvasnunk két számot (a, b), meg kell határoznunk a és b közötti páratlan számokösszegét. Célszerűen egy ciklussal (méghozzá növekményes ciklussal) állítjuk elő azösszeadandó számokat. Az összegképzést halmozott összegképzéssel, az összegzés tételétfelhasználva valósítjuk meg. A program megírásánál kérdés lehet még, hogy mikor párosilletve páratlan egy szám. Páros a szám, ha 2-vel elosztva az osztási maradéka 0. A C++-ban

az egész számok körében a „/” az egész osztást, a „%”

(moduló), a maradékos osztást jelenti. A „%” osztás az osztásimaradékot adja eredményül. A C++ nyelvben a for (növekményes) ciklus sok feladatban

felhasználható. Szintaktikája: for(inicializáló kifejezés;feltételes kifejezés; léptető kifejezés). Ezt kihasználvamegoldhatjuk úgy is feladatot, hogy biztosítjuk azt, hogy az„a” változó páratlan értékről induljon, majd a ciklusbankettesével léptetjük az összeadandó számokat. Ekkor aciklusmagban a feltételvizsgálat elmaradhat. Ez lényegesidőmegtakarítással jár, hatékonyabb algoritmust kapunk.

)(:;,: i páratlan Kiba Beb

ai



10

int _tmain(int argc, _TCHAR* argv[]){ int szam, szjossz=0;

printf("\nSzam= ");scanf("%i",&szam);

while(szam!=0){szjossz=szjossz+szam%10;szam=szam/10;}

printf("\nSzamjegyek osszege= %i",szjossz);}

Számjegyösszeg() 1.

szjossz 02. read szam

3.

while szam 04.

do 5.

szjossz szjossz+szam%106. szam szam/107.

write szjossz


Erre a feladatra létezik egy zárt matematikai formula, amely alul látható. Az „a1” a sorozat

első tagja, az „an” a sorozat n. tagja, „n” a sorozat tagjainak a száma. „Sn” a sorozat n tagjánakaz összege. Önálló feladatként készítse el azt a programot, amely kiszámolja az adott formulaszerint a számtani sorozat n elemének az összegét.

1.1.2.5.

Készítsen programot, amely meghatározza egy egész szám számjegyeinek összegét!

A feladat során egy egész típusú számot számjegyeire bontunk, és meghatározzuk a

számjegyeinek az összegét. Ha egy egész számot maradékosan elosztunk 10-el, akkor

megkapjuk az utolsó számjegyét. A megoldás során ciklikusan osztjuk a számot maradékosan10-el (a maradékot, mint számjegyet hozzáadjuk egy összeg változóhoz), majd a számotelosztjuk egész osztással 10-el. A ciklus egészen addig fog futni, amíg a szám 0-vá nem válik.

1.1.2.6. Készítsen programot, amely kiszámítja PI /2 értékét az alábbi végtelen sorozat elsőn tényezőjének figyelembevételével! PI /2=2/1*2/3* 4/3* 4/5* 6/5* 6/7* 8/7* 8/9* .... A tényezőkszámát (n) a felhasználó adja meg!

Matematikai modell:

A számláló kezdőértéke=2, a nevező kezdőértéke=1.

A megoldás során egy növekményes ciklussal dolgozunk, mivel tudjuk, hogy n tényezőt kellmajd figyelembe vennünk. Törtek szorzatát kell előállítanunk. A számláló 2-ről indul, ésminden páratlan tagnál 2-vel kell növelni a számlálót. A nevező 1-ről indul, és minden párostagnál kell a nevezőt növelni 2-vel.

Önálló feladatként alakítsa át úgy az algoritmust, hogy a felhasználó által megadott közelítési pontosságig fusson a program! int _tmain(int argc, _TCHAR* argv[])

{ float szamlalo = 2.0, nevezo = 1.0; float pi2=szamlalo/nevezo;int i,n;printf("\ntenyezok szama="); scanf("%i",&n);}for(i=2;i<=n;i++){if(i%2!=0) {szamlalo=szamlalo+2;} else {nevezo=nevezo+2;}pi2=pi2*(szamlalo/nevezo);}

printf("\nPi/2 erteke=%6.2f",pi2);}

2

*)( 1 naaS nn

9. ábra. Az 1.1.2.6. feladat programlistája

n

inevez ő

számláló Pi2

2/

2: számláló számlálóeseténi páratlan

2: nevez ő nevez ő egyébként



12

Vektor1()

1.

for i 0 to hossz[t]2. do read t[i]

3. for i 0 to hossz[t]4.

do write t[i]

int _tmain(int argc, _TCHAR* argv[]){ int t[10],i;for(i=0;i<10;i++) //Beolvasás {printf("\n%i.elem= ",i);scanf("%i",&t[i]);}

for(i=0;i<10;i++){printf("%i\t",t[i]);}}


Vektor2()

1.

i 02.

repeat

3.

read t[i] : i i+1

4. until t[i-1] 0 and i<hossz[t]

5. if i=hossz[t]

6.

then n i else n i-17.

for i 0 to n do write t i

int _tmain(int argc, _TCHAR* argv[]){int t[100], i=0,n;do {printf("%i.elem= ",i);

scanf("%i",&t[i]); i++;}while(t[i-1]!=0 && i<100);

if(i==100) {n=i;} else {n=i-1;}for(i=0;i<n;i++)

{printf("%i\t",t[i]);}}


1.2.1.2. Olvassunk be egész számokat egy vektorba 0 végjelig, majd írjuk ki az elemeket aképernyőre!

Egy tömböt kell beolvasnunk „0 végjelig”, majd ki kell írnunk a tömbelemeket. A „0végjelig” való beolvasás azt jelenti, hogy elemeket olvasunk be egészen addig, amíg „0”-átnem olvastunk. A „0” jelzi a beolvasás végét. A feladatok megoldása során a „0”-át már nemtekintjük érvényes tömbelemnek. Mivel statikus tömbökkel foglalkozunk, egy újabb

tömbelem beolvasása előtt vizsgálnunk kell azt is, hogy van-e még hely a tömbben(i<maxelemszám). A beolvasás után meg kell határoznunk a beolvasott elemek számát. Ha

végjelre („0”-ra lépünk ki), akkor a beolvasott elemek száma egyenlő tömbindex-1-el, ha nem

(betelt a tömb), akkor a beolvasott elemek száma egyenlő a maxelemszámmal.

1.2.1.3. Ol juk meg az előző (1.2.1.2.) feladatot pointerváltozók segítségével! A C nyelvben a tömb neve egy pointerváltozó, vagyis a tömb neve a tömb memóriabelikezdőcíme. A megoldás során a tömb nevét, mint pointerváltozót fogjuk felhasználni. A

beolvasó és kiíró ciklusban nem indexelni fogjuk a tömböt, hanem a pointerváltozót, mint

címet fogjuk inkrementálni (vagy dekrementálni). Ebből is látszik, hogy a pointerváltozónakvan típusa. Ha pl. egész típusú tömbünk van, és egy-egy egész típusú elemet 4 bájton tárol a

rendszer, akkor a pointerváltozó értékének az inkrementálása automatikusan 4-el valónövelést fog jelenteni. int _tmain(int argc, _TCHAR* argv[]){int t[100],i=0,n=-1;int *tp=t; //a tomb neve egy pointervaltozo, tomb 0. elemenek a cimetp--;do{tp++;n++; //a tombre mutato pointervaltozot inkrementaljuk,

//n a beolvasott elemek szamaprintf("%i.elem= ",n);scanf("%i",tp);

}while(*tp!=0 && n<100); //kilepes, ha 0 vegjelet olvastunk be,tp=t; //vagy betelt a tombfor(;*tp!=0;tp++) //kiiras addig, amig a tombelem nem a 0 vegjel

{printf("%i\t",(*tp));}}




13

1.2.1.4. Olvassunk be egész számokat egy vektorba 0 végjelig, majd oldjuk meg a következőfeladatokat!

a) Adjuk meg a tömb elemeinek átlagát! b) Döntsük el, hogy van- e páros elem a tömb elemei között!

c)

Adjuk meg az első páros elem indexét! d) Adjuk meg a páros elemek darabszámát! e) Adjuk meg a legkisebb és a legnagyobb elemet!

Ezt a feladatot részenként (külön az a), b) … e)) oldjuk meg. Ezek a feladatok a jól ismert programozási tételekre épülnek .a) feladat: A megoldás során az összegzés tételét alkalmazzuk. Egy „összeg” változóhoz(melynek a kezdőértéke 0) ciklikusan hozzáadjuk a tömb elemeit.

b)

feladat: A megoldás során az eldöntés tételét alkalmazzuk. Nem szükséges a tömb összeselemét megvizsgálnunk (hogy páros-e vagy sem), hiszen, ha megtaláljuk az első páros elemet,

akkor már tudunk válaszolni a kérdésre. c) feladat: A megoldás során a lineáris keresés tételét alkalmazzuk. A b) feladat

megoldásához hasonlóan járunk el. A vizsgálóciklusból való kilépéskor, ha találtunk pároselemet a tömbben, akkor ennek az elemnek a tömbindexe adja a megoldást. d) feladat: A megoldás során a megszámolás tételét alkalmazzuk. Ciklikusan végigvizsgáljuka tömb elemeit, a páros elemeknél egy változó értékét (pl. db) megnöveljük 1-el. A db változókezdőértéke 0. e) feladat: A megoldás során a minimum, illetve a maximum kiválasztás tételét alkalmazzuk.

Kezdetben feltételezzük, hogy a legkisebb illetve a legnagyobb elem értéke egyenlő a tömb 0.elemével („min” és „max” változó). Ciklikusan végigvizsgáljuk a tömb elemeit, és ha azaddig feltételezett legkisebb elemnél kisebb, illetve az addig feltételezett legnagyobb elemnélnagyobb elemet találunk, akkor a min illetve a max változóban megjegyezzük a tömbelemértékét. int _tmain(int argc, _TCHAR* argv[]){ int t[100], i = 0, n;

do {printf("\n%i.elem= ",i); scanf("%i",&t[i]); i++;}while(t[i-1]!=0 && i<100);

if(i==100){n=i;} else {n=i-1;}int osszeg=0; float atlag; //a) feladat, összegzés for(i=0;i<n;i++)

{ osszeg=osszeg+t[i];}

atlag=(float)osszeg/(float)n;printf("\nA tomb elemeinek az atlaga= %6.2f", atlag);//b) és c) feladat, eldöntés és lineáris keresés i=0; int sorsz;while(t[i]%2!=0 && i<n)

{ i++; }if (i<n) {sorsz=i; printf("\nVan paros elem, indexe= %i", sorsz);}else {printf("\nNincs paros elem");}int db=0; //d) feladat, megszámolás for (i=0;i<n;i++)

{ if(t[i]%2==0) { db++; } }printf("\nA paros elemek darabszama= %i",db);



14



16. ábra. Az 1.2.1.6. feladat ro ramlistá a

//e) feladat, minimum és maximum kiválasztás int min=t[0], max=t[0];for (i=1;i<n;i++){ if(t[i]<min) { min=t[i]; }

if(t[i]>max) { max=t[i]; } }printf("\nA tomb legkisebb eleme= %i,

legnagyobb eleme= %i",min, max); return 0; }

1.2.1.5. Töltsön fel egy 10 elemű egész típusú tömböt „véletlenszámokkal”, úgy, hogy ne

legyen két azonos értékű elem. Ezután írja ki az elemeket a képernyőre. A „véletlenszámokkal” való feltöltés azt jelenti, hogy a fejlesztői rendszerünk (jelen esetben aC++) un. véletlenszám generátorával választunk számokat, és ezek a számok lesznek a tömbelemei. Ebben a feladatban kikötés, hogy nem lehet két egyforma szám a tömbben. Amikorgenerálunk egy számot, megnézzük, hogy szerepel-e már a tömbben (lineáris keresés tétele).Ha nem, akkor betesszük a tömbbe, ha igen, akkor új számot generálunk. Használat előtt a

véletlenszám generátort inicializálnunk kell. int _tmain(int argc, _TCHAR* argv[]){ int t[10],i=0,j,szam; int nincs;

srand (time(NULL)); //veletlenszam generator inicializalasawhile(i<10) //feltöltés {szam=rand()%10;j=0; //keresés while(t[j]!=szam && j<i)

{j++;}nincs=(j==i);if (nincs) { t[i]=szam; i++; }}printf("\nA tomb elemei:");for(i=0;i<10;i++) {printf("%8i",t[i]);}}

1.2.1.6. Készítsen programot, mely egy 10 elemű vektor elemeit 1 hellyel előre mozgatja, ésaz első elem az utolsó helyre kerül. A feltöltést véletlenszám generátorral oldja meg, majdírja ki az eredeti és az új vektort!

A megoldás során a tömb 0. elemét elmentjük egy segédváltozóba, majd ciklikusan a tömbi-1. elemét felülírjuk az i. elemmel. A ciklus lefutása után a legutolsó elembe betöltjük asegédváltozóba elmentett 0. elemet. int _tmain(int argc, _TCHAR* argv[])

{int t[10]; int i, seg;srand (time(NULL)); //veletlenszam generator inicializalasafor(i=0;i<10;i++) {t[i]=rand()%10;} //feltöltés printf("\nA tomb elemei:"); //kiírás for(i=0;i<10;i++) {printf("\t%i",t[i]);}//mozgatás seg=t[0]; for(i=1;i<10;i++) {t[i-1]=t[i];} t[9]=seg;printf("\nA tomb elemei mozgatas utan:");for(i=0;i<10;i++) {printf("\t%i",t[i]);} return 0; }



15


18. ábra. Az 1.2.1.8.feladat programlistája

1.2.1.7. Írjon programot, amely egy 10 elemű egész típusú tömb elemeiről eldönti, hogyszámtani sorozatot alkotnak - e! A tömböt a klaviatúráról történő beolvasással töltse fel,majd a megfelelő szöveges üzenetet írja ki a képernyőre!

Egy sorozat akkor számtani sorozat, ha a szomszédos elemek különbsége állandó. A

megoldás során az eldöntés tételét alkalmazzuk. A tömb 0. és 1. eleméből meghatározzuk a„d”-t (differenciát), majd ciklikus művelettel megvizsgáljuk, hogy a tömb összes szomszédoselemének a különbsége egyenlő-e a „d”-vel.

Önálló feladatként módosítsa úgy az algoritmust, hogy eldöntse, hogy a vektor elemei mértanisorozatot alkotnak-e?int _tmain(int argc, _TCHAR* argv[]){ int t[10];int i=0,n;

printf("\nKerem a tomb elemeit!");do{printf("\n%i.elem= ", i);scanf("%i",&t[i]);i++;

}while(t[i-1]!=0 && i<10);if(i==10) n=i; else n=i-1;

int d=t[1]-t[0]; i=2; //számtani sorozat? while(t[i]-t[i-1]==d && i<n) {i++;}if(i==n) printf("\nSzamtani sorozat");else printf("\nNem szamtani sorozat"); return 0; }

1.2.1.8. Oldjuk meg a z előző (1.2.1.7.) feladatot pointer változók segítségével! A tömb neve egy pointer változó. A részletes magyarázatot lásd az 1.2.1.3. példánál. int _tmain(int argc, _TCHAR* argv[]){ int t[10];int i=0,n=-1;

int *tp=t;tp--;printf("\nKerem a tomb elemeit!");do{tp++;n++;

printf("\n%i.elem= ", n);scanf("%i",tp);}while(*tp!=0 && n<10);

tp=t;int d=*(tp+1)-*tp; //differenciatp++;while(*tp!=0 && (*tp-*(tp-1)==d)) {tp++;}if(*tp==0) printf("\nSzamtani sorozat");else printf("\nNem szamtani sorozat");}

1.2.1.9. Adott egy N elemű sorozat, amely egész számokat tartalmaz. Adjuk meg a

sorozatban található legkisebb pozitív számot! A minimum kiválasztás tételét kell alkalmaznunk, meg kell határoznunk a sorozat legkisebb

pozitív elemét. A kérdés az, hogy mi legyen a „min” változó kezdőértéke. Egyik megoldás az,

hogy megkeressük az első pozitív számot, ez lesz a kezdőérték, és ezt fogjuk majd

összehasonlítani a sorozat következő pozitív elemével. A másik lehetőség, hogy a kezdőértéka változó értékkészlete által megengedett legnagyobb értékű elem lesz, és ezt hasonlítjuk asorozat pozitív elemeivel. Ha nincs a sorozatnak pozitív eleme, az is kiderül, mert akezdőérték nem fog megváltozni.



16

19. ábra. Az 1.2.1.9.a) feladat programlistája

20. ábra. A 1.2.1.9.b) feladat programlistája

a) megoldás: Megkeressük az első pozitív elemet. int _tmain(int argc, _TCHAR* argv[]){int t[10],i=0,n;do{printf("\n%i. elem= ",i);scanf("%i",&t[i]);i++;

}while(t[i-1]!=0 && i<10);if(i==10) n=i; else n=i-1;

for(i=0;i<n;i++) {printf("%8i", t[i]);}i=0; //az első pozitív elem keresése while(t[i]<0 && i<n) {i++;}if(i<n) //van pozitív elem?

{int min=t[i];for(;i<n;i++){if(t[i]>0)

{if(t[i]<min) {min=t[i];}}}printf("\nA tomb legkisebb pozitiv -eleme= %i",min);}

}else { printf("\nNincs a tombnek pozitív eleme");} return 0;}

b) megoldás: A min változónak a + értéket adjuk kezdőértékként.

int _tmain(int argc, _TCHAR* argv[]){ int t[10],i=0,n;

do {printf("\n%i. elem= ",i); scanf("%i",&t[i]);i++;}while(t[i-1]!=0 && i<10);

if(i==10) n=i; else n=i-1;for(i=0;i<n;i++) {printf("%8i", t[i]);}int min=+32767; //+végtelen for(i=0;i<n;i++){if(t[i]>0)

{if(t[i]<min) {min=t[i];}}}if(min!=+32767) //az adott valtozo lehetseges maximalis erteke

{printf("\nA tomb legkisebb pozitiv eleme= %i",min);}else {printf("\nNincs a tombnek pozitív eleme");} return 0;}

1.2.1.10. Adott egy N elemű sorozat (A), és egy M elemű sorozat (B). Adjuk meg a kétsorozat közös elemeit !

A megoldás során két vektort fogunk beolvasni 0 végjelig majd meghatározzuk azokat azelemeket, amelyek mindkét sorozatnak az elemei. A metszetképzés tételét alkalmazzuk. Mivel

a metszetképzés tétele során két halmaz metszetét képezzük, ezért feltételezzük, hogy avektorokban minden elem csak egyszer fordul elő (egy vektort akkor tekinthetünk halmaznak,ha minden elem csak egyszer fordul elő). Az „A” vektor elemeiről (egyesével) eldöntjük,hogy benne vannak-e a „B” vektorban. Ha igen, akkor beletesszük a közös elemekettartalmazó Metszet nevű vektorba. int _tmain(int argc, _TCHAR* argv[]){int a[100], b[100], metszet[100]; int i=0,j=0,k=0,n,m;printf("\nKerem az A vektor elemeit!\n");do{printf("\n%i.elem= ",i);scanf("%i",&a[i]);i++;

}while(a[i-1]!=0 && i<100);if(i==100) n=i; else n=i-1;



17


Gyakoriság()

1.

for i 0 to hossz[dobások]

2.

do dobasok[i] 03.

read dobasok_szama

4. for i 0 to dobasok_szama5.

do

6.

szam véletlenszám(1,6) 7.

dobasok[szam-1]dobasok[szam-1]+1

8. for i 0 to hossz[dobasok]9.

do write dobasok[i]

int _tmain(int argc, _TCHAR* argv[]){int i,szam,dobszam; int dobasok[6];printf("\nDobasok szama= "); scanf("%i",&dobszam);for(i=0;i<6;i++) {dobasok[i]=0;}for(i=0;i<dobszam;i++){szam=rand()%6; dobasok[szam]=dobasok[szam]+1;}

printf("\nDobasok statisztikaja:");

for(i=0;i<6;i++) {printf("\n%4i:%4i",i+1,dobasok[i]);}}


printf("\nKerem a B vektor elemeit!\n");do{printf("\n%i.elem= ",j);scanf("%i",&b[j]);j++;

}while(b[j-1]!=0 && j<100);if(j==100) m=j; else m=j-1;for(i=0;i<n;i++) //metszetképzés

{j=0;

while(j<m && a[i]!=b[j]) {j++;} //keresés if(j<m) {metszet[k]=a[i];k++;} //bennevan}

printf("\nAz A vektor elemei:\n");for(i=0;i<n;i++){printf("%8i",a[i]);}printf("\nA B vektor elemei:\n");for(i=0;i<m;i++){printf("%8i",b[i]);}printf("\nA kozos elemek:\n");for(i=0;i<k;i++){printf("%8i",metszet[i]);}}

1.2.2. Gyakorisági tömbök

A gyakorlati életben sok olyan feladattal találkozunk, amikor valamilyen események

gyakoriságát (előfordulási számát) kell meghatároznunk.

1.2.2.1. Készítsen statisztikát a kocka dobálás eredményeiről! A lehetséges dobás értékek:1, 2, 3, 4, 5, 6. Minden kockadobást véletlenszám- generátorral oldjon meg! A számlálást

gyakoriság i tömb alkalmazásával végezze el, majd az eredményt áttekinthető formában írjaki a képernyőre!

A megoldás során egy 6 elemű tömböt, mintgyakorisági tömböt fogunk használni. A tömb 0.eleme az 1-es dobások, az 1. eleme a 2-es

dobások… darabszámát fogja megadni. Mindenegyes kockadobás után a tömb dobás-1. elemétmegnöveljük 1-el (a C++-ban 0-tól indexeljük atömböket).

1.2.2.2. Készítsen olyan programot, amely megszámolja egy egész számban előfordulószámjegyek számát !A számjegyek számlálását gyakoriságtömb segítségével fogjuk megoldani. A gyakoriságtömb10 elemű lesz, mivel 10 db számjegyünk van. Az egyes számjegyeket maradékos (moduló)osztással fogjuk előállítani, majd a gyakoriságtömb számjegynek megfelelő elemétmegnöveljük 1-el.



18


Számjegyekszáma() 1.

for i 0 to hossz[szamjegyek] do szamjegyek[i] 02.

read szam

3.

while szam 0

4.

do szamjegy szam%10 : szam szam/10 : szamjegyek[szamjegy]

szamjegyek[szamjegy]+15. for i 0 to hossz[szamjegyek] do write szamjegyek[i]

int _tmain(int argc, _TCHAR* argv[]){int szamjegyek[10]; int i,szam,szamjegy;for(i=0;i<10;i++) {szamjegyek[i]=0;}printf("\nSzam= ");scanf("%i",&szam);if(szam==0) {szamjegy[szam]++;}while(szam!=0)

{szamjegy=szam%10;szamjegyek[szamjegy]++;szam=szam/10;}printf("\nAz elofordulo szamjegyek: \n");for(i=0;i<10;i++){printf("\n%i:\t%i",i,szamjegyek[i]);return 0;}


1.2.2.3. Határozzuk meg, hogy egy osztály tanulói közül hány 150 cm alatti, hány 150-160cm közötti, hány 160- 170 cm közötti, hány 170- 180 cm közötti, hány 180- 190 cm közötti éshány 190 cm feletti tanulója van. Készítsen olyan programot, amely előállítja ezenhisz togram adatsorát !

Az adatok beolvasása után gyakorisági tömb segítségével meghatározzuk az adott magasságihatárok közé eső tanulók számát. A gyakorisági tömb 0. eleme a 150 cm alatti tanulók számátfogja számolni, az 1. eleme a 150-160 cm között tanulók számát, … az 5. eleme a 190 cmfeletti tanulók számát. int _tmain(int argc, _TCHAR* argv[]){int magassagok[30];int gyakorisag[6];int i,n;for(i=0;i<6;i++) gyakorisag[i]=0;i=0;do{printf("\n%i.elem= ",i);scanf("%i",&magassagok[i]);i++;

}while(magassagok[i-1]!=0 && i<30);if(i==30) n=i; else n=i-1;for(i=0;i<n;i++){if(magassagok[i]<149) gyakorisag[0]++;else if(magassagok[i]>=150 && magassagok[i]<159) gyakorisag[1]++;else if(magassagok[i]>=160 && magassagok[i]<169) gyakorisag[2]++;else if(magassagok[i]>=170 && magassagok[i]<179) gyakorisag[3]++;else if(magassagok[i]>=180 && magassagok[i]<189) gyakorisag[4]++;else if(magassagok[i]>=190) gyakorisag[5]++;}for(i=0;i<6;i++) {printf("%8i",gyakorisag[i]);}}

1.2.3. K araktertömbök A következőkben megnézünk néhány példát karaktertömbökre! A karaktertömbökegydimenziós tömbök (vektorok), melyek minden eleme karakter. A C nyelv nem rendelkezik

önálló sztringtípussal, ezért a karaktertömböket használja a sztringek tárolására. A sztringtehát olyan karaktertömb (char[]), melyben a karaktersorozat végét nulla értékű bájt (’ \0’)

jelzi. A Windows és a Unix operációs rendszerben is un. 0-végű sztringeket használnak, így a

mintapéldáinkban mi ilyen adatszerkezettel oldjuk meg a feladatainkat.



19

int _tmain(int argc, _TCHAR* argv[]){char s[20]; int i=0,db=0; printf("\nString= ");do{scanf("%c",&s[i]);i++;

}while(s[i-1]!='\n' && i<20); s[i-1]='\0';

for(i=0;s[i]!='\0';i++)if(s[i]>='0' && s[i]<='9') db++;

printf("\nA szamjegy karakterek szama= %i",db);}

String1()

1.

repeat read s[i]: i i+12.

until s[i-1] Enter and i<hossz[s]

3.

s[i-1] ’\0’ : db 0

4. while s[i] ’\0’

5. do if s[i]>=’0’ and s[i]<=’9’

6.

then db db+1

7.

i i+18. write db



A 0 végű sztringek egyik előnye például az, hogy nem kell megjegyeznünk a sztringelemeinek a számát, mivel a sztring záró karakter egyértelműen meghatározza a sztring végét.A példákban szándékosan nem fogunk magas szintű sztring kezelő függvényeket használni, hanem a sztringeket tömbként kezeljük. Cél, hogy tovább gyakoroljuk a tömbökkel való

műveletvégzést. Léteznek előre megírt sztring kezelő függvények (C++ string.h fájlbandefiniálva). Ezekről részletesen olvashat Benkő Tiborné, Benkő László, Tóth Bertalan:Programozzunk C nyelven című könyvében6.

1.2.3.1. Olvassunk be „enter”( \n) végjelig egy maximum 20 elemű karaktertömböt ! Adjukmeg, hogy hány db számjegy karaktert tartalmaz a karaktertömb!Egy karaktertömböt kell beolvasnunk enter végjelig, majd meg kell határoznunk a számjegykarakterek darabszámát. A megoldáshoz felhasználjuk a megszámolás tételét! Karakterek

esetén a karakterek ASCII kódjáthasonlítjuk össze egymással. Az

„if(s[i]>=’0’ && s[i]<=’9’” sor jelentése:a feltétel igaz, ha az „s” karaktertömb ielemének ASCII kódja nagyobb vagyegyenlő a „0”-s karakter ASCII kódjánálés kisebb vagy egyenlő a „9”-es karakter

ASCII kódjánál.

1.2.3.2. Oldjuk meg az előző példát (1.2.3.1.) pointer változókkal! A tömb neve egy pointerváltozó. A részletes magyarázatot lásd az 1.2.1.3. példánál. int _tmain(int argc, _TCHAR* argv[]){char s[20];int n=0;int db=0;char *ps=s; ps--; printf("\nString= ");do{ps++;n++;

scanf("%c",ps);}while(*ps!='\n' && n<20); *ps='\0';

ps=s;for(;*ps!='\0';ps++)

if(*ps>='0' && *ps<='9') db++;printf("\nA szamjegy karakterek szama= %i",db);}

6 Benkő Tiborné, Benkő László, Tóth Bertalan: Programozzunk C nyelven 127-130. oldal



20


Mátrix()

1. for i 0 to n

2.

do

3.

for j 0 to m4.

do

5.

t[i] véletlenszám

6.

for i 0 to n

7.

do for j 0 to m8. do write t[i]

int _tmain(int argc, _TCHAR* argv[])

{int matrix[10][5]; int i,j;printf("\N= „);scanf("%i",&n); printf("\M= „);scanf("%i",&m);for(i=0;i<n;i++) //feltöltés for(j=0;j<m;j++) {matrix[i][j]=rand()%100;}

printf("\nA matrix elemei:\n"); //kiírás mátrix alakban for(i=0;i<n;i++){for(j=0;j<m;j++) {printf("%6i", matrix[i][j]);}}}


1.2.3.3. Olvassunk be „enter”( \n) végjelig egy maximum 20 elemű karaktertömböt ! Döntsük el, hogy a karaktertömb tükörszó-e!

Egy karaktertömböt kell beolvasnunk enter végjelig, majd el kell döntenünk, hogy tükörszó-e.

A megoldáshoz az eldöntés tételét fogjuk felhasználni. Meg kell vizsgálnunk, hogy a

karaktertömb 0. karaktere egyenlő-e a ’\0’ sztring záró karakter előtti utolsó karakterrel, az 1.karaktere egyenlő-e az utolsó előtti karakterrel, és így tovább. A vizsgálatot addig végezzük,amíg nem találunk két nem egyenlő karaktert, vagy felcserélődik a két tömbindex.int _tmain(int argc, _TCHAR* argv[]){char s[20]; int i=0,db=0; printf("\nString= ");do{scanf("%c",&s[i]);i++;

}while(s[i-1]!='\n' && i<20); s[i-1]='\0';int j=0; while(s[j]!='\0') { j++; }j--; i=0; int palindrom; while(s[i]==s[j] && i<j) {i++; j--;}palindrom=(i>=j);if(palindrom){printf("\nTukorszo");}else{printf("\nNem tukorszo");}}

1.2.4. Kétdimenziós tömbök, mátrixok

A következőkben megnézünk néhány példát a kétdimenziós tömbök (mátrix) kezelésére. Amátrixok esetében két indexre lesz szükségünk, lesz egy sorindex (általában i-vel jelölik) éslesz egy oszlopindex (általában j-vel jelöljük).

1.2.4.1. Írjon olyan programot, amely véletlen számokkal feltölt egy N*M-e s mátrixot, ésmátrix alakban kiírja a képernyőre! A mátrixokat feltölthetjük (illetve kiírhatjuk) sorfolytonosan vagy oszlop folytonosan. A

sorfolytonos feltöltés azt jelenti, hogy először feltöltjük a 0. sor elemeit egy belső ciklussal avektoroknál megismert módszerrel, majd az 1. sorelemeit és így tovább. Két ciklus lesz a feltöltéskor,a külső ciklus változója a sorindex, a belső ciklusváltozója az oszlopindex lesz. Az oszlop-folytonos

feltöltés esetén fordított sorrendben járunk el. Az

„n” és az „m” értékét a program a billentyűzetről olvassa be.



21


1.2.4.2. Készítsen programot, amely egy 10 fős tanulócsoport 6 tantárgyból szerzettosztályzatait dolgozza fel. Az osztályzatokat véletlenszám generátorral hozzuk létre, mátrixalakban jelenítsük meg, úgy, hogy egy sorban egy tanuló osztályzatai legyenek, a sor végéna tanuló tanulmányi átlagával. Utolsó sorként írjuk ki a tantárgyak átlagát a

tanulócsoportban! A feladatot kétdimenziós tömb alkalmazásával oldjuk meg. Ellenőrzött adat bevitellel vagy

véletlenszám generátorral feltöltünk egy 10*6-os mátrixot úgy, hogy minden tanuló esetébena tantárgyak sorrendje ugyanaz. Az osztályzatokat tanulónként hozzuk létre. A tanulókat és atantárgyakat is sorszámmal azonosítjuk. A tanulók tanulmányi átlagát a mátrix sorainak átlagafogja adni, a tantárgyankénti átlagot pedig a mátrix oszlop átlagai fogják megadni. int _tmain(int argc, _TCHAR* argv[]){int tanulok[10][6]; int i,j; float tanatl[10],tantargyatl[6];srand (time(NULL)); //veletlenszam generator inicializalasafor(i=0;i<10;i++) //feltöltés

for(j=0;j<6;j++) {tanulok[i][j]=rand()%5+1;}

for(i=0;i<10;i++) //tanulóátlag -> sorátlag {tanatl[i]=0;for(j=0;j<6;j++){tanatl[i]=tanatl[i]+tanulok[i][j];}

tanatl[i]=tanatl[i]/6;}for(j=0;j<6;j++) //tantárgyátlag -> oszlopátlag

{tantargyatl[j]=0;for(i=0;i<10;i++){tantargyatl[j]=tantargyatl[j]+tanulok[i][j];}

tantargyatl[j]=tantargyatl[j]/10;}printf("\nA tomb elemei:\n"); //kiírás mátrix alakban for (i=0;i<10;i++){for(j=0;j<6;j++) {printf("%6i",tanulok[i][j]);}

printf("%6.2f",tanatl[i]); printf("\n");}for(j=0;j<6;j++){printf("%6.2f",tantargyatl[j]);} return 0; }

1.2.4.3. Egy hónapon keresztül minden nap megmértük a hőmérsékletet reggel és este. a) Adjuk meg azt a napot, amikor r eggel a legmelegebb volt !

b) Adjuk meg mikor volt a legkisebb különbség a reggeli és az esti hőmérséklet között! c) Adjuk meg azokat a napokat, amikor reggel melegebb volt, mint este!

d) Hány nap volt 10 fok fölött a különbség a reggeli és az esti hőmérséklet között?

e)

Hány olyan nap volt, amikor az előző esti hőmérséklet megegyezett az aznap reggel ihőmérséklettel?Az adatokat egy 30*2-es mátrixban fogjuk tárolni. Tételezzük fel, hogy 30 napos a hónap. Amátrix sorai a napok sorszámai, az első oszlop a reggel, a második oszlop az este mérthőmérsékletet tartalmazza. a) megoldása: A mátrix nulladik (0-tól indexelünk) oszlopára egy maximum-kiválasztástalkalmazzuk.

b)

megoldása: Először meghatározzuk a reggeli és esti hőmérsékletek közötti különbséget,figyelve arra, hogy mindig pozitív eredményt kapjunk, és ezek alapján egy minimum-

kiválasztást végzünk .



22


c) megoldása: A kiválogatás tételét alkalmazzuk , és azon napok sorszámát adjuk meg, amikoraz első oszlopban lévő érték (reggeli hőmérséklet) nagyobb, mint a második oszlopban lévő(esti hőmérséklet)d) megoldása: A megszámolás tételét alkalmazzuk. Meghatározzuk a reggeli és esti

hőmérsékletek közti különbséget (abszolút értékben), és ha ez 10 foknál nagyobb, növeljük adarabszámot, ami azon napok számát jelöli, ahol több 10 foknál a hőmérséklet különbség areggel és este mért érték között. e) megoldása: A megszámolás tételét alkalmazzuk. A második naptól kezdve, megnézzük,hogy az előző nap (előző sorban, a második oszlopban lévő érték) este mért értékmegegyezik-e a vizsgált nap reggelén mért értékkel (aktuális sor első oszlopa), ha igennöveljük a feltételnek eleget tévő napok számát. int _tmain(int argc, _TCHAR* argv[]){float hom[30][2]; int i=0,j=0,n=30;for(i=0;i<n;i++) //feltöltés {for(j=0; j<2; j++)

{printf("\n%i,%i.elem= ",i,j);scanf("%f",&hom[i][j]);}}//a) megoldása maximum kiválasztás a mátrix első oszlopára int maxi=0;for(i=1; i<n; i++){if(hom[i][0]>hom[maxi][0]) {maxi=i;}}printf("\nA %i. napon volt a legmelegebb a reggel",maxi);//b) megoldása minimum kiválasztás a hőm. különbségekre//abs(esti-reggeli hőm.) float kul=abs(hom[0][1]-hom[0][0]); int mini=0;for(i=1; i<n; i++){if(abs(hom[i][1]-hom[i][0])<kul)

{kul=abs(hom[i][1]-hom[i][0]); mini=i;} }printf("\nA %i. napon volt a legkisebb a homersekletkulonbseg

az esti es a reggeli hom. kozott",mini);//c) megoldása kiválogatás, amikor reggel melegebb volt, mint//esteprintf("\nAzok a napok, amikor reggel melegebb volt, mint este

a következő napok:"); for(i=0; i<n; i++){if(hom[i][0]>hom[i][1]) {printf("%4i",i);}}//d) megoldása megszámolás, amikor a hőm. különbségekre//abs(esti-reggeli hőm.)>10 int db=0;for(i=0; i<n; i++){if(abs(hom[i][1]-hom[i][0])>10) {db++;}}printf("\nAzok a napok szama, amikor a reggeli és esti

homerseklet kulonbseg nagyobb mint 10 fok: %i",db);//e) megoldása megszámolás, amikor az előző esti hőm. = az//aznap reggeli homersekletteldb=0;for(i=1; i<n; i++){if(hom[i-1][1]==hom[i][0]) {db++;}}printf("\nAzok a napok szama, amikor az elozo esti homerseklet

egyenlo az aznap reggili homerseklettel: %i",db);}



23



1.2.4.4. Készítsen programot, amely egy N*N - es mátrixot feltölt véletlen számokkal, majdelkészíti a transzponált mátrixot !A transzponált mátrixot úgy kapjuk, hogy a sorokat és az oszlopokat felcseréljük. int _tmain(int argc, _TCHAR* argv[]){int matrix[5][5], matrixtransz[5][5]; int i,j;

for(i=0;i<5;i++) //sorfolytonos feltöltés {for(j=0;j<5;j++){matrix[i][j]=rand()%100;}}printf("\nA feltoltott matrix:\n");for(i=0;i<5;i++){for(j=0;j<5;j++) {printf("%6i",matrix[i][j]);}printf("\n");}

for(i=0; i<5; i++) //transzponált mátrix előállítása {for(j=0;j<5;j++)

{matrixtransz[j][i]=matrix[i][j];}}printf("\nA transzponalt matrix:\n");for(i=0;i<5;i++){for(j=0;j<5;j++) {printf("%6i",matrixtransz[i][j]);}printf("\n");} return 0;}

1.2.4.5. Készítsen programot, amely egy N*N - es mátrixot feltölt a billentyűzetről, éseldönti, hogy a mátrix szimmetrikus-e!Egy négyzetes mátrix akkor szimmetrikus mátrix, ha az eredeti mátrix megegyezik atranszponáltjával. Vagyis: aij = a ji minden i,j=1,…n indexre. A megoldás során az eldöntéstételét fogjuk alkalmazni.A vizsgálóciklus addig fog futni, amíg nem találunk olyan elemet, amelyre aij ≠ a ji vagy i elériaz n-et, vagyis megvizsgáltunk minden elemet. Ha úgy lépünk ki, hogy i=n, akkor

szimmetrikus a mátrix. int _tmain(int argc, _TCHAR* argv[]){int matrix[10][10]; int i,j,n;do {printf("\nMatrix sor es oszlopszama= ");scanf("%i",&n);

}while(n<1 || n>10);for(i=0;i<n;i++) //sorfolytonos feltöltés {for(j=0;j<n;j++)

{printf("%i,%i.elem= ",i,j);scanf("%i",&matrix[i][j]);}}

printf("\nA feltoltott matrix:\n");for(i=0;i<n;i++){for(j=0;j<n;j++) {printf("%6i",matrix[i][j]);}printf("\n");}

//szimmetrikus mátrix? i=0;int szim=true;while(i<n && szim){j=0; while(matrix[i][j]==matrix[j][i] && j<n) {j++;}if(j<n) {szim=false;}i++;}

if(szim) {printf("\nA matrix szimmetrikus");}else {printf("\nA matrix nem szimmetrikus");}return 0;}



24



1.3. Függvények, paraméterátadás

A következőkben megoldunk néhány feladatot az alprogramok témakörében.

1.3.1. Érték szerinti paraméterátadás

1.3.1.1. Készítsünk olyan maximum nevű függvényt, aminek az a feladata, hogy a kapottkét paramétere közül a nagyobb értékűt adja vissza!A megoldás során két egész típusú változó értékét átadunk a függvénynek, amelymeghatározza, hogy a két érték közül melyik a nagyobb. A nagyobb értéket a függvénynevével, mint „változóval” adjuk vissza a hívó programnak. int maximum(int a, int b){if(a>b) return a; else return b;}int _tmain(int argc, _TCHAR* argv[]){int x,y,nagyobb;printf("\nx=");scanf("%i",&x);printf("\ny=");scanf("%i",&y);

nagyobb=maximum(x,y);printf("\nA két szám közül a(z) %i a nagyobb!",nagyobb);}

A maximum függvény két (a és b) paramétere értékként a híváskor megadott két paraméter (xés y) paraméter értékét kapja. A verem memóriában (stack) létrejön egy „a” és egy „b” nevűváltozó, amelyekbe bemásolódik az a x és y értéke! Érték kerül átadásra! A return utasításhatására visszatérünk a függvényből (a visszatérési cím a verem memóriából kivételre kerül),ekkor az a és a b változó megsemmisül, így értéke is elvész. A verem memória LIFO (Last In

First Out) szervezésű, így a visszatérési címhez csak úgy jutunk hozzá, hogy a felette levő

változókat „kidobáljuk” a veremből.

1.3.1.2. Egy ellenőrzéssel beolvasott pozitív egész számról döntse el, hogy prímszám-e! A

vizsgálatot függvénnyel végeztesse el, amely az eredményt „logikai érték” visszaadásával jelzi a főprogramnak! A szöveges üzenetet a főprogram írja ki a képernyőre!

A feladat megoldása során függvény segítségével döntjük el egy számról, hogy prímszám-e.

A függvénynek a főprogramban beolvasott számot értékszerinti paraméterátadással adjuk át,mivel a függvény a szám értékét nem fogja megváltoztatni. A függvény neve, mint logikaitípusú változó fogja az eredményt (igaz, vagy hamis) visszaadni. Egy szám akkor prímszám,ha csak 2 osztója van, az 1 és önmaga. int primszam(int a){int prim=true; int oszto=2;if(a!=1){while(a%oszto!=0) {oszto++;}prim=(oszto==a);}

return prim;}int _tmain(int argc, _TCHAR* argv[]){int szam;printf("\nSzam= ");scanf("%i",&szam);if(primszam(szam)) {printf("\nA(z) %i primszam", szam);}else {printf("\nA(z) %i nem primszam", szam);}return 0;}



25


36. ábra. A cím szerinti paraméterátadás

1.3.2. Cím szerinti paraméterátadás

1.3.2.1. Írjon olyan függvényt, amely a memóriában felcseréli két egész típusú változótartalmát! A feladat megoldása során látni fogjuk, hogy itt már nem fog helyesen működni az

algoritmusunk, ha érték szerinti paraméterátadást használunk. void csere(int &x, int &y){int cs; cs=x; x=y; y=cs;}int _tmain(int argc, _TCHAR* argv[]){int a,b;printf("\na=");scanf("%d",&a);printf("\nb=");scanf("%d",&b);printf("\nA két változó a csere elött:a= %d,b=%d",a,b); csere(a,b);printf("\nA két változó a csere után: a=%d, b=%d",a,b);}

A paraméterátadás folyamatát az alábbi ábra szemlélteti:

a

b

adat memória

void csere(int &x, int &y)

{ int cs;

cs=x;

x=y;

y=cs;

return; }

void main()

{

int a,b;

csere(a,b);

printf("\nA két változó a csere után : ...);

}

Visszatérési cím

x = a változó címe

y = b változó címe

verem (stack) memória

cs

A csere függvény két (x és y) paramétere értékként a híváskor megadott két paraméter (a és b)változó címét kapja. A veremmemóriában (stack) létrejön egy „x” és egy „y” nevű változó,amelyekbe bemásolódik az „a” és „b” változó címe! Memória cím kerül átadásra! Havisszatérünk a függvényből, akkor az x és az y változó megsemmisül, így értéke is elvész, deez nem okoz gondot, mert a változás (csere) az „a” és „b” változót tároló memóriarekeszekben történt. Az x=y utasítás értelmezése: Az x változó által mutatott memóriacímen

levő adat (a) legyen egyenlő az y változó által mutatott memóriacímen levő adattal (b).

1.3.3. Érték szerint pointerváltozó (memória cím) átadás

1.3.3.1. Oldjuk meg az előbbi csere programunkat úgy (1.3.2.1.) , hogy pointer változókkaldolgozunk!

Látni fogjuk, hogy működés szempontjából hasonló a helyzet, mint a címszerinti paraméterátadásnál. A híváskor az x mint pointer típusú változó az a változó memóriacímét,az y mint pointer típusú változó a b változó memóriacímét kapja értékül.



26

37. ábra. Az 1.3.3.1 feladat programlistája


void csere(int *x, int *y){int cs; cs=*x; *x=*y; *y=cs;}int _tmain(int argc, _TCHAR* argv[]){int a,b;printf("\na=");scanf("%d",&a);printf("\nb=");scanf("%d",&b);printf("\nA két változó a csere elött: a=%d, b=%d",a,b);

csere(&a,&b);printf("\nA két változó a csere után: a=%d, b=%d",a,b);}

Mi történik pl. a *x = *y utasítás hatására. Az „x” változó, mint pointerváltozó által mutatottmemória hely tartalma legyen egyenlő az „y”, mint pointerváltozó által mutatott memóriahelytartalmával. Mivel az „x” az „a” változó címét, az „y” a „b” változó címét tartalmazza,gyakorlatilag az a=b; utasítás kerül végrehajtásra. Tehát a működés hasonló a címszerinti

paraméterátadáshoz. Memóriacímet adunk át érték szerint.

1.3.4. A tömb, mint paraméter:

A C nyelvben a tömb neve egy pointerváltozó, vagyis a tömb neve a tömb memóriabelikezdőcíme. Így, ha tömböt kell átadnunk egy függvénynek, akkor egyszerűen a tömb nevét,mint pointerváltozót adjuk át. A függvényen belül ugyanúgy hivatkozhatunk a tömbre, mint amain() függvényben.

1.3.4.1. Írjon olyan függvényt, amely meghatározza egy adott elemszámú vektorlegnagyobb elemének indexét! A vektor elemeinek a beolvasását, és a legnagyobb elemindexének és értékének kiírását a főprogram végezze el. A megoldás során a függvénynek a tömb nevét, mint memóriacímet adjuk át. A függvény

meghatározza a legnagyobb elem indexét. Az indexet a hívó programnak a függvény nevével,mint „változóval” adjuk vissza. int maxkiv(int *v, int n){int i; int max=v[0];for(i=1; i<n; i++){if(v[i]>max) {max=v[i];}}return max;}

int _tmain(int argc, _TCHAR* argv[]){int t[100]; int i=0, n, maxelem;do{printf("\n%i.elem= ",i);scanf("%i",&t[i]);i++;

}while(t[i-1]!=0 && i<100);if(i==100) n=i; else n=i-1;maxelem=maxkiv(t,n);

printf("\nA tomb legnagyobb eleme= %i",maxelem);return 0;}

1.3.4.2. Készítsen olyan programot, amely beolvas egy maximum 100 elemű egész típusúvektor t 0 végjelig , majd meghatározza azoknak az elemeknek a számát, amelyektartalmaznak számjegy azonosságot. A feladatot függvényekkel oldja meg!

A megoldás során a „ beolvas” függvény segítségével 0 végjelig beolvasunk egy vektort. Afőprogram fogja megszámolni azokat az elemeket, amelyek tartalmaznak számjegy

azonosságot (a „szamjegyazonossag” nevű függvény által visszaadott érték alapján).



27


A „szamjegyazonossag” nevű függvény egy gyakoriságtömb segítségével megszámol ja, hogy

egy adott tömbelem (átadott szám) hány darab 0, 1, 2, … 9-es számjegyet tartalmaz. Afüggvény az eldöntés tétele segítségével eldönti, hogy a gyakoriságtömbnek van -e olyan

eleme, amely nagyobb, mint 1, vagyis van-e olyan számjegy, amely 1-nél többször fordul elő

az adott számban. Ha van, akkor igaz, ha nincs akkor hamis értékkel tér vissza. int beolvas(int *v){int i=0,n;do{printf("\n%i. elem= ",i);scanf("%i",&v[i]); i++;

}while(v[i-1]!=0 && i<100);if(i==100) {n=i;} else {n=i-1;} return;}

int szamjegyazonossag(int szam){int szjegyekdb[10],i,szjegy,van;for(i=0;i<10;i++) {szjegyekdb[i]=0;}while(szam!=0)

{szjegy=szam%10;szjegyekdb[szjegy]++;szam=szam/10;}//eldöntés van-e olyan szamjegy, van-e olyan eleme az szjegyekdb tombnek,

//amely nagyobb, mint 1i=0;while(i<10 && szjegyekdb[i]<2) {i++;}van=(i<10);return van;}

int _tmain(int argc, _TCHAR* argv[]){int t[100],i,db=0; int n=beolvas(t);for(i=0; i<n; i++)

{if(szamjegyazonossag(t[i])) {db++;}}printf("\nA tomb %i darab olyan elemet tartalmaz, amelyben

van szamjegyazonossag", db); return 0;}

1.3.4.3. Készítsen olyan programot, amely beolvas egy maximum 100 elemű egész típusúvektort 0 végjelig, majd kiválasztja azt az elemet, amelyben a számjegyek összege alegnagyobb. A feladatot függvényekkel oldja meg!

A megoldás során a „beolvas” függvény segítségével 0 végjelig beolvasunk egy vektort, majd

a maximum kiválasztás tételét alkalmazva meghatározzuk a legnagyobb számjegyösszegűelem sorszámát. Készítünk egy függvényt, amely meghatározza egy egész számszámjegyeinek összegét. A maximum kiválasztás során ezt a függvényt fogjuk hívni, hogy azaktuális tömbelem, mint szám számjegyinek az összegét meghatározza. int beolvas(int *t){int i=0,n;do{printf("\n%i.elem= ",i);scanf("%i",&t[i]);i++;

}while(t[i-1]!=0 && i<100);if(i==100) n=i; else n=i-1; return n;}

int szjosszeg(int szam){int szjossz=0;while(szam!=0) {szjossz=szjossz+szam%10;szam=szam/10;}return szjossz;}

int _tmain(int argc, _TCHAR* argv[]){int t[100],n,i;

n=beolvas(t);int maxi=0,szjossz; int maxszjossz=szjosszeg(t[0]);



28



for(i=1;i<n;i++){szjossz=szjosszeg(t[i]);if(szjossz>maxszjossz) {maxi=i;maxszjossz=szjossz;}}

printf("\nA legnagyobb szamjegyosszegu tombelem sorszama=%i,szjosszeg=%i", maxi,maxszjossz); return 0; }

1.3.4.4. Készítsen olyan programot, amely beolvas Enter karakterig egy karaktertömböt ,majd függvény segítségével meghatározza azon rész kezdő - és végindexét, amelyben azonoskarakterek vannak! Több ilyen esetén válassza ki azt, amelyben a karakterek számamaximáli s!

A megoldás során a „beolvas” függvény segítségével Enter végjelig beolvasunk egykaraktertömböt. Az „azonosresz” nevű függvény meghatározza annak a rész-karaktertömbnek a kezdő és végindexét, amely a leghosszabb azonos karakterekből álló intervallumot jelöli ki.

A megoldás során vizsgáljuk a karaktertömbünk szomszédos karaktereit. Ha a két szomszédoskarakter nem egyenlő, akkor egy új azonos karaktereket tartalmazó részintervallum

kezdődhet, vagyis a végindexet egyenlővé tesszük a kezdő indexel. Ha a két szomszédoskarakter megegyezik, akkor azonos karaktereket tartalmazó részintervallumban vagyunk,ekkor az a teendőnk, hogy megvizsgáljuk, hogy a mostani részintervallum hossza nagyobb-e,

mint az eddig megtalált, leghosszabb azonos karaktereket tartalmazó részintervallum. void beolvas(char *s){int i=0;printf("\nString= ");do {scanf("%c",&s[i]);i++;

}while(s[i-1]!='\n' && i<20);

s[i-1]='\0';}void azonosresz(char *s,int *kezdo,int *veg){int k=0,v, *kezdo=*veg=0;for(v=1;s[v]!='\0';v++)

{if(s[v]!=s[v-1]) k=v;else if(v-k>*veg-*kezdo) {*kezdo=k;*veg=v;}}}

int _tmain(int argc, _TCHAR* argv[]){char s[20];int kezdo,veg;beolvas(s); azonosresz(s,&kezdo,&veg);printf("\nAz azonos resz: %i - tol %i - ig",kezdo, veg);}

1.3.4.5. Készítsen olyan programot, amely beolvas Enter karakterig két db karaktertömböt .Függvény segítségével döntse el, hogy az első karaktertömb tartalmazza- e a másodikkaraktertömböt ! Nem használhat sztringkezelő függvényeket!

Egy függvény segítségével beolvassuk a két karaktertömböt. Első lépésként megkeressük,hogy az első karaktertömbünkben hol található a második karaktertömbünk kezdőkaraktere

(„kereselső”). Ha nincs benne, akkor végeztünk, az első karaktertömb nem tartalmazza a

második karaktertömböt. Ha megtaláltuk az első karaktert, akkor ettől a pozíciótól kezdvekarakterenként vizsgáljuk a két karaktertömböt. Ha a második karaktertömb végére értünk,

akkor tartalmazza az első karaktertömb a második karaktertömböt.



29


Ha találunk karakter eltérést, akkor az eljárást kezdjük elölről, keressük az elsőkaraktertömbünkben a második karaktertömb kezdőkarakterének következő előfordulását. Azeljárást addig folytatjuk, amíg az első karaktertömbünk végére nem érünk. void beolvas(char *s){int i=0;

printf("\nString=");do{scanf("%c",&s[i]); i++;

}while(s[i-1]!='\n' && i<20);s[i-1]='\0'; return;}

int kereselso(int i,char *s, char c){while(s[i]!='\0' && s[i]!=c) {i++;}return i;}

int tartalmazza(char *s1, char *s2){int i=0,benne=false,vege=false,k=0;while(!benne && !vege){k=kereselso(k,s1,s2[0]); //kezdőpozíció keresése

if(s1[k]=='\0') {vege=true;} //elértük az s1 végét else //megvan a kezdőpozíció, karakterenkénti hasonlítás {i=0; while(s1[k]!='\0' && s2[i]!='\0' && s1[k]==s2[i]) {k++;i++;}if(s2[i]=='\0') {benne=true;};}

}return benne;}

int _tmain(int argc, _TCHAR* argv[]){char s1[20], s2[20];beolvas(s1); beolvas(s2);if(tartalmazza(s1,s2)) {printf("\nBennevan");}else {printf("\nNincs benne");}return 0;}

1.3.4.6. Készítsen programot, amely két 1- nél nagyobb, egymástól különböző természetesszám esetén megoldja a következő feladatokat:

a) megadja külön- külön mindkét szám összes osztóját b) megadja külön- külön mindkét szám összes valódi osztóját (e gy szám valódi

osztóinak nevezünk minden olyan osztót, amely nem 1 és nem maga a szám.) c) megadja mindkét szám összes osztóját (növekvő sorrendben rendezetten) d) megadja mindkét szám összes valódi osztóját (növekvő sorrendben rendezetten) e) megadja mindkét szám közös osztóit f) eldönti, hogy a két szám relatív prím- e! Két szám relatív prím, ha egy közös valódi

osztójuk sincs.

A feladatot függvényekkel fogjuk megoldani. Az a) feladat esetén egy függvény egy tömbbe kigyűjti az adott szám összes osztóját. Afüggvényt először az első, majd a második számmal fogjuk meghívni. A b) feladat esetén az

a) feladathoz hasonlóan egy függvény kigyűjti az adott szám összes valódi osztóját . A c)

feladat során a függvény a számok osztóit tartalmazó halmazok rendezett unióját fogjaképezni az összefuttatás tétele segítségével. A d) feladat során a függvény a számok valódiosztóit tartalmazó halmazok rendezett unióját fogja képezni az összefuttatás tételesegítségével.



30

Az e) feladat során a két szám osztóit tartalmazó halmazok metszetét kell meghatározni. Az f)

feladat során a két szám valódi osztóit tartalmazó halmazok metszetét kell meghatározni. Ha ametszethalmaz üres halmaz, akkor a két szám relatív prím. int beolvas(){int szam,ok;

do{printf("\nSzam= ");fflush(stdin);ok=scanf("%i",&szam);}while(ok!=1 || szam<1);return szam;}

void inic(int *h){for(int i=0; i<100; i++) {h[i]=0;}}

int osztokereses(int *h, int szam){int i=0, oszto=1; inic(h);while(oszto<=szam){if(szam%oszto==0) {h[i]=oszto; i++;}oszto++;}return i;}

int valodiosztokereses(int *h, int szam)

{int i=0, oszto=2;inic(h);while(oszto<szam){if(szam%oszto==0) {h[i]=oszto; i++;}oszto++;}return i;}

void osztokkiir(int *h, int n){int i=0;while(i<n) {printf("%6i",h[i]);i++;}return;}

int osztokmindkereses(int *h1, int n, int *h2, int m, int *h3){inic(h3);int i=0,j=0,k=-1;while(h1[i]!=0 && h2[j]!=0){k++; if(h1[i]<h2[j]) {h3[k]=h1[i];i++;}

else if(h1[i]==h2[j]) {h3[k]=h1[i];i++;j++;}else if(h1[i]>h2[j]) {h3[k]=h2[j];j++;}}

while(h1[i]!=0) {k++;h3[k]=h1[i];i++;}while(h2[j]!=0) {k++;h3[k]=h2[j];j++;}return ++k;}

int osztokkozoskereses(int *h1, int n, int *h2, int m, int *h3){int i=0, j=0, k=0;for(i=0; i<n; i++){j=0; while(j<m && h2[j]!=h1[i]) {j++;}

if(j<m) {h3[k]=h1[i]; k++;} }return k;}

int _tmain(int argc, _TCHAR* argv[])

{int szam1=beolvas();int szam2=beolvas();int szam1osztoi[100], szam1on, szam2osztoi[100], szam2on, osztokmind[200];int mindn, osztokkozos[100], kozosn;printf("\n *** OSSZES OSZTOK ***");szam1on=osztokereses(szam1osztoi, szam1);szam2on=osztokereses(szam2osztoi, szam2);printf("\n%i osztoi:",szam1); osztokkiir(szam1osztoi, szam1on);printf("\n%i osztoi:",szam2); osztokkiir(szam2osztoi, szam2on);mindn= osztokmindkereses(szam1osztoi, szam1on, szam2osztoi, szam2on,

osztokmind);printf("\n%i es %i osztoi: ",szam1, szam2);osztokkiir(osztokmind, mindn);kozosn=osztokkozoskereses(szam1osztoi,szam1on,szam2osztoi,szam2on,

osztokkozos);

printf("\n%i es %i osztoi kozos osztoi:",szam1,szam2);osztokkiir(osztokkozos,kozosn);



31


printf("\n *** VALODI OSZTOK ***");szam1on=valodiosztokereses(szam1osztoi,szam1);szam2on=valodiosztokereses(szam2osztoi, szam2);printf("\n%i osztoi: ",szam1); osztokkiir(szam1osztoi, szam1on);printf("\n%i osztoi: ", szam2); osztokkiir(szam2osztoi, szam2on);mindn= osztokmindkereses(szam1osztoi, szam1on, szam2osztoi, szam2on,

osztokmind);printf("\n%i es %i osztoi: ",szam1, szam2);osztokkiir(osztokmind, mindn);kozosn=osztokkozoskereses(szam1osztoi, szam1on, szam2osztoi, szam2on,

osztokkozos);printf("\n%i es %i osztoi kozos osztoi: ",szam1, szam2);osztokkiir(osztokkozos, kozosn);if(kozosn==0) {printf("\n%i es %i relativ primek",szam1, szam2);}else {printf("\n%i es %i nem relativ primek",szam1,szam2);}return 0;}

1.3.4.7. Írjon olyan programot, amely egy maximum 100 elemű egész típusú tömbleggyakrabban előforduló elemét megkeresi és kiírja a standard outputra!

A megoldás során meg kell határoznunk, hogy a tömb elemei hányszor fordulnak elő, majdkiválasztani a leggyakrabban előforduló elemet. A tömböt növekvő (vagy csökkenő)sorrendbe fogjuk rendezni, ekkor biztosan egymás mellé fognak kerülni az azonos értékűelemek. A tömb elemeit végigjárva a maximum kiválasztás tétele segítségével kiválasztjuk aztaz elemet, amely a legtöbbször előfordul. Amíg a szomszédos elemek egyenlők addigszámolunk, ha már nem egyenlők, akkor a darabszámot hasonlítjuk a maxdarabszámhoz.int beolvas(int *t){int i=0,n;do{printf("\n%i.elem= ",i);scanf("%i",&t[i]);i++;

}while(t[i-1]!=0 && i<100);

if(i==100) n=i; else n=i-1;return n;}

void kiir(int *t,int n){int i;printf("\nA tomb elemei:\n");for(i=0; i<n; i++) {printf("%8i",t[i]);}return;}

void rendez(int *t,int n){int i,j,cs;for(i=0; i<n-1; i++)for(j=i+1; j<n; j++)

if(t[i]<t[j]) {cs=t[i]; t[i]=t[j];t[j]=cs;}return;}

int leggyakoribb(int *t,int n,int &maxdb){int i,maxi=0;int db=0;maxdb=0;for(i=0;i<n-1;i++){if(t[i]==t[i+1]) {db++;}else //találtunk eltérő elemet, meg kell néznünk, hogy a db>maxdb {if(db>maxdb) {maxdb=db; db=0; maxi=i;}}

}return maxi;}

int _tmain(int argc, _TCHAR* argv[]){int t[100],n; int maxi, maxdb;n=beolvas(t); kiir(t,n); rendez(t,n);kiir(t,n);



32



maxi=leggyakoribb(t,n,maxdb);if(maxdb!=0) printf("\nA leggyakrabban elofordulo elem %i, %i-szor

fordul elo",t[maxi],maxdb);else {printf("\nA tomb csak kulonbozo elemeket tartalmaz");}return 0;}

1.3.4.8.

Írjon olyan programot, amely meghatározza egy maximum 100 elemű egész típusútömbben előforduló számok gyakoriságát.

A megoldás során meg kell határoznunk, hogy a tömb elemei hányszor fordulnak elő.Célszerű a tömböt növekvő (vagy csökkenő) sorrendbe rendezni, így az egyenlő elemekegymás mellé fognak kerülni. A megszámolást egy gyakoriságmátrixszal fogjuk elvégezni. Amátrix első oszlopában a tömbelem fog szerepelni, a második oszlopában pedig az, hogy az

adott tömbelem hányszor fordul elő a tömbben. int beolvas(int *t){int i=0,n;do{printf("\n%i.elem= ",i);scanf("%i",&t[i]);i++;

}while(t[i-1]!=0 && i<100);if(i==100) n=i; else n=i-1;return n;}

void kiir(int *t,int n){int i;printf("\nA tomb elemei:\n");for(i=0; i<n; i++) {printf("%8i",t[i]);}return;}

void rendez(int *t,int n){int i,j,cs;for(i=0; i<n-1; i++)for(j=i+1; j<n; j++)

if(t[i]<t[j]) {cs=t[i]; t[i]=t[j];t[j]=cs;}return;}

void gyakorisag(int *t,int n){int i,k=0,gyakm[100][2];gyakm[k][0]=t[0]; gyakm[k][1]=1;for(i=1;i<n;i++){if(t[i]==t[i-1]) {gyakm[k][1]++;}else {k++; gyakm[k][0]=t[i]; gyakm[k][1]=1;} }

k++;for(i=0;i<k;i++){printf("\n%i : %i",gyakm[i][0],gyakm[i][1]); }return;}

int _tmain(int argc, _TCHAR* argv[]){int t[100], n=beolvas(t);kiir(t,n);rendez(t,n); kiir(t,n);gyakorisag(t,n);getch();return 0;}



33

1.4.

Önállóan kidolgozandó feladatok C

1.4.1. Kis programrészletek visszafejtése

Mit adnak eredményül, mit írnak ki a standard outputra a következő programrészletek?

void main(){int a=9,b=3;do{if(a>b) {a=a/2;}else {b=b/2;}printf("\na=%d\tb=%d",a,b);

}while(a!=b);}

void main(){int x,j;x=0;

for(j=5;j<15;j=j+3){x=x+j/3;printf("\nj=%d\tx=%d",j,x);}}

void main(){int x=0,y=1,z=x+y;while(z<=5){if(z%2!=0) {z=y+z; y++;}else {z=x+z; x++;}printf("\nx=%d y=%d z=%d",x,y,z);}

}

void main(){int a,d=0;for(a=2;a<20;a=a+d,d++)

printf("%8d",a);}

Az alábbiakban egy-egy programozási tétel algoritmusát látja benne egy kis hibával! Nevezze meg a programozási tételt! Mi a hiba az alábbi algoritmusban! Indokolja válaszát, támassza alá a válaszát tesztadatokkal.

Javítsa ki a hibát! Mutassa meg a tesztadatokkal, hogy jól működik az algoritmus.

Valami(s,n,ö)

for i 0 to n

do ö ö + s[i]

Valami(s,n,ö)

ö 0

for i 0 to n

do ö s[i]

Valami(s,n,T,van)

i 0 while s[i] nem T tulajdonságú

do i i+1

van (i<n)

Valami(s,n,T,van,sorsz)

i 0 while s[i] nem T tulajdonságú

do i i+1

van (i<n)if van

then sorsz i

Valami(s,n,T,db)

for i 0 to ndo

if s[i] T tulajdonságú

then db db+1

Valami(s,n,m)

m 0

for i 1 to ndo

if s[i]>max

then m s[i]

Valami(s,n,m)

m s[0]

for i 1 to ndo

if s[i]>max

then max i



34

1.4.2. Egyszerű programok (egyszerű adattípusok)

1. Olvasson be a rendszer bemenetéről egy egész számot, írja ki a reciprokát!*

2. Írjon programot, amely kiszámítja a téglalap kerületét és területét!/ bemenő adatok: a,b: a téglalap oldalai /

3. Írjon programot, amely kiszámítja a téglatest felszínét és térfogatát!

/ bemenő adatok: a,b,c: a téglatest élei /

4. Írjon programot, amely kiszámítja az egyenes henger felszínét és térfogatát!

/ bemenő adatok: r: alapkör sugara ill. M: a henger magassága /

5. Írjon programot, amely kiszámítja az egyenes körkúp térfogatát!/ bemenő adatok: r: alapkör sugara ill. M: a kúp magassága / / V=(r*r*Pi*M)/3 /

6. Három tetszőleges (beolvasott) számról döntse el, hogy lehetnek -e egy háromszög oldalai

(szerkeszthető-e háromszög)! 7.

Készítsen algoritmust, amely kiszámítja egy háromszög kerületét és területét a HERON

képlet segítségével! T=négyzetgyök((s*(s-a)*(s-b)*(s-c)); s=kerület/2*

8. Készítse el a másodfokú egyenlet megoldó képlete alapján azt a programot, amelymeghatározza egy tetszőleges másodfokú egyenlet valós gyökeit!

9. Állítsa elő a Fibonacci-sorozat 1000-nél kisebb elemeit! A Fibonacci-sorozat eleje: 0, 1, 1,

2, 3, 5, 8, 13,… A sorozatban az első kettőt kivéve, bármely elem a megelőző kettőösszegeként áll elő. Írja ki a képernyőre a sorozattagokat!

10.

Olvasson be a rendszer bemenetéről egész számokat 0 végjelig, és írja ki az átlagukat!*

11. Határozza meg a páratlan számok összegét a-tól b-ig! (a és b bármelyike lehet párosvagy páratlan szám.) Írja ki az eredményt!*

12. Olvasson be a klaviatúráról 2 pozitív egész számot, A-t és B-t! Írja ki a képernyőre az Aés B közötti 7-tel osztható páros számokat csökkenő sorrendben! (A és B egyaránt lehet

páros és páratlan is.) Végül írja ki a darabszámot is!

13. Írjon programot, amely meghatározza két természetes szám legnagyobb közös osztójátEuklidesi algoritmussal!*

14.

Írjon programot, amely megadja két egész szám legkisebb közös többszörösét.

15. Írjon programot, amely eldönti egy számról, hogy prím-e?

16. Írjunk programot, amely két 1-nél nagyobb, egymástól különböző természetes számróleldönti, hogy azok relatív prímek -e! Két szám relatív prím, ha egy közös valódi osztójuksincs. (Egy szám valódi osztóinak nevezünk minden olyan osztót, amely nem 1 és nemmaga a szám.)

17. Olvasson be a rendszer bemenetéről egész számokat 0 végjelig! Határozza meg a beolvasott negatív számok összegét és darabszámát!



35

18. Olvasson be a klaviatúráról egész számokat 0 végjelig! Adja meg a páros elemekdarabszámát!

19. Határozza meg az 1 -1000-ig terjedő intervallumban azoknak a természetes számoknak azátlagát, amelyek oszthatók 3-mal!

20.

Állítsa elő és írassa ki a számtani sorozat első 10 tagját az első elem és a differencia beolvasása után!

21. Állítsa elő és írassa ki a mértani sorozat első 10 tagját az első elem és a hányados beolvasása után! Figyeljen a túlcsordulásra!

22. Határozza meg egy szám osztóinak a számát! Olvassa be a számot, írja ki az osztóit, végülaz osztók számát is!

23. Határozza meg egy szám összes többszörösét, melyek nem nagyobbak, mint 100!

Olvassa be a számot, majd írja ki a többszöröseit 100-ig!

24. Írjon olyan programot, amely az 1000 alatti prímszámokat kiírja a standard outputra! Akiírás táblázatos formában, egy sorba több számot írva történjen!

25. Olvasson be a klaviatúráról 10 egész számot, majd írja ki a képernyőre a legnagyobb beolvasott számot, és azt is, hogy hányadikként olvasta be!

26. A hőmérsékletet Celsius-fokban és Fahrenheit-fokban szokás megadni. A kettő közöttiösszefüggést a következő képlet adja meg: C=(5/9)*(F-32). Írjon olyan programot, amelyelvégzi az átszámítást, ha a Fahrenheit-fokban megadott hőmérséklet 0-tól 300-ig 20

fokonként változik! A Fahrenheit- ben és a hozzátartozó Celsius- ban kapott hőmérséklet

értékeket táblázatos formában írja ki a képernyőre! A feladatot mindhárom ciklussal oldjameg!

27. Számolja ki PI értékét az alábbi végtelen sorozat 100 tényezőjének figyelembevételével!Az eredményt írja ki a képernyőre!* PI/2=2/1*2/3*4/3*4/5*6/5*6/7*8/7*8/9*....

28. Egy gyerek a szüleitől P Ft zsebpénzt kapott. Az első napon 10 Ft -ot költött, majd ezutánminden nap 5 Ft-tal többet. Hány napig tudta ezt a költekezést folytatni, és mennyi„töredék” pénze maradt? A P-t olvassa be, az eredményt írja ki!*

29. Írjon olyan programot, amelyben ellenőrzéssel beolvas a klaviatúráról legalább kétjegyű

pozitív egész számokat, majd minden egyes szám beolvasása után kiírja a képernyőre aszám fordítottját!

30.

Olvasson be egy 0-val végződő, egészekből álló számsorozatot, írja ki a beolvasottlegnagyobb számot és annak sorszámát is!

31. Készítsen programot, amely az összes olyan háromjegyű páratlan természetes számotkiírja a képernyőre növekvő sorrendben, amely különböző számjegyekből áll!

32. Írjon programot, amely nullától különböző egész értékeket olvas be a billentyűzetről a 0végjelig. A program határozza meg és írja képernyőre azt a három értéket, amelynek

átlaga maximális.



36

33. Írjon olyan programot, amely egy beolvasott műveleti jel (| / !) alapján számol abszolútértéket, reciprokot, faktoriálist! A műveletek operandusát is olvassa be! A beolvasásokatellenőrizze! (Használjon switch-case szerkezetet!)

34. Összegezze egy dominókészlet pontjait és írja ki az eredményt a képernyőre! (A dominó

legnagyobb értékű darabja a 8-8.)

1.4.3. Egydimenziós tömbök (vektorok), karaktertömbök 35. Olvasson be 0 végjelig egész számokat egy egydimenziós tömbbe!*

Adja meg a tömb elemeinek átlagát! Döntse el, hogy van-e páros elem a tömb elemei között! Adja meg az első páros elem indexét! Adja meg a páros elemek darabszámát! Adja meg a legkisebb és a legnagyobb elemet, valamint ezen elemek sorszámát!

36.

Olvasson be legfeljebb 20 kétjegyű egész számot! Nem kétjegyű szám esetén fejezze be a bevitelt! Írja ki, hogy hány számot olvasott, majd sorolja fel külön a páros és a páratlanszámokat!

37. Olvasson be a klaviatúráról egész számokat 0 végjelig! Adja meg a páratlan elemekátlagát!

38. Olvasson be 0 végjelig egész számokat egy egydimenziós tömbbe! Adja meg a párosértékű elemek átlagát és darabszámát!

39. Töltsön fel véletlen számokkal egy 20 elemű tömböt! Adja meg a tömb legkisebb és

legnagyobb elemének indexét és értékét! 40. Töltsön fel véletlen számokkal egy 10 elemű tömböt! Döntse el, hogy van-e 3-mal

osztható a tömb elemi között! Ha van, adja meg az első 3-mal osztható elem sorszámát!Adja meg, hogy hány db 3-mal osztható elem van a tömb elemei között!

41. Töltsön fel egy 10 elemű egész típusú tömböt véletlen-szám generátorral, Ezután írja ki azelemeket a képernyőre egy sorban, majd külön sorban a páratlan elemek számát is!

42. Töltsön fel egy 10 elemű egész típusú tömböt a klaviatúráról történő beolvasással!Állapítsa meg, hogy a tömb elemei szigorúan monoton növekvő sorozatot alkotnak -e,

majd az eredményről megfelelő szöveges üzenetet írjon a képernyőre!

43. Töltsön fel két 10 elemű vektort véletlenszám generátorral! Írja ki a tömbök tartalmát,majd a két vektor skaláris szorzatát a képernyőre!

44. Készítsen programot, mely egy 20 elemű vektor elemeit 1 hellyel előre mozgatja, és azelső elem az utolsó helyre kerül. A feltöltést véletlenszám generátorral oldja meg, majdírja ki az eredeti és az új vektort!*

45. Írjon olyan programot, amely egy 10 elemű egész típusú tömb elemeiről eldönti, hogyszámtani sorozatot alkotnak -e! A tömböt a klaviatúráról történő beolvasással töltse fel,majd a megfelelő szöveges üzenetet írja ki a képernyőre!*



37

46. Töltsön fel egy 10 elemű egész típusú tömböt véletlenszám generátorral, úgy, hogy csupa

különböző eleme legyen. Ezután írja ki az elemeket a képernyőre.*

47. Írjunk programot, amely a billentyűzetről egész értékeket olvas be a 0 végjelig! A program írja képernyőre azokat az értékeket, amelyek megegyeznek az előző két érték

összegével!

48.

K szám keresése. Olvasson be egy n és m természetes számot. Keressük meg azt atermészetes k számot, melyre: nk -1 m! nk

49. Inicializáljon egy char típusú tömböt (sztringet) a saját nevével, majd írja ki a tömbelemeit karakterenként új sorba!

50. Olvasson be egy karaktersorozatot (sztringet) ’Enter ’ karakterig! Keresse meg az elsőszámjegy karaktert!

51.

Olvasson be egy karaktersorozatot (sztringet) ’Enter ’ karakterig! Fordítsa meg a sztringet!

52. Olvasson be egy karaktersorozatot (sztringet) ’Enter ’ karakterig! Van ’a’ betű asztingben?

53. Olvasson be egy karaktersorozatot (sztringet) ’Enter ’ karakterig! Vizsgálja meg, hogy palindrom-e! (Palindrom az a szöveg vagy szám, amely fordítva olvasva is ugyanaz.Például: kerek vagy 13631.)*

1.4.4. Gyakorisági tömbök 54.

Készítsen statisztikát kocka dobálás eredményeiről! A lehetséges dobás értékek: 1, 2, 3, 4,5, 6. Minden kocka-dobást véletlenszám-generátorral oldjon meg! A számlálástgyakoriság tömb alkalmazásával végezze el, majd az eredményt áttekinthető formában írjaki a képernyőre!*

55. Írjon programot, amely statisztikát készít a standard bemeneten beolvasott számokban

előforduló számjegykarakterekről. A program számjegyenként írja ki, hogy melyikszámjegy hányszor fordult elő. Ügyeljen rá, hogy nem csak számjegyek fordulhatnak elő.*

56. Készítsen osztályzási statisztikát! Olvasson be a billentyűzetről osztályzatokatellenőrzéssel. Készítsen statisztikát, hogy hány db 1-es, 2-es, stb. született. Gyakorisági

tömbbel dolgozzon!

57.

Olvasson be a billentyűzetről max. 100 db egész számot. Gyakoriságtömb segítségévelszámolja meg, hogy hány pozitív, hány negatív és hány 0 eleme van a tömbnek!

58. Írjunk programot, amely a billentyűzetről látható karaktereket olvas ’Enter ’ végjelig! A program határozza meg és írja képernyőre a beolvasott különböző karaktereket és azokgyakoriságát!

59. Készítsen programot, amely az összes olyan háromjegyű páratlan természetes számotkiírja a képernyőre növekvő sorrendben, amely különböző számjegyekből áll!

60. Készítsen programot, amely meghatározza egy sztringben lévő a,b,c,d,e,…,z karakterek

előfordulásának gyakoriságát, majd a képernyőre írja ki az eredményt!



38

1.4.5. Kétdimenziós tömbök, mátrixok 61. Írjon olyan programot, amely véletlen számokkal feltölt egy 10*5-ös mátrixot, és mátrix

alakban kiírja a képernyőre!

62. Kétdimenziós tömb alkalmazásával oldja meg a következő feladatot:

Egy 10 fős tanulócsoport 6 tantárgyból szerzett osztályzatait kell feldolgozni. Ellenőrzött bevitellel vagy véletlenszám generátorral töltsük fel a 10*6-os tömböt úgy, hogy mindentanuló esetében a tantárgyak sorrendje ugyanaz. Az osztályzatokat tanulónként kérjük be.A tanulókat és a tantárgyakat is sorszámmal azonosítjuk. A bevitt osztályzatokat mátrixalakban jelenítsük meg, úgy, hogy egy sorban egy tanuló osztályzatai legyenek, a sorvégén a tanuló tanulmányi átlagával. Utolsó sorként írjuk ki a tantárgyak átlagát atanulócsoportban!*

63. Töltsön fel véletlen szám generátorral egy M*N-es mátrixot! Készítse el a mátrixtranszponáltját!*

64. Töltsön fel véletlen szám generátorral egy M*N-es mátrixot! Döntse el, hogy

szimmetrikus-e a mátrix?*

65. Készítsen Hilbert mátrixot! A Hilbert mátrix bármely eleme az elem sor - ésoszlopindexének összege. Jelenítse meg a képernyőn a mátrixot!

66. Készítsen olyan programot, amely feltölt egy négyzetes mátrixot páratlan egészszámokkal véletlenszám generátor alkalmazásával; majd 0-val helyettesíti a mátrix azonelemeit, melyek a főátlóban álló legnagyobb és legkisebb szám által meghatározottintervallumon kívül esnek.

67.

Egy egész típusú négyzetes mátrixot úgy töltsön fel, hogy minden elem a sor- ésoszlopindexének szorzata legyen! Ezután jelenítse meg az elemeket sorfolytonosan mátrixalakban, majd tükrözze a mátrix elemeit a főátlóra és az így kapott új tömböt is jelenítse

meg ugyancsak mátrix alakban!

68. Írjon olyan programot, amely: egy négyzetes mátrixot feltölt páratlan egész számokkalvéletlen szám generátor alkalmazásával; 0-val helyettesíti a mátrix azon elemeit, amelyeka főátlóban álló legnagyobb és legkisebb szám által meghatározott intervallumon kívülesnek; az így keletkezett mátrixot megjeleníti a képernyőn sorfolytonosan, táblázatosformában.

1.4.6. Függvények, paraméterátadás 69. Egy ellenőrzéssel beolvasott pozitív egész számról döntse el, hogy prímszám -e! A

vizsgálatot függvénnyel végeztesse el, amely az eredményt „logikai érték” visszaadásával jelzi a főprogramnak! A szöveges üzenetet a főprogram írja ki a képernyőre!*

70. Olvasson be ellenőrzéssel a klaviatúráról 2 pozitív egész számot, majd határozza meg alegnagyobb közös osztójukat! A legnagyobb közös osztó meghatározását függvénnyel

végeztesse el, amely azt visszaadja a hívónak! Az eredményt a főprogram írja ki aképernyőre!



39

71. Írjon olyan programot, amely egy 10 elemű egész típusú tömb legnagyobb elemétkiválasztja és kiírja a képernyőre! A tömböt a klaviatúráról történő beolvasással töltse fel!A legnagyobb elem kiválasztását függvénnyel végeztesse el, amely azt visszaadja ahívónak.*

72.

Töltsön fel egy 10 elemű egész típusú tömböt a billentyűzetről történő beolvasással, majdállapítsa meg, hogy a tömbelemek szigorúan monoton növekvő sorozatot alkotnak-e! Az

eredményről írjon szöveges üzenetet a képernyőre! A szöveges üzenet kiírása egyfüggvény által visszaadott érték szerint történjen!

73. Töltsön fel egy 10 elemű egész típusú tömböt véletlenszám generátorral, és írja ki atömbelemeket a képernyőre! Ezután olvasson be egy egész számot, és a lineáris keresésalgoritmusát alkalmazva állapítsa meg, hogy ez a szám előfordul-e a tömbelemek között!A lineáris keresést függvénnyel végeztesse el, amely a keresés eredményét logikai értékvisszaadásával jelzi a főprogramnak! A szöveges üzenetet a főprogram írja ki a

képernyőre!

74. Írjon olyan egész értékű függvényt, amely egy paraméterként megadott kezdőcímű éselemszámú egész típusú vektorban megkeresi a legnagyobb számot, és ezt adja vissza a

főprogramnak!*

75. Írjon olyan érték nélküli függvényt, amely egy paraméterként megadott kezdőcímű éselemszámú egész típusú vektor elemeit segéd tömb használata nélkül csökkenő sorrendberendezi!

76. Írjon függvényt annak megállapítására, hogy egy paraméterként megadott előjelnélküli

egész számban van-e számjegyazonosság, és az eredményt megfelelő érték visszaadásával jelezze a főprogramnak!

77. Írjon olyan egészértékű függvényt, amely egy paraméterként megadott kezdőcímű éselemszámú egész típusú tömb elemeiről eldönti, hogy számtani sorozatot alkotnak -e!

78. Írjon olyan egész értékű függvényt, amely egy paraméterként megadott kezdőcíműsztringben a szomszédos karakterek azonosságát megszünteti! A visszaadott érték az újsztring hossza legyen. A feladatot segéd sztring használata nélkül oldja meg! (Például:„Asswerrt 3455cvvvx” esetén az új sztring: „Aswert 2345cvx” és a visszaadott érték: 14.)

79.

Írjon olyan programot, amely egy a klaviatúráról beolvasott sztringről megállapítja, hogytartalmaz-e decimális számjegy karaktert, majd az eredményről írjon megfelelő szövegesüzenetet a képernyőre! A vizsgálatot függvénnyel végeztesse el, amely a sztringet

paraméterként kapja, az eredményt pedig logikai érték visszaadásával jelzi a hívónak!

80. Készítsen egy függvényt, amely egy egész számot átalakít egy adott számrendszerbelisztringgé! A függvény első paramétere az átalakítandó szám, második paramétere aszámrendszer alapja, a visszatérési érték pedig az eredmény sztring. A számrendszeralapszáma a 2, . . . , 35 intervallumba esik.

81. Írjon eljárást, amely paraméterként megkap egy karaktereket tartalmazó, tetszőleges

méretű egydimenziós tömböt, és a tömb nem betű karaktereit kicseréli szóközre.



40

82. Írjon eljárást, amely paraméterként megkap egy tetszőleges méretű, sztringeket tartalmazóvektort, és előállít egy olyan vektort, amelynek elemei rendre a paraméterként kapottvektor elemeinek annyiadik karakterét tartalmazzák, amennyi az adott elem indexe, illetvea @ karaktert, ha nem létezik ilyen elem. Egy sztring karaktereit 0-tól sorszámozzuk.

83.

Írjon olyan függvényt, amely megállapítja, hogy egy paraméterként kapott sztringben benne van-e egy másik, szintén paraméterként kapott sztring! A főprogram beolvassa asztringeket a klaviatúráról, majd a függvény által visszaadott eredmény szerint üzenetet íra képernyőre. Ha előfordul, akkor a kezdő indexet kimenő paraméterben adja vissza afüggvény a hívónak.*

84. Olvasson be a billentyűzetről ellenőrzéssel egy pozitív egész számot. Állapítsa meg, hogyvan-e benne számjegy azonosság, majd erről írjon megfelelő szöveges üzenetet aképernyőre! Ha van számjegy azonosság, írja ki, hogy melyik a leggyakrabban előfordulószámjegy érték! Több azonos előfordulás esetén a legkisebb jegy értékét írja ki. A

feladatot gyakorisági tömb alkalmazásával oldja meg! A főprogram az ellenőrzött beviteltés az eredmény kiírását végezze el. A beolvasott pozitív szám vizsgálatát egy függvényvégezze el

85. Írjunk logikai függvényt, amely egy paraméterként megkapott, sztringeket tartalmazónégyzetes mátrixról eldönti, hogy szimmetr ikus-e!

86. Írjon eljárást, amely egy paraméterként kapott tetszőleges méretű, egészeket tartalmazóegydimenziós tömbben meghatározza a legnagyobb összegű résztömb kezdő- ésvégindexét két kimenő paraméterében!

87.

Készítsen olyan C++ programot, amely kiválasztja egy pozitív egész számokat tartalmazóvektorból azt a számot, amelyben a számjegyek átlaga a legkisebb!

88. Készítsen olyan programot, amely egy természetes számot felbont törzstényezőinek

szorzatára! A számot olvassa be, az eredményt írja ki!

A *-gal jelölt feladatok megoldásai megtalálhatók a jegyzetben.



41

2.

Kidolgozott feladatok ASM programozásra

2.1. Adatmozgató, aritmetikai és vezérlésátadó utasítások 7

2.1.1.

Készítsen programot, amelya) m eghatározza 2 db bájtos memóriaváltozó összegét, az eredményt tárolja egy szavas

memória változóban! b) m eghatározza egy szavas és egy bájtos memóriaváltozó különbségét, az eredménytel tárolja egy szavas memóriaváltozóban!

Az Intel assembly programozási példák tanulmányozásához szükség lesz egy un. kódtáblára,amely megtalálható a jelen fájllal azonos könyvtárban AsmKodtabla.pdf néven (ha a link nem

működik, kérem keresse meg a fájlt az adott útvonalon!). Az Intel assembly programozássorán szavas regiszterek állnak rendelkezésünkre. Az Intel 8086/88 mikroprocesszor

regiszterkészlete a 46. ábrán látható. Ezek a szavas regiszterek bájtos regiszterekként ishasználhatók (pl. AX szavas regiszter alsó bájtja, mint bájtos regiszter AL, felső bájtja, mint

bájtos regiszter AH). Az utasítások során az operandusok típusának meg kell egyeznie. Pl. bájtos operandushoz bájtos operandust adhatunk hozzá. Következésképpen bájtosoperandushoz szavas operandust hozzáadva hibát kapunk (hiszen az eredmény valószínűlegnem fér el 1 bájton), de szavas operandushoz bájtos operandust hozzáadhatunk adatvesztésnélkül (ekkor is warning figyelmeztető üzenetet fogunk kapni), de az eredményünk helyeslesz. Van egy un. flag regiszter, amely jelzőbiteket tartalmaz. Az I8086 assembly programszegmentált felépítésű. Minden program tartalmazni fog egy INT 21H utasítássort. Az INT

(interrupt) egy szoftveres megszakítást generál, az INT 21H hatására egy (DOS szintű)szubrutingyűjtemény kerül meghívásra. Hogy melyik szubrutin fog végrehajtásra kerülni, azta funkciókód (amit általában az AH regiszterbe töltünk) dönti el. Ha a funkciókód 4CH, ak kor

a vezérlés visszaadódik az operációs rendszernek.

7 AsmKodtabla 3.-5. és 10.-12. oldal

46. ábra. Az Intel 8086/88 mikroprocesszor regiszterkészlete

http://localhost/var/www/apps/conversion/tmp/scratch_5/AsmKodtabla.pdf






42

47. ábra. A 2.1.1. feladat programlistája

ADAT SEGMENT ;ADAT SZEGMENS KEZDETEA DB 2 ;BÁJTOS MEM.VÁLTOZÓ B DB 6EW DW ? ;SZAVAS MEM.VÁLTOZÓ D DW 200DK DW ?

ADAT ENDS ;ADAT SZEGMENS VÉGE KOD SEGMENT ;KOD SZEGMENS KEZDETEASSUME DS:ADAT, CS:KOD

START: MOV AX,ADAT;A DS SZEGMENS REGISZTERBE BETÖLTJÜK AZMOV DS,AX ;ADATSZEGMENS KEZDŐCÍMÉTMOV AX,0MOV AL,A ;AZ A MEM.OP-OT AL REGISZTERBE TÖLTJÜK ADD AL,B ;AL-HEZ HOZZÁADJUK B MEM.OP-OTMOV EW,AX ;AZ EREDMÉNYT SZAVASAN KIMOZGATJUKMOV AX,D ;AX-BE BETÖLTJÜK A DK SZAVAS MEM.OP-OTMOV BH,0MOV BL,A ;A BL-BE BETÖLTJÜK A BÁJTOS A MEM.OP-OTSUB AX,BX ;SZÓT SZÓBÓL VONUNK KI

MOV DK,AX ;AZ AX-ET (AZ ELŐZŐ KIVONÁS EREDMÉNYÉT;KIMOZGATJUK A DK SZAVAS MEM.OP-BA)MOV AH,4CH ;AZ AH-BA 4CH-T TÖLTÜNK INT 21H ;A PROGRAM LOGIKAI VÉGE, VISSZAADJUK A VEZÉRLÉST AZ OP.

;RENDSZERNEKKOD ENDS ;KOD SZEGMENS VÉGE

END START ;A PROGRAM FIZIKAI VÉGE

2.1.2. Készítsen programot, amely a) 2 db memóriában tárolt bájtos adat szorzatát képezi, az eredményt eltárolja amemóriában!

b) 2 db memóriában tárolt bájtos adat hányadosát képezi, az eredményt (a hányadost és amaradékot) letárolja a memóriában!

A megoldás során a MUL és a DIV utasítást alkalmazzuk. Ez a két utasítás látszólagegyoperandusú utasítás. A másik operandus rejtett operandus. Mindkét műveletnek van bájtosés szavas változata is. Hogy melyik változatról van szó, azt az operandus típusa dönti el.ADAT SEGMENTA DB 2 ;BÁJTOS MEM.VÁLTOZÓ B DB 6SZW DW ? ;SZAVAS MEM.VÁLTOZÓ D DW 200

DK DW ?H DB ?M DB ?ADAT ENDSKOD SEGMENT

ASSUME DS:ADAT, CS:KODSTART: MOV AX,ADAT;A DS SZEGMENS REGISZTERBE BETÖLTJÜK AZ

MOV DS,AX ;ADATSZEGMENS KEZDŐCÍMÉTMOV AL,A ;BÁJTOS SZORZÁS (AL)*(B) AZ EREDMÉNY AZ MUL B ;AX-BEN KÉPZŐDIK MOV SZW,AXMOV AX,0MOV AL,A ;BÁJTOS OSZTÁS (AX)/(B) AZ EREDMÉNY DIV B ;AL-BEN A HÁNYADOS, AH-BAN A MARADÉK LESZ MOV H,AL



43

48. ábra. A 2.1.2. feladat

49. ábra. A 2.1.3. feladat

MOV M,AHMOV AH,4CH ;4CH FUNKCIÓKÓD BETÖLTÉSE AZ AH REGISZTERBE INT 21H ;A PROGRAM LOGIKAI VÉGE, VISSZADJUK A VEZÉRLÉST AZ OP.

;RENDSZENEKKOD ENDS

END START

2.1.3. Készítsen programot, amely a memóriában tárolt 10 bájtos adat (tömb elemeinek)összegét képzi, és az eredményt letárolja szavasan a memóriában.

Az algoritmusban bájtos adatokat fogunk összeadni, de az eredményt egy szón (16 biten)tároljuk. Az eredmény is lehetne bájtos adat, de ekkor nagy valószínűséggel túlcsorduláslépne fel. Ezt próbáljuk elkerülni úgy, hogy az eredményt egy szón tároljuk. A megoldássorán a halmozott összegképzést (az összegzés tételét) alkalmazzuk. Indexelt címzésthasználunk, a 0. adat címéhez képesti eltolást mindig az SI indexregiszter fogja mutatni. Az

assembly programozás során is van lehetőségünk ciklusok írására. Ciklust vezérlésátadó, ugróutasításokkal tudunk készíteni. Az ugró utasítások között kitüntetett szerepe van a LOOPutasításnak. A LOOP utasítással egy hátul-tesztelő ciklust tudunk készíteni. A LOOPautomatikusan csökkenti (dekrementálja) a CX tartalmát, és ha a CX nem 0, akkorvisszaugrik a megadott címkére, vagyis annyiszor hajtódik végre a ciklusmag, amennyi a CXértéke. ADAT SEGMENTT DB 20,-11,26,30,45,-20,-65,125,45,68OSSZ DW ? ;A SZÁMOK ÖSSZEGEADAT ENDSKOD SEGMENT

ASSUME DS:ADAT, CS:KODSTART: MOV AX,ADAT

MOV DS,AXMOV OSSZ,0 ;AZ ÖSSZEG KINULLÁZÁSA

;CIKLIKUSAN ÖSSZEADJUK A SZÁMOKATMOV CX,10 ;CIKLUS SZÁMLÁLÓ, ITT A TÖMB ELEMEINEK A SZÁMA MOV SI,0 ;AZ ADOTT ELEM INDEXEMOV AH,0

CIKL: MOV AL,T[SI];INDEXELT CÍMZÉS. AZ AL-BE BETÖLTJÜK AZ;ÉPPEN HOZZÁADANDO BÁJTOS SZÁMOT

ADD OSSZ,AX ;SZAVAS ÖSSZEADÁSINC SI ;INDEX NÖVELÉSELOOP CIKL ;CX CSÖKKENTÉSE, HA CX NEM 0, AKKOR UGRIK A CIKL CIMKÉRE

MOV AH,4CHINT 21H ;VISSZADJUK A VEZÉRLÉST AZ OP. RENDSZERNEK KOD ENDS

END START

2.1.4. Készítsen olyan programot, amely a memóriában letárolt 10 db bájtos adat közülmeghatározza a legnagyobb elemet!

Ebben az algoritmusban a maximum kiválasztás tételét alkalmazzuk. A megoldás soránfeltételezzük, hogy a 0. elem a legnagyobb. Ezt megjegyezzük egy MAX nevű változóba. Atömb többi elemét ehhez a változóhoz hasonlítjuk.



44

Ha találunk nagyobb elemet, akkor ezt megjegyezzük. Ebben a programban használjuk aCMP (compare) utasítást. A CMP célop, forrásop utasítás összehasonlítja a két operandustartalmát, és az eredménytől függően állítja a flageket. Pl. ha a két operandus egyenlő, akkor aZéró flag (ZF) 1 lesz. A példában szereplő JLE címke utasítás egy feltételes ugró utasítás.

Akkor ugrik a megadott címkére, ha az előző CMP utasítás eredménye az volt, hogycéloperandus kisebb vagy egyenlő a forrásoperandusnál. ADAT SEGMENTT DB 23, -10, 25, 31, 46, -21, -65, 125, 40, 67MAX DB ? ;AZ AKTUÁLIS LEGNAGYOBB ELEMADAT ENDSKOD SEGMENT


MOV DS,AXMOV SI,0 ;TÖMBINDEX LESZMOV AL,T[SI] ;A TÖMB 0. ELEMET BETÖLTJÜK A MAXMOV MAX,AL ;VÁLTOZÓBA

MOV CX,9 ;CIKLUSSZÁMLÁLÓ, A TÖMB ELEMEINEK SZÁMAINC SI ;INDEX NÖVELÉSE

CIKL: MOV AL,T[SI] ;HASONLÍTJUK A TÖMB AKTUÁLIS ELEMÉT AZCMP AL,MAX ;EDDIGI LEGNAGYOBB ELEMHEZJLE TOV ;HA <=, AKKOR NINCS TEENDŐNK, UGRUNKMOV MAX,AL ;HA (AL)>MAX, AKKOR MEGJEGYEZZÜK

TOV: INC SI ;INDEX NÖVELÉSE LOOP CIKL ;HA CX NEM 0 (VAN MÉG TÖMBELEM), UGRÁS A CIKL. CIMKÉRE MOV AH,4CHINT 21H ;VISSZADJUK A VEZÉRLÉST AZ OP. RENDSZERNEK

KOD ENDSEND START

2.1.5. Adott egy 10 bájtos tömb feltöltve. Másolja át egy 10 szavas tömbbe a bájtos tömbelemeit fordított sorrendben! A megoldás során két indexregisztert alkalmazunk. Az SI-vel a bájtos tömböt (kezdőértéke 0)indexeljük, a DI-vel a szavas tömböt (kezdőértéke 18) indexeljük. Ciklus segítségével töltjükát az elemeket, az SI-t 1-el növeljük (inkrementáljuk ), a DI-t 2-vel csökkentjük(dekrementáljuk ) (mivel szavas a tömb) egy-egy tömbelem áthelyezése után. ADAT SEGMENTTB DB 23, -10, 25, 31, 46, -21, -65, 125, 40, 67TW DW 10 DUP(0)

ADAT ENDS

KOD SEGMENTASSUME DS:ADAT, CS:KOD

START: MOV AX,ADATMOV DS,AXMOV CX,10 ;CIKLUSSZÁMLÁLÓ, ITT A TÖMB ELEMEINEK A SZÁMA MOV SI,0 ;SI ELÖLRŐL FOG INDEXELNI MOV DI,18 ;DI HÁTULRÓL FOG INDEXELNI MOV AX,0




45

CIKL: MOV AL,TB[SI]MOV TW[DI],AXINC SI ;INDEX NÖVELÉSE DEC DI ;TW SZAVAS TÖMB, EZÉRT AZ INDEXET 2-SÉVEL DEC DI ;KELL MOZGATNILOOP CIKL ;UGRÁS A CIKL CIMLÉRE, HA VAN MÉG TÖMBELEM

MOV AH,4CHINT 21H ;A PROGRAM LOGIKAI VÉGE

KOD ENDSEND START

2.1.6. Adott egy 10 szavas tömb feltöltve. A tömb minden elemét ossza el 5- tel, és ahányadosokat egy tömbben helyezze el!

A megoldás során (mivel szavas adatot kell osztanunk) célszerűen bájtos osztást fogunkhasználni. Ciklikusan az AX regiszterbe betöltjük az osztandó tömbelemet, elosztjuk 5-el (egy

5 értékű bájtos memóriaoperandussal). A hányados az AL regiszterben lesz, ezt kimozgatjuk aH nevű bájtos tömbünk aktuális elemébe. Mivel egy szavas és egy bájtos tömböt kellkezelnünk, célszerű két külön tömbindexet alkalmazni. A bájtos tömb indexét 1-el, a szavas

tömb indexét 2-el kell léptetnünk. ADAT SEGMENTT DW 23, 10, 25, 31, 46, 21, 65, 125, 40, 67H DB 5 DUP(0)OT DB 5ADAT ENDSKOD SEGMENT


MOV DS,AXMOV CX,10 ;CIKLUSSZÁMLÁLÓ, ITT A TÖMB ELEMEINEK A SZÁMA MOV SI,0 ;SI A T TÖMBÖT INDEXELI MOV DI,0 ;DI A H TÖMBÖT INDEXELI

CIKL: XOR AH,AH ;AH kinullázása MOV AX,T[SI]DIV OT ;BÁJTOS OSZTÁS MOV H[DI],AL ;HÁNYADOSOK KIMOZGATÁSA EGY TÖMBBE INC SI ;INDEX NÖVELÉSE INC SIINC DILOOP CIKL ;UGRÁS A CIKL CIMKÉRE, HA VAN MÉG TÖMBELEM MOV AH,4CH

INT 21HKOD ENDSEND START

2.1.7. Adott egy 10 bájtos tömb feltöltve. Rendezze át a tömbelemeket úgy, hogy mindenelem 1 hellyel előrelép, és az első elem a tömb utolsó helyére kerül!

A megoldás során a tömb 0. elemét kimozgatjuk egy segédváltozóba, majd ciklikusan a tömbi. elemét felülírjuk az i+1. elemmel. A ciklus lefutása után az utolsó elem helyére

bemozgatjuk a segédváltozóba kimentett 0. elemet.





46


ADAT SEGMENTT DB 1,2,3,4,5,6,7,8,9,10ADAT ENDSKOD SEGMENT


MOV DS,AXMOV BL,T[0] ;A 0. ELEM ELMENTÉSE MOV SI,0 ;TÖMBINDEX MOV CX,9 ;CIKLUSSZÁMLÁLÓ

CIKL: MOV AL,T[SI+1]MOV T[SI],AL ;AZ SI+1.ELEM A SI. HELYRE KERÜL INC SILOOP CIKLMOV T[9],BL ;AZ UTOLSÓ ELEM HELYÉRE BEMOZGATJUK

;A 0. ELEMETMOV AH,4CHINT 21h

KOD ENDS

END START

2.2. Bitműveletek, logikai utasítások 8

2.2.1. Készítsen programot, amely meghatározza, hogy a memóriában letárolt 10 bájtosadat (tömb) elemei között hány db páros elem van!

Ebben az algoritmusban a megszámolás tételét alkalmazzuk. A megoldás során az adatokategyesével vizsgáljuk, megnézzük, hogy páros-e. Ha igen, akkor egy változót (PDB)

megnövelünk 1-el. Ha egy szám páros, akkor az utolsó bitje biztosan 0. Ebben a példában aTEST op,maszk utasítást használjuk. A TEST utasítás bitenkénti logikai „és” (AND)műveletet végez, az eredménytől függően állítja a flageket. A példánkban a vizsgálttömbelemet (amit betöltünk az AL regiszterbe) logikai „és” kapcsolatba hosszuk 01H-val. Ha

a tömbelem legkisebb helyiértékű bitje 0 volt, akkor a TEST utasítás után 0 lesz az ALtartalma. Ekkor páros a vizsgált tömbelem. A logikai utasítások két operandussalrendelkeznek. Az utasítások a két operandussal bitenként végzik el a megadott logikaiműveletet. Az eredmény az első operandus helyén keletkezik. Az AND utasítás bitenkénti„és”, az OR bitenkénti „vagy”, az XOR bitenkénti „kizáró vagy” műveletet végez. A NOT

utasítás (tagadás) egyoperandusú művelet, a biteket ellentettjükre változtatja (egyeskomponens).ADAT SEGMENTT DB 23,-10,25,31,46,-21,-65,125,40,67PDB DB ? ;A PAROS ELEMEK DARABSZAMAKETTO DB 2ADAT ENDS

8 AsmKodtabla 7. oldal



47




START: MOV AX,ADATMOV DS,AX

;CIKLIKUSAN MEGVIZSGALJUK AZ ELEMEKET, HOGY AZ UTOLSÓ BIT 0-E?MOV CX,10 ;CIKLUSSZÁMLALO

MOV SI,0 ;INDEXMOV PDB,0

CIKL: MOV AH,0 ;AH-ba 0 AZ OSZTAS MIATT AX TARTALMA MEGVALTOZIKMOV AL,T[SI]TEST AL,01H ;LOGIKAI ÉS KAPCSOLAT 01H-VAL, HA AZ

;UTOLSÓ BIT 0, AKKOR 0 AZ EREDMÉNY JNZ TOV ;HA NEM 0 (ZF=0), AKKOR UGRASINC PDB ;PÁROS, DB SZAMLALO NOVELESE

TOV: INC SILOOP CIKLMOV AH,4CHINT 21H

KOD ENDS

END START

2.2.2. Egy 10 elemű szavas tömb minden elemét tegye 8- cal oszthatóvá úgy, hogy a 8-asosztás maradékát a számokból elveszi! Nem használhat DIV utasítást!

A megoldás során bitenkénti logikai műveleteket használunk. Egy szavas adat akkor osztható8-al, ha az alsó 3 helyi értéken levő bit 0 (az első 1-es bit a 23-on, vagyis a 8-as helyi értékenlehet). 8-al oszthatóvá úgy tudjuk tenni az elemeket, ha töröljük logikai AND művelettel azalsó 3 helyi értékű bitet. A maszkérték: FFF8H. A példában az AND műveletet használjuk,

amely bitenként logikai „és” műveletet végez. ADAT SEGMENTT DW 110,120,130,140,150,160,170,180,190,200ADAT ENDSKOD SEGMENT


MOV DS,AXMOV CX,10MOV SI,0

CIKL: AND T[SI],0FFF8H ;AZ ALSÓ 3 BITET TÖRÖLJÜK, INC SI ;EKKOR OSZTHATÓ 8-ALINC SI

LOOP CIKLMOV AH,4CHINT 21H

KOD ENDSEND START

2.2.3. Határozza meg egy 10 elemű szavas tömb 4- gyel osztható elemeinek a számát! Nem

használhat DIV utasítást!

A megoldás során bitenkénti logikai műveleteket használunk. Egy szavas adat akkor osztható4-el, ha az alsó 2 helyi értéken levő bit 0 (az első 1-es bit a 22-on, vagyis a 4-es helyi értéken

lehet).



48


A vizsgált tömbelemet 4-el oszthatóvá tesszük (töröljük az alsó két helyi értéken levő bitetlogikai AND művelettel, a maszkérték: FFFCH), majd összehasonlítjuk az eredeti értékkel.Ha a két érték megegyezik, akkor 4-el osztható az eredeti tömbelem, ekkor megnövelünk 1-el

egy számláló változót.ADAT SEGMENTT DW 110,120,130,140,150,160,170,180,190,200OSZT4 DB 0ADAT ENDSKOD SEGMENT



CIKL: MOV AX,T[SI]AND AX,0FFFCH ;AZ ALSÓ 2 BITET TÖRÖLJÜK,

;EKKOR OSZTHATÓ 4-ELCMP T[SI],AX ;ÖSSZEHASONLÍTJUK AZ EREDETI TÖMBELEMMEL JNZ NEM ;HA EGYENLŐ, AKKOR EREDETILEG 4-EL

;OSZTHATÓ VOLT INC OSZT4 ;MEGNÖVELJÜK A DARABSZÁMOT

NEM: INC SIINC SILOOP CIKLMOV AH,4ChINT 21H

KOD ENDSEND START

2.3.

Léptető (shift) és forgató (rotate) műveletek 9

2.3.1. Készítsen programot, amely megszámolja egy 10 elemű bájtos tömb azon elemeineka számát, amelyben a bitek száma páros!

A megoldás során a megszámolás tételét fogjuk alkalmazni. Meg kell számolnunk mindenegyes tömbelem esetén az 1-es értékű bitek számát. Az adott tömbelemet betöltjük egyregiszterbe, majd el fogjuk rotálni pl. balra úgy, hogy minden bit 1 helyi értékkel balra lép, akilépő bit belép majd a legkisebb helyi értéken és megjelenik a Carry flagben is. Ezt a RCLutasítás valósítja meg. Vizsgáljuk a Carry flaget, ha 1, akkor a bit 1-es, vagyis megnövelünk

majd egy számlálót. 8-szor kell majd rotálni, mivel 8 bites (1 bájtos) adatokkal dolgozunk.Ebben a példában szerepel még a PUSH op, illetve a POP op utasítás. A PUSH utasítás aszavas operandus értékét elmenti a verem memóriába, a POP utasítás egy szót kivesz a veremmemóriából. ADAT SEGMENTT DB 2,4,6,8,10,12,14,16,18,20P1DB DB 0ADAT ENDS

9 AsmKodtabla 8.-9. oldal



49



START: MOV AX,ADATMOV DS,AXMOV CX,10 ;CIKLUSSZÁMLÁLÓ, ITT A TÖMBELEMEK SZÁMA MOV SI,0

MOV DI,0CIKL: MOV AL,T[SI] ;A VIZSGÁLANDÓ TÖMBELEM

PUSH CX ;A CX TARTALMÁT ELMENTJÜK A VEREM MEMÓRIÁBA MOV CX,8 ;8-SZOR KELL ROTÁLNI

BIT1SZ: RCL AL,1 ;ROTÁLJUK 1 BITTEL BALRA JNC NEM1 ;HA A CF NEM 1, AKKOR UGRUNKINC DI ;MEGNOVELJUK AZ 1-ES BITEK SZAÁMÁT

NEM1: LOOP BIT1SZPOP CX ;A VEREM MEM. LEGFELSŐ SZAVÁT KIVESSZÜK A CX REGISZTERBE AND DI,01H ;AZ 1-ES BITEK SZÁMA ESETÉBEN A LEGKISEBB HELYIÉRTÉK 0? JNZ NEMPINC P1DB ;IGEN, MEGNÖVELJÜK A P1DB-T

NEMP: INC SI

LOOP CIKLMOV AH,4CHINT 21H

KOD ENDSEND START

2.4. Input/output műveletek 10

Az assembly nyelvben a beolvasás és kiírás nem olyan egyszerű, mint ahogy azt megszoktuka magas szintű nyelveknél. Pl. az 12345 számot, mint decimális számot számjegyenként(ciklikus művelettel) tudjuk beolvasni.Beolvasáskor karaktereket olvasunk, vagyis ASCII kódokat kapunk. Egy-egy karaktert egy-

egy bájtra helyezhetünk el a memóriában. Ahhoz, hogy dolgozni tudjunk a beolvasott

számmal, az 5 bájtos adatsorból (amely pl. az 12345 számjegyei) egy szavas (16 bites) binárisszámot kell képeznünk. Kiíráskor egy-egy karaktert tudunk megjeleníteni a képernyőn, így pl. ha az 12345 -nek

megfelelő bináris értéket decimális formában a képernyőn meg akarjuk jeleníteni, akkor

számjegyekre kell bontani, a számjegyek ASCII kódját előállítani, majd karakterenként(ciklik us művelettel) megjeleníteni a képernyőn.

2.4.1.

Olvassunk be a billentyűzetről egy maximum 5 jegyű decimális számot Enterkarakterig ellenőrzéssel, majd írjuk vissza a képernyőre! A megoldás során az INT 21H szoftver megszakítást alkalmazzuk.Beolvasás esetén az AH regiszterbe az 1-es funkció kódot kell tölteni, az INT 21Hvisszatérése után a beolvasott karakter ASCII kódját kapjuk meg az AL regiszterben.Kiírás esetén a kiírandó karakter ASCII kódját a DL regiszterben kell elhelyezni, az AHregiszterbe a 2-es funkciókódot kell tölteni. Az INT 21H meghívása után a karaktermegjelenik a képernyőn.

10 AsmKodtabla 13. oldal



50


További hasznos lehetőség, hogy a képernyőn szöveget (sztringet) jeleníthetünk meg. Ekkor akiírandó szöveg of f szet címét a LEA utasítás segítségével a DX regiszterbe töltjük, az AH-ba

a 9-es funkció kódot helyezzük el, és meghívjuk az INT 21H rutint. Fontos, hogy a kiírandószöveget a $ jellel zárjuk le! ADAT SEGMENTSZJ DB 5 DUP(?) ;A BEOLVASOTT SZÁMJEGYEK RÉSZÉRE

;LEFOGLALT HELYSZJSZ DW ? ;A BEOLVASOTT SZÁMJEGYEK SZÁMASZOV1 DB 0AH,0DH,'ADAT= $'SZOV2 DB 0AH,0DH,'A BEOLVASOTT ADAT= $'SZOV3 DB 0AH,0DH,'HIBAS KARAKTER!!! $'ADAT ENDSKOD SEGMENT


MOV DS,AXLEA DX,SZOV1 ;A SZOV1 SZTRINGÜNK KEZDŐCÍMÉT BETÖLTJÜK A DX-BEMOV AH,9

INT 21H ;INPUT SZOVEG MEGJELENÍTÉSE;BEOLVASAS CIKLIKUSAN

MOV SZJSZ,5MOV CX,5 ;MAX 5 DB SZÁMJEGYET OLVASUNK BEMOV SI,0 ;INDEX

BE: MOV AH,1INT 21H ;kar -> ALCMP AL,0DH ;ENTER KARAKTER?JE BEVEG ;HA ENTER, AKKOR KILÉPÜNK;ELLENORZESEKCMP AL,'0' ;(AL)='0'JL HIBA ;(AL)<'0' HIBAS KARAKTERCMP AL,'9' ;(AL)='9'

JG HIBA ;(AL)>'9' HIBAS KARAKTER;HELYES KARAKTER, LETÁROLJUKMOV SZJ[SI],ALINC SILOOP BE

BEVEG: SUB SZJSZ,CX ;A BEOLVASOTT SZÁMJEGYEK SZÁMACMP SZJSZ,0 ;HA 0 db KARAKTER LETT BEOLVASVA, AKKORJE VEGE ;PROGRAM VEGELEA DX,SZOV2MOV AH,9INT 21H ;KIÍRÁS SZÖVEG MEGJELENÍTÉSEMOV CX,SZJSZMOV SI,0

KI: MOV DL,SZJ[SI]MOV AH,2INT 21HINC SILOOP KIJMP VEGE

HIBA: LEA DX,SZOV3 ;HIBÁS KARAKTER MOV AH,9INT 21H

VEGE: MOV AH,4CHINT 21H

KOD ENDSEND START



51


2.4.2. Olvasson be maximum 80 karaktert a klaviatúráról, enter végjelig! Ezután írja ki aképernyőre; a kapott karaktersorozatot a decimális számjegy karakterek kihagyásával! A megoldás során karaktereket fogunk beolvasni a billentyűzetről. Minden egyes karaktert 1-

1 bájton tárolunk. Utána a számjegy karakterek kivételével kiírjuk a karaktereket a

képernyőre. A karakterek ASCII kódját fogjuk vizsgálni. Az adott karakter akkor számjegy,ha az ASCII kódja 30H és 39H közé esik. ADAT SEGMENTKAR DB 80 DUP(20H)KARSZ DB 0SOREM DB 0AH,0DH,'$'ADAT ENDSPROG SEGMENT

ASSUME DS:ADAT, CS:PROGSTART: MOV AX,ADAT


BE: MOV AH,1INT 21H ;1 KARAKTER BEOLVASÁSAMOV KAR[SI],AL ;BEOLVASOTT KARAKTER LETÁROLÁSAINC SICMP AL,0DH ;ENTER KARAKTER?LOOPNZ BE ;HA CX NEM 0 ÉS ZF NEM 1, AKKOR UGRÁS A BE CIMKÉRE LEA DX,SOREMMOV AH,9INT 21HMOV CX,80MOV SI,0

KI: MOV DL,KAR[SI] ;KIÍRANDÓ KARAKTER A DL-BECMP DL,30H

JL NEMSZ ;UGRIK, HA DL<'0'CMP DL,39HJG NEMSZ ;UGRIK, HA DL>'9'JMP SZ

NEMSZ: MOV AH,2INT 21H ;NEM SZÁMJEGY KARAKTER, KIÍRJUK

SZ: INC SICMP DL,0DHLOOPNZ KIMOV AH,4CHINT 21H

PROG ENDSEND START

2.4.3. Írjon olyan programot, amely egy 16 bites értéket binárisan kiír a képernyőre! A megoldás során léptető, rotáló és bitenkénti logikai műveleteket alkalmazunk. A kiírandó16 bites adatot (ciklikusan 16-szor) 1 bittel balra léptetjük úgy, hogy a kilépő bit belép alegkisebb helyi értéken és a Carry flagben is megjelenik. Ezt a ROL utasítás valósítja meg. A

Carry f lag tartalmát hozzáadjuk 0-hoz, így ha a kilépő bit 1-es volt, akkor az eredményünk 1lesz, ha 0 volt, akkor 0 lesz. A Carry flaggel együtt való összeadást az ADC utasítás valósítjameg. A zónarész hozzáadása után megjelenítjük a megfelelő karaktert ’1’ vagy ’0’ a

képernyőn.



52



ADAT SEGMENTBSZAM DW 0A3EFH ;A BITENKÉNT KIÍRANDÓ HEXADECIMÁLIS SZÁM ADAT ENDSKOD SEGMENT


MOV DS,AXMOV CX,16MOV BX,BSZAMMOV AH,2

CIKL: XOR DL,DL ;A DL TARTALMÁT ÖNMAGÁVAL KIZÁRÓ VAGY KAPCSOLATBA ;HOZZUK, ÍGY TARTALMA KINULLÁZÓDIK

ROL BX,1 ;ROTÁLJA BALRA CF-BEN IS MEGJENIK A BITADC DL,0 ;CF-EL EGYÜTT HOZZÁADJA DL-HEZOR DL,30H ;ZÓNARÉSZ RÁHELYEZÉSE INT 21H ;MEGJELENÍTJÜK A KÉPERNYŐN LOOP CIKLMOV AH,4CHINT 21H

KOD ENDSEND START

2.4.4. Írjon olyan programot, amely beolvas a klaviatúráról egy legfeljebb 16 jegyű binárisszámot ellenőrzéssel, majd a bináris értéket elhelyezi egy szavas változóban! A megoldás során léptető, és bitenkénti logikai műveleteket alkalmazunk. A konvertáltrészadatunkat tartalmazó regiszter tartalmát 1 bittel balra léptetjük (szorozzuk 2-vel), majd a

beolvasott aktuális karaktert (a zónarészét levágva) logikai OR művelettel hozzámásoljuk a

konvertált részadatunkhoz. ADAT SEGMENTBSZAM DW 0 ;MEMÓRIASZÓ ADAT ENDSKOD SEGMENT

ASSUME DS:ADAT, CS:KODSTART:MOV AX,ADAT

MOV DS,AXMOV CX,16XOR BX,BXMOV AH,1XOR DX,DX

BE: INT 21H ;AL-BEN OTT VAN A BEOLVASOTT ADATMOV DL,ALCMP DL,0DH

JZ KIBECMP DL,30JL BE ; <, HIBÁS ADAT CMP DL,31HJG BE ; >, HIBÁS ADAT AND DL,0FH ;ZÓNARÉSZ LEVÁGÁSA SHL BX,1 ;LÉPTETÉS BALRA, 2-VEL VALÓ SZORZÁS OR BX,DX ;BITENKÉNTI VAGY MŰVELET LOOP BE

KIBE: MOV AH,4CHINT 21H

KOD ENDSEND START



53

2.5. Konverziók A következőkben nézzük meg, hogy hogyan tudjuk a konverziókat végrehajtani. Alapvetőenmi a 10-es (decimális) számrendszerben dolgozunk, de a gépben az adatok 2-es (bináris)számrendszerben vannak tárolva.

Beolvasás esetén a számjegyeket a billentyűzetről karakterenként ASCII kódban tudjuk beolvasni. Pl. a 12345 beolvasásakor a billentyűzetről egy karaktersorozatot (31H, 32H, 33H,34H, 35H) kapunk. Ebből a karaktersorozatból kell előállítanunk egy 16 bites számot, amely a

decimális 12345karaktersorozatnak megfelelő bináris érték.Kiírás esetén a számjegyeket a képernyőre karakterenként ASCII kódban kell kiküldenünk.Most fordított a helyzet, mint beolvasáskor. Az egy szón binárisan tárolt adatbólkaraktersorozatot (különálló számjegyeket kell készítenünk) a kiíráshoz. Ezeket a műveleteketvalósítják meg a konverziók.

2.5.1. Készítsen algoritmust, amely egy decimális számot (pl: 1234) (4 bájton van tárolvakarakterenként a memóriában) átalakít egy 16 bites bináris adattá. Egy programban 4 jegyű ASCII kódú decimális számot sztringként tudunk definiálni (DBdirektívával). Ilyen definíció esetén a számjegyek a memória egy adott címétől kezdődőenegymást követő memóriarekeszekben helyezkednek el. (Ugyanez a helyzet, ha a számot inputeredményeként tároljuk). A 65535 decimális értéknél kisebb bináris értékek biztosan elférnekegy szóban, hiszen a 65535-nek megfelelő bináris érték: 1111 1111 1111 1111 (azaz 16

bites). Ezért az eredmény számára egy szó hosszúságú helyet kell biztosítanunk. Egy konkrétesetben pl., ha a decimális szám 1234, akkor a memóriában való elhelyezéskor amemóriarekeszek tartalma: 31H, 32H, 33H, 34H. Ennek megfelelő bináris érték egy szóban:

04D2H.

Mindenekelőtt minden ASCII kódú számjegy zóna részét (a 3-as értéket) minden bájtbóltörölni kell, azaz el kell érni, hogy minden bájton az adott számjegy bináris értéke legyen.Ezután, vegyük figyelembe, hogy az egyes számjegyeknek milyen a helyértéke és ahelyértékétől függően 10 megfelelő hatványával szorozni kell. Azért, hogy ne kelljen tárolni10 különböző hatványainak értékeit, a műveletet az ún. Horner elrendezés szerint végezzük el,azaz az első számot szorozzuk 10-zel, a szorzathoz hozzáadjuk a következő számot, majd eztaz összeget is szorozzuk 10-zel, majd ehhez a szorzathoz hozzáadjuk a következő számjegyetés így tovább haladunk addig, amíg az utolsó számot hozzá nem adtuk az előzőleg kiszámított

szorzathoz.Pl., ha a szám abcd, ahol a,b,c,d, decimális számjegyek, akkora bináris szám= (((a*10 + b ) * 10 ) +c )*10 + d

4 jegyű szám esetén 3-szor kell 10-zel szorozni és 3-szor kell összeadást is végezni, de 4

elemet kell elérni. Azért, hogy mindegyik elemmel hasonló műveletet kelljen elvégezni, azelső elemet is hozzáadjuk egy szorzathoz, mégpedig egy 0 értékhez. Algoritmusunk a

következő lesz: a bináris szám= (( (0 *10+ a )* 10 + b ) * 10 +c )*10 + d



54


ADAT SEGMENTDSZAM DB '1234' ;4 JEGYŰ ASCII KÓDÚ DECIMÁLIS SZÁM BSZAM DW ? ;AZ EREDMÉNY SZÁMÁRA FENNTARTOTT HELYTIZ DW 10ADAT ENDSKOD SEGMENT


MOV DS,AXMOV AX,0 ;EZT SZOROZZUK ELŐSZÖR 10-ZELMOV SI,0 ;INDEX A SORON KÖVETKEZŐ SZÁMJEGYHEZ MOV CX,4 ;CIKLUSSZÁMLÁLÓ BEÁLLÍTÁSA MOV BH,0 ;A SORON KÖVETKEZŐ SZÁMJEGYET BL-BE TÖLTJÜK,

;DE SZÓKÉNT ADJUK A SZORZATHOZ, AMELY A DX,AX-BEN;KELETKEZIK

CIKL: MUL TIZ ;SZAVAS SZORZÁST HAJTUNK VÉGRE, MERT BÁJTOS ESETBEN A;SZORZAT IS CSAK EGY BÁJTOS LEHETNE

MOV BL,DSZAM[SI]AND BL,0FH ;ZÓNARÉSZ TÖRLÉSE

ADD AX,BXINC SILOOP CIKLMOV BSZAM,AX ;AZ EREDMÉNYT KIÍRJUK A MEMÓRIÁBA ISMOV AH,4CHINT 21H

KOD ENDSEND START

2.5.2. Készítsen algoritmust, amely egy bináris számot (pl: 3039H) számjegyekre bont,előkészít a kiírásra.

Egy szó hosszúságú bináris szám ASCII kódú decimális számmá alakításánál először elő kellállítani a decimális szám számjegyeit egy-egy bájton, majd mindegyik számjegyet ASCIIkódúvá kell alakítani. 1 szó hosszúságú bináris szám legfeljebb 5 jegyű decimális számnakfelel meg. Ezért az eredmény számára egy 5 bájtos puffert tartunk fenn (1 számjegy 1 bájtrakerül). Az átalakítást a konverzióknál tanultaknak megfelelően 10-zel való osztogatássalvégezzük. Az osztás maradéka adja a decimális szám egy számjegyét, a hányadost pedig

tovább kell osztani 10-zel. Elsőként az utolsó számjegyet kapjuk, majd az utolsó előttit és ígytovább, majd amikor a hányados 0 lesz, akkor megkapjuk a legelső számjegyet. Amaradékokat rendre tároljuk, természetesen fordított sorrendben. Az osztást addig végezzük,

ameddig a hányados 0 nem lesz. Ha mindig 5-ször hajtjuk végre, ilyenkor kisebb szám eseténelképzelhető, hogy a maradékok 0 értékűek lesznek (azaz vezető 0 -k, értéktelen számjegyekkerülnek tárolásra). ADAT SEGMENTDSZAM DB 5 DUP (?) ;5 JEGYŰ ASCII KÓDÚ DECIMÁLIS

;SZÁM RÉSZÉRE FENNTARTOTT HELYBSZAM DW 2AB7H ;A BINÁRIS SZÁM AMELYEK KONVERTÁLUNK TIZ DW 10ADAT ENDS



55



START: MOV AX,ADATMOV DS,AXMOV AX,BSZAM ;EZT KELL KONVERTÁLNI MOV SI,4 ;INDEX AZ UTOLSÓ MEMÓRIAREKESZHEZ

MOV CX,5 ;CIKLUSSZÁMLÁLÓ BEÁLLÍTÁSA CIKL: MOV DX,0 ;SZAVAS OSZTÁSHOZ DIV TIZ ;SZAVAS OSZTÁST HAJTUNK VÉGRE, MERT BÁJTOS

;OSZTÁSNÁL A HÁNYADOS IS BÁJTON KELETKEZIKOR DL,30H ;ZÓNARÉSZ HOZZÁADÁSA MOV DSZAM[SI],DLDEC SI ;DECREMENTÁLJUK AZ INDEXET LOOP CIKLMOV AH,4CHINT 21H

KOD ENDSEND START

2.5.3. Készítsen algoritmust, amely egy hexadecimális számot (pl: 7A5EH) (4 bájton vantárolva karakterenként a memóriában) átalakít egy 16 bites bináris adattá. Ezt a feladatot az 14. feladatnál leírtakhoz hasonlóan meg lehet oldani, csak értelemszerűen ittaz átalakítandó szám maximálisan 4 jegyű lehet és nem csak decimális (0 -9), hanem

hexadecimális (A-F) értékek is szerepelhetnek a számjegyek között, valamint az egyesszámjegyeket nem 10-zel, hanem 16-tal kell szorozni.

Ugyanezt a feladatot azonban más módon is meg lehet oldani a léptetési utasításokfelhasználásával. Ennél a megoldásnál azt használjuk ki, hogy egy szavas érték 16-tal való

szorzása egyenértékű a szónak 4 bittel való balra léptetésével, valamint azt, hogy mindenegyes hexadecimális számjegy 4 biten tárolódik. ADAT SEGMENTHSZAM DB '7A5E' ;A HEXADECIMÁLIS SZÁMBSZAM DW ? ;A KONVERTÁLT BINÁRIS ÉRTÉKADAT ENDSKOD SEGMENT


MOV DS,AXMOV CX,4 ;4.SZER FUT LE A CIKLUSMOV SI,0 ;INDEXMOV AX,0 ;AZ AX-BEN FOG AZ EREDMÉNY KÉPZŐDNI

CIKL: PUSH CX ;CX TARTALMÁNAK ELMENTÉSEMOV BL,HSZAM[SI] ;AZ AKTUÁLIS SZÁMJEGYSUB BL,30HCMP BL,9 ;DECIMÁLIS SZÁMJEGY, VAGY BETŰ (A-F)JLE DECIM ;DECIMÁLIS SZÁMJEGYSUB BL,7

DECIM: MOV CL,4SHL AX,CL ;AX-ET 4 BITTEL BALRA LÉPTETJÜKOR AX,BX ;BX TARTALMÁT RÁMÁSOLJUK AX-REPOP CXINC SILOOP CIKLMOV BSZAM,AX ;AZ EREDMÉNY ELTÁROLÁSA



56



MOV AH,4CHINT 21H

KOD ENDSEND START

2.5.4. Készítsen algoritmust, amely egy bináris számot (pl: 7A5EH) hexadecimálisszámjegyekre bontva előkészít a kiírásra. Ezt a feladatot a 15. feladatnál leírtakhoz hasonlóan meg lehet oldani, csak értelemszerűen ittaz átalakított szám 4 jegyű lehet és nem csak decimális (0 -9), hanem hexadecimális (A-F)

értékek is szerepelhetnek a számjegyek között, valamint az egyes számjegyeket nem 10 -zel,

hanem 16-tal kell osztani.

Ugyanezt a feladatot más módon is meg lehet oldani a léptetési utasítások felhasználásával.Ennél a megoldásnál azt használjuk ki, hogy egy szavas érték 16-tal való osztása egyenértékűa szónak 4 bittel való jobbra léptetésével, valamint azt, hogy minden egyes hexadecimális

számjegy 4 biten tárolódik. Az algoritmus lényege az, hogy a szavas érték 4 tetrádját egy-egy

bájtos memóriarekeszben helyezzük el, mégpedig az egyes értékeknek megfelelő ASCIIkódban. A tetrádok elhelyezését a legfelső tetráddal kezdjük, ezért először balra léptetünkrotációval (a balra kilépő bitek jobbra belépnek), majd folytatjuk a műveletet 4-szer.ADAT SEGMENTHSZAM DB 4 DUP(?) ;A HEXADECIMÁLIS SZÁM SZÁMJEGYEIBSZAM DW 7A5EH ;A KONVERTÁLANDÓ HEXA SZÁM(BINÁRIS ÉRTÉK)ADAT ENDSKOD SEGMENT


MOV DS,AXMOV CX,4 ;4.SZER FUT LE A CIKLUSMOV SI,0 ;INDEXMOV AX,BSZAM ;A KONVERTÁLANDÓ BINÁRIS SZÁM

CIKL: PUSH CX ;CX ELMENTÉSEMOV CL,4ROL AX,CL ;AZ AX ÉRTÉKÉT ROTÁLJUK 4 BITTEL

;BALRA. A FELSŐ 4;BIT AZ ALSÓ 4 BIT HELYÉRE KERÜL

MOV BL,AL ;A BL ALSÓ TETRÁDJÁN LESZ A SZÁMJEGYAND BL,0FH ;A FELSŐ TETRÁD TÖRLÉSECMP BL,9 ;DECIMÁLIS SZÁMJEGYRŐL VAN SZÓ?JLE DECIM ;IGEN

ADD BL,7 ;BETÜ (A-Z)DECIM: ADD BL,30H ;ZONARÉSZ RÁHELYEZÉSEMOV HSZAM[SI],BL ;A SZÁMJEGY ELMENTÉSEINC SIPOP CXLOOP CIKLMOV AH,4CHINT 21H

KOD ENDSEND START



57

2.6. Sztringműveletek 11

2.6.1. Készítsen olyan programot, amely a saját nevével inicializált memóriaterülettartalmát átpakolja egy másik memóriaterületre!

A példát megoldjuk először úgy, hogy bájtonként pakoljuk át a sztringet, majd úgy, hogyismétlő művelettel egy lépésben átpakoljuk a sztring bájtjait. A LODS, STOS, MOVS

műveleteket fogjuk használni. A LODS utasítás az SI-vel megcímzett forrássztringből 1 bájtotvagy szót tölt be az AL vagy AX regiszterbe. A STOS utasítás az AL vagy AX regiszterből 1

bájtot vagy szót tölt ki a DI-vel megcímzett memóriaterületre. A MOVS utasítás sztringmozgatását végzi egyik memóriahelyről a másikba. Az utasítás kiadása előtt a forrássztring

DS-beli offszet címét az SI-be, a célsztring ES-beli offszet címét a DI-be indexregiszterbe kell

betölteni. A DF (direction) flag tartalmától függően SI és DI automatikusan inkrementálódik(ha DF=0), vagy dekrementálódik (ha DF=1). A példában ciklikusan kell mozgatni a sztring

bájtjait. Ezt megtehetjük a REP prefix utasítások segítségével is. A REP utasítás az egyszerűsztring utasításokat annyiszor hajtják végre, amíg a CX regiszter értéke 0 nem lesz. A REP

Prefix utasítás, hatása csak a következő utasításra terjed ki.ADAT SEGMENTNF DB 'Gipsz Jakab';FORRÁS SZTRINGNC1 DB 11 DUP(?) ; CÉL SZTRINGNC2 DB 11 DUP(?)NC3 DB 11 DUP(?)NC4 DB 11 DUP(?)ADAT ENDSKOD SEGMENT

ASSUME DS:ADAT, ES:ADAT, CS:KODSTART: MOV AX,ADAT

MOV DS,AXMOV ES,AX

;atpakolas bajtonkentCLD ;DF=0, SI INKREMENTÁLÓDIKMOV CX,11MOV SI,OFFSET NFMOV DI,OFFSET NC1

CIKL1: LODS NF ;EGY BÁJT -> (AL)STOS NC1 ;(AL) -> EGY BÁJT LOOP CIKL1STD ;DF=1, SI DEKREMENTÁLÓDIKMOV CX,11MOV SI,OFFSET NF

ADD SI,CX ;A SZTRING VÉGÉRE ÁLLÍTJUK AZ SI-TDEC SIMOV DI,OFFSET NC2ADD DI,CX ; A SZTRING VÉGÉRE ÁLLÍTJUK AZ DI-TDEC DI

CIKL2: LODS NF ;EGY BÁJT -> (AL)STOS NC1 ;(AL) -> EGY BÁJT LOOP CIKL2

;atpakolas ismetelt stringmuveletekkelCLD ;DF=0, SI ÉS DI INKREMENTÁLÓDIK MOV SI,OFFSET NF ;FORRÁS SZTRING ELTOLÁSI CÍME MOV DI,OFFSET NC3 ;CÉL SZTRING ELTOLÁSI CÍME

11 AsmKodTabla 14. oldal



58


MOV CX,11REP MOVS NC3,NF

STD ;DF=1, SI ÉS DI DEKREMENTÁLÓDIKMOV CX,11MOV SI,OFFSET NFADD SI,CX ; A SZTRING VÉGÉRE ÁLLÍTJUK AZ SI-T

DEC SIMOV DI,OFFSET NC4ADD DI,CX ; A SZTRING VÉGÉRE ÁLLÍTJUK AZ DI-TDEC DI

REP MOVS NC4,NFMOV AH,4CHINT 21H

KOD ENDSEND START

2.7. Procedúrák, makrók használata

A programozás során gyakran előfordul, hogy azonos, vagy hasonló feladatokat kellmegoldanunk többször. Ilyenkor érdemes ezt a programrészt kiemelni, és a programon belülcsak hivatkozni rájuk. Az Intel assembly nyelvben két lehetőség áll rendelkezésünkre; a

procedúra és a makro. A procedúra definícióját a kódszegmensben kell elhelyezni a program

logikai vége (a vezérlés visszaadása az operációs rendszernek) után. A procedúra meghívása aCALL utasítással történik, ekkor a vezérlés átadódik a procedúrának. A procedúra lefutásaután a RET utasítás adja vissza a vezérlést a hívó programnak. Amikor egy procedúrát hívunk(CALL procedúra_név), mielőtt a vezérlés átkerülne rá, a következő utasítás címe eltárolódika STACK- ben. Ezzel válik lehetővé, hogy a procedúra végén RET hatására a vezérlés

visszatérjen a hívást követő utasításra. A RET a stack tetején lévő érték alapján tér vissza ahívási helyre. A paraméterátadás vagy regisztereken, vagy a STACK memórián keresztültörténik. A makro definíciót a makro meghívása elé kell elhelyezni. A makro meghívása anevével és az aktuális paraméterlistával történik. A makro hívás során az assembler az elsőmenetben a makro kódját bemásolja a makro definíciós táblázatba. A második menetben azassembler a formális paraméterek helyébe behelyettesíti az aktuális paramétereket, és a makrokódját bemásolja a programkódba. Ha többször hívjuk meg a makrót, akkor annyiszormásolódik be a makro kódja, amennyiszer meghívjuk a makrót.

2.7.1. Procedúrák

2.7.1.1. Készítsen olyan programot, amely beolvas Enter karakterig (de maximum 5számjegyig) két decimális számot. A két számot összeadja, majd az eredményt megjeleníti aképernyőn. A beolvasást és a kiírást procedúrával oldja meg!

A megoldás során a „beolvas” procedúra fogja tartalmazni a „decimális- bináris” konverziót, a„kiir” procedúra pedig tartalmazni fogja a „bináris-decimális” konverziót. A paraméterátadásta verem (stack) memórián keresztül oldjuk meg.



59

A beolvasást végző procedúra:

Bemenet:

A stackben annak a memória területnek a címe, ahova a beolvasott számot binárisan el fogjukhelyezni. A memóriacímet (offszetcím) egy LEA utasítás segítségével töltjük be a BX

regiszterbe és a PUSH BX utasítással tesszük be a stack memóriába. Kimenet:

A memóriában a BX regiszter segítségével közvetlenül elhelyezzük a beolvasott számot 16 biten binárisan. A beolvasó procedúra végzi el a „decimális- bináris” konverziót.

A kiírást végző procedúra. Bemenet:

A stackben a kiírandó szám bináris formában. A stackben a memóriacím, ahova a kiírandó szám karaktereit el kell helyezni.

Kimenet:A képernyőn megjelennek a szám karakterei. A kiíráshoz szükséges bináris-decimális konverziót a kiíró procedúra végzi. A kiírásnálfelhasználjuk az INT 21H rutint, amelyet ha az AH=9 funkció kóddal hívunk meg, akkor aDX- ben megadott kezdőcímű sztringet jeleníti meg a képernyőn.Ehhez a kiírandó karaktereknek fenntartott memória helyet kezdetben szóközökkel töltjük fel,majd ebbe írjuk be a számjegy karaktereit. Ügyelnünk kell arra, hogy a kiírandó számjegyekmögé a memóriában egy ’$’ karakter is kerüljön. A „beolv” és a „kiir” procedúrán belül a „SZAM1 és SZAM2” illetve az „EREDM” változóraa memóriabeli offszet címén keresztül hivatkozunk. A procedúra meghívása előtt a veremmemóriában elhelyezzük az adott változó offszet címét, a procedúrán belül pedig a BX bázisregiszter segítségével (amibe betöltjük az adott változó offszet címét) hivatkozunk a változóra(pl. MOV [BX], AX).ADAT SEGMENTSZAM1 DW ? ;AZ ELSŐ SZÁM BINÁRIS ALAKBANSZAM2 DW ? ;A MÁSODIK SZÁM BINÁRIS ALAKBANEREDM DW ? ;AZ EREDMÉNY BINÁRIS ALAKBANSZJE DB 5 DUP(20H),'$' ;AZ EREDMÉNY KIÍRÁSÁHOZ SZÓKÖZÖK+$TIZ DW 10SZOV1 DB 0AH,0DH,'ADAT= $'SZOV2 DB 0AH,0DH,'EREDMENY= $'

ADAT ENDSKOD SEGMENTASSUME DS:ADAT, CS:KOD

START: MOV AX,ADATMOV DS,AXLEA BX,SZAM1PUSH BXCALL BEOLV ;AZ ELSŐ SZÁM BEOLVASÁSALEA BX,SZAM2PUSH BXCALL BEOLV ;A MÁSODIK SZÁM BEOLVASÁSAMOV AX,SZAM1ADD AX,SZAM2 ;MŰVELETVÉGZÉS

MOV EREDM,AXMOV AX,EREDM ;A KIÍRANDÓ ÉRTÉK BINÁRISAN



60

LEA BX,SZJE ;AZ EREDMÉNY SZÁMJEGYEINEK MEMÓRIABELI KEZDŐCÍMEPUSH AXPUSH BXCALL KIIR ;AZ EREDMÉNY KONVERTÁLÁSA KIÍRÁSHOZ ÉS KIÍRÁSMOV AH,4CHINT 21H ;PROGRAM VÉGE

;BEOLVAS PROCEDURA;BEMENET: STACKBEN A MEMÓRIA CÍM, AHOVÁ A BEOLVASOTT SZÁM BINÁRIS KÓDJÁT;EL KELL HELYEZNI;KIMENET: A MEMÓRIÁBAN TÁROLÁSRA KERÜL A BEOLVASOTT SZÁM BINÁRIS KÓDJABEOLV PROC

LEA DX,SZOV1MOV AH,9INT 21H ;INPUT SZÖVEG KIÍRÁSAMOV BP,SPMOV CX,5 ;MAX 5 JEGYŰ LEHET A SZÁMMOV AX,0 ;AZ AX-BEN FOG KÉPZŐDNI A BINÁRIS ÉRTÉK

BE: PUSH AX ;AZ AX ELMENTÉSE A STACKBE EGYÉBKÉNT ELVESZNE;A TARTALMA KARAKTER BEOLVASASKOR

MOV AH,1 ;EGY KARAKTER OLVASÁSA A BILLENTYŰZETRŐL.INT 21H ;A KAR. AL-BE KERÜLXCHG AX,BX ;AX ELMENTÉSE A DX REGISZTERBE.

;A BEOLVASOTT KARAKTERÜNK A DL-BEN VANPOP AX ;AX-VISSZAVÉTELE A STACKBŐL

;ITT KEPZŐDIK A KONVERTÁLT ÉRTÉKÜNKCMP BL,0DH ;ENTER KARAKTERT OLVASTUNK?JE BEVEG ;IGEN, BEOLVASÁS VÉGEAND BL,0FH ;ZÓNARÉSZ LEVÁGÁSAMOV BH,0MUL TIZ ;AX*10ADD AX,BXLOOP BE

BEVEG: MOV BX,[BP+2] ;A STACKBŐL A BX-BE T

ÖLTJ

ÜK;A BEOLVASANDÓ SZÁM MEMÓRIACÍMÉT

MOV [BX],AX ;A KONVERTÁLT ÉRTÉK ELMENTÉSE A MEMÓRIÁBANRET

BEOLV ENDP;KIIR PROCEDURA;BEMENET: STACKBEN A KIÍRANDÓ SZÁM BINÁRIS FORMÁBAN STACKBEN A MEMÓRIACÍM,;AHOVÁ A KONVERTÁLT KARAKTEREKET EL KELL HELYEZNI;KIMENET: A MEMÓRIÁBAN MEGJELENNEK A SZÁMJEGYEK A KEPERNYŐN;MEGJELENNEK A SZÁMJEGYEKKIIR PROC;KONVERZIÓ

MOV BP,SPMOV BX,[BP+2] ;SZÁMJEGYEK ELHELYEZÉSÉRE SZOLGÁLÓ

;MEMÓRIATERÜLET KEZDŐCIMEMOV AX,[BP+4] ;KONVERTÁLANDÓ ÉRTÉKMOV CX,5 ;MAX 5 JEGYŰ LESZ A SZÁMMOV SI,4 ;INDEX

KONV: MOV DX,0DIV TIZ ;AX/10 HÁNYADOS AZ AX-BEN, MARADÉK A DX-BENOR DL,30H ;ZÓNARÉSZMOV [BX][SI],DL ;A SZÁMJEGY ELMENTÉSECMP AX,0 ;AX=0?JE VEGE ;HA IGEN, AKKOR VÉGE A KONVERZIÓNAKDEC SILOOP KONV



61

67. ábra. A 2.7.1.1. feladat programlistája

VEGE: LEA DX,SZOV2MOV AH,9INT 21H ;OUTPUT SZÖVEG KIÍRÁSAMOV DX,BX ;A KIÍRANDÓ MEMÓRIA TERÜLET KEZDŐCÍMEMOV AH,9INT 21H ;AZ EREDMÉNY KIÍRÁSA SZTRINGKÉNT

RETKIIR ENDPKOD ENDS

END START

2.7.1.2. Készítsen olyan pro cedúrát , amely egy kezdőcímével és hosszával adott karakteralakú decimális számot pakolt decimálissá (BCD) alakít, majd elhelyez egy ugyancsak akezdőcímével adott memória területre! A főprogram végezze el az ellenőrzött bevitelt aklaviatúráról, majd az átalakítást a procedúra meghívásával végeztesse el! A számjegyekszáma lehet páros és páratlan is, max. 12 jegy! A megoldás során a billentyűzetről olvasunk be karaktereket (’0’-’9’) ellenőrzéssel. Egy-egy

számjegy karakter egy-egy bájton kerül tárolásra. A feladat az, hogy a számjegyeket BCDformátumúra alakítsuk. Pl. 31H és 32H- ból, ami két bájton van tárolva, 12H lesz, ami 1 bájtonvan tárolva. A megoldás: betöltjük egy regiszterbe a 31H-t, 01H-t készítünk belőle (zónarészlevágása), elléptetjük balra 4 bittel (10H), betöltjük egy regiszterbe a 32H-t, zónarésztlevágjuk (02H). A két bájtos regiszter tartalmát összemásoljuk OR művelet segítségével, ígymegkapjuk a 12H értéket egy bájton. ADAT SEGMENTSZAM DB 12 DUP(0)SZSZ DW 0ADAT ENDSADCEL SEGMENTPSZAM DB 6 DUP(0)PSZSZ DW 0ADCEL ENDSKOD SEGMENT

ASSUME DS:ADAT, ES:ADCEL, CS:KODSTART: MOV AX,ADAT

MOV DS,AXMOV AX,ADCELMOV ES,AXMOV CX,12MOV SI,0

MOV AH,1BE: INT 21h

CMP AL,0DHJZ KIBECMP AL,30hJL BECMP AL,39hJG BEMOV SZAM[SI],ALINC SILOOP BE

KIBE: MOV SZSZ,SI ;A BEOLVASOTT SZÁMJEGYEK SZÁMA LEA BX,SZAM

PUSH BX



62


MOV CX,SZSZPUSH CXLEA BX,PSZAMPUSH BXCALL PAKOLMOV AH,4CH

INT 21hPAKOL PROC

MOV BP,SPMOV BX,[BP+6]MOV CX,[BP+4]TEST CX,0001h ;PÁRATLAN? HA IGEN, AKKOR PÁROSAT KÉSZÍTÜNK BELŐLE JZ UGADD CX,1

UG: SHR CX,1 ;CX TARTALMÁT OSZTJUK 2-VEL, A BCD BÁJTOK SZÁMA ;FELE AZ EREDETINEK

MOV SI,0MOV DI,0

CIKL: XOR AX,AX

MOV AH,[BX][SI] ;BETÖLTJÜK AZ ELSŐ BÁJTOT AND AH,0FH ;ZÓNARÉSZT LEVÉGJUK PUSH CXMOV CL,4SHL AH,CL ;ELLÉPTETJÜK 4 BITTEL POP CXINC SICMP SI,[BP+4]JZ TOV ;AH ELÉRTÜK A VÉGÉT, VAGYIS PÁRATLAN AZ

;ELEMSZÁM, AKKOR UGRUNKMOV AL,[BX][SI] ;BETÖLTJÜK A MÁSODIK BÁJTOT AND AL,0FH ;ZÓNARÉSZT LEVÁGJUK

TOV: OR AL,AH ;ÖSSZEMÁSOLJUK A KÉT TETRÁDOT

MOV ES:[BX][DI],AL ;KIMOZGATJUK A MEMÓRIÁBA

INC SIINC DILOOP CIKLRET

PAKOL ENDPKOD ENDS

END START

2.7.2. Makrók

2.7.2.1.

Készítsen programot, amely összeadja egy adott elemszámú tömb elemeit! Azösszegzést makróval végezzük!ADAT SEGMENTT1 DB 21,32,54T2 DB 34,-54,21,5,-3E1 DW ?E2 DW ?ADAT ENDS



63



START: MOV AX,ADATMOV DS,AX

;MAKRO DEFINIALASAOSSZ MACRO T,ESZ,EM

LOCAL CIKLMOV CX,ESZ ;A TÖMB ELEMEINEK A SZÁMA MOV AX,0 ;AZ EREDMÉNY AZ AX-BEN FOG KÉPZŐDNI MOV SI,0

CIKL: MOV BH,0MOV BL,T[SI]ADD AX,BXINC SILOOP CIKLMOV EM,AXENDM

;MAKRO HIVASAOSSZ T1,3,E1 ;AZ ELSŐ TÖMB ELEMEINEK ÖSSZEADÁSA

OSSZ T2,5,E2 ;A MÁSODIK TÖMB ELEMEINEK ÖSSZEADÁSA MOV AH,4CHINT 21H

KOD ENDSEND START

2.8. Gépi kódos példák Ebben a részben assembly utasítások gépi kódra való visszafejtésére oldunk meg példákat .

Egy gépi kódú utasítás hossza minimum 1 bájt, maximum 6 bájt.

Egy gépi kódú utasítás két részből áll: 1. Milyen műveletet kell a mikroprocesszornak végrehajtania. (1 bájt Műveleti kód) 2.

Hol találhatók azok az adatok, amelyekkel az adott műveletet végre kell hajtani. (2-6.

bájt)

Egy gépi kódú utasítás a következő mezőkből áll:

Az egyes mezők jelentése a következő: 1.

bájt: Operációs, műveleti kód. Leírja a mikroprocesszor számára a végrehajtandóműveletet. 2. bájt: Címzési mód: Milyen módon érhetők el a műveletben szereplő adatok. Az I8086-os

mikroprocesszor 1 címes processzor, ami azt jelenti, hogy csak az egyik operandus lehetmemóriaváltozó. 3. bájt: A műveletben szereplő memória operandus eltolási címének (DISP) alacsonyab b

helyi értékű bájtja vagy közvetlen adat (DATA) alacsonyabb helyi értékű bájtja.



64

A DISP azt adja meg, hogy az adott memória operandus (szimbólum, változó) az adottszegmens elejéhez képest (amelyben a memóriaváltozót definiáltuk) hány bájttal van eltolva.

4. bájt: A műveletben szereplő memória operandus eltolási címének (DISP) magasabb helyiértékű bájtja vagy közvetlen adat (DATA) magasabb helyi értékű bájtja.

5.

A műveletben szereplő közvetlen adat (DATA) alacsonyabb helyi értékű bájtja. 6. A műveletben szereplő közvetlen adat (DATA) magasabb helyi értékű bájtja.

Nézzünk meg néhány példát! Adott a következő adatszegmens! ADAT SEGMENTA1 DW 23H,233H,5566H,4567H

DW 1122H,3344H,5566H,7788HA2 DB 19,11,22,37,44

DB 56,66,77,88,100ADAT ENDS

Ábrázoljuk a „memóriában” az adat szegmenst! Az A1 szimbólummal kezdődő adatok szavas, az A2 szimbólummal kezdődő adatok bájtosadatok. A memóriában a magasabb és az alacsonyabb helyi értékű bájt mindig fordítottsorrendben ábrázolódik. DISP 0 1 2 3 4 5 6 7 8 9

A1 23 00 33 02 66 55 67 45 22 11

DISP A B C D E F

A1 44 33 66 55 88 77

DISP 10 11 12 13 14 15 16 17 18 19

A2 13 0B 16 25 2C 38 42 4D 58 64

A táblázat 2., 4. és 6. sorában az adatokat láthatjuk, az 1. , 3. és az 5. sorban pedig az adott

adat eltolási címét (DISP) a szegmens elejéhez képest. Vagyis az A1-es szimbólum esetén DISP=0; az A2 szimbólum esetében, pedig DISP=10H.

Egy utasítás általános alakja: MNEMONIK cél-operandus, forrás-operandus

2.8.1. Határozzuk meg a MOV AX, A1 utasítás gépi kódját 12 !Első lépésként megkeressük a kódtáblázatunkban az aktuális utasítás csoportot, jelen esetbena MOV adatmozgató utasítást. Mint látható nem egy utasításkód szerepel, hanem több.

Ezekről azt kell tudni, hogy az első utasításkód formula általánosan használható, a többi esetvalamilyen speciális esetet ír le. Egy konkrét feladatnál meg kell néznünk, hogy valamelyspeciális eset ráhúzható-e a feladatra. Ha nem, akkor az általános formulát használjuk.

A MOV esetében: MOV mem/reg1,

mem/reg2: Általános formula, minden esetben használható, de ez adjaa leghosszabb kódot.

MOV mem, data: Egy memória operandusba közvetlen adatot mozgatunk.

12 AsmKódtábla 3. oldal



65

MOV reg, data: Egy regiszter operandusba közvetlen adatot mozgatunk. MOV ac, mem: Az akkumulátor regiszterbe egy direkt címzéssel címzett memória

operandust mozgatunk. Itt fontos megjegyezni, hogy az ac kizárólag azAX vagy AL regiszter lehet!

MOV mem, ac: A 4-es pont fordított esete. MOV sr, mem/reg: Egy szegmens regiszterbe (DS, ES, CS, SS) adatot mozgatunk memóriaoperandusból vagy regiszter operandusból.

MOV mem/reg, sr: A 6-os pont fordított esete.

A MOV AX, A1 esetben, mivel ac=AX és az A1 szimbólum elérése direkt címzéssel történik(a címképzésben csak az A1 szimbólum DISP címe szerepel, nem szerepel bázis regiszter(BX, BP) illetve indexregiszter (SI, DI), ezért a 4-es formulát használhatjuk.

Második lépésként meghatározzuk az egyes mezők értékét. Utasítás OP KÓD MOD REG R/M DISP/

DATA

DISP/

DATA

DATA DATA

MOV AX,A1 1010000w DISP DISP

10100001 00000000 00000000

A kódban használatos biteket, illetve bit mezőket a kódtáblázatunk első oldalán találhatótáblázatok, jelmagyarázatok alapján határozzuk meg. A w=1, mivel szavas műveletről van szó. A 16 bites AX regiszterbe bemozgatjuk az A1-es

memóriaváltozóban található 16 bites értéket. Az A1-es memóriaváltozó DISP értéke 0, hiszen az A1-es változó eltolása az ADATszegmenshez képest 0.

2.8.2. Határozzuk meg a MOV AX, A1[SI] utasítás gépi kódját! Az előző példában alkalmazott 4-es formula nem használható, mivel nem DIREKT címzésselérjük el a memória operandust. A címképzésben az A1 szimbólum DISP értéke és az SIindexregiszter értéke vesz részt. A memória operandus címét a DISP + [SI] adja. Az első,általános formulát kell alkalmaznunk. Utasítás OP KÓD MOD REG R/M DISP/

DATADISP/DATA

DATA DATA

MOVAX,A1[SI]

100010dw mod reg r/m (DISP) (DISP)

10001011 10 000 100 00000000 00000000

A w=1, mivel szavas műveletről van szó. A d bit 1, ha a mod r/m bitcsoportok a forrásoperandust definiálják. Ha megnézzük a mod r/m jelentését a kódtáblázatunkban, láthatjuk,hogy a mod r/m bitcsoporttal (a mod=11 regiszter operandust kivéve) mindig a memória

operandus eléréséhez szükséges címszámítási módot írjuk le. Vagyis mondhatjuk azt, hogy haaz utasításban van memóriaoperandus, akkor a d bit a memória operandus utasításbanelfoglalt helyét (forrás vagy cél) írja le. Következésképpen, ha a forrás operandus a memóriaoperandus, akkor a d bit értéke 1, ha a memória operandus nem a forrás operandu s, akkor a d

bit 0. Jelen esetben a d=1, mivel a memória operandus a forrás operandus.

Az utasításban memória operandus szerepel, így a mod mező étéke azt mondja meg, hogy amemória operandus címszámításában résztvevő DISP eltolási cím hány bájtos.



66

Az általános formula leírásából látható (DISP, DISP), hogy 2 bájtos eltolási címmeldolgozunk, vagyis mod=10. Az r/m mező a címszámítás módját írja le. Mivel A1[SI] amemória operandusunk, ebből látszik, hogy a címszámítás DISP+[SI], vagyis r/m=100. A regmező azt írja le, hogy az utasításban melyik regiszter vesz részt. Jelen esetben az AX

regiszter, vagyis reg=000. A DISP mező pedig 0 (ezt két bájton kell leírni az általánosformula szerint), hiszen az A1-es szimbólum az ADAT szegmens kezdetéhez képest 0 bájttal

van eltolva.

2.8.3. Határozzuk meg a MOV BL, A2 utasítás gépi kódját! Utasítás OP KÓD MOD REG R/M DISP/

DATADISP/DATA

DATA DATA

MOV BL,A2 100010dw mod reg r/m (DISP) (DISP)10001010 00 011 110 00010000 00000000

Látjuk, hogy egyik speciális eset sem húzható rá erre az utasításra, marad az általánosformula. A 4-es formula azért nem jó, mert az ac csak az AX, AL lehet. A w=0, mivel bájtos

műveletről van szó. A d=1, hiszen a memória operandus a forrás operandus helyén található.Mivel direkt címzésről van szó (csak a DISP vesz részt a címszámításban) ez egy kivételeseset, ekkor a mod=00 és r/m=110. A reg=011, hiszen az utasításban a BL regiszter szerepel. ADISP=10H, mivel az A2-es szimbólum 16 bájttal (10H) van eltolva az ADAT szegmenskezdetéhez képest.

2.8.4. Határozzuk meg a MOV A1, AX utasítás gépi kódját! Utasítás OP KÓD MOD REG R/M DISP/

DATADISP/DATA

DATA DATA

MOV A1,AX 1010001w DISP DISP10100011 00000000 00000000

Erre az utasításra a MOV mem, ac 5-ös speciális formula húzható rá, mivel az A1 memóriaoperandust direkt címzéssel érjük el, és a regiszter operandus az AX elsődleges akkumulátorregiszter. A w=1, mivel szavas műveletről van szó, a DISP=0, mivel az A1-es szimbólumeltolása az adatszegmens kezdetéhez képest 0.

2.8.5. Határozzuk meg a MOV A1[SI], AX utasítás gépi kódját! Utasítás OP KÓD MOD REG R/M DISP/

DATADISP/DATA

DATA DATA

MOVA1[SI],AX

100010dw mod reg r/m (DISP) (DISP)

10001001 10 000 100 00000000 00000000

Ebben az esetben egyik speciális eset sem húzható rá a feladatra, vagyis marad az általánosformula. A w=1, mivel szavas műveletről van szó. A d=0, mivel a memória operandus most acél operandus. (lásd az 1-es feladatot).

Az utasításban szereplő A1[SI] cél operandus elérési módját írjuk most le a mod r/m bájtsegítségével. Az általános formula leírásában látható, hogy két bájtos DISP értékkeldolgozunk, tehát mod=10. Az A1[SI] leírásból látszik, hogy a memória operanduscímszámításában az A1 szimbólum DISP értéke és az SI index regiszter vesz részt (vagyisDISP + [SI]), ebből következik, hogy r/m=100. A reg=000, mivel az utasításban az AXregiszter szerepel, mint regiszter operandus.



67

A DISP mező pedig 0 (ezt két bájton kell leírni az általános formula szerint), hiszen az A1-es

szimbólum az ADAT szegmens kezdetéhez képest 0 bájttal van eltolva. Ha összehasonlítjuk a MOV A1[SI], AX és a MOV AX, A1[SI] utasítás gépi kódját, látható,hogy a két kód a d bit értékében különbözik egymástól.

2.8.6.

Határozzuk meg a MOV BL, 10 utasítás gépi kódját! Utasítás OP KÓD MOD REG R/M DISP/

DATADISP/DATA

DATA DATA

MOV BL,10 1011wreg data (data)10110011 00001010

Erre a feladatra a MOV reg, data 3-as speciális formula húzható rá. A w=0, hiszen bájtosműveletről van szó. A reg=011, mivel a műveletben a BL regiszter szerepel. A közvetlen adatamit be kell töltenünk, data=10.

2.8.7. Határozzuk meg a MOV AX, 5 utasítás gépi kódját! Utasítás OP KÓD MOD REG R/M DISP/

DATA

DISP/

DATA

DATA DATA

MOV AX,5 1011wreg data (data)

10111000 00000101 00000000

Erre a feladatra a MOV reg, data 3-as formula húzható rá. A w=1, mivel szavas műveletrőlvan szó, az AX regiszter 16 bites, 1 szavas. A reg=000, mivel az utasításban az AX regiszterszerepel. A közvetlen adat, amit be kell töltenünk 5, de mivel szavas műveletről van szó, ezért2 bájton kell leírnunk a közvetlen adatot, és az alacsonyabb és magasabb helyi értékű bájtotfel kell cserélnünk.

2.8.8. Határozzuk meg a MOV A2, 5 utasítás gépi kódját!

Utasítás OP KÓD MOD REG R/M DISP/DATA DISP/DATA DATA DATA

MOV A2,5 1100011w mod reg r/m (DISP) (DISP) (data) (data)

11000110 00 000 110 00010000 00000000 00000101

Erre a feladatra a MOV mem, data 2-es formula húzható rá. A w=0, mivel bájtos műveletrőlvan szó. A mod=00 és r/m=110, mivel a memória operandust direkt címzéssel érjük el. Acímképzésben csak az A2-es szimbólum szegmens kezdetéhez képesti eltolási címe szerepel.Jelen esetben DISP=10H, de ezt szavasan (két bájton) kell leírni, és az alacsonyabb ésmagasabb helyi értékű bájt helyet cserél. A data=5, mivel 5-öt kell betöltenünk az A2-es

memória változóba.

2.8.9.

Határozzuk meg a MOV A2[SI], 10 utasítás gépi kódját! Utasítás OP KÓD MOD REG R/M DISP/

DATADISP/DATA

DATA DATA

MOV

A2[SI],10

1100011w mod 000 r/m (DISP) (DISP) data (data)

11000110 10 000 100 00010000 00000000 00001010

Ebben az utasításban használhatjuk a 2-es (MOV mem, data) speciális esetet. A w=0, hiszen bájtos műveletről van szó (A2-es szimbólum DB direktívával van definiálva). A mod=10,hiszen a kód leírásból látható, hogy 2 bájtos eltolási címmel dolgozunk. A reg mező=000, az

r/m=100, hiszen a címszámításban az A2-es szimbólum DISP értéke mellett az SI vesz részt.



68

A DISP=10H, az A2-es szimbólum eltolása az adatszegmens kezdetéhez képest 16 bájt. A betöltendő adat 10.

2.8.10. Határozzuk meg a MOV AX, CX utasítás gépi kódját! Utasítás OP KÓD MOD REG R/M DISP/

DATADISP/DATA

DATA DATA

MOV AX,CX 100010dw mod reg r/m (DISP) (DISP)

10001011 11 000 001

Ha megfigyeljük a speciális formulákat egyik sem húzható rá a feladatra, így marad az 1 -es

általános formula. De különbözik az eddigi műveletektől, mivel mindkét operandus regiszter

operandus. Ekkor a d bit mindig 1.

A w=1, hiszen szavas műveletről van szó, a mod=11, mivel regiszter operandussal dolgozunk.A d=1, így az r/m bitcsoport a forrás operandust írja le, ez a CX regiszter, melynek kódja 001,vagyis r/m=001. A reg mező a másik regiszter operandust írja le, ez az AX regiszter, melyneka kódja 000, vagyis reg=000.

2.8.11.

Határozzuk meg a MOV CX, AX utasítás gépi kódját! Utasítás OP KÓD MOD REG R/M DISP/

DATADISP/DATA

DATA DATA

MOV CX,AX 100010dw mod reg r/m (DISP) (DISP)10001011 11 001 000

A d=1, mivel mindkét operandus regiszter. A w=1, hiszen szavas műveletről van szó, amod=11, mivel regiszter operandussal dolgozunk. A d=1, így az r/m bitcsoport a forrásoperandust írja le, ez az AX regiszter, melynek kódja 000, vagyis r/m=000. A reg mező amásik regiszter operandust írja le, ez a CX regiszter, melynek a kódja 001, vagyis reg=001.

2.8.12.

Határozzuk meg a LEA BX, A2 utasítás gépi kódját!13

Utasítás OP KÓD MOD REG R/M DISP/

DATADISP/DATA

DATA DATA

LEA BX,A2 10001101 mod Reg r/m (DISP) (DISP)00 011 110 00010000 00000000

Ezzel az utasítással a BX regiszterbe betöltjük az A2-es memória változó ofszet címét, vagyisa DISP értéket. A mod és az r/m mezők értéke 00, 110, mivel direkt címzésről van szó. A regmező az utasításban résztvevő regiszter kódja, reg=011.

2.8.13. Határozzuk meg az ADD BX, AX utasítás gépi kódját!14 Ezzel az utasítással a BX regiszter tartalmához hozzáadjuk az AX regiszter tartalmát. Az

eredmény a BX regiszterben képződik.

Mint a táblázatból látható, a három lehetséges eset közül az első (általános) kell használnunk. Utasítás OP KÓD MOD REG R/M DISP/

DATADISP/DATA

DATA DATA

ADD BX,AX 000000dw mod Reg r/m (DISP) (DISP)

00000011 11 011 000

Mivel mindkét operandus regiszter, ezért a d=1. A w=1, hiszen szavas műveletről van szó. Amod=11, mivel regiszter operandussal dolgozunk.

13

AsmKodTabla 3. oldal14 AsmKodTabla 4. oldal



69

Utasítás OP. Kód MUL BL 11110110 11100reg

11100011

Utasítás OP. Kód MUL CX 11110111 11100reg

11100001

Utasítás OP. Kód INC SI 01000reg

01000110

A d=1, így az r/m bitcsoport a forrás operandust írja le, ez az AX regiszter, melynek kódja000, vagyis r/m=000. A reg mező a másik regiszter operandust írja le, ez a BX regiszter,melynek a kódja 011, vagyis reg=011.

2.8.14. Határozzuk meg a MUL BL utasítás gépi kódját!15

Ennél az utasítás csoportnál az operandustípusa határozza meg, hogy melyik formulátkell alkalmaznunk. Bájtos szorzást végzünk,hiszen a BL regiszter bájtos, így a MUL reg (8 bit) formulát kell használnunk.

2.8.15. Határozzuk meg a MUL CX utasítás gépi kódját! Ennél a példánál szavas szorzást végzünk,hiszen a CX regiszter szavas, így a MUL reg(16 bit) formulát használjuk.

2.8.16. Határozzuk meg az INC SI utasítás gépi kódját!16 Mint a táblázatból látható, két eset közül kell

választanunk. A második eset egy speciális eset,amikor valamely regiszter tartalmát inkrementáljuk(növeljük) egyel. Ebben a példában ezt használhatjuk. A művelet op. kódjában a reg=110,hiszen a műveletben az SI indexregiszter vesz részt.

2.8.17. Határozzuk meg az INC A2 utasítás gépi kódját! Utasítás OP KÓD MOD REG R/M DISP/

DATADISP/DATA

DATA DATA

INC A2 1111111w mod 000 r/m (DISP) (DISP)11111110 00 000 110 00010000 00000000

A w=0, mivel az A2-es szimbólummal jelölt memória operandus bájtos. A mod=00 ésr/m=110, hiszen direkt címzésről van szó. A DISP=10H, az A2-es szimbólum eltolása azadatszegmens kezdetéhez képest.

2.8.18. K észítsük el egy egyszerű program (cikluson belüli néhány utasításának gépi kódúlistáját )!Legyen ez a program a maximum kiválasztás tétele! A programrészlet: ADAT SEGMENT

T DB 23, -10, 25, 31, 46, -21, -65, 125, 40, 67

MAX DB ? ;AZ AKTUALIS LEGNAGYOBB ELEM

ADAT ENDS

CIKL: MOV AL,T[SI] ;HASONLITJUK A TOMB AKTUALIS ELEMET AZ EDDIGI

CMP AL,MAX ;LEGNAGYOBB ELEMHEZ

JLE TOV ;HA <=, AKKOR NINCS TEENDONK, UGRUNK

MOV MAX,AL ;HA (AL)>MAX, AKKOR MEGJEGYEZZUK

TOV: INC SI

LOOP CIKL ;CX TARTALMA 1-EL CSOKKEN. UGRAS, HA CX NEM 0

15

AsmKodTabla 5. oldal16 AsmKodTabla 5. oldal



70

2.8.19. Határozzuk meg a CMP AL,MAX utasítás gépi kódját! Utasítás OP KÓD MOD REG R/M DISP/

DATADISP/DATA

DATA DATA

CMP AL,MAX

001110dw mod 000 r/m (DISP) (DISP)

00111010 00 000 110 00001010 00000000

Keressük meg a kód táblázatunkban a CMP (összehasonlító) utasítást. Itt három kódoktalálunk, az első az általános eset, a másik kettő speciális eset.

Jelen esetben az akkumulátor regiszter értékét hasonlítjuk egy memória változó értékéhez,vagyis az általános esetet kell alkalmaznunk. A w=0, mivel bájtos műveletről van szó. A modr/m bájt a memória operandust írja le. Mivel a memória operandus a forrás operandus, így ad=1. Mivel a MAX nevű memória operandust direkt címzéssel érjük el, így mod=00,r/m=110. A DISP=0AH, mivel a MAX változó eltolása az adat szegmens kezdetéhez képest10 bájt. A kódtáblabeli leírásból látható, hogy a DISP értékét két bájton kell leírni.

2.8.20.

Határozzuk meg a JLE TOV utasítás gépi kódját! Utasítás OP KÓD MOD REG R/M DISP/

DATADISP/DATA

DATA DATA

JLE TOV 01111110 disp

00000011

Keressük meg a kód táblázatunkban a vezérlésátadó utasításokat!

A JLE címke utasítás esetén azt látjuk, hogy az OP kód: 7E. A gépi kódban szerepel még adisp eltolási cím. A táblázatban használt jelöléseknél látható, hogy a disp relatív eltolást

jelent. Meg kell határoznunk, hogy az a címke, amelyre át kell adnunk a vezérlést (rá kell

ugranunk) hány bájtra található az éppen aktuális utasítástól. Ez lehet pozitív vagy negatívszám is attól függően, hogy a címke a vezérlés átadó utasítás előtt vagy mögött van. Ahhoz,hogy ezt ki tudjuk számolni meg kell határozni a vezérlésátadó utasítás és a címke közötttalálható utasítások bájtban kifejezett hosszát. Ha meghatározzuk a MOV MAX,AL utasításgépi kódját, akkor látható, hogy ez 3 bájtos utasítás, vagyis a TOV címke relatív eltolása azugró utasításhoz képest 3 bájt.

2.8.21. Határozzuk meg a LOOP CIKL utasítás gépi kódját! Utasítás OP KÓD MOD REG R/M DISP/

DATADISP/DATA

DATA DATA

LOOP CIKL 11100010 disp

11110010

A LOOP címke utasítás esetén azt látjuk, hogy az OP kód: E2. A gépi kódban szerepel még adisp eltolási cím, amely az előző példához hasonlóan egy relatív eltolási cím. Jelen esetben ezegy negatív szám lesz, mivel a LOOP előtt található a CIKL nevű címke. Meg kellhatároznunk, hogy hány bájt van a LOOP és a CIKL nevű címke között (magát a LOOPutasítás bájtokban kifejezett hosszát is bele kell számolni). Jelen esetben azt látjuk, hogy 16

bájt. Vagyis -16 bájttal távolabb levő utasításra kell adni a vezérlést. A negatív számokatkettes komplemens kódban ábrázoljuk, vagyis: 16d=00010000b, -16d=11110000b



71

2.9. Önállóan kidolgozandó feladatok ASM

2.9.1. Címzési módok, aritmetikai utasítások, ciklusok

1. Adja össze 2 memóriabájt értékét, majd képezze egy memóriaszó és egy memóriabájt

különbségét! a) A két memóriabájt értéke legyen FF, az eredmény képződjön bájton! Mit tapasztal?

CF=?

b) A két memóriabájt értéke legyen FF, az eredmény képződjön szón! Mit tapasztal?CF=?

2. Készítsen programot, amely összead két memóriában tárolt bájtos adatot, és az eredménytletárolja a memóriában!*

3. Készítsen programot, amely két memóriában tárolt bájtos adat szorzatát képzi, és azeredményt letárolja a memóriában!*

4. Készítsen programot, amely két memóriában tárolt bájtos adat hányadosát képzi, és az

eredményt (hányados és maradék) a memóriában tárolja!*

5. Készítsen programot, amely a memóriában letárolt 5 bájtos adat (tömb elemeinek)összegét képzi, és az eredményt letárolja szavasan a memóriában!*

6. Készítsen programot, amely megadja, hogy a memóriában letárolt 5 bájtos adat (tömbelemei) között hány darab páros elem van!*

7. Írjon egy olyan programot, amely a saját nevével inicializált memóriarész tartalmát

átpakolja az adott szegmensen belül lefoglalt másik memóriaterületre!Az átpakolást végezze el úgy, hogy

a) indexelt címzést használjon és az átpakolást az első karakterrel kezdje, b) indexelt címzést használjon és az átpakolást az utolsó karakterrel kezdje!

8. Készítsen olyan programot, amely megadja a memória egy bizonyos területén letett 10 db bájtos adat közül a páratlan elemek darabszámát és összegét!

9. Készítsen olyan programot, amely a memóriában letett 10 db bájtos adat közül

meghatározza a legnagyobb elemet!*

10. Másoljon át egy 10 elemű bájtos tömböt egy szavas tömbbe!

11. Fordítsa meg egy 10 elemű szavas tömb elemeinek sorrendjét helyben!

12. Adott egy 10 bájtos tömb feltöltve. Másolja át egy 10 szavas tömbbe a bájtos tömbelemeit fordított sorrendben!*

13. Adott egy 10 szavas tömb feltöltve. Minden szó alsó helyi értékű bájtját helyezze el egy bájtos tömbbe!

14. Adott egy 10 bájtos tömb feltöltve. Adja össze az elemeket, és helyezze el az összeget egymemóriaváltozóban! (Az összeg 16 bites lesz!)



72

15. Adott egy 10 szavas tömb feltöltve. A tömb minden elemét ossza el 5-tel, és ahányadosokat egy tömbben helyezze el! (Milyen méretű lesz a hányados?)*

16. Adott egy 10 bájtos tömb feltöltve, valamint egy 5 szavas tömb. A bájtos tömbszámpárjainak szorzatát állítsa elő a szavas tömbbe! (A bájtos tömb első 2 elemének

szorzatát helyezze a szavas tömb első elemébe,…stb.)

17. Definiáljon egy 20 elemű bájtos és egy 20 elemű szavas tömböt! A bájtos tömböt töltse felaz első 20 páratlan számmal, majd a négyzetüket helyezze el a szavas tömbbe!

18. Adott egy 10 bájtos tömb feltöltve. Rendezze át a tömbelemeket úgy, hogy minden elem 1hellyel előrelép, és az első elem a tömb utolsó helyére kerül!*

19. Adott egy 10 elemű szavas tömb feltöltve. Helyezze át egy másik tömbbe az elemeket bájtonként regiszter indirekt címzéssel! (LEA utasítás használata)

2.9.2. Klaviatúra - képernyő I/O, összehasonlítás, vezérlés átadás

20. Írja ki a képernyőre a "Hello Világ!" szöveget!

21. Írjon olyan programot, amely a billentyűzetről beolvassa a saját nevét, elhelyezi egysztringben, majd kiírja a standard outputra, úgy, hogy minden karakter után tesz egyszóközt!

22. Írjon olyan programot, amely egy sztring karaktereit kiírja a standard outputra fordítottsorrendben!

23. Írja ki a képernyőre karakterenként a decimális számjegyeket csökkenő sorrendben, majd

külön sorba írja ki az angol ABC 26 nagybetűjét az ABC szerinti sorrendben! (Nehasználjon tömböt!)

24. Olvasson be maximum 80 karaktert a klaviatúráról, enter végjelig! Ezután írja ki a

képernyőre a kapott karaktersorozatot a decimális számjegy karakterek kihagyásával!

2.9.3. Bitműveletek - logikai utasítások

25. Egy 5 bájtos memóriaterületen helyezzünk el ASCII kódú számjegyeket. Töröljük azegyes számjegyek zónarészét!

26. Egy 20 elemű szavas tömb minden elemét tegye 8-cal oszthatóvá úgy, hogy a számokat az

osztási maradékkal csökkenti! Nem használhat DIV utasítást!*

27. Egy tetszőlegesen feltöltött 10 elemű bájtos tömb minden elemében a 4-es és az 5-ös bitlegyen 1 értékű!

28. Egy 10 bájtos memóriaterületen helyezzük el a lehetséges decimális számjegy értékekettetszőleges sorrendben, majd egy ciklusban írjuk ki a bájtok értékei szerinti számjegyeket!(Kiírni csak ASCII kódú karaktereket tudunk)

29. Olvasson be maximum 80 karaktert a klaviatúráról, enter végjelig! Írja ki a képernyőre akapott karaktersorozatot fordított sorrendben, majd az előfordult decimális számjegy

karakterek számát is!



73

30. Számlálja meg egy 20 elemű szavas tömb 4-gyel osztható elemeit, és az eredményt írja kia képernyőre! Nem használhat DIV utasítást!*

31. Egy 10 bájtos memóriaterületen helyezzünk el ASCII kódú számjegyeket. Töröljük azegyes számjegyek zónarészét!

32.

Írjon olyan programot, amely egy 16 bites értéket binárisan kiír a képernyőre!

33. Írjon olyan programot, amely a memória ötödik szavában előforduló 1 értékű bitek számátkiírja a képernyőre!

34. Írjon olyan programot, amely a PSP első szavában előforduló 0 értékű bitek számát kiírjaa képernyőre!

35. Írjon olyan programot, amely beolvas a klaviatúráról egy legfeljebb 16 jegyű binárisszámot ellenőrzéssel, majd a bináris értéket elhelyezi egy szavas változóban!

36.

Írjon olyan programot, amely egy legfeljebb 10 jegyű decimális számot ellenőrzéssel beolvas a standard inputról, majd a beolvasott számjegyeket egy 10 bájtos puffer területreátpakol úgy, hogy a pufferben a számjegyek jobbra igazítottan, vezető nullákkal feltöltvehelyezkedjenek el!

37. Írjon olyan programot, amely egy maximum 12 jegyű decimális számot ellenőrzéssel beolvas a standard inputról, majd megállapítja, hogy a beolvasott szám osztható-e 9-cel!

Az eredményről írjon szöveges üzenetet a képernyőre!

38. Adott egy 10 szavas tömb feltöltve. Állapítsa meg, van-e olyan tömbelem, amelyben az 1értékű bitek száma osztható 4-gyel!

39.

Adott egy 10 szavas tömb feltöltve. Írja ki annak az elemnek a sorszámát, amelyben az 1értékű bitek száma a legnagyobb!

40. Adott egy 20 bájtos tömb feltöltve. Írja ki, hogy hány tömbelemben páros az 1 értékű bitek száma!

41. Írjon olyan programot, amely egy legfeljebb 4 jegyű decimális számot ellenőrzéssel beolvas a standard inputról, majd a beolvasott számot binárisan elhelyezi egy szavasváltozóba. Végül írja ki külön-külön ennek a szónak a bájtjait decimálisan a képernyőre!Mit tapasztal? A program működjön ciklusban!*

42.

Írjon olyan programot, amely egy legfeljebb 4 jegyű hexadecimális számot ellenőrzéssel beolvas a standard inputról, majd a beolvasott számot binárisan kiírja a képernyőre! A program működjön ciklusban!

43. Írjon olyan programot, amely egy legfeljebb 16 jegyű bináris számot beolvas ellenőrzéssela klaviatúráról, majd a hexadecimális megfelelőjét kiírja a képernyőre! A programműködjön ciklusban!



74

2.9.4. Alprogramok

44. Írjon olyan programot, amely a billentyűzetről beolvas kettő, max. 5 jegyű számot, és a

beolvasott számokat binárisra konvertálja! Adja össze a két számot, majd az eredménytírja ki a képernyőre!*

45. Írjon olyan programot, amely a

- a billentyűzetről beolvas 2 (maximum 5 jegyű) számot - elosztja a két számot, - az eredményt (külön a hányadost és a maradékot) kiírja a képernyőre!

46. Válassza ki egy 20 elemű szavas tömb legnagyobb elemét, majd írja ki a képernyőre alegnagyobb elem sorszámát!

47. Írjon olyan programot, amely megszámolja egy bájtos adatokból álló tömb páros elemeit!A megszámolást procedúrával végezze!

a) A paraméterátadás regisztereken keresztül történjen! b) A paraméterátadás a stack memórián keresztül történjen!

48. Írjon olyan programot, amely megszámolja egy bájtos adatokból álló tömb páros elemeit!A megszámolást makróval végezze!

49. Írjon olyan programot, amely összead két bájtos adatot! Az eredmény szavas legyen (azösszeadást procedúrával végezze)! a) A paraméterátadás regisztereken keresztül történjen!

b) A paraméterátadás a stack memórián keresztül történjen!

50.

Írjon olyan programot, amely egy 10 db bájtos adatból álló tömb elemeit összegzi! Azösszegzést procedúrával végezze! a) A paraméterátadás regisztereken keresztül történjen!


51. Írjon olyan programot, amely egy 10 db bájtos adatból álló tömb páratlan elemeitösszegzi! Az összegzést procedúrával végezze! a) A paraméterátadás regisztereken keresztül történjen!


52. Írjon olyan programot, amely megadja egy 10 db bájtos adatból álló tömb legnagyobb

elemét! A maximum kiválasztást procedúrával végezze! a) A paraméterátadás regisztereken keresztül történjen!


53. Írjon olyan programot, amely a

- a billentyűzetről beolvas 2 (maximum 5 jegyű) számot - összeadja a két számot, - az eredményt kiírja a képernyőre!

A *-gal jelölt feladatok megoldásai megtalálhatók a jegyzetben.



Irodalomjegyzék 1. Niklaus Wirth: Algoritmusok + Adatstruktúrák = Programok

Műszaki Könyvkiadó, 1982. ISBN 963-10-3858-0

2. Benkő Tiborné, Benkő László, Tóth Bertalan: Programozzunk C nyelven

ComputerBooks, 2003. ISBN 9789636183660

3. Bjarne Stroustrup: C++ programozási nyelv

Kiskapu Kiadó, 2001. ISBN 9789639301191

4. Jesse Liberty, David B. Horvath: Tanuljuk meg a C++ programozási nyelvet 24 óra alatt Kiskapu Kft, 2008. ISBN 9789639637382

5. Máté Eörs: Assembly programozás Novadat Bt., 2000. ISBN 963-9056-27-8

6. Wikipédia: C++

http://hu.wikipedia.org/wiki/C++

7. Doksi.hu C++ segédletek http://doksi.hu/doksik.php?fid=44&doksi_order=new_desc

8. Abonyi Zsolt: PC hardver kézikönyv

ComputerBooks, 1996. ISBN 963-618-082-2

9. Pethő Ádám: Assembly alapismeretek 1. kötetSzámalk, 1987. ISBN 963-553-123-0

10. Peter Norton, John Socha: Az IBM PC assembly nyelvű programozása

Novotrade Kiadó, 1991. ISBN 963-585-016-6

11. Peter Norton: Az IBM PC programozása

Műszaki Könyvkiadó, 1992. ISBN 963-10-8272-5

12. Iványi Péter: Assembly programozás

http://e-oktat.pmmf.hu/webgui/www/uploads/images/1597/assembly

13. Rodek Lajos, Diós Gábor: Assembly programozás http://www.inf.u-szeged.hu/~ber/okt/asm/jegyzet.pdf

14. Kitlei Róbert: Assembly programozás http://www.inf.elte.hu/karunkrol/digitkonyv/Jegyzetek2007/assembly.pdf

15.

Wikipédia: Assembly

http://hu.wikipedia.org/wiki/Assembly

16. Doksi.hu Assembly segédletek http://www doksi hu/doksik php?q=assembly

http://hu.wikipedia.org/wiki/C%2B%2B


http://doksi.hu/doksik.php?fid=44&doksi_order=new_desc




http://www.inf.u-szeged.hu/~ber/okt/asm/jegyzet.pdf


http://www.inf.elte.hu/karunkrol/digitkonyv/Jegyzetek2007/assembly.pdf




http://www.doksi.hu/doksik.php?q=assembly









programozas i-ii kidolgozott peldak es peldatar

Documents