fix(guide): simplify directory structure

guide/portuguese/certifications/javascript-algorithms-and-data-structures/regular-expressions/check-for-all-or-none/index.md

@@ -0,0 +1,9 @@
+---
+title: Check for All or None
+localeTitle: Verificar tudo ou nada
+---
+## Verificar tudo ou nada
+
+Este é um esboço. [Ajude nossa comunidade a expandi-lo](https://github.com/freecodecamp/guides/tree/master/src/pages/certifications/javascript-algorithms-and-data-structures/regular-expressions/check-for-all-or-none/index.md) .
+
+[Este guia de estilo rápido ajudará a garantir que sua solicitação de recebimento seja aceita](https://github.com/freecodecamp/guides/blob/master/README.md) .

guide/portuguese/certifications/javascript-algorithms-and-data-structures/regular-expressions/extract-matches/index.md

@@ -0,0 +1,26 @@
+---
+title: Extract Matches
+localeTitle: Extrair correspondências
+---
+## Extrair correspondências
+
+Usando o método `match()` , você pode extrair partes de uma string que corresponda à sua expressão regular. Neste desafio, você está extraindo a palavra "codificação" da string fornecida.
+
+## Sugestão 1:
+
+Altere seu regex para detectar a palavra "codificação".
+
+## Dica 2:
+
+Você chamou o método `match()` na string?
+
+## Alerta de Spoiler - Solução à frente!
+
+## Solução:
+
+```javascript
+let extractStr = "Extract the word 'coding' from this string."; 
+ let codingRegex = /coding/; 
+ let result = extractStr.match(codingRegex); 
+
+```

guide/portuguese/certifications/javascript-algorithms-and-data-structures/regular-expressions/find-characters-with-lazy-matching/index.md

@@ -0,0 +1,18 @@
+---
+title: Find Characters with Lazy Matching
+localeTitle: Encontrar personagens com correspondência preguiçosa
+---
+## Encontrar personagens com correspondência preguiçosa
+
+#### Desafio:
+
+Corrija o regex `/<.*>/` para retornar a tag HTML `<h1>` e não o texto `<h1>Winter is coming</h1>` . Lembre-se do curinga. em uma expressão regular corresponde a qualquer caractere.
+
+#### Solução:
+
+```js
+let text = "<h1>Winter is coming</h1>"; 
+ let myRegex = /<h1>?/; // it's the answer! 
+ let result = text.match(myRegex); 
+
+```

guide/portuguese/certifications/javascript-algorithms-and-data-structures/regular-expressions/find-more-than-the-first-match/index.md

@@ -0,0 +1,26 @@
+---
+title: Find More Than the First Match
+localeTitle: Encontre mais do que o primeiro jogo
+---
+## Encontre mais do que o primeiro jogo
+
+Se você tiver várias ocorrências de sua regex dentro de uma string, você pode obter a função `match()` para detectar todas elas. Simplesmente marque a bandeira `g` no final do seu regex! Isso é o que você está fazendo neste desafio.
+
+## Sugestão 1:
+
+Altere o regex para que ele detecte a palavra "twinkle".
+
+## Dica 2:
+
+Você pode adicionar várias tags a uma regex! Por exemplo, um regex que detecta várias ocorrências e detecta, independentemente do caso, pode ser estruturado como `gi` ou `ig` .
+
+## Alerta de Spoiler - Solução à frente!
+
+## Solução
+
+```javascript
+let twinkleStar = "Twinkle, twinkle, little star"; 
+ let starRegex = /twinkle/gi; 
+ let result = twinkleStar.match(starRegex); 
+
+```

guide/portuguese/certifications/javascript-algorithms-and-data-structures/regular-expressions/find-one-or-more-criminals-in-a-hunt/index.md

@@ -0,0 +1,41 @@
+---
+title: Find One or More Criminals in a Hunt
+localeTitle: Encontre um ou mais criminosos em uma caçada
+---
+## Encontre um ou mais criminosos em uma caçada
+
+## O problema
+
+Um grupo de criminosos escapou da prisão e fugiu, mas você não sabe quantos. No entanto, você sabe que eles ficam juntos quando estão perto de outras pessoas. Você é responsável por encontrar todos os criminosos de uma só vez.
+
+Escreva um regex ganancioso que encontre um ou mais criminosos dentro de um grupo de outras pessoas. Um criminoso é representado pela letra maiúscula C.
+
+### Sugestão 1:
+
+Você está cercando seu regexp em barras?
+
+```javascript
+let regexp = /t.[az]*t/; 
+```
+
+### Dica 2:
+
+Você está usando a sinalização "+" no seu regexp?
+
+```javascript
+let regexp = /E+/; // returns E, EE, EEE patterns 
+```
+
+### Aviso de spoiler - Solução à frente
+
+## Solução
+
+```javascript
+let crowd = 'P1P2P3P4P5P6CCCP7P8P9'; 
+ 
+ let reCriminals = /C+/; // Change this line 
+ 
+ let matchedCriminals = crowd.match(reCriminals); 
+ console.log(matchedCriminals); 
+
+```

guide/portuguese/certifications/javascript-algorithms-and-data-structures/regular-expressions/ignore-case-while-matching/index.md

@@ -0,0 +1,22 @@
+---
+title: Ignore Case While Matching
+localeTitle: Ignorar maiúsculas e minúsculas durante a correspondência
+---
+## Ignorar maiúsculas e minúsculas durante a correspondência
+
+Ao criar uma expressão regular, você pode querer corresponder partes da string que são iguais em ortografia, mas diferentes no caso. Para fazer isso, você adiciona o sinalizador `i` ao final da regex. Neste desafio, você está fazendo exatamente isso.
+
+## Sugestão 1:
+
+Modifique o regex para que ele detecte "freeCodeCamp", "FREECODECAMP" e "FrEeCoDeCaMp". Talvez usando o `i` bandeira pode ajudar?
+
+## Alerta de Spoiler - Solução à frente!
+
+## Solução
+
+```javascript
+let myString = "freeCodeCamp"; 
+ let fccRegex = /freeCodeCamp/i; 
+ let result = fccRegex.test(myString); 
+
+```

guide/portuguese/certifications/javascript-algorithms-and-data-structures/regular-expressions/index.md

@@ -0,0 +1,11 @@
+---
+title: Regular Expressions
+localeTitle: Expressões regulares
+---
+## Expressões regulares
+
+Este é um esboço. [Ajude nossa comunidade a expandi-lo](https://github.com/freecodecamp/guides/tree/master/src/pages/mathematics/quadratic-equations/index.md) .
+
+[Este guia de estilo rápido ajudará a garantir que sua solicitação de recebimento seja aceita](https://github.com/freecodecamp/guides/blob/master/README.md) .
+
+#### Mais Informações:

guide/portuguese/certifications/javascript-algorithms-and-data-structures/regular-expressions/match-a-literal-string-with-different-possibilities/index.md

@@ -0,0 +1,22 @@
+---
+title: Match a Literal String with Different Possibilities
+localeTitle: Combine uma seqüência literal com diferentes possibilidades
+---
+## Combine uma seqüência literal com diferentes possibilidades
+
+Suponha que você queira combinar muitas palavras diferentes com sua expressão regular; usando o `|` símbolo, isso se torna possível. Neste desafio, você está usando esse símbolo para identificar quatro animais de estimação diferentes escondidos dentro de cordas!
+
+## Sugestão 1:
+
+Dentro da string literal, coloque os nomes dos animais de estimação, cada um separado pelo `|` símbolo.
+
+## Alerta de Spoiler - Solução à frente!
+
+## Solução:
+
+```javascriot
+let petString = "James has a pet cat."; 
+ let petRegex = /dog|cat|bird|fish/; 
+ let result = petRegex.test(petString); 
+
+```

guide/portuguese/certifications/javascript-algorithms-and-data-structures/regular-expressions/match-all-letters-and-numbers/index.md

@@ -0,0 +1,13 @@
+---
+title: Match All Letters and Numbers
+localeTitle: Corresponder todas as letras e números
+---
+O problema Use a classe de caractere abreviada \\ w para contar o número de caracteres alfanuméricos em várias aspas e cadeias de caracteres.
+
+Solução vamos quoteSample = "Os cinco magos do boxe saltam rapidamente."; let alphabetRegexV2 = / \\ w / gi; // Alterar esta linha deixe resultado = quoteSample.match (alphabetRegexV2) .length;
+
+## Corresponder todas as letras e números
+
+Este é um esboço. [Ajude nossa comunidade a expandi-lo](https://github.com/freecodecamp/guides/tree/master/src/pages/certifications/javascript-algorithms-and-data-structures/regular-expressions/match-all-letters-and-numbers/index.md) .
+
+[Este guia de estilo rápido ajudará a garantir que sua solicitação de recebimento seja aceita](https://github.com/freecodecamp/guides/blob/master/README.md) .

guide/portuguese/certifications/javascript-algorithms-and-data-structures/regular-expressions/match-all-non-numbers/index.md

@@ -0,0 +1,25 @@
+---
+title: Match All Non-Numbers
+localeTitle: Corresponder a todos os não-números
+---
+## Corresponder a todos os não-números
+
+## Sugestão 1
+
+*   Você deve tentar usar um sinalizador global.
+
+## Sugestão 2
+
+*   Tente um caractere abreviado para caracteres não-dígitos.
+
+# Alerta de Spoiler !! Solução à frente!
+
+## Solução
+
+```javascript
+let noNumRegex = /\D/g; 
+```
+
+## Explicação
+
+*   O caractere abreviado `\D` é usado para corresponder caracteres não-dígitos, tem o mesmo resultado que usar `[^0-9]` ;

guide/portuguese/certifications/javascript-algorithms-and-data-structures/regular-expressions/match-all-numbers/index.md

@@ -0,0 +1,25 @@
+---
+title: Match All Numbers
+localeTitle: Corresponder todos os números
+---
+## Corresponder todos os números
+
+## Sugestão 1
+
+*   Uma bandeira global ajudará você a superar esse desafio.
+
+## Sugestão 2
+
+*   Tente usar um personagem abreviação para `d` igits.
+
+# Alerta de Spoiler !! Solução à frente!
+
+## Solução
+
+```javascript
+let numRegex = /\d/g; 
+```
+
+## Explicação
+
+*   O caractere de abreviação `\d` é um atalho para `[0-9]` , ele procura por qualquer número entre 0 e 9.

guide/portuguese/certifications/javascript-algorithms-and-data-structures/regular-expressions/match-anything-with-wildcard-period/index.md

@@ -0,0 +1,25 @@
+---
+title: Match Anything with Wildcard Period
+localeTitle: Combinar qualquer coisa com o período curinga
+---
+## Combinar qualquer coisa com o período curinga
+
+## Sugestão 1:
+
+O ponto `.` é a chave neste desafio.
+
+## Dica 2:
+
+Você deve colocar o ponto na posição correta.
+
+## Solução
+
+```javascript
+let exampleStr = "Let's have fun with regular expressions!"; 
+ let unRegex = /.un/; // Change this line 
+ let result = unRegex.test(exampleStr); 
+```
+
+## Explicação
+
+O período `.` será qualquer caractere, então as strings "run", "sun", "fun" e "pun" terão os mesmos charaters.

guide/portuguese/certifications/javascript-algorithms-and-data-structures/regular-expressions/match-beginning-string-patterns/index.md

@@ -0,0 +1,33 @@
+---
+title: Match Beginning String Patterns
+localeTitle: Combinar Padrões de Cordas Iniciais
+---
+## Combinar Padrões de Cordas Iniciais
+
+## O problema
+
+Use o caractere de circunflexo em um regex para localizar "Cal" apenas no início da string rickyAndCal.
+
+### Sugestão 1:
+
+Tente cercar seu regexp em barras
+
+```javascript
+let testExp = /^test/; 
+ // returns true or false depending on whether test is found in the beginning of the string 
+```
+
+### Dica 2:
+
+Tente usar o cursor do caractere '^' fora dos colchetes, como visto no exemplo acima
+
+### Alerta de spoiler - Solução à frente
+
+## Solução
+
+```javascript
+let rickyAndCal = "Cal and Ricky both like racing."; 
+ let calRegex = /^Cal/; // Change this line 
+ let result = calRegex.test(rickyAndCal); 
+
+```

guide/portuguese/certifications/javascript-algorithms-and-data-structures/regular-expressions/match-characters-that-occur-one-or-more-times/index.md

@@ -0,0 +1,9 @@
+---
+title: Match Characters that Occur One or More Times
+localeTitle: Corresponder caracteres que ocorrem uma ou mais vezes
+---
+## Corresponder caracteres que ocorrem uma ou mais vezes
+
+\## o problema: Você quer encontrar correspondências quando a letra s ocorre uma ou mais vezes em "Mississippi". Escreva um regex que use o sinal +. ## a solução
+
+deixe difícilSpelling = "Mississippi"; deixe myRegex = / s + / g; // esta é a solução deixe resultar = difícilSpelling.match (myRegex);

guide/portuguese/certifications/javascript-algorithms-and-data-structures/regular-expressions/match-characters-that-occur-zero-or-more-times/index.md

@@ -0,0 +1,30 @@
+---
+title: Match Characters that Occur Zero or More Times
+localeTitle: Corresponder caracteres que ocorrem zero ou mais vezes
+---
+## Corresponder caracteres que ocorrem zero ou mais vezes
+
+Qualquer letra em uma expressão regex que é seguida por um `*` não precisa ocorrer na string testada, enquanto qualquer letra em uma expressão regex seguida por `+` deve ocorrer em uma string pelo menos uma vez, como mostrado abaixo,
+
+```javascript
+let phrase = "ba humbug"; 
+ 
+ let regexPlus = /bah+/; 
+ let regexStar = /bah*/; 
+ 
+ regexPlus.test(phrase);  // returns false 
+ regexStar.test(phrase);  // returns true 
+```
+
+Ambos permitem qualquer número de ocorrências da mesma letra em uma linha, por exemplo,
+
+```javascript
+let phrase = "wooooow look at that!"; 
+ 
+ let regexPlus = /wo+w/; 
+ let regexStar = /wo*w/; 
+ 
+ regexPlus.test(phrase); // returns true 
+ regexStar.test(phrase); // returns true 
+
+```

guide/portuguese/certifications/javascript-algorithms-and-data-structures/regular-expressions/match-ending-string-patterns/index.md

@@ -0,0 +1,9 @@
+---
+title: Match Ending String Patterns
+localeTitle: Padrões de Sequência de Correspondência Final
+---
+## Padrões de Sequência de Correspondência Final
+
+Este é um esboço. [Ajude nossa comunidade a expandi-lo](https://github.com/freecodecamp/guides/tree/master/src/pages/certifications/javascript-algorithms-and-data-structures/regular-expressions/match-ending-string-patterns/index.md) .
+
+[Este guia de estilo rápido ajudará a garantir que sua solicitação de recebimento seja aceita](https://github.com/freecodecamp/guides/blob/master/README.md) .

guide/portuguese/certifications/javascript-algorithms-and-data-structures/regular-expressions/match-everything-but-letters-and-numbers/index.md

@@ -0,0 +1,9 @@
+---
+title: Match Everything But Letters and Numbers
+localeTitle: Combine tudo, mas letras e números
+---
+## Combine tudo, mas letras e números
+
+Este é um esboço. [Ajude nossa comunidade a expandi-lo](https://github.com/freecodecamp/guides/tree/master/src/pages/certifications/javascript-algorithms-and-data-structures/regular-expressions/match-everything-but-letters-and-numbers/index.md) .
+
+[Este guia de estilo rápido ajudará a garantir que sua solicitação de recebimento seja aceita](https://github.com/freecodecamp/guides/blob/master/README.md) .

guide/portuguese/certifications/javascript-algorithms-and-data-structures/regular-expressions/match-letters-of-the-alphabet/index.md

@@ -0,0 +1,26 @@
+---
+title: Match Letters of the Alphabet
+localeTitle: Correspondência de letras do alfabeto
+---
+## Correspondência de letras do alfabeto
+
+Nesse desafio, você é solicitado a combinar todas as letras do alfabeto em uma determinada string. Você não apenas está combinando / pesquisando esses caracteres, mas também é solicitado a extraí-los.
+
+### Sugestão 1:
+
+Lembre-se de que você é solicitado a extrair as letras da string - isso não pode ser feito com o método .test () porque retorna True ou False. Nesse caso, precisamos extrair o resultado real da string usando o método .match ().
+
+### Dica 2:
+
+Você está usando o sinalizador de caso de caractere do método match () com colchetes? Por exemplo, regExp = / \[ae\] / vs regExp = / ae /. O que isso nos permite fazer é procurar na string por qualquer caractere correspondente a \[a, b, c,… e\] usando a notação abreviada / \[ae\] /.
+
+### Alerta de spoiler: Solução à frente
+
+## Solução
+
+```javascript
+let quoteSample = "The quick brown fox jumps over the lazy dog."; 
+ let alphabetRegex = /[az]/ig; // Change this line 
+ let result = quoteSample.match(alphabetRegex); // Change this line 
+
+```

guide/portuguese/certifications/javascript-algorithms-and-data-structures/regular-expressions/match-literal-strings/index.md

@@ -0,0 +1,24 @@
+---
+title: Match Literal Strings
+localeTitle: Combinar cordas literais
+---
+## Combinar cordas literais
+
+Este desafio não é diferente do anterior; Nesse caso, você está aprendendo que literais de string são sensíveis a maiúsculas e minúsculas. Isso significa que, quando você testar para ver se uma string tem um literal, ele procurará o caso exato (inferior ou superior) dentro da string. Você aprenderá como encontrar literais de string, independentemente do caso, em uma lição futura.
+
+Neste desafio, você está encontrando Waldo ... dentro de uma corda!
+
+## Sugestão 1:
+
+Altere a linha para ter o literal da string correto.
+
+## Alerta de Spoiler - Solução à frente!
+
+## Solução:
+
+```javascript
+let waldoIsHiding = "Somewhere Waldo is hiding in this text."; 
+ let waldoRegex = /Waldo/; // Change this line 
+ let result = waldoRegex.test(waldoIsHiding); 
+
+```

guide/portuguese/certifications/javascript-algorithms-and-data-structures/regular-expressions/match-non-whitespace-characters/index.md

@@ -0,0 +1,9 @@
+---
+title: Match Non-Whitespace Characters
+localeTitle: Corresponder Personagens Não-Brancos
+---
+## Corresponder Personagens Não-Brancos
+
+Este é um esboço. [Ajude nossa comunidade a expandi-lo](https://github.com/freecodecamp/guides/tree/master/src/pages/certifications/javascript-algorithms-and-data-structures/regular-expressions/match-non-whitespace-characters/index.md) .
+
+[Este guia de estilo rápido ajudará a garantir que sua solicitação de recebimento seja aceita](https://github.com/freecodecamp/guides/blob/master/README.md) .

guide/portuguese/certifications/javascript-algorithms-and-data-structures/regular-expressions/match-numbers-and-letters-of-the-alphabet/index.md

@@ -0,0 +1,40 @@
+---
+title: Match Numbers and Letters of the Alphabet
+localeTitle: Corresponder números e letras do alfabeto
+---
+## Corresponder números e letras do alfabeto
+
+Neste desafio, você é solicitado a retornar uma coleção de números e letras extraídos de uma string. Nosso objetivo é criar um regexp único que capture o intervalo de letras entre he s e os números de 2 a 6.
+
+### Sugestão 1:
+
+Você está usando o método match ()? Se sim, então você está chamando o método da variável apropriada? ou seja
+
+```javascript
+  let input_string = "The string you are testing on" 
+  let yourRegExp = /[hs]/; 
+  let correct_result = input_string.match(yourRegExp); // passes - returns characters H to S 
+ 
+  let incorrect_result = yourRegExp.match(input_string); // fails - .match() is not a function 
+```
+
+### Dica 2:
+
+Você se lembrou de ativar os sinalizadores regexp como "i" para ignorar maiúsculas e minúsculas e "g" para recuperar vários valores? Se sim, então você está incluindo tanto a correspondência de maiúsculas e minúsculas para números e letras?
+
+```javascript
+let regexp = /[a-z1-100]/ig 
+ // above code returns all characters from A to Z, along with all numbers from 1 to 100 
+ // this includes the letter A and Z and the numbers 1 and 100 
+```
+
+### Alerta de spoiler - Solução à frente
+
+## Solução
+
+```javascript
+let quoteSample = "Blueberry 3.141592653s are delicious."; 
+ let myRegex = /[h-s2-6]/ig; // Change this line 
+ let result = quoteSample.match(myRegex); // Change this line 
+
+```

guide/portuguese/certifications/javascript-algorithms-and-data-structures/regular-expressions/match-single-character-with-multiple-possibilities/index.md

@@ -0,0 +1,28 @@
+---
+title: Match Single Character with Multiple Possibilities
+localeTitle: Corresponder personagem único com várias possibilidades
+---
+## Corresponder personagem único com várias possibilidades
+
+### Extrair
+
+Usando o método match (), você pode extrair partes de uma string que corresponda à sua expressão regular. Neste desafio, você está extraindo as vogais "a, e, i, o, u" de uma string fornecida.
+
+### Sugestão 1:
+
+Você está tentando usar o método test ()? Lembre-se que este método só retorna True ou False - precisamos extrair as vogais da string.
+
+### Dica 2:
+
+Você já tentou usar a correspondência de caso de caractere '\[\]' sem vírgulas? ou seja, \[abcd\] vs \[a, b, c, d\]
+
+### Alerta de Spoiler - Solução à frente!
+
+## Solução
+
+```javascript
+let quoteSample = "Beware of bugs in the above code; I have only proved it correct, not tried it."; 
+ let vowelRegex = /[aeiou]/ig; // Change this line 
+ let result = quoteSample.match(vowelRegex); // Change this line 
+
+```

guide/portuguese/certifications/javascript-algorithms-and-data-structures/regular-expressions/match-single-characters-not-specified/index.md

@@ -0,0 +1,40 @@
+---
+title: Match Single Characters Not Specified
+localeTitle: Combinar Caracteres Únicos Não Especificados
+---
+## Combinar Caracteres Únicos Não Especificados
+
+Neste desafio, somos solicitados a retornar uma coleção de correspondências que não são exatamente especificadas. Enquanto os desafios anteriores de regexp teriam que combinar com o caractere de caractere \[az\], este desafio nos pede para negar essas correspondências usando o caractere de circunflexo \[^ az\]. Nosso objetivo então é retornar uma coleção negada (não-correspondência) de letras que não são vogais nem números.
+
+## Sugestão 1:
+
+Você se lembrou de cercar seu regexp em ambos os suportes e barras?
+
+```javascript
+let exampleRegExp = /[^az]/; 
+```
+
+Em caso afirmativo, verifique se você está adicionando os sinalizadores apropriados:
+
+*   i: Ignora letras maiúsculas e minúsculas da pesquisa / correspondência
+*   g: recupera vários valores; o padrão é definido para retornar a primeira correspondência encontrada
+*   ^: Nega os jogos seguindo este sinalizador
+
+### Dica 2:
+
+Certifique-se de verificar se o seu intervalo de numeração está correto - o desafio nos pede para negar todos os números de 0 a 99. Isso pode ser feito usando o cursor negado colocado imediatamente após o primeiro parêntese de abertura do seu regexp.
+
+```javacsript
+let numbersRegExp = /[^0-99]/ig; 
+```
+
+### Alerta de spoiler - Solução à frente
+
+## Solução
+
+```javascript
+let quoteSample = "3 blind mice."; 
+ let myRegex = /[^aeiou^0-99]/ig; // Change this line 
+ let result = quoteSample.match(myRegex); // Change this line 
+
+```

guide/portuguese/certifications/javascript-algorithms-and-data-structures/regular-expressions/match-whitespace/index.md

@@ -0,0 +1,9 @@
+---
+title: Match Whitespace
+localeTitle: Corresponder espaço em branco
+---
+## Corresponder espaço em branco
+
+Este é um esboço. [Ajude nossa comunidade a expandi-lo](https://github.com/freecodecamp/guides/tree/master/src/pages/certifications/javascript-algorithms-and-data-structures/regular-expressions/match-whitespace/index.md) .
+
+[Este guia de estilo rápido ajudará a garantir que sua solicitação de recebimento seja aceita](https://github.com/freecodecamp/guides/blob/master/README.md) .

guide/portuguese/certifications/javascript-algorithms-and-data-structures/regular-expressions/positive-and-negative-lookahead/index.md

@@ -0,0 +1,19 @@
+---
+title: Positive and Negative Lookahead
+localeTitle: Lookahead positivo e negativo
+---
+## Lookahead positivo e negativo
+
+*   Lembre-se de usar 2 `lookaheads` para verificar os padrões na string. A primeira `lookahead` é muito similar àquela dada no exemplo - '(? = \\ W {3,6})' - somente o `lower-number` 3 `lower-number` é muito baixo para nossos casos de teste, e um `upper-number` é completamente desnecessário. Essa primeira `lookahead` é usada apenas para encontrar uma string que contenha uma certa quantidade de caracteres. Um segundo `lookahead` deve ser usado para verificar valores numéricos consecutivos no final da string.
+    
+*   A segunda `lookahead` também é semelhante àquela fornecida no exemplo - `(?=\D*\d)` - no entanto, essa expressão também deve ser modificada para passar em todos os casos de teste. Lembre-se de especificar a quantidade exata de números que você deseja que apareça no final da string.
+    
+
+## Solução:
+
+```javascript
+let sampleWord = "astronaut"; 
+ let pwRegex = /(?=\w{5,})(?=\D*\d{2})/; 
+ let result = pwRegex.test(sampleWord); 
+
+```

guide/portuguese/certifications/javascript-algorithms-and-data-structures/regular-expressions/remove-whitespace-from-start-and-end/index.md

@@ -0,0 +1,26 @@
+---
+title: Remove Whitespace from Start and End
+localeTitle: Remova o espaço em branco do início e do fim
+---
+## Remova o espaço em branco do início e do fim
+
+Para resolver esse desafio, basta criar uma string regex que corresponda a qualquer espaço no início ou no final da string.
+
+## Sugestão 1:
+
+Pense em como você pode selecionar substrings no início ou no final de uma string.
+
+## Dica 2:
+
+Pense em como você pode selecionar o espaço em branco
+
+## Alerta de Spoiler - Solução à frente!
+
+## Solução:
+
+```javascript
+let hello = "   Hello, World!  "; 
+ let wsRegex = /^\s+|\s+$/g; // Change this line 
+ let result = hello.replace(wsRegex, ''); // Change this line 
+
+```

guide/portuguese/certifications/javascript-algorithms-and-data-structures/regular-expressions/restrict-possible-usernames/index.md

@@ -0,0 +1,34 @@
+---
+title: Restrict Possible Usernames
+localeTitle: Restringir nomes de usuário possíveis
+---
+## Restringir nomes de usuário possíveis
+
+## Solução:
+
+```javascript
+let username = "JackOfAllTrades"; 
+ let userCheck = /^[az]{2,}\d*$/i; 
+ let result = userCheck.test(username); 
+```
+
+## Explicar:
+
+1.  Os únicos números no nome de usuário devem estar no final. `\d$` Pode haver zero ou mais deles no final. `*`
+
+```javascript
+/\d*$/; 
+```
+
+2.  As letras de nome de usuário podem ser minúsculas e maiúsculas. `i`
+
+```javascript
+/\d*$/i; 
+```
+
+3.  Os nomes de usuários devem ter pelo menos dois caracteres. `{2,}` Um nome de usuário de duas letras só pode usar caracteres alfabéticos. `^[az]`
+
+```javascript
+/^[az]{2,}\d*$/i; 
+
+```

guide/portuguese/certifications/javascript-algorithms-and-data-structures/regular-expressions/reuse-patterns-using-capture-groups/index.md

@@ -0,0 +1,61 @@
+---
+title: Reuse Patterns Using Capture Groups
+localeTitle: Reutilizar padrões usando grupos de captura
+---
+## Reutilizar padrões usando o grupo de captura
+
+## Sugestão 1:
+
+Dado código abaixo:
+
+```javascript
+let testString = "test test test "; 
+ let reRegex =/(test)\s\1/; 
+ let result = reRegex.test(testString); 
+```
+
+`result` no `test test` porque `\1` neste exemplo representa o mesmo texto que o mais recente correspondido pelo primeiro grupo de captura `(test)` .
+
+Se fôssemos traduzir literalmente o regex, seria algo como isto:
+
+```js
+let re = /(test)\s\1; 
+ let literalRe = /test\stest; 
+```
+
+Ambos `rea` e `literalRe` combinariam com a mesma coisa.
+
+## Dica 2:
+
+Dado o código abaixo:
+
+```javascript
+let testString = "test test test "; 
+ let reRegex =/(test)(\s)\1\2\1/; 
+ let result = reRegex.test(testString); 
+```
+
+irá coincidir com o `test test test` inteiro porque: `\1` repetições (teste) `\2` repetições (\\ s)
+
+## Dica 3:
+
+O código abaixo:
+
+```javascript
+let testString = "test test test test test test"; 
+ let reRegex =/(test)(\s)\1\2\1/g; 
+ let result = reRegex.test(testString); 
+```
+
+porque usamos `\g` , nosso Regex não retorna após a primeira correspondência completa ( `test test test` ) e corresponde a todas as repetições.
+
+## Alerta de Spoiler - Solução à frente!
+
+## Solução:
+
+```javascript
+let repeatNum = "42 42 42"; 
+ let reRegex =  /^(\d+)\s\1\s\1$/; 
+ let result = reRegex.test(repeatNum); 
+
+```

guide/portuguese/certifications/javascript-algorithms-and-data-structures/regular-expressions/specify-exact-number-of-matches/index.md

@@ -0,0 +1,9 @@
+---
+title: Specify Exact Number of Matches
+localeTitle: Especifique o Número Exato de Correspondências
+---
+## Especifique o Número Exato de Correspondências
+
+Este é um esboço. [Ajude nossa comunidade a expandi-lo](https://github.com/freecodecamp/guides/tree/master/src/pages/certifications/javascript-algorithms-and-data-structures/regular-expressions/specify-exact-number-of-matches/index.md) .
+
+[Este guia de estilo rápido ajudará a garantir que sua solicitação de recebimento seja aceita](https://github.com/freecodecamp/guides/blob/master/README.md) .

guide/portuguese/certifications/javascript-algorithms-and-data-structures/regular-expressions/specify-only-the-lower-number-of-matches/index.md

@@ -0,0 +1,13 @@
+---
+title: Specify Only the Lower Number of Matches
+localeTitle: Especifique apenas o menor número de correspondências
+---
+O problema Altere o regex haRegex para que corresponda à palavra "Hazzah" apenas quando tiver quatro ou mais letras z.
+
+Solução deixe haStr = "Hazzzzah"; deixe haRegex = / Haz {4,30} ah /; // Alterar esta linha deixe resultado = haRegex.test (haStr);
+
+## Especifique apenas o menor número de correspondências
+
+Este é um esboço. [Ajude nossa comunidade a expandi-lo](https://github.com/freecodecamp/guides/tree/master/src/pages/certifications/javascript-algorithms-and-data-structures/regular-expressions/specify-only-the-lower-number-of-matches/index.md) .
+
+[Este guia de estilo rápido ajudará a garantir que sua solicitação de recebimento seja aceita](https://github.com/freecodecamp/guides/blob/master/README.md) .

guide/portuguese/certifications/javascript-algorithms-and-data-structures/regular-expressions/specify-upper-and-lower-number-of-matches/index.md

@@ -0,0 +1,33 @@
+---
+title: Specify Upper and Lower Number of Matches
+localeTitle: Especifique o Número Superior e Inferior de Correspondências
+---
+## Especifique o Número Superior e Inferior de Correspondências
+
+Lembre-se `/a{2,4}/` retornará `true` enquanto houver entre dois e quatro a juntos. Ele retornará `true` para qualquer string que tenha mais de quatro a juntos também.
+
+Todas essas strings retornarão `true` :
+
+```javascript
+let threeAs = "aaa"; 
+ let fourAs = "aaaa"; 
+ let sevenAs = "aaaaaaa"; 
+ 
+ let myRegex = /a{2,4}/; 
+ myRegex.test(threeAs) ; // true 
+ myRegex.test(fourAs) ; // true 
+ myRegex.test(sevenAs) ; // true 
+```
+
+## Alerta de Spolier!
+
+Lembre-se de usar `\s` após `Oh{3,6}` para incluir um espaço em branco, seguido de `no` para passar todos os casos de teste. Todos os casos de teste são escritos usando um O maiúsculo, no entanto, os testcases também podem ser passados ​​usando `ignore-case` : `/oh{3,6}\sno/i`
+
+## Solução:
+
+```javascript
+let ohStr = "Ohhh no"; 
+ let ohRegex = /Oh{3,6}\sno/; // Change this line 
+ let result = ohRegex.test(ohStr); 
+
+```

guide/portuguese/certifications/javascript-algorithms-and-data-structures/regular-expressions/use-capture-groups-to-search-and-replace/index.md

@@ -0,0 +1,23 @@
+---
+title: Use Capture Groups to Search and Replace
+localeTitle: Use grupos de captura para pesquisar e substituir
+---
+## Use grupos de captura para pesquisar e substituir
+
+Usando `.replace()` com o primeiro conjunto de parâmetros para localizar a parte da string original a ser substituída, e o segundo parâmetro deve ser a substituição.
+
+## Sugestão 1:
+
+Modifique o regex para que o `fixRegex` detecte a parte da string a ser substituída e a variável `replaceText` seja modificada para a string que irá substituir o `fixRegex` .
+
+## Alerta de Spoiler - Solução à frente!
+
+## Solução
+
+```javascript
+let huhText = "This sandwich is good."; 
+ let fixRegex = /good/; // Change this line 
+ let replaceText = "okey-dokey"; // Change this line 
+ let result = huhText.replace(fixRegex, replaceText); 
+
+```

guide/portuguese/certifications/javascript-algorithms-and-data-structures/regular-expressions/using-the-test-method/index.md

@@ -0,0 +1,22 @@
+---
+title: Using the Test Method
+localeTitle: Usando o método de teste
+---
+## Usando o método de teste
+
+Neste desafio, você está verificando para ver se uma seqüência contém um certo "expressão regular", ou **regex** **(reg** ular **ex** pressions). Você usará o método `test()` para fazer isso.
+
+## Sugestão 1:
+
+Chame o método de teste em `myRegex` . O que você acha que o argumento será?
+
+## Alerta de Spoiler - Solução à frente!
+
+## Solução
+
+```javascript
+let myString = "Hello, World!"; 
+ let myRegex = /Hello/; 
+ let result = myRegex.test(myString); // Change this line 
+
+```