@@ -115,19 +115,19 @@ Work out the first ten digits of the sum of the following one-hundred 50-digit n # --hints-- -`largeSum(testNums)` should return a number. +`largeSum(testNums)` dovrebbe restituire un numero. ```js assert(typeof largeSum(testNums) === 'number'); ``` -`largeSum(testNums)` should return 8348422521. +`largeSum(testNums)` dovrebbe restituire 8348422521. ```js assert.strictEqual(largeSum(testNums), 8348422521); ``` -`largeSum(fiftyDigitNums)` should return 5537376230. +`largeSum(fiftyDigitNums)` dovrebbe restituire 5537376230. ```js assert.strictEqual(largeSum(fiftyDigitNums), 5537376230); diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-14-longest-collatz-sequence.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-14-longest-collatz-sequence.md index 807f362857..604010c0df 100644 --- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-14-longest-collatz-sequence.md +++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-14-longest-collatz-sequence.md @@ -1,6 +1,6 @@ --- id: 5900f37a1000cf542c50fe8d -title: 'Problem 14: Longest Collatz sequence' +title: 'Problema 14: la sequenza di Collatz più lunga' challengeType: 5 forumTopicId: 301768 dashedName: problem-14-longest-collatz-sequence @@ -8,61 +8,61 @@ dashedName: problem-14-longest-collatz-sequence # --description-- -The following iterative sequence is defined for the set of positive integers: +La seguente sequenza iterativa è definita per il set degli interi positivi: -
n → n/2 (n is even)
+n → n/2 (n è pari)
-n → 3n + 1 (n is odd)
+n → 3n + 1 (n è dispari)
-Using the rule above and starting with 13, we generate the following sequence:
+Usando le regole qua sopra e iniziando con 13, generiamo la seguente sequenza:
13 → 40 → 20 → 10 → 5 → 16 → 8 → 4 → 2 → 1
-It can be seen that this sequence (starting at 13 and finishing at 1) contains 10 terms. Although it has not been proved yet (Collatz Problem), it is thought that all starting numbers finish at 1.
+Puoi vedere che questa sequenza (iniziando con 13 e finedno con 1) contiene 10 termini. Anche se non è ancora stato provato (Problema di Collatz), si pensa che con qualsiasi numeri si parta, si finisce a 1.
-Which starting number, under the given `limit`, produces the longest chain?
+Quale numero iniziale, sotto il dato limite `limit`, produce la catena più lunga?
-**Note:** Once the chain starts the terms are allowed to go above one million.
+**Nota:** Una volta che la catena inizia i termini possono superare `limit`.
# --hints--
-`longestCollatzSequence(14)` should return a number.
+`longestCollatzSequence(14)` dovrebbe restituire un numero.
```js
assert(typeof longestCollatzSequence(14) === 'number');
```
-`longestCollatzSequence(14)` should return 9.
+`longestCollatzSequence(14)` dovrebbe restituire 9.
```js
assert.strictEqual(longestCollatzSequence(14), 9);
```
-`longestCollatzSequence(5847)` should return 3711.
+`longestCollatzSequence(5847)` dovrebbe restituire 3711.
```js
assert.strictEqual(longestCollatzSequence(5847), 3711);
```
-`longestCollatzSequence(46500)` should return 35655.
+`longestCollatzSequence(46500)` dovrebbe restituire 35655.
```js
assert.strictEqual(longestCollatzSequence(46500), 35655);
```
-`longestCollatzSequence(54512)` should return 52527.
+`longestCollatzSequence(54512)` dovrebbe restituire 52527.
```js
assert.strictEqual(longestCollatzSequence(54512), 52527);
```
-`longestCollatzSequence(100000)` should return 77031.
+`longestCollatzSequence(100000)` dovrebbe restituire 77031.
```js
assert.strictEqual(longestCollatzSequence(100000), 77031);
```
-`longestCollatzSequence(1000000)` should return 837799.
+`longestCollatzSequence(1000000)` dovrebbe restituire 837799.
```js
assert.strictEqual(longestCollatzSequence(1000000), 837799);
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-15-lattice-paths.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-15-lattice-paths.md
index 225a31ee93..d4c758d97a 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-15-lattice-paths.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-15-lattice-paths.md
@@ -1,6 +1,6 @@
---
id: 5900f37b1000cf542c50fe8e
-title: 'Problem 15: Lattice paths'
+title: 'Problema 15: Percorsi nel reticolo'
challengeType: 5
forumTopicId: 301780
dashedName: problem-15-lattice-paths
@@ -8,33 +8,33 @@ dashedName: problem-15-lattice-paths
# --description--
-Starting in the top left corner of a 2×2 grid, and only being able to move to the right and down, there are exactly 6 routes to the bottom right corner.
+Iniziando nell'angolo in alto a sinistra di una griglia 2x2, e avendo l'abilità di muoversi solo verso destra e verso il basso, ci sono esattamente 6 strade verso l'angolo in basso a sinistra.
-
+
-How many such routes are there through a given `gridSize`?
+Quante strade di questo tipo ci sono data la dimensione della griglia `gridSize`?
# --hints--
-`latticePaths(4)` should return a number.
+`latticePaths(4)` dovrebbe restituire un numero.
```js
assert(typeof latticePaths(4) === 'number');
```
-`latticePaths(4)` should return 70.
+`latticePaths(4)` dovrebbe restituire 70.
```js
assert.strictEqual(latticePaths(4), 70);
```
-`latticePaths(9)` should return 48620.
+`latticePaths(9)` dovrebbe restituire 48620.
```js
assert.strictEqual(latticePaths(9), 48620);
```
-`latticePaths(20)` should return 137846528820.
+`latticePaths(20)` dovrebbe restituire 137846528820.
```js
assert.strictEqual(latticePaths(20), 137846528820);
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-16-power-digit-sum.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-16-power-digit-sum.md
index b71b480082..3a6f5aa8de 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-16-power-digit-sum.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-16-power-digit-sum.md
@@ -1,6 +1,6 @@
---
id: 5900f37d1000cf542c50fe8f
-title: 'Problem 16: Power digit sum'
+title: 'Problema 16: Somma delle cifre della potenza'
challengeType: 5
forumTopicId: 301791
dashedName: problem-16-power-digit-sum
@@ -8,31 +8,31 @@ dashedName: problem-16-power-digit-sum
# --description--
-215 = 32768 and the sum of its digits is 3 + 2 + 7 + 6 + 8 = 26.
+215 = 32768 e la somma delle sue cifre è 3 + 2 + 7 + 6 + 8 = 26.
-What is the sum of the digits of the number 2exponent?
+Qual'è la somma delle cifre del numero 2exponent?
# --hints--
-`powerDigitSum(15)` should return a number.
+`powerDigitSum(15)` dovrebbe restituire un numero.
```js
assert(typeof powerDigitSum(15) === 'number');
```
-`powerDigitSum(15)` should return 26.
+`powerDigitSum(15)` dovrebbe restituire 26.
```js
assert.strictEqual(powerDigitSum(15), 26);
```
-`powerDigitSum(128)` should return 166.
+`powerDigitSum(128)` dovrebbe restituire 166.
```js
assert.strictEqual(powerDigitSum(128), 166);
```
-`powerDigitSum(1000)` should return 1366.
+`powerDigitSum(1000)` dovrebbe restituire 1366.
```js
assert.strictEqual(powerDigitSum(1000), 1366);
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-17-number-letter-counts.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-17-number-letter-counts.md
index 2b096d1d78..8098ef67e7 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-17-number-letter-counts.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-17-number-letter-counts.md
@@ -1,6 +1,6 @@
---
id: 5900f37d1000cf542c50fe90
-title: 'Problem 17: Number letter counts'
+title: 'Problema 17: conteggio delle lettere dei numeri'
challengeType: 5
forumTopicId: 301804
dashedName: problem-17-number-letter-counts
@@ -8,33 +8,33 @@ dashedName: problem-17-number-letter-counts
# --description--
-If the numbers 1 to 5 are written out in words: one, two, three, four, five, then there are 3 + 3 + 5 + 4 + 4 = 19 letters used in total.
+Se i numeri da 1 a 5 fossero scritti in parole in inglese: one, two, three, four, five, allora ci sono 3 + 3 + 5 + 4 + 4 = 19 lettere usate in totale.
-If all the numbers from 1 to given `limit` inclusive were written out in words, how many letters would be used?
+Se tutti i numeri da 1 al dato limite inclusivo `limit` fossero scritti in parole in inglese, quante lettere sarebbero usate?
-**Note:** Do not count spaces or hyphens. For example, 342 (three hundred and forty-two) contains 23 letters and 115 (one hundred and fifteen) contains 20 letters. The use of "and" when writing out numbers is in compliance with British usage.
+**Nota:** Non contare gli spazi o i trattini. Per esempio, 342 (three hundred and forty-two) contiene 23 lettere e 115 (one hundred and fifteen) contiene 20 lettere. L'uso di "and" scrivendo i numeri segue l'uso britannico.
# --hints--
-`numberLetterCounts(5)` should return a number.
+`numberLetterCounts(5)` dovrebbe restituire un numero.
```js
assert(typeof numberLetterCounts(5) === 'number');
```
-`numberLetterCounts(5)` should return 19.
+`numberLetterCounts(5)` dovrebbe restituire 19.
```js
assert.strictEqual(numberLetterCounts(5), 19);
```
-`numberLetterCounts(150)` should return 1903.
+`numberLetterCounts(150)` dovrebbe restituire 1903.
```js
assert.strictEqual(numberLetterCounts(150), 1903);
```
-`numberLetterCounts(1000)` should return 21124.
+`numberLetterCounts(1000)` dovrebbe restituire 21124.
```js
assert.strictEqual(numberLetterCounts(1000), 21124);
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-18-maximum-path-sum-i.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-18-maximum-path-sum-i.md
index 2ad9a7a7a6..e81d7a383c 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-18-maximum-path-sum-i.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-18-maximum-path-sum-i.md
@@ -1,6 +1,6 @@
---
id: 5900f37e1000cf542c50fe91
-title: 'Problem 18: Maximum path sum I'
+title: 'Problema 18: Somma massima del percorso I'
challengeType: 5
forumTopicId: 301815
dashedName: problem-18-maximum-path-sum-i
@@ -8,7 +8,7 @@ dashedName: problem-18-maximum-path-sum-i
# --description--
-By starting at the top of the triangle below and moving to adjacent numbers on the row below, the maximum total from top to bottom is 23.
+Cominciando dalla parte superiore del triangolo sottostante e spostandosi verso i numeri adiacenti sulla riga sottostante, il totale massimo dall'alto al basso è 23.
3@@ -17,9 +17,9 @@ By starting at the top of the triangle below and moving to adjacent numbers on t 8 5 9 3 -That is, 3 + 7 + 4 + 9 = 23. +Cioè, 3 + 7 + 4 + 9 = 23. -Find the maximum total from top to bottom of the triangle below: +Trova il totale massimo dall'alto al basso del triangolo qui sotto: 75 95 64 @@ -37,23 +37,23 @@ Find the maximum total from top to bottom of the triangle below: 63 66 04 68 89 53 67 30 73 16 69 87 40 31 04 62 98 27 23 09 70 98 73 93 38 53 60 04 23 -**NOTE:** As there are only 16384 routes, it is possible to solve this problem by trying every route. However, Problem 67, is the same challenge with a triangle containing one-hundred rows; it cannot be solved by brute force, and requires a clever method! ;o) +**NOTA:** Poiché ci sono solo 16384 percorsi, è possibile risolvere questo problema provando ogni percorso. Tuttavia, Problema 67, è la stessa sfida con un triangolo contenente cento righe; non può essere risolto a forza bruta, e richiede un metodo intelligente! ;o) # --hints-- -`maximumPathSumI(testTriangle)` should return a number. +`maximumPathSumI(testTriangle)` dovrebbe restituire un numero. ```js assert(typeof maximumPathSumI(testTriangle) === 'number'); ``` -`maximumPathSumI(testTriangle)` should return 23. +`maximumPathSumI(testTriangle)` dovrebbe restituire 23. ```js assert.strictEqual(maximumPathSumI(testTriangle), 23); ``` -`maximumPathSumI(numTriangle)` should return 1074. +`maximumPathSumI(numTriangle)` dovrebbe restituire 1074. ```js assert.strictEqual(maximumPathSumI(numTriangle), 1074); diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-19-counting-sundays.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-19-counting-sundays.md index c12d6d1c6b..45ba307402 100644 --- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-19-counting-sundays.md +++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-19-counting-sundays.md @@ -1,6 +1,6 @@ --- id: 5900f37f1000cf542c50fe92 -title: 'Problem 19: Counting Sundays' +title: 'Problema 19: Contando le domeniche' challengeType: 5 forumTopicId: 301827 dashedName: problem-19-counting-sundays @@ -8,37 +8,37 @@ dashedName: problem-19-counting-sundays # --description-- -You are given the following information, but you may prefer to do some research for yourself. +Ti sono fornite le seguenti informazioni, ma potresti voler fare un po' di ricerca per conto tuo.
-
-
- 1 Jan 1900 was a Monday. -
- Thirty days has September,
April, June and November.
All the rest have thirty-one,
Saving February alone,
Which has twenty-eight, rain or shine.
And on leap years, twenty-nine.
- - A leap year occurs on any year evenly divisible by 4, but not on a century unless it is divisible by 400. +
- Il 1 Gennaio 1900 era un lunedì. +
- Trenta giorni a novembre,
con april, giugno e settembre,
di ventotto ce n'è uno,
tutti gli altri ne han trentuno.
+ - Un anno bisestile si verifica su qualsiasi anno divisibile per 4, ma non in un anno divisibile per 100 a meno che non sia divisibile per 400.
012 021 102 120 201 210
-What is the `n`th lexicographic permutation of the digits 0, 1, 2, 3, 4, 5, 6, 7, 8 and 9?
+Qual è l'`n`-sima permutazione lessicografica delle cifre 0, 1, 2, 3, 4, 5, 6, 7, 8 e 9?
# --hints--
-`lexicographicPermutations(699999)` should return a number.
+`lexicographicPermutations(699999)` dovrebbe restituire un numero.
```js
assert(typeof lexicographicPermutations(699999) === 'number');
```
-`lexicographicPermutations(699999)` should return 1938246570.
+`lexicographicPermutations(699999)` dovrebbe restituire 1938246570.
```js
assert(lexicographicPermutations(699999) == 1938246570);
```
-`lexicographicPermutations(899999)` should return 2536987410.
+`lexicographicPermutations(899999)` dovrebbe restituire 2536987410.
```js
assert(lexicographicPermutations(899999) == 2536987410);
```
-`lexicographicPermutations(900000)` should return 2537014689.
+`lexicographicPermutations(900000)` dovrebbe restituire 2537014689.
```js
assert(lexicographicPermutations(900000) == 2537014689);
```
-`lexicographicPermutations(999999)` should return 2783915460.
+`lexicographicPermutations(999999)` dovrebbe restituire 2783915460.
```js
assert(lexicographicPermutations(999999) == 2783915460);
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-25-1000-digit-fibonacci-number.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-25-1000-digit-fibonacci-number.md
index ca7d277f44..c25bacf224 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-25-1000-digit-fibonacci-number.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-25-1000-digit-fibonacci-number.md
@@ -1,6 +1,6 @@
---
id: 5900f3851000cf542c50fe98
-title: 'Problem 25: 1000-digit Fibonacci number'
+title: 'Problema 25: numero di Fibonacci a 1000 cifre'
challengeType: 5
forumTopicId: 301897
dashedName: problem-25-1000-digit-fibonacci-number
@@ -8,45 +8,45 @@ dashedName: problem-25-1000-digit-fibonacci-number
# --description--
-The Fibonacci sequence is defined by the recurrence relation:
+La sequenza di Fibonacci è definita dalla relazione ricorsiva:
-Fn = Fn−1 + Fn−2, where F1 = 1 and F2 = 1.
+Fn = Fn−1 + Fn−2, dove F1 = 1 e F2 = 1.
-Hence the first 12 terms will be:
+Quindi i primi 12 termini saranno:
F1 = 1
F2 = 1
F3 = 2
F4 = 3
F5 = 5
F6 = 8
F7 = 13
F8 = 21
F9 = 34
F10 = 55
F11 = 89
F12 = 144
1/2 = 0.5
1/3 = 0.(3)
1/4 = 0.25
1/5 = 0.2
1/6 = 0.1(6)
1/7 = 0.(142857)
1/8 = 0.125
1/9 = 0.(1)
1/10 = 0.1
1/2 = 0.5
1/3 = 0.(3)
1/4 = 0.25
1/5 = 0.2
1/6 = 0.1(6)
1/7 = 0.(142857)
1/8 = 0.125
1/9 = 0.(1)
1/10 = 0.1
$n^2 + n + 41$
-It turns out that the formula will produce 40 primes for the consecutive integer values $0 \\le n \\le 39$. However, when $n = 40, 40^2 + 40 + 41 = 40(40 + 1) + 41$ is divisible by 41, and certainly when $n = 41, 41^2 + 41 + 41$ is clearly divisible by 41.
+Si scopre che la formula produrrà 40 primi per i valori interi consecutivi $0 \\le n \\le 39$. Tuttavia, quando $n = 40, 40^2 + 40 + 41 = 40(40 + 1) + 41$ è divisibile per 41, e quando $n = 41, 41^2 + 41 + 41 $ è chiaramente divisibile per 41.
-The incredible formula $n^2 - 79n + 1601$ was discovered, which produces 80 primes for the consecutive values $0 \\le n \\le 79$. The product of the coefficients, −79 and 1601, is −126479.
+Si è scoperta l'incredibile formula $n^2 - 79n + 1601$ che produce 80 primi per i valori consecutivi $0 \\le n \\le 79$. Il prodotto dei coefficienti, −79 e 1601, è −126479.
-Considering quadratics of the form:
+Considerando le quadratiche della forma:
- $n^2 + an + b$, where $|a| < range$ and $|b| \le range$
- where $|n|$ is the modulus/absolute value of $n$
- e.g. $|11| = 11$ and $|-4| = 4$
+ $n^2 + an + b$, dove $|a| < range$ e $|b| \le range$
+ dove $|n|$ è il valore assoluto di $n$
+ ad esempio $|11| = 11$ e $|-4| = 4$
-Find the product of the coefficients, $a$ and $b$, for the quadratic expression that produces the maximum number of primes for consecutive values of $n$, starting with $n = 0$.
+Trova il prodotto dei coefficienti, $a$ e $b$ per l'espressione quadratica che produce il numero massimo di primi per valori consecutivi di $n$, a partire da $n = 0$.
# --hints--
-`quadraticPrimes(200)` should return a number.
+`quadraticPrimes(200)` dovrebbe restituire un numero.
```js
assert(typeof quadraticPrimes(200) === 'number');
```
-`quadraticPrimes(200)` should return -4925.
+`quadraticPrimes(200)` dovrebbe restituire -4925.
```js
assert(quadraticPrimes(200) == -4925);
```
-`quadraticPrimes(500)` should return -18901.
+`quadraticPrimes(500)` dovrebbe restituire -18901.
```js
assert(quadraticPrimes(500) == -18901);
```
-`quadraticPrimes(800)` should return -43835.
+`quadraticPrimes(800)` dovrebbe restituire -43835.
```js
assert(quadraticPrimes(800) == -43835);
```
-`quadraticPrimes(1000)` should return -59231.
+`quadraticPrimes(1000)` dovrebbe restituire -59231.
```js
assert(quadraticPrimes(1000) == -59231);
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-28-number-spiral-diagonals.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-28-number-spiral-diagonals.md
index a476199d1d..031945119e 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-28-number-spiral-diagonals.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-28-number-spiral-diagonals.md
@@ -1,6 +1,6 @@
---
id: 5900f3881000cf542c50fe9b
-title: 'Problem 28: Number spiral diagonals'
+title: 'Problema 28: le diagonali della spirale di numeri'
challengeType: 5
forumTopicId: 301930
dashedName: problem-28-number-spiral-diagonals
@@ -8,7 +8,7 @@ dashedName: problem-28-number-spiral-diagonals
# --description--
-Starting with the number 1 and moving to the right in a clockwise direction a 5 by 5 spiral is formed as follows:
+Iniziando con il numero 1 e muovendo a destra in direzione oraria una spirale 5 per 5 è formata come segue:
- where $|n|$ is the modulus/absolute value of $n$
- e.g. $|11| = 11$ and $|-4| = 4$
+ $n^2 + an + b$, dove $|a| < range$ e $|b| \le range$
+ dove $|n|$ è il valore assoluto di $n$
+ ad esempio $|11| = 11$ e $|-4| = 4$
21
22 23 24 25
@@ -18,37 +18,37 @@ Starting with the number 1 and moving to the right in a clockwise direction a 5
17
16 15 14 13
22=4, 23=8, 24=16, 25=32
@@ -17,41 +17,41 @@ Consider all integer combinations of ab for 2 ≤ a ≤ 5 and 2 ≤ b ≤ 5: 52=25, 53=125, 54=625, 55=3125
-If they are then placed in numerical order, with any repeats removed, we get the following sequence of 15 distinct terms:
+Se sono successivamente posizionati in ordine numerico, con eventuali ripetizioni rimosse, otteniamo la seguente sequenza di 15 termini distinti:
@@ -17,41 +17,41 @@ Consider all integer combinations of ab for 2 ≤ a ≤ 5 and 2 ≤ b ≤ 5: 52=25, 53=125, 54=625, 55=3125
4, 8, 9, 16, 25, 27, 32, 64, 81, 125, 243, 256, 625, 1024, 3125
-How many distinct terms are in the sequence generated by `ab` for 2 ≤ `a` ≤ `n` and 2 ≤ `b` ≤ `n`?
+Quanti termini distinti ci sono nella sequenza generata da $a^b$ per 2 ≤ `a` ≤ `n` e 2 ≤ `b` ≤ `n`?
# --hints--
-`distinctPowers(15)` should return a number.
+`distinctPowers(15)` dovrebbe restituire un numero.
```js
assert(typeof distinctPowers(15) === 'number');
```
-`distinctPowers(15)` should return 177.
+`distinctPowers(15)` dovrebbe restituire 177.
```js
assert.strictEqual(distinctPowers(15), 177);
```
-`distinctPowers(20)` should return 324.
+`distinctPowers(20)` dovrebbe restituire 324.
```js
assert.strictEqual(distinctPowers(20), 324);
```
-`distinctPowers(25)` should return 519.
+`distinctPowers(25)` dovrebbe restituire 519.
```js
assert.strictEqual(distinctPowers(25), 519);
```
-`distinctPowers(30)` should return 755.
+`distinctPowers(30)` dovrebbe restituire 755.
```js
assert.strictEqual(distinctPowers(30), 755);
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-30-digit-n-powers.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-30-digit-n-powers.md
index 1eb7fd409b..bc65aa8611 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-30-digit-n-powers.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-30-digit-n-powers.md
@@ -1,6 +1,6 @@
---
id: 5900f38a1000cf542c50fe9d
-title: 'Problem 30: Digit n powers'
+title: 'Problema 30: Potenze delle cifre'
challengeType: 5
forumTopicId: 301953
dashedName: problem-30-digit-n-powers
@@ -8,7 +8,7 @@ dashedName: problem-30-digit-n-powers
# --description--
-Surprisingly there are only three numbers that can be written as the sum of fourth powers of their digits:
+Sorprendentemente ci sono solo tre numeri che possono essere scritti come la somma delle quarte potenze delle loro cifre:
1634 = 14 + 64 + 34 + 44
@@ -16,39 +16,39 @@ Surprisingly there are only three numbers that can be written as the sum of four 9474 = 94 + 44 + 74 + 44
-As 1 = 14 is not a sum it is not included.
+Dato che 1 = 14 non è una somma, esso non è incluso.
-The sum of these numbers is 1634 + 8208 + 9474 = 19316.
+La somma di questi numeri è 1634 + 8208 + 9474 = 19316.
-Find the sum of all the numbers that can be written as the sum of `n` powers of their digits.
+Trova la somma di tutti i numeri che possono essere scritti come la somma di `n` potenze delle loro cifre.
# --hints--
-`digitnPowers(2)` should return a number.
+`digitnPowers(2)` dovrebbe restituire un numero.
```js
assert(typeof digitnPowers(2) === 'number');
```
-`digitnPowers(2)` should return 0.
+`digitnPowers(2)` dovrebbe restituire 0.
```js
assert(digitnPowers(2) == 0);
```
-`digitnPowers(3)` should return 1301.
+`digitnPowers(3)` dovrebbe restituire 1301.
```js
assert(digitnPowers(3) == 1301);
```
-`digitnPowers(4)` should return 19316.
+`digitnPowers(4)` dovrebbe restituire 19316.
```js
assert(digitnPowers(4) == 19316);
```
-`digitnPowers(5)` should return 443839.
+`digitnPowers(5)` dovrebbe restituire 443839.
```js
assert(digitnPowers(5) == 443839);
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-31-coin-sums.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-31-coin-sums.md
index 0826a685f4..3b0fbbc561 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-31-coin-sums.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-31-coin-sums.md
@@ -1,6 +1,6 @@
---
id: 5900f38b1000cf542c50fe9e
-title: 'Problem 31: Coin sums'
+title: 'Problema 31: somme di monete'
challengeType: 5
forumTopicId: 301965
dashedName: problem-31-coin-sums
@@ -8,43 +8,43 @@ dashedName: problem-31-coin-sums
# --description--
-In England the currency is made up of pound, £, and pence, p, and there are eight coins in general circulation:
+In Inghilterra la moneta è composta da sterline, £, e pence, p, e ci sono 8 monete in circolazione:
-@@ -16,39 +16,39 @@ Surprisingly there are only three numbers that can be written as the sum of four 9474 = 94 + 44 + 74 + 44
1p, 2p, 5p, 10p, 20p, 50p, £1 (100p) and £2 (200p).
+1p, 2p, 5p, 10p, 20p, 50p, £1 (100p) e £2 (200p).
-It is possible to make £2 in the following way:
+È possibile comporre 2 £ nel modo seguente:
1×£1 + 1×50p + 2×20p + 1×5p + 1×2p + 3×1p
-How many different ways can `n` pence be made using any number of coins?
+In quanti modi diversi si possono ottenere `n` pence usando qualsiasi numero di monete?
# --hints--
-`coinSums(50)` should return a number.
+`coinSums(50)` dovrebbe restituire un numero.
```js
assert(typeof coinSums(50) === 'number');
```
-`coinSums(50)` should return 451.
+`coinSums(50)` dovrebbe restituire 451.
```js
assert(coinSums(50) == 451);
```
-`coinSums(100)` should return 4563.
+`coinSums(100)` dovrebbe restituire 4563.
```js
assert(coinSums(100) == 4563);
```
-`coinSums(150)` should return 21873.
+`coinSums(150)` dovrebbe restituire 21873.
```js
assert(coinSums(150) == 21873);
```
-`coinSums(200)` should return 73682.
+`coinSums(200)` dovrebbe restituire 73682.
```js
assert(coinSums(200) == 73682);
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-32-pandigital-products.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-32-pandigital-products.md
index fe1724d44f..d7a5da9781 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-32-pandigital-products.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-32-pandigital-products.md
@@ -1,6 +1,6 @@
---
id: 5900f38c1000cf542c50fe9f
-title: 'Problem 32: Pandigital products'
+title: 'Problema 32: prodotti pandigitali'
challengeType: 5
forumTopicId: 301976
dashedName: problem-32-pandigital-products
@@ -8,47 +8,47 @@ dashedName: problem-32-pandigital-products
# --description--
-We shall say that an `n`-digit number is pandigital if it makes use of all the digits 1 to `n` exactly once; for example, the 5-digit number, 15234, is 1 through 5 pandigital.
+Possiamo dire che un numero di `n` cifre è pandigitale se usa tutte le cifre da 1 a `n` esattamente una volta; per esempio, il numero a 5 cifre 15234 è pandigitale per le cifre da 1 a 5.
-The product 7254 is unusual, as the identity, 39 × 186 = 7254, containing multiplicand, multiplier, and product is 1 through 9 pandigital.
+Il prodotto 7259 è inusuale, in quanto l'identità 39 x 186 = 7254, contenente moltiplicando, moltiplicatore, e prodotto, è pandigitale per le cifre da 1 a 9.
-Find the sum of all products whose multiplicand/multiplier/product identity can be written as a 1 through `n` pandigital.
+Trova le somme di tutti i prodotti la cui identità moltiplicando/moltiplicatore/prodotto può essere scritta come pandigitale per le cifre da 1 a `n`.
-**Hint:** Some products can be obtained in more than one way so be sure to only include it once in your sum.
+**Indizio:** Alcuni prodotti possono essere ottenuti in più di un modo quindi assicurati di includerli una volta sola nella tua somma.
# --hints--
-`pandigitalProducts(4)` should return a number.
+`pandigitalProducts(4)` dovrebbe restituire un numero.
```js
assert(typeof pandigitalProducts(4) === 'number');
```
-`pandigitalProducts(4)` should return `12`.
+`pandigitalProducts(4)` dovrebbe restituire `12`.
```js
assert.strictEqual(pandigitalProducts(4), 12);
```
-`pandigitalProducts(6)` should return `162`.
+`pandigitalProducts(6)` dovrebbe restituire `162`.
```js
assert.strictEqual(pandigitalProducts(6), 162);
```
-`pandigitalProducts(7)` should return `0`.
+`pandigitalProducts(7)` dovrebbe restituire `0`.
```js
assert.strictEqual(pandigitalProducts(7), 0);
```
-`pandigitalProducts(8)` should return `13458`.
+`pandigitalProducts(8)` dovrebbe restituire `13458`.
```js
assert.strictEqual(pandigitalProducts(8), 13458);
```
-`pandigitalProducts(9)` should return `45228`.
+`pandigitalProducts(9)` dovrebbe restituire `45228`.
```js
assert.strictEqual(pandigitalProducts(9), 45228);
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-33-digit-cancelling-fractions.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-33-digit-cancelling-fractions.md
index ec7756e945..28229f8cd8 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-33-digit-cancelling-fractions.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-33-digit-cancelling-fractions.md
@@ -1,6 +1,6 @@
---
id: 5900f38d1000cf542c50fea0
-title: 'Problem 33: Digit cancelling fractions'
+title: 'Problemi 33: frazioni cancellando le cifre'
challengeType: 5
forumTopicId: 301987
dashedName: problem-33-digit-cancelling-fractions
@@ -8,23 +8,23 @@ dashedName: problem-33-digit-cancelling-fractions
# --description--
-The fraction 49/98 is a curious fraction, as an inexperienced mathematician in attempting to simplify it may incorrectly believe that 49/98 = 4/8, which is correct, is obtained by cancelling the 9s.
+La frazione 49/98 è una frazione peculiare, poiché un matematico senza esperienza tentando di semplificarla potrebbe credere incorrettamente che la semplificazione 49/98 = 4/8, che è corretta, è ottenuta cancellando i 9.
-We shall consider fractions like, 30/50 = 3/5, to be trivial examples.
+Possiamo considerare frazioni come 30/50 = 3/5 un esempio triviale.
-There are exactly four non-trivial examples of this type of fraction, less than one in value, and containing two digits in the numerator and denominator.
+Ci sono esattamente quattro esempi non triviali di questo tipo di frazioni, con valore minore di 1, e contenenti due cifre al numeratore e denominatore.
-If the product of these four fractions is given in its lowest common terms, find the value of the denominator.
+Se il prodotto di queste quattro frazioni è dato nel formato semplificato, trova il valore del denominatore.
# --hints--
-`digitCancellingFractions()` should return a number.
+`digitCancellingFractions()` dovrebbe restituire un numero.
```js
assert(typeof digitCancellingFractions() === 'number');
```
-`digitCancellingFractions()` should return 100.
+`digitCancellingFractions()` dovrebbe restituire 100.
```js
assert.strictEqual(digitCancellingFractions(), 100);
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-34-digit-factorials.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-34-digit-factorials.md
index 080d068344..26400e9fdf 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-34-digit-factorials.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-34-digit-factorials.md
@@ -1,6 +1,6 @@
---
id: 5900f38e1000cf542c50fea1
-title: 'Problem 34: Digit factorials'
+title: 'Problema 34: fattoriali delle cifre'
challengeType: 5
forumTopicId: 301998
dashedName: problem-34-digit-factorials
@@ -8,15 +8,15 @@ dashedName: problem-34-digit-factorials
# --description--
-145 is a curious number, as 1! + 4! + 5! = 1 + 24 + 120 = 145.
+145 è un numero curioso, visto che 1! + 4! + 5! = 1 + 24 + 120 = 145.
-Find the numbers and the sum of the numbers which are equal to the sum of the factorial of their digits.
+Trova i numeri e le somme dei numeri che sono uguali alla somma dei fattoriali delle loro cifre.
-**Note:** as 1! = 1 and 2! = 2 are not sums they are not included.
+**Nota:** dato che 1! = 1 e 2! = 2 non sono somme essi non sono inclusi.
# --hints--
-`digitFactorial()` should return an object.
+`digitFactorial()` dovrebbe restituire un oggetto.
```js
assert.typeOf(digitFactorial(), 'object');
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-35-circular-primes.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-35-circular-primes.md
index d3d74989d6..57346f8e37 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-35-circular-primes.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-35-circular-primes.md
@@ -1,6 +1,6 @@
---
id: 5900f38f1000cf542c50fea2
-title: 'Problem 35: Circular primes'
+title: 'Problema 35: Primi circolari'
challengeType: 5
forumTopicId: 302009
dashedName: problem-35-circular-primes
@@ -8,55 +8,55 @@ dashedName: problem-35-circular-primes
# --description--
-The number, 197, is called a circular prime because all rotations of the digits: 197, 971, and 719, are themselves prime.
+Il numero 197 è chiamato un primo circolare perché tutte le rotazioni delle cifre: 197, 971 e 719, sono esse stesse prime.
-There are thirteen such primes below 100: 2, 3, 5, 7, 11, 13, 17, 31, 37, 71, 73, 79, and 97.
+Ci sono tredici di questi primi sotto il 100: 2, 3, 5, 7, 11, 13, 17, 31, 37, 71, 73, 79 e 97.
-How many circular primes are there below `n`, whereas 100 ≤ `n` ≤ 1000000?
+Quanti primi circolari ci sono sotto `n`, dove 100 ≤ `n` ≤ 1000000?
-**Note:**
+**Nota:**
-Circular primes individual rotation can exceed `n`.
+La rotazione individuale di primi circolari può superare `n`.
# --hints--
-`circularPrimes(100)` should return a number.
+`circularPrimes(100)` dovrebbe restituire un numero.
```js
assert(typeof circularPrimes(100) === 'number');
```
-`circularPrimes(100)` should return 13.
+`circularPrimes(100)` dovrebbe restituire 13.
```js
assert(circularPrimes(100) == 13);
```
-`circularPrimes(100000)` should return 43.
+`circularPrimes(100000)` dovrebbe restituire 43.
```js
assert(circularPrimes(100000) == 43);
```
-`circularPrimes(250000)` should return 45.
+`circularPrimes(250000)` dovrebbe restituire 45.
```js
assert(circularPrimes(250000) == 45);
```
-`circularPrimes(500000)` should return 49.
+`circularPrimes(500000)` dovrebbe restituire 49.
```js
assert(circularPrimes(500000) == 49);
```
-`circularPrimes(750000)` should return 49.
+`circularPrimes(750000)` dovrebbe restituire 49.
```js
assert(circularPrimes(750000) == 49);
```
-`circularPrimes(1000000)` should return 55.
+`circularPrimes(1000000)` dovrebbe restituire 55.
```js
assert(circularPrimes(1000000) == 55);
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-36-double-base-palindromes.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-36-double-base-palindromes.md
index 359211b530..5dd073a6cb 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-36-double-base-palindromes.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-36-double-base-palindromes.md
@@ -1,6 +1,6 @@
---
id: 5900f3901000cf542c50fea3
-title: 'Problem 36: Double-base palindromes'
+title: 'Problema 36: palindromi in doppia base'
challengeType: 5
forumTopicId: 302020
dashedName: problem-36-double-base-palindromes
@@ -8,39 +8,39 @@ dashedName: problem-36-double-base-palindromes
# --description--
-The decimal number, 585 = 10010010012 (binary), is palindromic in both bases.
+Il numero decimale 585 = 10010010012 (binary) è un palindromo in entrambe le basi.
-Find the sum of all numbers, less than `n`, whereas 1000 ≤ `n` ≤ 1000000, which are palindromic in base 10 and base 2.
+Trova la somma di tutti i numeri, meno di `n`, dove 1000 ≤ `n` ≤ 1000000, che sono palindromi in base 10 e in base 2.
-(Please note that the palindromic number, in either base, may not include leading zeros.)
+(Si noti che il numero palindromico, in entrambe le basi, non può includere zeri iniziali.)
# --hints--
-`doubleBasePalindromes(1000)` should return a number.
+`doubleBasePalindromes(1000)` dovrebbe restituire un numero.
```js
assert(typeof doubleBasePalindromes(1000) === 'number');
```
-`doubleBasePalindromes(1000)` should return 1772.
+`doubleBasePalindromes(1000)` dovrebbe restituire 1772.
```js
assert(doubleBasePalindromes(1000) == 1772);
```
-`doubleBasePalindromes(50000)` should return 105795.
+`doubleBasePalindromes(50000)` dovrebbe restituire 105795.
```js
assert(doubleBasePalindromes(50000) == 105795);
```
-`doubleBasePalindromes(500000)` should return 286602.
+`doubleBasePalindromes(500000)` dovrebbe restituire 286602.
```js
assert(doubleBasePalindromes(500000) == 286602);
```
-`doubleBasePalindromes(1000000)` should return 872187.
+`doubleBasePalindromes(1000000)` dovrebbe restituire 872187.
```js
assert(doubleBasePalindromes(1000000) == 872187);
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-37-truncatable-primes.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-37-truncatable-primes.md
index 7cac6e4ddb..af6402c745 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-37-truncatable-primes.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-37-truncatable-primes.md
@@ -1,6 +1,6 @@
---
id: 5900f3911000cf542c50fea4
-title: 'Problem 37: Truncatable primes'
+title: 'Problema 37: numeri primi troncabili'
challengeType: 5
forumTopicId: 302031
dashedName: problem-37-truncatable-primes
@@ -8,39 +8,39 @@ dashedName: problem-37-truncatable-primes
# --description--
-The number 3797 has an interesting property. Being prime itself, it is possible to continuously remove digits from left to right, and remain prime at each stage: 3797, 797, 97, and 7. Similarly we can work from right to left: 3797, 379, 37, and 3.
+Il numero 3797 ha una proprietà interessante. Essendo esso stesso un numero primo, è possibile rimuovere continuosamente cifre da sinistra a destra, e rimane primo ad ogni stadio: 3797, 797, 97, e 7. Allo stesso modo possiamo farlo da destra a sinistra: 3797, 379, 37, e 3.
-Find the sum of the only `n` (8 ≤ `n` ≤ 11) primes that are both truncatable from left to right and right to left.
+Trova la somma dei soli `n` (8 ≤ `n` ≤ 11) numeri primi che sono troncabili sia da sinistra a destra che da destra a sinistra.
-NOTE: 2, 3, 5, and 7 are not considered to be truncatable primes.
+Nota: 2, 3, 5, e 7 non sono considerati numeri primi troncabili.
# --hints--
-`truncatablePrimes(8)` should return a number.
+`truncatablePrimes(8)` dovrebbe restituire un numero.
```js
assert(typeof truncatablePrimes(8) === 'number');
```
-`truncatablePrimes(8)` should return 1986.
+`truncatablePrimes(8)` dovrebbe restituire 1986.
```js
assert(truncatablePrimes(8) == 1986);
```
-`truncatablePrimes(9)` should return 5123.
+`truncatablePrimes(9)` dovrebbe restituire 5123.
```js
assert(truncatablePrimes(9) == 5123);
```
-`truncatablePrimes(10)` should return 8920.
+`truncatablePrimes(10)` dovrebbe restituire 8920.
```js
assert(truncatablePrimes(10) == 8920);
```
-`truncatablePrimes(11)` should return 748317.
+`truncatablePrimes(11)` dovrebbe restituire 748317.
```js
assert(truncatablePrimes(11) == 748317);
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-38-pandigital-multiples.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-38-pandigital-multiples.md
index 1c3f0c56c6..d2eb417af4 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-38-pandigital-multiples.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-38-pandigital-multiples.md
@@ -1,6 +1,6 @@
---
id: 5900f3931000cf542c50fea5
-title: 'Problem 38: Pandigital multiples'
+title: 'Problema 38: Multipli pandigitali'
challengeType: 5
forumTopicId: 302042
dashedName: problem-38-pandigital-multiples
@@ -8,31 +8,31 @@ dashedName: problem-38-pandigital-multiples
# --description--
-Take the number 192 and multiply it by each of 1, 2, and 3:
+Prendi il numero 192 e moltiplicalo separatemente per 1, 2, e 3:
$$\begin{align} 192 × 1 = 192\\\\ 192 × 2 = 384\\\\ 192 × 3 = 576\\\\ \end{align}$$
-By concatenating each product we get the 1 to 9 pandigital, 192384576. We will call 192384576 the concatenated product of 192 and (1, 2, 3).
+Concatenando ogni prodotto otteniamo il pandigitale di cifre da 1 a 9, 192384576. Chiamiamo 192384576 il prodotto concatenato di 192 e (1, 2, 3).
-The same can be achieved by starting with 9 and multiplying by 1, 2, 3, 4, and 5, giving the pandigital, 918273645, which is the concatenated product of 9 and (1, 2, 3, 4, 5).
+Lo stesso può essere ottenuto iniziando con 9 e moltiplicandolo con 1, 2, 3, 4, e 5, dando il numero pandigitale 918273645, che è il prodotto concatenato di 9 e (1, 2, 3, 4, 5).
-What is the largest 1 to `k` pandigital `k`-digit number that can be formed as the concatenated product of an integer with (1, 2, ..., `n`) where `n` > 1?
+Quale è il pandigitale con cifre da 1 a `k` lungo `k` cifre che può essere formato come prodotto concatenato di un numeri intero (1, 2, ..., `n`) dove `n` > 1?
# --hints--
-`pandigitalMultiples(8)` should return a number.
+`pandigitalMultiples(8)` dovrebbe restituire un numero.
```js
assert(typeof pandigitalMultiples(8) === 'number');
```
-`pandigitalMultiples(8)` should return `78156234`.
+`pandigitalMultiples(8)` dovrebbe restituire `78156234`.
```js
assert.strictEqual(pandigitalMultiples(8), 78156234);
```
-`pandigitalMultiples(9)` should return `932718654`.
+`pandigitalMultiples(9)` dovrebbe restituire `932718654`.
```js
assert.strictEqual(pandigitalMultiples(9), 932718654);
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-39-integer-right-triangles.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-39-integer-right-triangles.md
index d19bb816b7..da09b39bd3 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-39-integer-right-triangles.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-39-integer-right-triangles.md
@@ -1,6 +1,6 @@
---
id: 5900f3931000cf542c50fea6
-title: 'Problem 39: Integer right triangles'
+title: 'Problema 39: triangoli rettangoli interi'
challengeType: 5
forumTopicId: 302054
dashedName: problem-39-integer-right-triangles
@@ -8,39 +8,39 @@ dashedName: problem-39-integer-right-triangles
# --description--
-If `p` is the perimeter of a right angle triangle with integral length sides, {a,b,c}, there are exactly three solutions for p = 120.
+Se `p` è il perimetro di un triangolo rettangolo con lunghezza dei lati di numeri interi, {a,b,c}, ci sono esattamente tre soluzioni per p = 120.
{20,48,52}, {24,45,51}, {30,40,50}
-For which value of `p` ≤ `n`, is the number of solutions maximized?
+Per quale valore di `p` ≤ `n` il numero delle soluzioni viene massimizzato?
# --hints--
-`intRightTriangles(500)` should return a number.
+`intRightTriangles(500)` dovrebbe restituire un numero.
```js
assert(typeof intRightTriangles(500) === 'number');
```
-`intRightTriangles(500)` should return 420.
+`intRightTriangles(500)` dovrebbe restituire 420.
```js
assert(intRightTriangles(500) == 420);
```
-`intRightTriangles(800)` should return 720.
+`intRightTriangles(800)` dovrebbe restituire 720.
```js
assert(intRightTriangles(800) == 720);
```
-`intRightTriangles(900)` should return 840.
+`intRightTriangles(900)` dovrebbe restituire 840.
```js
assert(intRightTriangles(900) == 840);
```
-`intRightTriangles(1000)` should return 840.
+`intRightTriangles(1000)` dovrebbe restituire 840.
```js
assert(intRightTriangles(1000) == 840);
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-40-champernownes-constant.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-40-champernownes-constant.md
index f7f6c8f51f..83875efa02 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-40-champernownes-constant.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-40-champernownes-constant.md
@@ -1,6 +1,6 @@
---
id: 5900f3941000cf542c50fea7
-title: 'Problem 40: Champernowne''s constant'
+title: 'Problema 40: costante di Champernowne'
challengeType: 5
forumTopicId: 302066
dashedName: problem-40-champernownes-constant
@@ -8,37 +8,37 @@ dashedName: problem-40-champernownes-constant
# --description--
-An irrational decimal fraction is created by concatenating the positive integers:
+Una frazione decimale irrazionale è creata concatenando i numeri interi positivi:
0.12345678910**1**112131415161718192021...
-It can be seen that the 12th digit of the fractional part is 1.
+Puoi vedere che la dodicesima cifra della parte frazionale è 1.
-If *dn* represents the *n*th digit of the fractional part, find the value of the following expression.
+Se *dn* rappresenta la *n*-sima cifra della parte frazionale, trova il valore di questa espressione.
d1 × d10 × d100 × d1000 × d10000 × d100000 × d1000000
# --hints--
-`champernownesConstant(100)` should return a number.
+`champernownesConstant(100)` dovrebbe restituire un numero.
```js
assert(typeof champernownesConstant(100) === 'number');
```
-`champernownesConstant(100)` should return 5.
+`champernownesConstant(100)` dovrebbe restituire 5.
```js
assert.strictEqual(champernownesConstant(100), 5);
```
-`champernownesConstant(1000)` should return 15.
+`champernownesConstant(1000)` dovrebbe restituire 15.
```js
assert.strictEqual(champernownesConstant(1000), 15);
```
-`champernownesConstant(1000000)` should return 210.
+`champernownesConstant(1000000)` dovrebbe restituire 210.
```js
assert.strictEqual(champernownesConstant(1000000), 210);
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-41-pandigital-prime.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-41-pandigital-prime.md
index 41465478fc..b65c1a3c03 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-41-pandigital-prime.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-41-pandigital-prime.md
@@ -1,6 +1,6 @@
---
id: 5900f3951000cf542c50fea8
-title: 'Problem 41: Pandigital prime'
+title: 'Problema 41: Primi pandigitali'
challengeType: 5
forumTopicId: 302078
dashedName: problem-41-pandigital-prime
@@ -8,25 +8,25 @@ dashedName: problem-41-pandigital-prime
# --description--
-We shall say that an `n`-digit number is pandigital if it makes use of all the digits 1 to `n` exactly once. For example, 2143 is a 4-digit pandigital and is also prime.
+Diremo che un numero di cifre `n` è pandigitale se utilizza tutte le cifre da 1 a `n` esattamente una volta. Ad esempio, 2143 è un pandigitale a 4 cifre ed è anche primo.
-What is the largest `n`-length digit pandigital prime that exists?
+Qual è il più grande pandigitale primo a `n` cifre esistente?
# --hints--
-`pandigitalPrime(4)` should return a number.
+`pandigitalPrime(4)` dovrebbe restituire un numero.
```js
assert(typeof pandigitalPrime(4) === 'number');
```
-`pandigitalPrime(4)` should return 4231.
+`pandigitalPrime(4)` dovrebbe restituire 4231.
```js
assert(pandigitalPrime(4) == 4231);
```
-`pandigitalPrime(7)` should return 7652413.
+`pandigitalPrime(7)` dovrebbe restituire 7652413.
```js
assert(pandigitalPrime(7) == 7652413);
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-42-coded-triangle-numbers.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-42-coded-triangle-numbers.md
index bc3de08623..ad3cd45bd3 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-42-coded-triangle-numbers.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-42-coded-triangle-numbers.md
@@ -1,6 +1,6 @@
---
id: 5900f3961000cf542c50fea9
-title: 'Problem 42: Coded triangle numbers'
+title: 'Problema 42: Numeri codificati triangolari'
challengeType: 5
forumTopicId: 302089
dashedName: problem-42-coded-triangle-numbers
@@ -8,41 +8,41 @@ dashedName: problem-42-coded-triangle-numbers
# --description--
-The `n`th term of the sequence of triangle numbers is given by, `tn` = ½`n`(`n`+1); so the first ten triangle numbers are:
+L'`n`-simo termine di una sequenza di numeri triangolari è data da `tn` = ½`n`(`n`+1); quindi i primi dieci numeri triangolari sono:
1, 3, 6, 10, 15, 21, 28, 36, 45, 55, ...
-By converting each letter in a word to a number corresponding to its alphabetical position and adding these values we form a word value. For example, the word value for SKY is 19 + 11 + 25 = 55 = `t`10. If the word value is a triangle number then we shall call the word a triangle word.
+Convertendo ogni lettera in una parola in un numero corrispondente alla sua posizione nell'alfabeto a 26 lettere, e sommando questi valori otteniamo il valore della parola. Per esempio, il valore della parola SKY è 19 + 11 + 25 = 55 = `t`10. Se il valore della parola è un numero triangolare allora chiamiamo questa parola triangolare.
-Using words array of `n`-length, how many are triangle words?
+Usando array di parole lungo `n`, quante sono parole triangolari?
# --hints--
-`codedTriangleNumbers(1400)` should return a number.
+`codedTriangleNumbers(1400)` dovrebbe restituire un numero.
```js
assert(typeof codedTriangleNumbers(1400) === 'number');
```
-`codedTriangleNumbers(1400)` should return 129.
+`codedTriangleNumbers(1400)` dovrebbe restituire 129.
```js
assert(codedTriangleNumbers(1400) == 129);
```
-`codedTriangleNumbers(1500)` should return 137.
+`codedTriangleNumbers(1500)` dovrebbe restituire 137.
```js
assert(codedTriangleNumbers(1500) == 137);
```
-`codedTriangleNumbers(1600)` should return 141.
+`codedTriangleNumbers(1600)` dovrebbe restituire 141.
```js
assert(codedTriangleNumbers(1600) == 141);
```
-`codedTriangleNumbers(1786)` should return 162.
+`codedTriangleNumbers(1786)` dovrebbe restituire 162.
```js
assert(codedTriangleNumbers(1786) == 162);
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-43-sub-string-divisibility.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-43-sub-string-divisibility.md
index 7c3a5a8342..42286c8c61 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-43-sub-string-divisibility.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-43-sub-string-divisibility.md
@@ -1,6 +1,6 @@
---
id: 5900f3971000cf542c50feaa
-title: 'Problem 43: Sub-string divisibility'
+title: 'Problema 43: Divisibilità in sotto-stringhe'
challengeType: 5
forumTopicId: 302100
dashedName: problem-43-sub-string-divisibility
@@ -8,49 +8,49 @@ dashedName: problem-43-sub-string-divisibility
# --description--
-The number, 1406357289, is a 0 to 9 pandigital number because it is made up of each of the digits 0 to 9 in some order, but it also has a rather interesting sub-string divisibility property.
+Il numero 1406357289 è un numero pandigitale da 0 a 9 perché è costituito da ciascuna delle cifre da 0 a 9 in un certo ordine, ma ha anche una proprietà di divisibilità in sotto-stringhe piuttosto interessante.
-Let $d_1$ be the $1^{st}$ digit, $d_2$ be the $2^{nd}$ digit, and so on. In this way, we note the following:
+Sia $d_1$ il $1^{st}$ numero, $d_2$ sia il $2^{nd}$ numero, e così via. In questo modo, notiamo quanto segue:
-- ${d_2}{d_3}{d_4} = 406$ is divisible by 2
-- ${d_3}{d_4}{d_5} = 063$ is divisible by 3
-- ${d_4}{d_5}{d_6} = 635$ is divisible by 5
-- ${d_5}{d_6}{d_7} = 357$ is divisible by 7
-- ${d_6}{d_7}{d_8} = 572$ is divisible by 11
-- ${d_7}{d_8}{d_9} = 728$ is divisible by 13
-- ${d_8}{d_9}{d_{10}} = 289$ is divisible by 17
+- ${d_2}{d_3}{d_4} = 406$ è divisibile per 2
+- ${d_3}{d_4}{d_5} = 063$ è divisibile per 3
+- ${d_4}{d_5}{d_6} = 635$ è divisibile per 5
+- ${d_5}{d_6}{d_7} = 357$ è divisibile per 7
+- ${d_6}{d_7}{d_8} = 572$ è divisibile per 11
+- ${d_7}{d_8}{d_9} = 728$ è divisibile per 13
+- ${d_8}{d_9}{d_{10}} = 289$ è divisibile per 17
-Find the sum of all 0 to `n` pandigital numbers with sub-strings fulfilling `n - 2` of these divisibility properties.
+Trova la somma di tutti i numeri pandigitali da 0 a `n` con sotto-stringhe che soddisfano `n - 2` di queste proprietà di divisibilità.
-**Note:** Pandigital numbers starting with `0` are to be considered in the result.
+**Nota:** i numeri pandigitali che iniziano con `0` devono essere considerati nel risultato.
# --hints--
-`substringDivisibility(5)` should return a number.
+`substringDivisibility(5)` dovrebbe restituire un numero.
```js
assert(typeof substringDivisibility(5) === 'number');
```
-`substringDivisibility(5)` should return `12444480`.
+`substringDivisibility(5)` dovrebbe restituire `12444480`.
```js
assert.strictEqual(substringDivisibility(5), 12444480)
```
-`substringDivisibility(7)` should return `1099210170`.
+`substringDivisibility(7)` dovrebbe restituire `1099210170`.
```js
assert.strictEqual(substringDivisibility(7), 1099210170)
```
-`substringDivisibility(8)` should return `1113342912`.
+`substringDivisibility(8)` dovrebbe restituire `1113342912`.
```js
assert.strictEqual(substringDivisibility(8), 1113342912)
```
-`substringDivisibility(9)` should return `16695334890`.
+`substringDivisibility(9)` dovrebbe restituire `16695334890`.
```js
assert.strictEqual(substringDivisibility(9), 16695334890)
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-44-pentagon-numbers.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-44-pentagon-numbers.md
index 3b89176ca1..1a1539eb16 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-44-pentagon-numbers.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-44-pentagon-numbers.md
@@ -1,6 +1,6 @@
---
id: 5900f3981000cf542c50feab
-title: 'Problem 44: Pentagon numbers'
+title: 'Problema 44: numeri pentagonali'
challengeType: 5
forumTopicId: 302111
dashedName: problem-44-pentagon-numbers
@@ -8,23 +8,23 @@ dashedName: problem-44-pentagon-numbers
# --description--
-Pentagonal numbers are generated by the formula, Pn=`n`(3`n`−1)/2. The first ten pentagonal numbers are:
+Numeri pentagonali sono generati dalla formula Pn=`n`(3`n`−1)/2. I primi dieci numeri pentagonali sono:
1, 5, 12, 22, 35, 51, 70, 92, 117, 145, ...
-It can be seen that P4 + P7 = 22 + 70 = 92 = P8. However, their difference, 70 − 22 = 48, is not pentagonal.
+Possiamo vedere che P4 + P7 = 22 + 70 = 92 = P8. D'altro canto, la loro differenza, 70 − 22 = 48, non è pentagonale.
-Find the pair of pentagonal numbers, Pj and Pk, for which their sum and difference are pentagonal and D = |Pk − Pj| is minimized; what is the value of D?
+Trova la coppia di numeri, Pj and Pk, per cui sia la loro somma che la loro differenza sono pentagonali e D = |Pk − Pj| è minimizzata; quale è il valore di D?
# --hints--
-`pentagonNumbers()` should return a number.
+`pentagonNumbers()` dovrebbe restituire un numero.
```js
assert(typeof pentagonNumbers() === 'number');
```
-`pentagonNumbers()` should return 5482660.
+`pentagonNumbers()` dovrebbe restituire 5482660.
```js
assert.strictEqual(pentagonNumbers(), 5482660);
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-45-triangular-pentagonal-and-hexagonal.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-45-triangular-pentagonal-and-hexagonal.md
index 5c3b224b4a..f5f3177c8e 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-45-triangular-pentagonal-and-hexagonal.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-45-triangular-pentagonal-and-hexagonal.md
@@ -1,6 +1,6 @@
---
id: 5900f3991000cf542c50feac
-title: 'Problem 45: Triangular, pentagonal, and hexagonal'
+title: 'Problema 45: triangolari, pentagonali ed esagonali'
challengeType: 5
forumTopicId: 302122
dashedName: problem-45-triangular-pentagonal-and-hexagonal
@@ -8,25 +8,25 @@ dashedName: problem-45-triangular-pentagonal-and-hexagonal
# --description--
-Triangle, pentagonal, and hexagonal numbers are generated by the following formulae:
+Numeri triangolari, pentagonali, ed esagonali sono generati dalle seguenti formule:
-Triangle
Tn=n(n+1)/2
1, 3, 6, 10, 15, ...
Pentagonal
Pn=n(3n−1)/2
1, 5, 12, 22, 35, ...
Hexagonal
Hn=n(2n−1)
1, 6, 15, 28, 45, ...
Triangolare
Tn=n(n+1)/2
1, 3, 6, 10, 15, ...
Pentagonale
Pn=n(3n−1)/2
1, 5, 12, 22, 35, ...
Esagonale
Hn=n(2n−1)
1, 6, 15, 28, 45, ...
9 = 7 + 2×12
@@ -19,19 +19,19 @@ It was proposed by Christian Goldbach that every odd composite number can be wri 33 = 31 + 2×12
-It turns out that the conjecture was false.
+Si scoprì che la congettura era falsa.
-What is the smallest odd composite that cannot be written as the sum of a prime and twice a square?
+Qual è il più piccolo composito dispari che non può essere scritto come la somma di un primo e due volte un quadrato?
# --hints--
-`goldbachsOtherConjecture()` should return a number.
+`goldbachsOtherConjecture()` dovrebbe restituire un numero.
```js
assert(typeof goldbachsOtherConjecture() === 'number');
```
-`goldbachsOtherConjecture()` should return 5777.
+`goldbachsOtherConjecture()` dovrebbe restituire 5777.
```js
assert.strictEqual(goldbachsOtherConjecture(), 5777);
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-47-distinct-primes-factors.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-47-distinct-primes-factors.md
index 998b035f79..e455497d01 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-47-distinct-primes-factors.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-47-distinct-primes-factors.md
@@ -1,6 +1,6 @@
---
id: 5900f39c1000cf542c50feae
-title: 'Problem 47: Distinct primes factors'
+title: 'Problema 47: Fattori primi distinti'
challengeType: 5
forumTopicId: 302145
dashedName: problem-47-distinct-primes-factors
@@ -8,14 +8,14 @@ dashedName: problem-47-distinct-primes-factors
# --description--
-The first two consecutive numbers to have two distinct prime factors are:
+I primi due numeri consecutivi ad avere due distinti fattori primi sono:
@@ -19,19 +19,19 @@ It was proposed by Christian Goldbach that every odd composite number can be wri 33 = 31 + 2×12
14 = 2 × 7
15 = 3 × 5
-The first three consecutive numbers to have three distinct prime factors are:
+I primi tre numeri consecutivi che hanno tre fattori primi distinti sono:
15 = 3 × 5
644 = 22 × 7 × 23
@@ -23,29 +23,29 @@ The first three consecutive numbers to have three distinct prime factors are: 646 = 2 × 17 × 19
-Find the first four consecutive integers to have four distinct prime factors each. What is the first of these numbers?
+Trova i primi quattro interi consecutivi ad avere quattro distinti fattori primi ciascuno. Qual è il primo di questi numeri?
# --hints--
-`distinctPrimeFactors(2, 2)` should return a number.
+`distinctPrimeFactors(2, 2)` dovrebbe restituire un numero.
```js
assert(typeof distinctPrimeFactors(2, 2) === 'number');
```
-`distinctPrimeFactors(2, 2)` should return 14.
+`distinctPrimeFactors(2, 2)` dovrebbe restituire 14.
```js
assert.strictEqual(distinctPrimeFactors(2, 2), 14);
```
-`distinctPrimeFactors(3, 3)` should return 644.
+`distinctPrimeFactors(3, 3)` dovrebbe restituire 644.
```js
assert.strictEqual(distinctPrimeFactors(3, 3), 644);
```
-`distinctPrimeFactors(4, 4)` should return 134043.
+`distinctPrimeFactors(4, 4)` dovrebbe restituire 134043.
```js
assert.strictEqual(distinctPrimeFactors(4, 4), 134043);
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-48-self-powers.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-48-self-powers.md
index 58e654f893..cd5a6cd4ad 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-48-self-powers.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-48-self-powers.md
@@ -1,6 +1,6 @@
---
id: 5900f39c1000cf542c50feaf
-title: 'Problem 48: Self powers'
+title: 'Problema 48: auto-potenze'
challengeType: 5
forumTopicId: 302157
dashedName: problem-48-self-powers
@@ -8,37 +8,37 @@ dashedName: problem-48-self-powers
# --description--
-The series, 11 + 22 + 33 + ... + 1010 = 10405071317.
+La serie 11 + 22 + 33 + ... + 1010 = 10405071317.
-Find the last ten digits of the series, 11 + 22 + 33 + ... + 10001000.
+Trova le ultime dieci cifre della serie 11 + 22 + 33 + ... + 10001000.
# --hints--
-`selfPowers(10, 3)` should return a number.
+`selfPowers(10, 3)` dovrebbe restituire un numero.
```js
assert(typeof selfPowers(10, 3) === 'number');
```
-`selfPowers(10, 3)` should return 317.
+`selfPowers(10, 3)` dovrebbe restituire 317.
```js
assert.strictEqual(selfPowers(10, 3), 317);
```
-`selfPowers(150, 6)` should return 29045.
+`selfPowers(150, 6)` dovrebbe restituire 29045.
```js
assert.strictEqual(selfPowers(150, 6), 29045);
```
-`selfPowers(673, 7)` should return 2473989.
+`selfPowers(673, 7)` dovrebbe restituire 2473989.
```js
assert.strictEqual(selfPowers(673, 7), 2473989);
```
-`selfPowers(1000, 10)` should return 9110846700.
+`selfPowers(1000, 10)` dovrebbe restituire 9110846700.
```js
assert.strictEqual(selfPowers(1000, 10), 9110846700);
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-49-prime-permutations.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-49-prime-permutations.md
index 0dc7ae0ddc..e09e517b8e 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-49-prime-permutations.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-49-prime-permutations.md
@@ -1,6 +1,6 @@
---
id: 5900f39d1000cf542c50feb0
-title: 'Problem 49: Prime permutations'
+title: 'Problema 49: permutazioni di numeri primi'
challengeType: 5
forumTopicId: 302159
dashedName: problem-49-prime-permutations
@@ -8,21 +8,21 @@ dashedName: problem-49-prime-permutations
# --description--
-The arithmetic sequence, 1487, 4817, 8147, in which each of the terms increases by 3330, is unusual in two ways: (i) each of the three terms are prime, and, (ii) each of the 4-digit numbers are permutations of one another.
+La sequenza aritmetica, 1487, 4817, 8147, in cui ognuno dei termini cresce di 3330, è inusuale in due modi: (i) i tre termini sono primi, e, (ii) i tre numeri sono permutazioni.
-There are no arithmetic sequences made up of three 1-, 2-, or 3-digit primes, exhibiting this property, but there is one other 4-digit increasing sequence.
+Non ci sono sequenze aritmetiche fatte di numeri primi a 1, 2 o 3 cifre che esibiscono questa proprietà, ma ce ne è un'altra sequenza crescente a 4 cifre.
-What 12-digit number do you form by concatenating the three terms in this sequence?
+Quale numero a 12 cifre ottieni concatenando i tre termini di questa sequenza?
# --hints--
-`primePermutations()` should return a number.
+`primePermutations()` dovrebbe restituire un numero.
```js
assert(typeof primePermutations() === 'number');
```
-`primePermutations()` should return 296962999629.
+`primePermutations()` dovrebbe restituire 296962999629.
```js
assert.strictEqual(primePermutations(), 296962999629);
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-50-consecutive-prime-sum.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-50-consecutive-prime-sum.md
index 92924bf85e..ad02851e16 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-50-consecutive-prime-sum.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-50-consecutive-prime-sum.md
@@ -1,6 +1,6 @@
---
id: 5900f39e1000cf542c50feb1
-title: 'Problem 50: Consecutive prime sum'
+title: 'Problema 50: somma di primi consecutivi'
challengeType: 5
forumTopicId: 302161
dashedName: problem-50-consecutive-prime-sum
@@ -8,31 +8,31 @@ dashedName: problem-50-consecutive-prime-sum
# --description--
-The prime 41, can be written as the sum of six consecutive primes:
+Il primo 41, può essere scritto come la somma di sei primi consecutivi:
@@ -23,29 +23,29 @@ The first three consecutive numbers to have three distinct prime factors are: 646 = 2 × 17 × 19
41 = 2 + 3 + 5 + 7 + 11 + 13
-This is the longest sum of consecutive primes that adds to a prime below one-hundred.
+Questa è la somma più lunga di primi consecutivi che dà come somma un primo sotto il cento.
-The longest sum of consecutive primes below one-thousand that adds to a prime, contains 21 terms, and is equal to 953.
+La somma più lunga di primi consecutivi sotto il mille che dà come somma un primo, contiene 21 termini, ed è pari a 953.
-Which prime, below one-million, can be written as the sum of the most consecutive primes?
+Quale primo, al di sotto di un milione, può essere scritto come la somma del maggior numero di numeri primi consecutivi?
# --hints--
-`consecutivePrimeSum(1000)` should return a number.
+`consecutivePrimeSum(1000)` dovrebbe restituire un numero.
```js
assert(typeof consecutivePrimeSum(1000) === 'number');
```
-`consecutivePrimeSum(1000)` should return 953.
+`consecutivePrimeSum(1000)` dovrebbe restituire 953.
```js
assert.strictEqual(consecutivePrimeSum(1000), 953);
```
-`consecutivePrimeSum(1000000)` should return 997651.
+`consecutivePrimeSum(1000000)` dovrebbe restituire 997651.
```js
assert.strictEqual(consecutivePrimeSum(1000000), 997651);
@@ -54,42 +54,70 @@ consecutivePrimeSum(1000000);
# --solutions--
```js
-function consecutivePrimeSum(limit) {
- function isPrime(num) {
- if (num < 2) {
- return false;
- } else if (num === 2) {
- return true;
- }
- const sqrtOfNum = Math.floor(num ** 0.5);
- for (let i = 2; i <= sqrtOfNum + 1; i++) {
- if (num % i === 0) {
- return false;
- }
+// Initalize prime number list with sieve
+const NUM_PRIMES = 1000000;
+const PRIMES = [2];
+const PRIME_SIEVE = Array(Math.floor((NUM_PRIMES-1)/2)).fill(true);
+(function initPrimes(num) {
+ const upper = Math.floor((num - 1) / 2);
+ const sqrtUpper = Math.floor((Math.sqrt(num) - 1) / 2);
+ for (let i = 0; i <= sqrtUpper; i++) {
+ if (PRIME_SIEVE[i]) {
+ // Mark value in PRIMES array
+ const prime = 2 * i + 3;
+ PRIMES.push(prime);
+ // Mark all multiples of this number as false (not prime)
+ const primeSqaredIndex = 2 * i ** 2 + 6 * i + 3;
+ for (let j = primeSqaredIndex; j < upper; j += prime)
+ PRIME_SIEVE[j] = false;
}
+ }
+ for (let i = sqrtUpper + 1; i < upper; i++) {
+ if (PRIME_SIEVE[i])
+ PRIMES.push(2 * i + 3);
+ }
+})(NUM_PRIMES);
+
+function isPrime(num) {
+ if (num === 2)
return true;
- }
- function getPrimes(limit) {
- const primes = [];
- for (let i = 0; i <= limit; i++) {
- if (isPrime(i)) primes.push(i);
- }
- return primes;
- }
+ else if (num % 2 === 0)
+ return false
+ else
+ return PRIME_SIEVE[(num - 3) / 2];
+}
- const primes = getPrimes(limit);
- let primeSum = [...primes];
- primeSum.reduce((acc, n, i) => {
- primeSum[i] += acc;
- return acc += n;
- }, 0);
+function consecutivePrimeSum(limit) {
+ // Initalize for longest sum < 100
+ let bestPrime = 41;
+ let bestI = 0;
+ let bestJ = 5;
- for (let j = primeSum.length - 1; j >= 0; j--) {
- for (let i = 0; i < j; i++) {
- const sum = primeSum[j] - primeSum[i];
- if (sum > limit) break;
- if (isPrime(sum) && primes.indexOf(sum) > -1) return sum;
+ // Find longest sum < limit
+ let sumOfCurrRange = 41;
+ let i = 0, j = 5;
+ // -- Loop while current some starting at i is < limit
+ while (sumOfCurrRange < limit) {
+ let currSum = sumOfCurrRange;
+ // -- Loop while pushing j towards end of PRIMES list
+ // keeping sum under limit
+ while (currSum < limit) {
+ if (isPrime(currSum)) {
+ bestPrime = sumOfCurrRange = currSum;
+ bestI = i;
+ bestJ = j;
+ }
+ // -- Increment inner loop
+ j++;
+ currSum += PRIMES[j];
}
+ // -- Increment outer loop
+ i++;
+ j = i + (bestJ - bestI);
+ sumOfCurrRange -= PRIMES[i - 1];
+ sumOfCurrRange += PRIMES[j];
}
+ // Return
+ return bestPrime;
}
```
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-51-prime-digit-replacements.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-51-prime-digit-replacements.md
index d890d42133..db9581caec 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-51-prime-digit-replacements.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-51-prime-digit-replacements.md
@@ -1,6 +1,6 @@
---
id: 5900f39f1000cf542c50feb2
-title: 'Problem 51: Prime digit replacements'
+title: 'Problema 51: sostituzioni di cifre nei primi'
challengeType: 5
forumTopicId: 302162
dashedName: problem-51-prime-digit-replacements
@@ -8,33 +8,33 @@ dashedName: problem-51-prime-digit-replacements
# --description--
-By replacing the 1st digit of the 2-digit number \*3, it turns out that six of the nine possible values: 13, 23, 43, 53, 73, and 83, are all prime.
+Sostituendo la prima cifra del numero a 2 cifre \*3, si scopre che sei dei nove valori possibili: 13, 23, 43, 53, 73 e 83, sono tutti primi.
-By replacing the 3rd and 4th digits of 56\*\*3 with the same digit, this 5-digit number is the first example having seven primes among the ten generated numbers, yielding the family: 56003, 56113, 56333, 56443, 56663, 56773, and 56993. Consequently 56003, being the first member of this family, is the smallest prime with this property.
+Sostituendo la terza e la quarta cifra di 56\*\*3 con la stessa cifra, questo numero a 5 cifre è il primo esempio con sette primi tra i dieci numeri generati, della famiglia: 56003, 56113, 56333, 56443, 56663, 56773 e 56993. Di conseguenza, 56003, essendo il primo membro di questa famiglia, è il più piccolo primo con questa proprietà.
-Find the smallest prime which, by replacing part of the number (not necessarily adjacent digits) with the same digit, is part of an `n` prime value family.
+Trova il primo più piccolo che, sostituendo parte del numero (non necessariamente cifre adiacenti) con la stessa cifra, fa parte di una famiglia di `n` valori primi.
# --hints--
-`primeDigitReplacements(6)` should return a number.
+`primeDigitReplacements(6)` dovrebbe restituire un numero.
```js
assert(typeof primeDigitReplacements(6) === 'number');
```
-`primeDigitReplacements(6)` should return `13`.
+`primeDigitReplacements(6)` dovrebbe restituire `13`.
```js
assert.strictEqual(primeDigitReplacements(6), 13);
```
-`primeDigitReplacements(7)` should return `56003`.
+`primeDigitReplacements(7)` dovrebbe restituire `56003`.
```js
assert.strictEqual(primeDigitReplacements(7), 56003);
```
-`primeDigitReplacements(8)` should return `121313`.
+`primeDigitReplacements(8)` dovrebbe restituire `121313`.
```js
assert.strictEqual(primeDigitReplacements(8), 121313);
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-52-permuted-multiples.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-52-permuted-multiples.md
index d5431d8135..a6aaf09e36 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-52-permuted-multiples.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-52-permuted-multiples.md
@@ -1,6 +1,6 @@
---
id: 5900f3a01000cf542c50feb3
-title: 'Problem 52: Permuted multiples'
+title: 'Problema 52: multipli permutati'
challengeType: 5
forumTopicId: 302163
dashedName: problem-52-permuted-multiples
@@ -8,25 +8,25 @@ dashedName: problem-52-permuted-multiples
# --description--
-It can be seen that the number, 125874, and its double, 251748, contain exactly the same digits, but in a different order.
+Si può notare che il numero 125874 e il suo doppio, 251748, contengono esattamente le stesse cifre, ma in un ordine differente.
-Find the smallest positive integer, such that multiplied by integers $\\{2, 3, \ldots, n\\}$, contain the same digits.
+Trova il più piccolo numero intero positivo, che moltiplicato per gli interi $\\{2, 3, \ldots, n\\}$, contenga le stesse cifre.
# --hints--
-`permutedMultiples(2)` should return a number.
+`permutedMultiples(2)` dovrebbe restituire un numero.
```js
assert(typeof permutedMultiples(2) === 'number');
```
-`permutedMultiples(2)` should return `125874`.
+`permutedMultiples(2)` dovrebbe restituire `125874`.
```js
assert.strictEqual(permutedMultiples(2), 125874);
```
-`permutedMultiples(6)` should return `142857`.
+`permutedMultiples(6)` dovrebbe restituire `142857`.
```js
assert.strictEqual(permutedMultiples(6), 142857);
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-53-combinatoric-selections.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-53-combinatoric-selections.md
index dbd39ef975..b3f9e9ee58 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-53-combinatoric-selections.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-53-combinatoric-selections.md
@@ -1,6 +1,6 @@
---
id: 5900f3a11000cf542c50feb4
-title: 'Problem 53: Combinatoric selections'
+title: 'Problema 53: selezione combinatoria'
challengeType: 5
forumTopicId: 302164
dashedName: problem-53-combinatoric-selections
@@ -8,45 +8,45 @@ dashedName: problem-53-combinatoric-selections
# --description--
-There are exactly ten ways of selecting three from five, 12345:
+Ci sono esattamente dieci modi di selezionare tre da cinque, 12345:
-123, 124, 125, 134, 135, 145, 234, 235, 245, and 345
+123, 124, 125, 134, 135, 145, 234, 235, 245, e 345
-In combinatorics, we use the notation, $\\displaystyle \\binom 5 3 = 10$
+In statistica combinatoria, usiamo la notazione, $\\displaystyle \\binom 5 3 = 10$
-In general, $\\displaystyle \\binom n r = \\dfrac{n!}{r!(n-r)!}$, where $r \\le n$, $n! = n \\times (n-1) \\times ... \\times 3 \\times 2 \\times 1$, and $0! = 1$.
+In generals, $\\displaystyle \\binom n r = \\dfrac{n!}{r!(n-r)!}$, dove $r \\le n$, $n! = n \\times (n-1) \\times ... \\times 3 \\times 2 \\times 1$, e $0! = 1$.
-It is not until $n = 23$, that a value exceeds one-million: $\\displaystyle \\binom {23} {10} = 1144066$.
+È solo raggiungendo $n = 23$, che un valore eccede un milione: $\\displaystyle \\binom {23} {10} = 1144066$.
-How many, not necessarily distinct, values of $\\displaystyle \\binom n r$ for $1 \\le n \\le 100$, are greater than one-million?
+Quanti, non necessariamente distinti, valori di $\\displaystyle \\binom n r$ per $1 \\le n \\le 100$, sono più grandi di un milione?
# --hints--
-`combinatoricSelections(1000)` should return a number.
+`combinatoricSelections(1000)` dovrebbe restituire un numero.
```js
assert(typeof combinatoricSelections(1000) === 'number');
```
-`combinatoricSelections(1000)` should return 4626.
+`combinatoricSelections(1000)` dovrebbe restituire 4626.
```js
assert.strictEqual(combinatoricSelections(1000), 4626);
```
-`combinatoricSelections(10000)` should return 4431.
+`combinatoricSelections(10000)` dovrebbe restituire 4431.
```js
assert.strictEqual(combinatoricSelections(10000), 4431);
```
-`combinatoricSelections(100000)` should return 4255.
+`combinatoricSelections(100000)` dovrebbe restituire 4255.
```js
assert.strictEqual(combinatoricSelections(100000), 4255);
```
-`combinatoricSelections(1000000)` should return 4075.
+`combinatoricSelections(1000000)` dovrebbe restituire 4075.
```js
assert.strictEqual(combinatoricSelections(1000000), 4075);
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-54-poker-hands.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-54-poker-hands.md
index fd260cddf9..b07a2fe22e 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-54-poker-hands.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-54-poker-hands.md
@@ -1,6 +1,6 @@
---
id: 5900f3a21000cf542c50feb5
-title: 'Problem 54: Poker hands'
+title: 'Problema 54: mani di poker'
challengeType: 5
forumTopicId: 302165
dashedName: problem-54-poker-hands
@@ -8,54 +8,54 @@ dashedName: problem-54-poker-hands
# --description--
-In the card game poker, a hand consists of five cards and are ranked, from lowest to highest, in the following way:
+Nel gioco di carte del poker, una mano è composta da cinque carte ed esse sono classificate, dalla più bassa alla più alta, nel modo seguente:
-
-
- High Card: Highest value card. -
- One Pair: Two cards of the same value. -
- Two Pairs: Two different pairs. -
- Three of a Kind: Three cards of the same value. -
- Straight: All cards are consecutive values. -
- Flush: All cards of the same suit. -
- Full House: Three of a kind and a pair. -
- Four of a Kind: Four cards of the same value. -
- Straight Flush: All cards are consecutive values of same suit. -
- Royal Flush: Ten, Jack, Queen, King, Ace, in same suit. +
- Carta alta: Carta di valore più alto. +
- Una coppia: due carte dello stesso valore. +
- Due coppie: due coppie diverse. +
- Tre di un tipo: tre carte dello stesso valore. +
- Straight: tutte le carte hanno valori consecutivi. +
- Flush: Tutte le carte dello stesso seme. +
- Casa Completa: Tre di un tipo e una coppia. +
- Quattro di un tipo: Quattro carte dello stesso valore. +
- Scala: Tutte le carte sono valori consecutivi dello stesso seme. +
- Scala reale: Dieci, Jack, Regina, Re, Asso, nello stesso seme.
Pair of Fives | 2C 3S 8S 8D TD
Pair of Eights | Player 2 | -| 2 | 5D 8C 9S JS AC
Highest card Ace | 2C 5C 7D 8S QH
Highest card Queen | Player 1 | -| 3 | 2D 9C AS AH AC
Three Aces | 3D 6D 7D TD QD
Flush with Diamonds | Player 2 | -| 4 | 4D 6S 9H QH QC
Pair of Queens
Highest card Nine | 3D 6D 7H QD QS
Pair of Queens
Highest card Seven | Player 1 | -| 5 | 2H 2D 4C 4D 4S
Full House
with Three Fours | 3C 3D 3S 9S 9D
Full House
with Three Threes | Player 1 | +| Mano | Giocatore 1 | Giocatore 2 | Vincitore | +| ------------------------- | ------------------------------------------------------------------------- | -------------------------------------------------------------------------- | ----------- | +| 1 | 5H 5C 6S 7S KD
Coppia di cinque | 2C 3S 8S 8D TD
Coppia di otto | Giocatore 2 | +| 2 | 5D 8C 9S JS AC
Carta più alta Asso | 2C 5C 7D 8S QH
Carta più alta Regina | Giocatore 1 | +| 3 | 2D 9C AS AH AC
Tre assi | 3D 6D 7D TD QD
Full di quadri | Giocatore 2 | +| 4 | 4D 6S 9H QH QC
Coppia di Regine
Carta più alta Nove | 3D 6D 7H QD QS
Coppia di Regine
Carta più alta Sette | Giocatore 1 | +| 5 | 2H 2D 4C 4D 4S
Full
con tre Quattro | 3C 3D 3S 9S 9D
Full
con tre Tre | Giocatore 1 | -The global array (`handsArr`) passed to the function, contains one-thousand random hands dealt to two players. Each line of the file contains ten cards (separated by a single space): the first five are Player 1's cards and the last five are Player 2's cards. You can assume that all hands are valid (no invalid characters or repeated cards), each player's hand is in no specific order, and in each hand there is a clear winner. +L'array globale (`handsArr`) passato alla funzione, contiene mille mani casuali distribuite a due giocatori. Ogni riga del file contiene dieci carte (separate da uno spazio singolo): le prime cinque sono carte del giocatore 1 e le ultime cinque sono carte del giocatore 2. Si può presumere che tutte le mani siano valide (nessun carattere non valido o carte ripetute), la mano di ogni giocatore non è in ordine specifico, e in ogni mano c'è un chiaro vincitore. -How many hands does Player 1 win? +In quante mani vince Giocatore 1? # --hints-- -`pokerHands(testArr)` should return a number. +`pokerHands(testArr)` dovrebbe restituire un numero. ```js assert(typeof pokerHands(testArr) === 'number'); ``` -`pokerHands(testArr)` should return 2. +`pokerHands(testArr)` dovrebbe restituire 2. ```js assert.strictEqual(pokerHands(testArr), 2); ``` -`pokerHands(handsArr)` should return 376. +`pokerHands(handsArr)` dovrebbe restituire 376. ```js assert.strictEqual(pokerHands(handsArr), 376); diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-55-lychrel-numbers.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-55-lychrel-numbers.md index 8b074ba259..be4d82b170 100644 --- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-55-lychrel-numbers.md +++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-55-lychrel-numbers.md @@ -1,6 +1,6 @@ --- id: 5900f3a31000cf542c50feb6 -title: 'Problem 55: Lychrel numbers' +title: 'Problema 55: numeri di Lychrel' challengeType: 5 forumTopicId: 302166 dashedName: problem-55-lychrel-numbers @@ -8,9 +8,9 @@ dashedName: problem-55-lychrel-numbers # --description-- -If we take 47, reverse and add, 47 + 74 = 121, which is palindromic. +Se prendiamo 47, e gli sommiamo lo speculare, 47 + 74 = 121, che è palindromo. -Not all numbers produce palindromes so quickly. For example, +Non tutti i numeri producono palindromi così rapidamente. Ad esempio,
349 + 943 = 1292,
@@ -18,49 +18,49 @@ Not all numbers produce palindromes so quickly. For example, 4213 + 3124 = 7337
-That is, 349 took three iterations to arrive at a palindrome.
+Cioè 349 richiede tre iterazioni per arrivare a un palindromo.
-Although no one has proved it yet, it is thought that some numbers, like 196, never produce a palindrome. A number that never forms a palindrome through the reverse and add process is called a Lychrel number. Due to the theoretical nature of these numbers, and for the purpose of this problem, we shall assume that a number is Lychrel until proven otherwise. In addition you are given that for every number below ten-thousand, it will either (i) become a palindrome in less than fifty iterations, or, (ii) no one, with all the computing power that exists, has managed so far to map it to a palindrome. In fact, 10677 is the first number to be shown to require over fifty iterations before producing a palindrome: 4668731596684224866951378664 (53 iterations, 28-digits).
+Anche se nessuno lo ha ancora dimostrato, si pensa che alcuni numeri, come il 196, non producano mai un palindromo. Un numero che non forma mai un palindromo attraverso un processo di inversione e addizione è chiamato numero di Lychrel. Data la teoretica natura di questi numeri, e per il proposito di questo problema, assumiamo che un numero è un numeri di Lychrel fino a prova contraria. In aggiunta ti è dato che per ogni numero al di sotto di diecimila, questo (i) diventerà un palindromo in meno di cinquanta iterazioni, oppure, (ii), nessuno, con tutto il potere computazionale che esiste, è riuscito fin ora a mapparlo ad un palindromo. Infatti, 10677 è il primo numero trovato per cui sono necessarie più di cinquanta iterazioni prima di produrre un palindromo: 4668731596684224866951378664 (53 iterazioni, 28-cifre).
-Surprisingly, there are palindromic numbers that are themselves Lychrel numbers; the first example is 4994.
+Sorprendentemente, ci sono numeri palindromi che sono a loro volta numeri di Lychrel; il primo esempio è 4994.
-How many Lychrel numbers are there below `num`?
+Quanti numeri di Lychrel ci sono sotto `num`?
-**Note:** Wording was modified slightly on 24 April 2007 to emphasize the theoretical nature of Lychrel numbers.
+**Nota:** La descrizione è stata modificata leggermente il giorno 24 Aprile 2007 per enfatizzare la natura teoretica dei numeri di Lychrel.
# --hints--
-`countLychrelNumbers(1000)` should return a number.
+`countLychrelNumbers(1000)` dovrebbe restituire un numero.
```js
assert(typeof countLychrelNumbers(1000) === 'number');
```
-`countLychrelNumbers(1000)` should return 13.
+`countLychrelNumbers(1000)` dovrebbe restituire 13.
```js
assert.strictEqual(countLychrelNumbers(1000), 13);
```
-`countLychrelNumbers(3243)` should return 39.
+`countLychrelNumbers(3243)` dovrebbe restituire 39.
```js
assert.strictEqual(countLychrelNumbers(3243), 39);
```
-`countLychrelNumbers(5000)` should return 76.
+`countLychrelNumbers(5000)` dovrebbe restituire 76.
```js
assert.strictEqual(countLychrelNumbers(5000), 76);
```
-`countLychrelNumbers(7654)` should return 140.
+`countLychrelNumbers(7654)` dovrebbe restituire 140.
```js
assert.strictEqual(countLychrelNumbers(7654), 140);
```
-`countLychrelNumbers(10000)` should return 249.
+`countLychrelNumbers(10000)` dovrebbe restituire 249.
```js
assert.strictEqual(countLychrelNumbers(10000), 249);
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-56-powerful-digit-sum.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-56-powerful-digit-sum.md
index 407314741a..52d77c9180 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-56-powerful-digit-sum.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-56-powerful-digit-sum.md
@@ -1,6 +1,6 @@
---
id: 5900f3a41000cf542c50feb7
-title: 'Problem 56: Powerful digit sum'
+title: 'Problema 56: Somma delle cifre della potenza'
challengeType: 5
forumTopicId: 302167
dashedName: problem-56-powerful-digit-sum
@@ -8,43 +8,43 @@ dashedName: problem-56-powerful-digit-sum
# --description--
-A googol ($10^{100}$) is a massive number: one followed by one-hundred zeros; $100^{100}$ is almost unimaginably large: one followed by two-hundred zeros. Despite their size, the sum of the digits in each number is only 1.
+Un googol ($10^{100}$) è un numero massivo: uno seguito da cento zeri; $100^{100}$ è un numero inimmaginabilmente grande: uno seguito da duecento zeri. Nonostante la loro dimensione, la somma delle cifre in ogni numero è solo 1.
-Considering natural numbers of the form, $a^b$, where `a`, `b` < `n`, what is the maximum digital sum?
+Considerando numeri naturali nella forma, $a^b$, dove `a`, `b` < `n`, qual è la somma massima delle cifre?
# --hints--
-`powerfulDigitSum(3)` should return a number.
+`powerfulDigitSum(3)` dovrebbe restituire un numero.
```js
assert(typeof powerfulDigitSum(3) === 'number');
```
-`powerfulDigitSum(3)` should return `4`.
+`powerfulDigitSum(3)` dovrebbe restituire `4`.
```js
assert.strictEqual(powerfulDigitSum(3), 4);
```
-`powerfulDigitSum(10)` should return `45`.
+`powerfulDigitSum(10)` dovrebbe restituire `45`.
```js
assert.strictEqual(powerfulDigitSum(10), 45);
```
-`powerfulDigitSum(50)` should return `406`.
+`powerfulDigitSum(50)` dovrebbe restituire `406`.
```js
assert.strictEqual(powerfulDigitSum(50), 406);
```
-`powerfulDigitSum(75)` should return `684`.
+`powerfulDigitSum(75)` dovrebbe restituire `684`.
```js
assert.strictEqual(powerfulDigitSum(75), 684);
```
-`powerfulDigitSum(100)` should return `972`.
+`powerfulDigitSum(100)` dovrebbe restituire `972`.
```js
assert.strictEqual(powerfulDigitSum(100), 972);
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-57-square-root-convergents.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-57-square-root-convergents.md
index 17103bc6fe..a80b8b0363 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-57-square-root-convergents.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-57-square-root-convergents.md
@@ -1,6 +1,6 @@
---
id: 5900f3a51000cf542c50feb8
-title: 'Problem 57: Square root convergents'
+title: 'Problema 57: Radici quadrate convergenti'
challengeType: 5
forumTopicId: 302168
dashedName: problem-57-square-root-convergents
@@ -8,11 +8,11 @@ dashedName: problem-57-square-root-convergents
# --description--
-It is possible to show that the square root of two can be expressed as an infinite continued fraction.
+È possibile dimostrare che la radice quadrata di due può essere espressa come una frazione infinita continua.
@@ -18,49 +18,49 @@ Not all numbers produce palindromes so quickly. For example, 4213 + 3124 = 7337
$\sqrt 2 =1+ \frac 1 {2+ \frac 1 {2 +\frac 1 {2+ \dots}}}$
-By expanding this for the first four iterations, we get:
+Espandendola per le prime quattro iterazioni, otteniamo:
$1 + \\frac 1 2 = \\frac 32 = 1.5$
@@ -22,31 +22,31 @@ $1 + \\frac 1 {2 + \\frac 1 {2+\\frac 1 2}} = \\frac {17}{12} = 1.41666 \\dots$
$1 + \\frac 1 {2 + \\frac 1 {2+\\frac 1 {2+\\frac 1 2}}} = \\frac {41}{29} = 1.41379 \\dots$
-The next three expansions are $\\frac {99}{70}$, $\\frac {239}{169}$, and $\\frac {577}{408}$, but the eighth expansion, $\\frac {1393}{985}$, is the first example where the number of digits in the numerator exceeds the number of digits in the denominator.
+Le prossime tre espansioni sono $\\frac {99}{70}$, $\\frac {239}{169}$, e $\\frac {577}{408}$, ma l'ottava espansione, $\\frac {1393}{985}$, è il primo esempio in cui il numero di cifre nel numeratore supera il numero di cifre nel denominatore.
-In the first `n` expansions, how many fractions contain a numerator with more digits than denominator?
+Nelle prime espansioni `n`, quante frazioni contengono un numeratore con più cifre di denominatore?
# --hints--
-`squareRootConvergents(10)` should return a number.
+`squareRootConvergents(10)` dovrebbe restituire un numero.
```js
assert(typeof squareRootConvergents(10) === 'number');
```
-`squareRootConvergents(10)` should return 1.
+`squareRootConvergents(10)` dovrebbe restituire 1.
```js
assert.strictEqual(squareRootConvergents(10), 1);
```
-`squareRootConvergents(100)` should return 15.
+`squareRootConvergents(100)` dovrebbe restituire 15.
```js
assert.strictEqual(squareRootConvergents(100), 15);
```
-`squareRootConvergents(1000)` should return 153.
+`squareRootConvergents(1000)` dovrebbe restituire 153.
```js
assert.strictEqual(squareRootConvergents(1000), 153);
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-58-spiral-primes.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-58-spiral-primes.md
index 29a3012e44..8c70f55717 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-58-spiral-primes.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-58-spiral-primes.md
@@ -1,6 +1,6 @@
---
id: 5900f3a61000cf542c50feb9
-title: 'Problem 58: Spiral primes'
+title: 'Problema 58: Primi a spirale'
challengeType: 5
forumTopicId: 302169
dashedName: problem-58-spiral-primes
@@ -8,7 +8,7 @@ dashedName: problem-58-spiral-primes
# --description--
-Starting with 1 and spiralling anticlockwise in the following way, a square spiral with side length 7 is formed.
+Partendo da 1 e a spirale antioraria nel modo seguente, si forma una spirale quadrata con lunghezza laterale 7.
37 36 35 34 33 32 31
@@ -20,31 +20,31 @@ Starting with 1 and spiralling anticlockwise in the following way, a square spir 43 44 45 46 47 48 49
-It is interesting to note that the odd squares lie along the bottom right diagonal, but what is more interesting is that 8 out of the 13 numbers lying along both diagonals are prime; that is, a ratio of 8/13 ≈ 62%.
+È interessante notare che i quadrati dispari si trovano lungo la diagonale in basso a destra, ma ciò che è più interessante è che 8 dei 13 numeri che si trovano lungo entrambe le diagonali sono primi, cioè un rapporto di 8/13 ≈ 62%.
-If one complete new layer is wrapped around the spiral above, a square spiral with side length 9 will be formed. If this process is continued, what is the side length of the square spiral for which the percent of primes along both diagonals first falls below `percent`?
+Se un nuovo strato completo è avvolto intorno alla spirale sopra, verrà formata una spirale quadrata con lunghezza laterale 9. Se si prosegue con questo processo, qual è la lunghezza laterale della spirale quadrata per la quale la percentuale di primi lungo entrambe le diagonali cade prima al di sotto del `percent`?
# --hints--
-`spiralPrimes(50)` should return a number.
+`spiralPrimes(50)` dovrebbe restituire un numero.
```js
assert(typeof spiralPrimes(50) === 'number');
```
-`spiralPrimes(50)` should return `11`.
+`spiralPrimes(50)` dovrebbe restituire `11`.
```js
assert.strictEqual(spiralPrimes(50), 11);
```
-`spiralPrimes(15)` should return `981`.
+`spiralPrimes(15)` dovrebbe restituire `981`.
```js
assert.strictEqual(spiralPrimes(15), 981);
```
-`spiralPrimes(10)` should return `26241`.
+`spiralPrimes(10)` dovrebbe restituire `26241`.
```js
assert.strictEqual(spiralPrimes(10), 26241);
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-59-xor-decryption.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-59-xor-decryption.md
index 683db15249..5a50946032 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-59-xor-decryption.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-59-xor-decryption.md
@@ -1,6 +1,6 @@
---
id: 5900f3a81000cf542c50feba
-title: 'Problem 59: XOR decryption'
+title: 'Problema 59: decifrazione di XOR'
challengeType: 5
forumTopicId: 302170
dashedName: problem-59-xor-decryption
@@ -8,25 +8,25 @@ dashedName: problem-59-xor-decryption
# --description--
-Each character on a computer is assigned a unique code and the preferred standard is ASCII (American Standard Code for Information Interchange). For example, uppercase A = 65, asterisk (\*) = 42, and lowercase k = 107.
+Ogni carattere in un computer ha assegnato un unico codice e lo standard preferito è ASCII (American Standard Code for Information Interchange - Codice standard americano per l'interscambio delle informazioni). Per esempio, A maiuscola = 65, asterisco (\*) = 42, e k minuscola = 107.
-A modern encryption method is to take a text file, convert the bytes to ASCII, then XOR each byte with a given value, taken from a secret key. The advantage with the XOR function is that using the same encryption key on the cipher text, restores the plain text; for example, 65 XOR 42 = 107, then 107 XOR 42 = 65.
+Un metodo moderno di codifica è di prendere un file di testo, convertire i byte in ASCII, e poi usare l'operatore XOR su ogni byte con un valore dato, preso da una chiave segreta. Il vantaggio della funzione XOR è che usare la stessa chiave di codifica sul testo cifrato, rigenera il testo iniziare; per esempio, 65 XOR 42 = 107, e 107 XOR 42 = 65.
-For unbreakable encryption, the key is the same length as the plain text message, and the key is made up of random bytes. The user would keep the encrypted message and the encryption key in different locations, and without both "halves", it is impossible to decrypt the message.
+Per una codifica non decodificabile, la chiave è della stessa lunghezza del messaggio e la chiave è fatta di byte random. L'utente deve tenere il messaggio cifrato e la chiave di codifica in due posti diversi, e senza le due "metà", è impossibile decifrare il messaggio.
-Unfortunately, this method is impractical for most users, so the modified method is to use a password as a key. If the password is shorter than the message, which is likely, the key is repeated cyclically throughout the message. The balance for this method is using a sufficiently long password key for security, but short enough to be memorable.
+Sfortunatamente, questo metodo non è pratico per la maggior parte degli utenti, quindi il metodo modificato è di usare una password come chiave. Se la password è più corta del messaggio, cosa che è probabile, allora la chiave è ripetuta ciclicamente lungo il messaggio. L'equilibrio per questo metodo è usare una password sufficientemente lunga per questioni di sicurezza, ma abbastanza corta da essere memorizzabile.
-Your task has been made easy, as the encryption key consists of three lower case characters. Using `cipher`, an array containing the encrypted ASCII codes, and the knowledge that the plain text must contain common English words, decrypt the message and find the sum of the ASCII values in the original text.
+Il tuo compito è stato reso facile, la chiave di sicurezza consiste di tre lettere minuscole. Usando `cipher`, un array contenente i codici ASCII cifrati, e la conoscenza che il messaggio deve contenere parole comuni inglesi, decifra il messaggio e fai la somma dei valori ASCII del messaggio originale.
# --hints--
-`XORDecryption(cipher)` should return a number.
+`XORDecryption(cipher)` dovrebbe restituire un numero.
```js
assert(typeof XORDecryption(cipher) === 'number');
```
-`XORDecryption(cipher)` should return 129448.
+`XORDecryption(cipher)` dovrebbe restituire 129448.
```js
assert.strictEqual(XORDecryption(cipher), 129448);
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-6-sum-square-difference.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-6-sum-square-difference.md
index ec60601f10..aa4c7405d4 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-6-sum-square-difference.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-6-sum-square-difference.md
@@ -1,6 +1,6 @@
---
id: 5900f3721000cf542c50fe85
-title: 'Problem 6: Sum square difference'
+title: 'Problema 6: Somma differenza quadrata'
challengeType: 5
forumTopicId: 302171
dashedName: problem-6-sum-square-difference
@@ -8,39 +8,39 @@ dashedName: problem-6-sum-square-difference
# --description--
-The sum of the squares of the first ten natural numbers is,
+La somma dei quadrati dei primi dieci numeri naturali è,
@@ -20,31 +20,31 @@ Starting with 1 and spiralling anticlockwise in the following way, a square spir 43 44 45 46 47 48 49
12 + 22 + ... + 102 = 385
-The square of the sum of the first ten natural numbers is,
+Il quadrato della somma dei primi dieci numeri naturali è
(1 + 2 + ... + 10)2 = 552 = 3025
-Hence the difference between the sum of the squares of the first ten natural numbers and the square of the sum is 3025 − 385 = 2640.
+Da qui la differenza tra la somma dei quadrati dei primi dieci numeri naturali e il quadrato della somma è 3025 − 385 = 2640.
-Find the difference between the sum of the squares of the first `n` natural numbers and the square of the sum.
+Trova la differenza tra la somma dei quadrati dei primi `n` numeri naturali e il quadrato della loro somma.
# --hints--
-`sumSquareDifference(10)` should return a number.
+`sumSquareDifference(10)` dovrebbe restituire un numero.
```js
assert(typeof sumSquareDifference(10) === 'number');
```
-`sumSquareDifference(10)` should return 2640.
+`sumSquareDifference(10)` dovrebbe restituire 2640.
```js
assert.strictEqual(sumSquareDifference(10), 2640);
```
-`sumSquareDifference(20)` should return 41230.
+`sumSquareDifference(20)` dovrebbe restituire 41230.
```js
assert.strictEqual(sumSquareDifference(20), 41230);
```
-`sumSquareDifference(100)` should return 25164150.
+`sumSquareDifference(100)` dovrebbe restituire 25164150.
```js
assert.strictEqual(sumSquareDifference(100), 25164150);
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-60-prime-pair-sets.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-60-prime-pair-sets.md
index 5acc6c2176..83fc1fc6af 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-60-prime-pair-sets.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-60-prime-pair-sets.md
@@ -1,6 +1,6 @@
---
id: 5900f3a81000cf542c50febb
-title: 'Problem 60: Prime pair sets'
+title: 'Problema 60: set di coppie di numeri primi'
challengeType: 5
forumTopicId: 302172
dashedName: problem-60-prime-pair-sets
@@ -8,19 +8,19 @@ dashedName: problem-60-prime-pair-sets
# --description--
-The primes 3, 7, 109, and 673, are quite remarkable. By taking any two primes and concatenating them in any order the result will always be prime. For example, taking 7 and 109, both 7109 and 1097 are prime. The sum of these four primes, 792, represents the lowest sum for a set of four primes with this property.
+I primi 3, 7, 109, e 673 sono degni di nota. Prendendo qualsiasi due di questi numeri e concatenandoli in qualsiasi ordine, il risultato sarà sempre un numero primo. Per esempio, prendendo 7 e 109, sia 7109 che 1097 sono primi. La somma di questi quattro numeri primi, 792, rappresenta la somma più piccola per un set di 4 numeri primi con questa proprietà.
-Find the lowest sum for a set of five primes for which any two primes concatenate to produce another prime.
+Trova la somma più piccola per un set di cinque numeri primi in cui due numeri qualsiasi concatenati producono un altri numero primo.
# --hints--
-`primePairSets()` should return a number.
+`primePairSets()` dovrebbe restituire un numero.
```js
assert(typeof primePairSets() === 'number');
```
-`primePairSets()` should return 26033.
+`primePairSets()` dovrebbe restituire 26033.
```js
assert.strictEqual(primePairSets(), 26033);
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-61-cyclical-figurate-numbers.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-61-cyclical-figurate-numbers.md
index 8989f4171c..2ff5ab0689 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-61-cyclical-figurate-numbers.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-61-cyclical-figurate-numbers.md
@@ -1,6 +1,6 @@
---
id: 5900f3a91000cf542c50febc
-title: 'Problem 61: Cyclical figurate numbers'
+title: 'Problema 61: Numeri ciclici figurati'
challengeType: 5
forumTopicId: 302173
dashedName: problem-61-cyclical-figurate-numbers
@@ -8,52 +8,52 @@ dashedName: problem-61-cyclical-figurate-numbers
# --description--
-Triangle, square, pentagonal, hexagonal, heptagonal, and octagonal numbers are all figurate (polygonal) numbers and are generated by the following formulae:
+Numeri triangolari, quadrati, pentagonali, esagonali, eptagonali e ottagonali sono tutti numeri che sono figurati (poligonali) e sono generati dalle seguenti formule:
-| Type of Number | Formula | Sequence |
+| Tipo di numero | Formula | Sequenza |
| -------------- | ----------------------------- | --------------------- |
-| Triangle | $P_3(n) = \frac{n(n+1)}{2}$ | 1, 3, 6, 10, 15, ... |
-| Square | $P_4(n) = n^2$ | 1, 4, 9, 16, 25, ... |
-| Pentagonal | $P_5(n) = \frac{n(3n−1)}2$ | 1, 5, 12, 22, 35, ... |
-| Hexagonal | $P_6(n) = n(2n−1)$ | 1, 6, 15, 28, 45, ... |
-| Heptagonal | $P_7(n) = \frac{n(5n−3)}{2}$ | 1, 7, 18, 34, 55, ... |
-| Octagonal | $P_8(n) = n(3n−2)$ | 1, 8, 21, 40, 65, ... |
+| Triangolare | $P_3(n) = \frac{n(n+1)}{2}$ | 1, 3, 6, 10, 15, ... |
+| Quadrato | $P_4(n) = n^2$ | 1, 4, 9, 16, 25, ... |
+| Pentagonale | $P_5(n) = \frac{n(3n−1)}2$ | 1, 5, 12, 22, 35, ... |
+| Esagonale | $P_6(n) = n(2n−1)$ | 1, 6, 15, 28, 45, ... |
+| Eptagonale | $P_7(n) = \frac{n(5n−3)}{2}$ | 1, 7, 18, 34, 55, ... |
+| Ottagonale | $P_8(n) = n(3n−2)$ | 1, 8, 21, 40, 65, ... |
-The ordered set of three 4-digit numbers: 8128, 2882, 8281, has three interesting properties.
+Il set ordinato nei numeri a 4 cifre: 8128, 2882, 8281, ha tre interessanti proprietà.
-1. The set is cyclic, in that the last two digits of each number is the first two digits of the next number (including the last number with the first).
-2. Each polygonal type: triangle ($P_3(127) = 8128$), square ($P_4(91) = 8281$), and pentagonal ($P_5(44) = 2882$), is represented by a different number in the set.
-3. This is the only set of 4-digit numbers with this property.
+1. Il set è ciclico, in quanto le ultime due cifre di ogni numero sono le prime due cifre del seguente (incluso l'ultimo numero con il primo).
+2. Ogni tipo poligonale: triangolare ($P_3(127) = 8128$), quadrato ($P_4(91) = 8281$), e pentagonale ($P_5(44) = 2882$), è rappresentato da un diverso numero nel set.
+3. Questo è l'unico set con numeri a quattro cifre con questa proprietà.
-Find the sum of all numbers in ordered sets of `n` cyclic 4-digit numbers for which each of the $P_3$ to $P_{n + 2}$ polygonal types, is represented by a different number in the set.
+Trova la somma di tutti i numeri in set ordinati di `n` numeri ciclici a quattro cifre per cui ognuno dei tipi poligonali da $P_3$ a $P_{n + 2}$ è rappresentato da un diverso numero nel set.
# --hints--
-`cyclicalFigurateNums(3)` should return a number.
+`cyclicalFigurateNums(3)` dovrebbe restituire un numero.
```js
assert(typeof cyclicalFigurateNums(3) === 'number');
```
-`cyclicalFigurateNums(3)` should return `19291`.
+`cyclicalFigurateNums(3)` dovrebbe restituire `19291`.
```js
assert.strictEqual(cyclicalFigurateNums(3), 19291);
```
-`cyclicalFigurateNums(4)` should return `28684`.
+`cyclicalFigurateNums(4)` dovrebbe restituire `28684`.
```js
assert.strictEqual(cyclicalFigurateNums(4), 28684);
```
-`cyclicalFigurateNums(5)` should return `76255`.
+`cyclicalFigurateNums(5)` dovrebbe restituire `76255`.
```js
assert.strictEqual(cyclicalFigurateNums(5), 76255);
```
-`cyclicalFigurateNums(6)` should return `28684`.
+`cyclicalFigurateNums(6)` dovrebbe restituire `28684`.
```js
assert.strictEqual(cyclicalFigurateNums(6), 28684);
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-62-cubic-permutations.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-62-cubic-permutations.md
index 82294e0708..2922ea3df7 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-62-cubic-permutations.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-62-cubic-permutations.md
@@ -1,6 +1,6 @@
---
id: 5900f3aa1000cf542c50febd
-title: 'Problem 62: Cubic permutations'
+title: 'Problema 62: permutazioni cubiche'
challengeType: 5
forumTopicId: 302174
dashedName: problem-62-cubic-permutations
@@ -8,37 +8,37 @@ dashedName: problem-62-cubic-permutations
# --description--
-The cube, 41063625 ($345^3$), can be permuted to produce two other cubes: 56623104 ($384^3$) and 66430125 ($405^3$). In fact, 41063625 is the smallest cube which has exactly three permutations of its digits which are also cube.
+Il cubo 41063625 ($345^3$), può essere permutato per produrre altri due cubi: 56623104 ($384^3$) e 66430125 ($405^3$). Infatti, 41063625 è il cubo più piccolo che ha esattamente tre permutazioni delle sue cifre che sono anch'esse dei cubi.
-Find the smallest cube for which exactly `n` permutations of its digits are cube.
+Trova il cubo più piccolo per il quale esattamente `n` permutazioni delle sue cifre sono dei cubi.
# --hints--
-`cubicPermutations(2)` should return a number.
+`cubicPermutations(2)` dovrebbe restituire un numero.
```js
assert(typeof cubicPermutations(2) === 'number');
```
-`cubicPermutations(2)` should return `125`.
+`cubicPermutations(2)` dovrebbe restituire `125`.
```js
assert.strictEqual(cubicPermutations(2), 125);
```
-`cubicPermutations(3)` should return `41063625`.
+`cubicPermutations(3)` dovrebbe restituire `41063625`.
```js
assert.strictEqual(cubicPermutations(3), 41063625);
```
-`cubicPermutations(4)` should return `1006012008`.
+`cubicPermutations(4)` dovrebbe restituire `1006012008`.
```js
assert.strictEqual(cubicPermutations(4), 1006012008);
```
-`cubicPermutations(5)` should return `127035954683`.
+`cubicPermutations(5)` dovrebbe restituire `127035954683`.
```js
assert.strictEqual(cubicPermutations(5), 127035954683);
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-63-powerful-digit-counts.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-63-powerful-digit-counts.md
index 02c9603685..d0eac54543 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-63-powerful-digit-counts.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-63-powerful-digit-counts.md
@@ -1,6 +1,6 @@
---
id: 5900f3ab1000cf542c50febe
-title: 'Problem 63: Powerful digit counts'
+title: 'Problema 63: Conteggio cifre potenti'
challengeType: 5
forumTopicId: 302175
dashedName: problem-63-powerful-digit-counts
@@ -8,73 +8,73 @@ dashedName: problem-63-powerful-digit-counts
# --description--
-The 5-digit number, 16807 = 75, is also a fifth power. Similarly, the 9-digit number, 134217728 = 89, is a ninth power.
+Il numero a 5 cifre, 16807 = 75, è anche una quinta potenza. Analogamente, il numero a 9 cifre, 134217728 = 89, è una nona potenza.
-Complete the function so that it returns how many positive integers are of length `n` and an `n`th power.
+Completa la funzione in modo che restituisca quanti interi positivi siano di lunghezza `n` e `n`ma potenza.
# --hints--
-`powerfulDigitCounts(1)` should return a number.
+`powerfulDigitCounts(1)` dovrebbe restituire un numero.
```js
assert(typeof powerfulDigitCounts(1) === 'number');
```
-`powerfulDigitCounts(1)` should return `9`.
+`powerfulDigitCounts(1)` dovrebbe restituire `9`.
```js
assert.strictEqual(powerfulDigitCounts(1), 9);
```
-`powerfulDigitCounts(2)` should return `6`.
+`powerfulDigitCounts(2)` dovrebbe restituire `6`.
```js
assert.strictEqual(powerfulDigitCounts(2), 6);
```
-`powerfulDigitCounts(3)` should return `5`.
+`powerfulDigitCounts(3)` dovrebbe restituire `5`.
```js
assert.strictEqual(powerfulDigitCounts(3), 5);
```
-`powerfulDigitCounts(4)` should return `4`.
+`powerfulDigitCounts(4)` dovrebbe restituire `4`.
```js
assert.strictEqual(powerfulDigitCounts(4), 4);
```
-`powerfulDigitCounts(5)` should return `3`.
+`powerfulDigitCounts(5)` dovrebbe restituire `3`.
```js
assert.strictEqual(powerfulDigitCounts(5), 3);
```
-`powerfulDigitCounts(6)` should return `3`.
+`powerfulDigitCounts(6)` dovrebbe restituire `3`.
```js
assert.strictEqual(powerfulDigitCounts(6), 3);
```
-`powerfulDigitCounts(7)` should return `2`.
+`powerfulDigitCounts(7)` dovrebbe restituire `2`.
```js
assert.strictEqual(powerfulDigitCounts(7), 2);
```
-`powerfulDigitCounts(8)` should return `2`.
+`powerfulDigitCounts(8)` dovrebbe restituire `2`.
```js
assert.strictEqual(powerfulDigitCounts(8), 2);
```
-`powerfulDigitCounts(10)` should return `2`.
+`powerfulDigitCounts(10)` dovrebbe restituire `2`.
```js
assert.strictEqual(powerfulDigitCounts(10), 2);
```
-`powerfulDigitCounts(21)` should return `1`.
+`powerfulDigitCounts(21)` dovrebbe restituire `1`.
```js
assert.strictEqual(powerfulDigitCounts(21), 1);
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-7-10001st-prime.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-7-10001st-prime.md
index 18b18b2bf1..a549bd1278 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-7-10001st-prime.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-7-10001st-prime.md
@@ -1,6 +1,6 @@
---
id: 5900f3731000cf542c50fe86
-title: 'Problem 7: 10001st prime'
+title: 'Problema 7: 10001esimo primo'
challengeType: 5
forumTopicId: 302182
dashedName: problem-7-10001st-prime
@@ -8,43 +8,43 @@ dashedName: problem-7-10001st-prime
# --description--
-By listing the first six prime numbers: 2, 3, 5, 7, 11, and 13, we can see that the 6th prime is 13.
+Elencando i primi sei numeri principali: 2, 3, 5, 7, 11 e 13, possiamo vedere che il sesto primo è 13.
-What is the `n`th prime number?
+Qual è il `n`-simo numero primo?
# --hints--
-`nthPrime(6)` should return a number.
+`nthPrime(6)` dovrebbe restituire un numero.
```js
assert(typeof nthPrime(6) === 'number');
```
-`nthPrime(6)` should return 13.
+`nthPrime(6)` dovrebbe restituire 13.
```js
assert.strictEqual(nthPrime(6), 13);
```
-`nthPrime(10)` should return 29.
+`nthPrime(10)` dovrebbe restituire 29.
```js
assert.strictEqual(nthPrime(10), 29);
```
-`nthPrime(100)` should return 541.
+`nthPrime(100)` dovrebbe restituire 541.
```js
assert.strictEqual(nthPrime(100), 541);
```
-`nthPrime(1000)` should return 7919.
+`nthPrime(1000)` dovrebbe restituire 7919.
```js
assert.strictEqual(nthPrime(1000), 7919);
```
-`nthPrime(10001)` should return 104743.
+`nthPrime(10001)` dovrebbe restituire 104743.
```js
assert.strictEqual(nthPrime(10001), 104743);
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-8-largest-product-in-a-series.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-8-largest-product-in-a-series.md
index 0fd4703af7..f8aaa540a6 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-8-largest-product-in-a-series.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-8-largest-product-in-a-series.md
@@ -1,6 +1,6 @@
---
id: 5900f3741000cf542c50fe87
-title: 'Problem 8: Largest product in a series'
+title: 'Problema 8: Prodotto più grande in una serie'
challengeType: 5
forumTopicId: 302193
dashedName: problem-8-largest-product-in-a-series
@@ -8,7 +8,7 @@ dashedName: problem-8-largest-product-in-a-series
# --description--
-The four adjacent digits in the 1000-digit number that have the greatest product are 9 × 9 × 8 × 9 = 5832.
+Le quattro cifre adiacenti del numero a 1000 cifre che hanno il prodotto più grande sono 9 × 9 × 8 × 9 = 5832.
73167176531330624919225119674426574742355349194934
96983520312774506326239578318016984801869478851843
@@ -31,23 +31,23 @@ The four adjacent digits in the 1000-digit number that have the greatest product
05886116467109405077541002256983155200055935729725
71636269561882670428252483600823257530420752963450
-Find the `n` adjacent digits in the 1000-digit number that have the greatest product. What is the value of this product?
+Trova le `n` cifre adiacenti nel numero a 1000 cifre che hanno il prodotto più grande. Qual è il valore di questo prodotto?
# --hints--
-`largestProductinaSeries(4)` should return a number.
+`largestProductinaSeries(4)` dovrebbe restituire un numero.
```js
assert(typeof largestProductinaSeries(4) === 'number');
```
-`largestProductinaSeries(4)` should return 5832.
+`largestProductinaSeries(4)` dovrebbe restituire 5832.
```js
assert.strictEqual(largestProductinaSeries(4), 5832);
```
-`largestProductinaSeries(13)` should return 23514624000.
+`largestProductinaSeries(13)` dovrebbe restituire 23514624000.
```js
assert.strictEqual(largestProductinaSeries(13), 23514624000);
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-9-special-pythagorean-triplet.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-9-special-pythagorean-triplet.md
index 3ce9715e40..a3e30250eb 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-9-special-pythagorean-triplet.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-9-special-pythagorean-triplet.md
@@ -1,6 +1,6 @@
---
id: 5900f3761000cf542c50fe88
-title: 'Problem 9: Special Pythagorean triplet'
+title: 'Problema 9: Tripletta Pitagorica Speciale'
challengeType: 5
forumTopicId: 302205
dashedName: problem-9-special-pythagorean-triplet
@@ -8,35 +8,35 @@ dashedName: problem-9-special-pythagorean-triplet
# --description--
-A Pythagorean triplet is a set of three natural numbers, `a` < `b` < `c`, for which,
+Una tripletta pitagorica è una serie di tre numeri naturali, `a` < `b` < `c` tali per cui
a2 + b2 = c2
-For example, 32 + 42 = 9 + 16 = 25 = 52.
+Ad esempio, 32 + 42 = 9 + 16 = 25 = 52.
-There exists exactly one Pythagorean triplet for which `a` + `b` + `c` = 1000. Find the product `abc` such that `a` + `b` + `c` = `n`.
+Esiste esattamente una tripletta pitagorica per la quale `a` + `b` + `c` = 1000. Trova il prodotto `abc` tale che `a` + `b` + `c` = `n`.
# --hints--
-`specialPythagoreanTriplet(24)` should return a number.
+`specialPythagoreanTriplet(24)` dovrebbe restituire un numero.
```js
assert(typeof specialPythagoreanTriplet(24) === 'number');
```
-`specialPythagoreanTriplet(24)` should return 480.
+`specialPythagoreanTriplet(24)` dovrebbe restituire 480.
```js
assert.strictEqual(specialPythagoreanTriplet(24), 480);
```
-`specialPythagoreanTriplet(120)` should return 49920, 55080 or 60000
+`specialPythagoreanTriplet(120)` dovrebbe restituire 49920, 55080 o 60000
```js
assert([49920, 55080, 60000].includes(specialPythagoreanTriplet(120)));
```
-`specialPythagoreanTriplet(1000)` should return 31875000.
+`specialPythagoreanTriplet(1000)` dovrebbe restituire 31875000.
```js
assert.strictEqual(specialPythagoreanTriplet(1000), 31875000);
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/letter-frequency.md b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/letter-frequency.md
index d7c0a30349..ccf7381024 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/letter-frequency.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/letter-frequency.md
@@ -1,6 +1,6 @@
---
id: 5e4ce2bbac708cc68c1df25f
-title: Letter frequency
+title: Frequenza delle lettere
challengeType: 5
forumTopicId: 385263
dashedName: letter-frequency
@@ -8,33 +8,33 @@ dashedName: letter-frequency
# --description--
-Given a string, calculate the frequency of each character.
+Data una stringa, calcolare la frequenza di ogni carattere.
-All characters should be counted. This includes lower and upper case letters, digits, whitespace, special characters, or any other distinct characters.
+Tutti i caratteri devono essere contati. Questo include lettere maiuscole e minuscole, cifre, spazi bianchi, caratteri speciali o qualsiasi altro carattere distinto.
# --instructions--
-Write a function to count the occurrences of each character in a given string.
+Scrivi una funzione per contare le occorrenze di ogni carattere in una determinata stringa.
-The function should return a 2D array with each of the elements in the following form: `['char', freq]`. The character should be a string with a length of 1, and frequency is a number denoting the count.
+La funzione dovrebbe restituire un array 2D con ciascuno degli elementi nella seguente forma: `['char', freq]`. Il carattere deve essere una stringa con una lunghezza di 1, e la frequenza è un numero che indica il conteggio.
-For example, given the string "ab", your function should return `[['a', 1], ['b', 1]]`.
+Per esempio, data la stringa "ab", la tua funzione dovrebbe restituire `[['a', 1], ['b', 1]]`.
# --hints--
-`letterFrequency` should be a function.
+`letterFrequency` dovrebbe essere una funzione.
```js
assert(typeof letterFrequency == 'function');
```
-`letterFrequency("Not all that Mrs. Bennet, however")` should return an array.
+`letterFrequency("Not all that Mrs. Bennet, however")` dovrebbe restituire un array.
```js
assert(Array.isArray(letterFrequency('Not all that Mrs. Bennet, however')));
```
-`letterFrequency("Not all that Mrs. Bennet, however")` should return `[[" ", 5], [",", 1], [".", 1], ["B", 1], ["M", 1], ["N", 1], ["a", 2], ["e", 4], ["h", 2], ["l", 2], ["n", 2], ["o", 2], ["r", 2], ["s", 1], ["t", 4], ["v", 1], ["w", 1]]`.
+`letterFrequency("Not all that Mrs. Bennet, however")` dovrebbe restituire `[[" ", 5], [",", 1], [".", 1], ["B", 1], ["M", 1], ["N", 1], ["a", 2], ["e", 4], ["h", 2], ["l", 2], ["n", 2], ["o", 2], ["r", 2], ["s", 1], ["t", 4], ["v", 1], ["w", 1]]`.
```js
assert.deepEqual(letterFrequency('Not all that Mrs. Bennet, however'), [
@@ -58,7 +58,7 @@ assert.deepEqual(letterFrequency('Not all that Mrs. Bennet, however'), [
]);
```
-`letterFrequency("daughters, could ask on the ")` should return `[[" ", 5],[",", 1],["a", 2],["c", 1],["d", 2],["e", 2],["g", 1],["h", 2],["k", 1],["l", 1],["n", 1],["o", 2],["r", 1],["s", 2],["t", 2],["u", 2]]`.
+`letterFrequency("daughters, could ask on the ")` dovrebbe restituire `[[" ", 5],[",", 1],["a", 2],["c", 1],["d", 2],["e", 2],["g", 1],["h", 2],["k", 1],["l", 1],["n", 1],["o", 2],["r", 1],["s", 2],["t", 2],["u", 2]]`.
```js
assert.deepEqual(letterFrequency('daughters, could ask on the '), [
@@ -81,7 +81,7 @@ assert.deepEqual(letterFrequency('daughters, could ask on the '), [
]);
```
-`letterFrequency("husband any satisfactory description")` should return `[[" ", 3], ["a", 4], ["b", 1], ["c", 2], ["d", 2], ["e", 1], ["f", 1], ["h", 1], ["i", 3], ["n", 3], ["o", 2], ["p", 1], ["r", 2], ["s", 4], ["t", 3], ["u", 1], ["y", 2]]`.
+`letterFrequency("husband any satisfactory description")` dovrebbe restituire `[[" ", 3], ["a", 4], ["b", 1], ["c", 2], ["d", 2], ["e", 1], ["f", 1], ["h", 1], ["i", 3], ["n", 3], ["o", 2], ["p", 1], ["r", 2], ["s", 4], ["t", 3], ["u", 1], ["y", 2]]`.
```js
assert.deepEqual(letterFrequency('husband any satisfactory description'), [
@@ -105,7 +105,7 @@ assert.deepEqual(letterFrequency('husband any satisfactory description'), [
]);
```
-`letterFrequency("in various ways--with barefaced")` should return `[[" ", 3], ["-", 2], ["a", 4], ["b", 1], ["c", 1], ["d", 1], ["e", 2], ["f", 1], ["h", 1], ["i", 3], ["n", 1], ["o", 1], ["r", 2], ["s", 2], ["t", 1], ["u", 1], ["v", 1], ["w", 2], ["y", 1]]`.
+`letterFrequency("in various ways--with barefaced")` dovrebbe restituire `[[" ", 3], ["-", 2], ["a", 4], ["b", 1], ["c", 1], ["d", 1], ["e", 2], ["f", 1], ["h", 1], ["i", 3], ["n", 1], ["o", 1], ["r", 2], ["s", 2], ["t", 1], ["u", 1], ["v", 1], ["w", 2], ["y", 1]]`.
```js
assert.deepEqual(letterFrequency('in various ways--with barefaced'), [
@@ -131,7 +131,7 @@ assert.deepEqual(letterFrequency('in various ways--with barefaced'), [
]);
```
-`letterFrequency("distant surmises; but he eluded")` should return `[[" ", 4], [";", 1], ["a", 1], ["b", 1], ["d", 3], ["e", 4], ["h", 1], ["i", 2], ["l", 1], ["m", 1], ["n", 1], ["r", 1], ["s", 4], ["t", 3], ["u", 3]]`.
+`letterFrequency("distant surmises; but he eluded")` dovrebbe restituire `[[" ", 4], [";", 1], ["a", 1], ["b", 1], ["d", 3], ["e", 4], ["h", 1], ["i", 2], ["l", 1], ["m", 1], ["n", 1], ["r", 1], ["s", 4], ["t", 3], ["u", 3]]`.
```js
assert.deepEqual(letterFrequency('distant surmises; but he eluded'), [
@@ -153,7 +153,7 @@ assert.deepEqual(letterFrequency('distant surmises; but he eluded'), [
]);
```
-`letterFrequency("last obliged to accept the second-hand,")` should return `[[" ", 5], [",", 1], ["-", 1], ["a", 3], ["b", 1], ["c", 3], ["d", 3], ["e", 4], ["g", 1], ["h", 2], ["i", 1], ["l", 2], ["n", 2], ["o", 3], ["p", 1], ["s", 2], ["t", 4]]`.
+`letterFrequency("last obliged to accept the second-hand,")` dovrebbe restituire `[[" ", 5], [",", 1], ["-", 1], ["a", 3], ["b", 1], ["c", 3], ["d", 3], ["e", 4], ["g", 1], ["h", 2], ["i", 1], ["l", 2], ["n", 2], ["o", 3], ["p", 1], ["s", 2], ["t", 4]]`.
```js
assert.deepEqual(letterFrequency('last obliged to accept the second-hand,'), [
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/longest-common-subsequence.md b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/longest-common-subsequence.md
index b027a10f5e..b86ef91fd5 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/longest-common-subsequence.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/longest-common-subsequence.md
@@ -1,6 +1,6 @@
---
id: 5e6dd1278e6ca105cde40ea9
-title: Longest common subsequence
+title: Più lunga successione comune
challengeType: 5
forumTopicId: 385271
dashedName: longest-common-subsequence
@@ -8,65 +8,65 @@ dashedName: longest-common-subsequence
# --description--
-The **longest common subsequence** (or [**LCS**](http://en.wikipedia.org/wiki/Longest_common_subsequence_problem)) of groups A and B is the longest group of elements from A and B that are common between the two groups and in the same order in each group. For example, the sequences "1234" and "1224533324" have an LCS of "1234":
+La **sottosequenza comune più lunga** (o [**LCS**](http://en.wikipedia.org/wiki/Longest_common_subsequence_problem)) dei gruppi A e B è il gruppo più lungo di elementi provenienti da A e B che sono comuni tra i due gruppi e nello stesso ordine in ogni gruppo. Per esempio, le sequenze "1234" e "1224533324" hanno un LCS di "1234":
***1234***
***12***245***3***332***4***
-For a string example, consider the sequences "thisisatest" and "testing123testing". An LCS would be "tsitest":
+Per un esempio di stringa, considera le sequenze "thisisatest" e "testing123testing". Un LCS sarebbe "tsitest":
***t***hi***si***sa***test***
***t***e***s***t***i***ng123***test***ing.
-Your code only needs to deal with strings.
+Il tuo codice deve riguardare solo le stringhe.
-For more information on this problem please see [Wikipedia](https://en.wikipedia.org/wiki/Longest_common_subsequence_problem).
+Per ulteriori informazioni su questo problema consulta [Wikipedia](https://en.wikipedia.org/wiki/Longest_common_subsequence_problem).
# --instructions--
-Write a case-sensitive function that returns the LCS of two strings. You don't need to show multiple LCS's.
+Scrivi una funzione sensibile alle maiuscole/minuscole che restituisce l'LCS di due stringhe. Non è necessario mostrare più LCS.
# --hints--
-`lcs` should be a function.
+`lcs` dovrebbe essere una funzione.
```js
assert(typeof lcs == 'function');
```
-`lcs("thisisatest", "testing123testing")` should return a string.
+`lcs("thisisatest", "testing123testing")` dovrebbe restituire una stringa.
```js
assert(typeof lcs('thisisatest', 'testing123testing') == 'string');
```
-`lcs("thisisatest", "testing123testing")` should return `"tsitest"`.
+`lcs("thisisatest", "testing123testing")` dovrebbe restituire `"tsitest"`.
```js
assert.equal(lcs('thisisatest', 'testing123testing'), 'tsitest');
```
-`lcs("ABCDGH", "AEDFHR")` should return `"ADH"`.
+`lcs("ABCDGH", "AEDFHR")` dovrebbe restituire `"ADH"`.
```js
assert.equal(lcs('ABCDGH', 'AEDFHR'), 'ADH');
```
-`lcs("AGGTAB", "GXTXAYB")` should return `"GTAB"`.
+`lcs("AGGTAB", "GXTXAYB")` dovrebbe restituire `"GTAB"`.
```js
assert.equal(lcs('AGGTAB', 'GXTXAYB'), 'GTAB');
```
-`lcs("BDACDB", "BDCB")` should return `"BDCB"`.
+`lcs("BDACDB", "BDCB")` dovrebbe restituire `"BDCB"`.
```js
assert.equal(lcs('BDACDB', 'BDCB'), 'BDCB');
```
-`lcs("ABAZDC", "BACBAD")` should return `"ABAD"`.
+`lcs("ABAZDC", "BACBAD")` dovrebbe restituire `"ABAD"`.
```js
assert.equal(lcs('ABAZDC', 'BACBAD'), 'ABAD');
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/longest-increasing-subsequence.md b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/longest-increasing-subsequence.md
index 0ba5661f6c..b692ed2fdd 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/longest-increasing-subsequence.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/longest-increasing-subsequence.md
@@ -1,6 +1,6 @@
---
id: 5e6dd139859c290b6ab80292
-title: Longest increasing subsequence
+title: Più lunga sottosequenza crescente
challengeType: 5
forumTopicId: 385272
dashedName: longest-increasing-subsequence
@@ -8,57 +8,57 @@ dashedName: longest-increasing-subsequence
# --description--
-The longest increasing subsequence problem is to find a subsequence of a given sequence in which the subsequence's elements are in sorted order, lowest to highest, and in which the subsequence is as long as possible. An example:
+Il problema di della più lunga sottosequenza crescente è quello di trovare una sottosequenza di una data sequenza in cui gli elementi successivi sono in ordine, dal più basso al più alto, e in cui la sottosequenza è la più lunga possibile. Un esempio:
-For the following array:
+Per il seguente array:
$\\{3, 10, 2, 1, 20\\}$
-Longest increasing sequence is:
+La sequenza crescente più lunga è:
$\\{3, 10, 20\\}$
-For more information on this problem please see [Wikipedia](https://en.wikipedia.org/wiki/Longest increasing subsequence).
+Per ulteriori informazioni su questo problema consulta [Wikipedia](https://en.wikipedia.org/wiki/Longest increasing subsequence).
# --instructions--
-Write a function that takes an array of numbers as a parameter and returns the longest increasing subsequence.
+Scrivere una funzione che prende un array di numeri come parametro e restituisce la più lunga sottosequenza crescente.
-It is guaranteed that every array will have a longest increasing subsequence.
+È garantito che ogni array avrà una sottosequenza crescente più lunga.
# --hints--
-`findSequence` should be a function.
+`findSequence` dovrebbe essere una funzione.
```js
assert(typeof findSequence == 'function');
```
-`findSequence([3, 10, 2, 1, 20])` should return a array.
+`findSequence([3, 10, 2, 1, 20])` dovrebbe restituire un array.
```js
assert(Array.isArray(findSequence([3, 10, 2, 1, 20])));
```
-`findSequence([3, 10, 2, 1, 20])` should return `[3, 10, 20]`.
+`findSequence([3, 10, 2, 1, 20])` dovrebbe restituire `[3, 10, 20]`.
```js
assert.deepEqual(findSequence([3, 10, 2, 1, 20]), [3, 10, 20]);
```
-`findSequence([2, 7, 3, 5, 8])` should return `[2, 3, 5, 8]`.
+`findSequence([2, 7, 3, 5, 8])` dovrebbe restituire `[2, 3, 5, 8]`.
```js
assert.deepEqual(findSequence([2, 7, 3, 5, 8]), [2, 3, 5, 8]);
```
-`findSequence([2, 6, 4, 5, 1])` should return `[2, 4, 5]`.
+`findSequence([2, 6, 4, 5, 1])` dovrebbe restituire `[2, 4, 5]`.
```js
assert.deepEqual(findSequence([2, 6, 4, 5, 1]), [2, 4, 5]);
```
-`findSequence([10, 22, 9, 33, 21, 50, 60, 80])` should return `[10, 22, 33, 50, 60, 80]`.
+`findSequence([10, 22, 9, 33, 21, 50, 60, 80])` dovrebbe restituire `[10, 22, 33, 50, 60, 80]`.
```js
assert.deepEqual(findSequence([10, 22, 9, 33, 21, 50, 60, 80]), [
@@ -71,7 +71,7 @@ assert.deepEqual(findSequence([10, 22, 9, 33, 21, 50, 60, 80]), [
]);
```
-`findSequence([0, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15])` should return `[0, 2, 6, 9, 11, 15`.
+`findSequence([0, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15])` dovrebbe restituire `[0, 2, 6, 9, 11, 15`.
```js
assert.deepEqual(
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/longest-string-challenge.md b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/longest-string-challenge.md
index 06a0c9d550..22886a6b6d 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/longest-string-challenge.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/longest-string-challenge.md
@@ -1,6 +1,6 @@
---
id: 5e6dd14192286d95fc43046e
-title: Longest string challenge
+title: Sfida della stringa più lunga
challengeType: 5
forumTopicId: 385275
dashedName: longest-string-challenge
@@ -8,27 +8,27 @@ dashedName: longest-string-challenge
# --description--
-In this challenge, you have to find the strings that are the longest among the given strings.
+In questa sfida, devi trovare le stringhe che sono le più lunghe tra le stringhe date.
# --instructions--
-Write a function that takes an array of strings and returns the strings that have a length equal to the longest length.
+Scrivi una funzione che richiede un array di stringhe e restituisce le stringhe che hanno una lunghezza uguale alla lunghezza più lunga.
# --hints--
-`longestString` should be a function.
+`longestString` dovrebbe essere una funzione.
```js
assert(typeof longestString == 'function');
```
-`longestString(["a", "bb", "ccc", "ee", "f", "ggg"])` should return a array.
+`longestString(["a", "bb", "ccc", "ee", "f", "ggg"])` dovrebbe restituire un array.
```js
assert(Array.isArray(longestString(['a', 'bb', 'ccc', 'ee', 'f', 'ggg'])));
```
-`longestString(["a", "bb", "ccc", "ee", "f", "ggg"])` should return `["ccc", "ggg"]'`.
+`longestString(["a", "bb", "ccc", "ee", "f", "ggg"])` dovrebbe restituire `["ccc", "ggg"]`.
```js
assert.deepEqual(longestString(['a', 'bb', 'ccc', 'ee', 'f', 'ggg']), [
@@ -37,7 +37,7 @@ assert.deepEqual(longestString(['a', 'bb', 'ccc', 'ee', 'f', 'ggg']), [
]);
```
-`longestString(["afedg", "bb", "sdccc", "efdee", "f", "geegg"])` should return `["afedg", "sdccc", "efdee", "geegg"]`.
+`longestString(["afedg", "bb", "sdccc", "efdee", "f", "geegg"])` dovrebbe restituire `["afedg", "sdccc", "efdee", "geegg"]`.
```js
assert.deepEqual(
@@ -46,7 +46,7 @@ assert.deepEqual(
);
```
-`longestString(["a", "bhghgb", "ccc", "efde", "fssdrr", "ggg"])` should return `["bhghgb", "fssdrr"]`.
+`longestString(["a", "bhghgb", "ccc", "efde", "fssdrr", "ggg"])` dovrebbe restituire `["bhghgb", "fssdrr"]`.
```js
assert.deepEqual(
@@ -55,7 +55,7 @@ assert.deepEqual(
);
```
-`longestString(["ahgfhg", "bdsfsb", "ccc", "ee", "f", "ggdsfg"])` should return `["ahgfhg", "bdsfsb", "ggdsfg"]`.
+`longestString(["ahgfhg", "bdsfsb", "ccc", "ee", "f", "ggdsfg"])` dovrebbe restituire `["ahgfhg", "bdsfsb", "ggdsfg"]`.
```js
assert.deepEqual(
@@ -64,7 +64,7 @@ assert.deepEqual(
);
```
-`longestString(["a", "bbdsf", "ccc", "edfe", "gzzzgg"])` should return `["gzzzgg"]`.
+`longestString(["a", "bbdsf", "ccc", "edfe", "gzzzgg"])` dovrebbe restituire `["gzzzgg"]`.
```js
assert.deepEqual(longestString(['a', 'bbdsf', 'ccc', 'edfe', 'gzzzgg']), [
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/look-and-say-sequence.md b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/look-and-say-sequence.md
index ed09269a09..b9cb82f907 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/look-and-say-sequence.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/look-and-say-sequence.md
@@ -1,6 +1,6 @@
---
id: 5e6dd14797f5ce267c2f19d0
-title: Look-and-say sequence
+title: Successione Look-and-say
challengeType: 5
forumTopicId: 385277
dashedName: look-and-say-sequence
@@ -8,64 +8,64 @@ dashedName: look-and-say-sequence
# --description--
-The [Look and say sequence](https://en.wikipedia.org/wiki/Look and say sequence) is a recursively defined sequence of numbers.
+La successione [Look and say](https://en.wikipedia.org/wiki/Look and say sequence) è una sequenza di numeri definita ricorsivamente.
-Sequence Definition
+Definizione della successione
-- Take a decimal number -
- Look at the number, visually grouping consecutive runs of the same digit. -
- Say the number, from left to right, group by group; as how many of that digit there are - followed by the digit grouped.
- Prendi un numero decimale +
- Guarda (look) il numero, raggruppando visivamente le successioni consecutive della stessa cifra. +
- Leggi (say) il numero, da sinistra a destra, gruppo per gruppo; quante ripetizioni di quella cifra ci sono - seguita dalla cifra raggruppata.
- Starting with the number 1, you have one 1 which produces 11 -
- Starting with 11, you have two 1's. I.E.: 21 -
- Starting with 21, you have one 2, then one 1. I.E.: (12)(11) which becomes 1211 -
- Starting with 1211, you have one 1, one 2, then two 1's. I.E.: (11)(12)(21) which becomes 111221
- A partire dal numero 1, hai un 1 che produce 11 +
- A partire da 11, hai due 1. Cioè: 21 +
- A partire da 21, hai un 2, poi un 1. Cioè: (12)(11) che diventa 1211 +
- A partire da 1211, hai un 1, un 2, poi due 1. Cioè: (11)(12)(21) che diventa 111221
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 ...
-(Loop)
+(Ciclo)
-
-
- Take the first member of the resultant array as the next ludic number 2. -
- Remove every 2nd indexed item from the array (including the first). +
- Prendi il primo membro dell'array risultante come prossimo numero ludico 2. +
- Rimuovi ogni secondo elemento indicizzato dall'array (incluso il primo).
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 ...-
-
- (Unrolling a few loops...) -
- Take the first member of the resultant array as the next ludic number 3. -
- Remove every 3rd indexed item from the array (including the first). +
- (Srotolando alcuni cicli...) +
- Prendi il primo membro dell'array risultante come il prossimo numero ludico 3. +
- Rimuovi ogni terzo elemento indicizzato dall'array (incluso il primo).
3 5 7 9 11 13 15 17 19 21 23 25 27 29 31 33 35 37 39 41 43 45 47 49 51 ...-
-
- Take the first member of the resultant array as the next ludic number 5. -
- Remove every 5th indexed item from the array (including the first). +
- Prendi il primo membro dell'array risultante come il prossimo numero ludico 5. +
- Rimuovi ogni quinto elemento indicizzato dall'array (incluso il primo).
5 7 11 13 17 19 23 25 29 31 35 37 41 43 47 49 53 55 59 61 65 67 71 73 77 ...-
-
- Take the first member of the resultant array as the next ludic number 7. -
- Remove every 7th indexed item from the array (including the first). +
- Prendi il primo membro dell'array risultante come il prossimo numero ludico 7. +
- Rimuovi ogni settimo elemento indicizzato dall'array (incluso il primo).
7 11 13 17 23 25 29 31 37 41 43 47 53 55 59 61 67 71 73 77 83 85 89 91 97 ...- ... -
- Take the first member of the current array as the next ludic number L. -
- Remove every Lth indexed item from the array (including the first). +
- Prendi il primo membro dell'array corrente come prossimo numero ludico L. +
- Rimuovi ogni elemento indicizzato Lmo dall'array (incluso il primo).
- ...
ludic should be a function.');
```
-`ludic(2)` should return a array.
+`ludic(2)` dovrebbe restituire un array.
```js
assert(Array.isArray(ludic(2)));
```
-`ludic(2)` should return `[1, 2]`.
+`ludic(2)` dovrebbe restituire `[1, 2]`.
```js
assert.deepEqual(ludic(2), [1, 2]);
```
-`ludic(3)` should return `[1, 2, 3]`.
+`ludic(3)` dovrebbe restituire `[1, 2, 3]`.
```js
assert.deepEqual(ludic(3), [1, 2, 3]);
```
-`ludic(5)` should return `[1, 2, 3, 5]`.
+`ludic(5)` dovrebbe restituire `[1, 2, 3, 5]`.
```js
assert.deepEqual(ludic(5), [1, 2, 3, 5]);
```
-`ludic(20)` should return `[1, 2, 3, 5, 7, 11, 13, 17]`.
+`ludic(20)` dovrebbe restituire `[1, 2, 3, 5, 7, 11, 13, 17]`.
```js
assert.deepEqual(ludic(20), [1, 2, 3, 5, 7, 11, 13, 17]);
```
-`ludic(26)` should return `[1, 2, 3, 5, 7, 11, 13, 17, 23, 25]`.
+`ludic(26)` dovrebbe restituire `[1, 2, 3, 5, 7, 11, 13, 17, 23, 25]`.
```js
assert.deepEqual(ludic(26), [1, 2, 3, 5, 7, 11, 13, 17, 23, 25]);
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/luhn-test-of-credit-card-numbers.md b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/luhn-test-of-credit-card-numbers.md
index 4fcc90502a..b19bf38cce 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/luhn-test-of-credit-card-numbers.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/luhn-test-of-credit-card-numbers.md
@@ -1,6 +1,6 @@
---
id: 5ea28156e79528a9ab248f27
-title: Luhn test of credit card numbers
+title: Test di Luhn dei numeri delle carte di credito
challengeType: 5
forumTopicId: 385284
dashedName: luhn-test-of-credit-card-numbers
@@ -8,22 +8,22 @@ dashedName: luhn-test-of-credit-card-numbers
# --description--
-The [Luhn test](https://en.wikipedia.org/wiki/Luhn algorithm) is used by some credit card companies to distinguish valid credit card numbers from what could be a random selection of digits.
+Il test di [Luhn](https://en.wikipedia.org/wiki/Luhn algorithm) è utilizzato da alcune aziende di carte di credito per distinguere i numeri di carta di credito validi da quella che potrebbe essere una selezione casuale di cifre.
-Those companies using credit card numbers that can be validated by the Luhn test have numbers that pass the following test:
+Le società che utilizzano numeri di carta di credito che possono essere convalidati dal test di Luhn hanno numeri che superano il seguente test:
-
-
- Reverse the order of the digits in the number. -
- Take the first, third, ... and every other odd digit in the reversed digits and sum them to form the partial sum s1 -
- Taking the second, fourth ... and every other even digit in the reversed digits: +
- Inverte l'ordine delle cifre nel numero. +
- Prende la prima, la terza, ... e ogni altra cifra dispari nelle cifre invertite e le somma per formare la somma parziale s1 +
- Prende la seconda, la quarta... e ogni altra cifra pari nelle cifre invertite:
- Multiply each digit by two and sum the digits if the answer is greater than nine to form partial sums for the even digits. -
- Sum the partial sums of the even digits to form s2. +
- Moltiplica ogni cifra per due e somma le cifre se la risposta è maggiore di nove per formare somme parziali per le cifre pari. +
- Somma le somme parziali delle cifre pari per formare s2.
- If s1 + s2 ends in zero then the original number is in the form of a valid credit card number as verified by the Luhn test. +
- Se s1 + s2 termina in zero allora il numero originale ha la forma di un numero di carta di credito valido, stando alla verifica del test di Luhn.
-
-
-
-
- Take an integer
n₀, greater than zero.
- - Form the next number
nof the series by reversingn₀and adding it ton₀
- - Stop when
nbecomes palindromic - i.e. the digits ofnin reverse order ==n.
+ - Prendi un numero intero
n₀maggiore di zero.
+ - Forma il prossimo numero
ndella serie invertendon₀e aggiungendolo an₀
+ - Termina quando
ndiventa palindromo - cioè le cifre dinin ordine inverso ==n.
((data "quoted data" 123 4.5) (data (!@# (4.5) "(more" "data)")))-and turn it into a native data structure. (See the [Pike](https://rosettacode.org/wiki/S-Expressions#Pike "\#Pike"), [Python](https://rosettacode.org/wiki/S-Expressions#Python "\#Python") and [Ruby](https://rosettacode.org/wiki/S-Expressions#Ruby "\#Ruby") implementations for examples of native data structures.) +e trasformarlo in una struttura di dati nativa. (Vedi le implementazioni in [Pike](https://rosettacode.org/wiki/S-Expressions#Pike "\#Pike"), [Python](https://rosettacode.org/wiki/S-Expressions#Python "\#Python") e [Ruby](https://rosettacode.org/wiki/S-Expressions#Ruby "\#Ruby") per esempi di strutture di dati native.) # --hints-- -`parseSexpr` should be a function. +`parseSexpr` dovrebbe essere una funzione. ```js assert(typeof parseSexpr === 'function'); ``` -`parseSexpr('(data1 data2 data3)')` should return `['data1', 'data2', 'data3']` +`parseSexpr('(data1 data2 data3)')` dovrebbe restituire `['data1', 'data2', 'data3']` ```js assert.deepEqual(parseSexpr(simpleSExpr), simpleSolution); ``` -`parseSexpr('((data "quoted data" 123 4.5) (data (!@# (4.5) "(more" "data)")))')` should return `[['data', '"quoted data"', 123, 4.5], ['data', ['!@#', [4.5], '"(more"', '"data)"']]]`. +`parseSexpr('((data "quoted data" 123 4.5) (data (!@# (4.5) "(more" "data)")))')` dovrebbe restituire `[['data', '"quoted data"', 123, 4.5], ['data', ['!@#', [4.5], '"(more"', '"data)"']]]`. ```js assert.deepEqual(parseSexpr(basicSExpr), basicSolution); diff --git a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/sailors-coconuts-and-a-monkey-problem.md b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/sailors-coconuts-and-a-monkey-problem.md index ec8a0c6e2d..a43aa562f7 100644 --- a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/sailors-coconuts-and-a-monkey-problem.md +++ b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/sailors-coconuts-and-a-monkey-problem.md @@ -1,6 +1,6 @@ --- id: 59da22823d04c95919d46269 -title: 'Sailors, coconuts and a monkey problem' +title: 'Problema dei marinai, scimmie e noci di cocco' challengeType: 5 forumTopicId: 302304 dashedName: sailors-coconuts-and-a-monkey-problem @@ -8,38 +8,38 @@ dashedName: sailors-coconuts-and-a-monkey-problem # --description-- -Five sailors are shipwrecked on an island and collect a large pile of coconuts during the day. That night the first sailor wakes up and decides to take his first share early so tries to divide the pile of coconuts equally into five piles but finds that there is one coconut left over, so he tosses it to a monkey and then hides "his" one of the five equally sized piles of coconuts and pushes the other four piles together to form a single visible pile of coconuts again and goes to bed. To cut a long story short, each of the sailors in turn gets up once during the night and performs the same actions of dividing the coconut pile into five, finding that one coconut is left over and giving that single remainder coconut to the monkey. In the morning (after the surreptitious and separate action of each of the five sailors during the night), the remaining coconuts are divided into five equal piles for each of the sailors, whereupon it is found that the pile of coconuts divides equally amongst the sailors with no remainder. (Nothing for the monkey in the morning.) +Cinque marinai sono naufragati su un'isola e raccolgono un grande mucchio di noci di cocco durante il giorno. Quella notte il primo marinaio si sveglia e decide di prendere la sua prima parte presto, così cerca di dividere il mucchio di noci di cocco ugualmente in cinque pile, ma scopre che c'è un cocco rimasto, così lo lancia ad una scimmia e poi nasconde la "sua" pila di cocco, di pari dimensione, e spinge le altre quattro insieme per formare nuovamente un unico mucchio visibile di noci di cocco e va a letto. Per farla breve, ciascuno dei marinai a sua volta si alza una volta durante la notte ed esegue le stesse azioni di divisione del mucchio di cocco in cinque, scopre che un cocco è rimasto e da quel singolo cocco alla scimmia. Al mattino (dopo l'azione surrettizia e separata di ciascuno dei cinque marinai durante la notte), le noci di cocco restanti sono suddivise in cinque pile uguali per ciascuno dei marinai, dopodiché si scopre che il mucchio di noci di cocco si divide ugualmente tra i marinai senza resto. (Niente per la scimmia al mattino.) # --instructions-- -Create a function that returns the minimum possible size of the initial pile of coconuts collected during the day for `N` sailors. **Note:** Of course the tale is told in a world where the collection of any amount of coconuts in a day and multiple divisions of the pile, etc. can occur in time fitting the story line, so as not to affect the mathematics. **C.f:** +Crea una funzione che restituisca la dimensione minima possibile del mucchio iniziale di noci di cocco raccolto durante il giorno per `N` marinai. **Nota:** Naturalmente la storia è raccontata in un mondo in cui la raccolta di qualsiasi quantità di noci di cocco in un giorno e divisioni multiple del mucchio, ecc. possono verificarsi nel tempo della storia, in modo da non influenzare la matematica. **Confronta:**
- Monkeys and Coconuts - Numberphile (Video) Analytical solution. -
- A002021 Pile of coconuts problem The On-Line Encyclopedia of Integer Sequences. (Although some of its references may use the alternate form of the tale). +
- A002021 Problema del mucchio di noci di cocco L'Enciclopedia online delle sequenze di numeri interi. (Anche se alcuni dei suoi riferimenti possono utilizzare la forma alternativa del racconto).
710889 => 7108899 @@ -24,35 +24,35 @@ B0YBKT => B0YBKT7 B00030 => B000300-Check that each input is correctly formed, especially with respect to valid characters allowed in a SEDOL string. Your function should return `null` on an invalid input. +Controllare che ogni input sia formato correttamente, soprattutto per quanto riguarda i caratteri validi consentiti in una stringa SEDOL. La tua funzione dovrebbe restituire `null` per un input non valido. # --hints-- -`sedol` should be a function. +`sedol` dovrebbe essere una funzione. ```js assert(typeof sedol === 'function'); ``` -`sedol('a')` should return null. +`sedol('a')` dovrebbe restituire null. ```js assert(sedol('a') === null); ``` -`sedol('710889')` should return '7108899'. +`sedol('710889')` dovrebbe restituire '7108899'. ```js assert(sedol('710889') === '7108899'); ``` -`sedol('BOATER')` should return null. +`sedol('BOATER')` dovrebbe restituire null. ```js assert(sedol('BOATER') === null); ``` -`sedol('228276')` should return '2282765'. +`sedol('228276')` dovrebbe restituire '2282765'. ```js assert(sedol('228276') === '2282765'); diff --git a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/self-describing-numbers.md b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/self-describing-numbers.md index df2a88508f..4f648057f3 100644 --- a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/self-describing-numbers.md +++ b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/self-describing-numbers.md @@ -1,6 +1,6 @@ --- id: 5eaf48389ee512d4d103684b -title: Self Describing Numbers +title: Numeri autodescrittivi challengeType: 5 forumTopicId: 385289 dashedName: self-describing-numbers @@ -8,52 +8,52 @@ dashedName: self-describing-numbers # --description-- -There are several so-called "self describing" or ["self-descriptive"](https://en.wikipedia.org/wiki/Self-descriptive_number) integers. +Ci sono diversi cosiddetti interi "auto-descriventi" o ["auto-descrittivi"](https://en.wikipedia.org/wiki/Self-descriptive_number) interi. -An integer is said to be "self-describing" if it has the property that, when digit positions are labeled 0 to N-1, the digit in each position is equal to the number of times that digit appears in the number. +Si dice che un intero è "auto-descritto" se ha la proprietà che, quando le posizioni di cifra sono etichettate da 0 a N-1, la cifra in ogni posizione è uguale al numero di volte che la cifra appare nel numero. -For example, **2020** is a four-digit self describing number: +Ad esempio, **2020** è un numero auto-descrittivo a quattro cifre:
-
-
- position 0 has value 2 and there are two 0s in the number; -
- position 1 has value 0 and there are no 1s in the number; -
- position 2 has value 2 and there are two 2s; -
- position 3 has value 0 and there are zero 3s; +
- la posizione 0 ha il valore 2 e nel numero ci sono due zeri; +
- la posizione 1 ha valore 0 e non ci sono uno nel numero; +
- la posizione 2 ha valore 2 e ci sono due due; +
- la posizione 3 ha valore 0 e ci sono zero tre;
0, 10, 1110, 3110, 132110, 1113122110, 311311222110 ...-The terms generated grow in length geometrically and never converge. +I termini generati crescono geometricamente in lunghezza e non convergono mai. -Another way to generate a self-referential sequence is to summarize the previous term. +Un altro modo per generare una sequenza auto-referenziale è quello di riassumere il termine precedente. -Count how many of each alike digit there is, then concatenate the sum and digit for each of the sorted enumerated digits. Note that the first five terms are the same as for the previous sequence. +Conta quante di ogni cifra simile ci sono, quindi concatena la somma e la cifra per ciascuna delle cifre enumerate ordinate. Nota che i primi cinque termini sono gli stessi della sequenza precedente.
0, 10, 1110, 3110, 132110, 13123110, 23124110 ...-Sort the digits largest to smallest. Do not include counts of digits that do not appear in the previous term. +Ordina le cifre da più grandi a più piccole. Non includere i conteggi di cifre che non appaiono nel termine precedente. -Depending on the seed value, series generated this way always either converge to a stable value or to a short cyclical pattern. (For our purposes, converge means that an element matches a previously seen element.) The sequence shown, with a seed value of 0, converges to a stable value of 1433223110 after 11 iterations. The seed value that converges most quickly is 22. It goes stable after the first element. (The next element is 22, which has been seen before.) +A seconda del valore del seme, le serie generate in questo modo convergono sempre a un valore stabile o a un breve modello periodico. (Per i nostri scopi, convergere significa che un elemento corrisponde a un elemento visto precedentemente.) La sequenza mostrata, con un valore di seme di 0, converge ad un valore stabile di 1433223110 dopo 11 iterazioni. Il valore del seme che converge più rapidamente è 22. Diventa stabile dopo il primo elemento. (L'elemento successivo è 22, che è stato visto prima.) # --instructions-- -Write a function that takes the seed value as parameter, generates a self referential sequence until it converges, and returns it as an array. +Scrivi una funzione che prende il valore del seme come parametro, genera una sequenza autoreferenziale fino a quando non converge, e la restituisce sotto forma di array. # --hints-- -`selfReferential` should be a function. +`selfReferential` dovrebbe essere una funzione. ```js assert(typeof selfReferential === 'function'); ``` -`selfReferential(40)` should return a array. +`selfReferential(40)` dovrebbe restituire un array. ```js assert(Array.isArray(selfReferential(40))); ``` -`selfReferential(40)` should return `["40", "1410", "142110", "14123110", "1413124110", "2413125110", "151413224110", "152413225110", "251413324110", "152423224110", "152413423110"]`. +`selfReferential(40)` dovrebbe restituire `["40", "1410", "142110", "14123110", "1413124110", "2413125110", "151413224110", "152413225110", "251413324110", "152423224110", "152413423110"]`. ```js assert.deepEqual(selfReferential(40), [ @@ -60,7 +60,7 @@ assert.deepEqual(selfReferential(40), [ ]); ``` -`selfReferential(132110)` should return `["132110", "13123110", "23124110", "1413223110", "1423224110", "2413323110", "1433223110"]`. +`selfReferential(132110)` dovrebbe restituire `["132110", "13123110", "23124110", "1413223110", "1423224110", "2413323110", "1433223110"]`. ```js assert.deepEqual(selfReferential(132110), [ @@ -74,7 +74,7 @@ assert.deepEqual(selfReferential(132110), [ ]); ``` -`selfReferential(132211)` should return `["132211", "132231", "232221", "134211", "14131231", "14231241", "24132231", "14233221"]`. +`selfReferential(132211)` dovrebbe restituire `["132211", "132231", "232221", "134211", "14131231", "14231241", "24132231", "14233221"]`. ```js assert.deepEqual(selfReferential(132211), [ @@ -89,7 +89,7 @@ assert.deepEqual(selfReferential(132211), [ ]); ``` -`selfReferential(1413223110)` should return `["1413223110", "1423224110", "2413323110", "1433223110"]`. +`selfReferential(1413223110)` dovrebbe restituire `["1413223110", "1423224110", "2413323110", "1433223110"]`. ```js assert.deepEqual(selfReferential(1413223110), [ @@ -100,7 +100,7 @@ assert.deepEqual(selfReferential(1413223110), [ ]); ``` -`selfReferential(251413126110)` should return `["251413126110", "16151413225110", "16251413226110", "26151413325110", "16251423225110", "16251413424110", "16153413225110"]`. +`selfReferential(251413126110)` dovrebbe restituire `["251413126110", "16151413225110", "16251413226110", "26151413325110", "16251423225110", "16251413424110", "16153413225110"]`. ```js assert.deepEqual(selfReferential(251413126110), [ diff --git a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/semiprime.md b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/semiprime.md index 961f13632f..4aeda76dca 100644 --- a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/semiprime.md +++ b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/semiprime.md @@ -1,6 +1,6 @@ --- id: 5eb3e4aa847216613aa81983 -title: Semiprime +title: Semiprimi challengeType: 5 forumTopicId: 385318 dashedName: semiprime @@ -8,83 +8,83 @@ dashedName: semiprime # --description-- -Semiprime numbers are natural numbers that are products of exactly two (possibly equal) [prime numbers](https://rosettacode.org/wiki/prime_number). +I numeri semiprimi sono numeri naturali che sono il prodotto di esattamente due [numeri primi](https://rosettacode.org/wiki/prime_number) (anche uguali).
1679 = 23 x 73# --instructions-- -Write a function that returns true if a number is semiprime, or false if it is not. +Scrivi una funzione che restituisce vero se un numero è semiprimo, o falso se non lo è. # --hints-- -`isSemiPrime` should be a function. +`isSemiPrime` dovrebbe essere una funzione. ```js assert(typeof isSemiPrime === 'function'); ``` -`isSemiPrime(100)` should return a boolean. +`isSemiPrime(100)` dovrebbe restituire un booleano. ```js assert(typeof isSemiPrime(100) === 'boolean'); ``` -`isSemiPrime(100)` should return `false`. +`isSemiPrime(100)` dovrebbe restituire `false`. ```js assert.equal(isSemiPrime(100), false); ``` -`isSemiPrime(504)` should return `false`. +`isSemiPrime(504)` dovrebbe restituire `false`. ```js assert.equal(isSemiPrime(504), false); ``` -`isSemiPrime(4)` should return `true`. +`isSemiPrime(4)` dovrebbe restituire `true`. ```js assert.equal(isSemiPrime(4), true); ``` -`isSemiPrime(46)` should return `true`. +`isSemiPrime(46)` dovrebbe restituire `true`. ```js assert.equal(isSemiPrime(46), true); ``` -`isSemiPrime(13)` should return `false`. +`isSemiPrime(13)` dovrebbe restituire `false`. ```js assert.equal(isSemiPrime(13), false); ``` -`isSemiPrime(74)` should return `true`. +`isSemiPrime(74)` dovrebbe restituire `true`. ```js assert.equal(isSemiPrime(74), true); ``` -`isSemiPrime(1679)` should return `true`. +`isSemiPrime(1679)` dovrebbe restituire `true`. ```js assert.equal(isSemiPrime(1679), true); ``` -`isSemiPrime(2)` should return `false`. +`isSemiPrime(2)` dovrebbe restituire `false`. ```js assert.equal(isSemiPrime(2), false); ``` -`isSemiPrime(95)` should return `true`. +`isSemiPrime(95)` dovrebbe restituire `true`. ```js assert.equal(isSemiPrime(95), true); ``` -`isSemiPrime(124)` should return `false`. +`isSemiPrime(124)` dovrebbe restituire `false`. ```js assert.equal(isSemiPrime(124), false); diff --git a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/set-consolidation.md b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/set-consolidation.md index 3a97b090b3..44a9da3564 100644 --- a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/set-consolidation.md +++ b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/set-consolidation.md @@ -1,6 +1,6 @@ --- id: 5eb3e4af7d0e7b760b46cedc -title: Set consolidation +title: Consolidazione di insiemi challengeType: 5 forumTopicId: 385319 dashedName: set-consolidation @@ -8,58 +8,58 @@ dashedName: set-consolidation # --description-- -Given two sets of items then if any item is common to any set then the result of applying *consolidation* to those sets is a set of sets whose contents is: +Dati due set di elementi, se un elemento è comune in comune tra almeno due set allora il risultato di applicare la *consolidazione* a questi set è un set di set il cui contenuto è:
-
-
- The two input sets if no common item exists between the two input sets of items. -
- The single set that is the union of the two input sets if they share a common item. +
- I due set di input se non c'è alcun elemento in comune tra i due set di elementi di input. +
- Il singolo set che è unione dei due set di input se hanno un elemento in comune.
- [a, b]: {x | a ≤ x and x ≤ b } @@ -17,52 +17,52 @@ All real numbers form the uncountable set ℝ. Among its subsets, relatively sim
- (a, b]: {x | a < x and x ≤ b }
-
-
- Devise a way to represent any set of real numbers, for the definition of "any" in the implementation notes below. -
- Provide methods for these common set operations (x is a real number; A and B are sets): +
- Definisci un modo per rappresentare qualsiasi insieme di numeri reali, per la definizione di "any" nelle note di implementazione qui sotto. +
- Fornisci dei metodi per queste operazioni comuni sugli insiemi (x è un numero reale; A e B sono insiemi):
-
- x ∈ A: determine if x is an element of A
- example: 1 is in [1, 2), while 2, 3, ... are not. + x ∈ A: determinare se x è un elemento di A
+ esempio: 1 è in [1, 2), mentre 2, 3, . . – non lo sono. -
- A ∪ B: union of A and B, i.e. {x | x ∈ A or x ∈ B}
- example: [0, 2) ∪ (1, 3) = [0, 3); [0, 1) ∪ (2, 3] = well, [0, 1) ∪ (2, 3] + A ∪ B: unione di A e B, cioè {xx A oppure x B}
+ esempio: [0, 2) ∪ (1, 3) = [0, 3; [0, 1) ∪ (2, 3] = pozzo, [0, 1) ∪ (2, 3] -
- A ∩ B: intersection of A and B, i.e. {x | x ∈ A and x ∈ B}
- example: [0, 2) ∩ (1, 3) = (1, 2); [0, 1) ∩ (2, 3] = empty set + A ∩ B: intersezione di A e B, cioè {x | x ∈ A e x ∈ B}
+ esempio: [0, 2) ∩ (1, 3) = (1, 2); [0, 1) ∩ (2, 3] = insieme vuoto -
- A - B: difference between A and B, also written as A \ B, i.e. {x | x ∈ A and x ∉ B}
- example: [0, 2) − (1, 3) = [0, 1] + A - B: differenza tra A e B, anche scritto come A \ B, cioè {x | x ∈ A e x ∉B}
+ esempio: [0, 2) - (1, 3) = [0, 1]
values: [7, 6, 5, 4, 3, 2, 1, 0]
@@ -18,25 +18,25 @@ Make your function work with the following list of values and set of indices:
indices(0-based): {6, 1, 7}
```
-Where the correct result would be:
+Dove il risultato corretto sarà:
[7, 0, 5, 4, 3, 2, 1, 6].
# --hints--
-`sortDisjoint` should be a function.
+`sortDisjoint` dovrebbe essere una funzione.
```js
assert(typeof sortDisjoint == 'function');
```
-`sortDisjoint([7, 6, 5, 4, 3, 2, 1, 0], [6, 1, 7])` should return an array.
+`sortDisjoint([7, 6, 5, 4, 3, 2, 1, 0], [6, 1, 7])` dovrebbe restituire un array.
```js
assert(Array.isArray(sortDisjoint([7, 6, 5, 4, 3, 2, 1, 0], [6, 1, 7])));
```
-`sortDisjoint([7, 6, 5, 4, 3, 2, 1, 0], [6, 1, 7])` should return `[7, 0, 5, 4, 3, 2, 1, 6]`.
+`sortDisjoint([7, 6, 5, 4, 3, 2, 1, 0], [6, 1, 7])` dovrebbe restituire `[7, 0, 5, 4, 3, 2, 1, 6]`.
```js
assert.deepEqual(sortDisjoint([7, 6, 5, 4, 3, 2, 1, 0], [6, 1, 7]), [
@@ -51,7 +51,7 @@ assert.deepEqual(sortDisjoint([7, 6, 5, 4, 3, 2, 1, 0], [6, 1, 7]), [
]);
```
-`sortDisjoint([7, 6, 5, 4, 3, 2, 1, 0], [1, 2, 5, 6])` should return `[7, 1, 2, 4, 3, 5, 6, 0]`.
+`sortDisjoint([7, 6, 5, 4, 3, 2, 1, 0], [1, 2, 5, 6])` dovrebbe restituire `[7, 1, 2, 4, 3, 5, 6, 0]`.
```js
assert.deepEqual(sortDisjoint([7, 6, 5, 4, 3, 2, 1, 0], [1, 2, 5, 6]), [
@@ -66,7 +66,7 @@ assert.deepEqual(sortDisjoint([7, 6, 5, 4, 3, 2, 1, 0], [1, 2, 5, 6]), [
]);
```
-`sortDisjoint([8, 7, 6, 5, 4, 3, 2, 1], [6, 1, 7])` should return `[8, 1, 6, 5, 4, 3, 2, 7]`.
+`sortDisjoint([8, 7, 6, 5, 4, 3, 2, 1], [6, 1, 7])` dovrebbe restituire `[8, 1, 6, 5, 4, 3, 2, 7]`.
```js
assert.deepEqual(sortDisjoint([8, 7, 6, 5, 4, 3, 2, 1], [6, 1, 7]), [
@@ -81,7 +81,7 @@ assert.deepEqual(sortDisjoint([8, 7, 6, 5, 4, 3, 2, 1], [6, 1, 7]), [
]);
```
-`sortDisjoint([8, 7, 6, 5, 4, 3, 2, 1], [1, 3, 5, 6])` should return `[8, 2, 6, 3, 4, 5, 7, 1]`.
+`sortDisjoint([8, 7, 6, 5, 4, 3, 2, 1], [1, 3, 5, 6])` dovrebbe restituire `[8, 2, 6, 3, 4, 5, 7, 1]`.
```js
assert.deepEqual(sortDisjoint([8, 7, 6, 5, 4, 3, 2, 1], [1, 3, 5, 6]), [
@@ -96,7 +96,7 @@ assert.deepEqual(sortDisjoint([8, 7, 6, 5, 4, 3, 2, 1], [1, 3, 5, 6]), [
]);
```
-`sortDisjoint([6, 1, 7, 1, 3, 5, 6], [6, 1, 5, 4])` should return `[6, 1, 7, 1, 3, 5, 6]`.
+`sortDisjoint([6, 1, 7, 1, 3, 5, 6], [6, 1, 5, 4])` dovrebbe restituire `[6, 1, 7, 1, 3, 5, 6]`.
```js
assert.deepEqual(sortDisjoint([6, 1, 7, 1, 3, 5, 6], [6, 1, 5, 4]), [
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/sort-stability.md b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/sort-stability.md
index 3f57407b6a..0660a217e6 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/sort-stability.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/sort-stability.md
@@ -1,6 +1,6 @@
---
id: 5a23c84252665b21eecc8014
-title: Sort stability
+title: Stabilità dell'ordinamento
challengeType: 5
forumTopicId: 302308
dashedName: sort-stability
@@ -8,9 +8,9 @@ dashedName: sort-stability
# --description--
-When sorting records in a table by a particular column or field, a [stable sort](https://en.wikipedia.org/wiki/Stable_sort#Stability) will always retain the relative order of records that have the same key.
+Quando si ordinano i record in una tabella per una particolare colonna o campo, un [ordinamento stabile](https://en.wikipedia.org/wiki/Stable_sort#Stability) manterrà sempre l'ordine relativo dei record che hanno la stessa chiave.
-For example, in this table of countries and cities, a stable sort on the **second** column, the cities, would keep the US Birmingham above the UK Birmingham. (Although an unstable sort *might*, in this case, place the US Birmingham above the UK Birmingham, a stable sort routine would *guarantee* it).
+Ad esempio, in questa tabella di paesi e città, un ordinamento stabile sulla **seconda** colonna, le città, manterrebbe US Birmingham sopra UK Birmingham. (Anche se un ordinamento instabile *potrebbe*, in questo caso, posizionare US Birmingham sopra UK Birmingham, un ordinamento stabile lo *garantirebbe* esso).
UK London US New York @@ -18,21 +18,21 @@ US Birmingham UK Birmingham-Similarly, stable sorting on just the first column would generate "UK London" as the first item and "US Birmingham" as the last item (since the order of the elements having the same first word – "UK" or "US" – would be maintained). +Allo stesso modo, l'ordinamento stabile fatto solo sulla prima colonna genererebbe "UK London" come primo elemento e "US Birmingham" come ultimo elemento (perché l'ordine degli elementi con la stessa prima parola – "UK" o "US" – sarebbe mantenuto). # --instructions-- -Write a function that takes a 2D array as a parameter. Each element has 2 elements similar to the above example. The function should sort the array as mentioned previously and return the sorted array. +Scrivi una funzione che richiede un array bidimensionale come parametro. Ogni elemento ha 2 elementi simili all'esempio precedente. La funzione dovrebbe ordinare l'array come menzionato precedentemente e restituire l'array ordinato. # --hints-- -`stableSort` should be a function. +`stableSort` dovrebbe essere una funzione. ```js assert(typeof stableSort == 'function'); ``` -`stableSort([["UK", "London"], ["US", "New York"], ["US", "Birmingham"], ["UK", "Birmingham"]])` should return an array. +`stableSort([["UK", "London"], ["US", "New York"], ["US", "Birmingham"], ["UK", "Birmingham"]])` dovrebbe restituire un array. ```js assert( @@ -47,7 +47,7 @@ assert( ); ``` -`stableSort([["UK", "London"], ["US", "New York"], ["US", "Birmingham"], ["UK", "Birmingham"]])` should return `[["US", "Birmingham"], ["UK", "Birmingham"], ["UK", "London"], ["US", "New York"]]`. +`stableSort([["UK", "London"], ["US", "New York"], ["US", "Birmingham"], ["UK", "Birmingham"]])` dovrebbe restituire `[["US", "Birmingham"], ["UK", "Birmingham"], ["UK", "London"], ["US", "New York"]]`. ```js assert.deepEqual( @@ -66,7 +66,7 @@ assert.deepEqual( ); ``` -`stableSort([[2, 2], [1, 2], [1, 4], [1, 5]])` should return `[[2, 2], [1, 2], [1, 4], [1, 5]]`. +`stableSort([[2, 2], [1, 2], [1, 4], [1, 5]])` dovrebbe restituire `[[2, 2], [1, 2], [1, 4], [1, 5]]`. ```js assert.deepEqual( @@ -85,7 +85,7 @@ assert.deepEqual( ); ``` -`stableSort([[11, 55], [12, 45], [11, 45], [32, 45]])` should return `[[12, 45], [11, 45], [32, 45], [11, 55]]`. +`stableSort([[11, 55], [12, 45], [11, 45], [32, 45]])` dovrebbe restituire `[[12, 45], [11, 45], [32, 45], [11, 55]]`. ```js assert.deepEqual( @@ -104,7 +104,7 @@ assert.deepEqual( ); ``` -`stableSort([[10, 22], [1, 2], [1, 4], [1, 5], [10, 9]])` should return `[[1, 2], [1, 4], [1, 5], [10, 9], [10, 22]]`. +`stableSort([[10, 22], [1, 2], [1, 4], [1, 5], [10, 9]])` dovrebbe restituire `[[1, 2], [1, 4], [1, 5], [10, 9], [10, 22]]`. ```js assert.deepEqual( @@ -125,7 +125,7 @@ assert.deepEqual( ); ``` -`stableSort([[55, 54], [12, 22], [31, 43], [31, 54], [10, 49]])` should return `[[12, 22], [31, 43], [10, 49], [55, 54], [31, 54]]`. +`stableSort([[55, 54], [12, 22], [31, 43], [31, 54], [10, 49]])` dovrebbe restituire `[[12, 22], [31, 43], [10, 49], [55, 54], [31, 54]]`. ```js assert.deepEqual( diff --git a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/sort-using-a-custom-comparator.md b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/sort-using-a-custom-comparator.md index e7e7919d0b..2ebf0f99a2 100644 --- a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/sort-using-a-custom-comparator.md +++ b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/sort-using-a-custom-comparator.md @@ -1,6 +1,6 @@ --- id: 5a23c84252665b21eecc8016 -title: Sort using a custom comparator +title: Ordina usando un comparatore personalizzato challengeType: 5 forumTopicId: 302309 dashedName: sort-using-a-custom-comparator @@ -8,17 +8,17 @@ dashedName: sort-using-a-custom-comparator # --description-- -Write a function to sort an array (or list) of strings in order of descending length, and in ascending lexicographic order for strings of equal length. +Scrivi una funzione per ordinare un array (o una lista) di stringhe in ordine di lunghezza decrescente, e in ordine lessicografico ascendente per stringhe di uguale lunghezza. # --hints-- -`lengthSorter` should be a function. +`lengthSorter` dovrebbe essere una funzione. ```js assert(typeof lengthSorter == 'function'); ``` -`lengthSorter(["Here", "are", "some", "sample", "strings", "to", "be", "sorted"])` should return an array. +`lengthSorter(["Here", "are", "some", "sample", "strings", "to", "be", "sorted"])` dovrebbe restituire un array. ```js assert( @@ -37,7 +37,7 @@ assert( ); ``` -`lengthSorter(["Here", "are", "some", "sample", "strings", "to", "be", "sorted"])` should return `["strings", "sample", "sorted", "Here", "some", "are", "be", "to"]`. +`lengthSorter(["Here", "are", "some", "sample", "strings", "to", "be", "sorted"])` dovrebbe restituire `["strings", "sample", "sorted", "Here", "some", "are", "be", "to"]`. ```js assert.deepEqual( @@ -55,7 +55,7 @@ assert.deepEqual( ); ``` -`lengthSorter(["I", "hope", "your", "day", "is", "going", "good", "?"])` should return `["going", "good", "hope", "your", "day", "is", "?","I"]`. +`lengthSorter(["I", "hope", "your", "day", "is", "going", "good", "?"])` dovrebbe restituire `["going", "good", "hope", "your", "day", "is", "?","I"]`. ```js assert.deepEqual( @@ -64,7 +64,7 @@ assert.deepEqual( ); ``` -`lengthSorter(["Mine", "is", "going", "great"])` should return `["going", "great", "Mine", "is"]`. +`lengthSorter(["Mine", "is", "going", "great"])` dovrebbe restituire `["going", "great", "Mine", "is"]`. ```js assert.deepEqual(lengthSorter(['Mine', 'is', 'going', 'great']), [ @@ -75,7 +75,7 @@ assert.deepEqual(lengthSorter(['Mine', 'is', 'going', 'great']), [ ]); ``` -`lengthSorter(["Have", "fun", "sorting", "!!"])` should return `["sorting", "Have", "fun", "!!"]`. +`lengthSorter(["Have", "fun", "sorting", "!!"])` dovrebbe restituire `["sorting", "Have", "fun", "!!"]`. ```js assert.deepEqual(lengthSorter(['Have', 'fun', 'sorting', '!!']), [ @@ -86,7 +86,7 @@ assert.deepEqual(lengthSorter(['Have', 'fun', 'sorting', '!!']), [ ]); ``` -`lengthSorter(["Everything", "is", "good", "!!"])` should return `["Everything", "good", "!!", "is"]`. +`lengthSorter(["Everything", "is", "good", "!!"])` dovrebbe restituire `["Everything", "good", "!!", "is"]`. ```js assert.deepEqual(lengthSorter(['Everything', 'is', 'good', '!!']), [ diff --git a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/sorting-algorithms-bead-sort.md b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/sorting-algorithms-bead-sort.md index 02b836f4de..4afa12b273 100644 --- a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/sorting-algorithms-bead-sort.md +++ b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/sorting-algorithms-bead-sort.md @@ -1,6 +1,6 @@ --- id: 5a23c84252665b21eecc8001 -title: Sorting algorithms/Bead sort +title: Algoritmi di ordinamento/Bead sort challengeType: 5 forumTopicId: 302310 dashedName: sorting-algorithmsbead-sort @@ -8,47 +8,47 @@ dashedName: sorting-algorithmsbead-sort # --description-- -Sort an array of positive integers using the [Bead Sort Algorithm](https://en.wikipedia.org/wiki/Bead_sort). +Ordina un array di interi positivi usando l'[Algoritmo di ordinamento Bead Sort](https://en.wikipedia.org/wiki/Bead_sort). -A *bead sort* is also known as a *gravity sort*. +Un *bead sort* è anche conosciuto come un *ordinamento per gravità*. -The algorithm has O(S), where S is the sum of the integers in the input set: Each bead is moved individually. +L'algoritmo ha complessità O(S), dove S è la somma degli interi nel set di ingresso: Ogni perla viene spostata singolarmente. -This is the case when bead sort is implemented without a mechanism to assist in finding empty spaces below the beads, such as in software implementations. +Questo è il caso in cui Bead Sort è implementato senza un meccanismo per aiutare a trovare spazi vuoti sotto le perle, ad esempio nelle implementazioni software. # --hints-- -`beadSort` should be a function. +`beadSort` dovrebbe essere una funzione. ```js assert(typeof beadSort == 'function'); ``` -`beadSort([25, 32, 12, 7, 20])` should return an array. +`beadSort([25, 32, 12, 7, 20])` dovrebbe restituire un array. ```js assert(Array.isArray(beadSort([25, 32, 12, 7, 20]))); ``` -`beadSort([25, 32, 12, 7, 20])` should return `[7, 12, 20, 25, 32]`. +`beadSort([25, 32, 12, 7, 20])` dovrebbe restituire `[7, 12, 20, 25, 32]`. ```js assert.deepEqual(beadSort([25, 32, 12, 7, 20]), [7, 12, 20, 25, 32]); ``` -`beadSort([38, 45, 35, 8, 13])` should return `[8, 13, 35, 38, 45]`. +`beadSort([38, 45, 35, 8, 13])` dovrebbe restituire `[8, 13, 35, 38, 45]`. ```js assert.deepEqual(beadSort([38, 45, 35, 8, 13]), [8, 13, 35, 38, 45]); ``` -`beadSort([43, 36, 20, 34, 24])` should return `[20, 24, 34, 36, 43]`. +`beadSort([43, 36, 20, 34, 24])` dovrebbe restituire `[20, 24, 34, 36, 43]`. ```js assert.deepEqual(beadSort([43, 36, 20, 34, 24]), [20, 24, 34, 36, 43]); ``` -`beadSort([12, 33, 26, 18, 1, 16, 38])` should return `[1, 12, 16, 18, 26, 33, 38]`. +`beadSort([12, 33, 26, 18, 1, 16, 38])` dovrebbe restituire `[1, 12, 16, 18, 26, 33, 38]`. ```js assert.deepEqual(beadSort([12, 33, 26, 18, 1, 16, 38]), [ @@ -62,7 +62,7 @@ assert.deepEqual(beadSort([12, 33, 26, 18, 1, 16, 38]), [ ]); ``` -`beadSort([3, 39, 48, 16, 1, 4, 29])` should return `[1, 3, 4, 16, 29, 39, 48]`. +`beadSort([3, 39, 48, 16, 1, 4, 29])` dovrebbe restituire `[1, 3, 4, 16, 29, 39, 48]`. ```js assert.deepEqual(beadSort([3, 39, 48, 16, 1, 4, 29]), [ diff --git a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/sorting-algorithms-bogosort.md b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/sorting-algorithms-bogosort.md index 2a7b74b5e3..93d15f30c7 100644 --- a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/sorting-algorithms-bogosort.md +++ b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/sorting-algorithms-bogosort.md @@ -1,6 +1,6 @@ --- id: 5a23c84252665b21eecc8002 -title: Sorting algorithms/Bogosort +title: Algoritmi di ordinamento/Bogosort challengeType: 5 forumTopicId: 302311 dashedName: sorting-algorithmsbogosort @@ -8,17 +8,17 @@ dashedName: sorting-algorithmsbogosort # --description-- -[Bogosort](https://en.wikipedia.org/wiki/Bogosort) a list of numbers. +[Bogosort](https://en.wikipedia.org/wiki/Bogosort) un elenco di numeri. -Bogosort simply shuffles a collection randomly until it is sorted. +Bogosort mescola semplicemente una raccolta in modo casuale fino a quando non viene ordinata. -"Bogosort" is a perversely inefficient algorithm only used as an in-joke. +"Bogosort" è un algoritmo perversamente inefficiente usato solo come presa in giro. -Its average run-time is O(n!) because the chance that any given shuffle of a set will end up in sorted order is about one in *n* factorial, and the worst case is infinite since there's no guarantee that a random shuffling will ever produce a sorted sequence. +La sua durata media è O(n!) perché la possibilità che qualsiasi mescolamento di un set finisca con un set ordinato è di circa uno su *n* fattoriale, e il caso peggiore è infinito dal momento che non c'è garanzia che un mescolamento casuale mai produrrà una sequenza ordinata. -Its best case is O(n) since a single pass through the elements may suffice to order them. +Il suo caso migliore è O(n) poiché un singolo passaggio attraverso gli elementi può essere sufficiente per ordinarli. -Pseudocode: +Pseudocodice:
while not InOrder(list) do
Shuffle(list)
@@ -27,37 +27,37 @@ Pseudocode:
# --hints--
-`bogosort` should be a function.
+`bogosort` dovrebbe essere una funzione.
```js
assert(typeof bogosort == 'function');
```
-`bogosort([25, 32, 12, 7, 20])` should return an array.
+`bogosort([25, 32, 12, 7, 20])` dovrebbe restituire un array.
```js
assert(Array.isArray(bogosort([25, 32, 12, 7, 20])));
```
-`bogosort([25, 32, 12, 7, 20])` should return `[7, 12, 20, 25, 32]`.
+`bogosort([25, 32, 12, 7, 20])` dovrebbe restituire `[7, 12, 20, 25, 32]`.
```js
assert.deepEqual(bogosort([25, 32, 12, 7, 20]), [7, 12, 20, 25, 32]);
```
-`bogosort([38, 45, 35, 8, 13])` should return `[8, 13, 35, 38, 45]`.
+`bogosort([38, 45, 35, 8, 13])` dovrebbe restituire `[8, 13, 35, 38, 45]`.
```js
assert.deepEqual(bogosort([38, 45, 35, 8, 13]), [8, 13, 35, 38, 45]);
```
-`bogosort([43, 36, 20, 34, 24])` should return `[20, 24, 34, 36, 43]`.
+`bogosort([43, 36, 20, 34, 24])` dovrebbe restituire `[20, 24, 34, 36, 43]`.
```js
assert.deepEqual(bogosort([43, 36, 20, 34, 24]), [20, 24, 34, 36, 43]);
```
-`bogosort([12, 33, 26, 18, 1, 16, 38])` should return `[1, 12, 16, 18, 26, 33, 38]`.
+`bogosort([12, 33, 26, 18, 1, 16, 38])` dovrebbe restituire `[1, 12, 16, 18, 26, 33, 38]`.
```js
assert.deepEqual(bogosort([12, 33, 26, 18, 1, 16, 38]), [
@@ -71,7 +71,7 @@ assert.deepEqual(bogosort([12, 33, 26, 18, 1, 16, 38]), [
]);
```
-`bogosort([3, 39, 48, 16, 1, 4, 29])` should return `[1, 3, 4, 16, 29, 39, 48]`.
+`bogosort([3, 39, 48, 16, 1, 4, 29])` dovrebbe restituire `[1, 3, 4, 16, 29, 39, 48]`.
```js
assert.deepEqual(bogosort([3, 39, 48, 16, 1, 4, 29]), [
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/sorting-algorithms-cocktail-sort.md b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/sorting-algorithms-cocktail-sort.md
index f4c1b63f68..55972f046d 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/sorting-algorithms-cocktail-sort.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/sorting-algorithms-cocktail-sort.md
@@ -1,6 +1,6 @@
---
id: 5a23c84252665b21eecc8004
-title: Sorting algorithms/Cocktail sort
+title: Algoritmi di Ordinamento/Cocktail Sort
challengeType: 5
forumTopicId: 302312
dashedName: sorting-algorithmscocktail-sort
@@ -8,7 +8,7 @@ dashedName: sorting-algorithmscocktail-sort
# --description--
-The cocktail shaker sort is an improvement on the [Bubble Sort](https://rosettacode.org/wiki/Bubble Sort). The improvement is basically that values "bubble" both directions through the array, because on each iteration the cocktail shaker sort bubble sorts once forwards and once backwards. Pseudocode for the algorithm (from [wikipedia](https://en.wikipedia.org/wiki/Cocktail sort)):
+L'algoritmo cocktail shaker sort è un miglioramento rispetto a [Bubble Sort](https://rosettacode.org/wiki/Bubble Sort). Il miglioramento è fondamentalmente che valuta "bolle" in entrambe le direzioni attraverso l'array, perché ad ogni iterazione il cocktail shaker ordina le bolle una volta avanti e una volta all'indietro. Pseudocodice per l'algoritmo (da [wikipedia](https://en.wikipedia.org/wiki/Cocktail sort)):
function cocktailSort( A : list of sortable items )
do
@@ -34,41 +34,41 @@ The cocktail shaker sort is an improvement on the [Bubble Sort](https://rosettac
# --instructions--
-Write a function that sorts a given array using cocktail sort.
+Scrivi una funzione che ordina un dato array usando cocktail sort.
# --hints--
-`cocktailSort` should be a function.
+`cocktailSort` dovrebbe essere una funzione.
```js
assert(typeof cocktailSort == 'function');
```
-`cocktailSort([25, 32, 12, 7, 20])` should return an array.
+`cocktailSort([25, 32, 12, 7, 20])` dovrebbe restituire un array.
```js
assert(Array.isArray(cocktailSort([25, 32, 12, 7, 20])));
```
-`cocktailSort([25, 32, 12, 7, 20])` should return `[7, 12, 20, 25, 32]`.
+`cocktailSort([25, 32, 12, 7, 20])` dovrebbe restituire `[7, 12, 20, 25, 32]`.
```js
assert.deepEqual(cocktailSort([25, 32, 12, 7, 20]), [7, 12, 20, 25, 32]);
```
-`cocktailSort([38, 45, 35, 8, 13])` should return `[8, 13, 35, 38, 45]`.
+`cocktailSort([38, 45, 35, 8, 13])` dovrebbe restituire `[8, 13, 35, 38, 45]`.
```js
assert.deepEqual(cocktailSort([38, 45, 35, 8, 13]), [8, 13, 35, 38, 45]);
```
-`cocktailSort([43, 36, 20, 34, 24])` should return `[20, 24, 34, 36, 43]`.
+`cocktailSort([43, 36, 20, 34, 24])` dovrebbe restituire `[20, 24, 34, 36, 43]`.
```js
assert.deepEqual(cocktailSort([43, 36, 20, 34, 24]), [20, 24, 34, 36, 43]);
```
-`cocktailSort([12, 33, 26, 18, 1, 16, 38])` should return `[1, 12, 16, 18, 26, 33, 38]`.
+`cocktailSort([12, 33, 26, 18, 1, 16, 38])` dovrebbe restituire `[1, 12, 16, 18, 26, 33, 38]`.
```js
assert.deepEqual(cocktailSort([12, 33, 26, 18, 1, 16, 38]), [
@@ -82,7 +82,7 @@ assert.deepEqual(cocktailSort([12, 33, 26, 18, 1, 16, 38]), [
]);
```
-`cocktailSort([3, 39, 48, 16, 1, 4, 29])` should return `[1, 3, 4, 16, 29, 39, 48]`.
+`cocktailSort([3, 39, 48, 16, 1, 4, 29])` dovrebbe restituire `[1, 3, 4, 16, 29, 39, 48]`.
```js
assert.deepEqual(cocktailSort([3, 39, 48, 16, 1, 4, 29]), [
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/sorting-algorithms-comb-sort.md b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/sorting-algorithms-comb-sort.md
index 472ce20af5..97bac56349 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/sorting-algorithms-comb-sort.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/sorting-algorithms-comb-sort.md
@@ -1,6 +1,6 @@
---
id: 5a23c84252665b21eecc8005
-title: Sorting algorithms/Comb sort
+title: Algoritmi di Ordinamento/Comb Sort
challengeType: 5
forumTopicId: 302313
dashedName: sorting-algorithmscomb-sort
@@ -8,30 +8,30 @@ dashedName: sorting-algorithmscomb-sort
# --description--
-Implement a *comb sort*.
+Implementa un *comb sort*.
-The **Comb Sort** is a variant of the [Bubble Sort](https://rosettacode.org/wiki/Bubble Sort).
+Il **Comb Sort** è una variante del [Bubble Sort](https://rosettacode.org/wiki/Bubble Sort).
-Like the [Shell sort](https://rosettacode.org/wiki/Shell sort), the Comb Sort increases the gap used in comparisons and exchanges.
+Come lo [Shell sort](https://rosettacode.org/wiki/Shell sort), il Comb Sort aumenta lo spazio utilizzato nei confronti e negli scambi.
-Dividing the gap by $(1-e^{-\\varphi})^{-1} \\approx 1.247330950103979$ works best, but 1.3 may be more practical.
+Dividere il divario per $(1-e^{-\\varphi})^{-1} \\ca. 1.247330950103979$ funziona meglio, ma 1.3 può essere più pratico.
-Some implementations use the insertion sort once the gap is less than a certain amount.
+Alcune implementazioni usano l'insertion sort una volta che il divario è inferiore a una certa quantità.
-**Also see**
+**Vedi anche**
-Variants:
+Varianti:
-
-
- Combsort11 makes sure the gap ends in (11, 8, 6, 4, 3, 2, 1), which is significantly faster than the other two possible endings. -
- Combsort with different endings changes to a more efficient sort when the data is almost sorted (when the gap is small). Comb sort with a low gap isn't much better than the Bubble Sort. +
- Combsort11 assicura che il divario finisca in (11, 8, 6, 4, 3, 2, 1), che è significativamente più veloce delle altre due possibili terminazioni. +
- Combsort con diversi terminali diventa un ordinamento più efficiente quando i dati sono quasi del tutto ordinati (quando il divario è piccolo). Combsort con un gap basso non è molto meglio di Bubble Sort.
function combsort(array input) gap := input.size //initialize gap size @@ -59,41 +59,41 @@ Pseudocode: # --instructions-- -Write a function that sorts a given array using Comb sort. +Scrivi una funzione che ordina un determinato array usando Combsort. # --hints-- -`combSort` should be a function. +`combSort` dovrebbe essere una funzione. ```js assert(typeof combSort == 'function'); ``` -`combSort([25, 32, 12, 7, 20])` should return an array. +`combSort([25, 32, 12, 7, 20])` dovrebbe restituire un array. ```js assert(Array.isArray(combSort([25, 32, 12, 7, 20]))); ``` -`combSort([25, 32, 12, 7, 20])` should return `[7, 12, 20, 25, 32]`. +`combSort([25, 32, 12, 7, 20])` dovrebbe restituire `[7, 12, 20, 25, 32]`. ```js assert.deepEqual(combSort([25, 32, 12, 7, 20]), [7, 12, 20, 25, 32]); ``` -`combSort([38, 45, 35, 8, 13])` should return `[8, 13, 35, 38, 45]`. +`combSort([38, 45, 35, 8, 13])` dovrebbe restituire `[8, 13, 35, 38, 45]`. ```js assert.deepEqual(combSort([38, 45, 35, 8, 13]), [8, 13, 35, 38, 45]); ``` -`combSort([43, 36, 20, 34, 24])` should return `[20, 24, 34, 36, 43]`. +`combSort([43, 36, 20, 34, 24])` dovrebbe restituire `[20, 24, 34, 36, 43]`. ```js assert.deepEqual(combSort([43, 36, 20, 34, 24]), [20, 24, 34, 36, 43]); ``` -`combSort([12, 33, 26, 18, 1, 16, 38])` should return `[1, 12, 16, 18, 26, 33, 38]`. +`combSort([12, 33, 26, 18, 1, 16, 38])` dovrebbe restituire `[1, 12, 16, 18, 26, 33, 38]`. ```js assert.deepEqual(combSort([12, 33, 26, 18, 1, 16, 38]), [ @@ -107,7 +107,7 @@ assert.deepEqual(combSort([12, 33, 26, 18, 1, 16, 38]), [ ]); ``` -`combSort([3, 39, 48, 16, 1, 4, 29])` should return `[1, 3, 4, 16, 29, 39, 48]`. +`combSort([3, 39, 48, 16, 1, 4, 29])` dovrebbe restituire `[1, 3, 4, 16, 29, 39, 48]`. ```js assert.deepEqual(combSort([3, 39, 48, 16, 1, 4, 29]), [ diff --git a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/sorting-algorithms-gnome-sort.md b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/sorting-algorithms-gnome-sort.md index e3162404d9..b5a934ede4 100644 --- a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/sorting-algorithms-gnome-sort.md +++ b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/sorting-algorithms-gnome-sort.md @@ -1,6 +1,6 @@ --- id: 5a23c84252665b21eecc8007 -title: Sorting algorithms/Gnome sort +title: Algoritmi di ordinamento/Gnome sort challengeType: 5 forumTopicId: 302314 dashedName: sorting-algorithmsgnome-sort @@ -8,9 +8,9 @@ dashedName: sorting-algorithmsgnome-sort # --description-- -Gnome sort is a sorting algorithm which is similar to [Insertion sort](https://rosettacode.org/wiki/Insertion sort), except that moving an element to its proper place is accomplished by a series of swaps, as in [Bubble Sort](https://rosettacode.org/wiki/Bubble Sort). +Gnome Sort è un algoritmo di ordinamento che è simile a [Insertion Sort](https://rosettacode.org/wiki/Insertion sort), tranne che lo spostamento di un elemento al suo posto corretto è realizzato da una serie di scambi, come in [Bubble Sort](https://rosettacode.org/wiki/Bubble Sort). -The pseudocode for the algorithm is: +Lo pseudocodice per l'algoritmo è:function gnomeSort(a[0..size-1]) i := 1 @@ -33,41 +33,41 @@ The pseudocode for the algorithm is: # --instructions-- -Write a function to implement the above pseudo code. The function should return the sorted array. +Scrivi una funzione che implementi lo pseudocodice di cui sopra. La funzione dovrebbe restituire l'array ordinato. # --hints-- -`gnomeSort` should be a function. +`gnomeSort` dovrebbe essere una funzione. ```js assert(typeof gnomeSort == 'function'); ``` -`gnomeSort([25, 32, 12, 7, 20])` should return an array. +`gnomeSort([25, 32, 12, 7, 20])` dovrebbe restituire un array. ```js assert(Array.isArray(gnomeSort([25, 32, 12, 7, 20]))); ``` -`gnomeSort([25, 32, 12, 7, 20])` should return `[7, 12, 20, 25, 32]`. +`gnomeSort([25, 32, 12, 7, 20])` dovrebbe restituire `[7, 12, 20, 25, 32]`. ```js assert.deepEqual(gnomeSort([25, 32, 12, 7, 20]), [7, 12, 20, 25, 32]); ``` -`gnomeSort([38, 45, 35, 8, 13])` should return `[8, 13, 35, 38, 45]`. +`gnomeSort([38, 45, 35, 8, 13])` dovrebbe restituire `[8, 13, 35, 38, 45]`. ```js assert.deepEqual(gnomeSort([38, 45, 35, 8, 13]), [8, 13, 35, 38, 45]); ``` -`gnomeSort([43, 36, 20, 34, 24])` should return `[20, 24, 34, 36, 43]`. +`gnomeSort([43, 36, 20, 34, 24])` dovrebbe restituire `[20, 24, 34, 36, 43]`. ```js assert.deepEqual(gnomeSort([43, 36, 20, 34, 24]), [20, 24, 34, 36, 43]); ``` -`gnomeSort([12, 33, 26, 18, 1, 16, 38])` should return `[1, 12, 16, 18, 26, 33, 38]`. +`gnomeSort([12, 33, 26, 18, 1, 16, 38])` dovrebbe restituire `[1, 12, 16, 18, 26, 33, 38]`. ```js assert.deepEqual(gnomeSort([12, 33, 26, 18, 1, 16, 38]), [ @@ -81,7 +81,7 @@ assert.deepEqual(gnomeSort([12, 33, 26, 18, 1, 16, 38]), [ ]); ``` -`gnomeSort([3, 39, 48, 16, 1, 4, 29])` should return `[1, 3, 4, 16, 29, 39, 48]`. +`gnomeSort([3, 39, 48, 16, 1, 4, 29])` dovrebbe restituire `[1, 3, 4, 16, 29, 39, 48]`. ```js assert.deepEqual(gnomeSort([3, 39, 48, 16, 1, 4, 29]), [ diff --git a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/sorting-algorithms-pancake-sort.md b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/sorting-algorithms-pancake-sort.md index f107df7b79..c26ece3359 100644 --- a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/sorting-algorithms-pancake-sort.md +++ b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/sorting-algorithms-pancake-sort.md @@ -1,6 +1,6 @@ --- id: 5a23c84252665b21eecc800b -title: Sorting algorithms/Pancake sort +title: Algoritmi di ordinamento/Pancake sort challengeType: 5 forumTopicId: 302315 dashedName: sorting-algorithmspancake-sort @@ -8,51 +8,51 @@ dashedName: sorting-algorithmspancake-sort # --description-- -Write a function to sort an array of integers (of any convenient size) into ascending order using [Pancake sorting](https://en.wikipedia.org/wiki/Pancake sorting). The function should return the sorted array. +Scrivi una funzione per ordinare un array di interi (di qualsiasi dimensione conveniente) in ordine crescente usando [Pancake sorting](https://en.wikipedia.org/wiki/Pancake sorting). La funzione dovrebbe restituire l'array ordinato. -In short, instead of individual elements being sorted, the only operation allowed is to "flip" one end of the list, like so: +In breve, invece di ordinare singoli elementi, l'unica operazione consentita è quella di "capovolgere" una estremità della lista in questo modo: -Before: +Prima: 6 7 8 9 2 5 3 4 1-Only one end of the list can be flipped; this should be the low end, but the high end is okay if it's easier to code or works better, but it **must** be the same end for the entire solution. (The end flipped can't be arbitrarily changed.) +Solo una fine della lista può essere capovolta; questa dovrebbe essere l'estremità di valore più basso, ma l'estremità alta va comunque bene se è più facile da codificare o funziona meglio, ma essa **deve** essere la stessa estremità per l'intera soluzione. (L'estremità capovolta non può essere cambiata arbitrariamente.) # --hints-- -`pancakeSort` should be a function. +`pancakeSort` dovrebbe essere una funzione. ```js assert(typeof pancakeSort == 'function'); ``` -`pancakeSort([25, 32, 12, 7, 20])` should return an array. +`pancakeSort([25, 32, 12, 7, 20])` dovrebbe restituire un array. ```js assert(Array.isArray(pancakeSort([25, 32, 12, 7, 20]))); ``` -`pancakeSort([25, 32, 12, 7, 20])` should return `[7, 12, 20, 25, 32]`. +`pancakeSort([25, 32, 12, 7, 20])` dovrebbe restituire `[7, 12, 20, 25, 32]`. ```js assert.deepEqual(pancakeSort([25, 32, 12, 7, 20]), [7, 12, 20, 25, 32]); ``` -`pancakeSort([38, 45, 35, 8, 13])` should return `[8, 13, 35, 38, 45]`. +`pancakeSort([38, 45, 35, 8, 13])` dovrebbe restituire `[8, 13, 35, 38, 45]`. ```js assert.deepEqual(pancakeSort([38, 45, 35, 8, 13]), [8, 13, 35, 38, 45]); ``` -`pancakeSort([43, 36, 20, 34, 24])` should return `[20, 24, 34, 36, 43]`. +`pancakeSort([43, 36, 20, 34, 24])` dovrebbe restituire `[20, 24, 34, 36, 43]`. ```js assert.deepEqual(pancakeSort([43, 36, 20, 34, 24]), [20, 24, 34, 36, 43]); ``` -`pancakeSort([12, 33, 26, 18, 1, 16, 38])` should return `[1, 12, 16, 18, 26, 33, 38]`. +`pancakeSort([12, 33, 26, 18, 1, 16, 38])` dovrebbe restituire `[1, 12, 16, 18, 26, 33, 38]`. ```js assert.deepEqual(pancakeSort([12, 33, 26, 18, 1, 16, 38]), [ @@ -66,7 +66,7 @@ assert.deepEqual(pancakeSort([12, 33, 26, 18, 1, 16, 38]), [ ]); ``` -`pancakeSort([3, 39, 48, 16, 1, 4, 29])` should return `[1, 3, 4, 16, 29, 39, 48]`. +`pancakeSort([3, 39, 48, 16, 1, 4, 29])` dovrebbe restituire `[1, 3, 4, 16, 29, 39, 48]`. ```js assert.deepEqual(pancakeSort([3, 39, 48, 16, 1, 4, 29]), [ diff --git a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/sorting-algorithms-permutation-sort.md b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/sorting-algorithms-permutation-sort.md index d5fc1e3b08..66c25a47a2 100644 --- a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/sorting-algorithms-permutation-sort.md +++ b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/sorting-algorithms-permutation-sort.md @@ -1,6 +1,6 @@ --- id: 5a23c84252665b21eecc800c -title: Sorting algorithms/Permutation sort +title: Algoritmi di ordinamento/Permutation sort challengeType: 5 forumTopicId: 302316 dashedName: sorting-algorithmspermutation-sort @@ -8,9 +8,9 @@ dashedName: sorting-algorithmspermutation-sort # --description-- -Write a function to implement a permutation sort, which proceeds by generating the possible permutations of the input array until discovering the sorted one. The function should return the sorted array. +Scrivere una funzione per implementare un ordinamento a permutazione, che procede generando le possibili permutazioni dell'array di input fino a trovare quello ordinato. La funzione dovrebbe restituire l'array ordinato. -Pseudocode: +Pseudocodice:
-After: +Dopo: 9 8 7 6 2 5 3 4 1while not InOrder(list) do nextPermutation(list) @@ -19,37 +19,37 @@ Pseudocode: # --hints-- -`permutationSort` should be a function. +`permutationSort` dovrebbe essere una funzione. ```js assert(typeof permutationSort == 'function'); ``` -`permutationSort([25, 32, 12, 7, 20])` should return an array. +`permutationSort([25, 32, 12, 7, 20])` dovrebbe restituire un array. ```js assert(Array.isArray(permutationSort([25, 32, 12, 7, 20]))); ``` -`permutationSort([25, 32, 12, 7, 20])` should return `[7, 12, 20, 25, 32]`. +`permutationSort([25, 32, 12, 7, 20])` dovrebbe restituire `[7, 12, 20, 25, 32]`. ```js assert.deepEqual(permutationSort([25, 32, 12, 7, 20]), [7, 12, 20, 25, 32]); ``` -`permutationSort([38, 45, 35, 8, 13])` should return `[8, 13, 35, 38, 45]`. +`permutationSort([38, 45, 35, 8, 13])` dovrebbe restituire `[8, 13, 35, 38, 45]`. ```js assert.deepEqual(permutationSort([38, 45, 35, 8, 13]), [8, 13, 35, 38, 45]); ``` -`permutationSort([43, 36, 20, 34, 24])` should return `[20, 24, 34, 36, 43]`. +`permutationSort([43, 36, 20, 34, 24])` dovrebbe restituire `[20, 24, 34, 36, 43]`. ```js assert.deepEqual(permutationSort([43, 36, 20, 34, 24]), [20, 24, 34, 36, 43]); ``` -`permutationSort([12, 33, 26, 18, 1, 16, 38])` should return `[1, 12, 16, 18, 26, 33, 38]`. +`permutationSort([12, 33, 26, 18, 1, 16, 38])` dovrebbe restituire `[1, 12, 16, 18, 26, 33, 38]`. ```js assert.deepEqual(permutationSort([12, 33, 26, 18, 1, 16, 38]), [ @@ -63,7 +63,7 @@ assert.deepEqual(permutationSort([12, 33, 26, 18, 1, 16, 38]), [ ]); ``` -`permutationSort([3, 39, 48, 16, 1, 4, 29])` should return `[1, 3, 4, 16, 29, 39, 48]`. +`permutationSort([3, 39, 48, 16, 1, 4, 29])` dovrebbe restituire `[1, 3, 4, 16, 29, 39, 48]`. ```js assert.deepEqual(permutationSort([3, 39, 48, 16, 1, 4, 29]), [ diff --git a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/sorting-algorithms-shell-sort.md b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/sorting-algorithms-shell-sort.md index 0940344732..ac563baee4 100644 --- a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/sorting-algorithms-shell-sort.md +++ b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/sorting-algorithms-shell-sort.md @@ -1,6 +1,6 @@ --- id: 5a23c84252665b21eecc8010 -title: Sorting algorithms/Shell sort +title: Algoritmi di ordinamento/Shell Sort challengeType: 5 forumTopicId: 302317 dashedName: sorting-algorithmsshell-sort @@ -8,51 +8,51 @@ dashedName: sorting-algorithmsshell-sort # --description-- -Write a function to sort an array of elements using the [Shell sort](https://en.wikipedia.org/wiki/Shell sort) algorithm, a diminishing increment sort. The function should return the sorted array. +Scrivi una funzione per ordinare un array di elementi usando l'algoritmo [Shell sort](https://en.wikipedia.org/wiki/Shell sort), un tipo di ordinamento a incremento in diminuzione. La funzione dovrebbe restituire l'array ordinato. -The Shell sort (also known as Shellsort or Shell's method) is named after its inventor, Donald Shell, who published the algorithm in 1959. +Shell Short (noto anche come metodo di Shellsort o Shell) prende il nome dal suo inventore, Donald Shell, che ha pubblicato l'algoritmo nel 1959. -Shell sort is a sequence of interleaved insertion sorts based on an increment sequence. The increment size is reduced after each pass until the increment size is 1. +Shell Sort è una sequenza di Insertion Sort intercalati basata su una sequenza di incremento. La dimensione dell'incremento viene ridotta dopo ogni passaggio fino a quando la dimensione dell'incremento è 1. -With an increment size of 1, the sort is a basic insertion sort, but by this time the data is guaranteed to be almost sorted, which is insertion sort's "best case". +Con un incremento della dimensione di 1, l'ordinamento è un classico Insertion Sort, ma per questo esercizio i dati sono garantiti essere quasi ordinati, che è il "caso migliore" per Insertion Sort. -Any sequence will sort the data as long as it ends in 1, but some work better than others. +Qualsiasi sequenza ordinerà i dati finché terminerà in 1, ma alcune funzionano meglio di altre. -Empirical studies have shown a geometric increment sequence with a ratio of about 2.2 work well in practice. +Studi empirici hanno mostrato che una sequenza geometrica di incremento con un rapporto di circa 2.2 funziona bene nella pratica. # --hints-- -`shellSort` should be a function. +`shellSort` dovrebbe essere una funzione. ```js assert(typeof shellSort == 'function'); ``` -`shellSort([25, 32, 12, 7, 20])` should return an array. +`shellSort([25, 32, 12, 7, 20])` dovrebbe restituire un array. ```js assert(Array.isArray(shellSort([25, 32, 12, 7, 20]))); ``` -`shellSort([25, 32, 12, 7, 20])` should return `[7, 12, 20, 25, 32]`. +`shellSort([25, 32, 12, 7, 20])` dovrebbe restituire `[7, 12, 20, 25, 32]`. ```js assert.deepEqual(shellSort([25, 32, 12, 7, 20]), [7, 12, 20, 25, 32]); ``` -`shellSort([38, 45, 35, 8, 13])` should return `[8, 13, 35, 38, 45]`. +`shellSort([38, 45, 35, 8, 13])` dovrebbe restituire `[8, 13, 35, 38, 45]`. ```js assert.deepEqual(shellSort([38, 45, 35, 8, 13]), [8, 13, 35, 38, 45]); ``` -`shellSort([43, 36, 20, 34, 24])` should return `[20, 24, 34, 36, 43]`. +`shellSort([43, 36, 20, 34, 24])` dovrebbe restituire `[20, 24, 34, 36, 43]`. ```js assert.deepEqual(shellSort([43, 36, 20, 34, 24]), [20, 24, 34, 36, 43]); ``` -`shellSort([12, 33, 26, 18, 1, 16, 38])` should return `[1, 12, 16, 18, 26, 33, 38]`. +`shellSort([12, 33, 26, 18, 1, 16, 38])` dovrebbe restituire `[1, 12, 16, 18, 26, 33, 38]`. ```js assert.deepEqual(shellSort([12, 33, 26, 18, 1, 16, 38]), [ @@ -66,7 +66,7 @@ assert.deepEqual(shellSort([12, 33, 26, 18, 1, 16, 38]), [ ]); ``` -`shellSort([3, 39, 48, 16, 1, 4, 29])` should return `[1, 3, 4, 16, 29, 39, 48]`. +`shellSort([3, 39, 48, 16, 1, 4, 29])` dovrebbe restituire `[1, 3, 4, 16, 29, 39, 48]`. ```js assert.deepEqual(shellSort([3, 39, 48, 16, 1, 4, 29]), [ diff --git a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/sorting-algorithms-stooge-sort.md b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/sorting-algorithms-stooge-sort.md index ec108886c1..9063d2cc28 100644 --- a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/sorting-algorithms-stooge-sort.md +++ b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/sorting-algorithms-stooge-sort.md @@ -1,6 +1,6 @@ --- id: 5a23c84252665b21eecc8012 -title: Sorting algorithms/Stooge sort +title: Algoritmi di Ordinamento/Stooge Sort challengeType: 5 forumTopicId: 302318 dashedName: sorting-algorithmsstooge-sort @@ -8,9 +8,9 @@ dashedName: sorting-algorithmsstooge-sort # --description-- -Write a function to perform [Stooge Sort](https://en.wikipedia.org/wiki/Stooge sort) on an array of integers. The function should return a sorted array. +Scrivi una funzione per eseguire lo [Stooge Sort](https://it.wikipedia.org/wiki/Trippel_sort) su un array di interi. La funzione dovrebbe restituire un array ordinato. -The Stooge Sort algorithm is as follows: +L'algoritmo Stooge Sort è il seguente:algorithm stoogesort(array L, i = 0, j = length(L)-1) if L[j] < L[i] then @@ -25,37 +25,37 @@ The Stooge Sort algorithm is as follows: # --hints-- -`stoogeSort` should be a function. +`stoogeSort` dovrebbe essere una funzione. ```js assert(typeof stoogeSort == 'function'); ``` -`stoogeSort([25, 32, 12, 7, 20])` should return an array. +`stoogeSort([25, 32, 12, 7, 20])` dovrebbe restituire un array. ```js assert(Array.isArray(stoogeSort([25, 32, 12, 7, 20]))); ``` -`stoogeSort([25, 32, 12, 7, 20])` should return `[7, 12, 20, 25, 32]`. +`stoogeSort([25, 32, 12, 7, 20])` dovrebbe restituire `[7, 12, 20, 25, 32]`. ```js assert.deepEqual(stoogeSort([25, 32, 12, 7, 20]), [7, 12, 20, 25, 32]); ``` -`stoogeSort([38, 45, 35, 8, 13])` should return `[8, 13, 35, 38, 45]`. +`stoogeSort([38, 45, 35, 8, 13])` dovrebbe restituire `[8, 13, 35, 38, 45]`. ```js assert.deepEqual(stoogeSort([38, 45, 35, 8, 13]), [8, 13, 35, 38, 45]); ``` -`stoogeSort([43, 36, 20, 34, 24])` should return `[20, 24, 34, 36, 43]`. +`stoogeSort([43, 36, 20, 34, 24])` dovrebbe restituire `[20, 24, 34, 36, 43]`. ```js assert.deepEqual(stoogeSort([43, 36, 20, 34, 24]), [20, 24, 34, 36, 43]); ``` -`stoogeSort([12, 33, 26, 18, 1, 16, 38])` should return `[1, 12, 16, 18, 26, 33, 38]`. +`stoogeSort([12, 33, 26, 18, 1, 16, 38])` dovrebbe restituire `[1, 12, 16, 18, 26, 33, 38]`. ```js assert.deepEqual(stoogeSort([12, 33, 26, 18, 1, 16, 38]), [ @@ -69,7 +69,7 @@ assert.deepEqual(stoogeSort([12, 33, 26, 18, 1, 16, 38]), [ ]); ``` -`stoogeSort([3, 39, 48, 16, 1, 4, 29])` should return `[1, 3, 4, 16, 29, 39, 48]`. +`stoogeSort([3, 39, 48, 16, 1, 4, 29])` dovrebbe restituire `[1, 3, 4, 16, 29, 39, 48]`. ```js assert.deepEqual(stoogeSort([3, 39, 48, 16, 1, 4, 29]), [ diff --git a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/sorting-algorithms-strand-sort.md b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/sorting-algorithms-strand-sort.md index d8408782db..dc9ed4ec6b 100644 --- a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/sorting-algorithms-strand-sort.md +++ b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/sorting-algorithms-strand-sort.md @@ -1,6 +1,6 @@ --- id: 5a23c84252665b21eecc8013 -title: Sorting algorithms/Strand sort +title: Algoritmi di ordinamento/Strand sort challengeType: 5 forumTopicId: 302319 dashedName: sorting-algorithmsstrand-sort @@ -8,43 +8,43 @@ dashedName: sorting-algorithmsstrand-sort # --description-- -Write a function to sort an array using the [Strand sort](https://en.wikipedia.org/wiki/Strand sort). The function should return the sorted array. +Scrivi una funzione per ordinare un array usando l'ordinamento [Strand sort](https://en.wikipedia.org/wiki/Strand sort). La funzione dovrebbe restituire l'array ordinato. -This is a way of sorting numbers by extracting shorter sequences of already sorted numbers from an unsorted list. +Questo è un modo di ordinare i numeri estraendo sequenze più brevi di numeri già ordinati da un elenco non ordinato. # --hints-- -`strandSort` should be a function. +`strandSort` dovrebbe essere una funzione. ```js assert(typeof strandSort == 'function'); ``` -`strandSort([25, 32, 12, 7, 20])` should return an array. +`strandSort([25, 32, 12, 7, 20])` dovrebbe restituire un array. ```js assert(Array.isArray(strandSort([25, 32, 12, 7, 20]))); ``` -`strandSort([25, 32, 12, 7, 20])` should return `[7, 12, 20, 25, 32]`. +`strandSort([25, 32, 12, 7, 20])` dovrebbe restituire `[7, 12, 20, 25, 32]`. ```js assert.deepEqual(strandSort([25, 32, 12, 7, 20]), [7, 12, 20, 25, 32]); ``` -`strandSort([38, 45, 35, 8, 13])` should return `[8, 13, 35, 38, 45]`. +`strandSort([38, 45, 35, 8, 13])` dovrebbe restituire `[8, 13, 35, 38, 45]`. ```js assert.deepEqual(strandSort([38, 45, 35, 8, 13]), [8, 13, 35, 38, 45]); ``` -`strandSort([43, 36, 20, 34, 24])` should return `[20, 24, 34, 36, 43]`. +`strandSort([43, 36, 20, 34, 24])` dovrebbe restituire `[20, 24, 34, 36, 43]`. ```js assert.deepEqual(strandSort([43, 36, 20, 34, 24]), [20, 24, 34, 36, 43]); ``` -`strandSort([12, 33, 26, 18, 1, 16, 38])` should return `[1, 12, 16, 18, 26, 33, 38]`. +`strandSort([12, 33, 26, 18, 1, 16, 38])` dovrebbe restituire `[1, 12, 16, 18, 26, 33, 38]`. ```js assert.deepEqual(strandSort([12, 33, 26, 18, 1, 16, 38]), [ @@ -58,7 +58,7 @@ assert.deepEqual(strandSort([12, 33, 26, 18, 1, 16, 38]), [ ]); ``` -`strandSort([3, 39, 48, 16, 1, 4, 29])` should return `[1, 3, 4, 16, 29, 39, 48]`. +`strandSort([3, 39, 48, 16, 1, 4, 29])` dovrebbe restituire `[1, 3, 4, 16, 29, 39, 48]`. ```js assert.deepEqual(strandSort([3, 39, 48, 16, 1, 4, 29]), [ diff --git a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/soundex.md b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/soundex.md index b7574b3837..5e8bc3b474 100644 --- a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/soundex.md +++ b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/soundex.md @@ -8,86 +8,86 @@ dashedName: soundex # --description-- -Soundex is an algorithm for creating indices for words based on their pronunciation. The goal is for homophones to be encoded to the same representation so that they can be matched despite minor differences in spelling (from [the WP article](https://en.wikipedia.org/wiki/soundex)). There is a major issue in many of the implementations concerning the separation of two consonants that have the same soundex code! According to the [official Rules](https://www.archives.gov/research/census/soundex.html). So check for instance if **Ashcraft** is coded to **A-261**. +Soundex è un algoritmo per creare indici per le parole basato sulla loro pronuncia. L'obbiettivo è avere gli omofoni codificati alla stessa rappresentazione così che possano essere combaciati nonostante piccole differenze di ortografia (dall'[articolo di Wikipedia](https://en.wikipedia.org/wiki/soundex)). C'è un problema importante in molte delle implementazioni riguardanti la separazione di due consonanti che hanno lo stesso codice soundex! In accordo con le [regole ufficiali](https://www.archives.gov/research/census/soundex.html). Quindi controlla se per esempio **Ashcraft** è codificato a **A-261**.
-
-
- If a vowel (A, E, I, O, U) separates two consonants that have the same soundex code, the consonant to the right of the vowel is coded. Tymczak is coded as T-522 (T, 5 for the M, 2 for the C, Z ignored (see "Side-by-Side" rule above), 2 for the K). Since the vowel "A" separates the Z and K, the K is coded. -
- If "H" or "W" separate two consonants that have the same soundex code, the consonant to the right of the vowel is not coded. Example: Ashcraft is coded A-261 (A, 2 for the S, C ignored, 6 for the R, 1 for the F). It is not coded A-226. +
- Se una vocale (A, E, I, O, U) separata due consonanti che hanno lo stesso codice soundex, la consonante a destra della vocale è codificata. Tymczak è codificato come T-522 (T, 5 per M, 2 per C, Z ignorata (vedi regola "Fianco-a-fianco" qua sopra), 2 per K). Visto che la "A" separa la Z e la K, la K è codificata. +
- Se "H" o "W" separano due consonanti che hanno lo stesso codice soundex, la consonante alla destra della vocale non è codificata. Per esempio: Ashcraft è codificato come A-261 (A, 2 per S, C ignorata, 6 per R, 1 per F). Non è codificata come A-226.
0 1 2 3 4 @@ -20,19 +20,19 @@ Produce a spiral array. A *spiral array* is a square arrangement of the first N< # --hints-- -`spiralArray` should be a function. +`spiralArray` dovrebbe essere una funzione. ```js assert(typeof spiralArray == 'function'); ``` -`spiralArray(3)` should return an array. +`spiralArray(3)` dovrebbe restituire un array. ```js assert(Array.isArray(spiralArray(3))); ``` -`spiralArray(3)` should return `[[0, 1, 2],[7, 8, 3],[6, 5, 4]]`. +`spiralArray(3)` dovrebbe restituire `[[0, 1, 2],[7, 8, 3],[6, 5, 4]]`. ```js assert.deepEqual(spiralArray(3), [ @@ -42,7 +42,7 @@ assert.deepEqual(spiralArray(3), [ ]); ``` -`spiralArray(4)` should return `[[0, 1, 2, 3],[11, 12, 13, 4],[10, 15, 14, 5],[9, 8, 7, 6]]`. +`spiralArray(4)` dovrebbe restituire `[[0, 1, 2, 3],[11, 12, 13, 4],[10, 15, 14, 5],[9, 8, 7, 6]]`. ```js assert.deepEqual(spiralArray(4), [ @@ -53,7 +53,7 @@ assert.deepEqual(spiralArray(4), [ ]); ``` -`spiralArray(5)` should return `[[0, 1, 2, 3, 4],[15, 16, 17, 18, 5],[14, 23, 24, 19, 6],[13, 22, 21, 20, 7],[12, 11, 10, 9, 8]]`. +`spiralArray(5)` dovrebbe restituire `[[0, 1, 2, 3, 4],[15, 16, 17, 18, 5],[14, 23, 24, 19, 6],[13, 22, 21, 20, 7],[12, 11, 10, 9, 8]]`. ```js assert.deepEqual(spiralArray(5), [ diff --git a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/split-a-character-string-based-on-change-of-character.md b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/split-a-character-string-based-on-change-of-character.md index 4bb28fba9a..b48c1eda92 100644 --- a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/split-a-character-string-based-on-change-of-character.md +++ b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/split-a-character-string-based-on-change-of-character.md @@ -1,6 +1,6 @@ --- id: 5a23c84252665b21eecc801d -title: Split a character string based on change of character +title: Dividi una stringa di caratteri in base al cambiamento di carattere challengeType: 5 forumTopicId: 302322 dashedName: split-a-character-string-based-on-change-of-character @@ -8,13 +8,13 @@ dashedName: split-a-character-string-based-on-change-of-character # --description-- -Split a (character) string into comma (plus a blank) delimited strings based on a change of character (left to right). Blanks should be treated as any other character (except they are problematic to display clearly). The same applies to commas. For instance, the string: +Dividere una stringa di caratteri in stringhe delimitate da virgola (più uno spazio bianco) in base a un cambiamento di carattere (da sinistra a destra). Gli spazi vuoti devono essere trattati come qualsiasi altro carattere (tranne per il fatto che sono problematici da visualizzare chiaramente). Lo stesso vale per le virgole. Per esempio, la stringa:"gHHH5YY++///\\"-should be split as: +dovrebbe essere diviso come:["g", "HHH", "5", "YY", "++", "///", "\\" ]; @@ -22,25 +22,25 @@ should be split as: # --hints-- -`split` should be a function. +`split` dovrebbe essere una funzione. ```js assert(typeof split == 'function'); ``` -`split("hello")` should return an array. +`split("hello")` dovrebbe restituire un array. ```js assert(Array.isArray(split('hello'))); ``` -`split("hello")` should return `["h", "e", "ll", "o"]`. +`split("hello")` dovrebbe restituire `["h", "e", "ll", "o"]`. ```js assert.deepEqual(split('hello'), ['h', 'e', 'll', 'o']); ``` -`split("commission")` should return `["c", "o", "mm", "i", "ss", "i", "o", "n"]`. +`split("commission")` dovrebbe restituire `["c", "o", "mm", "i", "ss", "i", "o", "n"]`. ```js assert.deepEqual(split('commission'), [ @@ -55,7 +55,7 @@ assert.deepEqual(split('commission'), [ ]); ``` -`split("ssss----====llloooo")` should return `["ssss", "----", "====", "lll", "oooo"]`. +`split("ssss----====llloooo")` dovrebbe restituire `["ssss", "----", "====", "lll", "oooo"]`. ```js assert.deepEqual(split('ssss----====llloooo'), [ @@ -67,7 +67,7 @@ assert.deepEqual(split('ssss----====llloooo'), [ ]); ``` -`split("sssmmmaaammmaaat")` should return `["sss", "mmm", "aaa", "mmm", "aaa", "t"]`. +`split("sssmmmaaammmaaat")` dovrebbe restituire `["sss", "mmm", "aaa", "mmm", "aaa", "t"]`. ```js assert.deepEqual(split('sssmmmaaammmaaat'), [ @@ -80,7 +80,7 @@ assert.deepEqual(split('sssmmmaaammmaaat'), [ ]); ``` -`split("gHHH5YY++///\\")` should return `["g", "HHH", "5", "YY", "++", "///", "\\"]`. +`split("gHHH5YY++///\\")` dovrebbe restituire `["g", "HHH", "5", "YY", "++", "///", "\\"]`. ```js assert.deepEqual(split('gHHH5YY++///\\'), [ diff --git a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/state-name-puzzle.md b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/state-name-puzzle.md index d22ef19220..a0f652d3f9 100644 --- a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/state-name-puzzle.md +++ b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/state-name-puzzle.md @@ -1,6 +1,6 @@ --- id: 5a23c84252665b21eecc8024 -title: State name puzzle +title: Puzzle sui nomi degli Stati challengeType: 5 forumTopicId: 302323 dashedName: state-name-puzzle @@ -8,21 +8,21 @@ dashedName: state-name-puzzle # --description-- -This task is inspired by Mark Nelson's DDJ Column "Wordplay" and one of the weekly puzzle challenges from Will Shortz on NPR Weekend Edition [\[1\]](https://www.npr.org/templates/story/story.php?storyId=9264290) and originally attributed to 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. +Questo compito è ispirato dalla colonna DDJ di Mark Nelson "Wordplay" e una delle sfide del puzzle settimanale da Will Shortz sulla NPR Weekend Edition [\[1\]](https://www.npr.org/templates/story/story.php?storyId=9264290) e originariamente attribuito a David Edelheit. La sfida è di prendere i nomi di due stati dell'USA, mischiarli, poi riarrangiare le lettere per formare i nomi di due *diversi* stati dell'USA (così da avere 4 nomi di stati diversi). Quali sono questi Stati? Il problema è stato ristampato su [Unicon Discussion Web](https://tapestry.tucson.az.us/twiki/bin/view/Main/StateNamesPuzzle) che include diverse soluzioni con analisi. Diverse tecniche possono essere utili e potresti voler fare riferimento a [ Gödel numbering](https://en.wikipedia.org/wiki/Goedel_numbering), [relazioni di equivalenza](https://en.wikipedia.org/wiki/Equivalence_relation), e [classi di equivalenza](https://en.wikipedia.org/wiki/Equivalence_classes). I meriti fondamentali di questi sono stati discussi nell'Unicon Discussion Web. È stata presentata anche una seconda sfida sotto forma di una serie di nuovi Stati fittizi. # --instructions-- -Write a function to solve the challenge for the given array of names of states. The function should return an array. Each element should be an object in this form: `{"from":[],"to":[]}`. The "from" array should contain the original names and the "to" array should contain the resultant names. +Scrivere una funzione per risolvere la sfida per la gamma data di nomi di Stati. La funzione dovrebbe restituire un array. Ogni elemento deve essere un oggetto in questa forma: `{"from":[],"to":[]}`. L'array "from" dovrebbe contenere i nomi originali e l'array "to" dovrebbe contenere i nomi risultanti. # --hints-- -`solve` should be a function. +`solve` dovrebbe essere una funzione. ```js assert(typeof solve == 'function'); ``` -`solve(["New Mexico", "New York", "North Carolina ", "North Dakota", "Ohio", "Oklahoma", "Oregon", "Pennsylvania", "Rhode Island", "South Carolina", "South Dakota"])` should return an array. +`solve(["New Mexico", "New York", "North Carolina ", "North Dakota", "Ohio", "Oklahoma", "Oregon", "Pennsylvania", "Rhode Island", "South Carolina", "South Dakota"])` dovrebbe restituire un array. ```js assert( @@ -44,7 +44,7 @@ assert( ); ``` -`solve(["New Mexico", "New York", "North Carolina ", "North Dakota", "Ohio", "Oklahoma", "Oregon", "Pennsylvania", "Rhode Island", "South Carolina", "South Dakota"])` should return `[{ from: ["North Carolina ", "South Dakota"], to: ["North Dakota", "South Carolina"] }]`. +`solve(["New Mexico", "New York", "North Carolina ", "North Dakota", "Ohio", "Oklahoma", "Oregon", "Pennsylvania", "Rhode Island", "South Carolina", "South Dakota"])` dovrebbe restituire `[{ from: ["North Carolina ", "South Dakota"], to: ["North Dakota", "South Carolina"] }]`. ```js assert.deepEqual( @@ -70,7 +70,7 @@ assert.deepEqual( ); ``` -`solve(["New York", "New Kory", "Wen Kory", "York New", "Kory New", "New Kory"])` should return `[{ from: ["New Kory", "New York"], to: ["Wen Kory", "York New"] }, { from: ["New Kory", "New York"], to: ["Kory New", "Wen Kory"] }, { from: ["New Kory", "New York"], to: ["Kory New", "York New"] }, { from: ["New York", "Wen Kory"], to: ["New Kory", "York New"] }, { from: ["New York", "Wen Kory"], to: ["Kory New", "New Kory"] }, { from: ["New York", "Wen Kory"], to: ["Kory New", "York New"] }, { from: ["New York", "York New"], to: ["New Kory", "Wen Kory"] }, { from: ["New York", "York New"], to: ["Kory New", "New Kory"] }, { from: ["New York", "York New"], to: ["Kory New", "Wen Kory"] }, { from: ["Kory New", "New York"], to: ["New Kory", "Wen Kory"] }, { from: ["Kory New", "New York"], to: ["New Kory", "York New"] }, { from: ["Kory New", "New York"], to: ["Wen Kory", "York New"] }, { from: ["New Kory", "Wen Kory"], to: ["Kory New", "York New"] }, { from: ["New Kory", "York New"], to: ["Kory New", "Wen Kory"] }, { from: ["Kory New", "New Kory"], to: ["Wen Kory", "York New"] }]`. +`solve(["New York", "New Kory", "Wen Kory", "York New", "Kory New", "New Kory"])` dovrebbe restituire `[{ from: ["New Kory", "New York"], to: ["Wen Kory", "York New"] }, { from: ["New Kory", "New York"], to: ["Kory New", "Wen Kory"] }, { from: ["New Kory", "New York"], to: ["Kory New", "York New"] }, { from: ["New York", "Wen Kory"], to: ["New Kory", "York New"] }, { from: ["New York", "Wen Kory"], to: ["Kory New", "New Kory"] }, { from: ["New York", "Wen Kory"], to: ["Kory New", "York New"] }, { from: ["New York", "York New"], to: ["New Kory", "Wen Kory"] }, { from: ["New York", "York New"], to: ["Kory New", "New Kory"] }, { from: ["New York", "York New"], to: ["Kory New", "Wen Kory"] }, { from: ["Kory New", "New York"], to: ["New Kory", "Wen Kory"] }, { from: ["Kory New", "New York"], to: ["New Kory", "York New"] }, { from: ["Kory New", "New York"], to: ["Wen Kory", "York New"] }, { from: ["New Kory", "Wen Kory"], to: ["Kory New", "York New"] }, { from: ["New Kory", "York New"], to: ["Kory New", "Wen Kory"] }, { from: ["Kory New", "New Kory"], to: ["Wen Kory", "York New"] }]`. ```js assert.deepEqual( diff --git a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/stern-brocot-sequence.md b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/stern-brocot-sequence.md index 5558082298..a03724c684 100644 --- a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/stern-brocot-sequence.md +++ b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/stern-brocot-sequence.md @@ -1,6 +1,6 @@ --- id: 5a23c84252665b21eecc8028 -title: Stern-Brocot sequence +title: Sequenza di Stern-Brocot challengeType: 5 forumTopicId: 302324 dashedName: stern-brocot-sequence @@ -8,75 +8,73 @@ dashedName: stern-brocot-sequence # --description-- -For this task, the Stern-Brocot sequence is to be generated by an algorithm similar to that employed in generating the [Fibonacci sequence](https://rosettacode.org/wiki/Fibonacci sequence). +Per questa sfida, la serie di Stern-Brocot deve essere generata da un algoritmo simile a quello usato per generare la [serie di Fibonacci](https://rosettacode.org/wiki/Fibonacci sequence).-
# --instructions-- -Create a function that returns the position in the Stern-Brocot sequence at which $ n $ is first encountered, where the sequence is generated with the method outlined above. Note that this sequence uses 1 based indexing. +Crea una funzione che restituisce la posizione della serie di Stern-Brocot a cui $ n $ si trova per la prima volte, dove la serie è generata con il metodo mostrato sopra. Nota che questa sequenza usa indicizzazione che parte da 1. # --hints-- -`sternBrocot` should be a function. +`sternBrocot` dovrebbe essere una funzione. ```js assert(typeof sternBrocot == 'function'); ``` -`sternBrocot(2)` should return a number. +`sternBrocot(2)` dovrebbe restituire un numero. ```js assert(typeof sternBrocot(2) == 'number'); ``` -`sternBrocot(2)` should return `3`. +`sternBrocot(2)` dovrebbe restiture `3`. ```js assert.equal(sternBrocot(2), 3); ``` -`sternBrocot(3)` should return `5`. +`sternBrocot(3)` dovrebbe restituire `5`. ```js assert.equal(sternBrocot(3), 5); ``` -`sternBrocot(5)` should return `11`. +`sternBrocot(5)` dovrebbe restiture `11`. ```js assert.equal(sternBrocot(5), 11); ``` -`sternBrocot(7)` should return `19`. +`sternBrocot(7)` dovrebbe restiture `19`. ```js assert.equal(sternBrocot(7), 19); ``` -`sternBrocot(10)` should return `39`. +`sternBrocot(10)` dovrebbe restiture `39`. ```js assert.equal(sternBrocot(10), 39); diff --git a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/straddling-checkerboard.md b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/straddling-checkerboard.md index e89ca872e6..544bf12a43 100644 --- a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/straddling-checkerboard.md +++ b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/straddling-checkerboard.md @@ -1,6 +1,6 @@ --- id: 5a23c84252665b21eecc8029 -title: Straddling checkerboard +title: Scacchiera a cavallo challengeType: 5 forumTopicId: 302325 dashedName: straddling-checkerboard @@ -8,17 +8,17 @@ dashedName: straddling-checkerboard # --description-- -Implement functions to encrypt and decrypt a message using the [straddling checkerboard](https://en.wikipedia.org/wiki/Straddling_checkerboard) method. The functions will take a string and an array as parameters. The array has 3 strings representing the 3 rows of the checkerboard. The output will be a series of decimal digits. Numbers should be encrypted by inserting the escape character before each digit, then including the digit unencrypted. This should be reversed for decryption. +Implementa le funzioni per crittografare e decrittografare un messaggio usando il metodo [straddling checkerboard](https://en.wikipedia.org/wiki/Straddling_checkerboard). Le funzioni prenderanno una stringa e un array come parametri. L'array ha 3 stringhe che rappresentano le 3 righe della scacchiera. L'output sarà una serie di cifre decimali. I numeri devono essere cifrati inserendo il carattere di escape prima di ogni cifra, quindi includendo la cifra non cifrata. Questo dovrebbe essere invertito per la decifratura. # --hints-- -`straddle` should be a function. +`straddle` dovrebbe essere una funzione. ```js assert(typeof straddle == 'function'); ``` -`straddle("One night-it was on the twentieth of March, 1888-I was returning.",["ESTONIA R", "BCDFGHJKLM", "PQUVWXYZ./"])` should return a string. +`straddle("One night-it was on the twentieth of March, 1888-I was returning.",["ESTONIA R", "BCDFGHJKLM", "PQUVWXYZ./"])` dovrebbe restituire una stringa. ```js assert( @@ -29,7 +29,7 @@ assert( ); ``` -`straddle("One night-it was on the twentieth of March, 1888-I was returning.",["ESTONIA R", "BCDFGHJKLM", "PQUVWXYZ./"])` should return `"34045747525284613427502840425027537379697175891898898898584619028294547488"`. +`straddle("One night-it was on the twentieth of March, 1888-I was returning.",["ESTONIA R", "BCDFGHJKLM", "PQUVWXYZ./"])` dovrebbe restituire `"34045747525284613427502840425027537379697175891898898898584619028294547488"`. ```js assert.equal( @@ -41,7 +41,7 @@ assert.equal( ); ``` -`straddle("One night-it was on the twentieth of March, 1888-I was returning",["HOL MES RT", "ABCDFGIJKN", "PQUVWXYZ./"])` should return `"139539363509369743061399059745399365901344308320791798798798367430685972839363935"`. +`straddle("One night-it was on the twentieth of March, 1888-I was returning",["HOL MES RT", "ABCDFGIJKN", "PQUVWXYZ./"])` dovrebbe restituire `"139539363509369743061399059745399365901344308320791798798798367430685972839363935"`. ```js assert.equal( @@ -54,7 +54,7 @@ assert.equal( ); ``` -`straddle("Thecheckerboardcakerecipespecifies3largeeggsand2.25cupsofflour.",["ET AON RIS", "BCDFGHJKLM", "PQ/UVWXYZ."])` should return `"125021250212707204372221327070218600960021823809623283724002424935226226962262521636094232328463769"`. +`straddle("Thecheckerboardcakerecipespecifies3largeeggsand2.25cupsofflour.",["ET AON RIS", "BCDFGHJKLM", "PQ/UVWXYZ."])` dovrebbe restituire `"125021250212707204372221327070218600960021823809623283724002424935226226962262521636094232328463769"`. ```js assert.equal( @@ -67,13 +67,13 @@ assert.equal( ); ``` -`unstraddle` should be a function. +`unstraddle` dovrebbe essere una funzione. ```js assert(typeof unstraddle == 'function'); ``` -`unstraddle("34045747525284613427502840425027537379697175891898898898584619028294547488",["ESTONIA R", "BCDFGHJKLM", "PQUVWXYZ./"])` should return a string. +`unstraddle("34045747525284613427502840425027537379697175891898898898584619028294547488",["ESTONIA R", "BCDFGHJKLM", "PQUVWXYZ./"])` dovrebbe restituire una stringa. ```js assert( @@ -84,7 +84,7 @@ assert( ); ``` -`unstraddle("34045747525284613427502840425027537379697175891898898898584619028294547488",["ESTONIA R", "BCDFGHJKLM", "PQUVWXYZ./"])` should return `"ONENIGHTITWASONTHETWENTIETHOFMARCH1888IWASRETURNING."`. +`unstraddle("34045747525284613427502840425027537379697175891898898898584619028294547488",["ESTONIA R", "BCDFGHJKLM", "PQUVWXYZ./"])` dovrebbe restituire `"ONENIGHTITWASONTHETWENTIETHOFMARCH1888IWASRETURNING."`. ```js assert.equal( @@ -96,7 +96,7 @@ assert.equal( ); ``` -`unstraddle("139539363509369743061399059745399365901344308320791798798798367430685972839363935",["HOL MES RT", "ABCDFGIJKN", "PQUVWXYZ./"])` should return `"ONENIGHTITWASONTHETWENTIETHOFMARCH1888IWASRETURNING"`. +`unstraddle("139539363509369743061399059745399365901344308320791798798798367430685972839363935",["HOL MES RT", "ABCDFGIJKN", "PQUVWXYZ./"])` dovrebbe restituire `"ONENIGHTITWASONTHETWENTIETHOFMARCH1888IWASRETURNING"`. ```js assert.equal( @@ -108,7 +108,7 @@ assert.equal( ); ``` -`unstraddle("125021250212707204372221327070218600960021823809623283724002424935226226962262521636094232328463769",["ET AON RIS", "BCDFGHJKLM", "PQ/UVWXYZ."])` should return `"THECHECKERBOARDCAKERECIPESPECIFIES3LARGEEGGSAND2.25CUPSOFFLOUR."`. +`unstraddle("125021250212707204372221327070218600960021823809623283724002424935226226962262521636094232328463769",["ET AON RIS", "BCDFGHJKLM", "PQ/UVWXYZ."])` dovrebbe restituire `"THECHECKERBOARDCAKERECIPESPECIFIES3LARGEEGGSAND2.25CUPSOFFLOUR."`. ```js assert.equal( diff --git a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/stream-merge.md b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/stream-merge.md index 234158bb50..69e5cce7ed 100644 --- a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/stream-merge.md +++ b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/stream-merge.md @@ -1,6 +1,6 @@ --- id: 5a23c84252665b21eecc802a -title: Stream Merge +title: Unione di flussi challengeType: 5 forumTopicId: 302326 dashedName: stream-merge @@ -8,17 +8,17 @@ dashedName: stream-merge # --description-- -Write a function that takes multiple sorted arrays of items, and returns one array of sorted items. +Scrivi una funzione che riceve vari array ordinati, e restituisce un unico array di elementi ordinato. # --hints-- -`mergeLists` should be a function. +`mergeLists` dovrebbe essere una funzione. ```js assert(typeof mergeLists == 'function'); ``` -`mergeLists([[1, 3, 5, 9, 10], [2, 4, 6, 7, 8]])` should return an array. +`mergeLists([[1, 3, 5, 9, 10], [2, 4, 6, 7, 8]])` dovrebbe restituire un array. ```js assert( @@ -31,7 +31,7 @@ assert( ); ``` -`mergeLists([[1, 3, 5, 9, 10], [2, 4, 6, 7, 8]])` should return `[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]`. +`mergeLists([[1, 3, 5, 9, 10], [2, 4, 6, 7, 8]])` dovrebbe restituire `[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]`. ```js assert.deepEqual( @@ -43,7 +43,7 @@ assert.deepEqual( ); ``` -`mergeLists([[1, 4, 7, 10], [2, 5, 8, 11], [3, 6, 9, 12]])` should return `[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]`. +`mergeLists([[1, 4, 7, 10], [2, 5, 8, 11], [3, 6, 9, 12]])` dovrebbe restituire `[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]`. ```js assert.deepEqual( @@ -56,7 +56,7 @@ assert.deepEqual( ); ``` -`mergeLists([[1, 3, 9, 14, 15, 17, 28], [7, 8, 14, 14, 23, 26, 28, 29, 30], [9, 23, 25, 29]])` should return `[1, 3, 7, 8, 9, 9, 14, 14, 14, 15, 17, 23, 23, 25, 26, 28, 28, 29, 29, 30]`. +`mergeLists([[1, 3, 9, 14, 15, 17, 28], [7, 8, 14, 14, 23, 26, 28, 29, 30], [9, 23, 25, 29]])` dovrebbe restituire `[1, 3, 7, 8, 9, 9, 14, 14, 14, 15, 17, 23, 23, 25, 26, 28, 28, 29, 29, 30]`. ```js assert.deepEqual( @@ -69,7 +69,7 @@ assert.deepEqual( ); ``` -`mergeLists([[3, 14, 15], [2, 17, 18], [], [2, 3, 5, 7]])` should return `[2, 2, 3, 3, 5, 7, 14, 15, 17, 18]`. +`mergeLists([[3, 14, 15], [2, 17, 18], [], [2, 3, 5, 7]])` dovrebbe restituire `[2, 2, 3, 3, 5, 7, 14, 15, 17, 18]`. ```js assert.deepEqual(mergeLists([[3, 14, 15], [2, 17, 18], [], [2, 3, 5, 7]]), [ @@ -86,7 +86,7 @@ assert.deepEqual(mergeLists([[3, 14, 15], [2, 17, 18], [], [2, 3, 5, 7]]), [ ]); ``` -`mergeLists([[1, 19, 1999], [17, 33, 2999, 3000], [8, 500, 3999]])` should return `[1, 8, 17, 19, 33, 500, 1999, 2999, 3000, 3999]`. +`mergeLists([[1, 19, 1999], [17, 33, 2999, 3000], [8, 500, 3999]])` dovrebbe restituire `[1, 8, 17, 19, 33, 500, 1999, 2999, 3000, 3999]`. ```js assert.deepEqual( diff --git a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/strip-control-codes-and-extended-characters-from-a-string.md b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/strip-control-codes-and-extended-characters-from-a-string.md index 317f9dd7b7..f221e78f42 100644 --- a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/strip-control-codes-and-extended-characters-from-a-string.md +++ b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/strip-control-codes-and-extended-characters-from-a-string.md @@ -1,6 +1,6 @@ --- id: 5a23c84252665b21eecc8036 -title: Strip control codes and extended characters from a string +title: Rimozione di codici di controllo e caratteri estesi da una stringa challengeType: 5 forumTopicId: 302327 dashedName: strip-control-codes-and-extended-characters-from-a-string @@ -8,47 +8,47 @@ dashedName: strip-control-codes-and-extended-characters-from-a-string # --description-- -The task is to strip control codes and extended characters from a string. The solution should demonstrate how to achieve each of the following results: A string with control codes and extended characters stripped. In ASCII, the control codes have decimal codes 0 through to 31 and 127. On an ASCII based system, if the control codes are stripped, the resultant string would have all of its characters within the range of 32 to 126 decimal on the ASCII table. On a non-ASCII based system, we consider characters that do not have a corresponding glyph on the ASCII table (within the ASCII range of 32 to 126 decimal) to be an extended character for the purpose of this task. +Il compito è quello di rimuovere i codici di controllo e i caratteri estesi da una stringa. La soluzione dovrebbe dimostrare come ottenere ciascuno dei seguenti risultati: una stringa con codici di controllo e caratteri estesi rimossi. Nell'ASCII, i codici di controllo hanno codici decimali da 0 a 31 e 127. Su un sistema basato su ASCII, se i codici di controllo sono rimossi, la stringa risultante avrebbe tutti i suoi caratteri nell'intervallo da 32 a 126 decimale nella tabella ASCII. Su un sistema non basato su ASCII, consideriamo i caratteri che non hanno un glifo corrispondente nella tabella ASCII (entro l'intervallo ASCII da 32 a 126 decimale) un carattere esteso ai fini di questo compito. # --hints-- -`strip` should be a function. +`strip` dovrebbe essere una funzione. ```js assert(typeof strip == 'function'); ``` -`strip("abc")` should return a string. +`strip("abc")` dovrebbe restituire una stringa. ```js assert(typeof strip('abc') == 'string'); ``` -`strip("\ba\x00b\n\rc\fd\xc3")` should return `"abcd"`. +`strip("\ba\x00b\n\rc\fd\xc3")` dovrebbe restituire `"abcd"`. ```js assert.equal(strip('\ba\x00b\n\rc\fd\xc3'), 'abcd'); ``` -`strip("\u0000\n abc\u00E9def\u007F")` should return `" abcdef"`. +`strip("\u0000\n abc\u00E9def\u007F")` dovrebbe restituire `" abcdef"`. ```js assert.equal(strip('\u0000\n abc\u00E9def\u007F'), ' abcdef'); ``` -`strip("a\n\tb\u2102d\u2147f")` should return `"abdf"`. +`strip("a\n\tb\u2102d\u2147f")` dovrebbe restituire `"abdf"`. ```js assert.equal(strip('a\n\tb\u2102d\u2147f'), 'abdf'); ``` -`strip("Français.")` should return `"Franais."`. +`strip("Français.")` dovrebbe restituire `"Franais."`. ```js assert.equal(strip('Français.'), 'Franais.'); ``` -`strip("123\tabc\u0007DEF\u007F+-*/€æŧðłþ")` should return `"123abcDEF+-*/"`. +`strip("123\tabc\u0007DEF\u007F+-*/€æŧðłþ")` dovrebbe restituire `"123abcDEF+-*/"`. ```js assert.equal(strip('123\tabc\u0007DEF\u007F+-*/€æŧðłþ'), '123abcDEF+-*/'); diff --git a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/subleq.md b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/subleq.md index d302bb9f99..d812c4f063 100644 --- a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/subleq.md +++ b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/subleq.md @@ -8,50 +8,34 @@ dashedName: subleq # --description-- -[Subleq](https://rosettacode.org/wiki/eso:Subleq) is an example of a [One-Instruction Set Computer (OISC)](https://en.wikipedia.org/wiki/One_instruction_set_computer). +[Subleq](https://rosettacode.org/wiki/eso:Subleq) è un esempio di un [Computer One-Instruction Set (OISC)](https://en.wikipedia.org/wiki/One_instruction_set_computer). -It is named after its only instruction, which is **SU**btract and **B**ranch if **L**ess than or **EQ**ual +Esso prende il nome dalla sua unica istruzione, che è **SU**btract e **B**ranch se **L**ess than or **EQ**ual to zero (sottrai e dirama se minore o uguale a zero). -to zero. +Il tuo compito è quello di creare un interprete che emula una macchina del genere. -Your task is to create an interpreter which emulates such a machine. +La memoria della macchina è costituita da una serie di numeri interi con segno. Qualsiasi dimensione ragionevole di parola va bene, ma la memoria deve essere in grado di contenere numeri negativi e positivi. -The machine's memory consists of an array of signed integers. Any reasonable word size is fine, but the memory must be - -able to hold negative as well as positive numbers. - -Execution begins with the instruction pointer aimed at the first word, which is address 0. It proceeds as follows: +L'esecuzione inizia con il puntatore di istruzioni rivolto alla prima parola, che è l'indirizzo 0. Essa procede come segue:- The first and second members of the sequence are both 1:
+- Il primo e il secondo elemento della serie sono entrambi 1:
-
- 1, 1
- Start by considering the second member of the sequence
-- Sum the considered member of the sequence and its precedent, (1 + 1) = 2, and append it to the end of the - sequence:
+- Inizia considerando il secondo elemento della serie
+- Somma l'elemento considerato della sequenza e il precedente, (1 + 1) = 2, e aggiungilo alla fine della sequenza:
-
- 1, 1, 2
- Append the considered member of the sequence to the end of the sequence:
+- Aggiungi l'elemento considerato alla fine della sequenza:
-
- 1, 1, 2, 1
- Consider the next member of the series, (the third member i.e. 2)
-- GOTO 3
+- Considera l'elemento successivo della serie, (il terzo elemento, cioè 2)
+- Vai a 3
-
-- ─── Expanding another loop we get: ───
+- ─── Espandendo un altro ciclo otteniamo: ───
- Sum the considered member of the sequence and its precedent, (2 + 1) = 3, and append it to the end of the - sequence:
+- Somma l'elemento considerato della sequenza e il suo predecessore, (2 + 1) = 3, e appendilo alla fine della sequenza:
-
- 1, 1, 2, 1, 3
- Append the considered member of the sequence to the end of the sequence:
+- Aggiungi l'elemento considerato alla fine della sequenza:
-
- 1, 1, 2, 1, 3, 2
- Consider the next member of the series, (the fourth member i.e. 1)
+- Considera l'elemento successivo della serie, (il quarto elemento, cioè 1)
-
-Other negative addresses besides -1 may be treated as equivalent to -1, or generate an error, as you see fit. +Altri indirizzi negativi oltre a -1 possono essere trattati come equivalenti a -1, o generare un errore, come si ritiene opportuno. -Your solution should accept a program to execute on the machine, separately from the input fed to the program itself. +La tua soluzione dovrebbe accettare un programma da eseguire sulla macchina, separatamente dall'input fornito al programma stesso. -This program should be in raw subleq "machine code" - whitespace-separated decimal numbers, with no symbolic names or - -other assembly-level extensions, to be loaded into memory starting at address 0. Show the output of your solution when - -fed this "Hello, world!" program. (Note that the example assumes ASCII or a superset of it, such as any of the Latin-N - -character sets or Unicode. You may translate it into another character set if your implementation is on a - -non-ASCiI-compatible environment.) +Questo programma dovrebbe essere "linguaggio macchina" subleq grezzo - numeri decimali separati da spazi, senza nomi simbolici o altre estensioni a livello di assembly, da caricare in memoria a partire dall'indirizzo 0. Mostra l'output della tua soluzione quando alimentato con questo programma "Hello, world!". (Nota che l'esempio assume ASCII o un superset di esso, come uno dei set di caratteri Latin-N o Unicode. Puoi tradurlo in un altro set di caratteri se la tua implementazione è in un ambiente non compatibile con ASCII.)- Let A, B, and C be the value stored in the three consecutive words in memory starting at the instruction pointer.
-- Advance the instruction pointer 3 words to point at the address after the one containing C.
-- If A is -1, then a character is read from standard input and its code point stored in the address given by B. C - is unused.
-- If B is -1, then the number contained in the address given by A is interpreted as a code point and the - corresponding character output. C is again unused.
-- Otherwise, both A and B are treated as the addresses of memory locations. The number contained in the address - given by A is subtracted from the number at the address given by B (and the result stored back in address B). If - the result is zero or negative, the value C becomes the new instruction pointer.
-- If the instruction pointer becomes negative, execution halts.
+- Sia A, B e C il valore memorizzato nelle tre parole consecutive in memoria a partire dal puntatore di istruzioni.
+- Fai avanzare il puntatore di tre parole in modo da puntare all'indirizzo successivo a quello contenente C.
+- Se A è -1, viene letto un carattere dallo standard input e il suo codice punto memorizzato nell'indirizzo indicato da B. C è inutilizzato.
+- Se B è -1, allora il numero contenuto nell'indirizzo dato da A è interpretato come un punto di codice e viene fatto l'output del carattere corrispondente. C è di nuovo inutilizzato.
+- Altrimenti, sia A che B sono trattati come gli indirizzi di luoghi di memoria. Il numero contenuto nell’indirizzo indicato da A viene sottratto dal numero all’indirizzo indicato da B (e il risultato memorizzato nell’indirizzo B). Se il risultato è zero o negativo, il valore C diventa il nuovo puntatore di istruzione.
+- Se il puntatore di istruzioni diventa negativo, l'esecuzione si ferma.
15 17 -1 17 -1 -1 16 1 -1 16 3 -1 15 15 0 0 -1 72 101 108 108 111 44 32 119 111 114 108 100 33 10 0-Which corresponds to something like this in a hypothetical assembler language: +Che corrisponde a qualcosa di simile in un ipotetico linguaggio assembler:start: zero, message, -1 @@ -66,19 +50,17 @@ message: "Hello, world!\n\0" # --instructions-- -Write a function that takes an array of integers as a parameter. This represents the memory elements. The function - -should interpret the sequence and return the output string. For this task, assume that there is no standard input. +Scrivi una funzione che richiede un array di interi come parametro. Questo rappresenta gli elementi di memoria. La funzione deve interpretare la sequenza e restituire la stringa di output. Per questo compito, supponiamo che non ci sia uno standard input. # --hints-- -`Subleq` should be a function. +`Subleq` dovrebbe essere una funzione. ```js assert(typeof Subleq == 'function'); ``` -`Subleq([15, 17, -1, 17, -1, -1, 16, 1, -1, 16, 3, -1, 15, 15, 0, 0, -1, 72, 101, 108, 108, 111, 44, 32, 119, 111, 114, 108, 100, 33, 0])` should return a string. +`Subleq([15, 17, -1, 17, -1, -1, 16, 1, -1, 16, 3, -1, 15, 15, 0, 0, -1, 72, 101, 108, 108, 111, 44, 32, 119, 111, 114, 108, 100, 33, 0])` dovrebbe restituire una stringa. ```js assert( @@ -118,7 +100,7 @@ assert( ); ``` -`Subleq([15, 17, -1, 17, -1, -1, 16, 1, -1, 16, 3, -1, 15, 15, 0, 0, -1, 72, 101, 108, 108, 111, 44, 32, 119, 111, 114, 108, 100, 33, 0])` should return `"Hello, world!"`. +`Subleq([15, 17, -1, 17, -1, -1, 16, 1, -1, 16, 3, -1, 15, 15, 0, 0, -1, 72, 101, 108, 108, 111, 44, 32, 119, 111, 114, 108, 100, 33, 0])` dovrebbe restituire `"Hello, world!"`. ```js assert.equal( diff --git a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/sudoku.md b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/sudoku.md index e0f6864a89..adbb9e585c 100644 --- a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/sudoku.md +++ b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/sudoku.md @@ -8,17 +8,17 @@ dashedName: sudoku # --description-- -Write a function to solve a partially filled-in normal 9x9 [Sudoku](https://en.wikipedia.org/wiki/Sudoku) grid and return the result. The blank fields are represented by `-1`. [Algorithmics of Sudoku](https://en.wikipedia.org/wiki/Algorithmics_of_sudoku) may help implement this. +Scrivi una funzione per risolvere una normale griglia di [Sudoku](https://en.wikipedia.org/wiki/Sudoku) 9x9 parzialmente riempita e restituisci il risultato. I campi vuoti sono rappresentati da `-1`. [Gli algoritmi di risoluzione di Sudoku](https://en.wikipedia.org/wiki/Algorithmics_of_sudoku) possono aiutare ad implementarlo. # --hints-- -`solveSudoku` should be a function. +`solveSudoku` dovrebbe essere una funzione. ```js assert(typeof solveSudoku == 'function'); ``` -`solveSudoku([[8, 1, 9, -1, -1, 5, -1, -1, -1],[-1, -1, 2, -1, -1, -1, 7, 5, -1],[-1, 3, 7, 1, -1, 4, -1, 6, -1],[4, -1, -1, 5, 9, -1, 1, -1, -1],[7, -1, -1, 3, -1, 8, -1, -1, 2],[-1, -1, 3, -1, 6, 2, -1, -1, 7],[-1, 5, -1, 7, -1, 9, 2, 1, -1],[-1, 6, 4, -1, -1, -1, 9, -1, -1],[-1, -1, -1, 2, -1, -1, 4, 3, 8]])` should return an array. +`solveSudoku([[8, 1, 9, -1, -1, 5, -1, -1, -1],[-1, -1, 2, -1, -1, -1, 7, 5, -1],[-1, 3, 7, 1, -1, 4, -1, 6, -1],[4, -1, -1, 5, 9, -1, 1, -1, -1],[7, -1, -1, 3, -1, 8, -1, -1, 2],[-1, -1, 3, -1, 6, 2, -1, -1, 7],[-1, 5, -1, 7, -1, 9, 2, 1, -1],[-1, 6, 4, -1, -1, -1, 9, -1, -1],[-1, -1, -1, 2, -1, -1, 4, 3, 8]])` dovrebbe restituire un array. ```js assert( @@ -38,7 +38,7 @@ assert( ); ``` -`solveSudoku([[8, 1, 9, -1, -1, 5, -1, -1, -1],[-1, -1, 2, -1, -1, -1, 7, 5, -1],[-1, 3, 7, 1, -1, 4, -1, 6, -1],[4, -1, -1, 5, 9, -1, 1, -1, -1],[7, -1, -1, 3, -1, 8, -1, -1, 2],[-1, -1, 3, -1, 6, 2, -1, -1, 7],[-1, 5, -1, 7, -1, 9, 2, 1, -1],[-1, 6, 4, -1, -1, -1, 9, -1, -1],[-1, -1, -1, 2, -1, -1, 4, 3, 8]])` should return `[[8, 1, 9, 6, 7, 5, 3, 2, 4],[6, 4, 2, 9, 8, 3, 7, 5, 1],[5, 3, 7, 1, 2, 4, 8, 6, 9],[4, 2, 6, 5, 9, 7, 1, 8, 3],[7, 9, 5, 3, 1, 8, 6, 4, 2],[1, 8, 3, 4, 6, 2, 5, 9, 7],[3, 5, 8, 7, 4, 9, 2, 1, 6],[2, 6, 4, 8, 3, 1, 9, 7, 5],[9, 7, 1, 2, 5, 6, 4, 3, 8]]`. +`solveSudoku([[8, 1, 9, -1, -1, 5, -1, -1, -1],[-1, -1, 2, -1, -1, -1, 7, 5, -1],[-1, 3, 7, 1, -1, 4, -1, 6, -1],[4, -1, -1, 5, 9, -1, 1, -1, -1],[7, -1, -1, 3, -1, 8, -1, -1, 2],[-1, -1, 3, -1, 6, 2, -1, -1, 7],[-1, 5, -1, 7, -1, 9, 2, 1, -1],[-1, 6, 4, -1, -1, -1, 9, -1, -1],[-1, -1, -1, 2, -1, -1, 4, 3, 8]])` dovrebbe restituire `[[8, 1, 9, 6, 7, 5, 3, 2, 4],[6, 4, 2, 9, 8, 3, 7, 5, 1],[5, 3, 7, 1, 2, 4, 8, 6, 9],[4, 2, 6, 5, 9, 7, 1, 8, 3],[7, 9, 5, 3, 1, 8, 6, 4, 2],[1, 8, 3, 4, 6, 2, 5, 9, 7],[3, 5, 8, 7, 4, 9, 2, 1, 6],[2, 6, 4, 8, 3, 1, 9, 7, 5],[9, 7, 1, 2, 5, 6, 4, 3, 8]]`. ```js assert.deepEqual( @@ -67,7 +67,7 @@ assert.deepEqual( ); ``` -`solveSudoku([[5, 3, -1, -1, 2, 4, 7, -1, -1],[-1, -1, 2, -1, -1, -1, 8, -1, -1],[1, -1, -1, 7, -1, 3, 9, -1, 2],[-1, -1, 8, -1, 7, 2, -1, 4, 9],[-1, 2, -1, 9, 8, -1, -1, 7, -1],[7, 9, -1, -1, -1, -1, -1, 8, -1],[-1, -1, -1, -1, 3, -1, 5, -1, 6],[9, 6, -1, -1, 1, -1, 3, -1, -1],[-1, 5, -1, 6, 9, -1, -1, 1, -1]])` should return `[[5, 3, 9, 8, 2, 4, 7, 6, 1],[6, 7, 2, 1, 5, 9, 8, 3, 4],[1, 8, 4, 7, 6, 3, 9, 5, 2],[3, 1, 8, 5, 7, 2, 6, 4, 9],[4, 2, 5, 9, 8, 6, 1, 7, 3],[7, 9, 6, 3, 4, 1, 2, 8, 5],[8, 4, 1, 2, 3, 7, 5, 9, 6],[9, 6, 7, 4, 1, 5, 3, 2, 8],[2, 5, 3, 6, 9, 8, 4, 1, 7]]`. +`solveSudoku([[5, 3, -1, -1, 2, 4, 7, -1, -1],[-1, -1, 2, -1, -1, -1, 8, -1, -1],[1, -1, -1, 7, -1, 3, 9, -1, 2],[-1, -1, 8, -1, 7, 2, -1, 4, 9],[-1, 2, -1, 9, 8, -1, -1, 7, -1],[7, 9, -1, -1, -1, -1, -1, 8, -1],[-1, -1, -1, -1, 3, -1, 5, -1, 6],[9, 6, -1, -1, 1, -1, 3, -1, -1],[-1, 5, -1, 6, 9, -1, -1, 1, -1]])` dovrebbe restituire `[[5, 3, 9, 8, 2, 4, 7, 6, 1],[6, 7, 2, 1, 5, 9, 8, 3, 4],[1, 8, 4, 7, 6, 3, 9, 5, 2],[3, 1, 8, 5, 7, 2, 6, 4, 9],[4, 2, 5, 9, 8, 6, 1, 7, 3],[7, 9, 6, 3, 4, 1, 2, 8, 5],[8, 4, 1, 2, 3, 7, 5, 9, 6],[9, 6, 7, 4, 1, 5, 3, 2, 8],[2, 5, 3, 6, 9, 8, 4, 1, 7]]`. ```js assert.deepEqual( @@ -96,7 +96,7 @@ assert.deepEqual( ); ``` -`solveSudoku([[-1, -1, 3, -1, 2, -1, 6, -1, -1],[9, -1, -1, 3, -1, 5, -1, -1, 1],[-1, -1, 1, 8, -1, 6, 4, -1, -1],[-1, -1, 8, 1, -1, 2, 9, -1, -1],[7, -1, -1, -1, -1, -1, -1, -1, 8],[-1, -1, 6, 7, -1, 8, 2, -1, -1],[-1, -1, 2, 6, -1, 9, 5, -1, -1],[8, -1, -1, 2, -1, 3, -1, -1, 9],[-1, -1, 5, -1, 1, -1, 3, -1, -1]])` should return `[[4, 8, 3, 9, 2, 1, 6, 5, 7],[9, 6, 7, 3, 4, 5, 8, 2, 1],[2, 5, 1, 8, 7, 6, 4, 9, 3],[5, 4, 8, 1, 3, 2, 9, 7, 6],[7, 2, 9, 5, 6, 4, 1, 3, 8],[1, 3, 6, 7, 9, 8, 2, 4, 5],[3, 7, 2, 6, 8, 9, 5, 1, 4],[8, 1, 4, 2, 5, 3, 7, 6, 9],[6, 9, 5, 4, 1, 7, 3, 8, 2]]`. +`solveSudoku([[-1, -1, 3, -1, 2, -1, 6, -1, -1],[9, -1, -1, 3, -1, 5, -1, -1, 1],[-1, -1, 1, 8, -1, 6, 4, -1, -1],[-1, -1, 8, 1, -1, 2, 9, -1, -1],[7, -1, -1, -1, -1, -1, -1, -1, 8],[-1, -1, 6, 7, -1, 8, 2, -1, -1],[-1, -1, 2, 6, -1, 9, 5, -1, -1],[8, -1, -1, 2, -1, 3, -1, -1, 9],[-1, -1, 5, -1, 1, -1, 3, -1, -1]])` dovrebbe restituire `[[4, 8, 3, 9, 2, 1, 6, 5, 7],[9, 6, 7, 3, 4, 5, 8, 2, 1],[2, 5, 1, 8, 7, 6, 4, 9, 3],[5, 4, 8, 1, 3, 2, 9, 7, 6],[7, 2, 9, 5, 6, 4, 1, 3, 8],[1, 3, 6, 7, 9, 8, 2, 4, 5],[3, 7, 2, 6, 8, 9, 5, 1, 4],[8, 1, 4, 2, 5, 3, 7, 6, 9],[6, 9, 5, 4, 1, 7, 3, 8, 2]]`. ```js assert.deepEqual( diff --git a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/sum-digits-of-an-integer.md b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/sum-digits-of-an-integer.md index d13a1bdb03..055f941dcb 100644 --- a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/sum-digits-of-an-integer.md +++ b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/sum-digits-of-an-integer.md @@ -1,6 +1,6 @@ --- id: 5a23c84252665b21eecc803f -title: Sum digits of an integer +title: Somma delle cifre di un intero challengeType: 5 forumTopicId: 302331 dashedName: sum-digits-of-an-integer @@ -8,7 +8,7 @@ dashedName: sum-digits-of-an-integer # --description-- -Write a function that takes a string as a parameter. This string represents a number that can be in any base (less than 37) and return the sum of its digits. +Scrivi una funzione che prende una stringa come parametro. Questa stringa rappresenta un numero che può essere in qualsiasi base (inferiore a 37) e restituisce la somma delle sue cifre.
- 110 sums to 1 @@ -19,49 +19,49 @@ Write a function that takes a string as a parameter. This string represents a nu # --hints-- -`sumDigits` should be a function. +`sumDigits` dovrebbe essere una funzione. ```js assert(typeof sumDigits == 'function'); ``` -`sumDigits("1")` should return a number. +`sumDigits("1")` dovrebbe restituire un numero. ```js assert(typeof sumDigits('1') == 'number'); ``` -`sumDigits("1")` should return `1`. +`sumDigits("1")` dovrebbe restituire `1`. ```js assert.equal(sumDigits('1'), 1); ``` -`sumDigits("12345")` should return `15`. +`sumDigits("12345")` dovrebbe restituire `15`. ```js assert.equal(sumDigits('12345'), 15); ``` -`sumDigits("254")` should return `11`. +`sumDigits("254")` dovrebbe restituire `11`. ```js assert.equal(sumDigits('254'), 11); ``` -`sumDigits("fe")` should return `29`. +`sumDigits("fe")` dovrebbe restituire `29`. ```js assert.equal(sumDigits('fe'), 29); ``` -`sumDigits("f0e")` should return `29`. +`sumDigits("f0e")` dovrebbe restituire `29`. ```js assert.equal(sumDigits('f0e'), 29); ``` -`sumDigits("999ABCXYZ")` should return `162`. +`sumDigits("999ABCXYZ")` dovrebbe restituire `162`. ```js assert.equal(sumDigits('999ABCXYZ'), 162); diff --git a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/sum-multiples-of-3-and-5.md b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/sum-multiples-of-3-and-5.md index f92d5b9d21..ba0ee58b9f 100644 --- a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/sum-multiples-of-3-and-5.md +++ b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/sum-multiples-of-3-and-5.md @@ -1,6 +1,6 @@ --- id: 5a23c84252665b21eecc8040 -title: Sum multiples of 3 and 5 +title: Somma multipli di 3 e 5 challengeType: 5 forumTopicId: 302332 dashedName: sum-multiples-of-3-and-5 @@ -8,47 +8,47 @@ dashedName: sum-multiples-of-3-and-5 # --description-- -The objective is to write a function that finds the sum of all positive multiples of 3 or 5 below *n*. +L'obiettivo è quello di scrivere una funzione che trova la somma di tutti i multipli positivi di 3 o 5 inferiori a *n*. # --hints-- -`sumMults` should be a function. +`sumMults` dovrebbe essere una funzione. ```js assert(typeof sumMults == 'function'); ``` -`sumMults(10)` should return a number. +`sumMults(10)` dovrebbe restituire un numero. ```js assert(typeof sumMults(10) == 'number'); ``` -`sumMults(10)` should return `23`. +`sumMults(10)` dovrebbe restituire `23`. ```js assert.equal(sumMults(10), 23); ``` -`sumMults(100)` should return `2318`. +`sumMults(100)` dovrebbe restituire `2318`. ```js assert.equal(sumMults(100), 2318); ``` -`sumMults(1000)` should return `233168`. +`sumMults(1000)` dovrebbe restituire `233168`. ```js assert.equal(sumMults(1000), 233168); ``` -`sumMults(10000)` should return `23331668`. +`sumMults(10000)` dovrebbe restituire `23331668`. ```js assert.equal(sumMults(10000), 23331668); ``` -`sumMults(100000)` should return `2333316668`. +`sumMults(100000)` dovrebbe restituire `2333316668`. ```js assert.equal(sumMults(100000), 2333316668); diff --git a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/sum-of-a-series.md b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/sum-of-a-series.md index 6ffa6d152f..eef35077dc 100644 --- a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/sum-of-a-series.md +++ b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/sum-of-a-series.md @@ -1,6 +1,6 @@ --- id: 5a23c84252665b21eecc8041 -title: Sum of a series +title: Somma di una serie challengeType: 5 forumTopicId: 302333 dashedName: sum-of-a-series @@ -8,51 +8,51 @@ dashedName: sum-of-a-series # --description-- -Compute the **n**th term of a [series](https://en.wikipedia.org/wiki/Series (mathematics)), i.e. the sum of the **n** first terms of the corresponding [sequence](https://en.wikipedia.org/wiki/sequence). Informally this value, or its limit when **n** tends to infinity, is also called the *sum of the series*, thus the title of this task. For this task, use: $S_n = \displaystyle\sum_{k=1}^n \frac{1}{k^2}$. +Calcola il termine **n**mo di una [serie](https://en.wikipedia.org/wiki/Series (mathematics)), cioè la somma dei primi **n** termini della successione [corrispondente](https://en.wikipedia.org/wiki/sequence). In modo informale questo valore, o il suo limite quando **n** tende all'infinito, è anche chiamato la *somma della serie*, quindi il titolo di questo compito. Per questo compito, usa: $S_n = \displaystyle\sum_{k=1}^n \frac{1}{k^2}$. # --instructions-- -Write a function that take $a$ and $b$ as parameters and returns the sum of $a^{th}$ to $b^{th}$ members of the sequence. +Scrivi una funzione che prende $a$ e $b$ come parametri e restituisce la somma dall'$a^{mo}$ al $b^{mo}$ elemento della successione. # --hints-- -`sum` should be a function. +`sum` dovrebbe essere una funzione. ```js assert(typeof sum == 'function'); ``` -`sum(1, 100)` should return a number. +`sum(1, 100)` dovrebbe restituire un numero. ```js assert(typeof sum(1, 100) == 'number'); ``` -`sum(1, 100)` should return `1.6349839001848923`. +`sum(1, 100)` dovrebbe restituire `1.6349839001848923`. ```js assert.equal(sum(1, 100), 1.6349839001848923); ``` -`sum(33, 46)` should return `0.009262256361481223`. +`sum(33, 46)` dovrebbe restituire `0.009262256361481223`. ```js assert.equal(sum(33, 46), 0.009262256361481223); ``` -`sum(21, 213)` should return `0.044086990748706555`. +`sum(21, 213)` dovrebbe restituire `0.044086990748706555`. ```js assert.equal(sum(21, 213), 0.044086990748706555); ``` -`sum(11, 111)` should return `0.08619778593108679`. +`sum(11, 111)` dovrebbe restituire `0.08619778593108679`. ```js assert.equal(sum(11, 111), 0.08619778593108679); ``` -`sum(1, 10)` should return `1.5497677311665408`. +`sum(1, 10)` dovrebbe restituire `1.5497677311665408`. ```js assert.equal(sum(1, 10), 1.5497677311665408); diff --git a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/sum-of-squares.md b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/sum-of-squares.md index d211cbc165..5264190cf5 100644 --- a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/sum-of-squares.md +++ b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/sum-of-squares.md @@ -1,6 +1,6 @@ --- id: 5a23c84252665b21eecc8042 -title: Sum of squares +title: Somma di quadrati challengeType: 5 forumTopicId: 302334 dashedName: sum-of-squares @@ -8,47 +8,47 @@ dashedName: sum-of-squares # --description-- -Write a function to find the sum of squares of an array of integers. +Scrivi una funzione per trovare la somma dei quadrati di un array di interi. # --hints-- -`sumsq` should be a function. +`sumsq` dovrebbe essere una funzione. ```js assert(typeof sumsq == 'function'); ``` -`sumsq([1, 2, 3, 4, 5])` should return a number. +`sumsq([1, 2, 3, 4, 5])` dovrebbe restituire un numero. ```js assert(typeof sumsq([1, 2, 3, 4, 5]) == 'number'); ``` -`sumsq([1, 2, 3, 4, 5])` should return `55`. +`sumsq([1, 2, 3, 4, 5])` dovrebbe restituire `55`. ```js assert.equal(sumsq([1, 2, 3, 4, 5]), 55); ``` -`sumsq([25, 32, 12, 7, 20])` should return `2242`. +`sumsq([25, 32, 12, 7, 20])` dovrebbe restituire `2242`. ```js assert.equal(sumsq([25, 32, 12, 7, 20]), 2242); ``` -`sumsq([38, 45, 35, 8, 13])` should return `4927`. +`sumsq([38, 45, 35, 8, 13])` dovrebbe restituire `4927`. ```js assert.equal(sumsq([38, 45, 35, 8, 13]), 4927); ``` -`sumsq([43, 36, 20, 34, 24])` should return `5277`. +`sumsq([43, 36, 20, 34, 24])` dovrebbe restituire `5277`. ```js assert.equal(sumsq([43, 36, 20, 34, 24]), 5277); ``` -`sumsq([12, 33, 26, 18, 1, 16, 3])` should return `2499`. +`sumsq([12, 33, 26, 18, 1, 16, 3])` dovrebbe restituire `2499`. ```js assert.equal(sumsq([12, 33, 26, 18, 1, 16, 3]), 2499); diff --git a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/sum-to-100.md b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/sum-to-100.md index f30b422ba8..a3090dea81 100644 --- a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/sum-to-100.md +++ b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/sum-to-100.md @@ -1,6 +1,6 @@ --- id: 5a23c84252665b21eecc8043 -title: Sum to 100 +title: Somma a 100 challengeType: 5 forumTopicId: 302335 dashedName: sum-to-100 @@ -8,33 +8,33 @@ dashedName: sum-to-100 # --description-- -Find solutions to the *sum to one hundred* puzzle. +Trova le soluzioni per il puzzle *Somma a cento*. -Add (insert) the mathematical operators **+** or **─** (plus or minus) before any of the digits in the decimal numeric string **123456789** such that the resulting mathematical expression adds up to a particular sum (in this iconic case, **100**). +Aggiungi (inserisci) gli operatori matematici **+** o **─** (più o meno) prima di una qualsiasi delle cifre della stringa numerica decimale **123456789** in modo che l'espressione matematica risultante sommi a una particolare somma (in questo caso iconico, **100**). -Example: +Esempio:
123 + 4 - 5 + 67 - 89 = 100# --instructions-- -Write a function that takes a number as parameter. The function should return an array containing all solutions for the given number. The solutions should be strings representing the expressions. For example: "1+23-456+78-9". Sort the array before returning it. +Scrivi una funzione che prende un numero come parametro. La funzione dovrebbe restituire un array contenente tutte le soluzioni per il numero dato. Le soluzioni dovrebbero essere stringhe che rappresentino le espressioni. Per esempio: "1+23-456+78-9". Ordina l'array prima di restituirlo. # --hints-- -`sumTo100` should be a function. +`sumTo100` dovrebbe essere una funzione. ```js assert(typeof sumTo100 == 'function'); ``` -`sumTo100(199)` should return an array. +`sumTo100(199)` dovrebbe restituire un array. ```js assert(Array.isArray(sumTo100(199))); ``` -`sumTo100(199)` should return `["-1+2-3+45+67+89", "123-4+5+6+78-9", "123-4+56+7+8+9"]`. +`sumTo100(199)` dovrebbe restituire `["-1+2-3+45+67+89", "123-4+5+6+78-9", "123-4+56+7+8+9"]`. ```js assert.deepEqual(sumTo100(199), [ @@ -44,13 +44,13 @@ assert.deepEqual(sumTo100(199), [ ]); ``` -`sumTo100(209)` should return `["1+234+56+7-89"]`. +`sumTo100(209)` dovrebbe restituire `["1+234+56+7-89"]`. ```js assert.deepEqual(sumTo100(209), ['1+234+56+7-89']); ``` -`sumTo100(243)` should return `["-1-234+567-89", "-12+345+6-7-89", "123+45+6+78-9"]`. +`sumTo100(243)` dovrebbe restituire `["-1-234+567-89", "-12+345+6-7-89", "123+45+6+78-9"]`. ```js assert.deepEqual(sumTo100(243), [ @@ -60,7 +60,7 @@ assert.deepEqual(sumTo100(243), [ ]); ``` -`sumTo100(197)` should return `["1-2-3+45+67+89", "12+34-5+67+89", "123+4-5+6+78-9"]`. +`sumTo100(197)` dovrebbe restituire `["1-2-3+45+67+89", "12+34-5+67+89", "123+4-5+6+78-9"]`. ```js assert.deepEqual(sumTo100(197), [ diff --git a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/sutherland-hodgman-polygon-clipping.md b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/sutherland-hodgman-polygon-clipping.md index 50fe64ed63..bbe356525d 100644 --- a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/sutherland-hodgman-polygon-clipping.md +++ b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/sutherland-hodgman-polygon-clipping.md @@ -1,6 +1,6 @@ --- id: 5a23c84252665b21eecc8045 -title: Sutherland-Hodgman polygon clipping +title: Taglio di un poligono di Sutherland-Hodgman challengeType: 5 forumTopicId: 302336 dashedName: sutherland-hodgman-polygon-clipping @@ -8,27 +8,27 @@ dashedName: sutherland-hodgman-polygon-clipping # --description-- -The [Sutherland-Hodgman clipping algorithm](https://en.wikipedia.org/wiki/Sutherland-Hodgman clipping algorithm) finds the polygon that is the intersection between an arbitrary polygon (the "subject polygon") and a convex polygon (the "clip polygon"). It is used in computer graphics (especially 2D graphics) to reduce the complexity of a scene being displayed by eliminating parts of a polygon that do not need to be displayed. Take the closed polygon defined by the points: +L'algoritmo [di ritaglio Sutherland-Hodgman](https://en.wikipedia.org/wiki/Sutherland-Hodgman clipping algorithm) trova il poligono che è l'intersezione tra un poligono arbitrario (il "poligono soggetto") e un poligono convesso (il "poligono di taglio"). Viene utilizzato nella grafica informatica (in particolare nella grafica 2D) per ridurre la complessità di una scena che viene visualizzata eliminando parti di un poligono che non hanno bisogno di essere visualizzate. Prende il poligono chiuso definito dai punti:
[(50, 150), (200, 50), (350, 150), (350, 300), (250, 300), (200, 250), (150, 350), (100, 250), (100, 200)]-and clip it by the rectangle defined by the points: +e lo ritaglia dal rettangolo definito dai punti:
[(100, 100), (300, 100), (300, 300), (100, 300)]# --instructions-- -Write a function that takes 2 arrays as parameters. The first array contains the points of the subject polygon and the second array contains the points of the clipping polygon. The function should return an array containing the points of the clipped polygon. Each number should be rounded to 3 decimal places. +Scrivi una funzione che richiede 2 array come parametri. Il primo array contiene i punti del poligono soggetto e il secondo array contiene i punti del poligono di ritaglio. La funzione dovrebbe restituire un array contenente i punti del poligono ritagliato. Ogni numero deve essere arrotondato al terzo decimale. # --hints-- -`clip` should be a function. +`clip` dovrebbe essere una funzione. ```js assert(typeof clip == 'function'); ``` -`clip([[50, 150], [200, 50], [350, 150], [350, 300], [250, 300], [200, 250], [150, 350], [100, 250], [100, 200]], [[100, 100], [300, 100], [300, 300], [100, 300]])` should return an array. +`clip([[50, 150], [200, 50], [350, 150], [350, 300], [250, 300], [200, 250], [150, 350], [100, 250], [100, 200]], [[100, 100], [300, 100], [300, 300], [100, 300]])` dovrebbe restituire un array. ```js assert( @@ -56,7 +56,7 @@ assert( ); ``` -`clip([[50, 150], [200, 50], [350, 150], [350, 300], [250, 300], [200, 250], [150, 350], [100, 250], [100, 200]], [[100, 100], [300, 100], [300, 300], [100, 300]])` should return `[[100, 116.667], [125, 100], [275, 100], [300, 116.667], [300, 300], [250, 300], [200, 250], [175, 300], [125, 300], [100, 250]]`. +`clip([[50, 150], [200, 50], [350, 150], [350, 300], [250, 300], [200, 250], [150, 350], [100, 250], [100, 200]], [[100, 100], [300, 100], [300, 300], [100, 300]])` dovrebbe restituire `[[100, 116.667], [125, 100], [275, 100], [300, 116.667], [300, 300], [250, 300], [200, 250], [175, 300], [125, 300], [100, 250]]`. ```js assert.deepEqual( @@ -94,7 +94,7 @@ assert.deepEqual( ); ``` -`clip([[150, 200], [400, 450], [30, 50]], [[10, 10], [300, 200], [400, 600], [100, 300]])` should return `[[150, 200], [350, 400], [348.611, 394.444], [30, 50]]`. +`clip([[150, 200], [400, 450], [30, 50]], [[10, 10], [300, 200], [400, 600], [100, 300]])` dovrebbe restituire `[[150, 200], [350, 400], [348.611, 394.444], [30, 50]]`. ```js assert.deepEqual( @@ -120,7 +120,7 @@ assert.deepEqual( ); ``` -`clip([[250, 200], [100, 450], [130, 250]], [[50, 60], [100, 230], [400, 600], [100, 300]])` should return `[[129.167, 329.167], [119.565, 319.565], [121.854, 304.305]]`. +`clip([[250, 200], [100, 450], [130, 250]], [[50, 60], [100, 230], [400, 600], [100, 300]])` dovrebbe restituire `[[129.167, 329.167], [119.565, 319.565], [121.854, 304.305]]`. ```js assert.deepEqual( diff --git a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/symmetric-difference.md b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/symmetric-difference.md index 7009bce461..89f73a749a 100644 --- a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/symmetric-difference.md +++ b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/symmetric-difference.md @@ -1,6 +1,6 @@ --- id: 5a23c84252665b21eecc8046 -title: Symmetric difference +title: Differenza simmetrica challengeType: 5 forumTopicId: 16086 dashedName: symmetric-difference @@ -8,21 +8,21 @@ dashedName: symmetric-difference # --description-- -Given two [set](https://rosettacode.org/wiki/set)s *A* and *B*, compute $(A \\setminus B) \\cup (B \\setminus A).$ That is, enumerate the items that are in *A* or *B* but not both. This set is called the [symmetric difference](https://en.wikipedia.org/wiki/Symmetric difference) of *A* and *B*. In other words: $(A \\cup B) \\setminus (A \\cap B)$ (the set of items that are in at least one of *A* or *B* minus the set of items that are in both *A* and *B*). +Dati due [insiemi](https://rosettacode.org/wiki/set) *A* e *B*, calcola $(A \\setminus B) \\cup (B \\setminus A). Vale a dire elenca gli elementi che sono in *A* o *B*, ma non in entrambi. Questo insieme è chiamato la [differenza simmetrica](https://en.wikipedia.org/wiki/Symmetric difference) di *A* e *B*. In altre parole: $(A \\cup B) \\setminus (A \\cap B)$ (l'insieme di elementi che sono in almeno uno di *A* o *B* meno l'insieme di elementi che sono sia in *A* che in *B*). # --instructions-- -Write a function that takes two arrays as parameters and returns the symmetric difference. Sort the resultant array before returning it. +Scrivi una funzione che prende due array come parametri e restituisce la differenza simmetrica. Ordina l'array risultante prima di restituirlo. # --hints-- -`symmetricDifference` should be a function. +`symmetricDifference` dovrebbe essere una funzione. ```js assert(typeof symmetricDifference == 'function'); ``` -`symmetricDifference(["John", "Bob", "Mary", "Serena"], ["Jim", "Mary", "John", "Bob"])` should return an array. +`symmetricDifference(["John", "Bob", "Mary", "Serena"], ["Jim", "Mary", "John", "Bob"])` dovrebbe restituire un array. ```js assert( @@ -35,7 +35,7 @@ assert( ); ``` -`symmetricDifference(["John", "Bob", "Mary", "Serena"], ["Jim", "Mary", "John", "Bob"])` should return `["Jim", "Serena"]`. +`symmetricDifference(["John", "Bob", "Mary", "Serena"], ["Jim", "Mary", "John", "Bob"])` dovrebbe restituire `["Jim", "Serena"]`. ```js assert.deepEqual( @@ -47,13 +47,13 @@ assert.deepEqual( ); ``` -`symmetricDifference([1, 2, 3], [3, 4])` should return `[1, 2, 4]`. +`symmetricDifference([1, 2, 3], [3, 4])` dovrebbe restituire `[1, 2, 4]`. ```js assert.deepEqual(symmetricDifference([1, 2, 3], [3, 4]), [1, 2, 4]); ``` -`symmetricDifference([1, 2, 3, 4, 5], [3, 4, 8, 7])` should return `[1, 2, 5, 7, 8]`. +`symmetricDifference([1, 2, 3, 4, 5], [3, 4, 8, 7])` dovrebbe restituire `[1, 2, 5, 7, 8]`. ```js assert.deepEqual(symmetricDifference([1, 2, 3, 4, 5], [3, 4, 8, 7]), [ @@ -65,7 +65,7 @@ assert.deepEqual(symmetricDifference([1, 2, 3, 4, 5], [3, 4, 8, 7]), [ ]); ``` -`symmetricDifference([1, 2, 3, 4, 5, 6, 7, 8], [1, 3, 5, 6, 7, 8, 9])` should return `[2, 4, 9]`. +`symmetricDifference([1, 2, 3, 4, 5, 6, 7, 8], [1, 3, 5, 6, 7, 8, 9])` dovrebbe restituire `[2, 4, 9]`. ```js assert.deepEqual( @@ -74,7 +74,7 @@ assert.deepEqual( ); ``` -`symmetricDifference([1, 2, 4, 7, 9], [2, 3, 7, 8, 9])` should return `[1, 3, 4, 8]`. +`symmetricDifference([1, 2, 4, 7, 9], [2, 3, 7, 8, 9])` dovrebbe restituire `[1, 3, 4, 8]`. ```js assert.deepEqual(symmetricDifference([1, 2, 4, 7, 9], [2, 3, 7, 8, 9]), [ diff --git a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/taxicab-numbers.md b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/taxicab-numbers.md index 895b46ef05..4cea31dcd0 100644 --- a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/taxicab-numbers.md +++ b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/taxicab-numbers.md @@ -1,6 +1,6 @@ --- id: 594ecc0d9a8cf816e3340187 -title: Taxicab numbers +title: Numeri dei taxi challengeType: 5 forumTopicId: 302337 dashedName: taxicab-numbers @@ -8,67 +8,67 @@ dashedName: taxicab-numbers # --description-- -A [taxicab number](https://en.wikipedia.org/wiki/Hardy–Ramanujan number "wp: Hardy–Ramanujan number") (the definition that is being used here) is a positive integer that can be expressed as the sum of two positive cubes in more than one way. +Un [numero taxicab](https://en.wikipedia.org/wiki/Hardy–Ramanujan number "wp: Hardy–Ramanujan number") (la definizione che viene utilizzata qui) è un intero positivo che può essere espresso come la somma di due cubi positivi in più di un modo. -The first taxicab number is `1729`, which is: +Il primo numero di taxi è `1729`, che è: -13 + 123 and +13 + 123 e 93 + 103. -Taxicab numbers are also known as: +I numeri dei taxi sono anche conosciuti come:
- taxi numbers
- taxi-cab numbers
- taxi cab numbers -
- Hardy-Ramanujan numbers +
- Numeri di Hardy-Ramanujan
-
-
- A001235 taxicab numbers on The On-Line Encyclopedia of Integer Sequences. -
- taxicab number on Wikipedia. +
- A001235 numeri taxicab su Enciclopedia On-Line di sequenze di numeri interi. +
- numero di taxi su Wikipedia.
-
-
- The string -
- The separator character -
- The escape character +
- La stringa +
- Il carattere separatore +
- Il carattere di escape
-
-
- The fields that were separated by the separators, become the elements of the output list. -
- Empty fields should be preserved, even at the start and end. +
- I campi separati dai separatori diventano gli elementi della lista di output. +
- I campi vuoti dovrebbero essere preservati, anche all'inizio e alla fine.
-
-
- "Escaped" means preceded by an occurrence of the escape character that is not already escaped itself. -
- When the escape character precedes a character that has no special meaning, it still counts as an escape (but does not do anything special). -
- Each occurrences of the escape character that was used to escape something, should not become part of the output. +
- "Fare l'escape" significa far precedere il carattere da una occorrenza del carattere di escape. +
- Quando il carattere di escape precede un carattere che non ha alcun significato speciale, conta ancora come un escape (ma non fa nulla di speciale). +
- Ogni occorrenza del carattere di escape che è stato usato per evitare qualcosa, non dovrebbe diventare parte dell'output.
one^|uno||three^^^^|four^^^|^cuatro|-and using `|` as a separator and `^` as escape character, your function should output the following array: +e usando `|` come separatore e `^` come carattere di escape la funzione dovrebbe produrre il seguente array:
['one|uno', '', 'three^^', 'four^|cuatro', '']# --hints-- -`tokenize` should be a function. +`tokenize` dovrebbe essere una funzione. ```js assert(typeof tokenize === 'function'); ``` -`tokenize` should return an array. +`tokenize` dovrebbe restituire un array. ```js assert(typeof tokenize('a', 'b', 'c') === 'object'); ``` -`tokenize('one^|uno||three^^^^|four^^^|^cuatro|', '|', '^')` should return `['one|uno', '', 'three^^', 'four^|cuatro', '']` +`tokenize('one^|uno||three^^^^|four^^^|^cuatro|', '|', '^')` dovrebbe restituire `['one|uno', '', 'three^^', 'four^|cuatro', '']` ```js assert.deepEqual(tokenize(testStr1, '|', '^'), res1); ``` -`tokenize('a@&bcd&ef&&@@hi', '&', '@')` should return `['a&bcd', 'ef', '', '@hi']` +`tokenize('a@&bcd&ef&&@@hi', '&', '@')` dovrebbe restituire `['a&bcd', 'ef', '', '@hi']` ```js assert.deepEqual(tokenize(testStr2, '&', '@'), res2); diff --git a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/top-rank-per-group.md b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/top-rank-per-group.md index 56cd284379..602f1cfba1 100644 --- a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/top-rank-per-group.md +++ b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/top-rank-per-group.md @@ -1,6 +1,6 @@ --- id: 595011cba5a81735713873bd -title: Top rank per group +title: Classifica superiore per gruppo challengeType: 5 forumTopicId: 302339 dashedName: top-rank-per-group @@ -8,9 +8,9 @@ dashedName: top-rank-per-group # --description-- -Find the top `n` ranked data in each group, where `n` is provided as a parameter. Name of the rank and the group are also provided as parameter. +Trova i primi `n` dati classificati in ogni gruppo, dove `n` è fornito come parametro. Anche il nome del rango e del gruppo sono forniti come parametri. -Given the following data: +Forniti i seguenti dati: ```js testData1 = [ @@ -30,13 +30,13 @@ testData1 = [ ]; ``` -One could rank top 10 employees in each department by calling: +Si potrebbero classificare i primi 10 dipendenti in ogni reparto chiamando: ```js topRankPerGroup(10, testData1, 'dept', 'salary') ``` -Given the following data: +Forniti i seguenti dati: ```js testData2 = [ @@ -48,15 +48,15 @@ testData2 = [ ]; ``` -One could rank the top-rated movie in each genre by calling: +Si potrebbe classificare il film più votato in ogni genere chiamando: ```js topRankPerGroup(1, testData2, 'genre', 'rating') ``` -The function should return an array with an array for each group containing the top `n` objects. +La funzione dovrebbe restituire un array con un array per ogni gruppo contenente gli `n` oggetti superiori. -For example, given data: +Per esempio, dati: ```js [ @@ -69,7 +69,7 @@ For example, given data: ]; ``` -Top two ranking employees in each department by salary would be: +I primi due dipendenti in classifica per stipendio in ogni reparto saranno: ```js [ [ { name: 'Kim Arlich', id: 'E10001', salary: 57000, dept: 'D050' }, @@ -80,37 +80,37 @@ Top two ranking employees in each department by salary would be: # --hints-- -`topRankPerGroup` should be a function. +`topRankPerGroup` dovrebbe essere una funzione. ```js assert(typeof topRankPerGroup === 'function'); ``` -`topRankPerGroup` should return undefined on negative n values. +`topRankPerGroup` dovrebbe restituire undefined per i valori negativi di n. ```js assert(typeof topRankPerGroup(-1, []) === 'undefined'); ``` -For `topRankPerGroup(10, testData1, 'dept', 'salary')`, the first result in the first group should be `{ name: 'John Rappl', id: 'E21437', salary: 47000, dept: 'D050'}`. +Per `topRankPerGroup(10, testData1, 'dept', 'salary')`, il primo risultato nel primo gruppo dovrebbe essere `{ name: 'John Rappl', id: 'E21437', salary: 47000, dept: 'D050'}`. ```js assert.deepEqual(res1[0][0], { name: 'John Rappl', id: 'E21437', salary: 47000, dept: 'D050'}); ``` -For `topRankPerGroup(10, testData1, 'dept', 'salary')`, the last result in the last group should be `{ name: 'Adam Smith', id: 'E63535', salary: 18000, dept: 'D202' }`. +Per `topRankPerGroup(10, testData1, 'dept', 'salary')`, l'ultimo risultato nell'ultimo gruppo dovrebbe essere `{ name: 'Adam Smith', id: 'E63535', salary: 18000, dept: 'D202' }`. ```js assert.deepEqual(res1[3][3], { name: 'Adam Smith', id: 'E63535', salary: 18000, dept: 'D202' }); ``` -`topRankPerGroup(1, ...)` should return only top ranking result per group. +`topRankPerGroup(1, ...)` dovrebbe restituire solo il il primo risultato in classifica per ogni gruppo. ```js assert.equal(res2[2].length, 1); ``` -`topRankPerGroup(2, ...)` should return two ranking results per group. +`topRankPerGroup(2, ...)` dovrebbe restituire due risultati di classifica per gruppo. ```js assert.equal(res3[2][1].name, 'Maze Runner'); diff --git a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/topological-sort.md b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/topological-sort.md index f57d218e66..2aad9f15b3 100644 --- a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/topological-sort.md +++ b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/topological-sort.md @@ -1,6 +1,6 @@ --- id: 594fa2746886f41f7d8bf225 -title: Topological sort +title: Ordinamento topologico challengeType: 5 forumTopicId: 302340 dashedName: topological-sort @@ -8,21 +8,21 @@ dashedName: topological-sort # --description-- -Given a mapping between items, and items they depend on, a topological sort orders items so that no item precedes an item it depends upon. There are two popular algorithms for topological sorting: Kahn's (1962) topological sort and depth-first search. +Data una mappatura tra elementi, e elementi da cui dipendono, un ordine topologico ordina elementi in modo che nessun elemento ne precede uno da cui dipende. Ci sono due algoritmi popolari per l'ordinamento topologico: l'ordinamento topologico di Kahn (1962) e la ricerca depth-first. # --instructions-- -Write a function that will return a list with valid compile order of libraries from their dependencies. +Scrivi una funzione che restituirà una lista con un valido ordine di compilazione delle librerie dalle loro dipendenze. -- Assume library names are single words. -- Items mentioned as only dependents have no dependents of their own, but their order of compiling must be given. -- Any self dependencies should be ignored. -- Any un-orderable dependencies should be ignored. +- Supponiamo che i nomi delle librerie siano parole singole. +- Gli elementi citati solo come persone a carico non hanno dipendenze proprie, ma il loro ordine di compilazione deve essere dato. +- Qualsiasi autosufficienza dovrebbe essere ignorata. +- Eventuali dipendenze non ordinabili dovrebbero essere ignorate. -Use the following data as an example: +Utilizzare i seguenti dati come esempio:
-LIBRARY LIBRARY DEPENDENCIES +LIBRERIA DIPENDENZA DELLE LIBRERIE ======= ==================== des_system_lib std synopsys std_cell_lib des_system_lib dw02 dw01 ramlib ieee dw01 ieee dw01 dware gtech @@ -39,11 +39,11 @@ std_cell_lib ieee std_cell_lib synopsys-The compiling of a library in the VHDL language has the constraint that a library must be compiled after any library it depends on. The above data would be un-orderable if, for example, `dw04` is added to the list of dependencies of `dw01`. +La compilazione di una libreria nel linguaggio VHDL ha il vincolo che una libreria può essere compilata solo dopo ogni libreria da cui dipende. I dati di cui sopra non sarebbero ordinabili se, ad esempio, `dw04` venisse aggiunto alla lista delle dipendenze di `dw01`. -The input of the function will be a multiline string, each line will consist of the name of the library, followed by its dependencies (if exist). +L'input della funzione sarà una stringa multilinea, ogni riga consisterà del nome della libreria, seguito dalle sue dipendenze (se esistenti). -For example: +Ad esempio: ```js const libsSimple = @@ -53,37 +53,37 @@ const libsSimple = # --hints-- -`topologicalSort` should be a function. +`topologicalSort` dovrebbe essere una funzione. ```js assert(typeof topologicalSort === 'function'); ``` -`topologicalSort(libsSimple)` should return an array. +`topologicalSort(libsSimple)` dovrebbe restituire un array. ```js assert(Array.isArray(topologicalSort(libsSimple))); ``` -`topologicalSort(libsSimple)` should return `['bbb', 'aaa']`. +`topologicalSort(libsSimple)` dovrebbe restituire `['bbb', 'aaa']`. ```js assert.deepEqual(topologicalSort(libsSimple), ['bbb', 'aaa']); ``` -`topologicalSort(libsVHDL)` should return `['ieee', 'std_cell_lib', 'gtech', 'dware', 'dw07', 'dw06', 'dw05', 'dw02', 'dw01', 'dw04', 'std', 'ramlib', 'synopsys', 'dw03', 'des_system_lib']`. +`topologicalSort(libsVHDL)` dovrebbe restituire `['ieee', 'std_cell_lib', 'gtech', 'dware', 'dw07', 'dw06', 'dw05', 'dw02', 'dw01', 'dw04', 'std', 'ramlib', 'synopsys', 'dw03', 'des_system_lib']`. ```js assert.deepEqual(topologicalSort(libsVHDL), ['ieee', 'std_cell_lib', 'gtech', 'dware', 'dw07', 'dw06', 'dw05', 'dw02', 'dw01', 'dw04', 'std', 'ramlib', 'synopsys', 'dw03', 'des_system_lib']); ``` -`topologicalSort(libsCustom)` should return `['base', 'c', 'd', 'b', 'a']`. +`topologicalSort(libsCustom)` dovrebbe restituire `['base', 'c', 'd', 'b', 'a']`. ```js assert.deepEqual(topologicalSort(libsCustom), ['base', 'c', 'd', 'b', 'a']); ``` -`topologicalSort` should ignore unorderable dependencies. +`topologicalSort` dovrebbe ignorare le dipendenze non ordinabili. ```js assert.deepEqual(topologicalSort(libsUnorderable), ['Base']); diff --git a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/towers-of-hanoi.md b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/towers-of-hanoi.md index 4de9c851ba..5d5d138945 100644 --- a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/towers-of-hanoi.md +++ b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/towers-of-hanoi.md @@ -1,6 +1,6 @@ --- id: 5951ed8945deab770972ae56 -title: Towers of Hanoi +title: Torri di Hanoi challengeType: 5 forumTopicId: 302341 dashedName: towers-of-hanoi @@ -8,41 +8,41 @@ dashedName: towers-of-hanoi # --description-- -Solve the [Towers of Hanoi](https://en.wikipedia.org/wiki/Towers_of_Hanoi "wp: Towers_of_Hanoi") problem. +Risolvi il problema delle [Torri di Hanoi](https://en.wikipedia.org/wiki/Towers_of_Hanoi "wp: Towers_of_Hanoi"). -Your solution should accept the number of discs as the first parameters, and three string used to identify each of the three stacks of discs, for example `towerOfHanoi(4, 'A', 'B', 'C')`. The function should return an array of arrays containing the list of moves, source -> destination. +La soluzione dovrebbe accettare il numero di dischi come primo parametro, e tre stringhe usate per identificare ciascuna delle tre pile di dischi, ad esempio `towerOfHanoi(4, 'A', 'B', 'C')`. La funzione dovrebbe restituire un array di array contenente l'elenco delle mosse, sorgente -> destinazione. -For example, the array `[['A', 'C'], ['B', 'A']]` indicates that the 1st move was to move a disc from stack A to C, and the 2nd move was to move a disc from stack B to A. +Per esempio, l'array `[['A', 'C'], ['B', 'A']]` indica che la prima mossa è stata di spostare un disco dalla pila A alla C, e la seconda mossa è stata quella di spostare un disco dalla pila B alla A. # --hints-- -`towerOfHanoi` should be a function. +`towerOfHanoi` dovrebbe essere una funzione. ```js assert(typeof towerOfHanoi === 'function'); ``` -`towerOfHanoi(3, ...)` should return 7 moves. +`towerOfHanoi(3, ...)` dovrebbe restituire 7 mosse. ```js assert(res3.length === 7); ``` -`towerOfHanoi(3, 'A', 'B', 'C')` should return `[['A','B'], ['A','C'], ['B','C'], ['A','B'], ['C','A'], ['C','B'], ['A','B']]`. +`towerOfHanoi(3, 'A', 'B', 'C')` dovrebbe restituire `[['A','B'], ['A','C'], ['B','C'], ['A','B'], ['C','A'], ['C','B'], ['A','B']]`. ```js assert.deepEqual(towerOfHanoi(3, 'A', 'B', 'C'), res3Moves); ``` -`towerOfHanoi(5, "X", "Y", "Z")` 10th move should be Y -> X. +La decima mossa di `towerOfHanoi(5, "X", "Y", "Z")` dovrebbe essere Y -> X. ```js assert.deepEqual(res5[9], ['Y', 'X']); ``` -`towerOfHanoi(7, 'A', 'B', 'C')` first ten moves should be `[['A','B'], ['A','C'], ['B','C'], ['A','B'], ['C','A'], ['C','B'], ['A','B'], ['A','C'], ['B','C'], ['B','A']]` +Le prime dieci mosse di `towerOfHanoi(7, 'A', 'B', 'C')` dovrebbero essere `['A','B'], ['A','C'], ['B','C'], ['A','B'], ['C','A'], ['C','B'], ['A','B'], ['A','C'], ['B','A']]` ```js assert.deepEqual(towerOfHanoi(7, 'A', 'B', 'C').slice(0, 10), res7First10Moves); diff --git a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/vector-cross-product.md b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/vector-cross-product.md index 4dab99b445..cef64cca88 100644 --- a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/vector-cross-product.md +++ b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/vector-cross-product.md @@ -1,6 +1,6 @@ --- id: 594810f028c0303b75339ad2 -title: Vector cross product +title: Prodotto vettoriale challengeType: 5 forumTopicId: 302342 dashedName: vector-cross-product @@ -8,27 +8,27 @@ dashedName: vector-cross-product # --description-- -A vector is defined as having three dimensions as being represented by an ordered collection of three numbers: (X, Y, Z). +Un vettore è definito come avente tre dimensioni e può essere rappresentato da una raccolta ordinata di tre numeri: (X, Y, Z). # --instructions-- -Write a function that takes two vectors (arrays) as input and computes their cross product. Your function should return `null` on invalid inputs such as vectors of different lengths. +Scrivi una funzione che prende due vettori (arrays) come input e calcola il loro prodotto vettoriale. La tua funzione dovrebbe restituire `null` su input non validi, come vettori di diverse lunghezze. # --hints-- -`crossProduct` should be a function. +`crossProduct` dovrebbe essere una funzione. ```js assert.equal(typeof crossProduct, 'function'); ``` -`crossProduct()` should return null. +`crossProduct()` dovrebbe restituire null. ```js assert.equal(crossProduct(), null); ``` -`crossProduct([1, 2, 3], [4, 5, 6])` should return `[-3, 6, -3]`. +`crossProduct([1, 2, 3], [4, 5, 6])` dovrebbe restituire `[-3, 6, -3]`. ```js assert.deepEqual(res12, exp12); diff --git a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/vector-dot-product.md b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/vector-dot-product.md index fb8ae242ae..0b658fadaf 100644 --- a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/vector-dot-product.md +++ b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/vector-dot-product.md @@ -1,6 +1,6 @@ --- id: 594810f028c0303b75339ad3 -title: Vector dot product +title: Prodotto scalare challengeType: 5 forumTopicId: 302343 dashedName: vector-dot-product @@ -8,51 +8,51 @@ dashedName: vector-dot-product # --description-- -A vector can have one or more values represented by an ordered collection. Examples could be (x), (x, y), or (x, y, z). +Un vettore può avere uno o più valori rappresentati da una collezione ordinata. Esempi potrebbero essere (x), (x, y), o (x, y, z). # --instructions-- -Write a function that takes two vectors (represented as one-dimensional arrays) as input and computes their dot product. Your function should return `null` on invalid inputs such as vectors of different lengths or passing anything other than two vectors. +Scrivi una funzione che prende due vettori (rappresentati come matrici unidimensionali) come input e calcola il loro prodotto scalare. La tua funzione dovrebbe restituire `null` per input non validi come vettori di diverse lunghezze, o per qualsiasi cosa che non sia due vettori. # --hints-- -`dotProduct` should be a function. +`dotProduct` dovrebbe essere una funzione. ```js assert.equal(typeof dotProduct, 'function'); ``` -`dotProduct()` should return `null`. +`dotProduct()` dovrebbe restituire `null`. ```js assert.equal(dotProduct(), null); ``` -`dotProduct([1], [1])` should return `1`. +`dotProduct([1], [1])` dovrebbe restituire `1`. ```js assert.equal(dotProduct([1], [1]), 1); ``` -`dotProduct([1], [1, 2])` should return `null`. +`dotProduct([1], [1, 2])` dovrebbe restituire `null`. ```js assert.equal(dotProduct([1], [1, 2]), null); ``` -`dotProduct([1, 3, -5], [4, -2, -1])` should return `3`. +`dotProduct([1, 3, -5], [4, -2, -1])` dovrebbe restituire `3`. ```js assert.equal(dotProduct([1, 3, -5], [4, -2, -1]), 3); ``` -`dotProduct([3, 2, 1], [2, 4, 2], [5, 3, 1])` should return `null`. +`dotProduct([3, 2, 1], [2, 4, 2], [5, 3, 1])` dovrebbe restituire `null`. ```js assert.equal(dotProduct([3, 2, 1], [2, 4, 2], [5, 3, 1]), null); ``` -`dotProduct([ 0, 3, 6, 9, 12 ], [ 0, 4, 8, 12, 16 ])` should return `360`. +`dotProduct([ 0, 3, 6, 9, 12 ], [ 0, 4, 8, 12, 16 ])` dovrebbe restituire `360`. ```js assert.equal(dotProduct([ 0, 3, 6, 9, 12 ], [ 0, 4, 8, 12, 16 ]), 360); diff --git a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/word-frequency.md b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/word-frequency.md index 70d2d054dc..5ae6ccfac7 100644 --- a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/word-frequency.md +++ b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/word-frequency.md @@ -1,6 +1,6 @@ --- id: 5e94a54cc7b022105bf0fd2c -title: Word frequency +title: Frequenza delle parole challengeType: 5 forumTopicId: 393913 dashedName: word-frequency @@ -8,68 +8,68 @@ dashedName: word-frequency # --description-- -Given a text string and an integer n, return the n most common words in the file (and the number of their occurrences) in decreasing frequency. +Data una stringa di testo e un intero n, restituire le n parole più comuni nel file (e il numero delle loro occorrenze) in ordine di frequenza decrescente. # --instructions-- -Write a function to count the occurrences of each word and return the n most commons words along with the number of their occurences in decreasing frequency. +Scrivere una funzione per contare le occorrenze di ogni parola e restituire le n parole più comuni insieme al numero delle loro occorrenze in ordine di frequenza decrescente. -The function should return a 2D array with each of the elements in the following form: `[word, freq]`. `word` should be the lowercase version of the word and `freq` the number denoting the count. +La funzione dovrebbe restituire un array 2D con ciascuno degli elementi nella seguente forma: `[word, freq]`. `word` dovrebbe essere la versione minuscola della parola e `freq` il numero che indica il conteggio. -The function should return an empty array, if no string is provided. +La funzione dovrebbe restituire un array vuoto, se non viene fornita alcuna stringa. -The function should be case insensitive, for example, the strings "Hello" and "hello" should be treated the same. +La funzione dovrebbe ignorare maiuscole e minuscole, per esempio, le stringe "Hello" e "hello" devono essere trattate allo stesso modo. -You can treat words that have special characters such as underscores, dashes, apostrophes, commas, etc., as distinct words. +Puoi le parole che hanno caratteri speciali come sottolineature, trattini, apostrofi, virgole, ecc., come parole distinte. -For example, given the string "Hello hello goodbye", your function should return `[['hello', 2], ['goodbye', 1]]`. +Per esempio, data la stringa "Hello hello goodbye", la tua funzione dovrebbe restituire `[['hello', 2], ['goodbye', 1]]`. # --hints-- -`wordFrequency` should be a function. +`wordFrequency` dovrebbe essere una funzione. ```js assert(typeof wordFrequency == 'function'); ``` -`wordFrequency` should return an array. +`wordFrequency` dovrebbe restituire un array. ```js assert(Array.isArray(wordFrequency('test'))); ``` -`wordFrequency("Hello hello world", 2)` should return `[['hello', 2], ['world', 1]]` +`wordFrequency("Hello hello world", 2)` dovrebbe restituire `[['hello', 2], ['world', 1]]` ```js assert.deepEqual(wordFrequency(example_1, 2), example_1_solution); ``` -`wordFrequency("The quick brown fox jumped over the lazy dog", 1)` should return `[['the', 2]]` +`wordFrequency("The quick brown fox jumped over the lazy dog", 1)` dovrebbe restituire `[['the', 2]]` ```js assert.deepEqual(wordFrequency(example_2, 1), example_2_solution); ``` -`wordFrequency("Opensource opensource open-source open source", 1)` should return `[['opensource', 2]]` +`wordFrequency("Opensource opensource open-source open source", 1)` dovrebbe restituire `[['opensource', 2]]` ```js assert.deepEqual(wordFrequency(example_3, 1), example_3_solution); ``` -`wordFrequency("Apple App apply aPP aPPlE", 3)` should return `[['app', 2], ['apple', 2], ['apply', 1]]` or `[['apple', 2], ['app', 2], ['apply', 1]]` +`wordFrequency("Apple App apply aPP aPPlE", 3)` dovrebbe restituire `[['app', 2], ['apple', 2], ['apply', 1]]` oppure `[['apple', 2], ['app', 2], ['apply', 1]]` ```js const arr = JSON.stringify(wordFrequency(example_4, 3)); assert(arr === example_4_solution_a || arr === example_4_solution_b); ``` -`wordFrequency("c d a d c a b d d c", 4)` should return `[['d', 4], ['c', 3], ['a', 2], ['b', 1]]` +`wordFrequency("c d a d c a b d d c", 4)` dovrebbe restituire `[['d', 4], ['c', 3], ['a', 2], ['b', 1]]` ```js assert.deepEqual(wordFrequency(example_5, 4), example_5_solution); ``` -`wordFrequency("", 5)` should return `[]` +`wordFrequency("", 5)` dovrebbe restituire `[]` ```js assert.deepEqual(wordFrequency(example_6, 5), example_6_solution); diff --git a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/word-wrap.md b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/word-wrap.md index 344be87802..dff3b7efb2 100644 --- a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/word-wrap.md +++ b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/word-wrap.md @@ -1,6 +1,6 @@ --- id: 594810f028c0303b75339ad4 -title: Word wrap +title: Mandare a capo challengeType: 5 forumTopicId: 302344 dashedName: word-wrap @@ -8,11 +8,11 @@ dashedName: word-wrap # --description-- -Even today, with proportional fonts and complex layouts, there are still cases where you need to wrap text at a specified column. The basic task is to wrap a paragraph of text in a simple way. +Ancora oggi, con caratteri proporzionali e layout complessi, ci sono ancora casi in cui è necessario mandare a capo il testo in una colonna specificata. Il compito di base è quello di chiudere un paragrafo di testo in modo semplice. # --instructions-- -Write a function that can wrap this text to any number of characters. As an example, the text wrapped to 80 characters should look like the following: +Scrivi una funzione che può mandare a capo questo testo a qualsiasi numero di caratteri. Ad esempio, il testo a capo di 80 caratteri dovrebbe assomigliare a quanto segue:
Wrap text using a more sophisticated algorithm such as the Knuth and Plass TeX
@@ -23,37 +23,37 @@ than a simple minimum length algorithm.
# --hints--
-wrap should be a function.
+wrap dovrebbe essere una funzione.
```js
assert.equal(typeof wrap, 'function');
```
-wrap should return a string.
+wrap dovrebbe restituire una stringa.
```js
assert.equal(typeof wrap('abc', 10), 'string');
```
-wrap(80) should return 4 lines.
+wrap(80) dovrebbe restituire 4 righe.
```js
assert(wrapped80.split('\n').length === 4);
```
-Your `wrap` function should return our expected text.
+La funzione `wrap` dovrebbe restituire il testo previsto.
```js
assert.equal(wrapped80.split('\n')[0], firstRow80);
```
-wrap(42) should return 7 lines.
+wrap(42) dovrebbe restituire 7 righe.
```js
assert(wrapped42.split('\n').length === 7);
```
-Your `wrap` function should return our expected text.
+La funzione `wrap` dovrebbe restituire il testo previsto.
```js
assert.equal(wrapped42.split('\n')[0], firstRow42);
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/y-combinator.md b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/y-combinator.md
index f76ab91e3c..c5c12f2b33 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/y-combinator.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/y-combinator.md
@@ -1,6 +1,6 @@
---
id: 594810f028c0303b75339ad5
-title: Y combinator
+title: Combinatore Y
challengeType: 5
forumTopicId: 302345
dashedName: y-combinator
@@ -8,11 +8,11 @@ dashedName: y-combinator
# --description--
-In strict [functional programming](https://en.wikipedia.org/wiki/Functional programming "wp: functional programming") and the [lambda calculus](https://en.wikipedia.org/wiki/lambda calculus "wp: lambda calculus"), functions (lambda expressions) don't have state and are only allowed to refer to arguments of enclosing functions. This rules out the usual definition of a recursive function wherein a function is associated with the state of a variable and this variable's state is used in the body of the function. The [Y combinator](https://mvanier.livejournal.com/2897.html) is itself a stateless function that, when applied to another stateless function, returns a recursive version of the function. The Y combinator is the simplest of the class of such functions, called [fixed-point combinators](https://en.wikipedia.org/wiki/Fixed-point combinator "wp: fixed-point combinator").
+In rigorosa [proframmazione funzionale](https://www.freecodecamp.org/news/the-principles-of-functional-programming/ "news: the principles of functional programming") e [calcolo lambda](https://en.wikipedia.org/wiki/lambda calculus "wp: lambda calculus"), le funzioni (espressioni lambda) non hanno stato e sono autorizzate solo a fare riferimento a argomenti di funzioni di chiusura. Questo esclude la definizione abituale di una funzione ricorsiva in cui una funzione è associata allo stato di una variabile e lo stato di questa variabile è usato nel corpo della funzione. Il combinatore [Y](https://mvanier.livejournal.com/2897.html) è di per sé una funzione apolide che, se applicata ad un'altra funzione senza stato, restituisce una versione ricorsiva della funzione. Il combinatore Y è il più semplice della classe di tali funzioni, chiamati [combinatori a punto fisso](https://en.wikipedia.org/wiki/Fixed-point combinator "wp: fixed-point combinator").
# --instructions--
-Define the stateless Y combinator function and use it to compute [factorial](https://en.wikipedia.org/wiki/Factorial "wp: factorial"). The `factorial(N)` function is already given to you. **See also:**
+Definire la funzione di combinatore Y senza stato e usarla per calcolare il [fattoriale](https://en.wikipedia.org/wiki/Factorial "wp: factorial"). La funzione `factorial(N)` ti viene data. **Vedi anche:**
- Jim Weirich: Adventures in Functional Programming. @@ -20,37 +20,37 @@ Define the stateless Y combinator function and use it to compute [factorial](htt # --hints-- -Y should return a function. +Y dovrebbe restituire una funzione. ```js assert.equal(typeof Y((f) => (n) => n), 'function'); ``` -factorial(1) should return 1. +factorial(1) dovrebbe restituire 1. ```js assert.equal(factorial(1), 1); ``` -factorial(2) should return 2. +factorial(2) dovrebbe restituire 2. ```js assert.equal(factorial(2), 2); ``` -factorial(3) should return 6. +factorial(3) dovrebbe restituire 6. ```js assert.equal(factorial(3), 6); ``` -factorial(4) should return 24. +factorial(4) dovrebbe restituire 24. ```js assert.equal(factorial(4), 24); ``` -factorial(10) should return 3628800. +factorial(10) dovrebbe restituire 3628800. ```js assert.equal(factorial(10), 3628800); diff --git a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/zeckendorf-number-representation.md b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/zeckendorf-number-representation.md index 7794021986..aca2c25f50 100644 --- a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/zeckendorf-number-representation.md +++ b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/zeckendorf-number-representation.md @@ -1,6 +1,6 @@ --- id: 594810f028c0303b75339ad6 -title: Zeckendorf number representation +title: Rappresentazione di Zeckendorf dei numeri challengeType: 5 forumTopicId: 302346 dashedName: zeckendorf-number-representation @@ -8,144 +8,144 @@ dashedName: zeckendorf-number-representation # --description-- -Just as numbers can be represented in a positional notation as sums of multiples of the powers of ten (decimal) or two (binary); all the positive integers can be represented as the sum of one or zero times the distinct members of the Fibonacci series. Recall that the first six distinct Fibonacci numbers are: `1, 2, 3, 5, 8, 13`. +Così come i numeri possono essere rappresentati in una notazione posizionale come somme di multipli delle potenze di dieci (decimali) o due (binario), tutti gli interi positivi possono essere rappresentati come la somma di una o zero volte i membri distinti della serie di Fibonacci. Ricorda che i primi sei numeri distinti di Fibonacci sono: `1, 2, 3, 5, 8, 13`. -The decimal number eleven can be written as `0*13 + 1*8 + 0*5 + 1*3 + 0*2 + 0*1` or `010100` in positional notation where the columns represent multiplication by a particular member of the sequence. Leading zeroes are dropped so that 11 decimal becomes `10100`. 10100 is not the only way to make 11 from the Fibonacci numbers however `0*13 + 1*8 + 0*5 + 0*3 + 1*2 + 1*1` or 010011 would also represent decimal 11. For a true Zeckendorf number there is the added restriction that *no two consecutive Fibonacci numbers can be used* which leads to the former unique solution. +Il numero decimale undici può essere scritto come `0*13 + 1*8 + 0*5 + 1*3 + 0*2 + 0*1` o `010100` nella notazione posizionale in cui le colonne rappresentano la moltiplicazione per un particolare membro della sequenza. Gli zeri iniziali sono caduti in modo che 11 decimale diventa `10100`. 10100 non è l'unico modo per formare 11 dai numeri di Fibonacci: anche `0*13 + 1*8 + 0*5 + 0*3 + 1*2 + 1*1` o 010011 rappresenta il decimale 11. Per un vero numero di Zeckendorf c'è la restrizione che *non possono essere utilizzati due numeri consecutivi di Fibonacci* che porta alla precedente soluzione unica. # --instructions-- -Write a function that generates and returns the Zeckendorf number representation of `n`. +Scrivi una funzione che genera e restituisce la rappresentazione di Zeckendorf del numero `n`. # --hints-- -`zeckendorf` should be a function. +`zeckendorf` dovrebbe essere una funzione. ```js assert.equal(typeof zeckendorf, 'function'); ``` -`zeckendorf(0)` should return `0`. +`zeckendorf(0)` dovrebbe restituire `0`. ```js assert.equal(zeckendorf(0), 0); ``` -`zeckendorf(1)` should return `1`. +`zeckendorf(1)` dovrebbe restituire `1`. ```js assert.equal(zeckendorf(1), 1); ``` -`zeckendorf(2)` should return `10`. +`zeckendorf(2)` dovrebbe restituire `10`. ```js assert.equal(zeckendorf(2), 10); ``` -`zeckendorf(3)` should return `100`. +`zeckendorf(3)` dovrebbe restituire `100`. ```js assert.equal(zeckendorf(3), 100); ``` -`zeckendorf(4)` should return `101`. +`zeckendorf(4)` dovrebbe restituire `101`. ```js assert.equal(zeckendorf(4), 101); ``` -`zeckendorf(5)` should return `1000`. +`zeckendorf(5)` dovrebbe restituire `1000`. ```js assert.equal(zeckendorf(5), 1000); ``` -`zeckendorf(6)` should return `1001`. +`zeckendorf(6)` dovrebbe restituire `1001`. ```js assert.equal(zeckendorf(6), 1001); ``` -`zeckendorf(7)` should return `1010`. +`zeckendorf(7)` dovrebbe restituire `1010`. ```js assert.equal(zeckendorf(7), 1010); ``` -`zeckendorf(8)` should return `10000`. +`zeckendorf(8)` dovrebbe restituire `10000`. ```js assert.equal(zeckendorf(8), 10000); ``` -`zeckendorf(9)` should return `10001`. +`zeckendorf(9)` dovrebbe restituire `10001`. ```js assert.equal(zeckendorf(9), 10001); ``` -`zeckendorf(10)` should return `10010`. +`zeckendorf(10)` dovrebbe restituire `10010`. ```js assert.equal(zeckendorf(10), 10010); ``` -`zeckendorf(11)` should return `10100`. +`zeckendorf(11)` dovrebbe restituire `10100`. ```js assert.equal(zeckendorf(11), 10100); ``` -`zeckendorf(12)` should return `10101`. +`zeckendorf(12)` dovrebbe restituire `10101`. ```js assert.equal(zeckendorf(12), 10101); ``` -`zeckendorf(13)` should return `100000`. +`zeckendorf(13)` dovrebbe restituire `100000`. ```js assert.equal(zeckendorf(13), 100000); ``` -`zeckendorf(14)` should return `100001`. +`zeckendorf(14)` dovrebbe restituire `100001`. ```js assert.equal(zeckendorf(14), 100001); ``` -`zeckendorf(15)` should return `100010`. +`zeckendorf(15)` dovrebbe restituire `100010`. ```js assert.equal(zeckendorf(15), 100010); ``` -`zeckendorf(16)` should return `100100`. +`zeckendorf(16)` dovrebbe restituire `100100`. ```js assert.equal(zeckendorf(16), 100100); ``` -`zeckendorf(17)` should return `100101`. +`zeckendorf(17)` dovrebbe restituire `100101`. ```js assert.equal(zeckendorf(17), 100101); ``` -`zeckendorf(18)` should return `101000`. +`zeckendorf(18)` dovrebbe restituire `101000`. ```js assert.equal(zeckendorf(18), 101000); ``` -`zeckendorf(19)` should return `101001`. +`zeckendorf(19)` dovrebbe restituire `101001`. ```js assert.equal(zeckendorf(19), 101001); ``` -`zeckendorf(20)` should return `101010`. +`zeckendorf(20)` dovrebbe restituire `101010`. ```js assert.equal(zeckendorf(20), 101010); diff --git a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/zhang-suen-thinning-algorithm.md b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/zhang-suen-thinning-algorithm.md index d3970f2f72..390583605e 100644 --- a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/zhang-suen-thinning-algorithm.md +++ b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/zhang-suen-thinning-algorithm.md @@ -1,6 +1,6 @@ --- id: 594810f028c0303b75339ad7 -title: Zhang-Suen thinning algorithm +title: L'algoritmo di semplificazione di Zhang-Suen challengeType: 5 forumTopicId: 302347 dashedName: zhang-suen-thinning-algorithm @@ -8,7 +8,7 @@ dashedName: zhang-suen-thinning-algorithm # --description-- -This is an algorithm used to thin a black and white i.e. one bit per pixel images. For example, with an input image of: +Questo è un algoritmo usato per comprimere immagini in bianco e nero, cioè con un bit per ogni pixel. Ad esempio, fornendo la seguente immagine: ```js const testImage1 = [ @@ -25,7 +25,7 @@ const testImage1 = [ ]; ``` -It produces the thinned output: +Produce il seguente output semplificato: ```js [ ' ', @@ -40,76 +40,76 @@ It produces the thinned output: ' ' ]; ``` -## Algorithm +## Algoritmo -Assume black pixels are one and white pixels zero, and that the input image is a rectangular N by M array of ones and zeroes. The algorithm operates on all black pixels P1 that can have eight neighbours. The neighbours are, in order, arranged as: +Supponiamo che i pixel neri siano 1 e i pixel bianchi 0, e che l'immagine in ingresso sia una matrice rettangolare N x M di 1 e 0. L'algoritmo opera su tutti i pixel P1 neri che possono avere otto vicini. I vicini sono, in ordine, disposti come: $$\begin{array}{|c|c|c|} \\hline P9 & P2 & P3\\\\ \\hline P8 & \boldsymbol{P1} & P4\\\\ \\hline P7 & P6 & P5\\\\ \\hline \end{array}$$ -Obviously the boundary pixels of the image cannot have the full eight neighbours. +Ovviamente i pixel ai margini dell'immagine non possono avere gli otto vicini. -- Define $A(P1)$ = the number of transitions from white to black, ($0 \to 1$) in the sequence P2, P3, P4, P5, P6, P7, P8, P9, P2. (Note the extra P2 at the end - it is circular). -- Define $B(P1)$ = the number of black pixel neighbours of P1. ($= \\sum(P2 \ldots P9)$) +- Definire $A(P1)$ = il numero di transizioni da bianco a nero, ($0 \to 1$) nella sequenza P2, P3, P4, P5, P6, P7, P8, P9, P2. (Si noti il P2 extra alla fine - è circolare). +- Sia $B(P1)$ = il numero di pixel neri vicini a P1. ($= \\sum(P2 \ldots P9)$) **Step 1:** -All pixels are tested and pixels satisfying all the following conditions (simultaneously) are just noted at this stage. +Tutti i pixel sono testati e i pixel che soddisfano tutte le condizioni seguenti (contemporaneamente) sono solo annotati in questa fase. -1. The pixel is black and has eight neighbours +1. Il pixel è nero e ha otto vicini 2. $2 \le B(P1) \le 6$ 3. $A(P1) = 1$ -4. At least one of $P2$, $P4$ and $P6$ is white -5. At least one of $P4$, $P6$ and $P8$ is white +4. Almeno uno tra $P2$, $P4$ e $P6$ è bianco +5. Almeno uno tra $P4$, $P6$ e $P8$ è bianco -After iterating over the image and collecting all the pixels satisfying all step 1 conditions, all these condition satisfying pixels are set to white. +Dopo aver iterato sull'immagine e aver raccolto tutti i pixel che soddisfano tutte le condizioni del passaggio 1, tutti questi pixel sono impostati su bianco. **Step 2:** -All pixels are again tested and pixels satisfying all the following conditions are just noted at this stage. +Tutti i pixel sono di nuovo testati e i pixel che soddisfano tutte le condizioni seguenti sono solo annotati in questa fase. -1. The pixel is black and has eight neighbours +1. Il pixel è nero e ha otto vicini 2. $2 \le B(P1) \le 6$ 3. $A(P1) = 1$ -4. At least one of $P2$, $P4$ and $P8$ is white -5. At least one of $P2$, $P6$ and $P8$ is white +4. Almeno uno tra $P2$, $P4$ e $P8$ è bianco +5. Almeno uno tra $P2$, $P6$ e $P8$ è bianco -After iterating over the image and collecting all the pixels satisfying all step 2 conditions, all these condition satisfying pixels are again set to white. +Dopo aver iterato sull'intera immagine e aver raccolto tutti i pixel che soddisfano tutte le condizioni del passaggio 2, tutti questi pixel sono di nuovo impostati su bianco. -**Iteration:** +**Iterazione:** -If any pixels were set in this round of either step 1 or step 2 then all steps are repeated until no image pixels are so changed. +Se un pixel è stato impostato in questa iterazione al passo 1 o 2, tutti i passi vengono ripetuti fino a quando nessun pixel dell'immagine non viene così modificato. # --instructions-- -Write a routine to perform Zhang-Suen thinning on the provided `image`, an array of strings, where each string represents single line of the image. In the string, `#` represents black pixel, and whitespace represents white pixel. Function should return thinned image, using the same representation. +Scrivi una routine per eseguire la compressione di Zhang-Suen sull'immagine `image` fornita, un insieme di stringhe, in cui ogni stringa rappresenta una singola riga dell'immagine. Nella stringa, `#` rappresenta i pixel neri e lo spazio vuoto quelli bianchi. La funzione dovrebbe restituire l'immagine assottigliata, usando la stessa rappresentazione. # --hints-- -`thinImage` should be a function. +`thinImage` dovrebbe essere una funzione. ```js assert.equal(typeof thinImage, 'function'); ``` -`thinImage` should return an array. +`thinImage` dovrebbe restituire un array. ```js assert(Array.isArray(thinImage(_testImage1))); ``` -`thinImage` should return an array of strings. +`thinImage` dovrebbe restituire un array di stringhe. ```js assert.equal(typeof thinImage(_testImage1)[0], 'string'); ``` -`thinImage(testImage1)` should return a thinned image as in the example. +`thinImage(testImage1)` dovrebbe restituire un'immagine assottigliata come nell'esempio. ```js assert.deepEqual(thinImage(_testImage1), expected1); ``` -`thinImage(testImage2)` should return a thinned image. +`thinImage(testImage2)` dovrebbe restituire un'immagine assottigliata. ```js assert.deepEqual(thinImage(_testImage2), expected2); diff --git a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/zig-zag-matrix.md b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/zig-zag-matrix.md index 4f5277c28a..7e5b833e1b 100644 --- a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/zig-zag-matrix.md +++ b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/zig-zag-matrix.md @@ -1,6 +1,6 @@ --- id: 594810f028c0303b75339ad8 -title: Zig-zag matrix +title: Matrice a zig-zag challengeType: 5 forumTopicId: 302348 dashedName: zig-zag-matrix @@ -8,9 +8,9 @@ dashedName: zig-zag-matrix # --description-- -A 'zig-zag' array is a square arrangement of the first $N^2$ integers, where the numbers increase sequentially as you zig-zag along the array's [anti-diagonals](https://en.wiktionary.org/wiki/antidiagonal). +Un array 'zig-zag' è una disposizione quadrata dei primi $N^2$ interi, dove i numeri aumentano sequenzialmente mentre si zig-zaga lungo le [anti-diagonali](https://en.wiktionary.org/wiki/antidiagonal) dell'array. -For example, for the input `5`, the following result should be produced: +Per esempio, se come input viene fornito `5`, questo dovrebbe essere il risultato prodotto:
0 1 5 6 14
@@ -22,41 +22,41 @@ For example, for the input `5`, the following result should be produced:
# --instructions--
-Write a function that takes the size of the zig-zag matrix, and returns the corresponding matrix as two-dimensional array.
+Scrivi una funzione che prendere la dimensione della matrice a zig-zag, e ritorna la matrice corrispondente come un array a 2 dimensioni.
# --hints--
-ZigZagMatrix should be a function.
+ZigZagMatrix dovrebbe essere una funzione.
```js
assert.equal(typeof ZigZagMatrix, 'function');
```
-ZigZagMatrix should return array.
+ZigZagMatrix deve restituire array.
```js
assert.equal(typeof ZigZagMatrix(1), 'object');
```
-ZigZagMatrix should return an array of nested arrays.
+ZigZagMatrix dovrebbe restituire un array di array annidati.
```js
assert.equal(typeof ZigZagMatrix(1)[0], 'object');
```
-ZigZagMatrix(1) should return \[[0]].
+ZigZagMatrix(1) dovrebbe restituire \[[0]].
```js
assert.deepEqual(ZigZagMatrix(1), zm1);
```
-ZigZagMatrix(2) should return \[[0, 1], [2, 3]].
+ZigZagMatrix(2) dovrebbe restituire \[[0, 1], [2, 3]].
```js
assert.deepEqual(ZigZagMatrix(2), zm2);
```
-ZigZagMatrix(5) should return specified matrix.
+ZigZagMatrix(5) deve restituire la matrice specificata.
```js
assert.deepEqual(ZigZagMatrix(5), zm5);
diff --git a/curriculum/challenges/japanese/02-javascript-algorithms-and-data-structures/basic-javascript/declare-a-read-only-variable-with-the-const-keyword.md b/curriculum/challenges/japanese/02-javascript-algorithms-and-data-structures/basic-javascript/declare-a-read-only-variable-with-the-const-keyword.md
index 8e10737d68..18957da95a 100644
--- a/curriculum/challenges/japanese/02-javascript-algorithms-and-data-structures/basic-javascript/declare-a-read-only-variable-with-the-const-keyword.md
+++ b/curriculum/challenges/japanese/02-javascript-algorithms-and-data-structures/basic-javascript/declare-a-read-only-variable-with-the-const-keyword.md
@@ -21,23 +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--
-コードを変更して、すべての変数を `let` または `const` を使用して宣言してください。 変更を必要とする変数には `let` を使用し、定数にする必要がある変数には `const` を使用してください。 また、`const` で宣言した変数の名前について、すべて英大文字にするという一般的な慣習に従うように変更してください。
+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.
# --hints--
-`var` がコード内に存在しない必要があります。
+`var` should not exist in your code.
```js
(getUserInput) => assert(!getUserInput('index').match(/var/g));
```
-`fCC` をすべて英大文字に変更する必要があります。
+You should change `fCC` to all uppercase.
```js
(getUserInput) => {
@@ -46,20 +44,20 @@ FAV_PET = "Dogs";
}
```
-`FCC` は `const` で宣言された定数変数である必要があります。
+`FCC` should be a constant variable declared with `const`.
```js
assert.equal(FCC, 'freeCodeCamp');
assert.match(code, /const\s+FCC/);
```
-`fact` は `let` を使用して宣言する必要があります。
+`fact` should be declared with `let`.
```js
(getUserInput) => assert(getUserInput('index').match(/(let fact)/g));
```
-`console.log` を、`FCC` と `fact` 変数を出力するように変更する必要があります。
+`console.log` should be changed to print the `FCC` and `fact` variables.
```js
(getUserInput) =>
diff --git a/curriculum/challenges/japanese/02-javascript-algorithms-and-data-structures/debugging/use-typeof-to-check-the-type-of-a-variable.md b/curriculum/challenges/japanese/02-javascript-algorithms-and-data-structures/debugging/use-typeof-to-check-the-type-of-a-variable.md
index adce0537c6..f6f66a013d 100644
--- a/curriculum/challenges/japanese/02-javascript-algorithms-and-data-structures/debugging/use-typeof-to-check-the-type-of-a-variable.md
+++ b/curriculum/challenges/japanese/02-javascript-algorithms-and-data-structures/debugging/use-typeof-to-check-the-type-of-a-variable.md
@@ -21,7 +21,7 @@ console.log(typeof {});
コンソールには、文字列 `string`、`number`、`object`、`object` が順番に表示されます。
-JavaScript recognizes seven primitive (immutable) data types: `Boolean`, `Null`, `Undefined`, `Number`, `String`, `Symbol` (new with ES6), and `BigInt` (new with ES2020), and one type for mutable items: `Object`. JavaScript では、配列は厳密にはオブジェクトの一種であることに注意してください。
+JavaScript は 7 つのプリミティブな (イミュータブル) データ型として、`Boolean`、`Null`、`Undefined`、`Number`、`String`、`Symbol` (ES6 で追加)、および `BigInt` (ES2020 で追加) を認識します。また、ミュータブルアイテムのための型の 1 つである `Object` も認識します。 JavaScript では、配列は厳密にはオブジェクトの一種であることに注意してください。
# --instructions--
diff --git a/curriculum/challenges/japanese/10-coding-interview-prep/data-structures/depth-first-search.md b/curriculum/challenges/japanese/10-coding-interview-prep/data-structures/depth-first-search.md
index 88349ab43b..e84e1c0c8f 100644
--- a/curriculum/challenges/japanese/10-coding-interview-prep/data-structures/depth-first-search.md
+++ b/curriculum/challenges/japanese/10-coding-interview-prep/data-structures/depth-first-search.md
@@ -49,7 +49,7 @@ assert.sameMembers(
);
```
-The input graph `[[0, 1, 0, 0], [1, 0, 1, 0], [0, 1, 0, 1], [0, 0, 1, 0]]` with a start node of `3` should return an array with `3`, `2`, `1`, and `0`.
+`3` を開始ノードとする入力グラフ `[[0, 1, 0, 0], [1, 0, 1, 0], [0, 1, 0, 1], [0, 0, 1, 0]]` は、`3`、`2`、`1`、`0` を持つ配列を返す必要があります。
```js
assert.sameMembers(
@@ -66,7 +66,7 @@ assert.sameMembers(
);
```
-The input graph `[[0, 1, 0, 0], [1, 0, 1, 0], [0, 1, 0, 1], [0, 0, 1, 0]]` with a start node of `1` should return an array with four elements.
+`1` を開始ノードとする入力グラフ `[[0, 1, 0, 0], [1, 0, 1, 0], [0, 1, 0, 1], [0, 0, 1, 0]]` は、4 つの要素を持つ配列を返す必要があります。
```js
assert(
@@ -82,7 +82,7 @@ assert(
);
```
-The input graph `[[0, 1, 0, 0], [1, 0, 1, 0], [0, 1, 0, 0], [0, 0, 0, 0]]` with a start node of `3` should return an array with `3`.
+`3` を開始ノードとする入力グラフ `[[0, 1, 0, 0], [1, 0, 1, 0], [0, 1, 0, 0], [0, 0, 0, 0]]` は、`3` を持つ配列を返す必要があります。
```js
assert.sameMembers(
@@ -99,7 +99,7 @@ assert.sameMembers(
);
```
-The input graph `[[0, 1, 0, 0], [1, 0, 1, 0], [0, 1, 0, 0], [0, 0, 0, 0]]` with a start node of `3` should return an array with one element.
+`3` を開始ノードとする入力グラフ `[[0, 1, 0, 0], [1, 0, 1, 0], [0, 1, 0, 0], [0, 0, 0, 0]]` は、1 つの要素を持つ配列を返す必要があります。
```js
assert(
@@ -115,7 +115,7 @@ assert(
);
```
-The input graph `[[0, 1, 0, 0], [1, 0, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0]]` with a start node of `3` should return an array with `2` and `3`.
+`3` を開始ノードとする入力グラフ `[[0, 1, 0, 0], [1, 0, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0]]`は、`2` と `3` を持つ配列を返す必要があります。
```js
assert.sameMembers(
@@ -132,7 +132,7 @@ assert.sameMembers(
);
```
-The input graph `[[0, 1, 0, 0], [1, 0, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0]]` with a start node of `3` should return an array with two elements.
+`3` を開始ノードとする入力グラフ `[[0, 1, 0, 0], [1, 0, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0]]` は、2 つの要素を持つ配列を返す必要があります。
```js
assert(
@@ -148,7 +148,7 @@ assert(
);
```
-The input graph `[[0, 1, 0, 0], [1, 0, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0]]` with a start node of `0` should return an array with `0` and `1`.
+`0` を開始ノードとする入力グラフ `[[0, 1, 0, 0], [1, 0, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0]]` は、`0` と `1` を持つ配列を返す必要があります。
```js
assert.sameMembers(
@@ -165,7 +165,7 @@ assert.sameMembers(
);
```
-The input graph `[[0, 1, 0, 0], [1, 0, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0]]` with a start node of `0` should return an array with two elements.
+`0` を開始ノードとする入力グラフ `[[0, 1, 0, 0], [1, 0, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0]]` は、2 つの要素を持つ配列を返す必要があります。
```js
assert(
diff --git a/curriculum/challenges/japanese/10-coding-interview-prep/rosetta-code/state-name-puzzle.md b/curriculum/challenges/japanese/10-coding-interview-prep/rosetta-code/state-name-puzzle.md
index 575dcd07dc..87e2b6f7e7 100644
--- a/curriculum/challenges/japanese/10-coding-interview-prep/rosetta-code/state-name-puzzle.md
+++ b/curriculum/challenges/japanese/10-coding-interview-prep/rosetta-code/state-name-puzzle.md
@@ -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 氏の発案によるものです。 この課題は、米国の 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 の課題も出題されました。
+このタスクは、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.
# --instructions--
diff --git a/curriculum/challenges/japanese/13-relational-databases/build-a-celestial-bodies-database-project/build-a-celestial-bodies-database.md b/curriculum/challenges/japanese/13-relational-databases/build-a-celestial-bodies-database-project/build-a-celestial-bodies-database.md
index 5f1a39d091..7880c9214a 100644
--- a/curriculum/challenges/japanese/13-relational-databases/build-a-celestial-bodies-database-project/build-a-celestial-bodies-database.md
+++ b/curriculum/challenges/japanese/13-relational-databases/build-a-celestial-bodies-database-project/build-a-celestial-bodies-database.md
@@ -9,15 +9,15 @@ dashedName: build-a-celestial-bodies-database
# --description--
-This is one of the required projects to earn your certification. For this project, you will build a database of celestial bodies using PostgreSQL.
+これは認定証を獲得するために必須のプロジェクトの 1 つです。 このプロジェクトでは、PostgreSQL を使用して天体のデータベースを構築します。
# --instructions--
-**Important:** After you pass all the project tests, save a dump of your database into a `universe.sql` file so you can complete step 2. There will be instructions how to do that within the virtual machine.
+**重要:** プロジェクトのテストのすべてに合格した後に、データベースのダンプを `universe.sql` ファイルの中に保存することでステップ 2 を完了できます。 仮想マシン内にその方法についての説明があります。
# --notes--
-Required files: `universe.sql`
+必須のファイル: `universe.sql`
# --hints--