import heapq
import sys
N = int(sys.stdin.readline())
heap = []
for _ in range(N):
num = int(sys.stdin.readline())
if num == 0:
if len(heap) == 0:
print(0)
else:
print(heapq.heappop(heap)[1]) # (우선순위, 값) 중 '값'을 pop
else:
heapq.heappush(heap, (-num,num)) # (배열, (우선순위, 값))
import heapq
import sys
N = int(input())
heap = []
for _ in range(N):
num = sys.stdin.readline()
num = int(num)
if num == 0:
if len(heap) == 0:
print(0)
else:
print(heapq.heappop(heap))
else:
heapq.heappush(heap, num)
import copy
def solution(dirs):
path = [] # 지나간 길 ex) [0,0,1,0] : (0,0) -> (1,0)
last = [0,0]
for a in dirs:
temp = copy.deepcopy(last)
if a == 'U':
last[1] +=1
if last[1] <= 5 and last[1] >= -5:
if (temp + last) not in path and (last + temp) not in path:
path.append(temp + last)
else:
last[1] -=1 # 범위 넘었을 경우 이동경로 다시 되돌려주기
elif a == 'D':
last[1] -=1
if last[1] <= 5 and last[1] >= -5:
if (temp + last) not in path and (last + temp) not in path:
path.append(temp + last)
else:
last[1] +=1 # 범위 넘었을 경우 이동경로 다시 되돌려주기
elif a == 'R':
last[0] +=1
if last[0] <= 5 and last[0] >= -5:
if (temp + last) not in path and (last + temp) not in path:
path.append(temp + last)
else:
last[0] -=1 # 범위 넘었을 경우 이동경로 다시 되돌려주기
elif a == 'L':
last[0] -=1
if last[0] <= 5 and last[0] >= -5:
if (temp + last) not in path and (last + temp) not in path:
path.append(temp + last)
else:
last[0] += 1 # 범위 넘었을 경우 이동경로 다시 되돌려주기
#print(last)
#print(path)
#print(len(path))
return len(path)
#solution("ULURRDLLU")
#solution("LULLLLLLU")
#solution("LR") # 1이 나와야 한다.
#solution("L")
# 주어진 조건대로 구현하면 되는문제
def solution(n, words):
index = -1
for i in range(len(words)):
if len(words[i]) == 1: # 한 글자인지
index = i
break
if i >= 1:
if words[i-1][-1] != words[i][0]: # 이전 단어랑 비교
index = i
break
if words[i] in words[:i]:
index = i
break
#print(index)
if index == -1:
return [0,0]
else:
#print([index%n+1, index//n+1])
return [index%n+1, index//n+1]
#solution(3, ['tank', 'kick', 'know', 'wheel', 'land', 'dream', 'mother', 'robot', 'tank'])
#solution(5, [hello, observe, effect, take, either, recognize, encourage, ensure, establish, hang, gather, refer, reference, estimate, executive])
#solution(2, ['hello', 'one', 'even', 'never', 'now', 'world', 'draw'])
#몫2, 나머지2 -> [3,3]
#몫2 나머지0 -> [1,3]
# 아이디어 : N에서 최대한 많이 2로 나눈다.
c = 0
def iron(n):
global c
if n%2 != 0: # 홀수 이면
n -= 1
c += 1
if n >0:
iron(n)
else: # 짝수 이면
n //=2
if n>0:
iron(n)
def solution(n):
iron(n)
#print(c)
return c
#solution(5)
#solution(5000)
# 브루트 포스 -> itertools의 '조합'(=순서가 없는 조합) 사용
from itertools import combinations
def isPrime(n):
for i in range(2, n):
if n % i == 0:
return False
return True
def solution(nums):
cb = combinations(nums, 3) # 주어진 숫자 중 3개 뽑은 조합
#print(list(c))
c = 0
for a in list(cb):
if isPrime(sum(a)):
c += 1
#print(c)
return c
#solution([1,2,3,4])
#solution([1,2,7,6,4])
def solution(n, stations, w):
t = [0]*(n+1)
# (1) 주파수 닿는곳 1로 표기 -> 시간복잡도 : O(n^2) (N은 200,000,000 이하의 자연수)
for st in stations:
for i in range(st-w, st+w+1):
if i < len(t):
t[i] = 1
#print(t)
# (2) 0으로만 이루어진 집합 각각의 0개수 구하기
c_arr = []
c = 0
for i in range(1, len(t)):
if t[i] == 0:
c+=1
if i == len(t)-1:
if c>0:
c_arr.append(c)
else:
if c>0:
c_arr.append(c)
c = 0
#print(c_arr)
# (3) 계산
answer = 0
signal = 2*w + 1 # 주파수 대역
for a in c_arr:
q = a//signal
r = a%signal
if r == 0:
answer +=q
else:
answer += (q+1)
#print(answer)
return answer
#solution(11, [4,11], 1)
#solution(16, [9], 2)
▶ 코드 (정답 -> 배열 업데이트 X)
def solution(n, stations, w):
dist = [] # 거리 집합
# (1) 설치된 기지국들 사이에 전파가 닿지 않는 거리를 저장한다.
for i in range(1, len(stations)):
dist.append( (stations[i]-w-1) - (stations[i-1]+w) )
# (2) 첫번째 아파트 ~ 맨 앞 기지국 사이에 전파가 닿지 않는 거리를 저장한다.
dist.append( stations[0]-w-1 )
# (3) 맨 뒤 기지국 ~ 마지막 아파트 사이에 전파가 닿지 않는 거리를 저장한다.
dist.append( n - (stations[-1]+w) )
#print(dist)
# (4) 계산
answer = 0
signal = 2*w + 1 # 주파수 대역
for a in dist:
q = a//signal
r = a%signal
if r == 0:
answer +=q
else:
answer += (q+1)
#print(answer)
return answer
#solution(11, [4,11], 1)
#solution(16, [9], 2)
# 출처 : https://inspirit941.tistory.com/entry/Python-%ED%94%84%EB%A1%9C%EA%B7%B8%EB%9E%98%EB%A8%B8%EC%8A%A4-%EA%B8%B0%EC%A7%80%EA%B5%AD-%EC%84%A4%EC%B9%98-Level-3
# 다익스트라 알고리즘 : 선형탐색 ver. (시간복잡도 O(n^2))
# 하나의 정점에서 다른 모든 정점으로 가는 최단 경로를 구할 수 있습니다.
# <과정>
# 1. 출발 노드를 설정합니다
# 2. 출발 노드를 기준으로 각 노드의 최소 비용을 저장합니다.
# 3. 방문하지 않은 노드 중에서 가장 비용이 적은 노드를 선택합니다.
# 4. 해당 노드를 거쳐서 특정한 노드로 가는 경우를 고려하여 최소 비용을 갱신합니다.
# 위 과정에서 3~4번을 반복합니다.
INF = 987654321
# dist배열 중, 방문하지 않았으면서 가장 작은 값 가진 정점 골라내기
def getSmallDistIndex(dist, N):
min_value = INF
index = 0
for i in range(N+1):
if dist[i] < min_value and visited[i] == 0:
min_value = dist[i]
index = i
return index
# 코딩편의를 위해, '이차원 배열' 형태로 만들어준다.
def normalize(road, N):
t = [[0 for i in range(N+1)] for i in range(N+1)]
for a in road:
if t[a[0]][a[1]] != 0: # 이미 있는 경로일때
if a[2] < t[a[0]][a[1]]: # 비교해서 더 작으면..갱신해주기
t[a[0]][a[1]] = a[2]
t[a[1]][a[0]] = a[2] # 양방향으로 넣어줘야됨
else:
t[a[0]][a[1]] = a[2]
t[a[1]][a[0]] = a[2]
return t
def dijkstra(road, N):
global visited
road = normalize(road, N)
#print('road=', road)
visited = [0]*(N+1)
dist = [INF for i in range(N+1)]
# 1번 정점에서 출발
dist[1] = 0
visited[1] = 1
for i in range(N+1):
if road[1][i] != 0:
dist[i] = road[1][i] # 1번 정점이랑 인접한 정점들의 가중치 넣어줌
#print('시작 dist=', dist)
#print()
for _ in range(N-1): # 총 N-1번 반복(=1번 정점 제외)
current = getSmallDistIndex(dist, N) # 현재 기준 (=거쳐서 갈 정점)
#print('current index=',current)
visited[current] = 1 # current를 방문처리
#print('현재 visited=', visited)
for j in range(1, N+1): # 1,2,,,,N
if visited[j] == 0 and road[current][j]!=0 : # 방문하지 않았으면서 길이 있는 경우
if dist[current] + road[current][j] < dist[j]:
dist[j] = dist[current] + road[current][j] # 최소값으로 갱신
#print(dist)
#print()
return dist
def solution(N, road, K): # N=정점의 개수, K는 배달시간 최대허용치
answer = 0
dist = dijkstra(road, N)
#print(dist)
for d in dist:
if d <= K:
answer += 1
#print(answer)
return answer
#solution(5,[[1,2,1],[2,3,3],[5,2,2],[1,4,2],[5,3,1],[5,4,2]],3)
#solution(6,[[1,2,1],[1,3,2],[2,3,2],[3,4,3],[3,5,2],[3,5,3],[5,6,1]],4)
def solution(skill, skill_trees):
c = 0
for i in range(len(skill_trees)):
t = []
for j in range(len(skill_trees[i])):
if skill_trees[i][j] in skill: # skill에 있는 영단어 이면..
t.append(skill_trees[i][j])
word = ''.join(t)
flag = 0
for k in range(len(word)):
if word[k] != skill[k]: # skill과 index위치가 동일하지 않는게 있다면..
flag = 1
if flag == 0:
c += 1
return c
SELECT A.cart_id FROM (SELECT cart_id FROM CART_PRODUCTS WHERE NAME='우유') as A, (SELECT cart_id FROM CART_PRODUCTS WHERE NAME='요거트') as B WHERE A.cart_id = B.cart_id
풀이 2: WHERE절에 그냥 NAME을 단순2개 비교하는 조건은 없기때문에, 서브쿼리로 id하나 구해준뒤 AND사용 SELECT cart_id FROM CART_PRODUCTS WHERE cart_id in (SELECT cart_id FROM CART_PRODUCTS WHERE name='우유') AND NAME='요거트' ORDER BY cart_id asc;
풀이 3: SELF JOIN SELECT C.cart_id FROM CART_PRODUCTS C, CART_PRODUCTS T WHERE C.cart_id = T.cart_id AND (C.name='우유' AND T.name='요거트') ORDER BY C.cart_id
# 110 = 1,2,3,,,,9,10,,,99 -> 99 개
n = int(input())
def isHansoo(i): # i 는 세자리수 또는 네자리수(1000도 포함)
i = str(i)
while len(i) > 2:
if len(i) == 3:
if int(i[2]) - int(i[1]) == int(i[1]) - int(i[0]):
return True
else:
if int(i[3]) - int(i[2]) == int(i[2]) - int(i[1]) == int(i[1]) - int(i[0]):
return True
return False
if n<=99:
print(n)
elif n<=110:
print(99)
else:
c=0
for i in range(111, n+1):
if isHansoo(i):
c += 1
print(99+c)
# 문제 : 서류,면접 등수가 모두 자기보다 낮은게 있으면 OUT
# 아이디어 : 1 .서류등수 기준으로 오름차순 한 다음,
# 2. 서류등수 1등인사람의 면접점수를 min값으로 두고,
# 3. 서류등수가 올라가는 순서로 되어있으므로, 그 다음번 원소의 면접등수는 앞에꺼보다 무조건 높은등수여야만 한다.
# 4. (따라서 min값을 계속 갱신해 나가야 한다)
T = int(input())
for _ in range(T):
n = int(input())
s = [0]*(n+1)
# 입력
for i in range(n):
a, b = map(int, input().split())
s[a] = b
#print(s)
min_number = s[1] # 서류등수 1등인 사람의 면접등수
c = 0
for i in range(2, len(s)): # 서류점수 2등~ n등까지 차례대로 면접등수 검사
if s[i] > min_number:
#print('걸러진것->(', i, s[i], ')')
c += 1
else:
min_number = s[i]
print(n - c)
# 정답 : https://pacific-ocean.tistory.com/343
'''시간초과'''
'''
#t=[[3,2],[1,4],[4,1],[2,3],[5,5]]
#t=[[3,6],[7,3],[4,2],[1,4],[5,7],[2,5],[6,1]],
# 배열에서 둘다 높아지는 경우 OUT
T = int(input())
for _ in range(T):
n = int(input())
t = []
for i in range(n):
t.append(list(map(int, input().split())))
t1 = sorted(t, key=lambda x: x[0])
t2 = sorted(t1, key=lambda x: x[1])
#print(t2)
c = 0
i = 0
j = 1
length = len(t2)
while j < len(t2):
if t2[i][0] > t2[j][0] or t2[i][1] > t2[j][1]:
i += 1
j += 1
else:
#print('삭제할것->', t2[j])
t2 = t2[:j] + t2[j+1:]
#print('t2다시 ->', t2)
c += 1
print(length-c)
'''
woman,man,k = map(int, input().split())
team = 0
while woman>=2 and man>=1 and woman+man>=k+3:
woman -=2
man -=1
team += 1
print(team)
# 정답 : https://yongku.tistory.com/entry/%EB%B0%B1%EC%A4%80-%EC%95%8C%EA%B3%A0%EB%A6%AC%EC%A6%98-%EB%B0%B1%EC%A4%80-2875%EB%B2%88-%EB%8C%80%ED%9A%8C-or-%EC%9D%B8%ED%84%B4-%ED%8C%8C%EC%9D%B4%EC%8D%ACPython
import sys
def greedy(temp):
c = 0
start = 0
for t in temp:
if t[0] >= start:
start = t[1]
c += 1
print(start)
return c
if __name__ == "__main__":
N = int(sys.stdin.readline())
temp = []
for i in range(N):
start, end = map(int, sys.stdin.readline().split())
temp.append((start, end))
temp = sorted(temp, key=lambda t:t[0]) # 시작시간 기준으로 오름차순 정렬
print('시작시간 기준 = ',temp)
temp = sorted(temp, key=lambda t:t[1]) # 종료시간 기준으로 오름차순 정렬
print('시작+종료시간 기준 = ',temp)
# 1. 이렇게하면, 기존의 시작 시간 기준으로 정렬한 값들을 '최대한 유지'하려 하기 때문에, 종료 시간이 같다면, 시작 시간이 빠른 기준으로 정렬된 결과가 나타난다. ex.. (1,2), (2,2)
# 2. 종료 시간이 짧은것 먼저 정렬했기 때문에 더 많은 회의들을 추가할 수 있다.
# 시작시간 기준 = [(0, 6), (1, 4), (2, 13), (3, 5), (3, 8), (5, 7), (5, 9), (6, 10), (8, 11), (8, 12), (12, 14)]
# 시작+종료시간 기준 = [(1, 4), (3, 5), (0, 6), (5, 7), (3, 8), (5, 9), (6, 10), (8, 11), (8, 12), (2, 13), (12, 14)]
print(greedy(temp))
import sys
if __name__ == "__main__":
N = int(sys.stdin.readline()) # N은 1000미만의 정수
c = 0
N = 1000 - N
while N > 0:
if N >= 500:
N-=500
c += 1
elif N >= 100:
N-=100
c += 1
elif N >= 50:
N-=50
c += 1
elif N >= 10:
N-=10
c += 1
elif N >= 5:
N-=5
c += 1
elif N >= 1:
N-=1
c += 1
print(c)