Loops: while and for

1-js/02-first-steps/13-while-for/1-loop-last-value/solution.md

@@ -1,4 +1,4 @@
-The answer: `1`.
+Răspunsul: `1`.
 
 ```js run
 let i = 3;
@@ -8,18 +8,18 @@ while (i) {
 }
 ```
 
-Every loop iteration decreases `i` by `1`. The check `while(i)` stops the loop when `i = 0`.
+Fiecare iterație descrește valoarea lui `i` cu `1`. Verificarea `while(i)` oprește iterația atunci când `i = 0`.
 
-Hence, the steps of the loop form the following sequence ("loop unrolled"):
+Așadar, pașii buclei formează următoarea secvență ("buclă desfășurată"):
 
 ```js
 let i = 3;
 
-alert(i--); // shows 3, decreases i to 2
+alert(i--); // afișează 3, descrește valoarea lui i la 2
 
-alert(i--) // shows 2, decreases i to 1
+alert(i--) // afișează 2, descrește valoarea lui i la 1
 
-alert(i--) // shows 1, decreases i to 0
+alert(i--) // afișează 1, descrește valoarea lui i la 0
 
-// done, while(i) check stops the loop
+// gata, verificarea while(i) oprește bucla
 ```

1-js/02-first-steps/13-while-for/1-loop-last-value/task.md

@@ -2,9 +2,9 @@ importance: 3
 
 ---
 
-# Last loop value
+# Ultima valoare a buclei
 
-What is the last value alerted by this code? Why?
+Care este ultima valoare afișată de acest cod? De ce?
 
 ```js
 let i = 3;

1-js/02-first-steps/13-while-for/2-which-value-while/solution.md

@@ -1,30 +1,24 @@
-The task demonstrates how postfix/prefix forms can lead to different results when used in comparisons.
+Acest exercițiu demonstrează cum prefixele/sufixele pot duce la rezultate diferite când sunt comparate.
 
-1. **From 1 to 4**
+1. **De la 1 la 4**
 
-    ```js run
-    let i = 0;
-    while (++i < 5) alert( i );
-    ```
+   ```js run
+   let i = 0;
+   while (++i < 5) alert( i );
+   ```
+   Prima valoare este `i = 1` pentru că `++i` incrementează prima dată `i` și apoi returnează noua valoare. Așadar prima comparație este `1 < 5`  și funcția `alert` afișează `1`.
+2. **De la 1 la 5**
 
-    The first value is `i = 1`, because `++i` first increments `i` and then returns the new value. So the first comparison is `1 < 5` and the `alert` shows `1`.
+   ```js run
+   let i = 0;
+   while (i++ < 5) alert( i );
+   ```
+   Prima valoare este din nou `i = 1`. Forma cu sufix `i++` incrementează `i` și după returnează vechea valoare, deci comparația `i++ < 5` va folosi `i = 0` (față de `++i < 5`).
 
-    Then follow `2, 3, 4…` -- the values show up one after another. The comparison always uses the incremented value, because `++` is before the variable.
+   Dar funcția `alert` se apelează separat. Este altă linie de cod care se execută după incrementare și după comparație. Așadar primește `i = 0`.
 
-    Finally, `i = 4` is incremented to `5`, the comparison `while(5 < 5)` fails, and the loop stops. So `5` is not shown.
-2. **From 1 to 5**
+   Apoi urmând `2, 3, 4...`
 
-    ```js run
-    let i = 0;
-    while (i++ < 5) alert( i );
-    ```
+   Hai să ne oprim la `i = 4`. Forma cu prefix `++i` l-ar incrementa și am folosi `5` pentru comparație. Dar aici avem forma cu sufix `i++`. Astfel îl incrementează pe `i` la `5`, dar returnează vechea valoare. Datorită faptului că comparația e de fapt `while(4 < 5)` - adevărat și execuția codului continuă cu funcția `alert`.
 
-    The first value is again `i = 1`. The postfix form of `i++` increments `i` and then returns the *old* value, so the comparison `i++ < 5` will use `i = 0` (contrary to `++i < 5`).
-
-    But the `alert` call is separate. It's another statement which executes after the increment and the comparison. So it gets the current `i = 1`.
-
-    Then follow `2, 3, 4…`
-
-    Let's stop on `i = 4`. The prefix form `++i` would increment it and use `5` in the comparison. But here we have the postfix form `i++`. So it increments `i` to `5`, but returns the old value. Hence the comparison is actually `while(4 < 5)` -- true, and the control goes on to `alert`.
-
-    The value `i = 5` is the last one, because on the next step `while(5 < 5)` is false.
+   Valoarea `i = 5` esre ultima, deoarece următorul pas `while(5 < 5)` este fals.

1-js/02-first-steps/13-while-for/2-which-value-while/task.md

@@ -2,21 +2,21 @@ importance: 4
 
 ---
 
-# Which values does the while loop show?
+# Ce valori afișează bucla while?
 
-For every loop iteration, write down which value it outputs and then compare it with the solution.
+Pentru fiecare iterație a buclei, scrie ce valori afișează și apoi compară-le cu soluția.
 
-Both loops `alert` the same values, or not?
+Ambele bucle afișează prin funcția `alert` aceleași valori, sau nu?
 
-1. The prefix form `++i`:
+1. Forma cu prefix `++i`:
 
-    ```js
-    let i = 0;
-    while (++i < 5) alert( i );
-    ```
-2. The postfix form `i++`
+   ```js
+   let i = 0;
+   while (++i < 5) alert( i );
+   ```
+2. Forma cu sufix `i++`
 
-    ```js
-    let i = 0;
-    while (i++ < 5) alert( i );
-    ```
+   ```js
+   let i = 0;
+   while (i++ < 5) alert( i );
+   ```

1-js/02-first-steps/13-while-for/3-which-value-for/solution.md

@@ -1,17 +1,17 @@
-**The answer: from `0` to `4` in both cases.**
+**Răspunsul: de la 0 la 4 în ambele cazuri.**
 
 ```js run
 for (let i = 0; i < 5; ++i) alert( i );
 
 for (let i = 0; i < 5; i++) alert( i );
 ```
 
-That can be easily deducted from the algorithm of `for`:
+Asta se poate deduce ușor din algoritmul lui `for`:
 
-1. Execute once `i = 0` before everything (begin).
-2. Check the condition `i < 5`
-3. If `true` -- execute the loop body `alert(i)`, and then `i++`
+1. Execută o dată `i = 0` înainte a orice altceva (inițializator).
+2. Verifică condiția `i < 5`
+3. Dacă e `true` -- rulează corpul buclei `alert(i)`, și apoi `i++`
 
-The increment `i++` is separated from the condition check (2). That's just another statement.
+Incrementarea `i++` e separată de verificarea condiției (2). Aceea e pur și simplu altă bucată de cod.
 
-The value returned by the increment is not used here, so there's no difference between `i++` and `++i`.
+Valoarea returnată după incrementare nu e folosită aici, așadar nu este nici-o diferență între `i++` și `++i`.

1-js/02-first-steps/13-while-for/3-which-value-for/task.md

@@ -2,19 +2,19 @@ importance: 4
 
 ---
 
-# Which values get shown by the "for" loop?
+# Ce valori se afișează pentru bucla "for"?
 
-For each loop write down which values it is going to show. Then compare with the answer.
+Pentru fiecare buclă, scrie ce valori se vor afișa. Apoi compară-le cu soluția.
 
-Both loops `alert` same values or not?
+Ambele bucle afișează prin funcția `alert` aceleași valori sau nu?
 
-1. The postfix form:
+1. Forma cu sufix:
 
-    ```js
-    for (let i = 0; i < 5; i++) alert( i );
-    ```
-2. The prefix form:
+   ```js
+   for (let i = 0; i < 5; i++) alert( i );
+   ```
+2. Forma cu prefix:
 
-    ```js
-    for (let i = 0; i < 5; ++i) alert( i );
-    ```
+   ```js
+   for (let i = 0; i < 5; ++i) alert( i );
+   ```

1-js/02-first-steps/13-while-for/4-for-even/solution.md

@@ -1,5 +1,3 @@
-
-
 ```js run demo
 for (let i = 2; i <= 10; i++) {
   if (i % 2 == 0) {
@@ -8,4 +6,4 @@ for (let i = 2; i <= 10; i++) {
 }
 ```
 
-We use the "modulo" operator `%` to get the remainder and check for the evenness here.
+Folosim operatorul "modulo" `%` pentru a afla restul împărțirii și astfel a verifica paritatea.

1-js/02-first-steps/13-while-for/4-for-even/task.md

@@ -2,8 +2,8 @@ importance: 5
 
 ---
 
-# Output even numbers in the loop
+# Afișează numerele pare în buclă
 
-Use the `for` loop to output even numbers from `2` to `10`.
+Folosește bucla `for` pentru a afișa numele pare între 2 și 10
 
 [demo]

1-js/02-first-steps/13-while-for/5-replace-for-while/solution.md

@@ -1,10 +1,7 @@
-
-
 ```js run
 let i = 0;
 while (i < 3) {
-  alert( `number ${i}!` );
+  alert( `numărul ${i}!` );
   i++;
 }
 ```
-

1-js/02-first-steps/13-while-for/5-replace-for-while/task.md

@@ -2,13 +2,12 @@ importance: 5
 
 ---
 
-# Replace "for" with "while"
+# Înlocuiește "for" cu "while"
 
-Rewrite the code changing the `for` loop to `while` without altering its behavior (the output should stay same).
+Rescrie codul schimbând bucla `for` cu `while` fără să schimbi comportamentul codului (ceea ce se afișează ar trebui să rămână neschimbat).
 
 ```js run
 for (let i = 0; i < 3; i++) {
-  alert( `number ${i}!` );
+  alert( `numărul ${i}!` );
 }
 ```
-

1-js/02-first-steps/13-while-for/6-repeat-until-correct/solution.md

@@ -1,15 +1,14 @@
-
 ```js run demo
 let num;
 
 do {
-  num = prompt("Enter a number greater than 100?", 0);
+  num = prompt("Introdu un număr mai mare ca 100?", 0);
 } while (num <= 100 && num);
 ```
 
-The loop `do..while` repeats while both checks are truthy:
+Bucla `do..while` se repetă până amândouă verificările sunt truthy:
 
-1. The check for `num <= 100` -- that is, the entered value is still not greater than `100`.
-2. The check `&& num` is false when `num` is `null` or an empty string. Then the `while` loop stops too.
+1. Verificarea ca `num <= 100` -- adică, valoarea introdusă încă nu e mai mare ca `100`
+2. Verificarea `&& num` e falsă când `num` e fie `null` fie un string gol. Atunci bucla `while` se oprește și ea.
 
-P.S. If `num` is `null` then `num <= 100` is `true`, so without the 2nd check the loop wouldn't stop if the user clicks CANCEL. Both checks are required.
+P.S. Dacă `num` e `null` atunci `num <= 100` e `true`, așa că fără a 2-a verificarea bucla nu s-ar mai putea opri decât dacă utilizatorul apasă Anulează. Ambele verificări sunt obligatorii.

1-js/02-first-steps/13-while-for/6-repeat-until-correct/task.md

@@ -2,12 +2,10 @@ importance: 5
 
 ---
 
-# Repeat until the input is correct
+# Repetă până numărul introdus e corect
 
-Write a loop which prompts for a number greater than `100`. If the visitor enters another number -- ask them to input again.
+Scrie o buclă care să ceară utilizatorului un număr mai mare decât `100`. Dacă utilizatorul introduce alt număr -- cere-i să încerce din nou.
 
-The loop must ask for a number until either the visitor enters a number greater than `100` or cancels the input/enters an empty line.
-
-Here we can assume that the visitor only inputs numbers. There's no need to implement a special handling for a non-numeric input in this task.
+Bucla trebuie să ceară un număr fie până vizitatorul introduce un număr mai mare decât `100` fie anulează introducerea sau introduce un string gol.
 
 [demo]

1-js/02-first-steps/13-while-for/7-list-primes/solution.md

@@ -1,29 +1,29 @@
-There are many algorithms for this task.
+Există mulți algoritmi pentru aceast exercițiu.
 
-Let's use a nested loop:
+Hai să folosim o buclă imbricată (nested loop):
 
 ```js
-For each i in the interval {
-  check if i has a divisor from 1..i
-  if yes => the value is not a prime
-  if no => the value is a prime, show it
+Pentru fiecare i din interval {
+  verifică dacă i are un divizor de la 1 la i
+  dacă da => numărul nu este prim
+  dacă nu => numărul este prim, afișează-l
 }
 ```
 
-The code using a label:
+Codul folosind o etichetă:
 
 ```js run
 let n = 10;
 
-nextPrime:
-for (let i = 2; i <= n; i++) { // for each i...
+următorulNrPrim:
+for (let i = 2; i <= n; i++) { // pentru fiecare i...
 
-  for (let j = 2; j < i; j++) { // look for a divisor..
-    if (i % j == 0) continue nextPrime; // not a prime, go next i
+  for (let j = 2; j < i; j++) { // caută un divizor..
+    if (i % j == 0) continue următorulNrPrim; // nu e prim, treci la următorul i
   }
 
-  alert( i ); // a prime
+  alert( i ); // e prim
 }
 ```
 
-There's a lot of space to optimize it. For instance, we could look for the divisors from `2` to square root of `i`. But anyway, if we want to be really efficient for large intervals, we need to change the approach and rely on advanced maths and complex algorithms like [Quadratic sieve](https://en.wikipedia.org/wiki/Quadratic_sieve), [General number field sieve](https://en.wikipedia.org/wiki/General_number_field_sieve) etc.
+Aici există foarte multe oportunități de optimizare. De exemplu, am putea căuta divizorii de la `2` la radical din `i`. În orice caz, dacă vrem să fim extrem de eficienți pentru intervale mari, trebuie să schimbăm abordarea și să ne bazăm pe matematică avansată și algoritmi complecși precum [Quadratic sieve](https://en.wikipedia.org/wiki/Quadratic_sieve), [General number field sieve](https://en.wikipedia.org/wiki/General_number_field_sieve), etc.

1-js/02-first-steps/13-while-for/7-list-primes/task.md

@@ -2,16 +2,14 @@ importance: 3
 
 ---
 
-# Output prime numbers
+# Afișează numere prime
 
-An integer number greater than `1` is called a [prime](https://en.wikipedia.org/wiki/Prime_number) if it cannot be divided without a remainder by anything except `1` and itself.
+Un număr de tip întreg mai mare decât `1` se numește [prim](https://ro.wikipedia.org/wiki/Num%C4%83r_prim) dacă nu se poate împărți fără rest cu nimic în afară de 1 și el însuși.
 
-In other words, `n > 1` is a prime if it can't be evenly divided by anything except `1` and `n`.
+Cu alte cuvinte, `n > 1` este prim dacă nu se poate împărți exact cu nimic în afară de `1` și `n`.
 
-For example, `5` is a prime, because it cannot be divided without a remainder by `2`, `3` and `4`.
+**Scrie codul care afișează numerele prime în intervalul de la 2 la `n`.**
 
-**Write the code which outputs prime numbers in the interval from `2` to `n`.**
+Pentru `n = 10` rezultatul va fi `2,3,5,7`.
 
-For `n = 10` the result will be `2,3,5,7`.
-
-P.S. The code should work for any `n`, not be hard-tuned for any fixed value.
+P.S. Codul ar trebui să funcționeze pentru orice `n`, nu să fie scris pentru o anume valoare.