우크라이나어 하는 개발자

제출 코드

function solution(answers) {
  let matchCount = new Object();
  const supoza1 = [1, 2, 3, 4, 5];
  const supoza2 = [2, 1, 2, 3, 2, 4, 2, 5];
  const supoza3 = [3, 3, 1, 1, 2, 2, 4, 4, 5, 5];
  for (let i = 0; i < answers.length; i++) {
    let order1 = i % supoza1.length;
    let order2 = i % supoza2.length;
    let order3 = i % supoza3.length;

    if (answers[i] === supoza1[order1]) {
      matchCount[1] = ++matchCount[1] || 1;
    }

    if (answers[i] === supoza2[order2]) {
      matchCount[2] = ++matchCount[2] || 1;
    }

    if (answers[i] === supoza3[order3]) {
      matchCount[3] = ++matchCount[3] || 1;
    }
  }
  let result = whoIsBest(matchCount);
  return result;
}

function whoIsBest(matchCount) {
  let result = new Array();
  let max = Math.max(...Object.values(matchCount));
  for (const [key, value] of Object.entries(matchCount)) {
    if (value === max) {
      result = result.concat(Number.parseInt(key));
    }
  }
  result.sort();
  return result;
}

수포자가 가진 배열 인덱스에 answers 배열 인덱스를 맞추기 위해 나머지 연산(%)을 사용하였습니다.

    let order1 = i % supoza1.length;
    let order2 = i % supoza2.length;
    let order3 = i % supoza3.length;

정답이라면 matchCount Object에 수포자에 해당되는 번호를 key로 하고

1을 더하거나 key가 없을 때는 1로 초기화합니다. 

    if (answers[i] === supoza1[order1]) {
      matchCount[1] = ++matchCount[1] || 1;
    }

whoIsBest 함수는 matchCount Object를 받아 결과값(ex [2,3])을 반환합니다.

function whoIsBest(matchCount) {
  let result = new Array();
  let max = Math.max(...Object.values(matchCount));
  for (const [key, value] of Object.entries(matchCount)) {
    if (value === max) {
      result = result.concat(Number.parseInt(key));
    }
  }
  result.sort();
  return result;
}

Object 가 가진 value 들 중에 가장 큰 값을 max로 선정합니다.

let max = Math.max(...Object.values(matchCount));

Object.entries method를 사용해 key와 value를 얻어내어 

value가 max와 같다면 key를 Number로 바꾸어 result 배열에 추가합니다.

for (const [key, value] of Object.entries(matchCount)) {
    if (value === max) {
      result = result.concat(Number.parseInt(key));
    }
  }

Solution with using filter

배열 filter 함수를 사용한 방법

function solution2(answers) {
  let matchCount = new Object();
  const supoza1 = [1, 2, 3, 4, 5];
  const supoza2 = [2, 1, 2, 3, 2, 4, 2, 5];
  const supoza3 = [3, 3, 1, 1, 2, 2, 4, 4, 5, 5];

  matchCount[1] = answers.filter(
    (answer, index) => answer === supoza1[index % supoza1.length]
  ).length;
  matchCount[2] = answers.filter(
    (answer, index) => answer === supoza2[index % supoza2.length]
  ).length;

  matchCount[3] = answers.filter(
    (answer, index) => answer === supoza3[index % supoza3.length]
  ).length;
 
  let result = whoIsBest(matchCount);
  return result;
}

Solution not using Object and fuction whoIsBest

Object와 whoIsBest 메소드를 사용하지 않은 방법

function solution(answers) {
  let result = new Array();
  const supoza1 = [1, 2, 3, 4, 5];
  const supoza2 = [2, 1, 2, 3, 2, 4, 2, 5];
  const supoza3 = [3, 3, 1, 1, 2, 2, 4, 4, 5, 5];

  const match1 = answers.filter(
    (answer, index) => answer === supoza1[index % supoza1.length]
  ).length;
  const match2 = answers.filter(
    (answer, index) => answer === supoza2[index % supoza2.length]
  ).length;
  const match3 = answers.filter(
    (answer, index) => answer === supoza3[index % supoza3.length]
  ).length;
  
  let max = Math.max(match1, match2, match3);
  
  [match1, match2, match3].forEach((match, index) => {
    if (match === max) {
      result = result.concat(index + 1);
    }
  });
  
  return result;
}

function solution(board, moves) {
  let answer = 0;
  let basket = new Array();
  for (let i = 0; i < moves.length; i++) {
    let pick = moves[i] - 1;
    let doll = 0;
    for (let j = 0; j < board.length; j++) {
      if (board[j][pick] > 0) {
        doll = board[j][pick];
        board[j].splice(pick, 1, 0);
        break;
      }
    }

    if (doll > 0) {
      basket.push(doll);
    }
    if (basket.length > 1) {
      let last = basket[basket.length - 1];
      let beforeLast = basket[basket.length - 2];
      if (last === beforeLast) {
        basket.splice(basket.length - 2, 2);
        answer += 2;
      }
    }
  }
  return answer;
}

let board = [
  [0, 0, 0, 0, 0],
  [0, 0, 1, 0, 3],
  [0, 2, 5, 0, 1],
  [4, 2, 4, 4, 2],
  [3, 5, 1, 3, 1],
];

let moves = [1, 5, 3, 5, 1, 2, 1, 4];

basket: 뽑은 인형을 담는 배열

pick: moves 배열 값으로 선택되는 세로축 번호

doll: 뽑은 인형 번호, 0은 빈 공간

for (let j = 0; j < board.length; j++) {
  if (board[j][pick] > 0) {
    doll = board[j][pick];
    board[j].splice(pick, 1, 0);
    break;
  }
}​

board.length는 인형뽑기 깊이를 의미합니다. 인형 번호가 1 이상이고 빈 공간이 0입니다.

board[j][pick]가 0보다 큰 경우는 인형이 있다는 것이고 doll에 인형 번호를 줍니다.

그리고 splice 함수를 이용해 인형이 있던 자리값을 0으로 바꾸어 줍니다.

인형을 뽑았기 때문에 반복문을 종료합니다.

 if (doll > 0) {
   basket.push(doll);
 }

board에서 인형을 뽑을 때 pick이 지정한 세로축에 인형이 없을 수도 있습니다!!

그러면 doll은 0인 상태인지 확인하고 basket에 인형을 담습니다.

    if (basket.length > 1) {
      let last = basket[basket.length - 1];
      let beforeLast = basket[basket.length - 2];
      if (last === beforeLast) {
        basket.splice(basket.length - 2, 2);
        answer += 2;
      }
    }

basket에 둘 이상이 있어야 뽑은 인형과 바로 전에 뽑은 인형을 비교할 수 있습니다.

방금 뽑은 인형과 이전에 뽑은 인형을 비교해 같다면

basket에서 이 둘을 splice를 이용해 제거합니다. 그리고 두 인형이 제거되었으므로 answer에 2를 더해줍니다.