# Echivalarea structurilor repetitive

> Pagina: https://bacalaurescu.ro/informatica/lectii/algoritmi-si-pseudocod/echivalarea-structurilor-repetitive
> Markdown: https://bacalaurescu.ro/informatica/lectii/algoritmi-si-pseudocod/echivalarea-structurilor-repetitive.md
> Sursa: Bacalaurescu (bacalaurescu.ro), conținut gratuit pentru BAC 2027.

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

Capitolul: [Algoritmi și pseudocod](https://bacalaurescu.ro/informatica/lectii/algoritmi-si-pseudocod)
Actualizat: 2026-11-01

Transformarea pentru ↔ cât timp ↔ repetă...până când: subiectul clasic de rescriere.

## Pe scurt pentru BAC

- Orice buclă are inițializare, condiție, corp și actualizare, iar echivalările doar le rearanjează.
- La trecerea de la `pentru` la `cât timp`, inițializarea iese înaintea buclei, iar actualizarea intră la finalul corpului.
- `repetă` execută corpul măcar o dată, pe când `cât timp` poate să nu-l execute deloc, de aceea echivalarea se protejează cu `dacă c atunci`.
- La transformare condiția se neagă: `cât timp x < 10` devine `până când x ≥ 10`.

## Cele trei structuri, aceeași logică

Orice buclă are: INIȚIALIZARE, CONDIȚIE, CORP, ACTUALIZARE. Echivalările le rearanjează.

## pentru → cât timp

```
pentru i ← 1, n execută        i ← 1
    scrie i                     cât timp i ≤ n execută
                                    scrie i
                                    i ← i + 1
```

Inițializarea iese ÎNAINTE, actualizarea intră la FINALUL corpului.

## cât timp → repetă...până când (capcana clasică)

`repetă` execută corpul MĂCAR O DATĂ; `cât timp` poate să nu-l execute deloc. Echivalarea corectă cere protecție:

```
cât timp c execută        dacă c atunci
    corp                       repetă
                                   corp
                               până când NOT c
```

Fără `dacă`, la condiție inițial falsă cele două programe diferă: EXACT ce testează subiectul.

## Inversarea condiției

`cât timp` rulează CÂT TIMP condiția e adevărată; `până când` se oprește CÂND devine adevărată. La transformare, condiția se NEAGĂ: `cât timp x < 10` ↔ `până când x ≥ 10`.

## Exemplu complet de rescriere (cerință tip)

```
i ← 10                       i ← 10
cât timp i > 0 execută       repetă
    scrie i                      scrie i
    i ← i - 2                    i ← i - 2
                             până când i ≤ 0
```

Ambele afișează 10 8 6 4 2 ✓ (condiția inițială e adevărată, protecția nu era necesară aici, dar menționeaz-o!).

> [!RETINE]
> Trei mutări la echivalare: inițializarea înainte, actualizarea în corp, condiția NEGATĂ la trecerea cât timp ↔ până când. Plus protecția cu dacă pentru cazul "zero execuții".

## Greșeli frecvente

1. Uitarea negării condiției: bucla rulează invers.
2. repetă fără protecție execută corpul și când nu trebuie.
3. La pentru descrescător (pas -1), actualizarea devine i ← i - 1: pasul se copiază fidel.