Utasítás hurokhoz algoritmikus struktúrát valósít meg hurok paraméterrel(vagy hurok számlálóval). A for ciklust akkor használjuk, ha a programban a ciklus utasításainak végrehajtása előtt ismertté (vagy előre meghatározottá) válik a ciklus lépéseinek száma. A folyamatábrán a for utasítás a következőképpen jelenik meg:

Szintaxis:

For( inicializálás; állapot; módosítás) ( Loop test utasítások; )

Ha egy utasítás van a ciklustörzsben, akkor ( ) elhagyható. A ciklusparaméter-változó (számláló) bármilyen numerikus lehet. Ez teszi a C++ for ciklust olyan sokoldalúvá, mint a while ciklust. A módosítás részben a postfix vagy az előtag növelése (vagy csökkentése) műveletet használják leggyakrabban, de bármilyen hozzárendelési kifejezés használható, amely megváltoztatja a ciklusparaméter értékét. A hurok így működik:

• Kezdetben megtörténik a számlálóváltozó leírása és inicializálása.
• Ezután ellenőrizze a feltételt: ha a kifejezésnek van értéke igaz, lesz egy iteráció
• A ciklustörzs utasításainak végrehajtása után a számláló értéke módosul

jegyzet: C++-ban szabály, hogy a számláló leírását a ciklusfejlécben kell megadni. De ez nem szükséges, különösen akkor, ha több változó inicializálását tervezi az inicializálási szakaszban a 9.2-es programban végrehajtott módon. A számlálóváltozó deklarációjának használata a hurok fejlécében azonban egy helyi változó deklarációt eredményez, amely automatikusan megsemmisül, amikor a ciklus véget ér. Ezért, hacsak nem feltétlenül szükséges, a for cikluson kívüli számlálóváltozó leírását nem szabad végrehajtani.
Amíg a for ciklus fut, nem ajánlott megváltoztatni az operandusokat a ciklusfejléc-kifejezésekben - ez mindenféle hibához vezet! De a változók (vagy állandók) értékei, beleértve változtatható értékek(számláló), használhatja. Vegyünk egy klasszikus példát.

Program 9.1 Adott egy N természetes szám. Nyomtassa ki ennek a számnak az összes osztóját.

#beleértve << "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

A folytatódik utasítás használata for ciklusban

Ha for ciklusban használja a turpināt utasítást, figyelembe kell venni a ciklus működésének sajátosságait:

• A folytatást követő kijelentések kimaradnak
• Ezután a számláló módosul.
• Továbblépés a következő iterációra (ellenkező esetben a feltétel ellenőrzése)

Mutassuk meg ezt egy példával: 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

jegyzet. Figyelem: bár a feltétel szerinti számok kiadása kimarad, a számláló növekszik. Ez a példa csak illusztráció, nem szabad így programozni a ciklust! Ez a probléma jobban megoldható a következő módon:

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

Több kifejezés az inicializálás és módosítás részben

Amint azt korábban megjegyeztük, a for utasítás fejében három szakasznak kell lennie. Ezekben a szakaszokban a kifejezések elhagyhatók, de a ";" nem hagyható el. . Hiszen csak távozni lehet; . Cím az űrlapon:

Mert (;;) ( ... )

egy „végtelen” hurok fejléce. (A hurokból való kilépést a huroktesten belül kell programozni).
A C++ több kifejezést is támogat a for utasításfejléc inicializálási és módosítási szakaszaiban. Ebben az esetben a ciklus folytatásának feltétele egy legyen!
Például. Feladat: Számítsd ki a 20-nál nem nagyobb szám faktoriálisát!
Program 9.2

#beleértve névtér használata std; int main() ( előjel nélküli hosszú hosszú 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

jegyzet: vegye figyelembe, hogy a 12. sor kimeneti adatfolyama nem a hurok törzsére vonatkozik! (A cím végén - ;). Így ennek a ciklusnak egy üres utasítása van a törzsben, és minden kifejezés kiértékelésre kerül a fejlécben. A 9.2 program helyesen számítja ki a 0 és 20 közötti szám faktoriálisát.

Tartomány alapú hurokhoz

Egy tömb vagy tároló elemei közötti iterációhoz ugyanolyan típusú műveleteket kell végrehajtania, nehézkes kód használata mellett. A konténerekkel való munka egyszerűsítése érdekében C++ nyelven létezik a for ciklus egy speciális formája - tartomány alapú for (loop hatótáv alapján vagy tartomány).
Szintaxis:

For( hirdetés : szekvencia_neve) ciklus_utasítás

Tartomány alapú használata egy C-tömb példáján:
Program 9.3

#beleértve névtér használata std; int main() ( int x ( 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ); for (auto &s: x) ( cout<< s << " "; } return 0; }

Ahhoz, hogy a tömb elemei megváltozzanak, az s változónak referenciaváltozónak kell lennie (mint a fenti példában). Ha a változó nem referencia, akkor az adatok másolásra kerülnek. Az automatikus típuskövetkeztetéshez ebben a ciklusban az automatikus megadót használjuk. A tartomány-alapú for-nak van egy korlátozása a dinamikus tömbökkel való munkavégzéshez: nem támogatja a tömb átméretezését, mivel rögzített tömbvégmutatót tartalmaz. Rögzített méretű tömbök esetén a ranged for nagyszerű és biztonságos alternatívája a szokásos for tömböknek.

Beágyazott hurkok számára

Csakúgy, mint a többi ciklusutasítás, a for támogatja a beágyazott ciklusok szerkezetét. A beágyazott ciklusok használata a kétdimenziós tömbök be- és kimenetének rendszerezésére sokkal kompaktabb, mint a while ciklus használata.
Az ilyen tömbök bejárása során azonban kerülni kell az if utasítás használatát. A feladat gyakran ésszerűbben valósítható meg az indexek (i és j hurokváltozók) manipulálásával. Vagyis az egyik index változását a másik értékétől függővé tenni. Nézzünk két példát.
Program 9.4 Adott egy n méretű négyzetmátrix, melynek elemei egyenlők 0-val. Töltsük fel az alatta és a főátlón lévő elemeket egyesekkel!

#beleértve névtér használata std; int main() ( int n; cout<< "n = "; cin >>n; intmas[n][n]; // Kitöltés nullákkal 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

Program 9.5Írjon programot, amely kitölt egy tömböt a Pascal-háromszög számaival, és adja ki ezt a tömböt. Pascal háromszöge így néz ki:


Ennek a háromszögnek a tetején és az oldalain 1-esek vannak (a 9.5-ös programban a háromszög az oldalára van helyezve – a háromszög oldalai: az első oszlop és a főátló). Mindegyik szám egyenlő a felette lévő két szám összegével. A háromszög egyenesei szimmetrikusak a függőleges tengelyre, és binomiális együtthatókat tartalmaznak.

#beleértve névtér használata std; int main() ( int n; cout<< "n = "; cin >>n; int pass[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

Kérdések

1. Helyettesíthető-e egy for ciklus utasítás egy while ciklus utasítással egy programban? Mindig lehetséges ez?
2. Mikor célszerű a for utasítást használni hurkoláshoz? míg?
3. Lehetségesek-e a következő kifejezések a for utasítás fejlécében: a) for (;a > b && !(a % 2);) b) for (a > b;;) c) for (;;i = 0) d) ha ( ;i = 0;) e) ha (;;i++, --b) f) ha (--i;;) g) ha (b = 0; b != a;) ?
4. Az i változó a külső ciklus paramétere, a j pedig a beágyazott ciklus paramétere. A j változó elérhető lesz a külső ciklusban? beágyazott hurokban vagyok?

Tankönyv

Házi feladat

1. Hátulsó 29. Írjon programot, amely természetes számokat ír be! aés b, és a kijelzőn megjelenik az összes prímszám a tól kezdődően a előtt b(algoritmusötlet Program 8.5)
2. Hátulsó 30. Tökéletes szám az a szám, amely megegyezik az összes, önmagánál kisebb osztójának összegével (például a 6 = 1 + 2 + 3). Írjon programot, amely felvesz egy N természetes számot, és meghatározza, hogy N tökéletes-e.
3. Írjon programot, amely egy n x n négyzet alakú numerikus táblázatot jelenít meg, amely így néz ki n = 10 esetén: 1 * * * * * * * * * * * 2 * * * * * * * * * * * 3 * * * * * * * * * * 4 5 5 * * * * * * * * * * 9 * * * * * * * * * * * 10

Irodalom

1. Laforet R. Objektum-orientált programozás C++ nyelven (4. kiadás). Péter: 2004
2. Prata, István. C++ programozási nyelv. Előadások és gyakorlatok, 6. kiad.: Per. angolról. - M.: I.D. Vilmos, 2012
3. Lippman B. Stanley, Josy Lajoye, Barbara E. Moo. C++ programozási nyelv. Alaptanfolyam. Szerk. 5. M: LLC „I. D. Williams”, 2014
4. Elline A. C++. Lamertől programozóig. Szentpétervár: Péter, 2015
5. Schildt G. C++: Alaptanfolyam, 3. kiadás. M.: Williams, 2010

Sziasztok kedves olvasók! Itt jutunk el a ciklusok tanulmányozásához. Ciklusok Pascalban. Ami? Hogyan kell használni? Mire kellenek? Ezekre a kérdésekre fogok ma válaszolni.
Ha elolvasta, akkor tudja, hogy háromféle algoritmus létezik: lineáris, elágazó és ciklikus. Már ismerjük az algoritmusok Pascalban való megvalósítását. Kezdjük az utolsó típusú algoritmusok tanulmányozásával.
A Pascalban, mint a legtöbb programozási nyelvben, háromféle hurkolt konstrukció létezik.

Minden ciklus egy törzsből és egy fejlécből áll. A ciklustörzs ismétlődő utasítások halmaza, a feltétel pedig egy logikai kifejezés, attól függően, hogy a ciklus eredményétől függően megismétlődik.

Vegyünk egy problémát, amelyet különféle típusú ciklusok segítségével fogunk megoldani.

1. feladat. Az összes szám megjelenítése 1-től a billentyűzetről beírt számig.

While, vagy egy hurok előfeltétellel

Amint valószínűleg már a névből is értetted, míg egy hurok, amelyben a feltétel a test elé kerül. Ezenkívül a huroktest akkor és csak akkor kerül végrehajtásra, ha a feltétel igaz; amint az állapot válik hamis

Míg a formátuma:

míg < условие> csináld<оператор 1>; (Viszlát… csináld…)

Ez a ciklus csak egy utasításra alkalmas, ha több utasítást akarunk használni a kódban, akkor ezeket zárójelbe kell tenni - kezdődikés vége;.

A probléma megoldása.

Program example_while; var i, N: egész szám; (változók deklarálása) begin i:= 1; ( Állítsa i-re 1 ) readln(N); (Olvassa el az utolsó számot), miközben i<= N do {Как только i станет больше N, цикл прекратится (можно было бы написать просто <, но пришлось бы добавлять 1 к N) } begin {Открываем операторные скобки} write(i, " "); {Выводим i} Inc(i); {увеличиваем i на один.} end; { закрываем скобки } end.

Ismétlés, vagy egy ciklus utófeltétellel

Ismétlés- teljes ellenkezője míg. Ismétlés egy hurok, amelyben az állapot a test után van. Sőt, akkor és csak akkor kerül végrehajtásra, ha a feltétel eredménye hamis;amint a logikai kifejezés válik igaz, a hurok véget ér.

Az ismétlés formátuma:

ismétlés(ismétlés…)
<оператор 1>;
< оператор 2>;
…
amíg(előtt…) <условие>

Kezdődikés vége nem szükséges.

A probléma megoldása.

Program example_repeat; var i, N: integer;( változók deklarálása) begin i:= 1; ( Állítsa i-re 1 ) readln(N); ( Utolsó szám olvasása ) ismétlés (az ismétlés után nincs szükség kezdetre és végre ) write(i, " "); (I. kijelző) Inc(i); (Növelje az i-t eggyel.) addig, amíg i = N + 1; (Például i = 11 és N = 10. A ciklus leáll, így a feltétel igaz lesz.) vége.

For, vagy egy ciklus paraméterrel

Mert egy ciklus, amelyben a testet adott számú alkalommal végrehajtják.

Kétféleképpen írhatjuk ezt a ciklust:

Első forma

számára<счетчик1> := <значение1>nak nek<конечное_значение>csináld<оператор1>;

<счетчик1>1-el fog növekedni.

<значение1>a számláló kezdeti értéke. Ez lehet egy változó vagy egy szám.
<конечное_значение>: amint az érték<счетчик1>több lesz<конечное_значение>

Ha több utasítást szeretne írni a ciklustörzsbe, használja kezdődikés vége.

És<счетчик1>, és<конечное_значение>, és<значение1>- változók az egész típus.

Leggyakrabban az i változót használják számlálóként.

Második forma

számára<счетчик2> := <значение2>le<конечное_значение>csináld<оператор1>;

Minden iteráció után az érték<счетчик2>1-el csökken.

<значение2>a számláló kezdeti értéke.
<конечное_значение>: amint az érték<счетчик2>kevesebb lesz<конечное_значение>, a hurok véget ér.

Két fontos megjegyzés:

1. A ciklus addig ismétlődik, amíg a számláló értéke a [érték; vég_érték].
2. Módosítsa a testen belüli számláló értékét ez tiltott! Íme, amit a fordító ad ki:

A probléma megoldása:

Program example_for; var i, N: egész szám; olvasás megkezdése(N); (tegyük fel, hogy 10-et írtunk be) for i:= 1 to N do write(i, " "); (az iterációk száma - 10 - 1 + 1 = 10) vége.

Egyetértek, ez a kód egyszerűbb és tömörebb, mint az összes előző. És kerékpározni számára- nem egészen hétköznapi ciklus, nincs benne logikai feltétel. Ezért a programozásban egy paraméterrel rendelkező ciklust szintaktikai cukornak nevezünk. A szintaktikus cukor a programozási nyelv szintaxisának kiegészítése, amely nem ad új funkciókat, de emberbarátabbá teszi a nyelv használatát.

Oldjunk meg egy-két problémát.

For1. A K és N egész számok (N > 0) adottak. Kimenet N-szer a K számmal.

Egy egyszerű ciklust szervezünk 1-től a kívánt számig.

Program for1; var K, N, i: egész szám; kezdi olvasni(K, N); for i:= 1 to N do write(K, " "); (K-t szóközzel elválasztva írunk) vége.

For2. < B). Вывести в порядке возрастания все целые числа, расположенные между A и B (включая сами числа A и B), а также количество N этих чисел.

Mivel A< B, то цикл должен будет выводить все числа от А до B. Чтобы сосчитать количество чисел, используем формулу: <конечное_значение> — <начальное_значение> + 1.

Program for2; var A, B, i, count: integer; beolvasás megkezdése(A, B); for i:= A-tól B-ig ír(i, " "); (írja a számokat a legkisebbtől a legnagyobbig) count:= B - A + 1; (számok száma) writeln; write("Számok száma - ", count); vége.

For9. Adott két A és B egész szám (A< B). Найти сумму квадратов всех целых чисел от A до B включительно.

Ugyanazt a ciklust szervezzük, mint az előző feladatban, de egyben összegezzük az összes szám négyzetét. A négyzet kiszámításához használja a függvényt.

Program for9; var A, B, i, S: egész szám; beolvasás megkezdése(A, B); S: = 0; (A PascalABC ezt automatikusan megteszi, de ha más fordítója van, javasoljuk, hogy a változókat kézzel állítsa nullára) for i:= A-tól B-ig do S:= S + Sqr(i); (összes négyzet hozzáadása) writeln; write("Négyzetösszeg - ", S); vége.

13°-ra. Adott egy N egész szám (> 0). Keresse meg az 1,1 - 1,2 + 1,3 - ... kifejezés értékét (N tag, előjel váltakozik). Ne használja a feltételes operátort.

Az előjel megváltoztatása érdekében a ciklus minden iterációjában a speciális változó értékét az ellenkezőjére változtatjuk.

Program for13; var N, A, i: egész szám; S: igazi begin Write("N = "); readln(N); S: = 1,1; A:= 1; (Először pozitív) i:= 2-től N do-ig (a ciklus első iterációját már elvégeztük, tehát 2-től kezdjük a számolást) kezdjük A:= -A; (Most negatív) S:= S + A * (1 + i / 10); (hozzáadás) vége; WriteIn(S:5:1); (Adjunk egy ismerőst a tört részhez) vége.

Míg1°. Az A és B (A > B) pozitív számok adottak. Az A hosszúságú szakaszon a lehető legtöbb B hosszúságú szakasz (átfedések nélkül) kerül elhelyezésre. A szorzás és osztás használata nélkül keresse meg az A szegmens nem foglalt részének hosszát.

Minden alkalommal vonjuk ki B-t A-ból addig, amíg A - B >= 0.

Program while1; var A, B: egész szám; start readln(A, B); míg (A - B) >= 0 do A:= A - B; (Amíg a különbség pozitív, kivonjuk. Olyan változatot kell megadni, amelynek A és B többszöröse, ezért >=) write(A); vége.

Míg 4°.Adott egy N egész szám (> 0). Ha ez 3 hatványa, akkor igaz, ha nem, akkor hamis.

A következőképpen járunk el: míg N osztható 3-mal, addig N osztható 3-mal. Ekkor, ha N = 1, akkor a szám három hatványa; ha N<>1, akkor a szám nem három hatványa. A probléma megoldásához tudnia kell, mik azok, és hogyan működnek.

Program while4; var N: egész szám; start readln(N); míg N mod 3 = 0 do N:= N div 3; (Amíg a hárommal való osztás maradéka nulla, osszuk el N-t 3-mal) writeln(N = 1); (logikai kifejezés) vége.

Ez minden mára! Ne felejtse el gyakrabban felkeresni oldalunkat, és kattintson a megjegyzések előtt található gombokra.

A paraméteres ciklussal már foglalkoztunk az "Algoritmusok típusai" témakör "Algoritmus" rovatában.
Paraméteres hurkot használnak,amikor előre ismert, hogy a ciklust hányszor kell végrehajtani.

Ciklusfelvételi formátum:

Itt érte, tenni, tenni- fenntartott szavak (for, before, perform);

<пар. цикла> - ciklus paraméter - változó egész szám típus (egész típus);
<нач. знач.> - kezdeti érték - szám vagy változóegész szám típus (egész típus);
<кон. знач.> - végérték - szám illváltozóegész szám típus (egész típus);
<оператор> egy tetszőleges Pascal operátor.

Példa: Az i:=1-től n-ig tegye<оператор>
itt az i a ciklusparaméter
1 - kezdeti érték
n - végső érték
Ha több operátort használunk a huroktörzsben, akkor operátori zárójeleket használunk: begin ... end.
A for utasítás végrehajtásakor először a kifejezés kerül kiértékelésre<нач.знач.>és annak értékét hozzárendeljük a hurokváltozóhoz<пар.цикла> := <нач. знач.>. Következő összehasonlítás történik<пар.цикла>és <кон.знач.>. Amíg egyenlővé nem válnak, az utasítás(ok) végrehajtásra kerülnek. Hurokváltozó értéke<нач.знач>automatikusan eggyel növekszik a ciklus során.Azonnal meg kell jegyezni, hogy ebben az operátorban nem lehet 1-től eltérő cikluslépést beállítani.
Példa:
A következő ciklusutasítások lehetségesek:

1) i esetén:= 1-től n-ig s1;

2) i esetén:= 3-10 do s1;

3) i esetén:= a-tól b-ig s1;

4) az i:= a-tól b-ig do
kezdődik

s1;
s2;
...
sn

vége;

Itt s1, s2, s3, ... sn hurokoperátorok.

Példa:
Írjon programot, amely 1 és 10 közötti számokat jelenít meg.

Példa:
Írjon programot egy n, azaz n! szám faktoriálisának kiszámítására! (0!=1)

Program magyarázata:
Az n változó a felhasználó által beírt számra vonatkozik, amelynek faktoriálisát kell megtalálni; f - egy változó, amelyben az n szám faktoriálisának értéke "felhalmozódik"; i - hurokváltozó.
Az f:= 1 változó kezdeti értéke be van állítva.
Ezután kezdődik a ciklus. Az i változó 1-re van inicializálva; összehasonlítjuk a végső - n (1<= n), если условие истинно, тогда выполняется оператор (в этой программе он один): f:= f*i, 1*1=1; значение переменной цикла увеличивается на 1, т. е. станет равным: i:= i + 1, 1 + 1 = 2 и цикл повторяется.
Amikor i értéke egyenlő lesz n-nel, akkor a ciklus utoljára fut le, mert i következő értéke n + 1 lesz, ami nagyobb, mint n végső értéke, az i feltétel<= n - ложно, цикл не выполняется.

A For ciklus utasításnak van egy másik formája is:
Ciklusfelvételi formátum:

A lefoglalt szó le cseréje downto-ra azt jelenti, hogy a ciklusparaméter lépése (-1).
A paraméterérték változása nagyobb értékről kisebbre megy, pl.<нач. знач.> <кон. знач.>.

Példa:
A következő ciklusutasítások lehetségesek:

1) i esetén:= n 1-től s1-ig;

2) i:= 10-től 3-ig s1-ig;

3) i:= b esetén a do s1-ig; (feltételezve, hogy b>a)

4) for i:= b downto a do
kezdődik

S1;
s2;
...
sn

vége; (feltételezve, hogy b>a)

Itt s1, s2, s3, ... sn hurokoperátorok.

Példa: Számoló program faktoriális számok állíthatók össze ezzel a ciklusutasítással.

Feladatok

1. Adott 10 szám, nyomtassa ki azokat, amelyek tökéletes négyzetek.
2. Adott 10 szám, keresse meg termékét.Készítsen blokkdiagramot és programot.
3. Adott 10 szám, keresse meg a páros számok összegét!Készítsen blokkdiagramot és programot.
4. Adott 10 szám, keresse meg a negatívak számát.Készítsen blokkdiagramot és programot.
5. Adott n valós szám. Keresse meg a maximumot és a minimumot.Készítsen blokkdiagramot és programot.
6. Adott n valós szám. Keresse meg az összes elem számtani átlagát!Készítsen blokkdiagramot és programot.
7. Adott n valós szám. Keresse meg a negatív és pozitív elemek számtani középértékét!Készítsen blokkdiagramot és programot.
8. Adott n természetes szám. Határozzuk meg azoknak az elemeknek az összegét és szorzatát, amelyek 3 és 5 többszörösei.Készítsen blokkdiagramot és programot.
9. Adott n természetes szám. Visszavonás azok a számok, amelyek értéke kettő hatványa (1, 2, 4, 8, 16, ...).Készítsen blokkdiagramot és programot.
10. Adott n természetes szám. Visszavonás azokat a számokat, amelyek értéke a szegmensben van.Készítsen blokkdiagramot és programot.
11. Adott n természetes szám. Jelenítse meg azokat a számokat, amelyek értéke valamely szám négyzete.Készítsen blokkdiagramot és programot.
12. Adott egy n természetes szám. Keresse meg az n 2-t.Készítsen blokkdiagramot és programot.
13. Adott a, n természetes számok. Keressen egy n.Készítsen blokkdiagramot és programot.
14. Adott egy n természetes szám. Határozza meg a kapacitását, növelje a szám legjelentősebb számjegyét 2-vel
15. Adott egy n természetes szám. Cserélje fel egy szám első és utolsó számjegyét
16. Adott egy n természetes szám. A 2 többszörösei számjegyeit 0-ra cseréljük.
17. Adott egy n természetes szám. A 3-nak többszörösei számjegyeit 1-gyel helyettesítjük.
18. Adott egy n természetes szám. Számítsa ki a (2n-1)*(3n-1)*(4n-1)*...*(10n-1) szorzatot!Készítsen blokkdiagramot és programot.
19. Számítsa ki a 2+4+6+...+100 összeget!Készítsen blokkdiagramot és programot.
20. Adott egy n természetes szám, valós x. Számítsa ki az x+x/2+x/3+...+x/n szorzatot!Készítsen blokkdiagramot és programot.
21. Adott egy n természetes szám. Számítsuk ki P=(1-1/2)(1-1/3)...(1-1/n), ahol n>2.Készítsen blokkdiagramot és programot.
22. Adott egy n természetes szám. Számítsuk ki P=(1+x)/n+(2+x)/(n-1)+...+(n+x)/1.Készítsen blokkdiagramot és programot.
23. Adott n természetes szám. Számítsa ki egy sorozat összegét1+x/1!+x 2/2!+x 3/3!+ ...+x n/n!. Készítsen blokkdiagramot és programot.

A paraméteres hurokoperátort pontosan olyan esetekben használják, amikor adott számú ismétlésszámú hurkot kell szervezni

számára <параметр_цикла>:=<начальное_знач> nak nek <конечное_знач> csináld <оператор>;

számára <параметр_цикла>:=<конечное_знач> le <начальное_зна.> csináld <оператор>;

Az utasítás, amely a ciklus törzse, lehet egyszerű vagy összetett.

A ciklusparaméter, valamint változási tartománya csak egész vagy felsorolt ​​típusú lehet.

A paraméter leírása más változókkal együtt történik.

A for ciklus lépése mindig állandó, és egyenlő "1" vagy "-1" értékkel.

Jelenítse meg az első tíz pozitív egész számot

var i: integer; //számláló be van írva

fori:=1to10do//míg a számláló értéke 1 és 10 között van, tegye a következőket

writeln(i); //kimeneti számláló értéke

vari,sum:integer;

összeg:=0; //a változó értékének nullázása

fori:=10-99do//kétjegyű pozitív számok felsorolása

ha i mod 3=0, akkor //multiplicity 3

összeg:=összeg+i; //a változó előző értékének és a feltételnek megfelelő számnak az összege

Jelenítse meg az első tíz pozitív páros szám szorzatát

vari,pr:integer;

pr:=1; //a szorzat megtalálásakor a változó kezdeti értéke nem 0, hanem 1

i:=1-től 10-ig tegye

ha i mod 2=0, akkor //határozzuk meg a paritást

Adott két A és B egész szám (A< B). Вывести в порядке возрастания все целые числа, расположенные между A и B (в том числе A и B), a также количество N этих чисел .

var i,pr: integer;

k:=0; //nulla a változó értékét, ami a számot jelenti

fori:=AtoBdo//számok felsorolása az adott tartományból

writeln(i); //kimenet növekvő sorrendben

k:=k+1; // a számok számának megszámlálása

writeln(k); //az összeg kimenete a cikluson kívül történik, mert egyszer kiadták

Írjon be N különböző számot. Keresse meg az összes szám számtani középértékét!

Varn,i,a:integer;

Az i:=1-től N-ig tegye

Writeln("számtani átlag= ",s/n:4:2);

Loop utasítás with while ... Do előfeltétel

A while ... do utasítás előfeltételes ciklusok megvalósítására szolgál.

A while ciklus törzsének állapotát minden lépés megkezdése előtt ellenőrizzük. Ezért, ha a feltétel nem teljesül azonnal, akkor a huroktestet figyelmen kívül hagyja, és a vezérlés közvetlenül a huroktestet követő operátorhoz kerül.

Kapcsolatfelvétel az üzemeltetővelmíg ... csinál fordítása "viszlát... tenni" és így néz ki:

míg <условие> csináld <оператор>

A while ciklus a következő algoritmust jelenti: amíg a feltétel igaz, a ciklustörzs utasításai végrehajtásra kerülnek.

Maga a feltétel lehet logikai konstans, változó vagy logikai kifejezés.

Tartsa szem előtt a következőket, amikor előfeltételes ciklusokat ír.

ahhoz, hogy egy hurok valaha is véget érjen, a test tartalmának szükségszerűen befolyásolnia kell a hurok állapotát.

a feltételnek a ciklustörzs első végrehajtása előtt meghatározott érvényes kifejezésekből és értékekből kell állnia.

Ha a hurok feltétele hamis, a ciklus soha nem fog végrehajtani!

A legtöbb programban szükség van valamilyen utasítás (vagy utasításblokk) ismételt végrehajtására. A hurokutasítások felhasználhatók az ilyen konstrukciók szervezésére. A Pascal programozási nyelv a következő típusú ciklusutasításokat használja: for, while, repeat (A PascalABC.NET a foreach ciklus operátort is használja).

Az ismétlődően végrehajtandó utasításblokkot huroktörzsnek nevezzük.

Pascal nyelvű kijelentéshez

Ha egy testismétlések száma ciklus előre ismert, akkor azt használják ciklusutasításhoz, amelyet gyakran paraméteres ciklusutasításnak is neveznek.

A for utasítás két részből áll: a huroktörzsből és a fejlécből, amely a ciklusparaméter kezdeti és végső értékét írja le, valamint a módosítási lehetőségből.

A ciklusparaméter változási irányától függően (növekedés - to vagy csökkentés - le) Pascalban, a for ciklus operátor kétféle formában írható:

• a := start_value és end_value paraméterhez do
• operátor;

• a := start_value paraméternél lefelé a végértékig do
• operátor;

A ciklusparaméter-változó bármilyen sorszámú lehet. Ebben az esetben a kezdeti és a végső értékeknek olyan típussal kell rendelkezniük, amely kompatibilis a paraméterváltozó típusával.

Tekintsük a for ciklus munkáját.

A ciklusutasítás kezdete előtt a paraméterváltozóhoz rendelt kezdőérték és a végső érték kiszámítása történik. Ezután a következő műveleteket hajtják végre ciklikusan:

1. Összehasonlítja a paraméter aktuális értékét a végső értékkel.
2. Ha az end_value feltétel paraméter igaz, akkor a ciklustörzs végrehajtásra kerül, ellenkező esetben a for utasítás véget ér, és a vezérlés átkerül a ciklust követő utasításra.

Figyelem: Pascal nyelvben a ciklusparaméter, függetlenül a növekedéstől vagy a csökkentéstől, minden alkalommal eggyel változik.

Egy feladat. Jelenítse meg a 10 és 1 közötti egész számok négyzeteinek listáját.

Megoldás. A feltett probléma esetén a ciklusparaméter csökken.

(Program kódrészlet)

• i:= 10-től 1 do-ig
• writeln(i:2, " ", i * i);

Figyelem: ha egynél több utasítást kell használni a ciklus törzsében, akkor összetett utasítást használunk (a zárójelek kezdete és vége ).

2. példa Egy jelentkező négy vizsgán elért érdemjegyei ismertek. Határozza meg a szerzett pontok mennyiségét.

Egy feladat. A jelentkező négy vizsgán elért pontszáma ismert. Határozza meg a szerzett pontok mennyiségét.

Megoldás. A programban paraméterekkel rendelkező hurokoperátort fogunk használni, mivel a végrehajtott műveletek ismétlődéseinek száma ismert (a pályázó pontosan négy pontot kapott)

(Program kódrészlet)

• s:= 0;
• i:= 1-től 4-ig csináld
• kezdődik
• readln(jel);
• s:= s + jel;
• írás(ok);