# Find an element which divides the array in two subarrays with equal product

Given, an array of size N. Find an element which divides the array into two sub-arrays with equal product. Print -1 if no such partition is not possible.

Examples :

```Input : 1 4 2 1 4
Output : 2
If 2 is the partition,
subarrays are : {1, 4} and {1, 4}

Input : 2, 3, 4, 1, 4, 6
Output : 1
If 1 is the partition,
Subarrays are : {2, 3, 4} and {4, 6}
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

A simple solution will be to consider every element starting from the second element. Compute the product of elements on its left and product of elements on its right. If these two products are same, return the element.
Time Complexity: O(N2)

A better solution will be to use prefix and suffix product arrays. Traverse from 0 to n-1th index, the index at which they yield an equal result, is the index where the array is partitioned with an equal product.
Time Complexity: O(N)
Auxiliary Space: O(N)

## C++

 `// C++ program to find an element which divides ` `// the array in two sub-arrays with equal product. ` `#include ` `using` `namespace` `std; ` ` `  `// Function to find the index ` `int` `findElement(``int` `arr[], ``int` `n) ` `{ ` `    ``// Forming prefix sum array from 0 ` `    ``int` `prefixMul[n]; ` `    ``prefixMul[0] = arr[0]; ` `    ``for` `(``int` `i = 1; i < n; i++) ` `        ``prefixMul[i] = prefixMul[i - 1] * arr[i]; ` ` `  `    ``// Forming suffix sum array from n-1 ` `    ``int` `suffixMul[n]; ` `    ``suffixMul[n - 1] = arr[n - 1]; ` `    ``for` `(``int` `i = n - 2; i >= 0; i--) ` `        ``suffixMul[i] = suffixMul[i + 1] * arr[i]; ` ` `  `    ``// Find the point where prefix and suffix ` `    ``// sums are same. ` `    ``for` `(``int` `i = 1; i < n - 1; i++) ` `        ``if` `(prefixMul[i] == suffixMul[i]) ` `            ``return` `arr[i]; ` ` `  `    ``return` `-1; ` `} ` `// Driver code ` `int` `main() ` `{ ` `    ``int` `arr[] = { 2, 3, 4, 1, 4, 6 }; ` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]); ` `    ``cout << findElement(arr, n); ` `    ``return` `0; ` `} `

## Java

 `// Java program to find an element  ` `// which divides the array in two  ` `// sub-arrays with equal product. ` `class` `GFG ` `{ ` `     `  `// Function to find ` `// the index ` `static` `int` `findElement(``int` `arr[],  ` `                       ``int` `n) ` `{ ` `    ``// Forming prefix  ` `    ``// sum array from 0 ` `    ``int` `prefixMul[] = ``new` `int``[n]; ` `    ``prefixMul[``0``] = arr[``0``]; ` `    ``for` `(``int` `i = ``1``; i < n; i++) ` `        ``prefixMul[i] = prefixMul[i - ``1``] *  ` `                                  ``arr[i]; ` ` `  `    ``// Forming suffix sum  ` `    ``// array from n-1 ` `    ``int` `suffixMul[] = ``new` `int``[n]; ` `    ``suffixMul[n - ``1``] = arr[n - ``1``]; ` `    ``for` `(``int` `i = n - ``2``; i >= ``0``; i--) ` `        ``suffixMul[i] = suffixMul[i + ``1``] *  ` `                                  ``arr[i]; ` ` `  `    ``// Find the point where prefix  ` `    ``// and suffix sums are same. ` `    ``for` `(``int` `i = ``1``; i < n - ``1``; i++) ` `        ``if` `(prefixMul[i] == suffixMul[i]) ` `            ``return` `arr[i]; ` ` `  `    ``return` `-``1``; ` `} ` ` `  `// Driver code ` `public` `static` `void` `main(String args[]) ` `{ ` `    ``int` `arr[] = {``2``, ``3``, ``4``,  ` `                 ``1``, ``4``, ``6``}; ` `                  `  `    ``int` `n = arr.length; ` `    ``System.out.println(findElement(arr, n)); ` ` `  `} ` `} ` ` `  `// This code is contributed  ` `// by Arnab Kundu `

## Python3

 `# Python3 program to find an element   ` `# which divides the array in two   ` `# sub-arrays with equal product.  ` ` `  `# Function to find the index ` `def` `findElement(arr, n): ` `    ``# Forming prefix sum array from 0 ` `    ``prefixMul ``=` `[] ` `    ``prefixMul.append(arr[``0``]) ` `    ``for` `i ``in` `range``(``1``, n): ` `        ``prefixMul.append(prefixMul[i``-``1``]``*``arr[i]) ` ` `  `    ``# Forming suffix sum array from n-1  ` `    ``suffixMul ``=` `[``None` `for` `i ``in` `range``(``0``, n)] ` `    ``suffixMul[n``-``1``] ``=` `arr[n``-``1``] ` `    ``for` `i ``in` `range``(n``-``2``, ``-``1``, ``-``1``): ` `        ``suffixMul[i] ``=` `suffixMul[i``+``1``]``*``arr[i] ` ` `  `    ``# Find the point where prefix and suffix  ` `    ``# sums are same.  ` `    ``for` `i ``in` `range``(``1``, n``-``1``): ` `        ``if` `prefixMul[i] ``=``=` `suffixMul[i]: ` `            ``return` `arr[i] ` `             `  `    ``return` `-``1` ` `  `# Driver Code ` `arr ``=` `[``2``, ``3``, ``4``, ``1``, ``4``, ``6``] ` `n ``=` `len``(arr) ` `print``(findElement(arr, n)) ` ` `  `# This code is contributed by SamyuktaSHegde `

## C#

 `// C# program to find an element  ` `// which divides the array in two  ` `// sub-arrays with equal product. ` `using` `System; ` ` `  `class` `GFG ` `{ ` `    ``// Function to find ` `    ``// the index ` `    ``static` `int` `findElement(``int` `[]arr,  ` `                           ``int` `n) ` `    ``{ ` `    ``// Forming prefix  ` `    ``// sum array from 0 ` `    ``int` `[]prefixMul = ``new` `int``[n]; ` `    ``prefixMul[0] = arr[0]; ` `     `  `    ``for` `(``int` `i = 1; i < n; i++) ` `        ``prefixMul[i] = prefixMul[i - 1] *  ` `                                  ``arr[i]; ` ` `  `    ``// Forming suffix sum  ` `    ``// array from n-1 ` `    ``int` `[]suffixMul = ``new` `int``[n]; ` `    ``suffixMul[n - 1] = arr[n - 1]; ` `     `  `    ``for` `(``int` `i = n - 2; i >= 0; i--) ` `        ``suffixMul[i] = suffixMul[i + 1] * ` `                                  ``arr[i]; ` ` `  `    ``// Find the point where prefix  ` `    ``// and suffix sums are same. ` `    ``for` `(``int` `i = 1; i < n - 1; i++) ` `        ``if` `(prefixMul[i] == suffixMul[i]) ` `            ``return` `arr[i]; ` ` `  `    ``return` `-1; ` `} ` ` `  `// Driver code ` `public` `static` `void` `Main() ` `{ ` `    ``int` `[]arr = {2, 3, 4, 1, 4, 6}; ` `                 `  `    ``int` `n = arr.Length; ` `    ``Console.Write(findElement(arr, n)); ` `} ` `} ` ` `  `// This code is contributed ` `// by shiv_bhakt `

## PHP

 `= 0; ``\$i``--) ` `        ``\$suffixMul``[``\$i``] = ``\$suffixMul``[``\$i` `+ 1] *  ` `                         ``\$arr``[``\$i``]; ` ` `  `    ``// Find the point where  ` `    ``// prefix and suffix sums ` `    ``// are same. ` `    ``for` `(``\$i` `= 1; ``\$i` `< ``\$n` `- 1; ``\$i``++) ` `        ``if` `(``\$prefixMul``[``\$i``] == ``\$suffixMul``[``\$i``]) ` `            ``return` `\$arr``[``\$i``]; ` ` `  `    ``return` `-1; ` `} ` ` `  `// Driver code ` `\$arr` `= ``array``( 2, 3, 4, 1, 4, 6 ); ` `\$n` `= sizeof(``\$arr``) / sizeof(``\$arr``[0]); ` `echo` `findElement(``\$arr``, ``\$n``); ` ` `  `// This code is contributed  ` `// by shiv_bhakt ` `?> `

Output:

```1
```

An efficient solution will be to calculate the product of the whole array except the first element in right_mul, considering it to be the partitioning element. Now, we traverse the array from left to right, dividing an element from right_mul and multiplying an element to left_mul. The point where right_mul equals left_mul, we get the partition.

Time Complexity: O(N)
Auxiliary Space: O(1)

## C++

 `// C++ program to find an element which divides ` `// the array in two sub-arrays with equal product. ` `#include ` `using` `namespace` `std; ` ` `  `// Function to compute partition ` `int` `findElement(``int` `arr[], ``int` `size) ` `{ ` `    ``int` `right_mul = 1, left_mul = 1; ` ` `  `    ``// Computing right_sum ` `    ``for` `(``int` `i = 1; i < size; i++) ` `        ``right_mul *= arr[i]; ` ` `  `    ``// Checking the point of partition ` `    ``// i.e. left_Sum == right_sum ` `    ``for` `(``int` `i = 0, j = 1; j < size; i++, j++) { ` `        ``right_mul /= arr[j]; ` `        ``left_mul *= arr[i]; ` ` `  `        ``if` `(left_mul == right_mul) ` `            ``return` `arr[i + 1]; ` `    ``} ` ` `  `    ``return` `-1; ` `} ` `// Driver Code ` `int` `main() ` `{ ` `    ``int` `arr[] = { 2, 3, 4, 1, 4, 6 }; ` `    ``int` `size = ``sizeof``(arr) / ``sizeof``(arr[0]); ` `    ``cout << findElement(arr, size); ` `    ``return` `0; ` `} `

## Java

 `// Java program to find an  ` `// element which divides the ` `// array in two sub-arrays  ` `// with equal product. ` `class` `GFG ` `{ ` ` `  `// Function to ` `// compute partition ` `static` `int` `findElement(``int` `arr[],  ` `                       ``int` `size) ` `{ ` `    ``int` `right_mul = ``1``,  ` `        ``left_mul = ``1``; ` ` `  `    ``// Computing right_sum ` `    ``for` `(``int` `i = ``1``; i < size; i++) ` `        ``right_mul *= arr[i]; ` ` `  `    ``// Checking the point of ` `    ``// partition i.e. left_Sum  ` `    ``// == right_sum ` `    ``for` `(``int` `i = ``0``, j = ``1``;  ` `             ``j < size; i++, j++)  ` `    ``{ ` `        ``right_mul /= arr[j]; ` `        ``left_mul *= arr[i]; ` ` `  `        ``if` `(left_mul == right_mul) ` `            ``return` `arr[i + ``1``]; ` `    ``} ` ` `  `    ``return` `-``1``; ` `} ` ` `  `// Driver Code ` `public` `static` `void` `main(String args[]) ` `{ ` `    ``int` `arr[] = {``2``, ``3``, ``4``, ``1``, ``4``, ``6``}; ` `    ``int` `size = arr.length; ` `    ``System.out.println(findElement(arr,  ` `                                   ``size)); ` `} ` `} ` `// This code is contributed  ` `// by Arnab Kundu `

## Python3

 `# Python program to find an element which divides ` `# the array in two sub-arrays with equal product. ` ` `  `# Function to compute partition ` `def` `findElement(arr, size): ` ` `  `    ``right_mul ``=` `1``; ` `    ``left_mul ``=` `1``; ` ` `  `    ``# Computing right_sum ` `    ``for` `i ``in` `range``(``1``,size): ` `        ``right_mul ``=` `right_mul ``*``arr[i]; ` `    ``# Checking the point of partition ` `    ``# i.e. left_Sum == right_sum ` `    ``for` `i, j ``in` `zip``(``range``(``0``,size), ``range``(``1``, size, ``1``)):     ` `        ``right_mul ``=``right_mul ``/` `arr[j]; ` `        ``left_mul ``=` `left_mul ``*` `arr[i]; ` ` `  `        ``if` `(left_mul ``=``=` `right_mul): ` `            ``return` `arr[i ``+` `1``]; ` `     `  ` `  `    ``return` `-``1``; ` ` `  `# Driver Code ` ` `  `arr ``=` `[ ``2``, ``3``, ``4``, ``1``, ``4``, ``6``,]; ` `size ``=` `len``(arr) ; ` `print``(findElement(arr, size)); ` `     `  `#This code is contributed by Shivi_Aggarwal `

## C#

 `// C# program to find an  ` `// element which divides the ` `// array in two sub-arrays  ` `// with equal product. ` `using` `System; ` ` `  `class` `GFG ` `{ ` `// Function to ` `// compute partition ` `static` `int` `findElement(``int` `[]arr, ` `                       ``int` `size) ` `{ ` `    ``int` `right_mul = 1,  ` `        ``left_mul = 1; ` ` `  `    ``// Computing right_sum ` `    ``for` `(``int` `i = 1; i < size; i++) ` `        ``right_mul *= arr[i]; ` ` `  `    ``// Checking the point of ` `    ``// partition i.e. left_Sum  ` `    ``// == right_sum ` `    ``for` `(``int` `i = 0, j = 1;  ` `            ``j < size; i++, j++)  ` `    ``{ ` `        ``right_mul /= arr[j]; ` `        ``left_mul *= arr[i]; ` ` `  `        ``if` `(left_mul == right_mul) ` `            ``return` `arr[i + 1]; ` `    ``} ` ` `  `    ``return` `-1; ` `} ` ` `  `// Driver Code ` `public` `static` `void` `Main() ` `{ ` `    ``int` `[]arr = ``new` `int``[] {2, 3, 4,  ` `                           ``1, 4, 6}; ` `    ``int` `size = arr.Length; ` `    ``Console.Write(findElement(arr, size)); ` `} ` `} ` ` `  `// This code is contributed  ` `// by shiv_bhakt. `

## PHP

 ` `

Output :

```1
```

My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

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

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Article Tags :
Practice Tags :

1

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.