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

tdoan

4 hours ago

5.82ms

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 = parts.next().ok_or("")?.to_string();
        let good_deeds = parts.next().ok_or("")?.parse().map_err(|_|"cant parse u32")?;
        let bad_deeds = parts.next().ok_or("")?.parse().map_err(|_|"cant parse 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
    }
}

João Paiva

jgpaiva

11 hours ago

5.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 fields: Vec<&str> = csv_row.split(",").collect();
        if fields.len() != 3 {
            return Err("nope");
        }
        let name = fields[0].to_string();
        let good_deeds = fields[1].parse().map_err(|_|"nope")?;
        let bad_deeds = fields[2].parse().map_err(|_|"nope")?;
        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
    }
}

Egor

Flash-Kaa

16 hours ago

4.56ms

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("Error")?.to_string();
        let good_deeds: u32 = split.next().ok_or("Error")?.parse().map_err(|_| "Error")?;
        let bad_deeds: u32 = split.next().ok_or("Error")?.parse().map_err(|_| "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
    }
}

mliertzer

16 hours ago

7.33ms

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("Could not parse name")?.to_string();
        let good_deeds = fields.next().ok_or("Could not parse good deeds")?.parse::<u32>().or(Err("Failed to parse good deeds"))?;
        let bad_deeds = fields.next().ok_or("Could not parse bad deeds")?.parse::<u32>().or(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
    }
}

isaaclv

16 hours ago

3.73ms

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
        let mut data = csv_row.split(',');
        let name = data.next().ok_or("Missing field")?.to_string();
        let good_deeds = data.next().ok_or("Missing field")?.parse().map_err(|_| "Invalid good deeds")?;
        let bad_deeds = data.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
    }
}

Mingzhe Yang

mei28

19 hours ago

3.93ms

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 = parts.next().ok_or("Name not found")?.to_string();
        let good_deeds = parts
            .next()
            .ok_or("Good deeds not found")?
            .parse::<u32>()
            .map_err(|_| "Good deeds not a number")?;
        let bad_deeds = parts
            .next()
            .ok_or("Bad deeds not found")?
            .parse::<u32>()
            .map_err(|_| "Bad deeds not a 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
    }
}

PangoSea

kapaseker

a day ago

3.61ms

89.31kb

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 colums = csv_row.split(',').collect::<Vec<&str>>();
        let name = colums.get(0).ok_or("Could not find name")?.to_string();
        let good_deeds = colums.get(1).ok_or("no good_deeds")?.to_string().parse::<u32>().or(Err("Could not parse good_deeds"))?;
        let bad_deeds = colums.get(2).ok_or("no bad_deeds")?.to_string().parse::<u32>().or(Err("Could not 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
    }
}

Harald Gliebe

hagl

a day ago

3.81ms

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("Missing name")?.to_string();
        let good_deeds = iter.next().ok_or("Missing good_deeds")?.parse::<u32>().map_err(|_| "Parse error")?;
        let bad_deeds = iter.next().ok_or("Missing bad_deeds")?.parse::<u32>().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
    }
}

Pumkko

a day ago

4.01ms

90.44kb

pub const GOOD_WEIGHT: f64 = 1.0;
pub const BAD_WEIGHT: f64 = 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("Missing Name")?;
        let good_deeds = parts
            .next()
            .ok_or("Missing good_deeds parts")?
            .parse::<u32>()
            .map_err(|_| "Failed to parse good deeds parts")?;
        let bad_deeds = parts
            .next()
            .ok_or("Missing bad_deeds parts")?
            .parse::<u32>()
            .map_err(|_| "Failed to parse bad deeds parts")?;
        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 = f64::from(good_deeds) * GOOD_WEIGHT;
        let bad_deeds = f64::from(bad_deeds) * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}

Pumkko

a day ago

3.68ms

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
        // 🎁 Your code here! 🎁
        let data: Vec<&str> = csv_row.split(",").collect();
        if data.len() != 3 {
            return Err("Row is missing data");
        }
        let name = data[0];
        let Ok(good_deeds) = data[1].parse() else {
            return Err("good_deeds is not a number");
        };
        let Ok(bad_deeds) = data[2].parse() else {
            return Err("bad_deeds is not a number");
        };
        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
    }
}

Omar Saber Talaat Abdelrahman

omar-s-ta

a day ago

5.14ms

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
        // 🎁 Your code here! 🎁
        
        let row: Vec<&str> = csv_row.split(',').collect();
        if row.len() < 3 {
            Err("not enought data")
        } else if let (Ok(good_deeds), Ok(bad_deeds)) =
            (row[1].parse::<u32>(), row[2].parse::<u32>())
        {
            Ok(Self::new(String::from(row[0]), good_deeds, bad_deeds))
        } else {
            Err("could not parse numbers")
        }
    }
    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
    }
}

doroshtapgh

2 days ago

4.29ms

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 = parts.next().ok_or("Missing field")?.to_string();
        let good_deeds = parts.next().ok_or("Missing field")?.parse::<u32>().map_err(|_| "Failed to parse good_deeds")?;
        let bad_deeds = parts.next().ok_or("Missing field")?.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
    }
}

Naoyuki Yamada

chokkoyamada

2 days ago

3.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 parts = csv_row.split(',');
        let name = parts.next().ok_or("Name not found")?.to_string();
        let good_deeds = parts
            .next()
            .ok_or("Good deeds not found")?
            .parse::<u32>()
            .map_err(|_| "Good deeds not a number")?;
        let bad_deeds = parts
            .next()
            .ok_or("Bad deeds not found")?
            .parse::<u32>()
            .map_err(|_| "Bad deeds not a 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
    }
}

Naoyuki Yamada

chokkoyamada

2 days ago

4.41ms

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 = parts.next().ok_or("Name not found")?.to_string();
        let good_deeds = parts
            .next()
            .ok_or("Good deeds not found")?
            .parse::<u32>()
            .map_err(|_| "Good deeds not a number")?;
        let bad_deeds = parts
            .next()
            .ok_or("Bad deeds not found")?
            .parse::<u32>()
            .map_err(|_| "Bad deeds not a 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
    }
}

Bob Schmertz

rschmertz

2 days ago

7.95ms

89.25kb

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 s = String::from(csv_row);
        let mut s_array = s.split(",");
        let name_maybe = s_array.next();
        let mut name = String::new();
        match name_maybe {
            None => return Err("No first item -- empty row"),
            Some(good_name) => name = good_name.to_string()
        }
        let mut good_deeds: u32 = 0;
        let mut bad_deeds: u32 = 0;
        let next_item = s_array.next();
        match next_item {
            None => return Err("No second item"),
            Some(good_deeds_s) => {
                let result = good_deeds_s.parse::<u32>();
                match result {
                    Ok(gd) => good_deeds = gd,
                    Err(e) => return Err("couldn't parse second item as u32")
                }
            }
        }
        let next_item = s_array.next();
        match next_item {
            None => return Err("No third item"),
            Some(bad_deeds_s) => {
                let result = bad_deeds_s.parse::<u32>();
                match result {
                    Ok(gd) => bad_deeds = gd,
                    Err(e) => return Err("couldn't parse third item 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
    }
}

pilotso11

2 days ago

3.86ms

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
        // 🎁 Your code here! 🎁
        let mut iter = csv_row.split(',');
        if iter.clone().count() != 3 {
            return Err("Invalid CSV row");
        }
        let name = iter.next().unwrap().to_string();
        let good_deeds = iter.next().unwrap().parse::<u32>();
        let bad_deeds = iter.next().unwrap().parse::<u32>();
        if good_deeds.is_err() || bad_deeds.is_err() {
            return Err("Invalid CSV row");
        }
        let good_deeds = good_deeds.unwrap();
        let bad_deeds = bad_deeds.unwrap();
        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
    }
}

David Griffin

findgriffin

2 days ago

4.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 parts: Vec<&str> = csv_row.split(',').collect();
        if parts.len() < 3 {
            Err("too few columns")
        } else {
            let name = parts[0].to_string();
            let good = parts[1].parse::<u32>();
            let bad =  parts[2].parse::<u32>();
            if good.is_err() || bad.is_err() {
                Err("cannot convert to int")
            } else {
                Ok(Self::new(name, good.unwrap(), bad.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
    }
}

Ankit Kumar Jha

Ankit8848

2 days ago

4.10ms

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_str = fields.next().ok_or("Missing field")?;
        let bad_deeds_str = fields.next().ok_or("Missing field")?;
        let good_deeds = good_deeds_str.parse().map_err(|_| "Invalid")?;
        let bad_deeds = bad_deeds_str.parse().map_err(|_| "Invalid")?;
        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
    }
}

Mladen Rasic

mladen5000

2 days ago

3.96ms

90.44kb

fn main() {
    println!("Hello, world!");
}
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,
}
/* 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.
*/
impl Kid {
    pub fn parse_row(csv_row: &str) -> Result<Kid, &'static str> {
        let csv_items: Vec<_> = csv_row.split(',').collect();
         if (csv_items.len() != 3){
            return Err("balh");}
        let (name, good_deeds, bad_deeds) = (
            csv_items[0].to_string(),
            csv_items[1].parse::<u32>(),
            csv_items[2].parse::<u32>(),
        );
        if let Ok(num) = good_deeds {
            let good_deeds = num;
        } else {
            return Err("womp");
        }
        if let Ok(num) = bad_deeds {
            let bad_deeds = num;
        } else {
            return Err("womp");
        }
        // 🎁 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.unwrap(), bad_deeds.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
    }
}

Habu

habu1010

2 days ago

4.05ms

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 fileds = csv_row.split(',');
        let name = fileds.next().ok_or("Missing field")?.to_string();
        let good_deeds_str = fileds.next().ok_or("Missing field")?;
        let bad_deeds_str = fileds.next().ok_or("Missing field")?;
        let good_deeds = good_deeds_str.parse().map_err(|_| "Invalid good deeds")?;
        let bad_deeds = bad_deeds_str.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
    }
}

Rickard Jensen

rjensen

2 days ago

3.66ms

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("CSV column missing")?.to_string();
        let good_deeds = fields.next().ok_or("CSV column missing")?.parse().map_err(|_| "field not a number")?;
        let bad_deeds = fields.next().ok_or("CSV column missing")?.parse().map_err(|_| "field not a 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
    }
}

Sukrit Amornpornwiwat

arm01846

3 days ago

3.99ms

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
        let mut fields = csv_row.split(',');
        let name = fields.next().expect("Missing name").to_string();
        let good_deeds_field = fields.next().ok_or("Missing good_deeds")?;
        let bad_deeds_field = fields.next().ok_or("Missing bad_deeds")?;
        let good_deeds = good_deeds_field.parse::<u32>().map_err(|_| "Invalid good deeds")?;
        let bad_deeds = bad_deeds_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
    }
}

Ankeet Parikh

ankeetparikh

3 days ago

7.13ms

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 parts: Vec<_> = csv_row.split(",").collect();
        if parts.len() != 3 {
            return Err("Number of parts is incorrect.")
        }
        let name = String::from(parts[0]);
        let good_deeds: u32 = match parts[1].parse() {
            Ok(v) => v,
            Err(_) => return Err("parsing went wrong")
        };
        let bad_deeds: u32 = match parts[2].parse() {
            Ok(v) => v,
            Err(_) => return Err("parsing went wrong")
        };
        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
    }
}

Tarokc

3 days 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 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
    }
}

json-stateham

3 days 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> {
        let mut parts = csv_row.split(',');
        let name = parts.next().ok_or("Missing field")?.to_string();
        let good_deeds = parts.next().ok_or("Missing field")?.parse::<u32>().map_err(|_| "Invalid good deeds")?;
        let bad_deeds = parts.next().ok_or("Missing field")?.parse::<u32>().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
    }
}

Nikita Smirnov

Nismirno

3 days ago

5.96ms

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 kid_data: Vec<&str> = csv_row.split(',').collect();
        if kid_data.len() < 3 {
            return Err("Not enough data");
        }
        let name: String = String::from(kid_data[0]);
        let good_deeds: u32 = match kid_data[1].parse() {
            Ok(n) => n,
            Err(_) => return Err("Incorrect value for good deeds"),
        };
        let bad_deeds: u32 = match kid_data[2].parse() {
            Ok(n) => n,
            Err(_) => return Err("Incorrect value 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
    }
}

Emmanuel Guefif

eguefif

3 days ago

4.50ms

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
        let mut splits = csv_row.split(",");
        let name;
        let good_deeds;
        let bad_deeds;
        if let Some(value) = splits.next() {
            name = value.to_string();
        } else {
            return Err("Error parsing name");
        }
        if let Some(value) = splits.next() {
            if let Ok(converted_value) = value.parse::<u32>() {
                good_deeds = converted_value
            } else {
                return Err("Invalid number: good_deeds");
            }
        } else {
            return Err("Error parsing good deeds");
        }
        if let Some(value) = splits.next() {
            if let Ok(converted_value) = value.parse::<u32>() {
                bad_deeds = converted_value
            } else {
                return Err("Invalid number: bad_deeds");
            }
        } else {
            return Err("Error parsing 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
    }
}

Patrick Tluszcz

uRTLy

3 days ago

7.20ms

90.54kb


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, PartialEq)]
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn parse_row(csv_row: &str) -> Result<Kid, &'static str> {
        println!("Row: {}", csv_row);
        let split = csv_row.clone().split(",").collect::<Vec<&str>>();
        if split.is_empty() ||  split.len() != 3 {
            return Err("Row is empty");
        }
        let name = split.get(0).expect("Empty name").to_string();
        println!("Name: {}", name);
        let good_deeds: u32 =  match split.get(1).and_then(|s| s.parse().ok()) {
            Some(s) =>  {
                println!("Good deeds: {}", s);
                s
            }
            None =>  { return Err("Invalid good deeds"); },
        };
        println!("Good deeds: {}", good_deeds);
        let bad_deeds: u32 =  match split.get(2).and_then(|s| s.parse().ok()) {
            Some(s) =>  {
                println!("Bad deeds: {}", s);
                s
            }
            None =>  { return Err("Invalid bad deeds"); },
        };
        println!("Bad deeds: {}", bad_deeds);
        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 }
    }
    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
    }
    fn print(self) {
        println!("This kid name is {}", self.name);
        println!("This kids niceness is {:?}", self.niceness);
    }
}

Job Matheka

jobm

4 days ago

4.00ms

89.30kb

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 row: Vec<_> = csv_row.split(",").collect();
        match row.len() < 3
            || !(row[0].chars().all(char::is_alphabetic)
                && row[1].chars().all(char::is_numeric)
                && row[2].chars().all(char::is_numeric))
        {
            true => Err("Invalid Input"),
            false => Ok(Self::new(
                row.first().unwrap().to_string(),
                row[1].parse::<u32>().unwrap(),
                row.last().unwrap().parse::<u32>().unwrap_or_default(),
            )),
        }
    }
    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
    }
}

Antenaina

antenaina0

4 days ago

4.88ms

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
        // 🎁 Your code here! 🎁
        let splitted: Vec<&str> = csv_row.split(",").collect();
        if splitted.len() < 3 {
            return Err("");
        }
        let parsed_gd = u32::from_str_radix(splitted[1], 10);
        let parsed_bd = u32::from_str_radix(splitted[2], 10);
        let gd_res = match parsed_gd {
            Ok(e) => e,
            Err(_) => return Err(""),
        };
        let bd_res = match parsed_bd {
            Ok(e) => e,
            Err(_) => return Err(""),
        };
        let name_str = String::from(splitted[0]);
        Ok(Self::new(name_str, gd_res, bd_res))
    }
    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
    }
}

Masayuki Sunahara

tamanishi

4 days ago

3.98ms

89.34kb

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 elms: Vec<_> = (*csv_row).split(',').collect::<Vec<_>>().to_vec();
        if elms.len() != 3 {
            return Err("Invalid csv_row");
        }
        let name = elms[0];
        let good_deeds = match elms[1].parse() {
            Ok(n) => n,
            Err(_) => return Err("Invalid good_deeds"),
        };
        let bad_deeds = match elms[2].parse() {
            Ok(n) => n,
            Err(_) => return 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
    }
}

Masashi Nakayasu

MCsamurai034

4 days ago

4.15ms

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 v: Vec<&str> = csv_row.split(",").collect();
        if v.len() == 3 {
            let name: String = String::from(v[0]);
            let good_deeds_result: Result<u32, &str> = match v[1].parse::<u32>() {
                Ok(u) => Ok(u),
                Err(_) => Err("good missed!")
            };
            let bad_deeds_result: Result<u32, &str> = match v[2].parse::<u32>() {
                Ok(u) => Ok(u),
                Err(_) => Err("bad missed!")
            };
            let good_deeds: u32 = match good_deeds_result {
                Ok(u) => u,
                Err(e) => return Err(e),
            };
            let bad_deeds: u32 = match bad_deeds_result {
                Ok(u) => u,
                Err(e) => return Err(e),
            };
            Ok(Self::new(name, good_deeds, bad_deeds))
        } else {
            Err("Terrible input!")
        }
    }
    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
    }
}

hafihaf123

4 days ago

4.60ms

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 csv_row = csv_row.split(",");
        let name = match csv_row.next() {
            Some(s) => s.to_owned(),
            None => return Err("No name"),
        };
        let good_deeds = match csv_row.next() {
            Some(s) => s.parse().or_else(|_| Err("Failed to parse")),
            None => Err("No good deeds"),
        }?;
        let bad_deeds = match csv_row.next() {
            Some(s) => s.parse().or_else(|_| Err("Failed to parse")),
            None => Err("No 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
    }
}

Francisco López

franlopezm

4 days ago

4.25ms

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(",").collect();
        if fields.len() != 3 {
            return Err("Missing fields.")
        }
        let name = fields[0].to_string();
        let good_deeds: u32 = fields[1].parse().map_err(|_| "Invalid good deeds")?;
        let bad_deeds: u32 = fields[2].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
    }
}

Francisco López

franlopezm

4 days ago

4.40ms

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<_> = csv_row.split(",").collect();
        if fields.len() != 3 {
            return Err("Missing fields.")
        }
        let name = fields[0].to_string();
        let good_deeds: u32 = fields[1].parse().map_err(|_| "Invalid good deeds")?;
        let bad_deeds: u32 = fields[2].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
    }
}

Francisco López

franlopezm

4 days ago

3.97ms

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<_> = csv_row.split(",").collect();
        if fields.len() < 3 {
            return Err("Missing fields.")
        }
        let name = fields[0].to_string();
        let good_deeds: u32 = fields[1].parse().map_err(|_| "Invalid good deeds")?;
        let bad_deeds: u32 = fields[2].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
    }
}

Yossa Bourne

terminox

4 days ago

21.50ms

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 name: String = String::from("");
        let mut good_deeds: u32 = 0;
        let mut bad_deeds: u32 = 0;
        let mut parts = csv_row.split(",");
        
        if let Some(value) = parts.next() {
            name = String::from(value);
        } else {
            return Err("Something went wrong");
        }
        if let Some(value) = parts.next() {
            match value.parse::<u32>() {
                Ok(i) => good_deeds = i,
                Err(err) => {
                    return Err("Something went wrong");
                }
            }
        } else {
            return Err("Something went wrong");
        }
        if let Some(value) = parts.next() {
            match value.parse::<u32>() {
                Ok(i) => bad_deeds = i,
                Err(err) => {
                    return Err("Something went wrong");
                }
            }
        } else {
            return Err("Something went wrong");
        }
        return 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
    }
}

Sourabh Cheedella

rirze

4 days ago

3.90ms

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

KLcpb

4 days ago

3.90ms

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().unwrap_or_else(|| {return "some error ";}).to_string();
        let good_deeds = splitted.next().unwrap_or_else(||{ return "some error ";}).parse::<u32>().map_err(|_|"invalid good deeds")?;
        let bad_deeds = splitted.next().unwrap_or_else(|| {return "some error ";}).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
    }
}

arodrigue003

5 days ago

3.65ms

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
        // 🎁 Your code here! 🎁
        let split_row: Vec<_> = csv_row.split(",").collect();
        if split_row.len() < 3 {
            return Err("Not enought data")
        }
        let good_deeds: u32 = split_row[1].parse().map_err(|_| "Unable to parse good deeds")?;
        let bad_deeds: u32 = split_row[2].parse().map_err(|_| "Unable to parse bad deeds")?;
        Ok(Self::new(split_row[0].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
    }
}

Davide Cevoli

dade6

5 days ago

3.58ms

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 data = csv_row.split(',');
        let name = data.next().ok_or("Missing field")?.to_string();
        let good_deeds = data.next().ok_or("Missing field")?.parse().map_err(|_| "Invalid good deeds")?;
        let bad_deeds = data.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
    }
}

Carlos Cardoso

carlos-cardoso

5 days ago

3.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 tokens: Vec<&str> = csv_row.split(',').collect();
        if tokens.len() != 3 {
            return Err("wrong number of elements in row")
        }
        let name = tokens[0].to_string();
        let good_deeds: u32 = tokens[1].parse().map_err(|_e| "failed to parse good_deeds")?;
        let bad_deeds: u32 = tokens[2].parse().map_err(|_e| "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
    }
}

kosay

sarub0b0

5 days 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> {
        let parsed: Vec<&str> = csv_row.split(',').collect();
        
        if parsed.len() < 3 {
            return Err("error");
        }
        let name = parsed[0].to_string();
        let good_deeds = parsed[1].parse().map_err(|_| "error")?;
        let bad_deeds = parsed[2].parse().map_err(|_| "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
    }
}

arilet

5 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 words: Vec<_> = csv_row.split(",").collect();
        if words.len() == 3 {
            let name = words[0].to_string();
            
            let good_deeds = match words[1].parse::<u32>() {
                Ok(value) => value,
                Err(_) => return Err("Failed"),
            };
            let bad_deeds = match words[2].parse::<u32>() {
                Ok(value) => value,
                Err(_) => return Err("Failed"),
            };
            return Ok(Self::new(name, good_deeds, bad_deeds))
        }
        Err("Failed")
    }
    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
    }
}

Trung Tran

tdtrung17693

5 days ago

4.34ms

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("invalid_format")?;
        let good_deeds: u32 = parts.next().ok_or("invalid_format")?.parse().or_else(|_| Err("invalid_format"))?;
        let bad_deeds: u32 = parts.next().ok_or("invalid_format")?.parse().or_else(|_| Err("invalid_format"))?;
        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
    }
}

Richmond Steele

RedNapPanda

5 days ago

3.73ms

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 split = csv_row.split(",");
        let name = split.next().ok_or("invalid name")?.to_string();
        let good_deeds = split.next().ok_or("invalid good_deeds")?.parse::<u32>().map_err(|_| "stupid bound")?;
        let bad_deeds = split.next().ok_or("invalid bad_deeds")?.parse::<u32>().map_err(|_| "stupid bound")?;
        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
    }
}

gmvar

5 days ago

3.93ms

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
        let mut columns = csv_row.split(',');
        let name: String = String::from(columns.next().ok_or("Name is missing!")?);
        let good_deeds: Result<_, &str> = columns.next()
        .ok_or("Good deeds is missing!")?
        .parse()
        .map_err(|_| "Good deeds did not parse!");
        let bad_deeds: Result<_, &str> = columns.next()
        .ok_or("Bad deeds is missing!")?
        .parse()
        .map_err(|_| "Bad deeds did not 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
    }
}

Tengz Mao

MaoX-Yu

5 days ago

5.55ms

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 v: Vec<&str> = csv_row.split(",").collect();
        if v.len() < 3 {
            return Err("Missing field");
        }
        let name = String::from(v[0]);
        let good_deeds = v[1].parse().map_err(|_| "Invalid good deeds")?;
        let bad_deeds = v[2].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
    }
}

Galen Seilis

galenseilis

5 days ago

3.95ms

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 columns = csv_row.split(',');
        let name: String = String::from(columns.next().ok_or("Name is missing!")?);
        let good_deeds: Result<_, &str> =  columns
                                .next()
                                .ok_or("Good deeds is missing!")?
                                .trim()
                                .parse()
                                .map_err(|_| "Good deeds did not parse!");
        let bad_deeds: Result<_, &str> =  columns
                                .next()
                                .ok_or("Bad deeds is missing!")?
                                .trim()
                                .parse()
                                .map_err(|_| "Bad deeds did not 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
    }
}

Orchid Manor

arcnemesys

5 days ago

5.34ms

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 split_row = csv_row.split(",");
        let name = split_row
            .next()
            .ok_or("Missing field")?
            .to_string();
        let good_deeds: u32 = split_row
            .next()
            .ok_or("Missing field")?
            .parse()
            .map_err(|_| "Unable to parse good deeds.")?;
        let bad_deeds = split_row
            .next()
            .ok_or("Missing field")?
            .parse()
            .map_err(|_| "Unable 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
    }
}