Hem › Firmware › Programmering av cykliska beräkningsdatabehandlingsprocesser. Programmera cykliska beräkningsprocesser. Ett exempel på användning av for-satsen

Programmering av cykliska beräkningsdatabehandlingsprocesser. Programmera cykliska beräkningsprocesser. Ett exempel på användning av for-satsen

I programmering finns det ofta uppgifter som kräver upprepad exekvering av samma grupp av programsatser med olika värden på deras operander. Sådana processer kallas cyklisk eller bara cykler. En grupp av cykliskt upprepade påståenden bildar den sk öglekropp, som kan representeras av antingen ett enkelt eller sammansatt uttryck. Vi kommer att kalla engångsutförandet av loopkroppen iteration.

Brödtexten i en loop i ett program föregås alltid av slinghuvud, som innehåller beteckningen slingoperatör och ett uttryck som definierar (direkt eller indirekt) antalet iterationer. Observera att slingans kropp är operanden av slingoperatorn; därför utgör slingans huvud och kropp en odelbar strukturell enhet i programmet. I det följande använder du termen " slingoperatör", menar vi både rubriken och slingans kropp.

För att organisera cykler i alla programmeringssystem finns det specialiserade slingoperatörer, vars användning befriar programmeraren från behovet av att programmera cykler "manuellt". MathCAD stöder två typer av sådana operatörer - cykla med predestination För (även kallad slinga med disk) Och slinga med förutsättning Medan . En beskrivning av strukturen för dessa operatörer ges i tabell 5.

5.4.1 Operatör För

Denna operator bör användas i de fall där antalet iterationer är förutbestämt, det vill säga känt i förväg.

Loop header av denna operator (den högra operanden) innehåller en variabel som kallas parameter(eller räknare) cykel, Och värdelista denna parameter. Antalet element i listan bestämmer också antalet iterationer - under varje iteration får loopparametern nästa värde från listan som anges i rubriken.

Slingparameter har status som en intern programvariabel och har alla dess egenskaper (beskrivs i avsnitt 5.1.4). Som regel används loopparametern på höger sida av uttrycken som ingår i loopens kropp, även om det inte är formellt förbjudet att använda den på vänster sida av uttryck (det vill säga till vänster om den lokala definitionen operatorn "f"). Man bör komma ihåg att om en parameter ändrades i slingans kropp, kommer dess ändrade värde endast att vara giltigt till slutet av den aktuella iterationen, eftersom parametern innan nästa iteration fortfarande kommer att få nästa värde från lista som anges i loophuvudet.

Formellt är det tillåtet att inte använda loopparametern alls i uttrycken för loopkroppen - i det här fallet spelar listan med parametervärden ingen roll - bara längden på denna lista är signifikant, vilket bestämmer antal (möjligen meningslösa) iterationer.

När den sista iterationen har slutförts kommer programsatsen efter loopsatsen att exekveras. I det här fallet behåller variabeln som används som parameter för den avslutade slingan det värde den hade i den sista faktiskt avslutad iteration[*]. Observera att detta värde inte alltid sammanfaller med det sista värdet från listan som anges i loophuvudet, eftersom en "tidig" utgång från loopen är möjlig när operatören triggas Ha sönder ingår i slingans kropp.

Värdelista Loopparametern skrivs i loophuvudet efter symbolen " Î ", indikerar medlemskap i en uppsättning (denna symbol behöver inte matas in manuellt - den kommer att visas automatiskt när du går in i operatören För ). MathCAD tillåter användning tre former poster i denna lista: direkt överföring– listelement är explicit specificerade avgränsade med kommatecken, parametern tar emot värden från listan i den ordning de visas; i rankad variabel stil – elementen i listan bildar motsvarande aritmetiska serier; array– listelement får sekventiellt värdena för arrayelement i ordningsföljd av deras index (först kolumner från vänster till höger, sedan rader uppifrån och ned).

De tre programmen som visas i figur 21 illustrerar olika användningsområden för operatören För .

Program Fakta(n) beräknar fakulteten för ett tal n . Slingoperatorn i detta program är en del av ett sammansatt uttryck, som i sin tur är operanden till en villkorlig operator Annat. Slingparameter k erhåller värden från en heltalsaritmetisk serie.

Program Ch(V,N,p) bearbetar ingångsvektorn V , och ersätter det med värdet sid de element vars index specificeras av elementen i den andra ingångsvektorn N . I det här exemplet en lista med loopparametervärden i definieras av en uppsättning vektorelement N . Observera att båda dessa program utför indatakontroll och blockerar exekveringen av huvudalgoritmen om de faktiska programargumenten är felaktigt specificerade.

Program L(M,z) ges i exemplet V ), åtföljs av detaljerade kommentarer och kräver ingen förklaring. Detta program illustrerar möjligheten att använda flera loop-satser, varav en ingår bland satserna kropp annan. Användande kapslade slingor- en typisk teknik som används för att bearbeta flerdimensionella arrayer.

Figur 21 – Exempel på cykelprogrammering För

Figur 22 illustrerar användningen av operatörer Ha sönder Och Fortsätta i slingans kropp. Vanligtvis är dessa operatörer själva operander villkorliga uttalanden Om eller Annat .

Operatör Ha sönder ("avbryta") avbryter utförande av slingan och överför kontrollen till operatören efter den avbrutna slingoperatören. Observera att om operatören Ha sönder avbröts kapslad slinga, kommer exekveringen av den yttre slingan att fortsätta.

Operatör Fortsätta ("fortsätt") agerar annorlunda - han avbryter endast den aktuella iterationen av slingan och överför kontrollen till huvudet för denna loop, varefter loopen exekveras fortsätter från nästa iteration (såvida inte, naturligtvis, den avbrutna iterationen var den sista).

Operatör Ha sönder får använda och utanför cykelns kropp. I det här fallet avbryts exekveringen av hela subrutinen, och resultatet av utvärderingen av dess senaste faktiskt exekverade uttryck returneras.

Figur 22 – Exempel på användning av operatorer Ha sönder Och Fortsätta

Fungera SumN(V) summerar endast de vektorelement som innehåller skalär numerisk data och hoppar över de återstående elementen. Fungera Invers (V) bildar en vektor vars element är de inversa värdena för motsvarande element i den ursprungliga vektorn. Dessutom, om nästa element innehåller talet "0" eller inte är en skalär av numerisk typ, cykeln avbryts. Observera att operatören Ha sönder i det sista exemplet avbryter den inte programmet, utan överför kontrollen till operatören Lämna tillbaka , omedelbart efter operatören För .

5.4.3 Operatör Medan

Till skillnad från operatören För , meddelandehuvud Medan (i översättning - " Hejdå") innehåller inte explicita indikationer på antalet iterationer - den innehåller logiskt uttryck, vars värde beräknas automatiskt innan början exekvering av varje nästa iteration[†]. Så länge detta uttryck är sant kommer loopen att fortsätta att iterera; så snart uttrycket blir falskt efter slutförandet av nästa iteration, kommer nästa iteration av slingan inte att exekveras, och programsatsen efter satsen kommer att få kontroll Medan .

Uppenbarligen, om ett identiskt falskt logiskt uttryck placeras i loophuvudet, kommer denna loop inte att slutföra någon av sina iterationer, och om detta uttryck är identiskt sant kommer loopen att vara oändlig (den senare situationen kallas looping program). För att undvika sådana situationer måste operanderna i ett logiskt uttryck innehålla en eller flera variabler som ändrar deras värden i slingans kropp så att slingan är ändlig (andra medel kan användas för att förhindra looping - till exempel tvinga operatören att lämna slingan Ha sönder ).

Exempel på användning av operatorn Medan visas i figur 23. Tre alternativ för att lösa samma problem ges: vart och ett av programmen F0 , F1 Och F2 returnerar indexet för det första elementet i källvektornV överskrider det angivna värdetz .

Första programmet (exempel A ) lägger till en till disken k i slingans kropp Medan tills nästa k det e elementet i den ursprungliga vektorn kommer inte att överskrida det angivna värdet z . Efter detta avslutas loopen och programmet returnerar det senast ändrade värdet på variabeln k , vilket är lösningen på problemet. Observera att, till skillnad från cykeln För , disken k här är det nödvändigt att bearbeta det med separata satser: initialisera (det vill säga tilldela det ett initialt värde) före loopoperatorn och ändra dess värde i loopens kropp.

Det är lätt att se att alternativet A ) av programmet har en betydande nackdel: det hindrar inte programmet från att loopa i fallet när problemet inte har någon lösning, det vill säga när parametern z överstiger värdet för det största elementet i vektorn V . I det här exemplet kommer looping i en sådan situation inte att hända - men detta är inte fördelen med vårt program, utan med MathCAD-systemet, som kommer att styra utmatningen av vektorindexet V utanför de tillåtna värdena och kommer att generera ett felmeddelande.

Fri från denna nackdel är alternativet b ) av ett program där slingans kropp innehåller en extra kontroll av giltigheten av nästa indexvärde och tvångsavbryter slingan med operatören Ha sönder i lämplig situation med utfärdande av ett textmeddelande.

Den kanske mest effektiva lösningen på detta problem är alternativet V ), som inte använder operatören alls Medan . I detta program variabeln k används endast för att bibehålla "stilens renhet" - för att utesluta bearbetning av loopparametern i utanför operatören För .

Figur 23 – Exempel på cykelprogrammering Medan

Målet med arbetet:

Studera de cykliska operatorerna för, medan, gör - medan, lär dig hur man komponerar och programmerar cykliska algoritmer.

Kort teoretisk information

Loop-operatorer används när det är nödvändigt att upprepa vissa åtgärder (operatorer och operationer) flera gånger, och sådana sektioner av algoritmer kallas loopar.

For loop-operatören

Den grundläggande formen av for loop-satsen är:

för (uttryck_1; uttryck_2; uttryck_3)

operatör;

Var uttryck_1– initialt värde för cykelparametern;

uttryck_2– Kontrollera villkoren för fortsättning av cykeln;

uttryck_3– ändring av cykelparameter (korrigering);

operatör– enkel eller sammansatt operator i C-språk.

Operatörens operationsschema är som följer: endast en gång, först beräknas expression_1, sedan kontrolleras expression_2, och om det är "sant", exekveras en cyklisk del av programmet, sedan korrigeras parametern, och så vidare tills expression_2 tar värdet "false".

Till exempel: för (k=1; k<5; k++)

printf(“\n %d”, k);

Som ett resultat av att köra denna operator skrivs siffrorna från 1 till 4 ut i en kolumn.

Du kan använda en variabel av vilken grundtyp som helst som en loopparameter.

Till exempel:

for(ch='a'; kap<=’z’; ch++) // Вывод на экран букв

printf(“ %c”,ch); // latinska alfabetet

Det är nödvändigt att noggrant kontrollera strukturen för for-slingorna i programmet så att du inte hamnar i en ändlös loop (från vilken det inte finns någon utgång).

Till exempel:

för(k=10; k>6;k++)

printf(“ändlös loop\n”);

Exit loop före schemat på följande sätt:

Genom ytterligare villkor;

Använder följande operatorer:

ha sönder;- gå ur slingan där break är belägen, kontrollen överförs till den första exekverade satsen efter slingan;

exit(int Kod);- avsluta programmet;

lämna tillbaka;- lämna funktionen;

Använder den ovillkorliga hoppoperatorn gå till<метка>;

Tidigt slutförandet av det aktuella cykliska steget möjligt med ett extra villkor eller operatör Fortsätta, som avbryter exekveringen av det aktuella slingsteget, dvs. hoppar över satserna för resten av slingan och överför kontrollen till slingans head-sats för att justera parametern och kontrollera tillståndet.

Det är förbjudet att överföra kontroll från utsidan till insidan av slingan.

Alla for-loop-uttryck inom parentes kan saknas, men symbolen ";". kan inte sänkas.

Till exempel:

för (; jag<3; i++)

puts(“Hej!”);

Cykliska stund och gör-medan uttalanden

Grundform för den cykliska operatorn medan:

Medan (skick)

operatör;

Var operatör

Slingan löper så länge tillståndet utvärderas till sant, dvs. uttrycket inom parentes returnerar ett resultat som inte är noll. Detta är en loop med en förutsättning - först kontrolleras villkoret, sedan körs satsen. Därför kommer while-slingan inte att exekveras ens en gång om det initiala resultatet av beräkningen av villkoret är 0.

Grundläggande form av operatör göra medan:

operatör;

while(villkor);

Var operatörär ett enkelt, sammansatt eller tomt påstående.

Operatör do–medan– loopoperator med postcondition, d.v.s. först exekveras uttalandet, och sedan kontrolleras villkoret för sanning. Eftersom villkoret i en do–while loop kontrolleras i slutet av loopen, kommer loopen att exekveras minst en gång.

I loopar som while och do–while är samma metoder för tidig utträde ur loopen och tidigt slutförande av det aktuella steget i loopen tillåtna som i for-satsen, men i det senare fallet, till skillnad från for-loopen, överförs kontrollen att kontrollera skicket. För att förhindra en oändlig loop inuti while- och do–while-slingorna måste du se till att de variabler som ingår i villkoret ändras.

Till exempel:

för (i=1;i<=300;i++) // Печать целых чисел, кратных 5

if (i%5!=0) fortsätt;

printf(“%5d”,i);

Exempel på oändliga loopar:

operatör;

2) while(number_not_0) // Alltid sant!

operatör;

while(nummer_inte_0); // Alltid sant!

Bland slingoperatörerna måste det finnas ett utgångsvillkor.

Kapslade loopar

I fallet med kapslade slingor är en slinga inuti en annan, till exempel:

för(i=nn;i

för(j=mn;j

operatör;

Var operatörär ett enkelt, sammansatt eller tomt påstående. Den inre slingan kommer att exekveras för varje värde på parameter i som uppfyller villkoret för den yttre slingan.

Exempel:

för(i=1;i<10;i++) // Печать таблицы умножения

för(j=1;j<4;j++)

printf(“\n %d*%d=%2d”, i, j, i*j);

printf(“\n”);

Ett exempel på användning av for-satsen

Beräkna. Programmet ska skriva ut mellan- och slutresultat.

Programtexten kan se ut

#omfatta

puts(“Ange N”);

scanf(“%d”,&N);

för (s=0, k=1; k<=N; k++) // В заголовке цикла можно выпол-

( // ta och dubbeluppgift

printf(" \n k=%d s=%f ", k, s);

printf("\n SVAR: s=%f, tryck på valfri tangent...",s);

Möjlighet till individuella uppdrag

Skriv ett program för att bestämma en tabell över funktionsvärden på inom ett godtyckligt intervall [ a,b] argument ändras X med godtyckliga steg h. Värderingar a, b, h in från tangentbordet. Tabellen måste innehålla följande kolumner: sekvensnummer, argumentvärde x, funktionsvärde, meddelande om ökande eller minskande funktion, skillnad mellan två angränsande funktionsvärden.

Bestäm maximala och lägsta värden för funktionen.

1. a=-p; b=p; h=0,4.

2. a=0,7; b=1,8; h=0,1.

3. a=-0,5; b=2,5; h=0,2.

4. a=-0,9; b=2,7; h=0,3.

5. a=-2; b=0,8; h=0,2.

6. a=-1,9; b=2,7; h=0,3.

7. a=-0,4p; b=0,4p; h=0,5.

8. a=-0,3p; b=1,3p; h= p/10.

9. a=-p/2; b= p/2; h=p/10.

10. a=-3; b=3; h=0,5.

"Programmering av cykliska beräkningsprocesser"

Målet med arbetet: behärska metoder för att kompilera algoritmer för cykliska beräkningsprocesser och organisera cykliska program med komplex struktur.

Teoretisk del

4.1.1. Cykliska algoritmer.

En cykel är en sekvens av åtgärder som kan utföras mer än en gång.

En round-robin-algoritm är en algoritm som innehåller en eller flera loopar.

Det finns 3 typer av cykler:

Slinga med förutsättning;

Slinga med postcondition;

Slinga med en räknare (räkneslinga).

Om exekveringen av en slinga är associerad med något logiskt villkor, används slingor med ett förvillkor eller ett eftervillkor.

Räknarslingor är en klass där exekveringen av slingkroppen måste upprepas ett förutbestämt antal gånger.

Blockdiagram av cykliska algoritmer ser ut så här:

1. Slinga med en räknare.

2. Slinga med förutsättning. 3. Slinga med postcondition.

4.1.2 Slingoperatorer i programmeringsspråket C++.

I C++ finns det en motsvarande operator för varje typ av loop:

Slinga som medan (med förutsättning);

Loop like do...while (med postcondition);

Slinga som för (räkna).

1. Loop operatör som medan

Anmälningsblankett:

medan (villkor) uttalande;

där: (villkor) – logiskt uttryck;

operator – operatören eller kroppen för slingan som exekveras i en slinga.

Om slingans kropp är en sammansatt sats, måste den omges av operatorparenteser (...):

medan (skick)

grupp av operatörer

Schemat för hur en sådan slinga fungerar: medan villkoret är sant, exekveras slingans kropp och villkoret kontrolleras igen, etc. När villkoret blir falskt avslutas slingan.

2. Slingoperatör som gör ... medan

Anmälningsblankett:

operatör;

while(villkor);

Schemat för hur en sådan slinga fungerar: först exekveras operatören, sedan kontrolleras villkoret, om villkoret är sant exekveras operatören och villkoret kontrolleras igen, etc. När villkoret blir falskt avslutas slingan.

Om slingans kropp är en sammansatt sats, måste den, precis som för en slinga med en förutsättning, omges av operatorparenteser (...):

grupp av operatörer

while(villkor);

3. Slingoperatör som för

Anmälningsblankett:

operatör;

A är ett initialt uttryck som anger initiala värden för loopparametern och, om nödvändigt, initiala värden för andra parametrar. Till exempel:

i=0, x=0,5, p=1, s=0

B är ett villkorligt uttryck som kontrollerar villkoret för att fortsätta slingan. Till exempel:

C är ett inkrementuttryck som anger ökningen av loopparametern och, om nödvändigt, andra parametrar, sedan skrivs de i en lista. Till exempel: x+=0,1, i++

4.1.3 Ett exempel på att kompilera en algoritm och ett program i C++ för en cyklisk beräkningsprocess.

Beräkna värdet på ett uttryck:

b– initialt värde, dess värde skrivs in från tangentbordet och ändras inte;

a– förändringar i intervallet i steg om 1;

y– resultat, dess värden visas på skärmen.

Baserat på specifikationen är variabel a ett heltal, så den kan användas som en räknare i en räkneslinga.

Blockschemat för algoritmen för att lösa detta problem med hjälp av en räknecykel är som följer:

#omfatta

printf("Ange b:");

scanf(“%f”,&b);

printf("ett y\n");

för (a=0;a<=10;a++)

printf(“%3d”,a);

printf(“%8.2f\n”,y);

y=(a-b)/sqrt(a);

printf(“%8.2f\n”,y);

Blockdiagrammet för algoritmen för att lösa detta problem med hjälp av en slinga med en förutsättning är som följer:

Texten i C++-programmet som motsvarar denna algoritm är som följer:

#omfatta

printf("Ange b:");

scanf(“%f”,&b);

printf("ett y\n");

printf(“%3d”,a);

printf(“%8.2f\n”,y);

y=(a-b)/sqrt(a);

printf(“%8.2f\n”,y);

else printf(“y existerar inte\n”);

Blockdiagrammet för algoritmen för att lösa detta problem med en slinga med ett postvillkor är som följer:

Texten i C++-programmet som motsvarar denna algoritm är som följer:

#omfatta

printf("Ange b:");

scanf(“%f”,&b);

printf("ett y\n");

printf(“%3d”,a);

printf(“%8.2f\n”,y);

y=(a-b)/sqrt(a);

printf(“%8.2f\n”,y);

else printf(“y existerar inte\n”);

medan (a<=10);

Praktisk del

4.2.1 Krav för att utföra arbetet:

Slutför uppgiften från laboratoriearbete nr 3 för en rad värden för en av variablerna. Variabeln som ändras, dess ändringsområde och steg anges i tabell 4. Skapa blockdiagram av algoritmer och program för de två typer av cykler som specificeras i den individuella uppgiften (tabell 4).

Formalisera resultatet av resultaten på ett sådant sätt att värdena för variabelparametern är tydligt markerade och för varje specifikt värde visas värdena för resultatet (tre variabler från kolumn 2 i Tabell 3) i formuläret av ett bord.

Ordningen på arbetet.

1. Gör en analys av uppgiften, formulera en problemformulering.

2. Skapa blockdiagram av algoritmer.

3. Skapa ett program i C++. Tillhandahåll inmatning av initiala data från tangentbordet och utmatning av resultat till skärmen.

4. Kontrollera programmets funktionalitet på olika initiala data.

5. Analysera de erhållna resultaten.

Möjlighet till individuella uppdrag.

Alternativ för individuella inlämningsuppgifter väljs från Tabell 4 i enlighet med elevnumret i grupplistan i lärarjournalen.

Tabell 4. Alternativ för enskilda uppgifter

Nej.	Föränderlig variabel	Typer av cykler

	10 ≤ a ≤ 10,Δ a=1

	-4 ≤ d ≤ 4, Δ d = 0,5
	-6 ≤ x ≤ 3, Δ x = 0,5
	0 ≤ b ≤ 3 0, Δ b = 1,5	1. Med förutsättning, 2. Räknebar
	-15 ≤ j ≤ 1 0, Δ j = 0,5	1. With precondition, 2. With postcondition
	5 ≤ e ≤ 35,Δ e = 2	1. Räknebar, 2. Med efterskick
	-5 ≤ m ≤ 15,Δ m = 1	1. Med förutsättning, 2. Räknebar
	1 ≤ c ≤ 70,Δ c = 3	1. With precondition, 2. With postcondition
	1,5 ≤ c ≤ 15,Δ c = 0,5	1. Räknebar, 2. Med efterskick
	-8 ≤ b ≤ 28,Δ b = 2	1. Med förutsättning, 2. Räknebar
	-4,5 ≤ x ≤ 11,5,Δ x = 0,5	1. With precondition, 2. With postcondition
	-7 ≤ k ≤ 2,Δ k = 0,3	1. Räknebar, 2. Med efterskick
	-1 ≤ m ≤ 21,Δ m = 1	1. Med förutsättning, 2. Räknebar
	-2 ≤ e ≤ 34,Δ e = 2	1. With precondition, 2. With postcondition
	-11 ≤ c ≤ 23,Δ c = 2	1. Räknebar, 2. Med efterskick
	-13 ≤ p ≤ 50,Δ p = 3	1. Med förutsättning, 2. Räknebar
	3,3 ≤ b ≤ 9,3,Δ b = 0,3	1. With precondition, 2. With postcondition
	3,5 ≤ y ≤ 12,3,Δ y = 0,4	1. Räknebar, 2. Med efterskick
	-7,5 ≤ a ≤ 5,7,Δ a = 0,6	1. Med förutsättning, 2. Räknebar
	-1,5 ≤ h ≤ 1,2,Δ h = 0,1	1. With precondition, 2. With postcondition
	0 ≤ h ≤ 10,Δ h=0,5	1. Räknebar, 2. Med efterskick
	-15 ≤ b ≤ 15, Δ b = 2	1. Med förutsättning, 2. Räknebar

	-7 ≤ l ≤ 3, Δ l = 0,5	1. With precondition, 2. With postcondition
	-5,5 ≤ b ≤ 6,5, Δ b = 0,5	1. Räknebar, 2. Med efterskick
	1 ≤ k ≤ 9, Δ k = 0,4	1. Med förutsättning, 2. Räknebar
	0 ≤ b ≤ 6,9,Δ b = 0,3	1. With precondition, 2. With postcondition
	-3 ≤ v ≤ 9,Δ v = 0,6	1. Räknebar, 2. Med efterskick
	-2 ≤ p ≤ 2,6,Δ p = 0,2	1. Med förutsättning, 2. Räknebar

4.3 Testfrågor och praktiska uppgifter:

1. Hur fungerar while-satsen?

2. Hur fungerar do ... while statement?

3. Hur fungerar for-utlåtandet?

4. Understryka de påståenden i programmet som bildar en cykel.

5. Vad är skillnaden mellan påståenden while och do ... while?

6. Byt ut en loopoperator i programmet med en annan.

I programmering stöter vi ofta på problem som innebär att processer upprepas. Därför måste vi känna till och kunna använda ett sådant begrepp som " cykliska beräkningsprocesser».

Det blir lätt för en nybörjare att förstå dem med ett generaliserat exempel. Dessutom är det viktigt att förstå att det i alla programmeringsspråk finns sätt att implementera loopar.

Vad är en loop i programmering?

En cykel - i programmering, är den upprepade upprepningen av samma åtgärder eller beräkningar, men enligt samma beroenden med olika värden på variablerna.

Vi möter begreppet en cykel inte bara i programmering. Det finns cykler på många områden i våra liv.

Till exempel är vattnets kretslopp i naturen ett naturligt kretslopp i våra liv.

Låt oss nu titta på de allmänna reglerna och begreppen som används i beräkningscykler.

Stadier av den cykliska processen

I allmänhet bör cykeln implementeras i fyra steg:

Steg 1 – förberedelse av cykeln (initiering).
Inställning av initialvärdet för parametern och loopvariabeln.
Slingparameter– detta värde som räknar antalet steg i cykeln (antal repetitioner av cykeln).
Slingvariabelär en storhet som ändrar sitt värde i varje skede av cykeln.
Initialisering– detta ställer in initialvärdena för parametern och loopvariabeln.
Steg 2 – cykelns kropp.
Detta är upprepad upprepning av en åtgärd i en cykel eller beräkningar baserade på samma matematiska beroenden med olika värden på variabler.
Steg 3 – modifiering (ändring) av cykeln.
Steg 4 – cykelhantering.
Detta är en tillståndskontroll för fortsättning eller start av slingan.

Det finns 3 loopoperatorer i pascal som kan implementera vilken som helst algoritmiskt – cyklisk struktur :

Slingoperatör med parameter
Slingoperatör med förutsättning
Slingoperatör med efterskick

Vi kommer att titta på dem i detalj i följande artikel.

1. Metoder för att konstruera cykliska beräkningsprocesser i program.

2. Angett i datornNriktiga nummer. Skriv ett program som visar det aritmetiska medelvärdet för denna uppsättning.

Introduktion

Cykliska program används i nästan alla program. I det här fallet kan cykler vara explicita eller implicita. I synnerhet finns den implicita slingan i avbrottshanterare, som effektivt körs i en oändlig slinga vars kropp triggas av avbrottet. Subrutiner - fönsterfunktioner i Windows-applikationer - är också cykliska. Nedan betraktar vi program med en loop vars kropp innehåller funktionella moduler.

Cyklisk processär en beräkningsprocess där beräkningar utförs upprepade gånger med samma formler för olika värden av argumentet.

Program, att implementera en cyklisk process kallas cykliska program.

Organisationen av cykeln kan delas in i följande steg:

förberedelse (initiering) av cykeln (AND);

utföra loopberäkningar (loopkropp) (T);

modifiering av parametrar (M);

kontroll av cykelns sluttillstånd (U).

Ordningen på dessa steg, såsom T och M, kan variera. Beroende på platsen för konditionskontrollen av cykelslutet görs en skillnad mellan cykler med nedre och övre ändar. För en bottenavslutande slinga exekveras slingans kropp minst en gång eftersom beräkningarna utförs först och sedan kontrolleras villkoret för att lämna slingan.

I fallet med en toppslutande loop får slingans kropp inte exekveras ens en gång om utgångsvillkoret omedelbart är uppfyllt.

En cykel kallas deterministisk om antalet repetitioner av slingkroppen är känt eller bestämt i förväg. En cykel kallas iterativ om antalet repetitioner av loopkroppen är okänt i förväg, men beror på värdena för parametrarna (vissa variabler) som är involverade i beräkningarna.

Loop Body– Det här är ett upprepat avsnitt i programmet.

Slingparameterär en variabel som får nya värden varje gång loopen upprepas (slingor kan vara enkla eller komplexa).

Allmän bild av slingan n gånger

I allmänhet skrivs en slinga n gånger så här:

nc antal repetitioner gånger

Serviceordet nts (början av cykeln) och kts (slutet av cykeln) skrivs strikt under varandra och förbundna med en vertikal linje. Till höger om denna rad skrivs en repeterbar sekvens av kommandon (loopkropp).

Antalet repetitioner är ett godtyckligt heltal.

Vid exekvering av algoritmen upprepas sekvensen av kommandon i slingans kropp det angivna antalet gånger. Reglerna för det algoritmiska språket tillåter att ange vilket heltal som helst av repetitioner. Det kan vara noll eller till och med negativt. Dessa fall anses inte vara felaktiga, slingans kropp kommer helt enkelt inte att exekveras en gång, och datorn kommer omedelbart att fortsätta att utföra kommandona som skrivits efter cc

Generell bild av cykeln hittills

I allmänhet är cykeln för närvarande skriven enligt följande:

inget skick ännu

| loop body (sekvens av kommandon)

När du utför en cykel upprepar datorn följande åtgärder:

a) kontrollerar villkoret skrivet efter funktionsordet while;

b) om villkoret inte är uppfyllt, avslutas exekveringen av slingan och datorn börjar utföra de kommandon som skrivits efter cc. Om villkoret är uppfyllt, kör datorn slingans kropp, kontrollerar villkoret igen, etc.

Generell bild av cykeln för

nc för i från i1 till i2

| loop body (sekvens av kommandon)

Här är i namnet på ett heltalstypvärde, i1, i2 är godtyckliga heltal eller uttryck med heltalsvärden. Slingans kropp exekveras sekventiellt för i = i1, i = i1 + 1, i1 + 2, …i = i2.

Reglerna för det algoritmiska språket tillåter att ange alla heltal i1, i2. i2 kan i synnerhet vara mindre än i1. det här fallet anses inte vara ett fel - helt enkelt slingans kropp kommer inte att exekveras ens en gång, och datorn kommer omedelbart att fortsätta med att utföra kommandona som skrivits efter cc.

Slinga n gånger och loop medan

Slingor n gånger och än så länge är formaterade på nästan samma sätt i det algoritmiska språket. Detta är inte förvånande, eftersom båda dessa kommandon definierar en loop - en upprepad sekvens av kommandon. Serviceorden nts och kts indikerar att en slinga exekveras, och slinghuvudet specificerar den specifika mekanismen för dess exekvering.

Dessa två cykler har dock en signifikant skillnad. När datorn börjar köra en loop n gånger vet den hur många gånger den kommer att behöva upprepa loopens kropp. När man kör en loop är detta inte fallet ännu: datorn kontrollerar slingans tillstånd varje gång och kan inte i förväg avgöra när exekveringen ska avslutas. För närvarande kan du ta reda på antalet repetitioner av en cykel först efter att cykeln är klar.

Detta gör det tydligt i vilka fall vilken slinga som ska användas. Om antalet repetitioner är känt när slingan startar är det bekvämt att använda slingan n gånger. Om antalet repetitioner inte kan bestämmas i förväg är en cykel nödvändig.

Till exempel har ett automatiskt styrprogram strukturen som visas i fig. 1. Moduler som ingår i cykeln(liksom avbrottshanteringsmoduler), med en ingång och en utgång vardera, har typiskt den karakteristiska egenskapen att modulerna innehåller statiska variabler som tilldelas ett värde i den aktuella cykeln, och analysen av dessa variabler utförs i nästa cykel . De nämnda variablerna karakteriserar således modulens tillstånd vid slutet av den aktuella eller början av nästa programcykel. I det följande kommer vi endast att överväga sådana moduler av cykliska program och kort beteckna dem som MCP.

Figur 1. Typisk struktur för ett styrprogram med en oändlig slinga.

MCP har en varierad struktur, vars komplexitet måste bedömas enligt särskilda kriterier. V.V. Lipaev föreslog ett bekvämt och objektivt kriterium för komplexiteten hos programvarumoduler, nämligen: antalet och totala längden av vägar i modulens kontrollgraf. Endast villkors- och urvalsangivelser beaktas. Detta kriterium är dock uppenbarligen inte tillräckligt för en MCP med statiskt minne, för när man analyserar en MCP är det nödvändigt att komma ihåg värdena för alla statiska variabler som ställts in i föregående cykel. Dessutom finns det inga rekommendationer för standardisering av algoritmer och program, förutom den sedan länge kända strukturerade programmeringen i vanliga programmeringsspråk som C och Pascal. Den här artikeln föreslår att man fyller dessa luckor i förhållande till MCP.

2. Fragment av cykliska programmoduler

Ett tvåterminalt fragment, eller helt enkelt ett fragment, kommer att betraktas som en sektion av ett program med en ingång och en utgång (inklusive slingoperatorer) under antagandet att MCP:erna i fråga är strukturerade. Det enklaste fragmentet innehåller ett enda uttalande. En sekvens av fragment är också ett fragment. MCP är i sin tur ett fragment och består av en sekvens av fragment.

Metoden för oberoende fragment föreslås för att syntetisera strukturen av moduler som implementerar beslutstabeller. I det här fallet anses ett fragment som kan infogas var som helst i sekvensen av modulfragment vara oberoende. Oberoendet av platsen för ett sådant fragment beror på det faktum att data som analyseras i det inte genereras i den specificerade sekvensen av fragment, och data som genereras i det oberoende fragmentet analyseras inte i denna sekvens av fragment. Därför kan oberoende fragment exekveras parallellt (pseudo-parallell). I fig. Figur 2 visar möjliga implementeringsalternativ för en modul med två oberoende fragment. I alternativen "a" och "b" omarrangeras fragmenten utan att förvränga programmets kärna; i alternativ "c" implementeras fragmenten parallellt.

Fig.2. Alternativ för att implementera en modul med oberoende fragment:

a) och b) - sekventiell implementering,

c) - parallell implementering: en dubbel horisontell linje indikerar parallellisering av programmet, en tjock horisontell linje indikerar slutförandet av parallella processer.

Ett beroende fragment är ett vars placering beror på platsen för ett annat fragment(er) i modulen. Vi kommer att skilja mellan ovan- och underberoende fragment. Det toppberoende fragmentet måste alltid vara beläget under något fragment där variablerna som används i detta (beroende) fragment bildas. Ett bottenberoende fragment ska alltid placeras ovanför ett fragment som använder variabler som genereras i detta fragment. Två beroende fragment, varav ett är beroende uppifrån av det andra och det andra underifrån beroende av det första, kommer att kallas ömsesidigt beroende fragment. De kan inte utbytas och kan inte implementeras parallellt. I fig. Figur 3 visar ett exempel på en modul med ömsesidigt beroende fragment. Mellan ömsesidigt beroende fragment kan det finnas andra, beroende eller oberoende av dem. Fig.3. Modul med beroende fragment.

Vi kommer att kalla ett beroende fragment vars plats i modulen är strikt definierad som fast. Till exempel, i modulen för att känna igen ett tecken som matas in från tangentbordet, måste det första vara det bottenberoende fragmentet av den faktiska teckeninmatningen. Operatörerna "start" och "slut" för en modul är fasta fragment.

Absolut oberoende fragment existerar inte, om så bara för att det i någon modul finns de nämnda fasta fragmenten av början och slutet. Därför har ett oberoende fragment i allmänhet ett möjligt lokaliseringsområde begränsat av två ömsesidigt beroende fragment. Det vill säga, en mer strikt definition av ett oberoende fragment är följande: oberoende med avseende på två fixerade fragment kommer vi att kalla ett fragment som kan placeras var som helst i sekvensen av fragment som avgränsas ovanför och under av de specificerade fixerade fragmenten.

Populär i kategorin: