chore(i18n,learn): processed translations (#45192)
This commit is contained in:
camperbot
GitHub
@ -21,13 +21,11 @@ La consola mostrará un error debido a la reasignación del valor de `FAV_PET`.
|
||||
|
||||
Siempre debes nombrar variables que no quieras reasignar usando la palabra clave `const`. Esto ayuda cuando intentas reasignar accidentalmente una variable que está destinada a permanecer constante.
|
||||
|
||||
Una práctica común al nombrar constantes es utilizar todas las letras en mayúsculas, con palabras separadas por un guion bajo.
|
||||
|
||||
**Nota:** Es común que los desarrolladores usen identificadores de variables en mayúsculas para valores inmutables y minúsculas o camelCase para valores mutables (objetos y arreglos). Aprenderás más sobre objetos, arreglos y valores inmutables y mutables en desafíos posteriores. También en desafíos posteriores, verás ejemplos de identificadores de variables mayúsculas, minúsculas o camelCase.
|
||||
|
||||
# --instructions--
|
||||
|
||||
Cambia el código para que todas las variables sean declaradas usando `let` o `const`. Usa `let` cuando quieras que la variable cambie, y `const` cuando quieras que la variable permanezca constante. Además, renombra las variables declaradas con `const` para adaptarse a las prácticas comunes, lo que significa que las constantes deben estar todas en mayúsculas.
|
||||
Cambia el código para que todas las variables se declaren con `let` o `const`. Usa `let` cuando quieras que la variable cambie y `const` cuando quieras que la variable permanezca constante. Además, renombra variables declaradas con `const` para adaptarse a las prácticas comunes.
|
||||
|
||||
# --hints--
|
||||
|
||||
@ -37,7 +35,7 @@ Cambia el código para que todas las variables sean declaradas usando `let` o `c
|
||||
(getUserInput) => assert(!getUserInput('index').match(/var/g));
|
||||
```
|
||||
|
||||
Debes cambiar `fCC` todas a mayúsculas.
|
||||
Debes cambiar `fCC` a todas mayúsculas.
|
||||
|
||||
```js
|
||||
(getUserInput) => {
|
||||
|
||||
@ -21,7 +21,7 @@ console.log(typeof {});
|
||||
|
||||
En orden, la consola mostrará las cadenas `string`, `number`, `object`, y `object`.
|
||||
|
||||
JavaScript reconoce seis tipos de datos primitivos (inmutables): `Boolean`, `Null`, `Undefined`, `Number`, `String`, y `Symbol` (nuevo con ES6) y un tipo para elementos mutables: `Object`. Ten en cuenta que en JavaScript, los arreglos son técnicamente un tipo de objeto.
|
||||
JavaScript reconoce siete tipos de datos primitivos (inmutables): `Boolean`, `Null`, `Undefined`, `Number`, `String`, `Symbol` (nuevo con ES6), y `BigInt` (nuevo con ES2020), y un tipo para elementos mutables: `Object`. Ten en cuenta que en JavaScript, los arreglos son técnicamente un tipo de objeto.
|
||||
|
||||
# --instructions--
|
||||
|
||||
|
||||
@ -21,13 +21,11 @@ La console mostrerà un errore a causa della riassegnazione del valore di `FAV_P
|
||||
|
||||
Dovresti sempre dichiarare le variabili che non vuoi riassegnare usando la parola chiave `const`. Questo aiuta quando nel caso dovessi tentare accidentalmente di riassegnare il valore a una variabile che è destinata a rimanere costante.
|
||||
|
||||
Una pratica comune quando si dà il nome alle costanti è usare tutte le lettere maiuscole, separando le parole con un underscore.
|
||||
|
||||
**Nota:** È pratica comune per gli sviluppatori usare identificatori di variabili a lettere maiuscole per valori immutabili e a lettere minuscole o camelCase per valori mutabili (oggetti e array). Imparerai di più su oggetti, array, e valori mutabili e immutabili in sfide future. In sfide future vedrai esempi di identificatori di variavile in maiuscolo, minuscolo e camelCase.
|
||||
|
||||
# --instructions--
|
||||
|
||||
Modifica il codice in modo che tutte le variabili siano dichiarate utilizzando `let` o `const`. Usa `let` quando vuoi che la variabile possa cambiare e `const` quando vuoi che la variabile rimanga costante. Inoltre, rinomina le variabili dichiarate con `const` per conformarti alle pratiche comuni, il che significa che le costanti dovrebbero essere tutte in maiuscolo.
|
||||
Modifica il codice in modo che tutte le variabili siano dichiarate utilizzando `let` o `const`. Usa `let` quando vuoi che la variabile possa cambiare e `const` quando vuoi che la variabile rimanga costante. Inoltre, rinomina le variabili dichiarate con `const` per conformarti alle pratiche comuni.
|
||||
|
||||
# --hints--
|
||||
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
---
|
||||
id: 5900f5431000cf542c510055
|
||||
title: 'Problem 470: Super Ramvok'
|
||||
title: 'Problema 470: Super Ramvok'
|
||||
challengeType: 5
|
||||
forumTopicId: 302146
|
||||
dashedName: problem-470-super-ramvok
|
||||
@ -8,26 +8,26 @@ dashedName: problem-470-super-ramvok
|
||||
|
||||
# --description--
|
||||
|
||||
Consider a single game of Ramvok:
|
||||
Considera un singolo gioco di Ramvok:
|
||||
|
||||
Let t represent the maximum number of turns the game lasts. If t = 0, then the game ends immediately. Otherwise, on each turn i, the player rolls a die. After rolling, if i < t the player can either stop the game and receive a prize equal to the value of the current roll, or discard the roll and try again next turn. If i = t, then the roll cannot be discarded and the prize must be accepted. Before the game begins, t is chosen by the player, who must then pay an up-front cost ct for some constant c. For c = 0, t can be chosen to be infinite (with an up-front cost of 0). Let R(d, c) be the expected profit (i.e. net gain) that the player receives from a single game of optimally-played Ramvok, given a fair d-sided die and cost constant c. For example, R(4, 0.2) = 2.65. Assume that the player has sufficient funds for paying any/all up-front costs.
|
||||
Sia $t$ il numero massimo di turni che il gioco dura. Se $t = 0$ allora il gioco finisce immediatamente. Altrimenti, ad ogni turno $i$, il giocatore tira un dado. Dopo aver tirato, se $i < t$ il giocatore può fermare il gioco e ricevere un premio uguale al tiro corrente o scartare il tiro e provare di nuovo al turno successivo. Se $i = t$, allora il tiro non può essere scartato e il premio deve essere accettato. Prima che il gioco inizi, $t$ è scelto dal giocatore, che deve quindi pagare un costo iniziale $ct$ per una costante $c$. Per $c = 0$, $t$ può essere scelto infinito (con un costo iniziale di 0). Sia $R(d, c)$ il profitto atteso (cioè guadagno netto) che il giocatore riceve da una singola partita di Ramvok giocata ottimalmente, dati un dado pesato a $d$ facce e una costante costo $c$. Per esempio, $R(4, 0.2) = 2,65$. Supponiamo che il giocatore disponga di fondi sufficienti per pagare qualsiasi/tutti i costi iniziali.
|
||||
|
||||
Now consider a game of Super Ramvok:
|
||||
Ora considera una partita di Super Ramvok:
|
||||
|
||||
In Super Ramvok, the game of Ramvok is played repeatedly, but with a slight modification. After each game, the die is altered. The alteration process is as follows: The die is rolled once, and if the resulting face has its pips visible, then that face is altered to be blank instead. If the face is already blank, then it is changed back to its original value. After the alteration is made, another game of Ramvok can begin (and during such a game, at each turn, the die is rolled until a face with a value on it appears). The player knows which faces are blank and which are not at all times. The game of Super Ramvok ends once all faces of the die are blank.
|
||||
In Super Ramvok, il gioco di Ramvok è giocato ripetutamente, ma con una leggera modifica. Dopo ogni partita, il dado viene alterato. Il processo di alterazione è il seguente: Il dado viene lanciato una volta, e se la faccia risultante ha i suoi pallini visibili, allora quella faccia è viene modificata per essere vuota. Se la faccia è già vuota, allora viene riportata al suo valore originale. Dopo che l'alterazione è fatta, può iniziare un'altra partita di Ramvok (e durante quella partita, ad ogni turno, il dado viene lanciato fino a quando appare una faccia con un valore su di essa). In ogni momento il giocatore sa quali facce sono vuote e quali no. Il gioco di Super Ramvok termina una volta che tutte le facce del dado sono vuote.
|
||||
|
||||
Let S(d, c) be the expected profit that the player receives from an optimally-played game of Super Ramvok, given a fair d-sided die to start (with all sides visible), and cost constant c. For example, S(6, 1) = 208.3.
|
||||
Sia $S(d, c)$ il profitto atteso che il giocatore riceve da un gioco ottimale di Super Ramvok, dato un dado a $d$ facce pesato per iniziare (con tutti i lati visibili), e un costo costante $c$. Per esempio, $S(6, 1) = 208,3$.
|
||||
|
||||
Let F(n) = ∑4≤d≤n ∑0≤c≤n S(d, c).
|
||||
Sia $F(n) = \sum_{4 ≤ d ≤ n} \sum_{0 ≤ c ≤ n} S(d, c)$.
|
||||
|
||||
Calculate F(20), rounded to the nearest integer.
|
||||
Calcola $F(20)$, arrotondato al numero intero più vicino.
|
||||
|
||||
# --hints--
|
||||
|
||||
`euler470()` should return 147668794.
|
||||
`superRamvok()` dovrebbe restituire `147668794`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(euler470(), 147668794);
|
||||
assert.strictEqual(superRamvok(), 147668794);
|
||||
```
|
||||
|
||||
# --seed--
|
||||
@ -35,12 +35,12 @@ assert.strictEqual(euler470(), 147668794);
|
||||
## --seed-contents--
|
||||
|
||||
```js
|
||||
function euler470() {
|
||||
function superRamvok() {
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
euler470();
|
||||
superRamvok();
|
||||
```
|
||||
|
||||
# --solutions--
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
---
|
||||
id: 5900f5461000cf542c510058
|
||||
title: 'Problem 473: Phigital number base'
|
||||
title: 'Problema 473: Base numerica pi-greco'
|
||||
challengeType: 5
|
||||
forumTopicId: 302150
|
||||
dashedName: problem-473-phigital-number-base
|
||||
@ -8,30 +8,32 @@ dashedName: problem-473-phigital-number-base
|
||||
|
||||
# --description--
|
||||
|
||||
Let $\\varphi$ be the golden ratio: $\\varphi=\\frac{1+\\sqrt{5}}{2}.$
|
||||
Sia $\varphi$ il rapporto aureo: $\varphi = \frac{1+\sqrt{5}}{2}.$
|
||||
|
||||
Remarkably it is possible to write every positive integer as a sum of powers of $\\varphi$ even if we require that every power of $\\varphi$ is used at most once in this sum.
|
||||
Degno di nota, è possibile scrivere ogni numero intero positivo come somma delle potenze di $\varphi$ anche con il limite che ogni potenza di $\varphi$ possa essere usata al massimo una volta nella somma.
|
||||
|
||||
Even then this representation is not unique.
|
||||
Anche in questo caso la rappresentazione non è unica.
|
||||
|
||||
We can make it unique by requiring that no powers with consecutive exponents are used and that the representation is finite.
|
||||
Possiamo renderla unica richiedendo che nessuna potenza con esponenti consecutivi sia usata e che la rappresentazione sia finita.
|
||||
|
||||
E.g:
|
||||
Ad es:
|
||||
|
||||
$2=\\varphi+\\varphi^{-2}$ and $3=\\varphi^{2}+\\varphi^{-2}$
|
||||
$2 = \varphi + \varphi^{-2}$ e $3 = \varphi^{2} + \varphi^{-2}$
|
||||
|
||||
To represent this sum of powers of $\\varphi$ we use a string of 0's and 1's with a point to indicate where the negative exponents start. We call this the representation in the phigital numberbase. So $1=1*{\\varphi}$, $2=10.01*{\\varphi}$, $3=100.01*{\\varphi}$ and $14=100100.001001*{\\varphi}$. The strings representing 1, 2 and 14 in the phigital number base are palindromic, while the string representing 3 is not. (the phigital point is not the middle character).
|
||||
Per rappresentare la somma delle potenze di $\varphi$ usiamo una stringa di 0 e 1 con un punto per indicare dove gli esponenti negativi iniziano. Chiamiamo questa rappresentazione in base pi-greco.
|
||||
|
||||
The sum of the positive integers not exceeding 1000 whose phigital representation is palindromic is 4345.
|
||||
Quindi $1 = 1_{\varphi}$, $2 = 10.01_{\varphi}$, $3 = 100.01_{\varphi}$ e $14 = 100100.001001_{\varphi}$. Le stringhe rappresentanti 1, 2 e 14 nella base pi-greco sono palindromiche, mentre la stringa rappresentante 3 non lo è. (il punto non è il carattere centrale).
|
||||
|
||||
Find the sum of the positive integers not exceeding $10^{10}$ whose phigital representation is palindromic.
|
||||
La somma dei numeri interi che non eccedono 1000 la cui rappresentazione in base pi-greco è palindromica è 4345.
|
||||
|
||||
Trova la somma dei numeri interi positivi non eccedenti $10^{10}$ la cui rappresentazione in base pi-greco è palindromica.
|
||||
|
||||
# --hints--
|
||||
|
||||
`euler473()` should return 35856681704365.
|
||||
`phigitalNumberBase()` dovrebbe restituire `35856681704365`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(euler473(), 35856681704365);
|
||||
assert.strictEqual(phigitalNumberBase(), 35856681704365);
|
||||
```
|
||||
|
||||
# --seed--
|
||||
@ -39,12 +41,12 @@ assert.strictEqual(euler473(), 35856681704365);
|
||||
## --seed-contents--
|
||||
|
||||
```js
|
||||
function euler473() {
|
||||
function phigitalNumberBase() {
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
euler473();
|
||||
phigitalNumberBase();
|
||||
```
|
||||
|
||||
# --solutions--
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
---
|
||||
id: 5900f5471000cf542c510059
|
||||
title: 'Problem 474: Last digits of divisors'
|
||||
title: 'Problema 474: Ultime cifre di divisori'
|
||||
challengeType: 5
|
||||
forumTopicId: 302151
|
||||
dashedName: problem-474-last-digits-of-divisors
|
||||
@ -8,20 +8,20 @@ dashedName: problem-474-last-digits-of-divisors
|
||||
|
||||
# --description--
|
||||
|
||||
For a positive integer n and digits d, we define F(n, d) as the number of the divisors of n whose last digits equal d.
|
||||
Per un numero intero positivo $n$ e cifre $d$ definiamo $F(n, d)$ come il numero dei divisori di $n$ le cui ultime cifre sono pari a $d$.
|
||||
|
||||
For example, F(84, 4) = 3. Among the divisors of 84 (1, 2, 3, 4, 6, 7, 12, 14, 21, 28, 42, 84), three of them (4, 14, 84) have the last digit 4.
|
||||
Per esempio, $F(84, 4) = 3$. Tra i divisori di 84 (1, 2, 3, 4, 6, 7, 12, 14, 21, 28, 42, 84), tre di loro (4, 14, 84) hanno l'ultima cifra 4.
|
||||
|
||||
We can also verify that F(12!, 12) = 11 and F(50!, 123) = 17888.
|
||||
Possiamo anche verificare che $F(12!, 12) = 11$ e $F(50!, 123) = 17\\,888$.
|
||||
|
||||
Find F(106!, 65432) modulo (1016 + 61).
|
||||
Trova $F({10}^6!, 65\\,432) \text{ modulo } ({10}^{16} + 61)$.
|
||||
|
||||
# --hints--
|
||||
|
||||
`euler474()` should return 9690646731515010.
|
||||
`lastDigitsOfDivisors()` dovrebbe restituire `9690646731515010`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(euler474(), 9690646731515010);
|
||||
assert.strictEqual(lastDigitsOfDivisors(), 9690646731515010);
|
||||
```
|
||||
|
||||
# --seed--
|
||||
@ -29,12 +29,12 @@ assert.strictEqual(euler474(), 9690646731515010);
|
||||
## --seed-contents--
|
||||
|
||||
```js
|
||||
function euler474() {
|
||||
function lastDigitsOfDivisors() {
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
euler474();
|
||||
lastDigitsOfDivisors();
|
||||
```
|
||||
|
||||
# --solutions--
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
---
|
||||
id: 5900f5481000cf542c51005a
|
||||
title: 'Problem 475: Music festival'
|
||||
title: 'Problema 475: Festival musicale'
|
||||
challengeType: 5
|
||||
forumTopicId: 302152
|
||||
dashedName: problem-475-music-festival
|
||||
@ -8,22 +8,24 @@ dashedName: problem-475-music-festival
|
||||
|
||||
# --description--
|
||||
|
||||
12n musicians participate at a music festival. On the first day, they form 3n quartets and practice all day.
|
||||
$12n$ musicisti partecipano a un festival musicale. Il primo giorno, formano $3n$ quartetti e provano tutto il giorno.
|
||||
|
||||
It is a disaster. At the end of the day, all musicians decide they will never again agree to play with any member of their quartet.
|
||||
È una catastrofe. Alla fine della giornata, tutti i musicisti decidono di non accettare mai più di suonare con nessun membro del loro quartetto.
|
||||
|
||||
On the second day, they form 4n trios, each musician avoiding his previous quartet partners.
|
||||
Il secondo giorno, formano $4n$ trio, evitando che ogni musicista stia con i suoi partner del quartetto precedente.
|
||||
|
||||
Let f(12n) be the number of ways to organize the trios amongst the 12n musicians. You are given f(12) = 576 and f(24) mod 1 000 000 007 = 509089824.
|
||||
Sia $f(12n)$ il numero di modi per organizzare i trio tra i $12n$ musicisti.
|
||||
|
||||
Find f(600) mod 1 000 000 007.
|
||||
Ti viene dato $f(12) = 576$ e $f(24)\bmod 1\\,000\\,000\\,007 = 509\\,089\\,824$.
|
||||
|
||||
Trova $f(600)\bmod 1\\,000\\,000\\,007$.
|
||||
|
||||
# --hints--
|
||||
|
||||
`euler475()` should return 75780067.
|
||||
`musicFestival()` dovrebbe restituire `75780067`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(euler475(), 75780067);
|
||||
assert.strictEqual(musicFestival(), 75780067);
|
||||
```
|
||||
|
||||
# --seed--
|
||||
@ -31,12 +33,12 @@ assert.strictEqual(euler475(), 75780067);
|
||||
## --seed-contents--
|
||||
|
||||
```js
|
||||
function euler475() {
|
||||
function musicFestival() {
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
euler475();
|
||||
musicFestival();
|
||||
```
|
||||
|
||||
# --solutions--
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
---
|
||||
id: 5900f5481000cf542c51005b
|
||||
title: 'Problem 476: Circle Packing II'
|
||||
title: 'Problema 476: Imballaggio del cerchio II'
|
||||
challengeType: 5
|
||||
forumTopicId: 302153
|
||||
dashedName: problem-476-circle-packing-ii
|
||||
@ -8,20 +8,20 @@ dashedName: problem-476-circle-packing-ii
|
||||
|
||||
# --description--
|
||||
|
||||
Let R(a, b, c) be the maximum area covered by three non-overlapping circles inside a triangle with edge lengths a, b and c.
|
||||
Sia $R(a, b, c)$ l'area massima coperta da tre cerchi non sovrapposti all'interno di un triangolo con lunghezze di bordo $a$, $b$ e $c$.
|
||||
|
||||
Let S(n) be the average value of R(a, b, c) over all integer triplets (a, b, c) such that 1 ≤ a ≤ b ≤ c < a + b ≤ n
|
||||
Sia $S(n)$ il valore medio di $R(a, b, c)$ su tutte le triplette intere $(a, b, c)$ tali che $1 ≤ a ≤ b ≤ c < a + b ≤ n$.
|
||||
|
||||
You are given S(2) = R(1, 1, 1) ≈ 0.31998, S(5) ≈ 1.25899.
|
||||
Ti viene dato $S(2) = R(1, 1, 1) ≈ 0.31998$, $S(5) ≈ 1.25899$.
|
||||
|
||||
Find S(1803) rounded to 5 decimal places behind the decimal point.
|
||||
Trova $S(1803)$ arrotondato a 5 decimali dopo il punto decimale.
|
||||
|
||||
# --hints--
|
||||
|
||||
`euler476()` should return 110242.87794.
|
||||
`circlePackingTwo()` dovrebbe restituire `110242.87794`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(euler476(), 110242.87794);
|
||||
assert.strictEqual(circlePackingTwo(), 110242.87794);
|
||||
```
|
||||
|
||||
# --seed--
|
||||
@ -29,12 +29,12 @@ assert.strictEqual(euler476(), 110242.87794);
|
||||
## --seed-contents--
|
||||
|
||||
```js
|
||||
function euler476() {
|
||||
function circlePackingTwo() {
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
euler476();
|
||||
circlePackingTwo();
|
||||
```
|
||||
|
||||
# --solutions--
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
---
|
||||
id: 5900f54a1000cf542c51005c
|
||||
title: 'Problem 477: Number Sequence Game'
|
||||
title: 'Problema 477: Gioco della sequenza dei numeri'
|
||||
challengeType: 5
|
||||
forumTopicId: 302154
|
||||
dashedName: problem-477-number-sequence-game
|
||||
@ -8,42 +8,38 @@ dashedName: problem-477-number-sequence-game
|
||||
|
||||
# --description--
|
||||
|
||||
The number sequence game starts with a sequence S of N numbers written on a line.
|
||||
Il gioco della sequenza di numeri inizia con una sequenza $S$ di $N$ numeri scritti su una riga.
|
||||
|
||||
Two players alternate turns. At his turn, a player must select and remove either the first or the last number remaining in the sequence.
|
||||
Due giocatori alternano il turno. Al proprio turno, un giocatore deve scegliere e rimuovere il primo o l'ultimo numero rimasto nella sequenza.
|
||||
|
||||
The player score is the sum of all the numbers he has taken. Each player attempts to maximize his own sum.
|
||||
Il punteggio del giocatore è la somma di tutti i numeri che ha cancellato. Ogni giocatore prova a massimizzare la propria somma.
|
||||
|
||||
If N = 4 and S = {1, 2, 10, 3}, then each player maximizes his score as follows:
|
||||
Se $N = 4$ e $S = \\{1, 2, 10, 3\\}$, allora ogni giocatore massimizza il proprio punteggio come segue:
|
||||
|
||||
Player 1: removes the first number (1)
|
||||
- Giocatore 1: rimuove il primo numero (1)
|
||||
- Giocatore 2: rimuove l'ultimo numero dalla sequenza rimasta (3)
|
||||
- Giocatore 1: rimuove l'ultimo numero dalla sequenza rimasta (10)
|
||||
- Giocatore 2: rimuove il numero rimasto (2)
|
||||
|
||||
Player 2: removes the last number from the remaining sequence (3)
|
||||
Il punteggio del giocatore 1 è $1 + 10 = 11$.
|
||||
|
||||
Player 1: removes the last number from the remaining sequence (10)
|
||||
Sia $F(N)$ il punteggio del giocatore 1 se entrambi i giocatori seguono la strategia ottimale per la sequenza $S = \\{s_1, s_2, \ldots, s_N\\}$ definita come:
|
||||
|
||||
Player 2: removes the remaining number (2)
|
||||
- $s_1 = 0$
|
||||
- $s_{i + 1} = ({s_i}^2 + 45)$ modulo $1\\,000\\,000\\,007$
|
||||
|
||||
Player 1 score is 1 + 10 = 11.
|
||||
La sequenza inizia con $S = \\{0, 45, 2\\,070, 4\\,284\\,945, 753\\,524\\,550, 478\\,107\\,844, 894\\,218\\,625, \ldots\\}$.
|
||||
|
||||
Let F(N) be the score of player 1 if both players follow the optimal strategy for the sequence S = {s1, s2, ..., sN} defined as:
|
||||
Ti è dato $F(2) = 45$, $F(4) = 4\\,284\\,990$, $F(100) = 26\\,365\\,463\\,243$, $F(104) = 2\\,495\\,838\\,522\\,951$.
|
||||
|
||||
s1 = 0
|
||||
|
||||
si+1 = (si2 + 45) modulo 1 000 000 007
|
||||
|
||||
The sequence begins with S = {0, 45, 2070, 4284945, 753524550, 478107844, 894218625, ...}.
|
||||
|
||||
You are given F(2) = 45, F(4) = 4284990, F(100) = 26365463243, F(104) = 2495838522951.
|
||||
|
||||
Find F(108).
|
||||
Trova $F({10}^8)$.
|
||||
|
||||
# --hints--
|
||||
|
||||
`euler477()` should return 25044905874565164.
|
||||
`numberSequenceGame()` dovrebbe restituire `25044905874565164`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(euler477(), 25044905874565164);
|
||||
assert.strictEqual(numberSequenceGame(), 25044905874565164);
|
||||
```
|
||||
|
||||
# --seed--
|
||||
@ -51,12 +47,12 @@ assert.strictEqual(euler477(), 25044905874565164);
|
||||
## --seed-contents--
|
||||
|
||||
```js
|
||||
function euler477() {
|
||||
function numberSequenceGame() {
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
euler477();
|
||||
numberSequenceGame();
|
||||
```
|
||||
|
||||
# --solutions--
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
---
|
||||
id: 5900f54b1000cf542c51005d
|
||||
title: 'Problem 479: Roots on the Rise'
|
||||
title: 'Problema 479: Radici in crescita'
|
||||
challengeType: 5
|
||||
forumTopicId: 302156
|
||||
dashedName: problem-479-roots-on-the-rise
|
||||
@ -8,22 +8,22 @@ dashedName: problem-479-roots-on-the-rise
|
||||
|
||||
# --description--
|
||||
|
||||
Let ak, bk, and ck represent the three solutions (real or complex numbers) to the expression 1/x = (k/x)2(k+x2) - kx.
|
||||
Siano $a_k$, $b_k$, e $c_k$ le tre soluzioni (numeri reali o complessi) dell'espressione $\frac{1}{x} = {\left(\frac{k}{x} \right)}^2 (k + x^2) - kx$.
|
||||
|
||||
For instance, for k = 5, we see that {a5, b5, c5} is approximately {5.727244, -0.363622+2.057397i, -0.363622-2.057397i}.
|
||||
Per esempio, per $k = 5$, vediamo che $\\{a_5, b_5, c_5\\}$ è approssimativamente $\\{5.727244, -0.363622 + 2.057397i, -0.363622 - 2.057397i\\}$.
|
||||
|
||||
Let S(n) = Σ (ak+bk)p(bk+ck)p(ck+ak)p for all integers p, k such that 1 ≤ p, k ≤ n.
|
||||
Sia $S(n) = \displaystyle\sum_{p = 1}^n \sum_{k = 1}^n {(a_k + b_k)}^p {(b_k + c_k)}^p {(c_k + a_k)}^p$ per tutti i numeri interi $p$, $k$ per cui $1 ≤ p, k ≤ n$.
|
||||
|
||||
Interestingly, S(n) is always an integer. For example, S(4) = 51160.
|
||||
È interessante notare che $S(n)$ è sempre un numero intero. Per esempio, $S(4) = 51\\,160$.
|
||||
|
||||
Find S(106) modulo 1 000 000 007.
|
||||
Trova $S({10}^6) \text{ modulo } 1\\,000\\,000\\,007$.
|
||||
|
||||
# --hints--
|
||||
|
||||
`euler479()` should return 191541795.
|
||||
`rootsOnTheRise()` dovrebbe restituire `191541795`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(euler479(), 191541795);
|
||||
assert.strictEqual(rootsOnTheRise(), 191541795);
|
||||
```
|
||||
|
||||
# --seed--
|
||||
@ -31,12 +31,12 @@ assert.strictEqual(euler479(), 191541795);
|
||||
## --seed-contents--
|
||||
|
||||
```js
|
||||
function euler479() {
|
||||
function rootsOnTheRise() {
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
euler479();
|
||||
rootsOnTheRise();
|
||||
```
|
||||
|
||||
# --solutions--
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
---
|
||||
id: 5900f54c1000cf542c51005f
|
||||
title: 'Problem 480: The Last Question'
|
||||
title: 'Problema 480: L''ultima domanda'
|
||||
challengeType: 5
|
||||
forumTopicId: 302158
|
||||
dashedName: problem-480-the-last-question
|
||||
@ -8,90 +8,42 @@ dashedName: problem-480-the-last-question
|
||||
|
||||
# --description--
|
||||
|
||||
Consider all the words which can be formed by selecting letters, in any order, from the phrase:
|
||||
Considera tutte le parole che possono essere formate selezionando lettere, in qualsiasi ordine, dalla frase:
|
||||
|
||||
thereisasyetinsufficientdataforameaningfulanswer
|
||||
$$\mathbf{\text{thereisasyetinsufficientdataforameaningfulanswer}}$$
|
||||
|
||||
Suppose those with 15 letters or less are listed in alphabetical order and numbered sequentially starting at 1.
|
||||
Supponi che quelle con 15 lettere o meno sono elencate in ordine alfabetico e numerate sequenzialmente iniziando da 1.
|
||||
|
||||
The list would include:
|
||||
La lista includerebbe:
|
||||
|
||||
1 : a
|
||||
$$\begin{align} & 1: \text{a} \\\\ & 2: \text{aa} \\\\ & 3: \text{aaa} \\\\ & 4: \text{aaaa} \\\\ & 5: \text{aaaaa} \\\\ & 6: \text{aaaaaa} \\\\ & 7: \text{aaaaaac} \\\\ & 8: \text{aaaaaacd} \\\\ & 9: \text{aaaaaacde} \\\\ & 10: \text{aaaaaacdee} \\\\ & 11: \text{aaaaaacdeee} \\\\ & 12: \text{aaaaaacdeeee} \\\\ & 13: \text{aaaaaacdeeeee} \\\\ & 14: \text{aaaaaacdeeeeee} \\\\ & 15: \text{aaaaaacdeeeeeef} \\\\ & 16: \text{aaaaaacdeeeeeeg} \\\\ & 17: \text{aaaaaacdeeeeeeh} \\\\ & \ldots \\\\ & 28: \text{aaaaaacdeeeeeey} \\\\ & 29: \text{aaaaaacdeeeeef} \\\\ & 30: \text{aaaaaacdeeeeefe} \\\\ & \ldots \\\\ & 115246685191495242: \text{euleoywuttttsss} \\\\ & 115246685191495243: \text{euler} \\\\ & 115246685191495244: \text{eulera} \\\\ & ... \\\\ & 525069350231428029: \text{ywuuttttssssrrr} \\\\ \end{align}$$
|
||||
|
||||
2 : aa
|
||||
Sia $P(w)$ la posizione della parola $w$.
|
||||
|
||||
3 : aaa
|
||||
Sia $W(p)$ la parola in posizione $p$.
|
||||
|
||||
4 : aaaa
|
||||
Possiamo vedere che $P(w)$ e $W(p)$ sono operazioni inverse: $P(W(p)) = p$ e $W(P(w)) = w$.
|
||||
|
||||
5 : aaaaa
|
||||
Esempi:
|
||||
|
||||
6 : aaaaaa
|
||||
$$\begin{align} & W(10) = \text{ aaaaaacdee} \\\\ & P(\text{aaaaaacdee}) = 10 \\\\ & W(115246685191495243) = \text{ euler} \\\\ & P(\text{euler}) = 115246685191495243 \\\\ \end{align}$$
|
||||
|
||||
7 : aaaaaac
|
||||
Trova $$W(P(\text{legionary}) + P(\text{calorimeters}) - P(\text{annihilate}) + P(\text{orchestrated}) - P(\text{fluttering})).$$
|
||||
|
||||
8 : aaaaaacd
|
||||
|
||||
9 : aaaaaacde
|
||||
|
||||
10 : aaaaaacdee
|
||||
|
||||
11 : aaaaaacdeee
|
||||
|
||||
12 : aaaaaacdeeee
|
||||
|
||||
13 : aaaaaacdeeeee
|
||||
|
||||
14 : aaaaaacdeeeeee
|
||||
|
||||
15 : aaaaaacdeeeeeef
|
||||
|
||||
16 : aaaaaacdeeeeeeg
|
||||
|
||||
17 : aaaaaacdeeeeeeh
|
||||
|
||||
...
|
||||
|
||||
28 : aaaaaacdeeeeeey
|
||||
|
||||
29 : aaaaaacdeeeeef
|
||||
|
||||
30 : aaaaaacdeeeeefe
|
||||
|
||||
...
|
||||
|
||||
115246685191495242: euleoywuttttsss
|
||||
|
||||
115246685191495243: euler
|
||||
|
||||
115246685191495244: eulera
|
||||
|
||||
...
|
||||
|
||||
525069350231428029: ywuuttttssssrrrDefine P(w) as the position of the word w.
|
||||
|
||||
Define W(p) as the word in position p.
|
||||
|
||||
We can see that P(w) and W(p) are inverses: P(W(p)) = p and W(P(w)) = w.
|
||||
|
||||
Examples:
|
||||
|
||||
W(10) = aaaaaacdee
|
||||
|
||||
P(aaaaaacdee) = 10
|
||||
|
||||
W(115246685191495243) = euler
|
||||
|
||||
P(euler) = 115246685191495243Find W(P(legionary) + P(calorimeters) - P(annihilate) + P(orchestrated) - P(fluttering)).
|
||||
|
||||
Give your answer using lowercase characters (no punctuation or space).
|
||||
Dai la tua risposta usando caratteri minuscoli (senza punteggiatura o spazi).
|
||||
|
||||
# --hints--
|
||||
|
||||
`euler480()` should return turnthestarson.
|
||||
`euler480()` dovrebbe restituire una stringa.
|
||||
|
||||
```js
|
||||
assert.strictEqual(euler480(), turnthestarson);
|
||||
assert(typeof euler480() === 'string');
|
||||
```
|
||||
|
||||
`euler480()` dovrebbe restituire la stringa `turnthestarson`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(euler480(), 'turnthestarson');
|
||||
```
|
||||
|
||||
# --seed--
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
---
|
||||
id: 5900f3ac1000cf542c50febf
|
||||
title: 'Problem 64: Odd period square roots'
|
||||
title: 'Problema 64: radici quadrate con periodo dispari'
|
||||
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:
|
||||
Tutte le radici quadrate sono periodiche quando sono scritte come frazioni continue e possono essere scritte nella 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}:$:
|
||||
Per esempio, considera $\\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 continuiamo otterremmo questa espansione:
|
||||
|
||||
$\\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:
|
||||
Il processo può essere riassunto come seque:
|
||||
|
||||
$\\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.
|
||||
Si può vedere che la sequenza si ripete. Per brevità usiamo la notazione $\\sqrt{23}=\[4;(1,3,1,8)]$, tper indicare che il blocco (1,3,1,8) ripete indefinitamente.
|
||||
|
||||
The first ten continued fraction representations of (irrational) square roots are:
|
||||
Le prime dieci rappresentazioni come frazioni continuate delle radici quadrate (irrazionali) sono:
|
||||
|
||||
$\\quad \\quad \\sqrt{2}=\[1;(2)]$, period = 1
|
||||
$\\quad \\quad \\sqrt{2}=\[1;(2)]$, periodo = 1
|
||||
|
||||
$\\quad \\quad \\sqrt{3}=\[1;(1,2)]$, period = 2
|
||||
$\\quad \\quad \\sqrt{3}=\[1;(1,2)]$, periodo = 2
|
||||
|
||||
$\\quad \\quad \\sqrt{5}=\[2;(4)]$, period = 1
|
||||
$\\quad \\quad \\sqrt{5}=\[2;(4)]$, periodo = 1
|
||||
|
||||
$\\quad \\quad \\sqrt{6}=\[2;(2,4)]$, period = 2
|
||||
$\\quad \\quad \\sqrt{6}=\[2;(2,4)]$, periodo = 2
|
||||
|
||||
$\\quad \\quad \\sqrt{7}=\[2;(1,1,1,4)]$, period = 4
|
||||
$\\quad \\quad \\sqrt{7}=\[2;(1,1,1,4)]$, periodo = 4
|
||||
|
||||
$\\quad \\quad \\sqrt{8}=\[2;(1,4)]$, period = 2
|
||||
$\\quad \\quad \\sqrt{8}=\[2;(1,4)]$, periodo = 2
|
||||
|
||||
$\\quad \\quad \\sqrt{10}=\[3;(6)]$, period = 1
|
||||
$\\quad \\quad \\sqrt{10}=\[3;(6)]$, periodo = 1
|
||||
|
||||
$\\quad \\quad \\sqrt{11}=\[3;(3,6)]$, period = 2
|
||||
$\\quad \\quad \\sqrt{11}=\[3;(3,6)]$, periodo = 2
|
||||
|
||||
$\\quad \\quad \\sqrt{12}=\[3;(2,6)]$, period = 2
|
||||
$\\quad \\quad \\sqrt{12}=\[3;(2,6)]$, periodo = 2
|
||||
|
||||
$\\quad \\quad \\sqrt{13}=\[3;(1,1,1,1,6)]$, period = 5
|
||||
$\\quad \\quad \\sqrt{13}=\[3;(1,1,1,1,6)]$, periodo = 5
|
||||
|
||||
Exactly four continued fractions, for $N \\le 13$, have an odd period.
|
||||
Esattamente quattro frazioni continuate per $N \\le 13$, hanno un periodo dispari.
|
||||
|
||||
How many continued fractions for $N \\le n$ have an odd period?
|
||||
Quante frazioni continuate hanno un periodo dispari per $N \\le n$?
|
||||
|
||||
# --hints--
|
||||
|
||||
`oddPeriodSqrts(13)` should return a number.
|
||||
`oddPeriodSqrts(13)` dovrebbe restituire un numero.
|
||||
|
||||
```js
|
||||
assert(typeof oddPeriodSqrts(13) === 'number');
|
||||
```
|
||||
|
||||
`oddPeriodSqrts(500)` should return `83`.
|
||||
`oddPeriodSqrts(500)` dovrebbe restituire `83`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(oddPeriodSqrts(500), 83);
|
||||
```
|
||||
|
||||
`oddPeriodSqrts(1000)` should return `152`.
|
||||
`oddPeriodSqrts(1000)` dovrebbe restituire `152`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(oddPeriodSqrts(1000), 152);
|
||||
```
|
||||
|
||||
`oddPeriodSqrts(5000)` should return `690`.
|
||||
`oddPeriodSqrts(5000)` dovrebbe restituire `690`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(oddPeriodSqrts(5000), 690);
|
||||
```
|
||||
|
||||
`oddPeriodSqrts(10000)` should return `1322`.
|
||||
`oddPeriodSqrts(10000)` dovrebbe restituire `1322`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(oddPeriodSqrts(10000), 1322);
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
---
|
||||
id: 5900f3ad1000cf542c50fec0
|
||||
title: 'Problem 65: Convergents of e'
|
||||
title: 'Problema 65: convergenti di 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.
|
||||
La radice quadrata di 2 può essere scritta come una frazione continuata 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}$.
|
||||
La frazione continuata infinita può essere scritta, $\\sqrt{2} = \[1; (2)]$ indica che 2 ripete *ad infinitum*. In modo simile, $\\sqrt{23} = \[4; (1, 3, 1, 8)]$. La sequenza di valori parziali di frazioni continuati delle radici quadrate provvede l'approssimazione razionale migliore. Consideriamo le convergenze con $\\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:
|
||||
Quindi la sequenza delle prime dieci convergenze per $\\sqrt{2}$ sono:
|
||||
|
||||
$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:
|
||||
La cosa sorprendente è che la più importante costante matematica, $e = \[2; 1, 2, 1, 1, 4, 1, 1, 6, 1, ... , 1, 2k, 1, ...]$. I primi dieci termini della sequenza convergente di `e` sono:
|
||||
|
||||
$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$.
|
||||
La somma delle digite del numeratore del 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`.
|
||||
Trova la somma delle cifre nel numeratore per il `n`<sup>o</sup> convergente della frazione continuata di `e`.
|
||||
|
||||
# --hints--
|
||||
|
||||
`convergentsOfE(10)` should return a number.
|
||||
`convergentsOfE(10)` dovrebbe restituire un numero.
|
||||
|
||||
```js
|
||||
assert(typeof convergentsOfE(10) === 'number');
|
||||
```
|
||||
|
||||
`convergentsOfE(10)` should return `17`.
|
||||
`convergentsOfE(10)` dovrebbe restituire `17`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(convergentsOfE(10), 17);
|
||||
```
|
||||
|
||||
`convergentsOfE(30)` should return `53`.
|
||||
`convergentsOfE(30)` dovrebbe restituire `53`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(convergentsOfE(30), 53);
|
||||
```
|
||||
|
||||
`convergentsOfE(50)` should return `91`.
|
||||
`convergentsOfE(50)` dovrebbe restituire `91`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(convergentsOfE(50), 91);
|
||||
```
|
||||
|
||||
`convergentsOfE(70)` should return `169`.
|
||||
`convergentsOfE(70)` dovrebbe restituire `169`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(convergentsOfE(70), 169);
|
||||
```
|
||||
|
||||
`convergentsOfE(100)` should return `272`.
|
||||
`convergentsOfE(100)` dovrebbe restituire `272`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(convergentsOfE(100), 272);
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
---
|
||||
id: 5900f3ae1000cf542c50fec1
|
||||
title: 'Problem 66: Diophantine equation'
|
||||
title: 'Problema 66: equazione 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:
|
||||
Considera l'equazione quadratica diofantina della forma:
|
||||
|
||||
<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.
|
||||
Per esempio, quando D=13, la soluzione minimale in 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.
|
||||
Si può assumere che non ci sono soluzioni con numeri interi positivi quando D è un quadrato.
|
||||
|
||||
By finding minimal solutions in x for D = {2, 3, 5, 6, 7}, we obtain the following:
|
||||
Trovando la soluzione minimale in x per D = {2, 3, 5, 6, 7}, otteniamo quanto segue:
|
||||
|
||||
<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.
|
||||
Quindi, considerando soluzioni minimali per `x` quando D ≤ 7, la `x` più grande si ottiene quando D=5.
|
||||
|
||||
Find the value of D ≤ `n` in minimal solutions of `x` for which the largest value of `x` is obtained.
|
||||
Trova il valore di D ≤ `n` in soluzioni minimali di `x` per cui il valore più grande di `x` è ottenuto.
|
||||
|
||||
# --hints--
|
||||
|
||||
`diophantineEquation(7)` should return a number.
|
||||
`diophantineEquation(7)` dovrebbe restituire un numero.
|
||||
|
||||
```js
|
||||
assert(typeof diophantineEquation(7) === 'number');
|
||||
```
|
||||
|
||||
`diophantineEquation(7)` should return `5`.
|
||||
`diophantineEquation(7)` dovrebbe restituire `5`.
|
||||
|
||||
```
|
||||
assert.strictEqual(diophantineEquation(7), 5);
|
||||
```
|
||||
|
||||
`diophantineEquation(100)` should return `61`.
|
||||
`diophantineEquation(100)` dovrebbe restituire `61`.
|
||||
|
||||
```
|
||||
assert.strictEqual(diophantineEquation(100), 61);
|
||||
```
|
||||
|
||||
`diophantineEquation(409)` should return `409`.
|
||||
`diophantineEquation(409)` dovrebbe restituire `409`.
|
||||
|
||||
```
|
||||
assert.strictEqual(diophantineEquation(409), 409);
|
||||
```
|
||||
|
||||
`diophantineEquation(500)` should return `421`.
|
||||
`diophantineEquation(500)` dovrebbe restituire `421`.
|
||||
|
||||
```
|
||||
assert.strictEqual(diophantineEquation(500), 421);
|
||||
```
|
||||
|
||||
`diophantineEquation(1000)` should return `661`.
|
||||
`diophantineEquation(1000)` dovrebbe restituire `661`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(diophantineEquation(1000), 661);
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
---
|
||||
id: 5900f3b01000cf542c50fec2
|
||||
title: 'Problem 67: Maximum path sum II'
|
||||
title: 'Problema 67: Somma massima del percorso 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.
|
||||
Cominciando dalla parte superiore del triangolo sottostante e spostandosi verso i numeri adiacenti sulla riga sottostante, il totale massimo dall'alto al basso è 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.
|
||||
Cioè, 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.
|
||||
Trova il totale massimo da cima a fondo in `numTriangle`, un array 2D definito dietro le quinte contenente un triangolo con cento righe.
|
||||
|
||||
**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)
|
||||
**Nota:** questa è una versione molto più difficile del problema 18. Non è possibile provare ogni percorso per risolvere questo problema, ce ne sono 2<sup>99</sup> in tutto! Se tu potessi controllare mille miliardi (10<sup>12</sup>) di percorsi ogni secondo ci vorrebbero dieci milioni di anni per controllarli tutti. C'è un algoritmo efficiente per risolverlo. ;o)
|
||||
|
||||
# --hints--
|
||||
|
||||
`maximumPathSumII(testTriangle)` should return a number.
|
||||
`maximumPathSumII(testTriangle)` dovrebbe restituire un numero.
|
||||
|
||||
```js
|
||||
assert(typeof maximumPathSumII(_testTriangle) === 'number');
|
||||
```
|
||||
|
||||
`maximumPathSumII(testTriangle)` should return 23.
|
||||
`maximumPathSumII(testTriangle)` dovrebbe restituire 23.
|
||||
|
||||
```js
|
||||
assert.strictEqual(maximumPathSumII(_testTriangle), 23);
|
||||
```
|
||||
|
||||
`maximumPathSumII(numTriangle)` should return 7273.
|
||||
`maximumPathSumII(numTriangle)` dovrebbe restituire 7273.
|
||||
|
||||
```js
|
||||
assert.strictEqual(maximumPathSumII(_numTriangle), 7273);
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
---
|
||||
id: 5900f3b01000cf542c50fec3
|
||||
title: 'Problem 68: Magic 5-gon ring'
|
||||
title: 'Problema 68: Anello pentagonale magico'
|
||||
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.
|
||||
Considera il seguente anello trigonale, riempito con i numeri da 1 a 6, e con ogni riga che somma a 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="un esempio completo di un anello trigonale" 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.
|
||||
Lavorando in **senso orario** e iniziando dal gruppo di tre con il nodo esterno numericamente più piccolo (4, 3, 2 in questo esempio), ogni soluzione può essere descritta in modo univoco. Per esempio, la soluzione sopra può essere descritta dal set: 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.
|
||||
È possibile completare l'anello con quattro somme diverse: 9, 10, 11, e 12. Ci sono otto soluzioni in totale.
|
||||
|
||||
<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.
|
||||
Concatenando ogni gruppo è possibile formare stringhe a 9 cifre; la stringa più grande per un anello trigonale è 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 i numeri da 1 a 10, a seconda dell'arrangiamento, è possibile formare stringhe a 16 e 17 cifre. Qual è la stringa più grande a **16 cifre** per un anello pentagonale "magico"?
|
||||
|
||||
<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="un diagramma vuoto di un anello pentagonale" 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()` dovrebbe restituire un numero.
|
||||
|
||||
```js
|
||||
assert(typeof magic5GonRing() === 'number');
|
||||
```
|
||||
|
||||
`magic5GonRing()` should return 6531031914842725.
|
||||
`magic5GonRing()` dovrebbe restituire 6531031914842725.
|
||||
|
||||
```js
|
||||
assert.strictEqual(magic5GonRing(), 6531031914842725);
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
---
|
||||
id: 5900f3b11000cf542c50fec4
|
||||
title: 'Problem 69: Totient maximum'
|
||||
title: 'Problema 69: Toziente massimo'
|
||||
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$.
|
||||
La funzione Toziente di Eulero, ${\phi}(n)$ (a volte chiamata funzione phi), viene utilizzata per determinare il numero di numeri inferiori a `n` che sono relativamente primi a `n`. Ad esempio 1, 2, 4, 5, 7 e 8, sono tutti minori di nove e relativamente primi a nove, quindi ${\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.
|
||||
Si può vedere che `n` = 6 produce un massimo di $\displaystyle\frac{n}{{\phi}(n)}$ per `n` ≤ 10.
|
||||
|
||||
Find the value of `n` ≤ `limit` for which $\displaystyle\frac{n}{{\phi(n)}}$ is a maximum.
|
||||
Trova il valore di `n` ≤ `limite` per il quale $\displaystyle\frac{n}{{\phi(n)}}$ è un massimo.
|
||||
|
||||
# --hints--
|
||||
|
||||
`totientMaximum(10)` should return a number.
|
||||
`totientMaximum(10)` dovrebbe restituire un numero.
|
||||
|
||||
```js
|
||||
assert(typeof totientMaximum(10) === 'number');
|
||||
```
|
||||
|
||||
`totientMaximum(10)` should return `6`.
|
||||
`totientMaximum(10)` dovrebbe restituire `6`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(totientMaximum(10), 6);
|
||||
```
|
||||
|
||||
`totientMaximum(10000)` should return `2310`.
|
||||
`totientMaximum(10000)` dovrebbe restituire `2310`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(totientMaximum(10000), 2310);
|
||||
```
|
||||
|
||||
`totientMaximum(500000)` should return `30030`.
|
||||
`totientMaximum(500000)` dovrebbe restituire `30030`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(totientMaximum(500000), 30030);
|
||||
```
|
||||
|
||||
`totientMaximum(1000000)` should return `510510`.
|
||||
`totientMaximum(1000000)` dovrebbe restituire `510510`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(totientMaximum(1000000), 510510);
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
---
|
||||
id: 5900f3b21000cf542c50fec5
|
||||
title: 'Problem 70: Totient permutation'
|
||||
title: 'Problema 70: Permutazione Toziente'
|
||||
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$.
|
||||
La funzione Toziente di Eulero, ${\phi}(n)$ (a volte chiamata funzione phi), viene utilizzata per determinare il numero di numeri positivi minori o uguali a `n` che sono relativamente primi a `n`. Ad esempio 1, 2, 4, 5, 7 e 8, sono tutti minori di nove e relativamente primi a nove, quindi ${\phi}(9) = 6$. Il numero 1 è considerato relativamente primo di ogni numero positivo, quindi ${\phi}(1) = 1$.
|
||||
|
||||
Interestingly, ${\phi}(87109) = 79180$, and it can be seen that 87109 is a permutation of 79180.
|
||||
È interessante notare che ${\phi}(87109) = 79180$, e si può vedere che 87109 è una permutazione di 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.
|
||||
Trova il valore di `n`, 1 < `n` < `limite`, per cui ${\phi}(n)$ è una permutazione di `n` e il rapporto $\displaystyle\frac{n}{{\phi}(n)}$ produce un minimo.
|
||||
|
||||
# --hints--
|
||||
|
||||
`totientPermutation(10000)` should return a number.
|
||||
`totientPermutation(10000)` dovrebbe restituire un numero.
|
||||
|
||||
```js
|
||||
assert(typeof totientPermutation(10000) === 'number');
|
||||
```
|
||||
|
||||
`totientPermutation(10000)` should return `4435`.
|
||||
`totientPermutation(10000)` dovrebbe restituire `4435`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(totientPermutation(10000), 4435);
|
||||
```
|
||||
|
||||
`totientPermutation(100000)` should return `75841`.
|
||||
`totientPermutation(100000)` dovrebbe restituire `75841`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(totientPermutation(100000), 75841);
|
||||
```
|
||||
|
||||
`totientPermutation(500000)` should return `474883`.
|
||||
`totientPermutation(500000)` dovrebbe restituire `474883`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(totientPermutation(500000), 474883);
|
||||
```
|
||||
|
||||
`totientPermutation(10000000)` should return `8319823`.
|
||||
`totientPermutation(10000000)` dovrebbe restituire `8319823`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(totientPermutation(10000000), 8319823);
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
---
|
||||
id: 5900f3b31000cf542c50fec6
|
||||
title: 'Problem 71: Ordered fractions'
|
||||
title: 'Problema 71: frazioni ordinate'
|
||||
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.
|
||||
Considera la frazione, $\frac{n}{d}$, dove `n` e `d` sono numeri interi positivi. Se `n` < `d` e il fattore comune più alto, ${{HCF}(n, d)} = 1$, viene chiamata frazione ridotta propria.
|
||||
|
||||
If we list the set of reduced proper fractions for `d` ≤ 8 in ascending order of size, we get:
|
||||
Se elenchiamo la lista delle frazioni proprie ridotte per `d` ≤ 8 in ordine decrescente di dimensioni, otteniamo:
|
||||
|
||||
$$\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}$.
|
||||
Si può vedere che $\frac{2}{5}$ è la frazione immediatamente a sinistra di $\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}$.
|
||||
Elencando la lista di frazioni proprie ridotte per `d` ≤ `limit` in ordine crescente, trova il numeratore della frazione immediatamente a sinistra di $\frac{3}{7}$.
|
||||
|
||||
# --hints--
|
||||
|
||||
`orderedFractions(8)` should return a number.
|
||||
`orderedFractions(8)` dovrebbe restituire un numero.
|
||||
|
||||
```js
|
||||
assert(typeof orderedFractions(8) === 'number');
|
||||
```
|
||||
|
||||
`orderedFractions(8)` should return `2`.
|
||||
`orderedFractions(8)` dovrebbe restituire `2`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(orderedFractions(8), 2);
|
||||
```
|
||||
|
||||
`orderedFractions(10)` should return `2`.
|
||||
`orderedFractions(10)` dovrebbe restituire `2`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(orderedFractions(10), 2);
|
||||
```
|
||||
|
||||
`orderedFractions(9994)` should return `4283`.
|
||||
`orderedFractions(9994)` dovrebbe restituire `4283`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(orderedFractions(9994), 4283);
|
||||
```
|
||||
|
||||
`orderedFractions(500000)` should return `214283`.
|
||||
`orderedFractions(500000)` dovrebbe restituire `214283`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(orderedFractions(500000), 214283);
|
||||
```
|
||||
|
||||
`orderedFractions(1000000)` should return `428570`.
|
||||
`orderedFractions(1000000)` dovrebbe restituire `428570`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(orderedFractions(1000000), 428570);
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
---
|
||||
id: 5900f3b41000cf542c50fec7
|
||||
title: 'Problem 72: Counting fractions'
|
||||
title: 'Problema 72: contando frazioni'
|
||||
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.
|
||||
Considera la frazione, $\frac{n}{d}$, dove `n` e `d` sono numeri interi positivi. Se `n` < `d` e il fattore commune più alto, ${HCF}(n, d) = 1$, viene chiamata frazione ridotta propria.
|
||||
|
||||
If we list the set of reduced proper fractions for `d` ≤ 8 in ascending order of size, we get:
|
||||
Se elenchiamo la lista delle frazioni proprie ridotte per `d` ≤ 8 in ordine decrescente di dimensioni, otteniamo:
|
||||
|
||||
$$\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.
|
||||
Possiamo vedere che ci sono `21` elementi in questo set.
|
||||
|
||||
How many elements would be contained in the set of reduced proper fractions for `d` ≤ `limit`?
|
||||
Quanti elementi sarebbero contenuti nel set di frazioni proprie semplificate per `d` ≤ `limit`?
|
||||
|
||||
# --hints--
|
||||
|
||||
`countingFractions(8)` should return a number.
|
||||
`countingFractions(8)` dovrebbe restituire un numero.
|
||||
|
||||
```js
|
||||
assert(typeof countingFractions(8) === 'number');
|
||||
```
|
||||
|
||||
`countingFractions(8)` should return `21`.
|
||||
`countingFractions(8)` dovrebbe restituire `21`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(countingFractions(8), 21);
|
||||
```
|
||||
|
||||
`countingFractions(20000)` should return `121590395`.
|
||||
`countingFractions(20000)` dovrebbe restituire `121590395`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(countingFractions(20000), 121590395);
|
||||
```
|
||||
|
||||
`countingFractions(500000)` should return `75991039675`.
|
||||
`countingFractions(500000)` dovrebbe restituire `75991039675`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(countingFractions(500000), 75991039675);
|
||||
```
|
||||
|
||||
`countingFractions(1000000)` should return `303963552391`.
|
||||
`countingFractions(1000000)` dovrebbe restituire `303963552391`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(countingFractions(1000000), 303963552391);
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
---
|
||||
id: 5900f3b61000cf542c50fec8
|
||||
title: 'Problem 73: Counting fractions in a range'
|
||||
title: 'Problema 73: contare frazioni in un range'
|
||||
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.
|
||||
Considera la frazione, $\frac{n}{d}$, dove `n` e `d` sono numeri interi positivi. Se `n` < `d` e il fattore commune più alto, ${HCF}(n, d) = 1$, viene chiamata frazione ridotta propria.
|
||||
|
||||
If we list the set of reduced proper fractions for `d` ≤ 8 in ascending order of size, we get:
|
||||
Se elenchiamo la lista delle frazioni proprie ridotte per `d` ≤ 8 in ordine decrescente di dimensioni, otteniamo:
|
||||
|
||||
$$\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}$.
|
||||
Si vede che ci sono `3` frazioni tra $\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`?
|
||||
Quante frazioni ci sono tra $\frac{1}{3}$ e $\frac{1}{2}$ nel set ordinato di frazioni proprie semplificate per `d` ≤ `limit`?
|
||||
|
||||
# --hints--
|
||||
|
||||
`countingFractionsInARange(8)` should return a number.
|
||||
`countingFractionsInARange(8)` dovrebbe restituire un numero.
|
||||
|
||||
```js
|
||||
assert(typeof countingFractionsInARange(8) === 'number');
|
||||
```
|
||||
|
||||
`countingFractionsInARange(8)` should return `3`.
|
||||
`countingFractionsInARange(8)` dovrebbe restituire `3`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(countingFractionsInARange(8), 3);
|
||||
```
|
||||
|
||||
`countingFractionsInARange(1000)` should return `50695`.
|
||||
`countingFractionsInARange(1000)` dovrebbe restituire `50695`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(countingFractionsInARange(1000), 50695);
|
||||
```
|
||||
|
||||
`countingFractionsInARange(6000)` should return `1823861`.
|
||||
`countingFractionsInARange(6000)` dovrebbe restituire `1823861`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(countingFractionsInARange(6000), 1823861);
|
||||
```
|
||||
|
||||
`countingFractionsInARange(12000)` should return `7295372`.
|
||||
`countingFractionsInARange(12000)` dovrebbe restituire `7295372`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(countingFractionsInARange(12000), 7295372);
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
---
|
||||
id: 5900f3b61000cf542c50fec9
|
||||
title: 'Problem 74: Digit factorial chains'
|
||||
title: 'Problema 74: catene fattoriali di cifre'
|
||||
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:
|
||||
Il numero 145 è noto per la proprietà che la somma del fattoriale delle sue cifre è pari 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:
|
||||
Forse meno noto è 169, in quanto produce la più lunga catena di numeri che riportano a 169; si scopre che esistono solo tre di questi loop:
|
||||
|
||||
$$\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,
|
||||
Non è difficile dimostrare che OGNI numero di partenza alla fine entrerà in un ciclo. Per esempio,
|
||||
|
||||
$$\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.
|
||||
Partire con 69 produce una catena di cinque termini non ripetibili, ma la più lunga catena non ripetibile con un numero iniziale inferiore a un milione è di sessanta termini.
|
||||
|
||||
How many chains, with a starting number below `n`, contain exactly sixty non-repeating terms?
|
||||
Quante catene, con un numero iniziale inferiore a `n`, contengono esattamente sessanta termini non ripetibili?
|
||||
|
||||
# --hints--
|
||||
|
||||
`digitFactorialChains(2000)` should return a number.
|
||||
`digitFactorialChains(2000)` dovrebbe restituire un numero.
|
||||
|
||||
```js
|
||||
assert(typeof digitFactorialChains(2000) === 'number');
|
||||
```
|
||||
|
||||
`digitFactorialChains(2000)` should return `6`.
|
||||
`digitFactorialChains(2000)` dovrebbe restituire `6`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(digitFactorialChains(2000), 6);
|
||||
```
|
||||
|
||||
`digitFactorialChains(100000)` should return `42`.
|
||||
`digitFactorialChains(100000)` dovrebbe restituire `42`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(digitFactorialChains(100000), 42);
|
||||
```
|
||||
|
||||
`digitFactorialChains(500000)` should return `282`.
|
||||
`digitFactorialChains(500000)` dovrebbe restituire `282`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(digitFactorialChains(500000), 282);
|
||||
```
|
||||
|
||||
`digitFactorialChains(1000000)` should return `402`.
|
||||
`digitFactorialChains(1000000)` dovrebbe restituire `402`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(digitFactorialChains(1000000), 402);
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
---
|
||||
id: 5900f3b71000cf542c50feca
|
||||
title: 'Problem 75: Singular integer right triangles'
|
||||
title: 'Problema 75: terne pitagoriche singolari'
|
||||
challengeType: 5
|
||||
forumTopicId: 302188
|
||||
dashedName: problem-75-singular-integer-right-triangles
|
||||
@ -8,7 +8,7 @@ dashedName: problem-75-singular-integer-right-triangles
|
||||
|
||||
# --description--
|
||||
|
||||
It turns out that 12 cm is the smallest length of wire that can be bent to form an integer sided right angle triangle in exactly one way, but there are many more examples.
|
||||
La lunghezza più corta di un filo per formare con esso un triangolo rettangoloto con lati di lunghezza intera in un unico modo è 12 cm, ma ci sono molti altri esempi.
|
||||
|
||||
<div style='margin-left: 4em;'>
|
||||
<strong>12 cm:</strong> (3,4,5)<br>
|
||||
@ -19,41 +19,41 @@ It turns out that 12 cm is the smallest length of wire that can be bent to form
|
||||
<strong>48 cm:</strong> (12,16,20)<br><br>
|
||||
</div>
|
||||
|
||||
In contrast, some lengths of wire, like 20 cm, cannot be bent to form an integer sided right angle triangle, and other lengths allow more than one solution to be found; for example, using 120 cm it is possible to form exactly three different integer sided right angle triangles.
|
||||
Al contrario, alcune lunghezze di filo, come 20 cm, non possono essere piegate per formare un triengolo rettangolo con i lati di lunghezza intera, e altre lunghezze permettono più di una soluzione; per esempio usando 120 cm è possibile formare esattamente tre diversi angoli rettangoli con i lati aventi lunghezze intere.
|
||||
|
||||
<div style='margin-left: 4em;'>
|
||||
<strong>120 cm:</strong> (30,40,50), (20,48,52), (24,45,51)<br><br>
|
||||
</div>
|
||||
|
||||
Given that L is the length of the wire, for how many values of L ≤ `n` can exactly one, integer sided right angle, triangle be formed?
|
||||
Dato che L è la lunghezza del filo, per quanti valori di L ≤ `n` si può avere esattamente un triangolo rettangolo con i lati aventi lunghezze intere?
|
||||
|
||||
# --hints--
|
||||
|
||||
`singularIntRightTriangles(48)` should return a number.
|
||||
`singularIntRightTriangles(48)` dovrebbe restituire un numero.
|
||||
|
||||
```js
|
||||
assert(typeof singularIntRightTriangles(48) === 'number');
|
||||
```
|
||||
|
||||
`singularIntRightTriangles(48)` should return `6`.
|
||||
`singularIntRightTriangles(48)` dovrebbe restituire `6`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(singularIntRightTriangles(48), 6);
|
||||
```
|
||||
|
||||
`singularIntRightTriangles(700000)` should return `75783`.
|
||||
`singularIntRightTriangles(700000)` dovrebbe restituire `75783`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(singularIntRightTriangles(700000), 75783);
|
||||
```
|
||||
|
||||
`singularIntRightTriangles(1000000)` should return `107876`.
|
||||
`singularIntRightTriangles(1000000)` dovrebbe restituire `107876`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(singularIntRightTriangles(1000000), 107876);
|
||||
```
|
||||
|
||||
`singularIntRightTriangles(1500000)` should return `161667`.
|
||||
`singularIntRightTriangles(1500000)` dovrebbe restituire `161667`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(singularIntRightTriangles(1500000), 161667);
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
---
|
||||
id: 5900f3b81000cf542c50fecb
|
||||
title: 'Problem 76: Counting summations'
|
||||
title: 'Problema 76: contando somme'
|
||||
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:
|
||||
È possibile scrivere 5 come somma in esattamente sei modi diversi:
|
||||
|
||||
<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?
|
||||
In quanti modi diversi puoi scrivere `n` come somma di almeno due numeri interi positivi?
|
||||
|
||||
# --hints--
|
||||
|
||||
`countingSummations(5)` should return a number.
|
||||
`countingSummations(5)` dovrebbe restituire un numero.
|
||||
|
||||
```js
|
||||
assert(typeof countingSummations(5) === 'number');
|
||||
```
|
||||
|
||||
`countingSummations(5)` should return `6`.
|
||||
`countingSummations(5)` dovrebbe restituire `6`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(countingSummations(5), 6);
|
||||
```
|
||||
|
||||
`countingSummations(20)` should return `626`.
|
||||
`countingSummations(20)` dovrebbe restituire `626`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(countingSummations(20), 626);
|
||||
```
|
||||
|
||||
`countingSummations(50)` should return `204225`.
|
||||
`countingSummations(50)` dovrebbe restituire `204225`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(countingSummations(50), 204225);
|
||||
```
|
||||
|
||||
`countingSummations(100)` should return `190569291`.
|
||||
`countingSummations(100)` dovrebbe restituire `190569291`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(countingSummations(100), 190569291);
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
---
|
||||
id: 5900f3b91000cf542c50fecc
|
||||
title: 'Problem 77: Prime summations'
|
||||
title: 'Problema 77: somme di numeri primi'
|
||||
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:
|
||||
È possibile scrivere dieci come somma di numeri primi in esattamente cinque modi diversi:
|
||||
|
||||
<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 è il primo valore che può essere scritto come somma di numeri primi in più di `n` modi?
|
||||
|
||||
# --hints--
|
||||
|
||||
`primeSummations(5)` should return a number.
|
||||
`primeSummations(5)` dovrebbe restituire un numero.
|
||||
|
||||
```js
|
||||
assert(typeof primeSummations(5) === 'number');
|
||||
```
|
||||
|
||||
`primeSummations(5)` should return `11`.
|
||||
`primeSummations(5)` dovrebbe restituire `11`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(primeSummations(5), 11);
|
||||
```
|
||||
|
||||
`primeSummations(100)` should return `31`.
|
||||
`primeSummations(100)` dovrebbe restituire `31`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(primeSummations(100), 31);
|
||||
```
|
||||
|
||||
`primeSummations(1000)` should return `53`.
|
||||
`primeSummations(1000)` dovrebbe restituire `53`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(primeSummations(1000), 53);
|
||||
```
|
||||
|
||||
`primeSummations(5000)` should return `71`.
|
||||
`primeSummations(5000)` dovrebbe restituire `71`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(primeSummations(5000), 71);
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
---
|
||||
id: 5900f3ba1000cf542c50fecd
|
||||
title: 'Problem 78: Coin partitions'
|
||||
title: 'Problema 78: Partizioni di monete'
|
||||
challengeType: 5
|
||||
forumTopicId: 302191
|
||||
dashedName: problem-78-coin-partitions
|
||||
@ -8,11 +8,11 @@ dashedName: problem-78-coin-partitions
|
||||
|
||||
# --description--
|
||||
|
||||
Let ${p}(n)$ represent the number of different ways in which `n` coins can be separated into piles. For example, five coins can be separated into piles in exactly seven different ways, so ${p}(5) = 7$.
|
||||
${p}(n)$ rappresenta il numero di modi differenti nei quali `n` monete possono essere separate in pile. Ad esempio, cinque monete possono essere separate in pile esattamente in sette modi diversi, quindi ${p}(5) = 7$.
|
||||
|
||||
<div style='text-align: center;'>
|
||||
|
||||
| Coin piles |
|
||||
| Pile di monete |
|
||||
| ----------------- |
|
||||
| OOOOO |
|
||||
| OOOO O |
|
||||
@ -24,35 +24,35 @@ Let ${p}(n)$ represent the number of different ways in which `n` coins can be se
|
||||
|
||||
</div><br>
|
||||
|
||||
Find the least value of `n` for which ${p}(n)$ is divisible by `divisor`.
|
||||
Trova il valore minimo di `n` per il quale ${p}(n)$ è divisibile per `divisor`.
|
||||
|
||||
# --hints--
|
||||
|
||||
`coinPartitions(7)` should return a number.
|
||||
`coinPartitions(7)` dovrebbe restituire un numero.
|
||||
|
||||
```js
|
||||
assert(typeof coinPartitions(7) === 'number');
|
||||
```
|
||||
|
||||
`coinPartitions(7)` should return `5`.
|
||||
`coinPartitions(7)` dovrebbe restituire `5`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(coinPartitions(7), 5);
|
||||
```
|
||||
|
||||
`coinPartitions(10000)` should return `599`.
|
||||
`coinPartitions(10000)` dovrebbe restituire `599`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(coinPartitions(10000), 599);
|
||||
```
|
||||
|
||||
`coinPartitions(100000)` should return `11224`.
|
||||
`coinPartitions(100000)` dovrebbe restituire `11224`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(coinPartitions(100000), 11224);
|
||||
```
|
||||
|
||||
`coinPartitions(1000000)` should return `55374`.
|
||||
`coinPartitions(1000000)` dovrebbe restituire `55374`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(coinPartitions(1000000), 55374);
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
---
|
||||
id: 5900f3bb1000cf542c50fece
|
||||
title: 'Problem 79: Passcode derivation'
|
||||
title: 'Problema 79: derivazione di codice chiave'
|
||||
challengeType: 5
|
||||
forumTopicId: 302192
|
||||
dashedName: problem-79-passcode-derivation
|
||||
@ -8,33 +8,33 @@ dashedName: problem-79-passcode-derivation
|
||||
|
||||
# --description--
|
||||
|
||||
A common security method used for online banking is to ask the user for three random characters from a passcode. For example, if the passcode was `531278`, they may ask for the 2nd, 3rd, and 5th characters; the expected reply would be: `317`.
|
||||
Un comune metodo sicuro usato per banking online è di chiedere a un utente tre caratteri random da un codice chiave. Per esempio se il codice è `531278`, potrebbero chiedere per il secondo, terzo e quinto carattere; la risposta aspettata sarebbe: `317`.
|
||||
|
||||
The arrays, `keylog1`, `keylog2`, and `keylog3`, contains fifty successful login attempts.
|
||||
Gli array,, `keylog1`, `keylog2`, e `keylog3`, contengono cinquanta tentativi di login che hanno avuto successo.
|
||||
|
||||
Given that the three characters are always asked for in order, analyze the array so as to determine the shortest possible secret passcode of unknown length.
|
||||
Dati che i tre caratteri sono sempre in ordine, analizza l'array così da determinare la password più corta possibile di lunghezza sconosciuta.
|
||||
|
||||
# --hints--
|
||||
|
||||
`passcodeDerivation(keylog1)` should return a number.
|
||||
`passcodeDerivation(keylog1)` dovrebbe restituire un numero.
|
||||
|
||||
```js
|
||||
assert(typeof passcodeDerivation(_keylog1) === 'number');
|
||||
```
|
||||
|
||||
`passcodeDerivation(keylog1)` should return `531278`.
|
||||
`passcodeDerivation(keylog1)` dovrebbe restituire `531278`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(passcodeDerivation(_keylog1), 531278);
|
||||
```
|
||||
|
||||
`passcodeDerivation(keylog2)` should return `1230567`.
|
||||
`passcodeDerivation(keylog2)` dovrebbe restituire `1230567`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(passcodeDerivation(_keylog2), 1230567);
|
||||
```
|
||||
|
||||
`passcodeDerivation(keylog3)` should return `73162890`.
|
||||
`passcodeDerivation(keylog3)` dovrebbe restituire `73162890`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(passcodeDerivation(_keylog3), 73162890);
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
---
|
||||
id: 5900f3bc1000cf542c50fecf
|
||||
title: 'Problem 80: Square root digital expansion'
|
||||
title: 'Problema 80: Espansione digitale della radice quadrata'
|
||||
challengeType: 5
|
||||
forumTopicId: 302194
|
||||
dashedName: problem-80-square-root-digital-expansion
|
||||
@ -8,33 +8,33 @@ dashedName: problem-80-square-root-digital-expansion
|
||||
|
||||
# --description--
|
||||
|
||||
It is well known that if the square root of a natural number is not an integer, then it is irrational. The decimal expansion of such square roots is infinite without any repeating pattern at all.
|
||||
È noto che se la radice quadrata di un numero naturale non è un intero, allora è irrazionale. L'espansione decimale di tali radici quadrate è infinita senza alcun pattern di ripetizione.
|
||||
|
||||
The square root of two is `1.41421356237309504880...`, and the digital sum of the first one hundred decimal digits is `475`.
|
||||
La radice quadrata di due è `1.41421356237309504880...`, e la somma digitale delle prime cento cifre decimali è `475`.
|
||||
|
||||
For the first `n` natural numbers, find the total of the digital sums of the first one hundred decimal digits for all the irrational square roots.
|
||||
Per i primi `n` numeri naturali, trova il totale delle somme digitali delle prime cento cifre decimali per tutte le radici quadrate irrazionali.
|
||||
|
||||
# --hints--
|
||||
|
||||
`sqrtDigitalExpansion(2)` should return a number.
|
||||
`sqrtDigitalExpansion(2)` dovrebbe restituire un numero.
|
||||
|
||||
```js
|
||||
assert(typeof sqrtDigitalExpansion(2) === 'number');
|
||||
```
|
||||
|
||||
`sqrtDigitalExpansion(2)` should return `475`.
|
||||
`sqrtDigitalExpansion(2)` dovrebbe restituire `475`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(sqrtDigitalExpansion(2), 475);
|
||||
```
|
||||
|
||||
`sqrtDigitalExpansion(50)` should return `19543`.
|
||||
`sqrtDigitalExpansion(50)` dovrebbe restituire `19543`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(sqrtDigitalExpansion(50), 19543);
|
||||
```
|
||||
|
||||
`sqrtDigitalExpansion(100)` should return `40886`.
|
||||
`sqrtDigitalExpansion(100)` dovrebbe restituire `40886`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(sqrtDigitalExpansion(100), 40886);
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
---
|
||||
id: 5900f3bd1000cf542c50fed0
|
||||
title: 'Problem 81: Path sum: two ways'
|
||||
title: 'Problema 81: Somma del percorso: due direzioni'
|
||||
challengeType: 5
|
||||
forumTopicId: 302195
|
||||
dashedName: problem-81-path-sum-two-ways
|
||||
@ -8,27 +8,27 @@ dashedName: problem-81-path-sum-two-ways
|
||||
|
||||
# --description--
|
||||
|
||||
In the 5 by 5 matrix below, the minimal path sum from the top left to the bottom right, by **only moving to the right and down**, is indicated in bold red and is equal to `2427`.
|
||||
Nella matrice 5x5 sotto, il percorso della somma più piccola dall'angolo in alto a sinistra all'angolo in basso a destra, **muovendo solo verso destra e verso il basso**, è indicato in rosso grassetto ed è uguale a `2427`.
|
||||
|
||||
$$\begin{pmatrix} \color{red}{131} & 673 & 234 & 103 & 18\\\\ \color{red}{201} & \color{red}{96} & \color{red}{342} & 965 & 150\\\\ 630 & 803 & \color{red}{746} & \color{red}{422} & 111\\\\ 537 & 699 & 497 & \color{red}{121} & 956\\\\ 805 & 732 & 524 & \color{red}{37} & \color{red}{331} \end{pmatrix}$$
|
||||
|
||||
Find the minimal path sum from the top left to the bottom right by only moving right and down in `matrix`, a 2D array representing a matrix. The maximum matrix size used in the tests will be 80 by 80.
|
||||
Trova il percorso della somma più piccola dall'angolo in alto a sinistra all'angolo in basso a destra muovendo solo verso destra e verso il basso in `matrix`, un array 2D rappresentante una matrice. La dimenzione più grande di una matrice usata nei test è 80x80.
|
||||
|
||||
# --hints--
|
||||
|
||||
`pathSumTwoWays(testMatrix1)` should return a number.
|
||||
`pathSumTwoWays(testMatrix1)` dovrebbe restituire un numero.
|
||||
|
||||
```js
|
||||
assert(typeof pathSumTwoWays(_testMatrix1) === 'number');
|
||||
```
|
||||
|
||||
`pathSumTwoWays(testMatrix1)` should return `2427`.
|
||||
`pathSumTwoWays(testMatrix1)` dovrebbe restituire `2427`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(pathSumTwoWays(_testMatrix1), 2427);
|
||||
```
|
||||
|
||||
`pathSumTwoWays(testMatrix2)` should return `427337`.
|
||||
`pathSumTwoWays(testMatrix2)` dovrebbe restituire `427337`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(pathSumTwoWays(_testMatrix2), 427337);
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
---
|
||||
id: 5900f3be1000cf542c50fed1
|
||||
title: 'Problem 82: Path sum: three ways'
|
||||
title: 'Problema 82: Somma del percorso: tre direzioni'
|
||||
challengeType: 5
|
||||
forumTopicId: 302196
|
||||
dashedName: problem-82-path-sum-three-ways
|
||||
@ -8,29 +8,29 @@ dashedName: problem-82-path-sum-three-ways
|
||||
|
||||
# --description--
|
||||
|
||||
**Note:** This problem is a more challenging version of Problem 81.
|
||||
**Nota:** Questo problema è una versione più impegnativa del Problema 81.
|
||||
|
||||
The minimal path sum in the 5 by 5 matrix below, by starting in any cell in the left column and finishing in any cell in the right column, and only moving up, down, and right, is indicated in red and bold; the sum is equal to `994`.
|
||||
La somma minima del percorso nella matrice 5 per 5 qui sotto, iniziando in qualsiasi cella nella colonna di sinistra e terminando in qualsiasi cella nella colonna di destra, e solo muovendosi verso l'alto, verso il basso e verso destra, è indicata in rosso e in grassetto; la somma è pari a `994`.
|
||||
|
||||
$$\begin{pmatrix} 131 & 673 & \color{red}{234} & \color{red}{103} & \color{red}{18}\\\\ \color{red}{201} & \color{red}{96} & \color{red}{342} & 965 & 150\\\\ 630 & 803 & 746 & 422 & 111\\\\ 537 & 699 & 497 & 121 & 956\\\\ 805 & 732 & 524 & 37 & 331 \end{pmatrix}$$
|
||||
|
||||
Find the minimal path sum from the left column to the right column in `matrix`, a 2D array representing a matrix. The maximum matrix size used in tests will be 80 by 80.
|
||||
Trova la somma del percorso minimo dalla colonna di sinistra alla colonna di destra in `matrix`, un array 2D che rappresenta una matrice. La dimensione massima della matrice utilizzata nei test sarà di 80 per 80.
|
||||
|
||||
# --hints--
|
||||
|
||||
`pathSumThreeWays(testMatrix1)` should return a number.
|
||||
`pathSumThreeWays(testMatrix1)` dovrebbe restituire un numero.
|
||||
|
||||
```js
|
||||
assert(typeof pathSumThreeWays(_testMatrix1) === 'number');
|
||||
```
|
||||
|
||||
`pathSumThreeWays(testMatrix1)` should return `994`.
|
||||
`pathSumThreeWays(testMatrix1)` dovrebbe restituire `994`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(pathSumThreeWays(_testMatrix1), 994);
|
||||
```
|
||||
|
||||
`pathSumThreeWays(testMatrix2)` should return `260324`.
|
||||
`pathSumThreeWays(testMatrix2)` dovrebbe restituire `260324`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(pathSumThreeWays(_testMatrix2), 260324);
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
---
|
||||
id: 5900f3bf1000cf542c50fed2
|
||||
title: 'Problem 83: Path sum: four ways'
|
||||
title: 'Problema 83: percorso della somma: quattro direzioni'
|
||||
challengeType: 5
|
||||
forumTopicId: 302197
|
||||
dashedName: problem-83-path-sum-four-ways
|
||||
@ -8,29 +8,29 @@ dashedName: problem-83-path-sum-four-ways
|
||||
|
||||
# --description--
|
||||
|
||||
**Note:** This problem is a significantly more challenging version of Problem 81.
|
||||
**Nota:** Questo problema è una versione molto più difficile di problema 81.
|
||||
|
||||
In the 5 by 5 matrix below, the minimal path sum from the top left to the bottom right, by moving left, right, up, and down, is indicated in bold red and is equal to `2297`.
|
||||
Nella matrice 5 x 5 sotto, il percorso della somma più piccola dall'angolo in alto a sinistra all'angolo in basso a destra, muovendo verso destra, sinistra, alto e basso, è indicato in rosso grassetto ed è uguale a `2297`.
|
||||
|
||||
$$\begin{pmatrix} \color{red}{131} & 673 & \color{red}{234} & \color{red}{103} & \color{red}{18}\\\\ \color{red}{201} & \color{red}{96} & \color{red}{342} & 965 & \color{red}{150}\\\\ 630 & 803 & 746 & \color{red}{422} & \color{red}{111}\\\\ 537 & 699 & 497 & \color{red}{121} & 956\\\\ 805 & 732 & 524 & \color{red}{37} & \color{red}{331} \end{pmatrix}$$
|
||||
|
||||
Find the minimal path sum from the top left to the bottom right by moving left, right, up, and down in `matrix`, a 2D array representing a matrix. The maximum matrix size used in tests will be 80 by 80.
|
||||
Trova il percorso della somma più piccola dall'angolo in alto a sinistra all'angolo in basso a destra muovendo a sinistra, destra, alto e basso in `matrix`, un array 2D rappresentate una matrice. La dimensione massima della matrice utilizzata nei test sarà di 80 per 80.
|
||||
|
||||
# --hints--
|
||||
|
||||
`pathSumFourWays(testMatrix1)` should return a number.
|
||||
`pathSumFourWays(testMatrix1)` dovrebbe restituire un numero.
|
||||
|
||||
```js
|
||||
assert(typeof pathSumFourWays(_testMatrix1) === 'number');
|
||||
```
|
||||
|
||||
`pathSumFourWays(testMatrix1)` should return `2297`.
|
||||
`pathSumFourWays(testMatrix1)` dovrebbe restituire `2297`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(pathSumFourWays(_testMatrix1), 2297);
|
||||
```
|
||||
|
||||
`pathSumFourWays(testMatrix2)` should return `425185`.
|
||||
`pathSumFourWays(testMatrix2)` dovrebbe restituire `425185`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(pathSumFourWays(_testMatrix2), 425185);
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
---
|
||||
id: 5900f3c11000cf542c50fed3
|
||||
title: 'Problem 84: Monopoly odds'
|
||||
title: 'Problema 84: probabilità del Monopoli'
|
||||
challengeType: 5
|
||||
forumTopicId: 302198
|
||||
dashedName: problem-84-monopoly-odds
|
||||
@ -8,13 +8,13 @@ dashedName: problem-84-monopoly-odds
|
||||
|
||||
# --description--
|
||||
|
||||
In the game, *Monopoly*, the standard board is set up in the following way:
|
||||
Nel gioco, *Monopoly*, il tabellone standard è sistemato in questo modo:
|
||||
|
||||
<div style="text-align: center;">
|
||||
<table cellspacing="1" cellpadding="5" border="0" style="background-color: black; color: black;" align="center">
|
||||
<tbody>
|
||||
<tr>
|
||||
<td style="background-color: #ffffff; color: black; padding: 5px; border: 1px solid black;">GO</td>
|
||||
<td style="background-color: #ffffff; color: black; padding: 5px; border: 1px solid black;">VIA</td>
|
||||
<td style="background-color: #ffffff; color: black; padding: 5px; border: 1px solid black;">A1</td>
|
||||
<td style="background-color: #ffffff; color: black; padding: 5px; border: 1px solid black;">CC1</td>
|
||||
<td style="background-color: #ffffff; color: black; padding: 5px; border: 1px solid black;">A2</td>
|
||||
@ -24,7 +24,7 @@ In the game, *Monopoly*, the standard board is set up in the following way:
|
||||
<td style="background-color: #ffffff; color: black; padding: 5px; border: 1px solid black;">CH1</td>
|
||||
<td style="background-color: #ffffff; color: black; padding: 5px; border: 1px solid black;">B2</td>
|
||||
<td style="background-color: #ffffff; color: black; padding: 5px; border: 1px solid black;">B3</td>
|
||||
<td style="background-color: #ffffff; color: black; padding: 5px; border: 1px solid black;">JAIL</td>
|
||||
<td style="background-color: #ffffff; color: black; padding: 5px; border: 1px solid black;">PRIGIONE</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td style="background-color: #ffffff; color: black; padding: 5px; border: 1px solid black;">H2</td>
|
||||
@ -88,69 +88,69 @@ In the game, *Monopoly*, the standard board is set up in the following way:
|
||||
</table>
|
||||
</div><br>
|
||||
|
||||
A player starts on the GO square and adds the scores on two 6-sided dice to determine the number of squares they advance in a clockwise direction. Without any further rules we would expect to visit each square with equal probability: 2.5%. However, landing on G2J (Go To Jail), CC (community chest), and CH (chance) changes this distribution.
|
||||
Il giocatore inizia nella cella del VIA e somma il risultato di due dadi a sei facce per determinare il numero di caselle di cui avanzano in senso orario. Senza regole aggiuntive ci aspetteremmo di visitare ogni casella con la stessa probabilità: 2,5%. Invece, finire su G2J (Go to jail - vai in prigione), CC (community chest - imprevisto), e CH (chance - probabilità) cambia questa distribuzione.
|
||||
|
||||
In addition to G2J, and one card from each of CC and CH, that orders the player to go directly to jail, if a player rolls three consecutive doubles, they do not advance the result of their 3rd roll. Instead they proceed directly to jail.
|
||||
In aggiunta a G2J e una carta ciascuno per CC e CH che ordina al giocatore di andare direttamente in prigione, se un giocatore tira tre doppi consecutivi questo non avanza del risultato del loro terzo tiro. Invece va direttamente in prigione.
|
||||
|
||||
At the beginning of the game, the CC and CH cards are shuffled. When a player lands on CC or CH they take a card from the top of the respective pile and, after following the instructions, it is returned to the bottom of the pile. There are sixteen cards in each pile, but for the purpose of this problem we are only concerned with cards that order a movement; any instruction not concerned with movement will be ignored and the player will remain on the CC/CH square.
|
||||
All'inizio del gioco, le carte CC e CH sono mescolate. Quando un giocatore finisce su una carta CC o CH questo prende una carta dalla cima del rispettivo mazzo e, dopo aver seguito le istruzioni, è rimessa al fondo della pila. Ci sono sedici carte in ogni mazzo, ma per l'obbiettivo di questo problema ci interessano solo le carte che dicono di muoversi; qualsiasi istruzione non legata con il movimento sarà ignorata e il giocatore rimarrà sulla casella CC/CH.
|
||||
|
||||
<ul>
|
||||
<li>Community Chest (2/16 cards):</li>
|
||||
<li>Imprevisto (2/16 carte):</li>
|
||||
<ol>
|
||||
<li>Advance to GO</li>
|
||||
<li>Go to JAIL</li>
|
||||
<li>Vai al VIA</li>
|
||||
<li>Vai in PRIGIONE</li>
|
||||
</ol>
|
||||
|
||||
<li>Chance (10/16 cards):</li>
|
||||
<li>Probabilità (10/16 carte):</li>
|
||||
<ol>
|
||||
<li>Advance to GO</li>
|
||||
<li>Go to JAIL</li>
|
||||
<li>Go to C1</li>
|
||||
<li>Go to E3</li>
|
||||
<li>Go to H2</li>
|
||||
<li>Go to R1</li>
|
||||
<li>Go to next R (railway company)</li>
|
||||
<li>Go to next R</li>
|
||||
<li>Go to next U (utility company)</li>
|
||||
<li>Go back 3 squares.</li>
|
||||
<li>Vai al VIA</li>
|
||||
<li>Vai in PRIGIONE</li>
|
||||
<li>Vai a C1</li>
|
||||
<li>Vai a E3</li>
|
||||
<li>Vai ad H2</li>
|
||||
<li>Vai a R1</li>
|
||||
<li>Vai al R successivo (stazione ferroviaria)</li>
|
||||
<li>Vai al R successivo</li>
|
||||
<li>Vai al U successivo (compagnia elettrica/dell'acqua)</li>
|
||||
<li>Indietreggia di 3 caselle.</li>
|
||||
</ol>
|
||||
</ul>
|
||||
|
||||
The heart of this problem concerns the likelihood of visiting a particular square. That is, the probability of finishing at that square after a roll. For this reason it should be clear that, with the exception of G2J for which the probability of finishing on it is zero, the CH squares will have the lowest probabilities, as 5/8 request a movement to another square, and it is the final square that the player finishes at on each roll that we are interested in. We shall make no distinction between "Just Visiting" and being sent to JAIL, and we shall also ignore the rule about requiring a double to "get out of jail", assuming that they pay to get out on their next turn.
|
||||
Il cuore di questo problema si incentra sulla probabilità di visitare una certa casella. Cioè, la probabilità di finire su quella casella dopo un tiro di dado. Per questa ragione dovrebbe essere chiaro che, con l'eccezzione di G2J per cui la probabilità di finire un movimento su di esso è zero, le caselle CH hanno la probabilità minore, visto che 5/8 carte dicono di muoversi su un'altra casella, e quella è la casella finale su cui il giocatore finisce il movimento per ogni tiro a cui siamo interessati. Non facciamo alcuna distinzione tra "Visita alla prigione" e venir mandati in prigione, e ignoriamo la regola che richiede un doppio per uscire di prigione, assumendo che il giocatore paga al turno successivo per uscire di prigione.
|
||||
|
||||
By starting at GO and numbering the squares sequentially from 00 to 39 we can concatenate these two-digit numbers to produce strings that correspond with sets of squares.
|
||||
Iniziando al VIA e numerando le celle sequenzialmente da 00 a 39 possiamo concatenare questi numeri a due cifre per produrre stringhe che corrispondono a set di celle.
|
||||
|
||||
Statistically it can be shown that the three most popular squares, in order, are JAIL (6.24%) = Square 10, E3 (3.18%) = Square 24, and GO (3.09%) = Square 00. So these three most popular squares can be listed with the six-digit modal string `102400`.
|
||||
Statisticamente si può mostrare che le tre celle più popolari sono, in ordine, PRIGIONE (6.24%) = cella 10, E3 (3.18%) = cella 24 e VIA (3.09%) = square 00. Queste tre celle più popolari possono essere elencate con la stringa a sei cifre `102400`.
|
||||
|
||||
If, instead of using two 6-sided dice, two `n`-sided dice are used, find the six-digit modal string.
|
||||
Trova la stringa a sei cifre che si ottiene sostituendo i due dadi a 6 facce con due dadi ad `n` facce.
|
||||
|
||||
# --hints--
|
||||
|
||||
`monopolyOdds(8)` should return a string.
|
||||
`monopolyOdds(8)` dovrebbe restituire una stringa.
|
||||
|
||||
```js
|
||||
assert(typeof monopolyOdds(8) === 'string');
|
||||
```
|
||||
|
||||
`monopolyOdds(8)` should return string `102400`.
|
||||
`monopolyOdds(8)` dovrebbe restituire la stringa `102400`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(monopolyOdds(8), '102400');
|
||||
```
|
||||
|
||||
`monopolyOdds(10)` should return string `100024`.
|
||||
`monopolyOdds(10)` dovrebbe restituire la stringa `100024`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(monopolyOdds(10), '100024');
|
||||
```
|
||||
|
||||
`monopolyOdds(20)` should return string `100005`.
|
||||
`monopolyOdds(20)` dovrebbe restituire la stringa `100005`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(monopolyOdds(20), '100005');
|
||||
```
|
||||
|
||||
`monopolyOdds(4)` should return string `101524`.
|
||||
`monopolyOdds(4)` dovrebbe restituire la stringa `101524`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(monopolyOdds(4), '101524');
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
---
|
||||
id: 5900f3c11000cf542c50fed4
|
||||
title: 'Problem 85: Counting rectangles'
|
||||
title: 'Problema 85: contando rettangoli'
|
||||
challengeType: 5
|
||||
forumTopicId: 302199
|
||||
dashedName: problem-85-counting-rectangles
|
||||
@ -8,45 +8,45 @@ dashedName: problem-85-counting-rectangles
|
||||
|
||||
# --description--
|
||||
|
||||
By counting carefully it can be seen that a rectangular grid measuring 3 by 2 contains eighteen rectangles:
|
||||
Contando con attenzione si può vedere che una griglia rettangolare che misuraa 3 per 2 contiene 18 rettangoli:
|
||||
|
||||
<img class="img-responsive center-block" alt="a diagram of the different rectangles found within a 3 by 2 rectangular grid" src="https://cdn-media-1.freecodecamp.org/project-euler/counting-rectangles.png" style="background-color: white; padding: 10px;" />
|
||||
<img class="img-responsive center-block" alt="un diagramma dei differenti rettangoli trovati dentro una griglia rettangolare 3 per 2" src="https://cdn-media-1.freecodecamp.org/project-euler/counting-rectangles.png" style="background-color: white; padding: 10px;" />
|
||||
|
||||
Although there may not exists a rectangular grid that contains exactly `n` rectangles, find the area of the grid with the nearest solution.
|
||||
Anche se potrebbe esistere una griglia rettangolare che contiene esattamente `n` rettangoli, trova l'area della griglia con la soluzione più vicina.
|
||||
|
||||
# --hints--
|
||||
|
||||
`countingRectangles(18)` should return a number.
|
||||
`countingRectangles(18)` dovrebbe restituire un numero.
|
||||
|
||||
```js
|
||||
assert(typeof countingRectangles(18) === 'number');
|
||||
```
|
||||
|
||||
`countingRectangles(18)` should return `6`.
|
||||
`countingRectangles(18)` dovrebbe restituire `6`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(countingRectangles(18), 6);
|
||||
```
|
||||
|
||||
`countingRectangles(250)` should return `22`.
|
||||
`countingRectangles(250)` dovrebbe restituire `22`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(countingRectangles(250), 22);
|
||||
```
|
||||
|
||||
`countingRectangles(50000)` should return `364`.
|
||||
`countingRectangles(50000)` dovrebbe restituire `364`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(countingRectangles(50000), 364);
|
||||
```
|
||||
|
||||
`countingRectangles(1000000)` should return `1632`.
|
||||
`countingRectangles(1000000)` dovrebbe restituire `1632`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(countingRectangles(1000000), 1632);
|
||||
```
|
||||
|
||||
`countingRectangles(2000000)` should return `2772`.
|
||||
`countingRectangles(2000000)` dovrebbe restituire `2772`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(countingRectangles(2000000), 2772);
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
---
|
||||
id: 5900f3c31000cf542c50fed5
|
||||
title: 'Problem 86: Cuboid route'
|
||||
title: 'Problema 86: percorso del cuboide'
|
||||
challengeType: 5
|
||||
forumTopicId: 302200
|
||||
dashedName: problem-86-cuboid-route
|
||||
@ -8,43 +8,43 @@ dashedName: problem-86-cuboid-route
|
||||
|
||||
# --description--
|
||||
|
||||
A spider, S, sits in one corner of a cuboid room, measuring 6 by 5 by 3, and a fly, F, sits in the opposite corner. By travelling on the surfaces of the room the shortest "straight line" distance from S to F is 10 and the path is shown on the diagram.
|
||||
Un ragno, S, si trova in un angolo di una stanza cuboide, che misura 6 x 5 x 3, e una mosca, F, si trova nell'angolo opposto. Muovendosi sulla superficie della stanza la più corta distanza "linea dritta" da S a F è 10 e il percorso è mostrato nel diagramma.
|
||||
|
||||
<img class="img-responsive center-block" alt="a diagram of a spider and fly's path from one corner of a cuboid room to the opposite corner" src="https://cdn-media-1.freecodecamp.org/project-euler/cuboid-route.png" style="background-color: white; padding: 10px;" />
|
||||
<img class="img-responsive center-block" alt="un diagramma del percorso di un ragno e una mosca da un vertice di una stanza cuboidale al vertice opposto" src="https://cdn-media-1.freecodecamp.org/project-euler/cuboid-route.png" style="background-color: white; padding: 10px;" />
|
||||
|
||||
However, there are up to three "shortest" path candidates for any given cuboid and the shortest route doesn't always have integer length.
|
||||
Invece, ci sono fino a tre candidati come percorso "più corto" per ogni dato cuboide e il percorso non ha sempre una lunghezza intera.
|
||||
|
||||
It can be shown that there are exactly `2060` distinct cuboids, ignoring rotations, with integer dimensions, up to a maximum size of M by M by M, for which the shortest route has integer length when M = 100. This is the least value of M for which the number of solutions first exceeds two thousand; the number of solutions when M = 99 is `1975`.
|
||||
Si può mostrare che ci sono esattamente `2060` cuboidi distinti, ignorando le rotazioni, con lati interi, fino a una dimensione massima di M per M per M, per cui il percorso più corto ha una lunghezza intera per M = 100. Questo è il valore più piccolo di M per cui il numero delle soluzioni eccede per la prima volta il duemila; il numero delle soluzioni per M = 99 è `1975`.
|
||||
|
||||
Find the least value of M such that the number of solutions first exceeds `n`.
|
||||
Trova l'ultimo valore di M per cui il numero delle soluzioni eccede per primo `n`.
|
||||
|
||||
# --hints--
|
||||
|
||||
`cuboidRoute(2000)` should return a number.
|
||||
`cuboidRoute(2000)` dovrebbe restituire un numero.
|
||||
|
||||
```js
|
||||
assert(typeof cuboidRoute(2000) === 'number');
|
||||
```
|
||||
|
||||
`cuboidRoute(2000)` should return `100`.
|
||||
`cuboidRoute(2000)` dovrebbe restituire `100`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(cuboidRoute(2000), 100);
|
||||
```
|
||||
|
||||
`cuboidRoute(25000)` should return `320`.
|
||||
`cuboidRoute(25000)` dovrebbe restituire `320`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(cuboidRoute(25000), 320);
|
||||
```
|
||||
|
||||
`cuboidRoute(500000)` should return `1309`.
|
||||
`cuboidRoute(500000)` dovrebbe restituire `1309`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(cuboidRoute(500000), 1309);
|
||||
```
|
||||
|
||||
`cuboidRoute(1000000)` should return `1818`.
|
||||
`cuboidRoute(1000000)` dovrebbe restituire `1818`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(cuboidRoute(1000000), 1818);
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
---
|
||||
id: 5900f3c51000cf542c50fed8
|
||||
title: 'Problem 87: Prime power triples'
|
||||
title: 'Problema 87: triplette di potenze di numeri primi'
|
||||
challengeType: 5
|
||||
forumTopicId: 302201
|
||||
dashedName: problem-87-prime-power-triples
|
||||
@ -8,7 +8,7 @@ dashedName: problem-87-prime-power-triples
|
||||
|
||||
# --description--
|
||||
|
||||
The smallest number expressible as the sum of a prime square, prime cube, and prime fourth power is `28`. In fact, there are exactly four numbers below fifty that can be expressed in such a way:
|
||||
Il numeri più piccolo che può essere espresso come la somma di un quadrato, un cubo e una quarta potenza di numeri primi è `28`. Infatti, ci sono esattamente quattro numeri sotto cinquanta che possono essere scritti in questo modo:
|
||||
|
||||
<div style='margin-left: 4em;'>
|
||||
28 = 2<sup>2</sup> + 2<sup>3</sup> + 2<sup>4</sup><br>
|
||||
@ -17,41 +17,41 @@ The smallest number expressible as the sum of a prime square, prime cube, and pr
|
||||
47 = 2<sup>2</sup> + 3<sup>3</sup> + 2<sup>4</sup>
|
||||
</div><br>
|
||||
|
||||
How many numbers below `n` can be expressed as the sum of a prime square, prime cube, and prime fourth power?
|
||||
Quanti numeri al di sotto di `n` possono essere espressi come somma di un quadrato, un cubo e una terza potenza di numeri primi?
|
||||
|
||||
# --hints--
|
||||
|
||||
`primePowerTriples(50)` should return a number.
|
||||
`primePowerTriples(50)` dovrebbe restituire un numero.
|
||||
|
||||
```js
|
||||
assert(typeof primePowerTriples(50) === 'number');
|
||||
```
|
||||
|
||||
`primePowerTriples(50)` should return `4`.
|
||||
`primePowerTriples(50)` dovrebbe restituire `4`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(primePowerTriples(50), 4);
|
||||
```
|
||||
|
||||
`primePowerTriples(10035)` should return `684`.
|
||||
`primePowerTriples(10035)` dovrebbe restituire `684`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(primePowerTriples(10035), 684);
|
||||
```
|
||||
|
||||
`primePowerTriples(500000)` should return `18899`.
|
||||
`primePowerTriples(500000)` dovrebbe restituire `18899`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(primePowerTriples(500000), 18899);
|
||||
```
|
||||
|
||||
`primePowerTriples(5000000)` should return `138932`.
|
||||
`primePowerTriples(5000000)` dovrebbe restituire `138932`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(primePowerTriples(5000000), 138932);
|
||||
```
|
||||
|
||||
`primePowerTriples(50000000)` should return `1097343`.
|
||||
`primePowerTriples(50000000)` dovrebbe restituire `1097343`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(primePowerTriples(50000000), 1097343);
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
---
|
||||
id: 5900f3c51000cf542c50fed6
|
||||
title: 'Problem 88: Product-sum numbers'
|
||||
title: 'Problema 88: numeri prodotto-somma'
|
||||
challengeType: 5
|
||||
forumTopicId: 302203
|
||||
dashedName: problem-88-product-sum-numbers
|
||||
@ -8,11 +8,11 @@ dashedName: problem-88-product-sum-numbers
|
||||
|
||||
# --description--
|
||||
|
||||
A natural number, `N`, that can be written as the sum and product of a given set of at least two natural numbers, $\\{a_1, a_2, \ldots , a_k\\}$ is called a product-sum number: $N = a_1 + a_2 + \cdots + a_k = a_1 × a_2 × \cdots × a_k$.
|
||||
Un numero naturale, `N`, che può essere scritto come somma e prodotto di un dato set di almeno due numeri naturali, $\\{a_1, a_2, \ldots , a_k\\}$, è chiamato numero prodotto-somma: $N = a_1 + a_2 + \cdots + a_k = a_1 × a_2 × \cdots × a_k$.
|
||||
|
||||
For example, 6 = 1 + 2 + 3 = 1 × 2 × 3.
|
||||
Per esempio, 6 = 1 + 2 + 3 = 1 × 2 × 3.
|
||||
|
||||
For a given set of size, `k`, we shall call the smallest N with this property a minimal product-sum number. The minimal product-sum numbers for sets of size, `k` = 2, 3, 4, 5, and 6 are as follows.
|
||||
Per una data dimensione del set, `k`, chiamiamo il numero N più piccolo con questa proprietà un numero prodotto-somma minimo. I numeri prodotto-somma minimi per set di dimensione `k` = 2, 3, 4, 5, e 6 sono come segue.
|
||||
|
||||
<div style='margin-left: 4em;'>
|
||||
<var>k</var>=2: 4 = 2 × 2 = 2 + 2<br>
|
||||
@ -22,27 +22,27 @@ For a given set of size, `k`, we shall call the smallest N with this property a
|
||||
<var>k</var>=6: 12 = 1 × 1 × 1 × 1 × 2 × 6 = 1 + 1 + 1 + 1 + 2 + 6
|
||||
</div><br>
|
||||
|
||||
Hence for 2 ≤ `k` ≤ 6, the sum of all the minimal product-sum numbers is 4 + 6 + 8 + 12 = 30; note that `8` is only counted once in the sum.
|
||||
Quindi per 2 ≤ `k` ≤ 6, la somma di tutti i numeri prodotto-somma minimi è 4 + 6 + 8 + 12 = 30; nota che `8` è contato una volta sola nella somma.
|
||||
|
||||
In fact, as the complete set of minimal product-sum numbers for 2 ≤ `k` ≤ 12 is $\\{4, 6, 8, 12, 15, 16\\}$, the sum is `61`.
|
||||
Infatti, vìsto che il set completo di numeri prodotto-somma minimi per 2 ≤ `k` ≤ 12 è $\\{4, 6, 8, 12, 15, 16\\}$. la somma è `61`.
|
||||
|
||||
What is the sum of all the minimal product-sum numbers for 2 ≤ `k` ≤ `limit`?
|
||||
Quale è la somma di tutti i numeri prodotto-somma minimi per 2 ≤ `k` ≤ `limit`?
|
||||
|
||||
# --hints--
|
||||
|
||||
`productSumNumbers(6)` should return a number.
|
||||
`productSumNumbers(6)` dovrebbe restituire un numero.
|
||||
|
||||
```js
|
||||
assert(typeof productSumNumbers(6) === 'number');
|
||||
```
|
||||
|
||||
`productSumNumbers(6)` should return `30`.
|
||||
`productSumNumbers(6)` dovrebbe restituire `30`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(productSumNumbers(6), 30);
|
||||
```
|
||||
|
||||
`productSumNumbers(12)` should return `61`.
|
||||
`productSumNumbers(12)` dovrebbe restituire `61`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(productSumNumbers(12), 61);
|
||||
@ -54,13 +54,13 @@ assert.strictEqual(productSumNumbers(12), 61);
|
||||
assert.strictEqual(productSumNumbers(300), 12686);
|
||||
```
|
||||
|
||||
`productSumNumbers(6000)` should return `2125990`.
|
||||
`productSumNumbers(6000)` dovrebbe restituire `2125990`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(productSumNumbers(6000), 2125990);
|
||||
```
|
||||
|
||||
`productSumNumbers(12000)` should return `7587457`.
|
||||
`productSumNumbers(12000)` dovrebbe restituire `7587457`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(productSumNumbers(12000), 7587457);
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
---
|
||||
id: 5900f3c51000cf542c50fed7
|
||||
title: 'Problem 89: Roman numerals'
|
||||
title: 'Problema 89: numeri romani'
|
||||
challengeType: 5
|
||||
forumTopicId: 302204
|
||||
dashedName: problem-89-roman-numerals
|
||||
@ -8,20 +8,20 @@ dashedName: problem-89-roman-numerals
|
||||
|
||||
# --description--
|
||||
|
||||
For a number written in Roman numerals to be considered valid there are basic rules which must be followed. Even though the rules allow some numbers to be expressed in more than one way there is always a *best* way of writing a particular number.
|
||||
Perché un numero scritto in numeri romani sia considerato valido ci sono delle regole di base che devono essere seguite. Anche se le regole permettono ad alcuni numeri di essere espressi in più di un modo c'è sempre un modo *migliore* per scrivere un certo numero.
|
||||
|
||||
- Numerals must be arranged in descending order of size.
|
||||
- M, C, and X cannot be equaled or exceeded by smaller denominations.
|
||||
- D, L, and V can each only appear once.
|
||||
- I numeri devono essere sistemati in ordine decrescente di dimensione.
|
||||
- M, C e X non possono essere uguagliati o ecceduti da denominazioni più piccole.
|
||||
- D, L e V possono apparire solo una volta.
|
||||
|
||||
In addition to the three rules given above, if subtractive combinations are used then the following four rules must be followed.
|
||||
In aggiunta a queste tre regole date sopra, se combinazioni sottrattive sono usate, allora bisogna seguire le seguenti quattro regole.
|
||||
|
||||
- Only one I, X, and C can be used as the leading numeral in part of a subtractive pair.
|
||||
- I can only be placed before V and X.
|
||||
- X can only be placed before L and C.
|
||||
- C can only be placed before D and M.
|
||||
- Solo un I, X o C può essere usato come numero iniziale in una coppia sottrattiva.
|
||||
- I può essere usato solo prima di V e X.
|
||||
- X può essere usato solo prima di L e C.
|
||||
- C può essere usato solo prima di D e M.
|
||||
|
||||
For example, it would appear that there are at least six ways of writing the number sixteen:
|
||||
Per esempio, sembra che ci sono almeno sei modi per scrivere il numero sedici:
|
||||
|
||||
<div style="margin-left: 4em; font-family: 'courier new', monospace;">
|
||||
IIIIIIIIIIIIIIII<br>
|
||||
@ -32,29 +32,29 @@ For example, it would appear that there are at least six ways of writing the num
|
||||
XVI<br><br>
|
||||
</div>
|
||||
|
||||
However, according to the rules only XIIIIII and XVI are valid, and the last example is considered to be the most efficient, as it uses the least number of numerals.
|
||||
Invece, in accordo alle regole, solo XIIIIII e XVI sono validi, e l'ultimo esempio è considerato il più efficiente, visto che usa il minor numero di simboli.
|
||||
|
||||
The array, `roman`, will contain numbers written with valid, but not necessarily minimal, Roman numerals.
|
||||
L'array, `roman`, conterrà numeri romani scritti in maniera valida ma non necessariamente minimale.
|
||||
|
||||
Find the number of characters saved by writing each of these in their minimal form.
|
||||
Trova il numero di caratteri salvati scrivendo ognuno di questi nella loro forma minimale.
|
||||
|
||||
**Note:** You can assume that all the Roman numerals in the array contain no more than four consecutive identical units.
|
||||
**Nota:** Puoi assumere che tutti i numeri contenuti nell'array non abbiamo più di quattro simboli consecutivi identici.
|
||||
|
||||
# --hints--
|
||||
|
||||
`romanNumerals(testNumerals1)` should return a number.
|
||||
`romanNumerals(testNumerals1)` dovrebbe restituire un numero.
|
||||
|
||||
```js
|
||||
assert(typeof romanNumerals(_testNumerals1) === 'number');
|
||||
```
|
||||
|
||||
`romanNumerals(testNumerals1)` should return `19`.
|
||||
`romanNumerals(testNumerals1)` dovrebbe restituire `19`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(romanNumerals(_testNumerals1), 19);
|
||||
```
|
||||
|
||||
`romanNumerals(testNumerals2)` should return `743`.
|
||||
`romanNumerals(testNumerals2)` dovrebbe restituire `743`.
|
||||
|
||||
```js
|
||||
assert.strictEqual(romanNumerals(_testNumerals2), 743);
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
---
|
||||
id: 5900f3c61000cf542c50fed9
|
||||
title: 'Problem 90: Cube digit pairs'
|
||||
title: 'Problema 90: coppie di cubi con le cifre'
|
||||
challengeType: 5
|
||||
forumTopicId: 302207
|
||||
dashedName: problem-90-cube-digit-pairs
|
||||
@ -8,38 +8,38 @@ dashedName: problem-90-cube-digit-pairs
|
||||
|
||||
# --description--
|
||||
|
||||
Each of the six faces on a cube has a different digit (0 to 9) written on it; the same is done to a second cube. By placing the two cubes side-by-side in different positions we can form a variety of 2-digit numbers.
|
||||
Ognuno delle sei facce di un cubo ha scritta una diversa cifra (da 0 a 9); la stessa cosa è fatta con un diverso cubo. Mettendo i due cubi fianco a fianco in diverse posizioni possiamo formare una varietà di numeri a 2 cifre.
|
||||
|
||||
For example, the square number 64 could be formed:
|
||||
Per esempio, possiamo formare il numero quadrato 64:
|
||||
|
||||
<img class="img-responsive center-block" alt="two cubes, one with the number 6 and the other with number 4" src="https://cdn-media-1.freecodecamp.org/project-euler/cube-digit-pairs.png" style="background-color: white; padding: 10px;" />
|
||||
<img class="img-responsive center-block" alt="due cubi, uno con il numero 6 e uno con il numero 4" src="https://cdn-media-1.freecodecamp.org/project-euler/cube-digit-pairs.png" style="background-color: white; padding: 10px;" />
|
||||
|
||||
In fact, by carefully choosing the digits on both cubes it is possible to display all of the square numbers below one-hundred: 01, 04, 09, 16, 25, 36, 49, 64, and 81.
|
||||
Infatti, scegliendo con attenzione le cifre sui due cubi, possiamo mostrare tutti i numeri quadrati al di sotto di 100: 01, 04, 09, 16, 25, 36, 49, 64, 81.
|
||||
|
||||
For example, one way this can be achieved is by placing {0, 5, 6, 7, 8, 9} on one cube and {1, 2, 3, 4, 8, 9} on the other cube.
|
||||
Per esempio, un modo in cui questo si può ottenere è scrivendo {0, 5, 6, 7, 8, 9} su un cubo e {1, 2, 3, 4, 8, 9} sull'altro cubo.
|
||||
|
||||
However, for this problem we shall allow the 6 or 9 to be turned upside-down so that an arrangement like {0, 5, 6, 7, 8, 9} and {1, 2, 3, 4, 6, 7} allows for all nine square numbers to be displayed; otherwise it would be impossible to obtain 09.
|
||||
Invece, per questo problema è possibile mettere il 6 o il 9 sottosopra così che un arrangiamento come {0, 5, 6, 7, 8, 9} e {1, 2, 3, 4, 6, 7} permette la formazione di tutti e nove i numeri quadrati, altrimenti sarebbe impossibile ottenere 09.
|
||||
|
||||
In determining a distinct arrangement we are interested in the digits on each cube, not the order.
|
||||
Nel determinare un arrangiamento distingo siamo interessati alle cifre su ogni cubo, non al loro ordine.
|
||||
|
||||
<div style="margin-left: 4em;">
|
||||
{1, 2, 3, 4, 5, 6} is equivalent to {3, 6, 4, 1, 2, 5}<br>
|
||||
{1, 2, 3, 4, 5, 6} is distinct from {1, 2, 3, 4, 5, 9}
|
||||
{1, 2, 3, 4, 5, 6} è equivalente a {3, 6, 4, 1, 2, 5}<br>
|
||||
{1, 2, 3, 4, 5, 6} è diverso da {1, 2, 3, 4, 5, 9}
|
||||
</div>
|
||||
|
||||
But because we are allowing 6 and 9 to be reversed, the two distinct sets in the last example both represent the extended set {1, 2, 3, 4, 5, 6, 9} for the purpose of forming 2-digit numbers.
|
||||
Ma visto che permettiamo al 6 e al 9 di essere capovolti, i due set distinti nell'ultimo esempio rappresentano entrambi il set esteso {1, 2, 3, 4, 5, 6, 9} per lo scopo di formare numeri a due cifre.
|
||||
|
||||
How many distinct arrangements of the two cubes allow for all of the square numbers to be displayed?
|
||||
Quanti arrangiamenti diversi dei due cubi permettono di formare tutti i numeri quadrati?
|
||||
|
||||
# --hints--
|
||||
|
||||
`cubeDigitPairs()` should return a number.
|
||||
`cubeDigitPairs()` dovrebbe restituire un numero.
|
||||
|
||||
```js
|
||||
assert(typeof cubeDigitPairs() === 'number');
|
||||
```
|
||||
|
||||
`cubeDigitPairs()` should return 1217.
|
||||
`cubeDigitPairs()` dovrebbe restituire 1217.
|
||||
|
||||
```js
|
||||
assert.strictEqual(cubeDigitPairs(), 1217);
|
||||
|
||||
@ -1,22 +1,22 @@
|
||||
---
|
||||
id: 606243f50267e718b1e755f4
|
||||
title: リレーショナルデータベース認定証
|
||||
title: Relational Database Certification
|
||||
certification: relational-database
|
||||
challengeType: 7
|
||||
isPrivate: true
|
||||
tests:
|
||||
-
|
||||
id: 5f1a4ef5d5d6b5ab580fc6ae
|
||||
title: 天体データベース
|
||||
title: Celestial Bodies Database
|
||||
-
|
||||
id: 5f9771307d4d22b9d2b75a94
|
||||
title: ワールドカップデータベース
|
||||
title: World Cup Database
|
||||
-
|
||||
id: 5f87ac112ae598023a42df1a
|
||||
title: サロン予約スケジューラー
|
||||
title: Salon Appointment Scheduler
|
||||
-
|
||||
id: 602d9ff222201c65d2a019f2
|
||||
title: 周期表データベース
|
||||
title: Periodic Table Database
|
||||
-
|
||||
id: 602da04c22201c65d2a019f4
|
||||
title: 数当てゲーム
|
||||
title: Number Guessing Game
|
||||
|
||||
@ -25,7 +25,7 @@ JavaScript では、`+` 演算子を `String` の値に対して使用する場
|
||||
const ourStr = "I come first. " + "I come second.";
|
||||
```
|
||||
|
||||
文字列 `I come first. ` `I come second.` がコンソールに表示されます。
|
||||
コンソールに、文字列 `I come first. I come second.` が表示されます。
|
||||
# --instructions--
|
||||
|
||||
`+` 演算子を使用して、文字列 `This is the start.` と `This is the end.` から `myStr` を作成してください。 2 つの文字列の間に空白を必ず含めるようにしてください。
|
||||
|
||||
@ -21,21 +21,21 @@ FAV_PET = "Dogs";
|
||||
|
||||
再代入を必要としない変数に名前を付けるときは、常に `const` キーワードを使用してください。 そうすれば、定数でなければならない変数に誤って再代入しようとするのを防ぐのに役立ちます。
|
||||
|
||||
**Note:** It is common for developers to use uppercase variable identifiers for immutable values and lowercase or camelCase for mutable values (objects and arrays). You will learn more about objects, arrays, and immutable and mutable values in later challenges. Also in later challenges, you will see examples of uppercase, lowercase, or camelCase variable identifiers.
|
||||
**注:** 開発者は一般に、イミュータブル (変更不可) の値には大文字の変数識別子を使用し、ミュータブル (変更可能) の値 (オブジェクトや配列) には小文字またはキャメルケースを使用します。 オブジェクトや配列、ミュータブルの値とイミュータブルの値については、このあとのチャレンジで詳しく説明します。 また以降のチャレンジでは、大文字、小文字、またはキャメルケースのさまざまな変数識別子を使用します。
|
||||
|
||||
# --instructions--
|
||||
|
||||
Change the code so that all variables are declared using `let` or `const`. Use `let` when you want the variable to change, and `const` when you want the variable to remain constant. Also, rename variables declared with `const` to conform to common practices.
|
||||
コードを変更して、すべての変数を `let` または `const` を使用して宣言してください。 変更を必要とする変数には `let` を使用し、定数にする必要がある変数には `const` を使用してください。 また、`const` で宣言した変数の名前について、一般的な慣習に従うように変更してください。
|
||||
|
||||
# --hints--
|
||||
|
||||
`var` should not exist in your code.
|
||||
`var` がコード内に存在しないようにしてください。
|
||||
|
||||
```js
|
||||
(getUserInput) => assert(!getUserInput('index').match(/var/g));
|
||||
```
|
||||
|
||||
You should change `fCC` to all uppercase.
|
||||
`fCC` をすべて大文字に変更する必要があります。
|
||||
|
||||
```js
|
||||
(getUserInput) => {
|
||||
@ -44,20 +44,20 @@ You should change `fCC` to all uppercase.
|
||||
}
|
||||
```
|
||||
|
||||
`FCC` should be a constant variable declared with `const`.
|
||||
`FCC` は `const` で宣言された定数変数である必要があります。
|
||||
|
||||
```js
|
||||
assert.equal(FCC, 'freeCodeCamp');
|
||||
assert.match(code, /const\s+FCC/);
|
||||
```
|
||||
|
||||
`fact` should be declared with `let`.
|
||||
`fact` は `let` を使用して宣言する必要があります。
|
||||
|
||||
```js
|
||||
(getUserInput) => assert(getUserInput('index').match(/(let fact)/g));
|
||||
```
|
||||
|
||||
`console.log` should be changed to print the `FCC` and `fact` variables.
|
||||
`console.log` を、`FCC` と `fact` 変数が出力されるように変更する必要があります。
|
||||
|
||||
```js
|
||||
(getUserInput) =>
|
||||
|
||||
@ -186,6 +186,12 @@ assert(telephoneCheck('(555)5(55?)-5555') === false);
|
||||
assert(telephoneCheck('55 55-55-555-5') === false);
|
||||
```
|
||||
|
||||
`telephoneCheck("11 555-555-5555")` should return `false`.
|
||||
|
||||
```js
|
||||
assert(telephoneCheck('11 555-555-5555') === false);
|
||||
```
|
||||
|
||||
# --seed--
|
||||
|
||||
## --seed-contents--
|
||||
|
||||
@ -8,7 +8,7 @@ dashedName: state-name-puzzle
|
||||
|
||||
# --description--
|
||||
|
||||
このタスクは、Mark Nelson 氏 の DDJ コラム「Wordplay (言葉遊び)」と、NPR 週末版の Will Shortz 氏の週ごとのパズルチャレンジの 1 つ[\[1\]](https://www.npr.org/templates/story/story.php?storyId=9264290) にインスパイアされたもので、もとは David Edelheit 氏の発案によるものです。 The challenge was to take the names of two U.S. States, mix them all together, then rearrange the letters to form the names of two *different* U.S. States (so that all four state names differ from one another). What states are these? The problem was reissued on [the Unicon Discussion Web](https://tapestry.tucson.az.us/twiki/bin/view/Main/StateNamesPuzzle) which includes several solutions with analysis. Several techniques may be helpful and you may wish to refer to [Gödel numbering](https://en.wikipedia.org/wiki/Goedel_numbering), [equivalence relations](https://en.wikipedia.org/wiki/Equivalence_relation), and [equivalence classes](https://en.wikipedia.org/wiki/Equivalence_classes). The basic merits of these were discussed in the Unicon Discussion Web. A second challenge in the form of a set of fictitious new states was also presented.
|
||||
このタスクは、Mark Nelson 氏 の DDJ コラム「Wordplay (言葉遊び)」と、NPR 週末版の Will Shortz 氏の週ごとのパズルチャレンジの 1 つ[\[1\]](https://www.npr.org/templates/story/story.php?storyId=9264290) にインスパイアされたもので、もとは David Edelheit 氏の発案によるものです。 チャレンジの内容は、アメリカの州の名前を 2 つ選び、すべての文字を混ぜて並べ替え、 *別の* 2 つの州の名前を作成するというものでした。(つまり、4 つの州の名前がすべて異なるようにします。) これらの州名は何でしょうか? この問題は [Unicon Discussion Web](https://tapestry.tucson.az.us/twiki/bin/view/Main/StateNamesPuzzle) で再び出題され、幾つかの解答が解説付きで紹介されています。 いくつかの役立つと思われるテクニックがあります。[Gödel numbering](https://en.wikipedia.org/wiki/Goedel_numbering)、[equivalence relations](https://en.wikipedia.org/wiki/Equivalence_relation)、[equivalence classes](https://en.wikipedia.org/wiki/Equivalence_classes) などを参考にすると良いでしょう。 これらの基本的なメリットは、Unicon Discussion Web で説明されています。 架空の新しい州のセットを使用する形式で、第 2 のチャレンジも出題されています。
|
||||
|
||||
# --instructions--
|
||||
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
---
|
||||
id: 5f1a4ef5d5d6b5ab580fc6ae
|
||||
title: Build a Celestial Bodies Database
|
||||
title: 天体データベースを構築する
|
||||
challengeType: 13
|
||||
helpCategory: Backend Development
|
||||
url: https://github.com/freeCodeCamp/learn-celestial-bodies-database
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
---
|
||||
id: 5ea8adfab628f68d805bfc5e
|
||||
title: Build a Boilerplate
|
||||
title: ボイラープレートを構築する
|
||||
challengeType: 12
|
||||
helpCategory: Backend Development
|
||||
url: https://github.com/freeCodeCamp/learn-bash-by-building-a-boilerplate
|
||||
@ -9,7 +9,7 @@ dashedName: build-a-boilerplate
|
||||
|
||||
# --description--
|
||||
|
||||
In this 170 lesson course, you will learn basic commands by creating a website boilerplate using only the command line.
|
||||
この 170 のレッスンコースでは、コマンドラインのみを使用してウェブサイトのボイラープレートを作成することで、基本のコマンドについて学習します。
|
||||
|
||||
# --instructions--
|
||||
|
||||
|
||||
@ -9,7 +9,7 @@ dashedName: build-a-mario-database
|
||||
|
||||
# --description--
|
||||
|
||||
In this 165 lesson course, you will learn the basics of relational databases by creating a PostgreSQL database filled with video game characters.
|
||||
In this 165 lesson course, you will learn the basics of a relational database by creating a PostgreSQL database filled with video game characters.
|
||||
|
||||
# --instructions--
|
||||
|
||||
|
||||
@ -21,17 +21,15 @@ O console vai exibir um erro devido à reatribuição do valor de `FAV_PET`.
|
||||
|
||||
Você sempre deve nomear variáveis que você não quer reatribuir, usando a palavra-chave `const`. Isso ajuda quando você acidentalmente tenta reatribuir uma variável que deveria ser constante.
|
||||
|
||||
Uma prática comum ao nomear constantes é colocar todas as letras em maiúsculas, com palavras separadas por sublinhado (underscore).
|
||||
|
||||
**Observação:** é comum que os desenvolvedores usem nomes de variáveis maiúsculas para valores imutáveis e minúsculas ou camelCase para valores mutáveis (objetos e arrays). Você aprenderá mais sobre objetos, arrays e valores imutáveis e mutáveis em desafios futuros. Em desafios posteriores, você também verá exemplos de identificadores de variáveis maiúsculas, minúsculas ou em camelCase.
|
||||
|
||||
# --instructions--
|
||||
|
||||
Altere o código para que todas as variáveis sejam declaradas usando `let` ou `const`. Use `let` quando você quiser que a variável mude e `const` quando você quiser que a variável permaneça constante. Além disso, renomeie as variáveis declaradas com `const` para estar em conformidade com as práticas comuns, o que significa que constantes devem ter todas as letras em maiúsculo.
|
||||
Altere o código para que todas as variáveis sejam declaradas usando `let` ou `const`. Use `let` quando você quiser que a variável mude e `const` quando você quiser que a variável permaneça constante. Além disso, renomeie as variáveis declaradas com `const` para que estejam de acordo com as práticas comuns.
|
||||
|
||||
# --hints--
|
||||
|
||||
`var` não deve existir no seu código.
|
||||
`var` não deve existir no código.
|
||||
|
||||
```js
|
||||
(getUserInput) => assert(!getUserInput('index').match(/var/g));
|
||||
|
||||
@ -21,7 +21,7 @@ console.log(typeof {});
|
||||
|
||||
Em ordem, o console exibirá as strings `string`, `number`, `object` e `object`.
|
||||
|
||||
JavaScript reconhece seis tipos de dados primitivos (imutável): `Boolean`, `Null`, `Undefined`, `Number`, `String` e `Symbol` (novo em ES6) e um tipo para itens mutáveis: `Object`. Note que em JavaScript, arrays são tecnicamente um tipo de objeto.
|
||||
JavaScript reconhece sete tipos de dados primitivos (imutáveis): `Boolean`, `Null`, `Undefined`, `Number`, `String`, `Symbol` (novo na ES6) e `BigInt` (novo na ES2020), além de um tipo para itens mutáveis: `Object`. Note que em JavaScript, arrays são tecnicamente um tipo de objeto.
|
||||
|
||||
# --instructions--
|
||||
|
||||
|
||||
@ -8,7 +8,7 @@ dashedName: state-name-puzzle
|
||||
|
||||
# --description--
|
||||
|
||||
Esta tarefa é inspirada na coluna "Wordplay", de Mark Nelson no DDJ e um dos desafios semanais de Will Shortz na edição de fim de semana da NPR [\[1\]](https://www.npr.org/templates/story/story.php?storyId=9264290), sendo originalmente atribuída a David Edelheit. O desafio era pegar os nomes de dois estados dos Estados Unidos misturá-los, e, então, reorganizar as letras para formar os nomes de dois estados *diferentes* (para que os quatro nomes de estados sejam diferentes um do outro). Que estados são esses? O problema foi publicado novamente na [Unicon Discussion Web](https://tapestry.tucson.az.us/twiki/bin/view/Main/StateNamesPuzzle), que inclui diversas soluções com a análise. Várias técnicas podem ser úteis caso você queira consultar, como: [a numeração de Gödel](https://en.wikipedia.org/wiki/Goedel_numbering), [as relações de equivalência](https://en.wikipedia.org/wiki/Equivalence_relation) e [as classes de equivalência](https://en.wikipedia.org/wiki/Equivalence_classes). Os méritos básicos destas técnicas foram discutidos na Unicon Discussion Web. Foi também apresentado um segundo desafio, sob a forma de um conjunto de novos estados fictícios.
|
||||
Esta tarefa é inspirada na coluna "Wordplay", de Mark Nelson no DDJ e um dos desafios semanais de Will Shortz na edição de fim de semana da NPR [\[1\]](https://www.npr.org/templates/story/story.php?storyId=9264290), sendo originalmente atribuída a David Edelheit. O desafio era pegar os nomes de dois estados dos Estados Unidos, misturá-los e, então, reorganizar as letras para formar os nomes de dois estados *diferentes* (de modo que os quatro nomes de estados sejam diferentes entre eles). Que estados são esses? O problema foi publicado novamente na [Unicon Discussion Web](https://tapestry.tucson.az.us/twiki/bin/view/Main/StateNamesPuzzle), que inclui diversas soluções com a análise. Várias técnicas podem ser úteis caso você queira consultar, como: [a numeração de Gödel](https://en.wikipedia.org/wiki/Goedel_numbering), [as relações de equivalência](https://en.wikipedia.org/wiki/Equivalence_relation) e [as classes de equivalência](https://en.wikipedia.org/wiki/Equivalence_classes). Os méritos básicos destas técnicas foram discutidos na Unicon Discussion Web. Foi também apresentado um segundo desafio, sob a forma de um conjunto de novos estados fictícios.
|
||||
|
||||
# --instructions--
|
||||
|
||||
|
||||
Reference in New Issue
Block a user