Red

• 메모 조회에 대한 필수 값 누락에 대한 테스트 진행

  • 단건 조회

    • id 필요
    • 없는 id 에러, 범위 검증
    • 객체 1개 반환
      • 코드

        const { readMemo } = require("../../src/memo/readMemo");
        

    describe("readMemo", () => { test("정상 id이면 memo 단건 조회에 성공한다", async () => {

    const result = await readMemo(1);
    
    expect(result).toMatchObject({
      id: 1,
      title: "TDD 메모 작성",
      period: {
        startDate: "2026-03-06",
        endDate: "2026-03-10",
      },
      content: "첫 번째 메모",
      priority: 3,
      isSuccess: false,
    });

    });

    test("id가 없으면 에러 발생", async () => {

    await expect(readMemo()).rejects.toThrow("id");

    });

    test("id가 null이면 에러 발생", async () => {

    await expect(readMemo(null)).rejects.toThrow("id");

    });

    test("id가 문자열이면 에러 발생", async () => {

    await expect(readMemo("1")).rejects.toThrow("id");

    });

    test("id가 0이면 에러 발생", async () => {

    await expect(readMemo(0)).rejects.toThrow("id");

    });

    test("id가 음수이면 에러 발생", async () => {

    await expect(readMemo(-1)).rejects.toThrow("id");

    });

    test("존재하지 않는 id이면 에러 발생", async () => {

    await expect(readMemo(999)).rejects.toThrow("memo");

    }); });

• 실행 로그 ``` hongseongchae@hongseongchaeui-MacBookPro tdd_study % npm test

  tdd_study@1.0.0 test jest

  FAIL test/memo/readMemo.test.js

  ● readMemo › 정상 id이면 memo 단건 조회에 성공한다
  
    TypeError: readMemo is not a function
  
      3 | describe("readMemo", () => {
      4 |   test("정상 id이면 memo 단건 조회에 성공한다", async () => {
    > 5 |     const result = await readMemo(1);
        |                          ^
      6 |
      7 |     expect(result).toMatchObject({
      8 |       id: 1,
  
      at Object.readMemo (__test__/memo/readMemo.test.js:5:26)
  
  ● readMemo › id가 없으면 에러 발생
  
    TypeError: readMemo is not a function
  
      19 |
      20 |   test("id가 없으면 에러 발생", async () => {
    > 21 |     await expect(readMemo()).rejects.toThrow("id");
         |                  ^
      22 |   });
      23 |
      24 |   test("id가 null이면 에러 발생", async () => {
  
      at Object.readMemo (__test__/memo/readMemo.test.js:21:18)
  
  ● readMemo › id가 null이면 에러 발생
  
    TypeError: readMemo is not a function
  
      23 |
      24 |   test("id가 null이면 에러 발생", async () => {
    > 25 |     await expect(readMemo(null)).rejects.toThrow("id");
         |                  ^
      26 |   });
      27 |
      28 |   test("id가 문자열이면 에러 발생", async () => {
  
      at Object.readMemo (__test__/memo/readMemo.test.js:25:18)
  
  ● readMemo › id가 문자열이면 에러 발생
  
    TypeError: readMemo is not a function
  
      27 |
      28 |   test("id가 문자열이면 에러 발생", async () => {
    > 29 |     await expect(readMemo("1")).rejects.toThrow("id");
         |                  ^
      30 |   });
      31 |
      32 |   test("id가 0이면 에러 발생", async () => {
  
      at Object.readMemo (__test__/memo/readMemo.test.js:29:18)
  
  ● readMemo › id가 0이면 에러 발생
  
    TypeError: readMemo is not a function
  
      31 |
      32 |   test("id가 0이면 에러 발생", async () => {
    > 33 |     await expect(readMemo(0)).rejects.toThrow("id");
         |                  ^
      34 |   });
      35 |
      36 |   test("id가 음수이면 에러 발생", async () => {
  
      at Object.readMemo (__test__/memo/readMemo.test.js:33:18)
  
  ● readMemo › id가 음수이면 에러 발생
  
    TypeError: readMemo is not a function
  
      35 |
      36 |   test("id가 음수이면 에러 발생", async () => {
    > 37 |     await expect(readMemo(-1)).rejects.toThrow("id");
         |                  ^
      38 |   });
      39 |
      40 |   test("존재하지 않는 id이면 에러 발생", async () => {
  
      at Object.readMemo (__test__/memo/readMemo.test.js:37:18)
  
  ● readMemo › 존재하지 않는 id이면 에러 발생
  
    TypeError: readMemo is not a function
  
      39 |
      40 |   test("존재하지 않는 id이면 에러 발생", async () => {
    > 41 |     await expect(readMemo(999)).rejects.toThrow("memo");
         |                  ^
      42 |   });
      43 | });
      44 |
  
      at Object.readMemo (__test__/memo/readMemo.test.js:41:18)

  PASS test/memo/createMemo.test.js

  Test Suites: 1 failed, 1 passed, 2 total Tests: 7 failed, 16 passed, 23 total Snapshots: 0 total Time: 0.498 s, estimated 1 s Ran all test suites.

• 리스트 조회

  • page 필요

  • pageSize 필요

  • page 타입 검증

  • pageSize 타입 검증

  • page 범위 검증 (1 이상)

  • pageSize 범위 검증 (1 이상)

  • isSuccess 필터

    • boolean 타입 검증
    • true → 성공 메모만 조회
    • false → 진행 중 메모 조회

  • priority 필터

    • 숫자 타입 검증
    • 범위 검증 (1 ~ 5)
    • priority 값에 해당하는 메모만 조회

  • 코드 ``` const { listMemo } = require("../../src/memo/readMemo");

    describe("listMemo", () => { test("page와 pageSize가 정상 입력이면 memo 목록 조회에 성공한다", async () => {

    const result = await listMemo({
      page: 1,
      pageSize: 10,
    });
    
    expect(Array.isArray(result)).toBe(true);

    });

    test("page가 없으면 에러 발생", async () => {

    await expect(
      listMemo({
        pageSize: 10,
      }),
    ).rejects.toThrow("page");

    });

    test("pageSize가 없으면 에러 발생", async () => {

    await expect(
      listMemo({
        page: 1,
      }),
    ).rejects.toThrow("pageSize");

    });

    test("page가 숫자가 아니면 에러 발생", async () => {

    await expect(
      listMemo({
        page: "1",
        pageSize: 10,
      }),
    ).rejects.toThrow("page");

    });

    test("pageSize가 숫자가 아니면 에러 발생", async () => {

    await expect(
      listMemo({
        page: 1,
        pageSize: "10",
      }),
    ).rejects.toThrow("pageSize");

    });

    test("page가 1보다 작으면 에러 발생", async () => {

    await expect(
      listMemo({
        page: 0,
        pageSize: 10,
      }),
    ).rejects.toThrow("page");

    });

    test("pageSize가 1보다 작으면 에러 발생", async () => {

    await expect(
      listMemo({
        page: 1,
        pageSize: 0,
      }),
    ).rejects.toThrow("pageSize");

    });

    test("isSuccess가 boolean이 아니면 에러 발생", async () => {

    await expect(
      listMemo({
        page: 1,
        pageSize: 10,
        isSuccess: "true",
      }),
    ).rejects.toThrow("isSuccess");

    });

    test("isSuccess가 true이면 성공한 메모만 조회", async () => {

    const result = await listMemo({
      page: 1,
      pageSize: 10,
      isSuccess: true,
    });
    
    expect(Array.isArray(result)).toBe(true);
    result.forEach((memo) => {
      expect(memo.isSuccess).toBe(true);
    });

    });

    test("isSuccess가 false이면 진행 중 메모만 조회", async () => {

    const result = await listMemo({
      page: 1,
      pageSize: 10,
      isSuccess: false,
    });
    
    expect(Array.isArray(result)).toBe(true);
    result.forEach((memo) => {
      expect(memo.isSuccess).toBe(false);
    });

    });

    test("priority가 숫자가 아니면 에러 발생", async () => {

    await expect(
      listMemo({
        page: 1,
        pageSize: 10,
        priority: "3",
      }),
    ).rejects.toThrow("priority");

    });

    test("priority가 1보다 작으면 에러 발생", async () => {

    await expect(
      listMemo({
        page: 1,
        pageSize: 10,
        priority: 0,
      }),
    ).rejects.toThrow("priority");

    });

    test("priority가 5보다 크면 에러 발생", async () => {

    await expect(
      listMemo({
        page: 1,
        pageSize: 10,
        priority: 6,
      }),
    ).rejects.toThrow("priority");

    });

    test("priority가 주어지면 해당 priority 메모만 조회", async () => {

    const result = await listMemo({
      page: 1,
      pageSize: 10,
      priority: 3,
    });
    
    expect(Array.isArray(result)).toBe(true);
    result.forEach((memo) => {
      expect(memo.priority).toBe(3);
    });

    }); });

• 실행 로그 ``` hongseongchae@hongseongchaeui-MacBookPro tdd_study % npm test

  tdd_study@1.0.0 test jest

  PASS test/memo/createMemo.test.js PASS test/memo/readMemo.test.js FAIL test/memo/readMemoList.test.js ● listMemo › page와 pageSize가 정상 입력이면 memo 목록 조회에 성공한다

  TypeError: listMemo is not a function
  
    3 | describe("listMemo", () => {
    4 |   test("page와 pageSize가 정상 입력이면 memo 목록 조회에 성공한다", async () => {
  > 5 |     const result = await listMemo({
      |                          ^
    6 |       page: 1,
    7 |       pageSize: 10,
    8 |     });
  
    at Object.listMemo (__test__/memo/readMemoList.test.js:5:26)

  ● listMemo › page가 없으면 에러 발생

  TypeError: listMemo is not a function
  
    13 |   test("page가 없으면 에러 발생", async () => {
    14 |     await expect(
  > 15 |       listMemo({
       |       ^
    16 |         pageSize: 10,
    17 |       }),
    18 |     ).rejects.toThrow("page");
  
    at Object.listMemo (__test__/memo/readMemoList.test.js:15:7)

  ● listMemo › pageSize가 없으면 에러 발생

  TypeError: listMemo is not a function
  
    21 |   test("pageSize가 없으면 에러 발생", async () => {
    22 |     await expect(
  > 23 |       listMemo({
       |       ^
    24 |         page: 1,
    25 |       }),
    26 |     ).rejects.toThrow("pageSize");
  
    at Object.listMemo (__test__/memo/readMemoList.test.js:23:7)

  ● listMemo › page가 숫자가 아니면 에러 발생

  TypeError: listMemo is not a function
  
    29 |   test("page가 숫자가 아니면 에러 발생", async () => {
    30 |     await expect(
  > 31 |       listMemo({
       |       ^
    32 |         page: "1",
    33 |         pageSize: 10,
    34 |       }),
  
    at Object.listMemo (__test__/memo/readMemoList.test.js:31:7)

  ● listMemo › pageSize가 숫자가 아니면 에러 발생

  TypeError: listMemo is not a function
  
    38 |   test("pageSize가 숫자가 아니면 에러 발생", async () => {
    39 |     await expect(
  > 40 |       listMemo({
       |       ^
    41 |         page: 1,
    42 |         pageSize: "10",
    43 |       }),
  
    at Object.listMemo (__test__/memo/readMemoList.test.js:40:7)

  ● listMemo › page가 1보다 작으면 에러 발생

  TypeError: listMemo is not a function
  
    47 |   test("page가 1보다 작으면 에러 발생", async () => {
    48 |     await expect(
  > 49 |       listMemo({
       |       ^
    50 |         page: 0,
    51 |         pageSize: 10,
    52 |       }),
  
    at Object.listMemo (__test__/memo/readMemoList.test.js:49:7)

  ● listMemo › pageSize가 1보다 작으면 에러 발생

  TypeError: listMemo is not a function
  
    56 |   test("pageSize가 1보다 작으면 에러 발생", async () => {
    57 |     await expect(
  > 58 |       listMemo({
       |       ^
    59 |         page: 1,
    60 |         pageSize: 0,
    61 |       }),
  
    at Object.listMemo (__test__/memo/readMemoList.test.js:58:7)

  ● listMemo › isSuccess가 boolean이 아니면 에러 발생

  TypeError: listMemo is not a function
  
    65 |   test("isSuccess가 boolean이 아니면 에러 발생", async () => {
    66 |     await expect(
  > 67 |       listMemo({
       |       ^
    68 |         page: 1,
    69 |         pageSize: 10,
    70 |         isSuccess: "true",
  
    at Object.listMemo (__test__/memo/readMemoList.test.js:67:7)

  ● listMemo › isSuccess가 true이면 성공한 메모만 조회

  TypeError: listMemo is not a function
  
    74 |
    75 |   test("isSuccess가 true이면 성공한 메모만 조회", async () => {
  > 76 |     const result = await listMemo({
       |                          ^
    77 |       page: 1,
    78 |       pageSize: 10,
    79 |       isSuccess: true,
  
    at Object.listMemo (__test__/memo/readMemoList.test.js:76:26)

  ● listMemo › isSuccess가 false이면 진행 중 메모만 조회

  TypeError: listMemo is not a function
  
    87 |
    88 |   test("isSuccess가 false이면 진행 중 메모만 조회", async () => {
  > 89 |     const result = await listMemo({
       |                          ^
    90 |       page: 1,
    91 |       pageSize: 10,
    92 |       isSuccess: false,
  
    at Object.listMemo (__test__/memo/readMemoList.test.js:89:26)

  ● listMemo › priority가 숫자가 아니면 에러 발생

  TypeError: listMemo is not a function
  
    101 |   test("priority가 숫자가 아니면 에러 발생", async () => {
    102 |     await expect(
  > 103 |       listMemo({
        |       ^
    104 |         page: 1,
    105 |         pageSize: 10,
    106 |         priority: "3",
  
    at Object.listMemo (__test__/memo/readMemoList.test.js:103:7)

  ● listMemo › priority가 1보다 작으면 에러 발생

  TypeError: listMemo is not a function
  
    111 |   test("priority가 1보다 작으면 에러 발생", async () => {
    112 |     await expect(
  > 113 |       listMemo({
        |       ^
    114 |         page: 1,
    115 |         pageSize: 10,
    116 |         priority: 0,
  
    at Object.listMemo (__test__/memo/readMemoList.test.js:113:7)

  ● listMemo › priority가 5보다 크면 에러 발생

  TypeError: listMemo is not a function
  
    121 |   test("priority가 5보다 크면 에러 발생", async () => {
    122 |     await expect(
  > 123 |       listMemo({
        |       ^
    124 |         page: 1,
    125 |         pageSize: 10,
    126 |         priority: 6,
  
    at Object.listMemo (__test__/memo/readMemoList.test.js:123:7)

  ● listMemo › priority가 주어지면 해당 priority 메모만 조회

  TypeError: listMemo is not a function
  
    130 |
    131 |   test("priority가 주어지면 해당 priority 메모만 조회", async () => {
  > 132 |     const result = await listMemo({
        |                          ^
    133 |       page: 1,
    134 |       pageSize: 10,
    135 |       priority: 3,
  
    at Object.listMemo (__test__/memo/readMemoList.test.js:132:26)

  Test Suites: 1 failed, 2 passed, 3 total Tests: 14 failed, 23 passed, 37 total Snapshots: 0 total Time: 0.488 s, estimated 1 s Ran all test suites.

  Green

• 단건 조회

  • 코드 ``` async function readMemo(id) { if (typeof id !== "number" || id <= 0) {

    throw new Error("id");

    }

    const mockMemos = [

    {
      id: 1,
      title: "TDD 메모 작성",
      period: {
        startDate: "2026-03-06",
        endDate: "2026-03-10",
      },
      content: "조회 테스트용 메모",
      priority: 3,
      isSuccess: false,
    },
    {
      id: 2,
      title: "두 번째 메모",
      period: {
        startDate: "2026-03-07",
        endDate: "2026-03-12",
      },
      content: "두 번째 조회 테스트용 메모",
      priority: 2,
      isSuccess: false,
    },

    ];

    const memo = mockMemos.find((item) => item.id === id);

    if (!memo) {

    throw new Error("memo");

    }

    return memo; }

    module.exports = { readMemo };

  • 리스트 조회

• 코드

  async function readMemo(id) {
    if (typeof id !== "number" || id <= 0) {
      throw new Error("id");
    }
  
    const mockMemos = [
      {
        id: 1,
        title: "TDD 메모 작성",
        period: {
          startDate: "2026-03-06",
          endDate: "2026-03-10",
        },
        content: "조회 테스트용 메모",
        priority: 3,
        isSuccess: false,
      },
      {
        id: 2,
        title: "두 번째 메모",
        period: {
          startDate: "2026-03-07",
          endDate: "2026-03-12",
        },
        content: "두 번째 조회 테스트용 메모",
        priority: 2,
        isSuccess: false,
      },
    ];
  
    const memo = mockMemos.find((item) => item.id === id);
  
    if (!memo) {
      throw new Error("memo");
    }
  
    return memo;
  }
  async function listMemo(query) {
    const { page, pageSize, isSuccess, priority } = query;
  
    if (typeof page !== "number" || page < 1) {
      throw new Error("page");
    }
  
    if (typeof pageSize !== "number" || pageSize < 1) {
      throw new Error("pageSize");
    }
  
    if (isSuccess !== undefined && typeof isSuccess !== "boolean") {
      throw new Error("isSuccess");
    }
  
    if (priority !== undefined) {
      if (typeof priority !== "number" || priority < 1 || priority > 5) {
        throw new Error("priority");
      }
    }
  
    const mockMemos = [
      {
        id: 1,
        title: "TDD 메모 작성",
        period: {
          startDate: "2026-03-06",
          endDate: "2026-03-10",
        },
        content: "첫 번째 메모",
        priority: 3,
        isSuccess: false,
      },
      {
        id: 2,
        title: "두 번째 메모",
        period: {
          startDate: "2026-03-07",
          endDate: "2026-03-12",
        },
        content: "두 번째 내용",
        priority: 2,
        isSuccess: true,
      },
      {
        id: 3,
        title: "세 번째 메모",
        period: {
          startDate: "2026-03-08",
          endDate: "2026-03-15",
        },
        content: "세 번째 내용",
        priority: 3,
        isSuccess: true,
      },
      {
        id: 4,
        title: "네 번째 메모",
        period: {
          startDate: "2026-03-09",
          endDate: "2026-03-18",
        },
        content: "네 번째 내용",
        priority: 1,
        isSuccess: false,
      },
    ];
  
    let result = mockMemos;
  
    if (isSuccess !== undefined) {
      result = result.filter((memo) => memo.isSuccess === isSuccess);
    }
  
    if (priority !== undefined) {
      result = result.filter((memo) => memo.priority === priority);
    }
  
    const startIndex = (page - 1) * pageSize;
    const endIndex = startIndex + pageSize;
  
    return result.slice(startIndex, endIndex);
  }
  
  module.exports = { readMemo, listMemo };
  

• 실행 로그

  • 단건 조회

      hongseongchae@hongseongchaeui-MacBookPro tdd_study % npm test
    
      > tdd_study@1.0.0 test
      > jest
    
       PASS  __test__/memo/readMemo.test.js
       PASS  __test__/memo/createMemo.test.js
    
      Test Suites: 2 passed, 2 total
      Tests:       23 passed, 23 total
      Snapshots:   0 total
      Time:        0.411 s, estimated 1 s
      Ran all test suites.
    - 리스트 조회

    hongseongchae@hongseongchaeui-MacBookPro tdd_study % npm test

    tdd_study@1.0.0 test jest

    PASS test/memo/readMemoList.test.js PASS test/memo/createMemo.test.js PASS test/memo/readMemo.test.js

    Test Suites: 3 passed, 3 total Tests: 37 passed, 37 total Snapshots: 0 total Time: 0.364 s, estimated 1 s Ran all test suites.

    blue

  • 코드

      const mockMemos = [
      {
        id: 1,
        title: "TDD 메모 작성",
        period: {
          startDate: "2026-03-06",
          endDate: "2026-03-10",
        },
        content: "첫 번째 메모",
        priority: 3,
        isSuccess: false,
      },
      {
        id: 2,
        title: "두 번째 메모",
        period: {
          startDate: "2026-03-07",
          endDate: "2026-03-12",
        },
        content: "두 번째 내용",
        priority: 2,
        isSuccess: true,
      },
      {
        id: 3,
        title: "세 번째 메모",
        period: {
          startDate: "2026-03-08",
          endDate: "2026-03-15",
        },
        content: "세 번째 내용",
        priority: 3,
        isSuccess: true,
      },
      {
        id: 4,
        title: "네 번째 메모",
        period: {
          startDate: "2026-03-09",
          endDate: "2026-03-18",
        },
        content: "네 번째 내용",
        priority: 1,
        isSuccess: false,
      },
    ];
    
    function validatePage(page) {
      if (typeof page !== "number" || page < 1) {
        throw new Error("page");
      }
    }
    
    function validatePageSize(pageSize) {
      if (typeof pageSize !== "number" || pageSize < 1) {
        throw new Error("pageSize");
      }
    }
    
    function validateIsSuccess(isSuccess) {
      if (isSuccess !== undefined && typeof isSuccess !== "boolean") {
        throw new Error("isSuccess");
      }
    }
    
    function validatePriority(priority) {
      if (priority !== undefined) {
        if (typeof priority !== "number" || priority < 1 || priority > 5) {
          throw new Error("priority");
        }
      }
    }
    
    function filterByIsSuccess(memos, isSuccess) {
      if (isSuccess === undefined) {
        return memos;
      }
    
      return memos.filter((memo) => memo.isSuccess === isSuccess);
    }
    
    function filterByPriority(memos, priority) {
      if (priority === undefined) {
        return memos;
      }
    
      return memos.filter((memo) => memo.priority === priority);
    }
    
    async function readMemo(id) {
      if (typeof id !== "number" || id <= 0) {
        throw new Error("id");
      }
    
      const memo = mockMemos.find((item) => item.id === id);
    
      if (!memo) {
        throw new Error("memo");
      }
    
      return memo;
    }
    
    async function listMemo(query) {
      const { page, pageSize, isSuccess, priority } = query;
    
      validatePage(page);
      validatePageSize(pageSize);
      validateIsSuccess(isSuccess);
      validatePriority(priority);
    
      let result = mockMemos;
    
      result = filterByIsSuccess(result, isSuccess);
      result = filterByPriority(result, priority);
    
      const startIndex = (page - 1) * pageSize;
      const endIndex = startIndex + pageSize;
    
      return result.slice(startIndex, endIndex);
    }
    
    module.exports = { readMemo, listMemo };

• 실행 로그 ``` hongseongchae@hongseongchaeui-MacBookPro tdd_study % npm test

  tdd_study@1.0.0 test jest

  PASS test/memo/readMemo.test.js PASS test/memo/readMemoList.test.js PASS test/memo/createMemo.test.js

  Test Suites: 3 passed, 3 total Tests: 37 passed, 37 total Snapshots: 0 total Time: 0.647 s, estimated 1 s Ran all test suites.

• 간단한 메모 CRUD

메모 등록

Red

• 메모 등록에 값의 범위, 필수 값 누락 등에 대한 테스트 진행

  • title : 누락, 공백, 타입 오류

  • period : 누락, 내부 필든 누락, 날짜 순서 날짜 형식 오류

  • content : 누락, 공백, 타입 오류

  • priority : 누락, 타입 오류, 범위 오류

  • 코드

    const { createMemo } = require("../../src/memo/createMemo");
    
    describe("createMemo", () => {
      const validInput = {
        title: "TDD 메모 작성",
        period: {
          startDate: "2026-03-06",
          endDate: "2026-03-10",
        },
        content: "Red 단계 테스트 작성",
        priority: 3,
      };
    
      test("정상 입력이면 memo 생성에 성공한다", async () => {
        const result = await createMemo(validInput);
    
        expect(result).toMatchObject({
          title: "TDD 메모 작성",
          period: {
            startDate: "2026-03-06",
            endDate: "2026-03-10",
          },
          content: "Red 단계 테스트 작성",
          priority: 3,
          isSuccess: false,
        });
      });
    
      test("title이 없으면 에러 발생", async () => {
        await expect(
          createMemo({
            ...validInput,
            title: "",
          }),
        ).rejects.toThrow("title");
      });
    
      test("title이 공백만 있으면 에러 발생", async () => {
        await expect(
          createMemo({
            ...validInput,
            title: "   ",
          }),
        ).rejects.toThrow("title");
      });
    
      test("title이 문자열이 아니면 에러 발생", async () => {
        await expect(
          createMemo({
            ...validInput,
            title: 1234,
          }),
        ).rejects.toThrow("title");
      });
    
      test("period가 없으면 에러 발생", async () => {
        await expect(
          createMemo({
            ...validInput,
            period: null,
          }),
        ).rejects.toThrow("period");
      });
    
      test("period의 startDate가 없으면 에러 발생", async () => {
        await expect(
          createMemo({
            ...validInput,
            period: {
              endDate: "2026-03-10",
            },
          }),
        ).rejects.toThrow("period");
      });
    
      test("period의 endDate가 없으면 에러 발생", async () => {
        await expect(
          createMemo({
            ...validInput,
            period: {
              startDate: "2026-03-06",
            },
          }),
        ).rejects.toThrow("period");
      });
    
      test("기간 시작일이 종료일보다 뒤면 에러 발생", async () => {
        await expect(
          createMemo({
            ...validInput,
            period: {
              startDate: "2026-03-11",
              endDate: "2026-03-10",
            },
          }),
        ).rejects.toThrow("period");
      });
    
      test("period 날짜 형식이 올바르지 않으면 에러 발생", async () => {
        await expect(
          createMemo({
            ...validInput,
            period: {
              startDate: "wrong-date",
              endDate: "2026-03-10",
            },
          }),
        ).rejects.toThrow("period");
      });
    
      test("content가 없으면 에러 발생", async () => {
        await expect(
          createMemo({
            ...validInput,
            content: "",
          }),
        ).rejects.toThrow("content");
      });
    
      test("content가 공백만 있으면 에러 발생", async () => {
        await expect(
          createMemo({
            ...validInput,
            content: "   ",
          }),
        ).rejects.toThrow("content");
      });
    
      test("content가 문자열이 아니면 에러 발생", async () => {
        await expect(
          createMemo({
            ...validInput,
            content: 1234,
          }),
        ).rejects.toThrow("content");
      });
    
      test("priority가 없으면 에러 발생", async () => {
        await expect(
          createMemo({
            ...validInput,
            priority: undefined,
          }),
        ).rejects.toThrow("priority");
      });
    
      test("priority가 숫자가 아니면 에러 발생", async () => {
        await expect(
          createMemo({
            ...validInput,
            priority: "3",
          }),
        ).rejects.toThrow("priority");
      });
    
      test("priority가 1보다 작으면 에러 발생", async () => {
        await expect(
          createMemo({
            ...validInput,
            priority: 0,
          }),
        ).rejects.toThrow("priority");
      });
    
      test("priority가 5보다 크면 에러 발생", async () => {
        await expect(
          createMemo({
            ...validInput,
            priority: 6,
          }),
        ).rejects.toThrow("priority");
      });
    });

  • 실행 로그

    hongseongchae@hongseongchaeui-MacBookPro tdd_study % npm test
    
    > tdd_study@1.0.0 test
    > jest
    
     FAIL  __test__/memo/createMemo.test.js
      ● createMemo › 정상 입력이면 memo 생성에 성공한다
    
    TypeError: createMemo is not a function
    
      13 |
      14 |   test("정상 입력이면 memo 생성에 성공한다", async () => {
    > 15 |     const result = await createMemo(validInput);
         |                          ^
      16 |
      17 |     expect(result).toMatchObject({
      18 |       title: "TDD 메모 작성",
    
      at Object.createMemo (__test__/memo/createMemo.test.js:15:26)
    
      ● createMemo › title이 없으면 에러 발생
    
    TypeError: createMemo is not a function
    
      29 |   test("title이 없으면 에러 발생", async () => {
      30 |     await expect(
    > 31 |       createMemo({
         |       ^
      32 |         ...validInput,
      33 |         title: "",
      34 |       }),
    
      at Object.createMemo (__test__/memo/createMemo.test.js:31:7)
    
      ● createMemo › title이 공백만 있으면 에러 발생
    
    TypeError: createMemo is not a function
    
      38 |   test("title이 공백만 있으면 에러 발생", async () => {
      39 |     await expect(
    > 40 |       createMemo({
         |       ^
      41 |         ...validInput,
      42 |         title: "   ",
      43 |       }),
    
      at Object.createMemo (__test__/memo/createMemo.test.js:40:7)
    
      ● createMemo › title이 문자열이 아니면 에러 발생
    
    TypeError: createMemo is not a function
    
      47 |   test("title이 문자열이 아니면 에러 발생", async () => {
      48 |     await expect(
    > 49 |       createMemo({
         |       ^
      50 |         ...validInput,
      51 |         title: 1234,
      52 |       }),
    
      at Object.createMemo (__test__/memo/createMemo.test.js:49:7)
    
      ● createMemo › period가 없으면 에러 발생
    
    TypeError: createMemo is not a function
    
      56 |   test("period가 없으면 에러 발생", async () => {
      57 |     await expect(
    > 58 |       createMemo({
         |       ^
      59 |         ...validInput,
      60 |         period: null,
      61 |       }),
    
      at Object.createMemo (__test__/memo/createMemo.test.js:58:7)
    
      ● createMemo › period의 startDate가 없으면 에러 발생
    
    TypeError: createMemo is not a function
    
      65 |   test("period의 startDate가 없으면 에러 발생", async () => {
      66 |     await expect(
    > 67 |       createMemo({
         |       ^
      68 |         ...validInput,
      69 |         period: {
      70 |           endDate: "2026-03-10",
    
      at Object.createMemo (__test__/memo/createMemo.test.js:67:7)
    
      ● createMemo › period의 endDate가 없으면 에러 발생
    
    TypeError: createMemo is not a function
    
      76 |   test("period의 endDate가 없으면 에러 발생", async () => {
      77 |     await expect(
    > 78 |       createMemo({
         |       ^
      79 |         ...validInput,
      80 |         period: {
      81 |           startDate: "2026-03-06",
    
      at Object.createMemo (__test__/memo/createMemo.test.js:78:7)
    
      ● createMemo › 기간 시작일이 종료일보다 뒤면 에러 발생
    
    TypeError: createMemo is not a function
    
      87 |   test("기간 시작일이 종료일보다 뒤면 에러 발생", async () => {
      88 |     await expect(
    > 89 |       createMemo({
         |       ^
      90 |         ...validInput,
      91 |         period: {
      92 |           startDate: "2026-03-11",
    
      at Object.createMemo (__test__/memo/createMemo.test.js:89:7)
    
      ● createMemo › period 날짜 형식이 올바르지 않으면 에러 발생
    
    TypeError: createMemo is not a function
    
       99 |   test("period 날짜 형식이 올바르지 않으면 에러 발생", async () => {
      100 |     await expect(
    > 101 |       createMemo({
          |       ^
      102 |         ...validInput,
      103 |         period: {
      104 |           startDate: "wrong-date",
    
      at Object.createMemo (__test__/memo/createMemo.test.js:101:7)
    
      ● createMemo › content가 없으면 에러 발생
    
    TypeError: createMemo is not a function
    
      111 |   test("content가 없으면 에러 발생", async () => {
      112 |     await expect(
    > 113 |       createMemo({
          |       ^
      114 |         ...validInput,
      115 |         content: "",
      116 |       }),
    
      at Object.createMemo (__test__/memo/createMemo.test.js:113:7)
    
      ● createMemo › content가 공백만 있으면 에러 발생
    
    TypeError: createMemo is not a function
    
      120 |   test("content가 공백만 있으면 에러 발생", async () => {
      121 |     await expect(
    > 122 |       createMemo({
          |       ^
      123 |         ...validInput,
      124 |         content: "   ",
      125 |       }),
    
      at Object.createMemo (__test__/memo/createMemo.test.js:122:7)
    
      ● createMemo › content가 문자열이 아니면 에러 발생
    
    TypeError: createMemo is not a function
    
      129 |   test("content가 문자열이 아니면 에러 발생", async () => {
      130 |     await expect(
    > 131 |       createMemo({
          |       ^
      132 |         ...validInput,
      133 |         content: 1234,
      134 |       }),
    
      at Object.createMemo (__test__/memo/createMemo.test.js:131:7)
    
      ● createMemo › priority가 없으면 에러 발생
    
    TypeError: createMemo is not a function
    
      138 |   test("priority가 없으면 에러 발생", async () => {
      139 |     await expect(
    > 140 |       createMemo({
          |       ^
      141 |         ...validInput,
      142 |         priority: undefined,
      143 |       }),
    
      at Object.createMemo (__test__/memo/createMemo.test.js:140:7)
    
      ● createMemo › priority가 숫자가 아니면 에러 발생
    
    TypeError: createMemo is not a function
    
      147 |   test("priority가 숫자가 아니면 에러 발생", async () => {
      148 |     await expect(
    > 149 |       createMemo({
          |       ^
      150 |         ...validInput,
      151 |         priority: "3",
      152 |       }),
    
      at Object.createMemo (__test__/memo/createMemo.test.js:149:7)
    
      ● createMemo › priority가 1보다 작으면 에러 발생
    
    TypeError: createMemo is not a function
    
      156 |   test("priority가 1보다 작으면 에러 발생", async () => {
      157 |     await expect(
    > 158 |       createMemo({
          |       ^
      159 |         ...validInput,
      160 |         priority: 0,
      161 |       }),
    
      at Object.createMemo (__test__/memo/createMemo.test.js:158:7)
    
    ● createMemo › priority가 5보다 크면 에러 발생
    
      TypeError: createMemo is not a function
    
      165 |   test("priority가 5보다 크면 에러 발생", async () => {
      166 |     await expect(
    > 167 |       createMemo({
          |       ^
      168 |         ...validInput,
      169 |         priority: 6,
      170 |       }),
    
      at Object.createMemo (__test__/memo/createMemo.test.js:167:7)
    
    

            Test Suites: 1 failed, 1 total
            Tests:       16 failed, 16 total
            Snapshots:   0 total
            Time:        1.01 s

Red인 경우 테스트 코드를 정의하는 단계(실패하는 케이스)이므로 코드가 구현되어있지않으므로 모두 실패로 나온다.

Green

• Red를 바탕으로 실행 코드를 작성한다

• 코드

    async function createMemo(input) {
    const { title, period, content, priority } = input;
  
    if (typeof title !== "string" || title.trim() === "") {
      throw new Error("title");
    }
  
    if (
      !period ||
      typeof period.startDate !== "string" ||
      typeof period.endDate !== "string"
    ) {
      throw new Error("period");
    }
  
    const start = new Date(period.startDate);
    const end = new Date(period.endDate);
  
    if (Number.isNaN(start.getTime()) || Number.isNaN(end.getTime())) {
      throw new Error("period");
    }
  
    if (start > end) {
      throw new Error("period");
    }
  
    if (typeof content !== "string" || content.trim() === "") {
      throw new Error("content");
    }
  
    if (typeof priority !== "number" || priority < 1 || priority > 5) {
      throw new Error("priority");
    }
  
    return {
      title,
      period,
      content,
      priority,
      isSuccess: false,
    };
  }
  
  module.exports = { createMemo };

• 실행 로그

  hongseongchae@hongseongchaeui-MacBookPro tdd_study % npm test
  
  > tdd_study@1.0.0 test
  > jest
  
   PASS  __test__/memo/createMemo.test.js
    createMemo
      ✓ 정상 입력이면 memo 생성에 성공한다 (3 ms)
      ✓ title이 없으면 에러 발생 (8 ms)
      ✓ title이 공백만 있으면 에러 발생 (3 ms)
      ✓ title이 문자열이 아니면 에러 발생 (1 ms)
      ✓ period가 없으면 에러 발생
      ✓ period의 startDate가 없으면 에러 발생 (1 ms)
      ✓ period의 endDate가 없으면 에러 발생 (1 ms)
      ✓ 기간 시작일이 종료일보다 뒤면 에러 발생 (1 ms)
      ✓ period 날짜 형식이 올바르지 않으면 에러 발생 (1 ms)
      ✓ content가 없으면 에러 발생
      ✓ content가 공백만 있으면 에러 발생 (1 ms)
      ✓ content가 문자열이 아니면 에러 발생
      ✓ priority가 없으면 에러 발생
      ✓ priority가 숫자가 아니면 에러 발생 (1 ms)
      ✓ priority가 1보다 작으면 에러 발생 (1 ms)
      ✓ priority가 5보다 크면 에러 발생
  
    Test Suites: 1 passed, 1 total
    Tests:       16 passed, 16 total
    Snapshots:   0 total
    Time:        0.215 s, estimated 1 s
    Ran all test suites.
  

blue

• Green을 통과한 기준으로 refactoring를 진행한다.

• 검증함수 분리

• 코드

    function validateTitle(title) {
      if (typeof title !== "string" || title.trim() === "") {
        throw new Error("title");
      }
    }
  
    function validateContent(content) {
      if (typeof content !== "string" || content.trim() === "") {
        throw new Error("content");
      }
    }
  
    function validatePriority(priority) {
      if (typeof priority !== "number" || priority < 1 || priority > 5) {
        throw new Error("priority");
      }
    }
  
    function validatePeriod(period) {
      if (
        !period ||
        typeof period.startDate !== "string" ||
        typeof period.endDate !== "string"
      ) {
        throw new Error("period");
      }
  
      if (!isValidDateRange(period.startDate, period.endDate)) {
        throw new Error("period");
      }
    }
  
    function isValidDateRange(startDate, endDate) {
      const start = new Date(startDate);
      const end = new Date(endDate);
  
      if (Number.isNaN(start.getTime()) || Number.isNaN(end.getTime())) {
        return false;
      }
  
      if (start > end) {
        return false;
      }
  
      return true;
    }
  
    async function createMemo(input) {
      const { title, period, content, priority } = input;
  
      validateTitle(title);
      validatePeriod(period);
      validateContent(content);
      validatePriority(priority);
  
      return {
        title,
        period,
        content,
        priority,
        isSuccess: false,
      };
    }
  
    module.exports = { createMemo };

• 실행 로그

    hongseongchae@hongseongchaeui-MacBookPro tdd_study % npm test
  
    > tdd_study@1.0.0 test
    > jest
  
     PASS  __test__/memo/createMemo.test.js
      createMemo
        ✓ 정상 입력이면 memo 생성에 성공한다 (3 ms)
        ✓ title이 없으면 에러 발생 (8 ms)
        ✓ title이 공백만 있으면 에러 발생 (1 ms)
        ✓ title이 문자열이 아니면 에러 발생 (1 ms)
        ✓ period가 없으면 에러 발생 (1 ms)
        ✓ period의 startDate가 없으면 에러 발생 (1 ms)
        ✓ period의 endDate가 없으면 에러 발생 (1 ms)
        ✓ 기간 시작일이 종료일보다 뒤면 에러 발생 (1 ms)
        ✓ period 날짜 형식이 올바르지 않으면 에러 발생 (1 ms)
        ✓ content가 없으면 에러 발생 (1 ms)
        ✓ content가 공백만 있으면 에러 발생 (2 ms)
        ✓ content가 문자열이 아니면 에러 발생 (1 ms)
        ✓ priority가 없으면 에러 발생
        ✓ priority가 숫자가 아니면 에러 발생 (1 ms)
        ✓ priority가 1보다 작으면 에러 발생
        ✓ priority가 5보다 크면 에러 발생
  
    Test Suites: 1 passed, 1 total
    Tests:       16 passed, 16 total
    Snapshots:   0 total
    Time:        0.339 s, estimated 1 s
    Ran all test suites.

• Test Driven Development의 약자
• 테스트 코드를 먼저 작성하고 그 테스트를 통과하도록 실제 코드를 구현하는 개발 방법론
• 짧은 개발 주기의 반복에 의존하는 개발 프로세스
• 애자일 방법론 중 하나인 eXtream Programming의 Test-First 개념에 기반을 둔 단순한 설계를 중요시한다.

개발 사이클

Red -> Green -> Refactor

• Red

  • 먼저 실패하는 테스트를 작성
  • 아직 기능이 구현되지 않았기 때문에 테스트는 실패
  • ex)

    test("두 숫자를 더하면 결과가 나온다", () => {
      expect(add(2,3)).toBe(5);
     });

• Green

  • 테스트가 통과하도록 최소한의 코드만 작성

  • ex)

    function add(a,b){
      return a+b;
    }

  • Refactor

    • 테스트가 통과하는 상태에서 코드를 개선한다.
    • 중복 제거
    • 구조 개선
    • 가독성 개선
    • ex)

      function add(a,b){
      return a+b;
      }
      

일반적인 개발 방식 vs TDD 개발 방식

• 일반 개발 방식

  • 방식

    • 요구사항 분석 -> 설계 -> 개발 -> 테스트 -> 배포

  • 장점

    • 개발 속도가 빠르다.
    • 테스트 코드 유지 비용이 없다.
    • 유연한 개발이 가능하다.

  • 단점

    • 소비자의 요구 사항이 명확하지 않을 수 있다.
    • 자체 버그 검출 능력 저하 또는 소스코드의 품질이 저하될 수 있다.
    • 기능이 많아질수록 버그가 발견되는 시점이 늦어진다.
    • 작은 기능 수정 시 모든 부분을 테스트 진행해야되므로 버그 발견이 어렵다

• TDD 개발 방식

  • 장점
    • 테스트 코드를 작성하는 도중에 발생하는 예외 사항(버그, 수정사항)들은 테스트 케이스에 추가하고 설계를 개선한다.
    • 테스트 통과된 코드만이 개발 단계에서 실제 코드로 작성되므로 안정성이 있다.
  • 단점
    • 테스트 코드를 먼저 작성해야되므로 초기 개발 속도가 느리다.
    • 테스트 코드 작성 난이도가 높다.
    • 모든 기능에 적용하기 어렵다.

      TDD 효과

  • 버그를 조기에 발견할 수 있다.
  • 선 테스트를 진행하므로 초기에 버그를 발견할 수 있다.
  • 안정적인 리팩토링이 가능하다.
  • 코드 설계 품질이 향상된다.
  • 의존성 감소, 모듈화, 유지보수 용이 장점
  • 요구사항을 명확하게 정의할 수 있다.
  • 추가 구현이 용이하다.

문제 설명

오래전 유행했던 콜라 문제가 있습니다. 콜라 문제의 지문은 다음과 같습니다.

정답은 아무에게도 말하지 마세요.

콜라 빈 병 2개를 가져다주면 콜라 1병을 주는 마트가 있다. 빈 병 20개를 가져다주면 몇 병을 받을 수 있는가?

단, 보유 중인 빈 병이 2개 미만이면, 콜라를 받을 수 없다.

문제를 풀던 상빈이는 콜라 문제의 완벽한 해답을 찾았습니다. 상빈이가 푼 방법은 아래 그림과 같습니다. 우선 콜라 빈 병 20병을 가져가서 10병을 받습니다. 받은 10병을 모두 마신 뒤, 가져가서 5병을 받습니다. 5병 중 4병을 모두 마신 뒤 가져가서 2병을 받고, 또 2병을 모두 마신 뒤 가져가서 1병을 받습니다. 받은 1병과 5병을 받았을 때 남은 1병을 모두 마신 뒤 가져가면 1병을 또 받을 수 있습니다. 이 경우 상빈이는 총 10 + 5 + 2 + 1 + 1 = 19병의 콜라를 받을 수 있습니다.

문제를 열심히 풀던 상빈이는 일반화된 콜라 문제를 생각했습니다. 이 문제는 빈 병 a개를 가져다주면 콜라 b병을 주는 마트가 있을 때, 빈 병 n개를 가져다주면 몇 병을 받을 수 있는지 계산하는 문제입니다. 기존 콜라 문제와 마찬가지로, 보유 중인 빈 병이 a개 미만이면, 추가적으로 빈 병을 받을 순 없습니다. 상빈이는 열심히 고심했지만, 일반화된 콜라 문제의 답을 찾을 수 없었습니다. 상빈이를 도와, 일반화된 콜라 문제를 해결하는 프로그램을 만들어 주세요.

콜라를 받기 위해 마트에 주어야 하는 병 수 a, 빈 병 a개를 가져다 주면 마트가 주는 콜라 병 수 b, 상빈이가 가지고 있는 빈 병의 개수 n이 매개변수로 주어집니다. 상빈이가 받을 수 있는 콜라의 병 수를 return 하도록 solution 함수를 작성해주세요.

제한 사항

• 1 ≤ b < a ≤ n ≤ 1,000,000
• 정답은 항상 int 범위를 넘지 않게 주어집니다.

  입출력 예

  

입출력 예 설명

입출력 예 #1

• 본문에서 설명한 예시입니다. 입출력 예 #2

• 빈 병 20개 중 18개를 마트에 가져가서, 6병의 콜라를 받습니다. 이때 상빈이가 가지고 있는 콜라 병의 수는 8(20 – 18 + 6 = 8)개 입니다.

• 빈 병 8개 중 6개를 마트에 가져가서, 2병의 콜라를 받습니다. 이때 상빈이가 가지고 있는 콜라 병의 수는 4(8 – 6 + 2 = 4)개 입니다.

• 빈 병 4 개중 3개를 마트에 가져가서, 1병의 콜라를 받습니다. 이때 상빈이가 가지고 있는 콜라 병의 수는 2(4 – 3 + 1 = 2)개 입니다.

• 3번의 교환 동안 상빈이는 9(6 + 2 + 1 = 9)병의 콜라를 받았습니다.

  제출 코드

  function solution(a, b, n) {
    let answer = 0;
  
    while (n >= a) {
        const exchanged = Math.floor(n / a); // 교환 횟수
        const received = exchanged * b;      // 받은 콜라
  
        answer += received;
        n = (n % a) + received;               // 남은 병 + 새 병
    }
  
    return answer;
  }

문제 설명

새로 생긴 놀이기구는 인기가 매우 많아 줄이 끊이질 않습니다. 이 놀이기구의 원래 이용료는 price원 인데, 놀이기구를 N 번 째 이용한다면 원래 이용료의 N배를 받기로 하였습니다. 즉, 처음 이용료가 100이었다면 2번째에는 200, 3번째에는 300으로 요금이 인상됩니다. 놀이기구를 count번 타게 되면 현재 자신이 가지고 있는 금액에서 얼마가 모자라는지를 return 하도록 solution 함수를 완성하세요. 단, 금액이 부족하지 않으면 0을 return 하세요.

제한사항

• 놀이기구의 이용료 price : 1 ≤ price ≤ 2,500, price는 자연수
• 처음 가지고 있던 금액 money : 1 ≤ money ≤ 1,000,000,000, money는 자연수
• 놀이기구의 이용 횟수 count : 1 ≤ count ≤ 2,500, count는 자연수

제한 사항

• 1,000 ≤ a, b ≤ 1,000

입출력 예

입출력 예 설명

입출력 예 #1

• 이용금액이 3인 놀이기구를 4번 타고 싶은 고객이 현재 가진 금액이 20이라면, 총 필요한 놀이기구의 이용 금액은 30 (= 3+6+9+12) 이 되어 10만큼 부족하므로 10을 return 합니다.

제출 코드

function solution(price, total_money, count) {
    var answer = -1;
    let use_money = 0;
    for(let i = 1; i < count+1; i++){
         use_money+=i*price;
        console.log(use_money);

    }

    if(total_money < use_money){
        return use_money-total_money;
    }
    return 0;
}

문제 설명

명함 지갑을 만드는 회사에서 지갑의 크기를 정하려고 합니다. 다양한 모양과 크기의 명함들을 모두 수납할 수 있으면서, 작아서 들고 다니기 편한 지갑을 만들어야 합니다. 이러한 요건을 만족하는 지갑을 만들기 위해 디자인팀은 모든 명함의 가로 길이와 세로 길이를 조사했습니다.

아래 표는 4가지 명함의 가로 길이와 세로 길이를 나타냅니다.

가장 긴 가로 길이와 세로 길이가 각각 80, 70이기 때문에 80(가로) x 70(세로) 크기의 지갑을 만들면 모든 명함들을 수납할 수 있습니다. 하지만 2번 명함을 가로로 눕혀 수납한다면 80(가로) x 50(세로) 크기의 지갑으로 모든 명함들을 수납할 수 있습니다. 이때의 지갑 크기는 4000(=80 x 50)입니다.

모든 명함의 가로 길이와 세로 길이를 나타내는 2차원 배열 sizes가 매개변수로 주어집니다. 모든 명함을 수납할 수 있는 가장 작은 지갑을 만들 때, 지갑의 크기를 return 하도록 solution 함수를 완성해주세요.

제한 사항

• sizes의 길이는 1 이상 10,000 이하입니다.
  • sizes의 원소는 [w, h] 형식입니다.
  • w는 명함의 가로 길이를 나타냅니다.
  • h는 명함의 세로 길이를 나타냅니다.
  • w와 h는 1 이상 1,000 이하인 자연수입니다.

입출력 예

입출력 예 설명

입출력 예 #1

• 문제 예시와 같습니다.

입출력 예 #2

• 명함들을 적절히 회전시켜 겹쳤을 때, 3번째 명함(가로: 8, 세로: 15)이 다른 모든 명함보다 크기가 큽니다. 따라서 지갑의 크기는 3번째 명함의 크기와 같으며, 120(=8 x 15)을 return 합니다.

입출력 예 #3

• 명함들을 적절히 회전시켜 겹쳤을 때, 모든 명함을 포함하는 가장 작은 지갑의 크기는 133(=19 x 7)입니다.

제출 코드

function solution(sizes) {
  let max_width = 0;  // 긴 변들 중 최대
  let max_height = 0; // 짧은 변들 중 최대

  for (let i = 0; i < sizes.length; i++) {
    const width = sizes[i][0];
    const height = sizes[i][1];

    const big = Math.max(width, height);
    const small = Math.min(width, height);

    if (big > max_width) max_width = big;
    if (small > max_height) max_height = small;
  }

  return max_width * max_height;
}

문제 설명

햄버거 가게에서 일을 하는 상수는 햄버거를 포장하는 일을 합니다. 함께 일을 하는 다른 직원들이 햄버거에 들어갈 재료를 조리해 주면 조리된 순서대로 상수의 앞에 아래서부터 위로 쌓이게 되고, 상수는 순서에 맞게 쌓여서 완성된 햄버거를 따로 옮겨 포장을 하게 됩니다. 상수가 일하는 가게는 정해진 순서(아래서부터, 빵 – 야채 – 고기 - 빵)로 쌓인 햄버거만 포장을 합니다. 상수는 손이 굉장히 빠르기 때문에 상수가 포장하는 동안 속 재료가 추가적으로 들어오는 일은 없으며, 재료의 높이는 무시하여 재료가 높이 쌓여서 일이 힘들어지는 경우는 없습니다.

예를 들어, 상수의 앞에 쌓이는 재료의 순서가 [야채, 빵, 빵, 야채, 고기, 빵, 야채, 고기, 빵]일 때, 상수는 여섯 번째 재료가 쌓였을 때, 세 번째 재료부터 여섯 번째 재료를 이용하여 햄버거를 포장하고, 아홉 번째 재료가 쌓였을 때, 두 번째 재료와 일곱 번째 재료부터 아홉 번째 재료를 이용하여 햄버거를 포장합니다. 즉, 2개의 햄버거를 포장하게 됩니다.

상수에게 전해지는 재료의 정보를 나타내는 정수 배열 ingredient가 주어졌을 때, 상수가 포장하는 햄버거의 개수를 return 하도록 solution 함수를 완성하시오.

제한 사항

• 1 ≤ ingredient의 길이 ≤ 1,000,000
• ingredient의 원소는 1, 2, 3 중 하나의 값이며, 순서대로 빵, 야채, 고기를 의미합니다.

입출력 예

입출력 예 설명

입출력 예 #1

• 문제 예시와 같습니다.

입출력 예 #2

• 상수가 포장할 수 있는 햄버거가 없습니다.

제출 코드

function solution(ingredient) {
    var answer = 0;
    // 쌓이는 순서대로 1,2,3,1 이렇게 쌓여야됨
    // 본문 for문에서 1,2,3,1 이렇게 될 경우에 빼기
    // 4개 이상 쌓였을 경우 확인
    let top = 0;
    let bugger_array = [];
    let count = 0;
    for(let i = 0; i<ingredient.length; i++){
        bugger_array[top] = ingredient[i];
        top++;
        if (top >= 4 && bugger_array[top - 4] === 1 && bugger_array[top - 3] === 2 && bugger_array[top - 2] === 3 && bugger_array[top - 1] === 1) {
          top -= 4;    
          count++;
        }
    }
    return count;
}

스택 구조

function solution(ingredient) {
  const bugger_array = [];
  let count = 0;

  for (const x of ingredient) {
    bugger_array.push(x);

    const n = bugger_array.length;
    if (
      n >= 4 &&
      bugger_array[n - 4] === 1 &&
      bugger_array[n - 3] === 2 &&
      bugger_array[n - 2] === 3 &&
      bugger_array[n - 1] === 1
    ) {
      bugger_array.pop();
      bugger_array.pop();
      bugger_array.pop();
      bugger_array.pop();
      count++;
    }
  }

  return count;
}

문제 설명

수웅이는 매달 주어진 음식을 빨리 먹는 푸드 파이트 대회를 개최합니다. 이 대회에서 선수들은 1대 1로 대결하며, 매 대결마다 음식의 종류와 양이 바뀝니다. 대결은 준비된 음식들을 일렬로 배치한 뒤, 한 선수는 제일 왼쪽에 있는 음식부터 오른쪽으로, 다른 선수는 제일 오른쪽에 있는 음식부터 왼쪽으로 순서대로 먹는 방식으로 진행됩니다. 중앙에는 물을 배치하고, 물을 먼저 먹는 선수가 승리하게 됩니다.

이때, 대회의 공정성을 위해 두 선수가 먹는 음식의 종류와 양이 같아야 하며, 음식을 먹는 순서도 같아야 합니다. 또한, 이번 대회부터는 칼로리가 낮은 음식을 먼저 먹을 수 있게 배치하여 선수들이 음식을 더 잘 먹을 수 있게 하려고 합니다. 이번 대회를 위해 수웅이는 음식을 주문했는데, 대회의 조건을 고려하지 않고 음식을 주문하여 몇 개의 음식은 대회에 사용하지 못하게 되었습니다.

예를 들어, 3가지의 음식이 준비되어 있으며, 칼로리가 적은 순서대로 1번 음식을 3개, 2번 음식을 4개, 3번 음식을 6개 준비했으며, 물을 편의상 0번 음식이라고 칭한다면, 두 선수는 1번 음식 1개, 2번 음식 2개, 3번 음식 3개씩을 먹게 되므로 음식의 배치는 "1223330333221"이 됩니다. 따라서 1번 음식 1개는 대회에 사용하지 못합니다.

수웅이가 준비한 음식의 양을 칼로리가 적은 순서대로 나타내는 정수 배열 food가 주어졌을 때, 대회를 위한 음식의 배치를 나타내는 문자열을 return 하는 solution 함수를 완성해주세요

제한 사항

• 2 ≤ food의 길이 ≤ 9
• 1 ≤ food의 각 원소 ≤ 1,000
• food에는 칼로리가 적은 순서대로 음식의 양이 담겨 있습니다.
• food[i]는 i번 음식의 수입니다.
• food[0]은 수웅이가 준비한 물의 양이며, 항상 1입니다.
• 정답의 길이가 3 이상인 경우만 입력으로 주어집니다.

입출력 예

입출력 예 설명

입출력 예 #1

• 문제 예시와 같습니다.

입출력 예 #2

• 두 선수는 1번 음식 3개, 3번 음식 1개를 먹게 되므로 음식의 배치는 "111303111"입니다.

제출 코드

function solution(food) {
    let left_array = '';

    for (let i = 1; i < food.length; i++) {
        left_array += String(i).repeat(Math.floor(food[i] / 2));
    }

    const right_array = left_array.split('').reverse().join('');
    return left_array + '0' + right_array;
}

문제 설명

과일 장수가 사과 상자를 포장하고 있습니다. 사과는 상태에 따라 1점부터 k점까지의 점수로 분류하며, k점이 최상품의 사과이고 1점이 최하품의 사과입니다. 사과 한 상자의 가격은 다음과 같이 결정됩니다.

• 한 상자에 사과를 m개씩 담아 포장합니다.
• 상자에 담긴 사과 중 가장 낮은 점수가 p (1 ≤ p ≤ k)점인 경우, 사과 한 상자의 가격은 p * m 입니다.

과일 장수가 가능한 많은 사과를 팔았을 때, 얻을 수 있는 최대 이익을 계산하고자 합니다.(사과는 상자 단위로만 판매하며, 남는 사과는 버립니다)

예를 들어, k = 3, m = 4, 사과 7개의 점수가 [1, 2, 3, 1, 2, 3, 1]이라면, 다음과 같이 [2, 3, 2, 3]으로 구성된 사과 상자 1개를 만들어 판매하여 최대 이익을 얻을 수 있습니다.

• (최저 사과 점수) x (한 상자에 담긴 사과 개수) x (상자의 개수) = 2 x 4 x 1 = 8

사과의 최대 점수 k, 한 상자에 들어가는 사과의 수 m, 사과들의 점수 score가 주어졌을 때, 과일 장수가 얻을 수 있는 최대 이익을 return하는 solution 함수를 완성해주세요.

제한 사항

• 3 ≤ k ≤ 9
• 3 ≤ m ≤ 10
• 7 ≤ score의 길이 ≤ 1,000,000
  • 1 ≤ score[i] ≤ k
• 이익이 발생하지 않는 경우에는 0을 return 해주세요.

입출력 예

입출력 예 설명

입출력 예 #1

• 문제의 예시와 같습니다.

입출력 예 #2

• 다음과 같이 사과 상자를 포장하여 모두 팔면 최대 이익을 낼 수 있습니다. 따라서 (1 x 3 x 1) + (2 x 3 x 1) + (4 x 3 x 2) = 33을 return합니다.

제출 코드

function solution(k, m, score) {
    let answer = 0;

    // 내림차순 정렬
    score.sort((a, b) => b - a);

    // m개씩 묶기
    for (let i = 0; i + m <= score.length; i += m) {
        // 묶음의 최저 점수는 i + m - 1
        answer += score[i + m - 1] * m;
    }

    return answer;
}

문제 설명

고객의 약관 동의를 얻어서 수집된 1~n번으로 분류되는 개인정보 n개가 있습니다. 약관 종류는 여러 가지 있으며 각 약관마다 개인정보 보관 유효기간이 정해져 있습니다. 당신은 각 개인정보가 어떤 약관으로 수집됐는지 알고 있습니다. 수집된 개인정보는 유효기간 전까지만 보관 가능하며, 유효기간이 지났다면 반드시 파기해야 합니다.

예를 들어, A라는 약관의 유효기간이 12 달이고, 2021년 1월 5일에 수집된 개인정보가 A약관으로 수집되었다면 해당 개인정보는 2022년 1월 4일까지 보관 가능하며 2022년 1월 5일부터 파기해야 할 개인정보입니다. 당신은 오늘 날짜로 파기해야 할 개인정보 번호들을 구하려 합니다.

모든 달은 28일까지 있다고 가정합니다.

다음은 오늘 날짜가 2022.05.19일 때의 예시입니다.

• 첫 번째 개인정보는 A약관에 의해 2021년 11월 1일까지 보관 가능하며, 유효기간이 지났으므로 파기해야 할 개인정보입니다.
• 두 번째 개인정보는 B약관에 의해 2022년 6월 28일까지 보관 가능하며, 유효기간이 지나지 않았으므로 아직 보관 가능합니다.
• 세 번째 개인정보는 C약관에 의해 2022년 5월 18일까지 보관 가능하며, 유효기간이 지났으므로 파기해야 할 개인정보입니다.
• 네 번째 개인정보는 C약관에 의해 2022년 5월 19일까지 보관 가능하며, 유효기간이 지나지 않았으므로 아직 보관 가능합니다.

따라서 파기해야 할 개인정보 번호는 [1, 3]입니다.

오늘 날짜를 의미하는 문자열 today, 약관의 유효기간을 담은 1차원 문자열 배열 terms와 수집된 개인정보의 정보를 담은 1차원 문자열 배열 privacies가 매개변수로 주어집니다. 이때 파기해야 할 개인정보의 번호를 오름차순으로 1차원 정수 배열에 담아 return 하도록 solution 함수를 완성해 주세요.

제한 사항

• today는 "YYYY.MM.DD" 형태로 오늘 날짜를 나타냅니다.
• 1 ≤ terms의 길이 ≤ 20
  • terms의 원소는 "약관 종류 유효기간" 형태의 약관 종류와 유효기간을 공백 하나로 구분한 문자열입니다.
  • 약관 종류는 A~Z중 알파벳 대문자 하나이며, terms 배열에서 약관 종류는 중복되지 않습니다.
  • 유효기간은 개인정보를 보관할 수 있는 달 수를 나타내는 정수이며, 1 이상 100 이하입니다.
• 1 ≤ privacies의 길이 ≤ 100
  • privacies[i]는 i+1번 개인정보의 수집 일자와 약관 종류를 나타냅니다.
  • privacies의 원소는 "날짜 약관 종류" 형태의 날짜와 약관 종류를 공백 하나로 구분한 문자열입니다.
  • 날짜는 "YYYY.MM.DD" 형태의 개인정보가 수집된 날짜를 나타내며, today 이전의 날짜만 주어집니다.
  • privacies의 약관 종류는 항상 terms에 나타난 약관 종류만 주어집니다.
• today와 privacies에 등장하는 날짜의 YYYY는 연도, MM은 월, DD는 일을 나타내며 점(.) 하나로 구분되어 있습니다.
  • 2000 ≤ YYYY ≤ 2022
  • 1 ≤ MM ≤ 12
  • MM이 한 자릿수인 경우 앞에 0이 붙습니다.
  • 1 ≤ DD ≤ 28
  • DD가 한 자릿수인 경우 앞에 0이 붙습니다.
  • 파기해야 할 개인정보가 하나 이상 존재하는 입력만 주어집니다

입출력 예

입출력 예

입출력 예 설명

입출력 예 #1 문제 예시와 같습니다.

입출력 예 #2 오늘 날짜는 2020년 1월 1일입니다.

• 첫 번째 개인정보는 D약관에 의해 2019년 5월 28일까지 보관 가능하며, 유효기간이 지났으므로 파기해야 할 개인정보입니다.
• 두 번째 개인정보는 Z약관에 의해 2020년 2월 14일까지 보관 가능하며, 유효기간이 지나지 않았으므로 아직 보관 가능합니다.
• 세 번째 개인정보는 D약관에 의해 2020년 1월 1일까지 보관 가능하며, 유효기간이 지나지 않았으므로 아직 보관 가능합니다.
• 네 번째 개인정보는 D약관에 의해 2019년 11월 28일까지 보관 가능하며, 유효기간이 지났으므로 파기해야 할 개인정보입니다.
• 다섯 번째 개인정보는 Z약관에 의해 2019년 3월 27일까지 보관 가능하며, 유효기간이 지났으므로 파기해야 할 개인정보입니다.

제출 코드

function solution(today, terms, privacies) {
    var answer = [];
    let [current_year, current_month, current_day] = today.split(".").map(Number);

    let terms_obj = {};
    terms.forEach((value) => {
      terms_obj[value.split(" ")[0]] = Number(value.split(" ")[1]);
    });

    for (let i = 0; i < privacies.length; i++) {
        let [pri_year, pri_month, pri_day] =
            privacies[i].split(" ")[0].split(".").map(Number);
        let pri_terms = privacies[i].split(" ")[1];

        // 약관 개월 수 더하기
        pri_month += terms_obj[pri_terms];

        // 년/월 보정
        if (pri_month > 12) {
            pri_year += Math.floor((pri_month - 1) / 12);
            pri_month = ((pri_month - 1) % 12) + 1;
        }

        // 현재 날짜랑 계산된 날짜 비교
        let expired = pri_year < current_year ||
            (pri_year === current_year && pri_month < current_month) ||
            (pri_year === current_year &&
             pri_month === current_month &&
             pri_day <= current_day);

        if (expired) {
            answer.push(i + 1); // 문제 조건: 1번부터 시작
        }
    }

    return answer;
}

문제 설명

문자열 s가 입력되었을 때 다음 규칙을 따라서 이 문자열을 여러 문자열로 분해하려고 합니다.

• 먼저 첫 글자를 읽습니다. 이 글자를 x라고 합시다.
• 이제 이 문자열을 왼쪽에서 오른쪽으로 읽어나가면서, x와 x가 아닌 다른 글자들이 나온 횟수를 각각 셉니다. 처음으로 두 횟수가 같아지는 순간 멈추고, 지금까지 읽은 문자열을 분리합니다.
• s에서 분리한 문자열을 빼고 남은 부분에 대해서 이 과정을 반복합니다. 남은 부분이 없다면 종료합니다.
• 만약 두 횟수가 다른 상태에서 더 이상 읽을 글자가 없다면, 역시 지금까지 읽은 문자열을 분리하고, 종료합니다.

문자열 s가 매개변수로 주어질 때, 위 과정과 같이 문자열들로 분해하고, 분해한 문자열의 개수를 return 하는 함수 solution을 완성하세요.

제한 사항

• 1 ≤ s의 길이 ≤ 10,000
• s는 영어 소문자로만 이루어져 있습니다.

입출력 예

입출력 예 설명

입출력 예 #1

• s="banana"인 경우 ba - na - na와 같이 분해됩니다.

입출력 예 #2

• s="abracadabra"인 경우 ab - ra - ca - da - br - a와 같이 분해됩니다.

입출력 예 #3

• s="aaabbaccccabba"인 경우 aaabbacc - ccab - ba와 같이 분해됩니다.

제출 코드

function solution(s) {
    let answer = 0;
    let array = s.split("");

    let count = { x: 0, y: 0 };
    let target = array[0];

    for (let i = 0; i < array.length; i++) {

        if (array[i] === target) {
            count.x++;
        } else {
            count.y++;
        }

        if (count.x === count.y) {
            answer++;
            // 다음 문자 기준으로 리셋
            target = array[i + 1];
            count.x = 0;
            count.y = 0;
        }
    }

    // 마지막 덩어리 처리
    if (count.x !== 0) {
        answer++;
    }

    return answer;
}

문제 설명

"명예의 전당"이라는 TV 프로그램에서는 매일 1명의 가수가 노래를 부르고, 시청자들의 문자 투표수로 가수에게 점수를 부여합니다. 매일 출연한 가수의 점수가 지금까지 출연 가수들의 점수 중 상위 k번째 이내이면 해당 가수의 점수를 명예의 전당이라는 목록에 올려 기념합니다. 즉 프로그램 시작 이후 초기에 k일까지는 모든 출연 가수의 점수가 명예의 전당에 오르게 됩니다. k일 다음부터는 출연 가수의 점수가 기존의 명예의 전당 목록의 k번째 순위의 가수 점수보다 더 높으면, 출연 가수의 점수가 명예의 전당에 오르게 되고 기존의 k번째 순위의 점수는 명예의 전당에서 내려오게 됩니다.

이 프로그램에서는 매일 "명예의 전당"의 최하위 점수를 발표합니다. 예를 들어, k = 3이고, 7일 동안 진행된 가수의 점수가 [10, 100, 20, 150, 1, 100, 200]이라면, 명예의 전당에서 발표된 점수는 아래의 그림과 같이 [10, 10, 10, 20, 20, 100, 100]입니다. 명예의 전당 목록의 점수의 개수 k, 1일부터 마지막 날까지 출연한 가수들의 점수인 score가 주어졌을 때, 매일 발표된 명예의 전당의 최하위 점수를 return하는 solution 함수를 완성해주세요.

제한 사항

• 3 ≤ k ≤ 100
• 7 ≤ score의 길이 ≤ 1,000
  • 0 ≤ score[i] ≤ 2,000

입출력 예

입출력 예

입출력 예 설명

• 입출력 예 #1
  • 문제의 예시와 같습니다.
• 입출력 예 #2
  • 아래와 같이, [0, 0, 0, 0, 20, 40, 70, 70, 150, 300]을 return합니다.

제출 코드

function solution(k, score) {
    const hall = [];   // 명예의 전당
    const result = [];

    for (let i = 0; i < score.length; i++) {
        hall.push(score[i]);          // 오늘 점수 추가
        hall.sort((a, b) => a - b);   // 오름차순 정렬

        // k명 초과하면 최하위 제거
        if (hall.length > k) {
            hall.shift();
        }

        // 현재 명예의 전당 최하위 점수 기록
        result.push(hall[0]);
    }

    return result;
}

문제 설명

어느 학교에 페인트가 칠해진 길이가 n미터인 벽이 있습니다. 벽에 동아리 · 학회 홍보나 회사 채용 공고 포스터 등을 게시하기 위해 테이프로 붙였다가 철거할 때 떼는 일이 많고 그 과정에서 페인트가 벗겨지곤 합니다. 페인트가 벗겨진 벽이 보기 흉해져 학교는 벽에 페인트를 덧칠하기로 했습니다.

넓은 벽 전체에 페인트를 새로 칠하는 대신, 구역을 나누어 일부만 페인트를 새로 칠 함으로써 예산을 아끼려 합니다. 이를 위해 벽을 1미터 길이의 구역 n개로 나누고, 각 구역에 왼쪽부터 순서대로 1번부터 n번까지 번호를 붙였습니다. 그리고 페인트를 다시 칠해야 할 구역들을 정했습니다.

벽에 페인트를 칠하는 롤러의 길이는 m미터이고, 롤러로 벽에 페인트를 한 번 칠하는 규칙은 다음과 같습니다.

롤러가 벽에서 벗어나면 안 됩니다. 구역의 일부분만 포함되도록 칠하면 안 됩니다. 즉, 롤러의 좌우측 끝을 구역의 경계선 혹은 벽의 좌우측 끝부분에 맞춘 후 롤러를 위아래로 움직이면서 벽을 칠합니다. 현재 페인트를 칠하는 구역들을 완전히 칠한 후 벽에서 롤러를 떼며, 이를 벽을 한 번 칠했다고 정의합니다.

한 구역에 페인트를 여러 번 칠해도 되고 다시 칠해야 할 구역이 아닌 곳에 페인트를 칠해도 되지만 다시 칠하기로 정한 구역은 적어도 한 번 페인트칠을 해야 합니다. 예산을 아끼기 위해 다시 칠할 구역을 정했듯 마찬가지로 롤러로 페인트칠을 하는 횟수를 최소화하려고 합니다.

정수 n, m과 다시 페인트를 칠하기로 정한 구역들의 번호가 담긴 정수 배열 section이 매개변수로 주어질 때 롤러로 페인트칠해야 하는 최소 횟수를 return 하는 solution 함수를 작성해 주세요.

제한 사항

• 1 ≤ m ≤ n ≤ 100,000
• 1 ≤ section의 길이 ≤ n
  • 1 ≤ section의 원소 ≤ n
  • section의 원소는 페인트를 다시 칠해야 하는 구역의 번호입니다.
  • section에서 같은 원소가 두 번 이상 나타나지 않습니다.
  • section의 원소는 오름차순으로 정렬되어 있습니다.

입출력 예

입출력 예 설명

입출력 예 #1 예제 1번은 2, 3, 6번 영역에 페인트를 다시 칠해야 합니다. 롤러의 길이가 4미터이므로 한 번의 페인트칠에 연속된 4개의 구역을 칠할 수 있습니다. 처음에 3, 4, 5, 6번 영역에 페인트칠을 하면 칠해야 할 곳으로 2번 구역만 남고 1, 2, 3, 4번 구역에 페인트칠을 하면 2번 만에 다시 칠해야 할 곳에 모두 페인트칠을 할 수 있습니다. 2번보다 적은 횟수로 2, 3, 6번 영역에 페인트를 덧칠하는 방법은 없습니다. 따라서 최소 횟수인 2를 return 합니다.

입출력 예 #2 예제 2번은 1, 3번 영역에 페인트를 다시 칠해야 합니다. 롤러의 길이가 4미터이므로 한 번의 페인트칠에 연속된 4개의 구역을 칠할 수 있고 1, 2, 3, 4번 영역에 페인트칠을 하면 한 번에 1, 3번 영역을 모두 칠할 수 있습니다. 따라서 최소 횟수인 1을 return 합니다.

입출력 예 #3 예제 3번은 모든 구역에 페인트칠을 해야 합니다. 롤러의 길이가 1미터이므로 한 번에 한 구역밖에 칠할 수 없습니다. 구역이 4개이므로 각 구역을 한 번씩만 칠하는 4번이 최소 횟수가 됩니다. 따라서 4를 return 합니다.

제출 코드

function solution(n, m, section) {
    var answer = 0;
    let value = 0;

    for (let i = 0; i < section.length; i++) {
        if (section[i] > value) {
            answer++;
            value = section[i] + m - 1;
        }
    }
    return answer;
}

문제 설명

휴대폰의 자판은 컴퓨터 키보드 자판과는 다르게 하나의 키에 여러 개의 문자가 할당될 수 있습니다. 키 하나에 여러 문자가 할당된 경우, 동일한 키를 연속해서 빠르게 누르면 할당된 순서대로 문자가 바뀝니다.

예를 들어, 1번 키에 "A", "B", "C" 순서대로 문자가 할당되어 있다면 1번 키를 한 번 누르면 "A", 두 번 누르면 "B", 세 번 누르면 "C"가 되는 식입니다.

같은 규칙을 적용해 아무렇게나 만든 휴대폰 자판이 있습니다. 이 휴대폰 자판은 키의 개수가 1개부터 최대 100개까지 있을 수 있으며, 특정 키를 눌렀을 때 입력되는 문자들도 무작위로 배열되어 있습니다. 또, 같은 문자가 자판 전체에 여러 번 할당된 경우도 있고, 키 하나에 같은 문자가 여러 번 할당된 경우도 있습니다. 심지어 아예 할당되지 않은 경우도 있습니다. 따라서 몇몇 문자열은 작성할 수 없을 수도 있습니다.

이 휴대폰 자판을 이용해 특정 문자열을 작성할 때, 키를 최소 몇 번 눌러야 그 문자열을 작성할 수 있는지 알아보고자 합니다.

1번 키부터 차례대로 할당된 문자들이 순서대로 담긴 문자열배열 keymap과 입력하려는 문자열들이 담긴 문자열 배열 targets가 주어질 때, 각 문자열을 작성하기 위해 키를 최소 몇 번씩 눌러야 하는지 순서대로 배열에 담아 return 하는 solution 함수를 완성해 주세요.

단, 목표 문자열을 작성할 수 없을 때는 -1을 저장합니다.

제한 사항

• 1 ≤ keymap의 길이 ≤ 100
  • 1 ≤ keymap의 원소의 길이 ≤ 100
  • keymap[i]는 i + 1번 키를 눌렀을 때 순서대로 바뀌는 문자를 의미합니다.
    • 예를 들어 keymap[0] = "ABACD" 인 경우 1번 키를 한 번 누르면 A, 두 번 누르면 B, 세 번 누르면 A 가 됩니다.
  • keymap의 원소의 길이는 서로 다를 수 있습니다.
  • keymap의 원소는 알파벳 대문자로만 이루어져 있습니다.
• 1 ≤ targets의 길이 ≤ 100
  • 1 ≤ targets의 원소의 길이 ≤ 100
  • targets의 원소는 알파벳 대문자로만 이루어져 있습니다.

입출력 예

입출력 예 설명

입출력 예 #1 "ABCD"의 경우, 1번 키 한 번 → A 2번 키 한 번 → B 2번 키 두 번 → C 1번 키 다섯 번 → D 따라서 총합인 9를 첫 번째 인덱스에 저장합니다. "AABB"의 경우, 1번 키 한 번 → A 1번 키 한 번 → A 2번 키 한 번 → B 2번 키 한 번 → B 따라서 총합인 4를 두 번째 인덱스에 저장합니다. 결과적으로 [9,4]를 return 합니다.

입출력 예 #2 "B"의 경우, 'B'가 어디에도 존재하지 않기 때문에 -1을 첫 번째 인덱스에 저장합니다. 결과적으로 [-1]을 return 합니다.

입출력 예 #3 "ASA"의 경우, 1번 키 한 번 → A 2번 키 두 번 → S 1번 키 한 번 → A 따라서 총합인 4를 첫 번째 인덱스에 저장합니다. "BGZ"의 경우, 2번 키 한 번 → B 1번 키 두 번 → G 1번 키 세 번 → Z 따라서 총합인 6을 두 번째 인덱스에 저장합니다. 결과적으로 [4, 6]을 return 합니다.

제출 코드

function solution(keymap, targets) {
  // 문자별 최소 누름 횟수
  const char_min_press = {};

  // keymap 순회
  for (let i = 0; i < keymap.length; i++) {
    const key = keymap[i];

    for (let j = 0; j < key.length; j++) {
      const char = key[j];
      const press_count = j + 1;

      if (char_min_press[char] === undefined) {
        char_min_press[char] = press_count;
      } else if (char_min_press[char] > press_count) {
        char_min_press[char] = press_count;
      }
    }
  }

  // targets 계산
  const result = [];

  for (let i = 0; i < targets.length; i++) {
    const target = targets[i];
    let total_press = 0;
    let is_possible = true;

    for (let j = 0; j < target.length; j++) {
      const char = target[j];

      if (char_min_press[char] === undefined) {
        is_possible = false;
        break;
      }

      total_press += char_min_press[char];
    }

    result.push(is_possible ? total_press : -1);
  }

  return result;
}

문제 설명

문자열 s가 주어졌을 때, s의 각 위치마다 자신보다 앞에 나왔으면서, 자신과 가장 가까운 곳에 있는 같은 글자가 어디 있는지 알고 싶습니다. 예를 들어, s="banana"라고 할 때, 각 글자들을 왼쪽부터 오른쪽으로 읽어 나가면서 다음과 같이 진행할 수 있습니다.

b는 처음 나왔기 때문에 자신의 앞에 같은 글자가 없습니다. 이는 -1로 표현합니다. a는 처음 나왔기 때문에 자신의 앞에 같은 글자가 없습니다. 이는 -1로 표현합니다. n은 처음 나왔기 때문에 자신의 앞에 같은 글자가 없습니다. 이는 -1로 표현합니다. a는 자신보다 두 칸 앞에 a가 있습니다. 이는 2로 표현합니다. n도 자신보다 두 칸 앞에 n이 있습니다. 이는 2로 표현합니다. a는 자신보다 두 칸, 네 칸 앞에 a가 있습니다. 이 중 가까운 것은 두 칸 앞이고, 이는 2로 표현합니다. 따라서 최종 결과물은 [-1, -1, -1, 2, 2, 2]가 됩니다.

문자열 s이 주어질 때, 위와 같이 정의된 연산을 수행하는 함수 solution을 완성해주세요.

제한 사항

• 1 ≤ s의 길이 ≤ 10,000
  • s은 영어 소문자로만 이루어져 있습니다.

입출력 예

입출력 예 설명

입출력 예 #1 지문과 같습니다.

입출력 예 #2 설명 생략

제출 코드

function solution(s) {
    const answer = [];
    const last_index_map = {}; // 문자별 마지막 등장 위치

    for (let i = 0; i < s.length; i++) {
        const current_char = s[i];

        if (last_index_map[current_char] === undefined) {
            // 처음 등장
            answer.push(-1);
        } else {
            // 이전 위치와의 거리
            answer.push(i - last_index_map[current_char]);
        }

        // 현재 위치로 갱신
        last_index_map[current_char] = i;
    }

    return answer;
}

문제 설명

두 문자열 s와 skip, 그리고 자연수 index가 주어질 때, 다음 규칙에 따라 문자열을 만들려 합니다. 암호의 규칙은 다음과 같습니다.

문자열 s의 각 알파벳을 index만큼 뒤의 알파벳으로 바꿔줍니다. index만큼의 뒤의 알파벳이 z를 넘어갈 경우 다시 a로 돌아갑니다. skip에 있는 알파벳은 제외하고 건너뜁니다. 예를 들어 s = "aukks", skip = "wbqd", index = 5일 때, a에서 5만큼 뒤에 있는 알파벳은 f지만 [b, c, d, e, f]에서 'b'와 'd'는 skip에 포함되므로 세지 않습니다. 따라서 'b', 'd'를 제외하고 'a'에서 5만큼 뒤에 있는 알파벳은 [c, e, f, g, h] 순서에 의해 'h'가 됩니다. 나머지 "ukks" 또한 위 규칙대로 바꾸면 "appy"가 되며 결과는 "happy"가 됩니다.

두 문자열 s와 skip, 그리고 자연수 index가 매개변수로 주어질 때 위 규칙대로 s를 변환한 결과를 return하도록 solution 함수를 완성해주세요.

제한 사항

• 5 ≤ s의 길이 ≤ 50
• 1 ≤ skip의 길이 ≤ 10
• s와 skip은 알파벳 소문자로만 이루어져 있습니다.
  • skip에 포함되는 알파벳은 s에 포함되지 않습니다.
• 1 ≤ index ≤ 20

입출력 예

입출력 예 설명

입출력 예 #1 본문 내용과 일치합니다.

제출 코드

function solution(s, skip, index) {
    var answer = '';
    let pass = [];

    // skip → 아스키 코드
    for (let i = 0; i < skip.length; i++) {
        pass.push(skip[i].charCodeAt());
    }

    // 문자열은 수정 불가 → 배열로 변환
    let arr = [];
    for (let i = 0; i < s.length; i++) {
        arr.push(s[i].charCodeAt());
    }

    let i = 0;
    let cnt = 0;

    while (i < arr.length) {
        arr[i]++;

        // z 초과 시 a로
        if (arr[i] > 122) arr[i] = 97;

        // skip 문자면 다시 증가
        if (pass.includes(arr[i])) continue;

        cnt++;
        if (cnt === index) {
            cnt = 0;
            i++;
        }
    }

    // 여기서 아스키 → 문자 변환 후 answer에 추가
    for (let i = 0; i < arr.length; i++) {
        answer += String.fromCharCode(arr[i]);
    }

    return answer;
}

문제 설명

코니는 영어 단어가 적힌 카드 뭉치 두 개를 선물로 받았습니다. 코니는 다음과 같은 규칙으로 카드에 적힌 단어들을 사용해 원하는 순서의 단어 배열을 만들 수 있는지 알고 싶습니다.

원하는 카드 뭉치에서 카드를 순서대로 한 장씩 사용합니다. 한 번 사용한 카드는 다시 사용할 수 없습니다. 카드를 사용하지 않고 다음 카드로 넘어갈 수 없습니다. 기존에 주어진 카드 뭉치의 단어 순서는 바꿀 수 없습니다. 예를 들어 첫 번째 카드 뭉치에 순서대로 ["i", "drink", "water"], 두 번째 카드 뭉치에 순서대로 ["want", "to"]가 적혀있을 때 ["i", "want", "to", "drink", "water"] 순서의 단어 배열을 만들려고 한다면 첫 번째 카드 뭉치에서 "i"를 사용한 후 두 번째 카드 뭉치에서 "want"와 "to"를 사용하고 첫 번째 카드뭉치에 "drink"와 "water"를 차례대로 사용하면 원하는 순서의 단어 배열을 만들 수 있습니다.

문자열로 이루어진 배열 cards1, cards2와 원하는 단어 배열 goal이 매개변수로 주어질 때, cards1과 cards2에 적힌 단어들로 goal를 만들 있다면 "Yes"를, 만들 수 없다면 "No"를 return하는 solution 함수를 완성해주세요.

제한 사항

• 1 ≤ cards1의 길이, cards2의 길이 ≤ 10
  • 1 ≤ cards1[i]의 길이, cards2[i]의 길이 ≤ 10
  • cards1과 cards2에는 서로 다른 단어만 존재합니다.
• 2 ≤ goal의 길이 ≤ cards1의 길이 + cards2의 길이
  • 1 ≤ goal[i]의 길이 ≤ 10
  • goal의 원소는 cards1과 cards2의 원소들로만 이루어져 있습니다.
• cards1, cards2, goal의 문자열들은 모두 알파벳 소문자로만 이루어져 있습니다.

입출력 예

입출력 예 설명

입출력 예 #1 본문과 같습니다.

입출력 예 #2 cards1에서 "i"를 사용하고 cards2에서 "want"와 "to"를 사용하여 "i want to"까지는 만들 수 있지만 "water"가 "drink"보다 먼저 사용되어야 하기 때문에 해당 문장을 완성시킬 수 없습니다. 따라서 "No"를 반환합니다.

제출 코드

function solution(cards1, cards2, goal) {
  let i = 0; // cards1 포인터
  let j = 0; // cards2 포인터

  for (const word of goal) {
    if (i < cards1.length && cards1[i] === word) {
      i++;
    } else if (j < cards2.length && cards2[j] === word) {
      j++;
    } else {
      return "No";
    }
  }

  return "Yes";
}

문제 설명

지나다니는 길을 'O', 장애물을 'X'로 나타낸 직사각형 격자 모양의 공원에서 로봇 강아지가 산책을 하려합니다. 산책은 로봇 강아지에 미리 입력된 명령에 따라 진행하며, 명령은 다음과 같은 형식으로 주어집니다.

["방향 거리", "방향 거리" … ] 예를 들어 "E 5"는 로봇 강아지가 현재 위치에서 동쪽으로 5칸 이동했다는 의미입니다. 로봇 강아지는 명령을 수행하기 전에 다음 두 가지를 먼저 확인합니다.

주어진 방향으로 이동할 때 공원을 벗어나는지 확인합니다. 주어진 방향으로 이동 중 장애물을 만나는지 확인합니다. 위 두 가지중 어느 하나라도 해당된다면, 로봇 강아지는 해당 명령을 무시하고 다음 명령을 수행합니다. 공원의 가로 길이가 W, 세로 길이가 H라고 할 때, 공원의 좌측 상단의 좌표는 (0, 0), 우측 하단의 좌표는 (H - 1, W - 1) 입니다. 공원을 나타내는 문자열 배열 park, 로봇 강아지가 수행할 명령이 담긴 문자열 배열 routes가 매개변수로 주어질 때, 로봇 강아지가 모든 명령을 수행 후 놓인 위치를 [세로 방향 좌표, 가로 방향 좌표] 순으로 배열에 담아 return 하도록 solution 함수를 완성해주세요.

제한 사항

• 3 ≤ park의 길이 ≤ 50
  • 3 ≤ park[i]의 길이 ≤ 50
    • park[i]는 다음 문자들로 이루어져 있으며 시작지점은 하나만 주어집니다.
      • S : 시작 지점
      • O : 이동 가능한 통로
      • X : 장애물
    • park는 직사각형 모양입니다.
• 1 ≤ routes의 길이 ≤ 50
  • routes의 각 원소는 로봇 강아지가 수행할 명령어를 나타냅니다.
  • 로봇 강아지는 routes의 첫 번째 원소부터 순서대로 명령을 수행합니다.
  • routes의 원소는 "op n"과 같은 구조로 이루어져 있으며, op는 이동할 방향, n은 이동할 칸의 수를 의미합니다.
    • op는 다음 네 가지중 하나로 이루어져 있습니다.
      • N : 북쪽으로 주어진 칸만큼 이동합니다.
      • S : 남쪽으로 주어진 칸만큼 이동합니다.
      • W : 서쪽으로 주어진 칸만큼 이동합니다.
      • E : 동쪽으로 주어진 칸만큼 이동합니다.
    • 1 ≤ n ≤ 9

입출력 예

입출력 예 설명

입출력 예 #1 입력된 명령대로 동쪽으로 2칸, 남쪽으로 2칸, 서쪽으로 1칸 이동하면 [0,0] -> [0,2] -> [2,2] -> [2,1]이 됩니다.

입출력 예 #2 입력된 명령대로라면 동쪽으로 2칸, 남쪽으로 2칸, 서쪽으로 1칸 이동해야하지만 남쪽으로 2칸 이동할 때 장애물이 있는 칸을 지나기 때문에 해당 명령을 제외한 명령들만 따릅니다. 결과적으로는 [0,0] -> [0,2] -> [0,1]이 됩니다.

입출력 예 #3 처음 입력된 명령은 공원을 나가게 되고 두 번째로 입력된 명령 또한 장애물을 지나가게 되므로 두 입력은 제외한 세 번째 명령만 따르므로 결과는 다음과 같습니다. [0,1] -> [0,0]

제출 코드

function solution(park, routes) {
    let current_row = 0;
    let current_col = 0;

    const park_height = park.length;
    const park_width = park[0].length;

    // 시작 위치 찾기
    for (let i = 0; i < park_height; i++) {
        for (let j = 0; j < park_width; j++) {
            if (park[i][j] === "S") {
                current_row = i;
                current_col = j;
            }
        }
    }

    // 방향별 이동 정의
    const direction_map = {
        "N": [-1, 0],
        "S": [1, 0],
        "W": [0, -1],
        "E": [0, 1]
    };

    //  명령 수행
    for (let i = 0; i < routes.length; i++) {
        const [direction, distance_str] = routes[i].split(" ");
        const distance = Number(distance_str);

        const [move_row, move_col] = direction_map[direction];

        let next_row = current_row;
        let next_col = current_col;
        let can_move = true;

        //  이동 가능 여부 미리 검사
        for (let step = 0; step < distance; step++) {
            next_row += move_row;
            next_col += move_col;

            // 공원 벗어나는지 확인
            if (next_row < 0 || next_row >= park_height || next_col < 0 || next_col >= park_width) {
                can_move = false;
                break;
            }

            // 장애물 확인
            if (park[next_row][next_col] === "X") {
                can_move = false;
                break;
            }
        }

        // 문제가 없을 때만 실제 이동
        if (can_move) {
            current_row = next_row;
            current_col = next_col;
        }
    }

    return [current_row, current_col];
}