# Count the number of elements which are greater than any of element on right side of an array

Given an array **Arr[]**. The task is to count the number of elements **Arr[i]** in the given array such that one or more smaller elements are present on the right side of the element **Arr[i]** in array.

**Examples: **

Input:Arr[] = { 3, 9, 4, 6, 7, 5 }

Output:3Numbers that counts are: 9, 6, 7

9– As all numbers are present after 9 are smaller than 9,

6– 5 is smaller element present after it,

7– 5 is smaller element which is present after it.

Input:Arr[] = { 3, 2, 1, 2, 3, 4, 5 }

Output:2

**Approach: **

Start traversing array from the last till first element of the array. While traversing maintain a **min** variable which stores the minimum element till now and a counter variable. Compare min variable with the current element. If **min** variable is smaller than current element **Arr[i]**, increase the counter and if **min** is greater than **Arr[i]** then update the **min**.

Below is the implementation of the above approach:

## C++

`// C++ implementation ` `#include <bits/stdc++.h> ` `using` `namespace` `std; ` ` ` `// function to return the count ` `int` `count_greater(` `int` `arr[], ` `int` `n) ` `{ ` ` ` `int` `min = INT_MAX; ` ` ` `int` `counter = 0; ` ` ` ` ` `// Comparing the given element ` ` ` `// with minimum element till ` ` ` `// occurred till now. ` ` ` `for` `(` `int` `i = n - 1; i >= 0; i--) { ` ` ` `if` `(arr[i] > min) { ` ` ` `counter++; ` ` ` `} ` ` ` ` ` `// Updating the min variable ` ` ` `if` `(arr[i] <= min) { ` ` ` `min = arr[i]; ` ` ` `} ` ` ` `} ` ` ` ` ` `return` `counter; ` `} ` ` ` `// Driver code ` `int` `main() ` `{ ` ` ` `int` `arr[] = { 3, 2, 1, 2, 3, 4, 5 }; ` ` ` `int` `n = ` `sizeof` `(arr) / ` `sizeof` `(` `int` `); ` ` ` ` ` `cout << count_greater(arr, n) << endl; ` ` ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

## Java

`// Java implementation of the approach ` `class` `GFG ` `{ ` ` ` `// function to return the count ` `static` `int` `count_greater(` `int` `arr[], ` `int` `n) ` `{ ` ` ` `int` `min = Integer.MAX_VALUE; ` ` ` `int` `counter = ` `0` `; ` ` ` ` ` `// Comparing the given element ` ` ` `// with minimum element till ` ` ` `// occurred till now. ` ` ` `for` `(` `int` `i = n - ` `1` `; i >= ` `0` `; i--) ` ` ` `{ ` ` ` `if` `(arr[i] > min) ` ` ` `{ ` ` ` `counter++; ` ` ` `} ` ` ` ` ` `// Updating the min variable ` ` ` `if` `(arr[i] <= min) ` ` ` `{ ` ` ` `min = arr[i]; ` ` ` `} ` ` ` `} ` ` ` `return` `counter; ` `} ` ` ` `// Driver code ` `public` `static` `void` `main(String[] args) ` `{ ` ` ` `int` `arr[] = { ` `3` `, ` `2` `, ` `1` `, ` `2` `, ` `3` `, ` `4` `, ` `5` `}; ` ` ` `int` `n = arr.length; ` ` ` ` ` `System.out.println(count_greater(arr, n)); ` `} ` `} ` ` ` `// This code is contributed by 29AjayKumar ` |

*chevron_right*

*filter_none*

## Python3

`# Python3 implementation for the above approach ` `import` `sys ` ` ` `# function to return the count ` `def` `count_greater(arr, n) : ` ` ` ` ` `min` `=` `sys.maxsize; ` ` ` `counter ` `=` `0` `; ` ` ` ` ` `# Comparing the given element ` ` ` `# with minimum element till ` ` ` `# occurred till now. ` ` ` `for` `i ` `in` `range` `(n ` `-` `1` `, ` `-` `1` `, ` `-` `1` `) : ` ` ` `if` `(arr[i] > ` `min` `) : ` ` ` `counter ` `+` `=` `1` `; ` ` ` ` ` `# Updating the min variable ` ` ` `if` `(arr[i] <` `=` `min` `) : ` ` ` `min` `=` `arr[i]; ` ` ` ` ` `return` `counter; ` ` ` `# Driver code ` `if` `__name__ ` `=` `=` `"__main__"` `: ` ` ` ` ` `arr ` `=` `[ ` `3` `, ` `2` `, ` `1` `, ` `2` `, ` `3` `, ` `4` `, ` `5` `]; ` ` ` `n ` `=` `len` `(arr); ` ` ` ` ` `print` `(count_greater(arr, n)); ` ` ` `# This code is contributed by AnkitRai01 ` |

*chevron_right*

*filter_none*

## C#

`// C# implementation of the approach ` `using` `System; ` ` ` `class` `GFG ` `{ ` ` ` `// function to return the count ` `static` `int` `count_greater(` `int` `[]arr, ` `int` `n) ` `{ ` ` ` `int` `min = ` `int` `.MaxValue; ` ` ` `int` `counter = 0; ` ` ` ` ` `// Comparing the given element ` ` ` `// with minimum element till ` ` ` `// occurred till now. ` ` ` `for` `(` `int` `i = n - 1; i >= 0; i--) ` ` ` `{ ` ` ` `if` `(arr[i] > min) ` ` ` `{ ` ` ` `counter++; ` ` ` `} ` ` ` ` ` `// Updating the min variable ` ` ` `if` `(arr[i] <= min) ` ` ` `{ ` ` ` `min = arr[i]; ` ` ` `} ` ` ` `} ` ` ` `return` `counter; ` `} ` ` ` `// Driver code ` `static` `public` `void` `Main () ` `{ ` ` ` `int` `[]arr = { 3, 2, 1, 2, 3, 4, 5 }; ` ` ` `int` `n = arr.Length; ` ` ` ` ` `Console.Write(count_greater(arr, n)); ` `} ` `} ` ` ` `// This code is contributed by ajit. ` |

*chevron_right*

*filter_none*

**Output:**

2

Don’t stop now and take your learning to the next level. Learn all the important concepts of Data Structures and Algorithms with the help of the most trusted course: **DSA Self Paced**. Become industry ready at a student-friendly price.

## Recommended Posts:

- Count smaller elements on right side and greater elements on left side using Binary Index Tree
- Count of smaller elements on right side of each element in an Array using Merge sort
- Count of greater elements for each element in the Array
- Count elements in first Array with absolute difference greater than K with an element in second Array
- Count of elements in first Array greater than second Array with each element considered only once
- Closest greater or same value on left side for every element in array
- Replace every element of array with sum of elements on its right side
- Count elements whose sum with K is greater than max element
- Count the number of sub-arrays such that the average of elements present in the sub-array is greater than that not present in the sub-array
- Smallest Greater Element on Right Side
- Elements greater than the previous and next element in an Array
- Adding elements of an array until every element becomes greater than or equal to k
- Sum of elements in an array with frequencies greater than or equal to that element
- Count of distinct index pair (i, j) such that element sum of First Array is greater
- Number of positions such that adding K to the element is greater than sum of all other elements
- Noble integers in an array (count of greater elements is equal to value)
- Find the number of elements greater than k in a sorted array
- Number of ways to choose an integer such that there are exactly K elements greater than it in the given array
- For each element in 1st array count elements less than or equal to it in 2nd array
- For each element in 1st array count elements less than or equal to it in 2nd array | Set 2

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 Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.