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/ruby/chapter_sorting/bubble_sort.rb

@@ -0,0 +1,51 @@
+=begin
+File: bubble_sort.rb
+Created Time: 2024-05-02
+Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
+=end
+
+# ## Пузырьковая сортировка ###
+def bubble_sort(nums)
+  n = nums.length
+  # Внешний цикл: неотсортированный диапазон [0, i]
+  for i in (n - 1).downto(1)
+    # Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец
+    for j in 0...i
+      if nums[j] > nums[j + 1]
+        # Поменять местами nums[j] и nums[j + 1]
+        nums[j], nums[j + 1] = nums[j + 1], nums[j]
+      end
+    end
+  end
+end
+
+# ## Пузырьковая сортировка (оптимизация флагом) ###
+def bubble_sort_with_flag(nums)
+  n = nums.length
+  # Внешний цикл: неотсортированный диапазон [0, i]
+  for i in (n - 1).downto(1)
+    flag = false # Инициализировать флаг
+
+    # Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец
+    for j in 0...i
+      if nums[j] > nums[j + 1]
+        # Поменять местами nums[j] и nums[j + 1]
+        nums[j], nums[j + 1] = nums[j + 1], nums[j]
+        flag = true # Записать обмен элементов
+      end
+    end
+
+    break unless flag # На этой итерации «всплытия» не было ни одного обмена, сразу выйти
+  end
+end
+
+### Driver Code ###
+if __FILE__ == $0
+  nums = [4, 1, 3, 1, 5, 2]
+  bubble_sort(nums)
+  puts "После пузырьковой сортировки nums = #{nums}"
+
+  nums1 = [4, 1, 3, 1, 5, 2]
+  bubble_sort_with_flag(nums1)
+  puts "После пузырьковой сортировки nums = #{nums1}"
+end

ru/codes/ruby/chapter_sorting/bucket_sort.rb

@@ -0,0 +1,43 @@
+=begin
+File: bucket_sort.rb
+Created Time: 2024-04-17
+Author: Martin Xu (martin.xus@gmail.com)
+=end
+
+# ## Сортировка корзинами ###
+def bucket_sort(nums)
+  # Инициализировать k = n/2 корзин, предполагая распределение 2 элементов в каждую корзину
+  k = nums.length / 2
+  buckets = Array.new(k) { [] }
+  
+  # 1. Распределить элементы массива по корзинам
+  nums.each do |num|
+    # Входные данные лежат в диапазоне [0, 1); использовать num * k для отображения в диапазон индексов [0, k-1]
+    i = (num * k).to_i
+    # Добавить num в корзину i
+    buckets[i] << num
+  end
+
+  # 2. Выполнить сортировку внутри каждой корзины
+  buckets.each do |bucket|
+    # Использовать встроенную функцию сортировки; ее также можно заменить другим алгоритмом сортировки
+    bucket.sort!
+  end
+
+  # 3. Обойти корзины и объединить результаты
+  i = 0
+  buckets.each do |bucket|
+    bucket.each do |num|
+      nums[i] = num
+      i += 1
+    end
+  end
+end
+
+### Driver Code ###
+if __FILE__ == $0
+  # Пусть входные данные — числа с плавающей точкой из диапазона [0, 1)
+  nums = [0.49, 0.96, 0.82, 0.09, 0.57, 0.43, 0.91, 0.75, 0.15, 0.37]
+  bucket_sort(nums)
+  puts "После сортировки корзинами nums = #{nums}"
+end

ru/codes/ruby/chapter_sorting/counting_sort.rb

@@ -0,0 +1,62 @@
+=begin
+File: counting_sort.rb
+Created Time: 2024-05-02
+Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
+=end
+
+# ## Сортировка подсчетом ###
+def counting_sort_naive(nums)
+  # Простая реализация, не подходит для сортировки объектов
+  # 1. Найти максимальный элемент массива m
+  m = 0
+  nums.each { |num| m = [m, num].max }
+  # 2. Подсчитать число появлений каждой цифры
+  # counter[num] обозначает число появлений num
+  counter = Array.new(m + 1, 0)
+  nums.each { |num| counter[num] += 1 }
+  # 3. Обойти counter и заполнить исходный массив nums элементами
+  i = 0
+  for num in 0...(m + 1)
+    (0...counter[num]).each do
+      nums[i] = num
+      i += 1
+    end
+  end
+end
+
+# ## Сортировка подсчетом ###
+def counting_sort(nums)
+  # Полная реализация, позволяет сортировать объекты и является стабильной сортировкой
+  # 1. Найти максимальный элемент массива m
+  m = nums.max
+  # 2. Подсчитать число появлений каждой цифры
+  # counter[num] обозначает число появлений num
+  counter = Array.new(m + 1, 0)
+  nums.each { |num| counter[num] += 1 }
+  # 3. Вычислить префиксные суммы counter и преобразовать «число появлений» в «конечный индекс»
+  # То есть counter[num]-1 — это индекс последнего появления num в res
+  (0...m).each { |i| counter[i + 1] += counter[i] }
+  # 4. Обойти nums в обратном порядке и поместить элементы в результирующий массив res
+  # Инициализировать массив res для хранения результата
+  n = nums.length
+  res = Array.new(n, 0)
+  (n - 1).downto(0).each do |i|
+    num = nums[i]
+    res[counter[num] - 1] = num # Поместить num по соответствующему индексу
+    counter[num] -= 1 # Уменьшить префиксную сумму на 1, чтобы получить индекс следующего размещения num
+  end
+  # Перезаписать исходный массив nums массивом результата res
+  (0...n).each { |i| nums[i] = res[i] }
+end
+
+### Driver Code ###
+if __FILE__ == $0
+  nums = [1, 0, 1, 2, 0, 4, 0, 2, 2, 4]
+
+  counting_sort_naive(nums)
+  puts "После сортировки подсчетом (объекты не поддерживаются) nums = #{nums}"
+
+  nums1 = [1, 0, 1, 2, 0, 4, 0, 2, 2, 4]
+  counting_sort(nums1)
+  puts "После сортировки подсчетом nums1 = #{nums1}"
+end

ru/codes/ruby/chapter_sorting/heap_sort.rb

@@ -0,0 +1,45 @@
+=begin
+File: heap_sort.rb
+Created Time: 2024-04-10
+Author: junminhong (junminhong1110@gmail.com)
+=end
+
+# ## Длина кучи равна n; начиная с узла i, выполнить просеивание сверху вниз ###
+def sift_down(nums, n, i)
+  while true
+    # Определить узел с максимальным значением среди i, l и r и обозначить его как ma
+    l = 2 * i + 1
+    r = 2 * i + 2
+    ma = i
+    ma = l if l < n && nums[l] > nums[ma]
+    ma = r if r < n && nums[r] > nums[ma]
+    # Если узел i уже максимален или индексы l и r вне границ, дальнейшее просеивание не требуется, выйти
+    break if ma == i
+    # Поменять два узла местами
+    nums[i], nums[ma] = nums[ma], nums[i]
+    # Циклическое просеивание вниз
+    i = ma
+  end
+end
+
+# ## Сортировка кучей ###
+def heap_sort(nums)
+  # Построение кучи: выполнить heapify для всех узлов, кроме листовых
+  (nums.length / 2 - 1).downto(0) do |i|
+    sift_down(nums, nums.length, i)
+  end
+  # Извлекать максимальный элемент из кучи в течение n-1 итераций
+  (nums.length - 1).downto(1) do |i|
+    # Поменять корневой узел с самым правым листом местами (поменять первый и последний элементы)
+    nums[0], nums[i] = nums[i], nums[0]
+    # Начиная с корневого узла, выполнить просеивание сверху вниз
+    sift_down(nums, i, 0)
+  end
+end
+
+### Driver Code ###
+if __FILE__ == $0
+  nums = [4, 1, 3, 1, 5, 2]
+  heap_sort(nums)
+  puts "После сортировки кучей nums = #{nums.inspect}"
+end

ru/codes/ruby/chapter_sorting/insertion_sort.rb

@@ -0,0 +1,26 @@
+=begin
+File: insertion_sort.rb
+Created Time: 2024-04-02
+Author: Cy (3739004@gmail.com), Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
+=end
+
+# ## Сортировка вставками ###
+def insertion_sort(nums)
+  n = nums.length
+  # Внешний цикл: отсортированный диапазон [0, i-1]
+  for i in 1...n
+    base = nums[i]
+    j = i - 1
+    # Внутренний цикл: вставить base в правильную позицию отсортированного диапазона [0, i-1]
+    while j >= 0 && nums[j] > base
+      nums[j + 1] = nums[j] # Сдвинуть nums[j] на одну позицию вправо
+      j -= 1
+    end
+    nums[j + 1] = base # Поместить base в правильную позицию
+  end
+end
+
+### Driver Code ###
+nums = [4, 1, 3, 1, 5, 2]
+insertion_sort(nums)
+puts "После сортировки вставками nums = #{nums}"

ru/codes/ruby/chapter_sorting/merge_sort.rb

@@ -0,0 +1,60 @@
+=begin
+File: merge_sort.rb
+Created Time: 2024-04-10
+Author: junminhong (junminhong1110@gmail.com)
+=end
+
+# ## Слияние левого и правого подмассивов ###
+def merge(nums, left, mid, right)
+  # Интервал левого подмассива: [left, mid], правого подмассива: [mid+1, right]
+  # Создать временный массив tmp для хранения результата слияния
+  tmp = Array.new(right - left + 1, 0)
+  # Инициализировать начальные индексы левого и правого подмассивов
+  i, j, k = left, mid + 1, 0
+  # Пока в левом и правом подмассивах еще есть элементы, сравнивать их и копировать меньший во временный массив
+  while i <= mid && j <= right
+    if nums[i] <= nums[j]
+      tmp[k] = nums[i]
+      i += 1
+    else
+      tmp[k] = nums[j]
+      j += 1
+    end
+    k += 1
+  end
+  # Скопировать оставшиеся элементы левого и правого подмассивов во временный массив
+  while i <= mid
+    tmp[k] = nums[i]
+    i += 1
+    k += 1
+  end
+  while j <= right
+    tmp[k] = nums[j]
+    j += 1
+    k += 1
+  end
+  # Скопировать элементы временного массива tmp обратно в соответствующий диапазон исходного массива nums
+  (0...tmp.length).each do |k|
+    nums[left + k] = tmp[k]
+  end
+end
+
+# ## Сортировка слиянием ###
+def merge_sort(nums, left, right)
+  # Условие завершения
+  # Когда длина подмассива равна 1, рекурсия завершается
+  return if left >= right
+  # Этап разбиения
+  mid = left + (right - left) / 2 # Вычислить середину
+  merge_sort(nums, left, mid) # Рекурсивно обработать левый подмассив
+  merge_sort(nums, mid + 1, right) # Рекурсивно обработать правый подмассив
+  # Этап слияния
+  merge(nums, left, mid, right)
+end
+
+### Driver Code ###
+if __FILE__ == $0
+  nums = [7, 3, 2, 6, 0, 1, 5, 4]
+  merge_sort(nums, 0, nums.length - 1)
+  puts "После сортировки слиянием nums = #{nums.inspect}"
+end

ru/codes/ruby/chapter_sorting/quick_sort.rb

@@ -0,0 +1,153 @@
+=begin
+File: quick_sort.rb
+Created Time: 2024-04-01
+Author: Cy (3739004@gmail.com), Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
+=end
+
+# ## Класс быстрой сортировки ###
+class QuickSort
+  class << self
+    # ## Разбиение с опорными указателями ###
+    def partition(nums, left, right)
+      # Взять nums[left] в качестве опорного элемента
+      i, j = left, right
+      while i < j
+        while i < j && nums[j] >= nums[left]
+          j -= 1 # Идти справа налево в поисках первого элемента меньше опорного
+        end
+        while i < j && nums[i] <= nums[left]
+          i += 1 # Идти слева направо в поисках первого элемента больше опорного
+        end
+        # Обмен элементов
+        nums[i], nums[j] = nums[j], nums[i]
+      end
+      # Переместить опорный элемент на границу двух подмассивов
+      nums[i], nums[left] = nums[left], nums[i]
+      i # Вернуть индекс опорного элемента
+    end
+
+    # ## Класс быстрой сортировки ###
+    def quick_sort(nums, left, right)
+      # Рекурсивно обрабатывать, пока длина подмассива не станет равной 1
+      if left < right
+        # Разбиение с опорными указателями
+        pivot = partition(nums, left, right)
+        # Рекурсивно обработать левый и правый подмассивы
+        quick_sort(nums, left, pivot - 1)
+        quick_sort(nums, pivot + 1, right)
+      end
+      nums
+    end
+  end
+end
+
+# ## Класс быстрой сортировки (оптимизация медианой) ###
+class QuickSortMedian
+  class << self
+    # ## Выбрать медиану из трех кандидатов ###
+    def median_three(nums, left, mid, right)
+      # Выбрать медиану из трех кандидатов
+      _l, _m, _r = nums[left], nums[mid], nums[right]
+      # m находится между l и r
+      return mid if (_l <= _m && _m <= _r) || (_r <= _m && _m <= _l)
+      # l находится между m и r
+      return left if (_m <= _l && _l <= _r) || (_r <= _l && _l <= _m)
+      return right
+    end
+
+    # ## Разбиение с опорными указателями (медиана трех) ###
+    def partition(nums, left, right)
+      # ## Использовать nums[left] как опорный элемент
+      med = median_three(nums, left, (left + right) / 2, right)
+      # Переместить медиану в крайний левый элемент массива
+      nums[left], nums[med] = nums[med], nums[left]
+      i, j = left, right
+      while i < j
+        while i < j && nums[j] >= nums[left]
+          j -= 1 # Идти справа налево в поисках первого элемента меньше опорного
+        end
+        while i < j && nums[i] <= nums[left]
+          i += 1 # Идти слева направо в поисках первого элемента больше опорного
+        end
+        # Обмен элементов
+        nums[i], nums[j] = nums[j], nums[i]
+      end
+      # Переместить опорный элемент на границу двух подмассивов
+      nums[i], nums[left] = nums[left], nums[i]
+      i # Вернуть индекс опорного элемента
+    end
+
+    # ## Быстрая сортировка ###
+    def quick_sort(nums, left, right)
+      # Рекурсивно обрабатывать, пока длина подмассива не станет равной 1
+      if left < right
+        # Разбиение с опорными указателями
+        pivot = partition(nums, left, right)
+        # Рекурсивно обработать левый и правый подмассивы
+        quick_sort(nums, left, pivot - 1)
+        quick_sort(nums, pivot + 1, right)
+      end
+      nums
+    end
+  end
+end
+
+# ## Класс быстрой сортировки (оптимизация глубины рекурсии) ###
+class QuickSortTailCall
+  class << self
+    # ## Разбиение с опорными указателями ###
+    def partition(nums, left, right)
+      # Использовать nums[left] как опорный элемент
+      i = left
+      j = right
+      while i < j
+        while i < j && nums[j] >= nums[left]
+          j -= 1 # Идти справа налево в поисках первого элемента меньше опорного
+        end
+        while i < j && nums[i] <= nums[left]
+          i += 1 # Идти слева направо в поисках первого элемента больше опорного
+        end
+        # Обмен элементов
+        nums[i], nums[j] = nums[j], nums[i]
+      end
+      # Переместить опорный элемент на границу двух подмассивов
+      nums[i], nums[left] = nums[left], nums[i]
+      i # Вернуть индекс опорного элемента
+    end
+
+    # ## Быстрая сортировка (оптимизация глубины рекурсии) ###
+    def quick_sort(nums, left, right)
+      # Рекурсивно обрабатывать, пока длина подмассива не станет равной 1
+      while left < right
+        # Разбиение с опорными указателями
+        pivot = partition(nums, left, right)
+        # Выполнить быструю сортировку для более короткого из двух подмассивов
+        if pivot - left < right - pivot
+          quick_sort(nums, left, pivot - 1)
+          left = pivot + 1 # Оставшийся неотсортированный диапазон: [pivot + 1, right]
+        else
+          quick_sort(nums, pivot + 1, right)
+          right = pivot - 1 # Оставшийся неотсортированный диапазон: [left, pivot - 1]
+        end
+      end
+    end
+  end
+end
+
+### Driver Code ###
+if __FILE__ == $0
+  # Быстрая сортировка
+  nums = [2, 4, 1, 0, 3, 5]
+  QuickSort.quick_sort(nums, 0, nums.length - 1)
+  puts "После быстрой сортировки nums = #{nums}"
+
+  # Быстрая сортировка (оптимизация медианным опорным элементом)
+  nums1 = [2, 4, 1, 0, 3, 5]
+  QuickSortMedian.quick_sort(nums1, 0, nums1.length - 1)
+  puts "После быстрой сортировки (оптимизация медианным опорным элементом) nums1 = #{nums1}"
+
+  # Быстрая сортировка (оптимизация глубины рекурсии)
+  nums2 = [2, 4, 1, 0, 3, 5]
+  QuickSortTailCall.quick_sort(nums2, 0, nums2.length - 1)
+  puts "После быстрой сортировки (оптимизация глубины рекурсии) nums2 = #{nums2}"
+end

ru/codes/ruby/chapter_sorting/radix_sort.rb

@@ -0,0 +1,70 @@
+=begin
+File: radix_sort.rb
+Created Time: 2024-05-03
+Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
+=end
+
+# ## Получить k-й разряд элемента num, где exp = 10^(k-1) ###
+def digit(num, exp)
+  # Передача exp вместо k позволяет избежать повторного выполнения дорогостоящих вычислений степени
+  (num / exp) % 10
+end
+
+# ## Сортировка подсчетом (сортировка по k-му разряду nums) ###
+def counting_sort_digit(nums, exp)
+  # Разряды десятичной системы лежат в диапазоне 0~9, поэтому нужен массив корзин длины 10
+  counter = Array.new(10, 0)
+  n = nums.length
+  # Подсчитать число появлений каждой цифры от 0 до 9
+  for i in 0...n
+    d = digit(nums[i], exp) # Получить k-й разряд nums[i], обозначив его как d
+    counter[d] += 1 # Подсчитать число появлений цифры d
+  end
+  # Вычислить префиксные суммы и преобразовать «число появлений» в «индекс массива»
+  (1...10).each { |i| counter[i] += counter[i - 1] }
+  # Выполняя обратный проход, заполнить res элементами по статистике в корзинах
+  res = Array.new(n, 0)
+  for i in (n - 1).downto(0)
+    d = digit(nums[i], exp)
+    j = counter[d] - 1 # Получить индекс j цифры d в массиве
+    res[j] = nums[i] # Поместить текущий элемент по индексу j
+    counter[d] -= 1 # Уменьшить количество d на 1
+  end
+  # Перезаписать исходный массив nums результатом
+  (0...n).each { |i| nums[i] = res[i] }
+end
+
+# ## Поразрядная сортировка ###
+def radix_sort(nums)
+  # Получить максимальный элемент массива, чтобы определить максимальное число разрядов
+  m = nums.max
+  # Проходить разряды от младшего к старшему
+  exp = 1
+  while exp <= m
+    # Выполнить сортировку подсчетом по k-му разряду элементов массива
+    # k = 1 -> exp = 1
+    # k = 2 -> exp = 10
+    # то есть exp = 10^(k-1)
+    counting_sort_digit(nums, exp)
+    exp *= 10
+  end
+end
+
+### Driver Code ###
+if __FILE__ == $0
+  # Поразрядная сортировка
+  nums = [
+    10546151,
+    35663510,
+    42865989,
+    34862445,
+    81883077,
+    88906420,
+    72429244,
+    30524779,
+    82060337,
+    63832996,
+  ]
+  radix_sort(nums)
+  puts "После поразрядной сортировки nums = #{nums}"
+end

ru/codes/ruby/chapter_sorting/selection_sort.rb

@@ -0,0 +1,29 @@
+=begin
+File: selection_sort.rb
+Created Time: 2024-05-03
+Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
+=end
+
+# ## Сортировка выбором ###
+def selection_sort(nums)
+  n = nums.length
+  # Внешний цикл: неотсортированный диапазон [i, n-1]
+  for i in 0...(n - 1)
+    # Внутренний цикл: найти минимальный элемент в неотсортированном диапазоне
+    k = i
+    for j in (i + 1)...n
+      if nums[j] < nums[k]
+        k = j # Записать индекс минимального элемента
+      end
+    end
+    # Поменять этот минимальный элемент местами с первым элементом неотсортированного диапазона
+    nums[i], nums[k] = nums[k], nums[i]
+  end
+end
+
+### Driver Code ###
+if __FILE__ == $0
+  nums = [4, 1, 3, 1, 5, 2]
+  selection_sort(nums)
+  puts "После сортировки выбором nums = #{nums}"
+end