chore(i18n,curriculum): processed translations - new ukrainian (#44447)

2021-12-10 11:14:24 +05:30
parent 8651ee1797
commit 0473dedf47
1663 changed files with 156692 additions and 1 deletions
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/access-array-data-with-indexes.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/access-array-data-with-indexes.md
@@ -0,0 +1,89 @@
+---
+id: 56bbb991ad1ed5201cd392ca
+title: Доступ до елементу в масиві за допомогою індексу
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cBZQbTz'
+forumTopicId: 16158
+dashedName: access-array-data-with-indexes
+---
+
+# --description--
+
+Ми можемо отримати доступ до даних всередині масивів за допомогою <dfn>індексів</dfn>.
+
+Індекс масивів, так як і в рядках, вказується у квадратних дужках ([]). Однак індекс в масивах використовується для отримання доступу до певного елемента в масиві. Як і рядки, масиви використовують індексування <dfn>на основі нуля</dfn>, тому перший елемент у масиві має індекс `0`.
+
+<br>
+
+**Наприклад**
+
+```js
+const array = [50, 60, 70];
+array[0];
+const data = array[1];
+```
+
+`array[0]` становить `50`, і`data` має значення `60`.
+
+**Примітка:** ніколи не вставляйте пробіл між ім'ям масиву і квадратними дужками, наприклад `array [0]`. Хоча JavaScript прочитає це правильно, але це може створити труднощі для інших програмістів, які читатимуть ваш код.
+
+# --instructions--
+
+Створіть змінну з назвою `myData` і встановіть її значення рівне до першому елементу `myArray`, використовуючи квадратні дужки.
+
+# --hints--
+
+Змінна `myData` повинна дорівнювати першому значенню `myArray`.
+
+```js
+assert(
+  (function () {
+    if (
+      typeof myArray !== 'undefined' &&
+      typeof myData !== 'undefined' &&
+      myArray[0] === myData
+    ) {
+      return true;
+    } else {
+      return false;
+    }
+  })()
+);
+```
+
+До даних в змінній `myArray` слід отримати доступ за допомогою індексу у квадратних дужках.
+
+```js
+assert(
+  (function () {
+    if (code.match(/\s*=\s*myArray\[0\]/g)) {
+      return true;
+    } else {
+      return false;
+    }
+  })()
+);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+if(typeof myArray !== "undefined" && typeof myData !== "undefined"){(function(y,z){return 'myArray = ' + JSON.stringify(y) + ', myData = ' + JSON.stringify(z);})(myArray, myData);}
+```
+
+## --seed-contents--
+
+```js
+const myArray = [50, 60, 70];
+
+
+```
+
+# --solutions--
+
+```js
+const myArray = [50, 60, 70];
+const myData = myArray[0];
+```
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/access-multi-dimensional-arrays-with-indexes.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/access-multi-dimensional-arrays-with-indexes.md
@@ -0,0 +1,77 @@
+---
+id: 56592a60ddddeae28f7aa8e1
+title: Доступ до багатовимірних масивів за допомогою індексів
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/ckND4Cq'
+forumTopicId: 16159
+dashedName: access-multi-dimensional-arrays-with-indexes
+---
+
+# --description--
+
+<dfn>Багатовимірні масиви</dfn> можна також описати як *масиви в масивах*. Коли ви використовуєте дужки для доступу до масиву, перша пара дужок відноситься до матеріалів зовнішнього (перший рівень) масиву, і кожна додаткова пара дужок стосується наступного рівня матеріалів.
+
+**Наприклад**
+
+```js
+const arr = [
+  [1, 2, 3],
+  [4, 5, 6],
+  [7, 8, 9],
+  [[10, 11, 12], 13, 14]
+];
+
+arr[3];
+arr[3][0];
+arr[3][0][1];
+```
+
+`arr[3]` є `[[10, 11, 12], 13, 14]`, `arr[3][0]` є `[10, 11, 12]`, і `arr[3][0][1]` є `11`.
+
+**Примітка:** ніколи не вставляйте пробіл між ім'ям масиву і квадратними дужками, наприклад, так `array [0][0]` і навіть так `array [0] [0]` не можна робити. Незважаючи на те, що для JavaScript це є дрібницею, ця звичка може ускладнити читання коду іншими програмістами.
+
+# --instructions--
+
+За допомогою квадратних дужок виберіть елемент із `myArray` таким чином, щоб `myData` дорівнював `8`.
+
+# --hints--
+
+`myData` має дорівнювати `8`.
+
+```js
+assert(myData === 8);
+```
+
+Ви маєте використовувати квадратні дужки, щоб зчитати правильне значення з `myArray`.
+
+```js
+assert(/myData=myArray\[2\]\[1\]/.test(__helpers.removeWhiteSpace(code)));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+if(typeof myArray !== "undefined"){(function(){return "myData: " + myData + " myArray: " + JSON.stringify(myArray);})();}
+```
+
+## --seed-contents--
+
+```js
+const myArray = [
+  [1, 2, 3],
+  [4, 5, 6],
+  [7, 8, 9],
+  [[10, 11, 12], 13, 14],
+];
+
+const myData = myArray[0][0];
+```
+
+# --solutions--
+
+```js
+const myArray = [[1, 2, 3], [4, 5, 6], [7, 8, 9], [[10, 11, 12], 13, 14]];
+const myData = myArray[2][1];
+```
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/accessing-nested-arrays.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/accessing-nested-arrays.md
@@ -0,0 +1,121 @@
+---
+id: 56533eb9ac21ba0edf2244cd
+title: Доступ до вкладених масивів
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cLeGDtZ'
+forumTopicId: 16160
+dashedName: accessing-nested-arrays
+---
+
+# --description--
+
+Як ми бачили в попередніх прикладах, об'єкти можуть містити і вкладені об'єкти, і вкладені масиви. Подібно до доступу до вкладених об'єктів, запис набору масивів може бути сформований для доступу до вкладених масив.
+
+Ось приклад того, як отримати доступ до вкладеного масиву:
+
+```js
+const ourPets = [
+  {
+    animalType: "cat",
+    names: [
+      "Meowzer",
+      "Fluffy",
+      "Kit-Cat"
+    ]
+  },
+  {
+    animalType: "dog",
+    names: [
+      "Spot",
+      "Bowser",
+      "Frankie"
+    ]
+  }
+];
+
+ourPets[0].names[1];
+ourPets[1].names[0];
+```
+
+`ourPets[0].names[1]` буде рядком `Fluffy`, і `ourPets[1].names[0]` буде рядком `Spot`.
+
+# --instructions--
+
+Використовуючи точкову і дужкову нотацію, встановіть змінну `secondTree` на другий елемент в списку `trees` з об'єкта `myPlants`.
+
+# --hints--
+
+`secondTree` повинно дорівнювати рядку `pine`.
+
+```js
+assert(secondTree === 'pine');
+```
+
+У вашому коді повинні бути точкова і дужкова нотація, щоб отримати доступ до `myPlants`.
+
+```js
+assert(/=\s*myPlants\[1\].list\[1\]/.test(code));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(x) {
+  if(typeof x != 'undefined') {
+    return "secondTree = " + x;
+  }
+  return "secondTree is undefined";
+})(secondTree);
+```
+
+## --seed-contents--
+
+```js
+const myPlants = [
+  {
+    type: "flowers",
+    list: [
+      "rose",
+      "tulip",
+      "dandelion"
+    ]
+  },
+  {
+    type: "trees",
+    list: [
+      "fir",
+      "pine",
+      "birch"
+    ]
+  }
+];
+
+const secondTree = "";
+```
+
+# --solutions--
+
+```js
+const myPlants = [
+  {
+    type: "flowers",
+    list: [
+      "rose",
+      "tulip",
+      "dandelion"
+    ]
+  },
+  {
+    type: "trees",
+    list: [
+      "fir",
+      "pine",
+      "birch"
+    ]
+  }
+];
+
+const secondTree = myPlants[1].list[1];
+```
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/accessing-nested-objects.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/accessing-nested-objects.md
@@ -0,0 +1,100 @@
+---
+id: 56533eb9ac21ba0edf2244cc
+title: Доступ до вкладених об'єктів
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cRnRnfa'
+forumTopicId: 16161
+dashedName: accessing-nested-objects
+---
+
+# --description--
+
+Доступ до субвластивостей об'єктів можна отримати використавши крапкову або дужкову нотацію.
+
+Ось вкладений об'єкт:
+
+```js
+const ourStorage = {
+  "desk": {
+    "drawer": "stapler"
+  },
+  "cabinet": {
+    "top drawer": { 
+      "folder1": "a file",
+      "folder2": "secrets"
+    },
+    "bottom drawer": "soda"
+  }
+};
+
+ourStorage.cabinet["top drawer"].folder2;
+ourStorage.desk.drawer;
+```
+
+`ourStorage.cabinet["top drawer"].folder2` зміниться на `secrets`, і `ourStorage.desk.drawer` зміниться на `stapler`.
+
+# --instructions--
+
+Отримайте доступ до `myStorage` та визначте вміст скрині `glove box` для змінної `gloveBoxContents`. Використовуйте точкову нотацію для всіх властивостей, де це можливо, в іншому випадку використовуйте дужки.
+
+# --hints--
+
+`gloveBoxContents` має дорівнювати рядку `maps`.
+
+```js
+assert(gloveBoxContents === 'maps');
+```
+
+Використовуйте крапкову або дужкову нотацію в коді, щоб отримати доступ до `myStorage`.
+
+```js
+assert(/=\s*myStorage\.car\.inside\[\s*("|')glove box\1\s*\]/g.test(code));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(x) { 
+  if(typeof x != 'undefined') { 
+    return "gloveBoxContents = " + x;
+  }
+  return "gloveBoxContents is undefined";
+})(gloveBoxContents);
+```
+
+## --seed-contents--
+
+```js
+const myStorage = {
+  "car": {
+    "inside": {
+      "glove box": "maps",
+      "passenger seat": "crumbs"
+     },
+    "outside": {
+      "trunk": "jack"
+    }
+  }
+};
+
+const gloveBoxContents = undefined;
+```
+
+# --solutions--
+
+```js
+const myStorage = {
+  "car":{
+    "inside":{
+      "glove box":"maps",
+      "passenger seat":"crumbs"
+    },
+    "outside":{
+      "trunk":"jack"
+    }
+  }
+};
+const gloveBoxContents = myStorage.car.inside["glove box"];
+```
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/accessing-object-properties-with-bracket-notation.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/accessing-object-properties-with-bracket-notation.md
@@ -0,0 +1,103 @@
+---
+id: 56533eb9ac21ba0edf2244c8
+title: Доступ до властивостей об'єкту за допомогою дужкової нотації
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cBvmEHP'
+forumTopicId: 16163
+dashedName: accessing-object-properties-with-bracket-notation
+---
+
+# --description--
+
+Наступний спосіб отримати доступ до властивостей об'єкта - це використати дужкову нотацію (`[]`). Якщо характеристика об'єкта, до якого ви намагаєтеся отримати доступ, має пропуск у назві, потрібно використовувати квадратні дужки.
+
+Однак, ви також можете використовувати дужкову нотацію для характеристик об'єкта без пропусків.
+
+Нижче наведено приклад використання дужкової нотації для прочитання характеристик об'єкта:
+
+```js
+const myObj = {
+  "Space Name": "Kirk",
+  "More Space": "Spock",
+  "NoSpace": "USS Enterprise"
+};
+
+myObj["Space Name"];
+myObj['More Space'];
+myObj["NoSpace"];
+```
+
+`myObj["Space Name"]` зміниться на `Kirk`, `myObj['More Space']` зміниться на`Spock`, і `myObj["NoSpace"]` зміниться на `USS Enterprise`.
+
+Зауважте, що значення імен з пробілами, повинні бути в лапках (одинарних або подвійних).
+
+# --instructions--
+
+Прочитайте значення властивостей `an entree` і `the drink` в `testObj` використовуючи запис у квадратних дужках, та зазначте їх як `entreeValue` і `drinkValue` відповідно.
+
+# --hints--
+
+`entreeValue` має бути рядком
+
+```js
+assert(typeof entreeValue === 'string');
+```
+
+Значення `entreeValue` має бути рядком `hamburger`
+
+```js
+assert(entreeValue === 'hamburger');
+```
+
+`drinkValue` має бути рядком
+
+```js
+assert(typeof drinkValue === 'string');
+```
+
+Значення `drinkValue` має бути рядком `water`
+
+```js
+assert(drinkValue === 'water');
+```
+
+Потрібно використовувати квадратні дужки двічі
+
+```js
+assert(code.match(/testObj\s*?\[('|")[^'"]+\1\]/g).length > 1);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(a,b) { return "entreeValue = '" + a + "', drinkValue = '" + b + "'"; })(entreeValue,drinkValue);
+```
+
+## --seed-contents--
+
+```js
+// Setup
+const testObj = {
+  "an entree": "hamburger",
+  "my side": "veggies",
+  "the drink": "water"
+};
+
+// Only change code below this line
+const entreeValue = testObj;   // Change this line
+const drinkValue = testObj;    // Change this line
+```
+
+# --solutions--
+
+```js
+const testObj = {
+  "an entree": "hamburger",
+  "my side": "veggies",
+  "the drink": "water"
+};
+const entreeValue = testObj["an entree"];
+const drinkValue = testObj['the drink'];
+```
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/accessing-object-properties-with-dot-notation.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/accessing-object-properties-with-dot-notation.md
@@ -0,0 +1,100 @@
+---
+id: 56533eb9ac21ba0edf2244c7
+title: Доступ до властивостей об'єкту за допомогою крапкових знаків
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cGryJs8'
+forumTopicId: 16164
+dashedName: accessing-object-properties-with-dot-notation
+---
+
+# --description--
+
+Є два способи доступу до властивостей об'єкту: крапковий запис (`.`) та запис за допомогою квадратних дужок (`[]`), подібні до масиву.
+
+Крапковий запис, це те, що ви використовуєте, коли ви знаєте назву властивості, до якої намагаєтеся отримати доступ.
+
+Нижче наведено приклад крапкового запису (`.`) для прочитання властивостей об'єкта:
+
+```js
+const myObj = {
+  prop1: "val1",
+  prop2: "val2"
+};
+
+const prop1val = myObj.prop1;
+const prop2val = myObj.prop2;
+```
+
+`prop1val` матиме значення рядка `val1`, і `prop2val` матиме значення рядка `val2`.
+
+# --instructions--
+
+Прочитайте значення властивостей `testObj`, використовуючи крапковий запис. Встановіть змінну `hatValue` рівну властивостям об'єкта `hat` і встановіть змінну `shirtValue` рівну властивостям об'єкта `shirt`.
+
+# --hints--
+
+`hatValue` має бути рядком
+
+```js
+assert(typeof hatValue === 'string');
+```
+
+Значення `hatValue` має бути рядком `ballcap`
+
+```js
+assert(hatValue === 'ballcap');
+```
+
+`shirtValue` має бути рядком
+
+```js
+assert(typeof shirtValue === 'string');
+```
+
+Значення `shirtValue` має бути рядком `jersey`
+
+```js
+assert(shirtValue === 'jersey');
+```
+
+Використовувати крапковий запис потрібно двічі
+
+```js
+assert(code.match(/testObj\.\w+/g).length > 1);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(a,b) { return "hatValue = '" + a + "', shirtValue = '" + b + "'"; })(hatValue,shirtValue);
+```
+
+## --seed-contents--
+
+```js
+// Setup
+const testObj = {
+  "hat": "ballcap",
+  "shirt": "jersey",
+  "shoes": "cleats"
+};
+
+// Only change code below this line
+const hatValue = testObj;      // Change this line
+const shirtValue = testObj;    // Change this line
+```
+
+# --solutions--
+
+```js
+const testObj = {
+  "hat": "ballcap",
+  "shirt": "jersey",
+  "shoes": "cleats"
+};
+
+const hatValue = testObj.hat;
+const shirtValue = testObj.shirt;
+```
--- 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
@@ -0,0 +1,125 @@
+---
+id: 56533eb9ac21ba0edf2244c9
+title: Доступ до властивостей об'єкту за допомогою змінних
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cnQyKur'
+forumTopicId: 16165
+dashedName: accessing-object-properties-with-variables
+---
+
+# --description--
+
+Ще одне використання дужкової нотації на об'єктах полягає в доступі до властивостей, які зберігаються у вигляді змінної величини. Це може бути дуже корисним для ітерації властивостей об'єкта або при отриманні доступу до пошукової таблиці.
+
+Ось приклад використання змінної для отримання доступу до властивостей:
+
+```js
+const dogs = {
+  Fido: "Mutt",
+  Hunter: "Doberman",
+  Snoopie: "Beagle"
+};
+
+const myDog = "Hunter";
+const myBreed = dogs[myDog];
+console.log(myBreed);
+```
+
+У консолі відображатиметься рядок `Doberman`.
+
+Інший спосіб, у який можна використовувати цей метод, - коли назви властивостей активно накопичуються протягом роботи у програмі, як показано далі:
+
+```js
+const someObj = {
+  propName: "John"
+};
+
+function propPrefix(str) {
+  const s = "prop";
+  return s + str;
+}
+
+const someProp = propPrefix("Name");
+console.log(someObj[someProp]);
+```
+
+`someProp` матиме значення рядка `propName`, і рядок `John` відображатиметься в консолі.
+
+Зверніть увагу, що ми *не* використовуємо лапки із змінними назвами, коли нам потрібен доступ до властивостей, тому що ми використовуємо *значення* змінної, а не її *назву*.
+
+# --instructions--
+
+Вкажіть, що `playerNumber` може змінюватися до `16`. Потім використовуйте змінну для пошуку імені гравця та закріпіть її за `player`.
+
+# --hints--
+
+`playerNumber` має бути числом
+
+```js
+assert(typeof playerNumber === 'number');
+```
+
+Змінна `player` повинна бути рядком
+
+```js
+assert(typeof player === 'string');
+```
+
+Значення `player` повинне бути рядком `Montana`
+
+```js
+assert(player === 'Montana');
+```
+
+Використовуйте дужкову нотацію, щоб отримати доступ до `testObj`
+
+```js
+assert(/testObj\s*?\[.*?\]/.test(code));
+```
+
+Значення `Montana` не можна закріплювати безпосередньо за змінною `player`.
+
+```js
+assert(!code.match(/player\s*=\s*"|\'\s*Montana\s*"|\'\s*;/gi));
+```
+
+Слід використовувати змінну `playerNumber` у квадратних дужках
+
+```js
+assert(/testObj\s*?\[\s*playerNumber\s*\]/.test(code));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+if(typeof player !== "undefined"){(function(v){return v;})(player);}
+```
+
+## --seed-contents--
+
+```js
+// Setup
+const testObj = {
+  12: "Namath",
+  16: "Montana",
+  19: "Unitas"
+};
+
+// Only change code below this line
+const playerNumber = 42;  // Change this line
+const player = testObj;   // Change this line
+```
+
+# --solutions--
+
+```js
+const testObj = {
+  12: "Namath",
+  16: "Montana",
+  19: "Unitas"
+};
+const playerNumber = 16;
+const player = testObj[playerNumber];
+```
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/add-new-properties-to-a-javascript-object.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/add-new-properties-to-a-javascript-object.md
@@ -0,0 +1,90 @@
+---
+id: 56bbb991ad1ed5201cd392d2
+title: Додати нові властивості об'єкту JavaScript
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cQe38UD'
+forumTopicId: 301169
+dashedName: add-new-properties-to-a-javascript-object
+---
+
+# --description--
+
+Ви можете додати нові властивості вже наявним об'єктам JavaScript, таким чином модифікуючи їх.
+
+Нижче подано як додавати властивість `bark` до `ourDog`:
+
+```js
+ourDog.bark = "bow-wow";
+```
+
+або
+
+```js
+ourDog["bark"] = "bow-wow";
+```
+
+Тепер, коли оцінимо `ourDog.bark`, отримаємо його гавкання, `bow-wow`.
+
+Наприклад:
+
+```js
+const ourDog = {
+  "name": "Camper",
+  "legs": 4,
+  "tails": 1,
+  "friends": ["everything!"]
+};
+
+ourDog.bark = "bow-wow";
+```
+
+# --instructions--
+
+Додайте властивість `bark` до `myDog` і встановіть його на звук собаки, наприклад "гав". Ви можете використовувати крапковий запис або запис квадратними дужками.
+
+# --hints--
+
+Вам потрібно додати властивість `bark` до `myDog`.
+
+```js
+assert(myDog.bark !== undefined);
+```
+
+Не слід додавати `bark` до ініціалізації `myDog`.
+
+```js
+assert(!/bark[^\n]:/.test(code));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(z){return z;})(myDog);
+```
+
+## --seed-contents--
+
+```js
+const myDog = {
+  "name": "Happy Coder",
+  "legs": 4,
+  "tails": 1,
+  "friends": ["freeCodeCamp Campers"]
+};
+
+
+```
+
+# --solutions--
+
+```js
+const myDog = {
+  "name": "Happy Coder",
+  "legs": 4,
+  "tails": 1,
+  "friends": ["freeCodeCamp Campers"]
+};
+myDog.bark = "Woof Woof";
+```
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/add-two-numbers-with-javascript.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/add-two-numbers-with-javascript.md
@@ -0,0 +1,62 @@
+---
+id: cf1111c1c11feddfaeb3bdef
+title: Додайте два числа з JavaScript
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cM2KBAG'
+forumTopicId: 16650
+dashedName: add-two-numbers-with-javascript
+---
+
+# --description--
+
+`Number` - це такий тип в JavaScript, який передає числові дані.
+
+Тепер спробуємо додати два числа за допомогою JavaScript.
+
+JavaScript використовує символ `+` в ролі оператора додавання, і розміщується між двома числами.
+
+**Наприклад:**
+
+```js
+const myVar = 5 + 10;
+```
+
+`myVar` тепер матиме значення `15`.
+
+# --instructions--
+
+Змініть `0` так, щоб сума дорівнювала `20`.
+
+# --hints--
+
+`sum` повинен дорівнювати `20`.
+
+```js
+assert(sum === 20);
+```
+
+Вам слід використовувати оператор `+`.
+
+```js
+assert(/\+/.test(code));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(z){return 'sum = '+z;})(sum);
+```
+
+## --seed-contents--
+
+```js
+const sum = 10 + 0;
+```
+
+# --solutions--
+
+```js
+const sum = 10 + 10;
+```
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/adding-a-default-option-in-switch-statements.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/adding-a-default-option-in-switch-statements.md
@@ -0,0 +1,128 @@
+---
+id: 56533eb9ac21ba0edf2244de
+title: Додавання опції за замовчуванням до команди Switch
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/c3JvVfg'
+forumTopicId: 16653
+dashedName: adding-a-default-option-in-switch-statements
+---
+
+# --description--
+
+В команді `switch` ви не матимете можливості вказати усі можливі значення, наприклад, як команда `case`. Натомість, ви можете додати команду `default`, яка включатиметься, якщо не знайдено відповідних перемикачів `case`. Вважайте це фінальною командою `else` у ланцюжку `if/else`.
+
+`default` перемикач повинен бути останнім.
+
+```js
+switch (num) {
+  case value1:
+    statement1;
+    break;
+  case value2:
+    statement2;
+    break;
+...
+  default:
+    defaultStatement;
+    break;
+}
+```
+
+# --instructions--
+
+Напишіть команду switch, щоб встановити `answer` за наступних умов:  
+`a` - `apple`  
+`b` - `bird`  
+`c` - `cat`  
+`default` - `stuff`
+
+# --hints--
+
+`switchOfStuff("a")` повинен перетворитися на рядок `apple`
+
+```js
+assert(switchOfStuff('a') === 'apple');
+```
+
+`switchOfStuff("b")` повинен перетворитися на рядок`bird`
+
+```js
+assert(switchOfStuff('b') === 'bird');
+```
+
+`switchOfStuff("c")` повинен перетворитися на рядок `cat`
+
+```js
+assert(switchOfStuff('c') === 'cat');
+```
+
+`switchOfStuff("d")` повинен перетворитися на рядок `stuff`
+
+```js
+assert(switchOfStuff('d') === 'stuff');
+```
+
+`switchOfStuff(4)` повинен перетворитися на рядок `stuff`
+
+```js
+assert(switchOfStuff(4) === 'stuff');
+```
+
+Ви не повинні використовувати `if` чи `else` команди
+
+```js
+assert(!/else/g.test(code) || !/if/g.test(code));
+```
+
+Вам слід користуватись командою`default`
+
+```js
+assert(switchOfStuff('string-to-trigger-default-case') === 'stuff');
+```
+
+Потрібно мати щонайменше 3 команди `break`
+
+```js
+assert(code.match(/break/g).length > 2);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function switchOfStuff(val) {
+  let answer = "";
+  // Only change code below this line
+
+
+
+  // Only change code above this line
+  return answer;
+}
+
+switchOfStuff(1);
+```
+
+# --solutions--
+
+```js
+function switchOfStuff(val) {
+  let answer = "";
+
+  switch(val) {
+    case "a":
+      answer = "apple";
+      break;
+    case "b":
+      answer = "bird";
+      break;
+    case "c":
+      answer = "cat";
+      break;
+    default:
+      answer = "stuff";
+  }
+  return answer;
+}
+```
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/appending-variables-to-strings.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/appending-variables-to-strings.md
@@ -0,0 +1,77 @@
+---
+id: 56533eb9ac21ba0edf2244ed
+title: Додавання змінних до рядків
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cbQmZfa'
+forumTopicId: 16656
+dashedName: appending-variables-to-strings
+---
+
+# --description--
+
+Так само, як ми можемо створити рядок з декількох рядків за допомогою <dfn>literals</dfn>, ми також можемо додати змінні до рядка, використовуючи знаки "плюс" та "дорівнює" (`+=`).
+
+Наприклад:
+
+```js
+const anAdjective = "awesome!";
+let ourStr = "freeCodeCamp is ";
+ourStr += anAdjective;
+```
+
+`ourStr` матиме значення `freeCodeCamp is awesome!`.
+
+# --instructions--
+
+Встановіть `someAdjective` у рядку із щонайменше 3 символів і додайте його до `myStr`, використовуючи знаки `+=`.
+
+# --hints--
+
+`someAdjective` повинен бути встановлений у рядку, який складається із не менше, ніж 3 символів.
+
+```js
+assert(typeof someAdjective !== 'undefined' && someAdjective.length > 2);
+```
+
+Вам потрібно додати `someAdjective` до `myStr`, використовуючи знаки `+=`.
+
+```js
+assert(code.match(/myStr\s*\+=\s*someAdjective\s*/).length > 0);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(){
+  var output = [];
+  if(typeof someAdjective === 'string') {
+    output.push('someAdjective = "' + someAdjective + '"');
+  } else {
+    output.push('someAdjective is not a string');
+  }
+  if(typeof myStr === 'string') {
+    output.push('myStr = "' + myStr + '"');
+  } else {
+    output.push('myStr is not a string');
+  }
+  return output.join('\n');
+})();
+```
+
+## --seed-contents--
+
+```js
+// Change code below this line
+const someAdjective = "";
+let myStr = "Learning to code is ";
+```
+
+# --solutions--
+
+```js
+const someAdjective = "neat";
+let myStr = "Learning to code is ";
+myStr += someAdjective;
+```
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/assigning-the-value-of-one-variable-to-another.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/assigning-the-value-of-one-variable-to-another.md
@@ -0,0 +1,86 @@
+---
+id: 5ee127a03c3b35dd45426493
+title: Присвоєння значення однієї змінної іншій
+challengeType: 1
+videoUrl: ''
+forumTopicId: 418265
+dashedName: assigning-the-value-of-one-variable-to-another
+---
+
+# --description--
+
+Після присвоєння значення змінної за допомогою оператора <dfn>assignment</dfn>, Ви можете присвоїти значення цієї змінної іншій змінній, використовуючи оператор <dfn>assignment</dfn>.
+
+```js
+var myVar;
+myVar = 5;
+var myNum;
+myNum = myVar;
+```
+
+Наведений вище приклад показує, що `myVar` - змінна без значення, а потім присвоює їй значення `5`. Далі можна побачити, що змінна з назвою `myNum`, - теж без значення. Потім, вміст `myVar` (який дорівнює `5`) присвоюється змінній `myNum`. І, ось, `myNum` тепер також має значення `5`.
+
+# --instructions--
+
+Призначте значення `a` змінній `b`.
+
+# --hints--
+
+Не слід змінювати код над зазначеним коментарем.
+
+```js
+assert(/var a;/.test(code) && /a = 7;/.test(code) && /var b;/.test(code));
+```
+
+`b` повинне мати значення `7`.
+
+```js
+assert(typeof b === 'number' && b === 7);
+```
+
+`a` потрібно призначити `b` за допомогою `=`.
+
+```js
+assert(/b\s*=\s*a\s*/g.test(code));
+```
+
+# --seed--
+
+## --before-user-code--
+
+```js
+if (typeof a != 'undefined') {
+  a = undefined;
+}
+if (typeof b != 'undefined') {
+  b = undefined;
+}
+```
+
+## --after-user-code--
+
+```js
+(function(a, b) {
+  return 'a = ' + a + ', b = ' + b;
+})(a, b);
+```
+
+## --seed-contents--
+
+```js
+// Setup
+var a;
+a = 7;
+var b;
+
+// Only change code below this line
+```
+
+# --solutions--
+
+```js
+var a;
+a = 7;
+var b;
+b = a;
+```
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/assignment-with-a-returned-value.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/assignment-with-a-returned-value.md
@@ -0,0 +1,72 @@
+---
+id: 56533eb9ac21ba0edf2244c3
+title: Призначення з поверненим значенням
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/ce2pEtB'
+forumTopicId: 16658
+dashedName: assignment-with-a-returned-value
+---
+
+# --description--
+
+Якщо Ви пригадаєте з нашого обговорення [Storing Values with the Assignment Operator](/learn/javascript-algorithms-and-data-structures/basic-javascript/storing-values-with-the-assignment-operator), все, що знаходиться справа від знака рівності визначається ще до того, як присвоюється значення. Це означає, що ми можемо взяти повернене значення функції та присвоїти її змінній.
+
+Припустимо, у нас уже є визначена функція `sum`, яка додає два числа, тоді:
+
+```js
+ourSum = sum(5, 12);
+```
+
+вона називатиметься функцією `sum`, яка повертає значення `17` і призначає її змінній `ourSum`.
+
+# --instructions--
+
+Назвіть функцію `processArg` з аргументом `7` і присвойте її повернене значення змінній `processed`.
+
+# --hints--
+
+`processed` повинне мати значення `2`
+
+```js
+assert(processed === 2);
+```
+
+`processArg` потрібно призначити `processed`
+
+```js
+assert(/processed\s*=\s*processArg\(\s*7\s*\)/.test(code));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(){return "processed = " + processed})();
+```
+
+## --seed-contents--
+
+```js
+// Setup
+let processed = 0;
+
+function processArg(num) {
+  return (num + 3) / 5;
+}
+
+// Only change code below this line
+
+```
+
+# --solutions--
+
+```js
+var processed = 0;
+
+function processArg(num) {
+  return (num + 3) / 5;
+}
+
+processed = processArg(7);
+```
--- 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
@@ -0,0 +1,159 @@
+---
+id: 56bbb991ad1ed5201cd392d0
+title: Створення об'єктів JavaScript
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cWGkbtd'
+forumTopicId: 16769
+dashedName: build-javascript-objects
+---
+
+# --description--
+
+Ви могли чути термін `object` раніше.
+
+Об'єкти подібні до `arrays`, за винятком того, що для отримання доступу та зміни їхніх даних використовуються не індекси, а `properties`.
+
+Об'єкти придатні для структурованого зберігання даних, і також можуть представляти об'єкти реального світу, такі як кіт, наприклад.
+
+Зразок об'єкта кота:
+
+```js
+const cat = {
+  "name": "Whiskers",
+  "legs": 4,
+  "tails": 1,
+  "enemies": ["Water", "Dogs"]
+};
+```
+
+У цьому прикладі всі властивості зберігаються у вигляді рядків, таких як `name`, `legs` і `tails`. Однак, ви також можете використовувати числа як характеристики. Лапки для характеристик, які складаються з одного слова, можна пропустити наступним чином:
+
+```js
+const anotherObject = {
+  make: "Ford",
+  5: "five",
+  "model": "focus"
+};
+```
+
+Якщо ваші об'єкти містять будь-які не рядкові характеристики, JavaScript автоматично надрукує їх як рядки.
+
+# --instructions--
+
+Створіть об'єкт під назвою `myDog`, який має такі характеристики: `name` (a string), `legs`, `tails` and `friends`.
+
+Ви можете надати характеристикам цих об'єктів будь-які значення, доки `name` - це рядок, `legs` and `tails` - числа, і `friends` - масив.
+
+# --hints--
+
+`myDog` має містити характеристику `name` і бути `string`.
+
+```js
+assert(
+  (function (z) {
+    if (
+      z.hasOwnProperty('name') &&
+      z.name !== undefined &&
+      typeof z.name === 'string'
+    ) {
+      return true;
+    } else {
+      return false;
+    }
+  })(myDog)
+);
+```
+
+`myDog` має містити характеристику `legs` і бути `number`.
+
+```js
+assert(
+  (function (z) {
+    if (
+      z.hasOwnProperty('legs') &&
+      z.legs !== undefined &&
+      typeof z.legs === 'number'
+    ) {
+      return true;
+    } else {
+      return false;
+    }
+  })(myDog)
+);
+```
+
+`myDog` має містити характеристику `tails` і бути `number`.
+
+```js
+assert(
+  (function (z) {
+    if (
+      z.hasOwnProperty('tails') &&
+      z.tails !== undefined &&
+      typeof z.tails === 'number'
+    ) {
+      return true;
+    } else {
+      return false;
+    }
+  })(myDog)
+);
+```
+
+`myDog` має містити характеристику `friends` і бути `array`.
+
+```js
+assert(
+  (function (z) {
+    if (
+      z.hasOwnProperty('friends') &&
+      z.friends !== undefined &&
+      Array.isArray(z.friends)
+    ) {
+      return true;
+    } else {
+      return false;
+    }
+  })(myDog)
+);
+```
+
+`myDog` має містити всі задані характеристики.
+
+```js
+assert(
+  (function (z) {
+    return Object.keys(z).length === 4;
+  })(myDog)
+);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(z){return z;})(myDog);
+```
+
+## --seed-contents--
+
+```js
+const myDog = {
+  // Only change code below this line
+
+
+  // Only change code above this line
+};
+```
+
+# --solutions--
+
+```js
+const myDog = {
+  "name": "Camper",
+  "legs": 4,
+  "tails": 1,
+  "friends": ["everything!"]
+};
+```
--- 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
@@ -0,0 +1,149 @@
+---
+id: 56533eb9ac21ba0edf2244dc
+title: Створення ланцюгу If Else (Що-Якщо)
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/caeJgsw'
+forumTopicId: 16772
+dashedName: chaining-if-else-statements
+---
+
+# --description--
+
+`if/else` може бути об'єднаним у разі складних алгоритмів. Ось <dfn>pseudocode</dfn> декількох ланцюжків `if` / `else if` тверджень:
+
+```js
+if (condition1) {
+  statement1
+} else if (condition2) {
+  statement2
+} else if (condition3) {
+  statement3
+. . .
+} else {
+  statementN
+}
+```
+
+# --instructions--
+
+Запишіть ланцюжок `if`/`else if` для того, щоб виконати наступні умови:
+
+`num < 5` дає `Tiny`  
+`num < 10` дає `Small`  
+`num < 15` дає `Medium`  
+`num < 20` дає `Large`  
+`num >= 20` дає `Huge`
+
+# --hints--
+
+Потрібно мати щонайменше 4 команди `else`
+
+```js
+assert(code.match(/else/g).length > 3);
+```
+
+Потрібно мати щонайменше 4 команди `if`
+
+```js
+assert(code.match(/if/g).length > 3);
+```
+
+Потрібно мати щонайменше 1 команду `return`
+
+```js
+assert(code.match(/return/g).length >= 1);
+```
+
+`testSize(0)` має повертати рядок `Tiny`
+
+```js
+assert(testSize(0) === 'Tiny');
+```
+
+`testSize(4)` має повертати рядок `Tiny`
+
+```js
+assert(testSize(4) === 'Tiny');
+```
+
+`testSize(5)` має повертати рядок `Small`
+
+```js
+assert(testSize(5) === 'Small');
+```
+
+`testSize(8)` має повертати рядок `Small`
+
+```js
+assert(testSize(8) === 'Small');
+```
+
+`testSize(10)` має повертати рядок `Medium`
+
+```js
+assert(testSize(10) === 'Medium');
+```
+
+`testSize(14)` має повертати рядок `Medium`
+
+```js
+assert(testSize(14) === 'Medium');
+```
+
+`testSize(15)` має повертати рядок `Large`
+
+```js
+assert(testSize(15) === 'Large');
+```
+
+`testSize(17)` має повертати рядок `Large`
+
+```js
+assert(testSize(17) === 'Large');
+```
+
+`testSize(20)` має повертати рядок `Huge`
+
+```js
+assert(testSize(20) === 'Huge');
+```
+
+`testSize(25)` має повертати рядок `Huge`
+
+```js
+assert(testSize(25) === 'Huge');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function testSize(num) {
+  // Only change code below this line
+
+
+  return "Change Me";
+  // Only change code above this line
+}
+
+testSize(7);
+```
+
+# --solutions--
+
+```js
+function testSize(num) {
+  if (num < 5) {
+    return "Tiny";
+  } else if (num < 10) {
+    return "Small";
+  } else if (num < 15) {
+    return "Medium";
+  } else if (num < 20) {
+    return "Large";
+  } else {
+    return "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
@@ -0,0 +1,63 @@
+---
+id: bd7123c9c441eddfaeb4bdef
+title: Поясніть ваш JavaScript код
+challengeType: 1
+removeComments: false
+videoUrl: 'https://scrimba.com/c/c7ynnTp'
+forumTopicId: 16783
+dashedName: comment-your-javascript-code
+---
+
+# --description--
+
+Пояснення - це рядки коду, які JavaScript буде навмисно ігнорувати. Коментарі - це чудовий спосіб залишити нотатки для себе та інших людей, які згодом мають дізнатися, що робить цей код.
+
+Є два шляхи написати пояснення у JavaScript:
+
+Використання `//` дозволить JavaScript ігнорувати решту тексту в поточному рядку. Це коментар всередині рядка:
+
+```js
+// This is an in-line comment.
+```
+
+Ви можете зробити багаторядковий коментар починаючи з `/*` і закінчуватися `*/`. Це багаторядковий коментар:
+
+```js
+/* This is a
+multi-line comment */
+```
+
+**ПРИМІТКА:**, написавши код, вам слід постійно додавати коментарі, щоб уточнити функцію частин вашого коду. Хороші і якісні коментарі допоможуть допомогти розібратись в значенні вашого коду - як для іншим людям, так і *and* для вас у майбутньому.
+
+# --instructions--
+
+Спробуйте створити один коментар кожного типу.
+
+# --hints--
+
+Ви повинні створити стиль `//`, що містить щонайменше п'ять літер.
+
+```js
+assert(code.match(/(\/\/)...../g));
+```
+
+Ви повинні створити коментар стилю `/* */`, що містить щонайменше п'ять літер.
+
+```js
+assert(code.match(/(\/\*)([^\/]{5,})(?=\*\/)/gm));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+
+```
+
+# --solutions--
+
+```js
+// Fake Comment
+/* Another Comment */
+```
--- 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
@@ -0,0 +1,91 @@
+---
+id: 56533eb9ac21ba0edf2244d0
+title: Порівняння з Оператором Рівності
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cKyVMAL'
+forumTopicId: 16784
+dashedName: comparison-with-the-equality-operator
+---
+
+# --description--
+
+У JavaScript є багато <dfn>операторів порівняння</dfn>. Всі ці оператори присвоюють логічне `true` або `false` значення.
+
+Основним є оператор рівності `==`. Оператор рівності порівнює два значення і видає `true`, якщо вони еквівалентні, або `false`, якщо ні. Зверніть увагу, що рівність відрізняється від присвоєння (`=`), яке закріплює за змінною ліворуч значення праворуч від оператора.
+
+```js
+function equalityTest(myVal) {
+  if (myVal == 10) {
+    return "Equal";
+  }
+  return "Not Equal";
+}
+```
+
+Якщо `myVal` рівнозначний `10`, оператор рівності видає `true`, тож код у фігурних дужках виконається, і функція буде `Equal`. В іншому випадку, функція буде `Not Equal`. Для того, щоб JavaScript порівняв два різні <dfn>типи даних</dfn> (наприклад, `numbers` і `strings`), потрібно конвертувати один тип в інший. Це називається Перетворення Типів. Однак, після його виконання поняття порівнюються наступним чином:
+
+```js
+1   ==  1
+1   ==  2
+1   == '1'
+"3" ==  3
+```
+
+У такому ж порядку, як вони є, ці вирази будуть оцінені, як `true`, `false`, `true`, і `true`.
+
+# --instructions--
+
+Додайте оператор рівності до зазначеного рядка, щоб функція визначила рядок, як `Equal`, коли `val` еквівалентна `12`.
+
+# --hints--
+
+`testEqual(10)` повинен повернути рядок `Not Equal`
+
+```js
+assert(testEqual(10) === 'Not Equal');
+```
+
+`testEqual(12)` повинен повернути рядок `Equal`
+
+```js
+assert(testEqual(12) === 'Equal');
+```
+
+`testEqual("12")` повинен повернути рядок `Equal`
+
+```js
+assert(testEqual('12') === 'Equal');
+```
+
+Слід використовувати оператор `==`
+
+```js
+assert(code.match(/==/g) && !code.match(/===/g));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+// Setup
+function testEqual(val) {
+  if (val) { // Change this line
+    return "Equal";
+  }
+  return "Not Equal";
+}
+
+testEqual(10);
+```
+
+# --solutions--
+
+```js
+function testEqual(val) {
+  if (val == 12) {
+    return "Equal";
+  }
+  return "Not Equal";
+}
+```
--- 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
@@ -0,0 +1,113 @@
+---
+id: 56533eb9ac21ba0edf2244d4
+title: Порівняння з оператором «більше ніж»
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cp6GbH4'
+forumTopicId: 16786
+dashedName: comparison-with-the-greater-than-operator
+---
+
+# --description--
+
+Оператор «більше ніж» (`>`) порівнює значення двох чисел. Якщо число зліва більше за число справа, то воно повертається `true`. В іншому випадку видається результат `false`.
+
+Як і оператор «рівність», «більше ніж» перетворюватиме типи даних під час порівняння.
+
+**Приклади**
+
+```js
+5   >  3
+7   > '3'
+2   >  3
+'1' >  9
+```
+
+По-порядку, ці вирази оцінюватимуться як `true`, `true`, `false`, та `false`.
+
+# --instructions--
+
+Додайте оператор «більше ніж» до вказаних рядків, щоб оператор повернення спрацював.
+
+# --hints--
+
+`GreaterThan(0)` має повернути рядок `10 або Under`
+
+```js
+assert(testGreaterThan(0) === '10 or Under');
+```
+
+`testGreaterThan(10)` має повернути рядок `10 or Under`
+
+```js
+assert(testGreaterThan(10) === '10 or Under');
+```
+
+`testGreaterThan(11)` має повернути рядок `Over 10`
+
+```js
+assert(testGreaterThan(11) === 'Over 10');
+```
+
+`testGreaterThan(99)` має повернути рядок `Over 10`
+
+```js
+assert(testGreaterThan(99) === 'Over 10');
+```
+
+`testGreaterThan(100)` має повернути рядок `Over 10`
+
+```js
+assert(testGreaterThan(100) === 'Over 10');
+```
+
+`testGreaterThan(101)` має повернути рядок `Over 100`
+
+```js
+assert(testGreaterThan(101) === 'Over 100');
+```
+
+`testGreaterThan(150)` має повернути рядок `Over 100`
+
+```js
+assert(testGreaterThan(150) === 'Over 100');
+```
+
+Ви повинні використати оператор `>` принаймні двічі
+
+```js
+assert(code.match(/val\s*>\s*('|")*\d+('|")*/g).length > 1);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function testGreaterThan(val) {
+  if (val) {  // Change this line
+    return "Over 100";
+  }
+
+  if (val) {  // Change this line
+    return "Over 10";
+  }
+
+  return "10 or Under";
+}
+
+testGreaterThan(10);
+```
+
+# --solutions--
+
+```js
+function testGreaterThan(val) {
+  if (val > 100) {  // Change this line
+    return "Over 100";
+  }
+  if (val > 10) {  // Change this line
+    return "Over 10";
+  }
+  return "10 or Under";
+}
+```
--- 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
@@ -0,0 +1,115 @@
+---
+id: 56533eb9ac21ba0edf2244d5
+title: Порівняння з оператором «Більше ніж дорівнює»
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/c6KBqtV'
+forumTopicId: 16785
+dashedName: comparison-with-the-greater-than-or-equal-to-operator
+---
+
+# --description--
+
+Оператор "більше ніж дорівнює" (`>=`) порівнює значення двох чисел. Якщо число зліва більше за число справа, тоді функція є `true`. В іншому випадку - вона `false`.
+
+Так само, як і оператор рівності, оператор "більше ніж дорівнює" конвертує типи даних під час їх порівняння.
+
+**Наприклад**
+
+```js
+6   >=  6
+7   >= '3'
+2   >=  3
+'7' >=  9
+```
+
+У такому ж порядку, як вони є, ці вирази будуть оцінені, як `true`, `true`, `false`, і `false`.
+
+# --instructions--
+
+Додайте оператор "більше ніж дорівнює" до зазначених рядків, щоб оператор повернення мав сенс.
+
+# --hints--
+
+`testGreaterOrEqual(0)` повинен повернути рядок `Less than 10`
+
+```js
+assert(testGreaterOrEqual(0) === 'Less than 10');
+```
+
+`testGreaterOrEqual(9)` повинен повернути рядок `Less than 10`
+
+```js
+assert(testGreaterOrEqual(9) === 'Less than 10');
+```
+
+`testGreaterOrEqual(10)` повинен повернути рядок `10 or Over`
+
+```js
+assert(testGreaterOrEqual(10) === '10 or Over');
+```
+
+`testGreaterOrEqual(11)` повинен повернути рядок `10 or Over`
+
+```js
+assert(testGreaterOrEqual(11) === '10 or Over');
+```
+
+`testGreaterOrEqual(19)` повинен повернути рядок `10 or Over`
+
+```js
+assert(testGreaterOrEqual(19) === '10 or Over');
+```
+
+`testGreaterOrEqual(100)` повинен повернути рядок `20 or Over`
+
+```js
+assert(testGreaterOrEqual(100) === '20 or Over');
+```
+
+`testGreaterOrEqual(21)` повинен повернути рядок `20 or Over`
+
+```js
+assert(testGreaterOrEqual(21) === '20 or Over');
+```
+
+Слід використовувати оператор `>=` принаймні двічі
+
+```js
+assert(code.match(/val\s*>=\s*('|")*\d+('|")*/g).length > 1);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function testGreaterOrEqual(val) {
+  if (val) {  // Change this line
+    return "20 or Over";
+  }
+
+  if (val) {  // Change this line
+    return "10 or Over";
+  }
+
+  return "Less than 10";
+}
+
+testGreaterOrEqual(10);
+```
+
+# --solutions--
+
+```js
+function testGreaterOrEqual(val) {
+  if (val >= 20) {  // Change this line
+    return "20 or Over";
+  }
+
+  if (val >= 10) {  // Change this line
+    return "10 or Over";
+  }
+
+  return "Less than 10";
+}
+```
--- 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
@@ -0,0 +1,93 @@
+---
+id: 56533eb9ac21ba0edf2244d2
+title: Порівняння з Оператором "Не дорівнює"
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cdBm9Sr'
+forumTopicId: 16787
+dashedName: comparison-with-the-inequality-operator
+---
+
+# --description--
+
+Оператор "не дорівнює" (`!=`) є протилежним до оператора рівності. Це означає, що вирази не еквівалентні і що вони повернуться `false`, де рівність повернеться `true` і *навпаки*. Так само, як і оператор рівності, оператор "не дорівнює" конвертує типи даних під час їх порівняння.
+
+**Наприклад**
+
+```js
+1 !=  2
+1 != "1"
+1 != '1'
+1 != true
+0 != false
+```
+
+У такому ж порядку, як вони є, ці вирази будуть оцінені, як `true`, `false`, `false`, `false` і `false`.
+
+# --instructions--
+
+Додайте оператора нерівності `!=` до команди `if`, щоб функція повернула рядок `Not Equal`, коли `val` не дорівнює `99`.
+
+# --hints--
+
+`testNotEqual(99)` має повернути рядок `Equal`
+
+```js
+assert(testNotEqual(99) === 'Equal');
+```
+
+`testNotEqual("99")` має повернути рядок `Equal`
+
+```js
+assert(testNotEqual('99') === 'Equal');
+```
+
+`testNotEqual(12)` має повернути рядок `Not Equal`
+
+```js
+assert(testNotEqual(12) === 'Not Equal');
+```
+
+`testNotEqual("12")` має повернути рядок `Not Equal`
+
+```js
+assert(testNotEqual('12') === 'Not Equal');
+```
+
+`testNotEqual("bob")` має повернути рядок `Not Equal`
+
+```js
+assert(testNotEqual('bob') === 'Not Equal');
+```
+
+Слід використовувати оператор `!=`
+
+```js
+assert(code.match(/(?!!==)!=/));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+// Setup
+function testNotEqual(val) {
+  if (val) { // Change this line
+    return "Not Equal";
+  }
+  return "Equal";
+}
+
+testNotEqual(10);
+```
+
+# --solutions--
+
+```js
+function testNotEqual(val) {
+  if (val != 99) {
+    return "Not Equal";
+  }
+  return "Equal";
+}
+```
--- 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
@@ -0,0 +1,108 @@
+---
+id: 56533eb9ac21ba0edf2244d6
+title: Порівняння з оператором "менше ніж"
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cNVRWtB'
+forumTopicId: 16789
+dashedName: comparison-with-the-less-than-operator
+---
+
+# --description--
+
+Оператор "менше ніж" (`<`) порівнює значення двох чисел. Якщо число ліворуч менше за число праворуч, то видається результат `true`. В іншому випадку видається результат `false`. Так само, як і оператор "дорівнює", оператор "менше ніж" конвертує типи даних під час їх порівняння.
+
+**Наприклад:**
+
+```js
+2   < 5
+'3' < 7
+5   < 5
+3   < 2
+'8' < 4
+```
+
+Відповідно, ці вирази будуть оцінені як `true`, `true`, `false`, `false`, та `false`.
+
+# --instructions--
+
+Додайте оператор "менше ніж" до вказаних рядків, щоб оператор повернення спрацював.
+
+# --hints--
+
+`testLessThan(0)` повинен видати рядок `Under 25`
+
+```js
+assert(testLessThan(0) === 'Under 25');
+```
+
+`testLessThan(24)` повинен видати рядок `Under 25`
+
+```js
+assert(testLessThan(24) === 'Under 25');
+```
+
+`testLessThan(25)` повинен видати рядок `Under 55`
+
+```js
+assert(testLessThan(25) === 'Under 55');
+```
+
+`testLessThan(54)` повинен видати рядок `Under 55`
+
+```js
+assert(testLessThan(54) === 'Under 55');
+```
+
+`testLessThan(55)` повинен видати рядок `55 or Over`
+
+```js
+assert(testLessThan(55) === '55 or Over');
+```
+
+`testLessThan(99)` повинен видати рядок `55 or Over`
+
+```js
+assert(testLessThan(99) === '55 or Over');
+```
+
+Оператор `<` потрібно використати принаймні двічі
+
+```js
+assert(code.match(/val\s*<\s*('|")*\d+('|")*/g).length > 1);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function testLessThan(val) {
+  if (val) {  // Change this line
+    return "Under 25";
+  }
+
+  if (val) {  // Change this line
+    return "Under 55";
+  }
+
+  return "55 or Over";
+}
+
+testLessThan(10);
+```
+
+# --solutions--
+
+```js
+function testLessThan(val) {
+  if (val < 25) {  // Change this line
+    return "Under 25";
+  }
+
+  if (val < 55) {  // Change this line
+    return "Under 55";
+  }
+
+  return "55 or Over";
+}
+```
--- 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
@@ -0,0 +1,114 @@
+---
+id: 56533eb9ac21ba0edf2244d7
+title: Порівняння з оператором "менше або рівне"
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cNVR7Am'
+forumTopicId: 16788
+dashedName: comparison-with-the-less-than-or-equal-to-operator
+---
+
+# --description--
+
+Оператор "менше або рівне"(`<=`) порівнює значення двох чисел. Якщо число ліворуч є меншим, ніж число праворуч або дорівнює йому, то видається результат `true`. Якщо число ліворуч більше за число праворуч, то видається результат `false`. Так само, як і оператор рівності, оператор "менше або рівне" конвертує типи даних.
+
+**Наприклад:**
+
+```js
+4   <= 5
+'7' <= 7
+5   <= 5
+3   <= 2
+'8' <= 4
+```
+
+Відповідно, ці вирази будуть оцінені як `true`, `true`, `true`, `false`, та `false`.
+
+# --instructions--
+
+Додайте оператор "менше або рівне до вказаних рядків, щоб оператор повернення спрацював.
+
+# --hints--
+
+`testLessOrEqual(0)` повинен повернути рядок `Smaller Than or Equal to 12`
+
+```js
+assert(testLessOrEqual(0) === '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)` повинен повернути рядок `Smaller Than or Equal to 12`
+
+```js
+assert(testLessOrEqual(12) === 'Smaller Than or Equal to 12');
+```
+
+`testLessOrEqual(23)` повинен повернути рядок `Smaller Than or Equal to 24`
+
+```js
+assert(testLessOrEqual(23) === '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)` повинен повернути рядок `More Than 24`
+
+```js
+assert(testLessOrEqual(25) === 'More Than 24');
+```
+
+`testLessOrEqual(55)` повинен повернути рядок `More Than 24`
+
+```js
+assert(testLessOrEqual(55) === 'More Than 24');
+```
+
+Оператор `<=` потрібно використати принаймні двічі
+
+```js
+assert(code.match(/val\s*<=\s*('|")*\d+('|")*/g).length > 1);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function testLessOrEqual(val) {
+  if (val) {  // Change this line
+    return "Smaller Than or Equal to 12";
+  }
+
+  if (val) {  // Change this line
+    return "Smaller Than or Equal to 24";
+  }
+
+  return "More Than 24";
+}
+
+testLessOrEqual(10);
+```
+
+# --solutions--
+
+```js
+function testLessOrEqual(val) {
+  if (val <= 12) {  // Change this line
+    return "Smaller Than or Equal to 12";
+  }
+
+  if (val <= 24) {  // Change this line
+    return "Smaller Than or Equal to 24";
+  }
+
+  return "More Than 24";
+}
+```
--- 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
@@ -0,0 +1,82 @@
+---
+id: 56533eb9ac21ba0edf2244d1
+title: Порівняння з Оператором Абсолютної Рівності
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cy87atr'
+forumTopicId: 16790
+dashedName: comparison-with-the-strict-equality-operator
+---
+
+# --description--
+
+Абсолютна рівність (`===`) є аналогом оператора рівності (`==`). Однак, на відміну від оператора рівності, який намагається перетворити обидва значення в порівнянні зі звичайним типом, оператор абсолютної рівності не виконує перетворення типів.
+
+Якщо значення, які перетворюються, мають різні типи, вони вважаються нерівними і оператор абсолютної рівності видасть помилку.
+
+**Наприклад**
+
+```js
+3 ===  3
+3 === '3'
+```
+
+Ці умови повертаються відповідно `true` та `false` відповідно.
+
+У другому прикладі, `3` є типом `Number`, а `'3'` є типом `String`.
+
+# --instructions--
+
+Використовуйте оператора абсолютної рівності з командою `if`, щоб функція повернула рядок `Equal`, коли `val` точно дорівнює `7`.
+
+# --hints--
+
+`testStrict(10)` перетворюється в рядку на `Not Equal`
+
+```js
+assert(testStrict(10) === 'Not Equal');
+```
+
+`testStrict(7)` перетворюється в рядку на `Equal`
+
+```js
+assert(testStrict(7) === 'Equal');
+```
+
+`testStrict("7")` перетворюється в рядку на `Not Equal`
+
+```js
+assert(testStrict('7') === 'Not Equal');
+```
+
+Вам слід використовувати оператора `===`
+
+```js
+assert(code.match(/(val\s*===\s*\d+)|(\d+\s*===\s*val)/g).length > 0);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+// Setup
+function testStrict(val) {
+  if (val) { // Change this line
+    return "Equal";
+  }
+  return "Not Equal";
+}
+
+testStrict(10);
+```
+
+# --solutions--
+
+```js
+function testStrict(val) {
+  if (val === 7) {
+    return "Equal";
+  }
+  return "Not Equal";
+}
+```
--- 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
@@ -0,0 +1,85 @@
+---
+id: 56533eb9ac21ba0edf2244d3
+title: Порівняння з Оператором Абсолютної Нерівності
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cKekkUy'
+forumTopicId: 16791
+dashedName: comparison-with-the-strict-inequality-operator
+---
+
+# --description--
+
+Оператор абсолютної нерівності (`!==`) є логічною протилежністю оператора абсолютної рівності. Це означає, що "Абсолютно Не Рівно" та визначається `false`, де абсолютна рівність визначається як `true` і *vice versa*. Оператор абсолютної нерівності не буде перетворювати типи даних.
+
+**Приклади**
+
+```js
+3 !==  3
+3 !== '3'
+4 !==  3
+```
+
+У такому порядку, ці вирази будуть оцінювати, як `false`, `true`,`true`.
+
+# --instructions--
+
+Додайте оператора абсолютної нерівності до команди `if`, щоб функція визначила рядок `Not Equal`, коли `val` не є абсолютно рівним `17`
+
+# --hints--
+
+`testStrictNotEqual(17)` перетворюється в рядку на `Equal`
+
+```js
+assert(testStrictNotEqual(17) === 'Equal');
+```
+
+`testStrictNotEqual("17")` перетворюється в рядку на `Not Equal`
+
+```js
+assert(testStrictNotEqual('17') === 'Not Equal');
+```
+
+`testStrictNotEqual(12)` перетворюється в рядку на `Not Equal`
+
+```js
+assert(testStrictNotEqual(12) === 'Not Equal');
+```
+
+`testStrictNotEqual("bob")` перетворюється в рядку на `Not Equal`
+
+```js
+assert(testStrictNotEqual('bob') === 'Not Equal');
+```
+
+Вам слід використовувати оператора`!==`
+
+```js
+assert(code.match(/(val\s*!==\s*\d+)|(\d+\s*!==\s*val)/g).length > 0);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+// Setup
+function testStrictNotEqual(val) {
+  if (val) { // Change this line
+    return "Not Equal";
+  }
+  return "Equal";
+}
+
+testStrictNotEqual(10);
+```
+
+# --solutions--
+
+```js
+function testStrictNotEqual(val) {
+  if (val !== 17) {
+    return "Not Equal";
+  }
+  return "Equal";
+}
+```
--- 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
@@ -0,0 +1,130 @@
+---
+id: 56533eb9ac21ba0edf2244d8
+title: Порівняння з оператором "більше ніж"
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cvbRVtr'
+forumTopicId: 16799
+dashedName: comparisons-with-the-logical-and-operator
+---
+
+# --description--
+
+Трапляється, що потрібно перевіряти більше ніж одну цифру одночасно. <dfn>Оператор "більше ніж"</dfn> `&&` стає `true` якщо <dfn>вихідні об'єкти</dfn> справа та зліва від нього вірні.
+
+Такого ж результату можна досягнути шляхом закладання інформації всередині іншого:
+
+```js
+if (num > 5) {
+  if (num < 10) {
+    return "Yes";
+  }
+}
+return "No";
+```
+
+результат `Yes`, якщо `num` є більшим `5` та меньшим за `10`. Приклад оператора наведено нище:
+
+```js
+if (num > 5 && num < 10) {
+  return "Yes";
+}
+return "No";
+```
+
+# --instructions--
+
+Замініть два оператора if statements одним використовуючи `&&` оператор. Значення рядка буде `Yes`, якщо `val` меньше або рівне `50` та більше або рівне `25`. В іншому випадку значення рядка стане `No`.
+
+# --hints--
+
+Використовуйте оператор `&&` лише один раз
+
+```js
+assert(code.match(/&&/g).length === 1);
+```
+
+У вас має бути лише один елемент `if`
+
+```js
+assert(code.match(/if/g).length === 1);
+```
+
+`testLogicalAnd(0)` перетворюється у рядку на `No`
+
+```js
+assert(testLogicalAnd(0) === 'No');
+```
+
+`testLogicalAnd(24)` перетворюється на `No`
+
+```js
+assert(testLogicalAnd(24) === 'No');
+```
+
+`testLogicalAnd(25)` перетворюється на `Yes`
+
+```js
+assert(testLogicalAnd(25) === 'Yes');
+```
+
+`testLogicalAnd(30)` перетворюється на `Yes`
+
+```js
+assert(testLogicalAnd(30) === 'Yes');
+```
+
+`testLogicalAnd(50)` перетворюється на `Yes`
+
+```js
+assert(testLogicalAnd(50) === 'Yes');
+```
+
+`testLogicalAnd(51)` перетворюється на `No`
+
+```js
+assert(testLogicalAnd(51) === 'No');
+```
+
+`testLogicalAnd(75)` перетворюється на `No`
+
+```js
+assert(testLogicalAnd(75) === 'No');
+```
+
+`testLogicalAnd(80)` перетворюється на `No`
+
+```js
+assert(testLogicalAnd(80) === 'No');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function testLogicalAnd(val) {
+  // Only change code below this line
+
+  if (val) {
+    if (val) {
+      return "Yes";
+    }
+  }
+
+  // Only change code above this line
+  return "No";
+}
+
+testLogicalAnd(10);
+```
+
+# --solutions--
+
+```js
+function testLogicalAnd(val) {
+  if (val >= 25 && val <= 50) {
+    return "Yes";
+  }
+  return "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
@@ -0,0 +1,135 @@
+---
+id: 56533eb9ac21ba0edf2244d9
+title: Порівняння з оператором "більше ніж"
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cEPrGTN'
+forumTopicId: 16800
+dashedName: comparisons-with-the-logical-or-operator
+---
+
+# --description--
+
+Якщо оператор <dfn>logical або</dfn> (`||`) повертає `true`, якщо будь-який з <dfn>operands</dfn> є `true`. В іншому випадку перетворюється на `false`.
+
+Оператор <dfn>логічний або</dfn> складається з двох символів труби (`||`). Зазвичай його можна знайти на клавіатурі між клавіш Backspace та Enter.
+
+Шаблон нижче повинен бути схожим з етапами вище:
+
+```js
+if (num > 10) {
+  return "No";
+}
+if (num < 5) {
+  return "No";
+}
+return "Yes";
+```
+
+стає `Yes` тільки, якщо `num` між `5` та `10` (5 та 10 включно). Приклад оператора наведено нижче:
+
+```js
+if (num > 10 || num < 5) {
+  return "No";
+}
+return "Yes";
+```
+
+# --instructions--
+
+Об'єднайте два оператори `if` в один оператор який перетворить рядок `Outside`, якщо `val` не знаходиться в діапазоні від `10` до `20` включно. В іншому випадку значення рядка стане `Inside`.
+
+# --hints--
+
+Використовуйте оператор `||` лише раз
+
+```js
+assert(code.match(/\|\|/g).length === 1);
+```
+
+У вас має бути лише один елемент `if`
+
+```js
+assert(code.match(/if/g).length === 1);
+```
+
+`testLogicalOr(0)` перетворюється на `Outside`
+
+```js
+assert(testLogicalOr(0) === 'Outside');
+```
+
+`testLogicalOr(9)` перетворюється на `Outside`
+
+```js
+assert(testLogicalOr(9) === 'Outside');
+```
+
+`testLogicalOr(10)` перетворюється на `Inside`
+
+```js
+assert(testLogicalOr(10) === 'Inside');
+```
+
+`testLogicalOr(15)` перетворюється на `Inside`
+
+```js
+assert(testLogicalOr(15) === 'Inside');
+```
+
+`testLogicalOr(19)` перетворюється на `Inside`
+
+```js
+assert(testLogicalOr(19) === 'Inside');
+```
+
+`testLogicalOr(20)` перетворюється на `Inside`
+
+```js
+assert(testLogicalOr(20) === 'Inside');
+```
+
+`testLogicalOr(21)` перетворюється на `Outside`
+
+```js
+assert(testLogicalOr(21) === 'Outside');
+```
+
+`testLogicalOr(25)` перетворюється на `Outside`
+
+```js
+assert(testLogicalOr(25) === 'Outside');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function testLogicalOr(val) {
+  // Only change code below this line
+
+  if (val) {
+    return "Outside";
+  }
+
+  if (val) {
+    return "Outside";
+  }
+
+  // Only change code above this line
+  return "Inside";
+}
+
+testLogicalOr(15);
+```
+
+# --solutions--
+
+```js
+function testLogicalOr(val) {
+  if (val < 10 || val > 20) {
+    return "Outside";
+  }
+  return "Inside";
+}
+```
--- 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
@@ -0,0 +1,101 @@
+---
+id: 56533eb9ac21ba0edf2244af
+title: Комбіноване присвоєння з розширеним додаванням
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cDR6LCb'
+forumTopicId: 16661
+dashedName: compound-assignment-with-augmented-addition
+---
+
+# --description--
+
+У програмуванні присвоєння зазвичай використовують для зміни вмісту змінної. Пам'ятайте, що спершу обчислюється усе, що стоїть праворуч від знаку "дорівнює", тож можна сказати, що:
+
+```js
+myVar = myVar + 5;
+```
+
+додати `5` до `myVar`. Оскільки це загальний шаблон, то існують оператори, які виконують математичні дії та присвоєння за один крок.
+
+Одним з таких операторів є `+=`.
+
+```js
+let myVar = 1;
+myVar += 5;
+console.log(myVar);
+```
+
+У консолі відображатиметься значення `6`.
+
+# --instructions--
+
+Конвертуйте присвоєння для `a`, `b`, та `c`, щоб використати оператор `+=`.
+
+# --hints--
+
+`a` повинне дорівнювати `15`.
+
+```js
+assert(a === 15);
+```
+
+`b` повинне дорівнювати `26`.
+
+```js
+assert(b === 26);
+```
+
+`c` повинне дорівнювати `19`.
+
+```js
+assert(c === 19);
+```
+
+Слід використовувати оператор `+=` для всіх змінних.
+
+```js
+assert(code.match(/\+=/g).length === 3);
+```
+
+Не слід змінювати код над зазначеним коментарем.
+
+```js
+assert(
+  /let a = 3;/.test(code) &&
+    /let b = 17;/.test(code) &&
+    /let c = 12;/.test(code)
+);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(a,b,c){ return "a = " + a + ", b = " + b + ", c = " + c; })(a,b,c);
+```
+
+## --seed-contents--
+
+```js
+let a = 3;
+let b = 17;
+let c = 12;
+
+// Only change code below this line
+a = a + 12;
+b = 9 + b;
+c = c + 7;
+```
+
+# --solutions--
+
+```js
+let a = 3;
+let b = 17;
+let c = 12;
+
+a += 12;
+b += 9;
+c += 7;
+```
--- 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
@@ -0,0 +1,95 @@
+---
+id: 56533eb9ac21ba0edf2244b2
+title: Комбіноване присвоєння з розширеним діленням
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/c2QvKT2'
+forumTopicId: 16659
+dashedName: compound-assignment-with-augmented-division
+---
+
+# --description--
+
+Оператор `/=` ділить змінну на інше число.
+
+```js
+myVar = myVar / 5;
+```
+
+Поділить `myVar` на `5`. Це можна записати ще так:
+
+```js
+myVar /= 5;
+```
+
+# --instructions--
+
+Конвертуйте присвоєння для `a`, `b`, та `c`, щоб використати оператор `/=`.
+
+# --hints--
+
+`a` повинне дорівнювати `4`.
+
+```js
+assert(a === 4);
+```
+
+`b` повинне дорівнювати `27`.
+
+```js
+assert(b === 27);
+```
+
+`c` повинне дорівнювати `3`.
+
+```js
+assert(c === 3);
+```
+
+Слід використовувати оператор `/=` для всіх змінних.
+
+```js
+assert(code.match(/\/=/g).length === 3);
+```
+
+Не слід змінювати код над зазначеним коментарем.
+
+```js
+assert(
+  /let a = 48;/.test(code) &&
+    /let b = 108;/.test(code) &&
+    /let c = 33;/.test(code)
+);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(a,b,c){ return "a = " + a + ", b = " + b + ", c = " + c; })(a,b,c);
+```
+
+## --seed-contents--
+
+```js
+let a = 48;
+let b = 108;
+let c = 33;
+
+// Only change code below this line
+a = a / 12;
+b = b / 4;
+c = c / 11;
+```
+
+# --solutions--
+
+```js
+let a = 48;
+let b = 108;
+let c = 33;
+
+a /= 12;
+b /= 4;
+c /= 11;
+```
--- 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
@@ -0,0 +1,95 @@
+---
+id: 56533eb9ac21ba0edf2244b1
+title: Комбіноване присвоєння з розширеним множенням
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/c83vrfa'
+forumTopicId: 16662
+dashedName: compound-assignment-with-augmented-multiplication
+---
+
+# --description--
+
+Оператор `*=` множить змінну на число.
+
+```js
+myVar = myVar * 5;
+```
+
+`myVar` множитиметься на `5`. Це можна переписати так:
+
+```js
+myVar *= 5;
+```
+
+# --instructions--
+
+Перетворіть присвоєння для `a`, `b`, і `c`, щоб використати оператор `*=`.
+
+# --hints--
+
+`a` повинне дорівнювати `25`.
+
+```js
+assert(a === 25);
+```
+
+`b` повинне дорівнювати `36`.
+
+```js
+assert(b === 36);
+```
+
+`c` повинне дорівнювати `46`.
+
+```js
+assert(c === 46);
+```
+
+Вам слід використовувати оператор `*=` для кожної змінної.
+
+```js
+assert(code.match(/\*=/g).length === 3);
+```
+
+Не слід змінювати код над зазначеним коментарем.
+
+```js
+assert(
+  /let a = 5;/.test(code) &&
+    /let b = 12;/.test(code) &&
+    /let c = 4\.6;/.test(code)
+);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(a,b,c){ return "a = " + a + ", b = " + b + ", c = " + c; })(a,b,c);
+```
+
+## --seed-contents--
+
+```js
+let a = 5;
+let b = 12;
+let c = 4.6;
+
+// Only change code below this line
+a = a * 5;
+b = 3 * b;
+c = c * 10;
+```
+
+# --solutions--
+
+```js
+let a = 5;
+let b = 12;
+let c = 4.6;
+
+a *= 5;
+b *= 3;
+c *= 10;
+```
--- 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
@@ -0,0 +1,93 @@
+---
+id: 56533eb9ac21ba0edf2244b0
+title: Комбіноване присвоєння з розширеним відніманням
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/c2Qv7AV'
+forumTopicId: 16660
+dashedName: compound-assignment-with-augmented-subtraction
+---
+
+# --description--
+
+Схожий на оператор `+=`, що додає, `-=` віднімає число від змінної.
+
+```js
+myVar = myVar - 5;
+```
+
+`5` віднімається від `myVar`. Це можна записати ще так:
+
+```js
+myVar -= 5;
+```
+
+# --instructions--
+
+Перетворіть присвоєння для `a`, `b`, і `c`, щоб використати оператор `-=`.
+
+# --hints--
+
+`a` повинне дорівнювати `5`.
+
+```js
+assert(a === 5);
+```
+
+`b` повинне дорівнювати `-6`.
+
+```js
+assert(b === -6);
+```
+
+`c` повинне дорівнювати `2`.
+
+```js
+assert(c === 2);
+```
+
+Слід використовувати оператор `-=` для кожної змінної.
+
+```js
+assert(code.match(/-=/g).length === 3);
+```
+
+Не слід змінювати код над зазначеним коментарем.
+
+```js
+assert(
+  /let a = 11;/.test(code) && /let b = 9;/.test(code) && /let c = 3;/.test(code)
+);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(a,b,c){ return "a = " + a + ", b = " + b + ", c = " + c; })(a,b,c);
+```
+
+## --seed-contents--
+
+```js
+let a = 11;
+let b = 9;
+let c = 3;
+
+// Only change code below this line
+a = a - 6;
+b = b - 15;
+c = c - 1;
+```
+
+# --solutions--
+
+```js
+let a = 11;
+let b = 9;
+let c = 3;
+
+a -= 6;
+b -= 15;
+c -= 1;
+```
--- 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
@@ -0,0 +1,83 @@
+---
+id: 56533eb9ac21ba0edf2244b7
+title: Об'єднання рядків за допомогою оператора "плюс"
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cNpM8AN'
+forumTopicId: 16802
+dashedName: concatenating-strings-with-plus-operator
+---
+
+# --description--
+
+В JavaScript, коли оператор `+` використовується зі значенням `String`, це називається оператором <dfn>об'єднання</dfn>. З рядків можна створити новий рядок, <dfn>об'єднавши</dfn> їх.
+
+**Наприклад:**
+
+```js
+'My name is Alan,' + ' I concatenate.'
+```
+
+**Примітка:** Зверніть увагу на пробіли. Під час об'єднання між рядками відсутні пробіли, вам потрібно буде додати їх самостійно.
+
+Наприклад:
+
+```js
+const ourStr = "I come first. " + "I come second.";
+```
+
+Рядок ` I come first. I come second.` відображатиметься у консолі.
+# --instructions--
+
+Створіть `myStr` з рядків `This is the start.` й `This is the end.` за допомогою `+` оператору. Обов'язково використовуйте пробіл між двома рядками.
+
+# --hints--
+
+`myStr` повинен мати таке ж значення як і рядок `This is the start. This is the end.`
+
+```js
+assert(myStr === 'This is the start. This is the end.');
+```
+
+Для створення `myStr` потрібно використовувати `+`.
+
+```js
+assert(code.match(/(["']).*\1\s*\+\s*(["']).*\2/g));
+```
+
+Для створення `myStr` потрібно використати ключове слово `const`.
+
+```js
+assert(/const\s+myStr/.test(code));
+```
+
+Слід призначити результат для змінної `myStr`.
+
+```js
+assert(/myStr\s*=/.test(code));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(){
+  if(typeof myStr === 'string') {
+    return 'myStr = "' + myStr + '"';
+  } else {
+    return 'myStr is not a string';
+  }
+})();
+```
+
+## --seed-contents--
+
+```js
+const myStr = ""; // Change this line
+```
+
+# --solutions--
+
+```js
+const myStr = "This is the start. " + "This is the end.";
+```
--- 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
@@ -0,0 +1,68 @@
+---
+id: 56533eb9ac21ba0edf2244b8
+title: Об'єднання рядків за допомогою оператора "плюс дорівнює"
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cbQmmC4'
+forumTopicId: 16803
+dashedName: concatenating-strings-with-the-plus-equals-operator
+---
+
+# --description--
+
+Ми можемо також використовувати оператор `+=`, щоб <dfn>з'єднувати</dfn> рядок з кінцем уже існуючого рядка змінної. Або ще для того, щоб розділяти довгий рядок над кількома рядками.
+
+**Примітка:** Зверніть увагу на пробіли. Під час об'єднання між рядками відсутні пробіли, вам потрібно буде додати їх самостійно.
+
+Наприклад:
+
+```js
+let ourStr = "I come first. ";
+ourStr += "I come second.";
+```
+
+`ourStr` зараз має значення рядка `I come first. I come second.`.
+
+# --instructions--
+
+Введіть `myStr` над кількома рядками, об'єднуючи ці два рядки: `This is the first sentence.` і `This is the second sentence.`. Використовуйте оператор `+=`. Використовуйте `+=` оператор, подібний до того, як показно в прикладі, й обов'язково зверніть увагу на наявність пробіл між рядками. Почніть з призначення першого рядка `myStr`, а потім додайте до другого рядка.
+
+# --hints--
+
+`myStr` повинен мати значення рядка `This is the first sentence. This is the second sentence.`
+
+```js
+assert(myStr === 'This is the first sentence. This is the second sentence.');
+```
+
+Для створення `myStr` потрібно використовувати `+=`.
+
+```js
+assert(code.match(/myStr\s*\+=\s*(["']).*\1/g));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(){
+  if(typeof myStr === 'string') {
+    return 'myStr = "' + myStr + '"';
+  } else {
+    return 'myStr is not a string';
+  }
+})();
+```
+
+## --seed-contents--
+
+```js
+let myStr;
+```
+
+# --solutions--
+
+```js
+let myStr = "This is the first sentence. ";
+myStr += "This is the second sentence.";
+```
--- 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
@@ -0,0 +1,75 @@
+---
+id: 56533eb9ac21ba0edf2244b9
+title: Створення рядків зі змінними
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cqk8rf4'
+forumTopicId: 16805
+dashedName: constructing-strings-with-variables
+---
+
+# --description--
+
+Інколи потрібно створити рядок у стилі гри [Mad Libs](https://en.wikipedia.org/wiki/Mad_Libs). Використовуючи оператор об'єднання (`+`), можна вставити одну або декілька змінних у рядок, який ви створюєте.
+
+Наприклад:
+
+```js
+const ourName = "freeCodeCamp";
+const ourStr = "Hello, our name is " + ourName + ", how are you?";
+```
+
+`ourStr` матиме значення рядка `Hello, our name is freeCodeCamp, how are you?`.
+
+# --instructions--
+
+Вставте `myName` у рядок з вашим іменем і створіть `myStr` з `myName` між рядками `My name is` і `and I am well!`
+
+# --hints--
+
+`myName` потрібно вставити у рядок, де є принаймні три символи.
+
+```js
+assert(typeof myName !== 'undefined' && myName.length > 2);
+```
+
+Ви маєте використати два оператори `+` для створення `myStr` з `myName` всередині нього.
+
+```js
+assert(code.match(/["']\s*\+\s*myName\s*\+\s*["']/g).length > 0);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(){
+  var output = [];
+  if(typeof myName === 'string') {
+    output.push('myName = "' + myName + '"');
+  } else {
+    output.push('myName is not a string');
+  }
+  if(typeof myStr === 'string') {
+    output.push('myStr = "' + myStr + '"');
+  } else {
+    output.push('myStr is not a string');
+  }
+  return output.join('\n');
+})();
+```
+
+## --seed-contents--
+
+```js
+// Only change code below this line
+const myName = "";
+const myStr = "";
+```
+
+# --solutions--
+
+```js
+const myName = "Bob";
+const myStr = "My name is " + myName + " and I am well!";
+```
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/count-backwards-with-a-for-loop.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/count-backwards-with-a-for-loop.md
@@ -0,0 +1,77 @@
+---
+id: 56105e7b514f539506016a5e
+title: Зворотній рахунок за допомогою циклу For Loop
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/c2R6BHa'
+forumTopicId: 16808
+dashedName: count-backwards-with-a-for-loop
+---
+
+# --description--
+
+Цикл For Loop може здійснювати зворотній відлік, якщо виставлені правильні умови.
+
+Для того, щоб зменшити значення на два кроки, потрібно змінити нашу ініціалізацію, умову та кінцевий вираз.
+
+Розпочнемо з `i = 10` та створимо цикл, коли `i > 0`. Зменшуватимемо значення `i` на 2 в кожному циклі при тому, що`i -= 2`.
+
+```js
+const ourArray = [];
+
+for (let i = 10; i > 0; i -= 2) {
+  ourArray.push(i);
+}
+```
+
+`ourArray` тепер міститиме `[10, 8, 6, 4, 2]`. Змінімо нашу ініціалізацію та кінцевий вираз і тоді ми зможемо відраховувати назад на два, щоб створити масив непарних чисел у порядку спадання.
+
+# --instructions--
+
+Додайте непарні числа від 9 до 1 до `myArray`, використовуючи цикл `for`.
+
+# --hints--
+
+Для цього потрібно використовувати цикл `for`.
+
+```js
+assert(/for\s*\([^)]+?\)/.test(code));
+```
+
+Потрібно використовувати метод масиву `push`.
+
+```js
+assert(code.match(/myArray.push/));
+```
+
+`myArray` повинне дорівнювати `[9, 7, 5, 3, 1]`.
+
+```js
+assert.deepEqual(myArray, [9, 7, 5, 3, 1]);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+if(typeof myArray !== "undefined"){(function(){return myArray;})();}
+```
+
+## --seed-contents--
+
+```js
+// Setup
+const myArray = [];
+
+// Only change code below this line
+
+```
+
+# --solutions--
+
+```js
+const myArray = [];
+for (let i = 9; i > 0; i -= 2) {
+  myArray.push(i);
+}
+```
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/create-decimal-numbers-with-javascript.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/create-decimal-numbers-with-javascript.md
@@ -0,0 +1,55 @@
+---
+id: cf1391c1c11feddfaeb4bdef
+title: Створення десяткових чисел з JavaScript
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/ca8GEuW'
+forumTopicId: 16826
+dashedName: create-decimal-numbers-with-javascript
+---
+
+# --description--
+
+Ми можемо зберігати десяткові числа також і у змінних. Десяткові числа іноді називаються числами <dfn>floating point</dfn> або <dfn>floats</dfn>.
+
+**Примітка:** Не всі дійсні числа можуть бути віднесені до <dfn>рухомої коми</dfn>. Це може призвести до помилок заокруглення. [Детальніше Тут](https://en.wikipedia.org/wiki/Floating-point_arithmetic#Accuracy_problems).
+
+# --instructions--
+
+Створіть змінну `myDecimal` і надайте їй десяткове значення з дробовою частиною (наприклад, `5.7`).
+
+# --hints--
+
+`myDecimal` повинне бути числом.
+
+```js
+assert(typeof myDecimal === 'number');
+```
+
+`myDecimal` повинне мати десяткову кому
+
+```js
+assert(myDecimal % 1 != 0);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(){if(typeof myDecimal !== "undefined"){return myDecimal;}})();
+```
+
+## --seed-contents--
+
+```js
+const ourDecimal = 5.7;
+
+// Only change code below this line
+
+```
+
+# --solutions--
+
+```js
+const myDecimal = 9.9;
+```
--- 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
@@ -0,0 +1,88 @@
+---
+id: 587d7b87367417b2b2512b41
+title: Оголосіть змінну, доступну лише для читання, з ключовим словом Const
+challengeType: 1
+forumTopicId: 301201
+dashedName: declare-a-read-only-variable-with-the-const-keyword
+---
+
+# --description--
+
+Ключове слово `let` є не єдиним новим способом оголосити змінну. В ES6 можливо також оголосити змінні, використовуючи ключове слово `const`.
+
+У `const` є ті ж круті функції, що й в `let` з приємним бонусом — тепер змінні, оголошені за допомогою `const`, доступні лише для читання. Вони мають константне значення. Тобто, як тільки змінна стає призначеною `const`, її вже неможливо призначити знову:
+
+```js
+const FAV_PET = "Cats";
+FAV_PET = "Dogs";
+```
+
+Консоль показуватиме помилку через перепризначення значення `FAV_PET`.
+
+Змінні, які не передбачають перепризначення, слід називати, використовуючи ключове слово `const`. Це може знадобитися, якщо ви випадково спробуєте перепризначити змінну, яка повинна бути константною.
+
+Як правило, назву пишуть великими літерами, а слова виокремлюють знаком підкреслення.
+
+**Зверніть увагу:** Зазвичай, розробники пишуть назву ідентифікаторів незмінних значень великими літерами, а назви змінних значень (об'єктів та масивів) — маленькими літерами або через camelCase. Ви дізнаєтесь більше про предмети, масиви, незмінні та незмінні цінності в наступних завданнях. Також у наступних завданнях ви побачите приклади використання нижнього та верхнього регістру, а також ідентифікаторів змінної camelCase.
+
+# --instructions--
+
+Змініть код так, щоб усі змінні були оголошені за допомогою `let` або `const`. Використовуйте `let` для змінних значень, а `const` для незмінних значень. Крім того, змініть назву змінної, оголошеної з `const`, відповідно до поширених методів роботи: назви констант мають писатися великими літерами.
+
+# --hints--
+
+`var` має бути відсутнім у коді.
+
+```js
+(getUserInput) => assert(!getUserInput('index').match(/var/g));
+```
+
+Ви повинні змінити `fCC` на верхні регістри.
+
+```js
+(getUserInput) => {
+  assert(getUserInput('index').match(/(FCC)/));
+  assert(!getUserInput('index').match(/fCC/));
+}
+```
+
+`FCC` має бути константною змінною, оголошеною з `const`.
+
+```js
+assert.equal(FCC, 'freeCodeCamp');
+assert.match(code, /const\s+FCC/);
+```
+
+`fact` має оголошуватися з `let`.
+
+```js
+(getUserInput) => assert(getUserInput('index').match(/(let fact)/g));
+```
+
+`console.log` необхідно змінити, щоб вивести на екран змінні `FCC` та `fact`.
+
+```js
+(getUserInput) =>
+  assert(getUserInput('index').match(/console\.log\(\s*FCC\s*\,\s*fact\s*\)\s*;?/g));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+var fCC = "freeCodeCamp"; // Change this line
+var fact = "is cool!"; // Change this line
+fact = "is awesome!";
+console.log(fCC, fact); // Change this line
+```
+
+# --solutions--
+
+```js
+const FCC = "freeCodeCamp";
+let fact = "is cool!";
+
+fact = "is awesome!";
+console.log(FCC, fact);
+```
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/declare-javascript-variables.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/declare-javascript-variables.md
@@ -0,0 +1,61 @@
+---
+id: bd7123c9c443eddfaeb5bdef
+title: Оголошення змінних JavaScript
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cNanrHq'
+forumTopicId: 17556
+dashedName: declare-javascript-variables
+---
+
+# --description--
+
+У інформатиці <dfn>data</dfn> має важливе значення для комп'ютера. JavaScript надає вісім різних типів <dfn>data</dfn>: `undefined`, `null`, `boolean`, `string`, `symbol`, `bigint`, `number` та `object`.
+
+Наприклад, компю'тери розрізняють числа, такі як `12` та `strings`, такі як `"12"`, `"dog"` або `"123 cats"`, котрі є набором символів. Комп'ютери можуть виконувати математичні операції з числом, але не з рядком.
+
+<dfn>Variables</dfn> дозволяють комп'ютеру динамічно зберігати та керувати даними. Вони роблять це шляхом використання "мітки" для того, щоб вказувати на дані, не використовуючи самі дані. Будь-який з восьми видів даних можуть зберігатися у змінній.
+
+Змінні подібні до змінних "x" та "y", що використовуються в математиці, і це означає, що вони є простою назвою для представлення даних, на які ми хочемо посилатися. Комп'ютерні змінні відрізняються від математичних змінних тим, що вони можуть зберігати різні значення в різний час.
+
+Ми вказуємо JavaScript створити або <dfn>declare</dfn> змінну, встановивши перед нею ключове слово `var`, таким чином:
+
+```js
+var ourName;
+```
+
+створює змінну, що називається `ourName`. В JavaScript ми завершуємо команди крапкою з комою. Імена змінних можуть бути складені з цифр, букв та `$` або `_`, але не можуть містити пробіли або починатися з числа.
+
+# --instructions--
+
+Використовуйте ключове слово `var` для створення змінної `myName`.
+
+**Підказка**  
+Якщо застрягли, перегляньте приклад `ourName` вище.
+
+# --hints--
+
+Ви повинні вказати `myName` з ключовим словом `var`, закінчуючи крапкою з комою
+
+```js
+assert(/var\s+myName\s*;/.test(code));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+if(typeof myName !== "undefined"){(function(v){return v;})(myName);}
+```
+
+## --seed-contents--
+
+```js
+
+```
+
+# --solutions--
+
+```js
+var myName;
+```
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/declare-string-variables.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/declare-string-variables.md
@@ -0,0 +1,87 @@
+---
+id: bd7123c9c444eddfaeb5bdef
+title: Оголошення типу змінних string
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/c2QvWU6'
+forumTopicId: 17557
+dashedName: declare-string-variables
+---
+
+# --description--
+
+Раніше ви використовували цей код, щоб оголосити змінну:
+
+```js
+var myName;
+```
+
+Але ви також можете оголосити рядковий тип змінним ось так:
+
+```js
+var myName = "your name";
+```
+
+`"your name"` називається <dfn>string</dfn> <dfn>literal</dfn>. string literal — це послідовність символів від нуля до нескінченності, записаних в одинарних чи подвійних лапках.
+
+# --instructions--
+
+Створіть дві нові змінні рядкового типу: `myFirstName` (моє ім'я) та `myLastName` (моє прізвище) та надайте їм значення вашого імені та прізвища.
+
+# --hints--
+
+`myFirstName` має бути рядком з хоча б одним символом всередині.
+
+```js
+assert(
+  (function () {
+    if (
+      typeof myFirstName !== 'undefined' &&
+      typeof myFirstName === 'string' &&
+      myFirstName.length > 0
+    ) {
+      return true;
+    } else {
+      return false;
+    }
+  })()
+);
+```
+
+`myLastName` має бути рядком з хоча б одним символом всередині.
+
+```js
+assert(
+  (function () {
+    if (
+      typeof myLastName !== 'undefined' &&
+      typeof myLastName === 'string' &&
+      myLastName.length > 0
+    ) {
+      return true;
+    } else {
+      return false;
+    }
+  })()
+);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+if(typeof myFirstName !== "undefined" && typeof myLastName !== "undefined"){(function(){return myFirstName + ', ' + myLastName;})();}
+```
+
+## --seed-contents--
+
+```js
+
+```
+
+# --solutions--
+
+```js
+var myFirstName = "Alan";
+var myLastName = "Turing";
+```
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/decrement-a-number-with-javascript.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/decrement-a-number-with-javascript.md
@@ -0,0 +1,80 @@
+---
+id: 56533eb9ac21ba0edf2244ad
+title: Зменшення числа за допомогою JavaScript
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cM2KeS2'
+forumTopicId: 17558
+dashedName: decrement-a-number-with-javascript
+---
+
+# --description--
+
+Ви можете легко <dfn>decrement</dfn> або зменшити змінну на одиницю за допомогою оператора `--`.
+
+```js
+i--;
+```
+
+дорівнює
+
+```js
+i = i - 1;
+```
+
+**Примітка:** Весь рядок стає `i--;`, усуваючи потребу в знаку рівності.
+
+# --instructions--
+
+Змініть код, щоб користуватися оператором `--` у `myVar`.
+
+# --hints--
+
+`myVar` повинен дорівнювати `10`.
+
+```js
+assert(myVar === 10);
+```
+
+`myVar = myVar - 1;` слід змінити.
+
+```js
+assert(
+  /let\s*myVar\s*=\s*11;\s*\/*.*\s*([-]{2}\s*myVar|myVar\s*[-]{2});/.test(code)
+);
+```
+
+Вам слід користуватись оператором `--` у `myVar`.
+
+```js
+assert(/[-]{2}\s*myVar|myVar\s*[-]{2}/.test(code));
+```
+
+Не слід змінювати код над зазначеним коментарем.
+
+```js
+assert(/let myVar = 11;/.test(code));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(z){return 'myVar = ' + z;})(myVar);
+```
+
+## --seed-contents--
+
+```js
+let myVar = 11;
+
+// Only change code below this line
+myVar = myVar - 1;
+```
+
+# --solutions--
+
+```js
+let myVar = 11;
+myVar--;
+```
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/delete-properties-from-a-javascript-object.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/delete-properties-from-a-javascript-object.md
@@ -0,0 +1,96 @@
+---
+id: 56bbb991ad1ed5201cd392d3
+title: Видалення властивостей з об'єкту JavaScript
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cDqKdTv'
+forumTopicId: 17560
+dashedName: delete-properties-from-a-javascript-object
+---
+
+# --description--
+
+Ми також можемо видалити властивості з таких об'єктів, як цей:
+
+```js
+delete ourDog.bark;
+```
+
+До прикладу:
+
+```js
+const ourDog = {
+  "name": "Camper",
+  "legs": 4,
+  "tails": 1,
+  "friends": ["everything!"],
+  "bark": "bow-wow"
+};
+
+delete ourDog.bark;
+```
+
+Після того, як зазначено останній рядок, `ourDog` виглядає так:
+
+```js
+{
+  "name": "Camper",
+  "legs": 4,
+  "tails": 1,
+  "friends": ["everything!"]
+}
+```
+
+# --instructions--
+
+Видаліть властивість `tails` з `myDog`. Ви можете використовувати крапковий запис або запис квадратними дужками.
+
+# --hints--
+
+Вам слід видалити властивість `tails` з `myDog`.
+
+```js
+assert(typeof myDog === 'object' && myDog.tails === undefined);
+```
+
+Ви не повинні змінювати налаштування `myDog`.
+
+```js
+assert(code.match(/"tails": 1/g).length > 0);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(z){return z;})(myDog);
+```
+
+## --seed-contents--
+
+```js
+// Setup
+const myDog = {
+  "name": "Happy Coder",
+  "legs": 4,
+  "tails": 1,
+  "friends": ["freeCodeCamp Campers"],
+  "bark": "woof"
+};
+
+// Only change code below this line
+
+```
+
+# --solutions--
+
+```js
+const myDog = {
+  "name": "Happy Coder",
+  "legs": 4,
+  "tails": 1,
+  "friends": ["freeCodeCamp Campers"],
+  "bark": "woof"
+};
+delete myDog.tails;
+```
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/divide-one-decimal-by-another-with-javascript.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/divide-one-decimal-by-another-with-javascript.md
@@ -0,0 +1,56 @@
+---
+id: bd7993c9ca9feddfaeb7bdef
+title: Ділення одного десяткового на інше у JavaScript
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cBZe9AW'
+forumTopicId: 18255
+dashedName: divide-one-decimal-by-another-with-javascript
+---
+
+# --description--
+
+Тепер давайте поділимо одне десяткове число на інше.
+
+# --instructions--
+
+Змініть `0.0` таким чином, щоб `quotient` дорівнювало `2.2`.
+
+# --hints--
+
+Змінна `quotient` повинна дорівнювати `2.2`
+
+```js
+assert(quotient === 2.2);
+```
+
+Вам слід використовувати оператор `/`, щоб поділити 4.4 на 2
+
+```js
+assert(/4\.40*\s*\/\s*2\.*0*/.test(code));
+```
+
+Коефіцієнтна змінна повинна бути визначена лише раз
+
+```js
+assert(code.match(/quotient/g).length === 1);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(y){return 'quotient = '+y;})(quotient);
+```
+
+## --seed-contents--
+
+```js
+const quotient = 0.0 / 2.0; // Change this line
+```
+
+# --solutions--
+
+```js
+const quotient = 4.4 / 2.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
@@ -0,0 +1,59 @@
+---
+id: cf1111c1c11feddfaeb6bdef
+title: Ділення одного числа на інше за допомогою JavaScript
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cqkbdAr'
+forumTopicId: 17566
+dashedName: divide-one-number-by-another-with-javascript
+---
+
+# --description--
+
+Також ми можемо поділити одне число на інше.
+
+JavaScript використовує символ `/` для ділення.
+
+**Приклад**
+
+```js
+const myVar = 16 / 2;
+```
+
+`myVar` тепер набуває значення `8`.
+# --instructions--
+
+Змініть `0` таким чином, щоб `quotient` дорівнювало `2`.
+
+# --hints--
+
+Змінна `quotient` має дорівнювати 2.
+
+```js
+assert(quotient === 2);
+```
+
+Вам слід використовувати оператор `/`.
+
+```js
+assert(/\d+\s*\/\s*\d+/.test(code));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(z){return 'quotient = '+z;})(quotient);
+```
+
+## --seed-contents--
+
+```js
+const quotient = 66 / 0;
+```
+
+# --solutions--
+
+```js
+const quotient = 66 / 33;
+```
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/escape-sequences-in-strings.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/escape-sequences-in-strings.md
@@ -0,0 +1,99 @@
+---
+id: 56533eb9ac21ba0edf2244b6
+title: Екранування послідовностей у рядках
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cvmqRh6'
+forumTopicId: 17567
+dashedName: escape-sequences-in-strings
+---
+
+# --description--
+
+Лапки - не єдині символи, що можуть бути <dfn>екрановані</dfn> в рядку. Існує дві причини використовувати екрановані символи:
+
+1.  Щоб дозволити вам використовувати символи, які ви не можете інакше вводити, такі як повернення каретки.
+2.  Щоб дозволити вам відобразити декілька лапок в рядку без неправильного тлумачення JavaScript того, що ви маєте на увазі.
+
+Ми вивчили це в попередньому завданні.
+
+<table class='table table-striped'><thead><tr><th>Код</th><th>При виведенні буде</th></tr></thead><tbody><tr><td><code>\'</code></td><td>одинарні лапки</td></tr><tr><td><code>\"</code></td><td>подвійні лапки</td></tr><tr><td><code>\\</code></td><td>зворотня коса риска</td></tr><tr><td><code>\n</code></td><td>новий рядок</td></tr><tr><td><code>\r</code></td><td>повернення каретки</td></tr><tr><td><code>\t</code></td><td>вкладка</td></tr><tr><td><code>\b</code></td><td>границі слова</td></tr><tr><td><code>\f</code></td><td>розрив сторінки</td></tr></tbody></table>
+
+*Зверніть увагу, що сама зворотня коса риска повинна бути екранована для того, щоб вона відображалась.*
+
+# --instructions--
+
+Задайте наступні 3 рядки тексту в єдину змінну `myStr`, використовуючи екрановану послідовність.
+
+<blockquote>Перша лінія<br>    \Друга лінія<br>Третя лінія</blockquote>
+
+Щоб правильно встановити спеціальні символи, потрібно використовувати екрановану послідовність. Також потрібно дотримуватись інтервалу, як це виглядає вище, без пробілів між екранованими послідовностями або словами.
+
+**Примітка:** Відступ для `SecondLine` досягається за допомогою символу екранування вкладки, а не пробілів.
+
+# --hints--
+
+`myStr` не повинен містити пробілів
+
+```js
+assert(!/ /.test(myStr));
+```
+
+`myStr` повинен містити рядки `FirstLine`, `SecondLine` та `ThirdLine` (пам'ятайте про врахування регістру)
+
+```js
+assert(
+  /FirstLine/.test(myStr) && /SecondLine/.test(myStr) && /ThirdLine/.test(myStr)
+);
+```
+
+За `FirstLine` повинен слідувати символ нового рядка `\n`
+
+```js
+assert(/FirstLine\n/.test(myStr));
+```
+
+`myStr` повинен містити символ вкладки `\t`, який слідує за символом нового рядка
+
+```js
+assert(/\n\t/.test(myStr));
+```
+
+За `SecondLine` повинен слідувати символ зворотної косої риски `\`
+
+```js
+assert(/\\SecondLine/.test(myStr));
+```
+
+Між `SecondLine` та `ThirdLine` повинен бути символ нового рядка
+
+```js
+assert(/SecondLine\nThirdLine/.test(myStr));
+```
+
+`myStr` повинен містити лише символи, показані в інструкціях
+
+```js
+assert(myStr === 'FirstLine\n\t\\SecondLine\nThirdLine');
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(){
+if (myStr !== undefined){
+console.log('myStr:\n' + myStr);}})();
+```
+
+## --seed-contents--
+
+```js
+const myStr = ""; // Change this line
+```
+
+# --solutions--
+
+```js
+const myStr = "FirstLine\n\t\\SecondLine\nThirdLine";
+```
--- 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
@@ -0,0 +1,72 @@
+---
+id: 56533eb9ac21ba0edf2244b5
+title: Уникнення літературних цитат в рядках
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/c2QvgSr'
+forumTopicId: 17568
+dashedName: escaping-literal-quotes-in-strings
+---
+
+# --description--
+
+Коли ви зазначаєте рядок, вам потрібно починати і закінчувати його одинарними або подвійними лапками. Що стається, коли ви потребуєте літературну цитату `"` or `'` всередині вашого рядка?
+
+В JavaScript, ви можете <dfn>вийти</dfn> з цитати і розглядати її як кінець рядка лапки, розмістивши <dfn>зворотнього слешу</dfn> (`\`) перед лапкою.
+
+```js
+const sampleStr = "Alan said, \"Peter is learning JavaScript\".";
+```
+
+Це сигнали для JavaScript про те, що така цитата не є кінцевим рядком, а повинна з'явитися всередині рядка. Тому якщо ви введете це в консолі, то отримаєте:
+
+```js
+Alan said, "Peter is learning JavaScript".
+```
+
+# --instructions--
+
+Використовуйте <dfn>косі риски</dfn> щоб зазначити для рядка змінну `myStr`, і таким чином ввівши її на консолі, побачите:
+
+```js
+I am a "double quoted" string inside "double quotes".
+```
+
+# --hints--
+
+Вам слід використовувати дві подвійні лапки (`"`) і чотири подвійні лапки (`\"`).
+
+```js
+assert(code.match(/\\"/g).length === 4 && code.match(/[^\\]"/g).length === 2);
+```
+
+Змінний myStr повинен містити рядок: `I am a "double quoted" string inside "double quotes".`
+
+```js
+assert(/I am a "double quoted" string inside "double quotes(\."|"\.)$/.test(myStr));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(){
+  if(typeof myStr === 'string') {
+    console.log("myStr = \"" + myStr + "\"");
+  } else {
+    console.log("myStr is undefined");
+  }
+})();
+```
+
+## --seed-contents--
+
+```js
+const myStr = ""; // Change this line
+```
+
+# --solutions--
+
+```js
+const myStr = "I am a \"double quoted\" string inside \"double quotes\".";
+```
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/explore-differences-between-the-var-and-let-keywords.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/explore-differences-between-the-var-and-let-keywords.md
@@ -0,0 +1,74 @@
+---
+id: 587d7b87367417b2b2512b3f
+title: Дослідіть відмінності між ключовими словами var та let
+challengeType: 1
+forumTopicId: 301202
+dashedName: explore-differences-between-the-var-and-let-keywords
+---
+
+# --description--
+
+Одна з найбільших проблем в оголошенні змінних з ключовим словом `var` полягає в легкому перезаписуванні оголошень змінних:
+
+```js
+var camper = "James";
+var camper = "David";
+console.log(camper);
+```
+
+У вищезазначеному коді змінна `camper` спочатку була оголошена як `James`, а потім була переписана на `David`. Тому консоль показує рядок `David`.
+
+У невеликому застосунку вам можливо і не загрожуватиме така проблема. Але з поступовим збільшенням кодової бази, ви можете випадково переписати якусь змінну. Оскільки така дія не вважається помилковою, то й знайти та виправити такі похибки буде складніше.
+
+Ключове слово `let` було введено в ES6 (важливе оновлення до JavaScript), щоб потенційно розв'язати цю проблему з ключовим словом `var`. Про інші функції ES6 ви дізнаєтеся у наступних завданнях.
+
+Якщо ви заміните `var` на `let` у коді вище, це призведе до помилки:
+
+```js
+let camper = "James";
+let camper = "David";
+```
+
+Помилку можна побачити у вашій консолі браузера.
+
+Отже, на відміну від `var`, при використанні `let` змінну з такою самою назвою можливо оголосити лише один раз.
+
+# --instructions--
+
+Оновіть код так, щоб використовувалося лише ключове слово `let`.
+
+# --hints--
+
+`var` має бути відсутнім у коді.
+
+```js
+(getUserInput) => assert(!getUserInput('index').match(/var/g));
+```
+
+`catName` має бути рядком `Oliver`.
+
+```js
+assert(catName === 'Oliver');
+```
+
+`catSound` має бути рядком `Meow!`
+
+```js
+assert(catSound === 'Meow!');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+var catName = "Oliver";
+var catSound = "Meow!";
+```
+
+# --solutions--
+
+```js
+let catName = "Oliver";
+let catSound = "Meow!";
+```
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/find-the-length-of-a-string.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/find-the-length-of-a-string.md
@@ -0,0 +1,68 @@
+---
+id: bd7123c9c448eddfaeb5bdef
+title: Знайти довжину рядка
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cvmqEAd'
+forumTopicId: 18182
+dashedName: find-the-length-of-a-string
+---
+
+# --description--
+
+Ви можете знайти довжину `String` значення, написавши `.length` після рядкової змінної або рядкового літералу.
+
+```js
+console.log("Alan Peter".length);
+```
+
+У консолі відображатиметься значення `10`.
+
+Наприклад, якби ми створили змінну `const firstName = "Ada"`, ми б змогли визначити довжину рядка `Ada` за допомогою властивості `firstName.length`.
+
+# --instructions--
+
+Використовуйте властивість `.length`, щоб вирахувати кількість символів у змінній `lastName` і призначити її до `lastNameLength`.
+
+# --hints--
+
+Не слід змінювати оголошення змінних у розділі `// Setup`.
+
+```js
+assert(
+  code.match(/let lastNameLength = 0;/) &&
+    code.match(/const lastName = "Lovelace";/)
+);
+```
+
+`lastNameLength` має дорівнювати вісім.
+
+```js
+assert(typeof lastNameLength !== 'undefined' && lastNameLength === 8);
+```
+
+Ви повинні отримати довжину `lastName`, використовуючи `.length` таким чином: `lastName.length`.
+
+```js
+assert(code.match(/=\s*lastName\.length/g) && !code.match(/lastName\s*=\s*8/));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+// Setup
+let lastNameLength = 0;
+const lastName = "Lovelace";
+
+// Only change code below this line
+lastNameLength = lastName;
+```
+
+# --solutions--
+
+```js
+let lastNameLength = 0;
+const lastName = "Lovelace";
+lastNameLength = lastName.length;
+```
--- 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
@@ -0,0 +1,67 @@
+---
+id: 56533eb9ac21ba0edf2244ae
+title: Пошук залишку в JavaScript
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cWP24Ub'
+forumTopicId: 18184
+dashedName: finding-a-remainder-in-javascript
+---
+
+# --description--
+
+Оператор <dfn>remainder</dfn> `%` надає залишки від ділення двох чисел.
+
+**Приклад**
+
+<blockquote>5 % 2 = 1 тому що <br>Math.floor(5 / 2) = 2 (Коефіцієнт)<br>2 * 2 = 4<br>5 - 4 = 1 (Залишок)</blockquote>
+
+**Usage**  
+В математиці число може бути перевіреним на парність чи непарність шляхом перевірки залишку від ділення числа на `2`.
+
+<blockquote>7 % 2 = 1 (17 є Непарним)<br>48 % 2 = 0 (48 є Парним)</blockquote>
+
+**Примітка:** Оператор <dfn>залишку</dfn> іноді неправильно називають оператором модуля. Він є дуже схожим на модуль, але не працює належним чином з від'ємними числами.
+
+# --instructions--
+
+Встановіть `remainder`, що дорівнює залишку `11` поділеного на `3` використовуючи оператор <dfn>remainder</dfn> (`%`).
+
+# --hints--
+
+Змінна `remainder` повинна бути ініціалізованою
+
+```js
+assert(/(const|let|var)\s+?remainder/.test(code));
+```
+
+Значення `remainder` повинне бути `2`
+
+```js
+assert(remainder === 2);
+```
+
+Вам слід використовувати оператор `%`
+
+```js
+assert(/\s+?remainder\s*?=\s*?.*%.*;?/.test(code));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(y){return 'remainder = '+y;})(remainder);
+```
+
+## --seed-contents--
+
+```js
+const remainder = 0;
+```
+
+# --solutions--
+
+```js
+const remainder = 11 % 3;
+```
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/generate-random-fractions-with-javascript.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/generate-random-fractions-with-javascript.md
@@ -0,0 +1,69 @@
+---
+id: cf1111c1c11feddfaeb9bdef
+title: Генерація випадкових дробів з JavaScript
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cyWJJs3'
+forumTopicId: 18185
+dashedName: generate-random-fractions-with-javascript
+---
+
+# --description--
+
+Випадкові числа є корисними для створення випадкової поведінки об'єкта.
+
+JavaScript має функцію `Math.random()`, що генерує випадкові десяткові числа між `0` (включно) and `1` (виключно). Таким чином `Math.random()` може повернути `0` але ніколи не поверне `1`.
+
+**Примітка:** Як [Storing Values with the Assignment Operator](/learn/javascript-algorithms-and-data-structures/basic-javascript/storing-values-with-the-assignment-operator), всі виклики функцій будуть вирішені до того, як `return` виконується, тому ми можемо повернути значення `return` функції `Math.random()`.
+
+# --instructions--
+
+Змініть `randomFraction`, щоб повернути випадкове число замість повернення `0`.
+
+# --hints--
+
+`randomFraction` має повернути випадкове число.
+
+```js
+assert(typeof randomFraction() === 'number');
+```
+
+Число, яке повернуто `randomFraction` має бути десятковим.
+
+```js
+assert((randomFraction() + '').match(/\./g));
+```
+
+Вам слід використовувати `Math.random` для генерації випадкового десяткового числа.
+
+```js
+assert(code.match(/Math\.random/g).length >= 0);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(){return randomFraction();})();
+```
+
+## --seed-contents--
+
+```js
+function randomFraction() {
+
+  // Only change code below this line
+
+  return 0;
+
+  // Only change code above this line
+}
+```
+
+# --solutions--
+
+```js
+function randomFraction() {
+  return Math.random();
+}
+```
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/generate-random-whole-numbers-with-javascript.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/generate-random-whole-numbers-with-javascript.md
@@ -0,0 +1,90 @@
+---
+id: cf1111c1c12feddfaeb1bdef
+title: Генерація випадкових цілих чисел за допомогою JavaScript
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cRn6bfr'
+forumTopicId: 18186
+dashedName: generate-random-whole-numbers-with-javascript
+---
+
+# --description--
+
+Це чудово, що ми можемо згенерувати випадкові десяткові числа, але більш зручно, якщо ми використаємо їх для генерації випадкових цілих чисел.
+
+<ol><li>Використовуйте <code>Math.random()</code> щоб згенерувати випадкове десяткове число.</li><li>Помножте це випадкое десяткове на <code>20</code>.</li><li>Використайте іншу функцію, <code>Math.floor()</code> щоб заокруглити число до найближчого цілого числа.</li></ol>
+
+Пам'ятайте, що `Math.random()` ніколи не повертає `1`, тому що ми заокруглюємо без можливості отримати `20`. Цей метод видасть нам ціле число від `0` до `19`.
+
+Зіставивши усе разом, ось так виглядає наш код:
+
+```js
+Math.floor(Math.random() * 20);
+```
+
+Ми називаємо `Math.random()`, перемноживши результат на 20, а потім передаємо значення функції `Math.floor()` для заокруглення значення до найближчого цілого числа.
+
+# --instructions--
+
+Використайте цей метод для утворення та повернення випадкового цілого числа від `0` до `9`.
+
+# --hints--
+
+Результат `randomWholeNum` має бути цілим числом.
+
+```js
+assert(
+  typeof randomWholeNum() === 'number' &&
+    (function () {
+      var r = randomWholeNum();
+      return Math.floor(r) === r;
+    })()
+);
+```
+
+Вам слід використовувати `Math.random` для утворення випадкового числа.
+
+```js
+assert(code.match(/Math.random/g).length >= 1);
+```
+
+Ви повинні помножити результат `Math.random` на 10, щоб зробити його числом від 0 до 9.
+
+```js
+assert(
+  code.match(/\s*?Math.random\s*?\(\s*?\)\s*?\*\s*?10[\D]\s*?/g) ||
+    code.match(/\s*?10\s*?\*\s*?Math.random\s*?\(\s*?\)\s*?/g)
+);
+```
+
+Ви повинні використовувати `Math.floor` для видалення десяткової частини числа.
+
+```js
+assert(code.match(/Math.floor/g).length >= 1);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(){return randomWholeNum();})();
+```
+
+## --seed-contents--
+
+```js
+function randomWholeNum() {
+
+  // Only change code below this line
+
+  return Math.random();
+}
+```
+
+# --solutions--
+
+```js
+function randomWholeNum() {
+  return Math.floor(Math.random() * 10);
+}
+```
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/generate-random-whole-numbers-within-a-range.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/generate-random-whole-numbers-within-a-range.md
@@ -0,0 +1,102 @@
+---
+id: cf1111c1c12feddfaeb2bdef
+title: Генерація випадкових цілих чисел в межах діапазону
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cm83yu6'
+forumTopicId: 18187
+dashedName: generate-random-whole-numbers-within-a-range
+---
+
+# --description--
+
+Замість генерації випадкового цілого числа між нулем і даним числом, як ми робили це раніше, ми можемо утворити випадкове ціле число, що потрапляє в діапазон двох конкретних чисел.
+
+Для цього ми визначимо мінімальне число `min` і максимальне число `max`.
+
+Ми будемо використовувати наступну формулу. Зробіть паузу, щоб прочитати і зрозуміти, що робить цей код:
+
+```js
+Math.floor(Math.random() * (max - min + 1)) + min
+```
+
+# --instructions--
+
+Створіть функцію під назвою `randomRange`, яка займає діапазон `myMin` і `myMax` і повертає випадкове ціле число, яке більше або дорівнює `myMin`і менше або дорівнює `myMax`, включно.
+
+# --hints--
+
+Найменше випадкове число, яке можна створити за допомогою `randomRange` має дорівнювати вашому мінімальному числу, `myMin`.
+
+```js
+assert(calcMin === 5);
+```
+
+Найбільше випадкове число, яке можна створити за допомогою `randomRange` має дорівнювати вашому максимальному числу, `myMax`.
+
+```js
+assert(calcMax === 15);
+```
+
+Випадкове число, утворене за допомогою `randomRange` має бути цілим, а не десятковим.
+
+```js
+assert(randomRange(0, 1) % 1 === 0);
+```
+
+`randomRange` повинен використовувати обидва `myMax` та `myMin`, і повертати випадкове число у межах вашого діапазону.
+
+```js
+assert(
+  (function () {
+    if (
+      code.match(/myMax/g).length > 1 &&
+      code.match(/myMin/g).length > 2 &&
+      code.match(/Math.floor/g) &&
+      code.match(/Math.random/g)
+    ) {
+      return true;
+    } else {
+      return false;
+    }
+  })()
+);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+var calcMin = 100;
+var calcMax = -100;
+for(var i = 0; i < 100; i++) {
+  var result = randomRange(5,15);
+  calcMin = Math.min(calcMin, result);
+  calcMax = Math.max(calcMax, result);
+}
+(function(){
+  if(typeof myRandom === 'number') {
+    return "myRandom = " + myRandom;
+  } else {
+    return "myRandom undefined";
+  }
+})()
+```
+
+## --seed-contents--
+
+```js
+function randomRange(myMin, myMax) {
+  // Only change code below this line
+  return 0;
+  // Only change code above this line
+}
+```
+
+# --solutions--
+
+```js
+function randomRange(myMin, myMax) {
+  return Math.floor(Math.random() * (myMax - myMin + 1)) + myMin;
+}
+```
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/global-scope-and-functions.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/global-scope-and-functions.md
@@ -0,0 +1,128 @@
+---
+id: 56533eb9ac21ba0edf2244be
+title: Глобальна область видимості та функції
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cQM7mCN'
+forumTopicId: 18193
+dashedName: global-scope-and-functions
+---
+
+# --description--
+
+У JavaScript, <dfn>область видимості</dfn> стосується видимості змінних. Змінні, які знаходяться за межами функції, мають <dfn>Глобальну</dfn> область видимості. Це означає, що їх можна побачити всюди у вашому коді в JavaScript.
+
+Змінні, які оголошуються без ключових слів `let` чи `const` автоматично створюються в `global` області видимості. Це може створити непередбачувані наслідки десь у вашому коді або при запуску функції знову. Ви повинні завжди визначати свої змінні за допомогою `let` чи `const`.
+
+# --instructions--
+
+Використовуючи `let` чи `const`, визначте глобальну змінну `myGlobal` поза будь-якою функцією. Привласніть їй значення `10`.
+
+Призначте `5` для `oopsGlobal` всередині функції `fun1` ***не*** використовуючи ключове слово `let` чи `const`.
+
+# --hints--
+
+`myGlobal` краще визначити
+
+```js
+assert(typeof myGlobal != 'undefined');
+```
+
+`myGlobal` повинне мати значення `10`
+
+```js
+assert(myGlobal === 10);
+```
+
+Для визначення `myGlobal` потрібно використати ключове слово `let` чи `const`
+
+```js
+assert(/(let|const)\s+myGlobal/.test(code));
+```
+
+`oopsGlobal` має бути глобальною змінною і мати значення `5`
+
+```js
+assert(typeof oopsGlobal != 'undefined' && oopsGlobal === 5);
+```
+
+# --seed--
+
+## --before-user-code--
+
+```js
+var logOutput = "";
+var originalConsole = console
+function capture() {
+    var nativeLog = console.log;
+    console.log = function (message) {
+        logOutput = message;
+        if(nativeLog.apply) {
+          nativeLog.apply(originalConsole, arguments);
+        } else {
+          var nativeMsg = Array.prototype.slice.apply(arguments).join(' ');
+          nativeLog(nativeMsg);
+        }
+    };
+}
+
+function uncapture() {
+  console.log = originalConsole.log;
+}
+var oopsGlobal;
+capture();
+```
+
+## --after-user-code--
+
+```js
+fun1();
+fun2();
+uncapture();
+(function() { return logOutput || "console.log never called"; })();
+```
+
+## --seed-contents--
+
+```js
+// Declare the myGlobal variable below this line
+
+
+function fun1() {
+  // Assign 5 to oopsGlobal Here
+
+}
+
+// Only change code above this line
+
+function fun2() {
+  var output = "";
+  if (typeof myGlobal != "undefined") {
+    output += "myGlobal: " + myGlobal;
+  }
+  if (typeof oopsGlobal != "undefined") {
+    output += " oopsGlobal: " + oopsGlobal;
+  }
+  console.log(output);
+}
+```
+
+# --solutions--
+
+```js
+const myGlobal = 10;
+
+function fun1() {
+  oopsGlobal = 5;
+}
+
+function fun2() {
+  var output = "";
+  if(typeof myGlobal != "undefined") {
+    output += "myGlobal: " + myGlobal;
+  }
+  if(typeof oopsGlobal != "undefined") {
+    output += " oopsGlobal: " + oopsGlobal;
+  }
+  console.log(output);
+}
+```
--- 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
@@ -0,0 +1,77 @@
+---
+id: 56533eb9ac21ba0edf2244c0
+title: Глобальна та Локальна Область видимості в роботі
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/c2QwKH2'
+forumTopicId: 18194
+dashedName: global-vs--local-scope-in-functions
+---
+
+# --description--
+
+<dfn>Локальні</dfn> та <dfn>глобальні</dfn> змінні можна використовувати з одним і тим самим іменем. Коли ви це зробите, локальна змінна має перевагу над глобальною змінною.
+
+У цьому прикладі:
+
+```js
+const someVar = "Hat";
+
+function myFun() {
+  const someVar = "Head";
+  return someVar;
+}
+```
+
+Функція `myFun` поверне рядок `Head`, оскільки присутній місцевий варіант змінної.
+
+# --instructions--
+
+Додайте локальну змінну до функції `myOutfit`, щоб перевизначити значення `outerWear` з рядком `sweater`.
+
+# --hints--
+
+Краще не змінювати значення глобального `outerWear`.
+
+```js
+assert(outerWear === 'T-Shirt');
+```
+
+`myOutfit` має повертати рядок `sweater`.
+
+```js
+assert(myOutfit() === 'sweater');
+```
+
+Не можна змінювати оператор повернення.
+
+```js
+assert(/return outerWear/.test(code));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+// Setup
+const outerWear = "T-Shirt";
+
+function myOutfit() {
+  // Only change code below this line
+
+  // Only change code above this line
+  return outerWear;
+}
+
+myOutfit();
+```
+
+# --solutions--
+
+```js
+const outerWear = "T-Shirt";
+function myOutfit() {
+  const outerWear = "sweater";
+  return outerWear;
+}
+```
--- 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
@@ -0,0 +1,136 @@
+---
+id: 5664820f61c48e80c9fa476c
+title: Golf Code
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/c9ykNUR'
+forumTopicId: 18195
+dashedName: golf-code
+---
+
+# --description--
+
+У грі [гольф](https://en.wikipedia.org/wiki/Golf), кожен отвір має `par`, значення від середньої кількості очікуваних `ударів`, які повинен зробити гравець, щоб потрапити м'ячем у лунку, для завершення гри. Залежно від того, на скільки вище або нижче `par` є ваші `удари`, існують різні псевдоніми.
+
+Ваша функція проходитиме аргументи `par` та `strokes`. Поверніть правильний рядок відповідно до цієї таблиці, яка перелічує удари в порядку пріоритету; зверху (найвищий) до низу (найнижчий):
+
+<table class='table table-striped'><thead><tr><th>Удари</th><th>Відображений результат</th></tr></thead><tbody><tr><td>1</td><td>"В лунку з першого удару"</td></tr><tr><td>&#x3C;= par - 2</td><td>"Орел"</td></tr><tr><td>par - 1</td><td>"Пташка"</td></tr><tr><td>par</td><td>"Середнячок"</td></tr><tr><td>par + 1</td><td>"Страшко"</td></tr><tr><td>par + 2</td><td>"Двічі Страшко"</td></tr><tr><td>>= par + 3</td><td>"Йди додому!"</td></tr></tbody></table>
+
+`par` та `удари` завжди будуть числовими та додатніми. Ми додали масив усіх ваших імен для зручності.
+
+# --hints--
+
+Рахунок `(4, 1)` має виводити стрічку `В лунку з першого удару!`
+
+```js
+assert(golfScore(4, 1) === 'Hole-in-one!');
+```
+
+Рахунок `(4, 2)` має виводити стрічку `Орел`
+
+```js
+assert(golfScore(4, 2) === 'Eagle');
+```
+
+Рахунок `(5, 2)` має виводити стрічку `Орел`
+
+```js
+assert(golfScore(5, 2) === 'Eagle');
+```
+
+Рахунок `(4, 3)` має виводити стрічку `Пташка`
+
+```js
+assert(golfScore(4, 3) === 'Birdie');
+```
+
+Рахунок `(4, 4)` має виводити стрічку `Середнячок`
+
+```js
+assert(golfScore(4, 4) === 'Par');
+```
+
+Рахунок `(1, 1)` має виводити стрічку `В лунку з першого удару!`
+
+```js
+assert(golfScore(1, 1) === 'Hole-in-one!');
+```
+
+Рахунок `(5, 5)` має виводити стрічку `Середнячок`
+
+```js
+assert(golfScore(5, 5) === 'Par');
+```
+
+Рахунок `(4, 5)` має виводити стрічку `Страшко`
+
+```js
+assert(golfScore(4, 5) === 'Bogey');
+```
+
+Рахунок `(4, 6)` має виводити стрічку `Двічі Страшко`
+
+```js
+assert(golfScore(4, 6) === 'Double Bogey');
+```
+
+Рахунок `(4, 7)` має виводити стрічку `Йди додому!`
+
+```js
+assert(golfScore(4, 7) === 'Go Home!');
+```
+
+Рахунок `(5, 9)` має виводити стрічку `Йди додому!`
+
+```js
+assert(golfScore(5, 9) === 'Go Home!');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+const names = ["Hole-in-one!", "Eagle", "Birdie", "Par", "Bogey", "Double Bogey", "Go Home!"];
+
+function golfScore(par, strokes) {
+  // Only change code below this line
+
+
+  return "Change Me";
+  // Only change code above this line
+}
+
+golfScore(5, 4);
+```
+
+# --solutions--
+
+```js
+function golfScore(par, strokes) {
+  if (strokes === 1) {
+    return "Hole-in-one!";
+  }
+
+  if (strokes <= par - 2) {
+    return "Eagle";
+  }
+
+  if (strokes === par - 1) {
+    return "Birdie";
+  }
+
+  if (strokes === par) {
+    return "Par";
+  }
+
+  if (strokes === par + 1) {
+    return "Bogey";
+  }
+
+  if(strokes === par + 2) {
+    return "Double Bogey";
+  }
+
+  return "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
@@ -0,0 +1,80 @@
+---
+id: 56533eb9ac21ba0edf2244ac
+title: Збільшення Числа з JavaScript
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/ca8GLT9'
+forumTopicId: 18201
+dashedName: increment-a-number-with-javascript
+---
+
+# --description--
+
+Ви можете легко <dfn>збільшити</dfn> або додати до змінної з оператором `++`.
+
+```js
+i++;
+```
+
+є еквівалентом
+
+```js
+i = i + 1;
+```
+
+**Note:** Весь рядок стає `i++;`, усуваючи потребу в знаку рівності.
+
+# --instructions--
+
+Змініть код, щоб використовувати оператор `++` у `myVar`.
+
+# --hints--
+
+`myVar` повинен дорівнювати `88`.
+
+```js
+assert(myVar === 88);
+```
+
+Ви не повинні використовувати оператор присвоєння.
+
+```js
+assert(
+  /let\s*myVar\s*=\s*87;\s*\/*.*\s*([+]{2}\s*myVar|myVar\s*[+]{2});/.test(code)
+);
+```
+
+Вам слід використовувати оператор `++`.
+
+```js
+assert(/[+]{2}\s*myVar|myVar\s*[+]{2}/.test(code));
+```
+
+Не слід змінювати код над зазначеним коментарем.
+
+```js
+assert(/let myVar = 87;/.test(code));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(z){return 'myVar = ' + z;})(myVar);
+```
+
+## --seed-contents--
+
+```js
+let myVar = 87;
+
+// Only change code below this line
+myVar = myVar + 1;
+```
+
+# --solutions--
+
+```js
+let myVar = 87;
+myVar++;
+```
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/initializing-variables-with-the-assignment-operator.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/initializing-variables-with-the-assignment-operator.md
@@ -0,0 +1,50 @@
+---
+id: 56533eb9ac21ba0edf2244a9
+title: Ініціалізація Змінних за допомогою Оператора Присвоєння
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cWJ4Bfb'
+forumTopicId: 301171
+dashedName: initializing-variables-with-the-assignment-operator
+---
+
+# --description--
+
+Є загальноприйнятим <dfn>ініціалізувати</dfn> змінну до початкового значення в тому ж рядку, в якому вона була вказана.
+
+```js
+var myVar = 0;
+```
+
+Створіть нову змінну з назвою `myVar` та призначте їй початкове значення `0`.
+
+# --instructions--
+
+Визначте змінну `a` з `var` та ініціалізуйте її до значення `9`.
+
+# --hints--
+
+Вам потрібно ініціалізувати `a` до значення `9`.
+
+```js
+assert(/var\s+a\s*=\s*9(\s*;?\s*)$/.test(code));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+if(typeof a !== 'undefined') {(function(a){return "a = " + a;})(a);} else { (function() {return 'a is undefined';})(); }
+```
+
+## --seed-contents--
+
+```js
+
+```
+
+# --solutions--
+
+```js
+var a = 9;
+```
--- 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
@@ -0,0 +1,114 @@
+---
+id: 56533eb9ac21ba0edf2244db
+title: Поняття про команду Else If
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/caeJ2hm'
+forumTopicId: 18206
+dashedName: introducing-else-if-statements
+---
+
+# --description--
+
+Якщо вам потрібно донести декілька умов, ви можете з'єднати команди з `if` разом з командами `else if`.
+
+```js
+if (num > 15) {
+  return "Bigger than 15";
+} else if (num < 5) {
+  return "Smaller than 5";
+} else {
+  return "Between 5 and 15";
+}
+```
+
+# --instructions--
+
+Перетворіть оператори використовуючи команди `else if`.
+
+# --hints--
+
+Щонайменше потрібно мати дві команди `else`
+
+```js
+assert(code.match(/else/g).length > 1);
+```
+
+Щонайменше потрібно мати дві команди `if`
+
+```js
+assert(code.match(/if/g).length > 1);
+```
+
+Кожен блок коду `if else` повинен мати закриті і відкриті фігурні дужки.
+
+```js
+assert(
+  code.match(
+    /if\s*\((.+)\)\s*\{[\s\S]+\}\s*else\s+if\s*\((.+)\)\s*\{[\s\S]+\}\s*else\s*\{[\s\S]+\s*\}/
+  )
+);
+```
+
+`testElseIf(0)` має повернути рядок `Smaller than 5`
+
+```js
+assert(testElseIf(0) === 'Smaller than 5');
+```
+
+`testElseIf(5)` має повернути рядок `Between 5 and 10`
+
+```js
+assert(testElseIf(5) === 'Between 5 and 10');
+```
+
+`testElseIf(7)` має повернути рядок `Between 5 and 10`
+
+```js
+assert(testElseIf(7) === 'Between 5 and 10');
+```
+
+`testElseIf(10)` має повернути рядок `Between 5 and 10`
+
+```js
+assert(testElseIf(10) === 'Between 5 and 10');
+```
+
+`testElseIf(12)` має повернути рядок `Greater than 10`
+
+```js
+assert(testElseIf(12) === 'Greater than 10');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function testElseIf(val) {
+  if (val > 10) {
+    return "Greater than 10";
+  }
+
+  if (val < 5) {
+    return "Smaller than 5";
+  }
+
+  return "Between 5 and 10";
+}
+
+testElseIf(7);
+```
+
+# --solutions--
+
+```js
+function testElseIf(val) {
+  if(val > 10) {
+    return "Greater than 10";
+  } else if(val < 5) {
+    return "Smaller than 5";
+  } else {
+    return "Between 5 and 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
@@ -0,0 +1,106 @@
+---
+id: 56533eb9ac21ba0edf2244da
+title: Поняття про команду Else
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cek4Efq'
+forumTopicId: 18207
+dashedName: introducing-else-statements
+---
+
+# --description--
+
+Коли умова команди `if` правильна, то наступний блок з кодом виконується. Що ж коли ця умова хибна? Зазвичай нічого не станеться. У випадку `else`, альтернативний блок коду може спрацювати.
+
+```js
+if (num > 10) {
+  return "Bigger than 10";
+} else {
+  return "10 or Less";
+}
+```
+
+# --instructions--
+
+Об’єднайте команди `if` в єдину команду `if/else`.
+
+# --hints--
+
+Ви повинні отримати одну команду `if` у редакторі
+
+```js
+assert(code.match(/if/g).length === 1);
+```
+
+Вам слід використати команду `else`
+
+```js
+assert(/else/g.test(code));
+```
+
+`testElse(4)` повинен видати рядок `5 or Smaller`
+
+```js
+assert(testElse(4) === '5 or Smaller');
+```
+
+`testElse(5)` повинен видати рядок `5 or Smaller`
+
+```js
+assert(testElse(5) === '5 or Smaller');
+```
+
+`testElse(6)` повинен видати рядок `Bigger than 5`
+
+```js
+assert(testElse(6) === 'Bigger than 5');
+```
+
+`testElse(10)` повинен видати рядок `Bigger than 5`
+
+```js
+assert(testElse(10) === 'Bigger than 5');
+```
+
+Не варто змінювати код вище або нижче зазначених коментарів.
+
+```js
+assert(/let result = "";/.test(code) && /return result;/.test(code));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function testElse(val) {
+  let result = "";
+  // Only change code below this line
+
+  if (val > 5) {
+    result = "Bigger than 5";
+  }
+
+  if (val <= 5) {
+    result = "5 or Smaller";
+  }
+
+  // Only change code above this line
+  return result;
+}
+
+testElse(4);
+```
+
+# --solutions--
+
+```js
+function testElse(val) {
+  let result = "";
+  if(val > 5) {
+    result = "Bigger than 5";
+  } else {
+    result = "5 or Smaller";
+  }
+  return result;
+}
+```
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/iterate-odd-numbers-with-a-for-loop.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/iterate-odd-numbers-with-a-for-loop.md
@@ -0,0 +1,69 @@
+---
+id: 56104e9e514f539506016a5c
+title: Ітерація непарних чисел у циклі for
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cm8n7T9'
+forumTopicId: 18212
+dashedName: iterate-odd-numbers-with-a-for-loop
+---
+
+# --description--
+
+Цикли for не повинні повторювати один одного по черзі. При зміні `final-expression`ми можемо порахувати парними числами.
+
+Розпочнемо з `i = 0` та створимо цикл, коли `i < 10`. Збільшуватимемо значення `i` на 2 в кожному циклі при тому, що `i += 2`.
+
+```js
+const ourArray = [];
+
+for (let i = 0; i < 10; i += 2) {
+  ourArray.push(i);
+}
+```
+
+`ourArray` тепер міститиме `[0, 2, 4, 6, 8]`. Тепер змінимо нашу `initialization` так, щоб ми могли рахувати за непарними числами.
+
+# --instructions--
+
+Додайте непарні числа від 1 до 9 до `myArray`, використовуючи цикл `for`.
+
+# --hints--
+
+Для цього потрібно використовувати цикл `for`.
+
+```js
+assert(/for\s*\([^)]+?\)/.test(code));
+```
+
+`myArray` повинне дорівнювати `[1, 3, 5, 7, 9]`.
+
+```js
+assert.deepEqual(myArray, [1, 3, 5, 7, 9]);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+if(typeof myArray !== "undefined"){(function(){return myArray;})();}
+```
+
+## --seed-contents--
+
+```js
+// Setup
+const myArray = [];
+
+// Only change code below this line
+
+```
+
+# --solutions--
+
+```js
+const myArray = [];
+for (let i = 1; i < 10; i += 2) {
+  myArray.push(i);
+}
+```
--- 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
@@ -0,0 +1,81 @@
+---
+id: 5675e877dbd60be8ad28edc6
+title: Ітерація через масив за допомогою циклу For
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/caeR3HB'
+forumTopicId: 18216
+dashedName: iterate-through-an-array-with-a-for-loop
+---
+
+# --description--
+
+Ітерація через вміст масиву є поширеною задачею у JavaScript. Це можна робити за допомогою циклу `for`. Цей код буде виводити кожен елемент масиву `arr` на консоль:
+
+```js
+const arr = [10, 9, 8, 7, 6];
+
+for (let i = 0; i < arr.length; i++) {
+   console.log(arr[i]);
+}
+```
+
+Пам'ятайте, що масиви мають індексацію, яка рахується від нуля і це означає, що останній індекс масиву - це `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`.
+
+# --hints--
+
+`total` повинна бути оголошеною та ініціалізованою до 0.
+
+```js
+assert(code.match(/(var|let|const)\s*?total\s*=\s*0.*?;?/));
+```
+
+`total` повинна дорівнювати 20.
+
+```js
+assert(total === 20);
+```
+
+Слід використовувати цикл `for` для ітерації через `myArr`.
+
+```js
+assert(/for\s*\(/g.test(code) && /myArr\s*\[/g.test(code));
+```
+
+Не потрібно намагатися напряму призначити `total` значення 20.
+
+```js
+assert(!__helpers.removeWhiteSpace(code).match(/total[=+-]0*[1-9]+/gm));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(){if(typeof total !== 'undefined') { return "total = " + total; } else { return "total is undefined";}})()
+```
+
+## --seed-contents--
+
+```js
+// Setup
+const myArr = [2, 3, 4, 5, 6];
+
+// Only change code below this line
+
+```
+
+# --solutions--
+
+```js
+const myArr = [2, 3, 4, 5, 6];
+let total = 0;
+
+for (let i = 0; i < myArr.length; i++) {
+  total += myArr[i];
+}
+```
--- 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
@@ -0,0 +1,105 @@
+---
+id: 5a2efd662fb457916e1fe604
+title: Ітерація з "do...while" циклами, JavaScript
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cDqWGcp'
+forumTopicId: 301172
+dashedName: iterate-with-javascript-do---while-loops
+---
+
+# --description--
+
+Наступний вид циклів, який ви вивчите, називається `do...while` циклом. Він називається `do...while` циклом, тому що, спочатку, не зважаючи ні на що, він `do` (робить) одну передачу коду, а потім продовжує виконувати цикл `while` поки вказана умова обчислюється до `true`.
+
+```js
+const ourArray = [];
+let i = 0;
+
+do {
+  ourArray.push(i);
+  i++;
+} while (i < 5);
+```
+
+Приклад вище поводиться аналогічно з іншими типами циклів, і результуючий масив буде виглядати як `[0, 1, 2, 3, 4]`. Однак, що відрізняє `do...while` від інших циклів, так це те, як він поводиться, коли умова підводить при першій перевірці. Давайте розглянемо це в дії: Ось звичайний `while` цикл, який запустить код за умови, якщо `i < 5`:
+
+```js
+const ourArray = []; 
+let i = 5;
+
+while (i < 5) {
+  ourArray.push(i);
+  i++;
+}
+```
+
+У цьому прикладі ми ініціалізуємо значення `ourArray` до порожнього масиву і значення `i` до 5. Коли ми виконуємо `while` цикл, умова обчислюється до `false`, тому що `i` не менше ніж 5, таким чином ми не виконуємо код всередині циклу. Результатом є те, що до `ourArray` не буде додано ніяких значень і він все ще виглядатиме, як `[]`, коли всі коди, в наведеному вище прикладі, вже завершили роботу. А зараз погляньте на `do...while` цикл:
+
+```js
+const ourArray = []; 
+let i = 5;
+
+do {
+  ourArray.push(i);
+  i++;
+} while (i < 5);
+```
+
+У цьому випадку, ми ініціалізуємо значення `i` до 5, так само, як ми зробили з `while` циклом. Коли ми доходимо до наступного рядка, то бачимо, що умови для обчислення немає. Таким чином, ми рухаємось до коду, що знаходиться у фігурних дужках, і виконуємо його. Ми додамо єдиний елемент до масиву, а потім збільшимо `i` перед тим, як перейти до перевірки умови. Коли ми нарешті обчислимо умову `i < 5` в останньому рядку, ми побачимо, що зараз `i` становить 6, що провалює перевірку умови. Тому, ми виходимо з циклу і завершуємо роботу. Наприкінці наведеного вище прикладу, значення `ourArray` становить `[5]`. В цілому, `do...while` цикл гарантує те, що код всередині циклу буде виконуватися принаймні один раз. Давайте спробуємо підготувати `do...while` цикл до роботи, висуваючи значення до масиву.
+
+# --instructions--
+
+В коді змініть `while` цикл на `do...while` цикл і він висуватиме лише число `10` до `myArray`, а `i` буде дорівнювати `11`, коли код закінчить роботу.
+
+# --hints--
+
+Для цього завдання вам слід використовувати `do...while` цикл.
+
+```js
+assert(code.match(/do/g));
+```
+
+`myArray` повинне дорівнювати `[10]`.
+
+```js
+assert.deepEqual(myArray, [10]);
+```
+
+`i` повинне дорівнювати `11`
+
+```js
+assert.equal(i, 11);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+if(typeof myArray !== "undefined"){(function(){return myArray;})();}
+```
+
+## --seed-contents--
+
+```js
+// Setup
+const myArray = [];
+let i = 10;
+
+// Only change code below this line
+while (i < 5) {
+  myArray.push(i);
+  i++;
+}
+```
+
+# --solutions--
+
+```js
+const myArray = [];
+let i = 10;
+do {
+  myArray.push(i);
+  i++;
+} while (i < 5)
+```
--- 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
@@ -0,0 +1,81 @@
+---
+id: cf1111c1c11feddfaeb5bdef
+title: Ітерація для циклів з JavaScript
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/c9yNVCe'
+forumTopicId: 18219
+dashedName: iterate-with-javascript-for-loops
+---
+
+# --description--
+
+Ви можете виконати один і той самий код декілька разів, використовуючи цикл.
+
+Найбільш поширеним типом JavaScript циклу є `for` цикл, тому що він виконується протягом певної кількості разів.
+
+For-цикли визнано трьома додатковими виразами, які розділені крапкою з комою:
+
+`for (a; b; c)`, де `a` — це твердження ініціалізації, `b` — твердження умови, а `c` — остаточний вираз.
+
+Твердження ініціалізації виконується лише один раз, перед початком циклу. Воно переважно використовується для визначення і налаштування змінної циклу.
+
+Твердження умови обчислюється на початку кожної ітерації циклу і продовжуватиметься до тих пір, поки не обчислиться до `true`. Коли, на початку ітерації, умова становить `false`, цикл припинить виконуватись. Це означає те, що якщо умова починається як "false", ваш цикл ніколи не виконається.
+
+Остаточний вираз виконується наприкінці кожної ітерації циклу, перед перевіркою наступної умови і, зазвичай, використовується для того, щоб збільшити або зменшити лічильник циклу.
+
+У наступному прикладі ми ініціалізуємо та ітеруємо `i = 0` допоки наша умова `i < 5` не буде правильною. Ми збільшимо `i` на `1` у кожній ітерації циклу `i++` у ролі нашого остаточного виразу.
+
+```js
+const ourArray = [];
+
+for (let i = 0; i < 5; i++) {
+  ourArray.push(i);
+}
+```
+
+`ourArray` тепер матиме значення `[0, 1, 2, 3, 4]`.
+
+# --instructions--
+
+Використовуйте `for` цикл для того, щоб перемістити значення 1 через 5 на `myArray`.
+
+# --hints--
+
+Для цього вам слід використовувати `for` цикл.
+
+```js
+assert(/for\s*\([^)]+?\)/.test(code));
+```
+
+`myArray` повинне дорівнювати `[1, 2, 3, 4, 5]`.
+
+```js
+assert.deepEqual(myArray, [1, 2, 3, 4, 5]);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+if (typeof myArray !== "undefined"){(function(){return myArray;})();}
+```
+
+## --seed-contents--
+
+```js
+// Setup
+const myArray = [];
+
+// Only change code below this line
+
+```
+
+# --solutions--
+
+```js
+const myArray = [];
+for (let i = 1; i < 6; i++) {
+  myArray.push(i);
+}
+```
--- 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
@@ -0,0 +1,75 @@
+---
+id: cf1111c1c11feddfaeb1bdef
+title: Ітерація циклів JavaScript
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/c8QbnCM'
+forumTopicId: 18220
+dashedName: iterate-with-javascript-while-loops
+---
+
+# --description--
+
+Завдяки циклу, Ви можете запустити той самий код декілька разів.
+
+Перший тип циклу, який ми вивчатимемо, називається `while`, оскільки виконується за заданою істинною умовою і припиняється, як тільки ця умова більше не буде істинною.
+
+```js
+const ourArray = [];
+let i = 0;
+
+while (i < 5) {
+  ourArray.push(i);
+  i++;
+}
+```
+
+У прикладі вище коду цикл `while` виконуватиметься 5 разів і додаватиме числа від 0 до 4 до `ourArray`.
+
+Спробуймо підготувати цикл while до роботи, розміщуючи значення в масиві даних.
+
+# --instructions--
+
+Додайте числа від 5 до 0 (включно) у порядку спадання до `myArray`, використовуючи цикл `while`.
+
+# --hints--
+
+Для цього слід використовувати цикл `while`.
+
+```js
+assert(code.match(/while/g));
+```
+
+`myArray` повинне дорівнювати `[5, 4, 3, 2, 1, 0]`.
+
+```js
+assert.deepEqual(myArray, [5, 4, 3, 2, 1, 0]);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+if(typeof myArray !== "undefined"){(function(){return myArray;})();}
+```
+
+## --seed-contents--
+
+```js
+// Setup
+const myArray = [];
+
+// Only change code below this line
+
+```
+
+# --solutions--
+
+```js
+const myArray = [];
+let i = 5;
+while (i >= 0) {
+  myArray.push(i);
+  i--;
+}
+```
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/local-scope-and-functions.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/local-scope-and-functions.md
@@ -0,0 +1,86 @@
+---
+id: 56533eb9ac21ba0edf2244bf
+title: Локальна область видимості та функції
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cd62NhM'
+forumTopicId: 18227
+dashedName: local-scope-and-functions
+---
+
+# --description--
+
+Змінні, що є зазначені в межах функції, мають діапазон <dfn>local</dfn>, так як і параметри функції. Це означає, що вони є видимими лише в межах цієї функції.
+
+Це функція `myTest` з локальною змінною `loc`.
+
+```js
+function myTest() {
+  const loc = "foo";
+  console.log(loc);
+}
+
+myTest();
+console.log(loc);
+```
+
+Виклик функції `myTest()` відображатиме рядок `foo` в консолі. Рядок `console.log(loc)` видасть помилку, тому що `loc` не є визначеним за діапазоном функції.
+
+# --instructions--
+
+Редактор має два `console.log` щоб допомогти вам побачити, що відбувається. Позначте консоль як ваш код, щоб побачити як вона змінюється. Зазначте локальну змінну e `myVar` всередині `myLocalScope` і запустіть тест.
+
+Консоль **Note:** все ще відображатиме `ReferenceError: myVar is not defined`, але це не спричинить збій тестувань.
+
+# --hints--
+
+Код не повинен містити глобальну змінну `myVar`.
+
+```js
+function declared() {
+  myVar;
+}
+
+assert.throws(declared, ReferenceError);
+```
+
+Вам слід додати локальну змінну `myVar`.
+
+```js
+assert(
+  /functionmyLocalScope\(\)\{.*(var|let|const)myVar[\s\S]*}/.test(
+    __helpers.removeWhiteSpace(code)
+  )
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function myLocalScope() {
+  // Only change code below this line
+
+  console.log('inside myLocalScope', myVar);
+}
+myLocalScope();
+
+// Run and check the console
+// myVar is not defined outside of myLocalScope
+console.log('outside myLocalScope', myVar);
+```
+
+# --solutions--
+
+```js
+function myLocalScope() {
+  // Only change code below this line
+  let myVar;
+  console.log('inside myLocalScope', myVar);
+}
+myLocalScope();
+
+// Run and check the console
+// myVar is not defined outside of myLocalScope
+console.log('outside myLocalScope', myVar);
+```
--- 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
@@ -0,0 +1,109 @@
+---
+id: 5690307fddb111c6084545d7
+title: Логічна послідовність в команді If Else
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cwNvMUV'
+forumTopicId: 18228
+dashedName: logical-order-in-if-else-statements
+---
+
+# --description--
+
+Послідовність є важливою в командах `if` та `else if`.
+
+Функція виконується зверху до низу, тому уважно перевірте, яке речення стоїть першим.
+
+Візьмемо ці дві функції як приклад.
+
+Перша:
+
+```js
+function foo(x) {
+  if (x < 1) {
+    return "Less than one";
+  } else if (x < 2) {
+    return "Less than two";
+  } else {
+    return "Greater than or equal to two";
+  }
+}
+```
+
+А друга лише міняє порядок команд:
+
+```js
+function bar(x) {
+  if (x < 2) {
+    return "Less than two";
+  } else if (x < 1) {
+    return "Less than one";
+  } else {
+    return "Greater than or equal to two";
+  }
+}
+```
+
+Оскільки ці дві функції виглядають майже однаково, навіть якщо ми надаємо однакове число обом, то отримуємо різні результати.
+
+```js
+foo(0)
+bar(0)
+```
+
+`foo(0)` видаватиме рядок `Less than one`, і `bar(0)` видаватиме рядок `Less than two`.
+
+# --instructions--
+
+Змініть логічну послідовність функції так, щоб вона видавала правильні команди у всіх випадках.
+
+# --hints--
+
+`orderMyLogic(4)` має видати рядок `Less than 5`
+
+```js
+assert(orderMyLogic(4) === 'Less than 5');
+```
+
+`orderMyLogic(6)` має видати рядок `Less than 10`
+
+```js
+assert(orderMyLogic(6) === 'Less than 10');
+```
+
+`orderMyLogic(11)` має видати рядок `Greater than or equal to 10`
+
+```js
+assert(orderMyLogic(11) === 'Greater than or equal to 10');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function orderMyLogic(val) {
+  if (val < 10) {
+    return "Less than 10";
+  } else if (val < 5) {
+    return "Less than 5";
+  } else {
+    return "Greater than or equal to 10";
+  }
+}
+
+orderMyLogic(7);
+```
+
+# --solutions--
+
+```js
+function orderMyLogic(val) {
+  if(val < 5) {
+    return "Less than 5";
+  } else if (val < 10) {
+    return "Less than 10";
+  } else {
+    return "Greater than or equal to 10";
+  }
+}
+```
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/manipulate-arrays-with-pop.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/manipulate-arrays-with-pop.md
@@ -0,0 +1,90 @@
+---
+id: 56bbb991ad1ed5201cd392cc
+title: Керування масивами за допомогою pop()
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cRbVZAB'
+forumTopicId: 18236
+dashedName: manipulate-arrays-with-pop
+---
+
+# --description--
+
+Іншим способом змінити дані у масиві можна за допомогою функції `.pop()`.
+
+`.pop()` використовується для виведення значення з кінця масиву. Ми можемо зберігати значення, яке виводиться, присвоюючи його змінній. Іншими словами, `.pop()` видаляє останній елемент з масиву і повертає цей елемент.
+
+Будь-який тип запису може бути виведений з масиву - цифри, рядки, навіть вкладені масиви.
+
+```js
+const threeArr = [1, 4, 6];
+const oneDown = threeArr.pop();
+console.log(oneDown);
+console.log(threeArr);
+```
+
+Перший `console.log` відображатиме значення `6`, а другий - значення `[1, 4]`.
+
+# --instructions--
+
+Використовуйте функцію `.pop()`, щоб видалити останній елемент з `myArray` та призначити значення, яке виводиться для `removedFromMyArray`.
+
+# --hints--
+
+`myArray` повинен містити лише `[["John", 23]]`.
+
+```js
+assert(
+  (function (d) {
+    if (d[0][0] == 'John' && d[0][1] === 23 && d[1] == undefined) {
+      return true;
+    } else {
+      return false;
+    }
+  })(myArray)
+);
+```
+
+Вам слід використовувати `pop()` на `myArray`.
+
+```js
+assert(/removedFromMyArray\s*=\s*myArray\s*.\s*pop\s*(\s*)/.test(code));
+```
+
+`removedFromMyArray` повинен містити лише `["cat", 2]`.
+
+```js
+assert(
+  (function (d) {
+    if (d[0] == 'cat' && d[1] === 2 && d[2] == undefined) {
+      return true;
+    } else {
+      return false;
+    }
+  })(removedFromMyArray)
+);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+if (typeof removedFromMyArray !== 'undefined') (function(y, z){return 'myArray = ' + JSON.stringify(y) + ' & removedFromMyArray = ' + JSON.stringify(z);})(myArray, removedFromMyArray);
+```
+
+## --seed-contents--
+
+```js
+// Setup
+const myArray = [["John", 23], ["cat", 2]];
+
+// Only change code below this line
+
+```
+
+# --solutions--
+
+```js
+const myArray = [["John", 23], ["cat", 2]];
+const removedFromMyArray = myArray.pop();
+```
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/manipulate-arrays-with-push.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/manipulate-arrays-with-push.md
@@ -0,0 +1,78 @@
+---
+id: 56bbb991ad1ed5201cd392cb
+title: Керування масивами за допомогою push()
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cnqmVtJ'
+forumTopicId: 18237
+dashedName: manipulate-arrays-with-push
+---
+
+# --description--
+
+Найпростіший спосіб додати дані до кінця масиву - це використати функцію `push()`.
+
+`.push()` приймає один або більше <dfn>parameters</dfn> і "виштовхує" їх в кінець масиву.
+
+Приклади:
+
+```js
+const arr1 = [1, 2, 3];
+arr1.push(4);
+
+const arr2 = ["Stimpson", "J", "cat"];
+arr2.push(["happy", "joy"]);
+```
+
+`arr1` зараз набуває значення `[1, 2, 3, 4]` та `arr2` набуває значення `["Stimpson", "J", "cat", ["happy", "joy"]]`.
+
+# --instructions--
+
+Виштовхніть `["dog", 3]` в кінець змінної `myArray`.
+
+# --hints--
+
+`myArray` тепер має дорівнювати `[["John", 23], ["cat", 2], ["dog", 3]]`.
+
+```js
+assert(
+  (function (d) {
+    if (
+      d[2] != undefined &&
+      d[0][0] == 'John' &&
+      d[0][1] === 23 &&
+      d[2][0] == 'dog' &&
+      d[2][1] === 3 &&
+      d[2].length == 2
+    ) {
+      return true;
+    } else {
+      return false;
+    }
+  })(myArray)
+);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(z){return 'myArray = ' + JSON.stringify(z);})(myArray);
+```
+
+## --seed-contents--
+
+```js
+// Setup
+const myArray = [["John", 23], ["cat", 2]];
+
+// Only change code below this line
+
+```
+
+# --solutions--
+
+```js
+const myArray = [["John", 23], ["cat", 2]];
+myArray.push(["dog",3]);
+```
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/manipulate-arrays-with-shift.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/manipulate-arrays-with-shift.md
@@ -0,0 +1,88 @@
+---
+id: 56bbb991ad1ed5201cd392cd
+title: Керування масивами за допомогою shift()
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cRbVETW'
+forumTopicId: 18238
+dashedName: manipulate-arrays-with-shift
+---
+
+# --description--
+
+`pop()` завжди видаляє останній елемент масиву. А якщо ти хочеш видалити перший?
+
+Саме тут нам на допомогу може прийти `.shift()`. Це працює точно так як `.pop()`, за винятком того, що видаляє перший елемент замість останнього.
+
+Наприклад:
+
+```js
+const ourArray = ["Stimpson", "J", ["cat"]];
+const removedFromOurArray = ourArray.shift();
+```
+
+`removedFromOurArray` матиме значення рядка `Stimpson` та `ourArray` отримає `["J", ["cat"]]`.
+
+# --instructions--
+
+Використовуйте функцію `.shift()`, щоб видалити перший елемент з `myArray` та призначивши значення "викреслено" для нової змінної `removedFromMyArray`.
+
+# --hints--
+
+`myArray` має дорівнювати `[["dog", 3]]`.
+
+```js
+assert(
+  (function (d) {
+    if (d[0][0] == 'dog' && d[0][1] === 3 && d[1] == undefined) {
+      return true;
+    } else {
+      return false;
+    }
+  })(myArray)
+);
+```
+
+`removedFromMyArray` повинен містити `["John", 23]`.
+
+```js
+assert(
+  (function (d) {
+    if (
+      d[0] == 'John' &&
+      d[1] === 23 &&
+      typeof removedFromMyArray === 'object'
+    ) {
+      return true;
+    } else {
+      return false;
+    }
+  })(removedFromMyArray)
+);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+if (typeof removedFromMyArray !== 'undefined') (function(y, z){return 'myArray = ' + JSON.stringify(y) + ' & removedFromMyArray = ' + JSON.stringify(z);})(myArray, removedFromMyArray);
+```
+
+## --seed-contents--
+
+```js
+// Setup
+const myArray = [["John", 23], ["dog", 3]];
+
+// Only change code below this line
+
+```
+
+# --solutions--
+
+```js
+const myArray = [["John", 23], ["dog", 3]];
+
+// Only change code below this line
+const removedFromMyArray = myArray.shift();
+```
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/manipulate-arrays-with-unshift.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/manipulate-arrays-with-unshift.md
@@ -0,0 +1,79 @@
+---
+id: 56bbb991ad1ed5201cd392ce
+title: Керування масивами за допомогою unshift()
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/ckNDESv'
+forumTopicId: 18239
+dashedName: manipulate-arrays-with-unshift
+---
+
+# --description--
+
+Ви можете не лише `shift` елементи з початку масиву, ви також можете `unshift` елементи на початок масиву, тобто додати елементи перед масивом.
+
+`.unshift()` працює в точності як `.push()`, але замість додавання елемента в кінець масиву, `unshift()` додає елемент на початку масиву.
+
+Наприклад:
+
+```js
+const ourArray = ["Stimpson", "J", "cat"];
+ourArray.shift();
+ourArray.unshift("Happy");
+```
+
+Після `shift`, `ourArray` матиме значення `["J", "cat"]`. Після `unshift`, `ourArray` матиме значення `["Happy", "J", "cat"]`.
+
+# --instructions--
+
+Додайте `["Paul", 35]` на початок змінної `myArray`, використовуючи `unshift()`.
+
+# --hints--
+
+`myArray` тепер має мати `[["Paul", 35], ["dog", 3]]`.
+
+```js
+assert(
+  (function (d) {
+    if (
+      typeof d[0] === 'object' &&
+      d[0][0] == 'Paul' &&
+      d[0][1] === 35 &&
+      d[1][0] != undefined &&
+      d[1][0] == 'dog' &&
+      d[1][1] != undefined &&
+      d[1][1] == 3
+    ) {
+      return true;
+    } else {
+      return false;
+    }
+  })(myArray)
+);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(y, z){return 'myArray = ' + JSON.stringify(y);})(myArray);
+```
+
+## --seed-contents--
+
+```js
+// Setup
+const myArray = [["John", 23], ["dog", 3]];
+myArray.shift();
+
+// Only change code below this line
+
+```
+
+# --solutions--
+
+```js
+const myArray = [["John", 23], ["dog", 3]];
+myArray.shift();
+myArray.unshift(["Paul", 35]);
+```
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/manipulating-complex-objects.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/manipulating-complex-objects.md
@@ -0,0 +1,179 @@
+---
+id: 56533eb9ac21ba0edf2244cb
+title: Керування складними об'єктами
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/c9yNMfR'
+forumTopicId: 18208
+dashedName: manipulating-complex-objects
+---
+
+# --description--
+
+Іноді ви можете зберігати дані в гнучкій <dfn>Data Structure</dfn>. Об'єкт JavaScript є одним із способів обробки гнучких даних. Вони створюють можливість довільних комбінацій <dfn>strings</dfn>, <dfn>numbers</dfn>, <dfn>booleans</dfn>, <dfn>arrays</dfn>, <dfn>functions</dfn> та <dfn>objects</dfn>.
+
+Ось приклад структури складних даних:
+
+```js
+const ourMusic = [
+  {
+    "artist": "Daft Punk",
+    "title": "Homework",
+    "release_year": 1997,
+    "formats": [ 
+      "CD", 
+      "Cassette", 
+      "LP"
+    ],
+    "gold": true
+  }
+];
+```
+
+Це масив, який містить один об'єкт всередині. Об'єкт має різні частини <dfn>metadata</dfn> про альбом. Він також має вкладений масив `formats`. Якщо ви хочете додати більше записів в альбом, це можна зробити, додавши записи до масиву верхнього рівня. Об'єкти зберігають дані у властивості, яка має формат ключ-значення. У прикладі вище, `"artist": "Daft Punk"` - це властивість, що має ключ `artist` і значення `Daft Punk`. [JavaScript Object Notation](http://www.json.org/) або `JSON` є форматом відповідного обміну даними, який використовується для зберігання даних.
+
+```json
+{
+  "artist": "Daft Punk",
+  "title": "Homework",
+  "release_year": 1997,
+  "formats": [ 
+    "CD",
+    "Cassette",
+    "LP"
+  ],
+  "gold": true
+}
+```
+
+**Примітка:** Вам потрібно буде розмістити кому після кожного об'єкта в масиві, якщо він не є останнім його об'єктом.
+
+# --instructions--
+
+Додайте новий альбом до масиву `myMusic`. Додайте `artist` та `title` рядки, `release_year` число та масив рядків `formats`.
+
+# --hints--
+
+`myMusic` повинен бути масивом
+
+```js
+assert(Array.isArray(myMusic));
+```
+
+`myMusic` має мати принаймні два елементи
+
+```js
+assert(myMusic.length > 1);
+```
+
+Елементи у масиві `myMusic` повинні бути об'єктами
+
+```js
+myMusic.forEach(object => {assert.typeOf(object, 'object')})
+```
+
+Ваш об'єкт в `myMusic` повинен мати щонайменше 4 властивості
+
+```js
+myMusic.forEach(object => {assert(Object.keys(object).length > 3); });
+```
+
+Ваш об'єкт в `myMusic` повинен містити властивість `artist`, яка належить до типу string
+
+```js
+myMusic.forEach(object => {
+  assert.containsAllKeys(object, ['artist']);
+  assert.typeOf(object.artist, 'string')
+})
+```
+
+Ваш об'єкт в `myMusic` повинен містити властивість `title`, яка належить до типу string
+
+```js
+myMusic.forEach(object => {
+  assert.containsAllKeys(object, ['title']);
+  assert.typeOf(object.title, 'string')
+})
+```
+
+Ваш об'єкт в `myMusic` повинен містити властивість `release_year`, яка належить до типу number
+
+```js
+myMusic.forEach(object => {
+  assert.containsAllKeys(object, ['release_year']);
+  assert.typeOf(object.release_year, 'number')
+})
+```
+
+Ваш об'єкт у `myMusic` повинен містити властивість `formats`, яка є масивом
+
+```js
+myMusic.forEach(object => {
+  assert.containsAllKeys(object, ['formats']);
+  assert.typeOf(object.formats, 'array')
+})
+```
+
+`formats` повинен бути масивом рядків з щонайменше двома елементами
+
+```js
+myMusic.forEach(object => {
+  object.formats.forEach(format => {
+    assert.typeOf(format, 'string')
+  });
+  assert.isAtLeast(object.formats.length, 2)
+})
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(x){ if (Array.isArray(x)) { return JSON.stringify(x); } return "myMusic is not an array"})(myMusic);
+```
+
+## --seed-contents--
+
+```js
+const myMusic = [
+  {
+    "artist": "Billy Joel",
+    "title": "Piano Man",
+    "release_year": 1973,
+    "formats": [
+      "CD",
+      "8T",
+      "LP"
+    ],
+    "gold": true
+  }
+];
+```
+
+# --solutions--
+
+```js
+const myMusic = [
+  {
+    "artist": "Billy Joel",
+    "title": "Piano Man",
+    "release_year": 1973,
+    "formats": [
+      "CS",
+      "8T",
+      "LP" ],
+    "gold": true
+  },
+  {
+    "artist": "ABBA",
+    "title": "Ring Ring",
+    "release_year": 1973,
+    "formats": [
+      "CS",
+      "8T",
+      "LP",
+    "CD",
+  ]
+  }
+];
+```
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/modify-array-data-with-indexes.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/modify-array-data-with-indexes.md
@@ -0,0 +1,87 @@
+---
+id: cf1111c1c11feddfaeb8bdef
+title: Зміна даних масиву за допомогою індексів
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/czQM4A8'
+forumTopicId: 18241
+dashedName: modify-array-data-with-indexes
+---
+
+# --description--
+
+На відміну від рядків, записи масиву <dfn>можуть бути змінювані</dfn>, навіть якщо масив був оголошений з `const`.
+
+**Наприклад:**
+
+```js
+const ourArray = [50, 40, 30];
+ourArray[0] = 15;
+```
+
+`ourArray` має значення `[15, 40, 30]`.
+
+**Примітка:** ніколи не вставляйте пробіл між іменем масиву і квадратними дужками, наприклад `array [0]`. Хоча JavaScript прочитає це правильно, але це може створити труднощі для інших програмістів, які читатимуть ваш код.
+
+# --instructions--
+
+Змінюйте дані, що зберігаються в індексі `0` масиву `myArray` до значення `45`.
+
+# --hints--
+
+`myArray` тепер повинен бути `[45, 64, 99]`.
+
+```js
+assert(
+  (function () {
+    if (
+      typeof myArray != 'undefined' &&
+      myArray[0] == 45 &&
+      myArray[1] == 64 &&
+      myArray[2] == 99
+    ) {
+      return true;
+    } else {
+      return false;
+    }
+  })()
+);
+```
+
+Слід використовувати правильний індекс для зміни значення у `myArray`.
+
+```js
+assert(
+  (function () {
+    if (code.match(/myArray\[0\]\s*=\s*/g)) {
+      return true;
+    } else {
+      return false;
+    }
+  })()
+);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+if(typeof myArray !== "undefined"){(function(){return myArray;})();}
+```
+
+## --seed-contents--
+
+```js
+// Setup
+const myArray = [18, 64, 99];
+
+// Only change code below this line
+
+```
+
+# --solutions--
+
+```js
+const myArray = [18, 64, 99];
+myArray[0] = 45;
+```
--- 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
@@ -0,0 +1,149 @@
+---
+id: 56533eb9ac21ba0edf2244df
+title: Кілька ідентичних параметрів у інструкціях перемикання
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cdBKWCV'
+forumTopicId: 18242
+dashedName: multiple-identical-options-in-switch-statements
+---
+
+# --description--
+
+Якщо команда `break` не включена в `switch` команди `case`, наступна (і) команди `case` буде виконуватись до тих пір поки `break` не буде виконано. Якщо у вас є кілька входів з одним і тим же виходом, ви можете подати їх в `switch` такої команди як ця:
+
+```js
+let result = "";
+switch(val) {
+  case 1:
+  case 2:
+  case 3:
+    result = "1, 2, or 3";
+    break;
+  case 4:
+    result = "4 alone";
+}
+```
+
+Кейси 1,2,3 дадуть один і той же результат.
+
+# --instructions--
+
+Запис інструкції перемикача для установки `answer` для наступних діапазонів:   
+`1-3` - `Low`  
+`4-6` - `Mid`  
+`7-9` - `High`
+
+**Note:** Ви повинні мати `case` для кожного числа в діапазоні.
+
+# --hints--
+
+`sequentialSizes(1)` перетворюється на `Low`
+
+```js
+assert(sequentialSizes(1) === 'Low');
+```
+
+`sequentialSizes(2)` змінюється на `Low`
+
+```js
+assert(sequentialSizes(2) === 'Low');
+```
+
+`sequentialSizes(3)` змінюється на `Low`
+
+```js
+assert(sequentialSizes(3) === 'Low');
+```
+
+`sequentialSizes(4)` перетворюється на `Mid`
+
+```js
+assert(sequentialSizes(4) === 'Mid');
+```
+
+`sequentialSizes(5)` перетворюється на `Mid`
+
+```js
+assert(sequentialSizes(5) === 'Mid');
+```
+
+`sequentialSizes(6)` перетворюється на `Mid`
+
+```js
+assert(sequentialSizes(6) === 'Mid');
+```
+
+`sequentialSizes(7)` перетворюється на `High`
+
+```js
+assert(sequentialSizes(7) === 'High');
+```
+
+`sequentialSizes(8)` перетворюється на `High`
+
+```js
+assert(sequentialSizes(8) === 'High');
+```
+
+`sequentialSizes(9)` перетворюється на `High`
+
+```js
+assert(sequentialSizes(9) === 'High');
+```
+
+Ви не повинні використовувати будь які `if` або `else` команди
+
+```js
+assert(!/else/g.test(code) || !/if/g.test(code));
+```
+
+У вас має бути дев'ять `case` команд
+
+```js
+assert(code.match(/case/g).length === 9);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function sequentialSizes(val) {
+  let answer = "";
+  // Only change code below this line
+
+
+
+  // Only change code above this line
+  return answer;
+}
+
+sequentialSizes(1);
+```
+
+# --solutions--
+
+```js
+function sequentialSizes(val) {
+  let answer = "";
+
+  switch(val) {
+    case 1:
+    case 2:
+    case 3:
+      answer = "Low";
+      break;
+    case 4:
+    case 5:
+    case 6:
+      answer = "Mid";
+      break;
+    case 7:
+    case 8:
+    case 9:
+      answer = "High";
+  }
+
+  return answer;
+}
+```
--- 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
@@ -0,0 +1,52 @@
+---
+id: bd7993c9c69feddfaeb7bdef
+title: Множення двох десяткових чисел за допомогою JavaScript
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/ce2GeHq'
+forumTopicId: 301173
+dashedName: multiply-two-decimals-with-javascript
+---
+
+# --description--
+
+У JavaScript, ви можете здійснювати розрахунки як з десятковими числами, так і цілими числами.
+
+Перемножимо два десяткових числа, щоб отримати їх добуток.
+
+# --instructions--
+
+Змініть `0.0` так, щоб добуток дорівнював `5.0`.
+
+# --hints--
+
+Змінна `product` повинна дорівнювати `5.0`.
+
+```js
+assert(product === 5.0);
+```
+
+Вам слід використовувати оператор `*`
+
+```js
+assert(/\*/.test(code));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(y){return 'product = '+y;})(product);
+```
+
+## --seed-contents--
+
+```js
+const product = 2.0 * 0.0;
+```
+
+# --solutions--
+
+```js
+const product = 2.0 * 2.5;
+```
--- 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
@@ -0,0 +1,60 @@
+---
+id: cf1231c1c11feddfaeb5bdef
+title: Множення двох чисел за допомогою JavaScript
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cP3y3Aq'
+forumTopicId: 18243
+dashedName: multiply-two-numbers-with-javascript
+---
+
+# --description--
+
+Ми також можемо множити одне число на інше.
+
+JavaScript використовує символ `*` для множення двох чисел.
+
+**Приклад**
+
+```js
+const myVar = 13 * 13;
+```
+
+`myVar` мало б значення `169`.
+
+# --instructions--
+
+Змініть `0` так, щоб добуток дорівнював `80`.
+
+# --hints--
+
+Змінна `product` повинна дорівнювати 80.
+
+```js
+assert(product === 80);
+```
+
+Ви маєте використати оператор `*`.
+
+```js
+assert(/\*/.test(code));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(z){return 'product = '+z;})(product);
+```
+
+## --seed-contents--
+
+```js
+const product = 8 * 0;
+```
+
+# --solutions--
+
+```js
+const product = 8 * 10;
+```
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/nest-one-array-within-another-array.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/nest-one-array-within-another-array.md
@@ -0,0 +1,51 @@
+---
+id: cf1111c1c11feddfaeb7bdef
+title: Вкладіть один масив всередину іншого масиву
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/crZQZf8'
+forumTopicId: 18247
+dashedName: nest-one-array-within-another-array
+---
+
+# --description--
+
+Ви також можете вкладати масиви всередину інших масивів, як це показано нижче:
+
+```js
+const teams = [["Bulls", 23], ["White Sox", 45]];
+```
+
+Це також називається <dfn>багатовимірний масив</dfn>.
+
+# --instructions--
+
+Створіть вкладений масив під назвою `myArray`.
+
+# --hints--
+
+`myArray` повинен мати щонайменше один масив, вкладений в інший масив.
+
+```js
+assert(Array.isArray(myArray) && myArray.some(Array.isArray));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+if(typeof myArray !== "undefined"){(function(){return myArray;})();}
+```
+
+## --seed-contents--
+
+```js
+// Only change code below this line
+const myArray = [];
+```
+
+# --solutions--
+
+```js
+const myArray = [[1, 2, 3]];
+```
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/nesting-for-loops.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/nesting-for-loops.md
@@ -0,0 +1,92 @@
+---
+id: 56533eb9ac21ba0edf2244e1
+title: Вкладення для циклів
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cRn6GHM'
+forumTopicId: 18248
+dashedName: nesting-for-loops
+---
+
+# --description--
+
+Якщо ви маєте багатовимірний масив, ви можете використати ту ж логіку, що і в попередній точці проходження до циклу через масив і будь-які підмасиви. Ось приклад:
+
+```js
+const arr = [
+  [1, 2], [3, 4], [5, 6]
+];
+
+for (let i = 0; i < arr.length; i++) {
+  for (let j = 0; j < arr[i].length; j++) {
+    console.log(arr[i][j]);
+  }
+}
+```
+
+Це виводить кожен піделемент у `arr` по одному. Зверніть увагу, що для внутрішнього циклу ми перевіряємо `.length` цього `arr[i]`, оскільки `arr[i]` і є масивом.
+
+# --instructions--
+
+Змініть функцію `multiplyAll` для того, щоб повернути добуток усіх чисел у підмасивах `arr`.
+
+# --hints--
+
+`multiplyAll([[1], [2], [3]])` повинен повернути `6`
+
+```js
+assert(multiplyAll([[1], [2], [3]]) === 6);
+```
+
+`multiplyAll([[1, 2], [3, 4], [5, 6, 7]])` повинен повернути `5040`
+
+```js
+assert(
+  multiplyAll([
+    [1, 2],
+    [3, 4],
+    [5, 6, 7]
+  ]) === 5040
+);
+```
+
+`multiplyAll([[5, 1], [0.2, 4, 0.5], [3, 9]])` повинен повернути `54`
+
+```js
+assert(
+  multiplyAll([
+    [5, 1],
+    [0.2, 4, 0.5],
+    [3, 9]
+  ]) === 54
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function multiplyAll(arr) {
+  let product = 1;
+  // Only change code below this line
+
+  // Only change code above this line
+  return product;
+}
+
+multiplyAll([[1, 2], [3, 4], [5, 6, 7]]);
+```
+
+# --solutions--
+
+```js
+function multiplyAll(arr) {
+  let product = 1;
+  for (let i = 0; i < arr.length; i++) {
+    for (let j = 0; j < arr[i].length; j++) {
+      product *= arr[i][j];
+    }
+  }
+  return product;
+}
+```
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/passing-values-to-functions-with-arguments.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/passing-values-to-functions-with-arguments.md
@@ -0,0 +1,120 @@
+---
+id: 56533eb9ac21ba0edf2244bd
+title: Передача значень до функцій з аргументами
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cy8rahW'
+forumTopicId: 18254
+dashedName: passing-values-to-functions-with-arguments
+---
+
+# --description--
+
+<dfn>Параметри</dfn> - це змінні, які діють як місця для заповнення тих значень, які вводяться у функцію під час її виклику. Коли функцію визначають, її зазвичай визначають разом з одним або декількома параметрами. Реальні значення, які введені (або <dfn>"передані"</dfn>) до функції під час її виклику, називаються <dfn>аргументами</dfn>.
+
+Ось функція з двома параметрами, `param1` and `param2`:
+
+```js
+function testFun(param1, param2) {
+  console.log(param1, param2);
+}
+```
+
+Потім ми можемо викликати `testFun`, отак: `testFun("Hello", "World");`. Ми передали два рядкові аргументи: `Hello` and `World`. Всередині функції, `param1` дорівнюватиме рядку `Hello`, а `param2` дорівнюватиме рядку `World`. Зверніть увагу на те, що ви можете викликати `testFun` знову, використовуючи різні аргументи та параметри, які візьмуть значення нових аргументів.
+
+# --instructions--
+
+<ol><li>Створіть функцію з назвою <code>functionWithArgs</code>, яка приймає 2 аргументи і виводить їхню суму в dev-консоль.</li><li>Викличте функцію з двома числами так, як аргументи.</li></ol>
+
+# --hints--
+
+`functionWithArgs` має бути функцією.
+
+```js
+assert(typeof functionWithArgs === 'function');
+```
+
+`functionWithArgs(1,2)` має вивести `3`.
+
+```js
+if (typeof functionWithArgs === 'function') {
+  capture();
+  functionWithArgs(1, 2);
+  uncapture();
+}
+assert(logOutput == 3);
+```
+
+`functionWithArgs(7,9)` має вивести `16`.
+
+```js
+if (typeof functionWithArgs === 'function') {
+  capture();
+  functionWithArgs(7, 9);
+  uncapture();
+}
+assert(logOutput == 16);
+```
+
+Вам слід викликати `functionWithArgs` з двома числами після того як визначите його.
+
+```js
+assert(
+  /functionWithArgs\([-+]?\d*\.?\d*,[-+]?\d*\.?\d*\)/.test(
+    code.replace(/\s/g, '')
+  )
+);
+```
+
+# --seed--
+
+## --before-user-code--
+
+```js
+var logOutput = "";
+var originalConsole = console
+function capture() {
+    var nativeLog = console.log;
+    console.log = function (message) {
+        if(message) logOutput = JSON.stringify(message).trim();
+        if(nativeLog.apply) {
+          nativeLog.apply(originalConsole, arguments);
+        } else {
+          var nativeMsg = Array.prototype.slice.apply(arguments).join(' ');
+          nativeLog(nativeMsg);
+        }
+    };
+}
+
+function uncapture() {
+  console.log = originalConsole.log;
+}
+
+capture();
+```
+
+## --after-user-code--
+
+```js
+uncapture();
+
+if (typeof functionWithArgs !== "function") { 
+  (function() { return "functionWithArgs is not defined"; })();
+} else {
+  (function() { return logOutput || "console.log never called"; })();
+}
+```
+
+## --seed-contents--
+
+```js
+
+```
+
+# --solutions--
+
+```js
+function functionWithArgs(a, b) {
+  console.log(a + b);
+}
+functionWithArgs(10, 5);
+```
--- 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
@@ -0,0 +1,78 @@
+---
+id: 599a789b454f2bbd91a3ff4d
+title: Вчіться порівнювати різні значення
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cm8PqCa'
+forumTopicId: 301174
+dashedName: practice-comparing-different-values
+---
+
+# --description--
+
+В останніх двох задачах, ми вивчили оператор рівності (`==`) та оператор абсолютної рівності (`===`). Пригадаймо пройдену інформацію та спробуймо використати ці оператори знову.
+
+Якщо ми порівнюємо значення різних типів, то оператор рівності спершу конвертує типи, а потім обраховує значення. Однак, оператор абсолютної рівності порівнюватиме, як тип даних, так і значення у вихідному вигляді, не конвертуючи типи.
+
+**Наприклад:**
+
+`3 == '3'` повертає результат `true` тому, що JavaScript конвертує рядок у число. `3 === '3'` повертає результат false, оскільки ці типи є різними і конвертація не виконується.
+
+**Примітка:** В JavaScript, ви можете визначити тип змінної або значення за допомогою оператора `typeof`, наступним чином:
+
+```js
+typeof 3
+typeof '3'
+```
+
+`typeof 3` повертає рядок `number`, а `typeof '3'` повертає рядок `string`.
+
+# --instructions--
+
+Функція `compareEquality` в редакторі порівнює два значення за допомогою оператора рівності. Змініть функцію так, щоб вона повернула рядок `Equal` лише тоді, коли значення абсолютно рівні.
+
+# --hints--
+
+`compareEquality(10, "10")` повинне повернути рядок `Not Equal`
+
+```js
+assert(compareEquality(10, '10') === 'Not Equal');
+```
+
+`compareEquality("20", 20)` повинне повернути рядок `Not Equal`
+
+```js
+assert(compareEquality('20', 20) === 'Not Equal');
+```
+
+Слід використовувати оператор `===`
+
+```js
+assert(code.match(/===/g));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+// Setup
+function compareEquality(a, b) {
+  if (a == b) { // Change this line
+    return "Equal";
+  }
+  return "Not Equal";
+}
+
+compareEquality(10, "10");
+```
+
+# --solutions--
+
+```js
+function compareEquality(a,b) {
+  if (a === b) {
+    return "Equal";
+  }
+  return "Not Equal";
+}
+```
--- 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
@@ -0,0 +1,144 @@
+---
+id: 5688e62ea601b2482ff8422b
+title: Пошук профілю
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cDqW2Cg'
+forumTopicId: 18259
+dashedName: profile-lookup
+---
+
+# --description--
+
+У нас є безліч об'єктів, що представляють різних людей у наших списках контактів.
+
+Функція `lookUpProfile` яка приймає `name` та властивість (`prop`) як аргументи були попередньо записані для вас.
+
+Функція має перевірити, чи `name` є фактичним контактом `firstName` і даний параметр (`prop`) є властивістю цього контакту.
+
+Якщо обидва є правдою, то поверніть "значення" цієї власності.
+
+Якщо `name` не відповідає жодному контакту, поверніть рядок `No such contact`.
+
+Якщо `prop` не відповідає жодним дійсним властивостям контакту, знайденим за відповідністю  `name`  потім поверніться на рядок `No such property`.
+
+# --hints--
+
+`lookUpProfile("Kristian", "lastName")` повинен повернути рядок `Vos`
+
+```js
+assert(lookUpProfile('Kristian', 'lastName') === 'Vos');
+```
+
+`lookUpProfile("Sherlock", "likes")` повинен повернутись як `["Intriguing Cases", "Violin"]`
+
+```js
+assert.deepEqual(lookUpProfile('Sherlock', 'likes'), [
+  'Intriguing Cases',
+  'Violin'
+]);
+```
+
+`lookUpProfile("Harry", "likes")` повинен повернути об'єкт
+
+```js
+assert(typeof lookUpProfile('Harry', 'likes') === 'object');
+```
+
+`lookUpProfile("Bob", "number")` повинен повернути рядок `No such contact`
+
+```js
+assert(lookUpProfile('Bob', 'number') === 'No such contact');
+```
+
+`lookUpProfile("Bob", "potato")` повинен повернути рядок `No such contact`
+
+```js
+assert(lookUpProfile('Bob', 'potato') === 'No such contact');
+```
+
+`lookUpProfile("Akira", "address")` повинен повертати рядок `No such property`
+
+```js
+assert(lookUpProfile('Akira', 'address') === 'No such property');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+// Setup
+const contacts = [
+  {
+    firstName: "Akira",
+    lastName: "Laine",
+    number: "0543236543",
+    likes: ["Pizza", "Coding", "Brownie Points"],
+  },
+  {
+    firstName: "Harry",
+    lastName: "Potter",
+    number: "0994372684",
+    likes: ["Hogwarts", "Magic", "Hagrid"],
+  },
+  {
+    firstName: "Sherlock",
+    lastName: "Holmes",
+    number: "0487345643",
+    likes: ["Intriguing Cases", "Violin"],
+  },
+  {
+    firstName: "Kristian",
+    lastName: "Vos",
+    number: "unknown",
+    likes: ["JavaScript", "Gaming", "Foxes"],
+  },
+];
+
+function lookUpProfile(name, prop) {
+  // Only change code below this line
+
+  // Only change code above this line
+}
+
+lookUpProfile("Akira", "likes");
+```
+
+# --solutions--
+
+```js
+const contacts = [
+  {
+    firstName: "Akira",
+    lastName: "Laine",
+    number: "0543236543",
+    likes: ["Pizza", "Coding", "Brownie Points"],
+  },
+  {
+    firstName: "Harry",
+    lastName: "Potter",
+    number: "0994372684",
+    likes: ["Hogwarts", "Magic", "Hagrid"],
+  },
+  {
+    firstName: "Sherlock",
+    lastName: "Holmes",
+    number: "0487345643",
+    likes: ["Intriguing Cases", "Violin"],
+  },
+  {
+    firstName: "Kristian",
+    lastName: "Vos",
+    number: "unknown",
+    likes: ["JavaScript", "Gaming", "Foxes"],
+  },
+];
+function lookUpProfile(name, prop) {
+  for (let i in contacts) {
+    if (contacts[i].firstName === name) {
+      return contacts[i][prop] || "No such property";
+    }
+  }
+  return "No such contact";
+}
+```
--- 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
@@ -0,0 +1,81 @@
+---
+id: 56533eb9ac21ba0edf2244b4
+title: Цитування рядків з одинарними лапками
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cbQmnhM'
+forumTopicId: 18260
+dashedName: quoting-strings-with-single-quotes
+---
+
+# --description--
+
+Значення <dfn>String</dfn> у JavaScript може бути записане з одинарними чи подвійними лапками, якщо ті ж самі лапки використовуються на початку та в кінці. На відміну від інших мов програмування, одинарні і подвійні лапки працюють однаково в JavaScript.
+
+```js
+const doubleQuoteStr = "This is a string"; 
+const singleQuoteStr = 'This is also a string';
+```
+
+Причиною використовувати один тип лапок поруч з іншим є використання обидвох типів лапок у рядку. Наприклад, коли ви хочете відтворити розмову у рядку і оформити цю розмову лапками. Або ж, коли ви зберігаєте тег `<a>` з різними атрибутами в лапках і все в межах одного рядка.
+
+```js
+const conversation = 'Finn exclaims to Jake, "Algebraic!"';
+```
+
+Однак проблема виникає тоді, коли вам потрібно використати зовнішні лапки в межах рядка. Пам'ятайте, що на початку і в кінці рядка використовуються ті ж самі лапки. Але якщо ви використаєте ці лапки всередині рядка, то рядок закінчиться швидше і це призведе до помилки.
+
+```js
+const goodStr = 'Jake asks Finn, "Hey, let\'s go on an adventure?"'; 
+const badStr = 'Finn responds, "Let's go!"';
+```
+
+В цього випадку `badStr` покаже помилку.
+
+У <dfn>goodStr</dfn> вище, можна спокійно використовувати лапки, додавши зворотну скісну риску `\` як екранований символ.
+
+**Примітка:** Зворотну скісну риску `\` не слід плутати з скісною рискою `/`. Вони мають різні функції.
+
+# --instructions--
+
+Змініть поданий рядок на рядок з одинарними лапками на початку і в кінці та не використовуйте екрановані символи.
+
+Зараз тег `<a>` у рядку може використовувати всюди подвійні лапки. Вам потрібно буде змінити зовнішні лапки на одинарні лапки, щоб видалити екрановані символи.
+
+# --hints--
+
+Вам слід видалити усі зворотні скісні риски (`\`).
+
+```js
+assert(
+  !/\\/g.test(code) &&
+    myStr.match(
+      '\\s*<a href\\s*=\\s*"http://www.example.com"\\s*target\\s*=\\s*"_blank">\\s*Link\\s*</a>\\s*'
+    )
+);
+```
+
+У вас повинні бути дві одинарні лапки `'` і чотири подвійні лапки `"`.
+
+```js
+assert(code.match(/"/g).length === 4 && code.match(/'/g).length === 2);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function() { return "myStr = " + myStr; })();
+```
+
+## --seed-contents--
+
+```js
+const myStr = "<a href=\"http://www.example.com\" target=\"_blank\">Link</a>";
+```
+
+# --solutions--
+
+```js
+const myStr = '<a href="http://www.example.com" target="_blank">Link</a>';
+```
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/record-collection.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/record-collection.md
@@ -0,0 +1,181 @@
+---
+id: 56533eb9ac21ba0edf2244cf
+title: Збірка записів
+challengeType: 1
+forumTopicId: 18261
+dashedName: record-collection
+---
+
+# --description--
+
+Вам наданий літерал об'єкту, який є частиною вашої збірки музичних альбомів. Кожен альбом має свій унікальний ідентифікаційний номер та декілька інших властивостей. Не всі альбоми мають повну інформацію.
+
+Ви починаєте з функції `updateRecords`, яка приймає літерал об'єкту `records`, який містить колекцію музичного альбому, `id`, `prop` (такі як `artist` чи `tracks`), і `value`. Завершіть функцію, використовуючи правила нижче, щоб змінити об'єкт, переданий до функції.
+
+-   Ваша функція повинна завжди повертати весь об'єкт збірки записів.
+-   Якщо `prop` це не `tracks` і `value` не є пустим рядком, то оновіть або встановіть `prop` альбому до `value`.
+-   Якщо `prop` є `tracks` але альбом немає властивості `tracks`, створіть пустий масив та додайте `value` до нього.
+-   Якщо `prop` є `tracks` та `value` не є пустим рядком, додайте `value` до кінця наявного масиву `tracks` у альбомі.
+-   Якщо `value` є пустим рядком, видаліть дану властивість `prop` з альбому.
+
+**Note:** Копія об'єкту `recordCollection` використовується для тестування.
+
+# --hints--
+
+Після `updateRecords(recordCollection, 5439, "artist", "ABBA")`, `artist` повинен бути рядок `ABBA`
+
+```js
+assert(
+  updateRecords(_recordCollection, 5439, 'artist', 'ABBA')[5439]['artist'] ===
+    'ABBA'
+);
+```
+
+Після `updateRecords(recordCollection, 5439, "tracks", "Take a Chance on Me")`, `tracks` повинні мати рядок `Take a Chance on Me` останнім елементом.
+
+```js
+assert(
+  updateRecords(_recordCollection, 5439, 'tracks', 'Take a Chance on Me')[5439][
+    'tracks'
+  ].pop() === 'Take a Chance on Me'
+);
+```
+
+Після `updateRecords(recordCollection, 2548, "artist", "")`, не потрібно встановлювати `artist`
+
+```js
+updateRecords(_recordCollection, 2548, 'artist', '');
+assert(!_recordCollection[2548].hasOwnProperty('artist'));
+```
+
+Після `updateRecords(recordCollection, 1245, "tracks", "Addicted to Love")`, `tracks` повинні мати рядок `Addicted to Love` останнім елементом.
+
+```js
+assert(
+  updateRecords(_recordCollection, 1245, 'tracks', 'Addicted to Love')[1245][
+    'tracks'
+  ].pop() === 'Addicted to Love'
+);
+```
+
+Після `updateRecords(recordCollection, 2468, "tracks", "Free")`, `tracks` повинні мати рядок `1999` першим елементом.
+
+```js
+assert(
+  updateRecords(_recordCollection, 2468, 'tracks', 'Free')[2468][
+    'tracks'
+  ][0] === '1999'
+);
+```
+
+Після `updateRecords(recordCollection, 2548, "tracks", "")`, не потрібно встановлювати `tracks`
+
+```js
+updateRecords(_recordCollection, 2548, 'tracks', '');
+assert(!_recordCollection[2548].hasOwnProperty('tracks'));
+```
+
+Після `updateRecords(recordCollection, 1245, "albumTitle", "Riptide")`, `albumTitle` повинно стати рядком `Riptide`
+
+```js
+assert(
+  updateRecords(_recordCollection, 1245, 'albumTitle', 'Riptide')[1245][
+    'albumTitle'
+  ] === 'Riptide'
+);
+```
+
+# --seed--
+
+## --before-user-code--
+
+```js
+const _recordCollection = {
+  2548: {
+    albumTitle: 'Slippery When Wet',
+    artist: 'Bon Jovi',
+    tracks: ['Let It Rock', 'You Give Love a Bad Name']
+  },
+  2468: {
+    albumTitle: '1999',
+    artist: 'Prince',
+    tracks: ['1999', 'Little Red Corvette']
+  },
+  1245: {
+    artist: 'Robert Palmer',
+    tracks: []
+  },
+  5439: {
+    albumTitle: 'ABBA Gold'
+  }
+};
+```
+
+## --seed-contents--
+
+```js
+// Setup
+const recordCollection = {
+  2548: {
+    albumTitle: 'Slippery When Wet',
+    artist: 'Bon Jovi',
+    tracks: ['Let It Rock', 'You Give Love a Bad Name']
+  },
+  2468: {
+    albumTitle: '1999',
+    artist: 'Prince',
+    tracks: ['1999', 'Little Red Corvette']
+  },
+  1245: {
+    artist: 'Robert Palmer',
+    tracks: []
+  },
+  5439: {
+    albumTitle: 'ABBA Gold'
+  }
+};
+
+// Only change code below this line
+function updateRecords(records, id, prop, value) {
+  return records;
+}
+
+updateRecords(recordCollection, 5439, 'artist', 'ABBA');
+```
+
+# --solutions--
+
+```js
+const recordCollection = {
+  2548: {
+    albumTitle: 'Slippery When Wet',
+    artist: 'Bon Jovi',
+    tracks: ['Let It Rock', 'You Give Love a Bad Name']
+  },
+  2468: {
+    albumTitle: '1999',
+    artist: 'Prince',
+    tracks: ['1999', 'Little Red Corvette']
+  },
+  1245: {
+    artist: 'Robert Palmer',
+    tracks: []
+  },
+  5439: {
+    albumTitle: 'ABBA Gold'
+  }
+};
+
+// Only change code below this line
+function updateRecords(records, id, prop, value) {
+  if (value === '') delete records[id][prop];
+  else if (prop === 'tracks') {
+    records[id][prop] = records[id][prop] || [];
+    records[id][prop].push(value);
+  } else {
+    records[id][prop] = value;
+  }
+
+  return records;
+}
+```
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/replace-loops-using-recursion.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/replace-loops-using-recursion.md
@@ -0,0 +1,105 @@
+---
+id: 5cfa3679138e7d9595b9d9d4
+title: Заміна циклів за допомогою рекурсії
+challengeType: 1
+videoUrl: >-
+  https://www.freecodecamp.org/news/how-recursion-works-explained-with-flowcharts-and-a-video-de61f40cb7f9/
+forumTopicId: 301175
+dashedName: replace-loops-using-recursion
+---
+
+# --description--
+
+Рекурсія - це концепція, згідно з якою функція може бути вираженою в термінах сама по собі. Щоб краще зрозуміти це, почніть з роздумів про наступне завдання: перемножте перші `n` елементів масиву, щоб створити добуток цих елементів. Ви могли б це зробити, використовуючи цикл `for`:
+
+```js
+  function multiply(arr, n) {
+    let product = 1;
+    for (let i = 0; i < n; i++) {
+      product *= arr[i];
+    }
+    return product;
+  }
+```
+
+Проте, зверніть увагу, що `multiply(arr, n) == multiply(arr, n - 1) * arr[n - 1]`. Це означає, що ви можете перезаписати `multiply` саме по собі і ніколи не використовувати цикл.
+
+```js
+  function multiply(arr, n) {
+    if (n <= 0) {
+      return 1;
+    } else {
+      return multiply(arr, n - 1) * arr[n - 1];
+    }
+  }
+```
+
+Рекурсивна версія `multiply` переривається таким чином. У <dfn>base case</dfn>, де `n <= 0`, повертає до 1. Для більших значень `n`, він викликає сам себе, але з `n - 1`. Цей виклик функції обчислюється так само, викликаючи `multiply` знову до `n <= 0`. На даному етапі, всі функції можуть повертати результат і початковий `multiply` повертає відповідь.
+
+**Примітка:** Рекурсивні функції повинні мати базовий регістр, коли вони повертають результат, не викликаючи функцію знову (в цьому прикладі, коли `n <= 0`), інакше вони ніколи не зможуть закінчити виконання.
+
+# --instructions--
+
+Напишіть рекурсивну функцію, `sum(arr, n)`, що повертає суму перших `n` елементів масиву `arr`.
+
+# --hints--
+
+`sum([1], 0)` повинен дорівнювати 0.
+
+```js
+assert.equal(sum([1], 0), 0);
+```
+
+`sum([2, 3, 4], 1)` повинен дорівнювати 2.
+
+```js
+assert.equal(sum([2, 3, 4], 1), 2);
+```
+
+`sum([2, 3, 4, 5], 3)` повинен дорівнювати 9.
+
+```js
+assert.equal(sum([2, 3, 4, 5], 3), 9);
+```
+
+Ваш код не має опиратися на жодні цикли (`for`, `while` або функції більш високої послідовності, такі як `forEach`, `map`, `filter` або `reduce`.).
+
+```js
+assert(
+  !code.match(/for|while|forEach|map|filter|reduce/g)
+);
+```
+
+Вам слід використати рекурсію, щоб вирішити цю проблему.
+
+```js
+assert(
+  sum.toString().match(/sum\(.*\)/g).length > 1
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function sum(arr, n) {
+  // Only change code below this line
+
+  // Only change code above this line
+}
+```
+
+# --solutions--
+
+```js
+function sum(arr, n) {
+  // Only change code below this line
+  if(n <= 0) {
+    return 0;
+  } else {
+    return sum(arr, n - 1) + arr[n - 1];
+  }
+  // Only change code above this line
+}
+```
--- 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
@@ -0,0 +1,157 @@
+---
+id: 56533eb9ac21ba0edf2244e0
+title: Заміна "if else" ланцюжка ключем
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/c3JE8fy'
+forumTopicId: 18266
+dashedName: replacing-if-else-chains-with-switch
+---
+
+# --description--
+
+Якщо ви маєте багато опцій, з яких можете вибирати, то твердження `switch` може бути легшим для написання, ніж багатоланцюгові `if`/`else if` твердження. Наступне:
+
+```js
+if (val === 1) {
+  answer = "a";
+} else if (val === 2) {
+  answer = "b";
+} else {
+  answer = "c";
+}
+```
+
+можна замінити цим:
+
+```js
+switch(val) {
+  case 1:
+    answer = "a";
+    break;
+  case 2:
+    answer = "b";
+    break;
+  default:
+    answer = "c";
+}
+```
+
+# --instructions--
+
+Змініть ланцюжкові `if`/`else if` твердження на `switch` твердження.
+
+# --hints--
+
+Вам не слід використовувати будь-які `else` твердження будь-де в редакторі
+
+```js
+assert(!/else/g.test(code));
+```
+
+Вам не слід використовувати будь-які `if` твердження будь-де в редакторі
+
+```js
+assert(!/if/g.test(code));
+```
+
+Ви повинні мати хоча б чотири `break` твердження
+
+```js
+assert(code.match(/break/g).length >= 4);
+```
+
+`chainToSwitch("bob")` має бути рядком `Marley`
+
+```js
+assert(chainToSwitch('bob') === 'Marley');
+```
+
+`chainToSwitch(42)` має бути рядком `The Answer`
+
+```js
+assert(chainToSwitch(42) === 'The Answer');
+```
+
+`chainToSwitch(1)` має бути рядком `There is no #1`
+
+```js
+assert(chainToSwitch(1) === 'There is no #1');
+```
+
+`chainToSwitch(99)` має бути рядком `Missed me by this much!`
+
+```js
+assert(chainToSwitch(99) === 'Missed me by this much!');
+```
+
+`chainToSwitch(7)` має бути рядком `Ate Nine`
+
+```js
+assert(chainToSwitch(7) === 'Ate Nine');
+```
+
+`chainToSwitch("John")` має бути `""` (пустим рядком)
+
+```js
+assert(chainToSwitch('John') === '');
+```
+
+`chainToSwitch(156)` має бути `""` (пустим рядком)
+
+```js
+assert(chainToSwitch(156) === '');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function chainToSwitch(val) {
+  let answer = "";
+  // Only change code below this line
+
+  if (val === "bob") {
+    answer = "Marley";
+  } else if (val === 42) {
+    answer = "The Answer";
+  } else if (val === 1) {
+    answer = "There is no #1";
+  } else if (val === 99) {
+    answer = "Missed me by this much!";
+  } else if (val === 7) {
+    answer = "Ate Nine";
+  }
+
+  // Only change code above this line
+  return answer;
+}
+
+chainToSwitch(7);
+```
+
+# --solutions--
+
+```js
+function chainToSwitch(val) {
+  let answer = "";
+
+  switch(val) {
+    case "bob":
+      answer = "Marley";
+      break;
+    case 42:
+      answer = "The Answer";
+      break;
+    case 1:
+      answer = "There is no #1";
+      break;
+    case 99:
+      answer = "Missed me by this much!";
+      break;
+    case 7:
+      answer = "Ate Nine";
+  }
+  return answer;
+}
+```
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/return-a-value-from-a-function-with-return.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/return-a-value-from-a-function-with-return.md
@@ -0,0 +1,73 @@
+---
+id: 56533eb9ac21ba0edf2244c2
+title: Повернути значення за допомогою функції повернення
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cy87wue'
+forumTopicId: 18271
+dashedName: return-a-value-from-a-function-with-return
+---
+
+# --description--
+
+Ми можемо передати значення у функцію за допомогою <dfn>аргументів</dfn>. Ви можете використати команду `return`, щоб надіслати значення назад за межі фунції.
+
+**Наприклад**
+
+```js
+function plusThree(num) {
+  return num + 3;
+}
+
+const answer = plusThree(5);
+```
+
+`answer` набуває значення `8`.
+
+`plusThree` приймає <dfn>аргумент</dfn> для `num` і повертає значення, яке дорівнює `num + 3`.
+
+# --instructions--
+
+Створіть функцію `timesFive`, що приймає один аргумент, множить його на `5` і повертає нове значення.
+
+# --hints--
+
+`timesFive` має бути функцією
+
+```js
+assert(typeof timesFive === 'function');
+```
+
+`timesFive(5)` має повернутися до `25`
+
+```js
+assert(timesFive(5) === 25);
+```
+
+`timesFive(2)` має повернутися до `10`
+
+```js
+assert(timesFive(2) === 10);
+```
+
+`timesFive(0)` має повернутися до `0`
+
+```js
+assert(timesFive(0) === 0);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+
+```
+
+# --solutions--
+
+```js
+function timesFive(num) {
+  return num * 5;
+}
+timesFive(10);
+```
--- 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
@@ -0,0 +1,106 @@
+---
+id: 56533eb9ac21ba0edf2244c4
+title: Повернення початкового шаблона для функцій
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cQe39Sq'
+forumTopicId: 18272
+dashedName: return-early-pattern-for-functions
+---
+
+# --description--
+
+Коли ви досягнули команди `return`, виконання поточної функції припиняється і об'єкт керування повертається до місця виклику.
+
+**Наприклад**
+
+```js
+function myFun() {
+  console.log("Hello");
+  return "World";
+  console.log("byebye")
+}
+myFun();
+```
+
+Показане вище відобразить рядок `Hello` у консолі і поверне рядок `World`. Рядок `byebye` ніколи не відобразиться у консолі, тому що функція виходить з команди `return`.
+
+# --instructions--
+
+Модифікуйте функцію `abTest` і тому, якщо `a` або `b` дорівнюватиме менше `0`, функція відразу вийде зі значенням `undefined`.
+
+**Підказка**  
+Пам'ятайте, що [`undefined` - це ключове слово](https://www.freecodecamp.org/learn/javascript-algorithms-and-data-structures/basic-javascript/understanding-uninitialized-variables), а не рядок.
+
+# --hints--
+
+`abTest(2, 2)` повинен повернути число
+
+```js
+assert(typeof abTest(2, 2) === 'number');
+```
+
+`abTest(2, 2)` повинен повернути `8`
+
+```js
+assert(abTest(2, 2) === 8);
+```
+
+`abTest(-2, 2)` повинен повернути `undefined`
+
+```js
+assert(abTest(-2, 2) === undefined);
+```
+
+`abTest(2, -2)` повинен повернути `undefined`
+
+```js
+assert(abTest(2, -2) === undefined);
+```
+
+`abTest(2, 8)` повинен повернути `18`
+
+```js
+assert(abTest(2, 8) === 18);
+```
+
+`abTest(3, 3)` повинен повернути `12`
+
+```js
+assert(abTest(3, 3) === 12);
+```
+
+`abTest(0, 0)` повинен повернути `0`
+
+```js
+assert(abTest(0, 0) === 0);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+// Setup
+function abTest(a, b) {
+  // Only change code below this line
+
+
+
+  // Only change code above this line
+
+  return Math.round(Math.pow(Math.sqrt(a) + Math.sqrt(b), 2));
+}
+
+abTest(2,2);
+```
+
+# --solutions--
+
+```js
+function abTest(a, b) {
+  if(a < 0 || b < 0) {
+    return undefined;
+  }
+  return Math.round(Math.pow(Math.sqrt(a) + Math.sqrt(b), 2));
+}
+```
--- 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
@@ -0,0 +1,82 @@
+---
+id: 5679ceb97cbaa8c51670a16b
+title: Повернення логічних значень з функцій
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cp62qAQ'
+forumTopicId: 18273
+dashedName: returning-boolean-values-from-functions
+---
+
+# --description--
+
+Ви можете пригадати з [Порівняння з оператором рівності](/learn/javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-equality-operator), що всі порівняльні оператори повертають логічне `true` або `false` значення.
+
+Інколи люди використовують `if/else` команду для того, щоб зробити порівняння на зразок цього:
+
+```js
+function isEqual(a, b) {
+  if (a === b) {
+    return true;
+  } else {
+    return false;
+  }
+}
+```
+
+Але є кращий спосіб це зробити. Оскільки `===` повертає `true` або `false`, ми можемо повернути результат порівняння:
+
+```js
+function isEqual(a, b) {
+  return a === b;
+}
+```
+
+# --instructions--
+
+Виправте функцію `isLess` для того, щоб видалити `if/else` команду.
+
+# --hints--
+
+`isLess(10, 15)` повинен повернути `true`
+
+```js
+assert(isLess(10, 15) === true);
+```
+
+`isLess(15, 10)` повинен повернути `false`
+
+```js
+assert(isLess(15, 10) === false);
+```
+
+Вам не слід використовувати будь-які `if` чи `else` команди
+
+```js
+assert(!/if|else/g.test(code));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function isLess(a, b) {
+  // Only change code below this line
+  if (a < b) {
+    return true;
+  } else {
+    return false;
+  }
+  // Only change code above this line
+}
+
+isLess(10, 15);
+```
+
+# --solutions--
+
+```js
+function isLess(a, b) {
+  return a < b;
+}
+```
--- 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
@@ -0,0 +1,114 @@
+---
+id: 56533eb9ac21ba0edf2244dd
+title: Вибір з багатьох опцій за допомогою перемикачів
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/c4mv4fm'
+forumTopicId: 18277
+dashedName: selecting-from-many-options-with-switch-statements
+---
+
+# --description--
+
+Якщо у вас є багато опцій для вибору, використовуйте команду <dfn>switch</dfn>. `switch` тести на значення і може мати багато <dfn> випадків </dfn> інструкцій, які визначають різні значення. Інструкції виконуються від першого узгодженого значення `case<code> до тих пір, поки <code>break<code> не відбудиться.</p>
+
+<p spaces-before="0">Ось наводиться приклад інструкції <code>switch`:
+
+```js
+switch(lowercaseLetter) {
+  case "a":
+    console.log("A");
+    break;
+  case "b":
+    console.log("B");
+    break;
+}
+```
+
+`case` значень перевіряється абсолютною рівністю (`===`). `break` пропонує JavaScript припинити виконання інструкцій. Якщо `break` пропущений, тоді наступна команда буде виконуватись.
+
+# --instructions--
+
+Напишіть команду switch, щоб встановити `answer` за наступних умов:  
+`1` - `alpha`  
+`2` - `beta`  
+`3` - `gamma`  
+`4` - `delta`
+
+# --hints--
+
+`caseInSwitch(1)` повинно відповідати значенню рядка `alpha`
+
+```js
+assert(caseInSwitch(1) === 'alpha');
+```
+
+`caseInSwitch(2)` повинно відповідати значенню рядка `beta`
+
+```js
+assert(caseInSwitch(2) === 'beta');
+```
+
+`caseInSwitch(3)` повинно відповідати значенню рядка `gamma`
+
+```js
+assert(caseInSwitch(3) === 'gamma');
+```
+
+`caseInSwitch(4)` повинно відповідати значенню рядка `delta`
+
+```js
+assert(caseInSwitch(4) === 'delta');
+```
+
+Не варто використовувати `if` або `else` команди
+
+```js
+assert(!/else/g.test(code) || !/if/g.test(code));
+```
+
+Ви повинні мати принаймні 3 інструкції `break`
+
+```js
+assert(code.match(/break/g).length > 2);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function caseInSwitch(val) {
+  let answer = "";
+  // Only change code below this line
+
+
+
+  // Only change code above this line
+  return answer;
+}
+
+caseInSwitch(1);
+```
+
+# --solutions--
+
+```js
+function caseInSwitch(val) {
+  let answer = "";
+
+  switch(val) {
+    case 1:
+      answer = "alpha";
+      break;
+    case 2:
+      answer = "beta";
+      break;
+    case 3:
+      answer = "gamma";
+      break;
+    case 4:
+      answer = "delta";
+  }
+  return answer;
+}
+```
--- 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
@@ -0,0 +1,97 @@
+---
+id: 56533eb9ac21ba0edf2244bc
+title: Список покупок
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/c9MEKHZ'
+forumTopicId: 18280
+dashedName: shopping-list
+---
+
+# --description--
+
+Створіть список покупок у змінній `myList`. Список повинен бути багатовимірним масивом, який містить декілька підмасивів.
+
+Перший елемент у кожному підмасиві повинен містити рядок з назвою одиниці. Другий елемент повинен бути числом, яке відображає кількість.
+
+```js
+["Chocolate Bar", 15]
+```
+
+У списку повинно бути щонайменше 5 підмасивів.
+
+# --hints--
+
+`myList` повинен бути масивом.
+
+```js
+assert(isArray);
+```
+
+Першими елементами у кожному з ваших підмасивів повинні бути рядки.
+
+```js
+assert(hasString);
+```
+
+Другими елементами у кожному підмасиві повинні бути числа.
+
+```js
+assert(hasNumber);
+```
+
+У списку має бути щонайменше 5 одиниць.
+
+```js
+assert(count > 4);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+var count = 0;
+var isArray = false;
+var hasString = false;
+var hasNumber = false;
+(function(list){
+  if(Array.isArray(myList)) {
+    isArray = true;
+    if(myList.length > 0) {
+      hasString = true;
+      hasNumber = true;
+      for (var elem of myList) {
+        if(!elem || !elem[0] || typeof elem[0] !== 'string') {
+          hasString = false;
+        }
+        if(!elem || typeof elem[1] !== 'number') {
+          hasNumber = false;
+        }
+      }
+    }
+    count = myList.length;
+    return JSON.stringify(myList);
+  } else {
+    return "myList is not an array";
+  }
+
+})(myList);
+```
+
+## --seed-contents--
+
+```js
+const myList = [];
+```
+
+# --solutions--
+
+```js
+const myList = [
+  ["Candy", 10],
+  ["Potatoes", 12],
+  ["Eggs", 12],
+  ["Catfood", 1],
+  ["Toads", 9]
+];
+```
--- 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
@@ -0,0 +1,116 @@
+---
+id: 56533eb9ac21ba0edf2244c6
+title: Стояти в черзі
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/ca8Q8tP'
+forumTopicId: 18307
+dashedName: stand-in-line
+---
+
+# --description--
+
+В комп'ютерних науках <dfn>queue</dfn> це абстрактне поняття <dfn>Data Structure</dfn>, де усі елементи зберігають певний порядок. Нові елементи можуть бути додані до черги, а старі елементи - зняті з черги.
+
+Напишіть функцію `nextInLine`, аргументами якої є масив (`arr`) та число (`item`).
+
+Додайте число до кінця масиву, а тоді видаліть перший елемент з масиву.
+
+Функція `nextInLine` повинна повернути видалений елемент.
+
+# --hints--
+
+`nextInLine([], 5)` має повернути до числа.
+
+```js
+assert.isNumber(nextInLine([], 5));
+```
+
+`nextInLine([], 1)` має повернути до `1`
+
+```js
+assert(nextInLine([], 1) === 1);
+```
+
+`nextInLine([2], 1)` має повернути до `2`
+
+```js
+assert(nextInLine([2], 1) === 2);
+```
+
+`nextInLine([5,6,7,8,9], 1)` має повернути до `5`
+
+```js
+assert(nextInLine([5, 6, 7, 8, 9], 1) === 5);
+```
+
+Після `nextInLine(testArr, 10)`, код `testArr[4]` має стати `10`
+
+```js
+nextInLine(testArr, 10);
+assert(testArr[4] === 10);
+```
+
+# --seed--
+
+## --before-user-code--
+
+```js
+var logOutput = [];
+var originalConsole = console
+function capture() {
+    var nativeLog = console.log;
+    console.log = function (message) {
+        logOutput.push(message);
+        if(nativeLog.apply) {
+          nativeLog.apply(originalConsole, arguments);
+        } else {
+          var nativeMsg = Array.prototype.slice.apply(arguments).join(' ');
+          nativeLog(nativeMsg);
+        }
+    };
+}
+
+function uncapture() {
+  console.log = originalConsole.log;
+}
+
+capture();
+```
+
+## --after-user-code--
+
+```js
+uncapture();
+testArr = [1,2,3,4,5];
+(function() { return logOutput.join("\n");})();
+```
+
+## --seed-contents--
+
+```js
+function nextInLine(arr, item) {
+  // Only change code below this line
+
+  return item;
+  // Only change code above this line
+}
+
+// Setup
+const testArr = [1, 2, 3, 4, 5];
+
+// Display code
+console.log("Before: " + JSON.stringify(testArr));
+console.log(nextInLine(testArr, 6));
+console.log("After: " + JSON.stringify(testArr));
+```
+
+# --solutions--
+
+```js
+const testArr = [1, 2, 3, 4, 5];
+
+function nextInLine(arr, item) {
+    arr.push(item);
+    return arr.shift();
+}
+```
--- 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
@@ -0,0 +1,63 @@
+---
+id: bd7993c9c69feddfaeb8bdef
+title: Зберігання кількох значень в одній змінній, використовуючи масиви JavaScript
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/crZQWAm'
+forumTopicId: 18309
+dashedName: store-multiple-values-in-one-variable-using-javascript-arrays
+---
+
+# --description--
+
+Зі змінними масивів `array` JavaScript, ми можемо зберігати частини даних в одному місці.
+
+Ви починаєте оголошення масиву з відкритої квадратної дужки, а завершуєте його закриваючи квадратною дужкою і ставлячи кому між кожним елементом приблизно так:
+
+```js
+const sandwich = ["peanut butter", "jelly", "bread"];
+```
+
+# --instructions--
+
+Змініть масив `myArray` так, щоб він містив і рядок, і число (у цьому порядку).
+
+# --hints--
+
+`myArray` повинен бути масивом.
+
+```js
+assert(typeof myArray == 'object');
+```
+
+Першим елементом у масиві `myArray` має бути рядок.
+
+```js
+assert(typeof myArray[0] !== 'undefined' && typeof myArray[0] == 'string');
+```
+
+Другий пункт в `myArray` має бути числом.
+
+```js
+assert(typeof myArray[1] !== 'undefined' && typeof myArray[1] == 'number');
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(z){return z;})(myArray);
+```
+
+## --seed-contents--
+
+```js
+// Only change code below this line
+const myArray = [];
+```
+
+# --solutions--
+
+```js
+const myArray = ["The Answer", 42];
+```
--- 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
@@ -0,0 +1,77 @@
+---
+id: 56533eb9ac21ba0edf2244a8
+title: Зберігання значень за допомогою оператора присвоєння
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cEanysE'
+forumTopicId: 18310
+dashedName: storing-values-with-the-assignment-operator
+---
+
+# --description--
+
+In JavaScript ви можете зберігати значення в змінній <dfn>assignment</dfn> з оператором (`=`).
+
+```js
+myVariable = 5;
+```
+
+Вона призначає `Number` зі значенням `5` до `myVariable`.
+
+Якщо праворуч від оператора є будь-які розрахунки `=`, ті з них, які розташовані перед значенням належать до змінної зліва від оператора.
+
+```js
+var myVar;
+myVar = 5;
+```
+
+Спочатку, цей код створює змінну з ім'ям `myVar`. Тоді код присвоює `5` на `myVar`. Тепер, якщо `myVar` знову з'являється в коді, програма буде розглядати його так, як `5`.
+
+# --instructions--
+
+Надайте значення `7` змінній `a`.
+
+# --hints--
+
+Не слід змінювати код над зазначеним коментарем.
+
+```js
+assert(/var a;/.test(code));
+```
+
+`a` має мати значення 7.
+
+```js
+assert(typeof a === 'number' && a === 7);
+```
+
+# --seed--
+
+## --before-user-code--
+
+```js
+if (typeof a != 'undefined') {
+  a = undefined;
+}
+```
+
+## --after-user-code--
+
+```js
+(function(a){return "a = " + a;})(a);
+```
+
+## --seed-contents--
+
+```js
+// Setup
+var a;
+
+// Only change code below this line
+```
+
+# --solutions--
+
+```js
+var a;
+a = 7;
+```
--- 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
@@ -0,0 +1,59 @@
+---
+id: cf1111c1c11feddfaeb4bdef
+title: Віднімати одне число від іншого використовуючи JavaScript
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cP3yQtk'
+forumTopicId: 18314
+dashedName: subtract-one-number-from-another-with-javascript
+---
+
+# --description--
+
+Ми також можемо віднімати одне число від іншого.
+
+JavaScript використовує символ `-` для віднімання.
+
+**Наприклад**
+
+```js
+const myVar = 12 - 6;
+```
+
+`myVar` тепер матиме значення `6`.
+# --instructions--
+
+Змініть `0` так, щоб сума дорівнювала `12`.
+
+# --hints--
+
+Змінна `difference` має дорівнювати 12.
+
+```js
+assert(difference === 12);
+```
+
+Потрібно відняти лише одне число від 45.
+
+```js
+assert(/difference=45-33;?/.test(__helpers.removeWhiteSpace(code)));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(z){return 'difference = '+z;})(difference);
+```
+
+## --seed-contents--
+
+```js
+const difference = 45 - 0;
+```
+
+# --solutions--
+
+```js
+const difference = 45 - 33;
+```
--- 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
@@ -0,0 +1,98 @@
+---
+id: 567af2437cbaa8c51670a16c
+title: Тестування властивостей об'єктів
+challengeType: 1
+forumTopicId: 18324
+dashedName: testing-objects-for-properties
+---
+
+# --description--
+
+Іноді варто перевіряти чи даний об'єкт вже має певні властивості. Ми можемо використовувати метод об'єктів `.hasOwnProperty(propname)`, щоб визначити чи об'єкт має ім'я властивості. `.hasOwnProperty()` показує `true` чи `false`, в залежності чи властивість знайдена, чи ні.
+
+**Наприклад**
+
+```js
+const myObj = {
+  top: "hat",
+  bottom: "pants"
+};
+
+myObj.hasOwnProperty("top");
+myObj.hasOwnProperty("middle");
+```
+
+Перший `hasOwnProperty` стає `true`, а другий - `false`.
+
+# --instructions--
+
+Змініть функцію `checkObj`, щоб перевірити чи об'єкт переданий до функції (`obj`) містить особливу властивість (`checkProp`). Якщо властивість знайдена, поверніть значення властивості. Якщо ні, поверніть `"Not Found"`.
+
+# --hints--
+
+`checkObj({gift: "pony", pet: "kitten", bed: "sleigh"}, "gift")` має повернути рядок `pony`.
+
+```js
+assert(
+  checkObj({ gift: 'pony', pet: 'kitten', bed: 'sleigh' }, 'gift') === 'pony'
+);
+```
+
+`checkObj({gift: "pony", pet: "kitten", bed: "sleigh"}, "pet")` має повернути рядок `kitten`.
+
+```js
+assert(
+  checkObj({ gift: 'pony', pet: 'kitten', bed: 'sleigh' }, 'pet') === 'kitten'
+);
+```
+
+`checkObj({gift: "pony", pet: "kitten", bed: "sleigh"}, "house")` має повернути рядок `Not Found`.
+
+```js
+assert(
+  checkObj({ gift: 'pony', pet: 'kitten', bed: 'sleigh' }, 'house') ===
+    'Not Found'
+);
+```
+
+`checkObj({city: "Seattle"}, "city")` має повернути рядок `Seattle`.
+
+```js
+assert(checkObj({ city: 'Seattle' }, 'city') === 'Seattle');
+```
+
+`checkObj({city: "Seattle"}, "district")` має повернути рядок `Not Found`.
+
+```js
+assert(checkObj({ city: 'Seattle' }, 'district') === 'Not Found');
+```
+
+`checkObj({pet: "kitten", bed: "sleigh"}, "gift")` має повернути рядок `Not Found`.
+
+```js
+assert(checkObj({ pet: 'kitten', bed: 'sleigh' }, 'gift') === 'Not Found');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function checkObj(obj, checkProp) {
+  // Only change code below this line
+  return "Change Me!";
+  // Only change code above this line
+}
+```
+
+# --solutions--
+
+```js
+function checkObj(obj, checkProp) {
+  if(obj.hasOwnProperty(checkProp)) {
+    return obj[checkProp];
+  } else {
+    return "Not Found";
+  }
+}
+```
--- 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
@@ -0,0 +1,70 @@
+---
+id: 56533eb9ac21ba0edf2244ba
+title: Розуміння нестійкості рядка
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cWPVaUR'
+forumTopicId: 18331
+dashedName: understand-string-immutability
+---
+
+# --description--
+
+У JavaScript, `String` значення <dfn>immutable</dfn>, означає, що їх не можна буде змінити після створення.
+
+Наприклад, у такому коді:
+
+```js
+let myStr = "Bob";
+myStr[0] = "J";
+```
+
+неможливо змінити значення `myStr` на `Job`, тому що вміст `myStr` не може бути зміненим. Зауважте, що *not* означає, що `myStr` не можна змінити, так само як окремі елементи в коді <dfn>string literal</dfn>. Єдиний спосіб змінити `myStr` - це додати новий рядок:
+
+```js
+let myStr = "Bob";
+myStr = "Job";
+```
+
+# --instructions--
+
+Виправте призначення `myStr` так, щоб код містив рядок зі значенням `Hello World`, використовуючи підхід, показаний вище.
+
+# --hints--
+
+`myStr` має мати значення рядка `Hello World`.
+
+```js
+assert(myStr === 'Hello World');
+```
+
+Не слід змінювати код над зазначеним коментарем.
+
+```js
+assert(/myStr = "Jello World"/.test(code));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(v){return "myStr = " + v;})(myStr);
+```
+
+## --seed-contents--
+
+```js
+// Setup
+let myStr = "Jello World";
+
+// Only change code below this line
+myStr[0] = "H"; // Change this line
+// Only change code above this line
+```
+
+# --solutions--
+
+```js
+let myStr = "Jello World";
+myStr = "Hello World";
+```
--- 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
@@ -0,0 +1,60 @@
+---
+id: bd7123c9c441eddfaeb5bdef
+title: Розуміння булевих значень
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/c9Me8t4'
+forumTopicId: 301176
+dashedName: understanding-boolean-values
+---
+
+# --description--
+
+Інший тип даних це <dfn>Boolean</dfn>. Булеві значення можуть мати лише два значення: `true` чи `false`. Фактично, це маленькі перемикачі, де `true` це "увімкнено" і `false` - "вимкнено". Ці два стани несумісні.
+
+**Note:** Булеві вирази ніколи не записуються в дужках. Рядки `"true"` й `"false"` не булеві і не мають особливого значення в JavaScript.
+
+# --instructions--
+
+Змініть функцію `welcomeToBooleans` так, щоб вона повертала `true` замість `false`, коли натискається кнопка запуску.
+
+# --hints--
+
+Функція `welcomeToBooleans()` має повернути значення (`true` or `false`).
+
+```js
+assert(typeof welcomeToBooleans() === 'boolean');
+```
+
+`welcomeToBooleans()` має повернути `true`.
+
+```js
+assert(welcomeToBooleans() === true);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+welcomeToBooleans();
+```
+
+## --seed-contents--
+
+```js
+function welcomeToBooleans() {
+  // Only change code below this line
+
+  return false; // Change this line
+
+  // Only change code above this line
+}
+```
+
+# --solutions--
+
+```js
+function welcomeToBooleans() {
+  return true; // Change this line
+}
+```
--- 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
@@ -0,0 +1,100 @@
+---
+id: 56533eb9ac21ba0edf2244ab
+title: Розуміння врахування регістру в змінних
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cd6GDcD'
+forumTopicId: 18334
+dashedName: understanding-case-sensitivity-in-variables
+---
+
+# --description--
+
+У JavaScript усі змінні та назви функцій існують з урахуванням регістру. Це означає, що написання з великої літери має значення.
+
+`MYVAR` - це не теж саме, що й `MyVar` чи `myvar`. Цілком можливо мати декілька різних змінних з одинаковою назвою, але різним відмінком. Наполегливо рекомендується, щоб, заради чіткості, ви *не* використовували цю мовну особливість.
+
+**Найкраща практика**
+
+Напишіть назви змінних у JavaScript в <dfn>camelCase</dfn>. У <dfn>camelCase</dfn>, у назвах змінних, які складаються з декількох слів, перше слово ми пишемо з малої букви, а першу букву кожного наступного слова - з великої.
+
+**Приклади:**
+
+```js
+var someVariable;
+var anotherVariableName;
+var thisVariableNameIsSoLong;
+```
+
+# --instructions--
+
+Модифікуйте існуючі оголошення та завдання так, щоб їхні назви використовували <dfn>camelCase</dfn>.
+
+Не створюйте жодних нових змінних.
+
+# --hints--
+
+`studlyCapVar` має бути визначене і мати значення `10`.
+
+```js
+assert(typeof studlyCapVar !== 'undefined' && studlyCapVar === 10);
+```
+
+`properCamelCase` має бути визначене і мати значення рядка `A String`.
+
+```js
+assert(
+  typeof properCamelCase !== 'undefined' && properCamelCase === 'A String'
+);
+```
+
+`titleCaseOver` має бути визначене і мати значення `9000`.
+
+```js
+assert(typeof titleCaseOver !== 'undefined' && titleCaseOver === 9000);
+```
+
+`studlyCapVar` має використовувати camelCase як в оголошенні, так і в розділах завдань.
+
+```js
+assert(code.match(/studlyCapVar/g).length === 2);
+```
+
+`properCamelCase` має використовувати camelCase як в оголошенні, так і в розділах завдань.
+
+```js
+assert(code.match(/properCamelCase/g).length === 2);
+```
+
+`titleCaseOver` має використовувати camelCase як в оголошенні, так і в розділах завдань.
+
+```js
+assert(code.match(/titleCaseOver/g).length === 2);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+// Variable declarations
+var StUdLyCapVaR;
+var properCamelCase;
+var TitleCaseOver;
+
+// Variable assignments
+STUDLYCAPVAR = 10;
+PRoperCAmelCAse = "A String";
+tITLEcASEoVER = 9000;
+```
+
+# --solutions--
+
+```js
+var studlyCapVar;
+var properCamelCase;
+var titleCaseOver;
+
+studlyCapVar = 10;
+properCamelCase = "A String";
+titleCaseOver = 9000;
+```
--- 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
@@ -0,0 +1,96 @@
+---
+id: 598e8944f009e646fc236146
+title: Розуміння невизначеного значення, яке повернуто з функції
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/ce2p7cL'
+forumTopicId: 301177
+dashedName: understanding-undefined-value-returned-from-a-function
+---
+
+# --description--
+
+Функція може містити команду `return`, але не обов'язково. У цьому випадку функція не має команди `return`. Натомість, коли ви викликаєте її, функція обробляє внутрішній код, але повернене значення є `undefined`.
+
+**Приклад**
+
+```js
+let sum = 0;
+
+function addSum(num) {
+  sum = sum + num;
+}
+
+addSum(3);
+```
+
+`addSum` - це функція без команди `return`. Функція змінить загальну `sum` (суму) змінної, але повернене значення функції буде `undefined`.
+
+# --instructions--
+
+Створіть функцію `addFive` без аргументів. Ця функція додає 5 до `sum` (суми) змінної, але повернене значення є `undefined`.
+
+# --hints--
+
+`addFive` має бути функцією.
+
+```js
+assert(typeof addFive === 'function');
+```
+
+Після запуску обидвох функцій, `sum` має дорівнювати `8`.
+
+```js
+assert(sum === 8);
+```
+
+Повернене з `addFive` значення, має бути `undefined`.
+
+```js
+assert(addFive() === undefined);
+```
+
+Всередині функції `addFive` вам слід додати `5` до `sum` змінної.
+
+```js
+assert(
+  __helpers.removeWhiteSpace(addFive.toString()).match(/sum=sum\+5|sum\+=5/)
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+// Setup
+let sum = 0;
+
+function addThree() {
+  sum = sum + 3;
+}
+
+// Only change code below this line
+
+
+// Only change code above this line
+
+addThree();
+addFive();
+```
+
+# --solutions--
+
+```js
+let sum = 0;
+
+function addThree() {
+  sum = sum + 3;
+}
+
+function addFive() {
+  sum = sum + 5;
+}
+
+addThree();
+addFive();
+```
--- 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
@@ -0,0 +1,79 @@
+---
+id: 56533eb9ac21ba0edf2244aa
+title: Розуміння неініціалізованих змінних
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cBa2JAL'
+forumTopicId: 18335
+dashedName: understanding-uninitialized-variables
+---
+
+# --description--
+
+Коли змінні JavaScript проголошено, вони мають початкове значення `undefined`. Якщо ви виконуєте математичну дію з `undefined` змінної, вашим результатом буде `NaN`, що означає <dfn>"Not a Number"</dfn>. Якщо ви об'єднаєте рядок з `undefined` змінною, ви отримаєте <dfn>рядок</dfn> літерала з `undefined`.
+
+# --instructions--
+
+Ініціалізуйте три змінні `a`, `b` та `c` відповідно з `5`, `10` і `"I am a"`, щоб вони не були `undefined`.
+
+# --hints--
+
+`a` має бути визначене й обчислене, щоб мати значення `6`.
+
+```js
+assert(typeof a === 'number' && a === 6);
+```
+
+`b` має бути визначене й обчислене, щоб мати значення `15`.
+
+```js
+assert(typeof b === 'number' && b === 15);
+```
+
+`c` не має містити `undefined` і повинне мати значення рядка `I am a String!`
+
+```js
+assert(!/undefined/.test(c) && c === 'I am a String!');
+```
+
+Вам не слід змінювати код під зазначеним коментарем.
+
+```js
+assert(
+  /a = a \+ 1;/.test(code) &&
+    /b = b \+ 5;/.test(code) &&
+    /c = c \+ " String!";/.test(code)
+);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(a,b,c){ return "a = " + a + ", b = " + b + ", c = '" + c + "'"; })(a,b,c);
+```
+
+## --seed-contents--
+
+```js
+// Only change code below this line
+var a;
+var b;
+var c;
+// Only change code above this line
+
+a = a + 1;
+b = b + 5;
+c = c + " String!";
+```
+
+# --solutions--
+
+```js
+var a = 5;
+var b = 10;
+var c = "I am a";
+a = a + 1;
+b = b + 5;
+c = c + " String!";
+```
--- 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
@@ -0,0 +1,78 @@
+---
+id: 56bbb991ad1ed5201cd392d1
+title: Оновлення властивостей об'єкта
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/c9yEJT4'
+forumTopicId: 18336
+dashedName: updating-object-properties
+---
+
+# --description--
+
+Після того, як ви створили об'єкт JavaScript, ви можете оновити його властивості в будь-який час, так як і будь-які інші його змінні. Ви можете використовувати точкову або дужкову нотацію для оновлення.
+
+Наприклад, погляньмо на `ourDog`:
+
+```js
+const ourDog = {
+  "name": "Camper",
+  "legs": 4,
+  "tails": 1,
+  "friends": ["everything!"]
+};
+```
+
+Оскільки це винятково щасливий собака, змінімо його ім'я на рядок `Happy Camper`. Ось як ми оновимо властивість імені його об'єкта: `ourDog.name = "Happy Camper";` або `ourDog["name"] = "Happy Camper";` Тепер коли ми оцінюємо `ourDog.name`, замість того, щоб отримати `Camper`, ми отримаємо його нове ім'я `Happy Camper`.
+
+# --instructions--
+
+Оновити властивість імені об'єкта `myDog`. Змінімо його ім'я з `Coder` на `Happy Coder`. Ви можете використовувати точкову або крапкову нотацію.
+
+# --hints--
+
+Вам слід оновити властивість `name` `myDog`, щоб вона дорівнювала рядку`Happy Coder`.
+
+```js
+assert(/happy coder/gi.test(myDog.name));
+```
+
+Не слід змінювати визначення `myDog`.
+
+```js
+assert(/"name": "Coder"/.test(code));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(z){return z;})(myDog);
+```
+
+## --seed-contents--
+
+```js
+// Setup
+const myDog = {
+  "name": "Coder",
+  "legs": 4,
+  "tails": 1,
+  "friends": ["freeCodeCamp Campers"]
+};
+
+// Only change code below this line
+
+```
+
+# --solutions--
+
+```js
+const myDog = {
+  "name": "Coder",
+  "legs": 4,
+  "tails": 1,
+  "friends": ["freeCodeCamp Campers"]
+};
+myDog.name = "Happy Coder";
+```
--- 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
@@ -0,0 +1,74 @@
+---
+id: bd7123c9c549eddfaeb5bdef
+title: Використовуйте Дужкову Нотацію для Пошуку Першого Символу в Рядку
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/ca8JwhW'
+forumTopicId: 18341
+dashedName: use-bracket-notation-to-find-the-first-character-in-a-string
+---
+
+# --description--
+
+<dfn>Дужкова нотація</dfn> - це спосіб отримання символу з певним індексом в рядку.
+
+Більшість сучасних мов програмування, таких як JavaScript, не починають рахувати з 1, як це роблять люди. Вони починають з 0. Це називають індексація <dfn>на основі нуля</dfn>.
+
+Наприклад, символ з індексом 0 у слові `Charles` буде `C`. Отже, якщо `const firstName = "Charles"`, ви можете отримати значення першої літери рядка, використовуючи `firstName[0]`.
+
+Наприклад:
+
+```js
+const firstName = "Charles";
+const firstLetter = firstName[0];
+```
+
+`firstLetter` повинна мати значення рядка `C`.
+
+# --instructions--
+
+Використовуйте дужкову нотацію, щоб знайти перший символ в змінній `lastName` та задайте його до `firstLetterOfLastName`.
+
+**Підказка:**Спробуйте подивитися на приклад вище, якщо застрягли.
+
+# --hints--
+
+Змінна `firstLetterOfLastName` повинна мати значення `L`.
+
+```js
+assert(firstLetterOfLastName === 'L');
+```
+
+Вам слід використовувати дужкову нотацію.
+
+```js
+assert(code.match(/firstLetterOfLastName\s*?=\s*?lastName\[.*?\]/));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(v){return v;})(firstLetterOfLastName);
+```
+
+## --seed-contents--
+
+```js
+// Setup
+let firstLetterOfLastName = "";
+const lastName = "Lovelace";
+
+// Only change code below this line
+firstLetterOfLastName = lastName; // Change this line
+```
+
+# --solutions--
+
+```js
+let firstLetterOfLastName = "";
+const lastName = "Lovelace";
+
+// Only change code below this line
+firstLetterOfLastName = lastName[0];
+```
--- 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
@@ -0,0 +1,68 @@
+---
+id: bd7123c9c451eddfaeb5bdef
+title: Використовуйте Дужкову Нотацію для Пошуку Останнього Символу в Рядку
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cBZQGcv'
+forumTopicId: 18342
+dashedName: use-bracket-notation-to-find-the-last-character-in-a-string
+---
+
+# --description--
+
+Щоб отримати останню літеру рядка, ви можете відняти її від довжини рядка.
+
+Наприклад, якщо `const firstName = "Ada"`, ви можете отримати значення останньої літери, використовуючи `firstName[firstName.length - 1]`.
+
+Наприклад:
+
+```js
+const firstName = "Ada";
+const lastLetter = firstName[firstName.length - 1];
+```
+
+`lastLetter` повинна мати значення рядка `a`.
+
+# --instructions--
+
+Використовуйте <dfn>дужкову нотацію</dfn>, щоб знайти останній символ у змінній `lastName`.
+
+**Підказка:**Спробуйте подивитися на приклад вище, якщо застрягли.
+
+# --hints--
+
+`lastLetterOfLastName` повинно бути літерою `e`.
+
+```js
+assert(lastLetterOfLastName === 'e');
+```
+
+Вам слід використовувати `.length`, щоб отримати останню літеру.
+
+```js
+assert(code.match(/\.length/g).length > 0);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(v){return v;})(lastLetterOfLastName);
+```
+
+## --seed-contents--
+
+```js
+// Setup
+const lastName = "Lovelace";
+
+// Only change code below this line
+const lastLetterOfLastName = lastName; // Change this line
+```
+
+# --solutions--
+
+```js
+const lastName = "Lovelace";
+const lastLetterOfLastName = lastName[lastName.length - 1];
+```
--- a/Show More
+++ b/Show More