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 <bits/stdc++.h>
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 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 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# 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
// PHP program to find Noble
// elements in an array.
// Returns a Noble integer
// if present, else returns -1.
function nobleInteger( $arr, $size)
{
for ( $i = 0; $i < $size; $i++ )
{
$count = 0;
for ( $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
$arr = array(10, 3, 20, 40, 2);
$size = count($arr);
$res = nobleInteger($arr, $size);
if ($res != -1)
echo "The noble integer is ", $res;
else
echo "No Noble Integer Found";
// This code is contributed by anuj_67.
?>
<script>
// Javascript program to find Noble elements
// in an array.
// Returns a Noble integer if present,
// else returns -1.
function nobleInteger(arr)
{
let size = arr.length;
for (let i = 0; i < size; i++ )
{
let count = 0;
for (let 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
let arr=[10, 3, 20, 40, 2];
let res = nobleInteger(arr);
if (res != -1)
document.write("The noble "
+ "integer is "+ res);
else
document.write("No Noble "
+ "Integer Found");
// This code is contributed by unknown2108
</script>
OutputThe 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)
- Sort the Array arr[] in ascending order. This step takes (O(nlogn)).
- 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<bits/stdc++.h>
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 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<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
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 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# 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
// PHP program to find Noble elements
// Returns a Noble integer if present,
// else returns -1.
function nobleInteger( $arr)
{
sort($arr);
// Return a Noble element if
// present before last.
$n = count($arr);
for ( $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
$arr = array(10, 3, 20, 40, 2);
$res = nobleInteger($arr);
if ($res != -1)
echo "The noble integer is ", $res;
else
echo "No Noble Integer Found";
// This code is contributed by anuj_67.
?>
<script>
// Javascript program to find Noble elements
// in an array.
// Returns a Noble integer if present,
// else returns -1.
function nobleInteger(arr)
{
arr.sort(function(a, b){return a - b;});
// Return a Noble element if present
// before last.
let n = arr.length;
for(let 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
let arr = [ 10, 3, 20, 40, 2 ];
let res = nobleInteger(arr);
if (res != -1)
document.write("The noble integer is " + res);
else
document.write("No Noble Integer Found");
// This code is contributed by patel2127
</script>
OutputThe 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].
- Declare an integer array countArr[] of size n + 1 (where n is the size of given array arr), and initialize it as zero.
- 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]].
- Declare an integer totalGreater, which keeps count of elements greater than current element, and initialize it as countArr[arr[n]].
- 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 <bits/stdc++.h>
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 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.
# 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# 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
<script>
// JavaScript program to find Noble elements
// in an array.
function nobleInteger(arr, n)
{
// Declare a countArr which keeps
// count of all elements
// greater than or equal to arr[i].
// Initialize it with zero.
let countArr = new Uint8Array(n + 1);
// Iterating through the given array
for(let 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
let totalGreater = countArr[n];
// Iterating through countArr
for(let 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
let arr = [ 10, 3, 20, 40, 2 ];
let res = nobleInteger(arr, 5);
if (res != -1)
document.write("The noble integer is " + res);
else
document.write("No Noble Integer Found");
// This code is contributed by Surbhi Tyagi.
</script>
OutputThe 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.
Similar Reads
Count of numbers in given Array greater than next K elements Given an array arr[] of integers of size N, the task is to count the number of elements whose value is greater than all the K elements to its immediate right. If there are less than K numbers to the right of the ith element, then the value of all of them must be lesser than that of the ith person. E
13 min read
Count the elements having frequency equals to its value | Set 2 Given an array of integers arr[] of size N, the task is to count all the elements of the array which have a frequency equals to its value.Examples: Input: arr[] = {3, 2, 2, 3, 4, 3} Output: 2 Explanation : Frequency of element 2 is 2 Frequency of element 3 is 3 Frequency of element 4 is 1 2 and 3 ar
5 min read
Count of array elements which are greater than all elements on its left Given an array arr[] of size n, the task is to count the number of array elements such that all the elements to its left are strictly smaller than it.Note: The first element of the array will be considered to be always satisfying the condition.Examples :Input: arr[] = [2, 4, 5, 6]Output: 4Explanatio
8 min read
Count of smaller or equal elements in sorted array 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 Outp
15+ min read
Count elements in Array having strictly smaller and strictly greater element present Given an array arr[], the task is to find the count of elements in the given array such that there exists an element strictly smaller and an element strictly greater than it. Examples: Input: arr [] = {11, 7, 2, 15}Output: 2Explanation: For arr[1] = 7, arr[0] is strictly greater than it and arr[2] i
8 min read