Oct 24, 2020 · Oct 24, 2020 · Oct 27, 2020 · Oct 27, 2020 · Oct 27, 2020 · Oct 27, 2020
diff --git a/1-js/02-first-steps/18-while-for/1-loop-last-value/solution.md b/1-js/02-first-steps/18-while-for/1-loop-last-value/solution.md
 The answer: `1`.
 Odpowiedź: `1`.

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

 Every loop iteration decreases `i`by `1`.The check`while(i)`stops the loop when `i = 0`.
 Każda obrót pętli zmniejsza `i`o `1`.Sprawdzenie`while(i)`zatrzymuje pętle kiedy `i = 0`.

 Hence, the steps of the loop form the following sequence ("loop unrolled"):
 Stąd kroki pętli tworzą następującą sekwencję ("pętla rozwijana"):

 ```js
 let i = 3;

 alert(i--); //shows 3,decreases ito 2
 alert(i--); //pokazuje 3,zmniejsza ido 2

 alert(i--) //shows 2,decreases ito 1
 alert(i--) //pokazuje 2,zmniejsza ido 1

 alert(i--) //shows 1,decreases ito 0
 alert(i--) //pokazuje 1,zmniejsza ido 0

 //done,while(i)check stops the loop
 //koniec, sprawdzeniewhile(i)zatrzymuje pętlę
 ```
diff --git a/1-js/02-first-steps/18-while-for/1-loop-last-value/task.md b/1-js/02-first-steps/18-while-for/1-loop-last-value/task.md
 importance: 3
 ważność: 3

 ---

 #Last loop value
 #Ostatnia wartość pętli

 What is the last value alerted by this code? Why?
 Jaka jest ostatnia wartość pokazana przez ten kod? Dlaczego?

 ```js
 let i = 3;
diff --git a/1-js/02-first-steps/18-while-for/2-which-value-while/solution.md b/1-js/02-first-steps/18-while-for/2-which-value-while/solution.md
 The task demonstrates howpostfix/prefixforms can lead to different results when used in comparisons.
 Zadanie pokazuje, w jaki sposób formypostfix/prefixmogą prowadzić do różnych wyników w przypadku ich wykorzystania w porównaniach.

 1. **From 1to 4**
 1. **Od 1do 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`.
 Pierwszą wartością jest`i = 1`,ponieważ `++i`najpierw powiększy `i`, a następnie zwraca nową wartość. Tak więc pierwsze porównanie jest `1 < 5`, a`alert`pokazuje `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.
 Następnie podążając `2, 3, 4...` --wartości pojawiają się jedna po drugiej. Porównanie zawsze używa zwiększonej wartości, ponieważ `++`jest przed zmienną.

 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**
 W końcu, `i = 4`jest zwiększone do `5`,porównanie`while(5 < 5)`zawodzi, a pętla się zatrzymuje. Tak więc`5`nie jest pokazane.
 2. **Od 1do 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`).
 Pierwszą wartością jest ponownie`i = 1`.Przyrostkowa forma`i++`zwiększa `i`, a następnie zwraca *starą* wartość, więc porównanie`i++ < 5`użyje`i = 0` (w przeciwieństwie do `++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`.
 Ale zawołanie `alert`jest osobne. Jest to kolejna stwierdzenie, która wykonuje się po inkrementacji i porównaniu. Więc dostaje bieżący `i = 1`.

 Then follow `2, 3, 4…`
 Potem kolejno `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`.
 Zatrzymajmy się na `i = 4`.Forma prefiksu`++i`zwiększyłaby go i użyła`5`w porównaniu. Ale tutaj mamy formę przyrostkową`i++`.Zwiększa więc`i`do `5`,ale zwraca starą wartość. Stąd porównanie`while(4 < 5)`jest prawdziwe, a kontrola przechodzi do `alert`.

 The value`i = 5`is the last one, because on the next step`while(5 < 5)`is false.
 Wartość`i = 5`jest ostatnią, ponieważ w następnym kroku`while(5 < 5)`jest fałszywe.
diff --git a/1-js/02-first-steps/18-while-for/2-which-value-while/task.md b/1-js/02-first-steps/18-while-for/2-which-value-while/task.md
 importance: 4
 ważność: 4

 ---

 #Which values does the while loop show?
 #Jakie wartości pokazuje pętla while?

 For every loop iteration, write down which value it outputs and then compare it with the solution.
 Dla każdej iteracji pętli zapisz, jaką wartość ona generuje, a następnie porównaj ją z rozwiązaniem.

 Both loops`alert` the samevalues, or not?
 Obie pętle ogłoszą (`alert`) te samewartości, czy nie?

 1.The prefix form `++i`:
 1.Forma prefiksowa `++i`:

    ```js
    let i = 0;
    while (++i < 5) alert( i );
    ```
 2.The postfix form `i++`
 2.Forma przyrostkowa (postfix) `i++`

    ```js
    let i = 0;
diff --git a/1-js/02-first-steps/18-while-for/3-which-value-for/solution.md b/1-js/02-first-steps/18-while-for/3-which-value-for/solution.md
 **The answer: from `0`to `4`in both cases.**
 **Odpowiedź: od `0`do `4`w obu przypadkach.**

 ```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`:
 Można to łatwo odczytać z algorytmu `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.Wykonać raz `i = 0`przed wszystkim (początek).
 2.Sprawdzić warunek `i < 5`
 3.jeśli `true` --wykonaj ciało pętli`alert(i)`,a potem `i++`

 The increment `i++` is separated from the condition check (2). That's just another statement.

 The value returned by the increment is not used here, so there's no difference between `i++` and `++i`.
 Przyrost `i++` jest oddzielony od sprawdzenia warunku (2). To tylko kolejne stwierdzenie.
 Wartość zwracana przez przyrost nie jest tutaj używana, więc nie ma różnicy między `i++` a `++i`.
diff --git a/1-js/02-first-steps/18-while-for/3-which-value-for/task.md b/1-js/02-first-steps/18-while-for/3-which-value-for/task.md
 importance: 4
 ważność: 4

 ---

 #Which values get shown by the"for" loop?
 #Jakie wartości pokazuje pętla"for"?

 For each loop write down which values it is going to show. Then compare with the answer.
 Dla każdej pętli zapisz, jakie wartości ma ona pokazywać. Następnie porównaj z odpowiedzią.

 Both loops`alert`samevalues or not?
 Obie pętle ogłaszają (`alert`) tesamewartości, czy nie?

 1.The postfix form:
 1.Forma przyrostkowa:

    ```js
    for (let i = 0; i < 5; i++) alert( i );
    ```
 2.The prefix form:
 2.Forma prefixowa:

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

 We use the"modulo"operator`%`to get the remainder and check for the evenness here.
 Używamy operatora"modulo" `%`aby uzyskać resztę i sprawdzić tutaj równomierność.
diff --git a/1-js/02-first-steps/18-while-for/4-for-even/task.md b/1-js/02-first-steps/18-while-for/4-for-even/task.md
 importance: 5
 ważność: 5

 ---

 #Output even numbers in the loop
 #Zwróć numery parzyste w pętli

 Use the `for`loop to output even numbers from`2`to `10`.
 Użyj pętli `for`do wyprowadzenia parzystych liczb od`2`do `10`.

 [demo]
diff --git a/1-js/02-first-steps/18-while-for/5-replace-for-while/solution.md b/1-js/02-first-steps/18-while-for/5-replace-for-while/solution.md
 ```js run
 let i = 0;
 while (i < 3) {
  alert( `number ${i}!` );
  alert( `liczba ${i}!` );
  i++;
 }
 ```
diff --git a/1-js/02-first-steps/18-while-for/5-replace-for-while/task.md b/1-js/02-first-steps/18-while-for/5-replace-for-while/task.md
 importance: 5
 ważność: 5

 ---

 #Replace "for"with "while"
 #Zastąp "for"pętlą "while"

 Rewrite the code changing the `for`loop to`while`without altering its behavior (the output should stay same).
 Przepisz ponownie kod zmieniając pętlę `for`na`while`bez zmiany jej zachowania (wyjście powinno pozostać takie samo).

 ```js run
 for (let i = 0; i < 3; i++) {
  alert( `number ${i}!` );
  alert( `liczba ${i}!` );
 }
 ```

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

 do {
  num = prompt("Enter a number greater than 100?", 0);
  num = prompt("Wprowadź liczbę większą niż 100?", 0);
 } while (num <= 100 && num);
 ```

 The loop`do..while`repeats while both checks are truthy:
 Pętla`do...while`powtarza się, podczas gdy oba sprawdzenia są prawdziwe:

 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.1. Sprawdzenie, czy `num <= 100` --to znaczy, że wprowadzona wartość jest wciąż nie większa niż `100`.
 2.Sprawdzanie`&& num`jest fałszywe, gdy `num`ma wartość`null`lub jest pustym stringiem. Wtedy pętla `while`też się zatrzymuje.

 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.Jeśli `num`ma wartość`null`to `num <= 100`ma wartość`true`,więc bez drugiego sprawdzenia pętla nie zatrzymałaby się, gdyby użytkownik kliknął PRZERWIJ. Oba sprawdzenia są wymagane.
diff --git a/1-js/02-first-steps/18-while-for/6-repeat-until-correct/task.md b/1-js/02-first-steps/18-while-for/6-repeat-until-correct/task.md
 importance: 5
 ważność: 5

 ---

 #Repeat until the input is correct
 #Powtarzaj do momentu, aż wejście będzie prawidłowe

 Write a loop which prompts for a number greater than`100`.If the visitor enters another number -- ask them to input again.
 Napisz pętlę, która pyta o liczbę większą niż`100`.Jeśli odwiedzający wprowadzi inną liczbę - poproś go o jej ponowne wprowadzenie.

 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.
 Pętla musi pytać o liczbę, dopóki użytkownik nie wprowadzi liczby większej niż`100`lub nie anuluje wejścia/wprowadzi pustą linię.

 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.
 Tutaj możemy założyć, że odwiedzający wprowadza tylko numery. Nie ma potrzeby implementowania specjalnej obsługi dla nie-numerycznych danych wejściowych w tym zadaniu.

 [demo]
diff --git a/1-js/02-first-steps/18-while-for/7-list-primes/solution.md b/1-js/02-first-steps/18-while-for/7-list-primes/solution.md
 There are many algorithms for this task.
 Istnieje wiele algorytmów dla tego zadania.

 Let's use a nested loop:
 Użyjmy pętli zagnieżdżonej:

 ```js
 For each iin the interval {
 check if ihas a divisor from 1..i
 if yes =>the value is not a prime
 if no =>the value is a prime, show it
 Dla każdego iw przedziale {
 sprawdź jeśli ima dzielnik od 1..i
 jeśli tak =>wartość nie jest liczbą pierwszą
 jeśli nie =>wartość jest liczbą pierwszą, pokaż ją
 }
 ```

 The code using a label:
 Kod używając etykiety:

 ```js run
 let n = 10;

 nextPrime:
 for (let i = 2; i <= n; i++) { //for each i...
 for (let i = 2; i <= n; i++) { //dla każdego 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++) { //szukaj dziewlnika..
    if (i % j == 0) continue nextPrime; //nie liczba pierwsza idź do następnego i
  }

  alert( i ); //a prime
  alert( i ); //liczba pierwsza
 }
 ```

 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.
 Jest dużo miejsca na optymalizację. Na przykład, możemy szukać dzielników od`2`do pierwiastka kwadratowego`i`.Ale tak czy inaczej, jeśli chcemy być naprawdę wydajni w dużych odstępach czasu, musimy zmienić podejście i polegać na zaawansowanych matematykach i złożonych algorytmach, takich jak [Sito kwadratowe](https://pl.wikipedia.org/wiki/Sito_kwadratowe), [Ogólne sito ciała liczbowego](https://pl.wikipedia.org/wiki/GNFS) itd.
diff --git a/1-js/02-first-steps/18-while-for/7-list-primes/task.md b/1-js/02-first-steps/18-while-for/7-list-primes/task.md
 importance: 3
 ważność: 3

 ---

 #Output prime numbers
 #Zwróć liczby pierwsze

 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.
 Liczba całkowita większa od`1`nazywana jest [liczbą pierwszą](https://pl.wikipedia.org/wiki/Liczba_pierwsza), jeśli nie może być podzielona bez reszty przez nic poza`1`i samą siebie.

 In other words, `n > 1`is a prime if it can't be evenly divided by anything except `1`and `n`.
 Innymi słowy, `n > 1`jest liczbą pierwszą, jeśli nie można jej równo podzielić przez nic poza `1`i `n`.

 For example, `5`is a prime, because it cannot be divided without a remainder by`2`, `3`and `4`.
 Na przykład, `5`jest liczbą pierwszą, ponieważ nie można jej podzielić bez reszty przez`2`, `3`i `4`.

 **Write the code which outputs prime numbers in the interval from`2`to `n`.**
 **Napisz kod, który wyprowadza liczby pierwsze w przedziale od`2`do `n`.**

 For `n = 10`the result will be `2,3,5,7`.
 Dla `n = 10`wynik będzie `2,3,5,7`.

 P.S.The code should work for any`n`,not be hard-tuned for any fixed value.
 P.S.Kod powinien działać dla każdego`n`,nie powinien być dostosowany na stałe do żadnej wartości.
Original file line number	Diff line number	Diff line change
		@@ -1,4 +1,4 @@
		The answer: `1`.
		Odpowiedź: `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`.
		Każda obrót pętli zmniejsza `i`o `1`.Sprawdzenie`while(i)`zatrzymuje pętle kiedy `i = 0`.

		Hence, the steps of the loop form the following sequence ("loop unrolled"):
		Stąd kroki pętli tworzą następującą sekwencję ("pętla rozwijana"):

		```js
		let i = 3;

		alert(i--); //shows 3,decreases ito 2
		alert(i--); //pokazuje 3,zmniejsza ido 2

		alert(i--) //shows 2,decreases ito 1
		alert(i--) //pokazuje 2,zmniejsza ido 1

		alert(i--) //shows 1,decreases ito 0
		alert(i--) //pokazuje 1,zmniejsza ido 0

		//done,while(i)check stops the loop
		//koniec, sprawdzeniewhile(i)zatrzymuje pętlę
		```
Original file line number	Diff line number	Diff line change
		@@ -1,10 +1,10 @@
		importance: 3
		ważność: 3
Copy link Member deivuss331Oct 16, 2021 Choose a reason for hiding this comment The reason will be displayed to describe this comment to others.Learn more. Please do not translate YAML metadata

		---

		#Last loop value
		#Ostatnia wartość pętli

		What is the last value alerted by this code? Why?
		Jaka jest ostatnia wartość pokazana przez ten kod? Dlaczego?

		```js
		let i = 3;
Expand Down
Original file line number	Diff line number	Diff line change
		@@ -1,30 +1,30 @@
		The task demonstrates howpostfix/prefixforms can lead to different results when used in comparisons.
		Zadanie pokazuje, w jaki sposób formypostfix/prefixmogą prowadzić do różnych wyników w przypadku ich wykorzystania w porównaniach.

		1. From 1to 4
		1. Od 1do 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`.
		Pierwszą wartością jest`i = 1`,ponieważ `++i`najpierw powiększy `i`, a następnie zwraca nową wartość. Tak więc pierwsze porównanie jest `1 < 5`, a`alert`pokazuje `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.
		Następnie podążając `2, 3, 4...` --wartości pojawiają się jedna po drugiej. Porównanie zawsze używa zwiększonej wartości, ponieważ `++`jest przed zmienną.

		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
		W końcu, `i = 4`jest zwiększone do `5`,porównanie`while(5 < 5)`zawodzi, a pętla się zatrzymuje. Tak więc`5`nie jest pokazane.
		2. Od 1do 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`).
		Pierwszą wartością jest ponownie`i = 1`.Przyrostkowa forma`i++`zwiększa `i`, a następnie zwraca starą wartość, więc porównanie`i++ < 5`użyje`i = 0` (w przeciwieństwie do `++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`.
		Ale zawołanie `alert`jest osobne. Jest to kolejna stwierdzenie, która wykonuje się po inkrementacji i porównaniu. Więc dostaje bieżący `i = 1`.

		Then follow `2, 3, 4…`
		Potem kolejno `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`.
		Zatrzymajmy się na `i = 4`.Forma prefiksu`++i`zwiększyłaby go i użyła`5`w porównaniu. Ale tutaj mamy formę przyrostkową`i++`.Zwiększa więc`i`do `5`,ale zwraca starą wartość. Stąd porównanie`while(4 < 5)`jest prawdziwe, a kontrola przechodzi do `alert`.

		The value`i = 5`is the last one, because on the next step`while(5 < 5)`is false.
		Wartość`i = 5`jest ostatnią, ponieważ w następnym kroku`while(5 < 5)`jest fałszywe.
Original file line number	Diff line number	Diff line change
		@@ -1,20 +1,20 @@
		importance: 4
		ważność: 4
Copy link Member deivuss331Oct 16, 2021 Choose a reason for hiding this comment The reason will be displayed to describe this comment to others.Learn more. Please do not translate YAML metadata

		---

		#Which values does the while loop show?
		#Jakie wartości pokazuje pętla while?

		For every loop iteration, write down which value it outputs and then compare it with the solution.
		Dla każdej iteracji pętli zapisz, jaką wartość ona generuje, a następnie porównaj ją z rozwiązaniem.

		Both loops`alert` the samevalues, or not?
		Obie pętle ogłoszą (`alert`) te samewartości, czy nie?

		1.The prefix form `++i`:
		1.Forma prefiksowa `++i`:

		```js
		let i = 0;
		while (++i < 5) alert( i );
		```
		2.The postfix form `i++`
		2.Forma przyrostkowa (postfix) `i++`

		```js
		let i = 0;
Expand Down
Original file line number	Diff line number	Diff line change
		@@ -1,17 +1,16 @@
		The answer: from `0`to `4`in both cases.
		Odpowiedź: od `0`do `4`w obu przypadkach.

		```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`:
		Można to łatwo odczytać z algorytmu `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.Wykonać raz `i = 0`przed wszystkim (początek).
		2.Sprawdzić warunek `i < 5`
		3.jeśli `true` --wykonaj ciało pętli`alert(i)`,a potem `i++`

		The increment `i++` is separated from the condition check (2). That's just another statement.

		The value returned by the increment is not used here, so there's no difference between `i++` and `++i`.
		Przyrost `i++` jest oddzielony od sprawdzenia warunku (2). To tylko kolejne stwierdzenie.
		Wartość zwracana przez przyrost nie jest tutaj używana, więc nie ma różnicy między `i++` a `++i`.
Copy link Member deivuss331Oct 16, 2021 Choose a reason for hiding this comment The reason will be displayed to describe this comment to others.Learn more. Please add a blank line between line 15 and 16
Original file line number	Diff line number	Diff line change
		@@ -1,19 +1,19 @@
		importance: 4
		ważność: 4
Copy link Member deivuss331Oct 16, 2021 Choose a reason for hiding this comment The reason will be displayed to describe this comment to others.Learn more. Please do not translate YAML metadata

		---

		#Which values get shown by the"for" loop?
		#Jakie wartości pokazuje pętla"for"?

		For each loop write down which values it is going to show. Then compare with the answer.
		Dla każdej pętli zapisz, jakie wartości ma ona pokazywać. Następnie porównaj z odpowiedzią.

		Both loops`alert`samevalues or not?
		Obie pętle ogłaszają (`alert`) tesamewartości, czy nie?

		1.The postfix form:
		1.Forma przyrostkowa:

		```js
		for (let i = 0; i < 5; i++) alert( i );
		```
		2.The prefix form:
		2.Forma prefixowa:

		```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.
		Używamy operatora"modulo" `%`aby uzyskać resztę i sprawdzić tutaj równomierność.
Original file line number	Diff line number	Diff line change
		@@ -1,9 +1,9 @@
		importance: 5
		ważność: 5
Copy link Member deivuss331Oct 16, 2021 Choose a reason for hiding this comment The reason will be displayed to describe this comment to others.Learn more. Please do not translate YAML metadata

		---

		#Output even numbers in the loop
		#Zwróć numery parzyste w pętli

		Use the `for`loop to output even numbers from`2`to `10`.
		Użyj pętli `for`do wyprowadzenia parzystych liczb od`2`do `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( `liczba ${i}!` );
		i++;
		}
		```
Expand Down
Original file line number	Diff line number	Diff line change
		@@ -1,14 +1,14 @@
		importance: 5
		ważność: 5
Copy link Member deivuss331Oct 16, 2021 Choose a reason for hiding this comment The reason will be displayed to describe this comment to others.Learn more. Please do not translate YAML metadata

		---

		#Replace "for"with "while"
		#Zastąp "for"pętlą "while"

		Rewrite the code changing the `for`loop to`while`without altering its behavior (the output should stay same).
		Przepisz ponownie kod zmieniając pętlę `for`na`while`bez zmiany jej zachowania (wyjście powinno pozostać takie samo).

		```js run
		for (let i = 0; i < 3; i++) {
		alert( `number ${i}!` );
		alert( `liczba ${i}!` );
		}
		```