Skip to main content

Hashmaps

hashmaps1.rs​

// A basket of fruits in the form of a hash map needs to be defined. The key
// represents the name of the fruit and the value represents how many of that
// particular fruit is in the basket. You have to put at least 3 different
// types of fruits (e.g. apple, banana, mango) in the basket and the total count
// of all the fruits should be at least 5.

use std::collections::HashMap;

fn fruit_basket() -> HashMap<String, u32> {
    // TODO: Declare the hash map.
    let mut basket = HashMap::new();

    // Two bananas are already given for you :)
    basket.insert(String::from("banana"), 2);
    basket.insert(String::from("apple"), 5);
    basket.insert(String::from("mango"), 10);

    basket
}

fn main() {
    // You can optionally experiment here.
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn at_least_three_types_of_fruits() {
        let basket = fruit_basket();
        assert!(basket.len() >= 3);
    }

    #[test]
    fn at_least_five_fruits() {
        let basket = fruit_basket();
        assert!(basket.values().sum::<u32>() >= 5);
    }
}

  • I this exercise we just need to declare new HashMap and insert more entries into it until at least we have 5 total values.

  • We can define new HashMap like this:

    let mut basket = HashMap::new();

  • As you can see we are not defining any types explicitly here because rust will infer it.

  • But we need to make sure all the keys have the same type and all the values also have the same types.

  • The we need to add more entries into the hashmap by using insert method.

hashmaps2.rs​

// We're collecting different fruits to bake a delicious fruit cake. For this,
// we have a basket, which we'll represent in the form of a hash map. The key
// represents the name of each fruit we collect and the value represents how
// many of that particular fruit we have collected. Three types of fruits -
// Apple (4), Mango (2) and Lychee (5) are already in the basket hash map. You
// must add fruit to the basket so that there is at least one of each kind and
// more than 11 in total - we have a lot of mouths to feed. You are not allowed
// to insert any more of the fruits that are already in the basket (Apple,
// Mango, and Lychee).

use std::collections::HashMap;

#[derive(Hash, PartialEq, Eq, Debug)]
enum Fruit {
    Apple,
    Banana,
    Mango,
    Lychee,
    Pineapple,
}

fn fruit_basket(basket: &mut HashMap<Fruit, u32>) {
    let fruit_kinds = [
        Fruit::Apple,
        Fruit::Banana,
        Fruit::Mango,
        Fruit::Lychee,
        Fruit::Pineapple,
    ];

    for fruit in fruit_kinds {
        // TODO: Insert new fruits if they are not already present in the
        // basket. Note that you are not allowed to put any type of fruit that's
        // already present!
        if basket.get(&fruit).is_none() {
            basket.insert(fruit, 5);
        }
    }
}

fn main() {
    // You can optionally experiment here.
}

#[cfg(test)]
mod tests {
    use super::*;

    // Don't modify this function!
    fn get_fruit_basket() -> HashMap<Fruit, u32> {
        let content = [(Fruit::Apple, 4), (Fruit::Mango, 2), (Fruit::Lychee, 5)];
        HashMap::from_iter(content)
    }

    #[test]
    fn test_given_fruits_are_not_modified() {
        let mut basket = get_fruit_basket();
        fruit_basket(&mut basket);
        assert_eq!(*basket.get(&Fruit::Apple).unwrap(), 4);
        assert_eq!(*basket.get(&Fruit::Mango).unwrap(), 2);
        assert_eq!(*basket.get(&Fruit::Lychee).unwrap(), 5);
    }

    #[test]
    fn at_least_five_types_of_fruits() {
        let mut basket = get_fruit_basket();
        fruit_basket(&mut basket);
        let count_fruit_kinds = basket.len();
        assert!(count_fruit_kinds >= 5);
    }

    #[test]
    fn greater_than_eleven_fruits() {
        let mut basket = get_fruit_basket();
        fruit_basket(&mut basket);
        let count = basket.values().sum::<u32>();
        assert!(count > 11);
    }

    #[test]
    fn all_fruit_types_in_basket() {
        let fruit_kinds = [
            Fruit::Apple,
            Fruit::Banana,
            Fruit::Mango,
            Fruit::Lychee,
            Fruit::Pineapple,
        ];

        let mut basket = get_fruit_basket();
        fruit_basket(&mut basket);

        for fruit_kind in fruit_kinds {
            let Some(amount) = basket.get(&fruit_kind) else {
                panic!("Fruit kind {fruit_kind:?} was not found in basket");
            };
            assert!(*amount > 0);
        }
    }
}

  • In this example we need to insert new fruits if they are not already present in the basket.

  • We can do this in multiple different ways.

  • First is by checking if the key exist if not the insert it:

    if basket.get(&fruit).is_none() {
      basket.insert(fruit, 5);
    }

  • Or we can use Entry like this:

    basket.entry(fruit).or_insert(5);

  • You can read more about entry in here: https://doc.rust-lang.org/beta/std/collections/hash_map/enum.Entry.html.

hashmaps3.rs​

// 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 TeamScores {
    goals_scored: u8,
    goals_conceded: u8,
}

fn build_scores_table(results: &str) -> HashMap<&str, TeamScores> {
    // The name of the team is the key and its associated struct is the value.
    let mut scores = HashMap::<&str, TeamScores>::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.

        // team 1
        scores
            .entry(team_1_name)
            .and_modify(|score| {
                score.goals_scored += team_1_score;
                score.goals_conceded += team_2_score
            })
            .or_insert(TeamScores {
                goals_scored: team_1_score,
                goals_conceded: team_2_score,
            });

        // team 2
        scores
            .entry(team_2_name)
            .and_modify(|score| {
                score.goals_scored += team_2_score;
                score.goals_conceded += team_1_score
            })
            .or_insert(TeamScores {
                goals_scored: team_2_score,
                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);
    }
}

  • In this example we need to build a score table that contains:

    • Team Name: Key
    • Goals Scored: TeamScores.goals_scored
    • Goals Conceded TeamScores.goals_conceded

  • There are multiple ways to do this and mostly we will use Entry because its more convenient.

  • First we can use and_modify with or_insert like this:

    // team 1
    scores
        .entry(team_1_name)
        .and_modify(| score | {
            score.goals_scored += team_1_score;
            score.goals_conceded += team_2_score
        })
        .or_insert(TeamScores {
            goals_scored: team_1_score,
            goals_conceded: team_2_score,
        });

    // team 2
    scores
        .entry(team_2_name)
        .and_modify(| score | {
            score.goals_scored += team_2_score;
            score.goals_conceded += team_1_score
        })
        .or_insert(TeamScores {
            goals_scored: team_2_score,
            goals_conceded: team_1_score,
        });

  • Or by using or_default and then adding the score like this:

    // Insert the default with zeros if a team doesn't exist yet.
    let team_1 = scores.entry(team_1_name).or_default();
    // Update the values.
    team_1.goals_scored += team_1_score;
    team_1.goals_conceded += team_2_score;

    // Similarly for the second team.
    let team_2 = scores.entry(team_2_name).or_default();
    team_2.goals_scored += team_2_score;
    team_2.goals_conceded += team_1_score;

  • Which one do you think is better?