[프로그래머스/JavaScript] Lv1. 실패율

프로그래머스

 

 

function solution(N, stages) {
    const player = stages.length;
    const fail = [];
    const stageCount = new Array(N).fill(0);
    let currentPlayer = 0;
    
    stages.map(num => num <= N ? stageCount[num-1]++ : 0);
    
    for (let i = 0; i < N; i++) {
    const remainingPlayers = player - currentPlayer;
    
    if (remainingPlayers > 0) {
        fail.push(stageCount[i] / remainingPlayers);
    } else {
            fail.push(0);  // 남은 플레이어가 없으면 실패율은 0
    }
        
    currentPlayer += stageCount[i];
}
    
   const result = fail
   .map((value, index) => [value, index + 1])  // [값, 인덱스+1] 형태로 변환
   .sort((a, b) => b[0] - a[0] || a[1] - b[1]);  // 값 기준 내림차순, 인덱스 기준 오름차순

    // 인덱스만 추출하여 반환
    return result.map(item => item[1]);
}

// 1. 현재 멈춰있는 스테이지 번호 배열 정렬
//    [1, 2, 2, 2, 3, 3, 4, 6] -> 8명
// 2. 1번 스테이지 실패율 = 1/8
//    2번 스테이지 실패율 = 3/7
//    3번 스테이지 실패율 = 2/4
//    같은 번호 개수 / 전체 플레이어 - 현재 번호보다 작은 번호들의 개수
// 3. result 배열의 길이 = N

 

1. 먼저 현재 멈춰있는 스테이지 번호 배열에서 같은 스테이지의 개수를 체크해 줬다.

 

2. 남은 플레이어가 있다면, 실패율 = 같은 스테이지 수 / 남은 플레이어 수

    남은 플레이어가 없다면, 실패율 = 0

    현재 플레이어 수는 += stageCount[i]; 로 계속 더해준다.

 

3. 결과는 [값, 인덱스+1] 형태로 저장하고 내림차순, 값이 같을 경우엔 오름차순으로 변환한다.

 

4. 설정한 인덱스+1 값만 반환한다.

 

---

다른 사람 코드 1

 

function solution(N, stages) {
    const challenger = new Array(N+2).fill(0);
    for(const stage of stages){
    	challenger[stage] += 1;
    }
    
    const fails = {};
    let total = stages.length;
    
    for(let i = 1; i <= N; i++){
    	if(challenger[i] === 0){
            fails[i] = 0;
            continue;
        }
        
        fails[i] = challenger[i] / total;
        
        total -= challenger[i];
    }
    
    const result = Object.entries(fails).sort((a,b) => b[1] - a[1]);
    
    return result.map((v) => Number(v[0]));
}

 

1. 스테이지와 인덱스를 맞추기 위해 (인덱스 1부터 사용) challenger 배열의 크기를 여유롭게 설정

 

2. 실패율을 객체로 저장

    챌린저가 없으면 실패율 = 0 

    분모의 스테이지 도달 사용자 수 = 전체 - 현재 이전의 챌린저 수 

    예시 - { '1': 0.125, '2': 0.4, '3': 0.5, '4': 0.5, '5': 0 }

 

3. Object.entries로 키와 값을 묶어 배열로 변환 후 내림차순 정렬

    예시 - [[ '3', 0.5 ], [ '4', 0.5 ], [ '2', 0.4 ], [ '1', 0.125 ], [ '5', 0 ]]

    이때, fails가 이미 인덱스 순으로 저장되었기 때문에 sort((a,b) => b[1] - a[1])만 해도 

    실패율이 같을 경우 작은 인덱스부터 정렬된다.

 

4. 키 값만 반환하면 되므로 Number(v[0])으로 리턴

 

---

다른 사람 코드 2

 

function solution(N, stages) {
    let result = [];
    for(let i=1; i<=N; i++){
        let reach = stages.filter((x) => x >= i).length;
        let curr = stages.filter((x) => x === i).length;
        result.push([i, curr/reach]);
    }
    result.sort((a,b) => b[1] - a[1]);
    return result.map((x) => x[0]);
}

 

1. 스테이지 수만큼 순회

   분모의 reach = 현재 스테이지 이상에 도달한 플레이어 수 (i 이상 요소의 길이)

   분자의 curr = 현재 스테이지에 도달한 플레이어 수 (i 요소의 길이)

   result에 [스테이지 번호, 실패율] 형식으로 저장

 

2. result 내림차순 후 스테이지 번호만 반환

 

* N만큼 도는 for문 내부에 filter 함수가 있어 성능 이슈가 있을 수 있음