1331. Rank Transform of an Array

import java.util.*;
class Solution {
    public int[] arrayRankTransform(int[] arr) {
        int[] sorted = arr.clone();
        Arrays.sort(sorted);
        Map<Integer, Integer> rank = new HashMap<>();
        int r = 1;
        for (int num : sorted) {
            if (!rank.containsKey(num)) {
                rank.put(num, r++);
            }
        }
        int[] ans = new int[arr.length];
        for (int i = 0; i < arr.length; i++) {
            ans[i] = rank.get(arr[i]);
        }
        return ans;
    }
}

class Solution:
    def arrayRankTransform(self, arr):
        sorted_arr = sorted(arr)

        rank = {}
        r = 1

        for num in sorted_arr:
            if num not in rank:
                rank[num] = r
                r += 1

        return [rank[num] for num in arr]

class Solution {
public:
    vector<int> arrayRankTransform(vector<int>& arr) {

        vector<int> sorted = arr;
        sort(sorted.begin(), sorted.end());

        unordered_map<int, int> rank;
        int r = 1;

        for (int num : sorted) {
            if (!rank.count(num)) {
                rank[num] = r++;
            }
        }

        vector<int> ans(arr.size());

        for (int i = 0; i < arr.size(); i++) {
            ans[i] = rank[arr[i]];
        }

        return ans;
    }
};

var arrayRankTransform = function(arr) {

    const sorted = [...arr].sort((a, b) => a - b);

    const rank = new Map();
    let r = 1;

    for (const num of sorted) {
        if (!rank.has(num)) {
            rank.set(num, r++);
        }
    }

    return arr.map(num => rank.get(num));
};