Loops: while and for

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

@@ -2,7 +2,7 @@ importance: 3
 
 ---
 
-# Ultimo valor del bucle
+# Último valor del bucle
 
 ¿Cuál es el último valor alertado/mostrado por este código? ¿Por qué?
 

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

@@ -1,4 +1,4 @@
-La tarea demuestra como las formas de sufjio y prefijo pueden llevar a diferentes resultado cuando son usadas en comparaciones.
+La tarea demuestra cómo las formas de sufijo y prefijo pueden llevar a diferentes resultado cuando son usadas en comparaciones.
 
 1. **Del 1 al 4**
 
@@ -7,24 +7,24 @@ La tarea demuestra como las formas de sufjio y prefijo pueden llevar a diferente
     while (++i < 5) alert( i );
     ```
 
-    El primer valor es `i = 1`, porque primero `++i` incrementa `i` y entonces retorna el valor nuevo. Así que la primera comparación es `1 < 5` y el `alert` muestra `1`. 
+    El primer valor es `i = 1`, porque `++i` primero incrementa `i` y luego retorna el valor nuevo. Así que la primera comparación es `1 < 5` y el `alert` muestra `1`. 
 
-    Entonces siguen `2, 3, 4…` -- los valores son mostrados uno tras de otro. La comparación siempre usa el valor incrementado, porque `++` esta antes de la variable.
+    Entonces siguen `2, 3, 4…` -- los valores son mostrados uno tras otro. La comparación siempre usa el valor incrementado, porque `++` está antes de la variable.
 
-    Finalmente, `i = 4` es incrementada a `5`, la comparación `while(5 < 5)` falla, y el bucle se detiene. Asi que `5` no es mostrado.
+    Finalmente, `i = 4` es incrementada a `5`, la comparación `while(5 < 5)` falla, y el bucle se detiene. Así que `5` no es mostrado.
 2. **Del 1 al 5**
 
     ```js run
     let i = 0;
     while (i++ < 5) alert( i );
     ```
 
-    El primer valor es de nuevo `i = 1`. La forma del sufijo de `i++` incrementa `i` y entonce retorna el valor *viejo*, asi que la comparación `i++ < 5` usara `i = 0` (contrario a `++i < 5`).
+    El primer valor es de nuevo `i = 1`. La forma del sufijo de `i++` incrementa `i` y luego retorna el valor *viejo*, así que la comparación `i++ < 5` usará `i = 0` (contrario a `++i < 5`).
 
-    Pero la llamada a `alert` esta separda. Es otra declaración la cual se ejecuta luego del increment y la comparación. Asi que obtiene el `i = 1` actual.
+    Pero la llamada a `alert` está separada. Es otra declaración la cual se ejecuta luego del incremento y la comparación. Asi que obtiene el `i = 1` actual.
 
     Luego siguen `2, 3, 4…`
 
-    Vamos a parar en `i = 4`. La forma del prefijo `++i` lo incrementaria y usaria `5` en la comparación. Pero aqui tenemos la forma del sufijo `i++`. Asi que incrementa `i` a `5`, pero retorna el valor viejo. Por lo tanto, la comparación es en realidad `while(4 < 5)` -- verdadero, y el control sigue a `alert`.
+    Detengámonos en `i = 4`. La forma del prefijo `++i` lo incrementaría y usaría `5` en la comparación. Pero aquí tenemos la forma del sufijo `i++`. Así que incrementa `i` a `5`, pero retorna el valor viejo. Por lo tanto, la comparación es en realidad `while(4 < 5)` -- verdadero, y el control sigue a `alert`.
 
     El valor `i = 5` es el último, porque el siguiente paso `while(5 < 5)` es falso.

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

@@ -2,11 +2,11 @@ importance: 4
 
 ---
 
-# ¿Qué valores seran mostrados por el bucle while?
+# ¿Qué valores serán mostrados por el bucle while?
 
-Para cada iteración del bucle, escribe cual valor sera impreso y entonces comparalo con la solución.
+Para cada iteración del bucle, escribe que valor sera impreso y luego comparalo con la solución.
 
-¿Para cada bucle se alertan los mismos valores o no?
+Ambos bucles ¿`alertan` los mismos valores?
 
 1. La forma de prefijo `++i`:
 

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

@@ -1,17 +1,17 @@
-**La respuesta: de `0 `a `4` en ambaos casos.**
+**La respuesta: de `0 `a `4` en ambos casos.**
 
 ```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`:
+Eso puede ser fácilmente deducido de el algoritmo de `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. Ejecutar `i = 0` una vez antes de todo (comienzo).
+2. Comprobar la condición `i <  5`.
+3. Si `true` -- ejecutar el cuerpo del bucle `alert(i)` y luego `i++`.
 
-The increment `i++` is separated from the condition check (2). That's just another statement.
+El incremento `i++` es separado de la comprobación de la condición (2). Es simplemente otra declaración.
 
-The value returned by the increment is not used here, so there's no difference between `i++` and `++i`.
+El valor retornado por el incremento no es usado aquí, así que no hay diferencia entre `i++` y `++i`.

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

@@ -2,11 +2,11 @@ importance: 4
 
 ---
 
-# ¿Qué valores seran mostrados por el bucle "for"?
+# ¿Qué valores serán mostrados por el bucle "for"?
 
-Para cada bucle anota que valores va a mostrar. Entonces compara con la respuesta.
+Para cada bucle anota qué valores mostrará y luego compara con la respuesta.
 
-¿Ambos bucles alertan los mismos valores o no?
+Ambos bucles ¿`alertan` los mismos valores?
 
 1. La forma del sufijo:
 

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

@@ -8,4 +8,4 @@ for (let i = 2; i <= 10; i++) {
 }
 ```
 
-Usamos el operador modulo `%` para conseguir el residuo y que los valores son pares.
+Usamos el operador "modulo" `%` para conseguir el residuo y comprobar que la paridad.

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

@@ -2,8 +2,8 @@ importance: 5
 
 ---
 
-# Produce números pares en el bucle
+# Muestra números pares en el bucle
 
-Usa el bucle `for` para producir números pares del `2` al `10`.
+Usa el bucle `for` para mostrar números pares del `2` al `10`.
 
 [demo]

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

@@ -4,7 +4,7 @@ importance: 5
 
 # Reemplaza "for" por "while"
 
-Reescribe el código cambiando el bucle `for` a `while` sin alterar su comportamient (la salida deberia ser la misma).
+Reescribe el código cambiando el bucle `for` a `while` sin alterar su comportamiento (la salida debería ser la misma).
 
 ```js run
 for (let i = 0; i < 3; i++) {

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

@@ -7,9 +7,9 @@ do {
 } while (num <= 100 && num);
 ```
 
-El bucle `do..while` se repite mientras ambas comprobaciones sean valores verdaderos:
+El bucle `do..while` se repite mientras ambas mientras ambas condiciones sean verdaderas:
 
-1. La comprobación para `num <= 100` -- eso es, el valor ingresado aún no es mayor que `100`.
-2. La comprobación `&& num` es falsa cuando `num` es `null` o una cadena de texto vacia. Entonces el bucle `while` se detiene tambien.
+1. La condición `num <= 100` -- eso es, el valor ingresado aún no es mayor que `100`.
+2. La condición `&& num` es falsa cuando `num` es `null` o una cadena de texto vaciá. Entonces el bucle `while` se detiene también.
 
-PD. Si `num` es `null` entonces `num <= 100` es `true`, asi que sin la segunda comprabación el bucle no se detendria si el usuario hace click en CANCELAR. Ambas comprobaciones son requreridas.
+PD. Si `num` es `null` entonces `num <= 100` es `true`, así que sin la segunda condición el bucle no se detendría si el usuario hace click en CANCELAR. Ambas comprobaciones son requeridas.

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

@@ -4,10 +4,10 @@ importance: 5
 
 # Repite hasta que la entrada sea correcta
 
-Escribe un bucle que solicita un número mayor que `100`. Si el visitante ingresa otro número -- pideles que ingresen un valor de nuevo.
+Escribe un bucle que solicita un número mayor que `100`. Si el usuario ingresa otro número -- pídele que ingrese un valor de nuevo.
 
-El bucle debe pedir por un número hasta que o el visitante ingrese un número mayor que `100` o cancele la entrada/ingresa un la linea vacía.
+El bucle debe pedir por un número hasta que el usuario ingrese un número mayor que `100` o bien cancele la entrada/ingresa un la linea vacía.
 
-Aquí podemos asumir que el visitante solo ingresara números. No hay necesidad de implementar un manejo especial para entradas no numéricas en esta tarea.
+Aquí podemos asumir que el usuario solo ingresará números. No hay necesidad de implementar un manejo especial para entradas no numéricas en esta tarea.
 
 [demo]

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

@@ -1,28 +1,28 @@
 Hay muchos algoritmos para esta tarea.
 
-Vamos a usar un bucle anidado.
+Usemos un bucle anidado.
 
 ```js
 Por cada i en el intervalo {
   comprobar si i tiene un divisor en 1..i
-  si sí => el valor no es un primo
-  si no => el valor es un primo, enséñalo
+  si tiene => el valor no es un primo
+  si no => el valor es un primo, mostrarlo
 }
 ```
-El codigo usando una etiqueta:
+El código usando una etiqueta:
 
 ```js run
 let n = 10;
 
 nextPrime:
 for (let i = 2; i <= n; i++) { // por cada i...
 
-  for (let j = 2; j < i; j++) { // buscar por un divisor..
-    if (i % j == 0) continue nextPrime; // no es un primo, ir al proximo i
+  for (let j = 2; j < i; j++) { // buscar un divisor..
+    if (i % j == 0) continue nextPrime; // no es primo, ir al próximo i
   }
 
-  alert( i ); // un primo
+  alert( i ); // primo
 }
 ```
 
-Hay un monton de espacio para optimizarlo. Por ejemplo, podriamos buscar por divisores desde `2` hasta la raíz cuadrada de `i`. Pero de todas formas, si queremos ser realmente eficientes para intervalos grandes, tenemos que cambiar el enfoque y confiar en matemáticas avanzadas y algoritmos complejos como [Criba cuadrática](https://es.wikipedia.org/wiki/Criba_cuadr%C3%A1tica), [Criba general del cuerpo de números](https://es.wikipedia.org/wiki/Criba_general_del_cuerpo_de_n%C3%BAmeros) etc.
+Hay mucho lugar para la mejora. Por ejemplo, podríamos buscar por divisores desde `2` hasta la raíz cuadrada de `i`. Pero de todas formas, si queremos ser realmente eficientes para intervalos grandes, necesitamos cambiar el enfoque y confiar en matemáticas avanzadas y algoritmos complejos como [Criba cuadrática](https://es.wikipedia.org/wiki/Criba_cuadr%C3%A1tica), [Criba general del cuerpo de números](https://es.wikipedia.org/wiki/Criba_general_del_cuerpo_de_n%C3%BAmeros) etc.

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

@@ -4,14 +4,14 @@ importance: 3
 
 # Muestra números primos
 
-Un número entero mayor que `1` es llamado [primo](https://es.wikipedia.org/wiki/N%C3%BAmero_primo) si no puede ser divido sin un residuo por cualquier número excepto `1` y el mismo.
+Un número entero mayor que `1` es llamado [primo](https://es.wikipedia.org/wiki/N%C3%BAmero_primo) si no puede ser dividido sin un residuo por ningún número excepto `1` y él mismo.
 
-En otras palabras, `n > 1` es un primo si no puede ser divido parejamente por cualquier número except `1` y `n`.
+En otras palabras, `n > 1` es un primo si no puede ser divido exactamente por ningún número excepto `1` y `n`.
 
-Por ejemplo, `5` es un primo, porque no puede ser divido sin un residuo por `2`, `3` y `4`.
+Por ejemplo, `5` es un primo, porque no puede ser divido exactamente por `2`, `3` y `4`.
 
-**Escribe el código que muestra números primos en el intervalo de `2` a `n`.**
+**Escribe el código que muestre números primos en el intervalo de `2` a `n`.**
 
-Para `n = 10` el resultado sera `2, 3, 5, 7`.
+Para `n = 10` el resultado será `2, 3, 5, 7`.
 
-PD. El código deberia funcionar para cualquier `n`, no debe estar programado para valores fijos.
+PD. El código debería funcionar para cualquier `n`, no debe estar programado para valores fijos.