Cicluri. Algoritmi ciclici. Bucle cu precondiție și postcondiție Se execută operatorul de bucle cu precondiție

Un proces de calcul ciclic (CMP) se caracterizează prin repetarea acelorași calcule pe un anumit set de date. Numărul de repetări ale unei bucle este controlat de o variabilă specială numită tejghea sau variabila de control ciclu. Se impune o condiție pe contor care determină cât timp ar trebui executată bucla.

Se numește blocul de calcul repetabil corp ciclu. Corpul buclei trebuie să furnizeze modificați valoarea contorului astfel încât să se poată completa. Dacă corpul buclei constă din mai multe declarații, ea este inclus în paranteze operatorîncepe ... sfârșit;. Executarea corpului buclei a fost numită odată Etapa.

Astfel, pentru a programa o buclă, este suficient să definiți o condiție care controlează numărul de repetări și să descrieți operatorii care formează corpul buclei. Din acest punct de vedere, teoretic sunt posibile doar două tipuri de bucle - verificarea stării fie precedă executarea corpului buclei, fie are loc după aceasta. Să prezentăm aceste cicluri sub formă de diagrame bloc cu descrierile corespunzătoare:

Buclă cu condiție prealabilă: condiția este verificată mai întâi, apoi, în funcție de faptul că este adevărată sau falsă, fie corpul buclei este executat, fie urmează trecerea la declarația care urmează corpului buclei. După sfârșitul corpului buclei, controlul este din nou transferat pentru a verifica starea. Bineînțeles, se presupune că unele modificări ale variabilelor incluse în condiție au fost furnizate în corpul buclei - în caz contrar, buclare iar programul va îngheța.

Buclă cu postcondiție: mai întâi, corpul buclei este executat, apoi controlul este trecut pentru a verifica starea. În funcție de adevărul sau falsitatea stării, corpul buclei este executat din nou sau are loc o tranziție la operator în urma corpului buclei. Tot ceea ce s-a spus despre posibila buclare pentru o buclă cu o condiție prealabilă este valabil și pentru o buclă cu o postcondiție.

Pe baza diagramelor bloc date, diferența principală dintre cele două bucle este evidentă: o buclă cu o postcondiție este garantată a fi executată cel puțin o dată, iar o buclă cu o condiție prealabilă nu poate fi executată nici măcar o dată dacă condiția este imediat falsă.

Ambele tipuri de bucle sunt implementate în Pascal. O buclă cu o condiție prealabilă are următoarea formă generală:

în timp ce expresia_booleană începe

(operatori corp buclă)

Activitatea ciclului poate fi descrisă în cuvintele: " atâta timp cât expresia booleană este adevărată, corpul buclei se repetă".

O expresie logică este construită conform regulilor studiate în Capitolul 7. Orice operator Pascal poate forma un corp de buclă. Dacă există un singur operator în corpul buclei, parantezele operatorului pot fi omise.

Înregistrarea generală a unei bucle cu postcondiție este după cum urmează:

(operatori corp buclă)

până la expresia_booleană;

Bucla cu postcondiție funcționează după cum urmează: " corpul buclei se repetă până când expresia booleană devine adevărată Rețineți că, spre deosebire de while, bucla de repetare a lui Pascal rulează atâta timp cât fals... Această diferență este accentuată de utilizarea cuvântului cheie until ("atâta timp cât nu") în loc de while (" atâta timp cât "). De asemenea, ca excepție, corpul buclei de repetare, chiar dacă este format din mai multe nuîncadrați între paranteze.

Buclele sunt adesea folosite interschimbabil. Imaginați-vă, de exemplu, că pentru fiecare dintre valorile variabilei x = 1,2, ..., 20, trebuie să efectuați unele calcule (matematic, această lege a schimbării x poate fi scrisă ca
sau
). Să arătăm vizualizarea generală a timpului și repetăm buclele:

în timp ce x<=20 do begin

(operatori de calcul)

După cum puteți vedea din listare, variabilei de control x în ambele cazuri i se atribuie valoarea inițială 1, ambele bucle modifică valoarea lui x și, în consecință, starea buclei, cu operatorul x: = x + 1;, dar pentru bucla repetată starea este „inversată” („până când x devine mai mare de 20”), iar corpul nu este închis între paranteze operator.

Deseori, folosirea uneia dintre bucle pare preferabilă. De exemplu, gestionarea intrărilor utilizatorului de la tastatură este mai convenabilă cu repetarea (mai întâi utilizatorul trebuie să apese o tastă, urmată de validare și procesare).

De asemenea, o buclă poate fi numită orice secvență de instrucțiuni care poate fi executată în mod repetat, organizată în orice mod. Definiții O secvență de instrucțiuni destinate executării repetate se numește corpul buclei. O singură execuție a unui corp de buclă se numește iterație. Expresia definitorie va itera din nou sau bucla se va termina se numește o condiție de ieșire sau o condiție de terminare a buclei sau o condiție de continuare, în funcție de modul în care adevărul său este interpretat ca un semn al necesității ...

Distribuiți munca dvs. pe rețelele sociale

Dacă această lucrare nu vi s-a potrivit în partea de jos a paginii, există o listă de lucrări similare. De asemenea, puteți utiliza butonul de căutare

Ciclu - un fel de structură de control înlimbaje de programare la nivel înalt, destinat organizării executării multiple a setului instrucțiuni ... De asemenea, o buclă poate fi numită orice secvență de instrucțiuni executate în mod repetat, organizate în orice mod.

Definiții

Se apelează o secvență de instrucțiuni concepute pentru a fi executate în mod repetat corpul ciclului ... Se numește o singură execuție a corpului buclei repetare. Expresie se determină dacă iterația va fi executată din nou sau bucla se va încheia stare de ieșire sau condiția pentru sfârșitul ciclului(sau condiție de continuareîn funcție de modul în care adevărul său este interpretat - ca un semn al necesității de a finaliza sau continua ciclul). Variabil se apelează stocarea numărului curent de iterațiecontor de iterațiiciclu sau doar contor ciclu ... Bucla nu conține neapărat un contor, contorul nu trebuie să fie unul - condiția pentru ieșirea din buclă poate depinde de mai multe variabile modificate în buclă sau poate fi determinată de condiții externe (de exemplu, debutul unui anumit timp), în acest din urmă caz, contorul poate să nu fie deloc necesar.

Executarea oricărei bucle include inițializarea inițială a variabilelor buclei, verificarea condiției de ieșire, executarea corpului buclei și actualizarea variabilei buclei la fiecare iterație. În plus, majoritatea limbajelor de programare oferă mijloace pentru controlul timpuriu al buclei, de exemplu, operatorii pentru a termina bucla, adică pentru a ieși din buclă indiferent dacă condiția de ieșire este adevărată.

Buclă cu condiție prealabilă

O buclă cu o precondiție este o buclă care se execută atâta timp cât unele condiții specificate înainte de începerea ei sunt adevărate. Această condiție este verificată inainte de executarea corpului buclei, deci corpul nu poate fi executat nici măcar o dată (dacă condiția este falsă încă de la început). În majoritatea limbajelor de programare procedurale, acesta este implementat de operator in timp ce , de aici și al doilea nume - while-loop. În Pascal, o buclă precondiționată arată astfel:

in timp ce<условие>do

începe

<тело цикла>

Sfârșit;

Buclă cu postcondiție

Buclă cu postcondiție - o buclă în care este verificată starea după executarea corpului buclei. Rezultă că corpulîntotdeauna executatcel puțin o dată. În Pascal, această buclă implementează operator repeta..pana; în C, faceți ... în timp ce.
În Pascal, o buclă de postcondiție arată astfel:

repeta

<тело цикла>

pana cand <условие выхода>

Buclă cu ieșire din mijloc

O buclă din mijloc este cea mai comună formă de buclă condițională. Din punct de vedere sintactic, o astfel de buclă este formatată folosind trei constructe: începutul buclei, sfârșitul buclei și comanda de ieșire din buclă. Construcția inițială marchează punctul din program în care începe corpul buclei, iar construcția finală marchează punctul în care se termină corpul. În interiorul corpului, trebuie să existe o comandă pentru a ieși din buclă, atunci când este executată, bucla se termină și controlul este transferat la instrucțiunea de după sfârșitul construcției buclei. Bineînțeles, pentru ca bucla să fie executată de mai multe ori, comanda de ieșire nu trebuie apelată necondiționat, ci numai atunci când este îndeplinită condiția de ieșire a buclei.

de fapt asta este pauză;

Ciclează cu contor

Un ciclu cu contor este un ciclu în care unii variabil își schimbă valoarea de la valoarea inițială dată la valoarea finală cu un anumit pas, iar pentru fiecare valoare a acestei variabile corpul buclei este executat o singură dată. În majoritatea limbajelor de programare procedurale, acesta este implementat de operator pentru , care indică contorul (așa-numita "variabilă de ciclu"), numărul necesar de treceri (sau valoarea limită a contorului) și, eventual, pasul cu care contorul se schimbă.

pentru i: = de la 0 la 9

începe

Corpul buclei

Sfârșit;

Ieșirea timpurie din ciclu

O comandă de ieșire timpurie este utilizată atunci când este necesară întreruperea executării unui ciclu în care condiția de ieșire nu a fost încă atinsă. Acest lucru se întâmplă, de exemplu, atunci când este detectată o eroare în timpul execuției corpului buclei, după care lucrarea ulterioară a buclei este lipsită de sens.

Comanda de ieșire timpurie este de obicei apelată EXIT sau pauză , iar acțiunea sa este similară acțiunii comenzii de salt necondiționat ( mergi la ) la comanda imediat după bucla în care se află această comandă.

Bucle imbricate

Este posibilă organizarea unei bucle în interiorul corpului unei alte bucle. Un astfel de ciclu va fi numitbucla imbricata... Ciclul imbricat în raport cu ciclul din corpul căruia este imbricat va fi denumitbucla interioarași invers, se va numi ciclul din corpul căruia există ciclul imbricat extern în raport cu cuibăritul. În interiorul buclei imbricate, încă o buclă poate fi imbricată pe rând, formând următoarelenivelul de cuibăritetc. Numărul nivelurilor de cuibărire, de regulă, nu este limitat.

Numărul total de execuții ale corpului buclei interioare nu depășește produsul numărului de iterații ale buclelor interioare și exterioare. De exemplu, luând trei bucle imbricate, fiecare cu 10 iterații, obținem 10 execuții ale corpului pentru bucla exterioară, 100 pentru bucla de al doilea nivel și 1000 în bucla cea mai interioară.

Alte lucrări similare care vă pot interesa
2740.		Algoritmi ciclici. Buclă cu condiție prealabilă	16,37 KB
	Să facem cunoștință cu primul dintre ei - operatorul buclă cu condiția de timp. Buclele cu o condiție prealabilă sunt utilizate atunci când execuția buclei este asociată cu o anumită condiție logică. O instrucțiune de buclă cu o precondiție are două părți: condiția de execuție a buclei și corpul buclei. Forma generală de notație este următoarea, în timp ce starea începe sfârșitul corpului buclei; În rusă sună cam așa: în timp ce această condiție este îndeplinită, faceți un grup de operatori de la început până la sfârșit; Este destul de înțeles că parantezele operatorului sunt utilizate pentru a se separa de restul programului care ...
7903.		Ciclul de producție	39,35 KB
	Perioada de lucru constă în timpul pentru efectuarea operațiunilor tehnologice și non-tehnologice; acestea din urmă includ toate operațiunile de control și transport din momentul finalizării primei operațiuni de producție și până la livrarea produsului finit. Cu un tip secvențial de mișcare, o comandă de producție - o piesă sau o mașină asamblată sau un lot de piese 1 serie de mașini 2 - în procesul de producție a acestora trece la fiecare operație ulterioară a procesului numai după terminarea procesării asamblării tuturor piese de mașini ale acestui lot ...
7548.		Ciclul de viață al EIS	34,12 KB
	Ciclul de viață al EIS Nevoia de a crea un EIS poate fi determinată fie de necesitatea automatizării sau modernizării proceselor informaționale existente, fie de necesitatea unei reorganizări radicale în activitățile unei întreprinderi pentru desfășurarea reingineriei afacerii. Nevoile pentru crearea unui EIS indică, mai întâi, atingerea obiectivelor în care este necesar să se dezvolte un sistem; în al doilea rând, în ce moment este recomandabil să se realizeze dezvoltarea; și în al treilea rând, ce costuri sunt necesare pentru proiectarea sistemului. Proiectare EIS ...
7492.		CICLUL PROIECTULUI	5,37 MB
	Ciclul de viață al unui proiect este punctul de plecare pentru investigarea problemelor de finanțare a lucrărilor de proiect și luarea deciziilor adecvate. Fiecare proiect, indiferent de complexitatea și cantitatea de muncă necesară pentru implementarea acestuia, trece prin anumite stări în dezvoltarea sa: de la o stare când proiectul nu este încă prezent la o stare când proiectul nu mai este acolo. Pentru oamenii de afaceri, începutul unui proiect este asociat cu începutul implementării sale și cu începutul investiției de bani în implementarea acestuia.
8075.		Al doilea ciclu de calcul	9,25 KB
	În al doilea caz, am obținut așa-numitele d-cuburi echivalente pentru elementul 8, care diferă de primul doar prin inversarea simbolului d, deci trebuie să luăm un d-cub echivalent ȘI să obținem o soluție.
21755.		Ciclul de viață al proiectului	154,99 KB
	Eficacitatea și sustenabilitatea activităților unei organizații moderne este în mare măsură determinată de calitatea activităților de management desfășurate în domeniul gestionării ciclului proiectului. Managementul competent al ciclului proiectului este un indicator al direcției corecte de dezvoltare strategică în conformitate cu oportunitățile disponibile.
2742.		Buclă cu condiția REPEAT	12,49 KB
	Știți deja cum să organizați o buclă folosind instrucțiunea while. Amintiți-vă că atunci când această instrucțiune este executată, computerul verifică valoarea stării. Dacă condiția este adevărată, atunci partea de execuție a instrucțiunii while se va repeta până la
20265.		Ciclul de viață al companiei "FERRERO"	13,74 KB
	Ale zupinila Am o vibrație bună pentru toți oamenii mari ai cunoscutei companii de cofetărie Ferrero. Cota de piele a patra amărăciune în lumină - găsește-te în gura lasuni, care este atât de bună pentru tine cu mângâierea grupului italian Ferrero, încât, în momentul adormirii, în viitor, începe să obții 70 de stâncoși . -pasta de pin numită Nutell ...
1002.		Verificarea stării, bucla cu condiție suplimentară	2,25 MB
	Limbajul de asamblare este un sistem de notare utilizat pentru a reprezenta, într-o formă lizibilă de om, programe scrise în codul mașinii. Limbajul de asamblare permite programatorului să utilizeze coduri opnice mnemonice alfabetice
2341.		Ciclul de viață al produsului și comportamentul consumatorului	14,84 KB
	Ciclul de viață al unui produs și comportamentul consumatorului LCI constă în mai multe etape: cercetare și dezvoltare; implementare; creșterea vânzărilor; maturitate; recesiune. Prima etapă a ciclului de viață este cercetarea și dezvoltarea produselor. Pentru o întreprindere, această etapă de creare a unui produs reprezintă doar costuri și posibile venituri viitoare. Procedura pentru aducerea unui produs pe piață necesită timp; în această perioadă, vânzările cresc lent, ceea ce se poate explica prin astfel de circumstanțe: întârzieri în extinderea capacităților de producție; probleme tehnice; ...

Vă rugăm să suspendați AdBlock pe acest site.

Uneori nu puteți prevedea din timp de câte ori ar trebui să ruleze o buclă. Dar, în același timp, se cunoaște o anumită afecțiune când ciclul ar trebui să se oprească. De exemplu:

Program: zaruri.

Programul înlocuiește zarurile obișnuite.

Control:

1 - aruncați zarurile;
0 - Termină jocul.

Să scriem un șablon pentru jocul nostru.

Listarea 1.

#include #include #include int main (void) (srand (time (NULL)); printf ("########### Oasele diavolului ############ \ n"); printf ("# # \ n"); printf ("# Comenzi: # \ n"); printf ("# # \ n"); printf ("# 1 - joc nou # \ n"); printf ("# 0 - exit # \ n "); printf (" # # \ n "); printf (" ############################### # ########## \ n \ n "); control int; valoare int = 0; printf (" Introduceți comanda: "); scanf ("% d "și control); dacă (control == 1) (valoare = 1 + rand ()% 6; printf ("Rezultat:% d \ n", valoare);) returnează 0;)

Aici ne confruntăm cu problema. Este clar că este imposibil să știți din timp când se va termina jocul. Aceasta înseamnă că nu puteți utiliza bucla for direct. O modalitate de a ieși din această situație este de a utiliza alte constructe ciclice. De exemplu, o buclă while.

Buclați-vă cu precondiția while

Listarea 2.

Declarația While (condiție);

Programul întâlnește cuvântul cheie while, ceea ce înseamnă că urmează construcția de buclă;
Starea este verificată. Expresia logică dintre paranteze este evaluată;
Dacă valoarea condiției este ADEVĂRATĂ, atunci corpul buclei este executat. Trecem la punctul 2;
Dacă valoarea condiției este FALSĂ, atunci ciclul se încheie. Controlul este transferat către operator urmând corpul buclei.

Un operator înseamnă un singur operator. Dacă trebuie să executați mai multe comenzi într-o buclă, atunci trebuie să utilizați operatorul compus ().

Să rescriem programul nostru folosind această buclă.

Listarea 3.

#include #include #include int main (void) (srand (time (NULL)); printf ("########### Oasele diavolului ############ \ n"); printf ("# # \ n"); printf ("# Comenzi: # \ n"); printf ("# # \ n"); printf ("# 1 - joc nou # \ n"); printf ("# 0 - exit # \ n "); printf (" # # \ n "); printf (" ############################### # ########## \ n \ n "); control int; valoare int = 0; printf (" Introduceți comanda: "); scanf ("% d "și & control); while (control! = 0) (comutator (control) (caz 1: valoare = 1 + rand ()% 6; printf ("Rezultat:% d \ n", valoare); pauză; implicit: printf ("Eroare! Încercați din nou ... \ n "); break;) printf (" Enter comanda: "); scanf ("% d ", & control);) printf (" La revedere! \ n "); returnează 0;)

Să descriem în cuvinte algoritmul acestui program:

Afișăm meniul utilizatorului și vă oferim să introduceți o comandă;
Începem bucla while. Verificăm starea;
Dacă utilizatorul a introdus 0, atunci condiția de execuție a buclei devine FALSĂ. Corpul buclei nu este executat. Controlul este transferat către operator în urma ciclului. Șirul La revedere! ... Programul se încheie;
1. Operator de selecție:
  1. Dacă utilizatorul a introdus 1, atunci generăm un număr aleatoriu de la 1 la 6 și îl afișăm pe ecran. Ieșiți din operatorul de selecție;
  2. Dacă utilizatorul a introdus altceva, afișăm un mesaj de eroare. Ieșiți din operatorul de selecție.
2. Afișăm oferta către utilizator pentru a introduce o nouă comandă;
3. Citim codul de comandă în controlul variabil;
4. Revenim la verificarea stării. Punctul 3.

Bucla while se numește buclă de precondiție deoarece înainte de a executa corpul buclei, starea este verificată. Aceasta înseamnă, de exemplu, că este posibil ca corpul buclei să nu fie executat deloc nici măcar o dată. Un alt nume pentru bucla while este bucla YET. Traducere literală din engleză. Acest nume reflectă însăși esența ciclului.

Regula mnemonică:

CÂND condiția este ADEVĂRATĂ, executați corpul buclei.

Buclați-vă cu post-condiție do-while

Și ultima, a treia construcție de buclă este bucla do-while.

Această buclă diferă de bucla while, deoarece condiția este verificată nu înainte de a executa corpul buclei, ci după executarea corpului buclei. Aceasta înseamnă că corpul buclei do-while trebuie executat cel puțin o dată.

Sintaxa pentru această construcție de buclă este următoarea:

Listarea 4.

Do operator; while (stare);

Această construcție funcționează după cum urmează:

Programul îndeplinește cuvântul cheie do. Înseamnă o buclă do-while în fața ei;
Corpul buclei este executat;
Starea este verificată;
Dacă condiția este ADEVĂRATĂ, atunci corpul buclei este executat din nou;
Dacă condiția este FALSĂ, atunci lucrarea structurii ciclice este terminată. Programul este executat de instrucțiunea care urmează buclei do-while.

Să rescriem programul nostru folosind acest tip de construcție în buclă.

Listarea 5.

#include #include #include int main (void) (srand (time (NULL)); printf ("########### oasele diavolului ############ \ n"); printf ("# # \ n"); printf ("# Comenzi: # \ n"); printf ("# # \ n"); printf ("# 1 - joc nou # \ n"); printf ("# 0 - exit # \ n "); printf (" # # \ n "); printf (" ############################### # ########## \ n \ n "); int ch_control; int value = 0; do (printf (" Comandă de intrare: "); scanf ("% d ", & ch_control); switch (ch_control) ) (caz 0: pauză; caz 1: valoare = 1 + rand ()% 6; printf ("Rezultat:% d \ n", valoare); pauză; implicit: printf ("Eroare! Încercați din nou ... \ n "); break;)) while (ch_control! = 0); printf (" La revedere! \ n "); returnează 0;)

În general, este foarte similar cu codul anterior. Adevărat, a trebuit să schimb puțin operatorul de selecție: adăugați cazul 0: ramură acolo. În caz contrar, datorită faptului că verificarea se efectuează după executarea corpului buclei, programul nu a funcționat corect. Un mesaj de eroare a fost afișat la introducerea zero. În programul anterior (cu bucla while) o astfel de situație nu ar putea exista, deoarece egalitatea la zero a fost verificată în condiția buclei. Dacă introduceți zero, condiția ar deveni falsă, ceea ce înseamnă că ciclul s-ar termina și corpul ciclului nu ar fi executat.

PLAN DE LECȚIE CONSECT

INFORMATICĂ ȘI TIC

ÎN CLASA 10 PE TEMA:

Algoritmi ciclici. Bucle cu precondiție și postcondiție ”.

Articol: Informatică și TIC

Subiectul lecției: „ Algoritmi ciclici. Bucle cu precondiție și postcondiție "

Tipul lecției: Învățarea de materiale noi

Forma: lecția de atelier

Obiectivele lecției

educational: Faceți cunoștință cu conceptul „Cicluri cu condiție prealabilă și postcondiționată”. Consolidați cunoștințele elevilor despre algoritm.

în curs de dezvoltare: Pentru a stimula diligența, independența, cultura vorbirii și comunicarea.

educational: Dezvoltă gândirea, memoria, vorbirea și alte procese mentale.

UUD cognitiv: formează și dezvoltă competența în utilizarea TIC

(Competențe TIC).

UUD de reglementare: să știe cum să coreleze acțiunile lor cu rezultatele planificate.

UUD comunicativ: știu cum să lucreze individual și în grup.

UUD personal: să înțeleagă importanța instruirii în domeniul informaticii și TIC într-un mediu

dezvoltarea societății informaționale.

Mijloace de educație: proiector, computer personal, software specializat (mediu de programare „PascalABC”).

În timpul orelor

1. Organizarea începutului lecției

Buna ziua. Astăzi voi preda lecțiile de „Informatică și TIC”. Salut studenții și le verific pregătirea pentru lecție. Elevii se salută.

2. Verificarea temelor

Le întreb materialul acoperit.

1. Ce este un algoritm liniar?

Un algoritm liniar sau urmărire este un tip de algoritm în care secvența acțiunilor nu se modifică în timpul executării sale. Algoritm, în care comenzile sunt executate în ordinea în care au fost scrise, adică secvențial una după alta, se numește liniar.

2. Cum este implementat algoritmul liniar?

În program, algoritmul liniar este implementat prin plasarea secvențială a operatorilor.

De exemplu, următorul algoritm de plantare a copacilor este liniar:

1) săpați o gaură în pământ;
2) coborâți răsadul în gaură;
3) umpleți gaura cu răsad cu pământ;
4) udati rasadul cu apa.

3. Ce formă de organizare a acțiunilor se numește ramificare?

Forma de organizare a acțiunilor în care, în funcție de îndeplinirea sau neîndeplinirea unei anumite condiții, se efectuează fie una, fie alta secvență de acțiuni, se numește ramificare.

4. Cum este formalizat algoritmul de ramificare?

Logica decizională poate fi descrisă după cum urmează:

DACĂ<условие>APOI<действия 1>IN CAZ CONTRAR<действия 2>

Exemple:

Dacă vrei să fii sănătos, DECI fii temperat, ALTUI întinde-te pe canapea toată ziua;
DACĂ rândunelele zboară jos, APOI va ploua, ALTĂ nu va ploua;
DACĂ lecțiile sunt învățate, ATUNCI merg la plimbare, ALTE învață lecțiile.

3. Învățarea de materiale noi

Tema lecțiilor noastre va fi: „ Algoritmi ciclici. Buclați cu precondiția „Bye”. Buclă cu condiție postală „Înainte”».

Scopul lecției noastre este: „cunoașterea conceptului de ciclu și dezvoltarea capacității de a rezolva diverse probleme pe această temă”.

Să scriem acum ce este un ciclu?

Ciclu - o formă de organizare a acțiunilor, în care aceeași succesiune de acțiuni se execută de mai multe ori până când orice condiție este îndeplinită.

Algoritm ciclic Este un algoritm care conține unul sau mai multe bucle.

Structura algoritmică „ciclu” poate fi fixată în diferite moduri:

grafic - folosind o diagramă bloc;

într-un limbaj de programare precum Pascal folosind instrucțiuni speciale care implementează bucle de diferite tipuri.

Astăzi ne vom familiariza cu buclele cu condiție prealabilă și postcondiție.

Buclele cu o condiție prealabilă sunt utilizate atunci când execuția buclei este asociată cu o anumită condiție logică. O instrucțiune de buclă cu o precondiție are două părți: condiția de execuție a buclei și corpul buclei.

În rusă sună cam așa:

în timp ce această condiție este îndeplinită, faceți-o
de la început
grup de operatori
a se termina;

Când utilizați o buclă cu o condiție prealabilă, rețineți următoarele:

valoarea condiției de execuție a ciclului trebuie determinată înainte de începerea ciclului;

dacă valoarea condiției este adevărată, atunci se execută corpul buclei, după care se repetă verificarea condiției. Dacă condiția este falsă, atunci bucla este închisă;

cel puțin unul dintre operatorii incluși în corpul buclei trebuie să afecteze valoarea condiției de execuție a buclei, altfel bucla va repeta un număr infinit de ori.

Când se execută o instrucțiune while, se execută un anumit grup de instrucțiuni atâta timp cât condiția booleană definită în instrucțiunea while este adevărată. Dacă condiția este imediat falsă, atunci declarația nu va fi executată nici măcar o dată.

Parantezele operatorului sunt folosite pentru a separa de restul programului acel grup de operatori care trebuie repetați într-o buclă. Dacă trebuie executat un singur operator în buclă, atunci parantezele operatorului nu sunt puse.

Această declarație este executată după cum urmează: mai întâi, condiția de după cuvântul WHILE este verificată pentru adevăr. Dacă este ADEVĂRAT, atunci se execută declarația de după cuvântul DO, apoi se verifică din nou starea și așa mai departe. De îndată ce condiția nu este îndeplinită la pasul următor (valoarea expresiei devine egală cu FALS), atunci execuția operatorului de buclă este terminată.

Dacă instrucțiunea executată nu modifică valorile variabilelor incluse în condiție, atunci condiția va fi întotdeauna adevărată, iar bucla va rula pentru totdeauna, în timp ce programul se spune că este în buclă. Dacă, atunci când condiția este verificată pentru prima dată, se dovedește imediat a fi falsă, atunci operatorul buclei nu este deloc executat.

Dacă trebuie să executăm mai mulți operatori într-o buclă, atunci se folosește un operator compus, adică mai multe declarații sunt cuprinse între paranteze declarație BEGIN ... END.

SLIDE (comutator) !!!

Când creați programe cu o structură de buclă WHILE:

1) valoarea inițială a expresiei logice trebuie determinată înainte de a intra în buclă, adică înainte de CÂND;

2) secvența operatorilor executați în corpul buclei trebuie să fie conectată logic și să conțină cel puțin un operator care modifică valoarea parametrului buclei, altfel bucla va continua la nesfârșit;

3) expresia booleană din capul buclei WHILE trebuie să accepte valoarea FALS pentru ca bucla să se termine.

Funcționarea declarației While

Să aruncăm o privire la primul exemplu:

În diagrama bloc, tabelul de înmulțire cu 3 arată astfel:

Încercați să vă creați propriul tabel de înmulțire cu 1, 2, 4, 5, 6, 7, 8 și 9. Cum va arăta ca o diagramă bloc? (elevii realizează un tabel de înmulțire sub forma unei diagrame).

Acum să ne uităm la caracteristicile acestui ciclu și să ne scriem:

Să încercăm acum să rezolvăm singuri problema în Turbo Pascal.

Rezolvarea problemei imprimării a 10 numere întregi pe ecran folosind o buclă In timp ce … do :

O sarcină:

Pentru a rezolva această problemă, să ne amintim ce este o serie naturală de numere?

O serie naturală este o serie de numere întregi începând de la 1. Adică 1, 2, 3,… și până la un anumit număr N.

Rezolvarea acestei probleme:

O sarcină:

Soluţie:

Programul KOSHEY_vasilisa;

Var v, s: întreg;

Începe

v: = 18; (Vârsta lui Vasilisa)

s: = 27360; (Capitala inițială a Koschei)

în timp ce s<30000 do

Începe

s: = s + 33; (În fiecare an Koschey se îmbogățește)

v: = v + 1; (Vasilisa îmbătrânește în fiecare an)

Sfârșit;

writeln („Vasilisa”, v, „ani”);

Sfârșit.

Următoarea sarcină pe care trebuie să o rezolvați acasă, scrieți sarcina:

Începând antrenamentele, schiorul a alergat 10 km în prima zi. În fiecare zi următoare, el a mărit durata cursei cu 10% față de ziua precedentă. Determinați în ce zi va alerga mai mult de 20 km, în ce zi kilometrajul total pentru toate zilele va depăși 100 km.

Să aruncăm o privire la câte variabile vom avea și ce tip sunt acestea? Avem doar 2 variabile, una va fi utilizată pentru a calcula kilometrajul zilnic de peste 20 km, iar cealaltă va calcula în ce zi kilometrajul total pentru toate zilele va depăși 100 km. Ce tip vor fi variabilele? Kilometrajul zilnic va fi de tip întreg (adică un întreg), iar al doilea real (adică un număr real sau un număr cu virgulă), deoarece avem 10%, atunci dacă îl convertim într-un număr, obținem 0,1. Vom avea două cicluri în program, primul ciclu pentru determinarea zilei în care schiorul va alerga mai mult de 20 km și al doilea pentru găsirea zilei în care kilometrajul total pentru toate zilele depășește 100 km.

Acum să facem cunoștință cu următorul tip de bucle - bucle cu o condiție post-condiție.

Știți deja cum să organizați o buclă folosind instrucțiunea while. Amintiți-vă că atunci când această instrucțiune este executată, computerul verifică valoarea stării. Dacă condiția este adevărată, atunci partea de execuție a instrucțiunii while se va repeta până când această condiție va fi falsă. Dacă valoarea condiției este Falsă la început, atunci corpul buclei while nu va fi deloc executat.

Uneori, la rezolvarea problemelor, devine necesar să se execute corpul buclei cel puțin o dată și apoi, după verificarea stării, să se determine dacă se repetă din nou corpul buclei. Această sarcină va fi realizată de un alt tip de buclă - bucla Repeat.

repeta(repeta)
(operatori)
pana cand <условие>; (până când condiția este adevărată)

Această construcție citește astfel:

Luați în considerare funcționarea unei bucle cu o condiție postală:

Caracteristicile unei bucle cu o postcondiție:

Să rezolvăm aceeași problemă acum folosind o buclă cu o condiție postală:

Să comparăm bucla cu pre și postcondițiile:

Cum am mai spus:

Există o ușoară diferență în organizarea buclei de repetare în comparație cu while: pentru a executa mai multe instrucțiuni în bucla de repetare, nu ar trebui să plasați aceste instrucțiuni în parantezele de instrucțiuni begin ... end. Cuvintele rezervate se repetă și până acționează ca niște paranteze.

Repetați ... până când construcția funcționează într-un mod similar cu o buclă while. Diferența este că o buclă de timp verifică o stare înainte de a efectua acțiuni, în timp ce repetă verifică o stare după efectuarea acțiunilor. Acest lucru garantează cel puțin o execuție a acțiunilor înainte de sfârșitul ciclului.

Și există, de asemenea, ceva în comun în aceste cicluri:

Înainte de ciclu dat de valoarea inițială a variabilelor ,
inclus în condiție. Condiție - expresie boolean tip.

În corpul buclei valoarea variabilelor incluse în condiție trebuie asigurați-vă că vă schimbați sensul , altfel va exista o situație de „îngheț”.

Pentru a rezolva următoarea problemă, amintiți-vă progresia geometrică.

Și acum sarcina în sine:

Toată lumea a văzut problema care trebuie rezolvată folosind o buclă cu o condiție post-condiție. Puteți vedea cu toții că există o diagramă de flux construită folosind o buclă de precondiție. Să o analizăm în detaliu și apoi voi da o sarcină. Vedem cu toții că diagrama bloc are un început, apoi sunt introduse date, unde i = 7, deoarece acesta este fiul numărul 7, deoarece a luat ultimele două smaralde din pieptul tatălui său, deci dăm q o valoare egală cu două. Deoarece primul fiu a luat jumătate din ceea ce era în piept, înseamnă că diferența de progresie geometrică este de două, adică atribuim lui r o valoare egală cu două. Litera r arată diferența progresiei geometrice. Condiția noastră va fi ca, în timp ce avem i> 1, să efectuăm următoarea succesiune de acțiuni, adică i: = i -1, adică această acțiune arată că numărul următorului fiu scade cu unul. Apoi calculăm termenul final al progresiei efectuând acțiunea: q = q * r. Această succesiune de două acțiuni va fi efectuată până când condiția i> 1 devine falsă, după care se va afișa câte smaralde erau în piept și programul se va încheia.

Notare și notare pentru studenți.

Vă mulțumim pentru participare și muncă activă. Pana data viitoare.

5. Temele

Temele vor repeta ce este o buclă, ce este o buclă cu o postare și o condiție prealabilă, precum și sintaxa pentru a le scrie în limbajul de programare Pascal ... Apoi, acasă, rezolvă problema legată de un schior folosind un ciclu cu un post și o condiție prealabilă și adu-mi programul scris într-un caiet cu răspunsuri la întrebările puse în problemă.

Etichete: C cicluri. C bucle. Buclă cu postcondiție. Buclă cu condiție prealabilă. Bucla cu decapant. in timp ce. face în timp ce. pentru. pauză. continua

Introducere. Bucle cu o condiție prealabilă.

Când rezolvați probleme practice, este constant necesar să repetați o acțiune de un anumit număr de ori sau până când se ajunge la o anumită condiție. De exemplu, afișați o listă cu toți utilizatorii, asfaltați planul cu o textură, efectuați calcule pe fiecare element al matricei de date etc. În C, trei tipuri de cicluri sunt utilizate în aceste scopuri: precondiție, postcondițieși ciclu pentru cu un contor (deși acesta este un nume condiționat, deoarece este posibil să nu existe un contor).

Orice ciclu constă dintr-un corp și verificarea stării în care acest ciclu trebuie încheiat. Corpul buclei este setul de instrucțiuni care trebuie repetate. Fiecare repetare a buclei se numește iterație.

Luați în considerare o buclă cu o condiție prealabilă.

Int i = 0; in timp ce eu< 10) { printf("%d\n", i); i++; }

Această buclă rulează atâta timp cât condiția specificată după cuvântul cheie while este adevărată. Corpul buclei este de două linii, una afișează numărul, a doua îl modifică. Evident, această buclă va rula de 10 ori și se va imprima
0
1
2
3
și așa mai departe până la 9.

Este foarte important ca condiția de ieșire din buclă să fie îndeplinită vreodată, altfel va apărea o buclă fără sfârșit și programul nu se va termina. De exemplu

Int i = 0; in timp ce eu< 10) { printf("%d\n", i); }

Această buclă nu modifică variabila i, care este utilizată pentru a determina starea de oprire, astfel încât bucla nu se termină.

Int i = 0; while (i> 0) (printf ("% d \ n", i); i ++;)

În acest program, bucla se va încheia, desigur, dar, din cauza unei acțiuni greșite, va fi executată mult mai mult de 10 ori. Deoarece C nu monitorizează depășirea unei variabile, va fi necesar să așteptați până când variabila deversează și devine mai mică de zero.

Int i; in timp ce eu< 10) { printf("%d\n", i); i++; }

Acest exemplu are un comportament nedefinit. Deoarece variabila i nu este inițializată în avans, ea stochează gunoiul, o valoare necunoscută anterior. Conținutul diferit al variabilei i va schimba comportamentul.

Dacă corpul buclei while conține o declarație, atunci acoladele pot fi omise.

Int i = 0; in timp ce eu< 10) printf("%d\n", i++);

Aici incrementăm variabila i când apelăm funcția printf. Acest stil de codare trebuie evitat. Lipsa acoladelor, mai ales la începutul tutorialului, poate duce la erori. În plus, codul citește mai rău, iar parantezele suplimentare nu umflă foarte mult listările.

Bucle cu postcondiție.

O buclă cu o postcondiție diferă de o buclă de timp prin aceea că starea din ea este verificată după executarea buclei, adică această buclă va fi repetată cel puțin o dată (spre deosebire de bucla de timp, care poate să nu fie executată deloc ). Sintaxa buclei

Faceți (corpul buclei) în timp ce (condiție);

Exemplul anterior care utilizează o buclă do ar arăta ca.

Int i = 0; do (printf ("% d \ n", i); i ++;) în timp ce (i< 10);

Să vedem un exemplu de utilizare a unei bucle cu o condiție post-condiție și o precondiție. Să presupunem că trebuie să integrăm funcția.

Orez. 1 Integrarea numerică a unei funcții∫ a b f x d x

Integrala este suma infinitesimalului. Putem gândi integralul ca o sumă și putem înlocui pur și simplu valorile infinitezimale cu valori mici.

∫ a b f x d x = ∑ i = a b f i h

Din formulă, puteți vedea că de fapt împărțim zona de sub grafic în multe dreptunghiuri, unde înălțimea dreptunghiului este valoarea funcției în punct, iar lățimea este pasul nostru. Adăugând suprafețele tuturor dreptunghiurilor, obținem astfel valoarea integralei cu o anumită eroare.

dreptunghiuri stânga "src =" / images / c_loop_rectangles_left.png "alt =" (! LANG: Integrarea numerică a unei funcții prin
dreptunghiuri stângi"> Рис. 2 Численное интегрирование функции методом!}
dreptunghiuri stângi

Funcția cerută să fie x 2. Vom avea nevoie de următoarele variabile. În primul rând, suma acumulatorului pentru stocarea integralei. În al doilea rând, limitele stânga și dreapta a și b și, în al treilea rând, pasul h. Avem nevoie și de valoarea curentă a argumentului funcției x.

Pentru a găsi integralul, este necesar să treci de la A inainte de b cu ceva pas h, și adăugați la sumă aria unui dreptunghi cu laturile f (x)și h.

#include #include int main () (suma dublă = 0,0; dublu a = 0,0; dublu b = 1,0; dublu h = 0,01; dublu x = a; în timp ce (x< b) { sum += x*x * h; x += h; } printf("%.3f", sum); getch(); }

Programul generează 0.328.

∫ 0 1 x 2 d x = x 3 3 | 0 1 = 1 3 ≈ 0,333

Dacă vă uitați la grafic, puteți vedea că de fiecare dată găsim valoarea funcției în punctul stâng. Prin urmare, această metodă de integrare numerică se numește metoda dreptunghiului stâng. În mod similar, puteți lua valoarea corectă. Atunci va fi metoda dreptunghiurilor drepte.

În timp ce (x< b) { x += h; sum += x*x * h; } dreptunghiuri drepte "src =" / images / c_loop_rectangles_right.png "alt =" (! LANG: Integrarea numerică a unei funcții prin
dreptunghiuri drepte"> Рис. 3 Численное интегрирование функции методом!}
dreptunghiuri drepte

Suma în acest caz va fi egală cu 0,338. Metoda dreptunghiului stâng și drept nu este foarte precisă. De fapt, am aproximat (aproximat) un grafic neted al unei funcții care crește monoton cu o histogramă. Dacă vă gândiți puțin, atunci aproximarea poate fi realizată nu numai prin însumarea dreptunghiurilor, ci și prin însumarea trapezelor.

trapez "src =" / images / c_loop_integral_trapezium.png "alt =" (! LANG: Integrarea numerică a unei funcții de către
trapez"> Рис. 4 Численное интегрирование функции методом!}
trapez

Aproximarea trapezoidală este de fapt o aproximare a curbei de ordinul întâi în bucăți (ax + b). Conectăm punctele de pe grafic folosind segmente de linie. Poate fi complicat prin conectarea punctelor nu prin segmente, ci prin bucăți de parabolă, atunci aceasta va fi metoda Simpson. Pentru a complica lucrurile și mai mult, ajungem la splina de interpolare, dar aceasta este deja o altă conversație foarte lungă.

Să ne întoarcem la berbecii noștri. Să luăm în considerare 4 cicluri.

Int i = 0; while (i ++< 3) { printf("%d ", i); } int i = 0; while (++i < 3) { printf("%d ", i); } int i = 0; do { printf("%d ", i); } while(i++ < 3); int i = 0; do { printf("%d ", i); } while(++i < 3);

Dacă urmați aceste exemple, veți vedea că buclele sunt executate de două până la patru ori. Acest lucru merită acordat atenție, deoarece schimbarea incorectă a contorului de buclă duce adesea la erori.

Se întâmplă adesea că trebuie să ieșim din buclă fără să așteptăm ca un semnal să fie ridicat sau să se schimbe valoarea unei variabile. În aceste scopuri, operatorul pauză care forțează programul să iasă din bucla curentă.

Să rezolvăm o problemă simplă. Utilizatorul introduce numere până la introducerea numărului 0, apoi afișează cel mai mare număr introdus. Există o captură aici. Nu se știe câte numere va introduce utilizatorul. Prin urmare, vom crea o buclă infinită și vom ieși din ea folosind operatorul pauză... În interiorul buclei, vom primi date de la utilizator și vom selecta numărul maxim.

#include #include int main () (int num = 0; int max = num; printf ("Pentru a renunța, introduceți 0 \ n"); / * buclă fără sfârșit * / while (1) (printf ("Vă rugăm, introduceți numărul:"); scanf ("% d", & num); / * condiție pentru a ieși din buclă * / if (num == 0) (break;) if (num> max) (max = num;)) printf ("numărul maxim a fost % d ", max); getch ();)

Permiteți-mi să vă reamintesc că nu există un tip boolean special în C. Numerele sunt folosite în schimb. Zero este fals, toate celelalte valori sunt adevărate. Bucla while (1) va rula la nesfârșit. Singurul punct de ieșire din acesta este condiția

Dacă (num == 0)

În acest caz, ieșim din buclă cu pauză; Pentru început, stabilim ca maxim 0. Utilizatorul introduce un număr, după care verificăm dacă este zero sau nu. Dacă nu este zero, comparați-l cu maximul curent.

Buclele infinite sunt utilizate destul de des, deoarece datele de intrare nu sunt întotdeauna cunoscute în prealabil sau se pot modifica în timpul execuției programului.

Când trebuie să omitem corpul buclei, dar în același timp să continuăm execuția buclei, folosim operatorul continua... Un exemplu simplu: utilizatorul introduce zece numere. Găsiți suma tuturor numerelor pozitive pe care le-a introdus.

#include #include int main () (int i = 0; int positiveCnt = 0; float sum = 0.0f; float input; printf ("Introduceți 10 numere \ n"); în timp ce (i< 10) { i++; printf("%2d: ", i); scanf("%f", &input); if (input <= 0.0) { continue; } sum += input; positiveCnt++; } printf("Sum of %d positive numbers = %f", positiveCnt, sum); getch(); }

Exemplul pare oarecum descurajat, deși în general reflectă semnificația operatorului continua... În acest exemplu, variabila positiveCnt este un contor de numere pozitive, sumă suma și intrare- o variabilă temporară pentru introducerea numerelor.

Iată un alt exemplu. Este necesar ca utilizatorul să introducă un număr întreg mai mare de zero și mai mic de 100. Până la introducerea numărului necesar, programul va continua să sondeze.

Do (printf ("Vă rugăm, introduceți numărul:"); scanf ("% d", & n); dacă (n< 0 || n>100) (printf ("număr greșit, încercați din nou \ n"); continuați;) altfel (pauză;)) în timp ce (1);

Pentru buclă

Una dintre cele mai utilizate este bucla contra. pentru... Sintaxa sa este

Pentru (<инициализация>; <условие продолжения>; <изменение счётчика>){ <тело цикла> }

De exemplu, să afișăm pătratele primelor sute de numere.

Int i; pentru (i = 1; i< 101; i++) { printf("%d ", i*i); }

Unul dintre lucrurile minunate despre bucla for este că poate funcționa cu mai mult decât cu numere întregi.

Float num; for (num = 5.3f; num> 0f; num - = 0.2) (printf ("%. 2f", num);)

Această buclă va imprima numere de la 5,3 la 0,1. Bucla for poate să nu aibă unele „blocuri” de cod, de exemplu, poate lipsi inițializarea, verificarea (apoi bucla devine infinită) sau schimbarea contorului. Iată un exemplu cu o integrală implementată folosind un contor pentru

#include #include int main () (suma dublă = 0,0; dublu a = 0,0; dublu b = 1,0; dublu h = 0,01; dublu x; pentru (x = a; x< b; x += h) { sum += x*x * h; } printf("%.3f", sum); getch(); }

Să aruncăm o privire la o bucată de cod

Dublu x; pentru (x = a; x< b; x += h) { sum += x*x * h; }

Poate fi schimbat astfel

Dublu x = a; pentru (; x< b; x+=h) { sum += x*x*h; }

Mai mult, folosind operatorul pauză, puteți elimina condiția și puteți scrie

Dublu x; for (x = a ;; x + = h) (if (x> b) (break;) sum + = x * x * h;)

Dublu x = a; for (;;) (if (x> b) (break;) sum + = x * x * h; x + = h;)

în plus, folosind operatorul „,”, puteți transfera unele dintre acțiuni

Dublu x; pentru (x = a; x< b; x += h, sum += x*x*h) ;

NOTĂ: Deși acest lucru se poate face, vă rugăm să nu faceți acest lucru! Acest lucru reduce lizibilitatea codului și duce la erori subtile.

Să rezolvăm o problemă practică mai dificilă. Să presupunem că avem o funcție f (x). Să găsim maximul derivatului său pe segment. Cum se găsește derivata unei funcții numeric? Evident prin definiție). Derivata funcției într-un punct este tangenta pantei tangentei.

F x ′ = d x d y

Luați un punct pe curbă cu coordonate (x; f (x)), mutați un pas h înainte, obțineți punctul (x + h, f (x + h)), atunci derivata va fi

D x d y = f (x + h) - f x (x + h - x) = tan α

Adică, raportul dintre un increment de funcție mic și un increment de argument mic. Un cititor atent poate întreba de ce mergem înainte în funcție și nu înapoi. Ei bine, să ne întoarcem

D x d y = f x - f (x - h) h = tan β

Luând media acestor două valori, obținem

F (x + h) - f (x - h) 2h

În general, acum sarcina devine banală: mergem de la punct A până la punctul bși găsiți valoarea minimă a derivatului, precum și punctul în care derivatul ia această valoare. Pentru a rezolva, avem nevoie, ca și în problema cu o integrală, de variabilele pentru limitele zonei de căutare Ași b, valoarea actuala Xși pas h... În plus, este necesară o valoare maximă maxValși coordonează maxX această valoare maximă. Pentru lucru, luați funcția x sin x

#include #include #include int main () (double a = 0; double b = 3.0; double h = 0.001; double h2 = h * 2.0; double maxVal = a * sin (a); double maxX = a; double curVal; double x; // Trecem peste întreaga regiune de la a la b // și căutăm maximul primei derivate // Folosim funcția x * sin (x) pentru (x = a; x< b; x += h) { curVal = ((x+h)*sin(x+h)-(x-h)*sin(x-h))/h2; if (curVal >maxVal) (maxVal = curVal; maxX = x;)) printf ("valoare maximă =% .3f la% .3f", maxVal, maxX); getch (); )

La ieșire, programul dă valoarea maximă = 1,391 la 1,077

Soluția numerică oferă aceleași rezultate (până la o eroare) ca și programul nostru.

Bucle imbricate

Luați în considerare un exemplu în care buclele sunt imbricate unul în celălalt. Să afișăm tabelul de înmulțire.

#include #include #include int main () (int i, j; // Pentru fiecare i pentru (i = 1; i< 11; i++) { // Выводим строку из произведения i на j for (j = 1; j < 11; j++) { printf("%4d", i*j); } // После чего переходим на новую строку printf("\n"); } getch(); }

În acest exemplu, în prima buclă peste variabilă eu a doua buclă imbricată pe variabilă j... Secvența acțiunilor este următoarea: mai întâi intrăm în buclă prin eu, apoi pentru curent eu Numerele sunt afișate de 10 ori la rând. După aceea, trebuie să mergeți la o nouă linie. Acum să afișăm numai articolele sub diagonala principală.

Pentru (i = 1; i< 11; i++) { for (j = 1; j < 11; j++) { if (j >i) (break;) printf ("% 4d", i * j); ) printf ("\ n"); )

După cum puteți vedea, operatorul pauză vă permite să ieșiți numai din ciclul curent. Acest exemplu poate fi rescris după cum urmează

Pentru (i = 1; i< 11; i++) { for (j = 1; j <= i; j++) { printf("%4d", i*j); } printf("\n"); }

În acest caz, folosim contorul primului ciclu în bucla imbricată.

Ru-Cyrl 18- tutorial Sypachev S.S. 14.04.1989 [e-mail protejat] Stepan Sypachev studenți

Încă nu e clar? - scrieți întrebări în căsuța poștală