37107287533902102798797998220837590246510135740250
@@ -115,19 +115,19 @@ Work out the first ten digits of the sum of the following one-hundred 50-digit n
# --hints--
-`largeSum(testNums)` should return a number.
+`largeSum(testNums)` deve retornar um número.
```js
assert(typeof largeSum(testNums) === 'number');
```
-`largeSum(testNums)` should return 8348422521.
+`largeSum(testNums)` deve retornar 8348422521.
```js
assert.strictEqual(largeSum(testNums), 8348422521);
```
-`largeSum(fiftyDigitNums)` should return 5537376230.
+`largeSum(fiftyDigitNums)` deve retornar 5537376230.
```js
assert.strictEqual(largeSum(fiftyDigitNums), 5537376230);
diff --git a/curriculum/challenges/portuguese/10-coding-interview-prep/project-euler/problem-14-longest-collatz-sequence.md b/curriculum/challenges/portuguese/10-coding-interview-prep/project-euler/problem-14-longest-collatz-sequence.md
index 807f362857..42c0555768 100644
--- a/curriculum/challenges/portuguese/10-coding-interview-prep/project-euler/problem-14-longest-collatz-sequence.md
+++ b/curriculum/challenges/portuguese/10-coding-interview-prep/project-euler/problem-14-longest-collatz-sequence.md
@@ -1,6 +1,6 @@
---
id: 5900f37a1000cf542c50fe8d
-title: 'Problem 14: Longest Collatz sequence'
+title: 'Problema 14: Maior conjectura de Collatz'
challengeType: 5
forumTopicId: 301768
dashedName: problem-14-longest-collatz-sequence
@@ -8,61 +8,61 @@ dashedName: problem-14-longest-collatz-sequence
# --description--
-The following iterative sequence is defined for the set of positive integers:
+A seguinte sequência iterativa é definida para o conjunto dos números inteiros positivos:
-
n → n/2 (n is even)
+
n → n/2 (use quando n for par)
-
n → 3n + 1 (n is odd)
+
n → 3n + 1 (use quando n for ímpar)
-Using the rule above and starting with 13, we generate the following sequence:
+Usando a regra acima e começando com 13, geramos a seguinte sequência:
13 → 40 → 20 → 10 → 5 → 16 → 8 → 4 → 2 → 1
-It can be seen that this sequence (starting at 13 and finishing at 1) contains 10 terms. Although it has not been proved yet (Collatz Problem), it is thought that all starting numbers finish at 1.
+Podemos ver que essa sequência (começando em 13 e terminando em 1) contém 10 termos. Embora ainda não tenha sido provado (conjectura de Collatz), acredita-se que qualquer número inicial termine em 1.
-Which starting number, under the given `limit`, produces the longest chain?
+Qual número inicial, sob o `limit` (limite) definido, produz a sequência mais longa?
-**Note:** Once the chain starts the terms are allowed to go above one million.
+**Observação:** uma vez iniciada, os termos na sequência podem passar de um milhão.
# --hints--
-`longestCollatzSequence(14)` should return a number.
+`longestCollatzSequence(14)` deve retornar um número.
```js
assert(typeof longestCollatzSequence(14) === 'number');
```
-`longestCollatzSequence(14)` should return 9.
+`longestCollatzSequence(14)` deve retornar 9.
```js
assert.strictEqual(longestCollatzSequence(14), 9);
```
-`longestCollatzSequence(5847)` should return 3711.
+`longestCollatzSequence(5847)` deve retornar 3711.
```js
assert.strictEqual(longestCollatzSequence(5847), 3711);
```
-`longestCollatzSequence(46500)` should return 35655.
+`longestCollatzSequence(46500)` deve retornar 35655.
```js
assert.strictEqual(longestCollatzSequence(46500), 35655);
```
-`longestCollatzSequence(54512)` should return 52527.
+`longestCollatzSequence(54512)` deve retornar 52527.
```js
assert.strictEqual(longestCollatzSequence(54512), 52527);
```
-`longestCollatzSequence(100000)` should return 77031.
+`longestCollatzSequence(100000)` deve retornar 77031.
```js
assert.strictEqual(longestCollatzSequence(100000), 77031);
```
-`longestCollatzSequence(1000000)` should return 837799.
+`longestCollatzSequence(1000000)` deve retornar 837799.
```js
assert.strictEqual(longestCollatzSequence(1000000), 837799);
diff --git a/curriculum/challenges/portuguese/10-coding-interview-prep/project-euler/problem-15-lattice-paths.md b/curriculum/challenges/portuguese/10-coding-interview-prep/project-euler/problem-15-lattice-paths.md
index 225a31ee93..7e2e68bed5 100644
--- a/curriculum/challenges/portuguese/10-coding-interview-prep/project-euler/problem-15-lattice-paths.md
+++ b/curriculum/challenges/portuguese/10-coding-interview-prep/project-euler/problem-15-lattice-paths.md
@@ -1,6 +1,6 @@
---
id: 5900f37b1000cf542c50fe8e
-title: 'Problem 15: Lattice paths'
+title: 'Problema 15: Caminhos em uma grade'
challengeType: 5
forumTopicId: 301780
dashedName: problem-15-lattice-paths
@@ -8,33 +8,33 @@ dashedName: problem-15-lattice-paths
# --description--
-Starting in the top left corner of a 2×2 grid, and only being able to move to the right and down, there are exactly 6 routes to the bottom right corner.
+Começando no canto superior esquerdo de uma grade 2×2, e sendo capaz de se mover para a direita e para baixo, existem exatamente 6 caminhos até o canto inferior direito.
-
+
-How many such routes are there through a given `gridSize`?
+Quantas rotas existem no parâmetro `gridSize` fornecido à sua função?
# --hints--
-`latticePaths(4)` should return a number.
+`latticePaths(4)` deve retornar um número.
```js
assert(typeof latticePaths(4) === 'number');
```
-`latticePaths(4)` should return 70.
+`latticePaths(4)` deve retornar 70.
```js
assert.strictEqual(latticePaths(4), 70);
```
-`latticePaths(9)` should return 48620.
+`latticePaths(9)` deve retornar 48620.
```js
assert.strictEqual(latticePaths(9), 48620);
```
-`latticePaths(20)` should return 137846528820.
+`latticePaths(20)` deve retornar 137846528820.
```js
assert.strictEqual(latticePaths(20), 137846528820);
diff --git a/curriculum/challenges/portuguese/10-coding-interview-prep/project-euler/problem-16-power-digit-sum.md b/curriculum/challenges/portuguese/10-coding-interview-prep/project-euler/problem-16-power-digit-sum.md
index b71b480082..34b78e891f 100644
--- a/curriculum/challenges/portuguese/10-coding-interview-prep/project-euler/problem-16-power-digit-sum.md
+++ b/curriculum/challenges/portuguese/10-coding-interview-prep/project-euler/problem-16-power-digit-sum.md
@@ -1,6 +1,6 @@
---
id: 5900f37d1000cf542c50fe8f
-title: 'Problem 16: Power digit sum'
+title: 'Problema 16: Soma dos algarismos de uma potenciação'
challengeType: 5
forumTopicId: 301791
dashedName: problem-16-power-digit-sum
@@ -8,31 +8,31 @@ dashedName: problem-16-power-digit-sum
# --description--
-2
15 = 32768 and the sum of its digits is 3 + 2 + 7 + 6 + 8 = 26.
+2
15 = 32768. A soma destes algarismos é 3 + 2 + 7 + 6 + 8 = 26.
-What is the sum of the digits of the number 2
exponent?
+Qual é a soma dos algarismos do número 2
exponent?
# --hints--
-`powerDigitSum(15)` should return a number.
+`powerDigitSum(15)` deve retornar um número.
```js
assert(typeof powerDigitSum(15) === 'number');
```
-`powerDigitSum(15)` should return 26.
+`powerDigitSum(15)` deve retornar 26.
```js
assert.strictEqual(powerDigitSum(15), 26);
```
-`powerDigitSum(128)` should return 166.
+`powerDigitSum(128)` deve retornar 166.
```js
assert.strictEqual(powerDigitSum(128), 166);
```
-`powerDigitSum(1000)` should return 1366.
+`powerDigitSum(1000)` deve retornar 1366.
```js
assert.strictEqual(powerDigitSum(1000), 1366);
diff --git a/curriculum/challenges/portuguese/10-coding-interview-prep/project-euler/problem-17-number-letter-counts.md b/curriculum/challenges/portuguese/10-coding-interview-prep/project-euler/problem-17-number-letter-counts.md
index 2b096d1d78..c235353b10 100644
--- a/curriculum/challenges/portuguese/10-coding-interview-prep/project-euler/problem-17-number-letter-counts.md
+++ b/curriculum/challenges/portuguese/10-coding-interview-prep/project-euler/problem-17-number-letter-counts.md
@@ -1,6 +1,6 @@
---
id: 5900f37d1000cf542c50fe90
-title: 'Problem 17: Number letter counts'
+title: 'Problema 17: Contador de letras'
challengeType: 5
forumTopicId: 301804
dashedName: problem-17-number-letter-counts
@@ -8,33 +8,33 @@ dashedName: problem-17-number-letter-counts
# --description--
-If the numbers 1 to 5 are written out in words: one, two, three, four, five, then there are 3 + 3 + 5 + 4 + 4 = 19 letters used in total.
+Considere os números de 1 a 5 escritos em palavras: um, dois, três, quatro, cinco. Se você somar a quantidade de letras, terá 2 + 4 + 4 + 6 + 5 = 21.
-If all the numbers from 1 to given `limit` inclusive were written out in words, how many letters would be used?
+Se todos os números entre 1 e o parâmetro `limit` (inclusivo) fossem escritos em palavras, quantas letras existiriam?
-**Note:** Do not count spaces or hyphens. For example, 342 (three hundred and forty-two) contains 23 letters and 115 (one hundred and fifteen) contains 20 letters. The use of "and" when writing out numbers is in compliance with British usage.
+**Observação:** não conte espaços ou hífens. Por exemplo, 342 (trezentos e quarenta e dois) contém 23 letras e 115 (cento e quinze) contém 12 letras. O uso de "e" ao escrever números está em conformidade com a utilização britânica. Lembre-se que o teste considera apenas números escritos em Inglês.
# --hints--
-`numberLetterCounts(5)` should return a number.
+`numberLetterCounts(5)` deve retornar um número.
```js
assert(typeof numberLetterCounts(5) === 'number');
```
-`numberLetterCounts(5)` should return 19.
+`numberLetterCounts(5)` deve retornar 19.
```js
assert.strictEqual(numberLetterCounts(5), 19);
```
-`numberLetterCounts(150)` should return 1903.
+`numberLetterCounts(150)` deve retornar 1903.
```js
assert.strictEqual(numberLetterCounts(150), 1903);
```
-`numberLetterCounts(1000)` should return 21124.
+`numberLetterCounts(1000)` deve retornar 21124.
```js
assert.strictEqual(numberLetterCounts(1000), 21124);
diff --git a/curriculum/challenges/portuguese/10-coding-interview-prep/project-euler/problem-18-maximum-path-sum-i.md b/curriculum/challenges/portuguese/10-coding-interview-prep/project-euler/problem-18-maximum-path-sum-i.md
index 2ad9a7a7a6..ac469849ce 100644
--- a/curriculum/challenges/portuguese/10-coding-interview-prep/project-euler/problem-18-maximum-path-sum-i.md
+++ b/curriculum/challenges/portuguese/10-coding-interview-prep/project-euler/problem-18-maximum-path-sum-i.md
@@ -1,6 +1,6 @@
---
id: 5900f37e1000cf542c50fe91
-title: 'Problem 18: Maximum path sum I'
+title: 'Problema 18: Soma do caminho I'
challengeType: 5
forumTopicId: 301815
dashedName: problem-18-maximum-path-sum-i
@@ -8,7 +8,7 @@ dashedName: problem-18-maximum-path-sum-i
# --description--
-By starting at the top of the triangle below and moving to adjacent numbers on the row below, the maximum total from top to bottom is 23.
+Começando no topo do triângulo abaixo e movendo-se para os números adjacentes na linha abaixo, o total máximo de cima para baixo é 23.
3
@@ -17,9 +17,9 @@ By starting at the top of the triangle below and moving to adjacent numbers on t
8 5 9 3
-That is, 3 + 7 + 4 + 9 = 23.
+Ou seja, 3 + 7 + 4 + 9 = 23.
-Find the maximum total from top to bottom of the triangle below:
+Calcule o máximo total do topo até o final do triângulo abaixo:
75
95 64
@@ -37,23 +37,23 @@ Find the maximum total from top to bottom of the triangle below:
63 66 04 68 89 53 67 30 73 16 69 87 40 31
04 62 98 27 23 09 70 98 73 93 38 53 60 04 23
-**NOTE:** As there are only 16384 routes, it is possible to solve this problem by trying every route. However, Problem 67, is the same challenge with a triangle containing one-hundred rows; it cannot be solved by brute force, and requires a clever method! ;o)
+**Observação:** como existem apenas 16384 rotas, é possível resolver este problema tentando cada rota. No entanto, o problema 67 (que você irá ver futuramente) aborda este mesmo desafio, com a diferença que o triângulo contém cem linhas. Por tanto, não pode ser resolvido pela força bruta e requer um método inteligente! ;)
# --hints--
-`maximumPathSumI(testTriangle)` should return a number.
+`maximumPathSumI(testTriangle)` deve retornar um número.
```js
assert(typeof maximumPathSumI(testTriangle) === 'number');
```
-`maximumPathSumI(testTriangle)` should return 23.
+`maximumPathSumI(testTriangle)` deve retornar 23.
```js
assert.strictEqual(maximumPathSumI(testTriangle), 23);
```
-`maximumPathSumI(numTriangle)` should return 1074.
+`maximumPathSumI(numTriangle)` deve retornar 1074.
```js
assert.strictEqual(maximumPathSumI(numTriangle), 1074);
diff --git a/curriculum/challenges/portuguese/10-coding-interview-prep/project-euler/problem-19-counting-sundays.md b/curriculum/challenges/portuguese/10-coding-interview-prep/project-euler/problem-19-counting-sundays.md
index c12d6d1c6b..992c759c3b 100644
--- a/curriculum/challenges/portuguese/10-coding-interview-prep/project-euler/problem-19-counting-sundays.md
+++ b/curriculum/challenges/portuguese/10-coding-interview-prep/project-euler/problem-19-counting-sundays.md
@@ -1,6 +1,6 @@
---
id: 5900f37f1000cf542c50fe92
-title: 'Problem 19: Counting Sundays'
+title: 'Problema 19: Contando domingos'
challengeType: 5
forumTopicId: 301827
dashedName: problem-19-counting-sundays
@@ -8,37 +8,37 @@ dashedName: problem-19-counting-sundays
# --description--
-You are given the following information, but you may prefer to do some research for yourself.
+Você recebeu as seguintes informações, mas se preferir, pode pesquisar por si mesmo.
- - 1 Jan 1900 was a Monday.
- - Thirty days has September,
April, June and November.
All the rest have thirty-one,
Saving February alone,
Which has twenty-eight, rain or shine.
And on leap years, twenty-nine.
- - A leap year occurs on any year evenly divisible by 4, but not on a century unless it is divisible by 400.
+ - 1 de janeiro de 1900 foi uma segunda-feira.
+ - Setembro, abril, junho e
novembro têm trinta dias.
Os outros meses têm trinta e um,
exceto fevereiro,
que tem vinte e oito, faça chuva ou faça sol.
E nos anos bissextos, vinte e nove apenas.
+ - Um ano bissexto é aquele que, dividido por 4, não deixa resto. Se o ano for secular, apenas aqueles divisíveis por 400 são bissextos.
-How many Sundays fell on the first of the month during the twentieth century (1 Jan 1901 to 31 Dec 2000)?
+Quantos domingos caíram no primeiro dia do mês durante o século 20 (1 de janeiro de 1901 a 31 de dezembro de 2000)?
# --hints--
-`countingSundays(1943, 1946)` should return a number.
+`countingSundays(1943, 1946)` deve retornar um número.
```js
assert(typeof countingSundays(1943, 1946) === 'number');
```
-`countingSundays(1943, 1946)` should return 6.
+`countingSundays(1943, 1946)` deve retornar 6.
```js
assert.strictEqual(countingSundays(1943, 1946), 6);
```
-`countingSundays(1995, 2000)` should return 10.
+`countingSundays(1995, 2000)` deve retornar 10.
```js
assert.strictEqual(countingSundays(1995, 2000), 10);
```
-`countingSundays(1901, 2000)` should return 171.
+`countingSundays(1901, 2000)` deve retornar 171.
```js
assert.strictEqual(countingSundays(1901, 2000), 171);
diff --git a/curriculum/challenges/portuguese/10-coding-interview-prep/project-euler/problem-20-factorial-digit-sum.md b/curriculum/challenges/portuguese/10-coding-interview-prep/project-euler/problem-20-factorial-digit-sum.md
index 579ac97f6f..657fd8e7cf 100644
--- a/curriculum/challenges/portuguese/10-coding-interview-prep/project-euler/problem-20-factorial-digit-sum.md
+++ b/curriculum/challenges/portuguese/10-coding-interview-prep/project-euler/problem-20-factorial-digit-sum.md
@@ -1,6 +1,6 @@
---
id: 5900f3801000cf542c50fe93
-title: 'Problem 20: Factorial digit sum'
+title: 'Problema 20: Soma dos algarismos de um fatorial'
challengeType: 5
forumTopicId: 301839
dashedName: problem-20-factorial-digit-sum
@@ -8,46 +8,46 @@ dashedName: problem-20-factorial-digit-sum
# --description--
-`n`! means `n` × (`n` − 1) × ... × 3 × 2 × 1
+`n`! significa `n` × (`n` - 1) × ... × 3 × 2 × 1
-For example, 10! = 10 × 9 × ... × 3 × 2 × 1 = 3628800,
-and the sum of the digits in the number 10! is 3 + 6 + 2 + 8 + 8 + 0 + 0 = 27.
+Por exemplo: 10! = 10 × 9 × ... × 3 × 2 × 1 = 3628800.
+E a soma dos dígitos no número 10! é 3 + 6 + 2 + 8 + 8 + 0 + 0 + 0 = 27.
-Find the sum of the digits `n`!
+Encontre a soma dos algarismos de `n`!
# --hints--
-`sumFactorialDigits(10)` should return a number.
+`sumFactorialDigits(10)` deve retornar um número.
```js
assert(typeof sumFactorialDigits(10) === 'number');
```
-`sumFactorialDigits(10)` should return 27.
+`sumFactorialDigits(10)` deve retornar 27.
```js
assert.strictEqual(sumFactorialDigits(10), 27);
```
-`sumFactorialDigits(25)` should return 72.
+`sumFactorialDigits(25)` deve retornar 72.
```js
assert.strictEqual(sumFactorialDigits(25), 72);
```
-`sumFactorialDigits(50)` should return 216.
+`sumFactorialDigits(50)` deve retornar 216.
```js
assert.strictEqual(sumFactorialDigits(50), 216);
```
-`sumFactorialDigits(75)` should return 432.
+`sumFactorialDigits(75)` deve retornar 432.
```js
assert.strictEqual(sumFactorialDigits(75), 432);
```
-`sumFactorialDigits(100)` should return 648.
+`sumFactorialDigits(100)` deve retornar 648.
```js
assert.strictEqual(sumFactorialDigits(100), 648);
diff --git a/curriculum/challenges/portuguese/10-coding-interview-prep/project-euler/problem-21-amicable-numbers.md b/curriculum/challenges/portuguese/10-coding-interview-prep/project-euler/problem-21-amicable-numbers.md
index 58acfba70e..6323eff009 100644
--- a/curriculum/challenges/portuguese/10-coding-interview-prep/project-euler/problem-21-amicable-numbers.md
+++ b/curriculum/challenges/portuguese/10-coding-interview-prep/project-euler/problem-21-amicable-numbers.md
@@ -1,6 +1,6 @@
---
id: 5900f3811000cf542c50fe94
-title: 'Problem 21: Amicable numbers'
+title: 'Problema 21: Números amigos'
challengeType: 5
forumTopicId: 301851
dashedName: problem-21-amicable-numbers
@@ -8,41 +8,41 @@ dashedName: problem-21-amicable-numbers
# --description--
-Let d(`n`) be defined as the sum of proper divisors of `n` (numbers less than `n` which divide evenly into `n`).
+Considere d(`n`) sendo igual à soma dos divisores próprios de `n` (divisores próprios de um número positivo `n` são todos os divisores inteiros positivos exceto o próprio `n`).
-If d(`a`) = `b` and d(`b`) = `a`, where `a` ≠ `b`, then `a` and `b` are an amicable pair and each of `a` and `b` are called amicable numbers.
+Se d(`a`) = `b` e d(`b`) = `a`, onde `a` ≠ `b`, então, `a` e `b` são um par amigável e tanto `a` quanto `b` são chamados de números amigos.
-For example, the proper divisors of 220 are 1, 2, 4, 5, 10, 11, 20, 22, 44, 55 and 110; therefore d(220) = 284. The proper divisors of 284 are 1, 2, 4, 71 and 142; so d(284) = 220.
+Por exemplo, os divisores próprios de 220 são 1, 2, 4, 5, 10, 11, 20, 22, 44, 55 e 110. Portanto, d(220) = 284. Os divisores próprios de 284 são 1, 2, 4, 71 e 142. Então d(284) = 220.
-Evaluate the sum of all the amicable numbers under `n`.
+Calcule a soma de todos os números amigos abaixo de `n`.
# --hints--
-`sumAmicableNum(1000)` should return a number.
+`sumAmicableNum(1000)` deve retornar um número.
```js
assert(typeof sumAmicableNum(1000) === 'number');
```
-`sumAmicableNum(1000)` should return 504.
+`sumAmicableNum(1000)` deve retornar 504.
```js
assert.strictEqual(sumAmicableNum(1000), 504);
```
-`sumAmicableNum(2000)` should return 2898.
+`sumAmicableNum(2000)` deve retornar 2898.
```js
assert.strictEqual(sumAmicableNum(2000), 2898);
```
-`sumAmicableNum(5000)` should return 8442.
+`sumAmicableNum(5000)` deve retornar 8442.
```js
assert.strictEqual(sumAmicableNum(5000), 8442);
```
-`sumAmicableNum(10000)` should return 31626.
+`sumAmicableNum(10000)` deve retornar 31626.
```js
assert.strictEqual(sumAmicableNum(10000), 31626);
diff --git a/curriculum/challenges/portuguese/10-coding-interview-prep/project-euler/problem-22-names-scores.md b/curriculum/challenges/portuguese/10-coding-interview-prep/project-euler/problem-22-names-scores.md
index e93e40d6ef..688bc921bc 100644
--- a/curriculum/challenges/portuguese/10-coding-interview-prep/project-euler/problem-22-names-scores.md
+++ b/curriculum/challenges/portuguese/10-coding-interview-prep/project-euler/problem-22-names-scores.md
@@ -1,6 +1,6 @@
---
id: 5a51eabcad78bf416f316e2a
-title: 'Problem 22: Names scores'
+title: 'Problema 22: Pontuações de nomes'
challengeType: 5
forumTopicId: 301862
dashedName: problem-22-names-scores
@@ -8,33 +8,33 @@ dashedName: problem-22-names-scores
# --description--
-Using `names`, an array defined in the background containing over five-thousand first names, begin by sorting it into alphabetical order. Then working out the alphabetical value for each name, multiply this value by its alphabetical position in the list to obtain a name score.
+Neste desafio, existe uma variável chamada `names`, que possui um array com mais de 5 mil nomes. Você pode acessá-la através do argumento passado para sua função. A primeira coisa que você precisa fazer é ordenar estes nomes alfabeticamente. Em seguida, descubra a posição de cada letra do nome e some todas as posições. Após calcular a soma, multiplique este valor pela posição do nome dentro do array de nomes.
-For example, when the list is sorted into alphabetical order, COLIN, which is worth 3 + 15 + 12 + 9 + 14 = 53, is the 938th name in the list. So, COLIN would obtain a score of 938 × 53 = 49714.
+Por exemplo, após ordenar a lista alfabeticamente, o nome COLIN, cujas letras valem 3 + 15 + 12 + 9 + 14 = 53, é o 938º nome na lista. Portanto, o nome COLIN obteria a pontuação de 938 × 53 = 49714.
-What is the total of all the name scores in the array?
+Qual é o total de todas as pontuações no array de nomes?
# --hints--
-`namesScores(test1)` should return a number.
+`namesScores(test1)` deve retornar um número.
```js
assert(typeof namesScores(test1) === 'number');
```
-`namesScores(test1)` should return 791.
+`namesScores(test1)` deve retornar 791.
```js
assert.strictEqual(namesScores(test1), 791);
```
-`namesScores(test2)` should return 1468.
+`namesScores(test2)` deve retornar 1468.
```js
assert.strictEqual(namesScores(test2), 1468);
```
-`namesScores(names)` should return 871198282.
+`namesScores(names)` deve retornar 871198282.
```js
assert.strictEqual(namesScores(names), 871198282);
diff --git a/curriculum/challenges/portuguese/10-coding-interview-prep/project-euler/problem-23-non-abundant-sums.md b/curriculum/challenges/portuguese/10-coding-interview-prep/project-euler/problem-23-non-abundant-sums.md
index ce8b2262e4..2399713e0e 100644
--- a/curriculum/challenges/portuguese/10-coding-interview-prep/project-euler/problem-23-non-abundant-sums.md
+++ b/curriculum/challenges/portuguese/10-coding-interview-prep/project-euler/problem-23-non-abundant-sums.md
@@ -1,6 +1,6 @@
---
id: 5900f3831000cf542c50fe96
-title: 'Problem 23: Non-abundant sums'
+title: 'Problema 23: Soma dos números não abundantes'
challengeType: 5
forumTopicId: 301873
dashedName: problem-23-non-abundant-sums
@@ -8,41 +8,41 @@ dashedName: problem-23-non-abundant-sums
# --description--
-A perfect number is a number for which the sum of its proper divisors is exactly equal to the number. For example, the sum of the proper divisors of 28 would be 1 + 2 + 4 + 7 + 14 = 28, which means that 28 is a perfect number.
+Um número perfeito é aquele igual à soma de seus divisores próprios. Por exemplo, a soma dos divisores próprios de 28 é 1 + 2 + 4 + 7 + 14 = 28. Isso significa que 28 é um número perfeito.
-A number `n` is called deficient if the sum of its proper divisors is less than `n` and it is called abundant if this sum exceeds `n`.
+Um número `n` é chamado de deficiente se a soma de seus divisores próprios for menor que `n`. Se a soma dos divisores próprios for maior que `n`, esse número é chamado de abundante.
-As 12 is the smallest abundant number, 1 + 2 + 3 + 4 + 6 = 16, the smallest number that can be written as the sum of two abundant numbers is 24. By mathematical analysis, it can be shown that all integers greater than 28123 can be written as the sum of two abundant numbers. However, this upper limit cannot be reduced any further by analysis even though it is known that the greatest number that cannot be expressed as the sum of two abundant numbers is less than this limit.
+Como 12 é o menor número abundante, 1 + 2 + 3 + 4 + 6 = 16, o menor número que pode ser escrito como a soma de dois números abundantes é 24. Usando análise matemática, podemos comprovar que todos os números inteiros maiores que 28123 podem ser escritos como a soma de dois números abundantes. No entanto, este limite máximo não pode ser reduzido através de uma análise, embora se saiba que o maior número que não pode ser expresso como a soma de dois números abundantes é inferior a este limite.
-Find the sum of all positive integers <= `n` which cannot be written as the sum of two abundant numbers.
+Calcule a soma de todos os números inteiros positivos <= `n` que não podem ser escritos como a soma de dois números abundantes.
# --hints--
-`sumOfNonAbundantNumbers(10000)` should return a number.
+`sumOfNonAbundantNumbers(10000)` deve retornar um número.
```js
assert(typeof sumOfNonAbundantNumbers(10000) === 'number');
```
-`sumOfNonAbundantNumbers(10000)` should return 3731004.
+`sumOfNonAbundantNumbers(10000)` deve retornar 3731004.
```js
assert(sumOfNonAbundantNumbers(10000) === 3731004);
```
-`sumOfNonAbundantNumbers(15000)` should return 4039939.
+`sumOfNonAbundantNumbers(15000)` deve retornar 4039939.
```js
assert(sumOfNonAbundantNumbers(15000) === 4039939);
```
-`sumOfNonAbundantNumbers(20000)` should return 4159710.
+`sumOfNonAbundantNumbers(20000)` deve retornar 4159710.
```js
assert(sumOfNonAbundantNumbers(20000) === 4159710);
```
-`sumOfNonAbundantNumbers(28123)` should return 4179871.
+`sumOfNonAbundantNumbers(28123)` deve retornar 4179871.
```js
assert(sumOfNonAbundantNumbers(28123) === 4179871);
diff --git a/curriculum/challenges/portuguese/10-coding-interview-prep/project-euler/problem-24-lexicographic-permutations.md b/curriculum/challenges/portuguese/10-coding-interview-prep/project-euler/problem-24-lexicographic-permutations.md
index 49998335d2..eef0ba35a7 100644
--- a/curriculum/challenges/portuguese/10-coding-interview-prep/project-euler/problem-24-lexicographic-permutations.md
+++ b/curriculum/challenges/portuguese/10-coding-interview-prep/project-euler/problem-24-lexicographic-permutations.md
@@ -1,6 +1,6 @@
---
id: 5900f3841000cf542c50fe97
-title: 'Problem 24: Lexicographic permutations'
+title: 'Problema 24: Permutações lexicográficas'
challengeType: 5
forumTopicId: 301885
dashedName: problem-24-lexicographic-permutations
@@ -8,39 +8,39 @@ dashedName: problem-24-lexicographic-permutations
# --description--
-A permutation is an ordered arrangement of objects. For example, 3124 is one possible permutation of the digits 1, 2, 3 and 4. If all of the permutations are listed numerically or alphabetically, we call it lexicographic order. The lexicographic permutations of 0, 1 and 2 are:
+Uma permutação consiste de elementos que podem formar agrupamentos que se diferenciam apenas pela ordem. Por exemplo, 3124 é uma possível permutação dos algarismos 1, 2, 3 e 4. Se todas as permutações estiverem listadas numericamente ou em ordem alfabética, chamamos isso de ordem lexicográfica. As permutações lexicográficas de 0, 1 e 2 são:
012 021 102 120 201 210
-What is the `n`th lexicographic permutation of the digits 0, 1, 2, 3, 4, 5, 6, 7, 8 and 9?
+Qual é a `n`-ésima permutação lexicográfica dos dígitos 0, 1, 2, 3, 4, 5, 6, 7, 8 e 9?
# --hints--
-`lexicographicPermutations(699999)` should return a number.
+`lexicographicPermutations(699999)` deve retornar um número.
```js
assert(typeof lexicographicPermutations(699999) === 'number');
```
-`lexicographicPermutations(699999)` should return 1938246570.
+`lexicographicPermutations(699999)` deve retornar 1938246570.
```js
assert(lexicographicPermutations(699999) == 1938246570);
```
-`lexicographicPermutations(899999)` should return 2536987410.
+`lexicographicPermutations(899999)` deve retornar 2536987410.
```js
assert(lexicographicPermutations(899999) == 2536987410);
```
-`lexicographicPermutations(900000)` should return 2537014689.
+`lexicographicPermutations(900000)` deve retornar 2537014689.
```js
assert(lexicographicPermutations(900000) == 2537014689);
```
-`lexicographicPermutations(999999)` should return 2783915460.
+`lexicographicPermutations(999999)` deve retornar 2783915460.
```js
assert(lexicographicPermutations(999999) == 2783915460);
diff --git a/curriculum/challenges/portuguese/10-coding-interview-prep/project-euler/problem-456-triangles-containing-the-origin-ii.md b/curriculum/challenges/portuguese/10-coding-interview-prep/project-euler/problem-456-triangles-containing-the-origin-ii.md
index fba2743a69..1af6f12cbf 100644
--- a/curriculum/challenges/portuguese/10-coding-interview-prep/project-euler/problem-456-triangles-containing-the-origin-ii.md
+++ b/curriculum/challenges/portuguese/10-coding-interview-prep/project-euler/problem-456-triangles-containing-the-origin-ii.md
@@ -1,6 +1,6 @@
---
id: 5900f5351000cf542c510047
-title: 'Problem 456: Triangles containing the origin II'
+title: 'Problema 456: Triângulos contendo a origem II'
challengeType: 5
forumTopicId: 302130
dashedName: problem-456-triangles-containing-the-origin-ii
@@ -8,24 +8,26 @@ dashedName: problem-456-triangles-containing-the-origin-ii
# --description--
-Define:xn = (1248n mod 32323) - 16161yn = (8421n mod 30103) - 15051
+Definição:
-Pn = {(x1, y1), (x2, y2), ..., (xn, yn)}
+$$\start{align} & x_n = ({1248}^n\bmod 32323) - 16161 \\\\ & y_n = ({8421}^n\bmod 30103) - 15051 \\\\ & P_n = \\{(x_1, y_1), (x_2, y_2), \ldots, (x_n, y_n)\\} \end{align}$$
-For example, P8 = {(-14913, -6630), (-10161, 5625), (5226, 11896), (8340, -10778), (15852, -5203), (-15165, 11295), (-1427, -14495), (12407, 1060)}.
+Por exemplo, $$P_8 = \\{(-14913, -6630), (-10161, 5625), (5226, 11896), (8340, -10778), (15852, -5203), (-15165, 11295), (-1427, -14495), (12407, 1060)\\}$$
-Let C(n) be the number of triangles whose vertices are in Pn which contain the origin in the interior.
+Considere $C(n)$ o número de triângulos cujos vértices estão em $P_n$ e que contêm a origem em seu interior.
-Examples: C(8) = 20 C(600) = 8950634 C(40 000) = 2666610948988
+Exemplos:
-Find C(2 000 000).
+$$\start{align} & C(8) = 20 \\\\ & C(600) = 8\\,950\\,634 \\\\ & C(40\\,000) = 2\\,66610\\,948\\,988 \end{align}$$
+
+Encontre $C(2\\,000\\,000)$.
# --hints--
-`euler456()` should return 333333208685971500.
+`trianglesContainingOriginTwo()` deve retornar `333333208685971500`.
```js
-assert.strictEqual(euler456(), 333333208685971500);
+assert.strictEqual(trianglesContainingOriginTwo(), 333333208685971500);
```
# --seed--
@@ -33,12 +35,12 @@ assert.strictEqual(euler456(), 333333208685971500);
## --seed-contents--
```js
-function euler456() {
+function trianglesContainingOriginTwo() {
return true;
}
-euler456();
+trianglesContainingOriginTwo();
```
# --solutions--
diff --git a/curriculum/challenges/portuguese/10-coding-interview-prep/rosetta-code/convert-seconds-to-compound-duration.md b/curriculum/challenges/portuguese/10-coding-interview-prep/rosetta-code/convert-seconds-to-compound-duration.md
index e050e0d7d2..de1312f9e6 100644
--- a/curriculum/challenges/portuguese/10-coding-interview-prep/rosetta-code/convert-seconds-to-compound-duration.md
+++ b/curriculum/challenges/portuguese/10-coding-interview-prep/rosetta-code/convert-seconds-to-compound-duration.md
@@ -1,6 +1,6 @@
---
id: 596fd036dc1ab896c5db98b1
-title: Convert seconds to compound duration
+title: Converter segundos para duração composta
challengeType: 5
forumTopicId: 302236
dashedName: convert-seconds-to-compound-duration
@@ -8,69 +8,69 @@ dashedName: convert-seconds-to-compound-duration
# --description--
-Implement a function which:
+Implementar uma função que:
- - takes a positive integer representing a duration in seconds as input (e.g.,
100), and
- - returns a string which shows the same duration decomposed into weeks, days, hours, minutes, and seconds as detailed below (e.g.,
1 min, 40 sec).
+ - receba um inteiro positivo que represente uma duração em segundos como entrada (por exemplo,
100) e
+ - retorna uma string que mostra a mesma duração decomposta em semanas, dias, horas, minutos e segundos detalhados abaixo (por exemplo,
1 min, 40 sec).
-Demonstrate that it passes the following three test-cases:
+Demonstre que a função passa pelos três casos de teste:
-
Test Cases
+
Casos de teste
-| Input number | Output number |
-| ------------ | ------------------------- |
-| 7259 |
2 hr, 59 sec |
-| 86400 |
1 d |
-| 6000000 |
9 wk, 6 d, 10 hr, 40 min |
+| Número de entrada | Número de saída |
+| ----------------- | ------------------------- |
+| 7259 |
2 hr, 59 sec |
+| 86400 |
1 d |
+| 6000000 |
9 wk, 6 d, 10 hr, 40 min |
-
Details
+
Detalhes
-
- The following five units should be used:
+ As cinco unidades a seguir devem ser usadas:
-| Unit | Suffix used in Output | Conversion |
+| Unidade | Sufixo usado na saída | Conversão |
| ------ | --------------------- | --------------------- |
-| week |!!crwdBlockTags_18_sgaTkcolBdwrc!! | 1 week = 7 days |
-| day |!!crwdBlockTags_19_sgaTkcolBdwrc!! | 1 day = 24 hours |
-| hour |!!crwdBlockTags_20_sgaTkcolBdwrc!! | 1 hour = 60 minutes |
-| minute |!!crwdBlockTags_21_sgaTkcolBdwrc!! | 1 minute = 60 seconds |
+| week |!!crwdBlockTags_18_sgaTkcolBdwrc!! | 1 semana = 7 dias |
+| day |!!crwdBlockTags_19_sgaTkcolBdwrc!! | 1 dia = 24 horas |
+| hour |!!crwdBlockTags_20_sgaTkcolBdwrc!! | 1 hora = 60 minutos |
+| minute |!!crwdBlockTags_21_sgaTkcolBdwrc!! | 1 minuto = 60 segundos |
| second |!!crwdBlockTags_22_sgaTkcolBdwrc!! | --- |
-
- However, only include quantities with non-zero values in the output (e.g., return
1 d and not 0 wk, 1 d, 0 hr, 0 min, 0 sec).
+ No entanto, somente inclua quantidades com valores diferentes de zero na saída (por exemplo, retorne 1 d em vez de 0 wk, 1 d, 0 hr, 0 min, 0 sec).
-
- Give larger units precedence over smaller ones as much as possible (e.g., return
2 min, 10 sec and not 1 min, 70 sec or 130 sec).
+ Dê precedência a unidades maiores sobre unidades menores tanto quanto possível (por exemplo, retorne 2 min, 10 sec e não 1 min, 70 sec ou 130 sec).
-
- Mimic the formatting shown in the test-cases (quantities sorted from largest unit to smallest and separated by comma+space; value and unit of each quantity separated by space).
+ Imite a formatação mostrada nos casos de teste (quantidades ordenadas da maior unidade para a menor e separadas por vírgula + espaço, alem de valor e unidade de cada quantidade separada por espaço).
# --hints--
-`convertSeconds` should be a function.
+`convertSeconds` deve ser uma função.
```js
assert(typeof convertSeconds === 'function');
```
-`convertSeconds(7259)` should return `2 hr, 59 sec`.
+`convertSeconds(7259)` deve retornar `2 hr, 59 sec`.
```js
assert.equal(convertSeconds(testCases[0]), results[0]);
```
-`convertSeconds(86400)` should return `1 d`.
+`convertSeconds(86400)` deve retornar `1 d`.
```js
assert.equal(convertSeconds(testCases[1]), results[1]);
```
-`convertSeconds(6000000)` should return `9 wk, 6 d, 10 hr, 40 min`.
+`convertSeconds(6000000)` deve retornar `9 wk, 6 d, 10 hr, 40 min`.
```js
assert.equal(convertSeconds(testCases[2]), results[2]);
diff --git a/curriculum/challenges/portuguese/10-coding-interview-prep/rosetta-code/count-occurrences-of-a-substring.md b/curriculum/challenges/portuguese/10-coding-interview-prep/rosetta-code/count-occurrences-of-a-substring.md
index 50d6c16f8d..3f38716b81 100644
--- a/curriculum/challenges/portuguese/10-coding-interview-prep/rosetta-code/count-occurrences-of-a-substring.md
+++ b/curriculum/challenges/portuguese/10-coding-interview-prep/rosetta-code/count-occurrences-of-a-substring.md
@@ -1,6 +1,6 @@
---
id: 596fda99c69f779975a1b67d
-title: Count occurrences of a substring
+title: Contar as ocorrências de uma substring
challengeType: 5
forumTopicId: 302237
dashedName: count-occurrences-of-a-substring
@@ -8,42 +8,42 @@ dashedName: count-occurrences-of-a-substring
# --description--
-Create a function, or show a built-in function, to count the number of non-overlapping occurrences of a substring inside a string.
+Crie uma função, ou mostre uma função integrada para contar o número de ocorrências não sobrepostas de uma substring dentro de uma string.
-The function should take two arguments:
+A função deve receber dois argumentos:
- - the first argument being the string to search, and
- - the second a substring to be searched for.
+ - o primeiro argumento deve ser a string onde ocorrerá a busca, e
+ - o segundo deve ser uma substring a ser buscada.
-It should return an integer count.
+A função deve retornar uma contagem inteira.
-The matching should yield the highest number of non-overlapping matches.
+A pesquisa deve produzir o maior número de correspondências não sobrepostas.
-In general, this essentially means matching from left-to-right or right-to-left.
+Em geral, isto significa, essencialmente, uma correspondência da esquerda para a direita e da direita para a esquerda.
# --hints--
-`countSubstring` should be a function.
+`countSubstring` deve ser uma função.
```js
assert(typeof countSubstring === 'function');
```
-`countSubstring("the three truths", "th")` should return `3`.
+`countSubstring("the three truths", "th")` deve retornar `3`.
```js
assert.equal(countSubstring(testCases[0], searchString[0]), results[0]);
```
-`countSubstring("ababababab", "abab")` should return `2`.
+`countSubstring("ababababab", "abab")` deve retornar `2`.
```js
assert.equal(countSubstring(testCases[1], searchString[1]), results[1]);
```
-`countSubstring("abaabba*bbaba*bbab", "a*b")` should return `2`.
+`countSubstring("abaabba*bbaba*bbab", "a*b")` deve retornar `2`.
```js
assert.equal(countSubstring(testCases[2], searchString[2]), results[2]);
diff --git a/curriculum/challenges/portuguese/10-coding-interview-prep/rosetta-code/count-the-coins.md b/curriculum/challenges/portuguese/10-coding-interview-prep/rosetta-code/count-the-coins.md
index 3e6bd14d1d..653fe38c40 100644
--- a/curriculum/challenges/portuguese/10-coding-interview-prep/rosetta-code/count-the-coins.md
+++ b/curriculum/challenges/portuguese/10-coding-interview-prep/rosetta-code/count-the-coins.md
@@ -1,6 +1,6 @@
---
id: 59713bd26bdeb8a594fb9413
-title: Count the coins
+title: Contar moedas
challengeType: 5
forumTopicId: 302238
dashedName: count-the-coins
@@ -8,51 +8,51 @@ dashedName: count-the-coins
# --description--
-There are four types of common coins in [US](https://en.wikipedia.org/wiki/United_States) currency:
+Existem quatro tipos de moedas comuns no dinheiro dos [EUA](https://en.wikipedia.org/wiki/United_States):
- - quarters (25 cents)
- - dimes (10 cents)
- - nickels (5 cents), and
- - pennies (1 cent)
+ - quarters (25 centavos)
+ - dimes (10 centavos)
+ - nickels (5 centavos) e
+ - pennies (1 centavo)
-
There are six ways to make change for 15 cents:
+
Há seis maneiras de fazer troco com 15 centavos:
- - A dime and a nickel
- - A dime and 5 pennies
+ - Um dime e um nickel
+ - Um dime e 5 pennies
- 3 nickels
- - 2 nickels and 5 pennies
- - A nickel and 10 pennies
+ - 2 nickels e 5 pennies
+ - Um nickel e 10 pennies
- 15 pennies
# --instructions--
-Implement a function to determine how many ways there are to make change for a given input, `cents`, that represents an amount of US pennies using these common coins.
+Implemente uma função para determinar quantas maneiras há para fazer troco para uma determinada entrada, `cents`, que representa uma quantidade de centavos americanos usando essas moedas comuns.
# --hints--
-`countCoins` should be a function.
+`countCoins` deve ser uma função.
```js
assert(typeof countCoins === 'function');
```
-`countCoins(15)` should return `6`.
+`countCoins(15)` deve retornar `6`.
```js
assert.equal(countCoins(15), 6);
```
-`countCoins(85)` shouls return `163`.
+`countCoins(85)` deve retornar `163`.
```js
assert.equal(countCoins(85), 163);
```
-`countCoins(100)` should return `242`.
+`countCoins(100)` deve retornar `242`.
```js
assert.equal(countCoins(100), 242);
diff --git a/curriculum/challenges/portuguese/10-coding-interview-prep/rosetta-code/cramers-rule.md b/curriculum/challenges/portuguese/10-coding-interview-prep/rosetta-code/cramers-rule.md
index 7580e28c50..ea26031094 100644
--- a/curriculum/challenges/portuguese/10-coding-interview-prep/rosetta-code/cramers-rule.md
+++ b/curriculum/challenges/portuguese/10-coding-interview-prep/rosetta-code/cramers-rule.md
@@ -1,6 +1,6 @@
---
id: 59713da0a428c1a62d7db430
-title: Cramer's rule
+title: A regra de Cramer
challengeType: 5
forumTopicId: 302239
dashedName: cramers-rule
@@ -8,43 +8,43 @@ dashedName: cramers-rule
# --description--
-In [linear algebra](https://en.wikipedia.org/wiki/linear algebra "wp: linear algebra"), [Cramer's rule](https://en.wikipedia.org/wiki/Cramer's rule "wp: Cramer's rule") is an explicit formula for the solution of a [system of linear equations](https://en.wikipedia.org/wiki/system of linear equations "wp: system of linear equations") with as many equations as unknowns, valid whenever the system has a unique solution. It expresses the solution in terms of the determinants of the (square) coefficient matrix and of matrices obtained from it by replacing one column by the vector of right hand sides of the equations.
+Em [álgebra linear](https://en.wikipedia.org/wiki/linear algebra "wp: linear algebra"), a [Regra de Cramer](https://en.wikipedia.org/wiki/Cramer's rule "wp: Cramer's rule") é uma fórmula explícita para a solução de um [sistema de equações lineares](https://en.wikipedia.org/wiki/system of linear equations "wp: system of linear equations") com tantas equações quanto variáveis. Essa regra é válida sempre que o sistema tiver uma solução única. Ela exprime a solução em termos dos determinantes da matriz do coeficiente (quadrada) e de matrizes obtidas a partir dela substituindo uma coluna pelo vetor da direita das equações.
-Given
+Dado
$\\left\\{\\begin{matrix}a_1x + b_1y + c_1z&= {\\color{red}d_1}\\\\a_2x + b_2y + c_2z&= {\\color{red}d_2}\\\\a_3x + b_3y + c_3z&= {\\color{red}d_3}\\end{matrix}\\right.$
-which in matrix format is
+que no formato de matriz é
$\\begin{bmatrix} a_1 & b_1 & c_1 \\\\ a_2 & b_2 & c_2 \\\\ a_3 & b_3 & c_3 \\end{bmatrix}\\begin{bmatrix} x \\\\ y \\\\ z \\end{bmatrix}=\\begin{bmatrix} {\\color{red}d_1} \\\\ {\\color{red}d_2} \\\\ {\\color{red}d_3} \\end{bmatrix}.$
-Then the values of $x, y$ and $z$ can be found as follows:
+Então, os valores de $x, y$ e $z$ podem ser encontrados da seguinte forma:
$x = \\frac{\\begin{vmatrix} {\\color{red}d_1} & b_1 & c_1 \\\\ {\\color{red}d_2} & b_2 & c_2 \\\\ {\\color{red}d_3} & b_3 & c_3 \\end{vmatrix} } { \\begin{vmatrix} a_1 & b_1 & c_1 \\\\ a_2 & b_2 & c_2 \\\\ a_3 & b_3 & c_3 \\end{vmatrix}}, \\quad y = \\frac {\\begin{vmatrix} a_1 & {\\color{red}d_1} & c_1 \\\\ a_2 & {\\color{red}d_2} & c_2 \\\\ a_3 & {\\color{red}d_3} & c_3 \\end{vmatrix}} {\\begin{vmatrix} a_1 & b_1 & c_1 \\\\ a_2 & b_2 & c_2 \\\\ a_3 & b_3 & c_3 \\end{vmatrix}}, \\text{ and }z = \\frac { \\begin{vmatrix} a_1 & b_1 & {\\color{red}d_1} \\\\ a_2 & b_2 & {\\color{red}d_2} \\\\ a_3 & b_3 & {\\color{red}d_3} \\end{vmatrix}} {\\begin{vmatrix} a_1 & b_1 & c_1 \\\\ a_2 & b_2 & c_2 \\\\ a_3 & b_3 & c_3 \\end{vmatrix} }.$
# --instructions--
-Given the following system of equations:
+Dado o seguinte sistema de equações:
$\\begin{cases} 2w-x+5y+z=-3 \\\\ 3w+2x+2y-6z=-32 \\\\ w+3x+3y-z=-47 \\\\ 5w-2x-3y+3z=49 \\\\ \\end{cases}$
-solve for $w$, $x$, $y$ and $z$, using Cramer's rule.
+resolva para as variáveis $w$, $x$, $y$ e $z$ usando a Regra de Cramer.
# --hints--
-`cramersRule` should be a function.
+`cramersRule` deve ser uma função.
```js
assert(typeof cramersRule === 'function');
```
-`cramersRule([[2, -1, 5, 1], [3, 2, 2, -6], [1, 3, 3, -1], [5, -2, -3, 3]], [-3, -32, -47, 49])` should return `[2, -12, -4, 1]`.
+`cramersRule([[2, -1, 5, 1], [3, 2, 2, -6], [1, 3, 3, -1], [5, -2, -3, 3]], [-3, -32, -47, 49])` deve retornar `[2, -12, -4, 1]`.
```js
assert.deepEqual(cramersRule(matrices[0], freeTerms[0]), answers[0]);
```
-`cramersRule([[3, 1, 1], [2, 2, 5], [1, -3, -4]], [3, -1, 2])` should return `[1, 1, -1]`.
+`cramersRule([[3, 1, 1], [2, 2, 5], [1, -3, -4]], [3, -1, 2])` deve retornar `[1, 1, -1]`.
```js
assert.deepEqual(cramersRule(matrices[1], freeTerms[1]), answers[1]);
diff --git a/curriculum/challenges/portuguese/10-coding-interview-prep/rosetta-code/cumulative-standard-deviation.md b/curriculum/challenges/portuguese/10-coding-interview-prep/rosetta-code/cumulative-standard-deviation.md
index 28aa14710d..ce99a13136 100644
--- a/curriculum/challenges/portuguese/10-coding-interview-prep/rosetta-code/cumulative-standard-deviation.md
+++ b/curriculum/challenges/portuguese/10-coding-interview-prep/rosetta-code/cumulative-standard-deviation.md
@@ -1,6 +1,6 @@
---
id: 5a23c84252665b21eecc7e03
-title: Cumulative standard deviation
+title: Desvio padrão acumulado
challengeType: 5
forumTopicId: 302240
dashedName: cumulative-standard-deviation
@@ -8,41 +8,41 @@ dashedName: cumulative-standard-deviation
# --description--
-Write a function that takes an array of numbers as parameter and returns the [standard deviation](https://en.wikipedia.org/wiki/Standard Deviation) of the series.
+Escreva uma função que recebe um array de números como parâmetro e retorna o [desvio padrão](https://pt.wikipedia.org/wiki/Desvio_padr%C3%A3o) da série.
# --hints--
-`standardDeviation` should be a function.
+`standardDeviation` deve ser uma função.
```js
assert(typeof standardDeviation == 'function');
```
-`standardDeviation([2, 4, 4, 4, 5, 5, 7, 9])` should return a number.
+`standardDeviation([2, 4, 4, 4, 5, 5, 7, 9])` deve retornar um número.
```js
assert(typeof standardDeviation([2, 4, 4, 4, 5, 5, 7, 9]) == 'number');
```
-`standardDeviation([2, 4, 4, 4, 5, 5, 7, 9])` should return `2`.
+`standardDeviation([2, 4, 4, 4, 5, 5, 7, 9])` deve retornar `2`.
```js
assert.equal(standardDeviation([2, 4, 4, 4, 5, 5, 7, 9]), 2);
```
-`standardDeviation([600, 470, 170, 430, 300])` should return `147.323`.
+`standardDeviation([600, 470, 170, 430, 300])` deve retornar `147.323`.
```js
assert.equal(standardDeviation([600, 470, 170, 430, 300]), 147.323);
```
-`standardDeviation([75, 83, 96, 100, 121, 125])` should return `18.239`.
+`standardDeviation([75, 83, 96, 100, 121, 125])` deve retornar `18.239`.
```js
assert.equal(standardDeviation([75, 83, 96, 100, 121, 125]), 18.239);
```
-`standardDeviation([23, 37, 45, 49, 56, 63, 63, 70, 72, 82])` should return `16.87`.
+`standardDeviation([23, 37, 45, 49, 56, 63, 63, 70, 72, 82])` deve retornar `16.87`.
```js
assert.equal(
@@ -51,7 +51,7 @@ assert.equal(
);
```
-`standardDeviation([271, 354, 296, 301, 333, 326, 285, 298, 327, 316, 287, 314])` should return `22.631`.
+`standardDeviation([271, 354, 296, 301, 333, 326, 285, 298, 327, 316, 287, 314])` deve retornar `22.631`.
```js
assert.equal(