[Programmers] 프로그래머스 Lv.1 실패율 (JAVA)

728x90

링크 : https://school.programmers.co.kr/learn/courses/30/lessons/17681

📚 문제

🚫 제한사항

💡 아이디어

✅ 실패율 = (현재 X번 Stage를 도전하고 있는 사람 수) ÷ (X번 Stage를 도전했던, 도전 중인 사람 수)

다음과 같은 데이터가 예시로 주어졌다고 생각해 봅시다.

stages = [2, 1, 2, 6, 2, 4, 3, 3]

1번 Stage
- stages[1] = 1 → 1명이 현재 도전 중
- stages의 전체 요소 = 8명 → 1번 Stage를 도전 중이거나(1번 index), 이미 도전성공함(나머지 index)
  - ∴ 실패율 = 1 / 8
2번 Stage
- stages[0] = stages[2] = stages[4] = 2 → 3명이 현재 도전 중
- stages의 전체 요소 - 1번 Stage 도전 중인 사람 수 = 7명
  - ∴ 실패율 = 3 / 7

✅ HashMap 활용 : key(Stage), value(실패율)

이렇게 설정하면 value 값을 기준으로 정렬한 후, key값을 순서대로 출력하면 실패율이 높은 Stage부터 내림차순으로 정렬된 배열을 return하기 수월합니다.

✨ 잠깐, HashMap에서 value 기준으로 정렬은 어떻게 하는건지 궁금하신가요?


  
    
    
    
    
  
List<Integer> keySet = new ArrayList<>(map.keySet());
keySet.sort((o1, o2) -> map.get(o2).compareTo(map.get(o1)));

가장 먼저, map.keySet()을 활용하여 해당 HashMap의 key 요소들을 담은 ArrayList를 하나 생성해줍니다.
해당 keySet을 lambda를 사용하여 위와 같이 정렬하면 value 값이 높은 요소부터 내림차순으로 정렬할 수 있습니다.

👩🏻‍💻 Java 풀이


  
    
    
    
    
  
import java.util.*;
class Solution {
    public int[] solution(int N, int[] stages) {
        int[] cnt = new int[N];
        for(int i = 0; i < stages.length; i++) {
            if(stages[i] != N + 1) {
                cnt[stages[i] - 1]++;
            }
        }
        Map<Integer, Double> map = new HashMap<>();
        int num = stages.length;
        for(int i = 0; i < N; i++) {
            if(cnt[i] == 0 || num == 0) {
                map.put(i + 1, 0.0);
            } else {
                map.put(i + 1, (double)cnt[i] / num);
            }
            num -= cnt[i];
        }
        List<Integer> keySet = new ArrayList<>(map.keySet());
        keySet.sort((o1, o2) -> map.get(o2).compareTo(map.get(o1)));
        int[] answer = new int[N];
        for(int i = 0; i < N; i++) {
            answer[i] = keySet.get(i);
        }
        return answer;
    }
}

🎨 다른 풀이


  
    
    
    
    
  
import java.util.*;
class Solution {
    public int[] solution(int N, int[] stages) {
        int[] answer = new int[N];
        HashMap<Integer, Integer> map1 = new HashMap<>();
        HashMap<Integer, Double> map2 = new HashMap<>();
        for(int i = 0; i < stages.length; i++) {
            map1.put(stages[i], map1.getOrDefault(stages[i], 0) + 1);
        }
        double divide = stages.length;
        for(int i = 1; i <= N; i++) {
            if(map1.containsKey(i)) {
                map2.put(i, (double)(map1.get(i)) / divide);
                divide -= map1.get(i);
            } else {
                map2.put(i, 0.0);
            }
        }
        List<Integer> keySet = new ArrayList<>(map2.keySet());
        Collections.sort(keySet, (o1, o2) -> (map2.get(o2).compareTo(map2.get(o1))));
        for(int i = 0; i < N; i++) {
            answer[i] = keySet.get(i);
        }
        return answer;
    }
}


  
    
    
    
    
  
import java.util.*;
class Solution {
    public int[] solution(int N, int[] stages) {
        int[] answer = new int[N];
        HashMap<Integer, Integer> map1 = new HashMap<>();
        HashMap<Integer, Double> map2 = new HashMap<>();
        for(int i = 0; i < stages.length; i++) {
            map1.put(stages[i], map1.getOrDefault(stages[i], 0) + 1);
        }
        double divide = stages.length;
        for(int i = 1; i <= N; i++) {
            if(map1.containsKey(i)) {
                map2.put(i, (double)(map1.get(i)) / divide);
                divide -= map1.get(i);
            } else {
                map2.put(i, 0.0);
            }
        }
        List<Integer> keySet = new ArrayList<>(map2.keySet());
        Collections.sort(keySet, (o1, o2) -> (map2.get(o2).compareTo(map2.get(o1))));
        for(int i = 0; i < N; i++) {
            answer[i] = keySet.get(i);
        }
        return answer;
    }
}


  
    
    
    
    
  
import java.util.*;
class Solution {
    public int[] solution(int N, int[] stages) {
        int[] answer = new int[N];
        int user = stages.length;
        double[] failRate = new double[N];
        HashMap<Integer, Integer> fail = new HashMap<>();
		
        for (int i = 1; i <= N; i++) {
            fail.put(i, count(stages, i));
        }
        int idx = 0;
        for (Integer key : fail.keySet()) {
            failRate[idx++] = (double) fail.get(key) / user;
            if (user == fail.get(key))
                user = 1;
            else
                user -= fail.get(key);
        }
		
        Double[] temp = new Double[N];
        for (int i = 0; i < N; i++) {
            temp[i] = failRate[i];
        }
        Arrays.sort(temp, Collections.reverseOrder());
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                if (failRate[i] == temp[j]) {
                    if (answer[j] != 0)
                        continue;
                    answer[j] = i+1;    
                    break;
                }
            }
        }
        return answer;
    }
    
    public int count(int[] arr, int n) {
        int cnt = 0;
        for (int i : arr) {
            if (i == n)
                cnt++;
        }
        return cnt;
    }
}