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_array_and_linkedlist/array.zig

@@ -0,0 +1,131 @@
+// File: array.zig
+// Created Time: 2023-01-07
+// Author: codingonion (coderonion@gmail.com), CreatorMetaSky (creator_meta_sky@163.com)
+
+const std = @import("std");
+const utils = @import("utils");
+
+// Случайный доступ к элементу
+pub fn randomAccess(nums: []const i32) i32 {
+    // Случайным образом выбрать целое число из интервала [0, nums.len)
+    const random_index = std.crypto.random.intRangeLessThan(usize, 0, nums.len);
+    // Получить и вернуть случайный элемент
+    const randomNum = nums[random_index];
+    return randomNum;
+}
+
+// Увеличить длину массива
+pub fn extend(allocator: std.mem.Allocator, nums: []const i32, enlarge: usize) ![]i32 {
+    // Инициализировать массив увеличенной длины
+    const res = try allocator.alloc(i32, nums.len + enlarge);
+    @memset(res, 0);
+
+    // Скопировать все элементы исходного массива в новый массив
+    std.mem.copyForwards(i32, res, nums);
+
+    // Вернуть новый массив после расширения
+    return res;
+}
+
+// Вставить элемент num по индексу index в массив
+pub fn insert(nums: []i32, num: i32, index: usize) void {
+    // Сдвинуть элемент с индексом index и все последующие элементы на одну позицию назад
+    var i = nums.len - 1;
+    while (i > index) : (i -= 1) {
+        nums[i] = nums[i - 1];
+    }
+    // Присвоить num элементу по индексу index
+    nums[index] = num;
+}
+
+// Удалить элемент по индексу index
+pub fn remove(nums: []i32, index: usize) void {
+    // Сдвинуть все элементы после индекса index на одну позицию вперед
+    var i = index;
+    while (i < nums.len - 1) : (i += 1) {
+        nums[i] = nums[i + 1];
+    }
+}
+
+// Обход массива
+pub fn traverse(nums: []const i32) void {
+    var count: i32 = 0;
+
+    // Обход массива по индексам
+    var i: usize = 0;
+    while (i < nums.len) : (i += 1) {
+        count += nums[i];
+    }
+
+    // Непосредственно обходить элементы массива
+    count = 0;
+    for (nums) |num| {
+        count += num;
+    }
+
+    // Одновременно обходить индексы и элементы данных
+    for (nums, 0..) |num, index| {
+        count += nums[index];
+        count += num;
+    }
+}
+
+// Найти заданный элемент в массиве
+pub fn find(nums: []i32, target: i32) i32 {
+    for (nums, 0..) |num, i| {
+        if (num == target) return @intCast(i);
+    }
+    return -1;
+}
+
+// Driver Code
+pub fn run() !void {
+    // Инициализация массива
+    const arr = [_]i32{0} ** 5;
+    std.debug.print("Массив arr = {}\n", .{utils.fmt.slice(&arr)});
+
+    // Срез массива
+    var array = [_]i32{ 1, 3, 2, 5, 4 };
+    var known_at_runtime_zero: usize = 0;
+    _ = &known_at_runtime_zero;
+    var nums = array[known_at_runtime_zero..array.len]; // Превратить указатель в срез через известную во время выполнения переменную known_at_runtime_zero
+    std.debug.print("Массив nums = {}\n", .{utils.fmt.slice(nums)});
+
+    // Случайный доступ
+    const randomNum = randomAccess(nums);
+    std.debug.print("Случайный элемент из nums = {}\n", .{randomNum});
+
+    // Инициализация аллокатора памяти
+    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
+    defer arena.deinit();
+    const allocator = arena.allocator();
+
+    // Расширение длины
+    nums = try extend(allocator, nums, 3);
+    std.debug.print("После расширения длины массива до 8 nums = {}\n", .{utils.fmt.slice(nums)});
+
+    // Вставка элемента
+    insert(nums, 6, 3);
+    std.debug.print("После вставки числа 6 по индексу 3 nums = {}\n", .{utils.fmt.slice(nums)});
+
+    // Удаление элемента
+    remove(nums, 2);
+    std.debug.print("После удаления элемента по индексу 2 nums = {}\n", .{utils.fmt.slice(nums)});
+
+    // Обход массива
+    traverse(nums);
+
+    // Поиск элемента
+    const index = find(nums, 3);
+    std.debug.print("Поиск элемента 3 в nums: индекс = {}\n", .{index});
+
+    std.debug.print("\n", .{});
+}
+
+pub fn main() !void {
+    try run();
+}
+
+test "array" {
+    try run();
+}

ru/codes/zig/chapter_array_and_linkedlist/linked_list.zig

@@ -0,0 +1,96 @@
+// File: linked_list.zig
+// Created Time: 2023-01-07
+// Author: codingonion (coderonion@gmail.com), CreatorMetaSky (creator_meta_sky@163.com)
+
+const std = @import("std");
+const utils = @import("utils");
+const ListNode = utils.ListNode;
+
+// Вставить узел P после узла n0 в связном списке
+pub fn insert(comptime T: type, n0: *ListNode(T), P: *ListNode(T)) void {
+    const n1 = n0.next;
+    P.next = n1;
+    n0.next = P;
+}
+
+// Удалить первый узел после узла n0 в связном списке
+pub fn remove(comptime T: type, n0: *ListNode(T)) void {
+    // n0 -> P -> n1 => n0 -> n1
+    const P = n0.next;
+    const n1 = P.?.next;
+    n0.next = n1;
+}
+
+// Доступ к узлу связного списка по индексу index
+pub fn access(comptime T: type, node: *ListNode(T), index: i32) ?*ListNode(T) {
+    var head: ?*ListNode(T) = node;
+    var i: i32 = 0;
+    while (i < index) : (i += 1) {
+        if (head) |cur| {
+            head = cur.next;
+        } else {
+            return null;
+        }
+    }
+    return head;
+}
+
+// Найти в связном списке первый узел со значением target
+pub fn find(comptime T: type, node: *ListNode(T), target: T) i32 {
+    var head: ?*ListNode(T) = node;
+    var index: i32 = 0;
+    while (head) |cur| {
+        if (cur.val == target) return index;
+        head = cur.next;
+        index += 1;
+    }
+    return -1;
+}
+
+// Driver Code
+pub fn run() void {
+    // Инициализация всех узлов
+    var n0 = ListNode(i32){ .val = 1 };
+    var n1 = ListNode(i32){ .val = 3 };
+    var n2 = ListNode(i32){ .val = 2 };
+    var n3 = ListNode(i32){ .val = 5 };
+    var n4 = ListNode(i32){ .val = 4 };
+    // Построить ссылки между узлами
+    n0.next = &n1;
+    n1.next = &n2;
+    n2.next = &n3;
+    n3.next = &n4;
+    std.debug.print(
+        "Инициализированный связный список = {}\n",\n    .{utils.fmt.linkedList(i32, &n0)},\n);
+
+    // Вставка узла
+    var tmp = ListNode(i32){ .val = 0 };
+    insert(i32, &n0, &tmp);
+    std.debug.print(
+        "Связный список после вставки узла = {}\n",\n    .{utils.fmt.linkedList(i32, &n0)},\n);
+
+    // Удаление узла
+    remove(i32, &n0);
+    std.debug.print(
+        "Связный список после удаления узла = {}\n",\n    .{utils.fmt.linkedList(i32, &n0)},\n);
+
+    // Доступ к узлу
+    const node = access(i32, &n0, 3);
+    std.debug.print(
+        "Значение узла по индексу 3 в связном списке = {}\n",\n    .{node.?.val},\n);
+
+    // Поиск узла
+    const index = find(i32, &n0, 2);
+    std.debug.print(
+        "Индекс узла со значением 2 в связном списке = {}\n",\n    .{index},\n);
+
+    std.debug.print("\n", .{});
+}
+
+pub fn main() void {
+    run();
+}
+
+test "linked_list" {
+    run();
+}

ru/codes/zig/chapter_array_and_linkedlist/list.zig

@@ -0,0 +1,78 @@
+// File: list.zig
+// Created Time: 2023-01-07
+// Author: codingonion (coderonion@gmail.com), CreatorMetaSky (creator_meta_sky@163.com)
+
+const std = @import("std");
+const utils = @import("utils");
+
+// Driver Code
+pub fn run() !void {
+    // Инициализация списка
+    var nums = std.ArrayList(i32).init(std.heap.page_allocator);
+    defer nums.deinit(); // Отложенное освобождение памяти
+
+    try nums.appendSlice(&[_]i32{ 1, 3, 2, 5, 4 });
+    std.debug.print("Список nums = {}\n", .{utils.fmt.slice(nums.items)});
+
+    // Доступ к элементу
+    const num = nums.items[1];
+    std.debug.print("Элемент по индексу 1: num = {}\n", .{num});
+
+    // Обновление элемента
+    nums.items[1] = 0;
+    std.debug.print("После обновления элемента по индексу 1 до 0 nums = {}\n", .{utils.fmt.slice(nums.items)});
+
+    // Очистить список
+    nums.clearRetainingCapacity();
+    std.debug.print("После очистки списка nums = {}\n", .{utils.fmt.slice(nums.items)});
+
+    // Добавление элемента в конец
+    try nums.append(1);
+    try nums.append(3);
+    try nums.append(2);
+    try nums.append(5);
+    try nums.append(4);
+    std.debug.print("После добавления элементов nums = {}\n", .{utils.fmt.slice(nums.items)});
+
+    // Вставка элемента в середину
+    try nums.insert(3, 6);
+    std.debug.print("После вставки числа 6 по индексу 3 nums = {}\n", .{utils.fmt.slice(nums.items)});
+
+    // Удаление элемента
+    _ = nums.orderedRemove(3);
+    std.debug.print("После удаления элемента по индексу 3 nums = {}\n", .{utils.fmt.slice(nums.items)});
+
+    // Обходить список по индексам
+    var count: i32 = 0;
+    var i: usize = 0;
+    while (i < nums.items.len) : (i += 1) {
+        count += nums.items[i];
+    }
+
+    // Непосредственно обходить элементы списка
+    count = 0;
+    for (nums.items) |x| {
+        count += x;
+    }
+
+    // Объединить два списка
+    var nums1 = std.ArrayList(i32).init(std.heap.page_allocator);
+    defer nums1.deinit();
+    try nums1.appendSlice(&[_]i32{ 6, 8, 7, 10, 9 });
+    try nums.insertSlice(nums.items.len, nums1.items);
+    std.debug.print("После конкатенации списка nums1 к nums nums = {}\n", .{utils.fmt.slice(nums.items)});
+
+    // Отсортировать список
+    std.mem.sort(i32, nums.items, {}, comptime std.sort.asc(i32));
+    std.debug.print("После сортировки списка nums = {}\n", .{utils.fmt.slice(nums.items)});
+
+    std.debug.print("\n", .{});
+}
+
+pub fn main() !void {
+    try run();
+}
+
+test "list" {
+    try run();
+}

ru/codes/zig/chapter_array_and_linkedlist/my_list.zig

@@ -0,0 +1,217 @@
+// File: my_list.zig
+// Created Time: 2023-01-08
+// Author: codingonion (coderonion@gmail.com), CreatorMetaSky (creator_meta_sky@163.com)
+
+const std = @import("std");
+const utils = @import("utils");
+
+// Класс списка
+const MyList = struct {
+    const Self = @This();
+
+    items: []i32, // Массив (для хранения элементов списка)
+    capacity: usize, // Вместимость списка
+    allocator: std.mem.Allocator, // Аллокатор памяти
+
+    extend_ratio: usize = 2, // Коэффициент увеличения списка при каждом расширении
+
+    // Конструктор (выделение памяти + инициализация списка)
+    pub fn init(allocator: std.mem.Allocator) Self {
+        return Self{
+            .items = &[_]i32{},
+            .capacity = 0,
+            .allocator = allocator,
+        };
+    }
+
+    // Деструктор (освобождение памяти)
+    pub fn deinit(self: Self) void {
+        self.allocator.free(self.allocatedSlice());
+    }
+
+    // Добавление элемента в конец
+    pub fn add(self: *Self, item: i32) !void {
+        // При превышении вместимости по числу элементов запускается расширение
+        const newlen = self.items.len + 1;
+        try self.ensureTotalCapacity(newlen);
+
+        // Обновление элемента
+        self.items.len += 1;
+        const new_item_ptr = &self.items[self.items.len - 1];
+        new_item_ptr.* = item;
+    }
+
+    // Получить длину списка (текущее число элементов)
+    pub fn getSize(self: *Self) usize {
+        return self.items.len;
+    }
+
+    // Получить вместимость списка
+    pub fn getCapacity(self: *Self) usize {
+        return self.capacity;
+    }
+
+    // Доступ к элементу
+    pub fn get(self: *Self, index: usize) i32 {
+        // Если индекс выходит за границы, выбрасывается исключение; далее аналогично
+        if (index < 0 or index >= self.items.len) {
+            @panic("индекс выходит за границы");
+        }
+        return self.items[index];
+    }
+
+    // Обновление элемента
+    pub fn set(self: *Self, index: usize, num: i32) void {
+        // Если индекс выходит за границы, выбрасывается исключение; далее аналогично
+        if (index < 0 or index >= self.items.len) {
+            @panic("индекс выходит за границы");
+        }
+        self.items[index] = num;
+    }
+
+    // Вставка элемента в середину
+    pub fn insert(self: *Self, index: usize, item: i32) !void {
+        if (index < 0 or index >= self.items.len) {
+            @panic("индекс выходит за границы");
+        }
+
+        // При превышении вместимости по числу элементов запускается расширение
+        const newlen = self.items.len + 1;
+        try self.ensureTotalCapacity(newlen);
+
+        // Сдвинуть элемент с индексом index и все следующие элементы на одну позицию назад
+        self.items.len += 1;
+        var i = self.items.len - 1;
+        while (i >= index) : (i -= 1) {
+            self.items[i] = self.items[i - 1];
+        }
+        self.items[index] = item;
+    }
+
+    // Удаление элемента
+    pub fn remove(self: *Self, index: usize) i32 {
+        if (index < 0 or index >= self.getSize()) {
+            @panic("индекс выходит за границы");
+        }
+        // Сдвинуть все элементы после индекса index на одну позицию вперед
+        const item = self.items[index];
+        var i = index;
+        while (i < self.items.len - 1) : (i += 1) {
+            self.items[i] = self.items[i + 1];
+        }
+        self.items.len -= 1;
+        // Вернуть удаленный элемент
+        return item;
+    }
+
+    // Преобразовать список в массив
+    pub fn toArraySlice(self: *Self) ![]i32 {
+        return self.toOwnedSlice(false);
+    }
+
+    // Вернуть новый срез и указать, нужно ли сбросить или очистить контейнер списка
+    pub fn toOwnedSlice(self: *Self, clear: bool) ![]i32 {
+        const allocator = self.allocator;
+        const old_memory = self.allocatedSlice();
+        if (allocator.remap(old_memory, self.items.len)) |new_items| {
+            if (clear) {
+                self.* = init(allocator);
+            }
+            return new_items;
+        }
+
+        const new_memory = try allocator.alloc(i32, self.items.len);
+        @memcpy(new_memory, self.items);
+        if (clear) {
+            self.clearAndFree();
+        }
+        return new_memory;
+    }
+
+    // Расширение списка
+    fn ensureTotalCapacity(self: *Self, new_capacity: usize) !void {
+        if (self.capacity >= new_capacity) return;
+        const capcacity = if (self.capacity == 0) 10 else self.capacity;
+        const better_capacity = capcacity * self.extend_ratio;
+
+        const old_memory = self.allocatedSlice();
+        if (self.allocator.remap(old_memory, better_capacity)) |new_memory| {
+            self.items.ptr = new_memory.ptr;
+            self.capacity = new_memory.len;
+        } else {
+            const new_memory = try self.allocator.alloc(i32, better_capacity);
+            @memcpy(new_memory[0..self.items.len], self.items);
+            self.allocator.free(old_memory);
+            self.items.ptr = new_memory.ptr;
+            self.capacity = new_memory.len;
+        }
+    }
+
+    fn clearAndFree(self: *Self, allocator: std.mem.Allocator) void {
+        allocator.free(self.allocatedSlice());
+        self.items.len = 0;
+        self.capacity = 0;
+    }
+
+    fn allocatedSlice(self: Self) []i32 {
+        return self.items.ptr[0..self.capacity];
+    }
+};
+
+// Driver Code
+pub fn run() !void {
+    var gpa = std.heap.DebugAllocator(.{}){};
+    defer _ = gpa.deinit();
+    const allocator = gpa.allocator();
+
+    // Инициализация списка
+    var nums = MyList.init(allocator);
+    // Отложенное освобождение памяти
+    defer nums.deinit();
+
+    // Добавление элемента в конец
+    try nums.add(1);
+    try nums.add(3);
+    try nums.add(2);
+    try nums.add(5);
+    try nums.add(4);
+    std.debug.print("Список nums = {}, вместимость = {}, длина = {}\n", .{\n    utils.fmt.slice(nums.items),\n    nums.getCapacity(),\n    nums.getSize(),\n});
+
+    // Вставка элемента в середину
+    try nums.insert(3, 6);
+    std.debug.print(
+        "После вставки числа 6 по индексу 3 получаем nums = {}\n",\n    .{utils.fmt.slice(nums.items)},\n);
+
+    // Удаление элемента
+    _ = nums.remove(3);
+    std.debug.print(
+        "После удаления элемента по индексу 3 получаем nums = {}\n",\n    .{utils.fmt.slice(nums.items)},\n);
+
+    // Доступ к элементу
+    const num = nums.get(1);
+    std.debug.print("Элемент по индексу 1: num = {}\n", .{num});
+
+    // Обновление элемента
+    nums.set(1, 0);
+    std.debug.print(
+        "После обновления элемента по индексу 1 значением 0 получаем nums = {}\n",\n    .{utils.fmt.slice(nums.items)},\n);
+
+    // Проверка механизма расширения
+    var i: i32 = 0;
+    while (i < 10) : (i += 1) {
+        // При i = 5 длина списка превысит его вместимость, и в этот момент сработает механизм расширения
+        try nums.add(i);
+    }
+    std.debug.print(
+        "Список nums после увеличения вместимости = {}, вместимость = {}, длина = {}\n",\n    .{\n        utils.fmt.slice(nums.items),\n        nums.getCapacity(),\n        nums.getSize(),\n    },\n);
+
+    std.debug.print("\n", .{});
+}
+
+pub fn main() !void {
+    try run();
+}
+
+test "my_list" {
+    try run();
+}