y_flm's Blog

function solution(numbers, hand) {
    const keypad = [[1, 2, 3], [4, 5, 6], [7, 8, 9], ['*', 0, '#']];
    let left = [3, 0];
    let right = [3, 2];
    let result = [];
    
    for(let i = 0; i < numbers.length; i++) {
        for(let j = 0; j < keypad.length; j++) {
            for(let k = 0; k < keypad[j].length; k++) {
                // 입력할 번호와 키패드 번호가 일치할 시
                if(numbers[i] === keypad[j][k]) {
                    // 왼쪽 열일 때
                    if([1, 4, 7].includes(numbers[i])) {
                       left = [j, k];
                       result.push('L');
                    } 
                    // 오른쪽 열일 때
                    else if([3, 6, 9].includes(numbers[i])) {
                       right = [j, k];
                       result.push('R');
                    } 
                    // 가운데 열일 때
                    else {
                       // 각 왼손과 오른손으로 눌렀을 때의 거리 계산
                       let leftCount = Math.abs(j - left[0]) + Math.abs(k - left[1]);
                       let rightCount = Math.abs(j - right[0]) + Math.abs(k - right[1]);
                       
                       // 오른손이 더 가까울 경우
                       if(leftCount > rightCount) {
                           right = [j, k];
                           result.push('R');
                        } 
                        // 왼손이 더 가까울 경우
                        else if(rightCount > leftCount) {
                           left = [j, k];
                           result.push('L');
                        } 
                        // 거리가 같을 경우
                        else {
                           // hand에 따라 결정
                           if(hand === 'right') {
                               right = [j, k];
                               result.push('R');
                           } else {
                               left = [j, k];
                               result.push('L');
                           }
                        }
                    }
                }
            }
        }
    }
    
    return result.join('');
}

코드가 복잡해보이지만 막상 그렇지는 않다.

나는 좌표를 생각하면서 문제를 풀었다.

먼저 키패드와 비슷한 모양의 배열을 만들어주고, 시작위치는 *, # 이므로 해당 인덱스를 left, right에 각각 저장한다.

그 다음 누를 번호와 키패드의 번호가 같을 경우,

number[i]가 1, 4, 7 중 하나이면 왼손, 3, 6, 9 중 하나면 오른손이므로 키패드의 인덱스를 해당하는 손에 저장한다.

또한 result에 해당하는 손을 push 해준다.

left, right에 인덱스를 저렇게 저장하는 이유는 당연히 계속해서 값을 덮어씌워야 하기 때문이다.

그리고 가운데 열의 숫자일 때는 왼손에서의 거리, 오른손에서의 거리를 각각 계산해서 저장한다.

이 값을 가지고 leftCount가 더 크다면 오른손, rightCount가 더 크다면 왼손을 저장하도록 한다.

만약 두 손의 거리가 같을 경우에는 주어진 hand를 기준으로 해당하는 값을 저장하면 된다.

이렇게 result에 저장된 값은 배열이므로 join을 통해 문자열로 반환해주면 끝이다!

function solution(participant, completion) {
    let count = {};
    
    for(let name of participant) {
        count[name] = (count[name] || 0) + 1;
    }
    
    for(let name of completion) {
        count[name]--;
    }
    
    for(let name in count) {
        if(count[name] > 0) return name;
    }
}

효율성을 따져야하는 문제이기 때문에 객체를 택했다.

먼저 count 객체에 참가자의 이름과 count를 저장해준다.

{ a: 1, b: 1, ... } 이런식으로 저장되고,

그 다음 완주자 목록을 통해 count 객체에서 참가자 이름에 해당하는 값은 감소 시켜준다.

그러면 이제 완주하지 못한 사람만 1이 남아있을 것이다.

그렇기 때문에 count를 순회하며 0이상인 선수의 이름을 리턴하면 끝!

function solution(lottos, win_nums) {
    let scoreToRank = {
        6: 1,
        5: 2,
        4: 3,
        3: 4,
        2: 5,
        1: 6,
        0: 6
};
    
    let current = lottos.filter((num) => win_nums.includes(num)).length;
    let zero = lottos.filter((num) => num === 0).length;

    return [scoreToRank[current + zero], scoreToRank[current]];
}

로또 당첨번호와 일치하는 개수를 current에 저장하고, 알아볼 수 없는 번호의 개수를 zero에 저장해줬다.

맞춘 개수에 맞는 등수를 저장한 rank 객체를 이용해서

최고 순위는 current + zero로, 최저 순위는 current를 이용해서 구해주면 된다.

배열로 등수를 저장해서 풀 수도 있다!

function solution(lottos, win_nums) {
    let rank = [6, 6, 5, 4, 3, 2, 1]
    
    let current = lottos.filter((num) => win_nums.includes(num)).length;
    let zero = lottos.filter((num) => num === 0).length;

    return [rank[current + zero], rank[current]];
}

0, 1개는 6등, 1개를 맞추면 5등 이런 식이기 때문에 배열의 인덱스를 활용해서 풀 수도 있었다.

function solution(n) {
    let transCount = n.toString(2).match(/1/g).length;
    
    while(n++) {
        let iTransCount = n.toString(2).match(/1/g).length;
        if(transCount === iTransCount) return n;
    }
}

조건 1은 n++로 충족시킬 수 있고,

조건 2의 경우 미리 n을 2진수로 변환시켜서 1의 길이를 transCount에 저장해둔다.

그리고 while문 안에서 n++ 값을 똑같이 2진수 변환 후 1 길이를 저장하고,

만약 count가 같다면 해당 n을 리턴하도록 한다.

여기서 n은 순차적으로 증가하므로 자연스럽게 조건 3도 충족하게 된다.

function solution(sizes) {
    let result = { max: [], min: [] };
    
    for(let i = 0; i < sizes.length; i++) {
        result.max.push(Math.max(...sizes[i]));
        result.min.push(Math.min(...sizes[i]));
    }
    
    return Math.max(...result.max) * Math.max(...result.min);
}

오늘은 간단한 문제를 풀어보았다!

최소 직사각형이므로 가로, 세로 길이에서 큰 수와 작은 수를 각각 max, min에 저장하고,

마지막에 max에서 가장 큰수, min에서 가장 큰 수를 곱해주면 된다!

function solution(dartResult) {
    let scores = dartResult.match(/\d+\D+/g);
    scores.forEach((score, i) => {
        scores[i] = [
            ...(score.match(/\d+/) || []),
            ...(score.match(/[a-zA-Z]+/) || []),
            ...(score.match(/[^a-zA-Z0-9]+/) || [])]});

    for(let i = 0; i < scores.length; i++) {
        let score = 0;
        
        if(scores[i][1] === 'S') {
            score = Math.pow(scores[i][0], 1);
        } else if(scores[i][1] === 'D') {
            score = Math.pow(scores[i][0], 2);
        } else if(scores[i][1] === 'T') {
            score = Math.pow(scores[i][0], 3);
        }
        
        if(scores[i][2] === '*') {
            if((i - 1) >= 0) {
                scores[i - 1] *= 2;
                score *= 2;
            } else {
                score *= 2;
            }
        } else if(scores[i][2] === '#') {
            score *= -1;
        }
        scores[i] = score;
    }
    
    return scores.reduce((total, current) => total + current, 0);
}

처음 푼 풀이이다.

문제를 보고 먼저 각 기회에 맞게 배열로 나눈 뒤, 또 그 요소를 점수, 보너스, 옵션으로 나눠야겠다는 생각을 했다.

그래서 정규식을 이용하여 각각 나누어주었다.

 그 다음 보너스를 확인하여 알맞게 점수를 제곱해주었고, 옵션에 따라 점수를 곱해주었다.

마지막으로 각 점수들을 더해서 반환해주면 끝이다!

하지만 뭔가 마음에 들지 않았다. 너무 하드 코딩한 느낌이랄까 ... 

그래서 수정한다고 해봤는데 그리 크게 수정하지는 못했다.

function solution(dartResult) {
    let bonus = {'S': 1, 'D': 2, 'T': 3};
    let scores = dartResult.match(/\d+\D+/g);
    scores.forEach((score, i) => {
        scores[i] = [
            ...(score.match(/\d+/) || []),
            ...(score.match(/[a-zA-Z]+/) || []),
            ...(score.match(/[^a-zA-Z0-9]+/) || [])]});

    for(let i = 0; i < scores.length; i++) {
        let score = Math.pow(scores[i][0], bonus[scores[i][1]]);
        
        if(scores[i][2] === '*') {
            score *= 2;
            if((i - 1) >= 0) {
                scores[i - 1] *= 2;
            }
        } else if(scores[i][2] === '#') {
            score *= -1;
        }
        scores[i] = score;
    }
    
    return scores.reduce((total, current) => total + current, 0);
}

수정한건 두가지인데, 먼저 보너스 점수를 미리 선언해두니 중복 코드를 줄일 수 있었다. ㅎㅎ .. 

그 다음 옵션을 계산할 때 스타상은 어차피 해당 점수의 2배를 해줘야하므로 else문은 삭제해도 됐었다.

for문만 보면 그래도 깔끔해지긴 했지만 정규식 부분이 여전히 마음에 들지 않았다.

아직 정규식을 공부해보지는 않아서 더 나은 방법을 알 수가 없었기 때문에 gpt의 힘을 빌렸다 ㅎㅎ ;

function solution(dartResult) {
    const regex = /(\d+)([SDT])([*#]?)/g;
    let bonus = {'S': 1, 'D': 2, 'T': 3};
    let scores = [];
    let match;

    while ((match = regex.exec(dartResult)) !== null) {
        let [_, num, b, opt] = match;
        let score = Math.pow(parseInt(num), bonus[b]);

        if (opt === '*') {
            score *= 2;
            if (scores.length > 0) {
                scores[scores.length - 1] *= 2;
            }
        } else if (opt === '#') {
            score *= -1;
        }

        scores.push(score);
    }
    
    return scores.reduce((total, current) => total + current, 0);
}

먼저 정규식을 선언해두고 while 문을 이용해서 풀었다.

엄청 생소한 메서드들이었는데 여기서도 특히 match 값을 왜 while 조건문 안에서 저장해주는지 의문이었다.

그 이유는 regex.exec()는 g 플래그와 함께 쓰면 매번 한 개씩 매치를 반환해주기 때문이었다.

만약 미리 match에 저장해둔다면 반복이 한 번밖에 되지 않기 때문에 원하는 답이 안나온다.

그리고 match 값을 각각 구조 분해하여 num, b, opt에 저장해주고 나면 나머지 코드는 비슷하다.

여기서 또 궁금했던건 왜 굳이 [_, num, b, opt]에서 처음 요소를 비워주는지 궁금했다.

그 이유는 exec의 반환 값을 보면 알 수 있었다.

let [_, num, b, opt] = match;
// _ : 전체 매치 (예: "1S")
// num : 숫자 (예: "1")
// b : 보너스 (예: "S")
// opt : 옵션 (예: "*", "#", 또는 "")

이런 식으로 결과가 나오기 때문에 현재 문제에서는 전체 매치 값은 필요없으므로 비워줬던 것이다.

이 문제는 정규식을 잘 안다면 쉽게 풀 수 있는 문제인 것 같다.

function score(userAnswers, answers) {
  let count = 0;

  for (let i = 0; i < answers.length; i++) {
    let index = i % userAnswers.length;
    if (answers[i] === userAnswers[index]) count++;
  }

  return count;
}

function solution(answers) {
  let student1 = [1, 2, 3, 4, 5];
  let student2 = [2, 1, 2, 3, 2, 4, 2, 5];
  let student3 = [3, 3, 1, 1, 2, 2, 4, 4, 5, 5];

  let corretCounts = [];

  corretCounts.push(score(student1, answers));
  corretCounts.push(score(student2, answers));
  corretCounts.push(score(student3, answers));

  let maxCount = Math.max(...corretCounts);
  let topScorers = [];

  for (let i = 0; i < corretCounts.length; i++) {
    if (maxCount === corretCounts[i]) topScorers.push(i + 1);
  }

  return topScorers;
}

 처음에는 반복되는 코드인 맞은 문제 수를 리턴해주는 score 함수를 따로 만들어서 풀었다.

학생마다 찍는 방식을 미리 선언해주고 score 함수를 통해 얻은 count를 correctCounts에 저장해준다.

그 후 correctCounts에서의 최댓값을 구해서 maxCount에 넣어주고,

문제를 많이 맞춘 학생의 번호를 topScores에 넣어줄 것이다.

그리고 maxCount와 correctCounts[i]가 같다면 topScore에 i + 1을 푸쉬하고,

마지막으로 topScores를 리턴해주면 된다.

그리고 다른 사람 풀이를 보다가 생각도 못했던 filter를 쓰는 방법도 있어서 filter로도 풀어봤다.

function solution(answers) {
    let student1 = [1, 2, 3, 4, 5];
    let student2 = [2, 1, 2, 3, 2, 4, 2, 5];
    let student3 = [3, 3, 1, 1, 2, 2, 4, 4, 5, 5];
    
    let correctCount1 = answers.filter((answer, i) => answer === student1[i % student1.length]).length;
    let correctCount2 = answers.filter((answer, i) => answer === student2[i % student2.length]).length;
    let correctCount3 = answers.filter((answer, i) => answer === student3[i % student3.length]).length;
    
    let maxCount = Math.max(correctCount1, correctCount2, correctCount3);
    let result = [];
    
    if(maxCount === correctCount1) result.push(1);
    if(maxCount === correctCount2) result.push(2);
    if(maxCount === correctCount3) result.push(3);
    
    return result;
}

이 문제는 다양하게 풀이할 수 있어서 좋은 것 같다!