From 7c5f992f047d17a52ade2be1162b14a9cf800c0f Mon Sep 17 00:00:00 2001
From: camperbot <camperbot@users.noreply.github.com>
Date: Fri, 13 Jan 2023 23:18:11 +0530
Subject: [PATCH] chore(i18n,learn): processed translations (#49013)

---
 ...ng-the-value-of-one-variable-to-another.md |  2 +-
 .../global-scope-and-functions.md             |  2 +-
 ...-variables-with-the-assignment-operator.md |  2 +-
 .../return-early-pattern-for-functions.md     |  2 +-
 ...ndefined-value-returned-from-a-function.md |  2 +-
 .../understanding-uninitialized-variables.md  |  2 +-
 .../serve-an-html-file.md                     |  2 +-
 .../data-cleaning-with-dataframes.md          |  2 +-
 .../615f8bfe0f30a1a3c340356b.md               |  2 +-
 .../615f8bfe0f30a1a3c340356b.md               |  2 +-
 .../615f8bfe0f30a1a3c340356b.md               |  2 +-
 .../615f8bfe0f30a1a3c340356b.md               |  2 +-
 .../problem-110-diophantine-reciprocals-ii.md | 10 +++---
 .../problem-111-primes-with-runs.md           | 36 +++++++++----------
 .../problem-112-bouncy-numbers.md             |  4 +--
 .../problem-113-non-bouncy-numbers.md         |  8 ++---
 ...oblem-114-counting-block-combinations-i.md | 12 +++----
 ...blem-115-counting-block-combinations-ii.md | 18 +++++-----
 .../problem-116-red-green-or-blue-tiles.md    | 16 ++++-----
 .../problem-117-red-green-and-blue-tiles.md   | 10 +++---
 .../problem-118-pandigital-prime-sets.md      |  6 ++--
 .../problem-119-digit-power-sum.md            | 10 +++---
 .../problem-120-square-remainders.md          |  6 ++--
 .../problem-121-disc-game-prize-fund.md       | 10 +++---
 .../problem-122-efficient-exponentiation.md   | 10 +++---
 .../problem-123-prime-square-remainders.md    |  8 ++---
 .../problem-124-ordered-radicals.md           |  4 +--
 .../problem-125-palindromic-sums.md           | 14 ++++----
 .../problem-126-cuboid-layers.md              | 14 ++++----
 .../project-euler/problem-127-abc-hits.md     | 12 +++----
 .../problem-128-hexagonal-tile-differences.md | 12 +++----
 .../problem-129-repunit-divisibility.md       | 12 +++----
 ...-composites-with-prime-repunit-property.md | 12 +++----
 .../problem-131-prime-cube-partnership.md     | 10 +++---
 .../problem-132-large-repunit-factors.md      | 10 +++---
 .../problem-133-repunit-nonfactors.md         | 10 +++---
 .../problem-134-prime-pair-connection.md      | 10 +++---
 .../problem-135-same-differences.md           | 10 +++---
 .../problem-136-singleton-difference.md       | 10 +++---
 .../problem-137-fibonacci-golden-nuggets.md   | 10 +++---
 ...problem-138-special-isosceles-triangles.md | 12 +++----
 .../615f8bfe0f30a1a3c340356b.md               |  2 +-
 .../sea-level-predictor.md                    |  2 +-
 .../algorithms/implement-binary-search.md     |  6 ++--
 .../615f42a021625f656101ef93.md               |  6 ++--
 .../615f4bfb9de4a16703b56eb6.md               |  6 ++--
 .../615f4ec58334106a4170c2a8.md               |  4 +--
 .../615f4f9e4a40566b776a8f38.md               | 10 +++---
 .../615f51257a8a516d80b6c743.md               |  4 +--
 .../615f522dea4f776f64dc3e91.md               |  6 ++--
 .../615f5486b8fd4b71633f69b0.md               | 12 +++----
 .../615f5af373a68e744a3c5a76.md               |  6 ++--
 .../615f5fd85d0062761f288364.md               |  4 +--
 .../615f671b6d1919792745aa5d.md               |  8 ++---
 .../615f6b2d164f81809efd9bdc.md               | 14 ++++----
 .../615f7bc680f7168ea01ebf99.md               |  2 +-
 .../615f7e7281626a92bbd62da8.md               | 16 ++++-----
 .../615f7ecb09de9a938ef94756.md               | 18 +++++-----
 .../615f808d85793195b0f53be9.md               |  2 +-
 .../615f83ef928ec9982b785b6a.md               |  6 ++--
 .../615f89e055040ba294719d2f.md               | 10 +++---
 .../615f8bfe0f30a1a3c340356b.md               |  6 ++--
 .../635bde33c91c80540eae239b.md               |  6 ++--
 .../6395d33ab5d91bf317107c48.md               |  6 ++--
 .../6396e33fe478dd264ebbf278.md               | 10 +++---
 .../62a8b6536156c51500739b41.md               |  2 +-
 .../615f8bfe0f30a1a3c340356b.md               |  2 +-
 .../sea-level-predictor.md                    |  2 +-
 .../algorithms/implement-binary-search.md     |  6 ++--
 .../615f7ecb09de9a938ef94756.md               |  2 +-
 .../615f8bfe0f30a1a3c340356b.md               |  2 +-
 .../62a8b6536156c51500739b41.md               |  2 +-
 ...ad-only-variable-with-the-const-keyword.md | 24 ++++++-------
 .../escaping-literal-quotes-in-strings.md     | 14 ++++----
 .../introducing-else-if-statements.md         |  2 +-
 .../introducing-else-statements.md            |  2 +-
 ...terate-through-an-array-with-a-for-loop.md | 12 +++----
 ...terate-with-javascript-do...while-loops.md | 14 ++++----
 .../iterate-with-javascript-for-loops.md      | 22 ++++++------
 .../iterate-with-javascript-while-loops.md    |  8 ++---
 .../logical-order-in-if-else-statements.md    |  2 +-
 .../quoting-strings-with-single-quotes.md     |  2 +-
 .../replacing-if-else-chains-with-switch.md   |  2 +-
 .../return-early-pattern-for-functions.md     | 28 +++++++--------
 ...returning-boolean-values-from-functions.md | 16 ++++-----
 ...rom-many-options-with-switch-statements.md | 20 +++++------
 .../basic-javascript/shopping-list.md         |  6 ++--
 .../basic-javascript/stand-in-line.md         | 18 +++++-----
 ...in-one-variable-using-javascript-arrays.md | 10 +++---
 ...ing-values-with-the-assignment-operator.md | 10 +++---
 ...one-number-from-another-with-javascript.md | 12 +++----
 .../testing-objects-for-properties.md         | 10 +++---
 .../understand-string-immutability.md         | 12 +++----
 .../understanding-boolean-values.md           | 10 +++---
 ...rstanding-case-sensitivity-in-variables.md | 22 ++++++------
 ...ndefined-value-returned-from-a-function.md | 16 ++++-----
 .../understanding-uninitialized-variables.md  | 12 +++----
 .../updating-object-properties.md             | 10 +++---
 ...to-find-the-first-character-in-a-string.md | 18 +++++-----
 ...-to-find-the-last-character-in-a-string.md | 16 ++++-----
 ...n-to-find-the-nth-character-in-a-string.md | 16 ++++-----
 ...d-the-nth-to-last-character-in-a-string.md | 18 +++++-----
 ...se-conditional-logic-with-if-statements.md | 24 ++++++-------
 ...-multiple-conditional-ternary-operators.md | 14 ++++----
 .../use-recursion-to-create-a-countdown.md    | 24 ++++++-------
 ...-recursion-to-create-a-range-of-numbers.md | 16 ++++-----
 .../use-the-conditional-ternary-operator.md   | 18 +++++-----
 .../use-the-parseint-function-with-a-radix.md | 18 +++++-----
 .../use-the-parseint-function.md              | 16 ++++-----
 .../using-objects-for-lookups.md              | 12 +++----
 .../basic-javascript/word-blanks.md           | 18 +++++-----
 ...rite-reusable-javascript-with-functions.md | 14 ++++----
 ...pare-scopes-of-the-var-and-let-keywords.md | 26 +++++++-------
 .../mutate-an-array-declared-with-const.md    | 14 ++++----
 .../sea-level-predictor.md                    |  2 +-
 .../615f7ecb09de9a938ef94756.md               |  2 +-
 .../615f8bfe0f30a1a3c340356b.md               |  2 +-
 .../62a8b6536156c51500739b41.md               |  2 +-
 118 files changed, 573 insertions(+), 573 deletions(-)

diff --git a/curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/assigning-the-value-of-one-variable-to-another.md b/curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/assigning-the-value-of-one-variable-to-another.md
index cfa32f47c14..d757a010d3a 100644
--- a/curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/assigning-the-value-of-one-variable-to-another.md
+++ b/curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/assigning-the-value-of-one-variable-to-another.md
@@ -9,7 +9,7 @@ dashedName: assigning-the-value-of-one-variable-to-another
 
 # --description--
 
-بعد تعيين قيمة إلى متغير باستخدام عملية <dfn>تكليف (=)</dfn>، يمكنك تعيين قيمة هذا المتغير إلى متغير آخر باستخدام عملية <dfn>تكليف (=)</dfn> ذاتها.
+بعد تعيين قيمة إلى متغير باستخدام مشغل <dfn>التعيين (=)</dfn>، يمكنك تعيين قيمة هذا المتغير إلى متغير آخر باستخدام مشغل <dfn>التعيين (=)</dfn> ذاتها.
 
 ```js
 var myVar;
diff --git a/curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/global-scope-and-functions.md b/curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/global-scope-and-functions.md
index 922ffb963ce..69418f3333b 100644
--- a/curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/global-scope-and-functions.md
+++ b/curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/global-scope-and-functions.md
@@ -9,7 +9,7 @@ dashedName: global-scope-and-functions
 
 # --description--
 
-في JavaScript، يشير <dfn>النطاق</dfn> إلى رؤية المتغيرات. يكون إلى المتغيرات التي تم تعريفها خارج الوظيفة نطاق يسمي <dfn>شامل</dfn>. وهذا يعني أنه يمكن رؤيتها في كل مكان في التعليمات البرمجية JavaScript الخاص بك.
+في JavaScript، يشير <dfn>النطاق</dfn> إلى رؤية المتغيرات. يكون إلى المتغيرات التي تم تعريفها خارج الوظيفة مجال <dfn>شامل</dfn> (Global scope). وهذا يعني أنه يمكن رؤيتها في كل مكان في التعليمات البرمجية JavaScript الخاص بك.
 
 تعلن المتغيرات دون استخدام المصطلحات الآتية `let` أو `const` وتنشئ تلقائيًا في نطاق `global`. هذا يمكن أن يؤدي إلى عواقب غير مقصودة في مكان آخر من التعليمات البرمجية الخاص بك أو عند تشغيل الوظيفة مرة أخرى. يجب عليك دائماً إعلان متغيراتك باستخدام `let` أو `const`.
 
diff --git a/curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/initializing-variables-with-the-assignment-operator.md b/curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/initializing-variables-with-the-assignment-operator.md
index 9ddea60f7fd..6a1b80fc4f9 100644
--- a/curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/initializing-variables-with-the-assignment-operator.md
+++ b/curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/initializing-variables-with-the-assignment-operator.md
@@ -19,7 +19,7 @@ var myVar = 0;
 
 # --instructions--
 
-أعلن متغير `a` باستخدام `var` و عيّن له قيمة `9`.
+أعلن متغير `a` باستخدام `var` و هيئ له قيمة `9`.
 
 # --hints--
 
diff --git a/curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/return-early-pattern-for-functions.md b/curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/return-early-pattern-for-functions.md
index 83f0157139c..7aec83fa65f 100644
--- a/curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/return-early-pattern-for-functions.md
+++ b/curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/return-early-pattern-for-functions.md
@@ -29,7 +29,7 @@ myFun();
 عدّل الوظيفة `abTest` بحيث إذا كان `a` أو `b` أقل من `0` ستنتج الوظيفة قيمة `undefined` فوراً.
 
 **تلميح**  
-تذكر أن <a href="https://www.freecodecamp.org/learn/javascript-algorithms-and-data-structures/basic-javascript/understanding-uninitialized-variables" target="_blank" rel="noopener noreferrer nofollow">تكون <code>undefined</code> كلمة</a> وليست مقتطع.
+تذكر أن <a href="https://www.freecodecamp.org/learn/javascript-algorithms-and-data-structures/basic-javascript/understanding-uninitialized-variables" target="_blank" rel="noopener noreferrer nofollow">تكون <code>undefined</code> مصطلح </a> وليست مقطع نصي.
 
 # --hints--
 
diff --git a/curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/understanding-undefined-value-returned-from-a-function.md b/curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/understanding-undefined-value-returned-from-a-function.md
index bb19d74f0ba..76a0072edf7 100644
--- a/curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/understanding-undefined-value-returned-from-a-function.md
+++ b/curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/understanding-undefined-value-returned-from-a-function.md
@@ -23,7 +23,7 @@ function addSum(num) {
 addSum(3);
 ```
 
-تكون `addSum` وظيفة دون `return`. سيغير وظيفة المتغير `sum` العالمي الآتي, ولكن تكون القيمة المرتجعة للوظيفة `undefined`.
+تكون `addSum` وظيفة دون `return`. ستغير الوظيفة المتغير الشامل `sum`، ولكن تكون القيمة المرتجعة للوظيفة `undefined`.
 
 # --instructions--
 
diff --git a/curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/understanding-uninitialized-variables.md b/curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/understanding-uninitialized-variables.md
index acc2aeea56c..0be01c9f7ec 100644
--- a/curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/understanding-uninitialized-variables.md
+++ b/curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/understanding-uninitialized-variables.md
@@ -9,7 +9,7 @@ dashedName: understanding-uninitialized-variables
 
 # --description--
 
-عند الإعلان المتغيرات في JavaScript، يكون لها قيمة أولية وهي `undefined`. إذا قمت بعملية رياضية على متغير `undefined` ستكون نتيجتك `NaN` مما يعني <dfn>"Not a Number"</dfn> إي "ليس رقما". إذا ربط مقطع مع متغير `undefined`، فستحصل على <dfn>مقطع</dfn> بقيمة `undefined`.
+عند الإعلان المتغيرات في JavaScript، يكون لها قيمة أولية وهي `undefined`. إذا قمت بعملية رياضية على متغير `undefined` ستكون نتيجتك `NaN` مما يعني <dfn>"Not a Number"</dfn> إي "ليس رقما". إذا ربط مقطع نصي مع متغير `undefined`، فستحصل على <dfn>مقطع نصي</dfn> بقيمة `undefined`.
 
 # --instructions--
 
diff --git a/curriculum/challenges/arabic/05-back-end-development-and-apis/basic-node-and-express/serve-an-html-file.md b/curriculum/challenges/arabic/05-back-end-development-and-apis/basic-node-and-express/serve-an-html-file.md
index 1d618673227..b15f95ac820 100644
--- a/curriculum/challenges/arabic/05-back-end-development-and-apis/basic-node-and-express/serve-an-html-file.md
+++ b/curriculum/challenges/arabic/05-back-end-development-and-apis/basic-node-and-express/serve-an-html-file.md
@@ -8,7 +8,7 @@ dashedName: serve-an-html-file
 
 # --description--
 
-You can respond to requests with a file using the `res.sendFile(path)` method. You can put it inside the `app.get('/', ...)` route handler. Behind the scenes, this method will set the appropriate headers to instruct your browser on how to handle the file you want to send, according to its type. Then it will read and send the file. This method needs an absolute file path. We recommend you to use the Node global variable `__dirname` to calculate the path like this:
+You can respond to requests with a file using the `res.sendFile(path)` method. You can put it inside the `app.get('/', ...)` route handler. خلف الكواليس، ستضبط تلك الطريقة العناوين المناسبة لترشد متصفحك عن كيفية التعامل مع الملف الذي تريد إرساله، وفقًا لنوعه. Then it will read and send the file. This method needs an absolute file path. We recommend you to use the Node global variable `__dirname` to calculate the path like this:
 
 ```js
 absolutePath = __dirname + relativePath/file.ext
diff --git a/curriculum/challenges/arabic/08-data-analysis-with-python/data-analysis-with-python-course/data-cleaning-with-dataframes.md b/curriculum/challenges/arabic/08-data-analysis-with-python/data-analysis-with-python-course/data-cleaning-with-dataframes.md
index 78b2f94a467..3f009dadd5a 100644
--- a/curriculum/challenges/arabic/08-data-analysis-with-python/data-analysis-with-python-course/data-cleaning-with-dataframes.md
+++ b/curriculum/challenges/arabic/08-data-analysis-with-python/data-analysis-with-python-course/data-cleaning-with-dataframes.md
@@ -16,7 +16,7 @@ dashedName: data-cleaning-with-dataframes
 
 More resources:
 
--  <a href="https://github.com/ine-rmotr-curriculum/data-cleaning-rmotr-freecodecamp" target="_blank" rel="noopener noreferrer nofollow">Notebooks on GitHub</a>
+-  <a href="https://github.com/ine-rmotr-curriculum/data-cleaning-rmotr-freecodecamp" target="_blank" rel="noopener noreferrer nofollow">Notebooks على GitHub</a>
 -  <a href="https://colab.research.google.com/github/googlecolab/colabtools/blob/master/notebooks/colab-github-demo.ipynb" target="_blank" rel="noopener noreferrer nofollow">كيفية فتح Notebooks من GitHub باستخدام Google Colab.</a>
 
 # --question--
diff --git a/curriculum/challenges/arabic/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f8bfe0f30a1a3c340356b.md b/curriculum/challenges/arabic/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f8bfe0f30a1a3c340356b.md
index d130c35bd2c..d2b05f0b169 100644
--- a/curriculum/challenges/arabic/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f8bfe0f30a1a3c340356b.md
+++ b/curriculum/challenges/arabic/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f8bfe0f30a1a3c340356b.md
@@ -30,7 +30,7 @@ assert(document.querySelector('.daily-value.small-text')?.lastElementChild?.prev
 assert(document.querySelector('.daily-value.small-text')?.lastElementChild?.previousElementSibling?.firstElementChild?.localName === 'span');
 ```
 
-Your first `span` element not be bold.
+Your first `span` element should not be bold.
 
 ```js
 assert(!document.querySelector('.daily-value.small-text')?.lastElementChild?.previousElementSibling?.firstElementChild?.classList?.contains('bold'));
diff --git a/curriculum/challenges/chinese-traditional/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f8bfe0f30a1a3c340356b.md b/curriculum/challenges/chinese-traditional/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f8bfe0f30a1a3c340356b.md
index 934bac6f9db..7164517af6c 100644
--- a/curriculum/challenges/chinese-traditional/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f8bfe0f30a1a3c340356b.md
+++ b/curriculum/challenges/chinese-traditional/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f8bfe0f30a1a3c340356b.md
@@ -30,7 +30,7 @@ assert(document.querySelector('.daily-value.small-text')?.lastElementChild?.prev
 assert(document.querySelector('.daily-value.small-text')?.lastElementChild?.previousElementSibling?.firstElementChild?.localName === 'span');
 ```
 
-Your first `span` element not be bold.
+Your first `span` element should not be bold.
 
 ```js
 assert(!document.querySelector('.daily-value.small-text')?.lastElementChild?.previousElementSibling?.firstElementChild?.classList?.contains('bold'));
diff --git a/curriculum/challenges/chinese/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f8bfe0f30a1a3c340356b.md b/curriculum/challenges/chinese/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f8bfe0f30a1a3c340356b.md
index e5ac3718143..f898a1da1a7 100644
--- a/curriculum/challenges/chinese/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f8bfe0f30a1a3c340356b.md
+++ b/curriculum/challenges/chinese/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f8bfe0f30a1a3c340356b.md
@@ -30,7 +30,7 @@ assert(document.querySelector('.daily-value.small-text')?.lastElementChild?.prev
 assert(document.querySelector('.daily-value.small-text')?.lastElementChild?.previousElementSibling?.firstElementChild?.localName === 'span');
 ```
 
-Your first `span` element not be bold.
+Your first `span` element should not be bold.
 
 ```js
 assert(!document.querySelector('.daily-value.small-text')?.lastElementChild?.previousElementSibling?.firstElementChild?.classList?.contains('bold'));
diff --git a/curriculum/challenges/espanol/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f8bfe0f30a1a3c340356b.md b/curriculum/challenges/espanol/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f8bfe0f30a1a3c340356b.md
index ed6e05099c9..804e7068e1b 100644
--- a/curriculum/challenges/espanol/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f8bfe0f30a1a3c340356b.md
+++ b/curriculum/challenges/espanol/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f8bfe0f30a1a3c340356b.md
@@ -30,7 +30,7 @@ Su primer elemento nuevo `p` debe tener un elemento `span`.
 assert(document.querySelector('.daily-value.small-text')?.lastElementChild?.previousElementSibling?.firstElementChild?.localName === 'span');
 ```
 
-Your first `span` element not be bold.
+Your first `span` element should not be bold.
 
 ```js
 assert(!document.querySelector('.daily-value.small-text')?.lastElementChild?.previousElementSibling?.firstElementChild?.classList?.contains('bold'));
diff --git a/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-110-diophantine-reciprocals-ii.md b/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-110-diophantine-reciprocals-ii.md
index 9bbeb3dd075..f89b5f65ee0 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-110-diophantine-reciprocals-ii.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-110-diophantine-reciprocals-ii.md
@@ -1,6 +1,6 @@
 ---
 id: 5900f3db1000cf542c50feed
-title: 'Problem 110: Diophantine Reciprocals II'
+title: 'Problem 110: Diophantische Umkehrfunktionen II'
 challengeType: 1
 forumTopicId: 301735
 dashedName: problem-110-diophantine-reciprocals-ii
@@ -8,19 +8,19 @@ dashedName: problem-110-diophantine-reciprocals-ii
 
 # --description--
 
-In the following equation x, y, and n are positive integers.
+In der folgenden Gleichung sind x, y und n positive ganze Zahlen.
 
 $$\frac{1}{x} + \frac{1}{y} = \frac{1}{n}$$
 
 It can be verified that when `n` = 1260 there are 113 distinct solutions and this is the least value of `n` for which the total number of distinct solutions exceeds one hundred.
 
-What is the least value of `n` for which the number of distinct solutions exceeds four million?
+Was ist der geringste Wert von `n`, für den die Anzahl an unterschiedlichen Lösungen mehr als vier Millionen beträgt?
 
-**Note:** This problem is a much more difficult version of Problem 108 and as it is well beyond the limitations of a brute force approach it requires a clever implementation.
+**Hinweis:** Dieses Problem ist eine viel schwierigere Version des Problems 108 und, da es weit über die Grenzen der Brute-Force-Methode hinausgeht, benötigt es eine geschickte Umsetzung.
 
 # --hints--
 
-`diophantineTwo()` should return `9350130049860600`.
+`diophantineTwo()` sollte `9350130049860600` zurückgeben.
 
 ```js
 assert.strictEqual(diophantineTwo(), 9350130049860600);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-111-primes-with-runs.md b/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-111-primes-with-runs.md
index 7f22fbffb6c..ac40e33815f 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-111-primes-with-runs.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-111-primes-with-runs.md
@@ -8,34 +8,34 @@ dashedName: problem-111-primes-with-runs
 
 # --description--
 
-Considering 4-digit primes containing repeated digits it is clear that they cannot all be the same: 1111 is divisible by 11, 2222 is divisible by 22, and so on. But there are nine 4-digit primes containing three ones:
+Bei 4-stelligen Primzahlen mit wiederholten Ziffern ist klar, dass sie nicht alle gleich sein können: 1111 ist durch 11 teilbar, 2222 ist durch 22 teilbar, usw. Aber es gibt neun 4-stellige Primzahlen, die drei Einsen enthalten:
 
 $$1117, 1151, 1171, 1181, 1511, 1811, 2111, 4111, 8111$$
 
-We shall say that $M(n, d)$ represents the maximum number of repeated digits for an n-digit prime where d is the repeated digit, $N(n, d)$ represents the number of such primes, and $S(n, d)$ represents the sum of these primes.
+Wir sagen, dass $M(n, d)$ die maximale Anzahl wiederholter Ziffern für eine n-stellige Primzahl darstellt, wobei d die wiederholte Ziffer ist, $N(n, d)$ die Anzahl solcher Primzahlen, und $S(n, d)$ die Summe dieser Primzahlen.
 
-So $M(4, 1) = 3$ is the maximum number of repeated digits for a 4-digit prime where one is the repeated digit, there are $N(4, 1) = 9$ such primes, and the sum of these primes is $S(4, 1) = 22275$. It turns out that for d = 0, it is only possible to have $M(4, 0) = 2$ repeated digits, but there are $N(4, 0) = 13$ such cases.
+Also ist $M(4, 1) = 3$ die maximale Anzahl der wiederholten Ziffern für eine vierstellige Primzahl, wobei eine die wiederholte Ziffer ist, es gibt $N(4, 1) = 9$ solcher Primzahlen, und die Summe dieser Primzahlen ist $S(4, 1) = 22275$. Es stellt sich heraus, dass es für d = 0 nur $M(4, 0) = 2$ wiederholte Ziffern geben kann, aber es gibt $N(4, 0) = 13$ solcher Fälle.
 
-In the same way we obtain the following results for 4-digit primes.
+Auf die gleiche Weise erhalten wir die folgenden Ergebnisse für 4-stellige Primzahlen.
 
-| Digit, d | $M(4, d)$ | $N(4, d)$ | $S(4, d)$ |
-| -------- | --------- | --------- | --------- |
-| 0        | 2         | 13        | 67061     |
-| 1        | 3         | 9         | 22275     |
-| 2        | 3         | 1         | 2221      |
-| 3        | 3         | 12        | 46214     |
-| 4        | 3         | 2         | 8888      |
-| 5        | 3         | 1         | 5557      |
-| 6        | 3         | 1         | 6661      |
-| 7        | 3         | 9         | 57863     |
-| 8        | 3         | 1         | 8887      |
-| 9        | 3         | 7         | 48073     |
+| Ziffer, d | $M(4, d)$ | $N(4, d)$ | $S(4, d)$ |
+| --------- | --------- | --------- | --------- |
+| 0         | 2         | 13        | 67061     |
+| 1         | 3         | 9         | 22275     |
+| 2         | 3         | 1         | 2221      |
+| 3         | 3         | 12        | 46214     |
+| 4         | 3         | 2         | 8888      |
+| 5         | 3         | 1         | 5557      |
+| 6         | 3         | 1         | 6661      |
+| 7         | 3         | 9         | 57863     |
+| 8         | 3         | 1         | 8887      |
+| 9         | 3         | 7         | 48073     |
 
-For d = 0 to 9, the sum of all $S(4, d)$ is 273700. Find the sum of all $S(10, d)$.
+Für d = 0 bis 9 ist die Summe aller $S(4, d)$ 273700. Finde die Summe aller $S(10, d)$.
 
 # --hints--
 
-`primesWithRuns()` should return `612407567715`.
+`primesWithRuns()` sollte `612407567715` zurückgeben.
 
 ```js
 assert.strictEqual(primesWithRuns(), 612407567715);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-112-bouncy-numbers.md b/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-112-bouncy-numbers.md
index 7599de29978..cc88391f535 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-112-bouncy-numbers.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-112-bouncy-numbers.md
@@ -8,9 +8,9 @@ dashedName: problem-112-bouncy-numbers
 
 # --description--
 
-Working from left-to-right if no digit is exceeded by the digit to its left it is called an increasing number; for example, 134468.
+Wenn man von links nach rechts arbeitet und keine Ziffer durch die Ziffer links davon übertroffen wird, spricht man von einer aufsteigenden Zahl, zum Beispiel 134468.
 
-Similarly if no digit is exceeded by the digit to its right it is called a decreasing number; for example, 66420.
+Ähnlich verhält es sich, wenn keine Ziffer von der Ziffer rechts überschritten wird, wird es eine abnehmende Zahl genannt; zum Beispiel, 66420.
 
 We shall call a positive integer that is neither increasing nor decreasing a "bouncy" number; for example, 155349.
 
diff --git a/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-113-non-bouncy-numbers.md b/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-113-non-bouncy-numbers.md
index 868909ef6b2..472c5b9a78f 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-113-non-bouncy-numbers.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-113-non-bouncy-numbers.md
@@ -8,19 +8,19 @@ dashedName: problem-113-non-bouncy-numbers
 
 # --description--
 
-Working from left-to-right if no digit is exceeded by the digit to its left it is called an increasing number; for example, 134468.
+Wenn man von links nach rechts arbeitet und keine Ziffer durch die Ziffer links davon übertroffen wird, spricht man von einer aufsteigenden Zahl, zum Beispiel 134468.
 
-Similarly if no digit is exceeded by the digit to its right it is called a decreasing number; for example, 66420.
+Ähnlich verhält es sich, wenn keine Ziffer von der Ziffer rechts daneben übertroffen wird. Man spricht dann von einer absteigenden Zahl, zum Beispiel 66420.
 
 We shall call a positive integer that is neither increasing nor decreasing a "bouncy" number; for example, 155349.
 
 As n increases, the proportion of bouncy numbers below n increases such that there are only 12951 numbers below one-million that are not bouncy and only 277032 non-bouncy numbers below ${10}^{10}$.
 
-How many numbers below a googol (${10}^{100}$) are not bouncy?
+Wie viele Zahlen unterhalb eines Googols (${10}^{100}$) sind nicht sprunghaft?
 
 # --hints--
 
-`nonBouncyNumbers()` should return `51161058134250`.
+`nonBouncyNumbers()` sollte `51161058134250` zurückgeben.
 
 ```js
 assert.strictEqual(nonBouncyNumbers(), 51161058134250);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-114-counting-block-combinations-i.md b/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-114-counting-block-combinations-i.md
index 3e1b2f85927..51df6281e96 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-114-counting-block-combinations-i.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-114-counting-block-combinations-i.md
@@ -1,6 +1,6 @@
 ---
 id: 5900f3e01000cf542c50fef2
-title: 'Problem 114: Counting block combinations I'
+title: 'Problem 114: Zählen von Blockkombinationen I'
 challengeType: 1
 forumTopicId: 301740
 dashedName: problem-114-counting-block-combinations-i
@@ -8,17 +8,17 @@ dashedName: problem-114-counting-block-combinations-i
 
 # --description--
 
-A row measuring seven units in length has red blocks with a minimum length of three units placed on it, such that any two red blocks (which are allowed to be different lengths) are separated by at least one black square. There are exactly seventeen ways of doing this.
+Auf einer sieben Einheiten langen Reihe werden rote Blöcke mit einer Mindestlänge von drei Einheiten so platziert, dass zwei beliebige rote Blöcke (die unterschiedlich lang sein dürfen) durch mindestens ein schwarzes Quadrat getrennt sind. Es gibt genau siebzehn Möglichkeiten, dies zu tun.
 
-<img class="img-responsive center-block" alt="Possible ways of placing block with a minimum length of three units, on a row with length of seven units" src="https://cdn.freecodecamp.org/curriculum/project-euler/counting-block-combinations-i.png" style="background-color: white; padding: 10px;" />
+<img class="img-responsive center-block" alt="Möglichkeiten der Platzierung von Blöcken mit einer Mindestlänge von drei Einheiten in einer Reihe mit einer Länge von sieben Einheiten" src="https://cdn.freecodecamp.org/curriculum/project-euler/counting-block-combinations-i.png" style="background-color: white; padding: 10px;" />
 
-How many ways can a row measuring fifty units in length be filled?
+Auf wie viele Arten kann eine Reihe mit einer Länge von fünfzig Einheiten gefüllt werden?
 
-**Note:** Although the example above does not lend itself to the possibility, in general it is permitted to mix block sizes. For example, on a row measuring eight units in length you could use red (3), black (1), and red (4).
+**Hinweis:** Obwohl das obige Beispiel keine Möglichkeit bietet, ist es im Allgemeinen erlaubt, Blockgrößen zu mischen. Bei einer Reihe mit einer Länge von acht Einheiten kannst du zum Beispiel rot (3), schwarz (1) und rot (4) verwenden.
 
 # --hints--
 
-`countingBlockOne()` should return `16475640049`.
+`countingBlockOne()` sollte `16475640049` zurückgeben.
 
 ```js
 assert.strictEqual(countingBlockOne(), 16475640049);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-115-counting-block-combinations-ii.md b/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-115-counting-block-combinations-ii.md
index a659ea34ad1..1419376cee8 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-115-counting-block-combinations-ii.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-115-counting-block-combinations-ii.md
@@ -1,6 +1,6 @@
 ---
 id: 5900f3df1000cf542c50fef1
-title: 'Problem 115: Counting block combinations II'
+title: 'Problem 115: Zählen von Blockkombinationen II'
 challengeType: 1
 forumTopicId: 301741
 dashedName: problem-115-counting-block-combinations-ii
@@ -8,23 +8,23 @@ dashedName: problem-115-counting-block-combinations-ii
 
 # --description--
 
-A row measuring `n` units in length has red blocks with a minimum length of `m` units placed on it, such that any two red blocks (which are allowed to be different lengths) are separated by at least one black square.
+Auf eine Reihe mit einer Länge von `n` Einheiten werden rote Blöcke mit einer Mindestlänge von `m` Einheiten gelegt, so dass zwei rote Blöcke (die unterschiedlich lang sein dürfen) durch mindestens ein schwarzes Quadrat getrennt sind.
 
-Let the fill-count function, $F(m, n)$, represent the number of ways that a row can be filled.
+Die Füllfunktion $F(m, n)$ soll die Anzahl der Möglichkeiten darstellen, wie eine Zeile gefüllt werden kann.
 
-For example, $F(3, 29) = 673135$ and $F(3, 30) = 1089155$.
+Zum Beispiel $F(3, 29) = 673135$ und $F(3, 30) = 1089155$.
 
-That is, for m = 3, it can be seen that n = 30 is the smallest value for which the fill-count function first exceeds one million.
+Das heißt, für m = 3 ist n = 30 der kleinste Wert, für den die Fill-Count-Funktion erstmals eine Million überschreitet.
 
-In the same way, for m = 10, it can be verified that $F(10, 56) = 880711$ and $F(10, 57) = 1148904$, so n = 57 is the least value for which the fill-count function first exceeds one million.
+Auf die gleiche Weise kann für m = 10 nachgewiesen werden, dass $F(10, 56) = 880711$ und $F(10, 57) = 1148904$, also n = 57 der kleinste Wert ist, für den die Fill-Count-Funktion erstmals eine Million überschreitet.
 
-For m = 50, find the least value of `n` for which the fill-count function first exceeds one million.
+Finde für m = 50 den kleinsten Wert von `n`, für den die Funktion fill-count zuerst eine Million überschreitet.
 
-**Note:** This is a more difficult version of Problem 114.
+**Hinweis:** Dies ist eine schwierigere Version von Problem 114.
 
 # --hints--
 
-`countingBlockTwo()` should return `168`.
+`countingBlockTwo()` sollte `168` zurückgeben.
 
 ```js
 assert.strictEqual(countingBlockTwo(), 168);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-116-red-green-or-blue-tiles.md b/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-116-red-green-or-blue-tiles.md
index b0b1969a3df..0893b760448 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-116-red-green-or-blue-tiles.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-116-red-green-or-blue-tiles.md
@@ -1,6 +1,6 @@
 ---
 id: 5900f3e01000cf542c50fef3
-title: 'Problem 116: Red, green or blue tiles'
+title: 'Problem 116: Rote, grüne oder blaue Fliesen'
 challengeType: 1
 forumTopicId: 301742
 dashedName: problem-116-red-green-or-blue-tiles
@@ -8,7 +8,7 @@ dashedName: problem-116-red-green-or-blue-tiles
 
 # --description--
 
-A row of five black square tiles is to have a number of its tiles replaced with coloured oblong tiles chosen from red (length two), green (length three), or blue (length four).
+Bei einer Reihe von fünf schwarzen quadratischen Steinen wird eine bestimmte Anzahl von Spielsteinen durch farbige längliche Spielsteine ersetzt, die entweder rot (Länge zwei), grün (Länge drei) oder blau (Länge vier) sind.
 
 If red tiles are chosen there are exactly seven ways this can be done.
 
@@ -16,19 +16,19 @@ If red tiles are chosen there are exactly seven ways this can be done.
 
 If green tiles are chosen there are three ways.
 
-<img class="img-responsive center-block" alt="Possible ways of placing green oblong on a row with length of five units" src="https://cdn.freecodecamp.org/curriculum/project-euler/red-green-or-blue-tiles-2.png" style="background-color: white; padding: 10px;" />
+<img class="img-responsive center-block" alt="Möglichkeiten, das grüne Rechteck in einer Reihe mit einer Länge von fünf Einheiten zu platzieren" src="https://cdn.freecodecamp.org/curriculum/project-euler/red-green-or-blue-tiles-2.png" style="background-color: white; padding: 10px;" />
 
-And if blue tiles are chosen there are two ways.
+Und wenn blaue Steine gewählt werden, gibt es zwei Möglichkeiten.
 
-<img class="img-responsive center-block" alt="Possible ways of placing blue oblong on a row with length of five units" src="https://cdn.freecodecamp.org/curriculum/project-euler/red-green-or-blue-tiles-3.png" style="background-color: white; padding: 10px;" />
+<img class="img-responsive center-block" alt="Möglichkeiten, das blaue Rechteck in einer Reihe mit einer Länge von fünf Einheiten zu platzieren" src="https://cdn.freecodecamp.org/curriculum/project-euler/red-green-or-blue-tiles-3.png" style="background-color: white; padding: 10px;" />
 
-Assuming that colors cannot be mixed there are 7 + 3 + 2 = 12 ways of replacing the black tiles in a row measuring five units in length. How many different ways can the black tiles in a row measuring fifty units in length be replaced if colors cannot be mixed and at least one colored tile must be used?
+Unter der Annahme, dass Farben nicht gemischt werden können, gibt es 7 + 3 + 2 = 12 Möglichkeiten, die schwarzen Steine in einer Reihe von fünf Einheiten Länge zu ersetzen. Auf wie viele verschiedene Arten können die schwarzen Steine in einer Reihe von fünfzig Einheiten Länge ersetzt werden, wenn die Farben nicht gemischt werden können und mindestens ein farbiger Stein verwendet werden muss?
 
-**Note:** This is related to Problem 117.
+**Hinweis:** Dies bezieht sich auf Problem 117.
 
 # --hints--
 
-`redGreenBlueOne()` should return `20492570929`.
+`redGreenBlueOne()` sollte `20492570929` zurückgeben.
 
 ```js
 assert.strictEqual(redGreenBlueOne(), 20492570929);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-117-red-green-and-blue-tiles.md b/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-117-red-green-and-blue-tiles.md
index 4a4873aac95..7c4a14b26f0 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-117-red-green-and-blue-tiles.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-117-red-green-and-blue-tiles.md
@@ -8,17 +8,17 @@ dashedName: problem-117-red-green-and-blue-tiles
 
 # --description--
 
-Using a combination of black square tiles and oblong tiles chosen from: red tiles measuring two units, green tiles measuring three units, and blue tiles measuring four units, it is possible to tile a row measuring five units in length in exactly fifteen different ways.
+Mit einer Kombination aus schwarzen quadratischen Steinen und länglichen Steinen, ausgewählt aus roten Steinen mit einer Größe von zwei Einheiten, grünen Steinen mit einer Größe von drei Einheiten und blauen Steinen mit einer Größe von vier Einheiten, ist es möglich, eine Reihe mit einer Länge von fünf Einheiten auf genau fünfzehn verschiedene Arten zu verlegen.
 
-<img class="img-responsive center-block" alt="Possible ways of placing red, green and blue oblongs on a row with length of five units" src="https://cdn.freecodecamp.org/curriculum/project-euler/red-green-and-blue-tiles.png" style="background-color: white; padding: 10px;" />
+<img class="img-responsive center-block" alt="Möglichkeiten, rote, grüne und blaue Rechtecke in einer Reihe mit einer Länge von fünf Einheiten zu platzieren" src="https://cdn.freecodecamp.org/curriculum/project-euler/red-green-and-blue-tiles.png" style="background-color: white; padding: 10px;" />
 
-How many ways can a row measuring fifty units in length be tiled?
+Auf wie viele Arten kann eine Reihe mit einer Länge von fünfzig Einheiten übereinander gelegt werden?
 
-**Note**: This is related to Problem 116.
+**Hinweis**: Dies hängt mit Problem 116 zusammen.
 
 # --hints--
 
-`redGreenBlueTilesTwo()` should return `100808458960497`.
+`redGreenBlueTilesTwo()` sollte `100808458960497` zurückgeben.
 
 ```js
 assert.strictEqual(redGreenBlueTilesTwo(), 100808458960497);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-118-pandigital-prime-sets.md b/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-118-pandigital-prime-sets.md
index 195d39136ed..b7eb2495bd1 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-118-pandigital-prime-sets.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-118-pandigital-prime-sets.md
@@ -8,13 +8,13 @@ dashedName: problem-118-pandigital-prime-sets
 
 # --description--
 
-Using all of the digits 1 through 9 and concatenating them freely to form decimal integers, different sets can be formed. Interestingly with the set $\\{2, 5, 47, 89, 631\\}$, all of the elements belonging to it are prime.
+Wenn man alle Ziffern von 1 bis 9 verwendet und sie frei zu Dezimalzahlen verkettet, können verschiedene Mengen gebildet werden. Interessanterweise sind alle Elemente, die zur Menge $\\{2, 5, 47, 89, 631\\}$ gehören, Primzahlen.
 
-How many distinct sets containing each of the digits one through nine exactly once contain only prime elements?
+Wie viele unterschiedliche Mengen, die jede der Ziffern eins bis neun genau einmal enthalten, enthalten nur Primzahlen?
 
 # --hints--
 
-`pandigitalPrimeSets()` should return `44680`.
+`pandigitalPrimeSets()` sollte `44680` zurückgeben.
 
 ```js
 assert.strictEqual(pandigitalPrimeSets(), 44680);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-119-digit-power-sum.md b/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-119-digit-power-sum.md
index 87bf836b33a..b3e7219da69 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-119-digit-power-sum.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-119-digit-power-sum.md
@@ -8,17 +8,17 @@ dashedName: problem-119-digit-power-sum
 
 # --description--
 
-The number 512 is interesting because it is equal to the sum of its digits raised to some power: $5 + 1 + 2 = 8$, and $8^3 = 512$. Another example of a number with this property is $614656 = 28^4$.
+Die Zahl 512 ist interessant, weil sie gleich der Summe ihrer Ziffern in einer Potenz ist: $5 + 1 + 2 = 8$, und $8^3 = 512$. Ein weiteres Beispiel für eine Zahl mit dieser Eigenschaft ist $614656 = 28^4$.
 
-We shall define $a_n$ to be the $n-th$ term of this sequence and insist that a number must contain at least two digits to have a sum.
+Wir definieren $a_n$ als den $n-th$ Term dieser Folge und bestehen darauf, dass eine Zahl mindestens zwei Ziffern enthalten muss, um eine Summe zu haben.
 
-You are given that $a_2 = 512$ and $a_{10} = 614656$.
+Es ist gegeben, dass $a_2 = 512$ und $a_{10} = 614656$.
 
-Find $a_{30}$.
+Finde $a_{30}$.
 
 # --hints--
 
-`digitPowerSum()` should return `248155780267521`.
+`digitPowerSum()` sollte `248155780267521` zurückgeben.
 
 ```js
 assert.strictEqual(digitPowerSum(), 248155780267521);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-120-square-remainders.md b/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-120-square-remainders.md
index d42c224e3db..8142f429a54 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-120-square-remainders.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-120-square-remainders.md
@@ -10,13 +10,13 @@ dashedName: problem-120-square-remainders
 
 Let `r` be the remainder when ${(a − 1)}^n + {(a + 1)}^n$ is divided by $a^2$.
 
-For example, if $a = 7$ and $n = 3$, then $r = 42: 6^3 + 8^3 = 728 ≡ 42 \\ \text{mod}\\ 49$. And as `n` varies, so too will `r`, but for $a = 7$ it turns out that $r_{max} = 42$.
+Wenn zum Beispiel $a = 7$ und $n = 3$, dann ist $r = 42: 6^3 + 8^3 = 728 ≡ 42 \\ \text{mod}\ 49$. Und so wie `n` variiert, so wird auch `r` variieren, aber für $a = 7$ stellt sich heraus, dass $r_{max} = 42$ ist.
 
-For $3 ≤ a ≤ 1000$, find $\sum{r}_{max}$.
+Für $3 ≤ a ≤ 1000$, finde $\sum{r}_{max}$.
 
 # --hints--
 
-`squareRemainders()` should return `333082500`.
+`squareRemainders()` sollte `333082500` zurückgeben.
 
 ```js
 assert.strictEqual(squareRemainders(), 333082500);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-121-disc-game-prize-fund.md b/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-121-disc-game-prize-fund.md
index 0f23b7fdd50..7f208dfd73e 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-121-disc-game-prize-fund.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-121-disc-game-prize-fund.md
@@ -8,17 +8,17 @@ dashedName: problem-121-disc-game-prize-fund
 
 # --description--
 
-A bag contains one red disc and one blue disc. In a game of chance a player takes a disc at random and its colour is noted. After each turn the disc is returned to the bag, an extra red disc is added, and another disc is taken at random.
+Ein Beutel enthält eine rote Scheibe und eine blaue Scheibe. In einem Glücksspiel zieht ein Spieler eine zufällige Scheibe und deren Farbe wird notiert. Nach jeder Runde wird die Scheibe zurück in den Beutel gelegt, eine zusätzliche rote Scheibe wird hinzugefügt, und eine andere Scheibe wird zufällig entnommen.
 
-The player pays £1 to play and wins if they have taken more blue discs than red discs at the end of the game.
+Der Spieler zahlt £1, um zu spielen und gewinnt, wenn am Ende des Spiels mehr blaue als rote Scheiben entnommen wurden.
 
-If the game is played for four turns, the probability of a player winning is exactly 11/120, and so the maximum prize fund the banker should allocate for winning in this game would be £10 before they would expect to incur a loss. Note that any payout will be a whole number of pounds and also includes the original £1 paid to play the game, so in the example given the player actually wins £9.
+Wenn das Spiel in vier Runden gespielt wird, liegt die Wahrscheinlichkeit, dass ein Spieler gewinnt, bei genau 11/120, und der maximale Preisfonds, den der Bankier für einen Gewinn in diesem Spiel bereitstellen sollte, würde so 10 £ betragen, bevor ein Verlust erwartet werden würde. Zu beachten ist, dass jede Auszahlung eine ganze Zahl von Pfund ist und auch die ursprünglich für das Spiel gezahlten 1 Pfund einschließt, so dass der Spieler in dem angegebenen Beispiel tatsächlich 9 Pfund gewinnt.
 
-Find the maximum prize fund that should be allocated to a single game in which fifteen turns are played.
+Finde die maximale Prämie, die in einem einzigen Spiel zugewiesen werden sollte, in dem 15 Runden gespielt werden.
 
 # --hints--
 
-`discGamePrize()` should return `2269`.
+`discGamePrize()` sollte `2269` zurückgeben.
 
 ```js
 assert.strictEqual(discGamePrize(), 2269);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-122-efficient-exponentiation.md b/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-122-efficient-exponentiation.md
index 78c29aa7952..bf2a3dde829 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-122-efficient-exponentiation.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-122-efficient-exponentiation.md
@@ -12,26 +12,26 @@ The most naive way of computing $n^{15}$ requires fourteen multiplications:
 
 $$n × n × \ldots × n = n^{15}$$
 
-But using a "binary" method you can compute it in six multiplications:
+Mit einer "binären" Methode kann man sie jedoch in sechs Multiplikationen berechnen:
 
 $$\begin{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}$$
 
-However it is yet possible to compute it in only five multiplications:
+Es ist jedoch möglich, ihn in nur fünf Multiplikationen zu berechnen:
 
 $$\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}$$
 
-We shall define $m(k)$ to be the minimum number of multiplications to compute $n^k$; for example $m(15) = 5$.
+Wir definieren $m(k)$ als die minimale Anzahl von Multiplikationen zur Berechnung von $n^k$; zum Beispiel $m(15) = 5$.
 
-For $1 ≤ k ≤ 200$, find $\sum{m(k)}$.
+Für $1 ≤ k ≤ 200$, finde $\sum{m(k)}$.
 
 # --hints--
 
-`efficientExponentation()` should return `1582`.
+`efficientExponentation()` sollte `1582` zurückgeben.
 
 ```js
 assert.strictEqual(efficientExponentation(), 1582);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-123-prime-square-remainders.md b/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-123-prime-square-remainders.md
index 743089b64e3..d9367187ae9 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-123-prime-square-remainders.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-123-prime-square-remainders.md
@@ -10,15 +10,15 @@ dashedName: problem-123-prime-square-remainders
 
 Let $p_n$ be the $n$th prime: 2, 3, 5, 7, 11, ..., and let $r$ be the remainder when ${(p_n−1)}^n + {(p_n+1)}^n$ is divided by ${p_n}^2$.
 
-For example, when $n = 3, p_3 = 5$, and $4^3 + 6^3 = 280 ≡ 5\\ mod\\ 25$.
+Zum Beispiel, wenn $n = 3, p_3 = 5$, und $4^3 + 6^3 = 280 ≡ 5\\ mod\ 25$.
 
-The least value of $n$ for which the remainder first exceeds $10^9$ is 7037.
+Der kleinste Wert von $n$, für den der Rest zuerst $10^9$ überschreitet, ist 7037.
 
-Find the least value of $n$ for which the remainder first exceeds $10^{10}$.
+Finde den kleinsten Wert von $n$, für den der Rest zuerst $10^{10}$ überschreitet.
 
 # --hints--
 
-`primeSquareRemainders()` should return `21035`.
+`primeSquareRemainders()` sollte `21035` zurückgeben.
 
 ```js
 assert.strictEqual(primeSquareRemainders(), 21035);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-124-ordered-radicals.md b/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-124-ordered-radicals.md
index 899171a9731..8cfb41d3abe 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-124-ordered-radicals.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-124-ordered-radicals.md
@@ -112,11 +112,11 @@ If we calculate $rad(n)$ for $1 ≤ n ≤ 10$, then sort them on $rad(n)$, and s
   </table>
 </div><br>
 
-Let $E(k)$ be the $k$th element in the sorted $n$ column; for example, $E(4) = 8$ and $E(6) = 9$. If $rad(n)$ is sorted for $1 ≤ n ≤ 100000$, find $E(10000)$.
+Lasse $E(k)$ das $k$th Element in der geordneten $n$ Spalte sein; zum Beispiel, $E(4) = 8$ und $E(6) = 9$. Wenn $rad(n)$ für $1 ≤ n ≤ 100000$ geordnet ist, findest du $E(10000)$.
 
 # --hints--
 
-`orderedRadicals()` should return `21417`.
+`orderedRadicals()` sollte `21417` zurückgeben.
 
 ```js
 assert.strictEqual(orderedRadicals(), 21417);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-125-palindromic-sums.md b/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-125-palindromic-sums.md
index eb499c13931..ab191571cf2 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-125-palindromic-sums.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-125-palindromic-sums.md
@@ -1,6 +1,6 @@
 ---
 id: 5900f3e91000cf542c50fefc
-title: 'Problem 125: Palindromic sums'
+title: 'Problem 125: Palindromische Summen'
 challengeType: 1
 forumTopicId: 301752
 dashedName: problem-125-palindromic-sums
@@ -8,14 +8,14 @@ dashedName: problem-125-palindromic-sums
 
 # --description--
 
-The palindromic number 595 is interesting because it can be written as the sum of consecutive squares: $6^2 + 7^2 + 8^2 + 9^2 + 10^2 + 11^2 + 12^2$.
+Die palindromische Zahl 595 ist interessant, weil sie als Summe aufeinander folgender Quadrate geschrieben werden kann: $6^2 + 7^2 + 8^2 + 9^2 + 10^2 + 11^2 + 11^2 + 12^2$.
 
-There are exactly eleven palindromes below one-thousand that can be written as consecutive square sums, and the sum of these palindromes is 4164. Note that $1 = 0^2 + 1^2$ has not been included as this problem is concerned with the squares of positive integers.
+Es gibt genau elf Palindrome unter eintausend, die als aufeinanderfolgende Quadratsummen geschrieben werden können, und die Summe dieser Palindrome ist 4164. Man beachte, dass $1 = 0^2 + 1^2$ nicht berücksichtigt wurde, da es sich bei diesem Problem um die Quadrate positiver ganzer Zahlen handelt.
 
-Find the sum of all the numbers less than the  `limit`  that are both palindromic and can be written as the sum of consecutive squares.
+Finde die Summe aller Zahlen, die kleiner als `limit` sind, die beide palindromisch sind und als Summe aufeinanderfolgender Quadrate geschrieben werden können.
 
 # --hints--
-`palindromicSums(100000000)` should return `2906969179`.
+`palindromicSums(100000000)` sollte `2906969179` zurückgeben.
 
 ```js
 
@@ -23,13 +23,13 @@ assert.strictEqual(palindromicSums(100000000), 2906969179);
 
 ```
 
-`palindromicSums(100)` should return `137`.
+`palindromicSums(100)` sollte `137` zurückgeben.
 
 ```js
 assert.strictEqual(palindromicSums(100), 137);
 ```
 
-`palindromicSums(1000)` should return `4164`.
+`palindromicSums(1000)` sollte `4164` zurückgeben.
 
 ```js
 assert.strictEqual(palindromicSums(1000),4164);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-126-cuboid-layers.md b/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-126-cuboid-layers.md
index d089c18aff0..cc7eb63f572 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-126-cuboid-layers.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-126-cuboid-layers.md
@@ -1,6 +1,6 @@
 ---
 id: 5900f3ea1000cf542c50fefd
-title: 'Problem 126: Cuboid layers'
+title: 'Problem 126: Quaderförmige Ebenen'
 challengeType: 1
 forumTopicId: 301753
 dashedName: problem-126-cuboid-layers
@@ -12,19 +12,19 @@ The minimum number of cubes to cover every visible face on a cuboid measuring 3
 
 <img class="img-responsive center-block" alt="3x2x1 cuboid covered by twenty-two 1x1x1 cubes" src="https://cdn.freecodecamp.org/curriculum/project-euler/cuboid-layers.png" style="background-color: white; padding: 10px;" />
 
-If we add a second layer to this solid it would require forty-six cubes to cover every visible face, the third layer would require seventy-eight cubes, and the fourth layer would require one-hundred and eighteen cubes to cover every visible face.
+Fügen wir diesem Körper eine zweite Schicht hinzu, wären sechsundvierzig Würfel erforderlich, um jede sichtbare Fläche zu bedecken, für die dritte Schicht wären achtundsiebzig Würfel erforderlich, und für die vierte Schicht wären einhundertachtzehn Würfel erforderlich, um jede sichtbare Fläche zu bedecken.
 
-However, the first layer on a cuboid measuring 5 x 1 x 1 also requires twenty-two cubes; similarly, the first layer on cuboids measuring 5 x 3 x 1, 7 x 2 x 1, and 11 x 1 x 1 all contain forty-six cubes.
+Für die erste Schicht auf einem Quader mit den Maßen 5 x 1 x 1 werden jedoch auch zweiundzwanzig Würfel benötigt; ebenso enthält die erste Schicht auf Quadern mit den Maßen 5 x 3 x 1, 7 x 2 x 1 und 11 x 1 x 1 jeweils sechsundvierzig Würfel.
 
-We shall define $C(n)$ to represent the number of cuboids that contain $n$ cubes in one of its layers. So $C(22) = 2$, $C(46) = 4$, $C(78) = 5$, and $C(118) = 8$.
+Wir definieren $C(n)$ als die Anzahl der Quader, die $n$ Würfel in einer ihrer Schichten enthalten. Also $C(22) = 2$, $C(46) = 4$, $C(78) = 5$, und $C(118) = 8$.
 
-It turns out that 154 is the least value of $n$ for which $C(n) = 10$.
+Es stellt sich heraus, dass 154 der kleinste Wert von $n$ ist, für den $C(n) = 10$ ist.
 
-Find the least value of $n$ for which $C(n) = 1000$.
+Finde den kleinsten Wert von $n$, für den $C(n) = 1000$ ist.
 
 # --hints--
 
-`cuboidLayers()` should return `18522`.
+`cuboidLayers()` sollte `18522` zurückgeben.
 
 ```js
 assert.strictEqual(cuboidLayers(), 18522);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-127-abc-hits.md b/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-127-abc-hits.md
index 2f7f927858e..13aa0f507a9 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-127-abc-hits.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-127-abc-hits.md
@@ -8,29 +8,29 @@ dashedName: problem-127-abc-hits
 
 # --description--
 
-The radical of $n$, $rad(n)$, is the product of distinct prime factors of $n$. For example, $504 = 2^3 × 3^2 × 7$, so $rad(504) = 2 × 3 × 7 = 42$.
+The radical of $n$, $rad(n)$, is the product of distinct prime factors of $n$. Zum Beispiel: $504 = 2^3 × 3^2 × 7$, also $rad(504) = 2 × 3 × 7 = 42$.
 
-We shall define the triplet of positive integers (a, b, c) to be an abc-hit if:
+Wir definieren das Tripel positiver ganzer Zahlen (a, b, c) als einen abc-Treffer, wenn:
 
 1. $GCD(a, b) = GCD(a, c) = GCD(b, c) = 1$
 2. $a &lt; b$
 3. $a + b = c$
 4. $rad(abc) &lt; c$
 
-For example, (5, 27, 32) is an abc-hit, because:
+Zum Beispiel ist (5, 27, 32) ein abc-Treffer, weil:
 
 1. $GCD(5, 27) = GCD(5, 32) = GCD(27, 32) = 1$
 2. $5 &lt; 27$
 3. $5 + 27 = 32$
 4. $rad(4320) = 30 &lt; 32$
 
-It turns out that abc-hits are quite rare and there are only thirty-one abc-hits for $c &lt; 1000$, with $\sum{c} = 12523$.
+Es stellt sich heraus, dass abc-Treffer recht selten sind und es nur einunddreißig abc-Treffer für $c &lt; 1000$ gibt, mit $\sum{c} = 12523$.
 
-Find $\sum{c}$ for $c &lt; 120000$.
+Finde $\sum{c}$ für $c &lt; 120000$.
 
 # --hints--
 
-`abcHits()` should return `18407904`.
+`abcHits()` sollte `18407904` zurückgeben.
 
 ```js
 assert.strictEqual(abcHits(), 18407904);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-128-hexagonal-tile-differences.md b/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-128-hexagonal-tile-differences.md
index 49d59948762..3a074a9cf8d 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-128-hexagonal-tile-differences.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-128-hexagonal-tile-differences.md
@@ -10,17 +10,17 @@ dashedName: problem-128-hexagonal-tile-differences
 
 A hexagonal tile with number 1 is surrounded by a ring of six hexagonal tiles, starting at "12 o'clock" and numbering the tiles 2 to 7 in an anti-clockwise direction.
 
-New rings are added in the same fashion, with the next rings being numbered 8 to 19, 20 to 37, 38 to 61, and so on. The diagram below shows the first three rings.
+Neue Ringe werden auf die gleiche Weise hinzugefügt, wobei die nächsten Ringe die Nummern 8 bis 19, 20 bis 37, 38 bis 61 usw. tragen. Das folgende Diagramm zeigt die ersten drei Ringe.
 
-<img class="img-responsive center-block" alt="three first rings of arranged hexagonal tiles with numbers 1 to 37, and with highlighted tiles 8 and 17" src="https://cdn.freecodecamp.org/curriculum/project-euler/hexagonal-tile-differences.png" style="background-color: white; padding: 10px;" />
+<img class="img-responsive center-block" alt="drei erste Ringe aus angeordneten sechseckigen Steinen mit den Nummern 1 bis 37 und den hervorgehobenen Steinen 8 und 17" src="https://cdn.freecodecamp.org/curriculum/project-euler/hexagonal-tile-differences.png" style="background-color: white; padding: 10px;" />
 
 By finding the difference between tile $n$ and each of its six neighbours we shall define $PD(n)$ to be the number of those differences which are prime.
 
-For example, working clockwise around tile 8 the differences are 12, 29, 11, 6, 1, and 13. So $PD(8) = 3$.
+For example, working clockwise around tile 8 the differences are 12, 29, 11, 6, 1, and 13. Somit ist $PD(8) = 3$.
 
 In the same way, the differences around tile 17 are 1, 17, 16, 1, 11, and 10, hence $PD(17) = 2$.
 
-It can be shown that the maximum value of $PD(n)$ is $3$.
+Es kann gezeigt werden, dass der Maximalwert von $PD(n)$ $ $3$ ist.
 
 If all of the tiles for which $PD(n) = 3$ are listed in ascending order to form a sequence, the 10th tile would be 271.
 
@@ -28,13 +28,13 @@ Find the 2000th tile in this sequence.
 
 # --hints--
 
-`hexagonalTile(10)` should return `271`.
+`hexagonalTile(10)` sollte `271` zurückgeben.
 
 ```js
 assert.strictEqual(hexagonalTile(10), 271);
 ```
 
-`hexagonalTile(2000)` should return `14516824220`.
+`hexagonalTile(2000)` sollte `14516824220` zurückgeben.
 
 ```js
 assert.strictEqual(hexagonalTile(2000), 14516824220);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-129-repunit-divisibility.md b/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-129-repunit-divisibility.md
index e7f423f96d5..c7097d98b23 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-129-repunit-divisibility.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-129-repunit-divisibility.md
@@ -1,6 +1,6 @@
 ---
 id: 5900f3ef1000cf542c50ff01
-title: 'Problem 129: Repunit divisibility'
+title: 'Problem 129: Teilbarkeit von Einheiten'
 challengeType: 1
 forumTopicId: 301756
 dashedName: problem-129-repunit-divisibility
@@ -8,17 +8,17 @@ dashedName: problem-129-repunit-divisibility
 
 # --description--
 
-A number consisting entirely of ones is called a repunit. We shall define $R(k)$ to be a repunit of length $k$; for example, $R(6) = 111111$.
+Eine Zahl, die ausschließlich aus Einsen besteht, nennt man ein Repunit. We shall define $R(k)$ to be a repunit of length $k$; for example, $R(6) = 111111$.
 
-Given that $n$ is a positive integer and $GCD(n, 10) = 1$, it can be shown that there always exists a value, $k$, for which $R(k)$ is divisible by $n$, and let $A(n)$ be the least such value of $k$; for example, $A(7) = 6$ and $A(41) = 5$.
+Unter der Voraussetzung, dass $n$ eine positive ganze Zahl ist und $GCD(n, 10) = 1$, kann man zeigen, dass es immer einen Wert $k$ gibt, für den $R(k)$ durch $n$ teilbar ist, und dass $A(n)$ der kleinste solche Wert von $k$ ist; zum Beispiel $A(7) = 6$ und $A(41) = 5$.
 
-The least value of $n$ for which $A(n)$ first exceeds ten is 17.
+Der kleinste Wert von $n$, für den $A(n)$ zuerst zehn überschreitet, ist 17.
 
-Find the least value of $n$ for which $A(n)$ first exceeds one-million.
+Finde den kleinsten Wert von $n$, für den $A(n)$ zuerst eine Million überschreitet.
 
 # --hints--
 
-`repunitDivisibility()` should return `1000023`.
+`repunitDivisibility()` sollte `1000023` zurückgeben.
 
 ```js
 assert.strictEqual(repunitDivisibility(), 1000023);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-130-composites-with-prime-repunit-property.md b/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-130-composites-with-prime-repunit-property.md
index 48f7149e5a6..589b913f9c6 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-130-composites-with-prime-repunit-property.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-130-composites-with-prime-repunit-property.md
@@ -8,19 +8,19 @@ dashedName: problem-130-composites-with-prime-repunit-property
 
 # --description--
 
-A number consisting entirely of ones is called a repunit. We shall define $R(k)$ to be a repunit of length $k$; for example, $R(6) = 111111$.
+Eine Zahl, die ausschließlich aus Einsen besteht, nennt man Repunit. Wir definieren $R(k)$ als Repunit der Länge $k$; zum Beispiel $R(6) = 111111$.
 
-Given that $n$ is a positive integer and $GCD(n, 10) = 1$, it can be shown that there always exists a value, $k$, for which $R(k)$ is divisible by $n$, and let $A(n)$ be the least such value of $k$; for example, $A(7) = 6$ and $A(41) = 5$.
+Unter der Voraussetzung, dass $n$ eine positive ganze Zahl ist und $GCD(n, 10) = 1$, kann man zeigen, dass es immer einen Wert $k$ gibt, für den $R(k)$ durch $n$ teilbar ist, und dass $A(n)$ der kleinste solche Wert von $k$ ist; zum Beispiel $A(7) = 6$ und $A(41) = 5$.
 
-You are given that for all primes, $p > 5$, that $p − 1$ is divisible by $A(p)$. For example, when $p = 41, A(41) = 5$, and 40 is divisible by 5.
+Es ist gegeben, dass für alle Primzahlen $p > 5$, dass $p - 1$ durch $A(p)$ teilbar ist. Wenn zum Beispiel $p = 41 ist, ist A(41) = 5$, und 40 durch 5 teilbar.
 
-However, there are rare composite values for which this is also true; the first five examples being 91, 259, 451, 481, and 703.
+Es gibt jedoch seltene zusammengesetzte Werte, für die dies ebenfalls zutrifft; die ersten fünf Beispiele sind 91, 259, 451, 481 und 703.
 
-Find the sum of the first twenty-five composite values of $n$ for which $GCD(n, 10) = 1$ and $n − 1$ is divisible by $A(n)$.
+Finde die Summe der ersten fünfundzwanzig zusammengesetzten Werte von $n$, für die $GCD(n, 10) = 1$ und $n - 1$ durch $A(n)$ teilbar ist.
 
 # --hints--
 
-`compositeRepunit()` should return `149253`.
+`compositeRepunit()` sollte `149253` zurückgeben.
 
 ```js
 assert.strictEqual(compositeRepunit(), 149253);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-131-prime-cube-partnership.md b/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-131-prime-cube-partnership.md
index 73e7e8e7490..6c534288159 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-131-prime-cube-partnership.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-131-prime-cube-partnership.md
@@ -8,17 +8,17 @@ dashedName: problem-131-prime-cube-partnership
 
 # --description--
 
-There are some prime values, $p$, for which there exists a positive integer, $n$, such that the expression $n^3 + n^{2}p$ is a perfect cube.
+Es gibt einige Primzahlen $p$, für die es eine positive ganze Zahl $n$ gibt, sodass der Ausdruck $n^3 + n^{2}p$ ein perfekter Würfel ist.
 
-For example, when $p = 19,\\ 8^3 + 8^2 × 19 = {12}^3$.
+Zum Beispiel, wenn $p = 19,\\ 8^3 + 8^2 × 19 = {12}^3$.
 
-What is perhaps most surprising is that the value of $n$ is unique for each prime with this property, and there are only four such primes below one hundred.
+Was vielleicht am meisten überrascht, ist, dass der Wert von $n$ für jede Primzahl mit dieser Eigenschaft einzigartig ist, und dass es nur vier solcher Primzahlen unter hundert gibt.
 
-How many primes below one million have this remarkable property?
+Wie viele Primzahlen unter einer Million haben diese bemerkenswerte Eigenschaft?
 
 # --hints--
 
-`primeCubePartnership()` should return `173`.
+`primeCubePartnership()` sollte `173` zurückgeben.
 
 ```js
 assert.strictEqual(primeCubePartnership(), 173);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-132-large-repunit-factors.md b/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-132-large-repunit-factors.md
index 5ca7c0760fd..c3c4b789140 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-132-large-repunit-factors.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-132-large-repunit-factors.md
@@ -1,6 +1,6 @@
 ---
 id: 5900f3f11000cf542c50ff03
-title: 'Problem 132: Large repunit factors'
+title: 'Problem 132: Große Repunit-Faktoren'
 challengeType: 1
 forumTopicId: 301760
 dashedName: problem-132-large-repunit-factors
@@ -8,15 +8,15 @@ dashedName: problem-132-large-repunit-factors
 
 # --description--
 
-A number consisting entirely of ones is called a repunit. We shall define $R(k)$ to be a repunit of length $k$.
+Eine Zahl, die alleinig aus Einsen besteht, wird Repunit genannt. We shall define $R(k)$ to be a repunit of length $k$.
 
-For example, $R(10) = 1111111111 = 11 × 41 × 271 × 9091$, and the sum of these prime factors is 9414.
+Zum Beispiel gilt, dass $R(10) = 1111111111 = 11 × 41 × 271 × 9091$ und die Summe dieser Primfaktoren 9414 ist.
 
-Find the sum of the first forty prime factors of $R({10}^9)$.
+Finde die Summe der ersten 40 Primfaktoren von $R({10}^9)$.
 
 # --hints--
 
-`largeRepunitFactors()` should return `843296`.
+`largeRepunitFactors()` sollte `843296` ausgeben.
 
 ```js
 assert.strictEqual(largeRepunitFactors(), 843296);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-133-repunit-nonfactors.md b/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-133-repunit-nonfactors.md
index ee861a14420..c98e7f5adff 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-133-repunit-nonfactors.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-133-repunit-nonfactors.md
@@ -8,17 +8,17 @@ dashedName: problem-133-repunit-nonfactors
 
 # --description--
 
-A number consisting entirely of ones is called a repunit. We shall define $R(k)$ to be a repunit of length $k$; for example, $R(6) = 111111$.
+Eine Zahl, die ausschließlich aus Einsen besteht, nennt man Repunit. Wir definieren $R(k)$ als Repunit der Länge $k$; zum Beispiel $R(6) = 111111$.
 
-Let us consider repunits of the form $R({10}^n)$.
+Wir betrachten Repunits in der Form $R({10}^n)$.
 
-Although $R(10)$, $R(100)$, or $R(1000)$ are not divisible by 17, $R(10000)$ is divisible by 17. Yet there is no value of n for which $R({10}^n)$ will divide by 19. Remarkably, 11, 17, 41, and 73 are the only four primes below one-hundred that can be a factor of $R({10}^n)$.
+Obwohl $R(10)$, $R(100)$ oder $R(1000)$ nicht durch 17 teilbar sind, ist $R(10000)$ durch 17 teilbar. Es gibt jedoch keinen Wert von n, für den $R({10}^n)$ durch 19 teilbar wäre. Bemerkenswerterweise sind 11, 17, 41 und 73 die einzigen vier Primzahlen unter Hundert, die ein Faktor von $R({10}^n)$ sein können.
 
-Find the sum of all the primes below one-hundred thousand that will never be a factor of $R({10}^n)$.
+Finde die Summe aller Primzahlen unter einhunderttausend, die niemals ein Faktor von $R({10}^n)$ sein wird.
 
 # --hints--
 
-`repunitNonfactors()` should return `453647705`.
+`repunitNonfactors()` sollte `453647705` zurückgeben.
 
 ```js
 assert.strictEqual(repunitNonfactors(), 453647705);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-134-prime-pair-connection.md b/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-134-prime-pair-connection.md
index d6629ef1579..ebd5e7555c5 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-134-prime-pair-connection.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-134-prime-pair-connection.md
@@ -1,6 +1,6 @@
 ---
 id: 5900f3f21000cf542c50ff05
-title: 'Problem 134: Prime pair connection'
+title: 'Problem 134: Primzahl-Paar-Verbindungen'
 challengeType: 1
 forumTopicId: 301762
 dashedName: problem-134-prime-pair-connection
@@ -8,15 +8,15 @@ dashedName: problem-134-prime-pair-connection
 
 # --description--
 
-Consider the consecutive primes $p_1 = 19$ and $p_2 = 23$. It can be verified that 1219 is the smallest number such that the last digits are formed by $p_1$ whilst also being divisible by $p_2$.
+Betrachte die aufeinanderfolgenden Primzahlen $p_1 = 19$ und $p_2 = 23$. Es kann bewiesen werden, dass 1219 die kleinste Zahl ist, so dass die letzten Ziffern mit $p_1$ gebildet werden, während sie auch durch $p_2$ teilbar sind.
 
-In fact, with the exception of $p_1 = 3$ and $p_2 = 5$, for every pair of consecutive primes, $p_2 > p_1$, there exist values of $n$ for which the last digits are formed by $p_1$ and $n$ is divisible by $p_2$. Let $S$ be the smallest of these values of $n$.
+Tatsächlich gibt es mit Ausnahme von $p_1 = 3$ und $p_2 = 5$ für jedes Paar von aufeinanderfolgenden Primzahlen $p_2 > p_1$ Werte von $n$, für die die letzten Ziffern durch $p_1$ gebildet werden und $n$ durch $p_2$ teilbar ist. Lass $S$ den kleinsten dieser Werte von $n$ sein.
 
-Find $\sum{S}$ for every pair of consecutive primes with $5 ≤ p_1 ≤ 1000000$.
+Finde $\sum{S}$ für jedes Paar der aufeinanderfolgenden Primzahlen mit $5 ≤ p_1 ≤ 1000000$.
 
 # --hints--
 
-`primePairConnection()` should return `18613426663617120`.
+`primePairConnection()` sollte `18613426663617120` zurückgeben.
 
 ```js
 assert.strictEqual(primePairConnection(), 18613426663617120);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-135-same-differences.md b/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-135-same-differences.md
index 3045467d61e..c873eafde34 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-135-same-differences.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-135-same-differences.md
@@ -1,6 +1,6 @@
 ---
 id: 5900f3f31000cf542c50ff06
-title: 'Problem 135: Same differences'
+title: 'Problem 135: Gleiche Unterschiede'
 challengeType: 1
 forumTopicId: 301763
 dashedName: problem-135-same-differences
@@ -8,17 +8,17 @@ dashedName: problem-135-same-differences
 
 # --description--
 
-Given the positive integers, $x$, $y$, and $z$, are consecutive terms of an arithmetic progression, the least value of the positive integer, $n$, for which the equation, $x^2 − y^2 − z^2 = n$, has exactly two solutions is $n = 27$:
+Da die positiven ganzen Zahlen $x$, $y$ und $z$ aufeinanderfolgende Terme einer arithmetischen Progression sind, ist der kleinste Wert der positiven ganzen Zahl $n$, für den die Gleichung $x^2 - y^2 - z^2 = n$ genau zwei Lösungen hat, $n = 27$:
 
 $$34^2 − 27^2 − 20^2 = 12^2 − 9^2 − 6^2 = 27$$
 
-It turns out that $n = 1155$ is the least value which has exactly ten solutions.
+Es stellt sich heraus, dass $n = 1155$ der kleinste Wert ist, der genau zehn Lösungen hat.
 
-How many values of $n$ less than one million have exactly ten distinct solutions?
+Wie viele Werte von $n$, unter einer Million, haben genau zehn verschiedene Lösungen?
 
 # --hints--
 
-`sameDifferences()` should return `4989`.
+`sameDifferences()` sollte `4989` zurückgeben.
 
 ```js
 assert.strictEqual(sameDifferences(), 4989);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-136-singleton-difference.md b/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-136-singleton-difference.md
index d73ff59f63b..f57080ee0c5 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-136-singleton-difference.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-136-singleton-difference.md
@@ -1,6 +1,6 @@
 ---
 id: 5900f3f51000cf542c50ff07
-title: 'Problem 136: Singleton difference'
+title: 'Problem 136: Singleton Unterschied'
 challengeType: 1
 forumTopicId: 301764
 dashedName: problem-136-singleton-difference
@@ -8,17 +8,17 @@ dashedName: problem-136-singleton-difference
 
 # --description--
 
-The positive integers, $x$, $y$, and $z$, are consecutive terms of an arithmetic progression. Given that $n$ is a positive integer, the equation, $x^2 − y^2 − z^2 = n$, has exactly one solution when $n = 20$:
+Die positiven ganzen Zahlen $x$, $y$ und $z$ sind aufeinanderfolgende Terme einer arithmetischen Progression. Unter der Voraussetzung, dass $n$ eine positive ganze Zahl ist, hat die Gleichung $x^2 - y^2 - z^2 = n$ genau eine Lösung, wenn $n = 20$:
 
 $$13^2 − 10^2 − 7^2 = 20$$
 
-In fact, there are twenty-five values of $n$ below one hundred for which the equation has a unique solution.
+In der Tat gibt es fünfundzwanzig Werte von $n$ unter hundert, für die die Gleichung eine eindeutige Lösung hat.
 
-How many values of $n$ less than fifty million have exactly one solution?
+Wie viele Werte von $n$ kleiner als fünfzig Millionen haben genau eine Lösung?
 
 # --hints--
 
-`singletonDifference()` should return `2544559`.
+`singletonDifference()` sollte `2544559` zurückgeben.
 
 ```js
 assert.strictEqual(singletonDifference(), 2544559);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-137-fibonacci-golden-nuggets.md b/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-137-fibonacci-golden-nuggets.md
index b700dba62d0..b003067241c 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-137-fibonacci-golden-nuggets.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-137-fibonacci-golden-nuggets.md
@@ -8,16 +8,16 @@ dashedName: problem-137-fibonacci-golden-nuggets
 
 # --description--
 
-Consider the infinite polynomial series $A_{F}(x) = xF_1 + x^2F_2 + x^3F_3 + \ldots$, where $F_k$ is the $k$th term in the Fibonacci sequence: $1, 1, 2, 3, 5, 8, \ldots$; that is, $F_k = F_{k − 1} + F_{k − 2}, F_1 = 1$ and $F_2 = 1$.
+Man betrachte die unendliche Polynomreihe $A_{F}(x) = xF_1 + x^2F_2 + x^3F_3 + \ldots$, wobei $F_k$ der $k$-te Term der Fibonacci-Folge ist: $1, 1, 2, 3, 5, 8, \ldots$; das heißt, $F_k = F_{k - 1} + F_{k - 2}, F_1 = 1$ und $F_2 = 1$.
 
-For this problem we shall be interested in values of $x$ for which $A_{F}(x)$ is a positive integer.
+Für dieses Problem sind wir an Werten von $x$ interessiert, für die $A_{F}(x)$ eine positive ganze Zahl ist.
 
-Surprisingly
+Überraschenderweise
 
 $$\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}$$
 
-The corresponding values of $x$ for the first five natural numbers are shown below.
+Die entsprechenden Werte von $x$ für die ersten fünf natürlichen Zahlen sind unten dargestellt.
 
 | $x$                         | $A_F(x)$ |
 | --------------------------- | -------- |
@@ -33,7 +33,7 @@ Find the 15th golden nugget.
 
 # --hints--
 
-`goldenNugget()` should return `1120149658760`.
+`goldenNugget()` sollte `1120149658760` zurückgeben.
 
 ```js
 assert.strictEqual(goldenNugget(), 1120149658760);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-138-special-isosceles-triangles.md b/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-138-special-isosceles-triangles.md
index 6391b7523c4..3c5ec39db3c 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-138-special-isosceles-triangles.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/project-euler/problem-138-special-isosceles-triangles.md
@@ -1,6 +1,6 @@
 ---
 id: 5900f3f61000cf542c50ff09
-title: 'Problem 138: Special isosceles triangles'
+title: 'Problem 130: Besondere gleichschenklige Dreiecke'
 challengeType: 1
 forumTopicId: 301766
 dashedName: problem-138-special-isosceles-triangles
@@ -10,17 +10,17 @@ dashedName: problem-138-special-isosceles-triangles
 
 Consider the isosceles triangle with base length, $b = 16$, and legs, $L = 17$.
 
-<img class="img-responsive center-block" alt="isosceles triangle with edges named as L - two edges with the same length and base of the triangle as b; and height of the triangle - h from the base of the triangle to the angle between L edges" src="https://cdn.freecodecamp.org/curriculum/project-euler/special-isosceles-triangles.png" style="background-color: white; padding: 10px;" />
+<img class="img-responsive center-block" alt="gleichschenkliges Dreieck mit Kanten, die als L bezeichnet werden - zwei Kanten mit der gleichen Länge und der Basis des Dreiecks wie b; und Höhe des Dreiecks - h von der Basis des Dreiecks bis zum Winkel zwischen den L-Kanten" src="https://cdn.freecodecamp.org/curriculum/project-euler/special-isosceles-triangles.png" style="background-color: white; padding: 10px;" />
 
-By using the Pythagorean theorem, it can be seen that the height of the triangle, $h = \sqrt{{17}^2 − 8^2} = 15$, which is one less than the base length.
+Mit Hilfe des Satzes des Pythagoras kannst du feststellen, dass die Höhe des Dreiecks $h = \sqrt{{17}^2 - 8^2} = 15$ ist, also um eins kleiner als die Basislänge.
 
-With $b = 272$ and $L = 305$, we get $h = 273$, which is one more than the base length, and this is the second smallest isosceles triangle with the property that $h = b ± 1$.
+Mit $b = 272$ und $L = 305$ erhalten wir $h = 273$, was eins mehr als die Basislänge ist, und dies ist das zweitkleinste gleichschenklige Dreieck mit der Eigenschaft, dass $h = b ± 1$ gilt.
 
-Find $\sum{L}$ for the twelve smallest isosceles triangles for which $h = b ± 1$ and $b$, $L$ are positive integers.
+Finde $\sum{L}$ für die zwölf kleinsten gleichschenkligen Dreiecke, für die $h = b ± 1$ gilt und $b$, $L$ positive ganze Zahlen sind.
 
 # --hints--
 
-`isoscelesTriangles()` should return `1118049290473932`.
+`isoscelesTriangles()` sollte `1118049290473932` ausgeben.
 
 ```js
 assert.strictEqual(isoscelesTriangles(), 1118049290473932);
diff --git a/curriculum/challenges/german/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f8bfe0f30a1a3c340356b.md b/curriculum/challenges/german/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f8bfe0f30a1a3c340356b.md
index 56c45f3f86e..68a0d9093d8 100644
--- a/curriculum/challenges/german/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f8bfe0f30a1a3c340356b.md
+++ b/curriculum/challenges/german/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f8bfe0f30a1a3c340356b.md
@@ -30,7 +30,7 @@ Your first new `p` element should have a `span` element.
 assert(document.querySelector('.daily-value.small-text')?.lastElementChild?.previousElementSibling?.firstElementChild?.localName === 'span');
 ```
 
-Your first `span` element not be bold.
+Your first `span` element should not be bold.
 
 ```js
 assert(!document.querySelector('.daily-value.small-text')?.lastElementChild?.previousElementSibling?.firstElementChild?.classList?.contains('bold'));
diff --git a/curriculum/challenges/italian/08-data-analysis-with-python/data-analysis-with-python-projects/sea-level-predictor.md b/curriculum/challenges/italian/08-data-analysis-with-python/data-analysis-with-python-projects/sea-level-predictor.md
index 42c9b8f79bc..043f84406d3 100644
--- a/curriculum/challenges/italian/08-data-analysis-with-python/data-analysis-with-python-projects/sea-level-predictor.md
+++ b/curriculum/challenges/italian/08-data-analysis-with-python/data-analysis-with-python-projects/sea-level-predictor.md
@@ -28,7 +28,7 @@ Analizzerai un set di dati del cambiamento globale medio del livello del mare da
 Usa i dati per completare le seguenti attività:
 
 - Usa Pandas per importare i dati da `epa-sea-level.csv`.
-- Use matplotlib to create a scatter plot using the `Year` column as the x-axis and the `CSIRO Adjusted Sea Level` column as the y-axis.
+- Usa matplotlib per creare un grafico a dispersione usando la colonna `Year` come asse x e la colonna `CSIRO Adjusted Sea Level` come asse y.
 - Usa la funzione `linregress` da `scipy.stats` per ottenere la pendenza e l'intercetta y della retta di regressione. Traccia la retta di regressione sopra la parte superiore del grafico a dispersione. Fai passare la linea attraverso l'anno 2050 per prevedere l'aumento del livello del mare nel 2050.
 - Traccia una nuova retta di regressione utilizzando i dati dall'anno 2000 all'anno più recente nel set di dati. Fai passare la linea anche per l'anno 2050 per prevedere quale sarà l'aumento del livello del mare nel 2050 se il tasso di crescita continuerà come ha fatto dal 2000 in poi.
 - L'asse x dovrebbe essere `Year`, l'asse y dovrebbe essere `Sea Level (inches)` e il titolo dovrebbe essere `Rise in Sea Level`.
diff --git a/curriculum/challenges/italian/10-coding-interview-prep/algorithms/implement-binary-search.md b/curriculum/challenges/italian/10-coding-interview-prep/algorithms/implement-binary-search.md
index 61012423e6c..267d3090020 100644
--- a/curriculum/challenges/italian/10-coding-interview-prep/algorithms/implement-binary-search.md
+++ b/curriculum/challenges/italian/10-coding-interview-prep/algorithms/implement-binary-search.md
@@ -10,10 +10,10 @@ dashedName: implement-binary-search
 
 Binary Search è un algoritmo con efficienza **O(log(n))** che permette di cercare un elemento dentro a un array ordinato. Funziona usando i seguenti step:
 
-1. Trova il `value` centrale di un array ordinato. If `value == target` return `true` (The value has been found and the search is complete).
+1. Trova il `value` centrale di un array ordinato. Se `value == target` restituisce `true` (il valore è stato trovato e la ricerca è completa).
 1. Se invece `value < target`, cerca nella metà destra dell'array nella prossima comparazione.
 1. Se invece `value > target`, cerca nella metà sinistra dell'array nella prossima comparazione.
-1. If after searching the whole array the value is not present, return `false` (The array has been searched and the value is not in the array).
+1. Se dopo aver cercato nell'intero array il valore non è presente, restituisce `false` (l'array è stato setacciato e il valore non è nell'array).
 
 Come puoi vedere, stai dimessando successivamente un array, cosa che da l'efficienza log(n). Per questa sfida vogliamo vedere il tuo lavoro - come sei arrivato al valore target... la strada che hai preso!
 
@@ -21,7 +21,7 @@ Come puoi vedere, stai dimessando successivamente un array, cosa che da l'effici
 
 Scrivi una funzione `binarySearch` che implementa un algoritmo di ricerca binaria su un array, restituendo il percorso che hai preso (ogni valore centrale di comparazione) per trovare il target nell'array.
 
-La funzione riceve un array di numeri interi ordinati, e un valore target come input. Restituisce un array contentente in ordine i valori centrali che hai trovato ad ogni dimezzamento dell'array originale fino a che non hai trovato il valore target. Il valore target dovrebbe essere l'ultimo elemento dell'array restituito. If the value is not found, return the string `Value Not Found`.
+La funzione riceve un array di numeri interi ordinati, e un valore target come input. Restituisce un array contentente in ordine i valori centrali che hai trovato ad ogni dimezzamento dell'array originale fino a che non hai trovato il valore target. Il valore target dovrebbe essere l'ultimo elemento dell'array restituito. Se il valore non è stato trovato, restituisci `Value Not Found`.
 
 Per esempio, `binarySearch([1,2,3,4,5,6,7], 5)` dovrebbe restituisce `[4,6,5]`.
 
diff --git a/curriculum/challenges/italian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f42a021625f656101ef93.md b/curriculum/challenges/italian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f42a021625f656101ef93.md
index 666d7a213e5..e08b4a8288d 100644
--- a/curriculum/challenges/italian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f42a021625f656101ef93.md
+++ b/curriculum/challenges/italian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f42a021625f656101ef93.md
@@ -9,7 +9,7 @@ dashedName: step-22
 
 La spaziatura orizzontale tra elementi di uguale importanza può migliorare la leggibilità del testo.
 
-Wrap the text `2/3 cup (55g)` in a `span` element.
+Racchiudi il testo `2/3 cup (55g)` in un elemento `span`.
 
 # --hints--
 
@@ -19,13 +19,13 @@ Dovresti creare un nuovo elemento `span`.
 assert(document.querySelector('span'));
 ```
 
-Your `span` element should have the text `2/3 cup (55g)`.
+L'elemento `span` dovrebbe avere il testo `2/3 cup (55g)`.
 
 ```js
 assert(document.querySelector('span')?.textContent?.trim() === '2/3 cup (55g)');
 ```
 
-Your `p` element should still have the text `Serving size 2/3 cup (55g)`.
+L'elemento `p` dovrebbe ancora avere il testo `Serving size 2/3 cup (55g)`.
 
 ```js
 assert(document.querySelectorAll('p')?.[1]?.innerText === 'Serving size 2/3 cup (55g)');
diff --git a/curriculum/challenges/italian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f4bfb9de4a16703b56eb6.md b/curriculum/challenges/italian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f4bfb9de4a16703b56eb6.md
index 686336b2dca..ac4e9b9ecb6 100644
--- a/curriculum/challenges/italian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f4bfb9de4a16703b56eb6.md
+++ b/curriculum/challenges/italian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f4bfb9de4a16703b56eb6.md
@@ -7,17 +7,17 @@ dashedName: step-23
 
 # --description--
 
-Now we can add the horizontal spacing using `flex`. In your `p` selector, add a `display` property set to `flex` and a `justify-content` property set to `space-between`.
+Ora possiamo aggiungere la spaziatura orizzontale usando `flex`. Nel selettore `p`, aggiungi una proprietà `display` impostata su `flex` e una proprietà `justify-content` impostata su `space-between`.
 
 # --hints--
 
-Your `p` selector should have a `display` property set to `flex`.
+Il selettore `p` dovrebbe avere un proprietà `display` impostata su `flex`.
 
 ```js
 assert(new __helpers.CSSHelp(document).getStyle('p')?.display === 'flex');
 ```
 
-Your `p` selector should have a `justify-content` property set to `space-between`.
+Il selettore `p` dovrebbe avere una proprietà `justify-content` impostata su `space-between`.
 
 ```js
 assert(new __helpers.CSSHelp(document).getStyle('p')?.justifyContent === 'space-between');
diff --git a/curriculum/challenges/italian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f4ec58334106a4170c2a8.md b/curriculum/challenges/italian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f4ec58334106a4170c2a8.md
index cc2ae9155cb..138884799ca 100644
--- a/curriculum/challenges/italian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f4ec58334106a4170c2a8.md
+++ b/curriculum/challenges/italian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f4ec58334106a4170c2a8.md
@@ -7,7 +7,7 @@ dashedName: step-26
 
 # --description--
 
-Create a new `div` element below your `header` element, and give it a `class` attribute set to `divider large`.
+Crea un nuovo elemento `div` sotto l'elemento `header` e assegnagli un attributo `class` con il valore `divider large`.
 
 # --hints--
 
@@ -23,7 +23,7 @@ Il nuovo elemento `div` dovrebbe trovarsi dopo l'elemento `header`.
 assert(document.querySelector('.label')?.lastElementChild?.localName === 'div');
 ```
 
-Your new `div` element should have the `class` attribute set to `divider large`.
+Il nuovo elemento `div` dovrebbe avere l'attributo `class` con il valore `divider large`.
 
 ```js
 const div = document.querySelector('.label')?.lastElementChild;
diff --git a/curriculum/challenges/italian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f4f9e4a40566b776a8f38.md b/curriculum/challenges/italian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f4f9e4a40566b776a8f38.md
index 4fd89a7f1fa..2b86de1ab80 100644
--- a/curriculum/challenges/italian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f4f9e4a40566b776a8f38.md
+++ b/curriculum/challenges/italian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f4f9e4a40566b776a8f38.md
@@ -7,29 +7,29 @@ dashedName: step-27
 
 # --description--
 
-Create a new `.large` selector and give it a `height` property set to `10px`. Also create an `.large, .medium` selector and set the `background-color` property to `black`.
+Crea un nuovo selettore `.large` e assegnagli una proprietà `height` con il valore `10px`. Crea anche un selettore `.large, .medium` e imposta la proprietà `background-color` con il valore `black`.
 
 # --hints--
 
-You should have a new `.large` selector.
+Dovresti avere un nuovo selettore `.large`.
 
 ```js
 assert(new __helpers.CSSHelp(document).getStyle('.large'));
 ```
 
-Your `.large` selector should have a `height` property set to `10px`.
+Il selettore `.large` dovrebbe avere una proprietà `height` con il valore `10px`.
 
 ```js
 assert(new __helpers.CSSHelp(document).getStyle('.large')?.height === '10px');
 ```
 
-You should have a new `.large, .medium` selector.
+Dovresti avere un nuovo selettore `.large, .medium`.
 
 ```js
 assert(new __helpers.CSSHelp(document).getStyle('.large, .medium'));
 ```
 
-Your `.large, .medium` selector should have a `background-color` property set to `black`.
+Il selettore `.large, .medium` dovrebbe avere una proprietà `background-color` con il valore `black`.
 
 ```js
 assert(new __helpers.CSSHelp(document).getStyle('.large, .medium')?.backgroundColor === 'black');
diff --git a/curriculum/challenges/italian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f51257a8a516d80b6c743.md b/curriculum/challenges/italian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f51257a8a516d80b6c743.md
index 8cd7d290afa..a6c1f439987 100644
--- a/curriculum/challenges/italian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f51257a8a516d80b6c743.md
+++ b/curriculum/challenges/italian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f51257a8a516d80b6c743.md
@@ -7,7 +7,7 @@ dashedName: step-29
 
 # --description--
 
-Create a new `div` below your `.large` element and give it a `class` attribute set to `calories-info`.
+Crea un nuovo `div` sotto l'elemento `.large` e assegnagli un attributo `class` con il valore `calories-info`.
 
 # --hints--
 
@@ -23,7 +23,7 @@ Il nuovo elemento `div` dovrebbe avere un attributo `class` con il valore `calor
 assert(document.querySelector('.label')?.lastElementChild?.classList?.contains('calories-info'));
 ```
 
-Your new `div` should come after the `.large` element.
+Il nuovo `div` dovrebbe trovarsi dopo l'elemento `.large`.
 
 ```js
 assert(document.querySelector('.label')?.lastElementChild?.previousElementSibling?.classList?.contains('large'));
diff --git a/curriculum/challenges/italian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f522dea4f776f64dc3e91.md b/curriculum/challenges/italian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f522dea4f776f64dc3e91.md
index 7e60c233ce8..9c54ecb2255 100644
--- a/curriculum/challenges/italian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f522dea4f776f64dc3e91.md
+++ b/curriculum/challenges/italian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f522dea4f776f64dc3e91.md
@@ -9,17 +9,17 @@ dashedName: step-31
 
 L'unità `rem` sta per `root em` ed è relativa alla dimensione del carattere dell'elemento `html`.
 
-Create an `.small-text` selector and set the `font-size` to `0.85rem`, which would calculate to be roughly `13.6px` (remember that you set your `html` to have a `font-size` of `16px`).
+Crea un selettore `.small-text` e imposta la proprietà `font-size` a `0.85rem`, approssimativamente equivalenti a `13.6px` (ricorda che hai dato al tuo `html` una proprietà `font-size` di `16px`).
 
 # --hints--
 
-You should have an `.small-text` selector.
+Dovresti avere un selettore `.small-text`.
 
 ```js
 assert(new __helpers.CSSHelp(document).getStyle('.small-text'));
 ```
 
-Your `.small-text` selector should have a `font-size` property set to `0.85rem`.
+Il selettore `.small-text` dovrebbe avere una proprietà `font-size` con il valore `0.85rem`.
 
 ```js
 assert(new __helpers.CSSHelp(document).getStyle('.small-text')?.fontSize === '0.85rem');
diff --git a/curriculum/challenges/italian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f5486b8fd4b71633f69b0.md b/curriculum/challenges/italian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f5486b8fd4b71633f69b0.md
index 94386610197..a0f89c5dca0 100644
--- a/curriculum/challenges/italian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f5486b8fd4b71633f69b0.md
+++ b/curriculum/challenges/italian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f5486b8fd4b71633f69b0.md
@@ -7,35 +7,35 @@ dashedName: step-33
 
 # --description--
 
-Below your `.small-text` element, create a new `p` element with the text `Calories`. Also below the `.left-container` element, create a new `span` element with the text `230`.
+Sotto l'elemento `.small-text`, crea un nuovo elemento `p` con il testo `Calories`. Inoltre, sotto l'elemento `.left-container`, crea un nuovo elemento `span` con il testo `230`.
 
 # --hints--
 
-You should have a new `p` element within your `.calories-info` element.
+Dovresti avere un nuovo elemento `p` all'interno dell'elemento `.calories-info`.
 
 ```js
 assert(document.querySelector('.calories-info')?.querySelector('p'))
 ```
 
-You should have a new `span` element within your `.calories-info` element.
+Dovresti avere un nuovo elemento `span` all'interno dell'elemento `.calories-info`.
 
 ```js
 assert(document.querySelector('.calories-info')?.querySelector('span'))
 ```
 
-Your `p` element should come after your `.small-text` element.
+L'elemento `p` dovrebbe trovarsi dopo l'elemento `.small-text`.
 
 ```js
 assert(document.querySelector('.small-text')?.nextElementSibling?.localName === 'p');
 ```
 
-Your `p` element should have the text `Calories`.
+L'elemento `p` dovrebbe avere il testo `Calories`.
 
 ```js
 assert(document.querySelector('.left-container')?.lastElementChild?.innerText === 'Calories');
 ```
 
-Your `span` element should come after your `.left-container` element.
+L'elemento `span` dovrebbe trovarsi dopo l'elemento `.left-container`.
 
 ```js
 assert(document.querySelector('.left-container')?.nextElementSibling?.localName ==='span');
diff --git a/curriculum/challenges/italian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f5af373a68e744a3c5a76.md b/curriculum/challenges/italian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f5af373a68e744a3c5a76.md
index 36cc5dc44de..4eb37413874 100644
--- a/curriculum/challenges/italian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f5af373a68e744a3c5a76.md
+++ b/curriculum/challenges/italian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f5af373a68e744a3c5a76.md
@@ -7,7 +7,7 @@ dashedName: step-36
 
 # --description--
 
-Create a `.calories-info span` selector, set its `font-size` to `2.4em` and `font-weight` to `700`.
+Create un selettore `.calories-info span` e imposta `font-size` su `2.4em` e `font-weight` su `700`.
 
 # --hints--
 
@@ -17,13 +17,13 @@ Dovresti creare un selettore `.calories-info span`.
 assert(new __helpers.CSSHelp(document).getStyle('.calories-info span'));
 ```
 
-Your `.calories-info span` selector should have a `font-size` property set to `2.4em`.
+Il selettore `.calories-info span` dovrebbe avere una proprietà `font-size` con il valore `2.4em`.
 
 ```js
 assert(new __helpers.CSSHelp(document).getStyle('.calories-info span')?.fontSize === '2.4em');
 ```
 
-Your `.calories-info span` selector should have a `font-weight` property set to `700`.
+Il selettore `.calories-info span` dovrebbe avere una proprietà `font-weight` con il valore `700`.
 
 ```js
 assert(new __helpers.CSSHelp(document).getStyle('.calories-info span')?.fontWeight === '700');
diff --git a/curriculum/challenges/italian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f5fd85d0062761f288364.md b/curriculum/challenges/italian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f5fd85d0062761f288364.md
index 69a475b6581..e56b5e51d9e 100644
--- a/curriculum/challenges/italian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f5fd85d0062761f288364.md
+++ b/curriculum/challenges/italian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f5fd85d0062761f288364.md
@@ -9,11 +9,11 @@ dashedName: step-37
 
 La tipografia è spesso più arte che scienza. Potrebbe essere necessario modificare cose come l'allineamento fino a quando non sembra corretto.
 
-Give your `.calories-info span` selector a `margin` set to `-7px -2px`. In questo modo, sposterai il testo `230` nella posizione giusta.
+Assegna al selettore `.calories-info span` una proprietà `margin` con il valore `-7px -2px`. In questo modo, sposterai il testo `230` nella posizione giusta.
 
 # --hints--
 
-Your `.calories-info span` selector should have a `margin` set to `-7px -2px`.
+Il selettore `.calories-info span` dovrebbe avere una proprietà `margin` con il valore `-7px -2px`.
 
 ```js
 assert(new __helpers.CSSHelp(document).getStyle('.calories-info span')?.margin === '-7px -2px');
diff --git a/curriculum/challenges/italian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f671b6d1919792745aa5d.md b/curriculum/challenges/italian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f671b6d1919792745aa5d.md
index 074dcc33c06..73f6d1a6934 100644
--- a/curriculum/challenges/italian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f671b6d1919792745aa5d.md
+++ b/curriculum/challenges/italian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f671b6d1919792745aa5d.md
@@ -7,11 +7,11 @@ dashedName: step-40
 
 # --description--
 
-Create a new `div` element below your `.medium` element. Give it a `class` attribute set to `daily-value small-text`. Within this new `div`, add a `p` element with the text `% Daily Value *`, and set the `class` attribute to `bold right`.
+Crea un nuovo elemento `div` sotto l'elemento `.medium`. Assegnagli un attributo `class` impostato su `daily-value small-text`. All'interno di questo nuovo `div`, crea un elemento `p` con il testo `% Daily Value *` e imposta l'attributo `class` con il valore `bold right`.
 
 # --hints--
 
-You should create a new `div` element after your `.medium` element.
+Dovresti creare un nuovo elemento `div` dopo l'elemento `.medium`.
 
 ```js
 assert(document.querySelector('.label')?.lastElementChild?.localName === 'div');
@@ -19,7 +19,7 @@ assert(document.querySelector('.label')?.lastElementChild?.previousElementSiblin
 assert(document.querySelector('.label')?.lastElementChild?.previousElementSibling?.classList?.contains('medium'));
 ```
 
-Your new `div` should have a `class` attribute set to `daily-value small-text`.
+Il nuovo `div` dovrebbe avere un attributo `class` con il valore `daily-value small-text`.
 
 ```js
 assert(document.querySelector('.label')?.lastElementChild?.classList?.contains('daily-value'));
@@ -38,7 +38,7 @@ Il nuovo elemento `p` dovrebbe avere il testo `% Daily Value *`.
 assert(document.querySelector('.label')?.lastElementChild?.firstElementChild?.textContent === '% Daily Value *');
 ```
 
-Your new `p` element should have a `class` attribute set to `bold right`.
+Il nuovo elemento `p` dovrebbe avere un attributo `class` con il valore `bold right`.
 
 ```js
 assert(document.querySelector('.label')?.lastElementChild?.firstElementChild?.classList?.contains('bold'));
diff --git a/curriculum/challenges/italian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f6b2d164f81809efd9bdc.md b/curriculum/challenges/italian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f6b2d164f81809efd9bdc.md
index e04229d7ae4..bf1bccaa3a8 100644
--- a/curriculum/challenges/italian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f6b2d164f81809efd9bdc.md
+++ b/curriculum/challenges/italian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f6b2d164f81809efd9bdc.md
@@ -7,7 +7,7 @@ dashedName: step-43
 
 # --description--
 
-Dopo l'ultimo elemento `.divider`, crea un elemento `p` e assegnagli il testo `Total Fat 8g 10%`. Avvolgi `Total Fat` in un elemento `span` con l'attributo `class` con il valore `bold`. Wrap `10%` in another `span` element with the `class` set to `bold`. Also wrap the words `Total Fat 8g` in an additional `span` element for alignment.
+Dopo l'ultimo elemento `.divider`, crea un elemento `p` e assegnagli il testo `Total Fat 8g 10%`. Avvolgi `Total Fat` in un elemento `span` con l'attributo `class` con il valore `bold`. Racchiudi `10%` in un altro elemento `span` con `class` impostata su `bold`. Inoltre racchiudi il testo `Total Fat 8g` in un elemento `span` aggiuntivo per l'allineamento.
 
 # --hints--
 
@@ -23,37 +23,37 @@ Il nuovo elemento `p` dovrebbe avere il testo `Total Fat 8g 10%`.
 assert(document.querySelector('.daily-value.small-text')?.lastElementChild?.innerText?.match(/Total Fat[\s|\n]+8g[\s|\n]+10%/));
 ```
 
-Your `p` element should have three `span` elements.
+L'elemento `p` dovrebbe avere tre elementi `span`.
 
 ```js
 assert(document.querySelector('.daily-value.small-text')?.lastElementChild?.querySelectorAll('span')?.length === 3);
 ```
 
-One `span` element should wrap the text `Total Fat`.
+Un elemento `span` dovrebbe racchiudere il testo `Total Fat`.
 
 ```js
 assert(document.querySelector('.daily-value.small-text')?.lastElementChild?.querySelector('span > span')?.innerText === 'Total Fat');
 ```
 
-The `span` element around `Total Fat` should have the `class` set to `bold`.
+L'elemento `span` attorno a `Total Fat` dovrebbe avere l'attributo `class` impostato su `bold`.
 
 ```js
 assert(document.querySelector('.daily-value.small-text')?.lastElementChild?.querySelector('span > span')?.className === 'bold');
 ```
 
-A `span` element should wrap the text `10%`.
+Un elemento `span` dovrebbe racchiudere il testo `10%`.
 
 ```js
 assert(document.querySelector('.daily-value.small-text')?.lastElementChild?.querySelector('span + span')?.innerText === '10%');
 ```
 
-The `span` element around `10%` should have the `class` set to `bold`.
+L'elemento `span` attorno a `10%` dovrebbe avere l'attributo `class` impostato su `bold`.
 
 ```js
 assert(document.querySelector('.daily-value.small-text')?.lastElementChild?.querySelectorAll('span')?.[1]?.className === 'bold');
 ```
 
-A `span` element should have the text `Total Fat 8g`.
+Un elemento `span` dovrebbe avere il testo `Total Fat 8g`.
 
 ```js
 assert(document.querySelector('.daily-value.small-text')?.lastElementChild?.innerText?.match(/Total Fat[\s|\n]+8g/));
diff --git a/curriculum/challenges/italian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f7bc680f7168ea01ebf99.md b/curriculum/challenges/italian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f7bc680f7168ea01ebf99.md
index 8c1cfd3bec6..5f14975f8cf 100644
--- a/curriculum/challenges/italian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f7bc680f7168ea01ebf99.md
+++ b/curriculum/challenges/italian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f7bc680f7168ea01ebf99.md
@@ -13,7 +13,7 @@ Il primo elemento `.no-divider` ha un `.divider` dopo di esso. Crea un altro `.d
 
 # --hints--
 
-You should create a new `div` at the end of your `.daily-value` element.
+Dovresti creare un nuovo `div` alla fine dell'elemento `.daily-value`.
 
 ```js
 assert(document.querySelector('.daily-value.small-text')?.lastElementChild?.localName === 'div');
diff --git a/curriculum/challenges/italian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f7e7281626a92bbd62da8.md b/curriculum/challenges/italian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f7e7281626a92bbd62da8.md
index ff01c7e9009..1c89356cd4f 100644
--- a/curriculum/challenges/italian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f7e7281626a92bbd62da8.md
+++ b/curriculum/challenges/italian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f7e7281626a92bbd62da8.md
@@ -7,11 +7,11 @@ dashedName: step-54
 
 # --description--
 
-Sotto l'ultimo elemento `p`, crea un altro elemento `p` con il testo `Sodium 160mg 7%`. Atorrno al testo `Sodium`, crea un elemento `span` con un attributo `class` impostato su `bold`. Wrap the `7%` text in another `span` element with the `class` set to `bold`. Also add an additional `span` element around `Sodium 160mg` for aligning it correctly.
+Sotto l'ultimo elemento `p`, crea un altro elemento `p` con il testo `Sodium 160mg 7%`. Atorrno al testo `Sodium`, crea un elemento `span` con un attributo `class` impostato su `bold`. Racchiudi il testo `7%` in un altro elemento `span` con l'attributo `class` impostato su `bold`. Aggiungi anche un altro elemento `span` attorno a `Sodium 160mg` per allinearlo correttamente.
 
 # --hints--
 
-You should create a new `p` element at the end of your `.daily-value` element.
+Dovresti creare un nuovo elemento `p` alla fine dell'elemento `.daily-value`.
 
 ```js
 assert(document.querySelector('.daily-value.small-text')?.lastElementChild?.localName === 'p');
@@ -23,37 +23,37 @@ Il nuovo elemento `p` dovrebbe avere il testo `Sodium 160mg 7%`.
 assert(document.querySelector('.daily-value.small-text')?.lastElementChild?.innerText?.match(/Sodium[\s|\n]160mg[\s|\n]+7%/));
 ```
 
-Your new `p` element should have three `span` elements.
+Il nuovo elemento `p` dovrebbe avere tre elementi `span`.
 
 ```js
 assert(document.querySelector('.daily-value.small-text')?.lastElementChild?.querySelectorAll('span')?.length === 3);
 ```
 
-A `span` element should wrap the text `Sodium 360mg`.
+Un elemento `span` dovrebbe racchiudere il testo `Sodium 360mg`.
 
 ```js
 assert(document.querySelector('.daily-value.small-text')?.lastElementChild?.firstElementChild?.innerText?.match(/Sodium[\s|\n]160mg/));
 ```
 
-A `span` element should wrap the text `Sodium`.
+Un elemento `span` dovrebbe racchiudere il testo `Sodium`.
 
 ```js
 assert(document.querySelector('.daily-value.small-text')?.lastElementChild?.firstElementChild?.firstElementChild?.innerText === "Sodium");
 ```
 
-The `span` around `Sodium` should have the `class` attribute set to `bold`.
+L'elemento `span` attorno a `Sodium` dovrebbe avere l'attributo `class` impostato su `bold`.
 
 ```js
 assert(document.querySelector('.daily-value.small-text')?.lastElementChild?.firstElementChild?.firstElementChild?.classList?.contains('bold'));
 ```
 
-A `span` element should wrap the text `7%`.
+Un elemento `span` dovrebbe racchiudere il testo `7%`.
 
 ```js
 assert(document.querySelector('.daily-value.small-text')?.lastElementChild?.lastElementChild?.innerText === '7%');
 ```
 
-The `span` element around `7%` should have the `class` attribute set to `bold`.
+L'elemento `span` attorno a `7%` dovrebbe avere l'attributo `class` impostato su `bold`.
 
 ```js
 assert(document.querySelector('.daily-value.small-text')?.lastElementChild?.lastElementChild?.classList?.contains('bold'));
diff --git a/curriculum/challenges/italian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f7ecb09de9a938ef94756.md b/curriculum/challenges/italian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f7ecb09de9a938ef94756.md
index 790ffe63c98..6aa1eb7c1c3 100644
--- a/curriculum/challenges/italian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f7ecb09de9a938ef94756.md
+++ b/curriculum/challenges/italian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f7ecb09de9a938ef94756.md
@@ -7,11 +7,11 @@ dashedName: step-55
 
 # --description--
 
-Aggiungi un altro elemento `p` con il testo `Total Carbohydrate 37g 13%`. Like before, use `span` elements to make the text `Total Carbohydrate` and `13%` bold. Also add an additional `span` element to wrap the `Total Carbohydrate 37g` text in a span element so to have it aligned to the left, and `13%` to the right.
+Aggiungi un altro elemento `p` con il testo `Total Carbohydrate 37g 13%`. Come prima, usa gli elementi `span` per rendere il testo `Total Carbohydrate` e `13%` in grassetto. Aggiungi un altro elemento `span` per racchiudere `Total Carbohydrate 37g`, allineare il testo a sinistra e `13%` a destra.
 
 # --hints--
 
-You should create a new `p` element at the end of your `.daily-value` element.
+Dovresti creare un nuovo elemento `p` alla fine dell'elemento `.daily-value`.
 
 ```js
 assert(document.querySelector('.daily-value.small-text')?.lastElementChild?.localName === 'p');
@@ -23,43 +23,43 @@ Il nuovo elemento `p` dovrebbe avere il testo `Total Carbohydrate 37g 13%`.
 assert(document.querySelector('.daily-value.small-text')?.lastElementChild?.innerText?.match(/Total Carbohydrate[\s|\n]+37g[\s|\n]+13%/));
 ```
 
-Your new `p` element should have three `span` elements.
+Il nuovo elemento `p` dovrebbe avere tre elementi `span`.
 
 ```js
 assert(document.querySelector('.daily-value.small-text')?.lastElementChild?.querySelectorAll('span')?.length === 3);
 ```
 
-One `span` element should wrap the text `Total Carbohydrate 37g`.
+Un elemento `span` dovrebbe racchiudere il testo `Total Carbohydrate 37g`.
 
 ```js
 assert(document.querySelector('.daily-value.small-text')?.lastElementChild?.firstElementChild?.innerText?.match(/Total Carbohydrate[\s|\n]+37g/));
 ```
 
-One `span` element should wrap the text `Total Carbohydrate`.
+Un elemento `span` dovrebbe racchiudere il testo `Total Carbohydrate`.
 
 ```js
 assert(document.querySelector('.daily-value.small-text')?.lastElementChild?.firstElementChild?.firstElementChild?.innerText === 'Total Carbohydrate');
 ```
 
-The `span` element around `Total Carbohydrate` should have the `class` attribute set to `bold`.
+L'elemento `span` attorno a `Total Carbohydrate` dovrebbe avere l'attributo `class` impostato su `bold`.
 
 ```js
 assert(document.querySelector('.daily-value.small-text')?.lastElementChild?.firstElementChild?.firstElementChild?.classList?.contains('bold'));
 ```
 
-A `span` element should wrap the text `13%`.
+Un elemento `span` dovrebbe racchiudere il testo `13%`.
 
 ```js
 assert(document.querySelector('.daily-value.small-text')?.lastElementChild?.lastElementChild?.innerText === '13%');
 ```
 
-The `span` element around `13%` should have the `class` attribute set to `bold`.
+L'elemento `span` attorno a `13%` dovrebbe avere l'attributo `class` impostato su `bold`.
 
 ```js
 assert(document.querySelector('.daily-value.small-text')?.lastElementChild?.lastElementChild?.classList?.contains('bold'));
 ```
 
-Your second `span` element should wrap the text `13%`.
+Il secondo elemento `span` dovrebbe racchiudere il testo `13%`.
 
 ```js
 assert(document.querySelector('.daily-value.small-text')?.lastElementChild?.lastElementChild?.innerText === '13%');
diff --git a/curriculum/challenges/italian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f808d85793195b0f53be9.md b/curriculum/challenges/italian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f808d85793195b0f53be9.md
index 8b132a13fba..45615569f71 100644
--- a/curriculum/challenges/italian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f808d85793195b0f53be9.md
+++ b/curriculum/challenges/italian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f808d85793195b0f53be9.md
@@ -11,7 +11,7 @@ Crea un altro elemento `p` dopo l'ultimo `.divider` e dagli il testo `Total Suga
 
 # --hints--
 
-You should create a new `p` and `div` element at the end of your `.daily-value` element.
+Dovresti creare un nuovo elemento `p` e un nuovo `div` alla fine dell'elemento `.daily-value`.
 
 ```js
 assert(document.querySelector('.daily-value.small-text')?.lastElementChild?.previousElementSibling?.localName === 'p');
diff --git a/curriculum/challenges/italian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f83ef928ec9982b785b6a.md b/curriculum/challenges/italian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f83ef928ec9982b785b6a.md
index 370fd147adf..cf186398ea3 100644
--- a/curriculum/challenges/italian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f83ef928ec9982b785b6a.md
+++ b/curriculum/challenges/italian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f83ef928ec9982b785b6a.md
@@ -7,17 +7,17 @@ dashedName: step-59
 
 # --description--
 
-Create a `.double-indent` selector and give it a left margin of `2em`.
+Crea un selettore `.double-indent` e dagli un margine sinistro di `2em`.
 
 # --hints--
 
-You should have a new `.double-indent` selector.
+Dovresti avere un nuovo selettore `.double-indent`.
 
 ```js
 assert(new __helpers.CSSHelp(document).getStyle('.double-indent'));
 ```
 
-Your `.double-indent` selector should have a `margin-left` property set to `2em`.
+Il selettore `.double-indent` dovrebbe avere una proprietà `margin-left` con il valore `2em`.
 
 ```js
 assert(new __helpers.CSSHelp(document).getStyle('.double-indent')?.marginLeft === '2em');
diff --git a/curriculum/challenges/italian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f89e055040ba294719d2f.md b/curriculum/challenges/italian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f89e055040ba294719d2f.md
index 65775002b07..1e82d95e280 100644
--- a/curriculum/challenges/italian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f89e055040ba294719d2f.md
+++ b/curriculum/challenges/italian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f89e055040ba294719d2f.md
@@ -9,29 +9,29 @@ dashedName: step-62
 
 Crea un altro elemento `p` sotto il divider grande. Dai all'elemento `p` il testo `Vitamin D 2mcg 10%`.
 
-The `p` element contains only text, you can wrap the percentage in a `span` element so that it is considered a separate entity from the rest of the text, and it's moved to the right.
+L'elemento `p` contiene solo testo, puoi racchiudere la percentuale in un elemento `span` in modo che sia considerato un'entità separata dal resto del testo e venga spostato a destra.
 
 # --hints--
 
-You should create a new `p` element at the end of your `.daily-value` element.
+Dovresti creare un nuovo elemento `p` alla fine dell'elemento `.daily-value`.
 
 ```js
 assert(document.querySelector('.daily-value.small-text')?.lastElementChild?.localName === 'p');
 ```
 
-Your new `p` element should have the text `Vitamin D 2mcg 10%`.
+Il nuovo elemento `p` dovrebbe avere il testo `Vitamin D 2mcg 10%`.
 
 ```js
 assert(document.querySelector('.daily-value.small-text')?.lastElementChild?.innerText?.match(/Vitamin D 2mcg[\s|\n]+10%/));
 ```
 
-Your new `p` element should have a `span` element.
+Il nuovo elemento `p` dovrebbe avere un elemento `span`.
 
 ```js
 assert(document.querySelector('.daily-value.small-text')?.lastElementChild?.querySelectorAll('span')?.length === 1);
 ```
 
-Your `span` element should not be bold.
+L'elemento `span` non dovrebbe essere in grassetto.
 
 ```js
 assert(!document.querySelector('.daily-value.small-text')?.lastElementChild?.querySelector('span')?.classList?.contains('bold'));
diff --git a/curriculum/challenges/italian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f8bfe0f30a1a3c340356b.md b/curriculum/challenges/italian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f8bfe0f30a1a3c340356b.md
index e411e34de8b..d4c61933c43 100644
--- a/curriculum/challenges/italian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f8bfe0f30a1a3c340356b.md
+++ b/curriculum/challenges/italian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f8bfe0f30a1a3c340356b.md
@@ -11,7 +11,7 @@ Crea un altro elemento `p` e dagli il testo `Calcium 260mg 20%`. Allinea il `20%
 
 # --hints--
 
-You should create two new `p` elements at the end of your `.daily-value` element.
+Dovresti creare due nuovi elementi `p` alla fine dell'elemento `.daily-value`.
 
 ```js
 assert(document.querySelector('.daily-value.small-text')?.lastElementChild?.localName === 'p');
@@ -30,7 +30,7 @@ Il primo nuovo elemento `p` dovrebbe avere un elemento `span`.
 assert(document.querySelector('.daily-value.small-text')?.lastElementChild?.previousElementSibling?.firstElementChild?.localName === 'span');
 ```
 
-Your first `span` element not be bold.
+Your first `span` element should not be bold.
 
 ```js
 assert(!document.querySelector('.daily-value.small-text')?.lastElementChild?.previousElementSibling?.firstElementChild?.classList?.contains('bold'));
@@ -54,7 +54,7 @@ Il secondo nuovo elemento `p` dovrebbe avere un elemento `span`.
 assert(document.querySelector('.daily-value.small-text')?.lastElementChild?.firstElementChild?.localName === 'span');
 ```
 
-Your second `span` element should not be bold.
+Il secondo elemento `span` non dovrebbe essere in grassetto.
 
 ```js
 assert(!document.querySelector('.daily-value.small-text')?.lastElementChild?.firstElementChild?.classList?.contains('bold'));
diff --git a/curriculum/challenges/italian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/635bde33c91c80540eae239b.md b/curriculum/challenges/italian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/635bde33c91c80540eae239b.md
index d9073bf18ba..304deebf5bd 100644
--- a/curriculum/challenges/italian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/635bde33c91c80540eae239b.md
+++ b/curriculum/challenges/italian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/635bde33c91c80540eae239b.md
@@ -7,11 +7,11 @@ dashedName: step-41
 
 # --description--
 
-The text `* Daily Value %` should be aligned to the right. Create a `.right` selector and use the `justify-content` property to do it.
+Il testo `* Daily Value %` dovrebbe essere allineato a destra. Crea un selettore `.right` e usa la proprietà `justify-content` per farlo.
 
 # --hints--
 
-You should have a `.right` selector.
+Dovresti avere un selettore `.right`.
 
 ```js
 const hasRight = new __helpers.CSSHelp(document).getStyle('.right');
@@ -19,7 +19,7 @@ assert(hasRight);
 
 ```
 
-The `.right` selector should have the `justify-content` property set to `flex-end`.
+Il selettore `.right` dovrebbe avere la proprietà `justify-content` impostata su `flex-end`.
 
 ```js
 const rightJustifyContent = new __helpers.CSSHelp(document).getStyle('.right')?.getPropertyValue('justify-content');
diff --git a/curriculum/challenges/italian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/6395d33ab5d91bf317107c48.md b/curriculum/challenges/italian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/6395d33ab5d91bf317107c48.md
index e6f009b7e04..4200d051a93 100644
--- a/curriculum/challenges/italian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/6395d33ab5d91bf317107c48.md
+++ b/curriculum/challenges/italian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/6395d33ab5d91bf317107c48.md
@@ -7,17 +7,17 @@ dashedName: step-32
 
 # --description--
 
-Create a `.calories-info h2` selector and remove all margins.
+Crea un selettore `.calories-info h2` e rimuovi tutti i margini.
 
 # --hints--
 
-Create a `.calories-info h2` selector.
+Crea un selettore `.calories-info h2`.
 
 ```js
 assert(new __helpers.CSSHelp(document).getStyle('.calories-info h2'));
 ```
 
-Your `.calories-info h2` selector should have a `margin` set to `0`.
+Il selettore `.calories-info h2` dovrebbe avere una proprietà `margin` con il valore `0`.
 
 ```js
 assert(new __helpers.CSSHelp(document).getStyle('.calories-info h2')?.margin === '0px');
diff --git a/curriculum/challenges/italian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/6396e33fe478dd264ebbf278.md b/curriculum/challenges/italian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/6396e33fe478dd264ebbf278.md
index 6a2dbb37aa9..477f8d41d38 100644
--- a/curriculum/challenges/italian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/6396e33fe478dd264ebbf278.md
+++ b/curriculum/challenges/italian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/6396e33fe478dd264ebbf278.md
@@ -7,29 +7,29 @@ dashedName: step-34
 
 # --description--
 
-Create a new `.calories-info` selector and give it a `display` property set to `flex`. Also give it a `justify-content` property set to `space-between` and `align-items` property set to `flex-end`.
+Crea un nuovo selettore `.calories-info` e assegnagli una proprietà `display` con il valore `flex`. Dagli anche una proprietà `justify-content` impostata su `space-between` e una proprietà `align-items` impostata su `flex-end`.
 
 # --hints--
 
-You should create a `.calories-info` selector.
+Dovresti creare un selettore `.calories-info`.
 
 ```js
 assert(new __helpers.CSSHelp(document).getStyle('.calories-info'));
 ```
 
-Your `.calories-info` selector should have a `display` property set to `flex`.
+Il selettore `.calories-info` dovrebbe avere una proprietà `display` con il valore `flex`.
 
 ```js
 assert(new __helpers.CSSHelp(document).getStyle('.calories-info')?.display === 'flex');
 ```
 
-Your `.calories-info` selector should have a `justify-content` property set to `space-between`.
+Il selettore `.calories-info` dovrebbe avere una proprietà `justify-content` con il valore `space-between`.
 
 ```js
 assert(new __helpers.CSSHelp(document).getStyle('.calories-info')?.justifyContent === 'space-between');
 ```
 
-Your `.calories-info` selector should have a `align-items` property set to `flex-end`.
+Il selettore `.calories-info` dovrebbe avere una proprietà `align-items` impostata su `flex-end`.
 
 ```js
 assert(new __helpers.CSSHelp(document).getStyle('.calories-info')?.alignItems === 'flex-end');
diff --git a/curriculum/challenges/italian/15-javascript-algorithms-and-data-structures-22/learn-basic-javascript-by-building-a-role-playing-game/62a8b6536156c51500739b41.md b/curriculum/challenges/italian/15-javascript-algorithms-and-data-structures-22/learn-basic-javascript-by-building-a-role-playing-game/62a8b6536156c51500739b41.md
index 73e6afddc6f..9ab6465bf24 100644
--- a/curriculum/challenges/italian/15-javascript-algorithms-and-data-structures-22/learn-basic-javascript-by-building-a-role-playing-game/62a8b6536156c51500739b41.md
+++ b/curriculum/challenges/italian/15-javascript-algorithms-and-data-structures-22/learn-basic-javascript-by-building-a-role-playing-game/62a8b6536156c51500739b41.md
@@ -7,7 +7,7 @@ dashedName: step-62
 
 # --description--
 
-The `locations` array contains two locations: the `town square` and the `store`. Currently you are passing that entire array into the `update` function. Passa soltanto il primo elemento dell'array `locations` aggiungendo `[0]` alla fine della variabile. Ad esempio: `myFunction(arg[0]);`.
+L'array `locations` contiene due location: `town square` e `store`. Attualmente stai passando l'intero array nella funzione `update`. Passa soltanto il primo elemento dell'array `locations` aggiungendo `[0]` alla fine della variabile. Ad esempio: `myFunction(arg[0]);`.
 
 Questa notazione si chiama <dfn>notazione a parentesi</dfn>. I valori in un array sono accessibili tramite il loro indice. Gli indici sono valori numerici e partono da 0 - questo sistema è detto a base zero. `arg[0]` è il primo elemento nell'array `arg`.
 
diff --git a/curriculum/challenges/japanese/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f8bfe0f30a1a3c340356b.md b/curriculum/challenges/japanese/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f8bfe0f30a1a3c340356b.md
index a80b55e466e..80e5153eb3f 100644
--- a/curriculum/challenges/japanese/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f8bfe0f30a1a3c340356b.md
+++ b/curriculum/challenges/japanese/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f8bfe0f30a1a3c340356b.md
@@ -30,7 +30,7 @@ assert(document.querySelector('.daily-value.small-text')?.lastElementChild?.prev
 assert(document.querySelector('.daily-value.small-text')?.lastElementChild?.previousElementSibling?.firstElementChild?.localName === 'span');
 ```
 
-Your first `span` element not be bold.
+Your first `span` element should not be bold.
 
 ```js
 assert(!document.querySelector('.daily-value.small-text')?.lastElementChild?.previousElementSibling?.firstElementChild?.classList?.contains('bold'));
diff --git a/curriculum/challenges/portuguese/08-data-analysis-with-python/data-analysis-with-python-projects/sea-level-predictor.md b/curriculum/challenges/portuguese/08-data-analysis-with-python/data-analysis-with-python-projects/sea-level-predictor.md
index 2fd1233120f..35448744a49 100644
--- a/curriculum/challenges/portuguese/08-data-analysis-with-python/data-analysis-with-python-projects/sea-level-predictor.md
+++ b/curriculum/challenges/portuguese/08-data-analysis-with-python/data-analysis-with-python-projects/sea-level-predictor.md
@@ -28,7 +28,7 @@ Você analisará um dataset da mudança média do nível do mar global desde 188
 Use os dados para completar as seguintes tarefas:
 
 - Use o Pandas para importar os dados de `epa-sea-level.csv`.
-- Use matplotlib to create a scatter plot using the `Year` column as the x-axis and the `CSIRO Adjusted Sea Level` column as the y-axis.
+- Use a matplotlib para criar um diagrama de dispersão usando a coluna `Year` como eixo x e a coluna `CSIRO Adjusted Sea Level` (Nível do mar ajustado) como o eixo y.
 - Use a função `linregress` do `scipy.stats` para obter o coeficiente angular e o ponto de interceptação da linha de y do melhor ajuste. Trace a linha de melhor ajuste na parte superior do diagrama de dispersão. Faça a linha passar pelo ano 2050 para prever o aumento do nível do mar em 2050.
 - Trace uma nova linha do melhor ajuste utilizando apenas os dados do ano 2000 ao longo do último ano no dataset. Faça com que a linha passe também pelo ano 2050 para prever o aumento do nível do mar em 2050 se a taxa de crescimento continuar como está desde o ano 2000.
 - O rótulo de x deve ser `Year` e o rótulo de y deve ser `Sea Level (inches)` (Nível do mar, em polegadas), e o título deve ser `Rise in Sea Level` (Aumento do nível do mar).
diff --git a/curriculum/challenges/portuguese/10-coding-interview-prep/algorithms/implement-binary-search.md b/curriculum/challenges/portuguese/10-coding-interview-prep/algorithms/implement-binary-search.md
index 9320f642a61..8d7fdddedd1 100644
--- a/curriculum/challenges/portuguese/10-coding-interview-prep/algorithms/implement-binary-search.md
+++ b/curriculum/challenges/portuguese/10-coding-interview-prep/algorithms/implement-binary-search.md
@@ -10,10 +10,10 @@ dashedName: implement-binary-search
 
 A busca binária é um algoritmo de eficiência **O(log(n))** para procurar um elemento em um array ordenado. Ele opera usando as seguintes etapas:
 
-1. Encontrar o `value` do meio de um array ordenado. If `value == target` return `true` (The value has been found and the search is complete).
+1. Encontrar o `value` do meio de um array ordenado. Se `value == target` retornou `true` (O valor foi encontrado e a pesquisa está completa).
 1. Se `value < target`, procurar à direita do meio do array na próxima comparação.
 1. Se `value > target`, procurar à esquerda do meio do array na próxima comparação.
-1. If after searching the whole array the value is not present, return `false` (The array has been searched and the value is not in the array).
+1. Se, depois de pesquisar no array inteiro, o valor não está presente, retorne `false` (O array foi pesquisado e o valor não está no array).
 
 Como você pode ver, você está dividindo um array para metade com sucesso, o que traz a eficiência log(n). Para este desafio, queremos que você mostre seu trabalho - como você conseguiu o valor de destino... o caminho que você fez!
 
@@ -21,7 +21,7 @@ Como você pode ver, você está dividindo um array para metade com sucesso, o q
 
 Escreva uma função `binarySearch` que implemente o algoritmo de busca binária em um array, retornando o caminho que você utilizou (cada comparação com o valor do meio) para encontrar o destino em um array.
 
-A função recebe um array ordenado de números inteiros e um valor de destino como entrada. Ele retorna um array contendo (em ordem) o valor do meio que você encontrou a cada divisão do array original até encontrar o valor de destino. O valor de destino deve ser o último elemento do array retornado. If the value is not found, return the string `Value Not Found`.
+A função recebe um array ordenado de números inteiros e um valor de destino como entrada. Ele retorna um array contendo (em ordem) o valor do meio que você encontrou a cada divisão do array original até encontrar o valor de destino. O valor de destino deve ser o último elemento do array retornado. Se o valor não for encontrado, retorne a string `Value Not Found`.
 
 Por exemplo, `binarySearch([1,2,3,4,5,6,7], 5)` retornará `[4,6,5]`.
 
diff --git a/curriculum/challenges/portuguese/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f7ecb09de9a938ef94756.md b/curriculum/challenges/portuguese/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f7ecb09de9a938ef94756.md
index 889fc9109d6..ee70bb8eeb8 100644
--- a/curriculum/challenges/portuguese/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f7ecb09de9a938ef94756.md
+++ b/curriculum/challenges/portuguese/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f7ecb09de9a938ef94756.md
@@ -7,7 +7,7 @@ dashedName: step-55
 
 # --description--
 
-Adicione outro elemento `p` com o texto `Total Carbohydrate 37g 13%`. Like before, use `span` elements to make the text `Total Carbohydrate` and `13%` bold. Adicione também um elemento `span` para envolver o texto `Total Carbohydrate 37g` em um elemento span que ele esteja alinhado à esquerda e `13%` à direita.
+Adicione outro elemento `p` com o texto `Total Carbohydrate 37g 13%`. Como antes, use elementos `span` para deixar o texto `Total Carbohydrate` e o texto `13%` em negrito. Adicione também um elemento `span` para envolver o texto `Total Carbohydrate 37g` em um elemento span que ele esteja alinhado à esquerda e `13%` à direita.
 
 # --hints--
 
diff --git a/curriculum/challenges/portuguese/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f8bfe0f30a1a3c340356b.md b/curriculum/challenges/portuguese/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f8bfe0f30a1a3c340356b.md
index 206a0e9b7cb..361326fd4d4 100644
--- a/curriculum/challenges/portuguese/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f8bfe0f30a1a3c340356b.md
+++ b/curriculum/challenges/portuguese/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f8bfe0f30a1a3c340356b.md
@@ -30,7 +30,7 @@ O primeiro novo elemento `p` deve ter um elemento `span`.
 assert(document.querySelector('.daily-value.small-text')?.lastElementChild?.previousElementSibling?.firstElementChild?.localName === 'span');
 ```
 
-O primeiro elemento `span` não deve estar em negrito.
+Your first `span` element should not be bold.
 
 ```js
 assert(!document.querySelector('.daily-value.small-text')?.lastElementChild?.previousElementSibling?.firstElementChild?.classList?.contains('bold'));
diff --git a/curriculum/challenges/portuguese/15-javascript-algorithms-and-data-structures-22/learn-basic-javascript-by-building-a-role-playing-game/62a8b6536156c51500739b41.md b/curriculum/challenges/portuguese/15-javascript-algorithms-and-data-structures-22/learn-basic-javascript-by-building-a-role-playing-game/62a8b6536156c51500739b41.md
index f15a8c6de8b..29a65d1e307 100644
--- a/curriculum/challenges/portuguese/15-javascript-algorithms-and-data-structures-22/learn-basic-javascript-by-building-a-role-playing-game/62a8b6536156c51500739b41.md
+++ b/curriculum/challenges/portuguese/15-javascript-algorithms-and-data-structures-22/learn-basic-javascript-by-building-a-role-playing-game/62a8b6536156c51500739b41.md
@@ -7,7 +7,7 @@ dashedName: step-62
 
 # --description--
 
-The `locations` array contains two locations: the `town square` and the `store`. Currently you are passing that entire array into the `update` function. Passe apenas o primeiro elemento do array `locations` adicionando `[0]` no final da variável. Por exemplo: `myFunction(arg[0]);`.
+O array `locations` contém dois locais: a praça da cidade (em inglês, `town square`) e a loja (em inglês, `store`). No momento, você está passando esse array inteiro para a função de `update`. Passe apenas o primeiro elemento do array `locations` adicionando `[0]` no final da variável. Por exemplo: `myFunction(arg[0]);`.
 
 Isso é chamado de <dfn>notação de colchete</dfn>. Valores em um array são acessados pelo índice. Índices são valores numéricos e começam em 0 – isto é chamado de indexação baseada em zero. `arg[0]` deve ser o primeiro elemento no array `arg`.
 
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/declare-a-read-only-variable-with-the-const-keyword.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/declare-a-read-only-variable-with-the-const-keyword.md
index 54d09b76687..739cc63f87b 100644
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/declare-a-read-only-variable-with-the-const-keyword.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/declare-a-read-only-variable-with-the-const-keyword.md
@@ -1,6 +1,6 @@
 ---
 id: 587d7b87367417b2b2512b41
-title: Оголосіть змінну, доступну лише для читання, з ключовим словом Const
+title: Оголошення змінної для читання з ключовим словом const
 challengeType: 1
 forumTopicId: 301201
 dashedName: declare-a-read-only-variable-with-the-const-keyword
@@ -10,57 +10,57 @@ dashedName: declare-a-read-only-variable-with-the-const-keyword
 
 Ключове слово `let` є не єдиним новим способом оголосити змінну. В ES6 можливо також оголосити змінні, використовуючи ключове слово `const`.
 
-У `const` є ті ж круті функції, що й в `let` з приємним бонусом — тепер змінні, оголошені за допомогою `const`, доступні лише для читання. Вони мають константне значення. Тобто, як тільки змінна стає призначеною `const`, її вже неможливо призначити знову:
+`const` має ті ж круті функції, що й `let`, але з бонусом: тепер змінні, оголошені за допомогою `const`, доступні лише для читання. Вони мають константне значення, тобто після присвоєння змінної з `const`, її неможливо присвоїти знову:
 
 ```js
 const FAV_PET = "Cats";
 FAV_PET = "Dogs";
 ```
 
-Консоль показуватиме помилку через перепризначення значення `FAV_PET`.
+Консоль показуватиме помилку через повторне присвоєння значення `FAV_PET`.
 
-Змінні, які не передбачають перепризначення, слід називати, використовуючи ключове слово `const`. Це може знадобитися, якщо ви випадково спробуєте перепризначити змінну, яка повинна бути константною.
+Змінні, які не передбачають повторного присвоєння, потрібно називати, використовуючи ключове слово `const`. Це може знадобитися, якщо ви випадково спробуєте повторно присвоїти змінну, яка повинна залишатись константною.
 
-**Note:** It is common for developers to use uppercase variable identifiers for immutable values and lowercase or camelCase for mutable values (objects and arrays). You will learn more about objects, arrays, and immutable and mutable values in later challenges. Also in later challenges, you will see examples of uppercase, lowercase, or camelCase variable identifiers.
+**Примітка:** зазвичай розробники використовують ідентифікатори змінних у верхньому регістрі для незмінних значень та у нижньому регістрі чи верблюдячомуРегістрі для змінних значень (об’єктів чи масивів). Ви дізнаєтесь більше про об’єкти, масиви, а також змінні та незмінні значення в наступних завданнях. Також ви побачите приклади ідентифікаторів змінних у верхньому регістрі, нижньому регістрі та верблюдячомуРегістрі.
 
 # --instructions--
 
-Change the code so that all variables are declared using `let` or `const`. Use `let` when you want the variable to change, and `const` when you want the variable to remain constant. Also, rename variables declared with `const` to conform to common practices. Do not change the strings assigned to the variables.
+Змініть код так, щоб усі змінні були оголошені за допомогою `let` або `const`. Використайте `let` для змінних значень, а `const` для незмінних значень. Крім того, перейменуйте змінні, оголошені за допомогою `const`, щоб відповідати загальним практикам. Не змінюйте рядки, які присвоєні змінним.
 
 # --hints--
 
-`var` should not exist in your code.
+`var` повинне бути відсутнім у коді.
 
 ```js
 assert.notMatch(code, /var/g);
 ```
 
-You should change `fCC` to all uppercase.
+Ви повинні змінити `fCC` на верхній регістр.
 
 ```js
 assert.match(code, /(FCC)/);
 assert.notMatch(code, /(fCC)/);
 ```
 
-`FCC` should be a constant variable declared with `const`.
+`FCC` повинна бути константною змінною, оголошеною з `const`.
 
 ```js
 assert.match(code, /const\s+FCC/);
 ```
 
-The string assigned to `FCC` should not be changed.
+Не потрібно змінювати рядок, присвоєний до `FCC`.
 
 ```js
 assert.equal(FCC, 'freeCodeCamp');
 ```
 
-`fact` should be declared with `let`.
+`fact` повинна бути оголошеною із `let`.
 
 ```js
 assert.match(code, /(let\s+fact)/g);
 ```
 
-`console.log` should be changed to print the `FCC` and `fact` variables.
+`console.log` потрібно змінити так, щоб виводились змінні `FCC` та `fact`.
 
 ```js
 assert.match(code, /console\.log\(\s*FCC\s*\,\s*fact\s*\)\s*;?/g);
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/escaping-literal-quotes-in-strings.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/escaping-literal-quotes-in-strings.md
index 84c1e5b448f..f565a0baa10 100644
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/escaping-literal-quotes-in-strings.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/escaping-literal-quotes-in-strings.md
@@ -1,6 +1,6 @@
 ---
 id: 56533eb9ac21ba0edf2244b5
-title: Уникнення літературних цитат в рядках
+title: Порятунок цитат у рядках
 challengeType: 1
 videoUrl: 'https://scrimba.com/c/c2QvgSr'
 forumTopicId: 17568
@@ -9,15 +9,15 @@ dashedName: escaping-literal-quotes-in-strings
 
 # --description--
 
-Коли ви зазначаєте рядок, вам потрібно починати і закінчувати його одинарними або подвійними лапками. Що стається, коли ви потребуєте літературну цитату `"` or `'` всередині вашого рядка?
+Коли ви визначаєте рядок, він повинен починатися та закінчуватися одинарними або подвійними лапками. Що робити, якщо всередині рядка потрібно написати цитату в `"` чи `'`?
 
-В JavaScript, ви можете <dfn>вийти</dfn> з цитати і розглядати її як кінець рядка лапки, розмістивши <dfn>зворотнього слешу</dfn> (`\`) перед лапкою.
+У JavaScript можна <dfn>уникнути</dfn> непотрібного завершення рядка, написавши <dfn>зворотну косу риску</dfn> (`\`) на початку цитати.
 
 ```js
 const sampleStr = "Alan said, \"Peter is learning JavaScript\".";
 ```
 
-Це сигнали для JavaScript про те, що така цитата не є кінцевим рядком, а повинна з'явитися всередині рядка. Тому якщо ви введете це в консолі, то отримаєте:
+Це повідомляє JavaScript про те, що цитата не є кінцем рядка, а повинна з’явитися всередині рядка. Якщо ви надрукуєте це на консолі, то отримаєте:
 
 ```js
 Alan said, "Peter is learning JavaScript".
@@ -25,7 +25,7 @@ Alan said, "Peter is learning JavaScript".
 
 # --instructions--
 
-Використовуйте <dfn>косі риски</dfn> щоб зазначити для рядка змінну `myStr`, і таким чином ввівши її на консолі, побачите:
+Використайте <dfn>зворотні косі риски</dfn>, щоб присвоїти рядок до змінної `myStr` та при виводі на консоль ви бачили наступне:
 
 ```js
 I am a "double quoted" string inside "double quotes".
@@ -33,13 +33,13 @@ I am a "double quoted" string inside "double quotes".
 
 # --hints--
 
-Вам слід використовувати дві подвійні лапки (`"`) і чотири подвійні лапки (`\"`).
+Ви повинні використати дві подвійні лапки (`"`) та чотири екрановані подвійні лапки (`\"`).
 
 ```js
 assert(code.match(/\\"/g).length === 4 && code.match(/[^\\]"/g).length === 2);
 ```
 
-Variable `myStr` should contain the string: `I am a "double quoted" string inside "double quotes".`
+Змінна `myStr` повинна містити рядок `I am a "double quoted" string inside "double quotes".`
 
 ```js
 assert(/I am a "double quoted" string inside "double quotes(\."|"\.)$/.test(myStr));
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/introducing-else-if-statements.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/introducing-else-if-statements.md
index 43069b3adf5..42ad7bc009d 100644
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/introducing-else-if-statements.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/introducing-else-if-statements.md
@@ -1,6 +1,6 @@
 ---
 id: 56533eb9ac21ba0edf2244db
-title: Вступ до інструкцій «else if»
+title: Вступ до інструкцій else if
 challengeType: 1
 videoUrl: 'https://scrimba.com/c/caeJ2hm'
 forumTopicId: 18206
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/introducing-else-statements.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/introducing-else-statements.md
index 29951b232b4..37cdb67743f 100644
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/introducing-else-statements.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/introducing-else-statements.md
@@ -1,6 +1,6 @@
 ---
 id: 56533eb9ac21ba0edf2244da
-title: Вступ до інструкцій «else»
+title: Вступ до інструкцій else
 challengeType: 1
 videoUrl: 'https://scrimba.com/c/cek4Efq'
 forumTopicId: 18207
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/iterate-through-an-array-with-a-for-loop.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/iterate-through-an-array-with-a-for-loop.md
index 84d6820c899..4e8bd19e667 100644
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/iterate-through-an-array-with-a-for-loop.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/iterate-through-an-array-with-a-for-loop.md
@@ -1,6 +1,6 @@
 ---
 id: 5675e877dbd60be8ad28edc6
-title: Ітерація через масив за допомогою циклу For
+title: Ітерація масиву за допомогою циклу for
 challengeType: 1
 videoUrl: 'https://scrimba.com/c/caeR3HB'
 forumTopicId: 18216
@@ -9,7 +9,7 @@ dashedName: iterate-through-an-array-with-a-for-loop
 
 # --description--
 
-Ітерація через вміст масиву є поширеною задачею у JavaScript. Це можна робити за допомогою циклу `for`. Цей код буде виводити кожен елемент масиву `arr` на консоль:
+У JavaScript часто доводиться перебрати вміст масиву. Це можна зробити за допомогою циклу `for`. Цей код виводитиме кожен елемент масиву `arr` на консоль:
 
 ```js
 const arr = [10, 9, 8, 7, 6];
@@ -19,11 +19,11 @@ for (let i = 0; i < arr.length; i++) {
 }
 ```
 
-Пам'ятайте, що масиви мають індексацію, яка рахується від нуля і це означає, що останній індекс масиву - це `length - 1`. Нашою умовою для цього циклу є `i < arr.length`, який зупиняє цикл, коли `i` дорівнює `length`. У цьому випадку останньою ітерацією є `i === 4`, тобто коли `i` дорівнює `arr.length - 1` і виводить `6` на консоль. Тоді `i` збільшується на `5`, і цикл закінчується тому, що код `i < arr.length` є `false`.
+Пам'ятайте, що масиви мають індексацію на основі нуля і це означає, що останнім індексом масиву є `length - 1`. Нашою умовою для цього циклу є `i < arr.length`, який зупиняє цикл, коли `i` дорівнює `length`. У цьому випадку останньою ітерацією є `i === 4`, тобто коли `i` дорівнює `arr.length - 1` і виводить `6` на консоль. Тоді `i` збільшується до `5`, і цикл закінчується через те, що `i < arr.length` є `false`.
 
 # --instructions--
 
-Оголосіть та ініціалізуйте змінну `total` до `0`. Використовуйте цикл `for` для додавання значення кожного елементу масиву `myArr` до `total`.
+Оголосіть та ініціалізуйте змінну `total` до `0`. Використайте цикл `for`, щоб додати значення кожного елемента масиву `myArr` до `total`.
 
 # --hints--
 
@@ -39,13 +39,13 @@ assert(code.match(/(var|let|const)\s*?total\s*=\s*0.*?;?/));
 assert(total === 20);
 ```
 
-Слід використовувати цикл `for` для ітерації через `myArr`.
+Ви повинні використати цикл `for`, щоб перебрати `myArr`.
 
 ```js
 assert(/for\s*\(/g.test(code) && /myArr\s*\[/g.test(code));
 ```
 
-Не потрібно намагатися напряму призначити `total` значення 20.
+Не потрібно намагатися напряму присвоїти значення 20 до `total`.
 
 ```js
 assert(!__helpers.removeWhiteSpace(code).match(/total[=+-]0*[1-9]+/gm));
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/iterate-with-javascript-do...while-loops.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/iterate-with-javascript-do...while-loops.md
index b1414c7bf7b..bb63650e883 100644
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/iterate-with-javascript-do...while-loops.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/iterate-with-javascript-do...while-loops.md
@@ -1,6 +1,6 @@
 ---
 id: 5a2efd662fb457916e1fe604
-title: Ітерація з "do...while" циклами, JavaScript
+title: Ітерація з циклами do...while у JavaScript
 challengeType: 1
 videoUrl: 'https://scrimba.com/c/cDqWGcp'
 forumTopicId: 301172
@@ -9,7 +9,7 @@ dashedName: iterate-with-javascript-do---while-loops
 
 # --description--
 
-Наступний вид циклів, який ви вивчите, називається `do...while` циклом. Він називається `do...while` циклом, тому що, спочатку, не зважаючи ні на що, він `do` (робить) одну передачу коду, а потім продовжує виконувати цикл `while` поки вказана умова обчислюється до `true`.
+Наступним ви вивчите цикл `do...while`. Цикл `do...while` називається так, бо спочатку він щось виконує у коді (`do`), а потім продовжує цикл (`while`), доки умова не становитиме `true`.
 
 ```js
 const ourArray = [];
@@ -21,7 +21,7 @@ do {
 } while (i < 5);
 ```
 
-Приклад вище поводиться аналогічно з іншими типами циклів, і результуючий масив буде виглядати як `[0, 1, 2, 3, 4]`. Однак, що відрізняє `do...while` від інших циклів, так це те, як він поводиться, коли умова підводить при першій перевірці. Let's see this in action. Here is a regular `while` loop that will run the code in the loop as long as `i < 5`:
+Наведений вище приклад поводиться подібно до інших типів циклів, і кінцевий масив матиме такий вигляд: `[0, 1, 2, 3, 4]`. Однак цикл `do...while` відрізняється від інших циклів своєю поведінкою, коли умова не відповідає першій перевірці. Розглянемо на дії. Ось звичайний цикл `while`, який запускає код за умови, що `i < 5`:
 
 ```js
 const ourArray = []; 
@@ -33,7 +33,7 @@ while (i < 5) {
 }
 ```
 
-У цьому прикладі ми ініціалізуємо значення `ourArray` до порожнього масиву і значення `i` до 5. Коли ми виконуємо `while` цикл, умова обчислюється до `false`, тому що `i` не менше ніж 5, таким чином ми не виконуємо код всередині циклу. Результатом є те, що до `ourArray` не буде додано ніяких значень і він все ще виглядатиме, як `[]`, коли всі коди, в наведеному вище прикладі, вже завершили роботу. А зараз погляньте на `do...while` цикл:
+У цьому прикладі ми ініціалізуємо значення `ourArray` до порожнього масиву і значення `i` до 5. Коли ми виконуємо цикл `while`, умова обчислюється як `false`, оскільки `i` не менше за 5, тому ми не виконуємо код всередині циклу. Результатом є те, що `ourArray` не матиме доданих значень і досі виглядатиме як `[]`, коли весь код у прикладі вище вже завершить виконання. А зараз погляньте на цикл `do...while`:
 
 ```js
 const ourArray = []; 
@@ -45,11 +45,11 @@ do {
 } while (i < 5);
 ```
 
-У цьому випадку, ми ініціалізуємо значення `i` до 5, так само, як ми зробили з `while` циклом. Коли ми доходимо до наступного рядка, то бачимо, що умови для обчислення немає. Таким чином, ми рухаємось до коду, що знаходиться у фігурних дужках, і виконуємо його. Ми додамо єдиний елемент до масиву, а потім збільшимо `i` перед тим, як перейти до перевірки умови. Коли ми нарешті обчислимо умову `i < 5` в останньому рядку, ми побачимо, що зараз `i` становить 6, що провалює перевірку умови. Тому, ми виходимо з циклу і завершуємо роботу. Наприкінці наведеного вище прикладу, значення `ourArray` становить `[5]`. В цілому, `do...while` цикл гарантує те, що код всередині циклу буде виконуватися принаймні один раз. Давайте спробуємо підготувати `do...while` цикл до роботи, висуваючи значення до масиву.
+У цьому випадку ми ініціалізуємо значення `i` до 5, так само, як ми зробили з циклом `while`. Коли ми доходимо до наступного рядка, то бачимо, що немає умови, тому ми переходимо до коду у фігурних дужках та виконуємо його. Ми додамо один елемент до масиву та збільшимо `i` перед тим, як перейти до перевірки умови. Коли ми обчислимо умову `i < 5` в останньому рядку, ми побачимо, що зараз `i` дорівнює 6 та не проходить перевірку умови, тому ми виходимо з циклу і завершуємо роботу. В кінці вищеподаного прикладу, значення `ourArray` становить `[5]`. По суті, цикл `do...while` гарантує те, що код всередині циклу виконається принаймні один раз. Спробуємо заставити цикл `do...while` працювати, передаючи значення до масиву.
 
 # --instructions--
 
-В коді змініть `while` цикл на `do...while` цикл і він висуватиме лише число `10` до `myArray`, а `i` буде дорівнювати `11`, коли код закінчить роботу.
+Змініть цикл `while` у коді на цикл `do...while` так, щоб цикл передавав лише число `10` до `myArray`, та `i` дорівнювала `11`, коли код закінчить виконання.
 
 # --hints--
 
@@ -65,7 +65,7 @@ assert(code.match(/do/g));
 assert.deepEqual(myArray, [10]);
 ```
 
-`i` повинне дорівнювати `11`
+`i` повинна дорівнювати `11`
 
 ```js
 assert.equal(i, 11);
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/iterate-with-javascript-for-loops.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/iterate-with-javascript-for-loops.md
index 6ca36022e02..eb5f4b8a640 100644
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/iterate-with-javascript-for-loops.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/iterate-with-javascript-for-loops.md
@@ -1,6 +1,6 @@
 ---
 id: cf1111c1c11feddfaeb5bdef
-title: Ітерація для циклів з JavaScript
+title: Ітерація з циклами for у JavaScript
 challengeType: 1
 videoUrl: 'https://scrimba.com/c/c9yNVCe'
 forumTopicId: 18219
@@ -9,21 +9,21 @@ dashedName: iterate-with-javascript-for-loops
 
 # --description--
 
-Ви можете виконати один і той самий код декілька разів, використовуючи цикл.
+Ви можете виконати один і той самий код декілька разів за допомогою циклу.
 
-Найбільш поширеним типом JavaScript циклу є `for` цикл, тому що він виконується протягом певної кількості разів.
+Найпоширенішим типом циклу в JavaScript є `for`, оскільки він виконується певну кількість разів.
 
-For-цикли визнано трьома додатковими виразами, які розділені крапкою з комою:
+Цикли for оголошуються з трьома додатковими виразами, які розділені крапкою з комою:
 
-`for (a; b; c)`, де `a` — це твердження ініціалізації, `b` — твердження умови, а `c` — остаточний вираз.
+`for (a; b; c)`, де `a` є інструкцією ініціалізації, `b` є інструкцією умови, а `c` є кінцевим виразом.
 
-Твердження ініціалізації виконується лише один раз, перед початком циклу. Воно переважно використовується для визначення і налаштування змінної циклу.
+Інструкція ініціалізації виконується лише один раз (перед початком циклу). Її переважно використовують, щоб визначити та налаштувати змінну циклу.
 
-Твердження умови обчислюється на початку кожної ітерації циклу і продовжуватиметься до тих пір, поки не обчислиться до `true`. Коли, на початку ітерації, умова становить `false`, цикл припинить виконуватись. Це означає те, що якщо умова починається як "false", ваш цикл ніколи не виконається.
+Інструкція умови обчислюється на початку кожної ітерації циклу і продовжуватиметься до тих пір, поки не обчислиться до `true`. Коли на початку ітерації умова становить `false`, цикл припинить виконуватись. Це означає те, що якщо умова починається як «false», ваш цикл ніколи не виконається.
 
-Остаточний вираз виконується наприкінці кожної ітерації циклу, перед перевіркою наступної умови і, зазвичай, використовується для того, щоб збільшити або зменшити лічильник циклу.
+Кінцевий вираз виконується в кінці кожної ітерації циклу, перед перевіркою наступної умови і, зазвичай, використовується для того, щоб збільшити або зменшити лічильник.
 
-У наступному прикладі ми ініціалізуємо та ітеруємо `i = 0` допоки наша умова `i < 5` не буде правильною. Ми збільшимо `i` на `1` у кожній ітерації циклу `i++` у ролі нашого остаточного виразу.
+У наступному прикладі ми ініціалізуємо з `i = 0` та ітеруємо, доки наша умова `i < 5` не буде істинною. Ми збільшимо `i` на `1` у кожній ітерації циклу з кінцевим виразом `i++`.
 
 ```js
 const ourArray = [];
@@ -33,11 +33,11 @@ for (let i = 0; i < 5; i++) {
 }
 ```
 
-`ourArray` тепер матиме значення `[0, 1, 2, 3, 4]`.
+Тепер `ourArray` матиме значення `[0, 1, 2, 3, 4]`.
 
 # --instructions--
 
-Використовуйте `for` цикл для того, щоб перемістити значення 1 через 5 на `myArray`.
+Використайте цикл `for`, щоб передати значення від 1 до 5 до `myArray`.
 
 # --hints--
 
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/iterate-with-javascript-while-loops.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/iterate-with-javascript-while-loops.md
index 973508027c6..6ad26a95202 100644
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/iterate-with-javascript-while-loops.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/iterate-with-javascript-while-loops.md
@@ -1,6 +1,6 @@
 ---
 id: cf1111c1c11feddfaeb1bdef
-title: Ітерація циклів JavaScript
+title: Ітерація з циклами while у JavaScript
 challengeType: 1
 videoUrl: 'https://scrimba.com/c/c8QbnCM'
 forumTopicId: 18220
@@ -9,7 +9,7 @@ dashedName: iterate-with-javascript-while-loops
 
 # --description--
 
-Завдяки циклу, Ви можете запустити той самий код декілька разів.
+Ви можете виконати один і той самий код декілька разів за допомогою циклу.
 
 Перший тип циклу, який ми вивчатимемо, називається `while`, оскільки виконується за заданою істинною умовою і припиняється, як тільки ця умова більше не буде істинною.
 
@@ -23,9 +23,9 @@ while (i < 5) {
 }
 ```
 
-У прикладі вище коду цикл `while` виконуватиметься 5 разів і додаватиме числа від 0 до 4 до `ourArray`.
+У вищеподаному прикладі цикл `while` виконуватиметься 5 разів і додаватиме числа від 0 до 4 до `ourArray`.
 
-Спробуймо підготувати цикл while до роботи, розміщуючи значення в масиві даних.
+Спробуємо заставити цикл while працювати, передаючи значення до масиву.
 
 # --instructions--
 
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/logical-order-in-if-else-statements.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/logical-order-in-if-else-statements.md
index 09d0ef8530a..ded945f387e 100644
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/logical-order-in-if-else-statements.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/logical-order-in-if-else-statements.md
@@ -1,6 +1,6 @@
 ---
 id: 5690307fddb111c6084545d7
-title: Логічна послідовність в інструкції «if else»
+title: Логічна послідовність в інструкції if else
 challengeType: 1
 videoUrl: 'https://scrimba.com/c/cwNvMUV'
 forumTopicId: 18228
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/quoting-strings-with-single-quotes.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/quoting-strings-with-single-quotes.md
index 0717bf36f37..4a1d059ddf1 100644
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/quoting-strings-with-single-quotes.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/quoting-strings-with-single-quotes.md
@@ -1,6 +1,6 @@
 ---
 id: 56533eb9ac21ba0edf2244b4
-title: Цитування рядків з одинарними лапками
+title: Цитування рядків одинарними лапками
 challengeType: 1
 videoUrl: 'https://scrimba.com/c/cbQmnhM'
 forumTopicId: 18260
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/replacing-if-else-chains-with-switch.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/replacing-if-else-chains-with-switch.md
index 352f9038cf9..b294228045f 100644
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/replacing-if-else-chains-with-switch.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/replacing-if-else-chains-with-switch.md
@@ -1,6 +1,6 @@
 ---
 id: 56533eb9ac21ba0edf2244e0
-title: Заміна ланцюжків «if else» на switch
+title: Заміна ланцюжків if else на switch
 challengeType: 1
 videoUrl: 'https://scrimba.com/c/c3JE8fy'
 forumTopicId: 18266
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/return-early-pattern-for-functions.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/return-early-pattern-for-functions.md
index c0c5264303f..b9d3c880ab0 100644
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/return-early-pattern-for-functions.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/return-early-pattern-for-functions.md
@@ -1,6 +1,6 @@
 ---
 id: 56533eb9ac21ba0edf2244c4
-title: Повернення початкового шаблона для функцій
+title: Повернення початкового шаблону функцій
 challengeType: 1
 videoUrl: 'https://scrimba.com/c/cQe39Sq'
 forumTopicId: 18272
@@ -9,9 +9,9 @@ dashedName: return-early-pattern-for-functions
 
 # --description--
 
-Коли ви досягнули команди `return`, виконання поточної функції припиняється і об'єкт керування повертається до місця виклику.
+Коли досягається інструкція `return`, виконання поточної функції припиняється, а керування повертається до місця, де було викликано функцію.
 
-**Наприклад**
+**Приклад**
 
 ```js
 function myFun() {
@@ -22,54 +22,54 @@ function myFun() {
 myFun();
 ```
 
-Показане вище відобразить рядок `Hello` у консолі і поверне рядок `World`. Рядок `byebye` ніколи не відобразиться у консолі, тому що функція виходить з команди `return`.
+Вищеподане покаже рядок `Hello` на консолі та поверне рядок `World`. Рядок `byebye` ніколи не зобразиться на консолі, оскільки функція виходить з інструкції `return`.
 
 # --instructions--
 
-Модифікуйте функцію `abTest` і тому, якщо `a` або `b` дорівнюватиме менше `0`, функція відразу вийде зі значенням `undefined`.
+Змініть функцію `abTest` таким чином, що коли `a` або `b` буде менше за `0`, функція одразу вийде зі значенням `undefined`.
 
-**Hint**  
-Remember that <a href="https://www.freecodecamp.org/learn/javascript-algorithms-and-data-structures/basic-javascript/understanding-uninitialized-variables" target="_blank" rel="noopener noreferrer nofollow"><code>undefined</code> is a keyword</a>, not a string.
+**Підказка**  
+Пам’ятайте, що <a href="https://www.freecodecamp.org/ukrainian/learn/javascript-algorithms-and-data-structures/basic-javascript/understanding-uninitialized-variables" target="_blank" rel="noopener noreferrer nofollow"><code>undefined</code> є ключовим словом</a>, а не рядком.
 
 # --hints--
 
-`abTest(2, 2)` повинен повернути число
+`abTest(2, 2)` повинна повертати число
 
 ```js
 assert(typeof abTest(2, 2) === 'number');
 ```
 
-`abTest(2, 2)` повинен повернути `8`
+`abTest(2, 2)` повинна повертати `8`
 
 ```js
 assert(abTest(2, 2) === 8);
 ```
 
-`abTest(-2, 2)` повинен повернути `undefined`
+`abTest(-2, 2)` повинна повертати `undefined`
 
 ```js
 assert(abTest(-2, 2) === undefined);
 ```
 
-`abTest(2, -2)` повинен повернути `undefined`
+`abTest(2, -2)` повинна повертати `undefined`
 
 ```js
 assert(abTest(2, -2) === undefined);
 ```
 
-`abTest(2, 8)` повинен повернути `18`
+`abTest(2, 8)` повинна повертати `18`
 
 ```js
 assert(abTest(2, 8) === 18);
 ```
 
-`abTest(3, 3)` повинен повернути `12`
+`abTest(3, 3)` повинна повертати `12`
 
 ```js
 assert(abTest(3, 3) === 12);
 ```
 
-`abTest(0, 0)` повинен повернути `0`
+`abTest(0, 0)` повинна повертати `0`
 
 ```js
 assert(abTest(0, 0) === 0);
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/returning-boolean-values-from-functions.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/returning-boolean-values-from-functions.md
index 8eacab1dfb0..02b0e606584 100644
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/returning-boolean-values-from-functions.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/returning-boolean-values-from-functions.md
@@ -1,6 +1,6 @@
 ---
 id: 5679ceb97cbaa8c51670a16b
-title: Повернення логічних значень з функцій
+title: Повернення булевих значень із функцій
 challengeType: 1
 videoUrl: 'https://scrimba.com/c/cp62qAQ'
 forumTopicId: 18273
@@ -9,9 +9,9 @@ dashedName: returning-boolean-values-from-functions
 
 # --description--
 
-You may recall from <a href="/learn/javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-equality-operator" target="_blank" rel="noopener noreferrer nofollow">Comparison with the Equality Operator</a> that all comparison operators return a boolean `true` or `false` value.
+Як ви можете пригадати з <a href="/ukrainian/learn/javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-equality-operator" target="_blank" rel="noopener noreferrer nofollow">порівняння з оператором «дорівнює»</a>, всі оператори порівняння повертають булеве значення `true` або `false`.
 
-Інколи люди використовують `if/else` команду для того, щоб зробити порівняння на зразок цього:
+Іноді люди використовують інструкцію `if/else`, щоб виконати порівняння:
 
 ```js
 function isEqual(a, b) {
@@ -23,7 +23,7 @@ function isEqual(a, b) {
 }
 ```
 
-Але є кращий спосіб це зробити. Оскільки `===` повертає `true` або `false`, ми можемо повернути результат порівняння:
+Але існує кращий спосіб. Оскільки `===` повертає `true` або `false`, ми можемо повернути результат порівняння:
 
 ```js
 function isEqual(a, b) {
@@ -33,23 +33,23 @@ function isEqual(a, b) {
 
 # --instructions--
 
-Виправте функцію `isLess` для того, щоб видалити `if/else` команду.
+Виправте функцію `isLess` так, щоб видалити інструкції `if/else`.
 
 # --hints--
 
-`isLess(10, 15)` повинен повернути `true`
+`isLess(10, 15)` повинна повертати `true`
 
 ```js
 assert(isLess(10, 15) === true);
 ```
 
-`isLess(15, 10)` повинен повернути `false`
+`isLess(15, 10)` повинна повертати `false`
 
 ```js
 assert(isLess(15, 10) === false);
 ```
 
-Вам не слід використовувати будь-які `if` чи `else` команди
+Ви не повинні використовувати інструкції `if` або `else`
 
 ```js
 assert(!/if|else/g.test(code));
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/selecting-from-many-options-with-switch-statements.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/selecting-from-many-options-with-switch-statements.md
index 593f8e69d60..990a0c9359e 100644
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/selecting-from-many-options-with-switch-statements.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/selecting-from-many-options-with-switch-statements.md
@@ -1,6 +1,6 @@
 ---
 id: 56533eb9ac21ba0edf2244dd
-title: Вибір з багатьох опцій за допомогою перемикачів
+title: Вибір із багатьох варіантів за допомогою інструкцій switch
 challengeType: 1
 videoUrl: 'https://scrimba.com/c/c4mv4fm'
 forumTopicId: 18277
@@ -9,9 +9,9 @@ dashedName: selecting-from-many-options-with-switch-statements
 
 # --description--
 
-Якщо у вас є багато опцій для вибору, використовуйте команду <dfn>switch</dfn>. `switch` тести на значення і може мати багато <dfn> випадків </dfn> інструкцій, які визначають різні значення. Інструкції виконуються від першого узгодженого значення `case<code> до тих пір, поки <code>break<code> не відбудиться.</p>
+Якщо ви маєте багато варіантів для вибору, використовуйте інструкцію <dfn>switch</dfn>. Інструкція `switch` тестує значення та може мати багато інструкцій <dfn>case</dfn>, які визначають можливі значення. Інструкції виконуються від першого відповідного значення `case` до тих пір, поки не зіткнуться із `break`.
 
-<p spaces-before="0">Ось наводиться приклад інструкції <code>switch`:
+Ось приклад інструкції `switch`:
 
 ```js
 switch (lowercaseLetter) {
@@ -24,11 +24,11 @@ switch (lowercaseLetter) {
 }
 ```
 
-`case` значень перевіряється абсолютною рівністю (`===`). `break` пропонує JavaScript припинити виконання інструкцій. Якщо `break` пропущений, тоді наступна команда буде виконуватись.
+Значення `case` перевіряються за допомогою строгої рівності (`===`). `break` вказує JavaScript зупинити запущені інструкції. Якщо пропустити `break`, виконується наступна інструкція.
 
 # --instructions--
 
-Напишіть команду switch, щоб встановити `answer` за наступних умов:  
+Напишіть інструкцію switch, яка перевіряє `val` та встановлює `answer` для наступних умов:  
 `1` - `alpha`  
 `2` - `beta`  
 `3` - `gamma`  
@@ -36,31 +36,31 @@ switch (lowercaseLetter) {
 
 # --hints--
 
-`caseInSwitch(1)` повинно відповідати значенню рядка `alpha`
+`caseInSwitch(1)` повинна мати значення рядка `alpha`
 
 ```js
 assert(caseInSwitch(1) === 'alpha');
 ```
 
-`caseInSwitch(2)` повинно відповідати значенню рядка `beta`
+`caseInSwitch(2)` повинна мати значення рядка `beta`
 
 ```js
 assert(caseInSwitch(2) === 'beta');
 ```
 
-`caseInSwitch(3)` повинно відповідати значенню рядка `gamma`
+`caseInSwitch(3)` повинна мати значення рядка `gamma`
 
 ```js
 assert(caseInSwitch(3) === 'gamma');
 ```
 
-`caseInSwitch(4)` повинно відповідати значенню рядка `delta`
+`caseInSwitch(4)` повинна мати значення рядка `delta`
 
 ```js
 assert(caseInSwitch(4) === 'delta');
 ```
 
-Не варто використовувати `if` або `else` команди
+Ви не повинні використовувати інструкції `if` чи `else`
 
 ```js
 assert(!/else/g.test(code) || !/if/g.test(code));
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/shopping-list.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/shopping-list.md
index b6002732b79..2f73e75582c 100644
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/shopping-list.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/shopping-list.md
@@ -11,13 +11,13 @@ dashedName: shopping-list
 
 Створіть список покупок у змінній `myList`. Список повинен бути багатовимірним масивом, який містить декілька підмасивів.
 
-Перший елемент у кожному підмасиві повинен містити рядок з назвою одиниці. Другий елемент повинен бути числом, яке відображає кількість.
+Перший елемент у кожному підмасиві повинен містити рядок з назвою одиниці. Другим елементом повинне бути число, яке вказує кількість.
 
 ```js
 ["Chocolate Bar", 15]
 ```
 
-У списку повинно бути щонайменше 5 підмасивів.
+У списку повинно бути принаймні 5 підмасивів.
 
 # --hints--
 
@@ -39,7 +39,7 @@ assert(hasString);
 assert(hasNumber);
 ```
 
-У списку має бути щонайменше 5 одиниць.
+У списку повинно бути принаймні 5 одиниць.
 
 ```js
 assert(count > 4);
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/stand-in-line.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/stand-in-line.md
index fa01106df13..a0e9a11ea8a 100644
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/stand-in-line.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/stand-in-line.md
@@ -1,6 +1,6 @@
 ---
 id: 56533eb9ac21ba0edf2244c6
-title: Стояти в черзі
+title: Станьте в чергу
 challengeType: 1
 videoUrl: 'https://scrimba.com/c/ca8Q8tP'
 forumTopicId: 18307
@@ -9,43 +9,43 @@ dashedName: stand-in-line
 
 # --description--
 
-В комп'ютерних науках <dfn>queue</dfn> це абстрактне поняття <dfn>Data Structure</dfn>, де усі елементи зберігають певний порядок. Нові елементи можуть бути додані до черги, а старі елементи - зняті з черги.
+<dfn>Черга</dfn> в комп’ютерних науках – це абстрактна <dfn>структура даних</dfn>, де усі елементи зберігають певний порядок. Нові елементи можна додати в кінець черги, а старі елементи знімають з початку.
 
 # --instructions--
 
-Напишіть функцію `nextInLine`, аргументами якої є масив (`arr`) та число (`item`).
+Напишіть функцію `nextInLine`, яка приймає масив (`arr`) та число (`item`) як аргументи.
 
 Додайте число до кінця масиву, а тоді видаліть перший елемент з масиву.
 
-Функція `nextInLine` повинна повернути видалений елемент.
+Функція `nextInLine` повинна повертати видалений елемент.
 
 # --hints--
 
-`nextInLine([], 5)` має повернути до числа.
+`nextInLine([], 5)` повинна повертати число.
 
 ```js
 assert.isNumber(nextInLine([], 5));
 ```
 
-`nextInLine([], 1)` має повернути до `1`
+`nextInLine([], 1)` повинна повертати `1`
 
 ```js
 assert(nextInLine([], 1) === 1);
 ```
 
-`nextInLine([2], 1)` має повернути до `2`
+`nextInLine([2], 1)` повинна повертати `2`
 
 ```js
 assert(nextInLine([2], 1) === 2);
 ```
 
-`nextInLine([5,6,7,8,9], 1)` має повернути до `5`
+`nextInLine([5,6,7,8,9], 1)` повинна повертати `5`
 
 ```js
 assert(nextInLine([5, 6, 7, 8, 9], 1) === 5);
 ```
 
-Після `nextInLine(testArr, 10)`, код `testArr[4]` має стати `10`
+Після `nextInLine(testArr, 10)`, `testArr[4]` повинен бути `10`
 
 ```js
 nextInLine(testArr, 10);
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/store-multiple-values-in-one-variable-using-javascript-arrays.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/store-multiple-values-in-one-variable-using-javascript-arrays.md
index b51fa94707c..7921f774513 100644
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/store-multiple-values-in-one-variable-using-javascript-arrays.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/store-multiple-values-in-one-variable-using-javascript-arrays.md
@@ -1,6 +1,6 @@
 ---
 id: bd7993c9c69feddfaeb8bdef
-title: Зберігання кількох значень в одній змінній, використовуючи масиви JavaScript
+title: Зберігання декількох значень в одній змінній за допомогою масивів JavaScript
 challengeType: 1
 videoUrl: 'https://scrimba.com/c/crZQWAm'
 forumTopicId: 18309
@@ -9,9 +9,9 @@ dashedName: store-multiple-values-in-one-variable-using-javascript-arrays
 
 # --description--
 
-Зі змінними масивів `array` JavaScript, ми можемо зберігати частини даних в одному місці.
+Ми можемо зберігати деякі дані в одному місці завдяки змінним `array` у JavaScript.
 
-Ви починаєте оголошення масиву з відкритої квадратної дужки, а завершуєте його закриваючи квадратною дужкою і ставлячи кому між кожним елементом приблизно так:
+Оголошення масиву починається з початкової квадратної дужки, закінчується кінцевою квадратною дужкою, а між кожним елементом ставиться кома:
 
 ```js
 const sandwich = ["peanut butter", "jelly", "bread"];
@@ -29,13 +29,13 @@ const sandwich = ["peanut butter", "jelly", "bread"];
 assert(typeof myArray == 'object');
 ```
 
-Першим елементом у масиві `myArray` має бути рядок.
+Першим елементом у `myArray` повинен бути рядок.
 
 ```js
 assert(typeof myArray[0] !== 'undefined' && typeof myArray[0] == 'string');
 ```
 
-Другий пункт в `myArray` має бути числом.
+Другим елементом у `myArray` повинне бути число.
 
 ```js
 assert(typeof myArray[1] !== 'undefined' && typeof myArray[1] == 'number');
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/storing-values-with-the-assignment-operator.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/storing-values-with-the-assignment-operator.md
index 6c674c29e0c..0b87f73812c 100644
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/storing-values-with-the-assignment-operator.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/storing-values-with-the-assignment-operator.md
@@ -1,6 +1,6 @@
 ---
 id: 56533eb9ac21ba0edf2244a8
-title: Зберігання значень за допомогою оператора присвоєння
+title: Зберігання значень за допомогою оператора присвоювання
 challengeType: 1
 videoUrl: 'https://scrimba.com/c/cEanysE'
 forumTopicId: 18310
@@ -9,7 +9,7 @@ dashedName: storing-values-with-the-assignment-operator
 
 # --description--
 
-In JavaScript ви можете зберігати значення в змінній <dfn>assignment</dfn> з оператором (`=`).
+У JavaScript можна зберігати значення в змінній за допомогою оператора <dfn>присвоювання</dfn> (`=`).
 
 ```js
 myVariable = 5;
@@ -17,14 +17,14 @@ myVariable = 5;
 
 Вона призначає `Number` зі значенням `5` до `myVariable`.
 
-Якщо праворуч від оператора є будь-які розрахунки `=`, ті з них, які розташовані перед значенням належать до змінної зліва від оператора.
+Якщо праворуч від оператора `=` є будь-які розрахунки, вони виконуються до того, як значення буде присвоєно змінній ліворуч від оператора.
 
 ```js
 var myVar;
 myVar = 5;
 ```
 
-Спочатку, цей код створює змінну з ім'ям `myVar`. Тоді код присвоює `5` на `myVar`. Тепер, якщо `myVar` знову з'являється в коді, програма буде розглядати його так, як `5`.
+Спочатку цей код створює змінну під назвою `myVar`. Потім код присвоює `5` до `myVar`. Якщо `myVar` знову з’явиться у коді, програма розглядатиме її як `5`.
 
 # --instructions--
 
@@ -38,7 +38,7 @@ myVar = 5;
 assert(/var a;/.test(code));
 ```
 
-`a` має мати значення 7.
+`a` повинна мати значення 7.
 
 ```js
 assert(typeof a === 'number' && a === 7);
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/subtract-one-number-from-another-with-javascript.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/subtract-one-number-from-another-with-javascript.md
index 4a706a20030..6cb4bd9ef8f 100644
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/subtract-one-number-from-another-with-javascript.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/subtract-one-number-from-another-with-javascript.md
@@ -1,6 +1,6 @@
 ---
 id: cf1111c1c11feddfaeb4bdef
-title: Віднімати одне число від іншого використовуючи JavaScript
+title: Віднімання одного числа від іншого за допомогою JavaScript
 challengeType: 1
 videoUrl: 'https://scrimba.com/c/cP3yQtk'
 forumTopicId: 18314
@@ -9,11 +9,11 @@ dashedName: subtract-one-number-from-another-with-javascript
 
 # --description--
 
-Ми також можемо віднімати одне число від іншого.
+Ми також можемо відняти одне число від іншого.
 
 JavaScript використовує символ `-` для віднімання.
 
-**Наприклад**
+**Приклад**
 
 ```js
 const myVar = 12 - 6;
@@ -22,17 +22,17 @@ const myVar = 12 - 6;
 `myVar` тепер матиме значення `6`.
 # --instructions--
 
-Змініть `0` так, щоб сума дорівнювала `12`.
+Змініть `0` так, щоб різниця дорівнювала `12`.
 
 # --hints--
 
-The variable `difference` should be equal to `12`.
+Змінна `difference` повинна дорівнювати `12`.
 
 ```js
 assert(difference === 12);
 ```
 
-You should only subtract one number from `45`.
+Ви повинні відняти лише одне число від `45`.
 
 ```js
 assert(/difference=45-33;?/.test(__helpers.removeWhiteSpace(code)));
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/testing-objects-for-properties.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/testing-objects-for-properties.md
index 6423bed3c81..702bbc50883 100644
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/testing-objects-for-properties.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/testing-objects-for-properties.md
@@ -1,6 +1,6 @@
 ---
 id: 567af2437cbaa8c51670a16c
-title: Тестування властивостей об'єктів
+title: Перевірка властивостей об’єктів
 challengeType: 1
 forumTopicId: 18324
 dashedName: testing-objects-for-properties
@@ -8,9 +8,9 @@ dashedName: testing-objects-for-properties
 
 # --description--
 
-Іноді варто перевіряти чи даний об'єкт вже має певні властивості. Ми можемо використовувати метод об'єктів `.hasOwnProperty(propname)`, щоб визначити чи об'єкт має ім'я властивості. `.hasOwnProperty()` показує `true` чи `false`, в залежності чи властивість знайдена, чи ні.
+Іноді потрібно перевіряти, чи об'єкт має певну властивість. Ми можемо використати метод об'єктів `.hasOwnProperty(propname)`, щоб визначити, чи має цей об’єкт задану назву властивості. `.hasOwnProperty()` повертає `true` або `false`, якщо властивість знайдена чи не знайдена.
 
-**Наприклад**
+**Приклад**
 
 ```js
 const myObj = {
@@ -22,11 +22,11 @@ myObj.hasOwnProperty("top");
 myObj.hasOwnProperty("middle");
 ```
 
-Перший `hasOwnProperty` стає `true`, а другий - `false`.
+Перший `hasOwnProperty` повертає `true`, а другий повертає `false`.
 
 # --instructions--
 
-Змініть функцію `checkObj`, щоб перевірити чи об'єкт переданий до функції (`obj`) містить особливу властивість (`checkProp`). Якщо властивість знайдена, поверніть значення властивості. Якщо ні, поверніть `"Not Found"`.
+Змініть функцію `checkObj` так, щоб вона перевіряла, чи переданий до функції об’єкт (`obj`) містить певну властивість (`checkProp`). Якщо властивість знайдена, поверніть значення властивості. Якщо ні, поверніть `"Not Found"`.
 
 # --hints--
 
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/understand-string-immutability.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/understand-string-immutability.md
index 638fbf24f55..17838d6240a 100644
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/understand-string-immutability.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/understand-string-immutability.md
@@ -1,6 +1,6 @@
 ---
 id: 56533eb9ac21ba0edf2244ba
-title: Розуміння нестійкості рядка
+title: Незмінність рядка
 challengeType: 1
 videoUrl: 'https://scrimba.com/c/cWPVaUR'
 forumTopicId: 18331
@@ -9,16 +9,16 @@ dashedName: understand-string-immutability
 
 # --description--
 
-У JavaScript, `String` значення <dfn>immutable</dfn>, означає, що їх не можна буде змінити після створення.
+Значення рядка (`String`) у JavaScript є <dfn>незмінним</dfn>, тобто його не можна змінити після створення.
 
-For example, the following code will produce an error because the letter `B` in the string `Bob` cannot be changed to the letter `J`:
+Наприклад, наступний код спричинить помилку, оскільки літеру `B` у рядку `Bob` не можна змінити на літеру `J`:
 
 ```js
 let myStr = "Bob";
 myStr[0] = "J";
 ```
 
-Note that this does *not* mean that `myStr` could not be re-assigned. The only way to change `myStr` would be to assign it with a new value, like this:
+Зауважте, що це *не* означає, що `myStr` не можна повторно присвоїти. Єдиний спосіб змінити `myStr` – присвоїти нове значення:
 
 ```js
 let myStr = "Bob";
@@ -27,11 +27,11 @@ myStr = "Job";
 
 # --instructions--
 
-Виправте призначення `myStr` так, щоб код містив рядок зі значенням `Hello World`, використовуючи підхід, показаний вище.
+Використовуючи приклад вище, виправте присвоєння `myStr` так, щоб значенням рядка було `Hello World`.
 
 # --hints--
 
-`myStr` має мати значення рядка `Hello World`.
+`myStr` повинен мати значення рядка `Hello World`.
 
 ```js
 assert(myStr === 'Hello World');
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/understanding-boolean-values.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/understanding-boolean-values.md
index a9fc89baebe..7f360e08b1c 100644
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/understanding-boolean-values.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/understanding-boolean-values.md
@@ -1,6 +1,6 @@
 ---
 id: bd7123c9c441eddfaeb5bdef
-title: Розуміння булевих значень
+title: Булеві значення
 challengeType: 1
 videoUrl: 'https://scrimba.com/c/c9Me8t4'
 forumTopicId: 301176
@@ -9,9 +9,9 @@ dashedName: understanding-boolean-values
 
 # --description--
 
-Інший тип даних це <dfn>Boolean</dfn>. Булеві значення можуть мати лише два значення: `true` чи `false`. Фактично, це маленькі перемикачі, де `true` це "увімкнено" і `false` - "вимкнено". Ці два стани несумісні.
+Іншим типом даних є <dfn>булеві</dfn>. Булеві можуть мати лише два значення: `true` або `false`. По суті, це маленькі перемикачі, де `true` означає «увімкнено», а `false` означає «вимкнено». Ці два стани несумісні.
 
-**Note:** Булеві вирази ніколи не записуються в дужках. Рядки `"true"` й `"false"` не булеві і не мають особливого значення в JavaScript.
+**Примітка:** булеві значення завжди записують без лапок. Рядки `"true"` та `"false"` не є булевими та не мають особливого значення у JavaScript.
 
 # --instructions--
 
@@ -19,13 +19,13 @@ dashedName: understanding-boolean-values
 
 # --hints--
 
-Функція `welcomeToBooleans()` має повернути значення (`true` or `false`).
+Функція `welcomeToBooleans()` повинна повертати булеве значення (`true` або `false`).
 
 ```js
 assert(typeof welcomeToBooleans() === 'boolean');
 ```
 
-`welcomeToBooleans()` має повернути `true`.
+`welcomeToBooleans()` повинна повертати `true`.
 
 ```js
 assert(welcomeToBooleans() === true);
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/understanding-case-sensitivity-in-variables.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/understanding-case-sensitivity-in-variables.md
index 19a7875014d..320f8759ee6 100644
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/understanding-case-sensitivity-in-variables.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/understanding-case-sensitivity-in-variables.md
@@ -1,6 +1,6 @@
 ---
 id: 56533eb9ac21ba0edf2244ab
-title: Розуміння врахування регістру в змінних
+title: Чуттєвість змінних до регістру
 challengeType: 1
 videoUrl: 'https://scrimba.com/c/cd6GDcD'
 forumTopicId: 18334
@@ -9,13 +9,13 @@ dashedName: understanding-case-sensitivity-in-variables
 
 # --description--
 
-У JavaScript усі змінні та назви функцій існують з урахуванням регістру. Це означає, що написання з великої літери має значення.
+Усі назви змінних та функцій у JavaScript чуттєві до регістру. Це означає, що написання з великої літери має значення.
 
-`MYVAR` - це не теж саме, що й `MyVar` чи `myvar`. Цілком можливо мати декілька різних змінних з одинаковою назвою, але різним відмінком. Наполегливо рекомендується, щоб, заради чіткості, ви *не* використовували цю мовну особливість.
+`MYVAR` – це не саме, що `MyVar` чи `myvar`. Ви можете мати декілька різних змінних з одинаковою назвою, але різним регістром. Заради чіткості рекомендовано *не* використовувати цю особливість мови.
 
 **Найкраща практика**
 
-Напишіть назви змінних у JavaScript в <dfn>camelCase</dfn>. У <dfn>camelCase</dfn>, у назвах змінних, які складаються з декількох слів, перше слово ми пишемо з малої букви, а першу букву кожного наступного слова - з великої.
+Напишіть назви змінних у JavaScript <dfn>верблюдячимРегістром</dfn>. Назви змінних <dfn>верблюдячимРегістром</dfn> складаються з декількох слів, де перше слово ми пишемо з малої букви, а першу букву кожного наступного слова пишемо з великої.
 
 **Приклади:**
 
@@ -27,19 +27,19 @@ var thisVariableNameIsSoLong;
 
 # --instructions--
 
-Модифікуйте існуючі оголошення та завдання так, щоб їхні назви використовували <dfn>camelCase</dfn>.
+Змініть наявні оголошення та присвоєння так, щоб їхні назви були написані <dfn>верблюдячимРегістром</dfn>.
 
 Не створюйте жодних нових змінних.
 
 # --hints--
 
-`studlyCapVar` має бути визначене і мати значення `10`.
+`studlyCapVar` повинна бути визначеною та мати значення `10`.
 
 ```js
 assert(typeof studlyCapVar !== 'undefined' && studlyCapVar === 10);
 ```
 
-`properCamelCase` має бути визначене і мати значення рядка `A String`.
+`properCamelCase` повинна бути визначеною та мати значення рядка `A String`.
 
 ```js
 assert(
@@ -47,25 +47,25 @@ assert(
 );
 ```
 
-`titleCaseOver` має бути визначене і мати значення `9000`.
+`titleCaseOver` повинна бути визначеною та мати значення `9000`.
 
 ```js
 assert(typeof titleCaseOver !== 'undefined' && titleCaseOver === 9000);
 ```
 
-`studlyCapVar` має використовувати camelCase як в оголошенні, так і в розділах завдань.
+`studlyCapVar` повинна використовувати верблюдячийРегістр як в оголошенні, так і в присвоєнні.
 
 ```js
 assert(code.match(/studlyCapVar/g).length === 2);
 ```
 
-`properCamelCase` має використовувати camelCase як в оголошенні, так і в розділах завдань.
+`properCamelCase` повинна використовувати верблюдячийРегістр як в оголошенні, так і в присвоєнні.
 
 ```js
 assert(code.match(/properCamelCase/g).length === 2);
 ```
 
-`titleCaseOver` має використовувати camelCase як в оголошенні, так і в розділах завдань.
+`titleCaseOver` повинна використовувати верблюдячийРегістр як в оголошенні, так і в присвоєнні.
 
 ```js
 assert(code.match(/titleCaseOver/g).length === 2);
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/understanding-undefined-value-returned-from-a-function.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/understanding-undefined-value-returned-from-a-function.md
index 1da37c8da7a..5a0ed6ebc32 100644
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/understanding-undefined-value-returned-from-a-function.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/understanding-undefined-value-returned-from-a-function.md
@@ -1,6 +1,6 @@
 ---
 id: 598e8944f009e646fc236146
-title: Розуміння невизначеного значення, яке повернуто з функції
+title: Невизначене значення, повернуте з функції
 challengeType: 1
 videoUrl: 'https://scrimba.com/c/ce2p7cL'
 forumTopicId: 301177
@@ -9,7 +9,7 @@ dashedName: understanding-undefined-value-returned-from-a-function
 
 # --description--
 
-Функція може містити команду `return`, але не обов'язково. У цьому випадку функція не має команди `return`. Натомість, коли ви викликаєте її, функція обробляє внутрішній код, але повернене значення є `undefined`.
+Функція може містити інструкцію `return`, але це необов'язково. Якщо функція не має інструкції `return`, то під час виклику функція обробляє внутрішній код, але поверненим значенням є `undefined`.
 
 **Приклад**
 
@@ -23,33 +23,33 @@ function addSum(num) {
 addSum(3);
 ```
 
-`addSum` - це функція без команди `return`. Функція змінить загальну `sum` (суму) змінної, але повернене значення функції буде `undefined`.
+`addSum` є функцією без інструкції `return`. Функція змінить глобальну змінну `sum`, але поверненим значенням функції буде `undefined`.
 
 # --instructions--
 
-Створіть функцію `addFive` без аргументів. Ця функція додає 5 до `sum` (суми) змінної, але повернене значення є `undefined`.
+Створіть функцію `addFive` без аргументів. Ця функція додає 5 до змінної `sum`, але поверненим значенням є `undefined`.
 
 # --hints--
 
-`addFive` має бути функцією.
+`addFive` повинна бути функцією.
 
 ```js
 assert(typeof addFive === 'function');
 ```
 
-Після запуску обидвох функцій, `sum` має дорівнювати `8`.
+Після запуску обидвох функцій, `sum` повинна дорівнювати `8`.
 
 ```js
 assert(sum === 8);
 ```
 
-Повернене з `addFive` значення, має бути `undefined`.
+Поверненим значенням з `addFive` повинне бути `undefined`.
 
 ```js
 assert(addFive() === undefined);
 ```
 
-Всередині функції `addFive` вам слід додати `5` до `sum` змінної.
+Всередині функції `addFive` ви повинні додати `5` до змінної `sum`.
 
 ```js
 assert(
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/understanding-uninitialized-variables.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/understanding-uninitialized-variables.md
index 8aeb65007bd..81600b1d38d 100644
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/understanding-uninitialized-variables.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/understanding-uninitialized-variables.md
@@ -1,6 +1,6 @@
 ---
 id: 56533eb9ac21ba0edf2244aa
-title: Розуміння неініціалізованих змінних
+title: Неініціалізовані змінні
 challengeType: 1
 videoUrl: 'https://scrimba.com/c/cBa2JAL'
 forumTopicId: 18335
@@ -9,7 +9,7 @@ dashedName: understanding-uninitialized-variables
 
 # --description--
 
-Коли змінні JavaScript проголошено, вони мають початкове значення `undefined`. Якщо ви виконуєте математичну дію з `undefined` змінної, вашим результатом буде `NaN`, що означає <dfn>"Not a Number"</dfn>. If you concatenate a string with an `undefined` variable, you will get a <dfn>string</dfn> of `undefined`.
+Коли змінні у JavaScript оголошено, вони отримують початкове значення `undefined`. Якщо виконати математичну дію на змінній `undefined`, то результатом буде `NaN`, що означає «Not a Number» <dfn>(укр. «не є числом»)</dfn>. Якщо об’єднати рядок зі змінною `undefined`, ви отримаєте <dfn>рядок</dfn> з `undefined`.
 
 # --instructions--
 
@@ -17,25 +17,25 @@ dashedName: understanding-uninitialized-variables
 
 # --hints--
 
-`a` should be defined and have a final value of `6`.
+`a` повинна бути визначеною та мати кінцеве значення `6`.
 
 ```js
 assert(typeof a === 'number' && a === 6);
 ```
 
-`b` should be defined and have a final value of `15`.
+`b` повинна бути визначеною та мати кінцеве значення `15`.
 
 ```js
 assert(typeof b === 'number' && b === 15);
 ```
 
-`c` should not contain `undefined` and should have a final value of the string `I am a String!`
+`c` не повинна містити `undefined` та повинна мати кінцеве значення рядка `I am a String!`
 
 ```js
 assert(!/undefined/.test(c) && c === 'I am a String!');
 ```
 
-Вам не слід змінювати код під зазначеним коментарем.
+Не змінюйте код під зазначеним коментарем.
 
 ```js
 assert(
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/updating-object-properties.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/updating-object-properties.md
index 933435b6819..179b115adaa 100644
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/updating-object-properties.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/updating-object-properties.md
@@ -9,7 +9,7 @@ dashedName: updating-object-properties
 
 # --description--
 
-Після того, як ви створили об'єкт JavaScript, ви можете оновити його властивості в будь-який час, так як і будь-які інші його змінні. Ви можете використовувати точкову або дужкову нотацію для оновлення.
+Після створення об’єкта JavaScript ви можете будь-коли оновити його властивості так само, як оновлювали б будь-яку іншу змінну. Для оновлення можна використати точкову або дужкову нотацію.
 
 Наприклад, погляньмо на `ourDog`:
 
@@ -22,21 +22,21 @@ const ourDog = {
 };
 ```
 
-Оскільки це винятково щасливий собака, змінімо його ім'я на рядок `Happy Camper`. Ось як ми оновимо властивість імені його об'єкта: `ourDog.name = "Happy Camper";` або `ourDog["name"] = "Happy Camper";` Тепер коли ми оцінюємо `ourDog.name`, замість того, щоб отримати `Camper`, ми отримаємо його нове ім'я `Happy Camper`.
+Оскільки це особливо щаслива собака, змінимо його ім'я на рядок `Happy Camper`. Ось як ми оновлюємо властивість назви об’єкта: `ourDog.name = "Happy Camper";` або `ourDog["name"] = "Happy Camper";`. Тепер, коли ми визначаємо `ourDog.name`, замість `Camper` ми отримуватимемо нове ім’я `Happy Camper`.
 
 # --instructions--
 
-Оновити властивість імені об'єкта `myDog`. Змінімо його ім'я з `Coder` на `Happy Coder`. Ви можете використати точкову або дужкову нотацію.
+Оновіть властивість імені об'єкта `myDog`. Змінимо ім'я з `Coder` на `Happy Coder`. Ви можете використати точкову або дужкову нотацію.
 
 # --hints--
 
-Вам слід оновити властивість `name` `myDog`, щоб вона дорівнювала рядку`Happy Coder`.
+Ви повинні оновити властивість `name` об’єкта `myDog`, щоб вона дорівнювала рядку `Happy Coder`.
 
 ```js
 assert(/happy coder/gi.test(myDog.name));
 ```
 
-Не слід змінювати визначення `myDog`.
+Ви не повинні редагувати визначення `myDog`.
 
 ```js
 assert(/"name": "Coder"/.test(code));
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/use-bracket-notation-to-find-the-first-character-in-a-string.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/use-bracket-notation-to-find-the-first-character-in-a-string.md
index 88cfff3c774..997e60c6b65 100644
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/use-bracket-notation-to-find-the-first-character-in-a-string.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/use-bracket-notation-to-find-the-first-character-in-a-string.md
@@ -1,6 +1,6 @@
 ---
 id: bd7123c9c549eddfaeb5bdef
-title: Використовуйте Дужкову Нотацію для Пошуку Першого Символу в Рядку
+title: Дужкова нотація для пошуку першого символа рядка
 challengeType: 1
 videoUrl: 'https://scrimba.com/c/ca8JwhW'
 forumTopicId: 18341
@@ -9,26 +9,26 @@ dashedName: use-bracket-notation-to-find-the-first-character-in-a-string
 
 # --description--
 
-<dfn>Дужкова нотація</dfn> - це спосіб отримання символу з певним індексом в рядку.
+Завдяки <dfn>дужковій нотації</dfn> можна отримати символ з певним індексом в рядку.
 
-Більшість сучасних мов програмування, таких як JavaScript, не починають рахувати з 1, як це роблять люди. Вони починають з 0. Це називають індексація <dfn>на основі нуля</dfn>.
+Більшість сучасних мов програмування, наприклад JavaScript, не починають рахунок з 1, як це роблять люди. Вони починають з 0. Це називається індексацією <dfn>на основі нуля</dfn>.
 
-Наприклад, символ з індексом 0 у слові `Charles` буде `C`. Отже, якщо `const firstName = "Charles"`, ви можете отримати значення першої літери рядка, використовуючи `firstName[0]`.
+Наприклад, символом з індексом 0 у слові `Charles` буде `C`. Тому, якщо `const firstName = "Charles"`, ви можете отримати значення першої літери рядка, використовуючи `firstName[0]`.
 
-Наприклад:
+Приклад:
 
 ```js
 const firstName = "Charles";
 const firstLetter = firstName[0];
 ```
 
-`firstLetter` повинна мати значення рядка `C`.
+`firstLetter` матиме значення рядка `C`.
 
 # --instructions--
 
-Використовуйте дужкову нотацію, щоб знайти перший символ в змінній `lastName` та задайте його до `firstLetterOfLastName`.
+Використайте дужкову нотацію, щоб знайти перший символ у змінній `lastName` та призначте його до `firstLetterOfLastName`.
 
-**Підказка:**Спробуйте подивитися на приклад вище, якщо застрягли.
+**Підказка:** якщо застрягли, перегляньте вищеподаний приклад.
 
 # --hints--
 
@@ -38,7 +38,7 @@ const firstLetter = firstName[0];
 assert(firstLetterOfLastName === 'L');
 ```
 
-Вам слід використовувати дужкову нотацію.
+Ви повинні використати дужкову нотацію.
 
 ```js
 assert(code.match(/firstLetterOfLastName\s*=\s*lastName\s*\[\s*\d\s*\]/));
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/use-bracket-notation-to-find-the-last-character-in-a-string.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/use-bracket-notation-to-find-the-last-character-in-a-string.md
index d0476568550..56ce0139fc6 100644
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/use-bracket-notation-to-find-the-last-character-in-a-string.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/use-bracket-notation-to-find-the-last-character-in-a-string.md
@@ -1,6 +1,6 @@
 ---
 id: bd7123c9c451eddfaeb5bdef
-title: Використовуйте Дужкову Нотацію для Пошуку Останнього Символу в Рядку
+title: Дужкова нотація для пошуку останнього символа рядка
 challengeType: 1
 videoUrl: 'https://scrimba.com/c/cBZQGcv'
 forumTopicId: 18342
@@ -9,28 +9,28 @@ dashedName: use-bracket-notation-to-find-the-last-character-in-a-string
 
 # --description--
 
-Щоб отримати останню літеру рядка, ви можете відняти її від довжини рядка.
+Щоб отримати останню літеру рядка, можна відняти одиницю від довжини рядка.
 
-Наприклад, якщо `const firstName = "Ada"`, ви можете отримати значення останньої літери, використовуючи `firstName[firstName.length - 1]`.
+Наприклад, якщо `const firstName = "Ada"`, ви можете отримати значення останньої літери, використавши `firstName[firstName.length - 1]`.
 
-Наприклад:
+Приклад:
 
 ```js
 const firstName = "Ada";
 const lastLetter = firstName[firstName.length - 1];
 ```
 
-`lastLetter` повинна мати значення рядка `a`.
+`lastLetter` матиме значення рядка `a`.
 
 # --instructions--
 
-Використовуйте <dfn>дужкову нотацію</dfn>, щоб знайти останній символ у змінній `lastName`.
+Використайте <dfn>дужкову нотацію</dfn>, щоб знайти останній символ у змінній `lastName`.
 
-**Підказка:**Спробуйте подивитися на приклад вище, якщо застрягли.
+**Підказка:** якщо застрягли, перегляньте вищеподаний приклад.
 
 # --hints--
 
-`lastLetterOfLastName` повинно бути літерою `e`.
+`lastLetterOfLastName` повинна бути літера `e`.
 
 ```js
 assert(lastLetterOfLastName === 'e');
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/use-bracket-notation-to-find-the-nth-character-in-a-string.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/use-bracket-notation-to-find-the-nth-character-in-a-string.md
index 7a2a1ae2423..4443cc2eae7 100644
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/use-bracket-notation-to-find-the-nth-character-in-a-string.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/use-bracket-notation-to-find-the-nth-character-in-a-string.md
@@ -1,6 +1,6 @@
 ---
 id: bd7123c9c450eddfaeb5bdef
-title: Використовуйте Дужкову Нотацію для Пошуку N-го Символу в Рядку
+title: Дужкова нотація для пошуку n-го символа рядка
 challengeType: 1
 videoUrl: 'https://scrimba.com/c/cWPVJua'
 forumTopicId: 18343
@@ -9,24 +9,24 @@ dashedName: use-bracket-notation-to-find-the-nth-character-in-a-string
 
 # --description--
 
-Ви можете також використовувати <dfn>дужкову нотацію</dfn>, щоб отримати символ на інших позиціях в рядку.
+Ви також можете використати <dfn>дужкову нотацію</dfn>, щоб отримати символ на інших позиціях рядка.
 
-Пам'ятайте, що комп'ютер починає рахувати з `0`, тому перший символ є в дійсності нульовим.
+Пам’ятайте, що комп’ютер починає рахувати з `0`, тому насправді першим символом є нульовий.
 
-Наприклад:
+Приклад:
 
 ```js
 const firstName = "Ada";
 const secondLetterOfFirstName = firstName[1];
 ```
 
-`secondLetterOfFirstName` повинна мати значення рядка `d`.
+`secondLetterOfFirstName` матиме значення рядка `d`.
 
 # --instructions--
 
-Спробуйте встановити `thirdLetterOfLastName` на рівні третьої літери змінної `lastName`, використовуючи дужкову нотацію.
+Спробуйте встановити `thirdLetterOfLastName`, щоб вона дорівнювала третій літері змінної `lastName`, використовуючи дужкову нотацію.
 
-**Підказка:** Спробуйте подивитися на приклад вище, якщо застрягли.
+**Підказка:** якщо застрягли, перегляньте вищеподаний приклад.
 
 # --hints--
 
@@ -36,7 +36,7 @@ const secondLetterOfFirstName = firstName[1];
 assert(thirdLetterOfLastName === 'v');
 ```
 
-Вам слід використовувати дужкову нотацію.
+Ви повинні використати дужкову нотацію.
 
 ```js
 assert(code.match(/thirdLetterOfLastName\s*=\s*lastName\s*\[\s*\d\s*\]/));
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/use-bracket-notation-to-find-the-nth-to-last-character-in-a-string.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/use-bracket-notation-to-find-the-nth-to-last-character-in-a-string.md
index 2f0dd284938..b698783888b 100644
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/use-bracket-notation-to-find-the-nth-to-last-character-in-a-string.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/use-bracket-notation-to-find-the-nth-to-last-character-in-a-string.md
@@ -1,6 +1,6 @@
 ---
 id: bd7123c9c452eddfaeb5bdef
-title: Використовуйте Дужкову Нотацію для Пошуку Символу N-го до Останнього в Рядку
+title: Дужкова нотація для пошуку n-го символа з кінця рядка
 challengeType: 1
 videoUrl: 'https://scrimba.com/c/cw4vkh9'
 forumTopicId: 18344
@@ -9,34 +9,34 @@ dashedName: use-bracket-notation-to-find-the-nth-to-last-character-in-a-string
 
 # --description--
 
-Ви можете використовувати той самий принцип, який ми використовували для отримання останнього символу в рядку, щоб отримати символ N-го до останнього.
+Ви можете використати той самий принцип, який ми щойно використовували для отримання останнього символу в рядку, щоб отримати n-ий символ з кінця.
 
-Наприклад, ви можете отримати значення третьої до останньої літери рядка `const firstName = "Augusta"`, використовуючи `firstName[firstName.length - 3]`
+Наприклад, ви можете отримати значення третьої з кінця літери рядка `const firstName = "Augusta"`, використавши `firstName[firstName.length - 3]`
 
-Наприклад:
+Приклад:
 
 ```js
 const firstName = "Augusta";
 const thirdToLastLetter = firstName[firstName.length - 3];
 ```
 
-`thirdToLastLetter` повинен мати значення рядка `s`.
+`thirdToLastLetter` матиме значення рядка `s`.
 
 # --instructions--
 
-Використовуйте <dfn>дужкову нотацію</dfn> для пошуку передостаннього символу в `lastName` в рядку.
+Використайте <dfn>дужкову нотацію</dfn>, щоб знайти другий з кінця символ у рядку `lastName`.
 
-**Підказка:**Спробуйте подивитися на приклад вище, якщо застрягли.
+**Підказка:** якщо застрягли, перегляньте вищеподаний приклад.
 
 # --hints--
 
-`secondToLastLetterOfLastName` повинно бути літерою `c`.
+`secondToLastLetterOfLastName` повинна бути літера `c`.
 
 ```js
 assert(secondToLastLetterOfLastName === 'c');
 ```
 
-Вам слід використовувати `.length`, щоб отримати передостанню літеру.
+Ви повинні використати `.length`, щоб отримати передостанню літеру.
 
 ```js
 assert(code.match(/\.length/g).length > 0);
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/use-conditional-logic-with-if-statements.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/use-conditional-logic-with-if-statements.md
index d743b19a570..c4258e437f1 100644
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/use-conditional-logic-with-if-statements.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/use-conditional-logic-with-if-statements.md
@@ -1,6 +1,6 @@
 ---
 id: cf1111c1c12feddfaeb3bdef
-title: Використання умовної логіки з командою if
+title: Використання умовної логіки з інструкцією if
 challengeType: 1
 videoUrl: 'https://scrimba.com/c/cy87mf3'
 forumTopicId: 18348
@@ -9,15 +9,15 @@ dashedName: use-conditional-logic-with-if-statements
 
 # --description--
 
-Інструкції `If` використовуються для прийняття рішень у коді. Ключове слово `if` наказує JavaScript виконати код у фігурних дужках за певних умов, вказаних у круглих дужках. Ці умови ще називаються умовами `Boolean` і вони можуть бути лише `true` або `false`.
+Інструкції `if` використовують для прийняття рішень у коді. Ключове слово `if` вказує JavaScript виконати код у фігурних дужках за певних умов, вказаних у круглих дужках. Ці умови ще називаються булевими умовами (`Boolean`), і вони можуть бути лише `true` або `false`.
 
-Коли умова є оціненою як `true`, програма виконує команду у фігурних дужках. Коли булева умова є оцінена як `false`, команда у фігурних дужках не буде виконана.
+Якщо умова оцінена як `true`, програма виконує інструкцію у фігурних дужках. Якщо булева умова оцінена як `false`, команда у фігурних дужках не виконується.
 
 **Псевдокод**
 
-<blockquote>if (<i>condition is true</i>) {<br>  <i>statement is executed</i><br>}</blockquote>
+<blockquote>if (<i>умова оцінена як true</i>) {<br>  <i>інструкція виконується</i><br>}</blockquote>
 
-**Наприклад:**
+**Приклад**
 
 ```js
 function test (myCondition) {
@@ -33,39 +33,39 @@ test(false);
 
 `test(true)` повертає рядок `It was true`, а `test(false)` повертає рядок `It was false`.
 
-Коли `test` отримує значення `true`, оператор `if` оцінює `myCondition`, щоб побачити чи воно є `true` чи ні. Оскільки це `true`, функція повертає `It was true`. Коли ми викликаємо `test` зі значенням `false`, `myCondition` *не* `true`, інструкція у круглих дужках не виконується та функція повертає `It was false`.
+Коли `test` викликається зі значенням `true`, інструкція `if` оцінює `myCondition`, щоб побачити чи воно `true`. Оскільки воно `true`, функція повертає `It was true`. Коли ми викликаємо `test` зі значенням `false`, то `myCondition` *не* оцінюється як `true`, інструкція у круглих дужках не виконується та функція повертає `It was false`.
 
 # --instructions--
 
-Створіть оператора `if` всередині функції, щоб повернути `Yes, that was true`, якщо параметр `wasThatTrue` є `true` та повернути `No, that was false` у протилежному випадку.
+Створіть інструкцію `if` всередині функції, щоб повернути `Yes, that was true`, якщо параметр `wasThatTrue` є `true` та повернути `No, that was false` у протилежному випадку.
 
 # --hints--
 
-`trueOrFalse` повинен бути функцією
+`trueOrFalse` повинна бути функцією
 
 ```js
 assert(typeof trueOrFalse === 'function');
 ```
 
-`trueOrFalse(true)` повинен повертати рядок
+`trueOrFalse(true)` повинна повертати рядок
 
 ```js
 assert(typeof trueOrFalse(true) === 'string');
 ```
 
-`trueOrFalse(false)` повинен повертати рядок
+`trueOrFalse(false)` повинна повертати рядок
 
 ```js
 assert(typeof trueOrFalse(false) === 'string');
 ```
 
-`trueOrFalse(true)` повинен повертати рядок `Yes, that was true`
+`trueOrFalse(true)` повинна повертати рядок `Yes, that was true`
 
 ```js
 assert(trueOrFalse(true) === 'Yes, that was true');
 ```
 
-`trueOrFalse(false)` повинен повертати рядок `No, that was false`
+`trueOrFalse(false)` повинна повертати рядок `No, that was false`
 
 ```js
 assert(trueOrFalse(false) === 'No, that was false');
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/use-multiple-conditional-ternary-operators.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/use-multiple-conditional-ternary-operators.md
index a33c54866ef..3b7d6708b85 100644
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/use-multiple-conditional-ternary-operators.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/use-multiple-conditional-ternary-operators.md
@@ -1,6 +1,6 @@
 ---
 id: 587d7b7e367417b2b2512b21
-title: Використання декількох умовних (трикомпонентних) операторів
+title: Використання декількох умовних (тернарних) операторів
 challengeType: 1
 videoUrl: 'https://scrimba.com/c/cyWJBT4'
 forumTopicId: 301179
@@ -11,7 +11,7 @@ dashedName: use-multiple-conditional-ternary-operators
 
 У попередньому завданні ви використовували одинарний умовний оператор. Ви також можете їх об'єднати для того, щоб перевірити декілька умов.
 
-Наступна функція використовує `if`, `else if`, а також `else` твердження, щоб перевірити декілька умов:
+Наступна функція використовує інструкції `if`, `else if` та `else`, щоб перевірити декілька умов:
 
 ```js
 function findGreaterOrEqual(a, b) {
@@ -47,29 +47,29 @@ function findGreaterOrEqual(a, b) {
 
 # --instructions--
 
-У функції `checkSign`, використовуйте декілька умовних операторів, дотримуючись рекомендованого формату, що використаний у `findGreaterOrEqual` - для того, щоб перевірити чи число додатнє, від'ємне або нуль. Функція має повернути `positive`, `negative` or `zero`.
+Використайте декілька умовних операторів у функції `checkSign`, дотримуючись рекомендованого формату, використаного у `findGreaterOrEqual`, щоб перевірити, чи число додатнє, від’ємне або дорівнює нулю. Функція повинна повертати `positive`, `negative` або `zero`.
 
 # --hints--
 
-`checkSign` має використовувати декілька умовних операторів
+`checkSign` повинна використовувати декілька умовних операторів
 
 ```js
 assert(/.+?\s*?\?\s*?.+?\s*?:\s*?.+?\s*?\?\s*?.+?\s*?:\s*?.+?/gi.test(code));
 ```
 
-`checkSign(10)` повинен повертати рядок `positive`. Зверніть увагу на те, що написання з великої літери - важливе
+`checkSign(10)` повинна повертати рядок `positive`. Зверніть увагу на те, що важливе написання з великої/малої літери
 
 ```js
 assert(checkSign(10) === 'positive');
 ```
 
-`checkSign(-12)` повинен повертати рядок `negative`. Зверніть увагу на те, що написання з великої літери - важливе
+`checkSign(-12)` повинна повертати рядок `negative`. Зверніть увагу на те, що важливе написання з великої/малої літери
 
 ```js
 assert(checkSign(-12) === 'negative');
 ```
 
-`checkSign(0)` повинен повертати рядок `zero`. Зверніть увагу на те, що написання з великої літери - важливе
+`checkSign(0)` повинна повертати рядок `zero`. Зверніть увагу на те, що важливе написання з великої/малої літери
 
 ```js
 assert(checkSign(0) === 'zero');
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/use-recursion-to-create-a-countdown.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/use-recursion-to-create-a-countdown.md
index b46d142741e..95b5c3d366a 100644
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/use-recursion-to-create-a-countdown.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/use-recursion-to-create-a-countdown.md
@@ -1,6 +1,6 @@
 ---
 id: 5cd9a70215d3c4e65518328f
-title: Використовуйте рекурсію для створення зворотного відліку
+title: Використання рекурсії для створення зворотного відліку
 challengeType: 1
 forumTopicId: 305925
 dashedName: use-recursion-to-create-a-countdown
@@ -8,11 +8,11 @@ dashedName: use-recursion-to-create-a-countdown
 
 # --description--
 
-In a <a href="/learn/javascript-algorithms-and-data-structures/basic-javascript/replace-loops-using-recursion" target="_blank" rel="noopener noreferrer nofollow">previous challenge</a>, you learned how to use recursion to replace a `for` loop. Тепер подивимося на більш складну функцію, яка повертає масив послідовних чисел, починаючи з `1` до числа, переданого функції.
+У <a href="/ukrainian/learn/javascript-algorithms-and-data-structures/basic-javascript/replace-loops-using-recursion" target="_blank" rel="noopener noreferrer nofollow">попередньому завданні</a> ви дізнались, як використовувати рекурсію для заміни циклів `for`. Тепер розглянемо складнішу функцію, яка повертає масив послідовних цілих чисел, починаючи з `1` до числа, переданого функції.
 
-Як уже було згадано в попередньому завданні, це буде <dfn>base case</dfn>. Він повідомляє рекурсивній функції, коли їй більше не потрібно викликати саму себе. Це простий випадок, коли значення, яке повертається, вже відоме. Також існує <dfn>recursive call</dfn>, який виконує початкову функцію з різними параметрами. Якщо функція написана правильно, то буде досягнутий базовий випадок.
+Як було згадано в попередньому завданні, ми матимемо <dfn>базовий випадок</dfn>. Він повідомляє рекурсивній функції, коли їй більше не потрібно викликати саму себе. Це простий випадок, коли повернене значення вже відоме. Також існує <dfn>рекурсивний виклик</dfn>, який виконує початкову функцію з різними аргументами. Якщо функція написана правильно, то буде досягнутий базовий випадок.
 
-Наприклад, скажімо, ви хочете написати рекурсивну функцію, яка повертає масив, що містить числа від `1` до `n`. Цій функції потрібно прийняти параметр `n`, який означає остаточне число. Тоді їй потрібно викликати саму себе, поступово зменшуючи значення числа `n`, поки воно не досягне `1`. Ви можете написати функцію наступним чином:
+Скажімо, ви хочете написати рекурсивну функцію, що повертає масив, який містить числа від `1` до `n`. Цій функції потрібно прийняти аргумент `n`, який позначає кінцеве число. Тоді їй потрібно викликати саму себе, поступово зменшуючи значення числа `n`, поки воно не досягне `1`. Ви можете написати функцію наступним чином:
 
 ```javascript
 function countup(n) {
@@ -29,33 +29,33 @@ console.log(countup(5));
 
 Значення `[1, 2, 3, 4, 5]` будуть відображені на консолі.
 
-Спочатку це може здатися парадоксальним, адже значення `n` *зростає*, але значення у остаточному масиві *зростають*. Так відбувається, тому що підвищення відбувається останнім після рекурсивного виклику. У точці, де `n` вставляється в масив `countup(n - 1)` вже проаналізовано та повернуто `[1, 2, ..., n - 1]`.
+Спочатку це може здатися парадоксальним, адже значення `n` *зменшується*, а значення у кінцевому масиві *збільшується*. Так відбувається через те, що збільшення відбувається останнім, після повернення рекурсивного виклику. На моменті, коли `n` поміщається у масив, `countup(n - 1)` вже проаналізований та повернуто `[1, 2, ..., n - 1]`.
 
 # --instructions--
 
-Ми вже визначили функцію під назвою `countdown` з одним параметром (`n`). Функція має використовувати рекурсію, щоб повернути масив, який містить цілі числа від `n` до `1` на основі параметра `n`. Якщо функція викликається числом меншим за 1, вона має повернути порожній масив. Наприклад, виклик цієї функції зі значенням `n = 5` має повернути масив `[5, 4, 3, 2, 1]`. Ваша функція має використовувати рекурсію шляхом виклику самої себе, але не повинна використовувати ніякі цикли.
+Ми вже визначили функцію під назвою `countdown` з одним параметром (`n`). Функція повинна використовувати рекурсію, щоб повернути масив, який містить цілі числа від `n` до `1` на основі параметра `n`. Якщо функція викликається числом меншим за 1, вона повинна повернути порожній масив. Наприклад, якщо викликати цю функцію із `n = 5`, повинен повернутися масив `[5, 4, 3, 2, 1]`. Ваша функція повинна використовувати рекурсію, викликаючи саму себе, та не повинна використовувати цикли.
 
 # --hints--
 
-`countdown(-1)` має повернути пустий масив.
+`countdown(-1)` повинна повертати порожній масив.
 
 ```js
 assert.isEmpty(countdown(-1));
 ```
 
-`countdown(10)` має повернути `[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]`
+`countdown(10)` повинна повертати `[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]`
 
 ```js
 assert.deepStrictEqual(countdown(10), [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]);
 ```
 
-`countdown(5)` має повернути `[5, 4, 3, 2, 1]`
+`countdown(5)` повинна повертати `[5, 4, 3, 2, 1]`
 
 ```js
 assert.deepStrictEqual(countdown(5), [5, 4, 3, 2, 1]);
 ```
 
-Ваш код не має опиратися на жодні цикли (`for`, `while` або функції більш високого порядку, такі як `forEach`, `map`, `filter`, and `reduce`).
+Ваш код не повинен опиратися на жодні цикли (`for`, `while` або функції вищого порядку, як-от `forEach`, `map`, `filter` або `reduce`).
 
 ```js
 assert(
@@ -63,7 +63,7 @@ assert(
 );
 ```
 
-Вам слід використати рекурсію, щоб вирішити цю проблему.
+Ви повинні використати рекурсію, щоб розв’язати це завдання.
 
 ```js
 assert(
@@ -71,7 +71,7 @@ assert(
 );
 ```
 
-Global variables should not be used to cache the array.
+Не використовуйте глобальні змінні для кешування масиву.
 
 ```js
 countdown(1)
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/use-recursion-to-create-a-range-of-numbers.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/use-recursion-to-create-a-range-of-numbers.md
index 52192450bb6..3f27bed193c 100644
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/use-recursion-to-create-a-range-of-numbers.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/use-recursion-to-create-a-range-of-numbers.md
@@ -8,11 +8,11 @@ dashedName: use-recursion-to-create-a-range-of-numbers
 
 # --description--
 
-Продовжуючи попереднє завдання, ми пропонуємо вам ще одну можливість створити рекурсивну функцію для вирішення проблеми.
+Продовжуючи попереднє завдання, ми пропонуємо створити рекурсивну функцію ще раз, щоб розв’язати завдання.
 
 # --instructions--
 
-Ми визначили функцію під назвою `rangeOfNumbers` з двома параметрами. Функція повинна повернути масив цілих чисел, що починаються з числа, представленого параметром `startNum` і закінчується числом, яке представлене параметром `endNum`. Початкове число завжди буде меншим або рівним кінцевому номеру. Ваша функція має використовувати рекурсію, викликаючи сама себе, але не повинна використовувати якісь цикли. Вона також повинна працювати у випадках, коли`startNum` і `endNum` однакові.
+Ми визначили функцію під назвою `rangeOfNumbers` з двома параметрами. Функція повинна повернути масив цілих чисел, що починається з числа, представленого параметром `startNum` і закінчується числом, представленим параметром `endNum`. Початкове число завжди буде меншим або дорівнюватиме кінцевому числу. Ваша функція повинна використовувати рекурсію, викликаючи саму себе, та не повинна використовувати цикли. Вона також повинна працювати, якщо `startNum` та `endNum` однакові.
 
 # --hints--
 
@@ -22,7 +22,7 @@ dashedName: use-recursion-to-create-a-range-of-numbers
 assert(Array.isArray(rangeOfNumbers(5, 10)));
 ```
 
-У вашому коді не повинні використовуватися ніякі циклічні синтаксичні структури (`for` або `while` або функції вищого порядку, такі як `forEach`, `map`, `filter`, або `reduce`).
+Ваш код не повинен використовувати синтаксиси циклу (`for`, `while` або функції вищого порядку, як-от `forEach`, `map`, `filter` або `reduce`).
 
 ```js
 assert(
@@ -30,7 +30,7 @@ assert(
 );
 ```
 
-`rangeOfNumbers` повинен використовувати рекурсію (викликати самого себе) для вирішення цьгого завдання.
+`rangeOfNumbers` повинна використовувати рекурсію (викликати саму себе), щоб розв’язати це завдання.
 
 ```js
 assert(
@@ -38,25 +38,25 @@ assert(
 );
 ```
 
-`rangeOfNumbers(1, 5)` повинен повертати `[1, 2, 3, 4, 5]`.
+`rangeOfNumbers(1, 5)` повинна повертати `[1, 2, 3, 4, 5]`.
 
 ```js
 assert.deepStrictEqual(rangeOfNumbers(1, 5), [1, 2, 3, 4, 5]);
 ```
 
-`rangeOfNumbers(6, 9)` повинен повертати `[6, 7, 8, 9]`.
+`rangeOfNumbers(6, 9)` повинна повертати `[6, 7, 8, 9]`.
 
 ```js
 assert.deepStrictEqual(rangeOfNumbers(6, 9), [6, 7, 8, 9]);
 ```
 
-`rangeOfNumbers(4, 4)` повинен повертати `[4]`.
+`rangeOfNumbers(4, 4)` повинна повертати `[4]`.
 
 ```js
 assert.deepStrictEqual(rangeOfNumbers(4, 4), [4]);
 ```
 
-Global variables should not be used to cache the array.
+Не використовуйте глобальні змінні для кешування масиву.
 
 ```js
 rangeOfNumbers(1, 3)
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/use-the-conditional-ternary-operator.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/use-the-conditional-ternary-operator.md
index 80716483e62..5e9fe8c9050 100644
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/use-the-conditional-ternary-operator.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/use-the-conditional-ternary-operator.md
@@ -1,6 +1,6 @@
 ---
 id: 587d7b7e367417b2b2512b24
-title: Використання умовного (трикомпонентного) оператора
+title: Використання умовного (тернарного) оператора
 challengeType: 1
 forumTopicId: 301181
 dashedName: use-the-conditional-ternary-operator
@@ -8,11 +8,11 @@ dashedName: use-the-conditional-ternary-operator
 
 # --description--
 
-<dfn>Умовний оператор</dfn>, який також називається <dfn>трикомпонентним оператором</dfn>, може використовуватися як однорядковий "if-else" вираз.
+<dfn>Умовний оператор</dfn>, який також називається <dfn>тернарним оператором</dfn>, можна використовувати як однорядкову інструкцію «if-else».
 
-Синтаксисом є `a ? b : c`, де `a` - це умова, `b` - це код, що запускається, коли умова повертає `true` і `c` - код, що запускається, коли умова повертає `false`.
+Синтаксисом є `a ? b : c`, де `a` – умова, `b` – код, якщо умова повертає `true` та `c` – код, якщо умова повертає `false`.
 
-Ця функція використовує `if/else` твердження для того, щоб перевірити умову:
+Ця функція використовує інструкцію `if/else`, щоб перевірити умову:
 
 ```js
 function findGreater(a, b) {
@@ -35,29 +35,29 @@ function findGreater(a, b) {
 
 # --instructions--
 
-Використовуйте умовний оператор у функції `checkEqual`, щоб перевірити чи два числа рівні, чи ні. Функція повинна повернути рядок `Equal` або рядок `Not Equal`.
+Використайте умовний оператор у функції `checkEqual`, щоб перевірити, чи два числа рівні. Функція повинна повернути рядок `Equal` або рядок `Not Equal`.
 
 # --hints--
 
-`checkEqual` має використовувати умовний оператор
+`checkEqual` повинна використовувати умовний оператор
 
 ```js
 assert(/.+?\s*?\?\s*?.+?\s*?:\s*?.+?/.test(code));
 ```
 
-`checkEqual(1, 2)` повинен повертати рядок `Not Equal`
+`checkEqual(1, 2)` повинна повертати рядок `Not Equal`
 
 ```js
 assert(checkEqual(1, 2) === 'Not Equal');
 ```
 
-`checkEqual(1, 1)` повинен повертати рядок `Equal`
+`checkEqual(1, 1)` повинна повертати рядок `Equal`
 
 ```js
 assert(checkEqual(1, 1) === 'Equal');
 ```
 
-`checkEqual(1, -1)` повинен повертати рядок `Not Equal`
+`checkEqual(1, -1)` повинна повертати рядок `Not Equal`
 
 ```js
 assert(checkEqual(1, -1) === 'Not Equal');
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/use-the-parseint-function-with-a-radix.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/use-the-parseint-function-with-a-radix.md
index 6122e32ee71..20165988bd6 100644
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/use-the-parseint-function-with-a-radix.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/use-the-parseint-function-with-a-radix.md
@@ -1,6 +1,6 @@
 ---
 id: 587d7b7e367417b2b2512b22
-title: Використайте функцію ParseInt з радіусом
+title: Використання функції parseInt з розрядом
 challengeType: 1
 videoUrl: 'https://scrimba.com/c/c6K4Kh3'
 forumTopicId: 301182
@@ -9,7 +9,7 @@ dashedName: use-the-parseint-function-with-a-radix
 
 # --description--
 
-Функція `parseInt()` аналізує рядок і повертає ціле число. Для радікса потрібен другий аргумент, який визначає основу числа у рядку. Радіксом може бути ціле число від 2 до 36.
+Функція `parseInt()` аналізує рядок і повертає ціле число. Вона приймає другий аргумент для розряду, який вказує базу числа в рядку. Розрядом може бути ціле число від 2 до 36.
 
 Виклик функції виглядає так:
 
@@ -23,39 +23,39 @@ parseInt(string, radix);
 const a = parseInt("11", 2);
 ```
 
-Змінна радікса говорить, що `11` знаходиться у двійковій системі або у базі 2. Цей приклад перетворює рядок `11` на ціле число `3`.
+Змінна розряду каже, що `11` знаходиться у двійковій системі, або у базі 2. Цей приклад перетворює рядок `11` на ціле число `3`.
 
 # --instructions--
 
-Використовуйте `parseInt()` у функції `convertToInteger`, щоб воно перетворило двійкове число на ціле число і повернуло його.
+Використайте `parseInt()` у функції `convertToInteger`, щоб двійкове число перетворилось на ціле число і повернулось.
 
 # --hints--
 
-`convertToInteger` має використати функцію `parseInt()`
+`convertToInteger` повинна використовувати функцію `parseInt()`
 
 ```js
 assert(/parseInt/g.test(code));
 ```
 
-`convertToInteger("10011")` має повернути число
+`convertToInteger("10011")` повинна повертати число
 
 ```js
 assert(typeof convertToInteger('10011') === 'number');
 ```
 
-`convertToInteger("10011")` має повернути 19
+`convertToInteger("10011")` повинна повертати 19
 
 ```js
 assert(convertToInteger('10011') === 19);
 ```
 
-`convertToInteger("111001")` має повернути 57
+`convertToInteger("111001")` повинна повертати 57
 
 ```js
 assert(convertToInteger('111001') === 57);
 ```
 
-`convertToInteger("JamesBond")` має повернути `NaN`
+`convertToInteger("JamesBond")` повинна повертати `NaN`
 
 ```js
 assert.isNaN(convertToInteger('JamesBond'));
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/use-the-parseint-function.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/use-the-parseint-function.md
index 6aba56ffb0a..2c346959fca 100644
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/use-the-parseint-function.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/use-the-parseint-function.md
@@ -1,6 +1,6 @@
 ---
 id: 587d7b7e367417b2b2512b23
-title: Використовуйте Функцію parseInt
+title: Використання функції parseInt
 challengeType: 1
 videoUrl: 'https://scrimba.com/c/cm83LSW'
 forumTopicId: 301183
@@ -15,39 +15,39 @@ dashedName: use-the-parseint-function
 const a = parseInt("007");
 ```
 
-Наведена вище функція перетворює рядок `007` у ціле `7`. Якщо перший символ у рядку не може бути перетвореним у число, тоді він повертає `NaN`.
+Наведена вище функція перетворює рядок `007` на ціле число `7`. Якщо перший символ у рядку не можна перетворити на число, повертається `NaN`.
 
 # --instructions--
 
-Використовуйте `parseInt()` у функції `convertToInteger`, щоб вона конвертувала вхідний рядок `str` у ціле число та повернула його.
+Використайте `parseInt()` у функції `convertToInteger`, щоб вхідний рядок `str` перетворився на ціле число та повернувся.
 
 # --hints--
 
-`convertToInteger` має використати функцію `parseInt()`
+`convertToInteger` повинна використовувати функцію `parseInt()`
 
 ```js
 assert(/parseInt/g.test(code));
 ```
 
-`convertToInteger("56")` має повернути число
+`convertToInteger("56")` повинна повертати число
 
 ```js
 assert(typeof convertToInteger('56') === 'number');
 ```
 
-`convertToInteger("56")` має повернути 56
+`convertToInteger("56")` повинна повертати 56
 
 ```js
 assert(convertToInteger('56') === 56);
 ```
 
-`convertToInteger("77")` має повернути 77
+`convertToInteger("77")` повинна повертати 77
 
 ```js
 assert(convertToInteger('77') === 77);
 ```
 
-`convertToInteger("JamesBond")` має повернути `NaN`
+`convertToInteger("JamesBond")` повинна повертати `NaN`
 
 ```js
 assert.isNaN(convertToInteger('JamesBond'));
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/using-objects-for-lookups.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/using-objects-for-lookups.md
index eb3e9f9652f..ddccc78c5d1 100644
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/using-objects-for-lookups.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/using-objects-for-lookups.md
@@ -9,9 +9,9 @@ dashedName: using-objects-for-lookups
 
 # --description--
 
-Об'єкти можна вважати сховищем ключів та значень, як словники. Якщо ви маєте табличні дані, ви краще можете використати об'єкт для пошуку значень, ніж `switch` твердження або `if/else` ланцюжок. Це найбільш корисно, коли ви знаєте, що ваші вхідні дані обмежені до певного діапазону.
+Об'єкти можна вважати сховищем ключів/значень, як словники. Якщо ви маєте табличні дані, для пошуку значень краще використати об'єкт, а не інструкцію `switch` чи ланцюжок `if/else`. В такому випадку найкраще, якщо ви знаєте, що ваші вхідні дані обмежені до певного діапазону.
 
-Here is an example of an article object:
+Ось приклад об’єкта-публікації:
 
 ```js
 const article = {
@@ -30,11 +30,11 @@ const value = "title";
 const valueLookup = article[value];
 ```
 
-`articleAuthor` is the string `Kaashan Hussain`, `articleLink` is the string `https://www.freecodecamp.org/news/a-complete-guide-to-creating-objects-in-javascript-b0e2450655e8/`, and `valueLookup` is the string `How to create objects in JavaScript`.
+`articleAuthor` є рядком `Kaashan Hussain`, `articleLink` є рядком `https://www.freecodecamp.org/news/a-complete-guide-to-creating-objects-in-javascript-b0e2450655e8/`, а `valueLookup` є рядком `How to create objects in JavaScript`.
 
 # --instructions--
 
-Переробіть ключове твердження на об'єкт, що називається `lookup`. Використовуйте його, щоб шукати `val` і призначати пов'язаний рядок до `result` змінної.
+Перетворіть інструкцію switch на об’єкт під назвою `lookup`. Використайте його, щоб знайти `val` та призначати пов'язаний рядок до змінної `result`.
 
 # --hints--
 
@@ -80,13 +80,13 @@ assert(phoneticLookup('foxtrot') === 'Frank');
 assert(typeof phoneticLookup('') === 'undefined');
 ```
 
-Вам не слід змінювати `return` твердження
+Ви не повинні змінювати інструкцію `return`
 
 ```js
 assert(code.match(/return\sresult;/));
 ```
 
-Вам не слід використовувати `case`, `switch` або `if` твердження
+Ви не повинні використовувати інструкції `case`, `switch` або `if`
 
 ```js
 assert(
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/word-blanks.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/word-blanks.md
index b8e66955219..193c37d964d 100644
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/word-blanks.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/word-blanks.md
@@ -9,9 +9,9 @@ dashedName: word-blanks
 
 # --description--
 
-You are provided sentences with some missing words, like nouns, verbs, adjectives and adverbs. You then fill in the missing pieces with words of your choice in a way that the completed sentence makes sense.
+Вам надано речення з пропущеними словами: іменниками, дієсловами, прикметниками та прислівниками. Потім ви заповнюєте пропуски словами так, щоб завершене речення мало сенс.
 
-Consider this sentence - It was really **\_\_\_\_**, and we **\_\_\_\_** ourselves **\_\_\_\_**. This sentence has three missing pieces- an adjective, a verb and an adverb, and we can add words of our choice to complete it. We can then assign the completed sentence to a variable as follows:
+Розгляньте речення «It was really **\_\_\_\_**, and we **\_\_\_\_** ourselves **\_\_\_\_**». У цьому реченні відсутні три слова: прикметник, дієслово та прислівник; ми можемо додати вибрані слова, щоб завершити речення. Потім ми можемо присвоїти завершене речення змінній наступним чином:
 
 ```js
 const sentence = "It was really " + "hot" + ", and we " + "laughed" + " ourselves " + "silly" + ".";
@@ -19,21 +19,21 @@ const sentence = "It was really " + "hot" + ", and we " + "laughed" + " ourselve
 
 # --instructions--
 
-In this challenge, we provide you with a noun, a verb, an adjective and an adverb. You need to form a complete sentence using words of your choice, along with the words we provide.
+У цьому завданні вам надано іменник, дієслово, прикметник та прислівник. Ви повинні завершити речення, використовуючи слова на власний вибір, а також надані нами.
 
-You will need to use the string concatenation operator `+` to build a new string, using the provided variables: `myNoun`, `myAdjective`, `myVerb`, and `myAdverb`. You will then assign the formed string to the `wordBlanks` variable. You should not change the words assigned to the variables.
+Ви повинні використати оператор конкатенації `+`, щоб побудувати новий рядок, використовуючи надані змінні: `myNoun`, `myAdjective`, `myVerb` та `myAdverb`. Потім ви присвоїте сформований рядок до змінної `wordBlanks`. Ви не повинні змінювати слова, присвоєні зміннім.
 
-You will also need to account for spaces in your string, so that the final sentence has spaces between all the words. The result should be a complete sentence.
+Вам також потрібно врахувати пропуски у рядку, щоб завершене речення містило пробіли між усіма словами. Результатом повинне бути завершене речення.
 
 # --hints--
 
-`wordBlanks` має бути рядком.
+`wordBlanks` повинен бути рядком.
 
 ```js
 assert(typeof wordBlanks === 'string');
 ```
 
-You should not change the values assigned to `myNoun`, `myVerb`, `myAdjective` or `myAdverb`.
+Ви не повинні змінювати значення, присвоєні до `myNoun`, `myVerb`, `myAdjective` або `myAdverb`.
 
 ```js
 assert(
@@ -44,7 +44,7 @@ assert(
 );
 ```
 
-You should not directly use the values `dog`, `ran`, `big`, or `quickly` to create `wordBlanks`.
+Ви не повинні напряму використовувати значення `dog`, `ran`, `big` або `quickly`, щоб створити `wordBlanks`.
 
 ```js
 const newCode = removeAssignments(code);
@@ -56,7 +56,7 @@ assert(
 );
 ```
 
-`wordBlanks` should contain all of the words assigned to the variables `myNoun`, `myVerb`, `myAdjective` and `myAdverb` separated by non-word characters (and any additional words of your choice).
+`wordBlanks` повинен містити всі слова, присвоєні до змінних `myNoun`, `myVerb`, `myAdjective` та `myAdverb`, розділені розділовим знаком (та додаткові слова на ваш вибір).
 
 ```js
 assert(
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/write-reusable-javascript-with-functions.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/write-reusable-javascript-with-functions.md
index 655a53c4698..7841896ddf1 100644
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/write-reusable-javascript-with-functions.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/write-reusable-javascript-with-functions.md
@@ -1,6 +1,6 @@
 ---
 id: 56bbb991ad1ed5201cd392cf
-title: Створення багаторазового коду JavaScript за допомогою функцій
+title: Написання багаторазового JavaScript із функціями
 challengeType: 1
 videoUrl: 'https://scrimba.com/c/cL6dqfy'
 forumTopicId: 18378
@@ -9,7 +9,7 @@ dashedName: write-reusable-javascript-with-functions
 
 # --description--
 
-У JavaScript можна розділити код на повторно використовувані частини, які називаються <dfn>функціями</dfn>.
+У JavaScript можна розділити код на багаторазові частини, які називаються <dfn>функціями</dfn>.
 
 Приклад функції:
 
@@ -19,13 +19,13 @@ function functionName() {
 }
 ```
 
-Ви можете викликати або <dfn>активувати</dfn> цю функцію, використавши дужки для написання її назви, ось так: `functionName();`. При кожному виклику функції на консоль буде виводитись повідомлення `Hello World`. Щоразу як буде викликана функція, увесь код між фігурними дужками буде виконуватись.
+Ви можете викликати або <dfn>активувати</dfn> цю функцію, використавши дужки для написання її назви, ось так: `functionName();`. При кожному виклику функції на консоль буде виводитись повідомлення `Hello World`. При кожному виклику функції буде виконуватись код у фігурних дужках.
 
 # --instructions--
 
 <ol>
   <li>
-    Створіть функцію, яка називається <code>reusableFunction</code>, що друкує рядок <code>Hi World</code> на консоль розробників.
+    Створіть функцію під назвою <code>reusableFunction</code>, яка друкує рядок <code>Hi World</code> на консоль.
   </li>
   <li>
     Викличте функцію.
@@ -34,19 +34,19 @@ function functionName() {
 
 # --hints--
 
-`reusableFunction` повинен бути функцією.
+`reusableFunction` повинна бути функцією.
 
 ```js
 assert(typeof reusableFunction === 'function');
 ```
 
-Якщо `reusableFunction` буде викликано, то він має виводити рядок `Hi World` на консоль.
+Якщо `reusableFunction` буде викликано, то вона повинна виводити рядок `Hi World` на консоль.
 
 ```js
 assert(testConsole());
 ```
 
-Викличте функцію `reusableFunction` після її визначення.
+Ви повинні викликати `reusableFunction` після її визначення.
 
 ```js
 const functionStr = reusableFunction && __helpers.removeWhiteSpace(reusableFunction.toString());
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/es6/compare-scopes-of-the-var-and-let-keywords.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/es6/compare-scopes-of-the-var-and-let-keywords.md
index 2074773d3c7..ad0b747f17d 100644
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/es6/compare-scopes-of-the-var-and-let-keywords.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/es6/compare-scopes-of-the-var-and-let-keywords.md
@@ -1,6 +1,6 @@
 ---
 id: 587d7b87367417b2b2512b40
-title: Порівняйте можливості ключових слів var та let
+title: Порівняння областей видимості ключових слів var та let
 challengeType: 1
 forumTopicId: 301195
 dashedName: compare-scopes-of-the-var-and-let-keywords
@@ -8,11 +8,11 @@ dashedName: compare-scopes-of-the-var-and-let-keywords
 
 # --description--
 
-Якщо ви ще не знаєте про `let`, див. <a href="/learn/javascript-algorithms-and-data-structures/basic-javascript/explore-differences-between-the-var-and-let-keywords" target="_blank" rel="noopener noreferrer nofollow">це завдання про різницю між <code>let</code> та <code>var</code></a>.
+Якщо ви ще не знайомі з `let`, див. <a href="/ukrainian/learn/javascript-algorithms-and-data-structures/basic-javascript/explore-differences-between-the-var-and-let-keywords" target="_blank" rel="noopener noreferrer nofollow">це завдання про різницю між <code>let</code> та <code>var</code></a>.
 
-Коли ви задаєте змінну з ключовим словом `var`, вона стане глобальною або локальною, якщо буде оголошена у рамках функції.
+Коли ви оголошуєте змінну з ключовим словом `var`, вона оголошена глобально, або локально, якщо оголошена всередині функції.
 
-Ключове слово `let` функціонує схожим чином, але з додатковими можливостями. Коли ви задаєте змінну з ключовим словом `let` у блоці, команді чи виразі, її можливості обмежуються цим блоком, виразом чи виразом.
+Ключове слово `let` поводиться схожим чином, але з додатковими можливостями. Коли ви оголошуєте змінну з ключовим словом `let` всередині блоку, інструкції чи виразу, її можливості обмежуються цим блоком, інструкцією чи виразом.
 
 Наприклад:
 
@@ -27,7 +27,7 @@ console.log(i);
 
 У такому разі консоль показуватиме значення `[0, 1, 2]` та `3`.
 
-Якщо ключове слово — `var`, значення `i` оголошується глобальним. Отже, коли виконується `i++`, глобальна змінна теж оновлюється. Цей код виглядає наступним чином:
+Якщо ключовим словом є `var`, то `i` оголошується глобально. Тому коли виконується `i++`, глобальна змінна теж оновлюється. Цей код схожий до наступного:
 
 ```js
 var numArray = [];
@@ -57,7 +57,7 @@ console.log(printNumTwo());
 
 У такому разі консоль показуватиме значення `3`.
 
-Як бачите, `printNumTwo()` показує 3, а не 2. Це пояснюється тим, що значення для `i` оновилося, а `printNumTwo()` повертає глобальне значення `i`, а не те значення, яке `i` мало при створенні функції для циклу. Ключове слово `let` діє інакше:
+Як бачите, `printNumTwo()` друкує 3, а не 2. Це пояснюється тим, що значення для `i` оновилося, а `printNumTwo()` повертає глобальну `i`, а не те значення, яке `i` мало при створенні функції у циклі for. Ключове слово `let` діє інакше:
 
 ```js
 let printNumTwo;
@@ -72,31 +72,31 @@ console.log(printNumTwo());
 console.log(i);
 ```
 
-У такому разі консоль показуватиме значення `2`, і помилку: `i is not defined`.
+У такому разі консоль показуватиме значення `2` та помилку `i is not defined`.
 
-`i` не визначено (not defined), оскільки змінну не було оголошено в глобальному масштабі. Вона стає оголошеною лише у команді циклу `for`. `printNumTwo()` повернув правильне значення, оскільки було створено три різних змінних `i` з унікальними значеннями (0, 1, та 2) завдяки ключовому слову `let` в рамках команди циклу.
+`i` не визначена, оскільки її не було оголошено в глобальній області. Вона оголошена лише в інструкції циклу `for`. `printNumTwo()` повернула правильне значення, оскільки за допомогою ключового слова `let` в межах інструкції циклу було створено три різні змінні `i` з унікальними значеннями (0, 1 та 2).
 
 # --instructions--
 
-Виправте код так, щоб `i`, оголошена в команді `if`, була окремою змінною, на відміну від `i`, оголошеної у першому рядку функції. Не використовуйте у вашому коді ключове слово `var`.
+Виправте код так, щоб `i`, оголошена в інструкції `if`, була окремою змінною від `i`, оголошеною у першому рядку функції. Не використовуйте у вашому коді ключове слово `var`.
 
-Ця вправа створена для того, щоб показати відмінність між тим, як ключові слова `var` і `let` задають можливості оголошеної змінної. При програмуванні схожої функції на ту, що використовувалася у цій вправі, нерідко слід використовувати різні назви для змінних, щоб уникнути плутанини.
+Ця вправа створена для того, щоб показати відмінність між тим, як ключові слова `var` і `let` присвоюють область видимості оголошеній змінній. При програмуванні схожої функції краще використовувати різні назви для змінних, щоб уникнути плутанини.
 
 # --hints--
 
-`var` має бути відсутнім у коді.
+`var` повинне бути відсутнім у коді.
 
 ```js
 assert(!code.match(/var/g));
 ```
 
-Змінна `i`, оголошена в операторі `if`, має дорівнювати рядку `block scope`.
+Змінна `i`, оголошена в інструкції `if`, повинна дорівнювати рядку `block scope`.
 
 ```js
 assert(code.match(/(i\s*=\s*).*\s*.*\s*.*\1('|")block\s*scope\2/g));
 ```
 
-`checkScope()` має повернути рядок `function scope`
+`checkScope()` повинна повертати рядок `function scope`
 
 ```js
 assert(checkScope() === 'function scope');
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/es6/mutate-an-array-declared-with-const.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/es6/mutate-an-array-declared-with-const.md
index 2594e86a699..6cba1c737a1 100644
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/es6/mutate-an-array-declared-with-const.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/es6/mutate-an-array-declared-with-const.md
@@ -1,6 +1,6 @@
 ---
 id: 587d7b87367417b2b2512b42
-title: Видозмінюйте наданий масив за допомогою змінної
+title: Мутація масиву, оголошеного з const
 challengeType: 1
 forumTopicId: 301206
 dashedName: mutate-an-array-declared-with-const
@@ -8,13 +8,13 @@ dashedName: mutate-an-array-declared-with-const
 
 # --description--
 
-Якщо ви ще не знаєте про `const`, див. <a href="/learn/javascript-algorithms-and-data-structures/basic-javascript/declare-a-read-only-variable-with-the-const-keyword" target="_blank" rel="noopener noreferrer nofollow">це завдання про ключове слово <code>const</code></a>.
+Якщо ви ще не знайомі з `const`, див. <a href="/ukrainian/learn/javascript-algorithms-and-data-structures/basic-javascript/declare-a-read-only-variable-with-the-const-keyword" target="_blank" rel="noopener noreferrer nofollow">це завдання про ключове слово <code>const</code></a>.
 
-Є багато значень змінної `const` у сучасній JavaScript.
+У сучасному JavaScript існує багато випадків оголошень з `const`.
 
-Деякі розробники надають перевагу привласненню усіх змінних за допомогою `const`, доки вони не дізнаються про можливу необхідність перепризначення змінної. Тоді вони використовують `let`.
+Деякі розробники надають перевагу присвоєнню усіх змінних за допомогою `const`, якщо їм не потрібно повторно присвоїти значення. Тоді вони використовують `let`.
 
-Проте варто розуміти, що об'єкти (включаючи масиви та функції), призначенні змінній за допомогою `const`, все ще можна змінювати. Правильне використання `const` запобігає зміненню ідентифікатора змінної.
+Однак варто розуміти, що об'єкти (включно з масивами та функціями), присвоєні змінній за допомогою `const`, всеодно можна змінити. Оголошення `const` всього лиш запобігає повторному присвоєнню ідентифікатора змінної.
 
 ```js
 const s = [5, 6, 7];
@@ -23,9 +23,9 @@ s[2] = 45;
 console.log(s);
 ```
 
-`s = [1, 2, 3]` призведе до помилки. After commenting out that line, the `console.log` will display the value `[5, 6, 45]`.
+`s = [1, 2, 3]` призведе до помилки. Після коментування цього рядка, `console.log` показуватиме значення `[5, 6, 45]`.
 
-Як ви помітили, можна змінювати об'єкт `[5, 6, 7]`. Змінна `s` все ще вказуватиме на змінений масив `[5, 6, 45]`. Як і усі масиви, елементи масиву в `s` є незмінними, бо було використано `const`. Ви не можете використовувати ідентифікатор змінної `s`, щоб вказувати на інший масив оператору призначення.
+Як ви помітили, об’єкт `[5, 6, 7]` можна змінювати, але змінна `s` всеодно вказуватиме на змінений масив `[5, 6, 45]`. Як і усі масиви, елементи масиву в `s` є незмінними, бо було використано `const`. Ви не можете використовувати ідентифікатор змінної `s`, щоб вказувати на інший масив оператору призначення.
 
 # --instructions--
 
diff --git a/curriculum/challenges/ukrainian/08-data-analysis-with-python/data-analysis-with-python-projects/sea-level-predictor.md b/curriculum/challenges/ukrainian/08-data-analysis-with-python/data-analysis-with-python-projects/sea-level-predictor.md
index 057d572668c..27a50dfe2e7 100644
--- a/curriculum/challenges/ukrainian/08-data-analysis-with-python/data-analysis-with-python-projects/sea-level-predictor.md
+++ b/curriculum/challenges/ukrainian/08-data-analysis-with-python/data-analysis-with-python-projects/sea-level-predictor.md
@@ -28,7 +28,7 @@ dashedName: sea-level-predictor
 Використайте дані для виконання наступних завдань:
 
 - Використайте Pandas для імпорту даних з `epa-sea-level.csv`.
-- Use matplotlib to create a scatter plot using the `Year` column as the x-axis and the `CSIRO Adjusted Sea Level` column as the y-axis.
+- Використайте matplotlib, щоб створити діаграму розсіювання, використовуючи стовпчик `Year` як вісь x та стовпчик `CSIRO Adjusted Sea Level` як вісь y.
 - Використайте функцію `linregress` із `scipy.stats`, щоб отримати нахил та Y-перехоплення лінії, яка найкраще підходить. Нанесіть лінію, яка найкраще підходить, поверх діаграми розсіювання. Проведіть лінію через 2050 рік, щоб передбачити підвищення рівня моря в 2050 році.
 - Побудуйте нову лінію, яка найкраще підходить, просто використовуючи дані з 2000 року до найновішого року в наборі даних. Зробіть так, щоб лінія також проходила через 2050 рік, щоб передбачити підвищення рівня моря в 2050 році, якщо темпи підвищення триватимуть, як це було з 2000 року.
 - Міткою x повинна бути `Year`, міткою y повинна бути `Sea Level (inches)`, а назва повинна бути `Rise in Sea Level`.
diff --git a/curriculum/challenges/ukrainian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f7ecb09de9a938ef94756.md b/curriculum/challenges/ukrainian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f7ecb09de9a938ef94756.md
index 390a8a4087e..afb04c47b44 100644
--- a/curriculum/challenges/ukrainian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f7ecb09de9a938ef94756.md
+++ b/curriculum/challenges/ukrainian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f7ecb09de9a938ef94756.md
@@ -7,7 +7,7 @@ dashedName: step-55
 
 # --description--
 
-Додайте ще один елемент `p` з текстом `Total Carbohydrate 37g 13%`. Like before, use `span` elements to make the text `Total Carbohydrate` and `13%` bold. Також додайте додатковий елемент `span`, щоб обгорнути текст `Total Carbohydrate 37g` в елемент span, щоб вирівняти його за лівим краєм, а `13%` – за правим.
+Додайте ще один елемент `p` з текстом `Total Carbohydrate 37g 13%`. Як і раніше, використайте елементи `span`, щоб зробити шрифт текстів `Total Carbohydrate` та `13%` жирним. Також додайте додатковий елемент `span`, щоб обгорнути текст `Total Carbohydrate 37g` в елемент span, щоб вирівняти його за лівим краєм, а `13%` – за правим.
 
 # --hints--
 
diff --git a/curriculum/challenges/ukrainian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f8bfe0f30a1a3c340356b.md b/curriculum/challenges/ukrainian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f8bfe0f30a1a3c340356b.md
index 81b82480acc..a4a9ccedc37 100644
--- a/curriculum/challenges/ukrainian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f8bfe0f30a1a3c340356b.md
+++ b/curriculum/challenges/ukrainian/14-responsive-web-design-22/learn-typography-by-building-a-nutrition-label/615f8bfe0f30a1a3c340356b.md
@@ -30,7 +30,7 @@ assert(document.querySelector('.daily-value.small-text')?.lastElementChild?.prev
 assert(document.querySelector('.daily-value.small-text')?.lastElementChild?.previousElementSibling?.firstElementChild?.localName === 'span');
 ```
 
-Ваш перший елемент `span` не повинен бути жирним.
+Your first `span` element should not be bold.
 
 ```js
 assert(!document.querySelector('.daily-value.small-text')?.lastElementChild?.previousElementSibling?.firstElementChild?.classList?.contains('bold'));
diff --git a/curriculum/challenges/ukrainian/15-javascript-algorithms-and-data-structures-22/learn-basic-javascript-by-building-a-role-playing-game/62a8b6536156c51500739b41.md b/curriculum/challenges/ukrainian/15-javascript-algorithms-and-data-structures-22/learn-basic-javascript-by-building-a-role-playing-game/62a8b6536156c51500739b41.md
index 100f17affdf..9f87c0038ae 100644
--- a/curriculum/challenges/ukrainian/15-javascript-algorithms-and-data-structures-22/learn-basic-javascript-by-building-a-role-playing-game/62a8b6536156c51500739b41.md
+++ b/curriculum/challenges/ukrainian/15-javascript-algorithms-and-data-structures-22/learn-basic-javascript-by-building-a-role-playing-game/62a8b6536156c51500739b41.md
@@ -7,7 +7,7 @@ dashedName: step-62
 
 # --description--
 
-The `locations` array contains two locations: the `town square` and the `store`. Currently you are passing that entire array into the `update` function. Передайте лише перший елемент масиву `locations`, додавши `[0]` в кінці змінної. Наприклад: `myFunction(arg[0]);`.
+Масив `locations` містить дві локації: `town square` та `store`. Наразі ви передаєте цілий масив до функції `update`. Передайте лише перший елемент масиву `locations`, додавши `[0]` в кінці змінної. Наприклад: `myFunction(arg[0]);`.
 
 Це називається <dfn>дужковою нотацією</dfn>. Значення в масиві доступні за індексом. Індекси є числовими значеннями та починаються з 0 – це називається індексуванням від нуля. Першим елементом у масиві `arg` був би `arg[0]`.