읍내리 까치골

[C++] 백준 33665번: 트레이드 AI - 단순 구현

KDLove5500 — Mon, 9 Feb 2026 01:15:47 +0900

solved.ac 프로필배경이 어떤게 추가가 되었나 둘러보다가, 옛날같았으면 대회에 참여해야 주던 배경을 이제는 문제 풀이로도 받을 수 있는 것들이 생겼다는 것을 보게 되었습니다. 기왕 봤는데... 해봐야겠죠?

(결론부터 말하자면 일단 얻었습니다)

33665번 문제는 단순 구현 문제이며 링크는 아래와 같습니다.
https://www.acmicpc.net/problem/33665

문제 파악

입력 형태가 조금 복잡해 보이고 모노폴리라는 게임을 언급하여 문제 풀이가 어려워 보일 수도 있는데, 이해하고 나면 크게 어려운 것 없이 진행하실 수 있을 것이라 생각합니다. 핵심 문장은 아래입니다.

게임을 하는 도중에 트레이드 조건이 주어질 때, 트레이드가 자신에게 이득인지를 파악하는 것이 이 문제의 핵심입니다. 현상 유지 또는 자산의 증가라면 YES, 자산의 감소를 불러올 경우 NO를 출력하는 것입니다.

입력 형식 분석

입력 형식과 함께 문제의 주요 변수를 살펴보겠습니다.

일단 게임 내 40개의 도시가 존재하며, 이 문제는 보유한 도시의 트레이딩에서 이익을 찾는 것입니다. 총 10개의 구역이 존재하고, 각 구역별로 4개의 도시가 존재합니다. 구역 내 도시의 각 가격은 동일한 것으로 간주하되, 구역 내 몇 개의 도시를 보유하느냐에 따라 자산 가치가 달라지는 것으로 생각하면 되겠습니다. 이 때 자산 가치는 선형이 아님에 유의합니다. (서초구에 부동산 4개를 소유하면 떼부자가 될 수도 있겠지만 다주택자로 과세폭탄을 맞을 수 있음을 생각하면 될 것 같습니다)

11번째 줄은 도시의 소유자를 의미, 0은 소유주 없음, 1은 나의 도시, 2는 상대의 도시입니다.
12번째 줄은 트레이딩 희망이며 1의 경우 내가 상대로부터 도시를 매입하고자 할 때, 2의 경우 상대가 내 도시를 매입하고자 함을 의미합니다.
13번째 줄은 담보의 유무를 의미하는데, 도시에 담보가 잡혔을 경우 자산 가치를 낮게 간주합니다. 감산은 비율이 아닌 정액제로 가장 마지막 줄(19번째 줄)입니다.
14번째 줄은 내가 가지고 있는 현금, 15번째 줄은 상대가 가지고 있는 현금이며, 16번째 줄은 내가 상대의 도시를 매입하기 위해 제시한 현금(2000원을 줘야 함)이고 17번째 줄은 상대가 나의 도시를 매입하기 위해 제시한 현금(4000원을 받게 됨)입니다.
마지막으로 18번째 줄은 현금 가치의 비율을 얼마로 볼 것인지에 대한 백분율 값이며 예제 3번 입력의 경우 10이므로 10%입니다. (만 원 소유 시 천 원으로 봄)

필요 변수

각 구역마다 도시를 0개부터 4개까지 5단계로 보유 상태를 가질 수 있고, 그에 따라 자산 가중치가 달라집니다. 또한 도시의 담보 여부에 따라 자산의 평가액 감소가 이뤄집니다. 트레이딩의 수락/거부 의사 결정을 위하여 트레이딩 전과 후의 가치를 각각 계산하여야 합니다. 따라서 아래의 변수가 필요할 것으로 판단하였습니다.

각 구역 별 보유 도시 개수에 따른 평가액 : int value[][]
현재 보유 중인 도시 현황 : int owner[][]
트레이드 후 보유 예정인 도시 : int trade[][]
도시의 담보 여부 : int mortgage[][]
현재 가지고 있는 현금 : int cash
제시한 거래액 : int price
거래 이후 가지고 있을 잔액 : int change
자산 총계 : int sum

위 내용을 코드로 작성하여 아래와 같이 정리하였습니다.

// ============================== Declare Variables ===============================
int value[10][5] = {0};         // 1 ~ 10
int owner[10][6] = {0};         // 11
int trade[10][6] = {0};         // 12
bool mortgage[10][5] = {false}; // 13
string tmp;                     // for 11~13
int cashA, cashB, priceA, priceB, cashRate, mortgagePrice,  // 14~19
    resultBefore = 0, resultAfter = 0, changeA, changeB,

    beforeSumA = 0,         afterSumA = 0,      beforeSumB = 0,         afterSumB = 0,
    beforeMortgageA = 0,    afterMortgageA = 0, beforeMortgageB = 0,    afterMortgageB = 0;

자산 총계 계산 시 담보액을 따로 계산하기 위하여 별도의 변수로 작성하였으며, 거래 전/후 비교가 필요하므로 before/after로 구분하였습니다. 변수명에서 A는 나, B는 상대를 의미합니다.

owner와 trade 2차원 배열은 열을 총 6개로 설정하였는데, 각 구역의 1,2,3,4번 도시의 소유 여부를 확인하기 위해 1~4번 열을 소유자(1, 2)를 표시하는데 사용하였습니다. 이 문제에서는 구역 내 도시를 "몇 개" 소유하였느냐가 핵심입니다. (구역 내 어느 도시를 소유하였는지는 중요하지 않습니다 - 담보 확인 시에만 사용.) 따라서 0번 열을 구역 내 내가 소유한 도시의 개수, 5번 열을 상대가 소유한 도시의 개수로 사용하였습니다. 담보(mortgage)의 0번 열은 버리는 열이 되었습니다. 계산의 정확성 및 분석 용이를 위해 1~4번으로 통일하였습니다.

입력 받기

이제 앞서 분석한 내용에 맞추어 입력을 받을 차례입니다. 계산 과정은 입력 이후에 설명하도록 하겠습니다. 데이터의 순서대로 입력 과정을 나누어 설명하였습니다.

각 구역의 보유 도시 수에 따른 자산 가중치

// ================================ Input Values ===================================
// line 1 ~ 10 - values of city
    for (int i=0; i<10; i++)
       cin >> value[i][1] >> value[i][2] >> value[i][3] >> value[i][4];

0번 구역부터 10번 구역까지, 자산 가중치를 입력합니다. 0개 보유시에는 자산 가치가 0이므로 별도 설정하지 않습니다.

각 도시의 소유자 상태

// line 11 Owner
    cin>>tmp;
    for (int i=0; i<40; i++) {
        owner[i/4][i%4+1] = tmp[i]-'0';
    }

owner 배열을 2차원으로 설정하였는데 입력은 0, 1, 2로 구성된 40개의 숫자로 들어옵니다. 따라서 string으로 받은 뒤 각 자리를 돌며 값을 할당합니다. 4개씩 끊어야 하므로 i/4, i%4 연산을 통해 2차원으로 변환시켜 주었습니다. (integer 연산에 따라 나눗셈 연산 시 소수점은 절사됩니다.) 모듈러 연산은 4일 경우 0, 1, 2, 3이 나오므로 +1 해주었습니다.

트레이딩 후 소유자 상태

// line 12 Trade
    cin>>tmp;
    for (int i=0; i<40; i++) {
        if (tmp[i] == '0')
            trade[i/4][i%4+1] = owner[i/4][i%4+1];
        else
            trade[i/4][i%4+1] = tmp[i]-'0';
    }

트레이딩을 진행하게 될 경우 기존의 소유 상태에서 교환을 희망하는 도시만 변경이 이루어집니다. 도시의 트레이딩은 상대가 소유한 도시를 희망하는 것이기 때문에, 기존 상태에서 소유권이 없던 도시(0)는 그대로 두면 됩니다. 또한 트레이딩 대상이 아닌 도시도 그대로 두면 되고, 트레이딩 희망하는 경우만 반영하면 되겠습니다.
따라서 트레이딩 희망 여부가 0인 경우 기존의 값 복사, 그 외의 값인 경우 신규 소유자로 덮어씌우면 되겠습니다.

담보 여부

// line 13 Mortgage
    cin>>tmp;
    for (int i=0; i<40; i++) {
        mortgage[i/4][i%4+1] = tmp[i]-'0';
    }

담보 여부를 저장하는 mortgage는 boolean 배열로 0(false)과 1(true)를 저장 가능합니다. 주어지는 입력도 0과 1이므로 해당 형식에 맞게 저장해줍니다. 이 배열은 자산 계산 시 도시 소유자 정보와 연동하면 됩니다.

보유 현금, 제시 가격, 현금 평가비율, 담보 페널티 금액, 거래 후 보유 현금

// 나머지 라인
    // line 14 ~ 15 Cash
    cin>>cashA>>cashB;
    // line 16 ~ 17 Price
    cin>>priceA>>priceB;
    // line 18 ~ 19 Rate
    cin>>cashRate>>mortgagePrice;

    // Cash at after trade
    changeA = cashA - priceA + priceB, changeB = cashB - priceB + priceA;

나머지 입력 부분입니다. 그대로 정수 변수들에 모두 저장해주면 되겠습니다. 입력이 끝난 후 거래 후 보유 현금을 미리 계산해두었습니다. A의 잔고는 최초 A의 현금 보유액에서 B에게 준 금액(priceA)을 제하고 B에게 받은 금액(priceB)을 더해주면 됩니다. B의 잔고도 동일하게 처리하면 됩니다.
이로써 입력 과정이 끝났습니다.

자산 계산하기

입력을 받아왔으니 이제 계산만 하면 됩니다.
거래 전 후로 A(나)와 B(상대)의 도시 보유 상태와 담보 여부 및 현금 계산만 해주면 됩니다. 도시가 40개씩이나 되어서 복잡해보일 수도 있는데 속성이 도시, 담보, 현금 3가지이기에 간단하게 계산이 가능합니다. 변수가 많아서 조금 헷갈릴 수는 있습니다.

거래 전/후 보유 도시 개수 계산

// ============================== Calculate Result =================================
// sum of city
    for (int i=0; i<10; i++) {
        // loop in 10 color
        for (int j=1; j<=4; j++) {
            // loop in 4 city in each color
            if (owner[i][j] == 1) owner[i][0]++;
            if (owner[i][j] == 2) owner[i][5]++;
            if (trade[i][j] == 1) trade[i][0]++;
            if (trade[i][j] == 2) trade[i][5]++;
        }
    }

앞서 owner 배열과 trade 배열의 각각 0열과 5열을 A와 B의 보유 도시 개수를 저장하기 위해 6열짜리로 선언했다고 언급했었습니다. 그에 맞게 각 구역 별 A와 B의 보유 도시 개수를 계산해줍니다. owner 배열이 거래 이전 원래 소유자, trade 배열이 거래 이후 변경된 소유 상태를 저장한 배열입니다.각 배열 0열과 5열은 0부터 3사이의 값을 갖게 됩니다.

거래 전 자산에 대한 계산

// Before Trade----------------------------
    // City value
    for (int i=0; i<10; i++) {
        beforeSumA += value[i][owner[i][0]];
        beforeSumB += value[i][owner[i][5]];
    }

    // Cash value
    beforeSumA += cashA * cashRate / 100;
    beforeSumB += cashB * cashRate / 100;

    // Mortgage
    for (int i=0; i<10; i++)
        for (int j=1; j<=4; j++)
            if (mortgage[i][j] == true) {
                if (owner[i][j] == 1) beforeMortgageA++;
                if (owner[i][j] == 2) beforeMortgageB++;
            }
    beforeSumA -= mortgagePrice * beforeMortgageA;
    beforeSumB -= mortgagePrice * beforeMortgageB;

    // result
    resultBefore = beforeSumA - beforeSumB;

자산에 대한 계산은 도시의 보유 가치 + 현금 가치 - 담보 페널티 금액입니다. 10개 구역 각각의 보유 도시 개수에 따른 자산 가치를 합하고, 그 다음 현금 보유액에 평가 비율을 곱하여 합하고, 보유 도시에서 담보에 해당하는 개수만큼 페널티 금액을 곱해 제합니다. 이 과정을 거쳐 A와 B의 합계(Sum)를 도출하고 거래 전 계산 값으로 저장합니다.

거래 후 자산에 대한 계산

// After Trade-----------------------------
    // City value
    for (int i=0; i<10; i++) {
        afterSumA += value[i][trade[i][0]];
        afterSumB += value[i][trade[i][5]];
    }

    // Cash value
    afterSumA += changeA * cashRate / 100;
    afterSumB += changeB * cashRate / 100;

    // Mortgage
    for (int i=0; i<10; i++)
        for (int j=1; j<=4; j++)
            if (mortgage[i][j] == true) {
                if (trade[i][j] == 1) afterMortgageA++;
                if (trade[i][j] == 2) afterMortgageB++;
            }
    afterSumA -= mortgagePrice * afterMortgageA;
    afterSumB -= mortgagePrice * afterMortgageB;

    resultAfter = afterSumA - afterSumB;

거래 후 자산 계산도 동일한 과정을 거치게 됩니다. 변수명만 차이가 있고 나머지는 동일한 과정을 거칩니다.

정답 도출

전/후 자산 평가액을 모두 구하였으므로 두 값을 비교하여 결과값을 출력하면 됩니다.

// ================================ Print Answer ===================================
    if (resultAfter - resultBefore >= 0)
        cout << "YES";
    else
        cout << "NO";

    return 0;

트레이딩 후의 자산 차이 값이 트레이딩 전보다 크거나 같으면 YES입니다. 자산 차이가 줄어들었다는 것은 격차가 좁혀졌다는 뜻이고, 내가 손해를 보았다는 뜻이니 트레이딩을 거절하여야(NO)합니다. 자산 차이 값이 음수 (내가 상대한테 지고 있던 경우) 또한 동일한 결과를 갖습니다.

번외: 차트 출력

백준 문제 페이지에서는 각 예제에 대하여 비교 차트를 제공하고 있습니다. 본 문제는 변수의 종류가 너무 많은 관계로 저도 풀이 중 디버그 목적으로 아래와 같은 차트 표시 함수를 제작하여 활용하였습니다.

void printChart() {
    printf("\n\n");
    printf("          |          Before Trade         |          After Trade\n");
    printf("          |       Me      |      Rival    |       Me      |      Rival    \n");
    printf("          |Origin  Convert|Origin  Convert|Origin  Convert|Origin  Convert\n");
    printf("--------------------------------------------------------------------------\n");
    for (int i=0; i<10; i++)
        printf("  City %c  | %6d  %5d | %6d  %5d | %6d  %5d | %6d  %5d \n", i+65,
            owner[i][0], value[i][owner[i][0]], owner[i][5], value[i][owner[i][5]],
            trade[i][0], value[i][trade[i][0]], trade[i][5], value[i][trade[i][5]]);
    printf("--------------------------------------------------------------------------\n");
    printf("   Cash   | %6d  %5d | %6d  %5d | %6d  %5d | %6d  %5d \n",
        cashA, cashA*cashRate/100, cashB, cashB*cashRate/100,
        changeA, changeA*cashRate/100, changeB, changeB*cashRate/100);
    printf(" Mortgage | %6d  %5d | %6d  %5d | %6d  %5d | %6d  %5d \n",
        beforeMortgageA, beforeMortgageA*mortgagePrice, beforeMortgageB, beforeMortgageB*mortgagePrice,
        afterMortgageA, afterMortgageA*mortgagePrice, afterMortgageB, afterMortgageB*mortgagePrice);
    printf("--------------------------------------------------------------------------\n");
    printf("    Sum   |     %6d    |     %6d    |     %6d    |     %6d\n",
        beforeSumA, beforeSumB, afterSumA, afterSumB);
    printf(" Distance |            %6d             |            %6d\n", resultBefore, resultAfter);
}

포맷 지정의 편의를 위하여 printf를 사용하였습니다. 입출력 속도를 위해 sync_with_stdio를 false로 설정하신 경우 printf 사용시 에러가 날 수 있습니다.

예제 3번에 대한 차트 출력 결과

마무리

골드5 레벨의 문제 치고는 해법은 비교적 간단합니다. 문제의 태그도 '구현' 하나만 되어있습니다. 다만 변수의 종류가 워낙 많고, 변수 구성을 어떻게 하고 연산 처리를 어떻게 하느냐에 대하여 수 분 내 뚝딱 할만한 문제는 아닌 것 같아 해당 레벨이 붙은게 아닐까 싶습니다.

본 풀이는 마지막의 차트 출력 부분을 함께 보여주기 위해서 변수를 필요보다 많이 선언한 경향이 있습니다. 백준 PS 문제들의 경우 실무와는 다르게 원본 값의 보존이 중요하지 않은 경우가 많아 변수 재활용 등의 방법으로 풀이가 가능합니다. 풀이의 방법은 무궁무진하니 여러 방법 중 하나라고 생각해주시면 감사하겠습니다.

아래 전체 코드를 첨부하겠습니다. 그대로 갖다붙여 제출하시면 백준의 윤리 규정에 의거 시스템에 의해 계정에 제재를 받을 수 있으니 참고용으로만 보시기 바랍니다.

#include <iostream>

#define endl '\n'

using namespace std;

// ============================== Declare Variables ===============================
int value[10][5] = {0};         // 1 ~ 10
int owner[10][6] = {0};         // 11
int trade[10][6] = {0};         // 12
bool mortgage[10][5] = {false}; // 13
string tmp;                     // for 11~13
int cashA, cashB, priceA, priceB, cashRate, mortgagePrice,  // 14~19
    resultBefore = 0, resultAfter = 0, changeA, changeB,

    beforeSumA = 0,         afterSumA = 0,      beforeSumB = 0,         afterSumB = 0,
    beforeMortgageA = 0,    afterMortgageA = 0, beforeMortgageB = 0,    afterMortgageB = 0;

void printChart();

int main() {

    // ================================ Input Values ===================================
    // line 1 ~ 10 - values of city
    for (int i=0; i<10; i++)
        cin >> value[i][1] >> value[i][2] >> value[i][3] >> value[i][4];

    // line 11 Owner
    cin>>tmp;
    for (int i=0; i<40; i++) {
        owner[i/4][i%4+1] = tmp[i]-'0';
    }
    // line 12 Trade
    cin>>tmp;
    for (int i=0; i<40; i++) {
        if (tmp[i] == '0')
            trade[i/4][i%4+1] = owner[i/4][i%4+1];
        else
            trade[i/4][i%4+1] = tmp[i]-'0';
    }
    // line 13 Mortgage
    cin>>tmp;
    for (int i=0; i<40; i++) {
        mortgage[i/4][i%4+1] = tmp[i]-'0';
    }
    // line 14 ~ 15 Cash
    cin>>cashA>>cashB;
    // line 16 ~ 17 Price
    cin>>priceA>>priceB;
    // line 18 ~ 19 Rate
    cin>>cashRate>>mortgagePrice;

    // Cash at after trade
    changeA = cashA - priceA + priceB, changeB = cashB - priceB + priceA;

    // ============================== Calculate Result =================================
    // sum of city
    for (int i=0; i<10; i++) {
        // loop in 10 color
        for (int j=1; j<=4; j++) {
            // loop in 4 city in each color
            if (owner[i][j] == 1) owner[i][0]++;
            if (owner[i][j] == 2) owner[i][5]++;
            if (trade[i][j] == 1) trade[i][0]++;
            if (trade[i][j] == 2) trade[i][5]++;
        }
    }

    // Before Trade----------------------------
    // City value
    for (int i=0; i<10; i++) {
        beforeSumA += value[i][owner[i][0]];
        beforeSumB += value[i][owner[i][5]];
    }

    // Cash value
    beforeSumA += cashA * cashRate / 100;
    beforeSumB += cashB * cashRate / 100;

    // Mortgage
    for (int i=0; i<10; i++)
        for (int j=1; j<=4; j++)
            if (mortgage[i][j] == true) {
                if (owner[i][j] == 1) beforeMortgageA++;
                if (owner[i][j] == 2) beforeMortgageB++;
            }
    beforeSumA -= mortgagePrice * beforeMortgageA;
    beforeSumB -= mortgagePrice * beforeMortgageB;

    // result
    resultBefore = beforeSumA - beforeSumB;

    // After Trade-----------------------------
    // City value
    for (int i=0; i<10; i++) {
        afterSumA += value[i][trade[i][0]];
        afterSumB += value[i][trade[i][5]];
    }

    // Cash value
    afterSumA += changeA * cashRate / 100;
    afterSumB += changeB * cashRate / 100;

    // Mortgage
    for (int i=0; i<10; i++)
        for (int j=1; j<=4; j++)
            if (mortgage[i][j] == true) {
                if (trade[i][j] == 1) afterMortgageA++;
                if (trade[i][j] == 2) afterMortgageB++;
            }
    afterSumA -= mortgagePrice * afterMortgageA;
    afterSumB -= mortgagePrice * afterMortgageB;

    resultAfter = afterSumA - afterSumB;

    // ================================ Print Answer ===================================
    if (resultAfter - resultBefore >= 0)
        cout << "YES";
    else
        cout << "NO";

    printChart();

    return 0;
}

void printChart() {
    printf("\n\n");
    printf("          |          Before Trade         |          After Trade\n");
    printf("          |       Me      |      Rival    |       Me      |      Rival    \n");
    printf("          |Origin  Convert|Origin  Convert|Origin  Convert|Origin  Convert\n");
    printf("--------------------------------------------------------------------------\n");
    for (int i=0; i<10; i++)
        printf("  City %c  | %6d  %5d | %6d  %5d | %6d  %5d | %6d  %5d \n", i+65,
            owner[i][0], value[i][owner[i][0]], owner[i][5], value[i][owner[i][5]],
            trade[i][0], value[i][trade[i][0]], trade[i][5], value[i][trade[i][5]]);
    printf("--------------------------------------------------------------------------\n");
    printf("   Cash   | %6d  %5d | %6d  %5d | %6d  %5d | %6d  %5d \n",
        cashA, cashA*cashRate/100, cashB, cashB*cashRate/100,
        changeA, changeA*cashRate/100, changeB, changeB*cashRate/100);
    printf(" Mortgage | %6d  %5d | %6d  %5d | %6d  %5d | %6d  %5d \n",
        beforeMortgageA, beforeMortgageA*mortgagePrice, beforeMortgageB, beforeMortgageB*mortgagePrice,
        afterMortgageA, afterMortgageA*mortgagePrice, afterMortgageB, afterMortgageB*mortgagePrice);
    printf("--------------------------------------------------------------------------\n");
    printf("    Sum   |     %6d    |     %6d    |     %6d    |     %6d\n",
        beforeSumA, beforeSumB, afterSumA, afterSumB);
    printf(" Distance |            %6d             |            %6d\n", resultBefore, resultAfter);
}

[C++] 백준 10989 : 정렬의 다른 접근방법 (Counting)

KDLove5500 — Sun, 1 Feb 2026 17:53:31 +0900

편의점에서 야간 근무 중 한산한 시간에 백준을 들어갔다가, 재미있는 문제를 풀어서 글을 써봅니다.

어렵지는 않은데 접근법을 달리하는 것이 저난도 PS의 재미인 것 같습니다.

https://www.acmicpc.net/problem/10989

정렬 문제인데 일반적인 vector<>와 sort()를 사용하는 접근법이 불가능한 문제입니다.

그 이유는 입력 조건에 있습니다.

데이터 개수가 총 천만(10,000,000)건
메모리 제한 8mb
각 요소는 10,000 이하 자연수

단순 계산으로 천만 건의 데이터를 8mb 안에 담는 것은 불가능합니다

int : 4byte * 10,000,000 = 40mb

shrot: 2byte * 10,000,000 = 20mb

byte형 또한 10mb에 달하는 것과 동시에 unsigned를 사용하여도 512까지 표현가능하니 사용할 수 없습니다. 따라서 일반적인 sort 대신 다른 접근을 하여야 합니다. 힌트는 위의 조건에 있는데, 데이터가 "천만 건"씩이나 되지만 그 범위는 "1부터 10,000까지"라는 것입니다.

잘 생각해보면, 우리가 정렬을 할 때 비교를 해서 위치를 바꾸는 복잡한 과정을 하는 이유는, 앞의 값과 뒤의 값이 어떤 값이 올지 알 수 없기 때문입니다. (21억 4700만이 올지 0이 올지 그 범위를 알 수 없습니다.) 그런데 1부터 10,000까지로 제한이 되었다면 비교 대신 개수를 세는 방법으로 대체가 가능합니다.

아래 계수 정렬(Counting Sort)에 대해 잘 설명해주신 다른 분 글이 있어 링크를 첨부합니다:

https://jeonyeohun.tistory.com/103

[알고리즘 정리] 계수정렬(Counting Sort)

Comparison Sort 모든 정렬 알고리즘은 기본적으로 배열의 요소들을 검사하는 과정이 포함되어 있다. 결국 배열의 데이터들을 비교하기 위해서는 Decision Tree 를 만들어 경우의 수를 따져볼 수 있는데

jeonyeohun.tistory.com

여기까지 도달했다면 다음은 간단합니다. 1부터 10,000까지의 수가 각각 몇 번 나왔는지 세어서, 각 숫자를 나온 횟수만큼 출력해주면 됩니다. 1이 10번이 나왔다 하여도 그 10개의 1은 모두 같은 1이므로, 입력 받은 후 count[num]++ 형태로 처리하면 되겠습니다.

백준의 문제 특성 상 입력을 스토리지에 저장해둘 필요도 없고, 출력 또한 콘솔에 찍으면 그만이기에 별도의 저장 배열은 필요 없습니다. Count 배열만 메모리에 할당하여 표준 입력을 받을때 증가연산, 입력을 다 받으면 반복문을 통해 출력을 하면 되겠습니다. 정렬이라 하면 일반적으로 입력 받은 후 정렬된 것을 저장하는데, 이번 문제같은 경우 저장 없이 횟수만 저장하기에 제목을 Counting이라고 표현하였습니다.

아래는 그 코드입니다.

개수를 저장하는 배열은 arr로 선언하였습니다. (모두 0으로 초기화하는 번거로운 작업을 생략하기 위해 전역 배열로 선언하였습니다.) 등장 횟수가 0번인 수는 출력하지 않아야 하는데, 이는 for-loop 조건에서 걸러집니다. (2중 loop 중 j 부분)

#include <iostream>

#define endl '\n'

using namespace std;

int arr[10001];

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);

    int size;
    int temp;
    cin >> size;

    for (int i = 0; i < size; i++) {
        cin >> temp;
        arr[temp]++;
    }

    for (int i = 1; i <= 10000; i++) {
        for (int j=0; j<arr[i]; j++)
            cout << i << endl;
    }

    return 0;
}

Whisper STT Model 사용 연습

KDLove5500 — Sun, 3 Aug 2025 17:09:24 +0900

프로젝트에의 활용을 위해 Whisper STT Model을 설치 및 테스트 하는 단계를 기록하였다.

pip install git+https://github.com/openai/whisper.git

Python 환경 터미널에서 pip install 통해 whisper를 설치한다.

pip install whisper로 할 경우 다른 비공식 라이브러리가 깔릴 수 있어 git을 이용한 우회적 방법을 사용했다.

대충 이런 느낌으로 진행, Successfully installed 확인하고 진행한다

https://www.gyan.dev/ffmpeg/builds/

Builds - CODEX FFMPEG @ gyan.dev

FFmpeg is a widely-used cross-platform multimedia framework which can process almost all common and many uncommon media formats. It has over 1000 internal components to capture, decode, encode, modify, combine, stream media, and it can make use of dozens o

www.gyan.dev

음성 처리를 위해 ffmpeg 설치 - C:\에 별도 폴더 만들어 설치한 후 ffmpeg\bin 폴더 환경변수 System변수 Path에 등록

ffmpeg -version

을 입력해서 위와같이 나오면 잘 설치된 것이다.

Whisper STT Model 기본 사용 방법은 아래와 같다

import whisper

model = whisper.load_model("base")
result = model.transcribe("example.mp3")

print("Transcription:", result["text"])

load_model을 통해 모델을 지정하고 (tiny, base, samll, medium, large 중 택1) transcribe를 통해 음성을 불러와 결과값을 저장한다. 모델 선택 기준은 해석 난이도(억양 및 웅얼거림 등)에 따라 결정하며 tiny가 제일 빠르면서 정확도는 가장 낮다.

STT 실습을 위하여 1호선, 3호선, 7호선 전철 안내방송 파일을 가져와 STT 라이브러리 작동 테스트를 하였다. 사용한 코드는 아래와 같으며 별도의 sttSample폴더를 만들어 세 개의 파일을 넣어두었다.

import whisper
# pip install git+https://github.com/openai/whisper.git

model = whisper.load_model("small")

sample = ["sttSample/Cheonan_end.wav", "sttSample/line7_BupyeongguOffice.mp3", "sttSample/3_Gupabal.mp3"]

for s in sample:
    result = model.transcribe(s, language="ko")

    print("\n전체 텍스트:")
    print(result["text"])

    print("\n세부 구간별 출력:")
    for segment in result["segments"]:
        print(f"[{segment['start']:.2f}s - {segment['end']:.2f}s] {segment['text']}")

실제 음성파일 재생 및 출력 결과 확인은 아래 영상에서 할 수 있다.

영상을 보면 알 수 있지만, language가 "ko"로 되어있기 때문에 한국어만 인식한다. 간혹 일본어 또는 중국어가 한국어와 유사한 부분에서 인식이 되기는 하나 영어는 전부 인식되지 않았음을 볼 수 있다. "auto"로 설정할 경우 가장 많이 나온 언어로 인식이 된다고는 한다. 그러나 4개국어 동시 인식같은 것은 불가능하다고 하며 필요시 구간별로 파일을 잘라야 한다고 한다.

어찌 되었든 프로그램 개발 목적에서 다중 언어 동시 인식은 필요 없으므로 "ko" 로 놓고 개발하기로 한다. 전철 안내방송은 전문화된 성우가 녹음한 것이기에 인식 난이도가 매우 쉬운 편에 속한다. 앞으로 해야 할 일은 마이크를 갖다 놓고서 직접 이야기를 해보며 인식을 잘 하는지, 그 다음에는 실시간 인식 기능 구현을 위해 음성 인식 및 끊는 지점 찾는 알고리즘 개발 등이 필요하다.

[C++] 2차원 배열 기반 BFS (기초) (+ 백준 1012번 풀이)

KDLove5500 — Wed, 20 Mar 2024 14:33:05 +0900

알고리즘을 공부할 때 그래프 구조에서 사용하는 대표적 알고리즘으로 DFS와 BFS가 있습니다. Depth First Search, Breadth First Search의 약자로 풀이하면 깊이 우선 탐색, 너비 우선 탐색이라 부를 수 있습니다.

두 알고리즘은 원리 자체는 동일하다 볼 수 있고, 단지 노드 탐색에 있어 Queue에서 넣고 꺼내는 순서의 차이가 있다고 생각하면 될 것 같습니다.

BFS 하면 가장 많이 보이는 그림입니다. Root는 탐색을 시작하는 지점이며 레벨 0으로 간주하겠습니다. BFS의 동작은 해당 레벨의 노드를 모두 탐색하면 다음 레벨의 노드를 탐색합니다. 그림에서 보시다시피 레벨 1의 노드 두 개 (1, 2번)을 모두 탐색한 후에는 레벨 2로 넘어가서 탐색을 계속합니다.

이러한 원리로 "너비 우선 탐색"이라고 불리는 것이고, 동일 깊이의 노드를 모두 탐색한 후 다음 깊이의 노드를 탐색한다는 핵심만 기억하시면 될 것 같습니다.

2차원 배열 기반 BFS 개념

주제가 조금 생소하실 수도 있을 것 같습니다. 이것은 그래프와 탐색에 대한 이해를 묻는 문제에서 2차원 배열 형태를 준 뒤에 탐색하여 결과를 도출하는 알고리즘 문제에서 주로 사용하는 방법입니다. 아래 예시를 보시겠습니다.

2차원 배열 예시 (초기 상태)




			Start

만약 상, 하, 좌, 우 4방향으로만 탐색한다고 (대각선은 고려하지 않고 변이 맞닿은 부분만 탐색) 가정해보겠습니다. 그렇다면 변으로 맞닿은 인접 칸들은 한 번에 넘어갈 수 있으니 거리가 1이 될 것입니다.

2차원 배열 예시 (깊이 1)



	1
1	Start	1
	1

위 표와 같이 깊이 레벨 1번을 탐색하면 4개의 노드가 탐색될 것입니다. 상, 하, 좌, 우 4방향으로 탐색한 결과입니다. 그 다음 배열의 모든 칸을 탐색해보겠습니다.

2차원 배열 예시 (탐색 완료)

6	5	4	3	4	5
5	4	3	2	3	4
4	3	2	1	2	3
3	2	1	Start	1	2
4	3	2	1	2	3

이렇게 모든 칸을 탐색해보면 사각형 모양으로 퍼져나가듯 탐색하는 것을 볼 수 있습니다.

2차원 배열 기반 BFS 구현

그렇다면 배열 기반 BFS의 구현은 어떻게 해야 할까요? 깊이 정보가 필요가 없다면 상, 하, 좌, 우 방향으로 탐색 가능한 노드인지 확인하고 탐색 가능하다면 탐색했다는 표시를 하면 됩니다. 깊이 정보가 필요하다면 Queue 구조를 활용하여 깊이 레벨을 함께 넣어야 하는데 이 부분은 다음 기회에 14940번 :: 쉬운 최단거리 문제와 함께 알아보겠습니다.

이번에는 단순하게 배열 안에서 탐색 가능한 모든 노드를 탐색해보는 방식으로 알아보겠습니다. 아래 예시 그림을 확인해보겠습니다.

만약 (0, 0) 위치에서 탐색을 하는데 (0, 1) 위치가 이미 탐색이 되었다고 가정해보겠습니다. 2차원 배열에서 상, 하, 좌, 우로 움직인다고 가정했으므로, 현재 탐색중인 노드의 인덱스를 (x, y)로 표현한다고 하면 인접 4방향 노드의 인덱스는 (x-1, y), (x+1, y), (x, y-1), (x, y+1)이라고 볼 수 있겠습니다.

이렇게 4방향으로 탐색을 할 때 중요한 조건이 있습니다. 첫 번째는 접근할 수 있는 인덱스인가? 입니다. 배열의 크기를 초과하는 인덱스이거나, 0 미만 음수가 나오면 접근 불가능한 인덱스이므로 액세스 위반 오류가 뜨게 됩니다. 두 번째는 탐색이 되지 않은 노드인가? 입니다. 이미 탐색이 완료된 노드라면 건너뛰어야 합니다. BFS 또는 DFS 알고리즘은 재귀 구조로 이루어져있는데 탐색이 완료되었다고 표시된 것은 해당 노드에서도 이미 BFS 재귀가 이루어진 것이므로 다시 접근하도록 코드를 작성하면 무한 루프에 빠질 위험이 있습니다.

이 두 가지 조건을 따져서 BFS 재귀 함수를 작성해보면 아래와 같은 형태가 될 것입니다.

bool **matrix;
int row, col;

void bfs(int x, int y){
    matrix[x][y] = true;

    // 4-ways bfs
    if(x > 0){
        if(matrix[x-1][y] == false)
            bfs(x-1, y);
    }
    if(x < col - 1){
        if(matrix[x+1][y] == false)
            bfs(x+1, y);
    }
    if(y > 0){
        if(matrix[x][y-1] == false)
            bfs(x, y-1);
    }
    if(y < row - 1) {
        if(matrix[x][y+1] == false)
            bfs(x, y+1);
    }
}

백준 1012번 문제 :: 유기농 배추

문제 링크 : https://www.acmicpc.net/problem/1012

1012번: 유기농 배추

차세대 영농인 한나는 강원도 고랭지에서 유기농 배추를 재배하기로 하였다. 농약을 쓰지 않고 배추를 재배하려면 배추를 해충으로부터 보호하는 것이 중요하기 때문에, 한나는 해충 방지에

www.acmicpc.net

2차원 배열 기반 BFS 알고리즘을 연습하기에 좋은 문제입니다. 입력 예제를 보면 2차원 배열의 가로와 세로 크기, 그리고 탐색해야 할 노드 개수와 노드의 좌표들이 입력이 됩니다. 입력 데이터에서 지정된 노드들 끼리 인접한 그룹이 몇 개인지 (즉 배열에서 표현된 노드들이 몇 개의 그룹을 가지고 있는지) 출력하는 문제입니다.

풀이

입력된 예제를 2차원 배열에 표현하면 아래와 같습니다.

O	O
	O
				O
				O
		O	O		O	O	O
				O	O	O	O
					O	O	O

문제의 조건을 바탕으로 인접한 노드들의 그룹의 개수를 살펴본다면 총 5개의 그룹이 될 것입니다. 그렇다면 이렇게 인접한 노드들의 그룹은 어떤 기준으로 판단해야 할까요? 아래와 같은 분석을 통해 문제를 풀어보겠습니다.

탐색되지 않은 노드를 발견하여 BFS 알고리즘을 시행하면 해당 노드와 인접한 노드들은 모두 탐색이 완료된 것으로 표시될 것이다.
BFS의 재귀가 다 끝나면 해당 그룹은 파악이 완료된 것이다 => 그룹 개수 카운트를 하나 늘린다.
아직 탐색되지 않은 노드를 찾아 다시 BFS 알고리즘을 반복한다.
2차원 배열의 시작점부터 끝점까지 2중 반복문을 돌려 모든 노드를 탐색하면 모든 그룹이 다 카운트 될 것이다.

이러한 분석을 바탕으로 해당 문제 풀이를 위한 코드를 작성해보았습니다. 독자 분들께서 실행 결과를 확인할 수 있도록 별도로 printMatrix() 함수를 작성하여 출력하도록 설정하였습니다.

#include <iostream>
#include <queue>
using namespace std;

#define endl '\n'

// baekjoon 1012

int **cabbage; // is Cabbage
int row, col;

void bfs(int x, int y, int areaNum){
    cabbage[x][y] = areaNum;

    // 4-ways bfs
    if(x > 0){
        if(cabbage[x-1][y] == -1)
            bfs(x-1, y, areaNum);
    }
    if(x < col - 1){
        if(cabbage[x+1][y] == -1)
            bfs(x+1, y, areaNum);
    }
    if(y > 0){
        if(cabbage[x][y-1] == -1)
            bfs(x, y-1, areaNum);
    }
    if(y < row - 1) {
        if(cabbage[x][y+1] == -1)
            bfs(x, y + 1, areaNum);
    }
}

void printMatrix(){
    for(int i=0; i<row; i++){
        for(int j=0; j<col; j++){
            printf("%2d ", cabbage[j][i]);
        }
        cout<<endl;
    }
}

int main() {
    cin.tie(nullptr);
    cout.tie(nullptr);
    //ios_base::sync_with_stdio(false);

    int cases, x, y, numOfCabbage;
    cin>>cases;


    // loop for cases===============================
    for(int c=0; c<cases; c++){
        cin>>col>>row>>numOfCabbage;
        int numOfArea = 0;

        // init Matrix
        cabbage = new int* [col];
        for(int i=0; i<col; i++){
            cabbage[i] = new int[row];
            for(int j=0; j<row; j++)
                cabbage[i][j] = 0;
        }

        // get Cabbage Position
        for(int i=0; i<numOfCabbage; i++){
            cin>>x>>y;
            cabbage[x][y] = -1;
        }

        // find New Area
        for(int i=0; i<col; i++){
            for(int j=0; j<row; j++){
                if(cabbage[i][j] == -1) {
                    bfs(i, j, ++numOfArea);
                }
            }
        }

        // return memory
        cout<<numOfArea<<endl;
        printMatrix();

        for(int i=0; i<col; i++){
            delete[] cabbage[i];
        }
        delete[] cabbage;

    }  //end of cases loop =============================

    return 0;
}

예제 1번의 첫번째 테스트케이스에 대한 실행 결과 (배열 출력을 임의로 출력)

5
 1  1  0  0  0  0  0  0  0  0
 0  1  0  0  0  0  0  0  0  0
 0  0  0  0  3  0  0  0  0  0
 0  0  0  0  3  0  0  0  0  0
 0  0  2  2  0  0  0  5  5  5
 0  0  0  0  4  0  0  5  5  5
 0  0  0  0  0  0  0  5  5  5
 0  0  0  0  0  0  0  0  0  0

그룹 번호를 지정하여 출력함으로써 인접 노드 그룹 개수가 카운트 됨을 표현하였습니다. 비록 Queue를 사용하지 않은 간단한 BFS였지만 BFS의 원리를 공부하기에는 괜찮은 문제라고 생각했습니다.

이렇게 2차원 배열 기반 간단한 BFS를 알아봤습니다. 다음번에는 깊이 레벨과 함께 Queue 구조를 사용하는 조금 더 심화된 BFS에 대하여 알아보겠습니다.

긴 글 읽어주셔서 감사합니다.

수도권 주요 라디오 주파수

KDLove5500 — Wed, 1 Dec 2021 16:11:25 +0900

군에 스마트폰 사용이 허가된지가 벌써 2년이 넘어가고 있지만.. 아직도 일과시간에는 사용을 할 수 없는게 현실입니다. 최근에 전 시간 이용으로 확대를 검토하고 있으나 언제 실현될지는 모르겠네요.

요즈음은 전투차 뿐만 아니라 사제차라 불리는 상용트럭, 버스 등 다양한 차량들을 운용하다보니 라디오는 운전병에게 제일 친한 친구가 되기도 하죠. (물론 동승 간부님께 노래를 틀어달라 할 수도 있겠지만.)

언젠가 한번 만들어야지 만들어야지 하고 미루다가 이제서야 만들어보는, 수도권 주요 라디오 주파수입니다. 제가수도권 인근에 있다보니 수도권 기준이 되었는데.. 강원권이나 충청권, 전라권, 경상권 등등 필요하면 수정하여 쓰셔도 무방합니다.

즐거운 운행의 동반자 라디오와 함께.. 오늘도 안전운행하시고 항상 좋은 일만 가득하길 기원합니다.

(이미지는 클릭하시면 깔끔하게 나옵니다)

수도권 라디오주파수.hwp

0.49MB

수도권 라디오주파수(4개 모아찍기).pdf

0.98MB

대학 메일을 스마트폰 이메일 어플에 연동하기 (pop3 외부메일 부르기)

KDLove5500 — Tue, 25 Feb 2020 14:35:23 +0900

대학 입학 후 학번과 웹메일을 발급받았습니다. 굉장히 설레는 일인데요, 다만 대학메일을 볼 때 웹으로 가서 봐야하기 때문에 조금 불편한 점이 있습니다. 오늘 포스팅에서는 이 점을 해결하기 위해서 스마트폰 기본 어플인 "이메일" 어플에 대학메일을 연동하는 방법을 알아보겠습니다.

Android 9.0 / Samsung Galaxy S10 5G에서 캡쳐한 화면들입니다.

다른 스마트폰도 대부분 비슷한 인터페이스를 가지고 있으니 상황에 맞게 설정하시면 됩니다.

1. 대학메일 설정창에서 Pop3 / IMAP 설정을 합니다.

대학 메일 환경설정 창

메일 환경설정에서 연결 허용이 되어있어야 외부메일 연동이 가능합니다.

허용 여부만 "예"로 설정하시고, 나머지 설정값은 필요한대로 하면 됩니다.

보통 하단 또는 상단의 환경설정에 들어가면 메뉴 중 "Pop3 / IMAP설정" 또는 "외부메일 연결" 등의 키워드로 해당 설정창이 있습니다.

2. 스마트폰 이메일 어플 환경설정에 들어갑니다.

좌측 상단의 줄 세개짜리 메뉴를 누르고, 다시 우측 상단의 톱니바퀴 모양을 눌러 계정 추가 버튼을 누릅니다.

이메일 설정에서 기타를 누르고, 이메일 주소와 학내 메일 로그인시 사용하는 비밀번호를 입력한 후

수동설정 / 로그인 둘 중 아무거나 누르시면 우측 화면과 같이 계정 유형 선택이 뜹니다.

제가 다니는 학교의 메일은 Pop3 방식을 이용중인데, IMAP을 쓰는 학교의 경우 IMAP으로 설정하시면 됩니다.

저는 Pop3 방식을 사용하므로 해당 버튼을 눌렀습니다.

3. 연결 설정을 셋팅합니다.

네이버나 다음 메일을 불러오는 것과는 달리 학교메일은 수동으로 불러와야 하기 때문에 익숙치 않아 당황하실 수 있습니다. 차근차근 하면 쉽습니다.

1. 이메일 주소에는 대학메일 주소를 그대로 씁니다.

2. 사용자 이름과 비밀번호는 대학 메일에 로그인 할 때 쓰는 ID와 비밀번호입니다. 보통 사용자 이름은 메일 주소와 같습니다. (메일주소를 그대로 한번 더 입력하면 됩니다.)

3. 받는메일 서버, 보내는 메일 서버 설정란에서 보안 방식을 둘다 SSL로 바꿔주면 포트가 각각 995, 465로 자동 설정됩니다. 다른 내용은 그대로 놔둬도 괜찮습니다.

4. 보내는 메일 서버 하단에 로그인 정보를 한번 더 입력합니다.

마지막으로 로그인 버튼을 누르면 잠시 로딩창이 뜨다가 연결이 완료됩니다.

우측 그림과 같이 뜨면 연결이 완료된 것입니다.

이후 메일 앱 자체 동기화 간격 설정에 따라 일정 시간 간격으로 메일이 왔는지 확인해주고, 메일이 왔을 경우 핸드폰 푸시알림(상단 바)으로 알려줍니다.

대학 메일 뿐만 아니라 다른 계정도 연결할 일이 있을 경우 위의 방법으로 연결하시면 메일 열람을 더욱편하게 하실 수 있습니다.

추가적으로 궁금하신 사항은 덧글로 말씀해주시면 아는 한도 내에서 최대한 답변드리겠습니다.

읽어주셔서 감사합니다.

TISTORY 블로그 개설 !!

KDLove5500 — Sun, 12 Jan 2020 21:54:03 +0900

7년 전 즈음 (2013년?) 철도 동호회에서 같이 활동하던 동호회 회원분께 초대장을 받아 티스토리에 가입하던 그 때가 기억납니다. 당시에는 티스토리는 물론 블로그 자체가 활동이 굉장히 많았던 때이기 때문에 티스토리 초대장을 받을 수 있다면 정말 영광이었죠. 지금은 잘 지내실련지 모르겠지만, 이 자리를 빌려 다시 한번 감사하다는 말씀을 드리고 싶습니다.

가입하고 수 년간 방치해뒀던 블로그를 다시 꺼낸 이유가 무엇이냐 물으신다면.. 12년도부터 15년도 즈음 까지, 초등학생 말기와 중학교 초기에 운영했던 블로그는 저의 주 관심사였던 교통수단에 관한 이야기들로 가득찼고, 이웃들도 전부 그쪽 계열인지라 제가 이번에 쓰고자 하는 주제와는 아무런 연관도 없다고 생각하여 이렇게 시작하게 되었습니다. 그 블로그를 초기화하기엔 옛 추억들이 아까워 그건 그거대로 남겨두고, 새로운 출발을 하고자 합니다.

기나긴, 12년간의 정규 교육과정을 마치고 충청남도 아산의 모 대학 컴퓨터 소프트웨어 학과에 합격했고, 이 글을 쓰는 시점에서 입학을 한달 반 정도 앞두고 있습니다. 공부를 더 열심히 했다면 더 좋은 곳으로 갈 수도 있었지 않느냐.. 라는 이야기도 많이 들었고 스스로도 그런 생각도 많이 했습니다만, 지나간 일들 돌아봐도 의미 없는 일이고 제 스스로도 나름의 방법으로 최선을 다했기에 후회는 없습니다. 입학 후에는 학과 이름에 맞게 소프트웨어의 여러 분야들에 대한 기초 지식을 쌓을 것 같고, 중학생, 고등학생 때 부터 구상해온 것들이 몇 있어 개인 프로젝트로 구현해보면 어떨까 하는 것들이 있습니다.

이 블로그는 주로 제가 했던 공부들에 대한 기록 (어쩌면 일기?) , 그리고 제가 구상했던 것들을 구현해나가는 프로젝트 진행 현황에 대해서 글을 쓸 것 같습니다. 유익한 이야기들도 있을 것 같고 한편으로는 저의 사담으로 끝나는 이야기들도 있겠지만, 그래도 방문해 주신 모든 분들이 제 글을 읽는 것 만으로도 소중한 인연이라 생각하며, 이런 사람도 있구나 하고 지켜봐 주시면 감사하겠습니다.

저에 대하여 궁금한 점이나 하고싶은 말이 있을 때 덧글이나 방명록 같이 공개된 곳에서 이야기하시기 어렵다면 메일로 문의 주셔도 괜찮습니다. 다만 지나치게 사적인 이야기나 구글링 몇 번으로 해결할 수 있는 일들은 제가 따로 답변을 드리지 못하는 점 양해 부탁드립니다. 지금도 네이버 메일을 주로 쓰고 있긴 합니다만, 모든 멤버십이나 인터넷 계정들을 다 연결해두다 보니 메일 양이 많아 못 보는 메일도 종종 생기고 있습니다. 휴대폰과 연결된 Google 메일 주소를 첨부해드릴테니 꼭 필요한 연락들만 해주시기 바랍니다. 주소는 제 닉네임과 같습니다. kdlove5500@gmail.com

블로그 이름이 읍내리 까치골인데, 이름의 유래는 소소한 퀴즈로 남겨두겠습니다. 생각보다는 쉽습니다 : )

방문해주셔서 감사하고, 인터넷 글을 통해 만나며 스쳐가는 인연이 아니라 서로에게 의미있는 인연이 되었으면 좋겠습니다. 좋은 하루 되세요.