#pragma once
#include <iostream>
#include <string>
#include <vector>
using namespace std;
///////////////////////////////////////////////
// Globals
// DAT[i] : 트리의 Level i 에 속한 노드의 인덱스들이 저장되어 있는 vector<char>
vector<char> DAT[8];
char name[] = "ABHCDGEF";
char target;
int targetIdx;
int targetLevel;
int NodeCnt = 8;
int tree[8][8] = {
/*A*/0,1,1,1,0,0,0,0,
/*B*/0,0,0,0,0,0,0,0,
/*H*/0,0,0,0,0,0,0,0,
/*C*/0,0,0,0,1,1,1,0,
/*D*/0,0,0,0,0,0,0,1,
/*G*/0,0,0,0,0,0,0,0,
/*E*/0,0,0,0,0,0,0,0,
/*F*/0,0,0,0,0,0,0,0
};
///////////////////////////////////////////////
// Functions
// lev에 해당하는 노드의 자식들을 저장하는 함수
void SaveUnder(int lev)
{
// lev의 모든 노드 확인
vector<char>& nodes = DAT[lev];
for (auto d : nodes)
{
// Find target level
if (d == targetIdx)
targetLevel = lev;
for (int j = 0; j < NodeCnt; ++j)
{
// 트리배열에서 각 노드의 자식을 찾아 다음 레벨에 저장
if (tree[d][j] == 1)
{
DAT[lev + 1].push_back(j);
}
}
}
}
int main()
{
/*1. Input value*/
cin >> target;
targetIdx = strchr(name, target) - name;
/*2. Solve*/
// Put root node
DAT[0].push_back(0);
// Run function 'Solve' until DAT is empty
int i = 0;
while (DAT[i].empty() == false)
{
SaveUnder(i);
++i;
}
/*3. Print*/
if (DAT[targetLevel].size() == 1)
{
cout << "없음";
}
else
{
for (auto d : DAT[targetLevel])
{
// Don't print 'target'
if (name[d] == target) continue;
cout << name[d] << " ";
}
}
return 0;
}
개선 코드
///////////////////////////////////////////////
// Globals
char target;
int targetIdx;
int targetLevel;
const int totalNodes = 8;
int tree[totalNodes][totalNodes] = {
/*A*/0,1,1,1,0,0,0,0,
/*B*/0,0,0,0,0,0,0,0,
/*H*/0,0,0,0,0,0,0,0,
/*C*/0,0,0,0,1,1,1,0,
/*D*/0,0,0,0,0,0,0,1,
/*G*/0,0,0,0,0,0,0,0,
/*E*/0,0,0,0,0,0,0,0,
/*F*/0,0,0,0,0,0,0,0
};
char name[] = "ABHCDGEF";
// DAT[i] = i번째 노드의 레벨
char DAT[totalNodes] = { 0 };
///////////////////////////////////////////////
// Functions
void DFS(int idx, int lev)
{
// Base case:
if (totalNodes <= idx)
return;
// Recursive step:
for (int i = 0; i < totalNodes; ++i)
{
if (tree[idx][i] == 0) continue;
// Put level of
// DAT[i] = child node of the current node
DAT[i] = lev + 1;
DFS(i, lev + 1);
}
}
///////////////////////////////////////////////
// Main
int main()
{
/*1. Update value*/
cin >> target;
targetIdx = strchr(name, target) - name;
/*2. Solve*/
// Fill in DAT
DFS(0, 0);
// Insert into the string the nodes at the same level as the target level.
string ret = "";
int targetLev = DAT[targetIdx];
for (int i = 0; i < totalNodes; ++i)
{
if (DAT[i] == targetLev && name[i] != target)
ret += name[i];
}
/*3. Print*/
cout << (ret.length() == 0 ? "없음" : ret);
return 0;
}
///////////////////////////////////////////////
// Globals
char tree[] = " ADFZCGQH";
///////////////////////////////////////////////
// Main
int main()
{
// 1. Input value
char a, b;
cin >> a >> b;
// 2. Find index 'a, b'
int idxA, idxB;
for (int i = 0; i < sizeof(tree); ++i)
{
if (tree[i] == a)
idxA = i;
if (tree[i] == b)
idxB = i;
}
// 3. Compare each index
bool ret = false;
if (idxA / 2 == idxB || idxB / 2 == idxA)
ret = true;
// 4. Print
cout << (ret ? "부모자식관계" : "아님");
return 0;
}
///////////////////////////////////////////////
// Globals
string name = "0234561";
int tree[7][7] = {
/*0*/0,1,1,1,0,0,0,
/*2*/0,0,0,0,1,1,0,
/*3*/0,0,0,0,0,0,1,
/*4*/0,0,0,0,0,0,0,
/*5*/0,0,0,0,0,0,0,
/*6*/0,0,0,0,0,0,0,
/*7*/0,0,0,0,0,0,0,
};
const int totalNodes = 7;
///////////////////////////////////////////////
// Functions
// Print sub node corresponding to idx in tree
void TraverseLevelOrder(int idx)
{
// Base case: Stop if is out of bounds
if (totalNodes <= idx)
return;
// work step: Print current Node
cout << name[idx] << " ";
// Recursive step : Traverse all sub nodes of the current node
for (int i = 0; i < totalNodes; ++i)
{
if (tree[idx][i] != 1) continue;
TraverseLevelOrder(i);
}
return;
}
///////////////////////////////////////////////
// Main
int main()
{
TraverseLevelOrder(0);
return 0;
}
///////////////////////////////////////////////
// Globals
const int totalNodes = 8;
int tree[totalNodes] = { 0,3,4,2,4,1,0,3 };
///////////////////////////////////////////////
// Functions
void DFS(int idx)
{
// Base case:
if (totalNodes <= idx || tree[idx] == 0)
return;
// Work step:
cout << tree[idx] << " ";
// Recursive step:
DFS(idx * 2);
DFS(idx * 2 + 1);
return;
}
///////////////////////////////////////////////
// Main
int main()
{
// Update value
int idx, val;
cin >> idx >> val;
tree[idx] = val;
// Do tree traversal
DFS(1);
return 0;
}
///////////////////////////////////////////////
// Globals
const int totalNodes = 9;
int tree[totalNodes][totalNodes] = {
0,1,1,0,0,0,0,0,0,
0,0,0,1,1,1,0,0,0,
0,0,0,0,0,0,1,1,1,
0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,
};
string path = { 0 };
///////////////////////////////////////////////
// Functions
void DFS(int idx)
{
// Base case:
if (path.length() == 3)
{
cout << path << endl;
return;
}
// Recursive step:
for (int i = 0; i < totalNodes; ++i)
{
if (tree[idx][i] != 1) continue;
path.push_back('0' + i);
DFS(i);
path.pop_back();
}
return;
}
///////////////////////////////////////////////
// Main
int main()
{
// Do tree traversal
path[0] = '0';
DFS(0);
return 0;
}
///////////////////////////////////////////////
// Globals
const int totalNodes = 8;
int tree[totalNodes] = { 0,3,7,10,5,6,3,6 };
int path[totalNodes] = { 0 };
int pushIdx = 0;
///////////////////////////////////////////////
// Functions
void DFS(int idx)
{
// Base case:
if (totalNodes <= idx)
return;
// Work step:
path[pushIdx++] = tree[idx];
if (tree[idx] % 2 == 0)
{
// Print path
for (int i = 0; i < pushIdx; ++i)
{
cout << path[i] << " ";
}
cout << endl;
}
// Recursive step:
DFS(idx * 2);
DFS(idx * 2 + 1);
path[--pushIdx] = 0;
return;
}
///////////////////////////////////////////////
// Main
int main()
{
DFS(1);
return 0;
}
class list
{
public:
struct Node
{
int value = 0;
Node* next = nullptr;
};
void Push(int data)
{
Node* buff = new Node;
if (mSize == 0)
mHead = buff;
if (0 < mSize)
mTop->next = buff;
buff->value = data;
buff->next = nullptr;
mTop = buff;
mSize++;
}
void Print()
{
Node* t = mHead;
do
{
cout << t->value <<" ";
t = t->next;
} while (t != nullptr);
}
private:
Node* mHead = nullptr;
Node* mTop = nullptr;
size_t mSize = 0;
};
int main()
{
int input;
cin >> input;
list l;
for (int i = 1; i <= 4; ++i)
{
l.Push(input * i);
}
l.Print();
return 0;
}
#define DIST ('A' - 11)
class list
{
public:
struct Node
{
char value;
Node* next;
};
void push(char d)
{
Node* buff = new Node;
buff->value = d;
buff->next = nullptr;
if (size == 0)
head = buff;
else
top->next = buff;
top = buff;
++size;
}
void print()
{
Node* t = head;
do
{
cout << t->value;
t = t->next;
} while (t != nullptr);
}
private:
Node* head = nullptr;
Node* top = nullptr;
size_t size = 0;
};
int main()
{
int input;
cin >> input;
list l;
for (int i = 0; i < 4; ++i)
{
l.push(input + i + DIST);
}
l.print();
return 0;
}
char path[5] = { 0 };
char check[4] = { 0 };
int input = 0;
void Solve(int lev = 0)
{
if (lev == input)
{
cout << path << endl;
return;
}
for (int i = 0; i < 4; ++i)
{
if (check[i] == 1)
continue;
check[i] = 1;
path[lev] = 'A' + i;
Solve(lev + 1);
path[lev] = 0;
check[i] = 0;
}
return;
}
int main()
{
cin >> input;
Solve();
return 0;
}
class list
{
public:
struct Node
{
char a;
int b;
Node* next;
};
void push(char c, int i)
{
Node* buff = new Node;
buff->a = c;
buff->b = i;
buff->next = nullptr;
if (size == 0)
{
head = buff;
}
else
{
tail->next = buff;
}
tail = buff;
size++;
}
void printChar()
{
Node* t = head;
for (int i = 0; i < size; ++i)
{
cout << t->a << " ";
t = t->next;
}
cout << endl;
}
void printNum()
{
Node* t = head;
while (t != nullptr)
{
cout << t->b << " ";
t = t->next;
}
cout << endl;
}
private:
Node* head = nullptr;
Node* tail = nullptr;
size_t size = 0;
};
int main()
{
int input;
cin >> input;
list l;
for (int i = 0; i < input; ++i)
{
l.push('A' + i, i + 1);
}
l.printChar();
l.printNum();
return 0;
}
class Queue
{
public:
struct Node
{
char data;
Node* next;
};
void push(int d)
{
Node* buff = new Node;
buff->data = d;
buff->next = nullptr;
if (size == 0)
{
head = buff;
}
else
{
tail->next = buff;
}
tail = buff;
size++;
}
void pop()
{
if (size == 0) return;
Node* buff = head->next;
delete[] head;
head = buff;
size--;
}
void Print()
{
Node* buff = head;
do
{
cout << buff->data << " ";
buff = buff->next;
} while (buff != nullptr);
}
private:
Node* head = nullptr;
Node* tail = nullptr;
int size = 0;
};
int main()
{
Queue q;
int input1, input2;
cin >> input1 >> input2;
for (int i = 0; i < input1; ++i)
{
char c;
cin >> c;
q.push(c);
}
for (int i = 0; i < input2; ++i)
{
q.pop();
}
q.Print();
return 0;
}
int main()
{
char buf[100] = { 0 };
cin >> buf;
bool find = false;
int ret = 0;
for (auto d : buf)
{
// 문자면
if (d < '0' || '9' < d)
{
// 이전에 숫자를 찾은 경우면 종료
if (find == true)
break;
// 문자만 찾아왔다면 다음 반복문 실행
continue;
}
ret = ret * 10 + (d - '0');
}
cout << ret + 5;
return 0;
}
class queue
{
public:
struct Node
{
int x = 0;
char y = 0;
};
void push(int i, char c)
{
if (max < size + 1) return;
if (0 < size)
{
tail++;
if (tail == max)
tail = 0;
}
data[tail].x = i;
data[tail].y = c;
size++;
}
void pop()
{
if (size == 0) return;
// 기존 값 초기화
data[head] = Node();
// head가 최대 인덱스를 넘었을 때
head++;
if (max <= head)
{
head = 0;
}
size--;
return;
}
Node front()
{
return data[head];
}
bool empty()
{
if (size == 0) return true;
return false;
}
private:
static const int max = 5;
Node data[max];
int head = 0;
int tail = 0;
int size = 0;
};
int main()
{
queue q;
int input = 0;
cin >> input;
for (int i = 0; i < input; i++)
{
int a;
char b;
cin >> a >> b;
q.push(a, b);
}
while (q.empty() == false)
{
cout << q.front().x << " " << q.front().y << endl;
q.pop();
}
return 0;
}
class queue
{
public:
struct Node
{
int data;
Node* next;
};
void Enqueue(int input)
{
Node* buff = new Node;
buff->data = input;
buff->next = nullptr;
if (size == 0)
head = buff;
else
tail->next = buff;
tail = buff;
++size;
}
void Dequeue()
{
if (size == 0)
return;
Node* temp = head->next;
cout << head->data;
memset(head, 0, sizeof(Node));
delete[] head;
head = temp;
--size;
}
private:
Node* head = nullptr;
Node* tail = nullptr;
int size = 0;
};
int main()
{
int input;
cin >> input;
queue q;
for (int x = 0; x < input; ++x)
{
q.Enqueue(1);
q.Enqueue(2);
q.Enqueue(3);
q.Dequeue();
q.Dequeue();
q.Dequeue();
}
return 0;
}
int board[4][4] = {
3,5,1,4,
2,2,1,1,
0,1,2,3,
3,1,3,1
};
int main()
{
char input;
cin >> input;
for (int i = 0; i < 4; ++i)
{
int t;
if ('0' <= input && input <= '3')
{
t = board[input - '0'][i];
}
if ('A' <= input && input <= 'D')
{
t = board[i][input - 'A'];
}
cout << t;
}
return 0;
}
int main()
{
string input;
cin >> input;
int cnt = 0;
for (auto d : input)
{
if (d == '<')
++cnt;
if (d == '>')
{
if (--cnt < 0)
{
cout << "비정상";
return 0;
}
}
}
if (cnt == 0)
cout << "정상";
else
cout << "비정상";
return 0;
}
int main()
{
string text,cmd;
int pos;
cin >> text >> pos >> cmd;
int max = text.size();
for (auto d : cmd)
{
if (d == 'R')
if (max < ++pos)
pos = max;
if (d == 'L')
if (--pos < 0)
pos = 0;
}
cout << pos;
return 0;
}
class CircularQueue
{
public:
struct Node
{
char data;
Node* next;
};
void push(char d)
{
Node* buff = new Node;
buff->data = d;
if (size == 0)
head = buff;
if (0 < size)
tail->next = buff;
tail = buff;
tail->next = head;
++size;
}
void pop()
{
if (size = 0) return;
tail->next = head->next;
memset(head, 0, sizeof(Node));
delete[] head;
head = tail->next;
}
char front()
{
return head->data;
}
void Rotation()
{
head = head->next;
tail = tail->next;
}
private:
Node* head = nullptr;
Node* tail = nullptr;
int size = 0;
};
int main()
{
CircularQueue q;
q.push('B');
q.push('I');
q.push('A');
q.push('H');
for (int i = 0; i < 4; ++i)
{
for (int j = 0; j < 4; ++j)
{
q.Rotation();
}
cout << q.front();
q.pop();
}
return 0;
}
int A[3][3] = {
2,6,3,
7,1,1,
3,4,2
};
int B[2][4] = {
6,4,2,4,
1,1,5,8
};
int C[2][3] = {
9,2,3,
4,2,1
};
void Substitution(std::deque<int>& d, int* pi, size_t size)
{
for (int i = 0; i < size; ++i)
{
d.push_back(*(pi + i));
}
}
void MergeSort(int* data, int as, int ae, int be)
{
// 1. Base case
if (as == be)
return;
int bs = ae + 1;
// 2. Merge
MergeSort(data, as, (as + ae) / 2, ae);
MergeSort(data, bs, (bs + be) / 2, be);
// 3. Sort
int tempAs = as;
int buff[10] = { 0 };
int inputIdx = 0;
while (as <= ae && bs <= be)
{
if (data[as] <= data[bs])
{
buff[inputIdx++] = data[as++];
}
if (data[as] >= data[bs])
{
buff[inputIdx++] = data[bs++];
}
}
while (as <= ae)
{
buff[inputIdx++] = data[as++];
}
while (bs <= be)
{
buff[inputIdx++] = data[bs++];
}
// 4. Copy
// inputIdx => buff Size
memcpy(data + tempAs, buff, inputIdx * sizeof(int));
}
int main()
{
constexpr int lastIdxA = sizeof(A) / sizeof(int) - 1;
MergeSort(*A, 0, lastIdxA / 2, lastIdxA);
constexpr int lastIdxB = sizeof(B) / sizeof(int) - 1;
MergeSort(*B, 0, lastIdxB / 2, lastIdxB);
constexpr int lastIdxC = sizeof(C) / sizeof(int) - 1;
MergeSort(*C, 0, lastIdxC / 2, lastIdxC);
std::deque<int> dA;
Substitution(dA, *A, lastIdxA + 1);
std::deque<int> dB;
Substitution(dB, *B, lastIdxB + 1);
std::deque<int> dC;
Substitution(dC, *C, lastIdxC + 1);
int ret[3][3] = { 0 };
int inputIdx = 0;
for (int i = 0; i < 3; ++i)
{
for (int j = 0; j < 3; ++j)
{
if (j == 0)
{
ret[j][i] = dA.back();
dA.pop_back();
}
if (j == 1)
{
ret[j][i] = dB.front();
dB.pop_front();
}
if (j == 2)
{
ret[j][i] = dC.front();
dC.pop_front();
}
}
}
ret[2][2] = dC.back();
for (int i = 0; i < 3; ++i)
{
for (int j = 0; j < 3; ++j)
{
cout << ret[i][j] << " ";
}
cout << endl;
}
return 0;
}
int main()
{
char input[106];
cin >> input;
int size = strlen(input);
int i = -1;
while (++i < size - i - 1)
{
std::swap(input[i], input[size - i - 1]);
}
cout << input;
return 0;
}
using namespace std;
int main()
{
int input = -9463847412;
//cin >> input;
int ret = 0;
while(input != 0)
{
// input의 뒷자리 추출 후 뒷자리 떼버리기
int t = input % 10;
input /= 10;
// 더하기 전에 범위 체크,
// Overflow의 값을 저장할 수 없으니까, 맨 뒷자리와 그 나머지를 나누어서 비교
// 양수
if (INT_MAX / 10 < ret || INT_MAX / 10 == ret && INT_MAX % 10 < t)
{
cout << 0;
return 0;
}
// 음수
if (INT_MIN / 10 > ret || INT_MIN / 10 == ret && INT_MIN % 10 > t)
{
cout << 0;
return 0;
}
// 문제 없다면 더하기
ret = ret * 10 + t;
}
cout << ret;
return 0;
}
char input[10'000'000];
char DAT[257] = { 0 };
int main()
{
cin >> input;
int i = 0;
while (input[i] != 0)
{
++DAT[input[i++]];
}
i = 0;
while (input[i] != 0)
{
if (DAT[input[i++]] == 1)
{
cout << i - 1;
return 0;
}
}
cout << -1;
return 0;
}
char s[1000000] = { 0 };
char t[1000000] = { 0 };
char DATs[300] = { 0 };
char DATt[300] = { 0 };
int main()
{
cin >> s >> t;
if (strlen(s) != strlen(t))
{
cout << "false";
return;
}
int i = 0;
while (s[i] != 0 ||)
{
++DATs[s[i++]];
++DATt[t[i++]];
}
for (int i = 'a'; i <= 'z'; ++i)
{
if (DATs[i] != DATt[i])
{
cout << "false";
return;
}
}
cout << "true";
return 0;
}
char s[1000000] = "A man, a plan, a cansal: Panama";
int main()
{
//cin >> s;
char t[1000000] = { 0 };
int inputIdx = 0;
int spaceCnt = 0;
for (int i = 0; i < strlen(s); ++i)
{
int c = s[i];
if (c == ' ')
++spaceCnt;
if ((c < 'A' || 'z' < c) == (c < '0' || '9' < c))
{
continue;
}
if ('A' <= c && c <= 'Z')
c += 'a' - 'A';
t[inputIdx++] = c;
}
if (spaceCnt == strlen(s))
{
cout << "true";
return 0;
}
int i = 0;
do
{
if (t[i] != t[strlen(t) - i - 1])
{
cout << "false";
return 0;
}
} while (++i < strlen(t) - i - 1);
cout << "true";
return 0;
}
char s[500] ={0};
int main()
{
cin >> s;
int idx = 0;
// 1. 공백 무시
while (s[idx] == ' ')
{
++idx;
};
// 2. 부호 확인
int sign = 1;
if (s[idx] == '-')
{
sign = -1;
++idx;
}
// 3. 초반 0 무시
while (s[idx] == '0')
{
++idx;
};
// 4. 숫자 저장 & 문자 확인
int ret = 0;
bool first = true;
while (s[idx] != 0)
{
// 숫자 이외의 값이면 저장 종료
if (s[idx] < '0' || '9' < s[idx])
break;
// 숫자 저장 전 범위 체크
int t = (s[idx++] - '0') * sign;
// 양수
if (INT_MAX / 10 < ret || INT_MAX / 10 == ret && INT_MAX % 10 < t)
{
cout << INT_MAX;
return 0;
}
// 음수
if (INT_MIN / 10 > ret || INT_MIN / 10 == ret && INT_MIN % 10 > t)
{
cout << INT_MIN;
return 0;
}
// 숫자 저장
ret = ret * 10 + t;
}
cout << ret * sign;
return 0;
}
char str[100000] = { 0 };
char token[100000] = { 0 };
int main()
{
cin >> str >> token;
int strSize = strlen(str);
int tokenSize = strlen(token);
bool ret = false;
int i = 0;
for (; i < strSize - tokenSize + 1; ++i)
{
if (strncmp(str + i, token, tokenSize) == 0)
{
ret = true;
break;
}
}
cout << (ret ? i : -1);
return 0;
}
int main()
{
string strs[] = { "dog", "racecar", "car" };
int size = sizeof(strs) / sizeof(string);
sort(strs, &(strs[size]));
int i;
for (i = 0; strs[0][i] == strs[size - 1][i]; ++i);
cout << strs[0].substr(0, i);
return 0;
}
struct BBQ
{
int a;
int b;
};
int main()
{
BBQ* bbq = new BBQ;
cin >> bbq->a >> bbq->b;
cout << bbq->a + bbq->b;
return 0;
}
int main()
{
char *a, *b, *c;
a = new char;
b = new char;
c = new char;
cin >> *a >> *b >> *c;
//isupper islower
if ('A' <= *a && *a <= 'Z')
if ('A' <= *b && *b <= 'Z')
if ('A' <= *c && *c <= 'Z')
{
cout << "모두 대문자";
return 0;
}
cout << "소문자 있음";
return 0;
}
struct Node
{
int a;
Node* p1;
Node* p2;
};
int main()
{
Node* head = new Node;
head->a = 3;
head->p1 = new Node;
head->p2 = new Node;
head->p1->a = 7;
head->p2->a = 6;
head->p2->p1 = new Node;
head->p2->p1->a = 2;
return 0;
}
struct Node
{
char a;
Node* p1;
Node* p2;
};
int main()
{
Node* head = new Node;
head->a = 'A';
head->p1 = new Node;
head->p2 = new Node;
head->p1->a = 'B';
head->p1->p1 = new Node;
head->p1->p2 = new Node;
head->p1->p1->a = 'D';
head->p1->p2->a = 'E';
head->p2->a = 'C';
char cmd[100] = { 0 };
cin >> cmd;
Node* t = head;
int i = 0;
do
{
if (cmd[i] == 'L')
t = t->p1;
if (cmd[i] == 'R')
t = t->p2;
} while (cmd[++i] != 0);
cout << t->a;
return 0;
}
struct Node
{
int a;
Node* p = nullptr;
};
int main()
{
Node* head = new Node;
head->p = new Node;
head->p->a = 3;
head->p->p = new Node;
head->p->p->a = 5;
head->p->p->p = new Node;
head->p->p->p->a = 4;
head->p->p->p->p = new Node;
head->p->p->p->p->a = 2;
do
{
head = head->p;
cout << head->a << " ";
} while (head->p != nullptr);
return 0;
}
struct Node
{
char a;
Node* p = nullptr;
};
int main()
{
char str[] = "QTPKQ";
Node* head = new Node;
Node* t = head;
for (int i = 0; i < 5; ++i)
{
t->p = new Node;
t = t->p;
t->a = str[i];
}
cout << t->a;
return 0;
}
struct Node
{
string name = { 0 };
Node* Love1 = nullptr;
Node* Love2 = nullptr;
};
int main()
{
Node* head = new Node;
Node* boss = new Node;
Node* wife = new Node;
Node* son = new Node;
Node* gf = new Node;
Node* bf = new Node;
boss->name = "boss";
boss->Love1 = wife;
boss->Love2 = son;
wife->name = "wife";
wife->Love1 = boss;
wife->Love2 = son;
son->name = "son";
son->Love1 = gf;
son->Love2 = bf;
gf->name = "girlfriend";
gf->Love1 = son;
gf->Love2 = bf;
bf->name = "boyfriend";
bf->Love1 = gf;
bf->Love2 = nullptr;
head = boss;
cout << head->Love2->Love1->name << " " << head->Love2->Love2->name;
return 0;
}
int input = 0;
int main()
{
cin >> input;
int extract[2] = { 0 };
int i = 1;
while(0 <input)
{
if (i == 2 || i == 4)
{
extract[i / 2 - 1] = input % 10;
}
input /= 10;
++i;
}
cout << extract[1] * 10 + extract[0] + 5;
return 0;
}
char board[4][4] = { 0 };
int main()
{
for (int i = 0; i < 16; ++i)
{
cin >> *((*board) + i);
}
for (int i = 0; i < 4; ++i)
{
int ret = 0;
for (int j = 0; j < 4; ++j)
{
if (board[j][i] != '#')
++ret;
}
cout << ret << " ";
}
return 0;
}
int main()
{
string input;
cin >> input;
int cntB = 0;
for (auto d : input)
{
if (d == 'B')
++cntB;
else
--cntB;
if (cntB < 0)
{
cout << "짝이 안맞음";
return 0;
}
}
if (cntB != 0)
cout << "짝이 안맞음";
else
cout << "짝이 맞음";
return 0;
}
int board[3][3] = {
0,5,4,
3,0,0,
0,0,1
};
void Rotation()
{
for (int i = 0; i < 3; ++i)
{
for (int j = i; j < 3; ++j)
{
std::swap(board[i][j], board[j][i]);
}
std::reverse(board[i], board[i] + 3);
}
}
int main()
{
int input;
cin >> input;
for (int i = 0; i < input; ++i)
{
Rotation();
}
for (int i = 0; i < 3; ++i)
{
for (int j = 0; j < 3; ++j)
{
cout << board[i][j] << " ";
}
cout << endl;
}
return 0;
}
char input[16] = {0};
int main()
{
cin >> input;
char* p = input;
while(*p != 0)
{
char t[6] = { 0 };
memcpy_s(t, sizeof(t), p, 5);
cout << t << endl;
p += 5;
}
return 0;
}
int number[6] = { 3,7,4,0,9,6 };
char input[] = "mxmmxx";
// 닫힌 구간 [ as <= idx <= be ]
void sort(int as, int ae, int be)
{
int bs = ae + 1;
// Base case
if (as == be) return;
// 분할
sort(as, (as + ae) / 2, ae);
sort(bs, (bs + be) / 2, be);
// 정렬
int tas = as; // 마지막 복사를 위한 임시 저장 값
int arrSize = be - as + 1;
int t[10] = { 0 };
int i = 0;
while (as <= ae && bs <= be)
{
if (number[as] < number[bs])
t[i++] = number[as++];
else
t[i++] = number[bs++];
}
// a파트를 모두 탐색했을 때
while (bs <= be)
t[i++] = number[bs++];
// b파트를 모두 탐색했을 때
while (as <= ae)
t[i++] = number[as++];
// 데이터 이동
int a = memcpy_s(&(number[tas]), arrSize * sizeof(int), t, arrSize * sizeof(int));
}
int main()
{
sort(0, 5 / 2, 5);
int m = 0, x = 5;
for (auto d : input)
{
if (d == 'm')
std::cout << number[m++] << " ";
if (d == 'x')
std::cout << number[x--] << " ";
}
return 0;
}
char path[4] = { 0 };
void Func(int level, const int n)
{
// Base case
if (level == n)
{
cout << path << endl;
return;
}
for (int i = 1; i < 7; ++i)
{
path[level] = i + '0';
Func(level + 1, n);
path[level] = 0;
}
return;
}
int main()
{
int n;
cin >> n;
Func(0, n);
return 0;
}
class Shape
{
public:
Shape()
{
type_ = 1;
len_ = 1;
rectCnt_++;
}
Shape(int type, double len)
: type_(type), len_(len)
{
if (type_ == 1) rectCnt_++;
if (type_ == 2) circleCnt_++;
}
~Shape()
{
if (type_ == 1) rectCnt_--;
if (type_ == 2) circleCnt_--;
}
static const int GetRectCount()
{
return rectCnt_;
}
static const int GetCircleCount()
{
return circleCnt_;
}
const double GetArea() const
{
// 정사각형
if (type_ == 1)
{
return len_ * len_;
}
// 원
if (type_ == 2)
{
return len_ * len_ * PI;
}
}
private:
const double PI = 3.14;
static int rectCnt_;
static int circleCnt_;
int type_; // 1 : 정사각형, 2 : 원
double len_; // 정사각형의 경우 한 변의 길이, 원의 경우 반지름
};
int Shape::rectCnt_ = 0;
int Shape::circleCnt_ = 0;
class Array
{
public:
Array() = default;
Array(int count)
:count_(count)
{
ary_ = new int[count_];
PutData();
}
~Array()
{
delete[] ary_;
}
void PrintArray()
{
for (int i = 0; i < count_; ++i)
{
cout << ary_[i] << " ";
}
cout << endl;
}
private:
void PutData()
{
for (int i = 0; i < count_; ++i)
{
ary_[i] = rand() % 10;
}
}
private:
int count_;
int* ary_;
};
int main()
{
srand(time(NULL));
Array arr1(3);
Array arr2(5);
arr1.PrintArray();
arr2.PrintArray();
return 0;
}
