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/zig/chapter_searching/binary_search.zig

@@ -0,0 +1,64 @@
+// File: binary_search.zig
+// Created Time: 2023-01-15
+// Author: codingonion (coderonion@gmail.com)
+
+const std = @import("std");
+const inc = @import("include");
+
+// Бинарный поиск (двусторонне замкнутый интервал)
+fn binarySearch(comptime T: type, nums: std.ArrayList(T), target: T) T {
+    // Инициализировать двусторонне замкнутый интервал [0, n-1], то есть i и j указывают на первый и последний элементы массива соответственно
+    var i: usize = 0;
+    var j: usize = nums.items.len - 1;
+    // Цикл завершается, когда диапазон поиска пуст (при i > j диапазон пуст)
+    while (i <= j) {
+        var m = i + (j - i) / 2;                // Вычислить индекс середины m
+        if (nums.items[m] < target) {           // Это означает, что target находится в интервале [m+1, j]
+            i = m + 1;
+        } else if (nums.items[m] > target) {    // Это означает, что target находится в интервале [i, m-1]
+            j = m - 1;
+        } else {                                // Целевой элемент найден, вернуть его индекс
+            return @intCast(m);
+        }
+    }
+    // Целевой элемент не найден, вернуть -1
+    return -1;
+}
+
+// Бинарный поиск (лево замкнутый, право открытый интервал)
+fn binarySearchLCRO(comptime T: type, nums: std.ArrayList(T), target: T) T {
+    // Инициализировать лево замкнутый, право открытый интервал [0, n), то есть i и j указывают на первый элемент массива и позицию сразу за последним элементом соответственно
+    var i: usize = 0;
+    var j: usize = nums.items.len;
+    // Цикл завершается, когда диапазон поиска пуст (при i = j диапазон пуст)
+    while (i <= j) {
+        var m = i + (j - i) / 2;                // Вычислить индекс середины m
+        if (nums.items[m] < target) {           // Это означает, что target находится в интервале [m+1, j)
+            i = m + 1;
+        } else if (nums.items[m] > target) {    // Это означает, что target находится в интервале [i, m)
+            j = m;
+        } else {                                // Целевой элемент найден, вернуть его индекс
+            return @intCast(m);
+        }
+    }
+    // Целевой элемент не найден, вернуть -1
+    return -1;
+}
+
+// Driver Code
+pub fn main() !void {
+    var target: i32 = 6;
+    var nums = std.ArrayList(i32).init(std.heap.page_allocator);
+    defer nums.deinit();
+    try nums.appendSlice(&[_]i32{ 1, 3, 6, 8, 12, 15, 23, 26, 31, 35 });
+
+    // Бинарный поиск (двусторонне замкнутый интервал)
+    var index = binarySearch(i32, nums, target);
+    std.debug.print("Индекс целевого элемента 6 = {}\n", .{index});
+
+    // Бинарный поиск (лево замкнутый, право открытый интервал)
+    index = binarySearchLCRO(i32, nums, target);
+    std.debug.print("Индекс целевого элемента 6 = {}\n", .{index});
+
+    _ = try std.io.getStdIn().reader().readByte();
+}

ru/codes/zig/chapter_searching/hashing_search.zig

@@ -0,0 +1,57 @@
+// File: hashing_search.zig
+// Created Time: 2023-01-15
+// Author: codingonion (coderonion@gmail.com)
+
+const std = @import("std");
+const inc = @import("include");
+
+// Хеш-поиск (массив)
+fn hashingSearchArray(comptime T: type, map: std.AutoHashMap(T, T), target: T) T {
+    // key хеш-таблицы: целевой элемент, value: индекс
+    // Если такого key нет в хеш-таблице, вернуть -1
+    if (map.getKey(target) == null) return -1;
+    return map.get(target).?;
+}
+
+// Хеш-поиск (связный список)
+fn hashingSearchLinkedList(comptime T: type, map: std.AutoHashMap(T, *inc.ListNode(T)), target: T) ?*inc.ListNode(T) {
+    // key хеш-таблицы: значение целевого узла, value: объект узла
+    // Если такого key нет в хеш-таблице, вернуть null
+    if (map.getKey(target) == null) return null;
+    return map.get(target);
+}
+
+// Driver Code
+pub fn main() !void {
+    var target: i32 = 3;
+
+    // Хеш-поиск (массив)
+    var nums = [_]i32{ 1, 5, 3, 2, 4, 7, 5, 9, 10, 8 };
+    // Инициализация хеш-таблицы
+    var map = std.AutoHashMap(i32, i32).init(std.heap.page_allocator);
+    defer map.deinit();
+    for (nums, 0..) |num, i| {
+        try map.put(num, @as(i32, @intCast(i)));    // key: элемент, value: индекс
+    }
+    var index = hashingSearchArray(i32, map, target);
+    std.debug.print("Индекс целевого элемента 3 = {}\n", .{index});
+
+    // Хеш-поиск (связный список)
+    var mem_arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
+    defer mem_arena.deinit();
+    const mem_allocator = mem_arena.allocator();
+    var head = try inc.ListUtil.arrToLinkedList(i32, mem_allocator, &nums);
+    // Инициализация хеш-таблицы
+    var map1 = std.AutoHashMap(i32, *inc.ListNode(i32)).init(std.heap.page_allocator);
+    defer map1.deinit();
+    while (head != null) {
+        try map1.put(head.?.val, head.?);
+        head = head.?.next;
+    }
+    var node = hashingSearchLinkedList(i32, map1, target);
+    std.debug.print("Объект узла со значением 3 = ", .{});
+    try inc.PrintUtil.printLinkedList(i32, node);
+
+    _ = try std.io.getStdIn().reader().readByte();
+}
+

ru/codes/zig/chapter_searching/linear_search.zig

@@ -0,0 +1,54 @@
+// File: linear_search.zig
+// Created Time: 2023-01-13
+// Author: codingonion (coderonion@gmail.com)
+
+const std = @import("std");
+const inc = @import("include");
+
+// Линейный поиск (массив)
+fn linearSearchArray(comptime T: type, nums: std.ArrayList(T), target: T) T {
+    // Обход массива
+    for (nums.items, 0..) |num, i| {
+        // Найти целевой элемент и вернуть его индекс
+        if (num == target) {
+            return @intCast(i);
+        }
+    }
+    // Целевой элемент не найден, вернуть -1
+    return -1;
+}
+
+// Линейный поиск (связный список)
+pub fn linearSearchLinkedList(comptime T: type, node: ?*inc.ListNode(T), target: T) ?*inc.ListNode(T) {
+    var head = node;
+    // Обойти связный список
+    while (head != null) {
+        // Найти целевой узел и вернуть его
+        if (head.?.val == target) return head;
+        head = head.?.next;
+    }
+    return null;
+}
+
+// Driver Code
+pub fn main() !void {
+    var target: i32 = 3;
+
+    // Выполнить линейный поиск в массиве
+    var nums = std.ArrayList(i32).init(std.heap.page_allocator);
+    defer nums.deinit();
+    try nums.appendSlice(&[_]i32{ 1, 5, 3, 2, 4, 7, 5, 9, 10, 8 });
+    var index = linearSearchArray(i32, nums, target);
+    std.debug.print("Индекс целевого элемента 3 = {}\n", .{index});
+
+    // Выполнить линейный поиск в связном списке
+    var mem_arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
+    defer mem_arena.deinit();
+    const mem_allocator = mem_arena.allocator();
+    var head = try inc.ListUtil.listToLinkedList(i32, mem_allocator, nums);
+    var node = linearSearchLinkedList(i32, head, target);
+    std.debug.print("Объект узла со значением 3 = ", .{});
+    try inc.PrintUtil.printLinkedList(i32, node);
+
+    _ = try std.io.getStdIn().reader().readByte();
+}

ru/codes/zig/chapter_searching/two_sum.zig

@@ -0,0 +1,58 @@
+// File: two_sum.zig
+// Created Time: 2023-01-07
+// Author: codingonion (coderonion@gmail.com)
+
+const std = @import("std");
+const inc = @import("include");
+
+// Метод 1: полный перебор
+pub fn twoSumBruteForce(nums: []i32, target: i32) ?[2]i32 {
+    var size: usize = nums.len;
+    var i: usize = 0;
+    // Два вложенных цикла, временная сложность O(n^2)
+    while (i < size - 1) : (i += 1) {
+        var j = i + 1;
+        while (j < size) : (j += 1) {
+            if (nums[i] + nums[j] == target) {
+                return [_]i32{@intCast(i), @intCast(j)};
+            }
+        }
+    }
+    return null;
+}
+
+// Метод 2: вспомогательная хеш-таблица
+pub fn twoSumHashTable(nums: []i32, target: i32) !?[2]i32 {
+    var size: usize = nums.len;
+    // Вспомогательная хеш-таблица, пространственная сложность O(n)
+    var dic = std.AutoHashMap(i32, i32).init(std.heap.page_allocator);
+    defer dic.deinit();
+    var i: usize = 0;
+    // Один цикл, временная сложность O(n)
+    while (i < size) : (i += 1) {
+        if (dic.contains(target - nums[i])) {
+            return [_]i32{dic.get(target - nums[i]).?, @intCast(i)};
+        }
+        try dic.put(nums[i], @intCast(i));
+    }
+    return null;
+}
+
+
+pub fn main() !void {
+    // ======= Test Case =======
+    var nums = [_]i32{ 2, 7, 11, 15 };
+    var target: i32 = 9;
+
+    // ====== Основной код ======
+    // Метод 1
+    var res = twoSumBruteForce(&nums, target).?;
+    std.debug.print("Метод 1: res = ", .{});
+    inc.PrintUtil.printArray(i32, &res); 
+    // Метод 2
+    res = (try twoSumHashTable(&nums, target)).?;
+    std.debug.print("\nМетод 2: res = ", .{});
+    inc.PrintUtil.printArray(i32, &res); 
+
+    _ = try std.io.getStdIn().reader().readByte();
+}