(Java)프로그래머스 - 실패율

나의 풀이

import java.util.*;

class Solution {
    public int[] solution(int N, int[] stages) {
        int[] answer = new int[N]; // 1
        HashMap<Integer, Float> map = new HashMap<>();
        float defaultValue = 0;
        
        for (int i = 1; i <= N; i++) { // 2
            map.put(i, defaultValue);
        }
        
        for (int i = 0; i < people; i++) { // 3
            for (int j = 1; j <= N; j++) {
                if (stages[i] == j) {
                    float temp = map.get(j) + 1;
                    map.put(j, temp);
                }
            }
        }
        
        int people = stages.length;
        
        for (int i = 1; i <= N; i++) { // 4
            float percent = 0;
            if (people > 0) percent = map.get(i) / (float)people;
            map.put(i, percent);
            people -= map.get(i);
        }
        
        List<Integer> list = new ArrayList<>(map.keySet()); // 5
        
        Collections.sort(list, (value1, value2) -> (map.get(value2).compareTo(map.get(value1))));
        
        int i = 0;
        
        for(int key : list) {
			answer[i++] = key;
		}
        
        return answer;
    }
}

과정

1. answer의 길이는 스테이지의 개수 N개이므로 크기를 N으로 지정 stages에 담겨있는 멈춰있는 스테이지를 저장할 HashMap함수를 만들어준다.
2. map에 기본값을 0으로 하고, N까지의 수 i를 key로 하는 값을 넣어준다
3. stages를 순회하며 멈춰있는 스테이지의 수를 map에 넣어준다
4. N까지의 스테이지를 순회하며 전체 사람의 수가 0 이상이면 전체 사람의 수와 i번째 스테이지에 멈춰있는 사람을 나눠주고, map에 넣는다. 이때 전체 사람의 수는 i번째 스테이지에 멈춰있는 사람을 빼고, 다시 설정해준다(i번째 스테이지에 멈춰있는 사람은 i + 1번째 스테이지에 도전하지 못했으므로)
5. map을 내림차순으로 정렬해주고, 나온 값을 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;
        }
    }
}