tarasyyyk · Aug 25, 2021 · Aug 14, 2021 · Aug 14, 2021 · Aug 15, 2021 · Aug 15, 2021
diff --git a/1-js/05-data-types/05-array-methods/1-camelcase/_js.view/solution.js b/1-js/05-data-types/05-array-methods/1-camelcase/_js.view/solution.js
@@ -1,10 +1,10 @@
 function camelize(str) {
   return str
-    .split('-') // splits 'my-long-word' into array ['my', 'long', 'word']
+    .split('-') // розбиваємо 'my-long-word' на масив елементів ['my', 'long', 'word']
     .map(
-      // capitalizes first letters of all array items except the first one
-      // converts ['my', 'long', 'word'] into ['my', 'Long', 'Word']
+      // робимо першу літеру велику для всіх елементів масиву, крім першого
+      // конвертуємо ['my', 'long', 'word'] в ['my', 'Long', 'Word']
       (word, index) => index == 0 ? word : word[0].toUpperCase() + word.slice(1)
     )
-    .join(''); // joins ['my', 'Long', 'Word'] into 'myLongWord'
+    .join(''); // зʼєднуємо ['my', 'Long', 'Word'] в 'myLongWord'
 }
diff --git a/1-js/05-data-types/05-array-methods/1-camelcase/task.md b/1-js/05-data-types/05-array-methods/1-camelcase/task.md
@@ -2,18 +2,18 @@ importance: 5
 
 ---
 
-# Translate border-left-width to borderLeftWidth
+# Переведіть текст виду border-left-width в borderLeftWidth
 
-Write the function `camelize(str)` that changes dash-separated words like "my-short-string" into camel-cased "myShortString".
+Напишіть функцію `camelize(str)`, яка перетворює такі рядки "my-short-string" в "myShortString".
 
-That is: removes all dashes, each word after dash becomes uppercased.
+Тобто дефіси видаляються, а всі слова після них починаються з великої літери.
 
-Examples:
+Приклади:
 
 ```js
 camelize("background-color") == 'backgroundColor';
 camelize("list-style-image") == 'listStyleImage';
 camelize("-webkit-transition") == 'WebkitTransition';
 ```
 
-P.S. Hint: use `split` to split the string into an array, transform it and `join` back.
+P.S. Підказка: використовуйте `split`, щоб розбити рядок на масив символів, потім переробіть все як потрібно та методом `join` зʼєднайте елементи в рядок.
diff --git a/1-js/05-data-types/05-array-methods/10-average-age/solution.md b/1-js/05-data-types/05-array-methods/10-average-age/solution.md
@@ -3,11 +3,11 @@ function getAverageAge(users) {
   return users.reduce((prev, user) => prev + user.age, 0) / users.length;
 }
 
-let john = { name: "John", age: 25 };
-let pete = { name: "Pete", age: 30 };
-let mary = { name: "Mary", age: 29 };
+let ivan = { name: "Іван", age: 25 };
+let petro = { name: "Петро", age: 30 };
+let mariya = { name: "Марія", age: 29 };
 
-let arr = [ john, pete, mary ];
+let arr = [ ivan, petro, mariya ];
 
 alert( getAverageAge(arr) ); // 28
 ```

diff --git a/1-js/05-data-types/05-array-methods/10-average-age/task.md b/1-js/05-data-types/05-array-methods/10-average-age/task.md
@@ -2,13 +2,13 @@ importance: 4
 
 ---
 
-# Get average age
+# Вирахувати середній вік
 
-Write the function `getAverageAge(users)` that gets an array of objects with property `age` and returns the average age.
+Напишіть функцію `getAverageAge(users)`, яка приймає масив об’єктів з властивістю `age` та повертає середній вік.
 
-The formula for the average is `(age1 + age2 + ... + ageN) / N`.
+Формула обчислення середнього арифметичного значення: `(age1 + age2 + ... + ageN) / N`.
 
-For instance:
+Наприклад:
 
 ```js no-beautify
 let john = { name: "John", age: 25 };

diff --git a/1-js/05-data-types/05-array-methods/11-array-unique/solution.md b/1-js/05-data-types/05-array-methods/11-array-unique/solution.md
@@ -1,6 +1,6 @@
-Let's walk the array items:
-- For each item we'll check if the resulting array already has that item.
-- If it is so, then ignore, otherwise add to results.
+Давайте пройдемося по елементам масиву:
+- Для кожного елемента ми перевіримо, чи є він в масиві з результатом.
+- Якщо є, то ігноруємо його, а якщо немає -- додаємо до результатів.
 
 ```js run demo
 function unique(arr) {
@@ -15,25 +15,25 @@ function unique(arr) {
   return result;
 }
 
-let strings = ["Hare", "Krishna", "Hare", "Krishna",
-  "Krishna", "Krishna", "Hare", "Hare", ":-O"
+let strings = ["Привіт", "Світ", "Привіт", "Світ",
+  "Привіт", "Привіт", "Світ", "Світ", ":-O"
 ];
 
-alert( unique(strings) ); // Hare, Krishna, :-O
+alert( unique(strings) ); // Привіт, Світ, :-O
 ```
 
-The code works, but there's a potential performance problem in it.
+Код працює, але в ньому є потенційна проблема з продуктивністю.
 
-The method `result.includes(str)` internally walks the array `result` and compares each element against `str` to find the match.
+Метод `result.includes(str)` всередині себе обходить масив `result` і порівнює кожен елемент з `str`, щоб знайти збіг.
 
-So if there are `100` elements in `result` and no one matches `str`, then it will walk the whole `result` and do exactly `100` comparisons. And if `result` is large, like `10000`, then there would be `10000` comparisons.
+Таким чином, якщо `result` містить `100` елементів і жоден з них не збігається з `str`, тоді він обійде весь `result` і зробить рівно `100` порівнянь. А якщо `result` великий масив, наприклад, `10000` елементів, то буде зроблено `10000` порівнянь.
 
-That's not a problem by itself, because JavaScript engines are very fast, so walk `10000` array is a matter of microseconds.
+Само собою це не проблема, адже рушій JavaScript дуже швидкий, тому обхід `10000` елементів масиву займає лічені мікросекунди.
 
-But we do such test for each element of `arr`, in the `for` loop.
+Але ми робимо таку перевірку для кожного елемента `arr` в циклі `for`.
 
-So if `arr.length` is `10000` we'll have something like `10000*10000` = 100 millions of comparisons. That's a lot.
+Тому, якщо `arr.length` дорівнює `10000`, у нас буде щось на зразок `10000*10000` = 100 мільйонів порівнянь. Це забагато. 
 
-So the solution is only good for small arrays.
+Ось чому дане рішення підходить тільки для невеликих масивів.
 
-Further in the chapter <info:map-set> we'll see how to optimize it.
+Далі в розділі <info:map-set> ми побачимо, як його оптимізувати.
diff --git a/1-js/05-data-types/05-array-methods/11-array-unique/task.md b/1-js/05-data-types/05-array-methods/11-array-unique/task.md
@@ -2,22 +2,22 @@ importance: 4
 
 ---
 
-# Filter unique array members
+# Залишити унікальні елементи масиву
 
-Let `arr` be an array.
+Нехай `arr` -- масив рядків. 
 
-Create a function `unique(arr)` that should return an array with unique items of `arr`.
+Напишіть функцію `unique(arr)`, яка повертає масив, що містить тільки унікальні елементи `arr`.
 
-For instance:
+Наприклад:
 
 ```js
 function unique(arr) {
-  /* your code */
+  /* ваш код */
 }
 
-let strings = ["Hare", "Krishna", "Hare", "Krishna",
-  "Krishna", "Krishna", "Hare", "Hare", ":-O"
+let strings = ["Привіт", "Світ", "Привіт", "Світ",
+  "Привіт", "Привіт", "Світ", "Світ", ":-O"
 ];
 
-alert( unique(strings) ); // Hare, Krishna, :-O
+alert( unique(strings) ); // Привіт, Світ, :-O
 ```
diff --git a/1-js/05-data-types/05-array-methods/12-reduce-object/task.md b/1-js/05-data-types/05-array-methods/12-reduce-object/task.md
@@ -2,36 +2,36 @@ importance: 4
 
 ---
 
-# Create keyed object from array
+# Створення об’єкта з ключем з масиву
 
-Let's say we received an array of users in the form `{id:..., name:..., age:... }`.
+Припустимо, ми отримали масив користувачів у вигляді `{id:..., name:..., age:...}`.
 
-Create a function `groupById(arr)` that creates an object from it, with `id` as the key, and array items as values.
+Створіть функцію `groupById(arr)`, яка створює з масиву об’єкт із ключом `id` та елементами масиву як значеннями.
 
-For example:
+Наприклад:
 
 ```js
 let users = [
-  {id: 'john', name: "John Smith", age: 20},
-  {id: 'ann', name: "Ann Smith", age: 24},
-  {id: 'pete', name: "Pete Peterson", age: 31},
+  {id: 'іван', name: "Іван Іванко", age: 20},
+  {id: 'ганна', name: "Ганна Іванко", age: 24},
+  {id: 'петро', name: "Петро Петренко", age: 31},
 ];
 
 let usersById = groupById(users);
 
 /*
-// after the call we should have:
+// після виклику функції ви повинні отримати:
 
 usersById = {
-  john: {id: 'john', name: "John Smith", age: 20},
-  ann: {id: 'ann', name: "Ann Smith", age: 24},
-  pete: {id: 'pete', name: "Pete Peterson", age: 31},
+  іван: {id: 'іван', name: "Іван Іванко", age: 20},
+  ганна: {id: 'ганна', name: "Ганна Іванко", age: 24},
+  петро: {id: 'петро', name: "Петро Петренко", age: 31},
 }
 */
 ```
 
-Such function is really handy when working with server data.
+Така функція дійсно зручна при роботі з даними сервера.
 
-In this task we assume that `id` is unique. There may be no two array items with the same `id`.
+У цьому завданні ми вважаємо, що `id` унікальний. Не може бути двох елементів масиву з однаковими `id`.
 
-Please use array `.reduce` method in the solution.
+Будь ласка, використовуйте метод масиву `.reduce`  у рішенні.
diff --git a/1-js/05-data-types/05-array-methods/2-filter-range/_js.view/solution.js b/1-js/05-data-types/05-array-methods/2-filter-range/_js.view/solution.js
@@ -1,5 +1,5 @@
 
 function filterRange(arr, a, b) {
-  // added brackets around the expression for better readability
+  // навколо виразу додано дужки для кращої читабельності
   return arr.filter(item => (a <= item && item <= b));
 }
diff --git a/1-js/05-data-types/05-array-methods/2-filter-range/solution.md b/1-js/05-data-types/05-array-methods/2-filter-range/solution.md
@@ -1,14 +1,14 @@
 ```js run demo
 function filterRange(arr, a, b) {
-  // added brackets around the expression for better readability
+  // навколо виразу додано дужки для кращої читабельності
   return arr.filter(item => (a <= item && item <= b));
 }
 
 let arr = [5, 3, 8, 1];
 
 let filtered = filterRange(arr, 1, 4);
 
-alert( filtered ); // 3,1 (matching values)
+alert( filtered ); // 3,1 (відфільтровані значення)
 
-alert( arr ); // 5,3,8,1 (not modified)
+alert( arr ); // 5,3,8,1 (не змінюється)
 ```
diff --git a/1-js/05-data-types/05-array-methods/2-filter-range/task.md b/1-js/05-data-types/05-array-methods/2-filter-range/task.md
@@ -2,21 +2,21 @@ importance: 4
 
 ---
 
-# Filter range
+# Фільтрація за діапазоном
 
-Write a function `filterRange(arr, a, b)` that gets an array `arr`, looks for elements with values higher or equal to `a` and lower or equal to `b` and return a result as an array.
+Напишіть функцію `filterRange(arr, a, b)`, яка приймає масив `arr`, шукає в ньому елементи більші-рівні `a` та менші-рівні `b` і віддає масив цих елементів.
 
-The function should not modify the array. It should return the new array.
+Функція повинна повертати новий масив і не змінювати вихідний.
 
-For instance:
+Наприклад:
 
 ```js
 let arr = [5, 3, 8, 1];
 
 let filtered = filterRange(arr, 1, 4); 
 
-alert( filtered ); // 3,1 (matching values)
+alert( filtered ); // 3,1 (відфільтровані значення)
 
-alert( arr ); // 5,3,8,1 (not modified)
+alert( arr ); // 5,3,8,1 (не змінюється)
 ```
 
diff --git a/1-js/05-data-types/05-array-methods/3-filter-range-in-place/solution.md b/1-js/05-data-types/05-array-methods/3-filter-range-in-place/solution.md
@@ -4,7 +4,7 @@ function filterRangeInPlace(arr, a, b) {
   for (let i = 0; i < arr.length; i++) {
     let val = arr[i];
 
-    // remove if outside of the interval
+    // видаляти, якщо не у вказаному діапазоні
     if (val < a || val > b) {
       arr.splice(i, 1);
       i--;
@@ -15,7 +15,7 @@ function filterRangeInPlace(arr, a, b) {
 
 let arr = [5, 3, 8, 1];
 
-filterRangeInPlace(arr, 1, 4); // removed the numbers except from 1 to 4
+filterRangeInPlace(arr, 1, 4); // видаляє всі числа крім тих, що в діапазоні від 1 до 4
 
 alert( arr ); // [3, 1]
 ```
diff --git a/1-js/05-data-types/05-array-methods/3-filter-range-in-place/task.md b/1-js/05-data-types/05-array-methods/3-filter-range-in-place/task.md
@@ -2,17 +2,17 @@ importance: 4
 
 ---
 
-# Filter range "in place"
+# Фільтрація за діапазоном "на місці"
 
-Write a function `filterRangeInPlace(arr, a, b)` that gets an array `arr` and removes from it all values except those that are between `a` and `b`. The test is: `a ≤ arr[i] ≤ b`.
+Напишіть функцію `filterRangeInPlace(arr, a, b)`, яка приймає масив `arr` і видаляє з нього всі значення крім тих, які знаходяться між `a` і `b`. Тобто, перевірка має вигляд `a ≤ arr[i] ≤ b`.
 
-The function should only modify the array. It should not return anything.
+Функція повинна змінювати поточний масив і нічого не повертати.
 
-For instance:
+Наприклад:
 ```js
 let arr = [5, 3, 8, 1];
 
-filterRangeInPlace(arr, 1, 4); // removed the numbers except from 1 to 4
+filterRangeInPlace(arr, 1, 4); // видаляє всі числа крім тих, що в діапазоні від 1 до 4
 
 alert( arr ); // [3, 1]
 ```
diff --git a/1-js/05-data-types/05-array-methods/4-sort-back/task.md b/1-js/05-data-types/05-array-methods/4-sort-back/task.md
@@ -2,12 +2,12 @@ importance: 4
 
 ---
 
-# Sort in decreasing order
+# Сортувати за спаданням
 
 ```js
 let arr = [5, 2, 1, -10, 8];
 
-// ... your code to sort it in decreasing order
+// ... ваш код для сортування за спаданням
 
 alert( arr ); // 8, 5, 2, 1, -10
 ```

diff --git a/1-js/05-data-types/05-array-methods/5-copy-sort-array/solution.md b/1-js/05-data-types/05-array-methods/5-copy-sort-array/solution.md
@@ -1,4 +1,4 @@
-We can use `slice()` to make a copy and run the sort on it:
+Для копіювання масиву використовуємо `slice()` і тут же -- сортування:
 
 ```js run
 function copySorted(arr) {

diff --git a/1-js/05-data-types/05-array-methods/5-copy-sort-array/task.md b/1-js/05-data-types/05-array-methods/5-copy-sort-array/task.md
@@ -2,17 +2,17 @@ importance: 5
 
 ---
 
-# Copy and sort array
+# Скопіювати і впорядкувати масив
 
-We have an array of strings `arr`. We'd like to have a sorted copy of it, but keep `arr` unmodified.
+У нас є масив рядків `arr`. Потрібно отримати відсортовану копію та залишити `arr` незміненим.
 
-Create a function `copySorted(arr)` that returns such a copy.
+Створіть функцію `copySorted(arr)`, яка буде повертати таку копію.
 
 ```js
 let arr = ["HTML", "JavaScript", "CSS"];
 
 let sorted = copySorted(arr);
 
 alert( sorted ); // CSS, HTML, JavaScript
-alert( arr ); // HTML, JavaScript, CSS (no changes)
+alert( arr ); // HTML, JavaScript, CSS (без змін)
 ```
diff --git a/1-js/05-data-types/05-array-methods/6-array-get-names/solution.md b/1-js/05-data-types/05-array-methods/6-array-get-names/solution.md
@@ -1,13 +1,13 @@
 ```js run
 
-let john = { name: "John", age: 25 };
-let pete = { name: "Pete", age: 30 };
-let mary = { name: "Mary", age: 28 };
+let ivan = { name: "Іван", age: 25 };
+let petro = { name: "Петро", age: 30 };
+let mariya = { name: "Марія", age: 28 };
 
-let users = [ john, pete, mary ];
+let users = [ ivan, petro, mariya ];
 
 let names = users.map(item => item.name);
 
-alert( names ); // John, Pete, Mary
+alert( names ); // Іван, Петро, Марія
 ```
 
diff --git a/1-js/05-data-types/05-array-methods/6-array-get-names/task.md b/1-js/05-data-types/05-array-methods/6-array-get-names/task.md
@@ -2,21 +2,21 @@ importance: 5
 
 ---
 
-# Map to names
+# Трансформувати в масив імен
 
-You have an array of `user` objects, each one has `user.name`. Write the code that converts it into an array of names.
+У вас є масив об’єктів user, і в кожному з них є `user.name`. Напишіть код, який перетворює їх в масив імен.
 
-For instance:
+Наприклад:
 
 ```js no-beautify
-let john = { name: "John", age: 25 };
-let pete = { name: "Pete", age: 30 };
-let mary = { name: "Mary", age: 28 };
+let ivan = { name: "Іван", age: 25 };
+let petro = { name: "Петро", age: 30 };
+let mariya = { name: "Марія", age: 28 };
 
-let users = [ john, pete, mary ];
+let users = [ ivan, petro, mariya ];
 
-let names = /* ... your code */
+let names = /* ... ваш код */
 
-alert( names ); // John, Pete, Mary
+alert( names ); // Іван, Петро, Марія
 ```
 
diff --git a/1-js/05-data-types/05-array-methods/6-calculator-extendable/solution.md b/1-js/05-data-types/05-array-methods/6-calculator-extendable/solution.md
@@ -1,3 +1,3 @@
 
-- Please note how methods are stored. They are simply added to `this.methods` property.
-- All tests and numeric conversions are done in the `calculate` method. In future it may be extended to support more complex expressions.
+- Зверніть увагу, як зберігаються методи. Вони просто додаються до внутрішнього обʼєкта (`this.methods`).
+- Всі тести та числові перетворення виконуються в методі `calculate`. У майбутньому він може бути розширений для підтримки складніших виразів.