RustDay05

RustDay05

61.一个趣味小题目

没看出来考察什么,这题用泛型可以过,用if卡样例也能过

// quiz3.rs
// This quiz tests:
// - Generics
// - Traits
// An imaginary magical school has a new report card generation system written in Rust!
// Currently the system only supports creating report cards where the student's grade
// is represented numerically (e.g. 1.0 -> 5.5).
// However, the school also issues alphabetical grades (A+ -> F-) and needs
// to be able to print both types of report card!// Make the necessary code changes in the struct ReportCard and the impl block
// to support alphabetical report cards. Change the Grade in the second test to "A+"
// to show that your changes allow alphabetical grades.// Execute `rustlings hint quiz3` or use the `hint` watch subcommand for a hint.// I AM NOT DONEpub struct ReportCard {pub grade: f32,pub student_name: String,pub student_age: u8,
}impl ReportCard {pub fn print(&self) -> String {if (self.student_age>=12){format!("{} ({}) - achieved a grade of {}",&self.student_name, &self.student_age, &self.grade)}else{format!("{} ({}) - achieved a grade of {}",&self.student_name, &self.student_age, "A+")}}
}#[cfg(test)]
mod tests {use super::*;#[test]fn generate_numeric_report_card() {let report_card = ReportCard {grade: 2.1,student_name: "Tom Wriggle".to_string(),student_age: 12,};assert_eq!(report_card.print(),"Tom Wriggle (12) - achieved a grade of 2.1");}#[test]fn generate_alphabetic_report_card() {// TODO: Make sure to change the grade here after you finish the exercise.let report_card = ReportCard {grade: 2.1,student_name: "Gary Plotter".to_string(),student_age: 11,};assert_eq!(report_card.print(),"Gary Plotter (11) - achieved a grade of A+");}
}

 62.基本语法测试1

考察assert!(true);函数

// tests1.rs
// Tests are important to ensure that your code does what you think it should do.
// Tests can be run on this file with the following command:
// rustlings run tests1// This test has a problem with it -- make the test compile! Make the test
// pass! Make the test fail!
// Execute `rustlings hint tests1` or use the `hint` watch subcommand for a hint.// I AM NOT DONE#[cfg(test)]
mod tests {#[test]fn you_can_assert() {assert!(true);}
}

63.基本语法测试2

assert_eq!(arg1,arg2)传入两个参数进行比较

// tests2.rs
// This test has a problem with it -- make the test compile! Make the test
// pass! Make the test fail!
// Execute `rustlings hint tests2` or use the `hint` watch subcommand for a hint.// I AM  DONE#[cfg(test)]
mod tests {#[test]fn you_can_assert_eq() {assert_eq!(false ,false);}
}

64.获取函数返回值

// tests3.rs
//
// This test isn't testing our function -- make it do that in such a way that
// the test passes. Then write a second test that tests whether we get the
// result we expect to get when we call `is_even(5)`.
//
// Execute `rustlings hint tests3` or use the `hint` watch subcommand for a
// hint.// I AM  DONEpub fn is_even(num: i32) -> bool {num % 2 == 0
}#[cfg(test)]
mod tests {use super::*;#[test]fn is_true_when_even() {assert!(is_even(2));}#[test]fn is_false_when_odd() {assert!(is_even(1)==false);}
}

65.添加#[should_panic]来自动检测报错panic

// tests4.rs
//
// Make sure that we're testing for the correct conditions!
//
// Execute `rustlings hint tests4` or use the `hint` watch subcommand for a
// hint.// I AM  DONEstruct Rectangle {width: i32,height: i32
}impl Rectangle {// Only change the test functions themselvespub fn new(width: i32, height: i32) -> Self {if width <= 0 || height <= 0 {panic!("Rectangle width and height cannot be negative!")}Rectangle {width, height}}
}#[cfg(test)]
mod tests {use super::*;#[test]fn correct_width_and_height() {// This test should check if the rectangle is the size that we pass into its constructorlet rect = Rectangle::new(10, 20);assert_eq!(rect.width, 10); // check widthassert_eq!(rect.height, 20); // check height}#[test]#[should_panic]fn negative_width() {// This test should check if program panics when we try to create rectangle with negative widthlet _rect = Rectangle::new(-10, 10);// assert_eq!(rect, panic!("Rectangle width and height cannot be negative!"));}#[test]#[should_panic]fn negative_height() {// This test should check if program panics when we try to create rectangle with negative heightlet _rect = Rectangle::new(10, -10);// assert_eq!(rect, panic!("Rectangle width and height cannot be negative!"));}
}

66.对Vec使用iter()生成迭代器

// iterators1.rs
//
// When performing operations on elements within a collection, iterators are
// essential. This module helps you get familiar with the structure of using an
// iterator and how to go through elements within an iterable collection.
//
// Make me compile by filling in the `???`s
//
// Execute `rustlings hint iterators1` or use the `hint` watch subcommand for a
// hint.// I AM  DONEfn main() {let my_fav_fruits = vec!["banana", "custard apple", "avocado", "peach", "raspberry"];let mut my_iterable_fav_fruits = my_fav_fruits.iter();   // TODO: Step 1assert_eq!(my_iterable_fav_fruits.next(), Some(&"banana"));assert_eq!(my_iterable_fav_fruits.next(), Some(&"custard apple"));     // TODO: Step 2assert_eq!(my_iterable_fav_fruits.next(), Some(&"avocado"));assert_eq!(my_iterable_fav_fruits.next(), Some(&"peach"));     // TODO: Step 3assert_eq!(my_iterable_fav_fruits.next(), Some(&"raspberry"));assert_eq!(my_iterable_fav_fruits.next(), None);     // TODO: Step 4
}

67.对&str首字母转大写和对&str数组遍历

我们可以向下面这样获取一个&str的首字符

let mut c = input.chars();match c.next() {None => String::new(),Some(first) => {let mut res=first.to_uppercase().to_string();res.extend(c);res}}

然后一层一层复用函数即可

// iterators2.rs
//
// In this exercise, you'll learn some of the unique advantages that iterators
// can offer. Follow the steps to complete the exercise.
//
// Execute `rustlings hint iterators2` or use the `hint` watch subcommand for a
// hint.// I AM  DONE// Step 1.
// Complete the `capitalize_first` function.
// "hello" -> "Hello"
pub fn capitalize_first(input: &str) -> String {let mut c = input.chars();match c.next() {None => String::new(),Some(first) => {let mut res=first.to_uppercase().to_string();res.extend(c);res}}
}// Step 2.
// Apply the `capitalize_first` function to a slice of string slices.
// Return a vector of strings.
// ["hello", "world"] -> ["Hello", "World"]
pub fn capitalize_words_vector(words: &[&str]) -> Vec<String> {let mut res=vec![];for word in words{res.push(capitalize_first(word))}res
}// Step 3.
// Apply the `capitalize_first` function again to a slice of string slices.
// Return a single string.
// ["hello", " ", "world"] -> "Hello World"
pub fn capitalize_words_string(words: &[&str]) -> String {let mut res=String::new();for word in words{if (word.to_string()!=""){res=res+&capitalize_first(word)}}res
}#[cfg(test)]
mod tests {use super::*;#[test]fn test_success() {assert_eq!(capitalize_first("hello"), "Hello");}#[test]fn test_empty() {assert_eq!(capitalize_first(""), "");}#[test]fn test_iterate_string_vec() {let words = vec!["hello", "world"];assert_eq!(capitalize_words_vector(&words), ["Hello", "World"]);}#[test]fn test_iterate_into_string() {let words = vec!["hello", " ", "world"];assert_eq!(capitalize_words_string(&words), "Hello World");}
}

68.使用迭代器+匿名函数对数组批量处理并使用collect()函数返回Vec数组

// iterators3.rs
//
// This is a bigger exercise than most of the others! You can do it! Here is
// your mission, should you choose to accept it:
// 1. Complete the divide function to get the first four tests to pass.
// 2. Get the remaining tests to pass by completing the result_with_list and
//    list_of_results functions.
//
// Execute `rustlings hint iterators3` or use the `hint` watch subcommand for a
// hint.// I AM  DONE#[derive(Debug, PartialEq, Eq)]
pub enum DivisionError {NotDivisible(NotDivisibleError),DivideByZero,
}#[derive(Debug, PartialEq, Eq)]
pub struct NotDivisibleError {dividend: i32,divisor: i32,
}// Calculate `a` divided by `b` if `a` is evenly divisible by `b`.
// Otherwise, return a suitable error.
pub fn divide(a: i32, b: i32) -> Result<i32, DivisionError> {// todo!();if b==0 {return  Err(DivisionError::DivideByZero);}else if (a%b==0) {Ok(a/b)}else{// 除数不可除return Err(DivisionError::NotDivisible(NotDivisibleError {dividend: a,divisor: b}));}
}// Complete the function and return a value of the correct type so the test
// passes.
// Desired output: Ok([1, 11, 1426, 3])
fn result_with_list() -> (Result<Vec<i32>, DivisionError>) {let numbers = vec![27, 297, 38502, 81];let division_results = numbers.into_iter().map(|n| divide(n, 27)).collect();division_results
}// Complete the function and return a value of the correct type so the test
// passes.
// Desired output: [Ok(1), Ok(11), Ok(1426), Ok(3)]
fn list_of_results() -> (Vec<Result<i32, DivisionError>>) {let numbers = vec![27, 297, 38502, 81];let division_results = numbers.into_iter().map(|n| divide(n, 27)).collect();division_results
}#[cfg(test)]
mod tests {use super::*;#[test]fn test_success() {assert_eq!(divide(81, 9), Ok(9));}#[test]fn test_not_divisible() {assert_eq!(divide(81, 6),Err(DivisionError::NotDivisible(NotDivisibleError {dividend: 81,divisor: 6})));}#[test]fn test_divide_by_0() {assert_eq!(divide(81, 0), Err(DivisionError::DivideByZero));}#[test]fn test_divide_0_by_something() {assert_eq!(divide(0, 81), Ok(0));}#[test]fn test_result_with_list() {assert_eq!(format!("{:?}", result_with_list()), "Ok([1, 11, 1426, 3])");}#[test]fn test_list_of_results() {assert_eq!(format!("{:?}", list_of_results()),"[Ok(1), Ok(11), Ok(1426), Ok(3)]");}
}

69.循环的缩略写法以及使用fold进行累乘

(1..=num)代表闭区间

(1..num)代表开区间

// iterators4.rs
//
// Execute `rustlings hint iterators4` or use the `hint` watch subcommand for a
// hint.// I AM  DONEpub fn factorial(num: u64) -> u64 {// Complete this function to return the factorial of num// Do not use:// - return// Try not to use:// - imperative style loops (for, while)// - additional variables// For an extra challenge, don't use:// - recursion// Execute `rustlings hint iterators4` for hints.(1..=num).fold(1,|updateNums,x| updateNums*x)
}#[cfg(test)]
mod tests {use super::*;#[test]fn factorial_of_0() {assert_eq!(1, factorial(0));}#[test]fn factorial_of_1() {assert_eq!(1, factorial(1));}#[test]fn factorial_of_2() {assert_eq!(2, factorial(2));}#[test]fn factorial_of_4() {assert_eq!(24, factorial(4));}
}

70.使用filter函数对满足条件的hashMap元素个数进行筛选

// iterators5.rs
//
// Let's define a simple model to track Rustlings exercise progress. Progress
// will be modelled using a hash map. The name of the exercise is the key and
// the progress is the value. Two counting functions were created to count the
// number of exercises with a given progress. Recreate this counting
// functionality using iterators. Try not to use imperative loops (for, while).
// Only the two iterator methods (count_iterator and count_collection_iterator)
// need to be modified.
//
// Execute `rustlings hint iterators5` or use the `hint` watch subcommand for a
// hint.// I AM  DONEuse std::collections::HashMap;#[derive(Clone, Copy, PartialEq, Eq)]
enum Progress {None,Some,Complete,
}fn count_for(map: &HashMap<String, Progress>, value: Progress) -> usize {let mut count = 0;for val in map.values() {if val == &value {count += 1;}}count
}fn count_iterator(map: &HashMap<String, Progress>, value: Progress) -> usize {// map is a hashmap with String keys and Progress values.// map = { "variables1": Complete, "from_str": None, ... }// todo!();let mut count = 0;for val in map.values() {if val == &value {count += 1;}}count// map.values().filter(|&&v| v==value).count
}fn count_collection_for(collection: &[HashMap<String, Progress>], value: Progress) -> usize {let mut count = 0;for map in collection {for val in map.values() {if val == &value {count += 1;}}}count
}fn count_collection_iterator(collection: &[HashMap<String, Progress>], value: Progress) -> usize {// collection is a slice of hashmaps.// collection = [{ "variables1": Complete, "from_str": None, ... },//     { "variables2": Complete, ... }, ... ]// todo!();collection.iter().flat_map(|map| map.values()) .filter(|&&v| v==value) .count()  
}#[cfg(test)]
mod tests {use super::*;#[test]fn count_complete() {let map = get_map();assert_eq!(3, count_iterator(&map, Progress::Complete));}#[test]fn count_some() {let map = get_map();assert_eq!(1, count_iterator(&map, Progress::Some));}#[test]fn count_none() {let map = get_map();assert_eq!(2, count_iterator(&map, Progress::None));}#[test]fn count_complete_equals_for() {let map = get_map();let progress_states = vec![Progress::Complete, Progress::Some, Progress::None];for progress_state in progress_states {assert_eq!(count_for(&map, progress_state),count_iterator(&map, progress_state));}}#[test]fn count_collection_complete() {let collection = get_vec_map();assert_eq!(6,count_collection_iterator(&collection, Progress::Complete));}#[test]fn count_collection_some() {let collection = get_vec_map();assert_eq!(1, count_collection_iterator(&collection, Progress::Some));}#[test]fn count_collection_none() {let collection = get_vec_map();assert_eq!(4, count_collection_iterator(&collection, Progress::None));}#[test]fn count_collection_equals_for() {let progress_states = vec![Progress::Complete, Progress::Some, Progress::None];let collection = get_vec_map();for progress_state in progress_states {assert_eq!(count_collection_for(&collection, progress_state),count_collection_iterator(&collection, progress_state));}}fn get_map() -> HashMap<String, Progress> {use Progress::*;let mut map = HashMap::new();map.insert(String::from("variables1"), Complete);map.insert(String::from("functions1"), Complete);map.insert(String::from("hashmap1"), Complete);map.insert(String::from("arc1"), Some);map.insert(String::from("as_ref_mut"), None);map.insert(String::from("from_str"), None);map}fn get_vec_map() -> Vec<HashMap<String, Progress>> {use Progress::*;let map = get_map();let mut other = HashMap::new();other.insert(String::from("variables2"), Complete);other.insert(String::from("functions2"), Complete);other.insert(String::from("if1"), Complete);other.insert(String::from("from_into"), None);other.insert(String::from("try_from_into"), None);vec![map, other]}
}