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

bernardoLY19

10 hours ago

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

Miguel Ángel Allende

maallende

2 days ago

4.29ms

102.50kb

use std::collections::HashMap;
#[derive(Default)]
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() {
            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 {
    // 2. Define the fields
    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) {
            &student.grades
        } else {
            &[]
        }
    }
    pub fn get_student(&self, name: &str) -> Option<&Student> {
        // Implement here
        self.students.get(name)
    }
}
// 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]
    let alice = tracker.students.get_mut("Alice").unwrap();
    alice.add_grade(95);
    println!("{:?}", alice.grades);
    println!("{:?}", alice.average_grade());
    println!("{:?}", tracker.get_grades("Bob"));
    
    // Example of using default value
    let default_student = Student::default();
    let student: &Student = tracker.get_student("Alice").unwrap_or(&default_student);
    println!("{:?}", student.name); // Some(Student { name: "Alice", grades: [85, 90] })
    
}

Baron Curtin

baroncurtin2

2 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().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(&[])
    }
}
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"));
}

Cobran53

3 days ago

3.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) {
        self.grades.push(grade);
    }
    pub fn average_grade(&self) -> f64 {
        if self.grades.len() != 0 {
            self.grades.iter().sum::<u8>() as f64/self.grades.len() as f64
        } else { 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] {
        &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"));
}

medzernik

6 days ago

3.85ms

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().map(|x| *x).sum::<u8>() as f64;
        let divider = match self.grades.len() {
            0 => 1.,
            val => val as f64,
        };
        sum / divider
    }
}
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());
}

alexsavio

6 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) {
        // 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.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"));
}

coreyralph

8 days ago

4.33ms

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

Herman effendi

hrmneffdii

8 days ago

4.01ms

102.50kb

use std::collections::HashMap;
#[derive(Debug)]
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: u32 = self.grades.iter().map(|&g| g as u32).sum();
        let count = self.grades.len();
        sum as f64 / count as f64
    }
}
#[derive(Debug)]
pub struct StudentGrades {
    pub students: HashMap<String, Student>,
}
impl StudentGrades {
    pub fn new() -> Self {
        Self {
            students: HashMap::new(),
        }
    }
    pub fn add_student(&mut self, name: &str) {
        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<&[u8]> {
        self.students.get(name).map(|s| s.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: {:?}", alice.grades);
    println!("Alice avg: {}", alice.average_grade());
    println!("Bob grades: {:?}", tracker.get_grades("Bob"));
}

Rocky.C

cloki0610

9 days ago

4.03ms

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().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] {
        self.students.get(name).map(|student|student.grades.as_slice()).unwrap_or_else(||{
            println!("The student {} is not found!", name);
            &[]
        })
    }
}
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"));
}

Ushakov Andrey

stdstring

9 days 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
        match self.grades.len() {
            length if length == 0 => 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 get_grades(&self, name: &str) -> &[u8] {
        // Implement here
        self.students.get(name).expect("input is always valid").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"));
}

vanos001

9 days ago

3.73ms

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 : f64= self.grades.len() as f64;
        if n == 0.0 {
            return 0.0
        }
        let mut sum : f64 = 0.0;
        for i in self.grades.iter(){
            sum += *i as f64;
        }
        return sum/(n);
    }
    pub fn get_grades_s(&self) -> Vec<u8>{
        return self.grades.clone();
    }
}
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>>{
        return Some(self.students.get(name)?.get_grades_s());
    }
}
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"));
}

Kr0wZ

10 days ago

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

Philippe Massicotte

PMassicotte

10 days ago

4.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) {
        self.grades.push(grade);
    }
    pub fn average_grade(&self) -> f64 {
        if self.grades.is_empty() {
            return 0.0;
        }
        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 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"));
}

Tri Nguyen

nguyentri

10 days ago

4.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
        let slice = self.grades.as_slice();
        let slice_len = self.grades.len() as f64;
        if slice.is_empty(){
            0.0f64
        } else {
            let mut sum = slice[0] as f64;
            //let mut i = 1;
            for num in slice.iter().skip(1) {
                sum = sum + *num as f64;
                //i += 1;
            }
            sum/slice_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_else(||{
            println!("The student {} is not found!", name);
            &[]
        })
    }
}
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"));
}

laiaga

12 days 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) {
        self.grades.push(grade);
    }
    pub fn average_grade(&self) -> f64 {
        let nb_grades = self.grades.len() as f64;
        if nb_grades == 0.0 {
            0.0
        } else {
            let mut total: f64 = 0.0;
            for grade in self.grades.iter() {
                total = total + *grade as f64;
            }
            total / nb_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(&mut self, name: &str) -> Vec<u8> {
        self.students[name].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"));
}

Smith Cruise

Smith-Cruise

12 days ago

4.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) {
        // Implement here
        self.grades.push(grade);
    }
    pub fn average_grade(&self) -> f64 {
        // Implement here
        let mut total: f64 = 0.0;
        if self.grades.len() == 0 {
            return total;
        }
        let mut num: f64 = 0.0;
        for grade in &self.grades {
            total += *grade as f64;
            num += 1.0;
        }
        return total / num;
    }
}
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"));
}

Tri Nguyen

nguyentri

12 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) {
        // Implement here
        self.grades.push(grade);
    }
    pub fn average_grade(&self) -> f64 {
        // Implement here
        let slice = self.grades.as_slice();
        if slice.is_empty(){
            0.0f64
        } else {
            let mut sum = slice[0] as f64;
            let mut i = 1;
            for num in slice.iter().skip(1) {
                sum = sum + *num as f64;
                i += 1;
            }
            sum/i 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_else(||{
            println!("The student {} is not found!", name);
            &[]
        })
    }
}
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"));
}

Enes

enesscevik

13 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) {
        // Implement here
        self.grades.push(grade);
    }
    pub fn average_grade(&self) -> f64 {
        // Implement here
        if self.grades.len() == 0{
            return 0.0;
        }
        let sum : f64 = self.grades.iter().map(|&x| x 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 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"));
}

Luigi Terrone

LuigiTer

14 days 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

15 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

15 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

16 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

16 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

17 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

19 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

20 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

21 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

22 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

24 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

a month 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

a month 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

a month 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

a month 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

a month 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

a month 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

a month 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

a month 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

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

a month 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

a month 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

a month 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

a month 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

a month 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

a month 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

a month 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

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