public/subjects/sales

sales

Instructions

You will have to create a shopping system, where you will have a :

• Store that will save all the products in it
• Cart that will have items, that the client will buy, and a receipt

This store is having a promotion, "Buy three and get one for free" (the free item must be the cheapest). The receipt must not present any value as 0, so you will have to apply the promotion to all items instead.

Expected Function

#[derive(Debug, Clone)]
pub struct Store {
    pub products: Vec<(String, f32)>,
}
impl Store {
    pub fn new(products: Vec<(String, f32)>) -> Store {
        Store { products }
    }
}

#[derive(Debug, Clone)]
pub struct Cart {
    // expected public fields
}
impl Cart {
    pub fn new() -> Cart {}
    pub fn insert_item(&mut self, s: &Store, ele: String) {}
    pub fn get_prices(&self) -> Vec<f32> {}
    pub fn generate_receipt(&mut self) -> Vec<f32> {}
}

Example

[1.23, 3.12, 23.1] -> receipt will be [1.17, 2.98, 22.07]

So 1.17 + 2.98 + 22.07 == 3.12 + 23.1 + 0

This is a percentage calculation, and it can be applied to a set of three items. If the client purchase 9 items it will be applied the promotion, three for free, to all items

|--------------| |---------------| |---------------| [1.23, 23.1, 3.12, 9.75, 1.75, 23.75, 2.75, 1.64, 15.23] -> receipt will be [1.16, 1.55, 1.65, 2.6, 2.94, 9.2, 14.38, 21.8, 22.42]

|--------| |--------| |--------| [3.12, 9.75, 1.75, 23.75, 2.75, 1.64, 15.23] -> receipt will be [1.54, 1.65, 2.59, 2.94, 9.18, 14.34, 22.36]

and so on... (hint: Closures is the way)

You will have to implement for the Cart structure the following function:

• new, that will initialize the cart
• insert_item, that will receive a reference to Store and a String. Just like the name says you will have to insert the item to the cart
• generate_receipt, that returns a vector of sorted floats. This function must generate the receipt just like the example above, using the promotion. Also saving the result in the filed receipt.

Usage

Here is a program to test your function

fn main() {
    let store = Store::new(vec![
        (String::from("product A"), 1.23),
        (String::from("product B"), 23.1),
        (String::from("product C"), 3.12)]);

    println!("{:?}", store);

    let mut cart = Cart::new();
    cart.insert_item(&store, String::from("product A"));
    cart.insert_item(&store, String::from("product B"));
    cart.insert_item(&store, String::from("product C"));

    println!("{:?}", cart.generate_receipt());

    println!("{:?}", cart);
}

And its output:

student@ubuntu:~/[[ROOT]]/test$ cargo run
Store { products: [("product A", 1.23), ("product B", 23.1), ("product C", 3.12)] }
[1.17, 2.98, 22.07]
Cart { items: [("product A", 1.23), ("product B", 23.1), ("product C", 3.12)], receipt: [1.17, 2.98, 22.07] }
student@ubuntu:~/[[ROOT]]/test$

Notions

• https://doc.rust-lang.org/rust-by-example/fn/closures.html