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
|
|---|---|---|---|---|---|---|
#!usr/bin/env python3
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop
from itertools import permutations
import sys
import math
import bisect
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS(): return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == "\n":
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
x = I()
if 599 >= x >= 400:
print(8)
elif 799 >= x >= 600:
print(7)
elif 999 >= x >= 800:
print(6)
elif 1199 >= x >= 1000:
print(5)
elif 1399 >= x >= 1200:
print(4)
elif 1599 >= x >= 1400:
print(3)
elif 1799 >= x >= 1600:
print(2)
elif 1999 >= x >= 1800:
print(1)
return
# Solve
if __name__ == "__main__":
solve()
| i = int(input())
print('ACL'*i) | 0 | null | 4,479,454,276,320 | 100 | 69 |
def solve(n):
ans = 0
for i in range(1, n+1):
m = n // i
ans += m * (m+1) * i // 2
return ans
n = int(input())
print(solve(n)) | n, m = map(int, input().split())
ab = [list(map(int, input().split())) for _ in range(m)]
class Union:
def __init__(self, n):
self.parents = [-1] * n
def root(self, x):
if self.parents[x] < 0:
return x
else:
return self.root(self.parents[x])
def unite(self, x, y):
x = self.root(x)
y = self.root(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
uni = Union(n)
for a, b in ab:
uni.unite(a-1, b-1)
print(-min(uni.parents)) | 0 | null | 7,493,582,232,552 | 118 | 84 |
import math
a,b,x=map(int,input().split())
if a*a*b==x:
ans=90
elif x>((a**2)*b)/2:
ans=math.degrees(math.atan(a/(2*(b-(x/(a**2))))))
else:
ans=math.degrees(math.atan((2*x)/(a*(b**2))))
print(90-ans)
| import math
a, b, x = list(map(float, input().split()))
if x <= 0.5 * a * a * b:
res = math.degrees(math.atan(2 * x / (a * b * b)))
elif x < a * a * b:
res = math.degrees(math.atan(a / (2 * (b - x / a ** 2))))
else:
res = 90.0
print(f'{90 - res:.7f}')
| 1 | 163,747,540,969,430 | null | 289 | 289 |
H,N=map(int,input().split())
print('No' if sum(list(map(int,input().split()))) < H else 'Yes')
| H, N = [int(s) for s in input().split()]
A = [int(s) for s in input().split()]
print('Yes' if H - sum(A) <= 0 else 'No') | 1 | 77,927,098,784,352 | null | 226 | 226 |
import math
lst = []
while True:
try:
a, b = map(int, input().split())
lst.append(int(math.log10(a+b))+1)
except EOFError:
for i in lst:
print(i)
break | def mergeSort(A, left, right, n):
if left + 1 < right:
mid = int((right + left ) / 2 )
mergeSort(A, left, mid, n)
mergeSort(A, mid, right, n)
return (merge(A, left, mid, right, n))
def merge(A, left, mid, right, n):
n1 = mid - left
n2 = right - mid
L = A[left:mid] + [10 ** 9 + 1]
R = A[mid:right] + [10 ** 9 + 1]
i , j = 0, 0
for k in range(left, right):
A[n] += 1
if L[i] <= R[j]:
key = L[i]
A[k] = key
i += 1
else:
key = R[j]
A[k] = key
j += 1
return A
n = int(input())
A = list(map(int, input().split()))
A.append(0)
S = mergeSort(A, 0, len(A) - 1, n)
print(" ".join(list(map(str, S[:n]))))
print(S[n])
| 0 | null | 58,306,296,642 | 3 | 26 |
from collections import deque
n,u,v=map(int,input().split())
G=[[] for i in range(n)]
dist_u=[-1]*n
dist_v=[-1]*n
for i in range(n-1):
a,b=map(int,input().split())
G[a-1].append(b-1)
G[b-1].append(a-1)
u-=1
v-=1
dist_u[u]=0
q=deque([u])
while q:
cur=q.popleft()
for nx in G[cur]:
if dist_u[nx]==-1:
q.append(nx)
dist_u[nx]=dist_u[cur]+1
dist_v[v]=0
q=deque([v])
while q:
cur=q.popleft()
for nx in G[cur]:
if dist_v[nx]==-1:
q.append(nx)
dist_v[nx]=dist_v[cur]+1
ans=0
for i in range(n):
if dist_u[i]<dist_v[i] and dist_v[i]>=ans:
ans=dist_v[i]
print(ans-1)
| from collections import deque,defaultdict
import copy
def main():
from collections import defaultdict
import copy
n,u,v = map(int,input().split())
u -= 1
v -= 1
graph = defaultdict(deque)
for _ in range(n-1):
a,b = map(int,input().split())
a -= 1
b -= 1
graph[a].append(b)
graph[b].append(a)
depth = dfs(graph,u,n)
# print(depth)
depth2 = dfs(graph,v,n)
# print(depth2)
ans = 0
ans2 = 10**6
for i,j in zip(depth,depth2):
if i < j:
ans = max(j,ans)
# elif i == j:
# ans2 = min(j,ans2)
print(ans-1)
def dfs(G,s,n):
stack = deque([s])
graph = copy.deepcopy(G)
depth = [None] * n
depth[s] = 0
while stack:
u = stack[-1]
if graph[u]:
v = graph[u].popleft()
if depth[v] == None:
depth[v] = depth[u] + 1
stack.append(v)
else:
stack.pop()
return depth
main() | 1 | 117,632,529,637,688 | null | 259 | 259 |
string = input()
for _ in range(int(input())):
com = [x for x in input().split()]
c = com[0]
a,b = [int(com[i]) for i in range(1,3)]
if c == 'reverse':
string = string[:a] + string[a:b+1][::-1] + string[b+1:]
if c == 'print':
print(string[a:b+1])
if c == 'replace':
string = string[:a] + com[3] + string[b+1:]
| string = input()
q = int(input())
for _ in range(q):
line = input().split()
a = int(line[1])
b = int(line[2])
if line[0] == "print":
print(string[a:b+1])
elif line[0] == "reverse":
tmp = string[a:b+1]
tmp = tmp[::-1]
new_s = string[:a] + tmp + string[b+1:]
string = new_s
else:
new_s = string[:a] + line[3] + string[b+1:]
string = new_s
| 1 | 2,119,297,879,390 | null | 68 | 68 |
import sys
stdin = sys.stdin
ni = lambda: int(ns())
ns = lambda: stdin.readline().rstrip()
na = lambda: list(map(int, stdin.readline().split()))
# code here
N, R = na()
if N >= 10:
print(R)
else:
print(R + 100*(10-N))
| import math
import itertools
for i in range(int(input())):
a, b, c = sorted(map(int, input().split()))
print('YES' if a*a+b*b==c*c else 'NO') | 0 | null | 31,554,680,252,178 | 211 | 4 |
# -*- coding: utf-8 -*-
"""
Created on Mon Sep 7 01:13:08 2020
@author: liang
"""
"""
ABC 171 D 差分更新 パケット変換
【無駄な探索は行わない（メモリ化） ⇒ パケット変換】
パケット
値vが出現する回数を記録しておく
dict()方式 ⇒ 探索にO(logn) or O(n)がかかる
配列方式 ⇒ 探索がO(1)となる!
【差分更新】
値Bが全て値Cになる
⇒ (C - B) * 値Bの個数だけ増加する
⇒ 値Cの個数 += 値Bの個数
⇒ 値Bの個数 = 0
"""
N = int(input())
A = [int(i) for i in input().split()]
Q = int(input())
d = [0]*(10**5)
for i in A:
d[i-1] += 1
ans = sum(A)
for i in range(Q):
b, c = map(int,input().split())
ans += (c-b)*d[b-1]
d[c-1] += d[b-1]
d[b-1] = 0
print(ans) |
from itertools import accumulate
from collections import defaultdict, deque
def resolve():
N, K = map(int, input().split())
A = list(map(int, input().split()))
A = accumulate([a % K for a in A])
A = [0] + list(A)
# 区間 [i,j] の和(累積和): dj+1−di
# 区間 [i,j] の要素の数(0_indの為 +1): j−i+1
# 上記を一般化: dr−dl=r−l となるものの個数を求める
# r−l<K の時、mod K において式変形が成り立つ, dr−r=dl−l
# rを固定し辞書で管理すれば、dl−lと同じ値なので個数を求められる。
cnt = defaultdict(int)
q = deque()
ans = 0
for r in range(N + 1):
t = (A[r] - r) % K
ans += cnt[t]
cnt[t] += 1
q.append(t)
if len(q) == K:
left = q.popleft()
cnt[left] -= 1
print(ans)
if __name__ == "__main__":
resolve()
| 0 | null | 74,612,182,461,830 | 122 | 273 |
# Falling Asleep
# prepare input
N = int(input()) # データ数
playlist = [] # プレイリスト
for i in range(N):
s, t = input().split()
t = int(t)
playlist.append([s,t])
X = input() # 寝落ちした時の曲
# Xのある要素を線形探索 O(N)
p = 0
for i in range(N):
if playlist[i][0]==X:
p = i
break
# 時間の集計
playlist = playlist[p+1:] # プレイリストのカット
time = 0
for i in playlist:
time = time + i[1]
# 結果の出力
print(time)
| import sys
input = sys.stdin.readline
N = int(input())
musics = []
for _ in range(N):
s, t = input().split()
musics.append((s.strip(), int(t)))
X = input().strip()
ans = 0
flag = False
for s, t in musics:
if flag:
ans += t
if s == X:
flag = True
print(ans) | 1 | 96,520,749,282,240 | null | 243 | 243 |
from statistics import median
n=int(input())
A,B=[],[]
for _ in range(n):
a,b=map(int,input().split())
A.append(a*2)
B.append(b*2)
ma,mb = int(median(A)),int(median(B))
#print(ma,mb)
if n%2 == 0:
print(mb-ma+1)
else:
print((mb-ma)//2+1)
| import sys
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 19
MOD = 998244353
N, K = MAP()
A = LIST()
dp = list2d(N+1, K+1, 0)
dp[0][0] = 1
for i, a in enumerate(A):
for j in range(K+1):
dp[i+1][j] += dp[i][j] * 2
dp[i+1][j] %= MOD
if j+a <= K:
dp[i+1][j+a] += dp[i][j]
dp[i+1][j+a] %= MOD
ans = dp[N][K]
print(ans)
| 0 | null | 17,431,067,782,622 | 137 | 138 |
class dice:
value = [0] * 6
def __init__(self, list):
self.value = list
def dice_roll(self,dir):
if dir == "S":
prev = self.value
self.value = [prev[4],prev[0],prev[2],prev[3],prev[5],prev[1]]
elif dir == "N":
prev = self.value
self.value = [prev[1],prev[5],prev[2],prev[3],prev[0],prev[4]]
elif dir == "W":
prev = self.value
self.value = [prev[2],prev[1],prev[5],prev[0],prev[4],prev[3]]
elif dir == "E":
prev = self.value
self.value = [prev[3],prev[1],prev[0],prev[5],prev[4],prev[2]]
mydice = dice(list(map(int, input().split())))
x = str(input())
for i in x:
mydice.dice_roll(i)
print(mydice.value[0])
| N = int(input())
t = 0
max_run_length = 0
for _ in range(N):
D1, D2 = map(int, input().split())
if D1 == D2:
t += 1
else:
t = 0
max_run_length = max(max_run_length, t)
if max_run_length >= 3:
print('Yes')
else:
print('No')
| 0 | null | 1,341,271,431,808 | 33 | 72 |
S,T=map(str,input().split())
a,b=map(int,input().split())
U=input()
if U == S:
a +=-1
elif U == T:
b += -1
print(a,b) |
def main():
s, t = input().split()
a, b = map(int, input().split())
u = input()
if s == u:
print(a-1, b)
else:
print(a, b-1)
if __name__ == "__main__":
main()
| 1 | 71,838,208,077,482 | null | 220 | 220 |
import sys
def ISS(): return sys.stdin.readline().rstrip().split()
s,t =ISS()
print(t+s)
| s,t=input().split()
print(t+s,end='') | 1 | 102,983,258,106,948 | null | 248 | 248 |
a,b=map(int,input().split())
l=list(map(int,input().split()))
for i in range(b):
a-=l[i]
print("Yes" if a<=0 else"No") | from collections import defaultdict
n, s = map(int, input().split())
aa = tuple(sorted(map(int, input().split())))
MOD = 998244353
dp = [[0 for i in range(s + 1)] for j in range(n + 1)]
dp[0][0] = 1
for i in range(n):
for j in range(s + 1):
# 選ばない場合
dp[i + 1][j] += 2 * dp[i][j]
dp[i + 1][j] %= MOD
# j + a[i]を選んだ場合
if j + aa[i] <= s:
dp[i + 1][j + aa[i]] += dp[i][j]
dp[i + 1][j + aa[i]] %= MOD
print(dp[n][s]) | 0 | null | 47,852,150,889,440 | 226 | 138 |
S,W = map(int, input().split())
print('safe' if W < S else 'unsafe') | from typing import List
def dfs(adj_matrix: List[List[int]], vartex: int) -> int:
global step
global discover_times
global finish_times
if 0 != discover_times[vartex]:
return 0
discover_times[vartex] = step
for col_idx in range(len(adj_matrix)):
if (0 != adj_matrix[vartex][col_idx]) and (0 == discover_times[col_idx]):
step += 1
dfs(adj_matrix, col_idx)
step += 1
finish_times[vartex] = step
return 1
if __name__ == "__main__":
num_vertices = int(input())
adj_matrix = [[0] * num_vertices for i in range(num_vertices)]
for _ in range(num_vertices):
vertex, _, *adjs = map(lambda x: int(x), input().split())
for adj in adjs:
adj_matrix[vertex - 1][adj - 1] = 1
step = 1
discover_times = [0] * num_vertices
finish_times = [0] * num_vertices
for vartex in range(num_vertices):
if 1 == dfs(adj_matrix, vartex):
step += 1
for vertex, (d, f) in enumerate(zip(discover_times, finish_times)):
print(f"{vertex + 1} {d} {f}")
| 0 | null | 14,580,020,681,028 | 163 | 8 |
n, m, k = map(int, input().split(" "))
a = [int(i) for i in input().split(" ")]
b = [int(i) for i in input().split(" ")]
A = [0]
B = [0]
for i in a:
if A[-1] > k:
break
A.append(A[-1] + i)
for i in b:
if B[-1] > k:
break
B.append(B[-1] + i)
ans = 0
j = len(B) - 1
for i in range(len(A)):
if A[i] > k:
break
while A[i] + B[j] > k:
j -= 1
ans = max(ans, i + j)
print(ans)
| import sys
import math
import itertools
import collections
from collections import deque
sys.setrecursionlimit(1000000)
MOD = 10 ** 9 + 7
input = lambda: sys.stdin.readline().strip()
NI = lambda: int(input())
NMI = lambda: map(int, input().split())
NLI = lambda: list(NMI())
SI = lambda: input()
def main():
N, M, K = NMI()
A = NLI()
B = NLI()
cumsum_A = [0 for _ in range(len(A)+1)]
cumsum_B = [0 for _ in range(len(B)+1)]
cnt = 0
for n in range(N):
cnt += A[n]
cumsum_A[n+1] = cnt
cnt = 0
for m in range(M):
cnt += B[m]
cumsum_B[m+1] = cnt
ans = 0
b= M
for n in range(N+1):
remain_K = K - cumsum_A[n]
if remain_K < 0:
break
else:
for m in range(b,-1,-1):
if cumsum_B[m]> remain_K:
continue
else:
b = m
ans = max(ans,n+m)
break
print(ans)
if __name__ == '__main__':
main() | 1 | 10,769,708,434,680 | null | 117 | 117 |
while True:
i = input().split()
result = 0
if i[1] == '+':
result = int(i[0]) + int(i[2])
elif i[1] == '-':
result = int(i[0]) - int(i[2])
elif i[1] == '*':
result = int(i[0]) * int(i[2])
elif i[1] == '/':
result = int(i[0]) // int(i[2])
elif i[1] == '?':
break
print(result) | def az10():
while True:
xs = raw_input().split()
a,op,b = int(xs[0]),xs[1],int(xs[2])
if op == "?" : break
if op == "+" : print (a + b)
if op == "-" : print (a - b)
if op == "*" : print (a * b)
if op == "/" : print (a / b)
az10() | 1 | 696,343,618,110 | null | 47 | 47 |
N,K = [int(x) for x in input().split()]
count = [0]*(K+1)
ans = 0
mod = 1000000007
for i in range(K,0,-1):
kosuu = pow(K//i,N,mod)
if K // i >= 2:
for j in range(K//i,1,-1):
kosuu -= count[j*i]
ans += i*kosuu
count[i] = kosuu
print(ans%mod) | import math
N,K= map(int, input().split())
a=[0]*(K+1)
co=0
mod=(10**9+7)
for i in range(K,0,-1):
b=K//i
t=2*i
m=0
while t<=K:
m=m+a[t]
t+=i
c=pow(b,N,mod)
a[i]=c-m
co+=(a[i]*i)%mod
print(co%mod)
| 1 | 36,851,952,195,950 | null | 176 | 176 |
S = input()
ss = str()
for s in S:
ss = ss + s
if len(ss)==3:
print (ss)
break | n,k = map(int,input().split())
a = list(map(int,input().split()))
l = 0
r = 10**10
while r > l + 1:
m = (r+l)//2
count = 0
for i in a:
if i <= m:
continue
count += (i)//m
if count > k:
l = m
else:
r = m
print(r)
| 0 | null | 10,639,184,617,698 | 130 | 99 |
#!/usr/bin/env python3
def main():
_ = int(input())
P = [int(x) for x in input().split()]
res = P[0]
ans = 0
for p in P:
if p <= res:
ans += 1
res = p
print(ans)
if __name__ == '__main__':
main()
| n = int(input())
p = list(map(int,input().split()))
min_num = 10**6
cnt = 0
for i in range(n):
if p[i] < min_num:
min_num = p[i]
cnt += 1
print(cnt) | 1 | 85,537,255,131,678 | null | 233 | 233 |
n, m = [int(x) for x in input().split()]
a = [[int(x) for x in input().split()] for y in range(n)]
b = [int(input()) for x in range(m)]
c = []
for i in range(n):
c.append(sum([a[i][x] * b[x] for x in range(m)]))
for i in c:
print(i) | def ST(A,k):
#標準形の文字列を与えたときに
#長さが1大きい標準形の文字列の集合を出力
OP = []
for a in A:
max_cord = 0
for i in range(len(a)):
max_cord = max(ord(a[i]),max_cord)
for i in range(97,max_cord+2):
OP.append(a+chr(i))
return OP
N = int(input())
n,A = 1,["a"]
while n < N:
A = ST(A,n)
n += 1
A.sort()
for i in range(len(A)):
print(A[i])
| 0 | null | 26,760,429,931,840 | 56 | 198 |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
def main():
S, W = map(int, input().split())
if W >= S:
print('unsafe')
else:
print('safe')
if __name__ == '__main__':
main()
| def main():
stop = list(input())
a, b = 0, 0
for i in stop:
if 'A' == i:
a+=1
else:
b+=1
if a > 0 and b > 0:
print('Yes')
else:
print('No')
main() | 0 | null | 41,964,322,919,188 | 163 | 201 |
n = int(input())
d = {}
for i in range(n):
s = str(input())
if s in d.keys():
d[s] += 1
else:
d[s] = 1
max_count = max(d.values())
for i in sorted(d.keys()):
if d[i] == max_count:
print(i) | N = int(input())
S = [input() for i in range(N)]
dict = {}
for s in S :
dict.setdefault(s, 0)
dict[s] += 1
max_value = max(dict.values())
ans = sorted([ k for k,v in dict.items() if v == max_value])
for a in ans :
print(a) | 1 | 69,745,674,756,790 | null | 218 | 218 |
# coding: utf-8
import sys
#from operator import itemgetter
sysread = sys.stdin.buffer.readline
read = sys.stdin.buffer.read
#from heapq import heappop, heappush
#from collections import defaultdict
sys.setrecursionlimit(10**7)
#import math
#from itertools import product, accumulate, combinations, product
#import bisect# lower_bound etc
#import numpy as np
#from copy import deepcopy
#from collections import deque
def sum_count(arr):
mem = arr[:]
while True:
if len(mem) == 1:break
tmp = []
while True:
if len(mem) == 1:
tmp.append(mem[-1])
mem = tmp[:]
break
if len(mem) == 0:
mem = tmp[:]
break
x1, x2 = mem.pop(), mem.pop()
tmp.append(int(x1) + int(x2))
return int(mem[0])
def run():
N = int(input())
X = list(input())[::-1]
lis_bf = []
lis_af = []
count1 = sum_count(X)
sum_val_bf, sum_val_af = 0, 0
if count1 <= 1:
for i in range(N):
tmp_af = 0
if int(X[i]):
tmp_af = pow(2, i, count1 + 1)
lis_af.append(tmp_af)
sum_val_af += tmp_af
sum_val_af %= count1 + 1
for i in list(range(N))[::-1]:
ans = 0
if X[i] == '1':
print(0)
continue
else:
next_val = (sum_val_af + pow(2, i, count1 + 1)) % (count1 + 1)
# print(next_val)
ans += 1
# print(f'i : {i}, next_val : {next_val}')
while True:
if next_val == 0: break
val = next_val
count_n = sum_count(list(bin(val)[2:]))
next_val = val % count_n
ans += 1
# print(f'next_val : {next_val}')
print(ans)
return None
for i in range(N):
tmp_bf, tmp_af = 0,0
if int(X[i]):
tmp_bf = pow(2, i , count1-1)
tmp_af = pow(2, i, count1+1)
lis_bf.append(tmp_bf)
lis_af.append(tmp_af)
sum_val_bf += tmp_bf
sum_val_bf %= count1-1
sum_val_af += tmp_af
sum_val_af %= count1 + 1
for i in list(range(N))[::-1]:
ans = 0
if X[i] == '1':
next_val = (sum_val_bf - lis_bf[i]) % (count1-1)
else:
next_val = (sum_val_af + pow(2, i, count1+1)) % (count1+1)
#print(next_val)
ans += 1
#print(f'i : {i}, next_val : {next_val}')
while True:
if next_val == 0:break
val = next_val
count_n = sum_count(list(bin(val)[2:]))
next_val = val % count_n
ans += 1
#print(f'next_val : {next_val}')
print(ans)
if __name__ == "__main__":
run()
| N = int(input())
X = list(input())
X = [int(x) for x in X]
popcnt = 0
for i in range(N):
if X[i]:
popcnt += 1
Ys = [0,0]
for i in range(N):
if X[i]:
Ys[0] += pow(2,N-1-i,popcnt+1)
Ys[0] %= popcnt+1
if popcnt > 1:
for i in range(N):
if X[i]:
Ys[1] += pow(2,N-1-i,popcnt-1)
Ys[1] %= popcnt-1
for i in range(N):
if X[i]:#1->0
mod = popcnt-1
if mod == 0:
print(0)
continue
Y = Ys[1] - pow(2,N-1-i,mod)
else:#0->1
mod = popcnt+1
Y = Ys[0] + pow(2,N-1-i,mod)
Y %= mod
ans = 1
if Y == 0:
print(ans)
continue
while Y > 0:
L = Y.bit_length()
mod = 0
for j in range(L):
if Y>>j&1:
mod += 1
Y %= mod
ans += 1
print(ans) | 1 | 8,226,208,048,748 | null | 107 | 107 |
class Saikoro:
def sai(self,one,two,three,four,five,six):
self.s1=int(one)
self.s2=int(two)
self.s3=int(three)
self.s4=int(four)
self.s5=int(five)
self.s6=int(six)
def turnE(self):
e=[self.s4,self.s2,self.s1,self.s6,self.s5,self.s3]
self.s1=e[0]
self.s2=e[1]
self.s3=e[2]
self.s4=e[3]
self.s5=e[4]
self.s6=e[5]
def turnN(self):
n=[self.s2,self.s6,self.s3,self.s4,self.s1,self.s5]
self.s1=n[0]
self.s2=n[1]
self.s3=n[2]
self.s4=n[3]
self.s5=n[4]
self.s6=n[5]
def turnS(self):
s=[self.s5,self.s1,self.s3,self.s4,self.s6,self.s2]
self.s1=s[0]
self.s2=s[1]
self.s3=s[2]
self.s4=s[3]
self.s5=s[4]
self.s6=s[5]
def turnW(self):
w=[self.s3,self.s2,self.s6,self.s1,self.s5,self.s4]
self.s1=w[0]
self.s2=w[1]
self.s3=w[2]
self.s4=w[3]
self.s5=w[4]
self.s6=w[5]
l=input().split()
m=list(input())
sai1=Saikoro()
sai1.sai(l[0],l[1],l[2],l[3],l[4],l[5])
n=len(m)
i=0
while i<n:
if m[i]=="E":
sai1.turnE()
elif m[i]=="N":
sai1.turnN()
elif m[i]=="S":
sai1.turnS()
else:
sai1.turnW()
i+=1
print(sai1.s1)
| class Dice:
D = {'E':(3,1,0,5,4,2), 'W':(2,1,5,0,4,3), 'S':(4,0,2,3,5,1), 'N':(1,5,2,3,0,4)}
def __init__(self, tp, fwd, rs, ls, bk, bm):
self.nbrs = [tp, fwd, rs, ls, bk, bm]
def rll(self, drctn):
return [self.nbrs[i] for i in self.D[drctn]]
A = input().split()
for i in input():
dice = Dice(A[0], A[1], A[2], A[3], A[4], A[5])
A = dice.rll(i)
print(A[0])
| 1 | 237,328,165,620 | null | 33 | 33 |
from itertools import combinations_with_replacement
CList = []
N, M, Q = map(int, input().split())
for i in range(1, M+1):
CList.append(i)
Qtotal = []
x = 0
ans = 0
CList=list(combinations_with_replacement(CList, N))
a, b, c, d = map(int, input().split())
for i in CList:
if CList[x][b-1]-CList[x][a-1] == c:
Qtotal.append(d)
else:
Qtotal.append(0)
x = x+1
x=0
for i in range(Q-1):
a, b, c, d = map(int, input().split())
for j in CList:
if CList[x][b-1]-CList[x][a-1] == c:
Qtotal[x] = Qtotal[x]+d
x = x+1
x=0
ans=max(Qtotal)
print(ans)
| # -*- coding: utf-8 -*-
from itertools import combinations_with_replacement
def main():
n, m, q = map(int, input().split())
xs = []
for i in range(q):
xs.append(list(map(int, input().split())))
max = 0
for suretu in combinations_with_replacement(range(1, m + 1), n):
wa = 0
for x in xs:
a, b, c, d = x
if suretu[b - 1] - suretu[a - 1] == c:
wa += d
if wa > max:
max = wa
print(max)
if __name__ == "__main__":
main()
| 1 | 27,599,757,096,628 | null | 160 | 160 |
a = int(input())
b = int(input())
if a == 1 or b == 1:
if a == 2 or b == 2:
print(3)
else:
print(2)
else:
print(1) | S=input()
S+=input()
print(*[a for a in '123' if a not in S]) | 1 | 111,275,952,167,488 | null | 254 | 254 |
# 問題：https://atcoder.jp/contests/abc142/tasks/abc142_b
n, k = map(int, input().strip().split())
h = list(map(int, input().strip().split()))
res = 0
for i in range(n):
if h[i] < k:
continue
res += 1
print(res)
| n,k = map(int, input().split())
H = list(map(int, input().split()))
ans = 0
for i in range(n):
if H[i] >= k:
ans += 1
else:
pass
print(ans) | 1 | 178,912,384,041,910 | null | 298 | 298 |
from math import ceil
H,W=map(int,input().split())
print(ceil(H*W/2) if H!=1 and W!=1 else 1) | def main():
N,P = map(int,input().split())
S = [int(s) for s in list(input().strip())][::-1]
num = 0
ans = 0
if P == 2 or P == 5:
for i in range(N):
if S[i]%P == 0:
ans += N-i
print(ans)
return
L = [0]*P
L[0]=1
t = 0
s = 1
for z in S:
t = (z*s+t)%P
L[t]+=1
s=s*10%P
for l in L:
ans += l * (l - 1) // 2
print(ans)
if __name__ == '__main__':
main()
| 0 | null | 54,298,637,939,800 | 196 | 205 |
def insertionSort(A, n, g):
cnt_local = 0
for i in range(g, n):
v = A[i]
j = i - g
while (j >= 0 and A[j] > v):
A[j+g] = A[j]
j = j - g
cnt_local += 1
A[j+g] = v
return cnt_local
cnt_all = 0
n = int(input())
A = []
for _ in range(n):
A.append(int(input()))
G = [int((3**i-1)/2)for i in range(17,0,-1)]
G = [v for v in G if v <= n]
m = len(G)
for i in range(m):
cnt_all += insertionSort(A, n, G[i])
print(m)
print(*G)
print(cnt_all)
print(*A, sep='\n')
|
n,k = map(int,input().split())
class Combination(): # nCr mod MOD など
"""
O(n+log(mod))の前計算を1回行うことで，O(1)でnCr mod mを求められる
n_max = 10**6のとき前処理は約950ms (PyPyなら約340ms, 10**7で約1800ms)
使用例：
C = Combination(10**6)
print(C.combi_mod(5, 3)) # 10
"""
def __init__(self, n_max, mod=10**9+7): # O(n+log(mod))
self.mod = mod
self.fac, self.facinv = self.prepare(n_max)
#self.modinv = self.make_modinv_list(n_max) ##なくても問題ないので、必要な時のみ使う
def prepare(self,n): # O(n+log(mod))
# 前処理(コンストラクタで自動的に実行)
# 1! ~ n! の計算
factorials = [1] # 0!の分
for m in range(1, n+1):
factorials.append(factorials[m-1]*m%self.mod)
# n!^-1 ~ 1!^-1 の計算
invs = [1] * (n+1)
invs[n] = pow(factorials[n], self.mod-2, self.mod)
for m in range(n, 1, -1):
invs[m-1] = invs[m]*m%self.mod
return factorials, invs # list
def make_modinv_list(self, n): # O(n)
# 0からnまでのmod逆元のリストを返す O(n)
modinv = [0] * (n+1)
modinv[1] = 1
for i in range(2, n+1):
# 整数aのMを法とした時の逆元a^-1は、(0<=a<=M-1)
# a == qM+rであるとき(qは商,rは余り)、
# a^-1 == -qr^-1 % M で与えられる。
modinv[i] = (self.mod - self.mod//i)*modinv[self.mod%i] % self.mod
return modinv
def perm_mod(self,n,r): # nPr % self.mod
if n < r:
return 0
if (n < 0 or r < 0):
return 0
return (self.fac[n] * self.facinv[n-r]) % self.mod
def combi_mod(self,n,r): # nCr % self.mod
if n < r:
return 0
if (n < 0 or r < 0):
return 0
return (((self.fac[n] * self.facinv[r]) % self.mod) * self.facinv[n-r]) % self.mod
def repeated_permutation(self,n,deno): # 重複順列
# n!/(deno[0]!*deno[1]!*...*deno[len(deno)-1]) % MOD
## n:int(分子),deno:分母のlist
if n < max(deno):
return 0
if (n < 0 or min(deno) < 0):
return 0
D = 1
for i in range(len(deno)):
D = D*self.facinv[deno[i]] % self.mod
return self.fac*D % self.mod # int ## == n!/(deno[0]!*deno[1]!*...*deno[len(deno)-1]) % MOD
def H(self,n,r): # 重複組合せ nHr % self.mod
now_n = len(self.fac)
if now_n < n+r-1: # もしself.facの長さが足りなかったら追加
for i in range(now_n+1, n+r-1+1):
self.fac.append(self.fac[i-1]*i%self.mod)
return self.combi_mod(n+r-1,r)
mod = 10**9+7
C = Combination(n,mod)
ans = 0
for i in range(min(k+1,n+1)):
ans += C.combi_mod(n,i)*C.H(n-i,i)
ans %= mod
print(ans)
| 0 | null | 33,678,234,553,858 | 17 | 215 |
n = int(input())
S = map(int,raw_input().split())
q = int(input())
T = map(int,raw_input().split())
count = 0
for v in T:
for i in range(n):
if S[i] == v:
count += 1
break
print count | import sys
sys.setrecursionlimit(10**6)
def dfs(GF,group,gn,i):
size = 1
group[i]=gn
for node in GF[i]:
if group[node]==-1:
group[node]=gn
size+=dfs(GF,group,gn,node)
return size
def main():
from sys import stdin
n,m,k = map(int,stdin.readline().rstrip().split())
F=[]
for _ in range(m):
F.append(list(map(int,stdin.readline().rstrip().split())))
GF = [[] for _ in range(n+1)]
for a,b in F:
GF[a].append(b)
GF[b].append(a)
B=[]
for _ in range(k):
B.append(list(map(int,stdin.readline().rstrip().split())))
GB = [[] for _ in range(n+1)]
for a,b in B:
GB[a].append(b)
GB[b].append(a)
U = []
group= [-1]*(n+1)
gn = 0
for i in range(1,n+1):
if group[i] == -1:
sz = dfs(GF,group,gn,i)
gn+=1
U.append(sz)
for i in range(1,n+1):
g = group[i]
ans = U[g]-1-len(GF[i])
for b in GB[i]:
if group[b]==g:
ans-=1
print(ans,end=" ")
main() | 0 | null | 30,642,595,385,472 | 22 | 209 |
import math
k=int(input())
result=0
for i in range(1,k+1):
for j in range(1,k+1):
first=math.gcd(i,j)
for g in range(1,k+1):
result=result+math.gcd(first,g)
print(result)
| def main():
N = int(input())
A = (
1, 9, 30, 76, 141, 267, 400, 624, 885, 1249, 1590, 2208, 2689, 3411, 4248, 5248, 6081, 7485, 8530, 10248, 11889,
13687, 15228, 17988, 20053, 22569, 25242, 28588, 31053, 35463, 38284, 42540, 46581, 50893, 55362, 61824, 65857,
71247, 76884, 84388, 89349, 97881, 103342, 111528, 120141, 128047, 134580, 146316, 154177, 164817, 174438, 185836,
194157, 207927, 218812, 233268, 245277, 257857, 268182, 288216, 299257, 313635, 330204, 347836, 362973, 383709,
397042, 416448, 434025, 456967, 471948, 499740, 515581, 536073, 559758, 583960, 604833, 633651, 652216, 683712,
709065, 734233, 754734, 793188, 818917, 846603, 874512, 909496, 933081, 977145, 1006126, 1041504, 1073385, 1106467,
1138536, 1187112, 1215145, 1255101, 1295142, 1342852, 1373253, 1422195, 1453816, 1502376, 1553361, 1595437, 1629570,
1691292, 1726717, 1782111, 1827492, 1887772, 1925853, 1986837, 2033674, 2089776, 2145333, 2197483, 2246640, 2332104,
2379085, 2434833, 2490534, 2554600, 2609625, 2693919, 2742052, 2813988, 2875245, 2952085, 3003306, 3096024, 3157249,
3224511, 3306240, 3388576, 3444609, 3533637, 3591322, 3693924, 3767085, 3842623, 3912324, 4027884, 4102093, 4181949,
4270422, 4361548, 4427853, 4548003, 4616104, 4718640, 4812789, 4918561, 5003286, 5131848, 5205481, 5299011, 5392008,
5521384, 5610705, 5739009, 5818390, 5930196, 6052893, 6156139, 6239472, 6402720, 6493681, 6623853, 6741078, 6864016,
6953457, 7094451, 7215016, 7359936, 7475145, 7593865, 7689630, 7886244, 7984165, 8130747, 8253888, 8403448, 8523897,
8684853, 8802826, 8949612, 9105537, 9267595, 9376656, 9574704, 9686065, 9827097, 9997134, 10174780, 10290813,
10493367, 10611772, 10813692)
print(A[N - 1])
if __name__ == '__main__':
main() | 1 | 35,394,049,904,490 | null | 174 | 174 |
s = input()
if s in ['hi','hihi','hihihi','hihihihi','hihihihihi']:
print('Yes')
else:
print('No') | # -*- coding: utf-8 -*-
"""
D - Xor Sum 4
https://atcoder.jp/contests/abc147/tasks/abc147_d
"""
import sys
def solve(N, A):
MOD = 10**9 + 7
bit_len = max(map(int.bit_length, A))
ans = 0
for i in range(bit_len):
zeros, ones = 0, 0
for a in A:
if (a & 1<<i):
ones += 1
else:
zeros += 1
ans = (ans + (ones * zeros * 2**i)) % MOD
return ans % MOD
def main(args):
N = int(input())
A = list(map(int, input().split()))
ans = solve(N, A)
print(ans)
if __name__ == '__main__':
main(sys.argv[1:])
| 0 | null | 88,279,929,488,352 | 199 | 263 |
w, h, x, y, r = map(int, raw_input().split())
if x < r or y < r:
print "No"
elif x+r>w or y+r>h:
print "No"
else:
print "Yes" | whxyr = input().split()
[w, h, x, y, r] = [int(x) for x in whxyr]
if 0 <= x - r and x + r <= w and 0 <= y - r and y + r <= h:
print("Yes")
else:
print("No") | 1 | 454,641,495,868 | null | 41 | 41 |
def main():
n = int(input())
a = sorted(list(map(int,input().split())),reverse=True)
ans = a[0]
for i in range(3,n+1):
if i%2==0:
ans += a[i//2-1]
else:
ans += a[(i-1)//2]
print(ans)
if __name__ == "__main__":
main()
| N = int(input())
A = sorted(list(map(int,input().split())),reverse=True)
ans = A[0]
for i in range(1,N//2):
ans += 2* A[i]
if N%2 == 1:
ans += A[N//2]
print(ans) | 1 | 9,166,023,119,152 | null | 111 | 111 |
N=int(input())
*A,=map(int,input().split())
Q=int(input())
*M,=map(int,input().split())
mf=['no']*Q
t=[]
for i in range(0,2**N):
ans=0
for j in range(N):
if (i>>j&1):
ans+=A[j]
t.append(ans)
tset=set(t)
for i in range(Q):
if M[i] in tset:
mf[i] = 'yes'
for i in mf:
print(i)
| def main():
import sys, itertools as ite
n = int(sys.stdin.readline())
A = tuple(map(int, sys.stdin.readline().split()))
#print(A)
q = int(sys.stdin.readline())
M = map(int, sys.stdin.readline().split())
bit = ite.product([0,1], repeat=n)
ans = []
for b in bit:
tmp = 0
for i in range(n):
tmp +=b[i]*A[i]
ans += [tmp]
for m in M:
if m in ans:
print('yes')
else:
print('no')
if __name__=='__main__':
main()
| 1 | 103,681,993,774 | null | 25 | 25 |
# 初期入力
r = int(input())
#mennseki_r =3.14*r*r
#mennseki_1 =3.14*1*1
#kotae =int(mennseki_r / mennseki_1)
kotae=r*r
print(kotae) | import math
n, d = input().split()
count = 0
dn = int(d)
for i in range(int(n)):
x = list(map(int,input().split()))
if dn >= math.sqrt(x[0] ** 2 + x[1] ** 2):
count += 1
print(count) | 0 | null | 75,627,265,262,592 | 278 | 96 |
A,B = map(int,input().split())
x = A
y = B
while y>0:
x,y = y,x%y
print((A//x)*B) | import fractions
a,b=map(int,input().split())
c = fractions.gcd(a,b)
print(int((a*b)/c)) | 1 | 113,140,165,062,120 | null | 256 | 256 |
K = list(map(int,input().split()))
m = K[0]*500
if m >= K[1]:
print('Yes')
else:
print('No')
| def solve():
K, X = map(int, input().split())
return "Yes" if K*500 >= X else "No"
print(solve()) | 1 | 98,277,052,890,380 | null | 244 | 244 |
from itertools import groupby
S=input()
K=int(input())
count=0
group=[len(list(value)) for key,value in groupby(S)]
for value in group:
count+=value//2
count*=K
if S[0]==S[-1] and group[0]%2!=0 and group[-1]%2!=0:
if len(S)==group[0]:
count+=K//2
else:
count+=K-1
print(count) | def insertionSort(table, g):
global cnt
for i in range(g, len(table)):
v = table[i]
j = i - g
while j >= 0 and table[j] > v:
table[j + g] = table[j]
j = j - g
cnt += 1
table[j + g] = v
def shellSort(table):
gap = [1]
while gap[0] * 3 + 1 < len(table):
gap.insert(0, (gap[0] * 3 + 1))
for g in gap:
insertionSort(table, g)
return gap
n = int(input())
table = []
cnt =0
for i in range(n):
table.append(int(input()))
gap = shellSort(table)
print(len(gap))
print(' '.join(map(str, gap)))
print(cnt)
print('\n'.join(map(str, table)))
| 0 | null | 87,601,622,991,200 | 296 | 17 |
print(~-int(input())//2) | from collections import deque
N,K = map(int,input().split())
A = [int(i) for i in input().split()]
B = deque(A[:K])
for i in range(K,N):
if B.popleft() < A[i]:
print('Yes')
else:
print('No')
B.append(A[i])
| 0 | null | 80,148,384,471,080 | 283 | 102 |
def tripleDots(n, string):
string_len = len(string)
if string_len > n :
string = string[ 0 : n ] + "..."
print(string)
arr = ["", ""]
for i in range(2):
arr[i] = input()
tripleDots(int(arr[0]), arr[1]) | import sys
k, s = sys.stdin.readlines()
k = int(k)
s = s.strip()
if len(s) <= k:
print(s)
else:
print('{}...'.format(s[:k])) | 1 | 19,669,894,766,300 | null | 143 | 143 |
for i in range(1, 10):
for j in range(1, 10):
fmt = format("{0}x{1}={2}")
g = fmt.format(i, j, i*j)
print(g) | def input_int():
return map(int, input().split())
def one_int():
return int(input())
def one_str():
return input()
def many_int():
return list(map(int, input().split()))
A, B = input_int()
print(A*B) | 0 | null | 7,885,352,110,818 | 1 | 133 |
num = raw_input()
num_list = raw_input().split()
num_list = map(int, num_list)
count = 0
def bubble_sort(num_list, count):
flag = True
i = 0
while flag:
flag = False
for j in range(len(num_list)-1, i, -1):
if num_list[j-1] > num_list[j]:
temp = num_list[j]
num_list[j] = num_list[j-1]
num_list[j-1] = temp
count += 1
flag = True
i += 1
return count
count = bubble_sort(num_list, count)
num_list = map(str, num_list)
print " ".join(num_list)
print count | n = int(input()) - 1
a = list(map(int, input().split()))
count = 0
flag = 1
while flag:
flag = 0
j = 0
for i in range( n, j, -1 ):
if a[i] < a[i-1]:
t = a[i]
a[i] = a[i-1]
a[i-1] = t
count += 1
flag = 1
j += 1
print(*a)
print(count) | 1 | 16,111,273,474 | null | 14 | 14 |
N, K = map(int, input().split())
def base_10_to_n(X, n):
if (int(X / n)):
return base_10_to_n(int(X / n), n) + str(X % n)
return str(X % n)
ans = base_10_to_n(N, K)
print(len(str(ans)))
| n,k = map(int,input().split())
keta = 1
while k ** keta <= n:
keta += 1
print(keta) | 1 | 64,151,301,386,130 | null | 212 | 212 |
n = input()
debt = 100000
for i in range(n):
debt *= 1.05
if(debt % 1000):
debt -= debt % 1000
debt += 1000
print(int(debt)) | from pprint import pprint
n,m=map(int,input().split())
c=list(map(int,input().split()))
dp=[[10**5]*(n+1) for _ in range(m+1)]
dp[0][0]=0
for i in range(m):
for j in range(n+1):
if c[i]>j:
dp[i+1][j]=dp[i][j]
else:
dp[i+1][j]=min(dp[i][j],dp[i][j-c[i]]+1,dp[i+1][j-c[i]]+1)
# pprint(dp)
print(dp[m][n])
| 0 | null | 72,013,996,012 | 6 | 28 |
H,W = (int(x) for x in input().split())
lines = [input() for i in range(H)]
dp = [[0] * W for _ in range(H)]
if lines[0][0] == "#":
dp[0][0] = 1
q = r = dp[0][0]
for i in range(H):
for j in range(W):
if i == j == 0: continue
if j > 0:
q = dp[i][j-1]
if lines[i][j] == "#" and lines[i][j-1] == ".":
q = dp[i][j-1] + 1
if i > 0:
r = dp[i-1][j]
if lines[i][j] == "#" and lines[i-1][j] == ".":
r = dp[i-1][j] + 1
if j == 0:
dp[i][j] = r
elif i == 0:
dp[i][j] = q
else:
dp[i][j] = min(q,r)
print(dp[H-1][W-1]) | H,W=map(int,input().split())
s=[]
for _ in range(H):
s.append(list(input()))
inf=float("inf")
ans=[[inf]*W for _ in range(H)]
if s[0][0]==".":
ans[0][0]=0
else:
ans[0][0]=1
for i in range(H):
for j in range(W):
if j!=W-1:
if s[i][j]=="." and s[i][j+1]=="#":
ans[i][j+1]=min(ans[i][j]+1,ans[i][j+1])
else:
ans[i][j+1]=min(ans[i][j],ans[i][j+1])
if i!=H-1:
if s[i][j]=="." and s[i+1][j]=="#":
ans[i+1][j]=min(ans[i][j]+1,ans[i+1][j])
else:
ans[i+1][j]=min(ans[i][j],ans[i+1][j])
print(ans[H-1][W-1])
| 1 | 49,355,533,479,812 | null | 194 | 194 |
#!/usr/bin/env python3
import sys
from typing import NamedTuple, List
class Game(NamedTuple):
c: List[int]
s: List[List[int]]
def solve(D: int, c: "List[int]", s: "List[List[int]]", t: "List[int]"):
from functools import reduce
ans = [0]
lasts = [0] * 26
sum_c = sum(c)
daily_loss = sum_c
bits = [BIT(D*2) for _ in range(26)]
for day, tt in enumerate(t, 1):
a = s[day-1][tt-1]
lasts[tt-1] = day
for i in range(26):
bits[i].add(day, lasts[i]*c[i])
a -= daily_loss
a += sum(b.sum(day)-b.sum(day-1) for b in bits)
ans.append(ans[-1]+a)
daily_loss += sum_c
return ans[1:]
# https://kopricky.github.io/code/For_Python/bit.html
class BIT:
def __init__(self, node_size):
self._node = node_size+1
self.bit = [0]*self._node
def add(self, index, add_val):
index += 1
while index < self._node:
self.bit[index] += add_val
index += index & -index
def sum(self, index):
index += 1
res = 0
while index > 0:
res += self.bit[index]
index -= index & -index
return res
# Generated by 1.1.7.1 https://github.com/kyuridenamida/atcoder-tools
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
D = int(next(tokens)) # type: int
c = [int(next(tokens)) for _ in range(26)] # type: "List[int]"
s = [[int(next(tokens)) for _ in range(26)] for _ in range(D)] # type: "List[List[int]]"
t = [int(next(tokens)) for _ in range(D)] # type: "List[int]"
print(*solve(D, c, s, t), sep="\n")
def test():
import doctest
doctest.testmod()
if __name__ == '__main__':
#test()
main()
| #-*-coding:utf-8-*-
import sys
input=sys.stdin.readline
import heapq
def main():
A=[]
B=[]
M=[]
values=[]
a,b,m = map(int,input().split())
A=list(map(int,input().split()))
B=list(map(int,input().split()))
M=[list(map(int,input().split())) for _ in range(m)]
# #割引した組み合わせ
for m in M:
values.append(A[m[0]-1]+B[m[1]-1]-m[2])
heapq.heapify(A)
heapq.heapify(B)
#最も安い組み合わせ
cheap=heapq.heappop(A)+heapq.heappop(B)
print(min(cheap,min(values)))
if __name__=="__main__":
main() | 0 | null | 31,836,474,247,368 | 114 | 200 |
n = int(input())
if n%2==1:
print(0)
else:
# 2の倍数には不足しないので、5の倍数を数える
i=1
cnt=0
while n//(5**i*2) > 0:
cnt += n//((5**i)*2)
i += 1
print(cnt) | import sys
input = sys.stdin.readline
def I(): return int(input())
def MI(): return map(int, input().split())
def LI(): return list(map(int, input().split()))
def main():
mod=10**9+7
N=I()
if N%2==1:
print(0)
exit()
ans=0
for i in range(1,100):
a=2*pow(5,i)
ans+=N//a
print(ans)
main()
| 1 | 116,011,899,196,480 | null | 258 | 258 |
T=input()
for i in range(len(T)):
T=T.replace(T[i],'x')
print(T) | import sys
sys.setrecursionlimit(10**7)
input = sys.stdin.readline
s = input().rstrip()
n = len(s)
print('x'*n)
| 1 | 72,638,030,738,092 | null | 221 | 221 |
n, q = list(map(int, input().split()))
que = []
for _ in range(n):
name, time = input().split()
que.append([name, int(time)])
elapsed_time = 0
while que:
name, time = que.pop(0)
dt = min(q, time)
time -= dt
elapsed_time += dt
if time > 0:
que.append([name, time])
else:
print (name, elapsed_time) | # coding: utf-8
# Here your code !
import sys
from collections import deque
class CPU():
def __init__(self, in_quantum):
self.quantum = in_quantum
self.total_time = 0
def deal(self, in_process, in_time):
this_process_time = 0
if in_time[0] > self.quantum:
remain_time = in_time[0] - self.quantum
this_process_time = in_time[0] - remain_time
in_process.append(in_process[0])
in_time.append(remain_time)
self.total_time += this_process_time
else:
this_process_time = in_time[0]
self.total_time += this_process_time
#make log
self.makeLog(in_process[0])
in_process.popleft()
in_time.popleft()
return in_process, in_time
def makeLog(self, in_process):
print(in_process, self.total_time)
processes = deque()
times = deque()
data_cnt, quantum = list(map(int,input().split(" ")))
for i in range(data_cnt):
tmp_process, tmp_time = input().split(" ")
processes.append(tmp_process)
times.append(int(tmp_time))
objCPU = CPU(quantum)
while True:
processes, times = objCPU.deal(processes, times)
if len(processes) == 0:
break | 1 | 41,662,189,442 | null | 19 | 19 |
n, k = map(int, input().split())
p = list(map(lambda x: (1+int(x))/2, input().split()))
s = sum(p[0:k])
ans = s
for i in range(k, n):
s += p[i] - p[i-k]
ans = max(ans, s)
print(ans) | N, K = map(int,input().split())
P = [0]+list(map(int,input().split()))
for i in range(1,N+1):
p = P[i]
p = (1+p)/2
P[i] = p+P[i-1]
ans = 0
for i in range(N-K+1):
ans = max(ans,P[i+K]-P[i])
print(ans) | 1 | 75,163,858,674,160 | null | 223 | 223 |
i = 1
while True:
n = input()
if n != 0:
print 'Case %s: %s' % (str(i), str(n))
i = i + 1
else:
break | count = 0
for i in range(10000):
a = input()
a = int(a)
if a >= 1:
count += 1
print('Case '+str(count)+': '+str(a))
else:
break
| 1 | 485,880,767,132 | null | 42 | 42 |
def is_ok(arg):
return not Alist[arg] <= t
def bisect(ok, ng):
while abs(ok - ng) > 1:
mid = (ok + ng) // 2
if is_ok(mid):
ok = mid
else:
ng = mid
return ok
N, M, K = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
Alist = [0]
for i in range(N):
Alist.append(Alist[i] + A[i])
ans = 0
for i in range(N+1):
if Alist[i] <= K:
ans = i
else:
break
b = 0
for i in range(M):
b += B[i]
t = K - b
if t >= 0:
res = bisect(N + 1, -1)
ans = max(ans, i + res)
else:
break
print(ans) | n,m = map(int, input().split())
print("Yes") if n-m==0 else print("No") | 0 | null | 46,896,691,181,622 | 117 | 231 |
K = int(input())
seven_number = 0
ality = 0
for ans in range(1,10**7):
if ans > K:
print("-1")
break
else:
seven_number = (seven_number*10+7) % K
if seven_number ==0:
print(ans)
break
| k = int(input())
start = 7
if k % 2 == 0:
print("-1")
exit()
for i in range(k + 1):
if start % k == 0:
print(i + 1)
exit()
start = (start * 10 + 7) % k
print("-1") | 1 | 6,128,884,115,900 | null | 97 | 97 |
S = raw_input().split(" ")
for i in range(0, len(S)):
S[i] = int(S[i])
primeNum = 0
for i in range(S[0], S[1]+1):
if(S[2] % i == 0):
primeNum = primeNum+1
print(primeNum) | import itertools
n = int(input())
d = list(map(int, input().split()))
sum = 0
for i in itertools.combinations(d, 2):
sum += i[0] * i[1]
print(sum)
| 0 | null | 84,302,028,246,748 | 44 | 292 |
from itertools import combinations
N = int(input())
L = list(map(int, input().split()))
ans = 0
for a, b, c in combinations(L, 3):
if a == b or b ==c or a == c:
continue
if a + b + c - max(a, b, c) > max(a, b, c):
ans += 1
print(ans) | N = int(input())
L = list(map(int, input().split()))
count = 0
for i in range(N):
for j in range(i+1,N):
for k in range(j+1,N):
if L[i] != L[j] and L[j] != L[k] and L[i] != L[k] and max(L[i],L[j],L[k]) < sum([L[i],L[j],L[k]])/2:
count+=1
print(count) | 1 | 5,028,693,159,932 | null | 91 | 91 |
a, b, c = eval(input().replace(' ', ','))
print("Yes" if a < b < c else "No") | a,b,c=map(int, input().split())
0<=a<=100,0<=b<=100,0<=c<=100,
if a<b:
if b<c:
print('Yes')
else:
print('No')
else:
print('No')
| 1 | 389,834,636,970 | null | 39 | 39 |
import os
import sys
import numpy as np
def solve(N, K, S, P, R, T):
dp = np.zeros((N+1, 3), dtype=np.int64)
for i in range(1, N+1):
c = T[i]
dp[i, 0] = max(dp[i-K, 1], dp[i-K, 2]) + (c == "r") * R
dp[i, 1] = max(dp[i-K, 0], dp[i-K, 2]) + (c == "s") * S
dp[i, 2] = max(dp[i-K, 0], dp[i-K, 1]) + (c == "p") * P
#d = dp.max(1)
d = np.zeros(N+1, dtype=np.int64)
for i in range(N+1):
d[i] = dp[i].max()
ans = d[-K:].sum()
return ans
# >>> numba compile >>>
numba_config = [
[solve, "i8(i8,i8,i8,i8,i8,string)"],
]
if sys.argv[-1] == "ONLINE_JUDGE":
from numba import njit
from numba.pycc import CC
cc = CC("my_module")
for func, signature in numba_config:
vars()[func.__name__] = njit(signature)(func)
cc.export(func.__name__, signature)(func)
cc.compile()
exit()
elif os.name == "posix":
exec(f"from my_module import {','.join(func.__name__ for func, _ in numba_config)}")
else:
from numba import njit
for func, signature in numba_config:
vars()[func.__name__] = njit(signature, cache=True)(func)
print("compiled!", file=sys.stderr)
# <<< numba compile <<<
def main():
N, K = map(int, input().split())
S, P, R = map(int, input().split())
T = "_" + input()
ans = solve(N, K, S, P, R, T)
print(ans)
main()
| import bisect,collections,copy,itertools,math,string
import sys
def I(): return int(sys.stdin.readline().rstrip())
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())
def main():
n,k = LI()
r,s,p = LI()
t = list(S())
ans = 0
for i in t[:k]:
if i=="r":
ans += p
elif i == "s":
ans += r
elif i == "p":
ans += s
for i in range(k,n):
if t[i]=="r":
if t[i-k]=="r":
t[i] = ""
else:
ans += p
elif t[i]=="s":
if t[i-k]=="s":
t[i] = ""
else:
ans += r
elif t[i]=="p":
if t[i-k]=="p":
t[i] = ""
else:
ans += s
print(ans)
main()
| 1 | 107,025,196,553,408 | null | 251 | 251 |
import sys
import time
import random
import math
from collections import deque
import heapq
import itertools
from decimal import Decimal
import bisect
from operator import itemgetter
MAX_INT = int(10e18)
MIN_INT = -MAX_INT
mod = 1000000000+7
sys.setrecursionlimit(1000000)
def IL(): return list(map(int,input().split()))
def SL(): return input().split()
def I(): return int(sys.stdin.readline())
def S(): return input()
def tami(ans):
res = 0
LastDay = [0]*26
for i in range(D):
res += s[i][ans[i]]
for j in range(26):
if ans[i] == j:
continue
res -= (i+1 - LastDay[j]) * c[j]
LastDay[ans[i]] = i+1
return res
def nasu():
res = []
LastDay = [0]*26
for d in range(1,D+1):
tmp = ["", 0]
for i in range(26):
if tmp[1] < s[d-1][i] + (d - LastDay[i]) * c[i]:
tmp = [i, s[d-1][i] + (d - LastDay[i]) * c[i]]
res.append(tmp[0])
LastDay[tmp[0]] = d
return res
def nbo(ans, score, num):
tmp_ans = ans[:]
for _ in range(num):
random_date = random.randint(0,D-1)
random_val = random.randint(0,25)
tmp_ans[random_date] = random_val
scoscore = tami(tmp_ans)
if scoscore > score:
return (True, tmp_ans, scoscore)
else:
return (False, tmp_ans, scoscore)
start = time.time()
D = I()
c = IL()
s = [IL() for i in range(D)]
ans = nasu()
#print(ans)
score = tami(ans)
#print(score)
end = time.time()
num = 10
cnt = 0
while (time.time() - start) < 1.8:
judge, anans, scoscore = nbo(ans, score, num)
if judge == True:
ans, score = anans, scoscore
#print(ans)
#print(tami(ans))
cnt += 1
if cnt == 1000:
cnt = 0
num = max(2, num-1)
for i in ans:
print(i+1) | x = list(map(int,list(input())))
n = len(x)
dp = [[0,1] for _ in range(n+1)]
for i in range(n):
dp[i+1][0] = min(dp[i][0]+x[i],dp[i][1]+10-x[i])
dp[i+1][1] = min(dp[i][0]+x[i]+1,dp[i][1]+9-x[i])
print(dp[n][0])
| 0 | null | 40,546,605,689,220 | 113 | 219 |
l=int(input())
ll=l/3
print(ll**3) | h = int(input())
w = int(input())
n = int(input())
m = max(w,h)
if n > n //m * m:
ans = n // m + 1
else:
ans = n // m
print(ans) | 0 | null | 67,932,846,431,524 | 191 | 236 |
nd = list(map(int, input().split()))
N = nd[0]
D = nd[1]
ans = 0
for i in range(N):
x = list(map(int, input().split()))
if x[0] ** 2 + x[1] ** 2 <= D ** 2:
ans += 1
print(ans)
| n,d = map(int, input().split())
xy = [map(int, input().split()) for _ in range(n)]
x, y = [list(i) for i in zip(*xy)]
ans=0
for i in range(n):
if x[i]**2+y[i]**2<=d**2:
ans+=1
print(ans) | 1 | 5,917,712,600,800 | null | 96 | 96 |
N = int(input())
d = {}
ans = []
for i in range(N):
S = input()
d.setdefault(S,0)
d[S] += 1
max = max(d.values())
for key in d.keys():
if d[key] == max:
ans.append(key)
ans = sorted(ans)
for word in ans:
print(word) | from collections import Counter
n = int(input())
s = [input() for _ in range(n)]
c = Counter(s)
csort = sorted(c.items(), key=lambda x:x[1],reverse=True)
maxc = csort[0][1]
ans = []
for s,v in csort:
if v == maxc:
ans.append(s)
anssort = sorted(ans)
for s in anssort:
print(s) | 1 | 69,604,889,243,610 | null | 218 | 218 |
def bigcmb(N, R, MOD):
if (R < 0) or (N < R):
return 0
R = min(R, N - R)
fact, inv = 1, 1
for i in range(1, R + 1):
fact = (fact * (N - i + 1)) % MOD
inv = (inv * i) % MOD
return fact * pow(inv, MOD - 2, MOD) % MOD
X, Y = map(int, input().split())
if (X + Y) % 3 != 0:
print(0)
exit()
mod = 10**9 + 7
count = (X + Y) // 3
ans = bigcmb(count, X - count, mod)
print(ans) | print(eval(input().replace(*' *'))) | 0 | null | 83,219,190,763,172 | 281 | 133 |
s_max = -float('inf')
s = 0
for i in range(int(input())):
r = int(input())
if i:
s = max(s, 0) + r - prev
s_max = max(s, s_max)
prev = r
print(s_max)
| room = [[[],[],[]],[[],[],[]],[[],[],[]],[[],[],[]]]
for i in range(4):
for j in range(3):
for k in range(10):
room[i][j].append(0)
n = int(input())
for _ in range(n):
b, f, r, v = map(int, input().split())
room[b-1][f-1][r-1] += v
for i in range(4):
for j in range(3):
print(" "+" ".join(map(str, room[i][j])))
if i != 3: print("#"*20) | 0 | null | 548,897,602,870 | 13 | 55 |
H = int(input())
import math
def caracal(H):
if H == 1:
return 1
return 2*caracal(math.floor(H/2)) + 1
print(caracal(H))
| n = input()
if n[0] == '7' or n[1] == '7' or n[2] == '7':
ans = 'Yes'
else:
ans = 'No'
print(ans) | 0 | null | 56,874,911,519,452 | 228 | 172 |
a, b = map(int, input().split())
print(a // b, a % b, "{:f}".format(a / b)) |
splited = input().split(" ")
f = int(splited[0])/int(splited[1])
r = int(splited[0])%int(splited[1])
d = int(splited[0])//int(splited[1])
print(d, r, "{0:.5f}".format(f)) | 1 | 592,553,452,460 | null | 45 | 45 |
n = int(input())
p = list(map(int, input().split()))
ans = 0
min_p = n
for i in p:
if i <= min_p:
min_p = i
ans += 1
print(ans)
|
N = int(input())
"""
愚直にやると、Kを2～Nの範囲で全部調べて数え上げる。N <= 10**12 なので間に合わない。
たとえば N=100だと、
[2, 3, 4, 9, 10, 11, 33, 99, 100]
が条件を満たす数字になる。
割り算を行わないとき、明らかに N % K = 1 になる
これは、「NをKで割ったら、１あまる」であるから、「N-1をKでわったら割り切れる」ともいえる。
なので、割り算が起こらないものは、N-1の約数。
割り算が起こるやつは、割れるだけ割った後、余りを調べればよい。
"""
def solve(n):
i = 1
ret = set()
while i * i <= n:
if n % i == 0:
ret.add(i)
ret.add(n // i)
i += 1
return ret
div_N_sub_1 = solve(N-1)
div_N = solve(N)
ans = len(div_N_sub_1) - 1
for i in div_N:
if i == 1:
continue
tmp = N
while tmp % i == 0:
tmp //= i
if tmp % i == 1:
ans += 1
print(ans) | 0 | null | 63,140,710,545,828 | 233 | 183 |
import bisect,collections,copy,heapq,itertools,math,string
import numpy as np
import sys
sys.setrecursionlimit(10**7)
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 = I()
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
divisors.sort()
return divisors
# c = sympy.divisors(N)
c = make_divisors(N)
lenc = len(c)
if (lenc % 2)==0:
a = c[lenc // 2 - 1]
b = c[lenc // 2]
else:
a = c[lenc // 2]
b = a
print(a + b -2)
#H,N = LI()
#AB = [LI() for _ in range(N)]
#A,B = zip(*AB)
#Ap = np.array(A)
#C = np.zeros(N + 1)
# if ans:
# print('Yes')
# else:
# print('No') | n=int(input())
ans = n
for i in range(1,int(n**0.5)+2):
if n % i == 0:
ans = min(ans,(i-1)+(n//i-1))
print(ans) | 1 | 162,118,198,460,892 | null | 288 | 288 |
n, k = map(int, input().split(" "))
MOD = (10**9) + 7
def dSum(s, e):
s -= 1
_s = s * (s + 1) // 2
_e = e * (e + 1) // 2
return _e - _s
ans = 0
for i in range(k, n + 1):
# _sum = dSum(n - i - 1, n) - dSum(0, i - 1) + 1
ans += dSum(i, n) - dSum(0, n - i) + 1
print((ans + 1) % MOD)
| N,K = map(int,input().split())
counter = 0
for k in range(K,N+2):
counter += k*(N-k+1) + 1
print(counter%(pow(10,9)+7)) | 1 | 33,242,887,028,602 | null | 170 | 170 |
n,k=map(int,input().split())
B=list(map(int,input().split()))
S=list(input())
A=[[] for i in range(k)]
for i in range(n):
if S[i]=="s":
A[i%k].append(0)
elif S[i]=="p":
A[i%k].append(1)
else:
A[i%k].append(2)
ans=0
for i in range(k):
f=0
for j in range(len(A[i])):
if f==0:
ans=ans+B[A[i][j]]
if j!=len(A[i])-1:
if A[i][j]==A[i][j+1]:
f=1
else:
f=0
print(ans) | import math
k = int(input())
a, b = list(map(int, input().split()))
mul = math.floor(b/k) * k
if(mul >= a and (mul >= a and mul <= b)):
print('OK')
else:
print('NG') | 0 | null | 66,559,326,345,788 | 251 | 158 |
cnt = 0
n = int(input())
lst = list(map(int, input().split()))
for i in range(n):
m = i
for j in range(i, n):
if lst[j] < lst[m]:
m = j
if m != i:
lst[i], lst[m] = lst[m], lst[i]
cnt += 1
print(*lst)
print(cnt) | def selection(A,n):
count = 0
for i in range(0,n-1):
min = i
for j in range(i,n):
if(A[j] < A[min]):
min = j
if(min!=i):
A[i], A[min] = A[min], A[i]
count+=1
printList(A)
print(count)
def printList(A):
print(" ".join(str(x) for x in A))
n = int(input())
A = [int(x) for x in input().split()]
selection(A,n) | 1 | 21,219,337,828 | null | 15 | 15 |
import numpy as np
H, W = map(int, input().split())
masu = [input() for i in range(H)]
#temp = [list(input().replace("#","0").replace(".","1")) for i in range(H)]
#masu = [[int(temp[i][j]) for j in range(W)] for i in range(H)]
#dp = np.zeros((H, W))
dp = [[0]*W for i in range(H)]
if masu[0][0] == "#":
dp[0][0] = 1
for i in range(0,H):
for j in range(0,W):
if i == 0:
a = 100000
else:
if masu[i][j] == "#" and masu[i-1][j] == ".":
a = dp[i-1][j] + 1
else:
a = dp[i-1][j]
if j == 0:
b = 100000
else:
if masu[i][j] == "#" and masu[i][j-1] == ".":
b = dp[i][j-1] + 1
else:
b = dp[i][j-1]
if a != 100000 or b != 100000:
dp[i][j] = min([a, b])
print(int(dp[H-1][W-1]))
| from functools import reduce
N = int(input())
A = list(map(int, input().split()))
m = reduce(lambda a, b: a^b, A)
l = list(map(str, [a ^ m for a in A]))
ans = ' '.join(l)
print(ans) | 0 | null | 30,854,917,893,632 | 194 | 123 |
W = input().lower()
count = 0
while True:
l = input()
if l == 'END_OF_TEXT':
break
for i in l.lower().split():
if i == W:
count += 1
print(count) | def main():
Counter = 0
Text_W = input()
while True:
Text_T = input()
if "END_OF_TEXT" in Text_T:
temp = Text_T.lower().split()
for i in range(len(temp)):
Counter += 1 if Text_W == temp[i] else 0
break
else:
temp = Text_T.lower().split()
for i in range(len(temp)):
Counter += 1 if Text_W == temp[i] else 0
print (Counter)
if __name__ == '__main__':
main()
| 1 | 1,829,954,660,448 | null | 65 | 65 |
#input()
ans=1
for i in map(int,input().split()):ans*=i
print(int(ans)) | import sys
input = sys.stdin.readline
n = int(input())
a_ord = ord('a')
s = ["a"]
ans = []
def dfs(s):
max_ord = a_ord
for i in s:
max_ord = max(max_ord, ord(i))
for i in range(a_ord, max_ord + 2):
t = s[:]
t.append(chr(i))
if len(t) == n:
ans.append("".join(t))
else:
dfs(t)
if n == 1:
print('a')
else:
dfs(s)
ans.sort()
for w in ans:
print(w) | 0 | null | 34,145,389,124,472 | 133 | 198 |
from bisect import bisect_left
X, N = list(map(int, input().split()))
P = list(map(int, input().split()))
P.sort()
S = set(P)
if N == 0:
print(X)
exit()
def bisectsearch_left(L, a):
i = bisect_left(L, a)
return(i)
k = bisectsearch_left(P, X)
if X != P[k]:
print(X)
else:
ct = 0
while True:
ct += 1
if X-ct not in S:
print(X-ct)
break
elif X+ct not in S:
print(X+ct)
break | s, w = map(int, input().split())
if s<=w:
print("unsafe")
else:
print("safe") | 0 | null | 21,825,974,077,600 | 128 | 163 |
A,B=map(int,input().strip().split())
print(max(A-2*B,0)) | import itertools
##print(ord("A"))
a,b,= map(int,input().split())
ans= a-b*2
if ans <=0:
print(0)
else:
print(ans) | 1 | 166,437,657,533,070 | null | 291 | 291 |
n = int(input())
if n%2 == 0:
t=(n//2)/n
else:
t=(n//2+1)/n
print('{:.10f}'.format(t)) | def resolve():
N = int(input())
print((N//2+1)/N if N%2==1 else 0.5)
if '__main__' == __name__:
resolve() | 1 | 177,278,434,737,988 | null | 297 | 297 |
import math
n = []
score = []
scores = []
while True:
input_n = int(input())
if input_n == 0:
break
n.append(input_n)
input_score = [int(i) for i in input().split()]
score.append(input_score)
def total(scorelist):
total = 0
for i in range(len(scorelist)):
total = total + scorelist[i]
return total
def ave(total,n):
return float(total / n)
def variance(scorelist,ave,n):
total = 0
for i in range(len(scorelist)):
total = total + math.pow(scorelist[i]-ave,2)
return total / n
for i in range(len(n)):
total_score = total(score[i])
average = ave(total_score,n[i])
var = variance(score[i],average,n[i])
print(math.sqrt(var)) | import queue
def main():
n = int(input())
A = list(map(int,input().split()))
A = sorted(A,reverse=True)
q = queue.PriorityQueue()
q.put([-1*A[0],-1*A[0]])
ans = 0
for a in A[1:]:
_min, _max = map(lambda x:-1*x,q.get())
ans += _min
q.put([-1*a,-1*_min])
q.put([-1*a,-1*_max])
print(ans)
return
if __name__ == "__main__":
main() | 0 | null | 4,635,987,082,958 | 31 | 111 |
from scipy.sparse.csgraph import floyd_warshall
import sys
input = sys.stdin.readline
def solve():
inf = float("Inf")
n,m,l = (int(i) for i in input().split())
path = [[-1*inf]*n for _ in range(n)]
for i in range(m):
a,b,c = (int(i) for i in input().split())
path[a-1][b-1] = c
path[b-1][a-1] = c
d = floyd_warshall(path)
q = int(input())
minipath = [[-1*inf]*n for _ in range(n)]
for i in range(n):
for j in range(n):
if d[i][j] <= l:
minipath[i][j] = 1
d2 = floyd_warshall(minipath)
for i in range(q):
s,t = (int(i) for i in input().split())
s,t = s-1,t-1
cost = d2[s][t]
if cost == inf:
print(-1)
else:
print(int(cost)-1)
solve() | import sys
input = sys.stdin.readline
N,M,L = map(int, input().split())
INF = float("inf")
dist1 = [[INF]*N for i in range(N)]
dist2 = [[INF]*N for i in range(N)]
for i in range(M):
A,B,C = map(int, input().split())
A -= 1
B -= 1
dist1[A][B] = C
dist1[B][A] = C
for i in range(N):
dist1[i][i] = 0
dist2[i][i] = 0
for k in range(N):
for i in range(N):
for j in range(N):
d = dist1[i][k]+dist1[k][j]
if dist1[i][j] <= d:
continue
dist1[i][j] = d
for i in range(N):
for j in range(N):
if dist1[i][j] > L or i==j:
continue
dist2[i][j] = 1
for k in range(N):
for i in range(N):
for j in range(N):
d = dist2[i][k]+dist2[k][j]
if dist2[i][j] <= d:
continue
dist2[i][j] = d
Q = int(input())
for i in range(Q):
s,t = map(int, input().split())
print(dist2[s-1][t-1]-1 if dist2[s-1][t-1]<=L else -1) | 1 | 174,124,171,268,714 | null | 295 | 295 |
import string
n = int(input())
alphabet = list(string.ascii_lowercase)
ans = ''
while n > 0:
ans = alphabet[(n-1) % 26] + ans
n = (n-1) // 26
print(ans)
| # -*- coding: utf-8 -*-
"""
Created on Mon Sep 7 02:42:25 2020
@author: liang
"""
"""
n進数問題
【原則】 大きな数の計算をしない
⇒ １の桁から計算する
171-C いびつなn進数
27 -> a(26)a(1)となる
⇒先にa(1)だけもらってN%26とすることで解決
ASCII化 ord()
文字化 chr()
"""
N = int(input())
res = str()
while N > 0:
N -= 1 #"a"として予め設置
res += chr(ord("a") + N%26)
N //= 26
print(res[::-1]) | 1 | 11,944,297,926,278 | null | 121 | 121 |
XY = [int(s) for s in input().split()]
X = XY[0]
Y = XY[1]
if Y % 2 == 0 and Y <= 4 * X and Y >= 2* X:
print('Yes')
else:
print('No') | r=input().split()
X=int(r[0])
Y=int(r[1])
ans=0
for i in range(X+1):
if 2*i==4*X-Y:
print("Yes")
ans+=1
break
if ans==0:
print("No") | 1 | 13,875,636,414,630 | null | 127 | 127 |
t=int(input())
taro=0
hanako=0
for i in range(t):
S=input().split()
if S[0]==S[1]:
taro+=1
hanako+=1
elif S[0]>S[1]:
taro+=3
else:
hanako+=3
print(taro,hanako) | n=int(input())
t=0
h=0
for i in range(n):
a,b=map(str,input().split())
if a<b:
h+=3
elif a>b:
t+=3
else:
t+=1
h+=1
print("{} {}".format(t,h)) | 1 | 2,005,846,705,812 | null | 67 | 67 |
import sys
n = int(input())
l = sys.stdin.readlines()
s = ""
for i in l:
x, y, z = sorted(map(lambda x:x*x,map(int, i.split())))
if x + y == z:
s += "YES\n"
else:
s += "NO\n"
print(s,end="") | n = int(input())
s = ""
for i in range(n):
l = list(map(lambda x:x*x,map(int, input().split())))
l.sort()
if l[0] + l[1] == l[2]:
s += "YES\n"
else:
s += "NO\n"
print(s,end="") | 1 | 321,427,902 | null | 4 | 4 |
deck = {"S":[0]*13, "H":[0]*13, "C":[0]*13, "D":[0]*13}
n = input()
for i in range(0, n):
suit, num = raw_input().split(" ")
deck[suit][int(num)-1] = 1
for i in ["S", "H", "C", "D"]:
for j in range(0, 13):
if (deck[i][j] == 0):
print("%s %d" % (i, j+1)) | n = input()
a = [raw_input() for _ in range(n)]
b = []
for i in ['S ','H ','C ','D ']:
for j in range(1,14):
b.append(i+str(j))
for i in a:
b.remove(i)
for i in b:
print i | 1 | 1,037,708,904,580 | null | 54 | 54 |
import numpy as np
import sys
input = sys.stdin.readline
def main():
h, w, k = map(int, input().split())
values = np.zeros((h, w), dtype=np.int64)
items = np.array([list(map(int, input().split())) for _ in range(k)])
ys, xs, vs = items[:, 0] - 1, items[:, 1] - 1, items[:, 2]
values[ys, xs] = vs
DP = np.zeros(w + 1, dtype=np.int64)
for line in values:
DP[1:] += line
DP = np.maximum.accumulate(DP)
for _ in range(2):
DP[1:] = np.maximum(DP[:-1] + line, DP[1:])
DP = np.maximum.accumulate(DP)
print(DP[-1])
if __name__ == "__main__":
main()
| n, m = map(int,input().split())
a = list(map(int,input().split()))
i = 0
s = 0
sum = sum(a)
for i in range(n):
if a[i]/sum >= 1/(4*m):
s += 1
if s >= m:
print('Yes')
else:
print('No')
| 0 | null | 22,101,250,215,012 | 94 | 179 |
A, B = [s for s in input().split()]
A = int(A)
B = int(float(B) * 100 + .5)
C = A * B
ans = int(C // 100)
print(ans) | S = input()
Sliststr = list(S)
Slist = [int(s) for s in Sliststr]
Smod = [0]
mod10 = [1]
count = [0]*2019
ans = 0
for i in range(len(S)-1):
mod10.append(mod10[i]*10%2019)
for i in range(len(S)):
Smod.append((Smod[i]+Slist[-i-1]*mod10[i])%2019)
for i in range(len(Smod)):
count[Smod[i]] += 1
for i in range(2019):
ans += count[i] * (count[i]-1) // 2
print(ans) | 0 | null | 23,605,461,562,228 | 135 | 166 |
x = int(input())
ans = 0
while True:
ans += 1
if ans*x % 360 == 0:
break
print(ans)
| from decimal import *
import math
a, b = map(str, input().split())
print(math.floor(Decimal(a)*Decimal(b))) | 0 | null | 14,875,363,648,320 | 125 | 135 |
n, m = map(int, input().split())
a = list(map(int, input().split()))
print("Yes" if len([i for i in a if i/sum(a) >= 1/(4 * m)]) >= m else "No") | n,m = map(int,input().split())
Ai = list(map(int,input().split()))
list.sort(Ai, reverse=True)
print('Yes' if Ai[m-1]>= sum(Ai) / (4 * m) else 'No') | 1 | 38,555,875,670,998 | null | 179 | 179 |
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 issame(self, x, y):
return self.find[x] == self.find(y)
'''
参考
https://qiita.com/K_SIO/items/03ff1fc1184cb39674aa#d-friends
'''
if __name__ == '__main__':
N, M = map(int, input().split())
uf = UnionFind(N)
for _ in range(M):
A, B = map(int, input().split())
uf.union(A-1, B-1)
ans = 0
for i in range(N):
ans = max(ans, uf.size(i))
print(ans)
| A=int(input())
B=int(input())
print(6-(A+B)) | 0 | null | 57,029,215,786,048 | 84 | 254 |
import numpy as np
N = int(input())
A = list(map(int,input().split()))
A = np.array(A)
A.sort()
d = {}
for a in A:
d.setdefault(a,0)
d[a] += 1
sieve = [True] * (A[-1] + 1)
for a in A:
if d[a] > 1:
sieve[a] = False
for i in range(a + a, A[-1] + 1, a):
sieve[i] = False
print(sum(1 for a in A if sieve[a])) | import sys
read = sys.stdin.read
readlines = sys.stdin.readlines
#import numpy as np
from collections import Counter
def main():
n, *a = map(int, read().split())
if 1 in a:
count1 = a.count(1)
if count1 == 1:
print(1)
sys.exit()
else:
print(0)
sys.exit()
maxa = max(a)
seq = [0] * (maxa + 1)
ac = Counter(a)
for ae in ac.items():
if ae[1] == 1:
seq[ae[0]] = 1
for ae in a:
t = ae * 2
while t <= maxa:
seq[t] = 0
t += ae
r = sum(seq)
print(r)
if __name__ == '__main__':
main()
| 1 | 14,534,003,806,752 | null | 129 | 129 |
a, b, c = map(int, input().split())
k = int(input())
n = 0
while a >= b:
b = b*2
n += 1
while b >= c:
c = c*2
n += 1
if a < b < c and n <= k:
print('Yes')
else:
print('No') | n = int(input())
x = int(n / 1.08)
if int(x * 1.08) == n:
print(x)
elif int((x-1) * 1.08) == n:
print(x-1)
elif int((x+1) * 1.08) == n:
print(x+1)
else:
print(':(') | 0 | null | 66,647,342,504,492 | 101 | 265 |
N,M = map(int,input().split())
print( 'No' if M < N else 'Yes') | n = int(input())
s = input()
q = int(input())
class SegmentTree:
def __init__(self, a, func=max, one=-10 ** 18):
self.logn = (len(a) - 1).bit_length()
self.n = 1 << self.logn
self.func = func
self.one = one
self.b = [self.one] * (2 * self.n - 1)
for i, j in enumerate(a):
self.b[i + self.n - 1] = j
for i in reversed(range(self.n - 1)):
self.b[i] = self.func(self.b[i * 2 + 1], self.b[i * 2 + 2])
self.ll = []
self.rr = []
i = self.n
for _ in range(self.logn+1):
for j in range(0, self.n, i):
self.ll.append(j)
self.rr.append(j + i)
i //= 2
def get_item(self, i):
return self.b[i + self.n - 1]
def update(self, index, x):
i = index + self.n - 1
self.b[i] = x
while i != 0:
i = (i - 1) // 2
self.b[i] = self.func(self.b[i * 2 + 1], self.b[i * 2 + 2])
def update_func(self, index, x):
i = index + self.n - 1
self.b[i] = self.func(self.b[i], x)
while i != 0:
i = (i - 1) // 2
self.b[i] = self.func(self.b[i * 2 + 1], self.b[i * 2 + 2])
def get_segment(self, l, r, i=0):
ll = self.ll[i]
rr = self.rr[i]
if l <= ll and rr <= r:
return self.b[i]
elif rr <= l or r <= ll:
return self.one
else:
return self.func(self.get_segment(l, r, i * 2 + 1),
self.get_segment(l, r, i * 2 + 2))
def get_int(s):
abc = "abcdefghijklmnopqrstuvwxyz"
return 1 << abc.index(s)
seg = SegmentTree([get_int(i) for i in s], int.__or__, 0)
for _ in range(q):
q, i, j = input().split()
if q == "1":
seg.update(int(i) - 1, get_int(j))
else:
aa = seg.get_segment(int(i) - 1, int(j))
ans = 0
for i in range(26):
if (aa >> i) & 1 == 1:
ans += 1
print(ans)
| 0 | null | 72,737,476,142,588 | 231 | 210 |
a,b = map(int,input().split())
low = a*2
high = a*4
if b%2 != 0:
print("No")
elif b<low or b>high:
print("No")
else:
print("Yes") | n,k = map(int,input().split())
mod = 1000000007
def comb(n,k):
if n < k: return 0
if n < 0 or k < 0: return 0
return fac[n]*finv[k]%mod*finv[n-k]%mod
fac = [1]*(n+1)
finv = [1]*(n+1)
for i in range(1,n+1):
fac[i] = fac[i-1]*i%mod
finv[i] = pow(fac[i],mod-2,mod)
ans = 0
for i in range(min(k+1,n)):
ans += comb(n,i)*comb(n-1,i)%mod
ans %= mod
print(ans) | 0 | null | 40,269,081,923,064 | 127 | 215 |
inp = input()
if inp[0] == inp[1] and inp[1] == inp[2]:
print("No")
else:
print("Yes") | print('Yes' if(len(set(input())) != 1) else 'No')
| 1 | 54,939,619,541,378 | null | 201 | 201 |
K = int(input())
S = input()
S_len = len(S)
if len(S)<=K:
print(S)
else:
print(S[0:K]+'...') | S = input()
print("%s:%s:%s"%(S/3600,(S//60)%60,S%60)) | 0 | null | 10,069,285,221,270 | 143 | 37 |
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor
from operator import mul
from functools import reduce
from pprint import pprint
sys.setrecursionlimit(2147483647)
INF = 10 ** 13
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 1000000007
t1, t2 = LI()
a1, a2 = LI()
b1, b2 = LI()
p = (a1 - b1) * t1
q = (a2 - b2) * t2
if p > 0:
p = -p
q = -q
if p + q == 0:
print('infinity')
elif p + q < 0:
print(0)
else:
print((-p // (p + q)) * 2 + bool(-p % (p + q))) | X = int(input())
for a in range(-118,120):
for b in range(-119,119):
if a**5 - b**5 == X:
ans = (a,b)
break
print(ans[0],ans[1])
| 0 | null | 78,389,683,670,202 | 269 | 156 |
#!/usr/bin/env python3
s = input()
k = int(input())
n = len(s)
b = [0] * n
c = [0] * n
c[0] = 1
for i in range(n):
if s[i - 1] == s[i] and not c[i - 1]:
c[i] = 1
if i and s[i - 1] == s[i] and not b[i - 1]:
b[i] = 1
s1 = sum(b)
s2 = sum(c)
if s[-1] != s[0] or b[-1]:
print(s1 * k)
else:
if c[-1]:
print((s1 + s2) * (k // 2) + s1 * (k % 2))
else:
print(s1 + (k - 1) * s2)
| #!/usr/bin/env python3
s = input()
n = len(s)
k = int(input())
if s.count(s[0]) == n:
print(n * k // 2)
exit()
# pre,post を数えた上で前から連続しているやつの長さを数えて和をとる
ans = 0 # k倍する前をおく
cnt = 1
pre, post = 0, 0
pre_bit = 1
for i in range(n - 1):
if s[i] == s[i + 1]:
cnt += 1
else:
ans += cnt // 2
if pre_bit:
pre = cnt
pre_bit = 0
cnt = 1
ans += cnt // 2
post = cnt
if s[0] != s[-1]:
print(ans * k)
else:
print(ans * k + (k - 1) * (-1 * (pre // 2 + post // 2) + (pre + post) // 2))
| 1 | 175,252,556,984,772 | null | 296 | 296 |
n = int(input())
l = list(map(int,input().split()))+[0]
l.sort(reverse=True)
ans = 0
for i in range(n-2):
for j in range(i+1,n-1):
left = j
right = n
while right - left > 1:
middle = (left + right)//2
if l[i]-l[j] < l[middle]:
left = middle
else:
right = middle
ans += (left-j)
print(ans) | N=int(input())
L= list(map(int,input().split()))
L_sorted=sorted(L,reverse=False)#昇順
count=0
for i in range(N):
for j in range(i+1,N):
a=L_sorted[i]
b=L_sorted[j]
n=a+b
fin=N
sta=0
while sta+1<fin:
m=((fin-sta)//2)+sta
if L_sorted[m]<n:
sta=m
else:
fin=m
count+=sta-j
print(count) | 1 | 171,538,410,050,282 | null | 294 | 294 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.