diff --git a/curriculum/challenges/italian/10-coding-interview-prep/data-structures/create-a-stack-class.md b/curriculum/challenges/italian/10-coding-interview-prep/data-structures/create-a-stack-class.md
index c4a493c439..774bd9d4ce 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/data-structures/create-a-stack-class.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/data-structures/create-a-stack-class.md
@@ -1,6 +1,6 @@
---
id: 587d8250367417b2b2512c5f
-title: Create a Stack Class
+title: Creare una classe Stack
challengeType: 1
forumTopicId: 301633
dashedName: create-a-stack-class
@@ -8,15 +8,15 @@ dashedName: create-a-stack-class
# --description--
-In the last section, we talked about what a stack is and how we can use an array to represent a stack. In this section, we will be creating our own stack class. Although you can use arrays to create stacks, sometimes it is best to limit the amount of control we have with our stacks. Apart from the `push` and `pop` method, stacks have other useful methods. Let's add a `peek`, `isEmpty`, and `clear` method to our stack class.
+Nell'ultima sezione, abbiamo parlato di cosa è uno stack (pila) e come possiamo usare un array per rappresentarlo. In questa sezione, creeremo la nostra classe stack. Anche se è possibile utilizzare degli array per creare gli stack, a volte è meglio limitare la quantità di controllo che abbiamo sui nostri stack. Oltre al metodo `push` e `pop`, gli stack hanno altri metodi utili. Aggiungiamo un metodo `peek`, `isEmpty`e `clear` alla nostra classe stack.
# --instructions--
-Write a `push` method that pushes an element to the top of the stack, a `pop` method that removes and returns the element on the top of the stack, a `peek` method that looks at the top element in the stack, an `isEmpty` method that checks if the stack is empty, and a `clear` method that removes all elements from the stack. Normally stacks don't have this, but we've added a `print` helper method that console logs the collection.
+Scrivi un metodo `push` che inserisce un elemento in cima allo stack, un metodo `pop` che rimuove e restituisce l'elemento in cima allo stack, un metodo `peek` che guarda l'elemento in cima allo stack, un metodo `isEmpty` che controlla se lo stack è vuoto, e un metodo `clear` che rimuove tutti gli elementi dallo stack. Normalmente gli stack non hanno questo, ma abbiamo aggiunto un metodo di aiuto `print` che visualizza la collezione nella console.
# --hints--
-Your `Stack` class should have a `push` method.
+La tua classe `Stack` dovrebbe avere un metodo `push`.
```js
assert(
@@ -27,7 +27,7 @@ assert(
);
```
-Your `Stack` class should have a `pop` method.
+La tua classe `Stack` dovrebbe avere un metodo `pop`.
```js
assert(
@@ -38,7 +38,7 @@ assert(
);
```
-Your `Stack` class should have a `peek` method.
+La tua classe `Stack` dovrebbe avere un metodo `peek`.
```js
assert(
@@ -49,7 +49,7 @@ assert(
);
```
-Your `Stack` class should have a `isEmpty` method.
+La tua classe `Stack` dovrebbe avere un metodo `isEmpty`.
```js
assert(
@@ -60,7 +60,7 @@ assert(
);
```
-Your `Stack` class should have a `clear` method.
+La tua classe `Stack` dovrebbe avere un metodo `clear`.
```js
assert(
@@ -71,7 +71,7 @@ assert(
);
```
-The `peek` method should return the top element of the stack
+Il metodo `peek` dovrebbe restituire l'elemento in cima allo stack
```js
assert(
@@ -84,7 +84,7 @@ assert(
);
```
-The `pop` method should remove and return the top element of the stack
+Il metodo `pop` dovrebbe rimuovere e restituire l'elemento in cima allo stack
```js
assert(
@@ -97,7 +97,7 @@ assert(
);
```
-The `isEmpty` method should return true if a stack does not contain any elements
+Il metodo `isEmpty` dovrebbe restituire true se uno stack non contiene alcun elemento
```js
assert(
@@ -108,7 +108,7 @@ assert(
);
```
-The `clear` method should remove all element from the stack
+Il metodo `clear` dovrebbe rimuovere tutti gli elementi dallo stack
```js
assert(
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/data-structures/delete-a-node-with-two-children-in-a-binary-search-tree.md b/curriculum/challenges/italian/10-coding-interview-prep/data-structures/delete-a-node-with-two-children-in-a-binary-search-tree.md
index aab61e9c37..c587e86aee 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/data-structures/delete-a-node-with-two-children-in-a-binary-search-tree.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/data-structures/delete-a-node-with-two-children-in-a-binary-search-tree.md
@@ -1,6 +1,6 @@
---
id: 587d8258367417b2b2512c82
-title: Delete a Node with Two Children in a Binary Search Tree
+title: Eliminare un nodo con due figli in un albero binario di ricerca
challengeType: 1
forumTopicId: 301639
dashedName: delete-a-node-with-two-children-in-a-binary-search-tree
@@ -8,15 +8,15 @@ dashedName: delete-a-node-with-two-children-in-a-binary-search-tree
# --description--
-Removing nodes that have two children is the hardest case to implement. Removing a node like this produces two subtrees that are no longer connected to the original tree structure. How can we reconnect them? One method is to find the smallest value in the right subtree of the target node and replace the target node with this value. Selecting the replacement in this way ensures that it is greater than every node in the left subtree it becomes the new parent of but also less than every node in the right subtree it becomes the new parent of. Once this replacement is made the replacement node must be removed from the right subtree. Even this operation is tricky because the replacement may be a leaf or it may itself be the parent of a right subtree. If it is a leaf we must remove its parent's reference to it. Otherwise, it must be the right child of the target. In this case, we must replace the target value with the replacement value and make the target reference the replacement's right child.
+Rimuovere i nodi che hanno due figli è il caso più difficile da implementare. Rimuovere un nodo come questo produce due sotto-alberi che non sono più collegati alla struttura originale dell'albero. Come possiamo ricollegarli? Un metodo è quello di trovare il valore più piccolo nel sottoalbero destro del nodo obiettivo e sostituire il nodo obiettivo con questo valore. Selezionare il rimpiazzo in questo modo assicura che sia maggiore di ogni nodo nel sottoalbero sinistro di cui diventa il nuovo genitore ma anche minore di ogni nodo nel sottoalbero destro di cui diventa il nuovo genitore. Una volta effettuata la sostituzione, il nodo di rimpiazzo deve essere rimosso dal sotto-albero destro. Anche questa operazione è difficile perché il rimpiazzo può essere una foglia o può essere di per sé il genitore di un sottoalbero destro. Se si tratta di una foglia dobbiamo eliminare il riferimento nel suo genitore. In caso contrario, deve essere il figlio destro del nodo obiettivo. In questo caso, dobbiamo sostituire il valore obiettivo con il valore di sostituzione e far sì che il riferimento dell'obiettivo punti al figlio destro del sostituto.
# --instructions--
-Let's finish our `remove` method by handling the third case. We've provided some code again for the first two cases. Add some code now to handle target nodes with two children. Any edge cases to be aware of? What if the tree has only three nodes? Once you are finished this will complete our deletion operation for binary search trees. Nice job, this is a pretty hard problem!
+Finiamo il nostro metodo `remove` gestendo il terzo caso. Abbiamo fornito di nuovo del codice per i primi due casi. Aggiungi adesso un po' di codice per gestire i nodi obiettivo con due figli. Eventuali casi limite di cui essere a conoscenza? E se l'albero avesse solo tre nodi? Una volta finito, questo completerà la nostra operazione di cancellazione per gli alberi di ricerca binari. Bel lavoro, questo è un problema piuttosto difficile!
# --hints--
-The `BinarySearchTree` data structure should exist.
+La struttura di dati `BinarySearchTree` dovrebbe esistere.
```js
assert(
@@ -30,7 +30,7 @@ assert(
);
```
-The binary search tree should have a method called `remove`.
+L'albero binario di ricerca dovrebbe avere un metodo chiamato `remove`.
```js
assert(
@@ -46,7 +46,7 @@ assert(
);
```
-Trying to remove an element that does not exist should return `null`.
+Tentare di rimuovere un elemento che non esiste dovrebbe restituire `null`.
```js
assert(
@@ -62,7 +62,7 @@ assert(
);
```
-If the root node has no children, deleting it should set the root to `null`.
+Se il nodo radice non ha figli, l'eliminazione dovrebbe impostare la radice a `null`.
```js
assert(
@@ -80,7 +80,7 @@ assert(
);
```
-The `remove` method should remove leaf nodes from the tree.
+Il metodo `remove` dovrebbe rimuovere i nodi foglia dall'albero.
```js
assert(
@@ -107,7 +107,7 @@ assert(
);
```
-The `remove` method should remove nodes with one child.
+Il metodo `remove` dovrebbe rimuovere i nodi con un figlio.
```js
assert(
@@ -133,7 +133,7 @@ assert(
);
```
-Removing the root in a tree with two nodes should set the second to be the root.
+Rimuovere la radice in un albero con due nodi dovrebbe impostare il secondo come radice.
```js
assert(
@@ -155,7 +155,7 @@ assert(
);
```
-The `remove` method should remove nodes with two children while maintaining the binary search tree structure.
+Il metodo `remove` dovrebbe rimuovere i nodi con due figli mantenendo la struttura dell'albero binario di ricerca.
```js
assert(
@@ -212,7 +212,7 @@ assert(
);
```
-The root should be removable on a tree of three nodes.
+La radice dovrebbe essere rimovibile su un albero di tre nodi.
```js
assert(
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/data-structures/depth-first-search.md b/curriculum/challenges/italian/10-coding-interview-prep/data-structures/depth-first-search.md
index 8fedd91cc5..aa44cfeb2f 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/data-structures/depth-first-search.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/data-structures/depth-first-search.md
@@ -1,6 +1,6 @@
---
id: 587d825d367417b2b2512c96
-title: Depth-First Search
+title: Ricerca Depth-First
challengeType: 1
forumTopicId: 301640
dashedName: depth-first-search
@@ -8,31 +8,31 @@ dashedName: depth-first-search
# --description--
-Similar to breadth-first search, here we will learn about another graph traversal algorithm called depth-first search.
+Similmente alla ricerca breadth-first, qui impareremo a conoscere un altro algoritmo di attraversamento chiamato ricerca depth-first.
-Whereas the breadth-first search searches incremental edge lengths away from the source node, depth-first search first goes down a path of edges as far as it can.
+Mentre la ricerca breadth-first cerca lunghezze di archi incrementali lontano dal nodo di origine, la ricerca depth-first scende prima lungo un percorso di archi il più profondo possibile.
-Once it reaches one end of a path, the search will backtrack to the last node with an un-visited edge path and continue searching.
+Una volta che raggiunge la fine di un percorso, la ricerca tornerà indietro fino all'ultimo nodo con un percorso di archi non visitato e continuerà a cercare.
-The animation below shows how the algorithm works. The algorithm starts with the top node and visits the nodes in the numbered order.
+L'animazione qui sotto mostra come funziona l'algoritmo. L'algoritmo inizia con il nodo iniziale e visita i nodi nell'ordine numerato.
-Notice how, unlike breadth-first search, every time a node is visited, it doesn't visit all of its neighbors. Instead, it first visits one of its neighbors and continues down that path until there are no more nodes to be visited on that path.
+Nota come, a differenza della ricerca breadth-first, ogni volta che un nodo viene visitato, non visita tutti i suoi vicini. Invece, prima visita uno dei suoi vicini e continua lungo quel percorso fino a quando non ci sono più nodi da visitare su di esso.
-To implement this algorithm, you'll want to use a stack. A stack is an array where the last element added is the first to be removed. This is also known as a Last-In-First-Out data structure. A stack is helpful in depth-first search algorithms because, as we add neighbors to the stack, we want to visit the most recently added neighbors first and remove them from the stack.
+Per implementare questo algoritmo, vorrai utilizzare una pila (stack). Una pila è un array in cui l'ultimo elemento aggiunto è il primo ad essere rimosso. Questo è noto anche come una struttura di dati Last-In-First-Out. Uno stack è utile negli algoritmi di ricerca depth-first perché, mano a mano che aggiungiamo nodi vicini allo stack, vogliamo visitare prima i nodi vicini aggiunti più di recente e rimuoverli dallo stack.
-A simple output of this algorithm is a list of nodes which are reachable from a given node. Therefore, you'll also want to keep track of the nodes you visit.
+Un semplice output di questo algoritmo è un elenco di nodi raggiungibili da un dato nodo. Pertanto, dovrai anche tenere traccia dei nodi che visiti.
# --instructions--
-Write a function `dfs()` that takes an undirected, adjacency matrix `graph` and a node label `root` as parameters. The node label will just be the numeric value of the node between `0` and `n - 1`, where `n` is the total number of nodes in the graph.
+Scrivi una funzione `dfs()` che richiede una matrice di adiacenza non orientata `graph`, e un'etichetta di nodo `root` come parametri. L' etichetta del nodo sarà solo il valore numerico del nodo tra `0` e `n - 1`, dove `n` è il numero totale dei nodi nel grafo.
-Your function should output an array of all nodes reachable from `root`.
+La tua funzione dovrebbe generare un array di tutti i nodi raggiungibili da `root`.
# --hints--
-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 `0`, `1`, `2`, and `3`.
+Il grafo di input `[[0, 1, 0, 0], [1, 0, 1, 0], [0, 1, 0, 1], [0, 0, 1, 0]]` con un nodo iniziale di `1` dovrebbe restituire un array con `0`, `1`, `2`e `3`.
```js
assert.sameMembers(
@@ -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 `1` should return an array with four elements.
+Il grafo di input `[[0, 1, 0, 0], [1, 0, 1, 0], [0, 1, 0, 1], [0, 0, 1, 0]]` con un nodo di partenza di `1` dovrebbe restituire un array con quattro elementi.
```js
assert(
@@ -65,7 +65,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`.
+Il grafo di input `[[0, 1, 0, 0], [1, 0, 1, 0], [0, 1, 0, 0], [0, 0, 0, 0]]` con un nodo di partenza di `3` dovrebbe restituire un array con `3`.
```js
assert.sameMembers(
@@ -82,7 +82,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.
+Il grafo di input `[[0, 1, 0, 0], [1, 0, 1, 0], [0, 1, 0, 0], [0, 0, 0, 0]]` con un nodo iniziale di `3` dovrebbe restituire un array con un unico elemento.
```js
assert(
@@ -98,7 +98,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`.
+Il grafo di input `[[0, 1, 0, 0], [1, 0, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0]]` con un nodo iniziale di `3` dovrebbe restituire un array con `2` e `3`.
```js
assert.sameMembers(
@@ -115,7 +115,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.
+Il grafo di input `[[0, 1, 0, 0], [1, 0, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0]]` con un nodo di inizio di `3` dovrebbe restituire un array con due elementi.
```js
assert(
@@ -131,7 +131,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`.
+Il grafo di input `[[0, 1, 0, 0], [1, 0, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0]]` con un nodo iniziale di `0` deve restituire un array con `0` e `1`.
```js
assert.sameMembers(
@@ -148,7 +148,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.
+Il grafo di input `[[0, 1, 0, 0], [1, 0, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0]]` con un nodo di inizio di `0` dovrebbe restituire un array con due elementi.
```js
assert(
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/data-structures/learn-how-a-stack-works.md b/curriculum/challenges/italian/10-coding-interview-prep/data-structures/learn-how-a-stack-works.md
index 19ea0d3c26..9389de3cf6 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/data-structures/learn-how-a-stack-works.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/data-structures/learn-how-a-stack-works.md
@@ -1,6 +1,6 @@
---
id: 587d8250367417b2b2512c5e
-title: Learn how a Stack Works
+title: Impara come funziona uno stack
challengeType: 1
forumTopicId: 301705
dashedName: learn-how-a-stack-works
@@ -8,43 +8,43 @@ dashedName: learn-how-a-stack-works
# --description--
-You are probably familiar with stack of books on your table. You have likely used the undo feature of a text editor. You are also probably used to hitting the back button on your phone to go back to the previous view in your app.
+Probabilmente hai familiarità con la pila di libri sul tuo tavolo. Probabilmente hai usato la funzione di annullamento di un editor di testo. Probabilmente sei anche abituato a premere il pulsante indietro sul telefono per tornare alla vista precedente nella tua app.
-You know what they all have in common? They all store the data in a way so that you can traverse backwards.
+Sai cos'hanno in comune queste cose? Tutte memorizzano i dati in modo che possano essere ripercorsi all'indietro.
-The topmost book in the stack was the one that was put there last. If you remove that book from your stack's top, you would expose the book that was put there before the last book and so on.
+Il libro più in alto nella pila è quello che era stato messo lì per ultimo. Se si rimuove quel libro dalla cima della pila, si espone il libro che è stato messo lì prima dell'ultimo e così via.
-If you think about it, in all the above examples, you are getting Last-In-First-Out type of service. We will try to mimic this with our code.
+Se ci pensi, in tutti gli esempi di cui sopra, si sta ottenendo il tipo di servizio Last-In-First-Out. Cercheremo di imitarlo con il nostro codice.
-This data storage scheme is called a Stack. In particular, we would have to implement the `push()` method that pushes JavaScript objects at the top of the stack; and `pop()` method, that removes the JavaScript object that's at the top of the stack at the current moment.
+Questo schema di memorizzazione dati è chiamato Stack (pila). In particolare, dovremmo implementare il metodo `push()` che inserisce gli oggetti JavaScript nella parte superiore della pila; e il metodo `pop()`, che rimuove l'oggetto JavaScript in cima ad essa al momento attuale.
# --instructions--
-Here we have a stack of homework assignments represented as an array: `"BIO12"` is at the base, and `"PSY44"` is at the top of the stack.
+Qui abbiamo una pila di compiti a casa rappresentati come un array: `"BIO12"` è alla base dello stack, e `"PSY44"` è in cima.
-Modify the given array and treat it like a `stack` using the JavaScript methods mentioned above. Remove the top element `"PSY44"` from the stack. Then add `"CS50"` to be the new top element of the stack.
+Modifica l'array dato e trattarlo come uno `stack` utilizzando i metodi JavaScript sopra menzionati. Rimuovi l'elemento superiore `"PSY44"` dallo stack. Quindi aggiungi `"CS50"` in modo che sia il nuovo elemento in cima allo stack.
# --hints--
-`homeworkStack` should only contain 4 elements.
+`homeworkStack` dovrebbe contenere solo 4 elementi.
```js
assert(homeworkStack.length === 4);
```
-The last element in `homeworkStack` should be `"CS50"`.
+L'ultimo elemento in `homeworkStack` dovrebbe essere `"CS50"`.
```js
assert(homeworkStack[3] === 'CS50');
```
-`homeworkStack` should not contain `"PSY44"`.
+`homeworkStack` non dovrebbe contenere `"PSY44"`.
```js
assert(homeworkStack.indexOf('PSY44') === -1);
```
-The initial declaration of the `homeworkStack` should not be changed.
+La dichiarazione iniziale di `homeworkStack` non dovrebbe essere modificata.
```js
assert(
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/data-structures/perform-a-difference-on-two-sets-of-data.md b/curriculum/challenges/italian/10-coding-interview-prep/data-structures/perform-a-difference-on-two-sets-of-data.md
index 1c79329128..a190d51354 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/data-structures/perform-a-difference-on-two-sets-of-data.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/data-structures/perform-a-difference-on-two-sets-of-data.md
@@ -1,6 +1,6 @@
---
id: 587d8254367417b2b2512c6e
-title: Perform a Difference on Two Sets of Data
+title: Eseguire una differenza su due insiemi di dati
challengeType: 1
forumTopicId: 301706
dashedName: perform-a-difference-on-two-sets-of-data
@@ -8,13 +8,13 @@ dashedName: perform-a-difference-on-two-sets-of-data
# --description--
-In this exercise we are going to perform a difference on 2 sets of data. We will create a method on our `Set` data structure called `difference`. A difference of sets should compare two sets and return the items present in the first set that are absent in the second. This method should take another `Set` as an argument and return the `difference` of the two sets.
+In questo esercizio eseguiremo una differenza su 2 set di dati. Creeremo un metodo sulla nostra struttura di dati `Set` chiamato `difference`. Una differenza di insiemi dovrebbe confrontare due insiemi e restituire gli elementi presenti nel primo insieme che sono assenti nel secondo. Questo metodo dovrebbe prendere un altro `Set` come argomento e restituire la `difference` dei due set.
-For example, if `setA = ['a','b','c']` and `setB = ['a','b','d','e']`, then the difference of setA and setB is: `setA.difference(setB) = ['c']`.
+Per esempio, se `setA = ['a','b','c']` e `setB = ['a','b','d','e']`, allora la differenza di setA e setB è: `setA.difference(setB) = ['c']`.
# --hints--
-Your `Set` class should have a `difference` method.
+La tua classe `Set` dovrebbe avere un metodo `difference`.
```js
assert(
@@ -25,7 +25,7 @@ assert(
);
```
-Your `difference` method should return the proper collection.
+Il metodo `difference` dovrebbe restituire la collezione corretta.
```js
assert(
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/9-billion-names-of-god-the-integer.md b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/9-billion-names-of-god-the-integer.md
index 125236ca75..241505fd59 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/9-billion-names-of-god-the-integer.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/9-billion-names-of-god-the-integer.md
@@ -1,6 +1,6 @@
---
id: 5949b579404977fbaefcd736
-title: 9 billion names of God the integer
+title: I 9 miliardi di nomi di Dio
challengeType: 5
forumTopicId: 302219
dashedName: 9-billion-names-of-god-the-integer
@@ -8,21 +8,21 @@ dashedName: 9-billion-names-of-god-the-integer
# --description--
-This task is a variation of the [short story by Arthur C. Clarke](https://en.wikipedia.org/wiki/The Nine Billion Names of God#Plot_summary "wp: The Nine Billion Names of God#Plot_summary").
+Questa sfida è una variazione [della storia breve di Arthur C. Clarke](https://it.wikipedia.org/wiki/I_nove_miliardi_di_nomi_di_Dio).
-(Solvers should be aware of the consequences of completing this task.)
+(I risolutori dovrebbero essere consapevoli delle consequenze di completare questa sfida)
-In detail, to specify what is meant by a "name":
+In dettaglio, per specificare cosa si intende per "nome":
1 1 1 @@ -32,53 +32,53 @@ This can be visualized in the following form: 1 3 3 2 1 1-Where row $n$ corresponds to integer $n$, and each column $C$ in row $m$ from left to right corresponds to the number of names beginning with $C$. +Dove la riga $n$ corrisponde al numero $n$, e ogni colonna $C$ nella riga $m$ da sinistra a destra corrisponde al numero di nomi che inizia con $C$. -Optionally note that the sum of the $n$-th row $P(n)$ is the integer partition function. +Facoltativamente, nota che la somma dell'$n$-sima riga $P(n)$ è la funzione di partizione dei numeri interi. # --instructions-- -Implement a function that returns the sum of the $n$-th row. +Implementa una funzione che restituisca la somma della $n$-sima riga. # --hints-- -`numberOfNames` should be function. +`numberOfNames` dovrebbe essere una funzione. ```js assert(typeof numberOfNames === 'function'); ``` -`numberOfNames(5)` should equal 7. +`numberOfNames(5)` dovrebbe essere uguale a 7. ```js assert.equal(numberOfNames(5), 7); ``` -`numberOfNames(12)` should equal 77. +`numberOfNames(12)` dovrebbe essere uguale a 77. ```js assert.equal(numberOfNames(12), 77); ``` -`numberOfNames(18)` should equal 385. +`numberOfNames(18)` dovrebbe essere uguale a 385. ```js assert.equal(numberOfNames(18), 385); ``` -`numberOfNames(23)` should equal 1255. +`numberOfNames(23)` dovrebbe essere uguale a 1255. ```js assert.equal(numberOfNames(23), 1255); ``` -`numberOfNames(42)` should equal 53174. +`numberOfNames(42)` dovrebbe essere uguale a 53174. ```js assert.equal(numberOfNames(42), 53174); ``` -`numberOfNames(123)` should equal 2552338241. +`numberOfNames(123)` dovrebbe essere uguale a 2552338241. ```js assert.equal(numberOfNames(123), 2552338241); diff --git a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/abc-problem.md b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/abc-problem.md index b42b619749..5e121a9fba 100644 --- a/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/abc-problem.md +++ b/curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/abc-problem.md @@ -1,6 +1,6 @@ --- id: 594810f028c0303b75339acc -title: ABC Problem +title: Problema ABC challengeType: 5 forumTopicId: 302220 dashedName: abc-problem @@ -8,7 +8,7 @@ dashedName: abc-problem # --description-- -You are given a collection of ABC blocks (e.g., childhood alphabet blocks). There are 20 blocks with two letters on each block. A complete alphabet is guaranteed amongst all sides of the blocks. The sample collection of blocks: +Ti viene data una collezione di blocchi ABC (tipo i cubi con le lettere per i bambini). Ci sono 20 blocchi con due lettere su ogni blocco. Considerando tutti i lati dei blocchi è garantito un alfabeto completo. Ecco un esempio di una collezione di blocchi:
(B O) (X K) @@ -34,60 +34,60 @@ You are given a collection of ABC blocks (e.g., childhood alphabet blocks). Ther # --instructions-- -Implement a function that takes a string (word) and determines whether the word can be spelled with the given collection of blocks. +Implementa una funzione che prende una stringa (parola) e determina se la parola può essere scritta con la collezione di blocchi data. -Some rules to keep in mind: +Alcune regole da tenere a mente: