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

Krzysztof Figaj

kfigaj

2 days ago

3.76ms

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
        match Self::is_nice(good_deeds, bad_deeds) {
            true => Self {
                        name: name,
                        niceness: Niceness::Nice(good_deeds),
                    },
            false => Self {
                        name: 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
    }
}

KalaayPT

3 days ago

3.68ms

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

Lucas Deprit

lucasdeprit

4 days ago

4.19ms

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

SilentCanon

silentcanon

6 days ago

3.48ms

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 {
        let niceness = match Kid::is_nice(good_deeds, bad_deeds) {
            true => Niceness::Nice(good_deeds),
            false => Niceness::Naughty
        };
        Kid {
            name: name,
            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;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}

Oleksii Khodakovskyi

Rezistencee

6 days ago

4.50ms

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) -> Self {
         Self {  
            name: name,
            niceness: if Self::is_nice(good_deeds, bad_deeds) == true {
                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
    }
}

Gaga889

7 days 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 {
    // 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`
    pub name: String,
    // and `niceness` field of type `Niceness`
    pub niceness: 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 {
        // Return a Kid instance        
        Self {  name: name,
                niceness: if Self::is_nice(good_deeds, bad_deeds) == true {
                    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
}
}

James Parkington

james-parky

7 days ago

4.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
        Kid {name: name, 
             niceness: match Kid::is_nice(good_deeds, bad_deeds) {
                true => Niceness::Nice(good_deeds),
                false => 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
}
}

Kishan Patel

KishanPatel4273

7 days ago

4.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,
}
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
    }
}

FredoPo

7 days ago

4.04ms

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 mut niceness = Niceness::Naughty;
        if Self::is_nice(good_deeds, bad_deeds) {
            niceness = Niceness::Nice(good_deeds);
        }
        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
    }
}

fivaya

7 days ago

4.60ms

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

Vebjørn Johansen Rognli

vebjornjr

9 days ago

3.98ms

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
        if Self::is_nice(good_deeds, bad_deeds) {
            Self {
                name,
                niceness: Niceness::Nice(good_deeds),
            }
        } else {
            Self {
                name,
                niceness: Niceness::Naughty,
            }
        }
    }
    // Move yesterday's function to an associated function in the struct
    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
    }
}

Jason Cheng

JasonCheng1

10 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 {
    // 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
    }
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        // Return a Kid instance
        match Kid::is_nice(good_deeds, bad_deeds) {
            true => Kid{name: name, niceness: Niceness::Nice(good_deeds)},
            false => Kid{name: name, niceness: Niceness::Naughty}
        }
    }
}

raj-klaviyo

10 days ago

3.47ms

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) -> 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 {
        return Niceness::Nice(good_deeds as u32)
    } else {
        return Niceness::Naughty
    }
}
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        Kid {
            name: name,
            niceness: is_nice(good_deeds, bad_deeds)
        }
    }
}

Christopher Nielson

c-nielson

10 days ago

3.78ms

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

Yi Hao

leongyihao

10 days ago

3.37ms

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

Kurisu-Null

10 days 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 {
    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 is_nice = Kid::is_nice(good_deeds, bad_deeds);
        Kid {
            name,
            niceness: if is_nice {
                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
    }
}

Kurisu-Null

10 days ago

3.22ms

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 is_nice = Kid::is_nice(good_deeds, bad_deeds);
        Kid {
            name,
            niceness: if is_nice {
                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
    }
}

Mahammed Numeez Baloch

Numeez

10 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 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){
            return Kid{
                name:name,
                niceness:Niceness::Nice(good_deeds)
            }
        }
         return Kid{
                name:name,
                niceness:Niceness::Naughty
            };
    }
}

rponcepore

11 days 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(i32),
    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 result_niceness = is_nice(good_deeds, bad_deeds);
        let good_deeds_i: i32 = good_deeds as i32;
        let niceness: Niceness;
        if result_niceness {
            niceness = Niceness::Nice(good_deeds_i);
        }else{
            niceness = Niceness::Naughty;
        }
        Kid {name, niceness}
    }
}

norabbito

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

Louis

tototomate123

12 days ago

6.73ms

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 niceness = if Kid::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Kid { name, niceness }
    }
}

anjanimaurya

13 days 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`
    // 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
        Kid{
            name,
            niceness:match is_nice(good_deeds, bad_deeds){
                true=> Niceness::Nice(good_deeds),
                false=> Niceness::Naughty,
            }
        }
        
    }
}

avilikof

13 days ago

3.59ms

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

sakulstar

18 days ago

3.10ms

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

Manu

wirew0lf

19 days ago

3.66ms

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(i32),
    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: name,
            niceness: Self::is_nice(good_deeds, bad_deeds)
        }
    }
    // Move yesterday's function to an associated function in the struct
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> Niceness {
        if good_deeds == 0 && bad_deeds == 0 {
            return Niceness::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 {
            Niceness::Nice(good_deeds as i32)
        } else {
            Niceness::Naughty
        }
    }
}

Ifediora Emmanuel

Manuelshub

19 days 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,
}
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        // Return a Kid instance
        let how_nice: bool = Self::is_nice(good_deeds, bad_deeds);
        let niceness = match how_nice {
            true => Niceness::Nice(good_deeds),
            false => Niceness::Naughty,
        };
        Kid {
            name: name,
            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
    }
}

christianbaumberger

22 days ago

3.64ms

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 {
        // Return a Kid instance
        let nice = Self::is_nice(good_deeds, bad_deeds);
        let niceness = match nice {
            true => Niceness::Nice(good_deeds),
            false => Niceness::Naughty,
        };
        Self {
            name: name,
            niceness: niceness
        }
    }
}

TaiPoole

23 days ago

4.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
    Naughty,
    Nice(u32)
}
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 {
        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
}
// Move yesterday's function to an associated function in the struct
}

tnsborum

23 days ago

8.72ms

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
    pub niceness: Niceness
}
// Move yesterday's function to an associated function in the struct
impl Kid {
    fn is_nice(good_deeds: u32, bad_deeds: u32) -> Niceness {
        let return_naugthy = Niceness::Naughty;
        let return_nice = Niceness::Nice(good_deeds.clone());
        
        if good_deeds == 0 && bad_deeds == 0 {
            
            return return_naugthy
        }
        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{
            return return_nice
        }else{
            return return_naugthy;
        }
    }
}
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
    // Return a Kid instance
        Kid {
            name: name,
            //niceness: Niceness::Naughty
            niceness: Kid::is_nice(good_deeds,bad_deeds)
        }
    }
}

Leandro Abreu

leandronowras

25 days ago

3.98ms

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 = match Self::is_nice(good_deeds, bad_deeds) {
            true => Niceness::Nice(good_deeds),
            _=> 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
    }
}

Meann Sen

meannzen

a month ago

4.32ms

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 {
        let niceness = match is_nice(good_deeds, bad_deeds) {
            true => Niceness::Nice(good_deeds),
            _=> Niceness::Naughty
        };
        Self {
            name,
            niceness
        }
    }
}

Patrick G

doeixd

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 {
    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 {
        // Return a Kid instance
        let nice = Kid::is_nice(good_deeds, bad_deeds);
        Kid {
            name: name,
            niceness: if nice { 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
    }
}

Chess Luo

chessl

a month 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 {
    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 {
        match Self::is_nice(good_deeds, bad_deeds) {
            true => Kid { name, niceness: Niceness::Nice(good_deeds)},
            false => Kid { name, niceness: 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
    }
}

zitro

0zitro

a month ago

3.39ms

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: match is_nice(good_deeds, bad_deeds) {
                true => Niceness::Nice(good_deeds),
                false => Niceness::Naughty
            }
        }
    }
}

Alex Ioannidis

slint

a month ago

3.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 {
    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: name,
            niceness: match Self::is_nice(good_deeds, bad_deeds) {
                true => Niceness::Nice(good_deeds),
                false => 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
    }
}

Lungile Maseko

Lu-TheCoder

a month ago

3.91ms

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

adli daffa

addffa

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

William Chu

uptickmetachu

a month 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 {
    // 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
    }
    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
        }
    }
}

aey4

a month ago

5.50ms

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:Niceness = match is_nice(good_deeds, bad_deeds){
            true => Niceness::Nice(good_deeds),
            false => Niceness::Naughty
        };
    Kid{
        name: name,
        niceness: niceness,
    }
    }
}

aey4

a month ago

3.68ms

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:Niceness = match is_nice(good_deeds, bad_deeds){
            true => Niceness::Nice(good_deeds),
            false => Niceness::Naughty
        };
    Kid{
        name: name,
        niceness: niceness,
    }
    }
}

Hideyuki Tanaka

tanakh

a month ago

5.09ms

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
        Kid {
            name,
            niceness: if is_nice(good_deeds, bad_deeds) {
                Niceness::Nice(good_deeds)
            } else {
                Niceness::Naughty
            }
        }
    }
}

Daniel Cadenas

dcadenas

a month ago

4.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
}
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
        };
        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
}
}

zafra147

a month ago

3.46ms

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
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 {
        match is_nice(good_deeds, bad_deeds) {
            true => Kid {name: name, niceness: Niceness::Nice(good_deeds) },
            false => Kid {name: name, niceness: Niceness::Naughty}
        }
    }
}

David Camdzic

david-camdzic

a month ago

3.37ms

87.41kb

pub const GOOD_WEIGHT: f64 = 1.0;
pub const BAD_WEIGHT: f64 = 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 Self::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 ratio = good_deeds as f64 / (good_deeds as f64 + (BAD_WEIGHT * bad_deeds as f64));
        if ratio >= 0.75 {
            true
        } else {
            false
        }
    }
}

Erik Werner

rikner

a month 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
}
// 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: Niceness = match is_nice(good_deeds, bad_deeds) {
            true => Niceness::Nice(good_deeds),
            false => Niceness::Naughty
        };
        Kid {
            name: name,
            niceness: niceness
        }
    }
}

KamiTrades

kamixbt

a month ago

3.75ms

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 : match Self::is_nice(good_deeds, bad_deeds) {
                true =>  Niceness::Nice(good_deeds),
                false => 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
}
}

ssvv0

a month ago

7.62ms

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`
    pub name: String,
    // and `niceness` field of type `Niceness`
    pub niceness: 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  Kid {
            name: name,
            niceness: match (is_nice(good_deeds, bad_deeds)) {
                true => Niceness::Nice(good_deeds),
                false => Niceness::Naughty 
            }
        }
 }
}

B L I

blietaer

a month ago

3.89ms

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 {
    // 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: Niceness;
        if Kid::is_nice(good_deeds, bad_deeds) {
            niceness = Niceness::Nice(good_deeds);
        } else {
            niceness = Niceness::Naughty;
        }
        Kid {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);
        if ratio >= 0.75 {
            return true
        }
        return false
    }
}

viky

vikyw89

a month ago

3.94ms

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 is_nice = is_nice(good_deeds, bad_deeds);
        if !is_nice {
            return Kid {
                name: name,
                niceness: Niceness::Naughty,
            };
        }
        return Kid {
            name: name,
            niceness: Niceness::Nice(good_deeds),
        };
    }
}

Eduardo Suárez Ojeda

edusu

a month ago

3.50ms

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
        Kid {
            name,
            niceness: match(is_nice(good_deeds, bad_deeds)) {
                true => {
                    Niceness::Nice(good_deeds)
                },
                false => {
                    Niceness::Naughty
                }
            }
        }
    }
}