Typer av cykler

loopar med parameter för

slingor med förutsättning

cykel medan med förutsättning

cykel upprepa - tills med postcondition

Slinga med förutsättning i Pascal - WHILE

En loopoperator med en förutsättning utför åtgärder ett okänt antal gånger. Slingan avslutas om något logiskt uttryck eller dess resultat visar sig vara falskt.

För lojalitet logiskt uttryckär markerad i början, kan loopens kropp inte exekveras ens en gång.

Slingstruktur MEDAN

Block - cykeldiagram MEDAN

operatör

skick

Exempel

Uppgift: Skriv ett program som beräknar summan av alla jämna tal upp till 50.

writeln("Summan är: ",summa);

Uppgift

Skriv ett program som söker efter n!.

Ögla med postcondition i Pascal – REPEAT-TILL

Denna operatör liknar loopoperatorn med en förutsättning, men skiljer sig från den genom att villkoret kontrolleras efter att slingans kropp (åtgärder) exekveras. Detta säkerställer att det exekveras minst en gång, till skillnad från tidigare analyserade loopar.

Vänligen notera att denna operatör cykel innebär närvaron av flera operatörer i cykelns kropp, det vill säga flera åtgärder kan utföras, så tjänsteorden Börja Och Slutet Behövs inte.

Slingstruktur

REPETERA-TILL

Block - cykeldiagram REPETERA-TILL

operatör

skick

Exempel

Uppgift: Skriv ett program som bestämmer summan av första och sista siffran i ett tal.

a,b,c,d:heltal;

writeln("skriv in ett tal");

writeln('Summan av den första och sista siffran är:'c);

Uppgift

Skriv ett program som avgör om ett tal är primtal.

Slinga med en parameter i Pascal - FOR

Cykel FÖR ställer in villkoret under vilket programmet kommer att fungera innan det körs, låt oss säga att du behöver loopa programmet n gånger, då kan detta enkelt göras med denna loop.

U cyklar FÖR Det finns en karakteristisk egenskap - en räknare, som vanligtvis betecknas med bokstaven i eller j.

I en slinga kan räknaren anges antingen direkt (serviceord till ), och i omvänd ordning (funktionellt ord ner till ).

Slingstruktur FÖR

FÖR i:= n1 TILL n2 DO

1:a inspelningsformuläret

FÖR i:= n2 NER TILL n1 DO

2:a inspelningsformuläret

Block - cykeldiagram FÖR

i:= n1 … n2

Slingkropp

Exempel

Uppgift: Skriv ett program som beräknar n:te potensen av ett givet tal.

a, n, i, pr: heltal;

writeln('Ange ett nummer');

writeln('Ange styrkan för talet');

för i:= 1 till n do

writeln('Makten i talet är',pr);

Uppgift

Skriv ett program som hittar talet P = (1-1/2)(1-1/3)*...*(1-1/n).

N skrivs in från tangentbordet.

Slinga med en förutsättning Om antalet repetitioner är okänt i förväg, men endast anges av ett villkor, och en åtgärd som måste utföras först efter att ha kontrollerat förutsättningarna, använd en slinga med en förutsättning. Ett logiskt uttryck används som villkor, slingans kropp är en enkel eller sammansatt operator. Före varje exekvering av loopkroppen kontrolleras villkoret, om resultatet är "sant" exekveras loopkroppen igen, om "falskt" avslutas loopen. På blockschemat In Pascal börjar slutet; Villkor Slingans kropp Nej Övning Start av slingan Slutet av slingan JA Medan gör

Slinga med ett postvillkor Om antalet repetitioner är okänt i förväg, men endast anges av ett villkor, och den åtgärd som måste utföras innan villkoret kontrolleras, använd en slinga med ett eftervillkor. Ett logiskt uttryck används som villkor, slingans kropp är en enkel eller sammansatt operator. Efter varje exekvering av loopkroppen kontrolleras villkoret, om resultatet är "falskt" exekveras loopkroppen igen, om "sant" avslutas loopen. På blockschemat I Pascal Upprepa tillstånd Loop Body Ja Nej Öva tills ;

Slinga med en parameter I de fall antalet repetitioner är känt i förväg används en slinga med en parameter. Variabeln som anger antalet repetitioner kallas en loopparameter eller kontrollvariabel. Efter varje exekvering av slingkroppen ökas eller minskas styrvariabeln, slingan exekveras tills den överskrider eller blir mindre än gränsen. I blockschemat i Pascal är X kontrollvariabeln (cykelparameter) A är startvärdet av X, B är slutvärdet av X C är steget att ändra X. Som ett steg kan du bara använda: "till" = 1; “downto” = -1 X:=A,B,C Loop Body Practice För X:=A till B gör Början Slut;

Ett exempel på ett problem som använder en slinga med en förutsättning Höj siffran 3 till en given potens UPPGIFT: Verbal algoritm: Multiplicera talet X, initialt lika med 1, ett givet antal gånger (H) med 3. starta H BHBH X: =1 X:=X*3 slut X Ange de givna graderna Inledande värden "B" gradräknare B=B+1 Multiplicera med 3 Öka räknaren Mata ut det resulterande värdet Program Stepen; Var H,B,X:heltal; Börja skrivaln(Grad?); Readln(H); X:=1; B:=1; Medan B

H X:=1 X:=X*3 slut X Ange en given potens Initiala värden" title="Exempel på en uppgift som använder en slinga med ett eftervillkor Höj siffran 3 till en given potens UPPGIFT: Verbal algoritm: Multiplicera talet X initialt lika med 1 givet antal gånger (H) för 3. start N B>=H X:=1 X:=X*3 slut X Ange en given grad Initialvärden" class="link_thumb"> 8 !} Ett exempel på ett problem med en slinga med ett postvillkor Höj siffran 3 till en given potens UPPGIFT: Verbal algoritm: Multiplicera talet X, initialt lika med 1, ett specificerat antal gånger (H) med 3. starta H B>=H X :=1 X:=X*3 slut X Ange en given grad Initialvärden "B" gradräknare B=B+1 Multiplicera med 3 Öka räknaren Mata ut det resulterande värdet Program Stepen; Var H,B,X:heltal; Börja skrivaln(Grad?); Readln(H); X:=1; B:=0; Upprepa X:=X*3; B:=B+1; Tills B>=H; Writeln(Resultat,X); Slutet. Nej Ja Pascal Teori Blockdiagram Förklaringar B:=0 =H X:=1 X:=X*3 slut X Ange en given grad initiala värden"> =H X:=1 X:=X*3 slut X Ange en given grad initiala värden "B" gradräknare B=B +1 Multiplicera med 3 Öka räknaren Mata ut det resulterande värdet Program Stepen; Var H,B,X:heltal; Börja skrivaln(Grad?); Läsln(H); X:=1; B:=0; Upprepa X:= X*3; B: =B+1; Tills B>=H; Skrivln (Resultat,X); Slut. Nej Ja Teori Pascal Blockdiagram Förklaringar B:=0"> =H X:=1 X:=X*3 slut X Ange en given grad Initiala värden" title=" Exempel på ett problem med en slinga med ett postvillkor Höj siffran 3 till en given potens UPPGIFT: Verbal algoritm: Multiplicera talet X initialt lika med 1 ett givet tal gånger (H) med 3. början N B>=H X: =1 X:=X*3 slut X Ange den angivna graden Inledande värden"> title="Ett exempel på ett problem med en slinga med ett postvillkor Höj siffran 3 till en given potens UPPGIFT: Verbal algoritm: Multiplicera talet X, initialt lika med 1, ett specificerat antal gånger (H) med 3. starta H B>=H X :=1 X:=X*3 slut X Ange en given grad Initialvärden"> !}

Ett exempel på en uppgift som använder en slinga med parametern Höj siffran 3 till en given potens UPPGIFT: Verbal algoritm: Multiplicera talet X, initialt lika med 1, ett specificerat antal gånger (H) med 3. starta H X:=1 X:=X*3 slut X Ange en given effekt Initialt värde X=1 Parametrar från 1 till N Multiplikation med 3 Utmatning av det resulterande värdet Programm Stepen; Var H,B,X:heltal; Börja skrivaln(Grad?); Readln(H); X:=1; För B:=1 till H börjar X:=X*3; Slutet; Writeln(Resultat,X); Slutet. B:=1,H,1 Pascal Teori Blockdiagram Förklaringar

Uppgift: Efter att ha börjat träna sprang idrottaren 10 km första dagen. Varje dag ökade han dagsnormen med 10 % av föregående dags norm. Vad är den totala sträckan som idrottaren kommer att tillryggalägga på 7 dagar? Indatavariabler: Utdatavariabler: S – total väg d – antal dagar Sd – sträcka för aktuell dag

Slutfrågor för kontroll: 1. Vilken operator i Pascal definierar en loop med ett förutsättning 2. Hur specificerar man steget "1" och "-1" i en parameter i en loop 3. Vilken gren följer loopen med ett postvillkor? 4. Finns det en tillståndsparameter 5. Vad kan en loops kropp vara 6. När används en loop med parametrar

Bild 2

Planen

Begreppet en loop Loop statement för Loop While Loop Repeat Litteratur

Bild 3

Litteratur

Kastornov A.F., Evstratova G.A. Pascal programmeringsspråk: handledning för universiteten. - Cherepovets: State Educational Institution of Higher Professional Education ChSU, 2010. - 117 sid. - Bibliografi: P.114. Elektronisk lärobok om programmeringsspråket Pascal /http://pascal.guti.ru Plan

Bild 4

Begreppet en cykel

Algoritmer för att lösa många problem är cykliska, för att uppnå resultatet specifik sekvensåtgärder utförs flera gånger. Till exempel visar ett kunskapskontrollprogram en fråga, accepterar svaret, lägger till ett betyg för svaret till totalpoängen och upprepar sedan dessa åtgärder tills ämnet svarar på alla frågorna. Eller för att till exempel söka efter det önskade efternamnet i listan bör du kontrollera det första efternamnet i listan för att se om det stämmer med det sökta, sedan det andra, tredje osv. tills önskat efternamn hittas eller slutet av listan nås.

Bild 5

En algoritm där det finns en grupp satser som exekveras flera gånger kallas cyklisk. Gruppen av upprepade påståenden kallas loopens kropp. I Pascal kan loopar implementeras med For-, While- och Repeat-loopsatserna. Planen

Bild 6

För slingoperatör

Operatorn For loop används om slingans kropp behöver köras flera gånger och antalet repetitioner är känt i förväg.

Bild 7

1:a formen av att skriva For loop-operatorn

Första formen av att skriva For-operatören i allmän syn ser ut så här: ForCounter:=Start_valuetoFinal_valuedoOperator; Where For, to, do är funktionsord. En räknare är en ordningsvariabel (vanligtvis ett heltal) som bestämmer hur många gånger slingan ska upprepas. Antalet repetitioner beräknas med formeln: Final_value – Initial_value+1. End_Value måste vara större än eller lika med Start_Value.

Bild 8

Om slingans kropp består av flera operatorer, så ser den första formen av att skriva operatorn For ut så här: ForCounter:=Start_valuetoFinal_valuedo Begin (Loop body) End;

Bild 9

Låt oss titta på algoritmen för For-slingan i den första formen av skrivning. Räknaren tilldelas ett Initial_-värde. Villkoret kontrolleras: Är räknarvärdet större än End_value? Om villkoret är sant (Ja), slutar slingan. Om villkoret är falskt (Nej), så exekveras slingans kropp, då ökas räknarvärdet med ett och villkoret kontrolleras igen, d.v.s. klausul 2.

Bild 10

2:a formen av att skriva For loop-operatorn

Den andra formen av att skriva For-operatorn ser generellt ut så här: For Counter:=Start_valuedowntoFinal_valuedoOperator; Var: För, ner till, gör är funktionsord. En räknare är en ordningsvariabel (vanligtvis ett heltal) som bestämmer hur många gånger slingan ska upprepas. Antalet repetitioner beräknas med formeln: Startvärde–Slutvärde+1. Start_Value måste vara större än eller lika med End_Value.

Bild 11

Om slingans kropp består av flera operatorer, så ser den andra formen av att skriva For-operatorn ut så här: ForCounter:=Start_valuedowntoFinal_valuedo Begin //Loop body End;

Bild 12

Låt oss betrakta algoritmen för For-slingan i den andra formen av notation: Räknaren tilldelas ett Initial_-värde. Villkoret kontrolleras: Är räknarvärdet mindre än End_value? Om villkoret är sant (Ja), slutar slingan. Om villkoret är falskt (Nej), så exekveras slingans kropp, då minskas räknarvärdet med ett och villkoret kontrolleras igen, d.v.s. klausul 2.

Bild 13

För slingoperatör

programEx1; var i, n:heltal; (i – räknare, n – erforderligt antal stjärnor) s:string;(s – genererad sträng av stjärnor) begin Writeln("Ange antalet stjärnor"); (frågar antalet stjärnor) Readln(n); (användaren anger antalet stjärnor n) s:=""; (bildandet av en sträng av asterisker börjar med en tom sträng) (Strängen bildas med hjälp av en For-loop. Räknarens initiala_värde är 1, Det slutliga_värdet är det erforderliga antalet stjärnor n.) fori:= 1 till n do s :=s+"*"; (vid varje steg i slingan är en asterisk limmad på linjen) Writeln(s), (en rad skrivs ut) Readln; slutet. Planexempel: Programmet genererar en sträng av stjärnor. Antalet stjärnor på en rad bestäms av användaren.

Bild 14

Medan Loop

While-slingan används när antalet repetitioner av loopkroppen under programutveckling är okänt och kan endast fastställas medan programmet körs. I allmänhet är While-satsen skriven enligt följande: While Condition doOperator; Där While, do är funktionsord. Villkor är ett logiskt uttryck som bestämmer fortsättningen av slingan.

Bild 15

Om slingans brödtext består av flera satser, skrivs While-slingan på följande sätt: WhileCondition do Begin //Loop body End;

Bild 16

Låt oss titta på algoritmen för While-slingan: Villkoret kontrolleras. Om villkoret är sant, exekveras slingans kropp. Därefter kontrolleras tillståndet igen. Om villkoret är falskt slutar slingan.

Bild 17

Sålunda är While en loop med en förutsättning eller en “While”-loop (kroppen i loopen exekveras medan villkoret är sant). Om villkoret är falskt vid det första passet av slingan, kommer slingans kropp inte att exekveras ens en gång. Om villkoret aldrig blir falskt, så kommer slingan att upprepas på obestämd tid, d.v.s. looping kommer att inträffa.

Bild 18

ProgramEx2; varAccount: Real; (kontostorlek) Månad: heltal; (antal månader som har gått sedan kontot öppnades) start Account:=1000; (1000 rubel sattes in på kontot) Månad:=0; (kontot har precis öppnats) whileAccount

Bild 19

Upprepa cykeln

Repeat-slingan, liksom While-slingan, används i ett program om det är nödvändigt att utföra slingans kropp flera gånger, men antalet repetitioner är okänt i förväg. I allmänhet skrivs en Repeat loop enligt följande: Repeat //Body of the loop Till Condition; Där Repeat, Till är funktionsord. Villkor är ett booleskt uttryck som bestämmer slutet på slingan.

Bild 20

Låt oss överväga algoritmen för Repeat-loopen: Broppen på loopen som ligger mellan de reserverade orden Repeat och Until exekveras. Tillståndet kontrolleras. Om villkoret är sant slutar slingan. Om villkoret är falskt exekveras slingans kropp igen.

Bild 21

Således är Repet en loop med ett postvillkor eller en "Before" loop (kroppen av loopen exekveras tills villkoret är sant). Därför exekveras slingans kropp minst en gång. Om villkoret aldrig blir sant, kommer slingan att bli oändlig.

Bild 22

ProgramEx3; var Tid:heltal; (delningstid) Celler: heltal;(antal celler) börjar Tid:=0;(cellen har ännu inte börjat dela) Celler:=1;(en cell) Upprepningstid:=Tid+3;(inom de kommande tre timmarna ) Celler: =Celler*2;(antalet celler ökade med 2 gånger) Tills Celler>24; (tills villkoret "antalet celler är större än 24" är sant) Writeln(Time);(mata ut resultatet) Readln; slutet. Planexempel: En encellig amöba delar sig i 2 celler var tredje timme. Bestäm hur många timmar senare antalet celler kommer att överstiga 24.

Visa alla bilder

Tillbaka framåt

Uppmärksamhet! Förhandsvisning Bilderna är endast i informationssyfte och representerar kanske inte alla funktioner i presentationen. Om du är intresserad detta jobb, ladda ner den fullständiga versionen.

Mål: studera den algoritmiska strukturen av cykler, skapa modeller och algoritmer för att lösa praktiska problem.

Under lektionerna

I. Uppdatering av kunskap

• Gå igenom begreppet en algoritm och de grundläggande konstruktionerna av ett algoritmiskt språk.
• Kunna utvecklas matematisk modell, algoritm och blockschema för att lösa problemet.
• Ha en förståelse för programmeringsspråk och deras syften.
• Kunna arbeta i en programmeringsmiljö.
• Känna till programstrukturer.
• Kunna skriva uttryck som innehåller numeriska och symboliska storheter.
• Känna till operatörernas strukturer och funktionerna i deras arbete.
• Kunna använda operatorer vid skrivning av program med linjära och förgrenade strukturer.
• Kunna skapa och köra program på en dator för felsökning.

II. Lektionens teoretiska material

De flesta praktiska problem kräver upprepad upprepning av samma åtgärder, det vill säga återanvändning av en eller flera operatörer. (Presentation)

Anta att du behöver ange och bearbeta en sekvens av nummer. Om det bara finns fem siffror kan du skapa en linjär algoritm. Om det finns tusen av dem är det möjligt att skriva en linjär algoritm, men det är väldigt tråkigt och irrationellt. Om antalet siffror är okänt när algoritmen utvecklas, är en linjär algoritm i grunden omöjlig.

Ett annat exempel. För att hitta en persons efternamn på listan måste du kontrollera det första efternamnet på listan, sedan det andra, tredje osv. tills den önskade hittas eller slutet av listan nås. Du kan övervinna sådana svårigheter med hjälp av cykler.

En cykel är en del av en algoritm (program) som exekveras upprepade gånger. Följaktligen är en cyklisk algoritm en algoritm som innehåller cykler.

Det finns två typer av cykler: med ett känt antal repetitioner och med ett okänt antal repetitioner. I båda fallen avser detta antalet repetitioner i algoritmutvecklingsstadiet.

Det finns tre typer av cykliska strukturer:

• Slinga med förutsättning;
• Slinga med postcondition;
• Slinga med parameter;

Annars kallas dessa strukturer cykler som "Medan", "Före", "För".

Grafisk form för inspelning av data av algoritmiska strukturer:

Slinga med förutsättning (aka slinga Hejdå) har formen:

skick – uttryck av logisk typ.

Slingan kanske inte exekveras ens en gång om värdet på det logiska uttrycket omedelbart visar sig vara falskt.

Serien av kommandon mellan start och slut exekveras tills medan villkoret är sant .

För det för att cykeln ska ta slut, är det nödvändigt att sekvensen av instruktioner mellan BEGIN och END ändrar värdet på variablerna som ingår i skick.

Slinga med postcondition (alias slinga innan) har formen:

skick – uttryck av logisk typ.

Notera:

Sekvens av instruktioner mellanupprepa Ochfram tills kommer alltid att uppfyllas åtminstone en gång;

För att slingan ska slutföras är det nödvändigt att sekvensen av påståenden mellanupprepa Ochfram tills ändrade värdena för variablerna som ingår i villkorsuttrycket.

Repetitionsinstruktionen, liksom while-instruktionen, används i ett program om det är nödvändigt att utföra några upprepade beräkningar (en loop), men antalet repetitioner är inte känt i förväg och bestäms av själva beräkningens framsteg.

Slinga med en parameter (aka loop För) har formen:

i – cykelparameter;
a – startvärdet för cykeln;
b – slutvärdet för cykeln.
h – steg för parameterändring.

Strukturen för denna cykel kallas annars cykla i gånger.

Detta kommando exekveras på detta sätt: parametern i sätts till initialvärdet a, jämfört med slutvärdet b, och om det är mindre än eller lika med slutvärdet b, exekveras en serie kommandon. Parametern tilldelas värdet av den föregående, ökat med h– steg för parameterändring och jämförs igen med slutvärdet b.

I programmeringsspråket Pascal kan parameterändringssteget vara lika med ett eller minus ett.

Om det bara finns ett påstående mellan början och slutet, behöver inte operatorparenteser skrivas. Den här regeln fungerar för loopar som "While" och "For".

Låt oss titta på ett exempel på att lösa problem med hjälp av dessa strukturer

Exempel.

Beräkna produkten av siffror från 1 till 5 med hjälp av olika loopalternativ

Matematisk modell:

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

Låt oss komponera algoritmen i form av ett blockdiagram.

För att kontrollera algoritmens korrekthet, låt oss fylla i spårningstabellen.

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

Kontroll av ett villkor sker i flera steg: kontroll av villkoret och exekvering av kommandon på en av grenarna. Därför registrerar inte spårningstabellen algoritmkommandon, utan individuella operationer som utförs av datorn vid varje steg.

Steg ett: P tilldelas värdet ett.

Steg två: i tilldelas värdet ett.

Steg tre: när i är lika med ett, kontrollerar vi villkoret ett är mindre än eller lika med fem, ja, villkoret är sant, vilket betyder att P tilldelas värdet ett multiplicerat med ett, det kommer att finnas två. För i: ett plus ett är lika med två.

Steg fyra: när i är lika med två, kontrollerar vi att villkoret två är mindre än eller lika med fem, ja, villkoret är sant, vilket betyder att P tilldelas värdet 2 gånger ett, det blir 2. För i: två plus ett, det blir tre.

Steg fem: med i lika med tre kontrollerar vi att villkoret tre är mindre än eller lika med fem, ja, villkoret är sant, vilket betyder att P tilldelas värdet av två multiplicerat med tre, det blir sex. För i: tre plus en är lika med fyra.

Steg sex: med i lika med fyra kontrollerar vi att villkoret fyra är mindre än eller lika med fem, ja, villkoret är sant, vilket betyder att P tilldelas värdet sex gånger fyra, det blir tjugofyra. För i: fyra plus en är lika med fem.

Steg sju: med i lika med fem, kontrollerar vi att villkoret fem är mindre än eller lika med fem, ja, villkoret är sant, vilket betyder att P tilldelas värdet av tjugofyra multiplicerat med fem, det blir etthundratjugo. För mig: fem plus ett är sex.

Steg åtta: när i är lika med sex, kontrollerar vi att villkoret sex är mindre än eller lika med fem, nej, villkoret är falskt, sedan lämnar vi slingan, och som ett resultat får vi det sista värdet lika med etthundratjugo .

Program Pr1;
Var i: heltal;
Börja
P:=1;
i:=1;
Medan jag<=5 do
Börja
P:=P*i;
i:=i+1;
slutet;
Write('P=', P);
slutet.

För en slinga med ett postvillkor kommer vi att bygga ett blockschema och en spårningstabell. (bild 16)

Som ett resultat får vi det sista värdet lika med hundra och tjugo i det sjunde steget

Och för cykeln med en parameter kommer vi att bygga ett blockschema och en spårningstabell. (bild 17)

Som ett resultat får vi det sista värdet lika med hundra tjugo vid det sjätte steget

Uppgift:

Visa siffror från 1 till 5 i:

1. direkt ordning;
2. i omvänd ordning.

Matematisk modell:

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

Blockschemat och programmet för att lösa problemet presenteras för siffror i framåt- och omvänd ordning.

(bild 21)

Låt oss skriva de övervägda algoritmerna i programmeringsspråket Pascal.

(bild 22)

III. Sammanfattning av lektionen

Så vi funderade på följande frågor:

1. Algoritmisk strukturcykel;
2. Typer av algoritmiska strukturer:
   1. Slinga med förutsättning;
   2. Slinga med postcondition;
   3. Slinga med parameter;
3. Vi tittade på sätt att registrera dessa strukturer;
4. Vi tittade på exempel på att lösa problem med hjälp av dessa strukturer.