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

@@ -0,0 +1,67 @@
+/**
+ * File: n_queens.swift
+ * Created Time: 2023-05-14
+ * Author: nuomi1 (nuomi1@qq.com)
+ */
+
+/* Алгоритм бэктрекинга: n ферзей */
+func backtrack(row: Int, n: Int, state: inout [[String]], res: inout [[[String]]], cols: inout [Bool], diags1: inout [Bool], diags2: inout [Bool]) {
+    // Когда все строки уже обработаны, записать решение
+    if row == n {
+        res.append(state)
+        return
+    }
+    // Обойти все столбцы
+    for col in 0 ..< n {
+        // Вычислить главную и побочную диагонали, соответствующие этой клетке
+        let diag1 = row - col + n - 1
+        let diag2 = row + col
+        // Отсечение: в столбце, главной диагонали и побочной диагонали этой клетки не должно быть ферзей
+        if !cols[col] && !diags1[diag1] && !diags2[diag2] {
+            // Попытка: поставить ферзя в эту клетку
+            state[row][col] = "Q"
+            cols[col] = true
+            diags1[diag1] = true
+            diags2[diag2] = true
+            // Перейти к размещению следующей строки
+            backtrack(row: row + 1, n: n, state: &state, res: &res, cols: &cols, diags1: &diags1, diags2: &diags2)
+            // Откат: восстановить эту клетку как пустую
+            state[row][col] = "#"
+            cols[col] = false
+            diags1[diag1] = false
+            diags2[diag2] = false
+        }
+    }
+}
+
+/* Решить задачу о n ферзях */
+func nQueens(n: Int) -> [[[String]]] {
+    // Инициализировать доску размера n*n, где 'Q' обозначает ферзя, а '#' — пустую клетку
+    var state = Array(repeating: Array(repeating: "#", count: n), count: n)
+    var cols = Array(repeating: false, count: n) // Отмечать, есть ли ферзь в столбце
+    var diags1 = Array(repeating: false, count: 2 * n - 1) // Отмечать наличие ферзя на главной диагонали
+    var diags2 = Array(repeating: false, count: 2 * n - 1) // Отмечать наличие ферзя на побочной диагонали
+    var res: [[[String]]] = []
+
+    backtrack(row: 0, n: n, state: &state, res: &res, cols: &cols, diags1: &diags1, diags2: &diags2)
+
+    return res
+}
+
+@main
+enum NQueens {
+    /* Driver Code */
+    static func main() {
+        let n = 4
+        let res = nQueens(n: n)
+
+        print("Размер входной доски = \(n)")
+        print("Количество способов расстановки ферзей: \(res.count)")
+        for state in res {
+            print("--------------------")
+            for row in state {
+                print(row)
+            }
+        }
+    }
+}

ru/codes/swift/chapter_backtracking/permutations_i.swift

@@ -0,0 +1,50 @@
+/**
+ * File: permutations_i.swift
+ * Created Time: 2023-04-30
+ * Author: nuomi1 (nuomi1@qq.com)
+ */
+
+/* Алгоритм бэктрекинга: все перестановки I */
+func backtrack(state: inout [Int], choices: [Int], selected: inout [Bool], res: inout [[Int]]) {
+    // Когда длина состояния равна числу элементов, записать решение
+    if state.count == choices.count {
+        res.append(state)
+        return
+    }
+    // Перебор всех вариантов выбора
+    for (i, choice) in choices.enumerated() {
+        // Отсечение: нельзя выбирать один и тот же элемент повторно
+        if !selected[i] {
+            // Попытка: сделать выбор и обновить состояние
+            selected[i] = true
+            state.append(choice)
+            // Перейти к следующему выбору
+            backtrack(state: &state, choices: choices, selected: &selected, res: &res)
+            // Откат: отменить выбор и восстановить предыдущее состояние
+            selected[i] = false
+            state.removeLast()
+        }
+    }
+}
+
+/* Все перестановки I */
+func permutationsI(nums: [Int]) -> [[Int]] {
+    var state: [Int] = []
+    var selected = Array(repeating: false, count: nums.count)
+    var res: [[Int]] = []
+    backtrack(state: &state, choices: nums, selected: &selected, res: &res)
+    return res
+}
+
+@main
+enum PermutationsI {
+    /* Driver Code */
+    static func main() {
+        let nums = [1, 2, 3]
+
+        let res = permutationsI(nums: nums)
+
+        print("Входной массив nums = \(nums)")
+        print("Все перестановки res = \(res)")
+    }
+}

ru/codes/swift/chapter_backtracking/permutations_ii.swift

@@ -0,0 +1,52 @@
+/**
+ * File: permutations_ii.swift
+ * Created Time: 2023-04-30
+ * Author: nuomi1 (nuomi1@qq.com)
+ */
+
+/* Алгоритм бэктрекинга: все перестановки II */
+func backtrack(state: inout [Int], choices: [Int], selected: inout [Bool], res: inout [[Int]]) {
+    // Когда длина состояния равна числу элементов, записать решение
+    if state.count == choices.count {
+        res.append(state)
+        return
+    }
+    // Перебор всех вариантов выбора
+    var duplicated: Set<Int> = []
+    for (i, choice) in choices.enumerated() {
+        // Отсечение: нельзя выбирать один и тот же элемент повторно и нельзя повторно выбирать равные элементы
+        if !selected[i], !duplicated.contains(choice) {
+            // Попытка: сделать выбор и обновить состояние
+            duplicated.insert(choice) // Записать значения уже выбранных элементов
+            selected[i] = true
+            state.append(choice)
+            // Перейти к следующему выбору
+            backtrack(state: &state, choices: choices, selected: &selected, res: &res)
+            // Откат: отменить выбор и восстановить предыдущее состояние
+            selected[i] = false
+            state.removeLast()
+        }
+    }
+}
+
+/* Все перестановки II */
+func permutationsII(nums: [Int]) -> [[Int]] {
+    var state: [Int] = []
+    var selected = Array(repeating: false, count: nums.count)
+    var res: [[Int]] = []
+    backtrack(state: &state, choices: nums, selected: &selected, res: &res)
+    return res
+}
+
+@main
+enum PermutationsII {
+    /* Driver Code */
+    static func main() {
+        let nums = [1, 2, 3]
+
+        let res = permutationsII(nums: nums)
+
+        print("Входной массив nums = \(nums)")
+        print("Все перестановки res = \(res)")
+    }
+}

ru/codes/swift/chapter_backtracking/preorder_traversal_i_compact.swift

@@ -0,0 +1,43 @@
+/**
+ * File: preorder_traversal_i_compact.swift
+ * Created Time: 2023-04-30
+ * Author: nuomi1 (nuomi1@qq.com)
+ */
+
+import utils
+
+var res: [TreeNode] = []
+
+/* Предварительный обход: пример 1 */
+func preOrder(root: TreeNode?) {
+    guard let root = root else {
+        return
+    }
+    if root.val == 7 {
+        // Записать решение
+        res.append(root)
+    }
+    preOrder(root: root.left)
+    preOrder(root: root.right)
+}
+
+@main
+enum PreorderTraversalICompact {
+    /* Driver Code */
+    static func main() {
+        let root = TreeNode.listToTree(arr: [1, 7, 3, 4, 5, 6, 7])
+        print("\nИнициализация двоичного дерева")
+        PrintUtil.printTree(root: root)
+
+        // Предварительный обход
+        res = []
+        preOrder(root: root)
+
+        print("\nВсе узлы со значением 7")
+        var vals: [Int] = []
+        for node in res {
+            vals.append(node.val)
+        }
+        print(vals)
+    }
+}

ru/codes/swift/chapter_backtracking/preorder_traversal_ii_compact.swift

@@ -0,0 +1,51 @@
+/**
+ * File: preorder_traversal_ii_compact.swift
+ * Created Time: 2023-04-30
+ * Author: nuomi1 (nuomi1@qq.com)
+ */
+
+import utils
+
+var path: [TreeNode] = []
+var res: [[TreeNode]] = []
+
+/* Предварительный обход: пример 2 */
+func preOrder(root: TreeNode?) {
+    guard let root = root else {
+        return
+    }
+    // Попытка
+    path.append(root)
+    if root.val == 7 {
+        // Записать решение
+        res.append(path)
+    }
+    preOrder(root: root.left)
+    preOrder(root: root.right)
+    // Откат
+    path.removeLast()
+}
+
+@main
+enum PreorderTraversalIICompact {
+    /* Driver Code */
+    static func main() {
+        let root = TreeNode.listToTree(arr: [1, 7, 3, 4, 5, 6, 7])
+        print("\nИнициализация двоичного дерева")
+        PrintUtil.printTree(root: root)
+
+        // Предварительный обход
+        path = []
+        res = []
+        preOrder(root: root)
+
+        print("\nВсе пути от корня к узлу 7")
+        for path in res {
+            var vals: [Int] = []
+            for node in path {
+                vals.append(node.val)
+            }
+            print(vals)
+        }
+    }
+}

ru/codes/swift/chapter_backtracking/preorder_traversal_iii_compact.swift

@@ -0,0 +1,52 @@
+/**
+ * File: preorder_traversal_iii_compact.swift
+ * Created Time: 2023-04-30
+ * Author: nuomi1 (nuomi1@qq.com)
+ */
+
+import utils
+
+var path: [TreeNode] = []
+var res: [[TreeNode]] = []
+
+/* Предварительный обход: пример 3 */
+func preOrder(root: TreeNode?) {
+    // Отсечение
+    guard let root = root, root.val != 3 else {
+        return
+    }
+    // Попытка
+    path.append(root)
+    if root.val == 7 {
+        // Записать решение
+        res.append(path)
+    }
+    preOrder(root: root.left)
+    preOrder(root: root.right)
+    // Откат
+    path.removeLast()
+}
+
+@main
+enum PreorderTraversalIIICompact {
+    /* Driver Code */
+    static func main() {
+        let root = TreeNode.listToTree(arr: [1, 7, 3, 4, 5, 6, 7])
+        print("\nИнициализация двоичного дерева")
+        PrintUtil.printTree(root: root)
+
+        // Предварительный обход
+        path = []
+        res = []
+        preOrder(root: root)
+
+        print("\nВсе пути от корня к узлу 7, не содержащие узлов со значением 3")
+        for path in res {
+            var vals: [Int] = []
+            for node in path {
+                vals.append(node.val)
+            }
+            print(vals)
+        }
+    }
+}

ru/codes/swift/chapter_backtracking/preorder_traversal_iii_template.swift

@@ -0,0 +1,76 @@
+/**
+ * File: preorder_traversal_iii_template.swift
+ * Created Time: 2023-04-30
+ * Author: nuomi1 (nuomi1@qq.com)
+ */
+
+import utils
+
+/* Проверить, является ли текущее состояние решением */
+func isSolution(state: [TreeNode]) -> Bool {
+    !state.isEmpty && state.last!.val == 7
+}
+
+/* Записать решение */
+func recordSolution(state: [TreeNode], res: inout [[TreeNode]]) {
+    res.append(state)
+}
+
+/* Проверить, допустим ли этот выбор в текущем состоянии */
+func isValid(state: [TreeNode], choice: TreeNode?) -> Bool {
+    choice != nil && choice!.val != 3
+}
+
+/* Обновить состояние */
+func makeChoice(state: inout [TreeNode], choice: TreeNode) {
+    state.append(choice)
+}
+
+/* Восстановить состояние */
+func undoChoice(state: inout [TreeNode], choice: TreeNode) {
+    state.removeLast()
+}
+
+/* Алгоритм бэктрекинга: пример 3 */
+func backtrack(state: inout [TreeNode], choices: [TreeNode], res: inout [[TreeNode]]) {
+    // Проверить, является ли текущее состояние решением
+    if isSolution(state: state) {
+        recordSolution(state: state, res: &res)
+    }
+    // Перебор всех вариантов выбора
+    for choice in choices {
+        // Отсечение: проверить допустимость выбора
+        if isValid(state: state, choice: choice) {
+            // Попытка: сделать выбор и обновить состояние
+            makeChoice(state: &state, choice: choice)
+            // Перейти к следующему выбору
+            backtrack(state: &state, choices: [choice.left, choice.right].compactMap { $0 }, res: &res)
+            // Откат: отменить выбор и восстановить предыдущее состояние
+            undoChoice(state: &state, choice: choice)
+        }
+    }
+}
+
+@main
+enum PreorderTraversalIIITemplate {
+    /* Driver Code */
+    static func main() {
+        let root = TreeNode.listToTree(arr: [1, 7, 3, 4, 5, 6, 7])
+        print("\nИнициализация двоичного дерева")
+        PrintUtil.printTree(root: root)
+
+        // Алгоритм бэктрекинга
+        var state: [TreeNode] = []
+        var res: [[TreeNode]] = []
+        backtrack(state: &state, choices: [root].compactMap { $0 }, res: &res)
+
+        print("\nВсе пути от корня к узлу 7, не содержащие узлов со значением 3")
+        for path in res {
+            var vals: [Int] = []
+            for node in path {
+                vals.append(node.val)
+            }
+            print(vals)
+        }
+    }
+}

ru/codes/swift/chapter_backtracking/subset_sum_i.swift

@@ -0,0 +1,53 @@
+/**
+ * File: subset_sum_i.swift
+ * Created Time: 2023-07-02
+ * Author: nuomi1 (nuomi1@qq.com)
+ */
+
+/* Алгоритм бэктрекинга: сумма подмножеств I */
+func backtrack(state: inout [Int], target: Int, choices: [Int], start: Int, res: inout [[Int]]) {
+    // Если сумма подмножества равна target, записать решение
+    if target == 0 {
+        res.append(state)
+        return
+    }
+    // Обойти все варианты выбора
+    // Отсечение 2: начинать обход с start, чтобы избежать генерации повторяющихся подмножеств
+    for i in choices.indices.dropFirst(start) {
+        // Отсечение 1: если сумма подмножества превышает target, немедленно завершить цикл
+        // Это связано с тем, что массив уже отсортирован, следующие элементы больше, и сумма подмножества точно превысит target
+        if target - choices[i] < 0 {
+            break
+        }
+        // Попытка: сделать выбор и обновить target и start
+        state.append(choices[i])
+        // Перейти к следующему выбору
+        backtrack(state: &state, target: target - choices[i], choices: choices, start: i, res: &res)
+        // Откат: отменить выбор и восстановить предыдущее состояние
+        state.removeLast()
+    }
+}
+
+/* Решить задачу суммы подмножеств I */
+func subsetSumI(nums: [Int], target: Int) -> [[Int]] {
+    var state: [Int] = [] // Состояние (подмножество)
+    let nums = nums.sorted() // Отсортировать nums
+    let start = 0 // Стартовая вершина обхода
+    var res: [[Int]] = [] // Список результатов (список подмножеств)
+    backtrack(state: &state, target: target, choices: nums, start: start, res: &res)
+    return res
+}
+
+@main
+enum SubsetSumI {
+    /* Driver Code */
+    static func main() {
+        let nums = [3, 4, 5]
+        let target = 9
+
+        let res = subsetSumI(nums: nums, target: target)
+
+        print("Входной массив nums = \(nums), target = \(target)")
+        print("Все подмножества с суммой \(target): res = \(res)")
+    }
+}

ru/codes/swift/chapter_backtracking/subset_sum_i_naive.swift

@@ -0,0 +1,51 @@
+/**
+ * File: subset_sum_i_naive.swift
+ * Created Time: 2023-07-02
+ * Author: nuomi1 (nuomi1@qq.com)
+ */
+
+/* Алгоритм бэктрекинга: сумма подмножеств I */
+func backtrack(state: inout [Int], target: Int, total: Int, choices: [Int], res: inout [[Int]]) {
+    // Если сумма подмножества равна target, записать решение
+    if total == target {
+        res.append(state)
+        return
+    }
+    // Перебор всех вариантов выбора
+    for i in choices.indices {
+        // Отсечение: если сумма подмножества превышает target, пропустить этот выбор
+        if total + choices[i] > target {
+            continue
+        }
+        // Попытка: сделать выбор и обновить элемент и total
+        state.append(choices[i])
+        // Перейти к следующему выбору
+        backtrack(state: &state, target: target, total: total + choices[i], choices: choices, res: &res)
+        // Откат: отменить выбор и восстановить предыдущее состояние
+        state.removeLast()
+    }
+}
+
+/* Решить задачу суммы подмножеств I (с повторяющимися подмножествами) */
+func subsetSumINaive(nums: [Int], target: Int) -> [[Int]] {
+    var state: [Int] = [] // Состояние (подмножество)
+    let total = 0 // Сумма подмножеств
+    var res: [[Int]] = [] // Список результатов (список подмножеств)
+    backtrack(state: &state, target: target, total: total, choices: nums, res: &res)
+    return res
+}
+
+@main
+enum SubsetSumINaive {
+    /* Driver Code */
+    static func main() {
+        let nums = [3, 4, 5]
+        let target = 9
+
+        let res = subsetSumINaive(nums: nums, target: target)
+
+        print("Входной массив nums = \(nums), target = \(target)")
+        print("Все подмножества с суммой \(target): res = \(res)")
+        print("Обратите внимание: результат этого метода содержит повторяющиеся множества")
+    }
+}

ru/codes/swift/chapter_backtracking/subset_sum_ii.swift

@@ -0,0 +1,58 @@
+/**
+ * File: subset_sum_ii.swift
+ * Created Time: 2023-07-02
+ * Author: nuomi1 (nuomi1@qq.com)
+ */
+
+/* Алгоритм бэктрекинга: сумма подмножеств II */
+func backtrack(state: inout [Int], target: Int, choices: [Int], start: Int, res: inout [[Int]]) {
+    // Если сумма подмножества равна target, записать решение
+    if target == 0 {
+        res.append(state)
+        return
+    }
+    // Обойти все варианты выбора
+    // Отсечение 2: начинать обход с start, чтобы избежать генерации повторяющихся подмножеств
+    // Отсечение 3: начинать обход с start, чтобы избежать повторного выбора одного и того же элемента
+    for i in choices.indices.dropFirst(start) {
+        // Отсечение 1: если сумма подмножества превышает target, немедленно завершить цикл
+        // Это связано с тем, что массив уже отсортирован, следующие элементы больше, и сумма подмножества точно превысит target
+        if target - choices[i] < 0 {
+            break
+        }
+        // Отсечение 4: если этот элемент равен элементу слева, значит ветвь поиска повторяется, ее нужно сразу пропустить
+        if i > start, choices[i] == choices[i - 1] {
+            continue
+        }
+        // Попытка: сделать выбор и обновить target и start
+        state.append(choices[i])
+        // Перейти к следующему выбору
+        backtrack(state: &state, target: target - choices[i], choices: choices, start: i + 1, res: &res)
+        // Откат: отменить выбор и восстановить предыдущее состояние
+        state.removeLast()
+    }
+}
+
+/* Решить задачу суммы подмножеств II */
+func subsetSumII(nums: [Int], target: Int) -> [[Int]] {
+    var state: [Int] = [] // Состояние (подмножество)
+    let nums = nums.sorted() // Отсортировать nums
+    let start = 0 // Стартовая вершина обхода
+    var res: [[Int]] = [] // Список результатов (список подмножеств)
+    backtrack(state: &state, target: target, choices: nums, start: start, res: &res)
+    return res
+}
+
+@main
+enum SubsetSumII {
+    /* Driver Code */
+    static func main() {
+        let nums = [4, 4, 5]
+        let target = 9
+
+        let res = subsetSumII(nums: nums, target: target)
+
+        print("Входной массив nums = \(nums), target = \(target)")
+        print("Все подмножества с суммой \(target): res = \(res)")
+    }
+}