1-js/05-data-types/05-array-methods/

Ru translation:
   Tasks from 9 to 11 have been translated.

Author: shchegol

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 vasya = { name: "Вася", age: 25 };
+let petya = { name: "Петя", age: 30 };
+let masha = { name: "Маша", age: 29 };
 
-let arr = [ john, pete, mary ];
+let arr = [ vasya, petya, masha ];
 
 alert( getAverageAge(arr) ); // 28
 ```

1-js/05-data-types/05-array-methods/10-average-age/task.md

@@ -1,21 +1,21 @@
-importance: 4
+важность: 4
 
 ---
 
-# Get average age
+# Получить средний возраст
 
-Write the function `getAverageAge(users)` that gets an array of objects with property `age` and gets the average.
+Напишите функцию `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 };
-let pete = { name: "Pete", age: 30 };
-let mary = { name: "Mary", age: 29 };
+let vasya = { name: "Вася", age: 25 };
+let petya = { name: "Петя", age: 30 };
+let masha = { name: "Маша", age: 29 };
 
-let arr = [ john, pete, mary ];
+let arr = [ vasya, petya, masha ];
 
 alert( getAverageAge(arr) ); // (25 + 30 + 29) / 3 = 28
 ```

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-weakmap-weakset> we'll see how to optimize it.
+Далее в главе <info:map-set-weakmap-weakset> мы увидим, как его оптимизировать.

1-js/05-data-types/05-array-methods/11-array-unique/task.md

@@ -1,23 +1,23 @@
-importance: 4
+важность: 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
 ```

1-js/05-data-types/05-array-methods/9-shuffle/solution.md

@@ -1,4 +1,4 @@
-The simple solution could be:
+Простое решение может быть:
 
 ```js run
 *!*
@@ -12,18 +12,18 @@ shuffle(arr);
 alert(arr);
 ```
 
-That somewhat works, because `Math.random() - 0.5` is a random number that may be positive or negative, so the sorting function reorders elements randomly.
+Это конечно будет работать потому, что `Math.random() - 0.5` отдаёт случайное число, которое может быть положительным или отрицательным, следовательно функция сортировки меняет порядок элементов случайным образом.
 
-But because the sorting function is not meant to be used this way, not all permutations have the same probability.
+Но поскольку метод `sort` не предназначен для использования в таких случаях, не все возможные варианты имеют одинаковую вероятность.
 
-For instance, consider the code below. It runs `shuffle` 1000000 times and counts appearances of all possible results:
+Например, рассмотрим код ниже. Он запускает `shuffle` 1000000 раз и считает вероятность появления для всех возможных вариантов `arr`:
 
 ```js run
 function shuffle(array) {
   array.sort(() => Math.random() - 0.5);
 }
 
-// counts of appearances for all possible permutations
+// подсчёт вероятности для всех возможных вариантов
 let count = {
   '123': 0,
   '132': 0,
@@ -39,13 +39,13 @@ for (let i = 0; i < 1000000; i++) {
   count[array.join('')]++;
 }
 
-// show counts of all possible permutations
+// показать количество всех возможных вариантов
 for (let key in count) {
   alert(`${key}: ${count[key]}`);
 }
 ```
 
-An example result (for V8, July 2017):
+Результат примера (для V8, июль 2017):
 
 ```js
 123: 250706
@@ -56,24 +56,24 @@ An example result (for V8, July 2017):
 321: 125223
 ```
 
-We can see the bias clearly: `123` and `213` appear much more often than others.
+Теперь мы отчётливо видим допущенное отклонение: `123` и `213` появляются намного чаще чем остальные варианты.
 
-The result of the code may vary between JavaScript engines, but we can already see that the approach is unreliable.
+Результаты этого кода могут варьироваться при запуске на разных движках JavaScript, но очевидно что такой подход не надёжен.
 
-Why it doesn't work? Generally speaking, `sort` is a "black box": we throw an array and a comparison function into it and expect the array to be sorted. But due to the utter randomness of the comparison the black box goes mad, and how exactly it goes mad depends on the concrete implementation that differs between engines.
+Так почему это не работает? Если говорить простыми словами, то `sort` это "чёрный ящик": мы бросаем в него массив и функцию сравнения ожидая получить отсортированный массив. Но из-за абсолютной хаотичности сравнений чёрный ящик сходит с ума, и как именно он сходит с ума, зависит от конкретной его реализации, которая различна на разных движках JavaScript.
 
-There are other good ways to do the task. For instance, there's a great algorithm called [Fisher-Yates shuffle](https://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle). The idea is to walk the array in the reverse order and swap each element with a random one before it:
+Есть и другие хорошие способы решить эту задачу. Например, есть отличный алгоритм под названием [Тасование Фишера — Йетса](https://ru.wikipedia.org/wiki/%D0%A2%D0%B0%D1%81%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5_%D0%A4%D0%B8%D1%88%D0%B5%D1%80%D0%B0_%E2%80%94_%D0%99%D0%B5%D1%82%D1%81%D0%B0). Суть заключается в том, чтобы проходить по массиву в обратном порядке и менять местами каждый элемент со случайным элементом, который находится перед ним.
 
 ```js
 function shuffle(array) {
   for (let i = array.length - 1; i > 0; i--) {
-    let j = Math.floor(Math.random() * (i + 1)); // random index from 0 to i
-    [array[i], array[j]] = [array[j], array[i]]; // swap elements
+    let j = Math.floor(Math.random() * (i + 1)); // случайный индекс от 0 до i
+    [array[i], array[j]] = [array[j], array[i]]; // перестановка элементов
   }
 }
 ```
 
-Let's test it the same way:
+Давайте проверим эту реализацию на том же примере:
 
 ```js run
 function shuffle(array) {
@@ -83,7 +83,7 @@ function shuffle(array) {
   }
 }
 
-// counts of appearances for all possible permutations
+// подсчёт вероятности для всех возможных вариантов
 let count = {
   '123': 0,
   '132': 0,
@@ -99,13 +99,13 @@ for (let i = 0; i < 1000000; i++) {
   count[array.join('')]++;
 }
 
-// show counts of all possible permutations
+// показать количество всех возможных вариантов
 for (let key in count) {
   alert(`${key}: ${count[key]}`);
 }
 ```
 
-The example output:
+Пример вывода:
 
 ```js
 123: 166693
@@ -116,6 +116,6 @@ The example output:
 321: 166316
 ```
 
-Looks good now: all permutations appear with the same probability.
+Теперь всё в порядке: все варианты появляются с одинаковой вероятностью.
 
-Also, performance-wise the Fisher-Yates algorithm is much better, there's no "sorting" overhead.
+Кроме того, если посмотреть с точки зрения производительности, то алгоритм "Тасование Фишера — Йетса" намного быстрее, так как в нём нет лишних затрат на сортировку.