[프로그래머스/JavaScript] 주사위 게임 3 (Feat. Map)

 

어우... 정말 어려웠는데요. 이 문제를 풀기 위해 찾았던 개념들에 대해 먼저 정리하고자 합니다.

1. JavaScript의 Map
- 값을 저장(변경) : set(key, value)
- key 존재 여부 확인 : has(key)
- key에 해당하는 value 가져오기 : get(key)
- size(크기) 확인 : size
- map의 key, value 확인(사용) : forEach((value, key) => {})

2. JavaScript의 배열
- 값 저장 : push(값)
- 배열 중 최소 값 구하기 : Math.min(... 배열명)

3. 절댓값 구하기
- 절댓값 : Math.abs(숫자)

4. 제곱 구하기
- 제곱 : **

 

초기 코드

function solution(a, b, c, d) {
    var answer = 0;
    return answer;
}

 

결과 코드

테스트 1 〉통과 (0.11ms, 33.4MB)
테스트 2 〉통과 (0.20ms, 33.5MB)
테스트 3 〉통과 (0.12ms, 33.6MB)
테스트 4 〉통과 (0.11ms, 33.6MB)
...

스스로 해냈다는 게 뿌듯하네요...

function solution(a, b, c, d) {
    // 결과를 담을 변수 answer
    var answer = 0;

    // 숫자들을 담은 배열
    const arr = [a, b, c, d];

    // 숫자 등장 횟수를 세는 Map 생성
    const map = new Map();

    // 각 숫자의 등장 횟수를 세는 과정
    for (let i = 0; i < arr.length; i++) {
        const key = arr[i];

        // Map에 키가 이미 존재하면 등장 횟수를 증가시키고,
        // 없으면 새로운 키를 추가하고 등장 횟수를 1로 설정
        if (map.has(key)) {
            const value = map.get(key);
            const newValue = value + 1;
            map.set(key, newValue);
        } else {
            map.set(key, 1);
        }
    }

    // 등장한 숫자의 종류 개수
    const mapSize = map.size;

    // 등장한 숫자의 종류에 따라 다른 로직 수행
    switch (mapSize) {
        case 1:
            // 모든 숫자가 같은 경우, 1111을 곱하여 반환
            map.forEach((value, key) => {
                answer = key * 1111;
            });
            break;
        case 2:
            // 숫자 종류가 2가지인 경우
            let flag = true;  // (등장 횟수에 따른) 특정 조건을 나타내는 플래그
            let sameArr = [];  // 등장 횟수가 2인 숫자를 저장하는 배열
            let diffArr = [];  // 등장 횟수가 3인 숫자와 1인 숫자를 저장하는 배열

            // 등장 횟수에 따라 분류
            map.forEach((value, key) => {
                if (value === 3) {
                    diffArr[0] = key;
                } else if (value === 2) {
                    sameArr.push(key);
                    flag = false;  // 등장 횟수가 2인 숫자가 있음을 나타내는 플래그 변경
                } else {
                    diffArr[1] = key;
                }
            });

            if (flag) {
                // 등장 횟수에 따라 로직 수행
                answer = (10 * diffArr[0] + diffArr[1]) ** 2;
            } else {
                answer = (sameArr[0] + sameArr[1]) * Math.abs(sameArr[0] - sameArr[1]);
            }
            break;
        case 3:
            // 모든 숫자가 다른 경우, 두 숫자를 곱하여 반환
            let temp1 = [];
            map.forEach((value, key) => {
                if (value === 1) {
                    temp1.push(key);
                }
            });
            answer = temp1[0] * temp1[1];
            break;
        case 4:
            // 모든 숫자가 다른 경우, 가장 작은 숫자를 반환
            let temp2 = [];
            map.forEach((value, key) => {
                temp2.push(key);
            });
            answer = Math.min(...temp2);
            break;
    }

    // 최종 결과 반환
    return answer;
}

 

+ 저는 1시간을 고민해서 풀어냈는데요, 쉽고 가독성 있게 풀이한 것이 있어서 가져와봤습니다.

function solution(a, b, c, d) {
    if (a === b && a === c && a === d) return 1111 * a

    if (a === b && a === c) return (10 * a + d) ** 2
    if (a === b && a === d) return (10 * a + c) ** 2
    if (a === c && a === d) return (10 * a + b) ** 2
    if (b === c && b === d) return (10 * b + a) ** 2

    if (a === b && c === d) return (a + c) * Math.abs(a - c)
    if (a === c && b === d) return (a + b) * Math.abs(a - b)
    if (a === d && b === c) return (a + b) * Math.abs(a - b)

    if (a === b) return c * d
    if (a === c) return b * d
    if (a === d) return b * c
    if (b === c) return a * d
    if (b === d) return a * c
    if (c === d) return a * b

    return Math.min(a, b, c, d)
}