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/python/chapter_backtracking/n_queens.py

@@ -0,0 +1,62 @@
+"""
+File: n_queens.py
+Created Time: 2023-04-26
+Author: krahets (krahets@163.com)
+"""
+
+
+def backtrack(
+    row: int,
+    n: int,
+    state: list[list[str]],
+    res: list[list[list[str]]],
+    cols: list[bool],
+    diags1: list[bool],
+    diags2: list[bool],
+):
+    """Алгоритм бэктрекинга: n ферзей"""
+    # Когда все строки уже обработаны, записать решение
+    if row == n:
+        res.append([list(row) for row in state])
+        return
+    # Обойти все столбцы
+    for col in range(n):
+        # Вычислить главную и побочную диагонали, соответствующие этой клетке
+        diag1 = row - col + n - 1
+        diag2 = row + col
+        # Отсечение: в столбце, главной диагонали и побочной диагонали этой клетки не должно быть ферзей
+        if not cols[col] and not diags1[diag1] and not 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
+
+
+def n_queens(n: int) -> list[list[list[str]]]:
+    """Решить задачу о n ферзях"""
+    # Инициализировать доску размера n*n, где 'Q' обозначает ферзя, а '#' — пустую клетку
+    state = [["#" for _ in range(n)] for _ in range(n)]
+    cols = [False] * n  # Отмечать, есть ли ферзь в столбце
+    diags1 = [False] * (2 * n - 1)  # Отмечать наличие ферзя на главной диагонали
+    diags2 = [False] * (2 * n - 1)  # Отмечать наличие ферзя на побочной диагонали
+    res = []
+    backtrack(0, n, state, res, cols, diags1, diags2)
+
+    return res
+
+
+"""Driver Code"""
+if __name__ == "__main__":
+    n = 4
+    res = n_queens(n)
+
+    print(f"Размер входной доски = {n}")
+    print(f"Количество способов расстановки ферзей: {len(res)}")
+    for state in res:
+        print("--------------------")
+        for row in state:
+            print(row)

ru/codes/python/chapter_backtracking/permutations_i.py

@@ -0,0 +1,44 @@
+"""
+File: permutations_i.py
+Created Time: 2023-04-15
+Author: krahets (krahets@163.com)
+"""
+
+
+def backtrack(
+    state: list[int], choices: list[int], selected: list[bool], res: list[list[int]]
+):
+    """Алгоритм бэктрекинга: все перестановки I"""
+    # Когда длина состояния равна числу элементов, записать решение
+    if len(state) == len(choices):
+        res.append(list(state))
+        return
+    # Перебор всех вариантов выбора
+    for i, choice in enumerate(choices):
+        # Отсечение: нельзя выбирать один и тот же элемент повторно
+        if not selected[i]:
+            # Попытка: сделать выбор и обновить состояние
+            selected[i] = True
+            state.append(choice)
+            # Перейти к следующему выбору
+            backtrack(state, choices, selected, res)
+            # Откат: отменить выбор и восстановить предыдущее состояние
+            selected[i] = False
+            state.pop()
+
+
+def permutations_i(nums: list[int]) -> list[list[int]]:
+    """Все перестановки I"""
+    res = []
+    backtrack(state=[], choices=nums, selected=[False] * len(nums), res=res)
+    return res
+
+
+"""Driver Code"""
+if __name__ == "__main__":
+    nums = [1, 2, 3]
+
+    res = permutations_i(nums)
+
+    print(f"Входной массив nums = {nums}")
+    print(f"Все перестановки res = {res}")

ru/codes/python/chapter_backtracking/permutations_ii.py

@@ -0,0 +1,46 @@
+"""
+File: permutations_ii.py
+Created Time: 2023-04-15
+Author: krahets (krahets@163.com)
+"""
+
+
+def backtrack(
+    state: list[int], choices: list[int], selected: list[bool], res: list[list[int]]
+):
+    """Алгоритм бэктрекинга: все перестановки II"""
+    # Когда длина состояния равна числу элементов, записать решение
+    if len(state) == len(choices):
+        res.append(list(state))
+        return
+    # Перебор всех вариантов выбора
+    duplicated = set[int]()
+    for i, choice in enumerate(choices):
+        # Отсечение: нельзя выбирать один и тот же элемент повторно и нельзя повторно выбирать равные элементы
+        if not selected[i] and choice not in duplicated:
+            # Попытка: сделать выбор и обновить состояние
+            duplicated.add(choice)  # Записать значения уже выбранных элементов
+            selected[i] = True
+            state.append(choice)
+            # Перейти к следующему выбору
+            backtrack(state, choices, selected, res)
+            # Откат: отменить выбор и восстановить предыдущее состояние
+            selected[i] = False
+            state.pop()
+
+
+def permutations_ii(nums: list[int]) -> list[list[int]]:
+    """Все перестановки II"""
+    res = []
+    backtrack(state=[], choices=nums, selected=[False] * len(nums), res=res)
+    return res
+
+
+"""Driver Code"""
+if __name__ == "__main__":
+    nums = [1, 2, 2]
+
+    res = permutations_ii(nums)
+
+    print(f"Входной массив nums = {nums}")
+    print(f"Все перестановки res = {res}")

ru/codes/python/chapter_backtracking/preorder_traversal_i_compact.py

@@ -0,0 +1,36 @@
+"""
+File: preorder_traversal_i_compact.py
+Created Time: 2023-04-15
+Author: krahets (krahets@163.com)
+"""
+
+import sys
+from pathlib import Path
+
+sys.path.append(str(Path(__file__).parent.parent))
+from modules import TreeNode, print_tree, list_to_tree
+
+
+def pre_order(root: TreeNode):
+    """Предварительный обход: пример 1"""
+    if root is None:
+        return
+    if root.val == 7:
+        # Записать решение
+        res.append(root)
+    pre_order(root.left)
+    pre_order(root.right)
+
+
+"""Driver Code"""
+if __name__ == "__main__":
+    root = list_to_tree([1, 7, 3, 4, 5, 6, 7])
+    print("\nИнициализация двоичного дерева")
+    print_tree(root)
+
+    # Предварительный обход
+    res = list[TreeNode]()
+    pre_order(root)
+
+    print("\nВсе узлы со значением 7")
+    print([node.val for node in res])

ru/codes/python/chapter_backtracking/preorder_traversal_ii_compact.py

@@ -0,0 +1,42 @@
+"""
+File: preorder_traversal_ii_compact.py
+Created Time: 2023-04-15
+Author: krahets (krahets@163.com)
+"""
+
+import sys
+from pathlib import Path
+
+sys.path.append(str(Path(__file__).parent.parent))
+from modules import TreeNode, print_tree, list_to_tree
+
+
+def pre_order(root: TreeNode):
+    """Предварительный обход: пример 2"""
+    if root is None:
+        return
+    # Попытка
+    path.append(root)
+    if root.val == 7:
+        # Записать решение
+        res.append(list(path))
+    pre_order(root.left)
+    pre_order(root.right)
+    # Откат
+    path.pop()
+
+
+"""Driver Code"""
+if __name__ == "__main__":
+    root = list_to_tree([1, 7, 3, 4, 5, 6, 7])
+    print("\nИнициализация двоичного дерева")
+    print_tree(root)
+
+    # Предварительный обход
+    path = list[TreeNode]()
+    res = list[list[TreeNode]]()
+    pre_order(root)
+
+    print("\nВсе пути от корня к узлу 7")
+    for path in res:
+        print([node.val for node in path])

ru/codes/python/chapter_backtracking/preorder_traversal_iii_compact.py

@@ -0,0 +1,43 @@
+"""
+File: preorder_traversal_iii_compact.py
+Created Time: 2023-04-15
+Author: krahets (krahets@163.com)
+"""
+
+import sys
+from pathlib import Path
+
+sys.path.append(str(Path(__file__).parent.parent))
+from modules import TreeNode, print_tree, list_to_tree
+
+
+def pre_order(root: TreeNode):
+    """Предварительный обход: пример 3"""
+    # Отсечение
+    if root is None or root.val == 3:
+        return
+    # Попытка
+    path.append(root)
+    if root.val == 7:
+        # Записать решение
+        res.append(list(path))
+    pre_order(root.left)
+    pre_order(root.right)
+    # Откат
+    path.pop()
+
+
+"""Driver Code"""
+if __name__ == "__main__":
+    root = list_to_tree([1, 7, 3, 4, 5, 6, 7])
+    print("\nИнициализация двоичного дерева")
+    print_tree(root)
+
+    # Предварительный обход
+    path = list[TreeNode]()
+    res = list[list[TreeNode]]()
+    pre_order(root)
+
+    print("\nВсе пути от корня к узлу 7, не содержащие узлов со значением 3")
+    for path in res:
+        print([node.val for node in path])

ru/codes/python/chapter_backtracking/preorder_traversal_iii_template.py

@@ -0,0 +1,71 @@
+"""
+File: preorder_traversal_iii_template.py
+Created Time: 2023-04-15
+Author: krahets (krahets@163.com)
+"""
+
+import sys
+from pathlib import Path
+
+sys.path.append(str(Path(__file__).parent.parent))
+from modules import TreeNode, print_tree, list_to_tree
+
+
+def is_solution(state: list[TreeNode]) -> bool:
+    """Проверить, является ли текущее состояние решением"""
+    return state and state[-1].val == 7
+
+
+def record_solution(state: list[TreeNode], res: list[list[TreeNode]]):
+    """Записать решение"""
+    res.append(list(state))
+
+
+def is_valid(state: list[TreeNode], choice: TreeNode) -> bool:
+    """Проверить, допустим ли этот выбор в текущем состоянии"""
+    return choice is not None and choice.val != 3
+
+
+def make_choice(state: list[TreeNode], choice: TreeNode):
+    """Обновить состояние"""
+    state.append(choice)
+
+
+def undo_choice(state: list[TreeNode], choice: TreeNode):
+    """Восстановить состояние"""
+    state.pop()
+
+
+def backtrack(
+    state: list[TreeNode], choices: list[TreeNode], res: list[list[TreeNode]]
+):
+    """Алгоритм бэктрекинга: пример 3"""
+    # Проверить, является ли текущее состояние решением
+    if is_solution(state):
+        # Записать решение
+        record_solution(state, res)
+    # Перебор всех вариантов выбора
+    for choice in choices:
+        # Отсечение: проверить допустимость выбора
+        if is_valid(state, choice):
+            # Попытка: сделать выбор и обновить состояние
+            make_choice(state, choice)
+            # Перейти к следующему выбору
+            backtrack(state, [choice.left, choice.right], res)
+            # Откат: отменить выбор и восстановить предыдущее состояние
+            undo_choice(state, choice)
+
+
+"""Driver Code"""
+if __name__ == "__main__":
+    root = list_to_tree([1, 7, 3, 4, 5, 6, 7])
+    print("\nИнициализация двоичного дерева")
+    print_tree(root)
+
+    # Алгоритм бэктрекинга
+    res = []
+    backtrack(state=[], choices=[root], res=res)
+
+    print("\nВсе пути от корня к узлу 7, в которых путь не содержит узлов со значением 3")
+    for path in res:
+        print([node.val for node in path])

ru/codes/python/chapter_backtracking/subset_sum_i.py

@@ -0,0 +1,48 @@
+"""
+File: subset_sum_i.py
+Created Time: 2023-06-17
+Author: krahets (krahets@163.com)
+"""
+
+
+def backtrack(
+    state: list[int], target: int, choices: list[int], start: int, res: list[list[int]]
+):
+    """Алгоритм бэктрекинга: сумма подмножеств I"""
+    # Если сумма подмножества равна target, записать решение
+    if target == 0:
+        res.append(list(state))
+        return
+    # Обойти все варианты выбора
+    # Отсечение 2: начинать обход с start, чтобы избежать генерации повторяющихся подмножеств
+    for i in range(start, len(choices)):
+        # Отсечение 1: если сумма подмножества превышает target, немедленно завершить цикл
+        # Это связано с тем, что массив уже отсортирован, следующие элементы больше, и сумма подмножества точно превысит target
+        if target - choices[i] < 0:
+            break
+        # Попытка: сделать выбор и обновить target и start
+        state.append(choices[i])
+        # Перейти к следующему выбору
+        backtrack(state, target - choices[i], choices, i, res)
+        # Откат: отменить выбор и восстановить предыдущее состояние
+        state.pop()
+
+
+def subset_sum_i(nums: list[int], target: int) -> list[list[int]]:
+    """Решить задачу суммы подмножеств I"""
+    state = []  # Состояние (подмножество)
+    nums.sort()  # Отсортировать nums
+    start = 0  # Стартовая вершина обхода
+    res = []  # Список результатов (список подмножеств)
+    backtrack(state, target, nums, start, res)
+    return res
+
+
+"""Driver Code"""
+if __name__ == "__main__":
+    nums = [3, 4, 5]
+    target = 9
+    res = subset_sum_i(nums, target)
+
+    print(f"Входной массив nums = {nums}, target = {target}")
+    print(f"Все подмножества с суммой {target}: res = {res}")

ru/codes/python/chapter_backtracking/subset_sum_i_naive.py

@@ -0,0 +1,50 @@
+"""
+File: subset_sum_i_naive.py
+Created Time: 2023-06-17
+Author: krahets (krahets@163.com)
+"""
+
+
+def backtrack(
+    state: list[int],
+    target: int,
+    total: int,
+    choices: list[int],
+    res: list[list[int]],
+):
+    """Алгоритм бэктрекинга: сумма подмножеств I"""
+    # Если сумма подмножества равна target, записать решение
+    if total == target:
+        res.append(list(state))
+        return
+    # Перебор всех вариантов выбора
+    for i in range(len(choices)):
+        # Отсечение: если сумма подмножества превышает target, пропустить этот выбор
+        if total + choices[i] > target:
+            continue
+        # Попытка: сделать выбор и обновить элемент и total
+        state.append(choices[i])
+        # Перейти к следующему выбору
+        backtrack(state, target, total + choices[i], choices, res)
+        # Откат: отменить выбор и восстановить предыдущее состояние
+        state.pop()
+
+
+def subset_sum_i_naive(nums: list[int], target: int) -> list[list[int]]:
+    """Решить задачу суммы подмножеств I (с повторяющимися подмножествами)"""
+    state = []  # Состояние (подмножество)
+    total = 0  # Сумма подмножеств
+    res = []  # Список результатов (список подмножеств)
+    backtrack(state, target, total, nums, res)
+    return res
+
+
+"""Driver Code"""
+if __name__ == "__main__":
+    nums = [3, 4, 5]
+    target = 9
+    res = subset_sum_i_naive(nums, target)
+
+    print(f"Входной массив nums = {nums}, target = {target}")
+    print(f"Все подмножества с суммой {target}: res = {res}")
+    print(f"Обратите внимание: результат этого метода содержит повторяющиеся множества")

ru/codes/python/chapter_backtracking/subset_sum_ii.py

@@ -0,0 +1,52 @@
+"""
+File: subset_sum_ii.py
+Created Time: 2023-06-17
+Author: krahets (krahets@163.com)
+"""
+
+
+def backtrack(
+    state: list[int], target: int, choices: list[int], start: int, res: list[list[int]]
+):
+    """Алгоритм бэктрекинга: сумма подмножеств II"""
+    # Если сумма подмножества равна target, записать решение
+    if target == 0:
+        res.append(list(state))
+        return
+    # Обойти все варианты выбора
+    # Отсечение 2: начинать обход с start, чтобы избежать генерации повторяющихся подмножеств
+    # Отсечение 3: начинать обход с start, чтобы избежать повторного выбора одного и того же элемента
+    for i in range(start, len(choices)):
+        # Отсечение 1: если сумма подмножества превышает target, немедленно завершить цикл
+        # Это связано с тем, что массив уже отсортирован, следующие элементы больше, и сумма подмножества точно превысит target
+        if target - choices[i] < 0:
+            break
+        # Отсечение 4: если этот элемент равен элементу слева, значит ветвь поиска повторяется, ее нужно сразу пропустить
+        if i > start and choices[i] == choices[i - 1]:
+            continue
+        # Попытка: сделать выбор и обновить target и start
+        state.append(choices[i])
+        # Перейти к следующему выбору
+        backtrack(state, target - choices[i], choices, i + 1, res)
+        # Откат: отменить выбор и восстановить предыдущее состояние
+        state.pop()
+
+
+def subset_sum_ii(nums: list[int], target: int) -> list[list[int]]:
+    """Решить задачу суммы подмножеств II"""
+    state = []  # Состояние (подмножество)
+    nums.sort()  # Отсортировать nums
+    start = 0  # Стартовая вершина обхода
+    res = []  # Список результатов (список подмножеств)
+    backtrack(state, target, nums, start, res)
+    return res
+
+
+"""Driver Code"""
+if __name__ == "__main__":
+    nums = [4, 4, 5]
+    target = 9
+    res = subset_sum_ii(nums, target)
+
+    print(f"Входной массив nums = {nums}, target = {target}")
+    print(f"Все подмножества с суммой {target}: res = {res}")