Sep 9, 2019 · May 21, 2019 · May 21, 2019 · May 24, 2019 · May 25, 2019 · May 29, 2019
diff --git a/1-js/02-first-steps/12-while-for/1-loop-last-value/solution.md b/1-js/02-first-steps/12-while-for/1-loop-last-value/solution.md
 The answer: `1`.
 La respuesta: `1`.

 ```js run
 let i = 3;
 }
 ```

 Every loop iteration decreases`i`by `1`.The check `while(i)`stops the loop when `i = 0`.
 Cada iteración del bucle disminuye`i`en `1`.La comprobación `while(i)`detiene el bucle cuando `i = 0`.

 Hence, the steps of the loop form the following sequence ("loop unrolled"):
 Por consiguiente, los pasos del bucle forman la siguiente secuencia ("bucle desenrollado").

 ```js
 let i = 3;

 alert(i--); //shows 3,decreases ito 2
 alert(i--); //muestra 3,disminuye ia 2

 alert(i--) //shows 2,decreases ito 1
 alert(i--) //muestra 2,disminuye ia 1

 alert(i--) //shows 1,decreases ito 0
 alert(i--) //muestra 1,disminuye ia 0

 //done, while(i)check stops the loop
 //listo, while(i)comprueba y detiene el bucle
 ```
diff --git a/1-js/02-first-steps/12-while-for/1-loop-last-value/task.md b/1-js/02-first-steps/12-while-for/1-loop-last-value/task.md

 ---

 #Last loop value
 #Último valor del bucle

 What is the last value alerted by this code? Why?
 ¿Cuál es el último valor alertado/mostrado por este código? ¿Por qué?

 ```js
 let i = 3;
diff --git a/1-js/02-first-steps/12-while-for/2-which-value-while/solution.md b/1-js/02-first-steps/12-while-for/2-which-value-while/solution.md
 The task demonstrates how postfix/prefix forms can lead to different results when used in comparisons.
 La tarea demuestra cómo las formas de sufijo y prefijo pueden llevar a diferentes resultados cuando son usadas en comparaciones.

 1. **From 1to 4**
 1. **Del 1al 4**

    ```js run
    let i = 0;
    while (++i < 5) alert( i );
    ```

 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`.
 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`.

 Then follow `2, 3, 4…` --the values show up one after another. The comparison always uses the incremented value, because `++`is before the 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.

 Finally, `i = 4`is incremented to `5`,the comparison `while(5 < 5)`fails, and the loop stops. So`5`is not shown.
 2. **From 1to 5**
 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 1al 5**

    ```js run
    let i = 0;
    while (i++ < 5) alert( i );
    ```

 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`).
 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`).

 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`.
 Pero la llamada a`alert`está separada. Es otra declaración, la cual se ejecuta luego del incremento y la comparación. Así que obtiene el`i = 1` actual.

 Then follow `2, 3, 4…`
 Luego siguen `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 controlgoes on to `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 controlsigue a `alert`.

 The value `i = 5`is the last one, because on the next step`while(5 < 5)`is false.
 El valor `i = 5`es el último, porque el siguiente paso`while(5 < 5)`es falso.
diff --git a/1-js/02-first-steps/12-while-for/2-which-value-while/task.md b/1-js/02-first-steps/12-while-for/2-which-value-while/task.md

 ---

 #Which values does the while loop show?
 #¿Qué valores serán mostrados por el bucle while?

 For every loop iteration, write down which value it outputs and then compare it with the solution.
 Para cada iteración del bucle, escribe qué valor será impreso y luego compáralo con la solución.

 Both loops `alert` the same values, or not?
 Ambos bucles ¿`alertan` los mismos valores?

 1.The prefix form `++i`:
 1.La forma de prefijo `++i`:

    ```js
    let i = 0;
    while (++i < 5) alert( i );
    ```
 2.The postfix form `i++`
 2.La forma de sufijo `i++`

    ```js
    let i = 0;
diff --git a/1-js/02-first-steps/12-while-for/3-which-value-for/solution.md b/1-js/02-first-steps/12-while-for/3-which-value-for/solution.md
 **The answer: from `0` to`4`in both cases.**
 **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 del 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 nodifference between`i++`and `++i`.
 El valor retornado por el incremento no es usado aquí, así que nohay diferencia entre`i++`y `++i`.
diff --git a/1-js/02-first-steps/12-while-for/3-which-value-for/task.md b/1-js/02-first-steps/12-while-for/3-which-value-for/task.md

 ---

 #Which values get shown by the"for" loop?
 #¿Qué valores serán mostrados por el bucle"for"?

 For each loop write down which values it is going to show. Then compare with the answer.
 Para cada bucle, anota qué valores mostrará y luego compara las respuestas.

 Both loops `alert` same values or not?
 Ambos bucles ¿`alertan` los mismos valores?

 1.The postfix form:
 1.La forma del sufijo:

    ```js
    for (let i = 0; i < 5; i++) alert( i );
    ```
 2.The prefix form:
 2.La forma del prefijo:

    ```js
    for (let i = 0; i < 5; ++i) alert( i );
diff --git a/1-js/02-first-steps/12-while-for/4-for-even/solution.md b/1-js/02-first-steps/12-while-for/4-for-even/solution.md
 }
 ```

 We use the "modulo"operator`%`to get the remainder and check for the evenness here.
 Usamos el operador "modulo" `%`para conseguir el resto y comprobar la paridad.
diff --git a/1-js/02-first-steps/12-while-for/4-for-even/task.md b/1-js/02-first-steps/12-while-for/4-for-even/task.md

 ---

 #Output even numbers in the loop
 #Muestra números pares en el bucle

 Use the`for`loop to output even numbers from`2`to `10`.
 Usa el bucle`for`para mostrar números pares del`2`al `10`.

 [demo]
diff --git a/1-js/02-first-steps/12-while-for/5-replace-for-while/solution.md b/1-js/02-first-steps/12-while-for/5-replace-for-while/solution.md
 ```js run
 let i = 0;
 while (i < 3) {
  alert( `number ${i}!` );
  alert( `número ${i}!` );
  i++;
 }
 ```
diff --git a/1-js/02-first-steps/12-while-for/5-replace-for-while/task.md b/1-js/02-first-steps/12-while-for/5-replace-for-while/task.md

 ---

 #Replace "for"with "while"
 #Reemplaza "for"por "while"

 Rewrite the code changing the`for`loop to`while`without altering its behavior (the output should stay same).
 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++) {
  alert( `number ${i}!` );
  alert( `número ${i}!` );
 }
 ```

diff --git a/1-js/02-first-steps/12-while-for/6-repeat-until-correct/solution.md b/1-js/02-first-steps/12-while-for/6-repeat-until-correct/solution.md
 let num;

 do {
  num = prompt("Enter a number greater than 100?", 0);
  num = prompt("Ingresa un número mayor a 100", 0);
 } while (num <= 100 && num);
 ```

 The loop `do..while`repeats while both checks are truthy:
 El bucle `do..while`se repite mientras ambas condiciones sean verdaderas:

 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 a empty string. Then the`while`loop stops too.
 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.

 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.
 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.
diff --git a/1-js/02-first-steps/12-while-for/6-repeat-until-correct/task.md b/1-js/02-first-steps/12-while-for/6-repeat-until-correct/task.md

 ---

 #Repeat until the input is correct
 #Repite hasta que la entrada sea correcta

 Write a loop which prompts for a number greater than`100`.If the visitor enters another number --ask them to input again.
 Escribe un bucle que solicite un número mayor que`100`.Si el usuario ingresa otro número --pídele que ingrese un valor de nuevo.

 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.
 El bucle debe pedir un número hasta que el usuario ingrese un número mayor que`100`o bien cancele la entrada/ingrese una linea vacía.

 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.
 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]
diff --git a/1-js/02-first-steps/12-while-for/7-list-primes/solution.md b/1-js/02-first-steps/12-while-for/7-list-primes/solution.md
 There are many algorithms for this task.
 Hay muchos algoritmos para esta tarea.

 Let's use a nested loop:
 Usemos un bucle anidado.

 ```js
 For each iin the interval {
 check if ihas a divisorfrom 1..i
 if yes =>the value is not a prime
 if no =>the value is a prime, show it
 Por cada ien el intervalo {
 comprobar si itiene un divisoren 1..i
 si tiene =>el valor no es un primo
 si no =>el valor es un primo, mostrarlo
 }
 ```

 The code using a label:
 El código usando una etiqueta:

 ```js run
 let n = 10;

 nextPrime:
 for (let i = 2; i <= n; i++) { //for each i...
 for (let i = 2; i <= n; i++) { //por cada 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++) { //buscar un divisor..
    if (i % j == 0) continue nextPrime; //no es primo, ir al próximo i
  }

  alert( i ); //a prime
  alert( i ); //primo
 }
 ```

 There's a lot of space to opimize 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.
 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.
diff --git a/1-js/02-first-steps/12-while-for/7-list-primes/task.md b/1-js/02-first-steps/12-while-for/7-list-primes/task.md

 ---

 #Output prime numbers
 #Muestra números primos

 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 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 resto por ningún número excepto`1`y él mismo.

 In other words, `n > 1`is a prime if it can't be evenly divided by anything except`1`and `n`.
 En otras palabras, `n > 1`es un primo si no puede ser divido exactamente por ningún número excepto`1`y `n`.

 For example, `5`is a prime, because it cannot be divided without a remainder by`2`, `3`and `4`.
 Por ejemplo, `5`es un primo, porque no puede ser divido exactamente por`2`, `3`y `4`.

 **Write the code which outputs prime numbers in the interval from `2`to `n`.**
 **Escribe el código que muestre números primos en el intervalo de `2`a `n`.**

 For `n = 10`the result will be`2,3,5,7`.
 Para `n = 10`el resultado será`2, 3, 5,7`.

 P.S. The code should work for any `n`,not be hard-tuned for any fixed value.
 PD. El código debería funcionar para cualquier `n`,no debe estar programado para valores fijos.
Original file line number	Diff line number	Diff line change
		@@ -1,4 +1,4 @@
		The answer: `1`.
		La respuesta: `1`.

		```js run
		let i = 3;
Expand All		@@ -8,18 +8,18 @@ while (i) {
		}
		```

		Every loop iteration decreases`i`by `1`.The check `while(i)`stops the loop when `i = 0`.
		Cada iteración del bucle disminuye`i`en `1`.La comprobación `while(i)`detiene el bucle cuando `i = 0`.

		Hence, the steps of the loop form the following sequence ("loop unrolled"):
		Por consiguiente, los pasos del bucle forman la siguiente secuencia ("bucle desenrollado").

		```js
		let i = 3;

		alert(i--); //shows 3,decreases ito 2
		alert(i--); //muestra 3,disminuye ia 2

		alert(i--) //shows 2,decreases ito 1
		alert(i--) //muestra 2,disminuye ia 1

		alert(i--) //shows 1,decreases ito 0
		alert(i--) //muestra 1,disminuye ia 0

		//done, while(i)check stops the loop
		//listo, while(i)comprueba y detiene el bucle
		```
Original file line number	Diff line number	Diff line change
Expand Up		@@ -2,9 +2,9 @@ importance: 3

		---

		#Last loop value
		#Último valor del bucle

		What is the last value alerted by this code? Why?
		¿Cuál es el último valor alertado/mostrado por este código? ¿Por qué?

		```js
		let i = 3;
Expand Down
Original file line number	Diff line number	Diff line change
		@@ -1,30 +1,30 @@
		The task demonstrates how postfix/prefix forms can lead to different results when used in comparisons.
		La tarea demuestra cómo las formas de sufijo y prefijo pueden llevar a diferentes resultados cuando son usadas en comparaciones.

		1. From 1to 4
		1. Del 1al 4

		```js run
		let i = 0;
		while (++i < 5) alert( i );
		```

		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`.
		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`.

		Then follow `2, 3, 4…` --the values show up one after another. The comparison always uses the incremented value, because `++`is before the 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.

		Finally, `i = 4`is incremented to `5`,the comparison `while(5 < 5)`fails, and the loop stops. So`5`is not shown.
		2. From 1to 5
		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 1al 5

		```js run
		let i = 0;
		while (i++ < 5) alert( i );
		```

		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`).
		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`).

		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`.
		Pero la llamada a`alert`está separada. Es otra declaración, la cual se ejecuta luego del incremento y la comparación. Así que obtiene el`i = 1` actual.

		Then follow `2, 3, 4…`
		Luego siguen `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 controlgoes on to `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 controlsigue a `alert`.

		The value `i = 5`is the last one, because on the next step`while(5 < 5)`is false.
		El valor `i = 5`es el último, porque el siguiente paso`while(5 < 5)`es falso.
Original file line number	Diff line number	Diff line change
Expand Up		@@ -2,19 +2,19 @@ importance: 4

		---

		#Which values does the while loop show?
		#¿Qué valores serán mostrados por el bucle while?

		For every loop iteration, write down which value it outputs and then compare it with the solution.
		Para cada iteración del bucle, escribe qué valor será impreso y luego compáralo con la solución.

		Both loops `alert` the same values, or not?
		Ambos bucles ¿`alertan` los mismos valores?

		1.The prefix form `++i`:
		1.La forma de prefijo `++i`:

		```js
		let i = 0;
		while (++i < 5) alert( i );
		```
		2.The postfix form `i++`
		2.La forma de sufijo `i++`

		```js
		let i = 0;
Expand Down
Original file line number	Diff line number	Diff line change
		@@ -1,17 +1,17 @@
		The answer: from `0` to`4`in both cases.
		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 del 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 nodifference between`i++`and `++i`.
		El valor retornado por el incremento no es usado aquí, así que nohay diferencia entre`i++`y `++i`.
Original file line number	Diff line number	Diff line change
Expand Up		@@ -2,18 +2,18 @@ importance: 4

		---

		#Which values get shown by the"for" loop?
		#¿Qué valores serán mostrados por el bucle"for"?

		For each loop write down which values it is going to show. Then compare with the answer.
		Para cada bucle, anota qué valores mostrará y luego compara las respuestas.

		Both loops `alert` same values or not?
		Ambos bucles ¿`alertan` los mismos valores?

		1.The postfix form:
		1.La forma del sufijo:

		```js
		for (let i = 0; i < 5; i++) alert( i );
		```
		2.The prefix form:
		2.La forma del prefijo:

		```js
		for (let i = 0; i < 5; ++i) alert( i );
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -8,4 +8,4 @@ for (let i = 2; i <= 10; i++) {
		}
		```

		We use the "modulo"operator`%`to get the remainder and check for the evenness here.
		Usamos el operador "modulo" `%`para conseguir el resto y comprobar la paridad.
Original file line number	Diff line number	Diff line change
Expand Up		@@ -2,8 +2,8 @@ importance: 5

		---

		#Output even numbers in the loop
		#Muestra números pares en el bucle

		Use the`for`loop to output even numbers from`2`to `10`.
		Usa el bucle`for`para mostrar números pares del`2`al `10`.

		[demo]
Original file line number	Diff line number	Diff line change
Expand Up		@@ -3,7 +3,7 @@
		```js run
		let i = 0;
		while (i < 3) {
		alert( `number ${i}!` );
		alert( `número ${i}!` );
		i++;
		}
		```
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -2,13 +2,13 @@ importance: 5

		---

		#Replace "for"with "while"
		#Reemplaza "for"por "while"

		Rewrite the code changing the`for`loop to`while`without altering its behavior (the output should stay same).
		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++) {
		alert( `number ${i}!` );
		alert( `número ${i}!` );
		}
		```