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,59 @@
+// 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
+impl<T: ToString> Summary for Vec<T> {
+    fn summarize(&self) -> String {
+        self.iter()
+            .map(|v| v.to_string())
+            .collect::<Vec<String>>()
+            .join(",")
+            .to_string()
+    }
+}
+
+// Реализация для 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 print_summary(summary: impl Summary) {
+    println!("{}", summary.summarize())
+}
+
+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,55 @@
+// Напиúите обобщенную функцию largest_by_key<T, F, K>(list: &[T], key: F) -> Option<&T>, где:
+// ● F: Fn(&T) -> K,
+// ● K: PartialOrd.
+// Функция должна возвращать элемент с максимальным значением key(item).
+
+fn largest_by_key<T, K: PartialOrd>(list: &[T], key: impl Fn(&T) -> K) -> Option<&T> {
+    let l_len = list.len();
+    if l_len < 1 {
+        return None;
+    } else if l_len == 1 {
+        return Some(&list[0]);
+    }
+    let mut max = &list[0];
+    let mut max_key = key(max);
+    for element in &list[1..] {
+        let element_key = key(element);
+        if element_key > max_key {
+            (max, max_key) = (element, element_key);
+        }
+    }
+    Some(max)
+}
+
+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/bin/g_draw.rs

@@ -0,0 +1,44 @@
+// Определяем типаж Draw
+trait Draw {
+    fn draw(&self);
+}
+
+// Структура Circle
+struct Circle;
+
+// Реализация Draw для Circle
+impl Draw for Circle {
+    fn draw(&self) {
+        println!("Drawing circle")
+    }
+}
+
+// Структура Square
+struct Square;
+
+// Реализация Draw для Square
+impl Draw for Square {
+    fn draw(&self) {
+        println!("Drawing square")
+    }
+}
+
+fn main() {
+    // Создаем гетерогенную коллекцию фигур
+    let shapes: Vec<Box<dyn Draw>> = vec![Box::new(Circle), Box::new(Square)];
+
+    // Рисуем все фигуры
+    for shape in shapes {
+        shape.draw();
+    }
+
+    // Добавим еще фигур динамически
+    let mut more_shapes: Vec<Box<dyn Draw>> = Vec::new();
+    more_shapes.push(Box::new(Circle));
+    more_shapes.push(Box::new(Square));
+
+    println!("\nЕще фигуры:");
+    for shape in more_shapes {
+        shape.draw();
+    }
+}

practice/src/bin/h_plugins.rs

@@ -0,0 +1,53 @@
+use std::time::SystemTime;
+
+// Определяем типаж Plugin
+trait Plugin {
+    fn execute(&self) -> String;
+}
+
+// Плагин приветствия
+struct GreetPlugin;
+
+impl Plugin for GreetPlugin {
+    fn execute(&self) -> String {
+        "Hello, world!".to_string()
+    }
+}
+
+// Плагин времени
+struct TimePlugin;
+
+impl Plugin for TimePlugin {
+    fn execute(&self) -> String {
+        let now = SystemTime::now()
+            .duration_since(SystemTime::UNIX_EPOCH)
+            .unwrap();
+
+        let seconds = now.as_secs();
+        let minutes = seconds / 60;
+        let hours = (minutes / 60) % 24;
+        let minutes = minutes % 60;
+
+        format!("Current time: {:02}:{:02}", hours, minutes)
+    }
+}
+
+fn main() {
+    // Создаем коллекцию плагинов
+    let plugins = Vec::<Box<dyn Plugin>>::with_capacity(2);
+
+    // Выполняем все плагины
+    for plugin in plugins {
+        println!("{}", plugin.execute());
+    }
+
+    // Дополнительный пример с динамическим добавлением
+    let mut dynamic_plugins: Vec<Box<dyn Plugin>> = Vec::new();
+    dynamic_plugins.push(Box::new(GreetPlugin));
+    dynamic_plugins.push(Box::new(TimePlugin));
+
+    println!("\nDynamic execution:");
+    for plugin in dynamic_plugins {
+        println!("{}", plugin.execute());
+    }
+}

practice/src/bin/i_dyn_parser.rs

@@ -0,0 +1,70 @@
+// Определяем типаж Parser
+trait Parser {
+    fn parse(&self, input: &str) -> Result<String, String>;
+}
+
+
+
+// Парсер JSON
+struct JsonParser;
+
+impl Parser for JsonParser {
+    fn parse(&self, input: &str) -> Result<String, String> {
+        if input.trim().starts_with('{') && input.trim().ends_with('}') {
+            Ok("Parsed JSON".to_string())
+        } else {
+            Err("Invalid JSON format".to_string())
+        }
+    }
+}
+
+// Парсер CSV
+struct CsvParser;
+
+impl Parser for CsvParser {
+    fn parse(&self, input: &str) -> Result<String, String> {
+        if input.contains(',') {
+            Ok("Parsed CSV".to_string())
+        } else {
+            Err("Invalid CSV format".to_string())
+        }
+    }
+}
+
+// Функция для обработки данных парсером
+fn parse_data(parser: &dyn Parser, input: &str) -> Result<String, String> {
+    parser.parse(input)
+}
+
+
+
+fn main() {
+    // Пример использования JSON парсера
+    let json_parser = JsonParser;
+    let result = parse_data(&json_parser, r#"{ "name": "Alice" }"#);
+    println!("{:?}", result); // Ok("Parsed JSON")
+
+    // Пример использования CSV парсера
+    let csv_parser = CsvParser;
+    let result = parse_data(&csv_parser, "name,age,location");
+    println!("{:?}", result); // Ok("Parsed CSV")
+
+    // Пример обработки ошибок
+    let invalid_json = parse_data(&json_parser, "not a json");
+    println!("{:?}", invalid_json); // Err("Invalid JSON format")
+
+    let invalid_csv = parse_data(&csv_parser, "no commas here");
+    println!("{:?}", invalid_csv); // Err("Invalid CSV format")
+
+    // Динамический выбор парсера
+    let parsers: Vec<&dyn Parser> = vec![&json_parser, &csv_parser];
+    for parser in parsers {
+        println!("Testing parser:");
+        let test_input = if parser.parse("{").is_ok() {
+            r#"{ "test": "value" }"#
+        } else {
+            "field1,field2,field3"
+        };
+        println!("{:?}", parser.parse(test_input));
+    }
+}

practice/src/bin/j_sort_strategy.rs

@@ -0,0 +1,89 @@
+// Определяем типаж стратегии сортировки
+trait SortStrategy {
+    fn sort(&self, data: &mut [i32]);
+}
+
+
+// Реализация пузырьковой сортировки
+struct BubbleSort;
+
+impl SortStrategy for BubbleSort {
+    fn sort(&self, data: &mut [i32]) {
+        let len = data.len();
+        for i in 0..len {
+            for j in 0..len - i - 1 {
+                if data[j] > data[j + 1] {
+                    data.swap(j, j + 1);
+                }
+            }
+        }
+    }
+}
+
+// Реализация быстрой сортировки
+struct QuickSort;
+
+impl SortStrategy for QuickSort {
+    fn sort(&self, data: &mut [i32]) {
+        if data.len() <= 1 {
+            return;
+        }
+
+        let pivot = data.len() / 2;
+        let mut i = 0;
+        let mut j = data.len() - 1;
+
+        loop {
+            while data[i] < data[pivot] {
+                i += 1;
+            }
+            while data[j] > data[pivot] {
+                j -= 1;
+            }
+
+            if i >= j {
+                break;
+            }
+
+            data.swap(i, j);
+            i += 1;
+            j -= 1;
+        }
+
+        self.sort(&mut data[..i]);
+        self.sort(&mut data[i..]);
+    }
+}
+
+// Функция для применения стратегии сортировки
+fn sort_data(strategy: &dyn SortStrategy, data: &mut [i32]) {
+    strategy.sort(data)
+}
+
+
+
+fn main() {
+    // Тестируем пузырьковую сортировку
+    let mut data1 = [3, 1, 2, 5, 4];
+    let bubble = Box::new(BubbleSort);
+    sort_data(&*bubble, &mut data1);
+    println!("Bubble sort: {:?}", data1); // [1, 2, 3, 4, 5]
+
+    // Тестируем быструю сортировку
+    let mut data2 = [7, 3, 9, 2, 1];
+    let quick = Box::new(QuickSort);
+    sort_data(&*quick, &mut data2);
+    println!("Quick sort: {:?}", data2); // [1, 2, 3, 7, 9]
+
+    // Динамический выбор стратегии
+    let strategies: Vec<Box<dyn SortStrategy>> = vec![
+        Box::new(BubbleSort),
+        Box::new(QuickSort),
+    ];
+
+    for strategy in strategies {
+        let mut test_data = [5, 2, 4, 1, 3];
+        strategy.sort(&mut test_data);
+        println!("Sorted: {:?}", test_data);
+    }
+}

practice/src/bin/k_dyn_logger.rs

@@ -0,0 +1,91 @@
+// Уровни логирования
+#[derive(Debug, PartialEq, PartialOrd, Copy, Clone)]
+enum LogLevel {
+    Error,
+    Warn,
+    Info,
+    Debug,
+}
+
+// Типаж Logger
+trait Logger {
+    fn log(&self, message: &str);
+    fn level(&self) -> LogLevel;
+}
+
+// Логгер в консоль
+struct ConsoleLogger {
+    level: LogLevel,
+}
+
+impl ConsoleLogger {
+    fn new(level: LogLevel) -> Self {
+        ConsoleLogger { level }
+    }
+}
+
+impl Logger for ConsoleLogger {
+    fn log(&self, message: &str) {
+        println!("[Console] {}", message);
+    }
+
+    fn level(&self) -> LogLevel {
+        self.level
+    }
+}
+
+// Логгер в файл (упрощенная реализация)
+struct FileLogger {
+    level: LogLevel,
+    file_path: String,
+}
+
+impl FileLogger {
+    fn new(level: LogLevel, file_path: &str) -> Self {
+        FileLogger {
+            level,
+            file_path: file_path.to_string(),
+        }
+    }
+}
+
+impl Logger for FileLogger {
+    fn log(&self, message: &str) {
+        println!("[File: {}] {}", self.file_path, message);
+        // В реальной реализации здесь была бы запись в файл
+    }
+
+    fn level(&self) -> LogLevel {
+        self.level
+    }
+}
+
+// Функция для логирования сообщения с проверкой уровня
+fn log_message(logger: &dyn Logger, message: &str) {
+    if logger.level() >= LogLevel::Info {  // Пример: логируем только Info и выше
+        logger.log(message);
+    }
+}
+
+fn main() {
+    // Создаем логгеры
+    let console_logger = Box::new(ConsoleLogger::new(LogLevel::Info));
+    let file_logger = Box::new(FileLogger::new(LogLevel::Debug, "app.log"));
+
+    // Логируем сообщения
+    log_message(&*console_logger, "Application started");
+    log_message(&*file_logger, "Debug information");
+
+    // Сообщение, которое не будет залогировано (уровень ниже Info)
+    log_message(&*console_logger, "Trace information");
+
+    // Динамический выбор логгера
+    let loggers: Vec<Box<dyn Logger>> = vec![
+        Box::new(ConsoleLogger::new(LogLevel::Warn)),
+        Box::new(FileLogger::new(LogLevel::Error, "errors.log")),
+    ];
+
+    for logger in loggers {
+        log_message(&*logger, "Testing logger");
+    }
+}

practice/src/bin/l_event_handler.rs

@@ -0,0 +1,80 @@
+use std::collections::HashMap;
+
+// Определяем типаж обработчика событий
+trait EventHandler {
+    fn handle(&self, event: &str);
+}
+
+// Обработчик для отправки email
+struct EmailHandler;
+
+impl EventHandler for EmailHandler {
+    fn handle(&self, event: &str) {
+        println!("EmailHandler handling event '{}'", event)
+    }
+}
+
+// Обработчик для сохранения в базу данных
+struct DatabaseHandler;
+
+impl EventHandler for DatabaseHandler {
+    fn handle(&self, event: &str) {
+        println!("DatabaseHandler handling event '{}'", event)
+    }
+}
+
+// Обработчик для логирования
+struct LogHandler;
+
+impl EventHandler for LogHandler {
+    fn handle(&self, event: &str) {
+        println!("LogHandler handling event '{}'", event)
+    }
+}
+
+fn main() {
+    // Создаем реестр обработчиков событий
+    let mut handlers: HashMap<String, Box<dyn EventHandler>> = HashMap::new();
+
+    // Регистрируем обработчики
+    handlers.insert("email".to_string(), Box::new(EmailHandler));
+    handlers.insert("database".to_string(), Box::new(DatabaseHandler));
+    handlers.insert("log".to_string(), Box::new(LogHandler));
+
+    // Обрабатываем события
+    if let Some(handler) = handlers.get("email") {
+        handler.handle("New user registration");
+    }
+
+    if let Some(handler) = handlers.get("database") {
+        handler.handle("User data update");
+    }
+
+    // Динамическая обработка нескольких событий
+    let events = vec![
+        ("email", "Password reset requested"),
+        ("database", "Order completed"),
+        ("log", "System started"),
+        ("unknown", "This won't be processed"), // Не будет обработано
+    ];
+
+    for (event_type, event_data) in events {
+        if let Some(handler) = handlers.get(event_type) {
+            handler.handle(event_data);
+        } else {
+            println!("No handler registered for event type: {}", event_type);
+        }
+    }
+
+    // Добавление нового обработчика во время выполнения
+    struct NotificationHandler;
+
+    impl EventHandler for NotificationHandler {
+        fn handle(&self, event: &str) {
+            println!("Sending push notification: '{}'", event);
+        }
+    }
+
+    handlers.insert("notification".to_string(), Box::new(NotificationHandler));
+    handlers["notification"].handle("New message received");
+}

practice/src/main.rs

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

smart-house/README.md

@@ -21,33 +21,33 @@
 Для библиотеки:
 
 - [x] Реализована в виде lib крейта.
-- [ ] Опишите тип: умный термометр. Тип должен предоставлять следующий функционал:
-    - [ ] Конструктор, принимающий значения полей.
-    - [ ] Возвращать значение текущей температуры (произвольное число).
-- [ ] Опишите тип: умная розетка. Тип должен предоставлять следующий функционал:
-    - [ ] Конструктор, принимающий значения полей.
-    - [ ] Включение/выключение + возможность узнать текущее состояние.
-    - [ ] Возвращать текущую мощность: если выключено — ноль, иначе произвольное число.
-- [ ] Опишите тип: умное устройство. Тип должен содержать одно из устройств (умный термометр или розетку) и предоставлять следующий функционал:
-    - [ ] Выводить в стандартный вывод сообщение о состоянии устройства.
-- [ ] Опишите тип: комната, содержащая массив умных устройств. Тип должен предоставлять следующий функционал:
-    - [ ] Конструктор, принимающий массив устройств.
-    - [ ] Можно получить ссылку на устройство по указанному индексу.
-    - [ ] Можно получить мутабельную ссылку на устройство по указанному индексу.
-    - [ ] Выводить в стандартный вывод отчёт о всех устройствах в комнате.
-- [ ] Опишите тип: умный дом, содержащий массив комнат. Тип должен предоставлять следующий функционал:
-    - [ ] Конструктор, принимающий массив комнат.
-    - [ ] Можно получить ссылку на комнату по указанному индексу.
-    - [ ] Можно получить мутабельную ссылку на комнату по указанному индексу.
-    - [ ] Выводить в стандартный вывод отчёт о всех комнатах.
+- [x] Опишите тип: умный термометр. Тип должен предоставлять следующий функционал:
+    - [x] Конструктор, принимающий значения полей.
+    - [x] Возвращать значение текущей температуры (произвольное число).
+- [x] Опишите тип: умная розетка. Тип должен предоставлять следующий функционал:
+    - [x] Конструктор, принимающий значения полей.
+    - [x] Включение/выключение + возможность узнать текущее состояние.
+    - [x] Возвращать текущую мощность: если выключено — ноль, иначе произвольное число.
+- [x] Опишите тип: умное устройство. Тип должен содержать одно из устройств (умный термометр или розетку) и предоставлять следующий функционал:
+    - [x] Выводить в стандартный вывод сообщение о состоянии устройства.
+- [x] Опишите тип: комната, содержащая массив умных устройств. Тип должен предоставлять следующий функционал:
+    - [x] Конструктор, принимающий массив устройств.
+    - [x] Можно получить ссылку на устройство по указанному индексу.
+    - [x] Можно получить мутабельную ссылку на устройство по указанному индексу.
+    - [x] Выводить в стандартный вывод отчёт о всех устройствах в комнате.
+- [x] Опишите тип: умный дом, содержащий массив комнат. Тип должен предоставлять следующий функционал:
+    - [x] Конструктор, принимающий массив комнат.
+    - [x] Можно получить ссылку на комнату по указанному индексу.
+    - [x] Можно получить мутабельную ссылку на комнату по указанному индексу.
+    - [x] Выводить в стандартный вывод отчёт о всех комнатах.
 - Размеры массивов можно выбрать произвольно.
 - В случае, если указан индекс, выходящий за пределы массива, приложение должно аварийно завершаться (макрос `panic!()`).
 
 Для примера использования:
 
-- [ ] Реализована в виде bin крейта.
-- [ ] Создайте экземпляр умного дома и выведете отчёт о его содержимом.
-- [ ] Для уже созданного экземпляра дома выключите умную розетку в одной из комнат. Снова выведите отчёт.
+- [x] Реализована в виде bin крейта.
+- [x] Создайте экземпляр умного дома и выведете отчёт о его содержимом.
+- [x] Для уже созданного экземпляра дома выключите умную розетку в одной из комнат. Снова выведите отчёт.
 
 **Критерии оценки**:
 

smart-house/src/device.rs

@@ -0,0 +1,55 @@
+use std::fmt::Display;
+
+pub enum Device {
+    Thermometer(super::Thermometer),
+    PowerSocket(super::PowerSocket),
+}
+
+impl Device {
+    pub fn display(&self) -> impl Display {
+        match self {
+            Device::Thermometer(thermometer) => {
+                format!("DEV:{}", thermometer.display())
+            }
+            Device::PowerSocket(power_socket) => {
+                format!("DEV:{}", power_socket.display())
+            }
+        }
+    }
+
+    pub fn print_status(&self) {
+        println!("{}", self.display());
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{PowerSocket, Thermometer};
+
+    #[test]
+    fn smoke_test() {
+        let dev_thermometer = Device::Thermometer(Thermometer::new(20.1));
+        let dev_power_socket = Device::PowerSocket(PowerSocket::new(11.2, false));
+
+        dev_thermometer.print_status();
+        dev_power_socket.print_status();
+
+        let Device::Thermometer(thermometer) = dev_thermometer else { unreachable!() };
+        let Device::PowerSocket(power_socket) = dev_power_socket else {
+            unreachable!()
+        };
+
+        assert_eq!(format!("{}", thermometer.display()), "Thermometer[ 20.1 ]");
+        assert_eq!(format!("{}", power_socket.display()), "PowerSocket[ OFF : 0.0 ]");
+    }
+
+    #[test]
+    fn display_test() {
+        let dev_thermometer = Device::Thermometer(Thermometer::new(20.1));
+        let dev_power_socket = Device::PowerSocket(PowerSocket::new(11.2, false));
+
+        assert_eq!(format!("{}", dev_thermometer.display()), "DEV:Thermometer[ 20.1 ]");
+        assert_eq!(format!("{}", dev_power_socket.display()), "DEV:PowerSocket[ OFF : 0.0 ]");
+    }
+}

smart-house/src/house.rs

@@ -0,0 +1,91 @@
+use crate::Room;
+
+pub struct House {
+    address: String,
+    rooms: Box<[Room]>,
+}
+
+impl House {
+    pub fn new(address: impl AsRef<str>, rooms: Box<[Room]>) -> Self {
+        Self {
+            address: address.as_ref().to_string(),
+            rooms,
+        }
+    }
+
+    fn check_bounds(&self, idx: usize) {
+        if idx >= self.rooms.len() {
+            panic!("Index is out of bounds")
+        }
+    }
+
+    pub fn get_room(&self, idx: usize) -> &Room {
+        self.check_bounds(idx);
+        &self.rooms[idx]
+    }
+
+    pub fn get_room_mut(&mut self, idx: usize) -> &mut Room {
+        self.check_bounds(idx);
+        &mut self.rooms[idx]
+    }
+
+    pub fn print_status(&self) {
+        println!("HOUSE '{}':", self.address);
+        println!("{}", "=".repeat(32));
+        for d in self.rooms.iter() {
+            d.print_status();
+            println!();
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{Device, PowerSocket, Thermometer};
+
+    fn create_test_house() -> House {
+        House::new(
+            "Best street, 777",
+            Box::new([
+                Room::new(
+                    "main",
+                    Box::new([
+                        Device::Thermometer(Thermometer::new(20.0)),
+                        Device::PowerSocket(PowerSocket::new(12.34, false)),
+                        Device::PowerSocket(PowerSocket::new(10.01, true)),
+                    ]),
+                ),
+                Room::new(
+                    "bedroom",
+                    Box::new([Device::PowerSocket(PowerSocket::new(11.11, true)), Device::Thermometer(Thermometer::new(17.99))]),
+                ),
+            ]),
+        )
+    }
+
+    #[test]
+    fn smoke_test() {
+        let mut house = create_test_house();
+        house.print_status();
+        assert_eq!(house.address, "Best street, 777");
+
+        assert_eq!(format!("{}", house.get_room(0).get_device(0).display()), "DEV:Thermometer[ 20.0 ]");
+        assert_eq!(format!("{}", house.get_room(0).get_device(1).display()), "DEV:PowerSocket[ OFF : 0.0 ]");
+        assert_eq!(format!("{}", house.get_room(1).get_device(0).display()), "DEV:PowerSocket[ ON : 11.1 ]");
+
+        let Device::PowerSocket(powers_socket) = house.get_room_mut(0).get_device_mut(1) else {
+            unreachable!()
+        };
+        powers_socket.set_on(true);
+
+        assert_eq!(format!("{}", house.get_room(0).get_device(1).display()), "DEV:PowerSocket[ ON : 12.3 ]");
+    }
+
+    #[test]
+    #[should_panic(expected = "Index is out of bounds")]
+    fn panic_test() {
+        let house = create_test_house();
+        house.check_bounds(2);
+    }
+}

smart-house/src/lib.rs

@@ -1 +1,11 @@
+mod device;
+mod house;
+mod power_socket;
+mod room;
+mod thermometer;
 
+pub use device::Device;
+pub use house::House;
+pub use power_socket::PowerSocket;
+pub use room::Room;
+pub use thermometer::Thermometer;

smart-house/src/main.rs

@@ -1 +1,38 @@
-fn main() {}
+use smart_house::{Device, House, PowerSocket, Room, Thermometer};
+
+fn main() {
+    let mut house = House::new(
+        "A house of dream",
+        Box::new([
+            Room::new(
+                "Hall",
+                Box::new([Device::PowerSocket(PowerSocket::new(9.5, true)), Device::Thermometer(Thermometer::new(20.1))]),
+            ),
+            Room::new(
+                "Main",
+                Box::new([
+                    Device::PowerSocket(PowerSocket::new(11.2, true)),
+                    Device::Thermometer(Thermometer::new(24.5)),
+                    Device::PowerSocket(PowerSocket::new(10.4, true)),
+                ]),
+            ),
+            Room::new(
+                "Bedroom",
+                Box::new([Device::Thermometer(Thermometer::new(19.3)), Device::PowerSocket(PowerSocket::new(12.1, true))]),
+            ),
+        ]),
+    );
+
+    house.print_status();
+
+    print!("# Switching off a power socket in Hall... ");
+    let Device::PowerSocket(power_socket) = house.get_room_mut(0).get_device_mut(0) else {
+        println!("FAILED!");
+        return;
+    };
+    power_socket.set_on(false);
+    println!("SUCCESS");
+    println!();
+
+    house.print_status();
+}

smart-house/src/power_socket.rs

@@ -0,0 +1,54 @@
+use std::fmt::Display;
+
+pub struct PowerSocket {
+    power_rate: f32,
+    on: bool,
+}
+
+impl PowerSocket {
+    pub fn new(power_rate: f32, on: bool) -> Self {
+        Self { power_rate, on }
+    }
+
+    pub fn is_on(&self) -> bool {
+        self.on
+    }
+
+    pub fn set_on(&mut self, on: bool) {
+        self.on = on
+    }
+
+    pub fn get_power(&self) -> f32 {
+        if self.on { self.power_rate } else { 0.0 }
+    }
+
+    pub fn display(&self) -> impl Display {
+        let state = if self.is_on() { "ON" } else { "OFF" };
+        format!("PowerSocket[ {} : {:02.1} ]", state, self.get_power())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn smoke_test() {
+        let mut power_socket = PowerSocket::new(12.4, false);
+        assert_eq!(power_socket.power_rate, 12.4);
+        assert!(!power_socket.on);
+        assert!(!power_socket.is_on());
+        assert_eq!(power_socket.get_power(), 0.0);
+
+        power_socket.set_on(true);
+        assert!(power_socket.is_on());
+        assert_eq!(power_socket.get_power(), 12.4);
+    }
+
+    #[test]
+    fn display_test() {
+        assert_eq!(format!("{}", PowerSocket::new(11.549, false).display()), "PowerSocket[ OFF : 0.0 ]");
+        assert_eq!(format!("{}", PowerSocket::new(11.549, true).display()), "PowerSocket[ ON : 11.5 ]");
+        assert_eq!(format!("{}", PowerSocket::new(11.550, true).display()), "PowerSocket[ ON : 11.6 ]");
+    }
+}

smart-house/src/room.rs

@@ -0,0 +1,80 @@
+use crate::Device;
+
+pub struct Room {
+    name: String,
+    devices: Box<[Device]>,
+}
+
+impl Room {
+    pub fn new(name: impl AsRef<str>, devices: Box<[Device]>) -> Self {
+        Self {
+            name: name.as_ref().to_string(),
+            devices,
+        }
+    }
+
+    fn check_bounds(&self, idx: usize) {
+        if idx >= self.devices.len() {
+            panic!("Index is out of bounds")
+        }
+    }
+
+    pub fn get_device(&self, idx: usize) -> &Device {
+        self.check_bounds(idx);
+        &self.devices[idx]
+    }
+
+    pub fn get_device_mut(&mut self, idx: usize) -> &mut Device {
+        self.check_bounds(idx);
+        &mut self.devices[idx]
+    }
+
+    pub fn print_status(&self) {
+        println!("ROOM '{}':", self.name);
+        println!("{}", "-".repeat(24));
+        for d in self.devices.iter() {
+            d.print_status();
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{PowerSocket, Thermometer};
+
+    #[test]
+    fn smoke_test() {
+        let devices = Box::new([
+            Device::PowerSocket(PowerSocket::new(12.34, false)),
+            Device::Thermometer(Thermometer::new(21.56)),
+        ]);
+        let mut room = Room::new("test_room", devices);
+        assert_eq!(room.name, "test_room");
+        room.print_status();
+
+        assert_eq!(format!("{}", room.get_device(0).display()), "DEV:PowerSocket[ OFF : 0.0 ]");
+        assert_eq!(format!("{}", room.get_device(1).display()), "DEV:Thermometer[ 21.6 ]");
+
+        let Device::PowerSocket(power_socket) = room.get_device_mut(0) else {
+            unreachable!()
+        };
+        power_socket.set_on(true);
+
+        assert_eq!(format!("{}", room.get_device(0).display()), "DEV:PowerSocket[ ON : 12.3 ]");
+        assert_eq!(format!("{}", room.get_device(1).display()), "DEV:Thermometer[ 21.6 ]");
+    }
+
+    #[test]
+    #[should_panic(expected = "Index is out of bounds")]
+    fn panic_test() {
+        let room = Room::new(
+            "test_room",
+            Box::new([
+                Device::PowerSocket(PowerSocket::new(12.34, false)),
+                Device::Thermometer(Thermometer::new(21.56)),
+            ]),
+        );
+        room.check_bounds(2);
+    }
+}

smart-house/src/thermometer.rs

@@ -0,0 +1,37 @@
+use std::fmt::Display;
+
+pub struct Thermometer {
+    temperature: f32,
+}
+
+impl Thermometer {
+    pub fn new(temperature: f32) -> Self {
+        Self { temperature }
+    }
+
+    pub fn get_temperature(&self) -> f32 {
+        self.temperature
+    }
+
+    pub fn display(&self) -> impl Display {
+        format!("Thermometer[ {:02.1} ]", self.get_temperature())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn smoke_test() {
+        let thermometer = Thermometer::new(20.0);
+        assert_eq!(thermometer.temperature, 20.0);
+        assert_eq!(thermometer.get_temperature(), 20.0);
+    }
+
+    #[test]
+    fn display_test() {
+        assert_eq!(format!("{}", Thermometer::new(19.550).display()), "Thermometer[ 19.5 ]");
+        assert_eq!(format!("{}", Thermometer::new(19.551).display()), "Thermometer[ 19.6 ]");
+    }
+}