package com.fishercoder.solutions;

import java.util.ArrayList;
import java.util.List;

/**
 * 1352. Product of the Last K Numbers
 *
 * Implement the class ProductOfNumbers that supports two methods:
 * 1. add(int num)
 * Adds the number num to the back of the current list of numbers.
 * 2. 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.
 * At any time, the product of any contiguous sequence of numbers will fit into a single 32-bit integer without overflowing.
 *
 * 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
 *
 * Constraints:
 * There will be at most 40000 operations considering both add and getProduct.
 * 0 <= num <= 100
 * 1 <= k <= 40000
 * */
public class _1352 {
    public static class Solution1 {
        /**credit: https://leetcode.com/problems/product-of-the-last-k-numbers/discuss/510260/JavaC%2B%2BPython-Prefix-Product*/
        public static class ProductOfNumbers {

            List<Integer> list;

            public ProductOfNumbers() {
                add(0);
            }

            public void add(int num) {
                if (num > 0) {
                    list.add(list.get(list.size() - 1) * num);
                } else {
                    list = new ArrayList<>();
                    list.add(1);
                }
            }

            public int getProduct(int k) {
                int size = list.size();
                return k >= size ? 0 : (list.get(size - 1) / list.get(size - k - 1));
            }
        }
    }
}

@@ -85,1638 +85,8 @@
 t;%0A%0A
-/**%0A * 1352. Product of the Last K Numbers%0A *%0A * Implement the class ProductOfNumbers that supports two methods:%0A * 1. add(int num)%0A * Adds the number num to the back of the current list of numbers.%0A * 2. getProduct(int k)%0A * Returns the product of the last k numbers in the current list.%0A * You can assume that always the current list has at least k numbers.%0A * At any time, the product of any contiguous sequence of numbers will fit into a single 32-bit integer without overflowing.%0A *%0A * Example:%0A * Input%0A * %5B%22ProductOfNumbers%22,%22add%22,%22add%22,%22add%22,%22add%22,%22add%22,%22getProduct%22,%22getProduct%22,%22getProduct%22,%22add%22,%22getProduct%22%5D%0A * %5B%5B%5D,%5B3%5D,%5B0%5D,%5B2%5D,%5B5%5D,%5B4%5D,%5B2%5D,%5B3%5D,%5B4%5D,%5B8%5D,%5B2%5D%5D%0A * Output%0A * %5Bnull,null,null,null,null,null,20,40,0,null,32%5D%0A * Explanation%0A * ProductOfNumbers productOfNumbers = new ProductOfNumbers();%0A * productOfNumbers.add(3);        // %5B3%5D%0A * productOfNumbers.add(0);        // %5B3,0%5D%0A * productOfNumbers.add(2);        // %5B3,0,2%5D%0A * productOfNumbers.add(5);        // %5B3,0,2,5%5D%0A * productOfNumbers.add(4);        // %5B3,0,2,5,4%5D%0A * productOfNumbers.getProduct(2); // return 20. The product of the last 2 numbers is 5 * 4 = 20%0A * productOfNumbers.getProduct(3); // return 40. The product of the last 3 numbers is 2 * 5 * 4 = 40%0A * productOfNumbers.getProduct(4); // return 0. The product of the last 4 numbers is 0 * 2 * 5 * 4 = 0%0A * productOfNumbers.add(8);        // %5B3,0,2,5,4,8%5D%0A * productOfNumbers.getProduct(2); // return 32. The product of the last 2 numbers is 4 * 8 = 32%0A *%0A * Constraints:%0A * There will be at most 40000 operations considering both add and getProduct.%0A * 0 %3C= num %3C= 100%0A * 1 %3C= k %3C= 40000%0A * */%0A
 publ
@@ -149,16 +149,28 @@
      /**
+%0A         * 
 credit: 
@@ -276,16 +276,26 @@
 -Product
+%0A         
 */%0A     

refactor 1352