Student Grades Tracker

Now that we know about vectors and hashmaps, let’s tackle something more challenging. In this exercise, we’ll build a system to manage and analyze student grades. This challenge will help you practice working with structs, hashmaps, vectors, and methods while managing a collection of data.

The focus here is on functionality. Ignore error handling for this challenge; assume the input is always valid.

Your Task

You need to define the StudentGrades struct, which contains a HashMap of student names (String) as keys and Student structs as values. Each Student struct should have the following fields:

name: The name of the student (String).
grades: A Vec<u8> to store the student's grades.

Implement the following methods for the StudentGrades struct:

add_student(name: &str): Add a new student to the HashMap. If the student already exists, do nothing.
add_grade(name: &str, grade: u8): Add a grade to an existing student.
get_grades(name: &str) -> &[u8]: Retrieve the grades of a student as an immutable reference.
Since there’s no error handling, assume all inputs are valid, and keys will exist when accessed.

Hints

Click here to reveal hints

Use the HashMap methods like entry, insert, and get to manage student data.

Editor not available on Mobile!

In order to solve the challenge, please visit this page on a desktop computer.

Solutions

Rocky.C

cloki0610

7 hours ago

31.37ms

2099.20kb

use std::collections::HashMap;
pub struct Student {
    // 1. Define the fields
    pub name: String,
    pub grades: Vec<u8>
}
pub struct StudentGrades {
    // 2. Define the fields
    pub students: HashMap<String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    // 3. Implement the methods
    pub fn add_student(&mut self, name: &str) {
        // Implement here
        self.students.entry(name.to_string())
            .or_insert( Student 
                { name: name.to_string(), 
                  grades: Vec::new(),
                }
            );
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        // Implement here
        if let Some(student) = self.students.get_mut(&name.to_string()) {
            student.grades.push(grade);
        }
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        // Implement here
        if let Some(student) = self.students.get(name) {
            return &student.grades;
        }
        &[]
    }
}
// Example usage
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    println!("{:?}", tracker.get_grades("Alice")); // [85, 90]
    println!("{:?}", tracker.get_grades("Bob")); // [78]
}

Luigi Terrone

LuigiTer

18 hours ago

45.54ms

2099.20kb

use std::collections::HashMap;
pub struct Student {
    // 1. Define the fields
    pub name: String,
    pub grades: Vec<u8>,
}
pub struct StudentGrades {
    // 2. Define the fields
    pub students: HashMap<String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    // 3. Implement the methods
    pub fn add_student(&mut self, name: &str) {
        // Implement here
        self.students.entry(name.to_string())
            .or_insert( Student 
                { name: name.to_string(), 
                  grades: Vec::new(),
                }
            );
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        // Implement here
        if let Some(student) = self.students.get_mut(&name.to_string()) {
            student.grades.push(grade);
        }
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        // Implement here
        if let Some(student) = self.students.get(name) {
            &student.grades
        }
        else {
            &[]
        }
    }
}
// Example usage
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    println!("{:?}", tracker.get_grades("Alice")); // [85, 90]
    println!("{:?}", tracker.get_grades("Bob")); // [78]
}

Heino Mortensen

hmortensen83

2 days ago

32.15ms

2099.20kb

use std::collections::HashMap;
pub struct Student {
    name: String,
    grades: Vec<u8>,
}
pub struct StudentGrades {
    pub students: HashMap<String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    // 3. Implement the methods
    pub fn add_student(&mut self, name: &str) {
        if !self.students.contains_key(name) {
            self.students.insert(
                name.to_owned(),
                Student {
                    name: name.to_owned(),
                    grades: vec![],
                },
            );
        }
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        self.students.get_mut(name).unwrap().grades.push(grade);
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        &self.students[name].grades
    }
}
// Example usage
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    println!("{:?}", tracker.get_grades("Alice")); // [85, 90]
    println!("{:?}", tracker.get_grades("Bob")); // [78]
}

0x0f1

Paul4673

2 days ago

32.43ms

2099.20kb

use std::collections::HashMap;
pub struct Student {
    pub name : String,
    pub grade : Vec<u8>,
}
pub struct StudentGrades {
    pub students : HashMap<String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    // 3. Implement the methods
    pub fn add_student(&mut self, name: &str) {
        if !self.students.contains_key(name){
            self.students.insert(name.to_string(), Student { name: name.to_string(), grade: Vec::new() });
        }
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        if let Some(student) = self.students.get_mut(name){
            student.grade.push(grade);
        }
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        match self.students.get(name) {
            Some(student) => &student.grade,
            None => &[]
        }
    }
}
// Example usage
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    println!("{:?}", tracker.get_grades("Alice")); // [85, 90]
    println!("{:?}", tracker.get_grades("Bob")); // [78]
}

0x0f1

Paul4673

2 days ago

34.51ms

2099.20kb

use std::collections::HashMap;
pub struct Student {
    pub name : String,
    pub grade : Vec<u8>,
}
pub struct StudentGrades {
    pub students : HashMap<String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    // 3. Implement the methods
    pub fn add_student(&mut self, name: &str) {
        if !self.students.contains_key(name){
            self.students.insert(name.to_string(), Student { name: name.to_string(), grade: Vec::new() });
        }
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        match self.students.get_mut(name){
            Some(student) => student.grade.push(grade),
            None => println!("student doesnt exist"),
        }
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        match self.students.get(name) {
            Some(student) => &student.grade,
            None => &[]
        }
    }
}
// Example usage
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    println!("{:?}", tracker.get_grades("Alice")); // [85, 90]
    println!("{:?}", tracker.get_grades("Bob")); // [78]
}

dattruongdev

3 days ago

30.37ms

2099.20kb

use std::collections::HashMap;
pub struct Student {
    // 1. Define the fields
    pub name: String,
    pub grades: Vec<u8>
}
pub struct StudentGrades {
    // 2. Define the fields
    pub students: HashMap<String, Student>
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    // 3. Implement the methods
    pub fn add_student(&mut self, name: &str) {
        // Implement here
        self.students.insert(name.to_string(), Student {name: name.to_string(), grades: Vec::new()});
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        // Implement herej
        let student = self.students.get_mut(&name.to_string());
        student.unwrap().grades.push(grade);
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        // Implement here
        let student = self.students.get(&name.to_string());
        &student.unwrap().grades
    }
}
// Example usage
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    println!("{:?}", tracker.get_grades("Alice")); // [85, 90]
    println!("{:?}", tracker.get_grades("Bob")); // [78]
}

esl

esl07

3 days ago

30.95ms

2099.20kb

use std::collections::HashMap;
pub struct Student {
    pub name: String,
    pub grades: Vec<u8>,
}
pub struct StudentGrades {
    pub students: HashMap<String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    pub fn add_student(&mut self, name: &str) {
        self.students.entry(name.to_string()).or_insert(Student {
            name: name.to_string(),
            grades: Vec::new(),
        });
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        if let Some(student) = self.students.get_mut(name) {
            student.grades.push(grade);
        }
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        if let Some(student) = self.students.get(&name.to_string()) {
            &student.grades
        } else {
            &[]
        }
    }
}
// Example usage
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    println!("{:?}", tracker.get_grades("Alice")); // [85, 90]
    println!("{:?}", tracker.get_grades("Bob")); // [78]
}

silaskoemen

4 days ago

32.07ms

2099.20kb

use std::collections::HashMap;
pub struct Student {
    name: String,
    grades: Vec<u8>
}
pub struct StudentGrades {
    pub students: HashMap<String, Student>
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    // 3. Implement the methods
    pub fn add_student(&mut self, name: &str) {
        if !self.students.contains_key(name) {
            self.students.insert(String::from(name), Student {name: String::from(name), grades: Vec::new()});
        }
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        &self.students.get_mut(name).unwrap().grades.push(grade);
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        return &self.students.get(name).unwrap().grades
    }
}
// Example usage
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    println!("{:?}", tracker.get_grades("Alice")); // [85, 90]
    println!("{:?}", tracker.get_grades("Bob")); // [78]
}

xxxxsk

6 days ago

46.36ms

2099.20kb

use std::collections::HashMap;
pub struct Student {
    // 1. Define the fields
    name: String,
    grades: Vec<u8>,
}
pub struct StudentGrades {
    // 2. Define the fields
    pub students: HashMap<String, Student>
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    // 3. Implement the methods
    pub fn add_student(&mut self, name: &str) {
        // Implement here
        if !self.students.contains_key(name)  {
            self.students.insert(name.to_string(), Student {
                name: name.to_string(),
                grades: Vec::new(),
            });
        }
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        // Implement here
        self.students.get_mut(name).map(|student| {
            student.grades.push(grade);
        });
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        // Implement here
        self.students.get(name).unwrap().grades.as_slice()
    }
}
// Example usage
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    println!("{:?}", tracker.get_grades("Alice")); // [85, 90]
    println!("{:?}", tracker.get_grades("Bob")); // [78]
}

Pierre Gordo

PierreGordo

6 days ago

32.23ms

2099.20kb

use std::collections::HashMap;
pub struct Student {
    // 1. Define the fields
    pub name: String,
    pub grades: Vec<u8>,
}
pub struct StudentGrades {
    // 2. Define the fields
    pub students: HashMap<String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    // 3. Implement the methods
    pub fn add_student(&mut self, name: &str) {
        // Implement here
        //Check whether a student exists
        if self.students.contains_key(name){
            //do nothing
        }
        else{
            //add student
            self.students.insert(name.to_string(), Student{name: name.to_string(), grades: Vec::new()});
        }
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        // Implement here
        //if self.students.contains_key(name){
        //    self.students.get_mut(name).unwrap().grades.push(grade);
        //}
        if let Some(x) = self.students.get_mut(name){
            x.grades.push(grade);
        }
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        // Implement here
        return self.students[name].grades.as_slice()
        
    }
}
// Example usage
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    println!("{:?}", tracker.get_grades("Alice")); // [85, 90]
    println!("{:?}", tracker.get_grades("Bob")); // [78]
}

Pierre Gordo

PierreGordo

6 days ago

35.46ms

2099.20kb

use std::collections::HashMap;
pub struct Student {
    // 1. Define the fields
    pub name: String,
    pub grades: Vec<u8>,
}
pub struct StudentGrades {
    // 2. Define the fields
    pub students: HashMap<String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    // 3. Implement the methods
    pub fn add_student(&mut self, name: &str) {
        // Implement here
        //Check whether a student exists
        if self.students.contains_key(name){
            //do nothing
        }
        else{
            //add student
            self.students.insert(name.to_string(), Student{name: name.to_string(), grades: Vec::new()});
        }
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        // Implement here
        //if self.students.contains_key(name){
        //    self.students.get_mut(name).unwrap().grades.push(grade);
        //}
        if let Some(x) = self.students.get_mut(name){
            x.grades.push(grade);
        }
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        // Implement here
        return self.students[name].grades.as_slice()
        
    }
}
// Example usage
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    println!("{:?}", tracker.get_grades("Alice")); // [85, 90]
    println!("{:?}", tracker.get_grades("Bob")); // [78]
}

hahu07

7 days ago

28.45ms

2099.20kb

use std::collections::HashMap;
pub struct Student {
    // 1. Define the fields
    pub name: String,
    pub grades: Vec<u8>
}
pub struct StudentGrades {
    // 2. Define the fields
    pub students: HashMap<String, Student>
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    // 3. Implement the methods
    pub fn add_student(&mut self, name: &str) {
        // Implement here
        self.students.entry(name.to_string()).or_insert(
            Student{name: name.to_string(),
                    grades: vec![],
                    });
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        // Implement here
        let student = self.students.get_mut(&name.to_string());
        match student {
            Some(std) => std.grades.push(grade),
            None => println!("Not available")
        }
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        // Implement here
        let student = self.students.get(&name.to_string()).unwrap();
        &student.grades
    }
}
// Example usage
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    println!("{:?}", tracker.get_grades("Alice")); // [85, 90]
    println!("{:?}", tracker.get_grades("Bob")); // [78]
}

Lucop1911

8 days ago

28.29ms

2099.20kb

use std::collections::HashMap;
pub struct Student {
    pub name: String,
    pub grades: Vec<u8>,
}
pub struct StudentGrades {
    pub students: HashMap<String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    // 3. Implement the methods
    pub fn add_student(&mut self, name: &str) {
        self.students.entry(name.to_string()).or_insert(Student {
            name: name.to_string(),
            grades: vec![],
        });
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        let student = self.students.get_mut(&name.to_string());
        match student {
            Some(s) => s.grades.push(grade),
            None => println!("Not found!"),
        }
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        let student = self.students.get(&name.to_string()).unwrap();
        &student.grades
    }
}
// Example usage
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    println!("{:?}", tracker.get_grades("Alice")); // [85, 90]
    println!("{:?}", tracker.get_grades("Bob")); // [78]
}

ycgw

9 days ago

39.46ms

2099.20kb

use std::collections::HashMap;
pub struct Student {
    pub name: String,
    pub grades: Vec<u8>,
}
pub struct StudentGrades {
    pub students: HashMap<String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    // 3. Implement the methods
    pub fn add_student(&mut self, name: &str) {
        self.students.entry(name.to_string()).or_insert(Student {
            name: name.to_string(),
            grades: vec![],
        });
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        let student = self.students.get_mut(&name.to_string());
        match student {
            Some(s) => s.grades.push(grade),
            None => println!("Not found!"),
        }
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        let student = self.students.get(&name.to_string()).unwrap();
        &student.grades
    }
}
// Example usage
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    println!("{:?}", tracker.get_grades("Alice")); // [85, 90]
    println!("{:?}", tracker.get_grades("Bob")); // [78]
}

Christopher Kolbe

chkolbe

10 days ago

32.50ms

2099.20kb

use std::collections::HashMap;
pub struct Student {
    pub name: String,
    pub grades: Vec<u8>,
}
pub struct StudentGrades {
    pub students: HashMap<String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    pub fn add_student(&mut self, name: &str) {
        self.students.insert(
            name.to_string(), 
            Student{
                name: name.to_string(), 
                grades: Vec::new()
            }
        );
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        match self.students.get_mut(name) {
            None => (),
            Some(student) => student.grades.push(grade),
        }
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        match self.students.get(name) {
            None => &[],
            Some(student) => student.grades.as_slice()
        }
    }
}
// Example usage
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    println!("{:?}", tracker.get_grades("Alice")); // [85, 90]
    println!("{:?}", tracker.get_grades("Bob")); // [78]
}

s.i

ssmi75

11 days ago

46.49ms

2099.20kb

use std::collections::HashMap;
pub struct Student {
    pub name: String,
    pub grades: Vec<u8>,
}
pub struct StudentGrades {
    pub students: HashMap<String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    // 3. Implement the methods
    pub fn add_student(&mut self, name: &str) {
        if !self.students.contains_key(name) {
            self.students.insert(
                name.to_string(),
                Student{name: name.to_string(), grades: vec![]}
            );
        }
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        self.students.get_mut(name).unwrap().grades.push(grade)
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        &(self.students.get(name).unwrap().grades)
    }
}
// Example usage
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    println!("{:?}", tracker.get_grades("Alice")); // [85, 90]
    println!("{:?}", tracker.get_grades("Bob")); // [78]
}

ikatlinsky

11 days ago

71.87ms

2099.20kb

use std::collections::HashMap;
pub struct Student {
    pub name: String,
    pub grades: Vec<u8>,
}
pub struct StudentGrades {
    pub students: HashMap<String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    // 3. Implement the methods
    pub fn add_student(&mut self, name: &str) {
        if self.students.contains_key(name) {
            return;
        }
        self.students.insert(name.to_string(), Student { name: name.to_string(), grades: vec![]});
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        if !self.students.contains_key(name) {
            return;
        }
        self.students.entry(name.to_string()).and_modify(|s| s.grades.push(grade));
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        self.students.get(name).map(|s| &s.grades).unwrap()
    }
}
// Example usage
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    println!("{:?}", tracker.get_grades("Alice")); // [85, 90]
    println!("{:?}", tracker.get_grades("Bob")); // [78]
}

Riccardo-Adami

12 days ago

31.58ms

2099.20kb

use std::collections::HashMap;
pub struct Student {
    // 1. Define the fields
    pub name: String,
    pub grades: Vec<u8>,
}
pub struct StudentGrades {
    // 2. Define the fields
    pub students: HashMap<String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    // 3. Implement the methods
    pub fn add_student(&mut self, name: &str) {
        // Implement here
        if !self.students.contains_key(name){
            self.students.insert(
                name.to_string(),
                Student{
                    name: name.to_string(),
                    grades: Vec::new(),
                }
            );
        }
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        // Implement here
        if let Some(stud) = self.students.get_mut(name){
            stud.grades.push(grade);
        }
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        // Implement here
        self.students
        .get(name)
        .map(|student| &student.grades)
        .unwrap()
    }
}
// Example usage
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    println!("{:?}", tracker.get_grades("Alice")); // [85, 90]
    println!("{:?}", tracker.get_grades("Bob")); // [78]
}

diucicd

13 days ago

33.29ms

2099.20kb

use std::collections::HashMap;
pub struct Student {
    // 1. Define the fields
    pub name: String,
    pub grades: Vec<u8>,
}
pub struct StudentGrades {
    // 2. Define the fields
    pub students: HashMap<String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    // 3. Implement the methods
    pub fn add_student(&mut self, name: &str) {
        // Implement here
        if !self.students.contains_key(&name.to_string()) {
            self.students.insert(
                name.to_string(),
                Student {
                    name: name.to_string(),
                    grades: Vec::new(),
                },
            );
        }
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        // Implement here
        if let Some(student) = self.students.get_mut(name) {
            student.grades.push(grade);
        }
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        self.students
            .get(name)
            .map(|student| &student.grades)
            .unwrap()
    }
}
// Example usage
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    println!("{:?}", tracker.get_grades("Alice")); // [85, 90]
    println!("{:?}", tracker.get_grades("Bob")); // [78]
}

Hendrik Dreesmann

DeemanOne

15 days ago

44.76ms

2099.20kb

use std::collections::HashMap;
pub struct Student {
    // 1. Define the fields
    pub name:String,
    pub grades: Vec<u8>,
}
pub struct StudentGrades {
    // 2. Define the fields
    pub students: HashMap<String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    // 3. Implement the methods
    pub fn add_student(&mut self, name: &str) {
        // Implement here
        self.students.entry(name.to_string()).or_insert(Student {name:name.to_string(), grades: Vec::new()});
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        // Implement here
        self.students.entry(name.to_string()).and_modify(|student| student.grades.push(grade));
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        // Implement here
        &self.students.get(name).unwrap().grades 
    }
}
// Example usage
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    println!("{:?}", tracker.get_grades("Alice")); // [85, 90]
    println!("{:?}", tracker.get_grades("Bob")); // [78]
}

0x90

riccio8

16 days ago

32.50ms

2099.20kb

use std::collections::HashMap;
pub struct Student {
    // 1. Define the fields
    pub name: String,
    pub grades: Vec<u8>,
}
pub struct StudentGrades {
    // 2. Define the fields
    pub students: HashMap< String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    // 3. Implement the methods
    pub fn add_student(&mut self, name: &str) {
        // Implement here
        if !self.students.contains_key(name){
            self.students.insert(name.to_string(), Student{name: name.to_string(), grades: Vec::new()});
        }
        
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        // Implement here
        &self.students.get_mut(&name.to_string()).unwrap().grades.push(grade);
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        // Implement here
        &self.students.get(&name.to_string()).unwrap().grades
    }
}
// Example usage
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    println!("{:?}", tracker.get_grades("Alice")); // [85, 90]
    println!("{:?}", tracker.get_grades("Bob")); // [78]
}

0x90

riccio8

16 days ago

36.10ms

2099.20kb

use std::collections::HashMap;
pub struct Student {
    // 1. Define the fields
    pub name: String,
    pub grades: Vec<u8>,
}
pub struct StudentGrades {
    // 2. Define the fields
    pub students: HashMap< String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    // 3. Implement the methods
    pub fn add_student(&mut self, name: &str) {
        // Implement here
        if !self.students.contains_key(name){
            self.students.insert(name.to_string(), Student{name: name.to_string(), grades: Vec::new()});
        }
        
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        // Implement here
        &self.students.get_mut(&name.to_string()).unwrap().grades.push(grade);
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        // Implement here
        &self.students.get(&name.to_string()).unwrap().grades
    }
}
// Example usage
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    println!("{:?}", tracker.get_grades("Alice")); // [85, 90]
    println!("{:?}", tracker.get_grades("Bob")); // [78]
}

AQian

AQian0

18 days ago

35.58ms

2099.20kb

use std::collections::HashMap;
pub struct Student {
    // 1. Define the fields
    pub name: String,
    pub grades: Vec<u8>
}
pub struct StudentGrades {
    // 2. Define the fields
    pub students: HashMap<String, Student>
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    // 3. Implement the methods
    pub fn add_student(&mut self, name: &str) {
        // Implement here
        if let None = self.students.get(name) {
            self.students.insert(name.to_string(), Student {
                name: name.to_string(),
                grades: vec![]
            });
        }
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        // Implement here
        if let Some(x) = self.students.get_mut(name) {
            x.grades.push(grade);
        }
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        // Implement here
        &self.students.get(name).unwrap().grades
    }
}
// Example usage
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    println!("{:?}", tracker.get_grades("Alice")); // [85, 90]
    println!("{:?}", tracker.get_grades("Bob")); // [78]
}

annececiledunand

19 days ago

32.18ms

2099.20kb

use std::collections::HashMap;
pub struct Student {
    name: String,
    grades: Vec<u8>,
}
pub struct StudentGrades {
    pub students: HashMap<String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    // 3. Implement the methods
    pub fn add_student(&mut self, name: &str) {
        if !self.students.contains_key(name) {
            self.students.insert(name.to_string(), Student { name: name.to_string(), grades: Vec::new() } );
        }
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        self.students.get_mut(&name.to_string()).unwrap().grades.push(grade);
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        &self.students.get(&name.to_string()).unwrap().grades
    }
}
// Example usage
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    println!("{:?}", tracker.get_grades("Alice")); // [85, 90]
    println!("{:?}", tracker.get_grades("Bob")); // [78]
}

Sergey Matyash

matiaspub

20 days ago

58.22ms

2099.20kb

use std::collections::HashMap;
pub struct Student {
    // 1. Define the fields
    pub name: String,
    pub grades: Vec<u8>,
}
pub struct StudentGrades {
    // 2. Define the fields
    pub students: HashMap<String, Student>
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    // 3. Implement the methods
    pub fn add_student(&mut self, name: &str) {
        self.students.entry(name.to_string()).or_insert(Student{name: name.to_string(), grades: Vec::new()});
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        // Implement here
        if let Some(stud) = self.students.get_mut(name) {
            stud.grades.push(grade);
        }
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        // Implement here
        &self.students.get(name).unwrap().grades
    }
}
// Example usage
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    println!("{:?}", tracker.get_grades("Alice")); // [85, 90]
    println!("{:?}", tracker.get_grades("Bob")); // [78]
}

GregGorin

20 days ago

50.28ms

2099.20kb

use std::collections::HashMap;
pub struct Student {
    pub name: String,
    pub grades: Vec<u8>
}
impl Student {
    fn new(name: &str) -> Self {
        Student { name: String::from(name), grades: Vec::new() }
    }
    fn append_grade(&mut self, grade: u8) {
        self.grades.push(grade);
    }
    fn get_grades(&self)-> &[u8] {
        &self.grades
    }
}
pub struct StudentGrades {
    pub students: HashMap<String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    // 3. Implement the methods
    pub fn add_student(&mut self, name: &str) {
        self.students.entry(String::from(name)).or_insert_with(|| Student::new(name));
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        self.students.get_mut(name).unwrap().append_grade(grade);
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        self.students.get(name).unwrap().get_grades()
    }
}
// Example usage
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    println!("{:?}", tracker.get_grades("Alice")); // [85, 90]
    println!("{:?}", tracker.get_grades("Bob")); // [78]
}

LeonardoPinheiro23

22 days ago

30.15ms

2099.20kb

use std::collections::HashMap;
pub struct Student {
    pub name: String,
    pub grades: Vec<u8>
}
impl Student {
    fn new(name: &str) -> Self {
        Student { name: String::from(name), grades: Vec::new() }
    }
    fn append_grade(&mut self, grade: u8) {
        self.grades.push(grade);
    }
    fn get_grades(&self)-> &[u8] {
        &self.grades
    }
}
pub struct StudentGrades {
    pub students: HashMap<String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    // 3. Implement the methods
    pub fn add_student(&mut self, name: &str) {
        self.students.entry(String::from(name)).or_insert_with(|| Student::new(name));
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        self.students.get_mut(name).unwrap().append_grade(grade);
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        self.students.get(name).unwrap().get_grades()
    }
}
// Example usage
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    println!("{:?}", tracker.get_grades("Alice")); // [85, 90]
    println!("{:?}", tracker.get_grades("Bob")); // [78]
}

zapp42

22 days ago

74.86ms

2099.20kb

use std::collections::HashMap;
pub struct Student {
    pub name: String,
    pub grades: Vec<u8>
}
pub struct StudentGrades {
    pub students: HashMap<String, Student>
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    // 3. Implement the methods
    pub fn add_student(&mut self, name: &str) {
        self.students.insert(name.to_string(), Student{ name: name.to_string(), grades: Vec::<u8>::new()});
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        self.students.get_mut(name).unwrap().grades.push(grade);
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        &self.students.get(name).unwrap().grades
    }
}
// Example usage
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    println!("{:?}", tracker.get_grades("Alice")); // [85, 90]
    println!("{:?}", tracker.get_grades("Bob")); // [78]
}

AlphaN00mer1cal

23 days ago

29.18ms

2099.20kb

use std::collections::HashMap;
use std::vec::Vec;
pub struct Student {
    pub name: String,
    pub grades: Vec<u8>
}
pub struct StudentGrades {
    pub students: HashMap<String, Student>
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    // 3. Implement the methods
    pub fn add_student(&mut self, name: &str) {
        let new_student = Student{
            name: name.to_string(),
            grades: Vec::<u8>::new()
        };
        self.students.insert(name.to_string(), new_student);
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        self.students.get_mut(name).unwrap().grades.push(grade)
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        &self.students.get(name).unwrap().grades
    }
}
// Example usage
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    println!("{:?}", tracker.get_grades("Alice")); // [85, 90]
    println!("{:?}", tracker.get_grades("Bob")); // [78]
}

jbrakmic

23 days ago

34.02ms

2099.20kb

use std::collections::HashMap;
pub struct Student {
    pub name: String,
    pub grades: Vec<u8>,
}
pub struct StudentGrades {
    pub students: HashMap<String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    // 3. Implement the methods
    pub fn add_student(&mut self, name: &str) {
        self.students.insert(name.to_string(), Student {
            name: name.to_string(),
            grades: Vec::new(),
        });
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        let student = self.students.get_mut(name).unwrap();
        student.grades.push(grade);
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        &self.students.get(name).unwrap().grades
    }
}
// Example usage
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    println!("{:?}", tracker.get_grades("Alice")); // [85, 90]
    println!("{:?}", tracker.get_grades("Bob")); // [78]
}

Saksinkarn Petchkuljinda

dward2nd

24 days ago

30.45ms

2099.20kb

use std::collections::HashMap;
pub struct Student {
    // 1. Define the fields
    pub name: String,
    pub grades: Vec<u8>,
}
pub struct StudentGrades {
    // 2. Define the fields
    pub students: HashMap<String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    // 3. Implement the methods
    pub fn add_student(&mut self, name: &str) {
        // Implement here
        self.students.insert(
            name.to_string(),
            Student {
                name: name.to_string(),
                grades: vec![],
            },
        );
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        // Implement here
        match self.students.get_mut(name) {
            Some(student) => {
                student.grades.push(grade);
            },
            None => {
                self.add_student(name);
                self.add_grade(name, grade);
            }
        }
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        // Implement here
        match self.students.get(name) {
            Some(student) => student.grades.as_slice(),
            None => &[],
        }
    }
}
// Example usage
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    println!("{:?}", tracker.get_grades("Alice")); // [85, 90]
    println!("{:?}", tracker.get_grades("Bob")); // [78]
}

wry

Liudel

24 days ago

43.94ms

2099.20kb

use std::collections::HashMap;
pub struct Student {
    // 1. Define the fields
    pub name: String,
    pub grades: Vec<u8>,
}
pub struct StudentGrades {
    // 2. Define the fields
    pub students: HashMap<String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    // 3. Implement the methods
    pub fn add_student(&mut self, name: &str) {
        // Implement here
        self.students.insert(
            name.to_string(),
            Student {
                name: name.to_string(),
                grades: vec![],
            },
        );
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        // Implement here
        if let Some(student) = self.students.get_mut(name) {
            student.grades.push(grade);
        }
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        self.students
            .get(name)
            .map(|student| student.grades.as_slice())
            .unwrap_or_default()
    }
}
// Example usage
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    println!("{:?}", tracker.get_grades("Alice")); // [85, 90]
    println!("{:?}", tracker.get_grades("Bob")); // [78]
}

Travis

ttmgraham

24 days ago

34.78ms

2099.20kb

use std::collections::HashMap;
pub struct Student {
    // 1. Define the fields
    pub name: String,
    pub grades: Vec<u8>
}
pub struct StudentGrades {
    // 2. Define the fields
    pub students: HashMap<String, Student>
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    // 3. Implement the methods
    pub fn add_student(&mut self, name: &str) {
        if self.students.get(name).is_none() {
            self.students.insert(name.to_string(), Student{ name: name.to_string(), grades: vec![] });
        }
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        self.students.get_mut(name).unwrap().grades.push(grade);
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        &self.students.get(name).unwrap().grades
    }
}
// Example usage
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    println!("{:?}", tracker.get_grades("Alice")); // [85, 90]
    println!("{:?}", tracker.get_grades("Bob")); // [78]
}

Tommytto

25 days ago

30.18ms

2099.20kb

use std::collections::HashMap;
pub struct Student {
    // 1. Define the fields
    pub name: String,
    pub grades: Vec<u8>,
}
pub struct StudentGrades {
    // 2. Define the fields
    pub students: HashMap<String, Student>
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    // 3. Implement the methods
    pub fn add_student(&mut self, name: &str) {
        // Implement here
        self.students.insert(name.to_string(), Student{
            name: name.to_string(),
            grades: Vec::new()
        });
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        // Implement here
        self.students.get_mut(name).unwrap().grades.push(grade);
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        // Implement here
        &(self.students.get(name).unwrap().grades)
    }
}
// Example usage
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    println!("{:?}", tracker.get_grades("Alice")); // [85, 90]
    println!("{:?}", tracker.get_grades("Bob")); // [78]
}

Dimas Avrian Fachriza.

FForFachriza

25 days ago

33.39ms

2099.20kb

use std::collections::HashMap;
pub struct Student {
    // 1. Define the fields
    pub name: String,
    pub grades: Vec<u8>,
}
pub struct StudentGrades {
    // 2. Define the fields
    pub students: HashMap<String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    // 3. Implement the methods
    pub fn add_student(&mut self, name: &str) {
        // Implement here
        let student_name = name.to_string();
        self.students
            .entry(student_name.clone())
            .or_insert(Student {
                name: student_name,
                grades: vec![],
            });
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        let student_name = name.to_string();
        self.students
            .entry(student_name)
            .and_modify(|g| g.grades.push(grade));
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        match self.students.get(name) {
            Some(student) => &student.grades,
            None => todo!(),
        }
    }
}
// Example usage
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    println!("{:?}", tracker.get_grades("Alice")); // [85, 90]
    println!("{:?}", tracker.get_grades("Bob")); // [78]
}

Kenas Zogara

kenaszogara

25 days ago

32.76ms

2099.20kb

use std::collections::HashMap;
pub struct Student {
    // 1. Define the fields
    pub name: String,
    pub grades: Vec<u8>
}
impl Student {
    pub fn new(name: String) -> Self {
        Self {
            name,
            grades: vec![]
        }
    }
}
pub struct StudentGrades {
    // 2. Define the fields
    pub students: HashMap<String, Student>
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    // 3. Implement the methods
    pub fn add_student(&mut self, name: &str) {
        // Implement here
        self.students.insert(name.to_string(), Student::new(name.to_string()));
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        // Implement here
        let student = self.students.entry(name.to_string());
        student.and_modify(|stud| stud.grades.push(grade));
            
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        // Implement here
        
        return self.students.get(name).map(|student| student.grades.as_slice()).unwrap_or_default();
    }
}
// Example usage
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    println!("{:?}", tracker.get_grades("Alice")); // [85, 90]
    println!("{:?}", tracker.get_grades("Bob")); // [78]
}

Ajit Kumar

urwithajit9

25 days ago

42.18ms

2099.20kb

use std::collections::HashMap;
pub struct Student {
    pub name:String,
    pub grades:Vec<u8>,
}
pub struct StudentGrades {
    pub students:HashMap<String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    // 3. Implement the methods
    pub fn add_student(&mut self, name: &str) {
        self.students
        .entry(name.to_string())
        .or_insert_with(||Student {
            name: name.to_string(),
            grades: Vec::new(),
    });
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        if let Some(student) = self.students.get_mut(name) {
        student.grades.push(grade);
    }
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
       self.students
        .get(name)
        .map(|student| student.grades.as_slice())
        .unwrap_or_default()
    
    }
}
// Example usage
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    println!("{:?}", tracker.get_grades("Alice")); // [85, 90]
    println!("{:?}", tracker.get_grades("Bob")); // [78]
}

Ajit Kumar

urwithajit9

25 days ago

31.50ms

2099.20kb

use std::collections::HashMap;
pub struct Student {
    pub name:String,
    pub grades:Vec<u8>,
}
pub struct StudentGrades {
    pub students:HashMap<String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    // 3. Implement the methods
    pub fn add_student(&mut self, name: &str) {
        self.students
        .entry(name.to_string())
        .or_insert_with(||Student {
            name: name.to_string(),
            grades: Vec::new(),
    });
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        if let Some(student) = self.students.get_mut(name) {
        student.grades.push(grade);
    }
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
       self.students
        .get(name)
        .map(|student| student.grades.as_slice())
        .unwrap_or_default()
    
    }
}
// Example usage
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    println!("{:?}", tracker.get_grades("Alice")); // [85, 90]
    println!("{:?}", tracker.get_grades("Bob")); // [78]
}

Maicon Crespo

maiconcrespo

25 days ago

37.51ms

2099.20kb

use std::collections::HashMap;
pub struct Student {
    // 1. Define the fields
    pub name: String,
    pub grades:Vec<u8>,
}
pub struct StudentGrades {
    // 2. Define the fields
    pub students:HashMap<String,Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    // 3. Implement the methods
    pub fn add_student(&mut self, name: &str) {
        // Implement here
        self.students
            .entry(name.to_string())
            .or_insert_with(||Student {
            name: name.to_string(),
            grades: Vec::new(),
    });
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        if let Some(student) = self.students.get_mut(name) {
        student.grades.push(grade);
}
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
       self.students
        .get(name)
        .map(|student| student.grades.as_slice())
        .unwrap_or_default()
    }
}
// Example usage
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    println!("{:?}", tracker.get_grades("Alice")); // [85, 90]
    println!("{:?}", tracker.get_grades("Bob")); // [78]
}

sjmellor

a month ago

34.52ms

2099.20kb

use std::collections::HashMap;
pub struct Student {
    // 1. Define the fields
    pub name: String,
    pub grades: Vec<u8>,
}
pub struct StudentGrades {
    // 2. Define the fields
    pub students: HashMap<String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    // 3. Implement the methods
    pub fn add_student(&mut self, name: &str) {
        // Implement here
        if let None = self.students.get(name) {
            let new_student = Student { name: name.to_string(), grades: vec![] };
            self.students.insert(name.to_string(), new_student);
        }
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        // Implement here
        self.students.entry(name.to_string())
            .and_modify(|student| student.grades.push(grade));
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        // Implement here
        match self.students.get(name) {
            Some(student) => &student.grades[..],
            None => &[],
        }
    }
}
// Example usage
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    println!("{:?}", tracker.get_grades("Alice")); // [85, 90]
    println!("{:?}", tracker.get_grades("Bob")); // [78]
}

thaisonho

a month ago

27.33ms

2099.20kb

use std::collections::HashMap;
pub struct Student {
    // 1. Define the fields
    pub name: String,
    pub grades: Vec<u8>
}
impl Student {
    pub fn new(name: String) -> Self {
        Student {
            name: name,
            grades: Vec::new(),
        }
    }
}
pub struct StudentGrades {
    // 2. Define the fields
    pub students: HashMap<String, Student>
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    // 3. Implement the methods
    pub fn add_student(&mut self, name: &str) {
        // Implement here
        self.students.insert(name.to_string(), Student::new(name.to_string()));
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        // Implement here
        self.students.entry(name.to_string())
                    .or_insert(Student::new(name.to_string()))
                    .grades.push(grade);
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        // Implement here
        &self.students.get(name).unwrap().grades
    }
}
// Example usage
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    println!("{:?}", tracker.get_grades("Alice")); // [85, 90]
    println!("{:?}", tracker.get_grades("Bob")); // [78]
}

Sergejs Kostjucenko

sergejparity

a month ago

36.46ms

2099.20kb

use std::collections::HashMap;
pub struct Student {
    pub name: String,
    pub grades: Vec<u8>,
}
impl Student {
    pub fn new(name: String) -> Student {
        Student {
            name,
            grades: Vec::new(),
        }
    } 
}
pub struct StudentGrades {
    pub students: HashMap<String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    // 3. Implement the methods
    pub fn add_student(&mut self, name: &str) {
        self.students.insert(name.to_string(), Student::new(name.to_string()));
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        // alternative self.students.entry(name.to_string()).or_insert(Student::new(name.to_string())).grades.push(grade);
        self.students.get_mut(name).unwrap().grades.push(grade);
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        &self.students.get(name).unwrap().grades
    }
}
// Example usage
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    println!("{:?}", tracker.get_grades("Alice")); // [85, 90]
    println!("{:?}", tracker.get_grades("Bob")); // [78]
}

Zeno

djeanql

a month ago

28.27ms

2099.20kb

use std::collections::HashMap;
pub struct Student {
    name: String,
    grades: Vec<u8>,
}
impl Student {
    pub fn new(name: String) -> Self {
        Self{name: name, grades: Vec::new()}
    }
}
pub struct StudentGrades {
    pub students: HashMap<String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    // 3. Implement the methods
    pub fn add_student(&mut self, name: &str) {
        self.students.insert(name.to_string(), Student::new(name.to_string()));
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        self.students.entry(name.to_string()).or_insert(Student::new(name.to_string())).grades.push(grade);
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        &self.students.get(name).unwrap().grades
    }
}
// Example usage
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    println!("{:?}", tracker.get_grades("Alice")); // [85, 90]
    println!("{:?}", tracker.get_grades("Bob")); // [78]
}

Zeno

djeanql

a month ago

28.21ms

2099.20kb

use std::collections::HashMap;
pub struct Student {
    name: String,
    grades: Vec<u8>,
}
impl Student {
    pub fn new(name: String) -> Self {
        Self{name: name, grades: Vec::new()}
    }
}
pub struct StudentGrades {
    pub students: HashMap<String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    // 3. Implement the methods
    pub fn add_student(&mut self, name: &str) {
        self.students.insert(name.to_string(), Student::new(name.to_string()));
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        self.students.entry(name.to_string()).or_insert(Student::new(name.to_string())).grades.push(grade);
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        &(self.students.get(name).unwrap().grades)
    }
}
// Example usage
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    println!("{:?}", tracker.get_grades("Alice")); // [85, 90]
    println!("{:?}", tracker.get_grades("Bob")); // [78]
}

Zeno

djeanql

a month ago

27.65ms

2099.20kb

use std::collections::HashMap;
pub struct Student {
    name: String,
    grades: Vec<u8>,
}
impl Student {
    pub fn new(name: String) -> Self {
        Self{name: name, grades: Vec::new()}
    }
}
pub struct StudentGrades {
    pub students: HashMap<String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    // 3. Implement the methods
    pub fn add_student(&mut self, name: &str) {
        self.students.insert(name.to_string(), Student::new(name.to_string()));
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        self.students.entry(name.to_string()).or_insert(Student::new(name.to_string())).grades.push(grade);
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        &(self.students.get(name).unwrap().grades)[..]
    }
}
// Example usage
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    println!("{:?}", tracker.get_grades("Alice")); // [85, 90]
    println!("{:?}", tracker.get_grades("Bob")); // [78]
}

Holger Knauer

hknauer

a month ago

31.23ms

2099.20kb

use std::collections::HashMap;
pub struct Student {
    // 1. Define the fields
    pub name: String,
    pub grades: Vec<u8>,
}
pub struct StudentGrades {
    // 2. Define the fields
    pub students: HashMap<String, Student>, 
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    // 3. Implement the methods
    pub fn add_student(&mut self, name: &str) {
        // Implement here
        if !self.students.contains_key(name) {
            let student = Student {
                name: name.to_string(),
                grades: Vec::new()
            };
            self.students.insert(name.to_string(), student);
        }
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        // Implement here
        self.students.get_mut(name).unwrap().grades.push(grade);
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        // Implement here
        &self.students.get(name).unwrap().grades
    }
}
// Example usage
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    println!("{:?}", tracker.get_grades("Alice")); // [85, 90]
    println!("{:?}", tracker.get_grades("Bob")); // [78]
}

Augsorn Chanklad

up2code

a month ago

25.84ms

2099.20kb

use std::collections::HashMap;
pub struct Student {
    // 1. Define the fields
    name: String,
    grades: Vec<u8>
}
pub struct StudentGrades {
    // 2. Define the fields
    pub students: HashMap<String, Student>
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    // 3. Implement the methods
    pub fn add_student(&mut self, name: &str) {
        // Implement here
        let student_name = String::from(name);
        self.students.insert(student_name.clone(), 
        Student{ 
            name: student_name, 
            grades: Vec::<u8>::new()
        });
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        // Implement here
        if let Some(student) = self.students.get_mut(name) {
            student.grades.push(grade);
        }
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        // Implement here
        &self.students.get(name).unwrap().grades
    }
}
// Example usage
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    println!("{:?}", tracker.get_grades("Alice")); // [85, 90]
    println!("{:?}", tracker.get_grades("Bob")); // [78]
}

Augsorn Chanklad

up2code

a month ago

27.01ms

2099.20kb

use std::collections::HashMap;
pub struct Student {
    // 1. Define the fields
    name: String,
    grades: Vec<u8>
}
pub struct StudentGrades {
    // 2. Define the fields
    pub students: HashMap<String, Student>
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    // 3. Implement the methods
    pub fn add_student(&mut self, name: &str) {
        // Implement here
        let student_name = String::from(name);
        self.students.insert(student_name.clone(), 
        Student{ 
            name: student_name, 
            grades: Vec::<u8>::new()
        });
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        // Implement here
        if let Some(student) = self.students.get_mut(name) {
            student.grades.push(grade);
        }
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        // Implement here
        &self.students.get(name).unwrap().grades
    }
}
// Example usage
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    println!("{:?}", tracker.get_grades("Alice")); // [85, 90]
    println!("{:?}", tracker.get_grades("Bob")); // [78]
}

zirkzee77

a month ago

34.02ms

2099.20kb

use std::collections::HashMap;
pub struct Student {
    // 1. Define the fields
    pub name: String,
    pub grades: Vec<u8>,
}
pub struct StudentGrades {
    // 2. Define the fields
    pub students: HashMap<String, Student>
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    // 3. Implement the methods
    pub fn add_student(&mut self, name: &str) {
        // Implement here
        match self.students.get(&String::from(name)) {
            Some(_) => {}
            None => {
                self.students.insert(String::from(name), Student{ name: String::from(name), grades: Vec::<u8>::new()});
            }
        }
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        // Implement here
        match self.students.get_mut(&String::from(name)) {
            Some(student) => {
                student.grades.push(grade);
            }
            None => {}
        }
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        // Implement here
        match self.students.get(&String::from(name)) {
            Some(student) => {
                &student.grades
            }
            None => {&[]}
        }
    }
}
// Example usage
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    println!("{:?}", tracker.get_grades("Alice")); // [85, 90]
    println!("{:?}", tracker.get_grades("Bob")); // [78]
}

Stas

nevmstas

a month ago

49.13ms

2099.20kb

use std::collections::HashMap;
pub struct Student {
    // 1. Define the fields
    pub name: String,
    pub grades: Vec<u8>
}
pub struct StudentGrades {
    // 2. Define the fields
    pub students: HashMap<String, Student>
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    // 3. Implement the methods
    pub fn add_student(&mut self, name: &str) {
        let student = Student { name: name.to_owned(), grades: Vec::new() };
        
        self.students.entry(name.to_owned()).or_insert(student);
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        if let Some(student) = self.students.get_mut(&name.to_string()) {
            student.grades.push(grade);
        }
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        if let Some(student) = self.students.get(&name.to_string()) {
            return &student.grades
        }
        &[]
    }
}
// Example usage
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    println!("{:?}", tracker.get_grades("Alice")); // [85, 90]
    println!("{:?}", tracker.get_grades("Bob")); // [78]
}