gaspersic/freeCodeCamp
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

chore(i18n,curriculum): update translations (#43078)

Browse Source
This commit is contained in:
camperbot
2021-07-30 23:57:21 +09:00
committed by GitHub
parent 5ab5d156e9
commit 594adf02c1
239 changed files with 1049 additions and 1045 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/regular-expressions/check-for-all-or-none.md
View File

@ -30,28 +30,28 @@ Altere a regex `favRegex` para encontrar as versões americana (`favorite`) e br
# --hints--
Sua regex deve usar a interrogação (`?`) para validação opcional.
A regex deve usar a interrogação (`?`) para validação opcional.
```js
favRegex.lastIndex = 0;
assert(favRegex.source.match(/\?/).length > 0);
```
Sua regex deve encontrar a string `favorite`
A regex deve encontrar a string `favorite`
```js
favRegex.lastIndex = 0;
assert(favRegex.test('favorite'));
```
Sua regex deve encontrar a string `favourite`
A regex deve encontrar a string `favourite`
```js
favRegex.lastIndex = 0;
assert(favRegex.test('favourite'));
```
Sua regex não deve encontrar a string `fav`
A regex não deve encontrar a string `fav`
```js
favRegex.lastIndex = 0;

10
curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/regular-expressions/check-for-mixed-grouping-of-characters.md
View File

@ -1,6 +1,6 @@
---
id: 5c3dda8b4d8df89bea71600f
title: Validando grupos mistos de caracteres
title: Validar grupos mistos de caracteres
challengeType: 1
forumTopicId: 301339
dashedName: check-for-mixed-grouping-of-characters
@ -30,28 +30,28 @@ Depois corrija o código, fazendo com que a regex seja testada na string `myStri
# --hints--
Sua regex `myRegex` deve retornar `true` para a string `Franklin D. Roosevelt`
A regex `myRegex` deve retornar `true` para a string `Franklin D. Roosevelt`
```js
myRegex.lastIndex = 0;
assert(myRegex.test('Franklin D. Roosevelt'));
```
Sua regex `myRegex` deve retornar `true` para a string `Eleanor Roosevelt`
A regex `myRegex` deve retornar `true` para a string `Eleanor Roosevelt`
```js
myRegex.lastIndex = 0;
assert(myRegex.test('Eleanor Roosevelt'));
```
Sua regex `myRegex` deve retornar `false` para a string `Franklin Rosevelt`
A regex `myRegex` deve retornar `false` para a string `Franklin Rosevelt`
```js
myRegex.lastIndex = 0;
assert(!myRegex.test('Franklin Rosevelt'));
```
Sua regex `myRegex` deve retornar `false` para a string `Frank Roosevelt`
A regex `myRegex` deve retornar `false` para a string `Frank Roosevelt`
```js
myRegex.lastIndex = 0;

2
curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/regular-expressions/extract-matches.md
View File

@ -42,7 +42,7 @@ O resultado, `result`, deve conter a string `coding`
assert(result.join() === 'coding');
```
Sua regex `codingRegex` deve buscar a string `coding`
A regex `codingRegex` deve buscar a string `coding`
```js
assert(codingRegex.source === 'coding');

2
curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/regular-expressions/find-characters-with-lazy-matching.md
View File

@ -16,7 +16,7 @@ Expressões regulares são gananciosas por padrão, então o resultado seria `["
Mas você pode usar o caractere `?` para torná-la preguiçosa. Aplicar a regex adaptada `/t[a-z]*?i/` à string `"titanic"` retorna `["ti"]`.
**Obs:** Ler HTML com expressões regulares deve ser evitado, mas procurar uma string HTML usando expressões regulares é perfeitamente aceitável.
**Observação:** ler HTML com expressões regulares deve ser evitado, mas procurar uma string HTML usando expressões regulares é perfeitamente aceitável.
# --instructions--

12
curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/regular-expressions/find-more-than-the-first-match.md
View File

@ -31,24 +31,24 @@ Aqui, `match` retorna o valor `["Repeat", "Repeat", "Repeat"]`
Usando a regex `starRegex`, encontre e extraia ambas ocorrências da palavra `Twinkle` da string `twinkleStar`.
**Obs:**
Você pode usar múltiplas flags em uma regex: `/search/gi`
**Observação:**
você pode usar múltiplas flags em uma regex: `/search/gi`
# --hints--
Sua regex `starRegex` deve usar a flag `g`
A regex `starRegex` deve usar a flag `g`
```js
assert(starRegex.flags.match(/g/).length == 1);
```
Sua regex `starRegex` deve usar a flag de ignorar caixa, `i`
A regex `starRegex` deve usar a flag de ignorar caixa, `i`
```js
assert(starRegex.flags.match(/i/).length == 1);
```
Seu resultado deve conter ambas as ocorrências da palavra `Twinkle`
O resultado deve conter ambas as ocorrências da palavra `Twinkle`
```js
assert(
@ -60,7 +60,7 @@ assert(
);
```
Seu resultado, `result`, deve conter dois elementos.
O resultado, `result`, deve conter dois elementos.
```js
assert(result.length == 2);

14
curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/regular-expressions/find-one-or-more-criminals-in-a-hunt.md
View File

@ -36,19 +36,19 @@ Escreva uma regex gananciosa que encontra uma ou mais criminosos em um grupo de
# --hints--
Sua regex deve encontrar um criminoso (`C`) na string `C`
A regex deve encontrar um criminoso (`C`) na string `C`
```js
assert('C'.match(reCriminals) && 'C'.match(reCriminals)[0] == 'C');
```
Sua regex deve encontrar dois criminosos (`CC`) na string `CC`
A regex deve encontrar dois criminosos (`CC`) na string `CC`
```js
assert('CC'.match(reCriminals) && 'CC'.match(reCriminals)[0] == 'CC');
```
Sua regex deve encontrar três criminosos (`CCC`) na string `P1P5P4CCCcP2P6P3`.
A regex deve encontrar três criminosos (`CCC`) na string `P1P5P4CCCcP2P6P3`.
```js
assert(
@ -57,7 +57,7 @@ assert(
);
```
Sua regex deve encontrar cinco criminosos (`CCCCC`) na string `P6P2P7P4P5CCCCCP3P1`
A regex deve encontrar cinco criminosos (`CCCCC`) na string `P6P2P7P4P5CCCCCP3P1`
```js
assert(
@ -66,19 +66,19 @@ assert(
);
```
Sua regex não deve encontrar nenhum criminoso na string vazia `""`
A regex não deve encontrar nenhum criminoso na string vazia `""`
```js
assert(!reCriminals.test(''));
```
Sua regex não deve encontrar nenhum criminoso na string `P1P2P3`
A regex não deve encontrar nenhum criminoso na string `P1P2P3`
```js
assert(!reCriminals.test('P1P2P3'));
```
Sua regex deve encontrar cinquenta criminosos (`CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC`) na string `P2P1P5P4CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCP3`.
A regex deve encontrar cinquenta criminosos (`CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC`) na string `P2P1P5P4CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCP3`.
```js
assert(

22
curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/regular-expressions/ignore-case-while-matching.md
View File

@ -16,65 +16,65 @@ Você pode encontrar ambas as caixas usando algo que chamamos de <dfn>flag</dfn>
# --instructions--
Escreva uma regex `fccRegex` que encontre `freeCodeCamp`, não importa em que caixa esteja. Sua regex não deve buscar abreviações ou variações com espaços.
Escreva uma regex `fccRegex` que encontre `freeCodeCamp`, não importa em que caixa esteja. A regex não deve buscar abreviações ou variações com espaços.
# --hints--
Sua regex deve encontrar a string `freeCodeCamp`
A regex deve encontrar a string `freeCodeCamp`
```js
assert(fccRegex.test('freeCodeCamp'));
```
Sua regex deve encontrar a string `FreeCodeCamp`
A regex deve encontrar a string `FreeCodeCamp`
```js
assert(fccRegex.test('FreeCodeCamp'));
```
Sua regex deve encontrar a string `FreecodeCamp`
A regex deve encontrar a string `FreecodeCamp`
```js
assert(fccRegex.test('FreecodeCamp'));
```
Sua regex deve encontrar a string `FreeCodecamp`
A regex deve encontrar a string `FreeCodecamp`
```js
assert(fccRegex.test('FreeCodecamp'));
```
Sua regex não deve encontrar a string `Free Code Camp`
A regex não deve encontrar a string `Free Code Camp`
```js
assert(!fccRegex.test('Free Code Camp'));
```
Sua regex deve encontrar a string `FreeCOdeCamp`
A regex deve encontrar a string `FreeCOdeCamp`
```js
assert(fccRegex.test('FreeCOdeCamp'));
```
Sua regex não deve encontrar a string `FCC`
A regex não deve encontrar a string `FCC`
```js
assert(!fccRegex.test('FCC'));
```
Sua regex deve encontrar a string `FrEeCoDeCamp`
A regex deve encontrar a string `FrEeCoDeCamp`
```js
assert(fccRegex.test('FrEeCoDeCamp'));
```
Sua regex deve encontrar a string `FrEeCodECamp`
A regex deve encontrar a string `FrEeCodECamp`
```js
assert(fccRegex.test('FrEeCodECamp'));
```
Sua regex deve encontrar a string `FReeCodeCAmp`
A regex deve encontrar a string `FReeCodeCAmp`
```js
assert(fccRegex.test('FReeCodeCAmp'));

14
curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/regular-expressions/match-a-literal-string-with-different-possibilities.md
View File

@ -22,43 +22,43 @@ Complete a regex `petRegex` para encontrar os pets `dog`, `cat`, `bird`, ou `fis
# --hints--
Sua regex `petRegex` deve retornar `true` para a string `John has a pet dog.`
A regex `petRegex` deve retornar `true` para a string `John has a pet dog.`
```js
assert(petRegex.test('John has a pet dog.'));
```
Sua regex `petRegex` deve retornar `false` para a string `Emma has a pet rock.`
A regex `petRegex` deve retornar `false` para a string `Emma has a pet rock.`
```js
assert(!petRegex.test('Emma has a pet rock.'));
```
Sua regex `petRegex` deve retornar `true` para a string `Emma has a pet bird.`
A regex `petRegex` deve retornar `true` para a string `Emma has a pet bird.`
```js
assert(petRegex.test('Emma has a pet bird.'));
```
Sua regex `petRegex` deve retornar `true` para a string `Liz has a pet cat.`
A regex `petRegex` deve retornar `true` para a string `Liz has a pet cat.`
```js
assert(petRegex.test('Liz has a pet cat.'));
```
Sua regex `petRegex` deve retornar `false` para a string `Kara has a pet dolphin.`
A regex `petRegex` deve retornar `false` para a string `Kara has a pet dolphin.`
```js
assert(!petRegex.test('Kara has a pet dolphin.'));
```
Sua regex `petRegex` deve retornar `true` para a string `Alice has a pet fish.`
A regex `petRegex` deve retornar `true` para a string `Alice has a pet fish.`
```js
assert(petRegex.test('Alice has a pet fish.'));
```
Sua regex `petRegex` deve retornar `false` para a string `Jimmy has a pet computer.`
A regex `petRegex` deve retornar `false` para a string `Jimmy has a pet computer.`
```js
assert(!petRegex.test('Jimmy has a pet computer.'));

12
curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/regular-expressions/match-all-letters-and-numbers.md
View File

@ -33,19 +33,19 @@ Use o atalho `\w` para contar o número de caracteres alfanuméricos em várias
# --hints--
Sua regex deve usar a flag global.
A regex deve usar a flag global.
```js
assert(alphabetRegexV2.global);
```
Sua regex deve usar o atalho `\w` para capturar todos os caracteres alfanuméricos.
A regex deve usar o atalho `\w` para capturar todos os caracteres alfanuméricos.
```js
assert(/\\w/.test(alphabetRegexV2.source));
```
Sua regex deve encontrar 31 caracteres alfanuméricos na string `The five boxing wizards jump quickly.`
A regex deve encontrar 31 caracteres alfanuméricos na string `The five boxing wizards jump quickly.`
```js
assert(
@ -53,7 +53,7 @@ assert(
);
```
Sua regex deve encontrar 32 caracteres alfanuméricos na string `Pack my box with five dozen liquor jugs.`
A regex deve encontrar 32 caracteres alfanuméricos na string `Pack my box with five dozen liquor jugs.`
```js
assert(
@ -62,7 +62,7 @@ assert(
);
```
Sua regex deve encontrar 30 caracteres alfanuméricos na string `How vexingly quick daft zebras jump!`
A regex deve encontrar 30 caracteres alfanuméricos na string `How vexingly quick daft zebras jump!`
```js
assert(
@ -70,7 +70,7 @@ assert(
);
```
Sua regex deve encontrar 36 caracteres alfanuméricos na string `123 456 7890 ABC def GHI jkl MNO pqr STU vwx YZ.`
A regex deve encontrar 36 caracteres alfanuméricos na string `123 456 7890 ABC def GHI jkl MNO pqr STU vwx YZ.`
```js
assert(

22
curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/regular-expressions/match-all-non-numbers.md
View File

@ -8,59 +8,59 @@ dashedName: match-all-non-numbers
# --description--
O último desafio mostrou como procurar dígitos usando o atalho `\d` com um `d` minúsculo. Você também pode procurar não-dígitos usando um atalho semelhante que usa um `D` maiúsculo.
O último desafio mostrou como procurar dígitos usando o atalho `\d` com um `d` minúsculo. Você também pode procurar não dígitos usando um atalho semelhante que usa um `D` maiúsculo.
O atalho para procurar não-dígitos é `\D`. Esse atalho é o mesmo que `[^0-9]`, que serve para procurar qualquer caractere que não seja um dígito de zero a nove.
O atalho para procurar não dígitos é `\D`. Esse atalho é o mesmo que `[^0-9]`, que serve para procurar qualquer caractere que não seja um dígito de zero a nove.
# --instructions--
Use o atalho `\D` para contar quantos não-dígitos existem em títulos de filmes.
Use o atalho `\D` para contar quantos não dígitos existem em títulos de filmes.
# --hints--
Sua regex deve usar o atalho que captura não-dígitos
A regex deve usar o atalho que captura não-dígitos
```js
assert(/\\D/.test(noNumRegex.source));
```
Sua regex deve usar a flag global.
A regex deve usar a flag global.
```js
assert(noNumRegex.global);
```
Sua regex não deve encontrar nenhum não-dígito na string `9`.
A regex não deve encontrar nenhum não dígito na string `9`.
```js
assert('9'.match(noNumRegex) == null);
```
Sua regex deve encontrar seis não-dígitos na string `Catch 22`.
A regex deve encontrar seis não dígitos na string `Catch 22`.
```js
assert('Catch 22'.match(noNumRegex).length == 6);
```
Sua regex deve encontrar onze não-dígitos na string `101 Dalmatians`.
A regex deve encontrar onze não dígitos na string `101 Dalmatians`.
```js
assert('101 Dalmatians'.match(noNumRegex).length == 11);
```
Sua regex deve encontrar quinze não-dígitos na string `One, Two, Three`.
A regex deve encontrar quinze não dígitos na string `One, Two, Three`.
```js
assert('One, Two, Three'.match(noNumRegex).length == 15);
```
Sua regex deve encontrar 12 não-dígitos na string `21 Jump Street`.
A regex deve encontrar 12 não dígitos na string `21 Jump Street`.
```js
assert('21 Jump Street'.match(noNumRegex).length == 12);
```
Sua regex deve encontrar dezessete não-dígitos na string `2001: A Space Odyssey`.
A regex deve encontrar dezessete não dígitos na string `2001: A Space Odyssey`.
```js
assert('2001: A Space Odyssey'.match(noNumRegex).length == 17);

16
curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/regular-expressions/match-all-numbers.md
View File

@ -18,49 +18,49 @@ Use o atalho `\d` para contar quantos dígitos existem em títulos de filmes. N
# --hints--
Sua regex deve usar o atalho que captura dígitos
A regex deve usar o atalho que captura dígitos
```js
assert(/\\d/.test(numRegex.source));
```
Sua regex deve usar a flag global.
A regex deve usar a flag global.
```js
assert(numRegex.global);
```
Sua regex deve encontrar um dígito na string `9`.
A regex deve encontrar um dígito na string `9`.
```js
assert('9'.match(numRegex).length == 1);
```
Sua regex deve encontrar dois dígitos na string `Catch 22`.
A regex deve encontrar dois dígitos na string `Catch 22`.
```js
assert('Catch 22'.match(numRegex).length == 2);
```
Sua regex deve encontrar três dígitos na string `101 Dalmatians`.
A regex deve encontrar três dígitos na string `101 Dalmatians`.
```js
assert('101 Dalmatians'.match(numRegex).length == 3);
```
Sua regex não deve encontrar dígito algum na string `One, Two, Three`.
A regex não deve encontrar dígito algum na string `One, Two, Three`.
```js
assert('One, Two, Three'.match(numRegex) == null);
```
Sua regex deve encontrar dois dígitos na string `21 Jump Street`.
A regex deve encontrar dois dígitos na string `21 Jump Street`.
```js
assert('21 Jump Street'.match(numRegex).length == 2);
```
Sua regex deve encontrar quatro dígitos na string `2001: A Space Odyssey`.
A regex deve encontrar quatro dígitos na string `2001: A Space Odyssey`.
```js
assert('2001: A Space Odyssey'.match(numRegex).length == 4);

18
curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/regular-expressions/match-anything-with-wildcard-period.md
View File

@ -24,7 +24,7 @@ As duas chamadas a `test` retornam `true`.
# --instructions--
Complete a regex `unRegex` para que ela encontre as strings `run`, `sun`, `fun`, `pun`, `nun` e `bun`. Sua regex deve usar o caractere curinga.
Complete a regex `unRegex` para que ela encontre as strings `run`, `sun`, `fun`, `pun`, `nun` e `bun`. A regex deve usar o caractere curinga.
# --hints--
@ -40,42 +40,42 @@ Você deve usar o caractere curinga na regex `unRegex`
assert(/\./.test(unRegex.source));
```
Sua regex `unRegex` deve encontrar `run` na string `Let us go on a run.`
A regex `unRegex` deve encontrar `run` na string `Let us go on a run.`
```js
unRegex.lastIndex = 0;
assert(unRegex.test('Let us go on a run.'));
```
Sua regex `unRegex` deve encontrar `sun` na string `The sun is out today.`
A regex `unRegex` deve encontrar `sun` na string `The sun is out today.`
```js
unRegex.lastIndex = 0;
assert(unRegex.test('The sun is out today.'));
```
Sua regex `unRegex` deve encontrar `fun` na string `Coding is a lot of fun.`
A regex `unRegex` deve encontrar `fun` na string `Coding is a lot of fun.`
```js
unRegex.lastIndex = 0;
assert(unRegex.test('Coding is a lot of fun.'));
```
Sua regex `unRegex` deve encontrar `pun` na string `Seven days without a pun makes one weak.`
A regex `unRegex` deve encontrar `pun` na string `Seven days without a pun makes one weak.`
```js
unRegex.lastIndex = 0;
assert(unRegex.test('Seven days without a pun makes one weak.'));
```
Sua regex `unRegex` deve encontrar `nun` na string `One takes a vow to be a nun.`
A regex `unRegex` deve encontrar `nun` na string `One takes a vow to be a nun.`
```js
unRegex.lastIndex = 0;
assert(unRegex.test('One takes a vow to be a nun.'));
```
Sua regex `unRegex` deve encontrar `bun` na string `She got fired from the hot dog stand for putting her hair in a bun.`
A regex `unRegex` deve encontrar `bun` na string `She got fired from the hot dog stand for putting her hair in a bun.`
```js
unRegex.lastIndex = 0;
@ -86,14 +86,14 @@ assert(
);
```
Sua regex `unRegex` não deve incluir a string `There is a bug in my code.` no resultado
A regex `unRegex` não deve incluir a string `There is a bug in my code.` no resultado
```js
unRegex.lastIndex = 0;
assert(!unRegex.test('There is a bug in my code.'));
```
Sua regex `unRegex` não deve incluir a string `Catch me if you can.` no resultado
A regex `unRegex` não deve incluir a string `Catch me if you can.` no resultado
```js
unRegex.lastIndex = 0;

8
curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/regular-expressions/match-beginning-string-patterns.md
View File

@ -28,25 +28,25 @@ Use o circunflexo em uma regex para encontrar `Cal`, mas apenas no começo da st
# --hints--
Sua regex deve buscar a string `Cal` com uma maiúscula.
A regex deve buscar a string `Cal` com uma maiúscula.
```js
assert(calRegex.source == '^Cal');
```
Sua regex não deve usar nenhuma flag.
A regex não deve usar nenhuma flag.
```js
assert(calRegex.flags == '');
```
Sua regex deve capturar a string `Cal` no começo de uma string.
A regex deve capturar a string `Cal` no começo de uma string.
```js
assert(calRegex.test('Cal and Ricky both like racing.'));
```
Sua regex não deve capturar a string `Cal` no meio de uma string.
A regex não deve capturar a string `Cal` no meio de uma string.
```js
assert(!calRegex.test('Ricky and Cal both like racing.'));

6
curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/regular-expressions/match-characters-that-occur-one-or-more-times.md
View File

@ -18,17 +18,17 @@ Se a string fosse `abab`, a operação retornaria `["a", "a"]` porque entre os d
# --instructions--
Você quer capturar as ocorrências de `s` quando acontecer uma ou mais vezes em `Mississippi`. Escreve uma regex que use o caractere `+`.
Você quer capturar as ocorrências de `s` quando acontecer uma ou mais vezes em `Mississippi`. Escreva uma regex que use o caractere `+`.
# --hints--
Sua regex `myRegex` deve usar o caractere `+` para encontrar um ou mais `s`s.
A regex `myRegex` deve usar o caractere `+` para encontrar um ou mais `s`s.
```js
assert(/\+/.test(myRegex.source));
```
Sua regex `myRegex` deve encontrar 2 itens.
A regex `myRegex` deve encontrar 2 itens.
```js
assert(result.length == 2);

14
curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/regular-expressions/match-characters-that-occur-zero-or-more-times.md
View File

@ -26,35 +26,35 @@ As três chamadas a `match` retornam, na ordem, os valores: `["goooooooo"]`, `["
# --instructions--
Neste desafio, a string `chewieQuote` recebeu o valor `Aaaaaaaaaaaaaaaarrrgh!` por trás dos panos. Escreva uma regex, `chewieRegex`, que usa o caractere `*` para capturar um `A` maiúsculo seguido imediatamente de zero ou mais `a` minúsculos em `chewieQuote`. Sua regex não precisa de flags ou de classes de caracteres. Ela também não deve capturar nenhuma outra parte da string.
Neste desafio, a string `chewieQuote` recebeu o valor `Aaaaaaaaaaaaaaaarrrgh!` por trás dos panos. Escreva uma regex, `chewieRegex`, que usa o caractere `*` para capturar um `A` maiúsculo seguido imediatamente de zero ou mais `a` minúsculos em `chewieQuote`. A regex não precisa de flags ou de classes de caracteres. Ela também não deve capturar nenhuma outra parte da string.
# --hints--
Sua regex `chewieRegex` deve usar o caractere `*` para encontrar zero ou mais `a`s.
A regex `chewieRegex` deve usar o caractere `*` para encontrar zero ou mais `a`s.
```js
assert(/\*/.test(chewieRegex.source));
```
Sua regex deve encontrar a string `A` em `chewieQuote`.
A regex deve encontrar a string `A` em `chewieQuote`.
```js
assert(result[0][0] === 'A');
```
Sua regex deve encontrar a string `Aaaaaaaaaaaaaaaa` em `chewieQuote`.
A regex deve encontrar a string `Aaaaaaaaaaaaaaaa` em `chewieQuote`.
```js
assert(result[0] === 'Aaaaaaaaaaaaaaaa');
```
Sua regex `chewieRegex` deve capturar 16 caracteres em `chewieQuote`.
A regex `chewieRegex` deve capturar 16 caracteres em `chewieQuote`.
```js
assert(result[0].length === 16);
```
Sua expressão regular não deve corresponder com nenhum caractere na string `He made a fair move. Screaming about it can't help you.`
A expressão regular não deve corresponder com nenhum caractere na string `He made a fair move. Screaming about it can't help you.`
```js
assert(
@ -62,7 +62,7 @@ assert(
);
```
Sua expressão regular não deve corresponder a nenhum caractere na string `Let him have it. It's not wise to upset a Wookiee.`
A expressão regular não deve corresponder a nenhum caractere na string `Let him have it. It's not wise to upset a Wookiee.`
```js
assert(

2
curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/regular-expressions/match-ending-string-patterns.md
View File

@ -34,7 +34,7 @@ Você deve usar o cifrão `$` na sua regex para buscar a string `caboose`.
assert(lastRegex.source == 'caboose$');
```
Sua regex não deve usar nenhuma flag.
A regex não deve usar nenhuma flag.
```js
assert(lastRegex.flags == '');

16
curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/regular-expressions/match-everything-but-letters-and-numbers.md
View File

@ -10,7 +10,7 @@ dashedName: match-everything-but-letters-and-numbers
Você aprendeu que você pode usar um atalho para capturar alfanuméricos `[A-Za-z0-9_]` usando `\w`. Você pode querer capturar exatamente o oposto disso.
Você pode capturar não-alfanuméricos usando `\W` ao invés de `\w`. Observe que o atalho usa uma maiúscula. Este atalho é o mesmo que escrever `[^A-Za-z0-9_]`.
Você pode capturar não alfanuméricos usando `\W` ao invés de `\w`. Observe que o atalho usa uma maiúscula. Este atalho é o mesmo que escrever `[^A-Za-z0-9_]`.
```js
let shortHand = /\W/;
@ -24,17 +24,17 @@ A primeira chamada a `match` retorna `["%"]` enquanto o segundo retorna `["!"]`.
# --instructions--
Use o atalho `\W` para contar o número de caracteres não-alfanuméricos em várias strings.
Use o atalho `\W` para contar o número de caracteres não alfanuméricos em várias strings.
# --hints--
Sua regex deve usar a flag global.
A regex deve usar a flag global.
```js
assert(nonAlphabetRegex.global);
```
Sua regex deve encontrar 6 caracteres não-alfanuméricos na string `The five boxing wizards jump quickly.`.
A regex deve encontrar 6 caracteres não alfanuméricos na string `The five boxing wizards jump quickly.`.
```js
assert(
@ -42,13 +42,13 @@ assert(
);
```
Sua regex deve usar o atalho que captura os caracteres não-alfanuméricos.
A regex deve usar o atalho que captura os caracteres não alfanuméricos.
```js
assert(/\\W/.test(nonAlphabetRegex.source));
```
Sua regex deve encontrar 8 caracteres não-alfanuméricos na string `Pack my box with five dozen liquor jugs.`
A regex deve encontrar 8 caracteres não alfanuméricos na string `Pack my box with five dozen liquor jugs.`
```js
assert(
@ -56,7 +56,7 @@ assert(
);
```
Sua regex deve encontrar 6 caracteres não-alfanuméricos na string `How vexingly quick daft zebras jump!`
A regex deve encontrar 6 caracteres não alfanuméricos na string `How vexingly quick daft zebras jump!`
```js
assert(
@ -64,7 +64,7 @@ assert(
);
```
Sua regex deve encontrar 12 caracteres não-alfanuméricos na string `123 456 7890 ABC def GHI jkl MNO pqr STU vwx YZ.`
A regex deve encontrar 12 caracteres não alfanuméricos na string `123 456 7890 ABC def GHI jkl MNO pqr STU vwx YZ.`
```js
assert(

2
curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/regular-expressions/match-letters-of-the-alphabet.md
View File

@ -34,7 +34,7 @@ Capture todas as letras na string `quoteSample`.
# --hints--
Sua regex `alphabetRegex` deve encontrar 35 itens.
A regex `alphabetRegex` deve encontrar 35 itens.
```js
assert(result.length == 35);

4
curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/regular-expressions/match-literal-strings.md
View File

@ -35,13 +35,13 @@ Complete a regex `waldoRegex` para encontrar `"Waldo"` na string `waldoIsHiding`
# --hints--
Sua regex `waldoRegex` deve encontrar a string `Waldo`
A regex `waldoRegex` deve encontrar a string `Waldo`
```js
assert(waldoRegex.test(waldoIsHiding));
```
Sua regex `waldoRegex` não deve buscar nada além disso.
A regex `waldoRegex` não deve buscar nada além disso.
```js
assert(!waldoRegex.test('Somewhere is hiding in this text.'));

12
curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/regular-expressions/match-non-whitespace-characters.md
View File

@ -10,7 +10,7 @@ dashedName: match-non-whitespace-characters
Você aprendeu a procurar por espaço em branco usando `\s` com um `s` minúsculo. Você também pode buscar tudo exceto espaços em branco.
Busque não-espaços em branco usando `\S` com um `s` maiúsculo. Este atalho não captura espaços em branco, retorno de carro, tabulações, feeds de formulário ou quebras de linha. O atalho é equivalente à classe de caracteres `[^ \r\t\f\n\v]`.
Busque não espaços em branco usando `\S` com um `s` maiúsculo. Este atalho não captura espaços em branco, retorno de carro, tabulações, feeds de formulário ou quebras de linha. O atalho é equivalente à classe de caracteres `[^ \r\t\f\n\v]`.
```js
let whiteSpace = "Whitespace. Whitespace everywhere!"
@ -26,19 +26,19 @@ Modifique a regex `countNonWhiteSpace` para que encontre tudo exceto espaços em
# --hints--
Sua regex deve usar a flag global.
A regex deve usar a flag global.
```js
assert(countNonWhiteSpace.global);
```
Sua regex deve usar o atalho `\S` para capturar tudo menos espaços em branco.
A regex deve usar o atalho `\S` para capturar tudo menos espaços em branco.
```js
assert(/\\S/.test(countNonWhiteSpace.source));
```
Sua regex deve encontrar 35 não-espaços na string `Men are from Mars and women are from Venus.`
A regex deve encontrar 35 não espaços na string `Men are from Mars and women are from Venus.`
```js
assert(
@ -47,13 +47,13 @@ assert(
);
```
Sua regex deve encontrar 23 não-espaços na string `Space: the final frontier.`
A regex deve encontrar 23 não espaços na string `Space: the final frontier.`
```js
assert('Space: the final frontier.'.match(countNonWhiteSpace).length == 23);
```
Sua regex deve encontrar 21 não-espaços na string `MindYourPersonalSpace`
A regex deve encontrar 21 não espaços na string `MindYourPersonalSpace`
```js
assert('MindYourPersonalSpace'.match(countNonWhiteSpace).length == 21);

2
curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/regular-expressions/match-numbers-and-letters-of-the-alphabet.md
View File

@ -26,7 +26,7 @@ Escreva uma única regex que encontra letras entre `h` e `s` e, também, número
# --hints--
Sua regex `myRegex` deve encontrar 17 itens.
A regex `myRegex` deve encontrar 17 itens.
```js
assert(result.length == 17);

2
curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/regular-expressions/match-single-character-with-multiple-possibilities.md
View File

@ -60,7 +60,7 @@ Você deve usar a flag de ignorar caixa na sua regex `vowelRegex`.
assert(vowelRegex.flags.match(/i/).length == 1);
```
Sua regex não deve encontrar nenhuma consoante.
A regex não deve encontrar nenhuma consoante.
```js
assert(!/[b-df-hj-np-tv-z]/gi.test(result.join()));

6
curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/regular-expressions/match-single-characters-not-specified.md
View File

@ -20,19 +20,19 @@ Crie uma única regex que captura todos os caracteres que não são números ou
# --hints--
Sua regex `myRegex` deve encontrar 9 itens.
A regex `myRegex` deve encontrar 9 itens.
```js
assert(result.length == 9);
```
Você deve usar a flag global na sua regex `myRegex`.
Você deve usar a flag global na regex `myRegex`.
```js
assert(myRegex.flags.match(/g/).length == 1);
```
Você deve usar a flag de ignorar caixa na sua regex `myRegex`.
Você deve usar a flag de ignorar caixa na regex `myRegex`.
```js
assert(myRegex.flags.match(/i/).length == 1);

10
curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/regular-expressions/match-whitespace.md
View File

@ -25,19 +25,19 @@ Mude a regex `countWhiteSpace` para que capture múltiplos espaços em branco em
# --hints--
Sua regex deve usar a flag global.
A regex deve usar a flag global.
```js
assert(countWhiteSpace.global);
```
Sua regex deve usar o atalho `\s` para capturar todos os espaços em branco.
A regex deve usar o atalho `\s` para capturar todos os espaços em branco.
```js
assert(/\\s/.test(countWhiteSpace.source));
```
Sua regex deve encontrar oito espaços na string `Men are from Mars and women are from Venus.`
A regex deve encontrar oito espaços na string `Men are from Mars and women are from Venus.`
```js
assert(
@ -46,13 +46,13 @@ assert(
);
```
Sua regex deve encontrar três espaços na string `Space: the final frontier.`
A regex deve encontrar três espaços na string `Space: the final frontier.`
```js
assert('Space: the final frontier.'.match(countWhiteSpace).length == 3);
```
Sua regex não deve encontrar espaços na string `MindYourPersonalSpace`
A regex não deve encontrar espaços na string `MindYourPersonalSpace`
```js
assert('MindYourPersonalSpace'.match(countWhiteSpace) == null);

20
curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/regular-expressions/positive-and-negative-lookahead.md
View File

@ -29,7 +29,7 @@ noquit.match(qRegex);
As duas chamadas a `match` retornam `["q"]`.
Validar dois padrões diferentes em uma string é considerado um uso mais prático de lookaheads. Neste não-tão-aprimorado validador de senhas, os lookaheads procuram por 3 a 6 caracteres e pelo menos um número, respectivamente, na string:
Validar dois padrões diferentes em uma string é considerado um uso mais prático de lookaheads. Neste não tão aprimorado validador de senhas, os lookaheads procuram por 3 a 6 caracteres e pelo menos um número, respectivamente, na string:
```js
let password = "abc123";
@ -43,55 +43,55 @@ Faça com que `pwRegex` capture senhas que têm 5 ou mais caracteres e dois díg
# --hints--
Sua regex deve usar dois `lookaheads` positivos.
A regex deve usar dois `lookaheads` positivos.
```js
assert(pwRegex.source.match(/\(\?=.*?\)\(\?=.*?\)/) !== null);
```
Sua regex não deve encontrar a string `astronaut`
A regex não deve encontrar a string `astronaut`
```js
assert(!pwRegex.test('astronaut'));
```
Sua regex não deve encontrar a string `banan1`
A regex não deve encontrar a string `banan1`
```js
assert(!pwRegex.test('banan1'));
```
Sua regex deve encontrar a string `bana12`
A regex deve encontrar a string `bana12`
```js
assert(pwRegex.test('bana12'));
```
Sua regex deve encontrar a string `abc123`
A regex deve encontrar a string `abc123`
```js
assert(pwRegex.test('abc123'));
```
Sua regex não deve encontrar a string `12345`
A regex não deve encontrar a string `12345`
```js
assert(!pwRegex.test('12345'));
```
Sua regex deve encontrar a string `8pass99`
A regex deve encontrar a string `8pass99`
```js
assert(pwRegex.test('8pass99'));
```
Sua regex não deve encontrar a string `1a2bcde`
A regex não deve encontrar a string `1a2bcde`
```js
assert(!pwRegex.test('1a2bcde'));
```
Sua regex deve encontrar a string `astr1on11aut`
A regex deve encontrar a string `astr1on11aut`
```js
assert(pwRegex.test('astr1on11aut'));

26
curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/regular-expressions/restrict-possible-usernames.md
View File

@ -26,79 +26,79 @@ Modifique a regex `userCheck` para que inclua as regras listadas.
# --hints--
Sua regex deve encontrar a string `JACK`
A regex deve encontrar a string `JACK`
```js
assert(userCheck.test('JACK'));
```
Sua regex não deve encontrar a string `J`
A regex não deve encontrar a string `J`
```js
assert(!userCheck.test('J'));
```
Sua regex deve encontrar a string `Jo`
A regex deve encontrar a string `Jo`
```js
assert(userCheck.test('Jo'));
```
Sua regex deve encontrar a string `Oceans11`
A regex deve encontrar a string `Oceans11`
```js
assert(userCheck.test('Oceans11'));
```
Sua regex deve encontrar a string `RegexGuru`
A regex deve encontrar a string `RegexGuru`
```js
assert(userCheck.test('RegexGuru'));
```
Sua regex não deve encontrar a string `007`
A regex não deve encontrar a string `007`
```js
assert(!userCheck.test('007'));
```
Sua regex não deve encontrar a string `9`
A regex não deve encontrar a string `9`
```js
assert(!userCheck.test('9'));
```
Sua regex não deve encontrar a string `A1`
A regex não deve encontrar a string `A1`
```js
assert(!userCheck.test('A1'));
```
Sua regex não deve encontrar a string `BadUs3rnam3`
A regex não deve encontrar a string `BadUs3rnam3`
```js
assert(!userCheck.test('BadUs3rnam3'));
```
Sua regex deve encontrar a string `Z97`
A regex deve encontrar a string `Z97`
```js
assert(userCheck.test('Z97'));
```
Sua regex não deve encontrar a string `c57bT3`
A regex não deve encontrar a string `c57bT3`
```js
assert(!userCheck.test('c57bT3'));
```
Sua regex deve encontrar a string `AB1`
A regex deve encontrar a string `AB1`
```js
assert(userCheck.test('AB1'));
```
Sua regex não deve encontrar a string `J%4`
A regex não deve encontrar a string `J%4`
```js
assert(!userCheck.test('J%4'))

18
curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/regular-expressions/reuse-patterns-using-capture-groups.md
View File

@ -37,55 +37,55 @@ Use grupos de captura na regex `reRegex` para capturar em uma string um número
# --hints--
Sua regex deve usar o atalho de classe de caracteres para dígitos.
A regex deve usar o atalho de classe de caracteres para dígitos.
```js
assert(reRegex.source.match(/\\d/));
```
Sua regex deve reusar um grupo de captura duas vezes.
A regex deve reusar um grupo de captura duas vezes.
```js
assert(reRegex.source.match(/\\1|\\2/g).length >= 2);
```
Sua regex deve encontrar a string `42 42 42`.
A regex deve encontrar a string `42 42 42`.
```js
assert(reRegex.test('42 42 42'));
```
Sua regex deve encontrar a string `100 100 100`.
A regex deve encontrar a string `100 100 100`.
```js
assert(reRegex.test('100 100 100'));
```
Sua regex não deve encontrar a string `42 42 42 42`.
A regex não deve encontrar a string `42 42 42 42`.
```js
assert.equal('42 42 42 42'.match(reRegex.source), null);
```
Sua regex não deve encontrar a string `42 42`.
A regex não deve encontrar a string `42 42`.
```js
assert.equal('42 42'.match(reRegex.source), null);
```
Sua regex não deve encontrar a string `101 102 103`.
A regex não deve encontrar a string `101 102 103`.
```js
assert(!reRegex.test('101 102 103'));
```
Sua regex não deve encontrar a string `1 2 3`.
A regex não deve encontrar a string `1 2 3`.
```js
assert(!reRegex.test('1 2 3'));
```
Sua regex deve encontrar a string `10 10 10`.
A regex deve encontrar a string `10 10 10`.
```js
assert(reRegex.test('10 10 10'));

12
curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/regular-expressions/specify-exact-number-of-matches.md
View File

@ -32,41 +32,41 @@ Modifique a regex `timRegex` para que capture quatro `m`s na string `Timber`.
# --hints--
Sua regex deve conter chaves.
A regex deve conter chaves.
```js
assert(timRegex.source.match(/{.*?}/).length > 0);
```
Sua regex não deve encontrar a string `Timber`
A regex não deve encontrar a string `Timber`
```js
timRegex.lastIndex = 0;
assert(!timRegex.test('Timber'));
```
Sua regex não deve encontrar a string `Timmber`
A regex não deve encontrar a string `Timmber`
```js
timRegex.lastIndex = 0;
assert(!timRegex.test('Timmber'));
```
Sua regex não deve encontrar a string `Timmmber`
A regex não deve encontrar a string `Timmmber`
```js
timRegex.lastIndex = 0;
assert(!timRegex.test('Timmmber'));
```
Sua regex deve encontrar a string `Timmmmber`
A regex deve encontrar a string `Timmmmber`
```js
timRegex.lastIndex = 0;
assert(timRegex.test('Timmmmber'));
```
Sua regex não deve encontrar a string `Timber` se nela houver 30 `m`s.
A regex não deve encontrar a string `Timber` se nela houver 30 `m`s.
```js
timRegex.lastIndex = 0;

14
curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/regular-expressions/specify-only-the-lower-number-of-matches.md
View File

@ -32,43 +32,43 @@ Modifique a regex `haRegex` para que capture quatro ou mais `z`s na string `Hazz
# --hints--
Sua regex deve usar chaves.
A regex deve usar chaves.
```js
assert(haRegex.source.match(/{.*?}/).length > 0);
```
Sua regex não deve encontrar a string `Hazzah`
A regex não deve encontrar a string `Hazzah`
```js
assert(!haRegex.test('Hazzah'));
```
Sua regex não deve encontrar a string `Hazzzah`
A regex não deve encontrar a string `Hazzzah`
```js
assert(!haRegex.test('Hazzzah'));
```
Sua regex deve encontrar a string `Hazzzzah`
A regex deve encontrar a string `Hazzzzah`
```js
assert('Hazzzzah'.match(haRegex)[0].length === 8);
```
Sua regex deve encontrar a string `Hazzzzzah`
A regex deve encontrar a string `Hazzzzzah`
```js
assert('Hazzzzzah'.match(haRegex)[0].length === 9);
```
Sua regex deve encontrar a string `Hazzzzzzah`
A regex deve encontrar a string `Hazzzzzzah`
```js
assert('Hazzzzzzah'.match(haRegex)[0].length === 10);
```
Sua regex deve capturar 30 `z`s, se presentes, na string `Hazzah`.
A regex deve capturar 30 `z`s, se presentes, na string `Hazzah`.
```js
assert('Hazzzzzzzzzzzzzzzzzzzzzzzzzzzzzzah'.match(haRegex)[0].length === 34);

16
curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/regular-expressions/specify-upper-and-lower-number-of-matches.md
View File

@ -8,7 +8,7 @@ dashedName: specify-upper-and-lower-number-of-matches
# --description--
Lembre-se que você pode usar o sinal de `+` para procurar por uma ou mais ocorrências e o asterisco `*` para procurar por zero ou mais ocorrências. Eles são convenientes, mas às vezes você precisa capturar um número exato de caracteres.
Lembre-se de que você pode usar o sinal de `+` para procurar por uma ou mais ocorrências e o asterisco `*` para procurar por zero ou mais ocorrências. Eles são convenientes, mas às vezes você precisa capturar um número exato de caracteres.
Você pode especificar um número mínimo e um máximo de capturas com <dfn>especificadores de quantidade</dfn>. Para usar especificadores de quantidade, usa-se chaves: `{` e `}`. Você pode especificar os dois números dentro delas para restringir as capturas.
@ -30,43 +30,43 @@ Altere a regex `ohRegex` para que capture a frase `Oh no`, mas apenas quando nel
# --hints--
Sua regex deve usar chaves.
A regex deve usar chaves.
```js
assert(ohRegex.source.match(/{.*?}/).length > 0);
```
Sua regex não deve encontrar a string `Ohh no`
A regex não deve encontrar a string `Ohh no`
```js
assert(!ohRegex.test('Ohh no'));
```
Sua regex deve encontrar a string `Ohhh no`
A regex deve encontrar a string `Ohhh no`
```js
assert('Ohhh no'.match(ohRegex)[0].length === 7);
```
Sua regex deve encontrar a string `Ohhhh no`
A regex deve encontrar a string `Ohhhh no`
```js
assert('Ohhhh no'.match(ohRegex)[0].length === 8);
```
Sua regex deve encontrar a string `Ohhhhh no`
A regex deve encontrar a string `Ohhhhh no`
```js
assert('Ohhhhh no'.match(ohRegex)[0].length === 9);
```
Sua regex deve encontrar a string `Ohhhhhh no`
A regex deve encontrar a string `Ohhhhhh no`
```js
assert('Ohhhhhh no'.match(ohRegex)[0].length === 10);
```
Sua regex não deve encontrar a string `Ohhhhhhh no`
A regex não deve encontrar a string `Ohhhhhhh no`
```js
assert(!ohRegex.test('Ohhhhhhh no'));

2
curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/regular-expressions/use-capture-groups-to-search-and-replace.md
View File

@ -40,7 +40,7 @@ Você deve usar `.replace()` para buscar e substituir.
assert(code.match(/\.replace\(.*\)/));
```
Sua regex deve mudar a string `one two three` para `three two one`
A regex deve mudar a string `one two three` para `three two one`
```js
assert(result === 'three two one');