二.进阶项目

• names.txt

小明
小李
小丽
小张
老赵
王五
小虾
虾仁
啊啊
阿斯顿
水淀粉
撒地方
阿是的饭
阿斯顿发的
阿是的饭饭
撒的恶
阿的

use std::{
    cmp::Ordering,
    io::{self, Write},
};

use rand::Rng;

fn main() {
    #[derive(Debug, Clone)]
    struct ExamRecord {
        id: u64,
        name: String,
        scores: Vec<Option<f32>>,
        total_score: Option<f32>,
        avg_score: Option<f32>,
    }
    const NAMES_CONTENT: &'static str = include_str!("../assets/names.txt");

    impl ExamRecord {
        fn gen_records() -> Vec<ExamRecord> {
            let mut id = 0u64;
            NAMES_CONTENT
                .split("\n")
                .filter(|s| !s.is_empty())
                .take(100)
                .map(|s| {
                    let mut rng = rand::thread_rng();
                    let n = rng.gen_range(1..100);

                    let chinese_score = if (id + 1) % 10 == 0 && n % 7 == 0 {
                        None
                    } else {
                        let score: f32 = rng.gen();
                        let score = 40.0 + score * 60.0;
                        Some(score)
                    };

                    let math_score = if (id + 1) % 10 == 0 && n % 7 == 0 {
                        None
                    } else {
                        let score: f32 = rng.gen();
                        let score = 40.0 + score * 60.0;
                        Some(score)
                    };

                    let english_score = if (id + 1) % 10 == 0 && n % 7 == 0 {
                        None
                    } else {
                        let score: f32 = rng.gen();
                        let score = 40.0 + score * 60.0;
                        Some(score)
                    };
                    let scores = vec![chinese_score, math_score, english_score];
                    let attend_exams: Vec<&Option<f32>> =
                        scores.iter().filter(|s| s.is_some()).collect();

                    let (total_score, avg_score) = if attend_exams.is_empty() {
                        (None, None)
                    } else {
                        let total: f32 = attend_exams.iter().map(|s| s.unwrap()).sum();
                        (Some(total), Some(total / (attend_exams.len() as f32)))
                    };

                    id += 1;

                    ExamRecord {
                        id,
                        name: s.to_owned(),
                        scores,
                        total_score,
                        avg_score,
                    }
                })
                .collect::<Vec<ExamRecord>>()
        }
    }

    impl std::fmt::Display for ExamRecord {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
            write!(
                f,
                "2024-{:03} {} {:>6} {:>6} {:>6} {:>7} {:>6}",
                self.id,
                &self.name,
                match &self.scores[0] {
                    Some(score) => format!("{:.2}", score),
                    None => "-".to_string(),
                },
                match &self.scores[1] {
                    Some(score) => format!("{:.2}", score),
                    None => "-".to_string(),
                },
                match &self.scores[2] {
                    Some(score) => format!("{:.2}", score),
                    None => "-".to_string(),
                },
                match &self.total_score {
                    Some(score) => format!("{:.2}", score),
                    None => "-".to_string(),
                },
                match &self.avg_score {
                    Some(score) => format!("{:.2}", score),
                    None => "-".to_string(),
                },
            )
        }
    }
    let mut records = ExamRecord::gen_records();
    fn print_main_menu() {
        println!("\n----- 成绩查询系统 ----");
        println!("   1. 打印成绩单");
        println!("   2. 排序成绩单");
        println!("   3. 查找成绩单");
        println!("   4. 全班平均成绩");
        println!("   5. 退出");
    }
    fn print_table_header() {
        println!(" # 学号 姓名 语⽂ 数学 英语 总分 平均分");
        println!("--------------------------------------------------------------");
    }
    fn print_records(records: &Vec<ExamRecord>) {
        print_table_header();
        let mut index = 0;
        records.iter().for_each(|r| {
            index += 1;
            println!("{:>3} {}", index, r);
        });
    }
    fn sort_by_total_score(records: &mut Vec<ExamRecord>) {
        records.sort_by(|a, b| match (a.total_score, b.total_score) {
            (Some(sa), Some(sb)) => sb.total_cmp(&sa),
            (Some(_), None) => Ordering::Less,
            (None, Some(_)) => Ordering::Greater,
            (None, None) => Ordering::Equal,
        });
        print_records(&records)
    }
    fn search_score(records: &mut Vec<ExamRecord>) {
        print!("\n请输入名字 :");
        io::stdout().flush().unwrap();

        let mut choice = String::new();
        io::stdin().read_line(&mut choice).unwrap();
        for val in records {
            if val.name == choice.trim() {
                let target = vec![val.clone()];
                print_records(&target)
            }
        }
    }
    fn sum_avg_score(records: &mut Vec<ExamRecord>) {
        let mut sum =0f32 ;
        for val in records.iter() {
            sum += val.avg_score.unwrap_or(0.0)
        }
        let len = records.len();
        let avg = sum / len as f32;
        println!("全班平均成绩 ：{}",avg)
    }
    loop {
        print_main_menu();

        print!("\n请选择 [1 - 5]:");
        io::stdout().flush().unwrap();

        let mut choice = String::new();
        io::stdin().read_line(&mut choice).unwrap();

        match choice.trim() {
            "1" => print_records(&records),
            "2" => sort_by_total_score(&mut records),
            "3" => search_score(&mut records),
            "4" => sum_avg_score(&mut records),
            "5" => break,
            _ => println!("Unkown option"),
        }
    }
}