# Bucle imbricate și tiparele clasice

> Pagina: https://bacalaurescu.ro/informatica/lectii/structuri-de-control/bucle-imbricate-si-tipare
> Markdown: https://bacalaurescu.ro/informatica/lectii/structuri-de-control/bucle-imbricate-si-tipare.md
> Sursa: Bacalaurescu (bacalaurescu.ro), conținut gratuit pentru BAC 2027.

Materia: [Informatică](https://bacalaurescu.ro/informatica)

Capitolul: [Structuri de control](https://bacalaurescu.ro/informatica/lectii/structuri-de-control)
Actualizat: 2026-11-01

For în for: divizori, numere prime și desenarea tiparelor cu stelute.

## Pe scurt pentru BAC

- Numerele 0 și 1 nu sunt prime, iar optimizarea `d * d <= n` verifică divizorii doar până la radical.
- Suma și numărul divizorilor se obțin parcurgând `d` de la 1 la `n` și adunând sau numărând fiecare `d` cu `n % d == 0`.
- Pentru n = 12 divizorii sunt 1, 2, 3, 4, 6, 12, deci numărul lor este 6, iar suma 28.
- Suma a două numere e pară când ambele sunt pare sau ambele sunt impare.

## Testul de număr prim

Tiparul care apare constant la BAC:

```cpp
int prim = 1;
if (n < 2) prim = 0;
for (int d = 2; d * d <= n; d++)
    if (n % d == 0) { prim = 0; break; }
```

Optimizarea `d * d <= n` (verifici doar până la radical) e standard; 1 și 0 NU sunt prime.

**Urmărire pentru n = 29**: d = 2, 3, 4, 5 (25 ≤ 29), niciun divizor → prim = 1 ✓.

## Suma și numărul divizorilor

```cpp
int s = 0, nr = 0;
for (int d = 1; d <= n; d++)
    if (n % d == 0) { s += d; nr++; }
```

Pentru n = 12: divizorii 1, 2, 3, 4, 6, 12 → nr = 6, s = 28.

## Bucle imbricate: numărarea perechilor

Câte perechi (i, j) cu $1 \le i < j \le n$ au suma pară?

```cpp
int nr = 0;
for (int i = 1; i < n; i++)
    for (int j = i + 1; j <= n; j++)
        if ((i + j) % 2 == 0) nr++;
```

Pentru n = 4: perechile (1,3), (2,4) → nr = 2. Regula: suma pară = ambele pare sau ambele impare.

## Numărul de pași la bucle imbricate

```cpp
for (int i = 1; i <= n; i++)
    for (int j = 1; j <= n; j++)
```

execută corpul de $n^2$ ori; cu `j = i + 1` la start: $\dfrac{n(n-1)}{2}$ ori (perechile). La subiectul cu "de câte ori se execută", astea două formule acoperă majoritatea cazurilor.

> [!ATENTIE]
> "break" iese DOAR din bucla curentă (cea interioară), nu din toate. La urmărire, notează exact ce buclă se întrerupe.

> [!RETINE]
> Test de prim: `n < 2` nu e prim, apoi cauți divizori `d` cât timp `d * d <= n`. Bucla dublă cu `j` de la 1 la `n` execută corpul de $n^2$ ori; cu `j` pornind de la `i + 1`, de $\dfrac{n(n-1)}{2}$ ori. `break` iese doar din bucla în care se află.

## Greșeli frecvente

1. Testul de prim fără cazul n < 2: 1 nu e prim.
2. La perechi cu i < j, bucla interioară pornește de la i + 1, nu de la 1 (altfel numeri dublu).
3. d * d <= n, nu d <= n / 2: a doua e corectă dar mai lentă și diferă la urmărire.