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

Octavian

orouwk

2 minutes ago

103.28ms

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
        //self.students.entity(name)
        if let Some(s) = self.students.get_mut(name) {
            s.grades.push(grade);
        }
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        // Implement here
        if let Some(name)=self.students.get(name) {
            name.grades.as_ref()
        } else {
            [].as_ref()
        }
    }
}
// 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]
}

anhdoo

TuanAnhDoHoang

3 days ago

37.70ms

2099.20kb

use std::collections::HashMap;
#[derive(PartialEq)]
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 None == self.students.get(&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(value) = self.students.get_mut(name){
            value.grades.push(grade);
        }
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        // Implement here
        if let Some(value) = self.students.get(&name.to_string()){
            let ret: &[u8] = value.grades.as_slice();
            return ret;
        }
        else{
            return &[];
        }
    }
}
// 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]
}

anhdoo

TuanAnhDoHoang

3 days ago

43.40ms

2099.20kb

use std::collections::HashMap;
#[derive(PartialEq)]
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 None == self.students.get(&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(value) = self.students.get_mut(name){
            value.grades.push(grade);
        }
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        // Implement here
        if let Some(value) = self.students.get(&name.to_string()){
            let ret: &[u8] = value.grades.as_slice();
            return ret;
        }
        else{
            return &[];
        }
    }
}
// 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]
}

LLukeDB

5 days ago

33.97ms

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
        if let Some(student) = self.students.get_mut(name) {
            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]
}

Teimur Gasanov

teimurjan

5 days ago

36.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) {
        // 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
        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)
            .map(|student| student.grades.as_slice())
            .unwrap_or(&[])
    }
}
// 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]
}

Kanak Shilledar

kanakshilledar

8 days ago

32.66ms

2099.20kb

use std::collections::HashMap;
pub struct Student {
    // 1. Define the fields
    name: String,
    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] {
        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]
}

Nicolai

Posmac

9 days ago

54.42ms

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) {
            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
        }
        return &[]
    }
}
// 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]
}

adamegao

10 days ago

33.33ms

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] {
        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]
}

adamegao

11 days ago

41.26ms

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.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) {
        if let Some(student) = self.students.get_mut(name) {
            student.grades.push(grade);
        }
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        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]
}

Thomastienn

12 days ago

29.19ms

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 name_str = name.to_string();
        let new_student = Student {
            name: name_str.clone(),
            grades: Vec::new(),
        };
        self.students.insert(name_str, new_student);
    }
    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 => {}
        }
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        // Implement here
        let student = self.students.get(name);
        match student {
            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]
}

Elizabeth Doughty

Thymelizabeth

12 days ago

41.62ms

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) {
        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) {
        self.students.entry(name.to_string()).and_modify(|student| student.grades.push(grade));
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        self.students.get(name).expect("No such 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]
}

Health-Care-Movie

12 days ago

23.78ms

1413.12kb

use std::collections::HashMap;
pub struct Student {
    // 1. Define the fields
    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 {grades: vec![]});
    }
    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]
}

Splatrac

splatrac

13 days ago

39.07ms

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[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]
}

TestingPurpose14

14 days ago

29.40ms

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 = 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
        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)
            .map_or(&[], |student| &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]
}

Trịnh Chấn Duy

Duyyy123

15 days ago

33.09ms

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())
            .or_insert(Student {
                name: name.to_string(),
                grades: Vec::new(),
            })
            .grades
            .push(grade);
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        // Implement here
        self.students
            .get(name)
            .map_or(&[], |student| &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]
}

Liyqq

18 days ago

48.96ms

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
        self.students.insert(name.to_string(), Student{name: String::from(name), grades: vec![]});
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        // Implement here
        self.students.entry(name.to_string())
            .and_modify(|e| e.grades.push(grade))
            .or_insert(Student{name: String::from(name), grades: vec![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]
}

cyberspace lee

cyberspacelee

19 days ago

33.79ms

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.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) {
        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) {
            return student.grades.as_ref()
        }
        &[]
    }
}
// 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]
}

agamaontherock

20 days ago

28.26ms

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] {
        return 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]
}

agamaontherock

20 days ago

33.77ms

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
        self.students.entry(name.to_string()).and_modify(|student| (*student).grades.push(grade));
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        return 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]
}

nabil-Tounarti

20 days ago

33.82ms

2099.20kb

use std::collections::HashMap;
pub struct Student {
    pub name: String,
    pub grades: Vec<u8>,
}
impl Student {
    pub fn add_grade(&mut self, grade: u8) {
        self.grades.push(grade);
    }
    pub fn average_grade(&self) -> f64 {
        let sum : f64= self.grades.iter().map(|&x| x as f64).sum();
        sum/(self.grades.len() as f64)
    }
}
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![],
        });
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        if let Some(student) = self.students.get_mut(name) {
            student.add_grade(grade);
        }
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        &self.students.get(name).unwrap().grades
    }
}
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);
    let alice = tracker.students.get_mut("Alice").unwrap();
    alice.add_grade(95);
    println!("{:?}", alice.grades);
    println!("{:?}", alice.average_grade());
    println!("{:?}", tracker.get_grades("Bob"));
}

Max

maxemontio

21 days ago

24.15ms

1413.12kb

use std::collections::HashMap;
pub struct Student {
    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{
            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] {
        &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]
}

Max

maxemontio

21 days ago

30.27ms

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::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]
}

nabil-Tounarti

21 days ago

34.10ms

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) {
        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) {
        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]
}

Sergey

Themelok

25 days ago

29.01ms

2099.20kb

use std::collections::HashMap;
#[derive(Default)]
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
        let stud = self.students.get_mut(name).unwrap();
        stud.grades.push(grade);
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        // Implement here
        let stud = self.students.get(name).unwrap();
        &stud.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]
}

Neel Knight

NeelKnight

a month ago

32.81ms

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) {
            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) {
        self.students.get_mut(name).unwrap().grades.push(grade);
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        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]
}

Nathan GAUD

Natchica

a month ago

37.74ms

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) {
        let student_to_grade = self.students.get_mut(name).unwrap();
        let student_grades_to_update = &mut student_to_grade.grades;
        student_grades_to_update.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]
}

elite_dev

mover-elite

a month ago

31.00ms

1413.12kb

use std::collections::HashMap;
pub struct Student {
    // name: String,
    pub grades: Vec<u8>
    // 1. Define the fields
}
pub struct StudentGrades {
    pub students: HashMap<String, Student>
    // 2. Define the fields
}
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 {
                grades: vec![],
            },
        );
       
        // Implement here
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        
        self.students
            .entry(name.to_string())
            .and_modify(|ell| ell.grades.push(grade))
            .or_insert(Student {
                grades: vec![grade],
            });
        // Implement here
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        
        match self.students.get(name) {
            Some(student) => &student.grades,
            None => &[],
        }
        // Implement here
    }
}
// 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]
}

Heatiche Mix

HeaticheTakachi

a month ago

26.19ms

1413.12kb

use std::collections::HashMap;
pub struct Student {
    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 {
                grades: vec![],
            },
        );
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        self.students
            .entry(name.to_string())
            .and_modify(|ell| ell.grades.push(grade))
            .or_insert(Student {
                grades: vec![grade],
            });
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        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]
}

mishbah

a month ago

25.38ms

1413.12kb

use std::collections::HashMap;
pub struct Student {
    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 {
                grades: vec![],
            },
        );
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        self.students
            .entry(name.to_string())
            .and_modify(|ell| ell.grades.push(grade))
            .or_insert(Student {
                grades: vec![grade],
            });
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        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]
}

mishbah

a month ago

26.66ms

1413.12kb

use std::collections::HashMap;
pub struct Student {
    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 {
                grades: vec![],
            },
        );
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        self.students
            .entry(name.to_string())
            .and_modify(|ell| ell.grades.push(grade))
            .or_insert(Student {
                grades: vec![grade],
            });
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        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]
}

mishbah

a month ago

27.22ms

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![],
            },
        );
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        self.students
            .entry(name.to_string())
            .and_modify(|ell| ell.grades.push(grade))
            .or_insert(Student {
                name: name.to_string(),
                grades: vec![grade],
            });
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        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]
}

Paolo Cancedda

Pac72

a month ago

23.70ms

1413.12kb

use std::collections::HashMap;
pub struct Student {
    // 1. Define the fields
    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 = Student { grades: Vec::new() };
        self.students.insert(name.to_string(), student);
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        // Implement here
        let student = self.students.get_mut(name).unwrap();
        student.grades.push(grade);
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        // Implement here
        let student = self.students.get(name).unwrap();
        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]
}

torbenhardt

a month ago

27.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) {
        let student = Student{name: name.to_string(), grades: Vec::new()};
        self.students.insert(name.to_string(), student);
        return
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        let stud = self.students.get_mut(name).expect("Student not found");
        stud.grades.push(grade);
        return
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        let stud = self.students.get(name).expect("Student not found");
        &stud.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]
}

Maintain

duonghb53

a month ago

32.21ms

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 Some(_student) = self.students.get(name) {
            return;
        }
        let student = Student { name: name.to_string() , grades: vec![]}; 
        self.students.insert(name.to_string(), student);
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        // Implement here
        if let Some(student) = self.students.get(name) {
            let mut grades = student.grades.clone();
            grades.push(grade);
            let student = Student { name: name.to_string() , grades }; 
            self.students.insert(name.to_string(), student);
        }
    }
    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]
}

asdfman

a month ago

45.10ms

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) {
        self.students.insert(name.to_owned(), Student { name: name.to_string(), 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] {
        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]
}

RASHMOR

RASHMOR1

a month ago

39.04ms

2099.20kb

use std::collections::HashMap;
#[derive(Debug)]
pub struct Student {
    pub name: String,
    pub grades: Vec<u8>,
}
#[derive(Debug)]
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) {
        // Implement here
        if !self.students.contains_key(name){
            let new_student  =Student{
                name: name.to_string(),
                grades: Vec::new(),
            };
            self.students.insert(name.to_string(), new_student);
        }
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        // Implement here
        if let Some(student) = self.students.get_mut(name) { // Fixed student lookup
            student.grades.push(grade);
        }
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        if let Some(student) = self.students.get(name) {
            &student.grades
        } else {
            &[] // Return an empty slice if student doesn't exist (not needed per problem statement, but safe)
        }
    }
}
// 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]
}

Jakub Wiśniewski

wisniewskij

a month ago

28.16ms

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) {
        self.students.entry(name.to_string()).and_modify(|e| {e.grades.push(grade)});
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        self.students.get(&name.to_string()).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]
}

Jason

Jason-fy-wang

a month ago

32.97ms

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::<u8>::new(),
                }
            );
        }
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        // Implement here
        if self.students.contains_key(name) {
            self.students.entry(name.to_string()).and_modify(|v| {v.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]
}

Nguyen Vo Hoang Son

sonmessia

a month ago

39.61ms

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
        let student = self.students.get_mut(name).unwrap();
        student.grades.push(grade);
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        // Implement here
        let student = self.students.get(name).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]
}

vijayabhaskar badireddi

ptcte

a month ago

36.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.entry(name.to_string()).or_insert(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] {
        let student = self.students.get(name).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]
}

AtlasVakyrie

a month ago

32.83ms

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
        let student = self.students.get_mut(name).unwrap();
        student.grades.push(grade);
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        // Implement here
        let student = self.students.get(name).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]
}

Nhat Vu

NhatTinyVu

a month ago

29.96ms

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
        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]
}

Leo Phạm

HongThaiPham

a month ago

30.20ms

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::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(&[])
    }
}
// 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]
}

pop_eax

pop-eax

a month ago

32.14ms

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::<u8>::new()});
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        // Implement here
        self.students.entry(name.to_string()).and_modify(|x| 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]
}

ZixinYeah

a month ago

43.15ms

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
        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] {
        // Implement here
        let Some(student) = self.students.get(name) else {
            return &[];
        };
        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]
}

Seth Wood

seth-wood

a month ago

27.70ms

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
        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(students) = self.students.get_mut(name) {
            students.grades.push(grade);
        }
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        // Implement here
        self.students.get(name)
            .map(|s| s.grades.as_slice())
            .unwrap_or(&[])
    }
}
// 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]
}

Levio-z

a month ago

32.89ms

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.into()).or_insert(Student{
            name : name.into(),
            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] {
        // Implement here
        let Some(student) = self.students.get(name) else{ return &[]};
        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]
}

shibu-t

a month ago

34.19ms

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(student) = self.students.get_mut(name) {
            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]
}

Assylbek Razakhbergenov

asylbek27

a month ago

26.99ms

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_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.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]
}

Deaddy3

a month ago

28.31ms

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) {
            student.grades.push(grade);
        }
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        // Implement here
        &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]
}