[JAVA 문제 풀이] 292. 실패율

내가 작성한 코드

import java.util.*;

class Solution {
    public int[] solution(int N, int[] stages) {
        int[] answer = new int[N];
        int[] total = new int[N + 1]; // 각 스테이지 클리어 유저 수 담는 배열
        double[] failRate = new double[N + 1]; // 실패율 담는 배열
        int user = stages.length; // 전체 유저

        // 클리어한 유저 수 담기
        for (int i = 0; i < stages.length; i++) {
            total[stages[i] - 1]++;
        }

        // 각 스테이지별 실패율 계산
        for (int i = 0; i < N; i++) {
            if (total[i] == 0) {
                failRate[i] = 0;
            } else {
                failRate[i] = (double) total[i] / user;
                user -= total[i];
            }
        }

        double[] sort = Arrays.copyOf(failRate, failRate.length - 1); // 실패율 배열 정렬을 위한 배열
        Arrays.sort(sort); // 실패율 배열 정렬

        boolean[] used = new boolean[N]; // 이미 사용한 인덱스 체크

        for (int i = N - 1, idx = 0; i >= 0; i--) { // 내림차순이므로 뒤에서부터
            for (int j = 0; j < N; j++) {
                // 사용한 스테이지 번호가 아니고 정렬된 실패율의 원소와 원본 실패율 배열의 원소가 같으면
                if (!used[j] && failRate[j] == sort[i]) {
                    answer[idx++] = j + 1; // 스테이지 번호는 1부터 시작
                    used[j] = true;
                    break;
                }
            }
        }

        return answer;
    }

}

다른 사람의 코드

import java.util.*;

class Solution {
    public int[] solution(int N, int[] lastStages) {
        int nPlayers = lastStages.length; // 유저의 수
        int[] nStagePlayers = new int[N + 2]; // stage별 유저의 수
        // stage별 유저의 수 카운트
        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()); // 스테이지 정렬 >> Stage.compareTo 사용용

        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;
        }
    }
}