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

Luigi Terrone

LuigiTer

18 hours ago

4.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.is_empty() {
            0.0
        } 
        else {
            let res: u32 = self.grades.iter().map(|&g| g as u32).sum();
            res 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());
    
}

Heino Mortensen

hmortensen83

2 days ago

3.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) {
        self.grades.push(grade);
    }
    pub fn average_grade(&self) -> f64 {
        if self.grades.is_empty() {
            0.0
        } else {
            self.grades.iter().map(|&g| g 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 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());
}

0x0f1

Paul4673

2 days ago

4.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) {
        self.grades.push(grade);
    }
    pub fn average_grade(&self) -> f64 {
        if self.grades.is_empty() {
            return 0.0
        }
        let length = self.grades.len() as f64;
        let mut total = 0.0;
        for grade in self.grades.iter(){
            total += *grade as f64;
        }
        let avg = total / length;
        avg 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) {
            Some(student) => &student.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"));
}

dattruongdev

3 days ago

4.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.len() <= 0 {
            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(&self, name: &str) -> &Vec<u8> {
        self.students.get(name).map(|s| &s.grades).unwrap()
    }
}
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    let alice = tracker.students.get_mut("Alice").unwrap();
    alice.add_grade(95);
    println!("{:?}", alice.grades);
    println!("{:?}", alice.average_grade());
    println!("{:?}", tracker.get_grades("Bob"));
}

esl

esl07

3 days ago

4.01ms

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() {
            0.0
        } else {
            let sum: f64 = self.grades.iter().map(|&g| g 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] {
        if let Some(student) = self.students.get(name) {
            &student.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"));
}

xxxxsk

4 days ago

5.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() {
            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) -> &Vec<u8> {
        &self.students[name].grades
    }
}
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    let alice = tracker.students.get_mut("Alice").unwrap();
    alice.add_grade(95);
    println!("{:?}", alice.grades);
    println!("{:?}", alice.average_grade());
    println!("{:?}", tracker.get_grades("Bob"));
}

Pierre Gordo

PierreGordo

6 days ago

3.91ms

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 mut total: f64 = 0.0;
            for grade in self.grades.iter(){
                total += *grade as f64;
            }
            return total/(self.grades.len() 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"));
}

hahu07

7 days ago

4.68ms

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 : f64 = self.grades.iter().sum::<u8>().into();
        let length : f64 = (self.grades.len() as u32).into();
        sum / length
    }
}
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"));
}

Lucop1911

8 days ago

4.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
        self.grades.push(grade);
    }
    pub fn average_grade(&self) -> f64 {
        // Implement here
        if self.grades.is_empty() {
            return 0.0;
        }
        let sum : f64 = self.grades.iter().sum::<u8>().into();
        let length : f64 = (self.grades.len() as u32).into();
        sum / length
    }
}
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"));
}

Christopher Kolbe

chkolbe

9 days ago

5.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.is_empty() {
            return 0.0;
        }
        let sum: f64 = self.grades.iter().sum::<u8>().into();
        let length: f64 = (self.grades.len() as u32).into();
        sum / length
    }
}
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"));
}

ikatlinsky

11 days ago

5.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) {
        self.grades.push(grade);
    }
    pub fn average_grade(&self) -> f64 {
        if self.grades.len() == 0 {
            return 0.0;
        }
        let sum = self.grades.iter().map(|&g| g as f64).sum::<f64>();
        let count = self.grades.len() as f64;
        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] {
        self.students.get(name).map(|s| &s.grades).unwrap()
    }
}
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    let alice = tracker.students.get_mut("Alice").unwrap();
    alice.add_grade(95);
    println!("{:?}", alice.grades);
    println!("{:?}", alice.average_grade());
    println!("{:?}", tracker.get_grades("Bob"));
}

diucicd

13 days ago

4.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.len() == 0 {
            return 0.0;
        }
        // Implement here
        let sz: f64 = self.grades.len() as f64;
        self.grades.iter().map(|&val| val as f64).sum::<f64>() / sz
    }
}
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()
    }
}
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"));
}

AQian

AQian0

18 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;
        }
        let sum: f64 = self.grades.iter().map(|grade| *grade as f64).sum();
        let len = self.grades.len() as f64;
        return sum / len
    }
}
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) -> Option<&Vec<u8>> {
        self.students.get(name).map(|student| &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"));
}

annececiledunand

19 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 {
        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 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());
    assert_eq!(alice.average_grade(), 90.0);
    assert_eq!(alice.average_grade(), 90.0);
    //println!("{:?}", tracker.get_grades("Bob"));
}

Sergey Matyash

matiaspub

20 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) {
        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) -> 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"));
}

GregGorin

20 days ago

4.49ms

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}      
    }
    fn get_grades(&self)-> &[u8] {
        &self.grades
    } 
}
pub struct StudentGrades {
    pub students: HashMap<String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    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().get_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"));
}

Ajit Kumar

urwithajit9

20 days ago

5.05ms

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 mut average: f64 = 0.0;
        let mut total :u8=0;
        if self.grades.len()> 0{
            for grade in &self.grades{
                total += grade;
            }
            average = total as f64 / self.grades.len() as f64;
        }
        return 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 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"));
}

AlphaN00mer1cal

21 days ago

4.40ms

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();
        if count == 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 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"));
}

wry

Liudel

22 days ago

5.17ms

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) -> Vec<u8> {
        if let Some(s) = self.students.get(name) {
            return s.grades.clone();
        }
        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"));
}

LeonardoPinheiro23

22 days ago

4.32ms

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 grades_len  = self.grades.len();
        if grades_len == 0 {
            return 0.0;
        }
        let grade_sum: u16 = self.grades.iter().map(|num_u8| *num_u8 as u16).sum();
        grade_sum as f64 / grades_len as f64
    }
    fn get_grades(&self) -> &[u8] {
        &self.grades
    }
}
pub struct StudentGrades {
    pub students: HashMap<String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    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.get_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"));
}

zapp42

22 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) {
        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 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"));
}

jbrakmic

23 days ago

5.35ms

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;
        }
        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());
    //println!("{:?}", tracker.get_grades("Bob"));
}

Saksinkarn Petchkuljinda

dward2nd

24 days ago

4.71ms

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: f64 = self.grades.iter()
            .map(|&grade| grade as f64)
            .sum();
        let len = self.grades.len();
        if len == 0 {
            0.0
        } else {
            sum / 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) {
            Some(student) => student.grades.as_slice(),
            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"));
}

Maicon Crespo

maiconcrespo

24 days ago

4.44ms

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 {
        // Implement here
        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)
        .map(|student| student.grades.as_slice())
        .unwrap_or_default()
    }
}
pub fn main() {
    let mut tracker = StudentGrades::new();
    tracker.add_student("Alice");
    tracker.add_student("Bob");
    tracker.add_grade("Alice", 85);
    tracker.add_grade("Alice", 90);
    tracker.add_grade("Bob", 78);
    let alice = tracker.students.get_mut("Alice").unwrap();
    alice.add_grade(95);
    println!("{:?}", alice.grades);
    println!("{:?}", alice.average_grade());
    println!("{:?}", tracker.get_grades("Bob"));
}

Travis

ttmgraham

24 days ago

5.48ms

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 as f64;
        }
        let mut total: f64 = 0.0;
        for grade in &self.grades {
            total += *grade as f64;
        }
        total / 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());
    // println!("{:?}", tracker.get_grades("Bob"));
}

Tommytto

25 days ago

6.44ms

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
        }
        // Implement here
        self.grades.iter().map(|&g| g 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 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());
}

Dimas Avrian Fachriza.

FForFachriza

25 days ago

11.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) {
        self.grades.push(grade);
    }
    pub fn average_grade(&self) -> f64 {
        let total_grades = self.grades.iter().fold(0, |acc, x| acc + x);
        let grades_len = self.grades.len();
        if total_grades == 0 {
            0.0
        } else {
            total_grades as f64 / 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());
}

Kenas Zogara

kenaszogara

25 days ago

5.25ms

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;
        for grade in self.grades.iter() {
            sum += grade;
        }
        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 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());
}

sjmellor

a month ago

5.79ms

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: u32 = self.grades.iter().fold(0u32, |sum, i| sum + (*i as u32));
        let count = self.grades.len();
        if count > 0 {
            return f64::from(sum) / count as f64
        }
        0f64
    }
}
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) {
            Some(student) => &student.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"));
}

thaisonho

a month ago

3.95ms

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

Sergejs Kostjucenko

sergejparity

a month ago

4.21ms

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 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"));
}

Zeno

djeanql

a month ago

3.81ms

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() {
            0.0
        } else {
            let sum: u32 = self.grades.iter().map(|&g| g 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) -> Option<&Vec<u8>> {
        self.students.get(name).map(|student| &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"));
}

Holger Knauer

hknauer

a month ago

3.94ms

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 0f64;
        }
        self.grades.iter().map(|x| *x 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] {
        // 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"));
}

zirkzee77

a month 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
        let sum: u8 = self.grades.iter().sum();
        let total = self.grades.len();
        if total == 0 {
        0.0        
        } else {
        sum as f64/ total 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());
}

Stas

nevmstas

a month ago

4.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.is_empty() {
            return 0.0;
        }   
        let sum: u8 = self.grades.iter().sum();
        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] {
        if let Some(student) = self.students.get(&name.to_string()) {
            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"));
}

ggnne

a month ago

4.32ms

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 n = self.grades.len();
        if n == 0 {
            return 0.0;
        }
        let sum: u8 = self.grades.iter().sum();
        sum as f64 / 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] {
        // Implement here
        if let Some(student) = self.students.get(&name.to_string()) {
            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"));
}

Octavian

orouwk

a month ago

12.68ms

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 sum:f64 = 0.0;
        let mut num:u8 = 0;
        for g in self.grades.iter() {
            sum+=*g as f64;
            num+=1;
        }
        if self.grades.len()>0 {
            sum/num 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) -> Vec<u8> {
        if let Some(s)=self.students.get(name) {
            s.grades.clone()
        } else {
            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"));
}

anhdoo

TuanAnhDoHoang

a month ago

6.12ms

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 mut s = 0.0;
            for grade in self.grades.iter(){
                s += *grade as f64;
            }
            return s/(self.grades.len() as f64);
        }
        return 0.0 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>{
        if let Some(value) = self.students.get(&name.to_string()){
            return value.grades.clone();
        }
        else{
            return Vec::new();
        }
    }
}
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"));
}

TestingPurpose14

a month ago

4.79ms

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() {
            0.0
        } else {
            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 get_grades(&self, name: &str) -> &[u8] {
        match self.students.get(name) {
            Some(student) => &student.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"));
}

Teimur Gasanov

teimurjan

a month ago

5.55ms

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 mut total: u8 = 0;
        for grade in self.grades.iter() {
            total += grade;
        }
        
        total 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.as_slice())
            .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"));
}

Seth Wood

seth-wood

a month ago

4.94ms

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() {
            0.0
        } else {
            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 get_grades(&self, name: &str) -> &[u8] {
        match self.students.get(name) {
            Some(student) => &student.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"));
}

Kanak Shilledar

kanakshilledar

a month ago

4.90ms

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) {
        self.grades.push(grade);
    }
    pub fn average_grade(&self) -> f64 {
        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] {
        match self.students.get(name) {
            Some(student) => &student.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"));
}

adamegao

a month ago

5.04ms

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) {
        self.grades.push(grade);
    }
    pub fn average_grade(&self) -> f64 {
        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] {
        match self.students.get(name) {
            Some(student) => &student.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"));
}

adamegao

a month ago

5.01ms

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) {
        self.grades.push(grade);
    }
    pub fn average_grade(&self) -> f64 {
        let len = self.grades.len() as f64;
        let sum = self
            .grades
            .iter()
            .map(|i| *i as f64)
            .fold(0f64, |acc: f64, x: f64| acc + x);
        sum / (if len > 0.0 { len } else { 1.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] {
        match self.students.get(name) {
            Some(student) => &student.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"));
}

Nicolai

Posmac

a month 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.len() <= 0 {
            return 0 as f64
        }
        let mut avg : f64 = 0.0;
        for g in self.grades.iter() {
            avg += *g as f64;
        }
        return (avg / self.grades.len() as f64) 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());
    //println!("{:?}", tracker.get_grades("Bob"));
}

Thomastienn

2 months ago

3.96ms

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) -> Option<&Vec<u8>> {
        self.students.get(name).map(|student| &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"));
}

Health-Care-Movie

2 months ago

4.26ms

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) -> 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"));
}

Elizabeth Doughty

Thymelizabeth

2 months ago

6.68ms

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 {
            self.grades.iter().copied().map(f64::from).sum::<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] {
        &self.students.get(name).expect("No such 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"));
}

Splatrac

splatrac

2 months ago

4.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
        let mut sum: f64 = 0.0;
        if self.grades.len() == 0 {
            return 0.0;
        }
        for n in &self.grades {
            sum += *n as f64; 
        }
        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) -> 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"));
}

Trịnh Chấn Duy

Duyyy123

2 months ago

5.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
        self.grades.iter().fold(0, |acc, x| acc + x) as f64
            / if self.grades.len() != 0 {
                self.grades.len()
            } else {
                1
            } 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());
}