2장. 수: 가상 세계를 구성하는 가장 작은 단위 (59~80p)

컴퓨터가 가상 세계를 구축하는 과정을 거슬러 올라가보면, 궁극적으로는 항상 참인 것으로 받아들여야 하는 수학의 명제로부터 모든것이 시작된다. 모니터 화면을 통해 보는 가상 세계의 본질은 체계화된 수들이 만들어 내는 질서에 불과할 뿐이다.

2.1 수와 집합

게임을 구성하는 가상 세계를 이해하기 위한 첫걸음은 집합이라는 개념으로 수를 이해하는 것이다.

의무교육에서 배운 집합은 서로 구분되는 원소로 구성된 묶음을 의미하며, 이러한 집합론을 소박한 집합론이라고 한다.

소박한 집합론의 관점에서는 용도에 따라 수집합을 정의하여 구분한다. 자연수, 정수, 유리수, 실수, 복소수 , 사원수 등이 있다.

하지만 소박한 집합론은 인간의 언어로 집합을 정의하기 때문에, 인간의 보편적인 관념에 의존 할 수밖에 없다.

우리는 앞으로 수가 가지는 특징을 분석하고 이를 확장해 가상 공간이라는 고차원의 체계를 만들어야 한다.

이러한 작업을 위해서 집합의 성질을 참과 거짓으로 명확하게 구분해 줄 수 있는 명제가 필요하다. 명제 중에서 증명할 필요가 없는 기본 명제를 공리라고 하는데, 공리적 집합론에서는 수가 가지는 연산에 대한 공리를 기반으로 수를 분류한다.

2.1.1 연산과 수의 구조

수집합의 고유한 특징은 원소를 이용해 연산을 한다는 점이다. 이들은 두 개의 원소를 사용해 새로운 원소를 만들어내기 때문에 이항연산이라고도 한다.

[ 이항 연산의 성질 6가지 ]

• 닫혀 있음 : 어떤 집합에서 두 원소를 사용한 이항연산의 결과가 항상 그 집합에 속하는 성질.

• 교환법칙 : 두 원소의 좌우 순서를 바꿔도 결과가 동일한 성질

• 결합법칙 : 세 원소의 연산 순서를 바꿔도 결과가 동일한 성질

• 분배법칙 : 두 이항 연산에 대해 좌분배법칙과 우분배법칙을 모두 만족하는 성질

• 항등원 : 연산의 결괏값이 입력 그대로 나오는 수.

• 역원 : 연산 결과를 항상 항등원으로 만들어주는 수.

2.1.2 수의 구조

[ 11가지 공리 ]

1. 연산에 대해 닫혀 있다.
2. 연산에 대해 결합법칙이 성립한다.
3. 연산에 대한 항등원이 존재한다.
4. 연산에 대한 역원이 존재한다.
5. 연산에 대해 교환법칙이 성립한다.
6. 두 번째 연산에 대해 닫혀 있다.
7. 두 번째 연산에 대해 결합법칙이 성립한다.
8. 첫 번째 연산과 두 번째 연산에 대해 분배법칙이 성립한다.
9. 두 번째 여산에 대해 교환법칙이 성립한다.
10. 두 번째 연산에 대해 항등원이 존재한다.
11. 두 번째 연산에 대해 역원이 존재한다.(단, 0은 제외.) 유리수와 실수는 곱셉의 역원이 존재하기 때문에 덧셈과 곱셈 두 연산에 대해 앞서 열거한 11가지 공리를 모두 만족한다.

공리적 집합론에서 두 연산에 대해 1번부터 11번까지의 공리를 모두 만족하는 수 집합은 체의 구조를 지닌다고 표현한다.

체의 구조를 가지는 수 집합은 특별한 예외 상황 없이 덧셈과 곱셈을 안전하고 자유롭게 사용할 수 있다.

뺄셈과 나눗셈은 교환법칙을 만족하지 않기 때문에 체의 구조를 지니지 못한다. 하지만, 뺄셈 대신 덧셈의 역원을 사용하고 나눗셈 대신 곱셈의 역원을 사용하여 해결할 수 있다.

2.1.3 수의 표현

직선 상에 유리수의 원소를 모두 순서대로 나열할 때, 유리수는 무리수를 표현할 수 없기 때문에 직선의 어느 지점에서는 빈틈이 발생하게 된다. 이러한 빈틈을 무리수로 채워 완벽한 연속성을 가지는 직선을 만들 수 있게 하는 수가 실수이다. 실수를 대응시켜 표현한 직선을 수직선이라고 한다.

실수의 모든 요소는 상호 간에 크기를 비교할 수 있다. 수가 지니는 방향의 속성은 부호를 사용해 나타내며, 크기의 속성은 원점으로부터의 거리를 의미한다.

이항연산에서 왼쪽 항의 수를 물체를 구성하는 점으로 보고, 오른쪽 항의 수를 점을 이동시키는 힘으로 본다.

• 덧셈 연산 : 수의 위치를 이동시키는 작업

• 곱셈 연산 : 점의 위치를 지정된 배율만큼 늘리고 대칭시키는 작업

2.2 함수

함수란 두 집합에서 첫 번째 집합의 모든 원소가 빠짐없이 두 번째 집합의 어떤 원소에 대응하는 관계를 의미한다.

2.2.1 함수의 개념과 종류

다음 두 규칙이 성립되어야 함수로 인정받는다.

1. 첫 번째 집합의 모든 우너소에 대한 대응 관계가 존재해야 함
2. 첫 번째 집합의 원소는 두 번째 집합의 한 원소에만 대응되어야 함

• 정의역(입력) : 함수에서 왼쪽에 위치한 첫 번째 집합

• 공역(출력) : 오른쪽에 위치한 두 번째 집합

• 치역 : 정의역에 대응되는 공역의 원소만 따로 모아 부분집합을 형성한 것

• 전사함수 : 공역의 모든 요소가 정의역에 대응하는 함수

• 단사함수 : 정의역과 공역의 요소가 일대일로 대응되는 함수

• 전단사함수 : 정의역과 공역의 모든 요소가 빠짐없이 일대일로 대응되는 함수

2.2.2 합성함수

• 합성함수 : 2개의 함수를 연쇄적으로 이어서 하나의 함수로 만드는 연산(함수의 합성)을 통해 만들어진 함수

2.2.3 항등함수와 역함수

• 항등함수 : 정의여과 공역이 동일한 값으로 대응되는 함수

• 역함수 : 두 집합의 대응 관계를 뒤집어 공역 Y에서 정의역 X로 대응하는 함수

2.2.4 곱집합을 활용한 좌표 평면으로의 확장

• 곱집합 : 두 집합의 원소를 순서쌍으로 묶은 원소의 집합

곱집합의 요소는 각 집합의 원소 a와 b를 (a, b)와 같은 순서쌍으로 묶어 표현한다.

3.3 정리

소박한 집합론의 개념에서 벗어나 공리적 집합론의 개념에서 수를 정의해보고, 수가 가진 연산 체계를 파악해보고, 실수의 덧셈과 곱셈이 가지는 특징에 대해 익혔다. 덧셈과 곱셈 연산에 대한 11가지의 공리를 모두 만족하면 수 집합은 체의 구조를 가진다라고 표현하는데, 이렇게 공리로부터 설계된 수의 구조는 수의 용도를 확장시켜 가상 세계를 구축하는데 기반이 된다.

1장. 메타버스를 지탱하는 게임 수학 (29~55p)

2020 코로나 팬데믹 사태 발발 이후 변화하고 있는 세계 정세.

사용자의 몰입감을 높여주는 콘텐츠로서의 VR(가상 현실)이라는 개념은 이전에도 있어왔으나, 경제, 문화, 사회적 활동을 영위하는 한발 더 진일보되고 광범위한 개념의 메타버스(Metaverse)라는 개념이 등장했다.

1.1 메타버스가 가져올 새로운 변화

메타버스라는 용어는 초월을 의미하는 메타와 우주를 뜻하는 유니버스를 합성한 단어다. 초기에는 컴퓨처로 만든 가상 세계를 지칭하는 데 사용돼오다 최근에는 그 개념이 확장돼 현실 세계를 가상 공간에 재현하고 그 안에서 활동을 가능하게 하는 기술 전반을 자칭하게 됐다.

메타버스 활동에는 모임, 수업, 전시, 공연 등 현실 속의 여러 활동이 포함되어 있으며 다양한 분야에 큰 변화를 가져왔다.

1.2 게임 엔진의 구성

게임 엔진은 빠르고 효율적으로 게임을 개발할 수 있게 게임 제작에 필요한 여러 기능을 통합해 제공하는 소프트웨어를 의미한다. 게임 엔진은 게임 제작을 위해 개발되었지만, 지금은 가상 콘서트 및 버추얼 프로덕션, 가상 패션하우스 등 메타버스 전 분야에 깊이 연관되어 있다.

인지도와 범용성 측면에서 대표적인 게임 엔진 두 가지로는 에픽 게임즈의 언리얼 엔진과 유니티 테크놀로지스의 유니티 엔진을 들 수 있다.

게임 엔진이 만들어내는 가상 세계는 알고 보면 모든 것이 수로 구성되어 있다. 가상 세계가 만들어내는 화려한 화면도 결국 수로 구성된 데이터 흐름에 불과하다.

GPU의 발전에 힘입어 게임의 표현력이 크게 향상되면서 게임 기술과 함께 게임 산업도 크게 성장했다. 렌더링 작업을 GPU에게 맡겼던 과거와 달리, 렌더링 자체에 관련된 원천 기술을 이해하고 이를 응용한 결과물의 가치가 더욱 커지고 있다. 원천 기술을 잘 이해하려면 가상 세계를 구축하는 규칙인 수학에서부터 제대로 된 지식을 쌓아야 한다.

렌더링을 중심으로 관련 이론과 기법을 다루는 학문을 컴퓨터 그래픽스라고 한다.

1.3 게임 수학의 구성

가상 공간을 구축하고, 변환하고 분석하는 데 사용되는 벡터 수학을 정리하고, 벡터 수학 위에서 움직이는 캐릭터를 모니터 화면에 렌더링하기 위해 필요한 이론과 응용하는 과정에서 사용되는 수학을 통틀어 게임 수학이라고 부른다.

게임 엔진을 징탱하는 데 사용되는 수학은 크게

• 공간을 다루는 수학 (벡터 -> 행렬)

• 물체를 다루는 수학 (점 -> 삼각형)

• 회전을 다루는 수학 (삼각함수 -> 사원수)

3가지 범주로 분류한다.

현실 세계에서 그림을 그릴 때에는 선으로 다양한 형태와 질감을 표현하지만, 컴퓨터 그래픽은 오로지 삼각형을 사용해 물체를 표현한다. 물체를 구성하는 삼각형을 생성하고 관리하기 위해서는 점으로부터 하나씩 체계를 쌓아나가야 한다.

추상적인 수들로 구성된 가상 공간이 모니터 화면을 구성하는 픽셀로 변환되게 하려면 일련의 규칙을 설정하고 이를 프로그래밍해야 한다. 이를 픽셀화라고 한다.

(그 외 도서의 학습 방향 및 커리큘럼 설명.)

1.4 이 책의 실습 환경 구축

상세 내용 도서 참조.

1.5 정리

이 책은 수학 이론을 설명하는 것에 그치지 않고 직접 게임 엔진을 흉내내 구현한 예제 프로제그를 이용해 기본 이론과 응용 능력 모두를 향상시키는 것을 목표로 한다.

과정

아직 레이팅이 오르는 범위다 싶어 최근 내내 안 풀었던 브론즈 문제들을 풀면서 요양하다가, 너무 느슨해진 것 같아 잡았다. 기존의 BFS로 날먹 가능하다고 생각하며 풀었었는데, 어림도 없었다. 기존 BFS에서 '루피'라는 데이터가 하나 더 추가되었기 때문이다. 개념이 하나 추가되었다고, 복잡하게 느껴졌다. 양수의 값이므로 다익스트라라는 개념을 적용할 수 있다는 것을 알게 되어 다익스트라를 새롭게 공부하게 되었다. 다익스트라는 크게 순차탐색과 우선순위 큐로 구현할 수 있다. 어차피 최소값을 찾는 과정이 필요하다고 생각되어 우선순위 큐를 이용하여 풀어보았다. 각 칸에 최소 루피를 저장한다.

결과

//
// Created by 전시은 on 2023/03/16.
//
// 문제 :: 녹색 옷 입은 애가 젤다지?
// 링크 :: https://www.acmicpc.net/problem/4485
// 입력 :: 력은 여러 개의 테스트 케이스로 이루어져 있다.
// 각 테스트 케이스의 첫째 줄에는 동굴의 크기를 나타내는 정수 N이 주어진다. (2 ≤ N ≤ 125) N = 0인 입력이 주어지면 전체 입력이 종료된다.
// 이어서 N개의 줄에 걸쳐 동굴의 각 칸에 있는 도둑루피의 크기가 공백으로 구분되어 차례대로 주어진다. 도둑루피의 크기가 k면 이 칸을 지나면 k루피를 잃는다는 뜻이다. 여기서 주어지는 모든 정수는 0 이상 9 이하인 한 자리 수다.
// 출력 :: 각 테스트 케이스마다 한 줄에 걸쳐 정답을 형식에 맞춰서 출력한다. 형식은 예제 출력을 참고하시오.

#include "../Problems.h"
#include <iostream>
#include <vector>
#include <queue>
using namespace std;

#define MAX 126
#define INF 99999

int dist4485[MAX][MAX];
int map4485[MAX][MAX];

int dx4485[4] = {0, 0, 1, -1};
int dy4485[4] = { 1, -1, 0, 0};

//int main()
int Solve4485()
{
    cout << "[디버깅용] Solve4485 :: 시작지점 >> \n";

    cin.tie(NULL);
    ios_base::sync_with_stdio(false);

    int nSize = -1;
    int nCount = 0;

    while (1)
    {
        cin >> nSize;
        if(nSize == 0) return 0;

        nCount++;

        // input
        for(int i = 0; i < nSize; i++)
        {
            for(int j = 0; j < nSize; j++)
            {
                cin >> map4485[i][j];
            }
        }

        // initalize
        for(int i = 0; i < MAX; i++)
        {
            for(int j = 0; j < MAX; j++)
            {
                dist4485[i][j] = INF;
            }
        }

        // Dijkstra using priority_queue
        priority_queue<pair<int, pair<int, int>>> pqData;
        pqData.push(make_pair(-map4485[0][0], make_pair(0, 0)));
        dist4485[0][0] = map4485[0][0];

        // until data empty
        while(!pqData.empty())
        {
            int rupee = -pqData.top().first;
            int x = pqData.top().second.first;
            int y = pqData.top().second.second;
            pqData.pop();

            // four direction
            for(int i = 0; i < 4; i++)
            {
                int nx = x + dx4485[i];
                int ny = y + dy4485[i];

                // border check
                if(nx >= 0 && ny >= 0 && nx < nSize && ny < nSize)
                {
                    int totalRupee = rupee + map4485[nx][ny];

                    // core
                    if(dist4485[nx][ny] > totalRupee)
                    {
                        dist4485[nx][ny] = totalRupee;
                        pqData.push(make_pair(-dist4485[nx][ny], make_pair(nx, ny)));
                    }
                }
            }
        }

        cout << "Problem " << nCount << ": " << dist4485[nSize - 1][nSize - 1] << "\n";
    }

    return 0;
}

과정

알파벳 개수 세기와 동일한 방식으로 풀었다.

배열 자체를 카운팅 해 주는 방식이다.

결과

//
// Created by 전시은 on 2023/03/14.
//
// 문제 :: 과제 안 내신 분..?
// 링크 :: https://www.acmicpc.net/problem/5597
// 입력 :: 입력은 총 28줄로 각 제출자(학생)의 출석번호 n(1 ≤ n ≤ 30)가 한 줄에 하나씩 주어진다. 출석번호에 중복은 없다.
// 출력 :: 출력은 2줄이다. 1번째 줄엔 제출하지 않은 학생의 출석번호 중 가장 작은 것을 출력하고, 2번째 줄에선 그 다음 출석번호를 출력한다.

#include "../Problems.h"
#include <iostream>
#include <string>
using namespace std;

int nArray5597[31];

//int main()
int Solve5597()
{
    cout << "[디버깅용] Solve5597 :: 시작지점 >> \n";

    cin.tie(NULL);
    ios_base::sync_with_stdio(false);

    for(int i = 0; i < 28; i++)
    {
        int nInput;
        cin >> nInput;

        nArray5597[nInput]++;
    }

    for(int i = 0; i < 28; i++)
    {
        if(nArray5597[i + 1] == 0)
        {
            cout << i+1 << "\n";
        }
    }
    return 0;
}

과정

간단한 브론즈 1 문제인데, 너무 복잡하게 풀었나 싶기도...

숫자를 문자로 취급하고 자릿수에 따라 제곱연산을 해 주면서 스택을 이용해서 단어뒤집기 때와 비슷하게 풀었다.

마지막 자리가 0으로 끝나지 않게 제거 해 준다.

결과!

//
// Created by 전시은 on 2023/03/11.
//

// 문제 :: 뒤집힌 덧셈
// 링크 :: https://www.acmicpc.net/problem/2309
// 입력 :: 첫째 줄에 수 X와 Y가 주어진다. X와 Y는 1,000보다 작거나 같은 자연수이다.
// 출력 :: 째 줄에 문제의 정답을 출력한다.

#include "../Problems.h"
#include <iostream>
#include <string>
#include <stack>
#include <cmath>
#include <algorithm>
using namespace std;


//int main()
int Solve1357()
{
    cout << "[디버깅용] Solve1357 :: 시작지점 >> \n";

    cin.tie(NULL);
    ios_base::sync_with_stdio(false);

    string sInput;
    stack<char> cInput;
    int nSum = 0;

    for(int i = 0; i < 2; i++)
    {
        cin >> sInput;

        for(int j = 0; j < sInput.size(); j++)
        {
            cInput.push(sInput.at(j));
        }
        for(int j = 0; j < sInput.size(); j++)
        {
            nSum += (cInput.top() - '0') * pow(10, sInput.size() - j - 1);
            cInput.pop();
        }
    }

    sInput = to_string(nSum);
    while(sInput.at(sInput.size()-1) == '0')
    {
        sInput.pop_back();
    }

    reverse(sInput.begin(), sInput.end());

    cout << sInput;

    return 0;
}

과정

input을 string형태에 입력받고, split 해 주고, 거꾸로 출력 해 주는 간단한 형태이다. split 하는 부분은 일반적으로 통용되는 형태로 보이는 코드를 가져다가 사용했다.

결과

//
// Created by 전시은 on 2023/03/11.
//
// 문제 :: 단어순서 뒤집기
// 링크 :: https://www.acmicpc.net/problem/2693
// 입력 :: 첫 행은 N이며, 전체 케이스의 개수이다.
//
//N개의 케이스들이 이어지는데, 각 케이스는 스페이스로 띄어진 단어들이다. 스페이스는 라인의 처음과 끝에는 나타나지 않는다. N과 L은 다음 범위를 가진다.
//N = 5
//1 ≤ L ≤ 25
// 출력 :: 각 케이스에 대해서, 케이스 번호가 x일때  "Case #x: " 를 출력한 후 그 후에 이어서 단어들을 반대 순서로 출력한다.

#include "../Problems.h"
#include <iostream>
#include <vector>
#include <string>
#include <sstream>
using namespace std;

vector<string> split12605(string input, char delimiter) {
    vector<string> answer;
    stringstream ss(input);
    string temp;

    while (getline(ss, temp, delimiter)) {
        answer.push_back(temp);
    }

    return answer;
}

//int main()
int Solve12605()
{
    cout << "[디버깅용] Solve12605 :: 시작지점 >> \n";

    cin.tie(NULL);
    ios_base::sync_with_stdio(false);

    int nCase;
    cin >> nCase;
    cin.ignore();

    for(int i = 0; i < nCase; i++)
    {
        vector<string> result;
        string sInput;
        getline(cin, sInput);
        result = split12605(sInput, ' ');

        cout << "Case #" << i + 1 << ": ";
        for(int i = result.size()-1; i >= 0; i--)
        {
            cout << result[i] << " ";
        }
        cout << "\n";
    }


    return 0;
}

과정

2의 3승은 8이다. 2진수는 뒤에서부터 세개씩 3개씩 묶어 자른 후 계산하면 8진수로 계산되는 부분을 이용해서 문제를 풀었다.

따라서 자릿수가 맞지 않는 경우 맞춰주는 작업을 하고 진행 해 주었다.

길이가 무한정한 문제로 string 자료형으로 풀어주었다. c

결과

//
// Created by 전시은 on 2023/03/09.
//
// 문제 :: 2진수 8진수
// 링크 :: https://www.acmicpc.net/problem/1373
// 입력 :: 첫째 줄에 2진수가 주어진다. 주어지는 수의 길이는 1,000,000을 넘지 않는다.
// 출력 :: 첫째 줄에 주어진 수를 8진수로 변환하여 출력한다.

#include "../Problems.h"
#include <iostream>
#include <string>
using namespace std;


//int main()
int Solve1373()
{
    cout << "[디버깅용] Solve1373 :: 시작지점 >> \n";

    cin.tie(NULL);
    ios_base::sync_with_stdio(false);

    string sInput;
    string sResult;
    cin >> sInput;

    if(sInput.size() % 3 != 0)
    {
        string sTemp;
        sTemp += '0';

        if(sInput.size() % 3 == 1)
        {
            sTemp += '0';
        }

        sTemp += sInput;
        sInput = sTemp;
    }

    for(int i = 0; i < sInput.size(); i++)
    {
        if(i % 3 == 2)
        {
            int nSum = 0;
            if(sInput[i-2] == '1')
            {
                nSum += 4;
            }
            if(sInput[i-1] == '1')
            {
                nSum += 2;
            }
            if(sInput[i] == '1')
            {
                nSum += 1;
            }
            sResult += (char) nSum + '0';
        }
    }

    cout << sResult;

    return 0;
}

과정

처음에는 난쟁이 경우의 수를 세워보면서 문제를 풀어보려고 했었는데, 사실 조금 단순하게 생각 해 보면 난쟁이 두 명의 키를 전체 값에서 빼면 되는 문제이다. 그래서 난쟁이 두명의 키를 뺀 값이 100이 되었을 때 값을 출력 해 주게끔 만들었다.

결과

//
// Created by 전시은 on 2023/03/08.
//
// 문제 :: 일곱 난쟁이
// 링크 :: https://www.acmicpc.net/problem/2309
// 입력 :: 아홉 개의 줄에 걸쳐 난쟁이들의 키가 주어진다. 주어지는 키는 100을 넘지 않는 자연수이며, 아홉 난쟁이의 키는 모두 다르며, 가능한 정답이 여러 가지인 경우에는 아무거나 출력한다.
// 출력 :: 일곱 난쟁이의 키를 오름차순으로 출력한다. 일곱 난쟁이를 찾을 수 없는 경우는 없다.

#include "../Problems.h"
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;


//int main()
int Solve2309()
{
    cout << "[디버깅용] Solve2309 :: 시작지점 >> \n";

    cin.tie(NULL);
    ios_base::sync_with_stdio(false);

    vector<int> vInputs;
    int nSum = 0;

    for(int i = 0; i < 9; i++)
    {
        int nInput;
        cin >> nInput;
        nSum += nInput;
        vInputs.push_back(nInput);
    }

    sort(vInputs.begin(), vInputs.end());

    for(int i = 0; i < 8; i++)
    {
        for(int j = 0; j < 9; j++)
        {
            if(nSum - vInputs[i] - vInputs[j] == 100)
            {
                for(int k = 0; k < 9; k++)
                {
                    if(k == i || k == j)
                    {
                        continue;
                    }
                    cout << vInputs[k] << "\n";
                }
                return 0;
            }
        }
    }

    return 0;
}

과정

행렬을 변경하여 출력하되, 데이터가 존재 할 경우에만 출력하게끔 조건을 주었다.!

결과

//
// Created by 전시은 on 2023/03/07.
//
// 문제 :: 세로읽기
// 링크 :: https://www.acmicpc.net/problem/10798
// 입력 :: 총 다섯줄의 입력이 주어진다. 각 줄에는 최소 1개, 최대 15개의 글자들이 빈칸 없이 연속으로 주어진다. 주어지는 글자는 영어 대문자 ‘A’부터 ‘Z’, 영어 소문자 ‘a’부터 ‘z’, 숫자 ‘0’부터 ‘9’ 중 하나이다. 각 줄의 시작과 마지막에 빈칸은 없다.
// 출력 :: 영석이가 세로로 읽은 순서대로 글자들을 출력한다. 이때, 글자들을 공백 없이 연속해서 출력한다.

#include <iostream>
using namespace std;

char cData10798[5][15];

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

    for(int i = 0; i < 5; i ++)
    {
        cin >> cData10798[i];
    }

    for(int i = 0; i < 15; i++)
    {
        for(int j = 0; j < 5; j ++)
        {
            if(cData10798[j][i] != '\u0000')
            {
                cout << cData10798[j][i];
            }
        }
    }

    return 0;
}

과정

약수는 짝을 이룬다. 약수와 그 약수의 짝을 곱하면 원래 수가 나온다.

하지만 짝은 어떻게 알아야할까? 쉽게 약수를 알아내기 위해서 최소값과 최대값을 곱해주었다.

결과

//
// Created by 전시은 on 2023/03/06.
//
// 문제 :: 약수
// 링크 :: https://www.acmicpc.net/problem/1037
// 입력 :: 첫째 줄에 N의 진짜 약수의 개수가 주어진다. 이 개수는 50보다 작거나 같은 자연수이다. 둘째 줄에는 N의 진짜 약수가 주어진다. 1,000,000보다 작거나 같고, 2보다 크거나 같은 자연수이고, 중복되지 않는다.
// 출력 :: 첫째 줄에 N을 출력한다. N은 항상 32비트 부호있는 정수로 표현할 수 있다.

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

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

    int nData[50];
    int n;
    cin >> n;

    for(int i = 0; i < n; i++)
    {
        cin >> nData[i];
    }

    int min = *min_element(nData, nData+n);
    int max = *max_element(nData, nData+n);

    cout << min * max;

    return 0;
}

과정

시간의 여유가 있어 미리 범위인 1~1000 구간을 구해 저장 해 두고,

입력 받은 숫자에서부터 숫자까지의 저장값을 꺼내어 더해주었다.

결과

//
// Created by 전시은 on 2023/03/05.
//
// 문제 :: 쉽게 푸는 문제
// 링크 :: https://www.acmicpc.net/problem/1292
// 입력 :: 첫째 줄에 구간의 시작과 끝을 나타내는 정수 A, B(1 ≤ A ≤ B ≤ 1,000)가 주어진다. 즉, 수열에서 A번째 숫자부터 B번째 숫자까지 합을 구하면 된다.
// 출력 :: 첫 줄에 구간에 속하는 숫자의 합을 출력한다.

#include <iostream>
using namespace std;

int main()
{

    cin.tie(NULL);
    ios_base::sync_with_stdio(false);

    int data[1001];
    int a, b, count = 0, sum = 0;
    cin >> a >> b;

    for(int i = 1; i <= 1000; i++)
    {
        for(int j = 1; j <= i; j++)
        {
            if(count == 1000) break;

            data[count] = i;
            count++;
        }
    }

    for(int i = a; i <= b; i++)
    {
        sum += data[i - 1];
    }

    cout << sum;

    return 0;
}

과정

처음에는 이렇게 베이직하게 푸는 게 맞나..! 싶은 마음도 들었는데, 아무튼 정답이다.

정말 원초적으로 분리해서 구현 해 보았다.

둘의 크기를 비교 해 가면서 기준값을 계속 더해준다. 둘이 같아지면 같이 공유하는 공배수이다.

결과

//
// Created by 전시은 on 2023/03/04.
//
// 문제 :: 최소공배수
// 링크 :: https://www.acmicpc.net/problem/1934
// 입력 :: 첫째 줄에 테스트 케이스의 개수 T(1 ≤ T ≤ 1,000)가 주어진다. 둘째 줄부터 T개의 줄에 걸쳐서 A와 B가 주어진다. (1 ≤ A, B ≤ 45,000)
// 출력 :: 첫째 줄부터 T개의 줄에 A와 B의 최소공배수를 입력받은 순서대로 한 줄에 하나씩 출력한다.

#include <iostream>
using namespace std;

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

    int t, a, b, nA, nB;
    cin >> t;

    for(int i = 0; i < t; i ++)
    {
        cin >> a >> b;
        nA = a;
        nB = b;

        while (nA != nB)
        {
            if(nA > nB)
            {
                nB += b;
            }
            else
            {
                nA += a;
            }
        }
        cout << nA << "\n";
    }

    return 0;
}

과정

처음에는 막연히 닫을 때 마다 개수를 더해주면 되겠다, 싶었는데.. 결과 값이 제대로 나오지를 않았다. 그래서 예시 출력을 다시 보면서 세어 보았다. 레이저만 있는 것은 아무것도 잘리지 않으며, 자른 곳은 2등분된 개수를 세야 한다는 문제가 있었다. 그래서 구분 분기를 주었다.

여는 괄호를 만날 때 마다 push를 해 주고, 닫는 괄호가 나왔을 때 pop을 해 준다. 닫는 괄호가 나왔을 때는 이 괄호가 레이저인지, 막대의 끝인지 구분 해 준다. 레이저면 가지고 있는 스택의 길이만큼 더하고, 막대의 끝이면 끝자락의 개수인 1을 더해준다.

결과

//
// Created by 전시은 on 2023/03/03.
//
// 문제 :: 쇠막대기
// 링크 :: https://www.acmicpc.net/problem/10799
// 입력 :: 한 줄에 쇠막대기와 레이저의 배치를 나타내는 괄호 표현이 공백없이 주어진다. 괄호 문자의 개수는 최대 100,000이다.
// 출력 :: 잘려진 조각의 총 개수를 나타내는 정수를 한 줄에 출력한다.

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


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

    string sInput;
    stack<char> sPipes;
    int nCount = 0;

    cin >> sInput;

    for(int i = 0; i < sInput.length(); i++)
    {
        if(sInput.at(i) == '(')
        {
            sPipes.push('(');
        }
        else if(sInput.at(i) == ')')
        {
            sPipes.pop();

            if(sInput.at(i - 1) == '(')
            {
                nCount += sPipes.size();
            }
            else
            {
                nCount++;
            }
        }
    }

    cout << nCount;

    return 0;
}

https://github.com/github/gitignore/blob/main/Unity.gitignore

만약 레포지토리에 유니티 프로젝트가 바로 있는 것이 아닐 경우, Github에서 제공하는 Unity용 .gitignore가 제대로 작동하지 않는다.

.gitignore에는 각 폴더들을 체크하지 말라고 했지만,

이럴 경우 다음 사진과 같이 각 폴더 앞에 **를 붙여 해결 할 수 있다.

과정

지난번에 풀었던 2178을 개선하였다. https://velog.io/@dev_sieun/%EC%95%8C%EA%B3%A0%EB%A6%AC%EC%A6%98-%EB%AF%B8%EB%A1%9C-%ED%83%90%EC%83%89-%EB%B0%B1%EC%A4%80-2178

기본적인 BFS 형태에 현재 그림의 개수를 세기 위한 Picture를 스캔하는 반복문 구간을 주었고, 넓이를 세고 비교하는 구간을 주었다.

결과

//
// Created by 전시은 on 2023/02/27.
//
// 문제 :: 그림
// 링크 :: https://www.acmicpc.net/problem/1926
// 입력 :: 첫째 줄에 도화지의 세로 크기 n(1 ≤ n ≤ 500)과 가로 크기 m(1 ≤ m ≤ 500)이 차례로 주어진다. 두 번째 줄부터 n+1 줄 까지 그림의 정보가 주어진다. (단 그림의 정보는 0과 1이 공백을 두고 주어지며, 0은 색칠이 안된 부분, 1은 색칠이 된 부분을 의미한다)
// 출력 :: 첫째 줄에는 그림의 개수, 둘째 줄에는 그 중 가장 넓은 그림의 넓이를 출력하여라. 단, 그림이 하나도 없는 경우에는 가장 넓은 그림의 넓이는 0이다.

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

int nPicture1926[501][501];
int nVisit1926[501][501];


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

    int n, m;
    int nPicCount = 0;
    int nPicBiggest = 0;
    int nX[4] = { 0, 0, -1, 1};
    int nY[4] = { -1, 1, 0, 0};
    cin >> n >> m;

    for(int i = 0; i < n; i++)
    {
        for(int j = 0; j < m; j++)
        {
            cin >> nPicture1926[i][j];
        }
    }

    for(int i = 0; i < n; i++)
    {
        for(int j = 0; j < m; j++)
        {
            if(nPicture1926[i][j] == 1 && nVisit1926[i][j] == 0)
            {
                int nCurrentPic = 0;
                queue<pair<int, int>> qBFS;
                qBFS.push(make_pair(i, j));
                nPicCount++;

                // bfs
                while(!qBFS.empty())
                {
                    pair<int, int> current = qBFS.front();
                    nVisit1926[current.first][current.second] = 1;
                    qBFS.pop();
                    nCurrentPic++;

                    for(int dir = 0; dir < 4; dir ++)
                    {
                        int dX = current.first + nX[dir];
                        int dY = current.second + nY[dir];

                        if (dX < 0 || dX >= n || dY < 0 || dY >= m) continue;
                        if (nVisit1926[dX][dY] == 1 || nPicture1926[dX][dY] == 0) continue;

                        nVisit1926[dX][dY] = 1;
                        qBFS.push(make_pair(dX, dY));
                    }
                }

                nPicBiggest = max(nPicBiggest, nCurrentPic);
            }
        }
    }

    cout << nPicCount << "\n" << nPicBiggest;

    return 0;
}

너무 좋은 기회라고 생각되어 지원 해 보게 되었다! 나름대로 야무지게 썼는데, 붙었으면 좋겠다!!!

과정

처음에는 조건을 주어 가며 하려고 했는데, 생각 해 보니 굳이 그러지 않아도 되었다.

어차피 더하려고 하는 것이니, 배열에 미리 값을 담아 넣고 반복하며 더해주었다.

굉장히 간단한 로직이다.

1월 1일이 월요일이므로 0으로 시작하기 편하게 해 주기 위해 일요일부터로 계산 해 주었다.

결과

//
// Created by 전시은 on 2023/02/24.
//
// 문제 :: 2007년
// 링크 :: https://www.acmicpc.net/problem/1924
// 입력 :: 첫째 줄에 빈 칸을 사이에 두고 x(1 ≤ x ≤ 12)와 y(1 ≤ y ≤ 31)이 주어진다. 참고로 2007년에는 1, 3, 5, 7, 8, 10, 12월은 31일까지, 4, 6, 9, 11월은 30일까지, 2월은 28일까지 있다.
// 출력 :: 첫째 줄에 x월 y일이 무슨 요일인지에 따라 SUN, MON, TUE, WED, THU, FRI, SAT중 하나를 출력한다.

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

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

    string day[7] = {"SUN", "MON", "TUE", "WED", "THU", "FRI", "SAT"};
    int month[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
    int x, y, result = 0;
    cin >> x >> y;

    for(int i = 0; i < x-1; i++)
    {
        result += month[i];
    }

    cout << day[(result + y) % 7];

    return 0;
}

과정

처음에는 메모리 생각을 못 하고 2차원 벡터로 구현했다. (최하단 주석)

정말 문제 내용을 그대로, 처음부터 검사해서 그 결과를 비교한 후 맥스값을 출력하는 로직이다.

메모리 초과가 뜨고 나서야 깨달았다. 입력 값을 다시 보니 애초에 이런 식으로 구현하면 안 되는 것이었구나.

입력을 보고 메모리와 시간복잡도를 계산 한 후 문제를 풀어야 하는데, 또 실수했다.

1차원 벡터로 줄이면서 어차피 처음의 값부터 차례대로 체크 해 나가는 것이니 접근 방식도 축소해서 훨씬 간단해졌다.

결과

//
// Created by 전시은 on 2023/02/22.
//
// 문제 :: 연속합
// 링크 :: https://www.acmicpc.net/problem/1912
// 입력 :: 첫째 줄에 정수 n(1 ≤ n ≤ 100,000)이 주어지고 둘째 줄에는 n개의 정수로 이루어진 수열이 주어진다. 수는 -1,000보다 크거나 같고, 1,000보다 작거나 같은 정수이다.
// 출력 :: 첫째 줄에 답을 출력한다.

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;


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

    vector<int> vInputs;
    vector<int> vSums;
    int n;

    cin >> n;

    for(int i = 0; i < n; i++)
    {
        int nInput;

        cin >> nInput;
        vInputs.push_back(nInput);
    }


    vSums.push_back(vInputs.at(0));

    for(int i = 1; i < n; i++)
    {
        vSums.push_back(max(vInputs.at(i), vInputs.at(i) + vSums.at((i - 1))));
    }

    cout << *max_element(vSums.begin(), vSums.end());;

    return 0;
}

/*
//
// Created by 전시은 on 2023/02/22.
//
// 문제 :: 연속합
// 링크 :: https://www.acmicpc.net/problem/1912
// 입력 :: 첫째 줄에 정수 n(1 ≤ n ≤ 100,000)이 주어지고 둘째 줄에는 n개의 정수로 이루어진 수열이 주어진다. 수는 -1,000보다 크거나 같고, 1,000보다 작거나 같은 정수이다.
// 출력 :: 첫째 줄에 답을 출력한다.

#include "../Problems.h"
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;


//int main()
int Solve1912()
{
    cout << "[디버깅용] Solve1912 :: 시작지점 >> \n";

    cin.tie(NULL);
    ios_base::sync_with_stdio(false);

    vector<int> vInputs;
    vector<vector<int>> vSums;
    int n, nResult = -1001;

    cin >> n;

    for(int i = 0; i < n; i++)
    {
        int nInput;

        cin >> nInput;
        vInputs.push_back(nInput);
    }


    for(int i = 0; i < n; i++)
    {
        vector<int> vec;
        vSums.push_back(vec);
        vSums[i].push_back(vInputs.at(i));

        for(int j = i + 1; j < n; j++)
        {
            vSums[i].push_back(vSums[i][j - i - 1] + vInputs[j]);

            cout << "i : " << i << ", j : " << j << "\n";
            cout << "vSums[i][j - 1] : " << vSums[i][j - i - 1] << "\n";
            cout << "vInputs[j] : " << vInputs[j] << "\n";
            cout << "vSums[i].at(j-i) : " << vSums[i].at(j - i) << "\n\n";
        }
    }

    for(int i = 0; i < n; i++)
    {
        nResult = max(nResult, *max_element(vSums[i].begin(), vSums[i].end()));
    }

    cout << nResult;

    return 0;
}
 * */

과정

전형적인 2차원 BFS 길찾기 문제 솔루션에 방문 표기와 거리 계산을 한번에 해 주는 방식으로 풀었다.

타일을 기준으로 상하좌우로 갈 수 있기에 - 1 0 +1을 사용하여 표현 해 주었는데, 지금과 같은 코드 반복 대신 묶어서 사용 해 줄 수 있을 것 같다는 생각이 든다.

결과

//
// Created by 전시은 on 2023/02/19.
//
// 문제 :: 미로 탐색
// 링크 :: https://www.acmicpc.net/problem/2178
// 입력 :: 첫째 줄에 두 정수 N, M(2 ≤ N, M ≤ 100)이 주어진다. 다음 N개의 줄에는 M개의 정수로 미로가 주어진다. 각각의 수들은 붙어서 입력으로 주어진다.
// 출력 :: 첫째 줄에 지나야 하는 최소의 칸 수를 출력한다. 항상 도착위치로 이동할 수 있는 경우만 입력으로 주어진다.

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

char cMaze2178[101][101];
int nVisit2178[101][101];


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

    queue<pair<int, int>> qBFS;
    qBFS.push(make_pair(0, 0));

    int n, m;
    cin >> n >> m;

    for(int i = 0; i < n; i++)
    {
        for(int j = 0; j < m; j++)
        {
            cin >> cMaze2178[i][j];
        }
    }

    // bfs
    while(!qBFS.empty())
    {
        pair<int, int> current = qBFS.front();
        nVisit2178[current.first][current.second];
        qBFS.pop();

        // up
        if(current.second-1 >= 0)
        {
            if(cMaze2178[current.first][current.second - 1] == '1' && nVisit2178[current.first][current.second - 1] == 0)
            {
                nVisit2178[current.first][current.second - 1] = nVisit2178[current.first][current.second] + 1;
                qBFS.push(make_pair(current.first, current.second - 1));
            }
        }
        // down
        if(current.second+1 < m)
        {
            if(cMaze2178[current.first][current.second + 1] == '1' && nVisit2178[current.first][current.second + 1] == 0)
            {
                nVisit2178[current.first][current.second + 1] = nVisit2178[current.first][current.second] + 1;
                qBFS.push(make_pair(current.first, current.second + 1));
            }
        }
        // left
        if(current.first-1 >= 0)
        {
            if(cMaze2178[current.first - 1][current.second] == '1' && nVisit2178[current.first - 1][current.second] == 0)
            {
                nVisit2178[current.first - 1][current.second] = nVisit2178[current.first][current.second] + 1;
                qBFS.push(make_pair(current.first - 1, current.second));
            }
        }
        //right
        if(current.first+1 < n)
        {
            if(cMaze2178[current.first + 1][current.second] == '1' && nVisit2178[current.first + 1][current.second] == 0)
            {
                nVisit2178[current.first + 1][current.second] = nVisit2178[current.first][current.second] + 1;
                qBFS.push(make_pair(current.first + 1, current.second));
            }
        }
    }
    cout << nVisit2178[n - 1][m - 1] + 1;;

    return 0;
}