Eljárások és funkciók a pascal prezentációban. Eljárások és funkciók Pascalban. Rekurzió. Alprogramok Egy feladatban gyakran meg akarunk ismételni egy bizonyos utasítássorozatot a program különböző részeiben. III. Új anyag magyarázata

Az óra célja

nevelési

egységeset alkotnak fogalomrendszer az eljárás és a funkció fogalmaihoz kapcsolódik;
megtanítja az alprogramok használatát Pascal-problémák megoldásában, valamint megtanítja megérteni, milyen típusú szubrutin szükséges egy adott probléma megoldásához;
mutassa meg az alprogramok használatának alapvető technikáit;

nevelési

pontosságra, figyelemre, szervezettségre nevelni;
a számítástechnikai ismeretek kultúrája;

fejlesztés

fejleszteni a tanulók logikus gondolkodását, algoritmikus kultúráját;
ismereteket és készségeket fejleszteni a Pascal szubrutinok írásához és hibakereséséhez.

A tanulóknak kötelező:

ismerje a paraméter nélküli és paraméterekkel írt eljárások szabályait;
ismerje a rögzítési funkciók szabályait;
tudjon eljárásokat és függvényeket alkalmazni egyszerű problémák megoldására.

Az órák alatt

I. Org. pillanat

II. Bevezetés. Relevancia

Adj ki egy feladatot a lapokra ( 1. számú melléklet ). Ismétlés keresése.

Néha a program különböző helyein szinte ugyanazt a műveletsort kell végrehajtani különböző kezdeti adatokkal. Az ilyen műveletsorok formalizálhatók ún szubrutinok (angolról, szubrutin) - csoportosítsa az utasításokat egy blokkba, amelyre név szerint lehet hivatkozni, és többször is.

Az alprogramok csökkentik a program szövegét, jelentősen lerövidítik a végrehajtásuk idejét, megkönnyítik azoknak a programozóknak az életét, akik modulárisan, vagyis egyszerűbb komponensek kész darabjaiból összetett programot állítanak össze. Ez lehetővé teszi a programozók egy csoportja számára, hogy nagy programokat hozzon létre, és egy iskolás csoport bármilyen globális projektet kidolgozzon és megvalósítson.

Az alprogramok eljárásokra és függvényekre vannak felosztva.

A beépített (standard) eljárások és funkciók azok rész nyelven, és név szerint is hívható előzetes leírás nélkül. Például , abs, sqrt, ln, sin… függvények (eredményt ad vissza), readln, write… eljárások (nem ad vissza eredményt). Jelenlétük nagyban megkönnyíti a pályázati programok fejlesztését. A legtöbb esetben azonban néhány különleges egy adott program esetében a műveletek nem találnak közvetlen analógokat a Turbo Pascal könyvtárakban, és ezután a programozónak ki kell fejlesztenie a sajátját nem szabványos eljárások és funkciók.

III. Új anyag magyarázata

A felhasználói eljárások le vannak írva magunktól programozó a nyelv szintaxisának megfelelően szubrutin leírása szakasz.

Az eljárás felépítése megismétli a program felépítését, ez egy "miniatűr program" - egy címsor és egy törzs is ábrázolja.

A fejléc a fenntartott szó eljárásból, az azonosítóból áll (név) eljárások.

VAR ... // a főprogram változóinak deklarációjának szakasza

eljárás ProcedureName;

//fő programtörzs

Meg van írva egy eljárás meghívása a későbbi végrehajtáshoz a főprogram törzsében.

1. példa Program terület és kerület kiszámításához.

Az alprogramok előnyei:

Alprogramokkal írt programok könnyebben tesztelhető és hibakereshető, világosabbak logikai szerkezet.
Az alprogramok önálló jellege lehetővé teszi, hogy összeállításukat különböző programozókra bízzák. Így működik a programozás felosztása, ill. ezáltal, elkészülése felgyorsul;
A szubrutinok használata memóriát takarít meg. A szubrutinban használt változók tárolására szolgáló memória csak a végrehajtás idejére van lefoglalva, és felszabadul, amint a végrehajtás véget ér.

2. példa A felhasználó három téglalap két oldalát írja be. Hozd ki a területüket.

A problémát így oldhatja meg:

i:=1-től 3-ig tegye

writeln('Írja be a és b:');

writeln('Terület=',a*b);

Jó programozási stílusnak tekinthető az eljárások használata. Szükségünk van egy eljárásra, amely kiszámítja a téglalap területét. A fő program sematikusan így fog kinézni:

számítás

A szöveges eljárás már megvan (lásd az 1. példát). Hozzunk létre egy második eljárást, amely kiszámítja a területet. De az S kiszámításához 2 oldalt kell ismernie, tehát az eljárásnak meg kell mutatnia, hogy melyik oldallal kell szoroznia.

eljárás pl(c,d: egész);

writeln(’egy téglalap területe oldalakkal ’,c, ‘’ ,d, ‘=’,S);

A paraméter egy olyan változó, amelyhez értéket rendelnek. Létezik formális paraméterek az alprogram fejlécében meghatározott, és tényleges paraméterek – olyan kifejezések, amelyek meghatározott értékeket adnak meg egy szubrutin elérésekor.

Az eljárás akkor kerül végrehajtásra, ha név szerint hívja meg és megadja a tényleges paramétereket , vesszővel elválasztva és zárójelben:

A tényleges paramétereknek típusban és mennyiségben meg kell egyeznie a formális paraméterekkel.

Tehát a fő program:

i:=1-től 3-ig tegye

Megjegyzés. A probléma megoldása során ellenőrizni kell a felhasználó által beírt számokat (nem lehetnek negatívak, különben a program megszakad).

Hozzunk létre egy ellenőrzési eljárást:

eljáráshiba(f,g:integer);

ha (f<0) or (g<0) then begin

writeln('a téglalap oldalai nem lehetnek negatívak');

Állj; // program megszakítása

Végső program - 4. függelék

Tehát az eljárás formátuma:

eljárást<имя>(formális paraméterek);

<операторы>;

3. példa Írjon programot két c=5 és d=7 szám helyének felcserélésére.

programcsereDan;

var c,d:integer;

eljárás obmen(a,b:integer);

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

writeln("Írjon be 2 számot: ");

writeln(c," ",d);

A program elindítása után látható, hogy a formális paraméterek (az eljárásban) helyet változtattak, de a ténylegesek (amelyeket a főprogramban használunk) nem változtak. Tekintsük az ábrát, amely a RAM egy részét mutatja:

1) ha az obmen eljárást két 5-ös és 7-es paraméterrel hívjuk, akkor az 5-ös és 7-es számok is az a és b változókba kerülnek:

3) de a c és d változókban az adatok nem változtak, mert más memóriahelyeken vannak.

A c és d változók érdekében a és b ugyanazokra a memóriacellákra utal (ha a és b értéke változik, akkor a c, d értéke is változni fog) a formális paraméterek leírásánál a szükséges változók elé tegyük a VAR szót:

eljárás obmen (var a,b:integer);

Az obmenDan program módosítása:

Hiba a következő miatt: var. A számok olyan állandók, amelyeket nem lehet megváltoztatni az eljárás során.

4. példa Keresse meg a kör területét egy olyan eljárással, amely csak számítást végez, de az eredményt nem jeleníti meg a képernyőn.

eljárás kör(r:real);

Az eljárásnak vissza kell adnia az eredményt:

eljárás kör (r:real; var S:real);

readln(a, e);

Megjegyzés: Az S eljárás változója az eljárás eredményeinek visszaküldésére szolgál a főprogramba. Ha változik, akkor a hívó programban a tényleges paraméter is megváltozik, pl. változó e.

Gyakrabban ehhez Pascalban az eljárások helyett függvényeket (valamit visszaadó szubrutinokat) használnak.

A funkció hasonló az eljáráshoz, de két különbség van.

A függvény átadja a programnak a munkájának eredményét - az egyetlen értéket, amelynek hordozója a függvény neve.
A függvény neve operandusként szerepelhet a kifejezésben. A függvény a hívás pontján adja vissza az eredményt.

Például az sqr(x) négyzetre emeli x értékét, és visszaadja az x szám négyzetének számított értékét a hívási pontnak: y:=sqr(x);

A felhasználó által definiált függvény egy fejlécből és egy függvénytörzsből áll. Egy függvény törzse felépítésében hasonló a programéhoz. Címkék leírása, konstansok, típusok stb. csak ezen eljáráson belül érvényes.

funkció<имя>(formális paraméterek):<тип результата>;

<операторы>;

Az utasításrésznek tartalmaznia kell legalább egy olyan utasítást, amely értéket rendel a függvény nevéhez. Az utolsó hozzárendelés eredménye visszakerül a hívópontra.

5. példa Írjuk át a kör területének problémáját.

függvény circle(r:real): valós;

a:=kör(5); (Hozzá kell rendelni)

6. példa Keress 1!+2!+…+n!

A faktoriális keresésének függvényét használjuk, mert bemenetként betápláljuk és megkapjuk az eredményt.

függvény tény(a:integer): egész szám;

for i:=1 egy do

A sorban tény:=tény*I;

a fordító hibát talál, mert a tényt paraméterekkel kell meghívni. Ezért általában egy további változót vezetnek be, amelybe az eredményt elhelyezik. Ezután ezt az eredményt a tényváltozóhoz rendeljük:

program faktoriális;

varsum,n,j: egész szám;

függvény tény(a:egész): egész szám;

var i,d: egész szám;

for i:=1 egy do

j:=1-től n-ig

összeg:=összeg+tény(j);

IV. Óra összefoglalója

Ebben az időben a programozási folyamat átalakul programok ipari gyártása alapján programozási technológiák. A legtöbb szakértő azon a véleményen van felülről lefelé irányuló szoftvertervezési módszerösszetett problémák megoldására a legalkalmasabb. Először a feladatot általánosan meghatározzák, majd fokozatosan finomítják a struktúrát. A következő lépésben minden részfeladatot több másik részre osztanak fel. Egy komplex probléma külön töredékének megoldása egy független programblokk - egy szubrutin.

V. Házi feladat

Problémák megoldása (írásban):

Írjon egy eljárást, amely minden a betűt *-ra cserél a beviteli karakterláncban.
Két javaslat szerepel. Keresse meg a bennük lévő "n" betűk számát. (Határozzon meg egy függvényt a mondatban lévő "n" betűk számának kiszámításához.)

szubrutinok V TurboPascal

szubrutin – ez egy elnevezett, logikailag teljes parancscsoport, amely a program különböző helyeiről tetszőleges számú végrehajtásra hívható.

A szubrutinok használatának okai

egy feladat több részfeladatra bontásával (felosztásával) egyszerűsítse a nagy programok fejlesztését;
a program nagyobb láthatósága;
memória megtakarítása.

Alprogramok típusai

eljárások

funkciókat

Eljárás a program egy független elnevezett része, amely meghatározott műveletek végrehajtására szolgál.

Paraméterek nélküli eljárások

Felvételi formátum :

eljárást ;

vége ;

A paraméter nélküli eljárásokban használt összes változó leírása a fő programban (a Var modulban található).

Példa . Írjon programot egy henger térfogatának meghatározására.

programhenger;

Var R, H, V: valós;

Beviteli eljárás ; (adatbeviteli eljárás)

Writeln('Adja meg a sugár értékét');

writeln('Adja meg a magasság értékét');

eljárás; { eljárást számításokat hangerő }

V:=PI*sqr(R)*H;

Kimeneti eljárás ; ( kimeneti eljárás )

writeln('V=',V);

Eljárások c paramétereket

Az eljárások konstansokat, változókat és egyéb eljárásokat írhatnak le.
Az eljárásokban a leírás rész felépítése megegyezik a főprograméval.
Lokális változók egy eljáráson belül deklarált változók.
A lokális változók nem érhetők el az eljáráson kívül.
Az eljáráson belüli helyi változók változásai nem érintik az azonos nevű, de az eljáráson kívül deklarált változók értékeit.

Eljárások c paramétereket

Globális változók

Példa .

programfeladat;

Var a, b: egész szám;

eljáráshelyi;

Var a, x: char; Mert eljárások helyi:

kezdődik változó x - helyi változó

a:='! '; (a program nem tudja megváltoztatni az értékét)

b:=b+1; változó b - globális változó

vége ; (a változó értékének minden változása az eljárásban

A BEGIN az eljárásból való kilépés után is megmarad)

b:=100; változó a a főprogramban – egész típus,

helyi; eljárásban pedig - karaktertípus. változó a

writeln('a=', a); egész típus nem érhető el a helyi eljárásban.

writeln('b=',b);

A program végrehajtásának eredménye: a=0; b=101.

); Rajt; vége ; "width="640"

Paraméterek átadása a következőnek Turbó Pascal

1. Paraméterek átadása érték szerint

Érték paraméterek – az eljárás neve után zárójelben deklarált változók. Előttük nincs szolgálati szó Var .
Felvételi formátum :

eljárást (:

változó);

vége ;

formális paraméterek .
tényleges paraméterek .

Példa .

program paraméter;

Var m, n: egész szám;

sum Procedure(a, b: integer);

writeln('S=',S);

summa(m,n); vagy summa(100,10);

Változók a És b formális paraméterek és változók m És n - tényleges. Aktuális paraméterértékek m =100 és n =10 átadásra kerül a formális paramétereknek a És b .

A tényleges paraméterek módosítása csak az eljáráson belül történik, és az eljáráson kívül nem érinti azokat.

; változó változó:); Rajt; vége ; "width="640"

Paraméterek átadása a következőnek Turbó Pascal

2. Paraméterek név szerinti átadása

Változó paraméterek – az eljárás neve után zárójelben deklarált változók, amelyeket a Var szolgáltatásszó előz meg.
Felvételi formátum :

eljárást (:

változó; Var

változó:);

vége ;

b, akkor min:= b; ha min c akkor min:= c; vége ; BEGIN writeln('Írjon be három számot'); readln(a1, b1, c1); writeln (' írjon be három számot'); readln(a2,b2,c2); minimum(a1,b1,c1,min1); minimum(a2,b2,c2,min2); S:= min1 + min2; writeln('S=', S); VÉGE. Példa. Adott két számhármas: a 1, b 1, c 1 és a 2, b 2, c 2. Határozza meg az összeg értékét: S=min (a1, b1, c1) + min (a2, b2, c2) "width=" 640"

Var a1,b1,c1,a2,b2,c2, min1, min2, S: valós;

Eljárási minimum (a,b,c: valós; Varmin: valós);

ha min b, akkor min:= b;

ha min c akkor min:= c;

writeln('Írj be három számot');

readln(a1, b1, c1);

writeln (' írjon be három számot');

readln(a2,b2,c2);

minimum(a1,b1,c1,min1);

minimum(a2,b2,c2,min2);

S:= min1 + min2;

writeln('S=', S);

Példa. Adott két számhármas: a 1, b 1, c 1 és a 2, b 2, c 2. Határozza meg az összeg értékét: S=min (a1, b1, c1) + min (a2, b2, c2)

Funkció egy szubrutin, amelynek eredménye valamilyen érték.

Felvételi formátum :

funkció (:

vége ;

A függvénytörzsben a függvénynévhez hozzá kell rendelni a végrehajtásának eredményét.
Amikor egy függvényt hívunk, annak nevét a tényleges paraméterek listájával együtt operandusként kell szerepeltetni a kifejezésben.

programkifejezés;

függvénymodul (a: valós) : valós;

writeln('Adja meg a változó értékét');

y:= modul(x-3) + modul(x+6);

writeln ('y=', y);

Példa . Számítsa ki a kifejezés értékét: y = | x -3 | + | x+6 |

8. osztály. ABC Pascal programozás

Informatika tanár, NIS, Uralsk FMN Zelenov Boris Alexandrovich

A tanulók eljárások és függvények segítségével oldják meg a problémákat
A tanulók megtanulják megoldani a nagy problémákat azáltal, hogy kisebbre bontják azokat.

Az eljárások és függvények fogalmának kialakítása programozási nyelvben.

A hallgatók ismerik az "eljárások" és "függvények" fogalmát, meghatározzák a formai és tényleges paramétereket

Várt eredmények – Leírók:

1. Ismeri az "eljárás" fogalmát

2. Ismeri a "funkció" definícióját

3. Meghatározza a tényleges és formális paramétereket

4. Megkülönbözteti a paraméterértékeket és a változókat

5. Megkeresi egy eljárás vagy függvény hívását a programkódban

Elvira standard terve

1. Távolítsa el a papírokat

2. Öntözzük meg a virágokat

3. Mossa le az íróasztalokat

4. Törölje le az üveget

Algoritmus vége

Hogyan lehetne javítani ennek a folyamatnak a megszervezését?

Óra témája

Rutinok:

Ishki bagdarlam

szubrutin

Eljárás

Parametler

Hasznos kifejezések:

A változók értékeinek az eljárásnak (függvénynek) való átadásához a tényleges paramétereket használják ...

Az eljárás leírásához először ...., majd ...

A szubrutin fogalma

Meghatározás

szubrutin különálló, funkcionálisan független része a programnak.

szubrutinok

Eljárások

megszünteti annak szükségességét, hogy a program szövegében hasonló töredékeket ismételten megismételjenek;
javítsa a program szerkezetét, megkönnyítve annak megértését;
növeli az ellenállást a programozási hibákkal és a programmódosítások során fellépő előre nem látható következményekkel szemben.

Rajzoljon kerítést egy programozási nyelv segítségével

Ebben a feladatban létrehozhat egy eljárást, amely végrehajtja az algoritmust egy töredék (kerítés) rajzolására, majd folyamatosan hivatkozik erre az eljárásra, megváltoztatva a toll kezdeti helyzetét

Ismertesse, hogyan kell racionálisan karácsonyfát rajzolni programozási környezetben

Ezek független programtöredékek, speciális módon megtervezve és saját névvel rendelkeznek.

Kölcsönhatás a főprogram és az alprogram között

blokk diagramm

Szubrutin hívásblokk (eljárás vagy funkció)

Szubrutin neve (eljárás vagy funkció)

blokk diagramm

Az eljárás leírása így néz ki:

eljárást name(formális paraméterek listája); leírás rész kezdődik operátorok vége ;

A funkció leírása így néz ki:

funkció name(formális paraméterek listája): return type;

leírás rész kezdődik operátorok vége ;

Helyszín a programban

program ...;

//Leírás szakasz Felhasználások, Const, Var, ...

eljárást A ;

kezdődik ....... vége ;

eljárást B ;

kezdődik ........ vége ;

C funkció ;

kezdődik ........ vége ;

//Fő program

kezdődik ........ vége .

A függvény és az eljárás közötti különbség az, hogy a függvény törzsét alkotó operátorok végrehajtásának eredménye mindig egyetlen érték, így a függvényhívás a megfelelő kifejezésekben használható változókkal és konstansokkal együtt.

Eljárások

Funkciók

Több eredménye is lehet, vagy végrehajthat néhány műveletet

Csak egy eredménye van, melynek típusát a függvény deklarálásakor külön adjuk meg.

Az eredmény bármilyen típusú tömb, karakterlánc, szám stb. lehet.

Az eredmény csak valós, egész vagy karakteres érték lehet.

Az eljáráshívás parancs egy különálló parancs, amelyet önállóan használnak.

A függvényhívás csak a megfelelő típusú kifejezés összetevőjeként használható.

Egy függvény törzsének tartalmaznia kell legalább egy hozzárendelési operátort, amelynek bal oldalán a függvény neve szerepel.

b majd max:=a else max:=b; MaxNumber:= max; end;" width="640"

Eljárás vagy funkció?

MaxNumber(a,b: integer): egész szám;

var max: integer;

MaxNumber:= max;

b majd max:=a else max:=b; end;" width="640"

Eljárás vagy funkció?

MaxNumber(a,b: integer; var max: integer);

ha ab akkor max:=a else max:=b;

Eljárás vagy funkció?

ChangeColor(C1, C2: Word);

TextBackGround (C2)

Eljárás vagy funkció?

Add(X, Y: Integer): Integer;

Tényleges

A fő program részben jelezve

Hivatalos

Az alprogramban megadva
Az alprogramban megadva

Az eljáráshívás a következő formátumú utasítással történik:

eljárás neve (a tényleges paraméterek listája);

A tényleges paraméterek listája a felsorolásukat vesszővel választjuk el.

A Pascal nyelvi szabványban a paraméterek kétféleképpen adhatók át - érték szerint és hivatkozással. Az érték által átadott paramétereket hívjuk érték paraméterek hivatkozással átadva - változó paraméterek. Ez utóbbiakat az különbözteti meg, hogy egy eljárás (függvény) fejlécében a var szolgálatszó áll előttük.

Paraméterek átadása. Formális paraméterek

Változók

Értékek

Paraméterek érték szerint

Formális paraméterek

Változók

Formális paraméterek

Paraméterek érték szerint

Az első módszerben (érték szerint haladva) a tényleges paraméterek értékeit a megfelelő formális paraméterekbe másoljuk.

Eljárás

Név Eljárás (a, b: egész);

Fő program

Ha ezek az értékek az eljárás (funkció) végrehajtása során megváltoznak, a kezdeti adatok (tényleges paraméterek) nem változhatnak

Var c, d: egész szám;

Referencia szerinti átadáskor minden változás, amely egy formális paraméterekkel rendelkező eljárás (függvény) törzsében történik, azonnali hasonló változáshoz vezet a nekik megfelelő tényleges paraméterekben.

Eljárás

Név Eljárás (a, b: egész szám, Var c: valós);

Fő program

Változások történnek a hívó blokk változóiban, így a kimeneti paraméterek hivatkozással kerülnek átadásra. Meghíváskor a hozzájuk tartozó tényleges paraméterek csak változók lehetnek.

Írsz:

1. Tényleges paraméterek ___________

Eljárás Kvad(R: valós; var S: valós);

2. Formai paraméterek ___________

3. Formális paraméterek-értékek__________

5. Eljárás neve ___________

6. Az eljárás lehívása a programból _________________________

Interaktív feladat

http://www.bzfar.net/load/podprogrammy_procedury_i_funkcii_parametry/23-1-0-498

Elvira az osztályfőnök. Tervet kell készítenie az általános takarításhoz az osztályteremben: távolítsa el a papírokat, öntözze meg a virágokat, mossa le az asztalokat, törölje le az ablakokat. Mi a legjobb módja a munkájának megszervezésére? Segíts Elvirának.

Elvira Advanced Plan

Rutinok:

Arsen – eltávolítja a papírokat

Mila virágokat öntöz

Vitalij - íróasztalokat mos

Indira - törli az üveget

1. Fuss Arsen

2. Fuss Milát

3. Fuss Vitalit

4. Fuss Indira

Algoritmus vége

Milyen új struktúrákkal találkoztunk ma a programozási nyelvben?
Nevezze meg a vizsgált paramétereket!

Hogyan adják át a paramétereket egy eljárásnak?

Óra összefoglalója

Meghatározások keresése: „Helyi változók” és „Globális változók”

Állítson össze két olyan feladatot, amelyben eljárások vagy függvények használhatók.

Hogyan határozná meg az óra témáját? (találja ki a saját nevét)
Mit gondolsz, mit kellene megtanulnod a következő leckében?

Találkozzunk

következő lecke!

Alprogramok Egy feladatban gyakran meg akarunk ismételni egy bizonyos utasítássorozatot a program különböző részeiben. Annak érdekében, hogy ezt a sorozatot egyszer leírjuk, és sokszor alkalmazzuk, a programozási nyelvekben szubrutinokat használnak. A szubrutin egy speciálisan kialakított programblokk a főprogramban történő további felhasználásra.Az alprogramok használata lehetővé teszi az egyik legmodernebb programozási módszer - a strukturált programozás - megvalósítását.

Az alprogramok három fontos feladatot oldanak meg, amelyek nagyban megkönnyítik a programozást: 1. megszűnik a programszöveg hasonló töredékeinek ismételt ismétlése, pl. csökkentse a program hatókörét; 2. javítsa a program szerkezetét, hogy könnyebben érthető legyen az elemzés során; 3.csökkenti a hibalehetőséget, növeli az ellenállást a programozási hibákkal és az előre nem látható következményekkel szemben a módosítás során.

Eljárások és függvények A Pascalban kétféle szubrutin létezik: eljárás (PROCEDURE) és funkció (FUNCTION). A Pascal eljárásai és függvényei a változószekció mögötti leírás részben vannak deklarálva. Program ProgramName; VAR … // a főprogram változóinak leírása; eljárás ProcedureName; var … begin …//Eljárás törzsének vége; begin //fő programtörzs vége.

A függvényeknek és eljárásoknak vannak paraméterei (változók, amelyek értéket adnak át). Két típusuk van: 1) Formális - azok, amelyek az alprogram leírásában szerepelnek 2) Aktuális - azok, amelyek a fő programból egy függvénybe vagy eljárásba kerülnek át. A tényleges paramétereknek számban, sorrendben és típusban meg kell egyeznie a formális paraméterekkel.

Eljárások Az eljárások akkor használatosak, ha egy szubrutinban több eredményt kell elérni. A Pascalban kétféle eljárás létezik: paraméteres és paraméter nélküli eljárások. Az eljárást az eljárás neve, majd a tényleges paraméterek követik. Egy eljárás meghívásakor egy-egy megfeleltetés jön létre a tényleges és a formális paraméterek között, majd a vezérlés átkerül az eljárásra. Az eljárás végrehajtása után a vezérlés átkerül a hívó program következő, az eljáráshívást követő operátorához.

1. példa: Paraméterek nélküli eljárás, amely 60 csillagból álló karakterláncot nyomtat. eljárás pr; var i: integer ; start for i:=1 – 60 do write(* "); writeln; end; begin pr; end.

2. példa Írjon programot két c=5 és d=7 szám helyének felcserélésére program obmenDan; var c,d:integer; eljárás obmen(a,b:integer); var m:integer; beginm:=a; a:=b; b:=m; writeln(a,b); vége; begin writeln("Írjon be 2 számot: "); readln(c, d); változás(c, d); writeln(c," ",d); vége. c5 d 7 a 5 b 7 a 7 b 5 3) de a c és d változók adatai nem változtak, más memóriasejtekben vannak

Annak érdekében, hogy a c és d, a és b változók ugyanazokra a memóriacellákra vonatkozzanak (ha a és b értéke változik, akkor a c és d értéke is megváltozik) a formális paraméterek leírásánál, add hozzá a VAR szót a szükséges változók elé: procedúra obmen (var a,b:integer); c5 d 7 a b

3. példa Adott 3 különböző egész szám tömb (egyiknek mérete nem haladja meg a 15-öt). Minden tömbben keresse meg az elemek összegét és a számtani átlagot. program proc; var i, n, sum: integer; sr: valódi; eljárási munka (r:integer; var s:integer; var s1:real); var mas: egész számok tömbje ; j: egész szám kezdődik s:=0; mert j:=1-től r-ig kezdjük az olvasást(mas[j]); s:=s+mas[j]; vége; s1:=s/r; vége;

(főprogram) begin for i:=1 to 3 do begin write ("Vvedite razmer ",i, " masiva: "); readln(n); munka(n, sum, sr); (munkaeljárás hívása) writeln("Summa elementov = ",sum); writeln("Srednearifmeticheskoe = ",sr:4:1); vége; vége.

A program munkájának eredménye: A program háromszor hívja meg a munkaeljárást, amelyben az r, s, s1 formális változókat a tényleges n, sum, sr váltja fel. Az eljárás elvégzi a tömbelemek bevitelét, kiszámítja az összeget és az átlagértéket. Az s és s1 változók visszakerülnek a főprogramba, így a var függvényszó a leírásuk elé kerül. A mas, j helyi paraméterek csak az eljárásban érvényesek. Globális - i, n, sum, sr a program egészében elérhetők.

Funkciók Pascalban A Pascal beépített funkcióinak készlete meglehetősen széles (ABS, SQR, TRUNC stb.). Ha új, nem szabványos funkció kerül a programba, akkor azt a programszövegben le kell írni, ezután lehet elérni a programból. A funkció hívása a hozzárendelési operátor jobb oldalán történik, feltüntetve a függvény nevét és az aktuális paramétereket. Egy függvénynek lehetnek saját helyi állandói, típusai, változói, eljárásai és függvényei. A funkciók leírása Pascalban hasonló az eljárások leírásához.

4. példa Írjon fel egy a x fokú szubrutinfüggvényt, ahol a, x tetszőleges szám. Használjuk a képletet: a x = e x egy p2 programban; var f, b, s, t, c, d: valós; ( globális változók) függvény stp (a, x: valós) : valós; variál: valódi; (lokális változók) begin y:= exp (x * ln (a)) ; stp:= y;(a szubrutin számítási eredményéhez tartozó függvénynév hozzárendelése) end; (a függvény leírása kész) begin d:= stp(2.4, 5); (különböző számok és változók számítási hatványai) writeln (d, stp (5,3.5)); read(f, b, s, t); c:= stp(f, s)+stp(b, t); writeln(c); vége.

Funkciók A szubrutin a program egy külön szintaktikai konstrukcióként kialakított és névvel (önálló programblokk) ellátott része az egyes feladatok megoldására. Eljárás leírása: eljárás () (helyi név végrehajtási szakasz) Begin (kimutatás végrehajtási szakasz) Befejezés; Funkció leírása: funkció (): típus; (helyi név deklarációs szakasz) Begin (futtatható utasítás szakasz) := ; (kötelező paraméter) End; Eljárás felhívás: (); Függvényhívás: := (); 1. A hozzárendelési operátor jobb oldalán. 2. Egy kifejezésben az elágazó operátor feltételében. 3. A kimeneti eljárásban a függvény eredményeként. Alprogramok leírása Eljárások

Rekurzió A Pascal-beli eljárások és függvények nevezhetik magukat, pl. rendelkezik a rekurzív tulajdonsággal. A rekurzív függvénynek szükségszerűen tartalmaznia kell egy rekurzív befejezési feltételt, hogy ne idézze elő a program ciklusát. Minden rekurzív hívás új helyi változókészletet hoz létre. Vagyis a hívott függvényen kívül található változók nem változnak.

1 függvény f(n: integer): egész szám; kezdődik, ha n = 1, akkor f:= 1 else f:= n * f (n -1); (f függvény meghívja magát" title="Példa 5. Hozz létre egy rekurzív függvényt, amely egy n szám faktoriálisát a következőképpen számítja ki: n! = 1 ha n= 1 n!= (n -1)! n ha n > 1 f függvény (n: egész): egész szám; kezdődik, ha n = 1, akkor f:= 1 else f:= n * f (n -1); (f függvény meghívja magát" class="link_thumb"> 19 !} 5. példa Írjon egy rekurzív függvényt, amely a következőképpen számítja ki egy n szám faktoriálisát: n! = 1, ha n= 1 n!= (n -1)! n ha n > 1 függvény f (n: integer): egész szám; kezdődik, ha n = 1, akkor f:= 1 else f:= n * f (n -1); (f függvény hívja magát) end; 1 függvény f(n: integer): egész szám; kezdődik, ha n = 1, akkor f:= 1 else f:= n * f (n -1); (az f függvény meghívja magát"> 1 f függvény (n: egész): egész szám; kezdődik, ha n = 1, akkor f:= 1 else f:= n * f (n -1); (f függvény meghívja magát) end; " > 1 függvény f (n: egész): egész szám; kezdődik, ha n = 1, akkor f:= 1 else f:= n * f (n -1); (f függvény meghívja magát" title="Példa 5 Írjon egy rekurzív függvényt, amely a következőképpen számítja ki n faktoriálisát: n!=1 ha n= 1 n!= (n -1) n ha n > 1 függvény f (n: egész): egész szám;kezdődik, ha n = 1, majd f:= 1 különben f:= n * f (n -1); (f függvény meghívja magát"> title="5. példa Írjon egy rekurzív függvényt, amely a következőképpen számítja ki egy n szám faktoriálisát: n! = 1, ha n= 1 n!= (n -1)! n ha n > 1 függvény f (n: integer): egész szám; kezdődik, ha n = 1, akkor f:= 1 else f:= n * f (n -1); (f függvény meghívja magát"> !}

Rekurzió Pascalban Tanár: Tlekhurai Yu.V. MOU "Líceum No. 8" Mit látsz a képeken? Ezt a jelenséget a művészetben ún rekurzió "A rekurzió megértéséhez először meg kell értened a rekurziót." rekurzió - egy objektum részleges meghatározása önmagán keresztül, egy objektum meghatározása korábban meghatározottak segítségével. Tudományosan szólva: rekurzió - objektumok vagy metódusok osztályának meghatározására szolgáló módszer úgy, hogy először megad egy vagy több (általában egyszerű) alapesetet vagy metódust, majd ezek alapján meghatározza a definiált osztály létrehozásának szabályait. Deutsch Péter Deutsch Péter

Iteráció embertől.

A rekurzió Istentől van.

Rekurzió a fizikában Rekurzió a nyelvben és az irodalomban A végtelen rekurzió klasszikus példája az két egymással szemben elhelyezett tükör: tükrök halványuló tükröződéseinek két folyosója alakul ki bennük. A végtelen rekurzió másik példája az öngerjesztő hatás (pozitív Visszacsatolás) nál nél elektronikus áramkörök erősítés, amikor a kimenetről érkező jel eléri a bemenetet, felerősítik, újra eléri az áramkör bemenetét, és ismét felerősítik. Azokat az erősítőket, amelyeknél ez a működési mód szabványos, önoszcillátoroknak nevezzük. Példa egy rekurzív szótári bejegyzésre: "A papnak volt egy kutyája..." - tipikus rekurzió Stanislav Lem számos története végtelen rekurzióval járó eseményekről szól: Egy történet a sepulksról ("Csendes János csillagnaplói") , amelyben a hős egymás után lép át a sepulkokról szóló cikkről a sepulációról szóló cikkre, onnan pedig a sepulcariáról szóló cikkre, amelyben ismét a "sepulcaria" cikkre hivatkozik. Történet egy racionális gépről, amely elég okos és lusta volt ahhoz, hogy egy hasonlót építsen, hogy megoldja a feladatot, és rábízza a megoldást (az eredmény egy végtelen rekurzió volt, amikor minden új gép megépítette a saját hasonlót, és áthelyezte a feladatot azt). A programozásban a rekurzió egy olyan számítási folyamat megszervezésének módja, amelyben egy eljárás vagy függvény önmagára hivatkozik az alkotó utasítások végrehajtása során. Ahhoz, hogy egy ilyen hívás ne legyen végtelen, az alprogram szövegének tartalmaznia kell egy olyan feltételt, amelynek elérésekor nem történik további hívás. így egy rekurzív hívás csak az alprogram egyik ágába foglalható bele. Példa. Természetes szám faktoriálisának kiszámítása Készítsen rekurzív függvényt, amely az n szám faktoriálisát a következőképpen számítja ki: f függvény (n: integer): longint; kezdődik, ha n = 1, akkor f:= 1 else f:= n * f(n -1); (f függvény meghívja magát) Pascal program vége rekurziót használva: Var n: integer; a:longint; függvény faktoriális(n: integer): longint; kezdődik, ha n = 1, akkor faktoriális:= 1 else faktoriális:= n * faktoriális (n -1); vége; Begin Write('n='); readln(n); A:=faktoriális(n); Write('n!=',a); readln; vége. Leonardo Pisan Fibonacci

A Fibonacci-számok egy numerikus sorozat elemei

0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, ..., amelyben minden következő szám egyenlő az előző kettő összegével.

Feladat: Jelenítsen meg egy Fibonacci-szám sorozatot a képernyőn, amely n elemből áll. A változók leírása: n a sorban lévő elemek száma; a, b a sorozat utolsó két elemének értékei; c egy puffer ("tartalék") változó; i - számláló. A feladat megoldásának algoritmusa: 1. Kapja meg n értékét! 2. Rendelje meg a és b értékét 0 és 1 értékkel (ezek a Fibonacci sorozat első számai). Vigye őket a képernyőre. 3. A 3. elemtől kezdve n-ig: a) jelenítse meg a és b összegét, b) tárolja a b változó értékét c-ben, c) írja be a és b összegét b-be, d) rendelje hozzá a c-től a. Pascal program iterációt használva: program Fibonacci; var a,b,c,i,n: egész szám; kezdődik write("n = "); readln(n); a:=0; írj egy," "); b:= 1; írás(b," "); mert i:=3-tól n-ig kezdjük írás(a+b," "); c:=b; b:= a + b; a:=c; vége; readln; vége. Pascal program rekurziót használva: A Fibonacci-számok kiszámításának rekurzív definíciója a következő: A Fibonacci-számok definíciója könnyen átalakítható rekurzív függvénnyel: függvény f(n: Integer) : longint; kezdődik, ha n<= 1 Then f:= n else f:= f(n– 1) + f(n - 2); end; Program chislaFibonacci; var n,i: integer; a: longint; function fib (n: integer): longint; begin If n <= 1 Then fib:= n else fib:= fib(n– 1) + fib(n - 2); End; begin write(‘n=’); readln(n); for i:=0 to n do begin A:= fib (n); write (‘ ’,a); end; readln; end. Домашнее задание Написать программу нахождения НОД двух натуральных чисел, используя алгоритм Евклида и рекурсию Даны два натуральных числа AÉs b. Ha A= b, akkor node( A,b)=a. Ha A>b, akkor node( A,b)= csomópont ( a -b,b). Ha A< b, akkor node( A,b)= csomópont ( A,b-a). Program noddvyxchisel; var a,b: longint; függvény nod(a,b:longint): longint; begin If a = b Akkor bólogat:= a else if a>b then nod:= nod(a-b,b) else nod:= nod(a,b-a) End; begin write('a='); readln(a); write('b='); readln(b); A:=nod(a,b); write('nod=',a); readln; vége. Hanoi tornyai probléma. Ebben az esetben szigorúan be kell tartani a következő szabályokat:

Egyszerre csak egy lemez mozgatható;
nagyobb lemezt nem lehet kisebb lemezre helyezni;
az eltávolított lemezt fel kell helyezni bármelyik kapaszkodóra, mielőtt egy másik lemezt eltávolítanak.

A három gyémánttorony egyikén 64 kerek aranykorong van. A tárcsák különböző sugarúak, és a toronyon helyezkednek el, a sugarak csökkenő sorrendjében az alaptól felfelé. A lemezeket át kell vinni az első toronyból a másodikba, szükség esetén a harmadik torony használatával.

Feladat. Írjon egy rekurzív programot, amely megoldja a fenti Hanoi tornyok problémáját n lemezzel (n = 1, 2, …). Megoldás. Adja meg a tornyok nevét: a, b, c. Hadd hanoi(n,a,b,c) a kívánt függvény, amely visszaadja a lemezek eltolási sorrendjét a tovább b segítségével c a fenti szabályok szerint. n=1 esetén meg tudjuk oldani a feladatot. Csak el kell végeznie a „mozgatás” műveletet a tovább b". Tegyük fel, hogy ezt a problémát meg tudjuk oldani n - 1 lemezekre. Mozgassunk n-1 lemezt ezzel a tovább Val vel. Ezután helyezze át a megmaradt meghajtót a tovább bés végül mozgass n-1 lemezt azzal c tovább b. Beviteli adat: a korongok száma az a; Kimenet: szekvenálás; Step0: (a változók típusának meghatározása); 1. lépés: (a hanoi eljárás leírása, amely egy műveletsorozatot ad ki); 1.1. lépés: (n-1 korong áthelyezése az a pontról a b pontra); 1.2. lépés: (n-edik lemez áthelyezése a-ból c-be); 1.3. lépés: (n-1 lemez áthelyezése b-ből c-be); (az 1.2-1.3 lépéseket rekurzívan hajtjuk végre); Step2:(főprogram); 2.1. lépés: (a lemezek számának megadása); 2.2. lépés: (a hanoi eljárás meghívása). Problémamegoldás Pascal Programban bahnya; varn: integer; a,b,c: char; eljárás hanoi(n: integer;a,b,c: char); kezdődik, ha n>0, akkor kezdődik hanoi(n-1,a,c,b); writeln ("Peremestit disk so sterzhnya ",a," na sterzhen" ",b); hanoi(n-1,c,b,a); end; end; Begin write ("Vvedite naturalnoe chislo n"); readln ( n); a:="a"; b:="b"; c:="c"; hanoi (n,a,c,b); readln; end. Házi feladat Írjon programot a fok természetes kitevővel történő kiszámításához Adott: fokozati alap x Kitevő Nak nek Ha k=0, akkor fok(k,x)=1, Egyébként fok(k,x)=x fok(k-1,x) Program stepen; variál: valódi; n: egész szám függvény lépés(k:egész, x:valós): valós; begin Ha k = 0 Akkor step:= 1 else step:= x * step(k-1,x) End; begin write('vvedite Foundation stepeni x='); readln(y); write('vvedite pokazatel stepeni k='); readln(n); write('x v stepeni k=', step(n, y)); readln; vége. Önálló munkavégzés

Keresse meg egy szám számjegyeinek összegét
Határozza meg, hogy egy adott természetes szám prím-e
Keresse meg egy szám első számjegyét
Természetes szám konvertálása decimális s.s-ből. binárisra
Határozzuk meg egy 20 elemből álló egész tömb elemeinek összegét!
Cserélje fel két egész szám értékét
Rendezze három változó értékét! a, b, c növekvő sorrendben
Határozzuk meg egy n természetes szám számjegyeinek számát!
Keresse meg a három megadott szám közül a legnagyobbat!
Határozza meg a pozitív számok számát négy A, B, C, D közül

Önálló tanulási válaszok #2. Program egyszerű; var n, m, s: egész szám; függvény prost(m, n:integer): logikai érték; kezdődik Ha n = m Akkor prost:= igaz else prost:= (n mod m<>0) és egyszerű (m+1, n); vége; begin write('n='); readln(n); M = 2; Ha prost(m,n) then write (n,'prostoechislo') Else write (n,'összetétel'); readln; vége.

programfordítás;

eljárás dvd(n:longint);

Ha n >1 Akkor dvd(n div 2);

write(n mod 2);