[프로그래머스_위클리 챌린지 6주차] 복서 정렬하기

문제

문제 설명

복서 선수들의 몸무게 weights와, 복서 선수들의 전적을 나타내는 head2head가 매개변수로 주어집니다. 복서 선수들의 번호를 다음과 같은 순서로 정렬한 후 return 하도록 solution 함수를 완성해주세요.

1. 전체 승률이 높은 복서의 번호가 앞쪽으로 갑니다. 아직 다른 복서랑 붙어본 적이 없는 복서의 승률은 0%로 취급합니다.
2. 승률이 동일한 복서의 번호들 중에서는 자신보다 몸무게가 무거운 복서를 이긴 횟수가 많은 복서의 번호가 앞쪽으로 갑니다.
3. 자신보다 무거운 복서를 이긴 횟수까지 동일한 복서의 번호들 중에서는 자기 몸무게가 무거운 복서의 번호가 앞쪽으로 갑니다.
4. 자기 몸무게까지 동일한 복서의 번호들 중에서는 작은 번호가 앞쪽으로 갑니다.

---

제한사항

• weights의 길이는 2 이상 1,000 이하입니다.
  • weights의 모든 값은 45 이상 150 이하의 정수입니다.
  • weights[i] 는 i+1번 복서의 몸무게(kg)를 의미합니다.
• head2head의 길이는 weights의 길이와 같습니다.
  • head2head의 모든 문자열은 길이가 weights의 길이와 동일하며, 'N', 'W', 'L'로 이루어진 문자열입니다.
  • head2head[i] 는 i+1번 복서의 전적을 의미하며, head2head[i][j]는 i+1번 복서와 j+1번 복서의 매치 결과를 의미합니다.
    • 'N' (None)은 두 복서가 아직 붙어본 적이 없음을 의미합니다.
    • 'W' (Win)는 i+1번 복서가 j+1번 복서를 이겼음을 의미합니다.
    • 'L' (Lose)는 i+1번 복사가 j+1번 복서에게 졌음을 의미합니다.
  • 임의의 i에 대해서 head2head[i][i] 는 항상 'N'입니다. 자기 자신과 싸울 수는 없기 때문입니다.
  • 임의의 i, j에 대해서 head2head[i][j] = 'W' 이면, head2head[j][i] = 'L'입니다.
  • 임의의 i, j에 대해서 head2head[i][j] = 'L' 이면, head2head[j][i] = 'W'입니다.
  • 임의의 i, j에 대해서 head2head[i][j] = 'N' 이면, head2head[j][i] = 'N'입니다.

---

입출력 예

weightshead2headresult

[50,82,75,120]	["NLWL","WNLL","LWNW","WWLN"]	[3,4,1,2]
[145,92,86]	["NLW","WNL","LWN"]	[2,3,1]
[60,70,60]	["NNN","NNN","NNN"]	[2,1,3]

---

입출력 예 설명

입출력 예 #1

• 다음은 선수들의 정보를 나타낸 표입니다.

선수 번호vs 1번vs 2번vs 3번vs 4번승률자기보다 무거운 복서를 이긴 횟수몸무게

1번	-	패배	승리	패배	33.33%	1회	50kg
2번	승리	-	패배	패배	33.33%	0회	82kg
3번	패배	승리	-	승리	66.66%	2회	75kg
4번	승리	승리	패배	-	66.66%	0회	120kg

• 본문에 서술된 우선순위를 따라 [3,4,1,2] 를 return 합니다.

입출력 예 #2

• 다음은 선수들의 정보를 나타낸 표입니다.

선수 번호vs 1번vs 2번vs 3번승률자기보다 무거운 복서를 이긴 횟수몸무게

1번	-	패배	승리	50%	0회	145kg
2번	승리	-	패배	50%	1회	92kg
3번	패배	승리	-	50%	1회	86kg

• 본문에 서술된 우선순위를 따라 [2,3,1] 을 return 합니다.

입출력 예 #3

• 다음은 선수들의 정보를 나타낸 표입니다.

선수 번호vs 1번vs 2번vs 3번승률자기보다 무거운 복서를 이긴 횟수몸무게

1번	-	-	-	0% (무전적)	0회	60kg
2번	-	-	-	0% (무전적)	0회	70kg
3번	-	-	-	0% (무전적)	0회	60kg

• 본문에 서술된 우선순위를 따라 [2,1,3] 을 return 합니다.

코드

function solution(weights, head2head) {
  var answer = [];
  let result = [];

  for(let i = 0; i < head2head.length; i++) {
    let score = 0;
    let myWeight = weights[i];
    for(let j = 0; j < head2head[i].length; j++) { //상대방과의 경기 결과 비교
      let fight = head2head[i][j]; // 경기 결과
      let opWeight = weights[j];
      if(fight === 'N') continue; // 자기 자신과 경기했을 경우
      if(fight === 'W') { 
        if(myWeight < opWeight) score += 2; // 상대방을 이겼으며 상대방보다 무게가 낮을 경우에는 2를 가산
        else score += 1; // 무게가 낮을 경우에는 1을 가산
      } 
      else if(fight === 'L') score -= 1; // 상대방에게 졌을 경우에는 1을 감산
    }
    result.push([score, myWeight, i + 1]); // [점수, 무게, 선수 번호]
  }
    
  result.sort((a, b) => {
    if(a[0] === b[0]) return b[1] - a[1];
    else return b[0] - a[0]
  })
 
  answer = result.map(elem => {return elem[2]});
  return answer;
}

 

오답

테스트 케이스를 실행했을 때는 모두 맞았지만 코드를 제출했을 때 많은 케이스에서 오답 처리되었다.

 

이에 문제를 다시 읽어보니 문제에서 요구하는 조건을 제대로 충족시키지 못했음을 확인하였다.

 

• 승률을 토대로 순위를 결정했어야 했는데 단순히 점수를 통해 순위를 결정했다
• 위 조건을 생각하지 못해 'N'인 경우에 어떠한 연산 처리 없이 넘어갔다_ (승률) = (이긴 경기 수) / (치룬 경기 수)
• 무게가 낮은 선수가 더 높은 순위를 가지게 된다 라는 조건은 첫 번째 조건에서 순위를 결정 짓지 못할 경우에 차후로 탐색해줬어야 했지만, 본 코드에서는 점수 1점을 더 주는 식으로 연산 처리했다.

위의 사항을 토대로 다시 코드를 작성해보았다.

 

코드

function rating(arr1, arr2, num) {
    const ratings = []
    for(let i=0; i<num; i++) {
        let wins = 0
        let weight = 0
        let none = 0
        for(let j=0; j<num; j++) {
            if(arr1[i][j] === "W") {
                wins++
                if(arr2[j] > arr2[i]) weight++
            } else if(arr1[i][j] === "N") none ++; // 치룬 경기 수를 구하기 위해 N인 경우에도 관련 변수에 가산      
        }
        if(num-none !== 0) ratings.push([i+1, wins/(num-none)*100, weight, arr2[i]]) // 경기를 하나도 치루지 않았을 경우를 제외하기 위한 조건 
        else ratings.push([i+1, 0, weight, arr2[i]])
    }
    return ratings // [선수 번호, 승률, 자신보다 체급이 높은 선수에 대한 승리 수, 선수 무게] 
}


function solution(weights, head2head) {
    const num = weights.length;
    const rate = rating(head2head, weights, num);
    const answer = rate.sort((a, b) => {
        if(a[1] != b[1]) return b[1] - a[1] // 승률
        else {
            if(a[2] != b[2]) return b[2] - a[2] // 자신보다 체급이 높은 선수에 대한 승리 수
            else {
                if(a[3] != b[3]) return b[3] - a[3] // 선수 자신의 체급
                else { // 선수 번호가 낮은 순서
                    return a[0] - b[0]
                }
            }
        }
    }).map(v => v[0]) // 최종적으로 선수 번호 반환
    return answer
}