Product of Array Except Self

Product of Array Except Self - Problem

Given an integer array nums, return an array answer such that answer[i] is equal to the product of all the elements of nums except nums[i].

The product of any prefix or suffix of nums is guaranteed to fit in a 32-bit integer.

You must write an algorithm that runs in O(n) time and without using the division operation.

Input & Output

Example 1 — Basic Case

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

› Output: [24,12,8,6]

💡 Note: For index 0: product = 2×3×4 = 24. For index 1: product = 1×3×4 = 12. For index 2: product = 1×2×4 = 8. For index 3: product = 1×2×3 = 6.

Example 2 — With Zero

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

› Output: [0,0,9,0,0]

💡 Note: Since there's a 0 in the array, all positions except index 2 will have product 0. At index 2 (skipping the 0): product = (-1)×1×(-3)×3 = 9.

Example 3 — Small Array

$ Input: nums = [2,3]

› Output: [3,2]

💡 Note: For index 0: skip nums[0]=2, product = 3. For index 1: skip nums[1]=3, product = 2.

Constraints

2 ≤ nums.length ≤ 10⁵
-30 ≤ nums[i] ≤ 30
The product of any prefix or suffix of nums is guaranteed to fit in a 32-bit integer.

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 f Facebook 32 A Apple 28

The key insight is that the product except current element equals the product of all left elements times the product of all right elements. The optimal approach uses the output array to store left products first, then traverses right-to-left to multiply by right products. Time: O(n), Space: O(1).

Common Approaches

✓ Brute Force - Nested Loops

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

For each index i, iterate through the entire array and multiply all elements except nums[i]. This gives us the correct result but requires nested loops.

Space Optimized - Single Array

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

Instead of using separate left and right arrays, we use the output array itself to first store left products, then traverse from right to left while maintaining a running right product.

Two Pass - Left and Right Products

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

First pass calculates prefix products (product of all elements to the left). Second pass calculates suffix products (product of all elements to the right) and combines with left products.

Brute Force - Nested Loops — Algorithm Steps

Iterate through each index i
For each i, multiply all elements except nums[i]
Store result in answer array

Visualization

Tap to expand

Step-by-Step Walkthrough

Input Array

Start with input array [1,2,3,4]

Calculate Each Position

For each index, multiply all other elements

Result

Get final answer array [24,12,8,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* answer = (int*)malloc(numsSize * sizeof(int));
    
    for (int i = 0; i < numsSize; i++) {
        answer[i] = 1;
        for (int j = 0; j < numsSize; j++) {
            if (i != j) {
                answer[i] *= nums[j];
            }
        }
    }
    
    return answer;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int nums[100];
    int count = 0;
    char* token = strtok(line + 1, ",]");
    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: outer loop runs n times, inner loop runs n-1 times for each

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space (excluding output array)

⚡ Linearithmic Space

89.5K Views

Very High Frequency

~15 min Avg. Time

2.8K 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 - Nested Loops — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler