feedback to rustlings solution

[lime thorn]

Hi

I struggeled a lot with hashmaps 3 in the rustlings exercises. I now came up with a solution (by getting inspired a little by the internet lol) but I feel a little weird about some parts, especially related to ownership and the borrow checker and I'd like receiving some feedback / improvements 🙂

the code:

// 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, goals
// the team scored, and goals the team 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!

// Execute `rustlings hint hashmaps3` or use the `hint` watch subcommand for a hint.

// I AM NOT DONE

use std::collections::HashMap;

// A structure to store team name and its goal details.
struct Team {
    name: String,
    goals_scored: u8,
    goals_conceded: u8,
}

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<String, Team> = HashMap::new();

    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 number of goals conceded from team_2, and similarly
        // goals scored by team_2 will be the number of goals conceded by
        // team_1.

        let team_1 = scores.entry(team_1_name.clone()).or_insert(Team {
            name: team_1_name.clone(),
            goals_scored: 0,
            goals_conceded: 0,
        });
        team_1.goals_scored += team_1_score;
        team_1.goals_conceded += team_2_score;

        let team_2 = scores.entry(team_2_name.clone()).or_insert(Team {
            name: team_2_name.clone(),
            goals_scored: 0,
            goals_conceded: 0,
        });
        team_2.goals_scored += team_2_score;
        team_2.goals_conceded += team_1_score;
    }
    scores
}

especially all the team_x_name.clone()

thanks in advance

[sullen hamlet]

are you allowed to change the function signature to this? rs fn build_scores_table(results: &str) -> HashMap<&str, Team> {

that would get rid of literally all of the need for cloning I think

well, you would still need .to_owned() to get a String for the Team struct

with that, the function would be this ```rs
fn build_scores_table(results: &str) -> HashMap<&str, Team> {
let mut scores: HashMap<&str, Team> = HashMap::new();

for r in results.lines() {
    let v: Vec<&str> = r.split(',').collect();
    let team_1_name = v[0];
    let team_1_score: u8 = v[2].parse().unwrap();
    let team_2_name = v[1];
    let team_2_score: u8 = v[3].parse().unwrap();

    let team_1 = scores.entry(team_1_name).or_insert(Team {
        name: team_1_name.to_owned(),
        goals_scored: 0,
        goals_conceded: 0,
    });
    team_1.goals_scored += team_1_score;
    team_1.goals_conceded += team_2_score;

    let team_2 = scores.entry(team_2_name).or_insert(Team {
        name: team_2_name.to_owned(),
        goals_scored: 0,
        goals_conceded: 0,
    });
    team_2.goals_scored += team_2_score;
    team_2.goals_conceded += team_1_score;
}
scores

}```