Java 프로그래머스 - [2019 카카오] 실패율 Level1

실패율

슈퍼 게임 개발자 오렐리는 큰 고민에 빠졌다. 그녀가 만든 프랜즈 오천성이 대성공을 거뒀지만, 요즘 신규 사용자의 수가 급감한 것이다. 원인은 신규 사용자와 기존 사용자 사이에 스테이지 차이가 너무 큰 것이 문제였다.

이 문제를 어떻게 할까 고민 한 그녀는 동적으로 게임 시간을 늘려서 난이도를 조절하기로 했다. 역시 슈퍼 개발자라 대부분의 로직은 쉽게 구현했지만, 실패율을 구하는 부분에서 위기에 빠지고 말았다. 오렐리를 위해 실패율을 구하는 코드를 완성하라.

• 실패율은 다음과 같이 정의한다.
  • 스테이지에 도달했으나 아직 클리어하지 못한 플레이어의 수 / 스테이지에 도달한 플레이어 수

전체 스테이지의 개수 N, 게임을 이용하는 사용자가 현재 멈춰있는 스테이지의 번호가 담긴 배열 stages가 매개변수로 주어질 때, 실패율이 높은 스테이지부터 내림차순으로 스테이지의 번호가 담겨있는 배열을 return 하도록 solution 함수를 완성하라.

제한사항

• 스테이지의 개수 N은 1 이상 500 이하의 자연수이다.
• stages의 길이는 1 이상 200,000 이하이다.
• stages에는 1 이상 N + 1 이하의 자연수가 담겨있다.
  • 각 자연수는 사용자가 현재 도전 중인 스테이지의 번호를 나타낸다.
  • 단, N + 1 은 마지막 스테이지(N 번째 스테이지) 까지 클리어 한 사용자를 나타낸다.
• 만약 실패율이 같은 스테이지가 있다면 작은 번호의 스테이지가 먼저 오도록 하면 된다.
• 스테이지에 도달한 유저가 없는 경우 해당 스테이지의 실패율은 0 으로 정의한다.
•  

---

해결법

 

이 문제를 접근하기 위해 Map을 이용해서 value를 내림차순으로 정렬해서 풀어주었다.

하지만 처음에 푼 답은 처음에 ratio를 계산하는 과정에서 for문을 두번 돌아서 O(N^2)이였기 때문에 시간복잡도 차원에서는 잘 풀지 못했다.

먼저 처음에 푼 코드를 설명하겠다.

import java.util.*;
class Solution {
    public int[] solution(int N, int[] stages) {
        double ratio = 0.0;
        Map<Integer, Double> map = new HashMap<>();
        int[] answer=new int[N];

        for (int i = 1; i < N + 1; i++) {
            int cntPlay = 0;
            int cntFail = 0;
            for (int j = 0; j < stages.length; j++) {
                if (stages[j] >= i) {
                    if (stages[j] == i) {
                        cntFail++;
                    }
                    cntPlay++;
                }
            }
            if (cntPlay == 0) {
                cntPlay++;
            }
            ratio = (double) cntFail / cntPlay;
            map.put(i, ratio);
        }

        List<Integer> keySetList = new ArrayList<>(map.keySet());
        // 내림차순
        Collections.sort(keySetList, (o1, o2) -> (map.get(o2).compareTo(map.get(o1))));
        
        int count=0;
        for(Integer key: keySetList){
            answer[count++]=key;
        }
        
        return answer;
    }
}

 

map에 index, ratio를 저장해주었다. ratio를 Key로 사용하지 않은 이유는 ratio에 중복이 있기 때문이다.

따라서 List를 새로 생성해준 뒤에 compareTo를 사용하여 value를 내림차순으로 정렬해준다.

 

다른 사람 코드

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

 

실패율을 구할 때 시간복잡도를 많이 줄일 수 있다.

for (int stage : lastStages) {
            nStagePlayers[stage] += 1;
}

여기서 stage별로 +1을 해줌으로 각 스테이지별 사람을 구한다.

Stage를 따로 만들어서 넣어주면서 순서를 바꿔주는 것도 놀라운 풀이였다.

 

배울점이 있는 코드!