Design an algorithm that accepts a stream of integers and retrieves the product of the last k integers of the stream.

Implement the ProductOfNumbers class:


	ProductOfNumbers() Initializes the object with an empty stream.
	void add(int num) Appends the integer num to the stream.
	int getProduct(int k) Returns the product of the last k numbers in the current list. You can assume that always the current list has at least k numbers.


The test cases are generated so that, at any time, the product of any contiguous sequence of numbers will fit into a single 32-bit integer without overflowing.

&nbsp;
Example:

Input
["ProductOfNumbers","add","add","add","add","add","getProduct","getProduct","getProduct","add","getProduct"]
[[],[3],[0],[2],[5],[4],[2],[3],[4],[8],[2]]

Output
[null,null,null,null,null,null,20,40,0,null,32]

Explanation
ProductOfNumbers productOfNumbers = new ProductOfNumbers();
productOfNumbers.add(3);        // [3]
productOfNumbers.add(0);        // [3,0]
productOfNumbers.add(2);        // [3,0,2]
productOfNumbers.add(5);        // [3,0,2,5]
productOfNumbers.add(4);        // [3,0,2,5,4]
productOfNumbers.getProduct(2); // return 20. The product of the last 2 numbers is 5 * 4 = 20
productOfNumbers.getProduct(3); // return 40. The product of the last 3 numbers is 2 * 5 * 4 = 40
productOfNumbers.getProduct(4); // return 0. The product of the last 4 numbers is 0 * 2 * 5 * 4 = 0
productOfNumbers.add(8);        // [3,0,2,5,4,8]
productOfNumbers.getProduct(2); // return 32. The product of the last 2 numbers is 4 * 8 = 32 


&nbsp;
Constraints:


	0 &lt;= num &lt;= 100
	1 &lt;= k &lt;= 4 * 104
	At most 4 * 104 calls will be made to add and getProduct.
	The product of the stream at any point in time will fit in a 32-bit integer.


class ProductOfNumbers:
    def __init__(self):
        self.prods = [1]
        self.max = 0

    def add(self, num: int) -> None:
        if num == 0:
            num = 1
            self.max = len(self.prods)
        self.prods.append(self.prods[-1] * num)

    def getProduct(self, k: int) -> int:
        if k >= len(self.prods) - self.max:
            return 0
        return self.prods[-1] // self.prods[-k-1]
class ProductOfNumbers {
    List<Integer> prefix;
    public ProductOfNumbers() {
        prefix = new ArrayList<>();
        prefix.add(1);
    }
    
    public void add(int num) {
        if(num==0){
            prefix.clear();
            prefix.add(1);
        }
        else prefix.add(num*prefix.get(prefix.size()-1));
    }
    public int getProduct(int k) {
        if(k>=prefix.size()) return 0;
        return prefix.get(prefix.size()-1)/prefix.get(prefix.size()-k-1);
    }
}
class ProductOfNumbers {
private:
    vector<int> prefixProduct;
public:
    ProductOfNumbers() {

    }

    void add(int num) {
        if(num == 0){
            prefixProduct.clear();
            return;
        }
        if(prefixProduct.empty()){
            prefixProduct.push_back(num);
        }else{
            int prod = prefixProduct[prefixProduct.size() - 1] * num;
            prefixProduct.push_back(prod);
        }

    }
    int getProduct(int k) {
        if(k > prefixProduct.size()){
            return 0;
        }
        int size = prefixProduct.size();
        if(k == size) return prefixProduct[size - 1];
        int prod = prefixProduct[size - 1] / prefixProduct[size - k - 1];
        return prod;

    }
};
var ProductOfNumbers = function() {
    this.nums = [];
    this.len = 0;
};

/** 
 * @param {number} num
 * @return {void}
 */
ProductOfNumbers.prototype.add = function(num) {
    this.nums.push(num);
    this.len++;
};

/** 
 * @param {number} k
 * @return {number}
 */
ProductOfNumbers.prototype.getProduct = function(k) {
    let product = 1;
    for (let i = 1; i <= k; i++)
        product *= this.nums[this.len - i];
    return product;
};

/** 
 * Your ProductOfNumbers object will be instantiated and called as such:
 * var obj = new ProductOfNumbers()
 * obj.add(num)
 * var param_2 = obj.getProduct(k)
 */
Product of the Last K Numbers