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/rust/chapter_array_and_linkedlist/array.rs

@@ -0,0 +1,111 @@
+/*
+ * File: array.rs
+ * Created Time: 2023-01-15
+ * Author: xBLACICEx (xBLACKICEx@outlook.com), codingonion (coderonion@gmail.com)
+ */
+
+use hello_algo_rust::include::print_util;
+use rand::Rng;
+
+/* Случайный доступ к элементу */
+fn random_access(nums: &[i32]) -> i32 {
+    // Случайным образом выбрать число из интервала [0, nums.len())
+    let random_index = rand::thread_rng().gen_range(0..nums.len());
+    // Получить и вернуть случайный элемент
+    let random_num = nums[random_index];
+    random_num
+}
+
+/* Увеличить длину массива */
+fn extend(nums: &[i32], enlarge: usize) -> Vec<i32> {
+    // Инициализировать массив увеличенной длины
+    let mut res: Vec<i32> = vec![0; nums.len() + enlarge];
+    // Скопировать все элементы исходного массива в новый
+    res[0..nums.len()].copy_from_slice(nums);
+
+    // Вернуть новый массив после расширения
+    res
+}
+
+/* Вставить элемент num по индексу index в массив */
+fn insert(nums: &mut [i32], num: i32, index: usize) {
+    // Сдвинуть элемент с индексом index и все последующие элементы на одну позицию назад
+    for i in (index + 1..nums.len()).rev() {
+        nums[i] = nums[i - 1];
+    }
+    // Присвоить num элементу по индексу index
+    nums[index] = num;
+}
+
+/* Удалить элемент по индексу index */
+fn remove(nums: &mut [i32], index: usize) {
+    // Сдвинуть все элементы после индекса index на одну позицию вперед
+    for i in index..nums.len() - 1 {
+        nums[i] = nums[i + 1];
+    }
+}
+
+/* Обход массива */
+fn traverse(nums: &[i32]) {
+    let mut _count = 0;
+    // Обход массива по индексам
+    for i in 0..nums.len() {
+        _count += nums[i];
+    }
+    // Непосредственно обходить элементы массива
+    _count = 0;
+    for &num in nums {
+        _count += num;
+    }
+}
+
+/* Найти заданный элемент в массиве */
+fn find(nums: &[i32], target: i32) -> Option<usize> {
+    for i in 0..nums.len() {
+        if nums[i] == target {
+            return Some(i);
+        }
+    }
+    None
+}
+
+/* Driver Code */
+fn main() {
+    /* Инициализация массива */
+    let arr: [i32; 5] = [0; 5];
+    print!("Массив arr = ");
+    print_util::print_array(&arr);
+    // В Rust при указании длины ([i32; 5]) получается массив, а без указания длины (&[i32]) — срез
+    // Так как массивы в Rust имеют длину, определяемую на этапе компиляции, для задания длины можно использовать только константы
+    // Vector обычно используется в Rust как тип динамического массива
+    // Для удобства реализации метода расширения extend() ниже vector рассматривается как массив (array)
+    let nums: Vec<i32> = vec![1, 3, 2, 5, 4];
+    print!("\nМассив nums = ");
+    print_util::print_array(&nums);
+
+    // Случайный доступ
+    let random_num = random_access(&nums);
+    println!("\nСлучайный элемент из nums = {}", random_num);
+
+    // Расширение длины
+    let mut nums: Vec<i32> = extend(&nums, 3);
+    print!("После увеличения длины массива до 8 nums = ");
+    print_util::print_array(&nums);
+
+    // Вставка элемента
+    insert(&mut nums, 6, 3);
+    print!("\nПосле вставки числа 6 по индексу 3 nums = ");
+    print_util::print_array(&nums);
+
+    // Удаление элемента
+    remove(&mut nums, 2);
+    print!("\nПосле удаления элемента по индексу 2 nums = ");
+    print_util::print_array(&nums);
+
+    // Обход массива
+    traverse(&nums);
+
+    // Поиск элемента
+    let index = find(&nums, 3).unwrap();
+    println!("\nПоиск элемента 3 в nums: индекс = {}", index);
+}

ru/codes/rust/chapter_array_and_linkedlist/linked_list.rs

@@ -0,0 +1,100 @@
+/*
+ * File: linked_list.rs
+ * Created Time: 2023-03-05
+ * Author: codingonion (coderonion@gmail.com)
+ */
+
+use hello_algo_rust::include::{print_util, ListNode};
+use std::cell::RefCell;
+use std::rc::Rc;
+
+/* Вставить узел P после узла n0 в связном списке */
+#[allow(non_snake_case)]
+pub fn insert<T>(n0: &Rc<RefCell<ListNode<T>>>, P: Rc<RefCell<ListNode<T>>>) {
+    let n1 = n0.borrow_mut().next.take();
+    P.borrow_mut().next = n1;
+    n0.borrow_mut().next = Some(P);
+}
+
+/* Удалить первый узел после узла n0 в связном списке */
+#[allow(non_snake_case)]
+pub fn remove<T>(n0: &Rc<RefCell<ListNode<T>>>) {
+    // n0 -> P -> n1
+    let P = n0.borrow_mut().next.take();
+    if let Some(node) = P {
+        let n1 = node.borrow_mut().next.take();
+        n0.borrow_mut().next = n1;
+    }
+}
+
+/* Доступ к узлу связного списка по индексу index */
+pub fn access<T>(head: Rc<RefCell<ListNode<T>>>, index: i32) -> Option<Rc<RefCell<ListNode<T>>>> {
+    fn dfs<T>(
+        head: Option<&Rc<RefCell<ListNode<T>>>>,
+        index: i32,
+    ) -> Option<Rc<RefCell<ListNode<T>>>> {
+        if index <= 0 {
+            return head.cloned();
+        }
+
+        if let Some(node) = head {
+            dfs(node.borrow().next.as_ref(), index - 1)
+        } else {
+            None
+        }
+    }
+
+    dfs(Some(head).as_ref(), index)
+}
+
+/* Найти в связном списке первый узел со значением target */
+pub fn find<T: PartialEq>(head: Rc<RefCell<ListNode<T>>>, target: T) -> i32 {
+    fn find<T: PartialEq>(head: Option<&Rc<RefCell<ListNode<T>>>>, target: T, idx: i32) -> i32 {
+        if let Some(node) = head {
+            if node.borrow().val == target {
+                return idx;
+            }
+            return find(node.borrow().next.as_ref(), target, idx + 1);
+        } else {
+            -1
+        }
+    }
+
+    find(Some(head).as_ref(), target, 0)
+}
+
+/* Driver Code */
+fn main() {
+    /* Инициализация связного списка */
+    // Инициализация всех узлов
+    let n0 = ListNode::new(1);
+    let n1 = ListNode::new(3);
+    let n2 = ListNode::new(2);
+    let n3 = ListNode::new(5);
+    let n4 = ListNode::new(4);
+    // Построить ссылки между узлами
+    n0.borrow_mut().next = Some(n1.clone());
+    n1.borrow_mut().next = Some(n2.clone());
+    n2.borrow_mut().next = Some(n3.clone());
+    n3.borrow_mut().next = Some(n4.clone());
+    print!("Исходный связный список ");
+    print_util::print_linked_list(&n0);
+
+    /* Вставка узла */
+    insert(&n0, ListNode::new(0));
+    print!("Связный список после вставки узла ");
+    print_util::print_linked_list(&n0);
+
+    /* Удаление узла */
+    remove(&n0);
+    print!("Связный список после удаления узла ");
+    print_util::print_linked_list(&n0);
+
+    /* Доступ к узлу */
+    let node = access(n0.clone(), 3);
+    println!("Значение узла по индексу 3 в связном списке = {}", node.unwrap().borrow().val);
+
+    /* Поиск узла */
+    let index = find(n0.clone(), 2);
+    println!("Индекс узла со значением 2 в связном списке = {}", index);
+}

ru/codes/rust/chapter_array_and_linkedlist/list.rs

@@ -0,0 +1,71 @@
+/*
+ * File: list.rs
+ * Created Time: 2023-01-18
+ * Author: xBLACICEx (xBLACKICEx@outlook.com), codingonion (coderonion@gmail.com)
+ */
+use hello_algo_rust::include::print_util;
+
+/* Driver Code */
+fn main() {
+    // Инициализация списка
+    let mut nums: Vec<i32> = vec![1, 3, 2, 5, 4];
+    print!("Список nums = ");
+    print_util::print_array(&nums);
+
+    // Доступ к элементу
+    let num = nums[1];
+    println!("\nЭлемент по индексу 1: num = {num}");
+
+    // Обновление элемента
+    nums[1] = 0;
+    print!("После обновления элемента по индексу 1 до 0 nums = ");
+    print_util::print_array(&nums);
+
+    // Очистить список
+    nums.clear();
+    print!("\nПосле очистки списка nums = ");
+    print_util::print_array(&nums);
+
+    // Добавление элемента в конец
+    nums.push(1);
+    nums.push(3);
+    nums.push(2);
+    nums.push(5);
+    nums.push(4);
+    print!("\nПосле добавления элементов nums = ");
+    print_util::print_array(&nums);
+
+    // Вставка элемента в середину
+    nums.insert(3, 6);
+    print!("\nПосле вставки числа 6 по индексу 3 nums = ");
+    print_util::print_array(&nums);
+
+    // Удаление элемента
+    nums.remove(3);
+    print!("\nПосле удаления элемента по индексу 3 nums = ");
+    print_util::print_array(&nums);
+
+    // Обходить список по индексам
+    let mut _count = 0;
+    for i in 0..nums.len() {
+        _count += nums[i];
+    }
+    // Непосредственно обходить элементы списка
+    _count = 0;
+    for x in &nums {
+        _count += x;
+    }
+
+    // Объединить два списка
+    let mut nums1 = vec![6, 8, 7, 10, 9];
+    nums.append(&mut nums1); // После append (перемещение) nums1 становится пустым!
+
+    // nums.extend(&nums1);   // extend (заимствование), nums1 можно продолжать использовать
+    print!("\nПосле конкатенации списка nums1 к nums nums = ");
+    print_util::print_array(&nums);
+
+    // Отсортировать список
+    nums.sort();
+    print!("\nПосле сортировки списка nums = ");
+    print_util::print_array(&nums);
+}

ru/codes/rust/chapter_array_and_linkedlist/my_list.rs

@@ -0,0 +1,164 @@
+/*
+ * File: my_list.rs
+ * Created Time: 2023-03-11
+ * Author: codingonion (coderonion@gmail.com)
+ */
+
+use hello_algo_rust::include::print_util;
+
+/* Класс списка */
+#[allow(dead_code)]
+struct MyList {
+    arr: Vec<i32>,       // Массив (для хранения элементов списка)
+    capacity: usize,     // Вместимость списка
+    size: usize,         // Длина списка (текущее число элементов)
+    extend_ratio: usize, // Коэффициент увеличения списка при каждом расширении
+}
+
+#[allow(unused, unused_comparisons)]
+impl MyList {
+    /* Конструктор */
+    pub fn new(capacity: usize) -> Self {
+        let mut vec = vec![0; capacity];
+        Self {
+            arr: vec,
+            capacity,
+            size: 0,
+            extend_ratio: 2,
+        }
+    }
+
+    /* Получить длину списка (текущее число элементов) */
+    pub fn size(&self) -> usize {
+        return self.size;
+    }
+
+    /* Получить вместимость списка */
+    pub fn capacity(&self) -> usize {
+        return self.capacity;
+    }
+
+    /* Доступ к элементу */
+    pub fn get(&self, index: usize) -> i32 {
+        // Если индекс выходит за границы, выбрасывается исключение; далее аналогично
+        if index >= self.size {
+            panic!("индекс выходит за границы")
+        };
+        return self.arr[index];
+    }
+
+    /* Обновление элемента */
+    pub fn set(&mut self, index: usize, num: i32) {
+        if index >= self.size {
+            panic!("индекс выходит за границы")
+        };
+        self.arr[index] = num;
+    }
+
+    /* Добавление элемента в конец */
+    pub fn add(&mut self, num: i32) {
+        // При превышении вместимости по числу элементов запускается расширение
+        if self.size == self.capacity() {
+            self.extend_capacity();
+        }
+        self.arr[self.size] = num;
+        // Обновить число элементов
+        self.size += 1;
+    }
+
+    /* Вставка элемента в середину */
+    pub fn insert(&mut self, index: usize, num: i32) {
+        if index >= self.size() {
+            panic!("индекс выходит за границы")
+        };
+        // При превышении вместимости по числу элементов запускается расширение
+        if self.size == self.capacity() {
+            self.extend_capacity();
+        }
+        // Сдвинуть элемент с индексом index и все следующие элементы на одну позицию назад
+        for j in (index..self.size).rev() {
+            self.arr[j + 1] = self.arr[j];
+        }
+        self.arr[index] = num;
+        // Обновить число элементов
+        self.size += 1;
+    }
+
+    /* Удаление элемента */
+    pub fn remove(&mut self, index: usize) -> i32 {
+        if index >= self.size() {
+            panic!("индекс выходит за границы")
+        };
+        let num = self.arr[index];
+        // Сдвинуть все элементы после индекса index на одну позицию вперед
+        for j in index..self.size - 1 {
+            self.arr[j] = self.arr[j + 1];
+        }
+        // Обновить число элементов
+        self.size -= 1;
+        // Вернуть удаленный элемент
+        return num;
+    }
+
+    /* Расширение списка */
+    pub fn extend_capacity(&mut self) {
+        // Создать новый массив длиной в extend_ratio раз больше исходного и скопировать в него исходный массив
+        let new_capacity = self.capacity * self.extend_ratio;
+        self.arr.resize(new_capacity, 0);
+        // Обновить вместимость списка
+        self.capacity = new_capacity;
+    }
+
+    /* Преобразовать список в массив */
+    pub fn to_array(&self) -> Vec<i32> {
+        // Преобразовывать только элементы списка в пределах фактической длины
+        let mut arr = Vec::new();
+        for i in 0..self.size {
+            arr.push(self.get(i));
+        }
+        arr
+    }
+}
+
+/* Driver Code */
+fn main() {
+    /* Инициализация списка */
+    let mut nums = MyList::new(10);
+    /* Добавление элемента в конец */
+    nums.add(1);
+    nums.add(3);
+    nums.add(2);
+    nums.add(5);
+    nums.add(4);
+    print!("Список nums = ");
+    print_util::print_array(&nums.to_array());
+    print!(" , вместимость = {} , длина = {}", nums.capacity(), nums.size());
+
+    /* Вставка элемента в середину */
+    nums.insert(3, 6);
+    print!("\nПосле вставки числа 6 по индексу 3 nums = ");
+    print_util::print_array(&nums.to_array());
+
+    /* Удаление элемента */
+    nums.remove(3);
+    print!("\nПосле удаления элемента по индексу 3 nums = ");
+    print_util::print_array(&nums.to_array());
+
+    /* Доступ к элементу */
+    let num = nums.get(1);
+    println!("\nЭлемент по индексу 1: num = {num}");
+
+    /* Обновление элемента */
+    nums.set(1, 0);
+    print!("После обновления элемента по индексу 1 до 0 nums = ");
+    print_util::print_array(&nums.to_array());
+
+    /* Проверка механизма расширения */
+    for i in 0..10 {
+        // При i = 5 длина списка превысит его вместимость, и в этот момент сработает механизм расширения
+        nums.add(i);
+    }
+    print!("\nСписок nums после увеличения вместимости = ");
+    print_util::print_array(&nums.to_array());
+    print!(" , вместимость = {} , длина = {}", nums.capacity(), nums.size());
+}