Skip to content
Related Articles

Related Articles

Improve Article

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<bits/stdc++.h>
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



<?php
// PHP 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.
function 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++;
        }
 
        // Move to smaller value
        else
            $r--;
    }
 
    return $result;
}
 
    // Driver Code
    $arr = array(1, 2, 3, 4, 5, 6, 7, 8);
    $n = sizeof($arr) / sizeof($arr[0]);
    $x = 7;
    echo findPairs($arr, $n, $x);
    return 0;
 
// This code is contributed by nitin mittal.
?>
Javascript



<script>
//javascript 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.
function findPairs(arr,n,x)
{
    let l = 0, r = n-1;
    let 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;
}
 
    let arr = [1, 2, 3, 4, 5, 6, 7, 8];
    let n = arr.length;
    let x = 7;
    document.write(findPairs(arr,n,x));
 
// This code is contributed by vaibhavrabadiya117.
</script>
Output


6
Time complexity : O(n) 
Space complexity : O(1)
Using Policy Based Data structure:
Its also works for the unsorted array 
C++



#include <iostream>
using namespace std;
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
#define ordered_set                                        \
    tree<pair<int, int>, null_type, less<pair<int, int> >, \
         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.
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.
 
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.



My Personal Notes
arrow_drop_up
Previous
Count pairs in a sorted array whose product is less than k
Next

Count pairs with given sum
Recommended Articles
Page :
Count pairs in a sorted array whose product is less than k
19, Sep 18
Count numbers whose maximum sum of distinct digit-sum is less than or equals M
30, Mar 20
Count array elements whose highest power of 2 less than or equal to that number is present in the given array
17, Jun 21
Sum of elements in an array whose difference with the mean of another array is less than k
08, Apr 19
Count elements less than or equal to a given value in a sorted rotated array
15, Jun 17
Count the number of strings in an array whose distinct characters are less than equal to M
06, May 20
Sum of all array elements less than X and greater than Y for Q queries
18, Jun 20
Count pairs having Bitwise XOR less than K from given array
25, Oct 20
Count pairs from an array with absolute difference not less than the minimum element in the pair
29, Jul 21
Count pairs from two sorted arrays whose sum is equal to a given value x
23, Jun 17
Count N-length arrays made from first M natural numbers whose subarrays can be made palindromic by replacing less than half of its elements
16, Dec 20
Check if a sorted array can be divided in pairs whose sum is k
02, Nov 15
Count pairs with bitwise OR less than Max
18, Mar 19
Count maximum number of disjoint pairs having one element not less than K times the other
05, Aug 21
Count pairs from an array whose Bitwise OR is greater than Bitwise AND
08, Feb 21
Maximum sum subarray having sum less than or equal to given sum using Set
22, Apr 20
Maximum sum subarray having sum less than or equal to given sum
05, Aug 17
Count of subsequences in an array with sum less than or equal to X
20, Jun 20
Longest subsequence whose average is less than K
22, Aug 18
Number of players whose rank is equal to or less than a given cutoff rank
21, Jul 21
Find element in a sorted array whose frequency is greater than or equal to n/2.
30, Aug 17
For each element in 1st array count elements less than or equal to it in 2nd array
11, Jun 17
For each element in 1st array count elements less than or equal to it in 2nd array | Set 2
01, Oct 18
Count indices where the maximum in the prefix array is less than that in the suffix array
27, Jan 21
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
GeeksforGeeks
Vote for difficulty
Current difficulty :
Easy





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox