# Find pair with greatest product in array

Given an array of n elements, the task is to find the greatest number such that it is product of two elements of given array. If no such element exists, print -1. Elements are within the range of 1 to 10^5.

Examples :

```Input :  arr[] = {10, 3, 5, 30, 35}
Output:  30
Explanation: 30 is the product of 10 and 3.

Input :  arr[] = {2, 5, 7, 8}
Output:  -1
Explanation: Since, no such element exists.

Input :  arr[] = {10, 2, 4, 30, 35}
Output:  -1

Input :  arr[] = {10, 2, 2, 4, 30, 35}
Output:  4

Input  : arr[] = {17, 2, 1, 35, 30}
Output : 35

```

## Recommended: Please solve it on “PRACTICE” first, before moving on to the solution.

A naive approach is to pick an element and then check for each pair product if equal to that number and update the max if the number is maximum,repeat until whole array gets traversed takes O(n^3) time.

## C++

 `// C++ program to find a pair with product ` `// in given array. ` `#include ` `using` `namespace` `std; ` ` `  `// Function to find greatest number that us ` `int` `findGreatest( ``int` `arr[] , ``int` `n) ` `{ ` `    ``int` `result = -1; ` `    ``for` `(``int` `i = 0; i < n ; i++) ` `        ``for` `(``int` `j = 0; j < n-1; j++) ` `            ``for` `(``int` `k = j+1 ; k < n  ; k++) ` `                ``if` `(arr[j] * arr[k] == arr[i]) ` `                    ``result = max(result, arr[i]); ` `    ``return` `result; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``// Your C++ Code ` `    ``int` `arr[] = {30, 10, 9, 3, 35}; ` `    ``int` `n = ``sizeof``(arr)/``sizeof``(arr); ` ` `  `    ``cout << findGreatest(arr, n); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java program to find a pair  ` `// with product in given array. ` `import` `java.io.*; ` ` `  `class` `GFG{ ` ` `  `static` `int` `findGreatest( ``int` `[]arr , ``int` `n) ` `{ ` `    ``int` `result = -``1``; ` `    ``for` `(``int` `i = ``0``; i < n ; i++) ` `        ``for` `(``int` `j = ``0``; j < n-``1``; j++) ` `            ``for` `(``int` `k = j+``1` `; k < n ; k++) ` `                ``if` `(arr[j] * arr[k] == arr[i]) ` `                    ``result = Math.max(result, arr[i]); ` `    ``return` `result; ` `} ` ` `  `    ``// Driver code ` `    ``static` `public` `void` `main (String[] args) ` `    ``{ ` `        ``int` `[]arr = {``30``, ``10``, ``9``, ``3``, ``35``}; ` `        ``int` `n = arr.length; ` ` `  `        ``System.out.println(findGreatest(arr, n)); ` `    ``} ` `} ` ` `  `//This code is contributed by vt_m. `

## Python 3

 `# Python 3 program to find a pair  ` `# with product in given array. ` ` `  `# Function to find greatest number  ` `def` `findGreatest( arr , n): ` ` `  `    ``result ``=` `-``1` `    ``for` `i ``in` `range``(n): ` `        ``for` `j ``in` `range``(n ``-` `1``): ` `            ``for` `k ``in` `range``(j ``+` `1``, n): ` `                ``if` `(arr[j] ``*` `arr[k] ``=``=` `arr[i]): ` `                    ``result ``=` `max``(result, arr[i]) ` `    ``return` `result ` ` `  `# Driver code ` `if` `__name__ ``=``=` `"__main__"``: ` `     `  `    ``arr ``=` `[ ``30``, ``10``, ``9``, ``3``, ``35``] ` `    ``n ``=` `len``(arr) ` ` `  `    ``print``(findGreatest(arr, n)) ` ` `  `# This code is contributed by ita_c `

## C#

 `// C# program to find a pair with product ` `// in given array. ` `using` `System; ` ` `  `class` `GFG{ ` ` `  `static` `int` `findGreatest( ``int` `[]arr , ``int` `n) ` `{ ` `    ``int` `result = -1; ` `    ``for` `(``int` `i = 0; i < n ; i++) ` `        ``for` `(``int` `j = 0; j < n-1; j++) ` `            ``for` `(``int` `k = j+1 ; k < n ; k++) ` `                ``if` `(arr[j] * arr[k] == arr[i]) ` `                    ``result = Math.Max(result, arr[i]); ` `    ``return` `result; ` `} ` ` `  `    ``// Driver code ` `    ``static` `public` `void` `Main () ` `    ``{ ` `       ``int` `[]arr = {30, 10, 9, 3, 35}; ` `       ``int` `n = arr.Length; ` ` `  `       ``Console.WriteLine(findGreatest(arr, n)); ` `    ``} ` `} ` ` `  `//This code is contributed by vt_m. `

## PHP

 ` `

Output :

```30
```

An efficient method follows below implementation:-

1. Create an empty hash table and store all array elements in it.
2. Sort the array in ascending order.
3. Pick elements one by one from end of the array.
4. And check if there exists a pair whose product is equal to that number. In this efficiency can be achieved. The idea is to reach till sqrt of that number. If we don’t get the pair till sqrt that means no such pair exists. We use hash table to make sure that we can find other element of pair in O(1) time.
5. Repeat steps 2 to 3 until we get the element or whole array gets traversed.

Below is the implementation.

## C++

 `// C++ program to find the largest product number ` `#include ` `using` `namespace` `std; ` ` `  `// Function to find greatest number ` `int` `findGreatest(``int` `arr[], ``int` `n) ` `{ ` `    ``// Store occurrences of all elements in hash ` `    ``// array ` `    ``unordered_map<``int``, ``int``> m; ` `    ``for` `(``int` `i = 0 ; i < n; i++) ` `        ``m[arr[i]]++; ` ` `  `    ``// Sort the array and traverse all elements from ` `    ``// end. ` `    ``sort(arr, arr+n); ` ` `  `    ``for` `(``int` `i=n-1; i>1; i--) ` `    ``{ ` `        ``// For every element, check if there is another ` `        ``// element which divides it. ` `        ``for` `(``int` `j=0; j 0) ` `                    ``return` `arr[i]; ` ` `  `                ``// To handle the case like arr[i] = 4 and ` `                ``// arr[j] = 2 ` `                ``else` `if` `(result == arr[j] && m[result] > 1) ` `                    ``return` `arr[i]; ` `            ``} ` `        ``} ` `    ``} ` `    ``return` `-1; ` `} ` ` `  `// Drivers code ` `int` `main() ` `{ ` `    ``int` `arr[] = {17, 2, 1, 15, 30}; ` `    ``int` `n = ``sizeof``(arr)/``sizeof``(arr); ` `    ``cout << findGreatest(arr, n); ` `    ``return` `0; ` `} `

## Java

 `// Java program to find the largest product number ` `import` `java.util.*; ` ` `  `class` `GFG  ` `{ ` ` `  `    ``// Function to find greatest number ` `    ``static` `int` `findGreatest(``int` `arr[], ``int` `n)  ` `    ``{ ` `        ``// Store occurrences of all  ` `        ``// elements in hash array ` `        ``Map m = ``new` `HashMap<>(); ` `        ``for` `(``int` `i = ``0``; i < n; i++)  ` `        ``{ ` `            ``if` `(m.containsKey(arr[i]))  ` `            ``{ ` `                ``m.put(arr[i], m.get(arr[i]) + ``1``); ` `            ``}  ` `            ``else`  `            ``{ ` `                ``m.put(arr[i], m.get(arr[i])); ` `            ``} ` `        ``} ` ` `  `        ``// m[arr[i]]++; ` `        ``// Sort the array and traverse  ` `        ``// all elements from end. ` `        ``Arrays.sort(arr); ` ` `  `        ``for` `(``int` `i = n - ``1``; i > ``1``; i--)  ` `        ``{ ` `            ``// For every element, check if there is another ` `            ``// element which divides it. ` `            ``for` `(``int` `j = ``0``; j < i &&  ` `                ``arr[j] <= Math.sqrt(arr[i]); j++)  ` `            ``{ ` `                ``if` `(arr[i] % arr[j] == ``0``)  ` `                ``{ ` `                    ``int` `result = arr[i] / arr[j]; ` ` `  `                    ``// Check if the result value exists in array ` `                    ``// or not if yes the return arr[i] ` `                    ``if` `(result != arr[j] &&  ` `                        ``m.get(result) == ``null``|| m.get(result) > ``0``) ` `                    ``{ ` `                        ``return` `arr[i]; ` `                    ``}  ` `                     `  `                    ``// To handle the case like arr[i] = 4 ` `                    ``// and arr[j] = 2 ` `                    ``else` `if` `(result == arr[j] && m.get(result) > ``1``)  ` `                    ``{ ` `                        ``return` `arr[i]; ` `                    ``} ` `                ``} ` `            ``} ` `        ``} ` `        ``return` `-``1``; ` `    ``} ` ` `  `    ``// Driver code ` `    ``public` `static` `void` `main(String[] args)  ` `    ``{ ` `        ``int` `arr[] = {``17``, ``2``, ``1``, ``15``, ``30``}; ` `        ``int` `n = arr.length; ` `        ``System.out.println(findGreatest(arr, n)); ` `    ``} ` `}  ` ` `  `// This code is contributed by PrinciRaj1992 `

## Python

 `# Python3 program to find the largest product number ` `from` `math ``import` `sqrt ` ` `  `# Function to find greatest number ` `def` `findGreatest(arr, n): ` ` `  `    ``# Store occurrences of all elements in hash ` `    ``# array ` `    ``m ``=` `dict``() ` ` `  `    ``for` `i ``in` `arr: ` `        ``m[i] ``=` `m.get(i, ``0``) ``+` `1` ` `  `    ``# Sort the array and traverse all elements from ` `    ``# end. ` `    ``arr``=``sorted``(arr) ` ` `  `    ``for` `i ``in` `range``(n ``-` `1``, ``0``, ``-``1``): ` `         `  `        ``# For every element, check if there is another ` `        ``# element which divides it. ` `        ``j ``=` `0` `        ``while``(j < i ``and` `arr[j] <``=` `sqrt(arr[i])): ` ` `  `            ``if` `(arr[i] ``%` `arr[j] ``=``=` `0``): ` ` `  `                ``result ``=` `arr[i]``/``/``arr[j] ` ` `  `                ``# Check if the result value exists in array ` `                ``# or not if yes the return arr[i] ` `                ``if` `(result !``=` `arr[j] ``and` `(result ``in` `m.keys() )``and` `m[result] > ``0``): ` `                    ``return` `arr[i] ` ` `  `                ``# To handle the case like arr[i] = 4 and ` `                ``# arr[j] = 2 ` `                ``elif` `(result ``=``=` `arr[j] ``and` `(result ``in` `m.keys()) ``and` `m[result] > ``1``): ` `                    ``return` `arr[i] ` ` `  `            ``j ``+``=` `1` ` `  ` `  `    ``return` `-``1` ` `  `# Drivers code ` `arr``=` `[``17``, ``2``, ``1``, ``15``, ``30``] ` `n ``=` `len``(arr) ` `print``(findGreatest(arr, n)) ` ` `  `# This code is contributed by mohit kumar `

## C#

 `// C# program to find the largest product number ` `using` `System; ` `using` `System.Collections.Generic; ` ` `  `class` `GFG  ` `{ ` ` `  `    ``// Function to find greatest number ` `    ``static` `int` `findGreatest(``int` `[]arr, ``int` `n)  ` `    ``{ ` `        ``// Store occurrences of all  ` `        ``// elements in hash array ` `        ``Dictionary<``int``,``int``> m = ``new` `Dictionary<``int``,``int``> (); ` `        ``for` `(``int` `i = 0; i < n; i++)  ` `        ``{ ` `            ``if` `(m.ContainsKey(arr[i]))  ` `            ``{ ` `                ``var` `a = m[arr[i]] + 1; ` `                 `  `                ``// m.Remove(arr[i]); ` `                ``m.Add(arr[i], a); ` `            ``}  ` `            ``else` `            ``{ ` `                ``m.Add(arr[i], arr[i]); ` `            ``} ` `        ``} ` ` `  `        ``// m[arr[i]]++; ` `        ``// Sort the array and traverse  ` `        ``// all elements from end. ` `        ``Array.Sort(arr); ` ` `  `        ``for` `(``int` `i = n - 1; i > 1; i--)  ` `        ``{ ` `            ``// For every element, check if there is another ` `            ``// element which divides it. ` `            ``for` `(``int` `j = 0; j < i &&  ` `                ``arr[j] <= Math.Sqrt(arr[i]); j++)  ` `            ``{ ` `                ``if` `(arr[i] % arr[j] == 0)  ` `                ``{ ` `                    ``int` `result = arr[i] / arr[j]; ` ` `  `                    ``// Check if the result value exists in array ` `                    ``// or not if yes the return arr[i] ` `                    ``if` `(result != arr[j] &&  ` `                        ``m[result] == ``null``|| m[result] > 0) ` `                    ``{ ` `                        ``return` `arr[i]; ` `                    ``}  ` `                     `  `                    ``// To handle the case like arr[i] = 4 ` `                    ``// and arr[j] = 2 ` `                    ``else` `if` `(result == arr[j] && m[result] > 1)  ` `                    ``{ ` `                        ``return` `arr[i]; ` `                    ``} ` `                ``} ` `            ``} ` `        ``} ` `        ``return` `-1; ` `    ``} ` ` `  `    ``// Driver code ` `    ``public` `static` `void` `Main(String[] args)  ` `    ``{ ` `        ``int` `[]arr = {17, 2, 1, 15, 30}; ` `        ``int` `n = arr.Length; ` `        ``Console.WriteLine(findGreatest(arr, n)); ` `    ``} ` `}  ` ` `  `// This code contributed by Rajput-Ji `

Output :

```30
```

Time Complexity : O(nlogn)

This article is contributed by Sahil Chhabra (akku). 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.