Product of Array Except Self

Problem statement

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.

Example 1:

Input: nums = [1,2,3,4]Output: [24,12,8,6]

Example 2:

Input: nums = [-1,1,0,-3,3]Output: [0,0,9,0,0]

Constraints:

• 2 <= nums.length <= 105
• -30 <= nums[i] <= 30
• The product of any prefix or suffix of nums is guaranteed to fit in a 32-bit integer.

Follow up: Can you solve the problem in O(1) extra space complexity? (The output array does not count as extra space for space complexity analysis.)

My solution

/**
 * @param {number[]} nums
 * @return {number[]}
 */
var productExceptSelf = function(nums) {
//     function productLeft(index) {
//         let prod = 1;
//         for (let i = index; i >= 0; i--) {
//             prod *= nums[i]
//         }
//         return prod;
//     }
    
//     function productRight(index) {
//         let prod = 1;
//         for (let i = index; i < nums.length; i++) {
//             prod *= nums[i]
//         }
//         return prod;
//     }
    
//     return nums.map((_, index) => productLeft(index - 1) * productRight(index + 1))
    
    let len = nums.length;
    let dp = Array.from({
        length: len
    }, () => 1);
    let prefixProduct = 1;
    let suffixProduct = 1;
    let left = 0;
    let right = len - 1;
    
    while (left < len) {
        // console.log(`${left}:${right} => ${prefixProduct}:${suffixProduct}`)
        // console.log(dp)
        dp[left] *= prefixProduct;
        dp[right] *= suffixProduct;
        
        
        prefixProduct *= nums[left++]
        suffixProduct *= nums[right--]
    }
    
    return dp;
};