Student Grades Tracker 2

If you’ve completed the first part of the Student Grades Tracker challenge, congratulations! Now it’s time to enhance the functionality by adding methods directly to the Student struct.

This will help you practice designing methods for individual struct instances while integrating them into a larger system.

For this challenge, we’ll build upon the StudentGrades system. In addition to the methods you’ve already implemented, you’ll now focus on adding two new methods to the Student struct itself.

Your Task

You need to extend the Student struct by implementing two methods:

add_grade: Add a grade to the student’s grades vector.
average_grade(&self) -> f64: Calculate and return the average grade of the student. Return 0.0 if the student has no grades.

The StudentGrades struct remains the same as in the previous challenge. You’ll modify its existing methods to use the newly added methods of the Student struct.

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

4.02ms

102.50kb

use std::collections::HashMap;
pub struct Student {
    pub name: String,
    pub grades: Vec<u8>,
}
impl Student {
    pub fn add_grade(&mut self, grade: u8) {
        // Implement here
        self.grades.push(grade);
    }
    pub fn average_grade(&self) -> f64 {
        // Implement here
        if self.grades.is_empty() {
            return 0_f64;
        }
        else {
            let mut sum = 0;
            for i in self.grades.clone() {
                sum += i;
            }
            return (sum as f64/self.grades.len() as f64);
        }
    }
}
pub struct StudentGrades {
    pub students: HashMap<String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    pub fn add_student(&mut self, name: &str) {
        self.students.entry(name.to_string()).or_insert(Student {
            name: name.to_string(),
            grades: vec![],
        });
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        if let Some(student) = self.students.get_mut(name) {
            student.add_grade(grade);
        }
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        self.students
            .get(name)
            .map(|student| &student.grades[..])
            .unwrap_or(&[])
    }
}
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    let alice = tracker.students.get_mut("Alice").unwrap();
    alice.add_grade(95);
    println!("{:?}", alice.grades);
    println!("{:?}", alice.average_grade());
    println!("{:?}", tracker.get_grades("Bob"));
}

amaneru

7ma8no9

3 days ago

4.23ms

102.50kb

use std::collections::HashMap;
pub struct Student {
    pub name: String,
    pub grades: Vec<u8>,
}
impl Student {
    pub fn add_grade(&mut self, grade: u8) {
        // Implement here
        self.grades.push(grade);
    }
    pub fn average_grade(&self) -> f64 {
        if self.grades.len() == 0 {
            return 0_f64;
        }
        // Implement here
        self.grades.iter().sum::<u8>() as f64 / self.grades.len() as f64
    }
}
pub struct StudentGrades {
    pub students: HashMap<String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        self.students.get(name).map_or(&[], |s| &s.grades)
    }
    pub fn add_student(&mut self, name: &str) {
        self.students.entry(name.to_string()).or_insert(Student {
            name: name.to_string(),
            grades: vec![],
        });
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        if let Some(student) = self.students.get_mut(name) {
            student.add_grade(grade);
        }
    }
}
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    let alice = tracker.students.get_mut("Alice").unwrap();
    alice.add_grade(95);
    println!("{:?}", alice.grades);
    println!("{:?}", alice.average_grade());
    println!("{:?}", tracker.get_grades("Bob"));
}

zawwwu

3 days ago

4.30ms

102.50kb

use std::collections::HashMap;
pub struct Student {
    pub name: String,
    pub grades: Vec<u8>,
}
impl Student {
    pub fn add_grade(&mut self, grade: u8) {
        self.grades.push(grade);
    }
    pub fn average_grade(&self) -> f64 {
        if self.grades.len() == 0 {
            return 0.0;
        }
        let sum: u32 = self.grades.iter().map(|&x| x as u32).sum();
        sum as f64 / self.grades.len() as f64
    }
}
pub struct StudentGrades {
    pub students: HashMap<String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    pub fn add_student(&mut self, name: &str) {
        self.students.entry(name.to_string()).or_insert(Student {
            name: name.to_string(),
            grades: vec![],
        });
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        if let Some(student) = self.students.get_mut(name) {
            student.add_grade(grade);
        }
    }
}
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    let alice = tracker.students.get_mut("Alice").unwrap();
    alice.add_grade(95);
    println!("{:?}", alice.grades);
    println!("{:?}", alice.average_grade());
}

AKA.MoneyTaker

M4Bo2

5 days ago

4.04ms

102.50kb

use std::collections::HashMap;
#[derive(Debug)]
pub struct Student {
    pub name: String,
    pub grades: Vec<u8>,
}
impl Student {
    // Add a grade to the student’s grades vector
    pub fn add_grade(&mut self, grade: u8) {
        self.grades.push(grade);
    }
    // Calculate and return the average grade of the student
    pub fn average_grade(&self) -> f64 {
        if self.grades.is_empty() {
            return 0.0; // Return 0.0 if the student has no grades
        }
        let sum: u32 = self.grades.iter().map(|&grade| grade as u32).sum(); // Sum all grades
        sum as f64 / self.grades.len() as f64 // Calculate the average
    }
}
#[derive(Debug)]
pub struct StudentGrades {
    pub students: HashMap<String, Student>,
}
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) {
        self.students
            .entry(name.to_string())
            .or_insert(Student {
                name: name.to_string(),
                grades: vec![],
            });
    }
    // 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.add_grade(grade);
        }
    }
    // Retrieve the grades of a student as an immutable slice reference
    pub fn get_grades(&self, name: &str) -> &[u8] {
        self.students
            .get(name)
            .map(|student| &student.grades[..])
            .unwrap_or(&[])
    }
}
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);
    // Add another grade to Alice
    let alice = tracker.students.get_mut("Alice").unwrap();
    alice.add_grade(95);
    // Print Alice’s grades and average grade
    println!("{:?}", alice.grades); // [85, 90, 95]
    println!("{:?}", alice.average_grade()); // 90.0
    // Print Bob’s grades
    println!("{:?}", tracker.get_grades("Bob")); // [78]
}

Dyaa Adel

dyaa-adel

7 days ago

5.19ms

102.50kb

use std::collections::HashMap;
pub struct Student {
    pub name: String,
    pub grades: Vec<u8>,
}
impl Student {
    pub fn add_grade(&mut self, grade: u8) {
        // Implement here
        self.grades.push(grade);
    }
    pub fn average_grade(&self) -> f64 {
        // Implement here
        if self.grades.len() > 0 {
            let sum: u8 = self.grades.iter().sum();
            return sum as f64 / self.grades.len() as f64;
        }
        return 0.0;
    }
}
pub struct StudentGrades {
    pub students: HashMap<String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    pub fn add_student(&mut self, name: &str) {
        self.students.entry(name.to_string()).or_insert(Student {
            name: name.to_string(),
            grades: vec![],
        });
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        if let Some(student) = self.students.get_mut(name) {
            student.add_grade(grade);
        }
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        &self.students.get(name).unwrap().grades
        
    }
}
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    let alice = tracker.students.get_mut("Alice").unwrap();
    alice.add_grade(95);
    println!("{:?}", alice.grades);
    println!("{:?}", alice.average_grade());
    println!("{:?}", tracker.get_grades("Bob"));
}

Lê Minh Quân

aleister1102

8 days ago

3.77ms

102.50kb

use std::collections::HashMap;
pub struct Student {
    pub name: String,
    pub grades: Vec<u8>,
}
impl Student {
    pub fn add_grade(&mut self, grade: u8) {
        // Implement here
        self.grades.push(grade);
    }
    pub fn average_grade(&self) -> f64 {
        // Implement here
        if self.grades.len() < 1 {
            return 0.0;
        }
        let mut sum: f64 = 0.0;
        for grade in &self.grades {
            sum += *grade as f64;
        }
        sum / self.grades.len() as f64
    }   
}
pub struct StudentGrades {
    pub students: HashMap<String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    pub fn add_student(&mut self, name: &str) {
        self.students.entry(name.to_string()).or_insert(Student {
            name: name.to_string(),
            grades: vec![],
        });
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        if let Some(student) = self.students.get_mut(name) {
            student.add_grade(grade);
        }
    }
    pub fn get_grades(&mut self, name: &str) -> &[u8] {
        if let Some(student) = self.students.get(name) {
            return &student.grades;
        }
        &[]
    }
}
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    let alice = tracker.students.get_mut("Alice").unwrap();
    alice.add_grade(95);
    println!("{:?}", alice.grades);
    println!("{:?}", alice.average_grade());
    println!("{:?}", tracker.get_grades("Bob"));
}

Yi Hao

leongyihao

10 days ago

4.61ms

102.50kb

use std::collections::HashMap;
pub struct Student {
    pub name: String,
    pub grades: Vec<u8>,
}
impl Student {
    pub fn add_grade(&mut self, grade: u8) {
		self.grades.push(grade);
    }
    pub fn average_grade(&self) -> f64 {
        if 0 == self.grades.len() {
			return 0.
		}
		let mut sum: f64 = 0.;
        self.grades.iter().for_each(|&x| sum += x as f64);
		sum / self.grades.len() as f64
    }
	pub fn get_grades(&self) -> &[u8] {
		self.grades.as_slice()
	}
}
pub struct StudentGrades {
    pub students: HashMap<String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    pub fn add_student(&mut self, name: &str) {
        self.students.entry(name.to_string()).or_insert(Student {
            name: name.to_string(),
            grades: vec![],
        });
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        if let Some(student) = self.students.get_mut(name) {
            student.add_grade(grade);
        }
    }
}
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    let alice = tracker.students.get_mut("Alice").unwrap();
    alice.add_grade(95);
    println!("{:?}", alice.grades);
    println!("{:?}", alice.average_grade());
}

Benjamin Falk

lumio

10 days ago

3.88ms

102.50kb

use std::collections::HashMap;
pub struct Student {
    pub name: String,
    pub grades: Vec<u8>,
}
impl Student {
    pub fn add_grade(&mut self, grade: u8) {
        self.grades.push(grade);
    }
    pub fn average_grade(&self) -> f64 {
        let count = self.grades.len() as f64;
        if count == 0.0 {
            return 0.0;
        }
        let sum: f64 = self.grades.iter().map(|x| *x as f64).sum();
        sum / count
    }
}
pub struct StudentGrades {
    pub students: HashMap<String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    pub fn add_student(&mut self, name: &str) {
        self.students.entry(name.to_string()).or_insert(Student {
            name: name.to_string(),
            grades: vec![],
        });
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        if let Some(student) = self.students.get_mut(name) {
            student.add_grade(grade);
        }
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        let student_option = self.students.get(name);
        if student_option.is_none() {
            return &[];
        }
        &student_option.unwrap().grades
    }
}
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    let alice = tracker.students.get_mut("Alice").unwrap();
    alice.add_grade(95);
    println!("{:?}", alice.grades);
    println!("{:?}", alice.average_grade());
    println!("{:?}", tracker.get_grades("Bob"));
}

Guilherme Cesário Strachan

strachan

10 days ago

4.00ms

102.50kb

use std::collections::HashMap;
pub struct Student {
    pub name: String,
    pub grades: Vec<u8>,
}
impl Student {
    pub fn add_grade(&mut self, grade: u8) {
        // Implement here
        self.grades.push(grade);
    }
    pub fn average_grade(&self) -> f64 {
        // Implement here
        if self.grades.is_empty() {
            return 0.0;
        } else {
            let sum: u8 = self.grades.iter().sum();
            sum as f64 / self.grades.len() as f64
        }
    }
}
pub struct StudentGrades {
    pub students: HashMap<String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    pub fn add_student(&mut self, name: &str) {
        self.students.entry(name.to_string()).or_insert(Student {
            name: name.to_string(),
            grades: vec![],
        });
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        if let Some(student) = self.students.get_mut(name) {
            student.add_grade(grade);
        }
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        // Implement here
        if let Some(x) = self.students.get(name) {
            &x.grades
        } else {
            &[]
        }
    }
}
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    let alice = tracker.students.get_mut("Alice").unwrap();
    alice.add_grade(95);
    println!("{:?}", alice.grades);
    println!("{:?}", alice.average_grade());
    println!("{:?}", tracker.get_grades("Bob"));
}

Anıl Şenay

anilsenay

10 days ago

5.14ms

102.50kb

use std::collections::HashMap;
pub struct Student {
    pub name: String,
    pub grades: Vec<u8>,
}
impl Student {
    pub fn add_grade(&mut self, grade: u8) {
        self.grades.push(grade);
    }
    pub fn average_grade(&self) -> f64 {
        if self.grades.is_empty() {
            return 0.0;
        }
        self.grades.iter().sum::<u8>() as f64 / self.grades.len() as f64
    }
}
pub struct StudentGrades {
    pub students: HashMap<String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    pub fn add_student(&mut self, name: &str) {
        self.students.entry(name.to_string()).or_insert(Student {
            name: name.to_string(),
            grades: vec![],
        });
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        if let Some(student) = self.students.get_mut(name) {
            student.add_grade(grade);
        }
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        &self.students.get(name).unwrap().grades
    }
}
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    let alice = tracker.students.get_mut("Alice").unwrap();
    alice.add_grade(95);
    println!("{:?}", alice.grades);
    println!("{:?}", alice.average_grade());
    println!("{:?}", tracker.get_grades("Bob"));
}

TiagONTOP

10 days ago

4.09ms

102.50kb

use std::collections::HashMap;
pub struct Student {
    pub name: String,
    pub grades: Vec<u8>,
}
impl Student {
    pub fn add_grade(&mut self, grade: u8) {
        // Implement here
        self.grades.push(grade)
    }
    pub fn average_grade(&self) -> f64 {
        // Implement here
        if self.grades.len() == 0 {
            return 0.0;
        }
        let mut sum: u8 = 0;
        let mut count: u8 = 0;
        for e in self.grades.iter() {
            sum += e;
            count += 1
        }
        sum as f64 / count as f64
    }
}
pub struct StudentGrades {
    pub students: HashMap<String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    pub fn add_student(&mut self, name: &str) {
        self.students.entry(name.to_string()).or_insert(Student {
            name: name.to_string(),
            grades: vec![],
        });
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        if let Some(student) = self.students.get_mut(name) {
            student.add_grade(grade);
        }
    }
    pub fn get_grades(&mut self, name: &str) -> Vec<u8>   {
        match self.students.get_mut(name) {
            s => s.unwrap().grades.clone(),
            None => vec![]
        }
    }
}
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    let alice = tracker.students.get_mut("Alice").unwrap();
    alice.add_grade(95);
    println!("{:?}", alice.grades);
    println!("{:?}", alice.average_grade());
    println!("{:?}", tracker.get_grades("Bob"));
}

Ayushman Rathore

Spartan09

11 days ago

14.11ms

102.50kb

use std::collections::HashMap;
pub struct Student {
    pub name: String,
    pub grades: Vec<u8>,
}
impl Student {
    pub fn add_grade(&mut self, grade: u8) {
        self.grades.push(grade);
    }
    pub fn average_grade(&self) -> f64 {
        if self.grades.len() == 0 {
            return 0.0;
        }
        self.grades.iter().sum::<u8>() as f64 / self.grades.len() as f64
    }
}
pub struct StudentGrades {
    pub students: HashMap<String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    pub fn add_student(&mut self, name: &str) {
        self.students.entry(name.to_string()).or_insert(Student {
            name: name.to_string(),
            grades: vec![],
        });
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        if let Some(student) = self.students.get_mut(name) {
            student.add_grade(grade);
        }
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        &self.students.get(name).unwrap().grades
    }
}
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    let alice = tracker.students.get_mut("Alice").unwrap();
    alice.add_grade(95);
    println!("{:?}", alice.grades);
    println!("{:?}", alice.average_grade());
    println!("{:?}", tracker.get_grades("Bob"));
}

norabbito

11 days ago

8.43ms

102.50kb

use std::collections::HashMap;
pub struct Student {
    pub name: String,
    pub grades: Vec<u8>,
}
impl Student {
    pub fn add_grade(&mut self, grade: u8) {
        // Implement here
        self.grades.push(grade);
    }
    pub fn average_grade(&self) -> f64 {
        // Implement here
        let sum: u8 = self.grades.iter().sum();
        if sum == 0 {
            return 0.0;
        }
        
        f64::from(sum) / (self.grades.len() as f64)
    }
}
pub struct StudentGrades {
    pub students: HashMap<String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    pub fn add_student(&mut self, name: &str) {
        self.students.entry(name.to_string()).or_insert(Student {
            name: name.to_string(),
            grades: vec![],
        });
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        if let Some(student) = self.students.get_mut(name) {
            student.add_grade(grade);
        }
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        &self.students.get(name).unwrap().grades
    }
}
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    let alice = tracker.students.get_mut("Alice").unwrap();
    alice.add_grade(95);
    println!("{:?}", alice.grades);
    println!("{:?}", alice.average_grade());
    println!("{:?}", tracker.get_grades("Bob"));
}

McToady.eth

McCoady

12 days ago

5.10ms

102.50kb

use std::collections::HashMap;
pub struct Student {
    pub name: String,
    pub grades: Vec<u8>,
}
impl Student {
    pub fn add_grade(&mut self, grade: u8) {
        // Implement here
        self.grades.push(grade);
    }
    pub fn average_grade(&self) -> f64 {
        // Implement here
        let mut tot = 0;
        let vals = self.grades.len() as f64;
         
        if vals == 0.0 {
            return 0.0;
        }
        for val in &self.grades {
            tot += val;
        }
        tot as f64 / vals
    }
}
pub struct StudentGrades {
    pub students: HashMap<String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    pub fn add_student(&mut self, name: &str) {
        self.students.entry(name.to_string()).or_insert(Student {
            name: name.to_string(),
            grades: vec![],
        });
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        if let Some(student) = self.students.get_mut(name) {
            student.add_grade(grade);
        }
    }
    pub fn get_grades(&self, name: &str) -> &Vec<u8> {
        &self.students.get(name).unwrap().grades
    }
}
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    let alice = tracker.students.get_mut("Alice").unwrap();
    alice.add_grade(95);
    println!("{:?}", alice.grades);
    println!("{:?}", alice.average_grade());
    println!("{:?}", tracker.get_grades("Bob"));
}

Jordan

Jordan-Haidee

13 days ago

4.39ms

102.50kb

use std::collections::HashMap;
pub struct Student {
    pub name: String,
    pub grades: Vec<u8>,
}
impl Student {
    pub fn add_grade(&mut self, grade: u8) {
        // Implement here
        self.grades.push(grade);
    }
    pub fn average_grade(&self) -> f64 {
        // Implement here
        if self.grades.is_empty() {
            return 0.0;
        }
        self.grades.iter().map(|v| *v as f64).sum::<f64>() / self.grades.len() as f64
    }
}
pub struct StudentGrades {
    pub students: HashMap<String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    pub fn add_student(&mut self, name: &str) {
        self.students.entry(name.to_string()).or_insert(Student {
            name: name.to_string(),
            grades: vec![],
        });
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        if let Some(student) = self.students.get_mut(name) {
            student.add_grade(grade);
        }
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        if let Some(v) = self.students.get(name) {
            v.grades.as_slice()
        } else {
            &[]
        }
    }
}
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    let alice = tracker.students.get_mut("Alice").unwrap();
    alice.add_grade(95);
    println!("{:?}", alice.grades);
    println!("{:?}", alice.average_grade());
    println!("{:?}", tracker.get_grades("Bob"));
}

Diego Maia

diegocmsantos

14 days ago

4.31ms

102.50kb

use std::collections::HashMap;
pub struct Student {
    pub name: String,
    pub grades: Vec<u8>,
}
impl Student {
    pub fn add_grade(&mut self, grade: u8) {
        self.grades.push(grade);
    }
    pub fn average_grade(&self) -> f64 {
        let sum: u8 = self.grades.iter().sum();
        let len: u8 = self.grades.len() as u8;
        if len == 0 {
            0.0
        } else {
            sum as f64 / len as f64
        }
    }
}
pub struct StudentGrades {
    pub students: HashMap<String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    pub fn add_student(&mut self, name: &str) {
        self.students.entry(name.to_string()).or_insert(Student {
            name: name.to_string(),
            grades: vec![],
        });
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        if let Some(student) = self.students.get_mut(name) {
            student.add_grade(grade);
        }
    }
}
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    let alice = tracker.students.get_mut("Alice").unwrap();
    alice.add_grade(95);
    println!("{:?}", alice.grades);
    println!("{:?}", alice.average_grade());
}

Kenneth Love

kennethlove

16 days ago

6.07ms

102.50kb

use std::collections::HashMap;
pub struct Student {
    pub name: String,
    pub grades: Vec<u8>,
}
impl Student {
    pub fn add_grade(&mut self, grade: u8) {
        // Implement here
        // add grade to grades vec
        self.grades.push(grade);
    }
    pub fn average_grade(&self) -> f64 {
        // Implement here
        // get average grade or 0.0 if no grades
        if self.grades.len() > 0 {
            let sum: u8 = self.grades.iter().sum();
            let len: u8 = self.grades.len() as u8;
            sum as f64 / len as f64
        } else { 0.0 }
    }
}
pub struct StudentGrades {
    pub students: HashMap<String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    pub fn add_student(&mut self, name: &str) {
        self.students.entry(name.to_string()).or_insert(Student {
            name: name.to_string(),
            grades: vec![],
        });
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        if let Some(student) = self.students.get_mut(name) {
            student.add_grade(grade);
        }
    }
}
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    let alice = tracker.students.get_mut("Alice").unwrap();
    alice.add_grade(95);
    println!("{:?}", alice.grades);
    println!("{:?}", alice.average_grade());
}

tzmijewski

17 days ago

4.83ms

102.50kb

use std::collections::HashMap;
pub struct Student {
    pub name: String,
    pub grades: Vec<u8>,
}
impl Student {
    pub fn add_grade(&mut self, grade: u8) {
        // Implement here
        self.grades.push(grade);
    }
    pub fn average_grade(&self) -> f64 {
        // Implement here
        let mut counter:f64 = 0.0;
        let mut sum:f64 = 0.0;
        for grade in &(self.grades) {
            sum += *grade as f64;
            counter += 1.0;
        }
        if counter > 0.0 {
            sum / counter
        } else {
            0.0
        }
    }
}
pub struct StudentGrades {
    pub students: HashMap<String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    pub fn add_student(&mut self, name: &str) {
        self.students.entry(name.to_string()).or_insert(Student {
            name: name.to_string(),
            grades: vec![],
        });
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        if let Some(student) = self.students.get_mut(name) {
            student.add_grade(grade);
        }
    }
        pub fn get_grades(&self, name: &str) -> &[u8] {
        // Implement here
        &(self.students[name].grades)
    }
}
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    let alice = tracker.students.get_mut("Alice").unwrap();
    alice.add_grade(95);
    println!("{:?}", alice.grades);
    println!("{:?}", alice.average_grade());
    println!("{:?}", tracker.get_grades("Bob"));
}

Prafful

iamsahu

17 days ago

4.54ms

102.50kb

use std::collections::HashMap;
pub struct Student {
    pub name: String,
    pub grades: Vec<u8>,
}
impl Student {
    pub fn add_grade(&mut self, grade: u8) {
        // Implement here
        &self.grades.push(grade);
    }
    pub fn average_grade(&self) -> f64 {
        // Implement here
        if self.grades.len() > 0 {
            self.grades.iter().copied().sum::<u8>() as f64 / self.grades.len() as f64
        } else {
            0.0
        }
    }
}
pub struct StudentGrades {
    pub students: HashMap<String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    pub fn add_student(&mut self, name: &str) {
        self.students.entry(name.to_string()).or_insert(Student {
            name: name.to_string(),
            grades: vec![],
        });
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        if let Some(student) = self.students.get_mut(name) {
            student.add_grade(grade);
        }
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        return &self.students.get(name).unwrap().grades
    }
}
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    let alice = tracker.students.get_mut("Alice").unwrap();
    alice.add_grade(95);
    println!("{:?}", alice.grades);
    println!("{:?}", alice.average_grade());
    println!("{:?}", tracker.get_grades("Bob"));
}

Prafful

iamsahu

17 days ago

4.24ms

102.50kb

use std::collections::HashMap;
pub struct Student {
    pub name: String,
    pub grades: Vec<u8>,
}
impl Student {
    pub fn add_grade(&mut self, grade: u8) {
        // Implement here
        &self.grades.push(grade);
    }
    pub fn average_grade(&self) -> f64 {
        // Implement here
        if self.grades.len() > 0 {
            self.grades.iter().copied().sum::<u8>() as f64 / self.grades.len() as f64
        } else {
            0.0
        }
    }
}
pub struct StudentGrades {
    pub students: HashMap<String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    pub fn add_student(&mut self, name: &str) {
        self.students.entry(name.to_string()).or_insert(Student {
            name: name.to_string(),
            grades: vec![],
        });
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        if let Some(student) = self.students.get_mut(name) {
            student.add_grade(grade);
        }
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        return &self.students.get(name).unwrap().grades
    }
}
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    let alice = tracker.students.get_mut("Alice").unwrap();
    alice.add_grade(95);
    println!("{:?}", alice.grades);
    println!("{:?}", alice.average_grade());
    println!("{:?}", tracker.get_grades("Bob"));
}

Suraj Vijayan

its-me-sv

18 days ago

25.82ms

102.50kb

use std::collections::HashMap;
pub struct Student {
    pub name: String,
    pub grades: Vec<u8>,
}
impl Student {
    pub fn add_grade(&mut self, grade: u8) {
        // Implement here
        self.grades.push(grade);
    }
    pub fn average_grade(&self) -> f64 {
        // Implement here
        match self.grades.is_empty() {
            true => 0.0,
            false => self.grades.iter().sum::<u8>() as f64 / self.grades.len() as f64
        }
    }
}
pub struct StudentGrades {
    pub students: HashMap<String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    pub fn add_student(&mut self, name: &str) {
        self.students.entry(name.to_string()).or_insert(Student {
            name: name.to_string(),
            grades: vec![],
        });
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        if let Some(student) = self.students.get_mut(name) {
            student.add_grade(grade);
        }
    }
}
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    let alice = tracker.students.get_mut("Alice").unwrap();
    alice.add_grade(95);
    println!("{:?}", alice.grades);
    println!("{:?}", alice.average_grade());
}

Muhammad-Dennis

18 days ago

5.22ms

102.50kb

use std::collections::HashMap;
pub struct Student {
    pub name: String,
    pub grades: Vec<u8>,
}
impl Student {
    pub fn add_grade(&mut self, grade: u8) {
        // Implement here
        self.grades.push(grade)
    }
    pub fn average_grade(&self) -> f64 {
        // Implement here
        if self.grades.is_empty() {
            return 0.0
        }
        let sum: u8 = self.grades.iter().sum();
        let average = sum as f64 / self.grades.len() as f64; 
        average
        
    }
}
pub struct StudentGrades {
    pub students: HashMap<String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    pub fn add_student(&mut self, name: &str) {
        self.students.entry(name.to_string()).or_insert(Student {
            name: name.to_string(),
            grades: vec![],
        });
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        if let Some(student) = self.students.get_mut(name) {
            student.add_grade(grade);
        }
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        // Implement here
        match self.students.get(name) {
            Some(s) => &s.grades,
            None => &[]
        }
    }
}
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    let alice = tracker.students.get_mut("Alice").unwrap();
    alice.add_grade(95);
    println!("{:?}", alice.grades);
    println!("{:?}", alice.average_grade());
    println!("{:?}", tracker.get_grades("Bob"));
}

ludovicknecht

18 days ago

3.99ms

102.50kb

use std::collections::HashMap;
pub struct Student {
    pub name: String,
    pub grades: Vec<u8>,
}
impl Student {
    pub fn add_grade(&mut self, grade: u8) {
        self.grades.push(grade);
    }
    pub fn average_grade(&self) -> f64 {
        let len = self.grades.len();
        if len == 0 {return 0.0};
        self.grades.iter().sum::<u8>() as f64 / len as f64
    }
}
pub struct StudentGrades {
    pub students: HashMap<String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    pub fn add_student(&mut self, name: &str) {
        self.students.entry(name.to_string()).or_insert(Student {
            name: name.to_string(),
            grades: vec![],
        });
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        if let Some(student) = self.students.get_mut(name) {
            student.add_grade(grade);
        }
    }
}

Whisper_icoma

1378046967

19 days ago

3.99ms

102.50kb

use std::collections::HashMap;
pub struct Student {
    pub name: String,
    pub grades: Vec<u8>,
}
impl Student {
    pub fn add_grade(&mut self, grade: u8) {
        self.grades.push(grade);
    }
    pub fn average_grade(&self) -> f64 {
        if self.grades.is_empty() {
            return 0.0;
        }
        self.grades.iter().copied().sum::<u8>() as f64 / self.grades.len() as f64
    }
}
pub struct StudentGrades {
    pub students: HashMap<String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    pub fn add_student(&mut self, name: &str) {
        self.students.entry(name.to_string()).or_insert(Student {
            name: name.to_string(),
            grades: vec![],
        });
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        if let Some(student) = self.students.get_mut(name) {
            student.add_grade(grade);
        }
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        if let Some(students) = self.students.get(name) {
            students.grades.as_slice()
        } else {
            &[]
        }
    }
}
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    let alice = tracker.students.get_mut("Alice").unwrap();
    alice.add_grade(95);
    println!("{:?}", alice.grades);
    println!("{:?}", alice.average_grade());
    println!("{:?}", tracker.get_grades("Bob"));
}

manuelmj

19 days ago

5.15ms

102.50kb

use std::collections::HashMap;
pub struct Student {
    pub name: String,
    pub grades: Vec<u8>,
}
impl Student {
    pub fn add_grade(&mut self, grade: u8) {
        // Implement here
        self.grades.push(grade);
    }
    pub fn average_grade(&self) -> f64 {
        // Implement here
        if self.grades.len() == 0 {
            return 0 as f64;
        }
            
        let sum: u32 = self.grades.iter().map(|&value |  value as u32).sum();
        sum as f64 / self.grades.len()  as f64
 
    }
}
pub struct StudentGrades {
    pub students: HashMap<String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    pub fn add_student(&mut self, name: &str) {
        self.students.entry(name.to_string()).or_insert(Student {
            name: name.to_string(),
            grades: vec![],
        });
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        if let Some(student) = self.students.get_mut(name) {
            student.add_grade(grade);
        }
    }
    pub fn get_grades(&self, name: &str) -> &[u8]{
        // Implement here
        &self.students.get(name).unwrap().grades 
    }
}
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    let alice = tracker.students.get_mut("Alice").unwrap();
    alice.add_grade(95);
    println!("{:?}", alice.grades);
    println!("{:?}", alice.average_grade());
    println!("{:?}", tracker.get_grades("Bob"));
}

kosay

sarub0b0

20 days ago

4.02ms

102.50kb

use std::collections::HashMap;
pub struct Student {
    pub name: String,
    pub grades: Vec<u8>,
}
impl Student {
    pub fn add_grade(&mut self, grade: u8) {
        self.grades.push(grade);
    }
    pub fn average_grade(&self) -> f64 {
        if self.grades.is_empty() {
            return 0.0;
        }
        self.grades.iter().copied().sum::<u8>() as f64 / self.grades.len() as f64
    }
}
pub struct StudentGrades {
    pub students: HashMap<String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    pub fn add_student(&mut self, name: &str) {
        self.students.entry(name.to_string()).or_insert(Student {
            name: name.to_string(),
            grades: vec![],
        });
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        if let Some(student) = self.students.get_mut(name) {
            student.add_grade(grade);
        }
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        if let Some(students) = self.students.get(name) {
            students.grades.as_slice()
        } else {
            &[]
        }
    }
}
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    let alice = tracker.students.get_mut("Alice").unwrap();
    alice.add_grade(95);
    println!("{:?}", alice.grades);
    println!("{:?}", alice.average_grade());
    println!("{:?}", tracker.get_grades("Bob"));
}

alemack17

20 days ago

4.53ms

102.50kb

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

automata-studio

20 days ago

4.20ms

102.50kb

use std::collections::HashMap;
pub struct Student {
    pub name: String,
    pub grades: Vec<u8>,
}
impl Student {
    pub fn add_grade(&mut self, grade: u8) {
        // Implement here
        self.grades.push(grade);
    }
    pub fn average_grade(&self) -> f64 {
        if self.grades.is_empty() {
            return 0.0;
        }
        let sum: u8 = self.grades.iter().sum();
        sum as f64 / self.grades.len() as f64
    }
}
pub struct StudentGrades {
    pub students: HashMap<String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    pub fn add_student(&mut self, name: &str) {
        self.students.entry(name.to_string()).or_insert(Student {
            name: name.to_string(),
            grades: vec![],
        });
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        if let Some(student) = self.students.get_mut(name) {
            student.add_grade(grade);
        }
    }
    pub fn average_grade(&self, name: &str) -> f64 {
        self.students.get(name).unwrap().average_grade()
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        &self.students.get(name).unwrap().grades
    }
}
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    let alice = tracker.students.get_mut("Alice").unwrap();
    alice.add_grade(95);
    println!("{:?}", alice.grades);
    println!("{:?}", alice.average_grade());
    println!("{:?}", tracker.get_grades("Bob"));
}

Donald Huber-Youmans

dHuberYoumans

20 days ago

5.63ms

102.50kb

use std::collections::HashMap;
pub struct Student {
    pub name: String,
    pub grades: Vec<u8>,
}
impl Student {
    pub fn add_grade(&mut self, grade: u8) {
        // Implement here
        self.grades.push(grade);
    }
    pub fn average_grade(&self) -> f64 {
        // Implement here
        if self.grades.is_empty() {
            0.0
        } else {
            self.grades.iter().sum::<u8>() as f64 / self.grades.len() as f64
        }
    }
}
pub struct StudentGrades {
    pub students: HashMap<String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    pub fn add_student(&mut self, name: &str) {
        self.students.entry(name.to_string()).or_insert(Student {
            name: name.to_string(),
            grades: vec![],
        });
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        if let Some(student) = self.students.get_mut(name) {
            student.add_grade(grade);
        }
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        &self.students.get(name).unwrap().grades
    }
    }
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    let alice = tracker.students.get_mut("Alice").unwrap();
    alice.add_grade(95);
    println!("{:?}", alice.grades);
    println!("{:?}", alice.average_grade());
    println!("{:?}", tracker.get_grades("Bob"));
}

Denis SOURON

Brack0

20 days ago

4.00ms

102.50kb

use std::collections::HashMap;
pub struct Student {
    pub name: String,
    pub grades: Vec<u8>,
}
impl Student {
    pub fn add_grade(&mut self, grade: u8) {
        self.grades.push(grade);
    }
    pub fn average_grade(&self) -> f64 {
        if self.grades.is_empty() {
            return 0.0;
        }
        let mut sum = 0u32;
        for &grade in &self.grades {
            sum += grade as u32;
        }
        (sum as f64) / (self.grades.len() as f64)
    }
}
pub struct StudentGrades {
    pub students: HashMap<String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    pub fn add_student(&mut self, name: &str) {
        self.students.entry(name.to_string()).or_insert(Student {
            name: name.to_string(),
            grades: vec![],
        });
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        if let Some(student) = self.students.get_mut(name) {
            student.add_grade(grade);
        }
    }
}

Romain Grimau

Herrgrim0

21 days ago

4.98ms

102.50kb

use std::collections::HashMap;
pub struct Student {
    pub name: String,
    pub grades: Vec<u8>,
}
impl Student {
    pub fn add_grade(&mut self, grade: u8) {
        // Implement here
        self.grades.push(grade)
    }
    pub fn average_grade(&self) -> f64 {
        // Implement here
        if self.grades.is_empty() {
            0.0
        } else {
            self.grades.iter().sum::<u8>() as f64 / self.grades.len() as  f64
        }
    }
}
pub struct StudentGrades {
    pub students: HashMap<String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    pub fn add_student(&mut self, name: &str) {
        self.students.entry(name.to_string()).or_insert(Student {
            name: name.to_string(),
            grades: vec![],
        });
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        if let Some(student) = self.students.get_mut(name) {
            student.add_grade(grade);
        }
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        &self.students.get(name).unwrap().grades
    }
}
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    let alice = tracker.students.get_mut("Alice").unwrap();
    alice.add_grade(95);
    println!("{:?}", alice.grades);
    println!("{:?}", alice.average_grade());
    println!("{:?}", tracker.get_grades("Bob"));
}

RiyadDz22

21 days ago

4.89ms

102.50kb

use std::collections::HashMap;
pub struct Student {
    pub name: String,
    pub grades: Vec<u8>,
}
impl Student {
    pub fn add_grade(&mut self, grade: u8) {
        // Implement here
        self.grades.push(grade);
    }
    pub fn average_grade(&self) -> f64 {
        // Implement here
        if self.grades.is_empty() {
            return 0.0;
        }
        let sum: u32 = self.grades.iter().map(|&grade| grade as u32).sum();
        sum as f64 / self.grades.len() as f64
    
    }
}
pub struct StudentGrades {
    pub students: HashMap<String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    pub fn add_student(&mut self, name: &str) {
        self.students.entry(name.to_string()).or_insert(Student {
            name: name.to_string(),
            grades: vec![],
        });
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        if let Some(student) = self.students.get_mut(name) {
            student.add_grade(grade);
        }
    }
}
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    let alice = tracker.students.get_mut("Alice").unwrap();
    alice.add_grade(95);
    println!("{:?}", alice.grades);
    println!("{:?}", alice.average_grade());
}

roux g. buciu

adudenamedruby

22 days ago

5.34ms

102.50kb

use std::collections::HashMap;
pub struct Student {
    pub name: String,
    pub grades: Vec<u8>,
}
impl Student {
       pub fn add_grade(&mut self, grade: u8) {
        self.grades.push(grade);
    }
    pub fn average_grade(&self) -> f64 {
        if self.grades.is_empty() { return 0.0 };
        let sum = self.grades.iter().fold(0u32, |sum, i| sum + (*i as u32));
        (sum as f64) / (self.grades.len() as f64)
    }
}
pub struct StudentGrades {
    pub students: HashMap<String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    pub fn add_student(&mut self, name: &str) {
        self.students.entry(name.to_string()).or_insert(Student {
            name: name.to_string(),
            grades: vec![],
        });
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        if let Some(student) = self.students.get_mut(name) {
            student.add_grade(grade);
        }
    }
}
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    let alice = tracker.students.get_mut("Alice").unwrap();
    alice.add_grade(95);
    println!("{:?}", alice.grades);
    println!("{:?}", alice.average_grade());
}

TeDeMos

22 days ago

4.31ms

102.50kb

use std::collections::HashMap;
pub struct Student {
    pub name: String,
    pub grades: Vec<u8>,
}
impl Student {
    pub fn add_grade(&mut self, grade: u8) {
        self.grades.push(grade);
    }
    pub fn average_grade(&self) -> f64 {
        if self.grades.is_empty() {
            return 0.0
        }
        self.grades.iter().sum::<u8>() as f64 / self.grades.len() as f64
    }
}
pub struct StudentGrades {
    pub students: HashMap<String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    pub fn add_student(&mut self, name: &str) {
        self.students.entry(name.to_string()).or_insert(Student {
            name: name.to_string(),
            grades: vec![],
        });
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        if let Some(student) = self.students.get_mut(name) {
            student.add_grade(grade);
        }
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        &self.students.get(name).unwrap().grades
    }
}
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    let alice = tracker.students.get_mut("Alice").unwrap();
    alice.add_grade(95);
    println!("{:?}", alice.grades);
    println!("{:?}", alice.average_grade());
    println!("{:?}", tracker.get_grades("Bob"));
}

Nikita Smirnov

Nismirno

22 days ago

6.06ms

102.50kb

use std::collections::HashMap;
pub struct Student {
    pub name: String,
    pub grades: Vec<u8>,
}
impl Student {
    pub fn add_grade(&mut self, grade: u8) {
        // Implement here
        self.grades.push(grade);
    }
    pub fn average_grade(&self) -> f64 {
        // Implement here
        if self.grades.is_empty() {
            return 0.0;
        }
        self.grades.iter().sum::<u8>() as f64 / self.grades.len() as f64
    }
}
pub struct StudentGrades {
    pub students: HashMap<String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    pub fn add_student(&mut self, name: &str) {
        self.students.entry(name.to_string()).or_insert(Student {
            name: name.to_string(),
            grades: vec![],
        });
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        if let Some(student) = self.students.get_mut(name) {
            student.add_grade(grade);
        }
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        match self.students.get(name) {
            None => &[],
            Some(student) => student.grades.as_slice(),
        }
    }
}
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    let alice = tracker.students.get_mut("Alice").unwrap();
    alice.add_grade(95);
    println!("{:?}", alice.grades);
    println!("{:?}", alice.average_grade());
    println!("{:?}", tracker.get_grades("Bob"));
}

Viktor Merkurev

fennr

22 days ago

4.87ms

102.50kb

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>,
}
impl Student {
    pub fn add_grade(&mut self, grade: u8) {
        // Implement here
        self.grades.push(grade);
    }
    pub fn average_grade(&self) -> f64 {
        // Implement here
        if self.grades.is_empty() {
            return 0.;
        }
        let sum: u32 = self.grades
            .iter()
            .map(|&x| x as u32)
            .sum();
        sum as f64 / self.grades.len() as f64
    }
}
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) {
        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.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

4.36ms

102.50kb

use std::collections::HashMap;
pub struct Student {
    pub name: String,
    pub grades: Vec<u8>,
}
impl Student {
    pub fn add_grade(&mut self, grade: u8) {
        // Implement here
        self.grades.push(grade);
    }
    pub fn average_grade(&self) -> f64 {
        // Implement here
        if self.grades.is_empty() {
            return 0.0;
        }
        self.grades.iter().sum::<u8>() as f64 / self.grades.len() as f64
    }
}
pub struct StudentGrades {
    pub students: HashMap<String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    pub fn add_student(&mut self, name: &str) {
        self.students.entry(name.to_string()).or_insert(Student {
            name: name.to_string(),
            grades: vec![],
        });
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        if let Some(student) = self.students.get_mut(name) {
            student.add_grade(grade);
        }
    }
    pub fn get_grades(&self,name: &str) -> &[u8] {
        if let Some(student) = self.students.get(name) {
            return &student.grades;
        }
        &[]
    }
}
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    let alice = tracker.students.get_mut("Alice").unwrap();
    alice.add_grade(95);
    println!("{:?}", alice.grades);
    println!("{:?}", alice.average_grade());
    println!("{:?}", tracker.get_grades("Bob"));
}

Jun Huang

leemars

22 days ago

5.06ms

102.50kb

use std::collections::HashMap;
pub struct Student {
    pub name: String,
    pub grades: Vec<u8>,
}
impl Student {
    pub fn add_grade(&mut self, grade: u8) {
        // Implement here
        self.grades.push(grade);
    }
    pub fn average_grade(&self) -> f64 {
        // Implement here
        if self.grades.is_empty() {
            return 0.0;
        }
        let sum = self.grades.iter().map(|&grade| grade as u32).sum::<u32>();
        let count = self.grades.len();
        sum as f64 / count as f64
    }
}
pub struct StudentGrades {
    pub students: HashMap<String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    pub fn add_student(&mut self, name: &str) {
        self.students.entry(name.to_string()).or_insert(Student {
            name: name.to_string(),
            grades: vec![],
        });
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        if let Some(student) = self.students.get_mut(name) {
            student.add_grade(grade);
        }
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        self.students.get(name).unwrap().grades.as_slice()
    }
}
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    let alice = tracker.students.get_mut("Alice").unwrap();
    alice.add_grade(95);
    println!("{:?}", alice.grades);
    println!("{:?}", alice.average_grade());
    println!("{:?}", tracker.get_grades("Bob"));
}

rawar089

23 days ago

4.86ms

102.50kb

use std::collections::HashMap;
pub struct Student {
    pub name: String,
    pub grades: Vec<u8>,
}
impl Student {
    pub fn add_grade(&mut self, grade: u8) {
        // Implement here
        self.grades.push(grade);
    }
    pub fn average_grade(&self) -> f64 {
        // Implement here
        let n = self.grades.len();
        if  n == 0 {
            return 0.0;
        } else {
            let mut sum = 0.0;
            for grade in self.grades.iter() {
                sum += *grade as f64;
            }
            return sum / (n as f64)
        }
    }
}
pub struct StudentGrades {
    pub students: HashMap<String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    pub fn add_student(&mut self, name: &str) {
        self.students.entry(name.to_string()).or_insert(Student {
            name: name.to_string(),
            grades: vec![],
        });
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        if let Some(student) = self.students.get_mut(name) {
            student.add_grade(grade);
        }
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        &self.students.get(name).unwrap().grades
    }
}
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    let alice = tracker.students.get_mut("Alice").unwrap();
    alice.add_grade(95);
    println!("{:?}", alice.grades);
    println!("{:?}", alice.average_grade());
    println!("{:?}", tracker.get_grades("Bob"));
}

Elliott Draper

ejdraper

23 days ago

12.03ms

104.10kb

use std::collections::HashMap;
pub struct Student {
    pub name: String,
    pub grades: Vec<u8>,
}
impl Student {
    pub fn add_grade(&mut self, grade: u8) {
        self.grades.push(grade);
    }
    pub fn average_grade(&self) -> f64 {
        if self.grades.len() == 0 {
            return 0.0;
        }
        let avg = self.grades.iter().sum::<u8>() as f64 / self.grades.len() as f64;
        println!("Average: {} :: {}", self.name, avg);
        return avg;
    }
}
pub struct StudentGrades {
    pub students: HashMap<String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    pub fn add_student(&mut self, name: &str) {
        self.students.entry(name.to_string()).or_insert(Student {
            name: name.to_string(),
            grades: vec![],
        });
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        if let Some(student) = self.students.get_mut(name) {
            student.add_grade(grade);
        }
    }
    pub fn get_grades(&mut self, name: &str) -> Vec<u8> {
        return self.students.get(name).unwrap().grades.clone();
    }
}
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    let alice = tracker.students.get_mut("Alice").unwrap();
    alice.add_grade(95);
    println!("{:?}", alice.grades);
    println!("{:?}", alice.average_grade());
    println!("{:?}", tracker.get_grades("Bob"));
}

Algorab

23 days ago

5.31ms

102.50kb

use std::collections::HashMap;
pub struct Student {
    pub name: String,
    pub grades: Vec<u8>,
}
impl Student {
    pub fn add_grade(&mut self, grade: u8) {
        self.grades.push(grade);
    }
    pub fn average_grade(&self) -> f64 {
    
        let sum = self.grades.iter().sum::<u8>() as f64;
        if sum == 0.0 {
            return sum;
        }
        sum / self.grades.len() as f64
    }
}
pub struct StudentGrades {
    pub students: HashMap<String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    pub fn add_student(&mut self, name: &str) {
        self.students.entry(name.to_string()).or_insert(Student {
            name: name.to_string(),
            grades: vec![],
        });
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        if let Some(student) = self.students.get_mut(name) {
            student.add_grade(grade);
        }
    }
}

Kentaro Abe

abekem

23 days ago

4.20ms

102.50kb

use std::collections::HashMap;
pub struct Student {
    pub name: String,
    pub grades: Vec<u8>,
}
impl Student {
    pub fn add_grade(&mut self, grade: u8) {
        self.grades.push(grade);
    }
    pub fn average_grade(&self) -> f64 {
        if self.grades.len() == 0 {
            return 0.0;
        }
        let sum: f64 = self.grades.iter().map(|&grade| grade as f64).sum();
        sum / self.grades.len() as f64
    } 
}
pub struct StudentGrades {
    pub students: HashMap<String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    pub fn add_student(&mut self, name: &str) {
        self.students.entry(name.to_string()).or_insert(Student {
            name: name.to_string(),
            grades: vec![],
        });
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        if let Some(student) = self.students.get_mut(name) {
            student.add_grade(grade);
        }
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        &self.students.get(name).unwrap().grades
    }
}
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    let alice = tracker.students.get_mut("Alice").unwrap();
    alice.add_grade(95);
    println!("{:?}", alice.grades);
    println!("{:?}", alice.average_grade());
    println!("{:?}", tracker.get_grades("Bob"));
}

Suresh Prajapati

toddlers

24 days ago

3.93ms

102.50kb

use std::collections::HashMap;
pub struct Student {
    pub name: String,
    pub grades: Vec<u8>,
}
impl Student {
    pub fn add_grade(&mut self, grade: u8) {
        // Implement here
        self.grades.push(grade);
    }
    pub fn average_grade(&self) -> f64 {
        // Implement here
         if !self.grades.is_empty(){
        let total_score: f64 = self.grades.iter().map(|it| *it as f64).sum();
        let l = self.grades.len();
        total_score/ l as f64
        
        } else {return 0.0;}
    }
}
pub struct StudentGrades {
    pub students: HashMap<String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    pub fn add_student(&mut self, name: &str) {
        self.students.entry(name.to_string()).or_insert(Student {
            name: name.to_string(),
            grades: vec![],
        });
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        if let Some(student) = self.students.get_mut(name) {
            student.add_grade(grade);
        }
    }
}
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    let alice = tracker.students.get_mut("Alice").unwrap();
    alice.add_grade(95);
    println!("{:?}", alice.grades);
    println!("{:?}", alice.average_grade());
    // println!("{:?}", tracker.get_grades("Bob"));
}

エヴァンゲリオン

Lu-zihang

24 days ago

4.36ms

102.50kb

use core::f64;
use std::collections::HashMap;
pub struct Student {
    pub name: String,
    pub grades: Vec<u8>,
}
impl Student {
    pub fn add_grade(&mut self, grade: u8) {
        // Implement here
        self.grades.push(grade);
    }
    pub fn average_grade(&self) -> f64 {
        // Implement here
        if self.grades.len() == 0 { return 0.0; }
        let gc = self.grades.len();
        
        let sum: f64 = self.grades.iter().map(|it| *it as f64).sum();
        sum / gc as f64
    }
}
pub struct StudentGrades {
    pub students: HashMap<String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    pub fn add_student(&mut self, name: &str) {
        self.students.entry(name.to_string()).or_insert(Student {
            name: name.to_string(),
            grades: vec![],
        });
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        if let Some(student) = self.students.get_mut(name) {
            student.add_grade(grade);
        }
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        &self.students.get(name).unwrap().grades
    }
}
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    let alice = tracker.students.get_mut("Alice").unwrap();
    alice.add_grade(95);
    println!("{:?}", alice.grades);
    println!("{:?}", alice.average_grade());
    println!("{:?}", tracker.get_grades("Bob"));
}

Simon Noetzlin

sainoe

24 days ago

6.67ms

102.50kb

use std::collections::HashMap;
pub struct Student {
    pub name: String,
    pub grades: Vec<u8>,
}
impl Student {
    pub fn add_grade(&mut self, grade: u8) {
        // Implement here
        self.grades.push(grade);
    }
    pub fn average_grade(&self) -> f64 {
        if self.grades.len() != 0 {
            let sum: i32 = self.grades.iter().map(|grade| *grade as i32).sum();
            let count: f64 = self.grades.len() as f64;
            sum as f64/count
        }else{
          0.0
        }
    }
}
pub struct StudentGrades {
    pub students: HashMap<String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    pub fn add_student(&mut self, name: &str) {
        self.students.entry(name.to_string()).or_insert(Student {
            name: name.to_string(),
            grades: vec![],
        });
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        if let Some(student) = self.students.get_mut(name) {
            student.add_grade(grade);
        }
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        &self
            .students
            .get(name)
            .unwrap()
            .grades
    }
}
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    let alice = tracker.students.get_mut("Alice").unwrap();
    alice.add_grade(95);
    println!("{:?}", alice.grades);
    println!("{:?}", alice.average_grade());
    println!("{:?}", tracker.get_grades("Bob"));
}

Stefan Roas

sroas

25 days ago

3.79ms

102.50kb

use core::f64;
use std::collections::HashMap;
pub struct Student {
    pub name: String,
    pub grades: Vec<u8>,
}
impl Student {
    pub fn add_grade(&mut self, grade: u8) {
        // Implement here
        self.grades.push(grade);
    }
    pub fn average_grade(&self) -> f64 {
        // Implement here
        let gc = self.grades.len();
        if gc == 0 {
            return 0.0;
        }
        let sum: f64 = self.grades.iter().map(|it| *it as f64).sum();
        sum / gc as f64
    }
}
pub struct StudentGrades {
    pub students: HashMap<String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    pub fn add_student(&mut self, name: &str) {
        self.students.entry(name.to_string()).or_insert(Student {
            name: name.to_string(),
            grades: vec![],
        });
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        if let Some(student) = self.students.get_mut(name) {
            student.add_grade(grade);
        }
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        &self.students.get(name).unwrap().grades
    }
}
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    let alice = tracker.students.get_mut("Alice").unwrap();
    alice.add_grade(95);
    println!("{:?}", alice.grades);
    println!("{:?}", alice.average_grade());
    println!("{:?}", tracker.get_grades("Bob"));
}

Marco-Normal

25 days ago

4.66ms

102.50kb

use std::collections::HashMap;
pub struct Student {
    pub name: String,
    pub grades: Vec<u8>,
}
impl Student {
    pub fn add_grade(&mut self, grade: u8) {
        self.grades.push(grade);
    }
    pub fn average_grade(&self) -> f64 {
        if self.grades.len() == 0 {
            return 0.0
        }
        self.grades.iter().sum::<u8>() as f64 / self.grades.len() as f64
    }
}
pub struct StudentGrades {
    pub students: HashMap<String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    pub fn add_student(&mut self, name: &str) {
        self.students.entry(name.to_string()).or_insert(Student {
            name: name.to_string(),
            grades: vec![],
        });
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        if let Some(student) = self.students.get_mut(name) {
            student.add_grade(grade);
        }
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        &self.students.get(name).unwrap().grades
    }
}
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    let alice = tracker.students.get_mut("Alice").unwrap();
    alice.add_grade(95);
    println!("{:?}", alice.grades);
    println!("{:?}", alice.average_grade());
    println!("{:?}", tracker.get_grades("Bob"));
}

Jim Lawton

jimlawton

25 days ago

4.42ms

102.50kb

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

Sandeep chauhan

ryzen-xp

25 days ago

6.27ms

102.50kb

use std::collections::HashMap;
pub struct Student {
    pub name: String,
    pub grades: Vec<u8>,
}
impl Student {
    pub fn add_grade(&mut self, grade: u8) {
        // Implement here
        self.grades.push(grade);
    }
    pub fn average_grade(&self) -> f64 {
        // Implement here
        let l = self.grades.len();
        if l == 0 {
            0.0
        } else {
            self.grades.iter().sum::<u8>() as f64 / l as f64 
        }
    }
}
pub struct StudentGrades {
    pub students: HashMap<String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    pub fn add_student(&mut self, name: &str) {
        self.students.entry(name.to_string()).or_insert(Student {
            name: name.to_string(),
            grades: vec![],
        });
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        if let Some(student) = self.students.get_mut(name) {
            student.add_grade(grade);
        }
    }
    pub fn get_grades(&self, name: &str) -> &[u8] {
        // Implement here
        &self.students.get(name).unwrap().grades
    }
}
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    let alice = tracker.students.get_mut("Alice").unwrap();
    alice.add_grade(95);
    println!("{:?}", alice.grades);
    println!("{:?}", alice.average_grade());
    println!("{:?}", tracker.get_grades("Bob"));
}

Mohammed Omar Miraj

MOmarMiraj

a month ago

10.16ms

102.50kb

use std::collections::HashMap;
pub struct Student {
    pub name: String,
    pub grades: Vec<u8>,
}
impl Student {
    pub fn add_grade(&mut self, grade: u8) {
        // Implement here
        self.grades.push(grade);
    }
    pub fn average_grade(&self) -> f64 {
        // Implement here
        if self.grades.is_empty() {
            return 0.0;
        }
        self.grades.iter().copied().sum::<u8>() as f64 / self.grades.len() as f64
    }
}
pub struct StudentGrades {
    pub students: HashMap<String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
        pub fn get_grades(&self, name: &str) -> &[u8] {
        // Implement here
        &self.students.get(name).unwrap().grades
    }
    pub fn add_student(&mut self, name: &str) {
        self.students.entry(name.to_string()).or_insert(Student {
            name: name.to_string(),
            grades: vec![],
        });
    }
    pub fn add_grade(&mut self, name: &str, grade: u8) {
        if let Some(student) = self.students.get_mut(name) {
            student.add_grade(grade);
        }
    }
}
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    let alice = tracker.students.get_mut("Alice").unwrap();
    alice.add_grade(95);
    println!("{:?}", alice.grades);
    println!("{:?}", alice.average_grade());
    println!("{:?}", tracker.get_grades("Bob"));
}