Now that we know about vectors and hashmaps, let’s tackle something more challenging. In this exercise, we’ll build a system to manage and analyze student grades. This challenge will help you practice working with structs, hashmaps, vectors, and methods while managing a collection of data.
The focus here is on functionality. Ignore error handling for this challenge; assume the input is always valid.
You need to define the StudentGrades
struct, which contains a HashMap
of student names (String
) as keys and Student
structs as values. Each Student
struct should have the following fields:
name
: The name of the student (String
).grades
: A Vec<u8>
to store the student's grades.Implement the following methods for the StudentGrades
struct:
add_student(name: &str)
: Add a new student to the HashMap
. If the student already exists, do nothing.add_grade(name: &str, grade: u8)
: Add a grade to an existing student.get_grades(name: &str) -> &[u8]
: Retrieve the grades of a student as an immutable reference.HashMap
methods like entry
, insert
, and get
to manage student data.use std::collections::HashMap;pub struct Student { // 1. Define the fields pub name: String, pub grades: Vec<u8>}pub struct StudentGrades { // 2. Define the fields pub students: HashMap<String, Student>,}impl StudentGrades { pub fn new() -> Self { Self { students: HashMap::new(), } } // 3. Implement the methods pub fn add_student(&mut self, name: &str) { // Create student struct let student = Student { name: String::from(name), grades: Vec::new() }; // Add name,student k,v to hashmap self.students.insert(String::from(name), student); } pub fn add_grade(&mut self, name: &str, grade: u8) { // If student in hashmap, push grade to grades vec if let Some(student) = self.students.get_mut(name) { student.grades.push(grade); } } pub fn get_grades(&self, name: &str) -> &[u8] { // Get student from hashmap, then get their grades &self.students.get(name).unwrap().grades }}// Example usagepub 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]}
use std::collections::HashMap;pub struct Student { // 1. Define the fields pub name: String, pub grades: Vec<u8>}pub struct StudentGrades { // 2. Define the fields pub students: HashMap<String, Student>}impl StudentGrades { pub fn new() -> Self { Self { students: HashMap::new(), } } // 3. Implement the methods pub fn add_student(&mut self, name: &str) { // Implement here self.students.entry(name.to_owned()) .and_modify(|_|{}) .or_insert(Student{name: name.to_owned(), grades: vec![]}); } pub fn add_grade(&mut self, name: &str, grade: u8) { // Implement here if let Some(v) = self.students.get_mut(name) { v.grades.push(grade); } } pub fn get_grades(&self, name: &str) -> &[u8] { if let Some(v) = self.students.get(name) { v.grades.as_slice() } else { &[] } }}// Example usagepub 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]}
use std::collections::HashMap;pub struct Student { pub name: String, pub grades: Vec<u8>}pub struct StudentGrades { pub students: HashMap<String, Student>,}impl StudentGrades { pub fn new() -> Self { Self { students: HashMap::new(), } } // 3. Implement the methods pub fn add_student(&mut self, name: &str) { self.students.insert(name.to_string(), Student {name: name.to_string(), grades: Vec::new()}); } pub fn add_grade(&mut self, name: &str, grade: u8) { self.students.entry(name.to_string()).and_modify(|stdnt| stdnt.grades.push(grade)); } pub fn get_grades(&self, name: &str) -> &[u8] { &self.students.get(name).unwrap().grades }}// Example usagepub 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]}
use std::collections::HashMap;pub struct Student { pub name: String, pub grades: Vec<u8>,}pub struct StudentGrades { pub students: HashMap<String, Student>,}impl StudentGrades { pub fn new() -> Self { Self { students: HashMap::new(), } } // 3. Implement the methods pub fn add_student(&mut self, name: &str) { let new_student = Student { name: name.to_string(), grades: vec![], }; self.students.insert(name.to_string(), new_student); } pub fn add_grade(&mut self, name: &str, grade: u8) { if let Some(student) = self.students.get_mut(&name.to_string()) { student.grades.push(grade); } } pub fn get_grades(&self, name: &str) -> &[u8] { if let Some(student) = self.students.get(&name.to_string()) { return &(student.grades[..]); } return &[]; }}// Example usagepub 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]}
use std::collections::HashMap;pub struct Student { name: String, pub grades: Vec<u8>,}pub struct StudentGrades { // 2. Define the fields pub students: HashMap<String, Student>,}impl StudentGrades { pub fn new() -> Self { Self { students: HashMap::new(), } } // 3. Implement the methods pub fn add_student(&mut self, name: &str) { if let None = self.students.get(name) { self.students.insert(name.to_string(), Student { name: name.to_string(), grades: vec![] }); } } pub fn add_grade(&mut self, name: &str, grade: u8) { if let Some(Student { name: _, ref mut grades }) = self.students.get_mut(name) { grades.push(grade); } } pub fn get_grades(&self, name: &str) -> &[u8] { // Implement here // get grades of a student if let Some(Student { name: _, grades }) = self.students.get(name) { &grades } else { &[] } }}// Example usagepub 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]}
use std::collections::HashMap;pub struct Student { pub name: String, pub grades: Vec<u8>,}pub struct StudentGrades { pub students: HashMap<String, Student>,}impl StudentGrades { pub fn new() -> Self { Self { students: HashMap::new(), } } // 3. Implement the methods pub fn add_student(&mut self, name: &str) { self.students.insert( name.to_string(), Student { name: name.to_string(), grades: Vec::new(), }, ); } pub fn add_grade(&mut self, name: &str, grade: u8) { self.students .entry(name.to_string()) .and_modify(|s| s.grades.push(grade)); } pub fn get_grades(&self, name: &str) -> &[u8] { self.students .get(name) .map(|s| s.grades.as_slice()) .unwrap_or(&[]) }}// Example usagepub 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]}
use std::collections::HashMap;pub struct Student { // 1. Define the fields pub name: String, pub grades: Vec<u8>}pub struct StudentGrades { // 2. Define the fields pub students: HashMap<String, Student>}impl StudentGrades { pub fn new() -> Self { Self { students: HashMap::new(), } } // 3. Implement the methods pub fn add_student(&mut self, name: &str) { // Implement here self.students.insert(name.to_string(), Student {name: name.to_string(), grades: Vec::new()}); } pub fn add_grade(&mut self, name: &str, grade: u8) { // Implement here let student: &mut Student = self.students.get_mut(name).unwrap(); student.grades.push(grade); } pub fn get_grades(&self, name: &str) -> &[u8] { // Implement here &self.students.get(name).unwrap().grades }}// Example usagepub 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]}
use std::collections::HashMap;pub struct Student { // 1. Define the fields pub name: String, pub grades: Vec<u8>,}impl Student { pub fn new(name: String) -> Self { Self { name: name, grades: Vec::<u8>::new() } }}pub struct StudentGrades { // 2. Define the fields pub students: HashMap<String, Student>,}impl StudentGrades { pub fn new() -> Self { Self { students: HashMap::new(), } } // 3. Implement the methods pub fn add_student(&mut self, name: &str) { // Implement here match self.students.get(name) { Some(Student) => {}, None => { self.students.insert(name.to_string(), Student::new(name.to_string())); } } } pub fn add_grade(&mut self, name: &str, grade: u8) { // Implement here self.students.get_mut(name).unwrap().grades.push(grade); } pub fn get_grades(&self, name: &str) -> &[u8] { // Implement here &(self.students[name].grades) }}// Example usagepub 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]}
use std::collections::HashMap;pub struct Student { pub name: String, pub grades: Vec<u8>,}pub struct StudentGrades { pub students: HashMap<String, Student>}impl StudentGrades { pub fn new() -> Self { Self { students: HashMap::new(), } } pub fn add_student(&mut self, name: &str) { self.students.insert( name.into(), Student { name: name.into(), grades: vec![], } ); } pub fn add_grade(&mut self, name: &str, grade: u8) { self.students.get_mut(name).unwrap().grades.push(grade); } pub fn get_grades(&self, name: &str) -> &[u8] { &self.students.get(name).unwrap().grades }}
use std::collections::HashMap;pub struct Student { // 1. Define the fields pub name: String, pub grades: Vec<u8>}pub struct StudentGrades { // 2. Define the fields pub students: HashMap<String, Student>}impl StudentGrades { pub fn new() -> Self { Self { students: HashMap::new(), } } // 3. Implement the methods pub fn add_student(&mut self, name: &str) { // Implement here match self.students.insert(name.to_string(), Student { name: name.to_string(), grades: vec![] }) { Some(_) => {}, None => {} } } pub fn add_grade(&mut self, name: &str, grade: u8) { // Implement here let g = self.students.entry(name.to_string()).or_insert(Student { name: name.to_string(), grades: vec![] }); g.grades.push(grade); } pub fn get_grades(&self, name: &str) -> &[u8] { // Implement here match self.students.get(name) { Some(s) => &s.grades, None => &[] } }}// Example usagepub 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]}
use std::collections::HashMap;pub struct Student { pub name: String, pub grades: Vec<u8>}pub struct StudentGrades { pub students: HashMap<String, Student>}impl StudentGrades { pub fn new() -> Self { Self { students: HashMap::new(), } } // 3. Implement the methods pub fn add_student(&mut self, name: &str) { self.students.entry(name.to_string()) .or_insert(Student{name: name.to_string(),grades: Vec::new()}); } pub fn add_grade(&mut self, name: &str, grade: u8) { self.students.get_mut(name).unwrap().grades.push(grade); } pub fn get_grades(&self, name: &str) -> &[u8] { &self.students.get(name).unwrap().grades }}// Example usagepub 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]}
use std::collections::HashMap;pub struct Student { pub name: String, pub grades: Vec<u8>}pub struct StudentGrades { pub students: HashMap<String, Student>}impl StudentGrades { pub fn new() -> Self { Self { students: HashMap::new(), } } // 3. Implement the methods pub fn add_student(&mut self, name: &str) { self.students.entry(name.to_string()) .or_insert(Student{name: name.to_string(),grades: Vec::new()}); } pub fn add_grade(&mut self, name: &str, grade: u8) { self.students.get_mut(name).unwrap().grades.push(grade); } pub fn get_grades(&self, name: &str) -> &[u8] { &self.students.get(name).unwrap().grades }}// Example usagepub 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]}
use std::collections::HashMap;pub struct Student { // 1. Define the fields pub name:String, pub grades:Vec<u8>}pub struct StudentGrades { // 2. Define the fields pub students: HashMap<String, Student> }impl StudentGrades { pub fn new() -> Self { Self { students: HashMap::new(), } } // 3. Implement the methods pub fn add_student(&mut self, name: &str) { // Implement here let name = name.to_string(); self.students.entry(name.clone()).or_insert(Student{name, grades: vec![]}); } pub fn add_grade(&mut self, name: &str, grade: u8) { // Implement here self.students.entry(name.to_string()).and_modify(|student| student.grades.push(grade)); } pub fn get_grades(&self, name: &str) -> &[u8] { // Implement here &self.students.get(name).unwrap().grades }}// Example usagepub 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]}
use std::collections::HashMap;pub struct Student { // 1. Define the fields pub name:String, pub grades:Vec<u8>}pub struct StudentGrades { // 2. Define the fields pub students: HashMap<String, Student> }impl StudentGrades { pub fn new() -> Self { Self { students: HashMap::new(), } } // 3. Implement the methods pub fn add_student(&mut self, name: &str) { // Implement here let name = name.to_string(); self.students.entry(name.clone()).or_insert(Student{name, grades: vec![]}); } pub fn add_grade(&mut self, name: &str, grade: u8) { // Implement here self.students.entry(name.to_string()).and_modify(|student| student.grades.push(grade)); } pub fn get_grades(&self, name: &str) -> &[u8] { // Implement here &self.students.get(name).unwrap().grades }}// Example usagepub 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]}
use std::collections::HashMap;pub struct Student { // 1. Define the fields pub name:String, pub grades:Vec<u8>}pub struct StudentGrades { // 2. Define the fields pub students: HashMap<String, Student> }impl StudentGrades { pub fn new() -> Self { Self { students: HashMap::new(), } } // 3. Implement the methods pub fn add_student(&mut self, name: &str) { // Implement here let name = name.to_string(); self.students.entry(name.clone()).or_insert(Student{name, grades: Vec::new()}); } pub fn add_grade(&mut self, name: &str, grade: u8) { // Implement here self.students.entry(name.to_string()).and_modify(|student| student.grades.push(grade)); } pub fn get_grades(&self, name: &str) -> &[u8] { // Implement here &self.students.get(name).unwrap().grades }}// Example usagepub 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]}
use std::collections::HashMap;pub struct Student { // 1. Define the fields pub name:String, pub grades:Vec<u8>}pub struct StudentGrades { // 2. Define the fields pub students: HashMap<String, Student> }impl StudentGrades { pub fn new() -> Self { Self { students: HashMap::new(), } } // 3. Implement the methods pub fn add_student(&mut self, name: &str) { // Implement here self.students.entry(name.to_string()).or_insert(Student{name:name.to_string(), grades:Vec::new()}); } pub fn add_grade(&mut self, name: &str, grade: u8) { // Implement here self.students.entry(name.to_string()).and_modify(|student| student.grades.push(grade)); } pub fn get_grades(&self, name: &str) -> &[u8] { // Implement here &self.students.get(name).unwrap().grades }}// Example usagepub 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]}
use std::collections::HashMap;pub struct Student { // 1. Define the fields pub name: String, pub grades: Vec<u8>,}pub struct StudentGrades { // 2. Define the fields pub students: HashMap<String, Student>,}impl StudentGrades { pub fn new() -> Self { Self { students: HashMap::new(), } } // 3. Implement the methods pub fn add_student(&mut self, name: &str) { self.students.insert(name.to_string(), Student { name: name.to_string(), grades: vec![]}); } pub fn add_grade(&mut self, name: &str, grade: u8) { let student = self.students.get_mut(name).unwrap(); student.grades.push(grade); } pub fn get_grades(&self, name: &str) -> &[u8] { &self.students.get(name).unwrap().grades }}// Example usagepub 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]}
use std::collections::HashMap;pub struct Student { pub name: String, pub grades: Vec<u8>,}pub struct StudentGrades { pub students: HashMap<String, Student>,}impl StudentGrades { pub fn new() -> Self { Self { students: HashMap::new(), } } // 3. Implement the methods pub fn add_student(&mut self, name: &str) { self.students .entry(name.to_string()) .or_insert(Student { name: name.to_string(), grades: Vec::new(), }); } pub fn add_grade(&mut self, name: &str, grade: u8) { self.students.entry(name.to_string()).and_modify(|student| student.grades.push(grade)); } pub fn get_grades(&self, name: &str) -> &[u8] { if let Some(student) = self.students.get(name) { student.grades.as_slice() } else { &[] } }}// Example usagepub 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]}
use std::collections::HashMap;pub struct Student { name: String, grades: Vec<u8>,}#[derive(Default)]pub struct StudentGrades { pub students: HashMap<String, Student>,}impl StudentGrades { pub fn new() -> Self { StudentGrades::default() } pub fn add_student(&mut self, name: &str) { self.students.insert( name.to_string(), Student { name: name.to_string(), grades: Vec::new(), }, ); } pub fn add_grade(&mut self, name: &str, grade: u8) { if let Some(student) = self.students.get_mut(name) { student.grades.push(grade); } } pub fn get_grades(&self, name: &str) -> &[u8] { if let Some(student) = self.students.get(name) { &student.grades } else { &[] } }}
use std::collections::HashMap;pub struct Student { // 1. Define the fields name: String, grades: Vec<u8>,}pub struct StudentGrades { // 2. Define the fields pub students: HashMap<String,Student>,}impl Student { pub fn new(name: &str) -> Self { Self { name: name.to_string(), grades: Vec::<u8>::new(), } }}impl StudentGrades { pub fn new() -> Self { Self { students: HashMap::new(), } } // 3. Implement the methods pub fn add_student(&mut self, name: &str) { // Implement here self.students.entry(name.to_string()).or_insert(Student::new(name)); } pub fn add_grade(&mut self, name: &str, grade: u8) { // Implement here self.students.get_mut(name).unwrap().grades.push(grade); } pub fn get_grades(&self, name: &str) -> &[u8] { // Implement here &self.students.get(name).unwrap().grades }}// Example usagepub 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]}
use std::collections::HashMap;pub struct Student { name: String, pub grades: Vec<u8>,}pub struct StudentGrades { pub students: HashMap<String, Student>,}impl StudentGrades { pub fn new() -> Self { Self { students: HashMap::new(), } } pub fn add_student(&mut self, name: &str) { if !self.students.contains_key(name) { self.students.insert( name.to_string(), Student { name: name.to_string(), grades: Vec::new(), }, ); } } pub fn add_grade(&mut self, name: &str, grade: u8) { if self.students.contains_key(name) { self.students .entry(name.to_string()) .and_modify(|v| v.grades.push(grade)); } } pub fn get_grades(&self, name: &str) -> &[u8] { &self.students.get(name).unwrap().grades }}// Example usagepub 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]}
use std::collections::HashMap;pub struct Student { pub name: String, pub grades: Vec<u8>}pub struct StudentGrades { pub students: HashMap<String, Student>}impl StudentGrades { pub fn new() -> Self { Self { students: HashMap::new(), } } // 3. Implement the methods pub fn add_student(&mut self, name: &str) { let name = name.to_string(); self.students.entry(name.clone()).or_insert_with(|| Student { name, grades: Vec::new() }); } pub fn add_grade(&mut self, name: &str, grade: u8) { self.students.get_mut(name).unwrap().grades.push(grade); } pub fn get_grades(&self, name: &str) -> &[u8] { &self.students.get(name).unwrap().grades }}// Example usagepub 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]}
use std::collections::HashMap;pub struct Student { // 1. Define the fields pub name : String, pub grades: Vec<u8>,}pub struct StudentGrades { // 2. Define the fields pub students : HashMap<String, Vec<u8>>}impl StudentGrades { pub fn new() -> Self { Self { students: HashMap::new(), } } // 3. Implement the methods pub fn add_student(&mut self, name: &str) { self.students.insert(name.to_string(),vec![]); } pub fn add_grade(&mut self, name: &str, grade: u8) { // Implement here if let Some(grades) = self.students.get_mut(name) { grades.push(grade); } } pub fn get_grades(&self, name: &str) -> &[u8] { // Implement here if let Some(grades) = self.students.get(name) { grades } else { &[] } }}// Example usagepub 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]}
use std::collections::HashMap;pub struct Student { // 1. Define the fields name: String, grades: Vec<u8>,}pub struct StudentGrades { // 2. Define the fields pub students: HashMap<String, Student>,}impl StudentGrades { pub fn new() -> Self { Self { students: HashMap::new(), } } // 3. Implement the methods pub fn add_student(&mut self, name: &str) { self.students.insert( name.to_string(), Student { name: name.to_string(), grades: Vec::new(), }, ); } pub fn add_grade(&mut self, name: &str, grade: u8) { if let Some(student) = self.students.get_mut(name) { student.grades.push(grade); } } pub fn get_grades(&self, name: &str) -> &[u8] { match self.students.get(name) { None => &[], Some(student) => student.grades.as_slice(), } }}// Example usagepub 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]}
use std::collections::HashMap;pub struct Student { // 1. Define the fields name: String, grades: Vec<u8>,}pub struct StudentGrades { // 2. Define the fields pub students: HashMap<String, Student>,}impl StudentGrades { pub fn new() -> Self { Self { students: HashMap::new(), } } // 3. Implement the methods pub fn add_student(&mut self, name: &str) { // Implement here if !self.students.contains_key(name) { self.students.insert( name.to_string(), Student { name: name.to_string(), grades: Vec::new(), }, ); } } pub fn add_grade(&mut self, name: &str, grade: u8) { // Implement here if let Some(student) = self.students.get_mut(name) { student.grades.push(grade); } } pub fn get_grades(&self, name: &str) -> &[u8] { // Implement here self.students .get(name) .map(|student| student.grades.as_slice()) .unwrap_or(&[]) }}// Example usagepub 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]}
use std::collections::HashMap;pub struct Student { // 1. Define the fields name: String, grades: Vec<u8>,}pub struct StudentGrades { // 2. Define the fields pub students: HashMap<String, Student>,}impl StudentGrades { pub fn new() -> Self { Self { students: HashMap::new(), } } // 3. Implement the methods pub fn add_student(&mut self, name: &str) { // Implement here if !self.students.contains_key(name) { self.students.insert( name.to_string(), Student { name: name.to_string(), grades: Vec::new(), }, ); } } pub fn add_grade(&mut self, name: &str, grade: u8) { // Implement here if let Some(student) = self.students.get_mut(name) { student.grades.push(grade); } } pub fn get_grades(&self, name: &str) -> &[u8] { // Implement here self.students .get(name) .map(|student| student.grades.as_slice()) .unwrap_or(&[]) }}// Example usagepub 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]}
use std::{collections::HashMap, hash::Hash};#[derive(Debug, PartialEq, Eq, Hash)]pub struct Student { // 1. Define the fields pub name: String, pub grades: Vec<u8>,}pub struct StudentGrades { // 2. Define the fields pub students: HashMap<String, Student>,}impl StudentGrades { pub fn new() -> Self { Self { students: HashMap::new(), } } // 3. Implement the methods pub fn add_student(&mut self, name: &str) { // Implement here self.students.insert(name.to_string(), Student { name: name.to_string(), grades: Vec::new() }); } pub fn add_grade(&mut self, name: &str, grade: u8) { if let Some(student) = self.students.get_mut(&name.to_string()) { student.grades.push(grade); } } pub fn get_grades(&self, name: &str) -> &[u8] { // Implement here if let Some(student) = self.students.get(&name.to_string()) { return student.grades.as_ref(); } else { return &[]; } }}// Example usagepub 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]}
use std::collections::HashMap;pub struct Student { // 1. Define the fields pub name: String, pub grades: Vec<u8>,}pub struct StudentGrades { // 2. Define the fields pub students: HashMap<String, Vec<u8>>}impl StudentGrades { pub fn new() -> Self { Self { students: HashMap::new(), } } // 3. Implement the methods pub fn add_student(&mut self, name: &str) { // Implement here self.students.insert(name.to_string(),vec![]); } pub fn add_grade(&mut self, name: &str, grade: u8) { // Implement here if let Some(grades) = self.students.get_mut(name) { grades.push(grade); } } pub fn get_grades(&self, name: &str) -> &[u8] { // Implement here if let Some(grades) = self.students.get(name) { grades } else { &[] } }}// Example usagepub 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]}
use std::collections::HashMap;pub struct Student { // 1. Define the fields pub name: String, pub grades: Vec<u8>,}pub struct StudentGrades { // 2. Define the fields pub students: HashMap<String, Student>,}impl StudentGrades { pub fn new() -> Self { Self { students: HashMap::new(), } } // 3. Implement the methods pub fn add_student(&mut self, name: &str) { // Implement here self.students.entry(name.to_string()) .or_insert( Student { name: name.to_string(), grades: vec![], } ); } pub fn add_grade(&mut self, name: &str, grade: u8) { // Implement here let stud = self.students.get_mut(name); match stud { Some(&mut ref mut student) => student.grades.push(grade), None => {}, }; } pub fn get_grades(&self, name: &str) -> &[u8] { // Implement here &self.students.get(name).unwrap().grades }}// Example usagepub 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]}
use std::collections::HashMap;pub struct Student { // 1. Define the fields pub name: String, pub grades: Vec<u8>,}pub struct StudentGrades { // 2. Define the fields pub students: HashMap<String, Student>,}impl StudentGrades { pub fn new() -> Self { Self { students: HashMap::new(), } } // 3. Implement the methods pub fn add_student(&mut self, name: &str) { // Implement here self.students.insert(name.into(), Student { name: name.into(), grades: vec![] }); } pub fn add_grade(&mut self, name: &str, grade: u8) { // Implement here self.students.get_mut(name.into()).unwrap().grades.push(grade); } pub fn get_grades(&self, name: &str) -> &[u8] { // Implement here self.students.get(name.into()).unwrap().grades.as_slice() }}// Example usagepub 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]}
use std::collections::HashMap;pub struct Student { // 1. Define the fields name: String, grades: Vec<u8>,}pub struct StudentGrades { // 2. Define the fields pub students: HashMap<String, Student>,}impl StudentGrades { pub fn new() -> Self { Self { students: HashMap::new(), } } // 3. Implement the methods pub fn add_student(&mut self, name: &str) { // Implement here if !self.students.contains_key(name) { self.students.insert(name.to_string(), Student{ name: name.to_string(), grades: vec![] }); } } pub fn add_grade(&mut self, name: &str, grade: u8) { // Implement here if let Some(student) = self.students.get_mut(name) { student.grades.push(grade); } } pub fn get_grades(&self, name: &str) -> &[u8] { // Implement here self.students.get(name).unwrap().grades.as_slice() }}// Example usagepub 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]}
use std::collections::HashMap;pub struct Student { // 1. Define the fields name: String, grades: Vec<u8>}pub struct StudentGrades { // 2. Define the fields pub students: HashMap<String, Student>,}impl StudentGrades { pub fn new() -> Self { Self { students: HashMap::new(), } } // 3. Implement the methods pub fn add_student(&mut self, name: &str) { // Implement here self.students.entry(name.to_string()).or_insert(Student{name: name.to_string(), grades: vec![]}); } pub fn add_grade(&mut self, name: &str, grade: u8) { // Implement here if let Some(student) = self.students.get_mut(name) { student.grades.push(grade); } } pub fn get_grades(&self, name: &str) -> &[u8] { // Implement here if let Some(student) = self.students.get(name) { &student.grades[..] } else { &[] } }}// Example usagepub 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]}
use std::collections::HashMap;pub struct Student { pub name: String, pub grades: Vec<u8>}pub struct StudentGrades { pub students: HashMap<String, Student>}impl StudentGrades { pub fn new() -> Self { Self { students: HashMap::new(), } } pub fn add_student(&mut self, name: &str) { self.students.entry(name.to_string()).or_insert(Student { name: name.to_string(), grades: vec![] }); } pub fn add_grade(&mut self, name: &str, grade: u8) { if let Some(student) = self.students.get_mut(name) { student.grades.push(grade); } } pub fn get_grades(&self, name: &str) -> &[u8] { return &self.students.get(name).unwrap().grades; }}// Example usagepub 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]}
use std::collections::HashMap;pub struct Student { pub name: String, pub grades: Vec<u8>,}pub struct StudentGrades { pub students: HashMap<String, Student>,}impl StudentGrades { pub fn new() -> Self { Self { students: HashMap::new(), } } // 3. Implement the methods pub fn add_student(&mut self, name: &str) { self.students.insert(name.to_string(), Student{name: name.to_string(), grades:Vec::new()}); } pub fn add_grade(&mut self, name: &str, grade: u8) { self.students.get_mut(name).unwrap().grades.push(grade); } pub fn get_grades(&self, name: &str) -> &[u8] { self.students.get(name).unwrap().grades.as_slice() }}// Example usagepub 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]}
use std::collections::HashMap;pub struct Student { name: String, grades: Vec<u8>,}pub struct StudentGrades { pub students: HashMap<String, Student>,}impl StudentGrades { pub fn new() -> Self { Self { students: HashMap::new(), } } pub fn add_student(&mut self, name: &str) { 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) { let _ = self.students .entry(name.to_string()) .and_modify(|s| s.grades.push(grade)); } pub fn get_grades(&self, name: &str) -> &[u8] { let student = self.students.get(name).unwrap(); return &student.grades; }}// Example usagepub 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]}
use std::collections::HashMap;pub struct Student { // 1. Define the fields pub name: String, pub grades: Vec<u8>,}pub struct StudentGrades { // 2. Define the fields pub students: HashMap<String, Student>,}impl StudentGrades { pub fn new() -> Self { Self { students: HashMap::new(), } } // 3. Implement the methods pub fn add_student(&mut self, name: &str) { // Implement here let init_vec = vec![]; self.students.insert( name.to_string(), Student { name: name.to_string(), grades: init_vec } ); } pub fn add_grade(&mut self, name: &str, grade: u8) { // Implement here let init_vec = vec![]; let student_grades = self.students.entry(name.to_string()).or_insert(Student { name: name.to_string(), grades: init_vec }); student_grades.grades.push(grade) } pub fn get_grades(&self, name: &str) -> &[u8] { // Implement here &self.students.get(name).unwrap().grades }}// Example usagepub 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]}
use std::collections::HashMap;pub struct Student { pub name: String, pub grades: Vec<u8>,}pub struct StudentGrades { pub students: HashMap<String, Student>,}impl StudentGrades { pub fn new() -> Self { Self { students: HashMap::new(), } } pub fn add_student(&mut self, name: &str) { if !self.students.contains_key(name) { self.students.insert(name.to_string(), Student{name: name.to_string(), grades: vec![]}); } } pub fn add_grade(&mut self, name: &str, grade: u8) { if let Some(student) = self.students.get_mut(name) { student.grades.push(grade); } } pub fn get_grades(&self, name: &str) -> &[u8] { &self.students.get(name).unwrap().grades }}// Example usagepub 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]}
use std::collections::HashMap;pub struct Student { pub name: String, pub grades: Vec<u8>,}pub struct StudentGrades { pub students: HashMap<String, Student>,}impl StudentGrades { pub fn new() -> Self { Self { students: HashMap::new(), } } // 3. Implement the methods pub fn add_student(&mut self, name: &str) { self .students .entry(name.to_string()) .or_insert(Student{name: name.to_string(), grades: Vec::new()}); } pub fn add_grade(&mut self, name: &str, grade: u8) { self .students .entry(name.to_string()) .or_insert( Student{name: name.to_string(), grades: Vec::new()} ) .grades .push(grade); } pub fn get_grades(&self, name: &str) -> &[u8] { &self .students .get(name) .unwrap() .grades }}// Example usagepub 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]}
use std::collections::HashMap;pub struct Student { pub name: String, pub grades: Vec<u8>,}pub struct StudentGrades { pub students: HashMap<String, Student>,}impl StudentGrades { pub fn new() -> Self { Self { students: HashMap::new(), } } pub fn add_student(&mut self, name: &str) { if !self.students.contains_key(name) { self.students.insert(name.to_string(), Student{name: name.to_string(), grades: vec![]}); } } pub fn add_grade(&mut self, name: &str, grade: u8) { if let Some(student) = self.students.get_mut(name) { student.grades.push(grade); } } pub fn get_grades(&self, name: &str) -> &[u8] { &self.students.get(name).unwrap().grades }}// Example usagepub 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]}
use std::collections::HashMap;pub struct Student { // 1. Define the fields pub name: String, pub grades: Vec<u8>,}pub struct StudentGrades { // 2. Define the fields pub students: HashMap<String, Student>,}impl StudentGrades { pub fn new() -> Self { Self { students: HashMap::new(), } } // 3. Implement the methods pub fn add_student(&mut self, name: &str) { // Implement here if self.students.contains_key(name) { return; } self.students.insert( name.to_string(), Student { name: name.to_string(), grades: vec![], }, ); } pub fn add_grade(&mut self, name: &str, grade: u8) { // Implement here self.students.entry(name.to_string()).and_modify(|v| { v.grades.push(grade); }); } pub fn get_grades(&self, name: &str) -> &[u8] { // Implement here &self.students.get(name).unwrap().grades }}// Example usagepub 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]}
use std::collections::HashMap;pub struct Student { // 1. Define the fields pub name: String, pub grades: Vec<u8>}pub struct StudentGrades { // 2. Define the fields pub students: HashMap<String, Student>}impl StudentGrades { pub fn new() -> Self { Self { students: HashMap::new(), } } // 3. Implement the methods pub fn add_student(&mut self, name: &str) { // Implement here self.students.insert(name.to_string(),Student {name: name.to_string(), grades: Vec::new()}); }// self.students.insert(name.to_string(), Student { name: name.to_string(), grades: Vec::new()}); pub fn add_grade(&mut self, name: &str, grade: u8) { // Implement here// let student_grades = self.students.entry(name.to_string()).or_insert(Student { name: name.to_string(), grades: Vec::new() });let student_grades = self.students.entry(name.to_string()).or_insert(Student {name: name.to_string(), grades: Vec::new()});student_grades.grades.push(grade) } pub fn get_grades(&self, name: &str) -> &[u8] { // Implement here &self.students.get(name).unwrap().grades }}// Example usagepub 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]}// impl StudentGrades {// pub fn new() -> Self {// Self {// students: HashMap::new(),// }// }// // 3. Implement the methods// pub fn add_student(&mut self, name: &str) {// // Implement here// self.students.insert(name.to_string(), Student { name: name.to_string(), grades: Vec::new()});// }// pub fn add_grade(&mut self, name: &str, grade: u8) {// // Implement here// let student_grades = self.students.entry(name.to_string()).or_insert(Student { name: name.to_string(), grades: Vec::new() });// student_grades.grades.push(grade);// }// pub fn get_grades(&self, name: &str) -> &[u8] {// // Implement here// &self.students.get(name).unwrap().grades// }// }
use std::collections::HashMap;#[derive(Debug, Clone)]pub struct Student { pub name: String, pub grades: Vec<u8>,}#[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) { let student = Student { name: name.to_string(), grades: Vec::<u8>::new(), }; self.students.insert(name.to_string(), student); } pub fn add_grade(&mut self, name: &str, grade: u8) { let mut student: Student = self.students.get(name).unwrap().clone(); student.grades.push(grade); self.students.insert(name.to_string(), student); } pub fn get_grades(&self, name: &str) -> &[u8] { &self.students.get(name).unwrap().grades }}// Example usagepub 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]}
use std::collections::HashMap;pub struct Student { // 1. Define the fields pub name: String, pub grades: Vec<u8>,}pub struct StudentGrades { // 2. Define the fields pub students: HashMap<String, Student>}impl Student { fn new(name: &str) -> Self { Self { name: name.to_string(), grades: Vec::new(), } }}impl StudentGrades { pub fn new() -> Self { Self { students: HashMap::new(), } } // 3. Implement the methods pub fn add_student(&mut self, name: &str) { self.students.insert(name.to_string(), Student::new(name)); } pub fn add_grade(&mut self, name: &str, grade: u8) { if let Some(grades) = self.students.get_mut(name) { grades.grades.push(grade) } } pub fn get_grades(&self, name: &str) -> &[u8] { &self.students.get(name).unwrap().grades }}// Example usagepub 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]}
use std::collections::HashMap;pub struct Student { // 1. Define the fields pub name: String, pub grades: Vec<u8>,}pub struct StudentGrades { // 2. Define the fields pub students: HashMap<String, Student>,}impl StudentGrades { pub fn new() -> Self { Self { students: HashMap::new(), } } // 3. Implement the methods pub fn add_student(&mut self, name: &str) { // Implement here self.students.insert(name.to_string(), Student { name: name.to_string(), grades: Vec::new()}); } pub fn add_grade(&mut self, name: &str, grade: u8) { // Implement here let student_grades = self.students.entry(name.to_string()).or_insert(Student { name: name.to_string(), grades: Vec::new() }); student_grades.grades.push(grade); } pub fn get_grades(&self, name: &str) -> &[u8] { // Implement here &self.students.get(name).unwrap().grades }}// Example usagepub 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]}
use std::collections::HashMap;pub struct Student { // 1. Define the fields pub name: String, pub grades: Vec<u8>,}pub struct StudentGrades { // 2. Define the fields pub students: HashMap<String, Student>,}impl StudentGrades { pub fn new() -> Self { Self { students: HashMap::new(), } } // 3. Implement the methods pub fn add_student(&mut self, name: &str) { // Implement here self.students.insert(name.to_string(), Student { name: name.to_string(), grades: Vec::new()}); } pub fn add_grade(&mut self, name: &str, grade: u8) { // Implement here let student_grades = self.students.entry(name.to_string()).or_insert(Student { name: name.to_string(), grades: Vec::new() }); student_grades.grades.push(grade); } pub fn get_grades(&self, name: &str) -> &[u8] { // Implement here &self.students.get(name).unwrap().grades }}// Example usagepub 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]}
use std::collections::HashMap;pub struct Student { pub name: String, pub grades: Vec<u8>, }pub struct StudentGrades { pub students: HashMap<String, Student>}impl StudentGrades { pub fn new() -> Self { Self { students: HashMap::new(), } } pub fn add_student(&mut self, name: &str) { self.students.insert(name.to_string(), Student { name: name.to_string() , grades: Vec::new(), }); } pub fn add_grade(&mut self, name: &str, grade: u8) { //get the previous vector of grades let mut grades = self.students.get(name).unwrap().grades.clone(); //update grades grades.push(grade); self.students.insert(name.to_string(), Student { name: name.to_string(), grades, }); } pub fn get_grades(&self, name: &str) -> &[u8] { &self.students.get(name).unwrap().grades }}// Example usagepub 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]}
use std::collections::HashMap;pub struct Student { // 1. Define the fields pub name: String, pub grades: Vec<u8>,}impl Student { pub fn new(name: &str) -> Self { Self { name: name.to_string(), grades: vec![] } }}pub struct StudentGrades { // 2. Define the fields pub students: HashMap<String, Student>}impl StudentGrades { pub fn new() -> Self { Self { students: HashMap::new(), } } // 3. Implement the methods pub fn add_student(&mut self, name: &str) { // Implement here self.students.entry(name.to_string()).or_insert(Student::new(name)); } pub fn add_grade(&mut self, name: &str, grade: u8) { // Implement here self.students.entry(name.to_string()).and_modify(|student| student.grades.push(grade)); } pub fn get_grades(&self, name: &str) -> &[u8] { // Implement here if let Some(student) = self.students.get(name) { return &student.grades[..]; } &[] }}// Example usagepub 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]}
use std::collections::HashMap;pub struct Student { // 1. Define the fields name: String, grades: Vec<u8>,}pub struct StudentGrades { // 2. Define the fields pub students : HashMap<String, Student> }impl StudentGrades { pub fn new() -> Self { Self { students: HashMap::new(), } } // 3. Implement the methods pub fn add_student(&mut self, name: &str) { // Implement here self.students.insert(name.to_string(), Student {name: name.to_string(), grades: vec![]}); } pub fn add_grade(&mut self, name: &str, grade: u8) { // Implement here match self.students.get_mut(name) { Some(student) => { student.grades.push(grade); }, _ => {} } } pub fn get_grades(&self, name: &str) -> &[u8] { // Implement here &self.students.get(name).unwrap().grades }}// Example usagepub 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]}
use std::collections::HashMap;pub struct Student { // 1. Define the fields name: String, grades: Vec<u8>}pub struct StudentGrades { // 2. Define the fields pub students: HashMap<String, Student>}impl StudentGrades { pub fn new() -> Self { Self { students: HashMap::new(), } } // 3. Implement the methods pub fn add_student(&mut self, name: &str) { // Implement here match self.students.get(name) { None => { let grades: Vec<u8> = Vec::new(); self.students.insert(name.to_string(), Student{name: name.to_string(), grades: grades}); }, _ => {} } } pub fn add_grade(&mut self, name: &str, grade: u8) { // Implement here match self.students.get_mut(name) { Some(student) => { student.grades.push(grade); }, _ => {} } } pub fn get_grades(&self, name: &str) -> &[u8] { // Implement here &self.students.get(name).unwrap().grades }}// Example usagepub 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]}
use std::collections::HashMap;pub struct Student { name: String, grades: Vec<u8>}pub struct StudentGrades { pub students: HashMap<String, Student>}impl StudentGrades { pub fn new() -> Self { Self { students: HashMap::new(), } } // 3. Implement the methods pub fn add_student(&mut self, name: &str) { self.students.insert(name.to_string(), Student {name: name.to_string(), grades: vec![]}); } pub fn add_grade(&mut self, name: &str, grade: u8) { self.students.get_mut(name).unwrap().grades.push(grade); } pub fn get_grades(&self, name: &str) -> &[u8] { &self.students.get(name).unwrap().grades }}// Example usagepub 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]}