1. ์๋ ์ค๋ช
์ ๋ง๋ RAID ๋จ๊ณ๋ฅผ ์ซ์๋ก ์์ฑํ์์ค.
- Striping(์คํธ๋ผ์ดํ) ๊ตฌํ ๋ฐฉ์
- I/O ๋ก๋์ ๋ถ์ฐ์ผ๋ก ๋งค์ฐ ๋น ๋ฅธ ์๋
- ๋ฐ์ดํฐ๋ฅผ ๋ธ๋ญ์ผ๋ก ๋ถํ ์ ์ฅํ๋ฉฐ, ๊ฐ ๋ธ๋ญ์ ๋ค๋ฅธ ๋์คํฌ๋ก ๋๋์ด ์ ์ฅ
2. ๋ค์ ์ค๋ช
์ ํ์ธํ์ฌ ํด๋นํ๋ ํญ๋ชฉ์ ๋ณด๊ธฐ์์ ์ฐพ์ ์ ์ผ์์ค.
(์ค์ ๊ธฐ์ถ๋ฌธ์ ์์๋ ๋ต์ ๋ณด๊ธฐ๊ฐ ์ฃผ์ด์ง๋๋ค.(์ค๋ต ์ค, rollback ๋ฑ..))
1. ์ค๋ฅ๊ฐ ๋ฐ์ํ๊ธฐ ์ ๊น์ง์ ์ฌํญ์ ๋ก๊ทธ(log)๋ก ๊ธฐ๋กํด ๋๊ณ , ์ด์ ์ํ๋ก ๋๋์๊ฐ ํ, ์คํจ๊ฐ ๋ฐ์ํ๊ธฐ ์ ๊น์ง์ ๊ณผ์ ์ ๊ทธ๋๋ก ๋ฐ๋ผ๊ฐ๋ ํ์
2. ์์
์ ์ทจ์ํ์ฌ ํธ๋์ญ์
์ ์ด์ ์ํ๋ก ๋๋๋ฆฌ๋ ๊ฒ
3. ๋ค์ ์๋ฐ ๋ฌธ๋ฒ์ ์๋ง๋ ์ถ๋ ฅ ๊ฒฐ๊ณผ๋ฅผ ์์ฑํ์์ค.
class A {
int a;
int b;
}
public class Main {
static void func1(A m){
m.a *= 10;
}
static void func2(A m){
m.a += m.b;
}
public static void main(String args[]){
A m = new A();
m.a = 100;
func1(m);
m.b = m.a;
func2(m);
System.out.printf("%d", m.a);
}
}
2000
4. ๋ค์ SQL ๊ฒฐ๊ณผ์ ์๋ง๋ ์ฟผ๋ฆฌ์ ์์ฑํ์์ค.
SELECT name, score FROM ์ฑ์ ( 1 ) BY ( 2 ) ( 3 )
1. ORDER
2. score
3. DESC
SELECT name, score FROM ์ฑ์ ORDER BY score DESC
score ๋ฅผ ๋ด๋ฆผ์ฐจ์์ผ๋ก ์ ๋ ฌํ์ฌ ๋ฐํํฉ๋๋ค.
๋ฐ๋ผ์ ๊ฒฐ๊ณผ๋ "score" ์ปฌ๋ผ์ ๊ธฐ์ค์ผ๋ก ๋ด๋ฆผ์ฐจ์์ผ๋ก ์ ๋ ฌ๋ ์ํ๋ก ๋ฐํ๋ฉ๋๋ค.
5. ๋ฐ์ดํฐ๋ฒ ์ด์ค์ ์ด์ํ์ ์ค, ์ญ์ ์ด์์ ๋ํด ์์ ํ์์ค.
๋ฐ์ดํฐ๋ฅผ ์ญ์ ํ ๊ฒฝ์ฐ ์ํ์ง ์๋ ๋ค๋ฅธ ๋ฐ์ดํฐ๋ ์ญ์ ๋์ด๋ฒ๋ฆฌ๋ ์ด์
์ญ์ ์ด์(Delete Anomaly)์ ๋ฐ์ดํฐ๋ฒ ์ด์ค์์ ํน์ ํ์ ์ญ์ ํ ๋,
๊ทธ ํ๊ณผ ๊ด๋ จ๋ ๋ค๋ฅธ ํ๋ค๋ ํจ๊ป ์ญ์ ๋์ด์๋ ์ ๋จ์๋ ๋ถ๊ตฌํ๊ณ ์ญ์ ๋ ๊ฒฝ์ฐ๋ฅผ ๋งํฉ๋๋ค.
6. ๋ค์์ ํ์ด์ฌ ์ฝ๋์์ ์ถ๋ ฅ๋๋ a์ b์ ๊ฐ์ ์์ฑํ์์ค.
def exam(num1, num2=2):
print('a=', num1, 'b=', num2)
exam(20)
a= 20 b= 2
์ ์ฝ๋๋ฅผ ์คํํ๋ฉด, ํจ์ exam์ด ํธ์ถ๋ ๋ ์ธ์ num1์๋ 20์ด ์ ๋ฌ๋๊ณ , ์ธ์ num2์๋ ๊ธฐ๋ณธ๊ฐ์ผ๋ก 2๊ฐ ์ ๋ฌ๋ฉ๋๋ค.
๋ฐ๋ผ์, ํจ์ ๋ด๋ถ์์ ์ถ๋ ฅ๋๋ ๋ฌธ์์ด์ a= 20 b= 2๊ฐ ๋ฉ๋๋ค.
์ฆ, exam(20)์ ํธ์ถํ๋ฉด a= 20 b= 2๊ฐ ์ถ๋ ฅ๋ฉ๋๋ค.
7. ๋ค์ ์ค๋ช
๊ณผ ๊ด๋ จ๋ ๋ต์ ๋ณด๊ธฐ์์ ๊ณจ๋ผ ์์ฑํ์์ค.
(์ค์ ๊ธฐ์ถ๋ฌธ์ ์์๋ ๋ต์ ๋ณด๊ธฐ๊ฐ ์ฃผ์ด์ง๋๋ค.(์ค๋ต ์ค, remove, sort ๋ฑ..))
1. ์์๋ฅผ ํ์ฅํด์ค๋ค๋ ์๋ฏธ๋ฅผ ๊ฐ์ง๊ณ ์์ผ๋ฉฐ, ๋ชจ๋ ํญ๋ชฉ์ ํ๋์ ์์๋ก ์ถ๊ฐ
2. ๋ฆฌ์คํธ ๋ด๋ถ ์์๋ฅผ ๊บผ๋ด์ฃผ๋ ํจ์๋ก์จ, ๊ทธ ์์๋ ๋ฆฌ์คํธ ์์์ ์ญ์ ํ๊ณ ๊ทธ ๊ฐ์ ๋ฐํ
3. ๋ฆฌ์คํธ ๋ด๋ถ์ ์์์ ์์๋ ๋ค์ง๋ ์ญํ
1. extend
2. pop
3. reverse
8. ๋ค์ ์๋ ๋จ์ด๋ฅผ ์์ด ์ฝ์๋ก ์์ฑํ์์ค.
์์ ํค ๋ฌด๊ฒฐ์ฑ ํ๋กํ ์ฝ
TKIP (Temporal Key Integrity Protocol)
9. ๋ค์ ์ค, ์ค๋ช
์ ๋ํ ๋ต์ ์์ด ์ฝ์๋ก ์์ฑํ์์ค.
ํค๋ณด๋๋ ๋ง์ฐ์ค์ ๊ฐ์ ์ฅ์น ์์ด ๋ง์ด๋ ํ๋ ๊ทธ๋ฆฌ๊ณ ๊ฐ์ ๊ณผ ๊ฐ์ ์ธ๊ฐ์ ์์ฐ์ค๋ฌ์ด ํํ์ผ๋ก ์ปดํจํฐ๋ ์ฅ์น๋ฅผ ์ ์ดํ ์ ์๋ ํ๊ฒฝ
NUI
NUI๋ "Natural User Interface(์์ฐ์ค๋ฌ์ด ์ฌ์ฉ์ ์ธํฐํ์ด์ค)"์ ์ฝ์ด๋ก์, ์ปดํจํฐ์ ์ธ๊ฐ ์ฌ์ด์ ์ํธ์์ฉ ๋ฐฉ์์ ๊ฐ์ ํ๊ธฐ ์ํ ๊ธฐ์ ์ ๋๋ค. ๊ธฐ์กด์ ๋ง์ฐ์ค๋ ํค๋ณด๋์ ๊ฐ์ ์ ๋ ฅ์ฅ์น๋ณด๋ค ๋์ฑ ์ง๊ด์ ์ด๊ณ ์์ฐ์ค๋ฌ์ด ๋ฐฉ์์ผ๋ก ์ฌ์ฉ์์ ์ปดํจํฐ๊ฐ ์ํธ์์ฉํ ์ ์๋๋ก ํฉ๋๋ค.
10. ๋ค์์ ๋ถ์๋๊ตฌ์ ๋ํ ์ค๋ช
์ผ๋ก ๋ณด๊ธฐ์ ์๋ง๋ ๋ต์ ์์ฑํ์์ค.
(์ค์ ๊ธฐ์ถ๋ฌธ์ ์์๋ ๋ต์ ๋ณด๊ธฐ๊ฐ ์ฃผ์ด์ง๋๋ค.(์ค๋ต ์ค, running analysis ๋ฑ..))
1. ์์ค ์ฝ๋์ ์คํ ์์ด, ์ฝ๋์ ์๋ฏธ๋ฅผ ๋ถ์ํด ๊ฒฐํจ์ ์ฐพ์๋ด๋ ์์์ ์ฝ๋ ๋ถ์ ๊ธฐ๋ฒ
2. ์์ค ์ฝ๋๋ฅผ ์คํํ์ฌ ํ๋ก๊ทธ๋จ ๋์์ด๋ ๋ฐ์์ ์ถ์ ํ๊ณ ์ฝ๋์ ์กด์ฌํ๋ ๋ฉ๋ชจ๋ฆฌ ๋์, ์ค๋ ๋ ๊ฒฐํจ ๋ฑ์ ๋ถ์
1. static
2. dynamic
11. ๋ค์ Java ์ฝ๋ ์ค์์ ๋ฐ์ค์ ๋ค์ด๊ฐ ์๋ง๋ ์ฝ๋๋ฅผ ์์ฑํ์์ค.
class Car implements Runnable{
int a;
public void run(){
system.out.println("message")
}
}
public class Main{
public static void main(String args[]){
Thread t1 = new Thread(new ___());
t1.start();
}
}
์ ์ฝ๋์์ ___ ์๋ฆฌ์๋ Car ํด๋์ค์ ๊ฐ์ฒด๋ฅผ ์์ฑํ์ฌ ์ ๋ฌํด์ผ ํฉ๋๋ค.
Car ํด๋์ค๋ Runnable ์ธํฐํ์ด์ค๋ฅผ ๊ตฌํํ๊ณ ์์ผ๋ฉฐ, run ๋ฉ์๋๋ฅผ ์ค๋ฒ๋ผ์ด๋ฉํ์ฌ ์๋ก์ด ์ค๋ ๋์์ ์คํํ ์ฝ๋๋ฅผ ์์ฑํ๊ณ ์์ต๋๋ค.
๋ฐ๋ผ์ Car ํด๋์ค์ ๊ฐ์ฒด๋ฅผ ์์ฑํ๊ณ , ์ด๋ฅผ Thread ํด๋์ค์ ์์ฑ์์ ์ ๋ฌํ์ฌ ์๋ก์ด ์ค๋ ๋๋ฅผ ์์ฑํ๊ณ ์คํํ ์ ์์ต๋๋ค.
์๋๋ Car ํด๋์ค ๊ฐ์ฒด๋ฅผ ์์ฑํ์ฌ Thread ํด๋์ค ์์ฑ์์ ์ ๋ฌํ๋ ์ฝ๋์ ๋๋ค.
์ ์ฝ๋๋ฅผ ์คํํ๋ฉด, Car ํด๋์ค์ run ๋ฉ์๋๊ฐ ์๋ก์ด ์ค๋ ๋์์ ์คํ๋๋ฉฐ, "message"๋ผ๋ ๋ฌธ์์ด์ด ์ถ๋ ฅ๋ฉ๋๋ค.
12. ๋ค์ ์ค๋ช
์ ๋ํ ์๋ง๋ ๋จ์ด๋ฅผ ์์ฑํ์์ค.
์๋ฐ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด๋ฅผ ์ด์ฉํ xUnit์ ํ
์คํธ ๊ธฐ๋ฒ์ผ๋ก์จ ์จ๊ฒจ์ง ๋จ์ ํ
์คํธ๋ฅผ ๋์ด๋ด์ด ์ ํํ์์ผ ๋จ์ ํ
์คํธ๋ฅผ ์ฝ๊ฒ ํด์ฃผ๋ ํ
์คํธ์ฉ Framework์ด๋ค.
JUnit
JUnit์ ์๋ฐ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด๋ฅผ ์ด์ฉํ xUnit์ ํ ์คํธ ๊ธฐ๋ฒ ์ค ํ๋๋ก, ๋จ์ ํ ์คํธ๋ฅผ ์ฝ๊ฒ ํ๋๋ก ๋์์ฃผ๋ ํ ์คํธ์ฉ Framework์ ๋๋ค. JUnit์ ์จ๊ฒจ์ง ๋จ์ ํ ์คํธ๋ฅผ ๋์ด๋ด์ด ์ ํํ์์ผ ์ค๋ค๋ ํน์ง์ ๊ฐ์ง๊ณ ์์ต๋๋ค. JUnit์ ์ฌ์ฉํ๋ฉด ์๋ํ๋ ๋จ์ ํ ์คํธ๋ฅผ ์ํํ๊ณ , ํ ์คํธ ๊ฒฐ๊ณผ๋ฅผ ๋น ๋ฅด๊ฒ ํ์ธํ ์ ์์ต๋๋ค. ์ด๋ฅผ ํตํด ์ํํธ์จ์ด ๊ฐ๋ฐ์ ํจ์จ์ฑ์ ๋์ผ ์ ์์ต๋๋ค.
13. ๋ค์ ๋ณด๊ธฐ ์ค์์ ๋ธ๋๋ฐ์ค ํ ์คํธ ๊ธฐ๋ฒ์ 3๊ฐ์ง ๊ณจ๋ผ ์์ฑํ์์ค.
ใท, ใน, ใ
14. ๋ค์ ์์ค์ฝ๋์์ ์ ๋ ฅ๊ฐ์ด 5๊ฐ ๋ค์ด์์๋ ์ถ๋ ฅ๋๋ ๊ฐ์ ์์ฑํ์์ค.
#include <stdio.h>
int func(int a) {
if (a <= 1) return 1;
return a * func(a - 1);
}
int main() {
int a;
scanf("%d", &a);
printf("%d", func(a));
}
120
์์ ์ฝ๋๋ ์ฌ๊ท ํจ์๋ฅผ ์ฌ์ฉํ์ฌ ์ ๋ ฅ๊ฐ a์ ํฉํ ๋ฆฌ์ผ์ ๊ณ์ฐํ๊ณ ์ถ๋ ฅํ๋ ์ฝ๋์ ๋๋ค.
15. ๋ค์ ์ค, ๊ดํธ ( ) ์์ ๋ค์ด๊ฐ ์ฐ์ฐ์๋ฅผ ์จ์ ์ ์๋ฅผ ์ญ์์ผ๋ก ์ถ๋ ฅํ๋ ์๋ง๋ ๋ต์ ์์ฑํ์์ค.
#include <stdio.h>
int main() {
int number = 1234;
int div = 10;
int result = 0;
while (number ( 1 ) 0) {
result = result * div;
result = result + number ( 2 ) div;
number = number ( 3 ) div;
}
printf("%d", result);
return 0;
}
1. >
2. %
3. /
#include <stdio.h>
int main() {
int number = 1234;
int div = 10;
int result = 0;
while (number > 0) {
result = result * div;
result = result + number % div;
number = number / div;
}
printf("%d", result);
return 0;
}
์ฃผ์ด์ง ์ฝ๋๋ ์ฃผ์ด์ง ์ ์ number๋ฅผ ๋ค์ง์ด์ ์ถ๋ ฅํ๋ ์ฝ๋์ ๋๋ค.
1๋ฒ ๋น์นธ์๋ ๋ถ๋ฑํธ๋ฅผ ์ฌ์ฉํ์ฌ >๋ฅผ ์จ์ผ ํฉ๋๋ค. ์ด๋ number๊ฐ 0๋ณด๋ค ํด ๋๊น์ง ๋ฐ๋ณตํ๊ฒ ๋ค๋ ์๋ฏธ์ ๋๋ค.
2๋ฒ ๋น์นธ์๋ ๋๋จธ์ง ์ฐ์ฐ์ %๋ฅผ ์ฌ์ฉํ์ฌ number๋ฅผ div๋ก ๋๋ ๋๋จธ์ง๋ฅผ ๊ตฌํด์ผ ํฉ๋๋ค. ์ด๋ number์ ์ผ์ ์๋ฆฌ ์๋ฅผ ๊ตฌํ ์ ์์ต๋๋ค.
3๋ฒ ๋น์นธ์๋ ์ ์ ๋๋์ ์ฐ์ฐ์ //๋ฅผ ์ฌ์ฉํ์ฌ number๋ฅผ div๋ก ๋๋ ๋ชซ์ ๊ตฌํด์ผ ํฉ๋๋ค. ์ด๋ number์ ์ผ์ ์๋ฆฌ ์๋ฅผ ์ ๊ฑฐํ ๋ค, ๋๋จธ์ง ์๋ฆฌ ์๋ค์ ๊ตฌํ ์ ์์ต๋๋ค.
6. ๋ค์ ์ค๋ช
์ ๋ํ ๋ต์ ์์ด ์ฝ์๋ก ์์ฑํ์์ค.
์ ๋ณด๋ณดํธ ๊ด๋ฆฌ์ฒด๊ณ์ ์๋ฌธ ์ฝ์
ISMS (Information Security Management System)
17. ๋ค์ ์ค๋ช
์ค, ๊ดํธ ( ) ์์ ๋ค์ด๊ฐ๋ ์๋ง๋ ๋ต์ ๋ณด๊ธฐ์์ ์ ํํ์ฌ ์์ฑํ์์ค.
(์ค์ ๊ธฐ์ถ๋ฌธ์ ์์๋ ๋ต์ ๋ณด๊ธฐ๊ฐ ์ฃผ์ด์ง๋๋ค.(์ค๋ต ์ค, ์ฐธ์กฐ์ฑ, ๋ฌด๊ฒฐ์ฑ ๋ฑ..))
1. ์ํผํค๋ ( 1 ) ์ ์์ฑ์ ๊ฐ๋๋ค.
2. ํ๋ณดํค๋ ( 1 ) ์/๊ณผ ( 2 ) ์ ์์ฑ์ ๊ฐ๋๋ค.
1. ์ ์ผ์ฑ
2. ์ต์์ฑ
18. ๋ค์ ์ค๋ช
๊ณผ ๊ด๋ จ๋ ๋ต์ ๋ณด๊ธฐ์ ์ฐพ์์ ์์ํ์์ค.
(์ค์ ๊ธฐ์ถ๋ฌธ์ ์์๋ ๋ต์ ๋ณด๊ธฐ๊ฐ ์ฃผ์ด์ง๋๋ค.(์ค๋ต ์ค, Pharming, Ransomware๋ฑ..))
์ด ๊ณต๊ฒฉ์ APT ๊ณต๊ฒฉ์์ ์ฃผ๋ก ์ฐ์ด๋ ๊ณต๊ฒฉ์ผ๋ก, ๊ณต๊ฒฉ ๋์์ด ๋ฐฉ๋ฌธํ ๊ฐ๋ฅ์ฑ์ด ์๋ ํฉ๋ฒ์ ์ธ ์น ์ฌ์ดํธ๋ฅผ ๋ฏธ๋ฆฌ ๊ฐ์ผ์ํจ ๋ค, ์ ๋ณตํ๊ณ ์๋ค๊ฐ ๊ณต๊ฒฉ ๋์์ด ๋ฐฉ๋ฌธํ๋ฉด ๋์์ ์ปดํจํฐ์ ์
์ฑ์ฝ๋๋ฅผ ์ค์นํ๋ ๋ฐฉ์
watering hole
19. ๋ค์ ์์ค์ฝ๋๊ฐ ์คํํ ๋์ ์ถ๋ ฅ๊ฐ์ ์์ฑํ์์ค.
#include <stdio.h>
int isPrime(int number) {
int i;
for (i=2; i<number; i++) {
if (number % i == 0) return 0;
}
return 1;
}
int main(void) {
int number = 13195, max_div=0, i;
for (i=2; i<number; i++)
if (isPrime(i) == 1 && number % i == 0) max_div = i;
printf("%d", max_div);
return 0;
}
์ ์ฝ๋๋ ์ฃผ์ด์ง number์ ์ต๋ ์์ธ์๋ฅผ ๊ตฌํ๋ ์ฝ๋์ ๋๋ค.
isPrime ํจ์๋ ์ ๋ ฅ๋ฐ์ number๊ฐ ์์์ธ์ง ์๋์ง๋ฅผ ํ๋ณํ์ฌ, ์์์ด๋ฉด 1์ ๋ฐํํ๊ณ ์๋๋ฉด 0์ ๋ฐํํฉ๋๋ค.
main ํจ์์์๋ 2๋ถํฐ number - 1๊น์ง์ ๋ชจ๋ ์์ ๋ํด isPrime ํจ์๋ฅผ ํธ์ถํ์ฌ ์์์ธ์ง ํ๋ณํฉ๋๋ค. ๊ทธ๋ฆฌ๊ณ ์ด ์ค์์ number์ ์ฝ์์ธ ์ ์ค์์ ๊ฐ์ฅ ํฐ ์์๋ฅผ max_div ๋ณ์์ ์ ์ฅํฉ๋๋ค. ๋ฐ๋ผ์, max_div์๋ number์ ์ต๋ ์์ธ์๊ฐ ์ ์ฅ๋ฉ๋๋ค.
์ฃผ์ด์ง ์ฝ๋์์ number ๋ณ์์๋ 13195๊ฐ ํ ๋น๋์ด ์์ต๋๋ค. ์ด ๊ฐ์ ์ต๋ ์์ธ์๋ฅผ ๊ตฌํ๋ ์ฝ๋์ด๋ฏ๋ก, ์ถ๋ ฅ๊ฐ์ 29๊ฐ ๋ฉ๋๋ค.
๋ฐ๋ผ์, ์ ์ฝ๋๋ฅผ ์คํํ๋ฉด 29๊ฐ ์ถ๋ ฅ๋ฉ๋๋ค.
20. ๋ค์์ V๋ชจ๋ธ์์์ ํ
์คํธ ๋จ๊ณ์ ๋ํ ์ค๋ช
์ผ๋ก ๊ดํธ์์ ๋ค์ด๊ฐ ๋ต์ ์์ฑํ์์ค.
1. ๋จ์ ํ
์คํธ
2. ํตํฉ ํ
์คํธ
3. ์์คํ
ํ
์คํธ
4. ์ธ์ ํ
์คํธ
'์๊ฒฉ์ฆ > ์ ๋ณด์ฒ๋ฆฌ๊ธฐ์ฌ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[์ ๋ณด์ฒ๋ฆฌ๊ธฐ์ฌ ์ค๊ธฐ] 2022๋ 3ํ ๊ธฐ์ถ๋ฌธ์ (0) | 2023.04.19 |
---|---|
[์ ๋ณด์ฒ๋ฆฌ๊ธฐ์ฌ ์ค๊ธฐ] 2022๋ 2ํ ๊ธฐ์ถ๋ฌธ์ (0) | 2023.04.18 |
[์ ๋ณด์ฒ๋ฆฌ๊ธฐ์ฌ ์ค๊ธฐ] 2021๋ 3ํ ๊ธฐ์ถ๋ฌธ์ (0) | 2023.04.16 |
[์ ๋ณด์ฒ๋ฆฌ๊ธฐ์ฌ ์ค๊ธฐ] 2021๋ 2ํ ๊ธฐ์ถ๋ฌธ์ (0) | 2023.04.15 |
[์ ๋ณด์ฒ๋ฆฌ๊ธฐ์ฌ ์ค๊ธฐ] 2021๋ 1ํ ๊ธฐ์ถ๋ฌธ์ (0) | 2023.04.14 |