Syklisten laskennallisten tietojenkäsittelyprosessien ohjelmointi. Syklisten laskentaprosessien ohjelmointi. Esimerkki for-lausekkeen käytöstä

Ohjelmoinnissa on usein tehtäviä, jotka vaativat saman ohjelmalauseryhmän toistuvan suorittamisen operandien eri arvoilla. Tällaisia ​​prosesseja kutsutaan syklinen tai yksinkertaisesti syklit. Ryhmä syklisesti toistuvia väitteitä muodostaa ns silmukan runko, joka voidaan esittää joko yksinkertaisella tai yhdistelmälausekkeella. Kutsumme silmukan rungon kertaluonteista suoritusta iterointi.

Ohjelman silmukan runkoa edeltää aina silmukan otsikko, joka sisältää nimityksen silmukan operaattori ja lauseke, joka määrittää (suoraan tai epäsuorasti) iteraatioiden määrän. Huomaa, että silmukan runko on silmukkaoperaattorin operandi, joten silmukan otsikko ja runko muodostavat ohjelman jakamattoman rakenneyksikön. Seuraavassa käytetään termiä " silmukan operaattori", tarkoitamme sekä silmukan otsikkoa että runkoa.

Syklien järjestämiseksi kaikissa ohjelmointijärjestelmissä on erikoistuneita silmukkaoperaattorit, jonka käyttö vapauttaa ohjelmoijan tarpeesta ohjelmoida jaksoja "manuaalisesti". MathCAD tukee kahdenlaisia ​​tällaisia ​​operaattoreita - kierto ennaltamääräyksellä varten (kutsutaan myös lenkki laskurilla) Ja silmukka ennakkoehdoin Sillä aikaa . Kuvaus näiden operaattoreiden rakenteesta on taulukossa 5.

5.4.1 Käyttäjä varten

Tätä operaattoria tulisi käyttää tapauksissa, joissa iteraatioiden lukumäärä on ennalta määrätty eli tiedossa etukäteen.

Silmukan otsikko tämän operaattorin (oikea operandi) sisältää muuttujan nimeltä parametri(tai laskuri) sykli, Ja arvoluettelo tämä parametri. Listan elementtien määrä määrää myös iteraatioiden määrän - jokaisen iteroinnin aikana silmukkaparametri saa seuraavan arvon otsikossa määritetystä listasta.

Loop-parametri on ohjelman sisäisen muuttujan tila ja sillä on kaikki ominaisuudet (kuvattu kohdassa 5.1.4). Silmukkaparametria käytetään pääsääntöisesti silmukan runkoon sisältyvien lausekkeiden oikealla puolella, vaikka sen käyttäminen lausekkeiden vasemmalla puolella (eli paikallisen määritelmän vasemmalla puolella) ei ole muodollisesti kiellettyä. operaattori "f"). On syytä muistaa, että jos parametria muutettiin silmukan rungossa, sen muutettu arvo on voimassa vain nykyisen iteraation loppuun asti, koska ennen seuraavan iteraation alkua parametri saa silti seuraavan arvon silmukan otsikossa määritetty luettelo.

Muodollisesti on sallittua olla käyttämättä silmukkaparametria ollenkaan silmukkarungon ilmaisuissa - tässä tapauksessa parametriarvojen luettelolla ei ole mitään merkitystä - vain tämän luettelon pituus on merkittävä, mikä määrittää (mahdollisesti merkityksettömien) iteraatioiden määrä.

Kun viimeinen iteraatio on suoritettu, silmukkakäskyä seuraava ohjelmakäsky suoritetaan. Tässä tapauksessa valmiin silmukan parametrina käytetty muuttuja säilyttää arvon, joka sillä oli viimeisessä todella valmistuneessa iteraatio[*]. Huomaa, että tämä arvo ei aina ole sama kuin silmukan otsikossa määritetyn luettelon viimeinen arvo, koska "varhainen" poistuminen silmukasta on mahdollista, kun operaattori laukaistaan Tauko sisältyy silmukan runkoon.

Luettelo arvoista Silmukkaparametri kirjoitetaan silmukan otsikkoon symbolin " Î ", joka osoittaa jäsenyyden joukkoon (tätä symbolia ei tarvitse syöttää manuaalisesti - se näkyy automaattisesti, kun syötetään operaattoria varten ). MathCAD mahdollistaa käytön kolme muotoa tämän listan merkinnät: suora siirto– luetteloelementit on määritelty erikseen pilkuilla erotettuina, parametri saa arvot luettelosta siinä järjestyksessä, jossa ne näkyvät; rankatussa muuttuvassa tyylissä – listan elementit muodostavat vastaavan aritmeettisen sarjan; joukko– listaelementit saavat peräkkäin taulukkoelementtien arvot indeksien järjestyksessä (ensin sarakkeet vasemmalta oikealle, sitten rivit ylhäältä alas).

Kuvassa 21 näkyvät kolme ohjelmaa havainnollistavat operaattorin erilaisia ​​käyttötapoja varten .

Ohjelmoida Fakta(n) laskee luvun faktoriaalin n . Tämän ohjelman silmukkaoperaattori on osa yhdistelmälauseketta, joka puolestaan ​​on ehdollisen operaattorin operandi Muuten. Loop-parametri k saa arvot aritmeettisesta kokonaislukusarjasta.

Ohjelmoida Ch(V,N,p) käsittelee tulovektorin V , korvaa sen arvolla s ne alkiot, joiden indeksit määritetään toisen tulovektorin elementeillä N . Tässä esimerkissä luettelo silmukkaparametrien arvoista i määritellään joukolla vektorielementtejä N . Huomaa, että molemmat ohjelmat suorittavat syötetietojen ohjausta ja estävät pääalgoritmin suorittamisen, jos ohjelman varsinaiset argumentit on määritetty väärin.

Ohjelmoida L(M,z) esimerkissä annettu V ), siihen on liitetty yksityiskohtaisia ​​kommentteja, eikä se vaadi selityksiä. Tämä ohjelma havainnollistaa mahdollisuutta käyttää useita silmukkakäskyjä, joista yksi sisältyy lauseisiin kehon toinen. Käyttö sisäkkäisiä silmukoita- tyypillinen tekniikka, jota käytetään moniulotteisten taulukoiden käsittelyyn.

Kuva 21 – Esimerkkejä syklin ohjelmoinnista varten

Kuva 22 havainnollistaa operaattoreiden käyttöä Tauko Ja Jatkaa silmukan rungossa. Tyypillisesti nämä operaattorit ovat itse operandeja ehdolliset lausunnot Jos tai Muuten .

Operaattori Tauko ("keskeyttää") keskeyttää silmukan suorittaminen ja siirtää ohjauksen keskeytynyttä silmukkaoperaattoria seuraavalle operaattorille. Huomaa, että jos operaattori Tauko keskeytettiin sisäkkäinen silmukka, ulomman silmukan suorittaminen jatkuu.

Operaattori Jatkaa ("jatka") toimii eri tavalla - hän keskeyttää vain silmukan nykyisen iteraation ja siirtää ohjauksen tämän silmukan otsikkoon, jonka jälkeen silmukka suoritetaan jatkuu seuraavasta iteraatiosta (ellei tietenkään keskeytetty iteraatio ollut viimeinen).

Operaattori Tauko sallittu käyttää ja ulkopuolella syklin runko. Tässä tapauksessa koko aliohjelman suoritus keskeytetään ja sen viimeisen tosiasiallisesti suoritetun lausekkeen arvioinnin tulos palautetaan.

Kuva 22 – Esimerkkejä operaattoreiden käytöstä Tauko Ja Jatkaa

Toiminto SumN(V) summaa vain ne vektorielementit, jotka sisältävät skalaarinumeerista dataa, ja ohittaa loput elementit. Toiminto Käänteinen (V) muodostaa vektorin, jonka elementit ovat alkuperäisen vektorin vastaavien elementtien käänteisarvoja. Lisäksi, jos seuraava elementti sisältää luvun "0" tai se ei ole numeerista tyyppiä oleva skalaari, sykli keskeytyy. Huomaa, että operaattori Tauko viimeisessä esimerkissä se ei keskeytä ohjelmaa, vaan siirtää ohjauksen operaattorille Palata , heti operaattorin jälkeen varten .

5.4.3 Käyttäjä Sillä aikaa

Toisin kuin operaattori varten , lausunnon otsikko Sillä aikaa (käännöksessä - " Hei hei") ei sisällä täsmällisiä viitteitä iteraatioiden määrästä - se sisältää looginen ilmaus, jonka arvo lasketaan automaattisesti ennen alkua jokaisen seuraavan iteraation suorittaminen[†]. Niin kauan kuin tämä lauseke on tosi, silmukka jatkaa iterointia; heti kun lauseke muuttuu epätosi seuraavan iteraation jälkeen, silmukan seuraavaa iteraatiota ei suoriteta ja käskyä seuraava ohjelmakäsky saa ohjauksen Sillä aikaa .

Ilmeisesti, jos silmukan otsikkoon sijoitetaan identtisesti väärä looginen lauseke, tämä silmukka ei suorita iteraatioitaan loppuun, ja jos tämä lauseke on identtisesti tosi, silmukka on ääretön (jälkimmäinen tilanne on ns. silmukoita ohjelmat). Tällaisten tilanteiden välttämiseksi loogisen lausekkeen operandeissa on oltava yksi tai useampi muuttuja, joka muuttaa niiden arvoja silmukan rungossa niin, että silmukka on äärellinen (muilla keinoilla voidaan estää silmukka - esim. pakottaa käyttäjä poistumaan silmukasta Tauko ).

Esimerkkejä operaattorin käytöstä Sillä aikaa on esitetty kuvassa 23. Saman ongelman ratkaisemiseksi annetaan kolme vaihtoehtoa: kukin ohjelma F0 , F1 Ja F2 palauttaa lähdevektorin ensimmäisen elementin indeksinV ylittää määritetyn arvonz .

Ensimmäinen ohjelma (esim A ) lisää yhden laskuriin k silmukan rungossa Sillä aikaa seuraavaan asti k alkuperäisen vektorin th elementti ei ylitä määritettyä arvoa z . Tämän jälkeen silmukka päättyy ja ohjelma palauttaa muuttujan viimeksi muokatun arvon k , joka on ratkaisu ongelmaan. Huomaa, että toisin kuin sykli varten , laskuri k tässä se on tarpeen käsitellä erillisillä käskyillä: alusta (eli anna sille alkuarvo) ennen silmukkaoperaattoria ja muuta sen arvoa silmukan rungossa.

Se on helppo nähdä, että vaihtoehto A ) -ohjelmassa on merkittävä haittapuoli: se ei estä ohjelmaa silmukamasta siinä tapauksessa, että ongelmalle ei ole ratkaisua, eli kun parametri z ylittää vektorin suurimman elementin arvon V . Tässä esimerkissä silmukointia tällaisessa tilanteessa ei todellakaan tapahdu - mutta tämä ei ole ohjelmamme, vaan MathCAD-järjestelmän ansio, joka ohjaa vektoriindeksin lähtöä V sallittujen arvojen ulkopuolella ja antaa virheilmoituksen.

Tästä haitasta vapaa vaihtoehto b ) ohjelmasta, jossa silmukan runko sisältää lisätarkistuksen seuraavan indeksiarvon oikeellisuudesta ja katkaisee väkisin silmukan operaattorilla Tauko sopivassa tilanteessa lähettämällä tekstiviestin.

Ehkä tehokkain ratkaisu tähän ongelmaan on vaihtoehto V ), joka ei käytä operaattoria ollenkaan Sillä aikaa . Tässä ohjelmassa muuttuja k käytetään vain "tyylipuhtauden" ylläpitämiseen - silmukkaparametrin käsittelyn poissulkemiseksi i operaattorin ulkopuolella varten .

Kuva 23 – Esimerkkejä syklin ohjelmoinnista Sillä aikaa

Työn tavoite:

Opi syklisiä operaattoreita varten, while, do - while, opi laatimaan ja ohjelmoimaan syklisiä algoritmeja.

Lyhyt teoreettinen tieto

Silmukkaoperaattoreita käytetään, kun tietyt toiminnot (operaattorit ja operaatiot) on toistettava useita kertoja, ja tällaisia ​​algoritmien osia kutsutaan silmukoiksi.

For silmukan operaattori

For silmukan lausekkeen perusmuoto on:

for (lauseke_1; lauseke_2; lauseke_3)

operaattori;

Missä lauseke_1– sykliparametrin alkuarvo;

lauseke_2– syklin jatkamisen edellytysten tarkistaminen;

lauseke_3– sykliparametrin muutos (korjaus);

operaattori– yksinkertainen tai yhdistelmäoperaattori C-kielellä.

Operaattorin toimintakaavio on seuraava: vain kerran lasketaan ensin lauseke_1, sitten lauseke_2 tarkistetaan ja jos se on "tosi", suoritetaan ohjelman syklinen osa, sitten korjataan parametri ja niin edelleen kunnes lauseke_2 saa arvon "false".

Esimerkiksi: for (k = 1; k<5; k++)

printf("\n %d", k);

Tämän operaattorin suorittamisen seurauksena numerot 1-4 tulostetaan sarakkeeseen.

Voit käyttää minkä tahansa perustyypin muuttujaa silmukkaparametrina.

Esimerkiksi:

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

printf(" %c",ch); // Latinalaiset aakkoset

Ohjelman for-silmukoiden rakennetta on valvottava huolellisesti, jotta et päädy loputtomaan silmukkaan (josta ei ole ulospääsyä).

Esimerkiksi:

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

printf("loputon silmukka\n");

Poistu silmukasta aikataulua edellä seuraavilla tavoilla:

Lisäehdon mukaan;

Käyttämällä seuraavia operaattoreita:

tauko;- poistua silmukasta, jossa katkos sijaitsee, ohjaus siirtyy silmukan jälkeiseen ensimmäiseen suoritettuun käskyyn;

exit(int Kod);- poistu ohjelmasta;

palata;- poistua toiminnosta;

Käytä ehdotonta hyppy-operaattoria mene<метка>;

Aikaisin nykyisen syklisen vaiheen loppuun saattaminen mahdollista käyttämällä lisäehtoa tai operaattoria jatkaa, joka keskeyttää nykyisen silmukan vaiheen suorittamisen, ts. ohittaa muun silmukan lauseet ja siirtää ohjauksen silmukan head-lauseeseen parametrin säätämiseksi ja tilan tarkistamiseksi.

Ohjauksen siirtäminen ulkopuolelta silmukan sisälle on kielletty.

Mikä tahansa suluissa olevista for-silmukan lausekkeista saattaa puuttua, mutta ";"-symboli ei voi laskea.

Esimerkiksi:

for(; i<3; i++)

laittaa ("Hei!");

Sykliset while- ja do–whi-lauseet

Syklisen operaattorin perusmuoto sillä aikaa:

Vaikka (kunto)

operaattori;

Missä operaattori

Silmukka kulkee niin kauan kuin ehto on tosi, ts. suluissa oleva lauseke palauttaa nollasta poikkeavan tuloksen. Tämä on silmukka, jossa on ehto - ensin ehto tarkistetaan, sitten lause suoritetaan. Siksi while-silmukkaa ei suoriteta edes kerran, jos ehdon laskennan alkuperäinen tulos on 0.

Operaattorin perusmuoto tehdä, kun:

operaattori;

while(ehto);

Missä operaattori on yksinkertainen, yhdistelmä tai tyhjä lause.

Operaattori tehdä–sillä aikaa– silmukkaoperaattori jälkiehdoin, ts. ensin lause suoritetaan ja sitten ehdon totuus tarkistetaan. Koska do–while-silmukassa ehto tarkistetaan silmukan lopussa, silmukka suoritetaan vähintään kerran.

Silmukoissa, kuten while ja do–while, samat menetelmät silmukasta aikaiseen poistumiseen ja silmukan nykyisen vaiheen varhaiseen loppuun saattamiseksi ovat sallittuja kuin for-käskyssä, mutta jälkimmäisessä tapauksessa, toisin kuin for-silmukassa, ohjaus siirretään. kunnon tarkistamiseen. Jotta estetään loputon silmukka while- ja do-while -silmukoiden sisällä, sinun on säädettävä ehtoon sisältyvien muuttujien muuttamisesta.

Esimerkiksi:

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

if (i%5!=0) jatka;

printf("%5d",i);

Esimerkkejä äärettömistä silmukoista:

operaattori;

2) while(numero_not_0) // Aina totta!

operaattori;

operaattori;

while(numero_not_0); // Aina totta!

Silmukkaoperaattoreiden joukossa on oltava poistumisehto.

Sisäkkäiset silmukat

Sisäkkäisten silmukoiden tapauksessa yksi silmukka on toisen sisällä, esimerkiksi:

for(i=nn;i

for(j=mn;j

operaattori;

Missä operaattori on yksinkertainen, yhdistelmä tai tyhjä lause. Sisäinen silmukka suoritetaan kullekin parametrin i arvolle, joka täyttää ulkoisen silmukan ehdon.

Esimerkki:

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

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

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

printf("\n");

Esimerkki for-lausekkeen käytöstä

Laskea. Ohjelman tulee tulostaa väli- ja lopputulokset.

Ohjelman teksti voi näyttää tältä

#sisältää

#sisältää

laittaa ("Enter N");

scanf("%d",&N);

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

( // ota ja tuplatehtävä

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

printf("\n VASTAUS: s=%f, Paina mitä tahansa näppäintä...",s);

Vaihtoehdot yksittäisiin tehtäviin

Kirjoita ohjelma funktioarvojen taulukon määrittämiseksi klo mielivaltaisella alueella [ a,b] argumentti muuttuu X mielivaltaisilla askelilla h. Arvot a, b, h syötetty näppäimistöltä. Taulukon tulee sisältää seuraavat sarakkeet: järjestysnumero, argumentin arvo x, funktion arvo, viesti funktion kasvattamisesta tai pienenemisestä, kahden vierekkäisen funktion arvon ero.

Määritä funktion enimmäis- ja minimiarvot.

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,4 p; b = 0,4 p; h = 0,5.

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

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

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

"Syklisten laskentaprosessien ohjelmointi"

Työn tavoite: masterointimenetelmiä syklisten laskentaprosessien algoritmien kokoamiseen ja monimutkaisen rakenteen omaavien syklisten ohjelmien järjestämiseen.

Teoreettinen osa

4.1.1. Sykliset algoritmit.

Jakso on toimintosarja, joka voidaan suorittaa useammin kuin kerran.

Round-robin-algoritmi on algoritmi, joka sisältää yhden tai useamman silmukan.

Syklejä on 3 tyyppiä:

Silmukka ennakkoehdoin;

Silmukka jälkikunnossa;

Silmukka laskurilla (laskentasilmukka).

Jos silmukan suoritus liittyy johonkin loogiseen ehtoon, käytetään silmukoita, joissa on ennakko- tai jälkiehto.

Laskurisilmukat ovat luokka, jossa silmukan rungon suoritus on toistettava ennalta määrätty määrä kertoja.

Syklisten algoritmien lohkokaaviot näyttävät tältä:

1. Silmukka laskurilla.

2. Silmukka ennakkoehdoin. 3. Silmukka jälkiehdoin.

4.1.2 Silmukkaoperaattorit C++-ohjelmointikielellä.

C++:ssa jokaiselle silmukkatyypille on vastaava operaattori:

Silmukka kuin while (edellytyksellä);

Loop like do...while (jälkiehdon kanssa);

Silmukka kuin (laskenta).

1. Loop-operaattori kuten while

Ilmoittautumislomake:

while (kunto)lauseke;

missä: (ehto) – looginen lauseke;

operaattori – silmukassa suoritetun silmukan operaattori tai runko.

Jos silmukan runko on yhdistelmälause, se on suljettava operaattorisuluissa (...):

kun (kunto)

toimijoiden ryhmä

Kaavio tällaisen silmukan toiminnasta: kun ehto on tosi, silmukan runko suoritetaan ja ehto tarkistetaan uudelleen jne. Kun ehdosta tulee epätosi, silmukka poistuu.

2. Silmukkaoperaattori kuten do…while

Ilmoittautumislomake:

operaattori;

while(ehto);

Kaavio tällaisen silmukan toiminnasta: ensin suoritetaan operaattori, sitten ehto tarkistetaan, jos ehto on tosi, operaattori suoritetaan ja ehto tarkistetaan uudelleen jne. Kun ehdosta tulee epätosi, silmukka poistuu.

Jos silmukan runko on yhdistelmälause, niin, kuten silmukassa, jolla on ennakkoehto, se on suljettava operaattorisuluissa (...):

toimijoiden ryhmä

while(ehto);

3. Silmukkaoperaattori kuten for

Ilmoittautumislomake:

operaattori;

A on alkulauseke, joka määrittää silmukkaparametrin alkuarvot ja tarvittaessa muiden parametrien alkuarvot. Esimerkiksi:

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

B on ehdollinen lauseke, joka tarkistaa ehdon silmukan jatkamiselle. Esimerkiksi:

C on lisäyslauseke, joka määrittää silmukkaparametrin ja tarvittaessa muiden parametrien inkrementin, sitten ne kirjoitetaan listaan. Esimerkki: x+=0,1, i++

4.1.3 Esimerkki algoritmin ja ohjelman kääntämisestä C++-kielellä syklistä laskentaprosessia varten.

Laske lausekkeen arvo:

b– alkuarvo, sen arvo syötetään näppäimistöltä eikä muutu;

a– vaihteluvälin muutokset 1:n välein;

y– tulos, sen arvot näkyvät näytöllä.

Määritelmän perusteella muuttuja a on kokonaisluku, joten sitä voidaan käyttää laskurina laskentasilmukassa.

Algoritmin lohkokaavio tämän ongelman ratkaisemiseksi laskentajaksolla on seuraava:

#sisältää

#sisältää

#sisältää

printf("Syötä b:");

scanf("%f",&b);

printf("a 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);

Algoritmin lohkokaavio tämän ongelman ratkaisemiseksi käyttämällä silmukkaa, jossa on ennakkoehto, on seuraava:

Tätä algoritmia vastaavan C++-ohjelman teksti on seuraava:

#sisältää

#sisältää

#sisältää

printf("Syötä b:");

scanf("%f",&b);

printf("a y\n");

printf("%3d",a);

printf("%8.2f\n",y);

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

printf("%8.2f\n",y);

else printf(" y ei ole olemassa\n");

Algoritmin lohkokaavio tämän ongelman ratkaisemiseksi käyttämällä silmukkaa, jossa on jälkiehto, on seuraava:

Tätä algoritmia vastaavan C++-ohjelman teksti on seuraava:

#sisältää

#sisältää

#sisältää

printf("Syötä b:");

scanf("%f",&b);

printf("a y\n");

printf("%3d",a);

printf("%8.2f\n",y);

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

printf("%8.2f\n",y);

else printf(" y ei ole olemassa\n");

kun (a<=10);

Käytännön osa

4.2.1 Vaatimukset työn suorittamiselle:

Suorita tehtävä laboratoriotyöstä nro 3 yhden muuttujan arvoalueelle. Muutettava muuttuja, sen muutosalue ja askel on esitetty taulukossa 4. Luo lohkokaaviot algoritmeista ja ohjelmista kahdelle yksittäisessä tehtävässä määritellylle syklityypille (taulukko 4).

Formalisoi tulosten tulos siten, että muuttujaparametrin arvot korostuvat selvästi ja jokaiselle tietylle arvolle tuloksen arvot (kolme muuttujaa taulukon 3 sarakkeesta 2) näytetään muodossa pöydästä.

Työjärjestys.

1. Suorita tehtävän analyysi, muotoile ongelma.

2. Luo algoritmien lohkokaavioita.

3. Luo ohjelma C++:lla. Syötä alkutiedot näppäimistöltä ja tulosta tulokset näytölle.

4. Tarkista ohjelman toimivuus erilaisista lähtötiedoista.

5. Analysoi saadut tulokset.

Vaihtoehdot yksittäisiin tehtäviin.

Yksittäisten tehtävien vaihtoehdot valitaan taulukosta 4 opettajan päiväkirjassa olevan ryhmäluettelon opiskelijanumeron mukaan.

Taulukko 4. Yksittäisten tehtävien vaihtoehdot

Ei.	Muuttuva muuttuja	Syklityypit
	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. Ehdolla, 2. Laskettavissa
	-15 ≤ j ≤ 1 0, Δ j = 0,5	1. Ehdolla, 2. Jälkiehdoin
	5 ≤ e ≤ 35,Δ e = 2	1. Laskettava, 2. Jälkiehdoin
	-5 ≤ m ≤ 15,Δ m = 1	1. Ehdolla, 2. Laskettavissa
	1 ≤ c ≤ 70,Δ c = 3	1. Ehdolla, 2. Jälkiehdoin
	1,5 ≤ c ≤ 15,Δ c = 0,5	1. Laskettava, 2. Jälkiehdoin
	-8 ≤ b ≤ 28,Δ b = 2	1. Ehdolla, 2. Laskettavissa
	-4,5 ≤ x ≤ 11,5,Δ x = 0,5	1. Ehdolla, 2. Jälkiehdoin
	-7 ≤ k ≤ 2,Δ k = 0,3	1. Laskettava, 2. Jälkiehdoin
	-1 ≤ m ≤ 21,Δ m = 1	1. Ehdolla, 2. Laskettavissa
	-2 ≤ e ≤ 34,Δ e = 2	1. Ehdolla, 2. Jälkiehdoin
	-11 ≤ c ≤ 23,Δ c = 2	1. Laskettava, 2. Jälkiehdoin
	-13 ≤ p ≤ 50,Δ p = 3	1. Ehdolla, 2. Laskettavissa
	3,3 ≤ b ≤ 9,3,Δ b = 0,3	1. Ehdolla, 2. Jälkiehdoin
	3,5 ≤ y ≤ 12,3,Δ y = 0,4	1. Laskettava, 2. Jälkiehdoin
	-7,5 ≤ a ≤ 5,7,Δ a = 0,6	1. Ehdolla, 2. Laskettavissa
	-1,5 ≤ h ≤ 1,2,Δ h = 0,1	1. Ehdolla, 2. Jälkiehdoin
	0 ≤ h ≤ 10,Δ h = 0,5	1. Laskettava, 2. Jälkiehdoin
	-15 ≤ b ≤ 15, Δ b = 2	1. Ehdolla, 2. Laskettavissa
	-7 ≤ l ≤ 3, Δ l = 0,5	1. Ehdolla, 2. Jälkiehdoin
	-5,5 ≤ b ≤ 6,5, Δ b = 0,5	1. Laskettava, 2. Jälkiehdoin
	1 ≤ k ≤ 9, Δ k = 0,4	1. Ehdolla, 2. Laskettavissa
	0 ≤ b ≤ 6,9,Δ b = 0,3	1. Ehdolla, 2. Jälkiehdoin
	-3 ≤ v ≤ 9,Δ v = 0,6	1. Laskettava, 2. Jälkiehdoin
	-2 ≤ p ≤ 2,6,Δ p = 0,2	1. Ehdolla, 2. Laskettavissa

4.3 Testikysymykset ja käytännön tehtävät:

1. Miten while-lause toimii?

2. Miten do ... while -lause toimii?

3. Miten for-lauseke toimii?

4. Alleviivaa ohjelman lauseet, jotka muodostavat syklin.

5. Mitä eroa on while- ja do ... while -lauseilla?

6. Korvaa yksi ohjelman silmukkaoperaattori toisella.

Ohjelmoinnissa kohtaamme usein ongelmia, jotka liittyvät itseään toistaviin prosesseihin. Siksi meidän on tiedettävä ja osattava käyttää sellaista käsitettä kuin " sykliset laskentaprosessit».

Aloittelevan ohjelmoijan on helppo ymmärtää ne yleisen esimerkin avulla. Lisäksi on tärkeää ymmärtää, että kaikilla ohjelmointikielillä on tapoja toteuttaa silmukoita.

Mikä on silmukka ohjelmoinnissa?

Jakso - ohjelmoinnissa on samojen toimintojen tai laskelmien toistuva toisto, mutta samojen riippuvuuksien mukaan muuttujien eri arvoilla.

Emme kohtaa syklin käsitettä vain ohjelmoinnissa. Syklejä on monilla elämämme alueilla.

Esimerkiksi veden kiertokulku luonnossa on luonnollinen kiertokulku elämässämme.

Katsotaan nyt yleisiä sääntöjä ja käsitteitä, joita käytetään laskennallisissa sykleissä.

Syklisen prosessin vaiheet

Yleensä sykli tulisi toteuttaa 4 vaiheessa:

• Vaihe 1 – syklin valmistelu (alustaminen).
  Parametrin ja silmukkamuuttujan alkuarvon asettaminen.
  Loop-parametri– tämä arvo, joka laskee jakson vaiheiden määrän (syklin toistojen lukumäärä).
  Silmukan muuttuja on suure, joka muuttaa arvoaan syklin jokaisessa vaiheessa.
  Alustus– tämä on parametrin ja silmukkamuuttujan alkuarvojen asettaminen.
• Vaihe 2 – syklin runko.
  Tämä on toiminnon toistamista syklissä tai samoihin matemaattisiin riippuvuuksiin perustuvia laskelmia eri muuttujien arvoilla.
• Vaihe 3 – syklin muutos (muutos).
• Vaihe 4 – syklin hallinta.
  Tämä on kunnon tarkistus silmukan jatkamista tai alkua varten.

Pascalissa on 3 silmukkaoperaattoria, jotka voivat toteuttaa minkä tahansa algoritmisesti – syklinen rakenne :

1. Loop lauseke parametrin kanssa
2. Silmukkaoperaattori ennakkoehdoin
3. Silmukkaoperaattori jälkiehdoin

Tarkastelemme niitä yksityiskohtaisesti seuraavassa artikkelissa.

1. Menetelmät syklisten laskentaprosessien rakentamiseksi ohjelmissa.

2. Syötetty tietokoneeseenNtodellisia lukuja. Kirjoita ohjelma, joka näyttää tämän joukon aritmeettisen keskiarvon.

Johdanto

Syklisiä ohjelmia käytetään lähes kaikissa ohjelmistoissa. Tässä tapauksessa syklit voivat olla eksplisiittisiä tai implisiittisiä. Erityisesti implisiittinen silmukka on läsnä keskeytyskäsittelijöissä, jotka toimivat tehokkaasti äärettömässä silmukassa, jonka runko on keskeytyksen laukaisema. Aliohjelmat - Windows-sovellusten ikkunatoiminnot - ovat myös syklisiä. Alla tarkastellaan ohjelmia, joissa on silmukka, jonka runko sisältää toiminnallisia moduuleja.

Syklinen prosessi on laskennallinen prosessi, jossa laskutoimitukset suoritetaan toistuvasti samoilla kaavoilla argumentin eri arvoille.

Ohjelmat, syklisen prosessin toteuttamista kutsutaan syklisiksi ohjelmiksi.

Syklin organisointi voidaan jakaa seuraaviin vaiheisiin:

syklin valmistelu (alustaminen) (AND);

silmukkalaskelmien suorittaminen (silmukan runko) (T);

parametrien muuttaminen (M);

syklin lopputilan tarkistaminen (U).

Näiden vaiheiden järjestys, kuten T ja M, voi vaihdella. Jakson lopun kunnon tarkistuksen sijainnista riippuen erotetaan syklit, joissa on ala- ja yläpääte. Alhaalla päättyvässä silmukassa silmukan runko suoritetaan vähintään kerran, koska ensin suoritetaan laskelmat ja sitten tarkistetaan silmukasta poistumisen ehto.

Yläpäätteisen silmukan tapauksessa silmukan runkoa ei voida suorittaa edes kerran, jos poistumisehto täyttyy välittömästi.

Jaksoa kutsutaan deterministiseksi, jos silmukkakappaleen toistojen lukumäärä tiedetään tai määrätään etukäteen. Jaksoa kutsutaan iteratiiviseksi, jos silmukan rungon toistojen lukumäärää ei tiedetä etukäteen, mutta se riippuu laskelmissa mukana olevien parametrien (jotkin muuttujat) arvoista.

Silmukan runko- Tämä on toistuvasti toistuva ohjelman osa.

Loop-parametri on muuttuja, joka saa uusia arvoja joka kerta, kun silmukka toistetaan (silmukat voivat olla yksinkertaisia ​​tai monimutkaisia).

Yleisnäkymä silmukasta n kertaa

Yleensä silmukka n kertaa kirjoitetaan näin:

nc toistojen lukumäärä

Palvelusanat nts (syklin alku) ja kts (syklin loppu) kirjoitetaan tiukasti toistensa alle ja yhdistetään pystyviivalla. Tämän rivin oikealle puolelle kirjoitetaan toistettava komentosarja (silmukan runko).

Toistojen määrä on mielivaltainen kokonaisluku.

Algoritmia suoritettaessa silmukan rungossa oleva komentosarja toistetaan määritetyn määrän kertoja. Algoritmisen kielen säännöt sallivat minkä tahansa kokonaislukumäärän toistoja. Se voi olla nolla tai jopa negatiivinen. Näitä tapauksia ei pidetä virheellisinä, silmukan runkoa ei yksinkertaisesti suoriteta edes kerran ja tietokone jatkaa välittömästi cc:n jälkeen kirjoitettujen komentojen suorittamista

Yleiskuva syklistä tähän mennessä

Yleensä sykli on tällä hetkellä kirjoitettu seuraavasti:

ei ehtoa vielä

| silmukan runko (komentosarja)

Kun tietokone suorittaa syklin, se toistaa seuraavat toiminnot:

a) tarkistaa funktiosanan while jälkeen kirjoitetun ehdon;

b) jos ehto ei täyty, silmukan suoritus päättyy ja tietokone alkaa suorittaa cc:n jälkeen kirjoitettuja komentoja. Jos ehto täyttyy, tietokone suorittaa silmukan rungon, tarkistaa ehdon uudelleen jne.

Yleisnäkymä syklistä

nc for i i1:stä i2:een

| silmukan runko (komentosarja)

Tässä i on kokonaislukutyypin arvon nimi, i1, i2 ovat mielivaltaisia ​​kokonaislukuja tai lausekkeita, joissa on kokonaislukuarvoja. Silmukan runko suoritetaan peräkkäin i = i1, i = i1 + 1, i1 + 2, …i = i2.

Algoritmisen kielen säännöt sallivat minkä tahansa kokonaislukujen i1, i2 määrittämisen. erityisesti i2 voi olla pienempi kuin i1. tätä tapausta ei pidetä virheenä - yksinkertaisesti silmukan runkoa ei suoriteta edes kerran, ja tietokone jatkaa välittömästi cc:n jälkeen kirjoitettujen komentojen suorittamista.

Kierrä n kertaa ja silmukaa while

Silmukat n kertaa ja tähän asti on muotoiltu lähes samalla tavalla algoritmikielellä. Tämä ei ole yllättävää, koska molemmat komennot määrittelevät silmukan - toistuvan komentosarjan. Palvelusanat nts ja kts osoittavat, että silmukkaa suoritetaan, ja silmukan otsikko määrittää tietyn mekanismin sen suorittamiselle.

Näillä kahdella syklillä on kuitenkin yksi merkittävä ero. Kun tietokone aloittaa silmukan suorittamisen n kertaa, se tietää kuinka monta kertaa sen on toistettava silmukan runko. Silmukkaa suoritettaessa näin ei vielä ole: tietokone tarkistaa silmukan kunnon joka kerta eikä voi määrittää etukäteen, milloin suoritus päättyy. Toistaiseksi voit selvittää syklin toistojen lukumäärän vasta syklin päätyttyä.

Tämä tekee selväksi, missä tapauksissa mitä silmukkaa tulisi käyttää. Jos toistojen määrä on tiedossa silmukan alkamishetkellä, on kätevää käyttää silmukkaa n kertaa. Jos toistojen määrää ei voida määrittää etukäteen, tarvitaan sykli.

Esimerkiksi automaattisella ohjausohjelmalla on kuvan 1 mukainen rakenne. 1. Moduulit sisältyvät kiertoon(sekä keskeytyksenkäsittelymoduuleilla), joissa kummassakin on yksi tulo ja yksi lähtö, on tyypillisesti se ominaisuus, että moduulit sisältävät staattisia muuttujia, joille annetaan arvo nykyisessä syklissä, ja näiden muuttujien analyysi suoritetaan seuraavassa jaksossa. . Mainitut muuttujat kuvaavat siis moduulin tilaa virran lopussa tai seuraavan ohjelmajakson alussa. Seuraavassa tarkastellaan vain sellaisia ​​syklisten ohjelmien moduuleja ja merkitään niitä lyhyesti MCP:ksi.

Kuva 1. Tyypillinen ohjausohjelman rakenne äärettömällä silmukalla.

MCP:t ovat rakenteeltaan vaihtelevia, ja niiden monimutkaisuus on arvioitava erityisten kriteerien mukaan. V.V. Lipaev ehdotti kätevää ja objektiivista kriteeriä ohjelmistomoduulien monimutkaisuuteen, nimittäin: polkujen lukumäärä ja kokonaispituus moduulin ohjauskaaviossa. Vain ehdolliset ja valintalausekkeet otetaan huomioon. Tämä kriteeri ei kuitenkaan selvästikään riitä staattisella muistilla varustetulle MCP:lle, koska MCP:tä analysoitaessa on muistettava kaikkien edellisessä syklissä asetettujen staattisten muuttujien arvot. Lisäksi algoritmien ja ohjelmien standardointiin ei ole suosituksia, lukuun ottamatta pitkään tunnettua strukturoitua ohjelmointia yleisesti käytetyillä ohjelmointikielillä, kuten C ja Pascal. Tässä artikkelissa ehdotetaan näiden aukkojen täyttämistä suhteessa MCP:hen.

2. Fragmentit syklisistä ohjelmamoduuleista

Kaksipääteistä fragmenttia tai yksinkertaisesti fragmenttia pidetään ohjelman osana, jossa on yksi tulo ja yksi lähtö (mukaan lukien silmukkaoperaattorit) sillä oletuksella, että tarkasteltavat MCP:t ovat strukturoituja. Yksinkertaisin fragmentti sisältää yhden lauseen. Fragmenttien sekvenssi on myös fragmentti. MCP puolestaan ​​on fragmentti ja koostuu fragmenttien sekvenssistä.

Itsenäisten fragmenttien menetelmää ehdotetaan päätöstaulukoita toteuttavien moduulien rakenteen syntetisoimiseksi. Tässä tapauksessa fragmenttia, joka voidaan lisätä mihin tahansa moduulifragmenttien sekvenssiin, pidetään itsenäisenä. Tällaisen fragmentin sijainnin riippumattomuus johtuu siitä, että siinä analysoitua dataa ei synny määritellyssä fragmenttisekvenssissä, eikä itsenäisessä fragmentissa generoitua dataa analysoida tässä fragmenttisekvenssissä. Siksi itsenäiset fragmentit voidaan suorittaa rinnakkain (pseudo-rinnakkais). Kuvassa Kuva 2 esittää mahdollisia toteutusvaihtoehtoja moduulille, jossa on kaksi itsenäistä fragmenttia. Vaihtoehdoissa "a" ja "b" fragmentit järjestetään uudelleen vääristämättä ohjelman olemusta; vaihtoehdossa "c" fragmentit toteutetaan rinnakkain.

Kuva 2. Vaihtoehdot itsenäisten fragmenttien sisältävän moduulin toteuttamiseksi:

a) ja b) - peräkkäinen toteutus,

c) - rinnakkainen toteutus: kaksinkertainen vaakasuora viiva osoittaa ohjelman rinnakkaistamisen, paksu vaakaviiva osoittaa rinnakkaisten prosessien valmistumisen.

Riippuvainen fragmentti on sellainen, jonka sijainti riippuu toisten fragmenttien sijainnista moduulissa. Teemme eron ylä- ja alariippuvaisten fragmenttien välillä. Top-riippuvaisen fragmentin tulee aina sijaita jonkin fragmentin alapuolella, jossa tässä (riippuvaisessa) fragmentissa käytetyt muuttujat muodostuvat. Pohjasta riippuvainen fragmentti tulee aina sijoittaa sellaisen fragmentin yläpuolelle, joka käyttää tässä fragmentissa luotuja muuttujia. Kahta riippuvaista fragmenttia, joista toinen on ylhäältä riippuvainen toisesta ja toinen alhaalta riippuvainen ensimmäisestä, kutsutaan toisistaan ​​riippuviksi fragmenteiksi. Niitä ei voida vaihtaa keskenään, eikä niitä voida toteuttaa rinnakkain. Kuvassa Kuvassa 3 on esimerkki moduulista, jossa on toisistaan ​​riippuvaisia ​​fragmentteja. Keskinäisesti riippuvaisten fragmenttien välillä voi olla muita, niistä riippuvaisia ​​tai riippumattomia. Kuva 3. Moduuli riippuvaisilla fragmenteilla.

Kutsumme riippuvaista fragmenttia, jonka sijainti moduulissa on tiukasti määritelty kiinteäksi. Esimerkiksi näppäimistöltä syötetyn merkin tunnistamismoduulissa ensimmäisen on oltava varsinaisen merkin syötteen alhaalta riippuva fragmentti. Moduulin "alku" ja "loppu"-operaattorit ovat kiinteitä fragmentteja.

Täysin itsenäisiä fragmentteja ei ole olemassa, jos vain siksi, että missä tahansa moduulissa on mainitut kiinteät fragmentit alun ja lopun. Siksi itsenäisellä fragmentilla on yleensä mahdollinen sijaintialue, jota rajoittaa kaksi toisistaan ​​riippuvaista fragmenttia. Toisin sanoen itsenäisen fragmentin tiukempi määritelmä on seuraava: riippumattomaksi kahden kiinteän fragmentin suhteen kutsumme fragmenttia, joka voidaan sijoittaa minne tahansa fragmenttien sekvenssiin, jota määritellyt kiinteät fragmentit rajoittavat ylä- ja alapuolelta.