Product of Array Except Self - Practice Coding Problems

Product of Array Except Self - Problem

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

For example, if nums = [1,2,3,4], then answer = [24,12,8,6] because:

answer[0] = 2×3×4 = 24 (all except index 0)
answer[1] = 1×3×4 = 12 (all except index 1)
answer[2] = 1×2×4 = 8 (all except index 2)
answer[3] = 1×2×3 = 6 (all except index 3)

Important constraints:

You must write an algorithm that runs in O(n) time
You cannot use the division operation
All products are guaranteed to fit in a 32-bit integer

This problem tests your ability to think creatively about prefix and suffix products - a fundamental technique used in many advanced algorithms!

Input & Output

example_1.py — 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.py — With Negative Numbers

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

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

💡 Note: Since there's a 0 in the array, all products except the one at index 2 will be 0. For index 2: product = (-1)×1×(-3)×3 = 9.

example_3.py — Two Elements

$ Input: nums = [2,3]

› Output: [3,2]

💡 Note: For index 0: product = 3. For index 1: product = 2. This is the minimum array size case.

Visualization

Tap to expand

Understanding the Visualization

Map the Assembly Line

Each array element represents a production station with its efficiency multiplier

Calculate Left Production

For each station, calculate cumulative production from all stations to its left

Calculate Right Production

Traverse right-to-left, multiplying left production by running right production

Get Final Efficiency

Each position now contains total production when that station is removed

Key Takeaway

🎯 Key Insight: By calculating left products in one pass and right products in another, we can determine the 'production without each station' efficiently in O(n) time and O(1) extra space.

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n elements, we iterate through n-1 other elements

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space (excluding the output array)

✓ Linear Space

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
You must write an algorithm that runs in O(n) time
You cannot use the division operation

Asked in

a Amazon 67 G Google 45 f Meta 38 ⊞ Microsoft 29 Apple 23

The optimal solution uses two strategic passes through the array: first storing left products in the output array, then multiplying by right products calculated on-the-fly. This achieves O(n) time and O(1) extra space by cleverly using the output array as workspace, avoiding the need for auxiliary arrays.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n²)	O(1)	For each position, multiply all other elements using nested loops
Left and Right Product Arrays (Two Pass)	O(n)	O(n)	Use separate arrays to store left and right products, then combine them
Space-Optimized Two Pass (Optimal)	O(n)	O(1)	Use the output array as workspace to achieve O(1) extra space

Brute Force (Nested Loops) — Algorithm Steps

For each index i in the array
Initialize product = 1
For each index j in the array (j ≠ i)
Multiply product by nums[j]
Store result in answer[i]

Visualization

Tap to expand

Step-by-Step Walkthrough

Position 0

Calculate product of indices 1,2,3: 2×3×4 = 24

Position 1

Calculate product of indices 0,2,3: 1×3×4 = 12

Position 2

Calculate product of indices 0,1,3: 1×2×4 = 8

Position 3

Calculate product of indices 0,1,2: 1×2×3 = 6

Code -

solution.c — C

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

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

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    int nums[1000];
    int count = 0;
    char* token = strtok(input, "[],\n");
    while (token != NULL) {
        nums[count++] = atoi(token);
        token = strtok(NULL, "[],\n");
    }
    
    int returnSize;
    int* result = productExceptSelf(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²)

For each of n elements, we iterate through n-1 other elements

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space (excluding the output array)

✓ Linear Space

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
You must write an algorithm that runs in O(n) time
You cannot use the division operation

89.2K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler