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

curriculum/challenges/portuguese/10-coding-interview-prep/rosetta-code/look-and-say-sequence.md

@@ -1,6 +1,6 @@
 ---
 id: 5e6dd14797f5ce267c2f19d0
-title: Look-and-say sequence
+title: Sequência para olhar e dizer
 challengeType: 5
 forumTopicId: 385277
 dashedName: look-and-say-sequence
@@ -8,64 +8,64 @@ dashedName: look-and-say-sequence
 
 # --description--
 
-The [Look and say sequence](https://en.wikipedia.org/wiki/Look and say sequence) is a recursively defined sequence of numbers.
+A [sequência de olhar e dizer](https://en.wikipedia.org/wiki/Look and say sequence) é uma sequência de números definida recursivamente.
 
-Sequence Definition
+Definição da sequência
 
-<ul><li>Take a decimal number</li>
-<li><span>Look</span> at the number, visually grouping consecutive runs of the same digit.</li>
-<li><span>Say</span> the number, from left to right, group by group; as how many of that digit there are - followed by the digit grouped.</li></ul><span> This becomes the next number of the sequence.</span>
+<ul><li>Recebe um número decimal</li>
+<li><span>Olha</span> para o número, agrupando visualmente sequências consecutivas do mesmo dígito.</li>
+<li><span>Diz</span> o número, da esquerda para a direita, grupo após grupo, descrevendo quantos daquele dígito há na sequência, e, logo após, os dígitos agrupados.</li></ul><span> Esse se torna o próximo número da sequência.</span>
 
-An example:
+Exemplo:
 
-<ul><li>Starting with the number 1, you have <span>one</span> 1 which produces 11</li>
-<li>Starting with 11, you have <span>two</span> 1's. I.E.: 21</li>
-<li>Starting with 21, you have <span>one</span> 2, then <span>one</span> 1. I.E.: (12)(11) which becomes 1211</li>
-<li>Starting with 1211, you have <span>one</span> 1, <span>one</span> 2, then <span>two</span> 1's. I.E.: (11)(12)(21) which becomes 111221</li></ul>
+<ul><li>Começando pelo número 1, você tem <span>um</span> 1, o que gera o número 11</li>
+<li>Começando com 11, você tem <span>dois</span> 1s. Ou seja, 21</li>
+<li>Começando com 21, você tem <span>um</span> 2 e depois <span>um</span> 1. Ou seja: (12)(11), que depois se torna 1211</li>
+<li>Começando com 1211, você tem <span>um</span> 1, <span>um</span> 2 e <span>dois</span> 1s. Ou seja: (11)(12)(21), que depois se torna 111221</li></ul>
 
 # --instructions--
 
-Write a function that accepts a string as a parameter, processes it, and returns the resultant string.
+Escreva uma função que aceita uma string como parâmetro, faz seu processamento e retorna a string resultante.
 
 # --hints--
 
-`lookAndSay` should be a function.
+`lookAndSay` deve ser uma função.
 
 ```js
 assert(typeof lookAndSay == 'function');
 ```
 
-`lookAndSay("1")` should return a string.
+`lookAndSay("1")` deve retornar uma string.
 
 ```js
 assert(typeof lookAndSay('1') == 'string');
 ```
 
-`lookAndSay("1")` should return `"11"`.
+`lookAndSay("1")` deve retornar `"11"`.
 
 ```js
 assert.equal(lookAndSay('1'), '11');
 ```
 
-`lookAndSay("11")` should return `"21"`.
+`lookAndSay("11")` deve retornar `"21"`.
 
 ```js
 assert.equal(lookAndSay('11'), '21');
 ```
 
-`lookAndSay("21")` should return `"1211"`.
+`lookAndSay("21")` deve retornar `"1211"`.
 
 ```js
 assert.equal(lookAndSay('21'), '1211');
 ```
 
-`lookAndSay("1211")` should return `"111221"`.
+`lookAndSay("1211")` deve retornar `"111221"`.
 
 ```js
 assert.equal(lookAndSay('1211'), '111221');
 ```
 
-`lookAndSay("3542")` should return `"13151412"`.
+`lookAndSay("3542")` deve retornar `"13151412"`.
 
 ```js
 assert.equal(lookAndSay('3542'), '13151412');