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-algorithm-scripting/boo-who.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/boo-who.md
@@ -0,0 +1,97 @@
+---
+id: a77dbc43c33f39daa4429b4f
+title: Хто такий Boo
+challengeType: 5
+forumTopicId: 16000
+dashedName: boo-who
+---
+
+# --description--
+
+Перевірте, чи значення відноситься булевого тиру (логічне значення). Функція має повертати `true` or `false`.
+
+Булеві примітиви - це коди `true` правда та `false` неправда.
+
+# --hints--
+
+`booWho(true)` повинен повертати `true`.
+
+```js
+assert.strictEqual(booWho(true), true);
+```
+
+`booWho(false)` повинен повертати `true`.
+
+```js
+assert.strictEqual(booWho(false), true);
+```
+
+`booWho([1, 2, 3])` повинен повертати `false`.
+
+```js
+assert.strictEqual(booWho([1, 2, 3]), false);
+```
+
+`booWho([].slice)` повинен повертати `false`.
+
+```js
+assert.strictEqual(booWho([].slice), false);
+```
+
+`booWho({ "a": 1 })` повинен повертати `false`.
+
+```js
+assert.strictEqual(booWho({ a: 1 }), false);
+```
+
+`booWho(1)` повинен повертати `false`.
+
+```js
+assert.strictEqual(booWho(1), false);
+```
+
+`booWho(NaN)` повинен повертати `false`.
+
+```js
+assert.strictEqual(booWho(NaN), false);
+```
+
+`booWho("a")` повинен повертати `false`.
+
+```js
+assert.strictEqual(booWho('a'), false);
+```
+
+`booWho("true")` повинен повертати `false`.
+
+```js
+assert.strictEqual(booWho('true'), false);
+```
+
+`booWho("false")` повинен повертати `false`.
+
+```js
+assert.strictEqual(booWho('false'), false);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function booWho(bool) {
+  return bool;
+}
+
+booWho(null);
+```
+
+# --solutions--
+
+```js
+function booWho(bool) {
+  return typeof bool === "boolean";
+}
+
+booWho(null);
+```
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/chunky-monkey.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/chunky-monkey.md
@@ -0,0 +1,110 @@
+---
+id: a9bd25c716030ec90084d8a1
+title: Алгоритм Chunky Monkey
+challengeType: 5
+forumTopicId: 16005
+dashedName: chunky-monkey
+---
+
+# --description--
+
+Напишіть функцію, яка ділить масив (перший аргумент) у групи: довжина `size` (другий аргумент) і повертає їх у вигляді двовимірного масиву.
+
+# --hints--
+
+`chunkArrayInGroups(["a", "b", "c", "d"], 2)` повинен перетворюватися на `[["a", "b"], ["c", "d"]]`.
+
+```js
+assert.deepEqual(chunkArrayInGroups(['a', 'b', 'c', 'd'], 2), [
+  ['a', 'b'],
+  ['c', 'd']
+]);
+```
+
+`chunkArrayInGroups([0, 1, 2, 3, 4, 5], 3)` повинен перетворюватися на `[[0, 1, 2], [3, 4, 5]]`.
+
+```js
+assert.deepEqual(chunkArrayInGroups([0, 1, 2, 3, 4, 5], 3), [
+  [0, 1, 2],
+  [3, 4, 5]
+]);
+```
+
+`chunkArrayInGroups([0, 1, 2, 3, 4, 5], 2)` повинен перетворюватися на `[[0, 1], [2, 3], [4, 5]]`.
+
+```js
+assert.deepEqual(chunkArrayInGroups([0, 1, 2, 3, 4, 5], 2), [
+  [0, 1],
+  [2, 3],
+  [4, 5]
+]);
+```
+
+`chunkArrayInGroups([0, 1, 2, 3, 4, 5], 4)` повинен перетворюватися на `[[0, 1, 2, 3], [4, 5]]`.
+
+```js
+assert.deepEqual(chunkArrayInGroups([0, 1, 2, 3, 4, 5], 4), [
+  [0, 1, 2, 3],
+  [4, 5]
+]);
+```
+
+`chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6], 3)` повинен перетворюватися на `[[0, 1, 2], [3, 4, 5], [6]]`.
+
+```js
+assert.deepEqual(chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6], 3), [
+  [0, 1, 2],
+  [3, 4, 5],
+  [6]
+]);
+```
+
+`chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6, 7, 8], 4)` повинен перетворюватися на `[[0, 1, 2, 3], [4, 5, 6, 7], [8]]`.
+
+```js
+assert.deepEqual(chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6, 7, 8], 4), [
+  [0, 1, 2, 3],
+  [4, 5, 6, 7],
+  [8]
+]);
+```
+
+`chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6, 7, 8], 2)` повинен перетворюватися на `[[0, 1], [2, 3], [4, 5], [6, 7], [8]]`.
+
+```js
+assert.deepEqual(chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6, 7, 8], 2), [
+  [0, 1],
+  [2, 3],
+  [4, 5],
+  [6, 7],
+  [8]
+]);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function chunkArrayInGroups(arr, size) {
+  return arr;
+}
+
+chunkArrayInGroups(["a", "b", "c", "d"], 2);
+```
+
+# --solutions--
+
+```js
+function chunkArrayInGroups(arr, size) {
+  let out = [];
+
+  for (let i = 0; i < arr.length; i += size) {
+    out.push(arr.slice(i, i + size));
+  }
+
+  return out;
+}
+
+chunkArrayInGroups(["a", "b", "c", "d"], 2);
+```
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/confirm-the-ending.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/confirm-the-ending.md
@@ -0,0 +1,113 @@
+---
+id: acda2fb1324d9b0fa741e6b5
+title: Підтвердження Закінчення
+challengeType: 5
+forumTopicId: 16006
+dashedName: confirm-the-ending
+---
+
+# --description--
+
+Перевірте, чи рядок (перший аргумент, `str`) закінчується заданим цільовим рядком (другий аргумент, `target`).
+
+Цю проблему *can* можна вирішити за допомогою методу `.endsWith()`, який був введений в ES2015. Але, мета цього завдання передбачає використання одного із методів виділення підрядків JavaScript.
+
+# --hints--
+
+`confirmEnding("Bastian", "n")` повинен перетворюватися на `true`.
+
+```js
+assert(confirmEnding('Bastian', 'n') === true);
+```
+
+`confirmEnding("Congratulation", "on")` повинен перетворюватися на `true`.
+
+```js
+assert(confirmEnding('Congratulation', 'on') === true);
+```
+
+`confirmEnding("Connor", "n")` повинен перетворюватися на `false`.
+
+```js
+assert(confirmEnding('Connor', 'n') === false);
+```
+
+`confirmEnding("Walking on water and developing software from a specification are easy if both are frozen", "specification")` повинен перетворюватися на `false`.
+
+```js
+assert(
+  confirmEnding(
+    'Walking on water and developing software from a specification are easy if both are frozen',
+    'specification'
+  ) === false
+);
+```
+
+`confirmEnding("He has to give me a new name", "name")` повинен перетворюватися на `true`.
+
+```js
+assert(confirmEnding('He has to give me a new name', 'name') === true);
+```
+
+`confirmEnding("Open sesame", "same")` повинен перетворюватися на `true`.
+
+```js
+assert(confirmEnding('Open sesame', 'same') === true);
+```
+
+`confirmEnding("Open sesame", "sage")` повинен перетворюватися на `false`.
+
+```js
+assert(confirmEnding('Open sesame', 'sage') === false);
+```
+
+`confirmEnding("Open sesame", "game")` повинен перетворюватися на `false`.
+
+```js
+assert(confirmEnding('Open sesame', 'game') === false);
+```
+
+`confirmEnding("If you want to save our world, you must hurry. We dont know how much longer we can withstand the nothing", "mountain")` повинен перетворюватися на `false`.
+
+```js
+assert(
+  confirmEnding(
+    'If you want to save our world, you must hurry. We dont know how much longer we can withstand the nothing',
+    'mountain'
+  ) === false
+);
+```
+
+`confirmEnding("Abstraction", "action")` повинен перетворюватися на `true`.
+
+```js
+assert(confirmEnding('Abstraction', 'action') === true);
+```
+
+У вашому коді не повинен використовуватися вбудований метод `.endsWith()` для вирішення завдання.
+
+```js
+assert(!/\.endsWith\(.*?\)\s*?;?/.test(code) && !/\['endsWith'\]/.test(code));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function confirmEnding(str, target) {
+  return str;
+}
+
+confirmEnding("Bastian", "n");
+```
+
+# --solutions--
+
+```js
+function confirmEnding(str, target) {
+  return str.substring(str.length - target.length) === target;
+}
+
+confirmEnding("Bastian", "n");
+```
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/convert-celsius-to-fahrenheit.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/convert-celsius-to-fahrenheit.md
@@ -0,0 +1,76 @@
+---
+id: 56533eb9ac21ba0edf2244b3
+title: Конвертація градусів за Цельсієм у градуси за Фаренгейтом
+challengeType: 1
+forumTopicId: 16806
+dashedName: convert-celsius-to-fahrenheit
+---
+
+# --description--
+
+Алгоритм конвертації градусів за Цельсієм у градуси за Фаренгейтом, це температура за Цельсієм помножена на `9/5`, плюс `32`.
+
+Ви отримуєте змінну `celsius`, що відповідає температурі за Цельсієм. Використовуйте вже визначену змінну `fahrenheit` і призначте їй температуру за Фаренгейтом, еквівалентну заданій температурі за Цельсієм. Використовуйте алгоритм запропонований вище для конвертації температури за Цельсієм у температуру за Фаренгейтом.
+
+# --hints--
+
+`convertToF(0)` має повернути число
+
+```js
+assert(typeof convertToF(0) === 'number');
+```
+
+`convertToF(-30)` має повертати значення `-22`
+
+```js
+assert(convertToF(-30) === -22);
+```
+
+`convertToF(-10)` має повертати значення `14`
+
+```js
+assert(convertToF(-10) === 14);
+```
+
+`convertToF(0)` має повертати значення `32`
+
+```js
+assert(convertToF(0) === 32);
+```
+
+`convertToF(20)` має повертати значення `68`
+
+```js
+assert(convertToF(20) === 68);
+```
+
+`convertToF(30)` має повертати значення `86`
+
+```js
+assert(convertToF(30) === 86);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function convertToF(celsius) {
+  let fahrenheit;
+  return fahrenheit;
+}
+
+convertToF(30);
+```
+
+# --solutions--
+
+```js
+function convertToF(celsius) {
+  let fahrenheit = celsius * 9/5 + 32;
+
+  return fahrenheit;
+}
+
+convertToF(30);
+```
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/factorialize-a-number.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/factorialize-a-number.md
@@ -0,0 +1,73 @@
+---
+id: a302f7aae1aa3152a5b413bc
+title: Факторизація числа
+challengeType: 5
+forumTopicId: 16013
+dashedName: factorialize-a-number
+---
+
+# --description--
+
+Повернути факторіал поданого цілого числа.
+
+Якщо ціле число позначається літерою `n`, факторіал - це добуток усіх додатних цілих чисел менших або рівних `n`.
+
+Факторіали часто зображаються  короткими позначеннями `n!`
+
+Наприклад: `5! = 1 * 2 * 3 * 4 * 5 = 120`
+
+Тільки цілі числа, які більші або дорівнюють нулю, будуть задані функції.
+
+# --hints--
+
+`factorialize(5)` "" має повертати число.
+
+```js
+assert(typeof factorialize(5) === 'number');
+```
+
+`factorialize(5)` має повернути `120`.
+
+```js
+assert(factorialize(5) === 120);
+```
+
+`factorialize(10)` має повернути число`3628800`.
+
+```js
+assert(factorialize(10) === 3628800);
+```
+
+`factorialize(20)` має повернути `2432902008176640000`.
+
+```js
+assert(factorialize(20) === 2432902008176640000);
+```
+
+`factorialize(0)` має повернути `1`.
+
+```js
+assert(factorialize(0) === 1);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function factorialize(num) {
+  return num;
+}
+
+factorialize(5);
+```
+
+# --solutions--
+
+```js
+function factorialize(num) {
+  return num < 1 ? 1 : num * factorialize(num - 1);
+}
+
+factorialize(5);
+```
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/falsy-bouncer.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/falsy-bouncer.md
@@ -0,0 +1,63 @@
+---
+id: adf08ec01beb4f99fc7a68f2
+title: Фільтрація помилкових значень масиву
+challengeType: 5
+forumTopicId: 16014
+dashedName: falsy-bouncer
+---
+
+# --description--
+
+Видалити всі неправильні значення з масиву.
+
+Неправильні значення в JavaScript: `false`, `null`, `0`, `""`, `undefined`, і `NaN`.
+
+Підказка: спробуйте перетворити кожне значення на логічне значення.
+
+# --hints--
+
+`bouncer([7, "ate", "", false, 9])` має повернути `[7, "ate", 9]`.
+
+```js
+assert.deepEqual(bouncer([7, 'ate', '', false, 9]), [7, 'ate', 9]);
+```
+
+`bouncer(["a", "b", "c"])` має вертати `["a", "b", "c"]`.
+
+```js
+assert.deepEqual(bouncer(['a', 'b', 'c']), ['a', 'b', 'c']);
+```
+
+`bouncer([false, null, 0, NaN, undefined, ""])` має повертати `[]`.
+
+```js
+assert.deepEqual(bouncer([false, null, 0, NaN, undefined, '']), []);
+```
+
+`bouncer([null, NaN, 1, 2, undefined])` має повертати `[1, 2]`.
+
+```js
+assert.deepEqual(bouncer([null, NaN, 1, 2, undefined]), [1, 2]);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function bouncer(arr) {
+  return arr;
+}
+
+bouncer([7, "ate", "", false, 9]);
+```
+
+# --solutions--
+
+```js
+function bouncer(arr) {
+  return arr.filter(e => e);
+}
+
+bouncer([7, "ate", "", false, 9]);
+```
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/find-the-longest-word-in-a-string.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/find-the-longest-word-in-a-string.md
@@ -0,0 +1,87 @@
+---
+id: a26cbbe9ad8655a977e1ceb5
+title: Знайдіть найдовше слово в рядку
+challengeType: 5
+forumTopicId: 16015
+dashedName: find-the-longest-word-in-a-string
+---
+
+# --description--
+
+Поверніть довжину найдовшого слова у даному реченні.
+
+Ваша відповідь повинна бути числом.
+
+# --hints--
+
+`findLongestWordLength("The quick brown fox jumped over the lazy dog")` відповідь має бути числом.
+
+```js
+assert(
+  typeof findLongestWordLength(
+    'The quick brown fox jumped over the lazy dog'
+  ) === 'number'
+);
+```
+
+`findLongestWordLength("The quick brown fox jumped over the lazy dog")` - результатом має бути `6`.
+
+```js
+assert(
+  findLongestWordLength('The quick brown fox jumped over the lazy dog') === 6
+);
+```
+
+`findLongestWordLength("May the force be with you")` - результатом має бути `5`.
+
+```js
+assert(findLongestWordLength('May the force be with you') === 5);
+```
+
+`findLongestWordLength("Google do a barrel roll")` - результатом має бути `6`.
+
+```js
+assert(findLongestWordLength('Google do a barrel roll') === 6);
+```
+
+`findLongestWordLength("What is the average airspeed velocity of an unladen swallow")` - результатом має бути `8`.
+
+```js
+assert(
+  findLongestWordLength(
+    'What is the average airspeed velocity of an unladen swallow'
+  ) === 8
+);
+```
+
+`findLongestWordLength("What if we try a super-long word such as otorhinolaryngology")` - результатом має бути `19`.
+
+```js
+assert(
+  findLongestWordLength(
+    'What if we try a super-long word such as otorhinolaryngology'
+  ) === 19
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function findLongestWordLength(str) {
+  return str.length;
+}
+
+findLongestWordLength("The quick brown fox jumped over the lazy dog");
+```
+
+# --solutions--
+
+```js
+function findLongestWordLength(str) {
+  return str.split(' ').sort((a, b) => b.length - a.length)[0].length;
+}
+
+findLongestWordLength("The quick brown fox jumped over the lazy dog");
+```
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/finders-keepers.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/finders-keepers.md
@@ -0,0 +1,58 @@
+---
+id: a6e40f1041b06c996f7b2406
+title: Що впало, те пропало
+challengeType: 5
+forumTopicId: 16016
+dashedName: finders-keepers
+---
+
+# --description--
+
+Створіть функцію, яка переглядає масив `arr` і повертає перший елемент у ньому, який проходить перевірку на "істинність". Це означає, що даний елемент `x` пройшов перевірку на "істинність", якщо `func(x)` є `true`. Якщо жодний елемент не проходить перевірку, відповідь буде `undefined`.
+
+# --hints--
+
+`findElement([1, 3, 5, 8, 9, 10], function(num) { return num % 2 === 0; })` має повертати `8`.
+
+```js
+assert.strictEqual(
+  findElement([1, 3, 5, 8, 9, 10], function (num) {
+    return num % 2 === 0;
+  }),
+  8
+);
+```
+
+`findElement([1, 3, 5, 9], function(num) { return num % 2 === 0; })` має повертати `undefined`.
+
+```js
+assert.strictEqual(
+  findElement([1, 3, 5, 9], function (num) {
+    return num % 2 === 0;
+  }),
+  undefined
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function findElement(arr, func) {
+  let num = 0;
+  return num;
+}
+
+findElement([1, 2, 3, 4], num => num % 2 === 0);
+```
+
+# --solutions--
+
+```js
+function findElement(arr, func) {
+  return arr.filter(func)[0];
+}
+
+findElement([1, 2, 3, 4], num => num % 2 === 0);
+```
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/mutations.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/mutations.md
@@ -0,0 +1,117 @@
+---
+id: af2170cad53daa0770fabdea
+title: Мутації
+challengeType: 5
+forumTopicId: 16025
+dashedName: mutations
+---
+
+# --description--
+
+Повертає `true` якщо рядок у першому елементі масиву містить усі літери рядка у другому елементі масиву.
+
+Наприклад, для `["hello", "Hello"]` має повертати `true` тому що всі літери у другому рядку присутні й у першому, незважаючи на їх регістр.
+
+Аргументи `["hello", "hey"]` мають повертати `false`, тому що рядок `hello` не містить літеру `y`.
+
+Зрештою, для `["Alien", "line"]` має повертати `true`, тому що всі літери слова`line` присутні у слові `Alien`.
+
+# --hints--
+
+`mutation(["hello", "hey"])` має повертати `false`.
+
+```js
+assert(mutation(['hello', 'hey']) === false);
+```
+
+`mutation(["hello", "Hello"])` має повертати `true`.
+
+```js
+assert(mutation(['hello', 'Hello']) === true);
+```
+
+`mutation(["zyxwvutsrqponmlkjihgfedcba", "qrstu"])` має повертати `true`.
+
+```js
+assert(mutation(['zyxwvutsrqponmlkjihgfedcba', 'qrstu']) === true);
+```
+
+`mutation(["Mary", "Army"])` має повертати `true`.
+
+```js
+assert(mutation(['Mary', 'Army']) === true);
+```
+
+`mutation(["Mary", "Aarmy"])` має повертати `true`.
+
+```js
+assert(mutation(['Mary', 'Aarmy']) === true);
+```
+
+`mutation(["Alien", "line"])` має повертати`true`.
+
+```js
+assert(mutation(['Alien', 'line']) === true);
+```
+
+`mutation(["floor", "for"])` має повертати `true`.
+
+```js
+assert(mutation(['floor', 'for']) === true);
+```
+
+`mutation(["hello", "neo"])` має повертати `false`.
+
+```js
+assert(mutation(['hello', 'neo']) === false);
+```
+
+`mutation(["voodoo", "no"])` має повертати `false`.
+
+```js
+assert(mutation(['voodoo', 'no']) === false);
+```
+
+`mutation(["ate", "date"])` має повертати `false`.
+
+```js
+assert(mutation(['ate', 'date']) === false);
+```
+
+`mutation(["Tiger", "Zebra"])` має повертати `false`.
+
+```js
+assert(mutation(['Tiger', 'Zebra']) === false);
+```
+
+`mutation(["Noel", "Ole"])` має повертати `true`.
+
+```js
+assert(mutation(['Noel', 'Ole']) === true);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function mutation(arr) {
+  return arr;
+}
+
+mutation(["hello", "hey"]);
+```
+
+# --solutions--
+
+```js
+function mutation(arr) {
+  let hash = Object.create(null);
+
+  arr[0].toLowerCase().split('').forEach(c => hash[c] = true);
+
+  return !arr[1].toLowerCase().split('').filter(c => !hash[c]).length;
+}
+
+mutation(["hello", "hey"]);
+```
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/repeat-a-string-repeat-a-string.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/repeat-a-string-repeat-a-string.md
@@ -0,0 +1,84 @@
+---
+id: afcc8d540bea9ea2669306b6
+title: Повторіть рядок Повторення рядка
+challengeType: 5
+forumTopicId: 16041
+dashedName: repeat-a-string-repeat-a-string
+---
+
+# --description--
+
+Повторити заданий рядок `str` (перший елемент) `num` разів (другий елемент). Повернути порожній рядок, якщо `num` не є додатнім числом. Для цього завдання *не* використовуйте вбудований `.repeat()` метод.
+
+# --hints--
+
+`repeatStringNumTimes("*", 3)` має повернути рядок `***`.
+
+```js
+assert(repeatStringNumTimes('*', 3) === '***');
+```
+
+`repeatStringNumTimes("abc", 3)` має повернути рядок `abcabcabc`.
+
+```js
+assert(repeatStringNumTimes('abc', 3) === 'abcabcabc');
+```
+
+`repeatStringNumTimes("abc", 4)` має повернути рядок `abcabcabcabc`.
+
+```js
+assert(repeatStringNumTimes('abc', 4) === 'abcabcabcabc');
+```
+
+`repeatStringNumTimes("abc", 1)` має повернути рядок `abc`.
+
+```js
+assert(repeatStringNumTimes('abc', 1) === 'abc');
+```
+
+`repeatStringNumTimes("*", 8)` має повернути рядок `********`.
+
+```js
+assert(repeatStringNumTimes('*', 8) === '********');
+```
+
+`repeatStringNumTimes("abc", -2)` має повернути порожній рядок (`""`).
+
+```js
+assert(repeatStringNumTimes('abc', -2) === '');
+```
+
+Вбудований метод `repeat()` не слід використовувати.
+
+```js
+assert(!/\.repeat/g.test(code));
+```
+
+`repeatStringNumTimes("abc", 0)` має повернути рядок `""`.
+
+```js
+assert(repeatStringNumTimes('abc', 0) === '');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function repeatStringNumTimes(str, num) {
+  return str;
+}
+
+repeatStringNumTimes("abc", 3);
+```
+
+# --solutions--
+
+```js
+function repeatStringNumTimes(str, num) {
+  if (num < 1) return '';
+  return num === 1 ? str : str + repeatStringNumTimes(str, num-1);
+}
+
+repeatStringNumTimes("abc", 3);
+```
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/return-largest-numbers-in-arrays.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/return-largest-numbers-in-arrays.md
@@ -0,0 +1,92 @@
+---
+id: a789b3483989747d63b0e427
+title: Знайдіть найбільші числа в масивах
+challengeType: 5
+forumTopicId: 16042
+dashedName: return-largest-numbers-in-arrays
+---
+
+# --description--
+
+Повертає масив, що складається з найбільшого числа з кожного під-масиву. Для простоти, даний масив буде містити рівно 4 під-масиви.
+
+Пам'ятайте, ви можете перебирати масив за допомогою простого циклу, і мати доступ до кожного елемента через синтаксис масиву `arr[i]`.
+
+# --hints--
+
+`largestOfFour([[4, 5, 1, 3], [13, 27, 18, 26], [32, 35, 37, 39], [1000, 1001, 857, 1]])` повинен повернути масив рядка.
+
+```js
+assert(
+  largestOfFour([
+    [4, 5, 1, 3],
+    [13, 27, 18, 26],
+    [32, 35, 37, 39],
+    [1000, 1001, 857, 1]
+  ]).constructor === Array
+);
+```
+
+`largestOfFour([[13, 27, 18, 26], [4, 5, 1, 3], [32, 35, 37, 39], [1000, 1001, 857, 1]])` повинен повернути `[27, 5, 39, 1001]`.
+
+```js
+assert.deepEqual(
+  largestOfFour([
+    [13, 27, 18, 26],
+    [4, 5, 1, 3],
+    [32, 35, 37, 39],
+    [1000, 1001, 857, 1]
+  ]),
+  [27, 5, 39, 1001]
+);
+```
+
+`largestOfFour([[4, 9, 1, 3], [13, 35, 18, 26], [32, 35, 97, 39], [1000000, 1001, 857, 1]])` повинен повернути`[9, 35, 97, 1000000]`.
+
+```js
+assert.deepEqual(
+  largestOfFour([
+    [4, 9, 1, 3],
+    [13, 35, 18, 26],
+    [32, 35, 97, 39],
+    [1000000, 1001, 857, 1]
+  ]),
+  [9, 35, 97, 1000000]
+);
+```
+
+`largestOfFour([[17, 23, 25, 12], [25, 7, 34, 48], [4, -10, 18, 21], [-72, -3, -17, -10]])` повинен повернути `[25, 48, 21, -3]`.
+
+```js
+assert.deepEqual(
+  largestOfFour([
+    [17, 23, 25, 12],
+    [25, 7, 34, 48],
+    [4, -10, 18, 21],
+    [-72, -3, -17, -10]
+  ]),
+  [25, 48, 21, -3]
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function largestOfFour(arr) {
+  return arr;
+}
+
+largestOfFour([[4, 5, 1, 3], [13, 27, 18, 26], [32, 35, 37, 39], [1000, 1001, 857, 1]]);
+```
+
+# --solutions--
+
+```js
+function largestOfFour(arr) {
+  return arr.map(subArr => Math.max.apply(null, subArr));
+}
+
+largestOfFour([[4, 5, 1, 3], [13, 27, 18, 26], [32, 35, 37, 39], [1000, 1001, 857, 1]]);
+```
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/reverse-a-string.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/reverse-a-string.md
@@ -0,0 +1,63 @@
+---
+id: a202eed8fc186c8434cb6d61
+title: Зворотний рядок
+challengeType: 5
+forumTopicId: 16043
+dashedName: reverse-a-string
+---
+
+# --description--
+
+Переверніть заданий рядок.
+
+За необхідності перетворіть рядок у масив до того, як вносити зміни.
+
+У результаті ви повинні отримати рядок.
+
+# --hints--
+
+`reverseString("hello")` повинен повністю змінити рядок.
+
+```js
+assert(typeof reverseString('hello') === 'string');
+```
+
+`reverseString("hello")` повинен перетворитися на рядок `olleh`.
+
+```js
+assert(reverseString('hello') === 'olleh');
+```
+
+`reverseString("Howdy")` повинен перетворитися на рядок `ydwoH`.
+
+```js
+assert(reverseString('Howdy') === 'ydwoH');
+```
+
+`reverseString("Greetings from Earth")` повинен перетворитися на рядок `htraE morf sgniteerG`.
+
+```js
+assert(reverseString('Greetings from Earth') === 'htraE morf sgniteerG');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function reverseString(str) {
+  return str;
+}
+
+reverseString("hello");
+```
+
+# --solutions--
+
+```js
+function reverseString(str) {
+  return str.split('').reverse().join('');
+}
+
+reverseString("hello");
+```
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/slice-and-splice.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/slice-and-splice.md
@@ -0,0 +1,98 @@
+---
+id: 579e2a2c335b9d72dd32e05c
+title: Метод Slice та Splice. Метод Slice () копіює задану частину масиву і повертає цю скопійовану частина у вигляді нового масиву. Вихідний масив при цьому не змінюється. Метод Splice () додає і видаляє елементи з масиву, змінюючи його
+challengeType: 5
+forumTopicId: 301148
+dashedName: slice-and-splice
+---
+
+# --description--
+
+Вам дано два масиви та індекс.
+
+Скопіюйте кожний елемент по порядку з першого масиву у другий.
+
+Вставляйте елементи індексу `n` до другого масиву.
+
+Поверніться до отриманого масиву. Вхідні масиви повинні залишатись незмінними після запуску функції.
+
+# --hints--
+
+`frankenSplice([1, 2, 3], [4, 5], 1)` має повертати `[4, 1, 2, 3, 5]`.
+
+```js
+assert.deepEqual(frankenSplice([1, 2, 3], [4, 5], 1), [4, 1, 2, 3, 5]);
+```
+
+`frankenSplice([1, 2], ["a", "b"], 1)` має повертати `["a", 1, 2, "b"]`.
+
+```js
+assert.deepEqual(frankenSplice(testArr1, testArr2, 1), ['a', 1, 2, 'b']);
+```
+
+`frankenSplice(["claw", "tentacle"], ["head", "shoulders", "knees", "toes"], 2)` має повертати `["head", "shoulders", "claw", "tentacle", "knees", "toes"]`.
+
+```js
+assert.deepEqual(
+  frankenSplice(
+    ['claw', 'tentacle'],
+    ['head', 'shoulders', 'knees', 'toes'],
+    2
+  ),
+  ['head', 'shoulders', 'claw', 'tentacle', 'knees', 'toes']
+);
+```
+
+Додавайте усі елементи з першого масиву до другого в початковій послідовності. `frankenSplice([1, 2, 3, 4], [], 0)` має повертати `[1, 2, 3, 4]`.
+
+```js
+assert.deepEqual(frankenSplice([1, 2, 3, 4], [], 0), [1, 2, 3, 4]);
+```
+
+Перший масив залишається незмінним після запуску функції.
+
+```js
+frankenSplice(testArr1, testArr2, 1);
+assert.deepEqual(testArr1, [1, 2]);
+```
+
+Другий масив залишається незмінним після запуску функції.
+
+```js
+frankenSplice(testArr1, testArr2, 1);
+assert.deepEqual(testArr2, ['a', 'b']);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+let testArr1 = [1, 2];
+let testArr2 = ["a", "b"];
+```
+
+## --seed-contents--
+
+```js
+function frankenSplice(arr1, arr2, n) {
+  return arr2;
+}
+
+frankenSplice([1, 2, 3], [4, 5, 6], 1);
+```
+
+# --solutions--
+
+```js
+function frankenSplice(arr1, arr2, n) {
+  // It's alive. It's alive!
+  let result = arr2.slice();
+  for (let i = 0; i < arr1.length; i++) {
+    result.splice(n+i, 0, arr1[i]);
+  }
+  return result;
+}
+
+frankenSplice([1, 2, 3], [4, 5], 1);
+```
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/title-case-a-sentence.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/title-case-a-sentence.md
@@ -0,0 +1,64 @@
+---
+id: ab6137d4e35944e21037b769
+title: Алгоритм Великі літери у реченнях
+challengeType: 5
+forumTopicId: 16088
+dashedName: title-case-a-sentence
+---
+
+# --description--
+
+Стрічка повинна починатись з великої літери в кожному слові. Переконайтесь, що решта букв написана у нижньому регістрі.
+
+Для виконання завдання, вам також необхідно писати з великої літери сполучення слів `the` та `of`.
+
+# --hints--
+
+`titleCase("I'm a little tea pot")` має повернути рядок.
+
+```js
+assert(typeof titleCase("I'm a little tea pot") === 'string');
+```
+
+`titleCase("I'm a little tea pot")` має повернути рядок `I'm A Little Tea Pot`.
+
+```js
+assert(titleCase("I'm a little tea pot") === "I'm A Little Tea Pot");
+```
+
+`titleCase("sHoRt AnD sToUt")` має повертати рядок `Short And Stout`.
+
+```js
+assert(titleCase('sHoRt AnD sToUt') === 'Short And Stout');
+```
+
+`titleCase("HERE IS MY HANDLE HERE IS MY SPOUT")` має повернути рядок `Here Is My Handle Here Is My Spout`.
+
+```js
+assert(
+  titleCase('HERE IS MY HANDLE HERE IS MY SPOUT') ===
+    'Here Is My Handle Here Is My Spout'
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function titleCase(str) {
+  return str;
+}
+
+titleCase("I'm a little tea pot");
+```
+
+# --solutions--
+
+```js
+function titleCase(str) {
+  return str.split(' ').map(word => word.charAt(0).toUpperCase() + word.substring(1).toLowerCase()).join(' ');
+}
+
+titleCase("I'm a little tea pot");
+```
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/truncate-a-string.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/truncate-a-string.md
@@ -0,0 +1,91 @@
+---
+id: ac6993d51946422351508a41
+title: Алгоритм Truncate a String (Скорочення рядка)
+challengeType: 5
+forumTopicId: 16089
+dashedName: truncate-a-string
+---
+
+# --description--
+
+Скоротіть рядок якщо перший аргумент довший ніж задана максимальна довжина рядка (другий аргумент). Перетворіть скорочений рядок на `...`.
+
+# --hints--
+
+`truncateString("A-tisket a-tasket A green and yellow basket", 8)` має повернути рядок `A-tisket...`.
+
+```js
+assert(
+  truncateString('A-tisket a-tasket A green and yellow basket', 8) ===
+    'A-tisket...'
+);
+```
+
+`truncateString("Peter Piper picked a peck of pickled peppers", 11)` має повернути рядок `Peter Piper...`.
+
+```js
+assert(
+  truncateString('Peter Piper picked a peck of pickled peppers', 11) ===
+    'Peter Piper...'
+);
+```
+
+`truncateString("A-tisket a-tasket A green and yellow basket", "A-tisket a-tasket A green and yellow basket".length)` має повернути рядок `A-tisket a-tasket A green and yellow basket`.
+
+```js
+assert(
+  truncateString(
+    'A-tisket a-tasket A green and yellow basket',
+    'A-tisket a-tasket A green and yellow basket'.length
+  ) === 'A-tisket a-tasket A green and yellow basket'
+);
+```
+
+`truncateString("A-tisket a-tasket A green and yellow basket", "A-tisket a-tasket A green and yellow basket".length + 2)` має повернути рядок `A-tisket a-tasket A green and yellow basket`.
+
+```js
+assert(
+  truncateString(
+    'A-tisket a-tasket A green and yellow basket',
+    'A-tisket a-tasket A green and yellow basket'.length + 2
+  ) === 'A-tisket a-tasket A green and yellow basket'
+);
+```
+
+`truncateString("A-", 1)` має повернути рядок `A...`.
+
+```js
+assert(truncateString('A-', 1) === 'A...');
+```
+
+`truncateString("Absolutely Longer", 2)` має повернути рядок `Ab...`.
+
+```js
+assert(truncateString('Absolutely Longer', 2) === 'Ab...');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function truncateString(str, num) {
+  return str;
+}
+
+truncateString("A-tisket a-tasket A green and yellow basket", 8);
+```
+
+# --solutions--
+
+```js
+function truncateString(str, num) {
+  if (num >= str.length) {
+    return str;
+  }
+
+  return str.slice(0, num) + '...';
+}
+
+truncateString("A-tisket a-tasket A green and yellow basket", 8);
+```
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/where-do-i-belong.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/where-do-i-belong.md
@@ -0,0 +1,143 @@
+---
+id: a24c1a4622e3c05097f71d67
+title: Куди я належу (Де моє місце)
+challengeType: 5
+forumTopicId: 16094
+dashedName: where-do-i-belong
+---
+
+# --description--
+
+Поверніть найнижчий індекс, при якому значення (другий аргумент) слід вставити в масив (перший аргумент), після того, як він був відсортований. Отримане значення має бути числом.
+
+Наприклад, `getIndexToIns([1,2,3,4], 1.5)`має дати відповідь `1`, тому що вона більша ніж `1` (індекс 0), але менша ніж `2` (індекс 1).
+
+Аналогічно, `getIndexToIns([20,3,5], 19)` має дати відповідь `2` тому що, як тільки масив буде відсортований, він виглядатиме як `[3,5,20]`, а `19` менше за `20` (індекс 2) та більше, ніж `5` (індекс 1).
+
+# --hints--
+
+`getIndexToIns([10, 20, 30, 40, 50], 35)` має повернути `3`.
+
+```js
+assert(getIndexToIns([10, 20, 30, 40, 50], 35) === 3);
+```
+
+`getIndexToIns([10, 20, 30, 40, 50], 35)` має дати відповідь числом.
+
+```js
+assert(typeof getIndexToIns([10, 20, 30, 40, 50], 35) === 'number');
+```
+
+`getIndexToIns([10, 20, 30, 40, 50], 30)` має дати відповідь `2`.
+
+```js
+assert(getIndexToIns([10, 20, 30, 40, 50], 30) === 2);
+```
+
+`getIndexToIns([10, 20, 30, 40, 50], 30)` має дати відповідь числом.
+
+```js
+assert(typeof getIndexToIns([10, 20, 30, 40, 50], 30) === 'number');
+```
+
+`getIndexToIns([40, 60], 50)` має дати відповідь `1`.
+
+```js
+assert(getIndexToIns([40, 60], 50) === 1);
+```
+
+`getIndexToIns([40, 60], 50)` має дати відповідь числом.
+
+```js
+assert(typeof getIndexToIns([40, 60], 50) === 'number');
+```
+
+`getIndexToIns([3, 10, 5], 3)` має дати відповідь `0`.
+
+```js
+assert(getIndexToIns([3, 10, 5], 3) === 0);
+```
+
+`getIndexToIns([3, 10, 5], 3)` має дати відповідь числом.
+
+```js
+assert(typeof getIndexToIns([3, 10, 5], 3) === 'number');
+```
+
+`getIndexToIns([5, 3, 20, 3], 5)` має дати відповідь `2`.
+
+```js
+assert(getIndexToIns([5, 3, 20, 3], 5) === 2);
+```
+
+`getIndexToIns([5, 3, 20, 3], 5)` має дати відповідь числом.
+
+```js
+assert(typeof getIndexToIns([5, 3, 20, 3], 5) === 'number');
+```
+
+`getIndexToIns([2, 20, 10], 19)` має дати відповідь `2`.
+
+```js
+assert(getIndexToIns([2, 20, 10], 19) === 2);
+```
+
+`getIndexToIns([2, 20, 10], 19)` має дати відповідь числом.
+
+```js
+assert(typeof getIndexToIns([2, 20, 10], 19) === 'number');
+```
+
+`getIndexToIns([2, 5, 10], 15)` має дати відповідь `3`.
+
+```js
+assert(getIndexToIns([2, 5, 10], 15) === 3);
+```
+
+`getIndexToIns([2, 5, 10], 15)` має дати відповідь числом.
+
+```js
+assert(typeof getIndexToIns([2, 5, 10], 15) === 'number');
+```
+
+`getIndexToIns([], 1)` має дати відповідь `0`.
+
+```js
+assert(getIndexToIns([], 1) === 0);
+```
+
+`getIndexToIns([], 1)` має дати відповідь числом.
+
+```js
+assert(typeof getIndexToIns([], 1) === 'number');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function getIndexToIns(arr, num) {
+  return num;
+}
+
+getIndexToIns([40, 60], 50);
+```
+
+# --solutions--
+
+```js
+function getIndexToIns(arr, num) {
+  arr = arr.sort((a, b) => a - b);
+
+  for (let i = 0; i < arr.length; i++) {
+    if (arr[i] >= num) {
+      return i;
+    }
+  }
+
+  return arr.length;
+}
+
+getIndexToIns([40, 60], 50);
+```
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-data-structures/access-an-arrays-contents-using-bracket-notation.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-data-structures/access-an-arrays-contents-using-bracket-notation.md
@@ -0,0 +1,82 @@
+---
+id: 5a661e0f1068aca922b3ef17
+title: Використання дужок для доступу до вмісту масиву
+challengeType: 1
+forumTopicId: 301149
+dashedName: access-an-arrays-contents-using-bracket-notation
+---
+
+# --description--
+
+Фундаментальною особливістю будь-якої структури даних, звичайно ж, є можливість не тільки зберігати дані, але і мати можливість отримувати ці дані по команді. Отже, тепер, коли ми дізналися, як створити масив, давайте подумаєте над тим, як ми можемо отримати доступ до інформації цього масиву.
+
+Коли ми визначаємо простий масив як показано нижче, в ньому є 3 елементи:
+
+```js
+let ourArray = ["a", "b", "c"];
+```
+
+У масиві кожен елемент масиву має <dfn>індекс</dfn>. Цей індекс подвоюється як позиція цього елемента в масиві і як ви на нього посилаєтесь. Проте важливо зазначити, що масиви JavaScript мають <dfn>нульовий індекс</dfn>це означає, що перший елемент масиву фактично знаходиться в ***нульовій*** позиції, а не в першій. Щоб отримати елемент з масиву, ми можемо помістити індекс в дужки і додати його в кінець масиву або, що відбувається частіше, до змінної, яка посилається на об'єкт масиву. Такий спосіб називають <dfn>дужки</dfn>. Наприклад, якщо ми хочемо отримати `a` з `ourArray` та призначити йому змінну, ми можемо зробити це за допомогою наступного коду:
+
+```js
+let ourVariable = ourArray[0];
+```
+
+Тепер `ourVariable` має значення `a`.
+
+Крім доступу до значення, пов'язаного з індексом, ви також можете* встановити *індекс для значення, використовуючи таке ж позначення:
+
+```js
+ourArray[1] = "not b anymore";
+```
+
+Використовуючи дужки, ми скинули елемент з індексом 1 з рядка `b`, на `not b anymore`. Тепер `ourArray` це `["a", "not b anymore", "c"]`.
+
+# --instructions--
+
+Щоб виконати це завдання, встановіть другу позицію (index `1`) для `myArray` на все, що захочете, крім букви `b`.
+
+# --hints--
+
+`myArray[0]` повинен дорівнювати букві `a`
+
+```js
+assert.strictEqual(myArray[0], 'a');
+```
+
+`myArray[1]` не повинен дорівнювати букві `b`
+
+```js
+assert.notStrictEqual(myArray[1], 'b');
+```
+
+`myArray[2]` повинен дорівнювати букві `c`
+
+```js
+assert.strictEqual(myArray[2], 'c');
+```
+
+`myArray[3]` повинен дорівнювати букві `d`
+
+```js
+assert.strictEqual(myArray[3], 'd');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let myArray = ["a", "b", "c", "d"];
+// Only change code below this line
+
+// Only change code above this line
+console.log(myArray);
+```
+
+# --solutions--
+
+```js
+let myArray = ["a", "b", "c", "d"];
+myArray[1] = "e";
+```
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-data-structures/access-property-names-with-bracket-notation.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-data-structures/access-property-names-with-bracket-notation.md
@@ -0,0 +1,101 @@
+---
+id: 587d7b7c367417b2b2512b1a
+title: Доступ до назв властивостей за допомогою дужок
+challengeType: 1
+forumTopicId: 301150
+dashedName: access-property-names-with-bracket-notation
+---
+
+# --description--
+
+У першому завданні про об'єкт ми згадували використання дужок як спосіб доступу до значень властивостей за допомогою оцінювання змінної. Наприклад, уявіть, що наш об'єкт `foods` використовується в програмі для касового апарату супермаркету. У нас є функція, яка встановлює `selectedFood` і ми хочемо перевірити наш об'єкт `foods` на наявність цієї їжі. Це може виглядати так:
+
+```js
+let selectedFood = getCurrentFood(scannedItem);
+let inventory = foods[selectedFood];
+```
+
+Цей код оцінить значення, яке зберігається в змінній `selectedFood` та поверне значення цього ключа в об'єкт`foods`, або `undefined` якщо він відсутній. Дужки дуже корисні, тому що іноді властивості об'єкта невідомі до часу виконання або нам потрібно отримати до них доступ більш динамічним способом.
+
+# --instructions--
+
+Ми визначили функцію, `checkInventory`, яка отримує відсканований елемент в якості аргументу. Повернути поточне значення ключа `scannedItem` в об'єкті `foods`. Ви можете припустити, що тільки дійсні ключі будуть надані в якості аргументу для `checkInventory`.
+
+# --hints--
+
+`checkInventory` повинен бути функцією.
+
+```js
+assert.strictEqual(typeof checkInventory, 'function');
+```
+
+Об'єкт `foods` повинен мати тільки наступні пари ключових значень: `apples: 25`, `oranges: 32`, `plums: 28`, `bananas: 13`, `grapes: 35`, `strawberries: 27`.
+
+```js
+assert.deepEqual(foods, {
+  apples: 25,
+  oranges: 32,
+  plums: 28,
+  bananas: 13,
+  grapes: 35,
+  strawberries: 27
+});
+```
+
+`checkInventory("apples")` повинен повернути `25`.
+
+```js
+assert.strictEqual(checkInventory('apples'), 25);
+```
+
+`checkInventory("bananas")` повинен повернути `13`.
+
+```js
+assert.strictEqual(checkInventory('bananas'), 13);
+```
+
+`checkInventory("strawberries")` повинен повернути `27`.
+
+```js
+assert.strictEqual(checkInventory('strawberries'), 27);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let foods = {
+  apples: 25,
+  oranges: 32,
+  plums: 28,
+  bananas: 13,
+  grapes: 35,
+  strawberries: 27
+};
+
+function checkInventory(scannedItem) {
+  // Only change code below this line
+
+  // Only change code above this line
+}
+
+console.log(checkInventory("apples"));
+```
+
+# --solutions--
+
+```js
+let foods = {
+  apples: 25,
+  oranges: 32,
+  plums: 28,
+  bananas: 13,
+  grapes: 35,
+  strawberries: 27
+};
+
+function checkInventory(scannedItem) {
+  return foods[scannedItem];
+}
+```
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-data-structures/add-items-to-an-array-with-push-and-unshift.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-data-structures/add-items-to-an-array-with-push-and-unshift.md
@@ -0,0 +1,87 @@
+---
+id: 587d78b2367417b2b2512b0e
+title: Додати елементи в масив за допомогою функцій push() і unshift()
+challengeType: 1
+forumTopicId: 301151
+dashedName: add-items-to-an-array-with-push-and-unshift
+---
+
+# --description--
+
+Довжина масиву, як і типи даних, які він може містити, не фіксована. Масиви можуть бути створені з будь-якою кількістю елементів, і елементи можуть бути додані або видалені з плином часу; іншими словами, масиви <dfn> мінливі</dfn>. У цьому завданні ми розглянемо два методи, за допомогою яких ми можемо програмно змінювати масив: `Array.push()` і `Array.unshift()`.
+
+Обидва методи приймають один або кілька елементів в якості параметрів і додають ці елементи в масив, для якого викликається метод; метод `push()` додає елементи в кінець масиву, а `unshift()` додає елементи на початок. Зверніть увагу:
+
+```js
+let twentyThree = 'XXIII';
+let romanNumerals = ['XXI', 'XXII'];
+
+romanNumerals.unshift('XIX', 'XX');
+```
+
+`romanNumerals` мав би значення `['XIX', 'XX', 'XXI', 'XXII']`.
+
+```js
+romanNumerals.push(twentyThree);
+```
+
+`romanNumerals` мав би значення `['XIX', 'XX', 'XXI', 'XXII', 'XXIII']`. Зверніть увагу, що ми також можемо передавати змінні, що дає нам ще більшу гнучкість при динамічній зміні даних нашого масиву.
+
+# --instructions--
+
+Ми визначили функцію, `mixedNumbers`, якій ми передаємо масив як аргумент. Змініть функцію за допомогою `push()` та`unshift()` щоб додати `'I', 2, 'three'` на початок масиву і `7, 'VIII', 9` в кінець, щоб повернутий масив містив числа 1-9 по порядку.
+
+# --hints--
+
+`mixedNumbers(["IV", 5, "six"])` тепер повинен повернути `["I", 2, "three", "IV", 5, "six", 7, "VIII", 9]`
+
+```js
+assert.deepEqual(mixedNumbers(['IV', 5, 'six']), [
+  'I',
+  2,
+  'three',
+  'IV',
+  5,
+  'six',
+  7,
+  'VIII',
+  9
+]);
+```
+
+Функція `mixedNumbers` повинна використовувати `push()` метод
+
+```js
+assert(mixedNumbers.toString().match(/\.push/));
+```
+
+Функція `mixedNumbers` повинна використовувати `unshift()` метод
+
+```js
+assert(mixedNumbers.toString().match(/\.unshift/));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function mixedNumbers(arr) {
+  // Only change code below this line
+
+  // Only change code above this line
+  return arr;
+}
+
+console.log(mixedNumbers(['IV', 5, 'six']));
+```
+
+# --solutions--
+
+```js
+function mixedNumbers(arr) {
+  arr.push(7,'VIII',9);
+  arr.unshift('I',2,'three');
+  return arr;
+}
+```
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-data-structures/add-items-using-splice.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-data-structures/add-items-using-splice.md
@@ -0,0 +1,93 @@
+---
+id: 587d78b3367417b2b2512b11
+title: Видалити елементи за допомогою функції splice()
+challengeType: 1
+forumTopicId: 301152
+dashedName: add-items-using-splice
+---
+
+# --description--
+
+Пам'ятаєте, в попередньому завданні ми згадували, що `splice()` може приймати до трьох параметрів? Що ж, ви можете використовувати третій параметр, що складається з одного або декількох елементів, для додавання в масив. Це може бути неймовірно корисно для швидкої зміни елемента або набору елементів для іншого елемента.
+
+```js
+const numbers = [10, 11, 12, 12, 15];
+const startIndex = 3;
+const amountToDelete = 1;
+
+numbers.splice(startIndex, amountToDelete, 13, 14);
+console.log(numbers);
+```
+
+В другому випадку `12` видалений, і ми додаємо `13` і `14` до того ж індексу. Тепер масив `numbers` буде мати вигляд `[ 10, 11, 12, 13, 14, 15 ]`.
+
+Тут ми починаємо з масиву чисел. Потім ми передаємо в `splice()` наступне: індекс, з якого слід почати видалення елементів (3), кількість елементів, які потрібно видалити (1), і решта аргументів (13, 14) будуть вставлені, починаючи з того ж індексу. Зверніть увагу, що після `amountToDelete` може бути будь-яка кількість елементів (розділених комами), кожен з яких вставляється.
+
+# --instructions--
+
+Ми визначили функцію `htmlColorNames`, яка приймає в якості аргументу масив кольорів HTML. Змініть функцію за допомогою `splice()`, щоб видалити перші два елементи масиву і додати `'DarkSalmon'` та `'BlanchedAlmond'` на свої місця.
+
+# --hints--
+
+`htmlColorNames` повинен повернути `["DarkSalmon", "BlanchedAlmond", "LavenderBlush", "PaleTurquoise", "FireBrick"]`
+
+```js
+assert.deepEqual(
+  htmlColorNames([
+    'DarkGoldenRod',
+    'WhiteSmoke',
+    'LavenderBlush',
+    'PaleTurquoise',
+    'FireBrick'
+  ]),
+  [
+    'DarkSalmon',
+    'BlanchedAlmond',
+    'LavenderBlush',
+    'PaleTurquoise',
+    'FireBrick'
+  ]
+);
+```
+
+Функція `htmlColorNames` повинна використовувати `splice()` метод
+
+```js
+assert(/.splice/.test(code));
+```
+
+Вам не слід використовувати `shift()` або `unshift()`.
+
+```js
+assert(!/shift|unshift/.test(code));
+```
+
+Вам не слід використовувати дужки масиву.
+
+```js
+assert(!/\[\d\]\s*=/.test(code));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function htmlColorNames(arr) {
+  // Only change code below this line
+
+  // Only change code above this line
+  return arr;
+}
+
+console.log(htmlColorNames(['DarkGoldenRod', 'WhiteSmoke', 'LavenderBlush', 'PaleTurquoise', 'FireBrick']));
+```
+
+# --solutions--
+
+```js
+function htmlColorNames(arr) {
+  arr.splice(0,2,'DarkSalmon', 'BlanchedAlmond');
+  return arr;
+}
+```
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-data-structures/add-key-value-pairs-to-javascript-objects.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-data-structures/add-key-value-pairs-to-javascript-objects.md
@@ -0,0 +1,124 @@
+---
+id: 587d7b7c367417b2b2512b18
+title: Додавання пар Key-Value (ключ-значення) до об'єктів JavaScript
+challengeType: 1
+forumTopicId: 301153
+dashedName: add-key-value-pairs-to-javascript-objects
+---
+
+# --description--
+
+По суті, об'єкти - це просто набори пар <dfn>ключ-значення</dfn>. Іншими словами, це фрагменти даних (<dfn>значення</dfn>), зіставлені з унікальними ідентифікаторами, що називаються <dfn>властивостями</dfn> (<dfn>ключами</dfn>). Розглянемо приклад:
+
+```js
+const tekkenCharacter = {
+  player: 'Hwoarang',
+  fightingStyle: 'Tae Kwon Doe',
+  human: true
+};
+```
+
+Наведений вище код називає об'єкт персонажа відеоігри Tekken з ім'ям `tekkenCharacter`. У нього є три властивості, кожна з яких відповідає певному значенню. Якщо ви хочете додати додаткову властивість, таку як "origin", це можна зробити, призначивши `origin` об’єкту:
+
+```js
+tekkenCharacter.origin = 'South Korea';
+```
+
+Тут використовується крапкова нотація. Якщо ви спостерігали за об'єктом `tekkenCharacter`, то тепер він містить властивість `origin`. У Хвоаранга також було яскраво-помаранчеве волосся. Ви можете додати цю властивість в дужки, виконавши:
+
+```js
+tekkenCharacter['hair color'] = 'dyed orange';
+```
+
+Позначення в дужках потрібно, якщо у вашій властивості є пробіл або якщо ви хочете використовувати змінну для імені властивості. У наведеному вище випадку властивість розміщується в лапках, щоб позначити її як рядок і вона буде додана точно так, як показано. Без лапок вона буде оцінюватися як змінна, а ім'я властивості буде мати будь-яке значення змінної. Ось приклад зі змінною:
+
+```js
+const eyes = 'eye color';
+
+tekkenCharacter[eyes] = 'brown';
+```
+
+Після додавання всіх прикладів об'єкт буде виглядати так:
+
+```js
+{
+  player: 'Hwoarang',
+  fightingStyle: 'Tae Kwon Doe',
+  human: true,
+  origin: 'South Korea',
+  'hair color': 'dyed orange',
+  'eye color': 'brown'
+};
+```
+
+# --instructions--
+
+Об'єкт `foods` був створений з трьома записами. Використовуючи обраний синтаксис, додайте до нього ще три записи: `bananas` із значенням `13`, `grapes` із значенням `35`, та `strawberries` із значенням `27`.
+
+# --hints--
+
+`foods` повинен бути об'єктом.
+
+```js
+assert(typeof foods === 'object');
+```
+
+Об'єкт `foods` повинен мати ключ `bananas` зі значенням `13`.
+
+```js
+assert(foods.bananas === 13);
+```
+
+Об'єкт `foods` повинен мати ключ `grapes` зі значенням `35`.
+
+```js
+assert(foods.grapes === 35);
+```
+
+Об'єкт `foods` повинен мати ключ `strawberries` зі значенням `27`.
+
+```js
+assert(foods.strawberries === 27);
+```
+
+Пари "ключ-значення" повинні бути встановлені за допомогою крапок або дужок.
+
+```js
+assert(
+  code.search(/bananas:/) === -1 &&
+    code.search(/grapes:/) === -1 &&
+    code.search(/strawberries:/) === -1
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let foods = {
+  apples: 25,
+  oranges: 32,
+  plums: 28
+};
+
+// Only change code below this line
+
+// Only change code above this line
+
+console.log(foods);
+```
+
+# --solutions--
+
+```js
+let foods = {
+  apples: 25,
+  oranges: 32,
+  plums: 28
+};
+
+foods['bananas'] = 13;
+foods['grapes']  = 35;
+foods['strawberries'] = 27;
+```
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-data-structures/check-for-the-presence-of-an-element-with-indexof.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-data-structures/check-for-the-presence-of-an-element-with-indexof.md
@@ -0,0 +1,93 @@
+---
+id: 587d7b7b367417b2b2512b14
+title: Перевірка наявності елемента за допомогою indexOf()
+challengeType: 1
+forumTopicId: 301154
+dashedName: check-for-the-presence-of-an-element-with-indexof
+---
+
+# --description--
+
+Оскільки масиви можуть бути змінені або *mutated* в будь-який час, немає ніяких гарантій щодо того, де конкретний фрагмент даних буде знаходитися в даному масиві, або що цей елемент все ще існує. На щастя, JavaScript надає нам ще один вбудований метод, `indexOf()`, який дозволяє нам швидко і легко перевіряти наявність елемента в масиві. `indexOf()` приймає елемент як параметр і при запиті - повертає позицію або індекс цього елемента або `-1`, якщо елементу в масиві немає.
+
+Наприклад:
+
+```js
+let fruits = ['apples', 'pears', 'oranges', 'peaches', 'pears'];
+
+fruits.indexOf('dates');
+fruits.indexOf('oranges');
+fruits.indexOf('pears');
+```
+
+`indexOf('dates')` повертає `-1`, `indexOf('oranges')` повертає `2`, і `indexOf('pears')` повертає `1` (перший індекс, за яким існує кожен елемент).
+
+# --instructions--
+
+`indexOf()` може бути неймовірно корисним для швидкої перевірки наявності елемента в масиві. Ми визначили функцію `quickCheck`, яка приймає в якості аргументів масив і елемент. Змініть функцію використовуючи `indexOf()` так, щоб вона повернула `true` якщо переданий елемент існує в масиві, та `false` якщо не існує.
+
+# --hints--
+
+Функція `quickCheck` повинна повернути логічне значення (`true` або `false`), а не рядок (`"true"` або `"false"`)
+
+```js
+assert.isBoolean(quickCheck(['squash', 'onions', 'shallots'], 'mushrooms'));
+```
+
+`quickCheck(["squash", "onions", "shallots"], "mushrooms")` повинна повернути `false`
+
+```js
+assert.strictEqual(
+  quickCheck(['squash', 'onions', 'shallots'], 'mushrooms'),
+  false
+);
+```
+
+`quickCheck(["onions", "squash", "shallots"], "onions")` повинна повернути `true`
+
+```js
+assert.strictEqual(
+  quickCheck(['onions', 'squash', 'shallots'], 'onions'),
+  true
+);
+```
+
+`quickCheck([3, 5, 9, 125, 45, 2], 125)` повинна повернути `true`
+
+```js
+assert.strictEqual(quickCheck([3, 5, 9, 125, 45, 2], 125), true);
+```
+
+`quickCheck([true, false, false], undefined)` повинна повернути `false`
+
+```js
+assert.strictEqual(quickCheck([true, false, false], undefined), false);
+```
+
+Функція `quickCheck` повинна використовувати метод `indexOf()`
+
+```js
+assert.notStrictEqual(quickCheck.toString().search(/\.indexOf\(/), -1);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function quickCheck(arr, elem) {
+  // Only change code below this line
+
+  // Only change code above this line
+}
+
+console.log(quickCheck(['squash', 'onions', 'shallots'], 'mushrooms'));
+```
+
+# --solutions--
+
+```js
+function quickCheck(arr, elem) {
+  return arr.indexOf(elem) >= 0; 
+}
+```
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-data-structures/check-if-an-object-has-a-property.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-data-structures/check-if-an-object-has-a-property.md
@@ -0,0 +1,161 @@
+---
+id: 587d7b7d367417b2b2512b1c
+title: Перевірте, чи має об'єкт властивість
+challengeType: 1
+forumTopicId: 301155
+dashedName: check-if-an-object-has-a-property
+---
+
+# --description--
+
+Тепер ми можемо додавати, змінювати та видаляти ключі з об'єктів. А якщо ми просто хочемо знати, чи об'єкт має конкретну властивість? JavaScript надає нам два різних способи це зробити. Один використовує метод `hasOwnProperty()` а інший використовує ключове слово `in`. Якщо у нас є об'єкт `users` з властивістю `Alan`, ми можемо перевірити її наявність одним із таких способів:
+
+```js
+users.hasOwnProperty('Alan');
+'Alan' in users;
+```
+
+Обидва вони повернуть `true`.
+
+# --instructions--
+
+Завершіть написання функції таким чином, щоб вона повертала true, якщо переданий їй об'єкт містить всі чотири імені: `Alan`, `Jeff`, `Sarah` і `Ryan`, а в іншому випадку - щоб повертала false.
+
+# --hints--
+
+До об'єкту `users` не можна звертатися безпосередньо
+
+```js 
+
+assert(code.match(/users/gm).length <= 2)
+
+```
+
+Об'єкт `users` повинен містити тільки ключі `Alan`, `Jeff`, `Sarah`, та `Ryan`
+
+```js
+assert(
+  'Alan' in users &&
+    'Jeff' in users &&
+    'Sarah' in users &&
+    'Ryan' in users &&
+    Object.keys(users).length === 4
+);
+```
+
+Функція `isEveryoneHere` повинна повертати `true` якщо `Alan`, `Jeff`, `Sarah`, та `Ryan` це властивості переданого їй об'єкту.
+
+```js
+assert(isEveryoneHere(users) === true);
+```
+
+Функція `isEveryoneHere` повинна повернути `false` якщо `Alan` не є властивістю переданого їй об'єкту.
+
+```js
+assert(
+  (function () {
+    delete users.Alan;
+    return isEveryoneHere(users);
+  })() === false
+);
+```
+
+Функція `isEveryoneHere` повинна повернути`false` якщо `Jeff` не є властивістю переданого їй об'єкту.
+
+```js
+assert(
+  (function () {
+    delete users.Jeff;
+    return isEveryoneHere(users);
+  })() === false
+);
+```
+
+Функція `isEveryoneHere` повинна повернути `false` якщо `Sarah` не є властивістю переданого їй об'єкту.
+
+```js
+assert(
+  (function () {
+    delete users.Sarah;
+    return isEveryoneHere(users);
+  })() === false
+);
+```
+
+Функція `isEveryoneHere` повинна повернути `false` якщо `Ryan` не є властивістю переданого їй об'єкту.
+
+```js
+assert(
+  (function () {
+    delete users.Ryan;
+    return isEveryoneHere(users);
+  })() === false
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let users = {
+  Alan: {
+    age: 27,
+    online: true
+  },
+  Jeff: {
+    age: 32,
+    online: true
+  },
+  Sarah: {
+    age: 48,
+    online: true
+  },
+  Ryan: {
+    age: 19,
+    online: true
+  }
+};
+
+function isEveryoneHere(userObj) {
+  // Only change code below this line
+
+  // Only change code above this line
+}
+
+console.log(isEveryoneHere(users));
+```
+
+# --solutions--
+
+```js
+let users = {
+  Alan: {
+    age: 27,
+    online: true
+  },
+  Jeff: {
+    age: 32,
+    online: true
+  },
+  Sarah: {
+    age: 48,
+    online: true
+  },
+  Ryan: {
+    age: 19,
+    online: true
+  }
+};
+
+function isEveryoneHere(userObj) {
+  return [
+    'Alan',
+    'Jeff',
+    'Sarah',
+    'Ryan'
+  ].every(user => userObj.hasOwnProperty(user));
+}
+
+console.log(isEveryoneHere(users));
+```
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-data-structures/combine-arrays-with-the-spread-operator.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-data-structures/combine-arrays-with-the-spread-operator.md
@@ -0,0 +1,63 @@
+---
+id: 587d7b7b367417b2b2512b17
+title: Об'єднайте масиви з Spread-оператором
+challengeType: 1
+forumTopicId: 301156
+dashedName: combine-arrays-with-the-spread-operator
+---
+
+# --description--
+
+Ще одна величезна перевага <dfn>spread</dfn>-оператора - це можливість комбінувати масиви або вставляти всі елементи одного масиву в інший по будь-якому індексу. Використовуючи більш традиційні види синтаксу, ми можемо об'єднувати масиви, але це дозволяє нам об'єднувати масиви тільки в кінці одного і на початку іншого. Функція Spread Synrax робить наступну операцію надзвичайно простою:
+
+```js
+let thisArray = ['sage', 'rosemary', 'parsley', 'thyme'];
+
+let thatArray = ['basil', 'cilantro', ...thisArray, 'coriander'];
+```
+
+`thatArray` буде мати значення `['basil', 'cilantro', 'sage', 'rosemary', 'parsley', 'thyme', 'coriander']`.
+
+Використовуючи функцію spread synrax, ми щойно виконали операцію, яка була б складнішою і більш детальною, якби ми використовували традиційні методи.
+
+# --instructions--
+
+Ми визначили функцію `spreadOut`, яка повертає змінну `sentence`. Змініть функцію використовуючи <dfn>spread</dfn> оператор, щоб вона повертала масив `['learning', 'to', 'code', 'is', 'fun']`.
+
+# --hints--
+
+`spreadOut` повинен повернути `["learning", "to", "code", "is", "fun"]`
+
+```js
+assert.deepEqual(spreadOut(), ['learning', 'to', 'code', 'is', 'fun']);
+```
+
+Функція `spreadOut` повинна використовувати spread syntax
+
+```js
+assert.notStrictEqual(spreadOut.toString().search(/[...]/), -1);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function spreadOut() {
+  let fragment = ['to', 'code'];
+  let sentence; // Change this line
+  return sentence;
+}
+
+console.log(spreadOut());
+```
+
+# --solutions--
+
+```js
+function spreadOut() {
+  let fragment = ['to', 'code'];
+  let sentence = ['learning', ...fragment, 'is', 'fun'];
+  return sentence;
+}
+```
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-data-structures/copy-an-array-with-the-spread-operator.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-data-structures/copy-an-array-with-the-spread-operator.md
@@ -0,0 +1,102 @@
+---
+id: 587d7b7b367417b2b2512b13
+title: Скопіюйте масив з Spread-оператором
+challengeType: 1
+forumTopicId: 301157
+dashedName: copy-an-array-with-the-spread-operator
+---
+
+# --description--
+
+Хоча `slice()` дозволяє нам вибирати, які елементи масиву копіювати, серед кількох інших корисних завдань, новий <dfn>spread-оператор</dfn> ES6 дозволяє нам легко копіювати *all* елементи масиву, по порядку, з простим і дуже читабельним синтаксисом. Spread синтаксис виглядає так: `...`
+
+На практиці ми можемо використати spread-оператор для копіювання масиву таким чином:
+
+```js
+let thisArray = [true, true, undefined, false, null];
+let thatArray = [...thisArray];
+```
+
+`thatArray` дорівнює `[true, true, undefined, false, null]`. `thisArray` залишається без змін і `thatArray` містить ті ж елементи, що й `thisArray`.
+
+# --instructions--
+
+Ми визначили функцію, `copyMachine`, яка приймає `arr` (масив) та `num` (номер) як аргументи. Функція повинна повертати новий масив, що складається з `num` копій `arr`. Ми виконали більшу частину роботи за вас, але це поки не працює. Змініть функцію, використовуючи spread синтаксис, щоб вона працювала правильно (підказка: тут може стати в нагоді інший метод, який ми вже розглядали!).
+
+# --hints--
+
+`copyMachine([true, false, true], 2)` повинна повернути `[[true, false, true], [true, false, true]]`
+
+```js
+assert.deepEqual(copyMachine([true, false, true], 2), [
+  [true, false, true],
+  [true, false, true]
+]);
+```
+
+`copyMachine([1, 2, 3], 5)` повинна повернути `[[1, 2, 3], [1, 2, 3], [1, 2, 3], [1, 2, 3], [1, 2, 3]]`
+
+```js
+assert.deepEqual(copyMachine([1, 2, 3], 5), [
+  [1, 2, 3],
+  [1, 2, 3],
+  [1, 2, 3],
+  [1, 2, 3],
+  [1, 2, 3]
+]);
+```
+
+`copyMachine([true, true, null], 1)` повинна повернути `[[true, true, null]]`
+
+```js
+assert.deepEqual(copyMachine([true, true, null], 1), [[true, true, null]]);
+```
+
+`copyMachine(["it works"], 3)` повинна повернути `[["it works"], ["it works"], ["it works"]]`
+
+```js
+assert.deepEqual(copyMachine(['it works'], 3), [
+  ['it works'],
+  ['it works'],
+  ['it works']
+]);
+```
+
+Функція `copyMachine` повинна використовувати `spread operator` з масивом `arr`
+
+```js
+assert(code.match(/\.\.\.arr/));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function copyMachine(arr, num) {
+  let newArr = [];
+  while (num >= 1) {
+    // Only change code below this line
+
+    // Only change code above this line
+    num--;
+  }
+  return newArr;
+}
+
+console.log(copyMachine([true, false, true], 2));
+```
+
+# --solutions--
+
+```js
+function copyMachine(arr,num){
+    let newArr=[];
+    while(num >=1){
+    newArr.push([...arr]);
+    num--;
+    }
+    return newArr;
+}
+console.log(copyMachine([true, false, true], 2));
+```
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-data-structures/copy-array-items-using-slice.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-data-structures/copy-array-items-using-slice.md
@@ -0,0 +1,65 @@
+---
+id: 587d7b7a367417b2b2512b12
+title: Скопіювати елементи масиву використовуючи slice()
+challengeType: 1
+forumTopicId: 301158
+dashedName: copy-array-items-using-slice
+---
+
+# --description--
+
+Наступний метод, який ми розглянемо це `slice()`. Замість зміни масиву `slice()` копіює або *extracts* задану кількість елементів в новий масив, залишаючи масив, для якого він викликається, незмінним. `slice()`приймає лише 2 параметри: перший - це індекс, з якого починається вибірка, а другий - індекс, за яким вибірка припиняється (вибірка відбуватиметься, але не включаючи елемент у цьому індексі). Врахуйте це:
+
+```js
+let weatherConditions = ['rain', 'snow', 'sleet', 'hail', 'clear'];
+
+let todaysWeather = weatherConditions.slice(1, 3);
+```
+
+`todaysWeather` матиме значення `['snow', 'sleet']`, хоча `weatherConditions` як і раніше буде мати `['rain', 'snow', 'sleet', 'hail', 'clear']`.
+
+Фактично, ми створили новий масив, вибираючи елементи з масиву, який вже існує.
+
+# --instructions--
+
+Ми визначили функцію `forecast`, яка приймає масив як аргумент. Змініть функцію за допомогою `slice()`, щоб вибрати інформацію з масиву аргументів і повернути новий масив, що містить елементи рядка `warm` і `sunny`.
+
+# --hints--
+
+`forecast` повинна повернути `["warm", "sunny"]`
+
+```js
+assert.deepEqual(
+  forecast(['cold', 'rainy', 'warm', 'sunny', 'cool', 'thunderstorms']),
+  ['warm', 'sunny']
+);
+```
+
+Функція `forecast` повинна використовувати `slice()` метод
+
+```js
+assert(/\.slice\(/.test(code));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function forecast(arr) {
+  // Only change code below this line
+
+  return arr;
+}
+
+// Only change code above this line
+console.log(forecast(['cold', 'rainy', 'warm', 'sunny', 'cool', 'thunderstorms']));
+```
+
+# --solutions--
+
+```js
+function forecast(arr) {
+  return arr.slice(2,4);
+}
+```
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-data-structures/create-complex-multi-dimensional-arrays.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-data-structures/create-complex-multi-dimensional-arrays.md
@@ -0,0 +1,218 @@
+---
+id: 587d7b7b367417b2b2512b16
+title: Створення комплексних багатовимірних масивів
+challengeType: 1
+forumTopicId: 301159
+dashedName: create-complex-multi-dimensional-arrays
+---
+
+# --description--
+
+Чудово! Ви щойно дізналися багато нового про масиви! Це був досить загальний огляд, і є ще багато чого, що потрібно дізнатися про роботу з масивами, багато чого ви побачите в наступних розділах. Але перш ніж перейти до розгляду <dfn>Objects</dfn>, давайте ще раз глянемо і подивимося, яким чином масиви можуть стати дещо складнішими за ті, які ми бачили в попередніх завданнях.
+
+Одна з найпотужніших функцій при розгляді масивів як структур даних полягає в тому, що масиви можуть містити або навіть повністю складатися з інших масивів. У попередніх завданнях ми бачили масиви, які містять масиви, але досить прості. Однак масиви можуть містити нескінченну глибину масивів, які можуть містити інші масиви, кожен зі своїми довільними рівнями глибини і так далі. Таким чином, масив може дуже швидко перетворитися в дуже складну структуру даних, відому як <dfn>multi-dimensional</dfn> або вкладений масив. Розглянемо наступний приклад:
+
+```js
+let nestedArray = [
+  ['deep'],
+  [
+    ['deeper'], ['deeper'] 
+  ],
+  [
+    [
+      ['deepest'], ['deepest']
+    ],
+    [
+      [
+        ['deepest-est?']
+      ]
+    ]
+  ]
+];
+```
+
+Масив `deep` вкладений на глибину 2 рівня. Масиви `deeper` мають глибину третього рівня. Масиви `deepest` мають 4 рівень, а `deepest-est?` - 5.
+
+Хоча цей приклад може здатися заплутаним, такий рівень складності не є чимось незвичним або навіть незвичайним при роботі з великими обсягами даних. Тим не менш, ми все ще можемо дуже легко отримати доступ до найглибших рівнів масиву цього складного масиву за допомогою дужок:
+
+```js
+console.log(nestedArray[2][1][0][0][0]);
+```
+
+Це записує рядок `deepest-est?`. І тепер, коли ми знаємо, де знаходиться цей фрагмент даних, ми можемо скинути його, якщо нам потрібно:
+
+```js
+nestedArray[2][1][0][0][0] = 'deeper still';
+
+console.log(nestedArray[2][1][0][0][0]);
+```
+
+Тепер він записує `deeper still`.
+
+# --instructions--
+
+Ми визначили змінну `myNestedArray`, що дорівнює масиву. Змініть `myNestedArray`, використовуючи будь-яку комбінацію <dfn>strings</dfn>, <dfn>numbers</dfn>, і <dfn>booleans</dfn> для елементів даних, так, щоб він мав точно п'ять рівнів глибини (пам'ятаєте, самий зовнішній масив - це рівень 1). Десь на третьому рівні, додайте рядок `deep`, на четвертому рівні, додайте рядок `deeper` та на п'ятому рівні, додайте рядок `deepest`.
+
+# --hints--
+
+`myNestedArray` повинен містити лише цифри, логічні значення та рядки в якості елементів даних
+
+```js
+assert.strictEqual(
+  (function (arr) {
+    let flattened = (function flatten(arr) {
+      const flat = [].concat(...arr);
+      return flat.some(Array.isArray) ? flatten(flat) : flat;
+    })(arr);
+    for (let i = 0; i < flattened.length; i++) {
+      if (
+        typeof flattened[i] !== 'number' &&
+        typeof flattened[i] !== 'string' &&
+        typeof flattened[i] !== 'boolean'
+      ) {
+        return false;
+      }
+    }
+    return true;
+  })(myNestedArray),
+  true
+);
+```
+
+`myNestedArray` повинен мати рівно 5 рівнів глибини
+
+```js
+assert.strictEqual(
+  (function (arr) {
+    let depth = 0;
+    function arrayDepth(array, i, d) {
+      if (Array.isArray(array[i])) {
+        arrayDepth(array[i], 0, d + 1);
+      } else {
+        depth = d > depth ? d : depth;
+      }
+      if (i < array.length) {
+        arrayDepth(array, i + 1, d);
+      }
+    }
+    arrayDepth(arr, 0, 0);
+    return depth;
+  })(myNestedArray),
+  4
+);
+```
+
+`myNestedArray` повинен містити рівно одне входження рядка `deep` в масиві, вкладеному в 3 рівень глибини
+
+```js
+assert(
+  (function howDeep(array, target, depth = 0) {
+    return array.reduce((combined, current) => {
+      if (Array.isArray(current)) {
+        return combined.concat(howDeep(current, target, depth + 1));
+      } else if (current === target) {
+        return combined.concat(depth);
+      } else {
+        return combined;
+      }
+    }, []);
+  })(myNestedArray, 'deep').length === 1 &&
+    (function howDeep(array, target, depth = 0) {
+      return array.reduce((combined, current) => {
+        if (Array.isArray(current)) {
+          return combined.concat(howDeep(current, target, depth + 1));
+        } else if (current === target) {
+          return combined.concat(depth);
+        } else {
+          return combined;
+        }
+      }, []);
+    })(myNestedArray, 'deep')[0] === 2
+);
+```
+
+`myNestedArray` повинен містити рівно одне входження рядка `deeper` в масиві, вкладеному в 4 рівень глибини
+
+```js
+assert(
+  (function howDeep(array, target, depth = 0) {
+    return array.reduce((combined, current) => {
+      if (Array.isArray(current)) {
+        return combined.concat(howDeep(current, target, depth + 1));
+      } else if (current === target) {
+        return combined.concat(depth);
+      } else {
+        return combined;
+      }
+    }, []);
+  })(myNestedArray, 'deeper').length === 1 &&
+    (function howDeep(array, target, depth = 0) {
+      return array.reduce((combined, current) => {
+        if (Array.isArray(current)) {
+          return combined.concat(howDeep(current, target, depth + 1));
+        } else if (current === target) {
+          return combined.concat(depth);
+        } else {
+          return combined;
+        }
+      }, []);
+    })(myNestedArray, 'deeper')[0] === 3
+);
+```
+
+`myNestedArray` повинен містити рівно одне входження рядка `deepest` в масиві, вкладеному в 5 рівень глибини
+
+```js
+assert(
+  (function howDeep(array, target, depth = 0) {
+    return array.reduce((combined, current) => {
+      if (Array.isArray(current)) {
+        return combined.concat(howDeep(current, target, depth + 1));
+      } else if (current === target) {
+        return combined.concat(depth);
+      } else {
+        return combined;
+      }
+    }, []);
+  })(myNestedArray, 'deepest').length === 1 &&
+    (function howDeep(array, target, depth = 0) {
+      return array.reduce((combined, current) => {
+        if (Array.isArray(current)) {
+          return combined.concat(howDeep(current, target, depth + 1));
+        } else if (current === target) {
+          return combined.concat(depth);
+        } else {
+          return combined;
+        }
+      }, []);
+    })(myNestedArray, 'deepest')[0] === 4
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let myNestedArray = [
+  // Only change code below this line
+  ['unshift', false, 1, 2, 3, 'complex', 'nested'],
+  ['loop', 'shift', 6, 7, 1000, 'method'],
+  ['concat', false, true, 'spread', 'array'],
+  ['mutate', 1327.98, 'splice', 'slice', 'push'],
+  ['iterate', 1.3849, 7, '8.4876', 'arbitrary', 'depth']
+  // Only change code above this line
+];
+```
+
+# --solutions--
+
+```js
+let myNestedArray = [
+  ['unshift', ['deep', ['deeper', ['deepest']]],false, 1, 2, 3, 'complex', 'nested'],
+  ['loop', 'shift', 6, 7, 1000, 'method'],
+  ['concat', false, true, 'spread', 'array'],
+  ['mutate', 1327.98, 'splice', 'slice', 'push'],
+  ['iterate', 1.3849, 7, '8.4876', 'arbitrary', 'depth']
+];
+```
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-data-structures/generate-an-array-of-all-object-keys-with-object.keys.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-data-structures/generate-an-array-of-all-object-keys-with-object.keys.md
@@ -0,0 +1,111 @@
+---
+id: 587d7b7d367417b2b2512b1e
+title: Створення масиву всіх ключів об’єкта за допомогою Object.keys()
+challengeType: 1
+forumTopicId: 301160
+dashedName: generate-an-array-of-all-object-keys-with-object-keys
+---
+
+# --description--
+
+Ми також можемо створити масив який містить всі ключі що зберігаються в об’єкті за допомогою методу `Object.keys()` і передавши об'єкт в якості аргументу. Це поверне масив з рядками, що представляють кожну властивість об'єкта. Знову ж таки, не буде певного порядку записів в масиві.
+
+# --instructions--
+
+Завершіть написання функції `getArrayOfUsers`, щоб вона повертала масив, що містить всі властивості об'єкта, який він отримує в якості аргументу.
+
+# --hints--
+
+Об'єкт `users` повинен містити тільки ключі `Alan`, `Jeff`, `Sarah`, та `Ryan`
+
+```js
+assert(
+  'Alan' in users &&
+    'Jeff' in users &&
+    'Sarah' in users &&
+    'Ryan' in users &&
+    Object.keys(users).length === 4
+);
+```
+
+Функція `getArrayOfUsers` повинна повернути масив, який містить усі ключі в об’єкті `users`
+
+```js
+assert(
+  (function () {
+    users.Sam = {};
+    users.Lewis = {};
+    let R = getArrayOfUsers(users);
+    return (
+      R.indexOf('Alan') !== -1 &&
+      R.indexOf('Jeff') !== -1 &&
+      R.indexOf('Sarah') !== -1 &&
+      R.indexOf('Ryan') !== -1 &&
+      R.indexOf('Sam') !== -1 &&
+      R.indexOf('Lewis') !== -1
+    );
+  })() === true
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let users = {
+  Alan: {
+    age: 27,
+    online: false
+  },
+  Jeff: {
+    age: 32,
+    online: true
+  },
+  Sarah: {
+    age: 48,
+    online: false
+  },
+  Ryan: {
+    age: 19,
+    online: true
+  }
+};
+
+function getArrayOfUsers(obj) {
+  // Only change code below this line
+
+  // Only change code above this line
+}
+
+console.log(getArrayOfUsers(users));
+```
+
+# --solutions--
+
+```js
+let users = {
+  Alan: {
+    age: 27,
+    online: false
+  },
+  Jeff: {
+    age: 32,
+    online: true
+  },
+  Sarah: {
+    age: 48,
+    online: false
+  },
+  Ryan: {
+    age: 19,
+    online: true
+  }
+};
+
+function getArrayOfUsers(obj) {
+  return Object.keys(obj);
+}
+
+console.log(getArrayOfUsers(users));
+```
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-data-structures/iterate-through-all-an-arrays-items-using-for-loops.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-data-structures/iterate-through-all-an-arrays-items-using-for-loops.md
@@ -0,0 +1,138 @@
+---
+id: 587d7b7b367417b2b2512b15
+title: Ітерація через усі масиви за допомогою циклів
+challengeType: 1
+forumTopicId: 301161
+dashedName: iterate-through-all-an-arrays-items-using-for-loops
+---
+
+# --description--
+
+Іноді при роботі з масивами дуже зручно мати можливість перебирати кожен елемент, щоб знайти один або кілька елементів, які можуть нам знадобитися, або керувати масивом в залежності від того, які елементи даних відповідають певному набору критеріїв. JavaScript надає різні побудови в методах, що ітерують крізь масиви й надають змогу досягнути певних результатів різними шляхами (such as `every()`, `forEach()`, `map()`, etc.). Однак, ця техніка є гнучкою й більш спроможна до контролю `for` циклу.
+
+Розглянемо наступний приклад:
+
+```js
+function greaterThanTen(arr) {
+  let newArr = [];
+  for (let i = 0; i < arr.length; i++) {
+    if (arr[i] > 10) {
+      newArr.push(arr[i]);
+    }
+  }
+  return newArr;
+}
+
+greaterThanTen([2, 12, 8, 14, 80, 0, 1]);
+```
+
+Завдяки використанню `for` у циклі, ця функція ітерує й надає доступ до кожного елементу в масиві простого тесту, який ми створили. Таким чином ми легко й автоматично визначаємо елементи дати, що більше, ніж `10`, й повертаємо новий масив, `[12, 14, 80]`, який містить ці елементи.
+
+# --instructions--
+
+Ми встановили функцію, `filteredArray`, яка обирає `arr`, вкладений масив, `elem` як аргументи, й повертає новий масив. `elem` означає елемент, що може не бути присутнім в одному або більше масивах в межах `arr`. Покращте функцію, використовуючи `for` циклу, для повернення відфільтрованої версії переданого масиву, так щоб версію в межах `arr` зі `elem` було прибрано.
+
+# --hints--
+
+`filteredArray([[10, 8, 3], [14, 6, 23], [3, 18, 6]], 18)` має повернути `[[10, 8, 3], [14, 6, 23]]`
+
+```js
+assert.deepEqual(
+  filteredArray(
+    [
+      [10, 8, 3],
+      [14, 6, 23],
+      [3, 18, 6]
+    ],
+    18
+  ),
+  [
+    [10, 8, 3],
+    [14, 6, 23]
+  ]
+);
+```
+
+`filteredArray([["trumpets", 2], ["flutes", 4], ["saxophones", 2]], 2)` має повернути `[["flutes", 4]]`
+
+```js
+assert.deepEqual(
+  filteredArray(
+    [
+      ['trumpets', 2],
+      ['flutes', 4],
+      ['saxophones', 2]
+    ],
+    2
+  ),
+  [['flutes', 4]]
+);
+```
+
+`filteredArray([["amy", "beth", "sam"], ["dave", "sean", "peter"]], "peter")` має повернути `[["amy", "beth", "sam"]]`
+
+```js
+assert.deepEqual(
+  filteredArray(
+    [
+      ['amy', 'beth', 'sam'],
+      ['dave', 'sean', 'peter']
+    ],
+    'peter'
+  ),
+  [['amy', 'beth', 'sam']]
+);
+```
+
+`filteredArray([[3, 2, 3], [1, 6, 3], [3, 13, 26], [19, 3, 9]], 3)` має повернути `[]`
+
+```js
+assert.deepEqual(
+  filteredArray(
+    [
+      [3, 2, 3],
+      [1, 6, 3],
+      [3, 13, 26],
+      [19, 3, 9]
+    ],
+    3
+  ),
+  []
+);
+```
+
+Функція `filteredArray` повинна використовуватися у циклі `for`
+
+```js
+assert.notStrictEqual(filteredArray.toString().search(/for/), -1);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function filteredArray(arr, elem) {
+  let newArr = [];
+  // Only change code below this line
+
+  // Only change code above this line
+  return newArr;
+}
+
+console.log(filteredArray([[3, 2, 3], [1, 6, 3], [3, 13, 26], [19, 3, 9]], 3));
+```
+
+# --solutions--
+
+```js
+function filteredArray(arr, elem) {
+  let newArr = [];
+  for (let i = 0; i<arr.length; i++) {
+    if (arr[i].indexOf(elem) < 0) {
+      newArr.push(arr[i]);
+    }
+  }
+  return newArr;
+}
+```
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-data-structures/iterate-through-the-keys-of-an-object-with-a-for...in-statement.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-data-structures/iterate-through-the-keys-of-an-object-with-a-for...in-statement.md
@@ -0,0 +1,138 @@
+---
+id: 587d7b7d367417b2b2512b1d
+title: Ітерація через ключі об'єкта у циклі "for...in"
+challengeType: 1
+forumTopicId: 301162
+dashedName: iterate-through-the-keys-of-an-object-with-a-for---in-statement
+---
+
+# --description--
+
+Часом вам треба буде ітерувати всі ключі всередині об'єкта. У JavaScript це вимагає певного синтаксису, що називається <dfn>for...in</dfn> циклом. Для нашого `users` об'єкту, це може виглядати так:
+
+```js
+for (let user in users) {
+  console.log(user);
+}
+```
+
+Це б зазначило, що `Alan`, `Jeff`, `Sarah`, і `Ryan` мають кожне значення у власному рядку.
+
+У цьому циклі ми визначили змінну `user` і, як ви можете побачити, цю змінну скидували під час кожної ітерації ключів об'єкта, в міру зациклювання через об’єкт, що призводить до того, що кожне ім'я користувача друкується на консолі.
+
+**ПРИМІТКА:** об'єкти не зберігають впорядкування ключів так, як це роблять масиви. Таким чином, позиція ключа в об'єкті або відносний його порядок є недоречним, коли ми його відсилаємо або отримуємо до нього доступ.
+
+# --instructions--
+
+Ми визначили функцію `countOnline`, яка приймає один аргумент (користувацький об'єкт). Використовуйте <dfn>for...in</dfn> цикл у межах цієї функції, щоб обробити користувацький об'єкт, який перейшов у функцію, і повернути кількість користувачів, чия `online` властивість установлена на `true`. Приклад користувацького об'єкту, який можна передати до `countOnline`, показано нижче. Кожен користувач матиме `online` властивість з обома `true` або `false` значеннями.
+
+```js
+{
+  Alan: {
+    online: false
+  },
+  Jeff: {
+    online: true
+  },
+  Sarah: {
+    online: false
+  }
+}
+```
+
+# --hints--
+
+Для функції `countOnline` слід використовувати `for in` цикл, щоб ітерувати ключі об'єкта, який передається до неї.
+
+```js
+assert(
+  code.match(
+    /for\s*\(\s*(var|let|const)\s+[a-zA-Z_$]\w*\s+in\s+[a-zA-Z_$]\w*\s*\)/
+  )
+);
+```
+
+Функція `countOnline` повинна повернути `1`, коли об'єкт `{ Alan: { online: false }, Jeff: { online: true }, Sarah: { online: false } }` передається до неї
+
+```js
+assert(countOnline(usersObj1) === 1);
+```
+
+Функція `countOnline` повинна повернути `2`, коли об'єкт `{ Alan: { online: true }, Jeff: { online: false }, Sarah: { online: true } }` передається до неї
+
+```js
+assert(countOnline(usersObj2) === 2);
+```
+
+Функція `countOnline` повинна повернути `0`, коли об'єкт `{ Alan: { online: false }, Jeff: { online: false }, Sarah: { online: false } }` передається до неї
+
+```js
+assert(countOnline(usersObj3) === 0);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+const usersObj1 = {
+  Alan: {
+    online: false
+  },
+  Jeff: {
+    online: true
+  },
+  Sarah: {
+    online: false
+  }
+}
+
+const usersObj2 = {
+  Alan: {
+    online: true
+  },
+  Jeff: {
+    online: false
+  },
+  Sarah: {
+    online: true
+  }
+}
+
+
+const usersObj3 = {
+  Alan: {
+    online: false
+  },
+  Jeff: {
+    online: false
+  },
+  Sarah: {
+    online: false
+  }
+}
+```
+
+## --seed-contents--
+
+```js
+function countOnline(usersObj) {
+  // Only change code below this line
+
+  // Only change code above this line
+}
+```
+
+# --solutions--
+
+```js
+function countOnline(usersObj) {
+  let online = 0;
+  for(let user in usersObj){
+    if(usersObj[user].online) {
+      online++;
+    }
+  }
+  return online;
+}
+```
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-data-structures/modify-an-array-stored-in-an-object.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-data-structures/modify-an-array-stored-in-an-object.md
@@ -0,0 +1,112 @@
+---
+id: 587d7b7d367417b2b2512b1f
+title: Змінити масив, збережений в об'єкті
+challengeType: 1
+forumTopicId: 301163
+dashedName: modify-an-array-stored-in-an-object
+---
+
+# --description--
+
+Тепер вам відомо про всі основні операції стосовно об'єктів JavaScript. Ви можете додавати, змінювати та видаляти пари ключів і значень, перевіряти, чи існують ключі, і ітерувати усі ключі в об'єкті. Продовжуючи вивчення JavaScript ви познайомитесь з ще більш універсальними програми об'єктів. Крім того, уроки про структури даних, що належать до розділу «Coding Interview Prep» навчальної програми, також містять інформацію про ES6 <dfn>Map</dfn> та <dfn>Set</dfn> об'єкти, які є схожими на звичайні об'єкти, але забезпечують певні додаткові функції. Тепер, коли ви з'ясували, що таке масиви та об'єкти, ви цілком готові до вирішення складніших проблем з допомогою JavaScript!
+
+# --instructions--
+
+Зверніть увагу на об’єкт, який подано в редакторі коду. Об'єкт `user` містить три ключі. Ключ `data` містить п'ять ключів, один з яких містить масив `friends`. З цього можна зрозуміти, наскільки гнучкими є об'єкти як структури даних. Ми почали писати функцію `addFriend`. Завершіть її для того, щоб вона прийняла об'єкт `user` і додала назву аргументу `friend` до масиву, збереженого в `user.data.friends` і повернула цей масив.
+
+# --hints--
+
+Об'єкт `user` повинен мати наступні ключі: `name`, `age` та `data`.
+
+```js
+assert('name' in user && 'age' in user && 'data' in user);
+```
+
+Функція `addFriend` повинна прийняти об’єкт `user` і рядок `friend` у ролі аргументів, а також додати ще один до масиву `friends` в об'єкті `user`.
+
+```js
+assert(
+  (function () {
+    let L1 = user.data.friends.length;
+    addFriend(user, 'Sean');
+    let L2 = user.data.friends.length;
+    return L2 === L1 + 1;
+  })()
+);
+```
+
+`addFriend(user, "Pete")` повинен повернути `["Sam", "Kira", "Tomo", "Pete"]`.
+
+```js
+assert.deepEqual(
+  (function () {
+    delete user.data.friends;
+    user.data.friends = ['Sam', 'Kira', 'Tomo'];
+    return addFriend(user, 'Pete');
+  })(),
+  ['Sam', 'Kira', 'Tomo', 'Pete']
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let user = {
+  name: 'Kenneth',
+  age: 28,
+  data: {
+    username: 'kennethCodesAllDay',
+    joinDate: 'March 26, 2016',
+    organization: 'freeCodeCamp',
+    friends: [
+      'Sam',
+      'Kira',
+      'Tomo'
+    ],
+    location: {
+      city: 'San Francisco',
+      state: 'CA',
+      country: 'USA'
+    }
+  }
+};
+
+function addFriend(userObj, friend) {
+  // Only change code below this line
+
+  // Only change code above this line
+}
+
+console.log(addFriend(user, 'Pete'));
+```
+
+# --solutions--
+
+```js
+let user = {
+  name: 'Kenneth',
+  age: 28,
+  data: {
+    username: 'kennethCodesAllDay',
+    joinDate: 'March 26, 2016',
+    organization: 'freeCodeCamp',
+    friends: [
+      'Sam',
+      'Kira',
+      'Tomo'
+    ],
+    location: {
+      city: 'San Francisco',
+      state: 'CA',
+      country: 'USA'
+    }
+  }
+};
+
+function addFriend(userObj, friend) {
+  userObj.data.friends.push(friend);
+  return userObj.data.friends;
+}
+```
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-data-structures/modify-an-object-nested-within-an-object.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-data-structures/modify-an-object-nested-within-an-object.md
@@ -0,0 +1,101 @@
+---
+id: 587d7b7c367417b2b2512b19
+title: Змінити об'єкт, вкладений в інший об'єкт
+challengeType: 1
+forumTopicId: 301164
+dashedName: modify-an-object-nested-within-an-object
+---
+
+# --description--
+
+Тепер давайте розглянемо дещо складніший об'єкт. Властивості об'єкта можуть бути вкладені на довільну глибину, а їхні значення можуть бути будь-яким видом даних, що підтримується JavaScript, включно з масивами й навіть іншими об'єктами. Зверніть увагу:
+
+```js
+let nestedObject = {
+  id: 28802695164,
+  date: 'December 31, 2016',
+  data: {
+    totalUsers: 99,
+    online: 80,
+    onlineStatus: {
+      active: 67,
+      away: 13,
+      busy: 8
+    }
+  }
+};
+```
+
+`nestedObject` має три властивості: `id` (значення — це число), `date` (значення — це рядок), а `data` (значення — це об'єкт з його вкладеною структурою). Хоча структури можуть швидко ускладнюватися, все одно можна використовувати ті самі позначення, щоб отримати доступ до необхідної інформації. Щоб закріпити значення `10` до властивості `busy`, вкладеної в об'єкт `onlineStatus`, використовується точкова нотація, щоб посилатись на властивість:
+
+```js
+nestedObject.data.onlineStatus.busy = 10;
+```
+
+# --instructions--
+
+Тут ми окреслили об'єкт `userActivity`, який включає в себе інший вкладений об'єкт. Встановіть значення ключа `online` до `45`.
+
+# --hints--
+
+`userActivity` повинен мати такі властивості: `id`,`date` і`data`.
+
+```js
+assert(
+  'id' in userActivity && 'date' in userActivity && 'data' in userActivity
+);
+```
+
+`userActivity` має мати `data` ключ, встановлений в об'єкті з `totalUsers` і `online` ключами.
+
+```js
+assert('totalUsers' in userActivity.data && 'online' in userActivity.data);
+```
+
+Властивість `online`, вкладена в `data` ключі `userActivity` повинен бути встановлений до `45`
+
+```js
+assert(userActivity.data.online === 45);
+```
+
+Властивість `online` повинна бути встановлена за допомогою точкової нотації або квадратних дужок.
+
+```js
+assert.strictEqual(code.search(/online: 45/), -1);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let userActivity = {
+  id: 23894201352,
+  date: 'January 1, 2017',
+  data: {
+    totalUsers: 51,
+    online: 42
+  }
+};
+
+// Only change code below this line
+
+// Only change code above this line
+
+console.log(userActivity);
+```
+
+# --solutions--
+
+```js
+let userActivity = {
+  id: 23894201352,
+  date: 'January 1, 2017',
+  data: {
+    totalUsers: 51,
+    online: 42
+  }
+};
+
+userActivity.data.online = 45;
+```
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-data-structures/remove-items-from-an-array-with-pop-and-shift.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-data-structures/remove-items-from-an-array-with-pop-and-shift.md
@@ -0,0 +1,86 @@
+---
+id: 587d78b2367417b2b2512b0f
+title: Видалити елементи з масиву за допомогою функцій pop() і shift()
+challengeType: 1
+forumTopicId: 301165
+dashedName: remove-items-from-an-array-with-pop-and-shift
+---
+
+# --description--
+
+Обидві функції `push()` і `unshift()` використовують відповідні методи, які за функціями майже протилежні: `pop()` та `shift()`. Як ви вже, напевне, зрозуміли, `pop()` *видаляє* елемент з кінця масиву, а не додає його, тоді як `shift()` видаляє елемент з початку. Ключова різниця між `pop()` і `shift()` та їх "ріднею", тобто `push()` і `unshift()` полягає в тому, що жоден метод не приймає параметри, а тільки дозволяє масиву змінюватися за допомогою одного елемента одночасно.
+
+Звернімо увагу:
+
+```js
+let greetings = ['whats up?', 'hello', 'see ya!'];
+
+greetings.pop();
+```
+
+`greetings` отримала б значення `['whats up?', 'hello']`.
+
+```js
+greetings.shift();
+```
+
+`greetings` отримала б значення `['hello']`.
+
+Ми також можемо повернути значення видаленого елемента за допомогою будь-якого з цих методів:
+
+```js
+let popped = greetings.pop();
+```
+
+`greetings` отримала б значення `[]`, а `popped` отримала б значення `hello`.
+
+# --instructions--
+
+Ми визначили функцію, `popShift`, яка приймає масив як аргумент і повертає новий масив. Змініть функцію, використовуючи `pop()` і `shift()`, щоб видалити перший та останній елементи масиву аргументів і призначити видалені елементи до їх відповідних змінних, щоб повернутий масив містив їхні значення.
+
+# --hints--
+
+`popShift(["challenge", "is", "not", "complete"])` має повернути `["challenge", "complete"]`
+
+```js
+assert.deepEqual(popShift(['challenge', 'is', 'not', 'complete']), [
+  'challenge',
+  'complete'
+]);
+```
+
+Функція `popShift` повинна використовувати метод `pop()`
+
+```js
+assert.notStrictEqual(popShift.toString().search(/\.pop\(/), -1);
+```
+
+Функція `popShift` повинна використовувати метод `shift()`
+
+```js
+assert.notStrictEqual(popShift.toString().search(/\.shift\(/), -1);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function popShift(arr) {
+  let popped; // Change this line
+  let shifted; // Change this line
+  return [shifted, popped];
+}
+
+console.log(popShift(['challenge', 'is', 'not', 'complete']));
+```
+
+# --solutions--
+
+```js
+function popShift(arr) {
+  let popped = arr.pop(); // Change this line
+  let shifted = arr.shift(); // Change this line
+  return [shifted, popped];
+}
+```
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-data-structures/remove-items-using-splice.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-data-structures/remove-items-using-splice.md
@@ -0,0 +1,87 @@
+---
+id: 587d78b2367417b2b2512b10
+title: Видалити елементи за допомогою функції splice()
+challengeType: 1
+forumTopicId: 301166
+dashedName: remove-items-using-splice
+---
+
+# --description--
+
+Що ж, ми дізналися, як видалити елементи з початку і кінця масиву, використовуючи `shift()` і `pop()`, але що робити, якщо ми хочемо прибрати елемент десь зі середини? Або видалити декілька елементів одразу? Якраз тут нам на допомогу може прийти `splice()`. `splice()` дозволяє нам зробити ось що: **видалити будь-яку кількість послідовних елементів** будь-де в масиві.
+
+`splice()` може прийняти до трьох параметрів, але зараз ми зосередимося на перших двох. Перші два параметри `splice()` — це цілі числа, які позначають індекси або позиції масиву, яким викликається `splice()`. Пам'ятайте, якщо масиви є *zero-indexed*, ми б використовували `0`, щоб зазначити перший елемент масиву. Перший параметр функції `splice()` позначає індекс в масиві, з якого починають видаляти елементи, у той час як другий параметр зазначає кількість елементів, необхідних для видалення. Наприклад:
+
+```js
+let array = ['today', 'was', 'not', 'so', 'great'];
+
+array.splice(2, 2);
+```
+
+Ось тут видаляємо 2 елементи, починаючи з третього елемента (за другим індексом). `array` отримала б значення `['today', 'was', 'great']`.
+
+`splice()` не лише змінює масив, на який вона викликається, але й повертає новий масив, що містить значення видалених елементів:
+
+```js
+let array = ['I', 'am', 'feeling', 'really', 'happy'];
+
+let newArray = array.splice(3, 2);
+```
+
+`newArray` має значення `['really', 'happy']`.
+
+# --instructions--
+
+Ми ініціалізували масив `arr`. Використовуйте `splice()`, щоб видалити елементи з `arr`, для того щоб він містив виключно елементи, які разом складають значення `10`.
+
+# --hints--
+
+Не потрібно змінювати вихідний рядок `const arr = [2, 4, 5, 1, 7, 5, 2, 1];`.
+
+```js
+assert(
+  __helpers.removeWhiteSpace(code).match(/constarr=\[2,4,5,1,7,5,2,1\];?/)
+);
+```
+
+`arr` повинен містити лише елементи, які разом складають значення до `10`.
+
+```js
+assert.strictEqual(
+  arr.reduce((a, b) => a + b),
+  10
+);
+```
+
+Ваш код повинен використовувати метод `splice()` у `arr`.
+
+```js
+assert(__helpers.removeWhiteSpace(code).match(/arr\.splice\(/));
+```
+
+Функція splice може лише видаляти елементи з `arr`, а не додавати їх до `arr`.
+
+```js
+assert(
+  !__helpers.removeWhiteSpace(code).match(/arr\.splice\(\d+,\d+,\d+.*\)/g)
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+const arr = [2, 4, 5, 1, 7, 5, 2, 1];
+// Only change code below this line
+
+// Only change code above this line
+console.log(arr);
+```
+
+# --solutions--
+
+```js
+const arr = [2, 4, 5, 1, 7, 5, 2, 1];
+arr.splice(1, 4);
+```
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-data-structures/use-an-array-to-store-a-collection-of-data.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-data-structures/use-an-array-to-store-a-collection-of-data.md
@@ -0,0 +1,95 @@
+---
+id: 587d7b7e367417b2b2512b20
+title: Використання масиву для зберігання зібраних даних
+challengeType: 1
+forumTopicId: 301167
+dashedName: use-an-array-to-store-a-collection-of-data
+---
+
+# --description--
+
+Нижче наведено приклад найпростішої реалізації структури масиву даних. Його називають <dfn>one-dimensional array</dfn>, що означає, що він має лише один рівень або що він не має жодних інших вкладених масивів. Зверніть увагу, що в ньому містяться <dfn>booleans</dfn>, <dfn>strings</dfn> і <dfn>numbers</dfn> серед інших дійсних типів даних JavaScript:
+
+```js
+let simpleArray = ['one', 2, 'three', true, false, undefined, null];
+console.log(simpleArray.length);
+```
+
+Виклик `console.log` відображає `7`.
+
+Усі масиви мають властивість довжини, до якої, як згадується вище, дуже легко можна отримати доступ за допомогою синтаксису `Array.length`. Складнішу реалізацію масиву можна побачити нижче. Це відомий <dfn>multi-dimensional array</dfn>, або масив що містить інші масиви. Зверніть увагу, що цей масив також включає JavaScript <dfn>objects</dfn>, які ми ретельно вивчатимемо в наступному розділі, але поки вам потрібно знати тільки те, що масиви також здатні зберігати складні об'єкти.
+
+```js
+let complexArray = [
+  [
+    {
+      one: 1,
+      two: 2
+    },
+    {
+      three: 3,
+      four: 4
+    }
+  ],
+  [
+    {
+      a: "a",
+      b: "b"
+    },
+    {
+      c: "c",
+      d: "d"
+    }
+  ]
+];
+```
+
+# --instructions--
+
+Ми визначили змінну з назвою `yourArray`. Виконайте інструкцію, призначаючи масив принаймні з 5 елементів у довжину до змінної `yourArray`. Ваш масив повинен містити щонайменше по-одному <dfn>string</dfn>, <dfn>number</dfn> і <dfn>boolean</dfn>.
+
+# --hints--
+
+`yourArray` повинна бути масивом.
+
+```js
+assert.strictEqual(Array.isArray(yourArray), true);
+```
+
+`yourArray` повинна складати щонайменше з 5 елементів в довжину.
+
+```js
+assert.isAtLeast(yourArray.length, 5);
+```
+
+`yourArray` повинна містити щонайменше одне `boolean`.
+
+```js
+assert(yourArray.filter((el) => typeof el === 'boolean').length >= 1);
+```
+
+`yourArray` повинна містити щонайменше одне `number`.
+
+```js
+assert(yourArray.filter((el) => typeof el === 'number').length >= 1);
+```
+
+`yourArray` повинна містити щонайменше один `string`.
+
+```js
+assert(yourArray.filter((el) => typeof el === 'string').length >= 1);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let yourArray; // Change this line
+```
+
+# --solutions--
+
+```js
+let yourArray = ['a string', 100, true, ['one', 2], 'another string'];
+```
--- a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-data-structures/use-the-delete-keyword-to-remove-object-properties.md
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-data-structures/use-the-delete-keyword-to-remove-object-properties.md
@@ -0,0 +1,86 @@
+---
+id: 587d7b7c367417b2b2512b1b
+title: Використати ключове слово delete для видалення властивостей об'єкта
+challengeType: 1
+forumTopicId: 301168
+dashedName: use-the-delete-keyword-to-remove-object-properties
+---
+
+# --description--
+
+Тепер вам відомо, що таке об'єкти, а також їхні основні функції і переваги. Коротше кажучи, вони — бази даних "ключ-значення", які забезпечують гнучкий та інтуїтивно зрозумілий спосіб структурування даних, ***і***, вони сприяють зменшенню часу пошуку. У решті цих завдань ми опишемо кілька типових операцій, які ви можете здійснити стосовно об'єктів, щоб вам було зручно застосовувати такі корисні структури даних у ваших програмах.
+
+У попередніх завданнях ми як додавали пари "ключ-значення" в об'єкт, так і змінювали їх. Таким чином, ми зрозуміємо, як ми можемо *видалити* пару "ключ-значення" з об'єкта.
+
+Повернімося до нашого прикладу об'єкту `foods` востаннє. Якщо ми хочемо видалити ключ `apples`, ми можемо зробити це за допомогою ключового слова `delete` наступним чином:
+
+```js
+delete foods.apples;
+```
+
+# --instructions--
+
+Використайте це ключове слово для видалення `oranges`, `plums` і `strawberries` ключів з об'єкту `foods`.
+
+# --hints--
+
+Об'єкт `foods` має включати тільки три ключі: `apples`, `grapes` і `bananas`.
+
+```js
+assert(
+  !foods.hasOwnProperty('oranges') &&
+    !foods.hasOwnProperty('plums') &&
+    !foods.hasOwnProperty('strawberries') &&
+    Object.keys(foods).length === 3
+);
+```
+
+Ключі `oranges`, `plums` і `strawberries` необхідно видалити, використовуючи `delete`.
+
+```js
+assert(
+  code.search(/oranges:/) !== -1 &&
+    code.search(/plums:/) !== -1 &&
+    code.search(/strawberries:/) !== -1
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let foods = {
+  apples: 25,
+  oranges: 32,
+  plums: 28,
+  bananas: 13,
+  grapes: 35,
+  strawberries: 27
+};
+
+// Only change code below this line
+
+// Only change code above this line
+
+console.log(foods);
+```
+
+# --solutions--
+
+```js
+let foods = {
+  apples: 25,
+  oranges: 32,
+  plums: 28,
+  bananas: 13,
+  grapes: 35,
+  strawberries: 27
+};
+
+delete foods.oranges;
+delete foods.plums;
+delete foods.strawberries;
+
+console.log(foods);
+```
--- 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/Show More
+++ b/Show More