§9 Silmukkakäsky for-parametrilla. A for-silmukka, joka perustuu alueeseen. Silmukat parametreilla Mitä silmukkaa kutsutaan silmukaksi parametrilla

Parametrilla varustetulla silmukalla on seuraava muoto:

for (alustus; lauseke; modifikaatiot) -lause;

Alustus käytetään ilmoittamaan ja osoittamaan alkuarvot silmukassa käytetyille suureille. Tässä osassa voit kirjoittaa useita lauseita pilkulla erotettuina ("peräkkäinen suoritus" -toiminto), esimerkiksi näin:

for (int i = 0, j = 2; ...

varten (k = 1, m = 0; ...

Silmukan alustusosassa ilmoitettujen muuttujien laajuus on silmukka 1. Alustus suoritetaan kerran silmukan suorituksen alussa.

Ilmaisu määrittää ehdon silmukan suorittamiselle: jos sen tulos, cast tyyppiin bool , on tosi, silmukka suoritetaan. Parametrilla varustettu silmukka toteutetaan ehdollisena silmukana.

Muutokset suoritetaan silmukan jokaisen iteraation jälkeen ja niitä käytetään yleensä muuttamaan silmukan parametreja. Muokkausosaan voit kirjoittaa useita lauseita pilkuilla erotettuina. Yksinkertainen tai yhdistelmä operaattori edustaa silmukan runkoa. Mikä tahansa osa for-lauseesta voidaan jättää pois (mutta puolipisteet on jätettävä paikoilleen!).

Esimerkki (operaattori, joka laskee lukujen summan 1-100):

for (Int i = 1, s = 0; 1<=100; i++) s += i;

Esimerkki (ohjelma tulostaa funktioarvojen taulukon y = x 2 +1 syötetyllä alueella):

#Sisältää

float Xn, Xk, Dx, X;

printf("Anna argumentin alue ja lisäys: ");

scanf ("%f%f%f", &Xn, &Xk, &Dx);

printf("| X | Y |\n");

for (X = Xn; X<=Xk; X+=Dx)

printf (" | %5.2f | %5.2f |\n", X*X + 1);

Esimerkki (ohjelma löytää kaikki positiivisen kokonaisluvun jakajat):

#Sisältää Int main())(

Int num, half, div;

cout<< “\n Введите число: "; cin >> numero;

for (puoli = luku / 2, jako = 2; jak<= half; div++)

if (!(num %div))cout<< div <<"\n";

Kaksi viimeistä esimerkkiä suorittavat samat toiminnot kuin esimerkit esiehdolliselle silmukalle, mutta ne on kirjoitettu tiiviimmin ja selkeämmin: kaikki silmukan ohjaamiseen liittyvät toiminnot lokalisoidaan sen otsikkoon.

Mikä tahansa while-silmukka voidaan muuntaa vastaavaksi silmukalle ja päinvastoin seuraavan kaavion avulla:

(b1: b2; bЗ) operaattorille b1;

while (b2)( operaattori; bЗ;)

Usein esiintyvä virheet ohjelmoitaessa jaksoja - alustamattomien muuttujien käyttö silmukan rungossa ja silmukan poistumisehdon virheellinen syöttäminen.

q tarkista, onko kaikille silmukan rungossa oleville osoitusoperaattoreiden oikealla puolella oleville muuttujille aiemmin määritetty alkuarvot (ja myös voidaanko muita operaattoreita suorittaa);

q tarkista, muuttuuko vähintään yksi silmukan poistumisehtoon sisältyvä muuttuja silmukassa;

q tarjoavat varauloskäynnin silmukasta, kun tietty määrä iteraatioita saavutetaan;

q ja tietenkään älä unohda, että jos sinun on suoritettava useampi kuin yksi lauseke silmukan rungossa, sinun on suljettava ne kiharat aaltosulkeet.

Silmukkaoperaattorit ovat vaihdettavissa, mutta jotkut suosituksia valita paras kussakin tapauksessa.

Do while -käskyä käytetään yleensä silloin, kun silmukka on suoritettava vähintään kerran (esimerkiksi jos silmukkaan syötetään dataa).

WhiIe-operaattoria on helpompi käyttää tapauksissa, joissa iteraatioiden lukumäärää ei tiedetä etukäteen, ei ole ilmeisiä silmukkaparametreja tai on kätevämpää kirjoittaa parametrien modifikaatio ei silmukan rungon loppuun.

For-operaattori on parempi useimmissa muissa tapauksissa (ehkästi silmukoiden järjestämiseen laskureilla).

Olemme jo tarkastelleet sykliä, jossa on parametri "Algoritmi" -osiossa "Algoritmityypit".
Käytetään silmukkaa parametrilla,kun tiedetään etukäteen kuinka monta kertaa silmukka tulee suorittaa.

Jakson tallennusmuoto:

Tässä varten, tehdä, tehdä- varatut sanat (varten, suorittaa, suorittaa);

<пар. цикла> - silmukkaparametri – muuttuja kokonaisluku tyyppi (tyyppi kokonaisluku);
<нач. знач.> - alkuarvo - numero tai muuttujakokonaisluku tyyppi (tyyppi kokonaisluku);
<кон. знач.> - lopullinen arvo - numero taimuuttujakokonaisluku tyyppi (tyyppi kokonaisluku);
<оператор> - mielivaltainen Pascal-operaattori.

Esimerkki: i:=1 - n do<оператор>
tässä olen silmukkaparametri
1 - alkuarvo
n - lopullinen arvo
Jos silmukan rungossa käytetään useita lauseita, käytetään operaattorisulkeja: begin ... end.
For-lausetta suoritettaessa lauseke arvioidaan ensin<нач.знач.>ja sen arvo on määritetty silmukkamuuttujalle<пар.цикла> := <нач. знач.>. Seuraavaksi he vertaavat<пар.цикла>Ja <кон.знач.>. Operaattori(t) suoritetaan, kunnes ne ovat yhtä suuret. Loop muuttujan arvo<нач.знач>kasvaa automaattisesti yhdellä silmukan aikana.On heti huomattava, että tässä operaattorissa on mahdotonta asettaa muuta jakson askelta kuin 1.
Esimerkki:
Seuraavat silmukkaoperaattorimerkinnät ovat mahdollisia:

1) i:lle: = 1 - n do s1;

2) i:lle: = 3 - 10 do s1;

3) i:lle = a - b tehdä s1;

4) i:= a - b do
alkaa

s1;
s2;
...
sn

loppu;

Tässä s1, s2, s3, ... sn ovat silmukkaoperaattoreita.

Esimerkki:
Kirjoita ohjelma, joka näyttää numerot 1-10.

Esimerkki:
Kirjoita ohjelma luvun n, eli n!, kertoimen laskemiseksi. (0!=1)

Ohjelman selitys:
Muuttuja n - käyttäjän syöttämälle numerolle, jonka kertoimella on löydettävä; f on muuttuja, johon luvun n faktoriaalin arvo "kertyy"; i on silmukkamuuttuja.
Muuttujan f:= 1 alkuarvo asetetaan.
Sitten sykli alkaa. Muuttujalle i annetaan alkuarvo 1; sitä verrataan viimeiseen - n (1<= n), если условие истинно, тогда выполняется оператор (в этой программе он один): f:= f*i, 1*1=1; значение переменной цикла увеличивается на 1, т. е. станет равным: i:= i + 1, 1 + 1 = 2 и цикл повторяется.
Kun i:n arvoksi tulee yhtä suuri kuin n, silmukka suoritetaan viimeisen kerran, koska i:n seuraava arvo on n + 1, mikä on suurempi kuin n:n lopullinen arvo, ehto i<= n - ложно, цикл не выполняется.

For-silmukan lausekkeella on toinen muoto:
Jakson tallennusmuoto:

Varatun sanan korvaaminen sanalla alas tarkoittaa, että silmukan parametriaskel on (-1).
Parametrin arvo muuttuu suuremmasta arvosta pienempään, ts.<нач. знач.> <кон. знач.>.

Esimerkki:
Seuraavat silmukkaoperaattorimerkinnät ovat mahdollisia:

1) i:= n:stä 1:een s1;

2) i: = 10 alas 3 do s1;

3) i:= b:lle alas a do s1:lle; (edellyttäen, että b>a)

4) for i:= b downto a do
alkaa

S1;
s2;
...
sn

loppu; (edellyttäen, että b>a)

Tässä s1, s2, s3, ... sn ovat silmukkaoperaattoreita.

Esimerkki: Laskuohjelma tekijällinen numerot voidaan muodostaa käyttämällä tätä silmukkaoperaattoria.

Tehtävät

Kun annetaan 10 numeroa, tulosta ne, jotka ovat täydellisiä neliöitä.
Kun annetaan 10 numeroa, etsi heidän tuotteensa.Luo vuokaavio ja ohjelma.
Kun on annettu 10 numeroa, etsi parillisten summa.Luo vuokaavio ja ohjelma.
Kun on annettu 10 numeroa, etsi negatiivisten lukumäärä.Luo vuokaavio ja ohjelma.
Annettu n reaalilukua. Etsi maksimi ja minimi.Luo vuokaavio ja ohjelma.
Annettu n reaalilukua. Etsi kaikkien elementtien aritmeettinen keskiarvo.Luo vuokaavio ja ohjelma.
Annettu n reaalilukua. Etsi negatiivisten ja positiivisten elementtien aritmeettinen keskiarvo.Luo vuokaavio ja ohjelma.
Annettu n luonnollista lukua. Etsi niiden elementtien summa ja tulo, jotka ovat 3:n ja 5:n kerrannaisia.Luo vuokaavio ja ohjelma.
Annettu n luonnollista lukua. Peruuttaa ne luvut, joiden arvot ovat kahden potenssit (1, 2, 4, 8, 16, ...).Luo vuokaavio ja ohjelma.
Annettu n luonnollista lukua. Peruuttaa ne numerot, joiden arvot ovat välissä.Luo vuokaavio ja ohjelma.
Annettu n luonnollista lukua. Näytä ne luvut, joiden arvot ovat jonkin luvun neliöitä.Luo vuokaavio ja ohjelma.
Annettu luonnollinen luku n. Etsi n 2.Luo vuokaavio ja ohjelma.
Annetut luonnolliset luvut a, n. Etsi n.Luo vuokaavio ja ohjelma.
Annettu luonnollinen luku n. Määritä sen bittisyvyys, suurenna luvun merkittävintä numeroa kahdella
Annettu luonnollinen luku n. Vaihda numeron ensimmäinen ja viimeinen numero
Annettu luonnollinen luku n. Korvaa luvun 2 kerrannaiset numerot nollalla.
Annettu luonnollinen luku n. Korvaa numerot, jotka ovat 3:n kerrannaisia yhdellä.
Annettu luonnollinen luku n. Laske tulo (2n-1)*(3n-1)*(4n-1)*...*(10n-1).Luo vuokaavio ja ohjelma.
Laske summa 2+4+6+...+100.Luo vuokaavio ja ohjelma.
Annettu luonnollinen luku n, reaaliluku x. Laske tulo x+x/2+x/3+...+x/n.Luo vuokaavio ja ohjelma.
Annettu luonnollinen luku n. Laske P=(1-1/2)(1-1/3)...(1-1/n), missä n>2.Luo vuokaavio ja ohjelma.
Annettu luonnollinen luku n. Laske P=(1+x)/n+(2+x)/(n-1)+...+(n+x)/1.Luo vuokaavio ja ohjelma.
Annettu n luonnollista lukua. Laske sarjan summa1+x/1!+x 2/2!+x 3/3!+ ...+x n/n!. Luo vuokaavio ja ohjelma.

Yleisesti ottaen opimme tänään jokaisesta Pascalin syklistä yksityiskohtaisemmin ja katsomme kuinka ne määritellään. Selvitämme sen while-silmukka ennakkoehdoin, silmukalle parametrin kanssa Ja toista - kunnes silmukka jälkiehdon kanssa.

1. Silmukka parametrilla Pascalissa - FOR

FOR-silmukka asettaa tietyn ehdon, jossa ohjelma toimii ennen sen suorittamista. Oletetaan, että ohjelma pitää silmukata 5 (tai n) kertaa, niin tämä voidaan tehdä helposti tällä silmukalla. FOR-silmukalla on ominaisuus - laskuri, jota yleensä merkitään kirjaimella i tai j.

Pascal-parametrin sisältävän silmukan ulkonäkö:

i:= 1 - n do // määritä i ensin yhdelle, sitten kahdelle, kolmelle, ..., n

Ensimmäisen kierroksen jälkeen annamme muuttujalle i 1:n, toisen jälkeen 2 ja niin edelleen, kunnes saavutamme n. to - tämä on jopa.. nousevassa järjestyksessä, on myös alas - asti.. laskevassa järjestyksessä.

Lohko - syklikaavio parametrilla:

2. Silmukka, jonka ennakkoehto Pascalissa - WHILE

Edellytyksen omaava silmukkaoperaattori suorittaa toimintoja tuntemattoman monta kertaa. Silmukka poistuu, jos jokin looginen lauseke tai sen tulos osoittautuu vääräksi. Koska loogisen lausekkeen oikeellisuus tarkistetaan alussa, silmukan runkoa ei välttämättä suoriteta edes kerran.

Silmukan rakenne edellytyksenä:

WHILE DO alkaa loppu;

Looginen lauseke, jonka totuus tarkistetaan syklisen operaattorin suorituksen alussa;

Kaikki suoritettavat kielen lausekkeet.

Silmukan suoritusjärjestys:

Vaikka ehto on tosi, silmukan runko suoritetaan. Heti kun ehdosta tulee epätosi, silmukan suoritus pysähtyy.

Lohko - syklin kaavio, jossa on ennakkoehto:

Huomautus: suorakaiteen muotoiset lohkot näyttävät kaikki toiminnot, jotka suoritetaan silmukassa tai sen jälkeen (silmukkaaskel), kun taas soikeat lohkot näyttävät koko ohjelman tai sen osan alun tai lopun. Päärooli tässä lohkokaaviossa on sen keskeisellä osalla.

Esimerkki:

Tehtävä: laske sarjan 1+1,5+2+2,5+3+3,5+ .. + 30 summa

ohjelma esimerkki-while;

Var summa:real; n:todellinen; ALKUsumma:=0; n: = 1; kun taas n

3. Silmukka jälkiehdon kanssa - Toista - kunnes.

Tämä operaattori on samanlainen kuin silmukkaoperaattori, jolla on ehto, mutta eroaa siitä siinä, että ehto tarkistetaan sen jälkeen, kun silmukan runko (toiminnot) on suoritettu. Tämä varmistaa, että se suoritetaan vähintään kerran, toisin kuin aiemmin jäsennetyt silmukat.

Huomaa, että tämä silmukkaoperaattori olettaa, että silmukan rungossa on useita lauseita, eli useita toimintoja voidaan suorittaa, joten Begin- ja End-palvelusanoja ei tarvita.

Silmukan runkoon sisältyvä operaattorisarja suoritetaan kerran, minkä jälkeen tarkistetaan palvelusanan Until jälkeen kirjoitettu ehto. Jos ehto ei täyty, silmukka päättyy. Muussa tapauksessa silmukan runko toistetaan uudelleen, minkä jälkeen ehto tarkistetaan uudelleen.

Lohkokaavio syklistä, jossa on jälkiehto:

Tallennusmuoto, syklin rakenne:
TOISTA KUNNES;

Esimerkki:

Ohjelmatesti2; Var b: Todellinen; Aloita b:=100; Toista b:=b/2; Kunnes b

Johtopäätökset:

1. Parametrilla varustettu silmukka käyttää muuttujaa, jota kutsutaan silmukkaparametriksi tai laskuriksi. Ennen silmukan suorittamista parametri (laskuri) asetetaan alkuperäiseen arvoonsa. Kun silmukkavaihe on suoritettu, parametrin arvoa kasvatetaan yhdellä. Silmukka jatkuu, kunnes parametri saavuttaa lopullisen arvon, joka on merkitty (alaspäin).

2. Edellytyssilmukka jatkuu, kunnes suoritusehdosta tulee epätosi, ja jatkuu, jos ehto on tosi.

3. Jälkiehdon sisältävä silmukka suoritetaan, kunnes ehdosta tulee tosi, jos ehto on epätosi, silmukka jatkuu.

For silmukan lauseke toteuttaa algoritmisen rakenteen silmukka parametrin kanssa(tai silmukka, jossa on laskuri). For-silmukkaa käytetään, kun ohjelmassa ennen silmukan käskyjen suorittamista tämän silmukan vaiheiden lukumäärä tulee tiedoksi (tai on ennalta määrätty). Lohkokaaviossa for-lause esitetään seuraavasti:

Syntaksi:

For( alustus; kunto; muutos) (Keskiosan ohjeet;)

Jos silmukan rungossa on yksi käsky, ( ) voidaan jättää pois. Silmukkaparametrimuuttuja (laskuri) voi olla mitä tahansa numeerista tyyppiä. Tämä tekee C++ for -silmukasta yhtä monipuolisen kuin while-silmukan. Muokkausosiossa käytetään useimmiten postfix- tai etuliitteen lisäys- (tai dekrementointi) -operaatiota, mutta mitä tahansa silmukkaparametrin arvoa muuttavaa osoituslauseketta voidaan käyttää. Sykli toimii näin:

Alussa laskurimuuttuja kuvataan ja alustetaan
Tarkista seuraavaksi ehto: jos lausekkeella on arvo totta, iteraatio tapahtuu
Kun silmukan rungon käskyt on suoritettu, laskurin arvoa muutetaan

Huomautus: C++:ssa on sääntö, että laskurimuuttujan ilmoitus tehdään silmukan päähän. Mutta tämä ei ole välttämätöntä, varsinkin jos aiot alustaa useita muuttujia alustusosassa ohjelman 9.2 mukaisesti. Laskurimuuttujan ilmoituksen käyttäminen silmukan otsikossa johtaa kuitenkin paikallisen muuttujan ilmoitukseen, joka tuhoutuu automaattisesti silmukan päättyessä. Siksi, ellei se ole ehdottoman välttämätöntä, sinun ei pitäisi määrittää laskurimuuttujaa for-silmukan ulkopuolelle.
For-silmukan ollessa käynnissä ei ole suositeltavaa muuttaa silmukan otsikkolausekkeiden operandeja - tämä johtaa kaikenlaisiin virheisiin! Mutta muuttujien (tai vakioiden) arvoja, mukaan lukien muuttuvat arvot (laskuri), voidaan käyttää. Katsotaanpa klassista esimerkkiä.

Ohjelma 9.1 Annettu luonnollinen luku N. Tulosta tämän luvun kaikki jakajat.

#sisältää << "N = "; cin >> N; for (int i = 2; i< N / 2; i++) { if (N % i == 0) cout << i << " "; } return 0; } N = 16000 2 4 5 8 10 16 20 25 32 40 50 64 80 100 125 128 160 200 250 320 400 500 640 800 1000 1600 2000 3200 4000

Jatka-lauseen käyttäminen for-silmukassa

Kun käytät jatkamislausetta for-silmukassa, sinun on otettava huomioon tämän silmukan toiminnan erityispiirteet:

Jatkoa seuraavat lausunnot ohitetaan
Sitten laskuria muutetaan
Siirry seuraavaan iteraatioon (muuten tilan tarkistaminen)

Osoitetaan tämä esimerkillä: int main() ( for (int i = 1; i< 20; i++) { if (i % 2 == 0) continue; cout << i << " "; } 1 3 5 7 9 11 13 15 17 19

Huomautus. Huomaa: vaikka numeroiden tulostaminen ehtojen mukaan ohitetaan, laskuri kasvaa. Tämä esimerkki on vain havainnollistava; tämä ei ole tapa ohjelmoida silmukkaa! Tämä ongelma on parempi ratkaista seuraavasti:

Int main() ( for (int i = 1; i< 20; i += 2) cout << i << " ";

Useita lausekkeita alustus- ja muokkausosiossa

Kuten aiemmin totesimme, for-lausekkeen pääosassa on oltava kolme osaa. Näiden osien lausekkeet voidaan jättää pois, mutta ";" -merkkiä ei voi jättää pois. . Lopulta voi vain lähteä; . Otsikko lomakkeessa:

Sille (;;) ( ... )

on "äärettömän" silmukan otsikko. (Silmukasta poistuminen on ohjelmoitava silmukan runkoon.)
C++ tukee useita lausekkeita for-lauseen otsikon alustus- ja muokkausosioissa. Tässä tapauksessa syklin jatkamisen edellytyksen on oltava yksi!
Esimerkiksi. Tehtävä: Laske luvun, joka on enintään 20, tekijä.
Ohjelma 9.2

#sisältää käyttäen nimiavaruutta std; int main() ( etumerkitön pitkä pitkä n; int i, k; cout<< "k = "; cin >>k; // 0<= k <= 20 for(n = 1, i = 1; i <= k; n *= i, ++i); cout << k << "! = " << n << endl; return 0; } k = 20 20! = 2432902008176640000

Huomautus: Huomaa, että rivin 12 lähtövirta ei ole osa silmukan runkoa! (Otsikon lopussa - ;). Siten tämän silmukan rungossa on tyhjä käsky, ja kaikki lausekkeet arvioidaan otsikossa. Ohjelma 9.2 laskee oikein luvun 0-20 kertoimen.

aluepohjainen silmukalle

Jotta voit iteroida taulukon tai säilön elementtejä, sinun on suoritettava samantyyppisiä toimintoja ja käytettävä hankalaa koodia. Säilöjen kanssa työskentelyn helpottamiseksi C++:ssa on olemassa erityinen for-silmukan muoto - aluepohjainen for (silmukka aluepohjaiselle tai vaihteluväli).
Syntaksi:

For( ilmoitus : sekvenssin_nimi) loop_lauseke

Aluepohjaisen käyttäminen C-taulukon käyttämiseen esimerkkinä:
Ohjelma 9.3

#sisältää käyttäen nimiavaruutta std; int main() ( int x ( 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ); for (auto &s: x) ( cout<< s << " "; } return 0; }

Jotta taulukon elementtejä voidaan muuttaa, muuttujan s on oltava viitemuuttuja (kuten yllä olevassa esimerkissä). Jos muuttuja ei ole viite, tiedot kopioidaan. Tämä silmukka käyttää automaattista tyyppiä päättelemään automaattisesti. aluepohjaisella for:lla on rajoitus dynaamisten taulukoiden kanssa työskennellessä: se ei tue taulukon koon muuttamista, koska se sisältää kiinteän osoittimen taulukon loppuun. Kun työskentelet kiinteän koon taulukoiden kanssa, alue for on erinomainen ja turvallinen vaihtoehto tavalliselle for .

Sisäkkäisiä silmukoita varten

Kuten muutkin silmukkakäskyt, for tukee sisäkkäistä silmukkarakennetta. Sisäkkäisten silmukoiden käyttäminen kaksiulotteisten taulukoiden tulon ja lähdön järjestämiseen on paljon kompaktimpaa kuin while-silmukan käyttäminen.
Kuitenkin, kun ratkaistaan tällaisten taulukoiden läpikulkuongelmia, on välttämätöntä välttää ehdollisen if-lauseen käyttöä. Usein tehtävä voidaan toteuttaa järkevämmin manipuloimalla indeksejä (silmukkamuuttujat i ja j). Toisin sanoen yhden indeksin muutoksen tekeminen riippuvaiseksi toisen indeksin arvosta. Katsotaanpa kahta esimerkkiä.
Ohjelma 9.4 Annettu neliömatriisi, jonka koko on n, jonka alkiot ovat yhtä kuin 0. Täytä päälävistäjän alapuolella ja päällä olevat alkiot ykkösillä.

#sisältää käyttäen nimiavaruutta std; int main() ( int n; cout<< "n = "; cin >>n; int mas[n][n]; // Täytä nollia for(int i = 0; i< n; i++) for(int j = 0; j < n; j++) mas[i][j] = 0; // Реализация for(int i = 0; i < n; i++) for(int j = 0; j <= i; j++) mas[i][j] = 1; // Вывод for(int i = 0; i < n; i++) { for(int j = 0; j < n; j++) { cout.width(2); cout << mas[i][j]; } cout << "\n"; } return 0; } n = 10 1 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 1 1 1 1 1 1 0 0 0 0 1 1 1 1 1 1 1 0 0 0 1 1 1 1 1 1 1 1 0 0 1 1 1 1 1 1 1 1 1 0 1 1 1 1 1 1 1 1 1 1

Ohjelma 9.5 Kirjoita ohjelma, joka täyttää taulukon numeroilla Pascalin kolmiosta ja tulosta tämä taulukko. Pascalin kolmio näyttää tältä:

Tässä kolmiossa on ylhäällä ja sivuilla (ohjelmassa 9.5 kolmio on "asetettu kyljelleen" - kolmion sivut ovat: ensimmäinen sarake ja päädiagonaali). Jokainen luku on yhtä suuri kuin sen yläpuolella olevien kahden luvun summa. Kolmion rivit ovat symmetrisiä pystyakselin suhteen ja sisältävät binomiaalikertoimia.

#sisältää käyttäen nimiavaruutta std; int main() ( int n; cout<< "n = "; cin >>n; int pas[n][n]; for (int i = 0; i< n; i++) for (int j = 0; j < n; j++) pas[i][j] = 0; pas = 1; for (int i = 1; i < n; i++) { pas[i] = 1; for (int j = 1; j <= i; j++) { pas[i][j] = pas + pas[j]; } } for (int i = 0; i < n; i++) { for (int j = 0; j <= i; j++) { cout.width(4); cout << pas[i][j]; } cout << "\n"; } return 0; } n = 12 1 1 1 1 2 1 1 3 3 1 1 4 6 4 1 1 5 10 10 5 1 1 6 15 20 15 6 1 1 7 21 35 35 21 7 1 1 8 28 56 70 56 28 8 1 1 9 36 84 126 126 84 36 9 1 1 10 45 120 210 252 210 120 45 10 1 1 11 55 165 330 462 462 330 165 55 11 1

Kysymyksiä

Voiko ohjelman for-silmukan käskyn korvata while-silmukan käskyllä? Voiko näin tehdä aina?
Milloin on kätevämpää käyttää for-lausetta silmukoiden järjestämiseen? sillä aikaa?
Ovatko seuraavat lausekkeet mahdollisia lausekkeen a alussa: a) for (;a > b && !(a % 2);) b) for (a > b;;) c) for (;;i = 0) d) ( ;i = 0;) e) (;;i++, --b) f) (--i;;) g) (b = 0; b != a;) ?
Muuttuja i on ulomman silmukan parametri ja muuttuja j on sisäkkäisen silmukan parametri. Onko muuttuja j käytettävissä ulkosilmukassa? olen sisäkkäisessä silmukassa?

Oppikirja

Kotitehtävät

Takaosa 29. Kirjoita ohjelma, joka syöttää luonnollisia lukuja a Ja b, ja näytössä näkyvät kaikki alkuluvut alueella alkaen a ennen b(algoritmiidea Ohjelma 8.5)
Takaosa 30. Lukua kutsutaan täydelliseksi, jos se on yhtä suuri kuin itseään pienempien jakajiensa summa (esim. luku 6 = 1 + 2 + 3). Kirjoita ohjelma, joka syöttää luonnollisen luvun N ja määrittää, onko N täydellinen luku.
Kirjoita ohjelma, joka näyttää neliönumerotaulukon, jonka koko on n x n ja jolla on seuraava muoto n = 10: 1 * * * * * * * * * * 2 * * * * * * * * * * 3 * * * * * *** * * * * * * * * * * 9 * * * * * * * * * * 10

Kirjallisuus

Lafore R. Olio-ohjelmointi C++-kielellä (4. painos). Pietari: 2004
Prata, Stephen. C++ ohjelmointikieli. Luennot ja harjoitukset, 6. painos: Trans. englannista - M.: LLC "I.D. William", 2012
Lippman B. Stanley, Josie Lajoie, Barbara E. Mu. C++ ohjelmointikieli. Peruskurssi. Ed. 5. M: LLC “I. D. Williams”, 2014
Elline A. C++. Lamerista ohjelmoijaksi. Pietari: Pietari, 2015
Shildt G. C++: Peruskurssi, 3. painos. M.: Williams, 2010

Kohde: anna syklien käsite parametrilla, lohkokaaviot, jotka kuvaavat tällaisia jaksoja. Opi laatimaan lohkokaavioita ja ohjelmia silmukoiden avulla tiettyjen esimerkkien avulla; antaa käsityksen ennakkoehdon, jälkiehdon ja parametrin silmukan välisistä eroista; opettaa käyttämään eri silmukoita yhdessä ohjelmassa, jos ohjelma sisältää useita silmukoita; syöttää ja suorittaa ohjelmia käyttämällä BPW- tai Turbo Pascal -kääntäjiä.

1. Operaattori silmukka ... tehdä ... tehdä ...

Joskus tiedät etukäteen, kuinka monta kertaa silmukka tulee suorittaa. Tämän tyyppisiä ongelmia varten Pascal-kielellä on operaattoreita silmukat parametreillä .
Tällaisten operaattoreiden tallennusmuoto on seuraava:
varten<pyörä par.> := <alkuarvo> to<lopullinen arvo.> tehdä <operaattori>.
Tässä varten, to, tehdä- varatut sanat (varten, suorittaa, suorittaa);
<höyryä. sykli> - silmukkaparametri - muuttuja, jonka tyyppi on kokonaisluku (tarkemmin sanottuna mikä tahansa järjestystyyppi);
<alku arvo.> - alkuarvo - samantyyppinen luku tai lauseke;
<con. arvo.> - lopullinen arvo - samantyyppinen luku tai lauseke;
<operaattori> on mielivaltainen Pascal-operaattori.
Jos operaattoreita on useita, niin kuten operaattorissa sillä aikaa... tee..., operaattorisulkeja käytetään: alkaa ... loppu.
Esimerkiksi seuraavat silmukkaoperaattorimerkinnät ovat mahdollisia:

varten minä:=a to b tehdä s1;

varten j:=a to b aloita s1; s2; ..., sn loppu; tai

varten k:=p to m tehdä
alkaa
s1;
s2;
...
sn
loppu;

Tässä s1, s2, s3, ... sn ovat silmukkaoperaattoreita.
Kun suoritat lausunnon varten ensin lauseke arvioidaan<alkuarvo.> ja määrittämällä sen arvon silmukkamuuttujalle
<pyörä par.> := <alku arvo.>.
Tämän jälkeen ne toistetaan syklisesti:
1) kunnon tarkistaminen<pyörä par.> <con. arvo.>; jos ehto ei täyty, operaattori varten lopettaa työn;
2) lausunnon täytäntöönpano<operaattori> tai operaattorit s1; s2; s3; ...sn;
3) silmukkamuuttuja<höyryä. sykli> kasvaa yhdellä.

Meidän tulee heti huomata että tässä lauseessa on mahdotonta asettaa muuta silmukkaaskelta kuin 1.

Graafinen esitys jaksoista varten tulee olemaan tällainen (katso kuva 33):

Riisi. 33

Tässä: i on silmukkamuuttuja; n on sen alkuarvo; k on sen lopullinen arvo. Jakson runko koostuu operaattorista tai useista operaattoreista: s1; s2; ... sn;, jotka on piirretty suorakulmioon.

Havainnollistamaan operaattorin työtä varten Tarkastellaan esimerkkiä, josta on tullut jo perinteinen tämän operaattorin työtä tutkittaessa.

Esimerkki 1. Tee ohjelma luvun n kertoimen laskemiseksi eli n!.

Muistakaamme matematiikasta, että luvun n tekijä on yhtä suuri kuin lukujen tulo 1:stä n:ään.
Esimerkiksi:

Z Huomautus . Matematiikassa hyväksytään: 0! = 1.

Lohkokaavio

Riisi. 34

Ohjelmoida

Ohjelmoida Ongelma1; ( Lasketaan n:n faktoriaali!)
käyttää WinCrt;
var
n, f, i: longint;
alkaa

f: = 1;
jos n<> 0 sitten varten minä:= 1 to n tehdä f:= f*i;
loppu.

Muuttuja n - käyttäjän syöttämälle numerolle, jonka kertoimella on löydettävä; f on muuttuja, joka sisältää " kerääntyä" luvun n kertoimen arvo; i on silmukkamuuttuja.
Muuttujan f:= 1 alkuarvo asetetaan.
Sitten sykli alkaa. Muuttujalle i annetaan alkuarvo 1; sitä verrataan viimeiseen - n (1<= n), Jos ehto on totta, Sitten Operaattori suoritetaan (tässä ohjelmassa on vain yksi): f:= f*i, 1*1=1; silmukkamuuttujan arvoa kasvatetaan 1:llä, eli se on yhtä suuri kuin: i:= i + 1, 1 + 1 = 2 ja silmukka toistuu.
Kun i:n arvosta tulee yhtä suuri kuin n, Sitten silmukka suoritetaan viimeisen kerran, koska i:n seuraava arvo on n + 1, joka on suurempi kuin n:n lopullinen arvo, kunto i<= n - väärä, silmukkaa ei suoriteta.

2. Silmukkaoperaattori varten...alalle...tekemään...

On olemassa toinenkin silmukkaoperaattorin muoto varten:
varten<par.cycle.> := <alku zn.> alaspäin <con. zn.> tehdä <operaattori>.

Varatun sanan korvaaminen to päällä alaspäin tarkoittaa että silmukan parametrivaihe on (-1).

Parametrin arvo muuttuu suuremmasta arvosta pienempään, ts.
<alku arvo.> <con. arvo.>.
Tällä silmukkaoperaattorilla voidaan kirjoittaa ohjelma luvun kertoimen laskemiseen.
Ohjelmoida

Ohjelmoida Ongelma1a;
käyttää WinCrt;
var
n, i, f: longint;
alkaa
write("Anna luonnollinen luku"); readln(n);
f: = 1;
jos n<> 0 sitten varten i:=n alaspäin 1 tehdä f:= f*i;
writeln("Kohteiden ", n, " tekijä on ", f)
loppu.

1. Muuta ohjelmaa siten, että se ei näytä neliötaulukkoa numeroista 1-n, vaan vain yhden käyttäjän syöttämän luvun n neliön.

2. Muuta ja laajenna ohjelmaa niin, että se antaa luvun neliön arvon ja ne parittomat luvut, joiden summa on yhtä suuri.

3 . Jatkuu aihe luonnonlukujen nostamisesta potenssiin, ilman kertolaskuoperaatioita, tarkastellaan kahta mielenkiintoista esimerkkiä. Ensimmäisessä niistä meidän on yhdistettävä " sijoittaa"kaksi sykliä toisiinsa varten ja toisessa syklit varten Ja toistaa.

Esimerkki 3. Minkä tahansa luonnollisen luvun n kuutio on yhtä suuri kuin n parittoman luvun summa, jotka seuraavat numerot, joiden summa oli edellisen luvun n - 1 kuutio:

13 = 1
23 = 3 + 5
33 = 7 + 9 + 11
43 = 13 + 15 + 17 + 19
. . . . . . . . . . . . . . . . . . . . . .

Luo tämän ominaisuuden perusteella ohjelma, jonka avulla voit tulostaa luonnollisten lukujen kuutioiden taulukon.

Tässä tarvitaan jo kaksi sykliä. Yksi on ulkoinen , parittomien lukujen määrän mukaan, joka on yhtä suuri kuin kuutiotettava luku, esimerkiksi 43:lle tämä silmukka tulee suorittaa 4 kertaa. Samassa jaksossa summan laskemisen jälkeen on tarpeen näyttää sen arvo näytöllä yhdessä kuutioitetun luvun kanssa.
Toinen on sisäinen , joka summaa parittomat luvut ja " kehittää"vaatii parittomat luvut summaamiseen.

Lohkokaavio

Riisi. 36

Ohjelmoida

Ohjelmoida Ongelma3; (luonnollisten lukujen kuutiot 1 - n)
käyttää WinCrt;
var
i, j, n, s, k: longint;
alkaa
writeln("Anna saavutettava luonnollinen luku");
write("tulosta numerokuutiot"); readln(n);
writeln("Lukukuutiot ovat seuraavat:");
k: = 1;
varten minä:= 1 to n tehdä
alkaa
s: = 0;
varten j:= 1 to i tehdä
alkaa
s:= s + k;
k:= k + 2
loppu;
writeln("Luvun ", i, " kuutio on yhtä suuri kuin ", s)
loppu
loppu.

Katsotaanpa, miten tämä ohjelma toimii

Muuttujia i ja j tarvitaan ensimmäisen - ulomman ja toisen - sisemmän silmukan muuttujina. Muuttuja k on parittomille luvuille ja s lukujen summalle. Näiden muuttujien tyypiksi on asetettu kokonaisluku, mutta longint, koska voi olla melko suuria kokonaislukuja, jotka ovat suurempia kuin 32767.
Ohjelma alkaa pyynnöllä, että käyttäjä syöttää writeln- ja write-operaattoreita käyttäen luonnollinen luku, jota ennen on tarpeen tuottaa numerokuutioiden taulukko. Tämä arvo syötetään sitten tietokoneen muistiin readln-käskyn avulla ja määritetään muuttujalle n.
Viesti " Lukukuutiot ovat seuraavat". Se annetaan ennen silmukoiden alkua ilmeisistä syistä. Sitä ei voi antaa silmukoissa - se toistetaan useita kertoja. Myös silmukoiden lopussa se kirjoitetaan alla, kun itse numerot on tulostettu Muuttujalle k annetaan ensimmäinen pariton arvo 1.
Ulompi silmukka alkaa numeroiden lukumäärän perusteella 1 - n. Silmukassa on useita lausuntoja, joten " avata" käyttösulut: - alkaa...
Ennen sisäisen silmukan alkua muuttuja s - summa - nollataan. Lisäksi tällainen nollaus tapahtuu joka kerta, kun ulkoinen silmukka, ennen kuin suoritat sisäisen silmukan.
Sisäsilmukka kulkee 1:stä i:hen. Miksi? Silmukka laskee summan ja kasvattaa paritonta k:ta kahdella, eli " on tuotettu"seuraava pariton numero.

Ilmoitus! Muuttujaa k ei anneta ennen kunkin sisemmän silmukan 1 alkua. Miksi?
Seuraava kirjoituslause ulkosilmukan sisällä tulostaa tiedot näytölle. Miksi se on sijoitettu ulompaan silmukkaan?

Esimerkki 4. Matematiikasta tiedetään, että jokainen luvun n luonnollinen potenssi on n peräkkäisen parittoman luonnollisen luvun summa. Kirjoita ohjelma, joka millä tahansa luonnollisen luvun n potenssilla löytäisi parittomia lukuja, joiden summa on yhtä suuri kuin tämä potenssi.

Esimerkiksi 53:lle se tuottaisi numerosarjan: 21, 23, 25, 27, 29.

Ohjelmointisuunnitelma

1. Määritetään ohjelman laatimisen tarkoitus: se on välttämätöntä näytä , joka on oikeastaan mikä tahansa luonnollisen luvun luonnollinen potenssi Voi edustaa sitä peräkkäisten parittomien lukujen summana.
Ja jos näin on, meidän on ehdottomasti tiedettävä n:n potenssin arvo eksponentin k kanssa.
Tämä voidaan tehdä yksinkertaisella silmukalla:

s: = 1;
varten minä:= 1 to k tehdä s:= s*n;

Tutkinnon arvo kumuloituu muuttujaan s; tätä varten sen alkuarvoksi asetetaan 1.
Silmukassa muuttujan s arvo kerrotaan peräkkäin k kertaa n:n potenssilla. Silmukan suorittamisen jälkeen muuttuja s saa n:n potenssin arvon eksponentilla k.
2. Kysymyksen koko kiireellisyys on siinä, että ensimmäinen pariton luku on tuntematon, josta peräkkäisten parittomien lukujen summaus on aloitettava.
Tätä varten tarvitset näyte lisää ensin parittomat luvut 1:stä eteenpäin (niiden lukumäärä tunnetaan - n);
1 + 3 + 5 + 7 + 9 ...,
ja tarkista sitten saatu tulos vertaamalla sitä asteen s arvoon. Jos yhtälö on tosi, lopeta silmukka ja näytä tuloksena saadut parittomat luvut näytöllä; jos yhtälö ei ole totta, sinun on aloitettava summaus seuraavasta parittomasta luvusta - 3: 3 + 5 + 7 + 9 . .. jne.
Tämä prosessi on helpompi järjestää silmukan avulla toistaa. Muuttuja j, joka määrittää alkuparittomat luvut, on asetettava alkuarvoon 1 ennen silmukan alkua.
Yleiskuva tällaisesta syklistä:

j: = 1;
toistaa
. . . . . .
j:=j+2
siihen asti kun...= s;

3. On vielä mietittävä, kuinka peräkkäisten parittomien lukujen summat lasketaan. Olemme jo törmänneet tähän kysymykseen ja tiedämme, että tätä varten meidän on luotava jakso 1:stä n:ään, jossa tämä määrä on kerättävä yhteen muuttujista, esimerkiksi m, ja toisen muuttujan täytyy " kehittää"seuraava pariton numero.
Tämä sykli voidaan kirjoittaa näin:

p:= j; m: = 0;
varten minä:= 1 to n tehdä
alkaa
m: = m + p;
p:= p+2
loppu;

Huomautus! Muuttuja p, joka sykli toistaa, (annetun ulkoinen) saa uuden parittoman luvun alkuarvon, ja summan muuttuja m - on nollattava ennen jokaista uutta summausta toiselle parittomille numeroille.
4. Lopuksi, kun parittomien numeroiden sarja löytyy, se on näytettävä näytöllä. Tätä varten meidän on järjestettävä toinen silmukka 1: stä n: ään, jossa annamme näiden parittomien lukujen arvot. Jakson ensimmäiselle parittomalle luvulle on otettava arvo j, mutta koska se on jo kasvanut kahdella, meidän tulee vähentää 2 j:stä. Tämä silmukka on:

j: = j - 2;
varten minä:= 1 to n tehdä
alkaa
kirjoittaa(j, " ");
j:=j+2
loppu

Lohkokaavio

Riisi . 37
Ohjelmoida

Ohjelmoida Ongelma4;
käyttää WinCrt;
var
n, i, k, j, m, s, p: longint;
alkaa
write("Anna luonnollinen luku - potenssin kanta"); readln(n);
write("Anna luonnollinen luku - eksponentti "); readln(k);
s: = 1; j: = 1;
varten minä:= 1 to k tehdä s:= s*n;
toistaa
p:= j;
m: = 0;
varten minä:= 1 to n tehdä
alkaa
m: = m + p;
p:= p+2
loppu;
j:=j+2
siihen asti kun m=s;
write("Power with base ", n);
writeln(" ja eksponentti ", k, " eli ", s);
writeln("yhtä kuin seuraavien parittomien lukujen summa");
j: = j - 2;
varten i:=1 to n tehdä
alkaa
kirjoittaa(j, " ");
j:=j+2
loppu
loppu.

Ymmärtääksesi paremmin, miten se toimii, ota teho 25 ja tarkista, kuinka ohjelmakäskyt suoritetaan peräkkäin.

1 . Suorita tämä ohjelma tietokoneissa.

2 . Luo vuokaavio ja ohjelma, joka määrittää, voiko teos tehdä
a) kolme; b) neljä peräkkäistä luonnollista lukua vastaa jonkin luonnollisen luvun potenssia (neliö, kuutio jne.)?

4. Erilaiset tehtävät

Esimerkki 5. Tulosta kaikki nelinumeroiset luvut, joiden desimaalimuodossa ei ole kahta identtistä numeroa.

Kommentti . Ennen kuin alat laatia vuokaavion tätä tehtävää varten, sinun tulee tietää, kuinka silmukoiden sisällä olevat silmukat on kuvattu silmukoille, joissa on parametrit. Kahden sisäkkäisen silmukan yleinen rakenne parametreilla on seuraava:

Riisi. 38
Välittömästi herää ajatus ohjelman luomisesta seuraavan kaavan mukaan:
järjestää sykli tuhansien lukumäärällä, t 1 - 9 ja sitten sisäinen syklit: satojen lukumäärällä, s 0 - 9; kymmenien lukumäärän mukaan, d välillä 0 - 9; yksiköiden lukumäärän mukaan, e 0 - 9; kuntotarkastus: Jos numerot ovat erilaisia Sitten näyttää niistä koostuvan nelinumeroisen luvun näytöllä.
Lohkokaavio

Riisi. 39
Ohjelmoida

Ohjelmoida Ongelma5; (1. menetelmä)
käyttää WinCrt;
var
t, s, d, e: kokonaisluku;
alkaa
varten t:= 1 to 9 tehdä
varten s:= 0 to 9 tehdä
varten d:= 0 to 9 tehdä
varten e:= 0 to 9 tehdä
jos(t<>s) ja(t<>d) ja(t<>e) ja(s<>d) ja
(s<>e) ja(d<>e)
sitten write(t*1000 + s*100 + d*10 + e, " ")
loppu.

On selvää, että tämä ohjelma toteutettiin irrationaalisesti. Siinä kaikki syklit suoritetaan kokonaan.
Ohjelmaa voidaan parantaa tällä tavalla. Kun satojen sykli suoritetaan, seuraava kymmenien sykli on aloitettava, Jos sataluku s ei ole sama kuin tuhansluku t, muuten muuten , satojen kiertoa on jatkettava, eli otetaan seuraava satojen numero.
Aseta kymmenille numeroille myös ehto, että seuraava yksikkösilmukka suoritetaan, Jos kymmenien numero d ei ole yhtä suuri kuin satoja ja tuhansia numeroita, muuten muuten , sinun on siirryttävä seuraavaan kymmeniin numeroihin.
Ja sitten, " sisällä"yksikköjen sykli, riittää kun kirjoitetaan ehto, Jos yksikön numerot e eivät ole yhtä suuria kuin kymmenluku d, satoja s ja tuhansia t, nelinumeroinen luku on haettu numero ja se näkyy näytöllä.

Lohkokaavio

Riisi . 40

Ohjelmoida

Ohjelmoida Ongelma5a; (2. menetelmä)
käyttää WinCrt;
var
t, s, d, e: kokonaisluku;
alkaa
writeln("Kaikki nelinumeroiset luvut eri numeroista");
varten t:= 1 to 9 tehdä
varten s:= 0 to 9 tee jos s<>t sitten
varten d:= 0 to 9 tee jos(d<>s) ja(d<>t) sitten
varten e:= 0 to 9 tehdä
jos(e<>d) ja(e<>s) ja(e<>t)
sitten write((((t*10 + s)*10 + d)*10) + e, " ")
loppu.

Tehtävä 4

1. Lisää ja muuta tämä ohjelma niin, että se näyttää eri nelinumeroisten numeroiden lisäksi myös niiden numeron.

2. Kun eri numeroista koostuva nelinumeroinen luku kerrotaan 9:llä, tulo tuotti luvun, joka erosi kertojasta vain siten, että tuhansien ja sadojen välillä oli nolla. Etsi kertoja. Luo vuokaavio ja ohjelma.

Esimerkki 6. Luonnollisten lukujen a, b, c kolminkertaisia, jotka täyttävät yhtälön: - kutsutaan Pythagoraan luvuiksi.
Esimerkiksi 3, 4 ja 5 ovat Pythagoraan lukuja, koska

Kirjoita ohjelma, joka etsii ja tulostaa kaikki Pythagoraan luvut, jotka eivät ylitä 20:tä.

Tämän kysymyksen takana oleva matematiikka on yksinkertainen. Luvuille a, b ja c mahdolliset arvot ovat luonnollisia lukuja 1-20.
A:n alkuarvo on yksi, a = 1. Käymme läpi kaikki mahdolliset b:n arvot välillä 1 - 20 sekä c:n arvot välillä 1 - 20 ja tarkistamme yhtälön a a + b b = c c . Kun yhtälö on täyttynyt, näytä a, b ja c arvot.
Seuraavaksi sinun on otettava arvo a = 2 ja tarkistettava b:n arvot 2:sta 20:een. Miksi ei 1:stä, vaan 2:sta? Kyllä, koska kahden luvun joukkoa 1 ja 2 on jo tarkasteltu arvoilla a = 1 ja b = 2, jotta a:n ja b:n arvot eivät toistuisi, ts. kahden identtisen numeroparin ilmaantumisen välttämiseksi b:n arvoja tulee alkaa tarkastella tai kunnes arvo a tai alkaen a 20 asti.
Tässä suhteessa on olemassa useita mahdollisia tapoja järjestää silmukoita muuttujille a ja b.
1. tapa:

varten a:= 1 to 20 tehdä
varten b:=a to 20 tehdä

2. menetelmä:

varten a:= 20 alaspäin 1 tehdä
varten b:= 1 to a tehdä

3. menetelmä:

varten a:= 1 to 20 tehdä
varten b:= 1 to a tehdä

On helppo nähdä, että kullakin näistä menetelmistä ei toisteta lukupareja. Tarkista se itse.
C:n arvoille meidän on tarkistettava kaikki luonnolliset luvut 1-20 jokaiselle lukuparille a ja b. Joten c:n silmukan pitäisi olla seuraava: varten c:= 1 to 20 tehdä

Lohkokaavio

Riisi . 41

Ohjelmoida

Ohjelmoida Ongelma6;
käyttää WinCrt;
var
a, b, c: kokonaisluku;
alkaa
writeln("Pythagoraan lukujen kolminkertaiset väliltä ");
varten a:= 1 to 20 tehdä
varten b:= 1 to a tehdä
varten c:= 1 to 20 tehdä
jos a*a + b*b = c*c sitten writeln(a, " ", b, " ", c)
loppu.

1. Luo lohkokaavio ja ohjelma, joka löytää kaikki ratkaisut yhtälöön, jossa n on annettu luku, väliltä .

2. Etsi kaikki luonnolliset x-arvot väliltä, jonka lauseke on luonnollisen luvun neliö.

Esimerkki 7. Kuinka monella tavalla tietty luonnollinen luku n voidaan esittää kahden luonnollisten lukujen kuution summana:

Termien uudelleenjärjestely ei anna uutta menetelmää. Nostotoimintoa tehoon 1/3 ei voi käyttää.

Seuraava yksinkertainen idea ohjelman luomiseksi herää välittömästi.

Järjestä kaksi silmukkaa, joista toinen on ulompi silmukka, jonka muuttuja i on välillä 1 - n, ja toinen on j:n sisäinen silmukka, myös 1 - n.

Ohjelman ydin on seuraava:

i:n ensimmäinen arvo on 1, se kerrotaan kolme kertaa itsellään (tämä korvaa korotuksen 3. potenssiin);
sitten" ovat liikkeessä"kaikki j:n arvot 1:stä n:ään, joista jokainen myös kerrotaan kolme kertaa itsellään ja lisätään arvoon i i, eli i kuutioituna;
Lisäksi tämä summa tarkistetaan, onko se yhtä suuri kuin arvo n, jos yhtälö on tosi, niin ohjelmassa ilmeisesti määriteltyä laskuria suurennetaan 1:llä ja i:n ja j:n arvot voidaan näkyvät näytöllä;
silmukka i:n kautta jatkuu, i saa toisen arvon - 2, ja sisempi silmukka j:n kautta 1:stä n:ään alkaa suorittaa uudelleen ja niin edelleen.
Jos laadimme ohjelman tämän suunnitelman mukaan, sillä on kaksi merkittävää haittaa:
1) tehdään paljon turhaa työtä - molemmat silmukat on järjestetty 1:stä n:ään ja niiden joukossa on monia tarpeettomia (riittää ottaa arvot 1:stä n:n kuutiojuureen);
2) ohjelma tuottaa arvoja, jotka saadaan järjestämällä termit uudelleen, esimerkiksi: 2 2 2 + 3 3 3 = 35 ja 3 3 3 + 2 2 2 = 35, mikä ei ole hyväksyttävää tehtävän ehtojen mukaan . Kuinka poistaa nämä puutteet?
Voimme poistaa ensimmäisen epäkohdan, jos selvitämme ensin, kuinka monta arvoa kullekin luvulle on otettava huomioon, jotta epäyhtälö pysyy voimassa
Voit tehdä tämän järjestämällä silmukan, jolla on ennakkoehto, silmukka " Hei hei ", johon sisällytetään laskuri - k, joka laskee, kuinka monta kertaa tällainen silmukka suoritetaan.

Tämä voidaan tehdä näin:

k: = 0; i: = 1;
sillä aikaa i*i*i + 1<= n tehdä
alkaa
k: = k + 1;
i:= i + 1
loppu;

Nyt voit vähentää merkittävästi jaksojen määrää " aiheita" numerot ja järjestä ne 1:stä k:hen, koska i:n arvoille, jotka ovat suurempia kuin k, pienimmälläkin j:n arvolla (j:= 2) epäyhtälö i i i + 1<=n не выполняется.
Voit poistaa toisen haitan, toisin sanoen, jotta et tuottaisi vaihtoehtoja ehtojen uudelleenjärjestelyllä, seuraavasti:

järjestä ensimmäisen luvun i:n ulompi silmukka arvoon k arvoon 1 ja tee j:n toisen luvun sisempi silmukka 1:stä i:hen. Saat tämän osan ohjelmasta:

p:= 0;
varten i:=k alaspäin 1 tehdä
varten j:= 1 to i tehdä
jos i*i*i + j*j*j = n
sitten
alkaa
p: = p + 1;
loppu;

Katso huolellisesti tätä ohjelman osaa ja mieti, miksi tässä tapauksessa vältämme vaihtoehtojen toistamista ja suljemme pois termien uudelleenjärjestelyt?

Vasen Kaunis lopeta ohjelma. Loppujen lopuksi hyvin usein on tapauksia, joissa lukua ei voida esittää ollenkaan kahden luvun kuutioiden summana. Tämä seikka on myös otettava huomioon.

Tätä varten, kun kaikki silmukat on suoritettu, otamme käyttöön ehdollisen operaattorin, jossa laskurin p arvoista riippuen vastaavat viestit lähetetään.

Jos p = 0, Sitten näyttöön tulee viesti, että numeroa ei voida esittää kahden luvun kuutioiden summana, ja muuten, näyttää viestin eri tavoista.
Tämä ohjelman osa voidaan suorittaa seuraavasti:

jos p = 0
sitten
alkaa

loppu
muu

Lohkokaavio

Riisi . 42

Ohjelmoida

Ohjelmoida Ongelma7;
käyttää WinCrt;
var
i, j, n, k, p: longint;
alkaa
write("Anna luonnollinen luku"); readln(n);
k: = 0; i: = 1;
sillä aikaa i*i*i + 1<= n tehdä
alkaa
k: = k + 1; i:= i + 1
loppu;
p:= 0;
varten i:=k alaspäin 1 tehdä
varten j:= 1 to i tehdä
jos i*i*i + j*j*j=n
sitten
alkaa
p: = p + 1;
writeln(i, "*", i, "*", i, "+", j, "*", j, "*", j, "=", n)
loppu;
jos p = 0
sitten
alkaa
write("Lukua ", n, " ei voi esittää muodossa ");
writeln("kahden luvun kuutioiden summa")
loppu
muu writeln("Tapojen lukumäärä on ", p)
loppu.

Toinen ratkaisu tähän ongelmaan

Ohjelmoida Tehtävä7b;
käyttää WinCrt;
etiketti 1, 2;
var
i, j, m, k, n: longint;
alkaa
write("Anna luonnollinen luku"); readln(n);
m: = 0; i: = 1; j: = 1;
sillä aikaa j*j*j + 1< n tehdä j: = j + 1;
toistaa
k:= i*i*i + j*j*j;
jos k = n sitten m: = m + 1;
jos k<= n sitten i:= i + 1;
jos k >= n sitten j: = j - 1;
siihen asti kun i > j;
jos m = 0 sitten mennään 1;
write("Luku ",n," voidaan esittää summana");
writeln(" kahden luvun kuutiot ",m," tapoja"); goto 2;
1: write("Tätä numeroa ei voi edustaa");
writeln("kahden luvun kuutioiden summa");
2: loppu.

Luonnollinen n on annettu. Voidaanko n esittää kolmen luonnollisten lukujen neliön summana? Jos mahdollista, ilmoita kaikki kolmiot x, y, z sellaiset luonnolliset luvut, että termien uudelleenjärjestäminen ei anna uutta menetelmää. Luo vuokaavio ja ohjelma.

5. Kirjoita Conversion

Esimerkki 8. Kaksinumeroinen desimaaliluku, joka lisätään samoilla numeroilla, mutta käänteisessä järjestyksessä kirjoitettuun numeroon, antaa täydellisen neliön. Etsi kaikki tällaiset numerot.

Olkoon haluttu kaksinumeroinen luku = a 10 + b, sitten samoilla numeroilla, mutta käänteisessä järjestyksessä kirjoitettu luku on = b 10 + a, esimerkiksi 12 ja 21, 13 ja 31 jne.
Näiden lukujen summan pitäisi antaa täydellinen neliö, ts. kokonaislukujen tarkka neliö. Kuinka voin tarkistaa tämän?
Tarkistaminen voidaan tehdä näin: ota tuloksena olevan summan neliöjuuri; sitten pyöristetään tulos kokonaislukuun ja kerrotaan sitten saatu tulos itsellään, jos näiden lukujen summa saadaan jälleen, se tarkoittaa, että se on tarkka tai täydellinen neliö.
Esimerkiksi 12 + 21=33, ota 33:n neliöjuuri, se on 5,74...; pyöreä, se on 6; kerro 6 itsellään ja saa 36.
Emme saaneet alkuperäistä tulosta, mikä tarkoittaa, että summa 33 ei ole tarkka neliö.
Vielä yksi esimerkki, jotta ymmärrät ratkaisun idean. Olkoon kaksinumeroinen luku 29, sitten samoilla numeroilla kirjoitettu luku, mutta käänteisessä järjestyksessä on 92, yhteensä ne antavat 121. Otetaan neliöjuuri luvusta 121 ja saadaan 11. Kertomalla 11 itsestään, saadaan taas 121. Päättelemme, että olemme saaneet tarkan neliön, mikä tarkoittaa, että kaksinumeroinen luku 29 on haluttu.
Jos haluat kirjoittaa ohjelman tällä periaatteella, sinun on otettava summan neliöjuuri, joka voidaan tehdä käyttämällä standardia sqrt(x)-funktiota. Sqrt(x)-funktion tulos on reaaliluku, se on pyöristettävä tai hylättävä, emmekä tiedä miten tämä tehdään.
Mutta vielä tärkeämpää on, että jos kokonaislukujoukon neliöjuuri otetaan kokonaisuudessaan, kuten 121:lle (se on yhtä suuri kuin 11), niin reaalilukujoukossa emme saa tarkasti numeroa 11, mutta tulos on hyvin lähellä 11:tä eikä itsestään kertomisen jälkeen vieläkään saa 121:tä, ts. on tarve muuntaa todellisesta arvosta kokonaisluvuksi.
Joten meillä on kaksi tehtävää: 1) selvittää kuinka pyöristää numeroita ja; 2) selvittää, kuinka reaalityyppi muunnetaan kokonaisluvuksi.

Tätä tarkoitusta varten Pascalissa on vakiofunktiot round(x) ja trunc(x)

Vakio-ominaisuudet pyöristää Ja trunc on tarkoitettu korvaamaan todellisen tyypin arvot kokonaislukutyypin arvoilla.
Toiminto pyöristää(x) pyöristää reaaliluvun x kokonaisluvuksi - sen arvo on lähin kokonaisluku:
pyöristää(4.2) = 4, pyöristää(4.7) = 5, pyöristää(4.5)=5,
pyöristää(-4.2) = -4, pyöristää(-4.7) = -5, pyöristää(-4.5) = -5.
Toiminto trunc(x) hylkää (ilman pyöristystä) reaaliluvun x murto-osan:
trunc(1.2) = 1, trunc(5.8) = 5, trunc(-1.2) = -1,
trunc(-5.8) = -5, trunc(-6.7) = -6, trunc(8,9) = 8

Pyöristysfunktiot liittyvät seuraavasti:
trunc(x + 0,5) = pyöristää(x), Jos x 0,
trunc(x - 0,5) = pyöristää(x), Jos x< 0.
Joten voit käyttää jotakin näistä toiminnoista ohjelmassa. Mikä? Ajattele itse ja kokeile ensin käyttää toimintoa ohjelmassa trunc ja korvaa se sitten pyöristää ja vertailla tuloksia.

Osoita, että nelinumeroinen luku, jossa tuhannet ja kymmenet ovat samat ja sadat ja ykköset ovat myös samat, ei voi olla tarkka neliö.

Kuuden peräkkäisen luonnollisen luvun tulo voi olla yhtä suuri kuin kolmen peräkkäisen luonnollisen luvun tulo. Esimerkiksi 1 2 3 4 5 6 = 8 9 10 = 720. Onko muita tällaisia lukuja?

Todista, että neljän peräkkäisen kokonaisluvun tulo yhteen lisättynä antaa täydellisen neliön.

Etsi 11 peräkkäistä luonnollista lukua, joiden neliöiden summa on kokonaisluvun neliö.

Onko olemassa kokonaislukuja, jotka pienenevät kertoimella 57, kun ensimmäinen (vasen) numero on yliviivattu?

Etsi nelinumeroinen luku tietäen, että se on luonnollisen luvun neliö ja että sen numerot jakautuvat kahteen pariin, jotka koostuvat identtisistä numeroista.

Etsi kaikki seitsennumeroiset luvut, jotka ovat jaollisia 15:llä ja kirjoitettu vain numeroina 0 ja 1.

Kuusinumeroinen luku alkaa numerolla 1. Jos tämä numero siirretään luvun loppuun, uusi numero on kolme kertaa suurempi kuin alkuperäinen. Etsi numero.

Kuinka monta tarkkaa ruutua voidaan tehdä luvuista 3, 4, 5, 6?

Annettu 20 erilaista luonnollista lukua, jotka eivät ole suurempia kuin 50. Etsi niistä kaksi, joiden ero on 4, 5 tai 9.

Kuinka monta kertaa kaksinumeroinen luku kasvaa, jos sama kaksinumeroinen luku lisätään sen oikealle puolelle?

Määritä kolminumeroisen luvun ja tämän luvun numeroiden summan suuruisen suhteen suurin arvo.

Etsi kolminumeroinen luku, joka on 45:n kerrannainen, jos tämän luvun ja samoilla numeroilla, mutta käänteisessä järjestyksessä kirjoitetun luvun välinen ero on 297.

Etsi nelinumeroinen luku, joka on luvun 11 kerrannainen, edellyttäen, että b + c = a on täydellinen neliö.

Etsi kolminumeroinen luku, joka on yhtä suuri kuin kymmeneen numeron, sadan numeron neliön ja yksikkönumeron kuution summa.

Etsi kaksi lukua, joiden tulo on kolminumeroinen luku, joka on tietyn luvun kuutio, ja osamäärä on tämän luvun neliö.

Luvun ja sen numeroiden tulon välinen ero on yhtä suuri kuin kyseisen luvun numeroiden summa. Etsi tämä numero.

Etsi kaikki luvun m arvot, joiden summa on 1! + 2! +, + m! on täydellinen neliö.

Etsi positiivinen nelinumeroinen luku, joka on 7:n kerrannainen ja on tietyn luvun kuution ja neliön summa.

Tietty luku jaettuna 7:llä jättää jäännöksen 3; sen neliö jaettuna luvulla 72 antaa jäännöksen 44; sen kuutio jaettuna 73:lla antaa jäännöksen 111. Etsi tämä luku.

Millä a:n luonnollisella arvolla luku a2 + a + 1589 on täydellinen neliö?
Etsi täydellinen numero muodossa 16p.
Etsi kaksi lukua, jos niiden neliöiden summa on 468 ja niiden yhteisen suurimman jakajan ja pienimmän kerrannaisen summa on 42.