turtle_hw.log

HTTP-프로토콜

Thu, 25 Apr 2024 00:42:15 GMT

HTTP 프로토콜

1. 웹을 만들기 위해 사용되는 기술들

< 요 세가지는 한 묶음 => 웹 표준>

HTML : 웹 페이지를 채울 내용
Javascript : 웹 페이지에 들어갈 기능
CSS : 웹 페이지를 예쁘게 꾸밀 디자인

공통점 = 클라이언트 컴퓨터에서 동작하는 코드들이다 저장은 서버쪽에 되어 있고, 그걸 받아와서 내 컴퓨터에서 실행시키는 것! 이거를 받아오는 프로토콜이 HTTP이다.(웹 표준 데이터를 받아오는 애다)
ASP/JSP/PHP는 서버쪽에서 동작하는 애들이다

2. HTTP 프로토콜의 특징

HyperText Transfer Protocol (하이퍼 텍스트 전송 프로토콜)
www에서 쓰이는 핵심 프로토콜로 문서의 전송을 위해 쓰이며, 오늘날 거의 모든 웹 애플리케이션에서 사용되고 있다. -> 음성, 화상 등 여러 종류의 데이터를 MIME로 정의하여 전송 가능
HTTP 특징
- Request / Response(요청/응답) 동작에 기반하여 서비스 제공

3. HTTP 프로토콜의 통신 과정

v 1.0
3Way Handshake 요청 후 HTTP 요청, 응답 하면 바로 연결 종료
v 1.1
요청 받아갈거 다 받아가면 연결 종료

HTTP 요청 프로토콜

HTTP Method 설명 중 GET, POST만 사용해야 한다고 하지만 개발자 입장에서 RESTful API 개발시 PUT, DELETE도 사용하는게 원칙임

1. HTTP 요청

2. 프로토콜의 구조

제일 첫줄인 Request 라인이 가장 중요함
요청타입(중요) + 공백 + URI(중요) + 공백 + HTTP 버전

3. 요청타입 ( GET, POST 중요)

GET 방식은 중요하지 않은 정보를 URI에 같이 보내는 방식임
POST 방식은 중요한 정보 ID, PW와 같은 정보를 body에 넣어보내는 방식임

URL, URI란?

URI는 Uniform Resource Identifier 의 약자

URI 구조

scheme ://host[:port][/path][?query] (scheme 자리엔 7계층 프로토콜 형식지정하면 된다)

HTTP 요청 프로토콜 작성 실습

GET / HTTP/1.1 을 웹사이트에 요청보내면 요청은 다 감(근데 실습 어떻게 해야하는지 앞에 생략이 너무 되있어서 안됨니다)

URI 이해를 위한 실습

API 만들기

HTTP 응답 프로토콜

요청과 똑같음( 요청보다 간단함 )

응답 프로토콜 구조

HTTP 버전 + 공백 + 상태코드 + 공백 + 상태문구
( 상태코드와 상태문구는 세트임 코드만 알아두자)
100, 300번대는 몰라도 된다
200번대는 정상적인 통신을 완료했을때임 (정상)
400번대는 클라이언트가 잘못한거임
500번대는 서버가 잘못한거임
개발 코드 잘못쳤을때 500번대 자주 나옴

HTTP 헤더 포맷

헤더 종류

둘다 사용할수 있는 일반 헤더
각자 사용할 수 있는 요청 헤더와 응답 헤더
특별한 경우에 사용하는 항목 헤더

일반 헤더

요청 헤더

응답 헤더

HTTP 프로토콜 분석 실습

burpsuite 활용한 실습

프로세스

Thu, 25 Apr 2024 00:41:57 GMT

프로세스 #2

질문 답변 > 동기식 입출력과 비동기식 입출력

동기식 입출력 ( Synchronous I/O)
- I/O 요청 후 입출력 작업이 완료된 후에야 제어가 사용자 프로그램에 넘어감
- 구현방법 1 : I/O가 끝날때까지 CPPU를 낭비시킴 : 매시점 하나의 I/O만 일어날 수 있음
- 구현방법 2 : I/O가 완료될 떄까지 해당 프로그램에게서 CPU를 빼앗음 : I/O 처리를 기다리는 줄에 그 프로그램을 줄 세움 : 다른 프로그램에게 CPU를 줌
비동기식 입출력(Asynchronous I/O)
- I/O가 시작된 후 입출력 작업이 끝나기를 기다리지 않고 제어가 사용자 프로그램에 즉시 넘어감

Thread

A thread(or lightweight process) is a basic unit of CPU utilization

프로세스 하나에 CPU 수행 단위만 여러개 두고 있는 것을 thread라고 한다.

그림1	그림2

Thread의 구성
- program counter
- register set
- stack space
  - Thread 가 동료 thread와 공유하는 부분(=task)
- code section
- data section
- OS resources

Thread 사용의 장점

다중 스레드로 구성된 태스크 구조에서는 하나의 서버 스레드가 blocked(waiting) 상태인 동안에도 동일한 태스크 내의 다른 스레드가 실행되어 빠른 처리를 할 수 있다
스레드를 사용하면 병렬성을 높일 수 있다.(CPU가 여러 개 달린 컴퓨터에서만 얻을 수 있는 장점)(CPU가 하나밖에 없으면 안됨)

프로세스 #3

Single and Multithreaded Processes

Single and Multithreaded Processes

Benefits of Threads

Responsiveness(응답성 향상) : 답답함 해소 / 원래는 프로세스가 블럭되는데 요청한 그 스레드만 막히고 다른 스레드가 텍스트라도 보여줄 수 있어서 응답성에 있어서의 장점이 생긴다.이미지 파일을 불러오는 동안에 다른 애가 먼저 텍스트 화면에 보여줄 수 있게 됨(비동기식 입출력)
Resource Sharing(자원 공유) : 똑같은 일을 하는 프로그램이 여러 개 있을 때, 프로그램을 하나만 만들어두고 CPU 수행단위만 여러 개 두게 되면 스레드들이 공유를 통해 자원을 효과적으로 사용할 수 있음
Economy(경제성) : 문맥 교환(프로세스를 여러개 만드는 것보다, 스레드하나를 생성하고 CPU를 스위치 하는게 오버헤드가 적게 든다)
Utilization of MP Architectures : 스레드가 여러 개 있을때 서로 다른 CPU에서 병렬적으로 일을 수행할 수 있음 -> 멀티 프로세서 환경에서 효율적으로 실행 가능

Implementation of Threads

1. Kernel Threads

threads가 여러 개 있다는 사실을 운영체제 커널이 알고 있음

2. User Threads

라이브러리를 이용해서 지원됨
커널은 모르고 있어서 일반적인 프로세스로 보임
사용자 수준에서 threads 구현하게 됨

네트워크_IPv4, ICMP 프로토콜

Fri, 12 Apr 2024 12:51:59 GMT

1. IPv4 프로토콜

: 네트워크 상에서 데이터를 교환하기 위한 프로토콜로 데이터가 정확하게 전달될 것을 보장하지 않는다. : 중복된 패킷을 전달하거나 패킷의 순서를 잘못 전달할 가능성도 있다. (악의적으로 이용되면 DoS 공격이 된다) : 데이터의 정확하고 순차적인 전달은 그보다 상위 프로토콜인 TCP에서 보장한다.

IP option은 붙을 수도 있고 안붙을수도 있음(최대 10개 붙을 수 있음)
```
- 옵션 하나씩 붙을때마다 4바이트씩 추가됨 
```
20바이트라고 생각하면 됨(총 60바이트까지 늘어날 수 있음)
보통은 옵션없이 사용해서 20바이트라고 생각하면 된다.

Version = 버전 4가 온다고 생각하면 됨 16진수 하나가 4비트 (6이 오는 경우 없음/ 버전6은 이 모양자체가 아님)
IHL = 헤더의 길이
identification과 flags(3비트)와 fragment offset(13비트)은 하나의 세트
Flagment Offset = 첫 시작부분으로부터 떨어진 정도
Time To Live(TTL) : 패킷이 존재할 시간을 지정. 오류로 특정 네트워크 대역에서 영원히 머물게되는 것을 방지함.
Protocol : 상위 프로토콜의 타입을 알려준다. (ICMP : 1, 3계층, TCP : 6, 4계층, UDP: 17, 4계층)
Header Checksum : 헤더에 오류가 있는지 비교해서 확인하는 파트 (손실 방지)
Source IP Address : 출발지 IP주소
Destination IP Address : 목적지 IP주소

2. ICMP 프로토콜

Internet Control Message Protocol, 인터넷 제어 메시지 프로토콜 : 네트워크 컴퓨터 위에서 돌아가는 운영체제에서 오류 메시지를 전송받는 데 주로 쓰임 : 프로토콜 구조의 타입과 코드를 통해 오류 메시지를 전송받음

Type = 대분류 / Code = 소분류

[ Type ] 0번, 8번 = 응답과 요청 3번, 11번 = 목적지 도달불가, 시간초과 / 3번은 아예 가지를 못한것 , 11번은 가긴했는데 응답을 못받는 것(ex. 상대방이 방화벽 켜둘 경우) 5번 = 원격지에 있는 상대방의 라우팅 테이블(지도)를 수정하는 것

3. 라우팅 테이블

어디로 보내야 하는지 설정되어 있음 (내가 보낸 패킷은 어디로 갈까)

라우팅?
- 최적의 경로 = 주어진 데이터를 가장 짧거나 가장 빠른 시간 안에 전송할 수 있는 경로
- 서로 다른 네트워크 대역에 있는 장치 간 통신을 할 때 최적의 경로를 통해 통신을 가능하게 해 주는 것

4. IPv4 조각화 이론

조각화란?

큰 IP 패킷들이 적은 MTU(Maximun Transmission Unit)를 갖는 링크를 통하여 전송되려면 여러 개의 작은 패킷으로 쪼개어/조각화 되어 전송되어야 함 즉, 목적지까지 패킷을 전달하는 과정에 통과하는 각 라우터마다 전송에 적합한 프레임으로 변환 필요

일단 조각화되면, 최종 목적지에 도달할 때까지 재조립되지 않는 것이 일반적
IPv4에서는 발신지 뿐만 아니라 중간 라우터에서도 IP 조각화 가능
IPv6에서는 IP 단편화가 발신지에서만 가능 / 재조립은 항상 최종 수신지에서만 가능함!!

조각화 실습

첫번째 패킷의 데이터 크기 = MTU(1500) - 20 = 1480
마지막 패킷의 데이터 크기 = 4800 - 1480 - 1480 - 1480 = 360

(강의 : 따라하면서 배우는 IT)

알고리즘

Sat, 16 Mar 2024 14:16:47 GMT

SWEA

파리 퇴치(2001)

sol

  T = int(input())

  for tc in range(1, T+1):
      N, M = map(int, input().split())
      flies = [list(map(int, input().split()))for _ in range(N)]

      max_die = 0

      for i in range(N-M+1):
          for j in range(N-M+1):
              result = 0
              for k in range(i, i+M):
                  for l in range(j, j+M):
                      result += flies[k][l]
              if max_die < result:
                  max_die = result
      print(f'#{tc} {max_die}')  # 이거 출력할 때 자꾸 result출력하려구 함 max_die 출력해야지!!
  -----------------------------------------------------------------
  T = int(input())

  for tc in range(1, T+1):
      N, M = map(int, input().split())  # N = 배열 / M = 파리채크기
      arr = [list(map(int, input().split())) for _ in range(N)]

      arr_2 = []

      for i in range(N-M+1):
          for j in range(N-M+1):
              paris = 0

              for k in range(M):
                  for l in range(M):
                      paris += arr[i+k][j+l]

              arr_2.append(paris) # 리스트에 어펜드해서 

      print(f'#{tc} {max(arr_2)}')  # 최대값 출력하기

min max(4828)

sol

  T = int(input())
  for tc in range(1, T+1):
      N = int(input())
      numbers = list(map(int, input().split()))
      max_num = numbers[0]
      min_num = numbers[0]
      for i in numbers:
          if max_num <= i:
              max_num = i
          if min_num >= i:
              min_num = i
      chi = max_num - min_num
      print(f'#{tc} {chi}')

숫자 카드(4834)

sol

  '''
  가장 많은 카드의 숫자와 장 수를 차례로 출력
  '''
  T = int(input())

  for tc in range(1, T+1):
      N = int(input())
      cards = map(int, input())
      # print(cards)
      tmp = [0] * 10 # 카드 개수 체크할 배열
      for card in cards:
          tmp[card] += 1

      max_card = tmp[0]  # 초기값 설정
      for index in range(len(tmp)):
          if max_card <= tmp[index]:
              max_card = tmp[index]
              card_count = index
      print(f'#{tc} {card_count} {max_card}')

구간합(4835) ⇒ 최소값 설정하기

sol

  T = int(input())

  for tc in range(1, T+1):
      N,M = map(int, input().split())
      numbers = list(input().split())
      # print(numbers)

      # max_sums = 0
      # min_sums =

      for i in range(N-M+1):   # i위치에서 M개의 원소를 더해서 비교해야하기 때문에 범위 -M 해주기
          sums = 0
          for j in range(M):   # 구간합 구하기위한 범위
              sums += int(numbers[i+j])  # i에서 시작하는 구간의 각 원소 sums에 더해서 구간 합 구하기

          if i == 0:
              max_sums,min_sums = sums, sums
          else:
              if max_sums < sums:   # 구간합이 최대값으로 설정해 둔 것보다 크면
                  max_sums = sums     # 구간합으로 최대값 변경 반복
              if min_sums > sums:   # 구간합이 최소값으로 설정해 둔 것보다 작으면
                  min_sums = sums     # 구간합으로 최소값 변경 반복

      result = max_sums - min_sums
      print(f'#{tc} {result}')

쉬운 거스름돈(1970)

sol

  money = [50000, 10000, 5000, 1000, 500, 100, 50, 10]
  money_cnt = [0] * 8

  T = int(input())
  for tc in range(1, T+1):
      N = int(input())
      for i in range(8):
          # money의 각 금액으로 나눈 몫이
          # 그 돈을 사용할 개수가 되고
          # 나머지로 다시 또 다른 금액이 몇개 필요한지 반복해야한다
          money_cnt[i] = N // money[i]
          N %= money[i]
      print(f'#{tc}')
      print(*money_cnt)

두 개의 숫자열(1959)
색칠하기(4836)

sol

  '''
  color = 1(빨강)
  color = 2(파랑)
  '''
  T = int(input())
  for tc in range(1, T+1):
      N = int(input())
      arr = [list(map(int, input().split())) for _ in range(N)]

      tmp = [[0] * 10 for _ in range(10)]  # 색칠할 범위 카운트해서 입력해 둘 배열 만들기
      # print(tmp)
      # print(arr)
      for i in arr:  # 배열에서 리스트 하나씩 꺼내와진다.
          for j in range(i[0], i[2] + 1):
              for k in range(i[1], i[3] + 1):
                  if i[4] == 1:
                      tmp[j][k] += 1
                  # elif i[4] == 2:
                  #     tmp[j][k] += 2
                  else:
                      tmp[j][k] += 2
      purple = 0
      for x in range(10):
          for y in range(10):
              if tmp[x][y] == 3:
                  purple += 1

      print(f'#{tc} {purple}')

스도쿠검증(1974)

sol

  T = int(input())
  N = 9

  # 3*3 확인할 때 쓸 델타
  di = [0,0,1,1,1,2,2,2]
  dj = [1,2,0,1,2,0,1,2]

  for tc in range(1, T+1):
      arr = [list(map(int, input().split())) for _ in range(N)]

      garo = arr # 가로는 그대로 받아와주고

      # 세로
   ## 참고 transpose = [list(i) for i in zip(*lst)]
  ### tmp2 = list(zip(*tmp))  # 전치행렬 # 튜플형태로 행렬이 전치됨
      # sero = list(map(list, zip(*arr))) # 전치행렬하는 방법
      sero = []
      for i in range(N):
          col = []
          for j in range(N):
              col.append(arr[j][i])
          sero.append(col)

      result = 1 # 조건에 안맞는일 없으면 1 출력할거다
      # 3*3 9칸 안에서
      for i in range(0, N, 3):
          for j in range(0, N, 3):
              point = arr[i][j] # 3*3 행렬의 0,0 위치를 point로 잡아주고
              for k in range(8):
                  ni = i + di[k]
                  nj = j + dj[k]
                  # if 0 <= ni < N and 0 <= nj < N:
                  point += arr[ni][nj] # 나머지 8칸을 더해준다.

              # point하나 정해졌을 때마다 검사하기
              for ga, se in zip(garo, sero): # 가로와 세로 배열에서 원소 하나씩 가져와서
                  # print(ga)
                  # 1-9까지의 총합이 45라서
                  if sum(ga) == sum(se) == point == 45: # 원소 내의 숫자들의 합이 45이고
                                                      # 다 더해져있는 point도 45이면
                      continue # 계속 진행시키기
                  else:  # 합이 45가 안되면
                      result = 0  # result 값을 0으로 변환시켜주기

      print(f'#{tc} {result}')

숫자 배열 회전(1961) ⇒ 다시 풀기

sol

  def rotation_90(arr):
      matrix = [[0]*N for _ in range(N)]
      for i in range(N):
          for j in range(N):
              matrix[i][j] = arr[N-1-j][i]
      return matrix

  T = int(input())
  for tc in range(1, T+1):
      N = int(input())
      arr = [list(map(int, input().split())) for _ in range(N)]
      result = rotation_90(arr)
      result2 = rotation_90(result)
      result3 = rotation_90(result2)
      # print(result)

      print(f'#{tc}')
      for k in range(N):
          a = map(str, result[k])
          b = map(str, result2[k])
          c = map(str, result3[k])
          print(''.join(a), ''.join(b), ''.join(c))

어디에 단어가 들어갈 수 있을까(1979)

sol

  '''
  흰색 부분 = 1 (단어 들어갈 수 있는 곳)
  검은색 부분 = 0  (단어 들어갈 수 없는 곳)

  '''
  T = int(input())

  # 가로 단어 먼저 탐색하기
  for tc in range(1, T+1):
      N, K = map(int, input().split()) # 퍼즐가로세로길이 / 단어의 길이
      puzzle = [list(map(int, input().split())) for _ in range(N)]
      # print(puzzle)
      words = 0  # 들어갈수 있는 단어의 개수
      # 가로로 순회하면서 흰색부분이 나오면 cnt +1 하고
      for i in range(N):
          cnt = 0  # 단어의 길이
          for j in range(N):
              if puzzle[i][j] == 1:
                  cnt += 1
                  # print(cnt)
                  # 하다가 0을 만나거나 퍼즐의 끝이나오면 멈추고
              if puzzle[i][j] == 0 or j == N-1:
                  # 그 때의 길이를 단어의 길이 K와 비교해서
                  if cnt == K:
                      # 길이가 같으면 들어갈 수 있는 단어 +1 해주기
                      words += 1
                  cnt = 0  # 카운트 다한다음에 다시 다음 단어 길이 세려면
                  #         # 초기화 다시 해줘야 하는데 자꾸 까뮤금
      # print(words,'words')

      for a in range(N):
          cnt2 = 0
          for b in range(N):
              if puzzle[b][a] == 1:
                  cnt2 += 1
              if puzzle[b][a] == 0 or b == N-1:
                  if cnt2 == K:
                      words += 1
                  cnt2 = 0
      print(f'#{tc} {words}')

View(1206) ★

view

  # sol_1
  for tc in range(1, T+1):
      N = int(input())  # 건물의 개수 N
      h = list(map(int, input().split())) # N개의 건물의 높이
      cnt = 0 # 세대의 수 카운트
      for i in range(2, N-1):
          max_h = h[i]  # 가운데를 기준으로 얘가 최대조망권 초기설정값이됨
          for j in range(i-2, i+3): # 양쪽 2칸씩 비교해야함
              if i == j: # 나와 나자신을 비교할 필요는 없다
                  continue # 지나가쟈
              if h[i] > h[j] and max_h > h[i]-h[j]:
                  max_h = h[i]-h[j]
              if h[i] <= h[j]:
                  break
          else:
              cnt += max_h
      print(f'#{tc} {cnt}')

  # sol_2
  T = 10                      # TC 10개 고정
  for tc in range(1, T+1):    # 10번 돌면서
      N = int(input())        # 가로 길이(N개의 건물)
      height = list(map(int, input().split()))   # 건물 높이 노나서 받아오기

      view = 0    # 초기값 설정
      for i in range(2, N-2):
          # 2 이상의 공간이 확보 되어야하니까 i-2부터 비교하기 위해서 설정
          max_v = height[i-2]
          # max_v = 0
          if max_v < height[i-1]:   # i-1과 비교
              max_v = height[i-1]
          if max_v < height[i+1]:  # i+1과 비교
              max_v = height[i+1]
          if max_v < height[i+2]:  # i+2과 비교
              max_v = height[i+2]
          # if max_v < height[i-2]:  # i-2과 비교
          #     max_v = height[i-2]       # 얘는 제거해도 됨
          if height[i] > max_v:  # i가 주변 보다 높으면
              view += height[i] - max_v

      print(f'#{tc} {view}')

  # sol_3
  T = 10
  for tc in range(1, T+1):
      N = int(input())
      lst = list(map(int, input().split()))

      res = 0
      for i in range(2, N-2):
          d2 = lst[i] - lst[i+1]
          d1 = lst[i] - lst[i+2]
          d_1 = lst[i] - lst[i-1]
          d_2 = lst[i] - lst[i-2]
          if d2 > 0 and d_1 > 0 and d1 > 0 and d_2 >0:
              res += min(d_2, d_1,d1,d2)
      print(f'#{tc} {res}')

Flatten(1208)⇒ 한번만 더

Flatten

  T = 10
  for tc in range(1, T+1):
      dump = int(input())
      lst = list(map(int, input().split()))

      for i in range(dump):
          lst.sort()
          if lst[-1] - lst[0] <= 1:
              break
          lst[0] += 1
          lst[-1] -= 1

      res = max(lst) - min(lst)
      print(f'#{tc} {res}')
  ---------------------------------------------------------------
  for tc in range(1, 11):
    res = 0
    dump = int(input())
    ct = list(map(int, input().split()))
    for _ in range(dump):
      max_1 = max(ct)
      min_1 = min(ct)
      # 최대, 최소 값 인덱스 받아오기
      maxIdx = ct.index(max_1)
      minIdx = ct.index(min_1)
      ct[maxIdx] -= 1
      ct[minIdx] += 1
    res = max(ct) - min(ct)
    print(f'#{tc} {res}')
  ---------------------------------------------------------------
  T = 10
  W = 100 # 가로는항상 100으로 주어짐

  for tc in range(1, T+1):
      dump_ = int(input()) # 덤프 횟수 제한
      boxes = list(map(int, input().split())) # 각 상자의 높이
      result = 0
      while dump_ > 0: # 덤프횟수가 소진될 때까지
          dump_ -= 1 # 한번 반복할 때마다 덤프횟수 -1
          max_idx = 0
          min_idx = 0
          # 범위설정 1부터 하는 이유는 이미 max_idx 값 초기화를 0으로 해뒀기 때문에
          # 굳이 0부터 비교하면 똑같은거끼리 비교하는거라서 1부터 하면 되는 거!!
          for i in range(1, W):
              # boxes의 몇번째인덱스위치가 최고점일까
              if boxes[max_idx] <= boxes[i]:
                  max_idx = i
              # boxes의 몇번째인덱스위치가 최저점일까
              if boxes[min_idx] >= boxes[i]:
                  min_idx = i
          # 최고점 최저점을 찾은 다음에
          if boxes[max_idx] - boxes[min_idx] <= 1:
              # 최고점과 최저점의 간격이 1보다 작거나 같아지면(평탄화 완료)
              # 최고점과 최저점의 차이를 반환하고 끝낸다.
              result = boxes[max_idx] - boxes[min_idx]
              break
          else: # 평탄화가 완료되지 않으면(아직 진행중이면)
              boxes[max_idx] -= 1 # 가장 높은 상자에서 하나 빼서
              boxes[min_idx] += 1 # 가장 낮은 상자에 하나 더해주기

      if dump_ == 0: # 아직 평탄화 다 못했는데 평탄화제한 횟수 다 써버리면
          min_idx = 0
          max_idx = 0
          for j in range(W): # 범위 돌면서 최고점, 최저점 찾기
              # boxes의 몇번째인덱스위치가 최고점일까
              if boxes[min_idx] > boxes[j]:
                  min_idx = j
              # boxes의 몇번째인덱스위치가 최저점일까
              if boxes[max_idx] <= boxes[j]:
                  max_idx = j
          result = boxes[max_idx] - boxes[min_idx] # 그때의 차이 출력

      print(f'#{tc} {result}')
  ------------------------------------------------------------------------------------T = 10
  W = 100

  for tc in range(1, T+1):
      dump_cnt = int(input())
      boxes = list(map(int, input().split()))
      boxes.sort()
      while dump_cnt > 0:
          dump_cnt -= 1
          boxes[-1] -= 1
          boxes[0] += 1
          boxes.sort()

      result = max(boxes) - min(boxes)
      print(f'#{tc} {result}')

민석이의 과제 체크하기
Sumㅌ
특별한 정렬(4843)

sol

  T = int(input())
  for tc in range(1, T+1):
      N = int(input())
      numbers = list(map(int, input().split()))
      # print(numbers)
      result = []
      numbers.sort()
      # print(numbers)
      while numbers:
          result.append(numbers.pop())
          result.append(numbers.pop(0))

      case = result[:10]

      print(f'#{tc}',*case)

Magnetic(1220) - if/elif

자석

  T = 10

  for tc in range(1, T+1):
      N = int(input()) # 테이블의 한 변의 길이
      table = [list(map(int, input().split())) for _ in range(N)]
      # print(table)
      cnt = 0
      for i in range(N):
          flag = 0
          for j in range(N):
              if table[j][i] == 1:
                  flag = 1
              elif table[j][i] == 2 and flag == 1:
                  cnt += 1
                  flag = 0 # 다시 아무것도 안움직이는 상태로 되돌려주기
      print(f'#{tc} {cnt}')

최대 성적표 만들기(4466)

sol

  T = int(input())

  for tc in range(1, T+1):
      N, K = map(int, input().split())
      scores = list(map(int, input().split()))
      # print(N,K)
      # print(scores)
      scores.sort()  # 정렬 해주고
      sum_ls = []  # 최대값 K개 넣을 리스트 만들고
      for i in range(K):
          sum_ls.append(scores.pop()) # 정렬해둿으니까 뒤에서부터 큰 수 K개
                              # pop해서 리스트에 넣어주고
      # print(sum_ls)

      result = 0 # 결과값 변수
      for j in range(len(sum_ls)): # 리스트에 넣은 개수만큼 반복하면서
          result += sum_ls.pop() # 결과값에 누적해서 더해주기

      print(f'#{tc} {result}')

농작물 수확하기(2805) ⇒ 범위 문제

sol

  T = int(input())
  for tc in range(1, T+1):
      N = int(input())
      arr = [list(map(int, input())) for _ in range(N)]
      benefit = 0

      G = N//2
      for i in range(N):
          if i <= G:
              for j in range(G-i, G+i+1):
                  benefit += arr[i][j]
          else:
              for j in range(i-G, N-i+G):
                  benefit += arr[i][j]
      print(f'#{tc} {benefit}')

정곤이의 단조 증가하는 수(6190)

정곤이

  # sol 1
  T = int(input())
  for tc in range(1, T+1):
      N = int(input())
      numbers = list(map(int, input().split()))
      multis = []
      for i in range(N):
          for j in range(i+1, N):
              multi = numbers[i]*numbers[j]
              multis.append(str(multi))

      danjo = []
      for k in multis:
          LEN = len(k)
          if LEN < 2:
              continue

          check = True # 단조 증가하는지 체크
          for a in range(LEN-1):
              if k[a] > k[a+1]: # 앞의 자리가 뒤 자리 보다 크게 되면
                  check = False # check 변환 그러면서
                  break # 바로위 for문 탈출
          if check: # 방금 포문 아무 이상없이 한바꾸 돌았네 ?
              danjo.append(int(k)) # 그럼 dan 리스트에 i이놈 정수로 바까서 ean에 넣어줘

      if danjo:
          result = max(danjo)  # max doesn't work in empty list
          print(f'#{tc} {result}')
      else:
          print(f'#{tc} -1')
  ------------------------------------------------------------------------------------

  # sol2
  T = int(input())
  for tc in range(1, T+1):
      N = int(input())
      numbers = list(map(int, input().split()))
      multis = []
      for i in range(len(numbers)-1):
          for j in range(i+1, len(numbers)):
              multi = numbers[i]*numbers[j]
              multi_list = list(map(int, str(multi)))
              multi_len = len(multi_list)
              # print(multi_list)  # [8] / [1, 4] / [2, 0] / [2, 8] / [4, 0] / [7, 0]
              check = True
              for a in range(multi_len - 1):
                  if multi_list[a] > multi_list[a+1]:
                      check = False
                      break
              else:
                  multis.append(multi)

      result = int(max(multis))
      if multis:
          print(f'#{tc} {result}')
      else:
          print(f'#{tc} -1')

GNS(1221)

GNS

  numbers = ['ZRO', 'ONE', 'TWO', 'THR', 'FOR', 'FIV', 'SIX', 'SVN', 'EGT', 'NIN']

  T = int(input())
  for _ in range(1, T+1):
      tc, L = input().split()
      num_ls = list(input().split())
      # sort_ls = sorted(num_ls, reverse=True)
      ls = []
      N = len(num_ls)
      for i in range(N):
          ls.append(numbers.index(num_ls[i]))

      ls.sort()

      for j in range(N):
          ls[j] = numbers[ls[j]]

      print(tc)
      print(*ls)

회문1(1215) = 외우기

회문1

  T = 10
  for tc in range(1, T+1):
      K = int(input())
      N = 8
      arr = [input() for _ in range(N)]
      # print(arr)
      cnt = 0  # 회문개수 세려고
      for i in range(N):
          for j in range(N - K + 1): # 회문의 길이가 K라서
              for p in range(K // 2):# 찾아야 하는 회문길의의 절반만큼 기준잡아서
                  if arr[i][j + p] != arr[i][j + K - 1 - p]: #  가로
                      break  # for p, j부터 시작하는 구간은 회문이 아님
              else:   # for이 끝나고 실행되는 행
                      # 근데 만약 break가 실행된 상태면 이거 실행 안됨
                  cnt += 1
              for p in range(K // 2):
                  if arr[j + p][i] != arr[j + K - 1 - p][i]: # 세로
                      break  # for p, j부터 시작하는 구간은 회문이 아님
              else:
                  cnt += 1
      print(f'#{tc} {cnt}')

회문2(1216)

회문2

  T = 10
  N = 100
  for _ in range(1, T+1):
      tc = int(input())
      matrix = [input() for _ in range(N)]
      length = 0
      # 회문의 길이 긴것부터 가져와서 l로
      for l in range(N, 0, -1):
          for i in range(N):
              for j in range(N-l+1):
                  for k in range(l//2):
                      if matrix[i][j+k] != matrix[i][j+l-1-k]:
                          break
                  else:
                      length = max(l, length)
                  for p in range(l//2):
                      if matrix[j+p][i] != matrix[j+l-1-p][i]:
                          break
                  else:
                      length = max(l, length)
      print(f'#{tc} {length}')

  ====================================================================================
  T = 10
  N = 100

  for _ in range(1, T+1):
      tc = int(input())
      pallin = [input() for _ in range(N)]
      # print(pallin)
      long = 1

      for K in range(N, 0, -1): # K의 길이를 긴 것부터 뽑아와서 설정해주고
          for i in range(N):
              for j in range(N-K+1):
                  for k in range(K//2):
                      check = True
                      if pallin[i][j+k] != pallin[i][j+K-1-k]:
                          check = False
                          break
                  if check:
                      # 설정해둔 K랑 long이랑 비교해서 가장 긴 회문길이 구하기
                      long = max(long, K) 

                  for p in range(K//2):
                      check = True
                      if pallin[j+p][i] != pallin[j+K-1-p][i]:
                          check = False
                          break
                  if check:
                      long = max(long, K)
      print(f'#{tc} {long}')

진기의 최고급 붕어빵(1860)

붕어빵

  '''
  제공할 수 있으면 'Possible'
  아니라면 'Impossible'
  '''

  T = int(input())
  for tc in range(1, T+1):
      # N손님수, M초마다 K개 생산
      N, M, K = map(int, input().split())
      # print(N, M, K)

      # N명이 각각 도착하는 시간
      visited_time = list(map(int, input().split()))
      visited_time.sort()  # 도착시간 순으로 정렬
      result = 'Possible'
      for i in range(N):
          # 1초에 K//M씩 생산하니까
          # i+1 번째 손님이 방문한 시간이
          # i 번째 손님이 방문한 시간까지의 붕어빵 생산량보다 커버리면
          # 붕어빵이 없어서 제공할 수가 없으니까
          # 아래와 같이 조건문을 달아준다.
          if i+1 > visited_time[i]//M*K:
              result = 'Impossible'
              break
      print(f'#{tc} {result}')

기차사이의 파리(6019)

sol

  T = int(input())
  for tc in range(1, T+1):
      D, A, B, F = map(int, input().split())
      # A와 B는 D/(A+B)시간이면 만난다
      time = D/(A+B)

      # 파리의 이동거리은 D/(A+B)를 파리의 속력이랑 곱하면 된다
      result = time*F
      print(f'#{tc} {result}')

Ladder1(1210)

ladder1 ⇒ 다시 한번 보자

  # 하, 좌, 우
  dx = [1, 0, 0]
  dy = [0, -1, 1]

  def search(x,y):
      #들린 지점은 1로 표시해서 다시 돌아가지 않게 만들기 위함
      visited = [[0]*100 for _ in range(100)]
      original_y = y  # 출발지점의 x좌표
      visited[x][y] = 1

      while x != 99:  # 마지막 행까지 갈 동안
          for k in range(3):  # 하, 좌, 우 방향 조사하면서
              ni = x + dx[k]
              nj = y + dy[k]
              # ni,nj가 범위 안에 있고 갈 수 있는 길이며, 들린적이 없으면 가야지
              if 0 <= ni < N and 0 <= nj < N and ladder[ni][nj] and visited[ni][nj] == 0:
                  x, y = ni, nj  # 그리고 거기를 기점으로 또 serch 해야함
                  visited[ni][nj] = 1   # 들렀음을 표시해주자

      if ladder[x][y] == 2: # 2가 적혀있는 도착점에 다다르면
          return original_y    # 출발위치의 x좌표인 y를 반환
      else:
          return "실패"

  T = 10
  N = 100
  for _ in range(1, T+1):
      tc = int(input())
      ladder = [list(map(int, input().split())) for _ in range(N)]
      # print(ladder)
      for i in range(N):
          if ladder[0][i] == 1:
              result = search(0, i)
          if result != "실패":
              break

      print(f'#{tc} {result}')

Ladder2(1211)

ladder2 ⇒ 다시 한번 보자

  # sol_1
      # 하, 좌, 우
  dx = [0, 0, 1]
  dy = [1, -1, 0]

  def check(x, y):
      visited = [[0] * 100 for _ in range(100)]
      original = y
      visited[x][y] = 1
      cnt = 0
      while x != 99:
          for k in range(3):
              ni = x + dx[k]
              nj = y + dy[k]
              if 0 <= ni < N and 0 <= nj < N and ladder[ni][nj] and visited[ni][nj] == 0:
                  x, y = ni, nj
                  visited[ni][nj] = 1
                  cnt += 1
                  break
      return [cnt, original]

  T = 10
  N = 100
  for _ in range(1, T+1):
      tc = int(input())
      ladder = [list(map(int, input().split())) for _ in range(N)]
      distance = 987654321  # 가장 짧은 이동거리를 구하기 위해 비교할 초기값 설정
      ans_y = 0   # 시작점인 x좌표 구하기 위해 비교할 초기값 설정

      for i in range(N):
          if ladder[0][i] == 1:  # 첫번째 행의 값이 1이면 시작지점
              dis, y_cordi = check(0, i)  # 이동거리와, 그때의 x 좌표를 반환한다
              # print(dis, y_cordi)
              if distance > dis:  # 가장 짧은 이동거리를 찾는다
                  distance = dis  # 그 때의 거리와
                  ans_y = y_cordi # 그 때의 시작점 x좌표를 구한다.
      print(f'#{tc} {ans_y}')
  ----------------------------------------------------------------------------------
  # sol_2
  # 하, 좌, 우
  dx = [0, 0, 1]
  dy = [1, -1, 0]

  def check(x, y):
      visited = [[0] * 100 for _ in range(100)]
      original = y
      visited[x][y] = 1
      cnt = 0
      while x != 99:
          for k in range(3):
              ni = x + dx[k]
              nj = y + dy[k]
              if 0 <= ni < N and 0 <= nj < N and ladder[ni][nj] and visited[ni][nj] == 0:
                  x, y = ni, nj
                  visited[ni][nj] = 1
                  cnt += 1
                  break

      return [cnt, original]  # 이동거리와,  좌표값을 리스트에 넣어서 반환한다.

  T = 10
  N = 100
  for _ in range(1, T + 1):
      tc = int(input())
      ladder = [list(map(int, input().split())) for _ in range(N)]
      cnt_list = []  # check 함수에서 반환되는 리스트 넣을 리스트 만들어두기

      for i in range(N): # N크기의 사다리라서 그 길이만큼 순회하면서
          if ladder[0][i] == 1:  # 첫번째 행의 값이 1이면 시작지점이다
              # 그때의 이동거리와, 좌표값리스트를 구하기 위한 check함수 호출 및 cnt_list에 담기
              cnt_list.append(check(0, i))

      cnt_list.sort()  # 기본정렬은 리스트의 리스트 첫번째 값을 기준으로 오름차순 정렬된다.
      result = cnt_list[0][1] # 정렬해뒀으니까 제일 앞에 있는 것의 이동거리가 제일 작을 것이고
                              # 그때의 x좌표를 result에 할당한다.
      print(f'#{tc} {result}')
  ----------------------------------------------------------------------------------
  # sol_3
  for tc in range(1, 11):
      input()
      MAP = [list(map(int, input().split())) for _ in range(100)]

      MIN = float('inf')
      res = -1
      for start in range(100):
          if MAP[0][start] == 1:
              col = start
              row = 0
              cnt = 0

              while row < 99:
                  cnt += 1

                  # 오른쪽으로 이동
                  if col < 99 and MAP[row][col+1] == 1:
                      while col < 99 and MAP[row][col+1] == 1:
                          col += 1
                          cnt += 1
                  # 왼쪽으로 이동
                  elif col > 0 and MAP[row][col-1] == 1:
                      while col > 0 and MAP[row][col-1] == 1:
                          col -= 1
                          cnt += 1
                  row += 1
              if MIN > cnt:
                  MIN = cnt
                  res = start
      print(f'#{tc} {res}')

행렬찾기(1258)

sol

  T = int(input())
  for tc in range(1, T+1):
      n = int(input())
      arr = [list(map(int, input().split())) for _ in range(n)]
      ls = []
      for i in range(n):
          for j in range(n):
              if arr[i][j] != 0:
                  x, y = j, i

                  while x < n and arr[i][x] != 0:
                      x += 1

                  while y < n and arr[y][j] != 0:
                      y += 1

                  if arr[i][j] != 0:  # 요조건은 위에 이미 있어서 안해두 댐
                      ls.append((y-i, x-j))

                  for a in range(i, y):
                      for b in range(j, x):
                          arr[a][b] = 0

          ls.sort(key=lambda a: (a[0]*a[1], a[0]))

      print(f'#{tc}', len(ls), end=' ')
      for x,y in ls:
          print(x, y, end=' ')
      print()

러시아 국기 같은 깃발(4613)

러시아

  T = int(input())
  for tc in range(1, T+1):
      N, M = map(int, input().split())
      arr = [input() for _ in range(N)]

      mx = 0
      for i in range(N-2):
          for j in range(i+1, N-1):
              cnt = 0
              for s in range(i+1):
                  cnt += arr[s].count('W')
              for s in range(i+1, j+1):
                  cnt += arr[s].count('B')
              for s in range(j+1, N):
                  cnt += arr[s].count('R')
              mx = max(mx, cnt)
      print(f'#{tc} {N*M-mx}')

상호의 배틀필드(1873)

배틀필드

  import sys
  # sys.stdin = open('input.txt')

  T = int(input())

  for tc in range(1, T + 1):
      H, W = map(int, input().split())
      MAP = [list(input()) for _ in range(H)]
      N = int(input())
      comm = input()

      for i in range(H):
          for j in range(W):
              if MAP[i][j] in '<>^v':
                  row = i
                  col = j
                  break

      for i in range(len(comm)):
          t_row = row
          t_col = col

          if comm[i] == 'U':
              MAP[t_row][t_col] = '^'
              if t_row-1 >= 0 and MAP[t_row-1][t_col] == '.':
                  MAP[t_row-1][t_col] = '^'
                  MAP[t_row][t_col] = '.'
                  row -= 1

          elif comm[i] == 'R':
              MAP[t_row][t_col] = '>'
              if t_col+1 < W and MAP[t_row][t_col+1] == '.':
                  MAP[t_row][t_col+1] = '>'
                  MAP[t_row][t_col] = '.'
                  col += 1

          elif comm[i] == 'L':
              MAP[t_row][t_col] = '<'
              if t_col -1 >= 0 and MAP[t_row][t_col-1] == '.':
                  MAP[t_row][t_col-1] = '<'
                  MAP[t_row][t_col] = '.'
                  col -= 1

          elif comm[i] == 'D':
              MAP[t_row][t_col] = 'v'
              if t_row+1 < H and MAP[t_row+1][t_col] == '.':
                  MAP[t_row+1][t_col] = 'v'
                  MAP[t_row][t_col] = '.'
                  row += 1

          elif comm[i] == 'S':
              if MAP[t_row][t_col] == '^':
                  if t_row -1 >= 0:
                      for u in range(t_row-1, -1, -1):
                          if MAP[u][t_col] == '*':
                              MAP[u][t_col] = '.'
                              break
                          elif MAP[u][t_col] == '#':
                              break

              elif MAP[t_row][t_col] == '>':
                  if t_col + 1 < W:
                      for r in range(t_col + 1, W):
                          if MAP[t_row][r] == '*':
                              MAP[t_row][r] = '.'
                              break
                          elif MAP[t_row][r] == '#':
                              break

              elif MAP[t_row][t_col] == 'v':
                  if t_row + 1 < H:
                      for d in range(t_row +1, H):
                          if MAP[d][t_col] == '*':
                              MAP[d][t_col] = '.'
                              break
                          elif MAP[d][t_col] == '#':
                              break

              elif MAP[t_row][t_col] == '<':
                  if t_col - 1 >= 0:
                      for l in range(t_col - 1, -1, -1):
                          if MAP[t_row][l] == '*':
                              MAP[t_row][l] = '.'
                              break
                          elif MAP[t_row][l] == '#':
                              break

      print(f'#{tc} {"".join(MAP[0])}')
      for k in range(1, H):
          print("".join(MAP[k]))

문제 제목 붙이기(7087) ⇒ 파이썬 제출 안됨

sol

  T = int(input())

  for tc in range(1, T+1):
      cnt = 0
      N = int(input())
      ls = []
      for _ in range(N):
          ls.append(input())
          ls.sort()
          # print(ls)
          log = 0
          for i in range(len(ls)-1):
              if log == 0:
                  if ord(ls[i][0]) == ord(ls[i+1][0]):
                      cnt += 1
                      log = 1
                  if ord(ls[i][0]) + 1 == ord(ls[i+1][0]):
                      cnt += 1
                  else:
                      break
              else:
                  if ord(ls[i][0]) + 1 == ord(ls[i+1][0]):
                      cnt += 1
                  else:
                      break

      print(f'#{tc} {cnt}')

영준이의 카드 카운팅(4047)
퍼팩트 셔플(3499)
패턴 마디의 길이(2007)

sol

  T = int(input())
  cnt = 0 # 마디의 길이를 출력할거다

  for tc in range(1, T+1):
      sentence = list(input())
      # print(sentence)
      # N = len(sentence)
      madi = 0
      for i in range(1, 11):
          if sentence[:i] == sentence[i:i*2]:
              madi = i
              break
      print(f'#{tc} {madi}')

간단한 369게임(1926)
자기방으로 돌아가기(4408)

자기방

  '''
  겹치는 만큼 기다려야하니까 가장 많이 겹치는 만큼이 최소 걸리는 시간이 되겠다!!
  '''

  T = int(input())
  for tc in range(1, T+1):
      N = int(input())  # 학생 수
      arr = [list(map(int, input().split())) for _ in range(N)]

      # for _ in range(N):
      #     go, to = map(int, input().split()) 9# 현재 방과 돌아갈 방
      #     print(go,to)
      # print(arr)

      cnt = [0] * 201         # 방사이 공간을 지나는 사람수를 기록할 복도
      for a, b in arr:        # arr에서 두개 꺼낼건데 a <= b라는 보장이 없음에 주의!!
                              # 복도번호 = (방번호 + 방번호%2) // 2
          a = (a + a % 2)//2
          b = (b + b % 2)//2
          for i in range(min(a, b), max(a, b)+1):  # 둘 중 작은데서 출발해서 둘중 큰곳으로 도착
              cnt[i] += 1
      print(f'#{tc} {max(cnt)}')

재밌는 오셀로 게임
18575

sol

  T = int(input())

  di = [-1,0,1,0]
  dj = [0,1,0,-1]

  for tc in range(1, T +1):
      N = int(input())
      arr = [list(map(int, input().split())) for _ in range(N)]

      max_sum = 0
      min_sum = 987654321
      for i in range(N):
          for j in range(N):
              point = arr[i][j]
              for k in range(4):
                  for l in range(1, N):
                      ni = i + di[k]*l
                      nj = j + dj[k]*l
                      if 0 <= ni < N and 0 <= nj < N:
                          point += arr[ni][nj]

              if max_sum <= point:
                  max_sum = point
              if min_sum >= point:
                  min_sum = point
      result = max_sum - min_sum
      print(f'#{tc} {result}')

당근 포장하기(16811)

sol

  def check(N, ls): # 당근의 크기를 입력하면 모든 조건을 확인하는 프로그램
      '''
      당근 3개 => 소,중,대 상자에 든 당근의 개수 차이 = 0 소 1 중 1 대 1 씩 들어갔으니까
      당근 5개  > 소 3 중 1 대 1 = 당근의 개수 차이 2
          그런데 2개 초과하는 상자 잇으니까 조건 만족 x
      당근 8개
      '''
      L = int(N/2) # L초과하는 당근이 있으면 안됨
      ls.sort()
      min_chai = 987654321  # 포장개수차이 최소값 초기값 설정
      for i in range(N-2):
          for j in range(i+1, N-1):
              if ls[i] != ls[i+1] and ls[j] != ls[j+1]:
                  small = i+1
                  middle = j-i
                  large = N-1-j
                  if small <= L and middle <= L and large <= L:
                      if min_chai >= (max(small, middle, large) - min(small, middle, large)):
                          min_chai = max(small, middle, large) - min(small, middle, large)
      return min_chai

  T = int(input()) # 수확횟수
  for tc in range(1, T+1):
      N = int(input()) # 수확한 당근의 개수 3
      C = list(map(int, input().split())) # 당근의 크기 1 2 3
      # C.sort() # 당근을 크기 순으로 정렬
      # min_v = 1000 # 포장별 최소 개수 차이, 포장 불가인 경우 -1
      # for i in range(N-2):
      #     for j in range(i+1, N-1):
      #         if C[i] != C[i+1] and C[j] != C[j+1]: # 같은 크기 사이에 경계를 두면 안돼
      #             small = i + 1   # 소 상자에 들어간 당근 개수
      #             middle = j-i    # 중 상자에 들어간 당근 개수
      #             large = N-1-j   # 대 상자에 들어간 당근 개수
      #             if 0 < small <= N//2 and 0 < middle <= N//2 and 0 < large <= N//2:
      #                 if min_v > (max(small, middle, large) - min(small, middle, large)):
      #                     min_v = max(small, middle, large) - min(small, middle, large)
      res = check(N,C)
      if res == 987654321:
          print(f'#{tc} -1')
      else:
          print(f'#{tc} {res}')

백준

스위치_켜고_끄기
주사위_쌓기
창고_다각형
일곱_난쟁이(2309)

난쟁이

  K = 100
  S = 0
  ls = []
  for i in range(9):
      ls.append(int(input()))

  S = sum(ls)
  find = S - K
  ls.sort()
  a = 0
  b = 0

  N = len(ls)
  for j in range(N-1):
      for k in range(j+1, N):
          if ls[j] + ls[k] == find:
              a = ls[j]
              b = ls[k]
              # print(a, b) = 15, 25
              # print(type(a)) -> int

  for f in ls:
      if f != a and f != b:
          print(f)

참외밭
직사각형
2527
직사각형을 만드는 방법

8320

  N = int(input())

  # [1] 가능한 경우를 모두 순회
  ans = 0
  for i in range(1, N+1):
      for j in range(i, N+1):
          if i*j <= N:
              ans += 1
  print(ans)

  # [2] 몫 연산을 통해서 처리
  ans = N
  for i in range(2, N):
      n = N // i - (i-1)
      if n < 1:
          break
      ans += n
  print(ans)

수열

2559

  # N = 온도측정한 전체 날짜의 수, K = 합구하기 위한 연속적인 날짜의 수
  N, K = map(int, input().split())
  degrees = list(map(int, input().split())) # 매일 측정한 온도
  result = [] # 온도의 합을 구해서 넣어둘 리스트
  result.append(sum(degrees[0:K])) # 0번째부터 K-1번째까지 먼저 합해서 넣어준다음
  for i in range(N-K): # K개만큼 더해야하니까 인덱스 번호 N에서 K 빼준 범위로 설정
     result.append(result[i]-degrees[i]+degrees[i+K])
     # 더한거에서 젤 앞에꺼 빼고 그다음 하나 더해주기(한칸씩 뒤로 가는겨)
  print(max(result)) # 리스트에 넣어둔 것들 중 가장 큰값 프린트 하기

색종이(2563)

색종이

  N = int(input())

  matrix = [[0]*102 for _ in range(102)] # 색종이 표시할 배열

  for _ in range(N):
      a, b = map(int, input().split())
      for i in range(a,a+10):
          for j in range(b, b+10):
              matrix[i][j] = 1

  result = 0
  for k in matrix:
      result += sum(k)  # matrix 안의 k리스트들의 합을 result에 누적시켜 더해주면
                          # 넓이(1로 채워져 있는 곳)이 나온다
  print(result)

색종이(10163)

10163

  def count(arr):
      cnt = 0
      for ls in arr:
          for k in range(1, len(ls)):
              if ls[k-1] != ls[k]:
                  cnt += 1
      return cnt

  N = int(input())
  tmp = [[0]*102 for _ in range(102)]
  for _ in range(N):
      a, b = map(int, input().split())
      for i in range(a, a+10):
          for j in range(b, b+10):
              tmp[i][j] = 1

  # tmp2 = list(zip(*tmp))  # 전치행렬 # 튜플형태로 행렬이 전치됨
  tmp2 = list(map(list, zip(*tmp)))  # 수정 필요할 시의 전치행렬 # 리스트 형태로 전치됨

  result = count(tmp) + count(tmp2)
  print(result)

경비원
빙고
줄_세우기

2605

  N = int(input()) # 학생의 수
  numbers = list(map(int, input().split()))
  alst = [n for n in range(1, N+1)]
  # print(alst) # [1, 2, 3, 4, 5]

  for i in range(N): # i위치의 학생을 순서대로 이동처리
      n, t = numbers[i], alst[i] # 앞으로 이동할 칸 수, 학생번호
      # 순차적으로 덮어씌우기
      # 나한테 전에꺼를 집어넣기
      # 끝난다음에는 alst[i-n]번째에 t 넣어주기
      for j in range(i, i-n, -1):
          alst[j] = alst[j-1]
      alst[i-n] = t
  print(*alst)

10431

  P = int(input())
  for tc in range(1, P+1):
      lst = list(map(int, input().split()))[1:]
      cnt = 0
      for i in range(1, 20):
          for j in range(i): # i의 이전 값들을 비교할것
              if lst[i] < lst[j]: # 더 큰애들이 앞에 서있으면
                  cnt += 1 # 카운트 증가

      print(f'{tc} {cnt}')

종이자르기

2628 - idea

  '''
  가장 큰 종이 조각의 넓이 ?
  바깥 둘레에서 잘라야하는 열과 행의 번호를
  각각 리스트에 담아서
  자르면 나오는 길이가지고
  가장 긴 길이 두개 곱하면 가장 큰 색종이 넓이 구할 수 있음 
  '''
  # 종이의 가로, 세로
  W, H = map(int, input().split())
  # [1] 가능한 가로/세로 자르는 위치를 저장 후 정렬
  w_ls = [0, H]
  h_ls = [0, W]
  N = int(input()) # 잘라야 하는 점선의 개수

  for _ in range(N):
      t, n = map(int, input().split())
      if t == 0:
          w_ls.append(n)
      else:
          h_ls.append(n)
  w_ls.sort()
  h_ls.sort()
  # print(w_ls)
  # [2] 가장 긴 길이 찾기
  w_mx = 0
  for i in range(1, len(w_ls)):
      w_mx = max(w_mx, w_ls[i] - w_ls[i-1])

  h_mx = 0
  for i in range(1, len(h_ls)):
      h_mx = max(h_mx, h_ls[i] - h_ls[i-1])

  print(w_mx*h_mx)

수_이어가기
직사각형_네개의_합집합의_면적_구하기

2669

  arr = [[0]*102 for _ in range(102)]
  for _ in range(4):
      a, b, c, d = map(int, input().split())
      for i in range(b, d):
          for j in range(a, c):
              arr[i][j] = 1
  cnt = 0
  for k in range(102):
      for l in range(102):
          if arr[k][l] == 1:
              cnt += 1

  print(cnt)

자리배정

10157

  C, R = map(int, input().split())
  K = int(input())

  if R*C < K: # 배정이 불가능한 경우 0
      print(0)
  else: # 배정하면서 K가 되면 그 때 좌표 출력
      di, dj = [1, 0, -1, 0], [0, 1, 0, -1]
      # 주변을 1로 둘러싸면 : 범위체크 필요없음
      arr = [[1]*(C+2)] + [[1] + [0]*C + [1] for _ in range(R)] + [[1]*(C+2)]

      ci, cj, dr = 1, 1, 0
      for n in range(1, K):
          arr[ci][cj] = n
          ni, nj = ci + di[dr] , cj + dj[dr]
          if arr[ni][nj] == 0: # 비어있으니 이동가능
              ci, cj = ni, nj
          else:   # 범위밖 또는 이미 채워진경우
              dr = (dr+1)% 4
              ci, cj = ci+di[dr], cj+dj[dr]
      print(f'{cj} {ci}')

개미
방_배정

13300

  '''
  여학생 = 0
  남학생 = 1
  '''
  def count(arr):
      grade = [0] * 7  # 학년 별로 몇명인지 세보자
      # ls = [] #
      for i in arr:   # 성별로 구분해서 학년만 넣어둔 리스트를 순회하면서
          grade[i] += 1 # 그 학년을 인덱스번호로 활용해서 cnt 증가시켜주기
          # print(grade)
      result = 0 # 방 몇개필요한지 구할 결과값변수 초기화
      for k in grade: # 학년별로 몇명인지 누적해서 구해둔 grade리스트 순회하면서
          if k % K == 0:  # 한방에 배정할 수 있는 최대 인원수로 나눈 값이 딱 떨어지면
              result += k//K  # 그 나눗셈 몫만큼의 방을 더해주면 됨
              # print(result)
          else:   # 안나눠 떨어지면 그 안나눠 떨어진 사람을 위해서
              result += k//K + 1  # 방 하나 추가 배정해 주면 됨
      return result # 누적된 방이 몇 개 필요한지에 대한 result값 반환하기

  # N = 수학여행에 참가하는 학생 수
  # K = 한 방에 배정할 수 있는 최대 인원 수
  N, K = map(int, input().split())
  cnt_S0 = []
  cnt_S1 = []

  for _ in range(N):
      S, Y = map(int, input().split())  # 성별 S / 학년 Y
      # print(S, Y)
      if S == 1: # 성별 1일경우
          # cnt_S1.append([S, Y]) # 의 성별과 학년 넣어주기
          cnt_S1.append(Y) # 아니지, 학년만 넣어주자 성별은 노났으니까
      elif S == 0: # 성별 2일경우
          # cnt_S0.append([S, Y])
          cnt_S0.append(Y)

  a = count(cnt_S1) # 성별 남자일 경우의 필요 방개수
  # print(a)
  b = count(cnt_S0)   # 성별 여자일 경우의 필요한 방개수
  ans = a+b # 더해서 결과값
  print(ans)

  '''
  print(cnt_S0)
  print(cnt_S1)
  [1, 2, 2, 3, 6, 5] # 성별 여자인 경우의 학년
  [1, 1, 2, 3, 4, 3, 3, 5, 5, 6] # 성별 남자인 경우의 학년'''

딱지놀이

14696

  N = int(input())  # 딱지놀이의 총 라운드 수
  for _ in range(N):
      A = list(input().split())
      B = list(input().split())
      a_len = int(A[0])
      b_len = int(B[0])
      a_ls = A[1:]
      b_ls = B[1:]

      # 인덱스 이용해서 카운트 해주자(1,2,3,4 입력해주기위해서 *5)
      one_cnt = [0] * 5
      two_cnt = [0] * 5

      for i in range(a_len):
          one_cnt[int(a_ls[i])] += 1
      for j in range(b_len):
          two_cnt[int(b_ls[j])] += 1

      # 4,3,2,1 역순 순회하면서 누가 이기는지 판단하기
      result = ''
      for k in range(4, 0, -1):
          if one_cnt[k] > two_cnt[k]:
              result = 'A'
              break
          elif one_cnt[k] < two_cnt[k]:
              result = 'B'
              break
          else:
              result = 'D'
      print(result)

State Management

Mon, 13 Nov 2023 00:57:08 GMT

1. State Management

상태관리

Vue 컴포넌트는 이미 반응형 상태를 관리하고 있음
상태 === 데이터

컴포넌트 구조의 단순화

상태(State) : 앱 구동에 필요한 기본 데이터
뷰(View) : 상태를 선언적으로 매핑하여 시각화
기능(Actions) : 뷰에서 사용자 입려겡 대해 반응적으로 상태를 변경할 수 있게 정의된 동작

" 단방향 데이터 흐름"의 간단한 표현

상태 관리의 단순성이 무너지는 시점

여러 컴포넌트가 상태를 공유할 때
1. 여러 뷰가 동일한 상태에 종속되는 경우
  - 공유 상태를 공통 조상 컴포넌트로 "끌어올린" 다음 props로 전달하는 것
  - 하지만 계층 구조가 깊어질 경우 비효율적, 관리가 어려워 짐
2. 서로 다른 뷰의 기능이 동일한 상태를 변경시켜야 하는 경우
  - 발신(emit)된 이벤트를 통해 상태의 여러 복사본을 변경 및 동기화 하는 것
  - 마찬가지로 관리의 패턴이 깨지기 쉽고 유지 관리할 수 없는 코드가 됨

해결책

각 컴포넌트의 공유 상태를 추출하여, 전역에서 참조할 수 있는 저장소에서 관리
컴포넌트 트리는 하나의 큰 "뷰"가 되고 모든 컴포넌트는 트리 계층 구조에 관계 없이 상태에 접근하거나 기능을 사용할 수 있음
Vue의 공식 상태 관리 라이브러리 === 'Pinia'

2. State management libarary(Pinia)

Vue의 공식 상태 관리 라이브러리

Pinia 구성 요소

1. store

중앙 저장소
모든 컴포넌트가 공유하는 상태, 기능 등이 작성됨

2. state

반응형 상태(데이터)
ref() === state

3. getters

계산된 값
computed() === getters

4. actions

메서드
function() === actions

5. plugin

애플리케이션의 상태 관리에 필요한 추가 기능을 제공하거나 확장하는 도구나 모듈
애플리케이션의 상태 관리를 더욱 간편하고 유연하게 만들어주며 패키지 매니저로 설치 이후 별도 설정을 통해 추가됨

Pinia 구성 요소 종합

Pinia는 store라는 저장소를 가짐
sotre는 state, getters, actions으로 이루어지며 각각 ref(), computed(), function()과 동일함

Pinia 구성 요소 활용

State

store 인스턴스로 state에 접근하여 직접 읽고 쓸 수 있음
만약 store에 state를 정의하지 않았다면 컴포넌트에서 새로 추가할 수 없음

Getters

store의 모든 getters를 state처럼 직접 접근 할 수 있음

Actions

store의 모든 actions를 직접 접근 및 호출할 수 있음
getters와 달리 state 조작, 비동기, API 호출이나 다른 로직을 진행할 수 있음

Router

Thu, 09 Nov 2023 00:01:04 GMT

1. Routing

네트워크에서 경로를 선택하는 프로세스
웹 애플리케이션에서 다른 페이지 간의 전환과 경로를 관리하는 기술

SSR 에서의 Routing

서버가 사용자가 방문한 URL 경로를 기반으로 응답을 전송
링크를 클릭하면 브라우저는 서버로부터 THML 응답을 수신하고 새 HTML로 전체 페이지를 다시 로드
SPA 에서 routing은 브라우저의 클라이언트 측에서 수행
클라이어트 측 JavaScript가 새 데이터를 동적으로 가져와 전체 페이지를 다시 로드하지 않음
페이지는 1개이지만, 링크에 따라 여러 컴포넌트를 렌더링하여 마치 여러 페이지를 사용하는 것처럼 보이도록 해야 함

만약 routing이 없다면

유저가 URL을 통한 페이지의 변화를 감지할 수 없음
페이지가 무엇을 렌더링 중인지에 대한 상태를 알 수 없음
- URL이 1개이기 때문에 새로 고침 시 처음 페이지로 되돌아감
- 링크를 공유할 시 첫 페이지만 공유 가능
브라우저의 뒤로 가기 기능을 사용할 수 없음

2. Vue Router

Vue 공식 라우터 (The official Router for Vue.js) 공식 라우터

Vite로 프로젝트 생성 시 Router 추가

서버 실행 후 Router로 인한 프로젝트 변화 확인

-> Home, About 링크에 따라 변경되는 URL과 새로 렌더링 되는 화면

Vue 프로젝트 구조 변화

1. App.vue 코드 변화

2. router & views 폴더 생성

RouterLink

페이지를 다시 로드하지 않고 RUL을 변경하고 URL 생성 및 관련 로직을 처리
HTML의 a태그를 렌더링

RouterView

URL 에 해당하는 컴포넌트를 표시()
어디에나 배치하여 레이아웃에 맞출 수 있음

router/index.js

라우팅에 관련된 정보 및 설정이 작성 되는 곳
router에 URL(라우트)과 컴포넌트를 매핑(연결)
Django의 urls.py와 유사한 구조를 가지고 있음 (주소, 이름, 컴포넌트 연결)

views

RouterView 위치에 렌더링 할 컴포넌트를 배치 기존 components 폴더와 기능적으로 다른 것은 없으며 단순 분류의 의미로 구성됨 -> 일반 컴포넌트와 구분하기 위해 컴포넌트 이름을 View로 끝나도록 작성하는 것을 권장

Basic Routing

라우팅 기본

index.js에 라우터 관련 설정 작성(주소, 이름, 컴포넌트)

//index.js
const router = createRouter({
    routes: [
      {
          path: '/',
          name: 'home',
          component: HomeView
        },
        ...
      ]
   })

RouterLink의 to속성으로 index.js에서 정의한 주소 속성 값(path)을 사용

Named Routes

경로에 이름을 지정하는 라우팅
name 속성 값에 경로에 대한 이름을 지정
경로에 연결하려면 RouterLink에 v-bind를 사용해 'to' prop 객체로 전달

Named Routes 장점

하드코딩 된 URL을 사용하지 않아도 됨
URL 입력 시 오타 방지

Dynamic Route Matching with Params

매개 변수를 사용한 동적 경로 매칭

주어진 패턴 경로를 동일한 컴포넌트에 매핑 해야 하는 경우 활용
예를 들어 모든 사용자의 ID를 활용하여 프로필 페이지 url을 설계 한다면? 일정한 패턴의 URL 작성을 반복해야 함

매개 변수를 사용한 동적 경로 매칭 활용

UserView 컴포넌트 작성

UserVies 컴포넌트 라우트 등록

 {
   path: '/user/:id',
   name: 'user',
   component: UserView
 }

매개변수는 콜론(:)으로 표기

App.view에 RouterLink 작성하기

라우트의 매개변수는 컴포넌트에서 $route.params로 참조 가능

다만 다음과 같이 Composition API 방식으로 작성하는 것을 권장

프로그래밍 방식 네비게이션

router의 인스턴스 메서드를 사용해 RouterLink로 a태그를 만드는 것처럼 프로그래밍으로 네비게이션 관련 작업을 수행할 수 있음

다른 위치로 이동하기 => router.push()
현재 위치 바꾸기 => router.replace()

router.push()

다른 위치로 이동하기 : Navigate to a different location
다른 URL로 이동하는 메서드
새 항목을 history stack에 push하므로 사용자가 브라우저 뒤로 가기 버튼을 클릭하면 이전 URL로 이동할 수 있음
RouterLink를 클릭했을 때 내부적으로 호출되는 메서드이므로 RouterLink를 클릭하는 것은 router.push()를 호출하는 것과 같음

router.push()활용

UserView 컴포넌트에서 HomeView 컴포넌트로 이동하는 버튼 만들기
```
import { userRoute, useRouter } from 'vue-router'
```

const router = useRouter()

const goHome = function() { router.push({ name: 'home' }) }

참고 : https://router.vuejs.org/guide/essentials/navigation.html

``` jsx
// literal string path
router.push('/users/alice')

//object with path
router.push({ path: '/users/alice' })

//named route with params to let the router build the url
router.push({ name: 'user', params: { username: 'alice' } })

//with query, resulting in /register?plan=private
router.push({ path: '/register', query: {plan: 'private' } })

router.relace()

현재 위치 바꾸기 : Replace current location
push 메서드와 달리 history stack 에 새로운 항목을 push하지 않고 다른 URL로 이동 (=== 이동 전 URL로 뒤로 가기 불가)

Vue router를 통해 특정 URL에 접근할 때 다른 URL로 redirect를 하거나 취소하여 네비게이션을 보호 ex) 인증 정보가 없으면 특정 페이지에 접근하지 못하게 함

종류

1. Globally (전역 가드)

애플리케이션 전역에서 동작
index.js에서 정의

router.beforeEach()

다른 URL로 이동하기 직전에 실행되는 함수
Global Before Guards

router.beforeEach 구조

to : 이동할 URL 정보가 담긴 Route 객체

from : 현재 RUL 정보가 담긴 Route 객체

선택적 반환(return) 값

false

Route Locaion

__false __ - 현재 내비게이션을 취소 - 브라우저 URL이 변경된 경우(사용자가 수동으로 또는 뒤로 버튼을 통해) from 경로의 URL로 재설정

Route Lacation

router.push()를 호출하는 것처럼 경로 위치를 전달하여 다른 위치로 redirect => return이 없다면 'to' URL Route 객체로 이동

router.beforeEach 예시

전역 가드 beforeEach 작성
HomeView에서 UserView로 이동 후 각 인자 값 출력 확인하기

to 에는 이동할 URL인 user 라우트에 대한 정보가, from에는 현재 URL인 home 라우트에 대한 정보가 들어있음

router.beforeEach 활용

사전 준비 : LoginView 컴포넌트 작성 및 라우트 등록

"Login이 되어있지 않다면 페이지 진입을 막고 Login 페이지로 이동시키기"
어떤 RouterLink를 클릭해도 LoginView 컴포넌트만 볼 수 있음
만약 로그인이 되어있지 않고(1), 이동하는 주소 이름이 login이 아니라면(2) login 페이지로 redirect

2. Per-route (라우터 가드)

특정 route 에서만 동작
index.js의 각 routes에 정의

router.beforeEnter()

route에 진입했을 때만 실행되는 함수
매개변수, 쿼리 값이 변경될 때는 실행되지 않고 다른 경로에서 탐색할 때만 실행됨

router.beforeEnter 구조

routes 객체에서 정의
함수의 to, from, 선택 반환인자는 beforeEach와 동일

router.beforeEnter 예시

라우터 가드 beforeEnter 작성
HomeView에서 UserView로 이동 후 각 인자 값 출력 확인하기

to 에는 이동할 URL인 user 라우트에 대한 정보가, from 에는 현재 URL인 home 라우트에 대한 정보가 들어있음
다른 경로에서 user 라우트를 탐색했을 때 실행된 것

router.beforeEnter 활용

"이미 로그인 한 상태라면 LoginView 진입을 막고 HomeView로 이동 시키기" (전역 가드 활용 코드는 주석 처리 후 진행)

이미 로그인 상태라면 HomeView로 이동
로그인 상태가 아니라면 LoginView로 이동

3. In-component (컴포넌트 가드)

특정 컴포넌트 내에서만 동작
컴포넌트 Script에 정의

In-component Guard

onBeforeRouteLeave

현재 라우트에서 다른 라우트로 이동하기 전에 실행
사용자가 현재 페이지를 떠나는 동작에 대한 로직을 처리

사용자가 UserView를 떠날 시 팝업 창 출력하기

// UserView.vue
import {onBeforeRouteLeave} from 'vue-router'

onBeforeRouteLeave((to, from) => {
   const answer = window.confirm('정말 떠나실 건가요?')
     if (answer === false) {
         return false
     }
 })

onBeforeRouteUpdate

이미 렌더링된 컴포넌트가 같은 라우트 내에서 업데이트 되기 전에 실행
라우트 업데이트 시 추가적인 로직을 처리
UserView 페이지에서 다른 id를 가진 User의 Userview 페이지로 이동하기

import { onBeforeRouteUpdate } from 'vue-router'


const routeUpdate = function() {
   router.push({name:'user', params: {id: 100} })
}

onBeforeRouteUpdate((to, from) => {
   userId.value = to.params.id
})

만약 onBeforeRouteUpdate 를 사용하지 않았다면

onBeforeRouteUpdate에서 userId를 변경하지 않으면 userId는 갱신되지 않음
컴포넌트가 재사용되었기 때문

참고

Lazy Loading Routes

첫 빌드 시 해당 컴포넌트를 로드 하지 않고,
해당 경로를 처음으로 방문할 때만 컴포넌트를 로드* 하는 것
- 앱을 빌드할 때 앱의 크기에 따라 페이지 로드 시간이 길어질 수 있기 때문
기존에 “정적 가져오기 방식” 을 “동적 가져오기 방식” 으로 변경과 같음

Component State Flow

Wed, 08 Nov 2023 01:53:58 GMT

1. Passing Props

동일한 사진 데이터가 한 화면에 다양한 위치에서 여러 번 출력되고 있음
하지만 해당 페이지를 구성하는 컴포넌트가 여러 개라면 각 컴포넌트가 개별적으로 동일한 데이터를 관리해야 할까?
그렇다면 사진을 변경해야 할 대 모든 커모넌트에 대해 변경 요청을 해야 함
공통된 부모 컴포넌트에서 관리하자 부모는 자식에게 데이터를 전달(Pass Props)하며, 자식은 자신에게 일어난 일을 부모에게 알림(Emit event) - 직접적으로 전달하는 것은 아님!

Props

부모 컴포넌트로부터 자식 컴포넌트로 데이터를 전달하는데 사용되는 속성

One-Way Data Flow

모든 props는 자식 속성과 부모 속성 사이에 하향식 단방향 바인딩을 형성(one-way-down binding)

Props 특징

부모 속성이 업데이트 되면 자식으로 흐르지만 그 반대는 안됨
즉, 자식 컴포넌트 내부에서 props를 변경하려고 시도해서는 안되며 불가능
또한, 부모 컴포넌트가 업데이트될 때마다 자식 컴포넌트의 모든 props가 최신 값으로 업데이트 됨
부모 컴포넌트에서만 변경하고 이를 내려 받는 자식 컴포넌트는 자연스럽게 갱신

단방향인 이유

하위 컴포넌트가 실수로 상위 컴포넌트의 상태를 변경하여 앱에서의 데이터 흐름을 이해하기 어렵게 만드는 것을 방지하기 위함

사전준비

vue 프로젝트 생성
초기 생성된 컴포넌트 모두 삭제(App.vue제외)
src/assets 내부 파일 모두 삭제
main.js 해당 코드 삭제
```
import './assets/main.css' // 삭제
```

APP > Parent > ParentChild 컴포넌트 관계 작성

1. App 컴포넌트 작성

2. Parent 컴포넌트 작성

ParentChild 컴포넌트 작성

---

## Props 선언
- 부모 컴포넌트에서 보낸 props를 사용하기 위해서는 자식 컴포넌트에서 명시적인 props 선언이 필요

### Props 작성
> 부모 컴포넌트 Parent에서 자식 컴포넌트 ParentChild에 보낼 props 작성![](https://velog.velcdn.com/images/turtle_hw/post/4bac0b71-d69d-4ba4-b7c2-168edbeaf458/image.png)![](https://velog.velcdn.com/images/turtle_hw/post/19d30105-204c-4bb6-b5d1-99f4a6beaa95/image.png)




## Props 선언 2가지 방식
### 1. 문자열 배열을 사용한 선언
- defineProps()를 사용하여 props 를 선언
![](https://velog.velcdn.com/images/turtle_hw/post/1df6b701-605b-479c-b0ca-4531b23410e3/image.png)



### 2. 객체를 사용한 선언
- 객체 선언 문법의 각 객체 속성의 키는 props의 이름이 되며, 객체 속성의 값은 값이 될 데이터의 타입에 해당하는 생성자 함수(Number, String..)여야 함
- 객체 선언 문법 사용 권장
![](https://velog.velcdn.com/images/turtle_hw/post/0eb80810-35ed-4360-bd47-1d9173a6058b/image.png)


---

## prop 데이터 사용
- 템플릿에서 반응형 변수와 같은 방식으로 활용
![](https://velog.velcdn.com/images/turtle_hw/post/d9e4ec10-21f5-4278-a0f0-ff3c94589939/image.png)

- props를 객체로 반환하므로 필요한 경우 JavaScript 에서 접근 가능
![](https://velog.velcdn.com/images/turtle_hw/post/10f5e387-9cab-4c92-9abf-0b9ce0eb9a96/image.png)


### 한 단계 더 prop 내려 보내기 
- ParentChild 컴포넌트를 부모로 갖는 ParentGrandChild 컴포넌트 생성 및 등록
```jsx

ParentChild 컴포넌트에서 Parent로부터 받은 prop인 myMsg를 ParentGrnadChild에게 전달

Props 세부사항

1. Props Name Casing(Props 이름 컨벤션)

선언 및 템플릿 참조 시 => camelCase

자식 컴포넌트로 전달 시 => kebab-case

-> 기술적으로 camelCase도 가능하나 HTML 속성 표기법과 동일하게 kebab-case로 표기할 것을 권장

2. Static Props & Dynamic Props

지금까지 작성한 것은 Static(정적) props
v-bind 를 사용하여 동적으로 할당된 props를 사용할 수 있음

Dynamic props 정의
Dynamic props 선언 및 출력

2. Component Events

💡 부모는 자식에게 데이터를 전달(Pass Props)하며, 자식은 자신에게 일어난 일을 부모에게 알림(Emit event) 부모가 prop 데이터를 변경하도록 소리쳐야 한다

$emit()

자식 컴포넌트가 이벤트를 발생시켜 부모 컴포넌트로 데이터를 전달하는 역할의 메서드
$ 표기는 Vue 인스턴스나 컴포넌트 내에서 제공되는 전역 속성이나 메서드를 식별하기 위한 접두어

event
- 커스텀 이벤트 이름 -> 부모가 캐치
args
- 추가 인자

Event 발신 및 수신(Emitting and Listening to Events)

$emit을 사용하여 템플릿 표현식에서 직접 사용자 정의 이벤트를 발신
그러면 부모는 v-on을 사용하여 수신할 수 있음

이벤트 발신 및 수신하기

ParentChild 에서 someEvent 라는 이름의 사용자 정의 이벤트를 발신

ParentChild의 부모 Parent는 v-on을 사용하여 발신된 이벤트를 수신
수신 후 처리할 로직 및 콜백함수 호출

emit 이벤트 선언

defineEmits() 를 사용하여 명시적으로 발신할 이벤트를 선언할 수 있음
script 에서 $meit 메서드를 접근할 수 없기 때문에 defineEmits() 는 $emit 대신 사용할 수 있는 동등한 함수를 반환

이벤트 선언하기

이벤트 선언 방식으로 추가 버튼 작성 및 결과 확인

Event 인자

이벤트 발신 시 추가 인자를 전달하여 값을 제공할 수 있음
이벤트인자 전달하기
ParentChild에서 이벤트를 발신하여 Parent로 추가 인자 전달하기
```
const emit = defineEmits(['someEvent', 'emitArgs'])
const emitArgs= function () {
  emit('emitArgs',1,2,3)
}
```

ParentChild에서 발신한 이벤트를 Parent에서 수신

const getNumbers=function (...args) { console.log(args) console.log(ParentChild가 전달한 추가인자 ${args}를 수신했어요) }

Event 세부사항
----------

### Event Name Casing

*   선언 및 발신 시 ( -> camelCase)
![](https://velog.velcdn.com/images/turtle_hw/post/b6a4734a-6f09-4a8e-980e-8b49a9cc6e50/image.png)

*   부모 컴포넌트로 수신 시 ( -> kebab-case)
![](https://velog.velcdn.com/images/turtle_hw/post/865f83b4-16fc-4c95-bb00-aabe09f42cf5/image.png)

---

### emit 이벤트 실습

> 최하단 컴포넌트 ParentGrandChild에서 Parent 컴포넌트의 name 변수 변경 요청하기
![](https://velog.velcdn.com/images/turtle_hw/post/5f8f85a2-b224-4c74-a547-a4074451e486/image.png)

---

- ParentGrandChild에서 이름 변경을 요청하는 이벤트 발신
![](https://velog.velcdn.com/images/turtle_hw/post/a5cfbfcb-7c57-408e-a897-efc11a252faa/image.png)
![](https://velog.velcdn.com/images/turtle_hw/post/b5df862c-2418-4a5f-b6a8-6a2390a0d57f/image.png)

---

- 이벤트 수신 후 이름 변경을 요청하는 이벤트 발신
![](https://velog.velcdn.com/images/turtle_hw/post/d648e12b-1925-4e0a-b6dd-759a8d965f98/image.png)

---


- 이벤트 수신 후 이름 변수 변경 메서드 호출
- 해당 변수를 prop 으로 받는 모든 곳에서 자동 업데이트
![](https://velog.velcdn.com/images/turtle_hw/post/e9470b7b-e629-415b-80e1-47e829edca6d/image.png)
```js
const updateName = function() {
  name.value = 'Bella'
}

참고

정적 & 동적 props 주의사항

첫 번째는 정적 props로 문자열로써의 "1"을 전달

두 번째는 동적 props로 숫자로써의 1을 전달

Prop 선언을 객체 선언 문법으로 권장하는 이유

prop에 타입을 지정하는 것은 컴포넌트를 가독성이 좋게 문서화하는데 도움이 되며, 다른 개발자가 잘못된 유형을 전달할 때에 브라우저 콘솔에 경고를 출력하도록 함
추가로 prop에 대한 유효성 검사 로써 활용 가능 https://vuejs.org/guide/components/props.html#prop-validation

emit 이벤트도 객체 선언 문법으로 작성 가능

props 타입 유효성 검사와 유사하게 emit 이벤트 또한 객체 구문으로 선언 된 경우 유효성을 검사할 수 있음
https://vuejs.org/guide/components/events.html#events-validation

Basic Syntax(2)

Mon, 06 Nov 2023 02:58:17 GMT

1. Computed Property

computed()

계산된 속성을 정의하는 함수
미리 계산된 속성을 사용하여 템플릿에서 표현식을 단순하게 하고 불필요한 반복 연산을 줄임
computed 기본 예시, 적용


      
        남은 할 일
            // 1번째 방법
        {{ restOfTodos }}
            // 메서드 활용방법
         {{ getRestofTodos() }}

반응성 데이터를 포함하는 복잡한 로직의 경우 computed를 활용하여 미리 값을 계산

computed 특징

반환되는 값은 computed ref 이며 일반 refs와 유사하게 계산된 결과를 .value로 참조할 수 있음(템플릿에서는 자동으로 wrapping 되기 때문에 .value 생략 가능)
computed 속성은 의존된 반응형 데이터를 자동으로 추적
의존하는 데이터가 변경될 때만 재평가
- restOftodos의 계산은 todos에 의존하고 있음
- 따라서 todos가 변경될 때만 resOftodos가 업데이트 됨

Computed vs Methods

computed 속성 대신 method 로도 동일한 기능을 정의할 수 있음

두 가지 접근 방식은 실제로 완전히 동일

computed 와 method의 차이

computed 속성은 의존된 반응형 데이터를 기반으로 캐시 된다. ( 매번 재평가하지 않는다)
의존하는 데이터가 변경된 경우에만 재평가됨
즉, 의존된 반응형 데이터가 변경되지 않는 한 이미 계산된 결과에 대한 여러 참조는 다시 평가할 필요 없이 이전에 계산된 결과를 즉시 반환
💡 반면, method 호출은 다시 렌더링이 발생할 때마다 항상 함수를 실행

캐시(Cache)

데이터나 결과를 일시적으로 저장해두는 임시 저장소
이후에 같은 데이터나 결과를 다시 계산하지 않고 빠르게 접근할 수 있도록 함 ex. 웹 페이지의 캐시 데이터 -> 페이지 일부 데이터를 브라우저 캐시에 저장 후 같은 페이지에 다시 요청 시 모든 데이터를 다시 응답 받는 것이 아닌 캐시 된 데이터를 사용하여 더 빠르게 웹 페이지를 렌더링

computed 와 method 의 적절한 사용처

computed

의존하는 데이터에 따라 결과가 바뀌는 계산된 속성을 만들 때 유용
동일한 의존성을 가진 여러 곳에서 사용할 때 계산 결과를 캐싱하여 중복 계산 방지

의존된 데이터가 변경되면 자동으로 업데이트

method

단순히 특정 동작을 수행하는 함수를 정의할 때 사용
데이터에 의존하는지 여부와 관계없이 항상 동일한 결과를 반환하는 함수

호출해야만 실행됨 💡 무조건 computed만 사용하는 것이 아니라 사용목적과 상황에 맞게 computed와 method를 적절히 조합하여 사용

2. Conditional Rendering

Conditional Rendering

v-if

표현식의 T/F를 기반으로 요소를 조건부로 렌더링

'v-else' directive를 사용하여 v-if 에 대한 else 블록을 나타낼 수 있음

  const app = createApp({
    setup() {
      const isSeen = ref(true)

      return {
        isSeen,
      }
    }
  })

   
    true일때 보여요
    false일때 보여요

다른 것들은 아예 렌더링도 되지 않았음을 볼 수 있음


    Alice입니다
    Bella입니다
    Cathy입니다
    아무도 아닙니다.

다른 것들은 아예 렌더링도 되지 않았음을 볼 수 있음

HTML

배열의 인덱스를 v-for의 key로 사용하지 말 것

- 인덱스는 식별자가 아닌 배열의 항목 위치만 나타내기 때문에 Vue가 DOM을 변경 할 때 (끝이 아닌 위치에 새 항목이 배열에 삽입되면) 여러 컴포넌트간 데이터 공유 시 문제가 발생
- 직접 고유한 값을 만들어내는 메서드를 만들거나 외부 라이브러리 등을 활용하는 등 식별자 역할을 할 수 있는 값을 만들어 사용



템플릿의 참조에 접근하려면 setup 함수에서 선언 및 반환 필요
템플릿에서 ref를 사용할 때는 .value를 작성할 필요 없음(automatically unwrapped

action과 method 속성은 삭제(요청은 axios 로 대체되기 때문)

url에 작성할 user pk 가져오기(HTML => JavaScript)