Typer av sykluser

løkker med parameter til

løkker med forutsetning

syklus samtidig som med forutsetning

syklus gjenta - til med postcondition

Sløyfe med forutsetning i Pascal - MENS

En sløyfeoperatør med en forutsetning utfører handlinger et ukjent antall ganger. Sløyfen avsluttes hvis et logisk uttrykk eller resultatet viser seg å være usant.

Fordi lojalitet logisk uttrykk er krysset av i begynnelsen, kan det hende at selve sløyfen ikke utføres en gang.

Løkkestruktur SAMTIDIG SOM

Blokk - syklusdiagram SAMTIDIG SOM

operatør

betingelse

Eksempel

Oppgave: Skriv et program som beregner summen av alle partall opp til 50.

writeln("Summen er: ",sum);

Oppgave

Skriv et program som søker n!.

Sløyfe med postcondition i Pascal – REPEAT-TIL

Denne operatøren ligner sløyfeoperatøren med en forutsetning, men skiller seg fra den ved at betingelsen kontrolleres etter at sløyfens kropp (handlinger) er utført. Dette sikrer at det utføres minst én gang, i motsetning til tidligere analyserte løkker.

Vær oppmerksom på at denne operatøren syklus innebærer tilstedeværelse av flere operatører i syklusens kropp, det vil si at flere handlinger kan utføres, så tjenesteordene Begynne Og Slutt Ikke nødvendig.

Løkkestruktur

GJENTA-TIL

Blokk - syklusdiagram GJENTA-TIL

operatør

betingelse

Eksempel

Oppgave: Skriv et program som bestemmer summen av første og siste siffer i et tall.

a,b,c,d:heltall;

writeln("skriv inn et tall");

writeln('Summen av det første og siste sifferet er:'c);

Oppgave

Skriv et program som bestemmer om et tall er primtall.

Sløyfe med en parameter i Pascal - FOR

Syklus TIL setter betingelsen som programmet skal fungere under før det kjøres, la oss si at du trenger å loope programmet n ganger, så kan dette enkelt gjøres ved å bruke denne loopen.

U sykler TIL Det er et karakteristisk trekk - en teller, som vanligvis er betegnet med bokstaven i eller j.

I en sløyfe kan telleren spesifiseres enten direkte (tjenesteord til ), og i omvendt rekkefølge (funksjonelt ord ned til ).

Løkkestruktur TIL

FOR i:= n1 TIL n2 GJØR

1. opptaksskjema

FOR i:= n2 NED TIL n1 GJØR

2. opptaksskjema

Blokk - syklusdiagram TIL

i:= n1 … n2

Løkkekropp

Eksempel

Oppgave: Skriv et program som regner ut n-te potens av et gitt tall.

a, n, i, pr: heltall;

writeln('Skriv inn et tall');

writeln('Skriv inn potensen til tallet');

for i:= 1 til n do

writeln('Kraften til tallet er',pr);

Oppgave

Skriv et program som finner tallet P = (1-1/2)(1-1/3)*...*(1-1/n).

N legges inn fra tastaturet.

Sløyfe med en forutsetning Hvis antall repetisjoner er ukjent på forhånd, men spesifiseres kun av en betingelse, og en handling som må utføres først etter kontroll av betingelsen, bruk en loop med en forutsetning. Et logisk uttrykk brukes som betingelse, sløyfens kropp er en enkel eller sammensatt operator. Før hver utførelse av sløyfekroppen, kontrolleres tilstanden, hvis resultatet er "sant", så utføres løkkelegemet igjen, hvis "false", avsluttes løkken. På blokkskjemaet In Pascal begynner slutten; Tilstand Hoveddelen av sløyfen Nei Øv Start av sløyfen Slutten av sløyfen JA Mens gjør

Sløyfe med en postbetingelse Hvis antall repetisjoner er ukjent på forhånd, men spesifiseres kun av en betingelse, og handlingen som må utføres før kontroll av tilstanden, bruk en sløyfe med en postbetingelse. Et logisk uttrykk brukes som betingelse, sløyfens kropp er en enkel eller sammensatt operator. Etter hver utførelse av sløyfekroppen, blir tilstanden sjekket, hvis resultatet er "false", utføres løkkekroppen igjen, hvis "sant", avsluttes løkken. På blokkskjemaet I Pascal Gjenta Tilstand Loop Body Ja Nei Øv til ;

Sløyfe med parameter I tilfeller hvor antall repetisjoner er kjent på forhånd, benyttes en sløyfe med parameter. Variabelen som spesifiserer antall repetisjoner kalles en loop-parameter eller kontrollvariabel. Etter hver utførelse av sløyfekroppen økes eller reduseres kontrollvariabelen, sløyfen utføres til den overskrider eller blir mindre enn grensen. I blokkdiagrammet i Pascal er X kontrollvariabelen (syklusparameter) A er startverdien til X, B er sluttverdien av X C er trinnet for å endre X. Som et trinn kan du bare bruke: "til" = 1; “downto” = -1 X:=A,B,C Loop Body Practice For X:=A to B do Begin End;

Et eksempel på et problem ved bruk av en sløyfe med en forutsetning Hev tallet 3 til en gitt potens OPPGAVE: Verbal algoritme: Multipliser tallet X, i utgangspunktet lik 1, et gitt antall ganger (H) med 3. start H BHBH X: =1 X:=X*3 slutt X Angi de gitte gradene Startverdiene "B" gradteller B=B+1 Multiplisere med 3 Øke telleren Utgi den resulterende verdien Program Stepen; Var H,B,X:heltall; Begynn å skrive (grad?); Readln(H); X:=1; B:=1; Mens B

H X:=1 X:=X*3 slutt X Skriv inn en gitt potens Startverdier" title="Eksempel på en oppgave som bruker en løkke med en postbetingelse Hev tallet 3 til en gitt potens OPPGAVE: Verbal algoritme: Multipliser tallet X opprinnelig lik 1 gitt antall ganger (H) for 3. start N B>=H X:=1 X:=X*3 slutt X Angi en gitt grad Startverdier" class="link_thumb"> 8 !} Et eksempel på et problem med bruk av en sløyfe med en postbetingelse Hev tallet 3 til en gitt potens OPPGAVE: Verbal algoritme: Multipliser tallet X innledningsvis lik 1 et gitt antall ganger (H) med 3. start H B>=H X:= 1 X:=X*3 slutt X Legge inn en gitt grad Startverdier "B" gradteller B=B+1 Multiplisere med 3 Øke telleren Utgi den resulterende verdien Program Stepen; Var H,B,X:heltall; Begynn å skrive (grad?); Readln(H); X:=1; B:=0; Gjenta X:=X*3; B:=B+1; Inntil B>=H; Writeln(Resultat,X); Slutt. Nei Ja Pascal Teori Blokkdiagram Forklaringer B:=0 =H X:=1 X:=X*3 slutt X Angi en gitt grad Startverdier"> =H X:=1 X:=X*3 slutt X Angi en gitt grad Startverdier "B" gradteller B=B +1 Multipliser med 3. Øk telleren. Send ut den resulterende verdien Pascal Block Diagram Forklaringer B:=0"> =H X:=1 X*3 slutt X Angi den angitte graden Startverdier" title=" Eksempel på et problem med bruk av en sløyfe med en postbetingelse Hev tallet 3 til en gitt potens OPPGAVE: Verbal algoritme: Multipliser tallet X innledningsvis lik 1 et gitt antall ganger (H) med 3. begynnelse N B>=H X: =1 X:=X*3 slutt X Angi spesifisert grad Startverdier"> title="Et eksempel på et problem med bruk av en sløyfe med en postbetingelse Hev tallet 3 til en gitt potens OPPGAVE: Verbal algoritme: Multipliser tallet X, i utgangspunktet lik 1, et spesifisert antall ganger (H) med 3. start H B>=H X :=1 X:=X*3 slutt X Angi en gitt grad Startverdier"> !}

Et eksempel på en oppgave som bruker en sløyfe med parameteren Hev tallet 3 til en gitt potens OPPGAVE: Verbal algoritme: Multipliser tallet X, initialt lik 1, et spesifisert antall ganger (H) med 3. start H X:=1 X:=X*3 slutt X Angi en gitt potens Startverdi X=1 Parametre fra 1 til N Multiplikasjon med 3 Utgang av den resulterende verdien Programm Stepen; Var H,B,X:heltall; Begynn å skrive (grad?); Readln(H); X:=1; For B:=1 til H begynner X:=X*3; Slutt; Writeln(Resultat,X); Slutt. B:=1,H,1 Pascal Theory Block Diagram Forklaringer

Oppgave: Etter å ha startet treningen løp utøveren 10 km den første dagen. Hver dag økte han dagsnormen med 10 % av forrige dags norm. Hva er den totale distansen utøveren skal tilbakelegge på 7 dager? Inndatavariabler: Utdatavariabler: S – total bane d – antall dager Sd – avstand for gjeldende dag

Slutt Spørsmål for kontroll: 1. Hvilken operatør i Pascal definerer en sløyfe med en forutsetning 2. Hvordan spesifisere trinn “1” og “-1” i en parameter i en sløyfe 3. Hvilken gren følger sløyfen med en postbetingelse? 4. Er det en tilstandsparameter 5. Hva kan være kroppen til en sløyfe 6. Når en sløyfe med parametere brukes

Lysbilde 2

Plan

Konseptet med en loop Loop statement For Loop While Loop Repeat Litteratur

Lysbilde 3

Litteratur

Kastornov A.F., Evstratova G.A. Pascal programmeringsspråk: opplæringen for universiteter. - Cherepovets: State Educational Institution of Higher Professional Education ChSU, 2010. - 117 s. - Bibliografi: S.114. Elektronisk lærebok om Pascal-programmeringsspråket /http://pascal.guti.ru Plan

Lysbilde 4

Konseptet med en syklus

Algoritmer for å løse mange problemer er sykliske, for å oppnå resultatet spesifikk sekvens handlinger utføres flere ganger. For eksempel viser et kunnskapskontrollprogram et spørsmål, godtar svaret, legger til et merke for svaret til den totale poengsummen, og gjentar deretter disse handlingene til emnet svarer på alle spørsmålene. Eller for eksempel for å søke etter ønsket etternavn i listen, bør du sjekke det første etternavnet i listen for å se om det samsvarer med det søkte, deretter det andre, tredje osv. til ønsket etternavn er funnet eller slutten av listen er nådd.

Lysbilde 5

En algoritme der det er en gruppe setninger som utføres flere ganger kalles syklisk. Gruppen av gjentatte utsagn kalles løkkens kropp. I Pascal kan løkker implementeres ved å bruke For-, While- og Repeat-løkkesetningene. Plan

Lysbilde 6

For sløyfeoperatør

For loop-operatoren brukes når hoveddelen av loopen må utføres flere ganger, og antall repetisjoner er kjent på forhånd.

Lysbilde 7

1. form for å skrive For loop-operatøren

1. form for å skrive For-operatøren i generelt syn ser slik ut: ForCounter:=Start_valuetoFinal_valuedoOperator; Hvor For, to, do er funksjonsord. En teller er en ordinalvariabel (vanligvis et heltall) som bestemmer antall ganger løkken skal gjentas. Antall repetisjoner beregnes ved hjelp av formelen: Final_value – Initial_value+1. End_Value må være større enn eller lik Start_Value.

Lysbilde 8

Hvis hoveddelen av loopen består av flere operatorer, så ser den første formen for å skrive For-operatoren slik ut: ForCounter:=Start_valuetoFinal_valuedo Begin (Loop body) End;

Lysbilde 9

La oss se på algoritmen for For-løkken i den første skriveformen. Telleren er tildelt en Initial_-verdi. Betingelsen kontrolleres: Er tellerverdien større enn End_value? Hvis betingelsen er sann (Ja), avsluttes løkken. Hvis betingelsen er usann (Nei), utføres sløyfens kropp, deretter økes tellerverdien med én og betingelsen kontrolleres igjen, dvs. klausul 2.

Lysbilde 10

2. form for å skrive For loop-operatoren

Den andre formen for å skrive For-operatoren ser generelt slik ut: For Counter:=Start_valuedowntoFinal_valuedoOperator; Hvor: For, ned til, do er funksjonsord. En teller er en ordinalvariabel (vanligvis et heltall) som bestemmer antall ganger løkken skal gjentas. Antall repetisjoner beregnes ved hjelp av formelen: Start_value–Final_value+1. Start_Value må være større enn eller lik End_Value.

Lysbilde 11

Hvis hoveddelen av loopen består av flere operatorer, så ser den andre formen for å skrive For-operatoren slik ut: ForCounter:=Start_valuedowntoFinal_valuedo Begin //Loop body End;

Lysbilde 12

La oss vurdere algoritmen til For-løkken i den andre notasjonsformen: Telleren er tildelt en Initial_-verdi. Betingelsen kontrolleres: Er tellerverdien mindre enn End_value? Hvis betingelsen er sann (Ja), avsluttes løkken. Hvis betingelsen er usann (Nei), utføres sløyfens kropp, deretter reduseres tellerverdien med én og betingelsen kontrolleres på nytt, dvs. klausul 2.

Lysbilde 13

For sløyfeoperatør

programEx1; var i, n:heltall; (i – teller, n – nødvendig antall stjerner) s:streng;(s – generert streng med stjerner) begin Writeln("Skriv inn antall stjerner"); (spør etter antall stjerner) Readln(n); (brukeren angir antall stjerner n) s:=""; (dannelsen av en linje med stjerner begynner med en tom linje) (Linen er dannet av For loop. Startverdien til telleren er 1. Den endelige_verdien er det nødvendige antallet stjerner n.) fori:= 1 til n do s:=s+"*"; (ved hvert trinn i løkken er en stjerne limt til linjen) Writeln(s) (en linje skrives ut) Readln; slutt. Planeksempel: Programmet genererer en streng med stjerner. Antall stjerner i en linje bestemmes av brukeren.

Lysbilde 14

Mens Loop

While-løkken brukes når antall repetisjoner av loop-kroppen under programutvikling er ukjent og kan bare bestemmes mens programmet kjører. Generelt er While-erklæringen skrevet som følger: While Condition doOperator; Hvor While, do er funksjonsord. Tilstand er et logisk uttrykk som bestemmer fortsettelsen av loopen.

Lysbilde 15

Hvis hoveddelen av loopen består av flere utsagn, skrives While-løkken som følger: WhileCondition do Begin //Loop body End;

Lysbilde 16

La oss vurdere algoritmen til While-løkken: Betingelsen er sjekket. Hvis betingelsen er sann, utføres sløyfens kropp. Deretter kontrolleres tilstanden på nytt. Hvis betingelsen er falsk, slutter løkken.

Lysbilde 17

Dermed er While en løkke med en forutsetning eller en "While"-løkke (kroppen til løkken utføres mens betingelsen er sann). Hvis betingelsen er falsk ved den første gjennomgangen av løkken, vil ikke løkkens kropp bli utført en gang. Hvis tilstanden aldri blir falsk, vil sløyfen gjentas på ubestemt tid, dvs. looping vil oppstå.

Lysbilde 18

ProgramEx2; varAccount: Ekte; (kontostørrelse) Måned: Heltall; (antall måneder som har gått siden kontoen ble åpnet) start Account:=1000; (1000 rubler ble satt inn på kontoen) Måned:=0; (kontoen har nettopp blitt åpnet) whileAccount

Lysbilde 19

Gjenta syklusen

Repeat-løkken, som While-løkken, brukes i et program hvis det er nødvendig å utføre selve løkken flere ganger, men antall repetisjoner er ukjent på forhånd. Generelt skrives en Repeat-løkke som følger: Repeat //Body of the loop Until Condition; Der Repeat, Til er funksjonsord. Condition er et boolsk uttrykk som bestemmer slutten av løkken.

Lysbilde 20

La oss vurdere algoritmen til Repeat-løkken: Broppen til loopen som ligger mellom de reserverte ordene Repeat og Until, utføres. Tilstanden er sjekket. Hvis betingelsen er sann, avsluttes løkken. Hvis betingelsen er falsk, utføres sløyfens kropp igjen.

Lysbilde 21

Dermed er Repet en løkke med en postbetingelse eller en "Before" løkke (kroppen av løkken utføres til betingelsen er sann). Derfor utføres løkkens kropp minst én gang. Hvis betingelsen aldri blir sann, vil løkken bli uendelig.

Lysbilde 22

ProgramEx3; var Tid:heltall; (divisjonstid) Celler: heltall;(antall celler) begynner Tid:=0;(celle har ennå ikke begynt deling) Celler:=1;(én celle) Gjentatid:=Tid+3;(i de neste tre timene ) Celler: =Celler*2;(antall celler økte med 2 ganger) Inntil Celler>24; (inntil betingelsen "antall celler er større enn 24" er sann) Writeln(Time (skriv ut resultatet) Readln; slutt. Planeksempel: En encellet amøbe deler seg i 2 celler hver 3. time. Bestem hvor mange timer senere antallet celler vil overstige 24.

Se alle lysbildene

Tilbake fremover

Merk følgende! Forhåndsvisning Lysbildene er kun til informasjonsformål og representerer kanskje ikke alle funksjonene i presentasjonen. Hvis du er interessert denne jobben, last ned fullversjonen.

Mål: studere den algoritmiske strukturen til sykluser, lage modeller og algoritmer for å løse praktiske problemer.

I løpet av timene

I. Oppdatering av kunnskap

• Gjennomgå konseptet til en algoritme og de grunnleggende konstruksjonene til et algoritmisk språk.
• Kunne utvikle seg matematisk modell, algoritme og blokkdiagram for å løse problemet.
• Ha en forståelse av programmeringsspråk og deres formål.
• Kunne jobbe i et programmeringsmiljø.
• Kjenne til programstrukturer.
• Kunne skrive uttrykk som inneholder numeriske og symbolske størrelser.
• Kjenn til strukturene til operatører og funksjonene i arbeidet deres.
• Kunne bruke operatorer ved skriving av programmer med lineære og forgrenede strukturer.
• Kunne lage og kjøre programmer på en datamaskin for feilsøking.

II. Teoretisk materiale for leksjonen

De fleste praktiske problemer krever gjentatt gjentakelse av de samme handlingene, det vil si gjenbruk av en eller flere operatører. (Presentasjon)

Anta at du må legge inn og behandle en tallsekvens. Hvis det bare er fem tall, kan du lage en lineær algoritme. Hvis det er tusen av dem, er det mulig å skrive en lineær algoritme, men det er veldig kjedelig og irrasjonelt. Hvis antall tall er ukjent på det tidspunktet algoritmen utvikles, er en lineær algoritme fundamentalt umulig.

Et annet eksempel. For å finne en persons etternavn på listen, må du sjekke det første etternavnet på listen, deretter det andre, tredje osv. til den ønskede er funnet eller slutten av listen er nådd. Du kan overvinne slike vanskeligheter ved hjelp av sykluser.

En syklus er en del av en algoritme (program) som utføres gjentatte ganger. Følgelig er en syklisk algoritme en algoritme som inneholder sykluser.

Det er to typer sykluser: med et kjent antall repetisjoner og med et ukjent antall repetisjoner. I begge tilfeller refererer dette til antall repetisjoner på algoritmeutviklingsstadiet.

Det er 3 typer sykliske strukturer:

• Løkke med forutsetning;
• Løkke med postcondition;
• Løkke med parameter;

Ellers kalles disse strukturene sykluser som "Mens", "Før", "For".

Grafisk form for registrering av data av algoritmiske strukturer:

Løkke med forutsetning (aka løkke Ha det) har formen:

betingelse – uttrykk av logisk type.

Løkken kan ikke utføres selv én gang hvis verdien til det logiske uttrykket umiddelbart viser seg å være falsk.

Serien av kommandoer mellom start og slutt utføres til mens tilstanden er sann .

For det for at syklusen skal ta slutt, er det nødvendig at sekvensen av instruksjoner mellom BEGIN og END endrer verdien av variablene inkludert i betingelse.

Løkke med postcondition (aka løkke før) har formen:

betingelse – uttrykk av logisk type.

Merk:

Rekkefølge av instruksjoner mellomgjenta Ogfør vil alltid bli oppfylt i hvert fall en gang;

For at loopen skal fullføres, er det nødvendig at sekvensen av utsagn mellomgjenta Ogfør endret verdiene til variablene som er inkludert i betingelsesuttrykket.

Repetisjonsinstruksjonen, som while-instruksjonen, brukes i et program dersom det er nødvendig å utføre noen gjentatte beregninger (en loop), men antall repetisjoner er ikke kjent på forhånd og bestemmes av fremdriften i selve beregningen.

Loop med en parameter (også kalt loop Til) har formen:

i – syklusparameter;
a – startverdien til syklusen;
b - sluttverdi av syklusen;
h – parameterendringstrinn.

Strukturen til denne syklusen kalles ellers sykle i ganger.

Denne kommandoen utføres på denne måten: parameteren i settes til startverdien a, sammenlignet med sluttverdien b, og hvis den er mindre enn eller lik sluttverdien b, utføres en rekke kommandoer. Parameteren tildeles verdien til den forrige, økt med h– trinn for parameterendring og sammenlignes igjen med sluttverdien b.

I programmeringsspråket Pascal kan parameterendringstrinnet være lik én eller minus én.

Hvis det bare er én setning mellom begynnelse og slutt, trenger ikke operatorparentes å skrives. Denne regelen fungerer for løkker som "While" og "For".

La oss vurdere et eksempel på å løse problemer ved å bruke disse strukturene

Eksempel.

Beregn produktet av tall fra 1 til 5 ved å bruke forskjellige sløyfealternativer

Matematisk modell:

Р= 1·2·3·4·5=120

La oss komponere algoritmen i form av et blokkdiagram.

For å sjekke riktigheten av algoritmen, la oss fylle ut sporingstabellen.

Steg	Operasjon	R	Jeg	Tilstandssjekk
1	P:=1	1
2	i:=1;	1	1
3	Jeg<=5 P:=P*I i:=i+1	1	1	1<=5, да (истина)
4	Jeg<=5 P:=P*I i:=i+1	2	2	2<=5, да (истина)
5	Jeg<=5 P:=P*I i:=i+1	6	3	3<=5, да (истина)
6	Jeg<=5 P:=P*I i:=i+1	24	4	4<=5, да (истина)
7	Jeg<=5 P:=P*I i:=i+1	120	5	5<=5, да (истина)
8	Jeg<=5 P:=P*I i:=i+1			6<=5, нет (ложь)

Kontroll av en tilstand skjer i flere trinn: kontroll av tilstanden og utføring av kommandoer på en av grenene. Derfor registrerer ikke sporingstabellen algoritmekommandoer, men individuelle operasjoner utført av datamaskinen ved hvert trinn.

Steg en: P er tildelt en verdi på én.

Trinn to: i er tildelt verdien en.

Trinn tre: når i er lik én, sjekker vi betingelsen en er mindre enn eller lik fem, ja, betingelsen er sann, noe som betyr at P er tildelt verdien én multiplisert med én, det vil være to. For i: en pluss en er lik to.

Trinn fire: når i er lik to, sjekker vi betingelsen to er mindre enn eller lik fem, ja, betingelsen er sann, noe som betyr at P er tildelt verdien 2 ganger én, vil den være 2. For i: to pluss én, det blir tre.

Trinn fem: med i lik tre, sjekker vi betingelsen tre er mindre enn eller lik fem, ja, betingelsen er sann, noe som betyr at P er tildelt verdien av to multiplisert med tre, det vil være seks. For i: tre pluss en er lik fire.

Trinn seks: med i lik fire, sjekker vi betingelsen fire er mindre enn eller lik fem, ja, betingelsen er sann, noe som betyr at P er tildelt verdien seks ganger fire, den vil være tjuefire. For i: fire pluss en er lik fem.

Trinn sju: med i lik fem, sjekker vi betingelsen fem er mindre enn eller lik fem, ja, betingelsen er sann, noe som betyr at P er tildelt verdien av tjuefire multiplisert med fem, det vil være hundre og tjue. For i: fem pluss én er seks.

Trinn åtte: når i er lik seks, sjekker vi betingelsen seks er mindre enn eller lik fem, nei, betingelsen er falsk, så går vi ut av løkken, og som et resultat får vi den siste verdien lik hundre og tjue .

Program Pr1;
Var i: heltall;
Begynne
P:=1;
i:=1;
Mens jeg<=5 do
begynne
P:=P*i;
i:=i+1;
slutt;
Skriv('P=', P);
slutt.

For en sløyfe med postbetingelse vil vi bygge et blokkdiagram og en sporingstabell. (lysbilde 16)

Som et resultat får vi den siste verdien lik hundre og tjue på det syvende trinnet

Og for syklusen med en parameter vil vi bygge et blokkdiagram og en sporingstabell. (lysbilde 17)

Som et resultat får vi den siste verdien lik hundre og tjue på det sjette trinnet

Oppgave:

Vis tall fra 1 til 5 i:

1. direkte ordre;
2. i omvendt rekkefølge.

Matematisk modell:

1. 1 2 3 4 5;
2. 5 4 3 2 1.

Blokkdiagrammet og programmet for å løse problemet er presentert for tall i forover og omvendt rekkefølge.

(lysbilde 21)

La oss skrive de vurderte algoritmene i programmeringsspråket Pascal.

(lysbilde 22)

III. Oppsummering av leksjonen

Så vi vurderte følgende spørsmål:

1. Algoritmisk struktursyklus;
2. Typer algoritmiske strukturer:
   1. Løkke med forutsetning;
   2. Løkke med postcondition;
   3. Løkke med parameter;
3. Vi så på måter å registrere disse strukturene på;
4. Vi så på eksempler på å løse problemer ved hjelp av disse strukturene.