Prefix Product Array - Problem

Given an array of integers nums, build and return a new array result where each element result[i] is equal to the product of all elements that appear before index i in the original array.

For the first element (index 0), since there are no elements before it, the result should be 1.

Special handling for zeros: If there are zeros in the input array, handle them correctly by treating them as actual zero values in the multiplication.

Example: For array [2, 3, 4, 5], the result would be [1, 2, 6, 24] because:

result[0] = 1 (no elements before index 0)
result[1] = 2 (product of elements before index 1)
result[2] = 2 × 3 = 6 (product of elements before index 2)
result[3] = 2 × 3 × 4 = 24 (product of elements before index 3)

Input & Output

Example 1 — Basic Case

$ Input: nums = [2,3,4,5]

› Output: [1,2,6,24]

💡 Note: result[0]=1 (no elements before), result[1]=2, result[2]=2×3=6, result[3]=2×3×4=24

Example 2 — With Zero

$ Input: nums = [1,0,3,4]

› Output: [1,1,0,0]

💡 Note: result[0]=1, result[1]=1, result[2]=1×0=0, result[3]=1×0×3=0

Example 3 — Small Array

$ Input: nums = [5,2]

› Output: [1,5]

💡 Note: result[0]=1 (no elements before), result[1]=5 (product of elements before index 1)

Constraints

2 ≤ nums.length ≤ 10⁴
-10⁹ ≤ nums[i] ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 M Microsoft 32 A Apple 28

The key insight is to maintain a running product as we iterate through the array. The optimal approach uses a single pass with O(n) time complexity and O(1) extra space, storing the product of all previous elements at each position.

Common Approaches

✓ Nested Loop Approach

⏱️ Time: O(n²) Space: O(1)

For each index i in the result array, iterate through all elements from index 0 to i-1 and compute their product. This gives us the product of all elements before position i.

Single Pass with Running Product

⏱️ Time: O(n) Space: O(1)

Use a single loop to iterate through the array while maintaining a running product. At each position i, store the current running product in result[i], then update the running product by multiplying it with nums[i] for the next iteration.

Nested Loop Approach — Algorithm Steps

Create result array of same length as input
For each position i, initialize product as 1
Multiply all elements from index 0 to i-1
Store the computed product in result[i]

Visualization

Tap to expand

Step-by-Step Walkthrough

Position 0

No elements before, product = 1

Position 1

Multiply: nums[0] = 2

Position 2

Multiply: nums[0] × nums[1] = 2 × 3 = 6

Code -

solution.c — C

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

int* solution(int* nums, int numsSize, int* returnSize) {
    *returnSize = numsSize;
    int* result = (int*)malloc(numsSize * sizeof(int));
    
    for (int i = 0; i < numsSize; i++) {
        int product = 1;
        for (int j = 0; j < i; j++) {
            product *= nums[j];
        }
        result[i] = product;
    }
    
    return result;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse JSON array manually
    int nums[100];
    int count = 0;
    char* ptr = strchr(line, '[');
    ptr++;
    char* token = strtok(ptr, ",]");
    while (token != NULL) {
        nums[count++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int returnSize;
    int* result = solution(nums, count, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Nested loops where outer loop runs n times and inner loop runs up to n-1 times

⚠ Quadratic Growth

Space Complexity

O(1)

Only uses a few variables, result array doesn't count as extra space

✓ Linear Space

32.5K Views

Medium Frequency

~15 min Avg. Time

980 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

Prefix Product Array - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Nested Loop Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler