Suma primelor n numere
Citiți un număr natural n și afișați suma 1 + 2 + … + n, calculată cu o buclă for.
515Structurile repetitive permit executarea unei secvențe de instrucțiuni atât timp cât o condiție rămâne adevărată. Cele trei forme din C/C++ sunt echivalente ca putere de calcul, dar fiecare exprimă mai natural un anumit tip de repetiție.
forbreak și continue| Instrucțiune | Testul condiției | Execuții minime | Se folosește când |
|---|---|---|---|
while | înainte de corp | 0 | numărul de repetări nu este cunoscut dinainte |
do-while | după corp | 1 | corpul trebuie executat măcar o dată (meniuri, validări) |
for | înainte de corp | 0 | numărul de repetări este cunoscut sau se parcurge un interval |
while (expresie)
instructiune;
do
instructiune;
while (expresie); // atentie: punct si virgula obligatoriu aici
La while se testează întâi expresia; dacă este adevărată (nenulă), se execută corpul,
apoi se reevaluează. La do-while, corpul se execută înainte de primul test, deci
cel puțin o dată, indiferent de condiție.
for (initializare; conditie; pas)
instructiune;
for (int i = 0; i < 10; i++) { ... }
│ │ └── se executa DUPA fiecare iteratie
│ └─────────── se testeaza INAINTE de fiecare iteratie
└─────────────────────── se executa O SINGURA DATA, la inceput
Toate cele trei componente sunt opționale. for (;;) este o buclă infinită validă,
echivalentă cu while (1).
| Formă | Efect |
|---|---|
for (i = 0; i < n; i++) | parcurgere crescătoare clasică |
for (i = n - 1; i >= 0; i--) | parcurgere descrescătoare |
for (i = 0, j = n; i < j; i++, j--) | doi indici, folosind operatorul virgulă |
for (;;) | buclă infinită |
Modificați cei trei parametri și urmăriți tabelul de iterații: de câte ori se execută corpul, ce valori ia contorul și cu ce valoare rămâne după terminarea buclei. Puneți pasul pe 0 pentru a vedea cum se detectează o buclă infinită.
Urmăriți cum funcționează continue și break într-o buclă
care însumează doar numerele pare, oprindu-se la prima valoare negativă.
| Instrucțiune | Efect | Domeniu de acțiune |
|---|---|---|
break | părăsește bucla sau switch-ul curent | doar structura cea mai interioară |
continue | sare la următoarea iterație | doar bucla cea mai interioară |
return | părăsește funcția, returnând o valoare | întreaga funcție |
goto eticheta | salt necondiționat la o etichetă | în interiorul aceleiași funcții |
exit(cod) | termină întreg programul | tot programul |
goto face codul greu de urmărit
și de întreținut. Singura utilizare acceptată în practica modernă este ieșirea rapidă din bucle imbricate
adânc, către un punct comun de eliberare a resurselor.break iese doar din bucla interioară.
Pentru a părăsi ambele bucle, se folosește un indicator (bool gasit), se scoate codul
într-o funcție cu return, sau - rar - goto.for (i = 0; i < 10; i++); execută bucla de zece ori „în gol", iar blocul de dedesubt
se execută o singură dată.for (i = 0; i <= n; i++) execută n + 1 iterații. La parcurgerea unui tablou cu
n elemente, aceasta depășește limita cu o poziție.do-while, continue sare direct la testul condiției. Dacă incrementarea
contorului se afla după continue, ea nu se mai execută și bucla devine infinită.for face comportamentul greu de urmărit
și este o sursă frecventă de bucle care nu se termină.
#include <stdio.h>
int main(void)
{
int n, i = 0;
double valoare, suma = 0.0;
printf("Cate valori? ");
scanf("%d", &n);
while (i < n) {
printf("Valoarea %d: ", i + 1);
scanf("%lf", &valoare);
suma += valoare;
i++; // FARA aceasta linie: bucla infinita
}
if (n > 0)
printf("Media aritmetica = %.4f\n", suma / n);
else
printf("Nicio valoare introdusa\n");
return 0;
}
#include <stdio.h>
int main(void)
{
int optiune;
do {
printf("\n--- MENIU ---\n");
printf("1. Adauga\n2. Sterge\n3. Afiseaza\n0. Iesire\n");
printf("Alegeti: ");
scanf("%d", &optiune);
switch (optiune) {
case 1: printf("Ati ales adaugarea\n"); break;
case 2: printf("Ati ales stergerea\n"); break;
case 3: printf("Ati ales afisarea\n"); break;
case 0: printf("La revedere!\n"); break;
default: printf("Optiune invalida\n");
}
} while (optiune != 0); // meniul se afiseaza macar o data
return 0;
}
#include <stdio.h>
int main(void)
{
printf("Numerele prime pana la 50:\n");
for (int n = 2; n <= 50; n++) {
int prim = 1; // presupunem ca n este prim
for (int d = 2; d * d <= n; d++)
if (n % d == 0) {
prim = 0; // am gasit un divizor
break; // iesire imediata din bucla interioara
}
if (!prim) continue; // sare peste cele neprime
printf("%d ", n);
}
printf("\n");
// tabla inmultirii, cu bucle imbricate
printf("\nTabla inmultirii 1-5:\n");
for (int i = 1; i <= 5; i++) {
for (int j = 1; j <= 5; j++)
printf("%4d", i * j);
printf("\n"); // linie noua dupa fiecare rand
}
return 0;
}
La bucle, modul Pas cu pas este cel mai util instrument: vedeți contorul crescând și condiția fiind reevaluată la fiecare trecere.
Aici scrieți voi codul. Butonul ✓ Verifică rulează programul pe mai multe seturi de date și vă arată imediat unde diferă rezultatul. La final trimiteți traseul ales, iar profesorul îl notează automat.
Fiecare exercițiu are programul deja început, iar comentariile vă spun ce mai trebuie adăugat. Scrieți codul, apăsați ✓ Verifică și citiți ce spune fiecare test picat. Dacă v-ați blocat, deschideți câte un indiciu. Puteți afișa și mesaje pentru utilizator (de tipul Introduceti n:), testul se uită la ce afișați la final.
Citiți un număr natural n și afișați suma 1 + 2 + … + n, calculată cu o buclă for.
515Citiți un număr natural n și afișați suma cifrelor lui, folosind while.
123410Citiți un întreg n și afișați, pe câte un rând, n x i = rezultat pentru i de la 1 la 10.
77 x 1 = 7
7 x 2 = 14
7 x 3 = 21
7 x 4 = 28
7 x 5 = 35
7 x 6 = 42
7 x 7 = 49
7 x 8 = 56
7 x 9 = 63
7 x 10 = 70Pe primul rând este n (n ≥ 1), apoi n numere întregi. Afișați media lor, cu două zecimale.
3
4 5 96.00Citiți un întreg n (poate fi 0 sau negativ) și afișați câte cifre are. Numărul 0 are o cifră. Folosiți do-while.
123455Problemele pornesc de la un main gol. Formatul ieșirii trebuie respectat exact (spațiile și rândurile noi nu contează, dacă enunțul nu spune altfel), deci nu afișați mesaje pentru utilizator. Testele vizibile acoperă doar cazurile simple; la notare se rulează și teste ascunse, alese să prindă cazurile limită.
Citiți un întreg n (2 ≤ n ≤ 5000) și afișați, pe un rând, toate numerele prime mai mici sau egale cu n, despărțite prin spațiu.
302 3 5 7 11 13 17 19 23 29Citiți două numere naturale nenule a și b (cel mult 50 000 000). Afișați cel mai mare divizor comun și cel mai mic multiplu comun.
12 186 36Citiți un întreg n (1 ≤ n ≤ 30) și afișați o piramidă cu n rânduri: rândul i (de la 1) are n - i spații urmate de 2i - 1 stele. Nu lăsați spații după stele.
Aici contează și spațiile: ieșirea se compară caracter cu caracter (doar spațiile de la capăt de rând se ignoră).
3 *
***
*****Pornind de la n (1 ≤ n ≤ 109), repetați: dacă n e par, n = n / 2, altfel n = 3n + 1, până ajungeți la 1. Afișați numărul de pași și cea mai mare valoare atinsă.
68 16while.for și apoi cu do-while; comparați lizibilitatea.continue.while.int.