Rank Transform of an Array - Practice Coding Problems

Rank Transform of an Array - Problem

Given an array of integers arr, your task is to transform each element into its rank.

Think of ranking like a leaderboard in a game - the higher your score, the higher your rank! Here's how the ranking system works:

Ranks start from 1 (not 0)
Larger elements get higher ranks - if element A > element B, then rank(A) > rank(B)
Equal elements get equal ranks - identical values share the same rank
Ranks should be consecutive - use the smallest possible rank values

Example: For array [40, 10, 20, 30]:
• 10 is smallest → rank 1
• 20 is next → rank 2
• 30 is next → rank 3
• 40 is largest → rank 4
Result: [4, 1, 2, 3]

Input & Output

example_1.py — Basic ranking

$ Input: arr = [40, 10, 20, 30]

› Output: [4, 1, 2, 3]

💡 Note: After sorting unique elements [10, 20, 30, 40], we get ranks: 10→1, 20→2, 30→3, 40→4. So [40,10,20,30] becomes [4,1,2,3].

example_2.py — Duplicate elements

$ Input: arr = [100, 100, 100]

› Output: [1, 1, 1]

💡 Note: All elements are the same, so they all get rank 1. There's only one unique value, so all elements share the lowest rank.

example_3.py — Mixed with duplicates

$ Input: arr = [37, 12, 28, 9, 100, 56, 80, 5, 12]

› Output: [5, 3, 4, 2, 8, 6, 7, 1, 3]

💡 Note: Unique sorted values: [5,9,12,28,37,56,80,100] get ranks [1,2,3,4,5,6,7,8]. Note that both 12's get rank 3.

Constraints

0 ≤ arr.length ≤ 10⁵
-10⁹ ≤ arr[i] ≤ 10⁹
Array elements can be negative, zero, or positive

Visualization

Tap to expand

Understanding the Visualization

Collect all scores

Gather all unique scores from participants: [40, 10, 20, 30]

Sort by performance

Order scores from lowest to highest: [10, 20, 30, 40]

Assign consecutive ranks

Give ranks 1, 2, 3, 4 to sorted scores respectively

Look up each participant's rank

Map original scores to their assigned ranks: [4, 1, 2, 3]

Key Takeaway

🎯 Key Insight: Instead of comparing each element with all others (O(n²)), we can sort unique values once and create a lookup table for O(1) rank retrieval, achieving optimal O(n log n) time complexity.

Asked in

G Google 42 a Amazon 38 f Meta 25 ⊞ Microsoft 31

The optimal solution uses a two-pass hash table approach with O(n log n) time complexity. First, extract unique elements and sort them to establish ranks. Second, create a hash map for O(1) rank lookups. This is much more efficient than the brute force O(n²) approach that compares every element with every other element.

Common Approaches

Approach	Time	Space	Notes
✓ Two-Pass Hash Table (Optimal)	O(n log n)	O(n)	Sort unique elements to create rank mapping, then lookup ranks
Brute Force (Nested Loops)	O(n²)	O(n)	For each element, count how many unique elements are smaller

Two-Pass Hash Table (Optimal) — Algorithm Steps

Extract all unique elements from the array using a set
Sort the unique elements in ascending order
Create a hash map mapping each sorted element to its rank (1, 2, 3, ...)
Iterate through original array and lookup each element's rank from the hash map

Visualization

Tap to expand

Step-by-Step Walkthrough

Extract unique elements

Get unique values: {40, 10, 20, 30}

Sort unique elements

Sorted: [10, 20, 30, 40]

Create rank mapping

Map: {10→1, 20→2, 30→3, 40→4}

Lookup ranks

For each element in original array, lookup its rank

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int compare(const void* a, const void* b) {
    return (*(int*)a - *(int*)b);
}

int* arrayRankTransform(int* arr, int arrSize, int* returnSize) {
    *returnSize = arrSize;
    if (arrSize == 0) return NULL;
    
    // First pass: get unique elements
    int* unique = (int*)malloc(arrSize * sizeof(int));
    int uniqueCount = 0;
    
    for (int i = 0; i < arrSize; i++) {
        int found = 0;
        for (int j = 0; j < uniqueCount; j++) {
            if (unique[j] == arr[i]) {
                found = 1;
                break;
            }
        }
        if (!found) {
            unique[uniqueCount++] = arr[i];
        }
    }
    
    // Sort unique elements
    qsort(unique, uniqueCount, sizeof(int), compare);
    
    // Second pass: lookup ranks
    int* result = (int*)malloc(arrSize * sizeof(int));
    for (int i = 0; i < arrSize; i++) {
        for (int j = 0; j < uniqueCount; j++) {
            if (unique[j] == arr[i]) {
                result[i] = j + 1;
                break;
            }
        }
    }
    
    free(unique);
    return result;
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    int arr[100], size = 0;
    char* token = strtok(input, "[],\n");
    while (token != NULL && size < 100) {
        arr[size++] = atoi(token);
        token = strtok(NULL, "[],\n");
    }
    
    int returnSize;
    int* result = arrayRankTransform(arr, size, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        if (i > 0) printf(",");
        printf("%d", result[i]);
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

O(n) to create set, O(k log k) to sort k unique elements, O(n) to build map and lookup ranks

⚡ Linearithmic

Space Complexity

O(n)

Space for set of unique elements, hash map for rank mapping, and result array

⚡ Linearithmic Space

73.2K Views

Medium Frequency

~15 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Two-Pass Hash Table (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler