AlgorithmProgrammers

프로그래머스 실패율

, ,

1. 문제 링크

프로그래머스 실패율

2. 문제 조건

실패율은 다음과 같이 정의한다.

  • 스테이지에 도달했으나 아직 클리어하지 못한 플레이어의 수 / 스테이지에 도달한 플레이어 수

  • 제한사항

  • 스테이지의 개수 N은 1 이상 500 이하의 자연수이다.

  • stages의 길이는 1 이상 200,000 이하이다.

  • stages에는 1 이상 N + 1 이하의 자연수가 담겨있다.

    • 각 자연수는 사용자가 현재 도전 중인 스테이지의 번호를 나타낸다.
    • 단, N + 1 은 마지막 스테이지(N 번째 스테이지) 까지 클리어 한 사용자를 나타낸다.

  • 만약 실패율이 같은 스테이지가 있다면 작은 번호의 스테이지가 먼저 오도록 하면 된다.

  • 스테이지에 도달한 유저가 없는 경우 해당 스테이지의 실패율은 0 으로 정의한다.

3. 컴퓨팅 사고

  • 실패율과 해당스테이지를 저장시키기 위한 List를 선언하였다.
  • stages에 있는 값들을 Arrays.sort 로 선언하여 값들을 정렬해주었다. 그 이유는 스테이지가 [2, 1, 2, 6, 2, 4, 3, 3] 라고 가정하였을때 오름차순 정렬을 해주면 [1, 2, 2, 2, 3, 3, 4, 6]의 값이 나오므로 스테이지별 처리를 해줄 수 있다.

스테이지에 도달했지만 클리어 하지 못한 플레이어 수

스테이지에 도달했지만 클리어 하지 못한 플레이어 수를 체크 하였다. 스테이지별로 순회하는 값과 스테이지에 있는 값이 같을 경우 스테이지에 도달은 하였지만 클리어를 하지 못한 수이다.

스테이지에 도달한 플레이어 수

현재 스테이지를 순회하면서 그 값과 같거나 그 이상인 값은 스테이지에 도달한 플레이어 수 라고 생각할 수 있다.

스테이지에 도달했지만 클리어 하지 못한 수가 0일 경우

스테이지에 도달했지만 클리어 하지 못한 수가 0일 경우 실패율을 0으로 놓는다. 실패율 0의 값과 현재 스테이지를 리스트에 담아준다

스테이지에 도달했지만 클리어 하지 못한 수가 0이 아닐 경우

double type으로 스테이지 클리어한 수 / 스테이지에 도달한 수 를 리스트에 실패율과 현재 스테이지 값을 담아주었다.

Arrays.sort VS Collections.sort

Arrays.sort()는 Primitive Type이나 Object Type의 Array를 정렬할때 사용합니다. 그리고Collections.sort()는 Collection의 List를 정렬할 때 사용합니다.

기본적으로 둘 다 오름차순 정렬이고, 인자로서 Array 또는 List를 넣어주면 인자로 넘겨진 객체의 내용 자체가 바뀐다. 둘 다 static method이므로 Arrays나 Collections객체를 바로 호출한다.

공통점으로는 Arrays.sort(), Collections.sort() 모두 Comparator를 통한 커스터마이징을 지원합니다.

Collections.reverse()는 내림차순 정렬이 아닌, 리스트의 구성을 반대로 뒤집는 것이다.

내림차순 정렬로 바꾸려면 어떤 형식으로 리턴을 해주어야할까?

Collections.sort(arr,Comparator.reverseOrder());

다음과 같이 내림차순 정렬로 바꿔줄 수 있다. 이렇게 바꿔주는 형식아니면 직접 커스터마이징을 해줄 수 있다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
static class Pair implements Comparable<Pair>{
        double x;
        int y;

        Pair(double x, int y){
            this.x = x;
            this.y = y;

        }

        @Override
        public int compareTo(Pair arr2) {
            if(x == arr2.x)
            {
                if(y < arr2.y)
                {
                    return -1;
                }
                else
                {
                    return 1;
                }
            }
            else if(x > arr2.x)
            {
                return -1;
            }
            else
            {
                return 1;
            }
        }
    }

compareTo함수의 특징을 살펴보면

A와 B가 같으면 0을 반환, A가 B보다 크면 양수를 반환, A가 B보다 작으면 음수를 반환합니다.

  • 실패율이 높은 스테이지부터 내림차순으로 스테이지 번호 출력

내림차순으로 정렬된 상태이므로 리스트에 담겨있는 값중에서 (실패율, 스테이지번호) 스테이지번호값들을 출력시켜줍니다.

4. 소스 코드

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

import java.util.*;

public class 실패율 {
    static class Pair implements Comparable<Pair>{
        double x;
        int y;

        Pair(double x, int y){
            this.x = x;
            this.y = y;

        }

        /*
         * A와 B가 같으면 0을 반환
         * A가 B보다 크면 양수를 반환
         * A가 B보다 작으면 음수를 반환
         */
        @Override
        public int compareTo(Pair arr2) {
            if(x == arr2.x)
            {
                if(y < arr2.y)
                {
                    return -1;
                }
                else
                {
                    return 1;
                }
            }
            else if(x > arr2.x)
            {
                return -1;
            }
            else
            {
                return 1;
            }
        }
    }
    public static void main(String[] args) {
        int n = 5;
        int[] stages ={2, 1, 2, 6, 2, 4, 3, 3};

        List<Pair> arr = new ArrayList<Pair>();

        int stage_clear = 0;
        int stage_arrive = 0;
        int[] answer = {};
        Arrays.sort(stages);
        // 1stage ~ N stage
        for(int i=1; i<=n; i++) {
            stage_clear = 0;
            stage_arrive = 0;
            for (int j = 0; j < stages.length; j++) {

                // 스테이지 도달했지만 클리어하지 못한 플레이어 수
                if (stages[j] == i) {
                    stage_clear++;
                }
                // 스테이지에 도달한 플레이어수
                if (stages[j] >= i) {
                    stage_arrive++;
                }

            }
                        // 스테이지 도달했지만 클리어하지 못한 플레이어수 가 0일 경우 실패율 = 0
            if (stage_clear == 0) {
                arr.add(new Pair(0, i));
            } else {
                arr.add(new Pair((double) stage_clear / stage_arrive, i));
            }
        }
                // 실패율이 높은 순서대로 내림 차순 정렬
        Collections.sort(arr);
        //Arrays.sort(arr, Comparator.reverseOrder());
        answer = new int[n];
        for(int i=0; i<arr.size(); i++){
            Pair p = arr.get(i);
            answer[i] = arr.get(i).y; // 스테이지 번호 넣기
            System.out.println(answer[i]);
        }
    }
}
Share