Coding Test with Javascript

[BOJ/백준] 11726번 - 2xn 타일링 (Javascript / NodeJS)

Paul Eich — Tue, 9 Jan 2024 17:51:46 +0900

문제

풀이

Dynamic Programming 문제이다. 먼저 값을 저장할 배열을 선언해주고, 점화식을 찾은 후, 초깃값을 설정하여 해결한다.

d[k]: 2*k 크기의 직사각형을 채우는 방법 수
점화식: d[k] = d[k-1] + d[k-2]
- d[k]는 다음과 같은 두 가지 방법의 수를 합하여 구할 수 있다.
- 2*(k-1) 크기의 직사각형 뒤에 1*2 크기의 직사각형을 배치하는 방법 수
- 2*(k-2) 크기의 직사각형 뒤에 2*1 크기의 직사각형 2개를 배치하는 방법 수
초기값: d[1] = 1, d[2] = 2

처음 시도에서 값을 `Number` 자료형으로 설정하니 통과하지 못했다. 그래서 `BigInt` 자료형으로 변경하여 문제를 해결했다.

"use strict"

const n = Number(require('fs').readFileSync('./dev/stdin').toString().trim());

function solution(n) {
    // 1. 배열: d[k] = 2*k 크기의 직사각형을 채우는 방법
    const d = Array.from({ length: n+1 }, () => 0);
    // 2. 점화식
    // d[k] = d[k-1] + d[k-2]
    // 3. 초기값
    d[1] = 1n;
    d[2] = 2n;

    for (let k = 3; k <= n; k++) {
        d[k] = d[k-1] + d[k-2]
    }

    return (d[n] % 10007n).toString();
}

console.log(solution(n));

추가 풀이

이전 글에서도 언급한 적 있지만 까먹은 것이 있었는데 modulo 연산의 경우 다음과 같은 분배법칙이 성립한다.

(A+B)%N === ((A%N) + (B%N))%N

따라서 이러한 성질을 이용한다면 `Number` 자료형으로도 해결할 수 있다.

"use strict"

const n = Number(require('fs').readFileSync('./dev/stdin').toString().trim());

function solution(n) {

    const mod = 10007;
    const d = Array.from({ length: n+1 }, () => 0);

    d[1] = 1;
    d[2] = 2;

    for (let k = 3; k <= n; k++) {
        d[k] = d[k-1] % mod + d[k-2] % mod;
    }

    return d[n] % mod;
}

console.log(solution(n));

[BOJ/백준] 11652번 - 카드 (Javascript / NodeJS)

Paul Eich — Thu, 4 Jan 2024 16:03:18 +0900

문제

문제 보러 가기

풀이

Map 자료형을 사용하여 각 숫자의 개수를 세고, 이를 활용하여 가장 많은 카드를 찾는다. 이 때, 카드의 숫자 범위가 매우 크므로 BigInt 자료형을 사용해주어야 한다. BigInt 자료형을 사용하지 않아서 계속 틀렸다. BigInt의 범위를 확인하기가 어려운데, 다음 명령어를 사용해서 판별할 수 있다.

console.log(Number.isSafeInteger(Math.pow(2, 62)));

"use strict"

const [n, ...cards] = require('fs').readFileSync('./dev/stdin').toString().trim().split('\n').map(BigInt);

function solution(n, cards) {
    const cnts = new Map();
    for (let card of cards) {
        if (cnts.get(card)) cnts.set(card, cnts.get(card) + 1);
        else cnts.set(card, 1);
    }
    return [...cnts.keys()].sort((a, b) => a - b < 0n ? -1 : 1).reduce((answer, key, idx) => {
        if (idx === 0) return key;
        if (cnts.get(key) > cnts.get(answer)) return key;
        else if (cnts.get(key) === cnts.get(answer)) {
            if (key < answer) return key;
            else return answer;
        }
        else return answer;
    }, 0).toString();
}

console.log(solution(n, cards));

[BOJ/백준] 11559번 - Puyo Puyo (Javascript / NodeJS)

Paul Eich — Wed, 3 Jan 2024 22:58:40 +0900

문제

문제 보러 가기

풀이

뿌요를 터뜨리는 데 distance를 알 필요가 없으므로 구현이 쉬운 DFS를 사용하여 탐색을 진행하였다. 탐색 결과, 뿌요가 4개 이상인 경우 뿌요를 지웠다. 그리고 필드에 대해서 DFS를 모두 수행해주고, 연쇄가 일어났다면 중력에 따라 뿌요를 재배치하고 다시 DFS를 수행할 수 있도록 코드를 작성하였다.

⚠️ 문제를 꼼꼼히 잘 읽는 습관이 아직 모자란 듯 하다.

터질 수 있는 뿌요가 여러 그룹이 있다면 동시에 터져야 하고 여러 그룹이 터지더라도 한번의 연쇄가 추가된다는 지문 한 줄을 정확하게 읽지 않아서, 세 번의 시도를 실패하고 성공하였다.

"use strict"

const field = require('fs').readFileSync('/dev/stdin').toString().trim().split('\n').map(str => str.split(''));


function solution(field){

    function gravity() {
        for (let c = 0; c < 6; c++) {
            let floor = 11;
            for (let i = 11; i >= 0; i--) {
                if (field[i][c] === '.') break;
                floor--;
            }
            for (let r = floor; r >= 0; r--) {
                if (field[r][c] !== '.') {
                    field[floor--][c] = field[r][c];
                    field[r][c] = '.';
                }
            }
        }
    }


    function puyo(start, visited) {
        let cnt = 1;
        const s = [];
        const pos = [];
        const dx = [1, 0, -1, 0];
        const dy = [0, 1, 0, -1];
        const color = field[start[0]][start[1]];
        s.push(start);
        pos.push(start);
        visited[start[0]][start[1]] = true;
        while(s.length > 0) {
            const [x, y] = s.pop();
            for (let dir = 0; dir < 4; dir++) {
                const nx = x + dx[dir];
                const ny = y + dy[dir];
                if (nx < 0 || nx >= 12 || ny < 0 || ny >= 6) continue;
                if (visited[nx][ny] || field[nx][ny] !== color) continue;
                s.push([nx, ny]);
                visited[nx][ny] = true;
                pos.push([nx, ny]);
                cnt++;
            }
        }
        if (cnt >= 4) {
            for (let [x, y] of pos) {
                field[x][y] = '.';
            }
        }

        return cnt >= 4
    }

    let answer = 0;

    let isPuyoed = true;
    while (isPuyoed) {
        isPuyoed = false;
        const visited = Array.from({ length: 12 }, () => Array.from({length: 6}, () => false));
        for (let c = 0; c < 6; c++) {
            for (let r = 11; r >= 0; r--) {
                if (field[r][c] === '.' || visited[r][c]) continue;
                if (puyo([r, c], visited)) {
                    isPuyoed = true;
                }
            }
        }
        if (isPuyoed) answer++;
        gravity();
    }

    return answer;
}

console.log(solution(field));

[BOJ/백준] 17298번 - 오큰수 (Javascript / NodeJS)

Paul Eich — Thu, 28 Dec 2023 01:08:51 +0900

문제

문제 보러 가기

풀이

문제를 보고 간단하게 이중 for문을 사용하여 푸는 방법이 떠올랐지만, N의 최댓값이 1,000,000이므로 시간 초과가 날 것이라고 생각하였다. 그래서 처음에는 스택을 두개 사용하는 방법을 통해서 풀이해봤지만, 메모리 초과가 발생하였다.

"use strict"

const [[n], a] = require('fs').readFileSync('./dev/stdin').toString().trim().split('\n').map(str => str.split(' ').map(Number));

function solution(n, a) {
    const answer = [];
    const s1 = [...a.reverse()];
    for (let i = 0; i < n; i++) {
        const s2 = [];
        let cur = s1.pop();
        let nge = s1.pop();
        while (cur >= nge) {
            s2.push(nge);
            nge = s1.pop();
        }
        answer.push(nge ?? -1);
        s1.push(nge, ...s2.reverse());
    }
    return answer.join(' ');
}

console.log(solution(n, a));

이후, 생각해낸 풀이는 다음과 같다. 스택을 통해 인덱스를 저장하고 오큰수를 찾으면 역방향으로 오큰수에 해당하는지 확인하는 방법이다.

"use strict"

const [[n], a] = require('fs').readFileSync('./dev/stdin').toString().trim().split('\n').map(str => str.split(' ').map(Number));

function solution(n, a) {
    const answer = [];
    const s = [];

    for (let i = 0; i < n; i++) {
        while (s.length && a[s.at(-1)] < a[i]) {
            answer[s.pop()] = a[i]
        }
        s.push(i);
    }

    for (let i of s) {
        answer[i] = -1;
    }

    return answer.join(' ');
}

console.log(solution(n, a));

[BOJ/백준] 15663번 - N과 M(9) (Javascript / NodeJS)

Paul Eich — Sat, 23 Dec 2023 23:17:09 +0900

문제

문제 보러 가기

풀이

N과 M 시리즈 문제로 백트래킹을 사용한다. 이 문제는 주어지는 수열에 중복인 수가 존재하여 중복 수열이 발생할 수 있어 이에 대한 처리를 해주어야 한다.

최초 풀이

최초 풀이의 경우, 정답을 출력하기 이전에 answers 배열에 기존 수열이 존재하는지 체크하기 위해서 includes 메소드를 사용하였다. 시간 초과가 날 것이라고 예상한 것과 다르게 통과하였다.
하지만 시간 초과가 날 수 있는 확률이 큰 부분을 제거하는 방법이 없을까 풀이를 찾아보았다.

"use strict"

const [[n, m], arr] = require('fs').readFileSync('/dev/stdin').toString().trim().split('\n').map(str => str.split(' ').map(Number));

function solution(n, m, arr) {
    const answers = [];
    const answer = [];
    const sorted = arr.sort((a, b) => a - b);
    const isUsed = Array(n).fill(false);

    function bt(k) {
        if (k === m) {
            if (!answers.includes(answer.join(' '))) answers.push(answer.join(' '));
            return;
        }
        for (let i = 0; i < n; i++) {
            if (!isUsed[i]) {
                answer.push(sorted[i]);
                isUsed[i] = true;
                bt(k + 1);
                answer.pop();
                isUsed[i] = false;
            }
        }
    }

    bt(0);

    return answers.join('\n');
}

console.log(solution(n, m, arr));

수정 풀이

풀이를 찾아보니 이전 수열의 마지막 항과 새로운 수열의 마지막 항이 같으며 중복 수열이라는 것을 알 수 있었다. 이 부분이 잘 이해가 가지 않아서 console에 계속 값을 출력해보면서 확인해보고 이해할 수 있었다.

백트래킹의 depth별로 마지막 항에 대해서 검사를 하기 때문에 9 9와 같이 중복 숫자가 있는 수열도 만들 수 있었다. 백트래킹 또한 재귀를 이용하는 풀이인데, 재귀적으로 생각하는게 아직 쉽지 않은 것 같다.

"use strict"

const [[n, m], arr] = require('fs').readFileSync('./dev/stdin').toString().trim().split('\n').map(str => str.split(' ').map(Number));

function solution(n, m, arr) {
    const answers = [];
    const answer = [];
    const sorted = arr.sort((a, b) => a - b);
    const isUsed = Array(n).fill(false);

    function bt(k) {
        if (k === m) return answers.push(answer.join(' '));
        let tmp = 0;
        for (let i = 0; i < n; i++) {
            if (!isUsed[i] && tmp !== sorted[i]) {
                answer.push(sorted[i]);
                isUsed[i] = true;
                tmp = sorted[i];
                bt(k + 1);
                answer.pop();
                isUsed[i] = false;
            }
        }
    }

    bt(0);

    return answers.join('\n');
}

console.log(solution(n, m, arr));

[BOJ/백준] 15654번 - N과 M(5) (Javascript / NodeJS)

Paul Eich — Thu, 21 Dec 2023 22:25:46 +0900

문제

문제 보러 가기

풀이

이 문제는 기존 N과 M 문제에서 숫자 배열을 주는 문제이다. 마찬가지로 오름차순으로 정렬해야하는데, 이를 위해 배열을 먼저 오름차순으로 정렬한 후 백트래킹 작업을 수행하였다.

"use strict"

const [[n, m], arr] = require('fs').readFileSync('/dev/stdin').toString().trim().split('\n').map(str => str.split(' ').map(Number));

function solution(n, m, arr) {
    const answers = [];
    const answer = [];
    const sArr = arr.sort((a,b)=>a-b);
    const isUsed = Array(n).fill(false);

    function bt(k) {
        if (k === m) return answers.push(answer.join(' '));
        for (let i = 0; i < n; i++) {
            if (!isUsed[i]) {
                answer.push(sArr[i]);
                isUsed[i] = true;
                bt(k+1);
                answer.pop();
                isUsed[i] = false;
            }
        }
    }

    bt(0);

    return answers.join('\n');
}

console.log(solution(n, m, arr));

[BOJ/백준] 15652번 - N과 M(4) (Javascript / NodeJS)

Paul Eich — Wed, 20 Dec 2023 11:52:20 +0900

[BOJ/백준] 15651번 - N과 M(3) (Javascript / NodeJS)

Paul Eich — Wed, 20 Dec 2023 11:31:38 +0900

문제

문제 보러 가기

풀이

15650번 N과 M(2)에서 중복을 허용하는 문제이다. 간단한 백트래킹을 통해서 풀 수 있다.

"use strict"

const [n, m] = require('fs').readFileSync('/dev/stdin').toString().trim().split(' ').map(Number);

function solution(n, m) {
    const answer = [];
    const arr = [];

    function bt(k) {
        if (k === m) return answer.push(arr.join(' '));
        for (let i = 1; i <= n; i++) {
            arr.push(i);
            bt(k+1);
            arr.pop(i);
        }
    }

    bt(0);

    return answer.join('\n');
}

console.log(solution(n, m));

[BOJ/백준] 15650번 - N과 M(2) (Javascript / NodeJS)

Paul Eich — Wed, 20 Dec 2023 11:05:43 +0900

문제

문제 보러 가기

풀이

백트래킹 문제로 수열을 만들고 출력하는 문제이다. 수열의 출력 형태가 공백으로 구분되어 있는 것을 보고 정답 배열에 arr.join(' ')을 추가해주는 형식으로 구현하였다. 문제의 조건 중, 수열은 사전 순으로 증가하는 순서로 출력해야 한다는 조건이 있는데, 이는 백트래킹 구현시 해당 조건을 만족시키면서 증가하기 때문에 따로 정렬하지 않았다.

"use strict"

const [n, m] = require('fs').readFileSync('/dev/stdin').toString().trim().split(' ').map(Number);

function solution(n, m) {
    const answer = [];
    const isUsed = Array(n+1).fill(false);
    const arr = [];

    function backTracking(k) {
        if (k === m) return answer.push(arr.join(' '));
        for (let i = 1; i <= n; i++) {
            if (!isUsed[i] && (arr.length===0 || i>arr.at(-1))) {
                arr.push(i);
                isUsed[i] = true;
                backTracking(k+1);
                arr.pop(i);
                isUsed[i] = false;
            }
        }
    }

    backTracking(0);

    return answer.join('\n');
}

console.log(solution(n, m));

[BOJ/백준] 1182번 - 부분수열의 합 (Javascript / NodeJS)

Paul Eich — Wed, 20 Dec 2023 01:18:31 +0900

문제

문제 보러 가기

풀이

계속해서 재귀와 백트래킹 문제를 풀고 있는데, 문제 유형이 조금만 달라져도 풀기가 어려워지는 것이 느껴진다. 이 문제의 경우, 어떤 값에 대해서 추가할지 아닐지를 정해나가는 문제이기 때문에 그 두 가지 경우에 대해서 모두 재귀함수를 호출하면서 반복해나가는 형태라 떠올리기 힘들었다. 재귀와 백트래킹 문제를 계속해서 풀어봐야겠다.

"use strict"

const [[n, s], inputs] = require('fs').readFileSync('/dev/stdin').toString().trim().split('\n').map(str => str.split(' ').map(Number));

function solution(n, s, inputs) {
    let answer = 0;

    function backTracking(k, sum) {
        if (k === n) {
            if (sum === s) answer++;
            return;
        }
        backTracking(k+1, sum);
        backTracking(k+1, sum+inputs[k]);
    }

    backTracking(0, 0);

    if (s == 0) answer--;

    return answer;
}

console.log(solution(n, s, inputs));