Count of smaller or equal elements in sorted array

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: Iterate over the complete array and count elements that are less than or equal to the key. dhanshriborse561

C++

// C++ program to count smaller or equal
// elements in sorted array.
#include <bits/stdc++.h>

using namespace std;
 
// Simple linear traversal for counting

int countOfElements(int arr[], int n, int x)
{

    // here the index is used as count
 
    // declared a variable to count

    int i = 0;
 
    for (i = 0; i < n; i++) {
 
        // break when find

        // greater element

        if (arr[i] > x)

            break;

    }
 
    // return the count

    return i;
}
 
// Driver Code

int main()
{

    int arr[] = { 1, 2, 4, 5, 8, 10 };

    int key = 11;

    int n = sizeof(arr) / sizeof(arr[0]);

    cout << countOfElements(arr, n, key);

    return 0;
}
 
// this code is contributed by rajdeep999

Java

// Java program to count smaller or equal
// elements in sorted array.

import java.io.*;
 
class GFG {

    // Simple linear traversal for counting

    static int countOfElements(int arr[], int n, int key)

    {

        // here the index is used as count
 
        // declared a variable to count

        int i = 0;
 
        for (i = 0; i < n; i++) {
 
            // break when find

            // greater element

            if (arr[i] > key)

                break;

        }
 
        // return the count

        return i;

    }
 
    // 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(countOfElements(arr, n, key));

    }
}
 
// this code is contributed by rajdeep999

Python3

class GFG :

    # Simple linear traversal for counting

    @staticmethod

    def  countOfElements( arr,  n,  key) :

        # here the index is used as count

        # declared a variable to count

        i = 0

        i = 0

        while (i < n) :

            # break when find

            # greater element

            if (arr[i] > key) :

                break

            i += 1

        # return the count

        return i

    # Driver Code

    @staticmethod

    def main( args) :

        arr = [1, 2, 4, 5, 8, 10]

        key = 11

        n = len(arr)

        print(GFG.countOfElements(arr, n, key), end ="")

if __name__=="__main__":

    GFG.main([])

    # This code is contributed by aadityaburujwale.

// Include namespace system

using System;
 
public class GFG
{

  // Simple linear traversal for counting

  public static int countOfElements(int[] arr, int n, int key)

  {

    // here the index is used as count

    // declared a variable to count

    var i = 0;

    for (i = 0; i < n; i++)

    {

      // break when find

      // greater element

      if (arr[i] > key)

      {

        break;

      }

    }

    // return the count

    return i;

  }
 
  // Driver Code

  public static void Main(String[] args)

  {

    int[] arr = {1, 2, 4, 5, 8, 10};

    var key = 11;

    var n = arr.Length;

    Console.Write(GFG.countOfElements(arr, n, key));

  }
}
 
// This code is contributed by dhanshriborse561

Javascript

// Javascript program to count smaller or equal
// elements in sorted array.
// Simple linear traversal for counting

function countOfElements(arr, n, x)
{

    // here the index is used as count

    // declared a variable to count

    let i = 0;

    for (i = 0; i < n; i++) {

        // break when find

        // greater element

        if (arr[i] > x)

            break;

    }

    // return the count

    return i;
}

    // Driver Code

    let arr = [ 1, 2, 4, 5, 8, 10 ];

    let key = 11;

    let n = arr.length;

    console.log(countOfElements(arr, n, key));

    // This code is contributed by Pushpesh Raj.

Output

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

Efficient approach: As the whole array is sorted we can use binary search to find results.

Case 1: When the key is present in the array, the last position of the key is the result.
Case 2: When the key is not present in the array, we ignore the left half if the key is greater than mid. If the key is smaller than mid, we ignore the right half. We always end up with a case where the key is present before the middle element.

Implementation:

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# 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

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

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 and then update right index as mid – 1 but if the middle element is less than or equal to the key update answer as mid + 1 and the 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# 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

Time Complexity: O(log(n))
Auxiliary Space: O(1)

Another Approach: Using standard in-built library functions such as upper_bound. The returns an iterator pointing to the first element in the range [first, last] greater than the value, or last if no such element is found. For more details on the upper_bound function refer to https://www.geeksforgeeks.org/upper_bound-in-cpp/amp/

Below is the code for the same.

C++

// c++ code for the above approach
#include <bits/stdc++.h>

using namespace std;
 

int countOfElements(int arr[], int n, int x)
{

    int i = upper_bound(arr, arr + n, x) - arr;

    return i;
}

int main()
{

    int arr[] = { 1, 2, 4, 5, 8, 10 };

    int key = 9;

    int n = sizeof(arr) / sizeof(arr[0]);

    cout << countOfElements(arr, n, key);

    return 0;
}

Java

// Java code for the above approach
 
import java.util.*;
 
class GFG { 

  // Function to count the number of elements in an array
// that are less than or equal to a given value x

public static int countOfElements(int arr[], int n, int x)
{

    int i = Arrays.binarySearch(arr, x);

    if (i < 0)

        i = -(i + 1);

    return i;
}
 
// Driver code

public static void main(String args[])
{

    int arr[] = { 1, 2, 4, 5, 8, 10 };

    int key = 9;

    int n = arr.length;

    System.out.println(countOfElements(arr, n, key));
}
}

Python3

from bisect import bisect_right
 
# Function to count the number of elements in an array that 
# are less than or equal to a given value x

def countOfElements(arr, n, x):

    i = bisect_right(arr, x)

    return i
 
arr = [1, 2, 4, 5, 8, 10]

key = 9

n = len(arr)

print(countOfElements(arr,n,key))

// C# code for the above approach
 
using System;
 
class GFG {

    // Function to count the number of elements in an array

    // that are less than or equal to a given value x

    public static int countOfElements(int[] arr, int n,

                                      int x)

    {

        int i = Array.BinarySearch(arr, x);

        if (i < 0)

            i = -(i + 1);

        return i;

    }
 
    // Driver code

    public static void Main(string[] args)

    {

        int[] arr = { 1, 2, 4, 5, 8, 10 };

        int key = 9;

        int n = arr.Length;

        Console.WriteLine(countOfElements(arr, n, key));

    }
}
// akashish__

Javascript

function countOfElements(arr, n, x) {

  let i = arr.findIndex(a => a > x);

  return i === -1 ? n : i;
}
 
let arr = [1, 2, 4, 5, 8, 10];
let key = 9;
let n = arr.length;
console.log(countOfElements(arr, n, key));

Output

Time Complexity: O(log(n))
Auxiliary Space: O(1)

Article Tags :

Arrays

DSA

Binary Search