# Rank of all elements in an array

Given an array of N integers with duplicates allowed. All elements are ranked from 1 to N in ascending order if they are distinct. If there are say x repeated elements of a particular value then each element should be assigned a rank equal to the arithmetic mean of x consecutive ranks.

Examples:

```Input : 20 30 10
Output : 2.0 3.0 1.0

Input : 10 12 15 12 10 25 12
Output : 1.5, 4.0, 6.0, 4.0, 1.5, 7.0, 4.0
10 is the smallest and there are two 10s so
take the average of two consecutive ranks
1 and 2 i.e. 1.5 . Next smallest element is 12.
Since, two elements are already ranked, the
next rank that can be given is 3. However, there
are three 12's so the rank of 2 is (3+4+5) / 3 = 4.
Next smallest element is 15. There is only one 15
so 15 gets a rank of 6 since 5 elements are ranked.
Next element is 25 and it gets a rank of 7.

Input : 1, 2, 5, 2, 1, 60, 3
Output : 1.5, 3.5, 6.0, 3.5, 1.5, 7.0, 5.0
```

Explanation for first input :

Method I (Simple).
Consider that there are no repeated elements. In such a case the rank of each element is simply 1 + the count of smaller elements in the array. Now if the array were to contain repeated elements then modify the ranks by considering the no of equal elements too. If there are exactly r elements which are less than e and s elements which are equal to e, then e gets the rank given by

```(r + r+1 + r+2 ... r+s-1)/s

[Separating all r's and applying
natural number sum formula]
= (r*s + s*(s-1)/2)/s
= r + 0.5*(s-1)
```

Algorithm

```function rankify(A)
N = length of A
R is the array for storing ranks
for i in 0..N-1
r = 1, s = 1
for j in 0..N-1
if j != i and A[j] < A[i]
r += 1
if j != i and A[j] = A[i]
s += 1
// Assign Rank to A[i]
R[i] = r + 0.5*(s-1)
return R
```

Implementation of the method is given below

## C++

 `// CPP Code to find rank of elements ` `#include ` `using` `namespace` `std; ` ` `  `// Function to find rank ` `void` `rankify(``int``* A , ``int` `n) { ` ` `  `    ``// Rank Vector ` `    ``float` `R[n] = {0}; ` `     `  `    ``// Sweep through all elements in A for each ` `    ``// element count the number of less than and ` `    ``// equal elements separately in r and s. ` `    ``for` `(``int` `i = 0; i < n; i++) { ` `        ``int` `r = 1, s = 1; ` `         `  `        ``for` `(``int` `j = 0; j < n; j++) { ` `            ``if` `(j != i && A[j] < A[i]) ` `                ``r += 1; ` `                 `  `            ``if` `(j != i && A[j] == A[i]) ` `                ``s += 1;      ` `        ``} ` `         `  `        ``// Use formula to obtain rank ` `        ``R[i] = r + (``float``)(s - 1) / (``float``) 2; ` `     `  `    ``}  ` `     `  `    ``for` `(``int` `i = 0; i < n; i++) ` `        ``cout << R[i] << ``' '``; ` ` `  `    ``} ` `     `  `// Driver Code ` `int` `main() { ` `    ``int` `A[] = {1, 2, 5, 2, 1, 25, 2}; ` `    ``int` `n = ``sizeof``(A) / ``sizeof``(A); ` `     `  `    ``for` `(``int` `i = 0; i < n; i++) ` `    ``cout << A[i] << ``' '``; ` `    ``cout << ``'\n'``; ` `     `  `    ``rankify(A, n); ` `     `  `    ``return` `0; ` `} ` ` `  `// This code is contributed by Gitanjali. `

## Java

 `// Java Code to find rank of elements ` `public` `class` `GfG { ` `     `  `    ``// Function to print m Maximum elements ` `    ``public` `static` `void` `rankify(``int` `A[], ``int` `n) ` `    ``{ ` `        ``// Rank Vector ` `        ``float` `R[] = ``new` `float``[n]; ` `     `  `        ``// Sweep through all elements in A ` `        ``// for each element count the number ` `        ``// of less than and equal elements ` `        ``// separately in r and s ` `        ``for` `(``int` `i = ``0``; i < n; i++) { ` `            ``int` `r = ``1``, s = ``1``; ` `             `  `            ``for` `(``int` `j = ``0``; j < n; j++)  ` `            ``{ ` `                ``if` `(j != i && A[j] < A[i]) ` `                    ``r += ``1``; ` `                     `  `                ``if` `(j != i && A[j] == A[i]) ` `                    ``s += ``1``;      ` `            ``} ` `         `  `        ``// Use formula to obtain  rank ` `        ``R[i] = r + (``float``)(s - ``1``) / (``float``) ``2``; ` `     `  `        ``}  ` `     `  `        ``for` `(``int` `i = ``0``; i < n; i++) ` `            ``System.out.print(R[i] + ``"  "``); ` `         `  `    ``} ` ` `  `    ``// Driver code ` `    ``public` `static` `void` `main(String args[]) ` `    ``{ ` `        ``int` `A[] = {``1``, ``2``, ``5``, ``2``, ``1``, ``25``, ``2``}; ` `        ``int` `n = A.length; ` `      `  `        ``for` `(``int` `i = ``0``; i < n; i++) ` `            ``System.out.print(A[i] + ``"    "``); ` `            ``System.out.println(); ` `            ``rankify(A, n); ` `    ``} ` `} ` ` `  `// This code is contributed by Swetank Modi `

## Python3

 `# Python Code to find  ` `# rank of elements ` `def` `rankify(A): ` ` `  `    ``# Rank Vector ` `    ``R ``=` `[``0` `for` `x ``in` `range``(``len``(A))] ` ` `  `    ``# Sweep through all elements ` `    ``# in A for each element count ` `    ``# the number of less than and  ` `    ``# equal elements separately ` `    ``# in r and s. ` `    ``for` `i ``in` `range``(``len``(A)): ` `        ``(r, s) ``=` `(``1``, ``1``) ` `        ``for` `j ``in` `range``(``len``(A)): ` `            ``if` `j !``=` `i ``and` `A[j] < A[i]: ` `                ``r ``+``=` `1` `            ``if` `j !``=` `i ``and` `A[j] ``=``=` `A[i]: ` `                ``s ``+``=` `1`        `        `  `        ``# Use formula to obtain rank ` `        ``R[i] ``=` `r ``+` `(s ``-` `1``) ``/` `2` ` `  `    ``# Return Rank Vector ` `    ``return` `R ` ` `  `if` `__name__ ``=``=` `"__main__"``: ` `    ``A ``=` `[``1``, ``2``, ``5``, ``2``, ``1``, ``25``, ``2``] ` `    ``print``(A) ` `    ``print``(rankify(A)) `

## C#

 `// C# Code to find rank of elements ` `using` `System; ` ` `  `public` `class` `GfG { ` `     `  `    ``// Function to print m Maximum ` `    ``// elements ` `    ``public` `static` `void` `rankify(``int` `[]A, ``int` `n) ` `    ``{ ` `        ``// Rank Vector ` `        ``float` `[]R = ``new` `float``[n]; ` `     `  `        ``// Sweep through all elements ` `        ``// in A  for each element count ` `        ``// the number  of less than and ` `        ``// equal elements separately in ` `        ``// r and s ` `        ``for` `(``int` `i = 0; i < n; i++) { ` `            ``int` `r = 1, s = 1; ` `             `  `            ``for` `(``int` `j = 0; j < n; j++)  ` `            ``{ ` `                ``if` `(j != i && A[j] < A[i]) ` `                    ``r += 1; ` `                     `  `                ``if` `(j != i && A[j] == A[i]) ` `                    ``s += 1;  ` `            ``} ` `         `  `        ``// Use formula to obtain rank ` `        ``R[i] = r + (``float``)(s - 1) / (``float``) 2; ` `     `  `        ``}  ` `     `  `        ``for` `(``int` `i = 0; i < n; i++) ` `            ``Console.Write(R[i] + ``" "``); ` `         `  `    ``} ` ` `  `    ``// Driver code ` `    ``public` `static` `void` `Main() ` `    ``{ ` `        ``int` `[]A = {1, 2, 5, 2, 1, 25, 2}; ` `        ``int` `n = A.Length; ` `     `  `        ``for` `(``int` `i = 0; i < n; i++) ` `            ``Console.Write(A[i] + ``" "``); ` `            ``Console.WriteLine(); ` `            ``rankify(A, n); ` `    ``} ` `} ` ` `  `// This code is contributed by vt_m. `

## PHP

 ` `

Output:

```[1, 2, 5, 2, 1, 25, 2]
[1.5, 4.0, 6.0, 4.0, 1.5, 7.0, 4.0]
```

Time Complexity is O(N*N), while space complexity is O(1) (excluding space required to hold ranks)

Method II (Efficient)
In this method, create another array (T) of tuples. The first element of the tuple stores the value while the second element refers to the index of the value in the array. Then, sort T in ascending order using the first value of each tuple. Once sorted it is guaranteed that equal elements become adjacent. Then simply walk down T, find the no of adjacent elements and set ranks for each of these elements. Use the second member of each tuple to determine the indices of the values.

Algorithm

```function rankify_improved(A)
N = Length of A
T = Array of tuples (i,j),
where i = A[i] and j = i
R = Array for storing ranks
Sort T in ascending order
according to i

for j in 0...N-1
k = j

while A[k] == A[k+1]
k += 1

n = k - j + 1

// Modify rank for each
for j in 0..n-1

// Get the index of the
index = T[i+j]
R[index] = r + (n-1)*0.5

// Skip n ranks
r += n

// Skip n indices
j += n

return R
```

The Python implementation of the method is given below

## Python3

 `# Python code to find  ` `# rank of elements ` `def` `rankify_improved(A): ` `     `  `    ``# create rank vector ` `    ``R ``=` `[``0` `for` `i ``in` `range``(``len``(A))] ` ` `  `    ``# Create an auxiliary array of tuples ` `    ``# Each tuple stores the data as well ` `    ``# as its index in A ` `    ``T ``=` `[(A[i], i) ``for` `i ``in` `range``(``len``(A))] ` ` `  `    ``# T[] is the data and T[] is ` `    ``# the index of data in A ` ` `  `    ``# Sort T according to first element ` `    ``T.sort(key``=``lambda` `x: x[``0``]) ` ` `  `    ``(rank, n, i) ``=` `(``1``, ``1``, ``0``) ` ` `  `    ``while` `i < ``len``(A): ` `        ``j ``=` `i ` ` `  `        ``# Get no of elements with equal rank ` `        ``while` `j < ``len``(A) ``-` `1` `and` `T[j][``0``] ``=``=` `T[j ``+` `1``][``0``]: ` `            ``j ``+``=` `1` `        ``n ``=` `j ``-` `i ``+` `1` ` `  `        ``for` `j ``in` `range``(n): ` ` `  `            ``# For each equal element use formula ` `            ``# obtain index of T[i+j] in A ` `            ``idx ``=` `T[i``+``j][``1``] ` `            ``R[idx] ``=` `rank ``+` `(n ``-` `1``) ``*` `0.5` ` `  `        ``# Increment rank and i ` `        ``rank ``+``=` `n ` `        ``i ``+``=` `n ` ` `  `    ``return` `R ` ` `  `if` `__name__ ``=``=` `"__main__"``: ` `    ``A ``=` `[``1``, ``2``, ``5``, ``2``, ``1``, ``25``, ``2``] ` `    ``print``(A) ` `    ``print``(rankify_improved(A)) `

Output

```[1, 2, 5, 2, 1, 25, 2]
[1.5, 4.0, 6.0, 4.0, 1.5, 7.0, 4.0]
```

Time Complexity depends on the sorting procedure which is typically O(N Log N). The auxiliary space is O(N), since we need to store the indices as well as values.

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

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.

Improved By : Mohit Korabu, Rajput-Ji