GeeksforGeeks App
Open App
Browser
Continue

# Pair with given product | Set 1 (Find if any pair exists)

Given an array of distinct elements and a number x, find if there is a pair with a product equal to x.

Examples :

```Input : arr[] = {10, 20, 9, 40};
int x = 400;
Output : Yes

Input : arr[] = {10, 20, 9, 40};
int x = 190;
Output : No

Input : arr[] = {-10, 20, 9, -40};
int x = 400;
Output : Yes

Input : arr[] = {-10, 20, 9, 40};
int x = -400;
Output : Yes

Input : arr[] = {0, 20, 9, 40};
int x = 0;
Output : Yes```
Recommended Practice

Naive approach:  Run two loops to consider all possible pairs. For every pair, check if the product is equal to x or not.

## C++

 `// A simple C++ program to find if there is a pair``// with given product.``#include``using` `namespace` `std;` `// Returns true if there is a pair in arr[0..n-1]``// with product equal to x.``bool` `isProduct(``int` `arr[], ``int` `n, ``int` `x)``{``    ``// Consider all possible pairs and check for``    ``// every pair.``    ``for` `(``int` `i=0; i

## Java

 `// Java program to find if there is a pair``// with given product.``class` `GFG``{   ``    ``// Returns true if there is a pair in``    ``// arr[0..n-1] with product equal to x. ``    ``boolean` `isProduct(``int` `arr[], ``int` `n, ``int` `x)``    ``{``        ``for` `(``int` `i=``0``; i

## Python3

 `# Python3 program to find if there``# is a pair with given product.` `# Returns true if there is a``# pair in arr[0..n-1] with``# product equal to x``def` `isProduct(arr, n, x):``    ``for` `i ``in` `arr:``        ``for` `j ``in` `arr:``            ``if` `i ``*` `j ``=``=` `x:``                ``return` `True``    ``return` `False``    ` `    ` `# Driver code    ``arr ``=` `[``10``, ``20``, ``9``, ``40``]``x ``=` `400``n ``=` `len``(arr)``if``(isProduct(arr,n, x) ``=``=` `True``):``    ``print` `(``"Yes"``)` `else``:``    ``print``(``"No"``)``    ` `x ``=` `900``if``(isProduct(arr, n, x)):``    ``print``(``"Yes"``)``    ` `else``:``    ``print``(``"No"``)` `# This code is contributed``# by prerna saini``   `

## C#

 `// C# program to find``// if there is a pair``// with given product.``using` `System;` `class` `GFG``{` `// Returns true if there``// is a pair in arr[0..n-1]``// with product equal to x.``static` `bool` `isProduct(``int` `[]arr,``                      ``int` `n, ``int` `x)``{``    ``for` `(``int` `i = 0; i < n - 1; i++)``        ``for` `(``int` `j = i + 1; j < n; j++)``            ``if` `(arr[i] * arr[j] == x)``                ``return` `true``;``    ``return` `false``;``}` `// Driver Code``static` `void` `Main()``{``    ``int` `[]arr = {10, 20, 9, 40};``    ``int` `x = 400;``    ``int` `n = arr.Length;``    ``if` `(isProduct(arr, n, x))``        ``Console.WriteLine(``"Yes"``);``    ``else``        ``Console.WriteLine(``"No"``);` `    ``x = 190;``    ``if` `(isProduct(arr, n, x))``        ``Console.WriteLine(``"Yes"``);``    ``else``        ``Console.WriteLine(``"No"``);``}``}` `// This code is contributed``// by Sam007`

## PHP

 ``

## Javascript

 ``

Output

```Yes
No```

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

Better Solution: We sort the given array. After sorting, we traverse the array and for every element arr[i], we do binary search for x/arr[i] in the subarray on the right of arr[i], i.e., in subarray arr[i+1..n-1]

## C++

 `// A simple C++ program to find if there is a pair``// with given product.``#include``using` `namespace` `std;` `//Function to check if x is present in the array or not``// such that arr[i] + x == given sum``bool` `binarysearch(``int` `arr[], ``int` `n, ``int` `i,``int` `x)``{``    ``int` `l = 0, r = n - 1;` `    ``while` `(l <= r) {``        ``int` `mid = (l + r) / 2;` `        ``// Checking if the middle element is equal to x``        ``if` `(arr[mid]*arr[i] == x)``        ``{  ``           ``if``(i!=mid)``//if position is no same``           ``{     ``return` `true``; }``          ``else``{ ``//if position is  same``            ``if``(mid>0 && arr[mid-1]==arr[mid])``            ``{  ``return` `true``;  }``//if exist adjacent element``            ``else` `if``(mid

## Java

 `// A simple Java program to find if there is a pair``// with given product.``import` `java.util.*;` `public` `class` `Gfg {` `    ``//Function to check if x is present in the array or not``    ``// such that arr[i] + x == given sum``    ``public` `static` `boolean` `binarysearch(``int``[] arr, ``int` `n, ``int` `i,``int` `x)``    ``{``        ``int` `l = ``0``, r = n - ``1``;``    ` `        ``while` `(l <= r) {``            ``int` `mid = (l + r) / ``2``;``    ` `            ``// Checking if the middle element is equal to x``            ``if` `(arr[mid]*arr[i] == x)``            ``{  ``               ``if``(i!=mid)``//if position is no same``               ``{     ``return` `true``; }``              ``else``{ ``//if position is  same``                ``if``(mid>``0` `&& arr[mid-``1``]==arr[mid])``                ``{  ``return` `true``;  }``//if exist adjacent element``                ``else` `if``(mid

## Python3

 `# Python program to find if there is a pair``# with given product.` `# Function to check if x is present in the array or not``# such that arr[i] * x == given product``def` `binarysearch(arr, n, i, x):``    ``l ``=` `0``    ``r ``=` `n ``-` `1` `    ``while` `l <``=` `r:``        ``mid ``=` `(l ``+` `r) ``/``/` `2` `        ``# Checking if the middle element is equal to x``        ``if` `arr[mid] ``*` `arr[i] ``=``=` `x:``            ``# if position is not same``            ``if` `i !``=` `mid:``                ``return` `True``            ``else``:``                ``# if position is same``                ``if` `mid > ``0` `and` `arr[mid``-``1``] ``=``=` `arr[mid]:``                    ``# if exist adjacent element``                    ``return` `True``                ``elif` `mid < n``-``1` `and` `arr[mid``+``1``] ``=``=` `arr[mid]:``                    ``# if exist adjacent element``                    ``return` `True``                ``else``:``                    ``return` `False``        ``elif` `arr[mid] ``*` `arr[i] < x:``            ``l ``=` `mid ``+` `1``        ``else``:``            ``r ``=` `mid ``-` `1` `    ``# return True, if element x is present in the array, else False``    ``return` `False` `# Returns True if there is a pair in arr[0..n-1]``# with product equal to x.``def` `isProduct(arr, n, x):``    ``# Sorting array for Binary search``    ``arr.sort()``    ` `    ``# Consider all possible pairs and check for every pair``    ``for` `i ``in` `range``(n):``        ``# Using binary search to check if there exists an``        ``# index in arr such that arr[i] * arr[index] == given product``        ``if` `binarysearch(arr, n, i, x):``            ``return` `True` `# Return True if pair found   ``    ``return` `False` `# Driver code``arr ``=` `[``10``, ``20``, ``9``, ``40``]``n ``=` `len``(arr)` `x ``=` `400``# Function call test case 1``if` `isProduct(arr, n, x):``    ``print``(``"Yes"``)``else``:``    ``print``(``"No"``)` `x ``=` `190``# Function call test case 2``if` `isProduct(arr, n, x):``    ``print``(``"Yes"``)``else``:``    ``print``(``"No"``)`

## C#

 `using` `System;` `class` `Program``{``  ``// Function to check if x is present in the array or not``  ``// such that arr[i] + x == given sum``  ``static` `bool` `binarysearch(``int``[] arr, ``int` `n, ``int` `i, ``int` `x)``  ``{``    ``int` `l = 0, r = n - 1;` `    ``while` `(l <= r)``    ``{``      ``int` `mid = (l + r) / 2;` `      ``// Checking if the middle element is equal to x``      ``if` `(arr[mid] * arr[i] == x)``      ``{``        ``if` `(i != mid) ``//if position is not the same``        ``{``          ``return` `true``;``        ``}``        ``else``        ``{ ``//if position is same``          ``if` `(mid > 0 && arr[mid - 1] == arr[mid])``          ``{``            ``return` `true``;``          ``} ``//if exist adjacent element``          ``else` `if` `(mid < n - 1 && arr[mid + 1] == arr[mid])``          ``{``            ``return` `true``;``          ``} ``//if exist adjacent element``          ``else``          ``{``            ``return` `false``;``          ``}``        ``}``      ``}``      ``else` `if` `(arr[mid] * arr[i] < x)``      ``{``        ``l = mid + 1;``      ``}``      ``else``      ``{``        ``r = mid - 1;``      ``}``    ``}``    ``// return true , if element x is present in the array``    ``// else false``    ``return` `false``;``  ``}` `  ``// Returns true if there is a pair in arr[0..n-1]``  ``// with product equal to x.``  ``static` `bool` `isProduct(``int``[] arr, ``int` `n, ``int` `x)``  ``{``    ``Array.Sort(arr); ``//sorting array for Binary search` `    ``// Consider all possible pairs and check for``    ``// every pair.``    ``for` `(``int` `i = 0; i < n; i++)``    ``{``      ``//Using binary search to check if there exist a``      ``//index in arr such that arr[i]*arr[index]==given sum``      ``if` `(binarysearch(arr, n, i, x))``      ``{``        ``return` `true``; ``// Return true if pair found   ``      ``}``    ``}``    ``return` `false``;``  ``}` `  ``// Driver code``  ``static` `void` `Main()``  ``{``    ``int``[] arr = { 10, 20, 9, 40 };``    ``int` `n = arr.Length;` `    ``int` `x = 400;``    ``// Function call test case 1``    ``if` `(isProduct(arr, n, x))``    ``{``      ``Console.WriteLine(``"Yes"``);``    ``}``    ``else``    ``{``      ``Console.WriteLine(``"No"``);``    ``}` `    ``x = 190;``    ``// Function call test case 2``    ``if` `(isProduct(arr, n, x))``    ``{``      ``Console.WriteLine(``"Yes"``);``    ``}``    ``else``    ``{``      ``Console.WriteLine(``"No"``);``    ``}``  ``}``}`

## Javascript

 `// Javascript equivalent code``function` `binarysearch(arr, n, i, x) {``  ``let l = 0;``  ``let r = n - 1;` `  ``while` `(l <= r) {``    ``let mid = Math.floor((l + r) / 2);` `    ``// Checking if the middle element is equal to x``    ``if` `(arr[mid] * arr[i] == x) {``      ``// if position is not same``      ``if` `(i != mid) {``        ``return` `true``;``      ``} ``else` `{``        ``// if position is same``        ``if` `(mid > 0 && arr[mid - 1] == arr[mid]) {``          ``// if exist adjacent element``          ``return` `true``;``        ``} ``else` `if` `(mid < n - 1 && arr[mid + 1] == arr[mid]) {``          ``// if exist adjacent element``          ``return` `true``;``        ``} ``else` `{``          ``return` `false``;``        ``}``      ``}``    ``} ``else` `if` `(arr[mid] * arr[i] < x) {``      ``l = mid + 1;``    ``} ``else` `{``      ``r = mid - 1;``    ``}``  ``}` `  ``// return True, if element x is present in the array, else False``  ``return` `false``;``}` `// Returns True if there is a pair in arr[0..n-1]``// with product equal to x.``function` `isProduct(arr, n, x) {``  ``// Sorting array for Binary search``  ``arr.sort();` `  ``// Consider all possible pairs and check for every pair``  ``for` `(let i = 0; i < n; i++) {``    ``// Using binary search to check if there exists an``    ``// index in arr such that arr[i] * arr[index] == given product``    ``if` `(binarysearch(arr, n, i, x)) {``      ``return` `true``; ``// Return True if pair found``    ``}``  ``}``  ``return` `false``;``}` `// Driver code``let arr = [10, 20, 9, 40];``let n = arr.length;` `let x = 400;``// Function call test case 1``if` `(isProduct(arr, n, x)) {``  ``console.log(``"Yes"``);``} ``else` `{``  ``console.log(``"No"``);``}` `x = 190;``// Function call test case 2``if` `(isProduct(arr, n, x)) {``  ``console.log(``"Yes"``);``} ``else` `{``  ``console.log(``"No"``);``}`

Output

```Yes
No```

Time Complexity: O(n log n)
Auxiliary Space: O(1)

Another Approach ( Using two pointer technique):

This approach to solve the problem is to sort the array in ascending order and then use Two pointer approach ( l = 0, r = arr.size()-1) to traverse that sorted array. If product of arr[l] and arr[r] is equal to x, then return true. If product is less than k then increase l else decrease r.

Algorithm:

1.  Define a function isProduct that takes an integer array arr, an integer n, and an integer x as inputs and returns a boolean value. The        function first sorts the array arr in ascending order. It then initializes two indices l and r to the beginning and end of the array,                      respectively. While l < r, the function calculates the product of the elements at indices l and r, compares it with x, and adjusts l and r    accordingly. If the product equals x, it returns true. Otherwise, if the product is less than x, it increments l to increase the value of the        product, and if the product is greater than x, it decrements r to decrease the value of the product. If no such pair exists in the array, the  function returns false.
2.  In the main function:
a. Create an integer array according to the input specification.
b. Initialize an integer n as the size of the array.
c. Initialize an integer x according to the input specification.
d. Call the isProduct function with the array, n, and x as inputs.
e. Print “Yes” if the function returns true, and “No” otherwise.

Below is the implementation of the above idea:

## C++

 `// C++ code for the approach` `#include ``using` `namespace` `std;` `// Returns true if there is a pair in arr[0..n-1]``// with product equal to x.``bool` `isProduct(``int` `arr[], ``int` `n, ``int` `x) {``    ``// sort the array arr``    ``sort(arr, arr + n);` `    ``int` `l = 0, r = n - 1;` `    ``// traverse the array inorder``    ``// using two pointer l and r``    ``while` `(l < r) {``        ``int` `prod = arr[l] * arr[r];` `        ``// if product of element``        ``// at the two pinters is k``        ``// return this as res``        ``if` `(prod == x) {``            ``return` `true``;``        ``}``        ``// if prod is less then``        ``// increase l as we have to``        ``// increase element value``        ``else` `if` `(prod < x)``            ``l++;``        ``// if prod is greater then``        ``// decrease r as we have to``        ``// decrease element value``        ``else``            ``r--;``    ``}` `    ``return` `false``;``}` `// Driver code``int` `main() {``    ``int` `arr[] = { 10, 20, 9, 40 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]);` `    ``int` `x = 400;``    ``// Function call test case 1``    ``if` `(isProduct(arr, n, x)) {``        ``cout << ``"Yes"` `<< endl;``    ``}``    ``else` `{``        ``cout << ``"No"` `<< endl;``    ``}` `    ``x = 190;``    ``// Function call test case 2``    ``if` `(isProduct(arr, n, x)) {``        ``cout << ``"Yes"` `<< endl;``    ``}``    ``else` `{``        ``cout << ``"No"` `<< endl;``    ``}` `    ``return` `0;``}` `// This code is contributed by Chandramani Kumar`

Output

```Yes
No```

Time Complexity: O(N * logN) where N is size of input array. This is because sort has been called which takes N*logN time.

Space Complexity: O(1) as no extra space has been taken.

Efficient Solution: We can improve time complexity to O(n) using hashing. Below are the steps.

1. Create an empty hash table
2. Traverse array elements and do the following for every element arr[i].
• If arr[i] is 0 and x is also 0, return true, else ignore arr[i].
• If x % arr[i] is 0 and x/arr[i] exists in the table, it returns true.
• Insert arr[i] into the hash table.
3. Return false

Below is the implementation of the above idea.

## C++14

 `// C++ program to find if there is a pair``// with given product.``#include``using` `namespace` `std;` `// Returns true if there is a pair in arr[0..n-1]``// with product equal to x.``bool` `isProduct(``int` `arr[], ``int` `n, ``int` `x)``{``    ``if` `(n < 2)``        ``return` `false``;` `    ``// Create an empty set and insert first``    ``// element into it``    ``unordered_set<``int``> s;` `    ``// Traverse remaining elements``    ``for` `(``int` `i=0; i

## Java

 `// Java program if there exists a pair for given product``import` `java.util.HashSet;` `class` `GFG``{``    ``// Returns true if there is a pair in arr[0..n-1]``    ``// with product equal to x.``    ``static` `boolean` `isProduct(``int` `arr[], ``int` `n, ``int` `x)``    ``{``        ``// Create an empty set and insert first``        ``// element into it``        ``HashSet hset = ``new` `HashSet<>();``        ` `        ``if``(n < ``2``)``            ``return` `false``;``        ` `        ``// Traverse remaining elements``        ``for``(``int` `i = ``0``; i < n; i++)``        ``{``            ``// 0 case must be handles explicitly as``            ``// x % 0 is undefined``            ``if``(arr[i] == ``0``)``            ``{``                ``if``(x == ``0``)``                    ``return` `true``;``                ``else``                    ``continue``;``            ``}` `            ``// x/arr[i] exists in hash, then we``            ``// found a pair``            ``if``(x % arr[i] == ``0``)``            ``{``                ``if``(hset.contains(x / arr[i]))``                    ``return` `true``;` `            ``// Insert arr[i]``            ``hset.add(arr[i]);``            ``}``        ``}``        ``return` `false``;``    ``}``    ` `    ``// driver code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `arr[] = {``10``, ``20``, ``9``, ``40``};``        ``int` `x = ``400``;``        ``int` `n = arr.length;``    ` `        ``if``(isProduct(arr, arr.length, x))``        ``System.out.println(``"Yes"``);``        ``else``        ``System.out.println(``"No"``);` `        ``x = ``190``;``    ` `        ``if``(isProduct(arr, arr.length, x))``        ``System.out.println(``"Yes"``);``        ``else``        ``System.out.println(``"No"``);``    ``}``}` `// This code is contributed by Kamal Rawal`

## Python3

 `# Python3 program to find if there``# is a pair with the given product.` `# Returns true if there is a pair in``# arr[0..n-1] with product equal to x.``def` `isProduct(arr, n, x):` `    ``if` `n < ``2``:``        ``return` `False` `    ``# Create an empty set and insert``    ``# first element into it``    ``s ``=` `set``()` `    ``# Traverse remaining elements``    ``for` `i ``in` `range``(``0``, n):``    ` `        ``# 0 case must be handles explicitly as``        ``# x % 0 is undefined behaviour in C++``        ``if` `arr[i] ``=``=` `0``:``        ` `            ``if` `x ``=``=` `0``:``                ``return` `True``            ``else``:``                ``continue` `        ``# x/arr[i] exists in hash, then``        ``# we found a pair``        ``if` `x ``%` `arr[i] ``=``=` `0``:``        ` `            ``if` `x ``/``/` `arr[i] ``in` `s:``                ``return` `True` `            ``# Insert arr[i]``            ``s.add(arr[i])``    ` `    ``return` `False` `# Driver code``if` `__name__ ``=``=` `"__main__"``:` `    ``arr ``=` `[``10``, ``20``, ``9``, ``40``]``    ``x ``=` `400` `    ``n ``=` `len``(arr)``    ``if` `isProduct(arr, n, x):``        ``print``(``"Yes"``)``    ``else``:``        ``print``(``"No"``)` `    ``x ``=` `190``    ``if` `isProduct(arr, n, x):``        ``print``(``"Yes"``)``    ``else``:``        ``print``(``"No"``)` `# This code is contributed by``# Rituraj Jain`

## C#

 `// C# program if there exists a``// pair for given product``using` `System;``using` `System.Collections.Generic;` `class` `GFG``{``// Returns true if there is a pair``// in arr[0..n-1] with product equal to x.``public` `static` `bool` `isProduct(``int``[] arr,``                             ``int` `n, ``int` `x)``{``    ``// Create an empty set and insert``    ``// first element into it``    ``HashSet<``int``> hset = ``new` `HashSet<``int``>();` `    ``if` `(n < 2)``    ``{``        ``return` `false``;``    ``}` `    ``// Traverse remaining elements``    ``for` `(``int` `i = 0; i < n; i++)``    ``{``        ``// 0 case must be handles explicitly``        ``// as x % 0 is undefined``        ``if` `(arr[i] == 0)``        ``{``            ``if` `(x == 0)``            ``{``                ``return` `true``;``            ``}``            ``else``            ``{``                ``continue``;``            ``}``        ``}` `        ``// x/arr[i] exists in hash, then``        ``// we found a pair``        ``if` `(x % arr[i] == 0)``        ``{``            ``if` `(hset.Contains(x / arr[i]))``            ``{``                ``return` `true``;``            ``}` `        ``// Insert arr[i]``        ``hset.Add(arr[i]);``        ``}``    ``}``    ``return` `false``;``}` `// Driver Code``public` `static` `void` `Main(``string``[] args)``{``    ``int``[] arr = ``new` `int``[] {10, 20, 9, 40};``    ``int` `x = 400;``    ``int` `n = arr.Length;` `    ``if` `(isProduct(arr, arr.Length, x))``    ``{``        ``Console.WriteLine(``"Yes"``);``    ``}``    ``else``    ``{``        ``Console.WriteLine(``"No"``);``    ``}` `    ``x = 190;` `    ``if` `(isProduct(arr, arr.Length, x))``    ``{``        ``Console.WriteLine(``"Yes"``);``    ``}``    ``else``    ``{``        ``Console.WriteLine(``"No"``);``    ``}``}``}` `// This code is contributed by Shrikant13`

## Javascript

 ``

Output

```Yes
No```

Time Complexity : O(n2)
Auxiliary Space: O(n)

In the next set, we will be discussing approaches to print all pairs with products equal to 0.