level 18th

.rustlings-state.txt

@@ -1,6 +1,6 @@
 DON'T EDIT THIS FILE!
 
-generics1
+box1
 
 intro1
 intro2
@@ -58,3 +58,22 @@ errors3
 errors4
 errors5
 errors6
+generics1
+generics2
+traits1
+traits2
+traits3
+traits4
+traits5
+quiz3
+lifetimes1
+lifetimes2
+lifetimes3
+tests1
+tests2
+tests3
+iterators1
+iterators2
+iterators3
+iterators4
+iterators5

exercises/15_traits/traits1.rs

@@ -6,6 +6,9 @@ trait AppendBar {
 
 impl AppendBar for String {
     // TODO: Implement `AppendBar` for the type `String`.
+    fn append_bar(self) -> Self {
+        self+"Bar"
+    }
 }
 
 fn main() {

exercises/15_traits/traits2.rs

@@ -4,6 +4,12 @@ trait AppendBar {
 
 // TODO: Implement the trait `AppendBar` for a vector of strings.
 // `append_bar` should push the string "Bar" into the vector.
+impl AppendBar for Vec<String>{
+    fn append_bar(mut self) -> Self {
+        self.push("Bar".to_string());
+        self
+    }
+}
 
 fn main() {
     // You can optionally experiment here.

exercises/15_traits/traits3.rs

@@ -3,7 +3,9 @@ trait Licensed {
     // implementors like the two structs below can share that default behavior
     // without repeating the function.
     // The default license information should be the string "Default license".
-    fn licensing_info(&self) -> String;
+    fn licensing_info(&self) -> String{
+        "Default license".to_string()
+    }
 }
 
 struct SomeSoftware {

exercises/15_traits/traits4.rs

@@ -11,7 +11,7 @@ impl Licensed for SomeSoftware {}
 impl Licensed for OtherSoftware {}
 
 // TODO: Fix the compiler error by only changing the signature of this function.
-fn compare_license_types(software1: ???, software2: ???) -> bool {
+fn compare_license_types<T: Licensed, U: Licensed>(software1: T, software2: U) -> bool {
     software1.licensing_info() == software2.licensing_info()
 }
 

exercises/15_traits/traits5.rs

@@ -19,7 +19,7 @@ impl SomeTrait for OtherStruct {}
 impl OtherTrait for OtherStruct {}
 
 // TODO: Fix the compiler error by only changing the signature of this function.
-fn some_func(item: ???) -> bool {
+fn some_func<T: SomeTrait + OtherTrait>(item: T) -> bool {
     item.some_function() && item.other_function()
 }
 

exercises/16_lifetimes/lifetimes1.rs

@@ -4,11 +4,11 @@
 // not own their own data. What if their owner goes out of scope?
 
 // TODO: Fix the compiler error by updating the function signature.
-fn longest(x: &str, y: &str) -> &str {
+fn longest(x: &str, y: &str) -> String {
     if x.len() > y.len() {
-        x
+        x.to_string()
     } else {
-        y
+        y.to_string()
     }
 }
 

exercises/16_lifetimes/lifetimes2.rs

@@ -11,9 +11,10 @@ fn main() {
     // TODO: Fix the compiler error by moving one line.
 
     let string1 = String::from("long string is long");
+    let string2 = String::from("xyz");
+
     let result;
     {
-        let string2 = String::from("xyz");
         result = longest(&string1, &string2);
     }
     println!("The longest string is '{result}'");

exercises/16_lifetimes/lifetimes3.rs

@@ -1,9 +1,9 @@
 // Lifetimes are also needed when structs hold references.
 
 // TODO: Fix the compiler errors about the struct.
-struct Book {
+struct Book<'a> {
-    author: &str,
+    author: &'a str,  
-    title: &str,
+    title: &'a str,  
 }
 
 fn main() {

exercises/17_tests/tests1.rs

@@ -13,11 +13,11 @@ fn main() {
 mod tests {
     // TODO: Import `is_even`. You can use a wildcard to import everything in
     // the outer module.
-
+    use super::*;
     #[test]
     fn you_can_assert() {
         // TODO: Test the function `is_even` with some values.
-        assert!();
+        assert!(is_even(2));
-        assert!();
+        assert!(!is_even(3));
     }   
 }

exercises/17_tests/tests2.rs

@@ -15,9 +15,9 @@ mod tests {
     #[test]
     fn you_can_assert_eq() {
         // TODO: Test the function `power_of_2` with some values.
-        assert_eq!();
+        assert_eq!(power_of_2(2),4);
-        assert_eq!();
+        assert_eq!(power_of_2(3),8);
-        assert_eq!();
+        assert_eq!(power_of_2(4),16);
-        assert_eq!();
+        assert_eq!(power_of_2(5),32);
     }
 }

exercises/17_tests/tests3.rs

@@ -29,13 +29,14 @@ mod tests {
         // TODO: This test should check if the rectangle has the size that we
         // pass to its constructor.
         let rect = Rectangle::new(10, 20);
-        assert_eq!(todo!(), 10); // Check width
+        assert_eq!(rect.width, 10); // Check width
-        assert_eq!(todo!(), 20); // Check height
+        assert_eq!(rect.height, 20); // Check height
     }
 
     // TODO: This test should check if the program panics when we try to create
     // a rectangle with negative width.
     #[test]
+    #[should_panic]
     fn negative_width() {
         let _rect = Rectangle::new(-10, 10);
     }
@@ -43,6 +44,7 @@ mod tests {
     // TODO: This test should check if the program panics when we try to create
     // a rectangle with negative height.
     #[test]    
+    #[should_panic]
     fn negative_height() {
         let _rect = Rectangle::new(10, -10);
     }

exercises/18_iterators/iterators1.rs

@@ -13,13 +13,13 @@ mod tests {
         let my_fav_fruits = ["banana", "custard apple", "avocado", "peach", "raspberry"];
 
         // TODO: Create an iterator over the array.
-        let mut fav_fruits_iterator = todo!();
+        let mut fav_fruits_iterator =my_fav_fruits.iter();
 
         assert_eq!(fav_fruits_iterator.next(), Some(&"banana"));
-        assert_eq!(fav_fruits_iterator.next(), todo!()); // TODO: Replace `todo!()`
+        assert_eq!(fav_fruits_iterator.next(), Some(&"custard apple")); // TODO: Replace `todo!()`
         assert_eq!(fav_fruits_iterator.next(), Some(&"avocado"));
-        assert_eq!(fav_fruits_iterator.next(), todo!()); // TODO: Replace `todo!()`
+        assert_eq!(fav_fruits_iterator.next(), Some(&"peach")); // TODO: Replace `todo!()`
         assert_eq!(fav_fruits_iterator.next(), Some(&"raspberry"));
-        assert_eq!(fav_fruits_iterator.next(), todo!()); // TODO: Replace `todo!()`
+        assert_eq!(fav_fruits_iterator.next(), None); // TODO: Replace `todo!()`
     }
 }

exercises/18_iterators/iterators2.rs

@@ -5,24 +5,26 @@
 // "hello" -> "Hello"
 fn capitalize_first(input: &str) -> String {
     let mut chars = input.chars();
-    match chars.next() {
+    let char =match chars.next() {
         None => String::new(),
-        Some(first) => todo!(),
+        Some(first) => first.to_uppercase().collect(),
-    }
+    };
+
+    char+chars.as_str()
 }
 
 // TODO: Apply the `capitalize_first` function to a slice of string slices.
 // Return a vector of strings.
 // ["hello", "world"] -> ["Hello", "World"]
 fn capitalize_words_vector(words: &[&str]) -> Vec<String> {
-    // ???
+    words.iter().map(|word| capitalize_first(word)).collect()
 }
 
 // TODO: Apply the `capitalize_first` function again to a slice of string
 // slices. Return a single string.
 // ["hello", " ", "world"] -> "Hello World"
 fn capitalize_words_string(words: &[&str]) -> String {
-    // ???
+    words.iter().map(|word| capitalize_first(word)).collect()
 }
 
 fn main() {

exercises/18_iterators/iterators3.rs

@@ -1,3 +1,4 @@
+
 #[derive(Debug, PartialEq, Eq)]
 enum DivisionError {
     // Example: 42 / 0
@@ -11,21 +12,30 @@ enum DivisionError {
 // TODO: Calculate `a` divided by `b` if `a` is evenly divisible by `b`.
 // Otherwise, return a suitable error.
 fn divide(a: i64, b: i64) -> Result<i64, DivisionError> {
-    todo!();
+    if b==0 { return Err(DivisionError::DivideByZero) } ;
+    if a == i64::MIN && b == -1 {
+        Err(DivisionError::IntegerOverflow)
+    } else if a % b != 0 {
+        Err(DivisionError::NotDivisible)
+    } else {
+        Ok(a / b)
+    }
 }
 
 // TODO: Add the correct return type and complete the function body.
 // Desired output: `Ok([1, 11, 1426, 3])`
-fn result_with_list() {
+fn result_with_list() -> Result<Vec<i64>,DivisionError>{
     let numbers = [27, 297, 38502, 81];
-    let division_results = numbers.into_iter().map(|n| divide(n, 27));
+    numbers.into_iter().map(|n| divide(n, 27)).collect()
+
 }
 
 // TODO: Add the correct return type and complete the function body.
 // Desired output: `[Ok(1), Ok(11), Ok(1426), Ok(3)]`
-fn list_of_results() {
+fn list_of_results()->Vec<Result<i64,DivisionError>> {
     let numbers = [27, 297, 38502, 81];
     let division_results = numbers.into_iter().map(|n| divide(n, 27));
+    division_results.collect()
 }
 
 fn main() {

exercises/18_iterators/iterators4.rs

@@ -10,6 +10,7 @@ fn factorial(num: u64) -> u64 {
     // - additional variables
     // For an extra challenge, don't use:
     // - recursion
+    (1..=num).product()
 }
 
 fn main() {

exercises/18_iterators/iterators5.rs

@@ -28,6 +28,7 @@ fn count_for(map: &HashMap<String, Progress>, value: Progress) -> usize {
 fn count_iterator(map: &HashMap<String, Progress>, value: Progress) -> usize {
     // `map` is a hash map with `String` keys and `Progress` values.
     // map = { "variables1": Complete, "from_str": None, … }
+    map.values().filter(|&v| *v == value).count()
 }
 
 fn count_collection_for(collection: &[HashMap<String, Progress>], value: Progress) -> usize {
@@ -48,6 +49,11 @@ fn count_collection_iterator(collection: &[HashMap<String, Progress>], value: Pr
     // `collection` is a slice of hash maps.
     // collection = [{ "variables1": Complete, "from_str": None, … },
     //               { "variables2": Complete, … }, … ]
+    collection
+        .iter()
+        .flat_map(|map| map.values())
+        .filter(|&v| *v == value)
+        .count()
 }
 
 fn main() {

exercises/quizzes/quiz3.rs

@@ -12,14 +12,14 @@
 // block to support alphabetical report cards in addition to numerical ones.
 
 // TODO: Adjust the struct as described above.
-struct ReportCard {
+struct ReportCard<T> {
-    grade: f32,
+    grade: T,
     student_name: String,
     student_age: u8,
 }
 
 // TODO: Adjust the impl block as described above.
-impl ReportCard {
+impl<T: std::fmt::Display> ReportCard<T> {
     fn print(&self) -> String {
         format!(
             "{} ({}) - achieved a grade of {}",

solutions/14_generics/generics2.rs

@@ -1,4 +1,28 @@
-fn main() {
+struct Wrapper<T> {
-    // DON'T EDIT THIS SOLUTION FILE!
+    value: T,
-    // It will be automatically filled after you finish the exercise.
+}
+
+impl<T> Wrapper<T> {
+    fn new(value: T) -> Self {
+        Wrapper { value }
+    }
+}
+
+fn main() {
+    // You can optionally experiment here.
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn store_u32_in_wrapper() {
+        assert_eq!(Wrapper::new(42).value, 42);
+    }
+
+    #[test]
+    fn store_str_in_wrapper() {
+        assert_eq!(Wrapper::new("Foo").value, "Foo");
+    }
 }

solutions/15_traits/traits1.rs

@@ -1,4 +1,32 @@
-fn main() {
+// The trait `AppendBar` has only one function which appends "Bar" to any object
-    // DON'T EDIT THIS SOLUTION FILE!
+// implementing this trait.
-    // It will be automatically filled after you finish the exercise.
+trait AppendBar {
+    fn append_bar(self) -> Self;
+}
+
+impl AppendBar for String {
+    fn append_bar(self) -> Self {
+        self + "Bar"
+    }
+}
+
+fn main() {
+    let s = String::from("Foo");
+    let s = s.append_bar();
+    println!("s: {s}");
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn is_foo_bar() {
+        assert_eq!(String::from("Foo").append_bar(), "FooBar");
+    }
+
+    #[test]
+    fn is_bar_bar() {
+        assert_eq!(String::from("").append_bar().append_bar(), "BarBar");
+    }
 }

solutions/15_traits/traits2.rs

@@ -1,4 +1,27 @@
-fn main() {
+trait AppendBar {
-    // DON'T EDIT THIS SOLUTION FILE!
+    fn append_bar(self) -> Self;
-    // It will be automatically filled after you finish the exercise.
+}
+
+impl AppendBar for Vec<String> {
+    fn append_bar(mut self) -> Self {
+        //        ^^^ this is important
+        self.push(String::from("Bar"));
+        self
+    }
+}
+
+fn main() {
+    // You can optionally experiment here.
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn is_vec_pop_eq_bar() {
+        let mut foo = vec![String::from("Foo")].append_bar();
+        assert_eq!(foo.pop().unwrap(), "Bar");
+        assert_eq!(foo.pop().unwrap(), "Foo");
+    }
 }

solutions/15_traits/traits3.rs

@@ -1,4 +1,36 @@
-fn main() {
+trait Licensed {
-    // DON'T EDIT THIS SOLUTION FILE!
+    fn licensing_info(&self) -> String {
-    // It will be automatically filled after you finish the exercise.
+        "Default license".to_string()
+    }
+}
+
+struct SomeSoftware {
+    version_number: i32,
+}
+
+struct OtherSoftware {
+    version_number: String,
+}
+
+impl Licensed for SomeSoftware {}
+impl Licensed for OtherSoftware {}
+
+fn main() {
+    // You can optionally experiment here.
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn is_licensing_info_the_same() {
+        let licensing_info = "Default license";
+        let some_software = SomeSoftware { version_number: 1 };
+        let other_software = OtherSoftware {
+            version_number: "v2.0.0".to_string(),
+        };
+        assert_eq!(some_software.licensing_info(), licensing_info);
+        assert_eq!(other_software.licensing_info(), licensing_info);
+    }
 }

solutions/15_traits/traits4.rs

@@ -1,4 +1,35 @@
-fn main() {
+trait Licensed {
-    // DON'T EDIT THIS SOLUTION FILE!
+    fn licensing_info(&self) -> String {
-    // It will be automatically filled after you finish the exercise.
+        "Default license".to_string()
+    }
+}
+
+struct SomeSoftware;
+struct OtherSoftware;
+
+impl Licensed for SomeSoftware {}
+impl Licensed for OtherSoftware {}
+
+fn compare_license_types(software1: impl Licensed, software2: impl Licensed) -> bool {
+    //                              ^^^^^^^^^^^^^             ^^^^^^^^^^^^^
+    software1.licensing_info() == software2.licensing_info()
+}
+
+fn main() {
+    // You can optionally experiment here.
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn compare_license_information() {
+        assert!(compare_license_types(SomeSoftware, OtherSoftware));
+    }
+
+    #[test]
+    fn compare_license_information_backwards() {
+        assert!(compare_license_types(OtherSoftware, SomeSoftware));
+    }
 }

solutions/15_traits/traits5.rs

@@ -1,4 +1,39 @@
-fn main() {
+trait SomeTrait {
-    // DON'T EDIT THIS SOLUTION FILE!
+    fn some_function(&self) -> bool {
-    // It will be automatically filled after you finish the exercise.
+        true
+    }
+}
+
+trait OtherTrait {
+    fn other_function(&self) -> bool {
+        true
+    }
+}
+
+struct SomeStruct;
+impl SomeTrait for SomeStruct {}
+impl OtherTrait for SomeStruct {}
+
+struct OtherStruct;
+impl SomeTrait for OtherStruct {}
+impl OtherTrait for OtherStruct {}
+
+fn some_func(item: impl SomeTrait + OtherTrait) -> bool {
+    //             ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+    item.some_function() && item.other_function()
+}
+
+fn main() {
+    // You can optionally experiment here.
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_some_func() {
+        assert!(some_func(SomeStruct));
+        assert!(some_func(OtherStruct));
+    }
 }

solutions/16_lifetimes/lifetimes1.rs

@@ -1,4 +1,28 @@
-fn main() {
+// The Rust compiler needs to know how to check whether supplied references are
-    // DON'T EDIT THIS SOLUTION FILE!
+// valid, so that it can let the programmer know if a reference is at risk of
-    // It will be automatically filled after you finish the exercise.
+// going out of scope before it is used. Remember, references are borrows and do
+// not own their own data. What if their owner goes out of scope?
+
+fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
+    //    ^^^^     ^^          ^^          ^^
+    if x.len() > y.len() {
+        x
+    } else {
+        y
+    }
+}
+
+fn main() {
+    // You can optionally experiment here.
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_longest() {
+        assert_eq!(longest("abcd", "123"), "abcd");
+        assert_eq!(longest("abc", "1234"), "1234");
+    }
 }

solutions/16_lifetimes/lifetimes2.rs

@@ -1,4 +1,33 @@
-fn main() {
+fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
-    // DON'T EDIT THIS SOLUTION FILE!
+    if x.len() > y.len() {
-    // It will be automatically filled after you finish the exercise.
+        x
+    } else {
+        y
+    }
+}
+
+fn main() {
+    let string1 = String::from("long string is long");
+    // Solution1: You can move `strings2` out of the inner block so that it is
+    // not dropped before the print statement.
+    let string2 = String::from("xyz");
+    let result;
+    {
+        result = longest(&string1, &string2);
+    }
+    println!("The longest string is '{result}'");
+    // `string2` dropped at the end of the function.
+
+    // =========================================================================
+
+    let string1 = String::from("long string is long");
+    let result;
+    {
+        let string2 = String::from("xyz");
+        result = longest(&string1, &string2);
+        // Solution2: You can move the print statement into the inner block so
+        // that it is executed before `string2` is dropped.
+        println!("The longest string is '{result}'");
+        // `string2` dropped here (end of the inner scope).
+    }
 }

solutions/16_lifetimes/lifetimes3.rs

@@ -1,4 +1,18 @@
-fn main() {
+// Lifetimes are also needed when structs hold references.
-    // DON'T EDIT THIS SOLUTION FILE!
+
-    // It will be automatically filled after you finish the exercise.
+struct Book<'a> {
+    //     ^^^^ added a lifetime annotation
+    author: &'a str,
+    //       ^^
+    title: &'a str,
+    //      ^^
+}
+
+fn main() {
+    let book = Book {
+        author: "George Orwell",
+        title: "1984",
+    };
+
+    println!("{} by {}", book.title, book.author);
 }

solutions/17_tests/tests1.rs

@@ -1,4 +1,24 @@
-fn main() {
+// Tests are important to ensure that your code does what you think it should
-    // DON'T EDIT THIS SOLUTION FILE!
+// do.
-    // It will be automatically filled after you finish the exercise.
+
+fn is_even(n: i64) -> bool {
+    n % 2 == 0
+}
+
+fn main() {
+    // You can optionally experiment here.
+}
+
+#[cfg(test)]
+mod tests {
+    // When writing unit tests, it is common to import everything from the outer
+    // module (`super`) using a wildcard.
+    use super::*;
+
+    #[test]
+    fn you_can_assert() {
+        assert!(is_even(0));
+        assert!(!is_even(-1));
+        //      ^ You can assert `false` using the negation operator `!`.
+    }
 }

solutions/17_tests/tests2.rs

@@ -1,4 +1,22 @@
-fn main() {
+// Calculates the power of 2 using a bit shift.
-    // DON'T EDIT THIS SOLUTION FILE!
+// `1 << n` is equivalent to "2 to the power of n".
-    // It will be automatically filled after you finish the exercise.
+fn power_of_2(n: u8) -> u64 {
+    1 << n
+}
+
+fn main() {
+    // You can optionally experiment here.
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn you_can_assert_eq() {
+        assert_eq!(power_of_2(0), 1);
+        assert_eq!(power_of_2(1), 2);
+        assert_eq!(power_of_2(2), 4);
+        assert_eq!(power_of_2(3), 8);
+    }
 }

solutions/17_tests/tests3.rs

@@ -1,4 +1,45 @@
-fn main() {
+struct Rectangle {
-    // DON'T EDIT THIS SOLUTION FILE!
+    width: i32,
-    // It will be automatically filled after you finish the exercise.
+    height: i32,
+}
+
+impl Rectangle {
+    // Don't change this function.
+    fn new(width: i32, height: i32) -> Self {
+        if width <= 0 || height <= 0 {
+            // Returning a `Result` would be better here. But we want to learn
+            // how to test functions that can panic.
+            panic!("Rectangle width and height must be positive");
+        }
+
+        Rectangle { width, height }
+    }
+}
+
+fn main() {
+    // You can optionally experiment here.
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn correct_width_and_height() {
+        let rect = Rectangle::new(10, 20);
+        assert_eq!(rect.width, 10); // Check width
+        assert_eq!(rect.height, 20); // Check height
+    }
+
+    #[test]
+    #[should_panic] // Added this attribute to check that the test panics.
+    fn negative_width() {
+        let _rect = Rectangle::new(-10, 10);
+    }
+
+    #[test]
+    #[should_panic] // Added this attribute to check that the test panics.
+    fn negative_height() {
+        let _rect = Rectangle::new(10, -10);
+    }
 }

solutions/18_iterators/iterators1.rs

@@ -1,4 +1,26 @@
+// 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.
+
 fn main() {
-    // DON'T EDIT THIS SOLUTION FILE!
+    // You can optionally experiment here.
-    // It will be automatically filled after you finish the exercise.
+}
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn iterators() {
+        let my_fav_fruits = ["banana", "custard apple", "avocado", "peach", "raspberry"];
+
+        // Create an iterator over the array.
+        let mut fav_fruits_iterator = my_fav_fruits.iter();
+
+        assert_eq!(fav_fruits_iterator.next(), Some(&"banana"));
+        assert_eq!(fav_fruits_iterator.next(), Some(&"custard apple"));
+        assert_eq!(fav_fruits_iterator.next(), Some(&"avocado"));
+        assert_eq!(fav_fruits_iterator.next(), Some(&"peach"));
+        assert_eq!(fav_fruits_iterator.next(), Some(&"raspberry"));
+        assert_eq!(fav_fruits_iterator.next(), None);
+        //                                     ^^^^ reached the end
+    }
 }

solutions/18_iterators/iterators2.rs

@@ -1,4 +1,56 @@
-fn main() {
+// In this exercise, you'll learn some of the unique advantages that iterators
-    // DON'T EDIT THIS SOLUTION FILE!
+// can offer.
-    // It will be automatically filled after you finish the exercise.
+
+// "hello" -> "Hello"
+fn capitalize_first(input: &str) -> String {
+    let mut chars = input.chars();
+    match chars.next() {
+        None => String::new(),
+        Some(first) => first.to_uppercase().to_string() + chars.as_str(),
+    }
+}
+
+// Apply the `capitalize_first` function to a slice of string slices.
+// Return a vector of strings.
+// ["hello", "world"] -> ["Hello", "World"]
+fn capitalize_words_vector(words: &[&str]) -> Vec<String> {
+    words.iter().map(|word| capitalize_first(word)).collect()
+}
+
+// Apply the `capitalize_first` function again to a slice of string
+// slices. Return a single string.
+// ["hello", " ", "world"] -> "Hello World"
+fn capitalize_words_string(words: &[&str]) -> String {
+    words.iter().map(|word| capitalize_first(word)).collect()
+}
+
+fn main() {
+    // You can optionally experiment here.
+}
+
+#[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");
+    }
 }

solutions/18_iterators/iterators3.rs

@@ -1,4 +1,86 @@
-fn main() {
+#[derive(Debug, PartialEq, Eq)]
-    // DON'T EDIT THIS SOLUTION FILE!
+enum DivisionError {
-    // It will be automatically filled after you finish the exercise.
+    // Example: 42 / 0
+    DivideByZero,
+    // Only case for `i64`: `i64::MIN / -1` because the result is `i64::MAX + 1`
+    IntegerOverflow,
+    // Example: 5 / 2 = 2.5
+    NotDivisible,
+}
+
+fn divide(a: i64, b: i64) -> Result<i64, DivisionError> {
+    if b == 0 {
+        return Err(DivisionError::DivideByZero);
+    }
+
+    if a == i64::MIN && b == -1 {
+        return Err(DivisionError::IntegerOverflow);
+    }
+
+    if a % b != 0 {
+        return Err(DivisionError::NotDivisible);
+    }
+
+    Ok(a / b)
+}
+
+fn result_with_list() -> Result<Vec<i64>, DivisionError> {
+    //                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+    let numbers = [27, 297, 38502, 81];
+    let division_results = numbers.into_iter().map(|n| divide(n, 27));
+    // Collects to the expected return type. Returns the first error in the
+    // division results (if one exists).
+    division_results.collect()
+}
+
+fn list_of_results() -> Vec<Result<i64, DivisionError>> {
+    //               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+    let numbers = [27, 297, 38502, 81];
+    let division_results = numbers.into_iter().map(|n| divide(n, 27));
+    // Collects to the expected return type.
+    division_results.collect()
+}
+
+fn main() {
+    // You can optionally experiment here.
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_success() {
+        assert_eq!(divide(81, 9), Ok(9));
+    }
+
+    #[test]
+    fn test_divide_by_0() {
+        assert_eq!(divide(81, 0), Err(DivisionError::DivideByZero));
+    }
+
+    #[test]
+    fn test_integer_overflow() {
+        assert_eq!(divide(i64::MIN, -1), Err(DivisionError::IntegerOverflow));
+    }
+
+    #[test]
+    fn test_not_divisible() {
+        assert_eq!(divide(81, 6), Err(DivisionError::NotDivisible));
+    }
+
+    #[test]
+    fn test_divide_0_by_something() {
+        assert_eq!(divide(0, 81), Ok(0));
+    }
+
+    #[test]
+    fn test_result_with_list() {
+        assert_eq!(result_with_list().unwrap(), [1, 11, 1426, 3]);
+    }
+
+    #[test]
+    fn test_list_of_results() {
+        assert_eq!(list_of_results(), [Ok(1), Ok(11), Ok(1426), Ok(3)]);
+    }
 }

solutions/18_iterators/iterators4.rs

@@ -1,4 +1,72 @@
-fn main() {
+// 3 possible solutions are presented.
-    // DON'T EDIT THIS SOLUTION FILE!
+
-    // It will be automatically filled after you finish the exercise.
+// With `for` loop and a mutable variable.
+fn factorial_for(num: u64) -> u64 {
+    let mut result = 1;
+
+    for x in 2..=num {
+        result *= x;
+    }
+
+    result
+}
+
+// Equivalent to `factorial_for` but shorter and without a `for` loop and
+// mutable variables.
+fn factorial_fold(num: u64) -> u64 {
+    // Case num==0: The iterator 2..=0 is empty
+    //              -> The initial value of `fold` is returned which is 1.
+    // Case num==1: The iterator 2..=1 is also empty
+    //              -> The initial value 1 is returned.
+    // Case num==2: The iterator 2..=2 contains one element
+    //              -> The initial value 1 is multiplied by 2 and the result
+    //                 is returned.
+    // Case num==3: The iterator 2..=3 contains 2 elements
+    //              -> 1 * 2 is calculated, then the result 2 is multiplied by
+    //                 the second element 3 so the result 6 is returned.
+    // And so on…
+    #[allow(clippy::unnecessary_fold)]
+    (2..=num).fold(1, |acc, x| acc * x)
+}
+
+// Equivalent to `factorial_fold` but with a built-in method that is suggested
+// by Clippy.
+fn factorial_product(num: u64) -> u64 {
+    (2..=num).product()
+}
+
+fn main() {
+    // You can optionally experiment here.
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn factorial_of_0() {
+        assert_eq!(factorial_for(0), 1);
+        assert_eq!(factorial_fold(0), 1);
+        assert_eq!(factorial_product(0), 1);
+    }
+
+    #[test]
+    fn factorial_of_1() {
+        assert_eq!(factorial_for(1), 1);
+        assert_eq!(factorial_fold(1), 1);
+        assert_eq!(factorial_product(1), 1);
+    }
+    #[test]
+    fn factorial_of_2() {
+        assert_eq!(factorial_for(2), 2);
+        assert_eq!(factorial_fold(2), 2);
+        assert_eq!(factorial_product(2), 2);
+    }
+
+    #[test]
+    fn factorial_of_4() {
+        assert_eq!(factorial_for(4), 24);
+        assert_eq!(factorial_fold(4), 24);
+        assert_eq!(factorial_product(4), 24);
+    }
 }

solutions/18_iterators/iterators5.rs

@@ -1,4 +1,168 @@
-fn main() {
+// Let's define a simple model to track Rustlings' exercise progress. Progress
-    // DON'T EDIT THIS SOLUTION FILE!
+// will be modelled using a hash map. The name of the exercise is the key and
-    // It will be automatically filled after you finish the exercise.
+// 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 to not use imperative loops (for/while).
+
+use 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 hash map with `String` keys and `Progress` values.
+    // map = { "variables1": Complete, "from_str": None, … }
+    map.values().filter(|val| **val == value).count()
+}
+
+fn count_collection_for(collection: &[HashMap<String, Progress>], value: Progress) -> usize {
+    let mut count = 0;
+    for map in collection {
+        count += count_for(map, value);
+    }
+    count
+}
+
+fn count_collection_iterator(collection: &[HashMap<String, Progress>], value: Progress) -> usize {
+    // `collection` is a slice of hash maps.
+    // collection = [{ "variables1": Complete, "from_str": None, … },
+    //               { "variables2": Complete, … }, … ]
+    collection
+        .iter()
+        .map(|map| count_iterator(map, value))
+        .sum()
+}
+
+// Equivalent to `count_collection_iterator` and `count_iterator`, iterating as
+// if the collection was a single container instead of a container of containers
+// (and more accurately, a single iterator instead of an iterator of iterators).
+fn count_collection_iterator_flat(
+    collection: &[HashMap<String, Progress>],
+    value: Progress,
+) -> usize {
+    // `collection` is a slice of hash maps.
+    // collection = [{ "variables1": Complete, "from_str": None, … },
+    //               { "variables2": Complete, … }, … ]
+    collection
+        .iter()
+        .flat_map(HashMap::values) // or just `.flatten()` when wanting the default iterator (`HashMap::iter`)
+        .filter(|val| **val == value)
+        .count()
+}
+
+fn main() {
+    // You can optionally experiment here.
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use Progress::*;
+
+    fn get_map() -> HashMap<String, 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>> {
+        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]
+    }
+
+    #[test]
+    fn count_complete() {
+        let map = get_map();
+        assert_eq!(count_iterator(&map, Complete), 3);
+    }
+
+    #[test]
+    fn count_some() {
+        let map = get_map();
+        assert_eq!(count_iterator(&map, Some), 1);
+    }
+
+    #[test]
+    fn count_none() {
+        let map = get_map();
+        assert_eq!(count_iterator(&map, None), 2);
+    }
+
+    #[test]
+    fn count_complete_equals_for() {
+        let map = get_map();
+        let progress_states = [Complete, Some, 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!(count_collection_iterator(&collection, Complete), 6);
+        assert_eq!(count_collection_iterator_flat(&collection, Complete), 6);
+    }
+
+    #[test]
+    fn count_collection_some() {
+        let collection = get_vec_map();
+        assert_eq!(count_collection_iterator(&collection, Some), 1);
+        assert_eq!(count_collection_iterator_flat(&collection, Some), 1);
+    }
+
+    #[test]
+    fn count_collection_none() {
+        let collection = get_vec_map();
+        assert_eq!(count_collection_iterator(&collection, None), 4);
+        assert_eq!(count_collection_iterator_flat(&collection, None), 4);
+    }
+
+    #[test]
+    fn count_collection_equals_for() {
+        let collection = get_vec_map();
+        let progress_states = [Complete, Some, None];
+
+        for progress_state in progress_states {
+            assert_eq!(
+                count_collection_for(&collection, progress_state),
+                count_collection_iterator(&collection, progress_state),
+            );
+            assert_eq!(
+                count_collection_for(&collection, progress_state),
+                count_collection_iterator_flat(&collection, progress_state),
+            );
+        }
+    }
 }

solutions/quizzes/quiz3.rs

@@ -1,4 +1,65 @@
-fn main() {
+// An imaginary magical school has a new report card generation system written
-    // DON'T EDIT THIS SOLUTION FILE!
+// in Rust! Currently, the system only supports creating report cards where the
-    // It will be automatically filled after you finish the exercise.
+// 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 in addition to numerical ones.
+
+use std::fmt::Display;
+
+// Make the struct generic over `T`.
+struct ReportCard<T> {
+    //           ^^^
+    grade: T,
+    //     ^
+    student_name: String,
+    student_age: u8,
+}
+
+// To be able to print the grade, it has to implement the `Display` trait.
+impl<T: Display> ReportCard<T> {
+    //  ^^^^^^^ require that `T` implements `Display`.
+    fn print(&self) -> String {
+        format!(
+            "{} ({}) - achieved a grade of {}",
+            &self.student_name, &self.student_age, &self.grade,
+        )
+    }
+}
+
+fn main() {
+    // You can optionally experiment here.
+}
+
+#[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() {
+        let report_card = ReportCard {
+            grade: "A+",
+            student_name: "Gary Plotter".to_string(),
+            student_age: 11,
+        };
+        assert_eq!(
+            report_card.print(),
+            "Gary Plotter (11) - achieved a grade of A+",
+        );
+    }
 }