22.11.16 : 가랏! RC카!, 백만 장자 프로젝트, 두 개의 숫자열, 달팽이 숫자
1940. 가랏! RC카!
RC (Radio Control) 카의 이동거리를 계산하려고 한다. 입력으로 매 초마다 아래와 같은 command 가 정수로 주어진다.
0 : 현재 속도 유지.
1 : 가속
2 : 감속
위 command 중, 가속(1) 또는 감속(2) 의 경우 가속도의 값이 추가로 주어진다.
가속도의 단위는, m/s2 이며, 모두 양의 정수로 주어진다.
입력으로 주어진 N개의 command 를 모두 수행했을 때, N초 동안 이동한 거리를 계산하는 프로그램을 작성하라.
RC 카의 초기 속도는 0 m/s 이다.
[예제]
아래 예제 입력에서 정답은 3 이 된다.
| 입력 | 시간 | RC 카의 속도 RC | 카의 이동거리 |
|---|---|---|---|
| (1) 2 | 1 sec | 2 m/s | 2 m |
| (2) 1 | 2 sec | 1 m/s | 3 m |
[제약사항]
1. N은 2이상 30이하의 정수이다. (2 ≤ N ≤ 30)
2. 가속도의 값은 1 m/s2 혹은 2 m/s2 이다.
3. 현재 속도보다 감속할 속도가 더 클 경우, 속도는 0 m/s 가 된다.
[입력]
입력은 첫 줄에 총 테스트 케이스의 개수 T, 다음 줄부터 각 테스트 케이스가 주어진다.
테스트 케이스 첫 줄에는 Command 의 수 N이 주어지고, 둘째 줄부터, 매 줄마다 각각의 Command가 주어진다.
[출력]
테스트 케이스 t에 대한 결과는 “#t”을 찍고, 한 칸 띄고, 정답을 출력한다.
(t는 테스트 케이스의 번호를 의미하며 1부터 시작한다.)
T = int(input())
for test_case in range(1, T + 1):
n = int(input())
speed = 0
distance = 0
for _ in range(n):
command = input().split()
if command[0] == '0':
pass
elif command[0] == '1': #가속
speed += int(command[1])
else: #감속
speed = max(0, speed - int(command[1]))
distance += speed
print(f"#{test_case} {distance}")T = int(input())
for t in range(1, T+1) :
N = int(input())
length = 0
v = 0
for i in range(N) :
value = input().split()
if value[0] == '0' :
v = v
length += v
elif value[0] == '1' :
v += int(value[1])
length += v
else :
if int(value[1]) > v :
v = 0
length = length
else :
v -= int(value[1])
length += v
print("#{} {}".format(t, length))1859. 백만 장자 프로젝트
25년 간의 수행 끝에 원재는 미래를 보는 능력을 갖게 되었다. 이 능력으로 원재는 사재기를 하려고 한다.
다만 당국의 감시가 심해 한 번에 많은 양을 사재기 할 수 없다.
다음과 같은 조건 하에서 사재기를 하여 최대한의 이득을 얻도록 도와주자.
1. 원재는 연속된 N일 동안의 물건의 매매가를 예측하여 알고 있다.
2. 당국의 감시망에 걸리지 않기 위해 하루에 최대 1만큼 구입할 수 있다.
3. 판매는 얼마든지 할 수 있다.예를 들어 3일 동안의 매매가가 1, 2, 3 이라면 처음 두 날에 원료를 구매하여
마지막 날에 팔면 3의 이익을 얻을 수 있다.
[입력]
첫 번째 줄에 테스트 케이스의 수 T가 주어진다.
각 테스트 케이스 별로 첫 줄에는 자연수 N(2 ≤ N ≤ 1,000,000)이 주어지고,
둘째 줄에는 각 날의 매매가를 나타내는 N개의 자연수들이 공백으로 구분되어 순서대로 주어진다.
각 날의 매매가는 10,000이하이다.
[출력]
각 테스트 케이스마다 ‘#x’(x는 테스트케이스 번호를 의미하며 1부터 시작한다)를 출력하고, 최대 이익을 출력한다.
[예제 풀이]
1번째 케이스는 아무 것도 사지 않는 것이 최대 이익이다.
2번째 케이스는 1,2일에 각각 한 개씩 사서 세 번째 날에 두 개를 팔면 10의 이익을 얻을 수 있다.
T = int(input())
for test_case in range(1, T + 1):
n = int(input())
price = list(map(int, input().split()))
profit = 0
max_price = price[-1]
for i in range(n - 2, -1, -1):
if price[i] < max_price:
profit += (max_price - price[i])
else:
max_price = price[i]
print(f"#{test_case} {profit}")1959. 두 개의 숫자열
링크텍스트
N 개의 숫자로 구성된 숫자열 Ai (i=1~N) 와 M 개의 숫자로 구성된 숫자열 Bj (j=1~M) 가 있다.
아래는 N =3 인 Ai 와 M = 5 인 Bj 의 예이다. Ai 나 Bj 를 자유롭게 움직여서 숫자들이 서로 마주보는 위치를 변경할 수 있다. 단, 더 긴 쪽의 양끝을 벗어나서는 안 된다.
서로 마주보는 숫자들을 곱한 뒤 모두 더할 때 최댓값을 구하라. 위 예제의 정답은 아래와 같이 30 이 된다.
[제약 사항]
N 과 M은 3 이상 20 이하이다.
[입력]
가장 첫 줄에는 테스트 케이스의 개수 T가 주어지고, 그 아래로 각 테스트 케이스가 주어진다. 각 테스트 케이스의 첫 번째 줄에 N 과 M 이 주어지고, 두 번째 줄에는 Ai, 세 번째 줄에는 Bj 가 주어진다.
[출력]
출력의 각 줄은 '#t'로 시작하고, 공백을 한 칸 둔 다음 정답을 출력한다. (t는 테스트 케이스의 번호를 의미하며 1부터 시작한다.)
T = int(input())
for test_case in range(1, T + 1):
n, m = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
answer = 0
for i in range(abs(n - m) + 1):
temp = 0
for j in range(min(n, m)):
if n > m:
temp += (a[j + i] * b[j])
else:
temp += (a[j] * b[j + i])
answer = max(answer, temp)
print(f'#{test_case} {answer}')T = int(input())
for test_case in range(1, T + 1):
n, m = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
# N과 M의 순서가 바뀌면, 다음에 따라오는 A, B의 순서도 바뀜
if N > M:
N, M = M, N # M이 큰 숫자를 가지도록 설정
A, B = B, A
max_sum = 0
# 작은 열과 더 많은 열을 돌릴 수 있는 최대의 수는 M-N+1 규칙성
for i in range(M-N+1):
# 항상 작은 박스열의 전체 길이에 맞춰 인덱스가 돌아감
temp = 0
for j in range(N):
temp += A[j] * B[j+i]
if temp > max_sum:
max_sum = temp
print(f'#{test_case} {max_sum}')1288. 새로운 불면증 치료법
민석이는 불면증에 걸렸다. 그래서 잠이 안 올 때의 민간요법 중 하나인 양 세기를 하려고 한다.
민석이는 1번 양부터 순서대로 세는 것이 재미없을 것 같아서 N의 배수 번호인 양을 세기로 하였다.
즉, 첫 번째에는 N번 양을 세고, 두 번째에는 2N번 양, … , k번째에는 kN번 양을 센다.
이렇게 숫자를 세던 민석이에게 잠은 더 오지 않고 다음과 같은 궁금증이 생겼다.
이전에 셌던 번호들의 각 자리수에서 0에서 9까지의 모든 숫자를 보는 것은 최소 몇 번 양을 센 시점일까?
예를 들어 N = 1295이라고 하자.
첫 번째로 N = 1295번 양을 센다. 현재 본 숫자는 1, 2, 5, 9이다.
두 번째로 2N = 2590번 양을 센다. 현재 본 숫자는 0, 2, 5, 9이다.
현재까지 본 숫자는 0, 1, 2, 5, 9이다.
세 번째로 3N = 3885번 양을 센다. 현재 본 숫자는 3, 5, 8이다.
현재까지 본 숫자는 0, 1, 2, 3, 5, 8, 9이다.
네 번째로 4N = 5180번 양을 센다. 현재 본 숫자는 0, 1, 5, 8이다.
현재까지 본 숫자는 0, 1, 2, 3, 5, 8, 9이다.
다섯 번째로 5N = 6475번 양을 센다. 현재 본 숫자는 4, 5, 6, 7이다.
현재까지 본 숫자는 0, 1, 2, 3, 4, 5, 6, 7, 8, 9이다.
5N번 양을 세면 0에서 9까지 모든 숫자를 보게 되므로 민석이는 양 세기를 멈춘다.
[입력]
첫 번째 줄에 테스트 케이스의 수 T가 주어진다.
각 테스트 케이스의 첫 번째 줄에는 N (1 ≤ N ≤ 106)이 주어진다.
[출력]
각 테스트 케이스마다 ‘#x’(x는 테스트케이스 번호를 의미하며 1부터 시작한다)를 출력하고,
최소 몇 번 양을 세었을 때 이전에 봤던 숫자들의 자릿수에서 0에서 9까지의 모든 숫자를 보게 되는지 출력한다.( 민석이는 xN번 양을 세고 있다. )
T = int(input())
for test_case in range(1, T+1):
N = int(input())
count = 0
zero_to_nine = [str(i) for i in range(10)]
while zero_to_nine:
count += 1
room = N * count
room = str(room) #숫자 문자열 취급
for c in room:
if c in zero_to_nine:
zero_to_nine.remove(c)
print('#{} {}'.format(test_case, room))T = int(input())
for test_case in range(1, T+1) :
N = int(input())
listA = [0]*10
i = 0
while(True) :
if 0 not in listA :
break
else :
i += 1
num = str(N*i)
for j in range(len(num)) :
listA[int(num[j])] = 1
print("#{} {}".format(test_case, num))1948. 날짜 계산기
월 일로 이루어진 날짜를 2개 입력 받아, 두 번째 날짜가 첫 번째 날짜의 며칠째인지 출력하는 프로그램을 작성하라.
[제약 사항]
월은 1 이상 12 이하의 정수이다. 각 달의 마지막 날짜는 다음과 같다.
1/31, 2/28, 3/31, 4/30, 5/31, 6/30, 7/31, 8/31, 9/30, 10/31, 11/30, 12/31
두 번째 날짜가 첫 번째 날짜보다 항상 크게 주어진다.
[입력]
가장 첫 줄에는 테스트 케이스의 개수 T가 주어지고, 그 아래로 각 테스트 케이스가 주어진다.
각 테스트 케이스의 첫 번째 줄에는 4개의 수가 주어진다.
첫 번째 수가 월을 나타내고 두 번째 수가 일을 나타낸다. 그 다음 같은 형식으로 두 번째 날짜가 주어진다.
[출력]
출력의 각 줄은 '#t'로 시작하고, 공백을 한 칸 둔 다음 정답을 출력한다. (t는 테스트 케이스의 번호를 의미하며 1부터 시작한다.)
T = int(input())
for test_case in range(1, T + 1):
a, b, c, d = map(int, input().split())
calendar = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
answer = d - b + 1 # a,c="월" / b,d="일" #ex) 30 - 31 + 1 = 0
for i in range(a, c): #월->일(for문)
answer += calendar[i]
print(f"#{test_case} {answer}")
#for i in range(1, 4): #월->일(for문)
#calendar[1] + calendar[2] + calendar[3] + calendar[4] = 31+28+31+30T = int(input())
for t in range(1, T+1) :
m1, d1, m2, d2 = map(int, input().split())
month = {1:31, 2:28, 3:31, 4:30, 5:31, 6:30, 7:31, 8:31, 9:30, 10:31, 11:30, 12:31}
answer = 0
for i in range(m1, m2) :
if m1 == i :
answer += month[i] - d1 + 1
else :
answer += month[i]
answer += d2
print("#{} {}".format(t, answer))1204. 최빈수 구하기
어느 고등학교에서 실시한 1000명의 수학 성적을 토대로 통계 자료를 만들려고 한다.
이때, 이 학교에서는 최빈수를 이용하여 학생들의 평균 수준을 짐작하는데, 여기서 최빈수는 특정 자료에서 가장 여러 번 나타나는 값을 의미한다.
다음과 같은 수 분포가 있으면 : 10, 8, 7, 2, 2, 4, 8, 8, 8, 9, 5, 5, 3
최빈수는 8이 된다. 최빈수를 출력하는 프로그램을 작성하여라 (단, 최빈수가 여러 개 일 때에는 가장 큰 점수를 출력하라).
[제약 사항]
학생의 수는 1000명이며, 각 학생의 점수는 0점 이상 100점 이하의 값이다.
[입력]
첫 번째 줄에 테스트 케이스의 수 T가 주어진다.
각 테스트 케이스의 첫 줄에는 테스트 케이스의 번호가 주어지고 그 다음 줄부터는 점수가 주어진다.
[출력]
부호와 함께 테스트 케이스의 번호를 출력하고, 공백 문자 후 테스트 케이스에 대한 답을 출력한다.
T = int(input())
for test_case in range(1, T+1):
_testcase = int(input())
array = list(map(int, input().split()))
_max = 0
for value in range(101): #학생의 점수 확인
if array.count(value) == 0:
continue
elif array.count(value) >= array.count(_max):
_max = value
print("#{} {}".format(_testcase, _max))
print(f'#{_testcase} {_max}')1926. 간단한 369게임
3 6 9 게임을 프로그램으로 제작중이다. 게임 규칙은 다음과 같다.
-
숫자 1부터 순서대로 차례대로 말하되, “3” “6” “9” 가 들어가 있는 수는 말하지 않는다.
1 2 3 4 5 6 7 8 9… -
"3" "6" "9"가 들어가 있는 수를 말하지 않는대신, 박수를 친다.
이 때, 박수는 해당 숫자가 들어간 개수만큼 쳐야 한다.
예를 들어 숫자 35의 경우 박수 한 번, 숫자 36의 경우 박수를 두번 쳐야 한다.
입력으로 정수N 이 주어졌을 때, 1~N 까지의 숫자를 게임 규칙에 맞게 출력하는 프로그램을 작성하라.
박수를 치는 부분은 숫자 대신, 박수 횟수에 맞게 “-“ 를 출력한다.
여기서 주의해야 할 것은 박수 한 번 칠 때는 - 이며, 박수를 두 번 칠 때는 - - 가 아닌 -- 이다.
[제약사항]
N은 10이상 1,000이하의 정수이다. (10 ≤ N ≤ 1,000)
[입력]
입력으로 정수 N 이 주어진다.
[출력]
1 ~ N까지의 숫자를 게임 규칙에 맞게 출력한다.
n = int(input())
word = ['3', '6', '9']
for i in range(1, n + 1):
count = 0
for w in word:
if w in str(i):
count += str(i).count(w)
if count == 0:
print(i, end=' ')
else:
print('-' * count, end=' ') # 박수를 치는 개수 선정N = int(input())
clap = ['3', '6', '9']
for i in range(1, N+1):
count = 0
for j in str(i):
if j in clap:
count += 1
if count > 0:
i = '-' * count
print(i, end=' ')1284. 수도 요금 경쟁
삼성전자에 입사한 종민이는 회사 근처로 이사를 하게 되었다.
그런데 집의 위치가 두 수도 회사 A, B 중간에 위치하기에 원하는 수도 회사를 선택할 수 있게 되었는데, 두 회사 중 더 적게 수도 요금을 부담해도 되는 회사를 고르려고 한다.
종민이가 알아본 결과 두 회사의 수도 요금은 한 달 동안 사용한 수도의 양에 따라 다음과 같이 정해진다.
A사 : 1리터당 P원의 돈을 내야 한다.
B사 : 기본 요금이 Q원이고, 월간 사용량이 R리터 이하인 경우 요금은 기본 요금만 청구된다. 하지만 R 리터보다 많은 양을 사용한 경우 초과량에 대해 1리터당 S원의 요금을 더 내야 한다.
[(w - r) * s]
종민이의 집에서 한 달간 사용하는 수도의 양이 W리터라고 할 때, 요금이 더 저렴한 회사를 골라 그 요금을 출력하는 프로그램을 작성하라.
[입력]
첫 번째 줄에 테스트 케이스의 수 T가 주어진다.
각 테스트 케이스마다 첫 번째 줄에 위 본문에서 설명한 대로 P, Q, R, S, W(1 ≤ P, Q, R, S, W ≤ 10000, 자연수)가 순서대로 공백 하나로 구분되어 주어진다.
[출력]
각 테스트 케이스마다 ‘#x’(x는 테스트케이스 번호를 의미하며 1부터 시작한다)를 출력하고, 종민이가 내야 하는 수도 요금을 출력한다.
#B사의 요금식 도출 아이디어
q + max(0, w - r) * sT = int(input())
for test_case in range(1, T + 1):
p, q, r, s, w = map(int, input().split())
answer = min(w * p, q + max(0, w - r) * s)
print(f"#{test_case} {answer}")1983. 조교의 성적 매기기
학기가 끝나고, 학생들의 점수로 학점을 계산중이다.
학점은 상대평가로 주어지는데, 총 10개의 평점이 있다.
A+ A0 A- B+ B0 B- C+ c0 C- D0
학점은 학생들이 응시한 중간/기말고사 점수 결과 및 과제 점수가 반영한다. 각각 아래 비율로 반영된다.
총점 = 중간고사(35%) + 기말고사(45%) + 과제(20%)
10 개의 평점을 총점이 높은 순서대로 부여하는데,
각각의 평점은 같은 비율로 부여할 수 있다.
예를 들어, N 명의 학생이 있을 경우 N/10 명의 학생들에게 동일한 평점을 부여할 수 있다.
입력으로 각각의 학생들의 중간, 기말, 과제 점수가 주어지고,
학점을 알고싶은 K 번째 학생의 번호가 주어졌을 때,
K 번째 학생의 학점을 출력하는 프로그램을 작성하라.
[제약사항]
1. N은 항상 10의 배수이며, 10이상 100이하의 정수이다. (10 ≤ N ≤ 100)
2. K는 1 이상 N 이하의 정수이다. (1 ≤ K ≤ N)
3. K 번째 학생의 총점과 다른 학생의 총점이 동일한 경우는 입력으로 주어지지 않는다.
[입력]
입력은 첫 줄에 총 테스트 케이스의 개수 T가 온다.
다음 줄부터 각 테스트 케이스가 주어진다.
테스트 케이스의 첫 번째 줄은 학생수 N 과, 학점을 알고싶은 학생의 번호 K 가 주어진다.
테스트 케이스 두 번째 줄 부터 각각의 학생이 받은 시험 및 과제 점수가 주어진다.
[출력]
테스트 케이스 t에 대한 결과는 “#t”을 찍고, 한 칸 띄고, 정답을 출력한다.
(t는 테스트 케이스의 번호를 의미하며 1부터 시작한다.)
score = ['A+', 'A0', 'A-', 'B+', 'B0', 'B-', 'C+', 'C0', 'C-', 'D0']
t = int(input())
for tc in range(1, t + 1) :
n, k = map(int, input().split())
data = []
for _ in range(n) :
a, b, c = map(int, input().split())
sum_value = (a * 0.35) + (b * 0.45) + (c * 0.2)
data.append(sum_value)
k_score = data[k-1]
data.sort(reverse=True)
value = n // 10
result = data.index(k_score) // value
print("#%d %s" % (tc, score[result]))T = int(input())
for t in range(1, T+1):
N, K = map(int, input().split(' '))
students = []
grade = ['A+', 'A0', 'A-', 'B+', 'B0', 'B-', 'C+', 'C0', 'C-', 'D0']
for n in range(N):
midterm, final, assignment = map(int, input().split())
sum_student = midterm * 0.35 + final * 0.45 + assignment * 0.20
students.append(sum_student)
k_score = students[K-1]
students.sort(reverse=True)
rank_of_ten = students.index(k_score) // (N//10) # 핵심 코드
k_grade = grade[rank_of_ten]
print('#{} {}'.format(t, k_grade))1984. 중간 평균값 구하기
10개의 수를 입력 받아, 최대 수와 최소 수를 제외한 나머지의 평균값을 출력하는 프로그램을 작성하라.
(소수점 첫째 자리에서 반올림한 정수를 출력한다.)
[제약 사항]
각 수는 0 이상 10000 이하의 정수이다.
[입력]
가장 첫 줄에는 테스트 케이스의 개수 T가 주어지고, 그 아래로 각 테스트 케이스가 주어진다.
각 테스트 케이스의 첫 번째 줄에는 10개의 수가 주어진다.
[출력]
출력의 각 줄은 '#t'로 시작하고, 공백을 한 칸 둔 다음 정답을 출력한다.
(t는 테스트 케이스의 번호를 의미하며 1부터 시작한다.)
T = int(input())
for test_case in range(1, T + 1):
scores = sorted(list(map(int, input().split())))
print(f'#{test_case} {round(sum(scores[1:9]) / 8)}')1966. 숫자를 정렬하자
주어진 N 길이의 숫자열을 오름차순으로 정렬하여 출력하라.
[제약 사항]
N 은 5 이상 50 이하이다.
[입력]
가장 첫 줄에는 테스트 케이스의 개수 T가 주어지고, 그 아래로 각 테스트 케이스가 주어진다.
각 테스트 케이스의 첫 번째 줄에 N 이 주어지고, 다음 줄에 N 개의 숫자가 주어진다.
[출력]
출력의 각 줄은 '#t'로 시작하고, 공백을 한 칸 둔 다음 정답을 출력한다.
(t는 테스트 케이스의 번호를 의미하며 1부터 시작한다.)
T = int(input())
for test_case in range(1, T + 1):
n = int(input())
numbers = sorted(list(map(int, input().split())))
print(f'#{test_case}', end=' ')
print(*numbers)1961. 숫자 배열 회전
N x N 행렬이 주어질 때, 시계 방향으로 90도, 180도, 270도 회전한 모양을 출력하라.
[제약 사항]
N은 3 이상 7 이하이다.
[입력]
가장 첫 줄에는 테스트 케이스의 개수 T가 주어지고, 그 아래로 각 테스트 케이스가 주어진다.
각 테스트 케이스의 첫 번째 줄에 N이 주어지고,
다음 N 줄에는 N x N 행렬이 주어진다.
[출력]
출력의 첫 줄은 '#t'로 시작하고, 다음 N줄에 걸쳐서 90도, 180도, 270도 회전한 모양을 출력한다. 입력과는 달리 출력에서는 회전한 모양 사이에만 공백이 존재함에 유의하라. (t는 테스트 케이스의 번호를 의미하며 1부터 시작한다.)
T = int(input())
for test_case in range(1, T + 1):
n = int(input())
array = [list(map(int, input().split())) for _ in range(n)]
array1 = list(map(list, zip(*array[::-1]))) #90도 회전
array2 = list(map(list, zip(*array1[::-1]))) #90도 회전의 90도 회전
array3 = list(map(list, zip(*array2[::-1]))) #180도 회전의 90도 회전
print(f"#{test_case}")
for j in range(n):
print(''.join(map(str, array1[j])), end=' ') #90도 회전
print(''.join(map(str, array2[j])), end=' ') #180도 회전
print(''.join(map(str, array3[j]))) #270도 회전배열회전 링크
ZIP을 사용한 깔끔한 회전
def zip_rotate(original):
rotated = np.array(list(zip(*original[::-1])))
return rotated1989. 초심자의 회문 검사
"level" 과 같이 거꾸로 읽어도 제대로 읽은 것과 같은 문장이나 낱말을 회문(回文, palindrome)이라 한다. 단어를 입력 받아 회문이면 1을 출력하고, 아니라면 0을 출력하는 프로그램을 작성하라.
[제약 사항]
각 단어의 길이는 3 이상 10 이하이다.
[입력]
가장 첫 줄에는 테스트 케이스의 개수 T가 주어지고, 그 아래로 각 테스트 케이스가 주어진다. 각 테스트 케이스의 첫 번째 줄에 하나의 단어가 주어진다.
[출력]
출력의 각 줄은 '#t'로 시작하고, 공백을 한 칸 둔 다음 정답을 출력한다. (t는 테스트 케이스의 번호를 의미하며 1부터 시작한다.)
T = int(input())
for test_case in range(1, T + 1):
s = input()
answer = 0
if s == s[::-1]: #역순배열
answer = 1
print(f'#{test_case} {answer}')2007. 패턴 마디의 길이
패턴에서 반복되는 부분을 마디라고 부른다. 문자열을 입력 받아 마디의 길이를 출력하는 프로그램을 작성하라.
[제약 사항]
각 문자열의 길이는 30이다. 마디의 최대 길이는 10이다.
[입력]
가장 첫 줄에는 테스트 케이스의 개수 T가 주어지고, 그 아래로 각 테스트 케이스가 주어진다. 각 테스트 케이스의 첫 번째 줄에는 길이가 30인 문자열이 주어진다.
[출력]
출력의 각 줄은 '#t'로 시작하고, 공백을 한 칸 둔 다음 정답을 출력한다.
(t는 테스트 케이스의 번호를 의미하며 1부터 시작한다.)
T = int(input())
for test_case in range(1, T + 1):
s = input()
target = ''
for i in range(1, 11):
if s[0:i] == s[i:i + i]:
target = s[0:i]
break
print(f'#{test_case} {len(target)}')1945. 간단한 소인수분해
숫자 N은 아래와 같다.
N=2a x 3b x 5c x 7d x 11e
N이 주어질 때 a, b, c, d, e 를 출력하라.
[제약 사항]
N은 2 이상 10,000,000 이하이다.
[입력]
가장 첫 줄에는 테스트 케이스의 개수 T가 주어지고, 그 아래로 각 테스트 케이스가 주어진다.
각 테스트 케이스의 첫 번째 줄에 N 이 주어진다.
[출력]
출력의 각 줄은 '#t'로 시작하고, 공백을 한 칸 둔 다음 정답을 출력한다.
(t는 테스트 케이스의 번호를 의미하며 1부터 시작한다.)
T = int(input())
for test_case in range(1, T + 1):
n = int(input())
answer = [0, 0, 0, 0, 0]
numbers = [2, 3, 5, 7, 11]
for i in range(4, -1, -1):
while n % numbers[i] == 0:
answer[i] += 1
n //= numbers[i]
print(f"#{test_case}", end=' ')
print(*answer)for test_case in range(1, int(input())+1):
n = int(input())
numbers = [2, 3, 5, 7, 11]
result = ''
for number in numbers:
cnt = 0
while True:
if N % number == 0:
N = N//number
cnt += 1
else:
result += str(cnt) + ' '
break
print(f"#{test_case} {result}")
print('#{} {}'.format(test_case, result)) 1946. 간단한 압축 풀기
원본 문서는 너비가 10인 여러 줄의 문자열로 이루어져 있다.
문자열은 마지막 줄을 제외하고 빈 공간 없이 알파벳으로 채워져 있고 마지막 줄은 왼쪽부터 채워져 있다.
이 문서를 압축한 문서는 알파벳과 그 알파벳의 연속된 개수로 이루어진 쌍들이 나열되어 있다. (예 : A 5 AAAAA)
압축된 문서를 입력 받아 원본 문서를 만드는 프로그램을 작성하시오.
[예제]
압축된 문서의 내용
A 10
B 7
C 5
압축을 풀었을 때 원본 문서의 내용
AAAAAAAAAA
BBBBBBBCCC
CC
[제약사항]
1. 압축된 문서의 알파벳과 숫자 쌍의 개수 N은 1 이상 10 이하의 정수이다. (1 ≤ N ≤ 10)
2. 주어지는 알파벳 Ci는 A~Z의 대문자이다. (i는 줄의 번호로 1~N까지의 수)
3. 알파벳의 연속된 개수로 주어지는 수 Ki는 1이상 20이하의 정수이다. (1 ≤ Ki ≤ 20, i는 줄의 번호로 1~N까지의 수)
4. 원본 문서의 너비는 10으로 고정이다.
[입력]
가장 첫 줄에는 테스트 케이스의 개수 T가 주어지고, 그 아래로 각 테스트 케이스가 주어진다.
각 테스트 케이스에는 N이 주어지고 다음 줄부터 N+1줄까지 Ci와 Ki가 빈 칸을 사이에 두고 주어진다.
[출력]
각 줄은 '#t'로 시작하고, 다음 줄부터 원본 문서를 출력한다.(t는 테스트 케이스의 번호를 의미하며 1부터 시작한다.)
T = int(input())
for test_case in range(1, T + 1):
n = int(input())
docs = ''
for _ in range(n):
c, k = input().split()
docs += c * int(k)
print(f'#{test_case}')
for i in range(0, len(docs), 10):
print(docs[i:i+10])1970. 쉬운 거스름돈
우리나라 화폐 ‘원’은 금액이 높은 돈을 우선적으로 계산할 때 돈의 개수가 가장 최소가 된다. S마켓에서 사용하는 돈의 종류는 다음과 같다.
50,000 원
10,000 원
5,000 원
1,000 원
500 원
100 원
50 원
10 원
S마켓에서 손님에게 거슬러 주어야 할 금액 N이 입력되면 돈의 최소 개수로 거슬러 주기 위하여 각 종류의 돈이 몇 개씩 필요한지 출력하라.
[예제]
N이 32850일 경우,
50,000 원 : 0개
10,000 원 : 3개
5,000 원 : 0개
1,000 원 : 2개
500 원 : 1개
100 원 : 3개
50 원 : 1개
10 원 : 0개
[제약 사항]
1. N은 10이상 1,000,000이하의 정수이다. (10 ≤ N ≤ 1,000,000)
2. N의 마지막 자릿수는 항상 0이다. (ex : 32850)
[입력]
가장 첫 줄에는 테스트 케이스의 개수 T가 주어지고, 그 아래로 각 테스트 케이스가 주어진다. 각 테스트 케이스에는 N이 주어진다.
[출력]
각 줄은 '#t'로 시작하고, 다음줄에 각 돈의 종류마다 필요한 개수를 빈칸을 사이에 두고 출력한다. (t는 테스트 케이스의 번호를 의미하며 1부터 시작한다.)
T = int(input())
coins = [50000, 10000, 5000, 1000, 500, 100, 50, 10]
for test_case in range(1, T + 1):
money = int(input())
answer = []
for coin in coins:
answer.append(money // coin) # "//" : 몫
money %= coin # "%=" : 나머지
print(f'#{test_case}')
print(*answer)1976. 시각 덧셈
시 분으로 이루어진 시각을 2개 입력 받아, 더한 값을 시 분으로 출력하는 프로그램을 작성하라. (시각은 12시간제로 표시한다. 즉, 시가 가질 수 있는 값은 1시부터 12시이다.)
[제약 사항]
시는 1 이상 12 이하의 정수이다. 분은 0 이상 59 이하의 정수이다.
[입력]
가장 첫 줄에는 테스트 케이스의 개수 T가 주어지고, 그 아래로 각 테스트 케이스가 주어진다. 각 테스트 케이스의 첫 번째 줄에는 4개의 수가 주어진다.
첫 번째 수가 시를 나타내고 두 번째 수가 분을 나타낸다. 그 다음 같은 형식으로 두 번째 시각이 주어진다.
[출력]
출력의 각 줄은 '#t'로 시작하고 공백을 한 칸 둔 다음, 시를 출력하고 공백을 한 칸 둔 다음 분을 출력한다. (t는 테스트 케이스의 번호를 의미하며 1부터 시작한다.)
T = int(input())
for test_case in range(1, T + 1):
a, b, c, d = map(int, input().split())
hour = a + c
minute = b + d
if minute >= 60:
minute -= 60
hour += 1
if hour > 12:
hour -= 12
print(f"#{test_case} {hour} {minute}")T = int(input())
hr = 0
mi = 0
for test_case in range(1, T + 1):
numbers = list(map(int, input().split()))
hr = numbers[0] + numbers[2]
mi = numbers[1] + numbers[3]
if mi > 59:
mi -= 60
hr += 1
if hr > 12:
hr -= 12
print(f'#{test_case} {hr} {mi}')1986. 지그재그 숫자
1부터 N까지의 숫자에서 홀수는 더하고 짝수는 뺐을 때 최종 누적된 값을 구해보자.
[예제 풀이]
N이 5일 경우,
1 – 2 + 3 – 4 + 5 = 3
N이 6일 경우,
1 – 2 + 3 – 4 + 5 – 6 = -3
[제약사항]
N은 1 이상 10 이하의 정수이다. (1 ≤ N ≤ 10)
[입력]
가장 첫 줄에는 테스트 케이스의 개수 T가 주어지고, 그 아래로 각 테스트 케이스가 주어진다. 각 테스트 케이스에는 N이 주어진다.
[출력]
각 줄은 '#t'로 시작하고, 공백을 한 칸 둔 다음 누적된 값을 출력한다.
(t는 테스트 케이스의 번호를 의미하며 1부터 시작한다.)
T = int(input())
for test_case in range(1, T + 1):
n = int(input())
answer = 0
for i in range(1, n + 1):
if i % 2 != 0:
answer += i
else:
answer -= i
print(f'#{test_case} {answer}')2005. 파스칼의 삼각형 (DP)
크기가 N인 파스칼의 삼각형을 만들어야 한다. 파스칼의 삼각형이란 아래와 같은 규칙을 따른다.
- 첫 번째 줄은 항상 숫자 1이다.
- 두 번째 줄부터 각 숫자들은 자신의 왼쪽과 오른쪽 위의 숫자의 합으로 구성된다.
N이 4일 경우, N을 입력 받아 크기 N인 파스칼의 삼각형을 출력하는 프로그램을 작성하시오.
[제약 사항]
파스칼의 삼각형의 크기 N은 1 이상 10 이하의 정수이다. (1 ≤ N ≤ 10)
[입력]
가장 첫 줄에는 테스트 케이스의 개수 T가 주어지고, 그 아래로 각 테스트 케이스가 주어진다. 각 테스트 케이스에는 N이 주어진다.
[출력]
각 줄은 '#t'로 시작하고, 다음 줄부터 파스칼의 삼각형을 출력한다. 삼각형 각 줄의 처음 숫자가 나오기 전까지의 빈 칸은 생략하고 숫자들 사이에는 한 칸의 빈칸을 출력한다. (t는 테스트 케이스의 번호를 의미하며 1부터 시작한다.)
T = int(input())
for test_case in range(1, T + 1):
n = int(input())
triangle = [[1 for j in range(i)] for i in range(1, n + 1)]
for i in range(2, n):
for j in range(1, i):
triangle[i][j] = triangle[i - 1][j - 1] + triangle[i - 1][j]
print(f"#{test_case}")
for t in triangle:
print(*t)2001. 파리 퇴치 (구현)
N x N 배열 안의 숫자는 해당 영역에 존재하는 파리의 개수를 의미한다.
아래는 N=5 의 예이다.
M x M 크기의 파리채를 한 번 내리쳐 최대한 많은 파리를 죽이고자 한다.
죽은 파리의 개수를 구하라! 예를 들어 M=2 일 경우 위 예제의 정답은 49마리가 된다.
[제약 사항]
1. N 은 5 이상 15 이하이다.
2. M은 2 이상 N 이하이다.
3. 각 영역의 파리 갯수는 30 이하 이다.
[입력]
가장 첫 줄에는 테스트 케이스의 개수 T가 주어지고, 그 아래로 각 테스트 케이스가 주어진다.
각 테스트 케이스의 첫 번째 줄에 N 과 M 이 주어지고, 다음 N 줄에 걸쳐 N x N 배열이 주어진다.
[출력]
출력의 각 줄은 '#t'로 시작하고, 공백을 한 칸 둔 다음 정답을 출력한다.
(t는 테스트 케이스의 번호를 의미하며 1부터 시작한다.)
T = int(input())
for test_case in range(1, T + 1):
n, m = map(int, input().split())
board = [list(map(int, input().split())) for _ in range(n)]
answer = 0
# 작은 열과 더 많은 열을 돌릴 수 있는 최대의 수는 M-N+1 규칙성
for i in range(n - m + 1):
for j in range(n - m + 1):
temp = 0
for y in range(i, i + m):
for x in range(j, j + m):
temp += board[y][x]
answer = max(temp, answer)
print(f"#{test_case} {answer}")NxN행렬에서 (N-M+1)x(N-M+1) 범위의 index를 돌며 해당 index의 MxM 범위 내 원소 합을 저장
최대값 비교 후 최대값 저장
T = int(input())
for tc in range(1,T+1):
N, M = map(int,input().split())
arr = [list(map(int,input().split())) for _ in range(N)]
n = M-1 #작은 열과 더 많은 열을 돌릴 수 있는 최대의 수는 M-N+1 규칙성
max_v = 0
#N-M+1 범위의 idx만큼 순회
for i in range(N-n): #작은 열과 더 많은 열을 돌릴 수 있는 최대의 수는 M-N+1 규칙성
for j in range(N-n):
sum_v = 0
#해당 인덱스에서 MxM 범위 내 원소합을 저장
for di in range(M):
for dj in range(M):
sum_v += arr[i+di][j+dj]
#최대값과 비교하며 최대값 저장
if sum_v > max_v:
max_v = sum_v
print('#{} {}'.format(tc, max_v))1954. 달팽이 숫자 (구현)
달팽이는 1부터 N*N까지의 숫자가 시계방향으로 이루어져 있다. 다음과 같이 정수 N을 입력 받아 N크기의 달팽이를 출력하시오.
[예제]
N이 3일 경우, N이 4일 경우
[제약사항]
달팽이의 크기 N은 1 이상 10 이하의 정수이다. (1 ≤ N ≤ 10)
[입력]
가장 첫 줄에는 테스트 케이스의 개수 T가 주어지고, 그 아래로 각 테스트 케이스가 주어진다. 각 테스트 케이스에는 N이 주어진다.
[출력]
각 줄은 '#t'로 시작하고, 다음 줄부터 빈칸을 사이에 두고 달팽이 숫자를 출력한다.
(t는 테스트 케이스의 번호를 의미하며 1부터 시작한다.)
T = int(input())
for test_case in range(1, T + 1):
n = int(input())
board = [[0] * n for _ in range(n)]
num = 0
y = 0
x = -1
size = n
step = 1
while size > 0:
for _ in range(size):
x += step
num += 1
board[y][x] = num
size -= 1
for _ in range(size):
y += step
num += 1
board[y][x] = num
step *= -1
print(f"#{test_case}")
for b in board:
print(*b)for tc in range(1, int(input())+1):
N = int(input())
total = N * N
arr = [[0] * N for _ in range(N)]
cnt = 1
# 시작은 좌측 상단
r = 0
c = 0
dr = [0, 1, -1, 0]
dc = [1, 0, 0, -1]
# 오른쪽이 시작이므로 시작점은 0
now = 0
while cnt <= total:
# 범위를 벗어나지 않고 그 안의 숫자가 0일 때
if 0 <= r < N and 0 <= c < N and not arr[r][c]:
arr[r][c] = cnt
cnt += 1
else:
# 더해서 초과된 부분을 다시 빼줌
r -= dr[now]
c -= dc[now]
# 인덱스 초과 방지
now = (now+1) % 4
r += dr[now]
c += dc[now]
print('#{}'.format(tc))
for i in range(N):
for j in range(N):
print(arr[i][j], end=' ')
print()1979. 어디에 단어가 들어갈 수 있을까 (구현)
N X N 크기의 단어 퍼즐을 만들려고 한다. 입력으로 단어 퍼즐의 모양이 주어진다.
주어진 퍼즐 모양에서 특정 길이 K를 갖는 단어가 들어갈 수 있는 자리의 수를 출력하는 프로그램을 작성하라.
[예제]
N = 5, K = 3 이고, 퍼즐의 모양이 아래 그림과 같이 주어졌을 때 길이가 3 인 단어가 들어갈 수 있는 자리는 2 곳(가로 1번, 가로 4번)이 된다.
[제약 사항]
1. N은 5 이상 15 이하의 정수이다. (5 ≤ N ≤ 15)
2. K는 2 이상 N 이하의 정수이다. (2 ≤ K ≤ N)
[입력]
입력은 첫 줄에 총 테스트 케이스의 개수 T가 온다. 다음 줄부터 각 테스트 케이스가 주어진다. 테스트 케이스의 첫 번째 줄에는 단어 퍼즐의 가로, 세로 길이 N 과, 단어의 길이 K 가 주어진다.
테스트 케이스의 두 번째 줄부터 퍼즐의 모양이 2차원 정보로 주어진다.
퍼즐의 각 셀 중, 흰색 부분은 1, 검은색 부분은 0 으로 주어진다.
[출력]
테스트 케이스 t에 대한 결과는 “#t”을 찍고, 한 칸 띄고, 정답을 출력한다.
(t는 테스트 케이스의 번호를 의미하며 1부터 시작한다.)
T = int(input())
for test_case in range(1, T + 1):
n, k = map(int, input().split())
board = [list(map(int, input().split())) for _ in range(n)]
answer = 0
for i in range(n):
count = 0
for j in range(n):
if board[i][j] == 1:
count += 1
else:
if count == k:
answer += 1
count = 0
if count == k:
answer += 1
for j in range(n):
count = 0
for i in range(n):
if board[i][j] == 1:
count += 1
else:
if count == k:
answer += 1
count = 0
if count == k:
answer += 1
print(f"#{test_case} {answer}")1974. 스도쿠 검증 (구현)
스도쿠는 숫자퍼즐로, 가로 9칸 세로 9칸으로 이루어져 있는 표에 1 부터 9 까지의 숫자를 채워넣는 퍼즐이다.
같은 줄에 1 에서 9 까지의 숫자를 한번씩만 넣고, 3 x 3 크기의 작은 격자 또한, 1 에서 9 까지의 숫자가 겹치지 않아야 한다.
입력으로 9 X 9 크기의 스도쿠 퍼즐의 숫자들이 주어졌을 때, 위와 같이 겹치는 숫자가 없을 경우, 1을 정답으로 출력하고 그렇지 않을 경우 0 을 출력한다.
[제약 사항]
1. 퍼즐은 모두 숫자로 채워진 상태로 주어진다.
2. 입력으로 주어지는 퍼즐의 모든 숫자는 1 이상 9 이하의 정수이다.
[입력]
입력은 첫 줄에 총 테스트 케이스의 개수 T가 온다.
다음 줄부터 각 테스트 케이스가 주어진다.
테스트 케이스는 9 x 9 크기의 퍼즐의 데이터이다.
[출력]
테스트 케이스 t에 대한 결과는 “#t”을 찍고, 한 칸 띄고, 정답을 출력한다.
(t는 테스트 케이스의 번호를 의미하며 1부터 시작한다.)
T = int(input())
for test_case in range(1, T + 1):
board = [list(map(int, input().split())) for _ in range(9)]
flag = True
# 가로줄 검증
for i in range(9):
numbers = [0] * 10
for j in range(9):
numbers[board[i][j]] += 1
for k in range(1, 10):
if numbers[k] == 0:
flag = False
break
# 세로줄 검증
for i in range(9):
numbers = [0] * 10
for j in range(9):
numbers[board[j][i]] += 1
for k in range(1, 10):
if numbers[k] == 0:
flag = False
break
# 3 X 3 검증
for k in range(0, 7, 3):
temp = 0
for i in range(k, k + 3):
for j in range(k, k + 3):
temp += board[i][j]
if temp != 45:
flag = False
break
if flag:
print(f"#{test_case} 1")
else:
print(f"#{test_case} 0")
#python에서 join 함수는 배열을 특정 문자로 구분하여 문자열로 변환해주는 함수
return str(int(''.join(numbers)))
return str(int("".join(r[1] for r in res)))