1. ์๋๋ C์ธ์ด์ 2์ฐจ์ ๋ฐฐ์ด ํํ์ด๋ค. field์ ๊ฒฝ์ฐ 2์ฐจ์ ๋ฐฐ์ด ํํ๋ ์์์ฒ๋ผ ์ถ๋ ฅ๋๋ฏ๋ก, ์ด๋ฅผ ์ฐธ๊ณ ํ์ฌ mines์ 2์ฐจ์ ๋ฐฐ์ด ํํ๋ฅผ ์์ฑํ์์ค.
void main{
field {{0,1,0,1},{0,0,0,1},{1,1,1,0},{0,1,1,1}};
mines {{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0}};
int w = 4, h = 4;
for(y=0; y<h; y++) {
for(x=0; x<w; x++) {
if(field[y][x] == 0) continue;
for(i=y-1; i<=y+1; i++) {
for(j=x-1; j<=x+1; j++) {
if(calculate(w,h,j,i) == 1) {
mines[i][j] += 1;
}
}
}
}
}
for(y=0; y<h; y++){
for(x=0; x<w; x++)
printf("%d", mines[y][x]);
printf("\n");
}
}
int calculate(w,h,j,i) {
if (i >= 0 && i < h && j >= 0 && j < w) return 1;
return 0;
}
1, 1, 3, 2
3, 4, 5, 3
3, 5, 6, 4
3, 5, 5, 3
์ ์ฝ๋๋ minesweeper ๊ฒ์์์ ์ง๋ขฐ ๊ฐ์๋ฅผ ๊ณ์ฐํ๋ ํจ์์ ๋๋ค.
๊ฒ์ ํ์ ๋ํ๋ด๋ field ๋ฐฐ์ด์์ ๊ฐ ์นธ์ ๊ฐ์ด 0์ธ ๊ฒฝ์ฐ๋ ์ง๋ขฐ๊ฐ ์๋ ๋น ์นธ์ ์๋ฏธํ๋ฉฐ, ์ด์ธ์ ๊ฒฝ์ฐ๋ ์ง๋ขฐ๊ฐ ์๋ ์นธ์ ๋๋ค.
์ด์ค for ๋ฌธ์ ์ฌ์ฉํ์ฌ ๊ฐ ์ง๋ขฐ๊ฐ ์๋ ์นธ์ ์ฐพ์ ํ, ํด๋น ์นธ ์ฃผ๋ณ 8์นธ์ mines ๋ฐฐ์ด ๊ฐ์ 1์ฉ ์ฆ๊ฐ์ํต๋๋ค.
calculate ํจ์๋ ๊ฒ์ ํ ํฌ๊ธฐ๋ฅผ ๋ฒ์ด๋์ง ์๋๋ก ๋ฒ์ ์ฒดํฌ๋ฅผ ํ๋ ํจ์์ ๋๋ค.
๋ง์ง๋ง์ผ๋ก, ์ง๋ขฐ ๊ฐ์๊ฐ ๊ณ์ฐ๋ mines ๋ฐฐ์ด์ ์ถ๋ ฅํฉ๋๋ค.
2. ์๋ ์์๋ฅผ ๋ณด๊ณ ๊ด๊ณ ๋์์ ๋ํ ๊ธฐํธ๋ฅผ ์์ฑํ์์ค.
U, -, X, π, โ
3. ๋ค์์ ๋์์ธ ํจํด์ ๋ํ ์ค๋ช ์ด๋ค. ๊ดํธ์์ ์๋ง๋ ๋ต์ ์์ฑํ์์ค.
(๊ธฐํธ์ ๋ณด๊ธฐ๊ฐ ์์ต๋๋ค. ex: Abstract Factory, Mediator ๋ฑ)
( 1 )์/๋ ๊ธฐ๋ฅ์ ์ฒ๋ฆฌํ๋ ํด๋์ค์ ๊ตฌํ์ ๋ด๋นํ๋ ์ถ์ ํด๋์ค๋ก ๊ตฌ๋ณํ๋ค.
๊ตฌํ๋ฟ ์๋๋ผ ์ถ์ํ๋ ๋
๋ฆฝ์ ๋ณ๊ฒฝ์ด ํ์ํ ๋ ๋ธ๋ฆฌ์ง ํจํด์ ์ฌ์ฉํ๋ค.
๊ธฐ์กด ์์คํ
์ ๋ถ์์ ์ธ ์๋ก์ด ๊ธฐ๋ฅ๋ค์ ์ง์์ ์ผ๋ก ์ถ๊ฐํ ๋ ์ฌ์ฉํ๋ฉด ์ ์ฉํ๋ฉฐ,
์๋ก์ด ์ธํฐํ์ด์ค๋ฅผ ์ ์ํ์ฌ ๊ธฐ์กด ํ๋ก๊ทธ๋จ์ ๋ณ๊ฒฝ ์์ด ๊ธฐ๋ฅ์ ํ์ฅํ ์ ์๋ค.
( 2 )์/๋ ํ ๊ฐ์ฒด์ ์ํ๊ฐ ๋ณํํ๋ฉด ๊ฐ์ฒด์ ์์๋์ด ์๋ ๋ค๋ฅธ ๊ฐ์ฒด๋ค์๊ฒ ๋ณํ๋ ์ํ๋ฅผ ์ ๋ฌํด์ฃผ๋ ํจํด์ด๋ค.
์ผ๋๋ค ๊ด๊ณ๋ฅผ ๊ฐ์ง๋ฉฐ, โ์ฃผ๋ก ๋ถ์ฐ๋ ์์คํ
๊ฐ์ ์ด๋ฒคํธ๋ฅผ ์์ฑ·๋ฐํ(Publish)ํ๊ณ , ์ด๋ฅผ ์์ (Subscribe)ํด์ผ ํ ๋ ์ด์ฉํ๋ค.
- ๋ธ๋ฆฌ์ง ํจํด (Bridge Pattern)
- ์ต์ ๋ฒ ํจํด (Observer Pattern)
๋ธ๋ฆฌ์ง ํจํด์ ๊ตฌํ๊ณผ ์ถ์ํ๋ฅผ ๋ถ๋ฆฌํ์ฌ ๊ฐ๊ฐ ๋ ๋ฆฝ์ ์ผ๋ก ๋ณํํ ์ ์๋๋ก ํ๋ ํจํด์ ๋๋ค.
์ฆ, ๊ธฐ๋ฅ์ ์ฒ๋ฆฌํ๋ ํด๋์ค์ ๊ทธ ๊ตฌํ์ ๋ด๋นํ๋ ์ถ์ ํด๋์ค๋ก ๊ตฌ๋ณํ์ฌ, ์ด๋ค์ ์ฐ๊ฒฐํ๋ ๋ธ๋ฆฟ์ง ์ญํ ์ ํ๋ ํจํด์ ๋๋ค.
์ต์ ๋ฒ ํจํด์ ํ ๊ฐ์ฒด์ ์ํ๊ฐ ๋ณํํ๋ฉด ๊ทธ ๊ฐ์ฒด์ ์์๋์ด ์๋ ๋ค๋ฅธ ๊ฐ์ฒด๋ค์๊ฒ ์๋์ผ๋ก ์๋ฆผ์ ์ ๋ฌํด์ฃผ๋ ํจํด์ ๋๋ค.
์ด ํจํด์ ์ผ๋๋ค ๊ด๊ณ๋ฅผ ๊ฐ์ง๋ฉฐ, ๋ณดํต ๋ถ์ฐ๋ ์์คํ ๊ฐ์ ์ด๋ฒคํธ๋ฅผ ์์ฑํ๊ณ , ์ด๋ฅผ ์์ ํด์ผ ํ ๋ ์ฌ์ฉ๋ฉ๋๋ค.
4. ์๋ ์ฝ๋์ ๋ํ ์ถ๋ ฅ ๊ฐ์ ์์ฑํ์์ค.
void main{
int []result = int[5];
int []arr = [77,32,10,99,50];
for(int i = 0; i < 5; i++) {
result[i] = 1;
for(int j = 0; j < 5; j++) {
if(arr[i] <arr[j]) result[i]++;
}
}
for(int k = 0; k < 5; k++) {
printf(result[k]);
}
}
24513
5. ์๋ ์ฝ๋์ ๋ํ ์ถ๋ ฅ ๊ฐ์ ์์ฑํ์์ค.
์ฒซ๋ฒ์งธ ๋คํธ์ํฌ ์ฃผ์๊ฐ 192.168.1.0/26์ผ๋ FLSM 4๊ฐ๋ก ๋ถํ ํ์๋
๋๋ฒ์งธ ๋คํธ์ํฌ ๋ธ๋ก๋์บ์ค๋ IP๋ฅผ 10์ง์๋ก ๋ณํํ ๊ฐ์ ์์ฑํ์์ค.
192.168.1.127
์๋ธ๋ท๋ง์คํฌ /26
11111111.11111111.11111111.11000000
์ฒซ๋ฒ์งธ ๋คํธ์ํฌ 0 ~ 63
๋๋ฒ์งธ ๋คํธ์ํฌ 64 ~ 127
์ธ๋ฒ์งธ ๋คํธ์ํฌ 128 ~ 191
๋ค๋ฒ์งธ ๋คํธ์ํฌ 192 ~ 255
6. ์๋ ํ๋ฅผ ํ์ธํ์ฌ ๋ณด๊ธฐ์ ์๋ง๋ ๊ฐ์ ๊ณ ๋ฅด์์ค.
(๊ธฐํธ์ ๋ณด๊ธฐ๊ฐ ์์ต๋๋ค. ex: Boundary Value Partitioningโ, Equivalence Partitioning ๋ฑ)
Boundary Value Analysis
Boundary Value Analysis๋ ์ํํธ์จ์ด ํ ์คํธ ๊ธฐ๋ฒ ์ค ํ๋๋ก, ์ ๋ ฅ๊ฐ์ ๊ฒฝ๊ณ(boundary) ๋ถ๋ถ์ ํ ์คํธํ๋ ๊ฒ์ ๋๋ค.
์ด ๊ธฐ๋ฒ์ ์ ๋ ฅ๊ฐ์ด ํน์ ๋ฒ์์ ์ํ ๊ฒฝ์ฐ, ๊ทธ ๋ฒ์์ ์ต์๊ฐ๊ณผ ์ต๋๊ฐ, ๊ทธ๋ฆฌ๊ณ ๊ทธ ์ค๊ฐ๊ฐ์ ํ ์คํธํฉ๋๋ค.
์ด๋ ๋๋ถ๋ถ์ ์ค๋ฅ๊ฐ ๊ฒฝ๊ณ๊ฐ์์ ๋ฐ์ํ๊ธฐ ๋๋ฌธ์, ๋์ ํ ์คํธ ํจ์จ์ฑ์ ๋ณด์ ๋๋ค.
7. ์๋ ๋ฐ์ดํฐ ๋ช ๋ น์ด๋ฅผ ์ ์ฉํ ๊ฒฝ์ฐ ์๋ง๋ ์ถ๋ ฅ๊ฐ์ ์์ฑํ์์ค.โ
CREATE TABLE ๋ถ์(
๋ถ์์ฝ๋ int, ๋ถ์๋ช
varchar(50)
PRIMARY KEY(๋ถ์์ฝ๋)
FORELGN KEY(๋ถ์์ฝ๋)
REFERENCES ์ง์(๋ถ์์ฝ๋)
ON DELETE CASCADE
);
CREATE TABLE ์ง์(
์ง์์ฝ๋ int, ๋ถ์์ฝ๋ int
PRIMARY KEY(์ง์์ฝ๋)
FORELGN KEY(๋ถ์์ฝ๋) PEFERENCES ๋ถ์(๋ถ์์ฝ๋)
);
insert into ๋ถ์ (๋ถ์์ฝ๋, ๋ถ์๋ช
) value ('10', '์์
๋ถ'),
('20', '๊ธฐํ๋ถ'), ('10', '๊ฐ๋ฐ๋ถ');
insert into ์ง์ (์ง์์ฝ๋, ๋ถ์์ฝ๋) value ('1000', '10');
insert into ์ง์ (์ง์์ฝ๋, ๋ถ์์ฝ๋) value ('2000', '10');
insert into ์ง์ (์ง์์ฝ๋, ๋ถ์์ฝ๋) value ('3000', '10');
insert into ์ง์ (์ง์์ฝ๋, ๋ถ์์ฝ๋) value ('4000', '20');
insert into ์ง์ (์ง์์ฝ๋, ๋ถ์์ฝ๋) value ('5000', '20');
insert into ์ง์ (์ง์์ฝ๋, ๋ถ์์ฝ๋) value ('6000', '30');
insert into ์ง์ (์ง์์ฝ๋, ๋ถ์์ฝ๋) value ('7000', '30');
SELECT DISTINCT COUNT(์ง์์ฝ๋) FROM ์ง์ WHERE ๋ถ์์ฝ๋ = '20';
DELETE FROM ๋ถ์ WHERE ๋ถ์์ฝ๋ = '20';
SELECT DISTINCT COUNT(์ง์์ฝ๋) FROM ์ง์;
(1). 3
(2). 4
"distinct"๋ SQL์์ ๋ฐ์ดํฐ๋ฒ ์ด์ค ํ ์ด๋ธ์์ ์ค๋ณต๋ ๊ฐ์ ์ ๊ฑฐํ์ฌ ์ ์ผํ ๊ฐ์ ์ ํํ๋ ํค์๋์ ๋๋ค.
"on delete cascade"๋ ๊ด๊ณํ ๋ฐ์ดํฐ๋ฒ ์ด์ค์์ ์ธ๋ํค(foreign key) ์ ์ฝ ์กฐ๊ฑด์ ์ค์ ํ ๋ ์ฌ์ฉํ๋ ์ต์ ์ค ํ๋์ ๋๋ค.
์ธ๋ํค๋ ๋ค๋ฅธ ํ ์ด๋ธ์ ๊ธฐ๋ณธํค(primary key)๋ฅผ ์ฐธ์กฐํ๋ ์ปฌ๋ผ์ ์๋ฏธํ๋ฉฐ, ์ด๋ฅผ ํตํด ๋ ๊ฐ ์ด์์ ํ ์ด๋ธ์ ์ฐ๊ฒฐํ ์ ์์ต๋๋ค. ์ด ๋, ์ธ๋ํค๋ฅผ ์ฐธ์กฐํ๋ ๋ ์ฝ๋๊ฐ ์ญ์ ๋ ๋, ์ฐธ์กฐ๋ ๋ ์ฝ๋๋ ํจ๊ป ์ญ์ ๋๋๋ก ์ค์ ํ ์ ์์ต๋๋ค.
์ด๋ฅผ "on delete cascade"๋ผ๊ณ ํฉ๋๋ค.
8. ์๋ ์ค๋ช ์ ๋ํ ์๋ง๋ ๋ต์ ์์ฑํ์์ค.
( 1 ) ์/๋ ๋ณด์ํ์ ์ธก๋ฉด์์ ๊ธฐ์ ์ ์ธ ๋ฐฉ๋ฒ์ด ์๋ ์ฌ๋๋ค๊ฐ์ ๊ธฐ๋ณธ์ ์ธ ์ ๋ขฐ๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ์ฌ๋์ ์์ฌ ๋น๋ฐ ์ ๋ณด๋ฅผ ํ๋ํ๋ ๊ธฐ๋ฒ์ด๋ค.
( 2 ) ์/๋ ๋น
๋ฐ์ดํฐ(Big Data)์ ๋น์ทํ๋ฉด์๋ ๊ตฌ์กฐํ๋ผ ์์ง ์๊ณ , ๋๋ ์ฌ์ฉํ์ง ์๋ ‘์ฃฝ์’ ๋ฐ์ดํฐ๋ฅผ ์๋ฏธํ๋ค. ์ผ๋ฐ์ ์ผ๋ก ์ ๋ณด๋ฅผ ์์งํด ์ ์ฅํ ์ดํ ๋ถ์์ด๋ ํน๋ณํ ๋ชฉ์ ์ ์ํด ํ์ฉํ๋ ๋ฐ์ดํฐ๊ฐ ์๋๋ฉฐ, ์ ์ฅ๊ณต๊ฐ๋ง ์ฐจ์งํ๊ณ ์ด๋ฌํ ์ด์ ๋ก ์ฌ๊ฐํ ๋ณด์ ์ํ์ ์ด๋ํ ์ ์๋ค.
1. ์ฌํ๊ณตํ
2. ๋คํฌ ๋ฐ์ดํฐ
9. ๋ค์ ํ์ด์ฌ ์ฝ๋์ ๋ํ ์ถ๋ ฅ๊ฐ์ ์์ฑํ์์ค.
TestList = [1, 2, 3, 4, 5]
TestList = list(map(lambda num: num + 100, TestList))
print(TestList)
์ถ๋ ฅ ๊ฒฐ๊ณผ๋ [101, 102, 103, 104, 105]์ ๋๋ค.
ํด๋น ์ฝ๋๋ ๋ฆฌ์คํธ TestList์ ๊ฐ ์์์ 100์ ๋ํ ์๋ก์ด ๋ฆฌ์คํธ๋ฅผ ์์ฑํ๋ ์ฝ๋์ ๋๋ค.
map() ํจ์๋ ๋ฆฌ์คํธ ๋ด์ ๋ชจ๋ ์์์ ์ง์ ๋ ํจ์๋ฅผ ์ ์ฉํ ๊ฒฐ๊ณผ๋ฅผ ์๋ก์ด ๋ฆฌ์คํธ๋ก ๋ฐํํฉ๋๋ค.
lambda ํจ์๋ ํ ์ค๋ก ํจ์๋ฅผ ์ ์ํ ์ ์๋ ํจ์์ ๋๋ค.
๋ฐ๋ผ์ ํด๋น ์ฝ๋์์ lambda num: num + 100์ num์ด๋ผ๋ ์ธ์๋ฅผ ๋ฐ์์ num + 100์ ๋ฐํํ๋ ํจ์๋ฅผ ์๋ฏธํฉ๋๋ค.
10. ๋ค์ ๋ณด์ ๊ด๋ จ ์ค๋ช ์ผ๋ก ๊ฐ์ฅ ์๋ง๋ ์ฉ์ด๋ฅผ ์์ฑํ์์ค.
( ) ์/๋ ๋จธ์ ๋ฌ๋ ๊ธฐ์ ์ ์ด์ฉํ์ฌ IT ์์คํ ์์ ๋ฐ์ํ๋ ๋๋์ ๋ก๊ทธ๋ฅผ ํตํฉ๊ด๋ฆฌ ๋ฐ ๋ถ์ํ์ฌ ์ฌ์ ์ ์ํ์ ๋์ํ๋ ๋ณด์ ์๋ฃจ์ ์ด๋ค. ์๋ก ๋ค๋ฅธ ๊ธฐ์ข ์ ๋ณด์์๋ฃจ์ ๋ก๊ทธ ๋ฐ ์ด๋ฒคํธ๋ฅผ ์ค์์์ ํตํฉ ์์งํ์ฌ ๋ถ์ํ ์ ์์ผ๋ฉฐ, ๋คํธ์ํฌ ์ํ์ monitoring ๋ฐ ์ด์์งํ๋ฅผ ๋ฏธ๋ฆฌ ๊ฐ์งํ ์ ์๋ค.
- ๋คํธ์ํฌ ์ด๊ธฐ์ข ์ฅ๋น ๊ฐ ๋ก๊ทธ์ ์๊ด๊ด๊ณ ๋ถ์
- ์ด์์งํ์ ํ์ ๊ธฐ๋ฐ ๋ฐ ๋ฌธ๋งฅ ๊ธฐ๋ฐ ๋ถ์ ๊ธฐ๋ฅ
- ๊ฐ ๋ก๊ทธ์ ์๊ด๊ด๊ณ๋ฅผ ์กฐ๊ฑด์์ ๋ฐ๋ผ ๊ฒ์ํ์ฌ ๋ถ์์ด ๊ฐ๋ฅ
- ์ด๋ฒคํธ ๋ฐ ๋ก๊ทธ์ ์ด์ํจํด์ ์ธ์ํด ์ ์ฌ์ ์ํ์ด ๋ฐ์์ ์๋ฆผ ๊ธฐ๋ฅ
SIEM
SIEM์ ๋ณด์ ์ ๋ณด ๋ฐ ์ด๋ฒคํธ ๊ด๋ฆฌ(Security Information and Event Management)์ ์ฝ์ด๋ก, ๊ธฐ์ ๋ด์์ ๋ฐ์ํ๋ ๋ณด์ ๊ด๋ จ ์ด๋ฒคํธ๋ค์ ์ค์๊ฐ์ผ๋ก ๋ชจ๋ํฐ๋งํ๊ณ ๋ถ์ํ์ฌ ๋ณด์ ์ํ์ ๋ํ ๋์ ๋ฐ ์๋ฐฉ์ ์ํํ๋ ์๋ฃจ์ ์ ๋๋ค.
SIEM ์๋ฃจ์ ์ ๋ค์ํ ๋ณด์ ๋ก๊ทธ ๋ฐ์ดํฐ๋ฅผ ์์ง, ๋ถ์ํ๊ณ ์ด๋ฅผ ์๊ฐํํ์ฌ ๊ด๋ฆฌ์๊ฐ ๋ณด์ ์ด์๋ฅผ ์ ์ํ๊ฒ ํ์ ํ ์ ์๋๋ก ์ง์ํฉ๋๋ค. ๋ํ, SIEM์ ์ด๋ฌํ ๋ณด์ ์ด์์ ๋ํ ๋์์ ์๋ํํ๊ณ ๋ณด์ ๊ท์ ์ค์๋ฅผ ๊ฐ์ ํ๋ ๋ฑ์ ๊ธฐ๋ฅ์ ์ ๊ณตํฉ๋๋ค.
11. ๋ค์ ๋ณด๊ธฐ ์ค, ํ์ ๊ด๋ฆฌ ํญ๋ชฉ์ 3๊ฐ์ง ๊ณ ๋ฅด์์ค.
CVS, SVN, GIT
12. STUDENT ํ ์ด๋ธ์์ ์ปดํจํฐ๊ณผ ํ์ 50๋ช , ์ ๊ธฐ๊ณผ ํ์ 100๋ช , ์ธํฐ๋ท๊ณผ ํ์ 50๋ช ์ ์ ๋ณด๊ฐ ์ ์ฅ๋์ด ์์ ๋,
๋ค์ SQL๋ฌธ์ ์คํ ๊ฒฐ๊ณผ์ ๋ฐ๋ฅธ ํํ์ ์๋? (๋จ, DEPT ์นผ๋ผ์ ํ๊ณผ๋ช ์ด๋ค.)
1) SELECT DERP FROM STUDENT;
2) SELECT DISTINCT DEPT FROM STUDENT;
3) SELECT COUNT(DISTINCT DEPT) FROM STUDENT WHERE DEPT = '์ธํฐ๋ท๊ณผ';
200
3
1
13. ๋ค์ ์ฝ๋์ ๋ํ ์ถ๋ ฅ ๊ฐ์ ์์ฑํ์์ค.
int n;
int k;
int s;
int el = 0;
for(n=6; n<=30; n++){
s=0;
k=n/2;
for(int j=1; j<=k; j++){
if(n%j==0){
s=s+j;
}
}
if(s==n){
el++;
}
}
printf("%d", el);
2
์ด ์ฝ๋๋ 6๋ถํฐ 30๊น์ง์ ์์ ์ ๊ฐ์๋ฅผ ๊ตฌํ๋ ์ฝ๋์ ๋๋ค.
์์ ์๋, ์๊ธฐ ์์ ์ ์ ์ธํ ์์ ์ฝ์๋ค์ ํฉ์ด ์๊ธฐ ์์ ๊ณผ ๊ฐ์ ์๋ฅผ ๋งํฉ๋๋ค.
์ฝ๋์ ์คํ ๊ฒฐ๊ณผ๋ 2๊ฐ ๋ฉ๋๋ค. ์์ ์์ธ 6๊ณผ 28์ด ์กด์ฌํ๊ธฐ ๋๋ฌธ์ ๋๋ค.
14. ์๋ ์ค๋ช ์ ๋ํ์ฌ ์๋ง๋ ๋ต์ ๋ณด๊ธฐ์์ ๊ณ ๋ฅด์์ค.
(๊ธฐํธ์ ๋ณด๊ธฐ๊ฐ ์์ต๋๋ค. ex: CSRF ๋ฑ)
( 1 )์/๋ ํ๋ก์ธ์(processor) ์์ ๋
๋ฆฝ์ ์ธ ๋ณด์ ๊ตฌ์ญ์ ๋ฐ๋ก ๋์ด ์ค์ํ ์ ๋ณด๋ฅผ ๋ณดํธํ๋ ARM์ฌ์์ ๊ฐ๋ฐํ ํ๋์จ์ด ๊ธฐ๋ฐ์ ๋ณด์ ๊ธฐ์ ๋ก ํ๋ก์ธ์(processor) ์์ ๋
๋ฆฝ์ ์ธ ๋ณด์ ๊ตฌ์ญ์ ๋ณ๋๋ก ํ์ฌ, ์ค์ํ ์ ๋ณด๋ฅผ ๋ณดํธํ๋ ํ๋์จ์ด ๊ธฐ๋ฐ์ ๋ณด์ ๊ธฐ์ ์ด๋ค.
( 2 )์/๋ ์ฌ์ฉ์๋ค์ด ์ฌ์ดํธ์ ์ ์ํ ๋ ์ฃผ์๋ฅผ ์๋ชป ์
๋ ฅํ๊ฑฐ๋ ์ฒ ์๋ฅผ ๋น ๋จ๋ฆฌ๋ ์ค์๋ฅผ ์ด์ฉํ๊ธฐ ์ํด ์ ์ฌํ ์ ๋ช
๋๋ฉ์ธ์ ๋ฏธ๋ฆฌ ๋ฑ๋กํ๋ ์ผ๋ก URL ํ์ด์ฌํน(hijacking)์ด๋ผ๊ณ ๋ ํ๋ค.
1. Trustzone
2. typosquatting
15. ์๋ ์ค๋ช ์ ๋ํ์ฌ ์๋ง๋ ์ฉ์ด๋ฅผ ์์ฑํ์์ค.
( )์/๋ ์ฌ๋ฌ ๊ฐ์ ์ฌ์ดํธ์์ ํ๋ฒ์ ๋ก๊ทธ์ธ์ผ๋ก ์ฌ๋ฌ๊ฐ์ง ๋ค๋ฅธ ์ฌ์ดํธ๋ค์ ์๋์ ์ผ๋ก ์ ์ํ์ฌ ์ด์ฉํ๋ ๋ฐฉ๋ฒ์ ๋งํ๋ค. ์ผ๋ฐ์ ์ผ๋ก ์๋ก ๋ค๋ฅธ ์์คํ ๋ฐ ์ฌ์ดํธ์์ ๊ฐ๊ฐ์ ์ฌ์ฉ์ ์ ๋ณด๋ฅผ ๊ด๋ฆฌํ๊ฒ ๋๋๋ฐ ์ด๋ ํ๋์ ์ฌ์ฉ์ ์ ๋ณด๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ์ฌ๋ฌ ์์คํ ์ ํ๋์ ํตํฉ ์ธ์ฆ์ ์ฌ์ฉํ๊ฒ ํ๋ ๊ฒ์ ๋งํ๋ค. ์ฆ ํ๋์ ์์คํ ์์ ์ธ์ฆ์ ํ ๊ฒฝ์ฐ ํ ์์คํ ์์๋ ์ธ์ฆ ์ ๋ณด๊ฐ ์๋์ง ํ์ธํ๊ณ ์์ผ๋ฉด ๋ก๊ทธ์ธ ์ฒ๋ฆฌ๋ฅผ ํ๋๋ก ํ๊ณ , ์๋ ๊ฒฝ์ฐ ๋ค์ ํตํฉ ์ธ์ฆ์ ํ ์ ์๋๋ก ๋ง๋๋ ๊ฒ์ ์๋ฏธํ๋ค.
์ฑ๊ธ ์ฌ์ธ ์จ (Single Sign-On, SSO)
16. ๋ค์์ ์ค์ผ์ค๋ง์ ๊ดํ ๋ด์ฉ์ด๋ค. ๊ดํธ์์ ์๋ง๋ ๋ต์ ์์ฑํ์์ค.
๋น์ ์ | ( A ) | ๋จผ์ ๋ค์ด์จ ํ๋ก์ธ์ค ๋จผ์ ์ฒ๋ฆฌ | Convoy Effect ๋ฐ์ |
( B ) | ์ฒ๋ฆฌ์๊ฐ์ด ์งง์ ํ๋ก์ธ์ค๋ถํฐ ์ฒ๋ฆฌ | Starvation ๋ฐ์ | |
HRN | ์งง์ ์์ ์๊ฐ์ด๋ฉด์ ๋๊ธฐ์๊ฐ์ด ๊ธด ํ๋ก์ธ์ค๋ถํฐ ์ฒ๋ฆฌ | Starvation ํด๊ฒฐ | |
์ ์ | ( C ) | ๋จผ์ ๋ค์ด์จ ์์๋๋ก ์ผ์ ์๊ฐ๋งํผ๋ง ์ฒ๋ฆฌ | |
( D ) | ๋จ์ ์๊ฐ์ด ์งง์ ํ๋ก์ธ์ค๋ถํฐ ์ฒ๋ฆฌ | ||
MLQ | ์ฐ์ ์์๋ณ๋ก ํ๋ฅผ ๋ถ๋ฆฌํ์ฌ ๋ค์ํ ์ค์ผ์ค๋ง ์ ์ฉ | Starvation ๋ฐ์ |
FCFS
SJF
RR (๋ผ์ด๋ ๋ก๋น)
SRT
FCFS๋ First-Come-First-Served์ ์ฝ์๋ก, ๋จผ์ ๋์ฐฉํ ํ๋ก์ธ์ค๋ฅผ ๋จผ์ ์ฒ๋ฆฌ
SJF(Shortest Job First)๋ ํ๋ก์ธ์ค์ ์คํ์๊ฐ์ ๊ณ ๋ คํ์ฌ ์ฒ๋ฆฌ์๊ฐ์ด ์งง์ ์์๋๋ก ํ๋ก์ธ์ค๋ฅผ ์ฒ๋ฆฌํ๋ ๋ฐฉ์
HRN(Highest Response ratio Next) :
๋ผ์ด๋ ๋ก๋น(Round Robin) : ํ๋ก์ธ์ค์๊ฒ ๊ฐ๊ฐ ๋์ผํ CPU ํ ๋น ์๊ฐ(ํ์ ์ฌ๋ผ์ด์ค, quantum)์ ๋ถ์ฌํด์
๊ทธ ์๊ฐ ๋์๋ง CPU๋ฅผ ์ด์ฉํ๊ฒ ํ๋ค.
SRT(Shortest Remaining Time)
๋ค๋จ๊ณ ํ(Multi-Level Queue)
17. ๋ค์์ UML์ ๊ดํ ์ค๋ช ์ด๋ค. ๊ดํธ์์ ์๋ง๋ ๋ต์ ์์ฑํ์์ค.
UML์ ํตํฉ ๋ชจ๋ธ๋ง ์ธ์ด๋ก์จ, ์์คํ ์ ๋ชจ๋ธ๋ก ํํํด์ฃผ๋ ๋ํ์ ์ธ ๋ชจ๋ธ๋ง ์ธ์ด์ด๋ค.
๊ตฌ์ฑ ์์๋ก๋ ์ฌ๋ฌผ, ( 1 ), ๋ค์ด์ด๊ทธ๋จ์ผ๋ก ์ด๋ฃจ์ด์ ธ ์์ผ๋ฉฐ, ๊ตฌ์กฐ ๋ค์ด์ด๊ทธ๋จ ์ค, ( 2 ) ๋ค์ด์ด๊ทธ๋จ์ ์์คํ ์์ ์ฌ์ฉ๋๋ ๊ฐ์ฒด ํ์ ์ ์ ์ํ๊ณ , ๊ทธ๋ค ๊ฐ์ ์กด์ฌํ๋ ์ ์ ์ธ ๊ด๊ณ๋ฅผ ๋ค์ํ ๋ฐฉ์์ผ๋ก ํํํ ๋ค์ด์ด๊ทธ๋จ์ด๋ค.
๋ํ UML ๋ชจ๋ธ๋ง์์ ( 3 )์/๋ ํด๋์ค์ ๊ฐ์ ๊ธฐํ ๋ชจ๋ธ ์์ ๋๋ ์ปดํฌ๋ํธ๊ฐ ๊ตฌํํด์ผ ํ๋ ์คํผ๋ ์ด์ ์ธํธ๋ฅผ ์ ์ํ๋ ๋ชจ๋ธ ์์์ด๋ค.
1. ๊ด๊ณ
2. ํด๋์ค
3. ์ธํฐํ์ด์ค
18. ๋ค์์ E-R๋ค์ด์ด๊ทธ๋จ์ ๊ดํ ์ค๋ช ์ด๋ค. ๊ดํธ ์์ ์๋ง๋ ๋ต์ ์์ฑํ์์ค.
๋ค์ค๊ฐ ์์ฑ, ์ฝํ ๊ฐ์ฒด ํ์
, ํค ์์ฑ, ๊ฐ์ฒด ํ์
, ์์ฑ, ๊ด๊ณ ํ์
, ์์ฑ, ์ฝํ ๊ด๊ณ ํ์
A ๊ฐ์ฒด ํ์
B ์ฝํ ๊ฐ์ฒด ํ์
C ๊ด๊ณ ํ์
D ์ฝํ ๊ด๊ณ ํ์
E ์์ฑ
F ํค ์์ฑ
G ๋ค์ค๊ฐ ์์ฑ
19. ๋ค์ ์๋ฐ ์ฝ๋์ ๋ํ ์ถ๋ ฅ ๊ฐ์ ์์ฑํ์์ค.
public class Main {
static int[] MakeArray(){
int[] tempArr = new int[4];
for(int i=0; i<tempArr.Length;i++){
tempArr[i] = i;
}
return tempArr;
}
public static void main(String[] args){
int[] intArr;
intArr = MakeArray();
for(int i=0; i < intArr.Length; i++)
System.out.print(intArr[i]);
}
}
0123
20. ๋ค์ ์๋ฐ ์ฝ๋์ ๋ํ ์ถ๋ ฅ ๊ฐ์ ์์ฑํ์์ค.
public class Exam {
public static void main(String[] args){
int a = 0;
for(int i=1; i<999; i++){
if(i%3==0 && i%2!=0)
a = i;
}
System.out.print(a);
}
}
993
'์๊ฒฉ์ฆ > ์ ๋ณด์ฒ๋ฆฌ๊ธฐ์ฌ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[์ ๋ณด์ฒ๋ฆฌ๊ธฐ์ฌ ์ค๊ธฐ] ๊ธฐ์ถ๋ฌธ์ ์ ๋ฆฌ (1) | 2023.04.20 |
---|---|
[์ ๋ณด์ฒ๋ฆฌ๊ธฐ์ฌ ์ค๊ธฐ] 2022๋ 2ํ ๊ธฐ์ถ๋ฌธ์ (0) | 2023.04.18 |
[์ ๋ณด์ฒ๋ฆฌ๊ธฐ์ฌ ์ค๊ธฐ] 2022๋ 1ํ ๊ธฐ์ถ๋ฌธ์ (0) | 2023.04.17 |
[์ ๋ณด์ฒ๋ฆฌ๊ธฐ์ฌ ์ค๊ธฐ] 2021๋ 3ํ ๊ธฐ์ถ๋ฌธ์ (0) | 2023.04.16 |
[์ ๋ณด์ฒ๋ฆฌ๊ธฐ์ฌ ์ค๊ธฐ] 2021๋ 2ํ ๊ธฐ์ถ๋ฌธ์ (0) | 2023.04.15 |