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

class Solution {
    public String[] findRelativeRanks(int[] score) {
        String[] places = new String[score.length];
        int[] scores = new int[score.length];
        for (int i = 0; i < score.length; i++) {
            scores[i] = score[i];
        }
        Arrays.sort(scores);
        int rank = 1;
        Map<Integer, String> map = new HashMap<>();
        final String GOLD = "Gold Medal";
        final String SILVER = "Silver Medal";
        final String BRONZE = "Bronze Medal";
        for (int i = scores.length - 1; i >= 0; i--) {
            switch (rank) {
                case 1: map.put(scores[i], GOLD); break;
                case 2: map.put(scores[i], SILVER); break;
                case 3: map.put(scores[i], BRONZE); break;
                default: map.put(scores[i], String.valueOf(rank)); break;
            }
            rank++;
        }
        for (int i = 0; i < score.length; i++) {
            places[i] = map.get(score[i]);
        }
        return places;
    }
}

vector<string> findRelativeRanks(vector<int>& score) {
        vector<string> result;
        result.resize(score.size());
        for(int i = 0; i < score.size(); i++) {
            int rank = i + 1;
            int it_max = 0;
            for (int j = 1; j < score.size(); j++) {
                if(score[j] > score[it_max]) it_max = j;
            }
            score[it_max] = -1;
            switch(rank) {
                case 1:
                    result[it_max] = "Gold Medal";
                    break;
                case 2:
                    result[it_max] = "Silver Medal";
                    break;
                case 3:
                    result[it_max] = "Bronze Medal";
                    break;
                default:
                    result[it_max] = to_string(rank);
            } 
        }
        return result;
    }

public String getRank(int rank) {
    return switch (rank) {
        case 0 -> "Gold Medal";
        case 1 -> "Silver Medal";
        case 2 -> "Bronze Medal";
        default -> Integer.toString(rank + 1);
    };
}

public String[] findRelativeRanks(int[] score) {
    Map<Integer, Integer> map = new TreeMap<>(Collections.reverseOrder());
    for (int i = 0; i < score.length; i++) {
        map.put(score[i], i);
    }
    int rank = 0;
    String[] answer = new String[score.length];
    for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
        int index = entry.getValue();
        answer[index] = getRank(rank++);
    }
    return answer;
}

class Solution:
    def findRelativeRanks(self, score: List[int]) -> List[str]:
        max_score = max(score)
        score_to_index = [None] * (max_score+1)
        for i in range (0, len(score), 1):
            score_to_index[score[i]] = i
            
        result = [None] * len(score)
        place_to_string = ["", "Gold Medal","Silver Medal","Bronze Medal"]
        current_place = 1
        for i in range (max_score, -1, -1):
            if score_to_index[i] is not None:
                if current_place < 4:
                    result[score_to_index[i]] = place_to_string[current_place]
                else:
                    result[score_to_index[i]] = str(current_place)
                current_place += 1
            
        return result

class Solution {
    public String[] findRelativeRanks(int[] score) {
        Queue<Integer> queue = new PriorityQueue<>((o1, o2) -> score[o2] - score[o1]);
        for(int i = 0; i < score.length; i++) {
            queue.offer(i);
        }
        String[] title = {"Gold Medal", "Silver Medal", "Bronze Medal"};
        String[] res = new String[score.length];
        int rank = 0;
        while(!queue.isEmpty()){
            int position = queue.poll();
            switch(rank) {
                case 0:
                case 1:
                case 2:
                    res[position] = title[rank];
                    break;
                default:
                    res[position] = String.valueOf(rank + 1);
                    break;
            }
            rank++;
        }
        return res;
    }
}

class Solution {
    fun findRelativeRanks(score: IntArray): Array<String> {
        val ans = Array<String>(score.size) { "" }
        val sortedScoreMap = score.sortedDescending().mapIndexed { index, score ->
            Pair(score, index)
        }.associate {
            it
        }
        score.forEachIndexed { index, score ->
            val rankIndex = sortedScoreMap[score]!!
            val rankString = when (rankIndex) {
                0 -> "Gold Medal"
                1 -> "Silver Medal"
                2 -> "Bronze Medal"
                else -> "${rankIndex + 1}"
            }
            ans[index] = rankString
        }
        return ans
    }
}

class Solution {
    public String[] findRelativeRanks(int[] score) {
        String[] ans = new String[score.length];
        PriorityQueue<Integer> pq = new PriorityQueue<>((x, y) -> Integer.compare(score[y], score[x]));
        for(int i= 0;i<score.length;i++) {
            pq.add(i);
        }
        String[] medal = new String[]{"Bronze Medal","Silver Medal", "Gold Medal"};
        int i= medal.length;
        while(!pq.isEmpty() && i-->0 ){
            int index = pq.poll();
            ans[index] = medal[i];
        }
        i = 4;
        while(!pq.isEmpty()){
            int index = pq.poll();
            ans[index] = String.valueOf(i);
            i++;
        }
        return ans;
    }
}

class Solution {
public:
  vector<string> findRelativeRanks(vector<int> &score) {
    map<int, int> mapScore;
    vector<string> ans;
    ans.resize(score.size());
    for (int i = 0; i < score.size(); i++) {
      mapScore[score[i]] = i;
    }
    sort(score.begin(), score.end(), greater<int>());
    for (int i = 0; i < score.size(); i++) {
      if (i < 3) {
        switch (i) {
        case 0:
          ans.at(mapScore[score[i]]) = "Gold Medal";
          break;
        case 1:
          ans.at(mapScore[score[i]]) = "Silver Medal";
          break;
        case 2:
          ans.at(mapScore[score[i]]) = "Bronze Medal";
          break;
        }
      } else
        ans.at(mapScore[score[i]]) = to_string(i + 1);
    }
    return ans;
  }
};

class Solution:
    def findRelativeRanks(self, score: List[int]) -> List[str]:
        size = len(score)
        sorted_scores = sorted(score, reverse=True)
        map_result = {}
        for idx, value in enumerate(sorted_scores):
            map_result[value] = str(idx + 1)
        map_result[sorted_scores[0]] = "Gold Medal"
        if size > 1:
            map_result[sorted_scores[1]] = "Silver Medal"
        if size > 2:
            map_result[sorted_scores[2]] = "Bronze Medal"
        return [map_result[value] for value in score]

// Beat 36%
public String[] findRelativeRanks(int[] score) {
        Integer[] leaderBoard = IntStream.of(score).boxed().toArray(Integer[]::new);
        Arrays.sort(leaderBoard, Comparator.reverseOrder());

        Map<Integer, String> scoreMap = new HashMap<>();
        for (int i = 0; i < leaderBoard.length; i++) {
            if (i == 0) scoreMap.put(leaderBoard[i], "Gold Medal");
            else if (i == 1) scoreMap.put(leaderBoard[i], "Silver Medal");
            else if (i == 2) scoreMap.put(leaderBoard[i], "Bronze Medal");
            else scoreMap.put(leaderBoard[i], String.valueOf(i + 1));
        }

        String[] ans = new String[score.length];
        for (int i = 0; i < score.length; i++) {
            ans[i] = scoreMap.get(score[i]);
        }

        return ans;
    }

    // Beat 96%
    public String[] findRelativeRanks2(int[] score) {
        int n = score.length;
        int[] sortedScore = score.clone();
        Arrays.sort(sortedScore);
        String[] ranks = new String[n];

        for (int i = 0; i < n; i++) {
            int rank = Arrays.binarySearch(sortedScore, score[i]);
            if (rank == n - 1) {
                ranks[i] = "Gold Medal";
            } else if (rank == n - 2) {
                ranks[i] = "Silver Medal";
            } else if (rank == n - 3) {
                ranks[i] = "Bronze Medal";
            } else {
                ranks[i] = String.valueOf(n - rank);
            }
        }

        return ranks;
    }

def find_relative_ranks(score)
  sorted_arr = score.sort.reverse
  hash = {}
  medals = ["Gold Medal", "Silver Medal", "Bronze Medal"]

  sorted_arr.each.with_index do |x, i|
    if i <= 2
      hash[x] = medals[i]
    else
      hash[x] = (i + 1).to_s
    end
  end

  score.map {|i| hash[i]}
end