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

2026-01-26 03:02:39 -05:00 · 2022-12-19 10:41:09 -08:00
parent eba1ea58a2
commit ecc7101854
73 changed files with 340 additions and 340 deletions
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/accessing-object-properties-with-variables.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/accessing-object-properties-with-variables.md
@@ -25,7 +25,7 @@ const myBreed = dogs[myDog];
 console.log(myBreed);
 ```

-Рядок `Doberman` повинен відображатись на консолі.
+На консолі відображатиметься рядок `Doberman`.

 Зверніть увагу, що ми *не* використовуємо лапки із назвами змінних, якщо використовуємо їх для доступу до властивостей, оскільки ми використовуємо *значення* змінної, а не *назву*.

--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/build-javascript-objects.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/build-javascript-objects.md
@@ -9,13 +9,13 @@ dashedName: build-javascript-objects

 # --description--

-Ви могли чути термін `object` раніше.
+Можливо, ви вже чули термін `object`.

-Об'єкти подібні до `arrays`, за винятком того, що для отримання доступу та зміни їхніх даних використовуються не індекси, а `properties`.
+Об'єкти подібні до `arrays`, за винятком того, що для отримання доступу та зміни їхніх даних використовуються не індекси, а властивості (`properties`).

-Об'єкти придатні для структурованого зберігання даних, і також можуть представляти об'єкти реального світу, такі як кіт, наприклад.
+Об'єкти придатні для структурованого зберігання даних, і також можуть представляти реальні об'єкти, наприклад кота.

-Зразок об'єкта кота:
+Приклад об'єкта-кота:

 ```js
 const cat = {
@@ -26,7 +26,7 @@ const cat = {
 };
 ```

-У цьому прикладі всі властивості зберігаються у вигляді рядків, таких як `name`, `legs` і `tails`. Однак, ви також можете використовувати числа як характеристики. Лапки для характеристик, які складаються з одного слова, можна пропустити наступним чином:
+У цьому прикладі всі властивості зберігаються як рядки, як-от `name`, `legs` та `tails`. Однак числа також можна використовувати як властивості. Ви навіть можете пропустити лапки для властивостей з одним словом, як показано нижче:

 ```js
 const anotherObject = {
@@ -36,17 +36,17 @@ const anotherObject = {
 };
 ```

-Якщо ваші об'єкти містять будь-які не рядкові характеристики, JavaScript автоматично надрукує їх як рядки.
+Однак, якщо ваші об'єкти містять будь-які не рядкові властивості, JavaScript автоматично перетворить їх на рядки.

 # --instructions--

-Створіть об'єкт під назвою `myDog`, який має такі характеристики: `name` (a string), `legs`, `tails` and `friends`.
+Створіть об'єкт, який представляє собаку, під назвою `myDog` і який має властивості `name` (рядок), `legs`, `tails` та `friends`.

-Ви можете надати характеристикам цих об'єктів будь-які значення, доки `name` - це рядок, `legs` and `tails` - числа, і `friends` - масив.
+Ви можете встановити властивості на будь-яке значення, але `name` повинен бути рядком, `legs` та `tails` повинні бути числами, а `friends` повинен бути масивом.

 # --hints--

-`myDog` має містити характеристику `name` і бути `string`.
+`myDog` повинен містити властивість `name` і бути рядком (`string`).

 ```js
 assert(
@@ -64,7 +64,7 @@ assert(
 );
 ```

-`myDog` має містити характеристику `legs` і бути `number`.
+`myDog` повинен містити властивість `legs` і бути числом (`number`).

 ```js
 assert(
@@ -82,7 +82,7 @@ assert(
 );
 ```

-`myDog` має містити характеристику `tails` і бути `number`.
+`myDog` повинен містити властивість `tails` і бути числом (`number`).

 ```js
 assert(
@@ -100,7 +100,7 @@ assert(
 );
 ```

-`myDog` має містити характеристику `friends` і бути `array`.
+`myDog` повинен містити властивість `friends` і бути масивом (`array`).

 ```js
 assert(
@@ -118,7 +118,7 @@ assert(
 );
 ```

-`myDog` має містити всі задані характеристики.
+`myDog` повинен містити всі задані властивості.

 ```js
 assert(
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/chaining-if-else-statements.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/chaining-if-else-statements.md
@@ -1,6 +1,6 @@
 ---
 id: 56533eb9ac21ba0edf2244dc
-title: Створення ланцюгу If Else (Що-Якщо)
+title: Ланцюжок інструкцій if else
 challengeType: 1
 videoUrl: 'https://scrimba.com/c/caeJgsw'
 forumTopicId: 16772
@@ -9,7 +9,7 @@ dashedName: chaining-if-else-statements

 # --description--

-`if/else` може бути об'єднаним у разі складних алгоритмів. Ось <dfn>pseudocode</dfn> декількох ланцюжків `if` / `else if` тверджень:
+Інструкції `if/else` можна об'єднати для складної логіки. Ось <dfn>псевдокод</dfn> декількох об'єднаних інструкцій `if` / `else if`:

 ```js
 if (condition1) {
@@ -26,89 +26,89 @@ if (condition1) {

 # --instructions--

-Запишіть ланцюжок `if`/`else if` для того, щоб виконати наступні умови:
+Напишіть об'єднані інструкції `if`/`else if`, щоб виконати наступні умови:

-`num < 5` дає `Tiny`  
-`num < 10` дає `Small`  
-`num < 15` дає `Medium`  
-`num < 20` дає `Large`  
-`num >= 20` дає `Huge`
+`num < 5` повертає `Tiny`  
+`num < 10` повертає `Small`  
+`num < 15` повертає `Medium`  
+`num < 20` повертає `Large`  
+`num >= 20` повертає `Huge`

 # --hints--

-Потрібно мати щонайменше 4 команди `else`
+Ви повинні мати принаймні 4 інструкції `else`

 ```js
 assert(code.match(/else/g).length > 3);
 ```

-Потрібно мати щонайменше 4 команди `if`
+Ви повинні мати принаймні 4 інструкції `if`

 ```js
 assert(code.match(/if/g).length > 3);
 ```

-Потрібно мати щонайменше 1 команду `return`
+Ви повинні мати принаймні 1 інструкцію `return`

 ```js
 assert(code.match(/return/g).length >= 1);
 ```

-`testSize(0)` має повертати рядок `Tiny`
+`testSize(0)` повинен повертати рядок `Tiny`

 ```js
 assert(testSize(0) === 'Tiny');
 ```

-`testSize(4)` має повертати рядок `Tiny`
+`testSize(4)` повинен повертати рядок `Tiny`

 ```js
 assert(testSize(4) === 'Tiny');
 ```

-`testSize(5)` має повертати рядок `Small`
+`testSize(5)` повинен повертати рядок `Small`

 ```js
 assert(testSize(5) === 'Small');
 ```

-`testSize(8)` має повертати рядок `Small`
+`testSize(8)` повинен повертати рядок `Small`

 ```js
 assert(testSize(8) === 'Small');
 ```

-`testSize(10)` має повертати рядок `Medium`
+`testSize(10)` повинен повертати рядок `Medium`

 ```js
 assert(testSize(10) === 'Medium');
 ```

-`testSize(14)` має повертати рядок `Medium`
+`testSize(14)` повинен повертати рядок `Medium`

 ```js
 assert(testSize(14) === 'Medium');
 ```

-`testSize(15)` має повертати рядок `Large`
+`testSize(15)` повинен повертати рядок `Large`

 ```js
 assert(testSize(15) === 'Large');
 ```

-`testSize(17)` має повертати рядок `Large`
+`testSize(17)` повинен повертати рядок `Large`

 ```js
 assert(testSize(17) === 'Large');
 ```

-`testSize(20)` має повертати рядок `Huge`
+`testSize(20)` повинен повертати рядок `Huge`

 ```js
 assert(testSize(20) === 'Huge');
 ```

-`testSize(25)` має повертати рядок `Huge`
+`testSize(25)` повинен повертати рядок `Huge`

 ```js
 assert(testSize(25) === 'Huge');
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/comment-your-javascript-code.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/comment-your-javascript-code.md
@@ -1,6 +1,6 @@
 ---
 id: bd7123c9c441eddfaeb4bdef
-title: Поясніть ваш JavaScript код
+title: Коментування коду JavaScript
 challengeType: 1
 removeComments: false
 videoUrl: 'https://scrimba.com/c/c7ynnTp'
@@ -10,24 +10,24 @@ dashedName: comment-your-javascript-code

 # --description--

-Пояснення - це рядки коду, які JavaScript буде навмисно ігнорувати. Коментарі - це чудовий спосіб залишити нотатки для себе та інших людей, які згодом мають дізнатися, що робить цей код.
+Коментарі – це рядки коду, які JavaScript буде навмисно ігнорувати. Це чудовий спосіб залишити нотатки для себе та інших людей, які згодом повинні дізнатися, що робить цей код.

-Є два шляхи написати пояснення у JavaScript:
+Існує два способи написання коментарів у JavaScript:

-Використання `//` дозволить JavaScript ігнорувати решту тексту в поточному рядку. Це коментар всередині рядка:
+Використавши `//`, ви повідомите JavaScript про те, що потрібно ігнорувати решту тексту поточного рядка. Це коментар всередині рядка:

 ```js
 // This is an in-line comment.
 ```

-Ви можете зробити багаторядковий коментар починаючи з `/*` і закінчуватися `*/`. Це багаторядковий коментар:
+Ви можете зробити багаторядковий коментар, починаючи з `/*` і закінчуючи `*/`. Це багаторядковий коментар:

 ```js
 /* This is a
 multi-line comment */
 ```

-**ПРИМІТКА:**, написавши код, вам слід постійно додавати коментарі, щоб уточнити функцію частин вашого коду. Хороші і якісні коментарі можуть допомогти передати мету вашого коду – як для інших людей, *так і* для себе в майбутньому.
+**ПРИМІТКА:** при написанні коду ви повинні часто додавати коментарі, щоб роз'яснити функції частин вашого коду. Хороші коментарі можуть передати мету вашого коду – як для інших людей, *так і* для себе в майбутньому.

 # --instructions--

@@ -35,13 +35,13 @@ multi-line comment */

 # --hints--

-Ви повинні створити стиль `//`, що містить щонайменше п'ять літер.
+Ви повинні створити коментар стилю `//`, який містить принаймні п'ять літер.

 ```js
 assert(code.match(/(\/\/)...../g));
 ```

-Ви повинні створити коментар стилю `/* */`, що містить щонайменше п'ять літер.
+Ви повинні створити коментар стилю `/* */`, який містить принаймні п'ять літер.

 ```js
 assert(code.match(/(\/\*)([^\/]{5,})(?=\*\/)/gm));
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-equality-operator.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-equality-operator.md
@@ -1,6 +1,6 @@
 ---
 id: 56533eb9ac21ba0edf2244d0
-title: Порівняння з Оператором Рівності
+title: Порівняння з оператором «дорівнює»
 challengeType: 1
 videoUrl: 'https://scrimba.com/c/cKyVMAL'
 forumTopicId: 16784
@@ -9,9 +9,9 @@ dashedName: comparison-with-the-equality-operator

 # --description--

-У JavaScript є багато <dfn>операторів порівняння</dfn>. Всі ці оператори присвоюють логічне `true` або `false` значення.
+У JavaScript існує багато <dfn>операторів порівняння</dfn>. Всі ці оператори повертають логічне значення `true` або `false`.

-Основним є оператор рівності `==`. Оператор рівності порівнює два значення і видає `true`, якщо вони еквівалентні, або `false`, якщо ні. Зверніть увагу, що рівність відрізняється від присвоєння (`=`), яке закріплює за змінною ліворуч значення праворуч від оператора.
+Основним є оператор «дорівнює» (`==`). Оператор «дорівнює» порівнює два значення та повертає `true`, якщо вони еквівалентні. В іншому випадку він повертає `false`. Зверніть увагу, що рівність відрізняється від присвоєння (`=`), яке присвоює значення праворуч від оператора до змінної зліва.

 ```js
 function equalityTest(myVal) {
@@ -22,7 +22,7 @@ function equalityTest(myVal) {
 }
 ```

-Якщо `myVal` рівнозначний `10`, оператор рівності видає `true`, тож код у фігурних дужках виконається, і функція буде `Equal`. В іншому випадку, функція буде `Not Equal`. Для того, щоб JavaScript порівняв два різні <dfn>типи даних</dfn> (наприклад, `numbers` і `strings`), потрібно конвертувати один тип в інший. Це називається Перетворення Типів. Однак, після його виконання поняття порівнюються наступним чином:
+Якщо `myVal` дорівнює `10`, то оператор «дорівнює» повертає `true`, тому код у фігурних дужках виконається і функція поверне `Equal`. В іншому випадку функція поверне `Not Equal`. Для того, щоб JavaScript порівняв два різні <dfn>типи даних</dfn> (наприклад, `numbers` та `strings`), потрібно конвертувати один тип в інший. Це називається приведенням типів. Після конвертації вони порівнюються наступним чином:

 ```js
 1   ==  1  // true
@@ -33,29 +33,29 @@ function equalityTest(myVal) {

 # --instructions--

-Add the equality operator to the indicated line so that the function will return the string `Equal` when `val` is equivalent to `12`.
+Додайте оператор «дорівнює» до зазначеного рядка, щоб функція повернула рядок `Equal`, якщо `val` дорівнює `12`.

 # --hints--

-`testEqual(10)` should return the string `Not Equal`
+`testEqual(10)` повинен повертати рядок `Not Equal`

 ```js
 assert(testEqual(10) === 'Not Equal');
 ```

-`testEqual(12)` should return the string `Equal`
+`testEqual(12)` повинен повертати рядок `Equal`

 ```js
 assert(testEqual(12) === 'Equal');
 ```

-`testEqual("12")` should return the string `Equal`
+`testEqual("12")` повинен повертати рядок `Equal`

 ```js
 assert(testEqual('12') === 'Equal');
 ```

-You should use the `==` operator
+Ви повинні використати оператор `==`

 ```js
 assert(code.match(/==/g) && !code.match(/===/g));
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-greater-than-operator.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-greater-than-operator.md
@@ -9,9 +9,9 @@ dashedName: comparison-with-the-greater-than-operator

 # --description--

-Оператор «більше ніж» (`>`) порівнює значення двох чисел. Якщо число зліва більше за число справа, то воно повертається `true`. В іншому випадку видається результат `false`.
+Оператор «більше ніж» (`>`) порівнює значення двох чисел. Якщо число зліва більше за число справа, оператор повертає `true`. В іншому випадку він повертає `false`.

-Як і оператор «рівність», «більше ніж» перетворюватиме типи даних під час порівняння.
+Як і оператор «дорівнює», «більше ніж» перетворює типи даних під час порівняння.

 **Приклади**

@@ -24,53 +24,53 @@ dashedName: comparison-with-the-greater-than-operator

 # --instructions--

-Add the greater than operator to the indicated lines so that the return statements make sense.
+Додайте оператор «більше ніж» до вказаних рядків, щоб повернені інструкції мали сенс.

 # --hints--

-`testGreaterThan(0)` має повернути рядок `10 or Under`
+`testGreaterThan(0)` повинен повертати рядок `10 or Under`

 ```js
 assert(testGreaterThan(0) === '10 or Under');
 ```

-`testGreaterThan(10)` має повернути рядок `10 or Under`
+`testGreaterThan(10)` повинен повертати рядок `10 or Under`

 ```js
 assert(testGreaterThan(10) === '10 or Under');
 ```

-`testGreaterThan(11)` має повернути рядок `Over 10`
+`testGreaterThan(11)` повинен повертати рядок `Over 10`

 ```js
 assert(testGreaterThan(11) === 'Over 10');
 ```

-`testGreaterThan(99)` має повернути рядок `Over 10`
+`testGreaterThan(99)` повинен повертати рядок `Over 10`

 ```js
 assert(testGreaterThan(99) === 'Over 10');
 ```

-`testGreaterThan(100)` має повернути рядок `Over 10`
+`testGreaterThan(100)` повинен повертати рядок `Over 10`

 ```js
 assert(testGreaterThan(100) === 'Over 10');
 ```

-`testGreaterThan(101)` має повернути рядок `Over 100`
+`testGreaterThan(101)` повинен повертати рядок `Over 100`

 ```js
 assert(testGreaterThan(101) === 'Over 100');
 ```

-`testGreaterThan(150)` має повернути рядок `Over 100`
+`testGreaterThan(150)` повинен повертати рядок `Over 100`

 ```js
 assert(testGreaterThan(150) === 'Over 100');
 ```

-You should use the `>` operator at least twice
+Ви повинні використати оператор `>` принаймні двічі

 ```js
 assert(code.match(/val\s*>\s*('|")*\d+('|")*/g).length > 1);
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-greater-than-or-equal-to-operator.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-greater-than-or-equal-to-operator.md
@@ -1,6 +1,6 @@
 ---
 id: 56533eb9ac21ba0edf2244d5
-title: Порівняння з оператором «Більше ніж дорівнює»
+title: Порівняння з оператором «більше ніж або дорівнює»
 challengeType: 1
 videoUrl: 'https://scrimba.com/c/c6KBqtV'
 forumTopicId: 16785
@@ -9,9 +9,9 @@ dashedName: comparison-with-the-greater-than-or-equal-to-operator

 # --description--

-Оператор "більше ніж дорівнює" (`>=`) порівнює значення двох чисел. Якщо число зліва більше чи дорівнює числу справа, тоді повертається `true`. В іншому випадку - вона `false`.
+Оператор «більше ніж або дорівнює» (`>=`) порівнює значення двох чисел. Якщо число зліва більше чи дорівнює числу справа, оператор повертає `true`. В іншому випадку він повертає `false`.

-Так само, як і оператор рівності, оператор "більше ніж дорівнює" конвертує типи даних під час їх порівняння.
+Як і оператор «дорівнює», «більше ніж або дорівнює» перетворює типи даних під час порівняння.

 **Приклади**

@@ -24,53 +24,53 @@ dashedName: comparison-with-the-greater-than-or-equal-to-operator

 # --instructions--

-Add the greater than or equal to operator to the indicated lines so that the return statements make sense.
+Додайте оператор «більше ніж або дорівнює» до вказаних рядків, щоб повернені інструкції мали сенс.

 # --hints--

-`testGreaterOrEqual(0)` має повертати рядок `Less than 10`
+`testGreaterOrEqual(0)` повинен повертати рядок `Less than 10`

 ```js
 assert(testGreaterOrEqual(0) === 'Less than 10');
 ```

-`testGreaterOrEqual(9)` має повертати рядок `Less than 10`
+`testGreaterOrEqual(9)` повинен повертати рядок `Less than 10`

 ```js
 assert(testGreaterOrEqual(9) === 'Less than 10');
 ```

-`testGreaterOrEqual(10)` має повертати рядок `10 or Over`
+`testGreaterOrEqual(10)` повинен повертати рядок `10 or Over`

 ```js
 assert(testGreaterOrEqual(10) === '10 or Over');
 ```

-`testGreaterOrEqual(11)` має повертати рядок `10 or Over`
+`testGreaterOrEqual(11)` повинен повертати рядок `10 or Over`

 ```js
 assert(testGreaterOrEqual(11) === '10 or Over');
 ```

-`testGreaterOrEqual(19)` має повертати рядок `10 or Over`
+`testGreaterOrEqual(19)` повинен повертати рядок `10 or Over`

 ```js
 assert(testGreaterOrEqual(19) === '10 or Over');
 ```

-`testGreaterOrEqual(100)` має повертати рядок `20 or Over`
+`testGreaterOrEqual(100)` повинен повертати рядок `20 or Over`

 ```js
 assert(testGreaterOrEqual(100) === '20 or Over');
 ```

-`testGreaterOrEqual(21)` має повертати рядок `20 or Over`
+`testGreaterOrEqual(21)` повинен повертати рядок `20 or Over`

 ```js
 assert(testGreaterOrEqual(21) === '20 or Over');
 ```

-You should use the `>=` operator at least twice
+Ви повинні використати оператор `>=` принаймні двічі

 ```js
 assert(code.match(/val\s*>=\s*('|")*\d+('|")*/g).length > 1);
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-inequality-operator.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-inequality-operator.md
@@ -1,6 +1,6 @@
 ---
 id: 56533eb9ac21ba0edf2244d2
-title: Порівняння з Оператором "Не дорівнює"
+title: Порівняння з оператором «не дорівнює»
 challengeType: 1
 videoUrl: 'https://scrimba.com/c/cdBm9Sr'
 forumTopicId: 16787
@@ -9,7 +9,7 @@ dashedName: comparison-with-the-inequality-operator

 # --description--

-Оператор "не дорівнює" (`!=`) є протилежним до оператора рівності. Це означає, що вирази не еквівалентні і що вони повернуться `false`, де рівність повернеться `true` і *навпаки*. Так само, як і оператор рівності, оператор "не дорівнює" конвертує типи даних під час їх порівняння.
+Оператор «не дорівнює» (`!=`) є протилежним до оператора «дорівнює». Це означає, що значення не еквівалентні і оператор повертає `false`, де рівність повернула б `true` та *навпаки*. Як і оператор «дорівнює», «не дорівнює» перетворює типи даних під час порівняння.

 **Приклади**

@@ -23,41 +23,41 @@ dashedName: comparison-with-the-inequality-operator

 # --instructions--

-Add the inequality operator `!=` in the `if` statement so that the function will return the string `Not Equal` when `val` is not equivalent to `99`.
+Додайте оператор «не дорівнює» (`!=`) в інструкції `if`, щоб функція повернула рядок `Not Equal`, якщо `val` не дорівнює `99`.

 # --hints--

-`testNotEqual(99)` має повернути рядок `Equal`
+`testNotEqual(99)` повинен повертати рядок `Equal`

 ```js
 assert(testNotEqual(99) === 'Equal');
 ```

-`testNotEqual("99")` має повернути рядок `Equal`
+`testNotEqual("99")` повинен повертати рядок `Equal`

 ```js
 assert(testNotEqual('99') === 'Equal');
 ```

-`testNotEqual(12)` має повернути рядок `Not Equal`
+`testNotEqual(12)` повинен повертати рядок `Not Equal`

 ```js
 assert(testNotEqual(12) === 'Not Equal');
 ```

-`testNotEqual("12")` має повернути рядок `Not Equal`
+`testNotEqual("12")` повинен повертати рядок `Not Equal`

 ```js
 assert(testNotEqual('12') === 'Not Equal');
 ```

-`testNotEqual("bob")` має повернути рядок `Not Equal`
+`testNotEqual("bob")` повинен повертати рядок `Not Equal`

 ```js
 assert(testNotEqual('bob') === 'Not Equal');
 ```

-You should use the `!=` operator
+Ви повинні використати оператор `!=`

 ```js
 assert(code.match(/(?!!==)!=/));
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-less-than-operator.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-less-than-operator.md
@@ -1,6 +1,6 @@
 ---
 id: 56533eb9ac21ba0edf2244d6
-title: Порівняння з оператором "менше ніж"
+title: Порівняння з оператором «менше ніж»
 challengeType: 1
 videoUrl: 'https://scrimba.com/c/cNVRWtB'
 forumTopicId: 16789
@@ -9,9 +9,9 @@ dashedName: comparison-with-the-less-than-operator

 # --description--

-Оператор "менше ніж" (`<`) порівнює значення двох чисел. Якщо число ліворуч менше за число праворуч, то видається результат `true`. В іншому випадку видається результат `false`. Так само, як і оператор "дорівнює", оператор "менше ніж" конвертує типи даних під час їх порівняння.
+Оператор «менше ніж» (`<`) порівнює значення двох чисел. Якщо число ліворуч менше за число праворуч, оператор повертає `true`. В іншому випадку він повертає `false`. Як і оператор «дорівнює», «менше ніж» перетворює типи даних під час порівняння.

-**Наприклад:**
+**Приклади**

 ```js
 2   < 5 // true
@@ -23,7 +23,7 @@ dashedName: comparison-with-the-less-than-operator

 # --instructions--

-Add the less than operator to the indicated lines so that the return statements make sense.
+Додайте оператор «менше ніж» до вказаних рядків, щоб повернені інструкції мали сенс.

 # --hints--

@@ -63,7 +63,7 @@ assert(testLessThan(55) === '55 or Over');
 assert(testLessThan(99) === '55 or Over');
 ```

-You should use the `<` operator at least twice
+Ви повинні використати оператор `<` принаймні двічі

 ```js
 assert(code.match(/val\s*<\s*('|")*\d+('|")*/g).length > 1);
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-less-than-or-equal-to-operator.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-less-than-or-equal-to-operator.md
@@ -1,6 +1,6 @@
 ---
 id: 56533eb9ac21ba0edf2244d7
-title: Порівняння з оператором "менше або рівне"
+title: Порівняння з оператором «менше ніж або дорівнює»
 challengeType: 1
 videoUrl: 'https://scrimba.com/c/cNVR7Am'
 forumTopicId: 16788
@@ -9,9 +9,9 @@ dashedName: comparison-with-the-less-than-or-equal-to-operator

 # --description--

-Оператор "менше або рівне"(`<=`) порівнює значення двох чисел. Якщо число ліворуч є меншим, ніж число праворуч або дорівнює йому, то видається результат `true`. Якщо число ліворуч більше за число праворуч, то видається результат `false`. Так само, як і оператор рівності, оператор "менше або рівне" конвертує типи даних.
+Оператор «менше ніж або дорівнює» (`<=`) порівнює значення двох чисел. Якщо число зліва менше чи дорівнює числу справа, оператор повертає `true`. Якщо число зліва більше за число справа, він повертає `false`. Як і оператор «дорівнює», «менше ніж або дорівнює» перетворює типи даних під час порівняння.

-**Наприклад:**
+**Приклади**

 ```js
 4   <= 5 // true
@@ -23,53 +23,53 @@ dashedName: comparison-with-the-less-than-or-equal-to-operator

 # --instructions--

-Add the less than or equal to operator to the indicated lines so that the return statements make sense.
+Додайте оператор «менше ніж або дорівнює» до вказаних рядків, щоб повернені інструкції мали сенс.

 # --hints--

-`testLessOrEqual(0)` should return the string `Smaller Than or Equal to 12`
+`testLessOrEqual(0)` повинен повертати рядок `Smaller Than or Equal to 12`

 ```js
 assert(testLessOrEqual(0) === 'Smaller Than or Equal to 12');
 ```

-`testLessOrEqual(11)` should return the string `Smaller Than or Equal to 12`
+`testLessOrEqual(11)` повинен повертати рядок `Smaller Than or Equal to 12`

 ```js
 assert(testLessOrEqual(11) === 'Smaller Than or Equal to 12');
 ```

-`testLessOrEqual(12)` should return the string `Smaller Than or Equal to 12`
+`testLessOrEqual(12)` повинен повертати рядок `Smaller Than or Equal to 12`

 ```js
 assert(testLessOrEqual(12) === 'Smaller Than or Equal to 12');
 ```

-`testLessOrEqual(23)` should return the string `Smaller Than or Equal to 24`
+`testLessOrEqual(23)` повинен повертати рядок `Smaller Than or Equal to 24`

 ```js
 assert(testLessOrEqual(23) === 'Smaller Than or Equal to 24');
 ```

-`testLessOrEqual(24)` should return the string `Smaller Than or Equal to 24`
+`testLessOrEqual(24)` повинен повертати рядок `Smaller Than or Equal to 24`

 ```js
 assert(testLessOrEqual(24) === 'Smaller Than or Equal to 24');
 ```

-`testLessOrEqual(25)` should return the string `More Than 24`
+`testLessOrEqual(25)` повинен повертати рядок `More Than 24`

 ```js
 assert(testLessOrEqual(25) === 'More Than 24');
 ```

-`testLessOrEqual(55)` should return the string `More Than 24`
+`testLessOrEqual(55)` повинен повертати рядок `More Than 24`

 ```js
 assert(testLessOrEqual(55) === 'More Than 24');
 ```

-You should use the `<=` operator at least twice
+Ви повинні використати оператор `<=` принаймні двічі

 ```js
 assert(code.match(/val\s*<=\s*('|")*\d+('|")*/g).length > 1);
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-strict-equality-operator.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-strict-equality-operator.md
@@ -1,6 +1,6 @@
 ---
 id: 56533eb9ac21ba0edf2244d1
-title: Порівняння з Оператором Абсолютної Рівності
+title: Порівняння з оператором «строго дорівнює»
 challengeType: 1
 videoUrl: 'https://scrimba.com/c/cy87atr'
 forumTopicId: 16790
@@ -9,44 +9,44 @@ dashedName: comparison-with-the-strict-equality-operator

 # --description--

-Абсолютна рівність (`===`) є аналогом оператора рівності (`==`). Однак, на відміну від оператора рівності, який намагається перетворити обидва значення в порівнянні зі звичайним типом, оператор абсолютної рівності не виконує перетворення типів.
+Строга рівність (`===`) є аналогом оператора рівності (`==`). Однак на відміну від оператора «дорівнює», який намагається перетворити обидва значення в порівнянні зі звичайним типом, оператор строгої рівності не перетворює типи даних.

-Якщо значення, які перетворюються, мають різні типи, вони вважаються нерівними і оператор абсолютної рівності видасть помилку.
+Якщо порівнювані значення мають різні типи, вони вважаються нерівними і оператор строгої рівності поверне false.

-**Наприклад**
+**Приклади**

 ```js
 3 ===  3  // true
 3 === '3' // false
 ```

-In the second example, `3` is a `Number` type and `'3'` is a `String` type.
+У другому прикладі `3` є типом `Number`, а `'3'` є типом `String`.

 # --instructions--

-Use the strict equality operator in the `if` statement so the function will return the string `Equal` when `val` is strictly equal to `7`.
+Використайте оператор «строго дорівнює» в інструкції `if`, щоб функція повернула рядок `Equal`, якщо `val` строго дорівнює `7`.

 # --hints--

-`testStrict(10)` should return the string `Not Equal`
+`testStrict(10)` повинен повертати рядок `Not Equal`

 ```js
 assert(testStrict(10) === 'Not Equal');
 ```

-`testStrict(7)` should return the string `Equal`
+`testStrict(7)` повинен повертати рядок `Equal`

 ```js
 assert(testStrict(7) === 'Equal');
 ```

-`testStrict("7")` should return the string `Not Equal`
+`testStrict("7")` повинен повертати рядок `Not Equal`

 ```js
 assert(testStrict('7') === 'Not Equal');
 ```

-You should use the `===` operator
+Ви повинні використати оператор `===`

 ```js
 assert(code.match(/(val\s*===\s*\d+)|(\d+\s*===\s*val)/g).length > 0);
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-strict-inequality-operator.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-strict-inequality-operator.md
@@ -1,6 +1,6 @@
 ---
 id: 56533eb9ac21ba0edf2244d3
-title: Порівняння з Оператором Абсолютної Нерівності
+title: Порівняння з оператором «строго не дорівнює»
 challengeType: 1
 videoUrl: 'https://scrimba.com/c/cKekkUy'
 forumTopicId: 16791
@@ -9,7 +9,7 @@ dashedName: comparison-with-the-strict-inequality-operator

 # --description--

-Оператор абсолютної нерівності (`!==`) є логічною протилежністю оператора абсолютної рівності. Це означає «строго нерівно» та повертає `false`, де строга рівність повернула б `true` та *навпаки*. Оператор абсолютної нерівності не буде перетворювати типи даних.
+Оператор строгої нерівності (`!==`) є логічною протилежністю оператора строгої рівності. Це означає «строго нерівно» та повертає `false`, де строга рівність повернула б `true` та *навпаки*. Оператор «строго не дорівнює» не перетворює типи даних.

 **Приклади**

@@ -21,35 +21,35 @@ dashedName: comparison-with-the-strict-inequality-operator

 # --instructions--

-Add the strict inequality operator to the `if` statement so the function will return the string `Not Equal` when `val` is not strictly equal to `17`
+Додайте оператор «строго не дорівнює» до інструкції `if`, щоб функція повернула рядок `Not Equal`, якщо `val` строго не дорівнює `17`

 # --hints--

-`testStrictNotEqual(17)` має повернути рядок `Equal`
+`testStrictNotEqual(17)` повинен повертати рядок `Equal`

 ```js
 assert(testStrictNotEqual(17) === 'Equal');
 ```

-`testStrictNotEqual("17")` має повернути рядок `Not Equal`
+`testStrictNotEqual("17")` повинен повертати рядок `Not Equal`

 ```js
 assert(testStrictNotEqual('17') === 'Not Equal');
 ```

-`testStrictNotEqual(12)` має повернути рядок `Not Equal`
+`testStrictNotEqual(12)` повинен повертати рядок `Not Equal`

 ```js
 assert(testStrictNotEqual(12) === 'Not Equal');
 ```

-`testStrictNotEqual("bob")` має повернути рядок `Not Equal`
+`testStrictNotEqual("bob")` повинен повертати рядок `Not Equal`

 ```js
 assert(testStrictNotEqual('bob') === 'Not Equal');
 ```

-You should use the `!==` operator
+Ви повинні використати оператор `!==`

 ```js
 assert(code.match(/(val\s*!==\s*\d+)|(\d+\s*!==\s*val)/g).length > 0);
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/comparisons-with-the-logical-and-operator.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/comparisons-with-the-logical-and-operator.md
@@ -1,6 +1,6 @@
 ---
 id: 56533eb9ac21ba0edf2244d8
-title: Порівняння з оператором "більше ніж"
+title: Порівняння з логічним оператором and
 challengeType: 1
 videoUrl: 'https://scrimba.com/c/cvbRVtr'
 forumTopicId: 16799
@@ -9,9 +9,9 @@ dashedName: comparisons-with-the-logical-and-operator

 # --description--

-Трапляється, що потрібно перевіряти більше ніж одну цифру одночасно. <dfn>Логічний оператор and</dfn> (`&&`) повертає `true` лише за умови, що <dfn>операнди</dfn> зліва та справа вірні.
+Іноді потрібно перевірити декілька речей одночасно. <dfn>Логічний оператор and</dfn> (`&&`) повертає `true` лише за умови, що <dfn>операнди</dfn> зліва та справа істинні.

-Такого ж результату можна досягнути шляхом закладання інформації всередині іншого:
+Такого ж результату можна досягнути, вклавши одну інструкцію if в іншу:

 ```js
 if (num > 5) {
@@ -22,7 +22,7 @@ if (num > 5) {
 return "No";
 ```

-результат `Yes`, якщо `num` є більшим `5` та меньшим за `10`. Приклад оператора наведено нище:
+поверне `Yes`, якщо `num` більше ніж `5` та менше ніж `10`. Цю саму логіку можна записати як:

 ```js
 if (num > 5 && num < 10) {
@@ -33,65 +33,65 @@ return "No";

 # --instructions--

-Замініть дві інструкції if на одну інструкцію, використавши оператор `&&`, який поверне рядок `Yes` якщо `val` менший чи дорівнює `50` та більший чи дорівнює `25`. В іншому випадку значення рядка стане `No`.
+Замініть дві інструкції if на одну інструкцію, використавши оператор `&&`, який поверне рядок `Yes`, якщо `val` менше чи дорівнює `50` та більше чи дорівнює `25`. В іншому випадку поверніть рядок `No`.

 # --hints--

-Використовуйте оператор `&&` лише один раз
+Ви повинні використати оператор `&&` лише раз

 ```js
 assert(code.match(/&&/g).length === 1);
 ```

-У вас має бути лише один елемент `if`
+Ви повинні мати лише одну інструкцію `if`

 ```js
 assert(code.match(/if/g).length === 1);
 ```

-`testLogicalAnd(0)` перетворюється у рядку на `No`
+`testLogicalAnd(0)` повинен повертати рядок `No`

 ```js
 assert(testLogicalAnd(0) === 'No');
 ```

-`testLogicalAnd(24)` перетворюється на `No`
+`testLogicalAnd(24)` повинен повертати рядок `No`

 ```js
 assert(testLogicalAnd(24) === 'No');
 ```

-`testLogicalAnd(25)` перетворюється на `Yes`
+`testLogicalAnd(25)` повинен повертати рядок `Yes`

 ```js
 assert(testLogicalAnd(25) === 'Yes');
 ```

-`testLogicalAnd(30)` перетворюється на `Yes`
+`testLogicalAnd(30)` повинен повертати рядок `Yes`

 ```js
 assert(testLogicalAnd(30) === 'Yes');
 ```

-`testLogicalAnd(50)` перетворюється на `Yes`
+`testLogicalAnd(50)` повинен повертати рядок `Yes`

 ```js
 assert(testLogicalAnd(50) === 'Yes');
 ```

-`testLogicalAnd(51)` перетворюється на `No`
+`testLogicalAnd(51)` повинен повертати рядок `No`

 ```js
 assert(testLogicalAnd(51) === 'No');
 ```

-`testLogicalAnd(75)` перетворюється на `No`
+`testLogicalAnd(75)` повинен повертати рядок `No`

 ```js
 assert(testLogicalAnd(75) === 'No');
 ```

-`testLogicalAnd(80)` перетворюється на `No`
+`testLogicalAnd(80)` повинен повертати рядок `No`

 ```js
 assert(testLogicalAnd(80) === 'No');
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/comparisons-with-the-logical-or-operator.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/comparisons-with-the-logical-or-operator.md
@@ -1,6 +1,6 @@
 ---
 id: 56533eb9ac21ba0edf2244d9
-title: Порівняння з оператором "більше ніж"
+title: Порівняння з логічним оператором or
 challengeType: 1
 videoUrl: 'https://scrimba.com/c/cEPrGTN'
 forumTopicId: 16800
@@ -9,11 +9,11 @@ dashedName: comparisons-with-the-logical-or-operator

 # --description--

-<dfn>Логічний оператор or</dfn> (`||`) повертає `true`, якщо один з <dfn>операндів</dfn> є `true`. В іншому випадку перетворюється на `false`.
+<dfn>Логічний оператор or</dfn> (`||`) повертає `true`, якщо один з <dfn>операндів</dfn> є `true`. В іншому випадку він повертає `false`.

-Оператор <dfn>логічний або</dfn> складається з двох символів труби (`||`). Зазвичай його можна знайти на клавіатурі між клавіш Backspace та Enter.
+<dfn>Логічний оператор or</dfn> складається з двох вертикальних рисок: (`||`). Як правило, цей символ можна знайти на клавіатурі між клавішами backspace та enter.

-Шаблон нижче повинен бути схожим з етапами вище:
+Наведений нижче шаблон має виглядати знайомим за пунктами з попередніх уривків:

 ```js
 if (num > 10) {
@@ -25,7 +25,7 @@ if (num < 5) {
 return "Yes";
 ```

-стає `Yes` тільки, якщо `num` між `5` та `10` (5 та 10 включно). Приклад оператора наведено нижче:
+поверне `Yes` лише за умови, що `num` знаходиться між `5` та `10` (включно з 5 і 10). Цю саму логіку можна записати як:

 ```js
 if (num > 10 || num < 5) {
@@ -36,65 +36,65 @@ return "Yes";

 # --instructions--

-Об'єднайте два оператори `if` в один оператор який перетворить рядок `Outside`, якщо `val` не знаходиться в діапазоні від `10` до `20` включно. В іншому випадку значення рядка стане `Inside`.
+Об'єднайте дві інструкції `if` в одну інструкцію, яка поверне рядок `Outside`, якщо `val` не знаходиться між `10` та `20` (включно). В іншому випадку поверніть рядок `Inside`.

 # --hints--

-Використовуйте оператор `||` лише раз
+Ви повинні використати оператор `||` лише раз

 ```js
 assert(code.match(/\|\|/g).length === 1);
 ```

-У вас має бути лише один елемент `if`
+Ви повинні мати лише одну інструкцію `if`

 ```js
 assert(code.match(/if/g).length === 1);
 ```

-`testLogicalOr(0)` перетворюється на `Outside`
+`testLogicalOr(0)` повинен повертати рядок `Outside`

 ```js
 assert(testLogicalOr(0) === 'Outside');
 ```

-`testLogicalOr(9)` перетворюється на `Outside`
+`testLogicalOr(9)` повинен повертати рядок `Outside`

 ```js
 assert(testLogicalOr(9) === 'Outside');
 ```

-`testLogicalOr(10)` перетворюється на `Inside`
+`testLogicalOr(10)` повинен повертати рядок `Inside`

 ```js
 assert(testLogicalOr(10) === 'Inside');
 ```

-`testLogicalOr(15)` перетворюється на `Inside`
+`testLogicalOr(15)` повинен повертати рядок `Inside`

 ```js
 assert(testLogicalOr(15) === 'Inside');
 ```

-`testLogicalOr(19)` перетворюється на `Inside`
+`testLogicalOr(19)` повинен повертати рядок `Inside`

 ```js
 assert(testLogicalOr(19) === 'Inside');
 ```

-`testLogicalOr(20)` перетворюється на `Inside`
+`testLogicalOr(20)` повинен повертати рядок `Inside`

 ```js
 assert(testLogicalOr(20) === 'Inside');
 ```

-`testLogicalOr(21)` перетворюється на `Outside`
+`testLogicalOr(21)` повинен повертати рядок `Outside`

 ```js
 assert(testLogicalOr(21) === 'Outside');
 ```

-`testLogicalOr(25)` перетворюється на `Outside`
+`testLogicalOr(25)` повинен повертати рядок `Outside`

 ```js
 assert(testLogicalOr(25) === 'Outside');
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/compound-assignment-with-augmented-addition.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/compound-assignment-with-augmented-addition.md
@@ -1,6 +1,6 @@
 ---
 id: 56533eb9ac21ba0edf2244af
-title: Комбіноване присвоєння з розширеним додаванням
+title: Складене присвоєння з додаванням
 challengeType: 1
 videoUrl: 'https://scrimba.com/c/cDR6LCb'
 forumTopicId: 16661
@@ -9,13 +9,13 @@ dashedName: compound-assignment-with-augmented-addition

 # --description--

-У програмуванні присвоєння зазвичай використовують для зміни вмісту змінної. Пам'ятайте, що спершу обчислюється усе, що стоїть праворуч від знаку "дорівнює", тож можна сказати, що:
+У програмуванні присвоєння зазвичай використовують, щоб змінити вміст змінної. Пам'ятайте, що спершу обчислюється усе, що стоїть праворуч від знаку рівності, тому можна сказати, що:

 ```js
 myVar = myVar + 5;
 ```

-додати `5` до `myVar`. Оскільки це загальний шаблон, то існують оператори, які виконують математичні дії та присвоєння за один крок.
+додасть `5` до `myVar`. Оскільки це загальний шаблон, то існують оператори, які виконують математичні дії та присвоєння одночасно.

 Одним з таких операторів є `+=`.

@@ -25,39 +25,39 @@ myVar += 5;
 console.log(myVar);
 ```

-У консолі відображатиметься значення `6`.
+На консолі відображатиметься `6`.

 # --instructions--

-Конвертуйте присвоєння для `a`, `b`, та `c`, щоб використати оператор `+=`.
+Конвертуйте присвоєння для `a`, `b` та `c`, використовуючи оператор `+=`.

 # --hints--

-`a` повинне дорівнювати `15`.
+`a` повинна дорівнювати `15`.

 ```js
 assert(a === 15);
 ```

-`b` повинне дорівнювати `26`.
+`b` повинна дорівнювати `26`.

 ```js
 assert(b === 26);
 ```

-`c` повинне дорівнювати `19`.
+`c` повинна дорівнювати `19`.

 ```js
 assert(c === 19);
 ```

-Слід використовувати оператор `+=` для всіх змінних.
+Ви повинні використати оператор `+=` для кожної змінної.

 ```js
 assert(code.match(/\+=/g).length === 3);
 ```

-Не слід змінювати код над зазначеним коментарем.
+Не змінюйте код над зазначеним коментарем.

 ```js
 assert(
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/compound-assignment-with-augmented-division.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/compound-assignment-with-augmented-division.md
@@ -1,6 +1,6 @@
 ---
 id: 56533eb9ac21ba0edf2244b2
-title: Комбіноване присвоєння з розширеним діленням
+title: Складене присвоєння з діленням
 challengeType: 1
 videoUrl: 'https://scrimba.com/c/c2QvKT2'
 forumTopicId: 16659
@@ -15,7 +15,7 @@ dashedName: compound-assignment-with-augmented-division
 myVar = myVar / 5;
 ```

-Поділить `myVar` на `5`. Це можна записати ще так:
+поділить `myVar` на `5`. Можна записати ще так:

 ```js
 myVar /= 5;
@@ -23,35 +23,35 @@ myVar /= 5;

 # --instructions--

-Конвертуйте присвоєння для `a`, `b`, та `c`, щоб використати оператор `/=`.
+Конвертуйте присвоєння для `a`, `b` та `c`, використовуючи оператор `/=`.

 # --hints--

-`a` повинне дорівнювати `4`.
+`a` повинна дорівнювати `4`.

 ```js
 assert(a === 4);
 ```

-`b` повинне дорівнювати `27`.
+`b` повинна дорівнювати `27`.

 ```js
 assert(b === 27);
 ```

-`c` повинне дорівнювати `3`.
+`c` повинна дорівнювати `3`.

 ```js
 assert(c === 3);
 ```

-Слід використовувати оператор `/=` для всіх змінних.
+Ви повинні використати оператор `/=` для кожної змінної.

 ```js
 assert(code.match(/\/=/g).length === 3);
 ```

-Не слід змінювати код над зазначеним коментарем.
+Не змінюйте код над зазначеним коментарем.

 ```js
 assert(
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/compound-assignment-with-augmented-multiplication.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/compound-assignment-with-augmented-multiplication.md
@@ -1,6 +1,6 @@
 ---
 id: 56533eb9ac21ba0edf2244b1
-title: Комбіноване присвоєння з розширеним множенням
+title: Складене присвоєння з множенням
 challengeType: 1
 videoUrl: 'https://scrimba.com/c/c83vrfa'
 forumTopicId: 16662
@@ -15,7 +15,7 @@ dashedName: compound-assignment-with-augmented-multiplication
 myVar = myVar * 5;
 ```

-`myVar` множитиметься на `5`. Це можна переписати так:
+помножить `myVar` на `5`. Можна записати ще так:

 ```js
 myVar *= 5;
@@ -23,35 +23,35 @@ myVar *= 5;

 # --instructions--

-Перетворіть присвоєння для `a`, `b`, і `c`, щоб використати оператор `*=`.
+Конвертуйте присвоєння для `a`, `b` та `c`, використовуючи оператор `*=`.

 # --hints--

-`a` повинне дорівнювати `25`.
+`a` повинна дорівнювати `25`.

 ```js
 assert(a === 25);
 ```

-`b` повинне дорівнювати `36`.
+`b` повинна дорівнювати `36`.

 ```js
 assert(b === 36);
 ```

-`c` повинне дорівнювати `46`.
+`c` повинна дорівнювати `46`.

 ```js
 assert(c === 46);
 ```

-Вам слід використовувати оператор `*=` для кожної змінної.
+Ви повинні використати оператор `*=` для кожної змінної.

 ```js
 assert(code.match(/\*=/g).length === 3);
 ```

-Не слід змінювати код над зазначеним коментарем.
+Не змінюйте код над зазначеним коментарем.

 ```js
 assert(
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/compound-assignment-with-augmented-subtraction.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/compound-assignment-with-augmented-subtraction.md
@@ -1,6 +1,6 @@
 ---
 id: 56533eb9ac21ba0edf2244b0
-title: Комбіноване присвоєння з розширеним відніманням
+title: Складене присвоєння з відніманням
 challengeType: 1
 videoUrl: 'https://scrimba.com/c/c2Qv7AV'
 forumTopicId: 16660
@@ -9,13 +9,13 @@ dashedName: compound-assignment-with-augmented-subtraction

 # --description--

-Схожий на оператор `+=`, що додає, `-=` віднімає число від змінної.
+Оператор `-=` схожий до `+=`, але він віднімає число від змінної.

 ```js
 myVar = myVar - 5;
 ```

-`5` віднімається від `myVar`. Це можна записати ще так:
+відніме `5` від `myVar`. Можна записати ще так:

 ```js
 myVar -= 5;
@@ -23,35 +23,35 @@ myVar -= 5;

 # --instructions--

-Перетворіть присвоєння для `a`, `b`, і `c`, щоб використати оператор `-=`.
+Конвертуйте присвоєння для `a`, `b` та `c`, використовуючи оператор `-=`.

 # --hints--

-`a` повинне дорівнювати `5`.
+`a` повинна дорівнювати `5`.

 ```js
 assert(a === 5);
 ```

-`b` повинне дорівнювати `-6`.
+`b` повинна дорівнювати `-6`.

 ```js
 assert(b === -6);
 ```

-`c` повинне дорівнювати `2`.
+`c` повинна дорівнювати `2`.

 ```js
 assert(c === 2);
 ```

-Слід використовувати оператор `-=` для кожної змінної.
+Ви повинні використати оператор `-=` для кожної змінної.

 ```js
 assert(code.match(/-=/g).length === 3);
 ```

-Не слід змінювати код над зазначеним коментарем.
+Не змінюйте код над зазначеним коментарем.

 ```js
 assert(
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/concatenating-strings-with-plus-operator.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/concatenating-strings-with-plus-operator.md
@@ -1,6 +1,6 @@
 ---
 id: 56533eb9ac21ba0edf2244b7
-title: Об'єднання рядків за допомогою оператора "плюс"
+title: Об'єднання рядків за допомогою оператора +
 challengeType: 1
 videoUrl: 'https://scrimba.com/c/cNpM8AN'
 forumTopicId: 16802
@@ -9,54 +9,54 @@ dashedName: concatenating-strings-with-plus-operator

 # --description--

-В JavaScript, коли оператор `+` використовується зі значенням `String`, це називається оператором <dfn>об'єднання</dfn>. З рядків можна створити новий рядок, <dfn>об'єднавши</dfn> їх.
+Оператором <dfn>об'єднання (конкатенації)</dfn> у JavaScript називають оператор `+`, який використовується зі значенням `String`. З рядків можна створити новий рядок, <dfn>об'єднавши</dfn> їх.

-**Наприклад:**
+**Приклад**

 ```js
 'My name is Alan,' + ' I concatenate.'
 ```

-**Примітка:** Зверніть увагу на пробіли. Під час об'єднання між рядками відсутні пробіли, вам потрібно буде додати їх самостійно.
+**Примітка:** зверніть увагу на пробіли. Конкатенація не додає пробіли між об'єднаними рядками, вам потрібно додавати їх самостійно.

-Наприклад:
+Приклад:

 ```js
 const ourStr = "I come first. " + "I come second.";
 ```

-The string `I come first. I come second.` would be displayed in the console.
+На консолі відображатиметься рядок `I come first. I come second.`.
 # --instructions--

-Створіть `myStr` з рядків `This is the start.` й `This is the end.` за допомогою `+` оператору. Обов'язково використовуйте пробіл між двома рядками.
+Побудуйте `myStr` з рядків `This is the start.` та `This is the end.`, використовуючи оператор `+`. Не забудьте використати пробіл між двома рядками.

 # --hints--

-`myStr` should have a single space character between the two strings.
+`myStr` повинен містити один пробіл між двома рядками.

 ```js
 assert(/start\. This/.test(myStr));
 ```

-`myStr` should have a value of the string `This is the start. This is the end.`
+`myStr` повинен мати значення рядка `This is the start. This is the end.`

 ```js
 assert(myStr === 'This is the start. This is the end.');
 ```

-You should use the `+` operator to build `myStr`.
+Ви повинні використати оператор `+`, щоб побудувати `myStr`.

 ```js
 assert(code.match(/(["']).*\1\s*\+\s*(["']).*\2/g));
 ```

-`myStr` should be created using the `const` keyword.
+Ви повинні використати ключове слово `const`, щоб створити `myStr`.

 ```js
 assert(/const\s+myStr/.test(code));
 ```

-You should assign the result to the `myStr` variable.
+Ви повинні присвоїти результат до змінної `myStr`.

 ```js
 assert(/myStr\s*=/.test(code));
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/concatenating-strings-with-the-plus-equals-operator.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/concatenating-strings-with-the-plus-equals-operator.md
@@ -1,6 +1,6 @@
 ---
 id: 56533eb9ac21ba0edf2244b8
-title: Об'єднання рядків за допомогою оператора "плюс дорівнює"
+title: Об'єднання рядків за допомогою оператора +=
 challengeType: 1
 videoUrl: 'https://scrimba.com/c/cbQmmC4'
 forumTopicId: 16803
@@ -9,38 +9,38 @@ dashedName: concatenating-strings-with-the-plus-equals-operator

 # --description--

-Ми можемо також використовувати оператор `+=`, щоб <dfn>з'єднувати</dfn> рядок з кінцем уже існуючого рядка змінної. Або ще для того, щоб розділяти довгий рядок над кількома рядками.
+Ми можемо також використати оператор `+=`, щоб <dfn>об'єднати</dfn> рядок з кінцем наявної змінної рядка. Це корисно ще й для того, щоб розділити довгий рядок на декілька малих.

-**Примітка:** Зверніть увагу на пробіли. Під час об'єднання між рядками відсутні пробіли, вам потрібно буде додати їх самостійно.
+**Примітка:** зверніть увагу на пробіли. Конкатенація не додає пробіли між об'єднаними рядками, вам потрібно додавати їх самостійно.

-Наприклад:
+Приклад:

 ```js
 let ourStr = "I come first. ";
 ourStr += "I come second.";
 ```

-`ourStr` зараз має значення рядка `I come first. I come second.`.
+Тепер `ourStr` має значення рядка `I come first. I come second.`.

 # --instructions--

-Введіть `myStr` над кількома рядками, об'єднуючи ці два рядки: `This is the first sentence.` і `This is the second sentence.`. Використовуйте оператор `+=`. Використовуйте `+=` оператор, подібний до того, як показно в прикладі, й обов'язково зверніть увагу на наявність пробіл між рядками. Почніть з призначення першого рядка `myStr`, а потім додайте до другого рядка.
+Побудуйте `myStr` у декількох рядках, об'єднавши ці два рядки: `This is the first sentence.` та `This is the second sentence.`, використовуючи оператор `+=`. Використайте оператор `+=` подібно до того, як показно в прикладі, та не забудьте використати пробіл між двома рядками. Почніть з присвоєння першого рядка до `myStr`, а потім додайте другий рядок.

 # --hints--

-`myStr` should have a single space character between the two strings.
+`myStr` повинен містити один пробіл між двома рядками.

 ```js
 assert(/sentence\. This/.test(myStr));
 ```

-`myStr` should have a value of the string `This is the first sentence. This is the second sentence.`
+`myStr` повинен мати значення рядка `This is the first sentence. This is the second sentence.`

 ```js
 assert(myStr === 'This is the first sentence. This is the second sentence.');
 ```

-You should use the `+=` operator to build `myStr`.
+Ви повинні використати оператор `+=`, щоб побудувати `myStr`.

 ```js
 assert(code.match(/myStr\s*\+=\s*(["']).*\1/g));
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/constructing-strings-with-variables.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/constructing-strings-with-variables.md
@@ -9,9 +9,9 @@ dashedName: constructing-strings-with-variables

 # --description--

-Sometimes you will need to build a string. Використовуючи оператор об'єднання (`+`), можна вставити одну або декілька змінних у рядок, який ви створюєте.
+Іноді потрібно побудувати рядок. За допомогою оператора об'єднання (`+`) можна вставити одну або більше змінних у рядок, який ви будуєте.

-Наприклад:
+Приклад:

 ```js
 const ourName = "freeCodeCamp";
@@ -22,17 +22,17 @@ const ourStr = "Hello, our name is " + ourName + ", how are you?";

 # --instructions--

-Вставте `myName` у рядок з вашим іменем і створіть `myStr` з `myName` між рядками `My name is` і `and I am well!`
+Встановіть `myName` на рядок, рівний вашому імені, і побудуйте `myStr` із `myName` між рядками `My name is` та `and I am well!`

 # --hints--

-`myName` потрібно вставити у рядок, де є принаймні три символи.
+`myName` повинен бути встановлений на рядок з принаймні трьох символів.

 ```js
 assert(typeof myName !== 'undefined' && myName.length > 2);
 ```

-Ви маєте використати два оператори `+` для створення `myStr` з `myName` всередині нього.
+Ви повинні використати два оператори `+`, щоб побудувати `myStr` із `myName` всередині.

 ```js
 assert(code.match(/["']\s*\+\s*myName\s*\+\s*["']/g).length > 0);
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/divide-one-number-by-another-with-javascript.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/divide-one-number-by-another-with-javascript.md
@@ -32,7 +32,7 @@ const myVar = 16 / 2;
 assert(quotient === 2);
 ```

-Вам слід використовувати оператор `/`.
+Ви повинні використати оператор `/`.

 ```js
 assert(/\d+\s*\/\s*\d+/.test(code));
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/finding-a-remainder-in-javascript.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/finding-a-remainder-in-javascript.md
@@ -40,7 +40,7 @@ assert(/(const|let|var)\s+?remainder/.test(code));
 assert(remainder === 2);
 ```

-Вам слід використовувати оператор `%`
+Ви повинні використати оператор `%`

 ```js
 assert(/\s+?remainder\s*?=\s*?.*%.*;?/.test(code));
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/global-vs.-local-scope-in-functions.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/global-vs.-local-scope-in-functions.md
@@ -36,7 +36,7 @@ function myFun() {
 assert(outerWear === 'T-Shirt');
 ```

-`myOutfit` має повертати рядок `sweater`.
+`myOutfit` повинен повертати рядок `sweater`.

 ```js
 assert(myOutfit() === 'sweater');
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/golf-code.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/golf-code.md
@@ -19,67 +19,67 @@ In the game of Golf, each hole has a `par`, meaning, the average number of `stro

 # --hints--

-Рахунок `(4, 1)` має виводити стрічку `В лунку з першого удару!`
+`golfScore(4, 1)` повинен повертати рядок `Hole-in-one!`

 ```js
 assert(golfScore(4, 1) === 'Hole-in-one!');
 ```

-Рахунок `(4, 2)` має виводити стрічку `Орел`
+`golfScore(4, 2)` повинен повертати рядок `Eagle`

 ```js
 assert(golfScore(4, 2) === 'Eagle');
 ```

-Рахунок `(5, 2)` має виводити стрічку `Орел`
+`golfScore(5, 2)` повинен повертати рядок `Eagle`

 ```js
 assert(golfScore(5, 2) === 'Eagle');
 ```

-Рахунок `(4, 3)` має виводити стрічку `Пташка`
+`golfScore(4, 3)` повинен повертати рядок `Birdie`

 ```js
 assert(golfScore(4, 3) === 'Birdie');
 ```

-Рахунок `(4, 4)` має виводити стрічку `Середнячок`
+`golfScore(4, 4)` повинен повертати рядок `Par`

 ```js
 assert(golfScore(4, 4) === 'Par');
 ```

-Рахунок `(1, 1)` має виводити стрічку `В лунку з першого удару!`
+`golfScore(1, 1)` повинен повертати рядок `Hole-in-one!`

 ```js
 assert(golfScore(1, 1) === 'Hole-in-one!');
 ```

-Рахунок `(5, 5)` має виводити стрічку `Середнячок`
+`golfScore(5, 5)` повинен повертати рядок `Par`

 ```js
 assert(golfScore(5, 5) === 'Par');
 ```

-Рахунок `(4, 5)` має виводити стрічку `Страшко`
+`golfScore(4, 5)` повинен повертати рядок `Bogey`

 ```js
 assert(golfScore(4, 5) === 'Bogey');
 ```

-Рахунок `(4, 6)` має виводити стрічку `Двічі Страшко`
+`golfScore(4, 6)` повинен повертати рядок `Double Bogey`

 ```js
 assert(golfScore(4, 6) === 'Double Bogey');
 ```

-Рахунок `(4, 7)` має виводити стрічку `Йди додому!`
+`golfScore(4, 7)` повинен повертати рядок `Go Home!`

 ```js
 assert(golfScore(4, 7) === 'Go Home!');
 ```

-Рахунок `(5, 9)` має виводити стрічку `Йди додому!`
+`golfScore(5, 9)` повинен повертати рядок `Go Home!`

 ```js
 assert(golfScore(5, 9) === 'Go Home!');
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/increment-a-number-with-javascript.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/increment-a-number-with-javascript.md
@@ -43,7 +43,7 @@ assert(
 );
 ```

-Вам слід використовувати оператор `++`.
+Ви повинні використати оператор `++`.

 ```js
 assert(/[+]{2}\s*myVar|myVar\s*[+]{2}/.test(code));
--- 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
@@ -49,31 +49,31 @@ assert(
 );
 ```

-`testElseIf(0)` має повернути рядок `Smaller than 5`
+`testElseIf(0)` повинен повертати рядок `Smaller than 5`

 ```js
 assert(testElseIf(0) === 'Smaller than 5');
 ```

-`testElseIf(5)` має повернути рядок `Between 5 and 10`
+`testElseIf(5)` повинен повертати рядок `Between 5 and 10`

 ```js
 assert(testElseIf(5) === 'Between 5 and 10');
 ```

-`testElseIf(7)` має повернути рядок `Between 5 and 10`
+`testElseIf(7)` повинен повертати рядок `Between 5 and 10`

 ```js
 assert(testElseIf(7) === 'Between 5 and 10');
 ```

-`testElseIf(10)` має повернути рядок `Between 5 and 10`
+`testElseIf(10)` повинен повертати рядок `Between 5 and 10`

 ```js
 assert(testElseIf(10) === 'Between 5 and 10');
 ```

-`testElseIf(12)` має повернути рядок `Greater than 10`
+`testElseIf(12)` повинен повертати рядок `Greater than 10`

 ```js
 assert(testElseIf(12) === 'Greater than 10');
--- 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
@@ -25,7 +25,7 @@ if (num > 10) {

 # --hints--

-Ви повинні отримати одну команду `if` у редакторі
+Ви повинні мати лише одну інструкцію `if` у редакторі

 ```js
 assert(code.match(/if/g).length === 1);
@@ -37,25 +37,25 @@ assert(code.match(/if/g).length === 1);
 assert(/else/g.test(code));
 ```

-`testElse(4)` повинен видати рядок `5 or Smaller`
+`testElse(4)` повинен повертати рядок `5 or Smaller`

 ```js
 assert(testElse(4) === '5 or Smaller');
 ```

-`testElse(5)` повинен видати рядок `5 or Smaller`
+`testElse(5)` повинен повертати рядок `5 or Smaller`

 ```js
 assert(testElse(5) === '5 or Smaller');
 ```

-`testElse(6)` повинен видати рядок `Bigger than 5`
+`testElse(6)` повинен повертати рядок `Bigger than 5`

 ```js
 assert(testElse(6) === 'Bigger than 5');
 ```

-`testElse(10)` повинен видати рядок `Bigger than 5`
+`testElse(10)` повинен повертати рядок `Bigger than 5`

 ```js
 assert(testElse(10) === 'Bigger than 5');
--- 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
@@ -58,19 +58,19 @@ bar(0)

 # --hints--

-`orderMyLogic(4)` має видати рядок `Less than 5`
+`orderMyLogic(4)` повинен повертати рядок `Less than 5`

 ```js
 assert(orderMyLogic(4) === 'Less than 5');
 ```

-`orderMyLogic(6)` має видати рядок `Less than 10`
+`orderMyLogic(6)` повинен повертати рядок `Less than 10`

 ```js
 assert(orderMyLogic(6) === 'Less than 10');
 ```

-`orderMyLogic(11)` має видати рядок `Greater than or equal to 10`
+`orderMyLogic(11)` повинен повертати рядок `Greater than or equal to 10`

 ```js
 assert(orderMyLogic(11) === 'Greater than or equal to 10');
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/multiple-identical-options-in-switch-statements.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/multiple-identical-options-in-switch-statements.md
@@ -37,55 +37,55 @@ switch (val) {

 # --hints--

-`sequentialSizes(1)` перетворюється на `Low`
+`sequentialSizes(1)` повинен повертати рядок `Low`

 ```js
 assert(sequentialSizes(1) === 'Low');
 ```

-`sequentialSizes(2)` змінюється на `Low`
+`sequentialSizes(2)` повинен повертати рядок `Low`

 ```js
 assert(sequentialSizes(2) === 'Low');
 ```

-`sequentialSizes(3)` змінюється на `Low`
+`sequentialSizes(3)` повинен повертати рядок `Low`

 ```js
 assert(sequentialSizes(3) === 'Low');
 ```

-`sequentialSizes(4)` перетворюється на `Mid`
+`sequentialSizes(4)` повинен повертати рядок `Mid`

 ```js
 assert(sequentialSizes(4) === 'Mid');
 ```

-`sequentialSizes(5)` перетворюється на `Mid`
+`sequentialSizes(5)` повинен повертати рядок `Mid`

 ```js
 assert(sequentialSizes(5) === 'Mid');
 ```

-`sequentialSizes(6)` перетворюється на `Mid`
+`sequentialSizes(6)` повинен повертати рядок `Mid`

 ```js
 assert(sequentialSizes(6) === 'Mid');
 ```

-`sequentialSizes(7)` перетворюється на `High`
+`sequentialSizes(7)` повинен повертати рядок `High`

 ```js
 assert(sequentialSizes(7) === 'High');
 ```

-`sequentialSizes(8)` перетворюється на `High`
+`sequentialSizes(8)` повинен повертати рядок `High`

 ```js
 assert(sequentialSizes(8) === 'High');
 ```

-`sequentialSizes(9)` перетворюється на `High`
+`sequentialSizes(9)` повинен повертати рядок `High`

 ```js
 assert(sequentialSizes(9) === 'High');
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/multiply-two-decimals-with-javascript.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/multiply-two-decimals-with-javascript.md
@@ -25,7 +25,7 @@ dashedName: multiply-two-decimals-with-javascript
 assert(product === 5.0);
 ```

-Вам слід використовувати оператор `*`
+Ви повинні використати оператор `*`

 ```js
 assert(/\*/.test(code));
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/multiply-two-numbers-with-javascript.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/multiply-two-numbers-with-javascript.md
@@ -33,7 +33,7 @@ const myVar = 13 * 13;
 assert(product === 80);
 ```

-Ви маєте використати оператор `*`.
+Ви повинні використати оператор `*`.

 ```js
 assert(/\*/.test(code));
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/practice-comparing-different-values.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/practice-comparing-different-values.md
@@ -32,19 +32,19 @@ typeof '3'

 # --hints--

-`compareEquality(10, "10")` повинне повернути рядок `Not Equal`
+`compareEquality(10, "10")` повинен повертати рядок `Not Equal`

 ```js
 assert(compareEquality(10, '10') === 'Not Equal');
 ```

-`compareEquality("20", 20)` повинне повернути рядок `Not Equal`
+`compareEquality("20", 20)` повинен повертати рядок `Not Equal`

 ```js
 assert(compareEquality('20', 20) === 'Not Equal');
 ```

-Слід використовувати оператор `===`
+Ви повинні використати оператор `===`

 ```js
 assert(code.match(/===/g));
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/profile-lookup.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/profile-lookup.md
@@ -23,7 +23,7 @@ dashedName: profile-lookup

 # --hints--

-`lookUpProfile("Kristian", "lastName")` повинен повернути рядок `Vos`
+`lookUpProfile("Kristian", "lastName")` повинен повертати рядок `Vos`

 ```js
 assert(lookUpProfile('Kristian', 'lastName') === 'Vos');
@@ -44,13 +44,13 @@ assert.deepEqual(lookUpProfile('Sherlock', 'likes'), [
 assert(typeof lookUpProfile('Harry', 'likes') === 'object');
 ```

-`lookUpProfile("Bob", "number")` повинен повернути рядок `No such contact`
+`lookUpProfile("Bob", "number")` повинен повертати рядок `No such contact`

 ```js
 assert(lookUpProfile('Bob', 'number') === 'No such contact');
 ```

-`lookUpProfile("Bob", "potato")` повинен повернути рядок `No such contact`
+`lookUpProfile("Bob", "potato")` повинен повертати рядок `No such contact`

 ```js
 assert(lookUpProfile('Bob', 'potato') === 'No such contact');
--- 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
@@ -30,7 +30,7 @@ myObj.hasOwnProperty("middle");

 # --hints--

-`checkObj({gift: "pony", pet: "kitten", bed: "sleigh"}, "gift")` має повернути рядок `pony`.
+`checkObj({gift: "pony", pet: "kitten", bed: "sleigh"}, "gift")` повинен повертати рядок `pony`.

 ```js
 assert(
@@ -38,7 +38,7 @@ assert(
 );
 ```

-`checkObj({gift: "pony", pet: "kitten", bed: "sleigh"}, "pet")` має повернути рядок `kitten`.
+`checkObj({gift: "pony", pet: "kitten", bed: "sleigh"}, "pet")` повинен повертати рядок `kitten`.

 ```js
 assert(
@@ -46,7 +46,7 @@ assert(
 );
 ```

-`checkObj({gift: "pony", pet: "kitten", bed: "sleigh"}, "house")` має повернути рядок `Not Found`.
+`checkObj({gift: "pony", pet: "kitten", bed: "sleigh"}, "house")` повинен повертати рядок `Not Found`.

 ```js
 assert(
@@ -55,19 +55,19 @@ assert(
 );
 ```

-`checkObj({city: "Seattle"}, "city")` має повернути рядок `Seattle`.
+`checkObj({city: "Seattle"}, "city")` повинен повертати рядок `Seattle`.

 ```js
 assert(checkObj({ city: 'Seattle' }, 'city') === 'Seattle');
 ```

-`checkObj({city: "Seattle"}, "district")` має повернути рядок `Not Found`.
+`checkObj({city: "Seattle"}, "district")` повинен повертати рядок `Not Found`.

 ```js
 assert(checkObj({ city: 'Seattle' }, 'district') === 'Not Found');
 ```

-`checkObj({pet: "kitten", bed: "sleigh"}, "gift")` має повернути рядок `Not Found`.
+`checkObj({pet: "kitten", bed: "sleigh"}, "gift")` повинен повертати рядок `Not Found`.

 ```js
 assert(checkObj({ pet: 'kitten', bed: 'sleigh' }, 'gift') === 'Not Found');
--- 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
@@ -36,7 +36,7 @@ const lastLetter = firstName[firstName.length - 1];
 assert(lastLetterOfLastName === 'e');
 ```

-Вам слід використовувати `.length`, щоб отримати останню літеру.
+Ви повинні використати `.length`, щоб отримати останню літеру.

 ```js
 assert(code.match(/\.length/g).length > 0);
--- 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
@@ -59,13 +59,13 @@ assert(typeof trueOrFalse(true) === 'string');
 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');
--- 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
@@ -57,19 +57,19 @@ function findGreaterOrEqual(a, b) {
 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');
--- 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
@@ -35,7 +35,7 @@ function findGreater(a, b) {

 # --instructions--

-Використовуйте умовний оператор у функції `checkEqual`, щоб перевірити чи два числа рівні, чи ні. Функція має повернути рядок `Equal` або рядок `Not Equal`.
+Використовуйте умовний оператор у функції `checkEqual`, щоб перевірити чи два числа рівні, чи ні. Функція повинна повернути рядок `Equal` або рядок `Not Equal`.

 # --hints--

@@ -45,19 +45,19 @@ function findGreater(a, b) {
 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');