chore(i18n,curriculum): update translations (#44138)
This commit is contained in:
camperbot
GitHub
@ -1,6 +1,6 @@
|
||||
---
|
||||
id: 5900f3ec1000cf542c50fefe
|
||||
title: 'Problem 127: abc-hits'
|
||||
title: 'Problema 127: Trio abc'
|
||||
challengeType: 5
|
||||
forumTopicId: 301754
|
||||
dashedName: problem-127-abc-hits
|
||||
@ -8,38 +8,32 @@ dashedName: problem-127-abc-hits
|
||||
|
||||
# --description--
|
||||
|
||||
The radical of n, rad(n), is the product of distinct prime factors of n. For example, 504 = 23 × 32 × 7, so rad(504) = 2 × 3 × 7 = 42.
|
||||
O radical de $n$, $rad(n)$, é o produto dos fatores primos distintos de $n$. Por exemplo, $504 = 2^3 × 3^2 × 7$, então $rad(504) = 2 × 3 × 7 = 42$.
|
||||
|
||||
We shall define the triplet of positive integers (a, b, c) to be an abc-hit if:
|
||||
Definiremos o trio de números inteiros positivos (a, b, c) como sendo um trio abc se:
|
||||
|
||||
GCD(a, b) = GCD(a, c) = GCD(b, c) = 1
|
||||
1. $GCD(a, b) = GCD(a, c) = GCD(b, c) = 1$
|
||||
2. $a < b$
|
||||
3. $a + b = c$
|
||||
4. $rad(abc) < c$
|
||||
|
||||
a < b
|
||||
Por exemplo, (5, 27, 32) é um trio abc, pois:
|
||||
|
||||
a + b = c
|
||||
1. $GCD(5, 27) = GCD(5, 32) = GCD(27, 32) = 1$
|
||||
2. $5 < 27$
|
||||
3. $5 + 27 = 32$
|
||||
4. $rad(4320) = 30 < 32$
|
||||
|
||||
rad(abc) < c
|
||||
Ocorre que os trios abc são bastante raros e há somente 31 deles para $c < 1000$, com a $\sum{c} = 12523$.
|
||||
|
||||
For example, (5, 27, 32) is an abc-hit, because:
|
||||
|
||||
GCD(5, 27) = GCD(5, 32) = GCD(27, 32) = 1
|
||||
|
||||
5 < 27
|
||||
|
||||
5 + 27 = 32
|
||||
|
||||
rad(4320) = 30 < 32
|
||||
|
||||
It turns out that abc-hits are quite rare and there are only thirty-one abc-hits for c < 1000, with ∑c = 12523.
|
||||
|
||||
Find ∑c for c < 120000.
|
||||
Encontre a $\sum{c}$ para $c < 120000$.
|
||||
|
||||
# --hints--
|
||||
|
||||
`euler127()` should return 18407904.
|
||||
`abcHits()` deve retornar `18407904`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(euler127(), 18407904);
|
||||
assert.strictEqual(abcHits(), 18407904);
|
||||
```
|
||||
|
||||
# --seed--
|
||||
@ -47,12 +41,12 @@ assert.strictEqual(euler127(), 18407904);
|
||||
## --seed-contents--
|
||||
|
||||
```js
|
||||
function euler127() {
|
||||
function abcHits() {
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
euler127();
|
||||
abcHits();
|
||||
```
|
||||
|
||||
# --solutions--
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
---
|
||||
id: 5900f3ec1000cf542c50feff
|
||||
title: 'Problem 128: Hexagonal tile differences'
|
||||
title: 'Problema 128: Diferenças de blocos hexagonais'
|
||||
challengeType: 5
|
||||
forumTopicId: 301755
|
||||
dashedName: problem-128-hexagonal-tile-differences
|
||||
@ -8,18 +8,30 @@ dashedName: problem-128-hexagonal-tile-differences
|
||||
|
||||
# --description--
|
||||
|
||||
A hexagonal tile with number 1 is surrounded by a ring of six hexagonal tiles, starting at "12 o'clock" and numbering the tiles 2 to 7 in an anti-clockwise direction.
|
||||
Um bloco hexagonal com o número 1 é cercado por um anel de seis blocos hexagonais, começando às "12 horas" e numerando os blocos de 2 a 7 em direção anti-horária.
|
||||
|
||||
New rings are added in the same fashion, with the next rings being numbered 8 to 19, 20 to 37, 38 to 61, and so on. The diagram below shows the first three rings.
|
||||
Novos anéis são adicionados da mesma forma, com os próximos anéis sendo numerados de 8 a 19, 20 a 37, 38 a 61, e assim por diante. O diagrama abaixo mostra os três primeiros anéis.
|
||||
|
||||
By finding the difference between tile n and each of its six neighbours we shall define PD(n) to be the number of those differences which are prime. For example, working clockwise around tile 8 the differences are 12, 29, 11, 6, 1, and 13. So PD(8) = 3. In the same way, the differences around tile 17 are 1, 17, 16, 1, 11, and 10, hence PD(17) = 2. It can be shown that the maximum value of PD(n) is 3. If all of the tiles for which PD(n) = 3 are listed in ascending order to form a sequence, the 10th tile would be 271. Find the 2000th tile in this sequence.
|
||||
<img class="img-responsive center-block" alt="três primeiros anéis de blocos hexagonais dispostos com números de 1 a 37 e com os blocos 8 e 17 destacados" src="https://cdn.freecodecamp.org/curriculum/project-euler/hexagonal-tile-differences.png" style="background-color: white; padding: 10px;" />
|
||||
|
||||
Ao calcular a diferença entre o bloco $n$ e cada um de seus seis vizinhos, definiremos $PD(n)$ como o número dessas diferenças primas, que são primos.
|
||||
|
||||
Por exemplo, trabalhando no sentido horário em torno do bloco 8, as diferenças são 12, 29, 11, 6, 1 e 13. Portanto, $PD(8) = 3$.
|
||||
|
||||
Da mesma forma, as diferenças em torno do bloco 17 são 1, 17, 16, 1, 11 e 10. Portanto, $PD(17) = 2$.
|
||||
|
||||
Pode-se ser mostrar que o valor máximo de $PD(n)$ é $3$.
|
||||
|
||||
Se todos os blocos para os quais $PD(n) = 3$ estiverem listados em ordem ascendente para formar uma sequência, o décimo bloco seria 271.
|
||||
|
||||
Encontre o 2000º bloco desta sequência.
|
||||
|
||||
# --hints--
|
||||
|
||||
`euler128()` should return 14516824220.
|
||||
`hexagonalTile()` deve retornar `14516824220`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(euler128(), 14516824220);
|
||||
assert.strictEqual(hexagonalTile(), 14516824220);
|
||||
```
|
||||
|
||||
# --seed--
|
||||
@ -27,12 +39,12 @@ assert.strictEqual(euler128(), 14516824220);
|
||||
## --seed-contents--
|
||||
|
||||
```js
|
||||
function euler128() {
|
||||
function hexagonalTile() {
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
euler128();
|
||||
hexagonalTile();
|
||||
```
|
||||
|
||||
# --solutions--
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
---
|
||||
id: 5900f3ef1000cf542c50ff01
|
||||
title: 'Problem 129: Repunit divisibility'
|
||||
title: 'Problema 129: Divisibilidade de repunits'
|
||||
challengeType: 5
|
||||
forumTopicId: 301756
|
||||
dashedName: problem-129-repunit-divisibility
|
||||
@ -8,20 +8,20 @@ dashedName: problem-129-repunit-divisibility
|
||||
|
||||
# --description--
|
||||
|
||||
A number consisting entirely of ones is called a repunit. We shall define R(k) to be a repunit of length k; for example, R(6) = 111111.
|
||||
Em inglês, um número que consiste apenas de 1s é chamado de repunit. Definiremos $R(k)$ como sendo um repunit de comprimento $k$. Por exemplo, $R(6) = 111111$.
|
||||
|
||||
Given that n is a positive integer and GCD(n, 10) = 1, it can be shown that there always exists a value, k, for which R(k) is divisible by n, and let A(n) be the least such value of k; for example, A(7) = 6 and A(41) = 5.
|
||||
Dado que $n$ é um número inteiro positivo e que o máximo divisor comum $GCD(n, 10) = 1$, pode-se mostrar que sempre existe um valor, $k$, para o qual $R(k)$ é divisível por $n$. Além disso, consideremos $A(n)$ o menor dos valores de $k$ (por exemplo, $A(7) = 6$ e $A(41) = 5$).
|
||||
|
||||
The least value of n for which A(n) first exceeds ten is 17.
|
||||
O menor valor de $n$ para o qual o $A(n)$ excede dez é 17.
|
||||
|
||||
Find the least value of n for which A(n) first exceeds one-million.
|
||||
Encontre o menor valor de $n$ para o qual $A(n)$ excede um milhão.
|
||||
|
||||
# --hints--
|
||||
|
||||
`euler129()` should return 1000023.
|
||||
`repunitDivisibility()` deve retornar `1000023`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(euler129(), 1000023);
|
||||
assert.strictEqual(repunitDivisibility(), 1000023);
|
||||
```
|
||||
|
||||
# --seed--
|
||||
@ -29,12 +29,12 @@ assert.strictEqual(euler129(), 1000023);
|
||||
## --seed-contents--
|
||||
|
||||
```js
|
||||
function euler129() {
|
||||
function repunitDivisibility() {
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
euler129();
|
||||
repunitDivisibility();
|
||||
```
|
||||
|
||||
# --solutions--
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
---
|
||||
id: 5900f3ee1000cf542c50ff00
|
||||
title: 'Problem 130: Composites with prime repunit property'
|
||||
title: 'Problema 130: Compostos com propriedade de primo repunit'
|
||||
challengeType: 5
|
||||
forumTopicId: 301758
|
||||
dashedName: problem-130-composites-with-prime-repunit-property
|
||||
@ -8,22 +8,22 @@ dashedName: problem-130-composites-with-prime-repunit-property
|
||||
|
||||
# --description--
|
||||
|
||||
A number consisting entirely of ones is called a repunit. We shall define R(k) to be a repunit of length k; for example, R(6) = 111111.
|
||||
Em inglês, um número que consiste apenas de 1s é chamado de repunit. Definiremos $R(k)$ como sendo um repunit de comprimento $k$. Por exemplo, $R(6) = 111111$.
|
||||
|
||||
Given that n is a positive integer and GCD(n, 10) = 1, it can be shown that there always exists a value, k, for which R(k) is divisible by n, and let A(n) be the least such value of k; for example, A(7) = 6 and A(41) = 5.
|
||||
Dado que $n$ é um número inteiro positivo e que o máximo divisor comum $GCD(n, 10) = 1$, pode-se mostrar que sempre existe um valor, $k$, para o qual $R(k)$ é divisível por $n$. Além disso, consideremos $A(n)$ o menor dos valores de $k$ (por exemplo, $A(7) = 6$ e $A(41) = 5$).
|
||||
|
||||
You are given that for all primes, p > 5, that p − 1 is divisible by A(p). For example, when p = 41, A(41) = 5, and 40 is divisible by 5.
|
||||
Você é informado, para todos os números primos, $p > 5$, que $p − 1$ é divisível por $A(p)$. Por exemplo, quando $p = 41, A(41) = 5$ e 40 é divisível por 5.
|
||||
|
||||
However, there are rare composite values for which this is also true; the first five examples being 91, 259, 451, 481, and 703.
|
||||
No entanto, há valores compostos raros para os quais isto também é verdadeiro. Os cinco primeiros exemplos são 91, 259, 451, 481 e 703.
|
||||
|
||||
Find the sum of the first twenty-five composite values of n for whichGCD(n, 10) = 1 and n − 1 is divisible by A(n).
|
||||
Encontre a soma dos primeiros vinte e cinco valores compostos de $n$ para os quais o máximo divisor comum, $GCD(n, 10) = 1$, e $n - 1$ é divisível por $A(n)$.
|
||||
|
||||
# --hints--
|
||||
|
||||
`euler130()` should return 149253.
|
||||
`compositeRepunit()` deve retornar `149253`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(euler130(), 149253);
|
||||
assert.strictEqual(compositeRepunit(), 149253);
|
||||
```
|
||||
|
||||
# --seed--
|
||||
@ -31,12 +31,12 @@ assert.strictEqual(euler130(), 149253);
|
||||
## --seed-contents--
|
||||
|
||||
```js
|
||||
function euler130() {
|
||||
function compositeRepunit() {
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
euler130();
|
||||
compositeRepunit();
|
||||
```
|
||||
|
||||
# --solutions--
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
---
|
||||
id: 5900f3f21000cf542c50ff04
|
||||
title: 'Problem 133: Repunit nonfactors'
|
||||
title: 'Problema 133: Não fatores repunit'
|
||||
challengeType: 5
|
||||
forumTopicId: 301761
|
||||
dashedName: problem-133-repunit-nonfactors
|
||||
@ -8,20 +8,20 @@ dashedName: problem-133-repunit-nonfactors
|
||||
|
||||
# --description--
|
||||
|
||||
A number consisting entirely of ones is called a repunit. We shall define R(k) to be a repunit of length k; for example, R(6) = 111111.
|
||||
Em inglês, um número que consiste apenas de 1s é chamado de repunit. Definiremos $R(k)$ como sendo um repunit de comprimento $k$. Por exemplo, $R(6) = 111111$.
|
||||
|
||||
Let us consider repunits of the form R(10n).
|
||||
Vamos considerar os repunits no formato $R({10}^n)$.
|
||||
|
||||
Although R(10), R(100), or R(1000) are not divisible by 17, R(10000) is divisible by 17. Yet there is no value of n for which R(10n) will divide by 19. In fact, it is remarkable that 11, 17, 41, and 73 are the only four primes below one-hundred that can be a factor of R(10n).
|
||||
Embora $R(10)$, $R(100)$ ou $R(1000)$ não sejam divisíveis por 17, $R(10000)$ é. No entanto, não há valor de n para o qual $R({10}^n)$ seja divisível por 19. Curiosamente, 11, 17, 41 e 73 são os únicos quatro primos abaixo de cem que podem ser um fator de $R({10}^n)$.
|
||||
|
||||
Find the sum of all the primes below one-hundred thousand that will never be a factor of R(10n).
|
||||
Encontre a soma de todos os primos abaixo de cem mil que nunca serão um fator de $R({10}^n)$.
|
||||
|
||||
# --hints--
|
||||
|
||||
`euler133()` should return 453647705.
|
||||
`repunitNonfactors()` deve retornar `453647705`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(euler133(), 453647705);
|
||||
assert.strictEqual(repunitNonfactors(), 453647705);
|
||||
```
|
||||
|
||||
# --seed--
|
||||
@ -29,12 +29,12 @@ assert.strictEqual(euler133(), 453647705);
|
||||
## --seed-contents--
|
||||
|
||||
```js
|
||||
function euler133() {
|
||||
function repunitNonfactors() {
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
euler133();
|
||||
repunitNonfactors();
|
||||
```
|
||||
|
||||
# --solutions--
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
---
|
||||
id: 5900f3f21000cf542c50ff05
|
||||
title: 'Problem 134: Prime pair connection'
|
||||
title: 'Problema 134: Conexão de pares de números primos'
|
||||
challengeType: 5
|
||||
forumTopicId: 301762
|
||||
dashedName: problem-134-prime-pair-connection
|
||||
@ -8,18 +8,18 @@ dashedName: problem-134-prime-pair-connection
|
||||
|
||||
# --description--
|
||||
|
||||
Consider the consecutive primes p1 = 19 and p2 = 23. It can be verified that 1219 is the smallest number such that the last digits are formed by p1 whilst also being divisible by p2.
|
||||
Considere os primos consecutivos $p_1 = 19$ e $p_2 = 23$. É possível verificar que 1219 é o menor número, tal que os últimos algarismos são formados por $p_1$, ao mesmo tempo em que são divisíveis por $p_2$.
|
||||
|
||||
In fact, with the exception of p1 = 3 and p2 = 5, for every pair of consecutive primes, p2 > p1, there exist values of n for which the last digits are formed by p1 and n is divisible by p2. Let S be the smallest of these values of n.
|
||||
De fato, com exceção de $p_1 = 3$ e $p_2 = 5$, para cada par de números primos consecutivos, $p_2 > p_1$, existem valores de $n$ para os quais os últimos algarismos são formados por $p_1$ e $n$ é divisível por $p_2$. Considere $S$ o menor destes valores de $n$.
|
||||
|
||||
Find ∑ S for every pair of consecutive primes with 5 ≤ p1 ≤ 1000000.
|
||||
Encontre $\sum{S}$ para cada par de números primos consecutivos, com $5 ≤ p_1 ≤ 1000000$.
|
||||
|
||||
# --hints--
|
||||
|
||||
`euler134()` should return 18613426663617120.
|
||||
`primePairConnection()` deve retornar `18613426663617120`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(euler134(), 18613426663617120);
|
||||
assert.strictEqual(primePairConnection(), 18613426663617120);
|
||||
```
|
||||
|
||||
# --seed--
|
||||
@ -27,12 +27,12 @@ assert.strictEqual(euler134(), 18613426663617120);
|
||||
## --seed-contents--
|
||||
|
||||
```js
|
||||
function euler134() {
|
||||
function primePairConnection() {
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
euler134();
|
||||
primePairConnection();
|
||||
```
|
||||
|
||||
# --solutions--
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
---
|
||||
id: 5900f3f31000cf542c50ff06
|
||||
title: 'Problem 135: Same differences'
|
||||
title: 'Problema 135: Mesmas diferenças'
|
||||
challengeType: 5
|
||||
forumTopicId: 301763
|
||||
dashedName: problem-135-same-differences
|
||||
@ -8,20 +8,20 @@ dashedName: problem-135-same-differences
|
||||
|
||||
# --description--
|
||||
|
||||
Given the positive integers, x, y, and z, are consecutive terms of an arithmetic progression, the least value of the positive integer, n, for which the equation, x2 − y2 − z2 = n, has exactly two solutions is n = 27:
|
||||
Sendo os números inteiros positivos, $x$, $y$ e $z$, termos consecutivos de uma progressão aritmética, o menor valor do inteiro positivo, $n$, para o qual a equação, $x^2 - y^2 - z^2 = n$, tem exatamente duas soluções é $n = 27$:
|
||||
|
||||
342 − 272 − 202 = 122 − 92 − 62 = 27
|
||||
$$34^2 − 27^2 − 20^2 = 12^2 − 9^2 − 6^2 = 27$$
|
||||
|
||||
It turns out that n = 1155 is the least value which has exactly ten solutions.
|
||||
Ocorre que $n = 1155$ é o menor valor para o qual a equação tem exatamente dez soluções.
|
||||
|
||||
How many values of n less than one million have exactly ten distinct solutions?
|
||||
Quantos valores de $n$ abaixo de um milhão têm exatamente dez soluções distintas?
|
||||
|
||||
# --hints--
|
||||
|
||||
`euler135()` should return 4989.
|
||||
`sameDifferences()` deve retornar `4989`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(euler135(), 4989);
|
||||
assert.strictEqual(sameDifferences(), 4989);
|
||||
```
|
||||
|
||||
# --seed--
|
||||
@ -29,12 +29,12 @@ assert.strictEqual(euler135(), 4989);
|
||||
## --seed-contents--
|
||||
|
||||
```js
|
||||
function euler135() {
|
||||
function sameDifferences() {
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
euler135();
|
||||
sameDifferences();
|
||||
```
|
||||
|
||||
# --solutions--
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
---
|
||||
id: 5900f3cc1000cf542c50fede
|
||||
title: 'Problem 95: Amicable chains'
|
||||
title: 'Problema 95: Cadeias amigáveis'
|
||||
challengeType: 5
|
||||
forumTopicId: 302212
|
||||
dashedName: problem-95-amicable-chains
|
||||
@ -8,45 +8,45 @@ dashedName: problem-95-amicable-chains
|
||||
|
||||
# --description--
|
||||
|
||||
The proper divisors of a number are all the divisors excluding the number itself. For example, the proper divisors of 28 are 1, 2, 4, 7, and 14. As the sum of these divisors is equal to 28, we call it a perfect number.
|
||||
Os divisores apropriados de um número são todos os seus divisores excetuando o número em si. Por exemplo, os divisores adequados de 28 são 1, 2, 4, 7 e 14. Como a soma desses divisores é igual a 28, chamamos esse número de um número perfeito.
|
||||
|
||||
Interestingly the sum of the proper divisors of 220 is 284 and the sum of the proper divisors of 284 is 220, forming a chain of two numbers. For this reason, 220 and 284 are called an amicable pair.
|
||||
Curiosamente, a soma dos divisores adequados de 220 é 284 e a soma dos divisores adequados de 284 é 220, formando uma cadeia de dois números. Por esta razão, 220 e 284 são chamados de par amigável.
|
||||
|
||||
Perhaps less well known are longer chains. For example, starting with 12496, we form a chain of five numbers:
|
||||
Talvez menos conhecidas sejam as cadeias mais longas. Por exemplo, começando com 12496, formamos uma cadeia de cinco números:
|
||||
|
||||
$$ 12496 → 14288 → 15472 → 14536 → 14264 \\,(→ 12496 → \cdots) $$
|
||||
|
||||
Since this chain returns to its starting point, it is called an amicable chain.
|
||||
Como essa cadeia retorna ao seu ponto de partida, ela é chamada de uma cadeia amigável.
|
||||
|
||||
Find the smallest member of the longest amicable chain with no element exceeding `limit`.
|
||||
Encontre o menor membro da maior cadeia amigável sem elementos que excedam o `limit`.
|
||||
|
||||
# --hints--
|
||||
|
||||
`amicableChains(300)` should return a number.
|
||||
`amicableChains(300)` deve retornar um número.
|
||||
|
||||
```js
|
||||
assert(typeof amicableChains(300) === 'number');
|
||||
```
|
||||
|
||||
`amicableChains(300)` should return `220`.
|
||||
`amicableChains(300)` deve retornar `220`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(amicableChains(300), 220);
|
||||
```
|
||||
|
||||
`amicableChains(15000)` should return `220`.
|
||||
`amicableChains(15000)` deve retornar `220`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(amicableChains(15000), 220);
|
||||
```
|
||||
|
||||
`amicableChains(100000)` should return `12496`.
|
||||
`amicableChains(100000)` deve retornar `12496`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(amicableChains(100000), 12496);
|
||||
```
|
||||
|
||||
`amicableChains(1000000)` should return `14316`.
|
||||
`amicableChains(1000000)` deve retornar `14316`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(amicableChains(1000000), 14316);
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
---
|
||||
id: 5900f3ce1000cf542c50fee0
|
||||
title: 'Problem 97: Large non-Mersenne prime'
|
||||
title: 'Problema 97: Grande número primo que não seja de Mersenne'
|
||||
challengeType: 5
|
||||
forumTopicId: 302214
|
||||
dashedName: problem-97-large-non-mersenne-prime
|
||||
@ -8,39 +8,39 @@ dashedName: problem-97-large-non-mersenne-prime
|
||||
|
||||
# --description--
|
||||
|
||||
The first known prime found to exceed one million digits was discovered in 1999, and is a Mersenne prime of the form $2^{6972593} − 1$; it contains exactly 2,098,960 digits. Subsequently other Mersenne primes, of the form $2^p − 1$, have been found which contain more digits.
|
||||
O primeiro número primo descoberto que excedia um milhão de algarismos foi descoberto em 1999. Ele é um primo de Mersenne no formato $2^{6972593} - 1$ e contém exatamente 2.098.960 algarismos. Depois disso, outros primos de Mersenne, no formato $2^p - 1$, foram encontrados e contendo mais dígitos.
|
||||
|
||||
However, in 2004 there was found a massive non-Mersenne prime which contains 2,357,207 digits: $28433 × 2^{7830457} + 1$.
|
||||
No entanto, em 2004, foi encontrado um número primo enorme e não sendo um primo de Mersenne que contém 2.357.207 algarismos: $28433 × 2^{7830457} + 1$.
|
||||
|
||||
Find the last ten digits of that non-Mersenne prime in the form $multiplier × 2^{power} + 1$.
|
||||
Encontre os últimos dez dígitos daquele primo que não seja de Mersenne na forma $multiplicador × 2^{potência} + 1$.
|
||||
|
||||
# --hints--
|
||||
|
||||
`largeNonMersennePrime(19, 6833086)` should return a string.
|
||||
`largeNonMersennePrime(19, 6833086)` deve retornar uma string.
|
||||
|
||||
```js
|
||||
assert(typeof largeNonMersennePrime(19, 6833086) === 'string');
|
||||
```
|
||||
|
||||
`largeNonMersennePrime(19, 6833086)` should return the string `3637590017`.
|
||||
`largeNonMersennePrime(19, 6833086)` deve retornar a string `3637590017`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(largeNonMersennePrime(19, 6833086), '3637590017');
|
||||
```
|
||||
|
||||
`largeNonMersennePrime(27, 7046834)` should return the string `0130771969`.
|
||||
`largeNonMersennePrime(27, 7046834)` deve retornar a string `0130771969`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(largeNonMersennePrime(27, 7046834), '0130771969');
|
||||
```
|
||||
|
||||
`largeNonMersennePrime(6679881, 6679881)` should return the string `4455386113`.
|
||||
`largeNonMersennePrime(6679881, 6679881)` deve retornar a string `4455386113`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(largeNonMersennePrime(6679881, 6679881), '4455386113');
|
||||
```
|
||||
|
||||
`largeNonMersennePrime(28433, 7830457)` should return the string `8739992577`.
|
||||
`largeNonMersennePrime(28433, 7830457)` deve retornar a string `8739992577`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(largeNonMersennePrime(28433, 7830457), '8739992577');
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
---
|
||||
id: 5900f3cf1000cf542c50fee1
|
||||
title: 'Problem 98: Anagramic squares'
|
||||
title: 'Problema 98: Quadrados anagrâmicos'
|
||||
challengeType: 5
|
||||
forumTopicId: 302215
|
||||
dashedName: problem-98-anagramic-squares
|
||||
@ -8,35 +8,35 @@ dashedName: problem-98-anagramic-squares
|
||||
|
||||
# --description--
|
||||
|
||||
By replacing each of the letters in the word CARE with 1, 2, 9, and 6 respectively, we form a square number: $1296 = 36^2$. What is remarkable is that, by using the same digital substitutions, the anagram, RACE, also forms a square number: $9216 = 96^2$. We shall call CARE (and RACE) a square anagram word pair and specify further that leading zeroes are not permitted, neither may a different letter have the same digital value as another letter.
|
||||
Ao substituir cada uma das letras na palavra CARE por 1, 2, 9 e 6, respectivamente, formamos um número quadrado: $1296 = 36^2$. O que é notável é que, usando as mesmas substituições digitais, o anagrama, RACE, também formamos um número quadrado: $9216 = 96^2$. Vamos chamar CARE (e RACE) de um par de palavras de anagrama quadrado. Especificaremos mais adiante que zeros à frente do número não são permitidos, nem uma outra letra pode ter o mesmo valor numérico que outra.
|
||||
|
||||
Using the `words` array, find all the square anagram word pairs (a palindromic word is NOT considered to be an anagram of itself).
|
||||
Usando o array `words`, encontre todos os pares de palavras que são anagramas quadrados (uma palavra palindrômica NÃO é considerada um anagrama de si mesmo).
|
||||
|
||||
What is the largest square number formed by any member of such a pair?
|
||||
Qual é o maior número quadrado formado por algum membro de um par desse tipo?
|
||||
|
||||
**Note:** All anagrams formed must be contained in the given `words` array.
|
||||
**Observação:** todos os anagramas formados devem estar contidos no array dado `words`.
|
||||
|
||||
# --hints--
|
||||
|
||||
`anagramicSquares(['CARE', 'RACE'])` should return a number.
|
||||
`anagramicSquares(['CARE', 'RACE'])` deve retornar um número.
|
||||
|
||||
```js
|
||||
assert(typeof anagramicSquares(['CARE', 'RACE']) === 'number');
|
||||
```
|
||||
|
||||
`anagramicSquares(['CARE', 'RACE'])` should return `9216`.
|
||||
`anagramicSquares(['CARE', 'RACE'])` deve retornar `9216`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(anagramicSquares(['CARE', 'RACE']), 9216);
|
||||
```
|
||||
|
||||
`anagramicSquares(testWords1)` should return `4761`.
|
||||
`anagramicSquares(testWords1)` deve retornar `4761`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(anagramicSquares(_testWords1), 4761);
|
||||
```
|
||||
|
||||
`anagramicSquares(testWords2)` should return `18769`.
|
||||
`anagramicSquares(testWords2)` deve retornar `18769`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(anagramicSquares(_testWords2), 18769);
|
||||
|
||||
Reference in New Issue
Block a user