13 while for

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

@@ -1,4 +1,4 @@
-La risposta: `1`.
+La risposta è: `1`.
 
 ```js run
 let i = 3;
@@ -15,11 +15,11 @@ Quindi, gli step del ciclo sono ("loop unrolled"):
 ```js
 let i = 3;
 
-alert(i--); // shows 3, decreases i to 2
+alert(i--); //mostra 3, decrementa i a 2
 
-alert(i--) // shows 2, decreases i to 1
+alert(i--) // mostra 2, decrementa i a 1
 
-alert(i--) // shows 1, decreases i to 0
+alert(i--) // mostra 1, decrementa i a 0
 
-// done, while(i) check stops the loop
+// finito, `i` è ora 0, che convertito a booleano è falso
 ```

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

@@ -4,7 +4,7 @@ importance: 3
 
 # Valore all'ultimo ciclo
 
-Qualè l'ultimo valore stampato da alert in questo codice? Perchè?
+Qual è l'ultimo valore mostrato da *alert* in questo codice? Perché?
 
 ```js
 let i = 3;

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

@@ -9,9 +9,9 @@ L'esercizio dimostrava come le forme prefissa/postfissa possono portare a risult
 
     Il primo valore è `i = 1`, perchè `++i` incrementa prima `i` e poi ritorna il nuovo valore. Quindi il primo confronto è `1 < 5` e `alert` mostra `1`.
 
-    Poi seguono `2, 3, 4…` -- i valori vengono mostrati uno dopo l'altro. Il confroto utilizza sempre il valose incrementato, perchè `++` è posto prima della variabile.
+    Poi seguono `2, 3, 4…` -- i valori vengono mostrati uno dopo l'altro. Il confronto utilizza sempre il valore incrementato, perchè `++` è posto prima della variabile.
 
-    Ultima iterazione, `i = 4` viene incrementato a `5`, il confronto `while(5 < 5)` fallisce, e il ciclo termina. Quindi `5` non viene mostrato.
+    Ultima iterazione, `i = 4` viene incrementato a `5`, il confronto `while(5 < 5)` risulta `false`, e il ciclo termina. `5` non viene mostrato.
 
 2. **Da 1 a 5**
 
@@ -22,10 +22,10 @@ L'esercizio dimostrava come le forme prefissa/postfissa possono portare a risult
 
     Il primo valore è ancora `i = 1`. La forma postfissa `i++` incrementa `i` e ritorna il *vecchio* valore, quindi il confronto `i++ < 5` utilizza `i = 0` (a differenza di `++i < 5`).
 
-    La chiamata ad `alert` è separata. E' un istruzione che viene eseguita dopo l'incremento e il confronto. Quindi avra il valore `i = 1`.
+    La chiamata ad `alert` è separata. E' un istruzione che viene eseguita dopo l'incremento di `i` e il controllo della condizione. Quindi `i = 1`.
 
     Seguono `2, 3, 4…`
 
-    Fermiamoci a `i = 4`. La forma prefissa `++i` incrementerebbe ed utilizzerebbe `5` nel confronto. Qui però stiamo usando la forma postfissa `i++`. Quindi incrementa `i`a `5`, ma ritorna il vecchio valore. Il confronto è `while(4 < 5)` -- vero, il controllo passa alla chiamata `alert`.
+    Fermiamoci a `i = 4`. La forma prefissa `++i` incrementerebbe ed utilizzerebbe `5` nel controllo della condizione `i < 5`. Qui però stiamo usando la forma postfissa `i++`. Quindi incrementa `i`a `5`, ma ritorna il vecchio valore. Il confronto è dunque `while(4 < 5)` -- vero; il controllo passa alla chiamata `alert`.
 
-    Il valore `i = 5` è l'ultimo, perchè nello step successivo avremmo `while(5 < 5)` che è falso.
+    Il valore `i = 5` è l'ultimo, perchè nell'iterazione successiva avremmo `while(5 < 5)` e la condizione sarebbe falsa.

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

@@ -2,11 +2,11 @@ importance: 4
 
 ---
 
-# Quali valori mostra il ciclo while?
+# Quali valori mostrerà il ciclo while?
 
-Per ogni iterazione del ciclo, scrivi quali valori vengono mostrati e poi confrontali alla soluzione.
+Per ogni iterazione del ciclo, scrivi quali valori verranno mostrati e poi confrontali con la soluzione.
 
-Entrambi i cicli mostrano gli stessi valori in `alert`, o no?
+Entrambi i cicli mostreranno gli stessi valori in `alert`, o no?
 
 1. La forma prefissa `++i`:
 

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

@@ -6,12 +6,12 @@ for (let i = 0; i < 5; ++i) alert( i );
 for (let i = 0; i < 5; i++) alert( i );
 ```
 
-Questo può eserre facilmete dedotto dall'algoritmo  `for`:
+Questo può essere facilmente dedotto dall'algoritmo  `for`:
 
-1. Esegue un asola volta `i = 0` come prima cosa (begin)
+1. Esegue come prima cosa `i = 0` (una sola volta)
 2. Verifica la condizione `i < 5`
-3. Se è `true` -- esegue il corpo del ciclo `alert(i)`, successivamente `i++`
+3. Se è `true` -- esegue il corpo del ciclo, dove si trova `alert(i)`, poi incrementa `i` di 1
 
-L'incremento `i++` è separato dal controllo della condizione(2). E' un istruzione differente.
+L'incremento `i++` è separato dal controllo della condizione(2). E' un'istruzione differente.
 
 Il valore ritornato non viene utilizzato, quindi non c'è differenza tra `i++` e `++i`.

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

@@ -2,11 +2,11 @@ importance: 4
 
 ---
 
-# Quali valori verrano mostrati dal ciclo "for"?
+# Quali valori verranno mostrati dal ciclo "for"?
 
 Per ogni ciclo scrivete quali valori verranno mostrati. Poi confrontateli con la soluzione.
 
-Entrambi gli `alert` mostrano gli stessi valori?
+I due `alert` mostreranno gli stessi valori?
 
 1. Forma postfissa:
 

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

@@ -8,4 +8,4 @@ for (let i = 2; i <= 10; i++) {
 }
 ```
 
-Utilizziamo l'operatore modulo `%` per ottenre il resto e controllare la parità.
+Utilizziamo l'operatore modulo `%` per controllare che un numero sia pari.

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

@@ -2,8 +2,8 @@ importance: 5
 
 ---
 
-# Stampare i numeri pari con un ciclo
+# Mostra i numeri pari con un ciclo 'for'
 
-Utilizzate il ciclo `for` per stampare i numeri pari da `2` a `10`.
+Utilizzate il ciclo `for` per mostrare i numeri pari da `2` a `10`.
 
 [demo]

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

@@ -4,7 +4,7 @@ importance: 5
 
 # Sostituisci "for" con "while"
 
-Riscrivi il codice cambiando il ciclo `for` con `while` senza modificare il comportamento (l'output deve rimanere lo stesso).
+Riscrivi il ciclo `for` utilizzando la sintassi `while`, ma senza alterarne la funzionalità (l'output deve rimanere lo stesso).
 
 ```js run
 for (let i = 0; i < 3; i++) {

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

@@ -7,9 +7,9 @@ do {
 } while (num <= 100 && num);
 ```
 
-Il ciclo `do..while` si ripete fino a chè entrambe le condizioni non risultano vere:
+Il ciclo `do..while` si ripete fintanto che entrambe le condizioni non risultano vere:
 
-1. Il controllo `num <= 100` -- controlla se il valore non risulta ancora maggiore di `100`.
-2. Il controllo `&& num` è falso quando `num` è `null` o una stringa. Quindi il ciclo `while` termina.
+1. Il controllo `num <= 100` -- controlla se il valore non risulti ancora maggiore di `100`.
+2. Il controllo `&& num` diventa falso quando `num` è `null` o una stringa. Quindi il ciclo `while` termina.
 
-P.S. Se `num` è `null` allora la condizione `num <= 100` è `true`, quindi senza il secondo controllo il ciclo non terminerebbe nel caso in cui l'utente prema CANCEL. Entrambi i controlli sono necessari.
+P.S. Se `num` è `null` allora la condizione `num <= 100` è `true`, quindi senza la seconda condizione il ciclo non terminerebbe nel caso in cui l'utente prema CANCEL. Entrambe le condizioni sono necessarie.

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

@@ -2,12 +2,12 @@ importance: 5
 
 ---
 
-# Ripeti fino a trovare un input corretto 
+# Ripeti fino a quando l'input è corretto 
 
-Scrivi un ciclo che richieda (prompt) un numero maggiore di `100`. Se l'utente inserisce un numero non valido -- chiedete di inserirlo nuovamente.
+Scrivi un ciclo che richieda (tramite *prompt*) un numero maggiore di `100`. Se l'utente inserisce un numero non valido -- chiedete di inserirlo nuovamente.
 
-Il ciclo deve continuare a richiede un numero fino a chè l'utente non inserisce un numero maggiore di `100`, oppure annulla l'input sia premendo cancel, che inserendo una riga vuota.
+Il ciclo deve continuare a richiede un numero fintanto che l'utente non inserisce un numero maggiore di `100`, oppure annulla l'input (sia premendo *cancel* che inserendo una riga vuota).
 
-Possiamo assumere che l'utente inserisca solo numeri. Non c'è quindi bisogno di implementare alcun tipo di gestione per un input di tipo non numerico.
+Possiamo assumere che l'utente inserisca solo numeri. Non c'è quindi bisogno di implementare alcun tipo di logica per un input di tipo non numerico.
 
 [demo]

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

@@ -1,4 +1,4 @@
-Ci sono diversi algoritmi per compiere questa attività.
+Ci sono diversi possibili algoritmi per il nostro scopo.
 
 Usiamo un ciclo annidato:
 
@@ -10,20 +10,20 @@ For each i in the interval {
 }
 ```
 
-Il codice usa un etichetta:
+Il codice usa un'etichetta:
 
 ```js run
 let n = 10;
 
 nextPrime:
-for (let i = 2; i <= n; i++) { // for each i...
+for (let i = 2; i <= n; i++) { // per ogni 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++) { // controlla i suoi divisori..
+    if (i % j == 0) continue nextPrime; // se è divisibile per uno di essi, non è un numero primo; passa a prossima iterazione
   }
 
-  alert( i ); // a prime
+  alert( i ); // un numero primo
 }
 ```
 
-Ci sono molti modi per ottimizzarlo. Ad esempio, potremmo controllare i divisori di `2` fino alla radice di `i`. In ogni caso, se vogliamo essere veramete efficenti su grandi intervalli, abbiamo bisogno di cambiare approcio ed affidarci ad algoritmi matematici più avanzati e complessi, come [Quadratic sieve](https://en.wikipedia.org/wiki/Quadratic_sieve), [General number field sieve](https://en.wikipedia.org/wiki/General_number_field_sieve) etc.
+Ci sono molti modi per ottimizzare questo algoritmo. Ad esempio, potremmo controllare i divisori di `2` fino alla radice di `i`. In ogni caso, se vogliamo essere veramete efficenti su grandi intervalli, abbiamo bisogno di cambiare approcio ed affidarci ad algoritmi matematici più avanzati e complessi, come [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,15 +2,15 @@ importance: 3
 
 ---
 
-# Stampare i numeri primi
+# Mostra i numeri primi
 
-Un valore intero maggiore di `1` si definisce [primo](https://en.wikipedia.org/wiki/Prime_number) se non può essere diviso, senza resto, da nessun numero ad eccezione di `1` e se stesso.
+Un valore intero maggiore di `1` si definisce [primo](https://it.wikipedia.org/wiki/Numero_primo) se non può essere diviso, senza [resto](https://it.wikipedia.org/wiki/Resto), da nessun numero ad eccezione di `1` e se stesso.
 
 In altre parole, `n > 1` è primo se non può essere diviso da nessun altro numero ad eccezione di `1` e `n`.
 
-Ad esempio, `5` è primo, perchè non può essere diviso senza resto da `2`, `3` e `4`.
+Ad esempio, `5` è primo perchè non può essere diviso senza resto da `2`, `3` o `4`.
 
-**scrivi un codice che stampa i numeri primi nell'interballo da `2` a `n`.**
+**scrivi un codice che mostri i numeri primi nell'intervallo da `2` a `n`.**
 
 Per `n = 10` il risultato sarà `2,3,5,7`.