2019 KAKAO BLIND RECRUITMENT > 실패율

https://school.programmers.co.kr/learn/courses/30/lessons/42889

프로그래머스

 

 

- 나의 풀이

✅ key : value 해시맵 ➡︎ <스테이지 : 실패율> failMap

HashMap<Integer, Double> failMap = new HashMap<>();

 

✅ 스테이지별 실패율 = 해당 스테이지에 도달한 플레이어 수 / 해당 스테이지를 클리어하지 못한 플레이어 수

• 해당 스테이지에 도달한 플레이어 수 ➡︎ players
• 해당 스테이지를 클리어하지 못한 플레이어 수 ➡︎ failPlayers

🚨 double 을 사용해야 실패율 계산 가능

 

✅ 스테이지에 도달한 플레이어가 없으면 실패율 0

이때, players와 failPlayers가 모두 0 이므로 실패율 = 0/0 ➡︎ java.lang.ArithmeticException: / by zero 에러발생

따라서 분모인 players를 1로 바꿔줌으로 실패율 0 처리

 

✅ failMap의 value인 실패율을 내림차순으로 key인 스테이지 정렬

+ 실패율이 같다면, 스테이지는 오름차순 정렬

• public Set<K> keySet() ➡︎ map의 key들을 Set 형태로 리턴
• public Collection<V> values() ➡︎ map의 value들을 Collection 형태로 리턴

HashMap<String, Integer> map = new HashMap<>();

map.put("apple", 1);
map.put("banana", 2);
map.put("orange", 3);

System.out.println("map : " + map);
System.out.println("keySet : " + map.keySet());
System.out.println("values : " + map.values());

위 예시의 결과

 

✅ 정렬된 스테이지는 failMap에서 삭제 ➡︎ 실패율이 제일 높은 스테이지의 중복 확인을 막기 위해

map.remove(key) ➡︎ failMap.remove(stageNum);

내림차순 정렬되어 answer 에 추가한 스테이지를 failMap에서 삭제하지 않을 시, 발생하는 중복 확인 결과

 

 

 - 나의 코드

import java.util.*;

class Solution {
    public int[] solution(int N, int[] stages) {
        int[] answer = new int[N];
        
        //해시맵<스테이지:실패율>
        HashMap<Integer, Double> failMap = new HashMap<>();
        
        for(int i=1; i<=N; i++) {
            //도달한 플레이어 수
            double players = 0;
            //아직 클리어하지 못한 플레이어 수
            double failPlayers = 0;
            
            for(int j=0; j<stages.length; j++) {
                //i <= 현재 있는 스테이지 j , i에 도달
                //i == 현재 있는 스테이지 j , i에서 실패
                if(i <= stages[j]) {
                    players++;
                }
                
                if(i == stages[j]) {
                    failPlayers++;
                }
            }
            
            //스테이지에 도달한 플레이어 없으면 실패율 0
            if(players == 0) {
                players = 1;
            }
            
            failMap.put(i, failPlayers/players);
        }    
        
        //실패율 내림차순으로 정렬
        for(int i=0; i<N; i++) {
            double maxFail = -1;
            int stageNum = -1;
            
            for(int key : failMap.keySet()) {
                if(maxFail < failMap.get(key)) {
                    maxFail = failMap.get(key);
                    stageNum = key;
                }
            }
            
            answer[i] = stageNum;
            
            //해당 스테이지 키 삭제
            failMap.remove(stageNum);
        }
        
        return answer;
    }
}

 

+

 

✅ StageFailRate 클래스 생성 ➡︎ 스테이지, 실패율 모두 가진 리스트를 정렬하기 위함

 

✅ list.sort 활용하여 정렬

 

- 다른 풀이 방식

import java.util.HashMap;
import java.util.ArrayList;

class Solution {
    public int[] solution(int N, int[] stages) {
        //StageFailRate 객체를 저장하는 ArrayList : stageList
        ArrayList<StageFailRate> stageList = new ArrayList<>();
        
        for(int i=1; i<=N; i++) {
            //스테이지에 도달한 플레이어 수
            double player = 0;
            //스테이지에 도달했으나 아직 클리어하지 못한 플레이어의 수
            double failPlayer = 0;
            
            for(int j=0; j<stages.length; j++) {
                if(i <= stages[j]) {
                    player++;
                }
                
                if(i == stages[j]) {
                    failPlayer++;
                }
            }
            
            //스테이지에 도달한 유저가 없는 경우, 실패율 0
            if(player == 0) {
                player = 1;
            }
            
            //stageList(스테이지, 실패율) 삽입
            stageList.add(new StageFailRate(i,failPlayer/player));
        }
        //System.out.println(stageList.toString());
        
        //실패율 내림차순 정렬
        //실패율이 같으면 스테이지 오름차순 정렬
        stageList.sort((stage1, stage2) -> {
            if(stage1.failRate > stage2.failRate) {
                return -1;
            } else if(stage1.failRate == stage2.failRate) {
                if(stage1.stage > stage2.stage) {
                    return 1;
                } else {
                    return -1;
                }
            } else {
                return 1;
            }
        });
        
        int[] answer = new int[stageList.size()];
        
        //answer에 정렬된 stageList 스테이지 값 넣기
        for(int i=0; i<stageList.size(); i++) {
            
            StageFailRate stageNum = stageList.get(i);
            answer[i] = stageNum.stage;
        }
        
        return answer;
    }
    
    //StageFailRate 클래스 생성 - 스테이지, 실패율 모두 가진 리스트를 정렬하기 위함
    class StageFailRate {
        int stage;
        double failRate;
        
        StageFailRate(int stage, double failRate) {
            this.stage = stage;
            this.failRate = failRate;
        }
        
        //toString 메서드 추가
        @Override
        public String toString() {
            return "Stage: " + stage + " , Fail Rate: " + failRate;
        }
    }
}

 

🚨 오류 ➡︎ stageList.add(i,failPlayer/player);

error: incompatible types: double cannot be converted to Solution.StageFailRate

 

해당 내용 ChatGPT 이용하여 검색 후 수정

🚨 수정 ➡︎ stageList.add(new StageFailRate(i,failPlayer/player)); 

stageList는 StageFailRate 객체를 저장하는 ArrayList 이므로, double 값을 직접 추가할 수 없습니다.
대신 StageFailRate 객체를 생성해서 리스트에 추가해야 합니다.

stageList.add(new StageFailRate(i,failPlayer/player)); 

이렇게 하면 StageFailRate 객체를 생성하여 stageList에 추가하게 되므로 타입 불일치 에러가 해결됩니다.