Add ru version (#1865)

* Add Russian docs site baseline

* Add Russian localized codebase

* Polish Russian code wording

* Update ru code translation.

* Update code translation and chapter covers.

* Fix pythontutor extraction.

* Add README and landing page.

* placeholder of profiles

* Use figures of English version

* Remove chapter paperbook

ru/codes/dart/chapter_sorting/bubble_sort.dart

@@ -0,0 +1,51 @@
+/**
+ * File: bubble_sort.dart
+ * Created Time: 2023-02-14
+ * Author: what-is-me (whatisme@outlook.jp)
+ */
+
+/* Пузырьковая сортировка */
+void bubbleSort(List<int> nums) {
+  // Внешний цикл: неотсортированный диапазон [0, i]
+  for (int i = nums.length - 1; i > 0; i--) {
+    // Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец
+    for (int j = 0; j < i; j++) {
+      if (nums[j] > nums[j + 1]) {
+        // Поменять местами nums[j] и nums[j + 1]
+        int tmp = nums[j];
+        nums[j] = nums[j + 1];
+        nums[j + 1] = tmp;
+      }
+    }
+  }
+}
+
+/* Пузырьковая сортировка (оптимизация флагом) */
+void bubbleSortWithFlag(List<int> nums) {
+  // Внешний цикл: неотсортированный диапазон [0, i]
+  for (int i = nums.length - 1; i > 0; i--) {
+    bool flag = false; // Инициализировать флаг
+    // Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец
+    for (int j = 0; j < i; j++) {
+      if (nums[j] > nums[j + 1]) {
+        // Поменять местами nums[j] и nums[j + 1]
+        int tmp = nums[j];
+        nums[j] = nums[j + 1];
+        nums[j + 1] = tmp;
+        flag = true; // Записать обмен элементов
+      }
+    }
+    if (!flag) break; // На этой итерации «всплытия» не было ни одного обмена, сразу выйти
+  }
+}
+
+/* Driver Code */
+void main() {
+  List<int> nums = [4, 1, 3, 1, 5, 2];
+  bubbleSort(nums);
+  print("После пузырьковой сортировки nums = $nums");
+
+  List<int> nums1 = [4, 1, 3, 1, 5, 2];
+  bubbleSortWithFlag(nums1);
+  print("После пузырьковой сортировки nums1 = $nums1");
+}

ru/codes/dart/chapter_sorting/bucket_sort.dart

@@ -0,0 +1,39 @@
+/**
+ * File: bucket_sort.dart
+ * Created Time: 2023-05-12
+ * Author: Jefferson (JeffersonHuang77@gmail.com)
+ */
+
+/* Сортировка корзинами */
+void bucketSort(List<double> nums) {
+  // Инициализировать k = n/2 корзин, предполагая распределение 2 элементов в каждую корзину
+  int k = nums.length ~/ 2;
+  List<List<double>> buckets = List.generate(k, (index) => []);
+
+  // 1. Распределить элементы массива по корзинам
+  for (double _num in nums) {
+    // Входные данные находятся в диапазоне [0, 1), используем _num * k для отображения в диапазон индексов [0, k-1]
+    int i = (_num * k).toInt();
+    // Добавить _num в корзину bucket_idx
+    buckets[i].add(_num);
+  }
+  // 2. Выполнить сортировку внутри каждой корзины
+  for (List<double> bucket in buckets) {
+    bucket.sort();
+  }
+  // 3. Обойти корзины и объединить результаты
+  int i = 0;
+  for (List<double> bucket in buckets) {
+    for (double _num in bucket) {
+      nums[i++] = _num;
+    }
+  }
+}
+
+/* Driver Code*/
+void main() {
+  // Пусть входные данные — числа с плавающей точкой из диапазона [0, 1)
+  final nums = [0.49, 0.96, 0.82, 0.09, 0.57, 0.43, 0.91, 0.75, 0.15, 0.37];
+  bucketSort(nums);
+  print('После сортировки корзинами nums = $nums');
+}

ru/codes/dart/chapter_sorting/counting_sort.dart

@@ -0,0 +1,72 @@
+/**
+ * File: counting_sort.dart
+ * Created Time: 2023-05-12
+ * Author: Jefferson (JeffersonHuang77@gmail.com)
+ */
+import 'dart:math';
+
+/* Сортировка подсчетом */
+// Простая реализация, не подходит для сортировки объектов
+void countingSortNaive(List<int> nums) {
+  // 1. Найти максимальный элемент массива m
+  int m = 0;
+  for (int _num in nums) {
+    m = max(m, _num);
+  }
+  // 2. Подсчитать число появлений каждой цифры
+  // counter[_num] обозначает число появлений _num
+  List<int> counter = List.filled(m + 1, 0);
+  for (int _num in nums) {
+    counter[_num]++;
+  }
+  // 3. Обойти counter и заполнить исходный массив nums элементами
+  int i = 0;
+  for (int _num = 0; _num < m + 1; _num++) {
+    for (int j = 0; j < counter[_num]; j++, i++) {
+      nums[i] = _num;
+    }
+  }
+}
+
+/* Сортировка подсчетом */
+// Полная реализация, позволяет сортировать объекты и является стабильной сортировкой
+void countingSort(List<int> nums) {
+  // 1. Найти максимальный элемент массива m
+  int m = 0;
+  for (int _num in nums) {
+    m = max(m, _num);
+  }
+  // 2. Подсчитать число появлений каждой цифры
+  // counter[_num] обозначает число появлений _num
+  List<int> counter = List.filled(m + 1, 0);
+  for (int _num in nums) {
+    counter[_num]++;
+  }
+  // 3. Вычислить префиксные суммы counter и преобразовать «число появлений» в «конечный индекс»
+  // То есть counter[_num]-1 — это индекс последнего появления _num в res
+  for (int i = 0; i < m; i++) {
+    counter[i + 1] += counter[i];
+  }
+  // 4. Обойти nums в обратном порядке и поместить элементы в результирующий массив res
+  // Инициализировать массив res для хранения результата
+  int n = nums.length;
+  List<int> res = List.filled(n, 0);
+  for (int i = n - 1; i >= 0; i--) {
+    int _num = nums[i];
+    res[counter[_num] - 1] = _num; // Поместить _num по соответствующему индексу
+    counter[_num]--; // Уменьшить префиксную сумму на 1, чтобы получить индекс следующего размещения _num
+  }
+  // Перезаписать исходный массив nums массивом результата res
+  nums.setAll(0, res);
+}
+
+/* Driver Code*/
+void main() {
+  final nums = [1, 0, 1, 2, 0, 4, 0, 2, 2, 4];
+  countingSortNaive(nums);
+  print('После сортировки подсчетом (объекты не поддерживаются) nums = $nums');
+
+  final nums1 = [1, 0, 1, 2, 0, 4, 0, 2, 2, 4];
+  countingSort(nums1);
+  print('После сортировки подсчетом nums1 = $nums1');
+}

ru/codes/dart/chapter_sorting/heap_sort.dart

@@ -0,0 +1,49 @@
+/**
+ * File: heap_sort.dart
+ * Created Time: 2023-06-01
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+/* Длина кучи равна n; начиная с узла i, выполнить просеивание сверху вниз */
+void siftDown(List<int> nums, int n, int i) {
+  while (true) {
+    // Определить узел с максимальным значением среди i, l и r и обозначить его как ma
+    int l = 2 * i + 1;
+    int r = 2 * i + 2;
+    int ma = i;
+    if (l < n && nums[l] > nums[ma]) ma = l;
+    if (r < n && nums[r] > nums[ma]) ma = r;
+    // Если узел i уже максимален или индексы l и r вне границ, дальнейшее просеивание не требуется, выйти
+    if (ma == i) break;
+    // Поменять два узла местами
+    int temp = nums[i];
+    nums[i] = nums[ma];
+    nums[ma] = temp;
+    // Циклическое просеивание вниз
+    i = ma;
+  }
+}
+
+/* Сортировка кучей */
+void heapSort(List<int> nums) {
+  // Построение кучи: выполнить heapify для всех узлов, кроме листовых
+  for (int i = nums.length ~/ 2 - 1; i >= 0; i--) {
+    siftDown(nums, nums.length, i);
+  }
+  // Извлекать максимальный элемент из кучи в течение n-1 итераций
+  for (int i = nums.length - 1; i > 0; i--) {
+    // Поменять корневой узел с самым правым листом местами (поменять первый и последний элементы)
+    int tmp = nums[0];
+    nums[0] = nums[i];
+    nums[i] = tmp;
+    // Начиная с корневого узла, выполнить просеивание сверху вниз
+    siftDown(nums, i, 0);
+  }
+}
+
+/* Driver Code */
+void main() {
+  List<int> nums = [4, 1, 3, 1, 5, 2];
+  heapSort(nums);
+  print("После сортировки кучей nums = $nums");
+}

ru/codes/dart/chapter_sorting/insertion_sort.dart

@@ -0,0 +1,26 @@
+/**
+ * File: insertion_sort.dart
+ * Created Time: 2023-02-14
+ * Author: what-is-me (whatisme@outlook.jp)
+ */
+
+/* Сортировка вставками */
+void insertionSort(List<int> nums) {
+  // Внешний цикл: отсортированный диапазон [0, i-1]
+  for (int i = 1; i < nums.length; i++) {
+    int base = nums[i], j = i - 1;
+    // Внутренний цикл: вставить base в правильную позицию отсортированного диапазона [0, i-1]
+    while (j >= 0 && nums[j] > base) {
+      nums[j + 1] = nums[j]; // Сдвинуть nums[j] на одну позицию вправо
+      j--;
+    }
+    nums[j + 1] = base; // Поместить base в правильную позицию
+  }
+}
+
+/* Driver Code */
+void main() {
+  List<int> nums = [4, 1, 3, 1, 5, 2];
+  insertionSort(nums);
+  print("После сортировки вставками nums = $nums");
+}

ru/codes/dart/chapter_sorting/merge_sort.dart

@@ -0,0 +1,52 @@
+/**
+ * File: merge_sort.dart
+ * Created Time: 2023-02-14
+ * Author: what-is-me (whatisme@outlook.jp)
+ */
+
+/* Объединить левый и правый подмассивы */
+void merge(List<int> nums, int left, int mid, int right) {
+  // Диапазон левого подмассива: [left, mid], диапазон правого подмассива: [mid+1, right]
+  // Создать временный массив tmp для хранения результата слияния
+  List<int> tmp = List.filled(right - left + 1, 0);
+  // Инициализировать начальные индексы левого и правого подмассивов
+  int i = left, j = mid + 1, k = 0;
+  // Пока в левом и правом подмассивах еще есть элементы, сравнивать их и копировать меньший во временный массив
+  while (i <= mid && j <= right) {
+    if (nums[i] <= nums[j])
+      tmp[k++] = nums[i++];
+    else
+      tmp[k++] = nums[j++];
+  }
+  // Скопировать оставшиеся элементы левого и правого подмассивов во временный массив
+  while (i <= mid) {
+    tmp[k++] = nums[i++];
+  }
+  while (j <= right) {
+    tmp[k++] = nums[j++];
+  }
+  // Скопировать элементы временного массива tmp обратно в соответствующий диапазон исходного массива nums
+  for (k = 0; k < tmp.length; k++) {
+    nums[left + k] = tmp[k];
+  }
+}
+
+/* Сортировка слиянием */
+void mergeSort(List<int> nums, int left, int right) {
+  // Условие завершения
+  if (left >= right) return; // Завершить рекурсию, когда длина подмассива равна 1
+  // Этап разбиения
+  int mid = left + (right - left) ~/ 2; // Вычислить середину
+  mergeSort(nums, left, mid); // Рекурсивно обработать левый подмассив
+  mergeSort(nums, mid + 1, right); // Рекурсивно обработать правый подмассив
+  // Этап слияния
+  merge(nums, left, mid, right);
+}
+
+/* Driver Code */
+void main() {
+  /* Сортировка слиянием */
+  List<int> nums = [7, 3, 2, 6, 0, 1, 5, 4];
+  mergeSort(nums, 0, nums.length - 1);
+  print("После сортировки слиянием nums = $nums");
+}

ru/codes/dart/chapter_sorting/quick_sort.dart

@@ -0,0 +1,145 @@
+/**
+ * File: quick_sort.dart
+ * Created Time: 2023-02-14
+ * Author: what-is-me (whatisme@outlook.jp)
+ */
+
+/* Класс быстрой сортировки */
+class QuickSort {
+  /* Обмен элементов */
+  static void _swap(List<int> nums, int i, int j) {
+    int tmp = nums[i];
+    nums[i] = nums[j];
+    nums[j] = tmp;
+  }
+
+  /* Разбиение с опорными указателями */
+  static int _partition(List<int> nums, int left, int right) {
+    // Взять nums[left] в качестве опорного элемента
+    int i = left, j = right;
+    while (i < j) {
+      while (i < j && nums[j] >= nums[left]) j--; // Идти справа налево в поисках первого элемента меньше опорного
+      while (i < j && nums[i] <= nums[left]) i++; // Идти слева направо в поисках первого элемента больше опорного
+      _swap(nums, i, j); // Поменять эти два элемента местами
+    }
+    _swap(nums, i, left); // Переместить опорный элемент на границу двух подмассивов
+    return i; // Вернуть индекс опорного элемента
+  }
+
+  /* Быстрая сортировка */
+  static void quickSort(List<int> nums, int left, int right) {
+    // Завершить рекурсию, когда длина подмассива равна 1
+    if (left >= right) return;
+    // Разбиение с опорными указателями
+    int pivot = _partition(nums, left, right);
+    // Рекурсивно обработать левый и правый подмассивы
+    quickSort(nums, left, pivot - 1);
+    quickSort(nums, pivot + 1, right);
+  }
+}
+
+/* Класс быстрой сортировки (оптимизация медианным опорным элементом) */
+class QuickSortMedian {
+  /* Обмен элементов */
+  static void _swap(List<int> nums, int i, int j) {
+    int tmp = nums[i];
+    nums[i] = nums[j];
+    nums[j] = tmp;
+  }
+
+  /* Выбрать медиану из трех кандидатов */
+  static int _medianThree(List<int> nums, int left, int mid, int right) {
+    int l = nums[left], m = nums[mid], r = nums[right];
+    if ((l <= m && m <= r) || (r <= m && m <= l))
+      return mid; // m находится между l и r
+    if ((m <= l && l <= r) || (r <= l && l <= m))
+      return left; // l находится между m и r
+    return right;
+  }
+
+  /* Разбиение с опорными указателями (медиана трех) */
+  static int _partition(List<int> nums, int left, int right) {
+    // Выбрать медиану из трех кандидатов
+    int med = _medianThree(nums, left, (left + right) ~/ 2, right);
+    // Переместить медиану в крайний левый элемент массива
+    _swap(nums, left, med);
+    // Взять nums[left] в качестве опорного элемента
+    int i = left, j = right;
+    while (i < j) {
+      while (i < j && nums[j] >= nums[left]) j--; // Идти справа налево в поисках первого элемента меньше опорного
+      while (i < j && nums[i] <= nums[left]) i++; // Идти слева направо в поисках первого элемента больше опорного
+      _swap(nums, i, j); // Поменять эти два элемента местами
+    }
+    _swap(nums, i, left); // Переместить опорный элемент на границу двух подмассивов
+    return i; // Вернуть индекс опорного элемента
+  }
+
+  /* Быстрая сортировка */
+  static void quickSort(List<int> nums, int left, int right) {
+    // Завершить рекурсию, когда длина подмассива равна 1
+    if (left >= right) return;
+    // Разбиение с опорными указателями
+    int pivot = _partition(nums, left, right);
+    // Рекурсивно обработать левый и правый подмассивы
+    quickSort(nums, left, pivot - 1);
+    quickSort(nums, pivot + 1, right);
+  }
+}
+
+/* Класс быстрой сортировки (оптимизация глубины рекурсии) */
+class QuickSortTailCall {
+  /* Обмен элементов */
+  static void _swap(List<int> nums, int i, int j) {
+    int tmp = nums[i];
+    nums[i] = nums[j];
+    nums[j] = tmp;
+  }
+
+  /* Разбиение с опорными указателями */
+  static int _partition(List<int> nums, int left, int right) {
+    // Взять nums[left] в качестве опорного элемента
+    int i = left, j = right;
+    while (i < j) {
+      while (i < j && nums[j] >= nums[left]) j--; // Идти справа налево в поисках первого элемента меньше опорного
+      while (i < j && nums[i] <= nums[left]) i++; // Идти слева направо в поисках первого элемента больше опорного
+      _swap(nums, i, j); // Поменять эти два элемента местами
+    }
+    _swap(nums, i, left); // Переместить опорный элемент на границу двух подмассивов
+    return i; // Вернуть индекс опорного элемента
+  }
+
+  /* Быстрая сортировка (оптимизация глубины рекурсии) */
+  static void quickSort(List<int> nums, int left, int right) {
+    // Завершить, когда длина подмассива равна 1
+    while (left < right) {
+      // Операция разбиения с опорными указателями
+      int pivot = _partition(nums, left, right);
+      // Выполнить быструю сортировку для более короткого из двух подмассивов
+      if (pivot - left < right - pivot) {
+        quickSort(nums, left, pivot - 1); // Рекурсивно отсортировать левый подмассив
+        left = pivot + 1; // Оставшийся неотсортированный диапазон: [pivot + 1, right]
+      } else {
+        quickSort(nums, pivot + 1, right); // Рекурсивно отсортировать правый подмассив
+        right = pivot - 1; // Оставшийся неотсортированный диапазон: [left, pivot - 1]
+      }
+    }
+  }
+}
+
+/* Driver Code */
+void main() {
+  /* Быстрая сортировка */
+  List<int> nums = [2, 4, 1, 0, 3, 5];
+  QuickSort.quickSort(nums, 0, nums.length - 1);
+  print("После быстрой сортировки nums = $nums");
+
+  /* Быстрая сортировка (оптимизация медианным опорным элементом) */
+  List<int> nums1 = [2, 4, 1, 0, 3, 5];
+  QuickSortMedian.quickSort(nums1, 0, nums1.length - 1);
+  print("После быстрой сортировки (оптимизация медианным опорным элементом) nums1 = $nums1");
+
+  /* Быстрая сортировка (оптимизация глубины рекурсии) */
+  List<int> nums2 = [2, 4, 1, 0, 3, 5];
+  QuickSortTailCall.quickSort(nums2, 0, nums2.length - 1);
+  print("После быстрой сортировки (оптимизация глубины рекурсии) nums2 = $nums2");
+}

ru/codes/dart/chapter_sorting/radix_sort.dart

@@ -0,0 +1,71 @@
+/**
+ * File: radix_sort.dart
+ * Created Time: 2023-02-14
+ * Author: what-is-me (whatisme@outlook.jp)
+ */
+
+/* Получить k-й разряд элемента _num, где exp = 10^(k-1) */
+int digit(int _num, int exp) {
+  // Передача exp вместо k позволяет избежать повторного дорогостоящего вычисления степени
+  return (_num ~/ exp) % 10;
+}
+
+/* Сортировка подсчетом (сортировка по k-му разряду nums) */
+void countingSortDigit(List<int> nums, int exp) {
+  // Разряды десятичной системы лежат в диапазоне 0~9, поэтому нужен массив корзин длины 10
+  List<int> counter = List<int>.filled(10, 0);
+  int n = nums.length;
+  // Подсчитать число появлений каждой цифры от 0 до 9
+  for (int i = 0; i < n; i++) {
+    int d = digit(nums[i], exp); // Получить k-й разряд nums[i], обозначив его как d
+    counter[d]++; // Подсчитать число появлений цифры d
+  }
+  // Вычислить префиксные суммы и преобразовать «число появлений» в «индекс массива»
+  for (int i = 1; i < 10; i++) {
+    counter[i] += counter[i - 1];
+  }
+  // Выполняя обратный проход, заполнить res элементами по статистике в корзинах
+  List<int> res = List<int>.filled(n, 0);
+  for (int i = n - 1; i >= 0; i--) {
+    int d = digit(nums[i], exp);
+    int j = counter[d] - 1; // Получить индекс j цифры d в массиве
+    res[j] = nums[i]; // Поместить текущий элемент по индексу j
+    counter[d]--; // Уменьшить количество d на 1
+  }
+  // Перезаписать исходный массив nums результатом
+  for (int i = 0; i < n; i++) nums[i] = res[i];
+}
+
+/* Поразрядная сортировка */
+void radixSort(List<int> nums) {
+  // Получить максимальный элемент массива, чтобы определить максимальное число разрядов
+  // В dart длина int составляет 64 бита
+  int m = -1 << 63;
+  for (int _num in nums) if (_num > m) m = _num;
+  // Проходить разряды от младшего к старшему
+  for (int exp = 1; exp <= m; exp *= 10)
+    // Выполнить сортировку подсчетом по k-му разряду элементов массива
+    // k = 1 -> exp = 1
+    // k = 2 -> exp = 10
+    // то есть exp = 10^(k-1)
+    countingSortDigit(nums, exp);
+}
+
+/* Driver Code */
+void main() {
+  // Поразрядная сортировка
+  List<int> nums = [
+    10546151,
+    35663510,
+    42865989,
+    34862445,
+    81883077,
+    88906420,
+    72429244,
+    30524779,
+    82060337,
+    63832996
+  ];
+  radixSort(nums);
+  print("После поразрядной сортировки nums = $nums");
+}

ru/codes/dart/chapter_sorting/selection_sort.dart

@@ -0,0 +1,29 @@
+/**
+ * File: selection_sort.dart
+ * Created Time: 2023-06-01
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+/* Сортировка выбором */
+void selectionSort(List<int> nums) {
+  int n = nums.length;
+  // Внешний цикл: неотсортированный диапазон [i, n-1]
+  for (int i = 0; i < n - 1; i++) {
+    // Внутренний цикл: найти минимальный элемент в неотсортированном диапазоне
+    int k = i;
+    for (int j = i + 1; j < n; j++) {
+      if (nums[j] < nums[k]) k = j; // Записать индекс минимального элемента
+    }
+    // Поменять этот минимальный элемент местами с первым элементом неотсортированного диапазона
+    int temp = nums[i];
+    nums[i] = nums[k];
+    nums[k] = temp;
+  }
+}
+
+/* Driver Code */
+void main() {
+  List<int> nums = [4, 1, 3, 1, 5, 2];
+  selectionSort(nums);
+  print("После сортировки выбором nums = $nums");
+}