Related Articles

Count pairs in a sorted array whose sum is less than x

• Difficulty Level : Easy
• Last Updated : 14 Jun, 2021

Given a sorted integer array and number x, the task is to count pairs in array whose sum is less than x.
Examples:

```Input  : arr[] = {1, 3, 7, 9, 10, 11}
x = 7
Output : 1
There is only one pair (1, 3)

Input  : arr[] = {1, 2, 3, 4, 5, 6, 7, 8}
x = 7
Output : 6
Pairs are (1, 2), (1, 3), (1, 4), (1, 5)
(2, 3) and (2, 4)  ```

A simple solution of this problem run two loops to generate all pairs and one by one and check if current pair’s sum 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.

```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 sum 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)

(b) Else
r--;

3) Return result```

Below is the implementation of above steps.

C++

 `// C++ program to count pairs in an array``// whose sum is less than given number x``#include``using` `namespace` `std;` `// Function to count pairs in array``// with sum less than x.``int` `findPairs(``int` `arr[],``int` `n,``int` `x)``{``    ``int` `l = 0, r = n-1;``    ``int` `result = 0;` `    ``while` `(l < r)``    ``{``        ``// If current left and current``        ``// right have sum smaller than x,``        ``// the all elements from l+1 to r``        ``// form a pair with current l.``        ``if` `(arr[l] + arr[r] < x)``        ``{``            ``result += (r - l);``            ``l++;``        ``}` `        ``// Move to smaller value``        ``else``            ``r--;``    ``}` `    ``return` `result;``}` `// Driven code``int` `main()``{``    ``int` `arr[] = {1, 2, 3, 4, 5, 6, 7, 8};``    ``int` `n = ``sizeof``(arr)/``sizeof``(``int``);``    ``int` `x = 7;``    ``cout << findPairs(arr, n, x);``    ``return` `0;``}`

Java

 `// Java program to count pairs in an array``// whose sum is less than given number x``class` `GFG {``    ` `    ``// Function to count pairs in array``    ``// with sum less than x.``    ``static` `int` `findPairs(``int` `arr[], ``int` `n, ``int` `x)``    ``{``        ` `        ``int` `l = ``0``, r = n - ``1``;``        ``int` `result = ``0``;``    ` `        ``while` `(l < r)``        ``{``            ` `            ``// If current left and current``            ``// right have sum smaller than x,``            ``// the all elements from l+1 to r``            ``// form a pair with current l.``            ``if` `(arr[l] + arr[r] < x)``            ``{``                ``result += (r - l);``                ``l++;``            ``}``    ` `            ``// Move to smaller value``            ``else``                ``r--;``        ``}``    ` `        ``return` `result;``    ``}``    ` `    ``// Driver method``    ``public` `static` `void` `main(String[] args)``    ``{``        ` `        ``int` `arr[] = {``1``, ``2``, ``3``, ``4``, ``5``, ``6``, ``7``, ``8``};``        ``int` `n = arr.length;``        ``int` `x = ``7``;``        ` `        ``System.out.print(findPairs(arr, n, x));``    ``}``}` `// This code is contributed by Anant Agarwal.`

Python3

 `# Python3 program to count pairs``# in an array whose sum is less``# than given number x` `# Function to count pairs in array``# with sum less than x.``def` `findPairs(arr, n, x):` `    ``l ``=` `0``; r ``=` `n``-``1``    ``result ``=` `0` `    ``while` `(l < r):``    ` `        ``# If current left and current``        ``# right have sum smaller than x,``        ``# the all elements from l+1 to r``        ``# form a pair with current l.``        ``if` `(arr[l] ``+` `arr[r] < x):``        ` `            ``result ``+``=` `(r ``-` `l)``            ``l ``+``=` `1``        `  `        ``# Move to smaller value``        ``else``:``            ``r ``-``=` `1` `    ``return` `result``    ` `# Driver Code``arr ``=` `[``1``, ``2``, ``3``, ``4``, ``5``, ``6``, ``7``, ``8``]``n ``=` `len``(arr)``x ``=` `7``print``(findPairs(arr, n, x))` `# This code is contributed by Anant Agarwal.`

C#

 `// C# program to count pairs in``// an array whose sum is less``// than given number x``using` `System;` `class` `GFG {``    ` `    ``// Function to count pairs in array``    ``// with sum less than x.``    ``static` `int` `findPairs(``int` `[]arr, ``int` `n,``                         ``int` `x)``    ``{``        ` `        ``int` `l = 0, r = n - 1;``        ``int` `result = 0;``    ` `        ``while` `(l < r)``        ``{``            ` `            ``// If current left and current``            ``// right have sum smaller than x,``            ``// the all elements from l+1 to r``            ``// form a pair with current l.``            ``if` `(arr[l] + arr[r] < x)``            ``{``                ``result += (r - l);``                ``l++;``            ``}``    ` `            ``// Move to smaller value``            ``else``                ``r--;``        ``}``    ` `        ``return` `result;``    ``}``    ` `    ``// Driver code``    ``public` `static` `void` `Main(String[] args)``    ``{``        ` `        ``int` `[]arr = {1, 2, 3, 4, 5, 6, 7, 8};``        ``int` `n = arr.Length;``        ``int` `x = 7;``        ` `        ``Console.Write(findPairs(arr, n, x));``    ``}``}` `// This code is contributed by parashar...`

PHP

 ``

Javascript

 ``
Output

`6`

Time complexity : O(n)
Space complexity : O(1)

Using Policy Based Data structure:

Its also works for the unsorted array

C++

 `#include ``using` `namespace` `std;``#include ``#include ``using` `namespace` `__gnu_pbds;``#define ordered_set                                        \``    ``tree, null_type, less >, \``         ``rb_tree_tag, tree_order_statistics_node_update>` `int` `countPair(vector<``int``> v, ``int` `sum)``{``    ``int` `ans = 0;` `    ``ordered_set st;``    ``int` `y = 0;``    ``for` `(``auto` `i = v.rbegin(); i != v.rend(); i++) {``        ``int` `num = *i;``        ``if` `(st.empty())``            ``st.insert({ num, y });` `        ``else` `{``            ``int` `left = sum - num;``            ``ans += st.order_of_key({ left, -1 });``            ``st.insert({ num, y });``        ``}``        ``y++;``    ``}` `    ``return` `ans;``}``int` `main()``{` `    ``int` `n;``    ``cin >> n;` `    ``vector<``int``> v{ 1, 2, 3, 4, 5, 6, 7, 8 };` `    ``int` `sum = 7;` `    ``cout << countPair(v, sum);` `    ``return` `0;``}`
Output
`6`

Extension:
If array is unsorted, then we can sort the array first and then apply above method to solve in O(n Log n) time.
Related Articles:
Count all distinct pairs with difference equal to k
Count pairs with given sum
Reference: https://www.quora.com/Given-a-sorted-integer-array-and-number-z-count-all-pairs-x-y-in-the-array-so-that-x-+-y-z-Can-it-be-done-in-O-n
This article is contributed by DANISH_RAZA . If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.