• k층 n호에 살고 있는 사람의 수 구하기
• a층 b호에 사는 사람은, a-1층의 1호부터 b호까지의 사람들의 수의 합

가능한 시간복잡도

K층의 N번째 사람 수를 구할 때 까지 총 O(K) * O(N)번의 연산이 필요. K와 N 모두 최대 14이고, 최대 연산수는 196 시간제한 : 0.5

알고리즘 선택

DP : 앞에 계산해 놓은 값을 재활용해 뒤의 문제의 답을 구하는 방식

📌 풀이하기

1. a층 b호 사람은 (a층 b-1호의 사람) + (a-1층 b호의 사람)
2. 관계식 구하기 dp[b] += dp[b-1]

📌 코드 설계하기

1. 문제의 input을 받는다.
2. 가장 작은 문제의 답, 0번째 층의 사람 수를 기록한다.
3. 설계한 관계식에 맞게 DP 탐색을 진행한다.

📌 시도 회차 수정 사항 (Optional)

📌 정답 코드

import sys

T = int(sys.stdin.readline())

for _ in range(T):
    K = int(sys.stdin.readline()) # 층
    N = int(sys.stdin.readline()) # 호

    # 0번째 층의 사람수
    DP = [i for i in range(1, N+1)]

    for a in range(K):
        for b in range(1, N):
            DP[b] += DP[b-1]

    print(DP[N - 1])

• 피보나치 수는 0과 1로 시작
• Fn = Fn-1 + Fn-2
• 즉, n = 10이면 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55
• N번째 피보나치 수를 구하기

가능한 시간복잡도

N번째 피보나치 수를 구할 때 까지 N번의 연산이 필요. 따라서 O(N)이 되고, N은 최대 90개 이기 때문에 1초의 시간안에 연산 가능.

알고리즘 선택

DP : 앞에 계산해 놓은 값을 재활용해 뒤의 문제의 답을 구하는 방식

📌 풀이하기

• DP 관계식 구하기 dp[N] = dp[n-1] + dp[n-2]

📌 코드 설계하기

1. 문제의 input을 받는다.
2. 가장 작은 문제의 답(피보나치 0,1번째 수)를 먼저 구한다.
3. DP 관계식을 구현하고, N번 째 수까지의 답을 순차적으로 탐색한다.

📌 시도 회차 수정 사항 (Optional)

📌 정답 코드

# 백준 2578
import sys

n = int(sys.stdin.readline())

dp = []
dp.append(0)
dp.append(1)

for i in range(2, n+1):
    dp.append(dp[i-2] + dp[i-1])

print(dp[n])

• 5 * 5 크기의 빙고판 입력
• 그 후 사회자가 불러주는 숫자가 5 * 5 배열로 입력
• 사회자가 숫자를 부른 후, 빙고판에서 빙고가 몇개 완성되었는지 확인
• 완성된 빙고가 3개 이상이라면 부른 숫자가 몇번째 숫자인지 출력

가능한 시간복잡도

시간 제한 : 1초 사회자는 총 25개의 숫자를 부르고, 빙고판에서 어느 위치에 숫자가 존재하는지 확인하는데도 총 25개의 비교연산이 필요하므로, 25 * 25 = 약 625개의 연산 필요

알고리즘 선택

시뮬레이션, 구현

📌 풀이하기

1. 사회자가 부른 숫자를 빙고판에 체크하기

   • 5 * 5 2차원 빙고판을 만들어두고, False 또는 0으로 마킹

   • 빙고판을 모두 탐색하며 사회자가 부른 숫자와 일치하면 True 또는 1로 마킹

     사회자는 총 25개의 숫자를 부르고, 빙고판에서 어느 위치에 숫자가 존재하는지 확인하는데도 총 25개의 비교연산이 필요하므로, 25 * 25 = 약 625개의 연산 필요 => 1초 안에 가능

2. 현재까지 완성된 빙고의 개수 확인하기 빙고는 총 가로 5개, 세로 5개, 대각선 2개 존재

   1. 가로 빙고
   • 가로 빙고는 i번째 행에 대해 [i][0], [i][1], ..., [i][4]가 모두 마킹된(True)인지 확인
   • 5개 행에 대해 모두 확인 필요
   2. 세로 빙고
   • 세로 빙고는 i번째 행에 대해 [0][i], [1][i], ...,[4][i]가 모두 True인지 확인
   • 5개 열에 대해 모두 확인 필요
   3. 대각선 빙고
   • 대각선의 경우 /모양과 \모양이 있다. \모양은 [i][i], /모양은 [i][4-i]

     사회자가 숫자를 부른 후, 현재까지 완성된 빙고의 개수를 확인하는데 걸리는 연산 개수 빙고는 총 가로 5개, 세로 5개, 대각선 2개가 존재하고 빙고 1줄당 총 5개의 비교연산이 필요하므로, 총 12 * 5 = 60번의 비교연산이 필요 사회자가 최대 25개의 숫자를 부를 수 있으므로, 최악의 경우 25 * 60 == 1500개의 연산 필요 => 1초 안에 가능

📌 코드 설계하기

1. 문제의 input을 받는다.
2. 빙고판을 초기화한다.
3. 빙고의 개수를 구할 수 있는 함수를 구현한다. (행, 열, 대각선)
4. 사회자가 부르는 각 수에 대해 빙고판을 True로 체크하고 만족하는 빙고의 수를 확인한다.
5. 완성된 빙고의 수가 3개 이상인지 확인하고, 정답을 출력한다.

📌 시도 회차 수정 사항 (Optional)

📌 정답 코드

import sys

# 백준 2578

# 1. 빙고판 입력 받기
arr = []
for _ in range(5):
    arr.append(sys.stdin.readline().split())


# 2. 사회자가 부르는 수 list 담기
num = []
for _ in range(5):
    list = sys.stdin.readline().split()

    for i in list:
        num.append(i)

# 3. 빙고판 초기화
check_board = [[False for _ in range(5)] for _ in range(5)]

# 4. 빙고 수를 체크할 수 있는 함수
def check_row_bingo():
    count = 0
    for i in range(5):
        is_bingo = True
        for j in range(5):
            if not check_board[i][j]:
                is_bingo = False
                break
        if is_bingo:
            count += 1
    return count

# 5. 빙고 column 수를 확인하기 위한 함수 구현
def check_column_bingo():
    count = 0
    for j in range(5):
        is_bingo = True
        for i in range(5):
            if not check_board[i][j]:
                is_bingo = False
                break
        if is_bingo:
            count += 1
    return count

# 6. 대각선 빙고 수 확인하기 위한 함수 구현
def check_diagonal_bingo():
    count = 0
    # \ 모양 대각선
    is_bingo = True
    for i in range(5):
        if not check_board[i][i]:
            is_bingo = False
            break
    if is_bingo:
        count += 1

    # / 모양 대각선
    is_bingo = True
    for i in range(5):
        if not check_board[i][4 - i]:
            is_bingo = False
            break
    if is_bingo:
        count += 1

    return count


# 7. 사회자가 부르는 각 수에 대해 빙고판을 True로 체크하고,
#    만족하는 빙고의 수를 확인
for i in range(25):
    now_num = num[i]
    # 사회자가 부른 숫자의 빙고판 위치 확인하고 True로 표기
    for x in range(5):
        for y in range(5):
            if arr[x][y] == now_num:
                check_board[x][y] = True
    # 빙고판 True로 체크한 이후 빙고 몇개 완성됐는지 확인
    count = check_row_bingo() + check_column_bingo() + check_diagonal_bingo()
    # 완성된 빙고의 개수가 3개 이상이라면 해당 순서 출력
    if count >= 3:
        print(i + 1)
        break

• 몸무게 x, 키 y -> (x, y)
• 덩치는 x와 y 모두 커야 덩치 큰 것
• x만 크거나 y만 큰 건 공동 순위

가능한 시간복잡도

시간 제한 : 1초 2 ≤ N ≤ 50

• N이 크지 않기 때문에 이중for문을 사용하여 O(N^2)

알고리즘 선택

브루트포스

📌 코드 설계하기

1. 문제의 input 받기
2. list[0]과 list[1] 모두 큰 1등 덩치와 꼴등 덩치 먼저 구하기
3. 나머지는 공동 순위
4. 순위 출력

📌 시도 회차 수정 사항 (Optional)

📌 정답 코드

N = int(input())
people = [tuple(map(int, input().split())) for _ in range(N)]
# 덩치 등수
ranks = [1] * N

for i in range(N):
    for j in range(N):
        if i != j:
            if people[i][0] < people[j][0] and people[i][1] < people[j][1]:
                ranks[i] += 1

print(*ranks, sep=" ")

• 1~5 숫자 나무조각을 오름차순으로 정렬
• 입력 받은 순서에서 오름차순으로 정렬되는 과정 출력
  • 첫번째 조각 > 두번째 조각 -> swap
  • 두번째 조각 > 세번째 조각 -> swap
  • 세번째 조각 > 네번째 조각 -> swap
  • 네번째 조각 > 다섯번째 조각 -> swap
  • 1,2,3,4,5가 아니라면 다시 반복
    • 단, swap 될 때만 출력

가능한 시간복잡도

시간 제한 : 1초

이중 for문의 시간복잡도는 O(N^2) -> N이 매우 클 경우 효율적인 알고리즘은 아니지만, N은 5로 작으므로 괜찮다.

알고리즘 선택

버블 정렬

📌 코드 설계하기

1. 문제의 input 받기
2. 이중 for 문으로 인접한 두 수를 비교해서 앞에 수가 뒤에 수보다 크면 교환 후 리스트 출력 -> 정렬이 완료될 때까지 반복(N:5번)

📌 시도 회차 수정 사항 (Optional)

📌 정답 코드

import sys

# arr = list(map(int, sys.stdin.readline().strip().split()))
arr = [int(x) for x in sys.stdin.readline().strip().split()]

for i in range(5):
    for j in range(5-i-1):
        if(arr[j+1] < arr[j]):
            arr[j+1], arr[j] = arr[j], arr[j+1]
            print(*arr, sep=" ")

• 응시생 N명 / 수상 인원 K명
• 점수가 가장 높은 K명 중 점수가 가장 낮은 사람의 점수
• 즉, 상을 받는 커트라인 출력

가능한 시간복잡도

시간 제한 : 1초 1 ≤ N ≤ 1000

sort() 메소드의 시간복잡도는 O(NlogN)

알고리즘 선택

정렬

📌 코드 설계하기

1. 문제의 input 받기
2. 조건에 맞게 정렬
   • 점수를 내림차순으로 정렬
3. 출력
   • K-1번째 리스트 요소 출력

📌 시도 회차 수정 사항 (Optional)

1회차

• import sys 를 빼먹어서 런타임 에러가 났다

📌 정답 코드

import sys

N, K = map(int, sys.stdin.readline().strip().split())
arr = list(map(int,sys.stdin.readline().strip().split()))

arr.sort(reverse=True)
print(arr[K-1])

• 주어진 생년월일로
• 가장 나이가 적은 사람과 가장 많은 사람 구하기
• 연도가 같으면 생일로 구분!

가능한 시간복잡도

시간 제한 : 1초 1 ≤ N ≤ 100

sort() 메소드의 시간복잡도는 O(NlogN)

알고리즘 선택

정렬

📌 코드 설계하기

1. 문제의 input 받기
2. 조건에 맞게 정렬
   • yyyy(연도) 오름차순
   • mm(월) 오름차순
   • dd(일) 오름차순
3. 출력
   • 가장 나이가 적은 사람의 이름
   • 가장 나이가 많은 사람의 이름

📌 시도 회차 수정 사항 (Optional)

📌 정답 코드

import sys

N = int(sys.stdin.readline())
arr = []

for i in range(N):
    name, dd, mm, yyyy = sys.stdin.readline().strip().split()
    arr.append([name, int(dd), int(mm), int(yyyy)])

# 정렬
arr.sort(key=lambda x: (x[3], x[2], x[1]))

print(arr[N-1][0])
print(arr[0][0])

• 람다식 이용

import sys

N = int(sys.stdin.readline())
arr = []

for i in range(N):
    name, dd, mm, yyyy = sys.stdin.readline().strip().split()
    arr.append([int(yyyy), int(mm), int(dd), name])

# 정렬
arr.sort()

print(arr[N-1][0])
print(arr[0][0])

• 리스트 저장 순서를 바꿔서 sort() 자체로 정렬
• 이름이 같거나, 생일이 같은 사람은 없다는 조건 !

• 정렬 조건
  1. 길이 오름차순 2. 사전 오름차순
• 중복된 단어는 제거!

가능한 시간복잡도

시간 제한 : 2초 1 ≤ N ≤ 20,000

입력 처리: O(N) 중복 제거: O(N) (set을 사용한 중복 제거) 정렬: O(N log N) (Timsort 정렬) 출력: O(N) => O(N log N) = 약 80,000만 => 적합

알고리즘 선택

파이썬의 내장 정렬 함수인 sort()는 Timsort 알고리즘을 사용한다. Timsort는 합병 정렬과 삽입 정렬의 장점을 결합한 알고리즘으로, 최악의 경우 시간 복잡도는 *O(N log N)

📌 코드 설계하기

1. 문제의 input 받기
2. 중복 제거
   • set 활용
3. 조건에 맞게 정렬 (1. 길이 오름차순 2. 사전 오름차순)
   • 람다식 활용
4. 출력

📌 시도 회차 수정 사항 (Optional)

1회차

import sys

# 1. input 받기
N = int(sys.stdin.readline())
arr = []
for _ in range(N):
    arr.append(sys.stdin.readline())

# 2. 중복 제거
unique = list(set(arr)) 

# 3. 정렬
unique.sort(key=lambda x: (len(x), x))

# 4. 출력
for u in unique:
    print(u)

# print(*unique, sep="\n")

• sys.stdin.readline() 를 사용했더니 출력에 개행이 한 줄씩 더 들어가 있어서 출력 형식이 다르다고 떴다.
• sys.stdin.readline()는 입출력은 빠르지만, 줄바꿈 문자를 포함하여 출력이 다르게 나올 수 있다. -> strip()을 사용하여 공백, 개행문자 제거하거나 input() 사용하기!

📌 정답 코드

# 1. input 받기
N = int(input())
arr = []
for _ in range(N):
    arr.append(input())

# 2. 중복 제거
unique = list(set(arr)) 

# 3. 정렬
unique.sort(key=lambda x: (len(x), x))

# 4. 출력
print(*unique, sep="\n")

• 회원의 나이와 이름을 정렬하여 출력
  • 나이가 증가하는 순
  • 나이가 같으면 먼저 가입한 순

가능한 시간복잡도

정렬의 시간 복잡도는 O(NlogN) N은 회원의 수로, 최대 100,000

알고리즘 선택

정렬

📌 코드 설계하기

1. 문제의 input 받기
2. 배열을 1열을 기준으로 1열의 값이 같을 경우 입력 순서 유지되도록 정렬

   arr.sort(key=lambda x: (x[0]))

3. 정렬한 배열을 출력

📌 시도 회차 수정 사항 (Optional)

1회차

• python 문법이 많이 부족하다..
• 2차원 배열과 같은 자료형

📌 정답 코드

import sys

# 1. 문제의 입출력을 받습니다.
N = int(sys.stdin.readline())
arr = []
for _ in range(N):
    age, name = sys.stdin.readline().split()
    arr.append([int(age), name])

# 2. 2차원 배열을 정렬합니다. 이 때 1열의 값이 같을 경우, 2열의 정렬 순서는 배열의 원래 순서 유지
arr.sort(key=lambda x: (x[0]))
for i in arr:
    print(i[0], i[1])

• 빅-오메가 : 최선일 때

• 빅-세타 : 보통일 때
• 📍 빅-오 O(n) : 최악일 때

import random
findNumber = random.randrange(1,101) # 1~100 사이 랜덤값 생성

for i in range(1, 101):
    if i == findNumber:
        print(i)
        break
# 빅-오메가 : 시간복잡도 1번
# 빅-세타 : 시간복잡도 N/2번 = 50번
# 빅-오 : 시간복잡도 N번 = 100번

코딩테스트에서는 빅-오 표기법(O(n)) 기준으로 수행 시간 계산하는 것이 좋다.

빅-오 표기법 O(n)

수 정렬하기 예제

• 데이터의 크기와 시간 제한 항상 고려!
• 1 <= N <=** 1,000,000**
• 최악의 케이스를 고려해야 하기 때문에
  • 데이터 크기(N)는 1,000,000값
  • 시간 제한은 1초에 2,000만번이므로, 2초에 40,000,000 번 이하의 연산 횟수로 문제 해야해야 함
• 즉, 연산 횟수 = 알고리즘 시간 복잡도 n값에 데이터의 최대 크기를 대입하여 도출
• 코딩테스트에서는 약 2,000만 번 ~ 1억 번의 연산이 대략 1초 정도 걸리나 최악의 케이스로 2,000만 번으로 기준!

시간복잡도 예제

• 버블 정렬 시간복잡도 공식 = O(N제곱) = 1,000,000 * 1,000,000 = 1,000,000,000,000 > 40,000,000 => 부적합 알고리즘
• 병합 정렬 시간복잡도 공식 = O(nlogn) = 1,000,000 * log2(1,000,000) = 약 20,000,000 < 40,000,000 => 적합 알고리즘 ** log2(1,000,000) = 20

연산 횟수는 1초에 2,000만 번 기준 시간 복잡도는 항상 최악, 즉 데이터의 크기가 가장 클 때를 기준

시간 복잡도 도출 기준

1. 상수는 시간 복잡도 계산에 제외한다.

• 연산 횟수 = N

  N = 100000
  cnt = 1
  

for i in range(N): print("연산횟수" + str(cnt)) cnt += 1

- 연산 횟수 = 3N
```python
N = 100000
cnt = 1

for i in range(N):
    print("연산횟수" + str(cnt))
    cnt += 1

for i in range(N):
    print("연산횟수" + str(cnt))
    cnt += 1

for i in range(N):
    print("연산횟수" + str(cnt))
    cnt += 1

위 두 코드는 같은 시간복잡도를 갖는다. 3N의 상수인 3을 무시하는 O(n)으로 같다.

2. 가장 많이 중첩된 반복문의 수행 횟수가 시간 복잡도의 기준이 된다.

• 연산 횟수 = N2(제곱)

  for i in range(N):
    for j in range(N):
        print("연산 횟수 " + str(cnt))
        cnt += 1

• 9명의 난쟁이 중 키의 합이 100이 되는 7명의 난쟁이를 구하는 문제
• 0 < 키 <= 100 자연수
• 출력은 키 합이 100인 난쟁이 7명 조합 아무거나 단, 오름차순 정렬

가능한 시간복잡도

(이 부분은 조금 더 공부하겠습니다😭)

알고리즘 선택

📍 해설지 참고

• 브루트포스 알고리즘(완전탐색/전체탐색)
• 정렬

📌 코드 설계하기

1. 문제의 input 받아 변수에 저장 (list 사용)
2. 9명의 난쟁이 중 7명의 난쟁이 선택 후 합이 100인지 확인
3. 합이 100이면 list 오름차순 정렬
4. 출력

📍 해설지 참고 후 2번 수정 -> 9명의 난쟁이 중 제외할 2명 구해서 9명 키 합 - 제외할 2명 키 == 100인지 확인

📌 시도 회차 수정 사항 (Optional)

1회차

## 리스트
heights = []
for i in range(9):
    heights.append(int(input()))

total_sum = 0
for i in range(10):
   result = heights[i : i + 7]
   total_sum = sum(result)

   print(f"i : {i} \n result : {result} \n sum : {total_sum}\n")

   if total_sum == 100:
     result.sort()
     print(result)

• 리스트에서 7명을 뽑아내 합을 구한 후 100이 넘는지 체크하는 로직으로 구성했다
• print 해보니 i가 커질수록 끝값이 인덱스에서 벗어나서 리스트에 7개 미만으로 들어왔다..

2회차

import itertools

## 리스트
heights = []
for i in range(9):
    heights.append(int(input()))

total_sum = 0
result = list(itertools.combinations(heights, 7))

for r in result:
    total_sum = sum(r)

    if total_sum == 100:
        sorted_r = sorted(r)
        print(sorted_r)
        break

• heights 리스트에서 7개의 모든 조합을 찾기 위해 구글링..

itertools.combinations(리스트, r):

• 이 함수는 주어진 리스트에서 r개의 요소를 뽑는 모든 조합을 반환
• combinations 객체는 반복자(iterator)이기 때문에, 리스트로 변환하거나 for문으로 순회하여 사용!!!
• import itertools 필요

r.sort()는 튜플에서는 사용할 수 없기 때문에 sorted()로 처리!!

3회차

📍 해설지 참고

• 9명의 난쟁이 중 7명을 선택(완전 탐색)하는 것이 아니라, 9명의 난쟁이 중 제외할 2명의 난쟁이를 선택
  • 생각의 전환 필요!!!
• 2명의 난쟁이를 따로 뽑을 필요없이, 이중 for문으로 제외한 두명의 키를 9명 전체 합에서 뺐을 때, 100을 만족하는지 확인

완전 탐색은 input의 크기가 유난히 작으면서 모든 경우의 수를 탐색하는 코드 구현이 가능할 경우에! 모든 경우의 수를 빠뜨리지 않고 탐색할 수 있게 구현하는 것이 중요

📌 정답 코드

import sys 
def print_result(arr, a, b):
    for i in range(9):
        if i == a or i == b:
            continue
        print(arr[i])

# 1. input 받기
heights = []
for i in range(9):
    heights.append(int(sys.stdin.readline())) # import sys 필요
    # heights.append(int(input()))

# 2. 아홉 난쟁이 키의 합 미리 구해두기
total_sum = sum(heights)
# 3. 미리 정렬
heights.sort()

# 4. 9명 중 2명을 제외하는 모든 경우의 수를 탐색하는 for loop 구현
found = False
for i in range(9):
    if found:
        break
    for j in range(i + 1, 9):
        # 5. 제외된 2명을 빼고 총 합이 100인지 확인
        now = total_sum - heights[i] - heights[j]

        # 6. 100이면 출력, for loop 탈출  
        if now == 100:
            print_result(heights, i, j)
            found = True
            break

sys.stdin.readline()을 왜 사용하나요? → 빠른 입출력을 위해 사용합니다. input()과 정확히 동일한 역할을 하지만 더 빠른 입출력을 지원!

📌 부족한 점

• 알고리즘 기법에 대한 이해가 없어서 설계가 너무 부족하다..
• 완전탐색(브루트 포스) 이론 공부하고 관련 문제 3개 더 풀자
• 문제를 보는 시선의 전환 또한 필요하다.. 이것도 많이 풀어보면 늘겠지...?

설치 후, 터미널에 brew -v 명령어를 입력하여 버전 정보가 나오면 된다.

> brew -v
Homebrew 4.0.24

2. MySQL 설치

$ brew install mysql

• MySQL 시작

$ mysql.server start

• MySQL 시작 후 기본 설정

$ mysql_secure_installation

순서대로 아래 질문들이 나오면 y 또는 n을 입력하여 설정해 준다.

1. 비밀번호 복잡도 검사 과정 (n)
2. 비밀번호 입력 & 확인
3. 익명 사용자 삭제 (y)
4. 원격 접속 허용하지 않을 것인가? (y)
5. test DB 삭제 (n)
6. previlege 테이블을 다시 로드할 것인지 (y)

-> 설정을 마치면 All done! 메세지가 출력됩니다.

3. 사용하기

bash에 다음 명령어를 입력하면 MySQL을 사용할 수 있다.

$ mysql -u root -p 
또는
$ mysql -u root -p비밀번호 -> 바로 접속

추가설정

MySQL 서버가 재부팅 상관없이 켜져있게 한다. (bash에 입력)

$ brew services start mysql

• 데이터베이스(DB)를 관리하는 시스템
  • DB : 테이블들이 모여 이루는 데이터 단위
• 데이터를 저장하고 유지보수(수정,삭제,추가)하고 이를 검색하는 시스템
  • CRUD
• 대량의 데이터를 처리하는 시스템
• 다양한 자료구조와 검색구조(정렬, 인덱싱, …) 사용해 빠른 검색 가능
• 대부분의 시스템은 R(검색) >>>>> CUD(업데이트)의 빈도수가 많음
• 검색에 최적화
  • 쓰기에 최적화된 시스템은 NoSQL 계열

RDBMS 관계형 데이터베이스 시스템

• 테이블 기반의 DBMS

  • 테이블/컬럼 형태의 데이터 저장 방식
    • 하나의 테이블은 여러 개의 컬럼으로 구성
  • 테이블과 테이블 간의 연관관계(주로 외래키 형태)를 이용해 필요한 정보를 구하는 방식
  • 테이블끼리의 중복정보는 최소화 → 정규화

• 모델링은 E-R(Entity Relationship) 모델을 사용

• 테이블을 엔티티(기본)와 릴레이션 테이블로 구분하는 방식

• 데이터의 검색을 빠르게 하기 위해서 데이터를 변경(추가/업데이트/삭제)할 때 인덱스를 미리 만들어서 데이터의 검색을 빨리 되도록 함

• 하지만, 데이터의 변경이 많을 경우에는 인덱스 때문에 오히려 성능이 떨어지기도 한다

정렬

• 빠른 검색을 위해서는 데이터가 반드시 정렬(Sorting)되어 있어야 함
• 정렬 되어 있지 않다면 평균적으로 전체 데이터의 절반 필요
  • 최선 : 1, 최악 : N, 평균 : N/2
• 정렬되어 있을 경우 데이터를 빠른 시간 안에 찾을 수 있음
  • O(NlogN)-O(N2)
• 퀵정렬/힙정렬 계열이 주로 사용됨

인덱스

• 이진검색(Binary Search)
  • 최대 log2(N)번 내에 검색 가능
  • 데이터를 정렬 후 “test” 단어를 검색하는 경우
    • 한가운데 값을 확인 → “sample” → 뒤쪽 절반
    • 뒤쪽 중 한가운데 확인 → “yield” → 앞쪽 절반
    • 계속 반복해 “test” 단어가 나올 때까지 계속
• 🌟 B-Tree 계열 → DBMS의 인덱스 기본!
  • 사용 DBMS에서 가장 일반적으로 많이 사용됨
  • 이진 검색과 유사하지만 한 번에 비교를 2번 (a,b : a <b)
    • 작은 값보다 작은 경우 ( x < a )
    • 큰 값과 작은 값 사이인 경우 ( a < x < b )
    • 큰 값보다 큰 경우 ( x > b )
    • B-트리 계열이 이진검색 계열보다 빠름
    • 데이터가 추가/삭제/변경 될 때마다 a,b 값을 업데이트

⇒ 데이터 추가/수정/삭제할 때마다 정렬/인덱스 업데이트가 일어남

1. 기존 이미지로 컨테이너 생성 후 작업 완료된 컨테이너를 다시 이미지로 생성

2. Dockerfile로 필요한 패키지, 소스코드, 명령어 등을 작성 후 빌드

📄 Dockerfile

• 도커 이미지를 생성할 수 있는 설정 파일
• 사용자가 이미지를 조합하기 위해 명령줄에서 호출할 수 있는 모든 명령을 포함하는 텍스트 문서
• 완성된 이미지를 생성하기 위해 필요한 컨테이너, 패키지, 소스코드, 명령어 등을 하나의 파일에 기록
• 도커에서 이 파일을 읽어 자동으로 작업을 수행한 뒤 완성된 이미지로 만들어 줌
• 깃과 같은 개발도구를 통해 애플리케이션의 빌드 및 배포를 자동화 할 수 있음

📍 Dockerfile 작성

• 컨테이너에서 수행해야 할 작업을 명시
• 정해진 형식과 명령어로 작성해야 함
• 문서 파일로 작성
• 한 줄에 하나의 명령어로 구성
• 명령어를 명시하고 뒤에 옵션을 추가
• 명령어는 대/소문자 상관없음(일반적으로 대문자로 표기)
• 위에서 아래로 한 줄씩 차례대로 실행됨
• 주석은 #기호를 사용

🌟 Dockerfile 명령어

ex)

# 베이스 이미지를 tomcat:9.0.75-jdk11로 지정
FROM tomcat:9.0.75-jdk11
# 작성자 라벨 생성
LABEL maintainer "kh<kh@iei.com>"
# 버전 라벨 생성
LABEL version="1.0"
# /usr/local/tomcat/webapps 디렉터리에 ROOT.war 파일 추가
ADD ROOT.war /usr/local/tomcat/webapps
# Timezone 환경변수를 Asia/Seoul로 변경
ENV TZ=Asia/Seoul
# 이미지에서 8080포트 사용
EXPOSE 8080
# 컨테이너 실행 시 catalina.sh 파일 자동 실행
CMD ["catalina.sh","run"]

🌟 Dockerfile 빌드

작성한 Dockerfile을 이용해 이미지를 생성하는 과정

docker build [옵션] <Dockerfile이 존재하는 디렉터리 경로>
docker build . -f Dockerfile.txt -t mytomcat:1.0

수업을 하면서 gui docker desktop으로 컨테이너나 이미지를 확인하는데 이미 설치되어있던 oracle이 컨테이너에 뜨지 않는 것이다.. 하지만 DB는 잘 작동하고 cli로 docker ps로 확인해봐도 잘 작동하고 있었다. 그래서 찾아본 결과 docker context가 colima, desktop-linux, default로 3개이고 내가 설치한 oracle은 colima에 설치되어 있었고, desktop-linux가 docker desktop 부분인 것 같았다. (그럼 여기서 default는..??)

mac은 colima를 이용해서 이미지를 x86_64로 바꿔 ORACLE을 돌려야 한다는 걸 알았지만, 혹시나 하는 마음에 docker desktop에서 설치해보았다.

docker run -d --name mydb -p 40000:1521 -e TZ=Asia/Seoul oracleinanutshell/oracle-xe-11g

docker ps -a

docker cp /Users/sujinchoi/mydb.sql mydb:/root

docker exec -it mydb bash

→ root@48ddec31a221:/# ls

→ root@48ddec31a221:/# ls / root

→ root@48ddec31a221:/# sqlplus sys/oracle as sysdba @/root/mydb.sql

docker run -d --name myweb -p 80:8080 -e TZ=Asia/Seoul --link mydb:db tomcat:9.0.75-jdk11

docker cp /Users/sujinchoi/ROOT.war myweb:/usr/local/tomcat/webapps

docker restart myweb

sql에서 넘어가지지 않는다.

안되는 걸 알았지만 이렇게 어떤 과정에서 안되는지 확인해보니 좋았다. 게다가 docker를 공부하는 과정에서 docker desktop gui로 확인하면서 파일이 제대로 복사되었는지 확인할 수 있어서 좋았는데,,, 앞으로 수업 실습을 할 때는 colima 상에서 돌려야 하기 때문에 확인을 할 수 없을 부분이 막막하다..

• 애플리케이션을 개발/배포/실행하기 위한 플랫폼!
• 컨테이너를 사용하여 애플리케이션 및 지원 구성 요소를 개발
• 리눅스 자체 기능을 사용하여 프로세스 단위의 격리 환경을 제공
• 배포 용량과 시간을 단축하고, 성능 손실을 최소화시킴

도커 엔진

• 외부에서 Docker API 요청을 받아 Docker 객체와 서비스들을 관리
• 컨테이너를 생성하고 관리하는 주체
• 도커 데몬(demon) : 도커 프로세스가 실행되어 입력받을 준비가 된 상태
• 도커 클라이언트 : 입력된 명령어를 Docker API 형태로 도커 데몬에게 전달 (-> 도커 엔진의 수행 결과를 반환받아 사용자에게 출력)
• 도커 레지스트리(Registry): 도커에서 사용되는 이미지들을 저장하고 공유해주는 원격 저장소

☑️ 도커 이미지 관리

🌟 도커 이미지

• 컨테이너를 만들고 실행하기 위한 읽기 전용 파일(템플릿)
• 모든 컨테이너는 이미지 기반으로 생성됨
• 컨테이너 실행에 필요한 파일과 설정 값 등을 포함하고 있음

<검색 방법>

1. 도커 허브에서 이미지 검색
2. 📍 docker search <키워드>

<이미지 다운로드> 📍 docker pull [저장소이름/]<이미지이름>[:태그] ex) docker pull tomcat:9.0

• 저장소 이름 생략 시 도커 허브 공식 이미지로 인식
• 태그는 버전을 나타냄 (생략시 최신 버전 latest 으로 인식)

🌟 도커 이미지와 컨테이너

• 컨테이너는 필요한 파일과 설정을 이미지에서 읽기전용으로 가져다 사용하고, 변경된 사항만 컨테이너 계층에 별도 저장
• 하나의 이미지로 여러 컨테이너에서 사용 가능

• 다운받은 이미지 목록 조회 📍 docker images

• 이미지 세부 정보 조회 📍 docker image insepect <이미지 ID>

• 도커 이미지 추출 : 도커 이미지를 별도의 파일로 저장할 때 사용 📍 docker save -o <파일명> <이미지명>[:태그] ex) docker save -o /Users/sujinchoi/tomcat_image tomcat:9.0

• 도커 이미지 로드 : 추출된 파일을 다시 도커 내 이미지로 로드 📍 docker load -i <파일명> ex) docker load -i /Users/sujinchoi/tomcat_image
• 도커 이미지 이름 추가 : 기존 이미지를 새로운 이름으로 추가 📍 docker tag [기존저장소/]<기존이미지명>[:기존태그] [새로운저장소/]<새로운이미지명>[:새로운태그] ex) docker tag tomcat:9.0 mytom:1

• IMAGE ID는 같고 이름만 다른 이미지 추가됨

• 도커 이미지 삭제 📍 docker rmi <이미지이름:태그 or IMAGE ID> ex) docker rmi mytom:1 -> 이름 추가(tag)된 이미지가 있으면 이미지는 삭제되지 않고 이름만 제거(untag) 됨 docker rmi tomcat:9.0 -> 이미지 삭제

☑️ 도커 컨테이너 관리

🌟 도커 컨테이너

• 도커 이미지의 실행 가능한 인스턴스
• 개별 애플리케이션의 실행에 필요한 실행환경을 독립적으로 운용

• 컨테이너 생성 📍 docker run [옵션] [저장소이름/] <이미지이름>[:버전] ex) docker run -d --name myweb -p 80:8080 tomcat:9.0.75-jdk11 다운받은 이미지가 없는 경우 자동으로 다운받아서 생성됨

• 이미지 다운로드(pull) + 컨테이너 생성(create) + 실행(start) + 접속(attach)까지 한번에 수행

• 컨테이너 확인 📍 docker ps [옵션] ex) docker ps -a : 전체 컨테이너 확인

• 컨테이너 상세 내용 조회 📍 docker inspect <컨테이너 이름 or ID> ex) docker inspect myweb
• 컨테이너로 파일 복사 📍 docker cp [옵션] <원본파일경로> <복사할 경로>

• 경로가 컨테이너 내부일 경우 <컨테이너명:켱로>로 지정 ex) docker cp /Users/sujinchoi/test.txt myweb:/root

• 컨테이너 실행/종료 📍 docker start/stop/restart <컨테이너 이름 or ID>

컨테이너 명령어 실행 📍 docker exec [옵션] <컨테이너이름 or ID> <명령어> ex) docker exec -it myweb /bin/bash

• 쉘을 실행하면 컨테이너에 접근 가능
• 쉘 접근 후 다양한 명령어 사용 가능(종료시 exit)

컨테이너 삭제 📍 docker rm [옵션] <컨테이너이름 or ID> [컨테이너 이름 or ID ...] ex) docker rm -f myweb

• 관점 지향 프로그래밍(Aspect Oriented Programming)
• 일반적으로 사용하는 클래스(Service, DAO 등)에서 중복되는 공통 코드 부분(commit, rollback, log 처리)을 별도의 영역으로 분히
• 소스 코드의 중복을 줄이고 필요할 때마다 가져다 쓸 수 있게 객체화하는 기술
• 횡단 관점

<용어 정리> ☑️ Advice : 공통되는 부분을 따로 빼내어 작성한 메소드 ☑️ JoinPoint : Advice가 적용될 수 있는 모든 관점(시점, 메소드) ☑️ Pointcut : JoinPoint 중 실제 Advice를 적용할 부분 ☑️ Aspect : Advice + Pointcut ☑️ Weaving : 그 시점에 공통 코드를 끼워 넣는 작업

기록을 남기는 것 !!!

Logging Framework (log4j / logback / slf4j)

스프링 프로젝트에는 기본적으로 log4j 라이브러리가 추가되어있고 log4j와 관련된 설정을 담는 log4j.xml 파일을 서버 구동과 동시에 로딩하게 되어 있음

하지만, log4j를 이용하여 많은 양의 로그를 출력하는 경우 성능 저하가 심하다. 그래서 최근에는 logback 이라는 라이브러리를 사용한다(-> 10배 빠름)

📍 Bean 등록 시 사용 @Component : 객체(컴포넌트)를 나타내는 일반적인 타입으로 <\bean> 태그와 동일한 역할 @Repository : 퍼시스턴스(persistence) 레이어, 영속성을 가지는 속성(파일, 데이터베이스)를 가진 클래스 @Service : 서비스 레이어, 비즈니스 로직을 가진 클래스 @Controller : 프리젠테이션 레이어, 웹 애플리케이션에서 View에서 전달된 웹 요청과 응답을 처리하는 클래스

=> @Repository, @Service, @Controller는 특정한 객체의 역할에 대한 @Controller의 구체화 형태!

📍 의존성 주입 시 사용 @Autowired

• 정밀한 의존 관계 주입(DI)이 필요한 경우에 유용하다.
• @Autowired는 필드 변수, setter 메소드, 생성자, 일반 메소드에 적용 가능하다.
• 의존하는 객체를 주입할 때 주로 Type을 이용하게 된다.
• @Autowired는 <\property>, <\constructor-arg> 태그와 동일한 역할을 한다.
• @Qualifier : @Autowired와 함께 쓰이며, 한 프로젝트 내에 @Autowired로 의존성을 주입하고자 하는 객체가 여러개 있을 경우, @Qualifier(“name”)를 통해 원하는 객체를 지정하여 주입할 수 있다.

@Resource

• 애플리케이션에서 필요로 하는 자원을 자동 연결할 때 사용된다.
• @Resource는 프로퍼티, setter 메소드에 적용 가능하다.
• 의존하는 객체를 주입할 때 주로 Name을 이용하게 된다.

@Value

• 단순한 값을 주입할 때 사용되는 어노테이션
• @Value('Spring')은 <property ... value='Spring'/>과 동일한 역할

@Autowired와 @Resource 어노테이션

• 공통점 : @Component로 의존관계를 설정한 객체로부터 의존 관계를 자동으로 주입
• 차이점 : @Autowired는 타입으로, @Resource는 이름으로 연결

🔅 Redirect 리다이렉트

: 서버에서 클라이언트에서 요청한 URL에 대한 응답에서 다른 URL로 재접속하라고 명령을 보내는 것 (Re-Direct -> URL을 다시 가리킨다) 즉, 클라이언트는 해당 URL로 다시 요청! 리다이렉트가 일어나면 URL 주소가 바뀌면서 다시 접속되는 것을 확인할 수 있어, 클라이언트 또한 리다이렉션이 일어났음을 알 수 있다.

** 클라이언트 : 웹브라우저

• 페이지 전환 주체가 클라이언트 : 접속한 URL이 아닌 다른 URL로 직접 접속하는 방법
• 사용자의 요청 정보가 바뀌어버림

  🌟⭐️ 리다이렉트는 클라이언트의 요청에 의해 서버의 DB에 변화가 생기는 작업에 사용된다!!!(로그인, 회원가입, 글쓰기) 예를 들어 DB 유저 테이블을 변경하는 회원가입과 같은 경우에는 리다이렉트가 사용되어야 요청을 중복해서 보내는 것을 방지할 수 있다.

🔅 Forward 포워드

: 서버 내부에서 일어나는 호출 -> 클라이언트의 URL에 대한 요청이 들어오면 해당 URL이 다른 URL로 포워딩 된 것이 확인되었을 경우 서버에서 포워딩된 URL의 리소스를 확인하여 클라이언트에 응답한다

• 페이지 전환 주체가 서버 : URL 주소가 바뀌지 않고도 서버 내부의 동작을 통해 다른 응답을 클라이언트에 내려 줄 수 있다
• 요청 정보는 그대로 유지한 채 서버 내부의 동작만 바뀜
• 웹 브라우저에는 최초 호출한 URL만 표시되고, 이동한 페이지의 URL 정보는 볼 수가 없다.

  🌟⭐️ 포워드는 특정 URL에 대해 외부에 공개되지 말아야 하는 부분을 가리는데 사용하거나 조회를 위해 사용된다!!!(리스트보기, 검색) 스프링의 경우, /WEB-INF에 있는 view에 대한 정보들이 외부에 직접 공개되지 말아야 할 때 내부에서 포워딩을 통해 /WEB-INF 경로를 가리키도록 한다. 예를 들어 sujin.com/96로 요청하면 sujin.com/WEB-INF/96을 응답하는 형식이다.