[programmers] 실패율

package programers;

import java.util.Arrays;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Stack;
import java.util.TreeMap;
import java.util.stream.Collectors;

public class Kakao5chunsung {


//
//
//    실패율은 다음과 같이 정의한다.
//    스테이지에 도달했으나 아직 클리어하지 못한 플레이어의 수 / 스테이지에 도달한 플레이어 수
//    전체 스테이지의 개수 N, 게임을 이용하는 사용자가 현재 멈춰있는 스테이지의 번호가 담긴 배열 stages가 매개변수로 주어질 때, 실패율이 높은 스테이지부터 내림차순으로 스테이지의 번호가 담겨있는 배열을 return 하도록 solution 함수를 완성하라.
//
//    제한사항
//    스테이지의 개수 N은 1 이상 500 이하의 자연수이다.
//    stages의 길이는 1 이상 200,000 이하이다.
//            stages에는 1 이상 N + 1 이하의 자연수가 담겨있다.
//    각 자연수는 사용자가 현재 도전 중인 스테이지의 번호를 나타낸다.
//            단, N + 1 은 마지막 스테이지(N 번째 스테이지) 까지 클리어 한 사용자를 나타낸다.
//    만약 실패율이 같은 스테이지가 있다면 작은 번호의 스테이지가 먼저 오도록 하면 된다.
//    스테이지에 도달한 유저가 없는 경우 해당 스테이지의 실패율은 0 으로 정의한다.
//    입출력 예
//    N    stages result
//5    [2, 1, 2, 6, 2, 4, 3, 3]   [3,4,2,1,5]
//        4    [4,4,4,4,4]    [4,1,2,3]
//    입출력 예 설명
//    입출력 예 #1
//            1번 스테이지에는 총 8명의 사용자가 도전했으며, 이 중 1명의 사용자가 아직 클리어하지 못했다. 따라서 1번 스테이지의 실패율은 다음과 같다.
//
//1 번 스테이지 실패율 : 1/8
//            2번 스테이지에는 총 7명의 사용자가 도전했으며, 이 중 3명의 사용자가 아직 클리어하지 못했다. 따라서 2번 스테이지의 실패율은 다음과 같다.
//
//2 번 스테이지 실패율 : 3/7
//    마찬가지로 나머지 스테이지의 실패율은 다음과 같다.
//
//            3 번 스테이지 실패율 : 2/4
//            4번 스테이지 실패율 : 1/2
//            5번 스테이지 실패율 : 0/1
//    각 스테이지의 번호를 실패율의 내림차순으로 정렬하면 다음과 같다.
//
//            [3,4,2,1,5]
//    입출력 예 #2
//
//    모든 사용자가 마지막 스테이지에 있으므로 4번 스테이지의 실패율은 1이며 나머지 스테이지의 실패율은 0이다.
//
//[4,1,2,3]


    public static void main(String[] args) {

//        int N = 5;
//        int[] stages = new int[]{2, 1, 2, 6, 2, 4, 3, 3};

                int N = 4;
        int[] stages = new int[]{4,4,4,4,4};


        int[] ret = solution(N, stages);
        Arrays.stream(ret).forEach(x -> System.out.println(x));
    }


    static class UserComparator implements Comparator<Object> {
        Map<Integer, Integer> map;
        public UserComparator(Map<Integer, Integer> map) {
            this.map = map;
        }
        public int compare(Object o1, Object o2) {
            if (map.get(o2) == map.get(o1))
                return 1;
            else
//                return ((Integer) map.get(o1)).compareTo((Integer)
//                        map.get(o2));

            return ((Integer) map.get(o2)).compareTo((Integer)
                    map.get(o1));
        }
    }

    public static int[] solution(int N, int[] stages) {
//        int[] answer = {};

        Map<Integer, Integer> failMap = new TreeMap<>();

        Map<Integer, Integer> map = new HashMap<>();
        Stack<Integer> stack = new Stack<>();

        for (int i = 0; i < stages.length; i++) {
            stack.push(stages[i]);
        }
        while (stack.size() > 0) {
            int stg = stack.pop();
            for (int j = 1; j < N + 1; j++) {
                if (stg == j) {
                    map.put(stg, map.getOrDefault(stg, 0) + 1);
                    break;
                }
                if (stg == N + 1) {
                    map.put(N, map.getOrDefault(stg, 0) + 0);
                    break;
                }
            }
        }


        int user = stages.length;
        for (int i = 1; i < N + 1; i++) {
            int rate = (int) Math.floor(((double) map.get(i) / user) * 100);

//            System.out.println(rate);
            failMap.put(i, rate);
            user = user - map.get(i);
        }


        UserComparator comparator = new UserComparator(failMap);
        Map<Integer, Integer> result = new TreeMap<Integer, Integer>(comparator);
        result.putAll(map);

        result.keySet().stream().forEach(x-> System.out.println(x));


        int[] answer = new int[result.size()];


        int i =0;
        for(int k : result.keySet()) {
            answer[i] = k;
            i++;
        }






//        result.forEach((k,v)->System.out.println(k+"="+v));


//
//        map.entrySet().stream()
//                .sorted(Map.Entry.comparingByValue()).forEach(x-> System.out.println(x.getValue()));




        System.out.println("-------");


//        for (int i = 0; i < stages.length; i++) {
//
//
//
//            for (int j = 1; j < N +1 ; j++){
//
//                if(stages[i] == j){
//                    map.put(j, map.getOrDefault(j, 0) + 1);
//                    break;
//                }
//                if(stages[i] == N +1){
//                    map.put(j, N);
//                    break;
//                }
//
//            }
//
//            System.out.println("----");
//        }


//        for (int i = 0; i < stages.length; i++) {
//            for (int j = 1; j < N + 1; j++) {
//                if (stages[i] == j) {
//                    map.put(j, map.getOrDefault(j, 0) + 1);
//                    continue;
//                }
//
//                if (stages[i] == N + 1) {
//                    map.put(j, N);
//                    continue;
//                }
//            }
//        }


//        System.out.println(user[0]);

//        Arrays.stream(user).forEach(x-> System.out.println(x));


        return answer;
    }


}