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_computational_complexity/iteration.swift

@@ -0,0 +1,75 @@
+/**
+ * File: iteration.swift
+ * Created Time: 2023-09-02
+ * Author: nuomi1 (nuomi1@qq.com)
+ */
+
+/* Цикл for */
+func forLoop(n: Int) -> Int {
+    var res = 0
+    // Циклическое суммирование 1, 2, ..., n-1, n
+    for i in 1 ... n {
+        res += i
+    }
+    return res
+}
+
+/* Цикл while */
+func whileLoop(n: Int) -> Int {
+    var res = 0
+    var i = 1 // Инициализация условной переменной
+    // Циклическое суммирование 1, 2, ..., n-1, n
+    while i <= n {
+        res += i
+        i += 1 // Обновить условную переменную
+    }
+    return res
+}
+
+/* Цикл while (двойное обновление) */
+func whileLoopII(n: Int) -> Int {
+    var res = 0
+    var i = 1 // Инициализация условной переменной
+    // Циклическое суммирование 1, 4, 10, ...
+    while i <= n {
+        res += i
+        // Обновить условную переменную
+        i += 1
+        i *= 2
+    }
+    return res
+}
+
+/* Двойной цикл for */
+func nestedForLoop(n: Int) -> String {
+    var res = ""
+    // Цикл по i = 1, 2, ..., n-1, n
+    for i in 1 ... n {
+        // Цикл по j = 1, 2, ..., n-1, n
+        for j in 1 ... n {
+            res.append("(\(i), \(j)), ")
+        }
+    }
+    return res
+}
+
+@main
+enum Iteration {
+    /* Driver Code */
+    static func main() {
+        let n = 5
+        var res = 0
+
+        res = forLoop(n: n)
+        print("\nРезультат суммирования в цикле for res = \(res)")
+
+        res = whileLoop(n: n)
+        print("\nРезультат суммирования в цикле while res = \(res)")
+
+        res = whileLoopII(n: n)
+        print("\nРезультат суммирования в цикле while (двойное обновление) res = \(res)")
+
+        let resStr = nestedForLoop(n: n)
+        print("\nРезультат обхода в двойном цикле for \(resStr)")
+    }
+}

ru/codes/swift/chapter_computational_complexity/recursion.swift

@@ -0,0 +1,79 @@
+/**
+ * File: recursion.swift
+ * Created Time: 2023-09-02
+ * Author: nuomi1 (nuomi1@qq.com)
+ */
+
+/* Рекурсия */
+func recur(n: Int) -> Int {
+    // Условие завершения
+    if n == 1 {
+        return 1
+    }
+    // Рекурсия: рекурсивный вызов
+    let res = recur(n: n - 1)
+    // Возврат: вернуть результат
+    return n + res
+}
+
+/* Имитация рекурсии итерацией */
+func forLoopRecur(n: Int) -> Int {
+    // Использовать явный стек для имитации системного стека вызовов
+    var stack: [Int] = []
+    var res = 0
+    // Рекурсия: рекурсивный вызов
+    for i in (1 ... n).reversed() {
+        // Имитировать «рекурсию» с помощью операции помещения в стек
+        stack.append(i)
+    }
+    // Возврат: вернуть результат
+    while !stack.isEmpty {
+        // Имитировать «возврат» с помощью операции извлечения из стека
+        res += stack.removeLast()
+    }
+    // res = 1+2+3+...+n
+    return res
+}
+
+/* Хвостовая рекурсия */
+func tailRecur(n: Int, res: Int) -> Int {
+    // Условие завершения
+    if n == 0 {
+        return res
+    }
+    // Хвостовой рекурсивный вызов
+    return tailRecur(n: n - 1, res: res + n)
+}
+
+/* Последовательность Фибоначчи: рекурсия */
+func fib(n: Int) -> Int {
+    // Условие завершения: f(1) = 0, f(2) = 1
+    if n == 1 || n == 2 {
+        return n - 1
+    }
+    // Рекурсивный вызов f(n) = f(n-1) + f(n-2)
+    let res = fib(n: n - 1) + fib(n: n - 2)
+    // Вернуть результат f(n)
+    return res
+}
+
+@main
+enum Recursion {
+    /* Driver Code */
+    static func main() {
+        let n = 5
+        var res = 0
+
+        res = recursion.recur(n: n)
+        print("\nРезультат суммирования в рекурсивной функции res = \(res)")
+
+        res = recursion.forLoopRecur(n: n)
+        print("\nРезультат суммирования при имитации рекурсии res = \(res)")
+
+        res = recursion.tailRecur(n: n, res: 0)
+        print("\nРезультат суммирования в хвостовой рекурсии res = \(res)")
+
+        res = recursion.fib(n: n)
+        print("\nЧлен последовательности Фибоначчи с номером \(n) = \(res)")
+    }
+}

ru/codes/swift/chapter_computational_complexity/space_complexity.swift

@@ -0,0 +1,98 @@
+/**
+ * File: space_complexity.swift
+ * Created Time: 2023-01-01
+ * Author: nuomi1 (nuomi1@qq.com)
+ */
+
+import utils
+
+/* Функция */
+@discardableResult
+func function() -> Int {
+    // Выполнить некоторые операции
+    return 0
+}
+
+/* Постоянная сложность */
+func constant(n: Int) {
+    // Константы, переменные и объекты занимают O(1) памяти
+    let a = 0
+    var b = 0
+    let nums = Array(repeating: 0, count: 10000)
+    let node = ListNode(x: 0)
+    // Переменные в цикле занимают O(1) памяти
+    for _ in 0 ..< n {
+        let c = 0
+    }
+    // Функции в цикле занимают O(1) памяти
+    for _ in 0 ..< n {
+        function()
+    }
+}
+
+/* Линейная сложность */
+func linear(n: Int) {
+    // Массив длины n занимает O(n) памяти
+    let nums = Array(repeating: 0, count: n)
+    // Список длины n занимает O(n) памяти
+    let nodes = (0 ..< n).map { ListNode(x: $0) }
+    // Хеш-таблица длины n занимает O(n) памяти
+    let map = Dictionary(uniqueKeysWithValues: (0 ..< n).map { ($0, "\($0)") })
+}
+
+/* Линейная сложность (рекурсивная реализация) */
+func linearRecur(n: Int) {
+    print("Рекурсия n = \(n)")
+    if n == 1 {
+        return
+    }
+    linearRecur(n: n - 1)
+}
+
+/* Квадратичная сложность */
+func quadratic(n: Int) {
+    // Двумерный список занимает O(n^2) памяти
+    let numList = Array(repeating: Array(repeating: 0, count: n), count: n)
+}
+
+/* Квадратичная сложность (рекурсивная реализация) */
+@discardableResult
+func quadraticRecur(n: Int) -> Int {
+    if n <= 0 {
+        return 0
+    }
+    // Длина массива nums равна n, n-1, ..., 2, 1
+    let nums = Array(repeating: 0, count: n)
+    print("В рекурсии n = \(n), длина nums = \(nums.count)")
+    return quadraticRecur(n: n - 1)
+}
+
+/* Экспоненциальная сложность (построение полного двоичного дерева) */
+func buildTree(n: Int) -> TreeNode? {
+    if n == 0 {
+        return nil
+    }
+    let root = TreeNode(x: 0)
+    root.left = buildTree(n: n - 1)
+    root.right = buildTree(n: n - 1)
+    return root
+}
+
+@main
+enum SpaceComplexity {
+    /* Driver Code */
+    static func main() {
+        let n = 5
+        // Постоянная сложность
+        constant(n: n)
+        // Линейная сложность
+        linear(n: n)
+        linearRecur(n: n)
+        // Квадратичная сложность
+        quadratic(n: n)
+        quadraticRecur(n: n)
+        // Экспоненциальная сложность
+        let root = buildTree(n: n)
+        PrintUtil.printTree(root: root)
+    }
+}

ru/codes/swift/chapter_computational_complexity/time_complexity.swift

@@ -0,0 +1,172 @@
+/**
+ * File: time_complexity.swift
+ * Created Time: 2022-12-26
+ * Author: nuomi1 (nuomi1@qq.com)
+ */
+
+/* Постоянная сложность */
+func constant(n: Int) -> Int {
+    var count = 0
+    let size = 100_000
+    for _ in 0 ..< size {
+        count += 1
+    }
+    return count
+}
+
+/* Линейная сложность */
+func linear(n: Int) -> Int {
+    var count = 0
+    for _ in 0 ..< n {
+        count += 1
+    }
+    return count
+}
+
+/* Линейная сложность (обход массива) */
+func arrayTraversal(nums: [Int]) -> Int {
+    var count = 0
+    // Число итераций пропорционально длине массива
+    for _ in nums {
+        count += 1
+    }
+    return count
+}
+
+/* Квадратичная сложность */
+func quadratic(n: Int) -> Int {
+    var count = 0
+    // Число итераций квадратично зависит от размера данных n
+    for _ in 0 ..< n {
+        for _ in 0 ..< n {
+            count += 1
+        }
+    }
+    return count
+}
+
+/* Квадратичная сложность (пузырьковая сортировка) */
+func bubbleSort(nums: inout [Int]) -> Int {
+    var count = 0 // Счетчик
+    // Внешний цикл: неотсортированный диапазон [0, i]
+    for i in nums.indices.dropFirst().reversed() {
+        // Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец
+        for j in 0 ..< i {
+            if nums[j] > nums[j + 1] {
+                // Поменять местами nums[j] и nums[j + 1]
+                let tmp = nums[j]
+                nums[j] = nums[j + 1]
+                nums[j + 1] = tmp
+                count += 3 // Обмен элементов включает 3 элементарные операции
+            }
+        }
+    }
+    return count
+}
+
+/* Экспоненциальная сложность (итеративная реализация) */
+func exponential(n: Int) -> Int {
+    var count = 0
+    var base = 1
+    // На каждом шаге клетка делится надвое, образуя последовательность 1, 2, 4, 8, ..., 2^(n-1)
+    for _ in 0 ..< n {
+        for _ in 0 ..< base {
+            count += 1
+        }
+        base *= 2
+    }
+    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1
+    return count
+}
+
+/* Экспоненциальная сложность (рекурсивная реализация) */
+func expRecur(n: Int) -> Int {
+    if n == 1 {
+        return 1
+    }
+    return expRecur(n: n - 1) + expRecur(n: n - 1) + 1
+}
+
+/* Логарифмическая сложность (итеративная реализация) */
+func logarithmic(n: Int) -> Int {
+    var count = 0
+    var n = n
+    while n > 1 {
+        n = n / 2
+        count += 1
+    }
+    return count
+}
+
+/* Логарифмическая сложность (рекурсивная реализация) */
+func logRecur(n: Int) -> Int {
+    if n <= 1 {
+        return 0
+    }
+    return logRecur(n: n / 2) + 1
+}
+
+/* Линейно-логарифмическая сложность */
+func linearLogRecur(n: Int) -> Int {
+    if n <= 1 {
+        return 1
+    }
+    var count = linearLogRecur(n: n / 2) + linearLogRecur(n: n / 2)
+    for _ in stride(from: 0, to: n, by: 1) {
+        count += 1
+    }
+    return count
+}
+
+/* Факториальная сложность (рекурсивная реализация) */
+func factorialRecur(n: Int) -> Int {
+    if n == 0 {
+        return 1
+    }
+    var count = 0
+    // Из одного получается n
+    for _ in 0 ..< n {
+        count += factorialRecur(n: n - 1)
+    }
+    return count
+}
+
+@main
+enum TimeComplexity {
+    /* Driver Code */
+    static func main() {
+        // Можно изменить n и запустить программу, чтобы увидеть, как меняется число операций при разных сложностях
+        let n = 8
+        print("Размер входных данных n = \(n)")
+
+        var count = constant(n: n)
+        print("Число операций константной сложности = \(count)")
+
+        count = linear(n: n)
+        print("Число операций линейной сложности = \(count)")
+        count = arrayTraversal(nums: Array(repeating: 0, count: n))
+        print("Число операций линейной сложности (обход массива) = \(count)")
+
+        count = quadratic(n: n)
+        print("Число операций квадратичной сложности = \(count)")
+        var nums = Array(stride(from: n, to: 0, by: -1)) // [n,n-1,...,2,1]
+        count = bubbleSort(nums: &nums)
+        print("Число операций квадратичной сложности (пузырьковая сортировка) = \(count)")
+
+        count = exponential(n: n)
+        print("Число операций экспоненциальной сложности (итеративная реализация) = \(count)")
+        count = expRecur(n: n)
+        print("Число операций экспоненциальной сложности (рекурсивная реализация) = \(count)")
+
+        count = logarithmic(n: n)
+        print("Число операций логарифмической сложности (итеративная реализация) = \(count)")
+        count = logRecur(n: n)
+        print("Число операций логарифмической сложности (рекурсивная реализация) = \(count)")
+
+        count = linearLogRecur(n: n)
+        print("Число операций линейно-логарифмической сложности (рекурсивная реализация) = \(count)")
+
+        count = factorialRecur(n: n)
+        print("Число операций факториальной сложности (рекурсивная реализация) = \(count)")
+    }
+}

ru/codes/swift/chapter_computational_complexity/worst_best_time_complexity.swift

@@ -0,0 +1,40 @@
+/**
+ * File: worst_best_time_complexity.swift
+ * Created Time: 2022-12-26
+ * Author: nuomi1 (nuomi1@qq.com)
+ */
+
+/* Создать массив с элементами { 1, 2, ..., n } в случайном порядке */
+func randomNumbers(n: Int) -> [Int] {
+    // Создать массив nums = { 1, 2, 3, ..., n }
+    var nums = Array(1 ... n)
+    // Случайно перемешать элементы массива
+    nums.shuffle()
+    return nums
+}
+
+/* Найти индекс числа 1 в массиве nums */
+func findOne(nums: [Int]) -> Int {
+    for i in nums.indices {
+        // Когда элемент 1 находится в начале массива, достигается лучшая временная сложность O(1)
+        // Когда элемент 1 находится в конце массива, достигается худшая временная сложность O(n)
+        if nums[i] == 1 {
+            return i
+        }
+    }
+    return -1
+}
+
+@main
+enum WorstBestTimeComplexity {
+    /* Driver Code */
+    static func main() {
+        for _ in 0 ..< 10 {
+            let n = 100
+            let nums = randomNumbers(n: n)
+            let index = findOne(nums: nums)
+            print("Массив [1, 2, ..., n] после перемешивания = \(nums)")
+            print("Индекс числа 1 = \(index)")
+        }
+    }
+}