exercises/07_structs/structs3.rs

@@ -25,8 +25,7 @@ impl Package {
 
     // TODO: Add the correct return type to the function signature.
     fn is_international(&self) {
-        // TODO: Read the tests that use this method to find out when a package
-        // is considered international.
+        // TODO: Read the tests that use this method to find out when a package is concidered international.
     }
 
     // TODO: Add the correct return type to the function signature.

exercises/10_modules/modules2.rs

@@ -2,7 +2,7 @@
 // the `use` and `as` keywords.
 
 mod delicious_snacks {
-    // TODO: Add the following two `use` statements after fixing them.
+    // TODO: Add the follwing two `use` statements after fixing them.
     // use self::fruits::PEAR as ???;
     // use self::veggies::CUCUMBER as ???;
 

exercises/11_hashmaps/hashmaps3.rs

@@ -1,38 +1,39 @@
 // A list of scores (one per line) of a soccer match is given. Each line is of
-// the form "<team_1_name>,<team_2_name>,<team_1_goals>,<team_2_goals>"
-// Example: "England,France,4,2" (England scored 4 goals, France 2).
+// the form : "<team_1_name>,<team_2_name>,<team_1_goals>,<team_2_goals>"
+// Example: England,France,4,2 (England scored 4 goals, France 2).
 //
 // You have to build a scores table containing the name of the team, the total
 // number of goals the team scored, and the total number of goals the team
-// conceded.
+// conceded. One approach to build the scores table is to use a Hashmap.
+// The solution is partially written to use a Hashmap,
+// complete it to pass the test.
+//
+// Make me pass the tests!
 
 use std::collections::HashMap;
 
 // A structure to store the goal details of a team.
-#[derive(Default)]
 struct Team {
     goals_scored: u8,
     goals_conceded: u8,
 }
 
-fn build_scores_table(results: &str) -> HashMap<&str, Team> {
+fn build_scores_table(results: String) -> HashMap<String, Team> {
     // The name of the team is the key and its associated struct is the value.
-    let mut scores = HashMap::new();
+    let mut scores: HashMap<String, Team> = HashMap::new();
 
-    for line in results.lines() {
-        let mut split_iterator = line.split(',');
-        // NOTE: We use `unwrap` because we didn't deal with error handling yet.
-        let team_1_name = split_iterator.next().unwrap();
-        let team_2_name = split_iterator.next().unwrap();
-        let team_1_score: u8 = split_iterator.next().unwrap().parse().unwrap();
-        let team_2_score: u8 = split_iterator.next().unwrap().parse().unwrap();
-
-        // TODO: Populate the scores table with the extracted details.
-        // Keep in mind that goals scored by team 1 will be the number of goals
-        // conceded by team 2. Similarly, goals scored by team 2 will be the
-        // number of goals conceded by team 1.
+    for r in results.lines() {
+        let v: Vec<&str> = r.split(',').collect();
+        let team_1_name = v[0].to_string();
+        let team_1_score: u8 = v[2].parse().unwrap();
+        let team_2_name = v[1].to_string();
+        let team_2_score: u8 = v[3].parse().unwrap();
+        // TODO: Populate the scores table with details extracted from the
+        // current line. Keep in mind that goals scored by team_1
+        // will be the number of goals conceded by team_2, and similarly
+        // goals scored by team_2 will be the number of goals conceded by
+        // team_1.
     }
-
     scores
 }
 
@@ -44,34 +45,40 @@ fn main() {
 mod tests {
     use super::*;
 
-    const RESULTS: &str = "England,France,4,2
-France,Italy,3,1
-Poland,Spain,2,0
-Germany,England,2,1
-England,Spain,1,0";
+    fn get_results() -> String {
+        let results = "".to_string()
+            + "England,France,4,2\n"
+            + "France,Italy,3,1\n"
+            + "Poland,Spain,2,0\n"
+            + "Germany,England,2,1\n";
+        results
+    }
 
     #[test]
     fn build_scores() {
-        let scores = build_scores_table(RESULTS);
+        let scores = build_scores_table(get_results());
 
-        assert!(["England", "France", "Germany", "Italy", "Poland", "Spain"]
-            .into_iter()
-            .all(|team_name| scores.contains_key(team_name)));
+        let mut keys: Vec<&String> = scores.keys().collect();
+        keys.sort();
+        assert_eq!(
+            keys,
+            vec!["England", "France", "Germany", "Italy", "Poland", "Spain"]
+        );
     }
 
     #[test]
     fn validate_team_score_1() {
-        let scores = build_scores_table(RESULTS);
+        let scores = build_scores_table(get_results());
         let team = scores.get("England").unwrap();
-        assert_eq!(team.goals_scored, 6);
+        assert_eq!(team.goals_scored, 5);
         assert_eq!(team.goals_conceded, 4);
     }
 
     #[test]
     fn validate_team_score_2() {
-        let scores = build_scores_table(RESULTS);
+        let scores = build_scores_table(get_results());
         let team = scores.get("Spain").unwrap();
         assert_eq!(team.goals_scored, 0);
-        assert_eq!(team.goals_conceded, 3);
+        assert_eq!(team.goals_conceded, 2);
     }
 }

exercises/quizzes/quiz2.rs

@@ -11,11 +11,10 @@
 // - Uppercase the string
 // - Trim the string
 // - Append "bar" to the string a specified amount of times
-//
 // The exact form of this will be:
-// - The input is going to be a vector of a 2-length tuple,
+// - The input is going to be a Vector of a 2-length tuple,
 //   the first element is the string, the second one is the command.
-// - The output element is going to be a vector of strings.
+// - The output element is going to be a Vector of strings.
 
 enum Command {
     Uppercase,
@@ -26,8 +25,15 @@ enum Command {
 mod my_module {
     use super::Command;
 
-    // TODO: Complete the function.
-    // pub fn transformer(input: ???) -> ??? { ??? }
+    // TODO: Complete the function signature!
+    pub fn transformer(input: ???) -> ??? {
+        // TODO: Complete the output declaration!
+        let mut output: ??? = vec![];
+        for (string, command) in input.iter() {
+            // TODO: Complete the function body. You can do it!
+        }
+        output
+    }
 }
 
 fn main() {
@@ -37,27 +43,20 @@ fn main() {
 #[cfg(test)]
 mod tests {
     // TODO: What do we need to import to have `transformer` in scope?
-    // use ???;
+    use ???;
     use super::Command;
 
     #[test]
     fn it_works() {
-        let input = vec![
-            ("hello".to_string(), Command::Uppercase),
-            (" all roads lead to rome! ".to_string(), Command::Trim),
-            ("foo".to_string(), Command::Append(1)),
-            ("bar".to_string(), Command::Append(5)),
-        ];
-        let output = transformer(input);
-
-        assert_eq!(
-            output,
-            [
-                "HELLO",
-                "all roads lead to rome!",
-                "foobar",
-                "barbarbarbarbarbar",
-            ]
-        );
+        let output = transformer(vec![
+            ("hello".into(), Command::Uppercase),
+            (" all roads lead to rome! ".into(), Command::Trim),
+            ("foo".into(), Command::Append(1)),
+            ("bar".into(), Command::Append(5)),
+        ]);
+        assert_eq!(output[0], "HELLO");
+        assert_eq!(output[1], "all roads lead to rome!");
+        assert_eq!(output[2], "foobar");
+        assert_eq!(output[3], "barbarbarbarbarbar");
     }
 }

rustlings-macros/info.toml

@@ -574,18 +574,16 @@ https://doc.rust-lang.org/stable/book/ch08-03-hash-maps.html#only-inserting-a-va
 name = "hashmaps3"
 dir = "11_hashmaps"
 hint = """
-Hint 1: Use the `entry()` and `or_insert()` (or `or_insert_with()`) methods of
-        `HashMap` to insert the default value of `Team` if a team doesn't
-        exist in the table yet.
+Hint 1: Use the `entry()` and `or_insert()` methods of `HashMap` to insert
+        entries corresponding to each team in the scores table.
 
-Learn more in The Book:
-https://doc.rust-lang.org/stable/book/ch08-03-hash-maps.html#only-inserting-a-value-if-the-key-has-no-value
+Learn more at https://doc.rust-lang.org/stable/book/ch08-03-hash-maps.html#only-inserting-a-value-if-the-key-has-no-value
 
 Hint 2: If there is already an entry for a given key, the value returned by
         `entry()` can be updated based on the existing value.
 
-Learn more in The Book:
-https://doc.rust-lang.org/book/ch08-03-hash-maps.html#updating-a-value-based-on-the-old-value"""
+Learn more at https://doc.rust-lang.org/book/ch08-03-hash-maps.html#updating-a-value-based-on-the-old-value
+"""
 
 # QUIZ 2
 

solutions/11_hashmaps/hashmaps3.rs

@@ -1,83 +1 @@
-// A list of scores (one per line) of a soccer match is given. Each line is of
-// the form "<team_1_name>,<team_2_name>,<team_1_goals>,<team_2_goals>"
-// Example: "England,France,4,2" (England scored 4 goals, France 2).
-//
-// You have to build a scores table containing the name of the team, the total
-// number of goals the team scored, and the total number of goals the team
-// conceded.
-
-use std::collections::HashMap;
-
-// A structure to store the goal details of a team.
-#[derive(Default)]
-struct Team {
-    goals_scored: u8,
-    goals_conceded: u8,
-}
-
-fn build_scores_table(results: &str) -> HashMap<&str, Team> {
-    // The name of the team is the key and its associated struct is the value.
-    let mut scores = HashMap::new();
-
-    for line in results.lines() {
-        let mut split_iterator = line.split(',');
-        // NOTE: We use `unwrap` because we didn't deal with error handling yet.
-        let team_1_name = split_iterator.next().unwrap();
-        let team_2_name = split_iterator.next().unwrap();
-        let team_1_score: u8 = split_iterator.next().unwrap().parse().unwrap();
-        let team_2_score: u8 = split_iterator.next().unwrap().parse().unwrap();
-
-        // Insert the default with zeros if a team doesn't exist yet.
-        let mut team_1 = scores.entry(team_1_name).or_insert_with(|| Team::default());
-        // Update the values.
-        team_1.goals_scored += team_1_score;
-        team_1.goals_conceded += team_2_score;
-
-        // Similarely for the second team.
-        let mut team_2 = scores.entry(team_2_name).or_insert_with(|| Team::default());
-        team_2.goals_scored += team_2_score;
-        team_2.goals_conceded += team_1_score;
-    }
-
-    scores
-}
-
-fn main() {
-    // You can optionally experiment here.
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    const RESULTS: &str = "England,France,4,2
-France,Italy,3,1
-Poland,Spain,2,0
-Germany,England,2,1
-England,Spain,1,0";
-
-    #[test]
-    fn build_scores() {
-        let scores = build_scores_table(RESULTS);
-
-        assert!(["England", "France", "Germany", "Italy", "Poland", "Spain"]
-            .into_iter()
-            .all(|team_name| scores.contains_key(team_name)));
-    }
-
-    #[test]
-    fn validate_team_score_1() {
-        let scores = build_scores_table(RESULTS);
-        let team = scores.get("England").unwrap();
-        assert_eq!(team.goals_scored, 6);
-        assert_eq!(team.goals_conceded, 4);
-    }
-
-    #[test]
-    fn validate_team_score_2() {
-        let scores = build_scores_table(RESULTS);
-        let team = scores.get("Spain").unwrap();
-        assert_eq!(team.goals_scored, 0);
-        assert_eq!(team.goals_conceded, 3);
-    }
-}
+// Solutions will be available before the stable release. Thank you for testing the beta version 🥰

solutions/quizzes/quiz2.rs

@@ -1,107 +1 @@
-// This is a quiz for the following sections:
-// - Strings
-// - Vecs
-// - Move semantics
-// - Modules
-// - Enums
-//
-// Let's build a little machine in the form of a function. As input, we're going
-// to give a list of strings and commands. These commands determine what action
-// is going to be applied to the string. It can either be:
-// - Uppercase the string
-// - Trim the string
-// - Append "bar" to the string a specified amount of times
-//
-// The exact form of this will be:
-// - The input is going to be a vector of a 2-length tuple,
-//   the first element is the string, the second one is the command.
-// - The output element is going to be a vector of strings.
-
-enum Command {
-    Uppercase,
-    Trim,
-    Append(usize),
-}
-
-mod my_module {
-    use super::Command;
-
-    // The solution with a loop. Check out `transformer_iter` for a version
-    // with iterators.
-    pub fn transformer(input: Vec<(String, Command)>) -> Vec<String> {
-        let mut output = Vec::new();
-
-        for (mut string, command) in input {
-            // Create the new string.
-            let new_string = match command {
-                Command::Uppercase => string.to_uppercase(),
-                Command::Trim => string.trim().to_string(),
-                Command::Append(n) => {
-                    for _ in 0..n {
-                        string += "bar";
-                    }
-                    string
-                }
-            };
-
-            // Push the new string to the output vector.
-            output.push(new_string);
-        }
-
-        output
-    }
-
-    // Equivalent to `transform` but uses an iterator instead of a loop for
-    // comparison. Don't worry, we will practice iterators later ;)
-    pub fn transformer_iter(input: Vec<(String, Command)>) -> Vec<String> {
-        input
-            .into_iter()
-            .map(|(mut string, command)| match command {
-                Command::Uppercase => string.to_uppercase(),
-                Command::Trim => string.trim().to_string(),
-                Command::Append(n) => {
-                    for _ in 0..n {
-                        string += "bar";
-                    }
-                    string
-                }
-            })
-            .collect()
-    }
-}
-
-fn main() {
-    // You can optionally experiment here.
-}
-
-#[cfg(test)]
-mod tests {
-    // Import `transformer`.
-    use super::my_module::transformer;
-
-    use super::my_module::transformer_iter;
-    use super::Command;
-
-    #[test]
-    fn it_works() {
-        for transformer in [transformer, transformer_iter] {
-            let input = vec![
-                ("hello".to_string(), Command::Uppercase),
-                (" all roads lead to rome! ".to_string(), Command::Trim),
-                ("foo".to_string(), Command::Append(1)),
-                ("bar".to_string(), Command::Append(5)),
-            ];
-            let output = transformer(input);
-
-            assert_eq!(
-                output,
-                [
-                    "HELLO",
-                    "all roads lead to rome!",
-                    "foobar",
-                    "barbarbarbarbarbar",
-                ]
-            );
-        }
-    }
-}
+// Solutions will be available before the stable release. Thank you for testing the beta version 🥰