1357. 每隔 n 个顾客打折

class Cashier:

    def __init__(self, n: int, discount: int, products: List[int], prices: List[int]):
        self.i = 0
        self.n = n
        self.discount = discount
        self.d = {a: b for a, b in zip(products, prices)}

    def getBill(self, product: List[int], amount: List[int]) -> float:
        self.i = (self.i + 1) % self.n
        x = sum(self.d[a] * b for a, b in zip(product, amount))
        if self.i == 0:
            return x - (self.discount * x) / 100
        return x


# Your Cashier object will be instantiated and called as such:
# obj = Cashier(n, discount, products, prices)
# param_1 = obj.getBill(product,amount)

class Cashier {
    private int i;
    private int n;
    private int discount;
    private Map<Integer, Integer> d;

    public Cashier(int n, int discount, int[] products, int[] prices) {
        this.i = 0;
        this.n = n;
        this.discount = discount;
        this.d = new HashMap<>();
        for (int j = 0; j < products.length; j++) {
            this.d.put(products[j], prices[j]);
        }
    }

    public double getBill(int[] product, int[] amount) {
        this.i = (this.i + 1) % this.n;
        double x = 0;
        for (int j = 0; j < product.length; j++) {
            x += this.d.get(product[j]) * amount[j];
        }
        if (this.i == 0) {
            return x - (this.discount * x) / 100.0;
        }
        return x;
    }
}

/**
 * Your Cashier object will be instantiated and called as such:
 * Cashier obj = new Cashier(n, discount, products, prices);
 * double param_1 = obj.getBill(product,amount);
 */

class Cashier {
public:
    int i;
    int n;
    int discount;
    unordered_map<int, int> d;

    Cashier(int n, int discount, vector<int>& products, vector<int>& prices) {
        this->i = 0;
        this->n = n;
        this->discount = discount;
        for (int j = 0; j < products.size(); j++) {
            d[products[j]] = prices[j];
        }
    }

    double getBill(vector<int> product, vector<int> amount) {
        i = (i + 1) % n;
        double x = 0;
        for (int j = 0; j < product.size(); j++) {
            x += d[product[j]] * amount[j];
        }
        if (i == 0) {
            return x - (discount * x) / 100.0;
        }
        return x;
    }
};

/**
 * Your Cashier object will be instantiated and called as such:
 * Cashier* obj = new Cashier(n, discount, products, prices);
 * double param_1 = obj->getBill(product,amount);
 */

type Cashier struct {
    i        int
    n        int
    discount int
    d        map[int]int
}

func Constructor(n int, discount int, products []int, prices []int) Cashier {
    d := make(map[int]int)
    for i := 0; i < len(products); i++ {
        d[products[i]] = prices[i]
    }
    return Cashier{i: 0, n: n, discount: discount, d: d}
}

func (this *Cashier) GetBill(product []int, amount []int) float64 {
    this.i = (this.i + 1) % this.n
    x := 0
    for i := 0; i < len(product); i++ {
        x += this.d[product[i]] * amount[i]
    }
    if this.i == 0 {
        return float64(x) - float64(this.discount)*float64(x)/100.0
    }
    return float64(x)
}

/**
 * Your Cashier object will be instantiated and called as such:
 * obj := Constructor(n, discount, products, prices);
 * param_1 := obj.GetBill(product,amount);
 */

class Cashier {
    i: number;
    n: number;
    discount: number;
    d: Map<number, number>;

    constructor(n: number, discount: number, products: number[], prices: number[]) {
        this.i = 0;
        this.n = n;
        this.discount = discount;
        this.d = new Map();
        for (let j = 0; j < products.length; j++) {
            this.d.set(products[j], prices[j]);
        }
    }

    getBill(product: number[], amount: number[]): number {
        this.i = (this.i + 1) % this.n;
        let x = 0;
        for (let j = 0; j < product.length; j++) {
            x += (this.d.get(product[j]) || 0) * amount[j];
        }
        if (this.i === 0) {
            return x - (this.discount * x) / 100;
        }
        return x;
    }
}

/**
 * Your Cashier object will be instantiated and called as such:
 * var obj = new Cashier(n, discount, products, prices)
 * var param_1 = obj.getBill(product,amount)
 */

use std::cell::Cell;
use std::collections::HashMap;

struct Cashier {
    i: Cell<i32>,
    n: i32,
    discount: i32,
    d: HashMap<i32, i32>,
}

impl Cashier {
    fn new(n: i32, discount: i32, products: Vec<i32>, prices: Vec<i32>) -> Self {
        let mut d = HashMap::new();
        for i in 0..products.len() {
            d.insert(products[i], prices[i]);
        }
        Cashier {
            i: Cell::new(0),
            n,
            discount,
            d,
        }
    }

    fn get_bill(&self, product: Vec<i32>, amount: Vec<i32>) -> f64 {
        let mut x = 0i64;
        let mut i = self.i.get();
        i = (i + 1) % self.n;
        self.i.set(i);

        for j in 0..product.len() {
            x += (self.d[&product[j]] as i64) * (amount[j] as i64);
        }

        if i == 0 {
            return x as f64 - (self.discount as f64) * (x as f64) / 100.0;
        }
        x as f64
    }
}

// Your Cashier object will be instantiated and called as such:
// let obj = Cashier::new(n, discount, products, prices);
// let ret_1: f64 = obj.get_bill(product, amount);