 Open in App
Not now

# A product array puzzle | Set 2 (O(1) Space)

• Difficulty Level : Hard
• Last Updated : 15 Jul, 2022

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 and in O(n).

Example:

```Input: arr[] = {10, 3, 5, 6, 2}
Output: prod[] = {180, 600, 360, 300, 900}
The elements of output array are
{3*5*6*2, 10*5*6*2, 10*3*6*2,
10*3*5*2, 10*3*5*6}

Input: arr[] = {1, 2, 1, 3, 4}
Output: prod[] = {24, 12, 24, 8, 6}
The elements of output array are
{3*4*1*2, 1*1*3*4, 4*3*2*1,
1*1*4*2, 1*1*3*2}```

There is already a discussed O(n) approach in A product array puzzle | set 1. The previous approach uses extra O(n) space for constructing product array.

Solution 1: Using log property.

Approach: In this post, a better approach has been discussed which uses log property to find the product of all elements of the array except at a particular index. This approach uses no extra space.

Use property of log to multiply large numbers

```x = a * b * c * d
log(x) = log(a * b * c * d)
log(x) = log(a) + log(b) + log(c) + log(d)
x = antilog(log(a) + log(b) + log(c) + log(d))```

So the idea is simple,
Traverse the array and find the sum of log of all the elements,

```log(a) + log(a) +
.. + log(a[n-1])```

Then again traverse through the array and find the product using this formula.

```antilog((log(a) + log(a) +
.. + log(a[n-1])) - log(a[i]))```

This equals to product of all the elements except a[i], i.e antilog(sum- log(a[i])).

Implementation:

## C++

 `// C++ program for product array puzzle``// with O(n) time and O(1) space.``#include ``using` `namespace` `std;` `// epsilon value to maintain precision``#define EPS 1e-9` `void` `productPuzzle(``int` `a[], ``int` `n)``{``    ``// to hold sum of all values``    ``long` `double` `sum = 0;``    ``for` `(``int` `i = 0; i < n; i++)``        ``sum += (``long` `double``)``log10``(a[i]);` `    ``// output product for each index``    ``// antilog to find original product value``    ``for` `(``int` `i = 0; i < n; i++)``        ``cout << (``int``)(EPS + ``pow``((``long` `double``)10.00, sum - ``log10``(a[i]))) << ``" "``;``}` `// Driver code``int` `main()``{``    ``int` `a[] = { 10, 3, 5, 6, 2 };``    ``int` `n = ``sizeof``(a) / ``sizeof``(a);``    ``cout << ``"The product array is: \n"``;``    ``productPuzzle(a, n);``    ``return` `0;``}` `// This code is contributed by Aditya Kumar (adityakumar129)`

## C

 `// C program for product array puzzle``// with O(n) time and O(1) space.``#include ``#include ` `// epsilon value to maintain precision``#define EPS 1e-9` `void` `productPuzzle(``int` `a[], ``int` `n)``{``    ``// to hold sum of all values``    ``long` `double` `sum = 0;``    ``for` `(``int` `i = 0; i < n; i++)``        ``sum += (``long` `double``)``log10``(a[i]);` `    ``// output product for each index``    ``// antilog to find original product value``    ``for` `(``int` `i = 0; i < n; i++)``        ``printf``(``"%d "``,(``int``)(EPS + ``pow``((``long` `double``)10.00, sum - ``log10``(a[i]))));``}` `// Driver code``int` `main()``{``    ``int` `a[] = { 10, 3, 5, 6, 2 };``    ``int` `n = ``sizeof``(a) / ``sizeof``(a);``    ``printf``(``"The product array is: \n"``);``    ``productPuzzle(a, n);``    ``return` `0;``}` `// This code is contributed by Aditya Kumar (adityakumar129)`

## Java

 `// Java program for product array puzzle``// with O(n) time and O(1) space.``public` `class` `Array_puzzle_2 {` `    ``// epsilon value to maintain precision``    ``static` `final` `double` `EPS = 1e-``9``;` `    ``static` `void` `productPuzzle(``int` `a[], ``int` `n)``    ``{``        ``// to hold sum of all values``        ``double` `sum = ``0``;``        ``for` `(``int` `i = ``0``; i < n; i++)``            ``sum += Math.log10(a[i]);` `        ``// output product for each index``        ``// anti log to find original product value``        ``for` `(``int` `i = ``0``; i < n; i++)``            ``System.out.print(``                ``(``int``)(EPS``                      ``+ Math.pow(``                            ``10.00``, sum``                                       ``- Math.log10(a[i])))``                ``+ ``" "``);``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String args[])``    ``{``        ``int` `a[] = { ``10``, ``3``, ``5``, ``6``, ``2` `};``        ``int` `n = a.length;``        ``System.out.println(``"The product array is: "``);``        ``productPuzzle(a, n);``    ``}``}``// This code is contributed by Sumit Ghosh`

## Python3

 `# Python program for product array puzzle``# with O(n) time and O(1) space.` `import` `math` `# epsilon value to maintain precision``EPS ``=` `1e``-``9` `def` `productPuzzle(a, n):``   ` `    ``# to hold sum of all values``    ``sum` `=` `0``    ``for` `i ``in` `range``(n):``        ``sum` `+``=` `math.log10(a[i])``    ` `    ``# output product for each index``    ``# antilog to find original product value``    ``for` `i ``in` `range``(n):``        ``print` `(``int``((EPS ``+` `pow``(``10.00``, ``sum` `-` `math.log10(a[i])))),end``=``" "``)``    ` `    ``return`` ` `# Driver code``a ``=` `[``10``, ``3``, ``5``, ``6``, ``2` `]``n ``=` `len``(a)``print` `(``"The product array is: "``)``productPuzzle(a, n)` `# This code is contributed by Sachin Bisht`

## C#

 `// C# program for product``// array puzzle with O(n)``// time and O(1) space.``using` `System;``class` `GFG {` `    ``// epsilon value to``    ``// maintain precision``    ``static` `double` `EPS = 1e-9;` `    ``static` `void` `productPuzzle(``int``[] a,``                              ``int` `n)``    ``{``        ``// to hold sum of all values``        ``double` `sum = 0;``        ``for` `(``int` `i = 0; i < n; i++)``            ``sum += Math.Log10(a[i]);` `        ``// output product for each``        ``// index anti log to find``        ``// original product value``        ``for` `(``int` `i = 0; i < n; i++)``            ``Console.Write((``int``)(EPS + Math.Pow(10.00, sum - Math.Log10(a[i]))) + ``" "``);``    ``}` `    ``// Driver code``    ``public` `static` `void` `Main()``    ``{``        ``int``[] a = { 10, 3, 5, 6, 2 };``        ``int` `n = a.Length;``        ``Console.WriteLine(``"The product array is: "``);``        ``productPuzzle(a, n);``    ``}``}` `// This code is contributed by mits`

## PHP

 ``

## Javascript

 ``

Output:

```The product array is:
180 600 360 300 900```

Complexity Analysis:

• Time Complexity: O(n).
Only two traversals of the array is required.
• Space Complexity: O(1).
No extra space is required.

Alternate Approach: Here’s another approach to solve the above problem by the use of pow() function, does not use division and works in O(n) time.
Traverse the array and find the product of all the elements in the array. Store the product in a variable.

Then again traverse the array and find the product of all the elements except that number by using the formula (product * pow(a[i], -1))

Implementation:

## C++

 `// C++ program for product array puzzle``// with O(n) time and O(1) space.``#include ``using` `namespace` `std;` `// Solve function which prints the answer``void` `solve(``int` `arr[], ``int` `n)``{` `    ``// Initialize a variable to store the``    ``// total product of the array elements``    ``int` `prod = 1;``    ``for` `(``int` `i = 0; i < n; i++)``        ``prod *= arr[i];` `    ``// we know x/y mathematically is same``    ``// as x*(y to power -1)``    ``for` `(``int` `i = 0; i < n; i++) {``        ``cout << (``int``)(prod * ``pow``(arr[i], -1)) << ``' '``;``    ``}``}` `// Driver Code``int` `main()``{``    ``int` `arr[] = { 10, 3, 5, 6, 2 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr);``    ``solve(arr, n);``    ``return` `0;``}` `// This code is contributed by Aditya Kumar (adityakumar129)`

## C

 `// C program for product array puzzle``// with O(n) time and O(1) space.``#include ``#include ` `// Solve function which prints the answer``void` `solve(``int` `arr[], ``int` `n)``{` `    ``// Initialize a variable to store the``    ``// total product of the array elements``    ``int` `prod = 1;``    ``for` `(``int` `i = 0; i < n; i++)``        ``prod *= arr[i];` `    ``// we know x/y mathematically is same``    ``// as x*(y to power -1)``    ``for` `(``int` `i = 0; i < n; i++)``        ``printf``(``"%d "``, (``int``)(prod * ``pow``(arr[i], -1)));``}` `// Driver Code``int` `main()``{``    ``int` `arr[] = { 10, 3, 5, 6, 2 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr);``    ``solve(arr, n);``    ``return` `0;``}` `// This code is contributed by Aditya Kumar (adityakumar129)`

## Java

 `// Java program for product array puzzle``// with O(n) time and O(1) space.``public` `class` `ArrayPuzzle {` `    ``static` `void` `solve(``int` `arr[], ``int` `n)``    ``{``        ``// Initialize a variable to store the``        ``// total product of the array elements``        ``int` `prod = ``1``;``        ``for` `(``int` `i = ``0``; i < n; i++)``            ``prod *= arr[i];` `        ``// we know x/y mathematically is same``        ``// as x*(y to power -1)``        ``for` `(``int` `i = ``0``; i < n; i++)``            ``System.out.print(``                ``(``int``)prod * Math.pow(arr[i], -``1``) + ``" "``);``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String args[])``    ``{``        ``int` `arr[] = { ``10``, ``3``, ``5``, ``6``, ``2` `};``        ``int` `n = arr.length;``        ``solve(arr, n);``    ``}``}``// This code is contributed by Sitesh Roy`

## Python3

 `# Python program for product array puzzle``# with O(n) time and O(1) space.``def` `solve(arr, n):` `    ``# Initialize a variable to store the``    ``# total product of the array elements``    ``prod ``=` `1``    ``for` `i ``in` `arr:``        ``prod ``*``=` `i` `    ``# we know x / y mathematically is same``    ``# as x*(y to power -1)``    ``for` `i ``in` `arr:``        ``print``(``int``(prod``*``(i``*``*``-``1``)), end ``=``" "``)` `# Driver Code``arr ``=` `[``10``, ``3``, ``5``, ``6``, ``2``]``n ``=` `len``(arr)``solve(arr, n)`  `# This code is contributed by Sitesh Roy`

## C#

 `// C# program for product array puzzle``// with O(n) time and O(1) space.``using` `System;` `class` `GFG {` `public``    ``class` `ArrayPuzzle {` `        ``static` `void` `solve(``int``[] arr, ``int` `n)``        ``{``            ``// Initialize a variable to store the``            ``// total product of the array elements``            ``int` `prod = 1;``            ``for` `(``int` `i = 0; i < n; i++)``                ``prod *= arr[i];` `            ``// we know x/y mathematically is same``            ``// as x*(y to power -1)``            ``for` `(``int` `i = 0; i < n; i++)``                ``Console.Write(``                    ``(``int``)prod * Math.Pow(arr[i], -1) + ``" "``);``        ``}` `        ``// Driver code``        ``static` `public` `void` `Main()``        ``{``            ``int``[] arr = { 10, 3, 5, 6, 2 };``            ``int` `n = arr.Length;``            ``solve(arr, n);``        ``}``    ``}``}``// This code is contributed by shivanisinghss2110`

## Javascript

 ``

Output:

`180 600 360 300 900`

Complexity Analysis:

• Time complexity: O(n), Only two traversals of the array is required.
• Space complexity: O(1), No extra space is required.

Note: This approach assumes that the array elements are not 0.
This approach is given by Sitesh Roy

If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

My Personal Notes arrow_drop_up