[์ ๋ณด์ฒ๋ฆฌ๊ธฐ์ฌ] ์ค๊ธฐ _ ์ถ์ ์์ ๊ฐ๋ ์ ์ฒด ์์ ์ ๋ฆฌ 1
* 2020๋ 1~4ํ ๊ธฐ์ถ๋ฌธ์ ๋ฐ ํ๊ธฐ ๋ฌธ์ ๊ธฐ๋ฐ์ผ๋ก ์ถ์ ์์ ๊ฐ๋ ์ ๋ฆฌํ ๋ด์ฉ์ ๋๋ค.
โ 1. ๋ฐ๋ณต๋ฌธ (for / while - ๋ฒ์ ๋ฐ๋ณต)
# ๋ค์ ํ๋ก๊ทธ๋จ์ ์คํ ๊ฒฐ๊ณผ๋ฅผ ์ฐ์์ค.
# include <stdio.h>
void main()
{
int i = 0, c = 0;
while (i < 10) {
i++;
c *= i;
}
printf("%d", c);
}
๐ก i ๊ฐ 0๋ถํฐ i < 10 ์กฐ๊ฑด์ ๋ง์กฑํ๋ ๋์, while ๋ฌธ ์์ ๋ฌธ์ฅ์ ๋ฐ๋ณตํด์ ์คํ
i++ → i = i + 1
c *= i → c = c * i (๊ฒฐ๊ณผ์ ์ผ๋ก, 0 * 1 ์ ๊ฒฐ๊ณผ์ธ 0์ด ๋ค์ c๊ฐ ๋๋ค.)
while ๋ฌธ ์ฒ์์ผ๋ก ๋์๊ฐ์ i ๋ ํ์ฌ 1 ์ด๋ฏ๋ก while(i < 10) ์กฐ๊ฑด์ ๋ง์กฑํ๊ณ ๊ณ์ ์คํ๋๋ค.
i++ ์คํ ์, i =2 / c *= i ์คํ ์, c = 0 * 2 = 0
์ด๋ ๊ฒ while ๋ฌธ์์ i ๊ฐ 9๊น์ง๋ง ์คํํ๊ฒ ๋๊ณ ์๋ฌด๋ฆฌ ๊ณฑํด์ c๋ 0์ด ๋๋ค.
โ 2. ์ฐ์ ์ฐ์ฐ์
# ๋ค์ ํ๋ก๊ทธ๋จ์ ์คํ ๊ฒฐ๊ณผ๋ฅผ ์ฐ์์ค.
public class Exam{
public static void main(String[] args) {
int i = 3, k = 1;
switch(i) {
case 1: k++;
case 2: k += 3;
case 3: k = 0;
case 4: k += 3;
case 5: k -= 10;
default: k--;
}
System.out.print(k);
}
}
๐ก switch case ๋ฌธ์ switch(๊ฐ) ์ด ์์ ๋, ๊ทธ ๊ฐ์ ํด๋นํ๋ case ๋ฌธ์ ์คํ
But, case ๋ฌธ ๋ฐ๋ก ๋ค์ break; ๋ฅผ ๋ฃ์ด์ฃผ์ง ์๋๋ค๋ฉด ๋๊น์ง ์ํํ๊ฒ ๋๋ค.
์์ ๋ฌธ์ ์์ ์ด๊ธฐ๊ฐ i ๋ 3์ด์ฌ์, case 3 ๋ถํฐ default ๊น์ง ํ๋ฒ์ ์ํํ๊ธฐ ๋๋ฌธ์,
k ๊ฐ 0์ด ๋์๋ค๊ฐ +3์ ํ๋ค๊ฐ -1์ ํ์ผ๋ฏ๋ก ๋ต์ -8
โ 3. ๋ฐฐ์ด - ์ด์ฐจ์ ๋ฐฐ์ด
# ๋ค์ ํ๋ก๊ทธ๋จ์ ์ถ๋ ฅ ๊ฒฐ๊ณผ๊ฐ ๋์ค๊ธฐ ์ํ (1) (2) ์ ๊ฐ์ ์ฐ์์ค.
public class Exam{
public static void main(String[] args) {
int [][] array = new int[(1)][(2)];
int n = 1;
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 5; j++) {
array[i][j] = j*3 + (i+1);
System.out.print(array[i][j] + "");
}
System.out.println();
}
}
}
/* ์ถ๋ ฅ ๊ฒฐ๊ณผ */
1 4 7 10 13
2 5 8 11 14
3 6 9 12 15
๐ก '์ถ๋ ฅ ๊ฒฐ๊ณผ' ๊ฐ 3ํ 5์ด๋ก ๊ตฌ์ฑ๋์ด ์์ผ๋ฏ๋ก,
๋ต์ (1) 3, (2) 5
โ 4. ํฌ์ธํฐ - C์ธ์ด
# ๋ค์ ํ๋ก๊ทธ๋จ์ ์คํ ๊ฒฐ๊ณผ๋ฅผ ์ฐ์์ค.
int main() {
char *p = "KOREA";
printf("%s \n ", p);
printf("%s \n ", p+3);
printf("%c \n ", *p);
printf("%c \n ", *(p+3));
printf("%c ", *p+2);
}
๐ก %s - ๋ฌธ์์ด ์ถ๋ ฅ format (๋ฌธ์์ด ๋งจ ๋๊น์ง ์ถ๋ ฅ) ๐ pointer ์ง์ ํ์ (pointer์ *์ ๋ถ์ฌ์ ๊ทธ ๊ฐ์ ๊บผ๋)
%c - ๋ฌธ์ ์ถ๋ ฅ (ํ ๊ธ์๋ง ์ถ๋ ฅ) ๐ pointer ๊ฐ ์๋ ๊ฐ ์ง์ ํ์
๋ฌธ์์ด์ด๋ ๋ฐฐ์ด์ pointer๋ก ์ทจ๊ธ ์, ๊ทธ ์์น๋ ํญ์ ๊ฐ์ฅ ์ฒซ ๋ฒ์งธ๋ฅผ ๊ฐ๋ฆฌํค๊ฒ ๋๋ค.
(๋ฌธ์์ด - ๋งจ ์ ๊ธ์ / ๋ฐฐ์ด - 0๋ฒ์งธ ์ธ๋ฑ์ค)
printf("%s \n", p); ๐ ๋งจ ์ฒซ ๋ฌธ์๋ถํฐ ๋๊น์ง ๋ค ์ถ๋ ฅ # KOREA
printf("%s \n", p+3); ๐ ๋งจ ์ฒซ ๋ฌธ์๋ถํฐ 3์นธ ๋ค๋ถํฐ ๋๊น์ง ๋ค ์ถ๋ ฅ # EA
printf("%c \n", *p); ๐ ๋งจ ์ฒซ ๋ฌธ์ ์ถ๋ ฅ # K
printf("%c \n", *(p+3)); ๐ ๋งจ ์ฒซ ๋ฌธ์๋ถํฐ 3์นธ ๋ค๋ถํฐ ๋๊น์ง ๋ค ์ถ๋ ฅ # E
printf("%c ", *p+2); ๐ ๋งจ ์ฒซ ๋ฌธ์(K, ASCII CODE = 107) + 2, ์ํ๋ฒณ K์์ 2์นธ ๋ ๋ค๋ก #
โ 5. JAVA ์์ - ํด๋์ค / ๋ฉ์๋
# ๋ค์ ํ๋ก๊ทธ๋จ์ ์คํ ๊ฒฐ๊ณผ๋ฅผ ์ฐ์์ค.
abstract class Vehicle {
String name;
abstract public String getName(String val);
public Vehicle(String val) {
this.name = val;
}
public String getName() {
return “Vehicle name : “ + name;
}
}
class Car extends Vehicle {
public Car(String val) {
super(val); // name = super.name = val;
}
public String getName(String val) { // ์ค๋ฒ๋ผ์ด๋ฉ
return “Car name : “ + val;
}
public String getName(byte val[]) { // ์ค๋ฒ๋ก๋ฉ (์ด๋ฆ ๊ฐ๊ณ ํ์
๋ค๋ฆ)
return “Car name : ” + val;
}
}
public class Exam {
public static void main(String[] args) {
Vehicle obj = new Car(“Spark”);
System.out.println(obj.getName());
}
๐ก main ํจ์์์ new๋ฅผ ์ด์ฉํด์ ์์ฑํ ๋,
Vehicle obj = new Car("Spark") ์ด๋ฏ๋ก, class Vehicle ๋ก ๋ง๋ ๊ฒ์ ์ ์ ์๋ค.
Vehicle ํจ์์ return ๊ฐ์ธ “Vehicle name : “ + name; ํํ๋ก ์คํ๋๋ค.
๋ต์ Vehicle name : Spark
โ 6. Python ๋ฌธ๋ฒ
# ๋ค์ ํ๋ก๊ทธ๋จ์ ์คํ ๊ฒฐ๊ณผ๋ฅผ ์ฐ์์ค.
>> asia = {‘ํ๊ตญ’, ‘์ค๊ตญ’, ‘์ผ๋ณธ’}
>> asia.add(‘๋ฒ ํธ๋จ’)
>> asia.add(‘์ค๊ตญ’)
>> asia.remove(‘์ผ๋ณธ’)
>> asia.update([‘ํ์ฝฉ, ‘ํ๊ตญ’, ‘ํ๊ตญ])
>> print(asia)
๐ก {} ์์ ๊ฐ๋ค์ด ์์ผ๋ฏ๋ก Set ์๋ฃํ ๐ ์ค๋ณต ์์ด ๊ฐ๋ค์ ๋ฃ๋ ์๋ฃํ
asia.add(‘๋ฒ ํธ๋จ’) ๐ asia = {'ํ๊ตญ', '์ค๊ตญ', '์ผ๋ณธ'} ์์ ๋ฒ ํธ๋จ์ด ์ถ๊ฐ
asia.add(‘์ค๊ตญ’) ๐ asia = {'ํ๊ตญ', '์ค๊ตญ', '์ผ๋ณธ', '๋ฒ ํธ๋จ'} ์ ์ค๊ตญ์ด ์์ผ๋ฏ๋ก ์ค๋ณต
asia.remove(‘์ผ๋ณธ’) ๐ asia = {'ํ๊ตญ', '์ค๊ตญ', '๋ฒ ํธ๋จ'} * ์ผ๋ณธ์ด ์ญ์ ๋ ํํ
asia.update([‘ํ์ฝฉ, ‘ํ๊ตญ’, ‘ํ๊ตญ]) ๐ update ๋ก ์ฌ๋ฌ๊ฐ ๊ฐ์ ์ถ๊ฐ / ์ค๋ณต๋์ง ์๋ ๊ฐ์ธ ํ์ฝฉ, ํ๊ตญ์ด ์ถ๊ฐ
๋ต: {‘ํ๊ตญ’, ‘ํ์ฝฉ’, ‘๋ฒ ํธ๋จ’, ‘ํ๊ตญ’, ‘์ค๊ตญ’}
โ 7. Python ๋ฌธ๋ฒ
# ๋ค์ ํ๋ก๊ทธ๋จ์ ์คํ ๊ฒฐ๊ณผ๋ฅผ ์ฐ์์ค.
lol = [[1,2,3], [4,5], [6,7,8,9]]
print(lol[0])
print([2][1])
for sub in lol:
for item in sub:
print(item, end=" ")
print()
๐ก print() ํจ์ - ๊ธฐ๋ณธ์ ์ผ๋ก end (๋๋ถ๋ถ) ์ ์ํฐ๋ก ์น๊ฒ ๋์ด์์.
๋ฐ๋ผ์, end = " " ๋ก ๋ ๋ถ๋ถ์ ๋์ด์ฐ๊ธฐ๋ก ํ๊ฒ ๋ค๊ณ ์ง์ ํ์ฌ ์์ผ๋ก ์ด์ด์ ์๋ฃ ์ถ๋ ฅ๋๋๋ก ๋ง๋ ๋ค.
๋ต : [1, 2, 3]
7
1 2 3
4 5
6 7 8 9
โ 8. ์๊ตฌ์ฌํญ ๊ฐ๋ฐ ํ๋ก์ธ์ค ์์
๐ข ์์ ๋์ด ๋ฌธ์ ๋์ฌ ๊ฐ๋ฅ์ฑ ↑
[ ๋๋ถ๋ช ํ ]
๋์ถ (Elicitation) - ๋ถ์ (Analysis) - ๋ช ์ธ (Specification) - ํ์ธ (Validation)
โ 9. UML ๊ด๊ณ
๐ข ๋จ๋ตํ or ์ฝ์ ํ
ํ๊ธฐ์์ ์ข ์ข ๊ทธ๋ฆผ์ ์ฃผ๊ณ ์ด ๋์ ๊ด๊ณ๊ฐ ์ด๋ค ๊ด๊ณ์ธ์ง ๋ง์ถ๋๋ก ํ๋ ๋ฌธ์ ์ถ์ → ์ค๊ธฐ์์๋ ์ถ์ ๊ฐ๋ฅ
์ฐ๊ด (Association) ๊ด๊ณ / ์งํฉ (Aggregation) ๊ด๊ณ / ํฌํจ (Composition) ๊ด๊ณ / ์ผ๋ฐํ (Generalization) ๊ด๊ณ /
์์กด (Dependency) ๊ด๊ณ / ์ค์ฒดํ (Realization) ๊ด๊ณ
โ 10. ๊ตฌ์กฐ์ ๋ค์ด์ด๊ทธ๋จ
[ ํด๊ฐ์ปด๋ฐฐ๋ณตํจ ]
ํด๋์ค ๋ค์ด์ด๊ทธ๋จ / ๊ฐ์ฒด ๋ค์ด์ด๊ทธ๋จ / ์ปดํฌ๋ํธ ๋ค์ด์ด๊ทธ๋จ / ๋ฐฐ์น ๋ค์ด์ด๊ทธ๋จ /
๋ณตํฉ์ฒด ๊ตฌ์กฐ ๋ค์ด์ด๊ทธ๋จ / ํจํค์ง ๋ค์ด์ด๊ทธ๋จ
* ์๋ ๋ค์ด์ด๊ทธ๋จ์ ์ด๋ฆ์ ์ฐ์์ค
๋ต : ํด๋์ค ๋ค์ด์ด๊ทธ๋จ
** ํด๋์ค ๋ค์ด์ด๊ทธ๋จ (Class Diagram)
→ ํด๋์ค์ ์์ฑ, ํจ์, ๋ณ์ํ์ ๋ค๋ก ๊ตฌ์ฑ๋ ๋ค์ด์ด๊ทธ๋จ
โ 10 - 1. ๊ตฌ์กฐ์ ๋ค์ด์ด๊ทธ๋จ (ํจํค์ง ๋ค์ด์ด๊ทธ๋จ)
* ์๋ ๋ค์ด์ด๊ทธ๋จ์ ์ด๋ฆ์ ์ฐ์์ค
๋ต : ํจํค์ง ๋ค์ด์ด๊ทธ๋จ
** ํจํค์ง ๋ค์ด์ด๊ทธ๋จ (Package Diagram)
→ UML์ ๋ค์ํ ๋ชจ๋ธ์์๋ฅผ ๊ทธ๋ฃนํํ ๋ค์ด์ด๊ทธ๋จ
โ 10 - 2. ๊ตฌ์กฐ์ ๋ค์ด์ด๊ทธ๋จ (๋๋จธ์ง ๋ค์ด์ด๊ทธ๋จ ์ ๋ฆฌ)
** ๊ฐ์ฒด ๋ค์ด์ด๊ทธ๋จ (Object Diagram)
→ ํด๋์ค์ ์ธ์คํด์ค, ๊ฐ์ด ๋งค๊ฒจ์ง ํ๋์ ๊ฐ์ง๊ณ ์๋ ๋ ๋ฆฝ๋ ๊ฐ์ฒด์ ๋ณด๋ฅผ ํํํ๋ ๋ค์ด์ด๊ทธ๋จ
** ์ปดํฌ๋ํธ ๋ค์ด์ด๊ทธ๋จ (Component Diagram)
→ ์ปดํฌ๋ํธ๋ผ๋ฆฌ์ ๊ตฌ์กฐ ๊ด๊ณ๋ฅผ ํํํ๋ ๋ค์ด์ด๊ทธ๋จ
** ๋ฐฐ์น ๋ค์ด์ด๊ทธ๋จ (Deployment Diagram)
→ ์ํํธ์จ์ด, ํ๋์จ์ด ๋ฑ์ ํฌํจํ ์์คํ ์ ๋ฌผ๋ฆฌ์ ์ธ ๊ตฌ์กฐ๋ฅผ ๋ํ๋ด๋ ๋ค์ด์ด๊ทธ๋จ