289 lines
10 KiB
Rust
289 lines
10 KiB
Rust
// ============================================================
|
||
// Rust 基础巩固练习 (变量类型 + 流程控制)
|
||
// 在做完所有题目之前，建议先注释掉 main 函数中的代码，
|
||
// 每题单独写一个函数来测试，然后在 main 中调用。
|
||
// ============================================================
|
||
|
||
fn main() {
|
||
println!("Hello, world!");
|
||
// ex1_variables();
|
||
// ex2_scalar_types();
|
||
// ex3_compound_types();
|
||
// ex4_functions();
|
||
// ex5_control_flow();
|
||
// ex6_loops();
|
||
mini_guessing_game();
|
||
// ex8_stats();
|
||
}
|
||
|
||
// ============================================================
|
||
// 练习1：变量与可变性
|
||
// ============================================================
|
||
// 1. 声明一个不可变变量 x = 10，尝试修改它为 20（看编译器报什么错），
|
||
// 然后把报错的那行注释掉。
|
||
// 2. 声明一个可变变量 y = 5，然后将它修改为 15，打印修改前后的值。
|
||
// 3. 使用 let 遮蔽（shadowing）：声明变量 z = "hello"，
|
||
// 然后用 let 再次声明 z，将其值改为 z.len()（即字符串长度），
|
||
// 再用 let 声明 z，将其值改为 z * 2。打印每次遮蔽后的值。
|
||
#[allow(dead_code)]
|
||
fn ex1_variables() {
|
||
// TODO: 在这里写你的代码
|
||
let x = 10;
|
||
// error: could not compile `part2` (bin "part2") due to 1 previous error; 10 warnings emitted
|
||
// x = 20;
|
||
let mut y = 5;
|
||
println!("修改前:{}", y);
|
||
y = 15;
|
||
println!("修改后:{}", y);
|
||
|
||
let z = "hello";
|
||
println!("z:{}", z);
|
||
let z = z.len();
|
||
println!("z:{}", z);
|
||
let z = z * 2;
|
||
println!("z:{}", z);
|
||
}
|
||
|
||
// ============================================================
|
||
// 练习2：基本数据类型
|
||
// ============================================================
|
||
// 1. 声明 u8, i32, f64, bool, char 类型的变量各一个，赋予合理的值。
|
||
// 2. 使用 as 关键字将 u8 转换为 i32，将 f64 转换为 i32（观察小数部分被截断）。
|
||
// 3. 打印字符 char 的数值表示（用 as u32）。
|
||
// 4. 声明一个 usize 变量 = 5，让它减去 10（观察 underflow 的编译报错或用 wrapping_sub）。
|
||
#[allow(dead_code)]
|
||
fn ex2_scalar_types() {
|
||
// TODO: 在这里写你的代码
|
||
let u8_var: u8 = 42;
|
||
let i32_var: i32 = 128;
|
||
let f64_var: f64 = 3.14;
|
||
let bool_var: bool = true;
|
||
let char_var = '2';
|
||
|
||
println!("u8 as i32: {}", u8_var as i32);
|
||
println!("f64 as i32: {}", f64_var as i32);
|
||
println!("char as u32: {}", char_var as u32);
|
||
|
||
let usize_var: usize = 5;
|
||
// error: usize_var - 10: attempt to compute `5_usize - 10_usize`, which would overflow
|
||
// usize_var.wrapping_sub(10): 18446744073709551611
|
||
println!("usize_var - 10: {}", usize_var.wrapping_sub(10));
|
||
}
|
||
|
||
// ============================================================
|
||
// 练习3：复合类型 —— 元组 (Tuple) 和数组 (Array)
|
||
// ============================================================
|
||
// 1. 声明一个元组 tup: (i32, f64, &str) = (42, 3.14, "rust")，
|
||
// 分别用解构和 .索引 两种方式取出并打印三个元素。
|
||
// 2. 声明一个数组 arr: [i32; 5] = [1, 2, 3, 4, 5]，
|
||
// 用 for 循环遍历打印每个元素，打印数组长度。
|
||
// 3. 尝试访问 arr[10]，观察编译报错 vs 运行时 panic 的区别——
|
||
// 先用常量索引（编译期检查），再用变量索引（运行期检查）。
|
||
#[allow(dead_code)]
|
||
fn ex3_compound_types() {
|
||
// TODO: 在这里写你的代码
|
||
let tup: (i32, f64, &str) = (42, 3.14, "rust");
|
||
let (a, b, c) = tup;
|
||
println!("tup: {}, {}, {}", a, b, c);
|
||
let a1 = tup.0;
|
||
let b1 = tup.1;
|
||
let c1 = tup.2;
|
||
println!("tup: {}, {}, {}", a1, b1, c1);
|
||
let arr: [i32; 5] = [1, 2, 3, 4, 5];
|
||
for i in 0..arr.len() {
|
||
println!("arr[{}]: {}", i, arr[i]);
|
||
}
|
||
println!("arr length: {}", arr.len());
|
||
// arr[10]; error: index out of bounds: the len is 5 but the index is 10
|
||
}
|
||
|
||
// ============================================================
|
||
// 练习4：函数定义与调用
|
||
// ============================================================
|
||
// 1. 写一个函数 add(a: i32, b: i32) -> i32，返回两数之和，在 main 中调它。
|
||
// 2. 写一个函数 factorial(n: u32) -> u32，用循环计算 n 的阶乘。
|
||
// 提示：n! = 1 × 2 × 3 × ... × n，0! = 1
|
||
// 3. 写一个函数 is_even(n: i32) -> bool，判断一个数是否为偶数。
|
||
// 4. 写一个无返回值的函数 greet(name: &str)，打印 "你好，{name}！"。
|
||
#[allow(dead_code)]
|
||
fn add(a: i32, b: i32) -> i32 {
|
||
a + b
|
||
}
|
||
|
||
#[allow(dead_code)]
|
||
fn factorial(n: u32) -> u32 {
|
||
let mut result = 1;
|
||
for i in 1..=n {
|
||
result *= i;
|
||
}
|
||
result
|
||
}
|
||
|
||
#[allow(dead_code)]
|
||
fn is_even(n: i32) -> bool {
|
||
n % 2 == 0
|
||
}
|
||
|
||
#[allow(dead_code)]
|
||
fn greet(name: &str) {
|
||
// TODO
|
||
println!("你好，{}！", name)
|
||
}
|
||
|
||
fn ex4_functions() {
|
||
// 在这里调用上面四个函数进行测试
|
||
println!("add(1, 2): {}", add(1, 2));
|
||
println!("factorial(5): {}", factorial(5));
|
||
println!("is_even(5): {}", is_even(5));
|
||
greet("Rust");
|
||
}
|
||
|
||
// ============================================================
|
||
// 练习5：控制流 —— if / else if / else
|
||
// ============================================================
|
||
// 1. 写一个函数 grade(score: u32) -> &'static str，根据分数返回等级：
|
||
// 90-100 → "A", 80-89 → "B", 70-79 → "C", 60-69 → "D", 0-59 → "F"
|
||
// 2. 写一个函数 fizzbuzz(n: u32)，打印 1 到 n：
|
||
// 能被 3 整除打印 "Fizz"，能被 5 整除打印 "Buzz"，
|
||
// 能同时被 3 和 5 整除打印 "FizzBuzz"，否则打印数字本身。
|
||
// 3. 使用 if 作为表达式（let x = if ... { ... } else { ... };），
|
||
// 根据一个 bool 变量给另一个变量赋不同的值。
|
||
#[allow(dead_code)]
|
||
fn grade(score: u32) -> &'static str {
|
||
let mut x = "";
|
||
if score >= 90 && score <= 100 {
|
||
x = "A";
|
||
} else if score >= 80 && score < 90 {
|
||
x = "B";
|
||
} else if score >= 70 && score < 80 {
|
||
x = "C";
|
||
} else if score >= 60 && score < 70 {
|
||
x = "D";
|
||
} else {
|
||
x = "F";
|
||
};
|
||
return x;
|
||
}
|
||
|
||
#[allow(dead_code)]
|
||
fn fizzbuzz(n: u32) {
|
||
for i in (1..=n) {
|
||
if i % 3 == 0 && i % 5 == 0 {
|
||
println!("FizzBuzz")
|
||
} else if i % 3 == 0 {
|
||
println!("Fizz")
|
||
} else if i % 5 == 0 {
|
||
println!("Buzz")
|
||
} else {
|
||
println!("{}", i)
|
||
}
|
||
}
|
||
}
|
||
|
||
fn ex5_control_flow() {
|
||
// 在这里测试
|
||
let score = 89;
|
||
let condition = true;
|
||
let n = if condition { 100 } else { 50 };
|
||
println!("grade：{}", grade(score));
|
||
fizzbuzz(n);
|
||
}
|
||
|
||
// ============================================================
|
||
// 练习6：循环 —— loop / while / for
|
||
// ============================================================
|
||
// 1. 用 loop 写一个无限循环，内部用计数器从 1 开始累加，
|
||
// 当计数达到 100 时用 break 退出，并用 break 返回值打印最终结果。
|
||
// 2. 用 while 循环打印 10 到 1 的倒数。
|
||
// 3. 用 for 循环遍历一个数组 [10, 20, 30, 40, 50]，打印每个元素及其索引。
|
||
// 提示：用 .iter().enumerate()
|
||
// 4. 用 for 循环配合 Range：打印 1..=5 的每个数的平方。
|
||
#[allow(dead_code)]
|
||
fn ex6_loops() {
|
||
// TODO: 在这里写你的代码
|
||
let mut sum = 0;
|
||
let mut i = 1;
|
||
let result = loop {
|
||
sum += i;
|
||
if i == 100 {
|
||
break sum;
|
||
};
|
||
i += 1;
|
||
};
|
||
println!("sum: {}", result);
|
||
|
||
let mut i = 10;
|
||
while i > 0 {
|
||
println!("倒数: {}", i);
|
||
i -= 1;
|
||
}
|
||
|
||
let arr = [10, 20, 30, 40, 50];
|
||
for (i, item) in arr.iter().enumerate() {
|
||
println!("index: {}, value: {}", i, item);
|
||
}
|
||
|
||
for i in 1..=5 {
|
||
println!("{} 的平方是 {}", i, i * i);
|
||
}
|
||
}
|
||
|
||
// ============================================================
|
||
// 练习7（综合）：猜数字游戏简化版
|
||
// ============================================================
|
||
// 写一个函数 mini_guessing_game()，模拟一个简化的猜数字游戏：
|
||
// - 设定一个固定的秘密数字（比如 42）
|
||
// - 用一个数组 [10, 50, 35, 60, 42] 模拟玩家的猜数字序列
|
||
// - 遍历数组，对每次猜测判断：
|
||
// - 猜小了 → 打印 "{} 太小了！"
|
||
// - 猜大了 → 打印 "{} 太大了！"
|
||
// - 猜对了 → 打印 "{} 猜对了！" 并退出循环
|
||
// 提示：for + if/else + break
|
||
#[allow(dead_code)]
|
||
fn mini_guessing_game() {
|
||
// TODO: 在这里写你的代码
|
||
let secret_number = 62;
|
||
let guesses: [i32; 5] = [10, 50, 35, 60, 42];
|
||
|
||
for (i, guess) in guesses.iter().enumerate() {
|
||
if guess < &secret_number {
|
||
println!("第{}次猜测，{} 太小了！", i + 1, guess);
|
||
} else if guess > &secret_number {
|
||
println!("第{}次猜测，{} 太大了！", i + 1, guess);
|
||
} else {
|
||
println!("第{}次猜测，{} 猜对了！", i + 1, guess);
|
||
break;
|
||
};
|
||
}
|
||
}
|
||
|
||
// ============================================================
|
||
// 练习8（综合）：统计字符串中的字母
|
||
// ============================================================
|
||
// 写一个函数 count_letters(s: &str) -> (u32, u32)，接收一个字符串切片，
|
||
// 统计其中大写字母和小写字母的数量，以元组形式返回。
|
||
// - 提示1：用 .chars() 获取字符迭代器
|
||
// - 提示2：用 char::is_uppercase() 和 char::is_lowercase() 判断
|
||
// - 提示3：在 ex8_stats 中调用这个函数，用两个不同的字符串测试
|
||
#[allow(dead_code)]
|
||
fn count_letters(s: &str) -> (u32, u32) {
|
||
// TODO
|
||
let chars = s.chars();
|
||
let tup: (u32, u32) = (0, 0);
|
||
let (mut upper, mut lower) = tup;
|
||
for c in chars {
|
||
if c.is_uppercase() {
|
||
upper += 1;
|
||
} else if c.is_lowercase() {
|
||
lower += 1;
|
||
}
|
||
}
|
||
(upper, lower)
|
||
}
|
||
|
||
fn ex8_stats() {
|
||
// 在这里测试 count_letters
|
||
let (upper, lower) = count_letters("Hello, World!");
|
||
println!("大写字母数量：{}，小写字母数量：{}", upper, lower);
|
||
}
|