# Count of smaller or equal elements in sorted array

• Difficulty Level : Easy
• Last Updated : 22 Sep, 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: Iterate over the complete array and count elements that are less than or equal to the key

## C++

 `// C++ program to count smaller or equal``// elements in sorted array.``#include ``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);``    ``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`

Output

`6`

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

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

 ``

Output

`6`

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

 ``

Output

`5`

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

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.

My Personal Notes arrow_drop_up