code1
stringlengths 16
427k
| code2
stringlengths 16
427k
| similar
int64 0
1
| pair_id
int64 6.82M
181,637B
⌀ | question_pair_id
float64 101M
180,471B
⌀ | code1_group
int64 2
299
| code2_group
int64 2
299
|
|---|---|---|---|---|---|---|
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) | a=input()
b=input()
res="No"
if a==b[:-1]:res="Yes"
print(res) | 0 | null | 16,040,799,981,180 | 117 | 147 |
# -*- coding: utf-8 -*-
X = int(input())
# A**5 - (A-1)**5 = X = 10**9(Xの最大) となるAが
# Aの最大値となる(それ以上Aが大きくなると、Xは上限値を超える)
# → 最大となるAは120
for A in range(-120, 120 + 1):
for B in range(-120, 120):
if A**5 - B**5 == X:
print("{} {}".format(A, B))
exit() | X=int(input())
def check():
for a in range(-200,200):
for b in range(-200,200):
if a**5-b**5==X:
print(a,b)
return 0
check() | 1 | 25,626,021,595,200 | null | 156 | 156 |
n,x,m=map(int, input().split())
a=x
ans=a
flg=[0]*m
flg[a]=1
l=[a]
lp=-1
for i in range(1,m+1):
if n <= i:
break
tmp=(a*a)%m
a=tmp
if flg[a]==1:
lp = l.index(a)
break
else:
ans+=tmp
l.append(a)
flg[a]=1
if lp != -1:
l2 = l[lp:]
tmp = sum(l2)
b=(n-len(l))//len(l2)
c=n-len(l)-b*len(l2)
ans=ans+(b*tmp)+sum(l2[:c])
print(ans) | import sys
sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline
n, x, m = map(int, input().split())
ans = 0
aa = x
ans += aa
aset = set([aa])
alist = [aa]
for i in range(1,n):
aa = pow(aa,2,m)
if aa in aset:
offset = alist.index(aa)
loop = alist[offset:i]
nloop, tail = divmod(n-offset, len(loop))
ans += sum(loop)*(nloop-1)
ans += sum(loop[0:tail])
break
else:
ans += aa
aset.add(aa)
alist.append(aa)
print(ans)
| 1 | 2,801,223,660,828 | null | 75 | 75 |
A, B = map(int, input().split())
C = A - (B*2)
C = 0 if C < 0 else C
print(C) | #coding:utf-8
#1_10_A 2015.4.10
import math
x1,y1,x2,y2 = list(map(float,input().split()))
distance = math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)
print('{:.5f}'.format(distance)) | 0 | null | 83,528,444,334,230 | 291 | 29 |
#Union Find
#xの根を求める
def find(x):
if par[x] < 0:
return x
else:
tank = []
while par[x] >= 0:
tank.append(x)
x = par[x]
for elt in tank:
par[elt] = x
return x
#xとyの属する集合の併合
def unite(x,y):
x = find(x)
y = find(y)
if x == y:
return False
else:
#sizeの大きいほうがx
if par[x] > par[y]:
x,y = y,x
par[x] += par[y]
par[y] = x
return True
n,m = map(int, input().split())
par = [-1] * n
for i in range(m):
a,b = map(int,input().split())
unite(a-1,b-1)
ans = set([])
for i in range(n):
ans.add(find(i))
print(len(ans)-1) | def main():
# input
import math
t1, t2 = map(int, input().split())
a1, a2 = map(int, input().split())
b1, b2 = map(int, input().split())
x = (a1-b1)*t1
y = (a2-b2)*t2
diff = x+y
if x == -y:
print("infinity")
return
elif x*y>0 or abs(x)>abs(y):
print(0)
return
x = abs(x)
diff = abs(diff)
ans = x//diff
remainder = x%diff
if remainder==0:
print(ans*2)
else:
print(ans*2+1)
# calc
if __name__ == '__main__':
main()
| 0 | null | 66,842,763,625,094 | 70 | 269 |
from collections import deque
dq = deque()
for _ in [None]*int(input()):
s = input()
if s == "deleteFirst":
dq.popleft()
elif s == "deleteLast":
dq.pop()
else:
a, b = s.split()
if a == "insert":
dq.appendleft(b)
else:
if b in dq:
dq.remove(b)
print(" ".join(dq))
| from collections import deque
n = int(input())
mylist = deque()
for i in range(n):
a = input()
if a == "deleteFirst":
mylist.popleft()
elif a == "deleteLast":
mylist.pop()
else:
a,key = a.split()
if a == "insert":
mylist.appendleft(key)
else:
try:
mylist.remove(key)
except:
pass
print(' '.join(mylist))
| 1 | 47,456,622,598 | null | 20 | 20 |
from itertools import permutations
def main():
N = int(input())
P = list(map(int, input().split()))
Q = list(map(int, input().split()))
A = [i for i in range(1, N+1)]
As = list(permutations(A))
for i in range(len(As)):
a = As[i]
for j in range(len(a)):
if a[j] != P[j]:
break
else:
p_rank = i
break
for i in range(len(As)):
a = As[i]
for j in range(len(a)):
if a[j] != Q[j]:
break
else:
q_rank = i
break
print(abs(p_rank-q_rank))
if __name__ == '__main__':
main() | from itertools import *
N = int(input())
P = tuple(map(int, input().split()))
Q = tuple(map(int, input().split()))
dic = dict()
i = 0
for a in permutations(range(1,N+1),N):
dic[a] = i
i += 1
print(abs(dic[P]-dic[Q])) | 1 | 100,332,011,021,450 | null | 246 | 246 |
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() | N,u,v = map(int,input().split())
u -= 1
v -= 1
data = [[] for _ in range(N)]
for i in range(N-1):
A,B = map(int,input().split())
A -= 1
B -= 1
data[A].append(B)
data[B].append(A)
#print(data)
stack = [[u,u]]
taka_dis = [0] * N
while stack:
x = stack.pop()
#print(x)
for y in data[x[1]]:
if y == x[0]:
continue
else:
stack.append([x[1],y])
taka_dis[y] = taka_dis[x[1]] + 1
#print(stack)
stack = [[v,v]]
aoki_dis = [0] * N
while stack:
x = stack.pop()
for y in data[x[1]]:
if y == x[0]:
continue
else:
stack.append([x[1],y])
aoki_dis[y] = aoki_dis[x[1]] + 1
can = [0] * N
for i in range(N):
if aoki_dis[i] - taka_dis[i] > 0:
can[i] = aoki_dis[i]
else:
can[i] = 0
#print(aoki_dis)
#print(taka_dis)
#print(can)
print(max(can) -1 )
| 0 | null | 71,448,002,533,820 | 156 | 259 |
while True:
h,w=map(int,input().split())
if h==0 and w==0:
break
for y in range(h):
for x in range(w):
if y==0 or y==h-1 or x==0 or x==w-1:
print("#",end='')
else:
print(".",end='')
print()
print() | while 1:
H, W=map(int, raw_input().split())
if H==0 and W==0:
break
for i in range(H):
L=list("#"*W)
if i==0 or i==(H-1):
s="".join(L)
print s
else:
for j in range(1, W-1):
L[j]="."
s="".join(L)
print s
print "" | 1 | 843,750,735,000 | null | 50 | 50 |
a, b, c, d = map(int,input().split())
while a > 0:
c -= b
a -= d
if c <= 0:
print('Yes')
else:
print('No') | a, b, c, k = map(int, input().split())
if(k <= a):
print(k)
elif(k <= a+b):
print(a)
else:
if(a <= k-a-b):
print(-1*(k-a-b-a))
elif(a > k-a-b):
print(a-(k-a-b)) | 0 | null | 25,884,422,890,482 | 164 | 148 |
import sys
from collections import deque
def main():
h, w = map(int, input().split())
maze = [input() for i in range(h)]
# 行ったかどうかのフラグ
visited = [[-1]*w for j in range(h)]
start_yx = []
for i in range(h):
for j in range(w):
if maze[i][j] == '.':
sy = i
sx = j
start_yx .append([sy, sx])
# 移動パターン
mv = [[1, 0], [-1, 0], [0, 1], [0, -1]]
ans = 0
for sy, sx in start_yx :
visited = [[-1]*w for j in range(h)]
q = deque([[sy, sx]])
visited[sy][sx] = 0
while q:
y, x = q.popleft()
ans = max(ans, visited[y][x])
for i, j in mv:
if (0 <= y + i < h) and (0 <= x + j < w):
ny = y+i
nx = x+j
if visited[ny][nx] != -1:
continue
if maze[ny][nx] == '.':
visited[ny][nx] = visited[y][x] + 1
q.append([ny, nx])
else:
continue
print(ans)
if __name__ == '__main__':
main()
| # coding=utf-8
a, b = map(int, input().split())
if a > b:
big_num = a
sml_num = b
else:
big_num = b
sml_num = a
while True:
diviser = big_num % sml_num
if diviser == 0:
break
else:
big_num = sml_num
sml_num = diviser
print(sml_num) | 0 | null | 47,461,119,995,520 | 241 | 11 |
al = "abcdefghijklmnopqrstuvwxyz"
C = input()
print(al[al.index(C)+1]) | import sys
input = sys.stdin.buffer.readline
import numpy as np
def main():
N,K = map(int,input().split())
a = list(map(int,input().split()))
f = list(map(int,input().split()))
a.sort()
f.sort(reverse=True)
if sum(a) <= K:
print(0)
else:
a = np.array(a)
f = np.array(f)
left,right = 0,max(a)*max(f)
while right-left > 1:
mid = (left+right)//2
pra = a-mid//f
pra[pra<0] = 0
if np.sum(pra) > K:
left = mid
else:
right = mid
print(right)
if __name__ == "__main__":
main()
| 0 | null | 128,768,127,344,934 | 239 | 290 |
import sys
def input(): return sys.stdin.readline().strip()
def mapint(): return map(int, input().split())
sys.setrecursionlimit(10**9)
N = int(input())
As = list(mapint())
ALL = 0
for a in As:
ALL ^= a
ans = [ALL^a for a in As]
print(*ans) | def main():
n = int(input())
a_list = list(map(int, input().split()))
all_xor = 0
for a in a_list:
all_xor ^= a
x_list = [a ^ all_xor for a in a_list]
print(*x_list, sep=" ")
if __name__ == "__main__":
main()
| 1 | 12,646,830,138,528 | null | 123 | 123 |
import sys
import math
import copy
from heapq import heappush, heappop, heapify
from functools import cmp_to_key
from bisect import bisect_left, bisect_right
from collections import defaultdict, deque, Counter
# sys.setrecursionlimit(1000000)
# input aliases
input = sys.stdin.readline
getS = lambda: input().strip()
getN = lambda: int(input())
getList = lambda: list(map(int, input().split()))
getZList = lambda: [int(x) - 1 for x in input().split()]
INF = float("inf")
MOD = 10**9 + 7
divide = lambda x: pow(x, MOD-2, MOD)
def nck(n, k, kaijyo):
if n < k:
return 0
if n == k:
return 1
return (npk(n, k, kaijyo) * divide(kaijyo[k])) % MOD
def npk(n, k, kaijyo):
if k == 0 or k == n:
return 1
return (kaijyo[n] * divide(kaijyo[n-k])) % MOD
def fact_and_inv(SIZE):
inv = [0] * SIZE # inv[j] = j^{-1} mod MOD
fac = [0] * SIZE # fac[j] = j! mod MOD
finv = [0] * SIZE # finv[j] = (j!)^{-1} mod MOD
inv[1] = 1
fac[0] = fac[1] = 1
finv[0] = finv[1] = 1
for i in range(2, SIZE):
inv[i] = MOD - (MOD // i) * inv[MOD % i] % MOD
fac[i] = fac[i - 1] * i % MOD
finv[i] = finv[i - 1] * inv[i] % MOD
return fac, finv
def solve():
n, k = getList()
nums = getList()
nums.sort()
kai, _ = fact_and_inv(n+2)
# print(kai)
# print(kai)
# print(npk(5,5,kai))
# print(nck(5,4,kai))
# for nn in nums:
# print(nn)
# print(MOD)
mn, mx = 0, 0
for i in range(n-k+1):
# print(n-i-1, k-1)
pat = nck(n-i-1, k-1, kai)
mn += pat * nums[i]
mx += pat * nums[-i-1]
mn %= MOD
mx %= MOD
# print(mx, mn)
print((mx - mn + MOD) % MOD)
def main():
n = getN()
for _ in range(n):
solve()
return
if __name__ == "__main__":
# main()
solve()
| import math
x1,y1,x2,y2=map(float,input().split())
a = ((x1-x2)**2)+((y1-y2)**2)
a = math.sqrt(a)
print('{:.8f}'.format(a))
| 0 | null | 48,118,455,009,890 | 242 | 29 |
N = int(input())
A = list(map(int, input().split()))
A.sort()
res = 1
for i in A:
res*=i;
if res>10**18:
res = -1
break
print(res) | N = int(input())
A = list(map(int, input().split()))
if 0 in A:
print(0)
else:
ans = 1
for a in A:
ans *= a
if ans > 10**18:
print(-1)
exit(0)
print(ans)
| 1 | 16,187,106,275,520 | null | 134 | 134 |
n = int(raw_input())
for i in range(n):
num = map(int, raw_input().split())
num.sort(reverse=True)
if num[0]**2 == num[1]**2 + num[2]**2:
print "YES"
else:
print "NO"
| n = input()
out = ""
for i in range(1, int(n) + 1):
if i % 3 == 0 or "3" in str(i):
out += " " + str(i)
print(out)
| 0 | null | 475,791,026,612 | 4 | 52 |
import sys
sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline
f_inf = float('inf')
mod = 10 ** 9 + 7
def resolve():
n = int(input())
res = 0
numbers = [[0] * 10 for _ in range(10)]
for i in range(1, n + 1):
ss = str(i)
numbers[int(ss[0])][int(ss[-1])] += 1
for j in range(1, 10):
for k in range(1, 10):
res += numbers[j][k] * numbers[k][j]
print(res)
if __name__ == '__main__':
resolve()
| # 解説と 13355391 を参考に実装予定
import math
def solve():
N = int(input())
ABs = [[int(i) for i in input().split()] for _ in range(N)]
mod = 10 ** 9 + 7
lonlieness = 0
pairs = {}
for AB in ABs:
a, b = AB
if a == 0 and b == 0:
lonlieness += 1
continue
elif a == 0:
a, b = -1, 0
bad_a, bad_b = 0, 1
elif b == 0:
a, b = (0, 1)
bad_a, bad_b = -1, 0
else:
_gcd = math.gcd(a, b)
a //= _gcd
b //= _gcd
bad_a = -b
bad_b = a
if b < 0:
a, b = -a, -b
if bad_b < 0:
bad_a, bad_b = -bad_a, -bad_b
pairs.setdefault((a, b), 0)
pairs.setdefault((bad_a, bad_b), 0) # 仲の悪いグループも登録しておく
pairs[(a, b)] += 1
permutations = []
for i, pair in enumerate(pairs.keys()):
if i % 2 == 1:
continue # 仲の悪いグループは隣り合っているので飛び石で計算
a, b = pair
bad_a, bad_b = -b, a
if bad_b < 0:
bad_a, bad_b = -bad_a, -bad_b
# gourp1 から1匹以上選ぶパターン + group2 から1匹以上選ぶパターン + どちらからも選ばないパターン計算する.
# group1 と group2 は仲が悪いので同時に選ばれることはない.
group_num = pow(2, pairs[(a, b)], mod) - 1
badgroup_num = pow(2, pairs[(bad_a, bad_b)], mod) - 1
permutations.append(group_num + badgroup_num + 1)
result = 1
for p in permutations:
result = result * p % mod
# 全員と仲が悪いイワシのパターンを足し, すべてのイワシを選ばないパターンを除外.
result = (result + lonlieness - 1) % mod
print(result)
if __name__ == '__main__':
solve()
| 0 | null | 54,002,692,969,472 | 234 | 146 |
from collections import deque
s = input()
q = int(input())
S = [c for c in s]
deque = deque(S)
reversed = 0
for i in range(q):
line = input()
if line[0] == '1':
reversed = reversed ^ 1
else:
op, f, c = line.split()
f = int(f)
if reversed == 0:
if f == 1:
deque.appendleft(c)
else:
deque.append(c)
else:
if f == 1:
deque.append(c)
else:
deque.appendleft(c)
if reversed:
deque.reverse()
result = "".join(deque)
print(result) | from collections import deque
s = input()
Q = int(input())
l = deque()
l.append(s)
rev = True
for i in range(Q):
q = list(input().split())
if q[0] == "1":
rev = not rev
else:
if rev:
if q[1] == "1":
l.appendleft(q[2])
else:
l.append(q[2])
else:
if q[1] == "1":
l.append(q[2])
else:
l.appendleft(q[2])
ans = ""
for i in l:
ans += i
if not rev:
print(ans[::-1])
else:
print(ans) | 1 | 57,395,170,365,808 | null | 204 | 204 |
N = int(input())
result = [0] * (N + 1)
for i in list(map(int, input().split())):
result[i] += 1
result.pop(0)
for r in result:
print(r)
| import collections
N = int(input())
ls = list(map(int,input().split()))
count = collections.Counter(ls)
for i in range(1,N+1):
if i in count.keys():
print(count[i])
else:
print(0) | 1 | 32,743,185,358,560 | null | 169 | 169 |
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import accumulate, permutations, combinations, 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
from fractions import gcd
from heapq import heappush, heappop
from functools import reduce
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 ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 998244353
N = INT()
D = LIST()
cnt_D = Counter(D)
if D[0] != 0 or cnt_D[0] >= 2:
print(0)
exit()
ans = 1
for i in range(1, max(D)+1):
ans *= pow(cnt_D[i-1], cnt_D[i], mod)
ans %= mod
print(ans)
| def resolve():
A,B,N = map(int,input().split())
x = min(N,B-1)
ans = int(A * x / B)
print(ans)
resolve() | 0 | null | 91,895,337,641,792 | 284 | 161 |
n = int(input())
al = list(map(int, input().split()))
ans = 0
for i in range(n-1):
if al[i] >= al[i+1]:
ans += al[i]-al[i+1]
al[i+1] += (al[i]-al[i+1])
print(ans) | a = int(input())
b = input().split()
c = "APPROVED"
for i in range(a):
if int(b[i]) % 2 == 0:
if int(b[i]) % 3 == 0 or int(b[i]) % 5 == 0:
c = "APPROVED"
else:
c = "DENIED"
break
print(c) | 0 | null | 36,742,685,684,150 | 88 | 217 |
import numpy as np
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
from numba import njit
def getInputs():
D = int(readline())
CS = np.array(read().split(), np.int32)
C = CS[:26]
S = CS[26:].reshape((-1, 26))
return D, C, S
def _compute_score(output, i, d, last):
mask = np.ones((26, ))
mask[i] = 0
score = S[d][i] - np.sum(C * (d + 1 - last) * mask)
return score
def solve():
output = []
last = np.zeros((26, ))
#SCORE = 0
for d in range(D):
max_score = float('-inf')
best_i = 0
for i in range(26):
output.append(i)
score = _compute_score(output, i, d, last)
if max_score < score:
max_score = score
best_i = i + 1
output.pop()
output.append(best_i)
last[best_i - 1] = d + 1
#SCORE += max_score
#print(SCORE)
return output
if __name__ == "__main__":
D, C, S = getInputs()
ans = solve()
print('\n'.join(map(str, ans))) | # Comparing Strings
a, b = map(int, input().split())
a, b = min(a, b), max(a, b)
ans = ''.join([str(a) for e in range(b)])
print(ans)
| 0 | null | 47,183,185,897,390 | 113 | 232 |
x = int(input())
y=100
c=0
while 1:
if y>=x :
break
y=y*101//100
c+=1
print(c) | import numpy as np
n,m = [int(i) for i in input().split()]
a = [int(i) for i in input().split()]
d = 2**18
f = np.array([0]*d)
for i in a:
f[i]+=1
tf = np.fft.fft(f)
f = np.fft.ifft(tf*tf)
f = [int(i+0.5) for i in f]
ans=0
for i in range(len(f)-1,0,-1):
if f[i]<=m:
ans+=i*f[i]
m-=f[i]
elif f[i]>m:
ans+=i*m
break
print(ans) | 0 | null | 67,797,611,027,718 | 159 | 252 |
def do_solve(n, k, c, s):
dp = [0 for i in xrange(n)]
for i in xrange(n):
dp[i] = 1 if s[i] == 'o' else 0
if i - c - 1 >= 0:
dp[i] = max(dp[i], dp[i - c - 1] + 1 if s[i] == 'o' else 0)
if i - 1 >= 0:
dp[i] = max(dp[i], dp[i - 1])
return dp
def solve(n, k, c, s):
dp1 = do_solve(n, k, c, s)
dp2 = do_solve(n, k, c, s[::-1])[::-1]
# print dp1
# print dp2
res = []
for i in xrange(n):
if s[i] == 'x':
continue
l = dp1[i - 1] if i - 1 >= 0 else 0
r = dp2[i + 1] if i + 1 < n else 0
# print i, l, r
if l + r == k - 1:
res.append(i + 1)
# print res
return res
assert solve(16, 4, 3, 'ooxxoxoxxxoxoxxo') == [11, 16]
assert solve(11, 3, 2, 'ooxxxoxxxoo') == [6]
assert solve(5, 1, 0, 'ooooo') == []
assert solve(5, 2, 3, 'ooxoo') == [1, 5]
(n, k, c) = map(int, raw_input().split())
s = raw_input().strip()
for num in solve(n, k, c, s):
print num
| # 解説を参考に作成
def solve():
N, K, C = map(int, input().split())
S = input()
left = []
rest = 0
work = 0
for i in range(N):
if S[i] == 'o' and rest == 0:
left.append(i)
rest = C + 1
work += 1
if rest > 0:
rest -= 1
if work == K:
break
right = []
rest = 0
work = 0
for i in reversed(range(N)):
if S[i] == 'o' and rest == 0:
right.append(i)
rest = C + 1
work += 1
if rest > 0:
rest -= 1
if work == K:
break
right = list(reversed(right))
# print(left)
# print(right)
for i in range(len(left)):
if left[i] == right[i]:
print(left[i] + 1)
if __name__ == '__main__':
solve()
| 1 | 40,644,057,857,050 | null | 182 | 182 |
import sys
input = sys.stdin.readline
if __name__ == '__main__':
n=int(input())
D=[0]*n
A=[]
def h1(x):
return x%n
def h2(x):
return 1+x%(n-1)
def h(x,i):
return h1(x)+i*h2(x)
def insert(x):
i=0
k=0
while True:
k=h(x,i)%n
if D[k]==0:
D[k]=x
return k
elif D[k]==x:
return k
i+=1
def find(x):
i=0
k=0
while i<n:
k=h(x,i)%n
if D[k]==x:
return True
elif D[k]==0:
return False
i+=1
return False
def getKey(X):
res=''
for x in X:
if x=='A':
res+='1'
elif x=='C':
res+='2'
elif x=='G':
res+='3'
elif x=='T':
res+='4'
return int(res)
for _ in range(n):
c,x=input().strip("\n").split()
#x=x.replace('A','1').replace('C','2').replace('G','3').replace('T','4')
#x=int(x)
x=getKey(x)
if c=='insert':
insert(x)
else:
A.append(find(x))
for ans in A:
print('yes' if ans else 'no')
| A, B, K = map(int, input().split())
if A >= K:
A = A - K
else:
B = B - (K - A)
A = 0
if B < 0:
B = 0
print(str(A) + " " + str(B)) | 0 | null | 52,456,976,237,540 | 23 | 249 |
n=input().rstrip().split(" ")
w=int(n[0])
l=int(n[1])
print(w*l, 2*w+2*l) | #!/usr/bin/env python3
# -*- coding: utf-8 -*-
def main():
numbers = input().split(' ')
height = int(numbers[0])
width = int(numbers[1])
print(height * width ,height * 2 + width * 2)
return
if __name__ == '__main__':
main() | 1 | 311,007,992,130 | null | 36 | 36 |
def resolve():
K, X = list(map(int, input().split()))
print("Yes" if 500*K>=X else "No")
if '__main__' == __name__:
resolve() | m = input().split()
K = int(m[0])
X = int(m[1])
ans = 'Yes'
if 500 * K < X:
ans = 'No'
print(ans) | 1 | 98,393,749,595,268 | null | 244 | 244 |
from heapq import heappush,heappop,heapify
from collections import deque,defaultdict,Counter
import itertools
from itertools import permutations,combinations
import sys
import bisect
import string
import math
import time
#import random
def I():
return int(input())
def MI():
return map(int,input().split())
def LI():
return [int(i) for i in input().split()]
def LI_():
return [int(i)-1 for i in input().split()]
def StoI():
return [ord(i)-97 for i in input()]
def ItoS(nn):
return chr(nn+97)
def show(*inp,end='\n'):
if show_flg:
print(*inp,end=end)
YN=['Yes','No']
mo=10**9+7
inf=float('inf')
l_alp=string.ascii_lowercase
u_alp=string.ascii_uppercase
ts=time.time()
#sys.setrecursionlimit(10**6)
input=lambda: sys.stdin.readline().rstrip()
show_flg=False
#show_flg=True
n,m=LI()
## Segment Tree ##
## Initializer Template ##
# Range Sum: sg=SegTree(n,0)
# Range Minimum: sg=SegTree(n,inf,min,inf)
class SegTree:
def __init__(self,n,init_val=0,function=lambda a,b:a+b,ide=0):
self.n=n
self.ide_ele=ide_ele=ide
self.num=num=2**(n-1).bit_length()
self.seg=seg=[self.ide_ele]*2*self.num
self.segfun=segfun=function
#set_val
for i in range(n):
self.seg[i+self.num-1]=init_val
#built
for i in range(self.num-2,-1,-1) :
self.seg[i]=self.segfun(self.seg[2*i+1],self.seg[2*i+2])
def update(self,k,x):
k += self.num-1
self.seg[k] = x
while k:
k = (k-1)//2
self.seg[k] = self.segfun(self.seg[k*2+1],self.seg[k*2+2])
def query(self,p,q):
if q<=p:
return self.ide_ele
p += self.num-1
q += self.num-2
res=self.ide_ele
while q-p>1:
if p&1 == 0:
res = self.segfun(res,self.seg[p])
if q&1 == 1:
res = self.segfun(res,self.seg[q])
q -= 1
p = p//2
q = (q-1)//2
if p == q:
res = self.segfun(res,self.seg[p])
else:
res = self.segfun(self.segfun(res,self.seg[p]),self.seg[q])
return res
def __str__(self):
# 生配列を表示
rt=self.seg[self.num-1:self.num-1+self.n]
return str(rt)
s=[int(i) for i in input()]
def dp(b,m): # N log (N)
N=len(b)-1
n=N+1
sg=SegTree(n,inf,min,inf)
sg.update(0,0)
dp=[0]+[inf]*(N)
for i in range(N):
if b[i+1]==1:
continue
dp[i+1]=sg.query(max(i-m+1,0),i+1)+1
sg.update(i+1,dp[i+1])
#show(seg)
show(sg)
return dp
dp1=dp(s,m)
step=dp1[n]
if step==inf:
print(-1)
exit()
dp2=dp(s[::-1],m)[::-1]
show(dp1,'dp1')
move=[0]
ans=[]
j=1
for i in range(step,0,-1): # N
while j<=n and dp2[j]!=i-1:
j+=1
move.append(j)
for i in range(len(move)-1):
ans.append(move[i+1]-move[i])
print(*ans)
| import heapq
def main():
N, M = list(map(int, input().split(' ')))
S = input()
# 最短手数のdpテーブルを作る
T = S[::-1] # ゴールから逆順にたどる（最後に逆にする）
dp = [-1] * (N + 1)
que = [0] * M
for i, t in enumerate(T):
if i == 0:
dp[0] = 0
continue
if len(que) == 0:
print(-1)
return
index = heapq.heappop(que)
if t == '1':
continue
dp[i] = 1 + dp[index]
while len(que) < M:
heapq.heappush(que, i)
dp.reverse()
# 細切れに進んでいく
path = list()
target = dp[0] - 1
cnt = 0
for i in range(N + 1):
if dp[i] != target:
cnt += 1
else:
path.append(cnt)
cnt = 1
target -= 1
print(' '.join(map(str, path)))
if __name__ == '__main__':
main()
| 1 | 138,955,357,166,080 | null | 274 | 274 |
import sys, bisect, math, itertools, string, queue, copy
import numpy as np
import scipy
from collections import Counter,defaultdict,deque
from itertools import permutations, combinations
from heapq import heappop, heappush
from fractions import gcd
input = sys.stdin.readline
sys.setrecursionlimit(10**8)
mod = 10**9+7
def inp(): return int(input())
def inpm(): return map(int,input().split())
def inpl(): return list(map(int, input().split()))
def inpls(): return list(input().split())
def inplm(n): return list(int(input()) for _ in range(n))
def inplL(n): return [list(input()) for _ in range(n)]
def inplT(n): return [tuple(input()) for _ in range(n)]
def inpll(n): return [list(map(int, input().split())) for _ in range(n)]
def inplls(n): return sorted([list(map(int, input().split())) for _ in range(n)])
k = inp()
runrun = [["1","2","3","4","5","6","7","8","9"]]
runrun_int = []
for j in range(2,11):
tmp = []
for i in range(len(runrun[j - 2])):
if runrun[j-2][i][j-2] == "0":
tmp.append(runrun[j-2][i] + str(int(runrun[j-2][i][j-2])))
tmp.append(runrun[j-2][i] + str(int(runrun[j-2][i][j-2]) + 1))
elif runrun[j-2][i][j-2] in ["1","2","3","4","5","6","7","8"]:
tmp.append(runrun[j-2][i] + str(int(runrun[j-2][i][j-2]) - 1))
tmp.append(runrun[j-2][i] + str(int(runrun[j-2][i][j-2])))
tmp.append(runrun[j-2][i] + str(int(runrun[j-2][i][j-2]) + 1))
elif runrun[j-2][i][j-2] == "9":
tmp.append(runrun[j-2][i] + str(int(runrun[j-2][i][j-2]) - 1))
tmp.append(runrun[j-2][i] + str(int(runrun[j-2][i][j-2])))
runrun.append(tmp)
ans = []
for i in range(len(runrun)):
for j in range(len(runrun[i])):
ans.append(int(runrun[i][j]))
ans.sort()
print(ans[k - 1]) | import collections
K = int(input())
if K < 10:
print(K)
exit()
q = collections.deque()
for i in range(1, 10):
q.append(i)
i = 9
while True:
x = q.popleft()
lsk = x % 10
shifted = x * 10
if lsk != 0:
q.append(shifted + lsk - 1)
i += 1
if i == K:
print(shifted + lsk - 1)
break
q.append(shifted + lsk)
i += 1
if i == K:
print(shifted + lsk)
break
if lsk != 9:
q.append(shifted + lsk + 1)
i += 1
if i == K:
print(shifted + lsk + 1)
break
| 1 | 40,010,288,927,062 | null | 181 | 181 |
import sys
while(True):
x, y = map(lambda x: (int, int)[x.isdigit()](x) ,sys.stdin.readline().split(None, 1))
if x == 0 and y == 0:
break
if x < y:
print("%d %d" % (x, y))
else:
print("%d %d" % (y, x)) | S = input()
if S == "RRR":
print(3)
elif S == "RRS" or S == "SRR":
print(2)
elif "R" in S:
print(1)
else:
print(0)
| 0 | null | 2,699,097,602,586 | 43 | 90 |
def give_grade(m, f, r):
if m == -1 or f == -1:
return "F"
elif m + f < 30:
return "F"
elif m + f < 50:
return "D" if r < 50 else "C"
elif m + f < 65:
return "C"
elif m + f < 80:
return "B"
else:
return "A"
while True:
m, f, r = map(int, input().split())
if m == f == r == -1:
break
else:
print(give_grade(m, f, r)) | N = int(input())
A = list(map(int, input().split()))
A.sort(reverse=True)
ans = A[0]
N -= 2
for i in range(1, N):
if N >= 2:
ans += A[i]*2
N -= 2
elif N == 1:
ans += A[i]
N -= 1
else:
break
print(ans)
| 0 | null | 5,134,083,209,318 | 57 | 111 |
n = input()
n = int(n)
l = []
for i in range(1, n+1):
if i % 3 == 0:
l.append(i)
else:
j = i
while j > 0:
if j % 10 == 3:
l.append(i)
break
else:
j //= 10
for p in l:
print(" " + str(p), end="")
print()
| n = [int(x) for x in input().split()]
for nn in range(1, n[0] + 1):
if nn % 3 == 0 or '3' in str(nn):
print(' ' + str(nn), end = '')
print() | 1 | 916,451,671,042 | null | 52 | 52 |
s=str(input())
t=str(input())
n=len(s)
count=0
for i in range(n):
if s[i]==t[i]:
count+=1
else:
continue
print(n-count)
| import math
from functools import reduce
def lcm_base(x, y):
return (x * y) // math.gcd(x, y)
def lcm(*numbers):
return reduce(lcm_base, numbers, 1)
N,M = map(int,input().split())
a = list(map(lambda a: int(a)//2, input().split()))
g = lcm(*a)
if any([g // item % 2 == 0 for item in a]):
print(0)
else:
ans = M//g
ans = max(math.ceil(ans/2),0)
print(ans) | 0 | null | 56,111,641,838,158 | 116 | 247 |
n, m = map(int, input().split())
lis = sorted(list(map(int, input().split())), reverse=True)
con = 0
for i in range(n):
if lis[i] >= sum(lis) * (1/(4*m)):
con += 1
if con == m:
print("Yes")
exit()
print("No") | n = int(input())
A = list(map(int, input().split()))
q = int(input())
m = list(map(int, input().split()))
max = max(m)
dp = [[0 for _ in range(max + 1)] for __ in range(n + 1)]
dp[0][0] = 1#[1 for _ in range(max + 1)]
for j in range(n):
for k in range(max + 1):
if k >= A[j] and dp[j][k - A[j]]:
dp[j + 1][k] = 1
elif dp[j][k]:
dp[j + 1][k] = 1
for i in range(q):
if dp[n][m[i]]:
print("yes")
else:
print("no")
| 0 | null | 19,367,255,900,178 | 179 | 25 |
#!/usr/bin/env python
import sys
input = sys.stdin.buffer.readline
sys.setrecursionlimit(10**6)
INF = float("inf")
def main():
A,B = map(int,input().split())
print(max(0, A-B*2))
if __name__ == "__main__":
main() | a,b=map(int, input().split())
c=a-2*b
print(c if c>=0 else 0 ) | 1 | 167,159,133,342,432 | null | 291 | 291 |
S=input()
N=len(S)
K=int(input())
s="".join((S,S))
cnt1=0
cnt2=0
buf=0
piv=""
if len(set(S))!=1:
for i in range(N):
if S[i]==piv:
buf=buf+1
else:
piv=S[i]
cnt1=cnt1+(buf+1)//2
buf=0
cnt1=cnt1+(buf+1)//2
buf=0
piv=""
for i in range(2*N):
if s[i]==piv:
buf=buf+1
else:
piv=s[i]
cnt2=cnt2+(buf+1)//2
buf=0
#print(buf)
cnt2 = cnt2 + (buf + 1) // 2
x = cnt2 - cnt1
print(cnt1 + (K - 1) * x)
else:
print((len(S)*K)//2)
| ni = lambda: int(input())
nm = lambda: map(int, input().split())
nl = lambda: list(map(int, input().split()))
k = ni()
a = [0]*(10**6+1)
a[1] = 7%k
for i in range(2,k+1):
a[i] = (a[i-1]*10+7)%k
for i in range(1,k+1):
if a[i]==0:
print(i)
exit()
print(-1) | 0 | null | 90,940,314,450,158 | 296 | 97 |
n = int(input())
s = [str(input()) for i in range(n)]
for h in ['AC','WA','TLE','RE']:
print(h,'x',s.count(h)) | n = int(input())
first_list = ['AC', 'WA', 'TLE', 'RE']
list = []
for _ in range(n):
list.append(input())
for i in first_list:
print(i, 'x', list.count(i)) | 1 | 8,612,964,880,052 | null | 109 | 109 |
import sys
S = input()
if not ( len(S) == 6 and S.islower() ): sys.exit()
print('Yes') if S[2] == S[3] and S[4] == S[5] else print('No') | for val in range(input()):
x = map(int,raw_input().split(' '))
x.sort()
if x[0]**2+x[1]**2==x[2]**2: print 'YES'
else: print 'NO' | 0 | null | 21,061,253,442,814 | 184 | 4 |
size = [int(i) for i in input().split()]
matrix = [[0 for i in range(size[1])] for j in range(size[0])]
vector = [0 for i in range(size[1])]
for gyou in range(size[0]):
x = [int(i) for i in input().split()]
matrix[gyou] = x
for retsu in range(size[1]):
x = int(input())
vector[retsu] = x
for gyou in range(size[0]):
print(sum(map(lambda val1, val2: val1 * val2, matrix[gyou], vector)))
| X = int(input())
ans = X // 500 * 1000
ans += X % 500 // 5 * 5
print(ans) | 0 | null | 22,108,458,395,968 | 56 | 185 |
import math
N = int(input())
print (math.ceil(N/2)) | import sys
t1, t2 = map(int, input().split())
a1, a2 = map(int, input().split())
b1, b2 = map(int, input().split())
if (a1-b1)*t1+(a2-b2)*t2 == 0:
print("infinity")
sys.exit()
e1 = (a1-b1)*t1
e2 = e1 + (a2-b2)*t2
if e1*e2 > 0:
print(0)
sys.exit()
e1, e2 = abs(e1), abs(e2)
if e1%e2:
print(1+2*(e1//e2))
else:
print(2*(e1//e2)) | 0 | null | 95,266,913,163,904 | 206 | 269 |
def solve():
N = int(input())
S, T = map(str, input().split())
ans = ""
for i in range(N): ans += S[i] + T[i]
print(ans)
if __name__ == "__main__":
solve() | N = int(input())
a=list(map(int,input().split()))
count=0
for i in range(1,N+1):
if i%2==1:
if a[i-1]%2==1:
count +=1
print(count) | 0 | null | 59,908,792,045,340 | 255 | 105 |
a,b = input().split()
if a == b:
print("Yes")
else:
print("No") | num = input().split()
a = int(num[0])
b = int(num[1])
c = int(num[2])
ans = 0
for i in range(a,b+1):
if c % i == 0:
ans += 1
print(ans) | 0 | null | 42,054,525,029,088 | 231 | 44 |
import sys
input = lambda: sys.stdin.readline().rstrip()
h1, m1, h2, m2, k = map(int, input().split())
m = 60 - m1
h1 += 1
m += (h2 - h1)*60 + m2
print(max(0, m - k)) | from collections import deque
import copy
h,w=map(int,input().split())
Inf=float('inf')
maze1=[]
for _ in range(h):
s=list(input())
for u in range(w):
if s[u]=='.':
s[u]=Inf
maze1.append(s)
def maze_solve(maze,sy,sx):
qu=deque([[sy,sx]])
maze[sy][sx]=0
while qu:
y,x=qu.popleft()
T=maze[y][x]
for i in ([1,0],[-1,0],[0,1],[0,-1]):
ny=y+i[0]
nx=x+i[1]
if 0<=ny<=h-1 and 0<=nx<=w-1 and maze[ny][nx]!='#':
if maze[ny][nx]>T+1:
maze[ny][nx]=T+1
qu.append([ny,nx])
ans=-Inf
for i in range(h):
for j in range(w):
if maze[i][j]!='#' and maze[i][j]!=Inf:
ans=max(ans,maze[i][j])
return ans
ans=-Inf
for i in range(h):
for j in range(w):
if maze1[i][j]!='#':
maze2=copy.deepcopy(maze1)
ans=max(ans,maze_solve(maze2,i,j))
print(ans) | 0 | null | 56,048,823,425,700 | 139 | 241 |
while True:
a, op, b = input().split()
if op == "?":
break
a, b = int(a), int(b)
if op == "+":
print(a + b)
elif op == "-":
print(a - b)
elif op == "/":
print("%d" % (a / b))
else:
print(a * b)
| while True:
a, op, b = raw_input().split()
if op == '?': break
a, b = int(a), int(b)
if op == '+': print a+b
if op == '-': print a-b
if op == '*': print a*b
if op == '/': print a/b | 1 | 699,765,084,340 | null | 47 | 47 |
N, P = map(int, input().split())
S = input()
if P == 2:
ans = 0
for i, d in enumerate(map(int, S)):
if d % 2 == 0:
ans += i+1
print(ans)
elif P == 5:
ans = 0
for i, d in enumerate(map(int, S)):
if d % 5 == 0:
ans += i+1
print(ans)
else:
mods = [0] * P
mods[0] = 1
cur_mod = 0
for i, digit in enumerate(map(int, S)):
cur_mod += pow(10, N-i-1, P) * digit
cur_mod %= P
mods[cur_mod] += 1
ans = 0
for count in mods:
ans += count * (count - 1) // 2
print(ans) | # C - Distinct or Not
# https://atcoder.jp/contests/abc154/tasks/abc154_c
num = int(input())
p = list(map(int, input().split()))
list.sort(p)
ret = "YES"
for i in range(num-1):
if p[i] == p[i+1]:
ret = "NO"
break
print("{}".format(ret)) | 0 | null | 66,003,178,620,974 | 205 | 222 |
import itertools
n=int(input())
list1=list(map(int,input().split()))
q=int(input())
list2=list(map(int,input().split()))
sum1=set()
for i in range(1,n+1):
x=list(itertools.combinations(list1,i))
for j in x:
sum1.add(sum(j))
for i in list2:
if i in sum1:
print("yes")
else:
print("no")
| n = int(input())
A = list(map(int, input().split()))
q = int(input())
m = list(map(int, input().split()))
memo = [[None]*2000 for i in range(2000)]
def exhaustivesearch(i, target):
if memo[i][target] is not None:
return memo[i][target]
if target == 0:
memo[i][target] = True
return True
if i >= n:
memo[i][target] = False
return False
else:
memo[i][target] = exhaustivesearch(i + 1, target) or exhaustivesearch(i + 1, target-A[i])
return memo[i][target]
for j in m:
if exhaustivesearch(0, j):
print("yes")
else:
print("no") | 1 | 96,975,414,822 | null | 25 | 25 |
import itertools
n =int(input())
p =tuple(map(int,input().split()))
q =tuple(map(int,input().split()))
l = list(range(1,n+1))
r = list(itertools.permutations(l, n))
print(abs(r.index(p)-r.index(q))) | n = int(input())
s = 0
a = 1
b = 1
while a*b < n:
while a*b < n and b <= a:
if a == b:
s += 1
else:
s += 2
b += 1
a += 1
b = 1
print(s)
| 0 | null | 51,772,788,843,428 | 246 | 73 |
h,n=map(int,input().split())
a,b=[],[]
for i in range(n):
A,B=map(int,input().split())
a.append(A)#ダメージ量
b.append(B)#消費魔力
dp=[float('inf')]*(h+1)
dp[0]=0
for i in range(h):
for j in range(n):
next=i+a[j] if i+a[j]<=h else h
dp[next]=min(dp[next],dp[i]+b[j])
print(dp[-1])
| h,n=map(int,input().split())
a=[]
b=[]
for i in range(n):
aa,bb=map(int,input().split())
a.append(aa)
b.append(bb)
inf=10**10
f=h+max(a)+1
dp=[f*[inf]for _ in range(n+1)]
dp[0][0]=0
for i in range(1,n+1):
dp[i]=dp[i-1]
for j in range(f):
if j+a[i-1]<f:
dp[i][j+a[i-1]]=min(dp[i][j+a[i-1]],dp[i][j]+b[i-1])
for j in range(f-1,0,-1):
dp[i][j-1]=min(dp[i][j-1],dp[i][j])
print(dp[-1][h])
| 1 | 81,032,522,539,748 | null | 229 | 229 |
n = int(input())
d = {}
t = 0
for i in range(n):
s = input()
d[s] = d.get(s, 0) + 1
t = max(t, d[s])
for key in sorted(d):
if d[key] == t:
print(key) | dic = {}
l = []
n = int(input())
for i in range(n):
s = input()
#sが新規キーか否かで操作を変える
if s in dic:
dic[s] += 1
#新規ではないならvalueを1増やす
else:
dic[s] = 1
m = max(dic.values())
for i in dic:
if dic[i] == m:
l += [i]
print(*sorted(l)) | 1 | 70,143,502,361,508 | null | 218 | 218 |
S = list(input())
N = int(input())
normalFlag = True
front = []
back = []
for _ in range(N):
q = list(map(str,input().split()))
if q[0] == '1':
normalFlag = not normalFlag
else:
if q[1] == '1':
if normalFlag:
front.append(q[2])
else:
back.append(q[2])
else:
if normalFlag:
back.append(q[2])
else:
front.append(q[2])
if normalFlag:
front.reverse()
ans = front+S+back
else:
back.reverse()
S.reverse()
ans = back+S+front
print(''.join(map(str,ans))) | N = int(input())
c = list(input())
#cを[R,R,R,.....,R,W,W,W,.....,W]の形にする。
div = c.count('R')
c_for = c[:div]
c_lat = c[div:]
ans = 0
replace = min(c_for.count('W'), c_lat.count('R'))
change = max(c_for.count('W'), c_lat.count('R')) - replace
ans = replace + change
#実質 ans = max(c_for.count('W'), c_lat.count('R')) やんけ！
print(ans) | 0 | null | 32,042,459,136,520 | 204 | 98 |
n,m = map(int,input().split())
prb = [[0] for _ in range(n+1)]
for _ in range(m):
sub = input().split()
p, s = int(sub[0]), sub[1]
lst = prb[p]
if lst[-1] == 1:
pass
elif s == "WA":
lst.append(0)
elif s == "AC":
lst.append(1)
prb[p] = lst
ac_prb = [lst for lst in prb if lst[-1] == 1]
ac_num = len(ac_prb)
pe_num = -2*ac_num
for prb in ac_prb:
pe_num += len(prb)
print(ac_num, pe_num) | import sys, bisect, math, itertools, string, queue, copy
# import numpy as np
# import scipy
# from collections import Counter,defaultdict,deque
# from itertools import permutations, combinations
# from heapq import heappop, heappush
# # input = sys.stdin.readline
# sys.setrecursionlimit(10**8)
mod = 10**9+7
def inp(): return int(input())
def inpm(): return map(int,input().split())
def inpl(): return list(map(int, input().split()))
def inpls(): return list(input().split())
def inplm(n): return list(int(input()) for _ in range(n))
def inplL(n): return [list(input()) for _ in range(n)]
def inplT(n): return [tuple(input()) for _ in range(n)]
def inpll(n): return [list(map(int, input().split())) for _ in range(n)]
def inplls(n): return sorted([list(map(int, input().split())) for _ in range(n)])
n,k = inpm()
A = sorted(inpl())
f=[1]
for i in range(1,n+1):
f.append(f[-1]*i % mod)
#nCr
def comb(n,r):
if n <= 0 or r <= 0:
return 0
x = f[n] % mod
y = f[r] * f[n-r] % mod
return (x * pow(y, mod-2, mod) % mod)
ans = 0
for i in range(n):
c = comb(n-i-1,k-1)
ans += A[n-1-i] * c - A[i] * c
ans %= mod
if c == 1:
break
print(ans)
| 0 | null | 94,701,329,734,602 | 240 | 242 |
import sys
n,m = map(int,input().split())
a = [0]*n
flag = [0]*n
for i in range(m):
s,c = map(int,input().split())
if s == 1 and c == 0 and n != 1:
print(-1)
sys.exit()
if flag[s-1] == 0:
flag[s-1] = 1
else:
#flag[s-1] == 1
if a[s-1] != c:
print(-1)
sys.exit()
a[s-1] = c
if a[0] == 0 and n != 1:
a[0] = 1
print("".join(map(str,a)))
| if __name__ == '__main__':
N, M = map(int, input().split())
S = []
C = []
for i in range(M):
s, c = map(int, input().split())
s -= 1
S.append(s)
C.append(c)
for num in range(0, pow(10, N)):
st_num = str(num)
if len(str(st_num))!=N: continue
cnt = 0
for m in range(M):
if int(st_num[S[m]])==C[m]:
cnt += 1
if cnt==M:
print(st_num)
quit()
print(-1)
| 1 | 60,751,434,339,222 | null | 208 | 208 |
n, k = map(int, input().split())
a_list = [int(i) for i in input().split()]
f_list = [int(i) for i in input().split()]
a_list.sort(reverse=True)
f_list.sort()
if k >= sum(a_list):
print(0)
exit()
point = []
for i in range(n):
point.append(a_list[i] * f_list[i])
import math
def binary_search(point, k):
left = 0
right = 10 ** 12
while left + 1< right:
ans = 0
center = (left + right) // 2
for i in range(n):
if point[i] > center:
ans += a_list[i] - (center // f_list[i])
if ans <= k:
right = center
else:
left = center
return left
value = binary_search(point, k)
print(value + 1)
| import numpy as np
def main():
N, K = [int(x) for x in input().split()]
A = [float(x) for x in input().split()]
F = [float(x) for x in input().split()]
A = np.array(sorted(A))
F = np.array(sorted(F, reverse=True))
if K >= np.sum(A)*N:
print(0)
exit()
min_time = 0
max_time = A[-1] * F[0]
while max_time != min_time:
tgt_time = (min_time + max_time)//2
ideal_a = np.floor(tgt_time*np.ones(N)/F)
cost = A - ideal_a
require_k = np.sum(cost[cost > 0])
if require_k <= K:
max_time = tgt_time
else:
min_time = tgt_time+1
print(int(max_time))
if __name__ == "__main__":
main()
| 1 | 165,467,345,669,696 | null | 290 | 290 |
N,M,L = map(int,input().split())
ABC = [list(map(int,input().split())) for _ in range(M)]
Q = int(input())
class WarshallFloyd:
def __init__(self,n):
self.n = n
self.inf = 100000000000000
self.d = [[self.inf for _ in range(n)] for _ in range(n)]
for i in range(self.n):
self.d[i][i] = 0
def register(self,v1,v2,l,multiple=True):
self.d[v1][v2] = l
if multiple:
self.d[v2][v1] = l
def solve(self):
for i in range(self.n):
for j in range(self.n):
for k in range(self.n):
self.d[j][k] = min(self.d[j][k],self.d[j][i]+self.d[i][k])
return self.d
W = WarshallFloyd(N)
for a,b,c in ABC:
W.register(a-1,b-1,c)
D = W.solve()
WL = WarshallFloyd(N)
for i in range(N):
for j in range(N):
if D[i][j] <= L and i != j:
WL.register(i,j,1)
DL = WL.solve()
ST = [list(map(int,input().split())) for _ in range(Q)]
for i in range(Q):
s,t = ST[i]
transition = DL[s-1][t-1]
if transition == 100000000000000:
print(-1)
else:
print(transition-1) | import itertools
N = int(input())
c = []
d = 0
for i in range(N):
x1, y1 = map(int, input().split())
c.append((x1,y1))
cp = list(itertools.permutations(c))
x = len(cp)
for i in range(x):
for j in range(N-1):
d += ((cp[i][j][0]-cp[i][j+1][0])**2 + (cp[i][j][1] - cp[i][j+1][1])**2)**0.5
print(d/x) | 0 | null | 161,316,842,348,890 | 295 | 280 |
import sys
readline = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)
def main():
C = input()
print(chr(ord(C) + 1))
if __name__ == '__main__':
main()
| c = input()
alpha = [chr(i) for i in range(97, 97+26)]
number = alpha.index(c)
print(alpha[number + 1])
| 1 | 91,930,878,638,742 | null | 239 | 239 |
D = int(input())
c = [int(i) for i in input().split()]
s = []
for i in range(D):
tmp = [int(j) for j in input().split()]
s.append(tmp)
t = []
for i in range(D):
t.append(int(input()))
sat = 0
lst = [0 for i in range(26)]
for i in range(D):
sat += s[i][t[i]-1]
lst[t[i]-1] = i + 1
for j in range(26):
sat -= c[j] * ((i + 1) - lst[j])
print(sat) | n = int(input())
print(n//2-1 + n % 2) | 0 | null | 81,831,095,776,060 | 114 | 283 |
N = int(input())
P = list(map(int,input().split()))
n = float("INF")
count = 0
for i in P:
if n >= i:
n = i
count += 1
print(count) | while True:
h,w = map(int,input().split())
if h==0 and w==0: break
for i in range(h):
s = ''
for j in range(w):
if (i+j)%2==0: s += '#'
else: s+='.'
print(s)
print()
| 0 | null | 43,107,995,438,222 | 233 | 51 |
K = int(input())
S = input()
def answer(K: int, S: str) -> str:
if len(S) <= K:
return S
else:
return S[:K]+ '...'
print(answer(K, S)) | n = int(input())
s = input()
if len(s) <= n:
print(s)
else:
print(s[0:n],'...', sep='') | 1 | 19,613,396,183,602 | null | 143 | 143 |
import math
n, a, b = map(int, input().split())
mod = 10**9 + 7
s = pow(2, n, mod) - 1
def cal(n, r):
p = 1
q = 1
for i in range(r):
p = p*(n-i)%mod
q = q*(i+1)%mod
return p*pow(q, mod-2, mod)%mod
print((s - cal(n, a) - cal(n, b))%mod) | # nCr mod m
# rがn/2に近いと非常に重くなる
def combination(n, r, mod=10**9+7):
n1, r = n+1, min(r, n-r)
numer = denom = 1
for i in range(1, r+1):
numer = numer * (n1-i) % mod
denom = denom * i % mod
return numer * pow(denom, mod-2, mod) % mod
mod = 10**9+7
N, A, B = map(int, input().split())
ans = pow(2, N, mod) - 1 - combination(N, A) - combination(N, B)
ans %= mod
print(ans)
| 1 | 66,604,668,980,818 | null | 214 | 214 |
N = int(input())
R = [int(input()) for _ in range(N)]
p_buy = R[0]
p_sale = R[1]
buy = R[1]
sale = None
for i in range(2, N):
if p_sale < R[i]:
p_sale = R[i]
if buy > R[i]:
if sale is None:
sale = R[i]
if p_sale - p_buy < sale - buy:
p_sale, p_buy = sale, buy
sale, buy = None, R[i]
else:
if sale is None or sale < R[i]:
sale = R[i]
p_gain = p_sale - p_buy
print(p_gain if sale is None else max(p_gain, sale - buy)) | if __name__ == "__main__":
a, b, c = map( int, input().split() )
if a < b < c:
print("Yes")
else:
print("No") | 0 | null | 197,710,315,072 | 13 | 39 |
N = int(input())
D = list(map(int, input().split()))
from itertools import accumulate
print(sum(list(d*c for d, c in zip(D[1:], accumulate(D)))))
| N=int(input())
d=list(map(int,input().split()))
l=len(d)
s=0
for i in range(l):
for j in range(i+1,l):
s+=d[i]*d[j]
print(s) | 1 | 167,905,941,700,718 | null | 292 | 292 |
def check(arr):
# 横チェック
for i in range(len(arr)):
if arr[i] == ["x", "x", "x"]:
return True
# 縦チェック
for i in range(3):
if arr[0][i] == "x" and arr[1][i] == "x" and arr[2][i] == "x":
return True
# 斜めチェック
if arr[0][0] == "x" and arr[1][1] == "x" and arr[2][2] == "x":
return True
elif arr[0][2] == "x" and arr[1][1] == "x" and arr[2][0] == "x":
return True
return False
arr = []
for _ in range(3):
arr.append(list(map(int, input().split(' '))))
n = int(input())
for _ in range(n):
b = int(input())
for i in range(len(arr)):
tmp_arr = []
for ele in arr[i]:
if b == ele:
tmp_arr.append("x")
else:
tmp_arr.append(ele)
arr[i] = tmp_arr
if check(arr) == True:
print("Yes")
else:
print("No")
| def main():
A = [list(map(int, input().split())) for _ in range(3)]
n = int(input())
for _ in range(n):
b = int(input())
for i in range(3):
for j in range(3):
if A[i][j] == b:
A[i][j] = 0
ans = 'No'
for i in range(3):
if any(A[i]) == 0:
ans = 'Yes'
for i in range(3):
if any([A[0][i], A[1][i], A[2][i]]) == 0:
ans = 'Yes'
if any([A[0][0], A[1][1], A[2][2]]) == 0:
ans = 'Yes'
if any([A[0][2], A[1][1], A[2][0]]) == 0:
ans = 'Yes'
print(ans)
if __name__ == '__main__':
main()
| 1 | 59,897,021,628,078 | null | 207 | 207 |
n = int(input())
left = []
mid = []
midminus = []
right = []
L = []
R = []
for i in range(n):
s = input()
l = 0
r = 0
for x in s:
if x == '(':
l += 1
else:
if l > 0:
l -= 1
else:
r += 1
if l > 0 and r == 0:
left.append((l, r))
elif l > 0 and r > 0:
if l > r:
mid.append((r, l)) # a,b-a
else:
midminus.append((r,l))
elif l == 0 and r > 0:
right.append((l, r))
L.append(l)
R.append(r)
if sum(L) != sum(R):
print('No')
exit()
A = 0
B = 0
for x in left:
A += x[0]
for x in right:
B += x[1]
mid = sorted(mid, key=lambda x: (x[0],-x[1]))
midminus = sorted(midminus,key= lambda x:x[0]-x[1])
mid += midminus
l = A
r = 0
for a, b in mid:
if l < a:
print('No')
exit()
l -= a
l += b
print('Yes') | n = int(input())
s = []
for i in range(n):
a = input()
b = []
for j in range(len(a)):
if a[j]=='(':
b.append(1)
else:
b.append(-1)
s.append(b)
l = []
r = []
for x in s:
b = 0
c = 0
for y in x:
c+=y
b = min(b,c)
z = len(x)
d = 0
e = 0
for j in range(z):
e += x[z-j-1]
d = max(d,e)
if c>0:
l.append([b,c])
else:
r.append([d,c])
l.sort(reverse=True)
r.sort()
flag = 1
x = 0
for b,c in l:
if x+b<0:
flag = 0
x += c
y = 0
for d,c in r:
if y+d>0:
flag = 0
y += c
if y+x!=0:
flag = 0
print('Yes' if flag else'No')
| 1 | 23,454,507,632,300 | null | 152 | 152 |
n = int(input())
l = {}
for _ in range(n):
ss = input().split()
order, string = ss[0], ss[1]
if order == "insert":
l[string] = 1
else:
print('yes' if string in l else 'no') | n = int(input())
a = [input() for i in range(n)]
c0, c1, c2, c3 = 0, 0, 0, 0
for output in a:
if output == 'AC':
c0 += 1
elif output == 'WA':
c1 += 1
elif output == 'TLE':
c2 += 1
elif output == 'RE':
c3 += 1
print('AC x {}'.format(c0))
print('WA x {}'.format(c1))
print('TLE x {}'.format(c2))
print('RE x {}'.format(c3)) | 0 | null | 4,425,398,450,528 | 23 | 109 |
w = raw_input().lower()
s = 0
while 1:
in_str = raw_input()
if in_str == "END_OF_TEXT":
break
in_str = map(str, in_str.split())
for i in in_str:
if i.lower() == w:
s+=1
print s | count = 0
W = input().lower()
while True:
T = input()
if T == 'END_OF_TEXT':
break
count += T.lower().split().count(W)
print(count) | 1 | 1,826,481,153,420 | null | 65 | 65 |
w, h, x, y, r= map(int, raw_input().split())
if (r <= x <= w-r) and (r <= y <= h - r):
print 'Yes'
else:
print 'No' | inl=map(int, raw_input().split())
if inl[0]>=inl[2]+inl[4] and inl[2]-inl[4]>=0 and inl[1]>=inl[3]+inl[4] and inl[3]-inl[4]>=0:
print "Yes"
else:
print "No" | 1 | 454,292,051,900 | null | 41 | 41 |
def main():
s = input()
n = len(s) + 1
ans = [-1] * (n)
def right(i, ans):
j = 1
while True:
ans[i + j] = max(ans[i + j], j)
if i + j == n - 1:
break
if s[i + j] == '<':
j += 1
else:
break
return ans
def left(i, ans):
j = 1
while True:
ans[i - j] = max(ans[i - j], j)
if i - j == 0:
break
if s[i - j - 1] == '>':
j += 1
else:
break
return ans
for i in range(n):
if i == 0:
if s[i] == '<':
ans[0] = 0
ans = right(i, ans)
else:
pass
elif i == n - 1:
if s[i - 1] == '>':
ans[n - 1] = 0
ans = left(i, ans)
else:
pass
else:
if s[i] == '<' and s[i - 1] == '>':
ans[i] = 0
ans = right(i, ans)
ans = left(i, ans)
else:
pass
print(sum(ans))
if __name__ == '__main__':
main()
| s=input()
sl=len(s)
a=[]
count=1
for i in range(sl-1):
if s[i+1]==s[i]:
count+=1
else:
a.append(count)
count=1
a.append(count)
ans=0
al=len(a)
if s[0]=="<":
for i in range(0,al-1,2):
m,n=max(a[i],a[i+1]),min(a[i],a[i+1])
ans+=(m*(m+1)+n*(n-1))/2
if al%2==1:
ans+=a[-1]*(a[-1]+1)/2
elif s[0]==">":
ans+=a[0]*(a[0]+1)/2
for i in range(1,al-1,2):
m,n=max(a[i],a[i+1]),min(a[i],a[i+1])
ans+=(m*(m+1)+n*(n-1))/2
if al%2==0:
ans+=a[-1]*(a[-1]+1)/2
print(int(ans)) | 1 | 156,059,460,424,800 | null | 285 | 285 |
import sys
import math
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
in_n = lambda: int(readline())
in_nn = lambda: map(int, readline().split())
in_nl = lambda: list(map(int, readline().split()))
in_na = lambda: map(int, read().split())
in_s = lambda: readline().rstrip().decode('utf-8')
def LCM(a, b):
return a * b // math.gcd(a, b)
def main():
N, M = in_nn()
a = in_nl()
lcm = 1
for i in range(N):
lcm = LCM(lcm, a[i])
if lcm > M * 2:
print(0)
exit()
for i in range(N):
if lcm // a[i] % 2 == 0:
print(0)
exit()
lcm = lcm // 2
q = M // lcm
if q % 2 == 0:
ans = q // 2
else:
ans = q // 2 + 1
print(ans)
if __name__ == '__main__':
main()
| def main():
N, K, C = map(int, input().split())
S = input()
i = 0
c = 0
p = [-1] * N
while c < K:
if S[i] == 'o':
p[i] = c
c += 1
i += C
i += 1
i = N - 1
c = K - 1
q = [-1] * N
while c >= 0:
if S[i] == 'o':
q[i] = c
c -= 1
i -= C
i -= 1
for i in range(N):
if ~p[i] and p[i] == q[i]:
print(i + 1)
if __name__ == '__main__':
main()
| 0 | null | 71,440,574,109,508 | 247 | 182 |
n = int(input())
a = list(map(int, input().split()))
assert(len(a) == n)
ans = 0
for i in range(n):
if not i % 2 and a[i] % 2:
ans += 1
print(ans)
| input()
print(' '.join(input().split()[::-1]))
| 0 | null | 4,371,243,646,660 | 105 | 53 |
import sys
sys.setrecursionlimit(1 << 25)
readline = sys.stdin.buffer.readline
read = sys.stdin.readline # 文字列読み込む時はこっち
ra = range
enu = enumerate
def exit(*argv, **kwarg):
print(*argv, **kwarg)
sys.exit()
def mina(*argv, sub=1): return list(map(lambda x: x - sub, argv))
# 受け渡されたすべての要素からsubだけ引く.リストを*をつけて展開しておくこと
def a_int(): return int(readline())
def ints(): return list(map(int, readline().split()))
def read_col(H):
'''H is number of rows
A列、B列が与えられるようなとき
ex1)A,B=read_col(H) ex2) A,=read_col(H) #一列の場合'''
ret = []
for _ in range(H):
ret.append(list(map(int, readline().split())))
return tuple(map(list, zip(*ret)))
def read_tuple(H):
'''H is number of rows'''
ret = []
for _ in range(H):
ret.append(tuple(map(int, readline().split())))
return ret
def read_matrix(H):
'''H is number of rows'''
ret = []
for _ in range(H):
ret.append(list(map(int, readline().split())))
return ret
# return [list(map(int, read().split())) for _ in range(H)] # 内包表記はpypyでは遅いため
MOD = 10**9 + 7
INF = 2**31 # 2147483648 > 10**9
# default import
from collections import defaultdict, Counter, deque
from operator import itemgetter, xor, add
from itertools import product, permutations, combinations
from bisect import bisect_left, bisect_right # , insort_left, insort_right
from functools import reduce
from math import gcd
def lcm(a, b):
# 最小公倍数
g = gcd(a, b)
return a // g * b
N = a_int()
X = read()[:-1]
tmp = X.count('1') # Xの1の数
X = list(map(int, list(X[::-1])))
# オリジナルをpop(X)+-1で割ったものを作っておく
Xmodpop = [0, 0, 0]
for i, x in enumerate(X):
if x:
Xmodpop[1] += pow(2, i, tmp + 1)
if tmp != 1:
Xmodpop[-1] += pow(2, i, tmp - 1)
Xmodpop[1] %= tmp + 1
if tmp != 1:
Xmodpop[-1] %= tmp - 1
X_nex = [] # 一度操作したあとの値
for i in range(N):
if X[i] == 1:
if tmp == 1:
X_nex.append(-1)
continue
X_nex.append((Xmodpop[-1] - pow(2, i, tmp - 1)) % (tmp - 1))
else:
X_nex.append((Xmodpop[1] + pow(2, i, tmp + 1)) % (tmp + 1))
# 愚直に操作
ans = []
for i in range(N):
n = X_nex[i]
if n == -1:
ans.append(0)
continue
cnt = 1
while n:
popc = bin(n).count('1')
n %= popc
cnt += 1
ans.append(cnt)
print(*ans[::-1], sep='\n')
| N = int(input())
az = [chr(i) for i in range(97, 97+26)]
N = N - 1
tmp1 = 0
for i in range(1, 1000):
tmp1 += 26 ** i
if tmp1 > N:
num = i
tmp1 -= 26 ** i
N -= tmp1
break
tmp = [0 for _ in range(num)]
for i in range(num):
tmp[i] = N%26
N = N // 26
ans = ""
for i in range(len(tmp)):
ans = az[tmp[i]] + ans
print(ans) | 0 | null | 10,022,278,314,012 | 107 | 121 |
x=list(map(int,input().split()))
if x[0]>x[2]:
print(str(x[0]-x[2])+" "+str(x[1]))
elif x[0]+x[1]>x[2]:
print("0"+" "+str(x[0]+x[1]-x[2]))
else:
print("0"+" "+"0") | a,b,c=map(int, input().split())
if a==b and a!=c:
ans="Yes"
elif a==c and a!=b:
ans="Yes"
elif b==c and b!=a:
ans="Yes"
else:
ans="No"
print(ans)
| 0 | null | 86,446,596,428,292 | 249 | 216 |
r, c = map(int, input().split())
element = [list(map(int, input().split())) for i in range(r)]
for i in range(r):
element[i].append(sum(element[i]))
for i in range(r):
for j in range(c):
print(element[i][j],end="")
print(' ',end="")
print(element[i][c])
for i in range(c):
num = 0
for j in range(r):
num += element[j][i]
print(num, end="")
print(' ',end="")
b = 0
for i in range(r):
b += element[i][c]
print(b)
| n = int(input())
a = sorted([int(i) for i in input().split()])
cnt = 1
for ai in a:
cnt *= ai
if cnt > 10 ** 18:
print(-1)
exit()
print(cnt) | 0 | null | 8,805,637,014,210 | 59 | 134 |
currAndRot2FBLR = {
'N':{'N':'F','E':'R','S':'B','W':'L'},
'E':{'E':'F','S':'R','W':'B','N':'L'},
'S':{'S':'F','W':'R','N':'B','E':'L'},
'W':{'W':'F','N':'R','E':'B','S':'L'}
}
dice = {
'1': {'F':'2F', 'R':'4R', 'B':'5B', 'L':'3L'},
'2': {'F':'6F', 'R':'4F', 'B':'1F', 'L':'3F'},
'3': {'F':'6L', 'R':'2F', 'B':'1R', 'L':'5F'},
'4': {'F':'6R', 'R':'5F', 'B':'1L', 'L':'2F'},
'5': {'F':'6B', 'R':'3F', 'B':'1B', 'L':'4F'},
'6': {'F':'5B', 'R':'4L', 'B':'2F', 'L':'3R'}
}
faces = list(map(int, input().split()))
cmd = input()
## initial state
currNum = '1'
currDir = 'N'
for c in cmd:
numDir = dice[currNum][currAndRot2FBLR[currDir][c]]
currNum = numDir[0]
currFBLR = numDir[1]
currDir = {v:k for k,v in currAndRot2FBLR[currDir].items()}[currFBLR]
print(faces[int(currNum) - 1]) | #!/usr/bin/env python3
# encoding:utf-8
import copy
import random
import bisect #bisect_left これで二部探索の大小検索が行える
import fractions #最小公倍数などはこっち
import math
import sys
import collections
from decimal import Decimal # 10進数で考慮できる
mod = 10**9+7
sys.setrecursionlimit(mod) # 再帰回数上限はでdefault1000
d = collections.deque()
def LI(): return list(map(int, sys.stdin.readline().split()))
A = str(input())
B = str(input())
ans = [str(i) for i in range(1,4)]
ans.remove(A)
ans.remove(B)
print(ans[0])
| 0 | null | 55,339,355,415,012 | 33 | 254 |
def merge_sort(left, right):
if right-left > 1:
mid = (left + right) // 2
merge_sort(left, mid)
merge_sort(mid, right)
merge(left, mid, right)
def merge(left, mid, right):
left_part = S[left:mid]
right_part = S[mid:right]
left_part.append(inf)
right_part.append(inf)
l, r = 0, 0
for i in range(left, right):
if left_part[l] < right_part[r]:
S[i] = left_part[l]
l += 1
else:
S[i] = right_part[r]
r += 1
num[0] += right-left
if __name__ == "__main__":
num = [0]
inf = float('inf')
n = int(input())
S = list(map(int, input().split()))
merge_sort(0, n)
print(' '.join(list(map(str, S))))
print(num[0])
| a,b,c,k=[int(x) for x in input().split()]
ans=0
if a<=k:
ans+=a
k-=a
elif k>0:
ans+=k
k=0
if b<=k:
k-=b
elif k>0:
k=0
if k>0:
ans-=k
print(ans) | 0 | null | 10,872,566,020,520 | 26 | 148 |
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
A.sort()
def cmb(n, r, mod):
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % mod
mod = 10**9+7 # 出力の制限
g1 = [1, 1] # 元テーブル
g2 = [1, 1] # 逆元テーブル
inverse = [0, 1] # 逆元テーブル計算用テーブル
for i in range( 2, N + 1 ):
g1.append( ( g1[-1] * i ) % mod )
inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )
g2.append( (g2[-1] * inverse[-1]) % mod )
ans = 0
for i in range(N-K+1):
ans += A[-1-i]*cmb(N-1-i, K-1, mod)
ans %= mod
ans -= A[i]*cmb(N-1-i, K-1, mod)
ans %= mod
print(ans) |
class Combination:
def __init__(self, n_max, mod=10 ** 9 + 7):
# O(n_max + log(mod))
self.mod = mod
f = 1
self.fac = fac = [f]
for i in range(1, n_max + 1):
f = f * i % mod
fac.append(f)
f = pow(f, mod - 2, mod)
self.facinv = facinv = [f]
for i in range(n_max, 0, -1):
f = f * i % mod
facinv.append(f)
facinv.reverse()
# "n 要素" は区別できる n 要素
# "k グループ" はちょうど k グループ
def __call__(self, n, r): # self.C と同じ
return self.fac[n] * self.facinv[r] % self.mod * self.facinv[n - r] % self.mod
def nCr(self, n, r):
if not 0 <= r <= n:
return 0
return self.fac[n] * self.facinv[r] % self.mod * self.facinv[n - r] % self.mod
def resolve():
# 各集合Sのmax(S) - min(S)の合計を求める
# 各A[i]が最大値になる回数、最小値になる回数を求め、それを計算する
MOD = 10**9+7
N, K = map(int, input().split())
A = sorted(map(int, input().split()))
Comb = Combination(N)
ans = 0
for i in range(N):
# 最大値になる組み合わせは、A[j]: 0 < j < iからK - 1個を選ぶ組み合わせ
ans += Comb.nCr(i, K-1) * A[i] % MOD
ans %= MOD
# 最小値になる組み合わせは、A[j]: i < j < nからK-1個を選ぶ組み合わせ
ans -= Comb.nCr(N-i-1, K - 1) * A[i]% MOD
ans %= MOD
print(ans)
if __name__ == "__main__":
resolve()
| 1 | 95,759,346,400,752 | null | 242 | 242 |
T1, T2 = map(int, input().split())
A1, A2 = map(int, input().split())
B1, B2 = map(int, input().split())
diff1 = (A1 - B1) * T1
diff2 = (A2 - B2) * T2
if diff1 > 0:
diff1, diff2 = -1 * diff1, -1 * diff2
if diff1 + diff2 < 0:
print(0)
elif diff1 + diff2 == 0:
print('infinity')
else:
q, r = divmod(-diff1, diff1 + diff2)
print(2*q + (1 if r != 0 else 0)) | T = list(map(int, input().split()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
da, db = 0, 0
for i in range(2):
da += T[i] * A[i]
db += T[i] * B[i]
if da == db:
print("infinity")
exit()
x = (B[0] - A[0]) * T[0]
y = da - db
print(max(0, x // y * 2 + (0 if x % y == 0 else 1)))
| 1 | 131,365,079,123,570 | null | 269 | 269 |
from collections import defaultdict
(h,n),*ab = [list(map(int, s.split())) for s in open(0)]
mxa = max(a for a,b in ab)
dp = defaultdict(lambda: float('inf'))
dp[0] = 0
for i in range(1, h+mxa):
dp[i] = min(dp[i-a] + b for a,b in ab)
print(min(v for k,v in dp.items() if k>=h)) | h,n=map(int,input().split())
ab = [list(map(int,input().split())) for i in range(n)]
dp=[float('inf')]*(h+1)
dp[0]=0
for i in range(h):
for j in range(n):
next=i+ab[j][0] if i+ab[j][0]<=h else h
dp[next]=min(dp[next],dp[i]+ab[j][1])
print(dp[-1])
| 1 | 80,823,792,083,902 | null | 229 | 229 |
def main():
S = input()
if S == 'ARC':
print('ABC')
else:
print('ARC')
if __name__ == '__main__':
main() | s = input()
print('ARC' if s[1]=='B' else 'ABC')
| 1 | 24,240,591,317,740 | null | 153 | 153 |
class ModCombination:
"""
nCk (mod m)を扱うクラス
"""
def __init__(self, mod, n_max):
"""
イニシャライザ
予め 1~nの階乗と階乗の逆元を計算しておく
:param mod: 法
:param n_max: nの最大値(100,000で約1秒)
"""
self.mod = mod
self.n_max = n_max
self.facts = [1, 1]
self.inverses = [None, 1]
self.fact_inverses = [1, 1]
for i in range(2, self.n_max + 1):
self.facts.append(self.facts[i - 1] * i % self.mod)
# self.inverses.append(mod_inverse(i, self.mod))
self.inverses.append(
self.mod - self.inverses[self.mod % i] *
(self.mod // i) % self.mod
)
self.fact_inverses.append(
self.fact_inverses[i - 1] * self.inverses[i] % self.mod
)
def mod_combination(self, n, k):
"""
nCk (mod m)を計算する
:param n: n
:param k: k
:return: nCk (mod m)
"""
if k > n:
raise ValueError
elif k == n:
return 1
elif k == 0:
return 1
denominator = self.fact_inverses[k] * self.fact_inverses[n - k] % self.mod
return self.facts[n] * denominator % self.mod
def mod_pow(a, n, mod):
"""
二分累乗法による a^n (mod m)の実装
:param a: 累乗の底
:param n: 累乗の指数
:param mod: 法
:return: a^n (mod m)
"""
result = 1
a_n = a
while n > 0:
if n & 1:
result = result * a_n % mod
a_n = a_n * a_n % mod
n >>= 1
return result
MOD = 10 ** 9 + 7
K = int(input())
S = input()
n = len(S)
comb = ModCombination(mod=MOD, n_max=n + K)
ans = 0
for i in range(K + 1):
ans += (mod_pow(25, i, MOD) * comb.mod_combination(i + n - 1, n - 1)) % MOD * mod_pow(26, K - i, MOD)
ans %= MOD
print(ans)
| def main():
k = int(input())
s = input()
n = len(s)
def cmb1(n, r, mod):
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % mod
mod = 10**9+7
N = 2*10**6
fac = [1]*(N+1)
finv = [1]*(N+1)
for i in range(N):
fac[i+1] = fac[i] * (i+1) % mod
finv[-1] = pow(fac[-1], mod-2, mod)
for i in reversed(range(N)):
finv[i] = finv[i+1] * (i+1) % mod
def cmb1(n, r, mod):
if r <0 or r > n:
return 0
r = min(r, n-r)
return fac[n] * finv[r] * finv[n-r] % mod
def power(a, n, mod):
bi=str(format(n,"b")) #2進数
res=1
for i in range(len(bi)):
res=(res*res) %mod
if bi[i]=="1":
res=(res*a) %mod
return res
ans = 0
for i in range(k+1):
temp = power(25, i, mod)
temp *= cmb1(i+n-1, n-1, mod)
temp %= mod
temp *= power(26, k-i, mod)
temp %= mod
ans += temp
print(ans%mod)
if __name__ == '__main__':
main()
| 1 | 12,774,467,035,700 | null | 124 | 124 |
def main():
N,R=map(int,input().split())
if(N<10):
inner=R+100*(10-N)
else:
inner=R
print(inner)
if __name__ == '__main__':
main() | def resolve():
n, r = list(map(int, input().split()))
if n > 10:
ans = r
else:
ans = r + 100 * (10 - n)
print(ans)
resolve() | 1 | 63,490,288,289,538 | null | 211 | 211 |
def registration():
S = input()
T = input()
for i, j in enumerate(S):
if T[i] != j:
break
else:
print("Yes")
return
print("No")
registration() | import math
x1, y1, x2, y2 = map(float, input().split())
print(f'{math.sqrt((x2-x1)**2+(y2-y1)**2):.8f}')
| 0 | null | 10,866,311,029,700 | 147 | 29 |
import sys
n,m=map(int,input().split())
if n==3:
ans=["1","0","0"]
elif n==2:
ans=["1","0"]
else:
ans=["0"]
cnt=[0,0,0]
for i in range(m):
s,c=map(int,input().split())
if s==1 and c==0 and n!=1:
print(-1)
sys.exit()
elif ans[s-1]!=str(c):
if cnt[s-1]==0:
ans[s-1]=str(c)
cnt[s-1]=1
else:
print(-1)
sys.exit()
print("".join(ans))
| n,m=map(int,input().split())
sc=[list(map(int,input().split())) for _ in range(m)]
for x in range(1000):
sx=str(x)
if n!=len(sx):
continue
for s,c in sc:
if sx[s-1]!=str(c):
break
else:
print(x)
exit(0)
print(-1) | 1 | 60,897,738,811,582 | null | 208 | 208 |
import sys
sys.setrecursionlimit(10**9)
def main():
N,M,K = map(int,input().split())
MOD = 998244353
def get_fact(maxim,mod):
maxim += 1
fact = [0]*maxim
fact[0] = 1
for i in range(1,maxim):
fact[i] = fact[i-1] * i % mod
invfact = [0]*maxim
invfact[maxim-1] = pow(fact[maxim-1],mod-2,mod)
for i in reversed(range(maxim-1)):
invfact[i] = invfact[i+1] * (i+1) % mod
return fact, invfact
def powerful_comb(n,r,mod,fact,invfact):
return fact[n] * invfact[r] * invfact[n-r] % mod
ans = 0
fact, invfact = get_fact(N+1,MOD)
for i in range(K+1):
ans += (M*pow(M-1,N-i-1,MOD) * powerful_comb(N-1,i,MOD,fact,invfact)) % MOD
print(ans % MOD)
if __name__ == "__main__":
main() | import numpy as np
N, M, K = [int(_) for _ in input().split()]
mod = 998244353
class Factorial:
def __init__(self, max_fact, mod):
#mod should be prime number
#using homogeneous_product(n,r), max_fact ≧ max(n+r-1)
f = [1] * (max_fact + 1)
for idx in range(2, max_fact + 1):
f[idx] = f[idx - 1] * idx
f[idx] %= mod
if mod > max_fact:
fi = [pow(f[-1], mod - 2, mod)]
for idx in range(max_fact, 0, -1):
fi += [fi[-1] * idx % mod]
fi = fi[::-1]
else:
fi = [pow(n, mod - 2, mod) for n in f]
self.mod = mod
self.f = f
self.fi = fi
def factorial(self, n):
return self.f[n]
def factorial_inverse(self, n):
return self.fi[n]
def combination(self, n, r):
f = self.f
fi = self.fi
return f[n] * fi[r] * fi[n - r] % self.mod
def permutation(self, n, r):
return self.f[n] * self.fi[n - r] % self.mod
def homogeneous_product(self, n, r):
f = self.f
fi = self.fi
return f[n + r - 1] * fi[r] * fi[n - 1] % self.mod
max_fact = N
fact_instance = Factorial(max_fact, mod)
comb = fact_instance.combination
ans = 0
for r in range(K + 1):
ans += comb(N - 1, r) * M * pow(M - 1, N - r - 1, mod)
ans %= mod
print(ans)
| 1 | 23,089,430,301,404 | null | 151 | 151 |
#!/usr/bin/env python
# coding: utf-8
# In[7]:
H,W = map(int, input().split())
s_mat = []
for _ in range(H):
s_mat.append(input())
# In[32]:
dp = [[1000 for i in range(W+1)] for j in range(H+1)]
dp[0][1] = 0
dp[1][0] = 1
for h in range(H):
for w in range(W):
dp[h+1][w+1] = min(
dp[h][w+1] + (s_mat[h][w] == "#" and (h==0 or s_mat[h-1][w] == ".")),
dp[h+1][w] + (s_mat[h][w] == "#" and (w==0 or s_mat[h][w-1] == "."))
)
print(dp[-1][-1])
# In[ ]:
| import sys, math
input = sys.stdin.readline
rs = lambda: input().strip()
ri = lambda: int(input())
rl = lambda: list(map(int, input().split()))
mod = 10**9 + 7
N = ri()
print(math.ceil(N / 2) / N)
| 0 | null | 112,900,702,933,508 | 194 | 297 |
n, a, b = map(int,input().split())
M = 10**9+7
Answer = pow(2,n,M)-1
factorial=1
for i in range(1,a+1):
factorial = (factorial*(n+1-i)*pow(i,M-2,M))%M
Answer -= factorial%M
factorial =1
for j in range(1,b+1):
factorial = (factorial*(n+1-j)*pow(j,M-2,M))%M
Answer -= factorial%M
Answer = Answer%M
print(Answer) | N ,a, b = map(int,input().split())
MOD = pow(10,9) + 7
A = 1
for i in range(a):
A = A*(N-i)*pow(i+1,MOD-2,MOD)%MOD
B = 1
for i in range(b):
B = B*(N-i)*pow(i+1,MOD-2,MOD)%MOD
alll = pow(2,N,MOD) -1
#nota = cmb(N,a,MOD)
#notb = cmb(N,b,MOD)
ans = alll - (A+B)
ans = ans%MOD
print(ans) | 1 | 66,161,763,805,542 | null | 214 | 214 |
def solve():
K, X = map(int, input().split())
return "Yes" if K*500 >= X else "No"
print(solve()) | n = int(input())
testimonies = [[] for i in range(n)]
for idx1 in range(n):
count = int(input())
for idx2 in range(count):
x,y = map(int, input().split())
testimonies[idx1].append((x-1, y))
output = 0
for combination in range(2 ** n):
consistent = True
for index in range(n):
if (combination >> index) & 1 == 0:
continue
for x,y in testimonies[index]:
if (combination >> x) & 1 != y:
consistent = False
break
if not consistent:
break
if consistent:
output = max(output, bin(combination)[2:].count("1"))
print(output) | 0 | null | 109,842,570,637,712 | 244 | 262 |
import numpy as np
from fractions import gcd
N=int(input())
A=list(map(int, input().split()))
p=10**9+7
n = 10 ** 6 # N は必要分だけ用意する
#fact = [1, 1] # fact[n] = (n! mod p)
#factinv = [1, 1] # factinv[n] = ((n!)^(-1) mod p)
inv = [0, 1] # factinv 計算用 逆元
"""
for i in range(2, n + 1):
#fact.append((fact[-1] * i) % p)
inv.append((-inv[p % i] * (p // i)) % p)
#factinv.append((factinv[-1] * inv[-1]) % p)
#a//gcd(a,b)*b
"""
def lcm(a,b):
g=gcd(a,b)
#return ((a*b)*pow(g,p-2,p))%p
return a//gcd(a,b)*b
LCM=1
for x in A:
LCM=lcm(LCM,x)
#print(LCM)
ans=0
LCM%=p
for i in range(N):
#ans+=(LCM*inv[A[i]])%p
ans+=(LCM*pow(A[i],p-2,p))%p
ans%=p
print(ans) | import sys
import math
import fractions
from collections import defaultdict
from functools import reduce
import collections
stdin = sys.stdin
ns = lambda: stdin.readline().rstrip()
ni = lambda: int(stdin.readline().rstrip())
nm = lambda: map(int, stdin.readline().split())
nl = lambda: list(map(int, stdin.readline().split()))
INF=10**18
mod=10**9+7
N=int(input())
A=nl()
NMAX=10**6
class Sieve:
def __init__(self,n):
self.n=n
self.f=[0]*(n+1)
self.prime=[]
self.f[0]=self.f[1]=-1
for i in range(2,n+1):
if(self.f[i]):
continue
else:
self.prime.append(i)
self.f[i]=i
for j in range(i*i,n+1,i):
if(~self.f[j]):
self.f[j]=i
def isProme(self,x):
return (self.f[x]==x)
def factorList(self,x):
res=[]
while(x!=1):
res.append(self.f[x])
x//=self.f[x]
return res
def factor(self,x):
fl=self.factorList(x)
return collections.Counter(fl)
def get_sieve_of_eratosthenes(n):
prime = [2]
limit = int(n**0.5)
data = [i + 1 for i in range(2, n, 2)]
while True:
p = data[0]
if limit <= p:
return prime + data
prime.append(p)
data = [e for e in data if e % p != 0]
sieve=Sieve(10**6)
mp=defaultdict(int)
for i in range(N):
f=sieve.factor(A[i])
for key,val in f.items():
mp[key]=max(val,mp[key])
lcm=1
for key,val in mp.items():
lcm*=(key**val)
ans=0
for i in range(N):
ans+=lcm//A[i]
print(ans%mod) | 1 | 87,698,533,577,188 | null | 235 | 235 |
N = int(input())
ans = ''
while True:
n = int(N / 26)
r = N % 26
if r == 0:
r = 26
n -= 1
ans = chr(96 + r) + ans
if n == 0:
break
else:
N = n
print(ans) | N=int(input())
c=-(-N//2)-1
print(c) | 0 | null | 82,212,658,935,110 | 121 | 283 |
n = int(input())
print(input().count("ABC")) | N = int(input())
s = list(input())
cnt = 0
for i in range(N-2):
if s[i] == 'A':
if s[i+1] == 'B':
if s[i+2] == 'C':
cnt += 1
print(cnt) | 1 | 99,400,342,558,836 | null | 245 | 245 |
S = list(input())
K = int(input())
ans = 0
#２つ並べて一般性を確かめる
S2 = S*2
for i in range(1,len(S2)):
if S2[i-1]== S2[i]:
S2[i] = '@'
#2回目以降はk-1回任意の@へ直す
if i>=len(S2)//2:
ans+= K-1
else:
ans+=1
if len(set(S)) ==1 and len(S)%2 !=0:
ans = len(S)*(K//2)+(K%2==1)*(len(S)//2)
print(ans) | n = int(input())
a = [int(i) for i in input().split()]
color = [0, 0, 0]
ans = 1
mod = 10 ** 9 + 7
for i in a:
cnt = color.count(i)
ans *= cnt
ans = ans % mod
if ans > 0:
color[color.index(i)] += 1
else:
break
print(ans) | 0 | null | 152,863,601,960,270 | 296 | 268 |
t,T,a,A,b,B=map(int, open(0).read().split())
x,y=(a-b)*t,(A-B)*T
if x+y==0:
r="infinity"
else:
s,t=divmod(-x, x+y)
r=0 if s<0 else s*2+(1 if t else 0)
print(r) | import sys
def MI(): return map(int,sys.stdin.readline().rstrip().split())
N,u,v = MI()
Graph = [[] for _ in range(N+1)]
for i in range(N-1):
a,b = MI()
Graph[a].append(b)
Graph[b].append(a)
dist_T = [-1]*(N+1) # uからの最短距離
dist_A = [-1]*(N+1) # vからの最短距離
dist_T[u] = 0
dist_A[v] = 0
from collections import deque
q1 = deque([u])
q2 = deque([v])
while q1:
n = q1.pop()
for d in Graph[n]:
if dist_T[d] == -1:
dist_T[d] = dist_T[n] + 1
q1.appendleft(d)
while q2:
n = q2.pop()
for d in Graph[n]:
if dist_A[d] == -1:
dist_A[d] = dist_A[n] + 1
q2.appendleft(d)
ans = 0
for i in range(1,N+1):
if dist_T[i] < dist_A[i]:
ans = max(ans,dist_A[i]-1)
print(ans)
| 0 | null | 124,101,997,265,158 | 269 | 259 |
x = int(input())
l = [i**5 for i in range(1000)]
for i in range(len(l)-1):
for j in range(i+1,len(l)):
if l[j]-l[i]==x:
print(int(l[j]**(1/5)),int(l[i]**(1/5)))
exit()
if l[j]+l[i]==x:
print(int(l[j]**(1/5)),-int(l[i]**(1/5)))
exit()
print('Not found') | import sys
input = sys.stdin.readline
X = int(input())
A = 1
B = 0
while True:
while A**5 - B**5 < X:
B -= 1
if A**5 - B**5 == X:
print(A,B)
exit()
B = A
A += 1 | 1 | 25,600,127,138,560 | null | 156 | 156 |
i=input;print(['NO','YES'][int(i())==len(set(i().split()))]) | N = int(input())
L = list(map(int, input().split()))
ans = 0
for i in range(N):
for j in range(i+1, N):
for k in range(j+1, N):
a = sorted([L[i], L[j], L[k]])
if a[0] == a[1] or a[1] == a[2] or a[2] == a[0]:
continue
if a[0] + a[1] > a[2]:
ans += 1
print(ans) | 0 | null | 39,465,922,799,460 | 222 | 91 |
n,k=map(int,input().split())
a=list(map(int,input().split()))
f=list(map(int,input().split()))
a.sort()
f.sort(reverse=True)
ok=10**15
ng=-1
while ok-ng>1:
check=(ok+ng)//2
cnt=0
for i in range(n):
cnt+=(max(0,a[i]-check//f[i]))
if cnt > k:ng = (ok+ng)//2
else: ok = (ok+ng)//2
print(ok) | cnt = int(input())
string = input()
if len(string) <= cnt:
print(string)
else:
print(string[:cnt] + "...") | 0 | null | 92,093,084,168,692 | 290 | 143 |
import sys
def input():
return sys.stdin.readline().strip()
def main():
N = int(input())
C = [[0] * 10 for _ in range(10)]
for i in range(10):
for j in range(10):
for n in range(1, N + 1):
L = len(str(n)) - 1
a = n // (10 ** L)
b = n % 10
if a == i and b == j:
C[i][j] += 1
answer = 0
for i in range(10):
for j in range(10):
answer += C[i][j] * C[j][i]
print(answer)
if __name__ == "__main__":
main()
| word = input()
n = len(word)
hanbun = int((n-1)/2)
notk = 0
for i in range(hanbun):
if word[i] != word[n-i-1]:
notk = 1
break
if hanbun % 2 == 0:
hanbun2 = int(hanbun/2)
else:
hanbun2 = int((hanbun-1)/2)
for j in range(hanbun2):
if word[j] != word[hanbun-j-1]:
notk = 1
break
if notk == 1:
print('No')
else:
print('Yes') | 0 | null | 66,286,394,745,132 | 234 | 190 |
x = int(input())
ans = 0
m = 100
while m < x:
m += m // 100
ans += 1
print(ans)
| def main():
import sys
readline = sys.stdin.buffer.readline
import math
import itertools
n = int(readline())
xy = [list(map(int, readline().split())) for _ in range(n)]
c = list(itertools.combinations(range(n), 2))
ans = 0
for a, b in c:
ans += ((xy[a][0] - xy[b][0])**2 + (xy[a][1] - xy[b][1])**2)**(1/2)
print(ans*2*math.factorial(n-1)/math.factorial(n))
if __name__ == '__main__':
main() | 0 | null | 87,407,227,084,360 | 159 | 280 |
n=input()
a=list(map(int, input().split()))
print(min(a),max(a),sum(a),sep = ' ')
| k=raw_input().split()
k=raw_input().split()
k.sort()
for i in range(len(k)):
k[i]=int(k[i])
k.sort()
print min(k),
print max(k),
print sum(k) | 1 | 730,168,338,890 | null | 48 | 48 |
# -*- coding: utf-8 -*-
import sys
import os
lst = input().split()
stack = []
for c in lst:
if c == '+':
a = stack.pop()
b = stack.pop()
stack.append(b + a)
elif c == '-':
a = stack.pop()
b = stack.pop()
stack.append(b - a)
elif c == '*':
a = stack.pop()
b = stack.pop()
stack.append(b * a)
else:
stack.append(int(c))
print(stack[0]) | import math
a,b,C=map(float,input().split())
S = a*b*math.sin(C*math.pi/180)/2
c = math.sqrt(a**2 + b**2 - 2*a*b*math.cos(C*math.pi/180))
h = 2*S/a
print("{:10f}".format(S))
print("{:10f}".format(a+b+c))
print("{:10f}".format(h))
| 0 | null | 108,203,445,140 | 18 | 30 |
import string
a = raw_input()
b = ""
for i in range(len(a)):
if a[i] in string.ascii_lowercase :
b = b + a[i].upper()
elif a[i] in string.ascii_uppercase :
b = b + a[i].lower()
else :
b = b + a[i]
print b | N = int(input())
s = -( - N // 2 )
print(s) | 0 | null | 30,127,163,844,630 | 61 | 206 |
import itertools
N, K = [int(_) for _ in input().split()]
A = [int(_) for _ in input().split()]
for _ in range(K):
cumsum = [0] * (N + 2)
for i, a in enumerate(A):
i += 1
cumsum[max(0, i - a)] += 1
cumsum[min(i + a + 1, N + 1)] -= 1
A = list(itertools.accumulate(cumsum))[1:N + 1]
if min(A) == N:
break
print(' '.join(map(str, A)))
| #!/usr/bin/env python3
l = int(input())
q = l / 3
print(q ** 3)
| 0 | null | 31,065,492,378,242 | 132 | 191 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.