Update

Author: ndb796

Diff for: Exams/solutions/A_1.py

@@ -0,0 +1,6 @@
+n = int(input())
+a = list(map(int, input().split()))
+a.sort()
+
+# Median(가운데) 값을 출력합니다.
+print(a[(n - 1) // 2])

Diff for: Exams/solutions/A_2.py

@@ -0,0 +1,17 @@
+n, k = map(int, input().split())
+a = list(map(int, input().split()))
+result = 0
+
+def dfs(x):
+    global result
+    # n보다 작거나 같은 자연수에 대해서만 확인
+    if x > n:
+        return
+    # K의 원소로만 구성된 가장 큰 수를 저장
+    result = max(x, result)
+    for i in a:
+        # K의 원소로만 구성된 모든 수를 탐색
+        dfs(x * 10 + i)
+
+dfs(0)
+print(result)

Diff for: Exams/solutions/A_3.py

@@ -0,0 +1,40 @@
+from collections import deque
+
+n, m = map(int, input().split())
+x, y = map(int, input().split())
+
+# 모든 상대편 말의 위치를 저장
+enemy = []
+for i in range(m):
+    a, b = map(int, input().split())
+    enemy.append((a, b))
+
+# 보드 전체를 -1으로 초기화
+board = [[-1] * (n + 1) for _ in range(n + 1)]
+# 나이트가 이동할 수 있는 8가지의 위치
+dx = [-2, -2, -1, -1, 1, 1, 2, 2]
+dy = [-1, 1, -2, 2, -2, 2, -1, 1]
+
+# 현재 위치를 큐에 삽입
+q = deque()
+q.append((x, y))
+# 현재 위치에 대한 최소 이동 수는 0
+board[x][y] = 0
+
+# 보드의 모든 위치에 대하여 최소 이동 수를 계산
+while q:
+    x, y = q.popleft()
+    # 8가지 위치를 각각 확인
+    for i in range(8):
+        nx = x + dx[i]
+        ny = y + dy[i]
+        # 해당 위치로 이동할 수 있는 경우
+        if 1 <= nx and nx <= n and 1 <= ny and ny <= n:
+            # 방문한 적 없다면, 그 위치로의 최소 이동 수 계산
+            if board[nx][ny] == -1:
+                board[nx][ny] = board[x][y] + 1
+                q.append((nx, ny))
+
+# 모든 상대편 말까지의 최소 이동 수 출력
+for a, b in enemy:
+    print(board[a][b], end=' ')

Diff for: Exams/solutions/B_1.py

@@ -0,0 +1,19 @@
+n, k = map(int, input().split())
+data = list(map(int, input().split()))
+
+course = []
+for i in range(n):
+    # (해당 코스의 번호, 해당 코스의 길이)를 입력
+    course.append((i + 1, data[i]))
+# 왕복 코스를 직선 형태로 표현
+course.extend(list(reversed(course)))
+
+# 코스의 길이를 앞에서부터 빼내기
+i = 0
+while True:
+    k -= course[i][1]
+    # 지나고 있는 코스 출력 및 종료
+    if k < 0:
+        print(course[i][0])
+        break
+    i += 1

Diff for: Exams/solutions/B_2.py

@@ -0,0 +1,14 @@
+n = int(input())
+data = list(map(int, input().split()))
+# 순서를 바꾸어 '최장 증가 부분 수열' 문제로 변환
+data.reverse()
+
+# LCS 알고리즘 수행
+dp = [1] * n
+for i in range(1, n):
+    for j in range(0, i):
+        if data[j] < data[i]:
+            dp[i] = max(dp[i], dp[j] + 1)
+
+# 열외해야 하는 병사의 최소 수를 출력
+print(n - max(dp))

Diff for: Exams/solutions/B_3.py

@@ -0,0 +1,43 @@
+from collections import deque
+n, k = map(int, input().split())
+
+# N x N 크기의 보드 전체를 0으로 초기화
+board = []
+data = [] 
+
+for i in range(n):
+    # 보드 정보를 한 줄 단위로 입력
+    board.append(list(map(int, input().split())))
+    for j in range(n):
+        # 해당 위치에 바이러스가 존재하는 경우
+        if board[i][j] != 0:
+            # (바이러스 종류, 시간, 위치 X, 위치 Y) 삽입
+            data.append((board[i][j], 0, i, j))
+
+# 정렬 이후에 큐로 옮기기
+data.sort()
+q = deque(data)
+ 
+target_s, target_x, target_y = map(int, input().split())
+ 
+# 바이러스가 퍼져나갈 수 있는 4가지의 위치
+dx = [-1, 0, 1, 0]
+dy = [0, 1, 0, -1]
+ 
+while q:
+    virus, s, x, y = q.popleft()
+    # 정확히 s초가 지나거나, 큐가 빌 때까지 반복
+    if s == target_s:
+        break
+    # 4가지 위치를 각각 확인
+    for i in range(4):
+        nx = x + dx[i]
+        ny = y + dy[i]
+        # 해당 위치로 이동할 수 있는 경우
+        if 0 <= nx and nx < n and 0 <= ny and ny < n:
+            # 방문한 적 없다면, 그 위치에 바이러스 넣기
+            if board[nx][ny] == 0:
+                board[nx][ny] = virus
+                q.append((virus, s + 1, nx, ny))
+
+print(board[target_x - 1][target_y - 1])

Diff for: Exams/solutions/C_1.py

@@ -0,0 +1,15 @@
+n, k = map(int, input().split())
+count = 0
+ 
+# 0시 0분 0초부터 N시 59분 59초까지의 모든 시각 확인
+for h in range(n + 1):
+    for m in range(60):
+        for s in range(60):
+            hour = str(h) if h >= 10 else '0' + str(h)
+            minute = str(m) if m >= 10 else '0' + str(m)
+            second = str(s) if s >= 10 else '0' + str(s)
+            # K가 포함되는 경우 카운트
+            if str(k) in hour + minute + second:
+                count += 1
+
+print(count)

Diff for: Exams/solutions/C_2.py

@@ -0,0 +1,22 @@
+n, m, h = map(int, input().split())
+a = []
+d = [0] * (h + 1)
+for i in range(n):
+    a.append(list(map(int, input().split())))
+
+d[0] = 1
+
+# 모든 학생에 대하여 처리
+for i in range(n):
+    data = []
+    # 0부터 h까지의 모든 높이에 대하여 처리
+    for j in range(h + 1):
+        for k in range(len(a[i])):
+            # 현재 학생의 블록으로 특정 높이의 탑을 쌓을 수 있는 경우
+            if d[j] != 0 and j + a[i][k] <= h:
+                data.append((j + a[i][k], d[j]))
+    # 쌓을 수 있는 높이에 대하여, 경우의 수 증가
+    for height, value in data:
+        d[height] = (d[height] + value) % 10007
+
+print(d[h])

Diff for: Exams/solutions/C_3.py

@@ -0,0 +1,78 @@
+from itertools import combinations
+
+n = int(input())
+a = []
+teachers = []
+spaces = []
+for i in range(n):
+    a.append(list(input().split()))
+    for j in range(n):
+        # 선생님이 존재하는 위치 저장
+        if a[i][j] == 'T':
+            teachers.append((i, j))
+        # 장애물을 설치할 수 있는 위치 저장
+        if a[i][j] == 'X':
+            spaces.append((i, j))
+
+# 특정 방향으로 감시를 진행 (학생 발견: True, 학생 미발견: False)
+def watch(x, y, direction):
+    # 왼쪽 방향으로 감시
+    if direction == 0:
+        while y >= 0:
+            if a[x][y] == 'S': # 학생이 있는 경우
+                return True
+            if a[x][y] == 'O': # 장애물이 있는 경우
+                return False
+            y -= 1
+    # 오른쪽 방향으로 감시
+    if direction == 1:
+        while y < n:
+            if a[x][y] == 'S': # 학생이 있는 경우
+                return True
+            if a[x][y] == 'O': # 장애물이 있는 경우
+                return False
+            y += 1
+    # 위쪽 방향으로 감시
+    if direction == 2:
+        while x >= 0:
+            if a[x][y] == 'S': # 학생이 있는 경우
+                return True
+            if a[x][y] == 'O': # 장애물이 있는 경우
+                return False
+            x -= 1
+    # 아래쪽 방향으로 감시
+    if direction == 3:
+        while x < n:
+            if a[x][y] == 'S': # 학생이 있는 경우
+                return True
+            if a[x][y] == 'O': # 장애물이 있는 경우
+                return False
+            x += 1
+    return False
+
+# 장애물 설치 이후에, 한 명이라도 학생이 감지되는지 검사
+def process():
+    # 모든 선생의 위치를 하나씩 확인
+    for x, y in teachers:
+        # 4가지 방향으로 학생을 감지할 수 있는지 확인
+        for i in range(4):
+            if watch(x, y, i):
+                return True
+    return False
+
+find = False
+for data in combinations(spaces, 3):
+    for x, y in data:
+        a[x][y] = 'O'
+    # 학생이 한 명도 감지되지 않는 경우
+    if not process():
+        # 원하는 경우를 발견한 것임
+        find = True
+        break
+    for x, y in data:
+        a[x][y] = 'X'
+
+if find:
+    print('YES')
+else:
+    print('NO')

Diff for: Exams/solutions/D_1.py

@@ -0,0 +1,16 @@
+n = input()
+length = len(n)
+sum = 0
+
+# 왼쪽 부분의 자릿수의 합 더하기
+for i in range(length // 2):
+    sum += int(n[i])
+
+# 오른쪽 부분의 자릿수의 합 빼기
+for i in range(length // 2, length):
+    sum -= int(n[i])
+
+if sum == 0:
+    print("LUCKY")
+else:
+    print("READY")

Diff for: Exams/solutions/D_2.py

@@ -0,0 +1,23 @@
+from itertools import permutations
+
+n, k = map(int, input().split())
+a = list(map(int, input().split()))
+result = 0
+
+# 운동 키트를 이용하는 모든 경우를 계산
+for data in permutations(a):
+    check = True
+    weight = 500
+    # 매일매일의 운동 키트를 확인
+    for i in data:
+        weight += i
+        weight -= k
+        # 중량이 500보다 낮아지는 날이 있는지 체크
+        if weight < 500:
+            check = False
+            break
+    # 매일매일 항상 중량 500 이상이라면, 카운트
+    if check:
+        result += 1
+
+print(result)

Diff for: Exams/solutions/D_3.py

@@ -0,0 +1,40 @@
+n, m = map(int, input().split())
+
+board = []
+for _ in range(n):
+    board.append(list(map(int, input().split())))
+v = [[False] * m for _ in range(n)]
+
+def dfs(x, y):
+    # 아래 끝까지 내려 온 경우 0을 반환
+    if x == n:
+        return 0
+    # 오른쪽 끝까지 이동한 경우 아래로 한 칸 내려가기
+    if y == m:
+        return dfs(x + 1, 0)
+    result = 0
+    # (x, y)를 기준으로 1번째 모양
+    if x + 1 < n and y + 1 < m and v[x][y] + v[x][y + 1] + v[x + 1][y + 1] == 0:
+        v[x][y] = v[x][y + 1] = v[x + 1][y + 1] = True
+        result = max(result, dfs(x, y + 1) + (board[x][y] + 2 * board[x][y + 1] + board[x + 1][y + 1]))
+        v[x][y] = v[x][y + 1] = v[x + 1][y + 1] = False
+    # (x, y)를 기준으로 2번째 모양
+    if x + 1 < n and y + 1 < m and v[x][y + 1] + v[x + 1][y] + v[x + 1][y + 1] == 0:
+        v[x][y + 1] = v[x + 1][y] = v[x + 1][y + 1] = True
+        result = max(result, dfs(x, y + 1) + (board[x][y + 1] + board[x + 1][y] + 2 * board[x + 1][y + 1]))
+        v[x][y + 1] = v[x + 1][y] = v[x + 1][y + 1] = False
+    # (x, y)를 기준으로 3번째 모양
+    if x + 1 < n and y + 1 < m and v[x][y] + v[x + 1][y] + v[x + 1][y + 1] == 0:
+        v[x][y] = v[x + 1][y] = v[x + 1][y + 1] = True
+        result = max(result, dfs(x, y + 1) + (board[x][y] + 2 * board[x + 1][y] + board[x + 1][y + 1]))
+        v[x][y] = v[x + 1][y] = v[x + 1][y + 1] = False
+    # (x, y)를 기준으로 4번째 모양
+    if x + 1 < n and y + 1 < m and v[x][y] + v[x][y + 1] + v[x + 1][y] == 0:
+        v[x][y] = v[x][y + 1] = v[x + 1][y] = True
+        result = max(result, dfs(x, y + 1) + (2 * board[x][y] + board[x][y + 1] + board[x + 1][y]))
+        v[x][y] = v[x][y + 1] = v[x + 1][y] = False
+    # 현재 위치를 기준으로 부메랑을 만들지 않는 경우
+    result = max(result, dfs(x, y + 1))
+    return result
+
+print(dfs(0, 0))

Diff for: Exams/solutions/E_1.py

@@ -0,0 +1,17 @@
+# 100 x 100 x 100보다 큰 수로, 최적의 해 보장
+MAX_VALUE = 10000000
+x, y, p1, p2 = map(int, input().split())
+
+# 모든 경우의 수를 포함하는 10,000,000까지 반복
+while p1 != p2 and p1 < MAX_VALUE:
+    if p1 < p2:
+        p1 += x
+    else:
+        p2 += y
+
+# 공통적으로 지나는 지점이 있다면
+if p1 < MAX_VALUE:
+    print(p1)
+# 공통적으로 지나는 지점이 없다면
+else:
+    print(-1)