rust-强化练习

钓鱼不打窝，钓的也不多

语言只靠看不行，还得练，下面是AI生成的一些题目，后续直接肝LeeCode,一举2得

1、猜数字

描述：创建一个简单的猜数字游戏，程序会随机生成一个数字，玩家需要猜出这个数字是多少。程序会给出提示，告诉玩家猜的数字是大了还是小了

use std::cmp::Ordering;
use std::io::stdin;
use rand::{Rng};
fn main() {
    'outer: loop {
        let rand_number = rand::thread_rng().gen_range(1..=100);
        loop {
            println!("please input one number:");
            let mut guess = String::new();
            stdin()
                .read_line(&mut guess).expect("error");
            let number = match guess.trim().parse::<i32>() {
                Ok(num) => num,
                Err(_) => {
                    println!("please input number");
                    continue;
                }
            };
            match number.cmp(&rand_number) {
                Ordering::Less => {
                    println!("too small")
                }
                Ordering::Equal => {
                    println!("you win current number is {}", rand_number);
                    break;
                }
                Ordering::Greater => {
                    println!("too big")
                }
            }
        }
        println!("you can choose 'y' to continue ");
        let mut flag = String::new();
        stdin()
            .read_line(&mut flag).expect("input error");
        if !flag.trim().eq("y") { break 'outer; }
    }
    println!("game over!")
}

2、计算器

描述：编写一个简单的计算器程序，支持加法、减法、乘法和除法运算。用户输入两个数字和一个操作符，程序输出运算结果。

use std::io::stdin;
use std::str::FromStr;

/**
 描述：编写一个简单的计算器程序，支持加法、减法、乘法和除法运算。用户输入两个数字和一个操作符，程序输出运算结果。
 */

fn main() {
    loop {
        //  输入数字
        let mut input_number = String::new();
        stdin().read_line(&mut input_number).expect("input error");
        let number = parse_number(&input_number);

        // 输入运算符
        let mut operator = String::new();
        stdin().read_line(&mut operator).expect("input error");

        // 输入数字2
        let mut input_number = String::new();
        stdin().read_line(&mut input_number).expect("input error");
        let number2 = parse_number(&input_number);

        // 计算
        match (number, number2) {
            (Ok(n1), Ok(n2)) => {
                match calculate(n1, n2, &operator) {
                    Ok(data) => println!("{}{}{}={}", n1, operator.trim(), n2, data),
                    Err(e) => println!("calc error {}", e)
                }
            }
            _ => println!("source number is none")
        }

        println!("you can choose 'n' to end ");
        let mut flag = String::new();
        stdin().read_line(&mut flag).expect("input error");
        if flag.trim().eq("n") {
            break;
        }
    }
}

/**
 * 数据计算
 */
fn calculate(number: f32, number2: f32, operator: &str) -> Result<f32, &str> {
    match operator.trim() {
        "+" => Ok(number + number2),
        "-" => Ok(number - number2),
        "*" => Ok(number * number2),
        "/" => {
            if number2.abs() > f32::EPSILON {
                Ok(number / number2)
            } else {
                Err("denominator should not be zero")
            }
        }
        _ => Err("unsupported")
    }
}

/**
 * 转换数字
 */
fn parse_number<T: FromStr>(s: &str) -> Result<T, T::Err> {
    s.trim().parse::<T>()
}

3、单词计数器

描述：编写一个程序，统计给定字符串中每个单词出现的次数。忽略大小写，输出结果按照单词出现次数从高到低排序。

代码还能优化一下

use std::collections::HashMap;
use std::io::stdin;
fn main() {
    //  输入数字
    let mut map = HashMap::new();
    let mut input_string = String::new();
    stdin().read_line(&mut input_string).expect("input error");
    // 统计每个单词的出现次数
    for x in input_string.split_whitespace() {
        let count = map.entry(x.to_string()).or_insert(0);
        *count += 1;
    }
    let mut vec:Vec<_> = map.iter().collect();
    vec.sort_by(|entry1,entry2| entry1.1.cmp(entry2.1).reverse());
    for (key, value) in vec {
        println!("{}={}", key, value)
    }
}

4、斐波那契数列

描述：编写一个函数，生成指定长度的斐波那契数列。斐波那契数列的定义是：前两个数为 0 和 1，之后的每个数是前两个数之和。

提示：

• 使用递归或迭代 实现。
• 处理边界条件（如长度为 0 或 1 的情况）。

fn main() {
}

pub fn fibonacci(num: i32) -> i32 {
    if num == 0 || num == 1 { return num; }
    let mut dp = vec![0; (num + 1) as usize];
    dp[0] = 0;
    dp[1] = 1;
    for i in 2..=num as usize {
        dp[i] = dp[i - 1] + dp[i - 2];
    }
    dp[num as usize]
}

#[cfg(test)]
mod test {
    use super::*;
    #[test]
    fn validate() {
        assert_eq!(fibonacci(2), 1);
    }
}

5、最长单词

描述：编写一个函数，接受一个字符串的引用，并返回这个字符串中最长的单词。

fn main() {
}
/**
 * 解析最长单词
 */
pub fn long_word(s: &str) -> i32 {
    s.trim().split_whitespace()
        .max_by_key(|item| item.len())
        .map(|word| word.len() as i32)
        .unwrap_or(0)
}

#[cfg(test)]
mod test {
    use super::*;
    #[test]
    fn validate() {
        assert_eq!(long_word("if you see as i see  /n if you world seek as i seek"), 5);
    }
}

6、矩形面积

描述：定义一个结构体 Rectangle，包含两个字段 width 和 height。为这个结构体实现一个方法 area，计算矩形的面积。

struct Rectangle {
    /*
    * 宽
    */
    width: i32,
    /*
    * 高
    */
    height: i32,
}

impl Rectangle {
    pub fn area(&self) -> i32 {
        self.width * self.height
    }
}

#[cfg(test)]
mod test {
    use super::*;
    #[test]
    fn validate() {
        let rec = Rectangle {
            width: 3,
            height: 4,
        };
        assert_eq!(rec.area(), 12)
    }
}

7、多边形面积（方法和函数）

描述：定义一个枚举 Shape，包含 Circle、Square 和 Rectangle 三种形状。为每种形状实现一个方法 area，计算它们的面积。

use std::f64::consts::PI;

enum  Shape {
    Circle(f64),
    Square(f64),
    Rectangle(f64, f64),
}

impl Shape {
    pub fn call(&self) -> f64 {
       match self {
           Shape::Circle(radius) => PI * radius * radius,
           Shape::Square(side) => side * side,
           Shape::Rectangle(w, h) => w * h,
       }
    }
}

#[cfg(test)]
mod test {
    use super::*;
    #[test]
    fn validate() {
        let rec = Shape::Rectangle(3.0,4.0);
        assert_eq!(rec.call(), 12.0);

        let squ = Shape::Square(4.0);
        assert_eq!(squ.call(), 16.0);

        let cir = Shape::Circle(3.0);
        assert_eq!(cir.call(), PI*3.0*3.0);
    }
}

8、命令行参数解析

描述：编写一个程序，接受命令行参数并输出这些参数。例如，运行 cargo run arg1 arg2 arg3 应该输出 arg1 arg2 arg3。

use std::env;

fn main() {
    let args: Vec<String> = env::args().collect();
    println!("print command line args: {}, {}, {}", args[1], args[2], args[3])
}

命令行运行

cd /home/mztt/space/rust/hello-rust/src && cargo run agr0 arg1 agr2

9、文件操作

描述：编写一个程序，读取一个文本文件的内容，并将其写入到另一个文件中。

10、多线程

描述：编写一个程序，启动多个线程，每个线程打印一个独特的消息。