Leetcode 238 Product of Array Except Self (C,C++,C#,JAVA,JAVASCRIPT,RUBY,TYPESCRIPT)

Given an array nums of n integers where n > 1, return an array output such that output[i] is equal to the product of all the elements of nums except nums[i].

Example:

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

Constraint: It’s guaranteed that the product of the elements of any prefix or suffix of the array (including the whole array) fits in a 32 bit integer.

Note: Please solve it without division and in O(n).

Follow up:
Could you solve it with constant space complexity? (The output array does not count as extra space for the purpose of space complexity analysis.)

//C
int* productExceptSelf(int* nums, int numsSize, int* returnSize){
        int left = 1;
        int right = 1;
    
        int *product=(int*)malloc(numsSize*sizeof(int));
        *returnSize=numsSize;
    
        for(int i = 0; i < numsSize; i++)
        {
            product[i] = left;
            left *= nums[i]; 
        }
        
        for(int i = numsSize -1; i > -1; i--)
        {
            product[i] = right*product[i];  // left * right
            right *= nums[i];             
        }
        return product;
}
//C++
class Solution {
public:
    vector<int> productExceptSelf(vector<int>& nums) {
        int left = 1;
        int right = 1;
        vector<int> product;
        
        for(int i = 0; i < nums.size(); i++)
        {
            product.push_back(left);
            left *= nums[i]; 
        }
        
        for(int i = nums.size() -1; i > -1; i--)
        {
            product[i] = (right*product[i]);  // left * right
            right *= nums[i];             
        }
        return product;
    }
};
//C#
public class Solution {
    public int[] ProductExceptSelf(int[] nums) {
        int left = 1;
        int right = 1;
        int[] product = new int[nums.Length];
        
        for(int i = 0; i < nums.Length; i++)
        {
            product[i] = left;
            left *= nums[i]; 
        }
        
        for(int i = nums.Length -1; i > -1; i--)
        {
            product[i] = right*product[i];  // left * right
            right *= nums[i];             
        }
        return product;
    }
}
//JAVA
class Solution {
    public int[] productExceptSelf(int[] nums) {
        int left = 1;
        int right = 1;
        int[] product = new int[nums.length];
        
        for(int i = 0; i < nums.length; i++)
        {
            product[i] = left;
            left *= nums[i]; 
        }
        
        for(int i = nums.length -1; i > -1; i--)
        {
            product[i] = right*product[i];  // left * right
            right *= nums[i];             
        }
        return product;
    }
}
//JAVASCRIPT
var productExceptSelf = function(nums) {
    let left = 1;
    let right = 1;
    let product = [];
    
    for(let i = 0; i < nums.length; i++)
    {
        product[i] = left;
        left *= nums[i]; 
    }
    
    for(let i = nums.length -1; i > -1; i--)
    {
        product[i] = right*product[i];  // left * right
        right *= nums[i];             
    }
    return product;
};
//RUBY
def product_except_self(nums)
    left = 1;
    right = 1;
    product = [];
    
    for i in (0..nums.length - 1)
        product[i] = left;
        left = left*nums[i]; 
    end
for i in ((nums.length - 1).downto(0)) 
    
        product[i] = right * product[i] # left * right
        right = right*nums[i];             
    end
    product;
end
//TYPECRIPT
function productExceptSelf(nums: number[]): number[] {
    let left: number = 1;
    let right: number = 1;
    let product: number[] = [];
    
    for(let i: number = 0; i < nums.length; i++)
    {
        product[i] = left;
        left *= nums[i]; 
    }
    
    for(let i: number = nums.length -1; i > -1; i--)
    {
        product[i] = right*product[i];  // left * right
        right *= nums[i];             
    }
    return product;
};