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

fomulate

finbaromahony

a day ago

31.67ms

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 let Some(_) = self.students.get(name) {
            // Student already exists, do nothing
            return;
        }
        // Otherwise add new 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) {
        if let Some(student) = self.students.get_mut(name){
            // Student exists allow adding of grade
            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]
}

Christophe Mohimont

mohic

2 days ago

29.36ms

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(),
        }
    }
    pub fn add_student(&mut self, name: &str) {
        let name = name.to_string();
        if !self.students.contains_key(&name) {
            self.students.insert(
                name.clone(),
                Student {
                    name,
                    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
    }
}

Solange

SolangeLL

3 days ago

29.97ms

1413.12kb

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

Heorhii

Kagev

4 days ago

23.64ms

1413.12kb

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

Heorhii

Kagev

4 days ago

29.08ms

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(),
        }
    }
    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).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]
}

firefly

KamisAyaka

6 days ago

28.54ms

2099.20kb

use std::collections::HashMap;
pub struct Student {
    name: String,
    grades: Vec<u8>,
}
pub struct StudentGrades {
    pub students: HashMap<String, Student>,
}
impl Student {
    // 学生构造函数
    pub fn new(name: &str) -> Self {
        Student {
            name: name.to_string(),
            grades: Vec::new(),
        }
    }
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    pub fn add_student(&mut self, name: &str) {
        // 使用 entry API 确保不覆盖现有学生
        self.students
            .entry(name.to_string())
            .or_insert_with(|| Student::new(name));
    }
    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()
    }
}
// 示例用法保持不变
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]
}

amdfxlucas

6 days ago

57.17ms

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.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) {
        if self.students.get(name).is_some() 
        {
            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]
}

lurah11

6 days ago

29.32ms

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(),
        }
    }
   
    pub fn add_student(&mut self, name: &str) {
        self.students.entry(name.to_string()).or_insert_with(|| Student {name:name.to_string(),grades:Vec::<u8>::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).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]
}

lurah11

6 days ago

48.00ms

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) {
        let student = Student {name:name.to_string(),grades:Vec::<u8>::new()};
        self.students.insert(name.to_string(),student);
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
       self.students.entry(name.to_string()).and_modify(|gr|gr.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]
}

Paul-Lucas Mock

mockpa

6 days ago

32.23ms

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);
        }
        else{
            print!("nope");
        }
    }
    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]
}

But a Learner

ButALearner

7 days ago

24.18ms

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::new()});
        
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        // Implement here
        if let Some(pupil) = self.students.get_mut(name) {
            pupil.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]
}

Juan Mejia

juan-mejia

8 days ago

31.48ms

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

ashishkr2912

9 days ago

35.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
        if !self.students.contains_key(name) {
            self.students.insert(name.to_string(), Student {
                name: name.to_string(),
                grades: Vec::new(),
            });
        }
        // if let None = self.students.get_mut(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);
        });
        // 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]
}

muemart

10 days ago

34.01ms

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

Phong H.

doivjpxx

10 days ago

27.60ms

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.get(name).expect("Student not found").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]
}

achla95

11 days ago

30.41ms

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.into(),
            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] {
        // Implement here
        self.students.get(name).map(|student| student.grades.as_slice()).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]
}

achla95

11 days ago

30.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
        self.students.entry(name.to_string()).or_insert(Student {
            name: name.into(),
            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] {
        // Implement here
        self.students.get(name).map(|student| student.grades.as_slice()).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]
}

achla95

11 days ago

30.92ms

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) {
            //do nothing
        }else {
            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.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).map(|student| student.grades.as_slice()).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]
}

johnson

ssebide

12 days ago

33.27ms

2099.20kb

use std::collections::HashMap;
#[derive(Clone)]
pub struct Student {
    pub name: String,
    pub grades: Vec<u8>,
}
pub struct StudentGrades {
    // 2. Define the fields
    pub students: HashMap<String, Student>,
}
impl Student {
    pub fn new(name: String) -> Self {
        Self {
            name,
            grades: Vec::new(),
        }
    }
    pub fn add_grade(&mut self, grade: u8) -> () {
        self.grades.push(grade)
    }
}
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::new(name.to_string()));
        }
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        // Implement here
        if let Some(exist_student) = self.students.get_mut(name) {
            exist_student.add_grade(grade);
        }
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        // Implement here
        let exist_student = self.students.get(name).unwrap();
        &exist_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]
}

StevenCanDrink

14 days ago

32.22ms

2099.20kb

use std::collections::HashMap;
#[derive(Clone)]
pub struct Student {
    pub name: String,
    pub grades: Vec<u8>,
}
pub struct StudentGrades {
    // 2. Define the fields
    pub students: HashMap<String, Student>,
}
impl Student {
    pub fn new(name: String) -> Self {
        Self {
            name,
            grades: Vec::new(),
        }
    }
    pub fn add_grade(&mut self, grade: u8) -> () {
        self.grades.push(grade)
    }
}
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::new(name.to_string()));
        }
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        // Implement here
        if let Some(exist_student) = self.students.get_mut(name) {
            exist_student.add_grade(grade);
        }
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        // Implement here
        let exist_student = self.students.get(name).unwrap();
        &exist_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]
}

Sergei Kaznakhovskii

fredeastside

14 days ago

35.67ms

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

Thomas Michiels

mithom

14 days ago

29.60ms

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

Thomas Michiels

mithom

14 days ago

30.64ms

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

Fanzzzd

15 days ago

29.66ms

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

David Rasch

dcrasch

15 days ago

26.70ms

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(),
        }
    }
    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);
    }
    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).map(|student| student.grades.as_slice()).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")); // Some([85, 90])
    println!("{:?}", tracker.get_grades("Bob"));   // Some([78])
}

Lvfalue

16 days ago

28.68ms

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

jovarmath

17 days ago

36.35ms

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

guinrt

18 days ago

52.36ms

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

guinrt

18 days ago

32.49ms

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

GunGraveCpp

18 days ago

27.28ms

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

GunGraveCpp

18 days ago

31.37ms

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

undefeated_

boyboi86

18 days ago

44.11ms

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).unwrap().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]
}

yaniel-dr

19 days ago

28.89ms

2099.20kb

use std::collections::HashMap;
#[derive(Default)]
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::<u8>::new(),
        });
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        let existent_student = self.students.get_mut(name);
        existent_student.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]
}

Jean-baptiste JOFFRE

Indy79

19 days ago

31.86ms

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

Anni Hoege

annitannenbaum

20 days ago

27.08ms

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

wytsier

20 days ago

29.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) {
        // Implement here
        self.students.entry(name.to_string()).or_insert(
            Student{
                name: name.to_string(),
                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]
}

visanr

21 days ago

29.57ms

2099.20kb

use std::collections::HashMap;
pub struct Student {
    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_owned())
            .or_insert_with(|| Student {
                name: name.to_owned(),
                grades: Vec::new()
            });
        // Implement here
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        self
            .students
            .entry(name.to_owned())
            .and_modify(|student| { student.grades.push(grade); });
        // Implement here
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        &self.students.get(name).unwrap().grades
        // 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]
}

toto

22 days ago

30.93ms

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![],
                },
            );
        }
    }
    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]
}

Lucas Watkins

lucas-watkins

22 days ago

30.93ms

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

Luka Bračun

lbracun

23 days ago

33.24ms

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) {
      let key = name.to_string();
      if !self.students.contains_key(&key) {
        self.students.insert(key, 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]
}

bzdula

23 days ago

45.17ms

2099.20kb

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

Ranjith Thangavel

RanjithECE24

25 days ago

77.17ms

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 Student {
    pub fn new(name: &str) -> Self {
        Self {
            name: name.to_string(),
            grades: Vec::<u8>::new(),
        }
    }
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    // 3. Implement the methods
    pub fn add_student(&mut self, name: &str) {
        let k = String::from(name);
        if !self.students.contains_key(&k) {
            let v = Student::new(name);
            self.students.insert(k, v);
        }
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        let k = String::from(name);
        match self.students.get_mut(&k) {
            Some(student) => {
                student.grades.push(grade);
            },
            None => {},
        }
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        let k = String::from(name);
        &self.students[&k].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 Deutsch

chrisdeutsch

a month ago

31.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) {
        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) {
        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) {
            student.grades.as_slice()
        } else {
            &[] as &[u8]
        }
    }
}
// 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]
}

drauch

a month ago

34.88ms

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

Wouter

WouterMartens

a month ago

22.87ms

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(|student| student.grades.push(grade));
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        &self.students[name].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);
    println!("{:?}", tracker.get_grades("Alice")); // [85, 90]
    println!("{:?}", tracker.get_grades("Bob")); // [78]
}

Wouter

WouterMartens

a month ago

26.09ms

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) {
        if let Some(student) = self.students.get_mut(name) {
            student.grades.push(grade);
        }
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        &self.students[name].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);
    println!("{:?}", tracker.get_grades("Alice")); // [85, 90]
    println!("{:?}", tracker.get_grades("Bob")); // [78]
}

whhc

a month ago

30.01ms

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

Andy Randrianirina

andyslash

a month ago

29.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.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.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).map(|stu| stu.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]
}

shahab-tplus

a month ago

24.05ms

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

shahab-tplus

a month ago

24.14ms

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