Product of Array except itself

Given an array arr[] of n integers, construct a Product Array prod[] (of same size) such that prod[i] is equal to the product of all the elements of arr[] except arr[i]. Solve it without division operator in O(n) time.

Example :

Input: arr[]  = {10, 3, 5, 6, 2}
Output: prod[]  = {180, 600, 360, 300, 900}
3 * 5 * 6 * 2 product of other array 
elements except 10 is 180
10 * 5 * 6 * 2 product of other array 
elements except 3 is 600
10 * 3 * 6 * 2 product of other array 
elements except 5 is 360
10 * 3 * 5 * 2 product of other array 
elements except 6 is 300
10 * 3 * 6 * 5 product of other array 
elements except 2 is 900


Input: arr[]  = {1, 2, 3, 4, 5}
Output: prod[]  = {120, 60, 40, 30, 24 }
2 * 3 * 4 * 5  product of other array 
elements except 1 is 120
1 * 3 * 4 * 5  product of other array 
elements except 2 is 60
1 * 2 * 4 * 5  product of other array 
elements except 3 is 40
1 * 2 * 3 * 5  product of other array 
elements except 4 is 30
1 * 2 * 3 * 4  product of other array 
elements except 5 is 24

Naive Solution:
Approach: Create two extra space, i.e. two extra arrays to store the product of all the array elements from start, up to that index and another array to store the product of all the array elements from the end of the array to that index. 
To get the product excluding that index, multiply the prefix product up to index i-1 with the suffix product up to index i+1.

Algorithm:

1. Create two array prefix and suffix of length n, i.e length of the original array, initialize prefix[0] = 1 and suffix[n-1] = 1 and also another array to store the product.
2. Traverse the array from second index to end.
3. For every index i update prefix[i] as prefix[i] = prefix[i-1] * array[i-1], i.e store the product upto i-1 index from the start of array.
4. Traverse the array from second last index to start.
5. For every index i update suffix[i] as suffix[i] = suffix[i+1] * array[i+1], i.e store the product upto i+1 index from the end of array
6. Traverse the array from start to end.
7. For every index i the output will be prefix[i] * suffix[i], the product of the array element except that element.

C++

// C++ implementation of above approach
#include <bits/stdc++.h>
using namespace std;

/* Function to print product array
for a given array arr[] of size n */
void productArray(int arr[], int n)
{

    // Base case
    if (n == 1) {
        cout << 0;
        return;
    }
    /* Allocate memory for temporary
arrays left[] and right[] */
    int* left = new int[sizeof(int) * n];
    int* right = new int[sizeof(int) * n];

    /* Allocate memory for the product array */
    int* prod = new int[sizeof(int) * n];

    int i, j;

    /* Left most element of left
array is always 1 */
    left[0] = 1;

    /* Right most element of right
array is always 1 */
    right[n - 1] = 1;

    /* Construct the left array */
    for (i = 1; i < n; i++)
        left[i] = arr[i - 1] * left[i - 1];

    /* Construct the right array */
    for (j = n - 2; j >= 0; j--)
        right[j] = arr[j + 1] * right[j + 1];

    /* Construct the product array using
        left[] and right[] */
    for (i = 0; i < n; i++)
        prod[i] = left[i] * right[i];

    /* print the constructed prod array */
    for (i = 0; i < n; i++)
        cout << prod[i] << " ";

    return;
}

/* Driver code*/
int main()
{
    int arr[] = { 10, 3, 5, 6, 2 };
    int n = sizeof(arr) / sizeof(arr[0]);
    cout << "The product array is: \n";
    productArray(arr, n);
}

// This is code is contributed by rathbhupendra

C

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

/* Function to print product array
for a given array arr[] of size n */
void productArray(int arr[], int n)
{

    // Base case
    if (n == 1) {
        printf("0");
        return;
    }

    /* Allocate memory for temporary
arrays left[] and right[] */
    int* left = (int*)malloc(sizeof(int) * n);
    int* right = (int*)malloc(sizeof(int) * n);

    /* Allocate memory for the product array */
    int* prod = (int*)malloc(sizeof(int) * n);

    int i, j;

    /* Left most element of left array
is always 1 */
    left[0] = 1;

    /* Right most element of right
array is always 1 */
    right[n - 1] = 1;

    /* Construct the left array */
    for (i = 1; i < n; i++)
        left[i] = arr[i - 1] * left[i - 1];

    /* Construct the right array */
    for (j = n - 2; j >= 0; j--)
        right[j] = arr[j + 1] * right[j + 1];

    /* Construct the product array using
    left[] and right[] */
    for (i = 0; i < n; i++)
        prod[i] = left[i] * right[i];

    /* print the constructed prod array */
    for (i = 0; i < n; i++)
        printf("%d ", prod[i]);

    return;
}

/* Driver program to test above functions */
int main()
{
    int arr[] = { 10, 3, 5, 6, 2 };
    int n = sizeof(arr) / sizeof(arr[0]);
    printf("The product array is: \n");
    productArray(arr, n);
    getchar();
}

Java

class ProductArray {
    /* Function to print product array
    for a given array arr[] of size n */
    void productArray(int arr[], int n)
    {

        // Base case
        if (n == 1) {
            System.out.print(0);
            return;
        }
        // Initialize memory to all arrays
        int left[] = new int[n];
        int right[] = new int[n];
        int prod[] = new int[n];

        int i, j;

        /* Left most element of left array
is always 1 */
        left[0] = 1;

        /* Right most element of right
array is always 1 */
        right[n - 1] = 1;

        /* Construct the left array */
        for (i = 1; i < n; i++)
            left[i] = arr[i - 1] * left[i - 1];

        /* Construct the right array */
        for (j = n - 2; j >= 0; j--)
            right[j] = arr[j + 1] * right[j + 1];

        /* Construct the product array using
        left[] and right[] */
        for (i = 0; i < n; i++)
            prod[i] = left[i] * right[i];

        /* print the constructed prod array */
        for (i = 0; i < n; i++)
            System.out.print(prod[i] + " ");

        return;
    }

    /* Driver program to test the above function */
    public static void main(String[] args)
    {
        ProductArray pa = new ProductArray();
        int arr[] = { 10, 3, 5, 6, 2 };
        int n = arr.length;
        System.out.println("The product array is : ");
        pa.productArray(arr, n);
    }
}

// This code has been contributed by Mayank Jaiswal

Python3

# Python implementation of the above approach

# Function to print product array for a given array
# arr[] of size n


def productArray(arr, n):

    # Base case
    if(n == 1):
        print(0)
        return

    # Allocate memory for temporary arrays left[] and right[]
    left = [0]*n
    right = [0]*n

    # Allocate memory for the product array
    prod = [0]*n

    # Left most element of left array is always 1
    left[0] = 1

    # Right most element of right array is always 1
    right[n - 1] = 1

    # Construct the left array
    for i in range(1, n):
        left[i] = arr[i - 1] * left[i - 1]

    # Construct the right array
    for j in range(n-2, -1, -1):
        right[j] = arr[j + 1] * right[j + 1]

    # Construct the product array using
    # left[] and right[]
    for i in range(n):
        prod[i] = left[i] * right[i]

    # print the constructed prod array
    for i in range(n):
        print(prod[i], end=' ')


# Driver code
arr = [10, 3, 5, 6, 2]
n = len(arr)
print("The product array is:")
productArray(arr, n)

# This code is contributed by ankush_953

C#

using System;

class GFG {

    /* Function to print product array
    for a given array arr[] of size n */
    static void productArray(int[] arr, int n)
    {

        // Base case
        if (n == 1) {
            Console.Write(0);
            return;
        }
        // Initialize memory to all arrays
        int[] left = new int[n];
        int[] right = new int[n];
        int[] prod = new int[n];

        int i, j;

        /* Left most element of left array
        is always 1 */
        left[0] = 1;

        /* Right most element of right
        array is always 1 */
        right[n - 1] = 1;

        /* Construct the left array */
        for (i = 1; i < n; i++)
            left[i] = arr[i - 1] * left[i - 1];

        /* Construct the right array */
        for (j = n - 2; j >= 0; j--)
            right[j] = arr[j + 1] * right[j + 1];

        /* Construct the product array using
        left[] and right[] */
        for (i = 0; i < n; i++)
            prod[i] = left[i] * right[i];

        /* print the constructed prod array */
        for (i = 0; i < n; i++)
            Console.Write(prod[i] + " ");

        return;
    }

    /* Driver program to test the above function */
    public static void Main()
    {
        int[] arr = { 10, 3, 5, 6, 2 };
        int n = arr.Length;
        Console.Write("The product array is :\n");

        productArray(arr, n);
    }
}

// This code is contributed by nitin mittal.

PHP

<?php
// Function to print product
// array for a given array
// arr[] of size n
function productArray($arr, $n)
{

    // Base case
    if($n == 1) {
        echo "0";
        return;
    }
    // Initialize memory
    // to all arrays
    $left = array();
    $right = array();
    $prod = array();

    $i; $j;

    // Left most element of
    // left array is always 1
    $left[0] = 1;

    // Right most element of
    // right array is always 1
    $right[$n - 1] = 1;

    // Construct the left array
    for ($i = 1; $i < $n; $i++)
        $left[$i] = $arr[$i - 1] *
                    $left[$i - 1];

    // Construct the right array
    for ($j = $n - 2; $j >= 0; $j--)
        $right[$j] = $arr[$j + 1] *
                    $right[$j + 1];

    // Construct the product array
    // using left[] and right[]
    for ($i = 0; $i < $n; $i++)
        $prod[$i] = $left[$i] *
                    $right[$i];

    // print the constructed prod array
    for ($i = 0; $i < $n; $i++)
        echo $prod[$i], " ";

    return;
}

// Driver Code
$arr = array(10, 3, 5, 6, 2);
$n = count($arr);
echo "The product array is : \n";
productArray($arr, $n);

// This code has been contributed by anuj_67.
?>

Javascript

<script>
    /* Function to print product array
    for a given array arr[] of size n */
    function productArray(arr, n)
    {

        // Base case
        if (n == 1) {
            document.write(0);
            return;
        }

        // Initialize memory to all arrays
        let left = new Array(n);
        let right = new Array(n);
        let prod = new Array(n);

        let i, j;

        /* Left most element of left array
        is always 1 */
        left[0] = 1;

        /* Right most element of right
        array is always 1 */
        right[n - 1] = 1;

        /* Construct the left array */
        for (i = 1; i < n; i++)
            left[i] = arr[i - 1] * left[i - 1];

        /* Construct the right array */
        for (j = n - 2; j >= 0; j--)
            right[j] = arr[j + 1] * right[j + 1];

        /* Construct the product array using
        left[] and right[] */
        for (i = 0; i < n; i++)
            prod[i] = left[i] * right[i];

        /* print the constructed prod array */
        for (i = 0; i < n; i++)
            document.write(prod[i] + " ");

        return;
    }

    // Driver code
    let arr = [ 10, 3, 5, 6, 2 ];
    let n = arr.length;
    document.write("The product array is :" + "</br>");

    productArray(arr, n);

// This code is contributed by mukesh07.
</script>

Output

The product array is: 
180 600 360 300 900 

Complexity Analysis:

• Time Complexity: O(n). 
  The array needs to be traversed three times, so the time complexity is O(n).
• Space Complexity: O(n). 
  Two extra arrays and one array to store the output is needed so the space complexity is O(n)

Note: The above method can be optimized to work in space complexity O(1). Thanks to Dileep for suggesting the below solution.

Efficient solution:
Approach: In the previous solution, two extra arrays were created to store the prefix and suffix, in this solution store the prefix and suffix product in the output array (or product array) itself. Thus reducing the space required.

Algorithm:

1. Create an array product and initialize its value to 1 and a variable temp = 1.
2. Traverse the array from start to end.
3. For every index i update product[i] as product[i] = temp and temp = temp * array[i], i.e store the product upto i-1 index from the start of array.
4. initialize temp = 1 and traverse the array from last index to start.
5. For every index i update product[i] as product[i] = product[i] * temp and temp = temp * array[i], i.e multiply with the product upto i+1 index from the end of array.
6. Print the product array.

C++

// C++ implementation of above approach
#include <bits/stdc++.h>
using namespace std;

/* Function to print product array
for a given array arr[] of size n */
void productArray(int arr[], int n)
{

    // Base case
    if (n == 1) {
        cout << 0;
        return;
    }

    int i, temp = 1;

    /* Allocate memory for the product array */
    int* prod = new int[(sizeof(int) * n)];

    /* Initialize the product array as 1 */
    memset(prod, 1, n);

    /* In this loop, temp variable contains product of
       elements on left side excluding arr[i] */
    for (i = 0; i < n; i++) {
        prod[i] = temp;
        temp *= arr[i];
    }

    /* Initialize temp to 1
    for product on right side */
    temp = 1;

    /* In this loop, temp variable contains product of
       elements on right side excluding arr[i] */
    for (i = n - 1; i >= 0; i--) {
        prod[i] *= temp;
        temp *= arr[i];
    }

    /* print the constructed prod array */
    for (i = 0; i < n; i++)
        cout << prod[i] << " ";

    return;
}

// Driver Code
int main()
{
    int arr[] = { 10, 3, 5, 6, 2 };
    int n = sizeof(arr) / sizeof(arr[0]);
    cout << "The product array is: \n";
    productArray(arr, n);
}

// This code is contributed by rathbhupendra

C

// C implementation of above approach
#include <stdio.h>
#include <string.h>
// Function to print product array for a given array arr[]
// of size n
void productArray(int arr[], int n)
{

    // Base case
    if (n == 1) {
        printf("0");
        return;
    }

    int i, temp = 1;

    /* Allocate memory for the product array */
    int prod[n];

    /* Initialize the product array as 1 */
    memset(prod, 1, n);

    /* In this loop, temp variable contains product of
       elements on left side excluding arr[i] */
    for (i = 0; i < n; i++) {
        prod[i] = temp;
        temp *= arr[i];
    }

    /* Initialize temp to 1
    for product on right side */
    temp = 1;

    /* In this loop, temp variable contains product of
       elements on right side excluding arr[i] */
    for (i = n - 1; i >= 0; i--) {
        prod[i] *= temp;
        temp *= arr[i];
    }

    /* print the constructed prod array */
    for (i = 0; i < n; i++)
        printf("%d ", prod[i]);

    return;
}

// Driver Code
int main()
{
    int arr[] = { 10, 3, 5, 6, 2 };
    int n = sizeof(arr) / sizeof(arr[0]);
    printf("The product array is: \n");
    productArray(arr, n);
}

// This code is contributed by Aditya Kumar (adityakumar129)

Java

class ProductArray {
    void productArray(int arr[], int n)
    {

        // Base case
        if (n == 1) {
            System.out.print("0");
            return;
        }

        int i, temp = 1;

        /* Allocate memory for the product array */
        int prod[] = new int[n];

        /* Initialize the product array as 1 */
        for (int j = 0; j < n; j++)
            prod[j] = 1;

        /* In this loop, temp variable contains product of
           elements on left side excluding arr[i] */
        for (i = 0; i < n; i++) {
            prod[i] = temp;
            temp *= arr[i];
        }

        /* Initialize temp to 1 for product on right side */
        temp = 1;

        /* In this loop, temp variable contains product of
           elements on right side excluding arr[i] */
        for (i = n - 1; i >= 0; i--) {
            prod[i] *= temp;
            temp *= arr[i];
        }

        /* print the constructed prod array */
        for (i = 0; i < n; i++)
            System.out.print(prod[i] + " ");

        return;
    }

    /* Driver program to test above functions */
    public static void main(String[] args)
    {
        ProductArray pa = new ProductArray();
        int arr[] = { 10, 3, 5, 6, 2 };
        int n = arr.length;
        System.out.println("The product array is : ");
        pa.productArray(arr, n);
    }
}

// This code has been contributed by Mayank Jaiswal

Python3

# Python3 program for A Product Array Puzzle
def productArray(arr, n):

    # Base case
    if n == 1:
        print(0)
        return

    i, temp = 1, 1

    # Allocate memory for the product array
    prod = [1 for i in range(n)]

    # Initialize the product array as 1

    # In this loop, temp variable contains product of
    # elements on left side excluding arr[i]
    for i in range(n):
        prod[i] = temp
        temp *= arr[i]

    # Initialize temp to 1 for product on right side
    temp = 1

    # In this loop, temp variable contains product of
    # elements on right side excluding arr[i]
    for i in range(n - 1, -1, -1):
        prod[i] *= temp
        temp *= arr[i]

    # Print the constructed prod array
    for i in range(n):
        print(prod[i], end=" ")

    return


# Driver Code
arr = [10, 3, 5, 6, 2]
n = len(arr)
print("The product array is: n")
productArray(arr, n)

# This code is contributed by mohit kumar

C#

using System;

class GFG {

    static void productArray(int[] arr, int n)
    {

        // Base case
        if (n == 1) {
            Console.Write(0);
            return;
        }
        int i, temp = 1;

        /* Allocate memory for the product
        array */
        int[] prod = new int[n];

        /* Initialize the product array as 1 */
        for (int j = 0; j < n; j++)
            prod[j] = 1;

        /* In this loop, temp variable contains
        product of elements on left side
        excluding arr[i] */
        for (i = 0; i < n; i++) {
            prod[i] = temp;
            temp *= arr[i];
        }

        /* Initialize temp to 1 for product on
        right side */
        temp = 1;

        /* In this loop, temp variable contains
        product of elements on right side
        excluding arr[i] */
        for (i = n - 1; i >= 0; i--) {
            prod[i] *= temp;
            temp *= arr[i];
        }

        /* print the constructed prod array */
        for (i = 0; i < n; i++)
            Console.Write(prod[i] + " ");

        return;
    }

    /* Driver program to test above functions */
    public static void Main()
    {
        int[] arr = { 10, 3, 5, 6, 2 };
        int n = arr.Length;
        Console.WriteLine("The product array is : ");

        productArray(arr, n);
    }
}

// This code is contributed by nitin mittal.

PHP

<?php
// PHP program for
// A Product Array Puzzle

function productArray($arr, $n)
    {

        // Base case
        if ($n == 1) {
            echo "0";
            return;
        }
        $i; $temp = 1;

        /* Allocate memory for
           the productarray */
        $prod = array();

        /* Initialize the product
           array as 1 */
        for( $j = 0; $j < $n; $j++)
            $prod[$j] = 1;

        /* In this loop, temp
           variable contains
           product of elements
           on left side
           excluding arr[i] */
        for ($i = 0; $i < $n; $i++)
        {
            $prod[$i] = $temp;
            $temp *= $arr[$i];
        }

        /* Initialize temp to 1
           for product on right
           side */
        $temp = 1;

        /* In this loop, temp
           variable contains
           product of elements
           on right side
           excluding arr[i] */
        for ($i = $n - 1; $i >= 0; $i--)
        {
            $prod[$i] *= $temp;
            $temp *= $arr[$i];
        }

        /* print the constructed
           prod array */
        for ($i = 0; $i < $n; $i++)
            echo $prod[$i], " ";

        return;
    }

        // Driver Code
        $arr = array(10, 3, 5, 6, 2);
        $n = count($arr);
        echo "The product array is : \n";
        productArray($arr, $n);

// This code is contributed by anuj_67.
?>

Javascript

<script>

    function productArray(arr , n)
    {

        // Base case
        if (n == 1) {
            document.write("0");
            return;
        }

        var i, temp = 1;

        /* Allocate memory for the product array */
        var prod = Array(n).fill(0);

        /* Initialize the product array as 1 */
        for (j = 0; j < n; j++)
            prod[j] = 1;

        /*
         In this loop, temp variable contains
         product of elements on left side
        excluding arr[i]
         */
        for (i = 0; i < n; i++) {
            prod[i] = temp;
            temp *= arr[i];
        }

        /* Initialize temp to 1 for
        product on right side */
        temp = 1;

        /*
          In this loop, temp variable contains
         product of elements on right side
         excluding arr[i]
         */
        for (i = n - 1; i >= 0; i--) {
            prod[i] *= temp;
            temp *= arr[i];
        }

        /* print the constructed prod array */
        for (i = 0; i < n; i++)
            document.write(prod[i] + " ");

        return;
    }

    /* Driver program to test above functions */


        var arr = [ 10, 3, 5, 6, 2 ];
        var n = arr.length;
        document.write("The product array is : ");
        productArray(arr, n);

// This code contributed by Rajput-Ji

</script>

Output

The product array is: 
180 600 360 300 900 

Complexity Analysis:

• Time Complexity: O(n). 
  The original array needs to be traversed only once, so the time complexity is constant.
• Space Complexity: O(n). 
  Even though the extra arrays are removed, the space complexity remains O(n), as the product array is still needed.

Another Approach:

Store the product of all the elements is a variable and then iterate the array and add product/current_index_value in a new array. and then return this new array.

Below is the implementation of the above approach:

C++

// C++ program for the above approach
#include <iostream>
using namespace std;

long* productExceptSelf(int a[], int n)
{
    long prod = 1;
    long flag = 0;

    // product of all elements
    for (int i = 0; i < n; i++) {
        // counting number of elements which have value 0
        if (a[i] == 0)
            flag++;
        else
            prod *= a[i];
    }

    // creating a new array of size n
    long* arr = new long[n];

    for (int i = 0; i < n; i++) {

        // if number of elements in array with value 0 is
        // more than 1 than each value in new array will be
        // equal to 0
        if (flag > 1)
            arr[i] = 0;

        // if no element having value 0 than we will insert
        // product/a[i] in new array
        else if (flag == 0)
            arr[i] = (prod / a[i]);

        // if 1 element of array having value 0 than all the
        // elements except that index value , will be equal
        // to 0
        else if (flag == 1 && a[i] != 0)
            arr[i] = 0;

        // if(flag == 1 && a[i] == 0)
        else
            arr[i] = prod;
    }
    return arr;
}

// Driver Code
int main()
{
    int n = 5;
    int array[] = { 10, 3, 5, 6, 2 };

    long* ans;
    ans = productExceptSelf(array, n);

    for (int i = 0; i < n; i++) {
        cout << ans[i] << " ";
    }
    return 0;
}

// This code is contributed by Aditya Kumar (adityakumar129)

C

// C program for the above approach
#include <stdio.h>

void productExceptSelf(int a[], int n)
{
    long prod = 1;
    long flag = 0;

    // product of all elements
    for (int i = 0; i < n; i++) {
        // counting number of elements which have value 0
        if (a[i] == 0)
            flag++;
        else
            prod *= a[i];
    }

    // creating a new array of size n
    long arr[n];

    for (int i = 0; i < n; i++) {

        // if number of elements in array with value 0 is
        // more than 1 than each value in new array will be
        // equal to 0
        if (flag > 1)
            arr[i] = 0;

        // if no element having value 0 than we will insert
        // product/a[i] in new array
        else if (flag == 0)
            arr[i] = (prod / a[i]);

        // if 1 element of array having value 0 than all the
        // elements except that index value , will be equal
        // to 0
        else if (flag == 1 && a[i] != 0)
            arr[i] = 0;

        // if(flag == 1 && a[i] == 0)
        else
            arr[i] = prod;
    }
    for (int i = 0; i < n; i++)
        printf("%ld ", arr[i]);
}

// Driver Code
int main()
{
    int n = 5;
    int array[] = { 10, 3, 5, 6, 2 };
    productExceptSelf(array, n);
    return 0;
}

// This code is contributed by Aditya Kumar (adityakumar129)

Java

// Java program for the above approach
import java.io.*;
import java.util.*;

class Solution {

    public static long[] productExceptSelf(int a[], int n)
    {
        long prod = 1;
        long flag = 0;

        // product of all elements
        for (int i = 0; i < n; i++) {

            // counting number of elements
            // which have value
            // 0
            if (a[i] == 0)
                flag++;
            else
                prod *= a[i];
        }

        // creating a new array of size n
        long arr[] = new long[n];
        for (int i = 0; i < n; i++) {

            // if number of elements in
            // array with value 0
            // is more than 1 than each
            // value in new array
            // will be equal to 0
            if (flag > 1) {
                arr[i] = 0;
            }

            // if no element having value
            // 0 than we will
            // insert product/a[i] in new array
            else if (flag == 0)
                arr[i] = (prod / a[i]);

            // if 1 element of array having
            // value 0 than all
            // the elements except that index
            // value , will be
            // equal to 0
            else if (flag == 1 && a[i] != 0) {
                arr[i] = 0;
            }

            // if(flag == 1 && a[i] == 0)
            else
                arr[i] = prod;
        }
        return arr;
    }

    // Driver Code
    public static void main(String args[])
        throws IOException
    {
        int n = 5;
        int[] array = { 10, 3, 5, 6, 2 };

        Solution ob = new Solution();
        long[] ans = new long[n];
        ans = ob.productExceptSelf(array, n);

        for (int i = 0; i < n; i++) {
            System.out.print(ans[i] + " ");
        }
    }
}

// This code is contributed by Kapil Kumar (kapilkumar2001)

Python3

# Python3 program for the above approach
def productExceptSelf(a, n):

    prod = 1
    flag = 0

    for i in range(n):

        # Counting number of elements
        # which have value
        # 0
        if (a[i] == 0):
            flag += 1
        else:
            prod *= a[i]

    # Creating a new array of size n
    arr = [0 for i in range(n)]

    for i in range(n):

        # If number of elements in
        # array with value 0
        # is more than 1 than each
        # value in new array
        # will be equal to 0
        if (flag > 1):
            arr[i] = 0

        # If no element having value
        # 0 than we will
        # insert product/a[i] in new array
        elif (flag == 0):
            arr[i] = (prod // a[i])

        # If 1 element of array having
        # value 0 than all
        # the elements except that index
        # value , will be
        # equal to 0
        elif (flag == 1 and a[i] != 0):
            arr[i] = 0

        # If(flag == 1 && a[i] == 0)
        else:
            arr[i] = prod

    return arr


# Driver Code
n = 5
array = [10, 3, 5, 6, 2]
ans = productExceptSelf(array, n)

print(*ans)

# This code is contributed by rag2127

C#

using System;

public class GFG {

    public static long[] productExceptSelf(int[] a, int n)
    {
        long prod = 1;
        long flag = 0;

        // product of all elements
        for (int i = 0; i < n; i++) {

            // counting number of elements
            // which have value
            // 0
            if (a[i] == 0)
                flag++;
            else
                prod *= a[i];
        }

        // creating a new array of size n
        long[] arr = new long[n];
        for (int i = 0; i < n; i++) {

            // if number of elements in
            // array with value 0
            // is more than 1 than each
            // value in new array
            // will be equal to 0
            if (flag > 1) {
                arr[i] = 0;
            }

            // if no element having value
            // 0 than we will
            // insert product/a[i] in new array
            else if (flag == 0)
                arr[i] = (prod / a[i]);

            // if 1 element of array having
            // value 0 than all
            // the elements except that index
            // value , will be
            // equal to 0
            else if (flag == 1 && a[i] != 0) {
                arr[i] = 0;
            }

            // if(flag == 1 && a[i] == 0)
            else
                arr[i] = prod;
        }
        return arr;
    }

    // Driver Code

    static public void Main()
    {

        int n = 5;
        int[] array = { 10, 3, 5, 6, 2 };

        long[] ans = new long[n];
        ans = productExceptSelf(array, n);

        for (int i = 0; i < n; i++) {
            Console.Write(ans[i] + " ");
        }
    }
}

// This code is contributed by avanitrachhadiya2155

Javascript

<script>

// Javascript program for the above approach
function productExceptSelf(a, n)
{
    let prod = 1;
    let flag = 0;

    // Product of all elements
    for(let i = 0; i < n; i++)
    {

        // Counting number of elements
        // which have value
        // 0
        if (a[i] == 0)
            flag++;
        else
            prod *= a[i];
    }

    // Creating a new array of size n
    let arr = Array(n).fill(0);
    for(let i = 0; i < n; i++)
    {

        // If number of elements in
        // array with value 0
        // is more than 1 than each
        // value in new array
        // will be equal to 0
        if (flag > 1)
        {
            arr[i] = 0;
        }

        // If no element having value
        // 0 than we will
        // insert product/a[i] in new array
        else if (flag == 0)
            arr[i] = (prod / a[i]);

        // If 1 element of array having
        // value 0 than all
        // the elements except that index
        // value , will be
        // equal to 0
        else if (flag == 1 && a[i] != 0)
        {
            arr[i] = 0;
        }

        // If(flag == 1 && a[i] == 0)
        else
            arr[i] = prod;
    }
    return arr;
}

// Driver code
let n = 5;
let array = [ 10, 3, 5, 6, 2 ];
let ans = Array(n).fill(0);
ans = productExceptSelf(array, n);

for(let i = 0; i < n; i++)
{
    document.write(ans[i] + " ");
}

// This code is contributed by avijitmondal1998

</script>

Output

180 600 360 300 900 

Time Complexity: O(n)

Space Complexity: O(n)

A product array puzzle | Set 2 (O(1) Space)
Related Problem:
Construct an Array from XOR of all elements of array except element at same index
Please write comments if you find the above code/algorithm incorrect, or find better ways to solve the same problem.