Introduction

Ranking array elements means assigning each element a position relative to the others while preserving the connection to the original order. The main design choice is how to handle ties. Once that rule is clear, the implementation usually becomes a sort-plus-mapping problem.

What “Rank” Actually Means

For an array such as [40, 10, 20, 10], the sorted order is [10, 10, 20, 40]. But there are several legitimate ranking systems:

• dense rank: 1, 1, 2, 3
• competition rank: 1, 1, 3, 4
• average rank: ties get the average of their occupied positions

So before writing code, define the ranking rule. Otherwise two correct implementations may still disagree.

Dense Ranking by Sorting with Indexes

A common pattern is to sort pairs of (value, original_index), then walk the sorted data and assign ranks back to the original positions.

1def dense_rank(values):
2    pairs = sorted((value, i) for i, value in enumerate(values))
3    result = [0] * len(values)
4
5    rank = 0
6    prev = object()
7
8    for value, original_index in pairs:
9        if value != prev:
10            rank += 1
11            prev = value
12        result[original_index] = rank
13
14    return result
15
16print(dense_rank([40, 10, 20, 10]))  # [3, 1, 2, 1]

This works well because sorting puts equal values next to each other while the stored original index lets you rebuild the answer in input order.

Competition Ranking

If ties should skip rank numbers, use competition ranking instead.

1def competition_rank(values):
2    pairs = sorted((value, i) for i, value in enumerate(values))
3    result = [0] * len(values)
4
5    current_rank = 1
6    for pos, (value, original_index) in enumerate(pairs):
7        if pos > 0 and value != pairs[pos - 1][0]:
8            current_rank = pos + 1
9        result[original_index] = current_rank
10
11    return result
12
13print(competition_rank([40, 10, 20, 10]))  # [4, 1, 3, 1]

This is common in leaderboards and sports standings.

If Values Are Unique, Ranking Is Simpler

When there are no duplicate values, you can rank by sorting once and building a lookup table.

1def unique_ranks(values):
2    sorted_values = sorted(values)
3    rank_of = {value: i + 1 for i, value in enumerate(sorted_values)}
4    return [rank_of[value] for value in values]
5
6print(unique_ranks([30, 10, 20]))  # [3, 1, 2]

This version is concise, but it assumes values are unique. With duplicates, the dictionary approach needs a tie policy.

Complexity and Tradeoffs

Most array-ranking implementations sort first, so the time complexity is typically O(n log n). That is usually the right trade for general input.

If the value range is tiny and known in advance, specialized counting-based approaches can do better, but that is a narrower problem than generic ranking.

The more important practical choice is usually not asymptotic speed. It is handling ties correctly and returning the answer in the shape the caller expects.

Ranking and Stability

If two equal values appear in the input, their relative order in the sorted intermediate form usually does not matter for ordinary ranking. But if the application attaches extra metadata to each element, stable sorting or explicit original indexes become important.

That is another reason the pair-based approach is a good default. It preserves the link back to the original array without guesswork.

A NumPy Version for Numeric Workflows

If the data is already in NumPy, you can still use the same core idea.

1import numpy as np
2
3values = np.array([40, 10, 20, 10])
4order = np.argsort(values)
5print(order)

argsort gives the order of indices rather than direct ranks. From there, you still need to implement the tie policy explicitly. That is why understanding the ranking rule matters more than memorizing one library call.

Common Pitfalls

• Starting implementation before deciding how ties should be ranked.
• Losing the original positions after sorting.
• Using a simple dictionary-based rank map when duplicates are present.
• Confusing sorted order with the final rank array in original order.
• Optimizing away the sort before confirming ranking correctness.

Summary

• Ranking array elements is usually a sort-plus-mapping problem.
• The most important design choice is how ties should be handled.
• Sorting (value, original_index) pairs is a reliable general pattern.
• Unique-value arrays allow simpler lookup-table approaches.
• For most workloads, correctness of tie handling matters more than micro-optimizing the sort.