# Count pairs from a given array whose product lies in a given range

• Difficulty Level : Medium
• Last Updated : 17 Aug, 2021

Given an array arr[] of size N, and integers L and R, the task is to count the number of pairs [arri , arrj] such that i < j and the product of arr[i] * arr[j] lies in the given range [L, R], i.e. L ≤ arr[i] * arr[j] ≤ R.

Examples:

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

Input: arr[ ] = {4, 1, 2, 5}, L = 4, R = 9
Output: 3
Explanation: Valid pairs are {4, 1}, {1, 5} and {4, 2}.

Input: arr[ ] = {1, 2, 5, 10, 5}, L = 2, R = 15
Output: 6
Explanation: Valid pairs are {1, 2}, {1, 5}, {1, 10}, {1, 5}, {2, 5}, {2, 5}.

Naive Approach: The simplest approach to solve the problem is to generate all possible pairs from the array and for each pair, check if its product lies in the range [L, R] or not.

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

Efficient Approach: This problem can be solved by Sorting and Binary Search technique. Follow the steps below to solve this problem:

• Sort the array arr[].
• Initialize a variable, say ans as 0, to store the number of pairs whose product lies in the range [L, R].
• Iterate over  the range [0, N-1] using a variable i and perform the following steps:
• Find upper bound of an element such that the element is less than equal to R / arr[i].
• Find lower bound of an element such that the element is greater than or equal to L / arr[i].
• Add upper bound – lower bound to ans
• After completing the above steps, print ans.

Below is the implementation of the above approach.

## C++

 `// C++ program for above approach` `#include ``using` `namespace` `std;` `// Function to count pairs from an array``// whose product lies in the range [l, r]``void` `countPairs(``int` `arr[], ``int` `l,``                ``int` `r, ``int` `n)``{``    ``// Sort the array arr[]``    ``sort(arr, arr + n);` `    ``// Stores the final answer``    ``int` `ans = 0;` `    ``for` `(``int` `i = 0; i < n; i++) {` `        ``// Upper Bound for arr[j] such``        ``// that arr[j] <= r/arr[i]``        ``auto` `itr1 = upper_bound(``                        ``arr + i + 1,``                        ``arr + n, r / arr[i])``                    ``- arr;` `        ``// Lower Bound for arr[j] such``        ``// that arr[j] >= l/arr[i]``        ``auto` `itr2 = lower_bound(``                        ``arr + i + 1, arr + n,``                        ``ceil``(``double``(l) / ``double``(arr[i])))``                    ``- arr;` `        ``ans += itr1 - itr2;``    ``}` `    ``// Print the answer``    ``cout << ans << endl;``}` `// Driver Code``int` `main()``{``    ``// Given Input``    ``int` `arr[] = { 2,2 };``    ``int` `l = 5, r = 9;` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr);` `    ``// Function Call``    ``countPairs(arr, l, r, n);` `    ``return` `0;``}`

## Java

 `// Java program for above approach``import` `java.util.Arrays;` `class` `GFG{``    ` `// Function to count pairs from an array``// whose product lies in the range [l, r]``public` `static` `void` `countPairs(``int``[] arr, ``int` `l,``                              ``int` `r, ``int` `n)``{``    ` `    ``// Sort the array arr[]``    ``Arrays.sort(arr);` `    ``// Stores the final answer``    ``int` `ans = ``0``;` `    ``for``(``int` `i = ``0``; i < n; i++)``    ``{``        ` `        ``// Upper Bound for arr[j] such``        ``// that arr[j] <= r/arr[i]``        ``int` `itr1 = upper_bound(arr, ``0``, arr.length - ``1``,``                               ``l / arr[i]);` `        ``// Lower Bound for arr[j] such``        ``// that arr[j] >= l/arr[i]``        ``int` `itr2 = lower_bound(arr, ``0``, arr.length - ``1``,``                               ``l / arr[i]);``        ``ans += itr1 - itr2;``    ``}` `    ``// Print the answer``    ``System.out.println(ans);``}` `public` `static` `int` `lower_bound(``int``[] arr, ``int` `low,``                              ``int` `high, ``int` `X)``{``    ` `    ``// Base Case``    ``if` `(low > high)``    ``{``        ``return` `low;``    ``}` `    ``// Find the middle index``    ``int` `mid = low + (high - low) / ``2``;` `    ``// If arr[mid] is greater than``    ``// or equal to X then search``    ``// in left subarray``    ``if` `(arr[mid] >= X)``    ``{``        ``return` `lower_bound(arr, low, mid - ``1``, X);``    ``}` `    ``// If arr[mid] is less than X``    ``// then search in right subarray``    ``return` `lower_bound(arr, mid + ``1``, high, X);``}` `public` `static` `int` `upper_bound(``int``[] arr, ``int` `low,``                              ``int` `high, ``int` `X)``{``    ` `    ``// Base Case``    ``if` `(low > high)``        ``return` `low;` `    ``// Find the middle index``    ``int` `mid = low + (high - low) / ``2``;` `    ``// If arr[mid] is less than``    ``// or equal to X search in``    ``// right subarray``    ``if` `(arr[mid] <= X)``    ``{``        ``return` `upper_bound(arr, mid + ``1``, high, X);``    ``}` `    ``// If arr[mid] is greater than X``    ``// then search in left subarray``    ``return` `upper_bound(arr, low, mid - ``1``, X);``}` `// Driver Code``public` `static` `void` `main(String args[])``{``    ` `    ``// Given Input``    ``int``[] arr = { ``4``, ``1``, ``2``, ``5` `};``    ``int` `l = ``4``, r = ``9``;``    ``int` `n = arr.length;` `    ``// Function Call``    ``countPairs(arr, l, r, n);``}``}` `// This code is contributed by gfgking.`

## Python3

 `# Python program for above approach` `# Function to count pairs from an array``# whose product lies in the range [l, r]``def` `countPairs(arr, l, r, n):` `    ``# Sort the array arr[]``    ``arr[::``-``1``]` `    ``# Stores the final answer``    ``ans ``=` `0``;` `    ``for` `i ``in` `range``(n):` `        ``# Upper Bound for arr[j] such``        ``# that arr[j] <= r/arr[i]``        ``itr1 ``=` `upper_bound(arr, ``0``, ``len``(arr) ``-` `1``, l ``/``/` `arr[i])` `        ``# Lower Bound for arr[j] such``        ``# that arr[j] >= l/arr[i]``        ``itr2 ``=` `lower_bound(arr, ``0``, ``len``(arr) ``-` `1``, l ``/``/` `arr[i]);` `        ``ans ``+``=` `itr1 ``-` `itr2;` `    ``# Print the answer``    ``print``(ans);` `def` `lower_bound(arr, low, high, X):` `    ``# Base Case``    ``if` `(low > high):``        ``return` `low;` `    ``# Find the middle index``    ``mid ``=` `low ``+` `(high ``-` `low) ``/``/` `2``;` `    ``# If arr[mid] is greater than``    ``# or equal to X then search``    ``# in left subarray``    ``if` `(arr[mid] >``=` `X):``        ``return` `lower_bound(arr, low, mid ``-` `1``, X);` `    ``# If arr[mid] is less than X``    ``# then search in right subarray``    ``return` `lower_bound(arr, mid ``+` `1``, high, X);` `def` `upper_bound(arr, low, high, X):` `    ``# Base Case``    ``if` `(low > high):``        ``return` `low;` `    ``# Find the middle index``    ``mid ``=` `low ``+` `(high ``-` `low) ``/``/` `2``;` `    ``# If arr[mid] is less than``    ``# or equal to X search in``    ``# right subarray``    ``if` `(arr[mid] <``=` `X):``        ``return` `upper_bound(arr, mid ``+` `1``, high, X);` `    ``# If arr[mid] is greater than X``    ``# then search in left subarray``    ``return` `upper_bound(arr, low, mid ``-` `1``, X);`  `# Driver Code` `# Given Input``arr ``=` `[``4``, ``1``, ``2``, ``5``];``l ``=` `4``;``r ``=` `9``;` `n ``=` `len``(arr)` `# Function Call``countPairs(arr, l, r, n);` `# This code is contributed by _Saurabh_Jaiswal.`

## C#

 `// C# program for the above approach``using` `System;` `class` `GFG{` `// Function to count pairs from an array``// whose product lies in the range [l, r]``public` `static` `void` `countPairs(``int``[] arr, ``int` `l,``                              ``int` `r, ``int` `n)``{``    ` `    ``// Sort the array arr[]``    ``Array.Sort(arr);`` ` `    ``// Stores the final answer``    ``int` `ans = 0;`` ` `    ``for``(``int` `i = 0; i < n; i++)``    ``{``        ` `        ``// Upper Bound for arr[j] such``        ``// that arr[j] <= r/arr[i]``        ``int` `itr1 = upper_bound(arr, 0, arr.Length - 1,``                               ``l / arr[i]);`` ` `        ``// Lower Bound for arr[j] such``        ``// that arr[j] >= l/arr[i]``        ``int` `itr2 = lower_bound(arr, 0, arr.Length - 1,``                               ``l / arr[i]);``        ``ans += itr1 - itr2;``    ``}`` ` `    ``// Print the answer``    ``Console.WriteLine(ans);``}`` ` `public` `static` `int` `lower_bound(``int``[] arr, ``int` `low,``                              ``int` `high, ``int` `X)``{``    ` `    ``// Base Case``    ``if` `(low > high)``    ``{``        ``return` `low;``    ``}`` ` `    ``// Find the middle index``    ``int` `mid = low + (high - low) / 2;`` ` `    ``// If arr[mid] is greater than``    ``// or equal to X then search``    ``// in left subarray``    ``if` `(arr[mid] >= X)``    ``{``        ``return` `lower_bound(arr, low, mid - 1, X);``    ``}`` ` `    ``// If arr[mid] is less than X``    ``// then search in right subarray``    ``return` `lower_bound(arr, mid + 1, high, X);``}`` ` `public` `static` `int` `upper_bound(``int``[] arr, ``int` `low,``                              ``int` `high, ``int` `X)``{``    ` `    ``// Base Case``    ``if` `(low > high)``        ``return` `low;`` ` `    ``// Find the middle index``    ``int` `mid = low + (high - low) / 2;`` ` `    ``// If arr[mid] is less than``    ``// or equal to X search in``    ``// right subarray``    ``if` `(arr[mid] <= X)``    ``{``        ``return` `upper_bound(arr, mid + 1, high, X);``    ``}`` ` `    ``// If arr[mid] is greater than X``    ``// then search in left subarray``    ``return` `upper_bound(arr, low, mid - 1, X);``}` `// Driver code``public` `static` `void` `Main(``string``[] args)``{``    ` `    ``// Given Input``    ``int``[] arr = { 4, 1, 2, 5 };``    ``int` `l = 4, r = 9;``    ``int` `n = arr.Length;``    ` `    ``// Function Call``    ``countPairs(arr, l, r, n);``}``}` `// This code is contributed by sanjoy_62`

## Javascript

 ``
Output:
`3`

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

My Personal Notes arrow_drop_up