Day 5: Parsing naughty-list.csv

The elves stared at their screens. They had just written the Kid struct and were testing it with Santa’s data.

But something was wrong with the data, Prancer leaned back, smirking. "We forgot something obvious, didn’t we? The data’s raw strings—we need to parse it first."

Alice,10,2
Bob,5,5
Charlie,1,9

"We need to create another function," Prancer continued. "to parse the CSV rows into Kid structs."

Blitzen slammed his mug down. "And since Santa put me in charge of this project, I’m naming the function. It’s going to be called parse_row."

An elf from the back muttered just loud enough to hear, "Ugh, he thinks he’s better than us because Santa made him lead."

Blitzen shot them a look. "I heard that. If you’ve got a better name, I’m listening."

Silence.

"Exactly. parse_row it is."

The Frustration

Blitzen paced. "We need a function that takes a CSV row, splits it, and converts it into a Kid. Name is easy—it stays a String. The good and bad deeds, though, need to be parsed to u32."

"But what if the row has garbage data?" asked an elf, holding up a note with Charlie,,9 scribbled on it.

Prancer rolled his eyes. "Obviously, we handle errors. No .unwrap() shortcuts."

The Task

Blitzen wants you to create an associated function for the Kid struct and name it parse_row. It should take a CSV row as a &str and return a Result<Kid, &'static str>. The function should:

Split the CSV row into parts.
Extract the name as a String.
Parse the second and third fields as u32 for good and bad deeds.
Finally create a Kid struct using the new() associated function we created earlier.

Hints

If you're stuck, here are some hints to help guide you:

Click to show hints

Split the Row Use split(',') to divide the CSV row into parts. let fields = row.split(',');
Get Next Field Get the next field with next(), it's going to return an Option<&str>.
Must be mutable The next() method requires a mutable reference to the iterator. So make it mutable, let mut fields = row.split(',');.
Transform Option to Result Use ok_or(&str) to convert the Option to a Result. e.g., fields.next().ok_or("Missing field").
Propagate Errors (optional) Use ? to propagate errors. e.g., fields.next().ok_or("Missing field")?.
Create a String After you get access to the &str use the to_string() method to make it a String and have Ownership.
Parse Numbers Parse the second and third fields as u32 for good and bad deeds. Use .parse(), you can either turbofish parse::<u32>() or assign a type to the variable let good_deeds: u32 = fields.next().ok_or("Missing field")?.parse();.
Map the Error The error from the parse() method can't be propagated directly, you need to map it to the return types error type &'static str using map_err(). e.g., fields.next().ok_or("Missing field")?.parse().map_err(|_| "Invalid good deeds")?.
Create the Kid Pass the extracted values to Kid::new to build the Kid struct.
Return a Result Use Ok for success and meaningful error messages (like "Invalid good deeds") for failures.

Editor not available on Mobile!

In order to solve the challenge, please visit this page on a desktop computer.

Solutions

Andrea Zoleo

andrea-zoleo

a day ago

3.88ms

89.24kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn parse_row(csv_row: &str) -> Result<Kid, &'static str> {
        // 🎁 Transform the CSV row into a Kid struct for Santa's list!
        // 🎅 Expected CSV: "Name,GoodDeeds,BadDeeds"
        //    Example: "Alice,3,1" -> name: "Alice", good_deeds: 3, bad_deeds: 1
        // 🎁 Your code here! 🎁
        let mut fields = csv_row.split(',');
        let name = fields.next().ok_or("Missing Field")?.to_string();
        let good_deeds = fields.next().ok_or("Missing Field")?.parse::<u32>().map_err(|_| "Invalid good deeds")?;
        let bad_deeds = fields.next().ok_or("Missing Field")?.parse::<u32>().map_err(|_| "Invalid bad deeds")?;
        Ok(Self::new(name, good_deeds, bad_deeds))
    }
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Self {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Self { name, niceness }
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}

jovanoviccn

a day ago

3.59ms

90.44kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn parse_row(csv_row: &str) -> Result<Kid, &'static str> {
        // 🎁 Transform the CSV row into a Kid struct for Santa's list!
        // 🎅 Expected CSV: "Name,GoodDeeds,BadDeeds"
        //    Example: "Alice,3,1" -> name: "Alice", good_deeds: 3, bad_deeds: 1
        // 🎁 Your code here! 🎁
        let fields:Vec<&str>=csv_row.split(',').into_iter().collect();
        if fields.len()<3 {
            return Err("Wrong input")
        }
        let name=fields[0];
        let good_deeds=match fields[1].trim().parse() {
            Ok(num)=>num,
            Err(e)=> return Err("cant be parsed correctly"),
        };
        let bad_deeds=match fields[2].trim().parse() {
            Ok(num)=>num,
            Err(e)=> return Err("cant be parsed correctly"),
        };
        Ok(Self::new(format!("{name}"), good_deeds, bad_deeds))
    }
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Self {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Self { name, niceness }
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}

Fabricio Arend Torres

FabricioArendTorres

2 days ago

3.90ms

90.44kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn parse_row(csv_row: &str) -> Result<Kid, &'static str> {
        // 🎁 Transform the CSV row into a Kid struct for Santa's list!
        // 🎅 Expected CSV: "Name,GoodDeeds,BadDeeds"
        //    Example: "Alice,3,1" -> name: "Alice", good_deeds: 3, bad_deeds: 1
        // 🎁 Your code here! 🎁
        let split_row = csv_row.split(',').collect::<Vec<_>>();
        if split_row.len() != 3 {
            return Err("Invalid Length of Row")
        }
        let name = split_row[0].to_string();
        let good_deeds : u32 = split_row[1].parse().map_err(|_| "invalid number")?;
        let bad_deeds : u32 = split_row[2].parse().map_err(|_| "invalid number")?;
        Ok(Self::new(name, good_deeds, bad_deeds))
    }
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Self {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Self { name, niceness }
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}

kogernik

3 days ago

4.52ms

89.24kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn parse_row(csv_row: &str) -> Result<Kid, &'static str> {
        // 🎁 Transform the CSV row into a Kid struct for Santa's list!
        // 🎅 Expected CSV: "Name,GoodDeeds,BadDeeds"
        //    Example: "Alice,3,1" -> name: "Alice", good_deeds: 3, bad_deeds: 1
        // 🎁 Your code here! 🎁
        let mut splitted = csv_row.split(',');
        let name = splitted.next().ok_or("EOF too soon")?.to_string();
        let good_deeds = splitted
            .next()
            .ok_or("EOF too soon")?
            .parse::<u32>()
            .map_err(|_| "good deeds is not correctly passed")?;
        let bad_deeds = splitted
            .next()
            .ok_or("EOF too soon")?
            .parse::<u32>()
            .map_err(|_| "bad deeds is not correctly passed")?;
        Ok(Self::new(name, good_deeds, bad_deeds))
    }
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Self {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Self { name, niceness }
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}

Prashant Puri

Prashant-dot1

9 days ago

4.46ms

90.44kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn parse_row(csv_row: &str) -> Result<Kid, &'static str> {
        // 🎁 Transform the CSV row into a Kid struct for Santa's list!
        // 🎅 Expected CSV: "Name,GoodDeeds,BadDeeds"
        //    Example: "Alice,3,1" -> name: "Alice", good_deeds: 3, bad_deeds: 1
        // 🎁 Your code here! 🎁
        let parts : Vec<&str>= csv_row.split(',').collect();
        if parts.len() != 3 {
            return Err("Invalid CSV format: expected 3 parts.");
        }
        let name = parts[0].to_string();
        let good_deeds = parts[1].parse::<u32>().map_err(|e| {
            "good deeds is not correctly passed"
        })?;
        let bad_deeds = parts[2].parse::<u32>().map_err(|e| {
            "bad deeds is not correctly passed"
        })?;
        Ok(Self::new(name, good_deeds, bad_deeds))
    }
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Self {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Self { name, niceness }
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}

Heino Mortensen

hmortensen83

12 days ago

4.28ms

90.44kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn parse_row(csv_row: &str) -> Result<Kid, &'static str> {
        // 🎁 Transform the CSV row into a Kid struct for Santa's list!
        // 🎅 Expected CSV: "Name,GoodDeeds,BadDeeds"
        //    Example: "Alice,3,1" -> name: "Alice", good_deeds: 3, bad_deeds: 1
        // 🎁 Your code here! 🎁
        let parts: Vec<_> = csv_row.split(',').collect();
        if parts.len() != 3 {
            return Err("Incorrect length");
        }
        let name = parts[0].to_string();
        let good_deeds = parts[1].parse().map_err(|_| "Parse error")?;
        let bad_deeds = parts[2].parse().map_err(|_| "Parse error")?;
        Ok(Self::new(name, good_deeds, bad_deeds))
    }
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Self {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Self { name, niceness }
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}

Ranjith Thangavel

RanjithECE24

14 days ago

3.78ms

89.29kb

use core::num::ParseIntError;
pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn parse_row(csv_row: &str) -> Result<Kid, &'static str> {
        // 🎁 Transform the CSV row into a Kid struct for Santa's list!
        // 🎅 Expected CSV: "Name,GoodDeeds,BadDeeds"
        //    Example: "Alice,3,1" -> name: "Alice", good_deeds: 3, bad_deeds: 1
        // 🎁 Your code here! 🎁
        if csv_row.is_empty() {
            return Err("Row is empty");
        }
        let row_split: Vec<&str> = csv_row
            .split(',')
            .collect();
        
        if row_split.len() != 3 {
            return Err("Missing at least a parameter in row");
        }
        let name: &str = row_split[0];
        let good_deeds_value_parse: Result<u32, ParseIntError> = row_split[1]
            .parse();
        if good_deeds_value_parse.is_err() {
            return Err("Failed to parse good_deeds");
        }
        
        let bad_deeds_value_parse: Result<u32, ParseIntError> = row_split[2]
            .parse();
        if bad_deeds_value_parse.is_err() {
            return Err("Failed to parse bad_deeds");
        }
        Ok(Self::new(name.to_string(), good_deeds_value_parse.unwrap(), bad_deeds_value_parse.unwrap()))
    }
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Self {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Self { name, niceness }
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}

Sebastien Vassal

svassal

18 days ago

7.62ms

89.29kb

use std::num::ParseIntError;
pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn parse_row(csv_row: &str) -> Result<Kid, &'static str> {
        if csv_row.is_empty() {
            return Err("Row is empty");
        }
        let row_split: Vec<&str> = csv_row
            .split(',')
            .collect();
        if row_split.len() != 3 {
            return Err("Missing at least a parameter in row");
        }
        let first_name: &str = row_split[0];
        let good_deeds_value_parse: Result<u32, ParseIntError> = row_split[1]
            .parse();
        if good_deeds_value_parse.is_err() {
            return Err("Failed to parse good_deeds");
        }
        let good_deeds_value = good_deeds_value_parse.unwrap();
        
        let bad_deeds_value_parse: Result<u32, ParseIntError> = row_split[2]
            .parse();
        if bad_deeds_value_parse.is_err() {
            return Err("Failed to parse bad_deeds");
        }
        let bad_deeds_value = bad_deeds_value_parse.unwrap();
        Ok(Self::new(first_name.to_string(), good_deeds_value, bad_deeds_value))
    }
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Self {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Self { name, niceness }
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}

Spheniscine

18 days ago

4.14ms

89.24kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn parse_row(csv_row: &str) -> Result<Kid, &'static str> {
        // 🎁 Transform the CSV row into a Kid struct for Santa's list!
        // 🎅 Expected CSV: "Name,GoodDeeds,BadDeeds"
        //    Example: "Alice,3,1" -> name: "Alice", good_deeds: 3, bad_deeds: 1
        // 🎁 Your code here! 🎁
        const ERR_MISSING_VALUE: &str = "missing value";
        const ERR_PARSE_FAILED: &str = "parse failed";
        let mut iter = csv_row.split(",");
        let name = iter.next().ok_or(ERR_MISSING_VALUE)?.to_string();
        let good_deeds: u32 = iter.next().ok_or(ERR_MISSING_VALUE)?.parse().map_err(|_| ERR_PARSE_FAILED)?;
        let bad_deeds: u32 = iter.next().ok_or(ERR_MISSING_VALUE)?.parse().map_err(|_| ERR_PARSE_FAILED)?;
        Ok(Self::new(name, good_deeds, bad_deeds))
    }
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Self {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Self { name, niceness }
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}

Andreas Lundin

andreaslundin47

19 days ago

3.80ms

89.24kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn parse_row(csv_row: &str) -> Result<Kid, &'static str> {
        // 🎁 Transform the CSV row into a Kid struct for Santa's list!
        // 🎅 Expected CSV: "Name,GoodDeeds,BadDeeds"
        //    Example: "Alice,3,1" -> name: "Alice", good_deeds: 3, bad_deeds: 1
        // 🎁 Your code here! 🎁
        let mut fields = csv_row.split(',');
        let name = fields.next().ok_or("Missing field")?.to_string();
        let good_deeds = fields.next().ok_or("Missing field")?.parse::<u32>().map_err(|_| "Missing good")?;
        let bad_deeds = fields.next().ok_or("Missing field")?.parse::<u32>().map_err(|_| "Missing bad")?;
        Ok(Self::new(name, good_deeds, bad_deeds))
    }
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Self {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Self { name, niceness }
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}

visanr

21 days ago

4.14ms

90.44kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn parse_row(csv_row: &str) -> Result<Kid, &'static str> {
        let parts: Vec<&str> = csv_row.split(',').collect();
        if parts.len() != 3 {
            return Err("Invalid row");
        }
        let name: String = parts[0].to_string();
        let good_deeds: u32 = parts[1].parse().map_err(|_| "Invalid good deeds")?;
        let bad_deeds: u32 = parts[2].parse().map_err(|_| "Invalid bad deeds")?;
        // 🎁 Transform the CSV row into a Kid struct for Santa's list!
        // 🎅 Expected CSV: "Name,GoodDeeds,BadDeeds"
        //    Example: "Alice,3,1" -> name: "Alice", good_deeds: 3, bad_deeds: 1
        // 🎁 Your code here! 🎁
        Ok(Self::new(name, good_deeds, bad_deeds))
    }
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Self {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Self { name, niceness }
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}

palcoo42

21 days ago

3.79ms

90.44kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn parse_row(csv_row: &str) -> Result<Kid, &'static str> {
        // 🎁 Transform the CSV row into a Kid struct for Santa's list!
        // 🎅 Expected CSV: "Name,GoodDeeds,BadDeeds"
        //    Example: "Alice,3,1" -> name: "Alice", good_deeds: 3, bad_deeds: 1
        // 🎁 Your code here! 🎁
        let split = csv_row.split_terminator(",").collect::<Vec<_>>();
        if split.len() != 3 {
            return Err("Invalid CSV format, expected three values, found {}");
        }
        let name = split[0].trim().to_string();
        let good_deeds = split[1]
            .trim()
            .parse::<u32>()
            .map_err(|_err| "Failed to parse good deeds")?;
        let bad_deeds = split[2]
            .trim()
            .parse::<u32>()
            .map_err(|_err| "Failed to parse bad deeds")?;
        Ok(Self::new(name, good_deeds, bad_deeds))
    }
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Self {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Self { name, niceness }
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}

angalar

22 days ago

4.12ms

89.24kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn parse_row(csv_row: &str) -> Result<Kid, &'static str> {
        let mut split = csv_row.split(',');
        let name = split.next().ok_or("Zero leng string")?.to_string();
        let good_deeds: u32 = split.next().ok_or("Missing good deeds")?.parse()
                              .map_err(|_| "Invalid number format")?;
        let bad_deeds: u32 = split.next().ok_or("Missing bad deeds")?.parse()
                             .map_err(|_| "Invalid number format")?;  
        Ok(Self::new(name, good_deeds, bad_deeds))
    }
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Self {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Self { name, niceness }
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}

almanaxxx

23 days ago

4.39ms

89.24kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn parse_row(csv_row: &str) -> Result<Kid, &'static str> {
        // 🎁 Transform the CSV row into a Kid struct for Santa's list!
        // 🎅 Expected CSV: "Name,GoodDeeds,BadDeeds"
        //    Example: "Alice,3,1" -> name: "Alice", good_deeds: 3, bad_deeds: 1
        // 🎁 Your code here! 🎁
        let mut fields = csv_row.split(',');
        let name = fields.next().ok_or("string is empty")?.to_string();
        let good_deeds: u32 = fields.next().ok_or("no good deeds")?.parse().map_err(|_| "Invalid good deeds format number")?;
        let bad_deeds: u32 = fields.next().ok_or("no bad deeds")?.parse().map_err(|_| "Invalid bad deeds format number")?;
        Ok(Self::new(name, good_deeds, bad_deeds))
    }
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Self {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Self { name, niceness }
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}

johndoe30bc

23 days ago

3.86ms

89.24kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn parse_row(csv_row: &str) -> Result<Kid, &'static str> {
        let mut it = csv_row.split(',');
        let name = it.next().ok_or("no name")?.to_string();
        let good_deeds = it
            .next()
            .ok_or("no good_deeds")?
            .parse::<u32>()
            .map_err(|_| "wrong type")?;
        let bad_deeds = it
            .next()
            .ok_or("no bad_deeds")?
            .parse::<u32>()
            .map_err(|_| "wrong type")?;
        Ok(Self::new(name, good_deeds, bad_deeds))
    }
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Self {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Self { name, niceness }
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}

Jake S

STIXTheMachine

24 days ago

4.49ms

90.44kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn parse_row(csv_row: &str) -> Result<Kid, &'static str> {
        // 🎁 Transform the CSV row into a Kid struct for Santa's list!
        // 🎅 Expected CSV: "Name,GoodDeeds,BadDeeds"
        //    Example: "Alice,3,1" -> name: "Alice", good_deeds: 3, bad_deeds: 1
        let mut fields = csv_row.split(',');
        let name = fields.next().ok_or("Missing field")?;
        let good_deeds = fields.next().ok_or("Missing field")?.parse::<u32>().map_err(|_| "Invalid good deeds")?;
        let bad_deeds = fields.next().ok_or("Missing field")?.parse::<u32>().map_err(|_| "Invalid bad deeds")?;
        Ok(Self::new(name.to_string(), good_deeds, bad_deeds))
    }
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Self {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Self { name, niceness }
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}

Wouter

WouterMartens

24 days ago

4.14ms

89.24kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn parse_row(csv_row: &str) -> Result<Kid, &'static str> {
        let mut parts = csv_row.split(',');
        
        Ok(Self::new(
            parts.next().ok_or("Missing field")?.to_string(),
            parts.next().ok_or("Missing field")?.parse::<u32>().map_err(|_| "Invalid good deeds")?,
            parts.next().ok_or("Missing field")?.parse::<u32>().map_err(|_| "Invalid bad deeds")?
        ))
    }
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Self {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Self { name, niceness }
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}

Guilherme

GuilhermeGcaires

a month ago

4.33ms

90.44kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn parse_row(csv_row: &str) -> Result<Kid, &'static str> {
        let splited: Vec<&str> = csv_row.split(',').collect();
        
        if splited.len() != 3 {
            return Err("Invalid input format");
        }
        
        let name = splited[0].to_string();
        let good_deeds = splited[1].parse::<u32>().map_err(|_| "Failed to parse")?;
        let bad_deeds = splited[2].parse::<u32>().map_err(|_| "Failed to parse")?;
        Ok(Self::new(name, good_deeds, bad_deeds))
    }
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Self {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Self { name, niceness }
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}

Khant

Khantdotcom

a month ago

4.45ms

89.24kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn parse_row(csv_row: &str) -> Result<Kid, &'static str> {
        // 🎁 Transform the CSV row into a Kid struct for Santa's list!
        // 🎅 Expected CSV: "Name,GoodDeeds,BadDeeds"
        //    Example: "Alice,3,1" -> name: "Alice", good_deeds: 3, bad_deeds: 1
        // 🎁 Your code here! 🎁
        let mut fields = csv_row.split(',');
        let name = fields.next().ok_or("Missing field")?.parse().map_err(|_| "Invalid name")?;
        let good_deeds = fields.next().ok_or("Missing field")?.parse().map_err(|_| "Invalid good deeds")?;
        let bad_deeds = fields.next().ok_or("Missing field")?.parse().map_err(|_| "Invalid bad deeds")?;
        if fields.next().is_some() == true {
            return Err("Too many fields");
        }
        Ok(Self::new(name, good_deeds, bad_deeds))
    }
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Self {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Self { name, niceness }
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}

Youssef Bennour Sahli

youssefbennour

a month ago

4.31ms

89.24kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn parse_row(csv_row: &str) -> Result<Kid, &'static str> {
        // 🎁 Transform the CSV row into a Kid struct for Santa's list!
        // 🎅 Expected CSV: "Name,GoodDeeds,BadDeeds"
        //    Example: "Alice,3,1" -> name: "Alice", good_deeds: 3, bad_deeds: 1
        // 🎁 Your code here! 🎁
        let mut fields= csv_row
            .split(',');
        let name = fields.next()
            .ok_or("Missing field")?
            .to_string();
        let good_deeds: u32 = fields.next()
            .ok_or("Missing field")?
            .parse()
            .map_err(|_| "Invalid good deeds")?;
        let bad_deeds: u32 = fields.next()
            .ok_or("Missing field")?
            .parse()
            .map_err(|_| "Invalid good deeds")?;
        Ok(Self::new(name, good_deeds, bad_deeds))
    }
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Self {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Self { name, niceness }
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}

Roman Dyachuk

Asterrus

a month ago

3.96ms

89.24kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}
#[derive(Debug)]
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn parse_row(csv_row: &str) -> Result<Kid, &'static str> {
        // 🎁 Transform the CSV row into a Kid struct for Santa's list!
        // 🎅 Expected CSV: "Name,GoodDeeds,BadDeeds"
        //    Example: "Alice,3,1" -> name: "Alice", good_deeds: 3, bad_deeds: 1
        // 🎁 Your code here! 🎁
        let mut fields = csv_row.split(',');
        let name = fields.next().ok_or("Missing name")?.to_string();
        let good_deeds = fields
            .next()
            .ok_or("Missing good deeds")?
            .parse::<u32>()
            .map_err(|_| "Invalid good deeds")?;
        let bad_deeds = fields
            .next()
            .ok_or("Missing bad deeds")?
            .parse::<u32>()
            .map_err(|_| "Invalid bad deeds")?;
        Ok(Self::new(name, good_deeds, bad_deeds))
    }
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Self {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Self { name, niceness }
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}

Roman Dyachuk

Asterrus

a month ago

4.23ms

90.44kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}
#[derive(Debug)]
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn parse_row(csv_row: &str) -> Result<Kid, &'static str> {
        // 🎁 Transform the CSV row into a Kid struct for Santa's list!
        // 🎅 Expected CSV: "Name,GoodDeeds,BadDeeds"
        //    Example: "Alice,3,1" -> name: "Alice", good_deeds: 3, bad_deeds: 1
        // 🎁 Your code here! 🎁
        let splitted: Vec<&str> = csv_row.split_terminator(',').collect();
        if splitted.len() != 3 {
            return Err("row must contain name, good_deeds and bad_deeds");
        }
        // let (name, good_deeds, bad_deeds) = splitted;
        let name = splitted[0].to_string();
        if name.len() == 0 {
            return Err("name not provided");
        }
        // let good_deeds: u32 = splitted[1].parse();
        let good_deeds = match splitted[1].parse::<u32>() {
            Ok(v) => v,
            Err(_) => {
                return Err("Incorrect good_deeds");
            }
        };
        // let bad_deeds: u32 = splitted[2].parse();
        let bad_deeds = match splitted[2].parse::<u32>() {
            Ok(v) => v,
            Err(_) => {
                return Err("Incorrect bad_deeds");
            }
        };
        Ok(Self::new(name, good_deeds, bad_deeds))
        // Ok(Self::new(name, good_deeds, bad_deeds))
    }
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Self {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Self { name, niceness }
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}

Icarus-15

a month ago

3.98ms

89.24kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn parse_row(csv_row: &str) -> Result<Kid, &'static str> {
        // 🎁 Transform the CSV row into a Kid struct for Santa's list!
        // 🎅 Expected CSV: "Name,GoodDeeds,BadDeeds"
        //    Example: "Alice,3,1" -> name: "Alice", good_deeds: 3, bad_deeds: 1
        // 🎁 Your code here! 🎁
        let mut fields = csv_row.split(',');
        let name = fields.next().ok_or("Missing name")?.to_string();
        let good_deeds = fields
        .next()
        .ok_or("Missing good deeds")?
        .parse::<u32>()
        .map_err(|_| "Invalid good deeds")?;
        let bad_deeds = fields
        .next()
        .ok_or("Missing bad deeds")?
        .parse::<u32>()
        .map_err(|_| "Invalid bad deeds")?;
        Ok(Self::new(name, good_deeds, bad_deeds))
    }
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Self {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Self { name, niceness }
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}

jcortial

a month ago

4.78ms

90.44kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn parse_row(csv_row: &str) -> Result<Kid, &'static str> {
        // 🎁 Transform the CSV row into a Kid struct for Santa's list!
        // 🎅 Expected CSV: "Name,GoodDeeds,BadDeeds"
        //    Example: "Alice,3,1" -> name: "Alice", good_deeds: 3, bad_deeds: 1
        // 🎁 Your code here! 🎁
        let mut tokens = csv_row.split(',');
        let name = tokens.next().ok_or("")?;
        let good_deeds = tokens.next().ok_or("")?.parse().map_err(|_| "")?;
        let bad_deeds = tokens.next().ok_or("")?.parse().map_err(|_| "")?;
        Ok(Self::new(name.to_owned(), good_deeds, bad_deeds))
    }
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Self {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Self { name, niceness }
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}

kartik adur

kartikadur

a month ago

3.89ms

89.24kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn parse_row(csv_row: &str) -> Result<Kid, &'static str> {
        // 🎁 Transform the CSV row into a Kid struct for Santa's list!
        // 🎅 Expected CSV: "Name,GoodDeeds,BadDeeds"
        //    Example: "Alice,3,1" -> name: "Alice", good_deeds: 3, bad_deeds: 1
        // 🎁 Your code here! 🎁
        let mut fields = csv_row.split(",");
        let name = fields.next().ok_or("Missing Field")?.to_string();
        let good_deeds = fields.next().ok_or("Missing Field")?.parse::<u32>().map_err(|_| "Can't convert to U32")?;
        let bad_deeds = fields.next().ok_or("Missing Field")?.parse::<u32>().map_err(|_| "Can't convert to U32")?;
        Ok(Kid::new(name, good_deeds, bad_deeds))
    }
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Self {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Self { name, niceness }
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}

mooncaker816

a month ago

5.25ms

89.24kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn parse_row(csv_row: &str) -> Result<Kid, &'static str> {
        // 🎁 Transform the CSV row into a Kid struct for Santa's list!
        // 🎅 Expected CSV: "Name,GoodDeeds,BadDeeds"
        //    Example: "Alice,3,1" -> name: "Alice", good_deeds: 3, bad_deeds: 1
        // 🎁 Your code here! 🎁
        let mut fields = csv_row.split(',');
        let name = fields.next().ok_or("Missing name")?.to_string();
        let good_deeds = fields.next().ok_or("Missing good deeds")?.parse().map_err(|_| "Invalid good deeds")?;
        let bad_deeds = fields.next().ok_or("Missing bad deeds")?.parse().map_err(|_| "Invalid bad deeds")?;
        Ok(Self::new(name, good_deeds, bad_deeds))
    }
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Self {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Self { name, niceness }
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}

sjmellor

a month ago

5.57ms

89.24kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn parse_row(csv_row: &str) -> Result<Kid, &'static str> {
        // 🎁 Transform the CSV row into a Kid struct for Santa's list!
        // 🎅 Expected CSV: "Name,GoodDeeds,BadDeeds"
        //    Example: "Alice,3,1" -> name: "Alice", good_deeds: 3, bad_deeds: 1
        // 🎁 Your code here! 🎁
        let mut fields = csv_row.split(',');
        let name: String = fields.next().ok_or("Missing Name")?.to_string();
        let good_deeds: u32 = fields.next().ok_or("Missing Field")?.parse().map_err(|_| "Invalid good deeds")?;
        let bad_deeds: u32 = fields.next().ok_or("Missing Field")?.parse().map_err(|_| "Invalid bad deeds")?;
        Ok(Self::new(name, good_deeds, bad_deeds))
    }
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Self {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Self { name, niceness }
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}

Chloe

chloecat34

a month ago

3.71ms

90.44kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn parse_row(csv_row: &str) -> Result<Kid, &'static str> {
        // 🎁 Transform the CSV row into a Kid struct for Santa's list!
        // 🎅 Expected CSV: "Name,GoodDeeds,BadDeeds"
        //    Example: "Alice,3,1" -> name: "Alice", good_deeds: 3, bad_deeds: 1
        // 🎁 Your code here! 🎁
        let mut parts = csv_row.split(",");
        let name = parts.next().ok_or("Name missing!")?;
        let second = parts.next().ok_or("Good deeds missing!")?;
        let third = parts.next().ok_or("Bad deeds missing!")?;
        let good_deeds = second.parse::<u32>().map_err(|_| "Good deeds could not be parsed!")?;
        let bad_deeds = third.parse::<u32>().map_err(|_| "Bad deeds could not be parsed!")?;
        Ok(Self::new(name.to_string(), good_deeds, bad_deeds))
    }
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Self {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Self { name, niceness }
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}

Chloe

chloecat34

a month ago

3.98ms

90.44kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn parse_row(csv_row: &str) -> Result<Kid, &'static str> {
        // 🎁 Transform the CSV row into a Kid struct for Santa's list!
        // 🎅 Expected CSV: "Name,GoodDeeds,BadDeeds"
        //    Example: "Alice,3,1" -> name: "Alice", good_deeds: 3, bad_deeds: 1
        // 🎁 Your code here! 🎁
        let mut parts = csv_row.split(",");
        let name = parts.next();
        let second = parts.next();
        let third = parts.next();
        if name.is_none() || second.is_none() || third.is_none() {
            return Err("The line isn't long enough!");
        }
        let good_deeds = second.unwrap().parse::<u32>();
        let bad_deeds = third.unwrap().parse::<u32>();
        match (good_deeds, bad_deeds) {
            (Err(err), _) | (_, Err(err)) => Err("Could not parse the deeds into numbers!"),
            (Ok(good_deeds), Ok(bad_deeds)) => Ok(Self::new(name.unwrap().to_string(), good_deeds, bad_deeds))
        }
    }
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Self {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Self { name, niceness }
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}

brucecox01

a month ago

4.84ms

89.24kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn parse_row(csv_row: &str) -> Result<Kid, &'static str> {
        // 🎁 Transform the CSV row into a Kid struct for Santa's list!
        // 🎅 Expected CSV: "Name,GoodDeeds,BadDeeds"
        //    Example: "Alice,3,1" -> name: "Alice", good_deeds: 3, bad_deeds: 1
        // 🎁 Your code here! 🎁
        let mut iter = csv_row.split(",");
        let name = iter.next().ok_or("Not enough fields")?.to_string();
        let good_deeds = iter.next().ok_or("Not enough fields")?.parse().or(Err("Good deeds unparseable"))?;
        let bad_deeds = iter.next().ok_or("Not enough fields")?.parse().or(Err("Bad deeds unparseable"))?;
        Ok(Self::new(name, good_deeds, bad_deeds))
    }
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Self {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Self { name, niceness }
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}

Sergey Chelak

SergeyChelak

a month ago

4.02ms

89.24kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn parse_row(csv_row: &str) -> Result<Kid, &'static str> {
        // 🎁 Transform the CSV row into a Kid struct for Santa's list!
        // 🎅 Expected CSV: "Name,GoodDeeds,BadDeeds"
        //    Example: "Alice,3,1" -> name: "Alice", good_deeds: 3, bad_deeds: 1
        // 🎁 Your code here! 🎁
        let mut iter = csv_row.split(',');
        let Some(name) = iter.next().map(|x| x.to_string()) else {
            return Err("bad name");
        };
        let Some(good_deeds) = iter.next().and_then(|x| x.parse::<u32>().ok()) else {
            return Err("bad good_deeds");
        };
        let Some(bad_deeds) = iter.next().and_then(|x| x.parse::<u32>().ok()) else {
            return Err("bad bad_deeds");
        };
        Ok(Self::new(name, good_deeds, bad_deeds))
    }
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Self {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Self { name, niceness }
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}

Felix

FelixMaetzler

2 months ago

3.84ms

89.24kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn parse_row(csv_row: &str) -> Result<Kid, &'static str> {
        // 🎁 Transform the CSV row into a Kid struct for Santa's list!
        // 🎅 Expected CSV: "Name,GoodDeeds,BadDeeds"
        //    Example: "Alice,3,1" -> name: "Alice", good_deeds: 3, bad_deeds: 1
        // 🎁 Your code here! 🎁
        let mut it = csv_row.split(',');
        let name = it.next().ok_or("")?.parse().map_err(|_| "")?;
        let good_deeds = it.next().ok_or("")?.parse().map_err(|_| "")?;
        let bad_deeds = it.next().ok_or("")?.parse().map_err(|_| "")?;
        Ok(Self::new(name, good_deeds, bad_deeds))
    }
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Self {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Self { name, niceness }
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}

DilligentDisaster

2 months ago

4.15ms

89.24kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn parse_row(csv_row: &str) -> Result<Kid, &'static str> {
    let mut parts = csv_row.split(',');
    let name = parts.next().ok_or("Missing name")?.to_string();
    let good_deeds = parts
        .next()
        .ok_or("Missing good deeds")?
        .parse::<u32>()
        .map_err(|_| "Invalid good deeds")?;
    let bad_deeds = parts
        .next()
        .ok_or("Missing bad deeds")?
        .parse::<u32>()
        .map_err(|_| "Invalid bad deeds")?;
    Ok(Self::new(name, good_deeds, bad_deeds))
}
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Self {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Self { name, niceness }
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}

Philippe Massicotte

PMassicotte

2 months ago

4.18ms

89.24kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
   pub fn parse_row(csv_row: &str) -> Result<Kid, &'static str> {
        // 🎁 Transform the CSV row into a Kid struct for Santa's list!
        // 🎅 Expected CSV: "Name,GoodDeeds,BadDeeds"
        //    Example: "Alice,3,1" -> name: "Alice", good_deeds: 3, bad_deeds: 1
        // 🎁 Your code here! 🎁
        let mut parts = csv_row.splitn(3, ',');
        let name = parts.next().ok_or("Missing name")?.to_string();
        let good_deeds = parts
            .next()
            .ok_or("Missing good_deeds")?
            .parse()
            .map_err(|_| "Invalid good_deeds")?;
        let bad_deeds = parts
            .next()
            .ok_or("Missing bad_deeds")?
            .parse()
            .map_err(|_| "Invalid bad_deeds")?;
        Ok(Self::new(name, good_deeds, bad_deeds))
  }
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Self {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Self { name, niceness }
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}

UncleScientist

2 months ago

4.35ms

90.44kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn parse_row(csv_row: &str) -> Result<Kid, &'static str> {
        // 🎁 Transform the CSV row into a Kid struct for Santa's list!
        // 🎅 Expected CSV: "Name,GoodDeeds,BadDeeds"
        //    Example: "Alice,3,1" -> name: "Alice", good_deeds: 3, bad_deeds: 1
        // 🎁 Your code here! 🎁
        let words = csv_row.split(',').collect::<Vec<_>>();
        if words.len() != 3 {
            return Err("Not enough fields");
        }
        let name = if words[0].is_empty() {
            return Err("Invalid name");
        } else {
            words[0].to_string()
        };
        let good_deeds = words[1].parse::<u32>().map_err(|_| "Failed to parse good_deeds")?;
        let bad_deeds = words[2].parse::<u32>().map_err(|_| "Failed to parse bad_deeds")?;
        Ok(Self::new(name, good_deeds, bad_deeds))
    }
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Self {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Self { name, niceness }
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}

0x0f1

Paul4673

2 months ago

4.42ms

89.24kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn parse_row(csv_row: &str) -> Result<Kid, &'static str> {
        // 🎁 Transform the CSV row into a Kid struct for Santa's list!
        // 🎅 Expected CSV: "Name,GoodDeeds,BadDeeds"
        //    Example: "Alice,3,1" -> name: "Alice", good_deeds: 3, bad_deeds: 1
        
        // 🎁 Your code here! 🎁
        let mut fields = csv_row.split(",");
        let name = fields.next().ok_or("No name")?.to_string();
        let good_deeds = fields.next().ok_or("empty")?.parse::<u32>().map_err(|_| " Invalid CSV format.")?;
        let bad_deeds = fields.next().ok_or("empty")?.parse::<u32>().map_err(|_| "Invalid CSV format.")?;
        Ok(Self::new(name, good_deeds, bad_deeds))
    }
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Self {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Self { name, niceness }
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}

Kristupas Arifovas

Quikmove

2 months ago

5.79ms

90.44kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn parse_row(csv_row: &str) -> Result<Kid, &'static str> {
        // 🎁 Transform the CSV row into a Kid struct for Santa's list!
        // 🎅 Expected CSV: "Name,GoodDeeds,BadDeeds"
        //    Example: "Alice,3,1" -> name: "Alice", good_deeds: 3, bad_deeds: 1
        let mut fields = csv_row.split(',');
        let name = fields.next().ok_or("No name!")?;
        let good_deeds: u32 = fields.next()
                                .ok_or("No good deeds!")?
                                .parse::<u32>()
                                .map_err(|_| "Invalid good deeds")?;
        let bad_deeds: u32 = fields.next()
                                .ok_or("No bad deeds!")?
                                .parse::<u32>()
                                .map_err(|_| "Invalid bad deeds")?;
        Ok(Self::new(String::from(name), good_deeds, bad_deeds))
    }
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Self {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Self { name, niceness }
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}

HubertBL47

2 months ago

4.03ms

89.24kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
pub const GOOD_THRESHOLD: f32 = 0.75;
#[derive(Debug, PartialEq)] // needed for tests
pub enum Niceness {
    Nice(u32),
    Naughty,
}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn parse_row(csv_row: &str) -> Result<Kid, &'static str> {
        let mut row_iter = csv_row.split(',');
        let name = row_iter
            .next()
            .ok_or("Invalid CSV format: Empty line")?
            .to_string();
        let good_deeds = row_iter
            .next()
            .ok_or("Invalid CSV format: No good deeds")?
            .parse::<u32>()
            .map_err(|_| "Invalid CSV format: Good deeds is not a valid positive number")?;
        let bad_deeds = row_iter
            .next()
            .ok_or("Invalid CSV format: No bad deeds")?
            .parse::<u32>()
            .map_err(|_| "Invalid CSV format: Bad deeds is not a valid positive number")?;
        Ok(Self::new(name, good_deeds, bad_deeds))
    }
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        Kid {
            name: name,
            niceness: Kid::is_nice(good_deeds, bad_deeds)
                .then(|| Niceness::Nice(good_deeds))
                .unwrap_or(Niceness::Naughty),
        }
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_score = good_deeds as f32 * GOOD_WEIGHT;
        let bad_score = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_score / (good_score + bad_score);
        ratio >= GOOD_THRESHOLD
    }
}

AncientSecrets

2 months ago

3.95ms

90.44kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn parse_row(csv_row: &str) -> Result<Kid, &'static str> {
        // 🎁 Transform the CSV row into a Kid struct for Santa's list!
        // 🎅 Expected CSV: "Name,GoodDeeds,BadDeeds"
        //    Example: "Alice,3,1" -> name: "Alice", good_deeds: 3, bad_deeds: 1
        // 🎁 Your code here! 🎁
        let words = csv_row.split(',').collect::<Vec<_>>();
        if words.len() != 3 {
            return Err("Bad field count");
        }
        if words[0].is_empty() {
            return Err("Invalid name");
        }
        let Ok(good_deeds) = words[1].parse::<u32>() else { return Err("Invalid good_deeds"); };
        let Ok(bad_deeds) = words[2].parse::<u32>() else { return Err("Invalid bad_deeds"); };
        Ok(Self::new(words[0].into(), good_deeds, bad_deeds))
    }
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Self {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Self { name, niceness }
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}

silaskoemen

2 months ago

3.91ms

89.24kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn parse_row(csv_row: &str) -> Result<Kid, &'static str> {
        // 🎁 Transform the CSV row into a Kid struct for Santa's list!
        // 🎅 Expected CSV: "Name,GoodDeeds,BadDeeds"
        //    Example: "Alice,3,1" -> name: "Alice", good_deeds: 3, bad_deeds: 1
        // 🎁 Your code here! 🎁
        let mut fields = csv_row.split(',');
        let name = fields.next().ok_or("Missing field")?.to_string();
        let good_deeds = fields.next().ok_or("Missing field")?.parse::<u32>().map_err(|_| "Invalid good deeds")?;
        let bad_deeds = fields.next().ok_or("Missing field")?.parse::<u32>().map_err(|_| "Invalid bad deeds")?;
        Ok(Self::new(name, good_deeds, bad_deeds))
    }
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Self {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Self { name, niceness }
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}

syberianbull

2 months ago

4.63ms

90.44kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn parse_row(csv_row: &str) -> Result<Kid, &'static str> {
        // 🎁 Transform the CSV row into a Kid struct for Santa's list!
        // 🎅 Expected CSV: "Name,GoodDeeds,BadDeeds"
        //    Example: "Alice,3,1" -> name: "Alice", good_deeds: 3, bad_deeds: 1
        // 🎁 Your code here! 🎁
        let parts: Vec<&str> = csv_row.split(",").collect();
        if parts.len() != 3 {
            return Err("Invalid row.")
        }
        let name = parts[0].to_string();
        let good_deeds = parts[1].parse::<u32>().map_err(|_|"Could not parse second argument to good deeds")?;
        let bad_deeds = parts[2].parse::<u32>().map_err(|_|"Could not parse third argument to bad deeds")?;
        Ok(Self::new(name, good_deeds, bad_deeds))
    }
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Self {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Self { name, niceness }
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}

Camiam144

2 months ago

5.13ms

89.24kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn parse_row(csv_row: &str) -> Result<Kid, &'static str> {
        // 🎁 Transform the CSV row into a Kid struct for Santa's list!
        // 🎅 Expected CSV: "Name,GoodDeeds,BadDeeds"
        //    Example: "Alice,3,1" -> name: "Alice", good_deeds: 3, bad_deeds: 1
        // 🎁 Your code here! 🎁
        let mut fields = csv_row.split(',');
        let name = fields.next().ok_or("Missing field")?.to_string();
        let good_deeds = fields.next().ok_or("Missing field")?.parse::<u32>().map_err(|_| "Invalid good deeds")?;
        let bad_deeds = fields.next().ok_or("Missing field")?.parse::<u32>().map_err(|_| "Invalid bad deeds")?;
        Ok(Self::new(name, good_deeds, bad_deeds))
    }
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Self {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Self { name, niceness }
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}

Aaron Willis

O-possum

2 months ago

3.98ms

90.44kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn parse_row(csv_row: &str) -> Result<Kid, &'static str> {
        // 🎁 Transform the CSV row into a Kid struct for Santa's list!
        // 🎅 Expected CSV: "Name,GoodDeeds,BadDeeds"
        //    Example: "Alice,3,1" -> name: "Alice", good_deeds: 3, bad_deeds: 1
        // 🎁 Your code here! 🎁
        let parts: Vec<&str> = csv_row.split(",").collect();
        if parts.len() != 3 {
            return Err("Invalid CSV format; expected 3 values separated by commas.")
        }
        let name: String = parts[0].to_string();
        let good_deeds: u32 = parts[1]
            .parse::<u32>()
            .map_err(|_|"Could not parse good deeds as u32")?;
        let bad_deeds: u32 = parts[2]
            .parse::<u32>()
            .map_err(|_|"Could not parse bad deeds as u32")?;
        Ok(Self::new(name, good_deeds, bad_deeds))
    }
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Self {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Self { name, niceness }
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}

Aaron Willis

O-possum

2 months ago

3.99ms

90.44kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn parse_row(csv_row: &str) -> Result<Kid, &'static str> {
        // 🎁 Transform the CSV row into a Kid struct for Santa's list!
        // 🎅 Expected CSV: "Name,GoodDeeds,BadDeeds"
        //    Example: "Alice,3,1" -> name: "Alice", good_deeds: 3, bad_deeds: 1
        // 🎁 Your code here! 🎁
        let parts: Vec<&str> = csv_row.split(",").collect();
        if parts.len() != 3 {
            return Err("Invalid CSV format; expected 3 values separated by commas.")
        }
        let name: String = String::from(parts[0]);
        let good_deeds: u32 = parts[1]
            .parse::<u32>()
            .map_err(|_|"Could not parse good deeds as u32")?;
        let bad_deeds: u32 = parts[2]
            .parse::<u32>()
            .map_err(|_|"Could not parse bad deeds as u32")?;
        Ok(Self::new(String::from(name), good_deeds, bad_deeds))
    }
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Self {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Self { name, niceness }
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}

Aaron Willis

O-possum

2 months ago

3.73ms

90.44kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn parse_row(csv_row: &str) -> Result<Kid, &'static str> {
        // 🎁 Transform the CSV row into a Kid struct for Santa's list!
        // 🎅 Expected CSV: "Name,GoodDeeds,BadDeeds"
        //    Example: "Alice,3,1" -> name: "Alice", good_deeds: 3, bad_deeds: 1
        // 🎁 Your code here! 🎁
        let mut parts = csv_row.split(",");
        let name: &str = parts.next()
            .ok_or("Couldn't parse name")?;
        let good_deeds: u32 = parts.next()
            .ok_or("Invalid good deeds")?
            .parse::<u32>()
            .map_err(|_|"Could not parse good deeds as u32")?;
        let bad_deeds: u32 = parts.next()
            .ok_or("Invalid bad deeds")?
            .parse::<u32>()
            .map_err(|_|"Could not parse bad deeds as u32")?;
        Ok(Self::new(String::from(name), good_deeds, bad_deeds))
    }
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Self {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Self { name, niceness }
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}

Luigi Terrone

LuigiTer

2 months ago

3.87ms

90.44kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn parse_row(csv_row: &str) -> Result<Kid, &'static str> {
        // 🎁 Transform the CSV row into a Kid struct for Santa's list!
        // 🎅 Expected CSV: "Name,GoodDeeds,BadDeeds"
        //    Example: "Alice,3,1" -> name: "Alice", good_deeds: 3, bad_deeds: 1
        // 🎁 Your code here! 🎁
        let vec: Vec<&str> = csv_row.split(',').collect();
        if vec.len() != 3 {
            return Err("Invalid CSV format: expected 3 fields");
        }
        if vec[0].is_empty() || vec[1].is_empty() || vec[2].is_empty() {
            return Err("Empty field found in CSV");
        }
        let name: String = vec[0].to_string();
        let good_deeds: u32 = vec[1].parse()
            .map_err(|_| "Invalid number for good deeds")?;
        let bad_deeds: u32 = vec[2].parse()
            .map_err(|_| "Invalid number for bad deeds")?;
        Ok(Self::new(name, good_deeds, bad_deeds))
    }
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Self {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Self { name, niceness }
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}

Alan Bowman

alanbowman

2 months ago

4.96ms

89.88kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn parse_row(csv_row: &str) -> Result<Kid, &'static str> {
        // 🎁 Transform the CSV row into a Kid struct for Santa's list!
        // 🎅 Expected CSV: "Name,GoodDeeds,BadDeeds"
        //    Example: "Alice,3,1" -> name: "Alice", good_deeds: 3, bad_deeds: 1
        let mut splits = csv_row.split(",");
        let name_entry = splits.next().ok_or("Missing field")?;
        let good_deeds_entry = splits.next().ok_or("Missing field")?;
        let bad_deeds_entry = splits.next().ok_or("Missing field")?;
        let name = name_entry.to_string();
        let good_deeds = good_deeds_entry.parse::<u32>().map_err(|_| "Unable to parse")?;
        let bad_deeds = bad_deeds_entry.parse::<u32>().map_err(|_| "Unable to parse")?;
        Ok(Self::new(name, good_deeds, bad_deeds))
    }
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Self {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Self { name, niceness }
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}

Hongzhii

2 months ago

3.76ms

89.24kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn parse_row(csv_row: &str) -> Result<Kid, &'static str> {
        // 🎁 Transform the CSV row into a Kid struct for Santa's list!
        // 🎅 Expected CSV: "Name,GoodDeeds,BadDeeds"
        //    Example: "Alice,3,1" -> name: "Alice", good_deeds: 3, bad_deeds: 1
        // 🎁 Your code here! 🎁
        let mut parts = csv_row.split(",");
        let name: String = parts.next().ok_or("Missing field")?.to_string();
        let good_deeds: u32 = parts.next().ok_or("Missing field")?.parse().map_err(|_|"Invalid good deeds")?;
        let bad_deeds: u32 = parts.next().ok_or("Missing field")?.parse().map_err(|_|"Invalid bad deeds")?;
        Ok(Self::new(name, good_deeds, bad_deeds))
    }
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Self {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Self { name, niceness }
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}

xian ma

xanvcs

2 months ago

3.76ms

90.44kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn parse_row(csv_row: &str) -> Result<Kid, &'static str> {
        // 🎁 Transform the CSV row into a Kid struct for Santa's list!
        // 🎅 Expected CSV: "Name,GoodDeeds,BadDeeds"
        //    Example: "Alice,3,1" -> name: "Alice", good_deeds: 3, bad_deeds: 1
        // 🎁 Your code here! 🎁
        let parts: Vec<&str> = csv_row.split(",").collect();
        if parts.len() != 3 {
            return Err("invalid length")
        };
        let name = parts[0].to_string();
        let good_deeds = parts[1].parse().map_err(|_| "good_deeds can't be parsed")?;
        let bad_deeds = parts[2].parse().map_err(|_| "bad_deeds can't be parsed")?;
        Ok(Self::new(name, good_deeds, bad_deeds))
    }
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Self {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Self { name, niceness }
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}

Andrés Pérez

cperez08

2 months ago

3.86ms

89.29kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn parse_row(csv_row: &str) -> Result<Kid, &'static str> {
        // 🎁 Transform the CSV row into a Kid struct for Santa's list!
        // 🎅 Expected CSV: "Name,GoodDeeds,BadDeeds"
        //    Example: "Alice,3,1" -> name: "Alice", good_deeds: 3, bad_deeds: 1
        let parts: Vec<&str> = csv_row.split(",").collect();
        if parts.len() != 3 {
            return Err("invalid row");
        }
        let name = parts[0];
        let good_deeds: u32 = match parts[1].parse() {
            Ok(n) => n,
            Err(_e) => return Err("invalid good deeds"),
        };
        let bad_deeds: u32 = match parts[2].parse() {
            Ok(n) => n,
            Err(_e) => return Err("invalid bad deeds"),
        };
        Ok(Self::new(name.to_owned(), good_deeds, bad_deeds))
    }
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Self {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Self { name, niceness }
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}