Product of the Last K Numbers - Practice Coding Problems

Product of the Last K Numbers - Problem

Array Math Design Data Stream Prefix Sum Medium

Design a data structure that efficiently handles a stream of integers and can quickly calculate the product of the last k numbers at any time.

You need to implement the ProductOfNumbers class with these methods:

ProductOfNumbers() - Initialize an empty stream
add(int num) - Append a number to the stream
getProduct(int k) - Return the product of the last k numbers

Key Challenge: The getProduct operation should be as fast as possible since it might be called frequently. Think about how you can precompute information to make queries efficient.

Note: Products are guaranteed to fit in a 32-bit integer, and there will always be at least k numbers when getProduct(k) is called.

Input & Output

example_1.py — Basic Operations

$ Input: obj = ProductOfNumbers() obj.add(3) obj.add(0) obj.add(2) obj.add(5) obj.add(4) obj.getProduct(2) obj.getProduct(3) obj.getProduct(4)

› Output: 20 40 0

💡 Note: getProduct(2) returns 5*4=20, getProduct(3) returns 2*5*4=40, getProduct(4) returns 0*2*5*4=0 due to the zero

example_2.py — No Zeros

$ Input: obj = ProductOfNumbers() obj.add(1) obj.add(2) obj.add(3) obj.add(4) obj.getProduct(1) obj.getProduct(2) obj.getProduct(4)

› Output: 4 12 24

💡 Note: getProduct(1) returns 4, getProduct(2) returns 3*4=12, getProduct(4) returns 1*2*3*4=24

example_3.py — Single Element

$ Input: obj = ProductOfNumbers() obj.add(5) obj.getProduct(1)

› Output: 5

💡 Note: With only one element, getProduct(1) simply returns that element

Constraints

1 ≤ nums.length ≤ 4 * 10⁴
1 ≤ k ≤ 4 * 10⁴
-10⁹ ≤ nums[i] ≤ 10⁹
The product of any contiguous sequence fits in a 32-bit integer
At most 4 * 10⁴ calls will be made to add and getProduct
It is guaranteed that there will be at least k numbers when getProduct(k) is called

Visualization

Tap to expand

Understanding the Visualization

Initialize

Start with prefix products array containing [1]

Add Numbers

For each new number, multiply with last prefix product

Query Range

Use division to get product of any range in O(1)

Key Takeaway

🎯 Key Insight: Prefix products transform O(k) range queries into O(1) operations using division, similar to how prefix sums work with subtraction!

Asked in

G Google 23 a Amazon 18 f Meta 15 ⊞ Microsoft 12

The optimal solution uses prefix products to achieve O(1) query time. Similar to prefix sums, we maintain a running product from the start to each position. To find the product of the last k numbers, we use division: total_product / product_before_range. Special care is needed when handling zeros in the stream.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Calculate Each Time)	O(k)	O(n)	Store all numbers and multiply the last k numbers for each query
Prefix Products (Optimal)	O(1)	O(n)	Use prefix products to calculate range products in O(1) time

Brute Force (Calculate Each Time) — Algorithm Steps

Store all numbers in a list as they arrive
For each getProduct(k) call, start from the end of the list
Multiply the last k numbers together
Return the result

Visualization

Tap to expand

Step-by-Step Walkthrough

Add Numbers

Numbers are added to the end of the list

Query Request

getProduct(k) is called

Iterate and Multiply

Loop through the last k numbers and multiply them

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

typedef struct {
    int* numbers;
    int size;
    int capacity;
} ProductOfNumbers;

ProductOfNumbers* productOfNumbersCreate() {
    ProductOfNumbers* obj = (ProductOfNumbers*)malloc(sizeof(ProductOfNumbers));
    obj->capacity = 1000;
    obj->numbers = (int*)malloc(obj->capacity * sizeof(int));
    obj->size = 0;
    return obj;
}

void productOfNumbersAdd(ProductOfNumbers* obj, int num) {
    if (obj->size >= obj->capacity) {
        obj->capacity *= 2;
        obj->numbers = (int*)realloc(obj->numbers, obj->capacity * sizeof(int));
    }
    obj->numbers[obj->size++] = num;
}

int productOfNumbersGetProduct(ProductOfNumbers* obj, int k) {
    int product = 1;
    int startIdx = obj->size - k;
    for (int i = startIdx; i < obj->size; i++) {
        product *= obj->numbers[i];
    }
    return product;
}

void productOfNumbersFree(ProductOfNumbers* obj) {
    free(obj->numbers);
    free(obj);
}

int main() {
    ProductOfNumbers* obj = productOfNumbersCreate();
    productOfNumbersAdd(obj, 3);
    productOfNumbersAdd(obj, 0);
    productOfNumbersAdd(obj, 2);
    productOfNumbersAdd(obj, 5);
    productOfNumbersAdd(obj, 4);
    printf("%d\n", productOfNumbersGetProduct(obj, 2)); // 20
    printf("%d\n", productOfNumbersGetProduct(obj, 3)); // 40
    printf("%d\n", productOfNumbersGetProduct(obj, 4)); // 0
    productOfNumbersFree(obj);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(k)

Each getProduct call requires multiplying k numbers

✓ Linear Growth

Space Complexity

O(n)

We need to store all n numbers that have been added

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~25 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Calculate Each Time) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler