# Noble integers in an array (count of greater elements is equal to value)

Last Updated : 19 Sep, 2023

Given an array arr[], find a Noble integer in it. An integer x is said to be Noble in arr[] if the number of integers greater than x is equal to x. If there are many Noble integers, return any of them. If there is no, then return -1.

Examples :

```Input  : [7, 3, 16, 10]
Output : 3
Number of integers greater than 3
is three.

Input  : [-1, -9, -2, -78, 0]
Output : 0
Number of integers greater than 0
is zero.```

Method 1 (Brute Force): Iterate through the array. For every element arr[i], find the number of elements greater than arr[i].

Implementation:

## C++

 `// C++ program to find Noble elements ` `// in an array. ` `#include ` `using` `namespace` `std; ` ` `  `// Returns a Noble integer if present, ` `// else returns -1. ` `int` `nobleInteger(``int` `arr[], ``int` `size) ` `{ ` `    ``for` `(``int` `i = 0; i < size; i++ ) ` `    ``{ ` `        ``int` `count = 0; ` `        ``for` `(``int` `j = 0; j < size; j++)  ` `            ``if` `(arr[i] < arr[j]) ` `                ``count++; ` `                 `  `        ``// If count of greater elements ` `        ``// is equal to arr[i] ` `        ``if` `(count == arr[i]) ` `            ``return` `arr[i]; ` `    ``} ` `     `  `    ``return` `-1; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `arr[] = {10, 3, 20, 40, 2}; ` `    ``int` `size = ``sizeof``(arr) / ``sizeof``(arr[0]); ` `    ``int` `res = nobleInteger(arr, size); ` `     `  `    ``if` `(res != -1) ` `        ``cout<<``"The noble integer is "``<< res; ` `    ``else` `        ``cout<<``"No Noble Integer Found"``; ` `} ` ` `  `// This code is contributed by Smitha. `

## Java

 `// Java program to find Noble elements ` `// in an array. ` `import` `java.util.ArrayList; ` ` `  `class` `GFG { ` `     `  `    ``// Returns a Noble integer if present, ` `    ``// else returns -1. ` `    ``public` `static` `int` `nobleInteger(``int` `arr[]) ` `    ``{ ` `        ``int` `size = arr.length; ` `        ``for` `(``int` `i = ``0``; i < size; i++ ) ` `        ``{ ` `            ``int` `count = ``0``; ` `            ``for` `(``int` `j = ``0``; j < size; j++) ` `                ``if` `(arr[i] < arr[j]) ` `                    ``count++; ` ` `  `            ``// If count of greater elements ` `            ``// is equal to arr[i] ` `            ``if` `(count == arr[i]) ` `                ``return` `arr[i]; ` `        ``} ` `        ``return` `-``1``; ` `    ``} ` ` `  `    ``// Driver code ` `    ``public` `static` `void` `main(String args[]) ` `    ``{ ` `        ``int` `[] arr = {``10``, ``3``, ``20``, ``40``, ``2``}; ` `        ``int` `res = nobleInteger(arr); ` `        ``if` `(res != -``1``) ` `            ``System.out.println(``"The noble "` `                     ``+ ``"integer is "``+ res); ` `        ``else` `            ``System.out.println(``"No Noble "` `                        ``+ ``"Integer Found"``); ` `    ``} ` `} `

## Python3

 `# Python3 program to find Noble ` `# elements in an array. ` ` `  `# Returns a Noble integer if ` `# present, else returns -1. ` `def` `nobleInteger(arr, size): ` ` `  `    ``for` `i ``in` `range``(``0``, size): ` `     `  `        ``count ``=` `0` `        ``for` `j ``in` `range``(``0``, size): ` `            ``if` `(arr[i] < arr[j]): ` `                ``count ``+``=` `1` `        ``# If count of greater  ` `        ``# elements is equal ` `        ``# to arr[i] ` `        ``if` `(count ``=``=` `arr[i]): ` `            ``return` `arr[i] ` `     `  `    ``return` `-``1` ` `  `# Driver code ` `arr ``=` `[``10``, ``3``, ``20``, ``40``, ``2``] ` `size ``=` `len``(arr) ` `res ``=` `nobleInteger(arr,size) ` `if` `(res !``=` `-``1``):  ` `    ``print``(``"The noble integer is "``, ` `                              ``res) ` `else``: ` `    ``print``(``"No Noble Integer Found"``) ` ` `  `# This code is contributed by ` `# Smitha. `

## C#

 `// C# program to find Noble elements ` `// in an array. ` `using` `System; ` ` `  `class` `GFG { ` `     `  `    ``// Returns a Noble integer if present, ` `    ``// else returns -1. ` `    ``public` `static` `int` `nobleInteger(``int` `[] arr) ` `    ``{ ` `        ``int` `size = arr.Length; ` `        ``for` `(``int` `i = 0; i < size; i++ ) ` `        ``{ ` `            ``int` `count = 0; ` `            ``for` `(``int` `j = 0; j < size; j++) ` `                ``if` `(arr[i] < arr[j]) ` `                    ``count++; ` ` `  `            ``// If count of greater elements ` `            ``// is equal to arr[i] ` `            ``if` `(count == arr[i]) ` `                ``return` `arr[i]; ` `        ``} ` `         `  `        ``return` `-1; ` `    ``} ` ` `  `    ``// Driver code ` `    ``public` `static` `void` `Main() ` `    ``{ ` `        ``int` `[] arr = {10, 3, 20, 40, 2}; ` `        ``int` `res = nobleInteger(arr); ` `        ``if` `(res != -1) ` `            ``Console.Write(``"The noble integer"` `                              ``+ ``" is "``+ res); ` `        ``else` `            ``Console.Write(``"No Noble Integer"` `                                 ``+ ``" Found"``); ` `    ``} ` `} ` ` `  `// This code is contributed by Smitha. `

## PHP

 ` `

## Javascript

 ` `

Output

`The noble integer is 3`

Time Complexity: O(n*n) where n is size of input array. This is because two nested for loops are executed.

Space Complexity: O(1) as no extra space has been taken.

Method 2 (Use Sorting)

1. Sort the Array arr[] in ascending order. This step takes (O(nlogn)).
2. Iterate through the array. Compare the value of index i to the number of elements after index i. If arr[i] equals the number of elements after arr[i], it is a noble Integer. Condition to check: (A[i] == length-i-1). This step takes O(n).

Note: Array may have duplicate elements. So, we should skip the elements (adjacent elements in the sorted array) that are same.

Implementation:

## C++

 `// C++ program to find Noble elements ` `// in an array. ` `#include ` `using` `namespace` `std; ` ` `  `// Returns a Noble integer if present, ` `// else returns -1. ` `int` `nobleInteger(``int` `arr[], ``int` `n) ` `{ ` `    ``sort(arr, arr + n); ` ` `  `    ``// Return a Noble element if present ` `    ``// before last. ` `    ``for` `(``int` `i = 0; i < n - 1; i++) ` `    ``{ ` `        ``if` `(arr[i] == arr[i + 1]) ` `            ``continue``; ` ` `  `        ``// In case of duplicates, we ` `        ``// reach last occurrence here. ` `        ``if` `(arr[i] == n - i - 1) ` `            ``return` `arr[i]; ` `    ``} ` `    ``if` `(arr[n - 1] == 0) ` `        ``return` `arr[n - 1]; ` `    ``return` `-1; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `arr[] = {10, 3, 20, 40, 2}; ` `    ``int` `res = nobleInteger(arr, 5); ` `    ``if` `(res != -1) ` `        ``cout << ``"The noble integer is "` `<< res; ` `    ``else` `        ``cout << ``"No Noble Integer Found"``; ` `    ``return` `0; ` `} ` ` `  `// This code is contributed by Rajput-Ji `

## Java

 `// Java program to find Noble elements ` `// in an array. ` `import` `java.util.Arrays; ` ` `  `public` `class` `Main ` `{ ` `    ``// Returns a Noble integer if present, ` `    ``// else returns -1. ` `    ``public` `static` `int` `nobleInteger(``int` `arr[]) ` `    ``{ ` `        ``Arrays.sort(arr); ` ` `  `        ``// Return a Noble element if present ` `        ``// before last. ` `        ``int` `n = arr.length; ` `        ``for` `(``int` `i=``0``; i

## Python3

 `# Python3 code to find Noble elements ` `# in an array ` ` `  `def` `nobleInteger(arr): ` `     `  `    ``arr.sort() ` `     `  `    ``# Return a Noble element if  ` `    ``# present before last ` `    ``n ``=` `len``(arr) ` `     `  `    ``for` `i ``in` `range``(n ``-` `1``): ` `         `  `        ``if` `arr[i] ``=``=` `arr[i ``+` `1``]: ` `            ``continue` `             `  `        ``# In case of duplicates we reach ` `        ``# last occurrence here ` `        ``if` `arr[i] ``=``=` `n ``-` `i ``-` `1``: ` `            ``return` `arr[i] ` `     `  `    ``if` `arr[n ``-` `1``] ``=``=` `0``: ` `        ``return` `arr[n ``-` `1``] ` `    ``return` `-``1` ` `  `# Driver code ` `arr ``=` `[``10``, ``3``, ``20``, ``40``, ``2``] ` ` `  `res ``=` `nobleInteger(arr) ` ` `  `if` `res !``=` `-``1``: ` `    ``print``(``"The noble integer is"``, res) ` `else``: ` `    ``print``(``"No Noble Integer Found"``) ` ` `  `# This code is contributed ` `# by Mohit Kumar `

## C#

 `// C# program to find Noble elements ` `// in an array.  ` `using` `System; ` ` `  `public` `class` `GFG { ` `     `  `    ``public` `static` `int` `nobleInteger(``int``[] arr) ` `    ``{ ` `        ``Array.Sort(arr); ` ` `  `        ``// Return a Noble element if present ` `        ``// before last. ` `        ``int` `n = arr.Length; ` `        ``for` `(``int` `i = 0; i < n-1; i++) ` `        ``{ ` `            ``if` `(arr[i] == arr[i+1]) ` `                ``continue``; ` ` `  `            ``// In case of duplicates, we ` `            ``// reach last occurrence here. ` `            ``if` `(arr[i] == n-i-1) ` `                ``return` `arr[i]; ` `        ``} ` ` `  `        ``if` `(arr[n-1] == 0) ` `            ``return` `arr[n-1]; ` ` `  `        ``return` `-1; ` `    ``} ` `     `  `    ``// Driver code ` `    ``static` `public` `void` `Main () ` `    ``{ ` `        ``int` `[] arr = {10, 3, 20, 40, 2}; ` `        ``int` `res = nobleInteger(arr); ` `        ``if` `(res != -1) ` `        ``Console.Write(``"The noble integer is "` `                                      ``+ res); ` `        ``else` `            ``Console.Write(``"No Noble Integer "`  `                                  ``+ ``"Found"``); ` `         `  `    ``} ` `} ` ` `  `// This code is contributed by Shrikant13. `

## PHP

 ` `

## Javascript

 ``

Output

`The noble integer is 3`

Method 3 (Using Count Array):

Maintain a count array countArr[] which keeps count of all elements greater than or equal to arr[i].

1. Declare an integer array countArr[] of size n + 1 (where n is the size of given array arr), and initialize it as zero.
2. Iterate through array arr, if arr[i] < 0, we ignore it, if arr[i] >= n, we increment countArr[n], else simply increment countArr[arr[i]].
3. Declare an integer totalGreater, which keeps count of elements greater than current element, and initialize it as countArr[arr[n]].
4. Iterate through count array countArr from last to first index, if at any point we find that totalGreater = i for countArr[i] > 0, we have found our solution. Else keep increasing totalGreater with countArr[i].

Implementation:

## C++

 `// C++ program to find Noble elements ` `// in an array. ` `#include ` `using` `namespace` `std; ` ` `  `int` `nobleInteger(``int` `arr[], ``int` `n) ` `{ ` `     `  `    ``// Declare a countArr which keeps  ` `    ``// count of all elements ` `    ``// greater than or equal to arr[i].  ` `    ``// Initialize it with zero. ` `    ``int` `countArr[n + 1] = { 0 }; ` ` `  `    ``// Iterating through the given array ` `    ``for` `(``int` `i = 0; i < n; i++) { ` `       `  `        ``// If current element is less  ` `        ``// than zero, it cannot ` `        ``// be a solution so we skip it. ` `        ``if` `(arr[i] < 0) { ` `            ``continue``; ` `        ``} ` ` `  `        ``// If current element is >= size of input array, if ` `        ``// will be greater than all elements which can be ` `        ``// considered as our solution, as it cannot be ` `        ``// greater than size of array. ` `        ``else` `if` `(arr[i] >= n) { ` `            ``countArr[n]++; ` `        ``} ` ` `  `        ``// Else we increase the count  ` `        ``// of elements >= our ` `        ``// current array in countArr ` `        ``else` `{ ` `            ``countArr[arr[i]]++; ` `        ``} ` `    ``} ` ` `  `    ``// Initially, countArr[n] is  ` `    ``// count of elements greater ` `    ``// than all possible solutions ` `    ``int` `totalGreater = countArr[n]; ` ` `  `    ``// Iterating through countArr ` `    ``for` `(``int` `i = n - 1; i >= 0; i--) { ` `       `  `        ``// If totalGreater = current index, means we found ` `        ``// arr[i] for which count of elements >= arr[i] is ` `        ``// equal to arr[i] ` `        ``if` `(totalGreater == i && countArr[i] > 0) { ` `            ``return` `i; ` `        ``} ` `       `  `        ``// If at any point count of elements greater than ` `        ``// arr[i] becomes more than current index, then it ` `        ``// means we can no longer have a solution ` `        ``else` `if` `(totalGreater > i) { ` `            ``return` `-1; ` `        ``} ` ` `  `        ``// Adding count of elements >= arr[i] to ` `        ``// totalGreater. ` `        ``totalGreater += countArr[i]; ` `    ``} ` ` `  `    ``return` `-1; ` `} ` ` `  `// Driver Code ` `int` `main() ` `{ ` `    ``int` `arr[] = { 10, 3, 20, 40, 2 }; ` `    ``int` `res = nobleInteger(arr, 5); ` `    ``if` `(res != -1) ` `        ``cout << ``"The noble integer is "` `<< res; ` `    ``else` `        ``cout << ``"No Noble Integer Found"``; ` `    ``return` `0; ` `}`

## Java

 `// Java program to find Noble elements ` `// in an array. ` `import` `java.util.Arrays; ` `class` `GFG { ` ` `  `  ``static` `int` `nobleInteger(``int` `arr[], ``int` `n) { ` ` `  `    ``// Declare a countArr which keeps ` `    ``// count of all elements ` `    ``// greater than or equal to arr[i]. ` `    ``// Initialize it with zero. ` `    ``int` `countArr[] = ``new` `int``[n + ``1``]; ` `    ``Arrays.fill(countArr, ``0``); ` ` `  `    ``// Iterating through the given array ` `    ``for` `(``int` `i = ``0``; i < n; i++) { ` ` `  `      ``// If current element is less ` `      ``// than zero, it cannot ` `      ``// be a solution so we skip it. ` `      ``if` `(arr[i] < ``0``) { ` `        ``continue``; ` `      ``} ` ` `  `      ``// If current element is >= size of input array, if ` `      ``// will be greater than all elements which can be ` `      ``// considered as our solution, as it cannot be ` `      ``// greater than size of array. ` `      ``else` `if` `(arr[i] >= n) { ` `        ``countArr[n]++; ` `      ``} ` ` `  `      ``// Else we increase the count ` `      ``// of elements >= our ` `      ``// current array in countArr ` `      ``else` `{ ` `        ``countArr[arr[i]]++; ` `      ``} ` `    ``} ` ` `  `    ``// Initially, countArr[n] is ` `    ``// count of elements greater ` `    ``// than all possible solutions ` `    ``int` `totalGreater = countArr[n]; ` ` `  `    ``// Iterating through countArr ` `    ``for` `(``int` `i = n - ``1``; i >= ``0``; i--) { ` ` `  `      ``// If totalGreater = current index, means we found ` `      ``// arr[i] for which count of elements >= arr[i] is ` `      ``// equal to arr[i] ` `      ``if` `(totalGreater == i && countArr[i] > ``0``) { ` `        ``return` `i; ` `      ``} ` ` `  `      ``// If at any point count of elements greater than ` `      ``// arr[i] becomes more than current index, then it ` `      ``// means we can no longer have a solution ` `      ``else` `if` `(totalGreater > i) { ` `        ``return` `-``1``; ` `      ``} ` ` `  `      ``// Adding count of elements >= arr[i] to ` `      ``// totalGreater. ` `      ``totalGreater += countArr[i]; ` `    ``} ` ` `  `    ``return` `-``1``; ` `  ``} ` ` `  `  ``// Driver Code ` `  ``public` `static` `void` `main(String args[]) { ` `    ``int` `arr[] = { ``10``, ``3``, ``20``, ``40``, ``2` `}; ` `    ``int` `res = nobleInteger(arr, ``5``); ` `    ``if` `(res != -``1``) ` `      ``System.out.println(``"The noble integer is "` `+ res); ` `    ``else` `      ``System.out.println(``"No Noble Integer Found"``); ` `  ``} ` `} ` ` `  `// This code is contributed by saurabh_jaiswal.`

## Python3

 `# Python program to find Noble elements ` `# in an array. ` `def` `nobleInteger(arr, n): ` ` `  `    ``# Declare a countArr which keeps ` `    ``# count of all elements ` `    ``# greater than or equal to arr[i]. ` `    ``# Initialize it with zero. ` `    ``countArr ``=` `[``0``] ``*` `(n ``+` `1``) ` ` `  `    ``# Iterating through the given array ` `    ``for` `i ``in` `range``(n): ` ` `  `        ``# If current element is less ` `        ``# than zero, it cannot ` `        ``# be a solution so we skip it. ` `        ``if` `(arr[i] < ``0``): ` `            ``continue` ` `  `        ``# If current element is >= size of input ` `        ``# array, if will be greater than all ` `        ``# elements which can be considered as ` `        ``# our solution, as it cannot be ` `        ``# greater than size of array. ` `        ``else` `if` `(arr[i] >``=` `n): ` `            ``countArr[n] ``+``=` `1` ` `  `        ``# Else we increase the count ` `        ``# of elements >= our ` `        ``# current array in countArr ` `        ``else``: ` `            ``countArr[arr[i]] ``+``=` `1` ` `  `    ``# Initially, countArr[n] is ` `    ``# count of elements greater ` `    ``# than all possible solutions ` `    ``totalGreater ``=` `countArr[n] ` ` `  `    ``# Iterating through countArr ` `    ``for` `i ``in` `range``(n ``-` `1``, ``-``1``, ``-``1``): ` ` `  `        ``# If totalGreater = current index, ` `        ``# means we found arr[i] for which ` `        ``# count of elements >= arr[i] is ` `        ``# equal to arr[i] ` `        ``if` `(totalGreater ``=``=` `i ``and` `countArr[i] > ``0``): ` `            ``return` `i ` ` `  `        ``# If at any point count of elements ` `        ``# greater than arr[i] becomes more ` `        ``# than current index, then it means ` `        ``# we can no longer have a solution ` `        ``else` `if` `(totalGreater > i): ` `            ``return` `-``1` ` `  `        ``# Adding count of elements >= arr[i] to ` `        ``# totalGreater. ` `        ``totalGreater ``+``=` `countArr[i] ` `    ``return` `-``1` ` `  `# Driver Code ` `arr ``=` `[``10``, ``3``, ``20``, ``40``, ``2``] ` `res ``=` `nobleInteger(arr, ``5``) ` ` `  `if` `(res !``=` `-``1``): ` `    ``print``(f``"The noble integer is {res}"``) ` `else``: ` `    ``print``(``"No Noble Integer Found"``) ` ` `  `# This code is contributed by gfgking`

## C#

 `// C# program to find Noble elements ` `// in an array. ` `using` `System; ` ` `  `public` `class` `GFG { ` ` `  `  ``static` `int` `nobleInteger(``int``[] arr, ``int` `n) ` `  ``{ ` ` `  `    ``// Declare a countArr which keeps ` `    ``// count of all elements ` `    ``// greater than or equal to arr[i]. ` `    ``// Initialize it with zero. ` `    ``int``[] countArr = ``new` `int``[n + 1]; ` `    ``for` `(``int` `i = 0; i < n + 1; i++) ` `      ``countArr[i] = 0; ` `    ``// Iterating through the given array ` `    ``for` `(``int` `i = 0; i < n; i++) { ` ` `  `      ``// If current element is less ` `      ``// than zero, it cannot ` `      ``// be a solution so we skip it. ` `      ``if` `(arr[i] < 0) { ` `        ``continue``; ` `      ``} ` ` `  `      ``// If current element is >= size of input array, ` `      ``// if will be greater than all elements which ` `      ``// can be considered as our solution, as it ` `      ``// cannot be greater than size of array. ` `      ``else` `if` `(arr[i] >= n) { ` `        ``countArr[n]++; ` `      ``} ` ` `  `      ``// Else we increase the count ` `      ``// of elements >= our ` `      ``// current array in countArr ` `      ``else` `{ ` `        ``countArr[arr[i]]++; ` `      ``} ` `    ``} ` ` `  `    ``// Initially, countArr[n] is ` `    ``// count of elements greater ` `    ``// than all possible solutions ` `    ``int` `totalGreater = countArr[n]; ` ` `  `    ``// Iterating through countArr ` `    ``for` `(``int` `i = n - 1; i >= 0; i--) { ` ` `  `      ``// If totalGreater = current index, means we ` `      ``// found arr[i] for which count of elements >= ` `      ``// arr[i] is equal to arr[i] ` `      ``if` `(totalGreater == i && countArr[i] > 0) { ` `        ``return` `i; ` `      ``} ` ` `  `      ``// If at any point count of elements greater ` `      ``// than arr[i] becomes more than current index, ` `      ``// then it means we can no longer have a ` `      ``// solution ` `      ``else` `if` `(totalGreater > i) { ` `        ``return` `-1; ` `      ``} ` ` `  `      ``// Adding count of elements >= arr[i] to ` `      ``// totalGreater. ` `      ``totalGreater += countArr[i]; ` `    ``} ` ` `  `    ``return` `-1; ` `  ``} ` ` `  `  ``// Driver code ` `  ``static` `public` `void` `Main() ` `  ``{ ` `    ``int``[] arr = { 10, 3, 20, 40, 2 }; ` `    ``int` `n = arr.Length; ` `    ``int` `res = nobleInteger(arr, n); ` `    ``if` `(res != -1) ` `      ``Console.Write(``"The noble integer is "` `+ res); ` `    ``else` `      ``Console.Write(``"No Noble Integer "` `                    ``+ ``"Found"``); ` `  ``} ` `} ` ` `  `// This code is contributed by Aarti_Rathi`

## Javascript

 ``

Output

`The noble integer is 3`
• Complexity Analysis:
• Time Complexity: O(n). As we iterate through both input array and countArr once.
• Space Complexity: O(n). As we use countArr of size same as given array.

Previous
Next