Rank Transform of an Array

Rank Transform of an Array - Problem

Given an array of integers arr, replace each element with its rank.

The rank represents how large the element is. The rank has the following rules:

Rank is an integer starting from 1.
The larger the element, the larger the rank. If two elements are equal, their rank must be the same.
Rank should be as small as possible.

Input & Output

Example 1 — Basic Case

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

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

💡 Note: 40 is the largest (rank 4), 10 is smallest (rank 1), 20 is second smallest (rank 2), 30 is third smallest (rank 3)

Example 2 — Duplicate Values

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

› Output: [1,1,1]

💡 Note: All elements are equal, so they all get the same rank 1 (smallest possible)

Example 3 — 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 are [5,9,12,28,37,56,80,100] with ranks 1-8. Element 12 appears twice and both get rank 3

Constraints

0 ≤ arr.length ≤ 10⁵
-10⁹ ≤ arr[i] ≤ 10⁹

Visualization

Tap to expand

Asked in

a Amazon 15 f Facebook 12 G Google 8 M Microsoft 6

The key insight is to sort unique values first to establish rank order. The optimal approach extracts unique values, sorts them, creates a value-to-rank mapping, then transforms the original array. Time: O(n log n), Space: O(n)

Common Approaches

✓ Brute Force - Count Smaller Elements

⏱️ Time: O(n³) Space: O(n)

For each element in the array, iterate through all elements to count how many unique values are smaller than it. The rank is this count plus 1.

Sort and Map Approach

⏱️ Time: O(n log n) Space: O(n)

Extract unique values, sort them to determine rank order, create a mapping from value to rank, then replace each element with its rank using the mapping.

Brute Force - Count Smaller Elements — Algorithm Steps

For each element, find all unique values smaller than it
Count these smaller unique values
Rank = count + 1

Visualization

Tap to expand

Step-by-Step Walkthrough

For Each Element

Examine every element to find its rank

Count Smaller

Count unique values smaller than current element

Assign Rank

Rank = count of smaller unique values + 1

Code -

solution.c — C

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

int* solution(int* arr, int arrSize, int* returnSize) {
    *returnSize = arrSize;
    int* result = (int*)malloc(arrSize * sizeof(int));
    
    for (int i = 0; i < arrSize; i++) {
        int uniqueCount = 0;
        int* seen = (int*)malloc(arrSize * sizeof(int));
        int seenCount = 0;
        
        for (int j = 0; j < arrSize; j++) {
            if (arr[j] < arr[i]) {
                int found = 0;
                for (int k = 0; k < seenCount; k++) {
                    if (seen[k] == arr[j]) {
                        found = 1;
                        break;
                    }
                }
                if (!found) {
                    seen[seenCount++] = arr[j];
                    uniqueCount++;
                }
            }
        }
        result[i] = uniqueCount + 1;
        free(seen);
    }
    
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n³)

For each element (n), we check all other elements (n), and for counting unique smaller values we may scan again (n)

⚠ Quadratic Growth

Space Complexity

O(n)

Result array to store ranks

⚡ Linearithmic Space

89.4K Views

Medium Frequency

~12 min Avg. Time

2.2K 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

Brute Force - Count Smaller Elements — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler