Rekursion i Pascal Lärare: Tlekhurai Yu.V. Kommunal läroanstalt "Lyceum nr 8" Vad ser du på målningarna? Detta fenomen i konsten kallas rekursion "För att förstå rekursion måste du först förstå rekursion." rekursion - partiell definition av ett objekt genom sig självt, definition av ett objekt med tidigare definierade. Vetenskapligt sett: Rekursion - en metod för att definiera en klass av objekt eller metoder genom att först specificera ett eller flera (vanligtvis enkla) av dess grundläggande fall eller metoder, och sedan specificera på grundval av dessa reglerna för att konstruera klassen som definieras. Peter Deutsch Peter Deutsch

Mänsklig iteration.

Rekursionen kommer från Gud.

Rekursion i fysik Rekursion i språk och litteratur Ett klassiskt exempel på oändlig rekursion är två speglar placerade mitt emot varandra: två korridorer bildas i dem från blekande reflektioner av speglar. Ett annat exempel på oändlig rekursion är självexciterande effekt (positiv respons) y elektroniska kretsar få, när signalen från utgången når ingången, förstärks, når återigen kretsens ingång och förstärks igen. Förstärkare för vilka detta driftläge är standard kallas självoscillatorer. Ett exempel på en rekursiv ordbokspost: "Prästen hade en hund..." - typisk rekursion Flera berättelser av Stanislaw Lem ägnas åt incidenter med oändlig rekursion: En berättelse om gravar ("The Star Diaries of John the Quiet"), där hjälten successivt går från en artikel om gravar till en artikel om sepulcaria, därifrån till en artikel om sepulcaria, som återigen innehåller en referens till artikeln "sepulcaria". En berättelse om en intelligent maskin som hade tillräckligt med intelligens och lättja för att bygga en liknande för att lösa ett givet problem och anförtro lösningen till det (resultatet blev en oändlig rekursion, när varje ny bil byggde en liknande henne själv och lämnade över uppgiften till henne). Rekursion i programmering är ett sätt att organisera en beräkningsprocess där en procedur eller funktion refererar till sig själv under exekveringen av dess ingående operatörer. För att ett sådant samtal inte ska vara oändligt måste texten i subrutinen innehålla ett villkor vid framkomst som inget ytterligare samtal inträffar. sålunda kan ett rekursivt samtal endast inkluderas i en av subrutinens grenar. Exempel. Beräkna faktorialet för ett naturligt tal Skapa en rekursiv funktion som beräknar faktorialet för talet n enligt följande: funktion f (n: heltal): longint; börja om n = 1 då f:= 1 annars f:= n * f(n -1); (funktion f kallar sig själv) avsluta Pascal-programmet med rekursion: Var n: heltal; a: longint; funktionsfaktoriell (n: heltal): longint; börja om n = 1 då faktoriell:= 1 annars faktoriell:= n * faktoriell (n -1); Slutet; Börja skriva('n='); Läsln(n); A:= faktorial(n); Skriv('n!=',a); Läsln; slutet. Leonardo från Pisa Fibonacci

Fibonacci-tal är element i en talföljd

0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, ..., där varje efterföljande tal är lika med summan av de två föregående.

Uppgift: Visa en serie Fibonacci-tal som består av n element. Beskrivning av variabler: n – antal element i serien; a, b - värden för de två sista elementen i serien; c – buffertvariabel (“reserv”); i – räknare. Algoritm för att lösa problemet: 1. Få värdet på n. 2. Tilldela a och b värdena 0 respektive 1 (detta är de första siffrorna i Fibonacci-serien). Visa dem på skärmen. 3. Börja från det 3:e elementet till n: a) visa summan av a och b, b) lagra värdet av variabeln b i c, c) skriv summan av a och b till b, d) tilldela värdet av c till a. Pascal-program som använder iteration: programmet Fibonacci; var a,b,c,i,n: heltal; Börja skriv("n = "); readln(n); a:= 0; Skriv en," "); b:= 1; skriv(b," "); för i:=3 till n börjar skriv(a+b," "); c:= b; b:= a + b; a:=c; slutet; readln; slutet. Pascal-program som använder rekursion: Den rekursiva definitionen för att beräkna Fibonacci-tal är följande: Denna definition av Fibonacci-tal kan enkelt omvandlas till en rekursiv funktion: funktion f(n: Heltal): longint; börja Om 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 Och b. Om A= b, sedan nod ( A,b)=a. Om A>b, sedan nod ( A,b)= nod ( a -b,b). Om A< b, sedan nod ( A,b)= nod ( A,b-a). Program noddvyxchisel; var a,b: longint; function nod(a,b:longint): longint; börja Om a = b Då nicka:= a annat om a>b då nicka:= nicka (a-b,b) annars nicka:= nicka (a,b-a) Slut; börja skriva('a='); readln(a); skriv('b='); readln(b); A:= nick(a,b); skriv('nicka=',a); readln; slutet. Problem om Towers of Hanoi. I det här fallet måste följande regler följas strikt:

• Du kan bara flytta en disk åt gången;
• större disk kan inte placeras på mindre disk;
• den borttagna skivan måste sättas på valfritt stift innan den andra skivan tas bort.
Hårt arbetande buddhistiska munkar bär skivor från spira till spira dag och natt. Legenden hävdar att när munkarna avslutar sitt arbete, kommer världens undergång att komma. Man skulle kunna räkna ut att lösa ett problem med 64 diskar skulle kräva 264–1 drag. Därför, när det gäller världens undergång, kommer det att inträffa efter fem miljarder århundraden, om vi betänker att en skiva rör sig på en sekund. Men både problemet och legenden för det uppfanns 1883 av matematikern Edouard Lucas från College of Saint-Louis.

En av de tre diamantspirorna bär 64 runda guldskivor. Skivorna har olika radier och är placerade på spiran i fallande radieordning från bas till topp. Det är nödvändigt att överföra skivorna från den första spiran till den andra, använd den tredje spiran om det behövs.

Uppgift. Skapa ett rekursivt program som skulle lösa problemet ovan om Towers of Hanoi med antalet diskar lika med n (n = 1, 2, ...). Lösning. Låt oss ange namn på spirorna: a, b, c. Låta hanoi(n,a,b,c)- den nödvändiga funktionen som returnerar sekvensen av rörelser av diskar med a på b använder sig av c enligt ovan beskrivna regler. När n=1 vet vi hur vi ska lösa problemet. Du behöver bara utföra "flytta"-operationen a på b" Låt oss anta att vi kan lösa detta problem för n – 1 diskar. Flytta n–1-skivor från a på Med. Flytta sedan den återstående disken från a på b och slutligen flytta n–1-skivor från c på b. Indata: antal skivor på pinne a; Produktion: sekvensering; Steg0:(definiera variabeltyp); Steg 1: (beskrivning av hanoi-proceduren, som visar sekvensen av åtgärder); Steg 1.1:(flytta (n-1) skivor från pinne a till pinne b); Steg 1.2:(flytta den n:te skivan från a till c); Steg 1.3:(flytta (n-1) skiva från b till c); (steg 1.2-1.3 utförs rekursivt); Steg 2:(huvudprogram); Steg 2.1:(ange antalet diskar); Steg 2.2: (anropar hanoi-proceduren). Lösa problemet i Pascal Program bahnya; var n: heltal; a,b,c: char; procedur hanoi(n: heltal;a,b,c: char); börja om n>0 börjar då hanoi(n-1,a,c,b); writeln ("Peremestit disk so sterzhnya ",a," na sterzhen" ",b); hanoi(n-1,c,b,a); slut; slut; Börja skriva ("Vvedite naturalnoe chislo n"); readln ( n); a:="a"; b:="b"; c:="c"; hanoi (n,a,c,b); readln; end. Läxor Skriv ett program för att beräkna examen med en naturlig exponent Given: gradbas X Exponent Till Om k=0, då grad(k,x)=1, annars grad(k,x)= x· grad(k-1,x) Program stepen; var y: verklig; n:heltal; funktionssteg(k:heltal, x:real): verklig; börja Om k = 0 Då steg:= 1 annat steg:= x * steg(k-1,x) Slut; börja skriva('vvedite osnovanie stepeni x='); readln(y); write('vvedite pokazatel stepeni k='); Läsln(n); skriv('x v stepeni k=',steg(n,y)); readln; slutet. Självständigt arbete

• Hitta summan av siffrorna i ett tal
• Bestäm om ett givet naturligt tal är primtal
• Hitta den första siffran i ett nummer
• Konvertera naturligt tal från decimal s.s. till binär
• Hitta summan av elementen i en heltalsmatris som består av 20 element
• Byt ut värdena för två heltal
• Beställ värdena för tre variabler a, b, c i stigande ordning
• Hitta antalet siffror i naturligt nummer n
• Hitta det största av tre givna tal
• Hitta antalet positiva tal bland fyra A, B, C, D

Svar för självständigt arbete nr 2 Program enkelt; var n, m, s: heltal; funktion prost(m, n:heltal): boolean; börja Om n = m Då prost:= true else prost:= (n mod m<>0) och prost (m+l, n); Slutet; börja skriva('n='); Läsln(n); M:=2; Om prost(m,n) så skriv (n,’prostoechislo’) Annars skriv (n,’sostavnoe’); readln; slutet.

programöversättning;

procedure dvd(n:longint);

Om n >1 Då dvd (n div 2);

skriv(n mod 2);

Subrutiner Ofta kräver en uppgift att du upprepar en viss sekvens av påståenden i olika delar av programmet. För att beskriva denna sekvens en gång och tillämpa den många gånger, använder programmeringsspråk subrutiner. En subrutin är ett specialdesignat block av ett program för dess efterföljande upprepade användning i huvudprogrammet. Användningen av subrutiner låter dig implementera en av de modernaste programmeringsmetoderna - strukturerad programmering

Subrutiner löser tre viktiga problem som i hög grad underlättar programmeringen: 1. de eliminerar behovet av att upprepade gånger upprepa liknande fragment i programtexten, d.v.s. minska storleken på programmet; 2. kommer att förbättra programmets struktur, vilket gör det lättare att förstå när man analyserar; 3.minska sannolikheten för fel, öka motståndet mot programmeringsfel och oförutsedda konsekvenser under modifiering.

Procedurer och funktioner Det finns två typer av subrutiner i Pascal: procedur (PROCEDURE) och funktion (FUNCTION). Procedurer och funktioner i Pascal deklareras i deklarationsdelen bakom variabeldelen. ProgramProgramName; VAR ... // avsnitt för att beskriva variabler i huvudprogrammet; procedur ProcedureName; var ... begin ...//Procedur body end; start //body av huvudprogrammet slut.

Funktioner och procedurer har parametrar (variabler som passerar ett värde). De är av två typer: 1) Formella - de som finns i beskrivningen av subrutinen 2) Faktiska - de som överförs från huvudprogrammet till en funktion eller procedur. De faktiska parametrarna måste motsvara de formella i kvantitet, ordning och typ.

Procedurer Procedurer används när en subrutin behöver få flera resultat. Det finns två typer av procedurer i Pascal: procedurer med parametrar och utan parametrar. En procedur nås av procedurnamnet, som kan följas av faktiska parametrar. När en procedur anropas upprättas en en-till-en-överensstämmelse mellan de faktiska och formella parametrarna, sedan överförs kontrollen till proceduren. Efter att proceduren har utförts överförs kontrollen till nästa operatör av det anropande programmet efter att proceduren har anropats.

Exempel 1: En procedur utan parametrar som skriver ut en sträng med 60 stjärnor. förfarande pr; var i: heltal ; börja för i:=1 till 60 skriv (* "); skrivln; slut; börja pr; slut.

Exempel 2. Skapa ett program för att byta två nummer c=5 och d=7 program obmenDan; var c,d:heltal; procedurutbyte (a,b:heltal); var m:heltal; börja m:=a; a:=b; b:=m; skrivln(a,b); slutet; begin writeln("Ange 2 siffror: "); readln(c,d); utbyte(c,d); writeln(c," ",d); slutet. c5 d 7 a 5 b 7 1) när obmen-proceduren anropas med två parametrar 5 och 7, placeras samma nummer 5 och 7 i variablerna a respektive b: 2) sedan i proceduren värdena för minnesceller a och b är omarrangerade: c5 d 7 a 7 b 5 3) men i variablerna c och d har data inte ändrats, eftersom de finns i andra minnesceller

För att variablerna c och d, a och b ska hänvisa till samma minnesceller (om värdena på a och b ändras, kommer värdena på c, d också att ändras), när man beskriver formella parametrar, är nödvändigt för att lägga till ordet VAR före de nödvändiga variablerna: procedurutbyte (var a,b:heltal); с5 d 7 a b

Exempel 3. Givet 3 olika arrayer av heltal (storleken på var och en överstiger inte 15). I varje matris, hitta summan av elementen och det aritmetiska medelvärdet. program proc; var i, n, summa: heltal; sr: verklig; procedurarbete (r:integer; var s:integer; var s1:real); var mas: array av heltal ; j:heltal; börjar s:=0; för j:=1 till r börjar läsas (mas[j]); s:=s+mas[j]; slutet; sl:=s/r; slutet;

(huvudprogram) börja för i:=1 till 3, börja skriva ("Vvedite razmer",i, "masiva: "); readln(n); arbete(n, summa, sr); (samtalsprocessarbete) writeln ("Summa elementov = ",summa); writeln("Srednearifmeticheskoe = ",sr:4:1); slutet; slutet.

Resultat av programmet: Programmet anropar arbetsproceduren tre gånger, där de formella variablerna r, s, s1 ersätts med faktiska n, summa, sr. Proceduren matar in matriselement, beräknar summan och medelvärdet. Variablerna s och s1 returneras till huvudprogrammet, så tjänsteordet var placeras före deras beskrivning. Lokala parametrar mas, j är endast giltiga i proceduren. Global - i, n, summa, sr är tillgängliga genom hela programmet.

Funktioner i Pascal Uppsättningen av inbyggda funktioner i Pascal-språket är ganska bred (ABS, SQR, TRUNC, etc.). Om en ny, icke-standardiserad funktion ingår i programmet, måste den beskrivas i programtexten, varefter den kan nås från programmet. En funktion nås till höger om tilldelningsoperatören, som anger funktionsnamn och faktiska parametrar. En funktion kan ha sina egna lokala konstanter, typer, variabler, procedurer och funktioner. Beskrivningen av funktioner i Pascal liknar beskrivningen av procedurer.

Exempel 4. Skriv en subrutinfunktion av grad a x, där a, x är valfria tal. Låt oss använda formeln: a x = e x l i ett program p2; var f, b, s, t, c, d: verklig; (globala variabler) funktion stp (a, x: real) : real; var y: verklig; (lokala variabler) börjar y:= exp (x * ln (a)); stp:= y;(tilldela ett funktionsnamn till resultatet av subrutinberäkningar) end; (funktionsbeskrivning färdig) start d:= stp (2.4, 5); (beräkna potenser för olika tal och variabler) writeln (d, stp (5,3.5)); läs (f, b, s, t); c:= stp (f, s) + stp (b, t); skrivln(c); slutet.

Funktioner En subrutin är en del av ett program, utformad som en separat syntaktisk struktur och försedd med ett namn (ett oberoende programblock), för att lösa individuella problem. Beskrivning av proceduren: procedure () (avsnitt för exekvering av lokala namn) Start (avsnitt för exekverande operatörer) Slut; Funktionsbeskrivning: funktion (): typ; (avsnitt för att beskriva lokala namn) Start (avsnitt för körbara satser) := ; (obligatorisk parameter) Slut; Proceduranrop: (); Funktionsanrop: := (); 1. På höger sida om uppdragsoperatören. 2. I uttrycket i förgreningsoperatörens tillstånd. 3. I utmatningsproceduren, som ett resultat av funktionen. Beskrivning av subrutiner Procedurer

Rekursion Procedurer och funktioner i Pascal kan kalla sig, d.v.s. har egenskapen rekursivitet. En rekursiv funktion måste nödvändigtvis innehålla ett villkor för att avsluta rekursivitet för att inte få programmet att gå i loop. Varje rekursivt anrop skapar en ny uppsättning lokala variabler. Det vill säga variabler som ligger utanför den anropade funktionen ändras inte.

1 funktion f (n: heltal): heltal; börja om n = 1 då f:= 1 annars f:= n * f (n -1); (funktion f anropar sig själv" title="Exempel 5. Skapa en rekursiv funktion som beräknar fakulteten för talet n enligt följande: n! = 1 om n= 1 n!= (n -1)! · n om n > 1 funktion f (n: heltal): heltal; börja om n = 1 så f:= 1 annars f:= n * f (n -1); (funktion f kallar sig själv" class="link_thumb"> 19 !} Exempel 5. Skapa en rekursiv funktion som beräknar fakulteten för talet n enligt följande: n! = 1 om n= 1 n!= (n -1)! · n om n > 1 funktion f (n: heltal): heltal; börja om n = 1 då f:= 1 annars f:= n * f (n -1); (funktion f kallar sig själv) end; 1 funktion f (n: heltal): heltal; börja om n = 1 då f:= 1 annars f:= n * f (n -1); (funktion f kallar sig"> 1 funktion f (n: heltal): heltal; börja om n = 1 så f:= 1 annars f:= n * f (n -1); (funktion f anropar sig själv) slut; " > 1 funktion f (n: heltal): heltal; börja om n = 1 så f:= 1 annars f:= n * f (n -1); (funktion f kallar sig" title="Exempel 5) Skapa en rekursiv funktion som beräknar faktorn för talet n enligt följande: n = 1, om n= 1 n!= (n -1) n, om n > 1 funktion f (n: heltal): heltal; börja om n = 1 då f:= 1 annars f:= n * f (n -1); (funktion f kallar sig själv"> title="Exempel 5. Skapa en rekursiv funktion som beräknar fakulteten för talet n enligt följande: n! = 1 om n= 1 n!= (n -1)! · n om n > 1 funktion f (n: heltal): heltal; börja om n = 1 då f:= 1 annars f:= n * f (n -1); (funktion f anropar sig själv"> !}

Bild 1

Bild 3

Subrutiner: globala och lokala variabler Alla subrutiner måste beskrivas i beskrivningsdelen. Varje subrutin måste ha ett namn. Information mellan huvudprogrammet och subrutinerna överförs av globala parametrar (variabler) som fungerar i vilken del av programmet som helst och har ett namn som beskrivs i huvudprogrammet. Lokala parametrar (variabler) kan användas i en subrutin - deras namn och värden har betydelse endast inom gränserna för en given subrutin och är inte tillgängliga för det anropande programmet

Bild 4

Formella och faktiska parametrar I beskrivningen av subrutiner anges parametrar endast med namn, så de kallas formella. De har ingen betydelse förrän subrutinen anropas. De reserverar endast utrymme för de faktiska parametrarna och bestämmer deras antal och datatyp. Typer av faktiska parametrar: Värdeparametrar anger vilket värde som ska tilldelas en specifik subrutinparameter. Efter att subrutinen har slutat antar de sina tidigare värden, även om de ändrades i subrutinen. Variabla parametrar i en subrutin ersätter formella, de kan ändra sitt värde under exekveringen av subrutinen och spara ändringarna när du lämnar subrutinen (variabelparametrar föregås av nyckelord Var).

Bild 5

Bild 6

Beskrivning av proceduren Program Pr1; Const...Type...Var...Procedur(); Beskrivande del Börja Procedur body Slut; Börja...(); ... slutet. När en procedur anropas ersätts de formella parametrarna med faktiska.

Bild 7

Proceduren för att beräkna summan av två tal program pr1; Usescrt; Var a,b,s:real; procedur summa(x,y:real;var z:real); börjar z:=x+y; slutet; börja clrscr; writeln("skriv in a,b"); readln(a,b); summa(a,b,s); writeln(" summa av siffror ",a:3:1," och ",b:3:1," = ",s:3:1); readln; slutet. x,y,z – formella parametrar, lokal variabler a,b,s– globala variabler a,b,s – faktiska parametrar x y z a b s Värdeparametrar Parametervariabel

Bild 8

Bild 9

Bild 10

Beräkna värdet på uttrycket a:=(3n!+2m!)/(m+n)! Vilken typ av variabler är lämpliga att använda för att hitta faktorn? program pr2; Usescrt; Var m,n,x,y,z:heltal; a:real; procedurfakta(d:heltal;var q:heltal); var i:heltal; börja q:=1; för i:=1 till d gör q:=q*i; slutet; börja clrscr; writeln("skriv in värden n, m"); readln(n,m); fakta(n,x); fakta(m,y); faktum(m+n,z); a:=(3*x+2*y)/z; writeln("värdet på uttrycket med m= ",m:4," och n= ",n:4,"är lika med",a:8:3); readln; slutet. N!=1·2·3·…· N

Bild 11

Inmatning av element i en endimensionell matris Funktionen Random(X) genererar ett slumpmässigt tal från 0 till X av heltal eller reell typ (innan funktionen anropas måste den initieras med hjälp av Randomize-proceduren). Om X-parametern inte anges kommer resultatet att vara av typen Real i intervallet från 0,0 till 1,0. För att erhålla en array av slumpmässiga heltal från intervallet slumpmässigt(B-A+1)+A Uppgift: Formulera inmatningen av element i en endimensionell array med hjälp av en slumptalsgenerator (värdeintervall från -10 till 20) och utmatning av element som en procedur. För A=-10 B=20 slumpmässigt(20-(-10)+1)+(-10)

Bild 12

Bild 13

Bild 14

Beskrivning av funktionen Funktioner är utformade för att bara beräkna ett värde, 1. Därför är dess första skillnad att proceduren kan ha nya värden för flera parametrar, men funktionen har bara en (det kommer att bli resultatet). 2. Den andra skillnaden är funktionstiteln. Den består av ordet FUNCTION, följt av namnet på funktionen, sedan en lista med formella parametrar inom parentes, följt av typen av funktionens resultat, separerade med ett kolon. 3. Funktionskroppen måste innehålla minst en tilldelningsoperator, där funktionsnamnet är på vänster sida och dess värde är på höger sida. Funktion (): Beskrivande Start Funktion body:=; Slutet;

Bild 15

Beräkna värdet på uttrycket a:=(3n!+2m!)/(m+n)! program fn2; Usescrt; Var m,n:heltal; a:real; funktionsfakta(d:heltal) :longint; var i:heltal; q:longint; börja q:=1; för i:=1 till d gör q:=q*i; faktum:=q; slutet; börja clrscr; writeln("skriv in värden n, m"); readln(n,m); a:=(3*fakta(n)+2*fakta(m))/fakta(m+n);; writeln("värdet på uttrycket med m= ",m:4," och n= ",n:4,"är lika med",a:8:3); readln; slutet.

Bild 16

Skapa ett program som hittar ab, det vill säga den b:te potensen av talet A, där A och B är heltal och B>0, inmatat från tangentbordet. Komponera ett program genom att ersätta funktionen med procedurprogrammet pr2; Usescrt; Var a,b:heltal; c:longint; Funktion stepen(x,y:heltal):longint; var i:heltal; s:longint; börjar s:=1; för i:=1 till y gör s:=s*x; steg:=s; slutet; börja clrscr; writeln("ange värden a, b"); readln(a,b); C:=steg(a,b); writeln("s=",s); readln; slutet.

Bild 17

Bild 18

Mekanism för att överföra parametrar till funktioner och procedurer Vad kommer att skrivas ut av proceduren och vad av programmet? Globala variabler Lokala variabler a b 3 3 -3 Adress c a b c 48 Adress c A:=b+3 B:=3*a C:=a+b Tillstånd C 24 5 8 Svara

Bild 19

8: e klass. Programmering i ABC Pascal

Informatiklärare vid NIS i Uralsk fysik och matematik Zelenov Boris Aleksandrovich

• Eleverna använder procedurer och funktioner för att lösa problem
• Eleverna lär sig att lösa stora problem genom att dela upp dem i mindre

• Utveckla ett koncept för procedurer och funktioner i ett programmeringsspråk.

• Eleverna känner till begreppen "procedurer" och "funktioner", bestämmer formella och faktiska parametrar

Förväntade resultat - Beskrivningar:

1.Känner till definitionen av "förfarande"

2.Känner till definitionen av "funktion"

3. Bestämmer faktiska och formella parametrar

4. Skiljer mellan värde och variabla parametrar

5. Hittar ett anrop till en procedur eller funktion i programkod

Elviras standardplan

1. Ta bort papper

2. Vattna blommorna

3. Tvätta skrivborden

4. Torka av glaset

Slutet på algoritmen

Hur kan man förbättra organisationen av denna process?

Lektionens ämne

Subrutiner:

Ishki bagdarlama

Subrutin

Procedur

Procedur

Parameterlare

Användbara fraser:

För att skicka variabla värden till en procedur (funktion) används faktiska parametrar...

För att beskriva proceduren bör du först..., sedan...

Konceptet med en subrutin

Definition

Subrutin– Det här är en separat funktionellt oberoende del av programmet.

Subrutiner

Förfaranden

• eliminera behovet av att upprepade gånger upprepa liknande fragment i programtexten;
• förbättra programmets struktur, vilket gör det lättare att förstå;
• öka motståndet mot programmeringsfel och oförutsedda konsekvenser under programändringar.

• Rita ett staket med hjälp av ett programmeringsspråk

I den här uppgiften kan du skapa en procedur som kommer att utföra algoritmen för att rita ett fragment (stängsel) och sedan ständigt hänvisa till denna procedur och ändra pennans initiala position

• Beskriv hur man effektivt ritar en julgran i en programmeringsmiljö

• De är fristående programfragment, designade på ett speciellt sätt och med ett eget namn.

Interaktion mellan huvudprogrammet och subrutinen

Blockdiagram

• Subrutin (procedur eller funktion) anropsblock

Subrutinnamn (procedur eller funktion).

Blockdiagram

Beskrivningen av proceduren är som följer:

procedur namn (lista över formella parametrar); beskrivningsavsnittet Börja operatörer slutet ;

Funktionsbeskrivningen ser ut så här:

fungera namn (lista över formella parametrar): returtyp;

beskrivningsavsnittet Börja operatörer slutet ;

Plats i programmet

Program ...;

//Description section Uses, Const, Var, ...

procedur A ;

Börja ....... slutet ;

procedur B ;

Börja ........ slutet ;

Funktion C ;

Börja ........ slutet ;

//Huvudprogram

Börja ........ slutet .

• Skillnaden mellan en funktion och en procedur är att resultatet av att utföra de operatorer som utgör funktionens kropp alltid är ett enda värde, så att anropa en funktion kan användas i lämpliga uttryck tillsammans med variabler och konstanter.

Förfaranden

Funktioner

Kan ha flera resultat eller utföra någon åtgärd

Har bara ett resultat, vars typ anges separat när funktionen deklareras.

Resultaten kan vara värden av vilken typ som helst - matriser, strängar, siffror, etc.

Resultatet kan bara vara ett värde av typen reellt, heltal eller char.

Proceduranropskommandot är ett separat kommando som kan användas oberoende

Ett funktionsanrop kan endast användas som en komponent i ett uttryck av lämplig typ.

Funktionskroppen måste innehålla minst en tilldelningsoperator med funktionsnamnet på vänster sida.

b sedan max:=a annat max:=b; MaxNumber:= max; end;" width="640"

Procedur eller funktion?

MaxNumber(a,b: heltal): heltal;

var max: heltal;

MaxNumber:= max;

b sedan max:=a annat max:=b; end;" width="640"

Procedur eller funktion?

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

om ab då max:=a annat max:=b;

Procedur eller funktion?

ChangeColor(C1, C2: Word);

TextBackGround(C2)

Procedur eller funktion?

Add(X, Y: Heltal): Heltal;

Faktisk

• Indikeras i huvudprogramsektionen

Formell

• Anges i subrutinen
• Anges i subrutinen

Proceduren anropas av en operatör med följande format:

procedurnamn (lista över faktiska parametrar);

• Lista över faktiska parametrar- det här är en lista över dem separerade med kommatecken.

• I språkstandarden Pascal kan parametrar skickas på två sätt - efter värde och genom referens. Parametrar som skickas av värde kallas parametrar-värden, godkänd genom referens - parametrar-variabler. De senare skiljer sig åt genom att de i procedurens (funktions) header föregås av tjänsteordet var.

Passerar parametrar. Formella parametrar

Variabler

Värderingar

Parametrar efter värde

Formella parametrar

Variabler

Formella parametrar

Parametrar efter värde

• I den första metoden (som passerar genom värde) kopieras värdena för de faktiska parametrarna till motsvarande formella parametrar.

Procedur

Procedurnamn (a, b: heltal);

Huvudprogram

När du ändrar dessa värden under exekveringen av en procedur (funktion), kan originaldata (faktiska parametrar) inte ändras

Var c, d: heltal;

• När man passerar genom referens leder alla ändringar som sker i kroppen av en procedur (funktion) med formella parametrar till omedelbara liknande förändringar i motsvarande faktiska parametrar.

Procedur

Procedurnamn (a, b: heltal, Var c: reell);

Huvudprogram

Ändringar sker i variablerna i det anropande blocket, så utdataparametrar skickas med referens. När de anropas kan deras motsvarande faktiska parametrar endast vara variabler.

Du skriver:

1. Faktiska parametrar___________

Procedur Kvad(R: real; var S: real);

2. Formella parametrar ___________

3. Formella parametrar-värden __________

5. Procedurnamn ___________

6. Åtkomst till en procedur från programmet __________________

Interaktiv uppgift

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

Elvira är klassledare. Hon kommer att behöva göra en plan för allmän städning i klassrummet: ta bort papper, vattna blommor, tvätta skrivbord, torka av glas. Hur kan hon bättre organisera sitt arbete? Hjälp Elvira.

Elviras avancerade plan

Subrutiner:

Arsen – lägger undan pappren

Mila - vattna blommor

Vitaly – tvättar skrivbord

Indira – torka av glaset

1. Kör Arsen

2. Kör Mila

3. Kör Vitaly

4. Kör Indira

Slutet på algoritmen

• Vilka nya programmeringsspråksstrukturer har vi mött idag?
• Namnge de studerade parametrarna

• Hur överförs parametrar till en procedur?

• Lektionssammanfattning

• Hitta definitioner: "Lokala variabler" och "Globala variabler"

• Komponera två uppgifter där du kan använda procedurer eller funktioner.

• Hur skulle du bestämma ämnet för lektionen? (kom på ditt eget namn)
• Vad tycker du att du ska lära dig i nästa lektion?

Låt oss träffas

nästa lektion!

Syftet med lektionen

pedagogisk

• att bland eleverna bilda en enhetlig begreppssystem relaterade till begreppen procedur och funktion;
• lära ut hur man använder subrutiner för att lösa problem i Pascal, och även lära sig att förstå vilken typ av subrutin som behövs när man löser ett visst problem;
• visa grundläggande tekniker för att använda subrutiner;

pedagogisk

• odla noggrannhet, uppmärksamhet, organisation;
• kultur av datorkunskaper;

utvecklande

• utveckla logiskt tänkande, algoritmisk kultur hos elever;
• utveckla kunskaper och färdigheter för att komponera och felsöka subrutiner i Pascal.

Studenter måste:

• känna till reglerna för att skriva procedurer utan parametrar och med parametrar;
• känna till reglerna för att skriva funktioner;
• kunna tillämpa procedurer och funktioner för att lösa enkla problem.

Under lektionerna

I. Org. ögonblick

II. Introduktion. Relevans

Ge ut uppgiften på lappar ( Bilaga 1 ). Hitta upprepningar.

Ibland på olika platser i programmet måste du utföra nästan samma sekvenser av åtgärder med olika initiala data. Sådana handlingssekvenser kan formaliseras i form av sk subrutiner (från engelska, subrutin) – gruppera operatörer i ett block som kan nås med namn och upprepade gånger.

Subrutiner förkortar texten i ett program, minskar avsevärt deras exekveringstid och gör livet lättare för programmerare som kan skapa program modulärt, det vill säga genom att sätta ihop ett komplext program från färdiga delar av enklare komponenter. Detta gör det möjligt för en grupp programmerare att skapa stora program och en grupp skolbarn att utveckla och implementera alla globala projekt

Subrutiner är indelade i procedurer och funktioner.

Inbyggda (standard) procedurer och funktioner finns del språk och kan kallas vid namn utan föregående beskrivning. Till exempel , abs, sqrt, ln, sin... är funktioner (retur ett resultat), readln, write... är procedurer (returnerar inte ett resultat). Deras närvaro underlättar i hög grad utvecklingen av applikationsprogram. Men i de flesta fall några specifik för detta åtgärdsprogram finns det inga direkta analoger i biblioteken Turbo Pascal, och sedan måste programmeraren utveckla sin egen icke-standard rutiner och funktioner.

III. Förklaring av nytt material

Användarprocedurer är skrivna oss själva programmerare i enlighet med syntaxen för språket i avsnitt för subrutinbeskrivning.

Strukturen för proceduren följer programmets struktur; det är ett "program i miniatyr" - det representeras också av en rubrik och en kropp.

Rubriken består av den reserverade ordproceduren, identifieraren (namn) förfaranden.

VAR ... // avsnitt för att beskriva variabler i huvudprogrammet

procedur ProcedureName;

//body av huvudprogrammet

Proceduranropet för efterföljande utförande registreras i huvuddelen av programmet.

Exempel 1. Program för att beräkna area och omkrets.

Fördelar med subrutiner:

• Program skrivna med hjälp av subrutiner lättare att testa och felsöka, de har en klarare logisk struktur.
• Den oberoende karaktären hos subrutiner gör att deras skapelse kan anförtros åt olika programmerare. På så sätt delas programmeringsarbetet upp och på så sätt påskyndas dess slutförande;
• Att använda subrutiner sparar minne. Minne för att lagra variabler som används i en subrutin tilldelas endast under dess drift och frigörs så snart dess exekvering slutar.

Exempel 2. Användaren matar in två sidor av tre rektanglar. Härleda deras områden.

Du kan lösa problemet så här:

för i:=1 till 3 do

writeln('Ange a och b:');

writeln(‘Area=’,a*b);

Det anses vara bra programmeringsstil att använda procedurer. En procedur behövs för att beräkna arean av en rektangel. Så här kommer huvudprogrammet att se ut schematiskt:

beräkning

beräkning

beräkning

Textproceduren finns redan (se exempel 1). Låt oss skapa en andra procedur som beräknar arean. Men för att kunna räkna ut S behöver du känna till 2 sidor, så proceduren måste visa vilka sidor den ska multiplicera.

procedur pl (c,d: heltal);

writeln('area av en rektangel med sidor',c, '',d, '=',S);

En parameter är en variabel som tilldelas ett värde. Existera formella parametrar , definierad i subrutinhuvudet, och faktiska parametrar – uttryck som anger specifika värden vid åtkomst till en subrutin.

Proceduren kommer att utföras om du kallar den vid namn och anger de faktiska parametrarna , separerade med kommatecken och inom parentes:

De faktiska parametrarna måste matcha de formella i typ och kvantitet.

Så, huvudprogrammet:

för i:=1 till 3 do

Kommentar. När du löser detta problem är det nödvändigt att kontrollera siffrorna som angetts av användaren (de får inte vara negativa, annars kommer programmet att avbrytas).

Låt oss skapa ett verifieringsförfarande:

procedurfel (f,g:heltal);

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

writeln('sidorna i en rektangel kan inte vara negativa');

stanna; // programavbrott

Sista programmet – Bilaga 4

Så formatet för proceduren:

Procedur<имя>(formella parametrar);

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

Exempel 3. Skriv ett program för att byta plats på två siffror c=5 och d=7.

programutbyteDan;

var c,d:heltal;

procedurutbyte (a,b:heltal);

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

writeln("Ange 2 siffror: ");

writeln(c," ",d);

Efter att ha startat programmet kan du se att de formella parametrarna (i proceduren) har bytt plats, men de faktiska (som används i huvudprogrammet) har inte ändrats. Låt oss titta på bilden som visar en del av RAM:et:

1) när obmen-proceduren anropas med två parametrar 5 och 7, placeras siffrorna 5 och 7 också i variablerna a respektive b:

3) men i variablerna c och d har data inte ändrats, eftersom de finns i andra minnesceller.

För variablerna c och d, a och b refererade till samma minnesceller (om värdena för a och b ändras, kommer värdena för c, d också att ändras) när man beskriver formella parametrar är det nödvändigt att lägga till ordet VAR före de nödvändiga variablerna:

procedurutbyte (var a,b:heltal);

Ändra obmenDan-programmet:

Fel på grund av var. Tal är konstanter som inte kan ändras i en procedur.

Exempel 4. Hitta arean av en cirkel med en procedur som bara beräknar men inte visar resultatet på skärmen.

procedurcirkel(r:real);

Proceduren bör returnera resultatet:

procedurcirkel (r:real; var S:real);

readln(a, e);

Kommentar: Variabeln i procedur S används för att returnera resultatet av proceduren till huvudprogrammet. När den ändras ändras även den faktiska parametern i det anropande programmet, d.v.s. variabel e.

Oftare, för detta i Pascal, istället för procedurer, används funktioner (subrutiner som returnerar något).

Funktionen liknar proceduren, men det finns två skillnader.

• Funktionen överför resultatet av sitt arbete till programmet - ett enda värde, vars bärare är namnet på dess funktion.
• Funktionsnamnet kan visas i ett uttryck som en operand. Funktionen returnerar resultatet till anropspunkten.

Till exempel, sqr(x) – kommer att kvadrera värdet x och returnera det beräknade värdet på kvadraten av talet x till anropspunkten: y:=sqr(x);

En användardefinierad funktion består av en funktionshuvud och en funktionskropp. Funktionens kropp liknar programmets struktur. Beskrivning av etiketter, konstanter, typer osv. giltig endast inom ramen för detta förfarande.

Fungera<имя>(formella parametrar):<тип результата>;

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

Sektionen måste innehålla minst en sats som tilldelar ett värde till funktionsnamnet. Resultatet av det senaste uppdraget returneras till larmcentralen.

Exempel 5. Låt oss omarbeta problemet om arean av en cirkel.

funktionscirkel (r:real): verklig;

a:=cirkel(5); (MÅSTE tilldelas)

Exempel 6. Hitta 1!+2!+…+n!

Vi använder funktionen att hitta factorial, eftersom vi matar in den som en ingång och får resultatet.

funktionsfaktum (a:heltal): heltal;

för i:=1 att göra

I raden fakta:=faktum*I;

kompilatorn hittar ett fel, eftersom fakta måste anropas med parametrar. Därför introduceras vanligtvis en extra variabel i vilken resultatet placeras. Och sedan tilldelas detta resultat till faktavariabeln:

programfaktoriell;

var summa,n,j: heltal;

funktionsfaktum (a: heltal): heltal;

var i,d: heltal;

för i:=1 att göra

för j:=1 till n do

summa:=summa+fakta(j);

IV. Lektionssammanfattning

Vid denna tidpunkt förvandlas programmeringsprocessen till industriell mjukvaruproduktion baserad programmeringsteknik. Det är de flesta experter av åsikten top-down programdesignmetod bäst lämpad för att lösa komplexa problem. Först definieras uppgiften i allmänna termer, sedan förtydligas dess struktur gradvis. I nästa steg delas varje deluppgift i sin tur upp i ett antal andra. Lösningen på ett separat fragment av ett komplext problem är ett oberoende programblock - en subrutin.

V. Läxor

Lös problem (skriftligt):

1. Skapa en procedur som ersätter alla bokstäverna a i den angivna strängen med *.
2. Två förslag ges. Hitta det totala antalet bokstäver "n" i dem. (Definiera en funktion för att beräkna antalet bokstäver "n" i en mening.)