thảo luận Leetcode mỗi ngày

use std::collections::{HashMap, BTreeSet};
impl Solution {
    pub fn array_rank_transform(arr: Vec<i32>) -> Vec<i32> {
        let rank_of = BTreeSet::<_>::from_iter(arr.iter().cloned())
            .into_iter()
            .enumerate()
            .fold(HashMap::new(), |mut rank_of, (idx, num)| {
                rank_of.insert(num, idx as i32 + 1);
                rank_of
            });
        arr.iter().map(|num| rank_of[num]).collect()
    }
}

class Solution:
    def arrayRankTransform(self, A: List[int]) -> List[int]:
        B = sorted(set(A))
        C = {r:l + 1 for l,r in enumerate(B) }
        return [C[a] for a in A ]

class Solution {
    public int[] arrayRankTransform(int[] arr) {
        int[] cp = new int[arr.length];
        System.arraycopy(arr, 0, cp, 0, arr.length);
        java.util.Arrays.sort(cp);
        java.util.Map<Integer, Integer> map = new java.util.HashMap<>();
        int rank = 1;
        for (int e : cp) {
            if (map.get(e) == null) map.put(e, rank++);
        }
        java.util.stream.IntStream.range(0, arr.length).parallel().forEach(i -> arr[i] = map.get(arr[i]));
        return arr;
    }
}

class Solution {
    public int[] arrayRankTransform(int[] arr) {
        int n = arr.length;
        if (n==0)
            return arr;
        HashMap<Integer,Integer> map = new HashMap<>();
        int[] arr2 = arr.clone();     
        Arrays.sort(arr2);
        int index =1;
        map.put(arr2[0],index++);
        
        for(int i = 1;i<n;i++)
            if(arr2[i]!=arr2[i-1])
                map.put(arr2[i],index++);
    
        for(int i = 0; i<n;i++)
            arr[i] = map.get(arr[i]);
        
        return arr;
    }
}

class Solution {
    public int findPeakElement(int[] nums) {
        int n = nums.length;
        int l =0 ;
        int r =n;
        while(l<r){
            int mid = (r+l)>>1;
            if(nums[mid]>nums[(mid-1+n)%n] && nums[mid]>nums[(mid+1)%n]) return mid;
            else if(nums[mid]>nums[(mid-1+n)%n] && nums[mid]<nums[(mid+1)%n]) l =mid+1;
            else r =mid;
        }
        return l;
    }
}

public class Solution {
    public int[] ArrayRankTransform(int[] arr) {
        int[] index = new int[arr.Length];
        for (int i = 0; i < arr.Length; ++i) {
            index[i] = i;
        }
        Array.Sort(index, (i, j) => (arr[i] - arr[j]));
        int[] res = new int[arr.Length];
        int rank = 1;
        for (int i = 0; i < arr.Length; ++i) {
            if (i > 0 && arr[index[i]] == arr[index[i-1]]) rank--;
            res[index[i]] = rank++;
        }
        return res;
    }
}

class Solution {
    public int[] arrayRankTransform(int[] arr) {
        int n = arr.length;
        int[] sortedArr = arr.clone();
        Arrays.sort(sortedArr);       

        Map<Integer, Integer> map = new HashMap<>();

        int rank = 1;
        for (int num : sortedArr) {
            if (map.containsKey(num)) {
                continue;
            }
            map.put(num, rank++);
        }

        int[] res = new int[n];

        for (int i = 0; i < n; i++) {
            res[i] = map.get(arr[i]);
        }

        return res;
    }
}