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

Pranav Garg

PranavGarg01

a day ago

34.92ms

2099.20kb

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

amaneru

7ma8no9

3 days ago

29.50ms

2099.20kb

use std::collections::HashMap;
pub struct Student {
    pub name: String,
    pub grades: Vec<u8>,
}
pub struct StudentGrades {
    pub students: HashMap<String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    pub fn add_student(&mut self, name: &str) {
        // 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))
            .or_insert(Student {
                name: name.to_string(),
                grades: vec![grade],
            });
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        self.students.get(name).map_or(&[], |s| &s.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]
}

Vladimir

PavluninVladimir

4 days ago

31.83ms

2099.20kb

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

Éric Villani

TheTrueCaligari

4 days ago

30.25ms

2099.20kb

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

AKA.MoneyTaker

M4Bo2

5 days ago

37.82ms

2099.20kb

use std::collections::HashMap;
#[derive(Debug)] // For easy printing and debugging
pub struct Student {
    pub name: String,
    pub grades: Vec<u8>,
}
pub struct StudentGrades {
    pub students: HashMap<String, Student>, // Key: Student name, Value: Student struct
}
impl StudentGrades {
    // Constructor to create a new StudentGrades instance
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    // Add a new student to the HashMap
    pub fn add_student(&mut self, name: &str) {
        // Check if the student already exists to avoid overwriting
        if !self.students.contains_key(name) {
            let student = Student {
                name: name.to_string(),
                grades: Vec::new(),
            };
            self.students.insert(name.to_string(), student);
        }
    }
    // Add a grade to an existing student
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        if let Some(student) = self.students.get_mut(name) {
            student.grades.push(grade);
        }
    }
    // Retrieve the grades of a student as an immutable slice reference
    pub fn get_grades(&self, name: &str) -> &[u8] {
        // Get the grades or return an empty slice if the student doesn't exist
        self.students.get(name).map(|student| &student.grades[..]).unwrap_or(&[])
    }
}
// Example usage
pub fn main() {
    let mut tracker = StudentGrades::new();
    // Add students
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    // Add grades
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    // Retrieve and print grades
    println!("{:?}", tracker.get_grades("Alice")); // [85, 90]
    println!("{:?}", tracker.get_grades("Bob"));   // [78]
}

zawwwu

5 days ago

31.89ms

2099.20kb

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

Dyaa Adel

dyaa-adel

7 days ago

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

Lê Minh Quân

aleister1102

8 days ago

29.23ms

2099.20kb

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

sander-b-postnl

9 days ago

37.26ms

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

Yi Hao

leongyihao

10 days ago

27.64ms

2099.20kb

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

Guilherme Cesário Strachan

strachan

10 days ago

34.25ms

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

Anıl Şenay

anilsenay

10 days ago

70.47ms

2099.20kb

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

TiagONTOP

10 days ago

39.08ms

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 grades: Vec<u8> = vec![];
        let student = Student { name: name.to_string(), grades};
        self.students.entry(name.to_string()).or_insert(student);
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        // Implement here
        match self.students.get_mut(name) {
            Some(s) => s.grades.push(grade),
            None => {}
        }
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        // Implement here
        match self.students.get(name) {
            Some(s) => &s.grades[0..s.grades.len()],
            None => {
                let grades: &[u8; 0] = &[];
                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]
}

Ayushman Rathore

Spartan09

11 days ago

30.91ms

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

norabbito

11 days ago

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

Benjamin Falk

lumio

12 days ago

25.79ms

2099.20kb

use std::collections::HashMap;
pub struct Student {
    pub name: String,
    pub grades: Vec<u8>
}
pub struct StudentGrades {
    pub students: HashMap<String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    pub fn add_student(&mut self, name: &str) {
        self.students.insert(
            name.to_string(),
            Student {
                name: name.to_string(),
                grades: vec![],
            },
        );
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        let student = match self.students.get_mut(name) {
            Some(found) => found,
            None => return,
        };
        student.grades.push(grade);
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        let student = match self.students.get(name) {
            Some(found) => found,
            None => 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]
}

McToady.eth

McCoady

12 days ago

29.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) {
        // Create student struct
        let student = Student { name: String::from(name), grades: Vec::new() };
        // Add name,student k,v to hashmap
        self.students.insert(String::from(name), student);
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        // If student in hashmap, push grade to grades vec 
        if let Some(student) = self.students.get_mut(name) {
            student.grades.push(grade);
        }
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        // Get student from hashmap, then get their grades
        &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]
}

Jordan

Jordan-Haidee

13 days ago

78.25ms

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_owned())
            .and_modify(|_|{})
            .or_insert(Student{name: name.to_owned(), grades: vec![]});
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        // Implement here
        if let Some(v) = self.students.get_mut(name) {
            v.grades.push(grade);
        }
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        if let Some(v) = self.students.get(name) {
            v.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]
}

Douglas Campbell

CampbellD84

13 days ago

25.31ms

2099.20kb

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

Kyle Diaz

kylediaz

14 days ago

26.54ms

2099.20kb

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

Kenneth Love

kennethlove

16 days ago

38.38ms

2099.20kb

use std::collections::HashMap;
pub struct Student {
    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 let None = self.students.get(name) {
            self.students.insert(name.to_string(), Student { name: name.to_string(), grades: vec![] });
        }
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        if let Some(Student { name: _, ref mut grades }) = self.students.get_mut(name) {
            grades.push(grade);
        }
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        // Implement here
        // get grades of a student
        if let Some(Student { name: _, grades }) = self.students.get(name) {
            &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]
}

Diego Maia

diegocmsantos

17 days ago

26.02ms

2099.20kb

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

Prafful

iamsahu

17 days ago

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

tzmijewski

17 days ago

56.13ms

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

ludovicknecht

18 days ago

27.73ms

2099.20kb

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

Muhammad-Dennis

18 days ago

32.03ms

2099.20kb

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

Whisper_icoma

1378046967

19 days ago

27.19ms

2099.20kb

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

alemack17

20 days ago

34.15ms

2099.20kb

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

manuelmj

20 days ago

27.27ms

2099.20kb

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

manuelmj

20 days ago

27.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
        let name = name.to_string();
        self.students.entry(name.clone()).or_insert(Student{name, 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]
}

manuelmj

20 days ago

32.22ms

2099.20kb

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

manuelmj

20 days ago

28.75ms

2099.20kb

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

automata-studio

20 days ago

24.98ms

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

kosay

sarub0b0

20 days ago

41.20ms

2099.20kb

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

Denis SOURON

Brack0

20 days ago

28.10ms

2099.20kb

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

Donald Huber-Youmans

dHuberYoumans

20 days ago

30.11ms

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

roux g. buciu

adudenamedruby

22 days ago

32.71ms

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) {
        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
                .entry(name.to_string())
                .and_modify(|v| v.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]
}

TeDeMos

22 days ago

28.62ms

2099.20kb

use std::collections::HashMap;
pub struct Student {
    pub name: String,
    pub grades: Vec<u8>
}
pub struct StudentGrades {
    pub students: HashMap<String, Student>
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    // 3. Implement the methods
    pub fn add_student(&mut self, name: &str) {
        let name = name.to_string();
        self.students.entry(name.clone()).or_insert_with(|| Student { name, grades: Vec::new() });
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        self.students.get_mut(name).unwrap().grades.push(grade);
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        &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]
}

RiyadDz22

22 days ago

28.31ms

1413.12kb

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

Nikita Smirnov

Nismirno

22 days ago

28.57ms

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

Suraj Vijayan

its-me-sv

22 days ago

37.70ms

2099.20kb

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

Suraj Vijayan

its-me-sv

22 days ago

32.63ms

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
            .get(name)
            .map(|student| student.grades.as_slice())
            .unwrap_or(&[])
    }
}
// Example usage
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    println!("{:?}", tracker.get_grades("Alice")); // [85, 90]
    println!("{:?}", tracker.get_grades("Bob")); // [78]
}

Viktor Merkurev

fennr

22 days ago

32.61ms

2099.20kb

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

iamforgettable

22 days ago

24.06ms

1413.12kb

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

Romain Grimau

Herrgrim0

22 days ago

28.99ms

2099.20kb

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

Jun Huang

leemars

22 days ago

28.04ms

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

rawar089

23 days ago

29.97ms

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

Eric Wilmes

ericwilmes

23 days ago

30.11ms

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

Elliott Draper

ejdraper

23 days ago

29.92ms

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![]
        });
    }
    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] {
        return &self.students.get(name).unwrap().grades;
    }
}
// Example usage
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    println!("{:?}", tracker.get_grades("Alice")); // [85, 90]
    println!("{:?}", tracker.get_grades("Bob")); // [78]
}

Algorab

23 days ago

36.11ms

2099.20kb

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