# Queries for greater than and not less than

Given an array of N integers. There will be Q queries, each include two integer of form q and x, 0 <= q <= 1. Queries are of two types:

• In first query (q = 0), the task is to find count of integers which are not less than x (OR greater than or equal to x).

• In second query (q = 1), the task is to find count of integers greater than x.

Examples:

```Input : arr[] = { 1, 2, 3, 4 } and Q = 3
Query 1: 0 5
Query 2: 1 3
Query 3: 0 3
Output :0
1
2
Explanation:
x = 5, q = 0 : There are no elements greater than or equal to it.
x = 3, q = 1 : There is one element greater than 3 which is 4.
x = 3, q = 0 : There are two elements greater than or equal to 3.
```

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

Method 1: A Naive approach can be for each query, traverse the whole array and count integers less or greater than x, depending on q. Time Complexity for this approach will be O(Q*N).

Method 2: An efficient approach can be sort the array and use binary search for each query. This will take O(NlogN + QlogN).

Below is C++ implementation of this approach:

```// C++ to find number of integer less or greater given
// integer queries
#include<bits/stdc++.h>
using namespace std;

// Return the index of integer which are not less than x
// (or greater than or equal to x)
int lower_bound(int arr[], int start, int end, int x)
{
while (start < end)
{
int mid = (start + end)>>1;
if (arr[mid] >= x)
end = mid;
else
start = mid + 1;
}

return start;
}

// Return the index of integer which are greater than x.
int upper_bound(int arr[], int start, int end, int x)
{
while (start < end)
{
int mid = (start + end)>>1;
if (arr[mid] <= x)
start = mid + 1;
else
end = mid;
}

return start;
}

void query(int arr[], int n, int type, int x)
{
// Counting number of integer which are greater than x.
if (type)
cout << n - upper_bound(arr, 0, n, x) << endl;

// Counting number of integer which are not less than x
// (Or greater tha or equal to x)
else
cout << n - lower_bound(arr, 0, n, x) << endl;
}

// Driven Program
int main()
{
int arr[] = { 1, 2, 3, 4 };
int n = sizeof(arr)/sizeof(arr[0]);

sort(arr, arr + n);

query(arr, n, 0, 5);
query(arr, n, 1, 3);
query(arr, n, 0, 3);

return 0;
}
```

Output:

```0
1
2
```

Time Complexity : O( (N + Q) * logN).

This article is contributed by Anuj Chauhan. 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.

# GATE CS Corner    Company Wise Coding Practice

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.
2.6 Average Difficulty : 2.6/5.0
Based on 5 vote(s)