Update

Author: ndb796

12/1.cpp

@@ -0,0 +1,24 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+string str;
+int summary = 0;
+
+int main(void) {
+    cin >> str;
+
+    // 왼쪽 부분의 자릿수의 합 더하기
+    for (int i = 0; i < str.size() / 2; i++) {
+        summary += str[i] - '0';
+    }
+
+    // 오른쪽 부분의 자릿수의 합 빼기
+    for (int i = str.size() / 2; i < str.size(); i++) {
+        summary -= str[i] - '0';
+    }
+
+    // 왼쪽 부분과 오른쪽 부분의 자릿수 합이 동일한지 검사
+    if (summary == 0) cout << "LUCKY" << '\n';
+    else cout << "READY" << '\n';
+}

12/2.cpp

@@ -0,0 +1,36 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+string str;
+vector<char> result;
+int value = 0;
+
+int main(void) {
+    cin >> str;
+
+    // 문자를 하나씩 확인하며
+    for (int i = 0; i < str.size(); i++) {
+        // 알파벳인 경우 결과 리스트에 삽입
+        if (isalpha(str[i])) {
+            result.push_back(str[i]);
+        }
+        // 숫자는 따로 더하기
+        else {
+            value += str[i] - '0';
+        }
+    }
+
+    // 알파벳을 오름차순으로 정렬
+    sort(result.begin(), result.end());
+
+    // 알파벳을 차례대로 출력
+    for (int i = 0; i < result.size(); i++) {
+        cout << result[i];
+    }
+
+    // 숫자가 하나라도 존재하는 경우 가장 뒤에 출력
+    if (value != 0) cout << value;
+
+    cout << '\n';
+}

12/3.cpp

@@ -0,0 +1,29 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+int solution(string s) {
+    int answer = s.size();
+    // 1개 단위(step)부터 압축 단위를 늘려가며 확인
+    for (int step = 1; step < s.size() / 2 + 1; step++) {
+        string compressed = "";
+        string prev = s.substr(0, step); // 앞에서부터 step만큼의 문자열 추출
+        int cnt = 1;
+        // 단위(step) 크기만큼 증가시키며 이전 문자열과 비교
+        for (int j = step; j < s.size(); j += step) {
+            // 이전 상태와 동일하다면 압축 횟수(count) 증가
+            if (prev == s.substr(j, step)) cnt += 1;
+            // 다른 문자열이 나왔다면(더 이상 압축하지 못하는 경우라면)
+            else {
+                compressed += (cnt >= 2)? to_string(cnt) + prev : prev;
+                prev += s.substr(j, step); // 다시 상태 초기화
+                cnt = 1;
+            }
+        }
+        // 남아있는 문자열에 대해서 처리
+        compressed += (cnt >= 2)? to_string(cnt) + prev : prev;
+        // 만들어지는 압축 문자열이 가장 짧은 것이 정답
+        answer = min(answer, (int)compressed.size());
+    }
+    return answer;
+}

12/4.cpp

@@ -0,0 +1,66 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+// 2차원 리스트 90도 회전하기
+vector<vector<int> > rotateMatrixBy90Degree(vector<vector<int> > a) {
+    int n = a.size(); // 행 길이 계산
+    int m = a[0].size(); // 열 길이 계산
+    vector<vector<int> > result(n, vector<int>(m)); // 결과 리스트
+    for (int i = 0; i < n; i++) {
+        for (int j = 0; j < m; j++) {
+            result[j][n - i - 1] = a[i][j];
+        }
+    }
+    return result;
+}
+
+// 자물쇠의 중간 부분이 모두 1인지 확인
+bool check(vector<vector<int> > newLock) {
+    int lockLength = newLock.size() / 3;
+    for (int i = lockLength; i < lockLength * 2; i++) {
+        for (int j = lockLength; j < lockLength * 2; j++) {
+            if (newLock[i][j] != 1) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+
+bool solution(vector<vector<int> > key, vector<vector<int> > lock) {
+    int n = lock.size();
+    int m = key.size();
+    // 자물쇠의 크기를 기존의 3배로 변환
+    vector<vector<int> > newLock(n * 3, vector<int>(n * 3));
+    // 새로운 자물쇠의 중앙 부분에 기존의 자물쇠 넣기
+    for (int i = 0; i < n; i++) {
+        for (int j = 0; j < n; j++) {
+            newLock[i + n][j + n] = lock[i][j];
+        }
+    }
+
+    // 4가지 방향에 대해서 확인
+    for (int rotation = 0; rotation < 4; rotation++) {
+        key = rotateMatrixBy90Degree(key); // 열쇠 회전
+        for (int x = 0; x < n * 2; x++) {
+            for (int y = 0; y < n * 2; y++) {
+                // 자물쇠에 열쇠를 끼워 넣기
+                for (int i = 0; i < m; i++) {
+                    for (int j = 0; j < m; j++) {
+                        newLock[x + i][y + j] += key[i][j];
+                    }
+                }
+                // 새로운 자물쇠에 열쇠가 정확히 들어 맞는지 검사
+                if (check(newLock)) return true;
+                // 자물쇠에서 열쇠를 다시 빼기
+                for (int i = 0; i < m; i++) {
+                    for (int j = 0; j < m; j++) {
+                        newLock[x + i][y + j] -= key[i][j];
+                    }
+                }
+            }
+        }
+    }
+    return false;
+}

12/5.cpp

@@ -0,0 +1,85 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+int n, k, l;
+int arr[101][101]; // 맵 정보
+vector<pair<int, char> > info; // 방향 회전 정보
+
+// 처음에는 오른쪽을 보고 있으므로(동, 남, 서, 북)
+int dx[] = {0, 1, 0, -1};
+int dy[] = {1, 0, -1, 0};
+
+int turn(int direction, char c) {
+    if (c == 'L') direction = (direction == 0)? 3 : direction - 1;
+    else direction = (direction + 1) % 4;
+    return direction;
+}
+
+int simulate() {
+    int x = 1, y = 1; // 뱀의 머리 위치
+    arr[x][y] = 2; // 뱀이 존재하는 위치는 2로 표시
+    int direction = 0; // 처음에는 동쪽을 보고 있음
+    int time = 0; // 시작한 뒤에 지난 '초' 시간
+    int index = 0; // 다음에 회전할 정보
+    queue<pair<int, int> > q; // 뱀이 차지하고 있는 위치 정보(꼬리가 앞쪽)
+    q.push({x, y});
+
+    while (true) {
+        int nx = x + dx[direction];
+        int ny = y + dy[direction];
+        // 맵 범위 안에 있고, 뱀의 몸통이 없는 위치라면
+        if (1 <= nx && nx <= n && 1 <= ny && ny <= n && arr[nx][ny] != 2) {
+            // 사과가 없다면 이동 후에 꼬리 제거
+            if (arr[nx][ny] == 0) {
+                arr[nx][ny] = 2;
+                q.push({nx, ny});
+                int px = q.front().first;
+                int py = q.front().second;
+                q.pop();
+                arr[px][py] = 0;
+            }
+            // 사과가 있다면 이동 후에 꼬리 그대로 두기
+            if (arr[nx][ny] == 1) {
+                arr[nx][ny] = 2;
+                q.push({nx, ny});
+            }
+        }
+        // 벽이나 뱀의 몸통과 부딪혔다면
+        else {
+            time += 1;
+            break;
+        }
+        // 다음 위치로 머리를 이동
+        x = nx;
+        y = ny;
+        time += 1;
+        if (index < l && time == info[index].first) { // 회전할 시간인 경우 회전
+            direction = turn(direction, info[index].second);
+            index += 1;
+        }
+    }
+    return time;
+}
+
+int main(void) {
+    cin >> n >> k;
+
+    // 맵 정보(사과 있는 곳은 1로 표시)
+    for (int i = 0; i < k; i++) {
+        int a, b;
+        cin >> a >> b;
+        arr[a][b] = 1;
+    }
+
+    // 방향 회전 정보 입력
+    cin >> l;
+    for (int i = 0; i < l; i++) {
+        int x;
+        char c;
+        cin >> x >> c;
+        info.push_back({x, c});
+    }
+
+    cout << simulate() << '\n';
+}

12/6.cpp

@@ -0,0 +1,92 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+// 현재 설치된 구조물이 '가능한' 구조물인지 확인하는 함수
+bool possible(vector<vector<int> > answer) {
+    for (int i = 0; i < answer.size(); i++) {
+        int x = answer[i][0];
+        int y = answer[i][1];
+        int stuff = answer[i][2];
+        if (stuff == 0) { // 설치된 것이 '기둥'인 경우
+            bool check = false;
+            // '바닥 위'라면 정상
+            if (y == 0) check = true;
+            // '보의 한 쪽 끝 부분 위' 혹은 '다른 기둥 위'라면 정상
+            for (int j = 0; j < answer.size(); j++) {
+                if (x - 1 == answer[j][0] && y == answer[j][1] && 1 == answer[j][2]) {
+                    check = true;
+                }
+                if (x == answer[j][0] && y == answer[j][1] && 1 == answer[j][2]) {
+                    check = true;
+                }
+                if (x == answer[j][0] && y - 1 == answer[j][1] && 0 == answer[j][2]) {
+                    check = true;
+                }
+            }
+            if (!check) return false; // 아니라면 거짓(False) 반환
+        }
+        else if (stuff == 1) { // 설치된 것이 '보'인 경우
+            bool check = false;
+            bool left = false;
+            bool right = false;
+            // '한쪽 끝부분이 기둥 위' 혹은 '양쪽 끝부분이 다른 보와 동시에 연결'이라면 정상
+            for (int j = 0; j < answer.size(); j++) {
+                if (x == answer[j][0] && y - 1 == answer[j][1] && 0 == answer[j][2]) {
+                    check = true;
+                }
+                if (x + 1 == answer[j][0] && y - 1 == answer[j][1] && 0 == answer[j][2]) {
+                    check = true;
+                }
+                if (x - 1 == answer[j][0] && y == answer[j][1] && 1 == answer[j][2]) {
+                    left = true;
+                }
+                if (x + 1 == answer[j][0] && y == answer[j][1] && 1 == answer[j][2]) {
+                    right = true;
+                }
+            }
+            if (left && right) check = true;
+            if (!check) return false; // 아니라면 거짓(False) 반환
+        }
+    }
+    return true;
+}
+
+vector<vector<int> > solution(int n, vector<vector<int> > build_frame) {
+    vector<vector<int> > answer;
+    // 작업(frame)의 개수는 최대 1,000개
+    for (int i = 0; i < build_frame.size(); i++) {
+        int x = build_frame[i][0];
+        int y = build_frame[i][1];
+        int stuff = build_frame[i][2];
+        int operate = build_frame[i][3];
+        if (operate == 0) { // 삭제하는 경우
+            // 일단 삭제를 해 본 뒤에
+            int index = 0;
+            for (int j = 0; j < answer.size(); j++) {
+                if (x == answer[j][0] && y == answer[j][1] && stuff == answer[j][2]) {
+                    index = j;
+                }
+            }
+            vector<int> erased = answer[index];
+            answer.erase(answer.begin() + index);
+            if (!possible(answer)) { // 가능한 구조물인지 확인
+                answer.push_back(erased); // 가능한 구조물이 아니라면 다시 설치
+            }
+        }
+        if (operate == 1) { // 설치하는 경우
+            // 일단 설치를 해 본 뒤에
+            vector<int> inserted;
+            inserted.push_back(x);
+            inserted.push_back(y);
+            inserted.push_back(stuff);
+            answer.push_back(inserted);
+            if (!possible(answer)) { // 가능한 구조물인지 확인
+                answer.pop_back(); // 가능한 구조물이 아니라면 다시 제거
+            }
+        }
+    }
+    // 정렬된 결과를 반환
+    sort(answer.begin(), answer.end());
+    return answer;
+}