์ด์ ํฌ์คํ
1. [์๋ฃ๊ตฌ์กฐ] ์๋ฃ๊ตฌ์กฐ๋ ๋ฌด์์ธ๊ฐ? - ์ ๋ฆฌ ๋ฐ ์ฐ์ต๋ฌธ์
https://atoz-develop.tistory.com/entry/entry/์๋ฃ๊ตฌ์กฐ-์๋ฃ๊ตฌ์กฐ๋-๋ฌด์์ธ๊ฐ-์ ๋ฆฌ-๋ฐ-์ฐ์ต๋ฌธ์
1. ๋ฐฐ์ด์ ์ ์
๋ฐฐ์ด(Array) :
- ์ธ๋ฑ์ค์ ์์๊ฐ์ ์(<index, value>)์ผ๋ก ๊ตฌ์ฑ๋ ์งํฉ
- ๋ฐฐ์ด์ ๊ฐ ์์๋ค์ ์๋ฃํ๊ณผ ๊ธฐ์ต ๊ณต๊ฐ์ ํฌ๊ธฐ๊ฐ ๊ฐ๋ค.
- ๋ฉ๋ชจ๋ฆฌ์ ๋ฌผ๋ฆฌ์ ์ธ ์์น๋ฅผ ์์์ ์ผ๋ก ๊ฒฐ์ ํ๋ ํน์ง์ด ์๋ค.
- ๋ฐฐ์ด์ ๋ ผ๋ฆฌ์ ์ธ ์์(์ธ๋ฑ์ค)๋ ๋ฉ๋ชจ๋ฆฌ์ ์ ์ฅ๋๋ ์์๊ฐ์ ๋ฌผ๋ฆฌ์ ์ธ ์์(๋ฉ๋ชจ๋ฆฌ ์ฃผ์)์ ๋์ผํ๋ค.
- ๋ฐฐ์ด์ ์ฒซ ๋ฒ์งธ ์์์ ๋ฉ๋ชจ๋ฆฌ ์ฃผ์์ ์ธ๋ฑ์ค๋ฅผ ํตํด ํน์ ์์์ ์ฃผ์๊ฐ์ ๊ณ์ฐํ ์ ์๋ค.
- ์ง์ ์ ๊ทผ(direct access) : ์ธ๋ฑ์ค๋ฅผ ์ด์ฉํด ์ ๊ทผํ๋ฏ๋ก
- ์๋ฃ๊ตฌ์กฐ์ ์ ํ ์ค ์ ํ ๊ตฌ์กฐ์ ํด๋นํ๋ค.
- ๊ฐ ์์์ ์ด๋ฆ์ ๊ณ ์ ํ ์ด๋ฆ์ด ์๊ณ ์์์ ์์น์ ๋ฐ๋ผ ์ ํด์ง๋ค.
๊ทธ๋ฆผ์ ์ข์ธก์ 16์ง์๋ก ํํ๋๋ ๋ฉ๋ชจ๋ฆฌ์ ์ค์ ์ฃผ์, ๊ฐ์ด๋ฐ๋ ๋ฉ๋ชจ๋ฆฌ์ ํ ๋น๋ ๋ฐ์ดํฐ, ์ฐ์ธก์ ๋ฐฐ์ด์ ์ธ๋ฑ์ค์ด๋ค. ์ด์ฒ๋ผ ๋ฐฐ์ด์ ๋ฌผ๋ฆฌ์ ์ธ ์ ์ฅ ์์๋ ์ธ๋ฑ์ค์ ์์์ ๋์ผํ๋ค. ์ธ๋ฑ์ค๋ ๊ฐ๋ฐ์๊ฐ ์ง๊ด์ ์ผ๋ก ๋ฐ์๋ค์ด๊ธฐ ์ํ ์ถ์ํ๋ ๊ฐ์ด๋ค. ์ด๋ ๊ฒ ์ถ์ํ๋ ์ธ๋ฑ์ค๋ฅผ ์ปดํจํฐ๊ฐ ํด์ํ์ฌ ๋ฌผ๋ฆฌ์ ์ธ ์ค์ ์ฃผ์๋ก ๋ณํํ๋ค.
2. ๋ฐฐ์ด์ ์ถ์ ์๋ฃํ(ADT)
์ด์ ํฌ์คํ [์๋ฃ๊ตฌ์กฐ] ์๋ฃ๋ ๋ฌด์์ธ๊ฐ?(๋งํฌ)์์ ๋ค๋ฃฌ ๊ฒ๊ณผ ๊ฐ์ด ์ถ์ ์๋ฃํ์ด๋ ์๋ฃ ์งํฉ๊ณผ ์ฐ์ฐ ์งํฉ์ ๋ช ์ธ์ด๋ค.
* Object(๊ฐ์ฒด)
<i∈Index, e∈Element> ์๋ค์ ์งํฉ. Index๋ ์์๋ฅผ ๋ํ๋ด๋ ์ ์์ ์ ํ์งํฉ์ด๊ณ Element๋ ํ์ ์ด ๊ฐ์ ์์์ ์งํฉ
* Functions(์ฐ์ฐ)
a∈Array; i∈index; x, item∈Element, n∈Integer์ธ ๋ชจ๋ a, item, n์ ๋ํด ๋ค์๊ณผ ๊ฐ์ ์ฐ์ฐ์ด ์ ์๋๋ค. a๋ 0๊ฐ ์ด์์ ์์๋ฅผ ๊ฐ๋ ๋ฐฐ์ด, item์ ๋ฐฐ์ด์ ์ ์ฅ๋๋ ์์, n์ ๋ฐฐ์ด์ ์ต๋ ํฌ๊ธฐ๋ฅผ ์ ์ํ๋ ์ ์๊ฐ์ด๋ค.
โ Array create(n) ::= ๋ฐฐ์ด์ ํฌ๊ธฐ๊ฐ n์ธ ๋ฐฐ์ด์ ์์ฑํ๊ณ ๋ฐํํ๋ค;
โก Element retrieve(a, i) ::=
if(i∈Index) then {๋ฐฐ์ด a์ i์ธ๋ฑ์ค์ ํด๋นํ๋ ์์๊ฐ 'e'๋ฅผ ๋ฐํํ๋ค;}
else {์๋ฌ ๋ฉ์์ง๋ฅผ ๋ฐํํ๋ค;}
โข Array store(a, i, e) ::=
if(i∈Index) then {๋ฐฐ์ด a์ i์ธ๋ฑ์ค์ ์์๊ฐ 'e'๋ฅผ ์ ์ฅํ๊ณ ๋ฐฐ์ด a๋ฅผ ๋ฐํํ๋ค;}
else {i๊ฐ ๋ฐฐ์ด a์ ํฌ๊ธฐ๋ฅผ ๋ฒ์ด๋๋ฉด ์๋ฌ๋ฉ์์ง๋ฅผ ๋ฐํํ๋ค;}
3. ๋ฐฐ์ด ์ฐ์ฐ์ ๊ตฌํ
๋ค์์ ์์์ ์ ์ํ ๋ฐฐ์ด์ ์ถ์ ์๋ฃํ์ ์ฐ์ฐ์ C์ธ์ด๋ก ๊ตฌํํ ๊ฒ์ด๋ค. Element๋ ์ ์๋ก ๊ฐ์ ํ๋ค.
3-1. ๋ฐฐ์ด์ ์์ฑ(create)
1
2
3
4
5
6
7
|
void create(int n) {
int a[n];
int i;
for(i=0, i<n, i++){
a[i] = 0;
}
}
|
cs |
3-2. ๋ฐฐ์ด์ ๊ฒ์(retrieve)
1
2
3
4
5
6
7
8
9
10
|
#define array_size 5
int retrieve(int *a, int i) {
if(i>=0 && i<array_size)
return a[i];
else {
printf("Error\n");
return(-1);
}
|
cs |
1๋ผ์ธ: ์ธ๋ฑ์ค์ ๋ฒ์๋ฅผ #define์ผ๋ก ์ ์ํ๋ค. ์ธ๋ฑ์ค i๊ฐ ์ ํจ ์งํฉ์ ํฌํจ๋์ด ์๋์ง ํ์ธํ๊ธฐ ์ํจ์ด๋ค.
2๋ผ์ธ: ๋ฐฐ์ด์ ๊ฐ๋ฆฌํค๋ ๋ณ์ a์ ์ธ๋ฑ์ค i๋ฅผ ๋งค๊ฐ๋ณ์๋ก ์ ๋ฌ๋ฐ๋๋ค.
3๋ผ์ธ: i๊ฐ Index ์ ํจ ์งํฉ ๋ฒ์์ ํด๋นํ๋์ง ๋น๊ตํ๋ค.
4๋ผ์ธ: ๋ฐฐ์ด์ i๋ฒ์งธ ์์๊ฐ์ ๋ฐํํ๋ค.
6~7๋ผ์ธ: i๊ฐ Index ์ ํจ ์งํฉ ๋ฒ์์ ํด๋นํ์ง ์๋ ๊ฒฝ์ฐ๋ก "Error" ๋ฉ์์ง๋ฅผ ์ถ๋ ฅํ๊ณ -1์ ๋ฐํํ๊ณ ์ข
๋ฃํ๋ค.
๋ฐฐ์ด์ ์์๊ฐ ์ ๊ทธ๋ฆผ๊ณผ ๊ฐ์ด ์ ์ฅ๋์ด ์๋ค๊ณ ๊ฐ์ ํ๋ฉด retrieve(a, 2)๋ a[2]์ธ 30์ ๋ฐํํ๋ค.
3-3. ๋ฐฐ์ด์ ์ ์ฅ
1
2
3
4
5
6
|
#define array_size 5
void store(int *a, int i, int e) {
if(i>=0 && i<array_size)
a[i] = e;
else printf("Error\n");
}
|
cs |
2๋ผ์ธ: ๋ฐฐ์ด์ ๊ฐ๋ฆฌํค๋ ๋ณ์ a, ์ธ๋ฑ์ค i, ์์๊ฐ e๋ฅผ ๋งค๊ฐ๋ณ์๋ก ์ ๋ฌ๋ฐ๋๋ค.
๋๋จธ์ง๋ ๋ฐฐ์ด์ ๊ฒ์ ์ฐ์ฐ๊ณผ ๋ง์ฐฌ๊ฐ์ง๋ก ์ธ๋ฑ์ค i์ ๊ฐ์ด Index ์ ํจ ์งํฉ ๋ฒ์์ ํด๋นํ๋์ง ํ์ธํ๊ณ ์๋๋ฉด "Error" ๋ฉ์์ง๋ฅผ ์ถ๋ ฅํ๋ค.
store(a, 3, 35)์ ๊ฒฐ๊ณผ๋ ์ ๊ทธ๋ฆผ๊ณผ ๊ฐ๋ค.
4. 1์ฐจ์ ๋ฐฐ์ด
- ์ธ๋ฑ์ค๊ฐ ํ ๊ฐ์ธ ํ ์ค์ง๋ฆฌ ๋ฐฐ์ด
- ์: A[i]
- ๋ฉ๋ชจ๋ฆฌ ์์ญ์ ํ ์ค๋ก ํ ๋น๋ฐ๋๋ค.
๋ฐฐ์ด A์ ์ฒซ ๋ฒ์งธ ์์ A[0]์ ๋ฉ๋ชจ๋ฆฌ ์ฃผ์๋ฅผ a๋ผ๊ณ ํ๊ณ ๊ฐ ์๋ฃํ์ ํฌ๊ธฐ k๋ฅผ ์๋ฉด A[i]์ ์ฃผ์๋ฅผ ๊ณ์ฐํ ์ ์๋ค.
1์ฐจ์ ๋ฐฐ์ด A[i]์ ์ฃผ์ ๊ณ์ฐ
์ฃผ์(A[i]) = ์ฃผ์(A[0]) + i * ์๋ฃํ์ ํฌ๊ธฐ
6. 2์ฐจ์ ๋ฐฐ์ด
- ์ธ๋ฑ์ค๊ฐ 2๊ฐ์ธ ๋ฐฐ์ด
- ์: A[i][j]
- ํ๋์ ์์๋ ๋ ๊ฐ์ ์ธ๋ฑ์ค(i, j)์ ์์ผ๋ก ๊ตฌ๋ถ๋๋ค.
- i๋ ํ(row), j๋ ์ด(column)์ ํํํ๋ค.
- ํ ์ฐ์ ๋ฉ๋ชจ๋ฆฌ ์ฐ์ํ ๋น, ์ด ์ฐ์ ๋ฉ๋ชจ๋ฆฌ ์ฐ์ํ ๋น ๋ฐฉ๋ฒ์ด ์๋ค.
6-1. ํ๋ ฌ์ ๋ฐฐ์ด ํํ
ํ๋ ฌ์ ํ๋ก๊ทธ๋จ์ผ๋ก ๊ตฌํํ ๋ 2์ฐจ์ ๋ฐฐ์ด์ ๋ง์ด ์ฌ์ฉํ๋ค.
ํ๋ ฌ์ ํ๊ณผ ์ด๋ก ์ด๋ฃจ์ด์ง๋ฏ๋ก ์ปดํจํฐ์์ ํํํ ๋ ๋์ผํ ํํ์ธ 2์ฐจ์ ๋ฐฐ์ด์ด ์ ํฉํ๊ธฐ ๋๋ฌธ์ด๋ค.
6-2. 2์ฐจ์ ํ๋ ฌ์ ๋ฉ๋ชจ๋ฆฌ ํ ๋น ๋ฐฉ์
6-2-1. ํ ์ฐ์ ์ ์ฅ ๋ฐฉ์
ํ ์ฐ์ ํ ๋น ๋ฐฉ์์ ๊ฐ๋ก์ 1์ฐจ์ ๋ฐฐ์ด ๋จ์๋ก ๋ฉ๋ชจ๋ฆฌ ์์ญ์ ํ ๋น๋ฐ๋๋ค. ์ฆ ํ๋์ ํ์ด ์ฐ์์ ์ผ๋ก ๋ฉ๋ชจ๋ฆฌ ์์ญ์ ํ ๋น๋ฐ๊ณ ๋ค์ ํ์ด ๋ฉ๋ชจ๋ฆฌ ์์ญ์ ์ฐ์์ ์ผ๋ก ํ ๋น๋ฐ๋๋ค.
[์ฐธ๊ณ ] ํ ์ฐ์ ์ ์ฅ ๋ฐฉ์์ 2์ฐจ์ ๋ฐฐ์ด(MxN) ์ฃผ์ ๊ณ์ฐ
์ฃผ์(A[i][j]) = ์ฃผ์(A[0][0]) + i * N * ์๋ฃํ์ ํฌ๊ธฐ + j * ์๋ฃํ์ ํฌ๊ธฐ
6-2-2. ์ด ์ฐ์ ์ ์ฅ ๋ฐฉ์
์ด ์ฐ์ ํ ๋น ๋ฐฉ์์ ์ธ๋ก์ 1์ฐจ์ ๋ฐฐ์ด ๋จ์๋ก ๋ฉ๋ชจ๋ฆฌ ์์ญ์ ํ ๋น๋ฐ๋๋ค. ์ฆ ํ๋์ ์ด์ด ์ฐ์์ ์ผ๋ก ๋ฉ๋ชจ๋ฆฌ ์์ญ์ ํ ๋น๋ฐ๊ณ ๋ค์ ์ด์ด ๋ฉ๋ชจ๋ฆฌ ์์ญ์ ์ฐ์์ ์ผ๋ก ํ ๋น๋ฐ๋๋ค.
[์ฐธ๊ณ ] ์ด ์ฐ์ ์ ์ฅ ๋ฐฉ์์ 2์ฐจ์ ๋ฐฐ์ด ์ฃผ์ ๊ณ์ฐ
์ฃผ์(A[i][j]) = ์ฃผ์(A[0][0]) + i * ์๋ฃํ์ ํฌ๊ธฐ + j * M * ์๋ฃํ์ ํฌ๊ธฐ
๊ฒฐ๊ตญ '๋ฉ๋ชจ๋ฆฌ์์ ๋ฌผ๋ฆฌ์ ์ธ ์ ์ฅ ์์์ ์ถ์์ ์ธ ์์์ ์์๊ฐ ์ผ์นํ๋ค'๋ ๋ฐฐ์ด์ ์ฑ์ง์ 2์ฐจ์ ๋ฐฐ์ด์์๋ ๋์ผํ๋ค. ์ฆ 2์ฐจ์ ๋ฐฐ์ด๋ 1์ฐจ์ ๋ฐฐ์ด๊ณผ ๋ง์ฐฌ๊ฐ์ง๋ก ๋ฉ๋ชจ๋ฆฌ์ ์์ฐจ์ ์ผ๋ก ์ ์ฅ๋๋ค. ๋ฐ๋ผ์ ๋ฐฐ์ด์ ํฌ๊ธฐ(MxN), ์ฒซ ๋ฒ์งธ ์์์ ์ฃผ์, ์ธ๋ฑ์ค, ์๋ฃํ์ ํฌ๊ธฐ๋ฅผ ํตํด ํน์ ์์์ ์ฃผ์๋ฅผ ๊ณ์ฐํ์ฌ ๋ฐฐ์ด์ ํน์ฑ ์ค ํ๋์ธ '์ง์ ์ ๊ทผ(direct access)'์ ํ์ฉํ ์ ์๋ค.
7. ํฌ์ํ๋ ฌ(Sparse Matrix)
- ์์๊ฐ์ด 0์ธ ์์๊ฐ ๊ทธ๋ ์ง ์์ ์์๋ณด๋ค ์๋์ ์ผ๋ก ๋ง์ ํ๋ ฌ
- ํฌ์ํ๋ ฌ์ 2์ฐจ์ ๋ฐฐ์ด๋ก ํํ ์ ๋ฉ๋ชจ๋ฆฌ ๋ญ๋น ๋ฐ์
- ๋ฐ๋ผ์ ๋ฉ๋ชจ๋ฆฌ์ ๋ญ๋น๋ฅผ ๋ง๊ณ ์ฒ๋ฆฌ์ ํจ์จ์ฑ์ ๋์ด๊ธฐ ์ํด 0์ด ์๋ ๊ฐ๋ง์ ๋ฐ๋ก ๋ชจ์ ์ ์ฅํ๋ ๋ฐฉ๋ฒ ํ์
- 0์ด ์๋ ๊ฐ ์์๋ฅผ (ํ๋ฒํธ, ์ด๋ฒํธ, ์์๊ฐ)์ ํํ๋ก ๋ํ๋ด๋ฉด ์ฐ์ธก๊ณผ ๊ฐ์ 2์ฐจ์ ๋ฐฐ์ด๋ก ํํ ๊ฐ๋ฅ
- ์ฐ์ธก ๋ฐฐ์ด์ [0,0]์ ์๋ณธ ๋ฐฐ์ด์ ํ ์, [0,1]์ ์๋ณธ ๋ฐฐ์ด์ ์ด ์, [0,2]๋ 0์ด ์๋ ์์๊ฐ์ ์๋ฅผ ๋ํ๋ธ๋ค.
- 1ํ๋ถํฐ๋ ์ฐจ๋ก๋ก ์๋ณธ ๋ฐฐ์ด์ ํ๋ฒํธ, ์ด๋ฒํธ, ๊ฐ์ ๋ํ๋ธ๋ค.
- ์๋ก 7ํ์ 5, 3, 91์ด ์ ์ฅ๋์ด ์๋๋ฐ, ์ข์ธก ์๋ณธ ๋ฐฐ์ด์์ [5,3]์ 91์ด ์ ์ฅ๋์ด ์์์ ์ ์ ์๋ค.
8. ์ฐ์ต๋ฌธ์
1. ์๋ฃ๊ตฌ์กฐ์ ์ ํ ์ค ์ ํ ๊ตฌ์กฐ์ ํด๋นํ๋ ๊ฒ์ ๋ฌด์์ธ๊ฐ?
โ ๋ฐฐ์ด
โก ๊ทธ๋ํ
โข ํธ๋ฆฌ
โฃ ํข
2. ์ง๋ฌธ์ (๊ฐ), (๋)์ ์ ํฉํ ๊ฒ์?
(๊ฐ)์ ๊ฐ ์์์ ์ด๋ฆ์ ๊ณ ์ ํ ์ด๋ฆ์ด ์๊ณ ์์์ ์์น์ ๋ฐ๋ผ ์ ํด์ง๋ฏ๋ก ์์๋ฅผ ๋ฐ๊ฟ ์ ์์ผ๋, (๋)๋(์) ๊ฐ ์์๋ง๋ค ๊ณ ์ ํ ์ด๋ฆ์ผ๋ก ๊ตฌ๋ณํ ์ ์๋ค.
โ ๋ฆฌ์คํธ, ๋ฐฐ์ด
โก ๋ฆฌ์คํธ, ๋ ์ฝ๋
โข ๋ฐฐ์ด, ๋ฆฌ์คํธ
โฃ ๋ฐฐ์ด, ๋ ์ฝ๋
3. ์์๋ฅผ ๊ฐ์ง ์์๋ค์ ์์ด๋ก์ ๋ฌผ๋ฆฌ์ ์์๊ฐ ๋ ผ๋ฆฌ์ ์์์ ์ผ์นํ๋ ์๋ฃ๊ตฌ์กฐ๋ ๋ฌด์์ธ๊ฐ?
โ ์์ ๋ฆฌ์คํธ
โก ๋ฐฐ์ด
โข ํ
โฃ ์คํ
4. ๋ฐฐ์ด์ ๋ํ ์ค๋ช ์ผ๋ก ํ๋ฆฐ ๊ฒ์ ๋ฌด์์ธ๊ฐ?
โ ์ธ๋ฑ์ค์ ์์๊ฐ(<index, value>)์ ์์ผ๋ก ๊ตฌ์ฑ๋ ์งํฉ์ด๋ค.
โก ์์๋ค์ด ๋ชจ๋ ๊ฐ์ ์๋ฃํ์ด๋ค.
โข ๊ตฌ์ฑ ์์๋ค์ ๋ ผ๋ฆฌ์ ๊ด๊ณ์ ์์์ ์ ์ฅ ์์น๋ ๋ฌด๊ดํ๋ค.
โฃ ๋ฉ๋ชจ๋ฆฌ์ ์ฃผ์๊ฐ๊ณผ ์ถ์ํ๋ ์ธ๋ฑ์ค๊ฐ์ด ๊ด๋ จ๋์ด ์๋ค.
5. ์๋๋ ๋ฐฐ์ด๊ฐ์ ์ ์ฅ์ ๋ํ๋ธ ๊ฒ์ด๋ค. [๊ฐ]์ ๋ค์ด๊ฐ ๊ฐ์ฅ ์๋ง์ ์ฝ๋๋ ๋ฌด์์ธ๊ฐ?
#define array_size 5
void store(int *a, int i, int e) {
if( [๊ฐ] ) a[i] = e;
else printf("Error\n");
}
โ i >= 0 && i < array_size
โก i >= 0 || i < array_size
โข i <= 0 && i < array_size
โฃ i <= 0 || i < array_size
6. ๋ค์ ์ค๋ช ์ค ํ๋ฆฐ ๊ฒ์ ๋ฌด์์ธ๊ฐ?
โ ๋ฐฐ์ด์ ์ธ๋ฑ์ค์ ์์๊ฐ์ ์์ผ๋ก ๊ตฌ์ฑ๋๋ค.
โก ๋ฐฐ์ด์ ์์๋ ์์๊ฐ์ด ์ ์ฅ๋๋ ๋ฌผ๋ฆฌ์ ์ธ ์์น์ ์์ฃผ ๋ฐ์ ํ ์๊ด์ด ์๋ค.
โข ๋ฐฐ์ด์ ์ธ๋ฑ์ค๊ฐ์ ์ด์ฉํด์ ์์๊ฐ์ ์ง์ ์ ๊ทผํ๋ค.
โฃ ๋ฐฐ์ด์ ๊ฐ ์์๊ฐ์ ์๋ฏธ์ ์ธ ์์๋ ์ธ๋ฑ์ค์ ์์์ ์ผ์นํ๋ค.
7. ๋ค์์ ๊ฐ์ ํ๋ ฌ์ด ํ์ฐ์ ๋ฐฉ์์ผ๋ก ์ ์ฅ๋๋ค๋ฉด, [3,4]์ ๋ค์์ ์ ์ฅ๋๋ ํ๋ ฌ์ ์์๋ ๋ฌด์์ธ๊ฐ?
โ [3,5]
โก [3,3]
โข [4,4]
โฃ [4,3]
์ ๋ต โผ
1 : โ
2 : โฃ
3 : โก
4 : โข
5 : โ
6 : โฃ
7 : โ
'Computer Science' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[์๋ฃ๊ตฌ์กฐ] ํ - ์ ๋ฆฌ ๋ฐ ์ฐ์ต๋ฌธ์ (0) | 2019.11.20 |
---|---|
[์๋ฃ๊ตฌ์กฐ] ์คํ - ์ ๋ฆฌ ๋ฐ ์ฐ์ต๋ฌธ์ (0) | 2019.11.19 |
[์๋ฃ๊ตฌ์กฐ] ์๋ฃ๊ตฌ์กฐ๋ ๋ฌด์์ธ๊ฐ? - ์ ๋ฆฌ ๋ฐ ์ฐ์ต๋ฌธ์ (0) | 2019.11.18 |
์ ์ด์ฅ์น - ์ ์ด์ฅ์น์ ๊ตฌ์ฑ๊ณผ ๋ช ๋ น์ด ์ํ ๊ณผ์ (0) | 2019.11.09 |
์ฒ๋ฆฌ์ฅ์น - ์ ์ด๋จ์ด์ ์ดํด์ ๋ง์ดํฌ๋ก ์ฐ์ฐ์ ์ ์ด๋จ์ด ๋ณํ (0) | 2019.11.09 |
๋๊ธ