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

@@ -0,0 +1,55 @@
+/**
+ * File: n_queens.js
+ * Created Time: 2023-05-13
+ * Author: Justin (xiefahit@gmail.com)
+ */
+
+/* Алгоритм бэктрекинга: n ферзей */
+function backtrack(row, n, state, res, cols, diags1, diags2) {
+    // Когда все строки уже обработаны, записать решение
+    if (row === n) {
+        res.push(state.map((row) => row.slice()));
+        return;
+    }
+    // Обойти все столбцы
+    for (let col = 0; col < n; col++) {
+        // Вычислить главную и побочную диагонали, соответствующие этой клетке
+        const diag1 = row - col + n - 1;
+        const 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;
+        }
+    }
+}
+
+/* Решить задачу о n ферзях */
+function nQueens(n) {
+    // Инициализировать доску размера n*n, где 'Q' обозначает ферзя, а '#' — пустую клетку
+    const state = Array.from({ length: n }, () => Array(n).fill('#'));
+    const cols = Array(n).fill(false); // Отмечать, есть ли ферзь в столбце
+    const diags1 = Array(2 * n - 1).fill(false); // Отмечать наличие ферзя на главной диагонали
+    const diags2 = Array(2 * n - 1).fill(false); // Отмечать наличие ферзя на побочной диагонали
+    const res = [];
+
+    backtrack(0, n, state, res, cols, diags1, diags2);
+    return res;
+}
+
+// Driver Code
+const n = 4;
+const res = nQueens(n);
+
+console.log(`Размер входной доски = ${n}`);
+console.log(`Количество способов расстановки ферзей: ${res.length}`);
+res.forEach((state) => {
+    console.log('--------------------');
+    state.forEach((row) => console.log(row));
+});

ru/codes/javascript/chapter_backtracking/permutations_i.js

@@ -0,0 +1,42 @@
+/**
+ * File: permutations_i.js
+ * Created Time: 2023-05-13
+ * Author: Justin (xiefahit@gmail.com)
+ */
+
+/* Алгоритм бэктрекинга: все перестановки I */
+function backtrack(state, choices, selected, res) {
+    // Когда длина состояния равна числу элементов, записать решение
+    if (state.length === choices.length) {
+        res.push([...state]);
+        return;
+    }
+    // Перебор всех вариантов выбора
+    choices.forEach((choice, i) => {
+        // Отсечение: нельзя выбирать один и тот же элемент повторно
+        if (!selected[i]) {
+            // Попытка: сделать выбор и обновить состояние
+            selected[i] = true;
+            state.push(choice);
+            // Перейти к следующему выбору
+            backtrack(state, choices, selected, res);
+            // Откат: отменить выбор и восстановить предыдущее состояние
+            selected[i] = false;
+            state.pop();
+        }
+    });
+}
+
+/* Все перестановки I */
+function permutationsI(nums) {
+    const res = [];
+    backtrack([], nums, Array(nums.length).fill(false), res);
+    return res;
+}
+
+// Driver Code
+const nums = [1, 2, 3];
+const res = permutationsI(nums);
+
+console.log(`Входной массив nums = ${JSON.stringify(nums)}`);
+console.log(`Все перестановки res = ${JSON.stringify(res)}`);

ru/codes/javascript/chapter_backtracking/permutations_ii.js

@@ -0,0 +1,44 @@
+/**
+ * File: permutations_ii.js
+ * Created Time: 2023-05-13
+ * Author: Justin (xiefahit@gmail.com)
+ */
+
+/* Алгоритм бэктрекинга: все перестановки II */
+function backtrack(state, choices, selected, res) {
+    // Когда длина состояния равна числу элементов, записать решение
+    if (state.length === choices.length) {
+        res.push([...state]);
+        return;
+    }
+    // Перебор всех вариантов выбора
+    const duplicated = new Set();
+    choices.forEach((choice, i) => {
+        // Отсечение: нельзя выбирать один и тот же элемент повторно и нельзя повторно выбирать равные элементы
+        if (!selected[i] && !duplicated.has(choice)) {
+            // Попытка: сделать выбор и обновить состояние
+            duplicated.add(choice); // Записать значения уже выбранных элементов
+            selected[i] = true;
+            state.push(choice);
+            // Перейти к следующему выбору
+            backtrack(state, choices, selected, res);
+            // Откат: отменить выбор и восстановить предыдущее состояние
+            selected[i] = false;
+            state.pop();
+        }
+    });
+}
+
+/* Все перестановки II */
+function permutationsII(nums) {
+    const res = [];
+    backtrack([], nums, Array(nums.length).fill(false), res);
+    return res;
+}
+
+// Driver Code
+const nums = [1, 2, 2];
+const res = permutationsII(nums);
+
+console.log(`Входной массив nums = ${JSON.stringify(nums)}`);
+console.log(`Все перестановки res = ${JSON.stringify(res)}`);

ru/codes/javascript/chapter_backtracking/preorder_traversal_i_compact.js

@@ -0,0 +1,33 @@
+/**
+ * File: preorder_traversal_i_compact.js
+ * Created Time: 2023-05-09
+ * Author: Justin (xiefahit@gmail.com)
+ */
+
+const { arrToTree } = require('../modules/TreeNode');
+const { printTree } = require('../modules/PrintUtil');
+
+/* Предварительный обход: пример 1 */
+function preOrder(root, res) {
+    if (root === null) {
+        return;
+    }
+    if (root.val === 7) {
+        // Записать решение
+        res.push(root);
+    }
+    preOrder(root.left, res);
+    preOrder(root.right, res);
+}
+
+// Driver Code
+const root = arrToTree([1, 7, 3, 4, 5, 6, 7]);
+console.log('\nИнициализация двоичного дерева');
+printTree(root);
+
+// Предварительный обход
+const res = [];
+preOrder(root, res);
+
+console.log('\nВсе узлы со значением 7');
+console.log(res.map((node) => node.val));

ru/codes/javascript/chapter_backtracking/preorder_traversal_ii_compact.js

@@ -0,0 +1,40 @@
+/**
+ * File: preorder_traversal_ii_compact.js
+ * Created Time: 2023-05-09
+ * Author: Justin (xiefahit@gmail.com)
+ */
+
+const { arrToTree } = require('../modules/TreeNode');
+const { printTree } = require('../modules/PrintUtil');
+
+/* Предварительный обход: пример 2 */
+function preOrder(root, path, res) {
+    if (root === null) {
+        return;
+    }
+    // Попытка
+    path.push(root);
+    if (root.val === 7) {
+        // Записать решение
+        res.push([...path]);
+    }
+    preOrder(root.left, path, res);
+    preOrder(root.right, path, res);
+    // Откат
+    path.pop();
+}
+
+// Driver Code
+const root = arrToTree([1, 7, 3, 4, 5, 6, 7]);
+console.log('\nИнициализация двоичного дерева');
+printTree(root);
+
+// Предварительный обход
+const path = [];
+const res = [];
+preOrder(root, path, res);
+
+console.log('\nВсе пути от корня к узлу 7');
+res.forEach((path) => {
+    console.log(path.map((node) => node.val));
+});

ru/codes/javascript/chapter_backtracking/preorder_traversal_iii_compact.js

@@ -0,0 +1,41 @@
+/**
+ * File: preorder_traversal_iii_compact.js
+ * Created Time: 2023-05-09
+ * Author: Justin (xiefahit@gmail.com)
+ */
+
+const { arrToTree } = require('../modules/TreeNode');
+const { printTree } = require('../modules/PrintUtil');
+
+/* Предварительный обход: пример 3 */
+function preOrder(root, path, res) {
+    // Отсечение
+    if (root === null || root.val === 3) {
+        return;
+    }
+    // Попытка
+    path.push(root);
+    if (root.val === 7) {
+        // Записать решение
+        res.push([...path]);
+    }
+    preOrder(root.left, path, res);
+    preOrder(root.right, path, res);
+    // Откат
+    path.pop();
+}
+
+// Driver Code
+const root = arrToTree([1, 7, 3, 4, 5, 6, 7]);
+console.log('\nИнициализация двоичного дерева');
+printTree(root);
+
+// Предварительный обход
+const path = [];
+const res = [];
+preOrder(root, path, res);
+
+console.log('\nВсе пути от корня к узлу 7, не содержащие узлов со значением 3');
+res.forEach((path) => {
+    console.log(path.map((node) => node.val));
+});

ru/codes/javascript/chapter_backtracking/preorder_traversal_iii_template.js

@@ -0,0 +1,68 @@
+/**
+ * File: preorder_traversal_iii_template.js
+ * Created Time: 2023-05-09
+ * Author: Justin (xiefahit@gmail.com)
+ */
+
+const { arrToTree } = require('../modules/TreeNode');
+const { printTree } = require('../modules/PrintUtil');
+
+/* Проверить, является ли текущее состояние решением */
+function isSolution(state) {
+    return state && state[state.length - 1]?.val === 7;
+}
+
+/* Записать решение */
+function recordSolution(state, res) {
+    res.push([...state]);
+}
+
+/* Проверить, допустим ли этот выбор в текущем состоянии */
+function isValid(state, choice) {
+    return choice !== null && choice.val !== 3;
+}
+
+/* Обновить состояние */
+function makeChoice(state, choice) {
+    state.push(choice);
+}
+
+/* Восстановить состояние */
+function undoChoice(state) {
+    state.pop();
+}
+
+/* Алгоритм бэктрекинга: пример 3 */
+function backtrack(state, choices, res) {
+    // Проверить, является ли текущее состояние решением
+    if (isSolution(state)) {
+        // Записать решение
+        recordSolution(state, res);
+    }
+    // Перебор всех вариантов выбора
+    for (const choice of choices) {
+        // Отсечение: проверить допустимость выбора
+        if (isValid(state, choice)) {
+            // Попытка: сделать выбор и обновить состояние
+            makeChoice(state, choice);
+            // Перейти к следующему выбору
+            backtrack(state, [choice.left, choice.right], res);
+            // Откат: отменить выбор и восстановить предыдущее состояние
+            undoChoice(state);
+        }
+    }
+}
+
+// Driver Code
+const root = arrToTree([1, 7, 3, 4, 5, 6, 7]);
+console.log('\nИнициализация двоичного дерева');
+printTree(root);
+
+// Алгоритм бэктрекинга
+const res = [];
+backtrack([], [root], res);
+
+console.log('\nВсе пути от корня к узлу 7, в которых путь не содержит узлов со значением 3');
+res.forEach((path) => {
+    console.log(path.map((node) => node.val));
+});

ru/codes/javascript/chapter_backtracking/subset_sum_i.js

@@ -0,0 +1,46 @@
+/**
+ * File: subset_sum_i.js
+ * Created Time: 2023-07-30
+ * Author: yuan0221 (yl1452491917@gmail.com)
+ */
+
+/* Алгоритм бэктрекинга: сумма подмножеств I */
+function backtrack(state, target, choices, start, res) {
+    // Если сумма подмножества равна target, записать решение
+    if (target === 0) {
+        res.push([...state]);
+        return;
+    }
+    // Обойти все варианты выбора
+    // Отсечение 2: начинать обход с start, чтобы избежать генерации повторяющихся подмножеств
+    for (let i = start; i < choices.length; i++) {
+        // Отсечение 1: если сумма подмножества превышает target, немедленно завершить цикл
+        // Это связано с тем, что массив уже отсортирован, следующие элементы больше, и сумма подмножества точно превысит target
+        if (target - choices[i] < 0) {
+            break;
+        }
+        // Попытка: сделать выбор и обновить target и start
+        state.push(choices[i]);
+        // Перейти к следующему выбору
+        backtrack(state, target - choices[i], choices, i, res);
+        // Откат: отменить выбор и восстановить предыдущее состояние
+        state.pop();
+    }
+}
+
+/* Решить задачу суммы подмножеств I */
+function subsetSumI(nums, target) {
+    const state = []; // Состояние (подмножество)
+    nums.sort((a, b) => a - b); // Отсортировать nums
+    const start = 0; // Стартовая вершина обхода
+    const res = []; // Список результатов (список подмножеств)
+    backtrack(state, target, nums, start, res);
+    return res;
+}
+
+/* Driver Code */
+const nums = [3, 4, 5];
+const target = 9;
+const res = subsetSumI(nums, target);
+console.log(`Входной массив nums = ${JSON.stringify(nums)}, target = ${target}`);
+console.log(`Все подмножества с суммой ${target}: res = ${JSON.stringify(res)}`);

ru/codes/javascript/chapter_backtracking/subset_sum_i_naive.js

@@ -0,0 +1,44 @@
+/**
+ * File: subset_sum_i_naive.js
+ * Created Time: 2023-07-30
+ * Author: yuan0221 (yl1452491917@gmail.com)
+ */
+
+/* Алгоритм бэктрекинга: сумма подмножеств I */
+function backtrack(state, target, total, choices, res) {
+    // Если сумма подмножества равна target, записать решение
+    if (total === target) {
+        res.push([...state]);
+        return;
+    }
+    // Перебор всех вариантов выбора
+    for (let i = 0; i < choices.length; i++) {
+        // Отсечение: если сумма подмножества превышает target, пропустить этот выбор
+        if (total + choices[i] > target) {
+            continue;
+        }
+        // Попытка: сделать выбор и обновить элемент и total
+        state.push(choices[i]);
+        // Перейти к следующему выбору
+        backtrack(state, target, total + choices[i], choices, res);
+        // Откат: отменить выбор и восстановить предыдущее состояние
+        state.pop();
+    }
+}
+
+/* Решить задачу суммы подмножеств I (с повторяющимися подмножествами) */
+function subsetSumINaive(nums, target) {
+    const state = []; // Состояние (подмножество)
+    const total = 0; // Сумма подмножеств
+    const res = []; // Список результатов (список подмножеств)
+    backtrack(state, target, total, nums, res);
+    return res;
+}
+
+/* Driver Code */
+const nums = [3, 4, 5];
+const target = 9;
+const res = subsetSumINaive(nums, target);
+console.log(`Входной массив nums = ${JSON.stringify(nums)}, target = ${target}`);
+console.log(`Все подмножества с суммой ${target}: res = ${JSON.stringify(res)}`);
+console.log('Обратите внимание: результат этого метода содержит повторяющиеся множества');

ru/codes/javascript/chapter_backtracking/subset_sum_ii.js

@@ -0,0 +1,51 @@
+/**
+ * File: subset_sum_ii.js
+ * Created Time: 2023-07-30
+ * Author: yuan0221 (yl1452491917@gmail.com)
+ */
+
+/* Алгоритм бэктрекинга: сумма подмножеств II */
+function backtrack(state, target, choices, start, res) {
+    // Если сумма подмножества равна target, записать решение
+    if (target === 0) {
+        res.push([...state]);
+        return;
+    }
+    // Обойти все варианты выбора
+    // Отсечение 2: начинать обход с start, чтобы избежать генерации повторяющихся подмножеств
+    // Отсечение 3: начинать обход с start, чтобы избежать повторного выбора одного и того же элемента
+    for (let i = start; i < choices.length; i++) {
+        // Отсечение 1: если сумма подмножества превышает target, немедленно завершить цикл
+        // Это связано с тем, что массив уже отсортирован, следующие элементы больше, и сумма подмножества точно превысит target
+        if (target - choices[i] < 0) {
+            break;
+        }
+        // Отсечение 4: если этот элемент равен элементу слева, значит ветвь поиска повторяется, ее нужно сразу пропустить
+        if (i > start && choices[i] === choices[i - 1]) {
+            continue;
+        }
+        // Попытка: сделать выбор и обновить target и start
+        state.push(choices[i]);
+        // Перейти к следующему выбору
+        backtrack(state, target - choices[i], choices, i + 1, res);
+        // Откат: отменить выбор и восстановить предыдущее состояние
+        state.pop();
+    }
+}
+
+/* Решить задачу суммы подмножеств II */
+function subsetSumII(nums, target) {
+    const state = []; // Состояние (подмножество)
+    nums.sort((a, b) => a - b); // Отсортировать nums
+    const start = 0; // Стартовая вершина обхода
+    const res = []; // Список результатов (список подмножеств)
+    backtrack(state, target, nums, start, res);
+    return res;
+}
+
+/* Driver Code */
+const nums = [4, 4, 5];
+const target = 9;
+const res = subsetSumII(nums, target);
+console.log(`Входной массив nums = ${JSON.stringify(nums)}, target = ${target}`);
+console.log(`Все подмножества с суммой ${target}: res = ${JSON.stringify(res)}`);