[프로그래머스] Lv1. 실패율

중첩 for문 안 쓰고 싶었는데 이게 제일 깔끔하고 쉬웠음 ㅠ

stage 총 이용자 수를 stage.length로 잡고 다음단계로 못 간 이용자를 제외시키면서 진행하는 걸 생각해내는데 어려움이 있었음..

 

연습해 본것

이중배열을 stream을 이용해 정렬하기

sorted( Comparator ) : 스트림의 요소를 정렬하는 데 사용됨

reversed() : 정렬 순서 뒤집기

Double[][] sortedArray = Arrays.stream(failRate)
                                .sorted(Comparator.comparingDouble((Double[] a) -> a[1]).reversed())
                                .toArray(Double[][]::new);

Comparator.naturalOrder() : 자연 정렬

Comparator.reverseOrder() : 역순 정렬

Comparator.nullsFirst(Comparator.naturalOrder()) : null을 맨 앞에 두고 정렬

Comparator.comparingInt(String::length) : 길이에 따라 정렬

 

import java.util.*;
import java.util.stream.*;

class Solution {
    public int[] solution(int N, int[] stages) {
        Double[][] failRate = new Double[N][2];
        int totalPlayers = stages.length; 
        
        for(int stage = 1; stage <= N ; stage++){
            int challengers = 0; //해당 스테이지의 이용자 수
            for(int s : stages){
                if(s == stage){
                    challengers += 1;
                }
            }
            
            failRate[stage-1][0] = (double) stage;
            //실패율 = challengers / totalPlayers;
            if(totalPlayers == 0){
                failRate[stage-1][1] = 0.0;
            }else{
                failRate[stage-1][1] = (double)challengers / (double)totalPlayers;
            }        
            
            //다음 단계로 못 간 이용자 제외
            totalPlayers -= challengers;
        }
        
        Double[][] sortedArray = Arrays.stream(failRate)
                                .sorted(Comparator.comparingDouble((Double[] a) -> a[1]).reversed())
                                .toArray(Double[][]::new);

        
        int[] answer = new int[N];
        for(int i=0; i<sortedArray.length; i++){
            answer[i] = sortedArray[i][0].intValue();
        }

        return answer;
    }
}