# Count pairs in a sorted array whose product is less than k

Given a sorted integer array and number k, the task is to count pairs in an array whose product is less than x.

Examples:

Input: A = {2, 3, 5, 6}, k = 16
Output: 4
Pairs having product less than 16: (2, 3), (2, 5), (2, 6), (3, 5)

Input: A = {2, 3, 4, 6, 9}, k = 20
Output: 6
Pairs having product less than 20: (2, 3), (2, 4), (2, 6), (2, 9), (3, 4), (3, 6)

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

A simple solution of this problem run two loops to generate all pairs and one by one and check if current pair’s product is less than x or not.

An Efficient solution of this problem is take initial and last value of index in l and r variable. Consider below two cases:

• Case-I:
Lets consider i < j and A[i]*A[j] < k then we can say that A[i]*A[j-1] < k as A[j-1] < A[j] for a sorted array,
Similarly A[i]*A[j-2] < k, A[i]*A[j-3] < k, ….., A[i]*A[i+1] < k.
• Case-II:
Lets consider i k then we can say that A[i]*A[j+1] > k as A[j+1] > A[j] for a sorted array,
similarly A[i]*A[j+2] > k, A[i]*A[j+3] > k, ….., A[i]*A[n-1] > k.

Above problem is similar to Count pairs in a sorted array whose sum is less than x, the only thing that is different is to find the product of pairs instead of sum.
Below is the algorithm to solve this problem:

```1) Initialize two variables l and r to find the candidate
elements in the sorted array.
(a) l = 0
(b) r = n - 1
2) Initialize : result = 0
2) Loop while l < r.

// If current left and current
// right have product smaller than x,
// the all elements from l+1 to r
// form a pair with current
(a) If (arr[l] * arr[r] < x)
result = result + (r - l)
l++;

(b) Else
r--;

3) Return result
```

Below is the implementation of above algorithm:

## C++

 `// C++ program to find number of pairs with ` `// product less than k in a sorted array ` `#include ` `using` `namespace` `std; ` ` `  `// Function to count the pairs ` `int` `fun(``int` `A[], ``int` `n, ``int` `k) ` `{ ` `    ``// count to keep count of ` `    ``// number of pairs with product ` `    ``// less than k ` `    ``int` `count = 0; ` `    ``int` `i = 0; ` `    ``int` `j = n - 1; ` ` `  `    ``// Traverse the array ` `    ``while` `(i < j) { ` ` `  `        ``// If product is less than k ` `        ``// then count that pair ` `        ``// and increment 'i' ` `        ``if` `(A[i] * A[j] < k) { ` `            ``count += (j - i); ` `            ``i++; ` `        ``} ` ` `  `        ``// Else decrement 'j' ` `        ``else` `{ ` `            ``j--; ` `        ``} ` `    ``} ` ` `  `    ``// Return count of pairs ` `    ``return` `count; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` ` `  `    ``int` `A[] = { 2, 3, 4, 6, 9 }; ` `    ``int` `n = ``sizeof``(A) / ``sizeof``(``int``); ` `    ``int` `k = 20; ` `    ``cout << ``"Number of pairs with product less than "` `         ``<< k << ``" = "` `<< fun(A, n, k) << endl; ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java program to find number  ` `// of pairs with product less  ` `// than k in a sorted array ` `class` `GFG ` `{ ` ` `  `// Function to count the pairs ` `static` `int` `fun(``int` `A[],  ` `               ``int` `n, ``int` `k) ` `{ ` `    ``// count to keep count of ` `    ``// number of pairs with  ` `    ``// product less than k ` `    ``int` `count = ``0``; ` `    ``int` `i = ``0``; ` `    ``int` `j = n - ``1``; ` ` `  `    ``// Traverse the array ` `    ``while` `(i < j)  ` `    ``{ ` ` `  `        ``// If product is less than  ` `        ``// k then count that pair ` `        ``// and increment 'i' ` `        ``if` `(A[i] * A[j] < k)  ` `        ``{ ` `            ``count += (j - i); ` `            ``i++; ` `        ``} ` ` `  `        ``// Else decrement 'j' ` `        ``else`  `        ``{ ` `            ``j--; ` `        ``} ` `    ``} ` ` `  `    ``// Return count of pairs ` `    ``return` `count; ` `} ` ` `  `// Driver code ` `public` `static` `void` `main(String args[]) ` `{ ` `    ``int` `A[] = {``2``, ``3``, ``4``, ``6``, ``9``}; ` `    ``int` `n = A.length; ` `    ``int` `k = ``20``; ` `     `  `    ``System.out.println(``"Number of pairs with "` `+ ` `                     ``"product less than 20 = "` `+  ` `                                  ``fun(A, n, k)); ` `} ` `} ` ` `  `// This code is contributed  ` `// by Kirti_Mangal `

## Python

 `# Python program to find number of pairs with ` `# product less than k in a sorted array  ` ` `  `def` `fun(A, k): ` `    ``# count to keep count of number  ` `    ``# of pairs with product less than k ` `    ``count ``=` `0` `    ``n ``=` `len``(A) ` `    ``# Left pointer pointing to leftmost part ` `    ``i ``=` `0` `     `  `    ``# Right pointer pointing to rightmost part ` `    ``j ``=` `n``-``1` `     `  `    ``# While left and right pointer don't meet ` `    ``while` `i < j: ` `        ``if` `A[i]``*``A[j] < k: ` `            ``count ``+``=` `(j``-``i) ` `            ``# Increment the left pointer ` `            ``i``+``=` `1` `        ``else``: ` `            ``# Decrement the right pointer ` `            ``j``-``=` `1` `    ``return` `count ` ` `  `# Driver code to test above function ` `A ``=` `[``2``, ``3``, ``4``, ``6``, ``9``] ` `k ``=` `20` `print``(``"Number of pairs with product less than "``, ` `k, ``" = "``, fun(A, k)) `

## C#

 `// C# program to find number  ` `// of pairs with product less  ` `// than k in a sorted array ` `using` `System; ` ` `  `class` `GFG ` `{ ` ` `  `// Function to count the pairs ` `static` `int` `fun(``int` `[]A,  ` `               ``int` `n, ``int` `k) ` `{ ` `    ``// count to keep count of ` `    ``// number of pairs with  ` `    ``// product less than k ` `    ``int` `count = 0; ` `    ``int` `i = 0; ` `    ``int` `j = n - 1; ` ` `  `    ``// Traverse the array ` `    ``while` `(i < j)  ` `    ``{ ` ` `  `        ``// If product is less than  ` `        ``// k then count that pair ` `        ``// and increment 'i' ` `        ``if` `(A[i] * A[j] < k)  ` `        ``{ ` `            ``count += (j - i); ` `            ``i++; ` `        ``} ` ` `  `        ``// Else decrement 'j' ` `        ``else` `        ``{ ` `            ``j--; ` `        ``} ` `    ``} ` ` `  `    ``// Return count of pairs ` `    ``return` `count; ` `} ` ` `  `// Driver code ` `public` `static` `void` `Main() ` `{ ` `    ``int` `[]A = {2, 3, 4, 6, 9}; ` `    ``int` `n = A.Length; ` `    ``int` `k = 20; ` `     `  `    ``Console.WriteLine(``"Number of pairs with "` `+ ` `                    ``"product less than 20 = "` `+  ` `                                 ``fun(A, n, k)); ` `} ` `} ` ` `  `// This code is contributed  ` `// by Subhadeep `

## PHP

 ` `

Output:

```Number of pairs with product less than 20 = 6
```

Time Complexity: O(N)

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.