chore(i18n,curriculum): processed translations (#43361)
This commit is contained in:
camperbot
GitHub
@ -1,6 +1,6 @@
|
||||
---
|
||||
id: 5900f4801000cf542c50ff93
|
||||
title: 'Problem 276: Primitive Triangles'
|
||||
title: 'Problema 276: Triângulos primitivos'
|
||||
challengeType: 5
|
||||
forumTopicId: 301926
|
||||
dashedName: problem-276-primitive-triangles
|
||||
@ -8,18 +8,18 @@ dashedName: problem-276-primitive-triangles
|
||||
|
||||
# --description--
|
||||
|
||||
Consider the triangles with integer sides a, b and c with a ≤ b ≤ c.
|
||||
Considere os triângulos com os lados inteiros $a$, $b$ e $c$ com $a ≤ b ≤ c$.
|
||||
|
||||
An integer sided triangle (a,b,c) is called primitive if gcd(a,b,c)=1.
|
||||
Um triângulo que tem seus lados sendo números inteiros $(a,b,c)$ é chamado primitivo se $gcd(a,b,c) = 1$.
|
||||
|
||||
How many primitive integer sided triangles exist with a perimeter not exceeding 10 000 000?
|
||||
Quantos triângulos primitivos (com os lados sendo números inteiros) existem com um perímetro que não excede $10\\,000\\,000$?
|
||||
|
||||
# --hints--
|
||||
|
||||
`euler276()` should return 5777137137739633000.
|
||||
`primitiveTriangles()` deve retornar `5777137137739633000`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(euler276(), 5777137137739633000);
|
||||
assert.strictEqual(primitiveTriangles(), 5777137137739633000);
|
||||
```
|
||||
|
||||
# --seed--
|
||||
@ -27,12 +27,12 @@ assert.strictEqual(euler276(), 5777137137739633000);
|
||||
## --seed-contents--
|
||||
|
||||
```js
|
||||
function euler276() {
|
||||
function primitiveTriangles() {
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
euler276();
|
||||
primitiveTriangles();
|
||||
```
|
||||
|
||||
# --solutions--
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
---
|
||||
id: 5900f3a91000cf542c50febc
|
||||
title: 'Problem 61: Cyclical figurate numbers'
|
||||
title: 'Problema 61: Números cíclicos'
|
||||
challengeType: 5
|
||||
forumTopicId: 302173
|
||||
dashedName: problem-61-cyclical-figurate-numbers
|
||||
@ -8,52 +8,52 @@ dashedName: problem-61-cyclical-figurate-numbers
|
||||
|
||||
# --description--
|
||||
|
||||
Triangle, square, pentagonal, hexagonal, heptagonal, and octagonal numbers are all figurate (polygonal) numbers and are generated by the following formulae:
|
||||
Números triângulares, quadrado, pentagonais, hexagonais, heptagonais e octogonal são números figurativos (poligonais) e são gerados pelas seguintes fórmulas:
|
||||
|
||||
| Type of Number | Formula | Sequence |
|
||||
| Tipo de número | Fórmula | Sequência |
|
||||
| -------------- | ----------------------------- | --------------------- |
|
||||
| Triangle | $P_3(n) = \frac{n(n+1)}{2}$ | 1, 3, 6, 10, 15, ... |
|
||||
| Square | $P_4(n) = n^2$ | 1, 4, 9, 16, 25, ... |
|
||||
| Triangular | $P_3(n) = \frac{n(n+1)}{2}$ | 1, 3, 6, 10, 15, ... |
|
||||
| Quadrado | $P_4(n) = n^2$ | 1, 4, 9, 16, 25, ... |
|
||||
| Pentagonal | $P_5(n) = \frac{n(3n−1)}2$ | 1, 5, 12, 22, 35, ... |
|
||||
| Hexagonal | $P_6(n) = n(2n−1)$ | 1, 6, 15, 28, 45, ... |
|
||||
| Heptagonal | $P_7(n) = \frac{n(5n−3)}{2}$ | 1, 7, 18, 34, 55, ... |
|
||||
| Octagonal | $P_8(n) = n(3n−2)$ | 1, 8, 21, 40, 65, ... |
|
||||
|
||||
The ordered set of three 4-digit numbers: 8128, 2882, 8281, has three interesting properties.
|
||||
O conjunto ordenado de três números que possuem 4 algarismos, 8128, 2882, 8281, possui três propriedades interessantes.
|
||||
|
||||
1. The set is cyclic, in that the last two digits of each number is the first two digits of the next number (including the last number with the first).
|
||||
2. Each polygonal type: triangle ($P_3(127) = 8128$), square ($P_4(91) = 8281$), and pentagonal ($P_5(44) = 2882$), is represented by a different number in the set.
|
||||
3. This is the only set of 4-digit numbers with this property.
|
||||
1. O conjunto é cíclico. Podemos notar que os dois últimos dígitos de cada número são os dois primeiros dígitos do próximo número (incluindo o último número com o primeiro).
|
||||
2. Cada tipo poligonal, triângulo ($P_3(127) = 8128$), quadrado ($P_4(91) = 8281$) e pentagonal ($P_5(44) = 2882$), é representado por um número diferente no conjunto.
|
||||
3. Este é o único conjunto de números de 4 algarismos com estas propriedades.
|
||||
|
||||
Find the sum of all numbers in ordered sets of `n` cyclic 4-digit numbers for which each of the $P_3$ to $P_{n + 2}$ polygonal types, is represented by a different number in the set.
|
||||
Calcule a soma de todos os números em conjuntos ordenados de `n` números de 4 algarismos cíclicos, onde cada tipo poligonal de $P_3$ a $P_{n + 2}$ é representado por um número diferente no conjunto.
|
||||
|
||||
# --hints--
|
||||
|
||||
`cyclicalFigurateNums(3)` should return a number.
|
||||
`cyclicalFigurateNums(3)` deve retornar um número.
|
||||
|
||||
```js
|
||||
assert(typeof cyclicalFigurateNums(3) === 'number');
|
||||
```
|
||||
|
||||
`cyclicalFigurateNums(3)` should return `19291`.
|
||||
`cyclicalFigurateNums(3)` deve retornar `19291`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(cyclicalFigurateNums(3), 19291);
|
||||
```
|
||||
|
||||
`cyclicalFigurateNums(4)` should return `28684`.
|
||||
`cyclicalFigurateNums(4)` deve retornar `28684`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(cyclicalFigurateNums(4), 28684);
|
||||
```
|
||||
|
||||
`cyclicalFigurateNums(5)` should return `76255`.
|
||||
`cyclicalFigurateNums(5)` deve retornar `76255`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(cyclicalFigurateNums(5), 76255);
|
||||
```
|
||||
|
||||
`cyclicalFigurateNums(6)` should return `28684`.
|
||||
`cyclicalFigurateNums(6)` deve retornar `28684`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(cyclicalFigurateNums(6), 28684);
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
---
|
||||
id: 5900f3aa1000cf542c50febd
|
||||
title: 'Problem 62: Cubic permutations'
|
||||
title: 'Problema 62: Permutações cúbicas'
|
||||
challengeType: 5
|
||||
forumTopicId: 302174
|
||||
dashedName: problem-62-cubic-permutations
|
||||
@ -8,37 +8,37 @@ dashedName: problem-62-cubic-permutations
|
||||
|
||||
# --description--
|
||||
|
||||
The cube, 41063625 ($345^3$), can be permuted to produce two other cubes: 56623104 ($384^3$) and 66430125 ($405^3$). In fact, 41063625 is the smallest cube which has exactly three permutations of its digits which are also cube.
|
||||
O número 41063625 é o resultado do cubo ($345^3$). Esse número pode ser permutado para produzir dois outros números que também são resultados de um cubo: 56623104 ($384^3$) e 66430125 ($405^3$). 41063625 é o menor número que tem exatamente três permutações dos seus dígitos e essas permutações também são o resultado de um cubo.
|
||||
|
||||
Find the smallest cube for which exactly `n` permutations of its digits are cube.
|
||||
Encontre o menor cubo onde `n` permutações de seus dígitos são cubos.
|
||||
|
||||
# --hints--
|
||||
|
||||
`cubicPermutations(2)` should return a number.
|
||||
`cubicPermutations(2)` deve retornar um número.
|
||||
|
||||
```js
|
||||
assert(typeof cubicPermutations(2) === 'number');
|
||||
```
|
||||
|
||||
`cubicPermutations(2)` should return `125`.
|
||||
`cubicPermutations(2)` deve retornar `125`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(cubicPermutations(2), 125);
|
||||
```
|
||||
|
||||
`cubicPermutations(3)` should return `41063625`.
|
||||
`cubicPermutations(3)` deve retornar `41063625`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(cubicPermutations(3), 41063625);
|
||||
```
|
||||
|
||||
`cubicPermutations(4)` should return `1006012008`.
|
||||
`cubicPermutations(4)` deve retornar `1006012008`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(cubicPermutations(4), 1006012008);
|
||||
```
|
||||
|
||||
`cubicPermutations(5)` should return `127035954683`.
|
||||
`cubicPermutations(5)` deve retornar `127035954683`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(cubicPermutations(5), 127035954683);
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
---
|
||||
id: 5900f3ab1000cf542c50febe
|
||||
title: 'Problem 63: Powerful digit counts'
|
||||
title: 'Problema 63: Contagem poderosa de dígitos'
|
||||
challengeType: 5
|
||||
forumTopicId: 302175
|
||||
dashedName: problem-63-powerful-digit-counts
|
||||
@ -8,73 +8,73 @@ dashedName: problem-63-powerful-digit-counts
|
||||
|
||||
# --description--
|
||||
|
||||
The 5-digit number, 16807 = 7<sup>5</sup>, is also a fifth power. Similarly, the 9-digit number, 134217728 = 8<sup>9</sup>, is a ninth power.
|
||||
O número de 5 algarismos, 16807 = 7<sup>5</sup>, também é uma quinta potência. Da mesma forma, o número de 9 algarismos, 134217728 = 8<sup>9</sup>, é uma nona potência.
|
||||
|
||||
Complete the function so that it returns how many positive integers are of length `n` and an `n`th power.
|
||||
Complete a função para que ela retorne quantos números inteiros e positivos são da `n`-ésima potência e de comprimento `n`.
|
||||
|
||||
# --hints--
|
||||
|
||||
`powerfulDigitCounts(1)` should return a number.
|
||||
`powerfulDigitCounts(1)` deve retornar um número.
|
||||
|
||||
```js
|
||||
assert(typeof powerfulDigitCounts(1) === 'number');
|
||||
```
|
||||
|
||||
`powerfulDigitCounts(1)` should return `9`.
|
||||
`powerfulDigitCounts(1)` deve retornar `9`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(powerfulDigitCounts(1), 9);
|
||||
```
|
||||
|
||||
`powerfulDigitCounts(2)` should return `6`.
|
||||
`powerfulDigitCounts(2)` deve retornar `6`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(powerfulDigitCounts(2), 6);
|
||||
```
|
||||
|
||||
`powerfulDigitCounts(3)` should return `5`.
|
||||
`powerfulDigitCounts(3)` deve retornar `5`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(powerfulDigitCounts(3), 5);
|
||||
```
|
||||
|
||||
`powerfulDigitCounts(4)` should return `4`.
|
||||
`powerfulDigitCounts(4)` deve retornar `4`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(powerfulDigitCounts(4), 4);
|
||||
```
|
||||
|
||||
`powerfulDigitCounts(5)` should return `3`.
|
||||
`powerfulDigitCounts(5)` deve retornar `3`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(powerfulDigitCounts(5), 3);
|
||||
```
|
||||
|
||||
`powerfulDigitCounts(6)` should return `3`.
|
||||
`powerfulDigitCounts(6)` deve retornar `3`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(powerfulDigitCounts(6), 3);
|
||||
```
|
||||
|
||||
`powerfulDigitCounts(7)` should return `2`.
|
||||
`powerfulDigitCounts(7)` deve retornar `2`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(powerfulDigitCounts(7), 2);
|
||||
```
|
||||
|
||||
`powerfulDigitCounts(8)` should return `2`.
|
||||
`powerfulDigitCounts(8)` deve retornar `2`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(powerfulDigitCounts(8), 2);
|
||||
```
|
||||
|
||||
`powerfulDigitCounts(10)` should return `2`.
|
||||
`powerfulDigitCounts(10)` deve retornar `2`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(powerfulDigitCounts(10), 2);
|
||||
```
|
||||
|
||||
`powerfulDigitCounts(21)` should return `1`.
|
||||
`powerfulDigitCounts(21)` deve retornar `1`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(powerfulDigitCounts(21), 1);
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
---
|
||||
id: 5900f3ac1000cf542c50febf
|
||||
title: 'Problem 64: Odd period square roots'
|
||||
title: 'Problema 64: Repetições ímpar da raiz quadrada'
|
||||
challengeType: 5
|
||||
forumTopicId: 302176
|
||||
dashedName: problem-64-odd-period-square-roots
|
||||
@ -8,19 +8,19 @@ dashedName: problem-64-odd-period-square-roots
|
||||
|
||||
# --description--
|
||||
|
||||
All square roots are periodic when written as continued fractions and can be written in the form:
|
||||
Todas as raízes quadradas são periódicas quando escritas como frações contínuas e podem ser escritas na forma:
|
||||
|
||||
$\\displaystyle \\quad \\quad \\sqrt{N}=a_0+\\frac 1 {a_1+\\frac 1 {a_2+ \\frac 1 {a3+ \\dots}}}$
|
||||
|
||||
For example, let us consider $\\sqrt{23}:$:
|
||||
Por exemplo, consideremos $\\sqrt{23}:$:
|
||||
|
||||
$\\quad \\quad \\sqrt{23}=4+\\sqrt{23}-4=4+\\frac 1 {\\frac 1 {\\sqrt{23}-4}}=4+\\frac 1 {1+\\frac{\\sqrt{23}-3}7}$
|
||||
|
||||
If we continue we would get the following expansion:
|
||||
Se continuarmos, teremos a seguinte expansão:
|
||||
|
||||
$\\displaystyle \\quad \\quad \\sqrt{23}=4+\\frac 1 {1+\\frac 1 {3+ \\frac 1 {1+\\frac 1 {8+ \\dots}}}}$
|
||||
|
||||
The process can be summarized as follows:
|
||||
O processo pode ser resumido da seguinte forma:
|
||||
|
||||
$\\quad \\quad a_0=4, \\frac 1 {\\sqrt{23}-4}=\\frac {\\sqrt{23}+4} 7=1+\\frac {\\sqrt{23}-3} 7$
|
||||
|
||||
@ -38,61 +38,61 @@ $\\quad \\quad a_6=3, \\frac 2 {\\sqrt{23}-3}=\\frac {2(\\sqrt{23}+3)} {14}=1+\\
|
||||
|
||||
$\\quad \\quad a_7=1, \\frac 7 {\\sqrt{23}-4}=\\frac {7(\\sqrt{23}+4)} {7}=8+\\sqrt{23}-4$
|
||||
|
||||
It can be seen that the sequence is repeating. For conciseness, we use the notation $\\sqrt{23}=\[4;(1,3,1,8)]$, to indicate that the block (1,3,1,8) repeats indefinitely.
|
||||
Podemos ver que a sequência está se repetindo. Para sermos concisos, podemos usar a notação $\\sqrt{23}=\[4;(1,3,1,8)]$ para indicar que o bloco (1, 3, 1, 8) se repete indefinidamente.
|
||||
|
||||
The first ten continued fraction representations of (irrational) square roots are:
|
||||
As primeiras dez representações de raízes (irracionais) contínuas são:
|
||||
|
||||
$\\quad \\quad \\sqrt{2}=\[1;(2)]$, period = 1
|
||||
$\\quad \\quad \\sqrt{2}=\[1;(2)]$, repetições = 1
|
||||
|
||||
$\\quad \\quad \\sqrt{3}=\[1;(1,2)]$, period = 2
|
||||
$\\quad \\quad \\sqrt{3}=\[1;(1,2)]$, repetições = 2
|
||||
|
||||
$\\quad \\quad \\sqrt{5}=\[2;(4)]$, period = 1
|
||||
$\\quad \\quad \\sqrt{5}=\[2;(4)]$, repetições = 1
|
||||
|
||||
$\\quad \\quad \\sqrt{6}=\[2;(2,4)]$, period = 2
|
||||
$\\quad \\quad \\sqrt{6}=\[2;(2,4)]$, repetições = 2
|
||||
|
||||
$\\quad \\quad \\sqrt{7}=\[2;(1,1,1,4)]$, period = 4
|
||||
$\\quad \\quad \\sqrt{7}=\[2;(1,1,1,4)]$, repetições = 4
|
||||
|
||||
$\\quad \\quad \\sqrt{8}=\[2;(1,4)]$, period = 2
|
||||
$\\quad \\quad \\sqrt{8}=\[2;(1,4)]$, repetições = 2
|
||||
|
||||
$\\quad \\quad \\sqrt{10}=\[3;(6)]$, period = 1
|
||||
$\\quad \\quad \\sqrt{10}=\[3;(6)]$, repetições = 1
|
||||
|
||||
$\\quad \\quad \\sqrt{11}=\[3;(3,6)]$, period = 2
|
||||
$\\quad \\quad \\sqrt{11}=\[3;(3,6)]$, repetições = 2
|
||||
|
||||
$\\quad \\quad \\sqrt{12}=\[3;(2,6)]$, period = 2
|
||||
$\\quad \\quad \\sqrt{12}=\[3;(2,6)]$, repetições = 2
|
||||
|
||||
$\\quad \\quad \\sqrt{13}=\[3;(1,1,1,1,6)]$, period = 5
|
||||
$\\quad \\quad \\sqrt{13}=\[3;(1,1,1,1,6)]$, repetições = 5
|
||||
|
||||
Exactly four continued fractions, for $N \\le 13$, have an odd period.
|
||||
Exatamente quatro frações contínuas, onde $N \\le 13$, têm um total de repetições ímpar.
|
||||
|
||||
How many continued fractions for $N \\le n$ have an odd period?
|
||||
Quantas frações contínuas onde $N \\le n$ têm repetições ímpar?
|
||||
|
||||
# --hints--
|
||||
|
||||
`oddPeriodSqrts(13)` should return a number.
|
||||
`oddPeriodSqrts(13)` deve retornar um número.
|
||||
|
||||
```js
|
||||
assert(typeof oddPeriodSqrts(13) === 'number');
|
||||
```
|
||||
|
||||
`oddPeriodSqrts(500)` should return `83`.
|
||||
`oddPeriodSqrts(500)` deve retornar `83`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(oddPeriodSqrts(500), 83);
|
||||
```
|
||||
|
||||
`oddPeriodSqrts(1000)` should return `152`.
|
||||
`oddPeriodSqrts(1000)` deve retornar `152`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(oddPeriodSqrts(1000), 152);
|
||||
```
|
||||
|
||||
`oddPeriodSqrts(5000)` should return `690`.
|
||||
`oddPeriodSqrts(5000)` deve retornar `690`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(oddPeriodSqrts(5000), 690);
|
||||
```
|
||||
|
||||
`oddPeriodSqrts(10000)` should return `1322`.
|
||||
`oddPeriodSqrts(10000)` deve retornar `1322`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(oddPeriodSqrts(10000), 1322);
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
---
|
||||
id: 5900f3ad1000cf542c50fec0
|
||||
title: 'Problem 65: Convergents of e'
|
||||
title: 'Problema 65: Convergentes de e'
|
||||
challengeType: 5
|
||||
forumTopicId: 302177
|
||||
dashedName: problem-65-convergents-of-e
|
||||
@ -8,59 +8,59 @@ dashedName: problem-65-convergents-of-e
|
||||
|
||||
# --description--
|
||||
|
||||
The square root of 2 can be written as an infinite continued fraction.
|
||||
A raiz quadrada de 2 pode ser escrita como uma fração contínua e infinita.
|
||||
|
||||
$\\sqrt{2} = 1 + \\dfrac{1}{2 + \\dfrac{1}{2 + \\dfrac{1}{2 + \\dfrac{1}{2 + ...}}}}$
|
||||
|
||||
The infinite continued fraction can be written, $\\sqrt{2} = \[1; (2)]$ indicates that 2 repeats *ad infinitum*. In a similar way, $\\sqrt{23} = \[4; (1, 3, 1, 8)]$. It turns out that the sequence of partial values of continued fractions for square roots provide the best rational approximations. Let us consider the convergents for $\\sqrt{2}$.
|
||||
Uma fração contínua e infinita pode ser representada por $\\sqrt{2} = \[1; (2)]$. Essa representação indica que 2 se repete *ad infinitum*. Da mesma forma, $\\sqrt{23} = \[4; (1, 3, 1, 8)]$. Acontece que a sequência de valores parciais de frações contínuas de raízes quadradas fornece as melhores aproximações racionais. Considere as convergências de $\\sqrt{2}$.
|
||||
|
||||
$1 + \\dfrac{1}{2} = \\dfrac{3}{2}\\\\ 1 + \\dfrac{1}{2 + \\dfrac{1}{2}} = \\dfrac{7}{5}\\\\ 1 + \\dfrac{1}{2 + \\dfrac{1}{2 + \\dfrac{1}{2}}} = \\dfrac{17}{12}\\\\ 1 + \\dfrac{1}{2 + \\dfrac{1}{2 + \\dfrac{1}{2 + \\dfrac{1}{2}}}} = \\dfrac{41}{29}$
|
||||
|
||||
Hence the sequence of the first ten convergents for $\\sqrt{2}$ are:
|
||||
Assim, a sequência dos primeiros dez convergentes onde $\\sqrt{2}$ são:
|
||||
|
||||
$1, \\dfrac{3}{2}, \\dfrac{7}{5}, \\dfrac{17}{12}, \\dfrac{41}{29}, \\dfrac{99}{70}, \\dfrac{239}{169}, \\dfrac{577}{408}, \\dfrac{1393}{985}, \\dfrac{3363}{2378}, ...$
|
||||
|
||||
What is most surprising is that the important mathematical constant, $e = \[2; 1, 2, 1, 1, 4, 1, 1, 6, 1, ... , 1, 2k, 1, ...]$. The first ten terms in the sequence of convergents for `e` are:
|
||||
O que é mais surpreendente é a constante matemática, $e = \[2; 1, 2, 1, 1, 4, 1, 1, 6, 1, ... , 1, 2k, 1, ...]$. Os primeiros dez termos na sequência de convergentes para `e` são:
|
||||
|
||||
$2, 3, \\dfrac{8}{3}, \\dfrac{11}{4}, \\dfrac{19}{7}, \\dfrac{87}{32}, \\dfrac{106}{39}, \\dfrac{193}{71}, \\dfrac{1264}{465}, \\dfrac{1457}{536}, ...$
|
||||
|
||||
The sum of digits in the numerator of the 10<sup>th</sup> convergent is $1 + 4 + 5 + 7 = 17$.
|
||||
A soma de algarismos no numerador do 10<sup>o</sup> convergente é $1 + 4 + 5 + 7 = 17$.
|
||||
|
||||
Find the sum of digits in the numerator of the `n`<sup>th</sup> convergent of the continued fraction for `e`.
|
||||
Calcule a soma dos dígitos no numerador do `n`<sup>o</sup> convergente da fração contínua para `e`.
|
||||
|
||||
# --hints--
|
||||
|
||||
`convergentsOfE(10)` should return a number.
|
||||
`convergentsOfE(10)` deve retornar um número.
|
||||
|
||||
```js
|
||||
assert(typeof convergentsOfE(10) === 'number');
|
||||
```
|
||||
|
||||
`convergentsOfE(10)` should return `17`.
|
||||
`convergentsOfE(10)` deve retornar `17`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(convergentsOfE(10), 17);
|
||||
```
|
||||
|
||||
`convergentsOfE(30)` should return `53`.
|
||||
`convergentsOfE(30)` deve retornar `53`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(convergentsOfE(30), 53);
|
||||
```
|
||||
|
||||
`convergentsOfE(50)` should return `91`.
|
||||
`convergentsOfE(50)` deve retornar `91`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(convergentsOfE(50), 91);
|
||||
```
|
||||
|
||||
`convergentsOfE(70)` should return `169`.
|
||||
`convergentsOfE(70)` deve retornar `169`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(convergentsOfE(70), 169);
|
||||
```
|
||||
|
||||
`convergentsOfE(100)` should return `272`.
|
||||
`convergentsOfE(100)` deve retornar `272`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(convergentsOfE(100), 272);
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
---
|
||||
id: 5900f3ae1000cf542c50fec1
|
||||
title: 'Problem 66: Diophantine equation'
|
||||
title: 'Problema 66: Equação Diofantina'
|
||||
challengeType: 5
|
||||
forumTopicId: 302178
|
||||
dashedName: problem-66-diophantine-equation
|
||||
@ -8,15 +8,15 @@ dashedName: problem-66-diophantine-equation
|
||||
|
||||
# --description--
|
||||
|
||||
Consider quadratic Diophantine equations of the form:
|
||||
Considere a fórmula da equação Diofantina:
|
||||
|
||||
<div style='text-align: center;'>x<sup>2</sup> – Dy<sup>2</sup> = 1</div>
|
||||
|
||||
For example, when D=13, the minimal solution in x is 649<sup>2</sup> – 13×180<sup>2</sup> = 1.
|
||||
Por exemplo, quando D = 13, a solução mínima de x é 649<sup>2</sup> - 13×180<sup>2</sup> = 1.
|
||||
|
||||
It can be assumed that there are no solutions in positive integers when D is square.
|
||||
Podemos partir do princípio de que não há soluções para números inteiros positivos quando D é o resultado de um número elevado ao quadrado.
|
||||
|
||||
By finding minimal solutions in x for D = {2, 3, 5, 6, 7}, we obtain the following:
|
||||
Ao encontrar soluções mínimas de x onde D = {2, 3, 5, 6, 7}, obtemos o seguinte:
|
||||
|
||||
<div style='margin-left: 2em;'>
|
||||
3<sup>2</sup> – 2×2<sup>2</sup> = 1<br>
|
||||
@ -26,43 +26,43 @@ By finding minimal solutions in x for D = {2, 3, 5, 6, 7}, we obtain the followi
|
||||
8<sup>2</sup> – 7×3<sup>2</sup> = 1<br>
|
||||
</div>
|
||||
|
||||
Hence, by considering minimal solutions in `x` for D ≤ 7, the largest `x` is obtained when D=5.
|
||||
Portanto, considerando soluções mínimas de `x` onde D ≤ 7, o maior `x` é obtido quando D = 5.
|
||||
|
||||
Find the value of D ≤ `n` in minimal solutions of `x` for which the largest value of `x` is obtained.
|
||||
Calcule o valor de D ≤ `n` em soluções mínimas de `x` para as quais o maior valor de `x` é obtido.
|
||||
|
||||
# --hints--
|
||||
|
||||
`diophantineEquation(7)` should return a number.
|
||||
`diophantineEquation(7)` deve retornar um número.
|
||||
|
||||
```js
|
||||
assert(typeof diophantineEquation(7) === 'number');
|
||||
```
|
||||
|
||||
`diophantineEquation(7)` should return `5`.
|
||||
`diophantineEquation(7)` deve retornar `5`.
|
||||
|
||||
```
|
||||
assert.strictEqual(diophantineEquation(7), 5);
|
||||
```
|
||||
|
||||
`diophantineEquation(100)` should return `61`.
|
||||
`diophantineEquation(100)` deve retornar `61`.
|
||||
|
||||
```
|
||||
assert.strictEqual(diophantineEquation(100), 61);
|
||||
```
|
||||
|
||||
`diophantineEquation(409)` should return `409`.
|
||||
`diophantineEquation(409)` deve retornar `409`.
|
||||
|
||||
```
|
||||
assert.strictEqual(diophantineEquation(409), 409);
|
||||
```
|
||||
|
||||
`diophantineEquation(500)` should return `421`.
|
||||
`diophantineEquation(500)` deve retornar `421`.
|
||||
|
||||
```
|
||||
assert.strictEqual(diophantineEquation(500), 421);
|
||||
```
|
||||
|
||||
`diophantineEquation(1000)` should return `661`.
|
||||
`diophantineEquation(1000)` deve retornar `661`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(diophantineEquation(1000), 661);
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
---
|
||||
id: 5900f3b01000cf542c50fec2
|
||||
title: 'Problem 67: Maximum path sum II'
|
||||
title: 'Problema 67: Soma do caminho máximo II'
|
||||
challengeType: 5
|
||||
forumTopicId: 302179
|
||||
dashedName: problem-67-maximum-path-sum-ii
|
||||
@ -8,7 +8,7 @@ dashedName: problem-67-maximum-path-sum-ii
|
||||
|
||||
# --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.
|
||||
|
||||
<div style='text-align: center;'>
|
||||
<strong style='color: red;'>3</strong><br>
|
||||
@ -17,27 +17,27 @@ By starting at the top of the triangle below and moving to adjacent numbers on t
|
||||
8 5 <strong style='color: red;'>9</strong> 3
|
||||
</div>
|
||||
|
||||
That is, 3 + 7 + 4 + 9 = 23.
|
||||
Ou seja, 3 + 7 + 4 + 9 = 23.
|
||||
|
||||
Find the maximum total from top to bottom in `numTriangle`, a 2D array defined in the background containing a triangle with one-hundred rows.
|
||||
Calcule o total máximo de cima para baixo em `numTriangle`, um array 2D definido em segundo plano contendo um triângulo com cem linhas.
|
||||
|
||||
**Note:** This is a much more difficult version of Problem 18. It is not possible to try every route to solve this problem, as there are 2<sup>99</sup> altogether! If you could check one trillion (10<sup>12</sup>) routes every second it would take over twenty billion years to check them all. There is an efficient algorithm to solve it. ;o)
|
||||
**Observação:** esta é uma versão muito mais difícil do Problema 18. Não é possível tentar todas as rotas para resolver este problema, pois há 2<sup>99</sup> rotas no total! Se você pudesse verificar um trilhão (10<sup>12</sup>) de rotas por segundo, levaria mais de vinte bilhões de anos para verificar todas elas. Existe um algoritmo eficaz para resolver esse problema. ;)
|
||||
|
||||
# --hints--
|
||||
|
||||
`maximumPathSumII(testTriangle)` should return a number.
|
||||
`maximumPathSumII(testTriangle)` deve retornar um número.
|
||||
|
||||
```js
|
||||
assert(typeof maximumPathSumII(_testTriangle) === 'number');
|
||||
```
|
||||
|
||||
`maximumPathSumII(testTriangle)` should return 23.
|
||||
`maximumPathSumII(testTriangle)` deve retornar 23.
|
||||
|
||||
```js
|
||||
assert.strictEqual(maximumPathSumII(_testTriangle), 23);
|
||||
```
|
||||
|
||||
`maximumPathSumII(numTriangle)` should return 7273.
|
||||
`maximumPathSumII(numTriangle)` deve retornar 7273.
|
||||
|
||||
```js
|
||||
assert.strictEqual(maximumPathSumII(_numTriangle), 7273);
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
---
|
||||
id: 5900f3b01000cf542c50fec3
|
||||
title: 'Problem 68: Magic 5-gon ring'
|
||||
title: 'Problema 68: Anel de 5 linhas mágicas'
|
||||
challengeType: 5
|
||||
forumTopicId: 302180
|
||||
dashedName: problem-68-magic-5-gon-ring
|
||||
@ -8,13 +8,13 @@ dashedName: problem-68-magic-5-gon-ring
|
||||
|
||||
# --description--
|
||||
|
||||
Consider the following "magic" 3-gon ring, filled with the numbers 1 to 6, and each line adding to nine.
|
||||
Considere o seguinte anel de 3 linhas "mágicas" com números de 1 a 6. Note que ao somar os números de cada linha, o resultado é nove.
|
||||
|
||||
<img class="img-responsive center-block" alt="a completed example of a 3-gon ring" src="https://cdn-media-1.freecodecamp.org/project-euler/3-gon-ring.png" style="background-color: white; padding: 10px;" />
|
||||
<img class="img-responsive center-block" alt="um exemplo completo de um anel de 3 linhas" src="https://cdn-media-1.freecodecamp.org/project-euler/3-gon-ring.png" style="background-color: white; padding: 10px;" />
|
||||
|
||||
Working **clockwise**, and starting from the group of three with the numerically lowest external node (4,3,2 in this example), each solution can be described uniquely. For example, the above solution can be described by the set: 4,3,2; 6,2,1; 5,1,3.
|
||||
Trabalhando **no sentido horário**, e começando pelo grupo onde o nó externo é numericamente menor (4, 3, 2 neste exemplo), cada solução pode ser descrita de forma única. Por exemplo, a solução acima pode ser descrita pelo conjunto: 4,3,2; 6,2,1; 5,1,3.
|
||||
|
||||
It is possible to complete the ring with four different totals: 9, 10, 11, and 12. There are eight solutions in total.
|
||||
É possível completar o anel com quatro totais diferentes: 9, 10, 11 e 12. No total, há oito soluções.
|
||||
|
||||
<div style='text-align: center;'>
|
||||
|
||||
@ -31,21 +31,21 @@ It is possible to complete the ring with four different totals: 9, 10, 11, and 1
|
||||
|
||||
</div>
|
||||
|
||||
By concatenating each group it is possible to form 9-digit strings; the maximum string for a 3-gon ring is 432621513.
|
||||
Ao concatenar cada grupo, é possível formar números de 9 algarismos; o maior número para um anel de 3 linhas é 432621513.
|
||||
|
||||
Using the numbers 1 to 10, and depending on arrangements, it is possible to form 16- and 17-digit strings. What is the maximum **16-digit** string for a "magic" 5-gon ring?
|
||||
Usando os números de 1 a 10 e dependendo dos arranjos, é possível formar números de 16 e 17 algarismos. Qual é o maior número de **16 algarismos** em um anel de 5 linhas?
|
||||
|
||||
<img class="img-responsive center-block" alt="a blank diagram of a 5-gon ring" src="https://cdn-media-1.freecodecamp.org/project-euler/5-gon-ring.png" style="background-color: white; padding: 10px;" />
|
||||
<img class="img-responsive center-block" alt="um diagrama em branco de um anel de 5 linhas" src="https://cdn-media-1.freecodecamp.org/project-euler/5-gon-ring.png" style="background-color: white; padding: 10px;" />
|
||||
|
||||
# --hints--
|
||||
|
||||
`magic5GonRing()` should return a number.
|
||||
`magic5GonRing()` deve retornar um número.
|
||||
|
||||
```js
|
||||
assert(typeof magic5GonRing() === 'number');
|
||||
```
|
||||
|
||||
`magic5GonRing()` should return 6531031914842725.
|
||||
`magic5GonRing()` deve retornar 6531031914842725.
|
||||
|
||||
```js
|
||||
assert.strictEqual(magic5GonRing(), 6531031914842725);
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
---
|
||||
id: 5900f3b11000cf542c50fec4
|
||||
title: 'Problem 69: Totient maximum'
|
||||
title: 'Problema 69: Totiente máximo'
|
||||
challengeType: 5
|
||||
forumTopicId: 302181
|
||||
dashedName: problem-69-totient-maximum
|
||||
@ -8,7 +8,7 @@ dashedName: problem-69-totient-maximum
|
||||
|
||||
# --description--
|
||||
|
||||
Euler's Totient function, ${\phi}(n)$ (sometimes called the phi function), is used to determine the number of numbers less than `n` which are relatively prime to `n`. For example, as 1, 2, 4, 5, 7, and 8, are all less than nine and relatively prime to nine, ${\phi}(9) = 6$.
|
||||
A função Totiente de Euler, ${\phi}(n)$ (às vezes chamada de função phi), é usada para determinar a quantidade de números menores que `n`, que são primos próximos de `n`. Por exemplo, 1, 2, 4, 5, 7 e 8 são todos inferiores a nove e primos relativos de nove, ${\phi}(9) = 6$.
|
||||
|
||||
<div style='margin-left: 4em;'>
|
||||
|
||||
@ -26,37 +26,37 @@ Euler's Totient function, ${\phi}(n)$ (sometimes called the phi function), is us
|
||||
|
||||
</div>
|
||||
|
||||
It can be seen that `n` = 6 produces a maximum $\displaystyle\frac{n}{{\phi}(n)}$ for `n` ≤ 10.
|
||||
Aqui, vemos que `n` = 6 produz um máximo $\displaystyle\frac{n}{{\phi}(n)}$, onde `n` ≤ 10.
|
||||
|
||||
Find the value of `n` ≤ `limit` for which $\displaystyle\frac{n}{{\phi(n)}}$ is a maximum.
|
||||
Calcule o valor de `n` ≤ `limit` onde $\displaystyle\frac{n}{{\phi(n)}}$ é um máximo.
|
||||
|
||||
# --hints--
|
||||
|
||||
`totientMaximum(10)` should return a number.
|
||||
`totientMaximum(10)` deve retornar um número.
|
||||
|
||||
```js
|
||||
assert(typeof totientMaximum(10) === 'number');
|
||||
```
|
||||
|
||||
`totientMaximum(10)` should return `6`.
|
||||
`totientMaximum(10)` deve retornar `6`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(totientMaximum(10), 6);
|
||||
```
|
||||
|
||||
`totientMaximum(10000)` should return `2310`.
|
||||
`totientMaximum(10000)` deve retornar `2310`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(totientMaximum(10000), 2310);
|
||||
```
|
||||
|
||||
`totientMaximum(500000)` should return `30030`.
|
||||
`totientMaximum(500000)` deve retornar `30030`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(totientMaximum(500000), 30030);
|
||||
```
|
||||
|
||||
`totientMaximum(1000000)` should return `510510`.
|
||||
`totientMaximum(1000000)` deve retornar `510510`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(totientMaximum(1000000), 510510);
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
---
|
||||
id: 5900f3b21000cf542c50fec5
|
||||
title: 'Problem 70: Totient permutation'
|
||||
title: 'Problema 70: Permutações Totiente'
|
||||
challengeType: 5
|
||||
forumTopicId: 302183
|
||||
dashedName: problem-70-totient-permutation
|
||||
@ -8,39 +8,39 @@ dashedName: problem-70-totient-permutation
|
||||
|
||||
# --description--
|
||||
|
||||
Euler's Totient function, ${\phi}(n)$ (sometimes called the phi function), is used to determine the number of positive numbers less than or equal to `n` which are relatively prime to `n`. For example, as 1, 2, 4, 5, 7, and 8, are all less than nine and relatively prime to nine, ${\phi}(9) = 6$. The number 1 is considered to be relatively prime to every positive number, so ${\phi}(1) = 1$.
|
||||
A função Totiente de Euler, ${\phi}(n)$ (às vezes chamada de função phi), é usada para determinar a quantidade de números menores que `n`, que são primos próximos de `n`. Por exemplo, 1, 2, 4, 5, 7 e 8 são todos inferiores a nove e primos relativos de nove, ${\phi}(9) = 6$. O número 1 é considerado um primo relativo para todos os números positivos, portanto ${\phi}(1) = 1$.
|
||||
|
||||
Interestingly, ${\phi}(87109) = 79180$, and it can be seen that 87109 is a permutation of 79180.
|
||||
Curiosamente, ${\phi}(87109) = 79180$, e pode ser visto que 87109 é uma permutação de 79180.
|
||||
|
||||
Find the value of `n`, 1 < `n` < `limit`, for which ${\phi}(n)$ is a permutation of `n` and the ratio $\displaystyle\frac{n}{{\phi}(n)}$ produces a minimum.
|
||||
Encontre o valor de `n`, 1 < `n` < `limit`, onde ${\phi}(n)$ é uma permutação de `n` e a razão $\displaystyle\frac{n}{{\phi}(n)}$ produz um mínimo.
|
||||
|
||||
# --hints--
|
||||
|
||||
`totientPermutation(10000)` should return a number.
|
||||
`totientPermutation(10000)` deve retornar um número.
|
||||
|
||||
```js
|
||||
assert(typeof totientPermutation(10000) === 'number');
|
||||
```
|
||||
|
||||
`totientPermutation(10000)` should return `4435`.
|
||||
`totientPermutation(10000)` deve retornar `4435`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(totientPermutation(10000), 4435);
|
||||
```
|
||||
|
||||
`totientPermutation(100000)` should return `75841`.
|
||||
`totientPermutation(100000)` deve retornar `75841`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(totientPermutation(100000), 75841);
|
||||
```
|
||||
|
||||
`totientPermutation(500000)` should return `474883`.
|
||||
`totientPermutation(500000)` deve retornar `474883`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(totientPermutation(500000), 474883);
|
||||
```
|
||||
|
||||
`totientPermutation(10000000)` should return `8319823`.
|
||||
`totientPermutation(10000000)` deve retornar `8319823`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(totientPermutation(10000000), 8319823);
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
---
|
||||
id: 5900f3b31000cf542c50fec6
|
||||
title: 'Problem 71: Ordered fractions'
|
||||
title: 'Problema 71: Frações ordenadas'
|
||||
challengeType: 5
|
||||
forumTopicId: 302184
|
||||
dashedName: problem-71-ordered-fractions
|
||||
@ -8,49 +8,49 @@ dashedName: problem-71-ordered-fractions
|
||||
|
||||
# --description--
|
||||
|
||||
Consider the fraction, $\frac{n}{d}$, where `n` and `d` are positive integers. If `n` < `d` and highest common factor, ${{HCF}(n, d)} = 1$, it is called a reduced proper fraction.
|
||||
Considere a fração $\frac{n}{d}$, onde `n` e `d` são números inteiros e positivos. Se `n` < `d` e o maior divisor comum, ${{HCF}(n, d)} = 1$, ela é chamada de fração irredutível.
|
||||
|
||||
If we list the set of reduced proper fractions for `d` ≤ 8 in ascending order of size, we get:
|
||||
Se nós listarmos o conjunto de frações irredutíveis onde `d` = 8, em ordem ascendente, temos:
|
||||
|
||||
$$\frac{1}{8}, \frac{1}{7}, \frac{1}{6}, \frac{1}{5}, \frac{1}{4}, \frac{2}{7}, \frac{1}{3}, \frac{3}{8}, \frac{\textbf2}{\textbf5}, \frac{3}{7}, \frac{1}{2}, \frac{4}{7}, \frac{3}{5}, \frac{5}{8}, \frac{2}{3}, \frac{5}{7}, \frac{3}{4}, \frac{4}{5}, \frac{5}{6}, \frac{6}{7}, \frac{7}{8}$$
|
||||
|
||||
It can be seen that $\frac{2}{5}$ is the fraction immediately to the left of $\frac{3}{7}$.
|
||||
Podemos ver que $\frac{2}{5}$ está imediatamente à esquerda de $\frac{3}{7}$.
|
||||
|
||||
By listing the set of reduced proper fractions for `d` ≤ `limit` in ascending order of size, find the numerator of the fraction immediately to the left of $\frac{3}{7}$.
|
||||
Ao listar o conjunto de frações irredutíveis em ordem ascendente, onde `d` ≤ `limit`, encontre o numerador da fração imediatamente à esquerda de $\frac{3}{7}$.
|
||||
|
||||
# --hints--
|
||||
|
||||
`orderedFractions(8)` should return a number.
|
||||
`orderedFractions(8)` deve retornar um número.
|
||||
|
||||
```js
|
||||
assert(typeof orderedFractions(8) === 'number');
|
||||
```
|
||||
|
||||
`orderedFractions(8)` should return `2`.
|
||||
`orderedFractions(8)` deve retornar `2`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(orderedFractions(8), 2);
|
||||
```
|
||||
|
||||
`orderedFractions(10)` should return `2`.
|
||||
`orderedFractions(10)` deve retornar `2`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(orderedFractions(10), 2);
|
||||
```
|
||||
|
||||
`orderedFractions(9994)` should return `4283`.
|
||||
`orderedFractions(9994)` deve retornar `4283`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(orderedFractions(9994), 4283);
|
||||
```
|
||||
|
||||
`orderedFractions(500000)` should return `214283`.
|
||||
`orderedFractions(500000)` deve retornar `214283`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(orderedFractions(500000), 214283);
|
||||
```
|
||||
|
||||
`orderedFractions(1000000)` should return `428570`.
|
||||
`orderedFractions(1000000)` deve retornar `428570`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(orderedFractions(1000000), 428570);
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
---
|
||||
id: 5900f3b41000cf542c50fec7
|
||||
title: 'Problem 72: Counting fractions'
|
||||
title: 'Problema 72: Contando frações'
|
||||
challengeType: 5
|
||||
forumTopicId: 302185
|
||||
dashedName: problem-72-counting-fractions
|
||||
@ -8,43 +8,43 @@ dashedName: problem-72-counting-fractions
|
||||
|
||||
# --description--
|
||||
|
||||
Consider the fraction, $\frac{n}{d}$, where `n` and `d` are positive integers. If `n` < `d` and highest common factor, ${HCF}(n, d) = 1$, it is called a reduced proper fraction.
|
||||
Considere a fração $\frac{n}{d}$, onde `n` e `d` são números inteiros e positivos. Se `n` < `d` e o maior divisor comum, ${HCF}(n, d) = 1$, ela é chamada de fração irredutível.
|
||||
|
||||
If we list the set of reduced proper fractions for `d` ≤ 8 in ascending order of size, we get:
|
||||
Se nós listarmos o conjunto de frações irredutíveis onde `d` = 8, em ordem ascendente, temos:
|
||||
|
||||
$$\frac{1}{8}, \frac{1}{7}, \frac{1}{6}, \frac{1}{5}, \frac{1}{4}, \frac{2}{7}, \frac{1}{3}, \frac{3}{8}, \frac{2}{5}, \frac{3}{7}, \frac{1}{2}, \frac{4}{7}, \frac{3}{5}, \frac{5}{8}, \frac{2}{3}, \frac{5}{7}, \frac{3}{4}, \frac{4}{5}, \frac{5}{6}, \frac{6}{7}, \frac{7}{8}$$
|
||||
|
||||
It can be seen that there are `21` elements in this set.
|
||||
Podemos notar que há `21` elementos neste conjunto.
|
||||
|
||||
How many elements would be contained in the set of reduced proper fractions for `d` ≤ `limit`?
|
||||
Quantos elementos existem no conjunto de frações irredutíveis onde `d` ≤ `limit`?
|
||||
|
||||
# --hints--
|
||||
|
||||
`countingFractions(8)` should return a number.
|
||||
`countingFractions(8)` deve retornar um número.
|
||||
|
||||
```js
|
||||
assert(typeof countingFractions(8) === 'number');
|
||||
```
|
||||
|
||||
`countingFractions(8)` should return `21`.
|
||||
`countingFractions(8)` deve retornar `21`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(countingFractions(8), 21);
|
||||
```
|
||||
|
||||
`countingFractions(20000)` should return `121590395`.
|
||||
`countingFractions(20000)` deve retornar `121590395`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(countingFractions(20000), 121590395);
|
||||
```
|
||||
|
||||
`countingFractions(500000)` should return `75991039675`.
|
||||
`countingFractions(500000)` deve retornar `75991039675`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(countingFractions(500000), 75991039675);
|
||||
```
|
||||
|
||||
`countingFractions(1000000)` should return `303963552391`.
|
||||
`countingFractions(1000000)` deve retornar `303963552391`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(countingFractions(1000000), 303963552391);
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
---
|
||||
id: 5900f3b61000cf542c50fec8
|
||||
title: 'Problem 73: Counting fractions in a range'
|
||||
title: 'Problema 73: Contando frações em um intervalo'
|
||||
challengeType: 5
|
||||
forumTopicId: 302186
|
||||
dashedName: problem-73-counting-fractions-in-a-range
|
||||
@ -8,43 +8,43 @@ dashedName: problem-73-counting-fractions-in-a-range
|
||||
|
||||
# --description--
|
||||
|
||||
Consider the fraction, $\frac{n}{d}$, where `n` and `d` are positive integers. If `n` < `d` and highest common factor, ${HCF}(n, d) = 1$, it is called a reduced proper fraction.
|
||||
Considere a fração $\frac{n}{d}$, onde `n` e `d` são números inteiros e positivos. Se `n` < `d` e o maior divisor comum, ${HCF}(n, d) = 1$, ela é chamada de fração irredutível.
|
||||
|
||||
If we list the set of reduced proper fractions for `d` ≤ 8 in ascending order of size, we get:
|
||||
Se nós listarmos o conjunto de frações irredutíveis onde `d` ≤ 8, em ordem ascendente, temos:
|
||||
|
||||
$$\frac{1}{8}, \frac{1}{7}, \frac{1}{6}, \frac{1}{5}, \frac{1}{4}, \frac{2}{7}, \frac{1}{3}, \mathbf{\frac{3}{8}, \frac{2}{5}, \frac{3}{7}}, \frac{1}{2}, \frac{4}{7}, \frac{3}{5}, \frac{5}{8}, \frac{2}{3}, \frac{5}{7}, \frac{3}{4}, \frac{4}{5}, \frac{5}{6}, \frac{6}{7}, \frac{7}{8}$$
|
||||
|
||||
It can be seen that there are `3` fractions between $\frac{1}{3}$ and $\frac{1}{2}$.
|
||||
Podemos notar que há `3` frações entre $\frac{1}{3}$ e $\frac{1}{2}$.
|
||||
|
||||
How many fractions lie between $\frac{1}{3}$ and $\frac{1}{2}$ in the sorted set of reduced proper fractions for `d` ≤ `limit`?
|
||||
Quantas frações estão entre $\frac{1}{3}$ e $\frac{1}{2}$ no conjunto de frações irredutíveis, onde `d` ≤ `limit`?
|
||||
|
||||
# --hints--
|
||||
|
||||
`countingFractionsInARange(8)` should return a number.
|
||||
`countingFractionsInARange(8)` deve retornar um número.
|
||||
|
||||
```js
|
||||
assert(typeof countingFractionsInARange(8) === 'number');
|
||||
```
|
||||
|
||||
`countingFractionsInARange(8)` should return `3`.
|
||||
`countingFractionsInARange(8)` deve retornar `3`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(countingFractionsInARange(8), 3);
|
||||
```
|
||||
|
||||
`countingFractionsInARange(1000)` should return `50695`.
|
||||
`countingFractionsInARange(1000)` deve retornar `50695`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(countingFractionsInARange(1000), 50695);
|
||||
```
|
||||
|
||||
`countingFractionsInARange(6000)` should return `1823861`.
|
||||
`countingFractionsInARange(6000)` deve retornar `1823861`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(countingFractionsInARange(6000), 1823861);
|
||||
```
|
||||
|
||||
`countingFractionsInARange(12000)` should return `7295372`.
|
||||
`countingFractionsInARange(12000)` deve retornar `7295372`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(countingFractionsInARange(12000), 7295372);
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
---
|
||||
id: 5900f3b61000cf542c50fec9
|
||||
title: 'Problem 74: Digit factorial chains'
|
||||
title: 'Problema 74: Cadeia de fatoriais'
|
||||
challengeType: 5
|
||||
forumTopicId: 302187
|
||||
dashedName: problem-74-digit-factorial-chains
|
||||
@ -8,49 +8,49 @@ dashedName: problem-74-digit-factorial-chains
|
||||
|
||||
# --description--
|
||||
|
||||
The number 145 is well known for the property that the sum of the factorial of its digits is equal to 145:
|
||||
O número 145 é conhecido pela propriedade onde a soma do fatorial de seus algarismos é igual a 145:
|
||||
|
||||
$$1! + 4! + 5! = 1 + 24 + 120 = 145$$
|
||||
|
||||
Perhaps less well known is 169, in that it produces the longest chain of numbers that link back to 169; it turns out that there are only three such loops that exist:
|
||||
Talvez 169 seja menos conhecido. Esse número produz a maior cadeia de números que remonta a 169. Acontece que existem apenas três desses laços:
|
||||
|
||||
$$\begin{align} &169 → 363601 → 1454 → 169\\\\ &871 → 45361 → 871\\\\ &872 → 45362 → 872\\\\ \end{align}$$
|
||||
|
||||
It is not difficult to prove that EVERY starting number will eventually get stuck in a loop. For example,
|
||||
Não é difícil provar que TODOS os números com que você iniciar ficarão presos em um ciclo. Por exemplo:
|
||||
|
||||
$$\begin{align} &69 → 363600 → 1454 → 169 → 363601\\ (→ 1454)\\\\ &78 → 45360 → 871 → 45361\\ (→ 871)\\\\ &540 → 145\\ (→ 145)\\\\ \end{align}$$
|
||||
|
||||
Starting with 69 produces a chain of five non-repeating terms, but the longest non-repeating chain with a starting number below one million is sixty terms.
|
||||
O número 69 produz uma cadeia de cinco termos sem repetição. A cadeia de maior número sem repetição, iniciando com um número abaixo de um milhão, é de sessenta termos.
|
||||
|
||||
How many chains, with a starting number below `n`, contain exactly sixty non-repeating terms?
|
||||
Quantas cadeias, com um número inicial abaixo de `n`, contém exatamente sessenta termos não repetidos?
|
||||
|
||||
# --hints--
|
||||
|
||||
`digitFactorialChains(2000)` should return a number.
|
||||
`digitFactorialChains(2000)` deve retornar um número.
|
||||
|
||||
```js
|
||||
assert(typeof digitFactorialChains(2000) === 'number');
|
||||
```
|
||||
|
||||
`digitFactorialChains(2000)` should return `6`.
|
||||
`digitFactorialChains(2000)` deve retornar `6`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(digitFactorialChains(2000), 6);
|
||||
```
|
||||
|
||||
`digitFactorialChains(100000)` should return `42`.
|
||||
`digitFactorialChains(100000)` deve retornar `42`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(digitFactorialChains(100000), 42);
|
||||
```
|
||||
|
||||
`digitFactorialChains(500000)` should return `282`.
|
||||
`digitFactorialChains(500000)` deve retornar `282`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(digitFactorialChains(500000), 282);
|
||||
```
|
||||
|
||||
`digitFactorialChains(1000000)` should return `402`.
|
||||
`digitFactorialChains(1000000)` deve retornar `402`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(digitFactorialChains(1000000), 402);
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
---
|
||||
id: 5900f3b81000cf542c50fecb
|
||||
title: 'Problem 76: Counting summations'
|
||||
title: 'Problema 76: Contagem de somas'
|
||||
challengeType: 5
|
||||
forumTopicId: 302189
|
||||
dashedName: problem-76-counting-summations
|
||||
@ -8,7 +8,7 @@ dashedName: problem-76-counting-summations
|
||||
|
||||
# --description--
|
||||
|
||||
It is possible to write five as a sum in exactly six different ways:
|
||||
É possível chegar ao resultado 5 a partir de uma soma de seis formas diferentes:
|
||||
|
||||
<div style='margin-left: 4em;'>
|
||||
4 + 1<br>
|
||||
@ -19,35 +19,35 @@ It is possible to write five as a sum in exactly six different ways:
|
||||
1 + 1 + 1 + 1 + 1<br><br>
|
||||
</div>
|
||||
|
||||
How many different ways can `n` be written as a sum of at least two positive integers?
|
||||
De quantas formas diferentes `n` pode ser escrito como o resultado de uma soma de pelo menos dois números inteiros positivos?
|
||||
|
||||
# --hints--
|
||||
|
||||
`countingSummations(5)` should return a number.
|
||||
`countingSummations(5)` deve retornar um número.
|
||||
|
||||
```js
|
||||
assert(typeof countingSummations(5) === 'number');
|
||||
```
|
||||
|
||||
`countingSummations(5)` should return `6`.
|
||||
`countingSummations(5)` deve retornar `6`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(countingSummations(5), 6);
|
||||
```
|
||||
|
||||
`countingSummations(20)` should return `626`.
|
||||
`countingSummations(20)` deve retornar `626`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(countingSummations(20), 626);
|
||||
```
|
||||
|
||||
`countingSummations(50)` should return `204225`.
|
||||
`countingSummations(50)` deve retornar `204225`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(countingSummations(50), 204225);
|
||||
```
|
||||
|
||||
`countingSummations(100)` should return `190569291`.
|
||||
`countingSummations(100)` deve retornar `190569291`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(countingSummations(100), 190569291);
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
---
|
||||
id: 5900f3b91000cf542c50fecc
|
||||
title: 'Problem 77: Prime summations'
|
||||
title: 'Problema 77: Contagem de primos'
|
||||
challengeType: 5
|
||||
forumTopicId: 302190
|
||||
dashedName: problem-77-prime-summations
|
||||
@ -8,7 +8,7 @@ dashedName: problem-77-prime-summations
|
||||
|
||||
# --description--
|
||||
|
||||
It is possible to write ten as the sum of primes in exactly five different ways:
|
||||
É possível chegar a 10 como resultado a partir de uma soma de números primos de cinco formas diferentes:
|
||||
|
||||
<div style='margin-left: 4em;'>
|
||||
7 + 3<br>
|
||||
@ -18,35 +18,35 @@ It is possible to write ten as the sum of primes in exactly five different ways:
|
||||
2 + 2 + 2 + 2 + 2<br><br>
|
||||
</div>
|
||||
|
||||
What is the first value which can be written as the sum of primes in over `n` ways?
|
||||
Qual é o primeiro valor que pode ser escrito como a soma de números primos de `n` maneiras?
|
||||
|
||||
# --hints--
|
||||
|
||||
`primeSummations(5)` should return a number.
|
||||
`primeSummations(5)` deve retornar um número.
|
||||
|
||||
```js
|
||||
assert(typeof primeSummations(5) === 'number');
|
||||
```
|
||||
|
||||
`primeSummations(5)` should return `11`.
|
||||
`primeSummations(5)` deve retornar `11`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(primeSummations(5), 11);
|
||||
```
|
||||
|
||||
`primeSummations(100)` should return `31`.
|
||||
`primeSummations(100)` deve retornar `31`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(primeSummations(100), 31);
|
||||
```
|
||||
|
||||
`primeSummations(1000)` should return `53`.
|
||||
`primeSummations(1000)` deve retornar `53`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(primeSummations(1000), 53);
|
||||
```
|
||||
|
||||
`primeSummations(5000)` should return `71`.
|
||||
`primeSummations(5000)` deve retornar `71`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(primeSummations(5000), 71);
|
||||
|
||||
Reference in New Issue
Block a user