스위프트 코딩테스트 강좌, 022 수 정렬하기 3

안녕하세요! 이번에는 스위프트를 기반으로 한 코딩테스트 문제인 “수 정렬하기 3″를 함께 풀어보겠습니다. 이 문제는 간단하게 숫자를 정렬하는 것처럼 보이지만, 특정한 조건과 제약이 있어서 코딩테스트에서는 좋은 연습이 될 것입니다. 이번 글에서는 문제 정의와 입력, 출력 형식, 알고리즘적 접근 방법, 그리고 최적화 방법에 대해 자세히 알아보겠습니다.

문제 설명

문제의 요구 사항은 주어진 수들을 정렬하되, 정렬할 수의 범위가 제한되어 있다는 것입니다. 구체적으로, 수의 범위는 1 이상 100,000 이하의 정수이며, 이 정수를 오름차순으로 정렬하여 출력하는 것입니다.

예를 들어, 다음과 같은 수들이 주어진다고 가정해보겠습니다:

  • 5
  • 3
  • 8
  • 1
  • 2

이 경우, 출력은 다음과 같이 표시되어야 합니다:

  • 1
  • 2
  • 3
  • 5
  • 8

입력 형식

입력은 다음과 같은 형식으로 제공됩니다:

  1. 첫 번째 줄에 숫자의 개수 N이 주어집니다. (1 ≤ N ≤ 100,000)
  2. 두 번째 줄에는 N개의 정수가 공백으로 구분되어 주어집니다.

출력 형식

출력은 정렬된 수를 한 줄에 하나씩 출력해야 합니다.

풀이 접근

이 문제는 우리가 수를 정렬하는 것이기 때문에, 가장 기본적인 정렬 알고리즘을 사용할 수 있습니다. 하지만, N의 최대 값이 100,000이므로, O(N^2) 시간 복잡도를 가진 Bubble Sort나 Selection Sort 같은 비효율적인 알고리즘은 사용할 수 없습니다.

여기서는 Counting Sort 알고리즘을 이용하여 문제를 해결하고자 합니다. Counting Sort는 주어진 수의 범위가 제한되어 있을 때, 더욱 효율적으로 정렬할 수 있는 방법입니다. 이 알고리즘은 다음과 같은 단계를 거칩니다:

  1. 입력된 수의 범위에 해당하는 배열을 생성합니다.
  2. 입력 수의 등장 횟수를 해당 인덱스에 기록합니다.
  3. 최종적으로, 등장 횟수에 따라 정렬된 수를 출력합니다.

코드 구현

이제 스위프트로 문제를 해결하기 위한 코드를 작성해보겠습니다. 스위프트에서는 배열을 필드로 사용할 수 있기 때문에, Counting Sort를 구현하기가 매우 수월합니다. 아래는 그 구현 예시입니다:


    import Foundation

    func countingSort(numbers: [Int]) -> [Int] {
        // 수의 범위가 1~100,000이므로 100,001 크기의 배열 초기화
        var counts = Array(repeating: 0, count: 100001)

        // 각 수의 개수를 카운트
        for number in numbers {
            counts[number] += 1
        }

        var sortedNumbers: [Int] = []
        
        // 카운트를 기반으로 정렬된 수 생성
        for (number, count) in counts.enumerated() {
            for _ in 0..

실행 예제

위의 코드를 사용하여 입력을 해봅시다. 예를 들어, 다음과 같은 입력을 제공한다고 가정합니다:


    5
    5 3 8 1 2
    

출력 결과는 다음과 같아야 합니다:


    1
    2
    3
    5
    8
    

복잡도 분석

이 알고리즘의 시간 복잡도는 O(N + K)입니다. 여기서 N은 입력되는 수의 개수, K는 수의 범위입니다. 이 경우 K는 100,000으로 고정되어 있으므로, 알고리즘이 매우 효율적이라고 할 수 있습니다. 공간 복잡도 역시 O(K)개소가 필요하므로 O(100,000) 공간을 차지합니다.

마치며

이번 글에서는 “수 정렬하기 3″라는 문제를 살펴보았고, Counting Sort를 이용한 해결 방법을 구현했습니다. 이와 같은 수 정렬 문제는 기본적인 알고리즘의 이해도를 높이고, 실제 코딩테스트에서 자주 등장할 수 있는 주제이므로 반드시 연습해보시길 바랍니다. 다음 강좌에서는 더 어려운 문제에 도전해보겠습니다. 감사합니다!

자바스크립트 코딩테스트 강좌, 세그먼트 트리

문제 설명

문제: 일정 범위의 합 구하기

n개의 정수가 담긴 배열 arr가 주어질 때,
다음 쿼리들을 처리하는 함수를 작성하시오:

  • 1. update(index, value) : 배열 arrindex번째 값을 value로 갱신합니다.
  • 2. rangeSum(left, right) : 배열 arrleft번째부터 right번째(0-indexing)까지의 합을 계산합니다.

주어진 배열과 쿼리들을 사용하여 updaterangeSum의 요구 사항을 효율적으로 처리하세요.
배열의 크기는 최대 10^5이고, 쿼리의 개수는 최대 10^5입니다.

해결 방법

이 문제는 범위 합을 효율적으로 구하고 업데이트를 처리해야 하므로, 세그먼트 트리를 사용할 수 있습니다.
세그먼트 트리는 주어진 배열을 구간(구간 합 쿼리) 단위로 나누어 저장하는 이진트리 기반의 자료구조입니다.

세그먼트 트리의 정의

세그먼트 트리는 다음과 같은 속성을 가집니다:

  • 각 노드는 하나의 배열 구간에 대한 정보를 저장합니다. 이 정보는 구간의 합 혹은 최소, 최대 등으로 설정할 수 있습니다.
  • 트리의 높이는 O(log n)이며, 이는 쿼리 연산과 업데이트 연산 모두에 대해 O(log n)의 시간이 소요됨을 의미합니다.

세그먼트 트리 구현 단계

세그먼트 트리를 구현하기 위해 다음과 같은 절차를 따릅니다:

  1. 초기화: 주어진 배열을 기반으로 세그먼트 트리를 초기화합니다.
  2. 구간 합 쿼리: 특정 구간의 합을 계산하기 위해 필요한 레벨의 노드들을 재귀적으로 가져옵니다.
  3. 업데이트: 특정 인덱스의 값을 업데이트하고 관련 세그먼트 노드들을 갱신합니다.

JavaScript 코드 구현


class SegmentTree {
    constructor(arr) {
        this.n = arr.length;
        this.tree = new Array(this.n * 4);
        this.build(arr, 0, 0, this.n - 1);
    }

    build(arr, node, start, end) {
        if (start === end) {
            // 리프 노드에 정수 값 저장
            this.tree[node] = arr[start];
        } else {
            const mid = Math.floor((start + end) / 2);
            // 왼쪽 자식 정의
            this.build(arr, node * 2 + 1, start, mid);
            // 오른쪽 자식 정의
            this.build(arr, node * 2 + 2, mid + 1, end);
            // 부모 노드는 두 자식의 합으로 정의
            this.tree[node] = this.tree[node * 2 + 1] + this.tree[node * 2 + 2];
        }
    }

    rangeSum(left, right) {
        return this.sum(0, 0, this.n - 1, left, right);
    }

    sum(node, start, end, left, right) {
        if (right < start || end < left) {
            // 요청된 범위와 겹치지 않으면 0 반환
            return 0;
        }
        if (left <= start && end <= right) {
            // 요청된 범위가 구간 안에 포함되면 노드 반환
            return this.tree[node];
        }
        const mid = Math.floor((start + end) / 2);
        const leftSum = this.sum(node * 2 + 1, start, mid, left, right);
        const rightSum = this.sum(node * 2 + 2, mid + 1, end, left, right);
        return leftSum + rightSum;
    }

    update(index, value) {
        this.updateValue(0, 0, this.n - 1, index, value);
    }

    updateValue(node, start, end, index, value) {
        if (start === end) {
            // 리프 노드 업데이트
            this.tree[node] = value;
        } else {
            const mid = Math.floor((start + end) / 2);
            if (index <= mid) {
                this.updateValue(node * 2 + 1, start, mid, index, value);
            } else {
                this.updateValue(node * 2 + 2, mid + 1, end, index, value);
            }
            // 부모 노드 업데이트
            this.tree[node] = this.tree[node * 2 + 1] + this.tree[node * 2 + 2];
        }
    }
}

// 사용 예시
const arr = [1, 3, 5, 7, 9, 11];
const segmentTree = new SegmentTree(arr);
console.log(segmentTree.rangeSum(1, 3)); // 15
segmentTree.update(1, 10);
console.log(segmentTree.rangeSum(1, 3)); // 22

결론

세그먼트 트리는 배열의 구간 합을 효율적으로 처리할 수 있는 강력한 도구입니다.
이 자료구조를 통해 O(log n)의 시간복잡도로 알림 처리 및 구간 합 계산이 가능합니다.
실전에서의 복잡한 문제들이 요구할 때, 세그먼트 트리를 활용하여 많은 이점을 얻을 수 있습니다.

추가 연습 문제

다음 문제들을 연습해 보세요:

  • 세그먼트 트리를 사용하여 주어진 배열의 최소값 구하기
  • 구간에서 특정 값을 더하는 쿼리 추가
  • 세그먼트 트리로 최대값 구하기

자바스크립트 코딩테스트 강좌, 확장 유클리드 호제법

안녕하세요, 여러분! 오늘은 자바스크립트를 사용한 코딩테스트에서 중요한 알고리즘 중 하나인 확장 유클리드 호제법(Extended Euclidean Algorithm)에 대해 알아보겠습니다. 이 강좌에서는 확장 유클리드 호제법의 개념, 이를 이용한 문제풀이 과정, 그리고 실질적인 코드 예제를 제공합니다.

1. 문제 설명

문제를 다음과 같이 정의하겠습니다. 두 정수 A와 B가 주어지면, AX + BY = GCD(A, B)를 만족하는 정수 X와 Y를 구하는 문제입니다. 여기서 GCD는 최대공약수를 의미합니다.

예제

입력: A = 30, B = 21

출력: X = 1, Y = -1, GCD = 3

풀이: 30 * 1 + 21 * (-1) = 3

2. 개념 설명

확장 유클리드 호제법은 두 정수의 최대공약수(GCD)를 계산할 뿐만 아니라, 이로부터 특정 계수들을 찾는 방법입니다. 이는 주로 다음의 수식에서 사용됩니다:

AX + BY = GCD(A, B)

여기서 A와 B는 주어진 두 정수, X와 Y는 우리가 찾고자 하는 정수입니다. 만약 GCD가 1이라면, A와 B는 서로 소이므로 X와 Y는 모듈러 역수를 찾는 데에도 사용됩니다.

3. 접근 방법

우리는 GCD를 구하는 일반적인 유클리드 알고리즘을 기반으로 확장 유클리드 알고리즘을 구현할 것입니다. 알고리즘의 주요 아이디어는 다음과 같습니다:

  1. 두 정수 A와 B를 입력받습니다.
  2. If B는 0이면, GCD는 A이며, X는 1, Y는 0입니다.
  3. 그렇지 않으면, 유클리드 호제법을 사용하여 B와 A % B로 재귀 호출합니다.
  4. 재귀 호출의 결과를 이용해 X와 Y의 값을 계산합니다.

4. 알고리즘 구현

다음은 확장 유클리드 알고리즘을 자바스크립트로 구현한 예제입니다:


function extendedGCD(a, b) {
    if (b === 0) { // Base case
        return { gcd: a, x: 1, y: 0 };
    }
    // Recur with the new parameters b and a % b
    const { gcd, x: x1, y: y1 } = extendedGCD(b, a % b);
    const x = y1;
    const y = x1 - Math.floor(a / b) * y1;
    return { gcd, x, y };
}

// Test the function with example values
const a = 30;
const b = 21;
const { gcd, x, y } = extendedGCD(a, b);
console.log(`GCD: ${gcd}, X: ${x}, Y: ${y}`);

5. 코드 설명

위 코드에서 우리는 재귀적으로 GCD를 구하고 있습니다. 기본 조건에서는 B가 0일 때 GCD는 A가 되고, 이 때 X는 1, Y는 0이 됩니다. 그 후, 반환된 X와 Y 값을 이용해 새로운 X와 Y를 계산하여 최종적으로 우리가 원하는 결과를 얻습니다.

6. 테스트 케이스

이제 다양한 테스트 케이스를 통해 위의 함수를 검증해보겠습니다.


// Test cases
const testCases = [
    { a: 30, b: 21 },
    { a: 48, b: 18 },
    { a: 56, b: 15 },
    { a: 101, b: 10 },
];

testCases.forEach(({ a, b }) => {
    const { gcd, x, y } = extendedGCD(a, b);
    console.log(`A: ${a}, B: ${b} => GCD: ${gcd}, X: ${x}, Y: ${y}`);
});

7. 정리

오늘은 확장 유클리드 호제법에 대해 알아보았습니다. 이 알고리즘은 두 정수의 최대공약수를 구하고, 이에 대한 특정 계수를 찾는 데 매우 유용합니다. 특히 모듈러 연산이나 복잡한 알고리즘 문제에서 종종 활용되므로, 충분히 이해하고 연습하는 것이 중요합니다.

이 글에서 사용한 알고리즘이 여러분의 코딩 시험 준비에 도움이 되길 바랍니다. 추가 질문이 있다면 댓글로 남겨주세요!

자바스크립트 코딩테스트 강좌, 트리 순회하기

개요

코딩테스트에서는 다양한 자료구조와 알고리즘 문제가 출제됩니다. 그 중 트리는 자주 등장하는 자료구조입니다.
트리 구조는 컴퓨터 과학에서 매우 중요한 역할을 하며, 파일 시스템, 데이터베이스 등의 다양한 분야에서 활용됩니다.
이 강좌에서는 자바스크립트를 이용하여 트리를 순회하는 방법에 대해 배워보겠습니다.

트리 구조란?

트리(Tree)란 노드(Node)와 엣지(Edge)로 구성된 비선형 데이터 구조로, 계층적인 관계를 표현하는 데 최적화되어 있습니다.
트리는 루트 노드(root node)와 자식 노드(child node), 부모 노드(parent node), 잎 노드(leaf node) 등의 개념을 가지고 있습니다.

트리의 주요 특징은 다음과 같습니다:

  • 트리는 하나의 루트를 가지고 있으며, 자식 노드들이 이 루트로부터 연결됩니다.
  • 노드는 0개 이상의 자식 노드를 가질 수 있습니다.
  • 리프 노드는 자식이 없는 노드입니다.

트리의 순회 방법

트리를 순회하는 방법에는 여러 가지가 있으며, 가장 일반적으로 사용되는 방식은 다음과 같습니다:

  • 전위 순회(Pre-order Traversal)
  • 중위 순회(In-order Traversal)
  • 후위 순회(Post-order Traversal)
  • 레벨 순회(Level-order Traversal)

각각의 순회 방법은 노드를 방문하는 순서가 다릅니다. 각 방법에 대해 자세히 살펴보겠습니다.

전위 순회(Pre-order Traversal)

전위 순회의 방식은 다음과 같습니다:

  1. 현재 노드를 방문한다.
  2. 왼쪽 서브트리를 전위 순회한다.
  3. 오른쪽 서브트리를 전위 순회한다.

예를 들어, 다음과 같은 트리 구조가 있다고 가정해봅시다.

                공공
                ├── 사용자 1
                │   ├── 사용자 1.1
                │   └── 사용자 1.2
                └── 사용자 2
                    ├── 사용자 2.1
                    └── 사용자 2.2
                

전위 순회 결과는 “공공, 사용자 1, 사용자 1.1, 사용자 1.2, 사용자 2, 사용자 2.1, 사용자 2.2″입니다.

중위 순회(In-order Traversal)

중위 순회의 방식은 다음과 같습니다:

  1. 왼쪽 서브트리를 중위 순회한다.
  2. 현재 노드를 방문한다.
  3. 오른쪽 서브트리를 중위 순회한다.

예를 들어, 같은 트리 구조에서 중위 순회 결과는 “사용자 1.1, 사용자 1, 사용자 1.2, 공공, 사용자 2.1, 사용자 2, 사용자 2.2″입니다.

후위 순회(Post-order Traversal)

후위 순회의 방식은 다음과 같습니다:

  1. 왼쪽 서브트리를 후위 순회한다.
  2. 오른쪽 서브트리를 후위 순회한다.
  3. 현재 노드를 방문한다.

같은 트리 구조에서 후위 순회 결과는 “사용자 1.1, 사용자 1.2, 사용자 1, 사용자 2.1, 사용자 2.2, 사용자 2, 공공”입니다.

레벨 순회(Level-order Traversal)

레벨 순회의 방식은 다음과 같습니다:

  1. 루트 노드를 방문한다.
  2. 현재 노드의 자식 노드들을 방문한다.
  3. 모든 자식 노드를 방문한 후, 다음 깊이로 이동한다.

같은 트리 구조에서 레벨 순회 결과는 “공공, 사용자 1, 사용자 2, 사용자 1.1, 사용자 1.2, 사용자 2.1, 사용자 2.2″입니다.

프로그래밍 문제: 이진 트리 순회

다음과 같은 이진 트리 구조가 주어졌을 때, 다양한 순회 방법을 이용하여 트리를 순회하는 함수를 작성하시오.
이진 트리는 다음과 같은 노드로 구성됩니다:

            class TreeNode {
                constructor(value) {
                    this.value = value;
                    this.left = null;
                    this.right = null;
                }
            }
            

입력 예시:

            const root = new TreeNode(1);
            root.left = new TreeNode(2);
            root.right = new TreeNode(3);
            root.left.left = new TreeNode(4);
            root.left.right = new TreeNode(5);
            

문제

위의 트리를 전위 순회, 중위 순회, 후위 순회, 레벨 순회하는 함수를 각각 작성하시오.

문제 풀이 과정

1. 전위 순회 구현

전위 순회를 수행하기 위해서는 재귀적 접근이 필요합니다. 아래는 이를 구현한 코드입니다:

            function preOrderTraversal(node) {
                if (node === null) return;
                console.log(node.value); // 현재 노드 방문
                preOrderTraversal(node.left); // 왼쪽 서브트리 방문
                preOrderTraversal(node.right); // 오른쪽 서브트리 방문
            }
            

위 코드는 노드를 순회하면서 현재 노드를 먼저 방문한 후 왼쪽과 오른쪽 노드를 순회합니다.

2. 중위 순회 구현

중위 순회도 재귀적으로 구현합니다. 아래는 중위 순회 코드입니다:

            function inOrderTraversal(node) {
                if (node === null) return;
                inOrderTraversal(node.left); // 왼쪽 서브트리 방문
                console.log(node.value); // 현재 노드 방문
                inOrderTraversal(node.right); // 오른쪽 서브트리 방문
            }
            

이 코드는 왼쪽 서브트리를 먼저 방문한 후 현재 노드를 방문합니다.

3. 후위 순회 구현

후위 순회 역시 재귀적으로 구현합니다. 다음은 구현된 코드입니다:

            function postOrderTraversal(node) {
                if (node === null) return;
                postOrderTraversal(node.left); // 왼쪽 서브트리 방문
                postOrderTraversal(node.right); // 오른쪽 서브트리 방문
                console.log(node.value); // 현재 노드 방문
            }
            

후위 순회에서는 두 자식 서브트리를 방문한 후에 현재 노드를 방문합니다.

4. 레벨 순회 구현

레벨 순회는 큐 자료구조를 이용하여 구현합니다. 큐를 사용하면 각 노드를 층층이 방문할 수 있습니다. 다음은 레벨 순회 코드입니다:

            function levelOrderTraversal(root) {
                if (root === null) return;
                const queue = [root]; // 큐 초기화
                while (queue.length > 0) {
                    const current = queue.shift(); // 큐에서 노드 제거
                    console.log(current.value); // 현재 노드 방문
                    if (current.left) queue.push(current.left); // 왼쪽 자식 추가
                    if (current.right) queue.push(current.right); // 오른쪽 자식 추가
                }
            }
            

큐를 통해 각 노드를 레벨별로 차례대로 방문할 수 있습니다.

결론

이 강좌에서는 자바스크립트를 활용하여 트리를 순회하는 다양한 방법에 대해 알아보았습니다.
트리 순회는 많은 프로그래밍 문제에서 기본적인 부분을 차지하므로, 충분히 연습하는 것이 중요합니다.
위에서 다룬 전위, 중위, 후위, 레벨 순회 알고리즘을 잘 이해하고 구현하는 것이 코딩테스트에서 좋은 성과를 낼 수 있는 방법입니다.

앞으로도 연습을 통해 다양한 알고리즘 문제를 해결해보세요. 연습과 반복은 최고의 스승입니다!

자바스크립트 코딩테스트 강좌, 계단 수 구하기

안녕하세요, 오늘은 자바스크립트 코딩테스트 준비에 유용한 알고리즘 문제 중 하나인 “계단 수 구하기”를 풀어보겠습니다. 이 문제는 동적 프로그래밍(Dynamic Programming)과 조합적으로 접근할 수 있는 흥미로운 문제입니다. 이 글에서는 문제 설명, 풀이 과정, 그리고 최적화 방안을 포함하여 자세히 설명하겠습니다.

문제 설명

계단 수는 n 자리 수 중, 인접한 두 자리의 차이가 1인 수를 의미합니다. 예를 들어, 123, 321과 같이 인접한 자리의 숫자 차이가 1일 경우 이 수는 계단 수입니다. 주어진 n에 대해 n 자리 계단 수를 구하는 프로그램을 작성하세요.

입력

정수 n (1 ≤ n ≤ 1000)

출력

n 자리의 계단 수의 개수를 1,000,000,000으로 나눈 나머지를 출력합니다.

문제 풀이 전략

이 문제를 해결하기 위해서는 동적 프로그래밍 접근 방식을 사용할 수 있습니다. 계단 수는 다음과 같이 상태를 정의하여 해결할 수 있습니다:

  • dp[i][j]: i자리 계단 수 중, j로 끝나는 수의 개수

계단 수를 구성하는 규칙을 다음과 같이 세울 수 있습니다:

  • j가 0일 때(0으로 시작하는 수 없음): dp[i][0] = dp[i-1][1]
  • j가 9일 때: dp[i][9] = dp[i-1][8]
  • 그 외의 경우: dp[i][j] = dp[i-1][j-1] + dp[i-1][j+1]

동적 프로그래밍 테이블 초기화

이제 dp 테이블을 초기화해보겠습니다. 1자리 수의 경우, 숫자는 0부터 9까지 가능하므로 dp[1][0] 부터 dp[1][9]까지 각각 1로 초기화합니다.

풀이 코드


function countStairNumbers(n) {
    const MOD = 1000000000;
    const dp = Array.from({ length: n + 1 }, () => Array(10).fill(0));

    // 1자리 수 초기화
    for (let j = 0; j < 10; j++) {
        dp[1][j] = 1;
    }

    // dp 테이블 채우기
    for (let i = 2; i <= n; i++) {
        for (let j = 0; j < 10; j++) {
            if (j > 0) dp[i][j] += dp[i - 1][j - 1]; // j-1에서 이동
            if (j < 9) dp[i][j] += dp[i - 1][j + 1]; // j+1에서 이동
            dp[i][j] %= MOD; // modulo 연산
        }
    }

    // n자리 모든 계단 수의 합
    let result = 0;
    for (let j = 0; j < 10; j++) {
        result += dp[n][j];
    }

    return result % MOD;
}

// 함수 호출 예시
console.log(countStairNumbers(3)); // 24

시간 복잡도

위 코드의 시간 복잡도는 O(n)이며, 공간 복잡도는 O(n)입니다. 각 자리 수의 조합을 통해 결과를 도출하기 때문에 n이 커질수록 시간과 공간을 효율적으로 사용할 수 있습니다.

최적화 방안

현재 구현된 코드에서 메모리 사용량을 줄이기 위해 dp 배열을 2차원에서 1차원으로 변경할 수 있습니다. 각 i에 대해 이전의 dp 상태만 필요하기 때문에, 이를 이용해 최적화할 수 있습니다.


function countStairNumbersOptimized(n) {
    const MOD = 1000000000;
    const dp = Array(10).fill(0);
    const temp = Array(10).fill(0);

    // 1자리 수 초기화
    for (let j = 0; j < 10; j++) {
        dp[j] = 1;
    }

    for (let i = 2; i <= n; i++) {
        for (let j = 0; j < 10; j++) {
            temp[j] = 0;
            if (j > 0) temp[j] += dp[j - 1]; // j-1에서 이동
            if (j < 9) temp[j] += dp[j + 1]; // j+1에서 이동
            temp[j] %= MOD; // modulo 연산
        }
        for (let j = 0; j < 10; j++) {
            dp[j] = temp[j]; // 다음 단계로 업데이트
        }
    }

    // n자리 모든 계단 수의 합
    let result = 0;
    for (let j = 0; j < 10; j++) {
        result += dp[j];
    }

    return result % MOD;
}

마치며

이번 글에서는 “계단 수 구하기” 문제를 통해 자바스크립트로 동적 프로그래밍을 활용하여 문제를 해결하는 방법을 배웠습니다. 초기화, dp 테이블 구성, 그리고 최적화 과정을 자세히 설명하였으며, 다양한 테크닉을 사용하여 알고리즘의 효율성을 높일 수 있는 방법도 소개하였습니다. 알고리즘 문제를 풀 때는 항상 다양한 접근 방식을 고민하고 최적화할 방안을 모색해 보세요. 감사합니다!