# Count elements less than or equal to a given value in a sorted rotated array

Given a sorted array of n distinct integers rotated at some point. Given a value x. The problem is to count all the elements in the array which are less than or equal to x.

Examples:

```Input : arr[] = {4, 5, 8, 1, 3},
x = 6
Output : 4

Input : arr[] = {6, 10, 12, 15, 2, 4, 5},
x = 14
Output : 6
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Naive Approach: One by one traverse all the elements of the array and count the one’s which are less than or equal to x. Time Complexity O(n).

Efficient Approach: Prerequisite of a modified binary search which can return the index of the largest element smaller than or equal to a given value in a sorted range of arr[l…h].
Refer this post for the required modified binary search:

Steps:

1. Find the index of the smallest element in rotated sorted array. Refer this post. Let it be min_index.
2. If x <= arr[n-1], find the index of the largest element smaller than or equal to x in the sorted range arr[min_index…n-1] with the help of modified binary search.
Let it be index1. Now, count = index1 + 1 – min_index.
3. If 0 <= (min_index -1) && x <= arr[min_index – 1], find the index of the largest element smaller than or equal to x in the sorted range arr[0…min_index-1] with the help of modified binary search. Let it be index2. Now, count = n – min_index + index2 + 1.
4. Else count = n.

## C++

 `// C++ implementation to count elements less than or  ` `// equal to a given value in a sorted rotated array ` `#include ` ` `  `using` `namespace` `std; ` ` `  `// function to find the minimum element's index ` `int` `findMinIndex(``int` `arr[], ``int` `low, ``int` `high) ` `{ ` `    ``// This condition is needed to handle the case when  ` `    ``// array is not rotated at all ` `    ``if` `(high < low)  ``return` `0; ` `  `  `    ``// If there is only one element left ` `    ``if` `(high == low) ``return` `low; ` `  `  `    ``// Find mid ` `    ``int` `mid = (low + high) / 2; ` `  `  `    ``// Check if element (mid+1) is minimum element. Consider ` `    ``// the cases like {3, 4, 5, 1, 2} ` `    ``if` `(mid < high && arr[mid+1] < arr[mid]) ` `       ``return` `(mid + 1); ` `  `  `    ``// Check if mid itself is minimum element ` `    ``if` `(mid > low && arr[mid] < arr[mid - 1]) ` `       ``return` `mid; ` `  `  `    ``// Decide whether we need to go to left half or right half ` `    ``if` `(arr[high] > arr[mid]) ` `       ``return` `findMinIndex(arr, low, mid-1); ` `    ``return` `findMinIndex(arr, mid+1, high); ` `} ` ` `  `// function returns the index of largest element  ` `// smaller than equal to 'x' in 'arr[l...h]'.  ` `// If no such element exits in the given range,  ` `// then it returns l-1.  ` `int` `binary_search(``int` `arr[], ``int` `l, ``int` `h, ``int` `x) ` `{ ` `    ``while` `(l <= h) ` `    ``{ ` `        ``int` `mid = (l+h) / 2; ` ` `  `        ``// if 'x' is less than or equla to arr[mid],  ` `        ``// then search in arr[mid+1...h] ` `        ``if` `(arr[mid] <= x) ` `            ``l = mid + 1; ` ` `  `        ``// else search in arr[l...mid-1]     ` `        ``else` `            ``h = mid - 1;     ` `    ``} ` `     `  `    ``// required index ` `    ``return` `h; ` `} ` ` `  `// function to count elements less than  ` `// or equal to a given value ` `int` `countEleLessThanOrEqual(``int` `arr[], ``int` `n, ``int` `x) ` `{ ` `    ``// index of the smallest element in the array ` `    ``int` `min_index = findMinIndex(arr, 0, n-1); ` `     `  `    ``// if largest element smaller than or equal to 'x' lies ` `    ``// in the sorted range arr[min_index...n-1] ` `    ``if` `(x <= arr[n-1]) ` `        ``return` `(binary_search(arr, min_index, n-1, x) + 1 - min_index); ` `     `  `    ``// if largest element smaller than or equal to 'x' lies ` `    ``// in the sorted range arr[0...min_index-1] ` `    ``if` `((min_index - 1) >= 0 && x <= arr[min_index - 1]) ` `        ``return` `(n - min_index + binary_search(arr, 0, min_index-1, x) + 1); ` `     `  `    ``// else all the elements of the array ` `    ``// are less than 'x'     ` `    ``return` `n;                 ` `} ` ` `  `// Driver program to test above ` `int` `main() ` `{ ` `    ``int` `arr[] = {6, 10, 12, 15, 2, 4, 5}; ` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]); ` `    ``int` `x = 14; ` `    ``cout << ``"Count = "` `         ``<< countEleLessThanOrEqual(arr, n, x); ` `    ``return` `0; ` `}  `

## Java

 `// Java implementation to count elements ` `// less than or equal to a given ` `// value in a sorted rotated array ` ` `  `class` `GFG { ` `     `  `// function to find the minimum  ` `// element's index ` `static` `int` `findMinIndex(``int` `arr[], ``int` `low, ``int` `high)  ` `{ ` `    ``// This condition is needed to handle  ` `    ``// the case when array is not rotated at all ` `    ``if` `(high < low) ` `    ``return` `0``; ` ` `  `    ``// If there is only one element left ` `    ``if` `(high == low) ` `    ``return` `low; ` ` `  `    ``// Find mid ` `    ``int` `mid = (low + high) / ``2``; ` ` `  `    ``// Check if element (mid+1) is  ` `    ``// minimum element. Consider ` `    ``// the cases like {3, 4, 5, 1, 2} ` `    ``if` `(mid < high && arr[mid + ``1``] < arr[mid]) ` `    ``return` `(mid + ``1``); ` ` `  `    ``// Check if mid itself is minimum element ` `    ``if` `(mid > low && arr[mid] < arr[mid - ``1``]) ` `    ``return` `mid; ` ` `  `    ``// Decide whether we need to go to  ` `    ``// left half or right half ` `    ``if` `(arr[high] > arr[mid]) ` `    ``return` `findMinIndex(arr, low, mid - ``1``); ` `    ``return` `findMinIndex(arr, mid + ``1``, high); ` `} ` ` `  `// function returns the index of largest element ` `// smaller than equal to 'x' in 'arr[l...h]'. ` `// If no such element exits in the given range, ` `// then it returns l-1. ` `static` `int` `binary_search(``int` `arr[], ``int` `l, ``int` `h, ``int` `x)  ` `{ ` `    ``while` `(l <= h) { ` `    ``int` `mid = (l + h) / ``2``; ` ` `  `    ``// if 'x' is less than or equla to arr[mid], ` `    ``// then search in arr[mid+1...h] ` `    ``if` `(arr[mid] <= x) ` `        ``l = mid + ``1``; ` ` `  `    ``// else search in arr[l...mid-1] ` `    ``else` `        ``h = mid - ``1``; ` `    ``} ` ` `  `    ``// required index ` `    ``return` `h; ` `} ` ` `  `// function to count elements less than ` `// or equal to a given value ` `static` `int` `countEleLessThanOrEqual(``int` `arr[], ``int` `n, ``int` `x)  ` `{ ` `    ``// index of the smallest element in the array ` `    ``int` `min_index = findMinIndex(arr, ``0``, n - ``1``); ` ` `  `    ``// if largest element smaller than or  ` `    ``// equal to 'x' lies in the sorted ` `    ``// range arr[min_index...n-1] ` `    ``if` `(x <= arr[n - ``1``]) ` `    ``return` `(binary_search(arr, min_index, n - ``1``, x) + ``1` `- min_index); ` ` `  `    ``// if largest element smaller than or  ` `    ``// equal to 'x' lies in the sorted ` `    ``// range arr[0...min_index-1] ` `    ``if` `((min_index - ``1``) >= ``0` `&& x <= arr[min_index - ``1``]) ` `    ``return` `(n - min_index + binary_search(arr, ``0``, min_index - ``1``, x) + ``1``); ` ` `  `    ``// else all the elements of the array ` `    ``// are less than 'x' ` `    ``return` `n; ` `} ` ` `  `// Driver code ` `public` `static` `void` `main(String[] args)  ` `{ ` `    ``int` `arr[] = {``6``, ``10``, ``12``, ``15``, ``2``, ``4``, ``5``}; ` `    ``int` `n = arr.length; ` `    ``int` `x = ``14``; ` `    ``System.out.print(``"Count = "` `+  ` `                      ``countEleLessThanOrEqual(arr, n, x)); ` `} ` `} ` ` `  `// This code is contributed by Anant Agarwal. `

## Python3

 `# Python implementation to ` `# count elements less than or  ` `# equal to a given value ` `# in a sorted rotated array ` ` `  `# function to find the ` `# minimum element's index ` `def` `findMinIndex(arr,low,high): ` ` `  `    ``# This condition is needed ` `    ``# to handle the case when  ` `    ``# array is not rotated at all ` `    ``if` `(high < low): ` `        ``return` `0` `   `  `    ``# If there is only one element left ` `    ``if` `(high ``=``=` `low): ` `        ``return` `low ` `   `  `    ``# Find mid ` `    ``mid ``=` `(low ``+` `high) ``/``/` `2` `   `  `    ``# Check if element (mid+1) is ` `    ``# minimum element. Consider ` `    ``# the cases like {3, 4, 5, 1, 2} ` `    ``if` `(mid < high ``and` `arr[mid``+``1``] < arr[mid]): ` `       ``return` `(mid ``+` `1``) ` `   `  `    ``# Check if mid itself ` `    ``# is minimum element ` `    ``if` `(mid > low ``and` `arr[mid] < arr[mid ``-` `1``]): ` `       ``return` `mid ` `   `  `    ``# Decide whether we need to ` `    ``# go to left half or right half ` `    ``if` `(arr[high] > arr[mid]): ` `       ``return` `findMinIndex(arr, low, mid``-``1``) ` `    ``return` `findMinIndex(arr, mid``+``1``, high) ` ` `  `# function returns the  ` `# index of largest element  ` `# smaller than equal to  ` `# 'x' in 'arr[l...h]'.  ` `# If no such element exits ` `# in the given range,  ` `# then it returns l-1.  ` `def` `binary_search(arr,l,h,x): ` ` `  `    ``while` `(l <``=` `h): ` `     `  `        ``mid ``=` `(l``+``h) ``/``/` `2` `  `  `        ``# if 'x' is less than ` `        ``# or equla to arr[mid],  ` `        ``# then search in arr[mid+1...h] ` `        ``if` `(arr[mid] <``=` `x): ` `            ``l ``=` `mid ``+` `1` `  `  `        ``# else search in arr[l...mid-1]     ` `        ``else``: ` `            ``h ``=` `mid ``-` `1`     `     `  `    ``# required index ` `    ``return` `h ` `  `  `# function to count ` `# elements less than  ` `# or equal to a given value ` `def` `countEleLessThanOrEqual(arr,n,x): ` ` `  `    ``# index of the smallest ` `    ``# element in the array ` `    ``min_index ``=` `findMinIndex(arr, ``0``, n``-``1``) ` `      `  `    ``# if largest element smaller ` `    ``# than or equal to 'x' lies ` `    ``# in the sorted range arr[min_index...n-1] ` `    ``if` `(x <``=` `arr[n``-``1``]): ` `        ``return` `(binary_search(arr, min_index, n``-``1``, x) ``+` `1` `-` `min_index) ` `      `  `    ``# if largest element smaller ` `    ``# than or equal to 'x' lies ` `    ``# in the sorted range arr[0...min_index-1] ` `    ``if` `((min_index ``-` `1``) >``=` `0` `and` `x <``=` `arr[min_index ``-` `1``]): ` `        ``return` `(n ``-` `min_index ``+` `binary_search(arr, ``0``, min_index``-``1``, x) ``+` `1``) ` `      `  `    ``# else all the elements of the array ` `    ``# are less than 'x'     ` `    ``return` `n                 ` ` `  `# driver code ` `arr ``=` `[``6``, ``10``, ``12``, ``15``, ``2``, ``4``, ``5``] ` `n ``=` `len``(arr) ` `x ``=` `14` ` `  `print``(``"Count = "``,end``=``"") ` `print``(countEleLessThanOrEqual(arr, n, x)) ` ` `  `# This code is contributed ` `# by Anant Agarwal. `

## C#

 `// C# implementation to count elements ` `// less than or equal to a given ` `// value in a sorted rotated array ` `using` `System; ` `         `  `public` `class` `GFG { ` `     `  `    ``// function to find the minimum  ` `    ``// element's index ` `    ``static` `int` `findMinIndex(``int` `[]arr, ``int` `low, ` `                                      ``int` `high)  ` `    ``{ ` `         `  `        ``// This condition is needed to handle  ` `        ``// the case when array is not rotated ` `        ``// at all ` `        ``if` `(high < low) ` `            ``return` `0; ` `     `  `        ``// If there is only one element left ` `        ``if` `(high == low) ` `            ``return` `low; ` `     `  `        ``// Find mid ` `        ``int` `mid = (low + high) / 2; ` `     `  `        ``// Check if element (mid+1) is  ` `        ``// minimum element. Consider ` `        ``// the cases like {3, 4, 5, 1, 2} ` `        ``if` `(mid < high && arr[mid + 1] < arr[mid]) ` `            ``return` `(mid + 1); ` `     `  `        ``// Check if mid itself is minimum element ` `        ``if` `(mid > low && arr[mid] < arr[mid - 1]) ` `            ``return` `mid; ` `     `  `        ``// Decide whether we need to go to  ` `        ``// left half or right half ` `        ``if` `(arr[high] > arr[mid]) ` `            ``return` `findMinIndex(arr, low, mid - 1); ` `             `  `        ``return` `findMinIndex(arr, mid + 1, high); ` `    ``} ` `     `  `    ``// function returns the index of largest element ` `    ``// smaller than equal to 'x' in 'arr[l...h]'. ` `    ``// If no such element exits in the given range, ` `    ``// then it returns l-1. ` `    ``static` `int` `binary_search(``int` `[]arr, ``int` `l,  ` `                                       ``int` `h, ``int` `x)  ` `    ``{ ` `        ``while` `(l <= h) ` `        ``{ ` `            ``int` `mid = (l + h) / 2; ` `         `  `            ``// if 'x' is less than or equla to ` `            ``// arr[mid], then search in  ` `            ``// arr[mid+1...h] ` `            ``if` `(arr[mid] <= x) ` `                ``l = mid + 1; ` `         `  `            ``// else search in arr[l...mid-1] ` `            ``else` `                ``h = mid - 1; ` `        ``} ` `     `  `        ``// required index ` `        ``return` `h; ` `    ``} ` `     `  `    ``// function to count elements less than ` `    ``// or equal to a given value ` `    ``static` `int` `countEleLessThanOrEqual(``int` `[]arr, ` `                                      ``int` `n, ``int` `x)  ` `    ``{ ` `         `  `        ``// index of the smallest element in ` `        ``// the array ` `        ``int` `min_index = findMinIndex(arr, 0, n - 1); ` `     `  `        ``// if largest element smaller than or  ` `        ``// equal to 'x' lies in the sorted ` `        ``// range arr[min_index...n-1] ` `        ``if` `(x <= arr[n - 1]) ` `            ``return` `(binary_search(arr, min_index, ` `                          ``n - 1, x) + 1 - min_index); ` `     `  `        ``// if largest element smaller than or  ` `        ``// equal to 'x' lies in the sorted ` `        ``// range arr[0...min_index-1] ` `        ``if` `((min_index - 1) >= 0 &&  ` `                             ``x <= arr[min_index - 1]) ` `            ``return` `(n - min_index + binary_search(arr, ` `                             ``0, min_index - 1, x) + 1); ` `     `  `        ``// else all the elements of the array ` `        ``// are less than 'x' ` `        ``return` `n; ` `    ``} ` `     `  `    ``// Driver code ` `    ``public` `static` `void` `Main()  ` `    ``{ ` `        ``int` `[]arr = {6, 10, 12, 15, 2, 4, 5}; ` `        ``int` `n = arr.Length; ` `        ``int` `x = 14; ` `         `  `        ``Console.Write(``"Count = "` `+  ` `                ``countEleLessThanOrEqual(arr, n, x)); ` `    ``} ` `} ` ` `  `// This code is contributed by Sam007. `

## PHP

 ` ``\$low` `&& ` `        ``\$arr``[``\$mid``] < ``\$arr``[``\$mid` `- 1]) ` `    ``return` `\$mid``; ` ` `  `    ``// Decide whether we need to go ` `    ``// to left half or right half ` `    ``if` `(``\$arr``[``\$high``] > ``\$arr``[``\$mid``]) ` `    ``return` `findMinIndex(``\$arr``, ``\$low``, ``\$mid` `- 1); ` `    ``return` `findMinIndex(``\$arr``, ``\$mid` `+ 1, ``\$high``); ` `} ` ` `  `// function returns the index of largest ` `// element smaller than equal to 'x' in   ` `// 'arr[l...h]'. If no such element exits  ` `// in the given range, then it returns l-1.  ` `function` `binary_search(&``\$arr``, ``\$l``, ``\$h``, ``\$x``) ` `{ ` `    ``while` `(``\$l` `<= ``\$h``) ` `    ``{ ` `        ``\$mid` `= ``intval``((``\$l` `+ ``\$h``) / 2); ` ` `  `        ``// if 'x' is less than or equla  ` `        ``// to arr[mid], then search in ` `        ``// arr[mid+1...h] ` `        ``if` `(``\$arr``[``\$mid``] <= ``\$x``) ` `            ``\$l` `= ``\$mid` `+ 1; ` ` `  `        ``// else search in arr[l...mid-1]  ` `        ``else` `            ``\$h` `= ``\$mid` `- 1;  ` `    ``} ` `     `  `    ``// required index ` `    ``return` `\$h``; ` `} ` ` `  `// function to count elements less  ` `// than or equal to a given value ` `function` `countEleLessThanOrEqual(&``\$arr``, ``\$n``, ``\$x``) ` `{ ` `    ``// index of the smallest element  ` `    ``// in the array ` `    ``\$min_index` `= findMinIndex(``\$arr``, 0, ``\$n` `- 1); ` `     `  `    ``// if largest element smaller than  ` `    ``// or equal to 'x' lies in the sorted  ` `    ``// range arr[min_index...n-1] ` `    ``if` `(``\$x` `<= ``\$arr``[``\$n` `- 1]) ` `        ``return` `(binary_search(``\$arr``, ``\$min_index``,  ` `                              ``\$n` `- 1, ``\$x``) + 1 - ``\$min_index``); ` `     `  `    ``// if largest element smaller than or  ` `    ``// equal to 'x' lies in the sorted ` `    ``// range arr[0...min_index-1] ` `    ``if` `((``\$min_index` `- 1) >= 0 &&  ` `         ``\$x` `<= ``\$arr``[``\$min_index` `- 1]) ` `        ``return` `(``\$n` `- ``\$min_index` `+  ` `                ``binary_search(``\$arr``, 0,  ` `                              ``\$min_index` `- 1, ``\$x``) + 1); ` `     `  `    ``// else all the elements of  ` `    ``// the array are less than 'x'  ` `    ``return` `\$n``;              ` `} ` ` `  `// Driver Code ` `\$arr` `= ``array``(6, 10, 12, 15, 2, 4, 5); ` `\$n` `= sizeof(``\$arr``); ` `\$x` `= 14; ` `echo` `"Count = "` `. countEleLessThanOrEqual(``\$arr``, ``\$n``, ``\$x``); ` ` `  `// This code is contributed  ` `// by ChitraNayal ` `?> `

Output:

```Count = 6
```

Time Complexity: O(logn)

This article is contributed by Ayush Jauhari. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.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.

My Personal Notes arrow_drop_up

Improved By : Sam007, chitranayal

Article Tags :
Practice Tags :

Be the First to upvote.

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.