Programmering av sykliske databehandlingsprosesser. Programmering av sykliske databehandlingsprosesser. Et eksempel på bruk av for-setningen

I programmering er det ofte oppgaver som krever gjentatt utførelse av den samme gruppen av programsetninger med forskjellige verdier av deres operander. Slike prosesser kalles syklisk eller rett og slett sykluser. En gruppe syklisk gjentatte utsagn danner den såkalte løkkekropp, som kan representeres av enten et enkelt eller sammensatt uttrykk. Vi vil kalle engangsutførelsen av loopen kroppen iterasjon.

Brødteksten til en loop i et program er alltid innledet med løkkehode, som inneholder betegnelsen sløyfeoperatør og et uttrykk som definerer (direkte eller indirekte) antall iterasjoner. Legg merke til at sløyfens hoveddel er operanden til sløyfeoperatøren; derfor utgjør overskriften og hoveddelen av løkken en udelelig strukturell enhet i programmet. I det følgende bruker du begrepet " sløyfeoperatør", vil vi mene både overskriften og hoveddelen av loopen.

For å organisere sykluser i alle programmeringssystemer, er det spesialiserte sløyfeoperatører, hvis bruk avlaster programmereren for behovet for å programmere sykluser "manuelt". MathCAD støtter to typer slike operatører - syklus med predestinasjon Til (også kalt løkke med teller) Og sløyfe med forutsetning Samtidig som . En beskrivelse av strukturen til disse operatørene er gitt i tabell 5.

5.4.1 Operatør Til

Denne operatøren bør brukes i tilfeller hvor antall iterasjoner er forhåndsbestemt, det vil si kjent på forhånd.

Loop header av denne operatoren (den høyre operanden) inneholder en variabel kalt parameter(eller teller) syklus, Og liste over verdier denne parameteren. Antall elementer i listen bestemmer også antall iterasjoner - under hver iterasjon mottar loop-parameteren neste verdi fra listen spesifisert i overskriften.

Sløyfeparameter har status som en intern programvariabel og har alle dens egenskaper (beskrevet i avsnitt 5.1.4). Som regel brukes loop-parameteren på høyre side av uttrykkene som er inkludert i løkken, selv om det ikke er formelt forbudt å bruke den på venstre side av uttrykk (det vil si til venstre for den lokale definisjonen operatør "f"). Det bør huskes at hvis en parameter ble endret i sløyfen, vil dens endrede verdi bare være gyldig til slutten av gjeldende iterasjon, siden før starten av neste iterasjon vil parameteren fortsatt motta den neste verdien fra liste spesifisert i løkkeoverskriften.

Formelt er det tillatt å ikke bruke loop-parameteren i det hele tatt i uttrykkene til loop-kroppen - i dette tilfellet spiller ikke listen over parameterverdier noen rolle - bare lengden på denne listen er signifikant, noe som bestemmer antall (muligens meningsløse) iterasjoner.

Når den siste iterasjonen er fullført, vil programsetningen etter loop-setningen bli utført. I dette tilfellet beholder variabelen som brukes som parameter for den fullførte sløyfen verdien den hadde i den siste faktisk fullført iterasjon[*]. Merk at denne verdien ikke alltid sammenfaller med den siste verdien fra listen spesifisert i løkkeoverskriften, siden en "tidlig" utgang fra løkken er mulig når operatøren utløses Gå i stykker inkludert i løkkens kropp.

Liste over verdier Løkkeparameteren skrives i løkkeoverskriften etter symbolet " Î ", som indikerer medlemskap i et sett (dette symbolet trenger ikke å legges inn manuelt - det vil automatisk vises når du går inn i operatøren Til ). MathCAD tillater bruk tre former oppføringer i denne listen: direkte overføring– listeelementer er eksplisitt spesifisert atskilt med kommaer, parameteren mottar verdier fra listen i den rekkefølgen de vises; i rangert variabel stil – elementene i listen danner den tilsvarende aritmetiske rekken; array– listeelementer mottar sekvensielt verdiene til matriseelementer i rekkefølgen til deres indekser (først kolonner fra venstre til høyre, deretter rader fra topp til bunn).

De tre programmene vist i figur 21 illustrerer ulike bruksområder for operatøren Til .

Program Fakta(n) beregner faktoren til et tall n . Løkkeoperatoren i dette programmet er en del av et sammensatt uttrykk, som igjen er operanden til en betinget operator Ellers. Sløyfeparameter k henter verdier fra en heltalls aritmetisk serie.

Program Ch(V,N,p) behandler inngangsvektoren V , og erstatter den med verdien s de elementene hvis indekser er spesifisert av elementene i den andre inngangsvektoren N . I dette eksemplet, en liste over løkkeparameterverdier Jeg definert av et sett med vektorelementer N . Merk at begge disse programmene utfører inputdatakontroll og blokkerer kjøringen av hovedalgoritmen hvis de faktiske programargumentene er angitt feil.

Program L(M,z) gitt i eksemplet V ), er ledsaget av detaljerte kommentarer og krever ingen forklaring. Dette programmet illustrerer muligheten for å bruke flere loop-setninger, hvorav en er inkludert blant setningene kropp en annen. Bruk nestede løkker- en typisk teknikk som brukes til å behandle flerdimensjonale arrays.

Figur 21 – Eksempler på syklusprogrammering Til

Figur 22 illustrerer bruken av operatører Gå i stykker Og Fortsette i løkkens kropp. Vanligvis er disse operatørene selv operander betingede uttalelser Hvis eller Ellers .

Operatør Gå i stykker ("avbryte") avbryter utførelse av sløyfen og overfører kontrollen til operatøren etter den avbrutte sløyfeoperatøren. Merk at hvis operatøren Gå i stykker avbrutt nestet løkke, vil utførelsen av den ytre sløyfen fortsette.

Operatør Fortsette ("fortsette") handler annerledes - han avbryter kun gjeldende iterasjon av sløyfen og overfører kontrollen til overskriften til denne løkken, hvoretter løkken utføres fortsetter fra neste iterasjon (med mindre, selvfølgelig, den avbrutte iterasjonen var den siste).

Operatør Gå i stykker lov til å bruke og utenfor syklusens kropp. I dette tilfellet blir utførelsen av hele subrutinen avbrutt, og resultatet av evalueringen av det siste faktisk utførte uttrykket returneres.

Figur 22 – Eksempler på bruk av operatorer Gå i stykker Og Fortsette

Funksjon SumN(V) summerer bare de elementene i vektoren som inneholder skalardata av numerisk type, og hopper over de gjenværende elementene. Funksjon Invers (V) danner en vektor hvis elementer er de inverse verdiene til de tilsvarende elementene i den opprinnelige vektoren. Videre, hvis det neste elementet inneholder tallet "0" eller ikke er en skalar av en numerisk type, syklusen avbrytes. Merk at operatøren Gå i stykker i det siste eksemplet avbryter den ikke programmet, men overfører kontrollen til operatøren Komme tilbake , umiddelbart etter operatøren Til .

5.4.3 Operatør Samtidig som

I motsetning til operatøren Til , setningsoverskrift Samtidig som (i oversettelse - " Ha det") inneholder ikke eksplisitte indikasjoner på antall iterasjoner - den inneholder logisk uttrykk, hvis verdi beregnes automatisk før begynnelsen utførelse av hver neste iterasjon[†]. Så lenge dette uttrykket er sant, vil loopen fortsette å iterere; så snart uttrykket blir usant etter fullføringen av neste iterasjon, vil ikke neste iterasjon av løkken bli utført, og programsetningen etter setningen vil motta kontroll Samtidig som .

Det er klart, hvis et identisk falskt logisk uttrykk plasseres i løkkeoverskriften, vil denne løkken ikke fullføre noen av sine iterasjoner, og hvis dette uttrykket er identisk sant, vil løkken være uendelig (sistnevnte situasjon kalles looping programmer). For å unngå slike situasjoner må operandene til et logisk uttrykk inkludere en eller flere variabler som endrer verdiene deres i løkkens kropp slik at sløyfen er begrenset (andre midler kan brukes for å forhindre sløyfe - for eksempel å tvinge operatøren til å gå ut av sløyfen Gå i stykker ).

Eksempler på bruk av operatoren Samtidig som er vist i figur 23. Tre alternativer for å løse det samme problemet er gitt: hvert av programmene F0 , F1 Og F2 returnerer indeksen til det første elementet i kildevektorenV overskrider den angitte verdienz .

Første program (eksempel EN ) legger en til telleren k i løkkens kropp Samtidig som til neste k elementet i den opprinnelige vektoren vil ikke overskride den angitte verdien z . Etter dette avsluttes loopen og programmet returnerer den siste endrede verdien av variabelen k , som er løsningen på problemet. Merk at, i motsetning til syklusen Til , disk k her er det nødvendig å behandle det med separate uttalelser: initialiser (det vil si tilordne det en startverdi) før sløyfeoperatøren og endre verdien i løkkens kropp.

Det er lett å se at alternativet EN ) av programmet har en betydelig ulempe: det forhindrer ikke at programmet går i løkke i tilfellet når problemet ikke har noen løsning, det vil si når parameteren z overskrider verdien av det største elementet i vektoren V . I dette eksemplet vil looping i en slik situasjon egentlig ikke skje - men dette er ikke fordelen med programmet vårt, men MathCAD-systemet, som vil kontrollere utgangen av vektorindeksen V utenfor de tillatte verdiene og vil generere en feilmelding.

Fri fra denne ulempen er alternativet b ) av et program der hoveddelen av løkken inneholder en ekstra sjekk for gyldigheten av neste indeksverdi og tvinger sløyfen med operatøren Gå i stykker i passende situasjon med utstedelse av en tekstmelding.

Kanskje den mest effektive løsningen på dette problemet er alternativet V ), som ikke bruker operatøren i det hele tatt Samtidig som . I dette programmet er variabelen k brukes bare for å opprettholde "stilrenhet" - for å utelukke behandling av loopparameteren Jeg utenfor operatøren Til .

Figur 23 – Eksempler på syklusprogrammering Samtidig som

Målet med arbeidet:

Studer de sykliske operatorene for, while, do - while, lær hvordan du komponerer og programmerer sykliske algoritmer.

Kort teoretisk informasjon

Sløyfeoperatører brukes når det er nødvendig å gjenta visse handlinger (operatører og operasjoner) flere ganger, og slike deler av algoritmer kalles løkker.

For loop-operatøren

Den grunnleggende formen for for loop-setningen er:

for (uttrykk_1; uttrykk_2; uttrykk_3)

operatør;

Hvor uttrykk_1– startverdien til syklusparameteren;

uttrykk_2– kontrollere betingelsene for fortsettelse av syklusen;

uttrykk_3– endring av syklusparameter (korreksjon);

operatør– enkel eller sammensatt operator i C-språk.

Operatørens operasjonsskjema er som følger: bare én gang beregnes først expression_1, deretter blir expression_2 sjekket, og hvis det er "sant", utføres en syklisk del av programmet, deretter blir parameteren korrigert, og så videre til expression_2 tar verdien "false".

For eksempel: for (k=1; k<5; k++)

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

Som et resultat av å utføre denne operatoren, blir tallene fra 1 til 4 skrevet ut i en kolonne.

Du kan bruke en variabel av en hvilken som helst grunnleggende type som en sløyfeparameter.

For eksempel:

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

printf(“ %c”,ch); // Latinsk alfabet

Det er nødvendig å nøye kontrollere strukturen til for-løkkene i programmet, slik at du ikke ender opp med en endeløs løkke (som det ikke er noen utgang fra).

For eksempel:

for(k=10; k>6;k++)

printf(“endeløs loop\n”);

Exit loop foran skjema på følgende måter:

Ved tilleggsbetingelse;

Bruker følgende operatører:

gå i stykker;- gå ut av sløyfen der pausen er lokalisert, kontrollen overføres til den første utførte setningen etter sløyfen;

exit(int Kod);- gå ut av programmet;

komme tilbake;- gå ut av funksjonen;

Bruke den ubetingede hoppoperatoren gå til<метка>;

Tidlig fullføring av det nåværende sykliske trinnet mulig ved bruk av en ekstra betingelse eller operatør Fortsette, som avbryter utførelsen av det gjeldende løkketrinnet, dvs. hopper over setningene til resten av løkken og overfører kontrollen til hodesetningen til løkken for å justere parameteren og sjekke tilstanden.

Det er forbudt å overføre kontroll fra utsiden til innsiden av sløyfen.

Noen av for-løkke-uttrykkene i parentes kan mangle, men ";"-symbolet kan ikke senkes.

For eksempel:

for (; jeg<3; i++)

puts(“Hei!”);

Sykliske stund- og gjør-mens-utsagn

Grunnform for den sykliske operatøren samtidig som:

Mens (tilstand)

operatør;

Hvor operatør

Løkken løper så lenge tilstanden evalueres til sann, dvs. uttrykket i parentes returnerer et resultat som ikke er null. Dette er en sløyfe med en forutsetning - først sjekkes betingelsen, deretter utføres setningen. Derfor vil while-løkken ikke bli utført en gang hvis det første resultatet av å beregne betingelsen er 0.

Grunnleggende operatørform gjør mens:

operatør;

while(tilstand);

Hvor operatør er et enkelt, sammensatt eller tomt utsagn.

Operatør gjøre–samtidig som– sløyfeoperatør med postcondition, dvs. først utføres setningen, og deretter kontrolleres betingelsen for sannhet. Siden betingelsen i en do-while-løkke kontrolleres på slutten av løkken, vil løkken bli utført minst én gang.

I løkker som while og do–while er de samme metodene for tidlig utgang fra løkken og tidlig fullføring av det nåværende trinnet i løkken tillatt som i for-setningen, men i sistnevnte tilfelle, i motsetning til for-løkken, overføres kontrollen å sjekke tilstanden. For å forhindre en endeløs løkke inne i while- og do-while-løkkene, må du sørge for å endre variablene som er inkludert i betingelsen.

For eksempel:

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

if (i%5!=0) fortsett;

printf(“%5d”,i);

Eksempler på uendelige løkker:

operatør;

2) while(nummer_ikke_0) // Alltid sant!

operatør;

operatør;

while(nummer_ikke_0); // Alltid sant!

Blant sløyfeoperatørene skal det være en utgangsbetingelse.

Nestede løkker

Når det gjelder nestede løkker, er en løkke inne i en annen, for eksempel:

for(i=nn;i

for(j=mn;j

operatør;

Hvor operatør er et enkelt, sammensatt eller tomt utsagn. Den indre sløyfen vil bli utført for hver verdi av parameter i som tilfredsstiller betingelsen til den ytre sløyfen.

Eksempel:

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

for(j=1;j<4;j++)

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

printf(“\n”);

Et eksempel på bruk av for-setningen

Regne ut. Programmet skal skrive ut mellom- og sluttresultater.

Programteksten kan se slik ut

#inkludere

#inkludere

puts(“Skriv inn N”);

scanf(“%d”,&N);

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

( // ta og dobbel oppgave

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

printf("\n SVAR: s=%f, Trykk på hvilken som helst tast...",s);

Valgmuligheter for individuelle oppdrag

Skriv et program for å bestemme en tabell med funksjonsverdier på i et vilkårlig område [ en,b] argument endres X med vilkårlige skritt h. Verdier a, b, h tastet inn fra tastaturet. Tabellen må inneholde følgende kolonner: sekvensnummer, argumentverdi x, funksjonsverdi, melding om økende eller minkende funksjon, forskjell på to tilstøtende funksjonsverdier.

Bestem maksimums- og minimumsverdiene for funksjonen.

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 sykliske databehandlingsprosesser"

Målet med arbeidet: mestre metoder for kompilering av algoritmer for sykliske beregningsprosesser og organisering av sykliske programmer med kompleks struktur.

Teoretisk del

4.1.1. Sykliske algoritmer.

En syklus er en sekvens av handlinger som kan utføres mer enn én gang.

En round-robin-algoritme er en algoritme som inneholder en eller flere løkker.

Det er 3 typer sykluser:

Løkke med forutsetning;

Løkke med postcondition;

Sløyfe med teller (telleløkke).

Hvis utførelsen av en løkke er assosiert med en logisk betingelse, brukes løkker med en forutsetning eller en postbetingelse.

Tellerløkker er en klasse der utførelsen av løkkelegemet må gjentas et forhåndsbestemt antall ganger.

Blokkdiagrammer av sykliske algoritmer ser slik ut:

1. Løkke med en teller.

2. Løkke med forutsetning. 3. Løkke med postcondition.

4.1.2 Sløyfeoperatører i programmeringsspråket C++.

I C++, for hver type sløyfe er det en tilsvarende operatør:

Løkke som mens (med forutsetning);

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

Løkke som for (telling).

1. Loop operatør som mens

Påmeldingsskjema:

mens (tilstand) uttalelse;

hvor: (betingelse) – logisk uttrykk;

operatør – operatøren eller kroppen til sløyfen utført i en sløyfe.

Hvis hoveddelen av løkken er en sammensatt setning, må den være omsluttet av operatørparenteser (...):

mens (tilstand)

gruppe operatører

Opplegget for hvordan en slik sløyfe fungerer: mens betingelsen er sann, utføres sløyfens kropp og tilstanden sjekkes igjen, etc. Når tilstanden blir falsk, går løkken ut.

2. Sløyfeoperatør som gjør...mens

Påmeldingsskjema:

operatør;

while(tilstand);

Opplegget for hvordan en slik sløyfe fungerer: først utføres operatøren, deretter kontrolleres betingelsen, hvis betingelsen er sann, utføres operatøren og betingelsen sjekkes igjen, etc. Når tilstanden blir falsk, går løkken ut.

Hvis hoveddelen av løkken er en sammensatt setning, må den, som for en løkke med en forutsetning, være omsluttet av operatørparenteser (...):

gruppe operatører

while(tilstand);

3. Sløyfeoperatør som for

Påmeldingsskjema:

operatør;

A er et startuttrykk som spesifiserer startverdier for loop-parameteren og, om nødvendig, startverdier for andre parametere. For eksempel:

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

B er et betinget uttrykk som kontrollerer betingelsen for å fortsette loopen. For eksempel:

C er et inkrementuttrykk som spesifiserer inkrementet til loop-parameteren og om nødvendig andre parametere, så skrives de i en liste. For eksempel: x+=0,1, i++

4.1.3 Et eksempel på kompilering av en algoritme og et program i C++ for en syklisk databehandlingsprosess.

Regn ut verdien av et uttrykk:

b– startverdi, verdien legges inn fra tastaturet og endres ikke;

en– endringer i området i trinn på 1;

y– Resultatet vises verdiene på skjermen.

Basert på spesifikasjonen er variabel a et heltall, så den kan brukes som en teller i en tellesløyfe.

Blokkdiagrammet for algoritmen for å løse dette problemet ved hjelp av en tellesyklus er som følger:

#inkludere

#inkludere

#inkludere

printf("Skriv inn b:");

scanf(“%f”,&b);

printf(“et y\n”);

for (a=0;a<=10;a++)

printf(“%3d”,a);

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

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

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

Blokkdiagrammet for algoritmen for å løse dette problemet ved å bruke en sløyfe med en forutsetning er som følger:

Teksten til C++-programmet som tilsvarer denne algoritmen er som følger:

#inkludere

#inkludere

#inkludere

printf("Skriv inn b:");

scanf(“%f”,&b);

printf(“et y\n”);

printf(“%3d”,a);

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

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

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

else printf(“ y eksisterer ikke\n”);

Blokkdiagrammet for algoritmen for å løse dette problemet ved å bruke en sløyfe med en postbetingelse er som følger:

Teksten til C++-programmet som tilsvarer denne algoritmen er som følger:

#inkludere

#inkludere

#inkludere

printf("Skriv inn b:");

scanf(“%f”,&b);

printf(“et y\n”);

printf(“%3d”,a);

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

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

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

else printf(“ y eksisterer ikke\n”);

mens (a<=10);

Praktisk del

4.2.1 Krav for å utføre arbeidet:

Fullfør oppgaven fra laboratoriearbeid nr. 3 for en rekke verdier for en av variablene. Variabelen som endres, dens endringsområde og trinn er angitt i tabell 4. Lag blokkskjemaer av algoritmer og programmer for de to syklustypene som er spesifisert i den enkelte oppgaven (tabell 4).

Formaliser resultatet av resultatene på en slik måte at verdiene til variabelparameteren er tydelig fremhevet, og for hver spesifikk verdi vises verdiene til resultatet (tre variabler fra kolonne 2 i tabell 3) i skjemaet av et bord.

Arbeidsrekkefølgen.

1. Utfør en analyse av oppgaven, formuler en problemstilling.

2. Lag blokkdiagrammer av algoritmer.

3. Lag et program i C++. Gi inndata av innledende data fra tastaturet og utdata av resultater til skjermen.

4. Sjekk funksjonaliteten til programmet på ulike startdata.

5. Analyser de oppnådde resultatene.

Valgmuligheter for individuelle oppdrag.

Alternativer for individuelle oppgaver velges fra tabell 4 i henhold til elevnummeret i gruppelisten i lærerens journal.

Tabell 4. Alternativer for enkeltoppgaver

Nei.	Mulig variabel	Typer av sykluser
	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 forutsetning, 2. Tellelig
	-15 ≤ j ≤ 1 0, Δ j = 0,5	1. With precondition, 2. With postcondition
	5 ≤ e ≤ 35,Δ e = 2	1. Tellelig, 2. Med postcondition
	-5 ≤ m ≤ 15,Δ m = 1	1. Med forutsetning, 2. Tellelig
	1 ≤ c ≤ 70,Δ c = 3	1. With precondition, 2. With postcondition
	1,5 ≤ c ≤ 15,Δ c = 0,5	1. Tellelig, 2. Med postcondition
	-8 ≤ b ≤ 28,Δ b = 2	1. Med forutsetning, 2. Tellelig
	-4,5 ≤ x ≤ 11,5,Δ x = 0,5	1. With precondition, 2. With postcondition
	-7 ≤ k ≤ 2,Δ k = 0,3	1. Tellelig, 2. Med postcondition
	-1 ≤ m ≤ 21,Δ m = 1	1. Med forutsetning, 2. Tellelig
	-2 ≤ e ≤ 34,Δ e = 2	1. With precondition, 2. With postcondition
	-11 ≤ c ≤ 23,Δ c = 2	1. Tellelig, 2. Med postcondition
	-13 ≤ p ≤ 50,Δ p = 3	1. Med forutsetning, 2. Tellelig
	3,3 ≤ b ≤ 9,3,Δ b = 0,3	1. With precondition, 2. With postcondition
	3,5 ≤ y ≤ 12,3,Δ y = 0,4	1. Tellelig, 2. Med postcondition
	-7,5 ≤ a ≤ 5,7,Δ a = 0,6	1. Med forutsetning, 2. Tellelig
	-1,5 ≤ h ≤ 1,2,Δ h = 0,1	1. With precondition, 2. With postcondition
	0 ≤ h ≤ 10,Δ h=0,5	1. Tellelig, 2. Med postcondition
	-15 ≤ b ≤ 15, Δ b = 2	1. Med forutsetning, 2. Tellelig
	-7 ≤ l ≤ 3, Δ l = 0,5	1. With precondition, 2. With postcondition
	-5,5 ≤ b ≤ 6,5, Δ b = 0,5	1. Tellelig, 2. Med postcondition
	1 ≤ k ≤ 9, Δ k = 0,4	1. Med forutsetning, 2. Tellelig
	0 ≤ b ≤ 6,9,Δ b = 0,3	1. With precondition, 2. With postcondition
	-3 ≤ v ≤ 9,Δ v = 0,6	1. Tellelig, 2. Med postcondition
	-2 ≤ p ≤ 2,6,Δ p = 0,2	1. Med forutsetning, 2. Tellelig

4.3 Testspørsmål og praktiske oppgaver:

1. Hvordan fungerer while-setningen?

2. Hvordan fungerer do ... while statement?

3. Hvordan fungerer for-uttalelsen?

4. Understrek utsagnene i programmet som danner en syklus.

5. Hva er forskjellen mellom while og do ... while-utsagn?

6. Bytt ut en sløyfeoperatør i programmet med en annen.

I programmering møter vi ofte problemer som involverer gjentatte prosesser. Derfor må vi kjenne til og kunne bruke et slikt konsept som " sykliske databehandlingsprosesser».

Det vil være lett for en nybegynner programmerer å forstå dem ved å bruke et generalisert eksempel. Dessuten er det viktig å forstå at i alle programmeringsspråk er det måter å implementere looper på.

Hva er en loop i programmering?

En syklus - i programmering, er gjentatt repetisjon av de samme handlingene eller beregningene, men i henhold til de samme avhengighetene med forskjellige verdier av variablene.

Vi møter begrepet en syklus ikke bare i programmering. Det er sykluser på mange områder av livene våre.

For eksempel er vannets kretsløp i naturen et naturlig kretsløp i livene våre.

La oss nå se på de generelle reglene og konseptene som brukes i beregningssykluser.

Stadier av den sykliske prosessen

Generelt bør syklusen implementeres i 4 trinn:

• Trinn 1 – forberedelse av syklusen (initialisering).
  Innstilling av startverdien for parameteren og sløyfevariabelen.
  Sløyfeparameter– denne verdien som teller antall trinn i syklusen (antall repetisjoner av syklusen).
  Løkkevariabel er en mengde som endrer sin verdi på hvert trinn i syklusen.
  Initialisering– dette er å angi startverdiene for parameteren og sløyfevariabelen.
• Trinn 2 – syklusens kropp.
  Dette er gjentatt repetisjon av en handling i en syklus eller beregninger basert på de samme matematiske avhengighetene med forskjellige verdier av variabler.
• Trinn 3 – modifikasjon (endring) av syklusen.
• Trinn 4 – syklusstyring.
  Dette er en tilstandssjekk for fortsettelse eller start av sløyfen.

Det er 3 loop-operatorer i pascal som kan implementere alle algoritmisk – syklisk struktur :

1. Loop statement med parameter
2. Sløyfeoperatør med forutsetning
3. Sløyfeoperatør med postcondition

Vi vil se på dem i detalj i den følgende artikkelen.

1. Metoder for å konstruere sykliske beregningsprosesser i programmer.

2. Lagt inn i datamaskinenNreelle tall. Skriv et program som viser det aritmetiske gjennomsnittet av dette settet.

Introduksjon

Sykliske programmer brukes i nesten all programvare. I dette tilfellet kan sykluser være eksplisitte eller implisitte. Spesielt er den implisitte sløyfen til stede i avbruddsbehandlere, som effektivt kjører i en uendelig sløyfe hvis kropp utløses av avbruddet. Subrutiner - vindusfunksjoner til Windows-applikasjoner - er også sykliske. Nedenfor tar vi for oss programmer med en løkke hvis kropp inneholder funksjonelle moduler.

Syklisk prosess er en beregningsprosess der beregninger utføres gjentatte ganger ved å bruke de samme formlene for forskjellige verdier av argumentet.

Programmer, implementering av en syklisk prosess kalles sykliske programmer.

Organiseringen av syklusen kan deles inn i følgende stadier:

forberedelse (initialisering) av syklusen (AND);

utføre sløyfeberegninger (løkkelegeme) (T);

modifikasjon av parametere (M);

kontrollere syklusens slutttilstand (U).

Rekkefølgen på disse trinnene, som T og M, kan variere. Avhengig av plasseringen avllen, skilles det mellom sykluser med nedre og øvre avslutning. For en bunnavsluttende sløyfe utføres hoveddelen av sløyfen minst én gang fordi beregningene utføres først og deretter kontrolleres betingelsen for å gå ut av sløyfen.

I tilfelle av en topp-ende sløyfe, kan kroppen til sløyfen ikke utføres selv én gang hvis utgangsbetingelsen er umiddelbart oppfylt.

En syklus kalles deterministisk hvis antall repetisjoner av løkkelegemet er kjent eller bestemt på forhånd. En syklus kalles iterativ hvis antall repetisjoner av løkkelegemet er ukjent på forhånd, men avhenger av verdiene til parameterne (noen variabler) som er involvert i beregningene.

Løkkekropp– Dette er en gjentatte ganger gjentatt del av programmet.

Sløyfeparameter er en variabel som får nye verdier hver gang loopen gjentas (løkker kan være enkle eller komplekse).

Generell oversikt over sløyfen n ganger

Generelt skrives en løkke n ganger slik:

nc antall repetisjoner ganger

Tjenesteordet nts (begynnelsen av syklusen) og kts (slutten av syklusen) er skrevet strengt under hverandre og forbundet med en vertikal linje. Til høyre for denne linjen er en repeterbar sekvens av kommandoer (loop body) skrevet.

Antall repetisjoner er et vilkårlig heltall.

Når du utfører algoritmen, gjentas sekvensen av kommandoer i hoveddelen av løkken det angitte antall ganger. Reglene for det algoritmiske språket tillater å spesifisere et hvilket som helst heltall av repetisjoner. Det kan være null eller til og med negativt. Disse tilfellene anses ikke som feilaktige, selve sløyfen vil ganske enkelt ikke bli utført en gang, og datamaskinen vil umiddelbart fortsette å utføre kommandoene skrevet etter cc

Generell oversikt over syklusen så langt

Generelt er syklusen for øyeblikket skrevet som følger:

ingen tilstand ennå

| loop body (sekvens av kommandoer)

Når du utfører en syklus, gjentar datamaskinen følgende handlinger:

a) sjekker betingelsen skrevet etter funksjonsordet while;

b) hvis betingelsen ikke er oppfylt, avsluttes utførelsen av løkken og datamaskinen begynner å utføre kommandoene skrevet etter cc. Hvis betingelsen er oppfylt, kjører datamaskinen selve sløyfen, sjekker betingelsen på nytt, osv.

Generell oversikt over syklusen for

nc for i fra i1 til i2

| loop body (sekvens av kommandoer)

Her er i navnet på en heltallstypeverdi, i1, i2 er vilkårlige heltall eller uttrykk med heltallsverdier. Hoveddelen av løkken utføres sekvensielt for i = i1, i = i1 + 1, i1 + 2, …i = i2.

Reglene for det algoritmiske språket tillater å spesifisere alle heltall i1, i2. spesielt kan i2 være mindre enn i1. dette tilfellet betraktes ikke som en feil - bare kroppen av løkken vil ikke bli utført en gang, og datamaskinen vil umiddelbart fortsette å utføre kommandoene skrevet etter cc.

Loop n ganger og loop mens

Loops n ganger og så langt er formatert på nesten samme måte i det algoritmiske språket. Dette er ikke overraskende, fordi begge disse kommandoene definerer en loop - en repeterende sekvens av kommandoer. Tjenesteordene nts og kts indikerer at en løkke blir utført, og løkkehodet spesifiserer den spesifikke mekanismen for dens utførelse.

Imidlertid har disse to syklusene en betydelig forskjell. Når datamaskinen begynner å kjøre en løkke n ganger, vet den hvor mange ganger den må gjenta løkken. Når du kjører en sløyfe, er dette ikke tilfelle ennå: datamaskinen sjekker tilstanden til sløyfen hver gang og kan ikke bestemme på forhånd når kjøringen skal avsluttes. Foreløpig kan du finne ut antall repetisjoner av en syklus først etter at syklusen er fullført.

Dette gjør det klart i hvilke tilfeller hvilken sløyfe som skal brukes. Hvis antall repetisjoner er kjent når sløyfen starter, er det praktisk å bruke sløyfen n ganger. Hvis antall repetisjoner ikke kan bestemmes på forhånd, er en syklus nødvendig.

For eksempel har et automatisk kontrollprogram strukturen vist i fig. 1. Moduler inkludert i syklusen(samt avbruddshåndteringsmoduler), med én inngang og én utgang hver, har typisk den karakteristiske egenskapen at modulene inneholder statiske variabler som er tildelt en verdi i gjeldende syklus, og analysen av disse variablene utføres i neste syklus. . De nevnte variablene karakteriserer således tilstanden til modulen ved slutten av gjeldende eller begynnelsen av neste programsyklus. I det følgende vil vi kun vurdere slike moduler av sykliske programmer og kort betegne dem som MCP.

Figur 1. Typisk struktur for et kontrollprogram med en uendelig sløyfe.

MCP-er har en variert struktur, hvor kompleksiteten må vurderes etter spesielle kriterier. V.V. Lipaev foreslo et praktisk og objektivt kriterium for kompleksiteten til programvaremoduler, nemlig: antall og total lengde på stier i kontrollgrafen til modulen. Det tas kun hensyn til vilkårs- og utvalgserklæringer. Imidlertid er dette kriteriet tydeligvis ikke nok for en MCP med statisk minne, fordi når man analyserer en MCP er det nødvendig å huske verdiene til alle statiske variabler satt i forrige syklus. I tillegg er det ingen anbefalinger for standardisering av algoritmer og programmer, bortsett fra den lenge kjente strukturerte programmeringen i ofte brukte programmeringsspråk som C og Pascal. Denne artikkelen foreslår å fylle disse hullene i forhold til MCP.

2. Fragmenter av sykliske programmoduler

Et to-terminal fragment, eller ganske enkelt et fragment, vil betraktes som en del av et program med én inngang og én utgang (inkludert sløyfeoperatører) under forutsetning av at MCP-ene som vurderes er strukturerte. Det enkleste fragmentet inkluderer en enkelt uttalelse. En sekvens av fragmenter er også et fragment. MCP er på sin side et fragment og består av en sekvens av fragmenter.

Metoden for uavhengige fragmenter er foreslått for å syntetisere strukturen til moduler som implementerer beslutningstabeller. I dette tilfellet anses et fragment som kan settes inn hvor som helst i sekvensen av modulfragmenter som uavhengig. Uavhengigheten til plasseringen av et slikt fragment skyldes det faktum at dataene som er analysert i det, ikke genereres i den spesifiserte sekvensen av fragmenter, og dataene som genereres i det uavhengige fragmentet, blir ikke analysert i denne sekvensen av fragmenter. Derfor kan uavhengige fragmenter utføres parallelt (pseudo-parallell). I fig. Figur 2 viser mulige implementeringsalternativer for en modul med to uavhengige fragmenter. I alternativene "a" og "b" blir fragmentene omorganisert uten å forvrenge essensen av programmet; i alternativ "c" implementeres fragmentene parallelt.

Fig.2. Alternativer for å implementere en modul med uavhengige fragmenter:

a) og b) - sekvensiell implementering,

c) - parallell implementering: en dobbel horisontal linje indikerer parallellisering av programmet, en tykk horisontal linje indikerer fullføring av parallelle prosesser.

Et avhengig fragment er et hvis plassering avhenger av plasseringen til et annet fragment(er) i modulen. Vi vil skille mellom over- og underavhengige fragmenter. Det toppavhengige fragmentet må alltid være plassert under et eller annet fragment der variablene som brukes i dette (avhengige) fragmentet er dannet. Et bunnavhengig fragment skal alltid plasseres over et fragment som bruker variabler generert i dette fragmentet. To avhengige fragmenter, hvorav det ene er avhengig ovenfra på det andre, og det andre nedenfra avhengig av det første, vil bli kalt gjensidig avhengige fragmenter. De kan ikke byttes ut og kan ikke implementeres parallelt. I fig. Figur 3 viser et eksempel på en modul med gjensidig avhengige fragmenter. Mellom gjensidig avhengige fragmenter kan det være andre, avhengige eller uavhengige av dem. Fig.3. Modul med avhengige fragmenter.

Vi vil kalle et avhengig fragment hvis plassering i modulen er strengt definert som fast. For eksempel, i modulen for å gjenkjenne et tegn som legges inn fra tastaturet, må det første være det bunnavhengige fragmentet av den faktiske tegninntastingen. "Start"- og "slutt"-operatørene til en modul er faste fragmenter.

Absolutt uavhengige fragmenter eksisterer ikke, om ikke annet fordi det i en hvilken som helst modul er de nevnte faste fragmentene av begynnelsen og slutten. Derfor har et uavhengig fragment generelt et mulig lokaliseringsområde begrenset av to gjensidig avhengige fragmenter. Det vil si at en mer streng definisjon av et uavhengig fragment er som følger: uavhengig med hensyn til to faste fragmenter vil vi kalle et fragment som kan plasseres hvor som helst i sekvensen av fragmenter avgrenset over og under av de spesifiserte faste fragmentene.