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_backtracking/n_queens.rb

@@ -0,0 +1,61 @@
+=begin
+File: n_queens.rb
+Created Time: 2024-05-21
+Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
+=end
+
+# ## Алгоритм бэктрекинга: n ферзей ###
+def backtrack(row, n, state, res, cols, diags1, diags2)
+  # Когда все строки уже обработаны, записать решение
+  if row == n
+    res << state.map { |row| row.dup }
+    return
+  end
+
+  # Обойти все столбцы
+  for col in 0...n
+    # Вычислить главную и побочную диагонали, соответствующие этой клетке
+    diag1 = row - col + n - 1
+    diag2 = row + col
+    # Отсечение: в столбце, главной диагонали и побочной диагонали этой клетки не должно быть ферзей
+    if !cols[col] && !diags1[diag1] && !diags2[diag2]
+      # Попытка: поставить ферзя в эту клетку
+      state[row][col] = "Q"
+      cols[col] = diags1[diag1] = diags2[diag2] = true
+      # Перейти к размещению следующей строки
+      backtrack(row + 1, n, state, res, cols, diags1, diags2)
+      # Откат: восстановить эту клетку как пустую
+      state[row][col] = "#"
+      cols[col] = diags1[diag1] = diags2[diag2] = false
+    end
+  end
+end
+
+# ## Решить задачу о n ферзях ###
+def n_queens(n)
+  # Инициализировать доску размера n*n, где 'Q' обозначает ферзя, а '#' — пустую клетку
+  state = Array.new(n) { Array.new(n, "#") }
+  cols = Array.new(n, false) # Отмечать, есть ли ферзь в столбце
+  diags1 = Array.new(2 * n - 1, false) # Отмечать наличие ферзя на главной диагонали
+  diags2 = Array.new(2 * n - 1, false) # Отмечать наличие ферзя на побочной диагонали
+  res = []
+  backtrack(0, n, state, res, cols, diags1, diags2)
+
+  res
+end
+
+### Driver Code ###
+if __FILE__ == $0
+  n = 4
+  res = n_queens(n)
+
+  puts "Размер входной доски = #{n}"
+  puts "Количество способов расстановки ферзей: #{res.length}"
+
+  for state in res
+    puts "--------------------"
+    for row in state
+      p row
+    end
+  end
+end

ru/codes/ruby/chapter_backtracking/permutations_i.rb

@@ -0,0 +1,46 @@
+=begin
+File: permutations_i.rb
+Created Time: 2024-05-22
+Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
+=end
+
+# ## Алгоритм бэктрекинга: все перестановки I ###
+def backtrack(state, choices, selected, res)
+  # Когда длина состояния равна числу элементов, записать решение
+  if state.length == choices.length
+    res << state.dup
+    return
+  end
+
+  # Перебор всех вариантов выбора
+  choices.each_with_index do |choice, i|
+    # Отсечение: нельзя выбирать один и тот же элемент повторно
+    unless selected[i]
+      # Попытка: сделать выбор и обновить состояние
+      selected[i] = true
+      state << choice
+      # Перейти к следующему выбору
+      backtrack(state, choices, selected, res)
+      # Откат: отменить выбор и восстановить предыдущее состояние
+      selected[i] = false
+      state.pop
+    end
+  end
+end
+
+# ## Все перестановки I ###
+def permutations_i(nums)
+  res = []
+  backtrack([], nums, Array.new(nums.length, false), res)
+  res
+end
+
+### Driver Code ###
+if __FILE__ == $0
+  nums = [1, 2, 3]
+
+  res = permutations_i(nums)
+
+  puts "Входной массив nums = #{nums}"
+  puts "Все перестановки res = #{res}"
+end

ru/codes/ruby/chapter_backtracking/permutations_ii.rb

@@ -0,0 +1,48 @@
+=begin
+File: permutations_ii.rb
+Created Time: 2024-05-22
+Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
+=end
+
+# ## Алгоритм бэктрекинга: все перестановки II ###
+def backtrack(state, choices, selected, res)
+  # Когда длина состояния равна числу элементов, записать решение
+  if state.length == choices.length
+    res << state.dup
+    return
+  end
+
+  # Перебор всех вариантов выбора
+  duplicated = Set.new
+  choices.each_with_index do |choice, i|
+    # Отсечение: нельзя выбирать один и тот же элемент повторно и нельзя повторно выбирать равные элементы
+    if !selected[i] && !duplicated.include?(choice)
+      # Попытка: сделать выбор и обновить состояние
+      duplicated.add(choice)
+      selected[i] = true
+      state << choice
+      # Перейти к следующему выбору
+      backtrack(state, choices, selected, res)
+      # Откат: отменить выбор и восстановить предыдущее состояние
+      selected[i] = false
+      state.pop
+    end
+  end
+end
+
+# ## Все перестановки II ###
+def permutations_ii(nums)
+  res = []
+  backtrack([], nums, Array.new(nums.length, false), res)
+  res
+end
+
+### Driver Code ###
+if __FILE__ == $0
+  nums = [1, 2, 2]
+
+  res = permutations_ii(nums)
+
+  puts "Входной массив nums = #{nums}"
+  puts "Все перестановки res = #{res}"
+end

ru/codes/ruby/chapter_backtracking/preorder_traversal_i_compact.rb

@@ -0,0 +1,33 @@
+=begin
+File: preorder_traversal_i_compact.rb
+Created Time: 2024-05-22
+Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
+=end
+
+require_relative '../utils/tree_node'
+require_relative '../utils/print_util'
+
+# ## Предварительный обход: пример 1 ###
+def pre_order(root)
+  return unless root
+
+  # Записать решение
+  $res << root if root.val == 7
+
+  pre_order(root.left)
+  pre_order(root.right)
+end
+
+### Driver Code ###
+if __FILE__ == $0
+  root = arr_to_tree([1, 7, 3, 4, 5, 6, 7])
+  puts "\nИнициализация двоичного дерева"
+  print_tree(root)
+
+  # Предварительный обход
+  $res = []
+  pre_order(root)
+
+  puts "\nВсе узлы со значением 7"
+  p $res.map { |node| node.val }
+end

ru/codes/ruby/chapter_backtracking/preorder_traversal_ii_compact.rb

@@ -0,0 +1,41 @@
+=begin
+File: preorder_traversal_ii_compact.rb
+Created Time: 2024-05-22
+Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
+=end
+
+require_relative '../utils/tree_node'
+require_relative '../utils/print_util'
+
+# ## Предварительный обход: пример 2 ###
+def pre_order(root)
+  return unless root
+
+  # Попытка
+  $path << root
+
+  # Записать решение
+  $res << $path.dup if root.val == 7
+
+  pre_order(root.left)
+  pre_order(root.right)
+
+  # Откат
+  $path.pop
+end
+
+### Driver Code ###
+if __FILE__ == $0
+  root = arr_to_tree([1, 7, 3, 4, 5, 6, 7])
+  puts "\nИнициализация двоичного дерева"
+  print_tree(root)
+
+  # Предварительный обход
+  $path, $res = [], []
+  pre_order(root)
+
+  puts "\nВсе пути от корня к узлу 7"
+  for path in $res
+    p path.map { |node| node.val }
+  end
+end

ru/codes/ruby/chapter_backtracking/preorder_traversal_iii_compact.rb

@@ -0,0 +1,42 @@
+=begin
+File: preorder_traversal_iii_compact.rb
+Created Time: 2024-05-22
+Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
+=end
+
+require_relative '../utils/tree_node'
+require_relative '../utils/print_util'
+
+# ## Предварительный обход: пример 3 ###
+def pre_order(root)
+  # Отсечение
+  return if !root || root.val == 3
+
+  # Попытка
+  $path.append(root)
+
+  # Записать решение
+  $res << $path.dup if root.val == 7
+
+  pre_order(root.left)
+  pre_order(root.right)
+
+  # Откат
+  $path.pop
+end
+
+### Driver Code ###
+if __FILE__ == $0
+  root = arr_to_tree([1, 7, 3, 4, 5, 6, 7])
+  puts "\nИнициализация двоичного дерева"
+  print_tree(root)
+
+  # Предварительный обход
+  $path, $res = [], []
+  pre_order(root)
+
+  puts "\nВсе пути от корня к узлу 7, не содержащие узлов со значением 3"
+  for path in $res
+    p path.map { |node| node.val }
+  end
+end

ru/codes/ruby/chapter_backtracking/preorder_traversal_iii_template.rb

@@ -0,0 +1,68 @@
+=begin
+File: preorder_traversal_iii_template.rb
+Created Time: 2024-05-22
+Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
+=end
+
+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 ###
+def backtrack(state, choices, res)
+  # Проверить, является ли текущее состояние решением
+  record_solution(state, res) if is_solution?(state)
+
+  # Перебор всех вариантов выбора
+  for choice in choices
+    # Отсечение: проверить допустимость выбора
+    if is_valid?(state, choice)
+      # Попытка: сделать выбор и обновить состояние
+      make_choice(state, choice)
+      # Перейти к следующему выбору
+      backtrack(state, [choice.left, choice.right], res)
+      # Откат: отменить выбор и восстановить предыдущее состояние
+      undo_choice(state, choice)
+    end
+  end
+end
+
+### Driver Code ###
+if __FILE__ == $0
+  root = arr_to_tree([1, 7, 3, 4, 5, 6, 7])
+  puts "\nИнициализация двоичного дерева"
+  print_tree(root)
+
+  # Алгоритм бэктрекинга
+  res = []
+  backtrack([], [root], res)
+
+  puts "\nВсе пути от корня к узлу 7, в которых путь не содержит узлов со значением 3"
+  for path in res
+    p path.map { |node| node.val }
+  end
+end

ru/codes/ruby/chapter_backtracking/subset_sum_i.rb

@@ -0,0 +1,47 @@
+=begin
+File: subset_sum_i.rb
+Created Time: 2024-05-22
+Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
+=end
+
+# ## Алгоритм бэктрекинга: сумма подмножеств I ###
+def backtrack(state, target, choices, start, res)
+  # Если сумма подмножества равна target, записать решение
+  if target.zero?
+    res << state.dup
+    return
+  end
+  # Обойти все варианты выбора
+  # Отсечение 2: начинать обход с start, чтобы избежать генерации повторяющихся подмножеств
+  for i in start...choices.length
+    # Отсечение 1: если сумма подмножества превышает target, немедленно завершить цикл
+    # Это связано с тем, что массив уже отсортирован, следующие элементы больше, и сумма подмножества точно превысит target
+    break if target - choices[i] < 0
+    # Попытка: сделать выбор и обновить target и start
+    state << choices[i]
+    # Перейти к следующему выбору
+    backtrack(state, target - choices[i], choices, i, res)
+    # Откат: отменить выбор и восстановить предыдущее состояние
+    state.pop
+  end
+end
+
+# ## Решить задачу суммы подмножеств I ###
+def subset_sum_i(nums, target)
+  state = [] # Состояние (подмножество)
+  nums.sort! # Отсортировать nums
+  start = 0 # Стартовая вершина обхода
+  res = [] # Список результатов (список подмножеств)
+  backtrack(state, target, nums, start, res)
+  res
+end
+
+### Driver Code ###
+if __FILE__ == $0
+  nums = [3, 4, 5]
+  target = 9
+  res = subset_sum_i(nums, target)
+
+  puts "Входной массив nums = #{nums}, target = #{target}"
+  puts "Все подмножества с суммой #{target}: res = #{res}"
+end

ru/codes/ruby/chapter_backtracking/subset_sum_i_naive.rb

@@ -0,0 +1,46 @@
+=begin
+File: subset_sum_i_naive.rb
+Created Time: 2024-05-22
+Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
+=end
+
+# ## Алгоритм бэктрекинга: сумма подмножеств I ###
+def backtrack(state, target, total, choices, res)
+  # Если сумма подмножества равна target, записать решение
+  if total == target
+    res << state.dup
+    return
+  end
+
+  # Перебор всех вариантов выбора
+  for i in 0...choices.length
+    # Отсечение: если сумма подмножества превышает target, пропустить этот выбор
+    next if total + choices[i] > target
+    # Попытка: сделать выбор и обновить элемент и total
+    state << choices[i]
+    # Перейти к следующему выбору
+    backtrack(state, target, total + choices[i], choices, res)
+    # Откат: отменить выбор и восстановить предыдущее состояние
+    state.pop
+  end
+end
+
+# ## Решить задачу суммы подмножеств I (с повторяющимися подмножествами) ###
+def subset_sum_i_naive(nums, target)
+  state = [] # Состояние (подмножество)
+  total = 0 # Сумма подмножеств
+  res = [] # Список результатов (список подмножеств)
+  backtrack(state, target, total, nums, res)
+  res
+end
+
+### Driver Code ###
+if __FILE__ == $0
+  nums = [3, 4, 5]
+  target = 9
+  res = subset_sum_i_naive(nums, target)
+
+  puts "Входной массив nums = #{nums}, target = #{target}"
+  puts "Все подмножества с суммой #{target}: res = #{res}"
+  puts "Обратите внимание: результат этого метода содержит повторяющиеся множества"
+end

ru/codes/ruby/chapter_backtracking/subset_sum_ii.rb

@@ -0,0 +1,51 @@
+=begin
+File: subset_sum_ii.rb
+Created Time: 2024-05-22
+Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
+=end
+
+# ## Алгоритм бэктрекинга: сумма подмножеств II ###
+def backtrack(state, target, choices, start, res)
+  # Если сумма подмножества равна target, записать решение
+  if target.zero?
+    res << state.dup
+    return
+  end
+
+  # Обойти все варианты выбора
+  # Отсечение 2: начинать обход с start, чтобы избежать генерации повторяющихся подмножеств
+  # Отсечение 3: начинать обход с start, чтобы избежать повторного выбора одного и того же элемента
+  for i in start...choices.length
+    # Отсечение 1: если сумма подмножества превышает target, немедленно завершить цикл
+    # Это связано с тем, что массив уже отсортирован, следующие элементы больше, и сумма подмножества точно превысит target
+    break if target - choices[i] < 0
+    # Отсечение 4: если этот элемент равен элементу слева, значит ветвь поиска повторяется, ее нужно сразу пропустить
+    next if i > start && choices[i] == choices[i - 1]
+    # Попытка: сделать выбор и обновить target и start
+    state << choices[i]
+    # Перейти к следующему выбору
+    backtrack(state, target - choices[i], choices, i + 1, res)
+    # Откат: отменить выбор и восстановить предыдущее состояние
+    state.pop
+  end
+end
+
+# ## Решить задачу суммы подмножеств II ###
+def subset_sum_ii(nums, target)
+  state = [] # Состояние (подмножество)
+  nums.sort! # Отсортировать nums
+  start = 0 # Стартовая вершина обхода
+  res = [] # Список результатов (список подмножеств)
+  backtrack(state, target, nums, start, res)
+  res
+end
+
+### Driver Code ###
+if __FILE__ == $0
+  nums = [4, 4, 5]
+  target = 9
+  res = subset_sum_ii(nums, target)
+
+  puts "Входной массив nums = #{nums}, target = #{target}"
+  puts "Все подмножества с суммой #{target}: res = #{res}"
+end