Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Count of smaller or equal elements in sorted array

  • Difficulty Level : Easy
  • Last Updated : 27 Jan, 2022

Given a sorted array of size n. Find a number of elements that are less than or equal to a given element.
Examples: 
 

Input : arr[] = {1, 2, 4, 5, 8, 10}
        key = 9
Output : 5
Elements less than or equal to 9 are 1, 2, 
4, 5, 8 therefore result will be 5.

Input : arr[] = {1, 2, 2, 2, 5, 7, 9}
        key = 2
Output : 4
Elements less than or equal to 2 are 1, 2, 
2, 2 therefore result will be 4.

Naive approach: Search whole array linearly and count elements that are less than or equal to the key. 
Efficient approach: As the whole array is sorted we can use binary search to find result. 
Case 1: When key is present in array, the last position of key is the result.
Case 2: When key is not present in array, we ignore left half if key is greater than mid. If key is smaller than mid, we ignore right half. We always end up with a case where key is present before middle element. 
 

C++




// C++ program to count smaller or equal
// elements in sorted array.
#include <bits/stdc++.h>
using namespace std;
 
// A binary search function. It returns
// number of elements less than of equal
// to given key
int binarySearchCount(int arr[], int n, int key)
{
    int left = 0, right = n;
 
    int mid;
    while (left < right) {
        mid = (right + left) >> 1;
 
        // Check if key is present in array
        if (arr[mid] == key) {
           
            // If duplicates are present it returns
            // the position of last element
            while (mid + 1 < n && arr[mid + 1] == key)
                mid++;
            break;
        }
 
        // If key is smaller, ignore right half
        else if (arr[mid] > key)
            right = mid;
 
        // If key is greater, ignore left half
        else
            left = mid + 1;
    }
 
    // If key is not found
    // in array then it will be
    // before mid
    while (mid > -1 && arr[mid] > key)
        mid--;
 
    // Return mid + 1 because of 0-based indexing
    // of array
    return mid + 1;
}
 
// Driver program to test binarySearchCount()
int main()
{
    int arr[] = { 1, 2, 4, 5, 8, 10 };
    int key = 11;
    int n = sizeof(arr) / sizeof(arr[0]);
    cout << binarySearchCount(arr, n, key);
    return 0;
}
Java



// Java program to count smaller or equal
// elements in sorted array.
 
class GFG {
 
  // A binary search function. It returns
  // number of elements less than of equal
  // to given key
  static int binarySearchCount(int arr[], int n, int key)
  {
    int left = 0, right = n;
 
    int mid = 0;
    while (left < right) {
      mid = (right + left) >> 1;
 
      // Check if key is present in array
      if (arr[mid] == key) {
 
        // If duplicates are present it returns
        // the position of last element
        while (mid + 1 < n && arr[mid + 1] == key)
          mid++;
        break;
      }
 
      // If key is smaller, ignore right half
      else if (arr[mid] > key)
        right = mid;
 
      // If key is greater, ignore left half
      else
        left = mid + 1;
    }
 
    // If key is not found in array then it will be
    // before mid
    while (mid > -1 && arr[mid] > key)
      mid--;
 
    // Return mid + 1 because of 0-based indexing
    // of array
    return mid + 1;
  }
 
  // Driver code
  public static void main(String[] args)
  {
    int arr[] = { 1, 2, 4, 5, 8, 10 };
    int key = 11;
    int n = arr.length;
    System.out.print(binarySearchCount(arr, n, key));
  }
}
 
// This code is contributed by Anant Agarwal.
Python3



# Python program to
# count smaller or equal
# elements in sorted array.
 
# A binary search function.
# It returns
# number of elements
# less than of equal
# to given key
def binarySearchCount(arr, n, key):
 
    left = 0
    right = n
  
    mid = 0
    while (left < right):
     
        mid = (right + left)//2
  
        # Check if key is present in array
        if (arr[mid] == key):
         
            # If duplicates are
            # present it returns
            # the position of last element
            while (mid + 1<n and arr[mid + 1] == key):
                 mid+= 1
            break
         
  
        # If key is smaller,
        # ignore right half
        elif (arr[mid] > key):
            right = mid
  
        # If key is greater,
        # ignore left half
        else:
            left = mid + 1
     
  
    # If key is not found in
    # array then it will be
    # before mid
    while (mid > -1 and  arr[mid] > key):
        mid-= 1
  
    # Return mid + 1 because
    # of 0-based indexing
    # of array
    return mid + 1
 
# Driver code
 
arr = [1, 2, 4, 5, 8, 10]
key = 11
n = len(arr)
 
print(binarySearchCount(arr, n, key))
 
# This code is contributed
# by Anant Agarwal.
C#



// C# program to count smaller or
// equal elements in sorted array.
using System;
 
class GFG {
 
    // A binary search function.
    // It returns number of elements
    // less than of equal to given key
    static int binarySearchCount(int[] arr,
                                 int n, int key)
    {
        int left = 0;
        int right = n;
 
        int mid = 0;
        while (left < right) {
            mid = (right + left) / 2;
 
            // Check if key is
            // present in array
            if (arr[mid] == key) {
 
                // If duplicates are present
                // it returns the position
                // of last element
                while (mid + 1 < n && arr[mid + 1] == key)
                    mid++;
                break;
            }
 
            // If key is smaller,
            // ignore right half
            else if (arr[mid] > key)
                right = mid;
 
            // If key is greater,
            // ignore left half
            else
                left = mid + 1;
        }
 
        // If key is not found in array
        // then it will be before mid
        while (mid > -1 && arr[mid] > key)
            mid--;
 
        // Return mid + 1 because of
        // 0-based indexing of array
        return mid + 1;
    }
 
    // Driver code
    static public void Main()
    {
        int[] arr = { 1, 2, 4, 5, 8, 10 };
        int key = 11;
        int n = arr.Length;
        Console.Write(binarySearchCount(arr, n, key));
    }
}
 
// This code is contributed by ajit.
PHP



<?php
// PHP program to count
// smaller or equal
// elements in sorted array.
 
// A binary search function.
// It returns number of
// elements less than of
// equal to given key
function binarySearchCount($arr, $n, $key)
{
    $left = 0;
    $right = $n;
    $mid;
    while ($left < $right)
    {
        $mid = ($right + $left) / 2;
 
        // Check if key is
        // present in array
        if ($arr[$mid] == $key)
        {
            // If duplicates are
            // present it returns
            // the position of
            // last element
            while ($mid + 1 < $n && $arr[$mid + 1] == $key)
                $mid++;
            break;
        }
 
        // If key is smaller,
        // ignore right half
        else if ($mid > -1 && $arr[$mid] > $key)
            $right = $mid;
 
        // If key is greater,
        // ignore left half
        else
            $left = $mid + 1;
    }
 
    // If key is not found in
    // array then it will be
    // before mid
    while ($arr[$mid] > $key)
        $mid--;
 
    // Return mid + 1 because
    // of 0-based indexing
    // of array
    return $mid + 1;
}
 
// Driver Code
$arr = array (1, 2, 4,
              5, 8, 10);
$key = 11;
$n = sizeof($arr) ;
echo binarySearchCount($arr, $n, $key);
 
// This code is contributed by ajit
?>
Javascript



<script>
 
    // Javascript program to
    // count smaller or equal
    // elements in sorted array.
     
    // A binary search function. It returns
    // number of elements less than of equal
    // to given key
    function binarySearchCount(arr, n, key)
    {
        let left = 0, right = n;
 
        let mid;
        while (left < right) {
            mid = (right + left) >> 1;
 
            // Check if key is present in array
            if (arr[mid] == key) {
 
                // If duplicates are
                // present it returns
                // the position of last element
                while ((mid + 1) < n &&
                       arr[mid + 1] == key)
                    mid++;
                break;
            }
 
            // If key is smaller, ignore right half
            else if (arr[mid] > key)
                right = mid;
 
            // If key is greater, ignore left half
            else
                left = mid + 1;
        }
 
        // If key is not found
        // in array then it will be
        // before mid
        while (mid > -1 && arr[mid] > key)
            mid--;
 
        // Return mid + 1 because of 0-based indexing
        // of array
        return mid + 1;
    }
     
    let arr = [ 1, 2, 4, 5, 8, 10 ];
    let key = 11;
    let n = arr.length;
    document.write(binarySearchCount(arr, n, key));
 
</script>
Output
6
Although this solution performs better on average, the worst-case time complexity of this solution is still O(n).
The above program can be implemented using a more simplified binary search. The idea is to check if the middle element is greater than the given element then update right index as mid – 1 but if the middle element is less than or equal to key update answer as mid + 1 and left index as mid + 1.
Below is the implementation of the above approach:
C++



// C++ program to count smaller or equal
// elements in sorted array
#include <bits/stdc++.h>
using namespace std;
 
// A binary search function to return
// the number of elements less than
// or equal to the given key
int binarySearchCount(int arr[], int n, int key)
{
    int left = 0;
    int right = n - 1;
 
    int count = 0;
 
    while (left <= right) {
        int mid = (right + left) / 2;
 
        // Check if middle element is
        // less than or equal to key
        if (arr[mid] <= key) {
 
            // At least (mid + 1) elements are there
            // whose values are less than
            // or equal to key
            count = mid + 1;
            left = mid + 1;
        }
 
        // If key is smaller, ignore right half
        else
            right = mid - 1;
    }
 
    return count;
}
 
// Driver code
int main()
{
    int arr[] = { 1, 2, 4, 11, 11, 16 };
    int key = 11;
    int n = sizeof(arr) / sizeof(arr[0]);
 
    cout << binarySearchCount(arr, n, key);
 
    return 0;
}
Java



// Java program to count smaller or equal
import java.io.*;
 
class GFG
{
     
// A binary search function to return
// the number of elements less than
// or equal to the given key
static int binarySearchCount(int arr[],
                             int n, int key)
{
    int left = 0;
    int right = n - 1;
 
    int count = 0;
 
    while (left <= right)
    {
        int mid = (right + left) / 2;
 
        // Check if middle element is
        // less than or equal to key
        if (arr[mid] <= key)
        {
 
            // At least (mid + 1) elements are there
            // whose values are less than
            // or equal to key
            count = mid + 1;
            left = mid + 1;
        }
 
        // If key is smaller, ignore right half
        else
            right = mid - 1;
    }
    return count;
}
 
// Driver code
public static void main (String[] args)
{
    int arr[] = { 1, 2, 4, 11, 11, 16 };
    int key = 11;
    int n = arr.length;
 
    System.out.println (binarySearchCount(arr, n, key));
}
}
 
// The code is contributed by Sachin.
Python3



# Python3 program to count smaller or equal
# elements in sorted array
 
# A binary search function to return
# the number of elements less than
# or equal to the given key
def binarySearchCount(arr, n, key):
 
    left = 0
    right = n - 1
 
    count = 0
 
    while (left <= right):
        mid = int((right + left) / 2)
 
        # Check if middle element is
        # less than or equal to key
        if (arr[mid] <= key):
 
            # At least (mid + 1) elements are there
            # whose values are less than
            # or equal to key
            count = mid + 1
            left = mid + 1
         
        # If key is smaller, ignore right half
        else:
            right = mid - 1
     
    return count
 
# Driver code
arr = [ 1, 2, 4, 11, 11, 16 ]
key = 11
n = len(arr)
 
print( binarySearchCount(arr, n, key))
 
# This code is contributed by Arnab Kundu
C#



// C# program to count smaller or equal
using System;
     
class GFG
{
     
// A binary search function to return
// the number of elements less than
// or equal to the given key
static int binarySearchCount(int []arr,
                             int n, int key)
{
    int left = 0;
    int right = n - 1;
 
    int count = 0;
 
    while (left <= right)
    {
        int mid = (right + left) / 2;
 
        // Check if middle element is
        // less than or equal to key
        if (arr[mid] <= key)
        {
 
            // At least (mid + 1) elements are there
            // whose values are less than
            // or equal to key
            count = mid + 1;
            left = mid + 1;
        }
 
        // If key is smaller,
        // ignore right half
        else
            right = mid - 1;
    }
    return count;
}
 
// Driver code
public static void Main (String[] args)
{
    int []arr = { 1, 2, 4, 11, 11, 16 };
    int key = 11;
    int n = arr.Length;
 
    Console.WriteLine(binarySearchCount(arr, n, key));
}
}
 
// This code is contributed by PrinciRaj1992
Javascript



<script>
    // Javascript program to count smaller or equal
    // elements in sorted array
     
    // A binary search function to return
    // the number of elements less than
    // or equal to the given key
    function binarySearchCount(arr, n, key)
    {
        let left = 0;
        let right = n - 1;
 
        let count = 0;
 
        while (left <= right) {
            let mid = parseInt((right + left) / 2, 10);
 
            // Check if middle element is
            // less than or equal to key
            if (arr[mid] <= key) {
 
                // At least (mid + 1) elements are there
                // whose values are less than
                // or equal to key
                count = mid + 1;
                left = mid + 1;
            }
 
            // If key is smaller, ignore right half
            else
                right = mid - 1;
        }
 
        return count;
    }
     
    let arr = [ 1, 2, 4, 11, 11, 16 ];
    let key = 11;
    let n = arr.length;
  
    document.write(binarySearchCount(arr, n, key));
     
    // This code is contributed by rameshtravel07.
</script>
Output
5
This article is contributed by nuclode. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to review-team@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. 

My Personal Notes
arrow_drop_up
Previous
Find the number of elements greater than k in a sorted array
Next

Count smaller elements on right side using Set in C++ STL
Recommended Articles
Page :
Count elements smaller than or equal to x in a sorted matrix
18, Jan 18
Delete array elements which are smaller than next or become smaller
22, Mar 18
Count smaller elements in sorted array in C++
30, Mar 18
Search equal, bigger or smaller in a sorted array in Java
23, Aug 18
Size of smallest subarray to be removed to make count of array elements greater and smaller than K equal
26, Aug 20
Count decrements to nearest smaller element required to make all array elements equal
03, Nov 20
Count number of common elements between a sorted array and a reverse sorted array
12, May 21
Count of array elements which is smaller than both its adjacent elements
22, May 20
Count smaller elements present in the array for each array element
17, Mar 21
First strictly smaller element in a sorted array in Java
03, Sep 18
Nearest smaller character to a character K from a Sorted Array
31, Jul 20
Count smaller elements on right side and greater elements on left side using Binary Index Tree
09, Aug 19
Count elements less than or equal to a given value in a sorted rotated array
15, Jun 17
Count triplets from a sorted array having difference between adjacent elements equal to D
12, May 21
Rearrange array such that even index elements are smaller and odd index elements are greater
08, Oct 17
Rearrange the Array to maximize the elements which is smaller than both its adjacent elements
24, Jun 21
Find all Array elements that are smaller than all elements to their right
26, Dec 21
For all Array elements find Product of Sum of all smaller and Sum of all greater elements
06, Apr 22
Count of smaller elements on right side of each element in an Array using Merge sort
04, Feb 20
Count array elements having at least one smaller element on its left and right side
09, Nov 20
Count elements in Array having strictly smaller and strictly greater element present
26, Jan 22
Check if array can be sorted by swapping pairs with GCD of set bits count equal to that of the smallest array element
17, Sep 20
Count of strings in the first array which are smaller than every string in the second array
05, Jul 19
Check if two sorted arrays can be merged to form a sorted array with no adjacent pair from the same array
16, Nov 20
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

Start Your Coding Journey Now!