Rank of all elements in a Stream in descending order when they arrive
Last Updated :
02 Jan, 2023
Given a stream of numbers as arr, the task is to find the rank of each element in the stream in descending order when they arrive.
Rank is defined as the total number of elements that is greater than the arriving element, where rank 1 defines the maximum value in the stream. Each value in the array is unique.
Examples:
Input: arr = [88, 14, 69, 30, 29, 89]
Output: 1 2 2 3 4 1
Explanation:
First 88 arrives, so its rank is 1.
when 14 arrives, 14 is less than 88 so its rank is 2.
when 69 arrives, 69 is less than 88 and greater than 14 so its rank is 2.
when 30 arrives, 30 is less than 88 and 69 so its rank is 3.
when 29 arrives, 29 is less than 88, 69, 30 than 29 so its rank is 4.
when 89 arrives, 89 is greater than all values so its rank is 1.
The rank of elements of array 1 2 2 3 4 1
Input: arr = [100, 110, 80, 85, 88, 89]
Output: 1 1 3 3 3 3
Explanation:
First 100 arrive so its rank is 1.
when 110 arrive, 110 is greater than 100 so its rank is 1.
when 80 arrive, 80 is less than 110 and 100 so its rank is 3.
when 85 arrive, 85 is less than 110 and 100 so its rank is 3.
when 88 arrive, 88 is less than 110 and 100 so its rank is 3.
when 89 arrive, 89 is less than 110 and 100 so its rank is 3.
The rank of elements of array 1 1 3 3 3 3
Naive Approach:
- The first element of the array will always have rank 1.
- Iterate over the array, if the element is greatest among previous elements then its rank is 1.
- If the element is not greatest than previous compared elements. then the rank of this element will be the number of greater elements before it.
For example, lets say if it is greater than 2 previous elements so its rank is 3.
Below is the implementation of the above approach:
C++
#include <iostream>
using namespace std;
void FindRank( int arr[], int length)
{
cout << "1" << " " ;
for ( int i = 1; i < length; i++)
{
int rank = 1;
for ( int j = 0; j < i; j++)
{
if (arr[j] > arr[i])
rank++;
}
cout << rank << " " ;
}
}
int main() {
int arr[] = {88, 14, 69, 30, 29, 89};
int len = sizeof (arr)/ sizeof (arr[0]);
FindRank(arr, len);
return 0;
}
|
Java
import java.util.*;
class GFG{
static void FindRank( int arr[], int length)
{
System.out.print( "1" + " " );
for ( int i = 1 ; i < arr.length; i++)
{
int rank = 1 ;
for ( int j = 0 ; j < i; j++)
{
if (arr[j] > arr[i])
rank++;
}
System.out.print(rank + " " );
}
}
public static void main(String args[]){
int arr[] = { 88 , 14 , 69 , 30 , 29 , 89 };
int len = arr.length;
FindRank(arr, len);
}
}
|
Python3
def FindRank(arr, length):
print ( 1 , end = " " )
for i in range ( 1 , length):
rank = 1
for j in range ( 0 , i):
if (arr[j] > arr[i]):
rank = rank + 1
print (rank, end = " " )
if __name__ = = '__main__' :
arr = [ 88 , 14 , 69 , 30 , 29 , 89 ]
length = len (arr)
FindRank(arr, length)
|
C#
using System;
class GFG{
static void FindRank( int [] arr, int length)
{
Console.Write( "1" + " " );
for ( int i = 1; i < arr.Length; i++)
{
int rank = 1;
for ( int j = 0; j < i; j++)
{
if (arr[j] > arr[i])
rank++;
}
Console.Write(rank + " " );
}
}
public static void Main(){
int [] arr = {88, 14, 69, 30, 29, 89};
int len = arr.Length;
FindRank(arr, len);
}
}
|
Javascript
<script>
function FindRank(arr , length) {
document.write( "1" + " " );
for (i = 1; i < arr.length; i++) {
var rank = 1;
for (j = 0; j < i; j++) {
if (arr[j] > arr[i])
rank++;
}
document.write(rank + " " );
}
}
var arr = [ 88, 14, 69, 30, 29, 89 ];
var len = arr.length;
FindRank(arr, len);
</script>
|
Time complexity: O(N2), where N is length of array.
Space complexity: O(1)
Efficient Approach: The idea is to use Binary search to find the rank of the number. It will give the count of numbers which are greater than the given number.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
void FindRank( int arr[], int length)
{
vector< int > rank;
int first = arr[0];
rank.push_back(first);
cout << 1 << " " ;
for ( int i = 1; i < length; i++)
{
int val = arr[i];
int ind = lower_bound(rank.begin(), rank.end(), val) - rank.begin();
rank.insert(rank.begin() + ind, val);
int eleRank = rank.size() - ind;
cout << eleRank << " " ;
}
}
int main()
{
int arr[] = {88, 14, 69, 30, 29, 89};
int length = sizeof (arr) / sizeof (arr[0]);
FindRank(arr, length);
}
|
Java
import java.util.*;
class GFG {
static void FindRank( int arr[], int length){
List<Integer> rank = new ArrayList<>();
int first = arr[ 0 ];
rank.add(first);
System.out.print( 1 + " " );
for ( int i= 1 ;i<length;i++){
int val = arr[i];
int ind = Collections.binarySearch(rank,val);
if (ind< 0 ){
ind = -ind- 1 ;
} else {
ind++;
}
rank.add(ind,val);
int eleRank = rank.size()-rank.indexOf(val);
System.out.print(eleRank + " " );
}
}
public static void main (String[] args)
{
int []arr = { 88 , 14 , 69 , 30 , 29 , 89 };
int length = arr.length;
FindRank(arr, length);
}
}
|
Python3
import bisect
def FindRank(arr, length):
rank = []
first = arr[ 0 ]
rank.append(first)
print ( 1 , end = " " )
for i in range ( 1 , length):
val = arr[i]
bisect.insort(rank, val)
eleRank = len (rank) - rank.index(val)
print (eleRank, end = " " )
if __name__ = = '__main__' :
arr = [ 88 , 14 , 69 , 30 , 29 , 89 ]
length = len (arr)
FindRank(arr, length)
|
C#
using System;
using System.Collections.Generic;
using System.Linq;
using System.Collections;
public class GFG
{
public static void FindRank( int [] arr, int length)
{
var rank = new List< int >();
var first = arr[0];
rank.Add(first);
Console.Write(1.ToString() + " " );
for ( int i = 1; i < length; i++)
{
var val = arr[i];
var ind = rank.BinarySearch(val);
if (ind < 0)
{
ind = -ind - 1;
}
else
{
ind++;
}
rank.Insert(ind,val);
var eleRank = rank.Count - rank.IndexOf(val);
Console.Write(eleRank.ToString() + " " );
}
}
public static void Main(String[] args)
{
int [] arr = {88, 14, 69, 30, 29, 89};
var length = arr.Length;
GFG.FindRank(arr, length);
}
}
|
Javascript
function lower_bound(arr, target){
for (let i = 0; i < arr.length; i++)
{
if (arr[i] >= target)
return i;
}
return arr.length;
}
function findRank(arr, length) {
const rank = [];
const first = arr[0];
rank.push(first);
let ans = "1 " ;
for (let i = 1; i < length; i++) {
const val = arr[i];
const ind = lower_bound(rank, val);
rank.splice(ind, 0, val);
const eleRank = rank.length - ind;
ans+=eleRank.toString()+ " " ;
}
console.log(ans);
}
const arr = [88, 14, 69, 30, 29, 89];
const length = arr.length;
findRank(arr, length);
|
Time complexity: O(N * log N), where N is length of array.
Space complexity: O(N)
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...