From e4765a45d069b0e58459e4e665b2c0ba4a3d970e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=81lvaro=20Antonio?= Date: Wed, 4 Sep 2019 17:10:14 -0300 Subject: [PATCH 01/13] Translate while-for loops --- .../1-loop-last-value/solution.md | 14 +- .../12-while-for/1-loop-last-value/task.md | 4 +- .../2-which-value-while/solution.md | 24 +- .../12-while-for/2-which-value-while/task.md | 10 +- .../3-which-value-for/solution.md | 14 +- .../12-while-for/3-which-value-for/task.md | 10 +- .../12-while-for/4-for-even/solution.md | 2 +- .../12-while-for/4-for-even/task.md | 4 +- .../5-replace-for-while/solution.md | 2 +- .../12-while-for/5-replace-for-while/task.md | 6 +- .../6-repeat-until-correct/solution.md | 10 +- .../6-repeat-until-correct/task.md | 8 +- .../12-while-for/7-list-primes/solution.md | 24 +- .../12-while-for/7-list-primes/task.md | 14 +- 1-js/02-first-steps/12-while-for/article.md | 250 +++++++++--------- 15 files changed, 198 insertions(+), 198 deletions(-) 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 index 43ee4aad3..a7b1840f2 100644 --- 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 @@ -1,4 +1,4 @@ -The answer: `1`. +Resposta: `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`. +Cada iteração do loop subtrai `1` de `i`. O teste `while(i)` interrompe o loop quando `i = 0`. -Hence, the steps of the loop form the following sequence ("loop unrolled"): +Portanto, as etapas do loop formam a seguinte sequência ("loop desenrolado"): ```js let i = 3; -alert(i--); // shows 3, decreases i to 2 +alert(i--); // exibe 3, decresce i para 2 -alert(i--) // shows 2, decreases i to 1 +alert(i--) // exibe 2, decresce i para 1 -alert(i--) // shows 1, decreases i to 0 +alert(i--) // exibe 1, decresce i para 0 -// done, while(i) check stops the loop +// pronto, o teste while(i) interrompe o loop ``` 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 index 3b847dfa2..dd931937d 100644 --- 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 @@ -2,9 +2,9 @@ importance: 3 --- -# Last loop value +# Último valor do loop -What is the last value alerted by this code? Why? +Qual é o último valor exibido no alerta 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 index 495359876..3a8cc5d6e 100644 --- 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 @@ -1,30 +1,32 @@ -The task demonstrates how postfix/prefix forms can lead to different results when used in comparisons. +Este exercício demonstra como formas posfixadas/prefixadas podem levar a resultados distintos quando utilizadas em comparações. -1. **From 1 to 4** +1. **De 1 a 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`. + O primeiro valor é `i = 1`, pois `++i` primeiro incrementa `i` e em seguida retorna o novo valor. Então, a primeira comparação é `1 < 5` e o `alert` exibe `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. + Em seguida vêm `2, 3, 4…` -- os valores aparecem um depois do outro. A comparação sempre usa o valor incrementado, pois `++` vem antes da variável. - 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** + Finalmente, `i = 4` é incrementado a `5`, a comparação `while(5 < 5)` falha, e o loop termina. Assim, `5` não é exibido. + +2. **De 1 a 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`). + O primeiro valor é novamente `i = 1`. A forma posfixada `i++`incrementa `i` e em seguida retorna o valor *antigo*, então a comparação `i++ < 5` utilizará `i = 0` (diferente de `++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`. + Mas a chamada de `alert` é separada. Ela é uma declaração distinta que executa após o incremento e a comparaçào. Assim, ela recebe o valor atual `i = 1`. - Then follow `2, 3, 4…` + Em seguida, vêm `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`. + Vamos parar em `i = 4`. A forma prefixada `++i` iria incrementar e utilizar `5` na comparação. Mas aqui temos a forma posfixada `i++`. Ela incrementa `i` para `5`, mas retorna o valor antigo. Portanto a comparação é, na verdade, `while(4 < 5)` -- verdadeira, e o controle passa para `alert`. - The value `i = 5` is the last one, because on the next step `while(5 < 5)` is false. + O valor `i = 5` é o último, porque na próxima etapa `while(5 < 5)` é falso. + \ No newline at end of file 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 index 298213237..aefb036d3 100644 --- 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 @@ -2,19 +2,19 @@ importance: 4 --- -# Which values does the while loop show? +# Quais valores o loop while retorna? -For every loop iteration, write down which value it outputs and then compare it with the solution. +Para cada iteração dos loops, anote o valor que ele retorna, depois compare com a solução. -Both loops `alert` the same values, or not? +Ambos os loops retornam em `alert` os mesmo valores, ou não? -1. The prefix form `++i`: +1. A forma prefixada `++i`: ```js let i = 0; while (++i < 5) alert( i ); ``` -2. The postfix form `i++` +2. A forma posfixada `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 index e2e28e75b..55f27ec83 100644 --- 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 @@ -1,4 +1,4 @@ -**The answer: from `0` to `4` in both cases.** +**Resposta: de `0` a `4` nos dois casos.** ```js run for (let i = 0; i < 5; ++i) alert( i ); @@ -6,12 +6,12 @@ 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`: +Isso pode ser facilmente deduzido do 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. Executar `i = 0` uma vez antes de tudo (begin). +2. Verificar a condição `i < 5`. +3. Caso verdadeira (`true`), executar o corpo do loop `alert(i)`, e em seguida `i++`. -The increment `i++` is separated from the condition check (2). That's just another statement. +O incremento `i++` é separado do teste da condição (2). Trata-se de outra declaração. -The value returned by the increment is not used here, so there's no difference between `i++` and `++i`. +O valor retornado pelo incremento não é utilizado aqui, então não há diferença entre `i++` e `++i`. \ No newline at end of file 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 index bfefa63f5..abc4a37be 100644 --- 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 @@ -2,18 +2,18 @@ importance: 4 --- -# Which values get shown by the "for" loop? +# Quais valores são mostrados pelo loop "for"? -For each loop write down which values it is going to show. Then compare with the answer. +Pada cada loop, anote quais os valores retornados. Depois, compare com a resposta. -Both loops `alert` same values or not? +Ambos os loops retornam em `alert` os mesmo valores, ou não? -1. The postfix form: +1. A forma posfixada: ```js for (let i = 0; i < 5; i++) alert( i ); ``` -2. The prefix form: +2. A forma prefixada: ```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 index e8e66bb47..f7e6e30f8 100644 --- 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 @@ -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. +Utilizamos o operador "módulo" `%` aqui para obter o resto e testar se o valor é par. 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 index ff34e7e40..5627f1f70 100644 --- 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 @@ -2,8 +2,8 @@ importance: 5 --- -# Output even numbers in the loop +# Retornar valores pares no loop -Use the `for` loop to output even numbers from `2` to `10`. +Utilize o loop `for` para retornar números pares de `2` a `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 index 612cf559c..5579686ef 100644 --- 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 @@ -3,7 +3,7 @@ ```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 index 0c69d9c2d..a38929c63 100644 --- 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 @@ -2,13 +2,13 @@ importance: 5 --- -# Replace "for" with "while" +# Substituir "for" por "while" -Rewrite the code changing the `for` loop to `while` without altering its behavior (the output should stay same). +Reescreva o código, mudando o loop `for` para `while` sem alterar seu comportamento (o resultado deve continuar o mesmo). ```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 index 2e04a78c4..f7ce57442 100644 --- 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 @@ -3,13 +3,13 @@ let num; do { - num = prompt("Enter a number greater than 100?", 0); + num = prompt("Digite um número maior que 100:", 0); } while (num <= 100 && num); ``` -The loop `do..while` repeats while both checks are truthy: +O loop `do..while` repete enquanto ambos os testes sejam verdadeiros: -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. O teste `num <= 100` -- isto é, o valor digitado ainda não é maior que `100`. +2. O teste `&& num` é falso quando `num` é `null` ou um string vazio. Então, o loop `while` também é interrompido. -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. Se `num` é `null`, então `num <= 100` é verdadeiro. Por isso, sem o segundo teste, o loop não iria encerrar se o usuário clicasse em "CANCELAR". Ambos os testes são necessários. 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 index 0788ee76e..b2253a61a 100644 --- 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 @@ -2,12 +2,12 @@ importance: 5 --- -# Repeat until the input is correct +# Repetir até que o input esteja correto -Write a loop which prompts for a number greater than `100`. If the visitor enters another number -- ask them to input again. +Escreva um loop que peça um número maior que `100`. Se o usuário digitar outro número, peça para digite digitar novamente. -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. +O loop deve pedir um número até que o usuário digite um número maior que `100` ou cancele o diálogo/submeta uma linha em branco. -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. +Aqui podemos assumir que o usuário só digita números. Não é preciso implementar um tratamento especial para inputs não-numéricos neste exercício. [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 index 9ff0663d7..a011f54db 100644 --- 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 @@ -1,29 +1,29 @@ -There are many algorithms for this task. +Há muitos algotimos para esta tarefa. -Let's use a nested loop: +Vamos utilizar um loop dentro de outro (isto é, aninhado): ```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 +Para cada i no intervalo { + testar se i tem um divisor de 1 a i + se sim => o valor não é um primo + se não => o valor e um primo, mostre-o } ``` -The code using a label: +O código usando um label: ```js run let n = 10; nextPrime: -for (let i = 2; i <= n; i++) { // for each i... +for (let i = 2; i <= n; i++) { // para 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++) { // procurar um divisor.. + if (i % j == 0) continue nextPrime; // não é primo, passar para o 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. +Há muitas maneiras de otimizá-lo. Por exemplo, podemos procurar divisores de `2` até a raiz quadrada de `i`. De qualquer modo, se quisermos ser realmente eficientes para intervalos maiores, precisamos mudar a abordagem e nos embasar em matemática avançada e algoritmos complexos como o [Crivo Quadrático](https://en.wikipedia.org/wiki/Quadratic_sieve), o [Crivo do Corpo de Números Geral](https://en.wikipedia.org/wiki/General_number_field_sieve), etc. \ No newline at end of file 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 index 6344b9f6f..8146424fa 100644 --- 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 @@ -2,16 +2,16 @@ importance: 3 --- -# Output prime numbers +# Retornar número 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. +Um número inteiro maior que `1` é chamado de [primo](https://pt.wikipedia.org/wiki/Número_primo) se ele não puder ser divido por nada exceto por `1` e por si mesmo sem gerar um resto. -In other words, `n > 1` is a prime if it can't be evenly divided by anything except `1` and `n`. +Em outras palavras, `n > 1` é um primo se ele não puder ser dividido sem resto por nada além de `1` e `n`. -For example, `5` is a prime, because it cannot be divided without a remainder by `2`, `3` and `4`. +Por exemplo, `5` é um primo, pois não pode ser dividido sem resto por `2`, `3` e `4`. -**Write the code which outputs prime numbers in the interval from `2` to `n`.** +**Escreve o código que retorne números primos no intervalo de `2` a `n`.** -For `n = 10` the result will be `2,3,5,7`. +Para `n = 10`, o resultado será `2,3,5,7`. -P.S. The code should work for any `n`, not be hard-tuned for any fixed value. +P.S. O código deve funcionar para qualquer `n`, e não pré-estabelecido para um valor fixo. diff --git a/1-js/02-first-steps/12-while-for/article.md b/1-js/02-first-steps/12-while-for/article.md index 6be50597d..584612b33 100644 --- a/1-js/02-first-steps/12-while-for/article.md +++ b/1-js/02-first-steps/12-while-for/article.md @@ -1,54 +1,54 @@ -# Loops: while and for +# Loops: while e for -We often need to repeat actions. +Frequentemente precisamos repetir ações. -For example, outputting goods from a list one after another or just running the same code for each number from 1 to 10. +Por exemplo, retornar itens de uma lista, um atrás do outro, ou apenas executar o mesmo código para cada número de 1 a 10. -*Loops* are a way to repeat the same code multiple times. +*Loops* são uma maneira de repetir o mesmo código múltiplas vezes. -## The "while" loop +## O loop "while" -The `while` loop has the following syntax: +O `while` loop tem a sintaxe seguinte: ```js -while (condition) { - // code - // so-called "loop body" +while (condição) { + // código + // chamado de "loop body" (corpo do loop) } ``` -While the `condition` is `true`, the `code` from the loop body is executed. +Enquanto `condição` for verdadeira, o `código` do corpo do loop é executado. -For instance, the loop below outputs `i` while `i < 3`: +Por exemplo, o loop abaixo retorna `i` enquanto `i < 3`: ```js run let i = 0; -while (i < 3) { // shows 0, then 1, then 2 +while (i < 3) { // retorna 0, depois 1, depois 2 alert( i ); i++; } ``` -A single execution of the loop body is called *an iteration*. The loop in the example above makes three iterations. +Uma única execução do corpo do loop é chamada de *uma iteração*. O loop no exemplo acima realiza três iterações. -If `i++` was missing from the example above, the loop would repeat (in theory) forever. In practice, the browser provides ways to stop such loops, and in server-side JavaScript, we can kill the process. +Se `i++` não estivesse presente no exemplo acima, o loop repetiria (teoricamente) para sempre. Na prática, o navegador nos oferece maneira de interromper tais loops, e em JavaScript server-side, é possível matar o processo. -Any expression or variable can be a loop condition, not just comparisons: the condition is evaluated and converted to a boolean by `while`. +Qualquer expressão ou variável pode ser uma condição para um loop, não apenas comparações: a condição é avaliada e convertida por `while` para um booleano. -For instance, a shorter way to write `while (i != 0)` is `while (i)`: +Por exemplo, uma maneira mais curta de escrever `while (i != 0)` é `while (i)`: ```js run let i = 3; *!* -while (i) { // when i becomes 0, the condition becomes falsy, and the loop stops +while (i) { // quando i se tornar 0, a condição se torna falsa, e o loop para */!* alert( i ); i--; } ``` -````smart header="Brackets are not required for a single-line body" -If the loop body has a single statement, we can omit the brackets `{…}`: +````smart header="Colchetes não são necessários se o corpo possuir só uma linha" +Se o corpo do loop possuir uma única declaração, podemos omitir os colchetes `{...}`: ```js run let i = 3; @@ -58,19 +58,19 @@ while (i) alert(i--); ``` ```` -## The "do..while" loop +## O loop "do..while" -The condition check can be moved *below* the loop body using the `do..while` syntax: +A verificação da condição pode ser movida *abaixo* do corpo do loop utilizando a sintaxe `do..while`: ```js do { - // loop body -} while (condition); + // corpo do loop +} while (condição); ``` -The loop will first execute the body, then check the condition, and, while it's truthy, execute it again and again. +O loop vai executar primeiro o corpo, depois checar a condição e, enquanto ela permanecer verdadeira, executar o corpo novamente. -For example: +Por exemplo: ```js run let i = 0; @@ -80,107 +80,107 @@ do { } while (i < 3); ``` -This form of syntax should only be used when you want the body of the loop to execute **at least once** regardless of the condition being truthy. Usually, the other form is preferred: `while(…) {…}`. +Esta forma de sintaxe deve ser usada apenas quando você deseja que o corpo do loop seja executado **pelo menos uma vez**, independente de a condição ser verdadeira. Geralmente, prefere-se a outra forma: `while(...) {...}`. -## The "for" loop +## O loop "for" -The `for` loop is the most commonly used loop. +O loop `for` é o mais comumente utilizado. -It looks like this: +Ele tem esse formato: ```js -for (begin; condition; step) { - // ... loop body ... +for (início; condição; etapa) { + // ... corpo do loop ... } ``` -Let's learn the meaning of these parts by example. The loop below runs `alert(i)` for `i` from `0` up to (but not including) `3`: +Vamos aprender o que significam cada uma dessas partes através de exemplos. O loop abaixo executa `alert(i)` para `i` de `0` a (não incluso) `3`: ```js run -for (let i = 0; i < 3; i++) { // shows 0, then 1, then 2 +for (let i = 0; i < 3; i++) { // retorna 0, depois 1, depois 2 alert(i); } ``` -Let's examine the `for` statement part-by-part: +Vamos examinar a declaração `for` parte por parte: -| part | | | -|-------|----------|----------------------------------------------------------------------------| -| begin | `i = 0` | Executes once upon entering the loop. | -| condition | `i < 3`| Checked before every loop iteration. If false, the loop stops. | -| step| `i++` | Executes after the body on each iteration but before the condition check. | -| body | `alert(i)`| Runs again and again while the condition is truthy. | +| part | | | +|----------|------------|--------------------------------------------------------------------------------| +| início | `i = 0` | Executado uma vez na entrada do loop. | +| condição | `i < 3` | Verificada a cada iteração do loop. Se falsa, o loop é interrompido. | +| etapa | `i++` | Executado depois do corpo, a cada iteração, mas antes de verificar a condição. | +| corpo | `alert(i)` | Executado repetidamente enquanto a condição for verdadeira. | -The general loop algorithm works like this: +O algoritmo geral do loop funciona assim: ``` -Run begin -→ (if condition → run body and run step) -→ (if condition → run body and run step) -→ (if condition → run body and run step) +Executar início +→ (se condição verdadeira → executar corpo e executar etapa) +→ (se condição verdadeira → executar corpo e executar etapa) +→ (se condição verdadeira → executar corpo e executar etapa) → ... ``` -If you are new to loops, it could help to go back to the example and reproduce how it runs step-by-step on a piece of paper. +Caso loops sejam novos para você, pode ser útil voltar ao exemplo e reproduzir sua execução passo-a-passo em uma folha de papel. -Here's exactly what happens in our case: +No nosso exemplo, o que acontece exatamente é isso: ```js // for (let i = 0; i < 3; i++) alert(i) -// run begin +// executar condição let i = 0 -// if condition → run body and run step +// se condição verdadeira → executar corpo e executar etapa if (i < 3) { alert(i); i++ } -// if condition → run body and run step +// se condição verdadeira → executar corpo e executar etapa if (i < 3) { alert(i); i++ } -// if condition → run body and run step +// se condição verdadeira → executar corpo e executar etapa if (i < 3) { alert(i); i++ } -// ...finish, because now i == 3 +// ...encerrar, pois agora i == 3 ``` -````smart header="Inline variable declaration" -Here, the "counter" variable `i` is declared right in the loop. This is called an "inline" variable declaration. Such variables are visible only inside the loop. +````smart header="Declaração de variável inline" +Aqui, a variável "de contagem" `i` é declarada diretamente no loop. Isso é chamado de declaração de variável "inline". Tais variáveis são visíveis somente no interior do loop. ```js run for (*!*let*/!* i = 0; i < 3; i++) { alert(i); // 0, 1, 2 } -alert(i); // error, no such variable +alert(i); // erro, variável não existente ``` -Instead of defining a variable, we could use an existing one: +Ao invés de definir a variável, podemos utilizar uma já existente: ```js run let i = 0; -for (i = 0; i < 3; i++) { // use an existing variable +for (i = 0; i < 3; i++) { // usando uma variável pré-existente alert(i); // 0, 1, 2 } -alert(i); // 3, visible, because declared outside of the loop +alert(i); // 3, visível, porque declarada fora do loop ``` ```` -### Skipping parts +### Omitindo partes -Any part of `for` can be skipped. +Qualquer parte de `for` pode ser omitida. -For example, we can omit `begin` if we don't need to do anything at the loop start. +Por exemplo, podemos omitir `início` caso não seja necessário fazer nada no início do loop. -Like here: +Como neste exemplo: ```js run -let i = 0; // we have i already declared and assigned +let i = 0; // já temos i declarada e atribuída -for (; i < 3; i++) { // no need for "begin" +for (; i < 3; i++) { // "início" não é necessário alert( i ); // 0, 1, 2 } ``` -We can also remove the `step` part: +Também podemos remover a parte da `etapa`: ```js run let i = 0; @@ -190,32 +190,32 @@ for (; i < 3;) { } ``` -This makes the loop identical to `while (i < 3)`. +Isso torna o loop idêntico a `while (i < 3)`. -We can actually remove everything, creating an infinite loop: +Na verdade, podemos remover tudo, criando um loop infinito: ```js for (;;) { - // repeats without limits + // repete sem limites } ``` -Please note that the two `for` semicolons `;` must be present. Otherwise, there would be a syntax error. +Note que os dois pontos-e-vírgulas `;` dentro do `for` devem estar presentes. Caso contrário, haverá um erro de sintaxe. -## Breaking the loop +## Quebrando o loop -Normally, a loop exits when its condition becomes falsy. +Normalmente, um loop se encerra quando sua condição se torna falsa. -But we can force the exit at any time using the special `break` directive. +Mas podemos forçar a saída a qualquer momento utilizando o comando especial `break`. -For example, the loop below asks the user for a series of numbers, "breaking" when no number is entered: +Por exemplo, o loop abaixo pede ao usuário uma série de números, e "quebra" quando nenhum número é informado: ```js let sum = 0; while (true) { - let value = +prompt("Enter a number", ''); + let value = +prompt("Digite um número", ''); *!* if (!value) break; // (*) @@ -224,35 +224,35 @@ while (true) { sum += value; } -alert( 'Sum: ' + sum ); +alert( 'Soma: ' + sum ); ``` -The `break` directive is activated at the line `(*)` if the user enters an empty line or cancels the input. It stops the loop immediately, passing control to the first line after the loop. Namely, `alert`. +O comando `break` é ativado na linha `(*)` se o usuário deixa a linha em branco ou cancela o diálogo. Ele interrompe o loop imediatamente, passando o controle à primeira linha depois do loop. Neste caso, `alert`. -The combination "infinite loop + `break` as needed" is great for situations when a loop's condition must be checked not in the beginning or end of the loop, but in the middle or even in several places of its body. +A combinação "loop infinito " `break` quando necessário" é ótima para situações onde a condição do loop precisa ser verificada não no início ou no fim do loop, mas no meio, ou até mesmo em vários lugares do corpo do loop. -## Continue to the next iteration [#continue] +## Continue para a próxima iteração [#continue] -The `continue` directive is a "lighter version" of `break`. It doesn't stop the whole loop. Instead, it stops the current iteration and forces the loop to start a new one (if the condition allows). +O comando `continue` é uma "versão mais light" de `break`. Ele não interrompe o loop como um todo. Ao invés disso, ele interrompe a iteração atual e força o loop a começar uma nova (se a condição permitir). -We can use it if we're done with the current iteration and would like to move on to the next one. +Você pode utilizá-lo caso a iteração atual já não seja útil e você deseje passar para a próxima. -The loop below uses `continue` to output only odd values: +O loop abaixo usa `continue` para exibir apenas valores ímpares: ```js run no-beautify for (let i = 0; i < 10; i++) { - // if true, skip the remaining part of the body + // se verdadeiro, pular o restante do corpo *!*if (i % 2 == 0) continue;*/!* alert(i); // 1, then 3, 5, 7, 9 } ``` -For even values of `i`, the `continue` directive stops executing the body and passes control to the next iteration of `for` (with the next number). So the `alert` is only called for odd values. +Para valores pares de `i`, o comando `continue` interrompe a execução do corpo e passa o controle para a próxima iteração de `for` (com o número seguinte). Então `alert` só é chamado para valores ímpares. -````smart header="The `continue` directive helps decrease nesting" -A loop that shows odd values could look like this: +````smart header="O comando `continue` ajuda a reduzir aninhamento" +Um loop que retorna apenas valores ímpares poderia ter a seguinte forma: ```js for (let i = 0; i < 10; i++) { @@ -264,15 +264,15 @@ for (let i = 0; i < 10; i++) { } ``` -From a technical point of view, this is identical to the example above. Surely, we can just wrap the code in an `if` block instead of using `continue`. +De uma perspectiva técnica, isso é idêntico ao exemplo anterior. Certamente, podemos apenas envolver o código em um bloco `if` ao invés de utilizar `continue`. -But as a side-effect, this created one more level of nesting (the `alert` call inside the curly braces). If the code inside of`if` is longer than a few lines, that may decrease the overall readability. +Mas como efeito colateral, isso criou mais um nível de aninhamento (o `alert` dentro dos colchetes). Se o código dentro de `if` for mais longo do que algumas linhas, isso pode reduzir a legibilidade de forma geral. ```` -````warn header="No `break/continue` to the right side of '?'" -Please note that syntax constructs that are not expressions cannot be used with the ternary operator `?`. In particular, directives such as `break/continue` aren't allowed there. +````warn header="Não utilize `break/continue` do lado direito de '?'" +Note que construções sintáticas que não sejam expressões não podem ser utilizados com o operador ternário `?`. Em particular, comandos como `break/continue` não são permitidos nesta posição. -For example, if we take this code: +Por exemplo, se tomarmos este código: ```js if (i > 5) { @@ -282,104 +282,102 @@ if (i > 5) { } ``` -...and rewrite it using a question mark: - +...e reescrevermos utilizando o ponto de interrogação: ```js no-beautify -(i > 5) ? alert(i) : *!*continue*/!*; // continue isn't allowed here +(i > 5) ? alert(i) : *!*continue*/!*; // continue não é permitido aqui ``` -...it stops working. Code like this will give a syntax error: - +...ele para de funcionar. Códigos como este vão gerar um erro de sintaxe. -This is just another reason not to use the question mark operator `?` instead of `if`. +Esta é apenas mais uma razão para não utilizar o operador ternário `?` no lugar de `if`. ```` ## Labels for break/continue -Sometimes we need to break out from multiple nested loops at once. +Às vezes, precisamos quebrar vários loops aninhados de uma vez só. -For example, in the code below we loop over `i` and `j`, prompting for the coordinates `(i, j)` from `(0,0)` to `(3,3)`: +Por exemplo, no código abaixo nós utilizamos dois loops, com `i` e `j`, dando as coordenadas `(i, j)` de `(0,0)` a `(3,3)`: ```js run no-beautify for (let i = 0; i < 3; i++) { for (let j = 0; j < 3; j++) { - let input = prompt(`Value at coords (${i},${j})`, ''); + let input = prompt(`Valor nas coordenadas (${i},${j})`, ''); - // what if we want to exit from here to Done (below)? + // e se quisermos sair daqui diretamente para "Pronto" (abaixo)? } } -alert('Done!'); +alert('Pronto!'); ``` -We need a way to stop the process if the user cancels the input. +Precisamos de uma maneira de interromper o processo caso o usuário cancele o input. -The ordinary `break` after `input` would only break the inner loop. That's not sufficient--labels, come to the rescue! +O `break` comum depois de `input` quebraria apenas o loop interno. Isso não é suficiente--labels, ao resgate! -A *label* is an identifier with a colon before a loop: +Um *label* é um identificador com dois pontos antes de um loop: ```js labelName: for (...) { ... } ``` -The `break ` statement in the loop below breaks out to the label: +A declaração `break ` no loop abaixo quebra o loop designado pelo label: ```js run no-beautify *!*outer:*/!* for (let i = 0; i < 3; i++) { for (let j = 0; j < 3; j++) { - let input = prompt(`Value at coords (${i},${j})`, ''); + let input = prompt(`Valor nas coordenadas (${i},${j})`, ''); - // if an empty string or canceled, then break out of both loops + // se retornar um string vazio ou cancelar, quebrar ambos os loops if (!input) *!*break outer*/!*; // (*) - // do something with the value... + // fazer algo com input... } } -alert('Done!'); +alert('Pronto!'); ``` -In the code above, `break outer` looks upwards for the label named `outer` and breaks out of that loop. +No código acima, `break outer` procura acima dele o label chamado `outer` e quebra aquele loop. -So the control goes straight from `(*)` to `alert('Done!')`. +Assim o controle vai direto de `(*)` para `alert('Pronto!')`. -We can also move the label onto a separate line: +Também podemos colocar o label em uma linha separada: ```js no-beautify outer: for (let i = 0; i < 3; i++) { ... } ``` -The `continue` directive can also be used with a label. In this case, code execution jumps to the next iteration of the labeled loop. +O comando `continue` também pode ser utilizado com um label. Nesse caso, a execução do código pula para a próxima iteração do loop nomeado pelo label. -````warn header="Labels are not a \"goto\"" -Labels do not allow us to jump into an arbitrary place in the code. +````warn header="Labels não significam \"ir para\"" +Labels não nos permitem pular para qualquer lugar do código. -For example, it is impossible to do this: +Por exemplo, é impossível fazer isso: ```js -break label; // jumps to label? No. +break label; // pula para label? Não. label: for (...) ``` -A call to `break/continue` is only possible from inside a loop and the label must be somewhere above the directive. +Uma chamada de `break/continue` só é possível de dentro de um loop e o label deve estar em algum lugar acima do comando. ```` -## Summary +## Resumo -We covered 3 types of loops: +Nós cobrimos 3 tipos de loops: -- `while` -- The condition is checked before each iteration. -- `do..while` -- The condition is checked after each iteration. -- `for (;;)` -- The condition is checked before each iteration, additional settings available. +- `while` -- A condição é verificada antes de cada iteração. +- `do..while` -- A condição é verificada após cada iteração. +- `for (;;)` -- A condição é verificada antes de cada iteração, configurações adicionais disponíveis. -To make an "infinite" loop, usually the `while(true)` construct is used. Such a loop, just like any other, can be stopped with the `break` directive. +Para fazer um loop "infinito", geralmente se utiliza a construção `white(true)`. Este loop, como qualquer outro, pode ser interrompido com o comando `break`. -If we don't want to do anything in the current iteration and would like to forward to the next one, we can use the `continue` directive. +Se não quisermos fazer nada na iteração atual e gostaríamos de pular para a próxima iteração, podemos utilizar o comando `continue`. -`break/continue` support labels before the loop. A label is the only way for `break/continue` to escape a nested loop to go to an outer one. +`break/continue` suportam labels antes do loop. Um label é a única maneira de fazer um `break/continue` escapar um loop aninhado e ir para o loop de fora. \ No newline at end of file From f3131548622b8f19784f2b05b478086c6aea8456 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=81lvaro=20Antonio?= Date: Wed, 4 Sep 2019 17:25:16 -0300 Subject: [PATCH 02/13] deleting --- .../1-loop-last-value/solution.md | 25 -- .../12-while-for/1-loop-last-value/task.md | 15 - .../2-which-value-while/solution.md | 32 -- .../12-while-for/2-which-value-while/task.md | 22 - .../3-which-value-for/solution.md | 17 - .../12-while-for/3-which-value-for/task.md | 20 - .../12-while-for/4-for-even/solution.md | 11 - .../12-while-for/4-for-even/task.md | 9 - .../5-replace-for-while/solution.md | 10 - .../12-while-for/5-replace-for-while/task.md | 14 - .../6-repeat-until-correct/solution.md | 15 - .../6-repeat-until-correct/task.md | 13 - .../12-while-for/7-list-primes/solution.md | 29 -- .../12-while-for/7-list-primes/task.md | 17 - 1-js/02-first-steps/12-while-for/article.md | 383 ------------------ 15 files changed, 632 deletions(-) delete mode 100644 1-js/02-first-steps/12-while-for/1-loop-last-value/solution.md delete mode 100644 1-js/02-first-steps/12-while-for/1-loop-last-value/task.md delete mode 100644 1-js/02-first-steps/12-while-for/2-which-value-while/solution.md delete mode 100644 1-js/02-first-steps/12-while-for/2-which-value-while/task.md delete mode 100644 1-js/02-first-steps/12-while-for/3-which-value-for/solution.md delete mode 100644 1-js/02-first-steps/12-while-for/3-which-value-for/task.md delete mode 100644 1-js/02-first-steps/12-while-for/4-for-even/solution.md delete mode 100644 1-js/02-first-steps/12-while-for/4-for-even/task.md delete mode 100644 1-js/02-first-steps/12-while-for/5-replace-for-while/solution.md delete mode 100644 1-js/02-first-steps/12-while-for/5-replace-for-while/task.md delete mode 100644 1-js/02-first-steps/12-while-for/6-repeat-until-correct/solution.md delete mode 100644 1-js/02-first-steps/12-while-for/6-repeat-until-correct/task.md delete mode 100644 1-js/02-first-steps/12-while-for/7-list-primes/solution.md delete mode 100644 1-js/02-first-steps/12-while-for/7-list-primes/task.md delete mode 100644 1-js/02-first-steps/12-while-for/article.md 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 deleted file mode 100644 index a7b1840f2..000000000 --- a/1-js/02-first-steps/12-while-for/1-loop-last-value/solution.md +++ /dev/null @@ -1,25 +0,0 @@ -Resposta: `1`. - -```js run -let i = 3; - -while (i) { - alert( i-- ); -} -``` - -Cada iteração do loop subtrai `1` de `i`. O teste `while(i)` interrompe o loop quando `i = 0`. - -Portanto, as etapas do loop formam a seguinte sequência ("loop desenrolado"): - -```js -let i = 3; - -alert(i--); // exibe 3, decresce i para 2 - -alert(i--) // exibe 2, decresce i para 1 - -alert(i--) // exibe 1, decresce i para 0 - -// pronto, o teste while(i) interrompe o loop -``` 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 deleted file mode 100644 index dd931937d..000000000 --- a/1-js/02-first-steps/12-while-for/1-loop-last-value/task.md +++ /dev/null @@ -1,15 +0,0 @@ -importance: 3 - ---- - -# Último valor do loop - -Qual é o último valor exibido no alerta por este código? Por quê? - -```js -let i = 3; - -while (i) { - alert( i-- ); -} -``` 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 deleted file mode 100644 index 3a8cc5d6e..000000000 --- a/1-js/02-first-steps/12-while-for/2-which-value-while/solution.md +++ /dev/null @@ -1,32 +0,0 @@ -Este exercício demonstra como formas posfixadas/prefixadas podem levar a resultados distintos quando utilizadas em comparações. - -1. **De 1 a 4** - - ```js run - let i = 0; - while (++i < 5) alert( i ); - ``` - - O primeiro valor é `i = 1`, pois `++i` primeiro incrementa `i` e em seguida retorna o novo valor. Então, a primeira comparação é `1 < 5` e o `alert` exibe `1`. - - Em seguida vêm `2, 3, 4…` -- os valores aparecem um depois do outro. A comparação sempre usa o valor incrementado, pois `++` vem antes da variável. - - Finalmente, `i = 4` é incrementado a `5`, a comparação `while(5 < 5)` falha, e o loop termina. Assim, `5` não é exibido. - -2. **De 1 a 5** - - ```js run - let i = 0; - while (i++ < 5) alert( i ); - ``` - - O primeiro valor é novamente `i = 1`. A forma posfixada `i++`incrementa `i` e em seguida retorna o valor *antigo*, então a comparação `i++ < 5` utilizará `i = 0` (diferente de `++i < 5`). - - Mas a chamada de `alert` é separada. Ela é uma declaração distinta que executa após o incremento e a comparaçào. Assim, ela recebe o valor atual `i = 1`. - - Em seguida, vêm `2, 3, 4…` - - Vamos parar em `i = 4`. A forma prefixada `++i` iria incrementar e utilizar `5` na comparação. Mas aqui temos a forma posfixada `i++`. Ela incrementa `i` para `5`, mas retorna o valor antigo. Portanto a comparação é, na verdade, `while(4 < 5)` -- verdadeira, e o controle passa para `alert`. - - O valor `i = 5` é o último, porque na próxima etapa `while(5 < 5)` é falso. - \ No newline at end of file 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 deleted file mode 100644 index aefb036d3..000000000 --- a/1-js/02-first-steps/12-while-for/2-which-value-while/task.md +++ /dev/null @@ -1,22 +0,0 @@ -importance: 4 - ---- - -# Quais valores o loop while retorna? - -Para cada iteração dos loops, anote o valor que ele retorna, depois compare com a solução. - -Ambos os loops retornam em `alert` os mesmo valores, ou não? - -1. A forma prefixada `++i`: - - ```js - let i = 0; - while (++i < 5) alert( i ); - ``` -2. A forma posfixada `i++`: - - ```js - let i = 0; - while (i++ < 5) alert( i ); - ``` 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 deleted file mode 100644 index 55f27ec83..000000000 --- a/1-js/02-first-steps/12-while-for/3-which-value-for/solution.md +++ /dev/null @@ -1,17 +0,0 @@ -**Resposta: de `0` a `4` nos dois casos.** - -```js run -for (let i = 0; i < 5; ++i) alert( i ); - -for (let i = 0; i < 5; i++) alert( i ); -``` - -Isso pode ser facilmente deduzido do algoritmo de `for`: - -1. Executar `i = 0` uma vez antes de tudo (begin). -2. Verificar a condição `i < 5`. -3. Caso verdadeira (`true`), executar o corpo do loop `alert(i)`, e em seguida `i++`. - -O incremento `i++` é separado do teste da condição (2). Trata-se de outra declaração. - -O valor retornado pelo incremento não é utilizado aqui, então não há diferença entre `i++` e `++i`. \ No newline at end of file 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 deleted file mode 100644 index abc4a37be..000000000 --- a/1-js/02-first-steps/12-while-for/3-which-value-for/task.md +++ /dev/null @@ -1,20 +0,0 @@ -importance: 4 - ---- - -# Quais valores são mostrados pelo loop "for"? - -Pada cada loop, anote quais os valores retornados. Depois, compare com a resposta. - -Ambos os loops retornam em `alert` os mesmo valores, ou não? - -1. A forma posfixada: - - ```js - for (let i = 0; i < 5; i++) alert( i ); - ``` -2. A forma prefixada: - - ```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 deleted file mode 100644 index f7e6e30f8..000000000 --- a/1-js/02-first-steps/12-while-for/4-for-even/solution.md +++ /dev/null @@ -1,11 +0,0 @@ - - -```js run demo -for (let i = 2; i <= 10; i++) { - if (i % 2 == 0) { - alert( i ); - } -} -``` - -Utilizamos o operador "módulo" `%` aqui para obter o resto e testar se o valor é par. 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 deleted file mode 100644 index 5627f1f70..000000000 --- a/1-js/02-first-steps/12-while-for/4-for-even/task.md +++ /dev/null @@ -1,9 +0,0 @@ -importance: 5 - ---- - -# Retornar valores pares no loop - -Utilize o loop `for` para retornar números pares de `2` a `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 deleted file mode 100644 index 5579686ef..000000000 --- a/1-js/02-first-steps/12-while-for/5-replace-for-while/solution.md +++ /dev/null @@ -1,10 +0,0 @@ - - -```js run -let i = 0; -while (i < 3) { - 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 deleted file mode 100644 index a38929c63..000000000 --- a/1-js/02-first-steps/12-while-for/5-replace-for-while/task.md +++ /dev/null @@ -1,14 +0,0 @@ -importance: 5 - ---- - -# Substituir "for" por "while" - -Reescreva o código, mudando o loop `for` para `while` sem alterar seu comportamento (o resultado deve continuar o mesmo). - -```js run -for (let i = 0; i < 3; 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 deleted file mode 100644 index f7ce57442..000000000 --- a/1-js/02-first-steps/12-while-for/6-repeat-until-correct/solution.md +++ /dev/null @@ -1,15 +0,0 @@ - -```js run demo -let num; - -do { - num = prompt("Digite um número maior que 100:", 0); -} while (num <= 100 && num); -``` - -O loop `do..while` repete enquanto ambos os testes sejam verdadeiros: - -1. O teste `num <= 100` -- isto é, o valor digitado ainda não é maior que `100`. -2. O teste `&& num` é falso quando `num` é `null` ou um string vazio. Então, o loop `while` também é interrompido. - -P.S. Se `num` é `null`, então `num <= 100` é verdadeiro. Por isso, sem o segundo teste, o loop não iria encerrar se o usuário clicasse em "CANCELAR". Ambos os testes são necessários. 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 deleted file mode 100644 index b2253a61a..000000000 --- a/1-js/02-first-steps/12-while-for/6-repeat-until-correct/task.md +++ /dev/null @@ -1,13 +0,0 @@ -importance: 5 - ---- - -# Repetir até que o input esteja correto - -Escreva um loop que peça um número maior que `100`. Se o usuário digitar outro número, peça para digite digitar novamente. - -O loop deve pedir um número até que o usuário digite um número maior que `100` ou cancele o diálogo/submeta uma linha em branco. - -Aqui podemos assumir que o usuário só digita números. Não é preciso implementar um tratamento especial para inputs não-numéricos neste exercício. - -[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 deleted file mode 100644 index a011f54db..000000000 --- a/1-js/02-first-steps/12-while-for/7-list-primes/solution.md +++ /dev/null @@ -1,29 +0,0 @@ -Há muitos algotimos para esta tarefa. - -Vamos utilizar um loop dentro de outro (isto é, aninhado): - -```js -Para cada i no intervalo { - testar se i tem um divisor de 1 a i - se sim => o valor não é um primo - se não => o valor e um primo, mostre-o -} -``` - -O código usando um label: - -```js run -let n = 10; - -nextPrime: -for (let i = 2; i <= n; i++) { // para cada i... - - for (let j = 2; j < i; j++) { // procurar um divisor.. - if (i % j == 0) continue nextPrime; // não é primo, passar para o próximo i - } - - alert( i ); // é primo -} -``` - -Há muitas maneiras de otimizá-lo. Por exemplo, podemos procurar divisores de `2` até a raiz quadrada de `i`. De qualquer modo, se quisermos ser realmente eficientes para intervalos maiores, precisamos mudar a abordagem e nos embasar em matemática avançada e algoritmos complexos como o [Crivo Quadrático](https://en.wikipedia.org/wiki/Quadratic_sieve), o [Crivo do Corpo de Números Geral](https://en.wikipedia.org/wiki/General_number_field_sieve), etc. \ No newline at end of file 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 deleted file mode 100644 index 8146424fa..000000000 --- a/1-js/02-first-steps/12-while-for/7-list-primes/task.md +++ /dev/null @@ -1,17 +0,0 @@ -importance: 3 - ---- - -# Retornar número primos - -Um número inteiro maior que `1` é chamado de [primo](https://pt.wikipedia.org/wiki/Número_primo) se ele não puder ser divido por nada exceto por `1` e por si mesmo sem gerar um resto. - -Em outras palavras, `n > 1` é um primo se ele não puder ser dividido sem resto por nada além de `1` e `n`. - -Por exemplo, `5` é um primo, pois não pode ser dividido sem resto por `2`, `3` e `4`. - -**Escreve o código que retorne números primos no intervalo de `2` a `n`.** - -Para `n = 10`, o resultado será `2,3,5,7`. - -P.S. O código deve funcionar para qualquer `n`, e não pré-estabelecido para um valor fixo. diff --git a/1-js/02-first-steps/12-while-for/article.md b/1-js/02-first-steps/12-while-for/article.md deleted file mode 100644 index 584612b33..000000000 --- a/1-js/02-first-steps/12-while-for/article.md +++ /dev/null @@ -1,383 +0,0 @@ -# Loops: while e for - -Frequentemente precisamos repetir ações. - -Por exemplo, retornar itens de uma lista, um atrás do outro, ou apenas executar o mesmo código para cada número de 1 a 10. - -*Loops* são uma maneira de repetir o mesmo código múltiplas vezes. - -## O loop "while" - -O `while` loop tem a sintaxe seguinte: - -```js -while (condição) { - // código - // chamado de "loop body" (corpo do loop) -} -``` - -Enquanto `condição` for verdadeira, o `código` do corpo do loop é executado. - -Por exemplo, o loop abaixo retorna `i` enquanto `i < 3`: - -```js run -let i = 0; -while (i < 3) { // retorna 0, depois 1, depois 2 - alert( i ); - i++; -} -``` - -Uma única execução do corpo do loop é chamada de *uma iteração*. O loop no exemplo acima realiza três iterações. - -Se `i++` não estivesse presente no exemplo acima, o loop repetiria (teoricamente) para sempre. Na prática, o navegador nos oferece maneira de interromper tais loops, e em JavaScript server-side, é possível matar o processo. - -Qualquer expressão ou variável pode ser uma condição para um loop, não apenas comparações: a condição é avaliada e convertida por `while` para um booleano. - -Por exemplo, uma maneira mais curta de escrever `while (i != 0)` é `while (i)`: - -```js run -let i = 3; -*!* -while (i) { // quando i se tornar 0, a condição se torna falsa, e o loop para -*/!* - alert( i ); - i--; -} -``` - -````smart header="Colchetes não são necessários se o corpo possuir só uma linha" -Se o corpo do loop possuir uma única declaração, podemos omitir os colchetes `{...}`: - -```js run -let i = 3; -*!* -while (i) alert(i--); -*/!* -``` -```` - -## O loop "do..while" - -A verificação da condição pode ser movida *abaixo* do corpo do loop utilizando a sintaxe `do..while`: - -```js -do { - // corpo do loop -} while (condição); -``` - -O loop vai executar primeiro o corpo, depois checar a condição e, enquanto ela permanecer verdadeira, executar o corpo novamente. - -Por exemplo: - -```js run -let i = 0; -do { - alert( i ); - i++; -} while (i < 3); -``` - -Esta forma de sintaxe deve ser usada apenas quando você deseja que o corpo do loop seja executado **pelo menos uma vez**, independente de a condição ser verdadeira. Geralmente, prefere-se a outra forma: `while(...) {...}`. - -## O loop "for" - -O loop `for` é o mais comumente utilizado. - -Ele tem esse formato: - -```js -for (início; condição; etapa) { - // ... corpo do loop ... -} -``` - -Vamos aprender o que significam cada uma dessas partes através de exemplos. O loop abaixo executa `alert(i)` para `i` de `0` a (não incluso) `3`: - -```js run -for (let i = 0; i < 3; i++) { // retorna 0, depois 1, depois 2 - alert(i); -} -``` - -Vamos examinar a declaração `for` parte por parte: - -| part | | | -|----------|------------|--------------------------------------------------------------------------------| -| início | `i = 0` | Executado uma vez na entrada do loop. | -| condição | `i < 3` | Verificada a cada iteração do loop. Se falsa, o loop é interrompido. | -| etapa | `i++` | Executado depois do corpo, a cada iteração, mas antes de verificar a condição. | -| corpo | `alert(i)` | Executado repetidamente enquanto a condição for verdadeira. | - - -O algoritmo geral do loop funciona assim: -``` -Executar início -→ (se condição verdadeira → executar corpo e executar etapa) -→ (se condição verdadeira → executar corpo e executar etapa) -→ (se condição verdadeira → executar corpo e executar etapa) -→ ... -``` - -Caso loops sejam novos para você, pode ser útil voltar ao exemplo e reproduzir sua execução passo-a-passo em uma folha de papel. - -No nosso exemplo, o que acontece exatamente é isso: - -```js -// for (let i = 0; i < 3; i++) alert(i) - -// executar condição -let i = 0 -// se condição verdadeira → executar corpo e executar etapa -if (i < 3) { alert(i); i++ } -// se condição verdadeira → executar corpo e executar etapa -if (i < 3) { alert(i); i++ } -// se condição verdadeira → executar corpo e executar etapa -if (i < 3) { alert(i); i++ } -// ...encerrar, pois agora i == 3 -``` - -````smart header="Declaração de variável inline" -Aqui, a variável "de contagem" `i` é declarada diretamente no loop. Isso é chamado de declaração de variável "inline". Tais variáveis são visíveis somente no interior do loop. - -```js run -for (*!*let*/!* i = 0; i < 3; i++) { - alert(i); // 0, 1, 2 -} -alert(i); // erro, variável não existente -``` - -Ao invés de definir a variável, podemos utilizar uma já existente: - -```js run -let i = 0; - -for (i = 0; i < 3; i++) { // usando uma variável pré-existente - alert(i); // 0, 1, 2 -} - -alert(i); // 3, visível, porque declarada fora do loop -``` - -```` - - -### Omitindo partes - -Qualquer parte de `for` pode ser omitida. - -Por exemplo, podemos omitir `início` caso não seja necessário fazer nada no início do loop. - -Como neste exemplo: - -```js run -let i = 0; // já temos i declarada e atribuída - -for (; i < 3; i++) { // "início" não é necessário - alert( i ); // 0, 1, 2 -} -``` - -Também podemos remover a parte da `etapa`: - -```js run -let i = 0; - -for (; i < 3;) { - alert( i++ ); -} -``` - -Isso torna o loop idêntico a `while (i < 3)`. - -Na verdade, podemos remover tudo, criando um loop infinito: - -```js -for (;;) { - // repete sem limites -} -``` - -Note que os dois pontos-e-vírgulas `;` dentro do `for` devem estar presentes. Caso contrário, haverá um erro de sintaxe. - -## Quebrando o loop - -Normalmente, um loop se encerra quando sua condição se torna falsa. - -Mas podemos forçar a saída a qualquer momento utilizando o comando especial `break`. - -Por exemplo, o loop abaixo pede ao usuário uma série de números, e "quebra" quando nenhum número é informado: - -```js -let sum = 0; - -while (true) { - - let value = +prompt("Digite um número", ''); - -*!* - if (!value) break; // (*) -*/!* - - sum += value; - -} -alert( 'Soma: ' + sum ); -``` - -O comando `break` é ativado na linha `(*)` se o usuário deixa a linha em branco ou cancela o diálogo. Ele interrompe o loop imediatamente, passando o controle à primeira linha depois do loop. Neste caso, `alert`. - -A combinação "loop infinito " `break` quando necessário" é ótima para situações onde a condição do loop precisa ser verificada não no início ou no fim do loop, mas no meio, ou até mesmo em vários lugares do corpo do loop. - -## Continue para a próxima iteração [#continue] - -O comando `continue` é uma "versão mais light" de `break`. Ele não interrompe o loop como um todo. Ao invés disso, ele interrompe a iteração atual e força o loop a começar uma nova (se a condição permitir). - -Você pode utilizá-lo caso a iteração atual já não seja útil e você deseje passar para a próxima. - -O loop abaixo usa `continue` para exibir apenas valores ímpares: - -```js run no-beautify -for (let i = 0; i < 10; i++) { - - // se verdadeiro, pular o restante do corpo - *!*if (i % 2 == 0) continue;*/!* - - alert(i); // 1, then 3, 5, 7, 9 -} -``` - -Para valores pares de `i`, o comando `continue` interrompe a execução do corpo e passa o controle para a próxima iteração de `for` (com o número seguinte). Então `alert` só é chamado para valores ímpares. - -````smart header="O comando `continue` ajuda a reduzir aninhamento" -Um loop que retorna apenas valores ímpares poderia ter a seguinte forma: - -```js -for (let i = 0; i < 10; i++) { - - if (i % 2) { - alert( i ); - } - -} -``` - -De uma perspectiva técnica, isso é idêntico ao exemplo anterior. Certamente, podemos apenas envolver o código em um bloco `if` ao invés de utilizar `continue`. - -Mas como efeito colateral, isso criou mais um nível de aninhamento (o `alert` dentro dos colchetes). Se o código dentro de `if` for mais longo do que algumas linhas, isso pode reduzir a legibilidade de forma geral. -```` - -````warn header="Não utilize `break/continue` do lado direito de '?'" -Note que construções sintáticas que não sejam expressões não podem ser utilizados com o operador ternário `?`. Em particular, comandos como `break/continue` não são permitidos nesta posição. - -Por exemplo, se tomarmos este código: - -```js -if (i > 5) { - alert(i); -} else { - continue; -} -``` - -...e reescrevermos utilizando o ponto de interrogação: - -```js no-beautify -(i > 5) ? alert(i) : *!*continue*/!*; // continue não é permitido aqui -``` - -...ele para de funcionar. Códigos como este vão gerar um erro de sintaxe. - -Esta é apenas mais uma razão para não utilizar o operador ternário `?` no lugar de `if`. -```` - -## Labels for break/continue - -Às vezes, precisamos quebrar vários loops aninhados de uma vez só. - -Por exemplo, no código abaixo nós utilizamos dois loops, com `i` e `j`, dando as coordenadas `(i, j)` de `(0,0)` a `(3,3)`: - -```js run no-beautify -for (let i = 0; i < 3; i++) { - - for (let j = 0; j < 3; j++) { - - let input = prompt(`Valor nas coordenadas (${i},${j})`, ''); - - // e se quisermos sair daqui diretamente para "Pronto" (abaixo)? - } -} - -alert('Pronto!'); -``` - -Precisamos de uma maneira de interromper o processo caso o usuário cancele o input. - -O `break` comum depois de `input` quebraria apenas o loop interno. Isso não é suficiente--labels, ao resgate! - -Um *label* é um identificador com dois pontos antes de um loop: -```js -labelName: for (...) { - ... -} -``` - -A declaração `break ` no loop abaixo quebra o loop designado pelo label: - -```js run no-beautify -*!*outer:*/!* for (let i = 0; i < 3; i++) { - - for (let j = 0; j < 3; j++) { - - let input = prompt(`Valor nas coordenadas (${i},${j})`, ''); - - // se retornar um string vazio ou cancelar, quebrar ambos os loops - if (!input) *!*break outer*/!*; // (*) - - // fazer algo com input... - } -} -alert('Pronto!'); -``` - -No código acima, `break outer` procura acima dele o label chamado `outer` e quebra aquele loop. - -Assim o controle vai direto de `(*)` para `alert('Pronto!')`. - -Também podemos colocar o label em uma linha separada: - -```js no-beautify -outer: -for (let i = 0; i < 3; i++) { ... } -``` - -O comando `continue` também pode ser utilizado com um label. Nesse caso, a execução do código pula para a próxima iteração do loop nomeado pelo label. - -````warn header="Labels não significam \"ir para\"" -Labels não nos permitem pular para qualquer lugar do código. - -Por exemplo, é impossível fazer isso: -```js -break label; // pula para label? Não. - -label: for (...) -``` - -Uma chamada de `break/continue` só é possível de dentro de um loop e o label deve estar em algum lugar acima do comando. -```` - -## Resumo - -Nós cobrimos 3 tipos de loops: - -- `while` -- A condição é verificada antes de cada iteração. -- `do..while` -- A condição é verificada após cada iteração. -- `for (;;)` -- A condição é verificada antes de cada iteração, configurações adicionais disponíveis. - -Para fazer um loop "infinito", geralmente se utiliza a construção `white(true)`. Este loop, como qualquer outro, pode ser interrompido com o comando `break`. - -Se não quisermos fazer nada na iteração atual e gostaríamos de pular para a próxima iteração, podemos utilizar o comando `continue`. - -`break/continue` suportam labels antes do loop. Um label é a única maneira de fazer um `break/continue` escapar um loop aninhado e ir para o loop de fora. \ No newline at end of file From b17dba1c99255e37dc7682bc2134f9ce1b6a133d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=81lvaro=20Antonio?= Date: Wed, 4 Sep 2019 17:26:21 -0300 Subject: [PATCH 03/13] Translate while-for loops --- .../1-loop-last-value/solution.md | 25 ++ .../12-while-for/1-loop-last-value/task.md | 15 + .../2-which-value-while/solution.md | 32 ++ .../12-while-for/2-which-value-while/task.md | 22 + .../3-which-value-for/solution.md | 17 + .../12-while-for/3-which-value-for/task.md | 20 + .../12-while-for/4-for-even/solution.md | 11 + .../12-while-for/4-for-even/task.md | 9 + .../5-replace-for-while/solution.md | 10 + .../12-while-for/5-replace-for-while/task.md | 14 + .../6-repeat-until-correct/solution.md | 15 + .../6-repeat-until-correct/task.md | 13 + .../12-while-for/7-list-primes/solution.md | 29 ++ .../12-while-for/7-list-primes/task.md | 17 + 1-js/02-first-steps/12-while-for/article.md | 383 ++++++++++++++++++ 15 files changed, 632 insertions(+) create mode 100644 1-js/02-first-steps/12-while-for/1-loop-last-value/solution.md create mode 100644 1-js/02-first-steps/12-while-for/1-loop-last-value/task.md create mode 100644 1-js/02-first-steps/12-while-for/2-which-value-while/solution.md create mode 100644 1-js/02-first-steps/12-while-for/2-which-value-while/task.md create mode 100644 1-js/02-first-steps/12-while-for/3-which-value-for/solution.md create mode 100644 1-js/02-first-steps/12-while-for/3-which-value-for/task.md create mode 100644 1-js/02-first-steps/12-while-for/4-for-even/solution.md create mode 100644 1-js/02-first-steps/12-while-for/4-for-even/task.md create mode 100644 1-js/02-first-steps/12-while-for/5-replace-for-while/solution.md create mode 100644 1-js/02-first-steps/12-while-for/5-replace-for-while/task.md create mode 100644 1-js/02-first-steps/12-while-for/6-repeat-until-correct/solution.md create mode 100644 1-js/02-first-steps/12-while-for/6-repeat-until-correct/task.md create mode 100644 1-js/02-first-steps/12-while-for/7-list-primes/solution.md create mode 100644 1-js/02-first-steps/12-while-for/7-list-primes/task.md create mode 100644 1-js/02-first-steps/12-while-for/article.md 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 new file mode 100644 index 000000000..a7b1840f2 --- /dev/null +++ b/1-js/02-first-steps/12-while-for/1-loop-last-value/solution.md @@ -0,0 +1,25 @@ +Resposta: `1`. + +```js run +let i = 3; + +while (i) { + alert( i-- ); +} +``` + +Cada iteração do loop subtrai `1` de `i`. O teste `while(i)` interrompe o loop quando `i = 0`. + +Portanto, as etapas do loop formam a seguinte sequência ("loop desenrolado"): + +```js +let i = 3; + +alert(i--); // exibe 3, decresce i para 2 + +alert(i--) // exibe 2, decresce i para 1 + +alert(i--) // exibe 1, decresce i para 0 + +// pronto, o teste while(i) interrompe o loop +``` 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 new file mode 100644 index 000000000..dd931937d --- /dev/null +++ b/1-js/02-first-steps/12-while-for/1-loop-last-value/task.md @@ -0,0 +1,15 @@ +importance: 3 + +--- + +# Último valor do loop + +Qual é o último valor exibido no alerta por este código? Por quê? + +```js +let i = 3; + +while (i) { + alert( i-- ); +} +``` 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 new file mode 100644 index 000000000..3a8cc5d6e --- /dev/null +++ b/1-js/02-first-steps/12-while-for/2-which-value-while/solution.md @@ -0,0 +1,32 @@ +Este exercício demonstra como formas posfixadas/prefixadas podem levar a resultados distintos quando utilizadas em comparações. + +1. **De 1 a 4** + + ```js run + let i = 0; + while (++i < 5) alert( i ); + ``` + + O primeiro valor é `i = 1`, pois `++i` primeiro incrementa `i` e em seguida retorna o novo valor. Então, a primeira comparação é `1 < 5` e o `alert` exibe `1`. + + Em seguida vêm `2, 3, 4…` -- os valores aparecem um depois do outro. A comparação sempre usa o valor incrementado, pois `++` vem antes da variável. + + Finalmente, `i = 4` é incrementado a `5`, a comparação `while(5 < 5)` falha, e o loop termina. Assim, `5` não é exibido. + +2. **De 1 a 5** + + ```js run + let i = 0; + while (i++ < 5) alert( i ); + ``` + + O primeiro valor é novamente `i = 1`. A forma posfixada `i++`incrementa `i` e em seguida retorna o valor *antigo*, então a comparação `i++ < 5` utilizará `i = 0` (diferente de `++i < 5`). + + Mas a chamada de `alert` é separada. Ela é uma declaração distinta que executa após o incremento e a comparaçào. Assim, ela recebe o valor atual `i = 1`. + + Em seguida, vêm `2, 3, 4…` + + Vamos parar em `i = 4`. A forma prefixada `++i` iria incrementar e utilizar `5` na comparação. Mas aqui temos a forma posfixada `i++`. Ela incrementa `i` para `5`, mas retorna o valor antigo. Portanto a comparação é, na verdade, `while(4 < 5)` -- verdadeira, e o controle passa para `alert`. + + O valor `i = 5` é o último, porque na próxima etapa `while(5 < 5)` é falso. + \ No newline at end of file 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 new file mode 100644 index 000000000..aefb036d3 --- /dev/null +++ b/1-js/02-first-steps/12-while-for/2-which-value-while/task.md @@ -0,0 +1,22 @@ +importance: 4 + +--- + +# Quais valores o loop while retorna? + +Para cada iteração dos loops, anote o valor que ele retorna, depois compare com a solução. + +Ambos os loops retornam em `alert` os mesmo valores, ou não? + +1. A forma prefixada `++i`: + + ```js + let i = 0; + while (++i < 5) alert( i ); + ``` +2. A forma posfixada `i++`: + + ```js + let i = 0; + while (i++ < 5) alert( i ); + ``` 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 new file mode 100644 index 000000000..55f27ec83 --- /dev/null +++ b/1-js/02-first-steps/12-while-for/3-which-value-for/solution.md @@ -0,0 +1,17 @@ +**Resposta: de `0` a `4` nos dois casos.** + +```js run +for (let i = 0; i < 5; ++i) alert( i ); + +for (let i = 0; i < 5; i++) alert( i ); +``` + +Isso pode ser facilmente deduzido do algoritmo de `for`: + +1. Executar `i = 0` uma vez antes de tudo (begin). +2. Verificar a condição `i < 5`. +3. Caso verdadeira (`true`), executar o corpo do loop `alert(i)`, e em seguida `i++`. + +O incremento `i++` é separado do teste da condição (2). Trata-se de outra declaração. + +O valor retornado pelo incremento não é utilizado aqui, então não há diferença entre `i++` e `++i`. \ No newline at end of file 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 new file mode 100644 index 000000000..abc4a37be --- /dev/null +++ b/1-js/02-first-steps/12-while-for/3-which-value-for/task.md @@ -0,0 +1,20 @@ +importance: 4 + +--- + +# Quais valores são mostrados pelo loop "for"? + +Pada cada loop, anote quais os valores retornados. Depois, compare com a resposta. + +Ambos os loops retornam em `alert` os mesmo valores, ou não? + +1. A forma posfixada: + + ```js + for (let i = 0; i < 5; i++) alert( i ); + ``` +2. A forma prefixada: + + ```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 new file mode 100644 index 000000000..f7e6e30f8 --- /dev/null +++ b/1-js/02-first-steps/12-while-for/4-for-even/solution.md @@ -0,0 +1,11 @@ + + +```js run demo +for (let i = 2; i <= 10; i++) { + if (i % 2 == 0) { + alert( i ); + } +} +``` + +Utilizamos o operador "módulo" `%` aqui para obter o resto e testar se o valor é par. 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 new file mode 100644 index 000000000..5627f1f70 --- /dev/null +++ b/1-js/02-first-steps/12-while-for/4-for-even/task.md @@ -0,0 +1,9 @@ +importance: 5 + +--- + +# Retornar valores pares no loop + +Utilize o loop `for` para retornar números pares de `2` a `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 new file mode 100644 index 000000000..5579686ef --- /dev/null +++ b/1-js/02-first-steps/12-while-for/5-replace-for-while/solution.md @@ -0,0 +1,10 @@ + + +```js run +let i = 0; +while (i < 3) { + 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 new file mode 100644 index 000000000..a38929c63 --- /dev/null +++ b/1-js/02-first-steps/12-while-for/5-replace-for-while/task.md @@ -0,0 +1,14 @@ +importance: 5 + +--- + +# Substituir "for" por "while" + +Reescreva o código, mudando o loop `for` para `while` sem alterar seu comportamento (o resultado deve continuar o mesmo). + +```js run +for (let i = 0; i < 3; 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 new file mode 100644 index 000000000..f7ce57442 --- /dev/null +++ b/1-js/02-first-steps/12-while-for/6-repeat-until-correct/solution.md @@ -0,0 +1,15 @@ + +```js run demo +let num; + +do { + num = prompt("Digite um número maior que 100:", 0); +} while (num <= 100 && num); +``` + +O loop `do..while` repete enquanto ambos os testes sejam verdadeiros: + +1. O teste `num <= 100` -- isto é, o valor digitado ainda não é maior que `100`. +2. O teste `&& num` é falso quando `num` é `null` ou um string vazio. Então, o loop `while` também é interrompido. + +P.S. Se `num` é `null`, então `num <= 100` é verdadeiro. Por isso, sem o segundo teste, o loop não iria encerrar se o usuário clicasse em "CANCELAR". Ambos os testes são necessários. 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 new file mode 100644 index 000000000..b2253a61a --- /dev/null +++ b/1-js/02-first-steps/12-while-for/6-repeat-until-correct/task.md @@ -0,0 +1,13 @@ +importance: 5 + +--- + +# Repetir até que o input esteja correto + +Escreva um loop que peça um número maior que `100`. Se o usuário digitar outro número, peça para digite digitar novamente. + +O loop deve pedir um número até que o usuário digite um número maior que `100` ou cancele o diálogo/submeta uma linha em branco. + +Aqui podemos assumir que o usuário só digita números. Não é preciso implementar um tratamento especial para inputs não-numéricos neste exercício. + +[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 new file mode 100644 index 000000000..a011f54db --- /dev/null +++ b/1-js/02-first-steps/12-while-for/7-list-primes/solution.md @@ -0,0 +1,29 @@ +Há muitos algotimos para esta tarefa. + +Vamos utilizar um loop dentro de outro (isto é, aninhado): + +```js +Para cada i no intervalo { + testar se i tem um divisor de 1 a i + se sim => o valor não é um primo + se não => o valor e um primo, mostre-o +} +``` + +O código usando um label: + +```js run +let n = 10; + +nextPrime: +for (let i = 2; i <= n; i++) { // para cada i... + + for (let j = 2; j < i; j++) { // procurar um divisor.. + if (i % j == 0) continue nextPrime; // não é primo, passar para o próximo i + } + + alert( i ); // é primo +} +``` + +Há muitas maneiras de otimizá-lo. Por exemplo, podemos procurar divisores de `2` até a raiz quadrada de `i`. De qualquer modo, se quisermos ser realmente eficientes para intervalos maiores, precisamos mudar a abordagem e nos embasar em matemática avançada e algoritmos complexos como o [Crivo Quadrático](https://en.wikipedia.org/wiki/Quadratic_sieve), o [Crivo do Corpo de Números Geral](https://en.wikipedia.org/wiki/General_number_field_sieve), etc. \ No newline at end of file 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 new file mode 100644 index 000000000..8146424fa --- /dev/null +++ b/1-js/02-first-steps/12-while-for/7-list-primes/task.md @@ -0,0 +1,17 @@ +importance: 3 + +--- + +# Retornar número primos + +Um número inteiro maior que `1` é chamado de [primo](https://pt.wikipedia.org/wiki/Número_primo) se ele não puder ser divido por nada exceto por `1` e por si mesmo sem gerar um resto. + +Em outras palavras, `n > 1` é um primo se ele não puder ser dividido sem resto por nada além de `1` e `n`. + +Por exemplo, `5` é um primo, pois não pode ser dividido sem resto por `2`, `3` e `4`. + +**Escreve o código que retorne números primos no intervalo de `2` a `n`.** + +Para `n = 10`, o resultado será `2,3,5,7`. + +P.S. O código deve funcionar para qualquer `n`, e não pré-estabelecido para um valor fixo. diff --git a/1-js/02-first-steps/12-while-for/article.md b/1-js/02-first-steps/12-while-for/article.md new file mode 100644 index 000000000..584612b33 --- /dev/null +++ b/1-js/02-first-steps/12-while-for/article.md @@ -0,0 +1,383 @@ +# Loops: while e for + +Frequentemente precisamos repetir ações. + +Por exemplo, retornar itens de uma lista, um atrás do outro, ou apenas executar o mesmo código para cada número de 1 a 10. + +*Loops* são uma maneira de repetir o mesmo código múltiplas vezes. + +## O loop "while" + +O `while` loop tem a sintaxe seguinte: + +```js +while (condição) { + // código + // chamado de "loop body" (corpo do loop) +} +``` + +Enquanto `condição` for verdadeira, o `código` do corpo do loop é executado. + +Por exemplo, o loop abaixo retorna `i` enquanto `i < 3`: + +```js run +let i = 0; +while (i < 3) { // retorna 0, depois 1, depois 2 + alert( i ); + i++; +} +``` + +Uma única execução do corpo do loop é chamada de *uma iteração*. O loop no exemplo acima realiza três iterações. + +Se `i++` não estivesse presente no exemplo acima, o loop repetiria (teoricamente) para sempre. Na prática, o navegador nos oferece maneira de interromper tais loops, e em JavaScript server-side, é possível matar o processo. + +Qualquer expressão ou variável pode ser uma condição para um loop, não apenas comparações: a condição é avaliada e convertida por `while` para um booleano. + +Por exemplo, uma maneira mais curta de escrever `while (i != 0)` é `while (i)`: + +```js run +let i = 3; +*!* +while (i) { // quando i se tornar 0, a condição se torna falsa, e o loop para +*/!* + alert( i ); + i--; +} +``` + +````smart header="Colchetes não são necessários se o corpo possuir só uma linha" +Se o corpo do loop possuir uma única declaração, podemos omitir os colchetes `{...}`: + +```js run +let i = 3; +*!* +while (i) alert(i--); +*/!* +``` +```` + +## O loop "do..while" + +A verificação da condição pode ser movida *abaixo* do corpo do loop utilizando a sintaxe `do..while`: + +```js +do { + // corpo do loop +} while (condição); +``` + +O loop vai executar primeiro o corpo, depois checar a condição e, enquanto ela permanecer verdadeira, executar o corpo novamente. + +Por exemplo: + +```js run +let i = 0; +do { + alert( i ); + i++; +} while (i < 3); +``` + +Esta forma de sintaxe deve ser usada apenas quando você deseja que o corpo do loop seja executado **pelo menos uma vez**, independente de a condição ser verdadeira. Geralmente, prefere-se a outra forma: `while(...) {...}`. + +## O loop "for" + +O loop `for` é o mais comumente utilizado. + +Ele tem esse formato: + +```js +for (início; condição; etapa) { + // ... corpo do loop ... +} +``` + +Vamos aprender o que significam cada uma dessas partes através de exemplos. O loop abaixo executa `alert(i)` para `i` de `0` a (não incluso) `3`: + +```js run +for (let i = 0; i < 3; i++) { // retorna 0, depois 1, depois 2 + alert(i); +} +``` + +Vamos examinar a declaração `for` parte por parte: + +| part | | | +|----------|------------|--------------------------------------------------------------------------------| +| início | `i = 0` | Executado uma vez na entrada do loop. | +| condição | `i < 3` | Verificada a cada iteração do loop. Se falsa, o loop é interrompido. | +| etapa | `i++` | Executado depois do corpo, a cada iteração, mas antes de verificar a condição. | +| corpo | `alert(i)` | Executado repetidamente enquanto a condição for verdadeira. | + + +O algoritmo geral do loop funciona assim: +``` +Executar início +→ (se condição verdadeira → executar corpo e executar etapa) +→ (se condição verdadeira → executar corpo e executar etapa) +→ (se condição verdadeira → executar corpo e executar etapa) +→ ... +``` + +Caso loops sejam novos para você, pode ser útil voltar ao exemplo e reproduzir sua execução passo-a-passo em uma folha de papel. + +No nosso exemplo, o que acontece exatamente é isso: + +```js +// for (let i = 0; i < 3; i++) alert(i) + +// executar condição +let i = 0 +// se condição verdadeira → executar corpo e executar etapa +if (i < 3) { alert(i); i++ } +// se condição verdadeira → executar corpo e executar etapa +if (i < 3) { alert(i); i++ } +// se condição verdadeira → executar corpo e executar etapa +if (i < 3) { alert(i); i++ } +// ...encerrar, pois agora i == 3 +``` + +````smart header="Declaração de variável inline" +Aqui, a variável "de contagem" `i` é declarada diretamente no loop. Isso é chamado de declaração de variável "inline". Tais variáveis são visíveis somente no interior do loop. + +```js run +for (*!*let*/!* i = 0; i < 3; i++) { + alert(i); // 0, 1, 2 +} +alert(i); // erro, variável não existente +``` + +Ao invés de definir a variável, podemos utilizar uma já existente: + +```js run +let i = 0; + +for (i = 0; i < 3; i++) { // usando uma variável pré-existente + alert(i); // 0, 1, 2 +} + +alert(i); // 3, visível, porque declarada fora do loop +``` + +```` + + +### Omitindo partes + +Qualquer parte de `for` pode ser omitida. + +Por exemplo, podemos omitir `início` caso não seja necessário fazer nada no início do loop. + +Como neste exemplo: + +```js run +let i = 0; // já temos i declarada e atribuída + +for (; i < 3; i++) { // "início" não é necessário + alert( i ); // 0, 1, 2 +} +``` + +Também podemos remover a parte da `etapa`: + +```js run +let i = 0; + +for (; i < 3;) { + alert( i++ ); +} +``` + +Isso torna o loop idêntico a `while (i < 3)`. + +Na verdade, podemos remover tudo, criando um loop infinito: + +```js +for (;;) { + // repete sem limites +} +``` + +Note que os dois pontos-e-vírgulas `;` dentro do `for` devem estar presentes. Caso contrário, haverá um erro de sintaxe. + +## Quebrando o loop + +Normalmente, um loop se encerra quando sua condição se torna falsa. + +Mas podemos forçar a saída a qualquer momento utilizando o comando especial `break`. + +Por exemplo, o loop abaixo pede ao usuário uma série de números, e "quebra" quando nenhum número é informado: + +```js +let sum = 0; + +while (true) { + + let value = +prompt("Digite um número", ''); + +*!* + if (!value) break; // (*) +*/!* + + sum += value; + +} +alert( 'Soma: ' + sum ); +``` + +O comando `break` é ativado na linha `(*)` se o usuário deixa a linha em branco ou cancela o diálogo. Ele interrompe o loop imediatamente, passando o controle à primeira linha depois do loop. Neste caso, `alert`. + +A combinação "loop infinito " `break` quando necessário" é ótima para situações onde a condição do loop precisa ser verificada não no início ou no fim do loop, mas no meio, ou até mesmo em vários lugares do corpo do loop. + +## Continue para a próxima iteração [#continue] + +O comando `continue` é uma "versão mais light" de `break`. Ele não interrompe o loop como um todo. Ao invés disso, ele interrompe a iteração atual e força o loop a começar uma nova (se a condição permitir). + +Você pode utilizá-lo caso a iteração atual já não seja útil e você deseje passar para a próxima. + +O loop abaixo usa `continue` para exibir apenas valores ímpares: + +```js run no-beautify +for (let i = 0; i < 10; i++) { + + // se verdadeiro, pular o restante do corpo + *!*if (i % 2 == 0) continue;*/!* + + alert(i); // 1, then 3, 5, 7, 9 +} +``` + +Para valores pares de `i`, o comando `continue` interrompe a execução do corpo e passa o controle para a próxima iteração de `for` (com o número seguinte). Então `alert` só é chamado para valores ímpares. + +````smart header="O comando `continue` ajuda a reduzir aninhamento" +Um loop que retorna apenas valores ímpares poderia ter a seguinte forma: + +```js +for (let i = 0; i < 10; i++) { + + if (i % 2) { + alert( i ); + } + +} +``` + +De uma perspectiva técnica, isso é idêntico ao exemplo anterior. Certamente, podemos apenas envolver o código em um bloco `if` ao invés de utilizar `continue`. + +Mas como efeito colateral, isso criou mais um nível de aninhamento (o `alert` dentro dos colchetes). Se o código dentro de `if` for mais longo do que algumas linhas, isso pode reduzir a legibilidade de forma geral. +```` + +````warn header="Não utilize `break/continue` do lado direito de '?'" +Note que construções sintáticas que não sejam expressões não podem ser utilizados com o operador ternário `?`. Em particular, comandos como `break/continue` não são permitidos nesta posição. + +Por exemplo, se tomarmos este código: + +```js +if (i > 5) { + alert(i); +} else { + continue; +} +``` + +...e reescrevermos utilizando o ponto de interrogação: + +```js no-beautify +(i > 5) ? alert(i) : *!*continue*/!*; // continue não é permitido aqui +``` + +...ele para de funcionar. Códigos como este vão gerar um erro de sintaxe. + +Esta é apenas mais uma razão para não utilizar o operador ternário `?` no lugar de `if`. +```` + +## Labels for break/continue + +Às vezes, precisamos quebrar vários loops aninhados de uma vez só. + +Por exemplo, no código abaixo nós utilizamos dois loops, com `i` e `j`, dando as coordenadas `(i, j)` de `(0,0)` a `(3,3)`: + +```js run no-beautify +for (let i = 0; i < 3; i++) { + + for (let j = 0; j < 3; j++) { + + let input = prompt(`Valor nas coordenadas (${i},${j})`, ''); + + // e se quisermos sair daqui diretamente para "Pronto" (abaixo)? + } +} + +alert('Pronto!'); +``` + +Precisamos de uma maneira de interromper o processo caso o usuário cancele o input. + +O `break` comum depois de `input` quebraria apenas o loop interno. Isso não é suficiente--labels, ao resgate! + +Um *label* é um identificador com dois pontos antes de um loop: +```js +labelName: for (...) { + ... +} +``` + +A declaração `break ` no loop abaixo quebra o loop designado pelo label: + +```js run no-beautify +*!*outer:*/!* for (let i = 0; i < 3; i++) { + + for (let j = 0; j < 3; j++) { + + let input = prompt(`Valor nas coordenadas (${i},${j})`, ''); + + // se retornar um string vazio ou cancelar, quebrar ambos os loops + if (!input) *!*break outer*/!*; // (*) + + // fazer algo com input... + } +} +alert('Pronto!'); +``` + +No código acima, `break outer` procura acima dele o label chamado `outer` e quebra aquele loop. + +Assim o controle vai direto de `(*)` para `alert('Pronto!')`. + +Também podemos colocar o label em uma linha separada: + +```js no-beautify +outer: +for (let i = 0; i < 3; i++) { ... } +``` + +O comando `continue` também pode ser utilizado com um label. Nesse caso, a execução do código pula para a próxima iteração do loop nomeado pelo label. + +````warn header="Labels não significam \"ir para\"" +Labels não nos permitem pular para qualquer lugar do código. + +Por exemplo, é impossível fazer isso: +```js +break label; // pula para label? Não. + +label: for (...) +``` + +Uma chamada de `break/continue` só é possível de dentro de um loop e o label deve estar em algum lugar acima do comando. +```` + +## Resumo + +Nós cobrimos 3 tipos de loops: + +- `while` -- A condição é verificada antes de cada iteração. +- `do..while` -- A condição é verificada após cada iteração. +- `for (;;)` -- A condição é verificada antes de cada iteração, configurações adicionais disponíveis. + +Para fazer um loop "infinito", geralmente se utiliza a construção `white(true)`. Este loop, como qualquer outro, pode ser interrompido com o comando `break`. + +Se não quisermos fazer nada na iteração atual e gostaríamos de pular para a próxima iteração, podemos utilizar o comando `continue`. + +`break/continue` suportam labels antes do loop. Um label é a única maneira de fazer um `break/continue` escapar um loop aninhado e ir para o loop de fora. \ No newline at end of file From 78ae1b78e711789a704b9052f6a2470abe6bac7c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=81lvaro=20Antonio?= Date: Mon, 21 Oct 2019 17:25:43 -0300 Subject: [PATCH 04/13] corrections according to the review --- 1-js/02-first-steps/12-while-for/1-loop-last-value/solution.md | 2 +- 1-js/02-first-steps/12-while-for/7-list-primes/task.md | 3 ++- 2 files changed, 3 insertions(+), 2 deletions(-) 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 index a7b1840f2..beece44a2 100644 --- 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 @@ -8,7 +8,7 @@ while (i) { } ``` -Cada iteração do loop subtrai `1` de `i`. O teste `while(i)` interrompe o loop quando `i = 0`. +Cada iteração do loop decresce `i` em `1`. O teste `while(i)` interrompe o loop quando `i = 0`. Portanto, as etapas do loop formam a seguinte sequência ("loop desenrolado"): 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 index 8146424fa..64377c5ed 100644 --- 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 @@ -4,7 +4,8 @@ importance: 3 # Retornar número primos -Um número inteiro maior que `1` é chamado de [primo](https://pt.wikipedia.org/wiki/Número_primo) se ele não puder ser divido por nada exceto por `1` e por si mesmo sem gerar um resto. +Um número inteiro maior que `1` é chamado de [primo](https://pt.wikipedia.org/wiki/Número_primo) se ele não puder ser divido por nenhum outro número exceto por `1` e por si mesmo sem gerar um resto. + Em outras palavras, `n > 1` é um primo se ele não puder ser dividido sem resto por nada além de `1` e `n`. From cfa3af4dc44d54ce610ce0b8ab6519330f1ed08a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=81lvaro=20Antonio?= Date: Mon, 21 Oct 2019 17:31:01 -0300 Subject: [PATCH 05/13] fix typo --- 1-js/02-first-steps/12-while-for/7-list-primes/task.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) 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 index 64377c5ed..6e517b8b9 100644 --- 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 @@ -11,7 +11,7 @@ Em outras palavras, `n > 1` é um primo se ele não puder ser dividido sem resto Por exemplo, `5` é um primo, pois não pode ser dividido sem resto por `2`, `3` e `4`. -**Escreve o código que retorne números primos no intervalo de `2` a `n`.** +**Escreva o código que retorne números primos no intervalo de `2` a `n`.** Para `n = 10`, o resultado será `2,3,5,7`. From 765fbe06400d3a944e01499d157d2d5b1031a302 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=81lvaro=20Antonio?= Date: Mon, 21 Oct 2019 17:38:53 -0300 Subject: [PATCH 06/13] deleting all work to commit with proper credentials --- .../1-loop-last-value/solution.md | 25 -- .../12-while-for/1-loop-last-value/task.md | 15 - .../2-which-value-while/solution.md | 32 -- .../12-while-for/2-which-value-while/task.md | 22 - .../3-which-value-for/solution.md | 17 - .../12-while-for/3-which-value-for/task.md | 20 - .../12-while-for/4-for-even/solution.md | 11 - .../12-while-for/4-for-even/task.md | 9 - .../5-replace-for-while/solution.md | 10 - .../12-while-for/5-replace-for-while/task.md | 14 - .../6-repeat-until-correct/solution.md | 15 - .../6-repeat-until-correct/task.md | 13 - .../12-while-for/7-list-primes/solution.md | 29 -- .../12-while-for/7-list-primes/task.md | 18 - 1-js/02-first-steps/12-while-for/article.md | 383 ------------------ 15 files changed, 633 deletions(-) delete mode 100644 1-js/02-first-steps/12-while-for/1-loop-last-value/solution.md delete mode 100644 1-js/02-first-steps/12-while-for/1-loop-last-value/task.md delete mode 100644 1-js/02-first-steps/12-while-for/2-which-value-while/solution.md delete mode 100644 1-js/02-first-steps/12-while-for/2-which-value-while/task.md delete mode 100644 1-js/02-first-steps/12-while-for/3-which-value-for/solution.md delete mode 100644 1-js/02-first-steps/12-while-for/3-which-value-for/task.md delete mode 100644 1-js/02-first-steps/12-while-for/4-for-even/solution.md delete mode 100644 1-js/02-first-steps/12-while-for/4-for-even/task.md delete mode 100644 1-js/02-first-steps/12-while-for/5-replace-for-while/solution.md delete mode 100644 1-js/02-first-steps/12-while-for/5-replace-for-while/task.md delete mode 100644 1-js/02-first-steps/12-while-for/6-repeat-until-correct/solution.md delete mode 100644 1-js/02-first-steps/12-while-for/6-repeat-until-correct/task.md delete mode 100644 1-js/02-first-steps/12-while-for/7-list-primes/solution.md delete mode 100644 1-js/02-first-steps/12-while-for/7-list-primes/task.md delete mode 100644 1-js/02-first-steps/12-while-for/article.md 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 deleted file mode 100644 index beece44a2..000000000 --- a/1-js/02-first-steps/12-while-for/1-loop-last-value/solution.md +++ /dev/null @@ -1,25 +0,0 @@ -Resposta: `1`. - -```js run -let i = 3; - -while (i) { - alert( i-- ); -} -``` - -Cada iteração do loop decresce `i` em `1`. O teste `while(i)` interrompe o loop quando `i = 0`. - -Portanto, as etapas do loop formam a seguinte sequência ("loop desenrolado"): - -```js -let i = 3; - -alert(i--); // exibe 3, decresce i para 2 - -alert(i--) // exibe 2, decresce i para 1 - -alert(i--) // exibe 1, decresce i para 0 - -// pronto, o teste while(i) interrompe o loop -``` 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 deleted file mode 100644 index dd931937d..000000000 --- a/1-js/02-first-steps/12-while-for/1-loop-last-value/task.md +++ /dev/null @@ -1,15 +0,0 @@ -importance: 3 - ---- - -# Último valor do loop - -Qual é o último valor exibido no alerta por este código? Por quê? - -```js -let i = 3; - -while (i) { - alert( i-- ); -} -``` 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 deleted file mode 100644 index 3a8cc5d6e..000000000 --- a/1-js/02-first-steps/12-while-for/2-which-value-while/solution.md +++ /dev/null @@ -1,32 +0,0 @@ -Este exercício demonstra como formas posfixadas/prefixadas podem levar a resultados distintos quando utilizadas em comparações. - -1. **De 1 a 4** - - ```js run - let i = 0; - while (++i < 5) alert( i ); - ``` - - O primeiro valor é `i = 1`, pois `++i` primeiro incrementa `i` e em seguida retorna o novo valor. Então, a primeira comparação é `1 < 5` e o `alert` exibe `1`. - - Em seguida vêm `2, 3, 4…` -- os valores aparecem um depois do outro. A comparação sempre usa o valor incrementado, pois `++` vem antes da variável. - - Finalmente, `i = 4` é incrementado a `5`, a comparação `while(5 < 5)` falha, e o loop termina. Assim, `5` não é exibido. - -2. **De 1 a 5** - - ```js run - let i = 0; - while (i++ < 5) alert( i ); - ``` - - O primeiro valor é novamente `i = 1`. A forma posfixada `i++`incrementa `i` e em seguida retorna o valor *antigo*, então a comparação `i++ < 5` utilizará `i = 0` (diferente de `++i < 5`). - - Mas a chamada de `alert` é separada. Ela é uma declaração distinta que executa após o incremento e a comparaçào. Assim, ela recebe o valor atual `i = 1`. - - Em seguida, vêm `2, 3, 4…` - - Vamos parar em `i = 4`. A forma prefixada `++i` iria incrementar e utilizar `5` na comparação. Mas aqui temos a forma posfixada `i++`. Ela incrementa `i` para `5`, mas retorna o valor antigo. Portanto a comparação é, na verdade, `while(4 < 5)` -- verdadeira, e o controle passa para `alert`. - - O valor `i = 5` é o último, porque na próxima etapa `while(5 < 5)` é falso. - \ No newline at end of file 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 deleted file mode 100644 index aefb036d3..000000000 --- a/1-js/02-first-steps/12-while-for/2-which-value-while/task.md +++ /dev/null @@ -1,22 +0,0 @@ -importance: 4 - ---- - -# Quais valores o loop while retorna? - -Para cada iteração dos loops, anote o valor que ele retorna, depois compare com a solução. - -Ambos os loops retornam em `alert` os mesmo valores, ou não? - -1. A forma prefixada `++i`: - - ```js - let i = 0; - while (++i < 5) alert( i ); - ``` -2. A forma posfixada `i++`: - - ```js - let i = 0; - while (i++ < 5) alert( i ); - ``` 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 deleted file mode 100644 index 55f27ec83..000000000 --- a/1-js/02-first-steps/12-while-for/3-which-value-for/solution.md +++ /dev/null @@ -1,17 +0,0 @@ -**Resposta: de `0` a `4` nos dois casos.** - -```js run -for (let i = 0; i < 5; ++i) alert( i ); - -for (let i = 0; i < 5; i++) alert( i ); -``` - -Isso pode ser facilmente deduzido do algoritmo de `for`: - -1. Executar `i = 0` uma vez antes de tudo (begin). -2. Verificar a condição `i < 5`. -3. Caso verdadeira (`true`), executar o corpo do loop `alert(i)`, e em seguida `i++`. - -O incremento `i++` é separado do teste da condição (2). Trata-se de outra declaração. - -O valor retornado pelo incremento não é utilizado aqui, então não há diferença entre `i++` e `++i`. \ No newline at end of file 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 deleted file mode 100644 index abc4a37be..000000000 --- a/1-js/02-first-steps/12-while-for/3-which-value-for/task.md +++ /dev/null @@ -1,20 +0,0 @@ -importance: 4 - ---- - -# Quais valores são mostrados pelo loop "for"? - -Pada cada loop, anote quais os valores retornados. Depois, compare com a resposta. - -Ambos os loops retornam em `alert` os mesmo valores, ou não? - -1. A forma posfixada: - - ```js - for (let i = 0; i < 5; i++) alert( i ); - ``` -2. A forma prefixada: - - ```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 deleted file mode 100644 index f7e6e30f8..000000000 --- a/1-js/02-first-steps/12-while-for/4-for-even/solution.md +++ /dev/null @@ -1,11 +0,0 @@ - - -```js run demo -for (let i = 2; i <= 10; i++) { - if (i % 2 == 0) { - alert( i ); - } -} -``` - -Utilizamos o operador "módulo" `%` aqui para obter o resto e testar se o valor é par. 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 deleted file mode 100644 index 5627f1f70..000000000 --- a/1-js/02-first-steps/12-while-for/4-for-even/task.md +++ /dev/null @@ -1,9 +0,0 @@ -importance: 5 - ---- - -# Retornar valores pares no loop - -Utilize o loop `for` para retornar números pares de `2` a `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 deleted file mode 100644 index 5579686ef..000000000 --- a/1-js/02-first-steps/12-while-for/5-replace-for-while/solution.md +++ /dev/null @@ -1,10 +0,0 @@ - - -```js run -let i = 0; -while (i < 3) { - 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 deleted file mode 100644 index a38929c63..000000000 --- a/1-js/02-first-steps/12-while-for/5-replace-for-while/task.md +++ /dev/null @@ -1,14 +0,0 @@ -importance: 5 - ---- - -# Substituir "for" por "while" - -Reescreva o código, mudando o loop `for` para `while` sem alterar seu comportamento (o resultado deve continuar o mesmo). - -```js run -for (let i = 0; i < 3; 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 deleted file mode 100644 index f7ce57442..000000000 --- a/1-js/02-first-steps/12-while-for/6-repeat-until-correct/solution.md +++ /dev/null @@ -1,15 +0,0 @@ - -```js run demo -let num; - -do { - num = prompt("Digite um número maior que 100:", 0); -} while (num <= 100 && num); -``` - -O loop `do..while` repete enquanto ambos os testes sejam verdadeiros: - -1. O teste `num <= 100` -- isto é, o valor digitado ainda não é maior que `100`. -2. O teste `&& num` é falso quando `num` é `null` ou um string vazio. Então, o loop `while` também é interrompido. - -P.S. Se `num` é `null`, então `num <= 100` é verdadeiro. Por isso, sem o segundo teste, o loop não iria encerrar se o usuário clicasse em "CANCELAR". Ambos os testes são necessários. 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 deleted file mode 100644 index b2253a61a..000000000 --- a/1-js/02-first-steps/12-while-for/6-repeat-until-correct/task.md +++ /dev/null @@ -1,13 +0,0 @@ -importance: 5 - ---- - -# Repetir até que o input esteja correto - -Escreva um loop que peça um número maior que `100`. Se o usuário digitar outro número, peça para digite digitar novamente. - -O loop deve pedir um número até que o usuário digite um número maior que `100` ou cancele o diálogo/submeta uma linha em branco. - -Aqui podemos assumir que o usuário só digita números. Não é preciso implementar um tratamento especial para inputs não-numéricos neste exercício. - -[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 deleted file mode 100644 index a011f54db..000000000 --- a/1-js/02-first-steps/12-while-for/7-list-primes/solution.md +++ /dev/null @@ -1,29 +0,0 @@ -Há muitos algotimos para esta tarefa. - -Vamos utilizar um loop dentro de outro (isto é, aninhado): - -```js -Para cada i no intervalo { - testar se i tem um divisor de 1 a i - se sim => o valor não é um primo - se não => o valor e um primo, mostre-o -} -``` - -O código usando um label: - -```js run -let n = 10; - -nextPrime: -for (let i = 2; i <= n; i++) { // para cada i... - - for (let j = 2; j < i; j++) { // procurar um divisor.. - if (i % j == 0) continue nextPrime; // não é primo, passar para o próximo i - } - - alert( i ); // é primo -} -``` - -Há muitas maneiras de otimizá-lo. Por exemplo, podemos procurar divisores de `2` até a raiz quadrada de `i`. De qualquer modo, se quisermos ser realmente eficientes para intervalos maiores, precisamos mudar a abordagem e nos embasar em matemática avançada e algoritmos complexos como o [Crivo Quadrático](https://en.wikipedia.org/wiki/Quadratic_sieve), o [Crivo do Corpo de Números Geral](https://en.wikipedia.org/wiki/General_number_field_sieve), etc. \ No newline at end of file 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 deleted file mode 100644 index 6e517b8b9..000000000 --- a/1-js/02-first-steps/12-while-for/7-list-primes/task.md +++ /dev/null @@ -1,18 +0,0 @@ -importance: 3 - ---- - -# Retornar número primos - -Um número inteiro maior que `1` é chamado de [primo](https://pt.wikipedia.org/wiki/Número_primo) se ele não puder ser divido por nenhum outro número exceto por `1` e por si mesmo sem gerar um resto. - - -Em outras palavras, `n > 1` é um primo se ele não puder ser dividido sem resto por nada além de `1` e `n`. - -Por exemplo, `5` é um primo, pois não pode ser dividido sem resto por `2`, `3` e `4`. - -**Escreva o código que retorne números primos no intervalo de `2` a `n`.** - -Para `n = 10`, o resultado será `2,3,5,7`. - -P.S. O código deve funcionar para qualquer `n`, e não pré-estabelecido para um valor fixo. diff --git a/1-js/02-first-steps/12-while-for/article.md b/1-js/02-first-steps/12-while-for/article.md deleted file mode 100644 index 584612b33..000000000 --- a/1-js/02-first-steps/12-while-for/article.md +++ /dev/null @@ -1,383 +0,0 @@ -# Loops: while e for - -Frequentemente precisamos repetir ações. - -Por exemplo, retornar itens de uma lista, um atrás do outro, ou apenas executar o mesmo código para cada número de 1 a 10. - -*Loops* são uma maneira de repetir o mesmo código múltiplas vezes. - -## O loop "while" - -O `while` loop tem a sintaxe seguinte: - -```js -while (condição) { - // código - // chamado de "loop body" (corpo do loop) -} -``` - -Enquanto `condição` for verdadeira, o `código` do corpo do loop é executado. - -Por exemplo, o loop abaixo retorna `i` enquanto `i < 3`: - -```js run -let i = 0; -while (i < 3) { // retorna 0, depois 1, depois 2 - alert( i ); - i++; -} -``` - -Uma única execução do corpo do loop é chamada de *uma iteração*. O loop no exemplo acima realiza três iterações. - -Se `i++` não estivesse presente no exemplo acima, o loop repetiria (teoricamente) para sempre. Na prática, o navegador nos oferece maneira de interromper tais loops, e em JavaScript server-side, é possível matar o processo. - -Qualquer expressão ou variável pode ser uma condição para um loop, não apenas comparações: a condição é avaliada e convertida por `while` para um booleano. - -Por exemplo, uma maneira mais curta de escrever `while (i != 0)` é `while (i)`: - -```js run -let i = 3; -*!* -while (i) { // quando i se tornar 0, a condição se torna falsa, e o loop para -*/!* - alert( i ); - i--; -} -``` - -````smart header="Colchetes não são necessários se o corpo possuir só uma linha" -Se o corpo do loop possuir uma única declaração, podemos omitir os colchetes `{...}`: - -```js run -let i = 3; -*!* -while (i) alert(i--); -*/!* -``` -```` - -## O loop "do..while" - -A verificação da condição pode ser movida *abaixo* do corpo do loop utilizando a sintaxe `do..while`: - -```js -do { - // corpo do loop -} while (condição); -``` - -O loop vai executar primeiro o corpo, depois checar a condição e, enquanto ela permanecer verdadeira, executar o corpo novamente. - -Por exemplo: - -```js run -let i = 0; -do { - alert( i ); - i++; -} while (i < 3); -``` - -Esta forma de sintaxe deve ser usada apenas quando você deseja que o corpo do loop seja executado **pelo menos uma vez**, independente de a condição ser verdadeira. Geralmente, prefere-se a outra forma: `while(...) {...}`. - -## O loop "for" - -O loop `for` é o mais comumente utilizado. - -Ele tem esse formato: - -```js -for (início; condição; etapa) { - // ... corpo do loop ... -} -``` - -Vamos aprender o que significam cada uma dessas partes através de exemplos. O loop abaixo executa `alert(i)` para `i` de `0` a (não incluso) `3`: - -```js run -for (let i = 0; i < 3; i++) { // retorna 0, depois 1, depois 2 - alert(i); -} -``` - -Vamos examinar a declaração `for` parte por parte: - -| part | | | -|----------|------------|--------------------------------------------------------------------------------| -| início | `i = 0` | Executado uma vez na entrada do loop. | -| condição | `i < 3` | Verificada a cada iteração do loop. Se falsa, o loop é interrompido. | -| etapa | `i++` | Executado depois do corpo, a cada iteração, mas antes de verificar a condição. | -| corpo | `alert(i)` | Executado repetidamente enquanto a condição for verdadeira. | - - -O algoritmo geral do loop funciona assim: -``` -Executar início -→ (se condição verdadeira → executar corpo e executar etapa) -→ (se condição verdadeira → executar corpo e executar etapa) -→ (se condição verdadeira → executar corpo e executar etapa) -→ ... -``` - -Caso loops sejam novos para você, pode ser útil voltar ao exemplo e reproduzir sua execução passo-a-passo em uma folha de papel. - -No nosso exemplo, o que acontece exatamente é isso: - -```js -// for (let i = 0; i < 3; i++) alert(i) - -// executar condição -let i = 0 -// se condição verdadeira → executar corpo e executar etapa -if (i < 3) { alert(i); i++ } -// se condição verdadeira → executar corpo e executar etapa -if (i < 3) { alert(i); i++ } -// se condição verdadeira → executar corpo e executar etapa -if (i < 3) { alert(i); i++ } -// ...encerrar, pois agora i == 3 -``` - -````smart header="Declaração de variável inline" -Aqui, a variável "de contagem" `i` é declarada diretamente no loop. Isso é chamado de declaração de variável "inline". Tais variáveis são visíveis somente no interior do loop. - -```js run -for (*!*let*/!* i = 0; i < 3; i++) { - alert(i); // 0, 1, 2 -} -alert(i); // erro, variável não existente -``` - -Ao invés de definir a variável, podemos utilizar uma já existente: - -```js run -let i = 0; - -for (i = 0; i < 3; i++) { // usando uma variável pré-existente - alert(i); // 0, 1, 2 -} - -alert(i); // 3, visível, porque declarada fora do loop -``` - -```` - - -### Omitindo partes - -Qualquer parte de `for` pode ser omitida. - -Por exemplo, podemos omitir `início` caso não seja necessário fazer nada no início do loop. - -Como neste exemplo: - -```js run -let i = 0; // já temos i declarada e atribuída - -for (; i < 3; i++) { // "início" não é necessário - alert( i ); // 0, 1, 2 -} -``` - -Também podemos remover a parte da `etapa`: - -```js run -let i = 0; - -for (; i < 3;) { - alert( i++ ); -} -``` - -Isso torna o loop idêntico a `while (i < 3)`. - -Na verdade, podemos remover tudo, criando um loop infinito: - -```js -for (;;) { - // repete sem limites -} -``` - -Note que os dois pontos-e-vírgulas `;` dentro do `for` devem estar presentes. Caso contrário, haverá um erro de sintaxe. - -## Quebrando o loop - -Normalmente, um loop se encerra quando sua condição se torna falsa. - -Mas podemos forçar a saída a qualquer momento utilizando o comando especial `break`. - -Por exemplo, o loop abaixo pede ao usuário uma série de números, e "quebra" quando nenhum número é informado: - -```js -let sum = 0; - -while (true) { - - let value = +prompt("Digite um número", ''); - -*!* - if (!value) break; // (*) -*/!* - - sum += value; - -} -alert( 'Soma: ' + sum ); -``` - -O comando `break` é ativado na linha `(*)` se o usuário deixa a linha em branco ou cancela o diálogo. Ele interrompe o loop imediatamente, passando o controle à primeira linha depois do loop. Neste caso, `alert`. - -A combinação "loop infinito " `break` quando necessário" é ótima para situações onde a condição do loop precisa ser verificada não no início ou no fim do loop, mas no meio, ou até mesmo em vários lugares do corpo do loop. - -## Continue para a próxima iteração [#continue] - -O comando `continue` é uma "versão mais light" de `break`. Ele não interrompe o loop como um todo. Ao invés disso, ele interrompe a iteração atual e força o loop a começar uma nova (se a condição permitir). - -Você pode utilizá-lo caso a iteração atual já não seja útil e você deseje passar para a próxima. - -O loop abaixo usa `continue` para exibir apenas valores ímpares: - -```js run no-beautify -for (let i = 0; i < 10; i++) { - - // se verdadeiro, pular o restante do corpo - *!*if (i % 2 == 0) continue;*/!* - - alert(i); // 1, then 3, 5, 7, 9 -} -``` - -Para valores pares de `i`, o comando `continue` interrompe a execução do corpo e passa o controle para a próxima iteração de `for` (com o número seguinte). Então `alert` só é chamado para valores ímpares. - -````smart header="O comando `continue` ajuda a reduzir aninhamento" -Um loop que retorna apenas valores ímpares poderia ter a seguinte forma: - -```js -for (let i = 0; i < 10; i++) { - - if (i % 2) { - alert( i ); - } - -} -``` - -De uma perspectiva técnica, isso é idêntico ao exemplo anterior. Certamente, podemos apenas envolver o código em um bloco `if` ao invés de utilizar `continue`. - -Mas como efeito colateral, isso criou mais um nível de aninhamento (o `alert` dentro dos colchetes). Se o código dentro de `if` for mais longo do que algumas linhas, isso pode reduzir a legibilidade de forma geral. -```` - -````warn header="Não utilize `break/continue` do lado direito de '?'" -Note que construções sintáticas que não sejam expressões não podem ser utilizados com o operador ternário `?`. Em particular, comandos como `break/continue` não são permitidos nesta posição. - -Por exemplo, se tomarmos este código: - -```js -if (i > 5) { - alert(i); -} else { - continue; -} -``` - -...e reescrevermos utilizando o ponto de interrogação: - -```js no-beautify -(i > 5) ? alert(i) : *!*continue*/!*; // continue não é permitido aqui -``` - -...ele para de funcionar. Códigos como este vão gerar um erro de sintaxe. - -Esta é apenas mais uma razão para não utilizar o operador ternário `?` no lugar de `if`. -```` - -## Labels for break/continue - -Às vezes, precisamos quebrar vários loops aninhados de uma vez só. - -Por exemplo, no código abaixo nós utilizamos dois loops, com `i` e `j`, dando as coordenadas `(i, j)` de `(0,0)` a `(3,3)`: - -```js run no-beautify -for (let i = 0; i < 3; i++) { - - for (let j = 0; j < 3; j++) { - - let input = prompt(`Valor nas coordenadas (${i},${j})`, ''); - - // e se quisermos sair daqui diretamente para "Pronto" (abaixo)? - } -} - -alert('Pronto!'); -``` - -Precisamos de uma maneira de interromper o processo caso o usuário cancele o input. - -O `break` comum depois de `input` quebraria apenas o loop interno. Isso não é suficiente--labels, ao resgate! - -Um *label* é um identificador com dois pontos antes de um loop: -```js -labelName: for (...) { - ... -} -``` - -A declaração `break ` no loop abaixo quebra o loop designado pelo label: - -```js run no-beautify -*!*outer:*/!* for (let i = 0; i < 3; i++) { - - for (let j = 0; j < 3; j++) { - - let input = prompt(`Valor nas coordenadas (${i},${j})`, ''); - - // se retornar um string vazio ou cancelar, quebrar ambos os loops - if (!input) *!*break outer*/!*; // (*) - - // fazer algo com input... - } -} -alert('Pronto!'); -``` - -No código acima, `break outer` procura acima dele o label chamado `outer` e quebra aquele loop. - -Assim o controle vai direto de `(*)` para `alert('Pronto!')`. - -Também podemos colocar o label em uma linha separada: - -```js no-beautify -outer: -for (let i = 0; i < 3; i++) { ... } -``` - -O comando `continue` também pode ser utilizado com um label. Nesse caso, a execução do código pula para a próxima iteração do loop nomeado pelo label. - -````warn header="Labels não significam \"ir para\"" -Labels não nos permitem pular para qualquer lugar do código. - -Por exemplo, é impossível fazer isso: -```js -break label; // pula para label? Não. - -label: for (...) -``` - -Uma chamada de `break/continue` só é possível de dentro de um loop e o label deve estar em algum lugar acima do comando. -```` - -## Resumo - -Nós cobrimos 3 tipos de loops: - -- `while` -- A condição é verificada antes de cada iteração. -- `do..while` -- A condição é verificada após cada iteração. -- `for (;;)` -- A condição é verificada antes de cada iteração, configurações adicionais disponíveis. - -Para fazer um loop "infinito", geralmente se utiliza a construção `white(true)`. Este loop, como qualquer outro, pode ser interrompido com o comando `break`. - -Se não quisermos fazer nada na iteração atual e gostaríamos de pular para a próxima iteração, podemos utilizar o comando `continue`. - -`break/continue` suportam labels antes do loop. Um label é a única maneira de fazer um `break/continue` escapar um loop aninhado e ir para o loop de fora. \ No newline at end of file From 787a0ecba45a6a7aa2c1abbc847778165e3dee68 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=81lvaro=20Antonio?= Date: Mon, 21 Oct 2019 17:39:58 -0300 Subject: [PATCH 07/13] commiting translation with proper credentials --- .../1-loop-last-value/solution.md | 25 ++ .../12-while-for/1-loop-last-value/task.md | 15 + .../2-which-value-while/solution.md | 32 ++ .../12-while-for/2-which-value-while/task.md | 22 + .../3-which-value-for/solution.md | 17 + .../12-while-for/3-which-value-for/task.md | 20 + .../12-while-for/4-for-even/solution.md | 11 + .../12-while-for/4-for-even/task.md | 9 + .../5-replace-for-while/solution.md | 10 + .../12-while-for/5-replace-for-while/task.md | 14 + .../6-repeat-until-correct/solution.md | 15 + .../6-repeat-until-correct/task.md | 13 + .../12-while-for/7-list-primes/solution.md | 29 ++ .../12-while-for/7-list-primes/task.md | 18 + 1-js/02-first-steps/12-while-for/article.md | 383 ++++++++++++++++++ 15 files changed, 633 insertions(+) create mode 100644 1-js/02-first-steps/12-while-for/1-loop-last-value/solution.md create mode 100644 1-js/02-first-steps/12-while-for/1-loop-last-value/task.md create mode 100644 1-js/02-first-steps/12-while-for/2-which-value-while/solution.md create mode 100644 1-js/02-first-steps/12-while-for/2-which-value-while/task.md create mode 100644 1-js/02-first-steps/12-while-for/3-which-value-for/solution.md create mode 100644 1-js/02-first-steps/12-while-for/3-which-value-for/task.md create mode 100644 1-js/02-first-steps/12-while-for/4-for-even/solution.md create mode 100644 1-js/02-first-steps/12-while-for/4-for-even/task.md create mode 100644 1-js/02-first-steps/12-while-for/5-replace-for-while/solution.md create mode 100644 1-js/02-first-steps/12-while-for/5-replace-for-while/task.md create mode 100644 1-js/02-first-steps/12-while-for/6-repeat-until-correct/solution.md create mode 100644 1-js/02-first-steps/12-while-for/6-repeat-until-correct/task.md create mode 100644 1-js/02-first-steps/12-while-for/7-list-primes/solution.md create mode 100644 1-js/02-first-steps/12-while-for/7-list-primes/task.md create mode 100644 1-js/02-first-steps/12-while-for/article.md 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 new file mode 100644 index 000000000..beece44a2 --- /dev/null +++ b/1-js/02-first-steps/12-while-for/1-loop-last-value/solution.md @@ -0,0 +1,25 @@ +Resposta: `1`. + +```js run +let i = 3; + +while (i) { + alert( i-- ); +} +``` + +Cada iteração do loop decresce `i` em `1`. O teste `while(i)` interrompe o loop quando `i = 0`. + +Portanto, as etapas do loop formam a seguinte sequência ("loop desenrolado"): + +```js +let i = 3; + +alert(i--); // exibe 3, decresce i para 2 + +alert(i--) // exibe 2, decresce i para 1 + +alert(i--) // exibe 1, decresce i para 0 + +// pronto, o teste while(i) interrompe o loop +``` 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 new file mode 100644 index 000000000..dd931937d --- /dev/null +++ b/1-js/02-first-steps/12-while-for/1-loop-last-value/task.md @@ -0,0 +1,15 @@ +importance: 3 + +--- + +# Último valor do loop + +Qual é o último valor exibido no alerta por este código? Por quê? + +```js +let i = 3; + +while (i) { + alert( i-- ); +} +``` 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 new file mode 100644 index 000000000..3a8cc5d6e --- /dev/null +++ b/1-js/02-first-steps/12-while-for/2-which-value-while/solution.md @@ -0,0 +1,32 @@ +Este exercício demonstra como formas posfixadas/prefixadas podem levar a resultados distintos quando utilizadas em comparações. + +1. **De 1 a 4** + + ```js run + let i = 0; + while (++i < 5) alert( i ); + ``` + + O primeiro valor é `i = 1`, pois `++i` primeiro incrementa `i` e em seguida retorna o novo valor. Então, a primeira comparação é `1 < 5` e o `alert` exibe `1`. + + Em seguida vêm `2, 3, 4…` -- os valores aparecem um depois do outro. A comparação sempre usa o valor incrementado, pois `++` vem antes da variável. + + Finalmente, `i = 4` é incrementado a `5`, a comparação `while(5 < 5)` falha, e o loop termina. Assim, `5` não é exibido. + +2. **De 1 a 5** + + ```js run + let i = 0; + while (i++ < 5) alert( i ); + ``` + + O primeiro valor é novamente `i = 1`. A forma posfixada `i++`incrementa `i` e em seguida retorna o valor *antigo*, então a comparação `i++ < 5` utilizará `i = 0` (diferente de `++i < 5`). + + Mas a chamada de `alert` é separada. Ela é uma declaração distinta que executa após o incremento e a comparaçào. Assim, ela recebe o valor atual `i = 1`. + + Em seguida, vêm `2, 3, 4…` + + Vamos parar em `i = 4`. A forma prefixada `++i` iria incrementar e utilizar `5` na comparação. Mas aqui temos a forma posfixada `i++`. Ela incrementa `i` para `5`, mas retorna o valor antigo. Portanto a comparação é, na verdade, `while(4 < 5)` -- verdadeira, e o controle passa para `alert`. + + O valor `i = 5` é o último, porque na próxima etapa `while(5 < 5)` é falso. + \ No newline at end of file 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 new file mode 100644 index 000000000..aefb036d3 --- /dev/null +++ b/1-js/02-first-steps/12-while-for/2-which-value-while/task.md @@ -0,0 +1,22 @@ +importance: 4 + +--- + +# Quais valores o loop while retorna? + +Para cada iteração dos loops, anote o valor que ele retorna, depois compare com a solução. + +Ambos os loops retornam em `alert` os mesmo valores, ou não? + +1. A forma prefixada `++i`: + + ```js + let i = 0; + while (++i < 5) alert( i ); + ``` +2. A forma posfixada `i++`: + + ```js + let i = 0; + while (i++ < 5) alert( i ); + ``` 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 new file mode 100644 index 000000000..55f27ec83 --- /dev/null +++ b/1-js/02-first-steps/12-while-for/3-which-value-for/solution.md @@ -0,0 +1,17 @@ +**Resposta: de `0` a `4` nos dois casos.** + +```js run +for (let i = 0; i < 5; ++i) alert( i ); + +for (let i = 0; i < 5; i++) alert( i ); +``` + +Isso pode ser facilmente deduzido do algoritmo de `for`: + +1. Executar `i = 0` uma vez antes de tudo (begin). +2. Verificar a condição `i < 5`. +3. Caso verdadeira (`true`), executar o corpo do loop `alert(i)`, e em seguida `i++`. + +O incremento `i++` é separado do teste da condição (2). Trata-se de outra declaração. + +O valor retornado pelo incremento não é utilizado aqui, então não há diferença entre `i++` e `++i`. \ No newline at end of file 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 new file mode 100644 index 000000000..abc4a37be --- /dev/null +++ b/1-js/02-first-steps/12-while-for/3-which-value-for/task.md @@ -0,0 +1,20 @@ +importance: 4 + +--- + +# Quais valores são mostrados pelo loop "for"? + +Pada cada loop, anote quais os valores retornados. Depois, compare com a resposta. + +Ambos os loops retornam em `alert` os mesmo valores, ou não? + +1. A forma posfixada: + + ```js + for (let i = 0; i < 5; i++) alert( i ); + ``` +2. A forma prefixada: + + ```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 new file mode 100644 index 000000000..f7e6e30f8 --- /dev/null +++ b/1-js/02-first-steps/12-while-for/4-for-even/solution.md @@ -0,0 +1,11 @@ + + +```js run demo +for (let i = 2; i <= 10; i++) { + if (i % 2 == 0) { + alert( i ); + } +} +``` + +Utilizamos o operador "módulo" `%` aqui para obter o resto e testar se o valor é par. 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 new file mode 100644 index 000000000..5627f1f70 --- /dev/null +++ b/1-js/02-first-steps/12-while-for/4-for-even/task.md @@ -0,0 +1,9 @@ +importance: 5 + +--- + +# Retornar valores pares no loop + +Utilize o loop `for` para retornar números pares de `2` a `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 new file mode 100644 index 000000000..5579686ef --- /dev/null +++ b/1-js/02-first-steps/12-while-for/5-replace-for-while/solution.md @@ -0,0 +1,10 @@ + + +```js run +let i = 0; +while (i < 3) { + 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 new file mode 100644 index 000000000..a38929c63 --- /dev/null +++ b/1-js/02-first-steps/12-while-for/5-replace-for-while/task.md @@ -0,0 +1,14 @@ +importance: 5 + +--- + +# Substituir "for" por "while" + +Reescreva o código, mudando o loop `for` para `while` sem alterar seu comportamento (o resultado deve continuar o mesmo). + +```js run +for (let i = 0; i < 3; 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 new file mode 100644 index 000000000..f7ce57442 --- /dev/null +++ b/1-js/02-first-steps/12-while-for/6-repeat-until-correct/solution.md @@ -0,0 +1,15 @@ + +```js run demo +let num; + +do { + num = prompt("Digite um número maior que 100:", 0); +} while (num <= 100 && num); +``` + +O loop `do..while` repete enquanto ambos os testes sejam verdadeiros: + +1. O teste `num <= 100` -- isto é, o valor digitado ainda não é maior que `100`. +2. O teste `&& num` é falso quando `num` é `null` ou um string vazio. Então, o loop `while` também é interrompido. + +P.S. Se `num` é `null`, então `num <= 100` é verdadeiro. Por isso, sem o segundo teste, o loop não iria encerrar se o usuário clicasse em "CANCELAR". Ambos os testes são necessários. 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 new file mode 100644 index 000000000..b2253a61a --- /dev/null +++ b/1-js/02-first-steps/12-while-for/6-repeat-until-correct/task.md @@ -0,0 +1,13 @@ +importance: 5 + +--- + +# Repetir até que o input esteja correto + +Escreva um loop que peça um número maior que `100`. Se o usuário digitar outro número, peça para digite digitar novamente. + +O loop deve pedir um número até que o usuário digite um número maior que `100` ou cancele o diálogo/submeta uma linha em branco. + +Aqui podemos assumir que o usuário só digita números. Não é preciso implementar um tratamento especial para inputs não-numéricos neste exercício. + +[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 new file mode 100644 index 000000000..a011f54db --- /dev/null +++ b/1-js/02-first-steps/12-while-for/7-list-primes/solution.md @@ -0,0 +1,29 @@ +Há muitos algotimos para esta tarefa. + +Vamos utilizar um loop dentro de outro (isto é, aninhado): + +```js +Para cada i no intervalo { + testar se i tem um divisor de 1 a i + se sim => o valor não é um primo + se não => o valor e um primo, mostre-o +} +``` + +O código usando um label: + +```js run +let n = 10; + +nextPrime: +for (let i = 2; i <= n; i++) { // para cada i... + + for (let j = 2; j < i; j++) { // procurar um divisor.. + if (i % j == 0) continue nextPrime; // não é primo, passar para o próximo i + } + + alert( i ); // é primo +} +``` + +Há muitas maneiras de otimizá-lo. Por exemplo, podemos procurar divisores de `2` até a raiz quadrada de `i`. De qualquer modo, se quisermos ser realmente eficientes para intervalos maiores, precisamos mudar a abordagem e nos embasar em matemática avançada e algoritmos complexos como o [Crivo Quadrático](https://en.wikipedia.org/wiki/Quadratic_sieve), o [Crivo do Corpo de Números Geral](https://en.wikipedia.org/wiki/General_number_field_sieve), etc. \ No newline at end of file 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 new file mode 100644 index 000000000..6e517b8b9 --- /dev/null +++ b/1-js/02-first-steps/12-while-for/7-list-primes/task.md @@ -0,0 +1,18 @@ +importance: 3 + +--- + +# Retornar número primos + +Um número inteiro maior que `1` é chamado de [primo](https://pt.wikipedia.org/wiki/Número_primo) se ele não puder ser divido por nenhum outro número exceto por `1` e por si mesmo sem gerar um resto. + + +Em outras palavras, `n > 1` é um primo se ele não puder ser dividido sem resto por nada além de `1` e `n`. + +Por exemplo, `5` é um primo, pois não pode ser dividido sem resto por `2`, `3` e `4`. + +**Escreva o código que retorne números primos no intervalo de `2` a `n`.** + +Para `n = 10`, o resultado será `2,3,5,7`. + +P.S. O código deve funcionar para qualquer `n`, e não pré-estabelecido para um valor fixo. diff --git a/1-js/02-first-steps/12-while-for/article.md b/1-js/02-first-steps/12-while-for/article.md new file mode 100644 index 000000000..584612b33 --- /dev/null +++ b/1-js/02-first-steps/12-while-for/article.md @@ -0,0 +1,383 @@ +# Loops: while e for + +Frequentemente precisamos repetir ações. + +Por exemplo, retornar itens de uma lista, um atrás do outro, ou apenas executar o mesmo código para cada número de 1 a 10. + +*Loops* são uma maneira de repetir o mesmo código múltiplas vezes. + +## O loop "while" + +O `while` loop tem a sintaxe seguinte: + +```js +while (condição) { + // código + // chamado de "loop body" (corpo do loop) +} +``` + +Enquanto `condição` for verdadeira, o `código` do corpo do loop é executado. + +Por exemplo, o loop abaixo retorna `i` enquanto `i < 3`: + +```js run +let i = 0; +while (i < 3) { // retorna 0, depois 1, depois 2 + alert( i ); + i++; +} +``` + +Uma única execução do corpo do loop é chamada de *uma iteração*. O loop no exemplo acima realiza três iterações. + +Se `i++` não estivesse presente no exemplo acima, o loop repetiria (teoricamente) para sempre. Na prática, o navegador nos oferece maneira de interromper tais loops, e em JavaScript server-side, é possível matar o processo. + +Qualquer expressão ou variável pode ser uma condição para um loop, não apenas comparações: a condição é avaliada e convertida por `while` para um booleano. + +Por exemplo, uma maneira mais curta de escrever `while (i != 0)` é `while (i)`: + +```js run +let i = 3; +*!* +while (i) { // quando i se tornar 0, a condição se torna falsa, e o loop para +*/!* + alert( i ); + i--; +} +``` + +````smart header="Colchetes não são necessários se o corpo possuir só uma linha" +Se o corpo do loop possuir uma única declaração, podemos omitir os colchetes `{...}`: + +```js run +let i = 3; +*!* +while (i) alert(i--); +*/!* +``` +```` + +## O loop "do..while" + +A verificação da condição pode ser movida *abaixo* do corpo do loop utilizando a sintaxe `do..while`: + +```js +do { + // corpo do loop +} while (condição); +``` + +O loop vai executar primeiro o corpo, depois checar a condição e, enquanto ela permanecer verdadeira, executar o corpo novamente. + +Por exemplo: + +```js run +let i = 0; +do { + alert( i ); + i++; +} while (i < 3); +``` + +Esta forma de sintaxe deve ser usada apenas quando você deseja que o corpo do loop seja executado **pelo menos uma vez**, independente de a condição ser verdadeira. Geralmente, prefere-se a outra forma: `while(...) {...}`. + +## O loop "for" + +O loop `for` é o mais comumente utilizado. + +Ele tem esse formato: + +```js +for (início; condição; etapa) { + // ... corpo do loop ... +} +``` + +Vamos aprender o que significam cada uma dessas partes através de exemplos. O loop abaixo executa `alert(i)` para `i` de `0` a (não incluso) `3`: + +```js run +for (let i = 0; i < 3; i++) { // retorna 0, depois 1, depois 2 + alert(i); +} +``` + +Vamos examinar a declaração `for` parte por parte: + +| part | | | +|----------|------------|--------------------------------------------------------------------------------| +| início | `i = 0` | Executado uma vez na entrada do loop. | +| condição | `i < 3` | Verificada a cada iteração do loop. Se falsa, o loop é interrompido. | +| etapa | `i++` | Executado depois do corpo, a cada iteração, mas antes de verificar a condição. | +| corpo | `alert(i)` | Executado repetidamente enquanto a condição for verdadeira. | + + +O algoritmo geral do loop funciona assim: +``` +Executar início +→ (se condição verdadeira → executar corpo e executar etapa) +→ (se condição verdadeira → executar corpo e executar etapa) +→ (se condição verdadeira → executar corpo e executar etapa) +→ ... +``` + +Caso loops sejam novos para você, pode ser útil voltar ao exemplo e reproduzir sua execução passo-a-passo em uma folha de papel. + +No nosso exemplo, o que acontece exatamente é isso: + +```js +// for (let i = 0; i < 3; i++) alert(i) + +// executar condição +let i = 0 +// se condição verdadeira → executar corpo e executar etapa +if (i < 3) { alert(i); i++ } +// se condição verdadeira → executar corpo e executar etapa +if (i < 3) { alert(i); i++ } +// se condição verdadeira → executar corpo e executar etapa +if (i < 3) { alert(i); i++ } +// ...encerrar, pois agora i == 3 +``` + +````smart header="Declaração de variável inline" +Aqui, a variável "de contagem" `i` é declarada diretamente no loop. Isso é chamado de declaração de variável "inline". Tais variáveis são visíveis somente no interior do loop. + +```js run +for (*!*let*/!* i = 0; i < 3; i++) { + alert(i); // 0, 1, 2 +} +alert(i); // erro, variável não existente +``` + +Ao invés de definir a variável, podemos utilizar uma já existente: + +```js run +let i = 0; + +for (i = 0; i < 3; i++) { // usando uma variável pré-existente + alert(i); // 0, 1, 2 +} + +alert(i); // 3, visível, porque declarada fora do loop +``` + +```` + + +### Omitindo partes + +Qualquer parte de `for` pode ser omitida. + +Por exemplo, podemos omitir `início` caso não seja necessário fazer nada no início do loop. + +Como neste exemplo: + +```js run +let i = 0; // já temos i declarada e atribuída + +for (; i < 3; i++) { // "início" não é necessário + alert( i ); // 0, 1, 2 +} +``` + +Também podemos remover a parte da `etapa`: + +```js run +let i = 0; + +for (; i < 3;) { + alert( i++ ); +} +``` + +Isso torna o loop idêntico a `while (i < 3)`. + +Na verdade, podemos remover tudo, criando um loop infinito: + +```js +for (;;) { + // repete sem limites +} +``` + +Note que os dois pontos-e-vírgulas `;` dentro do `for` devem estar presentes. Caso contrário, haverá um erro de sintaxe. + +## Quebrando o loop + +Normalmente, um loop se encerra quando sua condição se torna falsa. + +Mas podemos forçar a saída a qualquer momento utilizando o comando especial `break`. + +Por exemplo, o loop abaixo pede ao usuário uma série de números, e "quebra" quando nenhum número é informado: + +```js +let sum = 0; + +while (true) { + + let value = +prompt("Digite um número", ''); + +*!* + if (!value) break; // (*) +*/!* + + sum += value; + +} +alert( 'Soma: ' + sum ); +``` + +O comando `break` é ativado na linha `(*)` se o usuário deixa a linha em branco ou cancela o diálogo. Ele interrompe o loop imediatamente, passando o controle à primeira linha depois do loop. Neste caso, `alert`. + +A combinação "loop infinito " `break` quando necessário" é ótima para situações onde a condição do loop precisa ser verificada não no início ou no fim do loop, mas no meio, ou até mesmo em vários lugares do corpo do loop. + +## Continue para a próxima iteração [#continue] + +O comando `continue` é uma "versão mais light" de `break`. Ele não interrompe o loop como um todo. Ao invés disso, ele interrompe a iteração atual e força o loop a começar uma nova (se a condição permitir). + +Você pode utilizá-lo caso a iteração atual já não seja útil e você deseje passar para a próxima. + +O loop abaixo usa `continue` para exibir apenas valores ímpares: + +```js run no-beautify +for (let i = 0; i < 10; i++) { + + // se verdadeiro, pular o restante do corpo + *!*if (i % 2 == 0) continue;*/!* + + alert(i); // 1, then 3, 5, 7, 9 +} +``` + +Para valores pares de `i`, o comando `continue` interrompe a execução do corpo e passa o controle para a próxima iteração de `for` (com o número seguinte). Então `alert` só é chamado para valores ímpares. + +````smart header="O comando `continue` ajuda a reduzir aninhamento" +Um loop que retorna apenas valores ímpares poderia ter a seguinte forma: + +```js +for (let i = 0; i < 10; i++) { + + if (i % 2) { + alert( i ); + } + +} +``` + +De uma perspectiva técnica, isso é idêntico ao exemplo anterior. Certamente, podemos apenas envolver o código em um bloco `if` ao invés de utilizar `continue`. + +Mas como efeito colateral, isso criou mais um nível de aninhamento (o `alert` dentro dos colchetes). Se o código dentro de `if` for mais longo do que algumas linhas, isso pode reduzir a legibilidade de forma geral. +```` + +````warn header="Não utilize `break/continue` do lado direito de '?'" +Note que construções sintáticas que não sejam expressões não podem ser utilizados com o operador ternário `?`. Em particular, comandos como `break/continue` não são permitidos nesta posição. + +Por exemplo, se tomarmos este código: + +```js +if (i > 5) { + alert(i); +} else { + continue; +} +``` + +...e reescrevermos utilizando o ponto de interrogação: + +```js no-beautify +(i > 5) ? alert(i) : *!*continue*/!*; // continue não é permitido aqui +``` + +...ele para de funcionar. Códigos como este vão gerar um erro de sintaxe. + +Esta é apenas mais uma razão para não utilizar o operador ternário `?` no lugar de `if`. +```` + +## Labels for break/continue + +Às vezes, precisamos quebrar vários loops aninhados de uma vez só. + +Por exemplo, no código abaixo nós utilizamos dois loops, com `i` e `j`, dando as coordenadas `(i, j)` de `(0,0)` a `(3,3)`: + +```js run no-beautify +for (let i = 0; i < 3; i++) { + + for (let j = 0; j < 3; j++) { + + let input = prompt(`Valor nas coordenadas (${i},${j})`, ''); + + // e se quisermos sair daqui diretamente para "Pronto" (abaixo)? + } +} + +alert('Pronto!'); +``` + +Precisamos de uma maneira de interromper o processo caso o usuário cancele o input. + +O `break` comum depois de `input` quebraria apenas o loop interno. Isso não é suficiente--labels, ao resgate! + +Um *label* é um identificador com dois pontos antes de um loop: +```js +labelName: for (...) { + ... +} +``` + +A declaração `break ` no loop abaixo quebra o loop designado pelo label: + +```js run no-beautify +*!*outer:*/!* for (let i = 0; i < 3; i++) { + + for (let j = 0; j < 3; j++) { + + let input = prompt(`Valor nas coordenadas (${i},${j})`, ''); + + // se retornar um string vazio ou cancelar, quebrar ambos os loops + if (!input) *!*break outer*/!*; // (*) + + // fazer algo com input... + } +} +alert('Pronto!'); +``` + +No código acima, `break outer` procura acima dele o label chamado `outer` e quebra aquele loop. + +Assim o controle vai direto de `(*)` para `alert('Pronto!')`. + +Também podemos colocar o label em uma linha separada: + +```js no-beautify +outer: +for (let i = 0; i < 3; i++) { ... } +``` + +O comando `continue` também pode ser utilizado com um label. Nesse caso, a execução do código pula para a próxima iteração do loop nomeado pelo label. + +````warn header="Labels não significam \"ir para\"" +Labels não nos permitem pular para qualquer lugar do código. + +Por exemplo, é impossível fazer isso: +```js +break label; // pula para label? Não. + +label: for (...) +``` + +Uma chamada de `break/continue` só é possível de dentro de um loop e o label deve estar em algum lugar acima do comando. +```` + +## Resumo + +Nós cobrimos 3 tipos de loops: + +- `while` -- A condição é verificada antes de cada iteração. +- `do..while` -- A condição é verificada após cada iteração. +- `for (;;)` -- A condição é verificada antes de cada iteração, configurações adicionais disponíveis. + +Para fazer um loop "infinito", geralmente se utiliza a construção `white(true)`. Este loop, como qualquer outro, pode ser interrompido com o comando `break`. + +Se não quisermos fazer nada na iteração atual e gostaríamos de pular para a próxima iteração, podemos utilizar o comando `continue`. + +`break/continue` suportam labels antes do loop. Um label é a única maneira de fazer um `break/continue` escapar um loop aninhado e ir para o loop de fora. \ No newline at end of file From 1c87f6aa28c3d823a4e889751db13ae415f933bb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=81lvaro=20Antonio?= Date: Mon, 21 Oct 2019 17:44:00 -0300 Subject: [PATCH 08/13] copying original files for reviewers to compare --- .../1-loop-last-value/solution.md | 14 +- .../12-while-for/1-loop-last-value/task.md | 4 +- .../2-which-value-while/solution.md | 24 +- .../12-while-for/2-which-value-while/task.md | 10 +- .../3-which-value-for/solution.md | 14 +- .../12-while-for/3-which-value-for/task.md | 10 +- .../12-while-for/4-for-even/solution.md | 2 +- .../12-while-for/4-for-even/task.md | 4 +- .../5-replace-for-while/solution.md | 2 +- .../12-while-for/5-replace-for-while/task.md | 6 +- .../6-repeat-until-correct/solution.md | 10 +- .../6-repeat-until-correct/task.md | 8 +- .../12-while-for/7-list-primes/solution.md | 24 +- .../12-while-for/7-list-primes/task.md | 15 +- 1-js/02-first-steps/12-while-for/article.md | 250 +++++++++--------- 15 files changed, 198 insertions(+), 199 deletions(-) mode change 100644 => 100755 1-js/02-first-steps/12-while-for/1-loop-last-value/solution.md mode change 100644 => 100755 1-js/02-first-steps/12-while-for/1-loop-last-value/task.md mode change 100644 => 100755 1-js/02-first-steps/12-while-for/2-which-value-while/solution.md mode change 100644 => 100755 1-js/02-first-steps/12-while-for/2-which-value-while/task.md mode change 100644 => 100755 1-js/02-first-steps/12-while-for/3-which-value-for/solution.md mode change 100644 => 100755 1-js/02-first-steps/12-while-for/3-which-value-for/task.md mode change 100644 => 100755 1-js/02-first-steps/12-while-for/4-for-even/solution.md mode change 100644 => 100755 1-js/02-first-steps/12-while-for/4-for-even/task.md mode change 100644 => 100755 1-js/02-first-steps/12-while-for/5-replace-for-while/solution.md mode change 100644 => 100755 1-js/02-first-steps/12-while-for/5-replace-for-while/task.md mode change 100644 => 100755 1-js/02-first-steps/12-while-for/6-repeat-until-correct/solution.md mode change 100644 => 100755 1-js/02-first-steps/12-while-for/6-repeat-until-correct/task.md mode change 100644 => 100755 1-js/02-first-steps/12-while-for/7-list-primes/solution.md mode change 100644 => 100755 1-js/02-first-steps/12-while-for/7-list-primes/task.md mode change 100644 => 100755 1-js/02-first-steps/12-while-for/article.md 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 old mode 100644 new mode 100755 index beece44a2..43ee4aad3 --- 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 @@ -1,4 +1,4 @@ -Resposta: `1`. +The answer: `1`. ```js run let i = 3; @@ -8,18 +8,18 @@ while (i) { } ``` -Cada iteração do loop decresce `i` em `1`. O teste `while(i)` interrompe o loop quando `i = 0`. +Every loop iteration decreases `i` by `1`. The check `while(i)` stops the loop when `i = 0`. -Portanto, as etapas do loop formam a seguinte sequência ("loop desenrolado"): +Hence, the steps of the loop form the following sequence ("loop unrolled"): ```js let i = 3; -alert(i--); // exibe 3, decresce i para 2 +alert(i--); // shows 3, decreases i to 2 -alert(i--) // exibe 2, decresce i para 1 +alert(i--) // shows 2, decreases i to 1 -alert(i--) // exibe 1, decresce i para 0 +alert(i--) // shows 1, decreases i to 0 -// pronto, o teste while(i) interrompe o loop +// done, while(i) check stops the loop ``` 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 old mode 100644 new mode 100755 index dd931937d..3b847dfa2 --- 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 @@ -2,9 +2,9 @@ importance: 3 --- -# Último valor do loop +# Last loop value -Qual é o último valor exibido no alerta por este código? Por quê? +What is the last value alerted by this code? Why? ```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 old mode 100644 new mode 100755 index 3a8cc5d6e..495359876 --- 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 @@ -1,32 +1,30 @@ -Este exercício demonstra como formas posfixadas/prefixadas podem levar a resultados distintos quando utilizadas em comparações. +The task demonstrates how postfix/prefix forms can lead to different results when used in comparisons. -1. **De 1 a 4** +1. **From 1 to 4** ```js run let i = 0; while (++i < 5) alert( i ); ``` - O primeiro valor é `i = 1`, pois `++i` primeiro incrementa `i` e em seguida retorna o novo valor. Então, a primeira comparação é `1 < 5` e o `alert` exibe `1`. + 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`. - Em seguida vêm `2, 3, 4…` -- os valores aparecem um depois do outro. A comparação sempre usa o valor incrementado, pois `++` vem antes da variável. + Then follow `2, 3, 4…` -- the values show up one after another. The comparison always uses the incremented value, because `++` is before the variable. - Finalmente, `i = 4` é incrementado a `5`, a comparação `while(5 < 5)` falha, e o loop termina. Assim, `5` não é exibido. - -2. **De 1 a 5** + 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** ```js run let i = 0; while (i++ < 5) alert( i ); ``` - O primeiro valor é novamente `i = 1`. A forma posfixada `i++`incrementa `i` e em seguida retorna o valor *antigo*, então a comparação `i++ < 5` utilizará `i = 0` (diferente de `++i < 5`). + 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`). - Mas a chamada de `alert` é separada. Ela é uma declaração distinta que executa após o incremento e a comparaçào. Assim, ela recebe o valor atual `i = 1`. + 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`. - Em seguida, vêm `2, 3, 4…` + Then follow `2, 3, 4…` - Vamos parar em `i = 4`. A forma prefixada `++i` iria incrementar e utilizar `5` na comparação. Mas aqui temos a forma posfixada `i++`. Ela incrementa `i` para `5`, mas retorna o valor antigo. Portanto a comparação é, na verdade, `while(4 < 5)` -- verdadeira, e o controle passa para `alert`. + 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`. - O valor `i = 5` é o último, porque na próxima etapa `while(5 < 5)` é falso. - \ No newline at end of file + The value `i = 5` is the last one, because on the next step `while(5 < 5)` is false. 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 old mode 100644 new mode 100755 index aefb036d3..298213237 --- 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 @@ -2,19 +2,19 @@ importance: 4 --- -# Quais valores o loop while retorna? +# Which values does the while loop show? -Para cada iteração dos loops, anote o valor que ele retorna, depois compare com a solução. +For every loop iteration, write down which value it outputs and then compare it with the solution. -Ambos os loops retornam em `alert` os mesmo valores, ou não? +Both loops `alert` the same values, or not? -1. A forma prefixada `++i`: +1. The prefix form `++i`: ```js let i = 0; while (++i < 5) alert( i ); ``` -2. A forma posfixada `i++`: +2. The postfix form `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 old mode 100644 new mode 100755 index 55f27ec83..e2e28e75b --- 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 @@ -1,4 +1,4 @@ -**Resposta: de `0` a `4` nos dois casos.** +**The answer: from `0` to `4` in both cases.** ```js run for (let i = 0; i < 5; ++i) alert( i ); @@ -6,12 +6,12 @@ for (let i = 0; i < 5; ++i) alert( i ); for (let i = 0; i < 5; i++) alert( i ); ``` -Isso pode ser facilmente deduzido do algoritmo de `for`: +That can be easily deducted from the algorithm of `for`: -1. Executar `i = 0` uma vez antes de tudo (begin). -2. Verificar a condição `i < 5`. -3. Caso verdadeira (`true`), executar o corpo do loop `alert(i)`, e em seguida `i++`. +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++` -O incremento `i++` é separado do teste da condição (2). Trata-se de outra declaração. +The increment `i++` is separated from the condition check (2). That's just another statement. -O valor retornado pelo incremento não é utilizado aqui, então não há diferença entre `i++` e `++i`. \ No newline at end of file +The value returned by the increment is not used here, so there's no difference between `i++` and `++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 old mode 100644 new mode 100755 index abc4a37be..bfefa63f5 --- 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 @@ -2,18 +2,18 @@ importance: 4 --- -# Quais valores são mostrados pelo loop "for"? +# Which values get shown by the "for" loop? -Pada cada loop, anote quais os valores retornados. Depois, compare com a resposta. +For each loop write down which values it is going to show. Then compare with the answer. -Ambos os loops retornam em `alert` os mesmo valores, ou não? +Both loops `alert` same values or not? -1. A forma posfixada: +1. The postfix form: ```js for (let i = 0; i < 5; i++) alert( i ); ``` -2. A forma prefixada: +2. The prefix form: ```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 old mode 100644 new mode 100755 index f7e6e30f8..e8e66bb47 --- 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 @@ -8,4 +8,4 @@ for (let i = 2; i <= 10; i++) { } ``` -Utilizamos o operador "módulo" `%` aqui para obter o resto e testar se o valor é par. +We use the "modulo" operator `%` to get the remainder and check for the evenness here. 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 old mode 100644 new mode 100755 index 5627f1f70..ff34e7e40 --- 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 @@ -2,8 +2,8 @@ importance: 5 --- -# Retornar valores pares no loop +# Output even numbers in the loop -Utilize o loop `for` para retornar números pares de `2` a `10`. +Use the `for` loop to output even numbers from `2` to `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 old mode 100644 new mode 100755 index 5579686ef..612cf559c --- 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 @@ -3,7 +3,7 @@ ```js run let i = 0; while (i < 3) { - alert( `número ${i}!` ); + alert( `number ${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 old mode 100644 new mode 100755 index a38929c63..0c69d9c2d --- 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 @@ -2,13 +2,13 @@ importance: 5 --- -# Substituir "for" por "while" +# Replace "for" with "while" -Reescreva o código, mudando o loop `for` para `while` sem alterar seu comportamento (o resultado deve continuar o mesmo). +Rewrite the code changing the `for` loop to `while` without altering its behavior (the output should stay same). ```js run for (let i = 0; i < 3; i++) { - alert( `número ${i}!` ); + alert( `number ${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 old mode 100644 new mode 100755 index f7ce57442..2e04a78c4 --- 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 @@ -3,13 +3,13 @@ let num; do { - num = prompt("Digite um número maior que 100:", 0); + num = prompt("Enter a number greater than 100?", 0); } while (num <= 100 && num); ``` -O loop `do..while` repete enquanto ambos os testes sejam verdadeiros: +The loop `do..while` repeats while both checks are truthy: -1. O teste `num <= 100` -- isto é, o valor digitado ainda não é maior que `100`. -2. O teste `&& num` é falso quando `num` é `null` ou um string vazio. Então, o loop `while` também é interrompido. +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. -P.S. Se `num` é `null`, então `num <= 100` é verdadeiro. Por isso, sem o segundo teste, o loop não iria encerrar se o usuário clicasse em "CANCELAR". Ambos os testes são necessários. +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. 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 old mode 100644 new mode 100755 index b2253a61a..0788ee76e --- 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 @@ -2,12 +2,12 @@ importance: 5 --- -# Repetir até que o input esteja correto +# Repeat until the input is correct -Escreva um loop que peça um número maior que `100`. Se o usuário digitar outro número, peça para digite digitar novamente. +Write a loop which prompts for a number greater than `100`. If the visitor enters another number -- ask them to input again. -O loop deve pedir um número até que o usuário digite um número maior que `100` ou cancele o diálogo/submeta uma linha em branco. +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. -Aqui podemos assumir que o usuário só digita números. Não é preciso implementar um tratamento especial para inputs não-numéricos neste exercício. +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. [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 old mode 100644 new mode 100755 index a011f54db..9ff0663d7 --- 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 @@ -1,29 +1,29 @@ -Há muitos algotimos para esta tarefa. +There are many algorithms for this task. -Vamos utilizar um loop dentro de outro (isto é, aninhado): +Let's use a nested loop: ```js -Para cada i no intervalo { - testar se i tem um divisor de 1 a i - se sim => o valor não é um primo - se não => o valor e um primo, mostre-o +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 } ``` -O código usando um label: +The code using a label: ```js run let n = 10; nextPrime: -for (let i = 2; i <= n; i++) { // para cada i... +for (let i = 2; i <= n; i++) { // for each i... - for (let j = 2; j < i; j++) { // procurar um divisor.. - if (i % j == 0) continue nextPrime; // não é primo, passar para o próximo i + for (let j = 2; j < i; j++) { // look for a divisor.. + if (i % j == 0) continue nextPrime; // not a prime, go next i } - alert( i ); // é primo + alert( i ); // a prime } ``` -Há muitas maneiras de otimizá-lo. Por exemplo, podemos procurar divisores de `2` até a raiz quadrada de `i`. De qualquer modo, se quisermos ser realmente eficientes para intervalos maiores, precisamos mudar a abordagem e nos embasar em matemática avançada e algoritmos complexos como o [Crivo Quadrático](https://en.wikipedia.org/wiki/Quadratic_sieve), o [Crivo do Corpo de Números Geral](https://en.wikipedia.org/wiki/General_number_field_sieve), etc. \ No newline at end of file +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. 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 old mode 100644 new mode 100755 index 6e517b8b9..6344b9f6f --- 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 @@ -2,17 +2,16 @@ importance: 3 --- -# Retornar número primos +# Output prime numbers -Um número inteiro maior que `1` é chamado de [primo](https://pt.wikipedia.org/wiki/Número_primo) se ele não puder ser divido por nenhum outro número exceto por `1` e por si mesmo sem gerar um resto. +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. +In other words, `n > 1` is a prime if it can't be evenly divided by anything except `1` and `n`. -Em outras palavras, `n > 1` é um primo se ele não puder ser dividido sem resto por nada além de `1` e `n`. +For example, `5` is a prime, because it cannot be divided without a remainder by `2`, `3` and `4`. -Por exemplo, `5` é um primo, pois não pode ser dividido sem resto por `2`, `3` e `4`. +**Write the code which outputs prime numbers in the interval from `2` to `n`.** -**Escreva o código que retorne números primos no intervalo de `2` a `n`.** +For `n = 10` the result will be `2,3,5,7`. -Para `n = 10`, o resultado será `2,3,5,7`. - -P.S. O código deve funcionar para qualquer `n`, e não pré-estabelecido para um valor fixo. +P.S. The code should work for any `n`, not be hard-tuned for any fixed value. diff --git a/1-js/02-first-steps/12-while-for/article.md b/1-js/02-first-steps/12-while-for/article.md old mode 100644 new mode 100755 index 584612b33..6be50597d --- a/1-js/02-first-steps/12-while-for/article.md +++ b/1-js/02-first-steps/12-while-for/article.md @@ -1,54 +1,54 @@ -# Loops: while e for +# Loops: while and for -Frequentemente precisamos repetir ações. +We often need to repeat actions. -Por exemplo, retornar itens de uma lista, um atrás do outro, ou apenas executar o mesmo código para cada número de 1 a 10. +For example, outputting goods from a list one after another or just running the same code for each number from 1 to 10. -*Loops* são uma maneira de repetir o mesmo código múltiplas vezes. +*Loops* are a way to repeat the same code multiple times. -## O loop "while" +## The "while" loop -O `while` loop tem a sintaxe seguinte: +The `while` loop has the following syntax: ```js -while (condição) { - // código - // chamado de "loop body" (corpo do loop) +while (condition) { + // code + // so-called "loop body" } ``` -Enquanto `condição` for verdadeira, o `código` do corpo do loop é executado. +While the `condition` is `true`, the `code` from the loop body is executed. -Por exemplo, o loop abaixo retorna `i` enquanto `i < 3`: +For instance, the loop below outputs `i` while `i < 3`: ```js run let i = 0; -while (i < 3) { // retorna 0, depois 1, depois 2 +while (i < 3) { // shows 0, then 1, then 2 alert( i ); i++; } ``` -Uma única execução do corpo do loop é chamada de *uma iteração*. O loop no exemplo acima realiza três iterações. +A single execution of the loop body is called *an iteration*. The loop in the example above makes three iterations. -Se `i++` não estivesse presente no exemplo acima, o loop repetiria (teoricamente) para sempre. Na prática, o navegador nos oferece maneira de interromper tais loops, e em JavaScript server-side, é possível matar o processo. +If `i++` was missing from the example above, the loop would repeat (in theory) forever. In practice, the browser provides ways to stop such loops, and in server-side JavaScript, we can kill the process. -Qualquer expressão ou variável pode ser uma condição para um loop, não apenas comparações: a condição é avaliada e convertida por `while` para um booleano. +Any expression or variable can be a loop condition, not just comparisons: the condition is evaluated and converted to a boolean by `while`. -Por exemplo, uma maneira mais curta de escrever `while (i != 0)` é `while (i)`: +For instance, a shorter way to write `while (i != 0)` is `while (i)`: ```js run let i = 3; *!* -while (i) { // quando i se tornar 0, a condição se torna falsa, e o loop para +while (i) { // when i becomes 0, the condition becomes falsy, and the loop stops */!* alert( i ); i--; } ``` -````smart header="Colchetes não são necessários se o corpo possuir só uma linha" -Se o corpo do loop possuir uma única declaração, podemos omitir os colchetes `{...}`: +````smart header="Brackets are not required for a single-line body" +If the loop body has a single statement, we can omit the brackets `{…}`: ```js run let i = 3; @@ -58,19 +58,19 @@ while (i) alert(i--); ``` ```` -## O loop "do..while" +## The "do..while" loop -A verificação da condição pode ser movida *abaixo* do corpo do loop utilizando a sintaxe `do..while`: +The condition check can be moved *below* the loop body using the `do..while` syntax: ```js do { - // corpo do loop -} while (condição); + // loop body +} while (condition); ``` -O loop vai executar primeiro o corpo, depois checar a condição e, enquanto ela permanecer verdadeira, executar o corpo novamente. +The loop will first execute the body, then check the condition, and, while it's truthy, execute it again and again. -Por exemplo: +For example: ```js run let i = 0; @@ -80,107 +80,107 @@ do { } while (i < 3); ``` -Esta forma de sintaxe deve ser usada apenas quando você deseja que o corpo do loop seja executado **pelo menos uma vez**, independente de a condição ser verdadeira. Geralmente, prefere-se a outra forma: `while(...) {...}`. +This form of syntax should only be used when you want the body of the loop to execute **at least once** regardless of the condition being truthy. Usually, the other form is preferred: `while(…) {…}`. -## O loop "for" +## The "for" loop -O loop `for` é o mais comumente utilizado. +The `for` loop is the most commonly used loop. -Ele tem esse formato: +It looks like this: ```js -for (início; condição; etapa) { - // ... corpo do loop ... +for (begin; condition; step) { + // ... loop body ... } ``` -Vamos aprender o que significam cada uma dessas partes através de exemplos. O loop abaixo executa `alert(i)` para `i` de `0` a (não incluso) `3`: +Let's learn the meaning of these parts by example. The loop below runs `alert(i)` for `i` from `0` up to (but not including) `3`: ```js run -for (let i = 0; i < 3; i++) { // retorna 0, depois 1, depois 2 +for (let i = 0; i < 3; i++) { // shows 0, then 1, then 2 alert(i); } ``` -Vamos examinar a declaração `for` parte por parte: +Let's examine the `for` statement part-by-part: -| part | | | -|----------|------------|--------------------------------------------------------------------------------| -| início | `i = 0` | Executado uma vez na entrada do loop. | -| condição | `i < 3` | Verificada a cada iteração do loop. Se falsa, o loop é interrompido. | -| etapa | `i++` | Executado depois do corpo, a cada iteração, mas antes de verificar a condição. | -| corpo | `alert(i)` | Executado repetidamente enquanto a condição for verdadeira. | +| part | | | +|-------|----------|----------------------------------------------------------------------------| +| begin | `i = 0` | Executes once upon entering the loop. | +| condition | `i < 3`| Checked before every loop iteration. If false, the loop stops. | +| step| `i++` | Executes after the body on each iteration but before the condition check. | +| body | `alert(i)`| Runs again and again while the condition is truthy. | -O algoritmo geral do loop funciona assim: +The general loop algorithm works like this: ``` -Executar início -→ (se condição verdadeira → executar corpo e executar etapa) -→ (se condição verdadeira → executar corpo e executar etapa) -→ (se condição verdadeira → executar corpo e executar etapa) +Run begin +→ (if condition → run body and run step) +→ (if condition → run body and run step) +→ (if condition → run body and run step) → ... ``` -Caso loops sejam novos para você, pode ser útil voltar ao exemplo e reproduzir sua execução passo-a-passo em uma folha de papel. +If you are new to loops, it could help to go back to the example and reproduce how it runs step-by-step on a piece of paper. -No nosso exemplo, o que acontece exatamente é isso: +Here's exactly what happens in our case: ```js // for (let i = 0; i < 3; i++) alert(i) -// executar condição +// run begin let i = 0 -// se condição verdadeira → executar corpo e executar etapa +// if condition → run body and run step if (i < 3) { alert(i); i++ } -// se condição verdadeira → executar corpo e executar etapa +// if condition → run body and run step if (i < 3) { alert(i); i++ } -// se condição verdadeira → executar corpo e executar etapa +// if condition → run body and run step if (i < 3) { alert(i); i++ } -// ...encerrar, pois agora i == 3 +// ...finish, because now i == 3 ``` -````smart header="Declaração de variável inline" -Aqui, a variável "de contagem" `i` é declarada diretamente no loop. Isso é chamado de declaração de variável "inline". Tais variáveis são visíveis somente no interior do loop. +````smart header="Inline variable declaration" +Here, the "counter" variable `i` is declared right in the loop. This is called an "inline" variable declaration. Such variables are visible only inside the loop. ```js run for (*!*let*/!* i = 0; i < 3; i++) { alert(i); // 0, 1, 2 } -alert(i); // erro, variável não existente +alert(i); // error, no such variable ``` -Ao invés de definir a variável, podemos utilizar uma já existente: +Instead of defining a variable, we could use an existing one: ```js run let i = 0; -for (i = 0; i < 3; i++) { // usando uma variável pré-existente +for (i = 0; i < 3; i++) { // use an existing variable alert(i); // 0, 1, 2 } -alert(i); // 3, visível, porque declarada fora do loop +alert(i); // 3, visible, because declared outside of the loop ``` ```` -### Omitindo partes +### Skipping parts -Qualquer parte de `for` pode ser omitida. +Any part of `for` can be skipped. -Por exemplo, podemos omitir `início` caso não seja necessário fazer nada no início do loop. +For example, we can omit `begin` if we don't need to do anything at the loop start. -Como neste exemplo: +Like here: ```js run -let i = 0; // já temos i declarada e atribuída +let i = 0; // we have i already declared and assigned -for (; i < 3; i++) { // "início" não é necessário +for (; i < 3; i++) { // no need for "begin" alert( i ); // 0, 1, 2 } ``` -Também podemos remover a parte da `etapa`: +We can also remove the `step` part: ```js run let i = 0; @@ -190,32 +190,32 @@ for (; i < 3;) { } ``` -Isso torna o loop idêntico a `while (i < 3)`. +This makes the loop identical to `while (i < 3)`. -Na verdade, podemos remover tudo, criando um loop infinito: +We can actually remove everything, creating an infinite loop: ```js for (;;) { - // repete sem limites + // repeats without limits } ``` -Note que os dois pontos-e-vírgulas `;` dentro do `for` devem estar presentes. Caso contrário, haverá um erro de sintaxe. +Please note that the two `for` semicolons `;` must be present. Otherwise, there would be a syntax error. -## Quebrando o loop +## Breaking the loop -Normalmente, um loop se encerra quando sua condição se torna falsa. +Normally, a loop exits when its condition becomes falsy. -Mas podemos forçar a saída a qualquer momento utilizando o comando especial `break`. +But we can force the exit at any time using the special `break` directive. -Por exemplo, o loop abaixo pede ao usuário uma série de números, e "quebra" quando nenhum número é informado: +For example, the loop below asks the user for a series of numbers, "breaking" when no number is entered: ```js let sum = 0; while (true) { - let value = +prompt("Digite um número", ''); + let value = +prompt("Enter a number", ''); *!* if (!value) break; // (*) @@ -224,35 +224,35 @@ while (true) { sum += value; } -alert( 'Soma: ' + sum ); +alert( 'Sum: ' + sum ); ``` -O comando `break` é ativado na linha `(*)` se o usuário deixa a linha em branco ou cancela o diálogo. Ele interrompe o loop imediatamente, passando o controle à primeira linha depois do loop. Neste caso, `alert`. +The `break` directive is activated at the line `(*)` if the user enters an empty line or cancels the input. It stops the loop immediately, passing control to the first line after the loop. Namely, `alert`. -A combinação "loop infinito " `break` quando necessário" é ótima para situações onde a condição do loop precisa ser verificada não no início ou no fim do loop, mas no meio, ou até mesmo em vários lugares do corpo do loop. +The combination "infinite loop + `break` as needed" is great for situations when a loop's condition must be checked not in the beginning or end of the loop, but in the middle or even in several places of its body. -## Continue para a próxima iteração [#continue] +## Continue to the next iteration [#continue] -O comando `continue` é uma "versão mais light" de `break`. Ele não interrompe o loop como um todo. Ao invés disso, ele interrompe a iteração atual e força o loop a começar uma nova (se a condição permitir). +The `continue` directive is a "lighter version" of `break`. It doesn't stop the whole loop. Instead, it stops the current iteration and forces the loop to start a new one (if the condition allows). -Você pode utilizá-lo caso a iteração atual já não seja útil e você deseje passar para a próxima. +We can use it if we're done with the current iteration and would like to move on to the next one. -O loop abaixo usa `continue` para exibir apenas valores ímpares: +The loop below uses `continue` to output only odd values: ```js run no-beautify for (let i = 0; i < 10; i++) { - // se verdadeiro, pular o restante do corpo + // if true, skip the remaining part of the body *!*if (i % 2 == 0) continue;*/!* alert(i); // 1, then 3, 5, 7, 9 } ``` -Para valores pares de `i`, o comando `continue` interrompe a execução do corpo e passa o controle para a próxima iteração de `for` (com o número seguinte). Então `alert` só é chamado para valores ímpares. +For even values of `i`, the `continue` directive stops executing the body and passes control to the next iteration of `for` (with the next number). So the `alert` is only called for odd values. -````smart header="O comando `continue` ajuda a reduzir aninhamento" -Um loop que retorna apenas valores ímpares poderia ter a seguinte forma: +````smart header="The `continue` directive helps decrease nesting" +A loop that shows odd values could look like this: ```js for (let i = 0; i < 10; i++) { @@ -264,15 +264,15 @@ for (let i = 0; i < 10; i++) { } ``` -De uma perspectiva técnica, isso é idêntico ao exemplo anterior. Certamente, podemos apenas envolver o código em um bloco `if` ao invés de utilizar `continue`. +From a technical point of view, this is identical to the example above. Surely, we can just wrap the code in an `if` block instead of using `continue`. -Mas como efeito colateral, isso criou mais um nível de aninhamento (o `alert` dentro dos colchetes). Se o código dentro de `if` for mais longo do que algumas linhas, isso pode reduzir a legibilidade de forma geral. +But as a side-effect, this created one more level of nesting (the `alert` call inside the curly braces). If the code inside of`if` is longer than a few lines, that may decrease the overall readability. ```` -````warn header="Não utilize `break/continue` do lado direito de '?'" -Note que construções sintáticas que não sejam expressões não podem ser utilizados com o operador ternário `?`. Em particular, comandos como `break/continue` não são permitidos nesta posição. +````warn header="No `break/continue` to the right side of '?'" +Please note that syntax constructs that are not expressions cannot be used with the ternary operator `?`. In particular, directives such as `break/continue` aren't allowed there. -Por exemplo, se tomarmos este código: +For example, if we take this code: ```js if (i > 5) { @@ -282,102 +282,104 @@ if (i > 5) { } ``` -...e reescrevermos utilizando o ponto de interrogação: +...and rewrite it using a question mark: + ```js no-beautify -(i > 5) ? alert(i) : *!*continue*/!*; // continue não é permitido aqui +(i > 5) ? alert(i) : *!*continue*/!*; // continue isn't allowed here ``` -...ele para de funcionar. Códigos como este vão gerar um erro de sintaxe. +...it stops working. Code like this will give a syntax error: + -Esta é apenas mais uma razão para não utilizar o operador ternário `?` no lugar de `if`. +This is just another reason not to use the question mark operator `?` instead of `if`. ```` ## Labels for break/continue -Às vezes, precisamos quebrar vários loops aninhados de uma vez só. +Sometimes we need to break out from multiple nested loops at once. -Por exemplo, no código abaixo nós utilizamos dois loops, com `i` e `j`, dando as coordenadas `(i, j)` de `(0,0)` a `(3,3)`: +For example, in the code below we loop over `i` and `j`, prompting for the coordinates `(i, j)` from `(0,0)` to `(3,3)`: ```js run no-beautify for (let i = 0; i < 3; i++) { for (let j = 0; j < 3; j++) { - let input = prompt(`Valor nas coordenadas (${i},${j})`, ''); + let input = prompt(`Value at coords (${i},${j})`, ''); - // e se quisermos sair daqui diretamente para "Pronto" (abaixo)? + // what if we want to exit from here to Done (below)? } } -alert('Pronto!'); +alert('Done!'); ``` -Precisamos de uma maneira de interromper o processo caso o usuário cancele o input. +We need a way to stop the process if the user cancels the input. -O `break` comum depois de `input` quebraria apenas o loop interno. Isso não é suficiente--labels, ao resgate! +The ordinary `break` after `input` would only break the inner loop. That's not sufficient--labels, come to the rescue! -Um *label* é um identificador com dois pontos antes de um loop: +A *label* is an identifier with a colon before a loop: ```js labelName: for (...) { ... } ``` -A declaração `break ` no loop abaixo quebra o loop designado pelo label: +The `break ` statement in the loop below breaks out to the label: ```js run no-beautify *!*outer:*/!* for (let i = 0; i < 3; i++) { for (let j = 0; j < 3; j++) { - let input = prompt(`Valor nas coordenadas (${i},${j})`, ''); + let input = prompt(`Value at coords (${i},${j})`, ''); - // se retornar um string vazio ou cancelar, quebrar ambos os loops + // if an empty string or canceled, then break out of both loops if (!input) *!*break outer*/!*; // (*) - // fazer algo com input... + // do something with the value... } } -alert('Pronto!'); +alert('Done!'); ``` -No código acima, `break outer` procura acima dele o label chamado `outer` e quebra aquele loop. +In the code above, `break outer` looks upwards for the label named `outer` and breaks out of that loop. -Assim o controle vai direto de `(*)` para `alert('Pronto!')`. +So the control goes straight from `(*)` to `alert('Done!')`. -Também podemos colocar o label em uma linha separada: +We can also move the label onto a separate line: ```js no-beautify outer: for (let i = 0; i < 3; i++) { ... } ``` -O comando `continue` também pode ser utilizado com um label. Nesse caso, a execução do código pula para a próxima iteração do loop nomeado pelo label. +The `continue` directive can also be used with a label. In this case, code execution jumps to the next iteration of the labeled loop. -````warn header="Labels não significam \"ir para\"" -Labels não nos permitem pular para qualquer lugar do código. +````warn header="Labels are not a \"goto\"" +Labels do not allow us to jump into an arbitrary place in the code. -Por exemplo, é impossível fazer isso: +For example, it is impossible to do this: ```js -break label; // pula para label? Não. +break label; // jumps to label? No. label: for (...) ``` -Uma chamada de `break/continue` só é possível de dentro de um loop e o label deve estar em algum lugar acima do comando. +A call to `break/continue` is only possible from inside a loop and the label must be somewhere above the directive. ```` -## Resumo +## Summary -Nós cobrimos 3 tipos de loops: +We covered 3 types of loops: -- `while` -- A condição é verificada antes de cada iteração. -- `do..while` -- A condição é verificada após cada iteração. -- `for (;;)` -- A condição é verificada antes de cada iteração, configurações adicionais disponíveis. +- `while` -- The condition is checked before each iteration. +- `do..while` -- The condition is checked after each iteration. +- `for (;;)` -- The condition is checked before each iteration, additional settings available. -Para fazer um loop "infinito", geralmente se utiliza a construção `white(true)`. Este loop, como qualquer outro, pode ser interrompido com o comando `break`. +To make an "infinite" loop, usually the `while(true)` construct is used. Such a loop, just like any other, can be stopped with the `break` directive. -Se não quisermos fazer nada na iteração atual e gostaríamos de pular para a próxima iteração, podemos utilizar o comando `continue`. +If we don't want to do anything in the current iteration and would like to forward to the next one, we can use the `continue` directive. -`break/continue` suportam labels antes do loop. Um label é a única maneira de fazer um `break/continue` escapar um loop aninhado e ir para o loop de fora. \ No newline at end of file +`break/continue` support labels before the loop. A label is the only way for `break/continue` to escape a nested loop to go to an outer one. From 0e8eaef5a495497537c3b097bacacff12969172c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=81lvaro=20Antonio?= Date: Mon, 21 Oct 2019 17:46:09 -0300 Subject: [PATCH 09/13] commiting translation with proper credentials --- .../1-loop-last-value/solution.md | 14 +- .../12-while-for/1-loop-last-value/task.md | 4 +- .../2-which-value-while/solution.md | 24 +- .../12-while-for/2-which-value-while/task.md | 10 +- .../3-which-value-for/solution.md | 14 +- .../12-while-for/3-which-value-for/task.md | 10 +- .../12-while-for/4-for-even/solution.md | 2 +- .../12-while-for/4-for-even/task.md | 4 +- .../5-replace-for-while/solution.md | 2 +- .../12-while-for/5-replace-for-while/task.md | 6 +- .../6-repeat-until-correct/solution.md | 10 +- .../6-repeat-until-correct/task.md | 8 +- .../12-while-for/7-list-primes/solution.md | 24 +- .../12-while-for/7-list-primes/task.md | 15 +- 1-js/02-first-steps/12-while-for/article.md | 250 +++++++++--------- 15 files changed, 199 insertions(+), 198 deletions(-) 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 index 43ee4aad3..beece44a2 100755 --- 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 @@ -1,4 +1,4 @@ -The answer: `1`. +Resposta: `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`. +Cada iteração do loop decresce `i` em `1`. O teste `while(i)` interrompe o loop quando `i = 0`. -Hence, the steps of the loop form the following sequence ("loop unrolled"): +Portanto, as etapas do loop formam a seguinte sequência ("loop desenrolado"): ```js let i = 3; -alert(i--); // shows 3, decreases i to 2 +alert(i--); // exibe 3, decresce i para 2 -alert(i--) // shows 2, decreases i to 1 +alert(i--) // exibe 2, decresce i para 1 -alert(i--) // shows 1, decreases i to 0 +alert(i--) // exibe 1, decresce i para 0 -// done, while(i) check stops the loop +// pronto, o teste while(i) interrompe o loop ``` 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 index 3b847dfa2..dd931937d 100755 --- 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 @@ -2,9 +2,9 @@ importance: 3 --- -# Last loop value +# Último valor do loop -What is the last value alerted by this code? Why? +Qual é o último valor exibido no alerta 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 index 495359876..3a8cc5d6e 100755 --- 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 @@ -1,30 +1,32 @@ -The task demonstrates how postfix/prefix forms can lead to different results when used in comparisons. +Este exercício demonstra como formas posfixadas/prefixadas podem levar a resultados distintos quando utilizadas em comparações. -1. **From 1 to 4** +1. **De 1 a 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`. + O primeiro valor é `i = 1`, pois `++i` primeiro incrementa `i` e em seguida retorna o novo valor. Então, a primeira comparação é `1 < 5` e o `alert` exibe `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. + Em seguida vêm `2, 3, 4…` -- os valores aparecem um depois do outro. A comparação sempre usa o valor incrementado, pois `++` vem antes da variável. - 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** + Finalmente, `i = 4` é incrementado a `5`, a comparação `while(5 < 5)` falha, e o loop termina. Assim, `5` não é exibido. + +2. **De 1 a 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`). + O primeiro valor é novamente `i = 1`. A forma posfixada `i++`incrementa `i` e em seguida retorna o valor *antigo*, então a comparação `i++ < 5` utilizará `i = 0` (diferente de `++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`. + Mas a chamada de `alert` é separada. Ela é uma declaração distinta que executa após o incremento e a comparaçào. Assim, ela recebe o valor atual `i = 1`. - Then follow `2, 3, 4…` + Em seguida, vêm `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`. + Vamos parar em `i = 4`. A forma prefixada `++i` iria incrementar e utilizar `5` na comparação. Mas aqui temos a forma posfixada `i++`. Ela incrementa `i` para `5`, mas retorna o valor antigo. Portanto a comparação é, na verdade, `while(4 < 5)` -- verdadeira, e o controle passa para `alert`. - The value `i = 5` is the last one, because on the next step `while(5 < 5)` is false. + O valor `i = 5` é o último, porque na próxima etapa `while(5 < 5)` é falso. + \ No newline at end of file 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 index 298213237..aefb036d3 100755 --- 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 @@ -2,19 +2,19 @@ importance: 4 --- -# Which values does the while loop show? +# Quais valores o loop while retorna? -For every loop iteration, write down which value it outputs and then compare it with the solution. +Para cada iteração dos loops, anote o valor que ele retorna, depois compare com a solução. -Both loops `alert` the same values, or not? +Ambos os loops retornam em `alert` os mesmo valores, ou não? -1. The prefix form `++i`: +1. A forma prefixada `++i`: ```js let i = 0; while (++i < 5) alert( i ); ``` -2. The postfix form `i++` +2. A forma posfixada `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 index e2e28e75b..55f27ec83 100755 --- 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 @@ -1,4 +1,4 @@ -**The answer: from `0` to `4` in both cases.** +**Resposta: de `0` a `4` nos dois casos.** ```js run for (let i = 0; i < 5; ++i) alert( i ); @@ -6,12 +6,12 @@ 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`: +Isso pode ser facilmente deduzido do 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. Executar `i = 0` uma vez antes de tudo (begin). +2. Verificar a condição `i < 5`. +3. Caso verdadeira (`true`), executar o corpo do loop `alert(i)`, e em seguida `i++`. -The increment `i++` is separated from the condition check (2). That's just another statement. +O incremento `i++` é separado do teste da condição (2). Trata-se de outra declaração. -The value returned by the increment is not used here, so there's no difference between `i++` and `++i`. +O valor retornado pelo incremento não é utilizado aqui, então não há diferença entre `i++` e `++i`. \ No newline at end of file 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 index bfefa63f5..abc4a37be 100755 --- 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 @@ -2,18 +2,18 @@ importance: 4 --- -# Which values get shown by the "for" loop? +# Quais valores são mostrados pelo loop "for"? -For each loop write down which values it is going to show. Then compare with the answer. +Pada cada loop, anote quais os valores retornados. Depois, compare com a resposta. -Both loops `alert` same values or not? +Ambos os loops retornam em `alert` os mesmo valores, ou não? -1. The postfix form: +1. A forma posfixada: ```js for (let i = 0; i < 5; i++) alert( i ); ``` -2. The prefix form: +2. A forma prefixada: ```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 index e8e66bb47..f7e6e30f8 100755 --- 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 @@ -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. +Utilizamos o operador "módulo" `%` aqui para obter o resto e testar se o valor é par. 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 index ff34e7e40..5627f1f70 100755 --- 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 @@ -2,8 +2,8 @@ importance: 5 --- -# Output even numbers in the loop +# Retornar valores pares no loop -Use the `for` loop to output even numbers from `2` to `10`. +Utilize o loop `for` para retornar números pares de `2` a `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 index 612cf559c..5579686ef 100755 --- 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 @@ -3,7 +3,7 @@ ```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 index 0c69d9c2d..a38929c63 100755 --- 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 @@ -2,13 +2,13 @@ importance: 5 --- -# Replace "for" with "while" +# Substituir "for" por "while" -Rewrite the code changing the `for` loop to `while` without altering its behavior (the output should stay same). +Reescreva o código, mudando o loop `for` para `while` sem alterar seu comportamento (o resultado deve continuar o mesmo). ```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 index 2e04a78c4..f7ce57442 100755 --- 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 @@ -3,13 +3,13 @@ let num; do { - num = prompt("Enter a number greater than 100?", 0); + num = prompt("Digite um número maior que 100:", 0); } while (num <= 100 && num); ``` -The loop `do..while` repeats while both checks are truthy: +O loop `do..while` repete enquanto ambos os testes sejam verdadeiros: -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. O teste `num <= 100` -- isto é, o valor digitado ainda não é maior que `100`. +2. O teste `&& num` é falso quando `num` é `null` ou um string vazio. Então, o loop `while` também é interrompido. -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. Se `num` é `null`, então `num <= 100` é verdadeiro. Por isso, sem o segundo teste, o loop não iria encerrar se o usuário clicasse em "CANCELAR". Ambos os testes são necessários. 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 index 0788ee76e..b2253a61a 100755 --- 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 @@ -2,12 +2,12 @@ importance: 5 --- -# Repeat until the input is correct +# Repetir até que o input esteja correto -Write a loop which prompts for a number greater than `100`. If the visitor enters another number -- ask them to input again. +Escreva um loop que peça um número maior que `100`. Se o usuário digitar outro número, peça para digite digitar novamente. -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. +O loop deve pedir um número até que o usuário digite um número maior que `100` ou cancele o diálogo/submeta uma linha em branco. -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. +Aqui podemos assumir que o usuário só digita números. Não é preciso implementar um tratamento especial para inputs não-numéricos neste exercício. [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 index 9ff0663d7..a011f54db 100755 --- 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 @@ -1,29 +1,29 @@ -There are many algorithms for this task. +Há muitos algotimos para esta tarefa. -Let's use a nested loop: +Vamos utilizar um loop dentro de outro (isto é, aninhado): ```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 +Para cada i no intervalo { + testar se i tem um divisor de 1 a i + se sim => o valor não é um primo + se não => o valor e um primo, mostre-o } ``` -The code using a label: +O código usando um label: ```js run let n = 10; nextPrime: -for (let i = 2; i <= n; i++) { // for each i... +for (let i = 2; i <= n; i++) { // para 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++) { // procurar um divisor.. + if (i % j == 0) continue nextPrime; // não é primo, passar para o 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. +Há muitas maneiras de otimizá-lo. Por exemplo, podemos procurar divisores de `2` até a raiz quadrada de `i`. De qualquer modo, se quisermos ser realmente eficientes para intervalos maiores, precisamos mudar a abordagem e nos embasar em matemática avançada e algoritmos complexos como o [Crivo Quadrático](https://en.wikipedia.org/wiki/Quadratic_sieve), o [Crivo do Corpo de Números Geral](https://en.wikipedia.org/wiki/General_number_field_sieve), etc. \ No newline at end of file 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 index 6344b9f6f..6e517b8b9 100755 --- 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 @@ -2,16 +2,17 @@ importance: 3 --- -# Output prime numbers +# Retornar número 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. +Um número inteiro maior que `1` é chamado de [primo](https://pt.wikipedia.org/wiki/Número_primo) se ele não puder ser divido por nenhum outro número exceto por `1` e por si mesmo sem gerar um resto. -In other words, `n > 1` is a prime if it can't be evenly divided by anything except `1` and `n`. -For example, `5` is a prime, because it cannot be divided without a remainder by `2`, `3` and `4`. +Em outras palavras, `n > 1` é um primo se ele não puder ser dividido sem resto por nada além de `1` e `n`. -**Write the code which outputs prime numbers in the interval from `2` to `n`.** +Por exemplo, `5` é um primo, pois não pode ser dividido sem resto por `2`, `3` e `4`. -For `n = 10` the result will be `2,3,5,7`. +**Escreva o código que retorne números primos no intervalo de `2` a `n`.** -P.S. The code should work for any `n`, not be hard-tuned for any fixed value. +Para `n = 10`, o resultado será `2,3,5,7`. + +P.S. O código deve funcionar para qualquer `n`, e não pré-estabelecido para um valor fixo. diff --git a/1-js/02-first-steps/12-while-for/article.md b/1-js/02-first-steps/12-while-for/article.md index 6be50597d..584612b33 100755 --- a/1-js/02-first-steps/12-while-for/article.md +++ b/1-js/02-first-steps/12-while-for/article.md @@ -1,54 +1,54 @@ -# Loops: while and for +# Loops: while e for -We often need to repeat actions. +Frequentemente precisamos repetir ações. -For example, outputting goods from a list one after another or just running the same code for each number from 1 to 10. +Por exemplo, retornar itens de uma lista, um atrás do outro, ou apenas executar o mesmo código para cada número de 1 a 10. -*Loops* are a way to repeat the same code multiple times. +*Loops* são uma maneira de repetir o mesmo código múltiplas vezes. -## The "while" loop +## O loop "while" -The `while` loop has the following syntax: +O `while` loop tem a sintaxe seguinte: ```js -while (condition) { - // code - // so-called "loop body" +while (condição) { + // código + // chamado de "loop body" (corpo do loop) } ``` -While the `condition` is `true`, the `code` from the loop body is executed. +Enquanto `condição` for verdadeira, o `código` do corpo do loop é executado. -For instance, the loop below outputs `i` while `i < 3`: +Por exemplo, o loop abaixo retorna `i` enquanto `i < 3`: ```js run let i = 0; -while (i < 3) { // shows 0, then 1, then 2 +while (i < 3) { // retorna 0, depois 1, depois 2 alert( i ); i++; } ``` -A single execution of the loop body is called *an iteration*. The loop in the example above makes three iterations. +Uma única execução do corpo do loop é chamada de *uma iteração*. O loop no exemplo acima realiza três iterações. -If `i++` was missing from the example above, the loop would repeat (in theory) forever. In practice, the browser provides ways to stop such loops, and in server-side JavaScript, we can kill the process. +Se `i++` não estivesse presente no exemplo acima, o loop repetiria (teoricamente) para sempre. Na prática, o navegador nos oferece maneira de interromper tais loops, e em JavaScript server-side, é possível matar o processo. -Any expression or variable can be a loop condition, not just comparisons: the condition is evaluated and converted to a boolean by `while`. +Qualquer expressão ou variável pode ser uma condição para um loop, não apenas comparações: a condição é avaliada e convertida por `while` para um booleano. -For instance, a shorter way to write `while (i != 0)` is `while (i)`: +Por exemplo, uma maneira mais curta de escrever `while (i != 0)` é `while (i)`: ```js run let i = 3; *!* -while (i) { // when i becomes 0, the condition becomes falsy, and the loop stops +while (i) { // quando i se tornar 0, a condição se torna falsa, e o loop para */!* alert( i ); i--; } ``` -````smart header="Brackets are not required for a single-line body" -If the loop body has a single statement, we can omit the brackets `{…}`: +````smart header="Colchetes não são necessários se o corpo possuir só uma linha" +Se o corpo do loop possuir uma única declaração, podemos omitir os colchetes `{...}`: ```js run let i = 3; @@ -58,19 +58,19 @@ while (i) alert(i--); ``` ```` -## The "do..while" loop +## O loop "do..while" -The condition check can be moved *below* the loop body using the `do..while` syntax: +A verificação da condição pode ser movida *abaixo* do corpo do loop utilizando a sintaxe `do..while`: ```js do { - // loop body -} while (condition); + // corpo do loop +} while (condição); ``` -The loop will first execute the body, then check the condition, and, while it's truthy, execute it again and again. +O loop vai executar primeiro o corpo, depois checar a condição e, enquanto ela permanecer verdadeira, executar o corpo novamente. -For example: +Por exemplo: ```js run let i = 0; @@ -80,107 +80,107 @@ do { } while (i < 3); ``` -This form of syntax should only be used when you want the body of the loop to execute **at least once** regardless of the condition being truthy. Usually, the other form is preferred: `while(…) {…}`. +Esta forma de sintaxe deve ser usada apenas quando você deseja que o corpo do loop seja executado **pelo menos uma vez**, independente de a condição ser verdadeira. Geralmente, prefere-se a outra forma: `while(...) {...}`. -## The "for" loop +## O loop "for" -The `for` loop is the most commonly used loop. +O loop `for` é o mais comumente utilizado. -It looks like this: +Ele tem esse formato: ```js -for (begin; condition; step) { - // ... loop body ... +for (início; condição; etapa) { + // ... corpo do loop ... } ``` -Let's learn the meaning of these parts by example. The loop below runs `alert(i)` for `i` from `0` up to (but not including) `3`: +Vamos aprender o que significam cada uma dessas partes através de exemplos. O loop abaixo executa `alert(i)` para `i` de `0` a (não incluso) `3`: ```js run -for (let i = 0; i < 3; i++) { // shows 0, then 1, then 2 +for (let i = 0; i < 3; i++) { // retorna 0, depois 1, depois 2 alert(i); } ``` -Let's examine the `for` statement part-by-part: +Vamos examinar a declaração `for` parte por parte: -| part | | | -|-------|----------|----------------------------------------------------------------------------| -| begin | `i = 0` | Executes once upon entering the loop. | -| condition | `i < 3`| Checked before every loop iteration. If false, the loop stops. | -| step| `i++` | Executes after the body on each iteration but before the condition check. | -| body | `alert(i)`| Runs again and again while the condition is truthy. | +| part | | | +|----------|------------|--------------------------------------------------------------------------------| +| início | `i = 0` | Executado uma vez na entrada do loop. | +| condição | `i < 3` | Verificada a cada iteração do loop. Se falsa, o loop é interrompido. | +| etapa | `i++` | Executado depois do corpo, a cada iteração, mas antes de verificar a condição. | +| corpo | `alert(i)` | Executado repetidamente enquanto a condição for verdadeira. | -The general loop algorithm works like this: +O algoritmo geral do loop funciona assim: ``` -Run begin -→ (if condition → run body and run step) -→ (if condition → run body and run step) -→ (if condition → run body and run step) +Executar início +→ (se condição verdadeira → executar corpo e executar etapa) +→ (se condição verdadeira → executar corpo e executar etapa) +→ (se condição verdadeira → executar corpo e executar etapa) → ... ``` -If you are new to loops, it could help to go back to the example and reproduce how it runs step-by-step on a piece of paper. +Caso loops sejam novos para você, pode ser útil voltar ao exemplo e reproduzir sua execução passo-a-passo em uma folha de papel. -Here's exactly what happens in our case: +No nosso exemplo, o que acontece exatamente é isso: ```js // for (let i = 0; i < 3; i++) alert(i) -// run begin +// executar condição let i = 0 -// if condition → run body and run step +// se condição verdadeira → executar corpo e executar etapa if (i < 3) { alert(i); i++ } -// if condition → run body and run step +// se condição verdadeira → executar corpo e executar etapa if (i < 3) { alert(i); i++ } -// if condition → run body and run step +// se condição verdadeira → executar corpo e executar etapa if (i < 3) { alert(i); i++ } -// ...finish, because now i == 3 +// ...encerrar, pois agora i == 3 ``` -````smart header="Inline variable declaration" -Here, the "counter" variable `i` is declared right in the loop. This is called an "inline" variable declaration. Such variables are visible only inside the loop. +````smart header="Declaração de variável inline" +Aqui, a variável "de contagem" `i` é declarada diretamente no loop. Isso é chamado de declaração de variável "inline". Tais variáveis são visíveis somente no interior do loop. ```js run for (*!*let*/!* i = 0; i < 3; i++) { alert(i); // 0, 1, 2 } -alert(i); // error, no such variable +alert(i); // erro, variável não existente ``` -Instead of defining a variable, we could use an existing one: +Ao invés de definir a variável, podemos utilizar uma já existente: ```js run let i = 0; -for (i = 0; i < 3; i++) { // use an existing variable +for (i = 0; i < 3; i++) { // usando uma variável pré-existente alert(i); // 0, 1, 2 } -alert(i); // 3, visible, because declared outside of the loop +alert(i); // 3, visível, porque declarada fora do loop ``` ```` -### Skipping parts +### Omitindo partes -Any part of `for` can be skipped. +Qualquer parte de `for` pode ser omitida. -For example, we can omit `begin` if we don't need to do anything at the loop start. +Por exemplo, podemos omitir `início` caso não seja necessário fazer nada no início do loop. -Like here: +Como neste exemplo: ```js run -let i = 0; // we have i already declared and assigned +let i = 0; // já temos i declarada e atribuída -for (; i < 3; i++) { // no need for "begin" +for (; i < 3; i++) { // "início" não é necessário alert( i ); // 0, 1, 2 } ``` -We can also remove the `step` part: +Também podemos remover a parte da `etapa`: ```js run let i = 0; @@ -190,32 +190,32 @@ for (; i < 3;) { } ``` -This makes the loop identical to `while (i < 3)`. +Isso torna o loop idêntico a `while (i < 3)`. -We can actually remove everything, creating an infinite loop: +Na verdade, podemos remover tudo, criando um loop infinito: ```js for (;;) { - // repeats without limits + // repete sem limites } ``` -Please note that the two `for` semicolons `;` must be present. Otherwise, there would be a syntax error. +Note que os dois pontos-e-vírgulas `;` dentro do `for` devem estar presentes. Caso contrário, haverá um erro de sintaxe. -## Breaking the loop +## Quebrando o loop -Normally, a loop exits when its condition becomes falsy. +Normalmente, um loop se encerra quando sua condição se torna falsa. -But we can force the exit at any time using the special `break` directive. +Mas podemos forçar a saída a qualquer momento utilizando o comando especial `break`. -For example, the loop below asks the user for a series of numbers, "breaking" when no number is entered: +Por exemplo, o loop abaixo pede ao usuário uma série de números, e "quebra" quando nenhum número é informado: ```js let sum = 0; while (true) { - let value = +prompt("Enter a number", ''); + let value = +prompt("Digite um número", ''); *!* if (!value) break; // (*) @@ -224,35 +224,35 @@ while (true) { sum += value; } -alert( 'Sum: ' + sum ); +alert( 'Soma: ' + sum ); ``` -The `break` directive is activated at the line `(*)` if the user enters an empty line or cancels the input. It stops the loop immediately, passing control to the first line after the loop. Namely, `alert`. +O comando `break` é ativado na linha `(*)` se o usuário deixa a linha em branco ou cancela o diálogo. Ele interrompe o loop imediatamente, passando o controle à primeira linha depois do loop. Neste caso, `alert`. -The combination "infinite loop + `break` as needed" is great for situations when a loop's condition must be checked not in the beginning or end of the loop, but in the middle or even in several places of its body. +A combinação "loop infinito " `break` quando necessário" é ótima para situações onde a condição do loop precisa ser verificada não no início ou no fim do loop, mas no meio, ou até mesmo em vários lugares do corpo do loop. -## Continue to the next iteration [#continue] +## Continue para a próxima iteração [#continue] -The `continue` directive is a "lighter version" of `break`. It doesn't stop the whole loop. Instead, it stops the current iteration and forces the loop to start a new one (if the condition allows). +O comando `continue` é uma "versão mais light" de `break`. Ele não interrompe o loop como um todo. Ao invés disso, ele interrompe a iteração atual e força o loop a começar uma nova (se a condição permitir). -We can use it if we're done with the current iteration and would like to move on to the next one. +Você pode utilizá-lo caso a iteração atual já não seja útil e você deseje passar para a próxima. -The loop below uses `continue` to output only odd values: +O loop abaixo usa `continue` para exibir apenas valores ímpares: ```js run no-beautify for (let i = 0; i < 10; i++) { - // if true, skip the remaining part of the body + // se verdadeiro, pular o restante do corpo *!*if (i % 2 == 0) continue;*/!* alert(i); // 1, then 3, 5, 7, 9 } ``` -For even values of `i`, the `continue` directive stops executing the body and passes control to the next iteration of `for` (with the next number). So the `alert` is only called for odd values. +Para valores pares de `i`, o comando `continue` interrompe a execução do corpo e passa o controle para a próxima iteração de `for` (com o número seguinte). Então `alert` só é chamado para valores ímpares. -````smart header="The `continue` directive helps decrease nesting" -A loop that shows odd values could look like this: +````smart header="O comando `continue` ajuda a reduzir aninhamento" +Um loop que retorna apenas valores ímpares poderia ter a seguinte forma: ```js for (let i = 0; i < 10; i++) { @@ -264,15 +264,15 @@ for (let i = 0; i < 10; i++) { } ``` -From a technical point of view, this is identical to the example above. Surely, we can just wrap the code in an `if` block instead of using `continue`. +De uma perspectiva técnica, isso é idêntico ao exemplo anterior. Certamente, podemos apenas envolver o código em um bloco `if` ao invés de utilizar `continue`. -But as a side-effect, this created one more level of nesting (the `alert` call inside the curly braces). If the code inside of`if` is longer than a few lines, that may decrease the overall readability. +Mas como efeito colateral, isso criou mais um nível de aninhamento (o `alert` dentro dos colchetes). Se o código dentro de `if` for mais longo do que algumas linhas, isso pode reduzir a legibilidade de forma geral. ```` -````warn header="No `break/continue` to the right side of '?'" -Please note that syntax constructs that are not expressions cannot be used with the ternary operator `?`. In particular, directives such as `break/continue` aren't allowed there. +````warn header="Não utilize `break/continue` do lado direito de '?'" +Note que construções sintáticas que não sejam expressões não podem ser utilizados com o operador ternário `?`. Em particular, comandos como `break/continue` não são permitidos nesta posição. -For example, if we take this code: +Por exemplo, se tomarmos este código: ```js if (i > 5) { @@ -282,104 +282,102 @@ if (i > 5) { } ``` -...and rewrite it using a question mark: - +...e reescrevermos utilizando o ponto de interrogação: ```js no-beautify -(i > 5) ? alert(i) : *!*continue*/!*; // continue isn't allowed here +(i > 5) ? alert(i) : *!*continue*/!*; // continue não é permitido aqui ``` -...it stops working. Code like this will give a syntax error: - +...ele para de funcionar. Códigos como este vão gerar um erro de sintaxe. -This is just another reason not to use the question mark operator `?` instead of `if`. +Esta é apenas mais uma razão para não utilizar o operador ternário `?` no lugar de `if`. ```` ## Labels for break/continue -Sometimes we need to break out from multiple nested loops at once. +Às vezes, precisamos quebrar vários loops aninhados de uma vez só. -For example, in the code below we loop over `i` and `j`, prompting for the coordinates `(i, j)` from `(0,0)` to `(3,3)`: +Por exemplo, no código abaixo nós utilizamos dois loops, com `i` e `j`, dando as coordenadas `(i, j)` de `(0,0)` a `(3,3)`: ```js run no-beautify for (let i = 0; i < 3; i++) { for (let j = 0; j < 3; j++) { - let input = prompt(`Value at coords (${i},${j})`, ''); + let input = prompt(`Valor nas coordenadas (${i},${j})`, ''); - // what if we want to exit from here to Done (below)? + // e se quisermos sair daqui diretamente para "Pronto" (abaixo)? } } -alert('Done!'); +alert('Pronto!'); ``` -We need a way to stop the process if the user cancels the input. +Precisamos de uma maneira de interromper o processo caso o usuário cancele o input. -The ordinary `break` after `input` would only break the inner loop. That's not sufficient--labels, come to the rescue! +O `break` comum depois de `input` quebraria apenas o loop interno. Isso não é suficiente--labels, ao resgate! -A *label* is an identifier with a colon before a loop: +Um *label* é um identificador com dois pontos antes de um loop: ```js labelName: for (...) { ... } ``` -The `break ` statement in the loop below breaks out to the label: +A declaração `break ` no loop abaixo quebra o loop designado pelo label: ```js run no-beautify *!*outer:*/!* for (let i = 0; i < 3; i++) { for (let j = 0; j < 3; j++) { - let input = prompt(`Value at coords (${i},${j})`, ''); + let input = prompt(`Valor nas coordenadas (${i},${j})`, ''); - // if an empty string or canceled, then break out of both loops + // se retornar um string vazio ou cancelar, quebrar ambos os loops if (!input) *!*break outer*/!*; // (*) - // do something with the value... + // fazer algo com input... } } -alert('Done!'); +alert('Pronto!'); ``` -In the code above, `break outer` looks upwards for the label named `outer` and breaks out of that loop. +No código acima, `break outer` procura acima dele o label chamado `outer` e quebra aquele loop. -So the control goes straight from `(*)` to `alert('Done!')`. +Assim o controle vai direto de `(*)` para `alert('Pronto!')`. -We can also move the label onto a separate line: +Também podemos colocar o label em uma linha separada: ```js no-beautify outer: for (let i = 0; i < 3; i++) { ... } ``` -The `continue` directive can also be used with a label. In this case, code execution jumps to the next iteration of the labeled loop. +O comando `continue` também pode ser utilizado com um label. Nesse caso, a execução do código pula para a próxima iteração do loop nomeado pelo label. -````warn header="Labels are not a \"goto\"" -Labels do not allow us to jump into an arbitrary place in the code. +````warn header="Labels não significam \"ir para\"" +Labels não nos permitem pular para qualquer lugar do código. -For example, it is impossible to do this: +Por exemplo, é impossível fazer isso: ```js -break label; // jumps to label? No. +break label; // pula para label? Não. label: for (...) ``` -A call to `break/continue` is only possible from inside a loop and the label must be somewhere above the directive. +Uma chamada de `break/continue` só é possível de dentro de um loop e o label deve estar em algum lugar acima do comando. ```` -## Summary +## Resumo -We covered 3 types of loops: +Nós cobrimos 3 tipos de loops: -- `while` -- The condition is checked before each iteration. -- `do..while` -- The condition is checked after each iteration. -- `for (;;)` -- The condition is checked before each iteration, additional settings available. +- `while` -- A condição é verificada antes de cada iteração. +- `do..while` -- A condição é verificada após cada iteração. +- `for (;;)` -- A condição é verificada antes de cada iteração, configurações adicionais disponíveis. -To make an "infinite" loop, usually the `while(true)` construct is used. Such a loop, just like any other, can be stopped with the `break` directive. +Para fazer um loop "infinito", geralmente se utiliza a construção `white(true)`. Este loop, como qualquer outro, pode ser interrompido com o comando `break`. -If we don't want to do anything in the current iteration and would like to forward to the next one, we can use the `continue` directive. +Se não quisermos fazer nada na iteração atual e gostaríamos de pular para a próxima iteração, podemos utilizar o comando `continue`. -`break/continue` support labels before the loop. A label is the only way for `break/continue` to escape a nested loop to go to an outer one. +`break/continue` suportam labels antes do loop. Um label é a única maneira de fazer um `break/continue` escapar um loop aninhado e ir para o loop de fora. \ No newline at end of file From b8d6da2e5c160d956a965119df582e7a0cd3e174 Mon Sep 17 00:00:00 2001 From: Osvaldo Dias dos Santos Date: Mon, 15 Jul 2024 19:25:21 +0100 Subject: [PATCH 10/13] Translate a word. --- 1-js/02-first-steps/12-while-for/3-which-value-for/solution.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) 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 index 55f27ec83..d51ed4114 100755 --- 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 @@ -8,7 +8,7 @@ for (let i = 0; i < 5; i++) alert( i ); Isso pode ser facilmente deduzido do algoritmo de `for`: -1. Executar `i = 0` uma vez antes de tudo (begin). +1. Executar `i = 0` uma vez antes de tudo (início). 2. Verificar a condição `i < 5`. 3. Caso verdadeira (`true`), executar o corpo do loop `alert(i)`, e em seguida `i++`. From 59c82e13837b7c631bcad52a16282c51d1c9a0d6 Mon Sep 17 00:00:00 2001 From: Osvaldo Dias dos Santos Date: Mon, 15 Jul 2024 19:39:01 +0100 Subject: [PATCH 11/13] Correct a translation typo --- 1-js/02-first-steps/12-while-for/3-which-value-for/task.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) 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 index abc4a37be..0422670e6 100755 --- 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 @@ -6,7 +6,7 @@ importance: 4 Pada cada loop, anote quais os valores retornados. Depois, compare com a resposta. -Ambos os loops retornam em `alert` os mesmo valores, ou não? +Ambos os loops retornam em `alert` os mesmos valores, ou não? 1. A forma posfixada: From 784e756a77db7fb6ca4c31768fe6e81b8d698b79 Mon Sep 17 00:00:00 2001 From: Osvaldo Dias dos Santos Date: Fri, 19 Jul 2024 21:48:52 +0100 Subject: [PATCH 12/13] Remove duplicate translated word, suggest translation change, and replace hyperlink by Portuguese version --- 1-js/02-first-steps/12-while-for/6-repeat-until-correct/task.md | 2 +- 1-js/02-first-steps/12-while-for/7-list-primes/solution.md | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) 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 index b2253a61a..449e2db5f 100755 --- 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 @@ -4,7 +4,7 @@ importance: 5 # Repetir até que o input esteja correto -Escreva um loop que peça um número maior que `100`. Se o usuário digitar outro número, peça para digite digitar novamente. +Escreva um loop que peça um número maior que `100`. Se o usuário digitar outro número, peça para digitar novamente. O loop deve pedir um número até que o usuário digite um número maior que `100` ou cancele o diálogo/submeta uma linha em branco. 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 index a011f54db..667669725 100755 --- 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 @@ -26,4 +26,4 @@ for (let i = 2; i <= n; i++) { // para cada i... } ``` -Há muitas maneiras de otimizá-lo. Por exemplo, podemos procurar divisores de `2` até a raiz quadrada de `i`. De qualquer modo, se quisermos ser realmente eficientes para intervalos maiores, precisamos mudar a abordagem e nos embasar em matemática avançada e algoritmos complexos como o [Crivo Quadrático](https://en.wikipedia.org/wiki/Quadratic_sieve), o [Crivo do Corpo de Números Geral](https://en.wikipedia.org/wiki/General_number_field_sieve), etc. \ No newline at end of file +Há muitas maneiras de otimizá-lo. Por exemplo, podemos procurar divisores de `2` até a raiz quadrada de `i`. De qualquer modo, se quisermos ser realmente eficientes para intervalos maiores, precisamos de mudar a abordagem e usar matemática avançada e algoritmos complexos como o [Crivo Quadrático](https://en.wikipedia.org/wiki/Quadratic_sieve), o [Campo de número de peneira geral](https://pt.wikipedia.org/wiki/Campo_de_n%C3%BAmero_de_peneira_geral), etc. \ No newline at end of file From e0fccfcadc39e3e2eddb348b59330ee3211979ca Mon Sep 17 00:00:00 2001 From: Osvaldo Dias dos Santos Date: Fri, 19 Jul 2024 21:53:09 +0100 Subject: [PATCH 13/13] Remove duplicate translated word, suggest translation change, and replace hyperlink by Portuguese version