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/cpp/chapter_computational_complexity/CMakeLists.txt

@@ -0,0 +1,5 @@
+add_executable(iteration iteration.cpp)
+add_executable(recursion recursion.cpp)
+add_executable(space_complexity space_complexity.cpp)
+add_executable(time_complexity time_complexity.cpp)
+add_executable(worst_best_time_complexity worst_best_time_complexity.cpp)

ru/codes/cpp/chapter_computational_complexity/iteration.cpp

@@ -0,0 +1,76 @@
+/**
+ * File: iteration.cpp
+ * Created Time: 2023-08-24
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* Цикл for */
+int forLoop(int n) {
+    int res = 0;
+    // Циклическое суммирование 1, 2, ..., n-1, n
+    for (int i = 1; i <= n; ++i) {
+        res += i;
+    }
+    return res;
+}
+
+/* Цикл while */
+int whileLoop(int n) {
+    int res = 0;
+    int i = 1; // Инициализация условной переменной
+    // Циклическое суммирование 1, 2, ..., n-1, n
+    while (i <= n) {
+        res += i;
+        i++; // Обновить условную переменную
+    }
+    return res;
+}
+
+/* Цикл while (двойное обновление) */
+int whileLoopII(int n) {
+    int res = 0;
+    int i = 1; // Инициализация условной переменной
+    // Циклическое суммирование 1, 4, 10, ...
+    while (i <= n) {
+        res += i;
+        // Обновить условную переменную
+        i++;
+        i *= 2;
+    }
+    return res;
+}
+
+/* Двойной цикл for */
+string nestedForLoop(int n) {
+    ostringstream res;
+    // Цикл по i = 1, 2, ..., n-1, n
+    for (int i = 1; i <= n; ++i) {
+        // Цикл по j = 1, 2, ..., n-1, n
+        for (int j = 1; j <= n; ++j) {
+            res << "(" << i << ", " << j << "), ";
+        }
+    }
+    return res.str();
+}
+
+/* Driver Code */
+int main() {
+    int n = 5;
+    int res;
+
+    res = forLoop(n);
+    cout << "\nРезультат суммирования в цикле for res = " << res << endl;
+
+    res = whileLoop(n);
+    cout << "\nРезультат суммирования в цикле while res = " << res << endl;
+
+    res = whileLoopII(n);
+    cout << "\nРезультат суммирования в цикле while (двойное обновление) res = " << res << endl;
+
+    string resStr = nestedForLoop(n);
+    cout << "\nРезультат двойного цикла for " << resStr << endl;
+
+    return 0;
+}

ru/codes/cpp/chapter_computational_complexity/recursion.cpp

@@ -0,0 +1,78 @@
+/**
+ * File: recursion.cpp
+ * Created Time: 2023-08-24
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* Рекурсия */
+int recur(int n) {
+    // Условие завершения
+    if (n == 1)
+        return 1;
+    // Рекурсия: рекурсивный вызов
+    int res = recur(n - 1);
+    // Возврат: вернуть результат
+    return n + res;
+}
+
+/* Имитация рекурсии итерацией */
+int forLoopRecur(int n) {
+    // Использовать явный стек для имитации системного стека вызовов
+    stack<int> stack;
+    int res = 0;
+    // Рекурсия: рекурсивный вызов
+    for (int i = n; i > 0; i--) {
+        // Имитировать «рекурсию» с помощью операции помещения в стек
+        stack.push(i);
+    }
+    // Возврат: вернуть результат
+    while (!stack.empty()) {
+        // Имитировать «возврат» с помощью операции извлечения из стека
+        res += stack.top();
+        stack.pop();
+    }
+    // res = 1+2+3+...+n
+    return res;
+}
+
+/* Хвостовая рекурсия */
+int tailRecur(int n, int res) {
+    // Условие завершения
+    if (n == 0)
+        return res;
+    // Хвостовой рекурсивный вызов
+    return tailRecur(n - 1, res + n);
+}
+
+/* Последовательность Фибоначчи: рекурсия */
+int fib(int n) {
+    // Условие завершения: f(1) = 0, f(2) = 1
+    if (n == 1 || n == 2)
+        return n - 1;
+    // Рекурсивный вызов f(n) = f(n-1) + f(n-2)
+    int res = fib(n - 1) + fib(n - 2);
+    // Вернуть результат f(n)
+    return res;
+}
+
+/* Driver Code */
+int main() {
+    int n = 5;
+    int res;
+
+    res = recur(n);
+    cout << "\nРезультат суммирования в рекурсивной функции res = " << res << endl;
+
+    res = forLoopRecur(n);
+    cout << "\nРезультат суммирования с использованием итерации для имитации рекурсии res = " << res << endl;
+
+    res = tailRecur(n, 0);
+    cout << "\nРезультат суммирования в хвостовой рекурсии res = " << res << endl;
+
+    res = fib(n);
+    cout << "\nЭлемент последовательности Фибоначчи с индексом " << n << " = " << res << endl;
+
+    return 0;
+}

ru/codes/cpp/chapter_computational_complexity/space_complexity.cpp

@@ -0,0 +1,107 @@
+/**
+ * File: space_complexity.cpp
+ * Created Time: 2022-11-25
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* Функция */
+int func() {
+    // Выполнить некоторые операции
+    return 0;
+}
+
+/* Постоянная сложность */
+void constant(int n) {
+    // Константы, переменные и объекты занимают O(1) памяти
+    const int a = 0;
+    int b = 0;
+    vector<int> nums(10000);
+    ListNode node(0);
+    // Переменные в цикле занимают O(1) памяти
+    for (int i = 0; i < n; i++) {
+        int c = 0;
+    }
+    // Функции в цикле занимают O(1) памяти
+    for (int i = 0; i < n; i++) {
+        func();
+    }
+}
+
+/* Линейная сложность */
+void linear(int n) {
+    // Массив длины n занимает O(n) памяти
+    vector<int> nums(n);
+    // Список длины n занимает O(n) памяти
+    vector<ListNode> nodes;
+    for (int i = 0; i < n; i++) {
+        nodes.push_back(ListNode(i));
+    }
+    // Хеш-таблица длины n занимает O(n) памяти
+    unordered_map<int, string> map;
+    for (int i = 0; i < n; i++) {
+        map[i] = to_string(i);
+    }
+}
+
+/* Линейная сложность (рекурсивная реализация) */
+void linearRecur(int n) {
+    cout << "Рекурсия n = " << n << endl;
+    if (n == 1)
+        return;
+    linearRecur(n - 1);
+}
+
+/* Квадратичная сложность */
+void quadratic(int n) {
+    // Двумерный список занимает O(n^2) памяти
+    vector<vector<int>> numMatrix;
+    for (int i = 0; i < n; i++) {
+        vector<int> tmp;
+        for (int j = 0; j < n; j++) {
+            tmp.push_back(0);
+        }
+        numMatrix.push_back(tmp);
+    }
+}
+
+/* Квадратичная сложность (рекурсивная реализация) */
+int quadraticRecur(int n) {
+    if (n <= 0)
+        return 0;
+    vector<int> nums(n);
+    cout << "Рекурсия n = " << n << " , длина nums = " << nums.size() << endl;
+    return quadraticRecur(n - 1);
+}
+
+/* Экспоненциальная сложность (построение полного двоичного дерева) */
+TreeNode *buildTree(int n) {
+    if (n == 0)
+        return nullptr;
+    TreeNode *root = new TreeNode(0);
+    root->left = buildTree(n - 1);
+    root->right = buildTree(n - 1);
+    return root;
+}
+
+/* Driver Code */
+int main() {
+    int n = 5;
+    // Постоянная сложность
+    constant(n);
+    // Линейная сложность
+    linear(n);
+    linearRecur(n);
+    // Квадратичная сложность
+    quadratic(n);
+    quadraticRecur(n);
+    // Экспоненциальная сложность
+    TreeNode *root = buildTree(n);
+    printTree(root);
+
+    // Освободить память
+    freeMemoryTree(root);
+
+    return 0;
+}

ru/codes/cpp/chapter_computational_complexity/time_complexity.cpp

@@ -0,0 +1,168 @@
+/**
+ * File: time_complexity.cpp
+ * Created Time: 2022-11-25
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* Постоянная сложность */
+int constant(int n) {
+    int count = 0;
+    int size = 100000;
+    for (int i = 0; i < size; i++)
+        count++;
+    return count;
+}
+
+/* Линейная сложность */
+int linear(int n) {
+    int count = 0;
+    for (int i = 0; i < n; i++)
+        count++;
+    return count;
+}
+
+/* Линейная сложность (обход массива) */
+int arrayTraversal(vector<int> &nums) {
+    int count = 0;
+    // Число итераций пропорционально длине массива
+    for (int num : nums) {
+        count++;
+    }
+    return count;
+}
+
+/* Квадратичная сложность */
+int quadratic(int n) {
+    int count = 0;
+    // Число итераций квадратично зависит от размера данных n
+    for (int i = 0; i < n; i++) {
+        for (int j = 0; j < n; j++) {
+            count++;
+        }
+    }
+    return count;
+}
+
+/* Квадратичная сложность (пузырьковая сортировка) */
+int bubbleSort(vector<int> &nums) {
+    int count = 0; // Счетчик
+    // Внешний цикл: неотсортированный диапазон [0, i]
+    for (int i = nums.size() - 1; i > 0; i--) {
+        // Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец
+        for (int j = 0; j < i; j++) {
+            if (nums[j] > nums[j + 1]) {
+                // Поменять местами nums[j] и nums[j + 1]
+                int tmp = nums[j];
+                nums[j] = nums[j + 1];
+                nums[j + 1] = tmp;
+                count += 3; // Обмен элементов включает 3 элементарные операции
+            }
+        }
+    }
+    return count;
+}
+
+/* Экспоненциальная сложность (итеративная реализация) */
+int exponential(int n) {
+    int count = 0, base = 1;
+    // На каждом шаге клетка делится надвое, образуя последовательность 1, 2, 4, 8, ..., 2^(n-1)
+    for (int i = 0; i < n; i++) {
+        for (int j = 0; j < base; j++) {
+            count++;
+        }
+        base *= 2;
+    }
+    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1
+    return count;
+}
+
+/* Экспоненциальная сложность (рекурсивная реализация) */
+int expRecur(int n) {
+    if (n == 1)
+        return 1;
+    return expRecur(n - 1) + expRecur(n - 1) + 1;
+}
+
+/* Логарифмическая сложность (итеративная реализация) */
+int logarithmic(int n) {
+    int count = 0;
+    while (n > 1) {
+        n = n / 2;
+        count++;
+    }
+    return count;
+}
+
+/* Логарифмическая сложность (рекурсивная реализация) */
+int logRecur(int n) {
+    if (n <= 1)
+        return 0;
+    return logRecur(n / 2) + 1;
+}
+
+/* Линейно-логарифмическая сложность */
+int linearLogRecur(int n) {
+    if (n <= 1)
+        return 1;
+    int count = linearLogRecur(n / 2) + linearLogRecur(n / 2);
+    for (int i = 0; i < n; i++) {
+        count++;
+    }
+    return count;
+}
+
+/* Факториальная сложность (рекурсивная реализация) */
+int factorialRecur(int n) {
+    if (n == 0)
+        return 1;
+    int count = 0;
+    // Из одного получается n
+    for (int i = 0; i < n; i++) {
+        count += factorialRecur(n - 1);
+    }
+    return count;
+}
+
+/* Driver Code */
+int main() {
+    // Можно изменить n и запустить программу, чтобы увидеть, как меняется число операций при разных сложностях
+    int n = 8;
+    cout << "Размер входных данных n = " << n << endl;
+
+    int count = constant(n);
+    cout << "Количество операций постоянной сложности = " << count << endl;
+
+    count = linear(n);
+    cout << "Количество операций линейной сложности = " << count << endl;
+    vector<int> arr(n);
+    count = arrayTraversal(arr);
+    cout << "Количество операций линейной сложности (обход массива) = " << count << endl;
+
+    count = quadratic(n);
+    cout << "Количество операций квадратичной сложности = " << count << endl;
+    vector<int> nums(n);
+    for (int i = 0; i < n; i++)
+        nums[i] = n - i; // [n,n-1,...,2,1]
+    count = bubbleSort(nums);
+    cout << "Количество операций квадратичной сложности (пузырьковая сортировка) = " << count << endl;
+
+    count = exponential(n);
+    cout << "Количество операций экспоненциальной сложности (итерация) = " << count << endl;
+    count = expRecur(n);
+    cout << "Количество операций экспоненциальной сложности (рекурсия) = " << count << endl;
+
+    count = logarithmic(n);
+    cout << "Количество операций логарифмической сложности (итерация) = " << count << endl;
+    count = logRecur(n);
+    cout << "Количество операций логарифмической сложности (рекурсия) = " << count << endl;
+
+    count = linearLogRecur(n);
+    cout << "Количество операций линейно-логарифмической сложности (рекурсия) = " << count << endl;
+
+    count = factorialRecur(n);
+    cout << "Количество операций факториальной сложности (рекурсия) = " << count << endl;
+
+    return 0;
+}

ru/codes/cpp/chapter_computational_complexity/worst_best_time_complexity.cpp

@@ -0,0 +1,45 @@
+/**
+ * File: worst_best_time_complexity.cpp
+ * Created Time: 2022-11-25
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* Создать массив с элементами { 1, 2, ..., n } в случайном порядке */
+vector<int> randomNumbers(int n) {
+    vector<int> nums(n);
+    // Создать массив nums = { 1, 2, 3, ..., n }
+    for (int i = 0; i < n; i++) {
+        nums[i] = i + 1;
+    }
+    // Использовать системное время для генерации случайного seed
+    unsigned seed = chrono::system_clock::now().time_since_epoch().count();
+    // Случайно перемешать элементы массива
+    shuffle(nums.begin(), nums.end(), default_random_engine(seed));
+    return nums;
+}
+
+/* Найти индекс числа 1 в массиве nums */
+int findOne(vector<int> &nums) {
+    for (int i = 0; i < nums.size(); i++) {
+        // Когда элемент 1 находится в начале массива, достигается лучшая временная сложность O(1)
+        // Когда элемент 1 находится в конце массива, достигается худшая временная сложность O(n)
+        if (nums[i] == 1)
+            return i;
+    }
+    return -1;
+}
+
+/* Driver Code */
+int main() {
+    for (int i = 0; i < 1000; i++) {
+        int n = 100;
+        vector<int> nums = randomNumbers(n);
+        int index = findOne(nums);
+        cout << "\nПосле перемешивания массива [ 1, 2, ..., n ] nums = ";
+        printVector(nums);
+        cout << "Индекс числа 1 = " << index << endl;
+    }
+    return 0;
+}