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

Vendra000

7 hours ago

32.74ms

2099.20kb

use std::collections::HashMap;
pub struct Student {
    name: String,
    grades: Vec<u8>
}
pub struct StudentGrades {
    pub students: HashMap<String, Student>
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    // 3. Implement the methods
    pub fn add_student(&mut self, name: &str) {
        if !self.students.contains_key(name) {
            self.students.insert( name.to_string(), 
                                  Student{name: name.to_string(), 
                                          grades: Vec::new()} );
        }
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        if let Some(stud) = self.students.get_mut(name){
            stud.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]
}

Özgür

AyikOzgur

2 days ago

29.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
        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
        let student = self.students.get_mut(name);
        match student {
            Some(student_itself) => {
                student_itself.grades.push(grade);
            }
            None => {} 
        }
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        // Implement here
        let student = self.students.get(name);
        match student {
            Some(student_itself) => {
                return student_itself.grades.as_slice();
            }
            None => {&[]} 
        }
    }
}
// Example usage
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    println!("{:?}", tracker.get_grades("Alice")); // [85, 90]
    println!("{:?}", tracker.get_grades("Bob")); // [78]
}

Egu0

egu0

3 days ago

27.84ms

1413.12kb

use std::collections::HashMap;
pub struct Student {
    pub name: String,
    pub grades: Vec<u8>,
}
pub struct StudentGrades {
    pub students: HashMap<String, Vec<u8>>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    pub fn add_student(&mut self, name: &str) {
        if !self.students.contains_key(name) {
            self.students.insert(String::from(name), vec![]);
        }
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        self.students.get_mut(name).unwrap().push(grade);
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        self.students.get(name).unwrap()
    }
}

emiludenz

3 days ago

31.51ms

2099.20kb

use std::collections::HashMap;
pub struct Student {
    // 1. Define the fields
    pub name: String,
    pub grades: Vec<u8>,
}
impl Student {
    fn new(name: &str) -> Student {
        return Student {
            name: name.to_string(),
            grades: vec![],
        };
    }
}
pub struct StudentGrades {
    // 2. Define the fields
    pub students: HashMap<String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    // 3. Implement the methods
    pub fn add_student(&mut self, name: &str) {
        // Implement here
        if !self.students.contains_key(name) {
            self.students.insert(name.to_string(), Student::new(name));
        }
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        // Implement here
        if self.students.contains_key(name) {
            let stu = self.students.get_mut(name);
            stu.unwrap().grades.push(grade);
            //grades.push(grade);
        }
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        // Implement here
        if self.students.contains_key(name) {
            let stu = self.students.get(name);
            return stu.unwrap().grades.as_slice();
        }
        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]
}

Anthony Young

A-Young-Git

4 days ago

31.53ms

2099.20kb

use std::collections::HashMap;
type StudentInfo = HashMap<String, Student>;
pub struct Student {
    pub name: String,
    pub grades: Vec<u8>,
}
pub struct StudentGrades {
    pub students: StudentInfo,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: StudentInfo::new(),
        }
    }
    // 1. **`add_student(name: &str)`:** Add a new student to the `HashMap`. If the student already exists, do nothing.
    // 2. **`add_grade(name: &str, grade: u8)`:** Add a grade to an existing student.
    // 3. **`get_grades(name: &str) -> &[u8]`:** Retrieve the grades of a student as an immutable reference.
    // 4. Since there’s no error handling, assume all inputs are valid, and keys will exist when accessed.
    // 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]
}

azmahflameheart

4 days ago

26.61ms

2017.28kb

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_default();
    }
    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
        &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]
}

Marouan Boulahtouf

MBoulahtouf

5 days ago

26.36ms

2099.20kb

use std::collections::HashMap;
#[derive(Debug)]
pub struct Student {
    // 1. Define the fields
    pub name: String,
    pub grades: Vec<u8>
}
pub struct StudentGrades {
    // 2. Define the fields
    pub students:HashMap<String, Student>
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    // 3. Implement the methods
    pub fn add_student(&mut self, name: &str) {
        // Implement here
        self.students.entry(name.to_string()).or_insert_with(|| {
            Student {
                name: name.to_string(),
                grades: Vec::new()
            }
        });
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        // Implement here
        let student = self.students.entry(name.to_string()).or_insert_with(|| {
            Student {
                name: name.to_string(),
                grades: Vec::new()
            }
        });
        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]
}

Oredipe Oluwagbohunmi Adekunle

B1acB1rd

5 days ago

27.68ms

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

LawisChen

6 days ago

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

batblerone

6 days ago

28.91ms

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

ffrie

6 days ago

27.63ms

2099.20kb

use std::collections::HashMap;
pub struct Student {
    // 1. Define the fields
    pub name: String,
    pub grades: Vec<u8>,
}
pub struct StudentGrades {
    // 2. Define the fields
    pub students: HashMap<String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    // 3. Implement the methods
    pub fn add_student(&mut self, name: &str) {
        self.students.entry(name.to_string()).or_insert(Student{name: name.to_string(), grades: vec![]});
    }
    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]
}

Ramon Silva

rsilva1

7 days ago

30.70ms

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

vqk-2003

7 days ago

27.33ms

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

penmanglewood

10 days ago

27.09ms

2099.20kb

use std::collections::HashMap;
#[derive(Debug)]
pub struct Student {
    pub name: String,
    pub grades: Vec<u8>,
}
impl Student {
    pub fn new(name: &str) -> Self {
        Self {
            name: name.into(),
            grades: Vec::new(),
        }
    }
}
pub struct StudentGrades {
    pub students: HashMap<String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    // 3. Implement the methods
    pub fn add_student(&mut self, name: &str) {
        self.students
            .entry(name.to_owned())
            .or_insert(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);
        // }
        self.students
            .entry(name.to_string())
            .and_modify(|s| (*s).grades.push(grade));
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        if let Some(student) = self.students.get(name) {
            student.grades.as_slice()
        } 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]
}

Snoweuph

snoweuph

10 days ago

30.11ms

2099.20kb

use std::collections::HashMap;
pub struct Student {
    pub 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 _ = self.students.entry(name.into()).or_insert(Student {
            name: name.into(),
            grades: vec![],
        });
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        let student = self
            .students
            .get_mut(name)
            .expect("task doesn't want error handling");
        student.grades.push(grade);
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        &self
            .students
            .get(name)
            .expect("task doesn't want error handling")
            .grades
    }
}

Reda

RedaHamouche

10 days ago

27.90ms

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

Oleksandr Ryzhyk

webmarket7

11 days ago

29.66ms

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

Amit Patel

amitpatel-wstf

11 days ago

29.66ms

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

makinpaper

11 days ago

28.46ms

2099.20kb

use std::collections::HashMap;
pub struct Student {
    pub name: String,
    pub grades: Vec<u8>,
}
pub struct StudentGrades {
    pub students: HashMap<String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    // 3. Implement the methods
    pub fn add_student(&mut self, name: &str) {
        self.students.entry(name.to_owned()).or_insert(Student {
            name: name.to_owned(),
            grades: vec![],
        });
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        self.students
            .entry(name.to_owned())
            .and_modify(|grades| grades.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]
}

makinpaper

11 days ago

28.63ms

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

makinpaper

11 days ago

27.83ms

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

fasolyee

fasolyeedev

11 days ago

27.30ms

2099.20kb

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

Dan Wayne

danwayne-me

11 days ago

27.69ms

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

Nteli1

NteliFake

12 days ago

22.41ms

1413.12kb

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

Mubarak Muhammad Aminu

mubarak23

14 days ago

26.74ms

2099.20kb

use std::collections::HashMap;
pub struct Student {
    // 1. Define the fields
    pub name: String,
    pub grades: Vec<u8>
}
impl Student {
    pub fn new(name: String) -> Self {
        Student {
            name,
            grades: Vec::new()
        }
    }
}
pub struct StudentGrades {
    // 2. Define the fields
    pub students: HashMap<String, Student>
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    // 3. Implement the methods
    pub fn add_student(&mut self, name: &str) {
        // Implement here
        self.students.insert(String::from(name), Student::new(String::from(name)));  
    }
    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).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]
}

SpontaneousOverthrow

15 days ago

30.19ms

2099.20kb

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

Rodrigo Gimenez

rodrigoegimenez

16 days ago

33.21ms

2099.20kb

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

gtakacse

16 days ago

22.97ms

1413.12kb

use std::collections::HashMap;
pub struct Student {
    pub grades: Vec<u8>,
}
pub struct StudentGrades {
    pub students: HashMap<String, Student>,
}
impl Student {
    pub fn new() -> Student {
        Student { grades: Vec::new() }
    }
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    pub fn add_student(&mut self, name: &str) {
        self.students.insert(String::from(name), Student::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)
            .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]
}

gtakacse

16 days ago

27.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 Student {
    pub fn new(name: String) -> Student {
        Student {
            name,
            grades: Vec::new(),
        }
    }
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    pub fn add_student(&mut self, name: &str) {
        self.students
            .insert(String::from(name), Student::new(String::from(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)
            .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]
}

MöNir

Monir-Ruet

18 days ago

29.05ms

2099.20kb

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

Alan Castro

acsoliz

18 days ago

27.81ms

2099.20kb

use std::collections::HashMap;
pub struct Student {
    name: String,
    grades: Vec<u8>,
}
pub struct StudentGrades {
    // Los tests acceden a este campo directamente:
    pub students: HashMap<String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    // Agrega el estudiante si no existe
    pub fn add_student(&mut self, name: &str) {
        self.students.entry(name.to_string()).or_insert(Student {
            name: name.to_string(),
            grades: Vec::new(),
        });
    }
    // Agrega una nota a un estudiante existente
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        if let Some(student) = self.students.get_mut(name) {
            student.grades.push(grade);
        }
        // Según requisitos, asumimos que el estudiante existe;
        // si quisieras ser tolerante, podrías crear al vuelo.
    }
    // Devuelve las notas como slice inmutable
    pub fn get_grades(&self, name: &str) -> &[u8] {
        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]
}

Jesus Bautista

jesbt

19 days ago

36.83ms

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) {
        if !self.students.contains_key(&name.to_string()) {
            self.students.insert(
                name.to_string(), 
                Student {name: name.to_string(), grades: vec![]}
            );
        }
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        self.students.get_mut(name).unwrap().grades.push(grade);
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        let student = self.students.get(&name.to_string());
        if student.is_none() {
            return &[];
        } 
        &student.unwrap().grades
    }
}
// Example usage
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    println!("{:?}", tracker.get_grades("Alice")); // [85, 90]
    println!("{:?}", tracker.get_grades("Bob")); // [78]
}

Omar Saber Talaat Abdelrahman

omar-s-ta

19 days ago

32.52ms

1413.12kb

use std::collections::HashMap;
pub struct Student {
    pub grades: Vec<u8>,
}
#[derive(Default)]
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) {
        if self.students.contains_key(name) {
            return;
        }
        self.students
            .insert(name.to_string(), Student { 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
    }
}
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]
}

Omar Saber Talaat Abdelrahman

omar-s-ta

19 days ago

39.58ms

2099.20kb

use std::collections::HashMap;
pub struct Student {
    pub name: String,
    pub grades: Vec<u8>,
}
#[derive(Default)]
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) {
        if self.students.contains_key(name) {
            return;
        }
        self.students.insert(
            name.to_string(),
            Student {
                name: name.to_string(),
                grades: vec![],
            },
        );
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        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)
            .map(|student| student.grades.as_slice())
            .unwrap()
    }
}
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]
}

Dharm Singh

dharmvr1

22 days ago

36.90ms

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

<YoungAncient/>

youngancient

22 days ago

27.66ms

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
        self.students.entry(name.to_string()).and_modify(|student|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;
        }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]
}

tnsborum

22 days ago

34.60ms

2406.40kb

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_owned : String = name.to_string();
        let student = Student{name:name_owned.clone(),grades:vec![]};
        if !self.students.contains_key(&name_owned){
            self.students.insert(name_owned,student);
        }
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        // Implement here
        if let Some(student) = self.students.get_mut(name){
            println!("Name: {}. Grades: {:?}",student.name,student.grades);
            student.grades.push(grade);
            println!("Name: {}. Grades: {:?}",student.name,student.grades);
        }
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        // Implement here
        
        if let Some(student) = self.students.get(name){
            return &student.grades;
        }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]
}

Tim Boex

tboex

23 days ago

27.97ms

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.insert(String::from(name), 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]
}

Mykhailo Huzhvii

Ymkavi

24 days ago

35.25ms

2099.20kb

use std::collections::HashMap;
pub struct Student {
    pub name: String,
    pub grades: Vec<u8>
}
impl Student {
    pub fn new(name: String) -> Self {
        Self {
            name,
            grades: vec![]
        }
    }
}
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::new(name.to_string()));
    }
    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.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]
}

Gerasimos

glomvardos

25 days ago

50.39ms

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

Yamami

Yamami1221

25 days ago

27.50ms

2099.20kb

use std::collections::HashMap;
pub struct Student {
    // 1. Define the fields
    pub name: String,
    pub grade: Vec<u8>
}
pub struct StudentGrades {
    // 2. Define the fields
    pub students: HashMap<String,Student>
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    // 3. Implement the methods
    pub fn add_student(&mut self, name: &str) {
        self.students.insert(name.to_string(), Student{ name:name.to_string(), grade: Vec::new() });
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        self.students.get_mut(name).unwrap().grade.push(grade);
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        // Implement here
        // &self.students.get(name).unwrap_or(panic!("")).grade
        &self.students.get(name).unwrap().grade
    }
}
// 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]
}

Karshik Madavi

c0d3c

25 days ago

26.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::new(),
        });
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        // Implement here
        let v = self.students.entry(name.to_string()).or_insert(Student{
            name: name.to_string(),
            grades: Vec::new(),
        });
        v.grades.push(grade);
    }
    pub fn get_grades(&mut self, name: &str) -> &[u8] {
        // Implement here
        let v = self.students.entry(name.to_string()).or_insert_with( || {
            Student{
                name: name.to_string(),
                grades: Vec::new(),
            }
        });
        &v.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]
}

kasaxpong

a month ago

27.37ms

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

Tomiris Sharipbay

siwrid

a month ago

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

yrd241

a month ago

28.07ms

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()});
        // self.students.entry(name.to_string())
        //     .or_insert(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]
}

sn00py-lays

a month ago

27.65ms

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
        let student: &mut Student = self.students.get_mut(name).unwrap();
        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]
}

银雀Sparrxw

Sparr0www820

a month ago

39.30ms

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) {
        if !self.students.contains_key(name) {
            self.students.insert(
                name.into(),
                Student {
                    name: name.into(),
                    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.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]
}

hidethere

a month ago

28.50ms

2099.20kb

use std::collections::HashMap;
pub struct Student {
    // 1. Define the fields
    pub name: String,
    pub grades: Vec<u8>,
}
pub struct StudentGrades {
    // 2. Define the fields
    pub students: HashMap<String, Student>
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    // 3. Implement the methods
    pub fn add_student(&mut self, name: &str) {
        // Implement here
        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
        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.to_string()).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]
}

hidethere

a month ago

30.84ms

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

ychanghe

a month ago

45.32ms

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 self.students.contains_key(name) {
            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(s) = self.students.get(name){       // why this doesnt take string?? 
            &s.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]
}