chore(i18n,learn): processed translations (#45165)

curriculum/challenges/italian/10-coding-interview-prep/rosetta-code/lychrel-numbers.md

@@ -1,6 +1,6 @@
 ---
 id: 5ea2815a8640bcc6cb7dab3c
-title: Lychrel numbers
+title: Numeri di Lychrel
 challengeType: 5
 forumTopicId: 385287
 dashedName: lychrel-numbers
@@ -9,21 +9,21 @@ dashedName: lychrel-numbers
 # --description--
 
 <ol>
-  <li>Take an integer <code>n₀</code>, greater than zero.</li>
-  <li>Form the next number <code>n</code> of the series by reversing <code>n₀</code> and adding it to <code>n₀</code></li>
-  <li>Stop when <code>n</code> becomes palindromic - i.e. the digits of <code>n</code> in reverse order == <code>n</code>.</li>
+  <li>Prendi un numero intero <code>n₀</code> maggiore di zero.</li>
+  <li>Forma il prossimo numero <code>n</code> della serie invertendo <code>n₀</code> e aggiungendolo a <code>n₀</code></li>
+  <li>Termina quando <code>n</code> diventa palindromo - cioè le cifre di <code>n</code> in ordine inverso == <code>n</code>.</li>
 </ol>
 
-The above recurrence relation when applied to most starting numbers `n` = 1, 2, ... terminates in a palindrome quite quickly.
+La relazione di ricorrenza sopra riportata quando applicata alla maggior parte dei numeri iniziali `n` = 1, 2, ... termina in un palindromo abbastanza rapidamente.
 
-For example if `n₀` = 12 we get:
+Per esempio se `n₀` = 12 otteniamo:
 
 ```bash
 12
 12 + 21 = 33,  a palindrome!
 ```
 
-And if `n₀` = 55 we get:
+E se `n₀` = 55 otteniamo:
 
 ```bash
 55
@@ -31,17 +31,17 @@ And if `n₀` = 55 we get:
 110 + 011 = 121,  a palindrome!
 ```
 
-Notice that the check for a palindrome happens *after* an addition.
+Nota che il controllo per un palindromo viene fatto *dopo* una somma.
 
-Some starting numbers seem to go on forever; the recurrence relation for 196 has been calculated for millions of repetitions forming numbers with millions of digits, without forming a palindrome. These numbers that do not end in a palindrome are called **Lychrel numbers**.
+Alcuni numeri iniziali sembrano andare avanti per sempre; la relazione di ricorrenza per 196 è stata calcolata per milioni di ripetizioni formando numeri con milioni di cifre, senza formare un palindromo. Questi numeri che non terminano in un palindromo sono chiamati **numeri di Lychrel**.
 
-For the purposes of this task a Lychrel number is any starting number that does not form a palindrome within 500 (or more) iterations.
+Ai fini di questo compito un numero di Lychrel è qualsiasi numero iniziale che non forma un palindromo entro 500 (o più) iterazioni.
 
-**Seed and related Lychrel numbers:**
+**Seme e numeri di Lychrel correlati:**
 
-Any integer produced in the sequence of a Lychrel number is also a Lychrel number.
+Qualsiasi numero intero prodotto nella sequenza di un numero di Lychrel è anche un numero di Lychrel.
 
-In general, any sequence from one Lychrel number *might* converge to join the sequence from a prior Lychrel number candidate; for example the sequences for the numbers 196 and then 689 begin:
+In generale, qualsiasi sequenza da un numero di Lychrel *potrebbe* convergere alla sequenza formata da un precedente numero di Lychrel; per esempio le sequenze per i numeri 196 e poi 689 iniziano:
 
 ```bash
     196
@@ -58,59 +58,59 @@ In general, any sequence from one Lychrel number *might* converge to join the se
     ...
 ```
 
-So we see that the sequence starting with 689 converges to, and continues with the same numbers as that for 196.
+Quindi vediamo che la sequenza a partire da 689 converge e continua con gli stessi numeri di quella del 196.
 
-Because of this we can further split the Lychrel numbers into true **Seed** Lychrel number candidates, and **Related** numbers that produce no palindromes but have integers in their sequence seen as part of the sequence generated from a lower Lychrel number.
+A causa di questo possiamo ulteriormente dividere i numeri di Lychrel in veri **Seed** di numeri di Lychrel, e numeri **Correlati** che non producono palindromi ma hanno interi nella loro sequenza visti come parte della sequenza generata da un numero di Lychrel inferiore.
 
 # --instructions--
 
-Write a function that takes a number as a parameter. Return true if the number is a Lynchrel number. Otherwise, return false. Remember that the iteration limit is 500.
+Scrivi una funzione che prende un numero come parametro. Restituisce vero se il numero è un numero di Lychrel. Altrimenti, restituisci falso. Ricorda che il limite di iterazioni è 500.
 
 # --hints--
 
-`isLychrel` should be a function.
+`isLychrel` dovrebbe essere una funzione.
 
 ```js
 assert(typeof isLychrel === 'function');
 ```
 
-`isLychrel(12)` should return a boolean.
+`isLychrel(12)` dovrebbe restituire un booleano.
 
 ```js
 assert(typeof isLychrel(12) === 'boolean');
 ```
 
-`isLychrel(12)` should return `false`.
+`isLychrel(12)` dovrebbe restituire `false`.
 
 ```js
 assert.equal(isLychrel(12), false);
 ```
 
-`isLychrel(55)` should return `false`.
+`isLychrel(55)` dovrebbe restituire `false`.
 
 ```js
 assert.equal(isLychrel(55), false);
 ```
 
-`isLychrel(196)` should return `true`.
+`isLychrel(196)` dovrebbe restituire `true`.
 
 ```js
 assert.equal(isLychrel(196), true);
 ```
 
-`isLychrel(879)` should return `true`.
+`isLychrel(879)` dovrebbe restituire `true`.
 
 ```js
 assert.equal(isLychrel(879), true);
 ```
 
-`isLychrel(44987)` should return `false`.
+`isLychrel(44987)` dovrebbe restituire `false`.
 
 ```js
 assert.equal(isLychrel(44987), false);
 ```
 
-`isLychrel(7059)` should return `true`.
+`isLychrel(7059)` dovrebbe restituire `true`.
 
 ```js
 assert.equal(isLychrel(7059), true);