Migrate to Zensical (#1869)

* Fix Russian Ruby code extraction. * Add zensical configs.
2026-07-13 07:46:06 +00:00 · 2026-03-29 05:41:25 +08:00
parent bc4c5ec414
commit 7a78369e4c
84 changed files with 1302 additions and 445 deletions
@@ -4,7 +4,7 @@ Created Time: 2024-03-18
 Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 =end

-# ## Случайный доступ к элементу ###
+### Случайный доступ к элементу ###
 def random_access(nums)
  # Случайным образом выбрать число из интервала [0, nums.length)
  random_index = Random.rand(0...nums.length)
@@ -14,9 +14,9 @@ def random_access(nums)
 end


-# ## Увеличить длину массива ###
-# Обратите внимание: Array в Ruby является динамическим массивом и может быть расширен напрямую
-# Для удобства обучения эта функция рассматривает Array как массив неизменяемой длины
+### Увеличить длину массива ###
+# Обратите внимание: Array в Ruby является динамическим массивом и может расширяться напрямую
+# Для удобства обучения в этой функции Array рассматривается как массив неизменяемой длины
 def extend(nums, enlarge)
  # Инициализировать массив увеличенной длины
  res = Array.new(nums.length + enlarge, 0)
@@ -30,7 +30,7 @@ def extend(nums, enlarge)
  res
 end

-# ## Вставка элемента num по индексу index в массив ###
+### Вставка элемента num по индексу index в массив ###
 def insert(nums, num, index)
  # Сдвинуть элемент с индексом index и все последующие элементы на одну позицию назад
  for i in (nums.length - 1).downto(index + 1)
@@ -42,7 +42,7 @@ def insert(nums, num, index)
 end


-# ## Удаление элемента по индексу index ###
+### Удаление элемента по индексу index ###
 def remove(nums, index)
  # Сдвинуть все элементы после индекса index на одну позицию вперед
  for i in index...(nums.length - 1)
@@ -50,7 +50,7 @@ def remove(nums, index)
  end
 end

-# ## Обход массива ###
+### Обход массива ###
 def traverse(nums)
  count = 0

@@ -65,7 +65,7 @@ def traverse(nums)
  end
 end

-# ## Поиск заданного элемента в массиве ###
+### Поиск заданного элемента в массиве ###
 def find(nums, target)
  for i in 0...nums.length
    return i if nums[i] == target
@@ -7,15 +7,15 @@ Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 require_relative '../utils/list_node'
 require_relative '../utils/print_util'

-# ## Вставка узла _p после узла n0 в связном списке ###
-# В Ruby `p` — встроенная функция, а `P` — константа, поэтому вместо этого можно использовать `_p`
+### Вставка узла _p после узла n0 в связном списке ###
+# В Ruby `p` является встроенной функцией, а `P` — константой, поэтому вместо них можно использовать `_p`
 def insert(n0, _p)
  n1 = n0.next
  _p.next = n1
  n0.next = _p
 end

-# ## Удаление первого узла после узла n0 в связном списке ###
+### Удаление первого узла после узла n0 в связном списке ###
 def remove(n0)
  return if n0.next.nil?

@@ -25,7 +25,7 @@ def remove(n0)
  n0.next = n1
 end

-# ## Доступ к узлу связного списка по индексу index ###
+### Доступ к узлу связного списка по индексу index ###
 def access(head, index)
  for i in 0...index
    return nil if head.nil?
@@ -35,7 +35,7 @@ def access(head, index)
  head
 end

-# ## Поиск первого узла со значением target в связном списке ###
+### Поиск первого узла со значением target в связном списке ###
 def find(head, target)
  index = 0
  while head
@@ -4,12 +4,12 @@ Created Time: 2024-03-18
 Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 =end

-# ## Класс списка ###
+### Класс списка ###
 class MyList
  attr_reader :size       # Получить длину списка (текущее число элементов)
  attr_reader :capacity   # Получить вместимость списка

-  # ## Конструктор ###
+  ### Конструктор ###
  def initialize
    @capacity = 10
    @size = 0
@@ -17,20 +17,20 @@ class MyList
    @arr = Array.new(capacity)
  end

-  # ## Доступ к элементу ###
+  ### Доступ к элементу ###
  def get(index)
    # Если индекс выходит за границы, выбрасывается исключение; далее аналогично
    raise IndexError, "индекс выходит за границы" if index < 0 || index >= size
    @arr[index]
  end

-  # ## Доступ к элементу ###
+  ### Доступ к элементу ###
  def set(index, num)
    raise IndexError, "индекс выходит за границы" if index < 0 || index >= size
    @arr[index] = num
  end

-  # ## Добавление элемента в конец ###
+  ### Добавление элемента в конец ###
  def add(num)
    # При превышении вместимости по числу элементов запускается расширение
    extend_capacity if size == capacity
@@ -40,7 +40,7 @@ class MyList
    @size += 1
  end

-  # ## Вставка элемента в середину ###
+  ### Вставка элемента в середину ###
  def insert(index, num)
    raise IndexError, "индекс выходит за границы" if index < 0 || index >= size

@@ -57,7 +57,7 @@ class MyList
    @size += 1
  end

-  # ## Удаление элемента ###
+  ### Удаление элемента ###
  def remove(index)
    raise IndexError, "индекс выходит за границы" if index < 0 || index >= size
    num = @arr[index]
@@ -74,7 +74,7 @@ class MyList
    num
  end

-  # ## Расширение списка ###
+  ### Расширение списка ###
  def extend_capacity
    # Создать новый массив длиной в extend_ratio раз больше исходного и скопировать в него исходный массив
    arr = @arr.dup + Array.new(capacity * (@extend_ratio - 1))
@@ -82,7 +82,7 @@ class MyList
    @capacity = arr.length
  end

-  # ## Преобразование списка в массив ###
+  ### Преобразование списка в массив ###
  def to_array
    sz = size
    # Преобразовывать только элементы списка в пределах фактической длины
@@ -4,7 +4,7 @@ Created Time: 2024-05-21
 Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 =end

-# ## Алгоритм бэктрекинга: n ферзей ###
+### Алгоритм бэктрекинга: n ферзей ###
 def backtrack(row, n, state, res, cols, diags1, diags2)
  # Когда все строки уже обработаны, записать решение
  if row == n
@@ -31,7 +31,7 @@ def backtrack(row, n, state, res, cols, diags1, diags2)
  end
 end

-# ## Решить задачу о n ферзях ###
+### Решить задачу о n ферзях ###
 def n_queens(n)
  # Инициализировать доску размера n*n, где 'Q' обозначает ферзя, а '#' — пустую клетку
  state = Array.new(n) { Array.new(n, "#") }
@@ -4,7 +4,7 @@ Created Time: 2024-05-22
 Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 =end

-# ## Алгоритм бэктрекинга: все перестановки I ###
+### Алгоритм бэктрекинга: все перестановки I ###
 def backtrack(state, choices, selected, res)
  # Когда длина состояния равна числу элементов, записать решение
  if state.length == choices.length
@@ -28,7 +28,7 @@ def backtrack(state, choices, selected, res)
  end
 end

-# ## Все перестановки I ###
+### Все перестановки I ###
 def permutations_i(nums)
  res = []
  backtrack([], nums, Array.new(nums.length, false), res)
@@ -4,7 +4,7 @@ Created Time: 2024-05-22
 Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 =end

-# ## Алгоритм бэктрекинга: все перестановки II ###
+### Алгоритм бэктрекинга: все перестановки II ###
 def backtrack(state, choices, selected, res)
  # Когда длина состояния равна числу элементов, записать решение
  if state.length == choices.length
@@ -30,7 +30,7 @@ def backtrack(state, choices, selected, res)
  end
 end

-# ## Все перестановки II ###
+### Все перестановки II ###
 def permutations_ii(nums)
  res = []
  backtrack([], nums, Array.new(nums.length, false), res)
@@ -7,7 +7,7 @@ Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 require_relative '../utils/tree_node'
 require_relative '../utils/print_util'

-# ## Предварительный обход: пример 1 ###
+### Предварительный обход: пример 1 ###
 def pre_order(root)
  return unless root

@@ -7,7 +7,7 @@ Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 require_relative '../utils/tree_node'
 require_relative '../utils/print_util'

-# ## Предварительный обход: пример 2 ###
+### Предварительный обход: пример 2 ###
 def pre_order(root)
  return unless root

@@ -7,7 +7,7 @@ Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 require_relative '../utils/tree_node'
 require_relative '../utils/print_util'

-# ## Предварительный обход: пример 3 ###
+### Предварительный обход: пример 3 ###
 def pre_order(root)
  # Отсечение
  return if !root || root.val == 3
@@ -7,32 +7,32 @@ Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 require_relative '../utils/tree_node'
 require_relative '../utils/print_util'

-# ## Проверка, является ли текущее состояние решением ###
+### Проверка, является ли текущее состояние решением ###
 def is_solution?(state)
  !state.empty? && state.last.val == 7
 end

-# ## Записать решение ###
+### Записать решение ###
 def record_solution(state, res)
  res << state.dup
 end

-# ## Проверка допустимости этого выбора в текущем состоянии ###
+### Проверка допустимости этого выбора в текущем состоянии ###
 def is_valid?(state, choice)
  choice && choice.val != 3
 end

-# ## Обновить состояние ###
+### Обновить состояние ###
 def make_choice(state, choice)
  state << choice
 end

-# ## Восстановить состояние ###
+### Восстановить состояние ###
 def undo_choice(state, choice)
  state.pop
 end

-# ## Алгоритм бэктрекинга: пример 3 ###
+### Алгоритм бэктрекинга: пример 3 ###
 def backtrack(state, choices, res)
  # Проверить, является ли текущее состояние решением
  record_solution(state, res) if is_solution?(state)
@@ -4,7 +4,7 @@ Created Time: 2024-05-22
 Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 =end

-# ## Алгоритм бэктрекинга: сумма подмножеств I ###
+### Алгоритм бэктрекинга: сумма подмножеств I ###
 def backtrack(state, target, choices, start, res)
  # Если сумма подмножества равна target, записать решение
  if target.zero?
@@ -26,7 +26,7 @@ def backtrack(state, target, choices, start, res)
  end
 end

-# ## Решить задачу суммы подмножеств I ###
+### Решить задачу суммы подмножеств I ###
 def subset_sum_i(nums, target)
  state = [] # Состояние (подмножество)
  nums.sort! # Отсортировать nums
@@ -4,7 +4,7 @@ Created Time: 2024-05-22
 Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 =end

-# ## Алгоритм бэктрекинга: сумма подмножеств I ###
+### Алгоритм бэктрекинга: сумма подмножеств I ###
 def backtrack(state, target, total, choices, res)
  # Если сумма подмножества равна target, записать решение
  if total == target
@@ -4,7 +4,7 @@ Created Time: 2024-05-22
 Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 =end

-# ## Алгоритм бэктрекинга: сумма подмножеств II ###
+### Алгоритм бэктрекинга: сумма подмножеств II ###
 def backtrack(state, target, choices, start, res)
  # Если сумма подмножества равна target, записать решение
  if target.zero?
@@ -30,7 +30,7 @@ def backtrack(state, target, choices, start, res)
  end
 end

-# ## Решить задачу суммы подмножеств II ###
+### Решить задачу суммы подмножеств II ###
 def subset_sum_ii(nums, target)
  state = [] # Состояние (подмножество)
  nums.sort! # Отсортировать nums
@@ -4,7 +4,7 @@ Created Time: 2024-03-30
 Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com), Cy (9738314@gmail.com)
 =end

-# ## Цикл for ###
+### Цикл for ###
 def for_loop(n)
  res = 0

@@ -16,7 +16,7 @@ def for_loop(n)
  res
 end

-# ## Цикл while ###
+### Цикл while ###
 def while_loop(n)
  res = 0
  i = 1 # Инициализация условной переменной
@@ -46,7 +46,7 @@ def while_loop_ii(n)
  res
 end

-# ## Двойной цикл for ###
+### Двойной цикл for ###
 def nested_for_loop(n)
  res = ""

@@ -4,7 +4,7 @@ Created Time: 2024-03-30
 Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 =end

-# ## Рекурсия ###
+### Рекурсия ###
 def recur(n)
  # Условие завершения
  return 1 if n == 1
@@ -14,7 +14,7 @@ def recur(n)
  n + res
 end

-# ## Имитация рекурсии итерацией ###
+### Имитация рекурсии итерацией ###
 def for_loop_recur(n)
  # Использовать явный стек для имитации системного стека вызовов
  stack = []
@@ -34,7 +34,7 @@ def for_loop_recur(n)
  res
 end

-# ## Хвостовая рекурсия ###
+### Хвостовая рекурсия ###
 def tail_recur(n, res)
  # Условие завершения
  return res if n == 0
@@ -42,7 +42,7 @@ def tail_recur(n, res)
  tail_recur(n - 1, res + n)
 end

-# ## Последовательность Фибоначчи: рекурсия ###
+### Последовательность Фибоначчи: рекурсия ###
 def fib(n)
  # Условие завершения: f(1) = 0, f(2) = 1
  return n - 1 if n == 1 || n == 2
@@ -8,13 +8,13 @@ require_relative '../utils/list_node'
 require_relative '../utils/tree_node'
 require_relative '../utils/print_util'

-# ## Функция ###
+### Функция ###
 def function
  # Выполнить некоторые операции
  0
 end

-# ## Постоянная сложность ###
+### Постоянная сложность ###
 def constant(n)
  # Константы, переменные и объекты занимают O(1) памяти
  a = 0
@@ -27,7 +27,7 @@ def constant(n)
  (0...n).each { function }
 end

-# ## Линейная сложность ###
+### Линейная сложность ###
 def linear(n)
  # Список длины n занимает O(n) памяти
  nums = Array.new(n, 0)
@@ -46,7 +46,7 @@ def linear_recur(n)
  linear_recur(n - 1)
 end

-# ## Квадратичная сложность ###
+### Квадратичная сложность ###
 def quadratic(n)
  # Двумерный список занимает O(n^2) памяти
  Array.new(n) { Array.new(n, 0) }
@@ -4,7 +4,7 @@ Created Time: 2024-03-30
 Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 =end

-# ## Постоянная сложность ###
+### Постоянная сложность ###
 def constant(n)
  count = 0
  size = 100000
@@ -14,7 +14,7 @@ def constant(n)
  count
 end

-# ## Линейная сложность ###
+### Линейная сложность ###
 def linear(n)
  count = 0
  (0...n).each { count += 1 }
@@ -33,7 +33,7 @@ def array_traversal(nums)
  count
 end

-# ## Квадратичная сложность ###
+### Квадратичная сложность ###
 def quadratic(n)
  count = 0

@@ -106,7 +106,7 @@ def log_recur(n)
  log_recur(n / 2) + 1
 end

-# ## Линейно-логарифмическая сложность ###
+### Линейно-логарифмическая сложность ###
 def linear_log_recur(n)
  return 1 unless n > 1

@@ -4,7 +4,7 @@ Created Time: 2024-03-30
 Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 =end

-# ## Создать массив с элементами: 1, 2, ..., n в случайном порядке ###
+### Создать массив с элементами: 1, 2, ..., n в случайном порядке ###
 def random_numbers(n)
  # Создать массив nums =: 1, 2, 3, ..., n
  nums = Array.new(n) { |i| i + 1 }
@@ -12,7 +12,7 @@ def random_numbers(n)
  nums.shuffle!
 end

-# ## Найти индекс числа 1 в массиве nums ###
+### Найти индекс числа 1 в массиве nums ###
 def find_one(nums)
  for i in 0...nums.length
    # Когда элемент 1 находится в начале массива, достигается лучшая временная сложность O(1)
@@ -4,7 +4,7 @@ Created Time: 2024-05-13
 Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 =end

-# ## Бинарный поиск: задача f(i, j) ###
+### Бинарный поиск: задача f(i, j) ###
 def dfs(nums, target, i, j)
  # Если интервал пуст, целевой элемент отсутствует, вернуть -1
  return -1 if i > j
@@ -24,7 +24,7 @@ def dfs(nums, target, i, j)
  end
 end

-# ## Бинарный поиск ###
+### Бинарный поиск ###
 def binary_search(nums, target)
  n = nums.length
  # Решить задачу f(0, n-1)
@@ -7,7 +7,7 @@ Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 require_relative '../utils/tree_node'
 require_relative '../utils/print_util'

-# ## Построить двоичное дерево: разделяй и властвуй ###
+### Построить двоичное дерево: разделяй и властвуй ###
 def dfs(preorder, inorder_map, i, l, r)
  # Завершить при пустом диапазоне поддерева
  return if r - l < 0
@@ -25,7 +25,7 @@ def dfs(preorder, inorder_map, i, l, r)
  root
 end

-# ## Построить двоичное дерево ###
+### Построить двоичное дерево ###
 def build_tree(preorder, inorder)
  # Инициализировать хеш-таблицу для хранения соответствия элементов inorder их индексам
  inorder_map = {}
@@ -4,7 +4,7 @@ Created Time: 2024-05-13
 Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 =end

-# ## Переместить один диск ###
+### Переместить один диск ###
 def move(src, tar)
  # Снять диск с вершины src
  pan = src.pop
@@ -12,7 +12,7 @@ def move(src, tar)
  tar << pan
 end

-# ## Решить задачу Ханойской башни f(i) ###
+### Решить задачу Ханойской башни f(i) ###
 def dfs(i, src, buf, tar)
  # Если в src остался только один диск, сразу переместить его в tar
  if i == 1
@@ -28,7 +28,7 @@ def dfs(i, src, buf, tar)
  dfs(i - 1, buf, src, tar)
 end

-# ## Решить задачу Ханойской башни ###
+### Решить задачу Ханойской башни ###
 def solve_hanota(_A, _B, _C)
  n = _A.length
  # Переместить верхние n дисков из A в C с помощью B
@@ -4,7 +4,7 @@ Created Time: 2024-05-29
 Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 =end

-# ## Бэктрекинг ###
+### Бэктрекинг ###
 def backtrack(choices, state, n, res)
  # Когда подъем достигает n-й ступени, число вариантов увеличивается на 1
  res[0] += 1 if state == n
@@ -19,7 +19,7 @@ def backtrack(choices, state, n, res)
  # Откат
 end

-# ## Подъем по лестнице: бэктрекинг ###
+### Подъем по лестнице: бэктрекинг ###
 def climbing_stairs_backtrack(n)
  choices = [1, 2] # Можно подняться на 1 или 2 ступени
  state = 0 # Начать подъем с 0-й ступени
@@ -4,7 +4,7 @@ Created Time: 2024-05-29
 Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 =end

-# ## Подъем по лестнице с ограничениями: динамическое программирование ###
+### Подъем по лестнице с ограничениями: динамическое программирование ###
 def climbing_stairs_constraint_dp(n)
  return 1 if n == 1 || n == 2

@@ -4,7 +4,7 @@ Created Time: 2024-05-29
 Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 =end

-# ## Поиск ###
+### Поиск ###
 def dfs(i)
  # dp[1] и dp[2] уже известны, вернуть их
  return i if i == 1 || i == 2
@@ -12,7 +12,7 @@ def dfs(i)
  dfs(i - 1) + dfs(i - 2)
 end

-# ## Подъем по лестнице: поиск ###
+### Подъем по лестнице: поиск ###
 def climbing_stairs_dfs(n)
  dfs(n)
 end
@@ -4,7 +4,7 @@ Created Time: 2024-05-29
 Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 =end

-# ## Поиск с мемоизацией ###
+### Поиск с мемоизацией ###
 def dfs(i, mem)
  # dp[1] и dp[2] уже известны, вернуть их
  return i if i == 1 || i == 2
@@ -17,7 +17,7 @@ def dfs(i, mem)
  mem[i] = count
 end

-# ## Подъем по лестнице: поиск с мемоизацией ###
+### Подъем по лестнице: поиск с мемоизацией ###
 def climbing_stairs_dfs_mem(n)
  # mem[i] хранит число способов подняться на i-ю ступень, -1 означает отсутствие записи
  mem = Array.new(n + 1, -1)
@@ -4,7 +4,7 @@ Created Time: 2024-05-29
 Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 =end

-# ## Подъем по лестнице: динамическое программирование ###
+### Подъем по лестнице: динамическое программирование ###
 def climbing_stairs_dp(n)
  return n  if n == 1 || n == 2

@@ -18,7 +18,7 @@ def climbing_stairs_dp(n)
  dp[n]
 end

-# ## Подъем по лестнице: динамическое программирование с оптимизацией памяти ###
+### Подъем по лестнице: динамическое программирование с оптимизацией памяти ###
 def climbing_stairs_dp_comp(n)
  return n if n == 1 || n == 2

@@ -4,7 +4,7 @@ Created Time: 2024-05-29
 Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 =end

-# ## Размен монет: динамическое программирование ###
+### Размен монет: динамическое программирование ###
 def coin_change_dp(coins, amt)
  n = coins.length
  _MAX = amt + 1
@@ -27,7 +27,7 @@ def coin_change_dp(coins, amt)
  dp[n][amt] != _MAX ? dp[n][amt] : -1
 end

-# ## Размен монет: динамическое программирование с оптимизацией памяти ###
+### Размен монет: динамическое программирование с оптимизацией памяти ###
 def coin_change_dp_comp(coins, amt)
  n = coins.length
  _MAX = amt + 1
@@ -4,7 +4,7 @@ Created Time: 2024-05-29
 Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 =end

-# ## Размен монет II: динамическое программирование ###
+### Размен монет II: динамическое программирование ###
 def coin_change_ii_dp(coins, amt)
  n = coins.length
  # Инициализация таблицы dp
@@ -26,7 +26,7 @@ def coin_change_ii_dp(coins, amt)
  dp[n][amt]
 end

-# ## Размен монет II: динамическое программирование с оптимизацией памяти ###
+### Размен монет II: динамическое программирование с оптимизацией памяти ###
 def coin_change_ii_dp_comp(coins, amt)
  n = coins.length
  # Инициализация таблицы dp
@@ -4,7 +4,7 @@ Created Time: 2024-05-29
 Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 =end

-# ## Редакционное расстояние: полный перебор ###
+### Редакционное расстояние: полный перебор ###
 def edit_distance_dfs(s, t, i, j)
  # Если s и t пусты, вернуть 0
  return 0 if i == 0 && j == 0
@@ -41,7 +41,7 @@ def edit_distance_dfs_mem(s, t, mem, i, j)
  mem[i][j] = [insert, delete, replace].min + 1
 end

-# ## Редакционное расстояние: динамическое программирование ###
+### Редакционное расстояние: динамическое программирование ###
 def edit_distance_dp(s, t)
  n, m = s.length, t.length
  dp = Array.new(n + 1) { Array.new(m + 1, 0) }
@@ -63,7 +63,7 @@ def edit_distance_dp(s, t)
  dp[n][m]
 end

-# ## Редакционное расстояние: динамическое программирование с оптимизацией памяти ###
+### Редакционное расстояние: динамическое программирование с оптимизацией памяти ###
 def edit_distance_dp_comp(s, t)
  n, m = s.length, t.length
  dp = Array.new(m + 1, 0)
@@ -4,7 +4,7 @@ Created Time: 2024-05-29
 Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 =end

-# ## Рюкзак 0-1: полный перебор ###
+### Рюкзак 0-1: полный перебор ###
 def knapsack_dfs(wgt, val, i, c)
  # Если все предметы уже рассмотрены или в рюкзаке не осталось места, вернуть стоимость 0
  return 0 if i == 0 || c == 0
@@ -17,7 +17,7 @@ def knapsack_dfs(wgt, val, i, c)
  [no, yes].max
 end

-# ## Рюкзак 0-1: поиск с мемоизацией ###
+### Рюкзак 0-1: поиск с мемоизацией ###
 def knapsack_dfs_mem(wgt, val, mem, i, c)
  # Если все предметы уже рассмотрены или в рюкзаке не осталось места, вернуть стоимость 0
  return 0 if i == 0 || c == 0
@@ -32,7 +32,7 @@ def knapsack_dfs_mem(wgt, val, mem, i, c)
  mem[i][c] = [no, yes].max
 end

-# ## Рюкзак 0-1: динамическое программирование ###
+### Рюкзак 0-1: динамическое программирование ###
 def knapsack_dp(wgt, val, cap)
  n = wgt.length
  # Инициализация таблицы dp
@@ -52,7 +52,7 @@ def knapsack_dp(wgt, val, cap)
  dp[n][cap]
 end

-# ## Рюкзак 0-1: динамическое программирование с оптимизацией памяти ###
+### Рюкзак 0-1: динамическое программирование с оптимизацией памяти ###
 def knapsack_dp_comp(wgt, val, cap)
  n = wgt.length
  # Инициализация таблицы dp
@@ -4,7 +4,7 @@ Created Time: 2024-05-29
 Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 =end

-# ## Минимальная стоимость подъема по лестнице: динамическое программирование ###
+### Минимальная стоимость подъема по лестнице: динамическое программирование ###
 def min_cost_climbing_stairs_dp(cost)
  n = cost.length - 1
  return cost[n] if n == 1 || n == 2
@@ -4,7 +4,7 @@ Created Time: 2024-05-29
 Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 =end

-# ## Минимальная сумма пути: полный перебор ###
+### Минимальная сумма пути: полный перебор ###
 def min_path_sum_dfs(grid, i, j)
  # Если это верхняя левая ячейка, завершить поиск
  return grid[i][j] if i == 0 && j == 0
@@ -17,7 +17,7 @@ def min_path_sum_dfs(grid, i, j)
  [left, up].min + grid[i][j]
 end

-# ## Минимальная сумма пути: поиск с мемоизацией ###
+### Минимальная сумма пути: поиск с мемоизацией ###
 def min_path_sum_dfs_mem(grid, mem, i, j)
  # Если это верхняя левая ячейка, завершить поиск
  return grid[0][0] if i == 0 && j == 0
@@ -32,7 +32,7 @@ def min_path_sum_dfs_mem(grid, mem, i, j)
  mem[i][j] = [left, up].min + grid[i][j]
 end

-# ## Минимальная сумма пути: динамическое программирование ###
+### Минимальная сумма пути: динамическое программирование ###
 def min_path_sum_dp(grid)
  n, m = grid.length, grid.first.length
  # Инициализация таблицы dp
@@ -51,7 +51,7 @@ def min_path_sum_dp(grid)
  dp[n -1][m -1]
 end

-# ## Минимальная сумма пути: динамическое программирование с оптимизацией памяти ###
+### Минимальная сумма пути: динамическое программирование с оптимизацией памяти ###
 def min_path_sum_dp_comp(grid)
  n, m = grid.length, grid.first.length
  # Инициализация таблицы dp
@@ -4,7 +4,7 @@ Created Time: 2024-05-29
 Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 =end

-# ## Полный рюкзак: динамическое программирование ###
+### Полный рюкзак: динамическое программирование ###
 def unbounded_knapsack_dp(wgt, val, cap)
  n = wgt.length
  # Инициализация таблицы dp
@@ -6,11 +6,11 @@ Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)

 require_relative '../utils/vertex'

-# ## Класс неориентированного графа на основе списка смежности ###
+### Класс неориентированного графа на основе списка смежности ###
 class GraphAdjList
  attr_reader :adj_list
  
-  # ## Конструктор ###
+  ### Конструктор ###
  def initialize(edges)
    # Список смежности, где key — вершина, а value — все смежные ей вершины
    @adj_list = {}
@@ -22,12 +22,12 @@ class GraphAdjList
    end
  end

-  # ## Получение числа вершин ###
+  ### Получение числа вершин ###
  def size
    @adj_list.length
  end

-  # ## Добавление ребра ###
+  ### Добавление ребра ###
  def add_edge(vet1, vet2)
    raise ArgumentError if !@adj_list.include?(vet1) || !@adj_list.include?(vet2)

@@ -35,7 +35,7 @@ class GraphAdjList
    @adj_list[vet2] << vet1
  end

-  # ## Удаление ребра ###
+  ### Удаление ребра ###
  def remove_edge(vet1, vet2)
    raise ArgumentError if !@adj_list.include?(vet1) || !@adj_list.include?(vet2)

@@ -44,7 +44,7 @@ class GraphAdjList
    @adj_list[vet2].delete(vet1)
  end

-  # ## Добавление вершины ###
+  ### Добавление вершины ###
  def add_vertex(vet)
    return if @adj_list.include?(vet)

@@ -52,7 +52,7 @@ class GraphAdjList
    @adj_list[vet] = []
  end

-  # ## Удаление вершины ###
+  ### Удаление вершины ###
  def remove_vertex(vet)
    raise ArgumentError unless @adj_list.include?(vet)

@@ -64,7 +64,7 @@ class GraphAdjList
    end
  end

-  # ## Вывести список смежности ###
+  ### Вывести список смежности ###
  def __print__
    puts 'Список смежности ='
    for vertex in @adj_list
@@ -6,10 +6,10 @@ Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)

 require_relative '../utils/print_util'

-# ## Класс неориентированного графа на основе матрицы смежности ###
+### Класс неориентированного графа на основе матрицы смежности ###
 class GraphAdjMat
  def initialize(vertices, edges)
-    # ## Конструктор ###
+    ### Конструктор ###
    # Список вершин: элементы представляют «значения вершин», а индексы — «индексы вершин»
    @vertices = []
    # Матрица смежности, где индексы строк и столбцов соответствуют «индексам вершин»
@@ -21,12 +21,12 @@ class GraphAdjMat
    edges.each { |e| add_edge(e[0], e[1]) }
  end

-  # ## Получение числа вершин ###
+  ### Получение числа вершин ###
  def size
    @vertices.length
  end

-  # ## Добавление вершины ###
+  ### Добавление вершины ###
  def add_vertex(val)
    n = size
    # Добавить значение новой вершины в список вершин
@@ -38,7 +38,7 @@ class GraphAdjMat
    @adj_mat.each { |row| row << 0 }
  end

-  # ## Удаление вершины ###
+  ### Удаление вершины ###
  def remove_vertex(index)
    raise IndexError if index >= size

@@ -50,7 +50,7 @@ class GraphAdjMat
    @adj_mat.each { |row| row.delete_at(index) }
  end

-  # ## Добавление ребра ###
+  ### Добавление ребра ###
  def add_edge(i, j)
    # Параметры i и j соответствуют индексам элементов vertices
    # Обработка выхода индекса за границы и случая равенства
@@ -62,7 +62,7 @@ class GraphAdjMat
    @adj_mat[j][i] = 1
  end

-  # ## Удаление ребра ###
+  ### Удаление ребра ###
  def remove_edge(i, j)
    # Параметры i и j соответствуют индексам элементов vertices
    # Обработка выхода индекса за границы и случая равенства
@@ -73,7 +73,7 @@ class GraphAdjMat
    @adj_mat[j][i] = 0
  end

-  # ## Вывести матрицу смежности ###
+  ### Вывести матрицу смежности ###
  def __print__
    puts "Список вершин = #{@vertices}"
    puts 'Матрица смежности ='
@@ -8,7 +8,7 @@ require 'set'
 require_relative './graph_adjacency_list'
 require_relative '../utils/vertex'

-# ## Обход в ширину ###
+### Обход в ширину ###
 def graph_bfs(graph, start_vet)
  # Использовать список смежности для представления графа, чтобы получать все смежные вершины заданной вершины
  # Последовательность обхода вершин
@@ -8,7 +8,7 @@ require 'set'
 require_relative './graph_adjacency_list'
 require_relative '../utils/vertex'

-# ## Вспомогательная функция обхода в глубину ###
+### Вспомогательная функция обхода в глубину ###
 def dfs(graph, visited, res, vet)
  res << vet # Отметить посещенную вершину
  visited.add(vet) # Отметить эту вершину как посещенную
@@ -20,7 +20,7 @@ def dfs(graph, visited, res, vet)
  end
 end

-# ## Обход в глубину ###
+### Обход в глубину ###
 def graph_dfs(graph, start_vet)
  # Использовать список смежности для представления графа, чтобы получать все смежные вершины заданной вершины
  # Последовательность обхода вершин
@@ -4,7 +4,7 @@ Created Time: 2024-05-07
 Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 =end

-# ## Размен монет: жадный алгоритм ###
+### Размен монет: жадный алгоритм ###
 def coin_change_greedy(coins, amt)
  # Предположить, что список coins упорядочен
  i = coins.length - 1
@@ -4,7 +4,7 @@ Created Time: 2024-05-07
 Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 =end

-# ## Предмет ###
+### Предмет ###
 class Item
  attr_accessor :w # Вес предмета
  attr_accessor :v # Стоимость предмета
@@ -15,7 +15,7 @@ class Item
  end
 end

-# ## Дробный рюкзак: жадный алгоритм ###
+### Дробный рюкзак: жадный алгоритм ###
 def fractional_knapsack(wgt, val, cap)
  # Создать список предметов с двумя свойствами: вес и стоимость
  items = wgt.each_with_index.map { |w, i| Item.new(w, val[i]) }
@@ -4,7 +4,7 @@ Created Time: 2024-05-07
 Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 =end

-# ## Максимальная вместимость: жадный алгоритм ###
+### Максимальная вместимость: жадный алгоритм ###
 def max_capacity(ht)
  # Инициализировать i и j так, чтобы они располагались по двум концам массива
  i, j = 0, ht.length - 1
@@ -4,7 +4,7 @@ Created Time: 2024-05-07
 Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 =end

-# ## Максимальное произведение разрезания: жадный алгоритм ###
+### Максимальное произведение разрезания: жадный алгоритм ###
 def max_product_cutting(n)
  # Когда n <= 3, обязательно нужно выделить одну 1
  return 1 * (n - 1) if n <= 3
@@ -4,7 +4,7 @@ Created Time: 2024-04-13
 Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 =end

-# ## Пара ключ-значение ###
+### Пара ключ-значение ###
 class Pair
  attr_accessor :key, :val

@@ -14,20 +14,20 @@ class Pair
  end
 end

-# ## Хеш-таблица на основе массива ###
+### Хеш-таблица на основе массива ###
 class ArrayHashMap
-  # ## Конструктор ###
+  ### Конструктор ###
  def initialize
    # Инициализировать массив, содержащий 100 корзин
    @buckets = Array.new(100)
  end

-  # ## Хеш-функция ###
+  ### Хеш-функция ###
  def hash_func(key)
    index = key % 100
  end

-  # ## Операция поиска ###
+  ### Операция поиска ###
  def get(key)
    index = hash_func(key)
    pair = @buckets[index]
@@ -36,42 +36,42 @@ class ArrayHashMap
    pair.val
  end

-  # ## Операция добавления ###
+  ### Операция добавления ###
  def put(key, val)
    pair = Pair.new(key, val)
    index = hash_func(key)
    @buckets[index] = pair
  end

-  # ## Операция удаления ###
+  ### Операция удаления ###
  def remove(key)
    index = hash_func(key)
    # Присвоить nil, что означает удаление
    @buckets[index] = nil
  end

-  # ## Получить все пары ключ-значение ###
+  ### Получить все пары ключ-значение ###
  def entry_set
    result = []
    @buckets.each { |pair| result << pair unless pair.nil? }
    result
  end

-  # ## Получить все ключи ###
+  ### Получить все ключи ###
  def key_set
    result = []
    @buckets.each { |pair| result << pair.key unless pair.nil? }
    result
  end

-  # ## Получить все значения ###
+  ### Получить все значения ###
  def value_set
    result = []
    @buckets.each { |pair| result << pair.val unless pair.nil? }
    result
  end

-  # ## Вывести хеш-таблицу ###
+  ### Вывести хеш-таблицу ###
  def print
    @buckets.each { |pair| puts "#{pair.key} -> #{pair.val}" unless pair.nil? }
  end
@@ -6,9 +6,9 @@ Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)

 require_relative './array_hash_map'

-# ## Хеш-таблица с цепочками ###
+### Хеш-таблица с цепочками ###
 class HashMapChaining
-  # ## Конструктор ###
+  ### Конструктор ###
  def initialize
    @size = 0 # Число пар ключ-значение
    @capacity = 4 # Вместимость хеш-таблицы
@@ -17,17 +17,17 @@ class HashMapChaining
    @buckets = Array.new(@capacity) { [] } # Массив корзин
  end

-  # ## Хеш-функция ###
+  ### Хеш-функция ###
  def hash_func(key)
    key % @capacity
  end

-  # ## Коэффициент загрузки ###
+  ### Коэффициент загрузки ###
  def load_factor
    @size / @capacity
  end

-  # ## Операция поиска ###
+  ### Операция поиска ###
  def get(key)
    index = hash_func(key)
    bucket = @buckets[index]
@@ -39,7 +39,7 @@ class HashMapChaining
    nil
  end

-  # ## Операция добавления ###
+  ### Операция добавления ###
  def put(key, val)
    # Когда коэффициент загрузки превышает порог, выполнить расширение
    extend if load_factor > @load_thres
@@ -58,7 +58,7 @@ class HashMapChaining
    @size += 1
  end

-  # ## Операция удаления ###
+  ### Операция удаления ###
  def remove(key)
    index = hash_func(key)
    bucket = @buckets[index]
@@ -72,7 +72,7 @@ class HashMapChaining
    end
  end

-  # ## Расширение хеш-таблицы ###
+  ### Расширение хеш-таблицы ###
  def extend
    # Временно сохранить исходную хеш-таблицу
    buckets = @buckets
@@ -88,7 +88,7 @@ class HashMapChaining
    end
  end

-  # ## Вывести хеш-таблицу ###
+  ### Вывести хеш-таблицу ###
  def print
    for bucket in @buckets
      res = []
@@ -6,11 +6,11 @@ Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)

 require_relative './array_hash_map'

-# ## Хеш-таблица с открытой адресацией ###
+### Хеш-таблица с открытой адресацией ###
 class HashMapOpenAddressing
  TOMBSTONE = Pair.new(-1, '-1') # Удалить метку

-  # ## Конструктор ###
+  ### Конструктор ###
  def initialize
    @size = 0 # Число пар ключ-значение
    @capacity = 4 # Вместимость хеш-таблицы
@@ -19,17 +19,17 @@ class HashMapOpenAddressing
    @buckets = Array.new(@capacity) # Массив корзин
  end

-  # ## Хеш-функция ###
+  ### Хеш-функция ###
  def hash_func(key)
    key % @capacity
  end

-  # ## Коэффициент загрузки ###
+  ### Коэффициент загрузки ###
  def load_factor
    @size / @capacity
  end

-  # ## Найти индекс корзины, соответствующий key ###
+  ### Найти индекс корзины, соответствующий key ###
  def find_bucket(key)
    index = hash_func(key)
    first_tombstone = -1
@@ -54,7 +54,7 @@ class HashMapOpenAddressing
    first_tombstone == -1 ? index : first_tombstone
  end

-  # ## Операция поиска ###
+  ### Операция поиска ###
  def get(key)
    # Найти индекс корзины, соответствующий key
    index = find_bucket(key)
@@ -64,7 +64,7 @@ class HashMapOpenAddressing
    nil
  end

-  # ## Операция добавления ###
+  ### Операция добавления ###
  def put(key, val)
    # Когда коэффициент загрузки превышает порог, выполнить расширение
    extend if load_factor > @load_thres
@@ -80,7 +80,7 @@ class HashMapOpenAddressing
    @size += 1
  end

-  # ## Операция удаления ###
+  ### Операция удаления ###
  def remove(key)
    # Найти индекс корзины, соответствующий key
    index = find_bucket(key)
@@ -91,7 +91,7 @@ class HashMapOpenAddressing
    end
  end

-  # ## Расширение хеш-таблицы ###
+  ### Расширение хеш-таблицы ###
  def extend
    # Временно сохранить исходную хеш-таблицу
    buckets_tmp = @buckets
@@ -105,7 +105,7 @@ class HashMapOpenAddressing
    end
  end

-  # ## Вывести хеш-таблицу ###
+  ### Вывести хеш-таблицу ###
  def print
    for pair in @buckets
      if pair.nil?
@@ -4,7 +4,7 @@ Created Time: 2024-04-14
 Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 =end

-# ## Аддитивное хеширование ###
+### Аддитивное хеширование ###
 def add_hash(key)
  hash = 0
  modulus = 1_000_000_007
@@ -14,7 +14,7 @@ def add_hash(key)
  hash % modulus
 end

-# ## Мультипликативное хеширование ###
+### Мультипликативное хеширование ###
 def mul_hash(key)
  hash = 0
  modulus = 1_000_000_007
@@ -24,7 +24,7 @@ def mul_hash(key)
  hash % modulus
 end

-# ## XOR-хеширование ###
+### XOR-хеширование ###
 def xor_hash(key)
  hash = 0
  modulus = 1_000_000_007
@@ -34,7 +34,7 @@ def xor_hash(key)
  hash % modulus
 end

-# ## Хеширование с циклическим сдвигом ###
+### Хеширование с циклическим сдвигом ###
 def rot_hash(key)
  hash = 0
  modulus = 1_000_000_007
@@ -6,11 +6,11 @@ Author: Blue Bean (lonnnnnnner@gmail.com)

 require_relative '../utils/print_util'

-# ## Максимальная куча ###
+### Максимальная куча ###
 class MaxHeap
  attr_reader :max_heap

-  # ## Конструктор, строящий кучу по входному списку ###
+  ### Конструктор, строящий кучу по входному списку ###
  def initialize(nums)
    # Добавить элементы списка в кучу без изменений
    @max_heap = nums
@@ -20,42 +20,42 @@ class MaxHeap
    end
  end

-  # ## Получить индекс левого дочернего узла ###
+  ### Получить индекс левого дочернего узла ###
  def left(i)
    2 * i + 1
  end

-  # ## Получить индекс правого дочернего узла ###
+  ### Получить индекс правого дочернего узла ###
  def right(i)
    2 * i + 2
  end

-  # ## Получить индекс родительского узла ###
+  ### Получить индекс родительского узла ###
  def parent(i)
    (i - 1) / 2     # Округление вниз при делении
  end

-  # ## Обмен элементов ###
+  ### Обмен элементов ###
  def swap(i, j)
    @max_heap[i], @max_heap[j] = @max_heap[j], @max_heap[i]
  end

-  # ## Получить размер кучи ###
+  ### Получить размер кучи ###
  def size
    @max_heap.length
  end

-  # ## Проверка, пуста ли куча ###
+  ### Проверка, пуста ли куча ###
  def is_empty?
    size == 0
  end

-  # ## Доступ к элементу на вершине кучи ###
+  ### Доступ к элементу на вершине кучи ###
  def peek
    @max_heap[0]
  end

-  # ## Добавление элемента в кучу ###
+  ### Добавление элемента в кучу ###
  def push(val)
    # Добавление узла
    @max_heap << val
@@ -63,7 +63,7 @@ class MaxHeap
    sift_up(size - 1)
  end

-  # ## Начиная с узла i, выполнить просеивание снизу вверх ###
+  ### Начиная с узла i, выполнить просеивание снизу вверх ###
  def sift_up(i)
    loop do
      # Получение родительского узла для узла i
@@ -77,7 +77,7 @@ class MaxHeap
    end
  end

-  # ## Извлечение элемента из кучи ###
+  ### Извлечение элемента из кучи ###
  def pop
    # Обработка пустого случая
    raise IndexError, "куча пуста" if is_empty?
@@ -91,7 +91,7 @@ class MaxHeap
    val
  end

-  # ## Начиная с узла i, выполнить просеивание сверху вниз ###
+  ### Начиная с узла i, выполнить просеивание сверху вниз ###
  def sift_down(i)
    loop do
      # Определить узел с максимальным значением среди i, l и r и обозначить его как ma
@@ -6,31 +6,31 @@ Author: Blue Bean (lonnnnnnner@gmail.com)

 require_relative "./my_heap"

-# ## Добавление элемента в кучу ###
+### Добавление элемента в кучу ###
 def push_min_heap(heap, val)
  # Инвертировать знак элемента
  heap.push(-val)
 end

-# ## Извлечение элемента из кучи ###
+### Извлечение элемента из кучи ###
 def pop_min_heap(heap)
  # Инвертировать знак элемента
  -heap.pop
 end

-# ## Доступ к элементу на вершине кучи ###
+### Доступ к элементу на вершине кучи ###
 def peek_min_heap(heap)
  # Инвертировать знак элемента
  -heap.peek
 end

-# ## Извлечение элементов из кучи ###
+### Извлечение элементов из кучи ###
 def get_min_heap(heap)
  # Инвертировать все элементы кучи
  heap.max_heap.map { |x| -x }
 end

-# ## Поиск k наибольших элементов массива с помощью кучи ###
+### Поиск k наибольших элементов массива с помощью кучи ###
 def top_k_heap(nums, k)
  # Инициализация минимальной кучи
  # Обратите внимание: мы инвертируем все элементы кучи, чтобы с помощью максимальной кучи имитировать минимальную
@@ -4,7 +4,7 @@ Created Time: 2024-04-09
 Author: Blue Bean (lonnnnnnner@gmail.com)
 =end

-# ## Бинарный поиск (двусторонне замкнутый интервал) ###
+### Бинарный поиск (двусторонне замкнутый интервал) ###
 def binary_search(nums, target)
  # Инициализировать двусторонне замкнутый интервал [0, n-1], то есть i и j указывают на первый и последний элементы массива соответственно
  i, j = 0, nums.length - 1
@@ -26,7 +26,7 @@ def binary_search(nums, target)
  -1  # Целевой элемент не найден, вернуть -1
 end

-# ## Бинарный поиск (лево замкнутый, право открытый интервал) ###
+### Бинарный поиск (лево замкнутый, право открытый интервал) ###
 def binary_search_lcro(nums, target)
  # Инициализировать лево замкнутый, право открытый интервал [0, n), то есть i и j указывают на первый элемент массива и позицию сразу за последним элементом соответственно
  i, j = 0, nums.length
@@ -6,7 +6,7 @@ Author: Blue Bean (lonnnnnnner@gmail.com)

 require_relative './binary_search_insertion'

-# ## Бинарный поиск самого левого target ###
+### Бинарный поиск самого левого target ###
 def binary_search_left_edge(nums, target)
  # Эквивалентно поиску точки вставки target
  i = binary_search_insertion(nums, target)
@@ -17,7 +17,7 @@ def binary_search_left_edge(nums, target)
  i # Найти target и вернуть индекс i
 end

-# ## Бинарный поиск самого правого target ###
+### Бинарный поиск самого правого target ###
 def binary_search_right_edge(nums, target)
  # Преобразовать задачу в поиск самого левого target + 1
  i = binary_search_insertion(nums, target + 1)
@@ -4,7 +4,7 @@ Created Time: 2024-04-09
 Author: Blue Bean (lonnnnnnner@gmail.com)
 =end

-# ## Бинарный поиск точки вставки (без повторяющихся элементов) ###
+### Бинарный поиск точки вставки (без повторяющихся элементов) ###
 def binary_search_insertion_simple(nums, target)
  # Инициализировать двусторонне замкнутый интервал [0, n-1]
  i, j = 0, nums.length - 1
@@ -25,7 +25,7 @@ def binary_search_insertion_simple(nums, target)
  i # target не найден, вернуть точку вставки i
 end

-# ## Бинарный поиск точки вставки (с повторяющимися элементами) ###
+### Бинарный поиск точки вставки (с повторяющимися элементами) ###
 def binary_search_insertion(nums, target)
  # Инициализировать двусторонне замкнутый интервал [0, n-1]
  i, j = 0, nums.length - 1
@@ -6,14 +6,14 @@ Author: Blue Bean (lonnnnnnner@gmail.com)

 require_relative '../utils/list_node'

-# ## Хеш-поиск (массив) ###
+### Хеш-поиск (массив) ###
 def hashing_search_array(hmap, target)
  # key хеш-таблицы: целевой элемент, value: индекс
  # Если такого key нет в хеш-таблице, вернуть -1
  hmap[target] || -1
 end

-# ## Хеш-поиск (связный список) ###
+### Хеш-поиск (связный список) ###
 def hashing_search_linkedlist(hmap, target)
  # key хеш-таблицы: целевой элемент, value: объект узла
  # Если такого key нет в хеш-таблице, вернуть None
@@ -6,7 +6,7 @@ Author: Blue Bean (lonnnnnnner@gmail.com)

 require_relative '../utils/list_node'

-# ## Линейный поиск (массив) ###
+### Линейный поиск (массив) ###
 def linear_search_array(nums, target)
  # Обход массива
  for i in 0...nums.length
@@ -16,7 +16,7 @@ def linear_search_array(nums, target)
  -1 # Целевой элемент не найден, вернуть -1
 end

-# ## Линейный поиск (связный список) ###
+### Линейный поиск (связный список) ###
 def linear_search_linkedlist(head, target)
  # Обойти связный список
  while head
@@ -4,7 +4,7 @@ Created Time: 2024-04-09
 Author: Blue Bean (lonnnnnnner@gmail.com)
 =end

-# ## Метод 1: полный перебор ###
+### Метод 1: полный перебор ###
 def two_sum_brute_force(nums, target)
  # Два вложенных цикла, временная сложность O(n^2)
  for i in 0...(nums.length - 1)
@@ -16,7 +16,7 @@ def two_sum_brute_force(nums, target)
  []
 end

-# ## Метод 2: вспомогательная хеш-таблица ###
+### Метод 2: вспомогательная хеш-таблица ###
 def two_sum_hash_table(nums, target)
  # Вспомогательная хеш-таблица, пространственная сложность O(n)
  dic = {}
@@ -4,7 +4,7 @@ Created Time: 2024-05-02
 Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 =end

-# ## Пузырьковая сортировка ###
+### Пузырьковая сортировка ###
 def bubble_sort(nums)
  n = nums.length
  # Внешний цикл: неотсортированный диапазон [0, i]
@@ -4,7 +4,7 @@ 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
@@ -4,7 +4,7 @@ Created Time: 2024-05-02
 Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 =end

-# ## Сортировка подсчетом ###
+### Сортировка подсчетом ###
 def counting_sort_naive(nums)
  # Простая реализация, не подходит для сортировки объектов
  # 1. Найти максимальный элемент массива m
@@ -24,7 +24,7 @@ def counting_sort_naive(nums)
  end
 end

-# ## Сортировка подсчетом ###
+### Сортировка подсчетом ###
 def counting_sort(nums)
  # Полная реализация, позволяет сортировать объекты и является стабильной сортировкой
  # 1. Найти максимальный элемент массива m
@@ -4,7 +4,7 @@ Created Time: 2024-04-10
 Author: junminhong (junminhong1110@gmail.com)
 =end

-# ## Длина кучи равна n; начиная с узла i, выполнить просеивание сверху вниз ###
+### Длина кучи равна n; начиная с узла i, выполнить просеивание сверху вниз ###
 def sift_down(nums, n, i)
  while true
    # Определить узел с максимальным значением среди i, l и r и обозначить его как ma
@@ -22,7 +22,7 @@ def sift_down(nums, n, i)
  end
 end

-# ## Сортировка кучей ###
+### Сортировка кучей ###
 def heap_sort(nums)
  # Построение кучи: выполнить heapify для всех узлов, кроме листовых
  (nums.length / 2 - 1).downto(0) do |i|
@@ -4,7 +4,7 @@ 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]
@@ -4,7 +4,7 @@ Created Time: 2024-04-10
 Author: junminhong (junminhong1110@gmail.com)
 =end

-# ## Слияние левого и правого подмассивов ###
+### Слияние левого и правого подмассивов ###
 def merge(nums, left, mid, right)
  # Интервал левого подмассива: [left, mid], правого подмассива: [mid+1, right]
  # Создать временный массив tmp для хранения результата слияния
@@ -39,7 +39,7 @@ def merge(nums, left, mid, right)
  end
 end

-# ## Сортировка слиянием ###
+### Сортировка слиянием ###
 def merge_sort(nums, left, right)
  # Условие завершения
  # Когда длина подмассива равна 1, рекурсия завершается
@@ -4,10 +4,10 @@ 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
@@ -26,7 +26,7 @@ class QuickSort
      i # Вернуть индекс опорного элемента
    end

-    # ## Класс быстрой сортировки ###
+    ### Класс быстрой сортировки ###
    def quick_sort(nums, left, right)
      # Рекурсивно обрабатывать, пока длина подмассива не станет равной 1
      if left < right
@@ -44,7 +44,7 @@ end
 # ## Класс быстрой сортировки (оптимизация медианой) ###
 class QuickSortMedian
  class << self
-    # ## Выбрать медиану из трех кандидатов ###
+    ### Выбрать медиану из трех кандидатов ###
    def median_three(nums, left, mid, right)
      # Выбрать медиану из трех кандидатов
      _l, _m, _r = nums[left], nums[mid], nums[right]
@@ -77,7 +77,7 @@ class QuickSortMedian
      i # Вернуть индекс опорного элемента
    end

-    # ## Быстрая сортировка ###
+    ### Быстрая сортировка ###
    def quick_sort(nums, left, right)
      # Рекурсивно обрабатывать, пока длина подмассива не станет равной 1
      if left < right
@@ -95,7 +95,7 @@ end
 # ## Класс быстрой сортировки (оптимизация глубины рекурсии) ###
 class QuickSortTailCall
  class << self
-    # ## Разбиение с опорными указателями ###
+    ### Разбиение с опорными указателями ###
    def partition(nums, left, right)
      # Использовать nums[left] как опорный элемент
      i = left
@@ -4,7 +4,7 @@ Created Time: 2024-05-03
 Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 =end

-# ## Получить k-й разряд элемента num, где exp = 10^(k-1) ###
+### Получить k-й разряд элемента num, где exp = 10^(k-1) ###
 def digit(num, exp)
  # Передача exp вместо k позволяет избежать повторного выполнения дорогостоящих вычислений степени
  (num / exp) % 10
@@ -34,7 +34,7 @@ def counting_sort_digit(nums, exp)
  (0...n).each { |i| nums[i] = res[i] }
 end

-# ## Поразрядная сортировка ###
+### Поразрядная сортировка ###
 def radix_sort(nums)
  # Получить максимальный элемент массива, чтобы определить максимальное число разрядов
  m = nums.max
@@ -4,7 +4,7 @@ Created Time: 2024-05-03
 Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 =end

-# ## Сортировка выбором ###
+### Сортировка выбором ###
 def selection_sort(nums)
  n = nums.length
  # Внешний цикл: неотсортированный диапазон [i, n-1]
@@ -4,29 +4,29 @@ Created Time: 2024-04-05
 Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 =end

-# ## Двусторонняя очередь на основе кольцевого массива ###
+### Двусторонняя очередь на основе кольцевого массива ###
 class ArrayDeque
-  # ## Получение длины двусторонней очереди ###
+  ### Получение длины двусторонней очереди ###
  attr_reader :size

-  # ## Конструктор ###
+  ### Конструктор ###
  def initialize(capacity)
    @nums = Array.new(capacity, 0)
    @front = 0
    @size = 0
  end

-  # ## Получить вместимость двусторонней очереди ###
+  ### Получить вместимость двусторонней очереди ###
  def capacity
    @nums.length
  end

-  # ## Проверка, пуста ли двусторонняя очередь ###
+  ### Проверка, пуста ли двусторонняя очередь ###
  def is_empty?
    size.zero?
  end

-  # ## Добавление в голову очереди ###
+  ### Добавление в голову очереди ###
  def push_first(num)
    if size == capacity
      puts 'Двусторонняя очередь заполнена'
@@ -41,7 +41,7 @@ class ArrayDeque
    @size += 1
  end

-  # ## Добавление в хвост очереди ###
+  ### Добавление в хвост очереди ###
  def push_last(num)
    if size == capacity
      puts 'Двусторонняя очередь заполнена'
@@ -55,7 +55,7 @@ class ArrayDeque
    @size += 1
  end

-  # ## Извлечение из головы очереди ###
+  ### Извлечение из головы очереди ###
  def pop_first
    num = peek_first
    # Указатель головы сдвигается на одну позицию назад
@@ -64,21 +64,21 @@ class ArrayDeque
    num
  end

-  # ## Извлечение из хвоста очереди ###
+  ### Извлечение из хвоста очереди ###
  def pop_last
    num = peek_last
    @size -= 1
    num
  end

-  # ## Доступ к элементу в начале очереди ###
+  ### Доступ к элементу в начале очереди ###
  def peek_first
    raise IndexError, 'двусторонняя очередь пуста' if is_empty?

    @nums[@front]
  end

-  # ## Доступ к элементу в хвосте очереди ###
+  ### Доступ к элементу в хвосте очереди ###
  def peek_last
    raise IndexError, 'двусторонняя очередь пуста' if is_empty?

@@ -87,7 +87,7 @@ class ArrayDeque
    @nums[last]
  end

-  # ## Вернуть массив для вывода ###
+  ### Вернуть массив для вывода ###
  def to_array
    # Преобразовывать только элементы списка в пределах фактической длины
    res = []
@@ -99,7 +99,7 @@ class ArrayDeque

  private

-  # ## Вычислить индекс в кольцевом массиве ###
+  ### Вычислить индекс в кольцевом массиве ###
  def index(i)
    # С помощью операции взятия по модулю соединить начало и конец массива
    # Когда i выходит за конец массива, он возвращается в начало
@@ -4,29 +4,29 @@ Created Time: 2024-04-05
 Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 =end

-# ## Очередь на основе кольцевого массива ###
+### Очередь на основе кольцевого массива ###
 class ArrayQueue
-  # ## Получение длины очереди ###
+  ### Получение длины очереди ###
  attr_reader :size

-  # ## Конструктор ###
+  ### Конструктор ###
  def initialize(size)
    @nums = Array.new(size, 0) # Массив для хранения элементов очереди
    @front = 0 # Указатель head, указывающий на первый элемент очереди
    @size = 0 # Длина очереди
  end

-  # ## Получить вместимость очереди ###
+  ### Получить вместимость очереди ###
  def capacity
    @nums.length
  end

-  # ## Проверка, пуста ли очередь ###
+  ### Проверка, пуста ли очередь ###
  def is_empty?
    size.zero?
  end

-  # ## Добавление в очередь ###
+  ### Добавление в очередь ###
  def push(num)
    raise IndexError, 'очередь заполнена' if size == capacity

@@ -38,7 +38,7 @@ class ArrayQueue
    @size += 1
  end

-  # ## Извлечение из очереди ###
+  ### Извлечение из очереди ###
  def pop
    num = peek
    # Указатель head сдвигается на одну позицию назад; если он выходит за конец, то возвращается в начало массива
@@ -47,14 +47,14 @@ class ArrayQueue
    num
  end

-  # ## Доступ к элементу в начале очереди ###
+  ### Доступ к элементу в начале очереди ###
  def peek
    raise IndexError, 'очередь пуста' if is_empty?

    @nums[@front]
  end

-  # ## Вернуть список для вывода ###
+  ### Вернуть список для вывода ###
  def to_array
    res = Array.new(size, 0)
    j = @front
@@ -4,43 +4,43 @@ Created Time: 2024-04-06
 Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 =end

-# ## Стек на основе массива ###
+### Стек на основе массива ###
 class ArrayStack
-  # ## Конструктор ###
+  ### Конструктор ###
  def initialize
    @stack = []
  end

-  # ## Получить длину стека ###
+  ### Получить длину стека ###
  def size
    @stack.length
  end

-  # ## Проверка, пуст ли стек ###
+  ### Проверка, пуст ли стек ###
  def is_empty?
    @stack.empty?
  end

-  # ## Помещение в стек ###
+  ### Помещение в стек ###
  def push(item)
    @stack << item
  end

-  # ## Извлечение из стека ###
+  ### Извлечение из стека ###
  def pop
    raise IndexError, 'стек пуст' if is_empty?

    @stack.pop
  end

-  # ## Доступ к верхнему элементу стека ###
+  ### Доступ к верхнему элементу стека ###
  def peek
    raise IndexError, 'стек пуст' if is_empty?

    @stack.last
  end

-  # ## Вернуть список для вывода ###
+  ### Вернуть список для вывода ###
  def to_array
    @stack
  end
@@ -10,30 +10,30 @@ class ListNode
  attr_accessor :next # Ссылка на узел-преемник
  attr_accessor :prev # Ссылка на узел-предшественник

-  # ## Конструктор ###
+  ### Конструктор ###
  def initialize(val)
    @val = val
  end
 end

-# ## Двусторонняя очередь на основе двусвязного списка ###
+### Двусторонняя очередь на основе двусвязного списка ###
 class LinkedListDeque
-  # ## Получение длины двусторонней очереди ###
+  ### Получение длины двусторонней очереди ###
  attr_reader :size

-  # ## Конструктор ###
+  ### Конструктор ###
  def initialize
    @front = nil  # Головной узел front
    @rear = nil   # Хвостовой узел rear
    @size = 0     # Длина двусторонней очереди
  end

-  # ## Проверка, пуста ли двусторонняя очередь ###
+  ### Проверка, пуста ли двусторонняя очередь ###
  def is_empty?
    size.zero?
  end

-  # ## Операция добавления в очередь ###
+  ### Операция добавления в очередь ###
  def push(num, is_front)
    node = ListNode.new(num)
    # Если связный список пуст, пусть front и rear оба указывают на node
@@ -55,17 +55,17 @@ class LinkedListDeque
    @size += 1 # Обновить длину очереди
  end

-  # ## Добавление в голову очереди ###
+  ### Добавление в голову очереди ###
  def push_first(num)
    push(num, true)
  end

-  # ## Добавление в хвост очереди ###
+  ### Добавление в хвост очереди ###
  def push_last(num)
    push(num, false)
  end

-  # ## Операция извлечения из очереди ###
+  ### Операция извлечения из очереди ###
  def pop(is_front)
    raise IndexError, 'двусторонняя очередь пуста' if is_empty?

@@ -95,31 +95,31 @@ class LinkedListDeque
    val
  end

-  # ## Извлечение из головы очереди ###
+  ### Извлечение из головы очереди ###
  def pop_first
    pop(true)
  end

-  # ## Извлечение из головы очереди ###
+  ### Извлечение из головы очереди ###
  def pop_last
    pop(false)
  end

-  # ## Доступ к элементу в начале очереди ###
+  ### Доступ к элементу в начале очереди ###
  def peek_first
    raise IndexError, 'двусторонняя очередь пуста' if is_empty?

    @front.val
  end

-  # ## Доступ к элементу в хвосте очереди ###
+  ### Доступ к элементу в хвосте очереди ###
  def peek_last
    raise IndexError, 'двусторонняя очередь пуста' if is_empty?

    @rear.val
  end

-  # ## Вернуть массив для вывода ###
+  ### Вернуть массив для вывода ###
  def to_array
    node = @front
    res = Array.new(size, 0)
@@ -6,24 +6,24 @@ Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)

 require_relative '../utils/list_node'

-# ## Очередь на основе связного списка ###
+### Очередь на основе связного списка ###
 class LinkedListQueue
-  # ## Получение длины очереди ###
+  ### Получение длины очереди ###
  attr_reader :size

-  # ## Конструктор ###
+  ### Конструктор ###
  def initialize
    @front = nil  # Головной узел front
    @rear = nil   # Хвостовой узел rear
    @size = 0
  end

-  # ## Проверка, пуста ли очередь ###
+  ### Проверка, пуста ли очередь ###
  def is_empty?
    @front.nil?
  end

-  # ## Добавление в очередь ###
+  ### Добавление в очередь ###
  def push(num)
    # Добавить num после хвостового узла
    node = ListNode.new(num)
@@ -41,7 +41,7 @@ class LinkedListQueue
    @size += 1
  end

-  # ## Извлечение из очереди ###
+  ### Извлечение из очереди ###
  def pop
    num = peek
    # Удалить головной узел
@@ -50,14 +50,14 @@ class LinkedListQueue
    num
  end

-  # ## Доступ к элементу в начале очереди ###
+  ### Доступ к элементу в начале очереди ###
  def peek
    raise IndexError, 'очередь пуста' if is_empty?

    @front.val
  end

-  # ## Преобразовать связный список в Array и вернуть ###
+  ### Преобразовать связный список в Array и вернуть ###
  def to_array
    queue = []
    temp = @front
@@ -6,21 +6,21 @@ Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)

 require_relative '../utils/list_node'

-# ## Стек на основе связного списка ###
+### Стек на основе связного списка ###
 class LinkedListStack
  attr_reader :size

-  # ## Конструктор ###
+  ### Конструктор ###
  def initialize
    @size = 0
  end

-  # ## Проверка, пуст ли стек ###
+  ### Проверка, пуст ли стек ###
  def is_empty?
    @peek.nil?
  end

-  # ## Помещение в стек ###
+  ### Помещение в стек ###
  def push(val)
    node = ListNode.new(val)
    node.next = @peek
@@ -28,7 +28,7 @@ class LinkedListStack
    @size += 1
  end

-  # ## Извлечение из стека ###
+  ### Извлечение из стека ###
  def pop
    num = peek
    @peek = @peek.next
@@ -36,14 +36,14 @@ class LinkedListStack
    num
  end

-  # ## Доступ к верхнему элементу стека ###
+  ### Доступ к верхнему элементу стека ###
  def peek
    raise IndexError, 'стек пуст' if is_empty?

    @peek.val
  end

-  # ## Преобразовать связный список в Array и вернуть ###
+  ### Преобразовать связный список в Array и вернуть ###
  def to_array
    arr = []
    node = @peek
@@ -7,19 +7,19 @@ Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 require_relative '../utils/tree_node'
 require_relative '../utils/print_util'

-# ## Класс двоичного дерева в массивном представлении ###
+### Класс двоичного дерева в массивном представлении ###
 class ArrayBinaryTree
-  # ## Конструктор ###
+  ### Конструктор ###
  def initialize(arr)
    @tree = arr.to_a
  end

-  # ## Вместимость списка ###
+  ### Вместимость списка ###
  def size
    @tree.length
  end

-  # ## Получить значение узла с индексом i ###
+  ### Получить значение узла с индексом i ###
  def val(i)
    # Если индекс выходит за границы, вернуть nil, обозначающий пустую ячейку
    return if i < 0 || i >= size
@@ -27,22 +27,22 @@ class ArrayBinaryTree
    @tree[i]
  end

-  # ## Получить индекс левого дочернего узла узла с индексом i ###
+  ### Получить индекс левого дочернего узла узла с индексом i ###
  def left(i)
    2 * i + 1
  end

-  # ## Получить индекс правого дочернего узла узла с индексом i ###
+  ### Получить индекс правого дочернего узла узла с индексом i ###
  def right(i)
    2 * i + 2
  end

-  # ## Получить индекс родительского узла узла с индексом i ###
+  ### Получить индекс родительского узла узла с индексом i ###
  def parent(i)
    (i - 1) / 2
  end

-  # ## Обход в ширину ###
+  ### Обход в ширину ###
  def level_order
    @res = []

@@ -54,7 +54,7 @@ class ArrayBinaryTree
    @res
  end

-  # ## Обход в глубину ###
+  ### Обход в глубину ###
  def dfs(i, order)
    return if val(i).nil?
    # Предварительный обход
@@ -67,21 +67,21 @@ class ArrayBinaryTree
    @res << val(i) if order == :post
  end

-  # ## Предварительный обход ###
+  ### Предварительный обход ###
  def pre_order
    @res = []
    dfs(0, :pre)
    @res
  end

-  # ## Симметричный обход ###
+  ### Симметричный обход ###
  def in_order
    @res = []
    dfs(0, :in)
    @res
  end

-  # ## Обратный обход ###
+  ### Обратный обход ###
  def post_order
    @res = []
    dfs(0, :post)
@@ -7,19 +7,19 @@ Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 require_relative '../utils/tree_node'
 require_relative '../utils/print_util'

-# ## AVL-дерево ###
+### AVL-дерево ###
 class AVLTree
-  # ## Конструктор ###
+  ### Конструктор ###
  def initialize
    @root = nil
  end

-  # ## Получение корневого узла двоичного дерева ###
+  ### Получение корневого узла двоичного дерева ###
  def get_root
    @root
  end

-  # ## Получить высоту узла ###
+  ### Получить высоту узла ###
  def height(node)
    # Высота пустого узла равна -1, высота листового узла равна 0
    return node.height unless node.nil?
@@ -27,13 +27,13 @@ class AVLTree
    -1
  end

-  # ## Обновить высоту узла ###
+  ### Обновить высоту узла ###
  def update_height(node)
    # Высота узла равна высоте более высокого поддерева + 1
    node.height = [height(node.left), height(node.right)].max + 1
  end

-  # ## Получить коэффициент баланса ###
+  ### Получить коэффициент баланса ###
  def balance_factor(node)
    # Коэффициент баланса пустого узла равен 0
    return 0 if node.nil?
@@ -42,7 +42,7 @@ class AVLTree
    height(node.left) - height(node.right)
  end

-  # ## Операция правого вращения ###
+  ### Операция правого вращения ###
  def right_rotate(node)
    child = node.left
    grand_child = child.right
@@ -56,7 +56,7 @@ class AVLTree
    child
  end

-  # ## Операция левого вращения ###
+  ### Операция левого вращения ###
  def left_rotate(node)
    child = node.right
    grand_child = child.left
@@ -70,7 +70,7 @@ class AVLTree
    child
  end

-  # ## Выполнить вращение, чтобы снова сбалансировать поддерево ###
+  ### Выполнить вращение, чтобы снова сбалансировать поддерево ###
  def rotate(node)
    # Получить коэффициент баланса узла node
    balance_factor = balance_factor(node)
@@ -99,7 +99,7 @@ class AVLTree
    node
  end

-  # ## Вставка узла ###
+  ### Вставка узла ###
  def insert(val)
    @root = insert_helper(@root, val)
  end
@@ -122,7 +122,7 @@ class AVLTree
    rotate(node)
  end

-  # ## Удаление узла ###
+  ### Удаление узла ###
  def remove(val)
    @root = remove_helper(@root, val)
  end
@@ -158,7 +158,7 @@ class AVLTree
    rotate(node)
  end

-  # ## Поиск узла ###
+  ### Поиск узла ###
  def search(val)
    cur = @root
    # Искать в цикле и выйти после прохода за листовой узел
@@ -7,20 +7,20 @@ Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 require_relative '../utils/tree_node'
 require_relative '../utils/print_util'

-# ## Двоичное дерево поиска ###
+### Двоичное дерево поиска ###
 class BinarySearchTree
-  # ## Конструктор ###
+  ### Конструктор ###
  def initialize
    # Инициализировать пустое дерево
    @root = nil
  end

-  # ## Получение корневого узла двоичного дерева ###
+  ### Получение корневого узла двоичного дерева ###
  def get_root
    @root
  end

-  # ## Поиск узла ###
+  ### Поиск узла ###
  def search(num)
    cur = @root

@@ -41,7 +41,7 @@ class BinarySearchTree
    cur
  end

-  # ## Вставка узла ###
+  ### Вставка узла ###
  def insert(num)
    # Если дерево пусто, инициализировать корневой узел
    if @root.nil?
@@ -74,7 +74,7 @@ class BinarySearchTree
    end
  end

-  # ## Удаление узла ###
+  ### Удаление узла ###
  def remove(num)
    # Если дерево пусто, сразу вернуть
    return if @root.nil?
@@ -7,7 +7,7 @@ Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 require_relative '../utils/tree_node'
 require_relative '../utils/print_util'

-# ## Обход в ширину ###
+### Обход в ширину ###
 def level_order(root)
  # Инициализировать очередь и добавить корневой узел
  queue = [root]
@@ -7,7 +7,7 @@ Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 require_relative '../utils/tree_node'
 require_relative '../utils/print_util'

-# ## Предварительный обход ###
+### Предварительный обход ###
 def pre_order(root)
  return if root.nil?

@@ -17,7 +17,7 @@ def pre_order(root)
  pre_order(root.right)
 end

-# ## Симметричный обход ###
+### Симметричный обход ###
 def in_order(root)
  return if root.nil?

@@ -27,7 +27,7 @@ def in_order(root)
  in_order(root.right)
 end

-# ## Обратный обход ###
+### Обратный обход ###
 def post_order(root)
  return if root.nil?

@@ -4,7 +4,7 @@ Created Time: 2024-03-18
 Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 =end

-# ## Класс узла связного списка ###
+### Класс узла связного списка ###
 class ListNode
  attr_accessor :val  # Значение узла
  attr_accessor :next # Ссылка на следующий узел
@@ -15,7 +15,7 @@ class ListNode
  end
 end

-# ## Десериализация списка в связный список ###
+### Десериализация списка в связный список ###
 def arr_to_linked_list(arr)
  head = current = ListNode.new(arr[0])

@@ -27,7 +27,7 @@ def arr_to_linked_list(arr)
  head
 end

-# ## Сериализация связного списка в список ###
+### Сериализация связного списка в список ###
 def linked_list_to_arr(head)
  arr = []

@@ -6,14 +6,14 @@ Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)

 require_relative "./tree_node"

-# ## Вывести матрицу ###
+### Вывести матрицу ###
 def print_matrix(mat)
  s = []
  mat.each { |arr| s << " #{arr.to_s}" }
  puts "[\n#{s.join(",\n")}\n]"
 end

-# ## Вывести связный список ###
+### Вывести связный список ###
 def print_linked_list(head)
  list = []
  while head
@@ -39,8 +39,8 @@ def show_trunk(p)
  print p.str
 end

-# ## Вывести двоичное дерево ###
-# Этот вывод дерева заимствован из TECHIE DELIGHT
+### Вывести двоичное дерево ###
+# This tree printer is borrowed from TECHIE DELIGHT
 # https://www.techiedelight.com/c-program-print-binary-tree/
 def print_tree(root, prev=nil, is_right=false)
  return if root.nil?
@@ -66,12 +66,12 @@ def print_tree(root, prev=nil, is_right=false)
  print_tree(root.left, trunk, false)
 end

-# ## Вывести хеш-таблицу ###
+### Вывести хеш-таблицу ###
 def print_hash_map(hmap)
  hmap.entries.each { |key, value| puts "#{key} -> #{value}" }
 end

-# ## Вывести кучу ###
+### Вывести кучу ###
 def print_heap(heap)
  puts "Массивное представление кучи:#{heap}"
  puts "Древовидное представление кучи:"
@@ -4,7 +4,7 @@ Created Time: 2024-03-30
 Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 =end

-# ## Класс узла двоичного дерева ###
+### Класс узла двоичного дерева ###
 class TreeNode
  attr_accessor :val    # Значение узла
  attr_accessor :height # Высота узла
@@ -17,7 +17,7 @@ class TreeNode
  end
 end

-# ## Десериализация списка в двоичное дерево: рекурсия ###
+### Десериализация списка в двоичное дерево: рекурсия ###
 def arr_to_tree_dfs(arr, i)
  # Если индекс выходит за длину массива или соответствующий элемент равен nil, вернуть nil
  return if i < 0 || i >= arr.length || arr[i].nil?
@@ -29,12 +29,12 @@ def arr_to_tree_dfs(arr, i)
  root
 end

-# ## Десериализация списка в двоичное дерево ###
+### Десериализация списка в двоичное дерево ###
 def arr_to_tree(arr)
  arr_to_tree_dfs(arr, 0)
 end

-# ## Сериализация двоичного дерева в список: рекурсия ###
+### Сериализация двоичного дерева в список: рекурсия ###
 def tree_to_arr_dfs(root, i, res)
  return if root.nil?

@@ -45,7 +45,7 @@ def tree_to_arr_dfs(root, i, res)
  tree_to_arr_dfs(root.right, 2 * i + 2, res)
 end

-# ## Сериализация двоичного дерева в список ###
+### Сериализация двоичного дерева в список ###
 def tree_to_arr(root)
  res = []
  tree_to_arr_dfs(root, 0, res)
@@ -4,7 +4,7 @@ Created Time: 2024-04-25
 Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 =end

-# ## Класс вершины ###
+### Класс вершины ###
 class Vertex
  attr_accessor :val

@@ -13,12 +13,12 @@ class Vertex
  end
 end

-# ## На вход подается список значений vals, на выходе возвращается список вершин vets ###
+### На вход подается список значений vals, на выходе возвращается список вершин vets ###
 def vals_to_vets(vals)
  Array.new(vals.length) { |i| Vertex.new(vals[i]) }
 end

-# ## На вход подается список вершин vets, на выходе возвращается список значений vals ###
+### На вход подается список вершин vets, на выходе возвращается список значений vals ###
 def vets_to_vals(vets)
  Array.new(vets.length) { |i| vets[i].val }
 end