code1
stringlengths 17
427k
| code2
stringlengths 17
427k
| similar
int64 0
1
| pair_id
int64 2
181,637B
⌀ | question_pair_id
float64 3.7M
180,677B
⌀ | code1_group
int64 1
299
| code2_group
int64 1
299
|
---|---|---|---|---|---|---|
n = int(input())
lst = []
for i in range(n):
x, l = map(int, input().split())
lst.append((x + l, x - l))
sorted_lst = sorted(lst)
num = 0
ans = n
while True:
tmp = sorted_lst[num][0]
for i in range(num + 1, n):
if tmp > sorted_lst[i][1]:
ans -= 1
else:
num = i
break
if i == n - 1:
num = i
break
if num == n - 1:
break
print(ans) | x = int(input())
h500 = x // 500
h5 = (x%500) //5
print(h500 * 1000 + h5* 5) | 0 | null | 66,268,220,021,856 | 237 | 185 |
n = int(input())
d = [list(map(int, input().split())) for _i in range(n)]
c = 0
for i, j in d:
if i==j:
c += 1
if c == 3:
print('Yes')
import sys
sys.exit()
else:
c = 0
print('No') | def solution(arr):
count = 0
for i, j in arr:
if i == j:
count += 1
else:
count = 0
if count == 3:
return 'Yes'
return 'No'
n = int(input())
arr = []
for _ in range(n):
arr.append([ int(i) for i in input().split()])
print(solution(arr)) | 1 | 2,461,473,527,990 | null | 72 | 72 |
n, m = map(int, input().split())
s = []
c = []
for _ in range(m):
S, C = map(int, input().split())
s.append(S)
c.append(C)
for i in range(m):
if s[i] == 1 and c[i] == 0 and n != 1:
print(-1)
exit()
for i in range(m):
for j in range(m-1):
if s[i] == s[-j-1] and c[i] != c[-j-1]:
print(-1)
exit()
if n == 3:
one_hundred = False
ten = False
one = False
for i in range(m):
if s[i] == 1:
one_hundred = c[i]
elif s[i] == 2:
ten = c[i]
else:
one = c[i]
if one_hundred == False:
one_hundred = 1
if ten == False:
ten = 0
if one == False:
one = 0
print(one_hundred*100 + ten*10 + one)
exit()
elif n == 2:
ten = False
one = False
for i in range(m):
if s[i] == 1:
ten = c[i]
else:
one = c[i]
if ten == False:
ten = 1
if one == False:
one = 0
print(ten*10 + one)
exit()
else:
one = False
for i in range(m):
if s[i] == 1:
one = c[i]
if one == False:
one = 0
print(one)
exit()
print(-1) | #!/usr/bin/env pypy3
def I(): return int(input())
def MI(): return map(int, input().split())
def LI(): return list(map(int, input().split()))
def main():
N,M=MI()
st=pow(10,N-1)
en=pow(10,N)
if N==1:
st=0
s=[0]*M
c=[0]*M
for i in range(M):
s[i],c[i]=MI()
s[i]-=1
ans=-1
for i in range(st,en):
flag=1
i2=str(i)
for j in range(M):
aaa=int(i2[s[j]])
if aaa!=c[j]:
flag=0
break
if flag:
ans=i
break
print(ans)
main()
| 1 | 60,629,330,941,218 | null | 208 | 208 |
#!/usr/bin/env python3
import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(2147483647)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
def calc(lst):
ret = 0
for a, b, c, d in abcd:
if lst[b-1] - lst[a-1] == c:
ret += d
return ret
def dfs(lst):
if len(lst) == n:
return calc(lst)
x = lst[-1]
ret = 0
for i in range(x, m+1):
ret = max(ret, dfs(lst + [i]))
return ret
n, m, q = LI()
abcd = [LI() for _ in range(q)]
ans = dfs([1])
print(ans) | class Dice():
def __init__(self, *n):
self.rolls = n
def spin(self, order):
if order == "N":
self.rolls = [
self.rolls[1],
self.rolls[5],
self.rolls[2],
self.rolls[3],
self.rolls[0],
self.rolls[4]
]
if order == "E":
self.rolls = [
self.rolls[3],
self.rolls[1],
self.rolls[0],
self.rolls[5],
self.rolls[4],
self.rolls[2]
]
if order == "S":
self.rolls = [
self.rolls[4],
self.rolls[0],
self.rolls[2],
self.rolls[3],
self.rolls[5],
self.rolls[1]
]
if order == "W":
self.rolls = [
self.rolls[2],
self.rolls[1],
self.rolls[5],
self.rolls[0],
self.rolls[4],
self.rolls[3]
]
return self.rolls[0]
d = Dice(*[int(i) for i in input().split()])
for order in list(input()):
l = d.spin(order)
print(l) | 0 | null | 14,017,654,050,280 | 160 | 33 |
# print('input >>')
N, K = map(int,(input().split()))
ps = list(map(int,(input().split())))
ps.sort()
# print('-----output-----')
print(sum(ps[:K])) | import sys
input = sys.stdin.readline
from collections import deque
def bfs(s):
dist = [-1]*N
dist[s] = 0
q = deque([s])
while q:
v = q.popleft()
for nv in adj_list[v]:
if dist[nv]==-1:
dist[nv] = dist[v]+1
q.append(nv)
return dist
N, u, v = map(int, input().split())
adj_list = [[] for _ in range(N)]
for _ in range(N-1):
Ai, Bi = map(int, input().split())
adj_list[Ai-1].append(Bi-1)
adj_list[Bi-1].append(Ai-1)
d1 = bfs(u-1)
d2 = bfs(v-1)
ans = 0
for i in range(N):
if d1[i]<d2[i]:
ans = max(ans, d2[i]-1)
print(ans) | 0 | null | 64,533,986,103,700 | 120 | 259 |
import bisect, collections, copy, heapq, itertools, math, string
import sys
def I(): return int(sys.stdin.readline().rstrip())
def MI(): return map(int, sys.stdin.readline().rstrip().split())
def LI(): return list(map(int, sys.stdin.readline().rstrip().split()))
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())
from collections import deque
from collections import defaultdict
def main():
N = S()
N = N[::-1]
N += '0'
cnt = 0
next = 0
for i in range(len(N)):
num = int(N[i])
num += next
if num <= 4:
cnt += num
next = 0
elif num >= 6:
cnt += 10 - num
next = 1
else:
if int(N[i + 1]) <= 4:
cnt += num
next = 0
else:
cnt += 10 - num
next = 1
print(cnt)
if __name__ == "__main__":
main()
| # -*- coding: utf-8 -*-
def judge_tri(a, b, c):
if a+b>c and b+c>a and c+a>b:
return True
else:
return False
N = int(input())
L = map(int, input().split())
cnt = 0
L_sort = sorted(L)
for i in range(N):
for j in range(i+1, N, 1):
if L_sort[i] != L_sort[j]:
for k in range(j+1, N, 1):
if L_sort[i] != L_sort[k] and L_sort[j] != L_sort[k]:
if judge_tri(L_sort[i], L_sort[j], L_sort[k]):
cnt += 1
print(cnt) | 0 | null | 38,132,853,664,642 | 219 | 91 |
a,b,c = map(int, input().split())
m=0
while b >=a:
if c % b == 0 :
m = m + 1
else:
pass
b = b-1
print(m) | n,m=map(int,input().split())
lst=[[]for i in range(n)]
for i in range(n):
lst[i]=list(map(int,input().split()))
lst2=[[]*1 for i in range(m)]
for i in range(m):
lst2[i]=int(input())
for i in range(n):
x=0
for j in range(m):
x=x+lst[i][j]*lst2[j]
print("%d"%(x))
| 0 | null | 877,874,582,858 | 44 | 56 |
N = int(input())
S = set([input() for n in range(N)])
print(len(S)) | import sys
N, K = map(int, input().split())
if K == 10:
print(len(str(N)))
sys.exit()
p = 0
while True:
num = K ** p
if N < num:
break
p += 1
print(p)
| 0 | null | 47,285,653,735,562 | 165 | 212 |
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, tan, asin, acos, atan, radians, degrees, log2, gcd
from itertools import accumulate, permutations, combinations, combinations_with_replacement, product, groupby
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left, insort, insort_left
from heapq import heappush, heappop
from functools import reduce, lru_cache
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def TUPLE(): return tuple(map(int, input().split()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = 10**6#float('inf')
mod = 10 ** 9 + 7
#mod = 998244353
#from decimal import *
#import numpy as np
#decimal.getcontext().prec = 10
N = INT()
D = [LIST() for _ in range(N)]
cnt = 0
for x, y in D:
if x == y:
cnt += 1
if cnt == 3:
print("Yes")
break
else:
cnt = 0
else:
print("No") | dice = list(map(int, input().split()))
directions = input()
for direction in directions:
if direction == 'N':
dice = [dice[1], dice[5], dice[2], dice[3], dice[0], dice[4]]
elif direction == 'S':
dice = [dice[4], dice[0], dice[2], dice[3], dice[5], dice[1]]
elif direction == 'W':
dice = [dice[2], dice[1], dice[5], dice[0], dice[4], dice[3]]
else:
dice = [dice[3], dice[1], dice[0], dice[5], dice[4], dice[2]]
print(dice[0])
| 0 | null | 1,388,184,749,200 | 72 | 33 |
from math import ceil,floor,factorial,gcd,sqrt,log2,cos,sin,tan,acos,asin,atan,degrees,radians,pi,inf
from itertools import accumulate,groupby,permutations,combinations,product,combinations_with_replacement
from collections import deque,defaultdict,Counter
from bisect import bisect_left,bisect_right
from operator import itemgetter
from heapq import heapify,heappop,heappush
from queue import Queue,LifoQueue,PriorityQueue
from copy import deepcopy
from time import time
from functools import reduce
import string
import sys
sys.setrecursionlimit(10 ** 7)
def input() : return sys.stdin.readline().strip()
def INT() : return int(input())
def MAP() : return map(int,input().split())
def LIST() : return list(MAP())
n = INT()
ans = 0
for x in range(1, n+1):
y = n // x
ans += y * (y + 1) * x // 2
print(ans) | n=int(input())
ans=0
for i in range(1,n+1):
x,y=i,(n//i)*i
ans+=((n//i)*(x+y)//2)
print(ans) | 1 | 11,017,317,692,850 | null | 118 | 118 |
from collections import deque
def dfs(v):
global t
d[v] = t
visited[v] = True
t += 1
for u in graph[v]:
if not visited[u]: dfs(u)
f[v] = t
t += 1
n = int(input())
graph = [deque() for i in range(n)]
visited = [False] * n
d = [0] * n
f = [0] * n
t = 1
for i in range(n):
nums = list(map(int, input().split()))
for j in nums[2:]:
graph[i].append(j-1)
for i in range(n):
if not visited[i]: dfs(i)
for idx, df in enumerate(zip(d, f)):
print(idx+1, df[0], df[1])
| #!/usr/bin/env python3
import sys
sys.setrecursionlimit(10**6)
INF = 10 ** 9 + 1 # sys.maxsize # float("inf")
MOD = 10 ** 9 + 7
def debug(*x):
print(*x, file=sys.stderr)
def solve(N, K, AS):
for i in range(K, N):
# debug("i: i,AS[i-K],AS[K]", i, AS[i-K], AS[K])
if AS[i - K] < AS[i]:
print("Yes")
else:
print("No")
def main():
# parse input
N, K = map(int, input().split())
AS = list(map(int, input().split()))
solve(N, K, AS)
# tests
T1 = """
5 3
96 98 95 100 20
"""
TEST_T1 = """
>>> as_input(T1)
>>> main()
Yes
No
"""
T3 = """
15 7
3 1 4 1 5 9 2 6 5 3 5 8 9 7 9
"""
TEST_T3 = """
>>> as_input(T3)
>>> main()
Yes
Yes
No
Yes
Yes
No
Yes
Yes
"""
def _test():
import doctest
doctest.testmod()
g = globals()
for k in sorted(g):
if k.startswith("TEST_"):
doctest.run_docstring_examples(g[k], g)
def as_input(s):
"use in test, use given string as input file"
import io
f = io.StringIO(s.strip())
g = globals()
g["input"] = lambda: bytes(f.readline(), "ascii")
g["read"] = lambda: bytes(f.read(), "ascii")
input = sys.stdin.buffer.readline
read = sys.stdin.buffer.read
if sys.argv[-1] == "-t":
print("testing")
_test()
sys.exit()
main()
| 0 | null | 3,552,231,917,064 | 8 | 102 |
m1, d1 = map(int, input().split())
m2, d2 = map(int, input().split())
end = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
if d1 == end[m1-1]:
print(1)
else:
print(0) | """
n=int(input())
s=[int(x) for x in input().split()]
q=int(input())
t=[int(x) for x in input().split()]
#print(s)
c=0
for i in t:
if i in s:
c+=1
print(c)
"""
"""
n=int(input())
s=[int(x) for x in input().split()]
q=int(input())
t=[int(x) for x in input().split()]
#binary search
a=0
for i in range(q):
L=0
R=n-1#探索する方の配列(s)はソート済みでないといけない
while L<=R:
M=(L+R)//2
if s[M]<t[i]:
L=M+1
elif s[M]>t[i]:
R=M-1
else:
a+=1
break
print(a)
"""
#Dictionary
#dict型オブジェクトに対しinを使うとキーの存在確認になる
n=int(input())
d={}
for i in range(n):
command,words=input().split()
if command=='find':
if words in d:
print('yes')
else:
print('no')
else:
d[words]=0
| 0 | null | 62,411,977,814,690 | 264 | 23 |
n,k = map(int,input().split())
l = list(map(int,input().split()))
l.sort()
x,y=0,10**9
while y>x+1:
m = (x+y)//2
c=0
for i in l:
c+=(i-1)//m
if c<=k:
y=m
else:
x=m
print(y) | import sys
from collections import Counter
inint = lambda: int(sys.stdin.readline())
inintm = lambda: map(int, sys.stdin.readline().split())
inintl = lambda: list(inintm())
instrm = lambda: map(str, sys.stdin.readline().split())
instrl = lambda: list(instrm())
class UnionFind():
def __init__(self, n):
self.n = n # 要素数(初期頂点数)
self.root = [i for i in range(n)] # 根
self.rank = [0] * n # 深さ
self.sizes = [1] * n # 要素数(木)
def find(self, x): # 根を返す
if self.root[x] == x:
return x
self.root[x] = self.find(self.root[x]) # 経路圧縮
return self.root[x]
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.rank[x] < self.rank[y]: # 浅い方を深い方につなげる
self.root[x] = y
self.sizes[y] += self.sizes[x]
else:
self.root[y] = x
self.sizes[x] += self.sizes[y]
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
def same(self, x, y): # 同じ集合かどうかの真偽を返す
return self.find(x) == self.find(y)
def roots(self):
return {i for i, num in enumerate(self.root) if i == num}
def size(self, x):
return self.sizes[self.find(x)]
n, m = inintm()
uf = UnionFind(n)
for i in range(m):
a, b = inintm()
uf.unite(a-1, b-1)
ans = 0
r = uf.roots()
for i in r:
if uf.size(i) > ans:
ans = uf.size(i)
print(ans)
| 0 | null | 5,278,769,072,402 | 99 | 84 |
n = str(input())
tmp = 0
for i in n:
tmp += int(i)
if tmp % 9 == 0:
print("Yes")
else:
print("No") |
#!/usr/bin/python
# -*- coding: utf-8 -*-
# def
def int_mtx(N):
x = []
for _ in range(N):
x.append(list(map(int,input().split())))
return np.array(x)
def str_mtx(N):
x = []
for _ in range(N):
x.append(list(input()))
return np.array(x)
def int_map():
return map(int,input().split())
def int_list():
return list(map(int,input().split()))
def print_space(l):
return print(" ".join([str(x) for x in l]))
# import
import numpy as np
import collections as col
N = int(input())
ans = 0
for i in range(1,N):
if N%i != 0:
ans += N//i
else:
ans += N//i -1
print(ans)
| 0 | null | 3,489,225,903,140 | 87 | 73 |
N, M, Q = map(int, input().split())
a = []
b = []
c = []
d = []
for _ in range(Q):
ad, bd, cd, dd = map(int, input().split())
a.append(ad-1)
b.append(bd-1)
c.append(cd)
d.append(dd)
def score(A):
tmp = 0
for ai, bi, ci, di in zip(a, b, c, d):
if A[bi] - A[ai] == ci:
tmp += di
return tmp
def dfs(A):
if len(A) == N:
return score(A)
res = 0
prev_last = A[-1] if len(A) > 0 else 0
for v in range(prev_last, M):
A.append(v)
res = max(res, dfs(A))
A.pop()
return res
print(dfs([])) | from operator import itemgetter
N,M = map(int,input().split())
PS = [list(map(str,input().split())) for i in range(M)]
for i in range(M) :
PS[i][0] = int(PS[i][0])
submits = [["null"] for i in range(N)]
for i in range(M) :
submits[PS[i][0]-1][0] = PS[i][0]-1
submits[PS[i][0]-1].append(PS[i][1])
ac = 0
pena = 0
for i in range(len(submits)) :
if submits[i][0] == "null" :
continue
flag = False
wabuf1 = 0
for j in range(1,len(submits[i])) :
if submits[i][j] == "AC" :
ac += 1
flag = True
break
else :
wabuf1 += 1
if flag == True :
pena += wabuf1
print(ac,pena) | 0 | null | 60,411,769,832,722 | 160 | 240 |
#!/usr/bin/env python3
import collections as cl
import sys
def II():
return int(sys.stdin.readline())
def MI():
return map(int, sys.stdin.readline().split())
def LI():
return list(map(int, sys.stdin.readline().split()))
def main():
s = input()
for i in range(len(s)):
print("x", end="")
main()
| s=input()
ans="x"*len(s)
print(ans) | 1 | 72,773,058,410,780 | null | 221 | 221 |
N = int(input())
A = list(map(int,input().split()))
Q = int(input())
S = [list(map(int, input().split())) for l in range(Q)]
numList = {}
sum = 0
for n in range(N):
if A[n] not in numList:
numList[A[n]] = 0
numList[A[n]] += 1
sum += A[n]
for q in range(Q):
if S[q][0] in numList:
if S[q][1] not in numList:
numList[S[q][1]] = 0
sum += (S[q][1] - S[q][0]) * numList[S[q][0]]
numList[S[q][1]] += numList[S[q][0]]
numList[S[q][0]] = 0
print(sum) | from itertools import accumulate
import sys
input = sys.stdin.readline
N, M = map(int, input().split())
A = list(map(int, input().split()))
A.sort(reverse=True)
lb = 0
ub = 2*10**5+1
while ub - lb > 1:
m = (lb + ub) // 2
cnt = 0
s, t = 0, N-1
while t >= 0:
while s < N and A[s] + A[t] >= m:
s += 1
cnt += s
t -= 1
if cnt >= M:
lb = m
else:
ub = m
accum = list(accumulate([0] + A))
ans = 0
cnt = 0
s, t = 0, N-1
while t >= 0:
while s < N and A[s] + A[t] >= lb:
s += 1
ans += accum[s] + s * A[t]
cnt += s
t -= 1
print(ans - (cnt-M) * lb)
| 0 | null | 60,504,335,705,810 | 122 | 252 |
from itertools import accumulate
N, K = map(int, input().split())
P = list(map(int, input().split()))
Q = list(map(lambda x: (x+1)/2, P))
Q_cum = list(accumulate([0] + Q))
res = 0
for i in range(N-K+1):
temp = Q_cum[i+K]- Q_cum[i]
res = max(res, temp)
print(res) | import bisect,collections,copy,heapq,itertools,math,string
import numpy as np
import sys
sys.setrecursionlimit(10**7)
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
def _S(): return sys.stdin.readline().rstrip()
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LS(): return list(sys.stdin.readline().rstrip().split())
N,K = LI()
p = LI()
E_half = np.array(p) + 1
def main():
Pcum = np.zeros(N + 1, np.int32)
Pcum[1:] = E_half.cumsum()
# print(E_half)
# print(Pcum)
partial_sums_E_half = np.zeros(N-K+1, np.int32)
for i in range(N-K+1):
partial_sums_E_half[i] = Pcum[i+K] - Pcum[i]
# partial_sums = Pcum[K:] - Pcum[0:-K]
return (partial_sums_E_half.max())/2
print(main())
| 1 | 74,952,343,976,902 | null | 223 | 223 |
a,b = input().split()
ans = sorted( [a*int(b),b*int(a)] )[0]
print(ans) | a,b=map(int,input().split())
if a<b:
ans=str(a)*b
else:
ans=str(b)*a
print(ans) | 1 | 84,488,372,445,020 | null | 232 | 232 |
import bisect
def LI():
return list(map(int, input().split()))
N = int(input())
L = LI()
L.sort()
ans = 0
for i in range(N-1, 1, -1):
for j in range(i-1, 0, -1):
ind = bisect.bisect_right(L, L[i]-L[j])
if ind < j:
ans += j-ind
print(ans)
|
N = input()
N = N[::-1]
c = 0
otsuri = 0
mai = 0
for i in range(len(N)):
if int(N[i]) + c == 5 and i < len(N) - 1:
if int(N[i+1]) >= 5:
otsuri += 5
c = 1
else:
mai += int(N[i]) + c
c = 0
elif int(N[i]) + c > 5:
otsuri += 10 - int(N[i]) - c
c = 1
else:
mai += int(N[i]) + c
c = 0
print(otsuri + mai + c) | 0 | null | 121,110,660,630,080 | 294 | 219 |
n = int(input())
brackets_plus = []
brackets_minus = []
right = 0
left = 0
for i in range(n):
s = input()
cur = 0
m = 0
for j in range(len(s)):
if s[j] == "(":
left += 1
cur += 1
else:
right += 1
cur -= 1
m = min(m,cur)
if cur >= 0:
brackets_plus.append((m,cur))
else:
brackets_minus.append((m,cur,m-cur))
if right != left:
print("No")
exit()
cur = 0
brackets_plus.sort(reverse = True)
for i in brackets_plus:
if i[0] + cur < 0:
print("No")
exit()
cur += i[1]
brackets_minus.sort(key = lambda x:x[2])
for i in brackets_minus:
if i[0] + cur < 0:
print("No")
exit()
cur += i[1]
print("Yes") | import sys
N = int(sys.stdin.readline().strip())
S = []
for _ in range(N):
s_i = sys.stdin.readline().strip()
S.append(s_i)
# left bracket - right bracketを高さとした、最小の高さと最終的な高さの座標列
# ex)
# ")": (-1, -1)
# "(": (1, 1)
# "()": (1, 0)
# ")()(": (-1, 0)
# "))))(((((: (-4, 1)
plus_seqs = []
minus_seqs = []
for s_i in S:
h = 0
min_h = float("inf")
for bracket in s_i:
if bracket == "(":
h += 1
else:
h -= 1
min_h = min(min_h, h)
if h >= 0:
plus_seqs.append((min_h, h))
else:
# minus_seqs.append((-1 * min_h, -1 * h))
minus_seqs.append((min_h - h, -1 * h))
# print(plus_seqs)
# print(minus_seqs)
hight = 0
for (min_h, h) in sorted(plus_seqs, reverse=True):
if hight + min_h < 0:
print("No")
sys.exit()
hight += h
hight2 = 0
for (min_h, h) in sorted(minus_seqs, reverse=True):
if hight2 + min_h < 0:
print("No")
sys.exit()
hight2 += h
# print(hight, hight2)
if hight == hight2:
print("Yes")
else:
print("No") | 1 | 23,595,912,893,170 | null | 152 | 152 |
def main():
H = int(input())
W = int(input())
N = int(input())
print((N-1)//max(H,W) + 1)
if __name__ == '__main__':
main() | #!/usr/bin/env python3
import sys
import numpy as np
input = sys.stdin.readline
def ST():
return input().rstrip()
def I():
return int(input())
def MI():
return map(int, input().split())
def LI():
return list(MI())
S = ST()
cnt = np.zeros(2019)
cnt[0] = 1
res = 0
tmp = 1
for s in S[::-1]:
res += int(s) * tmp
res %= 2019
cnt[res] += 1
tmp *= 10
tmp %= 2019
ans = 0
for c in cnt[cnt >= 2]:
ans += c * (c - 1) // 2
print(int(ans))
| 0 | null | 59,567,334,721,258 | 236 | 166 |
honmyou=str(input())
print(honmyou[0:3]) | s = input()
ans = s[0]+s[1]+s[2]
print(ans) | 1 | 14,918,914,117,692 | null | 130 | 130 |
n, x, m = [int(x) for x in input().split()]
A = [x]
while len(A) < n:
a = (A[-1] * A[-1]) % m
if a not in A:
A.append(a)
else:
i = A.index(a)
loop_len = len(A) - i
print(sum(A[:i]) + sum(A[i:]) * ((n - i) // loop_len) + sum(A[i:i + ((n - i) % loop_len)]))
break
else:
print(sum(A))
| def readinput():
n,x,m=map(int,input().split())
return n,x,m
def main(n,x,m):
ans_list=[]
hist=[0]*m
val=x
count=0
while hist[val]==0 and count<n:
ans_list.append(val)
hist[val]+=1
val=(val*val)%m
if count==n:
loop_start=0
loop_len=n
else:
i=0
while ans_list[i] != val:
i+=1
loop_start=i
loop_len=len(ans_list)-i
# print(ans_list)
# print(loop_start)
# print(loop_len)
ans=sum(ans_list[:loop_start])
ans+=sum(ans_list[loop_start:])*((n-loop_start)//loop_len)
ans+=sum(ans_list[loop_start:loop_start+(n-loop_start)%loop_len])
# ans=sum(ans_list)*(n//loop_len) + sum(ans_list[:n%loop_len])
return ans
if __name__=='__main__':
n,x,m=readinput()
ans=main(n,x,m)
print(ans) | 1 | 2,788,177,687,358 | null | 75 | 75 |
n=int(input())
s=100000
for i in range(n):
s*=1.05
p=s%1000
if p!=0:
s+=1000-p
print(int(s))
| n=int(input())
s=100000
for i in range(n):
s=int(s*1.05)
if s % 1000>0:
s=s//1000*1000+1000
print(s)
| 1 | 1,207,604,598 | null | 6 | 6 |
# (+1,+2)をn回,(+2,+1)をm回とすると
# n + 2m = X
# 2n + m = Y でn,mが求まる.
# このとき答えは(n+m)Cn通り
def combination(n,r):
"""
高速な組み合わせの計算.
nCrは必ず整数になるため分母を全部約分で1にしてから残った分子の積を求める.
[参考]https://kadzus.hatenadiary.org/entry/20081211/1229023326
"""
if n-r < r: r = n-r
if r == 0: return 1
if r == 1: return int(n)
numerator = [i+1 for i in range(n-r, n)]
denominator = [i+1 for i in range(r)]
for p in range(2,r+1):
pivot = denominator[p-1]
if pivot > 1:
offset = (n-r)%p
for k in range(p-1, r, p):
numerator[k-offset] /= pivot
denominator[k] /= pivot
ans = 1
for i in range(r):
if numerator[i] > 1:
ans *= numerator[i]
if ans >= 1e9+7: ans %= 1e9+7
return int(ans)
X,Y = map(int, input().split())
if (X+Y)%3 != 0:
ans = 0
else:
n = int((2*Y-X)/3)
m = int(Y-2*n)
if n<0 or m<0:
ans = 0
else:
ans = combination(n+m, n)
print(ans) | def ncr(n, r):
num, den = 1, 1
if n - r < r:
r = n - r
for i in range(1, r + 1):
num *= n - i + 1
num %= MOD
den *= i
den %= MOD
return num * pow(den, MOD - 2, MOD) % MOD
MOD = 10 ** 9 + 7
X, Y = map(int, input().split())
Z = X + Y
if Z % 3 or Y > 2 * X or Y < X // 2:
print(0)
else:
print(ncr(Z // 3, X - Z // 3))
| 1 | 150,244,242,416,788 | null | 281 | 281 |
X = int(input())
for A in range(-118, 120):
for B in range(-119, 119):
if A**5-B**5 == X:
print(A, B)
exit() | x=int(input())
a=0
while True:
for b in range(10**3):
if a**5-b**5==x:
print(a,b)
exit()
elif a**5+b**5==x:
print(a,-b)
exit()
elif -a**5+b**5==x:
print(-a,-b)
exit()
a+=1 | 1 | 25,611,080,146,542 | null | 156 | 156 |
n=int(input())
for i in range(-150,150):
for j in range(-150,150):
if(i**5-j**5==n):
print(i,j)
exit()
| x = int(input())
for i in range(243):
for j in range(243):
if (i-121)**5 - (j-121)**5 == x:
print(i-121,j-121)
exit() | 1 | 25,543,905,381,500 | null | 156 | 156 |
def memolize(f):
cache = {}
def helper(x):
if x not in cache:
cache[x] = f(x)
return cache[x]
return helper
@memolize
def fib(n):
if n == 0:
return 1
elif n == 1:
return 1
return fib(n - 1) + fib(n - 2)
n = int(input())
print(fib(n))
| def gcd(x, y):
if y == 0:
return x
else:
return gcd(y, x%y)
def lcm(x,y):
return x/gcd(x, y)*y
while True:
try:
x, y = map(int, raw_input().split())
except EOFError:
break
print "%d %d" % (gcd(x, y), lcm(x, y)) | 0 | null | 1,304,927,660 | 7 | 5 |
import math
a, b, c = map(int, input().split())
PI = 3.1415926535897932384
c = math.radians(c)
print('{:.5f}'.format(a * b * math.sin(c) / 2))
A = a - b * math.cos(c)
B = b * math.sin(c)
print('{:.5f}'.format(math.sqrt(A * A + B * B) + a + b))
print('{:.5f}'.format(B))
| from math import *
a,b,C=map(int,raw_input().split())
C = radians(C)
print (0.5)*a*b*sin(C)
print sqrt(a**2+b**2-2*a*b*cos(C)) + a + b
h = b*sin(C)
print h | 1 | 168,413,636,772 | null | 30 | 30 |
n = int(input())
a = list(map(int, input().split()))
mod = 10**9+7
c = [0 for i in range(n+1)]
c[0] = 3
ans = 1
for i in range(n):
ans *= c[a[i]]
ans %= mod
c[a[i]] -= 1
c[a[i]+1] += 1
print (ans)
| n, *a = map(int, open(0).read().split())
mita = [0] * -~n
mita[-1] = 3
mod = 10 ** 9 + 7
c = 1
for i in range(n):
c = c * (mita[a[i] - 1] - mita[a[i]]) % mod
mita[a[i]] += 1
print(c)
| 1 | 130,366,552,364,220 | null | 268 | 268 |
#!/usr/bin/env python3
_, *a = map(int, open(0).read().split())
a.sort()
p = [0] * a[-1]
for i in a:
for j in range(1, a[-1] // i + 1):
p[j * i - 1] += j
print(sum(i == 1 for i in p))
| # -*- coding: utf-8 -*-
"""
Created on Sat Jun 17 09:19:58 2017
@author: syaga
"""
if __name__ == "__main__":
N = int(input())
A = list(map(int, input().split()))
print(" ".join(map(str, A)))
for i in range(1, N):
v = A[i]
j = i - 1
while j >= 0 and A[j] > v:
A[j+1] = A[j]
j -= 1
A[j+1] = v
print(" ".join(map(str, A))) | 0 | null | 7,199,118,715,892 | 129 | 10 |
# http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=ALDS1_2_B&lang=jp
sample_input = list(range(3))
sample_input[0] = '''6
5 6 4 2 1 3'''
sample_input[1] = '''6
5 2 4 6 1 3'''
sample_input[2] = ''''''
give_sample_input = None
if give_sample_input is not None:
sample_input_list = sample_input[give_sample_input].split('\n')
def input():
return sample_input_list.pop(0)
# main
def swap_list_item(lst, i, j):
tmp = lst[i]
lst[i] = lst[j]
lst[j] = tmp
num_of_data = int(input())
data_list = list(map(int, input().split()))
swap_count = 0
for i in range(num_of_data):
minj = i
for j in range(i, num_of_data):
if data_list[minj] > data_list[j]:
minj = j
if not minj == i:
swap_list_item(data_list, i, minj)
swap_count += 1
result = ''
for number in data_list:
result += str(number) + ' '
print(result.strip())
print(swap_count) | N = int(input())
ans = 10**12
for i in range(1,int(N**0.5)+1):
j = N/i
if(j == int(j)):
ans = i+j-2
print(int(ans)) | 0 | null | 80,414,534,458,842 | 15 | 288 |
r = int(input())
print((r + r) * 3.14) | import sys
from math import pi
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
R = int(readline())
print(2 * R * pi)
return
if __name__ == '__main__':
main()
| 1 | 31,469,891,832,628 | null | 167 | 167 |
import collections
List=collections.deque()
n=int(input())
for i in range(n):
command=input().split()
if command[0] == 'insert':
List.appendleft(command[1])
elif command[0] == 'delete':
try:List.remove(command[1])
except:pass
elif command[0] == 'deleteFirst':
List.popleft()
elif command[0] == 'deleteLast':
List.pop()
print(*List)
| import sys
import collections
N = int(input())
L = collections.deque()
for _ in range(N):
com = (sys.stdin.readline().rstrip()).split()
if com[0] == 'insert':
L.appendleft(int(com[1]))
elif com[0] == 'delete':
try:
L.remove(int(com[1]))
except:
pass
elif com[0] == 'deleteFirst':
L.popleft()
elif com[0] == 'deleteLast':
L.pop()
print(*L)
| 1 | 50,025,104,938 | null | 20 | 20 |
def solve(n,s):
if "ABC" not in s:
return 0
cnt = 0
for i in range(len(s)-2):
if "ABC" == s[i:i+3]:
cnt+=1
return cnt
n = int(input())
s = input()
ans = solve(n,s)
print(ans)
| N = int(input())
S = list(str(input()))
t = 0
for i in range(len(S)):
if S[i] == 'C' and S[i-1] == 'B' and S[i-2] == 'A':
t += 1
print(t) | 1 | 99,428,521,601,540 | null | 245 | 245 |
a, b, c = [int(s) for s in input().split()]
hit = 0
for i in range(a, b + 1):
if c % i == 0:
hit += 1
print(hit) | a,b,c = map(int,input().split(" "))
list_divisor=[i for i in range(1,c+1) if c % i == 0]
cnt = [j for j in range(a,b+1) if j in list_divisor]
print(len(cnt))
| 1 | 563,698,103,490 | null | 44 | 44 |
def main():
N,M=map(int,input().split())
S=input()
c,l=N,[]
while c>0:
for i in range(M,0,-1):
if i<=c and S[c-i]=='0':
l+=[i]
c-=i
break
else:
l=[-1]
break
print(*l[::-1])
main()
| """from collections import *
from itertools import *
from bisect import *
from heapq import *
import math
from fractions import gcd"""
import sys
#input = sys.stdin.readline
from heapq import*
N,M=map(int,input().split())
S=list(input())
S.reverse()
idx=0
lst=[]
while idx<N:
for i in range(1,M+1)[::-1]:
if i+idx<=N:
if S[i+idx]=="0":
idx+=i
lst.append(i)
break
else:
print(-1)
exit()
lst.reverse()
print(" ".join([str(i) for i in lst]))
| 1 | 139,325,465,805,360 | null | 274 | 274 |
import sys
d={}
for e in sys.stdin.readlines()[1:]:
c,g=e.split()
if'i'==c[0]:d[g]=0
else:print(['no','yes'][g in d])
| Dict = set()
n = int(input())
for i in range(n):
C = input().split()
if C[0] =="insert":
Dict.add(C[1])
else:
if C[1] in Dict:
print("yes")
else:
print("no") | 1 | 73,955,568,720 | null | 23 | 23 |
from sys import stdin
import sys
import math
from functools import reduce
import functools
import itertools
from collections import deque
x = int(stdin.readline().rstrip())
for i in range(-150,150):
for j in range(-150,150):
if i**5-j**5 == x: print(i,j); sys.exit()
| import sys
import numpy as np
from math import ceil as C, floor as F, sqrt
from collections import defaultdict as D, Counter as CNT
from functools import reduce as R
ALP = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
alp = 'abcdefghijklmnopqrstuvwxyz'
def _X(): return sys.stdin.readline().rstrip().split(' ')
def _S(ss): return tuple(ss) if len(ss) > 1 else ss[0]
def S(): return _S(_X())
def Ss(): return list(S())
def _I(ss): return tuple([int(s) for s in ss]) if isinstance(ss, tuple) else int(ss)
def I(): return _I(S())
def _Is(ss): return list(ss) if isinstance(ss, tuple) else [ss]
def Is(): return _Is(I())
x = I()
A = []
As = []
B = []
Bs = []
for i in range(250):
n = i ** 5
A.append(i)
As.append(n)
B.append(i)
Bs.append(n)
B.append(-i)
Bs.append(-n)
xs = [a-x for a in As]
for i, x in enumerate(xs):
if x in Bs:
print(A[i], B[Bs.index(x)])
break
| 1 | 25,629,430,662,010 | null | 156 | 156 |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# F - Select Half
n = int(input())
a = list(map(int, input().split()))
assert len(a) == n
# memo[i][m] a[0:i+1]からm個選ぶときの最大値
memo = [{} for i in range(n)]
memo[0] = {0: 0, 1: a[0]}
memo[1] = {1: max(a[:2])}
for i in range(2, n):
m = (i + 1) // 2
memo[i][m] = max(memo[i - 1][m], memo[i - 2][m - 1] + a[i])
if i % 2 == 0:
memo[i][m + 1] = memo[i - 2][m] + a[i]
print(memo[-1][n // 2])
| import sys
## io ##
def IS(): return sys.stdin.readline().rstrip()
def II(): return int(IS())
def MII(): return list(map(int, IS().split()))
def MIIZ(): return list(map(lambda x: x-1, MII()))
## dp ##
def DD2(d1,d2,init=0): return [[init]*d2 for _ in range(d1)]
def DD3(d1,d2,d3,init=0): return [DD2(d2,d3,init) for _ in range(d1)]
## math ##
def to_bin(x: int) -> str: return format(x, 'b') # rev => int(res, 2)
def to_oct(x: int) -> str: return format(x, 'o') # rev => int(res, 8)
def to_hex(x: int) -> str: return format(x, 'x') # rev => int(res, 16)
MOD=10**9+7
def divc(x,y) -> int: return -(-x//y)
def divf(x,y) -> int: return x//y
def gcd(x,y):
while y: x,y = y,x%y
return x
def lcm(x,y): return x*y//gcd(x,y)
def enumerate_divs(n):
"""Return a tuple list of divisor of n"""
return [(i,n//i) for i in range(1,int(n**0.5)+1) if n%i==0]
def get_primes(MAX_NUM=10**3):
"""Return a list of prime numbers n or less"""
is_prime = [True]*(MAX_NUM+1)
is_prime[0] = is_prime[1] = False
for i in range(2, int(MAX_NUM**0.5)+1):
if not is_prime[i]: continue
for j in range(i*2, MAX_NUM+1, i):
is_prime[j] = False
return [i for i in range(MAX_NUM+1) if is_prime[i]]
## libs ##
from itertools import accumulate as acc
from collections import deque, Counter
from heapq import heapify, heappop, heappush
from bisect import bisect_left
#======================================================#
def main():
a, b, m = MII()
aa = MII()
bb = MII()
q = [MII() for _ in range(m)]
minv = min(aa) + min(bb)
for x,y,c in q:
minv = min(minv, aa[x-1]+bb[y-1]-c)
print(minv)
if __name__ == '__main__':
main() | 0 | null | 45,807,016,950,720 | 177 | 200 |
from collections import deque
N, M, K = map(int,input().split())
friendlist = [[] for _ in range(N+1)]
for n in range(M):
A, B = map(int,input().split())
friendlist[A].append(B)
friendlist[B].append(A)
blocklist = [[] for _ in range(N+1)]
for n in range(K):
C, D = map(int, input().split())
blocklist[C].append(D)
blocklist[D].append(C)
whatgroup = [-1 for _ in range(N+1)]
visited = [-1] * (N+1)
d = deque()
leaderdic = {}
for person in range(1,N+1):
d.append(person)
leader = person
cnt = 0
while len(d)>0:
nowwho = d.popleft()
if whatgroup[nowwho] != -1:
continue
d.extend(friendlist[nowwho])
whatgroup[nowwho] = leader
cnt += 1
if cnt != 0:
leaderdic[leader] = cnt
for person in range(1,N+1):
ans = leaderdic[whatgroup[person]]
ans -= 1
ans -= len(friendlist[person])
for block in blocklist[person]:
if whatgroup[person]==whatgroup[block]:
ans -= 1
print(ans) | N=int(input())
zls=[0 for _ in range(N)]
wls=[0 for _ in range(N)]
for i in range(N):
x,y=[int(s) for s in input().split()]
zls[i]=x+y
wls[i]=x-y
print(max([max(zls)-min(zls),max(wls)-min(wls)])) | 0 | null | 32,508,810,665,280 | 209 | 80 |
N = int(input())
_L = list(map(int,input().split()))
L =[(v,i) for i,v in enumerate(_L)]
L = sorted(L,key = lambda x:(-x[0],x[1]))
dp = [[0]*(N+1) for _ in range(N+1)]
for i in range(N):#i番目の数字まで見た
for k in range(N):#k回(i-pi)のパターン
if k>i:
continue
val,ind = L[i]
dp[i+1][k+1] = max(dp[i+1][k+1],dp[i][k] + val * abs(ind-k))#先頭からk番目に動かす
dp[i+1][k] = max(dp[i+1][k],dp[i][k]+val * abs(N-1-(i-k)-ind))#すでに後ろからi-k個は使ってる=>後ろからN- (i-k)+1番目に動かす
print(max(dp[-1]))
| n = int(input())
a_list = list(map(int, input().split()))
dai = 0
for i in range(1, n):
if a_list[i] < a_list[i-1]:
dai += a_list[i-1] - a_list[i]
a_list[i] += a_list[i-1] - a_list[i]
# print(dai)
else:
continue
print(dai) | 0 | null | 19,158,164,930,760 | 171 | 88 |
X,N = map(int, input().split())
P = list(map(int, input().split()))
min = 51
for i in range(102):
if i not in P and abs(X-i) < min:
min = abs(X-i)
ans = i
print(ans) | n,m=[int(i) for i in input().split(" ")]
c=sorted([int(i) for i in input().split(" ")])
c.pop(0)
table=[[0 for j in range(n+1)] for i in range(m)]
for j in range(n+1):
table[0][j]=j
for i in range(1,m):
for j in range(n+1):
if j>=c[i-1]:
table[i][j]=min(table[i-1][j],table[i-1][j-c[i-1]]+1,table[i][j-c[i-1]]+1)
else:
table[i][j]=table[i-1][j]
print(table[-1][-1])
| 0 | null | 7,082,557,097,108 | 128 | 28 |
a,b,m = map(int,input().split())
A = list(map(int,input().split()))
B = list(map(int,input().split()))
ans = []
ans.append(min(A)+min(B))
for i in range(m):
M = list(map(int,input().split()))
tmp = A[M[0]-1] + B[M[1]-1] -M[2]
ans.append(tmp)
print(min(ans))
| A, B, M = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
min_price = min(a) + min(b)
for _ in range(M):
x, y, c = map(int, input().split())
discount_price = a[x-1] + b[y-1] - c
if min_price > discount_price:
min_price = discount_price
print(min_price)
| 1 | 53,967,607,259,412 | null | 200 | 200 |
n = input()
l = map(int,raw_input().split())
print min(l), max(l), sum(l) | N,M=map(int, input().split())
class UnionFind():
def __init__(self, n):
self.n = n # ノード数
self.parents = [-1]*n # 各ノードごとのparent
def find(self, x):
# 自身が根であれば
if self.parents[x]<0:
return x
# そうでなければ、再帰的に繰り返し、自身の根を探索
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
# それぞれの根
x = self.find(x)
y = self.find(y)
# 根が同一であれば
if x == y:
return
if self.parents[x] > self.parents[y]:
x,y = y,x
self.parents[x]+=self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
uf = UnionFind(N)
for _ in range(M):
i, j = map(int, input().split())
i-=1
j-=1
uf.union(i,j)
max_size = 0
for i in range(N):
if uf.parents[i]<0:
size = uf.size(i)
if max_size<size:
max_size = size
print(max_size)
| 0 | null | 2,362,471,567,024 | 48 | 84 |
import itertools
import math
import fractions
import functools
k, x = map(int, input().split())
if 500*k >= x:
print("Yes")
else:
print("No") | import itertools
n = int(input())
a = list(map(int, input().split()))
q = int(input())
M = list(map(int, input().split()))
able = [0] * (max(n * max(a) + 1, 2001))
for item in itertools.product([0, 1], repeat=n):
total = sum([i * j for i, j in zip(a, item)])
able[total] = 1
for m in M:
print('yes' if able[m] else 'no')
| 0 | null | 49,318,159,462,390 | 244 | 25 |
def main():
S = input()
def an_area(S):
ans = 0
stack_in = []
stack_out = []
for i,ch in enumerate(S):
if ch == '\\':
stack_in.append(i)
elif stack_in and ch == '/':
j = stack_in.pop()
cur = i - j
stack_out.append((j,i,cur))
ans += cur
return ans,stack_out
ans, l = an_area(S)
if ans == 0:
print(ans)
print(len(l))
return
l.sort()
pre_le, pre_ri = l[0][0], l[0][1]
pre_ar = 0
areas = []
for le,ri,ar in l:
if pre_le <= ri <= pre_ri:
pre_ar += ar
else:
areas.append(pre_ar)
pre_ar = ar
pre_le, pre_ri = le, ri
else:
areas.append(pre_ar)
print(ans)
print(len(areas),*areas)
if __name__ == '__main__':
main()
| from collections import defaultdict
BS, SL = '\\', '/'
diagram = list(input())
flood = defaultdict(int)
total = 0
stack = []
for cur, terrain in enumerate(diagram):
if terrain == BS:
stack.append(cur)
elif terrain == SL and stack:
first = stack.pop()
water = cur-first
total += water
for (f_first, f_last) in list(flood):
if first < f_first < cur:
flood[(first, cur)] += flood.pop((f_first, f_last))
flood[(first, cur)] += water
print(total)
print(' '.join(map(str, [len(flood)] + list(flood.values()))))
| 1 | 56,146,795,302 | null | 21 | 21 |
N = int(input())
c = input()
len_r = 0
len_w = 0
for i in range(N):
if c[i] == 'R':
len_r += 1
len_w = N - len_r
n_r = 0
for j in range(len_r):
if c[j] == 'R':
n_r += 1
ans = len_r - n_r
print(ans) | n = int(input())
s = input()
res = 0
tem = s.find('WR')
if tem == -1:
print(res)
else:
i, j = 0, len(s)-1
while i<j:
while i < j and s[i] != 'W': i+=1
while i < j and s[j] != 'R':j -= 1
if s[i] == 'W' and s[j] == 'R':
res += 1
i += 1
j -= 1
print(res)
| 1 | 6,291,665,518,070 | null | 98 | 98 |
N,T = list(map(int,input().split()))
A =[list(map(int,input().split())) for i in range(N)]
A.sort(key = lambda x:x[0])
INF = float("inf")
DP = [[-INF]*(T+3001) for i in range(N+1)]
DP[0][0] = 0
for i in range(N):
for j in range(T):
DP[i+1][j] = max(DP[i+1][j],DP[i][j])
DP[i+1][j+A[i][0]] = max(DP[i+1][j+A[i][0]],DP[i][j+A[i][0]],DP[i][j]+A[i][1])
score = 0
for i in range(N):
for j in range(T+A[i][0]):
score = DP[i+1][j] if DP[i+1][j]>score else score
print(score) | #A
R = int(input())
print(2*R*3.141592) | 0 | null | 91,431,837,664,300 | 282 | 167 |
x,k=map(int,input().split())
ans=0
while k**ans<=x:
ans+=1
print(ans)
| def main():
h, w, m = map(int, input().split())
hp = [0]*h
wp = [0]*w
hw = set()
for _ in range(m):
h1, w1 = map(int, input().split())
hp[h1-1] += 1
wp[w1-1] += 1
hw.add((h1, w1))
h_max = max(hp)
w_max = max(wp)
hh = [i+1 for i, v in enumerate(hp) if v == h_max]
ww = [i+1 for i, v in enumerate(wp) if v == w_max]
ans = h_max + w_max
for hb in hh:
for wb in ww:
if (hb, wb) not in hw:
print(ans)
exit()
print(ans-1)
if __name__ == '__main__':
main() | 0 | null | 34,370,636,701,480 | 212 | 89 |
import math
def main():
X=int(input())
for a in range(-120,120):
flag=0
for b in range(-120,120):
if pow(a,5)-pow(b,5)==X:
print("{} {}".format(a,b))
flag=1
break
if flag==1:
break
if __name__=="__main__":
main()
| X = int(input())
for a in range(-119, 120):
for b in range(-119, 120):
if X == a**5 - b**5:
la = a
lb = b
print(la, lb)
| 1 | 25,566,827,033,628 | null | 156 | 156 |
import sys
import math
from collections import defaultdict, deque
from copy import deepcopy
input = sys.stdin.readline
def RD(): return input().rstrip()
def F(): return float(input().rstrip())
def I(): return int(input().rstrip())
def MI(): return map(int, input().split())
def MF(): return map(float,input().split())
def LI(): return list(map(int, input().split()))
def LF(): return list(map(float,input().split()))
def Init(H, W, num): return [[num for i in range(W)] for j in range(H)]
def end_of_loop():raise StopIteration
def main():
N, K = MI()
P = LI()
C = LI()
#1週下再に加算されるスコア並びにあるますから出発した際に1マス進んだ際のスコアがわかればよい。
#初期化
ans = []
result = -float('inf')
#開始点
for i in range(N):
result2= 0
# start
temp = i
d = [-float('inf')] * N
for j in range(N):
temp = P[temp]-1
result2+=C[temp]
d[j] = result2
if temp == i:
index = j+1
score = result2
if index < K:
amari = K % index
syou = K // index
if amari !=0:
result = max(result, syou*score, syou*score+max(d[0:amari]), (syou-1)*score+max(d[0:index-1]), max(d), (syou-1)*score+max(d[0:index-1]))
else:
result = max(result, syou*score, max(d), (syou-1)*score+max(d[0:index-1]))
break
else:
result = max(result, max(d[0:K]))
break
print(result)
if __name__ == "__main__":
main() | import sys
from collections import Counter
S = ""
for s in sys.stdin:
s = s.strip().lower()
if not s:
break
S += s
for i in 'abcdefghijklmnopqrstuvwxyz':
print(i, ":", S.count(i))
| 0 | null | 3,572,867,224,420 | 93 | 63 |
from functools import reduce
from math import gcd
N=int(input())
A=list(map(int, input().split()))
c=max(A)+1
C=[0]*c
f=1
for i in A:
C[i]+=1
for i in range(2,c):
cnt=0
for j in range(i,c,i):
cnt+=C[j]
if cnt>1:
f=0
if f==1:
print('pairwise coprime')
elif reduce(gcd, A) == 1:
print('setwise coprime')
else:
print('not coprime') | n, p = map(int, input().split())
s = input()
if 10%p==0:
ans = 0
for r in range(n):
if int(s[r])%p == 0:
ans += r+1
print(ans)
exit()
d = [0]*(n+1)
ten = 1
for i in range(n-1, -1, -1):
a = int(s[i])*ten%p
d[i] = (d[i+1]+a)%p
ten *= 10
ten %= p
cnt = [0]*p
ans = 0
for i in range(n, -1, -1):
ans += cnt[d[i]]
cnt[d[i]] += 1
print(ans) | 0 | null | 31,368,593,991,392 | 85 | 205 |
n, k = map(int, input().split())
a = list(map(int, input().split()))
s = [0] * (n+1)
for i in range(n):
s[i+1] = s[i] + a[i]
s[i] = (s[i] - i) % k
s[n] = (s[n] - n) % k
count = dict()
for i in range(min(k-1, n+1)):
if not s[i] in count:
count[s[i]] = 0
count[s[i]] += 1
ans = 0
for i in range(k-1, n+1):
if not s[i] in count:
count[s[i]] = 0
count[s[i]] += 1
count[s[i-k+1]] -= 1
ans += count[s[i-k+1]]
for i in count.values():
ans += i * (i - 1) // 2
print(ans) | W, H, x, y, r = map(int, input().split())
print("Yes" if x - r >= 0 and x + r <= W and y - r >= 0 and y + r <= H else "No")
| 0 | null | 68,823,958,132,128 | 273 | 41 |
input()
print(1 if int(input().split()[1])==1 else 0) | import sys
input = lambda: sys.stdin.readline().rstrip()
def solve():
N = int(input())
if N % 2 == 1 or N < 10:
print(0)
exit()
ans = 0
div = 10
while div <= N:
ans += N // div
div *= 5
print(ans)
if __name__ == '__main__':
solve()
| 0 | null | 120,429,725,103,340 | 264 | 258 |
N = int(input())
zoro = 0
ans = 'No'
for i in range(N):
D1, D2 = map(int, input().split())
if D1 == D2:
zoro += 1
else:
zoro = 0
if zoro == 3:
ans = 'Yes'
break
print(ans) | from collections import deque
if __name__ == '__main__':
s = input()
n = int(input())
rvflg = False
d_st = deque()
d_ed = deque()
for _ in range(n):
q = input()
if len(q) == 1:
if rvflg:
rvflg = False
else:
rvflg = True
else:
i,f,c = map(str,q.split())
if f == "1":#先頭に追加
if rvflg:
#末尾に追加
d_ed.append(c)
else:
#先頭に追加
d_st.appendleft(c)
else:#末尾に追加
if rvflg:
#先頭に追加
d_st.appendleft(c)
else:
#末尾に追加
d_ed.append(c)
ans = "".join(d_st) + s + "".join(d_ed)
#最後に反転するかを決定
if rvflg:
ans = ans[::-1]
print(ans)
| 0 | null | 30,132,306,805,782 | 72 | 204 |
N = int(input())
alpha=list('abcdefghijklmnopqrstuvwxyz')
res=['']
for i in range(N):
tmp = []
for j in res:
for k in alpha[:len(set(list(j))) +1]:
tmp.append(j+k)
res = tmp
for i in res:
print(i) | import sys
from collections import deque
sys.setrecursionlimit(10 ** 6)
INF = float("inf")
MOD = 10 ** 9 + 7
def input():
return sys.stdin.readline().strip()
def bfs(N):
q = deque(["a"])
res = []
while q:
s = q.popleft()
if len(s) == N:
res.append(s)
continue
n = len(set(list(s)))
for i in range(n + 1):
c = chr(ord("a") + i)
q.append(s + c)
return res
def main():
N = int(input())
ans = bfs(N)
print(*ans, sep="\n")
if __name__ == "__main__":
main()
| 1 | 52,642,683,274,440 | null | 198 | 198 |
n, t = map(int, input().split())
lst = [0 for _ in range(t)]
ab = [list(map(int, input().split())) for _ in range(n)]
ab.sort()
ans = 0
for a, b in ab:
ans = max(ans, lst[-1] + b)
for i in range(t - 1, a - 1, -1):
lst[i] = max(lst[i], lst[i - a] + b)
print(ans) | import sys
input = sys.stdin.buffer.readline
from operator import itemgetter
import numpy as np
def main():
N,T = map(int,input().split())
food = []
for _ in range(N):
a,b = map(int,input().split())
food.append((a,b))
dp = np.zeros(T,dtype=int)
food.sort(key = itemgetter(0))
ans = 0
for a,b in food:
ans = max(ans,dp[-1]+b)
dp[a:] = np.maximum(dp[a:],dp[:-a]+b)
print(ans)
if __name__ == "__main__":
main() | 1 | 151,718,844,110,552 | null | 282 | 282 |
from collections import deque
h,w = map(int, input().split())
maze = [list(input()) for _ in range(h)]
dx = [1, 0, -1, 0]
dy = [0, 1, 0, -1]
ans = 0
for a in range(h):
for b in range(w):
if maze[a][b] == ".":
DQ = deque([(a, b)])
visit = [[-1] * w for _ in range(h)]
visit[a][b] = 0
tmp = 0
while DQ:
px, py = DQ.popleft()
for i in range(4):
nx = px + dx[i]
ny = py + dy[i]
if 0<=nx<=h-1 and 0<=ny<=w-1 and maze[nx][ny]=="." and visit[nx][ny]==-1:
visit[nx][ny] = visit[px][py] + 1
tmp = visit[nx][ny]
DQ.append((nx, ny))
ans = max(ans, tmp)
print(ans) | # D - Maze Master
# https://atcoder.jp/contests/abc151/tasks/abc151_d
from collections import deque
def main():
height, width = [int(num) for num in input().split()]
maze = [input() for _ in range(height)]
ans = 0
next_to = ((0, 1), (1, 0), (0, -1), (-1, 0))
for start_x in range(height):
for start_y in range(width):
if maze[start_x][start_y] == '#':
continue
queue = deque()
queue.append((start_x, start_y))
reached = [[-1] * width for _ in range(height)]
reached[start_x][start_y] = 0
while queue:
now_x, now_y = queue.popleft()
for move_x, move_y in next_to:
adj_x, adj_y = now_x + move_x, now_y + move_y
# Python は index = -1 が通ってしまうことに注意。
# except IndexError では回避できない。
if (not 0 <= adj_x < height
or not 0 <= adj_y < width
or maze[adj_x][adj_y] == '#'
or reached[adj_x][adj_y] != -1):
continue
queue.append((adj_x, adj_y))
reached[adj_x][adj_y] = reached[now_x][now_y] + 1
most_distant = max(max(row) for row in reached)
ans = max(most_distant, ans)
print(ans)
if __name__ == '__main__':
main()
| 1 | 94,538,445,152,932 | null | 241 | 241 |
def circle(n):
return n * n
if __name__ == "__main__":
n = int(input())
print(circle(n)) | n1 = int(input())
r1 = n1 * n1
print(r1)
| 1 | 144,747,186,312,740 | null | 278 | 278 |
import sys
input = sys.stdin.buffer.readline
sys.setrecursionlimit(10 ** 7)
N = int(input())
AB = [list(map(int, input().split())) for _ in range(N)]
if N % 2 == 1:
i = N // 2
AB.sort()
L = AB[i][0]
AB.sort(key=lambda x: x[1])
R = AB[i][1]
ans = R - L + 1
else:
i = N // 2 - 1
j = i + 1
AB.sort()
L = AB[i][0] + AB[j][0]
AB.sort(key=lambda x: x[1])
R = AB[i][1] + AB[j][1]
ans = R - L + 1
print(ans) | def main():
S, W = map(int, input().split())
if S <= W:
print("unsafe")
else:
print("safe")
if __name__ == "__main__":
main()
| 0 | null | 23,262,630,103,488 | 137 | 163 |
N=int(input())
DMY=10**9
mmax=None
mmin=None
dmax=None
dmin=None
for i in range(N):
x,y = map(int, input().split())
if not mmax:
mmax=(x,y,x+y)
mmin=(x,y,x+y)
dmax=(x,y,x+DMY-y)
dmin=(x,y,x+DMY-y)
continue
if x+y > mmax[2]:
mmax=(x,y,x+y)
elif x+y < mmin[2]:
mmin=(x,y,x+y)
if x+DMY-y > dmax[2]:
dmax=(x,y,x+DMY-y)
elif x+DMY-y < dmin[2]:
dmin=(x,y,x+DMY-y)
print(max(mmax[2]-mmin[2],dmax[2]-dmin[2]))
| N = int(input())
A = list(map(int, input().split()))
y = sorted([(i+1, A[i]) for i in range(N)], key=lambda x: x[1])
print(" ".join(map(str, [z[0] for z in y])))
| 0 | null | 92,139,720,646,752 | 80 | 299 |
import math
n,D = map(int,input().split())
cnt = 0
for i in range(n):
p,q = map(int,input().split())
d = math.sqrt(p**2 + q ** 2)
if D >= d:
cnt += 1
print(cnt) | N,D=map(int,input().split())
X=[]
for i in range(N):
X.append(list(map(int,input().split())))
count=0
for i in range(N):
if pow(X[i][0]*X[i][0]+X[i][1]*X[i][1],1/2)<=D:count+=1
print(count) | 1 | 5,891,484,137,980 | null | 96 | 96 |
#176 A
N, X, T = list(map(int, input().split()))
if N % X == 0:
print((int(N/X)) * T)
else:
print((int(N/X) + 1) * T) | n,k = map(int, input().split())
setn = {x for x in range(1,n+1)}
setd = set()
for i in range(k):
d = int(input())
setd |= set(map(int, input().split()))
print(len(setn - setd)) | 0 | null | 14,363,319,568,238 | 86 | 154 |
from functools import reduce
n = int(input())
a = list(map(int, input().split()))
b = reduce(lambda ac, x: ac ^ x, a)
print(*map(lambda x: x ^ b, a))
| n = int(raw_input())
def dfs(u,t):
global graph
global found
global timestamp
if u in found: return t
found.add(u)
timestamp[u] = [-1,-1]
timestamp[u][0] = t
t += 1
for v in graph[u]:
t = dfs(v,t)
timestamp[u][1] = t
t += 1
return t
graph = [[] for i in range(n)]
found = set()
timestamp = {}
for i in range(n):
entry = map(int,raw_input().strip().split(' '))
u = entry[0]
u -= 1
for v in entry[2:]:
v -= 1
graph[u].append(v)
t = 1
for i in range(n):
t = dfs(i,t)
for i in timestamp:
print i+1,timestamp[i][0],timestamp[i][1] | 0 | null | 6,325,898,762,888 | 123 | 8 |
a,b,c=map(int, input().split())
i=0
for x in range(a,b+1):
if c%x==0:
i+=1
print(i)
| cnt = 0
a, b, c = map(int, input().split())
if (a >= 1 and a <= 10000) and (b >= 1 and b <= 10000) and (c >= 1 and c <= 10000):
if a <= b:
for i in range(a, b+1):
if c % i == 0:
cnt += 1
print("{0}".format(str(cnt)))
else:
pass
else:
pass | 1 | 549,631,998,890 | null | 44 | 44 |
K = int(input())
Ans = 'ACL'
for i in range(K-1):
Ans += 'ACL'
print(Ans) | class ARepeatACL():
def main(self):
K = int(input())
print('ACL' * K)
if __name__ == "__main__":
this_class = ARepeatACL()
this_class.main() | 1 | 2,203,334,559,152 | null | 69 | 69 |
from collections import Counter,defaultdict,deque
from heapq import heappop,heappush
from bisect import bisect_left,bisect_right
import sys,math,itertools,fractions,pprint
sys.setrecursionlimit(10**8)
mod = 10**9+7
INF = float('inf')
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
def error():
print(-1)
quit()
n = inp()
a = inpl()
if n == 0 and sum(a) == 1:
print(1)
quit()
can = [0] * (n+1); can[0] = 1
b = [0] * (n+1)
res = [0] * (n+1)
if a[0] != 0:
error()
for i in range(n):
can[i+1] = can[i]*2 - a[i+1]
if can[i+1] < 0:
error()
can[-1] = 0
b[-1] = 0
res[-1] = a[-1]
for i in range(n)[::-1]:
b[i] = min(res[i+1], can[i])
res[i] = a[i] + b[i]
print(sum(res)) | n = int(input())
a = list(map(int, input().split()))
s = sum(a)
k = 1-a[0]
s -= a[0]
ans = 1
for i in range(1,n+1):
if k*2 <= s:
k *= 2
else:
k = s
ans += k
k -= a[i]
s -= a[i]
if k == 0 and s == 0:
print(ans)
else:
print(-1) | 1 | 18,871,027,251,758 | null | 141 | 141 |
import sys
sys.setrecursionlimit(10**9)
def mi(): return map(int,input().split())
def ii(): return int(input())
def isp(): return input().split()
def deb(text): print("-------\n{}\n-------".format(text))
INF=10**20
def main():
N,K=mi()
P=list(mi())
C=list(mi())
ans = -INF
for i in range(N):
start = i + 1
stack = [start]
score_his = [0]
scores = 0
depth = 1
seen = {}
while stack:
if depth > K: break
current = stack.pop()
if current in seen:
loop_start_depth = seen[current]
loop_end_depth = depth - 1
loop_scores = score_his[-1] - score_his[loop_start_depth-1]
loop_len = loop_end_depth - loop_start_depth + 1
if loop_scores < 0: break
# print(start,score_his)
# print(loop_start_depth,loop_end_depth,loop_scores,loop_len)
rest_count = K - depth + 1
available_loop_count = rest_count // loop_len
res1 = (available_loop_count-1) * loop_scores + scores
# print("a",rest_count,available_loop_count,res1)
res2 = res1
rest_loop_len = rest_count % loop_len + loop_len
# print("b",rest_loop_len)
ress = [res1,res2]
for j in range(rest_loop_len):
score = C[P[current-1]-1]
res2 += score
ress.append(res2)
current = P[current-1]
# print("ress",ress)
score_his.append(max(ress))
break
score = C[P[current-1]-1]
scores += score
score_his.append(scores)
seen[current] = depth
stack.append(P[current-1])
depth += 1
ans = max(ans,max(score_his[1:]))
print(ans)
if __name__ == "__main__":
main() | S = input()
S_ = S[::-1]
count = 0
for i in range(len(S)//2):
if S[i] != S_[i]:
count += 1
print(count) | 0 | null | 62,973,238,062,548 | 93 | 261 |
A,B,C,K = map(int,input().split())
SCO = 0
if A>K:
SCO+=K
else:
SCO+=A
if B<=(K-A):
if C<=(K-A-B):
SCO-=C
else:
SCO-=K-A-B
print(SCO) | import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
from collections import Counter, deque
from collections import defaultdict
from itertools import combinations, permutations, accumulate, groupby, product
from bisect import bisect_left,bisect_right
from heapq import heapify, heappop, heappush
from math import floor, ceil,pi,factorial
from operator import itemgetter
def I(): return int(input())
def MI(): return map(int, input().split())
def LI(): return list(map(int, input().split()))
def LI2(): return [int(input()) for i in range(n)]
def MXI(): return [[LI()]for i in range(n)]
def SI(): return input().rstrip()
def printns(x): print('\n'.join(x))
def printni(x): print('\n'.join(list(map(str,x))))
inf = 10**17
mod = 10**9 + 7
n=I()
lis=LI()
nleaf=[0 for i in range(n+1)]
nleaf[0]=1-lis[0]
if nleaf[0]<0:
print(-1)
sys.exit()
for i in range(n):
nleaf[i+1]=nleaf[i]*2-lis[i+1]
if nleaf[i+1]<0:
print(-1)
sys.exit()
#print(lis)
#print(nleaf)
u=list(reversed(lis))
sup=[0 for i in range(n+1)]
for i in range(n):
sup[i+1]=min(sup[i]+u[i],nleaf[n-i-1])
#print(sup[i]+u[i],nleaf[n-i-1])
#print(min(sup[i]+u[i],nleaf[n-i-1]))
#print(sup)
print(sum(lis)+sum(sup))
| 0 | null | 20,452,766,596,630 | 148 | 141 |
import sys
r=sys.stdin.readline
N,M=map(int,r().split())
city=[[] for _ in range(N+1)]
for _ in range(M):
a,b=map(int,r().split())
city[a].append(b)
city[b].append(a)
check=[True]+[False]*(N)
def dfs(v):
stack=[v]
while stack:
cur=stack.pop()
check[cur]=True
for v in city[cur]:
if not check[v]:
stack.append(v)
cnt=0
for i in range(1,N+1):
if not check[i]:
dfs(i)
cnt+=1
print(cnt-1) | class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
N, M = map(int, input().split())
uf = UnionFind(N)
import sys
input = sys.stdin.readline
import collections
for i in range(M):
A, B = map(int, input().rstrip().split())
uf.union(A-1, B-1)
doku = uf.parents.count(-1)
all = uf.group_count() - doku
ans = all + doku -1
print(ans) | 1 | 2,308,345,971,372 | null | 70 | 70 |
S = input()
T = input()
max_match = 0
n = len(T)
m = len(S)
for i in range(m-n+1):
tmp = 0
for j in range(i,i+n):
if S[j] == T[j-i]:
tmp += 1
if tmp > max_match:
max_match = tmp
ans = n - max_match
print(ans) | s = str(input())
t = str(input())
ans = len(t)
for i in range(len(s) - len(t) + 1):
tmp_ans = 0
for j in range(len(t)):
if s[i+j] != t[j]:
tmp_ans += 1
ans = min(ans, tmp_ans)
print(ans) | 1 | 3,679,693,210,620 | null | 82 | 82 |
from collections import deque
que = deque()
l = input()
S = 0
S2 = []
for j in range(len(l)):
i = l[j]
if i == '\\':
que.append(j)
continue
elif i == '/':
if len(que) == 0:
continue
k = que.pop()
pond_sum = j-k
S += pond_sum
while S2 and S2[-1][0] > k:
pond_sum += S2[-1][1]
S2.pop()
S2.append([k,pond_sum])
elif i == '_':
continue
data = [i for j,i in S2]
print(S)
print(len(S2),*data)
| def main():
line = input()
deepen_x = []
cur_x = 0
ponds = [] # [(水たまりの最初の位置, 水量)]
while len(line) > 0:
#print(cur_x, ponds, deepen_x)
tmp_char = line[0]
if tmp_char == '\\':
deepen_x.append(cur_x)
elif tmp_char == '/' and len(deepen_x) != 0:
pre_x = deepen_x.pop()
volume = cur_x - pre_x
if len(ponds) == 0:
ponds.append([pre_x, volume])
else:
if pre_x < ponds[-1][0]:
# 前の水たまりと結合する
a = list(filter(lambda x: x[0] > pre_x, ponds))
pond = 0
for item in a:
pond += item[1]
[ponds.pop() for x in range(len(a))]
ponds.append([pre_x, pond + volume])
else:
# 新しい水たまりを作成
ponds.append([pre_x, volume])
cur_x += 1
line = line[1:]
print(sum([x[1] for x in ponds]))
if len(ponds) == 0:
print('0')
else:
print("{} ".format(len(ponds)) + " ".join([str(x[1]) for x in ponds]))
return
main()
| 1 | 56,335,343,780 | null | 21 | 21 |
N=int(input())
A,B=[],[]
for i in range(N):
x,y=map(int, input().split())
A.append(x+y)
B.append(x-y)
A=sorted(A)
B=sorted(B)
print(max(abs(A[0]-A[-1]),abs(B[0]-B[-1]))) | n = int(input())
x = [None]*n
y = [None]*n
for i in range(n):
x[i],y[i] = map(int,input().split())
#y=x+k1 <=> x-y=-k1
k1 = [0]*n
#y=-x+k2 <=> x+y=k2
k2 = [0]*n
for i in range(n):
k1[i] = -(x[i]-y[i])
k2[i] = x[i]+y[i]
print(max(max(k1)-min(k1),max(k2)-min(k2))) | 1 | 3,434,993,069,422 | null | 80 | 80 |
import numpy as np
from scipy.sparse.csgraph import floyd_warshall
def main():
N, M, L = map(int, input().split())
graph = [[0] * N for _ in range(N)]
for _ in range(M):
s, t, w = map(int, input().split())
if w <= L:
graph[s-1][t-1] = graph[t-1][s-1] = w
graph = floyd_warshall(graph, directed=False)
graph = floyd_warshall(graph <= L, directed=False)
graph[np.isinf(graph)] = 0
Q = int(input())
ans = []
for _ in range(Q):
s, t = map(int, input().split())
ans.append(int(graph[s-1][t-1]) - 1)
print(*ans, sep='\n')
if __name__ == '__main__':
main()
| n = int(input())
p = list(map(int,input().split()))
q = list(map(int,input().split()))
def factorial(n) :
if n == 1:
return 1
else :
return n*factorial(n-1)
num_p = 0
num_q = 0
for i in range(n-1) :
sort_p = sorted(p[i:],reverse=True)
index_p = sort_p.index(p[i])
mp = n - (index_p + 1)
num_p += mp * factorial(n-(i+1))
sort_q = sorted(q[i:],reverse = True)
index_q = sort_q.index(q[i])
mq = n - (index_q + 1)
num_q += mq * factorial(n-(i+1))
print(abs(num_p - num_q))
| 0 | null | 137,002,681,517,578 | 295 | 246 |
H, N = map(int, input().split())
AB = [tuple(map(int, input().split())) for _ in range(N)]
dp = [10 ** 18] * (H + 1)
dp[0] = 0
for i in range(H + 1):
for A, B in AB:
if i + A >= H:
dp[H] = min(dp[H], dp[i] + B)
else:
dp[i + A] = min(dp[i + A], dp[i] + B)
res = dp[H]
print(res)
| a = list(map(int, input().split()))
HP = a[0]
x = []
for i in range(a[1]):
x1, y1 = [int(i) for i in input().split()]
x.append((x1, y1))
max_tup = max(x, key=lambda x: x[0]) #最高攻撃力の呪文を記憶
max_a = max_tup[0] #その攻撃力を記録
#1次元 横:与えるダメージ 中身:最小魔力
dp = [10**10] * (HP + max_a) #DP表はHP+最高攻撃力
dp[0] = 0
for i in range(1, len(dp)):
for a, b in x:
if i >= a:
dp[i] = min(dp[i],dp[i - a] + b )
print(min(dp[HP:])) | 1 | 81,149,336,278,550 | null | 229 | 229 |
s=input()
a,b,c,d=0,0,0,0
for i in range(len(s)):
if s[i]==">":
c=0;b+=1
if b<=d:a+=b-1
else:a+=b
else:b=0;c+=1;a+=c;d=c
print(a) | def main():
S = input()
N = len(S)+1
a = [0]*(N)
#右側からみていく
for i in range(N-1):
if S[i] == '<':
a[i+1] = max(a[i]+1,a[i+1])
#print(a)
#左側から見ていく
for i in range(N-2,-1,-1):
#print(i)
if S[i] == '>':
a[i] = max(a[i+1]+1,a[i])
ans = 0
#print(a)
for i in range(N):
ans += a[i]
return ans
print(main())
| 1 | 156,618,993,469,692 | null | 285 | 285 |
H, N, *AB = map(int, open(0).read().split())
A = AB[::2]
B = AB[1::2]
dp = [float("inf")] * (H + 1)
dp[0] = 0
for i in range(N):
for h in range(H):
dec_health = min(h + A[i], H)
dp[dec_health] = min(dp[dec_health], dp[h] + B[i])
print(dp[-1])
| def chmin(dp, i, *x):
dp[i] = min(dp[i], *x)
INF = float("inf")
# dp[i] := min 消耗する魔力 to H -= i
h, n = map(int, input().split())
dp = [0] + [INF]*h
for _ in [None]*n:
a, b = map(int, input().split())
for j in range(h + 1):
chmin(dp, min(j + a, h), dp[j] + b)
print(dp[h]) | 1 | 81,138,576,469,148 | null | 229 | 229 |
pm,pd = map(int,input().split())
nm,nd = map(int,input().split())
print(0 if pm == nm else 1) | while(1):
h,w = [int(i) for i in input().split()]
if h == 0 and w == 0:
break
for i in range(h):
print("#"*w)
print("")
| 0 | null | 62,413,871,784,210 | 264 | 49 |
import sys
stdin = sys.stdin
def ns(): return stdin.readline().rstrip()
def ni(): return int(stdin.readline().rstrip())
def nm(): return map(int, stdin.readline().split())
def nl(): return list(map(int, stdin.readline().split()))
def main():
n = ni()
A = nl()
mod = 10 ** 9 + 7
s = sum(A)
q = sum([a ** 2 for a in A])
ans = (((s * s) - q)) // 2
print(int(ans % mod))
if __name__ == '__main__':
main()
| n = int(input())
lst = list(map(int, input().split()))
mod = 10**9+7
# 累積和(Cumulative sum)リストの作成
cumsum = [0]*(n+1)
for i in range(n):
cumsum[i+1] = lst[i] + cumsum[i]
# 題意より、lst の1つ前までが対象
ans = 0
for i in range(n-1):
ans += (cumsum[n] - cumsum[i+1]) * lst[i]
print(ans % mod)
| 1 | 3,817,993,979,580 | null | 83 | 83 |
ans = -1
a = 0
K = int(input())
if K % 2 == 0:
ans = -1
elif K % 5 == 0:
ans = -1
else:
for i in range(0, K):
a = (10 * a + 7) % K
if a == 0:
ans = i + 1
break
print(ans) | import sys
a,b,c = map(int, sys.stdin.readline().split())
count=0
if a!=b :
for i in range(a,b+1):
if c%i == 0 :
count+=1
else:
if c%a == 0 :
count+=1
print(count) | 0 | null | 3,318,337,995,984 | 97 | 44 |
from fractions import gcd
from functools import reduce
n = int(input())
a_list = [int(x) for x in input().split()]
temp = reduce(lambda x, y: (x * y) // gcd(x, y), a_list)
mod = 10 ** 9 + 7
ans = sum([temp // a for a in a_list]) % mod
print(ans) | from math import log2
print(2 ** int(log2(int(input())) + 1) - 1) | 0 | null | 83,661,809,145,918 | 235 | 228 |
n=input().split()
h=input().split()
count=0
for i in range(len(h)):
if int(h[i])>=int(n[1]):
count+=1
print(count)
| X, Y, Z = [int(x) for x in input().split()]
print("%d %d %d" % (Z, X, Y))
| 0 | null | 108,133,690,667,872 | 298 | 178 |
#!/usr/bin/env python3
import sys
def solve(N: int, K: int, C: int, S: str):
l = [None] * N
r = [None] * N
pre = -float('inf')
k = -1
for cur in range(N):
if cur - pre > C and S[cur] == 'o':
k += 1
pre = cur
l[k] = cur
pre = float('inf')
k = K
for cur in range(N-1, -1, -1):
if pre - cur > C and S[cur] == 'o':
k -= 1
pre = cur
r[k] = cur
return [ll+1 for ll, rr in zip(l[:K], r[:K]) if ll == rr]
# Generated by 1.1.6 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
K = int(next(tokens)) # type: int
C = int(next(tokens)) # type: int
S = next(tokens) # type: str
print(*solve(N, K, C, S), sep='\n')
if __name__ == '__main__':
main()
| n,x,m=map(int,input().split())
def f(ai,m):
return (ai*ai)%m
if x==0:
print(0)
elif x==1:
print(n)
elif m==1:
print(0)
elif n<=m*2:
asum=x
ai=x
for i in range(1,n):
ai=f(ai,m)
asum+=ai
print(asum)
else:
chk=[-1]*m
asum00=[0]*m
ai,asum=x,0
for i in range(m):
if chk[ai]!=-1:
icnt0=chk[ai]
break
else:
chk[ai]=i
asum00[i]=asum
asum+=ai
ai=f(ai,m)
icnt=i
asum0=asum00[icnt0]
icntk=icnt-icnt0
n0=n-1-icnt0
nk=n0//icntk
nr=n0%icntk
asumk=asum-asum0
air,asumr=ai,0
for i in range(nr):
asumr+=air
air=f(air,m)
asumr+=air
ans=asum0+asumk*nk+asumr
print(ans)
| 0 | null | 21,891,381,213,030 | 182 | 75 |
N = int(input())
S = input()
ans = 0
for n in range(N-2):
if S[n:n+3] == "ABC":
ans += 1
print(ans) | n = int(input())
X = input()
a = 0
for i in range(n-2):
if X[i] + X[i+1] + X[i+2] == 'ABC':
a +=1
else:
a +=0
print(a) | 1 | 99,278,583,230,682 | null | 245 | 245 |
x = raw_input()
print int(x) ** 3 | x = input()
x = int(x)
x **= 3
print(x) | 1 | 271,674,499,710 | null | 35 | 35 |
n = int(input())
dict = {1:"a", 2:"b", 3:"c", 4:"d", 5:"e", 6:"f", 7:"g", 8:"h", 9:"i", 10:"j"}
dict2 = {"a":1, "b":2, "c":3, "d":4, "e":5, "f":6, "g":7, "h":8, "i":9, "j":10}
#ans = [["a", 1]]
#for i in range(n-1):
# newans = []
# for lis in ans:
# now = lis[0]
# count = lis[1]
# for j in range(1, count + 2):
# newans.append([now + dict[j], max(j, count)])
# ans = newans
#for lis in ans:
# print(lis[0])
def dfs(s):
if len(s) == n:
print(s)
return
m = max(s)
count = dict2[m]
for i in range(1, count+2):
dfs(s+dict[i])
dfs("a") | while True:
num = list(map(int,input().split()))
if(num[0] == 0 and num[1] == 0):
break
else:
if(num[0] > num[1]):
print("%d %d" %(num[1],num[0]))
else:
print("%d %d" %(num[0],num[1]))
| 0 | null | 26,446,146,121,542 | 198 | 43 |
k,x = map(int,input().split())
yen = k * 500
if yen < x:
print('No')
else:
print('Yes') | S,T=map(str,input().split())
A,B=map(int,input().split())
U=str(input())
if U==S:
A=A-1
elif U==T:
B=B-1
print("{} {}".format(A,B))
| 0 | null | 85,089,311,791,820 | 244 | 220 |
l=[list(map(int,input().split())) for _ in range(int(input()))]
f=sorted([x+y for x,y in l])
g=sorted([x-y for x,y in l])
print(max(f[-1]-f[0],g[-1]-g[0])) | import re
s = input()
s = re.sub('hi','0',s)
s = re.sub('0','',s)
if s == '':
print('Yes')
else:
print('No') | 0 | null | 28,305,225,745,468 | 80 | 199 |
a, nums = map(int, input().split())
add = 0
lst = list(map(int, input().split()))
lst.sort()
for i in range(0,nums):
add += lst[i]
print(add) | X,Y = map(int,input().split())
MMM = map (int,input().split())
MM = list(MMM)
MM.sort()
total = 0
for i in range(Y):
total += MM[i]
print(total)
| 1 | 11,598,512,701,568 | null | 120 | 120 |
n = int(input())
s = list(input().split())
q = int(input())
t = list(input().split())
ans = 0
for num in t:
if num in s:
ans += 1
print(ans)
| n =int(input())
S = list(map(int, input().split(' ')))
q = int(input())
T = list(map(int, input().split(' ')))
count = 0
for t in T:
if t in S:
count += 1
print(count)
| 1 | 66,350,499,550 | null | 22 | 22 |
x,y = map(int,input().split())
if (x+y)%3!=0:print(0);exit()
mod = 10**9+7
n = (x+y)//3
m = min(x-n,y-n)
frac = [1]*(n+1)
finv = [1]*(n+1)
for i in range(n):
frac[i+1] = (i+1)*frac[i]%mod
finv[-1] = pow(frac[-1],mod-2,mod)
for i in range(1,n+1):
finv[n-i] = finv[n-i+1]*(n-i+1)%mod
def nCr(n,r):
if n<0 or r<0 or n<r: return 0
r = min(r,n-r)
return frac[n]*finv[n-r]*finv[r]%mod
print(nCr(n,m)%mod) | from functools import lru_cache
MOD = 10**9+7
x,y = map(int, input().split())
summ = x+y
@lru_cache(maxsize=None)
def inv(n):
return pow(n,-1,MOD)
if summ%3 == 0 and summ//3 <= x and summ//3 <= y:
mn = min(x,y)
n = mn - summ//3
a = summ//3
b = 1
ans = 1
for i in range(n):
ans *= a
ans *= inv(b)
ans %= MOD
a -= 1
b += 1
print(ans)
else:
print(0) | 1 | 150,495,410,176,100 | null | 281 | 281 |
#import sys
#import numpy as np
import math
#from fractions import Fraction
import itertools
from collections import deque
from collections import Counter
import heapq
from fractions import gcd
#input=sys.stdin.readline
#import bisect
a,b=input().split()
a=int(a)
ans=math.floor(((a*int(b[0]))*100+(a*int(b[2]))*10+(a*int(b[3])))//100)
print(ans) | n = int(input())
a = list(map(int, input().split()))
c = 0
for i in range(n - 1):
j = a[i:].index(min(a[i:])) + i
if i != j:
a[i], a[j] = a[j], a[i]
c += 1
print(" ".join(map(str, a)))
print(c)
| 0 | null | 8,263,459,344,882 | 135 | 15 |
import bisect
N=int(input())
L=list(map(int,input().split()))
L=sorted(L)
ans=0
for i in range(N):
for j in range(i+1,N):
k=bisect.bisect_left(L,L[i]+L[j])
ans+=k-j-1
print(ans) | import sys, bisect
N = int(input())
L = list(map(int, sys.stdin.readline().rsplit()))
L.sort()
res = 0
for i in reversed(range(1, N)):
for j in reversed(range(i)):
l = bisect.bisect_left(L, L[i] + L[j])
# r = bisect.bisect_right(L, abs(L[i] - L[j]))
res += l - 1 - i
print(res)
| 1 | 171,567,267,985,212 | null | 294 | 294 |
x,y = list(map(int,input().split()))
print(x*y) | data = input().split(" ")
a ,b= int(data[0]) , int(data[1])
print(a*b) | 1 | 15,859,028,404,668 | null | 133 | 133 |
def resolve():
k,x=map(int,input().split())
if k*500 >= x:
print("Yes")
else:
print("No")
resolve() | import sys
INF = 1001001001
def resolve():
k, x = map(int, input().split())
if 500 * k >= x:
print("Yes")
else:
print("No")
return
if __name__ == "__main__":
resolve()
| 1 | 97,742,700,514,788 | null | 244 | 244 |
n,d = map(int,input().split())
su = 0
for i in range(n):
x,y = map(int,input().split())
#print("i=",i,"x,y=",x,y)
if d**2 >= x**2 +y**2:
su +=1
else:
continue
print(su) | n, d = map(int, input().split())
d_t = d**2
r = 0
for i in range(n):
a, b = map(int, input().split())
if d_t >= a**2 + b**2:
r += 1
print(r) | 1 | 5,926,671,219,418 | null | 96 | 96 |
a = raw_input().split()
W = int(a[0])
H = int(a[1])
x = int(a[2])
y = int(a[3])
r = int(a[4])
if x - r >= 0 and x + r <= W and y - r >= 0 and y + r <= H :
print "Yes"
else :
print "No" | W,H,x,y,r=map(int,raw_input().split())
if r<=x<=W-r:
if r<=y<=H-r:
print "Yes"
else:
print "No"
else:
print "No" | 1 | 443,676,148,750 | null | 41 | 41 |
n,k=map(int,input().split())
mod=10**9+7
ans=0
for x in range(k,n+2):
min_a=(0+x-1)*x//2
max_a=(n-x+1+n)*x//2
aa=max_a-min_a+1
ans+=aa
print(ans%mod) | n, k = map(int, input().split())
su = 0
for i in range(k, n+2):
co = (n+(n-i+1))*i/2 - (i-1)*i/2 + 1
su = (su + int(co)) % (10**9 + 7)
print(su) | 1 | 33,151,223,775,132 | null | 170 | 170 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.