quizzes

practice/.gitignore

@@ -0,0 +1 @@
+/target/

practice/Cargo.lock

@@ -0,0 +1,7 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "practice"
+version = "0.0.0"

practice/Cargo.toml

@@ -0,0 +1,6 @@
+[package]
+name = "practice"
+version = "0.0.0"
+edition = "2024"
+
+[dependencies]

practice/src/bin/a_compare.rs

@@ -0,0 +1,21 @@
+// Напиúите функøиĀ compare<T: PartialOrd>(a: T, b: T) -> T, котораā:
+// ● Возвраûает наиболþúий из двух аргументов (a или b).
+// ● Исполþзуйте трейт PartialOrd длā сравнениā.
+
+#![allow(clippy::approx_constant)]
+
+fn compare<T>(a: T, b: T) -> T
+where
+    T: PartialOrd,
+{
+    if a >= b { a } else { b }
+}
+
+fn main() {
+    println!("{}", compare(5, 10)); // 10
+    println!("{}", compare('a', 'z')); // z
+
+    // Также работает с другими типами, реализующими PartialOrd
+    println!("{}", compare(3.14, 2.71)); // 3.14
+    println!("{}", compare("apple", "banana")); // "banana"
+}

practice/src/bin/b_pair.rs

@@ -0,0 +1,35 @@
+// Создайте структуру Pair<T, U> с двумā полāми разнýх типов:
+// ● Реализуйте метод new(first: T, second: U) -> Self.
+// ● Добавþте метод swap(self) -> Pair<U, T>, которýй менāет местами знаùениā полей.
+
+#![allow(clippy::approx_constant)]
+
+#[derive(Debug)]
+struct Pair<T, U> {
+    first: T,
+    second: U,
+}
+
+impl<T, U> Pair<T, U> {
+    // Создаем новую пару
+    fn new(first: T, second: U) -> Self {
+        Self { first, second }
+    }
+
+    // Меняем местами значения
+    fn swap(self) -> Pair<U, T> {
+        Pair::new(self.second, self.first)
+    }
+}
+
+fn main() {
+    let pair = Pair::new(42, "hello");
+    let swapped = pair.swap();
+
+    println!("{:?}", swapped); // Pair("hello", 42)
+
+    // Дополнительный пример с другими типами
+    let float_str_pair = Pair::new(3.14, "pi");
+    let swapped_pair = float_str_pair.swap();
+    println!("{:?}", swapped_pair); // Pair("pi", 3.14)
+}

practice/src/bin/c_area.rs

@@ -0,0 +1,64 @@
+// 1. Определите типаж Area с методом area(&self) -> f64.
+// 2. Реализуйте его длā структур Circle (с полем radius: f64) и Square (с полем side: f64).
+// 3. Напишите обобщенную функцию print_area<T: Area>(shape: T), которая печатает площадь фигуру.
+
+// Определяем типаж Area
+trait Area {
+    fn area(&self) -> f64;
+}
+
+// Структура Circle
+struct Circle {
+    radius: f64,
+}
+
+// Реализация Area для Circle
+impl Area for Circle {
+    fn area(&self) -> f64 {
+        std::f64::consts::PI * self.radius * self.radius
+    }
+}
+
+// Структура Square
+struct Square {
+    side: f64,
+}
+
+// Реализация Area для Square
+impl Area for Square {
+    fn area(&self) -> f64 {
+        self.side * self.side
+    }
+}
+
+// Обобщённая функция для вывода площади
+fn print_area(area: impl Area) {
+    println!("Area: {}", area.area())
+}
+
+fn main() {
+    let circle = Circle { radius: 5.0 };
+    let square = Square { side: 10.0 };
+
+    print_area(circle); // Area: 78.53981633974483
+    print_area(square); // Area: 100
+
+    // Можно добавить больше фигур, реализующих Area
+    let rectangle = Rectangle {
+        width: 4.0,
+        height: 6.0,
+    };
+    print_area(rectangle); // Area: 24
+}
+
+// Дополнительная структура для демонстрации расширяемости
+struct Rectangle {
+    width: f64,
+    height: f64,
+}
+
+impl Area for Rectangle {
+    fn area(&self) -> f64 {
+        self.width * self.height
+    }
+}

practice/src/bin/d_wrapper.rs

@@ -0,0 +1,37 @@
+// Создайте структуру Wrapper<T> с одним полем value: T:
+// ● Реализуйте метод map<U, F>(self, f: F) -> Wrapper<U>, где F: FnOnce(T) -> U.
+// ● Метод должен применāтþ функøиĀ f к value и возвраûатþ новýй Wrapper с резулþтатом.
+
+#![allow(clippy::approx_constant)]
+
+struct Wrapper<T> {
+    value: T,
+}
+
+impl<T> Wrapper<T> {
+    // Создаем новый Wrapper
+    fn new(value: T) -> Self {
+        Self { value }
+    }
+
+    // Применяем функцию к значению и возвращаем новый Wrapper
+    fn map<U>(self, f: impl FnOnce(T) -> U) -> Wrapper<U> {
+        Wrapper::new(f(self.value))
+    }
+}
+
+fn main() {
+    // Пример из задания
+    let w = Wrapper { value: 42 };
+    let w2 = w.map(|x| x.to_string());
+    println!("{}", w2.value); // "42"
+
+    // Дополнительные примеры
+    let w3 = Wrapper::<f64>::new(3.14);
+    let w4 = w3.map(|x| x.floor() as i32);
+    println!("{}", w4.value); // 3
+
+    let w5 = Wrapper::new("hello");
+    let w6 = w5.map(|s| s.len());
+    println!("{}", w6.value); // 5
+}

practice/src/bin/e_summary.rs

@@ -0,0 +1,53 @@
+// 1. Создайте типаж Summary с методом summarize(&self) -> String.
+// 2. Реализуйте его длā:
+// ○ Vec<T> (где T: ToString), метод должен соединāтþ ÿлементý ùерез запāтуĀ.
+// ○ HashMap<K, V> (где K: ToString, V: ToString), метод должен вýводитþ парý key:value.
+// 3. Напиúите функøиĀ print_summary<T: Summary>(item: T), котораā пеùатает резулþтат summarize().
+
+use std::collections::HashMap;
+
+// Определяем типаж Summary
+trait Summary {
+    fn summarize(&self) -> String;
+}
+
+
+// Реализация для Vec<T> где T: ToString
+
+
+
+// Реализация для HashMap<K, V> где K: ToString, V: ToString
+impl<K: ToString, V: ToString> Summary for HashMap<K, V> {
+    fn summarize(&self) -> String {
+        self.iter()
+            .map(|(k, v)| format!("{}:{}", k.to_string(), v.to_string()))
+            .collect::<Vec<String>>()
+            .join(", ")
+    }
+}
+
+// Обобщённая функция для вывода сводки
+
+
+
+
+fn main() {
+    // Пример с вектором
+    let vec = vec![1, 2, 3];
+    print_summary(vec); // "1, 2, 3"
+
+    // Пример с HashMap
+    let mut map = HashMap::new();
+    map.insert("name", "Alice");
+    map.insert("age", "30");
+    print_summary(map); // "name:Alice, age:30" (порядок может отличаться)
+
+    // Дополнительный пример с разными типами
+    let words = vec!["hello", "world"];
+    print_summary(words); // "hello, world"
+
+    let mut scores = HashMap::new();
+    scores.insert("math", 95);
+    scores.insert("science", 90);
+    print_summary(scores); // "math:95, science:90"
+}

practice/src/bin/f_largest_by_key.rs

@@ -0,0 +1,30 @@
+// Напиúите обобûённуĀ функøиĀ largest_by_key<T, F, K>(list: &[T], key: F) -> Option<&T>, где:
+// ● F: Fn(&T) -> K,
+// ● K: PartialOrd.
+// Функøиā должна возвраûатþ ÿлемент с максималþнýм знаùением key(item).
+
+//fn largest_by_key
+
+
+
+
+fn main() {
+    // Пример из задания
+    let words = ["apple", "banana", "cherry"];
+    let longest = largest_by_key(&words, |s| s.len());
+    println!("{:?}", longest); // Some("banana")
+
+    // Дополнительные примеры
+    let numbers = [1, 42, 3, 100, 5];
+    let largest_num = largest_by_key(&numbers, |&n| n);
+    println!("{:?}", largest_num); // Some(100)
+
+    struct Person { name: String, age: u32 }
+    let people = [
+        Person { name: "Alice".to_string(), age: 30 },
+        Person { name: "Bob".to_string(), age: 25 },
+        Person { name: "Charlie".to_string(), age: 35 },
+    ];
+    let oldest = largest_by_key(&people, |p| p.age);
+    println!("Oldest: {:?}", oldest.map(|p| &p.name)); // Some("Charlie")
+}

practice/src/main.rs

@@ -0,0 +1,3 @@
+fn main() {
+    println!("Hello, world!");
+}