use std::io;
fn read_number(prompt: &str) -> f64 {
println!("{}", prompt);
let mut input = String::new();
io::stdin().read_line(&mut input).unwrap();
input.trim().parse().unwrap()
}
fn main() {
let a = read_number("Введите первое число:");
let b = read_number("Введите второе число:");
println!("Результат: {}", a + b);
}
use std::io;
fn main() {
println!("--- Простой калькулятор (сложение) ---");
println!("Введите первое число:");
let mut input1 = String::new();
io::stdin().read_line(&mut input1).expect("Ошибка чтения");
let num1: f64 = input1.trim().parse().expect("Это не число");
println!("Введите второе число:");
let mut input2 = String::new();
io::stdin().read_line(&mut input2).expect("Ошибка чтения");
let num2: f64 = input2.trim().parse().expect("Это не число");
let result = num1 + num2;
println!("Результат: {} + {} = {}", num1, num2, result);
}
use std::io;
fn read_number(prompt: &str) -> f64 {
println!("{}", prompt);
let mut input = String::new();
io::stdin()
.read_line(&mut input)
.expect("Ошибка чтения");
input
.trim()
.parse()
.expect("Это не число")
}
fn main() {
println!("--- Простой калькулятор (сложение) ---");
let num1 = read_number("Введите первое число:");
let num2 = read_number("Введите второе число:");
let result = num1 + num2;
println!("Результат: {} + {} = {}", num1, num2, result);
}
use std::io;
fn main() {
println!("=== Простой калькулятор на Rust ===");
println!("Для выхода введите 'q' или оставьте строку пустой\n");
loop {
// Читаем первое число
let num1 = match read_number("Введите первое число (или q для выхода):") {
Some(n) => n,
None => break,
};
// Читаем оператор
let operator = read_operator();
// Читаем второе число
let num2 = match read_number("Введите второе число:") {
Some(n) => n,
None => continue,
};
// Выполняем вычисление
match calculate(num1, &operator, num2) {
Ok(result) => {
println!("Результат: {} {} {} = {:.4}", num1, operator, num2, result);
}
Err(msg) => println!("Ошибка: {}", msg),
}
// Исправленная строка-разделитель
println!("{}", "─".repeat(40));
}
println!("До свидания! 👋");
}
// ====================== ФУНКЦИИ ======================
fn read_number(prompt: &str) -> Option<f64> {
loop {
println!("{}", prompt);
let mut input = String::new();
if io::stdin().read_line(&mut input).is_err() {
println!("Ошибка чтения ввода!");
continue;
}
let input = input.trim();
if input.eq_ignore_ascii_case("q") || input.is_empty() {
return None;
}
match input.parse::<f64>() {
Ok(num) => return Some(num),
Err(_) => println!("Ошибка: введите корректное число!"),
}
}
}
fn read_operator() -> String {
loop {
println!("Введите оператор (+, -, *, /):");
let mut input = String::new();
if io::stdin().read_line(&mut input).is_err() {
continue;
}
let op = input.trim();
if matches!(op, "+" | "-" | "*" | "/") {
return op.to_string();
} else {
println!("Ошибка: допустимы только +, -, *, /");
}
}
}
fn calculate(a: f64, op: &str, b: f64) -> Result<f64, String> {
match op {
"+" => Ok(a + b),
"-" => Ok(a - b),
"*" => Ok(a * b),
"/" => {
if b == 0.0 {
Err("Деление на ноль!".to_string())
} else {
Ok(a / b)
}
}
_ => Err("Неизвестный оператор".to_string()),
}
}
use rand::Rng;
use rand::RngExt;
// Генерация случайного числа
fn random_number(min: f64, max: f64) -> f64 {
let mut rng = rand::rng();
rng.random_range(min..max)
}
fn main() {
const PI: f64 = 3.14;
let radius = random_number(1.0, 10.0);
let pipe_thickness = random_number(1.0, 10.0);
println!("Внутренний радиус = {}, Толщина стенки цилиндра = {}", radius, pipe_thickness);
println!("================");
println!("Внешний радиус: {}", radius + pipe_thickness);
println!("Внутренний периметр цилиндра: {}", 2.0 * PI * radius);
}
// =============================================================================
// КОМПАКТНАЯ УЧЕБНАЯ ПРОГРАММА: МОДЕЛИРОВАНИЕ ОРБИТАЛЬНОГО МАНЕВРА
// =============================================================================
// 1. ДЕМОНСТРАЦИЯ: const (Константа)
// Ускорение свободного падения для расчета удельного импульса
const G0: f64 = 9.81;
// 2. ДЕМОНСТРАЦИЯ: функции (Расчет расхода топлива в кг/с)
fn calculate_fuel_flow(thrust: f64, isp: f64) -> f64 {
thrust / (isp * G0) // Возврат значения выражением (без return и `;`)
}
// Вспомогательная функция классификации двигателя
fn get_engine_class(thrust: f64) -> &'static str {
// 3. ДЕМОНСТРАЦИЯ: if else if else
if thrust < 10.0 {
"Маломощный"
} else if thrust < 100.0 {
"Стандартный"
} else {
"Мощный"
}
}
fn main() {
println!("--- СИСТЕМА УПРАВЛЕНИЯ МАНЕВРОМ ---");
// 4. ДЕМОНСТРАЦИЯ: let (Неизменяемые переменные)
let thrust = 25.0; // Тяга двигателя (Н)
let specific_impulse = 290.0; // Удельный импульс (с)
// 5. ДЕМОНСТРАЦИЯ: let mut (Изменяемая переменная — бак теперь пустеет!)
let mut fuel_mass = 120.0; // Запас топлива (кг)
// Расчет расхода топлива через функцию
let fuel_flow = calculate_fuel_flow(thrust, specific_impulse);
// 6. ДЕМОНСТРАЦИЯ: цикл for (Симуляция 5-секундного маневра шаг за шагом)
println!("\n[Запуск двигателя. Длительность маневра: 5 секунд]");
for second in 1..=5 {
// Уменьшаем реальный запас топлива в баке каждую секунду
fuel_mass -= fuel_flow;
println!("Секунда {}: топливо сгорает... Остаток: {:.4} кг", second, fuel_mass);
}
// 7. ДЕМОНСТРАЦИЯ: цикл while (Откачка остатков газов из магистрали после отключения)
let mut purge_time = 0.0;
while purge_time < 3.0 {
purge_time += 1.0;
}
println!("[Двигатель отключен. Продувка системы... Готово за {} с]", purge_time);
// 8. ДЕМОНСТРАЦИЯ: цикл loop и break (Поиск резервного времени работы на остатках)
let mut emergency_time = 0.0;
loop {
// Проверяем, хватит ли остатка топлива еще на один шаг
if fuel_mass < fuel_flow {
break; // 9. ДЕМОНСТРАЦИЯ: break (Выход из бесконечного цикла, если бак пуст)
}
fuel_mass -= fuel_flow;
emergency_time += 1.0;
}
println!("[Анализ ЧС]: Дополнительный аварийный резерв работы: {} с", emergency_time);
// 10. ДЕМОНСТРАЦИЯ: затенение переменных (Variable Shadowing)
// Переводим оставшуюся массу из кг в тонны для финального отчета
let fuel_mass = fuel_mass / 1000.0;
println!("\nФинальный остаток топлива в тоннах: {:.6} т", fuel_mass);
// Превращаем тонны обратно в кг для логики ветвления (снова затенение)
let fuel_mass = fuel_mass * 1000.0;
// 11. ДЕМОНСТРАЦИЯ: if как выражение (Тернарный аналог в Rust)
let status = if fuel_mass > 10.0 {
"Маневр успешен. Корабль на заданной орбите."
} else {
"Внимание! Критический остаток топлива!"
};
println!("Статус миссии: {}", status);
// 12. ДЕМОНСТРАЦИЯ: простой if и if else
if thrust > 20.0 {
println!("Уведомление: Стабилизация курса выполнена штатно.");
} else {
println!("Уведомление: Требуется более длительный импульс.");
}
// 13. ДЕМОНСТРАЦИЯ: match (Сопоставление с образцом на основе класса двигателя)
match get_engine_class(thrust) {
"Маломощный" => println!("Конфигурация: Подходит для точной ориентации спутников."),
"Стандартный" => println!("Конфигурация: Оптимально для большинства легких кораблей."),
_ => println!("Конфигурация: Требуется усиленная термозащита корпуса."),
}
println!("-----------------------------------");
}
// =============================================================================
// УПРОЩЕННАЯ УЧЕБНАЯ ПРОГРАММА: МОДЕЛИРОВАНИЕ РАСХОДА ТОПЛИВА
// =============================================================================
// Простая функция для расчета секундного расхода топлива.
// Принимает тягу двигателя и качество его настройки (эффективность).
fn calculate_flow(thrust: f64, efficiency: f64) -> f64 {
thrust / efficiency
}
fn main() {
println!("--- СИМУЛЯЦИЯ РАБОТЫ ДВИГАТЕЛЯ ---");
// 1. НЕИЗМЕНЯЕМЫЕ ПЕРЕМЕННЫЕ (let)
// Эти значения не меняются на протяжении всей работы
let thrust = 20.0; // Тяга двигателя (в Ньютонах)
let efficiency = 250.0; // Эффективность двигателя
// Расчет секундного расхода топлива с помощью нашей функции
let fuel_flow = calculate_flow(thrust, efficiency);
println!("Расход топлива в секунду: {} кг/с", fuel_flow);
// 2. ИЗМЕНЯЕМАЯ ПЕРЕМЕННАЯ (let mut)
// Масса топлива в баке будет уменьшаться, поэтому нужен mut
let mut fuel_mass = 50.0; // Стартовый запас топлива (в кг)
// Переменная-счетчик для учета времени работы двигателя
let mut seconds_passed = 0;
// 3. ОБЫЧНЫЙ ЦИКЛ (while)
// Работаем, пока в баке есть топливо (больше нуля)
println!("\n[Запуск двигателя. Симуляция до полного опустошения бака]");
while fuel_mass > 0.0 {
// Уменьшаем запас топлива на величину секундного расхода
fuel_mass = fuel_mass - fuel_flow;
// Увеличиваем счетчик времени на 1 секунду
seconds_passed = seconds_passed + 1;
println!("Секунда {}: остаток топлива: {:.2} кг", seconds_passed, fuel_mass);
}
println!("\n[Двигатель заглох. Время работы: {} с]", seconds_passed);
// 4. ОБЫЧНОЕ УСЛОВИЕ (if / else)
// Проверяем, хватило ли времени работы для успешного маневра
// Допустим, для выхода на нужную орбиту двигатель должен был отработать 500 секунд
if seconds_passed >= 500 {
println!("Статус: Успех! Корабль успешно вышел на заданную орбиту.");
} else {
println!("Статус: Отказ! Не хватило топлива для завершения маневра.");
}
println!("-----------------------------------");
}