From a3a8b8cb5e5e03745e13fa0b26ede09e8e08dee1 Mon Sep 17 00:00:00 2001
From: camperbot <camperbot@users.noreply.github.com>
Date: Thu, 31 Mar 2022 22:31:59 +0530
Subject: [PATCH] chore(i18n,learn): processed translations (#45583)

---
 ...font-size-for-multiple-heading-elements.md |   4 +-
 .../problem-137-fibonacci-golden-nuggets.md   |   3 +-
 .../problem-330-eulers-number.md              |   6 +-
 .../problem-92-square-digit-chains.md         |   3 +-
 ...font-size-for-multiple-heading-elements.md |   4 +-
 .../problem-137-fibonacci-golden-nuggets.md   |   3 +-
 .../problem-330-eulers-number.md              |   6 +-
 .../problem-92-square-digit-chains.md         |   3 +-
 ...font-size-for-multiple-heading-elements.md |   4 +-
 ...add-a-box-shadow-to-a-card-like-element.md |  12 +-
 .../adjust-the-hue-of-a-color.md              |  18 +-
 .../create-a-graphic-using-css.md             |   6 +-
 ...a-more-complex-shape-using-css-and-html.md |  10 +-
 ...font-size-for-multiple-heading-elements.md |   4 +-
 .../use-a-bezier-curve-to-move-a-graphic.md   |   2 +-
 ...ar-gradient-to-create-a-striped-element.md |   2 +-
 .../change-a-variable-for-a-specific-area.md  |   4 +-
 .../basic-css/create-a-custom-css-variable.md |   2 +-
 .../inherit-styles-from-the-body-element.md   |   2 +-
 .../override-styles-in-subsequent-css.md      |   2 +-
 .../use-a-media-query-to-change-a-variable.md |   2 +-
 .../basic-css/use-abbreviated-hex-code.md     |   8 +-
 .../use-hex-code-for-specific-colors.md       |   4 +-
 ...radio-buttons-and-checkboxes-by-default.md |   2 +-
 .../basic-html-and-html5/comment-out-html.md  |   2 +-
 .../inform-with-the-paragraph-element.md      |   2 +-
 ...ents-using-the-justify-content-property.md |   2 +-
 ...x-wrap-property-to-wrap-a-row-or-column.md |   2 +-
 ...grid-areas-using-the-grid-area-property.md |   2 +-
 ...-to-change-the-size-of-columns-and-rows.md |   2 +-
 .../convert-celsius-to-fahrenheit.md          |   4 +-
 .../check-if-an-object-has-a-property.md      |   2 +-
 .../remove-items-using-splice.md              |   2 +-
 .../access-array-data-with-indexes.md         |   4 +-
 .../basic-javascript/record-collection.md     |   8 +-
 .../understanding-uninitialized-variables.md  |   2 +-
 .../everything-be-true.md                     | 165 +++++++++---------
 ...d-a-new-element-to-a-binary-search-tree.md |   2 +-
 .../create-a-doubly-linked-list.md            |  10 +-
 .../data-structures/create-a-hash-table.md    |  14 +-
 .../create-a-map-data-structure.md            |  14 +-
 .../create-a-trie-search-tree.md              |   8 +-
 .../create-an-es6-javascript-map.md           |  14 +-
 .../implement-heap-sort-with-a-min-heap.md    |  10 +-
 .../data-structures/incidence-matrix.md       |   2 +-
 .../insert-an-element-into-a-max-heap.md      |   8 +-
 ...form-a-subset-check-on-two-sets-of-data.md |   2 +-
 .../perform-a-union-on-two-sets.md            |   2 +-
 .../remove-an-element-from-a-max-heap.md      |   8 +-
 .../reverse-a-doubly-linked-list.md           |  10 +-
 .../problem-101-optimum-polynomial.md         |   4 +-
 ...problem-103-special-subset-sums-optimum.md |   5 +-
 .../problem-108-diophantine-reciprocals-i.md  |   4 +-
 .../project-euler/problem-109-darts.md        |   7 +-
 .../problem-122-efficient-exponentiation.md   |   9 +-
 .../problem-137-fibonacci-golden-nuggets.md   |   3 +-
 ...y-for-a-sub-triangle-having-minimum-sum.md |   8 +-
 ...em-157-solving-the-diophantine-equation.md |   5 +-
 ...159-digital-root-sums-of-factorisations.md |   5 +-
 .../problem-160-factorial-trailing-digits.md  |   3 +-
 .../problem-163-cross-hatched-triangles.md    |   3 +-
 .../problem-165-intersections.md              |   8 +-
 .../project-euler/problem-166-criss-cross.md  |   4 +-
 ...an-be-expressed-as-a-sum-of-powers-of-2.md |   4 +-
 ...can-be-formed-by-concatenating-products.md |   3 +-
 ...f-the-squares-of-the-digits-is-a-square.md |   4 +-
 ...-zeros-of-a-function-of-three-variables.md |   3 +-
 .../project-euler/problem-185-number-mind.md  |  18 +-
 .../problem-196-prime-triplets.md             |   8 +-
 .../problem-2-even-fibonacci-numbers.md       |   2 +-
 .../problem-201-subsets-with-a-unique-sum.md  |  12 +-
 ...em-203-squarefree-binomial-coefficients.md |   6 +-
 ...problem-207-integer-partition-equations.md |   6 +-
 .../problem-212-combined-volume-of-cuboids.md |   5 +-
 .../problem-214-totient-chains.md             |   6 +-
 .../problem-228-minkowski-sums.md             |   3 +-
 ...-229-four-representations-using-squares.md |   8 +-
 .../problem-230-fibonacci-words.md            |  10 +-
 .../problem-238-infinite-string-tour.md       |   3 +-
 .../project-euler/problem-240-top-dice.md     |   4 +-
 .../project-euler/problem-244-sliders.md      |   4 +-
 .../project-euler/problem-252-convex-holes.md |   3 +-
 .../problem-255-rounded-square-roots.md       |   3 +-
 .../problem-257-angular-bisectors.md          |   2 +-
 .../problem-261-pivotal-square-sums.md        |   4 +-
 .../problem-282-the-ackermann-function.md     |   3 +-
 .../problem-288-an-enormous-factorial.md      |   3 +-
 .../problem-295-lenticular-holes.md           |   3 +-
 ...em-312-cyclic-paths-on-sierpiski-graphs.md |   4 +-
 .../project-euler/problem-318-2011-nines.md   |   6 +-
 ...itwise-or-operations-on-random-integers.md |  10 +-
 .../problem-324-building-a-tower.md           |   4 +-
 .../problem-330-eulers-number.md              |   6 +-
 .../problem-333-special-partitions.md         |   3 +-
 .../problem-334-spilling-the-beans.md         |   5 +-
 .../problem-340-crazy-function.md             |   3 +-
 ...em-341-golombs-self-describing-sequence.md |   3 +-
 .../project-euler/problem-345-matrix-sum.md   |  13 +-
 .../problem-348-sum-of-a-square-and-a-cube.md |   4 +-
 ...e-least-greatest-and-the-greatest-least.md |   4 +-
 .../problem-358-cyclic-numbers.md             |   9 +-
 .../problem-359-hilberts-new-hotel.md         |   5 +-
 ...-361-subsequence-of-thue-morse-sequence.md |   3 +-
 .../problem-368-a-kempner-like-series.md      |   3 +-
 .../problem-371-licence-plates.md             |   2 +-
 .../problem-375-minimum-of-subsequences.md    |   3 +-
 .../problem-376-nontransitive-sets-of-dice.md |   4 +-
 .../problem-38-pandigital-multiples.md        |   4 +-
 .../problem-384-rudin-shapiro-sequence.md     |   7 +-
 .../problem-406-guessing-game.md              |   4 +-
 .../problem-414-kaprekar-constant.md          |   3 +-
 .../problem-417-reciprocal-cycles-ii.md       |   7 +-
 ...problem-420-2x2-positive-integer-matrix.md |   9 +-
 .../problem-423-consecutive-die-throws.md     |   3 +-
 .../problem-426-box-ball-system.md            |   3 +-
 .../problem-433-steps-in-euclids-algorithm.md |   3 +-
 .../problem-437-fibonacci-primitive-roots.md  |   6 +-
 ...-part-of-polynomial-equations-solutions.md |   2 +-
 .../problem-440-gcd-and-tiling.md             |   3 +-
 .../project-euler/problem-443-gcd-sequence.md |   6 +-
 ...blem-450-hypocycloid-and-lattice-points.md |   5 +-
 .../problem-451-modular-inverses.md           |   5 +-
 ...problem-455-powers-with-trailing-digits.md |   4 +-
 ...-456-triangles-containing-the-origin-ii.md |   6 +-
 ...problem-463-a-weird-recurrence-relation.md |   4 +-
 ...istinct-terms-in-a-multiplication-table.md |   8 +-
 .../project-euler/problem-467-superinteger.md |   9 +-
 ...mooth-divisors-of-binomial-coefficients.md |   6 +-
 .../problem-473-phigital-number-base.md       |   2 +-
 .../problem-480-the-last-question.md          |  20 ++-
 .../problem-64-odd-period-square-roots.md     |   2 +-
 .../problem-74-digit-factorial-chains.md      |   8 +-
 .../problem-81-path-sum-two-ways.md           |   4 +-
 .../problem-82-path-sum-three-ways.md         |   4 +-
 .../problem-83-path-sum-four-ways.md          |   4 +-
 .../problem-9-special-pythagorean-triplet.md  |   2 +-
 .../problem-92-square-digit-chains.md         |   3 +-
 137 files changed, 557 insertions(+), 310 deletions(-)

diff --git a/curriculum/challenges/chinese-traditional/01-responsive-web-design/applied-visual-design/set-the-font-size-for-multiple-heading-elements.md b/curriculum/challenges/chinese-traditional/01-responsive-web-design/applied-visual-design/set-the-font-size-for-multiple-heading-elements.md
index 17b9eb61a3..59f169e9ed 100644
--- a/curriculum/challenges/chinese-traditional/01-responsive-web-design/applied-visual-design/set-the-font-size-for-multiple-heading-elements.md
+++ b/curriculum/challenges/chinese-traditional/01-responsive-web-design/applied-visual-design/set-the-font-size-for-multiple-heading-elements.md
@@ -11,7 +11,9 @@ dashedName: set-the-font-size-for-multiple-heading-elements
 
 `font-size` 屬性用來指定元素內文字的大小。 我們可以爲多個元素添加這個規則，讓頁面內不同元素的文字大小得以統一。 在本挑戰裏，你需要設置從 `h1` 到 `h6` 的文字大小。
 
-# --instructions-- <p>在 <code>style</code> 標籤中, 對各元素的 <code>font-size</code> 進行如下設置：</p>
+# --instructions--
+
+  <p>在 <code>style</code> 標籤中, 對各元素的 <code>font-size</code> 進行如下設置：</p>
 
   <ul>
     <li>將 <code>h1</code> 標籤的文字大小設爲 68px。</li>
diff --git a/curriculum/challenges/chinese-traditional/10-coding-interview-prep/project-euler/problem-137-fibonacci-golden-nuggets.md b/curriculum/challenges/chinese-traditional/10-coding-interview-prep/project-euler/problem-137-fibonacci-golden-nuggets.md
index 4a57e7d62a..b52d1c12fa 100644
--- a/curriculum/challenges/chinese-traditional/10-coding-interview-prep/project-euler/problem-137-fibonacci-golden-nuggets.md
+++ b/curriculum/challenges/chinese-traditional/10-coding-interview-prep/project-euler/problem-137-fibonacci-golden-nuggets.md
@@ -14,7 +14,8 @@ dashedName: problem-137-fibonacci-golden-nuggets
 
 令人驚訝的是：
 
-$$\begin{align} A_F(\frac{1}{2}) & = (\frac{1}{2}) × 1 + {(\frac{1}{2})}^2 × 1 + {(\frac{1}{2})}^3 × 2 + {(\frac{1}{2})}^4 × 3 + {(\frac{1}{2})}^5 × 5 + \cdots \\\\ & = \frac{1}{2} + \frac{1}{4} + \frac{2}{8} + \frac{3}{16} + \frac{5}{32} + \cdots \\\\ & = 2 \end{align}$$
+$$\begin{align} A_F(\frac{1}{2}) & = (\frac{1}{2}) × 1 + {(\frac{1}{2})}^2 × 1 + {(\frac{1}{2})}^3 × 2 + {(\frac{1}{2})}^4 × 3 + {(\frac{1}{2})}^5 × 5 + \cdots \\\\
+                 & = \frac{1}{2} + \frac{1}{4} + \frac{2}{8} + \frac{3}{16} + \frac{5}{32} + \cdots \\\\ & = 2 \end{align}$$
 
 前五個對應的自然數 $x$ 如下。
 
diff --git a/curriculum/challenges/chinese-traditional/10-coding-interview-prep/project-euler/problem-330-eulers-number.md b/curriculum/challenges/chinese-traditional/10-coding-interview-prep/project-euler/problem-330-eulers-number.md
index fb52e63736..35e360062b 100644
--- a/curriculum/challenges/chinese-traditional/10-coding-interview-prep/project-euler/problem-330-eulers-number.md
+++ b/curriculum/challenges/chinese-traditional/10-coding-interview-prep/project-euler/problem-330-eulers-number.md
@@ -10,11 +10,13 @@ dashedName: problem-330-eulers-number
 
 對於所有的整數 $n$，一個無限實數序列 $a(n)$ 定義如下：
 
-$$ a(n) = \begin{cases} 1                                                       & n < 0 \\\\ \displaystyle \sum_{i = 1}^{\infty} \frac{a(n - 1)}{i!} & n \ge 0 \end{cases} $$
+$$ a(n) = \begin{cases} 1                                                       & n < 0 \\\\
+\displaystyle \sum_{i = 1}^{\infty} \frac{a(n - 1)}{i!} & n \ge 0 \end{cases} $$
 
 例如，
 
-$$\begin{align} & a(0) = \frac{1}{1!} + \frac{1}{2!} + \frac{1}{3!} + \ldots = e − 1 \\\\ & a(1) = \frac{e − 1}{1!} + \frac{1}{2!} + \frac{1}{3!} + \ldots = 2e − 3 \\\\ & a(2) = \frac{2e − 3}{1!} + \frac{e − 1}{2!} + \frac{1}{3!} + \ldots = \frac{7}{2} e − 6 \end{align}$$
+$$\begin{align}   & a(0) = \frac{1}{1!} + \frac{1}{2!} + \frac{1}{3!} + \ldots = e − 1 \\\\
+  & a(1) = \frac{e − 1}{1!} + \frac{1}{2!} + \frac{1}{3!} + \ldots = 2e − 3 \\\\ & a(2) = \frac{2e − 3}{1!} + \frac{e − 1}{2!} + \frac{1}{3!} + \ldots = \frac{7}{2} e − 6 \end{align}$$
 
 其中，$e = 2.7182818\ldots$ 是歐拉常數。
 
diff --git a/curriculum/challenges/chinese-traditional/10-coding-interview-prep/project-euler/problem-92-square-digit-chains.md b/curriculum/challenges/chinese-traditional/10-coding-interview-prep/project-euler/problem-92-square-digit-chains.md
index 57a719d45e..cc65c62b88 100644
--- a/curriculum/challenges/chinese-traditional/10-coding-interview-prep/project-euler/problem-92-square-digit-chains.md
+++ b/curriculum/challenges/chinese-traditional/10-coding-interview-prep/project-euler/problem-92-square-digit-chains.md
@@ -12,7 +12,8 @@ dashedName: problem-92-square-digit-chains
 
 舉個例子：
 
-$$\begin{align} & 44 → 32 → 13 → 10 → \boldsymbol{1} → \boldsymbol{1}\\\\ & 85 → \boldsymbol{89} → 145 → 42 → 20 → 4 → 16 → 37 → 58 → \boldsymbol{89}\\\\ \end{align}$$
+$$\begin{align}   & 44 → 32 → 13 → 10 → \boldsymbol{1} → \boldsymbol{1}\\\\
+  & 85 → \boldsymbol{89} → 145 → 42 → 20 → 4 → 16 → 37 → 58 → \boldsymbol{89}\\\\ \end{align}$$
 
 可以發現，每條到達 1 或 89 的數鏈都會陷入循環。 最令人驚訝的是，從任意數字開始，數鏈最終都會到達 1 或 89。
 
diff --git a/curriculum/challenges/chinese/01-responsive-web-design/applied-visual-design/set-the-font-size-for-multiple-heading-elements.md b/curriculum/challenges/chinese/01-responsive-web-design/applied-visual-design/set-the-font-size-for-multiple-heading-elements.md
index 62a8c578d9..93da2b6921 100644
--- a/curriculum/challenges/chinese/01-responsive-web-design/applied-visual-design/set-the-font-size-for-multiple-heading-elements.md
+++ b/curriculum/challenges/chinese/01-responsive-web-design/applied-visual-design/set-the-font-size-for-multiple-heading-elements.md
@@ -11,7 +11,9 @@ dashedName: set-the-font-size-for-multiple-heading-elements
 
 `font-size` 属性用来指定元素内文字的大小。 我们可以为多个元素添加这个规则，让页面内不同元素的文字大小得以统一。 在本挑战里，你需要设置从 `h1` 到 `h6` 的文字大小。
 
-# --instructions-- <p>在 <code>style</code> 标签中, 对各元素的 <code>font-size</code> 进行如下设置：</p>
+# --instructions--
+
+  <p>在 <code>style</code> 标签中, 对各元素的 <code>font-size</code> 进行如下设置：</p>
 
   <ul>
     <li>将 <code>h1</code> 标签的文字大小设为 68px。</li>
diff --git a/curriculum/challenges/chinese/10-coding-interview-prep/project-euler/problem-137-fibonacci-golden-nuggets.md b/curriculum/challenges/chinese/10-coding-interview-prep/project-euler/problem-137-fibonacci-golden-nuggets.md
index 1e49943851..4ce34646a4 100644
--- a/curriculum/challenges/chinese/10-coding-interview-prep/project-euler/problem-137-fibonacci-golden-nuggets.md
+++ b/curriculum/challenges/chinese/10-coding-interview-prep/project-euler/problem-137-fibonacci-golden-nuggets.md
@@ -14,7 +14,8 @@ dashedName: problem-137-fibonacci-golden-nuggets
 
 令人惊讶的是：
 
-$$\begin{align} A_F(\frac{1}{2}) & = (\frac{1}{2}) × 1 + {(\frac{1}{2})}^2 × 1 + {(\frac{1}{2})}^3 × 2 + {(\frac{1}{2})}^4 × 3 + {(\frac{1}{2})}^5 × 5 + \cdots \\\\ & = \frac{1}{2} + \frac{1}{4} + \frac{2}{8} + \frac{3}{16} + \frac{5}{32} + \cdots \\\\ & = 2 \end{align}$$
+$$\begin{align} A_F(\frac{1}{2}) & = (\frac{1}{2}) × 1 + {(\frac{1}{2})}^2 × 1 + {(\frac{1}{2})}^3 × 2 + {(\frac{1}{2})}^4 × 3 + {(\frac{1}{2})}^5 × 5 + \cdots \\\\
+                 & = \frac{1}{2} + \frac{1}{4} + \frac{2}{8} + \frac{3}{16} + \frac{5}{32} + \cdots \\\\ & = 2 \end{align}$$
 
 前五个对应的自然数 $x$ 如下。
 
diff --git a/curriculum/challenges/chinese/10-coding-interview-prep/project-euler/problem-330-eulers-number.md b/curriculum/challenges/chinese/10-coding-interview-prep/project-euler/problem-330-eulers-number.md
index 8444afe2b7..7032ca0e9a 100644
--- a/curriculum/challenges/chinese/10-coding-interview-prep/project-euler/problem-330-eulers-number.md
+++ b/curriculum/challenges/chinese/10-coding-interview-prep/project-euler/problem-330-eulers-number.md
@@ -10,11 +10,13 @@ dashedName: problem-330-eulers-number
 
 对于所有的整数 $n$，一个无限实数序列 $a(n)$ 定义如下：
 
-$$ a(n) = \begin{cases} 1                                                       & n < 0 \\\\ \displaystyle \sum_{i = 1}^{\infty} \frac{a(n - 1)}{i!} & n \ge 0 \end{cases} $$
+$$ a(n) = \begin{cases} 1                                                       & n < 0 \\\\
+\displaystyle \sum_{i = 1}^{\infty} \frac{a(n - 1)}{i!} & n \ge 0 \end{cases} $$
 
 例如，
 
-$$\begin{align} & a(0) = \frac{1}{1!} + \frac{1}{2!} + \frac{1}{3!} + \ldots = e − 1 \\\\ & a(1) = \frac{e − 1}{1!} + \frac{1}{2!} + \frac{1}{3!} + \ldots = 2e − 3 \\\\ & a(2) = \frac{2e − 3}{1!} + \frac{e − 1}{2!} + \frac{1}{3!} + \ldots = \frac{7}{2} e − 6 \end{align}$$
+$$\begin{align}   & a(0) = \frac{1}{1!} + \frac{1}{2!} + \frac{1}{3!} + \ldots = e − 1 \\\\
+  & a(1) = \frac{e − 1}{1!} + \frac{1}{2!} + \frac{1}{3!} + \ldots = 2e − 3 \\\\ & a(2) = \frac{2e − 3}{1!} + \frac{e − 1}{2!} + \frac{1}{3!} + \ldots = \frac{7}{2} e − 6 \end{align}$$
 
 其中，$e = 2.7182818\ldots$ 是欧拉常数。
 
diff --git a/curriculum/challenges/chinese/10-coding-interview-prep/project-euler/problem-92-square-digit-chains.md b/curriculum/challenges/chinese/10-coding-interview-prep/project-euler/problem-92-square-digit-chains.md
index 612870aafb..aa0082deae 100644
--- a/curriculum/challenges/chinese/10-coding-interview-prep/project-euler/problem-92-square-digit-chains.md
+++ b/curriculum/challenges/chinese/10-coding-interview-prep/project-euler/problem-92-square-digit-chains.md
@@ -12,7 +12,8 @@ dashedName: problem-92-square-digit-chains
 
 举个例子：
 
-$$\begin{align} & 44 → 32 → 13 → 10 → \boldsymbol{1} → \boldsymbol{1}\\\\ & 85 → \boldsymbol{89} → 145 → 42 → 20 → 4 → 16 → 37 → 58 → \boldsymbol{89}\\\\ \end{align}$$
+$$\begin{align}   & 44 → 32 → 13 → 10 → \boldsymbol{1} → \boldsymbol{1}\\\\
+  & 85 → \boldsymbol{89} → 145 → 42 → 20 → 4 → 16 → 37 → 58 → \boldsymbol{89}\\\\ \end{align}$$
 
 可以发现，每条到达 1 或 89 的数链都会陷入循环。 最令人惊讶的是，从任意数字开始，数链最终都会到达 1 或 89。
 
diff --git a/curriculum/challenges/espanol/01-responsive-web-design/applied-visual-design/set-the-font-size-for-multiple-heading-elements.md b/curriculum/challenges/espanol/01-responsive-web-design/applied-visual-design/set-the-font-size-for-multiple-heading-elements.md
index 4c327c18e6..0317f18aaf 100644
--- a/curriculum/challenges/espanol/01-responsive-web-design/applied-visual-design/set-the-font-size-for-multiple-heading-elements.md
+++ b/curriculum/challenges/espanol/01-responsive-web-design/applied-visual-design/set-the-font-size-for-multiple-heading-elements.md
@@ -11,7 +11,9 @@ dashedName: set-the-font-size-for-multiple-heading-elements
 
 La propiedad `font-size` se usa para especificar que tan grande es el texto en un elemento dado. Esta regla se puede utilizar para varios elementos para crear coherencia visual del texto en una página. En este desafío, establecerá los valores para todas las etiquetas `h1` a `h6` para equilibrar los tamaños de los títulos.
 
-# --instructions-- <p>En las etiquetas <code>style</code>, establece el <code>font-size</code> de:</p>
+# --instructions--
+
+  <p>En las etiquetas <code>style</code>, establece el <code>font-size</code> de:</p>
 
   <ul>
     <li>Etiqueta <code>h1</code> a 68px.</li>
diff --git a/curriculum/challenges/italian/01-responsive-web-design/applied-visual-design/add-a-box-shadow-to-a-card-like-element.md b/curriculum/challenges/italian/01-responsive-web-design/applied-visual-design/add-a-box-shadow-to-a-card-like-element.md
index bf6544d0cc..f19c59a921 100644
--- a/curriculum/challenges/italian/01-responsive-web-design/applied-visual-design/add-a-box-shadow-to-a-card-like-element.md
+++ b/curriculum/challenges/italian/01-responsive-web-design/applied-visual-design/add-a-box-shadow-to-a-card-like-element.md
@@ -11,14 +11,14 @@ dashedName: add-a-box-shadow-to-a-card-like-element
 
 La proprietà `box-shadow` applica una o più ombre ad un elemento.
 
-La proprietà `box-shadow` è definita dai seguenti valori:
+La proprietà `box-shadow` prende i seguenti valori, in ordine:
 
 <ul>
-  <li><code>offset-x</code> (quanto l'ombra si sposta orizzontalmente dall'elemento),</li>
-  <li><code>offset-y</code> (quanto l'ombra si sposta verticalmente dall'elemento),</li>
-  <li><code>blur-radius</code>, cioè quanto è ampia la sfumatura,</li>
-  <li><code>spread-radius</code>, cioè quanto è ampia la base dell'ombra e</li>
-  <li><code>color</code> per definirne il colore, in quest'ordine.</li>
+  <li><code>offset-x</code> (quanto l'ombra si sposta orizzontalmente dall'elemento)</li>
+  <li><code>offset-y</code> (quanto l'ombra si sposta verticalmente dall'elemento)</li>
+  <li><code>blur-radius</code></li>
+  <li><code>spread-radius</code></li>
+  <li><code>color</code></li>
 </ul>
 
 I valori `blur-radius` e `spread-radius` sono opzionali.
diff --git a/curriculum/challenges/italian/01-responsive-web-design/applied-visual-design/adjust-the-hue-of-a-color.md b/curriculum/challenges/italian/01-responsive-web-design/applied-visual-design/adjust-the-hue-of-a-color.md
index 935bc3d3bf..28f42534f8 100644
--- a/curriculum/challenges/italian/01-responsive-web-design/applied-visual-design/adjust-the-hue-of-a-color.md
+++ b/curriculum/challenges/italian/01-responsive-web-design/applied-visual-design/adjust-the-hue-of-a-color.md
@@ -9,9 +9,9 @@ dashedName: adjust-the-hue-of-a-color
 
 # --description--
 
-I colori hanno diverse caratteristiche tra cui tonalità, saturazione e luminosità. CSS3 ha introdotto la proprietà `hsl()` (hue, saturation, lightness) come metodo alternativo per scegliere un colore indicando direttamente queste caratteristiche.
+I colori hanno diverse caratteristiche tra cui tonalità, saturazione e luminosità. CSS3 ha introdotto la funzione `hsl()` (hue-tonalità, saturation-saturazione, lightness-luminosità) come metodo alternativo per scegliere un colore indicando direttamente queste caratteristiche.
 
-**Tonalità** (Hue) è ciò che la gente generalmente intende come 'colore'. Se si immagina uno spettro di colori che inizia con il rosso a sinistra, passando attraverso il verde nel mezzo, e blu a destra, la tonalità è dove un colore si posiziona lungo questa linea. Con l'`hsl()`, la tonalità utilizza il concetto del cerchio cromatico invece dello spettro, dove l'angolo del colore sul cerchio è indicato come valore compreso tra 0 e 360.
+**Tonalità** è ciò che la gente generalmente intende come 'colore'. Se si immagina uno spettro di colori che inizia con il rosso a sinistra, passando attraverso il verde nel mezzo, e blu a destra, la tonalità è dove un colore si posiziona lungo questa linea. Con l'`hsl()`, la tonalità utilizza il concetto del cerchio cromatico invece dello spettro, dove l'angolo del colore sul cerchio è indicato come valore compreso tra 0 e 360.
 
 **Saturazione** è la quantità di grigio in un colore. Un colore completamente saturo non ha grigio in esso, e un colore minimamente saturo è quasi completamente grigio. Questo dato è in percentuale, dove 100% la saturazione completa.
 
@@ -23,41 +23,41 @@ Ecco alcuni esempi di utilizzo dell'`hsl()` con colori di luminosità normali co
 
 # --instructions--
 
-Cambia il `background-color` di ogni elemento `div` basandoti sui nomi delle classi (`green`, `cyan` o `blue`) utilizzando la proprietà `hsl()`. Tutti e tre dovrebbero avere piena saturazione e luminosità normale.
+Cambia il `background-color` di ogni elemento `div` basandoti sui nomi delle classi (`green` - verde, `cyan` - ciano o `blue` - blu) utilizzando la proprietà `hsl()`. Tutti e tre dovrebbero avere piena saturazione e luminosità normale.
 
 # --hints--
 
-Il tuo codice dovrebbe utilizzare la proprietà `hsl()` per dichiarare il colore `green`.
+Il tuo codice dovrebbe usare le funzioni `hsl()` per dichiarare il colore verde.
 
 ```js
 assert(code.match(/\.green\s*?{\s*?background-color\s*:\s*?hsl/gi));
 ```
 
-Il tuo codice dovrebbe utilizzare la proprietà `hsl()` per dichiarare il colore `cyan`.
+Il tuo codice dovrebbe utilizzare le funzioni `hsl()` per dichiarare il colore ciano.
 
 ```js
 assert(code.match(/\.cyan\s*?{\s*?background-color\s*:\s*?hsl/gi));
 ```
 
-Il tuo codice dovrebbe utilizzare la proprietà `hsl()` per dichiarare il colore `blue`.
+Il tuo codice dovrebbe utilizzare le funzioni `hsl()` per dichiarare il colore blu.
 
 ```js
 assert(code.match(/\.blue\s*?{\s*?background-color\s*:\s*?hsl/gi));
 ```
 
-L'elemento `div` con classe `green` dovrebbe avere un `background-color` verde (green).
+L'elemento `div` con classe `green` dovrebbe avere un `background-color` verde.
 
 ```js
 assert($('.green').css('background-color') == 'rgb(0, 255, 0)');
 ```
 
-L'elemento `div` con classe `cyan` dovrebbe avere un `background-color` ciano (cyan).
+L'elemento `div` con classe `cyan` dovrebbe avere un `background-color` ciano.
 
 ```js
 assert($('.cyan').css('background-color') == 'rgb(0, 255, 255)');
 ```
 
-L'elemento `div` con classe `blue` dovrebbe avere un `background-color` blu (blu).
+L'elemento `div` con classe `blue` dovrebbe avere un `background-color` blu.
 
 ```js
 assert($('.blue').css('background-color') == 'rgb(0, 0, 255)');
diff --git a/curriculum/challenges/italian/01-responsive-web-design/applied-visual-design/create-a-graphic-using-css.md b/curriculum/challenges/italian/01-responsive-web-design/applied-visual-design/create-a-graphic-using-css.md
index 37c09334bc..92a276aa71 100644
--- a/curriculum/challenges/italian/01-responsive-web-design/applied-visual-design/create-a-graphic-using-css.md
+++ b/curriculum/challenges/italian/01-responsive-web-design/applied-visual-design/create-a-graphic-using-css.md
@@ -15,11 +15,11 @@ Creerai un oggetto rotondo trasparente con un'ombra netta leggermente sfalsata s
 
 Per creare un oggetto rotondo, la proprietà `border-radius` dovrebbe essere impostata su un valore del 50%.
 
-Potresti ricordare da una sfida precedente che la proprietà `box-shadow` richiede dei valori per `offset-x`, `offset-y`, `blur-radius`, `spread-radius`, e un valore per il colore, in quest'ordine. I valori `blur-radius` e `spread-radius` sono opzionali.
+Potresti ricordare da una sfida precedente che la proprietà `box-shadow` richiede dei valori per `offset-x`, `offset-y`, `blur-radius`, `spread-radius`, e un valore per `color`, in quest'ordine. I valori `blur-radius` e `spread-radius` sono opzionali.
 
 # --instructions--
 
-Manipola l'elemento quadrato nell'editor per creare la forma della luna. Innanzitutto, cambia il `background-color` con `transparent`, quindi imposta la proprietà `border-radius` al 50% per rendere la forma circolare. Infine, cambia la proprietà `box-shadow` per impostare l'`offset-x` a 25px, l'`offset-y` a 10px, il `blur-radius` a 0, lo `spread-radius` a 0, e il colore a `blue`.
+Manipola l'elemento quadrato nell'editor per creare la forma della luna. Innanzitutto, cambia il `background-color` con `transparent`, quindi imposta la proprietà `border-radius` al 50% per rendere la forma circolare. Infine, cambia la proprietà `box-shadow` per impostare l'`offset-x` a 25px, l'`offset-y` a 10px, il `blur-radius` a 0, lo `spread-radius` a 0, e `color` a `blue`.
 
 # --hints--
 
@@ -35,7 +35,7 @@ Il valore della proprietà `border-radius` dovrebbe essere impostato a `50%`.
 assert(code.match(/border-radius:\s*?50%;/gi));
 ```
 
-I valori della proprietà `box-shadow` dovrebbero essere impostati a 25px per l'`offset-x`, 10px per l'`offset-y`, 0 per il `blur-radius`, 0 per lo `spread-radius`, e infine `blue` per il colore.
+I valori della proprietà `box-shadow` dovrebbero essere impostati a 25px per l'`offset-x`, 10px per l'`offset-y`, 0 per il `blur-radius`, 0 per lo `spread-radius`, e infine `blue` per `color`.
 
 ```js
 assert(
diff --git a/curriculum/challenges/italian/01-responsive-web-design/applied-visual-design/create-a-more-complex-shape-using-css-and-html.md b/curriculum/challenges/italian/01-responsive-web-design/applied-visual-design/create-a-more-complex-shape-using-css-and-html.md
index d45ef39b24..72eeab4c09 100644
--- a/curriculum/challenges/italian/01-responsive-web-design/applied-visual-design/create-a-more-complex-shape-using-css-and-html.md
+++ b/curriculum/challenges/italian/01-responsive-web-design/applied-visual-design/create-a-more-complex-shape-using-css-and-html.md
@@ -28,15 +28,15 @@ Affinché gli pseudo-elementi `::before` e `::after` funzionino correttamente, d
 
 # --instructions--
 
-Trasforma l'elemento sullo schermo in un cuore. Nel selettore `heart::after`, cambia il `background-color` a `pink` e il `border-radius` a 50%.
+Trasforma l'elemento sullo schermo in un cuore. Nel selettore `.heart::after`, cambia il `background-color` a `pink` e il `border-radius` a 50%.
 
 Poi, seleziona l'elemento di classe `heart` (solo `heart`) e riempi la proprietà `transform`. Usa la funzione `rotate()` con un argomento di -45 gradi.
 
-Infine, nel selettore `heart::before`, imposta la proprietà `content` su una stringa vuota.
+Infine, nel selettore `.heart::before`, imposta la proprietà `content` su una stringa vuota.
 
 # --hints--
 
-La proprietà `background-color` del selettore `heart::after` dovrebbe essere `pink`.
+La proprietà `background-color` del selettore `.heart::after` dovrebbe essere `pink`.
 
 ```js
 const heartAfter = code.match(/\.heart::after\s*{[\s\S]+?[^\}]}/g)[0];
@@ -45,7 +45,7 @@ assert(
 );
 ```
 
-Il `border-radius` del selettore `heart::after` dovrebbe essere del 50%.
+Il `border-radius` del selettore `.heart::after` dovrebbe essere del 50%.
 
 ```js
 assert(code.match(/border-radius\s*?:\s*?50%/gi).length == 2);
@@ -57,7 +57,7 @@ La proprietà `transform` per la classe `heart` dovrebbe utilizzare una funzione
 assert(code.match(/transform\s*?:\s*?rotate\(\s*?-45deg\s*?\)/gi));
 ```
 
-Il `content` del selettore `heart::before` dovrebbe essere una stringa vuota.
+Il `content` del selettore `.heart::before` dovrebbe essere una stringa vuota.
 
 ```js
 assert(code.match(/\.heart::before\s*?{\s*?content\s*?:\s*?("|')\1\s*?;/gi));
diff --git a/curriculum/challenges/italian/01-responsive-web-design/applied-visual-design/set-the-font-size-for-multiple-heading-elements.md b/curriculum/challenges/italian/01-responsive-web-design/applied-visual-design/set-the-font-size-for-multiple-heading-elements.md
index bd556d694b..8c700bfde6 100644
--- a/curriculum/challenges/italian/01-responsive-web-design/applied-visual-design/set-the-font-size-for-multiple-heading-elements.md
+++ b/curriculum/challenges/italian/01-responsive-web-design/applied-visual-design/set-the-font-size-for-multiple-heading-elements.md
@@ -11,7 +11,9 @@ dashedName: set-the-font-size-for-multiple-heading-elements
 
 La proprietà `font-size` è usata per specificare quanto grande è il testo in un dato elemento. Questa regola può essere utilizzata per più elementi per creare coerenza visiva del testo in una pagina. In questa sfida, imposterai i valori per tutti i tag da `h1` a `h6` per bilanciare le dimensioni dell'intestazione.
 
-# --instructions-- <p>Nel tag <code>style</code>, imposta la dimensione del font (<code>font-size</code>) per:</p>
+# --instructions--
+
+  <p>Nel tag <code>style</code>, imposta la dimensione del font (<code>font-size</code>) per:</p>
 
   <ul>
     <li>Il tag <code>h1</code> a 68px.</li>
diff --git a/curriculum/challenges/italian/01-responsive-web-design/applied-visual-design/use-a-bezier-curve-to-move-a-graphic.md b/curriculum/challenges/italian/01-responsive-web-design/applied-visual-design/use-a-bezier-curve-to-move-a-graphic.md
index f96e09c415..d670778010 100644
--- a/curriculum/challenges/italian/01-responsive-web-design/applied-visual-design/use-a-bezier-curve-to-move-a-graphic.md
+++ b/curriculum/challenges/italian/01-responsive-web-design/applied-visual-design/use-a-bezier-curve-to-move-a-graphic.md
@@ -11,7 +11,7 @@ dashedName: use-a-bezier-curve-to-move-a-graphic
 
 Una sfida precedente ha discusso la parola chiave `ease-out` che descrive un cambiamento di animazione che prima accelera e poi rallenta verso la fine dell'animazione. Sulla destra è mostrata la differenza tra la parola chiave `ease-out` (per l'elemento blu) e la parola chiave `linear` (per l'elemento rosso). Una progressione dell'animazione simile alla parola chiave `ease-out` può essere ottenuta utilizzando una curva di Bezier cubica personalizzata.
 
-In generale, cambiando i punti di ancoraggio `p1` e `p2` otteniamo la creazione di diverse curve di Bezier, che controllano come l'animazione progredisce nel tempo. Ecco un esempio di curva Bezier che usa valori per imitare lo stile ease-out:
+In generale, cambiando i punti di ancoraggio `p1` e `p2` otteniamo la creazione di diverse curve di Bezier, che controllano come l'animazione progredisce nel tempo. Ecco un esempio di curva di Bezier che usa valori per imitare lo stile `ease-out`:
 
 ```css
 animation-timing-function: cubic-bezier(0, 0, 0.58, 1);
diff --git a/curriculum/challenges/italian/01-responsive-web-design/applied-visual-design/use-a-css-linear-gradient-to-create-a-striped-element.md b/curriculum/challenges/italian/01-responsive-web-design/applied-visual-design/use-a-css-linear-gradient-to-create-a-striped-element.md
index 8be8e6ebd7..16d83328aa 100644
--- a/curriculum/challenges/italian/01-responsive-web-design/applied-visual-design/use-a-css-linear-gradient-to-create-a-striped-element.md
+++ b/curriculum/challenges/italian/01-responsive-web-design/applied-visual-design/use-a-css-linear-gradient-to-create-a-striped-element.md
@@ -47,7 +47,7 @@ La fermata del colore a 0 pixel dovrebbe essere `yellow`.
 assert(code.match(/yellow\s+?0(px)?/gi));
 ```
 
-Un color stop a 40 pixel dovrebbe essere `yellow`.
+Il primo stop di colore a 40 pixel dovrebbe essere `yellow`.
 
 ```js
 assert(code.match(/yellow\s+?40px/gi));
diff --git a/curriculum/challenges/italian/01-responsive-web-design/basic-css/change-a-variable-for-a-specific-area.md b/curriculum/challenges/italian/01-responsive-web-design/basic-css/change-a-variable-for-a-specific-area.md
index 44a101e9d4..be0df5aba9 100644
--- a/curriculum/challenges/italian/01-responsive-web-design/basic-css/change-a-variable-for-a-specific-area.md
+++ b/curriculum/challenges/italian/01-responsive-web-design/basic-css/change-a-variable-for-a-specific-area.md
@@ -11,7 +11,7 @@ dashedName: change-a-variable-for-a-specific-area
 
 Quando crei le tue variabili in `:root` questo imposterà il loro valore per l'intera pagina.
 
-È quindi possibile sovrascrivere queste variabili impostandole di nuovo all'interno di un elemento specifico.
+È quindi possibile sovrascrivere queste variabili impostandole nuovamente all'interno di un selettore specifico.
 
 # --instructions--
 
@@ -27,7 +27,7 @@ assert(
 );
 ```
 
-La classe `penguin` non dovrebbe contenere la proprietà `background-color`
+La classe `penguin` non dovrebbe contenere la proprietà `background-color`.
 
 ```js
 assert(
diff --git a/curriculum/challenges/italian/01-responsive-web-design/basic-css/create-a-custom-css-variable.md b/curriculum/challenges/italian/01-responsive-web-design/basic-css/create-a-custom-css-variable.md
index 2511e2177b..e8cb0a27d9 100644
--- a/curriculum/challenges/italian/01-responsive-web-design/basic-css/create-a-custom-css-variable.md
+++ b/curriculum/challenges/italian/01-responsive-web-design/basic-css/create-a-custom-css-variable.md
@@ -15,7 +15,7 @@ Per creare una variabile CSS, hai solo bisogno di dargli un nome con due trattin
 --penguin-skin: gray;
 ```
 
-Questo creerà una variabile chiamata `--penguin-skin` e assegnerà ad essa il valore di `gray`. Ora puoi usare quella variabile da altre parti nel tuo CSS per impostare il valore di altri elementi su grigio.
+Questo creerà una variabile chiamata `--penguin-skin` e assegnerà ad essa il valore di `gray`. Ora puoi usare quella variabile anche da altre parti nel tuo CSS per impostare il valore di altre proprietà su grigio.
 
 # --instructions--
 
diff --git a/curriculum/challenges/italian/01-responsive-web-design/basic-css/inherit-styles-from-the-body-element.md b/curriculum/challenges/italian/01-responsive-web-design/basic-css/inherit-styles-from-the-body-element.md
index 4de3b72304..f4455dfa90 100644
--- a/curriculum/challenges/italian/01-responsive-web-design/basic-css/inherit-styles-from-the-body-element.md
+++ b/curriculum/challenges/italian/01-responsive-web-design/basic-css/inherit-styles-from-the-body-element.md
@@ -77,7 +77,7 @@ assert(
 );
 ```
 
-Il tuo elemento `h1` dovrebbe ereditare il colore verde dal tuo elemento`body`.
+Il tuo elemento `h1` dovrebbe ereditare il colore `green` dal tuo elemento `body`.
 
 ```js
 assert($('h1').length > 0 && $('h1').css('color') === 'rgb(0, 128, 0)');
diff --git a/curriculum/challenges/italian/01-responsive-web-design/basic-css/override-styles-in-subsequent-css.md b/curriculum/challenges/italian/01-responsive-web-design/basic-css/override-styles-in-subsequent-css.md
index 53c6be1876..7126073390 100644
--- a/curriculum/challenges/italian/01-responsive-web-design/basic-css/override-styles-in-subsequent-css.md
+++ b/curriculum/challenges/italian/01-responsive-web-design/basic-css/override-styles-in-subsequent-css.md
@@ -27,7 +27,7 @@ class="class1 class2"
 
 **Nota:** Non importa in quale ordine sono elencate le classi nell'elemento HTML.
 
-Quello che veramente conta è l'ordine delle dichiarazioni di `class` nella sezione `<style>`. La seconda dichiarazione avrà sempre la precedenza sulla prima. Poiché `.blue-text` viene dichiarato per secondo, esso sovrascrive gli attributi di `.pink-text`
+Quello che veramente conta è l'ordine delle dichiarazioni di `class` nella sezione `<style>`. La seconda dichiarazione avrà sempre la precedenza sulla prima. Poiché `.blue-text` viene dichiarato per secondo, esso sovrascrive gli attributi di `.pink-text`.
 
 # --hints--
 
diff --git a/curriculum/challenges/italian/01-responsive-web-design/basic-css/use-a-media-query-to-change-a-variable.md b/curriculum/challenges/italian/01-responsive-web-design/basic-css/use-a-media-query-to-change-a-variable.md
index 3087bb780f..40fa17eeb6 100644
--- a/curriculum/challenges/italian/01-responsive-web-design/basic-css/use-a-media-query-to-change-a-variable.md
+++ b/curriculum/challenges/italian/01-responsive-web-design/basic-css/use-a-media-query-to-change-a-variable.md
@@ -15,7 +15,7 @@ Ad esempio, quando lo schermo è più piccolo o più grande del breakpoint (punt
 
 # --instructions--
 
-Nel selettore `:root` della `media query`, fai in modo che `--penguin-size` venga ridefinito con un valore di `200px`. Inoltre, ridefinisci `--penguin-skin` e dagli un valore di `black`. Quindi ridimensiona l'anteprima per vedere questa modifica in azione.
+Nel selettore `:root` della media query, fai in modo che `--penguin-size` venga ridefinito con un valore di `200px`. Inoltre, ridefinisci `--penguin-skin` e dagli un valore di `black`. Quindi ridimensiona l'anteprima per vedere questa modifica in azione.
 
 # --hints--
 
diff --git a/curriculum/challenges/italian/01-responsive-web-design/basic-css/use-abbreviated-hex-code.md b/curriculum/challenges/italian/01-responsive-web-design/basic-css/use-abbreviated-hex-code.md
index 62cacbc575..959c91fe5f 100644
--- a/curriculum/challenges/italian/01-responsive-web-design/basic-css/use-abbreviated-hex-code.md
+++ b/curriculum/challenges/italian/01-responsive-web-design/basic-css/use-abbreviated-hex-code.md
@@ -29,7 +29,7 @@ Il tuo elemento `h1` con il testo `I am red!` dovrebbe ricevere il `color` rosso
 assert($('.red-text').css('color') === 'rgb(255, 0, 0)');
 ```
 
-L'`hex code` abbreviato per il colore rosso dovrebbe essere utilizzato al posto del codice hex `#FF0000`.
+Dovresti usare il codice esadecimale abbreviato per il colore rosso al posto del codice `#FF0000`.
 
 ```js
 assert(code.match(/\.red-text\s*?{\s*?color\s*:\s*?#F00\s*?;?\s*?}/gi));
@@ -41,7 +41,7 @@ Al tuo elemento `h1` con il testo `I am green!` dovrebbe essere assegnato il `co
 assert($('.green-text').css('color') === 'rgb(0, 255, 0)');
 ```
 
-L'`hex code` abbreviato per il colore verde deve essere utilizzato al posto della parola `#00FF00`.
+Dovresti usare il codice esadecimale abbreviato per il colore verde al posto del codice `#00FF00`.
 
 ```js
 assert(code.match(/\.green-text\s*?{\s*?color\s*:\s*?#0F0\s*?;?\s*?}/gi));
@@ -53,7 +53,7 @@ Il tuo elemento `h1` con il testo `I am cyan!` dovrebbe ricevere il `color` cian
 assert($('.cyan-text').css('color') === 'rgb(0, 255, 255)');
 ```
 
-L'`hex code` abbreviato per il colore ciano dovrebbe essere utilizzato al posto della parola `#00FFFF`.
+Dovresti usare il codice esadecimale abbreviato per il colore ciano al posto del codice `#00FFFF`.
 
 ```js
 assert(code.match(/\.cyan-text\s*?{\s*?color\s*:\s*?#0FF\s*?;?\s*?}/gi));
@@ -65,7 +65,7 @@ Il tuo elemento `h1` con il testo `I am fuchsia!` dovrebbe ricevere il `color` f
 assert($('.fuchsia-text').css('color') === 'rgb(255, 0, 255)');
 ```
 
-L'`hex code` abbreviato per il colore fucsia dovrebbe essere utilizzato al posto dell'hex code `#FF00FF`.
+Dovresti usare il codice esadecimale abbreviato per il colore fucsia invece del codice `#FF00FF`.
 
 ```js
 assert(code.match(/\.fuchsia-text\s*?{\s*?color\s*:\s*?#F0F\s*?;?\s*?}/gi));
diff --git a/curriculum/challenges/italian/01-responsive-web-design/basic-css/use-hex-code-for-specific-colors.md b/curriculum/challenges/italian/01-responsive-web-design/basic-css/use-hex-code-for-specific-colors.md
index c4e6cf4816..882db8c71a 100644
--- a/curriculum/challenges/italian/01-responsive-web-design/basic-css/use-hex-code-for-specific-colors.md
+++ b/curriculum/challenges/italian/01-responsive-web-design/basic-css/use-hex-code-for-specific-colors.md
@@ -27,13 +27,13 @@ Sostituisci la parola `black` nel colore di sfondo dell'elemento `body` con la s
 
 # --hints--
 
-Il tuo elemento `body` dovrebbe avere un colore di sfondo nero.
+Il tuo elemento `body` dovrebbe avere il `background-color` nero.
 
 ```js
 assert($('body').css('background-color') === 'rgb(0, 0, 0)');
 ```
 
-L'`hex code` per il colore nero dovrebbe essere utilizzato al posto della parola `black`.
+L'hex code per il colore nero dovrebbe essere utilizzato al posto della parola `black`.
 
 ```js
 assert(
diff --git a/curriculum/challenges/italian/01-responsive-web-design/basic-html-and-html5/check-radio-buttons-and-checkboxes-by-default.md b/curriculum/challenges/italian/01-responsive-web-design/basic-html-and-html5/check-radio-buttons-and-checkboxes-by-default.md
index b991257298..f015e5290b 100644
--- a/curriculum/challenges/italian/01-responsive-web-design/basic-html-and-html5/check-radio-buttons-and-checkboxes-by-default.md
+++ b/curriculum/challenges/italian/01-responsive-web-design/basic-html-and-html5/check-radio-buttons-and-checkboxes-by-default.md
@@ -11,7 +11,7 @@ dashedName: check-radio-buttons-and-checkboxes-by-default
 
 Puoi settare una casella di spunta o un pulsante di opzione in modo che sia spuntato di default usando l'attributo`checked`.
 
-Per fare questo puoi semplicemente aggiungere la parola `checked`all'interno di un elemento input. Per esempio:
+Per fare questo puoi semplicemente aggiungere la parola `checked`all'interno di un elemento `input`. Per esempio:
 
 ```html
 <input type="radio" name="test-name" checked>
diff --git a/curriculum/challenges/italian/01-responsive-web-design/basic-html-and-html5/comment-out-html.md b/curriculum/challenges/italian/01-responsive-web-design/basic-html-and-html5/comment-out-html.md
index 8fbf8097e0..bf296da875 100644
--- a/curriculum/challenges/italian/01-responsive-web-design/basic-html-and-html5/comment-out-html.md
+++ b/curriculum/challenges/italian/01-responsive-web-design/basic-html-and-html5/comment-out-html.md
@@ -43,7 +43,7 @@ Ciascuno dei tuoi commenti dovrebbe essere chiuso con `-->`.
 assert(code.match(/[^fc]-->/g).length > 1);
 ```
 
-Non dovresti modificare l'ordine dei tag `h1` `h2` o `p` nel codice.
+Non dovresti modificare l'ordine degli elementi `h1` `h2` o `p` nel codice.
 
 ```js
 assert(
diff --git a/curriculum/challenges/italian/01-responsive-web-design/basic-html-and-html5/inform-with-the-paragraph-element.md b/curriculum/challenges/italian/01-responsive-web-design/basic-html-and-html5/inform-with-the-paragraph-element.md
index ec5e19335a..bf32b4c50c 100644
--- a/curriculum/challenges/italian/01-responsive-web-design/basic-html-and-html5/inform-with-the-paragraph-element.md
+++ b/curriculum/challenges/italian/01-responsive-web-design/basic-html-and-html5/inform-with-the-paragraph-element.md
@@ -9,7 +9,7 @@ dashedName: inform-with-the-paragraph-element
 
 # --description--
 
-Gli elementi `p` sono i preferiti per i paragrafi di testo nei siti web. `p` è l'abbreviazione per "paragrafo".
+L'elemento `p` è preferibile per i paragrafi di testo nei siti web. `p` è l'abbreviazione per "paragrafo".
 
 Puoi creare un elemento paragrafo in questo modo:
 
diff --git a/curriculum/challenges/italian/01-responsive-web-design/css-flexbox/align-elements-using-the-justify-content-property.md b/curriculum/challenges/italian/01-responsive-web-design/css-flexbox/align-elements-using-the-justify-content-property.md
index acdfc49fb4..a8cef073e6 100644
--- a/curriculum/challenges/italian/01-responsive-web-design/css-flexbox/align-elements-using-the-justify-content-property.md
+++ b/curriculum/challenges/italian/01-responsive-web-design/css-flexbox/align-elements-using-the-justify-content-property.md
@@ -17,7 +17,7 @@ Ricorda che l'impostazione di un contenitore flex come riga posiziona gli elemen
 
 Ci sono diverse opzioni per come spaziare gli elementi flex lungo la linea che è l'asse principale. Uno dei più comunemente usati è `justify-content: center;`, che allinea tutti gli elementi flex al centro del contenitore flex. Altre opzioni includono:
 
-<ul><li><code>flex-start</code>: allinea gli elementi all'inizio del contenitore flex. Per una riga, questo spinge gli oggetti alla sinistra del contenitore. Per una colonna, questo spinge gli oggetti verso l'alto del contenitore. Questo è l'allineamento predefinito se non viene specificato alcun <code>justify-content</code>.</li><li><code>flex-end</code>: allinea gli elementi alla fine del contenitore flex. Per una riga, questo spinge gli oggetti alla destra del contenitore. Per una colonna, questo spinge gli oggetti verso il fondo del contenitore.</li><li><code>space-between</code>: allinea gli oggetti al centro dell'asse principale, con spazio aggiuntivo tra gli elementi. Il primo e l'ultimo elemento vengono spinti fino all'estremità del contenitore flex. Ad esempio, in una riga il primo elemento è contro il lato sinistro del contenitore, l'ultimo elemento è contro il lato destro del contenitore, quindi lo spazio rimanente è distribuito uniformemente tra gli altri elementi.</li><li><code>space-around</code>: simile a <code>space-between</code> ma il primo e l'ultimo elemento non sono vincolati ai bordi del contenitore, lo spazio è distribuito intorno a tutti gli elementi con metà dello spazio su entrambe le estremità del contenitore flex.</li><li><code>space-evenly</code>: Distribuisce lo spazio uniformemente tra gli elementi flex con uno spazio pieno a entrambe le estremità del contrainer flex</li></ul>
+<ul><li><code>flex-start</code>: allinea gli elementi all'inizio del contenitore flex. Per una riga, questo spinge gli oggetti alla sinistra del contenitore. Per una colonna, questo spinge gli oggetti verso l'alto del contenitore. Questo è l'allineamento predefinito se non viene specificato alcun <code>justify-content</code>.</li><li><code>flex-end</code>: allinea gli elementi alla fine del contenitore flex. Per una riga, questo spinge gli oggetti alla destra del contenitore. Per una colonna, questo spinge gli oggetti verso il fondo del contenitore.</li><li><code>space-between</code>: allinea gli oggetti al centro dell'asse principale, con spazio aggiuntivo tra gli elementi. Il primo e l'ultimo elemento vengono spinti fino all'estremità del contenitore flex. Ad esempio, in una riga il primo elemento è contro il lato sinistro del contenitore, l'ultimo elemento è contro il lato destro del contenitore, quindi lo spazio rimanente è distribuito uniformemente tra gli altri elementi.</li><li><code>space-around</code>: simile a <code>space-between</code> ma il primo e l'ultimo elemento non sono vincolati ai bordi del contenitore, lo spazio è distribuito intorno a tutti gli elementi con metà dello spazio su entrambe le estremità del contenitore flex.</li><li><code>space-evenly</code>: distribuisce lo spazio uniformemente tra gli elementi flex con uno spazio pieno a entrambe le estremità del contrainer flex.</li></ul>
 
 # --instructions--
 
diff --git a/curriculum/challenges/italian/01-responsive-web-design/css-flexbox/use-the-flex-wrap-property-to-wrap-a-row-or-column.md b/curriculum/challenges/italian/01-responsive-web-design/css-flexbox/use-the-flex-wrap-property-to-wrap-a-row-or-column.md
index afe4bc93f6..da1bffa0aa 100644
--- a/curriculum/challenges/italian/01-responsive-web-design/css-flexbox/use-the-flex-wrap-property-to-wrap-a-row-or-column.md
+++ b/curriculum/challenges/italian/01-responsive-web-design/css-flexbox/use-the-flex-wrap-property-to-wrap-a-row-or-column.md
@@ -9,7 +9,7 @@ dashedName: use-the-flex-wrap-property-to-wrap-a-row-or-column
 
 # --description--
 
-Flexbox ha una funzione per dividere un elemento flex in più righe (o colonne). Per impostazione predefinita, un contenitore flex si adatterà a tutti gli elementi flex insieme. Ad esempio, una riga sarà tutta su una riga.
+Flexbox ha una funzione per dividere un contenitore flex in più righe (o colonne). Per impostazione predefinita, un contenitore flex si adatterà a tutti gli elementi flex insieme. Ad esempio, una riga sarà tutta su una riga.
 
 Tuttavia, usando la proprietà `flex-wrap` potremo dire a CSS di mandare a capo gli oggetti. Questo significa che gli elementi extra si sposteranno in una nuova riga o colonna. Il punto di rottura in cui avviene il ritorno a capo dipende dalle dimensioni degli oggetti e dalle dimensioni del contenitore.
 
diff --git a/curriculum/challenges/italian/01-responsive-web-design/css-grid/place-items-in-grid-areas-using-the-grid-area-property.md b/curriculum/challenges/italian/01-responsive-web-design/css-grid/place-items-in-grid-areas-using-the-grid-area-property.md
index fe2913c9a3..bd7434b7c1 100644
--- a/curriculum/challenges/italian/01-responsive-web-design/css-grid/place-items-in-grid-areas-using-the-grid-area-property.md
+++ b/curriculum/challenges/italian/01-responsive-web-design/css-grid/place-items-in-grid-areas-using-the-grid-area-property.md
@@ -17,7 +17,7 @@ Dopo aver creato un modello di area per il contenitore griglia, come mostrato ne
 }
 ```
 
-Questo consente alla griglia di sapere che vuoi che la classe `item1` vada nell'area denominata `header`. In questo caso, l'elemento userà l'intera riga in alto perché essa è definita come area di intestazione (header).
+Questo consente alla griglia di sapere che vuoi che la classe `item1` vada nell'area denominata `header`. In questo caso, l'elemento userà l'intera riga in alto perché essa è definita come area `header`.
 
 # --instructions--
 
diff --git a/curriculum/challenges/italian/01-responsive-web-design/css-grid/use-css-grid-units-to-change-the-size-of-columns-and-rows.md b/curriculum/challenges/italian/01-responsive-web-design/css-grid/use-css-grid-units-to-change-the-size-of-columns-and-rows.md
index 25430e0ca2..42e0e0f488 100644
--- a/curriculum/challenges/italian/01-responsive-web-design/css-grid/use-css-grid-units-to-change-the-size-of-columns-and-rows.md
+++ b/curriculum/challenges/italian/01-responsive-web-design/css-grid/use-css-grid-units-to-change-the-size-of-columns-and-rows.md
@@ -31,7 +31,7 @@ Crea una griglia con tre colonne le cui larghezze sono le seguenti: 1fr, 100px e
 
 # --hints--
 
-La classe `container` dovrebbe avere una proprietà `grid-template-columns` che ha tre colonne con le seguenti larghezze: `1fr, 100px, and 2fr`.
+La classe `container` dovrebbe avere una proprietà `grid-template-columns` che ha tre colonne con le seguenti larghezze: `1fr`, `100px`e `2fr`.
 
 ```js
 assert(
diff --git a/curriculum/challenges/italian/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/convert-celsius-to-fahrenheit.md b/curriculum/challenges/italian/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/convert-celsius-to-fahrenheit.md
index 701ea76e62..1faa90ee37 100644
--- a/curriculum/challenges/italian/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/convert-celsius-to-fahrenheit.md
+++ b/curriculum/challenges/italian/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/convert-celsius-to-fahrenheit.md
@@ -8,9 +8,9 @@ dashedName: convert-celsius-to-fahrenheit
 
 # --description--
 
-L'algoritmo per convertire i gradi da Celsius a Fahrenheit è la temperatura in Celsius moltiplicata per `9/5`, più `32`.
+La formula per convertire i gradi da Celsius a Fahrenheit è la temperatura in Celsius moltiplicata per `9/5`, più `32`.
 
-Ti viene data una variabile `celsius` che rappresenta una temperatura in Celsius. Usa la variabile `fahrenheit` già definita e assegnale la temperatura Fahrenheit equivalente alla temperatura Celsius specificata. Usa l'algoritmo definito sopra per aiutarti a convertire la temperatura da Celsius a Fahrenheit.
+Ti viene data una variabile `celsius` che rappresenta una temperatura in Celsius. Usa la variabile `fahrenheit` già definita e assegnale la temperatura Fahrenheit equivalente alla temperatura Celsius specificata. Usa la formula mernzionata qui sopra per aiutare a convertire la temperatura da gradi Celsius a Fahrenheit.
 
 # --hints--
 
diff --git a/curriculum/challenges/italian/02-javascript-algorithms-and-data-structures/basic-data-structures/check-if-an-object-has-a-property.md b/curriculum/challenges/italian/02-javascript-algorithms-and-data-structures/basic-data-structures/check-if-an-object-has-a-property.md
index ef169833f0..322d94ae6d 100644
--- a/curriculum/challenges/italian/02-javascript-algorithms-and-data-structures/basic-data-structures/check-if-an-object-has-a-property.md
+++ b/curriculum/challenges/italian/02-javascript-algorithms-and-data-structures/basic-data-structures/check-if-an-object-has-a-property.md
@@ -19,7 +19,7 @@ Entrambi restituirebbero `true`.
 
 # --instructions--
 
-Finisci di scrivere la funzione in modo che restituisca true se l'oggetto ad essa passato contiene tutti e quattro i nomi, `Alan`, `Jeff`, `Sarah` e `Ryan`, e false altrimenti.
+Finisci di scrivere la funzione in modo che restituisca `true` se l'oggetto ad essa passato contiene tutti e quattro i nomi, `Alan`, `Jeff`, `Sarah` e `Ryan`, altrimenti da come risultato `false`.
 
 # --hints--
 
diff --git a/curriculum/challenges/italian/02-javascript-algorithms-and-data-structures/basic-data-structures/remove-items-using-splice.md b/curriculum/challenges/italian/02-javascript-algorithms-and-data-structures/basic-data-structures/remove-items-using-splice.md
index b027543156..3191500b29 100644
--- a/curriculum/challenges/italian/02-javascript-algorithms-and-data-structures/basic-data-structures/remove-items-using-splice.md
+++ b/curriculum/challenges/italian/02-javascript-algorithms-and-data-structures/basic-data-structures/remove-items-using-splice.md
@@ -10,7 +10,7 @@ dashedName: remove-items-using-splice
 
 Ok, quindi abbiamo imparato a rimuovere gli elementi dall'inizio e dalla fine degli array usando `shift()` e `pop()`, ma cosa succede se vogliamo rimuovere un elemento da qualche parte nel mezzo? O rimuovere più di un elemento alla volta? Beh, ecco dove entra in gioco `splice()`. `splice()` ci permette di fare proprio questo: **rimuovere qualunque numero di elementi consecutivi** da qualsiasi punto di un array.
 
-`splice()` può richiedere fino a 3 parametri, ma per ora ci concentreremo solo sui primi 2. I primi due parametri di `splice()` sono interi che rappresentano indici, o posizioni, dell'array su cui viene chiamato `splice()`. E ricorda, gli array sono *indicizzati a zero*, quindi per indicare il primo elemento di un array, useremo `0`. Il primo parametro di `splice()`rappresenta l'indice dell'array da cui iniziare a rimuovere gli elementi, mentre il secondo parametro indica il numero di elementi da eliminare. Ad esempio:
+`splice()` può richiedere fino a 3 parametri, ma per ora ci concentreremo solo sui primi 2. I primi due parametri di `splice()` sono interi che rappresentano indici, o posizioni, dell'array sul quale viene chiamato `splice()`. E ricorda, gli array sono *indicizzati a zero*, quindi per indicare il primo elemento di un array, useremo `0`. Il primo parametro di `splice()`rappresenta l'indice dell'array da cui iniziare a rimuovere gli elementi, mentre il secondo parametro indica il numero di elementi da eliminare. Ad esempio:
 
 ```js
 let array = ['today', 'was', 'not', 'so', 'great'];
diff --git a/curriculum/challenges/italian/02-javascript-algorithms-and-data-structures/basic-javascript/access-array-data-with-indexes.md b/curriculum/challenges/italian/02-javascript-algorithms-and-data-structures/basic-javascript/access-array-data-with-indexes.md
index f616299623..d798f846d2 100644
--- a/curriculum/challenges/italian/02-javascript-algorithms-and-data-structures/basic-javascript/access-array-data-with-indexes.md
+++ b/curriculum/challenges/italian/02-javascript-algorithms-and-data-structures/basic-javascript/access-array-data-with-indexes.md
@@ -19,11 +19,11 @@ Gli indici degli array sono scritti nella stessa notazione tra parentesi usata d
 
 ```js
 const array = [50, 60, 70];
-array[0];
+console.log(array[0]);
 const data = array[1];
 ```
 
-`array[0]` ora è `50` e `data` ha il valore `60`.
+`console.log(array[0])` scrive `50`, e `data` ha il valore `60`.
 
 **Nota:** Non ci dovrebbero essere spazi tra il nome dell'array e le parentesi quadre, come in `array [0]`. Anche se JavaScript è in grado di elaborarlo correttamente, questo potrebbe confondere altri programmatori che leggono il tuo codice.
 
diff --git a/curriculum/challenges/italian/02-javascript-algorithms-and-data-structures/basic-javascript/record-collection.md b/curriculum/challenges/italian/02-javascript-algorithms-and-data-structures/basic-javascript/record-collection.md
index 12a7b5a260..2ffbe2c4d8 100644
--- a/curriculum/challenges/italian/02-javascript-algorithms-and-data-structures/basic-javascript/record-collection.md
+++ b/curriculum/challenges/italian/02-javascript-algorithms-and-data-structures/basic-javascript/record-collection.md
@@ -31,13 +31,13 @@ assert(
 );
 ```
 
-Dopo `updateRecords(recordCollection, 5439, "tracks", "Take a Chance on Me")`, `tracks` dovrebbero avere la stringa `Take a Chance on Me` come ultimo elemento.
+Dopo `updateRecords(recordCollection, 5439, "tracks", "Take a Chance on Me")`, `tracks` dovrebbe avere la stringa `Take a Chance on Me` come solo e ultimo elemento.
 
 ```js
 assert(
-  updateRecords(_recordCollection, 5439, 'tracks', 'Take a Chance on Me')[5439][
-    'tracks'
-  ].pop() === 'Take a Chance on Me'
+  updateRecords(_recordCollection, 5439, 'tracks', 'Take a Chance on Me') &&
+  _recordCollection[5439]['tracks'].length === 1 &&
+  _recordCollection[5439]['tracks'].pop() === 'Take a Chance on Me'
 );
 ```
 
diff --git a/curriculum/challenges/italian/02-javascript-algorithms-and-data-structures/basic-javascript/understanding-uninitialized-variables.md b/curriculum/challenges/italian/02-javascript-algorithms-and-data-structures/basic-javascript/understanding-uninitialized-variables.md
index 2ea4851d22..92ee5db13f 100644
--- a/curriculum/challenges/italian/02-javascript-algorithms-and-data-structures/basic-javascript/understanding-uninitialized-variables.md
+++ b/curriculum/challenges/italian/02-javascript-algorithms-and-data-structures/basic-javascript/understanding-uninitialized-variables.md
@@ -9,7 +9,7 @@ dashedName: understanding-uninitialized-variables
 
 # --description--
 
-Quando vengono dichiarate delle variabili in JavaScript, esse hanno un valore iniziale `undefined`. Se esegui un'operazione matematica su una variabile `undefined`, il risultato sarà `NaN` che significa <dfn>"Not a Number"</dfn> (non è un numero). Se concateni una stringa con una variabile `undefined`, otterrai una <dfn>stringa</dfn> letterale `undefined`.
+Quando vengono dichiarate delle variabili in JavaScript, esse hanno un valore iniziale `undefined`. Se esegui un'operazione matematica su una variabile `undefined`, il risultato sarà `NaN` che significa <dfn>"Not a Number"</dfn> (non è un numero). Se concateni una stringa con una variabile `undefined`, otterrai una <dfn>string</dfn> di valore `undefined`.
 
 # --instructions--
 
diff --git a/curriculum/challenges/italian/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/everything-be-true.md b/curriculum/challenges/italian/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/everything-be-true.md
index 6a4ff70a06..e99b67ee4e 100644
--- a/curriculum/challenges/italian/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/everything-be-true.md
+++ b/curriculum/challenges/italian/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/everything-be-true.md
@@ -18,120 +18,123 @@ Ricorda, puoi accedere alle proprietà dell'oggetto tramite la notazione a punti
 
 # --hints--
 
-`truthCheck([{"user": "Tinky-Winky", "sex": "male"}, {"user": "Dipsy", "sex": "male"}, {"user": "Laa-Laa", "sex": "female"}, {"user": "Po", "sex": "female"}], "sex")` dovrebbe restituire `true`.
+`truthCheck([{name: "Quincy", role: "Founder", isBot: false}, {name: "Naomi", role: "", isBot: false}, {name: "Camperbot", role: "Bot", isBot: true}], "isBot")` dovrebbe restituire `false`.
 
 ```js
-assert.strictEqual(
-  truthCheck(
-    [
-      { user: 'Tinky-Winky', sex: 'male' },
-      { user: 'Dipsy', sex: 'male' },
-      { user: 'Laa-Laa', sex: 'female' },
-      { user: 'Po', sex: 'female' }
-    ],
-    'sex'
-  ),
-  true
-);
+assert.strictEqual(truthCheck(
+  [
+    { name: "Quincy", role: "Founder", isBot: false },
+    { name: "Naomi", role: "", isBot: false },
+    { name: "Camperbot", role: "Bot", isBot: true }
+  ],
+  "isBot"), false);
 ```
 
-`truthCheck([{"user": "Tinky-Winky", "sex": "male"}, {"user": "Dipsy"}, {"user": "Laa-Laa", "sex": "female"}, {"user": "Po", "sex": "female"}], "sex")` dovrebbe restituire `false`.
+`truthCheck([{name: "Quincy", role: "Founder", isBot: false}, {name: "Naomi", role: "", isBot: false}, {name: "Camperbot", role: "Bot", isBot: true}], "name")` dovrebbe restituire `true`.
 
 ```js
-assert.strictEqual(
-  truthCheck(
-    [
-      { user: 'Tinky-Winky', sex: 'male' },
-      { user: 'Dipsy' },
-      { user: 'Laa-Laa', sex: 'female' },
-      { user: 'Po', sex: 'female' }
-    ],
-    'sex'
-  ),
-  false
-);
+assert.strictEqual(truthCheck(
+  [
+    { name: "Quincy", role: "Founder", isBot: false },
+    { name: "Naomi", role: "", isBot: false },
+    { name: "Camperbot", role: "Bot", isBot: true }
+  ],
+  "name"), true);
 ```
 
-`truthCheck([{"user": "Tinky-Winky", "sex": "male", "age": 0}, {"user": "Dipsy", "sex": "male", "age": 3}, {"user": "Laa-Laa", "sex": "female", "age": 5}, {"user": "Po", "sex": "female", "age": 4}], "age")` dovrebbe restituire `false`.
+`truthCheck([{name: "Quincy", role: "Founder", isBot: false}, {name: "Naomi", role: "", isBot: false}, {name: "Camperbot", role: "Bot", isBot: true}], "role")` dovrebbe restituire `false`.
 
 ```js
-assert.strictEqual(
-  truthCheck(
-    [
-      { user: 'Tinky-Winky', sex: 'male', age: 2 },
-      { user: 'Dipsy', sex: 'male', age: 0 },
-      { user: 'Laa-Laa', sex: 'female', age: 5 },
-      { user: 'Po', sex: 'female', age: 4 }
-    ],
-    'age'
-  ),
-  false
-);
+assert.strictEqual(truthCheck(
+  [
+    { name: "Quincy", role: "Founder", isBot: false },
+    { name: "Naomi", role: "", isBot: false },
+    { name: "Camperbot", role: "Bot", isBot: true }
+  ],
+  "role"), false);
 ```
 
-`truthCheck([{"name": "Pete", "onBoat": true}, {"name": "Repeat", "onBoat": true}, {"name": "FastForward", "onBoat": null}], "onBoat")` dovrebbe restituire `false`.
+`truthCheck([{name: "Pikachu", number: 25, caught: 3}, {name: "Togepi", number: 175, caught: 1}], "number")` dovrebbe ritornare `true`.
 
 ```js
-assert.strictEqual(
-  truthCheck(
-    [
-      { name: 'Pete', onBoat: true },
-      { name: 'Repeat', onBoat: true },
-      { name: 'FastForward', onBoat: null }
-    ],
-    'onBoat'
-  ),
-  false
-);
+assert.strictEqual(truthCheck(
+  [
+    { name: "Pikachu", number: 25, caught: 3 },
+    { name: "Togepi", number: 175, caught: 1 },
+  ],
+  "number"), true);
 ```
 
-`truthCheck([{"name": "Pete", "onBoat": true}, {"name": "Repeat", "onBoat": true, "alias": "Repete"}, {"name": "FastForward", "onBoat": true}], "onBoat")` dovrebbe restituire `true`.
+`truthCheck([{name: "Pikachu", number: 25, caught: 3}, {name: "Togepi", number: 175, caught: 1}, {name: "MissingNo", number: NaN, caught: 0}], "caught")` dovrebbe restituire `false`.
 
 ```js
-assert.strictEqual(
-  truthCheck(
-    [
-      { name: 'Pete', onBoat: true },
-      { name: 'Repeat', onBoat: true, alias: 'Repete' },
-      { name: 'FastForward', onBoat: true }
-    ],
-    'onBoat'
-  ),
-  true
-);
+assert.strictEqual(truthCheck(
+  [
+    { name: "Pikachu", number: 25, caught: 3 },
+    { name: "Togepi", number: 175, caught: 1 },
+    { name: "MissingNo", number: NaN, caught: 0 },
+  ],
+  "caught"), false);
 ```
 
-`truthCheck([{"single": "yes"}], "single")` dovrebbe restituire `true`.
+`truthCheck([{name: "Pikachu", number: 25, caught: 3}, {name: "Togepi", number: 175, caught: 1}, {name: "MissingNo", number: NaN, caught: 0}], "number")` dovrebbe restituire `false`.
 
 ```js
-assert.strictEqual(truthCheck([{ single: 'yes' }], 'single'), true);
+assert.strictEqual(truthCheck(
+  [
+    { name: "Pikachu", number: 25, caught: 3 },
+    { name: "Togepi", number: 175, caught: 1 },
+    { name: "MissingNo", number: NaN, caught: 0 },
+  ],
+  "number"), false);
 ```
 
-`truthCheck([{"single": ""}, {"single": "double"}], "single")` dovrebbe restituire `false`.
+`truthCheck([{name: "Quincy", username: "QuincyLarson"}, {name: "Naomi", username: "nhcarrigan"}, {name: "Camperbot"}], "username")` dovrebbe restituire `false`.
 
 ```js
-assert.strictEqual(
-  truthCheck([{ single: '' }, { single: 'double' }], 'single'),
-  false
-);
+assert.strictEqual(truthCheck(
+  [
+    { name: "Quincy", username: "QuincyLarson" },
+    { name: "Naomi", username: "nhcarrigan" },
+    { name: "Camperbot" }
+  ],
+  "username"), false);
 ```
 
-`truthCheck([{"single": "double"}, {"single": undefined}], "single")` dovrebbe restituire `false`.
+`truthCheck([{name: "freeCodeCamp", users: [{name: "Quincy"}, {name: "Naomi"}]}, {name: "Code Radio", users: [{name: "Camperbot"}]}, {name: "", users: []}], "users")` dovrebbe restituire `true`.
 
 ```js
-assert.strictEqual(
-  truthCheck([{ single: 'double' }, { single: undefined }], 'single'),
-  false
-);
+assert.strictEqual(truthCheck(
+  [
+    { name: "freeCodeCamp", users: [{ name: "Quincy" }, { name: "Naomi" }] },
+    { name: "Code Radio", users: [{ name: "Camperbot" }] },
+    { name: "", users: [] },
+  ],
+  "users"), true);
 ```
 
-`truthCheck([{"single": "double"}, {"single": NaN}], "single")` dovrebbe restituire `false`.
+`truthCheck([{id: 1, data: {url: "https://freecodecamp.org", name: "freeCodeCamp"}}, {id: 2, data: {url: "https://coderadio.freecodecamp.org/", name: "CodeRadio"}}, {id: null, data: {}}], "data")` dovrebbe restituire `true`.
 
 ```js
-assert.strictEqual(
-  truthCheck([{ single: 'double' }, { single: NaN }], 'single'),
-  false
-);
+assert.strictEqual(truthCheck(
+  [
+    { id: 1, data: { url: "https://www.freecodecamp.org", name: "freeCodeCamp" } },
+    { id: 2, data: { url: "https://coderadio.freecodecamp.org/", name: "CodeRadio" } },
+    { id: null, data: {} },
+  ],
+  "data"), true);
+```
+
+`truthCheck([{id: 1, data: {url: "https://freecodecamp.org", name: "freeCodeCamp"}}, {id: 2, data: {url: "https://coderadio.freecodecamp.org/", name: "CodeRadio"}}, {id: null, data: {}}], "id")` dovrebbe restituire `false`.
+
+```js
+assert.strictEqual(truthCheck(
+  [
+    { id: 1, data: { url: "https://www.freecodecamp.org", name: "freeCodeCamp" } },
+    { id: 2, data: { url: "https://coderadio.freecodecamp.org/", name: "CodeRadio" } },
+    { id: null, data: {} },
+  ],
+  "id"), false);
 ```
 
 # --seed--
@@ -143,7 +146,7 @@ function truthCheck(collection, pre) {
   return pre;
 }
 
-truthCheck([{"user": "Tinky-Winky", "sex": "male"}, {"user": "Dipsy", "sex": "male"}, {"user": "Laa-Laa", "sex": "female"}, {"user": "Po", "sex": "female"}], "sex");
+truthCheck([{name: "Quincy", role: "Founder", isBot: false}, {name: "Naomi", role: "", isBot: false}, {name: "Camperbot", role: "Bot", isBot: true}], "isBot");
 ```
 
 # --solutions--
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/data-structures/add-a-new-element-to-a-binary-search-tree.md b/curriculum/challenges/italian/10-coding-interview-prep/data-structures/add-a-new-element-to-a-binary-search-tree.md
index af67f90d5c..96a269522d 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/data-structures/add-a-new-element-to-a-binary-search-tree.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/data-structures/add-a-new-element-to-a-binary-search-tree.md
@@ -22,7 +22,7 @@ Gli alberi binari di ricerca sono strutture di dati molto comuni e utili perché
 
 # --instructions--
 
-Cominceremo con qualcosa di semplice. Qui abbiamo definito lo scheletro di una struttura ad albero binario di ricerca oltre a una funzione per creare nodi per il nostro albero. Nota che ogni nodo può avere un valore sinistro e destro. A questi saranno assegnati sotto-alberi figli, se esistono. Nel nostro albero binario di ricerca, creerai un metodo per aggiungere nuovi valori. Il metodo dovrebbe essere chiamato `add` e dovrebbe accettare un valore intero da aggiungere all'albero. Fai attenzione a mantenere invariata la struttura di un albero binario di ricerca: il valore in ogni figlio sinistro dovrebbe essere inferiore o uguale al valore genitore, e il valore in ogni figlio destro dovrebbe essere maggiore o uguale al valore genitore. Ecco, facciamo in modo che il nostro albero non possa contenere valori duplicati. Se cerchiamo di aggiungere un valore che esiste già, il metodo dovrebbe restituire `null`. Altrimenti, se l'aggiunta è riuscita, dovrebbe essere restituito `undefined`.
+Cominceremo con qualcosa di semplice. Qui abbiamo definito lo scheletro di una struttura ad albero binario di ricerca oltre a una funzione per creare nodi per il nostro albero. Nota che ogni nodo può avere un valore sinistro e destro. A questi saranno assegnati sotto-alberi figli, se esistono. Nel nostro albero binario di ricerca, creerai un metodo per aggiungere nuovi valori all'albero. Il metodo dovrebbe essere chiamato `add` e dovrebbe accettare un valore intero da aggiungere all'albero. Fai attenzione a mantenere invariata la struttura di un albero binario di ricerca: il valore in ogni figlio sinistro dovrebbe essere inferiore o uguale al valore genitore, e il valore in ogni figlio destro dovrebbe essere maggiore o uguale al valore genitore. Ecco, facciamo in modo che il nostro albero non possa contenere valori duplicati. Se cerchiamo di aggiungere un valore che esiste già, il metodo dovrebbe restituire `null`. Altrimenti, se l'aggiunta è riuscita, dovrebbe essere restituito `undefined`.
 
 **Suggerimento:** gli alberi sono strutture dati ricorsive per natura!
 
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/data-structures/create-a-doubly-linked-list.md b/curriculum/challenges/italian/10-coding-interview-prep/data-structures/create-a-doubly-linked-list.md
index d72790c7a3..fd9b8158de 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/data-structures/create-a-doubly-linked-list.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/data-structures/create-a-doubly-linked-list.md
@@ -20,7 +20,7 @@ Fai attenzione a gestire eventuali casi limite durante la scrittura di questi me
 
 # --hints--
 
-La struttura di dati DoublyLinkedList dovrebbe esistere.
+La struttura dei dati `DoublyLinkedList` dovrebbe esistere.
 
 ```js
 assert(
@@ -34,7 +34,7 @@ assert(
 );
 ```
 
-La lista DoublyLinkedList dovrebbe avere un metodo chiamato add.
+Il `DoublyLinkedList` dovrebbe avere un metodo denominato `add`.
 
 ```js
 assert(
@@ -51,7 +51,7 @@ assert(
 );
 ```
 
-La lista DoublyLinkedList dovrebbe avere un metodo chiamato remove.
+Il `DoublyLinkedList` dovrebbe avere un metodo denominato `remove`.
 
 ```js
 assert(
@@ -68,7 +68,7 @@ assert(
 );
 ```
 
-Rimuovere un elemento da una lista vuota dovrebbe restituire null.
+Inoltre, la rimozione di qualsiasi elemento da una lista vuota dovrebbe restituire `null`.
 
 ```js
 assert(
@@ -82,7 +82,7 @@ assert(
 );
 ```
 
-Il metodo add dovrebbe aggiungere elementi all'elenco.
+Il metodo `add` dovrebbe aggiungere elementi alla lista.
 
 ```js
 assert(
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/data-structures/create-a-hash-table.md b/curriculum/challenges/italian/10-coding-interview-prep/data-structures/create-a-hash-table.md
index fdbabbfa61..7d5e9eb422 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/data-structures/create-a-hash-table.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/data-structures/create-a-hash-table.md
@@ -24,7 +24,7 @@ Assicurati di scrivere il tuo codice per gestire le collisioni!
 
 # --hints--
 
-La struttura di dati HashTable dovrebbe esistere.
+La struttura di dati `HashTable` dovrebbe esistere.
 
 ```js
 assert(
@@ -38,7 +38,7 @@ assert(
 );
 ```
 
-L'HashTable dovrebbe avere un metodo add.
+La tua classe `HashTable` dovrebbe avere un metodo `add`.
 
 ```js
 assert(
@@ -52,7 +52,7 @@ assert(
 );
 ```
 
-L'HashTable dovrebbe avere un metodo lookup.
+La tua classe `HashTable` dovrebbe avere un metodo `lookup`.
 
 ```js
 assert(
@@ -66,7 +66,7 @@ assert(
 );
 ```
 
-L'HashTable dovrebbe avere un metodo remove.
+La tua classe `HashTable` dovrebbe avere un metodo `remove`.
 
 ```js
 assert(
@@ -80,7 +80,7 @@ assert(
 );
 ```
 
-Il metodo add dovrebbe aggiungere coppie chiave-valore e il metodo di ricerca dovrebbe restituire i valori associati a una determinata chiave.
+Il metodo `add` dovrebbe aggiungere coppie chiave-valore e il metodo `lookup` dovrebbe restituire i valori associati con una determinata chiave.
 
 ```js
 assert(
@@ -95,7 +95,7 @@ assert(
 );
 ```
 
-Il metodo di rimozione dovrebbe accettare una chiave come input e dovrebbe rimuovere la coppia chiave-valore associata.
+Il metodo `remove` dovrebbe accettare una chiave come input e rimuovere la coppia chiave-valore associata.
 
 ```js
 assert(
@@ -113,7 +113,7 @@ assert(
 );
 ```
 
-Il metodo di rimozione dovrebbe rimuovere solo la coppia chiave-valore corretta.
+Il metodo `remove` dovrebbe rimuovere solo la coppia chiave-valore corretta.
 
 ```js
 assert(
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/data-structures/create-a-map-data-structure.md b/curriculum/challenges/italian/10-coding-interview-prep/data-structures/create-a-map-data-structure.md
index 7901131133..11ee14a5d1 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/data-structures/create-a-map-data-structure.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/data-structures/create-a-map-data-structure.md
@@ -26,7 +26,7 @@ Facciamo un po' di pratica nel creare la nostra mappa. Poiché gli oggetti JavaS
 
 # --hints--
 
-La struttura di dati Mappa dovrebbe esistere.
+La struttura dati `Map` dovrebbe esistere.
 
 ```js
 assert(
@@ -40,7 +40,7 @@ assert(
 );
 ```
 
-L'oggetto Map dovrebbe avere i seguenti metodi: add, remove, get, has, values, clear e size.
+L'oggetto `Map` dovrebbe seguire i seguenti metodi: `add`, `remove`, `get`, `has`, `values`, `clear`, and `size`.
 
 ```js
 assert(
@@ -62,7 +62,7 @@ assert(
 );
 ```
 
-Il metodo add dovrebbe aggiungere oggetti alla mappa.
+Il metodo `add` dovrebbe aggiungere degli oggetti alla mappa.
 
 ```js
 assert(
@@ -79,7 +79,7 @@ assert(
 );
 ```
 
-Il metodo has dovrebbe restituire true per elementi esistenti e false per oggetti non esistenti.
+Il metodo `has` dovrebbe restituire `true` per gli oggetti aggiunti e `false` per quelli assenti.
 
 ```js
 assert(
@@ -94,7 +94,7 @@ assert(
 );
 ```
 
-Il metodo get dovrebbe accettare delle chiavi come input e dovrebbe restituire i valori associati.
+Il metodo `get` dovrebbe accettare le chiavi come input e dovrebbe restituire i valori associati.
 
 ```js
 assert(
@@ -109,7 +109,7 @@ assert(
 );
 ```
 
-Il metodo values dovrebbe restituire tutti i valori immagazzinati nella mappa come stringhe in un array.
+Il `values` dovrebbe ritornare tutti i valori immagazzinati nella mappa come stringhe in una variabile.
 
 ```js
 assert(
@@ -131,7 +131,7 @@ assert(
 );
 ```
 
-Il metodo clear dovrebbe svuotare la mappa e il metodo size dovrebbe restituire il numeri di oggetti presenti nella mappa.
+Il metodo `clear` dovrebbe svuotare la mappa e il metodo `size` dovrebbe restituire il numero di elementi presenti nella mappa.
 
 ```js
 assert(
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/data-structures/create-a-trie-search-tree.md b/curriculum/challenges/italian/10-coding-interview-prep/data-structures/create-a-trie-search-tree.md
index 4afbd6a370..5402ea96f1 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/data-structures/create-a-trie-search-tree.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/data-structures/create-a-trie-search-tree.md
@@ -16,7 +16,7 @@ Creiamo un trie per memorizzare parole. Accetterà parole attraverso un metodo `
 
 # --hints--
 
-Il Trie dovrebbe avere un metodo add.
+La tua classe `HashTable` dovrebbe avere un metodo `add`.
 
 ```js
 assert(
@@ -32,7 +32,7 @@ assert(
 );
 ```
 
-Il Trie dovrebbe avere un metodo print.
+Il `Trie` dovrebbe avere `print` come metodo.
 
 ```js
 assert(
@@ -48,7 +48,7 @@ assert(
 );
 ```
 
-Il Trie dovrebbe avere un metodo isWord.
+La tua classe `HashTable` dovrebbe avere un metodo `add`.
 
 ```js
 assert(
@@ -93,7 +93,7 @@ assert(
 );
 ```
 
-Il metodo isWord dovrebbe restituire vero solo per le parole aggiunte al trie e falso per tutte le altre parole.
+Il `has` dovrebbe ritornare `true` per gli oggetti aggiunti `false` per consentire gli altri oggetti.
 
 ```js
 assert(
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/data-structures/create-an-es6-javascript-map.md b/curriculum/challenges/italian/10-coding-interview-prep/data-structures/create-an-es6-javascript-map.md
index 1a6ec608b3..93abd0d4c7 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/data-structures/create-an-es6-javascript-map.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/data-structures/create-an-es6-javascript-map.md
@@ -8,7 +8,15 @@ dashedName: create-an-es6-javascript-map
 
 # --description--
 
-La nuova versione di JavaScript ci fornisce un oggetto Map incorporato che fornisce gran parte delle funzionalità che abbiamo scritto a mano nell'ultima sfida. Questo oggetto Map, anche se simile a oggetti JavaScript regolari, fornisce alcune funzionalità utili che agli oggetti normali mancano. Ad esempio, una Map ES6 tiene in memoria l'ordine di inserimento degli elementi che vengono aggiunti. Ecco una panoramica più completa dei suoi metodi: `.has(key)` restituisce true o false in base alla presenza di una chiave `.get(key)` restituisce il valore associato con una chiave `.set(key, value)` aggiunge una nuova coppia chiave-valore `.delete(key)` rimuove una coppia chiave-valore `.clear()` rimuove tutte le coppie chiave-valore `.entries()` restituisce un array con tutte le chiavi in ordine di inserimento `.values()` restituisce un array con tutti i valori in ordine di inserzione
+La nuova versione di JavaScript ci fornisce un oggetto Map incorporato che fornisce gran parte delle funzionalità che abbiamo scritto a mano nell'ultima sfida. Questo oggetto Map, anche se simile a oggetti JavaScript regolari, fornisce alcune funzionalità utili che agli oggetti normali mancano. Ad esempio, una Map ES6 tiene in memoria l'ordine di inserimento degli elementi che vengono aggiunti. Ecco una panoramica più completa dei suoi metodi:
+
+- `.has(key)` restituisce vero o falso in base alla presenza di una chiave
+- `.get(key)` restituisce il valore associato a una chiave
+- `.set(key, value)` imposta una nuova coppia chiave-valore
+- `.delete(key)` rimuove una coppia chiave-valore
+- `.clear()` rimuove tutte le coppie chiave-valore
+- `.entries()` restituisce un array di tutte le chiavi in ordine di inserimento
+- `.values()` restituisce un array di tutti i valori in ordine di inserimento
 
 # --instructions--
 
@@ -16,13 +24,13 @@ Definisci un oggetto Map JavaScript e assegna ad esso una variabile chiamata myM
 
 # --hints--
 
-L'oggetto myMap dovrebbe esistere.
+L'oggetto `myMap` dovrebbe esistere.
 
 ```js
 assert(typeof myMap === 'object');
 ```
 
-myMap dovrebbe contenere la coppia chiave-valore `freeCodeCamp`, `Awesome!`.
+`myMap` dovrebbe contenere la coppia chiave-valore `freeCodeCamp`,`Awesome!`.
 
 ```js
 assert(myMap.get('freeCodeCamp') === 'Awesome!');
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/data-structures/implement-heap-sort-with-a-min-heap.md b/curriculum/challenges/italian/10-coding-interview-prep/data-structures/implement-heap-sort-with-a-min-heap.md
index 317d7da3ec..092f3dd94b 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/data-structures/implement-heap-sort-with-a-min-heap.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/data-structures/implement-heap-sort-with-a-min-heap.md
@@ -18,7 +18,7 @@ Implementa un heap sort con un min heap. Adatta liberamente il codice del tuo ma
 
 # --hints--
 
-La struttura dati MinHeap dovrebbe esistere.
+La struttura dati `MinHeap` dovrebbe esistere
 
 ```js
 assert(
@@ -32,7 +32,7 @@ assert(
 );
 ```
 
-MinHeap dovrebbe avere un metodo chiamato insert.
+`MinHeap` dovrebbe avere un metodo chiamato `insert`
 
 ```js
 assert(
@@ -48,7 +48,7 @@ assert(
 );
 ```
 
-MinHeap dovrebbe avere un metodo chiamato remove.
+`MinHeap` dovrebbe avere un metodo chiamato `remove`
 
 ```js
 assert(
@@ -64,7 +64,7 @@ assert(
 );
 ```
 
-MinHeap dovrebbe avere un metodo chiamato sort.
+`MinHeap` dovrebbe avere un metodo chiamato `insert`
 
 ```js
 assert(
@@ -80,7 +80,7 @@ assert(
 );
 ```
 
-Il metodo sort dovrebbe restituire un array che continuete tutto gli elementi aggiunti al min heap ordinati.
+Il metodo sort dovrebbe restituire un array che contiene tutti gli elementi aggiunti al min heap ordinati.
 
 ```js
 assert(
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/data-structures/incidence-matrix.md b/curriculum/challenges/italian/10-coding-interview-prep/data-structures/incidence-matrix.md
index 63b1eabd12..2a5389ac70 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/data-structures/incidence-matrix.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/data-structures/incidence-matrix.md
@@ -18,7 +18,7 @@ Ogni colonna rappresenterà un arco unico. Inoltre, ogni arco collegherà due no
 
 <blockquote>    1<br>   ---<br>1 | 1<br>2 | 0<br>3 | 1</blockquote>
 
-Ecco un esempio di una `incidence matrix` con 4 archi e 4 nodi. Ricorda, le colonne sono gli archi e le righe sono i nodi.
+Ecco un esempio di matrice di incidenza con 4 archi e 4 nodi. Ricorda, le colonne sono gli archi e le righe sono i nodi.
 
 <blockquote>    1 2 3 4<br>   --------<br>1 | 0 1 1 1<br>2 | 1 1 0 0<br>3 | 1 0 0 1<br>4 | 0 0 1 0</blockquote>
 
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/data-structures/insert-an-element-into-a-max-heap.md b/curriculum/challenges/italian/10-coding-interview-prep/data-structures/insert-an-element-into-a-max-heap.md
index 767f0a6a2a..886a08a7cd 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/data-structures/insert-an-element-into-a-max-heap.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/data-structures/insert-an-element-into-a-max-heap.md
@@ -48,7 +48,7 @@ Alla fine, aggiungi un metodo `print` che restituire un array di tutti gli eleme
 
 # --hints--
 
-La struttura dati MaxHeap dovrebbe esistere.
+La struttura dati `MaxHeap` dovrebbe esistere
 
 ```js
 assert(
@@ -62,7 +62,7 @@ assert(
 );
 ```
 
-MaxHeap dovrebbe avere un metodo chiamato insert.
+`MaxHeap`dovrebbe avere un metodo chiamato `insert`.
 
 ```js
 assert(
@@ -78,7 +78,7 @@ assert(
 );
 ```
 
-MaxHeap dovrebbe avere un metodo chiamato print.
+`MaxHeap` dovrebbe avere un metodo chiamato `print`
 
 ```js
 assert(
@@ -94,7 +94,7 @@ assert(
 );
 ```
 
-Il metodo insert dovrebbe aggiungere elementi rispettando la proprietà max heap.
+Il metodo `insert` dovrebbe aggiungere elementi in base alla proprietà heap massima
 
 ```js
 assert(
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/data-structures/perform-a-subset-check-on-two-sets-of-data.md b/curriculum/challenges/italian/10-coding-interview-prep/data-structures/perform-a-subset-check-on-two-sets-of-data.md
index e4336b1c3f..2ebbc5d2e1 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/data-structures/perform-a-subset-check-on-two-sets-of-data.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/data-structures/perform-a-subset-check-on-two-sets-of-data.md
@@ -25,7 +25,7 @@ assert(
 );
 ```
 
-Il primo Set() dovrebbe essere contenuto nel secondo Set
+Il primo `Set` dovrebbe essere contenuto nel secondo `Set`
 
 ```js
 assert(
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/data-structures/perform-a-union-on-two-sets.md b/curriculum/challenges/italian/10-coding-interview-prep/data-structures/perform-a-union-on-two-sets.md
index 1ffa861051..d477d3a73e 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/data-structures/perform-a-union-on-two-sets.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/data-structures/perform-a-union-on-two-sets.md
@@ -25,7 +25,7 @@ assert(
 );
 ```
 
-L'unione di un insieme contenente valori ["a", "b", "c"] e un insieme contenente valori ["c", "d"] dovrebbe restituire un nuovo Set contenente valori ["a", "b", "c", "d"].
+L'unione di un `Set` contenente valori `["a", "b", "c"]` e un `Set` contenente valori `["c", "d"]` dovrebbe restituire un nuovo `Set` contenente valori `["a", "b", "c", "d"]`.
 
 ```js
 assert(
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/data-structures/remove-an-element-from-a-max-heap.md b/curriculum/challenges/italian/10-coding-interview-prep/data-structures/remove-an-element-from-a-max-heap.md
index cff5e8f7a8..350de23d52 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/data-structures/remove-an-element-from-a-max-heap.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/data-structures/remove-an-element-from-a-max-heap.md
@@ -22,7 +22,7 @@ Istruzioni: Aggiungere un metodo al nostro max-heap chiamato `remove`. Questo me
 
 # --hints--
 
-La struttura dati MaxHeap dovrebbe esistere.
+La struttura dati `MaxHeap` dovrebbe esistere
 
 ```js
 assert(
@@ -36,7 +36,7 @@ assert(
 );
 ```
 
-MaxHeap dovrebbe avere un metodo chiamato print.
+`MaxHeap` dovrebbe avere un metodo chiamato `print`.
 
 ```js
 assert(
@@ -52,7 +52,7 @@ assert(
 );
 ```
 
-MaxHeap dovrebbe avere un metodo chiamato insert.
+`MaxHeap`dovrebbe avere un metodo chiamato `insert`.
 
 ```js
 assert(
@@ -68,7 +68,7 @@ assert(
 );
 ```
 
-MaxHeap dovrebbe avere un metodo chiamato remove.
+`MaxHeap`dovrebbe avere un metodo chiamato `remove`.
 
 ```js
 assert(
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/data-structures/reverse-a-doubly-linked-list.md b/curriculum/challenges/italian/10-coding-interview-prep/data-structures/reverse-a-doubly-linked-list.md
index be06c37599..5659fc855f 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/data-structures/reverse-a-doubly-linked-list.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/data-structures/reverse-a-doubly-linked-list.md
@@ -12,7 +12,7 @@ Creiamo un metodo in più per la nostra lista a doppio collegamento, chiamato re
 
 # --hints--
 
-La struttura dei dati DoublyLinkedList dovrebbe esistere.
+La struttura di dati DoublyLinkedList dovrebbe esistere.
 
 ```js
 assert(
@@ -26,7 +26,7 @@ assert(
 );
 ```
 
-La lista DoublyLinkedList dovrebbe avere un metodo chiamato reverse.
+`DoublyLinkedList` dovrebbe avere un metodo chiamato `reverse`.
 
 ```js
 assert(
@@ -43,7 +43,7 @@ assert(
 );
 ```
 
-Invertire una lista vuota dovrebbe restituire null.
+Invertire una lista vuota dovrebbe restituire `null`.
 
 ```js
 assert(
@@ -57,7 +57,7 @@ assert(
 );
 ```
 
-Il metodo reverse dovrebbe invertire l'elenco.
+Il metodo `reverse` dovrebbe invertire la lista.
 
 ```js
 assert(
@@ -77,7 +77,7 @@ assert(
 );
 ```
 
-I riferimenti next e previous dovrebbero essere mantenuti correttamente quando un elenco è invertito.
+I riferimenti `next` e `previous` dovrebbero essere mantenuti correttamente quando la lista è invertita.
 
 ```js
 assert(
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-101-optimum-polynomial.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-101-optimum-polynomial.md
index e89b16a12a..e1526cecbd 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-101-optimum-polynomial.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-101-optimum-polynomial.md
@@ -20,7 +20,9 @@ Di base, se ci fosse stato dato solo il primo termine della sequenza, sarebbe pi
 
 Quindi otterremo i seguenti PO per la sequenza cubica:
 
-$$\begin{array}{ll} OP(1, n) = 1          & 1, {\color{red}1}, 1, 1, \ldots     \\\\ OP(2, n) = 7n−6       & 1, 8, {\color{red}{15}}, \ldots     \\\\ OP(3, n) = 6n^2−11n+6 & 1, 8, 27, {\color{red}{58}}, \ldots \\\\ OP(4, n) = n^3        & 1, 8, 27, 64, 125, \ldots \end{array}$$
+$$\begin{array}{ll}   OP(1, n) = 1          & 1, {\color{red}1}, 1, 1, \ldots     \\\\
+  OP(2, n) = 7n−6       & 1, 8, {\color{red}{15}}, \ldots     \\\\   OP(3, n) = 6n^2−11n+6 & 1, 8, 27, {\color{red}{58}}, \ldots \\\\
+  OP(4, n) = n^3        & 1, 8, 27, 64, 125, \ldots \end{array}$$
 
 Chiaramente non esistono BOP per k ≥ 4. Considerando la somma delle FIT generate dai BOP (indicata in $\color{red}{red}$ sopra), otteniamo 1 + 15 + 58 = 74. Considera la seguente funzione generatrice polinomiale di decimo grado:
 
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-103-special-subset-sums-optimum.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-103-special-subset-sums-optimum.md
index f8b28612cc..982de4ecd0 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-103-special-subset-sums-optimum.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-103-special-subset-sums-optimum.md
@@ -15,7 +15,10 @@ Lascia che $S(A)$ rappresenti la somma degli elementi nel set A di dimensione n.
 
 Se $S(A)$ è minimizzata per un dato n, la chiameremo somma speciale di un set ottimale. Le prime cinque somme speciali di un set ottimale sono date sotto.
 
-$$\begin{align} & n = 1: \\{1\\} \\\\ & n = 2: \\{1, 2\\} \\\\ & n = 3: \\{2, 3, 4\\} \\\\ & n = 4: \\{3, 5, 6, 7\\} \\\\ & n = 5: \\{6, 9, 11, 12, 13\\} \\\\ \end{align}$$
+$$\begin{align}   & n = 1: \\{1\\} \\\\
+  & n = 2: \\{1, 2\\} \\\\   & n = 3: \\{2, 3, 4\\} \\\\
+  & n = 4: \\{3, 5, 6, 7\\} \\\\   & n = 5: \\{6, 9, 11, 12, 13\\} \\\\
+\end{align}$$
 
 Sembra che per un dato set ottimale, $A = \\{a_1, a_2, \ldots, a_n\\}$, il successivo set ottimale è della forma $B = \\{b, a_1 + b, a_2 + b, \ldots, a_n + b\\}$, dove b è l'elemento "di mezzo" della riga precedente.
 
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-108-diophantine-reciprocals-i.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-108-diophantine-reciprocals-i.md
index 7aa8c13459..6534da053d 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-108-diophantine-reciprocals-i.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-108-diophantine-reciprocals-i.md
@@ -14,7 +14,9 @@ $$\frac{1}{x} + \frac{1}{y} = \frac{1}{n}$$
 
 Per `n` = 4 ci sono esattamente tre distinte soluzioni:
 
-$$\begin{align} & \frac{1}{5} + \frac{1}{20} = \frac{1}{4}\\\\ \\\\ & \frac{1}{6} + \frac{1}{12} = \frac{1}{4}\\\\ \\\\ & \frac{1}{8} + \frac{1}{8} = \frac{1}{4} \end{align}$$
+$$\begin{align}   & \frac{1}{5} + \frac{1}{20} = \frac{1}{4}\\\\
+  \\\\   & \frac{1}{6} + \frac{1}{12} = \frac{1}{4}\\\\
+  \\\\ & \frac{1}{8} + \frac{1}{8} = \frac{1}{4} \end{align}$$
 
 Qual è il valore più piccolo di `n` per cui il numero di soluzioni distinte supera mille?
 
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-109-darts.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-109-darts.md
index 13ed62c4d7..b7eb3ace0d 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-109-darts.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-109-darts.md
@@ -20,7 +20,12 @@ Ci sono molte variazioni di regole ma nel gioco più popolare i giocatori inizia
 
 Quando un giocare è in grado di finire sul proprio punteggio viene chiamato un "checkout" e il checkout più alto è 170: T20 T20 D25 (due tripli 20 e un doppio centro). Ci sono esattamente 11 modi distinti per fare checkout con un punteggio di 6:
 
-$$\begin{array} \text{D3} &    &    \\\\ D1        & D2 &    \\\\ S2        & D2 &    \\\\ D2        & D1 &    \\\\ S4        & D1 &    \\\\ S1        & S1 & D2 \\\\ S1        & T1 & D1 \\\\ S1        & S3 & D1 \\\\ D1        & D1 & D1 \\\\ D1        & S2 & D1 \\\\ S2        & S2 & D1 \end{array}$$
+$$\begin{array}   \text{D3} &    &    \\\\
+  D1        & D2 &    \\\\   S2        & D2 &    \\\\
+  D2        & D1 &    \\\\   S4        & D1 &    \\\\
+  S1        & S1 & D2 \\\\   S1        & T1 & D1 \\\\
+  S1        & S3 & D1 \\\\   D1        & D1 & D1 \\\\
+  D1        & S2 & D1 \\\\ S2        & S2 & D1 \end{array}$$
 
 Nota che D1 D2 è considerato diverso da D2 D1 visto che finiscono su doppi diversi. Invece, la combinazione S1 T1 D1 è considerata la stessa di T1 S1 D1. In aggiunta, non includiamo lanci mancati considerando le combinazioni; per esempio, D3 è la stessa cosa di 0 D3 e 0 0 D3. Incredibilmente ci sono 42336 modi diversi per fare checkout in totale. Quanti modi distinti ci sono per un giocatore di fare checkout con un punteggio inferiore a 100?
 
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-122-efficient-exponentiation.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-122-efficient-exponentiation.md
index 2635f0f469..63f94b748a 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-122-efficient-exponentiation.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-122-efficient-exponentiation.md
@@ -14,11 +14,16 @@ $$n × n × \ldots × n = n^{15}$$
 
 Ma usando un metodo "binario" è possibile calcolarlo in sei moltiplicazioni:
 
-$$$\start{align} & n × n = n^2\\\\ & n^2 × n^2 = n^4\\\\ & n^4 × n^4 = n^8\\\\ & n^8 × n^4 = n^{12}\\\\ & n^{12} × n^2 = n^{14}\\\\ & n^{14} × n = n^{15} \end{align}$$
+$$$\start{align}   & n × n = n^2\\\\
+  & n^2 × n^2 = n^4\\\\   & n^4 × n^4 = n^8\\\\
+  & n^8 × n^4 = n^{12}\\\\   & n^{12} × n^2 = n^{14}\\\\
+  & n^{14} × n = n^{15} \end{align}$$
 
 Tuttavia è ancora possibile calcolarlo in sole cinque moltiplicazioni:
 
-$$\begin{align} & n × n = n^2\\\\ & n^2 × n = n^3\\\\ & n^3 × n^3 = n^6\\\\ & n^6 × n^6 = n^{12}\\\\ & n^{12} × n^3 = n^{15} \end{align}$$
+$$\begin{align}   & n × n = n^2\\\\
+  & n^2 × n = n^3\\\\   & n^3 × n^3 = n^6\\\\
+  & n^6 × n^6 = n^{12}\\\\ & n^{12} × n^3 = n^{15} \end{align}$$
 
 Definiremo $m(k)$ in modo che sia il numero minimo di moltiplicazioni per calcolare $n^k$; per esempio $m(15) = 5$.
 
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-137-fibonacci-golden-nuggets.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-137-fibonacci-golden-nuggets.md
index 9b445ef2ea..16cc0c3f69 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-137-fibonacci-golden-nuggets.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-137-fibonacci-golden-nuggets.md
@@ -14,7 +14,8 @@ Per questo problema consideriamo i valori di $x$ per cui $A_{F}(x)$ è un numero
 
 Sorprendentemente
 
-$$\begin{align} A_F(\frac{1}{2}) & = (\frac{1}{2}) × 1 + {(\frac{1}{2})}^2 × 1 + {(\frac{1}{2})}^3 × 2 + {(\frac{1}{2})}^4 × 3 + {(\frac{1}{2})}^5 × 5 + \cdots \\\\ & = \frac{1}{2} + \frac{1}{4} + \frac{2}{8} + \frac{3}{16} + \frac{5}{32} + \cdots \\\\ & = 2 \end{align}$$
+$$\begin{align} A_F(\frac{1}{2}) & = (\frac{1}{2}) × 1 + {(\frac{1}{2})}^2 × 1 + {(\frac{1}{2})}^3 × 2 + {(\frac{1}{2})}^4 × 3 + {(\frac{1}{2})}^5 × 5 + \cdots \\\\
+                 & = \frac{1}{2} + \frac{1}{4} + \frac{2}{8} + \frac{3}{16} + \frac{5}{32} + \cdots \\\\ & = 2 \end{align}$$
 
 I valori porrispondenti di $x$ per i primi cinque numeri naturali sono mostrati sotto.
 
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-150-searching-a-triangular-array-for-a-sub-triangle-having-minimum-sum.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-150-searching-a-triangular-array-for-a-sub-triangle-having-minimum-sum.md
index 87579299a0..69a3596dd3 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-150-searching-a-triangular-array-for-a-sub-triangle-having-minimum-sum.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-150-searching-a-triangular-array-for-a-sub-triangle-having-minimum-sum.md
@@ -17,13 +17,17 @@ Nell'esempio sottostante si può facilmente verificare che il triangolo marcato
 
 Vogliamo creare una tale matrice triangolare con mille righe, in modo da generare 500500 numeri pseudo-casuali $s_k$ nel range $±2^{19}$, utilizzando un tipo di generatore di numeri casuali (noto come generatore di elementi costitutivi lineari) come segue:
 
-$$\begin{align} t := & \\ 0\\\\ \text{for}\\ & k = 1\\ \text{up to}\\ k = 500500:\\\\ & t := (615949 × t + 797807)\\ \text{modulo}\\ 2^{20}\\\\ & s_k := t − 219\\\\ \end{align}$$
+$$\begin{align}   t := & \\ 0\\\\
+  \text{for}\\ & k = 1\\ \text{up to}\\ k = 500500:\\\\   & t := (615949 × t + 797807)\\ \text{modulo}\\ 2^{20}\\\\
+  & s_k := t − 219\\\\ \end{align}$$
 
 Thus: $s_1 = 273519$, $s_2 = −153582$, $s_3 = 450905$ etc.
 
 La nostra matrice triangolare è poi formata utilizzando i numeri pseudo-casuali in questo modo:
 
-$$ s_1 \\\\ s_2\\;s_3 \\\\ s_4\\; s_5\\; s_6 \\\\ s_7\\; s_8\\; s_9\\; s_{10} \\\\ \ldots $$
+$$ s_1 \\\\
+s_2\\;s_3 \\\\ s_4\\; s_5\\; s_6 \\\\
+s_7\\; s_8\\; s_9\\; s_{10} \\\\ \ldots $$
 
 I sub-triangoli possono iniziare da qualsiasi elemento dell'array ed estendersi quanto vogliamo (prendendo i due elementi direttamente sotto di esso dalla riga successiva, i tre elementi direttamente al di sotto dalla riga successiva, e così via).
 
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-157-solving-the-diophantine-equation.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-157-solving-the-diophantine-equation.md
index fc78e084e1..124270f025 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-157-solving-the-diophantine-equation.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-157-solving-the-diophantine-equation.md
@@ -12,7 +12,10 @@ Considera l'equazione diofantina $\frac{1}{a} + \frac{1}{b} = \frac{p}{{10}^n}$
 
 Per $n = 1$ questa equazione ha 20 soluzioni che sono elencate di seguito:
 
-$$\begin{array}{lllll} \frac{1}{1}  + \frac{1}{1}  = \frac{20}{10} & \frac{1}{1} + \frac{1}{2}  = \frac{15}{10} & \frac{1}{1}  + \frac{1}{5}  = \frac{12}{10} & \frac{1}{1} + \frac{1}{10} = \frac{11}{10} & \frac{1}{2}  + \frac{1}{2}  = \frac{10}{10} \\\\ \frac{1}{2}  + \frac{1}{5}  = \frac{7}{10}   & \frac{1}{2} + \frac{1}{10} = \frac{6}{10} & \frac{1}{3}  + \frac{1}{6}  = \frac{5}{10}   & \frac{1}{3} + \frac{1}{15} = \frac{4}{10} & \frac{1}{4}  + \frac{1}{4}  = \frac{5}{10} \\\\ \frac{1}{4}  + \frac{1}{4}  = \frac{5}{10}  & \frac{1}{5}  + \frac{1}{5}  = \frac{4}{10} & \frac{1}{5}  + \frac{1}{10} = \frac{3}{10}  & \frac{1}{6}  + \frac{1}{30} = \frac{2}{10} & \frac{1}{10} + \frac{1}{10} = \frac{2}{10} \\\\ \frac{1}{11} + \frac{1}{110} = \frac{1}{10} & \frac{1}{12} + \frac{1}{60}  = \frac{1}{10} & \frac{1}{14} + \frac{1}{35}  = \frac{1}{10} & \frac{1}{15} + \frac{1}{30}  = \frac{1}{10} & \frac{1}{20} + \frac{1}{20}  = \frac{1}{10} \end{array}$$
+$$\begin{array}{lllll} \frac{1}{1}  + \frac{1}{1}  = \frac{20}{10} & \frac{1}{1} + \frac{1}{2}  = \frac{15}{10} & \frac{1}{1}  + \frac{1}{5}  = \frac{12}{10} & \frac{1}{1} + \frac{1}{10} = \frac{11}{10} & \frac{1}{2}  + \frac{1}{2}  = \frac{10}{10} \\\\
+  \frac{1}{2}  + \frac{1}{5}  = \frac{7}{10}   & \frac{1}{2} + \frac{1}{10} = \frac{6}{10} & \frac{1}{3}  + \frac{1}{6}  = \frac{5}{10}   & \frac{1}{3} + \frac{1}{15} = \frac{4}{10} & \frac{1}{4}  + \frac{1}{4}  = \frac{5}{10} \\\\
+  \frac{1}{4}  + \frac{1}{4}  = \frac{5}{10}  & \frac{1}{5}  + \frac{1}{5}  = \frac{4}{10} & \frac{1}{5}  + \frac{1}{10} = \frac{3}{10}  & \frac{1}{6}  + \frac{1}{30} = \frac{2}{10} & \frac{1}{10} + \frac{1}{10} = \frac{2}{10} \\\\
+  \frac{1}{11} + \frac{1}{110} = \frac{1}{10} & \frac{1}{12} + \frac{1}{60}  = \frac{1}{10} & \frac{1}{14} + \frac{1}{35}  = \frac{1}{10} & \frac{1}{15} + \frac{1}{30}  = \frac{1}{10} & \frac{1}{20} + \frac{1}{20}  = \frac{1}{10} \end{array}$$
 
 Quante soluzioni ha questa equazione per $1 ≤ n ≤ 9$?
 
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-159-digital-root-sums-of-factorisations.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-159-digital-root-sums-of-factorisations.md
index a20ff0dee5..859f5fe3dd 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-159-digital-root-sums-of-factorisations.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-159-digital-root-sums-of-factorisations.md
@@ -12,7 +12,10 @@ Un numero composito può essere fattorizzato in molti modi diversi.
 
 Per esempio, senza includere la moltiplicazione per 1, 24 può essere fattorizzato in 7 modi distinti:
 
-$$\begin{align} & 24 = 2 \times 2 \times 2 \times 3\\\\ & 24 = 2 \times 3 \times 4  \\\\ & 24 = 2 \times 2 \times 6  \\\\ & 24 = 4 \times 6    \\\\ & 24 = 3 \times 8    \\\\ & 24 = 2 \times 12   \\\\ & 24 = 24 \end{align}$$
+$$\begin{align}   & 24 = 2 \times 2 \times 2 \times 3\\\\
+  & 24 = 2 \times 3 \times 4  \\\\   & 24 = 2 \times 2 \times 6  \\\\
+  & 24 = 4 \times 6    \\\\   & 24 = 3 \times 8    \\\\
+  & 24 = 2 \times 12   \\\\ & 24 = 24 \end{align}$$
 
 Ricordati che le radice numerica di un numero, in base 10, si trova sommando le cifre del numero e ripetendo il processo fino a che il risultato non è inferiore a 10. Quindi la radice numerica di 467 è 8.
 
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-160-factorial-trailing-digits.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-160-factorial-trailing-digits.md
index 272cf78329..eb99348bf9 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-160-factorial-trailing-digits.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-160-factorial-trailing-digits.md
@@ -12,7 +12,8 @@ Per ogni $N$, $f(N)$ rappresenti le ultime cinque cifre prima degli zero finali
 
 Ad esempio,
 
-$$\begin{align} & 9! = 362880 \\; \text{so} \\; f(9) = 36288 \\\\ & 10! = 3628800 \\; \text{so} \\; f(10) = 36288 \\\\ & 20! = 2432902008176640000 \\; \text{so} \\; f(20) = 17664 \end{align}$$
+$$\begin{align}   & 9! = 362880 \\; \text{so} \\; f(9) = 36288 \\\\
+  & 10! = 3628800 \\; \text{so} \\; f(10) = 36288 \\\\ & 20! = 2432902008176640000 \\; \text{so} \\; f(20) = 17664 \end{align}$$
 
 Trova $f(1,000,000,000,000)$
 
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-163-cross-hatched-triangles.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-163-cross-hatched-triangles.md
index 4e7692819b..e76b7ce94c 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-163-cross-hatched-triangles.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-163-cross-hatched-triangles.md
@@ -18,7 +18,8 @@ Si può vedere che il triangolo di dimensione 2 contiene 4 triangoli di dimensio
 
 Sia $T(n)$ il numero di triangoli presenti in un triangolo di dimensione $n$, allora
 
-$$\begin{align} & T(1) = 16 \\\\ & T(2) = 104 \end{align}$$
+$$\begin{align}   & T(1) = 16 \\\\
+  & T(2) = 104 \end{align}$$
 
 Trova $T(36)$.
 
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-165-intersections.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-165-intersections.md
index f5d1d8cd6d..5492b105c2 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-165-intersections.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-165-intersections.md
@@ -16,13 +16,17 @@ Sia $T$, un punto in comune di due segmenti $L_1$ e $L_2$, un vero punto d'inter
 
 Considera i tre segmenti $L_1$, $L_2$, e $L_3$:
 
-$$\begin{align} & L_1: (27, 44) \\;\text{to}\\; (12, 32) \\\\ & L_2: (46, 53) \\;\text{to}\\; (17, 62) \\\\ & L_3: (46, 70) \\;\text{to}\\; (22, 40) \\\\ \end{align}$$
+$$\begin{align}   & L_1: (27, 44) \\;\text{to}\\; (12, 32) \\\\
+  & L_2: (46, 53) \\;\text{to}\\; (17, 62) \\\\   & L_3: (46, 70) \\;\text{to}\\; (22, 40) \\\\
+\end{align}$$
 
 Si può verificare che i segmenti $L_2$ e $L_3$ hanno un vero punto di intersezione. Notiamo che essendo uno dei terminali di $L_3$: (22, 40) su $L_1$ questo non è un vero punto d'intersezione. $L_1$ e $L_2$ non hanno un punto in comune. Quindi tra i tre segmenti troviamo un vero punto di intersezione.
 
 Adesso facciamo lo stesso per 5000 segmenti. A questo fine, generiamo 20000 numeri casuali usando il generatore pseudo-casuale di numeri chiamato "Blum Blum Shub".
 
-$$\begin{align} & s_0 = 290797 \\\\ & s_{n + 1} = s_n × s_n (\text{modulo}\\; 50515093) \\\\ & t_n = s_n (\text{modulo}\\; 500) \\\\ \end{align}$$
+$$\begin{align}   & s_0 = 290797 \\\\
+  & s_{n + 1} = s_n × s_n (\text{modulo}\\; 50515093) \\\\   & t_n = s_n (\text{modulo}\\; 500) \\\\
+\end{align}$$
 
 Per creare ogni segmento, usiamo quattro numeri consecutivi $t_n$. Quindi, il primo segmento è dato da:
 
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-166-criss-cross.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-166-criss-cross.md
index b5efd80746..3e08c3fbc7 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-166-criss-cross.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-166-criss-cross.md
@@ -12,7 +12,9 @@ Una griglia 4x4 è riempita con cifre $d$, $0 ≤ d ≤ 9$.
 
 Si può vedere che nella griglia
 
-$$\begin{array}{} 6 & 3 & 3 & 0 \\\\ 5 & 0 & 4 & 3 \\\\ 0 & 7 & 1 & 4 \\\\ 1 & 2 & 4 & 5 \end{array}$$
+$$\begin{array}{}   6 & 3 & 3 & 0 \\\\
+  5 & 0 & 4 & 3 \\\\   0 & 7 & 1 & 4 \\\\
+  1 & 2 & 4 & 5 \end{array}$$
 
 la somma di ciascuna riga e di ciascuna colonna ha il valore 12. Inoltre la somma di ogni diagonale è anch'essa 12.
 
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-169-exploring-the-number-of-different-ways-a-number-can-be-expressed-as-a-sum-of-powers-of-2.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-169-exploring-the-number-of-different-ways-a-number-can-be-expressed-as-a-sum-of-powers-of-2.md
index a3d5d7d917..7496ac57cc 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-169-exploring-the-number-of-different-ways-a-number-can-be-expressed-as-a-sum-of-powers-of-2.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-169-exploring-the-number-of-different-ways-a-number-can-be-expressed-as-a-sum-of-powers-of-2.md
@@ -14,7 +14,9 @@ Sia $f(0) = 1$ e sia $f(n)$ il numero di modi diversi in cui $n$ può essere esp
 
 Per esempio, $f(10)=5$ visto che ci sono cinque modi diversi di esprimere 10:
 
-$$\begin{align} & 1 + 1 + 8 \\\\ & 1 + 1 + 4 + 4 \\\\ & 1 + 1 + 2 + 2 + 4 \\\\ & 2 + 4 + 4 \\\\ & 2 + 8 \end{align}$$
+$$\begin{align}   & 1 + 1 + 8 \\\\
+  & 1 + 1 + 4 + 4 \\\\   & 1 + 1 + 2 + 2 + 4 \\\\
+  & 2 + 4 + 4 \\\\ & 2 + 8 \end{align}$$
 
 Qual è il valore di $f({10}^{25})$?
 
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-170-find-the-largest-0-to-9-pandigital-that-can-be-formed-by-concatenating-products.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-170-find-the-largest-0-to-9-pandigital-that-can-be-formed-by-concatenating-products.md
index 015049f22e..3cdfd567e9 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-170-find-the-largest-0-to-9-pandigital-that-can-be-formed-by-concatenating-products.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-170-find-the-largest-0-to-9-pandigital-that-can-be-formed-by-concatenating-products.md
@@ -12,7 +12,8 @@ dashedName: >-
 
 Prendi il numero 6 e moltiplicalo per 1273 e 9854:
 
-$$\begin{align} & 6 × 1273 = 7638 \\\\ & 6 × 9854 = 59124 \\\\ \end{align}$$
+$$\begin{align}   & 6 × 1273 = 7638 \\\\
+  & 6 × 9854 = 59124 \\\\ \end{align}$$
 
 Concatenando questi prodotti otteniamo il pandigitale 1-9 763859124. Chiamiamo 763859124 il "prodotto concatenato di 6 e (1273, 9854)". Nota anche, che la concatenazione dei numeri di input, 612739854, è pure un numero pandigitale 1-9.
 
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-171-finding-numbers-for-which-the-sum-of-the-squares-of-the-digits-is-a-square.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-171-finding-numbers-for-which-the-sum-of-the-squares-of-the-digits-is-a-square.md
index d3c6086143..e018c509b2 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-171-finding-numbers-for-which-the-sum-of-the-squares-of-the-digits-is-a-square.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-171-finding-numbers-for-which-the-sum-of-the-squares-of-the-digits-is-a-square.md
@@ -12,7 +12,9 @@ dashedName: >-
 
 Per un numero intero positivo $n$, sia $f(n)$ la somma dei quadrati delle cifre (in base 10) di $n$, es.
 
-$$\begin{align} & f(3) = 3^2 = 9 \\\\ & f(25) = 2^2 + 5^2 = 4 + 25 = 29 \\\\ & f(442) = 4^2 + 4^2 + 2^2 = 16 + 16 + 4 = 36 \\\\ \end{align}$$
+$$\begin{align}   & f(3) = 3^2 = 9 \\\\
+  & f(25) = 2^2 + 5^2 = 4 + 25 = 29 \\\\   & f(442) = 4^2 + 4^2 + 2^2 = 16 + 16 + 4 = 36 \\\\
+\end{align}$$
 
 Trova le ultime nove cifre della somma di tutti $n$, $0 &lt; n &lt; {10}^{20}$, tali che $f(n)$ sia un quadrato perfetto.
 
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-180-rational-zeros-of-a-function-of-three-variables.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-180-rational-zeros-of-a-function-of-three-variables.md
index c47d575689..09be31baa9 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-180-rational-zeros-of-a-function-of-three-variables.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-180-rational-zeros-of-a-function-of-three-variables.md
@@ -10,7 +10,8 @@ dashedName: problem-180-rational-zeros-of-a-function-of-three-variables
 
 Per qualsiasi intero $n$, considera le tre funzioni
 
-$$\begin{align} & f_{1,n}(x,y,z) = x^{n + 1} + y^{n + 1} − z^{n + 1}\\\\ & f_{2,n}(x,y,z) = (xy + yz + zx) \times (x^{n - 1} + y^{n - 1} − z^{n - 1})\\\\ & f_{3,n}(x,y,z) = xyz \times (x^{n - 2} + y^{n - 2} − z^{n - 2}) \end{align}$$
+$$\begin{align}   & f_{1,n}(x,y,z) = x^{n + 1} + y^{n + 1} − z^{n + 1}\\\\
+  & f_{2,n}(x,y,z) = (xy + yz + zx) \times (x^{n - 1} + y^{n - 1} − z^{n - 1})\\\\ & f_{3,n}(x,y,z) = xyz \times (x^{n - 2} + y^{n - 2} − z^{n - 2}) \end{align}$$
 
 e la loro combinazione
 
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-185-number-mind.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-185-number-mind.md
index 4782f71045..4c951ff110 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-185-number-mind.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-185-number-mind.md
@@ -14,13 +14,27 @@ Invece di chiodini colorati, devi indovinare una sequenza segreta di cifre. Dopo
 
 Per esempio, date le seguenti ipotesi per una sequenza segreta di 5 cifre,
 
-$$\begin{align} & 90342 ;2\\;\text{correct}\\\\ & 70794 ;0\\;\text{correct}\\\\ & 39458 ;2\\;\text{correct}\\\\ & 34109 ;1\\;\text{correct}\\\\ & 51545 ;2\\;\text{correct}\\\\ & 12531 ;1\\;\text{correct} \end{align}$$
+$$\begin{align}   & 90342 ;2\\;\text{correct}\\\\
+  & 70794 ;0\\;\text{correct}\\\\   & 39458 ;2\\;\text{correct}\\\\
+  & 34109 ;1\\;\text{correct}\\\\   & 51545 ;2\\;\text{correct}\\\\
+  & 12531 ;1\\;\text{correct} \end{align}$$
 
 La sequenza corretta 39542 è unica.
 
 Sulla base delle ipotesi seguenti,
 
-$$\begin{align} & 5616185650518293 ;2\\;\text{correct}\\\\ & 3847439647293047 ;1\\;\text{correct}\\\\ & 5855462940810587 ;3\\;\text{correct}\\\\ & 9742855507068353 ;3\\;\text{correct}\\\\ & 4296849643607543 ;3\\;\text{correct}\\\\ & 3174248439465858 ;1\\;\text{correct}\\\\ & 4513559094146117 ;2\\;\text{correct}\\\\ & 7890971548908067 ;3\\;\text{correct}\\\\ & 8157356344118483 ;1\\;\text{correct}\\\\ & 2615250744386899 ;2\\;\text{correct}\\\\ & 8690095851526254 ;3\\;\text{correct}\\\\ & 6375711915077050 ;1\\;\text{correct}\\\\ & 6913859173121360 ;1\\;\text{correct}\\\\ & 6442889055042768 ;2\\;\text{correct}\\\\ & 2321386104303845 ;0\\;\text{correct}\\\\ & 2326509471271448 ;2\\;\text{correct}\\\\ & 5251583379644322 ;2\\;\text{correct}\\\\ & 1748270476758276 ;3\\;\text{correct}\\\\ & 4895722652190306 ;1\\;\text{correct}\\\\ & 3041631117224635 ;3\\;\text{correct}\\\\ & 1841236454324589 ;3\\;\text{correct}\\\\ & 2659862637316867 ;2\\;\text{correct} \end{align}$$
+$$\begin{align}   & 5616185650518293 ;2\\;\text{correct}\\\\
+  & 3847439647293047 ;1\\;\text{correct}\\\\   & 5855462940810587 ;3\\;\text{correct}\\\\
+  & 9742855507068353 ;3\\;\text{correct}\\\\   & 4296849643607543 ;3\\;\text{correct}\\\\
+  & 3174248439465858 ;1\\;\text{correct}\\\\   & 4513559094146117 ;2\\;\text{correct}\\\\
+  & 7890971548908067 ;3\\;\text{correct}\\\\   & 8157356344118483 ;1\\;\text{correct}\\\\
+  & 2615250744386899 ;2\\;\text{correct}\\\\   & 8690095851526254 ;3\\;\text{correct}\\\\
+  & 6375711915077050 ;1\\;\text{correct}\\\\   & 6913859173121360 ;1\\;\text{correct}\\\\
+  & 6442889055042768 ;2\\;\text{correct}\\\\   & 2321386104303845 ;0\\;\text{correct}\\\\
+  & 2326509471271448 ;2\\;\text{correct}\\\\   & 5251583379644322 ;2\\;\text{correct}\\\\
+  & 1748270476758276 ;3\\;\text{correct}\\\\   & 4895722652190306 ;1\\;\text{correct}\\\\
+  & 3041631117224635 ;3\\;\text{correct}\\\\   & 1841236454324589 ;3\\;\text{correct}\\\\
+  & 2659862637316867 ;2\\;\text{correct} \end{align}$$
 
 Trova la sequenza segreta unica a 16 cifre.
 
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-196-prime-triplets.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-196-prime-triplets.md
index 027e5cbf46..b064281327 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-196-prime-triplets.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-196-prime-triplets.md
@@ -10,7 +10,13 @@ dashedName: problem-196-prime-triplets
 
 Costruisci un triangolo da tutti gli interi positivi nel modo seguente:
 
-$$\begin{array}{rrr} &  1 \\\\ &  \color{red}{2} &  \color{red}{3} \\\\ &  4 & \color{red}{5} &  6 \\\\ &  \color{red}{7} &  8 &  9 & 10 \\\\ & \color{red}{11} & 12 & \color{red}{13} & 14 & 15  \\\\ & 16 & \color{red}{17} & 18 & \color{red}{19} & 20 & 21 \\\\ & 22 & \color{red}{23} & 24 & 25 & 26 & 27 & 28 \\\\ & \color{red}{29} & 30 & \color{red}{31} & 32 & 33 & 34 & 35 & 36 \\\\ & \color{red}{37} & 38 & 39 & 40 & \color{red}{41} & 42 & \color{red}{43} & 44 & 45 \\\\ & 46 & \color{red}{47} & 48 & 49 & 50 & 51 & 52 & \color{red}{53} & 54 & 55 \\\\ & 56 & 57 & 58 & \color{red}{59} & 60 & \color{red}{61} & 62 & 63 & 64 & 65 & 66 \\\\ & \cdots \end{array}$$
+$$\begin{array}{rrr}   &  1 \\\\
+  &  \color{red}{2} &  \color{red}{3} \\\\   &  4 & \color{red}{5} &  6 \\\\
+  &  \color{red}{7} &  8 &  9 & 10 \\\\   & \color{red}{11} & 12 & \color{red}{13} & 14 & 15  \\\\
+  & 16 & \color{red}{17} & 18 & \color{red}{19} & 20 & 21 \\\\   & 22 & \color{red}{23} & 24 & 25 & 26 & 27 & 28 \\\\
+  & \color{red}{29} & 30 & \color{red}{31} & 32 & 33 & 34 & 35 & 36 \\\\   & \color{red}{37} & 38 & 39 & 40 & \color{red}{41} & 42 & \color{red}{43} & 44 & 45 \\\\
+  & 46 & \color{red}{47} & 48 & 49 & 50 & 51 & 52 & \color{red}{53} & 54 & 55 \\\\   & 56 & 57 & 58 & \color{red}{59} & 60 & \color{red}{61} & 62 & 63 & 64 & 65 & 66 \\\\
+  & \cdots \end{array}$$
 
 Ogni numero intero positivo ha fino a otto vicini nel triangolo.
 
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-2-even-fibonacci-numbers.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-2-even-fibonacci-numbers.md
index 7972ca5e59..92a62d0460 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-2-even-fibonacci-numbers.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-2-even-fibonacci-numbers.md
@@ -22,7 +22,7 @@ Considerando i termini nella sequenza di Fibonacci i cui valori non superano `n`
 assert(typeof fiboEvenSum(10) === 'number');
 ```
 
-La tua funzione dovrebbe restituire un valore `pari`.
+La tua funzione dovrebbe restituire un valore pari.
 
 ```js
 assert.equal(fiboEvenSum(10) % 2 === 0, true);
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-201-subsets-with-a-unique-sum.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-201-subsets-with-a-unique-sum.md
index c1b63b6995..bb2e34452d 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-201-subsets-with-a-unique-sum.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-201-subsets-with-a-unique-sum.md
@@ -12,7 +12,17 @@ Per qualsiasi insieme $A$ di numeri, sia $sum(A)$ la somma degli elementi di $A$
 
 Considera l'insieme $B = \\{1,3,6,8,10,11\\}$. Ci sono 20 sottoinsiemi di $B$ contenenti tre elementi, e le loro somme sono:
 
-$$\begin{align} & sum(\\{1,3,6\\}) = 10 \\\\ & sum(\\{1,3,8\\}) = 12 \\\\ & sum(\\{1,3,10\\}) = 14 \\\\ & sum(\\{1,3,11\\}) = 15 \\\\ & sum(\\{1,6,8\\}) = 15 \\\\ & sum(\\{1,6,10\\}) = 17 \\\\ & sum(\\{1,6,11\\}) = 18 \\\\ & sum(\\{1,8,10\\}) = 19 \\\\ & sum(\\{1,8,11\\}) = 20 \\\\ & sum(\\{1,10,11\\}) = 22 \\\\ & sum(\\{3,6,8\\}) = 17 \\\\ & sum(\\{3,6,10\\}) = 19 \\\\ & sum(\\{3,6,11\\}) = 20 \\\\ & sum(\\{3,8,10\\}) = 21 \\\\ & sum(\\{3,8,11\\}) = 22 \\\\ & sum(\\{3,10,11\\}) = 24 \\\\ & sum(\\{6,8,10\\}) = 24 \\\\ & sum(\\{6,8,11\\}) = 25 \\\\ & sum(\\{6,10,11\\}) = 27 \\\\ & sum(\\{8,10,11\\}) = 29 \\end{align}$$
+$$\begin{align}   & sum(\\{1,3,6\\}) = 10 \\\\
+  & sum(\\{1,3,8\\}) = 12 \\\\   & sum(\\{1,3,10\\}) = 14 \\\\
+  & sum(\\{1,3,11\\}) = 15 \\\\   & sum(\\{1,6,8\\}) = 15 \\\\
+  & sum(\\{1,6,10\\}) = 17 \\\\   & sum(\\{1,6,11\\}) = 18 \\\\
+  & sum(\\{1,8,10\\}) = 19 \\\\   & sum(\\{1,8,11\\}) = 20 \\\\
+  & sum(\\{1,10,11\\}) = 22 \\\\   & sum(\\{3,6,8\\}) = 17 \\\\
+  & sum(\\{3,6,10\\}) = 19 \\\\   & sum(\\{3,6,11\\}) = 20 \\\\
+  & sum(\\{3,8,10\\}) = 21 \\\\   & sum(\\{3,8,11\\}) = 22 \\\\
+  & sum(\\{3,10,11\\}) = 24 \\\\   & sum(\\{6,8,10\\}) = 24 \\\\
+  & sum(\\{6,8,11\\}) = 25 \\\\   & sum(\\{6,10,11\\}) = 27 \\\\
+  & sum(\\{8,10,11\\}) = 29 \\end{align}$$
 
 Alcune di queste somme si verificano più di una volta, altre sono uniche. Per un insieme $A$, sia $U(A,k)$ l'insieme di somme uniche dei sottoinsiemi di $k$ elementi di $A$, nel nostro esempio troviamo $U(B,3) = \\{10,12,14,18,21,25,27,29\\}$ e $sum(U(B,3)) = 156$.
 
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-203-squarefree-binomial-coefficients.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-203-squarefree-binomial-coefficients.md
index f220f57549..0831f13076 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-203-squarefree-binomial-coefficients.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-203-squarefree-binomial-coefficients.md
@@ -10,7 +10,11 @@ dashedName: problem-203-squarefree-binomial-coefficients
 
 I coefficienti binomiali $\displaystyle\binom{n}{k}$ possono essere disposti in forma triangolare (il triangolo di Pascal) in questo modo:
 
-$$\begin{array}{ccccccccccccccc} &   &   &   &    &    &    &  1 &    &    &    &   &   &   &   \\\\ &   &   &   &    &    &  1 &    & 1  &    &    &   &   &   &   \\\\ &   &   &   &    &  1 &    &  2 &    &  1 &    &   &   &   &   \\\\ &   &   &   &  1 &    &  3 &    &  3 &    &  1 &   &   &   &   \\\\ &   &   & 1 &    &  4 &    &  6 &    &  4 &    & 1 &   &   &   \\\\ &   & 1 &   &  5 &    & 10 &    & 10 &    &  5 &   & 1 &   &   \\\\ & 1 &   & 6 &    & 15 &    & 20 &    & 15 &    & 6 &   & 1 &   \\\\ 1 &   & 7 &   & 21 &    & 35 &    & 35 &    & 21 &   & 7 &   & 1 \\\\ &   &   &   &    &    &    & \ldots \end{array}$$
+$$\begin{array}{ccccccccccccccc}    &   &   &   &    &    &    &  1 &    &    &    &   &   &   &   \\\\
+   &   &   &   &    &    &  1 &    & 1  &    &    &   &   &   &   \\\\    &   &   &   &    &  1 &    &  2 &    &  1 &    &   &   &   &   \\\\
+   &   &   &   &  1 &    &  3 &    &  3 &    &  1 &   &   &   &   \\\\    &   &   & 1 &    &  4 &    &  6 &    &  4 &    & 1 &   &   &   \\\\
+   &   & 1 &   &  5 &    & 10 &    & 10 &    &  5 &   & 1 &   &   \\\\    & 1 &   & 6 &    & 15 &    & 20 &    & 15 &    & 6 &   & 1 &   \\\\
+ 1 &   & 7 &   & 21 &    & 35 &    & 35 &    & 21 &   & 7 &   & 1 \\\\ &   &   &   &    &    &    & \ldots \end{array}$$
 
 Si può notare che le prime otto righe del triangolo di Pascal contengono dodici numeri distinti: 1, 2, 3, 4, 5, 6, 7, 10, 15, 20, 21 e 35.
 
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-207-integer-partition-equations.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-207-integer-partition-equations.md
index 8ee2c97ed7..547cce61f1 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-207-integer-partition-equations.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-207-integer-partition-equations.md
@@ -20,7 +20,11 @@ Così $P(6) = \frac{1}{2}$.
 
 Nella tabella seguente sono elencati alcuni valori di $P(m)$
 
-$$\begin{align} & P(5) = \frac{1}{1}    \\\\ & P(10) = \frac{1}{2}   \\\\ & P(15) = \frac{2}{3}   \\\\ & P(20) = \frac{1}{2}   \\\\ & P(25) = \frac{1}{2}   \\\\ & P(30) = \frac{2}{5}   \\\\ & \ldots                \\\\ & P(180) = \frac{1}{4}  \\\\ & P(185) = \frac{3}{13} \end{align}$$
+$$\begin{align}   & P(5) = \frac{1}{1}    \\\\
+  & P(10) = \frac{1}{2}   \\\\   & P(15) = \frac{2}{3}   \\\\
+  & P(20) = \frac{1}{2}   \\\\   & P(25) = \frac{1}{2}   \\\\
+  & P(30) = \frac{2}{5}   \\\\   & \ldots                \\\\
+  & P(180) = \frac{1}{4}  \\\\ & P(185) = \frac{3}{13} \end{align}$$
 
 Trova il più piccolo $m$ per il quale $P(m) &lt; \frac{1}{12\\,345}
 
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-212-combined-volume-of-cuboids.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-212-combined-volume-of-cuboids.md
index c8385aff2b..0fe2f58edb 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-212-combined-volume-of-cuboids.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-212-combined-volume-of-cuboids.md
@@ -12,7 +12,10 @@ Un cuboid allineato all'asse, specificato dai parametri $\{ (x_0,y_0,z_0), (dx,d
 
 Sia $C_1, \ldots, C_{50000}$ una collezione di 50000 cuboidi allineati assialmente in modo che $C_n$ abbia parametri
 
-$$\begin{align} & x_0 = S_{6n - 5} \\; \text{modulo} \\; 10000    \\\\ & y_0 = S_{6n - 4} \\; \text{modulo} \\; 10000    \\\\ & z_0 = S_{6n - 3} \\; \text{modulo} \\; 10000    \\\\ & dx = 1 + (S_{6n - 2} \\; \text{modulo} \\; 399) \\\\ & dy = 1 + (S_{6n - 1} \\; \text{modulo} \\; 399) \\\\ & dz = 1 + (S_{6n} \\; \text{modulo} \\; 399)     \\\\ \end{align}$$
+$$\begin{align}   & x_0 = S_{6n - 5} \\; \text{modulo} \\; 10000    \\\\
+  & y_0 = S_{6n - 4} \\; \text{modulo} \\; 10000    \\\\   & z_0 = S_{6n - 3} \\; \text{modulo} \\; 10000    \\\\
+  & dx = 1 + (S_{6n - 2} \\; \text{modulo} \\; 399) \\\\   & dy = 1 + (S_{6n - 1} \\; \text{modulo} \\; 399) \\\\
+  & dz = 1 + (S_{6n} \\; \text{modulo} \\; 399)     \\\\ \end{align}$$
 
 dove $S_1, \ldots, S_{300000}$ provengono dal "Lagged Fibonacci Generator":
 
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-214-totient-chains.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-214-totient-chains.md
index 3ca3422cf0..4711753a68 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-214-totient-chains.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-214-totient-chains.md
@@ -12,7 +12,11 @@ Sia $φ$ la funzione toziente di Eulero, cioè per un numero naturale $n$, $φ(n
 
 Iterando $φ$, ogni numero intero positivo genera una serie decrescente di numeri che termina con 1. Ad es. se iniziamo con 5 viene generata la sequenza 5,4,2,1. Ecco un elenco di tutte le catene con lunghezza 4:
 
-$$\begin{align} 5,4,2,1 & \\\\ 7,6,2,1 & \\\\ 8,4,2,1 & \\\\ 9,6,2,1 & \\\\ 10,4,2,1 & \\\\ 12,4,2,1 & \\\\ 14,6,2,1 & \\\\ 18,6,2,1 & \end{align}$$
+$$\begin{align}    5,4,2,1 & \\\\
+   7,6,2,1 & \\\\    8,4,2,1 & \\\\
+   9,6,2,1 & \\\\   10,4,2,1 & \\\\
+  12,4,2,1 & \\\\   14,6,2,1 & \\\\
+  18,6,2,1 & \end{align}$$
 
 Solo due di queste catene iniziano con un primo, la loro somma è 12.
 
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-228-minkowski-sums.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-228-minkowski-sums.md
index 1ebdff6331..0831d12317 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-228-minkowski-sums.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-228-minkowski-sums.md
@@ -10,7 +10,8 @@ dashedName: problem-228-minkowski-sums
 
 Sia $S_n$ il poligono regolare a $n$ lati i cui vertici $v_k (k = 1, 2, \ldots, n)$ hanno coordinate:
 
-$$\begin{align} & x_k = cos(\frac{2k - 1}{n} × 180°) \\\\ & y_k = sin(\frac{2k - 1}{n} × 180°) \end{align}$$
+$$\begin{align}   & x_k = cos(\frac{2k - 1}{n} × 180°) \\\\
+  & y_k = sin(\frac{2k - 1}{n} × 180°) \end{align}$$
 
 Ogni $S_n$ è da considerarsi come una forma riempita consistente di tutti i punti sia del perimetro che dell'interno.
 
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-229-four-representations-using-squares.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-229-four-representations-using-squares.md
index d4808cd0e5..31b09f9dae 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-229-four-representations-using-squares.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-229-four-representations-using-squares.md
@@ -10,13 +10,17 @@ dashedName: problem-229-four-representations-using-squares
 
 Considera il numero 3600. È molto speciale, perché
 
-$$\begin{align} & 3600 = {48}^2 + {36}^2   \\\\ & 3600 = {20}^2 + {2×40}^2 \\\\ & 3600 = {30}^2 + {3×30}^2 \\\\ & 3600 = {45}^2 + {7×15}^2 \\\\ \end{align}$$
+$$\begin{align}   & 3600 = {48}^2 + {36}^2   \\\\
+  & 3600 = {20}^2 + {2×40}^2 \\\\   & 3600 = {30}^2 + {3×30}^2 \\\\
+  & 3600 = {45}^2 + {7×15}^2 \\\\ \end{align}$$
 
 In maniera simile troviamo che $88201 = {99}^2 + {280}^2 = {287}^2 + 2 × {54}^2 = {283}^2 + 3 × {52}^2 = {197}^2 + 7 × {84}^2$.
 
 Nel 1747, Eulero ha provato quali numeri sono rappresentabili come somma di due quadrati. Siamo interessati nel numero $n$ che ammette le rappresentazioni di tutti i seguenti quattro tipi:
 
-$$\begin{align} & n = {a_1}^2 + {b_1}^2  \\\\ & n = {a_2}^2 + 2{b_2}^2 \\\\ & n = {a_3}^2 + 3{b_3}^2 \\\\ & n = {a_7}^2 + 7{b_7}^2 \\\\ \end{align}$$
+$$\begin{align}   & n = {a_1}^2 + {b_1}^2  \\\\
+  & n = {a_2}^2 + 2{b_2}^2 \\\\   & n = {a_3}^2 + 3{b_3}^2 \\\\
+  & n = {a_7}^2 + 7{b_7}^2 \\\\ \end{align}$$
 
 dove i numeri $a_k$ e $b_k$ sono numeri interi positivi.
 
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-230-fibonacci-words.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-230-fibonacci-words.md
index d790165d8c..27bf14c866 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-230-fibonacci-words.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-230-fibonacci-words.md
@@ -18,17 +18,21 @@ Sia $A = 1\\,415\\,926\\,535$, $B = 8\\,979\\,323\\,846$. Vogliamo trovare, dici
 
 I primi termini di $F_{A,B}$ sono:
 
-$$\begin{align} & 1\\,415\\,926\\,535 \\\\ & 8\\,979\\,323\\,846 \\\\ & 14\\,159\\,265\\,358\\,979\\,323\\,846 \\\\ & 897\\,932\\,384\\,614\\,159\\,265\\,358\\,979\\,323\\,846 \\\\ & 14\\,159\\,265\\,358\\,979\\,323\\,846\\,897\\,932\\,384\\,614\\,15\color{red}{9}\\,265\\,358\\,979\\,323\\,846 \end{align}$$
+$$\begin{align}   & 1\\,415\\,926\\,535 \\\\
+  & 8\\,979\\,323\\,846 \\\\   & 14\\,159\\,265\\,358\\,979\\,323\\,846 \\\\
+  & 897\\,932\\,384\\,614\\,159\\,265\\,358\\,979\\,323\\,846 \\\\ & 14\\,159\\,265\\,358\\,979\\,323\\,846\\,897\\,932\\,384\\,614\\,15\color{red}{9}\\,265\\,358\\,979\\,323\\,846 \end{align}$$
 
 Allora $D_{A,B}(35)$ è la ${35}$-sima cifra nel qunto termine, che è 9.
 
 Ora utilizziamo per $A$ le prime 100 cifre di $π$ dietro il punto decimale:
 
-$$\begin{align} & 14\\,159\\,265\\,358\\,979\\,323\\,846\\,264\\,338\\,327\\,950\\,288\\,419\\,716\\,939\\,937\\,510 \\\\ & 58\\,209\\,749\\,445\\,923\\,078\\,164\\,062\\,862\\,089\\,986\\,280\\,348\\,253\\,421\\,170\\,679 \end{align}$$
+$$\begin{align}   & 14\\,159\\,265\\,358\\,979\\,323\\,846\\,264\\,338\\,327\\,950\\,288\\,419\\,716\\,939\\,937\\,510 \\\\
+  & 58\\,209\\,749\\,445\\,923\\,078\\,164\\,062\\,862\\,089\\,986\\,280\\,348\\,253\\,421\\,170\\,679 \end{align}$$
 
 e per $B$ le prossime cento cifre:
 
-$$\begin{align} & 82\\,148\\,086\\,513\\,282\\,306\\,647\\,093\\,844\\,609\\,550\\,582\\,231\\,725\\,359\\,408\\,128 \\\\ & 48\\,111\\,745\\,028\\,410\\,270\\,193\\,852\\,110\\,555\\,964\\,462\\,294\\,895\\,493\\,038\\,196 \end{align}$$
+$$\begin{align}   & 82\\,148\\,086\\,513\\,282\\,306\\,647\\,093\\,844\\,609\\,550\\,582\\,231\\,725\\,359\\,408\\,128 \\\\
+  & 48\\,111\\,745\\,028\\,410\\,270\\,193\\,852\\,110\\,555\\,964\\,462\\,294\\,895\\,493\\,038\\,196 \end{align}$$
 
 Trova $\sum_{n = 0, 1, \ldots, 17} {10}^n × D_{A,B}((127 + 19n) × 7^n)$.
 
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-238-infinite-string-tour.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-238-infinite-string-tour.md
index 1648a40f4d..27d088562e 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-238-infinite-string-tour.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-238-infinite-string-tour.md
@@ -10,7 +10,8 @@ dashedName: problem-238-infinite-string-tour
 
 Crea una sequenza di numeri usando il generatore pseudo-casuale di numero "Blum Blum Shub":
 
-$$ s_0 = 14025256 \\\\ s_{n + 1} = {s_n}^2 \\; mod \\; 20\\,300\\,713 $$
+$$ s_0 = 14025256 \\\\
+s_{n + 1} = {s_n}^2 \\; mod \\; 20\\,300\\,713 $$
 
 Concatena questi numeri $s_0s_1s_2\ldots$ per creare una stringa $w$ di lunghezza infinita. Quindi, $w = 14025256741014958470038053646\ldots$
 
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-240-top-dice.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-240-top-dice.md
index a743b1c08a..d9af28f663 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-240-top-dice.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-240-top-dice.md
@@ -10,7 +10,9 @@ dashedName: problem-240-top-dice
 
 Ci sono 1111 modi in cui cinque dadi a 6 facce (le facce numerate da 1 a 6) possono essere lanciati in modo che i tre più grandi sommino a 15. Alcuni esempi sono:
 
-$$\begin{align} & D_1,D_2,D_3,D_4,D_5 = 4,3,6,3,5 \\\\ & D_1,D_2,D_3,D_4,D_5 = 4,3,3,5,6 \\\\ & D_1,D_2,D_3,D_4,D_5 = 3,3,3,6,6 \\\\ & D_1,D_2,D_3,D_4,D_5 = 6,6,3,3,3 \end{align}$$
+$$\begin{align}   & D_1,D_2,D_3,D_4,D_5 = 4,3,6,3,5 \\\\
+  & D_1,D_2,D_3,D_4,D_5 = 4,3,3,5,6 \\\\   & D_1,D_2,D_3,D_4,D_5 = 3,3,3,6,6 \\\\
+  & D_1,D_2,D_3,D_4,D_5 = 6,6,3,3,3 \end{align}$$
 
 In quanti modi si possono lanciare venti dadi a 12 facce (facce numerate da 1 a 12) in modo che la somma dei dieci maggiori a 70?
 
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-244-sliders.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-244-sliders.md
index d8d8236379..37e1aeb7f5 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-244-sliders.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-244-sliders.md
@@ -16,7 +16,9 @@ Una mossa è indicata dall'iniziale maiuscolo della direzione (sinistra, destra,
 
 Per ogni percorso, il suo checksum è calcolato con (pseudocodice):
 
-$$\begin{align} & \text{checksum} = 0 \\\\ & \text{checksum} = (\text{checksum} × 243 + m_1) \\; \text{mod} \\; 100\\,000\\,007 \\\\ & \text{checksum} = (\text{checksum} × 243 + m_2) \\; \text{mod} \\; 100\\,000\\,007 \\\\ & \ldots \\\\ & \text{checksum} = (\text{checksum} × 243 + m_n) \\; \text{mod} \\; 100\\,000\\,007 \end{align}$$
+$$\begin{align}   & \text{checksum} = 0 \\\\
+  & \text{checksum} = (\text{checksum} × 243 + m_1) \\; \text{mod} \\; 100\\,000\\,007 \\\\   & \text{checksum} = (\text{checksum} × 243 + m_2) \\; \text{mod} \\; 100\\,000\\,007 \\\\
+  & \ldots \\\\ & \text{checksum} = (\text{checksum} × 243 + m_n) \\; \text{mod} \\; 100\\,000\\,007 \end{align}$$
 
 dove $m_k$ è il valore ASCII della $k^{\text{th}}$-ma lettera nella sequenza di movimento e i valori ASCII per le mosse sono:
 
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-252-convex-holes.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-252-convex-holes.md
index 07b00c6008..cbd1ba158a 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-252-convex-holes.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-252-convex-holes.md
@@ -16,7 +16,8 @@ Ad esempio, l'immagine sottostante mostra una serie di venti punti e alcuni di q
 
 Per il nostro esempio, abbiamo usato i primi 20 punti ($T_{2k − 1}$, $T_{2k}$), per $k = 1, 2, \ldots, 20$, prodotto con il generatore di numeri pseudo-casuali:
 
-$$\begin{align} S_0 & = 290\\,797 \\\\ S_{n+1} & = {S_n}^2 \\; \text{mod} \\; 50\\,515\\,093 \\\\ T_n & = (S_n \\; \text{mod} \\; 2000) − 1000 \end{align}$$
+$$\begin{align}   S_0 & = 290\\,797 \\\\
+  S_{n+1} & = {S_n}^2 \\; \text{mod} \\; 50\\,515\\,093 \\\\ T_n & = (S_n \\; \text{mod} \\; 2000) − 1000 \end{align}$$
 
 cioè (527, 144), (−488, 732), (−454, −947), …
 
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-255-rounded-square-roots.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-255-rounded-square-roots.md
index da36f27a45..03705aa9fb 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-255-rounded-square-roots.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-255-rounded-square-roots.md
@@ -28,7 +28,8 @@ Ad esempio, cerchiamo di trovare la radice-quadrata-arrotondata di $n = 4321$.
 
 $n$ ha 4 cifre, quindi $x_0 = 7 × {10}^{\frac{4-2}{2}} = 70$.
 
-$$x_1 = \left\lfloor\frac{70 + \left\lceil\frac{4321}{70}\right\rceil}{2}\right\rfloor = 66 \\\\ x_2 = \left\lfloor\frac{66 + \left\lceil\frac{4321}{66}\right\rceil}{2}\right\rfloor = 66$$
+$$x_1 = \left\lfloor\frac{70 + \left\lceil\frac{4321}{70}\right\rceil}{2}\right\rfloor = 66 \\\\
+x_2 = \left\lfloor\frac{66 + \left\lceil\frac{4321}{66}\right\rceil}{2}\right\rfloor = 66$$
 
 Dal momento che $x_2 = x_1$, ci fermiamo qui. Così, dopo solo due iterazioni, abbiamo scoperto che la radice-quadrata-arrotondata di 4321 è 66 (la vera radice quadrata è 65.7343137…).
 
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-257-angular-bisectors.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-257-angular-bisectors.md
index bef8945e89..762d6e1739 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-257-angular-bisectors.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-257-angular-bisectors.md
@@ -8,7 +8,7 @@ dashedName: problem-257-angular-bisectors
 
 # --description--
 
-Dato un triangolo con lati interi $ABC$ con lati $a ≤ b ≤ c$. ($AB = c$, $BC = a$ and $AC = b$).
+Ti viene dato un triangolo con lati interi $ABC$ con lati $a ≤ b ≤ c$ ($AB = c$, $BC = a$ e $AC = b$).
 
 Le bisettrici angolari del triangolo intersecano i lati ai punti $E$, $F$ e $G$ (vedi la figura sotto).
 
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-261-pivotal-square-sums.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-261-pivotal-square-sums.md
index a9e94a0804..a697f51b4f 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-261-pivotal-square-sums.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-261-pivotal-square-sums.md
@@ -14,7 +14,9 @@ $${(k - m)}^2 + \ldots + k^2 = {(n + 1)}^2 + \ldots + {(n + m)}^2$$
 
 Alcuni piccoli square-pivot sono
 
-$$\begin{align} & \mathbf{4}: 3^2 + \mathbf{4}^2 = 5^2 \\\\ & \mathbf{21}: {20}^2 + \mathbf{21}^2 = {29}^2 \\\\ & \mathbf{24}: {21}^2 + {22}^2 + {23}^2 + \mathbf{24}^2 = {25}^2 + {26}^2 + {27}^2 \\\\ & \mathbf{110}: {108}^2 + {109}^2 + \mathbf{110}^2 = {133}^2 + {134}^2 \\\\ \end{align}$$
+$$\begin{align}   & \mathbf{4}: 3^2 + \mathbf{4}^2 = 5^2 \\\\
+  & \mathbf{21}: {20}^2 + \mathbf{21}^2 = {29}^2 \\\\   & \mathbf{24}: {21}^2 + {22}^2 + {23}^2 + \mathbf{24}^2 = {25}^2 + {26}^2 + {27}^2 \\\\
+  & \mathbf{110}: {108}^2 + {109}^2 + \mathbf{110}^2 = {133}^2 + {134}^2 \\\\ \end{align}$$
 
 Trova la somma dei square pivot distinti $≤ {10}^{10}$.
 
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-282-the-ackermann-function.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-282-the-ackermann-function.md
index 345419ff5f..cc33d7f3f5 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-282-the-ackermann-function.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-282-the-ackermann-function.md
@@ -10,7 +10,8 @@ dashedName: problem-282-the-ackermann-function
 
 Per gli interi non negativi $m$, $n$, la funzione Ackermann $A(m, n)$ è definita come segue:
 
-$$A(m, n) = \begin{cases} n + 1                 & \text{if $m = 0$}             \\\\ A(m - 1, 1)           & \text{if $m > 0$ e $n = 0$} \\\\ A(m - 1, A(m, n - 1)) & \text{if $m > 0$ e $n > 0$} \end{cases}$$
+$$A(m, n) = \begin{cases} n + 1                 & \text{if $m = 0$}             \\\\
+A(m - 1, 1)           & \text{if $m > 0$ e $n = 0$} \\\\ A(m - 1, A(m, n - 1)) & \text{if $m > 0$ e $n > 0$} \end{cases}$$
 
 Per esempio $A(1, 0) = 2$, $A(2, 2) = 7$ e $A(3, 4) = 125$.
 
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-288-an-enormous-factorial.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-288-an-enormous-factorial.md
index 090e5e9ff7..125b6b2f71 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-288-an-enormous-factorial.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-288-an-enormous-factorial.md
@@ -10,7 +10,8 @@ dashedName: problem-288-an-enormous-factorial
 
 Per ogni numero primo $p$ il numero $N(p, q)$ è definito da $N(p,q) = \sum_{n=0}^q T_n \times p^n$ con $T_n$ generato dal seguente generatore casuale di numeri:
 
-$$\begin{align} & S_0 = 290797 \\\\ & S_{n + 1} = {S_n}^2\bmod 50\\,515\\,093 \\\\ & T_n = S_n\bmod p \end{align}$$
+$$\begin{align}   & S_0 = 290797 \\\\
+  & S_{n + 1} = {S_n}^2\bmod 50\\,515\\,093 \\\\ & T_n = S_n\bmod p \end{align}$$
 
 Sia $Nfac(p,q)$ il fattoriale di $N(p,q)$.
 
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-295-lenticular-holes.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-295-lenticular-holes.md
index 4dd6de4808..7a64a39299 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-295-lenticular-holes.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-295-lenticular-holes.md
@@ -16,7 +16,8 @@ Chiamiamo l'area convessa racchiusa da due cerchi un foro lenticolare se:
 
 Considera i cerchi:
 
-$$\begin{align} & C_0: x^2 + y^2 = 25 \\\\ & C_1: {(x + 4)}^2 + {(y - 4)}^2 = 1 \\\\ & C_2: {(x - 12)}^2 + {(y - 4)}^2 = 65 \end{align}$$
+$$\begin{align}   & C_0: x^2 + y^2 = 25 \\\\
+  & C_1: {(x + 4)}^2 + {(y - 4)}^2 = 1 \\\\ & C_2: {(x - 12)}^2 + {(y - 4)}^2 = 65 \end{align}$$
 
 I cerchi $C_0$, $C_1$ e $C_2$ sono disegnati nell'immagine sottostante.
 
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-312-cyclic-paths-on-sierpiski-graphs.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-312-cyclic-paths-on-sierpiski-graphs.md
index 152c175860..c43d8931be 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-312-cyclic-paths-on-sierpiski-graphs.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-312-cyclic-paths-on-sierpiski-graphs.md
@@ -19,7 +19,9 @@ Sia $C(n)$ il numero di cicli che passano esattamente una volta attraverso tutti
 
 Si può anche verificare che:
 
-$$\begin{align} & C(1) = C(2) = 1 \\\\ & C(5) = 71\\,328\\,803\\,586\\,048 \\\\ & C(10 000)\bmod {10}^8 = 37\\,652\\,224 \\\\ & C(10 000)\bmod {13}^8 = 617\\,720\\,485 \\\\ \end{align}$$
+$$\begin{align}   & C(1) = C(2) = 1 \\\\
+  & C(5) = 71\\,328\\,803\\,586\\,048 \\\\   & C(10 000)\bmod {10}^8 = 37\\,652\\,224 \\\\
+  & C(10 000)\bmod {13}^8 = 617\\,720\\,485 \\\\ \end{align}$$
 
 Trova $C(C(C(C(10\\,000)))\bmod {13}^8$.
 
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-318-2011-nines.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-318-2011-nines.md
index 50353654e9..aaf6b20172 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-318-2011-nines.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-318-2011-nines.md
@@ -12,7 +12,11 @@ Considera il numero reale $\sqrt{2} + \sqrt{3}$.
 
 Quando calcoliamo le potenze pari di $\sqrt{2} + \sqrt{3}$ troviamo:
 
-$$\begin{align} & {(\sqrt{2} + \sqrt{3})}^2 = 9.898979485566356\ldots \\\\ & {(\sqrt{2} + \sqrt{3})}^4 = 97.98979485566356\ldots \\\\ & {(\sqrt{2} + \sqrt{3})}^6 = 969.998969071069263\ldots \\\\ & {(\sqrt{2} + \sqrt{3})}^8 = 9601.99989585502907\ldots \\\\ & {(\sqrt{2} + \sqrt{3})}^{10} = 95049.999989479221\ldots \\\\ & {(\sqrt{2} + \sqrt{3})}^{12} = 940897.9999989371855\ldots \\\\ & {(\sqrt{2} + \sqrt{3})}^{14} = 9313929.99999989263\ldots \\\\ & {(\sqrt{2} + \sqrt{3})}^{16} = 92198401.99999998915\ldots \\\\ \end{align}$$
+$$\begin{align}   & {(\sqrt{2} + \sqrt{3})}^2 = 9.898979485566356\ldots \\\\
+  & {(\sqrt{2} + \sqrt{3})}^4 = 97.98979485566356\ldots \\\\   & {(\sqrt{2} + \sqrt{3})}^6 = 969.998969071069263\ldots \\\\
+  & {(\sqrt{2} + \sqrt{3})}^8 = 9601.99989585502907\ldots \\\\   & {(\sqrt{2} + \sqrt{3})}^{10} = 95049.999989479221\ldots \\\\
+  & {(\sqrt{2} + \sqrt{3})}^{12} = 940897.9999989371855\ldots \\\\   & {(\sqrt{2} + \sqrt{3})}^{14} = 9313929.99999989263\ldots \\\\
+  & {(\sqrt{2} + \sqrt{3})}^{16} = 92198401.99999998915\ldots \\\\ \end{align}$$
 
 Sembra che il numero di nove consecutivi all'inizio della parte frazionaria di queste potenze non diminuisca. In realtà si può dimostrare che la parte frazionaria di ${(\sqrt{2} + \sqrt{3})}^{2n}$ si avvicina 1 per $n$ di grandi dimensioni.
 
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-323-bitwise-or-operations-on-random-integers.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-323-bitwise-or-operations-on-random-integers.md
index b5edbc4190..e5972d1a3d 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-323-bitwise-or-operations-on-random-integers.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-323-bitwise-or-operations-on-random-integers.md
@@ -8,18 +8,16 @@ dashedName: problem-323-bitwise-or-operations-on-random-integers
 
 # --description--
 
-Sia $y_0, y_1, y_2, \ldots$ una sequenza di numeri interi casuali a 32 bit senza segno
+Sia $y_0, y_1, y_2, \ldots$ una successione casuale di numeri interi senza segno a 32 bit (cioè $0 ≤ y_i &lt; 2^{32}$, ogni valore altrettanto probabile).
 
-(cioè $0 ≤ y_i &lt; 2^{32}$, con ogni valore ugualmente probabile).
-
-Per la sequenza $x_i$ viene fornita la seguente ricorsione:
+Per la successione $x_i$ viene data la seguente ricorsione:
 
 - $x_0 = 0$ e
 - $x_i = x_{i - 1} \mathbf{|} y_{i - 1}$, per $i > 0$. ($\mathbf{|}$ è l'operatore bitwise-OR)
 
-Si può vedere che alla fine ci sarà un indice $N$ tale che $x_i = 2^{32} - 1$ (un bit-pattern di solo uno) per tutti $i ≥ N$.
+Si può vedere che alla fine ci sarà un indice $N$ tale che $x_i = 2^{32} - 1$ (un pattern con tutti i bit a uno) per tutti gli i $i ≥ N$.
 
-Trova il valore atteso di $N$. Dare la risposta arrotondata a 10 cifre dopo il punto decimale.
+Trova il valore atteso di $N$. Dai la tua risposta arrotondata a 10 cifre dopo il punto decimale.
 
 # --hints--
 
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-324-building-a-tower.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-324-building-a-tower.md
index b3329d8351..04fd6d803f 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-324-building-a-tower.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-324-building-a-tower.md
@@ -12,7 +12,9 @@ Sia $f(n)$ il numero di modi in cui si può riempire una torre $3×3×n$ con blo
 
 Per esempio (con $q = 100\\,000\\,007$):
 
-$$\begin{align} & f(2) = 229, \\\\ & f(4) = 117\\,805, \\\\ & f(10)\bmod q = 96\\,149\\,360, \\\\ & f({10}^3)\bmod q = 24\\,806\\,056, \\\\ & f({10}^6)\bmod q = 30\\,808\\,124. \end{align}$$
+$$\begin{align}   & f(2) = 229, \\\\
+  & f(4) = 117\\,805, \\\\   & f(10)\bmod q = 96\\,149\\,360, \\\\
+  & f({10}^3)\bmod q = 24\\,806\\,056, \\\\ & f({10}^6)\bmod q = 30\\,808\\,124. \end{align}$$
 
 Trova $f({10}^{10000})\bmod 100\\,000\\,007$.
 
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-330-eulers-number.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-330-eulers-number.md
index 3a2f38f5e5..8b7de4eaad 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-330-eulers-number.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-330-eulers-number.md
@@ -10,11 +10,13 @@ dashedName: problem-330-eulers-number
 
 Una sequenza infinita di numeri reali $a(n)$ è definita per tutti gli interi $n$ come segue:
 
-$$ a(n) = \begin{cases} 1                                                       & n < 0 \\\\ \displaystyle \sum_{i = 1}^{\infty} \frac{a(n - 1)}{i!} & n \ge 0 \end{cases} $$
+$$ a(n) = \begin{cases} 1                                                       & n < 0 \\\\
+\displaystyle \sum_{i = 1}^{\infty} \frac{a(n - 1)}{i!} & n \ge 0 \end{cases} $$
 
 Per esempio,
 
-$$\begin{align} & a(0) = \frac{1}{1!} + \frac{1}{2!} + \frac{1}{3!} + \ldots = e − 1 \\\\ & a(1) = \frac{e − 1}{1!} + \frac{1}{2!} + \frac{1}{3!} + \ldots = 2e − 3 \\\\ & a(2) = \frac{2e − 3}{1!} + \frac{e − 1}{2!} + \frac{1}{3!} + \ldots = \frac{7}{2} e − 6 \end{align}$$
+$$\begin{align}   & a(0) = \frac{1}{1!} + \frac{1}{2!} + \frac{1}{3!} + \ldots = e − 1 \\\\
+  & a(1) = \frac{e − 1}{1!} + \frac{1}{2!} + \frac{1}{3!} + \ldots = 2e − 3 \\\\ & a(2) = \frac{2e − 3}{1!} + \frac{e − 1}{2!} + \frac{1}{3!} + \ldots = \frac{7}{2} e − 6 \end{align}$$
 
 dove $e = 2.7182818\ldots$ è costante di Euler.
 
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-333-special-partitions.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-333-special-partitions.md
index 8b533c9b74..346085acdc 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-333-special-partitions.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-333-special-partitions.md
@@ -14,7 +14,8 @@ Consideriamo solo quelle partizioni dove nessuno dei termini può dividere uno d
 
 Molti interi hanno più di una partizione valida, il primo è 11 con le due partizioni seguenti.
 
-$$\begin{align} & 11 = 2 + 9 = (2^1 \times 3^0 + 2^0 \times 3^2) \\\\ & 11 = 8 + 3 = (2^3 \times 3^0 + 2^0 \times 3^1) \end{align}$$
+$$\begin{align}   & 11 = 2 + 9 = (2^1 \times 3^0 + 2^0 \times 3^2) \\\\
+  & 11 = 8 + 3 = (2^3 \times 3^0 + 2^0 \times 3^1) \end{align}$$
 
 Definiamo $P(n)$ come il numero di partizioni valide di $n$. Per esempio, $P(11) = 2$.
 
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-334-spilling-the-beans.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-334-spilling-the-beans.md
index b2b564d99d..d174ff7b30 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-334-spilling-the-beans.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-334-spilling-the-beans.md
@@ -16,7 +16,10 @@ Ad esempio, considera due ciotole adiacenti contenenti 2 e 3 fagioli rispettivam
 
 animazione di una partita con due ciotole adiacenti contenenti rispettivamente 2 e 3 fagioli:
 
-$$\begin{align} & t_0 = 123456, \\\\ & t_i = \begin{cases} \frac{t_{i - 1}}{2},               & \text{if $t_{i - 1}$ is even} \\\\ \left\lfloor\frac{t_{i - 1}}{2}\right\rfloor \oplus 926252, & \text{if $t_{i - 1}$ is odd} \end{cases} \\\\ & \qquad \text{dove$⌊x⌋$ è la funzione arrotonda verso il basso e $\oplus$ è l'operatore bitwise XOR.} \\\\ & b_i = (t_i\bmod 2^{11}) + 1. \end{align}$$
+$$\begin{align}   & t_0 = 123456, \\\\
+  & t_i = \begin{cases}          \frac{t_{i - 1}}{2},               & \text{if $t_{i - 1}$ is even} \\\\
+         \left\lfloor\frac{t_{i - 1}}{2}\right\rfloor \oplus 926252, & \text{if $t_{i - 1}$ is odd}          \end{cases} \\\\
+         & \qquad \text{dove$⌊x⌋$ è la funzione arrotonda verso il basso e $\oplus$ è l'operatore bitwise XOR.} \\\\ & b_i = (t_i\bmod 2^{11}) + 1. \end{align}$$
 
 I primi due termini dell'ultima sequenza sono $b_1 = 289$ e $b_2 = 145$. Se iniziamo con $b_1$ e $b_2$ fagioli in due ciotole adiacenti, saranno necessarie 3419100 mosse per finire la partita.
 
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-340-crazy-function.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-340-crazy-function.md
index c6e17627dc..641d1b144a 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-340-crazy-function.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-340-crazy-function.md
@@ -10,7 +10,8 @@ dashedName: problem-340-crazy-function
 
 Per gli interi fissati $a$, $b$, $c$, definire la funzione pazza $F(n)$ come segue:
 
-$$\begin{align} & F(n) = n - c \\;\text{ per ogni } n > b \\\\ & F(n) = F(a + F(a + F(a + F(a + n)))) \\;\text{ per ogni } n ≤ b. \end{align}$$
+$$\begin{align}   & F(n) = n - c \\;\text{ per ogni } n > b \\\\
+  & F(n) = F(a + F(a + F(a + F(a + n)))) \\;\text{ per ogni } n ≤ b. \end{align}$$
 
 Inoltre, definisci $S(a, b, c) = \displaystyle\sum_{n = 0}^b F(n)$.
 
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-341-golombs-self-describing-sequence.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-341-golombs-self-describing-sequence.md
index 693beaed83..1435d40e5c 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-341-golombs-self-describing-sequence.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-341-golombs-self-describing-sequence.md
@@ -10,7 +10,8 @@ dashedName: problem-341-golombs-self-describing-sequence
 
 La sequenza di auto-descrizione di Golomb ($G(n)$) è l'unica sequenza non decrescente di numeri naturali tali che $n$ appaia esattamente $G(n)$ volte nella sequenza. I valori di $G(n)$ per i primi $n$ sono
 
-$$\begin{array}{c} n    & 1 & 2 & 3 & 4 & 5 & 6 & 7 & 8 & 9 & 10 & 11 & 12 & 13 & 14 & 15 & \ldots \\\\ G(n) & 1 & 2 & 2 & 3 & 3 & 4 & 4 & 4 & 5 & 5  &  5 &  6 &  6 &  6 &  6 & \ldots \end{array}$$
+$$\begin{array}{c}   n    & 1 & 2 & 3 & 4 & 5 & 6 & 7 & 8 & 9 & 10 & 11 & 12 & 13 & 14 & 15 & \ldots \\\\
+  G(n) & 1 & 2 & 2 & 3 & 3 & 4 & 4 & 4 & 5 & 5  &  5 &  6 &  6 &  6 &  6 & \ldots \end{array}$$
 
 Ti viene dato che $G({10}^3) = 86$, $G({10}^6) = 6137$.
 
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-345-matrix-sum.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-345-matrix-sum.md
index a94d255151..55079c6c74 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-345-matrix-sum.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-345-matrix-sum.md
@@ -12,11 +12,20 @@ Definiamo la Somma di Matrice di una matrice come la somma massima di elementi d
 
 Ad esempio, la somma di matrice della matrice qui sotto è pari a $3315 ( = 863 + 383 + 343 + 959 + 767)$:
 
-$$\begin{array}{rrrrr} 7                &  53                & 183                & 439                & \color{lime}{863} \\\\ 497                & \color{lime}{383} & 563                &  79                & 973 \\\\ 287                &  63                & \color{lime}{343} & 169                & 583 \\\\ 627                & 343                & 773                & \color{lime}{959} & 943 \\\\ \color{lime}{767} & 473                & 103                & 699                & 303 \end{array}$$
+$$\begin{array}{rrrrr}     7                &  53                & 183                & 439                & \color{lime}{863} \\\\
+  497                & \color{lime}{383} & 563                &  79                & 973 \\\\   287                &  63                & \color{lime}{343} & 169                & 583 \\\\
+  627                & 343                & 773                & \color{lime}{959} & 943 \\\\ \color{lime}{767} & 473                & 103                & 699                & 303 \end{array}$$
 
 Trova la somma di matrice di:
 
-$$\\begin{array}{r} 7 &  53 & 183 & 439 & 863 & 497 & 383 & 563 &  79 & 973 & 287 &  63 & 343 & 169 & 583 \\\\ 627 & 343 & 773 & 959 & 943 & 767 & 473 & 103 & 699 & 303 & 957 & 703 & 583 & 639 & 913 \\\\ 447 & 283 & 463 &  29 &  23 & 487 & 463 & 993 & 119 & 883 & 327 & 493 & 423 & 159 & 743 \\\\ 217 & 623 &   3 & 399 & 853 & 407 & 103 & 983 &  89 & 463 & 290 & 516 & 212 & 462 & 350 \\\\ 960 & 376 & 682 & 962 & 300 & 780 & 486 & 502 & 912 & 800 & 250 & 346 & 172 & 812 & 350 \\\\ 870 & 456 & 192 & 162 & 593 & 473 & 915 &  45 & 989 & 873 & 823 & 965 & 425 & 329 & 803 \\\\ 973 & 965 & 905 & 919 & 133 & 673 & 665 & 235 & 509 & 613 & 673 & 815 & 165 & 992 & 326 \\\\ 322 & 148 & 972 & 962 & 286 & 255 & 941 & 541 & 265 & 323 & 925 & 281 & 601 &  95 & 973 \\\\ 445 & 721 &  11 & 525 & 473 &  65 & 511 & 164 & 138 & 672 &  18 & 428 & 154 & 448 & 848 \\\\ 414 & 456 & 310 & 312 & 798 & 104 & 566 & 520 & 302 & 248 & 694 & 976 & 430 & 392 & 198 \\\\ 184 & 829 & 373 & 181 & 631 & 101 & 969 & 613 & 840 & 740 & 778 & 458 & 284 & 760 & 390 \\\\ 821 & 461 & 843 & 513 &  17 & 901 & 711 & 993 & 293 & 157 & 274 &  94 & 192 & 156 & 574 \\\\ 34 & 124 &   4 & 878 & 450 & 476 & 712 & 914 & 838 & 669 & 875 & 299 & 823 & 329 & 699 \\\\ 815 & 559 & 813 & 459 & 522 & 788 & 168 & 586 & 966 & 232 & 308 & 833 & 251 & 631 & 107 \\\\ 813 & 883 & 451 & 509 & 615 &  77 & 281 & 613 & 459 & 205 & 380 & 274 & 302 &  35 & 805 \end{array}$$
+$$\\begin{array}{r}     7 &  53 & 183 & 439 & 863 & 497 & 383 & 563 &  79 & 973 & 287 &  63 & 343 & 169 & 583 \\\\
+  627 & 343 & 773 & 959 & 943 & 767 & 473 & 103 & 699 & 303 & 957 & 703 & 583 & 639 & 913 \\\\   447 & 283 & 463 &  29 &  23 & 487 & 463 & 993 & 119 & 883 & 327 & 493 & 423 & 159 & 743 \\\\
+  217 & 623 &   3 & 399 & 853 & 407 & 103 & 983 &  89 & 463 & 290 & 516 & 212 & 462 & 350 \\\\   960 & 376 & 682 & 962 & 300 & 780 & 486 & 502 & 912 & 800 & 250 & 346 & 172 & 812 & 350 \\\\
+  870 & 456 & 192 & 162 & 593 & 473 & 915 &  45 & 989 & 873 & 823 & 965 & 425 & 329 & 803 \\\\   973 & 965 & 905 & 919 & 133 & 673 & 665 & 235 & 509 & 613 & 673 & 815 & 165 & 992 & 326 \\\\
+  322 & 148 & 972 & 962 & 286 & 255 & 941 & 541 & 265 & 323 & 925 & 281 & 601 &  95 & 973 \\\\   445 & 721 &  11 & 525 & 473 &  65 & 511 & 164 & 138 & 672 &  18 & 428 & 154 & 448 & 848 \\\\
+  414 & 456 & 310 & 312 & 798 & 104 & 566 & 520 & 302 & 248 & 694 & 976 & 430 & 392 & 198 \\\\   184 & 829 & 373 & 181 & 631 & 101 & 969 & 613 & 840 & 740 & 778 & 458 & 284 & 760 & 390 \\\\
+  821 & 461 & 843 & 513 &  17 & 901 & 711 & 993 & 293 & 157 & 274 &  94 & 192 & 156 & 574 \\\\    34 & 124 &   4 & 878 & 450 & 476 & 712 & 914 & 838 & 669 & 875 & 299 & 823 & 329 & 699 \\\\
+  815 & 559 & 813 & 459 & 522 & 788 & 168 & 586 & 966 & 232 & 308 & 833 & 251 & 631 & 107 \\\\ 813 & 883 & 451 & 509 & 615 &  77 & 281 & 613 & 459 & 205 & 380 & 274 & 302 &  35 & 805 \end{array}$$
 
 # --hints--
 
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-348-sum-of-a-square-and-a-cube.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-348-sum-of-a-square-and-a-cube.md
index 75d443eac6..d88a1d0a19 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-348-sum-of-a-square-and-a-cube.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-348-sum-of-a-square-and-a-cube.md
@@ -14,7 +14,9 @@ Considera i numeri palindromici che possono essere espressi come la somma di un
 
 Ad esempio, 5229225 è un numero palindromico e può essere espresso esattamente in 4 modi diversi:
 
-$$\begin{align} & {2285}^2 + {20}^3 \\\\ & {2223}^2 + {66}^3 \\\\ & {1810}^2 + {125}^3 \\\\ & {1197}^2 + {156}^3 \end{align}$$
+$$\begin{align}   & {2285}^2 + {20}^3 \\\\
+  & {2223}^2 + {66}^3 \\\\   & {1810}^2 + {125}^3 \\\\
+  & {1197}^2 + {156}^3 \end{align}$$
 
 Trova la somma dei cinque numeri palindromi più piccoli.
 
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-350-constraining-the-least-greatest-and-the-greatest-least.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-350-constraining-the-least-greatest-and-the-greatest-least.md
index 3483721e4c..7fb5ffbcda 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-350-constraining-the-least-greatest-and-the-greatest-least.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-350-constraining-the-least-greatest-and-the-greatest-least.md
@@ -16,7 +16,9 @@ Il minimo comun divisore, o $lcm$ (dall'inglese least common multiple), di una l
 
 Sia $f(G, L, N)$ il numero di liste di dimensione $N$ con $gcd ≥ G$ e $lcm ≤ L$. Ad esempio:
 
-$$\begin{align} & f(10, 100, 1) = 91 \\\\ & f(10, 100, 2) = 327 \\\\ & f(10, 100, 3) = 1135 \\\\ & f(10, 100, 1000)\bmod {101}^4 = 3\\,286\\,053 \end{align}$$
+$$\begin{align}   & f(10, 100, 1) = 91 \\\\
+  & f(10, 100, 2) = 327 \\\\   & f(10, 100, 3) = 1135 \\\\
+  & f(10, 100, 1000)\bmod {101}^4 = 3\\,286\\,053 \end{align}$$
 
 Trova $f({10}^6, {10}^{12}, {10}^{18})\bmod {101}^4$.
 
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-358-cyclic-numbers.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-358-cyclic-numbers.md
index 1e526f8262..6098c56105 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-358-cyclic-numbers.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-358-cyclic-numbers.md
@@ -14,11 +14,16 @@ Quando è moltiplicato per 1, 2, 3, 4, ... $n$, tutti i prodotti hanno esattamen
 
 Il numero ciclico più piccolo è il numero a 6 cifre 142857:
 
-$$\begin{align} & 142857 × 1 = 142857 \\\\ & 142857 × 2 = 285714 \\\\ & 142857 × 3 = 428571 \\\\ & 142857 × 4 = 571428 \\\\ & 142857 × 5 = 714285 \\\\ & 142857 × 6 = 857142 \end{align}$$
+$$\begin{align}   & 142857 × 1 = 142857 \\\\
+  & 142857 × 2 = 285714 \\\\   & 142857 × 3 = 428571 \\\\
+  & 142857 × 4 = 571428 \\\\   & 142857 × 5 = 714285 \\\\
+  & 142857 × 6 = 857142 \end{align}$$
 
 Il successivo numero ciclico è 0588235294117647 con 16 cifre:
 
-$$\begin{align} & 0588235294117647 × 1 = 0588235294117647 \\\\ & 0588235294117647 × 2 = 1176470588235294 \\\\ & 0588235294117647 × 3 = 1764705882352941 \\\\ & \ldots \\\\ & 0588235294117647 × 16 = 9411764705882352 \end{align}$$
+$$\begin{align}   & 0588235294117647 × 1 = 0588235294117647 \\\\
+  & 0588235294117647 × 2 = 1176470588235294 \\\\   & 0588235294117647 × 3 = 1764705882352941 \\\\
+  & \ldots \\\\ & 0588235294117647 × 16 = 9411764705882352 \end{align}$$
 
 Nota che per i numeri ciclici gli zeri iniziali sono importanti.
 
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-359-hilberts-new-hotel.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-359-hilberts-new-hotel.md
index 2deee5cabb..d241cb59fb 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-359-hilberts-new-hotel.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-359-hilberts-new-hotel.md
@@ -27,7 +27,10 @@ Alla fine, ogni persona in fila ottiene una stanza nell'hotel.
 
 Sia $P(f, r)$ $n$ se la persona $n$ occupa stanza $r$ al piano $f$, e 0 se nessuna persona occupa la stanza. Ecco alcuni esempi:
 
-$$\begin{align} & P(1, 1) = 1 \\\\ & P(1, 2) = 3 \\\\ & P(2, 1) = 2 \\\\ & P(10, 20) = 440 \\\\ & P(25, 75) = 4863 \\\\ & P(99, 100) = 19454 \end{align}$$
+$$\begin{align}   & P(1, 1) = 1 \\\\
+  & P(1, 2) = 3 \\\\   & P(2, 1) = 2 \\\\
+  & P(10, 20) = 440 \\\\   & P(25, 75) = 4863 \\\\
+  & P(99, 100) = 19454 \end{align}$$
 
 Trova la somma di tutti i $P(f, r)$ per tutti i positivi $f$ e $r$ in modo tale che $f × r = 71\\,328\\,803\\,586\\,048$ e dai le ultime 8 cifre come risposta.
 
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-361-subsequence-of-thue-morse-sequence.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-361-subsequence-of-thue-morse-sequence.md
index db80599e17..f41ee79f12 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-361-subsequence-of-thue-morse-sequence.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-361-subsequence-of-thue-morse-sequence.md
@@ -20,7 +20,8 @@ Definiamo $\\{A_n\\}$ come la sequenza ordinata di interi in modo che l'espressi
 
 I primi svariati termini di $A_n$ sono dati come segue:
 
-$$\begin{array}{cr} n   & 0 & 1 & 2 & 3 & 4 & 5 & 6 & 7 &  8 &  9 & 10 & 11 & 12 & \ldots \\\\ A_n & 0 & 1 & 2 & 3 & 4 & 5 & 6 & 9 & 10 & 11 & 12 & 13 & 18 & \ldots \end{array}$$
+$$\begin{array}{cr}   n   & 0 & 1 & 2 & 3 & 4 & 5 & 6 & 7 &  8 &  9 & 10 & 11 & 12 & \ldots \\\\
+  A_n & 0 & 1 & 2 & 3 & 4 & 5 & 6 & 9 & 10 & 11 & 12 & 13 & 18 & \ldots \end{array}$$
 
 Possiamo verificare che $A_{100} = 3251$ e $A_{1000} = 80\\,852\\,364\\,498$.
 
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-368-a-kempner-like-series.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-368-a-kempner-like-series.md
index e262f93378..c36d73e570 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-368-a-kempner-like-series.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-368-a-kempner-like-series.md
@@ -16,7 +16,8 @@ Consideriamo ora un'altra serie armonica modificata omettendo dalla serie armoni
 
 Questi 20 termini omessi sono:
 
-$$\dfrac{1}{111}, \dfrac{1}{222}, \dfrac{1}{333}, \dfrac{1}{444}, \dfrac{1}{555}, \dfrac{1}{666}, \dfrac{1}{777}, \dfrac{1}{888}, \dfrac{1}{999}, \dfrac{1}{1000}, \dfrac{1}{1110}, \\\\ \dfrac{1}{1111}, \dfrac{1}{1112}, \dfrac{1}{1113}, \dfrac{1}{1114}, \dfrac{1}{1115}, \dfrac{1}{1116}, \dfrac{1}{1117}, \dfrac{1}{1118}, \dfrac{1}{1119}$$
+$$\dfrac{1}{111}, \dfrac{1}{222}, \dfrac{1}{333}, \dfrac{1}{444}, \dfrac{1}{555}, \dfrac{1}{666}, \dfrac{1}{777}, \dfrac{1}{888}, \dfrac{1}{999}, \dfrac{1}{1000}, \dfrac{1}{1110}, \\\\
+\dfrac{1}{1111}, \dfrac{1}{1112}, \dfrac{1}{1113}, \dfrac{1}{1114}, \dfrac{1}{1115}, \dfrac{1}{1116}, \dfrac{1}{1117}, \dfrac{1}{1118}, \dfrac{1}{1119}$$
 
 Anche questa serie converge.
 
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-371-licence-plates.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-371-licence-plates.md
index cc2e62c6fd..b678918fd5 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-371-licence-plates.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-371-licence-plates.md
@@ -14,7 +14,7 @@ Mentre guida per andare a lavoro Seth gioca il seguente gioco:
 
 Ogni volta che i numeri di due targhe visti nel suo viaggio si sommano a 1000, vince.
 
-Ad es. `MIC-012` e `HAN-988` è una vittoria e `RYU-500` e `SET-500` anche. (finché li vede nello stesso viaggio).
+Ad es. `MIC-012` e `HAN-988` è una vittoria, così come `RYU-500` e `SET-500` (sempre che li veda nello stesso viaggio).
 
 Trova il numero previsto di targhe che ha bisogno di vedere per una vittoria. Dai la tua risposta approssimata a 8 cifre dopo il punto decimale.
 
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-375-minimum-of-subsequences.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-375-minimum-of-subsequences.md
index d02d316962..5bf2177ded 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-375-minimum-of-subsequences.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-375-minimum-of-subsequences.md
@@ -10,7 +10,8 @@ dashedName: problem-375-minimum-of-subsequences
 
 Lascia che $S_n$ sia una sequenza intera prodotta con il seguente generatore di numeri pseudo-casuali:
 
-$$\begin{align} S_0 & = 290\\,797 \\\\ S_{n + 1} & = {S_n}^2\bmod 50\\,515\\,093 \end{align}$$
+$$\begin{align}         S_0 & = 290\\,797 \\\\
+  S_{n + 1} & = {S_n}^2\bmod 50\\,515\\,093 \end{align}$$
 
 Sia $A(i, j)$ il minimo dei numeri $S_i, S_{i + 1}, \ldots, S_j$ per $i ≤ j$. Sia $M(N) = \sum A(i, j)$ per $1 ≤ i ≤ j ≤ N$.
 
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-376-nontransitive-sets-of-dice.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-376-nontransitive-sets-of-dice.md
index 49d34bd6da..ecefdb2285 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-376-nontransitive-sets-of-dice.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-376-nontransitive-sets-of-dice.md
@@ -10,7 +10,9 @@ dashedName: problem-376-nontransitive-sets-of-dice
 
 Considera la seguente serie di dadi con pallini non standard:
 
-$$$\begin{array}{} \text{Dado A: } & 1 & 4 & 4 & 4 & 4 & 4 \\\\ \text{Dado B: } & 2 & 2 & 2 & 5 & 5 & 5 \\\\ \text{Dado C: } & 3 & 3 & 3 & 3 & 3 & 6 \\\\ \end{array}$$
+$$$\begin{array}{}   \text{Dado A: } & 1 & 4 & 4 & 4 & 4 & 4 \\\\
+  \text{Dado B: } & 2 & 2 & 2 & 5 & 5 & 5 \\\\   \text{Dado C: } & 3 & 3 & 3 & 3 & 3 & 6 \\\\
+\end{array}$$
 
 Un gioco è giocato da due giocatori scegliendo un dado a turno e lanciandolo. Il giocatore che lancia il valore più alto vince.
 
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 d2eb417af4..d1b484aa57 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
@@ -10,7 +10,9 @@ dashedName: problem-38-pandigital-multiples
 
 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}$$
+$$\begin{align}   192 × 1 = 192\\\\
+  192 × 2 = 384\\\\   192 × 3 = 576\\\\
+\end{align}$$
 
 Concatenando ogni prodotto otteniamo il pandigitale di cifre da 1 a 9, 192384576. Chiamiamo 192384576 il prodotto concatenato di 192 e (1, 2, 3).
 
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-384-rudin-shapiro-sequence.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-384-rudin-shapiro-sequence.md
index 7df6753156..cb43b37921 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-384-rudin-shapiro-sequence.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-384-rudin-shapiro-sequence.md
@@ -18,7 +18,9 @@ Considera anche la sequenza sommatoria di $b(n)$: $s(n) = \displaystyle\sum_{i =
 
 La prima coppia di valori di queste sequenze sono:
 
-$$\begin{array}{lr} n    & 0 & 1 & 2 &  3 & 4 & 5 &  6 & 7 \\\\ a(n) & 0 & 0 & 0 &  1 & 0 & 0 &  1 & 2 \\\\ b(n) & 1 & 1 & 1 & -1 & 1 & 1 & -1 & 1 \\\\ s(n) & 1 & 2 & 3 &  2 & 3 & 4 &  3 & 4 \end{array}$$
+$$\begin{array}{lr}   n    & 0 & 1 & 2 &  3 & 4 & 5 &  6 & 7 \\\\
+  a(n) & 0 & 0 & 0 &  1 & 0 & 0 &  1 & 2 \\\\   b(n) & 1 & 1 & 1 & -1 & 1 & 1 & -1 & 1 \\\\
+  s(n) & 1 & 2 & 3 &  2 & 3 & 4 &  3 & 4 \end{array}$$
 
 La sequenza $s(n)$ ha la notevole proprietà che tutti gli elementi sono positivi e ogni numero intero positivo $k$ si verifica esattamente $k$ volte.
 
@@ -28,7 +30,8 @@ Ad esempio: $g(3, 3) = 6$, $g(4, 2) = 7$ and $g(54321, 12345) = 1\\,220\\,847\\,
 
 Sia $F(n)$ la sequenza di fibonacci definita da:
 
-$$\begin{align} & F(0) = F(1) = 1 \text{ and} \\\\ & F(n) = F(n - 1) + F(n - 2) \text{ for } n > 1. \end{align}$$
+$$\begin{align}   & F(0) = F(1) = 1 \text{ and} \\\\
+  & F(n) = F(n - 1) + F(n - 2) \text{ for } n > 1. \end{align}$$
 
 Definisci $GF(t) = g(F(t), F(t - 1))$.
 
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-406-guessing-game.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-406-guessing-game.md
index 50a0b2ec35..5cdde78cb1 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-406-guessing-game.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-406-guessing-game.md
@@ -32,7 +32,9 @@ Sia $C(n, a, b)$ il costo per il peggio scenario ottenuto da una strategia ottim
 
 Ecco alcuni esempi:
 
-$$\begin{align} & C(5, 2, 3) = 5 \\\\ & C(500, \sqrt{2}, \sqrt{3}) = 13.220\\,731\\,97\ldots \\\\ & C(20\\,000, 5, 7) = 82 \\\\ & C(2\\,000\\,000, √5, √7) = 49.637\\,559\\,55\ldots \\\\ \end{align}$$
+$$\begin{align}   & C(5, 2, 3) = 5 \\\\
+  & C(500, \sqrt{2}, \sqrt{3}) = 13.220\\,731\\,97\ldots \\\\   & C(20\\,000, 5, 7) = 82 \\\\
+  & C(2\\,000\\,000, √5, √7) = 49.637\\,559\\,55\ldots \\\\ \end{align}$$
 
 Siano $F_k$ i numeri di Fibonacci: $F_k = F_{k - 1} + F_{k - 2}$ con i casi base $F_1 = F_2 = 1$.
 
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-414-kaprekar-constant.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-414-kaprekar-constant.md
index 7fcc9a5540..baf0bb5764 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-414-kaprekar-constant.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-414-kaprekar-constant.md
@@ -16,7 +16,8 @@ Questo funziona anche con numeri che hanno meno di 4 cifre se aggiungiamo al num
 
 Ad es. iniziamo con il numero 0837:
 
-$$\begin{align} & 8730 - 0378 = 8352 \\\\ & 8532 - 2358 = 6174 \end{align}$$
+$$\begin{align}   & 8730 - 0378 = 8352 \\\\
+  & 8532 - 2358 = 6174 \end{align}$$
 
 6174 è chiamata costante Kaprekar. Il processo di ordinamento e sottrazione e ripetizione fino a quando non si raggiunge lo 0 o la costante Kaprekar è chiamato la routine di Kaprekar.
 
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-417-reciprocal-cycles-ii.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-417-reciprocal-cycles-ii.md
index 85d56b4528..b02b085a9c 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-417-reciprocal-cycles-ii.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-417-reciprocal-cycles-ii.md
@@ -10,7 +10,12 @@ dashedName: problem-417-reciprocal-cycles-ii
 
 Una frazione di unità contiene 1 nel numeratore. La rappresentazione decimale delle frazioni di unità con i denominatori da 2 a 10 è indicata con:
 
-$$\begin{align} & \frac{1}{2}  = 0.5 \\\\ & \frac{1}{3}  = 0.(3) \\\\ & \frac{1}{4}  = 0.25 \\\\ & \frac{1}{5}  = 0.2 \\\\ & \frac{1}{6}  = 0.1(6) \\\\ & \frac{1}{7}  = 0.(142857) \\\\ & \frac{1}{8}  = 0.125 \\\\ & \frac{1}{9}  = 0.(1) \\\\ & \frac{1}{10} = 0.1 \\\\ \end{align}$$
+$$\begin{align}   & \frac{1}{2}  = 0.5 \\\\
+  & \frac{1}{3}  = 0.(3) \\\\   & \frac{1}{4}  = 0.25 \\\\
+  & \frac{1}{5}  = 0.2 \\\\   & \frac{1}{6}  = 0.1(6) \\\\
+  & \frac{1}{7}  = 0.(142857) \\\\   & \frac{1}{8}  = 0.125 \\\\
+  & \frac{1}{9}  = 0.(1) \\\\   & \frac{1}{10} = 0.1 \\\\
+\end{align}$$
 
 Dove $0.1(6)$ significa $0.166666\ldots$ e ha una cifra che si ripete. Si può vedere che $\frac{1}{7}$ ha 6 cifre che si ripetono.
 
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-420-2x2-positive-integer-matrix.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-420-2x2-positive-integer-matrix.md
index e9c09c8a67..3300df9015 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-420-2x2-positive-integer-matrix.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-420-2x2-positive-integer-matrix.md
@@ -12,11 +12,14 @@ Una matrice intera positiva è una matrice i cui elementi sono tutti interi posi
 
 Alcune matrici intere positive possono essere espresse come un quadrato di una matrice intera positiva in due modi diversi. Ecco un esempio:
 
-$$$\begin{pmatrix} 40 & 12 \\\\ 48 & 40 \end{pmatrix}=
+$$$\begin{pmatrix}   40 & 12 \\\\
+  48 & 40 \end{pmatrix}=
 {\start{pmatrix}
-  2 & 3 \\\\ 12 & 2 \end{pmatrix}}^2 =
+  2 & 3 \\\\
+ 12 & 2 \end{pmatrix}}^2 =
 {\start{pmatrix}
-  6 & 1 \\\\ 4 & 6 \end{pmatrix}}^2$$
+  6 & 1 \\\\
+  4 & 6 \end{pmatrix}}^2$$
 
 Definiamo $F(N)$ come il numero delle matrici intere positive 2x2 che hanno una traccia inferiore a N e che possono essere espresse come un quadrato di una matrice intera positiva in due modi diversi.
 
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-423-consecutive-die-throws.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-423-consecutive-die-throws.md
index 7dcece2046..ab62472a7a 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-423-consecutive-die-throws.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-423-consecutive-die-throws.md
@@ -14,7 +14,8 @@ Un dado a 6 lati viene lanciato $n$ volte. Sia $c$ il numero di coppie di lanci
 
 Ad esempio, se $n = 7$ e i valori dei lanci sono (1, 1, 5, 6, 6, 6, 3), allora le seguenti coppie di lanci consecutivi danno lo stesso valore:
 
-$$\begin{align} & (\underline{1}, \underline{1}, 5, 6, 6, 6, 3) \\\\ & (1, 1, 5, \underline{6}, \underline{6}, 6, 3) \\\\ & (1, 1, 5, 6, \underline{6}, \underline{6}, 3) \end{align}$$
+$$\begin{align}   & (\underline{1}, \underline{1}, 5, 6, 6, 6, 3) \\\\
+  & (1, 1, 5, \underline{6}, \underline{6}, 6, 3) \\\\ & (1, 1, 5, 6, \underline{6}, \underline{6}, 3) \end{align}$$
 
 Pertanto, $c = 3$ per (1, 1, 5, 6, 6, 6, 3).
 
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-426-box-ball-system.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-426-box-ball-system.md
index 40e649fdc1..55e261bf65 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-426-box-ball-system.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-426-box-ball-system.md
@@ -24,7 +24,8 @@ Può essere mostrato che il sistema dopo un numero sufficiente di turni evolve a
 
 Definiamo la sequenza $\\{t_i\\}$:
 
-$$\begin{align} & s_0 = 290\\,797 \\\\ & s_{k + 1} = {s_k}^2\bmod 50\\,515\\,093 \\\\ & t_k = (s_k\bmod 64) + 1 \end{align}$$
+$$\begin{align}   & s_0 = 290\\,797 \\\\
+  & s_{k + 1} = {s_k}^2\bmod 50\\,515\\,093 \\\\ & t_k = (s_k\bmod 64) + 1 \end{align}$$
 
 Iniziando dalla configurazione iniziale $(t_0, t_1, \ldots, t_{10})$, lo stato finale diventa [1, 3, 10, 24, 51, 75].
 
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-433-steps-in-euclids-algorithm.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-433-steps-in-euclids-algorithm.md
index c3eb2b6e5e..952056f59f 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-433-steps-in-euclids-algorithm.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-433-steps-in-euclids-algorithm.md
@@ -10,7 +10,8 @@ dashedName: problem-433-steps-in-euclids-algorithm
 
 Sia $E(x_0, y_0)$ il numero di passi necessari a determinare il maggiore divisore comune di $x_0$ e $y_0$ con l'algoritmo di Euclide. Più formalmente:
 
-$$$\start{align} & x_1 = y_0, y_1 = x_0\bmod y_0 \\\\ & x_n = y_{n - 1}, y_n = x_{n - 1}\bmod y_{n - 1} \end{align}$$
+$$$\start{align}   & x_1 = y_0, y_1 = x_0\bmod y_0 \\\\
+  & x_n = y_{n - 1}, y_n = x_{n - 1}\bmod y_{n - 1} \end{align}$$
 
 $E(x_0, y_0)$ è il più piccolo $n$ tale che $y_n = 0$.
 
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-437-fibonacci-primitive-roots.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-437-fibonacci-primitive-roots.md
index 825710de85..9d8d2e005b 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-437-fibonacci-primitive-roots.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-437-fibonacci-primitive-roots.md
@@ -16,7 +16,11 @@ Ma c'è di più:
 
 Se guardiamo più da vicino vediamo:
 
-$$\begin{align} & 1 + 8 = 9 \\\\ & 8 + 9 = 17 ≡ 6\bmod 11 \\\\ & 9 + 6 = 15 ≡ 4\bmod 11 \\\\ & 6 + 4 = 10 \\\\ & 4 + 10 = 14 ≡ 3\bmod 11 \\\\ & 10 + 3 = 13 ≡ 2\bmod 11 \\\\ & 3 + 2 = 5 \\\\ & 2 + 5 = 7 \\\\ & 5 + 7 = 12 ≡ 1\bmod 11. \end{align}$$
+$$\begin{align}   & 1 + 8 = 9 \\\\
+  & 8 + 9 = 17 ≡ 6\bmod 11 \\\\   & 9 + 6 = 15 ≡ 4\bmod 11 \\\\
+  & 6 + 4 = 10 \\\\   & 4 + 10 = 14 ≡ 3\bmod 11 \\\\
+  & 10 + 3 = 13 ≡ 2\bmod 11 \\\\   & 3 + 2 = 5 \\\\
+  & 2 + 5 = 7 \\\\ & 5 + 7 = 12 ≡ 1\bmod 11. \end{align}$$
 
 Quindi le potenze di 8 mod 11 sono cicliche con periodo 10, e $8^n + 8^{n + 1} ≡ 8^{n + 2} (\text{mod } 11)$. 8 è chiamata radice primitiva di Fibonacci di 11.
 
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-438-integer-part-of-polynomial-equations-solutions.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-438-integer-part-of-polynomial-equations-solutions.md
index 7d7c3b91be..5f81715c3d 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-438-integer-part-of-polynomial-equations-solutions.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-438-integer-part-of-polynomial-equations-solutions.md
@@ -19,7 +19,7 @@ Per $n = 4$, ci sono 12 $n$-ple di interi che soddisfano entrambe le condizioni.
 
 Definiamo $S(t)$ come la somma dei valori assoluti degli interi in $t$.
 
-Per $n = 4$ possiamo verificare che $\sum S(t) = 2087$ per tutte le $n$-ple t che soddisfano entrambe le condizioni.
+Per $n = 4$ possiamo verificare che $\sum S(t) = 2087$ per tutte le $n$-ple $t$ che soddisfano entrambe le condizioni.
 
 Trova $\sum S(t)$ per $n = 7$.
 
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-440-gcd-and-tiling.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-440-gcd-and-tiling.md
index 9c9c26c551..f7e77bc6c7 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-440-gcd-and-tiling.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-440-gcd-and-tiling.md
@@ -24,7 +24,8 @@ Sia $S(L)$ la tripla somma $\sum_{a, b, c} gcd(T(c^a), T(c^b)$ per $1 ≤ a, b,
 
 Per esempio:
 
-$$\begin{align} & S(2) = 10\\,444 \\\\ & S(3) = 1\\,292\\,115\\,238\\,446\\,807\\,016\\,106\\,539\\,989 \\\\ & S(4)\bmod 987\\,898\\,789 = 670\\,616\\,280. \end{align}$$
+$$\begin{align}   & S(2) = 10\\,444 \\\\
+  & S(3) = 1\\,292\\,115\\,238\\,446\\,807\\,016\\,106\\,539\\,989 \\\\ & S(4)\bmod 987\\,898\\,789 = 670\\,616\\,280. \end{align}$$
 
 Trova $S(2000)\bmod 987\\,898\\,789$.
 
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-443-gcd-sequence.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-443-gcd-sequence.md
index 0434129cfb..71b1042591 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-443-gcd-sequence.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-443-gcd-sequence.md
@@ -10,11 +10,13 @@ dashedName: problem-443-gcd-sequence
 
 Sia $g(n)$ una sequenza definita come segue:
 
-$$\begin{align} & g(4) = 13, \\\\ & g(n) = g(n-1) + gcd(n, g(n - 1)) \text{ for } n > 4. \end{align}$$
+$$\begin{align}   & g(4) = 13, \\\\
+  & g(n) = g(n-1) + gcd(n, g(n - 1)) \text{ for } n > 4. \end{align}$$
 
 I primi valori sono:
 
-$$\begin{array}{l} n    & 4  & 5  & 6  & 7  & 8  & 9  & 10 & 11 & 12 & 13 & 14 & 15 & 16 & 17 & 18 & 19 & 20 & \ldots \\\\ g(n) & 13 & 14 & 16 & 17 & 18 & 27 & 28 & 29 & 30 & 31 & 32 & 33 & 34 & 51 & 54 & 55 & 60 & \ldots \end{array}$$
+$$\begin{array}{l}   n    & 4  & 5  & 6  & 7  & 8  & 9  & 10 & 11 & 12 & 13 & 14 & 15 & 16 & 17 & 18 & 19 & 20 & \ldots \\\\
+  g(n) & 13 & 14 & 16 & 17 & 18 & 27 & 28 & 29 & 30 & 31 & 32 & 33 & 34 & 51 & 54 & 55 & 60 & \ldots \end{array}$$
 
 Ti viene dato che $g(1\\,000) = 2\\,524$ and $g(1\\,000\\,000) = 2\\,624\\,152$.
 
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-450-hypocycloid-and-lattice-points.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-450-hypocycloid-and-lattice-points.md
index ee85b3d7d6..df4eedafd6 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-450-hypocycloid-and-lattice-points.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-450-hypocycloid-and-lattice-points.md
@@ -24,9 +24,10 @@ Sia $T(N) = \sum_{R = 3}^N \sum_{r=1}^{\left\lfloor \frac{R - 1}{2} \right\rfloo
 
 Ti è dato che:
 
-$$\begin{align} C(3, 1) = & \\{(3, 0), (-1, 2), (-1,0), (-1,-2)\\} \\\\ C(2500, 1000) = & \\{(2500, 0), (772, 2376), (772, -2376), (516, 1792), (516, -1792), (500, 0), (68, 504), \\\\ &(68, -504),(-1356, 1088), (-1356, -1088), (-1500, 1000), (-1500, -1000)\\} \end{align}$$
+$$\begin{align}   C(3, 1) = & \\{(3, 0), (-1, 2), (-1,0), (-1,-2)\\} \\\\
+  C(2500, 1000) = & \\{(2500, 0), (772, 2376), (772, -2376), (516, 1792), (516, -1792), (500, 0), (68, 504), \\\\ &(68, -504),(-1356, 1088), (-1356, -1088), (-1500, 1000), (-1500, -1000)\\} \end{align}$$
 
-**Nota:** (-625, 0) non è un elemento di $C(2500, 1000)$ perché $\sin(t)$ non è un numero razionale per i valori corrispondenti di t.
+**Nota:**(-625, 0) non è un elemento di $C(2500, 1000)$ perchè $\sin(t)$ non è un numero razionale per i corrispondenti valori di $t$.
 
 $S(3, 1) = (|3| + |0|) + (|-1| + |2|) + (|-1| + |0|) + (|-1| + |-2|) = 10$
 
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-451-modular-inverses.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-451-modular-inverses.md
index a5bba84576..ea2565bf05 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-451-modular-inverses.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-451-modular-inverses.md
@@ -14,7 +14,10 @@ Ci sono 8 numeri positivi sotto il 14 che sono coprimi di 15: 1, 2, 4, 7, 8, 11,
 
 I modulari inversi di questi numeri modulo 15 sono: 1, 8, 4, 13, 2, 11, 7, 14 perché
 
-$$\begin{align} & 1  \times 1\bmod 15 = 1 \\\\ & 2  \times 8  = 16\bmod 15 = 1 \\\\ & 4  \times 4  = 16\bmod 15 = 1 \\\\ & 7  \times 13 = 91\bmod 15 = 1 \\\\ & 11 \times 11 = 121\bmod 15 = 1 \\\\ & 14 \times 14 = 196\bmod 15 = 1 \end{align}$$
+$$\begin{align}   & 1  \times 1\bmod 15 = 1 \\\\
+  & 2  \times 8  = 16\bmod 15 = 1 \\\\   & 4  \times 4  = 16\bmod 15 = 1 \\\\
+  & 7  \times 13 = 91\bmod 15 = 1 \\\\   & 11 \times 11 = 121\bmod 15 = 1 \\\\
+  & 14 \times 14 = 196\bmod 15 = 1 \end{align}$$
 
 Sia $I(n)$ il più grande numero positivo $m$ più piccolo di $n - 1$ tale che l'inverso modulare di $m$ modulo $n$ sia uguale a $m$ stesso.
 
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-455-powers-with-trailing-digits.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-455-powers-with-trailing-digits.md
index 4b31dc40ee..ffdbe176d3 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-455-powers-with-trailing-digits.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-455-powers-with-trailing-digits.md
@@ -12,7 +12,9 @@ Sia $f(n)$ il più grande numero intero positivo $x$ minore di ${10}^9$ tale che
 
 Ad esempio:
 
-$$\begin{align} & f(4) = 411\\,728\\,896 (4^{411\\,728\\,896} = ...490\underline{411728896}) \\\\ & f(10) = 0 \\\\ & f(157) = 743\\,757 (157^{743\\,757} = ...567\underline{000743757}) \\\\ & Σf(n), 2 ≤ n ≤ 103 = 442\\,530\\,011\\,399 \end{align}$$
+$$\begin{align}   & f(4) = 411\\,728\\,896 (4^{411\\,728\\,896} = ...490\underline{411728896}) \\\\
+  & f(10) = 0 \\\\   & f(157) = 743\\,757 (157^{743\\,757} = ...567\underline{000743757}) \\\\
+  & Σf(n), 2 ≤ n ≤ 103 = 442\\,530\\,011\\,399 \end{align}$$
 
 Trova $\sum f(n)$, $2 ≤ n ≤ {10}^6$.
 
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-456-triangles-containing-the-origin-ii.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-456-triangles-containing-the-origin-ii.md
index 6a5739927f..cd36be4a3b 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-456-triangles-containing-the-origin-ii.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-456-triangles-containing-the-origin-ii.md
@@ -10,7 +10,8 @@ dashedName: problem-456-triangles-containing-the-origin-ii
 
 Definisci:
 
-$$\begin{align} & x_n = ({1248}^n\bmod 32323) - 16161 \\\\ & y_n = ({8421}^n\bmod 30103) - 15051 \\\\ & P_n = \\{(x_1, y_1), (x_2, y_2), \ldots, (x_n, y_n)\\} \end{align}$$
+$$\begin{align}   & x_n = ({1248}^n\bmod 32323) - 16161 \\\\
+  & y_n = ({8421}^n\bmod 30103) - 15051 \\\\ & P_n = \\{(x_1, y_1), (x_2, y_2), \ldots, (x_n, y_n)\\} \end{align}$$
 
 Per esempio, $$P_8 = \\{(-14913, -6630), (-10161, 5625), (5226, 11896), (8340, -10778), (15852, -5203), (-15165, 11295), (-1427, -14495), (12407, 1060)\\}$$
 
@@ -18,7 +19,8 @@ Sia $C(n)$ il numero di triangoli i cui vertici sono in $P_n$ che contiene l'ori
 
 Esempi:
 
-$$\begin{align} & C(8) = 20 \\\\ & C(600) = 8\\,950\\,634 \\\\ & C(40\\,000) = 2\\,666\\,610\\,948\\,988 \end{align}$$
+$$\begin{align}   & C(8) = 20 \\\\
+  & C(600) = 8\\,950\\,634 \\\\ & C(40\\,000) = 2\\,666\\,610\\,948\\,988 \end{align}$$
 
 Trova $C(2\\,000\\,000)$.
 
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-463-a-weird-recurrence-relation.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-463-a-weird-recurrence-relation.md
index b8cf195f14..29d0c95f75 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-463-a-weird-recurrence-relation.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-463-a-weird-recurrence-relation.md
@@ -10,7 +10,9 @@ dashedName: problem-463-a-weird-recurrence-relation
 
 La funzione $f$ è definita per tutti i numeri interi positivi come segue:
 
-$$\begin{align} & f(1) = 1 \\\\ & f(3) = 3 \\\\ & f(2n) = f(n) \\\\ & f(4n + 1) = 2f(2n + 1) - f(n) \\\\ & f(4n + 3) = 3f(2n + 1) - 2f(n) \end{align}$$
+$$\begin{align}   & f(1) = 1 \\\\
+  & f(3) = 3 \\\\   & f(2n) = f(n) \\\\
+  & f(4n + 1) = 2f(2n + 1) - f(n) \\\\ & f(4n + 3) = 3f(2n + 1) - 2f(n) \end{align}$$
 
 La funzione $S(n)$ è definita come $\sum_{i=1}^{n} f(i)$.
 
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-466-distinct-terms-in-a-multiplication-table.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-466-distinct-terms-in-a-multiplication-table.md
index c4e95fd6f8..10e394bd8d 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-466-distinct-terms-in-a-multiplication-table.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-466-distinct-terms-in-a-multiplication-table.md
@@ -12,13 +12,17 @@ Sia $P(m,n)$ il numero di termini distinti in una tabella di moltiplicazione $m
 
 Ad esempio, una tabella di moltiplicazione 3×4 assomiglia a questa:
 
-$$\begin{array}{c} ×          & \mathbf{1} & \mathbf{2} & \mathbf{3} & \mathbf{4}  \\\\ \mathbf{1} & 1          & 2          & 3          & 4  \\\\ \mathbf{2} & 2          & 4          & 6          & 8  \\\\ \mathbf{3} & 3          & 6          & 9          & 12 \end{array}$$
+$$\begin{array}{c}   ×          & \mathbf{1} & \mathbf{2} & \mathbf{3} & \mathbf{4}  \\\\
+  \mathbf{1} & 1          & 2          & 3          & 4  \\\\   \mathbf{2} & 2          & 4          & 6          & 8  \\\\
+  \mathbf{3} & 3          & 6          & 9          & 12 \end{array}$$
 
 Ci sono 8 termini distinti {1, 2, 3, 4, 6, 8, 9, 12}, quindi $P(3, 4) = 8$.
 
 Ti è dato che:
 
-$$\begin{align} & P(64, 64) = 1\\,263, \\\\ & P(12, 345) = 1\\,998, \text{ and} \\\\ & P(32, {10}^{15}) = 13\\,826\\,382\\,602\\,124\\,302. \\\\ \end{align}$$
+$$\begin{align}   & P(64, 64) = 1\\,263, \\\\
+  & P(12, 345) = 1\\,998, \text{ and} \\\\   & P(32, {10}^{15}) = 13\\,826\\,382\\,602\\,124\\,302. \\\\
+\end{align}$$
 
 Trova $P(64, {10}^{16})$.
 
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-467-superinteger.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-467-superinteger.md
index 68c5d087c7..f74183219f 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-467-superinteger.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-467-superinteger.md
@@ -14,15 +14,18 @@ Ad esempio, 2718281828 è un superintero di 18828, mentre 314159 non è un super
 
 Sia $p(n) l'$n$° numero primo, e sia $c(n)$ l'$n$° numero composto. Per esempio, $p(1) = 2$, $p(10) = 29$, $c(1) = 4$ e $c(10) = 18$.
 
-$$\begin{align} & \\{p(i) : i ≥ 1\\} = \\{2, 3, 5, 7, 11, 13, 17, 19, 23, 29, \ldots \\} \\\\ & \\{c(i) : i ≥ 1\\} = \\{4, 6, 8, 9, 10, 12, 14, 15, 16, 18, \ldots \\} \end{align}$$
+$$\begin{align}   & \\{p(i) : i ≥ 1\\} = \\{2, 3, 5, 7, 11, 13, 17, 19, 23, 29, \ldots \\} \\\\
+  & \\{c(i) : i ≥ 1\\} = \\{4, 6, 8, 9, 10, 12, 14, 15, 16, 18, \ldots \\} \end{align}$$
 
 Sia $P^D$ la sequenza delle radici digitali di $\\{p(i)\\}$ ($C^D$ è definita in modo simile per $\\{c(i)\\}$):
 
-$$\begin{align} & P^D = \\{2, 3, 5, 7, 2, 4, 8, 1, 5, 2, \ldots \\} \\\\ & C^D = \\{4, 6, 8, 9, 1, 3, 5, 6, 7, 9, \ldots \\} \end{align}$$
+$$\begin{align}   & P^D = \\{2, 3, 5, 7, 2, 4, 8, 1, 5, 2, \ldots \\} \\\\
+  & C^D = \\{4, 6, 8, 9, 1, 3, 5, 6, 7, 9, \ldots \\} \end{align}$$
 
 Sia $P_n$ il numero intero formato concatenando i primi $n$ elementi di $P^D$ ($C_n$ è definito allo stesso modo per $C^D$).
 
-$$\begin{align} & P_{10} = 2\\,357\\,248\\,152 \\\\ & C_{10} = 4\\,689\\,135\\,679 \end{align}$$
+$$\begin{align}   & P_{10} = 2\\,357\\,248\\,152 \\\\
+  & C_{10} = 4\\,689\\,135\\,679 \end{align}$$
 
 Sia $f(n)$ il più piccolo intero positivo che è un superintero comune di $P_n$ e $C_n$. Per esempio, $f(10) = 2\\,357\\,246\\,891\\,352\\,679$, and $f(100)\bmod 1\\,000\\,000\\,007 = 771\\,661\\,825$.
 
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-468-smooth-divisors-of-binomial-coefficients.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-468-smooth-divisors-of-binomial-coefficients.md
index e03faaa567..85ef9f80be 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-468-smooth-divisors-of-binomial-coefficients.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-468-smooth-divisors-of-binomial-coefficients.md
@@ -14,13 +14,15 @@ Sia $SB(n)$ il divisore B-smooth più grande di $n$.
 
 Esempi:
 
-$$\begin{align} & S_1(10) = 1 \\\\ & S_4(2\\,100) = 12 \\\\ & S_{17}(2\\,496\\,144) = 5\\,712 \end{align}$$
+$$\begin{align}   & S_1(10) = 1 \\\\
+  & S_4(2\\,100) = 12 \\\\ & S_{17}(2\\,496\\,144) = 5\\,712 \end{align}$$
 
 Definisci $F(n) = \displaystyle\sum_{B = 1}^n \sum_{r = 0}^n S_B(\displaystyle\binom{n}{r})$. Qui, $\displaystyle\binom{n}{r}$ denota il coefficiente binomiale.
 
 Esempi:
 
-$$\begin{align} & F(11) = 3132 \\\\ & F(1\\,111)\bmod 1\\,000\\,000\\,993 = 706\\,036\\,312 \\\\ & F(111\\,111)\bmod 1\\,000\\,000\\,993 = 22\\,156\\,169 \end{align}$$
+$$\begin{align}   & F(11) = 3132 \\\\
+  & F(1\\,111)\bmod 1\\,000\\,000\\,993 = 706\\,036\\,312 \\\\ & F(111\\,111)\bmod 1\\,000\\,000\\,993 = 22\\,156\\,169 \end{align}$$
 
 Trova $F(11\\,111\\,111)\bmod 1\\,000\\,000\\,993$.
 
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-473-phigital-number-base.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-473-phigital-number-base.md
index 7039e95f2e..29aae1ddd4 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-473-phigital-number-base.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-473-phigital-number-base.md
@@ -22,7 +22,7 @@ $2 = \varphi + \varphi^{-2}$ e $3 = \varphi^{2} + \varphi^{-2}$
 
 Per rappresentare la somma delle potenze di $\varphi$ usiamo una stringa di 0 e 1 con un punto per indicare dove gli esponenti negativi iniziano. Chiamiamo questa rappresentazione in base pi-greco.
 
-Quindi $1 = 1_{\varphi}$, $2 = 10.01_{\varphi}$, $3 = 100.01_{\varphi}$ e $14 = 100100.001001_{\varphi}$. Le stringhe rappresentanti 1, 2 e 14 nella base pi-greco sono palindromiche, mentre la stringa rappresentante 3 non lo è. (il punto non è il carattere centrale).
+Quindi $1 = 1_{\varphi}$, $2 = 10.01_{\varphi}$, $3 = 100.01_{\varphi}$ e $14 = 100100.001001_{\varphi}$. Le stringhe che rappresentano 1,2 e 14 nella base numerica phigitale sono palindrome, mentre la stringa che rappresenta 3 non lo è ( il punto phigitale non è il carattere al centro).
 
 La somma dei numeri interi che non eccedono 1000 la cui rappresentazione in base pi-greco è palindromica è 4345.
 
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-480-the-last-question.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-480-the-last-question.md
index fe28a5680c..bb887f1697 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-480-the-last-question.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-480-the-last-question.md
@@ -16,7 +16,21 @@ Supponi che quelle con 15 lettere o meno sono elencate in ordine alfabetico e nu
 
 La lista includerebbe:
 
-$$\begin{align} & 1: \text{a} \\\\ & 2: \text{aa} \\\\ & 3: \text{aaa} \\\\ & 4: \text{aaaa} \\\\ & 5: \text{aaaaa} \\\\ & 6: \text{aaaaaa} \\\\ & 7: \text{aaaaaac} \\\\ & 8: \text{aaaaaacd} \\\\ & 9: \text{aaaaaacde} \\\\ & 10: \text{aaaaaacdee} \\\\ & 11: \text{aaaaaacdeee} \\\\ & 12: \text{aaaaaacdeeee} \\\\ & 13: \text{aaaaaacdeeeee} \\\\ & 14: \text{aaaaaacdeeeeee} \\\\ & 15: \text{aaaaaacdeeeeeef} \\\\ & 16: \text{aaaaaacdeeeeeeg} \\\\ & 17: \text{aaaaaacdeeeeeeh} \\\\ & \ldots \\\\ & 28: \text{aaaaaacdeeeeeey} \\\\ & 29: \text{aaaaaacdeeeeef} \\\\ & 30: \text{aaaaaacdeeeeefe} \\\\ & \ldots \\\\ & 115246685191495242: \text{euleoywuttttsss} \\\\ & 115246685191495243: \text{euler} \\\\ & 115246685191495244: \text{eulera} \\\\ & ... \\\\ & 525069350231428029: \text{ywuuttttssssrrr} \\\\ \end{align}$$
+$$\begin{align}   & 1: \text{a} \\\\
+  & 2: \text{aa} \\\\   & 3: \text{aaa} \\\\
+  & 4: \text{aaaa} \\\\   & 5: \text{aaaaa} \\\\
+  & 6: \text{aaaaaa} \\\\   & 7: \text{aaaaaac} \\\\
+  & 8: \text{aaaaaacd} \\\\   & 9: \text{aaaaaacde} \\\\
+  & 10: \text{aaaaaacdee} \\\\   & 11: \text{aaaaaacdeee} \\\\
+  & 12: \text{aaaaaacdeeee} \\\\   & 13: \text{aaaaaacdeeeee} \\\\
+  & 14: \text{aaaaaacdeeeeee} \\\\   & 15: \text{aaaaaacdeeeeeef} \\\\
+  & 16: \text{aaaaaacdeeeeeeg} \\\\   & 17: \text{aaaaaacdeeeeeeh} \\\\
+  & \ldots \\\\   & 28: \text{aaaaaacdeeeeeey} \\\\
+  & 29: \text{aaaaaacdeeeeef} \\\\   & 30: \text{aaaaaacdeeeeefe} \\\\
+  & \ldots \\\\   & 115246685191495242: \text{euleoywuttttsss} \\\\
+  & 115246685191495243: \text{euler} \\\\   & 115246685191495244: \text{eulera} \\\\
+  & ... \\\\   & 525069350231428029: \text{ywuuttttssssrrr} \\\\
+\end{align}$$
 
 Sia $P(w)$ la posizione della parola $w$.
 
@@ -26,7 +40,9 @@ Possiamo vedere che $P(w)$ e $W(p)$ sono operazioni inverse: $P(W(p)) = p$ e $W(
 
 Esempi:
 
-$$\begin{align} & W(10) = \text{ aaaaaacdee} \\\\ & P(\text{aaaaaacdee}) = 10 \\\\ & W(115246685191495243) = \text{ euler} \\\\ & P(\text{euler}) = 115246685191495243 \\\\ \end{align}$$
+$$\begin{align}   & W(10) = \text{ aaaaaacdee} \\\\
+  & P(\text{aaaaaacdee}) = 10 \\\\   & W(115246685191495243) = \text{ euler} \\\\
+  & P(\text{euler}) = 115246685191495243 \\\\ \end{align}$$
 
 Trova $$W(P(\text{legionary}) + P(\text{calorimeters}) - P(\text{annihilate}) + P(\text{orchestrated}) - P(\text{fluttering})).$$
 
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-64-odd-period-square-roots.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-64-odd-period-square-roots.md
index da534ee57e..06fd2bdc9c 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-64-odd-period-square-roots.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-64-odd-period-square-roots.md
@@ -12,7 +12,7 @@ Tutte le radici quadrate sono periodiche quando sono scritte come frazioni conti
 
 $\\displaystyle \\quad \\quad \\sqrt{N}=a_0+\\frac 1 {a_1+\\frac 1 {a_2+ \\frac 1 {a3+ \\dots}}}$
 
-Per esempio, considera $\\sqrt{23}$:
+Per esempio, consideriamo $\\sqrt{23}$:
 
 $\\quad \\quad \\sqrt{23}=4+\\sqrt{23}-4=4+\\frac 1 {\\frac 1 {\\sqrt{23}-4}}=4+\\frac 1 {1+\\frac{\\sqrt{23}-3}7}$
 
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-74-digit-factorial-chains.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-74-digit-factorial-chains.md
index c3382c6e83..1389ae1f1f 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-74-digit-factorial-chains.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-74-digit-factorial-chains.md
@@ -14,11 +14,15 @@ $$1! + 4! + 5! = 1 + 24 + 120 = 145$$
 
 Forse meno noto è 169, in quanto produce la più lunga catena di numeri che riportano a 169; si scopre che esistono solo tre di questi loop:
 
-$$\begin{align} &169 → 363601 → 1454 → 169\\\\ &871 → 45361 → 871\\\\ &872 → 45362 → 872\\\\ \end{align}$$
+$$\begin{align} &169 → 363601 → 1454 → 169\\\\
+&871 → 45361 → 871\\\\ &872 → 45362 → 872\\\\
+\end{align}$$
 
 Non è difficile dimostrare che OGNI numero di partenza alla fine entrerà in un ciclo. Per esempio,
 
-$$\begin{align} &69 → 363600 → 1454 → 169 → 363601\\ (→ 1454)\\\\ &78 → 45360 → 871 → 45361\\ (→ 871)\\\\ &540 → 145\\ (→ 145)\\\\ \end{align}$$
+$$\begin{align} &69 → 363600 → 1454 → 169 → 363601\\ (→ 1454)\\\\
+&78 → 45360 → 871 → 45361\\ (→ 871)\\\\ &540 → 145\\ (→ 145)\\\\
+\end{align}$$
 
 Partire con 69 produce una catena di cinque termini non ripetibili, ma la più lunga catena non ripetibile con un numero iniziale inferiore a un milione è di sessanta termini.
 
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-81-path-sum-two-ways.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-81-path-sum-two-ways.md
index 3df6413bef..fd1471da19 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-81-path-sum-two-ways.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-81-path-sum-two-ways.md
@@ -10,7 +10,9 @@ dashedName: problem-81-path-sum-two-ways
 
 Nella matrice 5x5 sotto, il percorso della somma più piccola dall'angolo in alto a sinistra all'angolo in basso a destra, **muovendo solo verso destra e verso il basso**, è indicato in rosso grassetto ed è uguale a `2427`.
 
-  $$\begin{pmatrix} \color{red}{131} & 673 & 234 & 103 & 18\\\\ \color{red}{201} & \color{red}{96} & \color{red}{342} & 965 & 150\\\\ 630 & 803 & \color{red}{746} & \color{red}{422} & 111\\\\ 537 & 699 & 497 & \color{red}{121} & 956\\\\ 805 & 732 & 524 & \color{red}{37} & \color{red}{331} \end{pmatrix}$$
+  $$\begin{pmatrix}   \color{red}{131} & 673 & 234 & 103 & 18\\\\
+  \color{red}{201} & \color{red}{96} & \color{red}{342} & 965 & 150\\\\   630 & 803 & \color{red}{746} & \color{red}{422} & 111\\\\
+  537 & 699 & 497 & \color{red}{121} & 956\\\\ 805 & 732 & 524 & \color{red}{37} & \color{red}{331} \end{pmatrix}$$
 
 Trova il percorso della somma più piccola dall'angolo in alto a sinistra all'angolo in basso a destra muovendo solo verso destra e verso il basso in `matrix`, un array 2D rappresentante una matrice. La dimenzione più grande di una matrice usata nei test è 80x80.
 
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-82-path-sum-three-ways.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-82-path-sum-three-ways.md
index 696efbb388..98f5d95841 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-82-path-sum-three-ways.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-82-path-sum-three-ways.md
@@ -12,7 +12,9 @@ dashedName: problem-82-path-sum-three-ways
 
 La somma minima del percorso nella matrice 5 per 5 qui sotto, iniziando in qualsiasi cella nella colonna di sinistra e terminando in qualsiasi cella nella colonna di destra, e solo muovendosi verso l'alto, verso il basso e verso destra, è indicata in rosso e in grassetto; la somma è pari a `994`.
 
-  $$\begin{pmatrix} 131 & 673 & \color{red}{234} & \color{red}{103} & \color{red}{18}\\\\ \color{red}{201} & \color{red}{96} & \color{red}{342} & 965 & 150\\\\ 630 & 803 & 746 & 422 & 111\\\\ 537 & 699 & 497 & 121 & 956\\\\ 805 & 732 & 524 & 37 & 331 \end{pmatrix}$$
+  $$\begin{pmatrix}   131 & 673 & \color{red}{234} & \color{red}{103} & \color{red}{18}\\\\
+  \color{red}{201} & \color{red}{96} & \color{red}{342} & 965 & 150\\\\   630 & 803 & 746 & 422 & 111\\\\
+  537 & 699 & 497 & 121 & 956\\\\ 805 & 732 & 524 & 37 & 331 \end{pmatrix}$$
 
 Trova la somma del percorso minimo dalla colonna di sinistra alla colonna di destra in `matrix`, un array 2D che rappresenta una matrice. La dimensione massima della matrice utilizzata nei test sarà di 80 per 80.
 
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-83-path-sum-four-ways.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-83-path-sum-four-ways.md
index 5b81f7db7b..f2d8882207 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-83-path-sum-four-ways.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-83-path-sum-four-ways.md
@@ -12,7 +12,9 @@ dashedName: problem-83-path-sum-four-ways
 
 Nella matrice 5 x 5 sotto, il percorso della somma più piccola dall'angolo in alto a sinistra all'angolo in basso a destra, muovendo verso destra, sinistra, alto e basso, è indicato in rosso grassetto ed è uguale a `2297`.
 
-  $$\begin{pmatrix} \color{red}{131} & 673 & \color{red}{234} & \color{red}{103} & \color{red}{18}\\\\ \color{red}{201} & \color{red}{96} & \color{red}{342} & 965 & \color{red}{150}\\\\ 630 & 803 & 746 & \color{red}{422} & \color{red}{111}\\\\ 537 & 699 & 497 & \color{red}{121} & 956\\\\ 805 & 732 & 524 & \color{red}{37} & \color{red}{331} \end{pmatrix}$$
+  $$\begin{pmatrix}   \color{red}{131} & 673 & \color{red}{234} & \color{red}{103} & \color{red}{18}\\\\
+  \color{red}{201} & \color{red}{96} & \color{red}{342} & 965 & \color{red}{150}\\\\   630 & 803 & 746 & \color{red}{422} & \color{red}{111}\\\\
+  537 & 699 & 497 & \color{red}{121} & 956\\\\ 805 & 732 & 524 & \color{red}{37} & \color{red}{331} \end{pmatrix}$$
 
 Trova il percorso della somma più piccola dall'angolo in alto a sinistra all'angolo in basso a destra muovendo a sinistra, destra, alto e basso in `matrix`, un array 2D rappresentate una matrice. La dimensione massima della matrice utilizzata nei test sarà di 80 per 80.
 
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 a3e30250eb..8afdffd2ee 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
@@ -30,7 +30,7 @@ assert(typeof specialPythagoreanTriplet(24) === 'number');
 assert.strictEqual(specialPythagoreanTriplet(24), 480);
 ```
 
-`specialPythagoreanTriplet(120)` dovrebbe restituire 49920, 55080 o 60000
+`specialPythagoreanTriplet(120)` dovrebbe restituire 49920, 55080 o 60000.
 
 ```js
 assert([49920, 55080, 60000].includes(specialPythagoreanTriplet(120)));
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-92-square-digit-chains.md b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-92-square-digit-chains.md
index 07491a5994..32af66e92f 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-92-square-digit-chains.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/project-euler/problem-92-square-digit-chains.md
@@ -12,7 +12,8 @@ Una catena di numeri è creata sommando in modo continuo i quadrati delle cifre
 
 Per esempio,
 
-$$\begin{align} & 44 → 32 → 13 → 10 → \boldsymbol{1} → \boldsymbol{1}\\\\ & 85 → \boldsymbol{89} → 145 → 42 → 20 → 4 → 16 → 37 → 58 → \boldsymbol{89}\\\\ \end{align}$$
+$$\begin{align}   & 44 → 32 → 13 → 10 → \boldsymbol{1} → \boldsymbol{1}\\\\
+  & 85 → \boldsymbol{89} → 145 → 42 → 20 → 4 → 16 → 37 → 58 → \boldsymbol{89}\\\\ \end{align}$$
 
 Quindi ogni catena che arriva ad 1 o 89 si bloccherà in un loop senza fine. La cosa affascinante è che OGNI numero iniziale arriverà prima o poi a 1 o 89.