Removed unnecessary quotes in curriculum/challenges/portuguese files. (#35773)

* package-lock.json and package.json have been updated?

* Revert "package-lock.json and package.json have been updated?"

This reverts commit 77fb01ddf6.

* removed quotes from portuguese challenge files

curriculum/challenges/portuguese/01-responsive-web-design/basic-html-and-html5/declare-the-doctype-of-an-html-document.portuguese.md

@@ -7,7 +7,7 @@ localeTitle: Declarar o Doctype de um documento HTML
 ---
 
 ## Description
-<section id="description"> Os desafios até agora cobriram elementos HTML específicos e seus usos. No entanto, existem alguns elementos que fornecem estrutura geral à sua página e devem ser incluídos em todos os documentos HTML. Na parte superior do seu documento, você precisa informar ao navegador qual versão do HTML sua página está usando. O HTML é uma linguagem em evolução e é atualizado regularmente. A maioria dos principais navegadores suporta a especificação mais recente, que é HTML5. No entanto, as páginas web mais antigas podem usar versões anteriores do idioma. Você diz ao navegador essas informações adicionando a tag <code>&lt;!DOCTYPE ...&gt;</code> na primeira linha, onde a parte &quot; <code>...</code> &quot; é a versão do HTML. Para HTML5, você usa <code>&lt;!DOCTYPE html&gt;</code> . O <code>!</code> e <code>DOCTYPE</code> maiúsculas é importante, especialmente para navegadores mais antigos. O <code>html</code> não faz <code>html</code> entre maiúsculas e minúsculas. Em seguida, o restante do código HTML precisa ser agrupado em tags <code>html</code> . A abertura <code>&lt;html&gt;</code> vai diretamente abaixo da linha <code>&lt;!DOCTYPE html&gt;</code> , e o fechamento <code>&lt;/html&gt;</code> vai no final da página. Aqui está um exemplo da estrutura da página: <blockquote> &lt;! DOCTYPE html&gt; <br> &lt;html&gt; <br> &lt;! - Seu código HTML vai aqui -&gt; <br> &lt;/ html&gt; </blockquote></section>
+<section id="description"> Os desafios até agora cobriram elementos HTML específicos e seus usos. No entanto, existem alguns elementos que fornecem estrutura geral à sua página e devem ser incluídos em todos os documentos HTML. Na parte superior do seu documento, você precisa informar ao navegador qual versão do HTML sua página está usando. O HTML é uma linguagem em evolução e é atualizado regularmente. A maioria dos principais navegadores suporta a especificação mais recente, que é HTML5. No entanto, as páginas web mais antigas podem usar versões anteriores do idioma. Você diz ao navegador essas informações adicionando a tag <code>&lt;!DOCTYPE ...&gt;</code> na primeira linha, onde a parte <code>...</code> é a versão do HTML. Para HTML5, você usa <code>&lt;!DOCTYPE html&gt;</code> . O <code>!</code> e <code>DOCTYPE</code> maiúsculas é importante, especialmente para navegadores mais antigos. O <code>html</code> não faz <code>html</code> entre maiúsculas e minúsculas. Em seguida, o restante do código HTML precisa ser agrupado em tags <code>html</code> . A abertura <code>&lt;html&gt;</code> vai diretamente abaixo da linha <code>&lt;!DOCTYPE html&gt;</code> , e o fechamento <code>&lt;/html&gt;</code> vai no final da página. Aqui está um exemplo da estrutura da página: <blockquote> &lt;! DOCTYPE html&gt; <br> &lt;html&gt; <br> &lt;! - Seu código HTML vai aqui -&gt; <br> &lt;/ html&gt; </blockquote></section>
 
 ## Instructions
 <section id="instructions"> Adicione uma tag <code>DOCTYPE</code> para HTML5 à parte superior do documento HTML em branco no editor de código. Sob ele, adicione as tags <code>html</code> abertura e fechamento, que envolvem um elemento <code>h1</code> . O título pode incluir qualquer texto. </section>

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript/iterate-with-javascript-do...while-loops.portuguese.md

@@ -7,7 +7,7 @@ localeTitle: Iterar com JavaScript Do ... While Loops
 ---
 
 ## Description
-<section id="description"> Você pode executar o mesmo código várias vezes usando um loop. O próximo tipo de loop que você aprenderá é chamado de loop &quot; <code>do...while</code> &quot; porque primeiro ele &quot; <code>do</code> &quot; uma passagem do código dentro do loop, não importa o que aconteça, e então executa &quot; <code>while</code> &quot; uma condição especificada é verdadeira e pára assim que a condição não for mais verdadeira. Vamos ver um exemplo. <blockquote> var ourArray = []; <br> var i = 0; <br> Faz { <br> ourArray.push (i); <br> i ++; <br> } enquanto (i &lt;5); </blockquote> Isso se comporta exatamente como você esperaria com qualquer outro tipo de loop, e a matriz resultante será semelhante a <code>[0, 1, 2, 3, 4]</code> . No entanto, o que faz o <code>do...while</code> diferente de outros loops é como ele se comporta quando a condição falha na primeira verificação. Vamos ver isso em ação. Aqui está um loop regular que executará o código no loop desde que <code>i &lt; 5</code> . <blockquote> var ourArray = []; <br> var i = 5; <br> enquanto (i &lt;5) { <br> ourArray.push (i); <br> i ++; <br> } </blockquote> Observe que inicializamos o valor de <code>i</code> como sendo 5. Quando executamos a próxima linha, notamos que <code>i</code> não é menor que 5. Portanto, não executamos o código dentro do loop. O resultado é que o <code>ourArray</code> terá nada adicionado a ele, então ele ainda ficará assim <code>[]</code> quando todo o código no exemplo acima terminar de ser executado. Agora, dê uma olhada em um <code>do...while</code> loop. <blockquote> var ourArray = []; <br> var i = 5; <br> Faz { <br> ourArray.push (i); <br> i ++; <br> } enquanto (i &lt;5); </blockquote> Neste caso, inicializamos o valor de <code>i</code> como 5, assim como fizemos com o loop while. Quando chegamos à próxima linha, não há verificação para o valor de <code>i</code> , então vamos para o código dentro das chaves e executá-lo. Vamos adicionar um elemento à matriz e incrementar <code>i</code> antes de chegarmos à verificação de condição. Então, quando chegarmos a verificar se <code>i &lt; 5</code> ver que <code>i</code> agora é 6, o que falha na verificação condicional. Então, saímos do loop e acabamos. No final do exemplo acima, o valor de <code>ourArray</code> é <code>[5]</code> . Essencialmente, um laço <code>do...while</code> while garante que o código dentro do loop será executado pelo menos uma vez. Vamos tentar fazer um <code>do...while</code> loop para trabalhar, empurrando valores para um array. </section>
+<section id="description"> Você pode executar o mesmo código várias vezes usando um loop. O próximo tipo de loop que você aprenderá é chamado de loop <code>do...while</code> porque primeiro ele <code>do</code> uma passagem do código dentro do loop, não importa o que aconteça, e então executa <code>while</code> uma condição especificada é verdadeira e pára assim que a condição não for mais verdadeira. Vamos ver um exemplo. <blockquote> var ourArray = []; <br> var i = 0; <br> Faz { <br> ourArray.push (i); <br> i ++; <br> } enquanto (i &lt;5); </blockquote> Isso se comporta exatamente como você esperaria com qualquer outro tipo de loop, e a matriz resultante será semelhante a <code>[0, 1, 2, 3, 4]</code> . No entanto, o que faz o <code>do...while</code> diferente de outros loops é como ele se comporta quando a condição falha na primeira verificação. Vamos ver isso em ação. Aqui está um loop regular que executará o código no loop desde que <code>i &lt; 5</code> . <blockquote> var ourArray = []; <br> var i = 5; <br> enquanto (i &lt;5) { <br> ourArray.push (i); <br> i ++; <br> } </blockquote> Observe que inicializamos o valor de <code>i</code> como sendo 5. Quando executamos a próxima linha, notamos que <code>i</code> não é menor que 5. Portanto, não executamos o código dentro do loop. O resultado é que o <code>ourArray</code> terá nada adicionado a ele, então ele ainda ficará assim <code>[]</code> quando todo o código no exemplo acima terminar de ser executado. Agora, dê uma olhada em um <code>do...while</code> loop. <blockquote> var ourArray = []; <br> var i = 5; <br> Faz { <br> ourArray.push (i); <br> i ++; <br> } enquanto (i &lt;5); </blockquote> Neste caso, inicializamos o valor de <code>i</code> como 5, assim como fizemos com o loop while. Quando chegamos à próxima linha, não há verificação para o valor de <code>i</code> , então vamos para o código dentro das chaves e executá-lo. Vamos adicionar um elemento à matriz e incrementar <code>i</code> antes de chegarmos à verificação de condição. Então, quando chegarmos a verificar se <code>i &lt; 5</code> ver que <code>i</code> agora é 6, o que falha na verificação condicional. Então, saímos do loop e acabamos. No final do exemplo acima, o valor de <code>ourArray</code> é <code>[5]</code> . Essencialmente, um laço <code>do...while</code> while garante que o código dentro do loop será executado pelo menos uma vez. Vamos tentar fazer um <code>do...while</code> loop para trabalhar, empurrando valores para um array. </section>
 
 ## Instructions
 <section id="instructions"> Alterar o <code>while</code> loop no código a um <code>do...while</code> loop para que o loop vai empurrar o número 10 a <code>myArray</code> , e <code>i</code> será igual a <code>11</code> quando o código termina a execução. </section>

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript/iterate-with-javascript-for-loops.portuguese.md

@@ -7,7 +7,7 @@ localeTitle: Iterar com JavaScript For Loops
 ---
 
 ## Description
-<section id="description"> Você pode executar o mesmo código várias vezes usando um loop. O tipo mais comum de loop de JavaScript é chamado de &quot; <code>for loop</code> &quot; porque é executado &quot;por&quot; um número específico de vezes. For loops são declarados com três expressões opcionais separadas por ponto e vírgula: <code>for ([initialization]; [condition]; [final-expression])</code> A instrução de <code>initialization</code> é executada uma vez apenas antes do loop iniciar. É normalmente usado para definir e configurar sua variável de loop. A instrução de <code>condition</code> é avaliada no início de cada iteração de loop e continuará enquanto ela for avaliada como <code>true</code> . Quando a <code>condition</code> é <code>false</code> no início da iteração, o loop deixará de ser executado. Isso significa que se a <code>condition</code> começar como <code>false</code> , seu loop nunca será executado. A <code>final-expression</code> é executada no final de cada iteração de loop, antes da próxima verificação de <code>condition</code> e é geralmente usada para incrementar ou decrementar seu contador de loop. No exemplo a seguir, inicializamos com <code>i = 0</code> e iteramos enquanto nossa condição <code>i &lt; 5</code> é verdadeira. Vamos incrementar <code>i</code> por <code>1</code> em cada iteração de loop com o <code>i++</code> como nossa <code>final-expression</code> . <blockquote> var ourArray = []; <br> para (var i = 0; i &lt;5; i ++) { <br> ourArray.push (i); <br> } </blockquote> <code>ourArray</code> irá agora conter <code>[0,1,2,3,4]</code> . </section>
+<section id="description"> Você pode executar o mesmo código várias vezes usando um loop. O tipo mais comum de loop de JavaScript é chamado de <code>for loop</code> porque é executado &quot;por&quot; um número específico de vezes. For loops são declarados com três expressões opcionais separadas por ponto e vírgula: <code>for ([initialization]; [condition]; [final-expression])</code> A instrução de <code>initialization</code> é executada uma vez apenas antes do loop iniciar. É normalmente usado para definir e configurar sua variável de loop. A instrução de <code>condition</code> é avaliada no início de cada iteração de loop e continuará enquanto ela for avaliada como <code>true</code> . Quando a <code>condition</code> é <code>false</code> no início da iteração, o loop deixará de ser executado. Isso significa que se a <code>condition</code> começar como <code>false</code> , seu loop nunca será executado. A <code>final-expression</code> é executada no final de cada iteração de loop, antes da próxima verificação de <code>condition</code> e é geralmente usada para incrementar ou decrementar seu contador de loop. No exemplo a seguir, inicializamos com <code>i = 0</code> e iteramos enquanto nossa condição <code>i &lt; 5</code> é verdadeira. Vamos incrementar <code>i</code> por <code>1</code> em cada iteração de loop com o <code>i++</code> como nossa <code>final-expression</code> . <blockquote> var ourArray = []; <br> para (var i = 0; i &lt;5; i ++) { <br> ourArray.push (i); <br> } </blockquote> <code>ourArray</code> irá agora conter <code>[0,1,2,3,4]</code> . </section>
 
 ## Instructions
 <section id="instructions"> Use um loop <code>for</code> para trabalhar para empurrar os valores de 1 a 5 para <code>myArray</code> . </section>

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript/iterate-with-javascript-while-loops.portuguese.md

@@ -7,7 +7,7 @@ localeTitle: Iterar com loops While de JavaScript
 ---
 
 ## Description
-<section id="description"> Você pode executar o mesmo código várias vezes usando um loop. O primeiro tipo de loop vamos aprender é chamado de &quot; <code>while</code> &quot; laço porque ele é executado &quot;enquanto&quot; uma condição especificada for verdadeira e pára uma vez que a condição já não é verdade. <blockquote> var ourArray = []; <br> var i = 0; <br> enquanto (i &lt;5) { <br> ourArray.push (i); <br> i ++; <br> } </blockquote> Vamos tentar fazer um loop while funcionar empurrando valores para um array. </section>
+<section id="description"> Você pode executar o mesmo código várias vezes usando um loop. O primeiro tipo de loop vamos aprender é chamado de <code>while</code> laço porque ele é executado &quot;enquanto&quot; uma condição especificada for verdadeira e pára uma vez que a condição já não é verdade. <blockquote> var ourArray = []; <br> var i = 0; <br> enquanto (i &lt;5) { <br> ourArray.push (i); <br> i ++; <br> } </blockquote> Vamos tentar fazer um loop while funcionar empurrando valores para um array. </section>
 
 ## Instructions
 <section id="instructions"> Empurrar os números de 0 a 4 para <code>myArray</code> usando uma <code>while</code> loop. </section>

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript/replacing-if-else-chains-with-switch.portuguese.md

@@ -29,7 +29,7 @@ tests:
     testString: 'assert(chainToSwitch(42) === "The Answer", "<code>chainToSwitch(42)</code> should be "The Answer"");'
   - text: '<code>chainToSwitch(1)</code> deve ser &quot;Não existe # 1&quot;'
     testString: 'assert(chainToSwitch(1) === "There is no #1", "<code>chainToSwitch(1)</code> should be "There is no #1"");'
-  - text: <code>chainToSwitch(99)</code> deve ser &quot; <code>chainToSwitch(99)</code> !&quot;
+  - text: <code>chainToSwitch(99)</code> deve ser <code>chainToSwitch(99)</code> !
     testString: 'assert(chainToSwitch(99) === "Missed me by this much!", "<code>chainToSwitch(99)</code> should be "Missed me by this much!"");'
   - text: <code>chainToSwitch(7)</code> deve ser &quot;Ate Nine&quot;
     testString: 'assert(chainToSwitch(7) === "Ate Nine", "<code>chainToSwitch(7)</code> should be "Ate Nine"");'

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

@@ -17,19 +17,19 @@ localeTitle: Encontre um ou mais criminosos em uma perseguição policial
 
 ```yml
 tests:
-  - text: Sua expressão regular deve corresponder a <code>one</code> criminoso (&quot; <code>C</code> &quot;) em <code>&quot;C&quot;</code>
+  - text: Sua expressão regular deve corresponder a <code>one</code> criminoso ( <code>C</code> ) em <code>C</code>
     testString: 'assert("C".match(reCriminals) && "C".match(reCriminals)[0] == "C", "Sua expressão regular deve corresponder a <code>one</code> criminoso ("<code>C</code>") em <code>"C"</code>");'
   - text: Sua expressão regular deve coincidir com <code>two</code> criminosos (&quot; <code>CC</code> &quot;) em <code>&quot;CC&quot;</code>
-    testString: 'assert("CC".match(reCriminals) && "CC".match(reCriminals)[0] == "CC", "Sua expressão regular deve corresponder a <code>two</code> criminosos ("<code>CC</code>") em <code>"CC"</code>");'
+    testString: 'assert("CC".match(reCriminals) && "CC".match(reCriminals)[0] == "CC", "Sua expressão regular deve corresponder a <code>two</code> criminosos (<code>CC</code>) em <code>CC</code>);'
-  - text: Sua expressão regular deve corresponder a <code>three</code> criminosos (&quot; <code>CCC</code> &quot;) em <code>&quot;P1P5P4CCCP2P6P3&quot;</code>
+  - text: Sua expressão regular deve corresponder a <code>three</code> criminosos ( <code>CCC</code> ) em <code>P1P5P4CCCP2P6P3</code>
     testString: 'assert("P1P5P4CCCP2P6P3".match(reCriminals) && "P1P5P4CCCP2P6P3".match(reCriminals)[0] == "CCC", "Sua expressão regular deve corresponder a <code>three</code> criminosos ("<code>CCC</code>") em <code>"P1P5P4CCCP2P6P3"</code>");'
-  - text: Sua expressão regular deve corresponder a <code>five</code> criminosos (&quot; <code>CCCCC</code> &quot;) em <code>&quot;P6P2P7P4P5CCCCCP3P1&quot;</code>
+  - text: Sua expressão regular deve corresponder a <code>five</code> criminosos ( <code>CCCCC</code> ) em <code>P6P2P7P4P5CCCCCP3P1</code>
     testString: 'assert("P6P2P7P4P5CCCCCP3P1".match(reCriminals) && "P6P2P7P4P5CCCCCP3P1".match(reCriminals)[0] == "CCCCC", "Sua expressão regular deve corresponder a <code>five</code> criminosos ("<code>CCCCC</code>") em <code>"P6P2P7P4P5CCCCCP3P1"</code>");'
   - text: Sua expressão regular não deve corresponder a nenhum criminoso em <code>&quot;&quot;</code>
     testString: 'assert(!reCriminals.test(""), "Sua expressão regular não deve corresponder a nenhum criminoso <code>""</code>");'
-  - text: Sua expressão regular não deve corresponder a nenhum criminoso em <code>&quot;P1P2P3&quot;</code>
+  - text: Sua expressão regular não deve corresponder a nenhum criminoso em <code>P1P2P3</code>
     testString: 'assert(!reCriminals.test("P1P2P3"), "Sua expressão regular não deve corresponder a nenhum criminoso em <code>"P1P2P3"</code>");'
-  - text: Sua expressão regular deve corresponder a <code>fifty</code> criminosos (&quot; <code>CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC</code> &quot;) em <code>&quot;P2P1P5P4CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCP3&quot;</code> .
+  - text: Sua expressão regular deve corresponder a <code>fifty</code> criminosos ( <code>CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC</code> ) em <code>P2P1P5P4CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCP3</code> .
     testString: 'assert("P2P1P5P4CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCP3".match(reCriminals) && "P2P1P5P4CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCP3".match(reCriminals)[0] == "CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC", "Sua expressão regular deve corresponder a <code>fifty</code> criminosos ("<code>CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC</code>") em <code>"P2P1P5P4CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCP3"</code>.");'
 
 ```

curriculum/challenges/portuguese/08-coding-interview-prep/rosetta-code/convert-seconds-to-compound-duration.portuguese.md

@@ -7,7 +7,7 @@ localeTitle: Converta segundos para duração composta
 ---
 
 ## Description
-<section id="description"> Tarefa: <p> Implemente uma função que: </p> recebe um inteiro positivo representando uma duração em segundos como entrada (por exemplo, <code>100</code> ) e retorna uma string que mostra a mesma duração decomposta em semanas, dias, horas, minutos e segundos, conforme detalhado abaixo (por exemplo, &quot; <code>1 min, 40 sec</code> &quot;). <p> Demonstre que ele passa nos três casos de teste a seguir: </p><p style="font-size:115%; margin:1em 0 0 0"> Casos de teste </p><table><tbody><tr><th> número de entrada </th><th> número de saída </th></tr><tr><td> 7259 </td><td> <code>2 hr, 59 sec</code> </td> </tr><tr><td> 86400 </td><td> <code>1 d</code> </td> </tr><tr><td> 6000000 </td><td> <code>9 wk, 6 d, 10 hr, 40 min</code> </td> </tr></tbody></table><p style="font-size:115%; margin:1em 0 0 0"> Detalhes </p> As seguintes cinco unidades devem ser usadas: <table><tbody><tr><th> unidade </th><th> sufixo usado na saída </th><th> conversão </th></tr><tr><td> semana </td><td> <code>wk</code> </td> <td> 1 semana = 7 dias </td></tr><tr><td> dia </td><td> <code>d</code> </td> <td> 1 dia = 24 horas </td></tr><tr><td> hora </td><td> <code>hr</code> </td> <td> 1 hora = 60 minutos </td></tr><tr><td> minuto </td><td> <code>min</code> </td> <td> 1 minuto = 60 segundos </td></tr><tr><td> segundo </td><td> <code>sec</code> </td> <td></td></tr></tbody></table> No entanto, inclua apenas quantidades com valores diferentes de zero na saída (por exemplo, retorne &quot; <code>1 d</code> &quot; e não &quot; <code>0 wk, 1 d, 0 hr, 0 min, 0 sec</code> &quot;). Dê precedência às unidades maiores em relação às menores possível (por exemplo, retornar <code>2 min, 10 sec</code> e não <code>1 min, 70 sec</code> ou <code>130 sec</code> ) Imite a formatação mostrada nos casos de teste (quantidades classificadas da maior unidade para a menor e separadas por vírgula + espaço; valor e unidade de cada quantidade separada por espaço). <p></p><hr style="margin:1em 0;"><p></p></section>
+<section id="description"> Tarefa: <p> Implemente uma função que: </p> recebe um inteiro positivo representando uma duração em segundos como entrada (por exemplo, <code>100</code> ) e retorna uma string que mostra a mesma duração decomposta em semanas, dias, horas, minutos e segundos, conforme detalhado abaixo (por exemplo, <code>1 min, 40 sec</code>). <p> Demonstre que ele passa nos três casos de teste a seguir: </p><p style="font-size:115%; margin:1em 0 0 0"> Casos de teste </p><table><tbody><tr><th> número de entrada </th><th> número de saída </th></tr><tr><td> 7259 </td><td> <code>2 hr, 59 sec</code> </td> </tr><tr><td> 86400 </td><td> <code>1 d</code> </td> </tr><tr><td> 6000000 </td><td> <code>9 wk, 6 d, 10 hr, 40 min</code> </td> </tr></tbody></table><p style="font-size:115%; margin:1em 0 0 0"> Detalhes </p> As seguintes cinco unidades devem ser usadas: <table><tbody><tr><th> unidade </th><th> sufixo usado na saída </th><th> conversão </th></tr><tr><td> semana </td><td> <code>wk</code> </td> <td> 1 semana = 7 dias </td></tr><tr><td> dia </td><td> <code>d</code> </td> <td> 1 dia = 24 horas </td></tr><tr><td> hora </td><td> <code>hr</code> </td> <td> 1 hora = 60 minutos </td></tr><tr><td> minuto </td><td> <code>min</code> </td> <td> 1 minuto = 60 segundos </td></tr><tr><td> segundo </td><td> <code>sec</code> </td> <td></td></tr></tbody></table> No entanto, inclua apenas quantidades com valores diferentes de zero na saída (por exemplo, retorne <code>1 d</code> e não <code>0 wk, 1 d, 0 hr, 0 min, 0 sec</code>). Dê precedência às unidades maiores em relação às menores possível (por exemplo, retornar <code>2 min, 10 sec</code> e não <code>1 min, 70 sec</code> ou <code>130 sec</code> ) Imite a formatação mostrada nos casos de teste (quantidades classificadas da maior unidade para a menor e separadas por vírgula + espaço; valor e unidade de cada quantidade separada por espaço). <p></p><hr style="margin:1em 0;"><p></p></section>
 
 ## Instructions
 <section id="instructions">