링크

자바 해쉬맵을 이용한 풀이

import java.util.*;

class Solution {
    public int[] solution(int N, int[] stages) {
        int[] answer = new int[N];
        Map<Integer, Integer> hash = new HashMap<>(); 
        int people = stages.length; 
        for(Integer in: stages){
            hash.put(in, hash.getOrDefault(in,0)+1);
        }  
        Map<Integer, Double> result = new HashMap<>();  
        for(int i=1; i<N+1;i++){  
            if(hash.get(i) != null){
                result.put(i, (Double)(hash.get(i) / (double)people)); 
                people -= hash.get(i); 
            }
            else{
                result.put(i, (Double)(0.0));
            }
        } 
        List<Integer> listKeySet = new ArrayList<>(result.keySet());
Collections.sort(listKeySet, (value1, value2) -> (result.get(value2).compareTo(result.get(value1))));
        int re = 0;
        for (Integer key : listKeySet){ 
            answer[re] = key;
            re += 1;
        } 
        return answer;
    }
}

자바 다른 풀이

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

class Solution {
    public int[] solution(int N, int[] lastStages) {
        int nPlayers = lastStages.length;
        int[] nStagePlayers = new int[N + 2];
        for (int stage : lastStages) {
            nStagePlayers[stage] += 1;
        }

        int remainingPlayers = nPlayers;
        List<Stage> stages = new ArrayList<>();
        for (int id = 1 ; id <= N; id++) {
            double failure = (double) nStagePlayers[id] / remainingPlayers;
            remainingPlayers -= nStagePlayers[id];

            Stage s = new Stage(id, failure);
            stages.add(s);
        }
        Collections.sort(stages, Collections.reverseOrder());

        int[] answer = new int[N];
        for (int i = 0; i < N; i++) {
            answer[i] = stages.get(i).id;
        }
        return answer;
    }

    class Stage implements Comparable<Stage> {
        public int id;
        public double failure;

        public Stage(int id_, double failure_) {
            id = id_;
            failure = failure_;
        }

        @Override
        public int compareTo(Stage o) {
            if (failure < o.failure ) {
                return -1;
            }
            if (failure > o.failure ) {
                return 1;
            }
            return 0;
        }
    }
}

자바 빠른거

class Solution {
    public int[] solution(int N, int[] stages) {
        int[] answer = new int[N];
        double[] tempArr = new double[N];
        int arrLength = stages.length;
        int idx = arrLength;
        double tempD = 0;
        int tempI = 0;
        for (int i = 0; i < arrLength; i++) {
            int stage = stages[i];
            if (stage != N + 1)
                answer[stage - 1] += 1;
        }
        for (int i = 0; i < N; i++) {
            int personNum = answer[i];
            tempArr[i] = (double) personNum / idx;
            idx -= personNum;
            answer[i] = i + 1;
        }

        for (int i = 0; i < N; i++) {
            for (int j = 1; j < N - i; j++) {
                if (tempArr[j - 1] < tempArr[j]) {
                    tempD = tempArr[j - 1];
                    tempArr[j - 1] = tempArr[j];
                    tempArr[j] = tempD;

                    tempI = answer[j - 1];
                    answer[j - 1] = answer[j];
                    answer[j] = tempI;
                }
            }
        }
        return answer;
    }
}

해쉬맵이 빠를줄 알았는데.. 그냥 리스트가 빨랐다.
정렬때문에 그런가

파이썬 첫번째

def solution(N, stages):
    answer = []
    fail = []
    info = [0] * (N + 2)
    for stage in stages:
        info[stage] += 1
    for i in range(N):
        be = sum(info[(i + 1):])
        yet = info[i + 1]
        if be == 0:
            fail.append((str(i + 1), 0))
        else:
            fail.append((str(i + 1), yet / be))
    for item in sorted(fail, key=lambda x: x[1], reverse=True):
        answer.append(int(item[0]))
    return answer

파이썬 두번째 짧은코드

def solution(N, stages):
    fail = {}
    for i in range(1,N+1):
        try:
            fail_ = len([a for a in stages if a==i])/len([a for a in stages if a>=i])
        except:
            fail_ = 0
        fail[i]=fail_
    answer = sorted(fail, key=fail.get, reverse=True)
    return answer

대신 시간이 매우 많이걸리니 쓰지 않는것

파이썬 세번째

from collections import Counter
from collections import deque

def solution(N, stages): 
    tmpAnswer = []

    sub = len(stages)
    result = Counter(stages)
    result = list(result.items())
    result.sort(key=lambda x: x[0])

    for data in result:
        currPosPlayer = data[1]
        if(data[0]== N+1):
            continue
        tmpAnswer.append([data[0], currPosPlayer / sub])
        sub -= currPosPlayer
 
    tmpAnswerDict = dict(tmpAnswer)
    dq = deque()

    for i in range(1, N + 1):
        data = tmpAnswerDict.get(i)
        if data == None:
            dq.append([i, 0])
            continue
        dq.append([i, data])
    resultAnswer = list(dq)

    resultAnswer.sort(key=lambda x: x[1], reverse=True)

    answer = []
    for i in range(N):
        answer.append(resultAnswer[i][0])
    return answer

Counter 써서 stages를 압축하여 시간을 단축하는 코드