Day 4: Structifying the Naughty List

Santa burst into the dev lounge, chugging his third espresso. "Great job yesterday, nerds! The is_nice function? Chef's kiss. But now, I want structure. STRUCTURE! We’re going full-on Rustacean. I need a Kid struct—immediately!"

The elves nodded enthusiastically, their tiny laptops open, running Arch Linux with bspwm because, obviously, they were that kind of devs. One elf, started yapping, "But Santa, why a struct? Isn’t this just overengineered?"

Santa slammed the table, shaking an untouched tray of gluten-free cookies. "No! A struct means no more random strings floating around. We need to encapsulate a kid's data—name, and niceness score. Plus, we’ll need some methods to make sense of it all."

The dev elves scrambled to work. In no time, they sketched out the basic blueprint. Santa glanced at the screen. "Not bad. But I will need this extended later. Keep it modular, bros!"

The room fell silent as the elves realized the implications. This was just the beginning of Santa’s unhinged data modeling spree.

Your Task

The elves need your help to finish the Kid struct.

Here is what you need to do:

Add two variants to the Niceness enum: Nice and Naughty. Nice takes the number of good deeds.
Add two fields to the Kid struct: name of type String and niceness of type Niceness.
Move the is_nice function we created on Day 3 to an associated function of the Kid struct.
Finally, implement the new() associated function for the Kid struct.

Hints

If you're stuck, here are some hints to help you get back on track:

Open the Hints!

Use Nice(u32) to represent the number of good deeds.
To define a field in a struct, use the syntax field_name: field_type, e.g., name: String.
An associated function is defined in the impl block without the self parameter.
Associated functions are called with :: instead of ., e.g. Kid::is_nice(10, 1);
Use Self::is_nice or Kid::is_nice to call the associated function from within the impl block.

Editor not available on Mobile!

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

Solutions

Adetola Ogunbanwo

Denched

2 days ago

5.24ms

87.41kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)] // needed for tests
pub enum Niceness {
    // Create the enum variants `Nice` and `Naughty`
    // Variant `Nice` is a tuple struct that holds the number of good deeds
    Nice(u32),
    Naughty,
}
pub struct Kid {
    // Add a field `name` of type `String`
    // and `niceness` field of type `Niceness`
    // Make all fields public
    pub name: String,
    pub niceness: Niceness,
}
// Move yesterday's function to an associated function in the struct
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        // Return a Kid instance
        // Kid::is_nice(good_deeds, bad_deeds)
        Kid {
            name,
            niceness: if Kid::is_nice(good_deeds, bad_deeds) {
                Niceness::Nice(good_deeds)
            } else {
                Niceness::Naughty
            }
        }
    }
    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
}
}

petrokropyvatablet-dotcom

5 days ago

7.12ms

87.41kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)] // needed for tests
pub enum Niceness {
    // Create the enum variants `Nice` and `Naughty`
    // Variant `Nice` is a tuple struct that holds the number of good deeds
    Nice(u32),
    Naughty,
}
pub struct Kid {
    // Add a field `name` of type `String`
    // and `niceness` field of type `Niceness`
    // Make all fields public
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        // Return a Kid instance
        Self {
            name,
            niceness: if Self::is_nice(good_deeds, bad_deeds) {
                Niceness::Nice(good_deeds)
            } else {
                Niceness::Naughty
            }
        }
    }
    // Move yesterday's function to an associated function in the struct
    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
    }
}

blackdeath1346

5 days ago

4.21ms

87.41kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)] // needed for tests
pub enum Niceness 
{
    Naughty,
    Nice(u32),
    // Create the enum variants `Nice` and `Naughty`
    // Variant `Nice` is a tuple struct that holds the number of good deeds
}
pub struct Kid 
{
    pub name :String,
    pub niceness :Niceness,
    // Add a field `name` of type `String`
    // and `niceness` field of type `Niceness`
    // Make all fields public
}
// Move yesterday's function to an associated function in the struct
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid 
    {
        let niceness: Niceness;
        if Self::is_nice(good_deeds,bad_deeds)
        {
            niceness=Niceness::Nice(good_deeds);
        }
        else
        {
            niceness=Niceness::Naughty;
        }
        return Kid{name: name, niceness: niceness };
        // Return a Kid instance
    }
    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
    }
}

beev

beevv

11 days ago

4.07ms

87.41kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)] // needed for tests
pub enum Niceness {
    // Create the enum variants `Nice` and `Naughty`
    // Variant `Nice` is a tuple struct that holds the number of good deeds
    Nice(u32),
    Naughty
}
pub struct Kid {
    // Add a field `name` of type `String`
    // and `niceness` field of type `Niceness`
    // Make all fields public
    pub name: String,
    pub niceness: Niceness
}
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        // Return a Kid instance
        Self {
            name: name,
            niceness: if Self::is_nice(good_deeds, bad_deeds) {
                Niceness::Nice(good_deeds)
            } else {
                Niceness::Naughty
            }
        }
    }
    // Move yesterday's function to an associated function in the struct
    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
    }
}

jfloresremar

12 days ago

3.31ms

87.41kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)] // needed for tests
pub enum Niceness {
    // Create the enum variants `Nice` and `Naughty`
    // Variant `Nice` is a tuple struct that holds the number of good deeds
    Nice(u32),
    Naughty
}
pub struct Kid {
    // Add a field `name` of type `String`
    // and `niceness` field of type `Niceness`
    // Make all fields public
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        Self{
            name,
            niceness: if Kid::is_nice(good_deeds, bad_deeds) {
                Niceness::Nice(good_deeds)
            } else {
                Niceness::Naughty
            }
        }
    }
    // Move yesterday's function to an associated function in the struct
    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
    }
}

StevenCanDrink

12 days ago

4.44ms

87.41kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)] // needed for tests
pub enum Niceness {
    // Create the enum variants `Nice` and `Naughty`
    // Variant `Nice` is a tuple struct that holds the number of good deeds
    Nice(u32),
    Naughty,
}
pub struct Kid {
    // Add a field `name` of type `String`
    // and `niceness` field of type `Niceness`
    // Make all fields public
    pub name: String,
    pub niceness: Niceness,
}
// Move yesterday's function to an associated function in the struct
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
}
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        // Return a Kid instance
        Self {
            name: name,
            niceness: if is_nice(good_deeds, bad_deeds) {
                Niceness::Nice(good_deeds)
            } else {
                Niceness::Naughty
            },
        }
    }
}

Erik Zhao

zhaoerik

14 days ago

3.42ms

87.41kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)] // needed for tests
pub enum Niceness {
    // Create the enum variants `Nice` and `Naughty`
    // Variant `Nice` is a tuple struct that holds the number of good deeds
    Nice(u32),
    Naughty,
}
pub struct Kid {
    // Add a field `name` of type `String`
    // and `niceness` field of type `Niceness`
    // Make all fields public
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Self {
        // Return a Kid instance
        Self {
            name,
            niceness: if Self::is_nice(good_deeds, bad_deeds) == true {
                Niceness::Nice(good_deeds)
            } else {
                Niceness::Naughty
            }
        }
    }
    // Move yesterday's function to an associated function in the struct
    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
    }
}

Alex Conley

aconley

15 days ago

3.61ms

87.41kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[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 new(name: String, good_deeds: u32, bad_deeds: u32) -> Self {
        Self {
            name,
            niceness: if Self::is_nice(good_deeds, bad_deeds) {
                Niceness::Nice(good_deeds)
            } else {
                Niceness::Naughty
            }
        }
    }
    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
    }
}

PommeYe

15 days ago

4.11ms

87.41kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)] // needed for tests
pub enum Niceness {
    Nice(u32),
    Naughty,
    // Create the enum variants `Nice` and `Naughty`
    // Variant `Nice` is a tuple struct that holds the number of good deeds
}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
    // Add a field `name` of type `String`
    // and `niceness` field of type `Niceness`
    // Make all fields public
}
// Move yesterday's function to an associated function in the struct
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
}
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        // Return a Kid instance
        if is_nice(good_deeds, bad_deeds) {
            Kid {
                name: name,
                niceness: Niceness::Nice(good_deeds)
            }
        } 
        else {
            Kid {
                name: name, 
                niceness: Niceness::Naughty
            }
        }
    }
}

capra1x0

15 days ago

3.38ms

87.41kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)] // needed for tests
pub enum Niceness {
    // Create the enum variants `Nice` and `Naughty`
    // Variant `Nice` is a tuple struct that holds the number of good deeds
    Nice(u32),
    Naughty,
}
pub struct Kid {
    // Add a field `name` of type `String`
    // and `niceness` field of type `Niceness`
    // Make all fields public
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        // Return a Kid instance
        return Kid {
            name: name,
            niceness: if Kid::is_nice(good_deeds, bad_deeds) {Niceness::Nice(good_deeds)} else {Niceness::Naughty}
        }
    }
    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
    }
}

msned

17 days ago

3.83ms

87.41kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)] // needed for tests
pub enum Niceness {
    // Create the enum variants `Nice` and `Naughty`
    // Variant `Nice` is a tuple struct that holds the number of good deeds
    Nice(u32),
    Naughty,
}
pub struct Kid {
    // Add a field `name` of type `String`
    // and `niceness` field of type `Niceness`
    // Make all fields public
    pub name : String,
    pub niceness : Niceness,
}
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        match Kid::is_nice(good_deeds,bad_deeds){
            true => Kid{name,niceness : Niceness::Nice(good_deeds)},
            false => Kid{name,niceness : Niceness::Naughty},
        }
    }
    // Move yesterday's function to an associated function in the struct
    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
    }
}

TheJanzap

19 days ago

3.36ms

87.41kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)] // needed for tests
pub enum Niceness {
    // Create the enum variants `Nice` and `Naughty`
    // Variant `Nice` is a tuple struct that holds the number of good deeds
    Nice(u32),
    Naughty,
}
pub struct Kid {
    // Add a field `name` of type `String`
    // and `niceness` field of type `Niceness`
    // Make all fields public
    pub name: String,
    pub niceness: Niceness,
}
// Move yesterday's function to an associated function in the struct
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        // Return a Kid instance
        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
    }
}

asdf

nitipot

20 days ago

3.84ms

87.41kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)] // needed for tests
pub enum Niceness {
    // Create the enum variants `Nice` and `Naughty`
    // Variant `Nice` is a tuple struct that holds the number of good deeds
    Nice(u32),
    Naughty
}
pub struct Kid {
    // Add a field `name` of type `String`
    // and `niceness` field of type `Niceness`
    // Make all fields public
    pub name: String,
    pub niceness: Niceness
}
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        // Return a Kid instance
        
        return Kid {
            name: name,
            niceness: if (Kid::is_nice(good_deeds, bad_deeds)) {Niceness::Nice(good_deeds)} else {Niceness::Naughty}
        }
    }
    // Move yesterday's function to an associated function in the struct
    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
    }
}

Emre Erbekin

erbekin

21 days ago

5.95ms

87.41kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)] // needed for tests
pub enum Niceness {
    // Create the enum variants `Nice` and `Naughty`
    // Variant `Nice` is a tuple struct that holds the number of good deeds
    Nice(u32),
    Naughty
}
pub struct Kid {
    // Add a field `name` of type `String`
    // and `niceness` field of type `Niceness`
    // Make all fields public
    pub name : String,
    pub niceness : Niceness,
}
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        // Return a Kid instance
        Kid {
            name,
            niceness : if Self::is_nice(good_deeds, bad_deeds) {
                    Niceness::Nice(good_deeds)
                } else {
                    Niceness::Naughty
                }
            }
    }
    // Move yesterday's function to an associated function in the struct
    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
    }
    
}

Spider

spider076

22 days ago

4.12ms

87.41kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)] // needed for tests
pub enum Niceness {
    // Create the enum variants `Nice` and `Naughty`
    // Variant `Nice` is a tuple struct that holds the number of good deeds
    Nice(u32),
    Naughty,
}
#[derive(Debug)]
pub struct Kid {
    // Add a field `name` of type `String`
    // and `niceness` field of type `Niceness`
    // Make all fields public
    pub name: String,
    pub niceness: Niceness,
}
// Move yesterday's function to an associated function in the struct
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
}
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        let isnice_result = is_nice(good_deeds, bad_deeds);
        let nice_enum: Niceness;
        if isnice_result {
            nice_enum = Niceness::Nice(good_deeds);
        } else {
            nice_enum = Niceness::Naughty;
        }
        // Return a Kid instance
        return Kid {
            name: name,
            niceness: nice_enum,
        };
    }
}

wdcs-tusharnagar

23 days ago

4.51ms

87.41kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)] // needed for tests
pub enum Niceness {
    // Create the enum variants `Nice` and `Naughty`
    // Variant `Nice` is a tuple struct that holds the number of good deeds
    Nice(u32),
    Naughty
}
pub struct Kid {
    // Add a field `name` of type `String`
    pub name:String,
    // and `niceness` field of type `Niceness`
    pub niceness:Niceness,
    // Make all fields public
}
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        if Kid::is_nice(good_deeds,bad_deeds){
            return Kid{
            name:name,
            niceness: Niceness::Nice(good_deeds)
        }}else {
            return Kid{
            name:name,
            niceness: Niceness::Naughty
        }
        }
        
    }
    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
}
}

wdcs-tusharnagar

23 days ago

3.73ms

87.41kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)] // needed for tests
pub enum Niceness {
    // Create the enum variants `Nice` and `Naughty`
    // Variant `Nice` is a tuple struct that holds the number of good deeds
    Nice(u32),
    Naughty
}
pub struct Kid {
    // Add a field `name` of type `String`
    pub name:String,
    // and `niceness` field of type `Niceness`
    pub niceness:Niceness,
    // Make all fields public
}
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        if Self::is_nice(good_deeds,bad_deeds){
            return Kid{
            name:name,
            niceness: Niceness::Nice(good_deeds)
        }}else {
            return Kid{
            name:name,
            niceness: Niceness::Naughty
        }
        }
        
    }
    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
}
}

Marcin

panpilkarz

23 days ago

4.23ms

87.41kb

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 is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        let ratio = (good_deeds as f32) / (good_deeds + 2 * bad_deeds) as f32;
        ratio >= 0.75
    }
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Self {
        if Self::is_nice(good_deeds, bad_deeds) {
            Kid{name, niceness: Niceness::Nice(good_deeds)}
        }
        else {
            Kid{name, niceness: Niceness::Naughty}
        }
    }
}

idorocodes

24 days ago

3.42ms

87.41kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)] // needed for tests
pub enum Niceness {
    // Create the enum variants `Nice` and `Naughty`
    // Variant `Nice` is a tuple struct that holds the number of good deeds
    Nice(u32),
    Naughty,
    
}
pub struct Kid {
    // Add a field `name` of type `String`
    // and `niceness` field of type `Niceness`
    // Make all fields public
   pub  name:String,
   pub  niceness:Niceness
}
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        // Return a Kid instance
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Self { name, niceness }
    }
    // Move yesterday's function to an associated function in the struct
    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
}
}

idorocodes

24 days ago

4.35ms

87.41kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)] // needed for tests
pub enum Niceness {
    // Create the enum variants `Nice` and `Naughty`
    // Variant `Nice` is a tuple struct that holds the number of good deeds
    Nice(u32),
    Naughty,
    
}
pub struct Kid {
    // Add a field `name` of type `String`
    // and `niceness` field of type `Niceness`
    // Make all fields public
   pub  name:String,
   pub  niceness:Niceness
}
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        // Return a Kid instance
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Self { name, niceness }
    }
    // Move yesterday's function to an associated function in the struct
    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
}
}

rap1 ラピ

srcrapi

24 days ago

3.61ms

87.41kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)] // needed for tests
pub enum Niceness {
    // Create the enum variants `Nice` and `Naughty`
    // Variant `Nice` is a tuple struct that holds the number of good deeds
    Nice(u32),
    Naughty
}
pub struct Kid {
    // Add a field `name` of type `String`
    // and `niceness` field of type `Niceness`
    // Make all fields public
    pub name: String,
    pub niceness: Niceness
}
// Move yesterday's function to an associated function in the struct
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        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 Kintsel

sergey-kintsel

a month ago

4.57ms

87.41kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)] // needed for tests
pub enum Niceness {
    // Create the enum variants `Nice` and `Naughty`
    // Variant `Nice` is a tuple struct that holds the number of good deeds
    Nice(u32),
    Naughty
}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
    // Add a field `name` of type `String`
    // and `niceness` field of type `Niceness`
    // Make all fields public
}
// Move yesterday's function to an associated function in the struct
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
}
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        let niceness = if is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Kid { name, niceness }
    }
    
}

lleongch

a month ago

3.74ms

87.41kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)] // needed for tests
pub enum Niceness {
    // Create the enum variants `Nice` and `Naughty`
    // Variant `Nice` is a tuple struct that holds the number of good deeds
    Nice(u32),
    Naughty
}
pub struct Kid {
    // Add a field `name` of type `String`
    // and `niceness` field of type `Niceness`
    // Make all fields public
    pub name: String,
    pub niceness: Niceness
}
// Move yesterday's function to an associated function in the struct
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        // Return a Kid instance
        Kid {
            name,
            niceness: Self::is_nice(good_deeds,bad_deeds)
        } 
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> Niceness {
    if good_deeds == 0 && bad_deeds == 0 {
        return Niceness::Naughty;
    }
    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);
    if ratio >= 0.75 {
        Niceness::Nice(good_deeds as u32)
    }else {
        Niceness::Naughty
    }
}
}

Nguyễn Trương Quang

ntquang98

a month ago

3.44ms

87.41kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)] // needed for tests
pub enum Niceness {
    // Create the enum variants `Nice` and `Naughty`
    // Variant `Nice` is a tuple struct that holds the number of good deeds
    Nice(u32),
    Naughty
}
pub struct Kid {
    // Add a field `name` of type `String`
    // and `niceness` field of type `Niceness`
    // Make all fields public
    pub name: String,
    pub niceness: Niceness,
}
// Move yesterday's function to an associated function in the struct
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
}
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        // Return a Kid instance
        let niceness = if is_nice(good_deeds, bad_deeds) { Niceness::Nice(good_deeds) } else { Niceness::Naughty };
        
        Kid { name, niceness }
    }
}

GavFred

a month ago

3.49ms

87.41kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)] // needed for tests
pub enum Niceness {
    // Create the enum variants `Nice` and `Naughty`
    // Variant `Nice` is a tuple struct that holds the number of good deeds
    Nice(u32),
    Naughty,
}
pub struct Kid {
    // Add a field `name` of type `String`
    // and `niceness` field of type `Niceness`
    // Make all fields public
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        let niceness = match Kid::is_nice(good_deeds, bad_deeds) {
            true => Niceness::Nice(good_deeds),
            false => Niceness::Naughty,
        };
        // Return a Kid instance
        Kid {
            name,
            niceness,
        }
    }
    // Move yesterday's function to an associated function in the struct
    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
    }
}

Smith, Taylor

a647965_fidelity

a month ago

3.82ms

87.41kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)] // needed for tests
pub enum Niceness {
    // Create the enum variants `Nice` and `Naughty`
    // Variant `Nice` is a tuple struct that holds the number of good deeds
    Nice(u32),
    Naughty,
}
pub struct Kid {
    // Add a field `name` of type `String`
    // and `niceness` field of type `Niceness`
    // Make all fields public
    pub name: String,
    pub niceness: Niceness,
}
// Move yesterday's function to an associated function in the struct
impl Kid {
    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
    }
}
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        Kid {
            name,
            niceness: if Kid::is_nice(good_deeds, bad_deeds) {
                Niceness::Nice(good_deeds)
            } else {
                Niceness::Naughty
            },
        }
    }
}

Keegan Conlee

dacid44

a month ago

3.33ms

87.41kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)] // needed for tests
pub enum Niceness {
    // Create the enum variants `Nice` and `Naughty`
    // Variant `Nice` is a tuple struct that holds the number of good deeds
    Nice(u32),
    Naughty,
}
pub struct Kid {
    // Add a field `name` of type `String`
    // and `niceness` field of type `Niceness`
    // Make all fields public
    pub name: String,
    pub niceness: Niceness,
}
// Move yesterday's function to an associated function in the struct
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        // Return a Kid instance
        Self {
            name,
            niceness: if Self::is_nice(good_deeds, bad_deeds) {
                Niceness::Nice(good_deeds)
            } else {
                Niceness::Naughty
            }
        }
    }
    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
    }
}

cmdrtomalak

a month ago

3.40ms

87.41kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)] // needed for tests
pub enum Niceness {
    // Create the enum variants `Nice` and `Naughty`
    // Variant `Nice` is a tuple struct that holds the number of good deeds
    Nice(u32),
    Naughty,
}
pub struct Kid {
    // Add a field `name` of type `String`
    // and `niceness` field of type `Niceness`
    // Make all fields public
    pub name: String,
    pub niceness: Niceness,
}
// Move yesterday's function to an associated function in the struct
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
}
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        // Return a Kid instance
        let niceness = if is_nice(good_deeds, bad_deeds) { Niceness::Nice(good_deeds) } else { Niceness::Naughty };
        Kid {
            name,
            niceness,
        }
    }
}

Yashwanth

Yash981

a month ago

3.34ms

87.41kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)] // needed for tests
pub enum Niceness {
    // Create the enum variants `Nice` and `Naughty`
    // Variant `Nice` is a tuple struct that holds the number of good deeds
    Nice(u32),
    Naughty
}
pub struct Kid {
    // Add a field `name` of type `String`
    // and `niceness` field of type `Niceness`
    // Make all fields public
    pub name:String,
    pub niceness:Niceness
}
// Move yesterday's function to an associated function in the struct
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        // Return a Kid instance
        let niceness_status = if Kid::is_nice(good_deeds,bad_deeds){
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Kid {
            name,
            niceness:niceness_status
        }
    }
    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
    }
}

Tre1z

a month ago

3.79ms

87.41kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)] // needed for tests
pub enum Niceness {
    // Create the enum variants `Nice` and `Naughty`
    // Variant `Nice` is a tuple struct that holds the number of good deeds
    Nice(u32),
    Naughty
}
pub struct Kid {
    // Add a field `name` of type `String`
    // and `niceness` field of type `Niceness`
    // Make all fields public
    pub name: String,
    pub niceness: Niceness
}
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        // Return a Kid instance
        Self {
            name,
            niceness: match Self::is_nice(good_deeds, bad_deeds) {
                true => Niceness::Nice(good_deeds),
                false => Niceness::Naughty
            }
        }
    }
    // Move yesterday's function to an associated function in the struct
    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
    }
}

Fanzzzd

a month ago

4.25ms

87.41kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)] // needed for tests
pub enum Niceness {
    // Create the enum variants `Nice` and `Naughty`
    Nice(u32),
    Naughty
    // Variant `Nice` is a tuple struct that holds the number of good deeds
}
pub struct Kid {
    // Add a field `name` of type `String`
    // and `niceness` field of type `Niceness`
    // Make all fields public
    pub name:String,
    pub niceness:Niceness
}
// Move yesterday's function to an associated function in the struct
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
}
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        Kid {
            name,
            niceness: 
                match is_nice(good_deeds, bad_deeds) {
                    true => Niceness::Nice(good_deeds),
                    _ => Niceness::Naughty
                }
        }
    }
}

Andrea Zoleo

andrea-zoleo

a month ago

4.10ms

87.41kb

use crate::Niceness::Nice;
use crate::Niceness::Naughty;
pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)] // needed for tests
pub enum Niceness {
    // Create the enum variants `Nice` and `Naughty`
    // Variant `Nice` is a tuple struct that holds the number of good deeds
    Nice(u32),
    Naughty
}
pub struct Kid {
    // Add a field `name` of type `String`
    // and `niceness` field of type `Niceness`
    // Make all fields public
    pub name: String,
    pub niceness: Niceness
}
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        // Return a Kid instance
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Nice(good_deeds)
        } else {
            Naughty
        };
        Kid{ name, niceness }
    }
    // Move yesterday's function to an associated function in the struct
    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

a month ago

3.55ms

87.41kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)] // needed for tests
pub enum Niceness {
    Nice(u32),
    Naughty
    // Create the enum variants `Nice` and `Naughty`
    // Variant `Nice` is a tuple struct that holds the number of good deeds
}
pub struct Kid {
    pub name : String,
    pub niceness:Niceness
    // Add a field `name` of type `String`
    // and `niceness` field of type `Niceness`
    // Make all fields public
}
// Move yesterday's function to an associated function in the struct
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
}
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        Kid {name,
             niceness : match is_nice(good_deeds, bad_deeds){
                true => Niceness::Nice(good_deeds),
                false => Niceness::Naughty
            }
        }
    }
}

kogernik

a month ago

3.65ms

87.41kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)] // needed for tests
pub enum Niceness {
    // Create the enum variants `Nice` and `Naughty`
    // Variant `Nice` is a tuple struct that holds the number of good deeds
    Nice(u32),
    Naughty
}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
    // Add a field `name` of type `String`
    // and `niceness` field of type `Niceness`
    // Make all fields public
}
impl Kid {
}
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        Kid {
            name,
            niceness: if Self::is_nice(good_deeds, bad_deeds) {
                Niceness::Nice(good_deeds)
            } else {
                Niceness::Naughty
            }
        }
    }
// Move yesterday's function to an associated function in the struct
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 month ago

3.51ms

87.41kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)] // needed for tests
pub enum Niceness {
    // Create the enum variants `Nice` and `Naughty`
    // Variant `Nice` is a tuple struct that holds the number of good deeds
    Nice(u32),
    Naughty,
}
pub struct Kid {
    // Add a field `name` of type `String`
    // and `niceness` field of type `Niceness`
    // Make all fields public
    pub name: String,
    pub niceness: Niceness,
}
// Move yesterday's function to an associated function in the struct
impl Kid {
    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
    }
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        match Self::is_nice(good_deeds, bad_deeds) {
            true => Kid {
                name: name,
                niceness: Niceness::Nice(good_deeds),
            },
            false => Kid {
                name: name,
                niceness: Niceness::Naughty,
            },
        }
    }
}

Prashant Puri

Prashant-dot1

2 months ago

4.02ms

87.41kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)] // needed for tests
pub enum Niceness {
    // Create the enum variants `Nice` and `Naughty`
    // Variant `Nice` is a tuple struct that holds the number of good deeds
    Nice(u32),
    Naughty
}
pub struct Kid {
    // Add a field `name` of type `String`
    // and `niceness` field of type `Niceness`
    // Make all fields public
    pub name: String,
    pub niceness: Niceness
}
// Move yesterday's function to an associated function in the struct
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        // Return a Kid instance
        let result = Kid::is_nice(good_deeds, bad_deeds);
        match result {
            true => { Self {
                name,
                niceness: Niceness::Nice(good_deeds)
            }
            },
            false => { Self {
                name,
                niceness: Niceness::Naughty
            }
            }
        }
    }
    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
    }
}

Varun D

varun-d

2 months ago

3.69ms

87.41kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)] // needed for tests
pub enum Niceness {
    Nice(u32),
    Naughty,
    // Create the enum variants `Nice` and `Naughty`
    // Variant `Nice` is a tuple struct that holds the number of good deeds
}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
    // Add a field `name` of type `String`
    // and `niceness` field of type `Niceness`
    // Make all fields public
}
// Move yesterday's function to an associated function in the struct
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        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

2 months ago

4.30ms

87.41kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)] // needed for tests
pub enum Niceness {
    // Create the enum variants `Nice` and `Naughty`
    // Variant `Nice` is a tuple struct that holds the number of good deeds
    Nice(u32),
    Naughty,
}
pub struct Kid {
    // Add a field `name` of type `String`
    pub name: String,
    // and `niceness` field of type `Niceness`
    pub niceness: Niceness,
    // Make all fields public
}
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Self {
            name,
            niceness,
        }
    }
    // Move yesterday's function to an associated function in the struct
    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

2 months ago

3.08ms

87.41kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)] // needed for tests
pub enum Niceness {
    // Create the enum variants `Nice` and `Naughty`
    // Variant `Nice` is a tuple struct that holds the number of good deeds
    Nice(u32),
    Naughty,
}
pub struct Kid {
    // Add a field `name` of type `String`
    // and `niceness` field of type `Niceness`
    // Make all fields public
    pub name: String,
    pub niceness: Niceness,
}
// Move yesterday's function to an associated function in the struct
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
}
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        // Return a Kid instance
        let mut niceness: Niceness;
        if is_nice(good_deeds, bad_deeds) {
            niceness = Niceness::Nice(good_deeds);
        } else {
            niceness = Niceness::Naughty
        }
        
        Kid { name: name, niceness: niceness}
    }
}

Spheniscine

2 months ago

3.41ms

87.41kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)] // needed for tests
pub enum Niceness {
    // Create the enum variants `Nice` and `Naughty`
    // Variant `Nice` is a tuple struct that holds the number of good deeds
    Nice(u32), Naughty
}
pub struct Kid {
    // Add a field `name` of type `String`
    // and `niceness` field of type `Niceness`
    // Make all fields public
    pub name: String,
    pub niceness: Niceness,
}
// Move yesterday's function to an associated function in the struct
impl Kid {
    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
    }
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        Kid {
            name, 
            niceness: if Self::is_nice(good_deeds, bad_deeds) {Niceness::Nice(good_deeds)} else {Niceness::Naughty}
        }
    }
}

Andreas Lundin

andreaslundin47

2 months ago

3.63ms

87.41kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)] // needed for tests
pub enum Niceness {
    // Create the enum variants `Nice` and `Naughty`
    // Variant `Nice` is a tuple struct that holds the number of good deeds
    Nice(u32),
    Naughty,
}
pub struct Kid {
    // Add a field `name` of type `String`
    // and `niceness` field of type `Niceness`
    // Make all fields public
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        // Return a Kid instance
        let niceness = if Kid::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Kid { name, niceness }
    }
    // Move yesterday's function to an associated function in the struct
    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

2 months ago

3.65ms

87.41kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)] // needed for tests
pub enum Niceness {
    Naughty,
    Nice(u32)
    // Create the enum variants `Nice` and `Naughty`
    // Variant `Nice` is a tuple struct that holds the number of good deeds
}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness
    // Add a field `name` of type `String`
    // and `niceness` field of type `Niceness`
    // Make all fields public
}
// Move yesterday's function to an associated function in the struct
impl Kid {
    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
    }
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        if Kid::is_nice(good_deeds, bad_deeds) {
            Kid {
                name,
                niceness: Niceness::Nice(good_deeds)
            }
        } else {
            Kid {
                name,
                niceness: Niceness::Naughty
            }
        }
    }
}

HackDabbler

2 months ago

3.49ms

87.41kb

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 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
    }
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        let n = Kid::is_nice(good_deeds, bad_deeds);
        let niceness = if n { Niceness::Nice(good_deeds) } else { Niceness::Naughty };
        Self {
            name: name,
            niceness: niceness,
        }
    }
}

palcoo42

2 months ago

3.49ms

87.41kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)] // needed for tests
pub enum Niceness {
    // Create the enum variants `Nice` and `Naughty`
    // Variant `Nice` is a tuple struct that holds the number of good deeds
    Nice (u32),
    Naughty
}
pub struct Kid {
    // Add a field `name` of type `String`
    // and `niceness` field of type `Niceness`
    // Make all fields public
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) { Niceness::Nice(good_deeds) } else { Niceness::Naughty };
        Self {
            name,
            niceness,
        }
    }
    // Move yesterday's function to an associated function in the struct
    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

2 months ago

4.20ms

87.41kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[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 new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        let niceness = if Kid::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Kid {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

2 months ago

4.11ms

87.41kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)] // needed for tests
pub enum Niceness {
    Nice(u32),
    Naughty
    // Create the enum variants `Nice` and `Naughty`
    // Variant `Nice` is a tuple struct that holds the number of good deeds
}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness
    // Add a field `name` of type `String`
    // and `niceness` field of type `Niceness`
    // Make all fields public
}
// Move yesterday's function to an associated function in the struct
impl Kid {
    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
    }
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        Kid {
            name,
            niceness: match Kid::is_nice(good_deeds, bad_deeds) {
                true => Niceness::Nice(good_deeds),
                false => Niceness::Naughty
            }
        }
    }
}

johndoe30bc

2 months ago

3.52ms

87.41kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[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 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

2 months ago

3.77ms

87.41kb

pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)] // needed for tests
pub enum Niceness {
    Nice(u32),
    Naughty
}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness
}
// Move yesterday's function to an associated function in the struct
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        let niceness = match Kid::is_nice(good_deeds, bad_deeds) {
                true => Niceness::Nice(good_deeds),
                false => 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

2 months ago

3.65ms

87.41kb

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 Niceness {
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> Self {
        if good_deeds == 0 && bad_deeds == 0 {
            return Self::Naughty;
        }
        let good_deeds_weighted = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds_weighted = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds_weighted / (good_deeds_weighted + bad_deeds_weighted);
        
        if ratio >= 0.75 {
            Self::Nice(good_deeds)
        } else {
            Self::Naughty
        }
    }
}
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        Self {
            name,
            niceness: Niceness::is_nice(good_deeds, bad_deeds),
        }
    }
}

Wouter

WouterMartens

2 months ago

4.33ms

87.41kb

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,
}
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;
    good_deeds / (good_deeds + bad_deeds) >= 0.75
}
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        Self {
            name,
            niceness: match is_nice(good_deeds, bad_deeds) {
                true => Niceness::Nice(good_deeds),
                false => Niceness::Naughty,
            },
        }
    }
}