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

vector<string> findRelativeRanks(vector<int>& score) {
  int n = score.size();
  vector<int> index(n);
  iota(index.begin(), index.end(), 0);
  sort(index.begin(), index.end(), [&score](int a, int b) {
    return score[a] > score[b];
  });
 
  vector<string> ret(n);    
  for(int i = 0; i < n; ++i) {
    if (i == 0) ret[index[0]] = "Gold Medal";
    else if (i == 1) ret[index[1]] = "Silver Medal";
    else if (i == 2) ret[index[2]] = "Bronze Medal";
    else ret[index[i]] = to_string(i+1);
  }
  return ret;
}

vector<string> findRelativeRanks(vector<int>& score) {
  int n = score.size();
  priority_queue<pair<int, int>> q;
  for(int i = 0; i < n; ++i)
    q.push(make_pair(score[i], i));
 
  vector<string> ret(n);     
  for(int i = 0; i < n; ++i) {
    int idx = q.top().second; q.pop();
    if (i == 0) ret[idx] = "Gold Medal";
    else if (i == 1) ret[idx] = "Silver Medal";
    else if (i == 2) ret[idx] = "Bronze Medal";
    else ret[idx] = to_string(i+1);
  }
  return ret;
}

class Solution:
    def findRelativeRanks(self, score: List[int]) -> List[str]:
        score2 = score.copy()
        heapq._heapify_max(score2)
        # print(score2)
        s = []
        i = 0
        dic = {}
        while score2:
            num = heapq._heappop_max(score2)
            if i == 0:
                dic[num] = "Gold Medal"
            elif i == 1:
                dic[num] = "Silver Medal"
            elif i == 2:
                dic[num] = "Bronze Medal"
            else:
                dic[num] = str(i+1)
            i += 1
        for i in range(len(score)):
            score[i] = dic[score[i]]
        return score

class Solution:
    def findRelativeRanks(self, score: List[int]) -> List[str]:
        s = []
        for i in range(len(score)):
            s.append((score[i] , i))

        s.sort(reverse=True)
        mp = {}
        for i , [sc , idx] in enumerate(s):
            if i == 0: mp[idx] = "Gold Medal"
            elif i == 1: mp[idx] = "Silver Medal"
            elif i == 2: mp[idx] = "Bronze Medal"
            else: mp[idx] = str(i + 1)

        res = []
        for i , val in enumerate(score):
            res.append(mp[i])
        
        return res

public class Solution {
    public string[] FindRelativeRanks(int[] score) {
        List<KeyValuePair<int, int>> sortScore = new List<KeyValuePair<int,int>>();
        for(int j = 0; j < score.Length; j++)
        {
            sortScore.Add(new KeyValuePair<int,int>(j, score[j]));
        }
        sortScore.Sort(new Comparison<KeyValuePair<int, int>>(
                (i1, i2) => i2.Value.CompareTo(i1.Value)));
        string[] rank = new string[score.Length];
        int i=0;
        while(i<rank.Length)
        {
            if(i==0)
                rank[sortScore[i].Key] = "Gold Medal";
            else if(i==1)
                rank[sortScore[i].Key] = "Silver Medal";
            else if(i==2)
                rank[sortScore[i].Key] = "Bronze Medal";
            else
                rank[sortScore[i].Key] = (i+1).ToString();
            i++;
        }
        return rank;
    }
}

class Solution:
    def findRelativeRanks(self, score: List[int]) -> List[str]:
        d = {}
        next_athlete = len(score)
        result = [""]*next_athlete
        for s in range(next_athlete):
            d[s] = score[s]
        new_dict = dict(sorted(d.items(), key=lambda x:x[1]))
        for d in new_dict:
            if next_athlete == 1:
                result[d]="Gold Medal"
            elif next_athlete == 2:
                result[d]="Silver Medal"
            elif next_athlete == 3:
                result[d]="Bronze Medal"
            else:
                result[d]=str(next_athlete)
            next_athlete-=1
        return result

public class Solution {
    public string[] FindRelativeRanks(int[] score) {
        string [] answer = new string[score.Length];
        Dictionary <int,string> top = new Dictionary<int,string>{
                {0, "Gold Medal"},
                {1, "Silver Medal"},
                {2, "Bronze Medal"}
        };
        Dictionary <int,int> scoreAndID = new Dictionary<int,int>();
        for(int i =0;i<score.Length;i++){
            scoreAndID.Add(i, score[i]);
        }
        List<KeyValuePair<int, int>> myList = scoreAndID.ToList();
        myList.Sort((pair1,pair2) => pair1.Value.CompareTo(pair2.Value));
        int rank = score.Length;
        int counter  =0;
        foreach(KeyValuePair<int, int> entry in myList){
            if(rank - 1 >= 3){
                answer[entry.Key] = $"{rank}";
            }else {
                answer[entry.Key] = top[rank - 1];
            }
            rank -= 1;
        }
        return answer;
    }
}

class Solution {
public:
    vector<string> findRelativeRanks(vector<int>& score) {
        vector<pair<int,int>> vp;
        for(int i=0;i<score.size();++i)
        {
            vp.push_back(make_pair(score[i],i));
        }
        sort(vp.rbegin(),vp.rend());
        vector<string> vRe(score.size(),"");
        if(vp.size()>=1) vRe[vp[0].second] = "Gold Medal";
        if(vp.size()>=2) vRe[vp[1].second] = "Silver Medal";
        if(vp.size()>=3) vRe[vp[2].second] = "Bronze Medal";
        for(auto i=3;i<vp.size();++i)
        {
            vRe[vp[i].second] = to_string(i+1);
        }
        return vRe;
    }
};

class Solution {
    public long maximumHappinessSum(int[] happiness, int k) {
        PriorityQueue<Integer> maxHeap = new PriorityQueue<>(Collections.reverseOrder());

        int decrement = 0;
        long ans = 0;

        for (int h: happiness) {
            maxHeap.offer(h);
        }

        while (decrement > - k) {
            ans += Math.max(0, maxHeap.poll() + decrement);
            decrement--;
        }

        return ans;
    }
}

class Solution:
    def maximumHappinessSum(self, happiness: List[int], k: int) -> int:
        decrease = 0
        maxHeap = []
        total = 0
        for item in happiness:
            heapq.heappush(maxHeap, (-item, item))
        
        while k:
            _, item = heappop(maxHeap)
            total += max(item - decrease, 0)
            decrease += 1
            k -= 1
            
        return total

class Solution {
public:
    long long maximumHappinessSum(vector<int>& happiness, int k) {
        sort(happiness.begin(), happiness.end(), greater<int>());
        long long result = 0;
        long long decrease = 0;
        int count = 0;
        for(long long i=0;i<happiness.size();i++){
            if(count == k) break;
            if(result + happiness[i] - decrease >= result){
                result += happiness[i] - decrease;
            }
            decrease++;
            count++;
        }
        return result;
    }
};

class Solution:
    def maximumHappinessSum(self, happiness: List[int], k: int) -> int:
        # turn = 0
        # heapq._heapify_max(happiness)
        # result = 0

        # while k > 0:
        #     pick = heapq._heappop_max(happiness)
        #     result += max(0, pick - turn)
        #     turn += 1
        #     k -= 1
        happiness.sort(reverse = True)
        turn, result = 0, 0
        while k > 0:
            if happiness[turn] - turn > 0:
                result += happiness[turn] - turn
            else:
                break
            k -= 1
            turn += 1
        return result

    long long maximumHappinessSum(vector<int>& happiness, int k) {
        priority_queue<int> q {happiness.begin(), happiness.end()};
        long long ret = 0;
        for(int i = 0; i < k; ++i) {
            int h = q.top(); q.pop();
            ret += max(h - i, 0);
        }
        return ret;
    }

class Solution {
public:
    long long maximumHappinessSum(vector<int>& happiness, int k) {
        sort(happiness.rbegin(), happiness.rend());
        long long sum = 0;
        for(int i = 0; i < k; ++i) {
            int h = happiness[i] -i;
            if (h <= 0) return sum;
            sum += h;
        }
        return sum;
    }
};

class Solution {
public:
    long long maximumHappinessSum(vector<int>& happiness, int k) {
        sort(happiness.begin(),happiness.end());
        long long sum=0;
        long long idex = 0;
        long long n =happiness.size();
        for(auto i=0;i<k;++i)
        {
            if(happiness[n-1-i] <= i) break;
            sum += (happiness[n-1-i] - i);
        }
        return sum;
    }
};

var maximumHappinessSum = function(happiness, k) {
    happiness.sort((a, b) => b - a);

    let res = 0;
    let decr = 0;
    for (let i = 0; i < k; i++) {
        res += (happiness[i] >= decr ? happiness[i] - decr : 0);
        decr++;
    }

    return res;
};

class Solution {
    public long maximumHappinessSum(int[] happiness, int k) {
        long res = 0;
        int i = 0;
        PriorityQueue<Integer> priorityQueue = new PriorityQueue<>((a, b) -> b - a);
        for (int happy : happiness) {
            priorityQueue.offer(happy);
        }
        while (k > 0) {
            int value = priorityQueue.poll() - i;
            if (value < 0) {
                value = 0;
            }
            res += value;
            i++;
            k--;
        }
        return res;
    }
}

function maximumHappinessSum(happiness: number[], k: number): number {
    happiness.sort((a,b) => a-b);
    let c = 0, res = 0;
    while(k) {
        const item = happiness.pop();
        if (item <= c) break;
        res+= item - c, c++, k--;
    }
    return res;
};