code1
stringlengths 16
24.5k
| code2
stringlengths 16
24.5k
| similar
int64 0
1
| pair_id
int64 2
181,637B
⌀ | question_pair_id
float64 3.71M
180,628B
⌀ | code1_group
int64 1
299
| code2_group
int64 1
299
|
|---|---|---|---|---|---|---|
N, K = map(int, input().split())
R, S, P = map(int, input().split())
T = list(input())
import numpy as np
#0: g, R
#1: c, S
#2: p, P
ans = 0
L = [[] for _ in range(K)]
for i in range(K):
L[i] = T[i:N:K]
for l in L:
# print()
# print(l)
lenl = len(l)
Dp = np.zeros([lenl+1, 3], dtype=int)
Dp[:][:] = -1
Dp[0][:] = 0
# print(Dp)
ll = l[0]
if ll == 'r':
Dp[1][0] = 0
Dp[1][1] = 0
Dp[1][2] = P
elif ll == 's':
Dp[1][0] = R
Dp[1][1] = 0
Dp[1][2] = 0
elif ll == 'p':
Dp[1][0] = 0
Dp[1][1] = S
Dp[1][2] = 0
for i in range(1, lenl):
ll = l[i]
if ll == 'r':
Dp[i+1][0] = max(Dp[i][1], Dp[i][2])
Dp[i+1][1] = max(Dp[i][2], Dp[i][0])
Dp[i+1][2] = max(Dp[i][0], Dp[i][1]) + P
elif ll == 's':
Dp[i+1][0] = max(Dp[i][1], Dp[i][2]) + R
Dp[i+1][1] = max(Dp[i][2], Dp[i][0])
Dp[i+1][2] = max(Dp[i][0], Dp[i][1])
elif ll == 'p':
Dp[i+1][0] = max(Dp[i][1], Dp[i][2])
Dp[i+1][1] = max(Dp[i][2], Dp[i][0]) + S
Dp[i+1][2] = max(Dp[i][0], Dp[i][1])
# print(Dp)
ans += max(Dp[-1][:])
print(ans) | N, K = list(map(int, input().split()))
pt = list(map(int, input().split()))
T = input()
pc_hand = [0]*N
my_hand = [0]*N
for i in range(N):
if T[i] == 'r':
pc_hand[i] = 0
elif T[i] == 's':
pc_hand[i] = 1
else:
pc_hand[i] = 2
point = 0
for i in range(N):
if i >= K and T[i] == T[i - K] and (my_hand[i - K] + 1) % 3 == pc_hand[i - K]:
my_hand[i] = pc_hand[i]
else:
my_hand[i] = (pc_hand[i] - 1) % 3
point += pt[my_hand[i]]
print(point) | 1 | 106,973,610,914,870 | null | 251 | 251 |
s = input()*2
print('Yes' if input() in s else 'No') | s=input()
p=input()
s=s+s
if s.find(p)==-1:
print('No')
else:
print('Yes')
| 1 | 1,734,689,350,000 | null | 64 | 64 |
n = int(input())
if n%2 == 0:
ans = n//2-1
else:
ans = n//2
print(ans) | N = int(input())
if N%2:
N += 1
print(N//2-1) | 1 | 152,617,347,273,228 | null | 283 | 283 |
T1, T2, A1, A2, B1, B2 = map(int, open(0).read().split())
P = (A1-B1)*T1
Q = (A2-B2)*T2
if P>0:
P *= -1
Q *= -1
if P+Q<0:
print(0)
elif P+Q==0:
print('infinity')
else:
S,T = divmod(-P,P+Q)
if T!=0:
print(S*2+1)
else:
print(S*2) |
#!/usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
from bisect import bisect_left, bisect_right
import sys, random, itertools, math
sys.setrecursionlimit(10**5)
input = sys.stdin.readline
sqrt = math.sqrt
def LI(): return list(map(int, input().split()))
def LF(): return list(map(float, input().split()))
def LI_(): return list(map(lambda x: int(x)-1, input().split()))
def II(): return int(input())
def IF(): return float(input())
def LS(): return list(map(list, input().split()))
def S(): return list(input().rstrip())
def IR(n): return [II() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def FR(n): return [IF() for _ in range(n)]
def LFR(n): return [LI() for _ in range(n)]
def LIR_(n): return [LI_() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
mod = 1000000007
inf = float('INF')
#solve
def solve():
t1, t2 = LI()
a1, a2 = LI()
b1, b2 = LI()
if t1 * a1 + t2 * a2 == t1 * b1 + t2 * b2:
print("infinity")
return
if t1 * a1 > t1 * b1:
if t1 * a1 + t2 * a2 > t1 * b1 + t2 * b2:
print(0)
return
else:
x = t1 * (a1 - b1) / (-t1 * (a1 - b1) + t2 * (b2 - a2))
if x.is_integer():
print(2 * (t1 * (a1 - b1) // (-t1 * (a1 - b1) + t2 * (b2 - a2))))
else:
print(2 * (t1 * (a1 - b1) // (-t1 * (a1 - b1) + t2 * (b2 - a2))) + 1)
return
elif t1 * a1 < t1 * b1:
if t1 * a1 + t2 * a2 < t1 * b1 + t2 * b2:
print(0)
return
else:
x = t1 * (b1 - a1) / (-t1 * (b1 - a1) + t2 * (a2 - b2))
if x.is_integer():
print(2 * (t1 * (b1 - a1) // (-t1 * (b1 - a1) + t2 * (a2 - b2))))
else:
print(2 * (t1 * (b1 - a1) // (-t1 * (b1 - a1) + t2 * (a2 - b2))) + 1)
return
return
#main
if __name__ == '__main__':
solve()
| 1 | 131,047,963,914,670 | null | 269 | 269 |
n,x, m = map(int, input().split())
mod = [None for _ in range(m)]
count = x
loop = []
rem = [x]
for i in range(1, n):
value = (x * x) % m
rem.append(value)
x = (x * x) % m
if mod[value] != None:
# print(mod)
s_index = mod[value]
loop = rem[s_index : -1]
num = (n - s_index) // len(loop)
amari = (n - s_index) % len(loop)
if amari == 0:
print(sum(rem[:s_index]) + sum(loop) * num)
else:
print(sum(rem[:s_index]) + sum(loop) * num + sum(loop[:amari]))
exit()
else:
mod[value] = i
count += value
print(count)
| def f(x, m):
return x * x % m
def main():
N, X, M = map(int, input().split())
pre = set()
pre.add(X)
cnt = 1
while cnt < N:
X = f(X, M)
if X in pre: break
cnt += 1
pre.add(X)
if cnt == N:
return sum(pre)
ans = sum(pre)
N -= cnt
loop = set()
loop.add(X)
while cnt < N:
X = f(X, M)
if X in loop: break
loop.add(X)
left = N % len(loop)
ans += sum(loop) * (N // len(loop))
for i in range(left):
ans += X
X = f(X, M)
return ans
print(main())
| 1 | 2,822,368,412,920 | null | 75 | 75 |
import math
a,b,c=[int(i) for i in input().split()]
e=math.ceil(a/c)
if(e<=b):
print('Yes')
else:
print('No') | #!/usr/bin/env python3
e, o = map(int, input().split())
print(e*(e-1)//2 + o*(o-1)//2) | 0 | null | 24,494,009,335,862 | 81 | 189 |
K = int(input())
A,B = list(map(int,input().split()))
flag=False
for i in range(A,B+1):
if i%K == 0:
flag=True
print("OK" if flag else "NG")
| n, m, l = map(int, raw_input().split())
A = [map(int, raw_input().split()) for i in xrange(n)]
B = [map(int, raw_input().split()) for i in xrange(m)]
C = [[0] * l for i in xrange(n)]
for i in xrange(n):
for j in xrange(l):
C[i][j] = sum(A[i][k] * B[k][j] for k in xrange(m))
for c in C:
print " ".join(map(str, c)) | 0 | null | 14,061,145,955,188 | 158 | 60 |
n = int(input())
cnt = [[0] * 10 for i in range(10)]
for i in range(n+1):
a = int(str(i)[0])
b = int(str(i)[-1])
if a == 0 or b == 0:
continue
cnt[a][b] += 1
ans = 0
for i in range(n+1):
a = int(str(i)[0])
b = int(str(i)[-1])
ans += cnt[b][a]
print(ans) | N=int(input())
D={(x//10,x%10):0 for x in range(100)}
for i in range(1,N+1):
if i<10:
D[(i,i)]=1
else:
Q=int(str(i)[0])
R=i%10
D[(Q,R)]+=1
S=0
for x in range(1,10):
for y in range(1,10):
S+=D[(x,y)]*D[(y,x)]
print(S)
| 1 | 86,621,090,456,268 | null | 234 | 234 |
N= int(input())
a = [0]*110000
if N == 2:
print(2)
else:
for i in range(2,N):
k = i
j = 2
while k<110000:
a[k]+=1
k = int((k/(j-1))*j)
j+=1
for i in range(N,110001):
if a[i]>0:
continue
elif a[i]==0:
print(i)
break | class Combination:
def __init__(self, n_max, mod=10**9+7):
self.mod = mod
self.modinv = self.make_modinv_list(n_max)
self.fac, self.facinv = self.make_factorial_list(n_max)
def __call__(self, n, r):
return self.fac[n] * self.facinv[r] % self.mod * self.facinv[n-r] % self.mod
def make_factorial_list(self, n):
# 階乗のリストと階乗のmod逆元のリストを返す O(n)
# self.make_modinv_list()が先に実行されている必要がある
fac = [1]
facinv = [1]
for i in range(1, n+1):
fac.append(fac[i-1] * i % self.mod)
facinv.append(facinv[i-1] * self.modinv[i] % self.mod)
return fac, facinv
def make_modinv_list(self, n):
# 0からnまでのmod逆元のリストを返す O(n)
modinv = [0] * (n+1)
modinv[1] = 1
for i in range(2, n+1):
modinv[i] = self.mod - self.mod//i * modinv[self.mod%i] % self.mod
return modinv
if __name__ == "__main__":
N, M, K = map(int, input().split())
MOD = 998244353
ans = 0
comb = Combination(1000000, MOD)
for i in range(K+1):
ans += M * pow(M-1, N-i-1, MOD) * comb(N-1, i)
ans %= MOD
print(ans)
| 0 | null | 64,327,462,022,408 | 250 | 151 |
n, k = map(int, input().split())
p = list(map(int, input().split()))
#logging.debug("デバッグスタート") #
l = [[] for i in range(n)]#期待値
m = [[] for i in range(n - k + 1)] #k個の合計
for i in range(n):
l[i] = (1 + p[i]) / 2
#logging.debug("l = {}".format(l))#
m[0] = sum(l[0:k])
ans = m[0]
for i in range(1, n - k + 1):
#logging.debug("m[i-1] = {} ,l[i-1] = {} ,l[i+k] = {}".format(m[i - 1], l[i - 1], l[i + k - 1])) #
m[i] = m[i - 1] - l[i - 1] + l[i + k - 1]
if m[i] > ans:
ans = m[i]
#logging.debug(m)#
print(ans) | def n_cand(x):
return int(x*1.08)
n = int(input())
x = round(n / 1.08)
n_dash = n_cand(x)
n_dash_m = n_cand(x-1)
n_dash_p = n_cand(x+1)
if n_dash == n:
print(x)
elif n_dash_m == n:
print(x-1)
elif n_dash_p == n:
print(x+1)
else:
print(':(') | 0 | null | 99,962,721,969,340 | 223 | 265 |
#!/usr/bin/env python3
import sys
import collections as cl
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def main():
x, y, a, b, c = MI()
p = LI()
q = LI()
r = LI()
p.sort(reverse=True)
q.sort(reverse=True)
r.sort(reverse=True)
p_selected = p[:x]
q_selected = q[:y]
ans = [*p_selected, *q_selected]
ans.sort()
i = 0
while i < x + y and i < c and ans[i] < r[i]:
ans[i] = r[i]
i += 1
print(sum(ans))
main()
| import math
A, B = map(int, input().split(' '))
print(A * B // (math.gcd(A, B))) | 0 | null | 79,360,818,198,090 | 188 | 256 |
from bisect import bisect
N = int(input())
S = [input() for _ in range(N)]
def count(s):
n = len(s)
n1 = 0
n2 = 0
for i in range(n):
if s[i]=='(':
n2 += 1
else:
if n2 > 0:
n2 -= 1
else:
n1 += 1
return n1,n2
l1 = []
l2 = []
m1 = 0
m2 = 0
for i in range(N):
n1,n2 = count(S[i])
if n1+n2==0:
continue
if n1 == 0:
m1 += n2
continue
if n2 == 0:
m2 += n1
continue
if n2-n1>=0:
l1.append([n1,n2])
else:
l2.append([n1,n2])
ans = 'Yes'
l1.sort()
for i in range(len(l1)):
n1,n2 = l1[i]
if m1 < n1:
ans = 'No'
break
m1 += n2-n1
l2.sort(key=lambda x:x[1])
for i in range(len(l2)):
n1,n2 = l2[i]
if m2 < n2:
ans = 'No'
break
m2 += n1-n2
if m1!=m2:
ans = 'No'
print(ans)
| import bisect
def resolve():
n = int(input())
l = sorted(list(map(int,input().split())))
ans = 0
for a in range(n):
for b in range(a+1,n):
c = bisect.bisect_left(l,l[a]+l[b])
if c > b:
ans += c-b-1
else:
pass
print(ans)
resolve() | 0 | null | 97,426,742,500,320 | 152 | 294 |
s=list(input())
t=list(input())
count = 0
for i,w in enumerate(s):
if w != t[i]:
count += 1
print(count) | def maximum():
A,B,C,K = map(int,input().split())
num = 0
max = 0
if A <= K:
max = A
num = K - A
if B <= num:
num = num - B
max -= num
print(max)
return
else:
print(max)
return
else:
print(K)
return
maximum()
| 0 | null | 16,054,531,227,440 | 116 | 148 |
import random
S=input()
r = random.randint(0,len(S)-3)
result =""
result = S[r]+S[r+1]+S[r+2]
print(result)
| from collections import deque
from heapq import heapify,heappop,heappush,heappushpop
from copy import copy,deepcopy
from itertools import permutations,combinations
from collections import defaultdict,Counter
# from math import gcd,ceil,floor,factorial
# from fractions import gcd
from functools import reduce
from pprint import pprint
def myinput():
return map(int,input().split())
def mylistinput(n):
return [ list(myinput()) for _ in range(n) ]
def mycol(data,col):
return [ row[col] for row in data ]
def mysort(data,col,reverse_flag):
data.sort(key=lambda x:x[col],reverse=reverse_flag)
return data
def mymax(data):
M = -1*float("inf")
for i in range(len(data)):
m = max(data[i])
M = max(M,m)
return M
def mymin(data):
m = float("inf")
for i in range(len(data)):
M = min(data[i])
m = min(m,M)
return m
def myoutput(ls,space=True):
if space:
if len(ls)==0:
print(" ")
elif type(ls[0])==str:
print(" ".join(ls))
elif type(ls[0])==int:
print(" ".join(map(str,ls)))
else:
print("Output Error")
else:
if len(ls)==0:
print("")
elif type(ls[0])==str:
print("".join(ls))
elif type(ls[0])==int:
print("".join(map(str,ls)))
else:
print("Output Error")
n = int(input())
a = list(myinput())
ls = []
for i in range(n):
ls.append([ i,a[i] ])
ls = mysort(ls,1,True)
# print(ls)
dp = [ [0]*(n+1) for _ in range(n+1) ]
# dp[i][l]: Aが大きい方からi番目まで決め，左へ移動した個数がl個である時の，スコアの最大値
for i in range(n):
f = ls[i][0]
A = ls[i][1]
for l in range(i+1):
#
# 【このi番目を右へ寄せる場合（左へ寄せない場合）】
# 移動先t
t = n - i + l - 1
# スコア
s = A*abs(t-f)
# dpテーブルの要素としての更新候補
dp1 = dp[i][l] + s
# 既に入っている値より大きければ更新
if dp1 > dp[i+1][l]:
dp[i+1][l] = dp1
#
# 【このi番目を左へ寄せる場合】
# 移動先t
t = l
# スコア
s = A*abs(t-f)
# dpテーブルの要素としての更新候補
dp2 = dp[i][l] + s
#
# 既に入っている値より大きければ更新
if dp2 > dp[i+1][l+1]:
dp[i+1][l+1] = dp2
# pprint(dp)
print(max(dp[n])) | 0 | null | 24,273,684,042,838 | 130 | 171 |
import sys
input = sys.stdin.readline
INF = float('inf')
def main():
S, T = map(str, input().split())
print(T + S)
if __name__ == '__main__':
main()
| import fileinput
s, t = input().split()
print(t + s) | 1 | 103,145,243,059,320 | null | 248 | 248 |
S = input()
T = input()
n = 0
for s, t in zip(S, T):
if s != t:
n += 1
print(n)
exit()
| s = input()
t = input()
ans = 0
for cs, ct in zip(s, t):
if cs != ct:
ans += 1
print(ans) | 1 | 10,513,366,758,700 | null | 116 | 116 |
import re
W = input()
T = []
count = 0
while(1):
line = input()
if (line == "END_OF_TEXT"):
break
words = list(line.split())
for word in words:
T.append(word)
for word in T:
matchOB = re.fullmatch(W, word.lower())
if matchOB:
count += 1
print(count) | w = input().casefold()
c = 0
while True:
_ = input()
if(_ == "END_OF_TEXT"):
break
t = _.casefold().split()
c += t.count(w)
print(c) | 1 | 1,842,724,141,050 | null | 65 | 65 |
import numpy as np
def check_bingo(A):
for i in range(3):
if np.all(A[i] == -1) or np.all(A[:, i] == -1):
return 'Yes'
if np.all(A[list(range(3)), list(range(3))] == -1) \
or np.all(A[list(range(3)), list(range(3))[::-1]] == -1):
return 'Yes'
return 'No'
def main():
A = np.array([list(map(int, input().split())) for _ in range(3)])
n = int(input())
for i in range(n):
b = int(input())
A = np.where(A == b, -1, A)
ans = check_bingo(A)
print(ans)
if __name__ == '__main__':
main()
| #144_E
n, k = map(int, input().split())
a = sorted(list(map(int,input().split())))
f = sorted(list(map(int,input().split())))[::-1]
l, r = -1, 10 ** 12
while r - l > 1:
x = (r + l) // 2
res = 0
for i in range(n):
res += max(0, a[i] - x // f[i])
if res > k:
l = x
else:
r = x
print(r) | 0 | null | 112,474,325,960,870 | 207 | 290 |
N = input()
print(N[:3])
| s=list(input())
t=[]
for i in range(3):
t.append(s[i])
r=''.join(t)
print(r)
| 1 | 14,709,159,360,868 | null | 130 | 130 |
n = int(input())
a = [int(i) for i in input().split()]
num = 0
is_swapped = True
i = 0
while is_swapped:
is_swapped = False
for j in range(n-1, i, -1):
if a[j] < a[j-1]:
tmp = a[j]
a[j] = a[j-1]
a[j-1] = tmp
is_swapped = True
num += 1
i += 1
print(' '.join([str(i) for i in a]))
print(num)
| n = int(input())
c = input()
left, right = 0, n - 1
cnt = 0
while left <= right:
while left < n and c[left] == 'R':
left += 1
while right > -1 and c[right] == 'W':
right -= 1
if left == n or right == -1 or left >= right: break
left += 1
right -= 1
cnt += 1
print(cnt) | 0 | null | 3,186,313,770,464 | 14 | 98 |
n, k = list(map(int, input().split()))
while n > abs(n - k):
if n >= k:
n = min(n, n % k)
elif k > n:
n = min(n, k % n)
print(n) | while True:
s = input()
if s == '0':
break
sum = 0
for d in s:
sum += int(d)
print(sum) | 0 | null | 20,503,278,478,000 | 180 | 62 |
#import numpy as np
import math
import collections
import bisect
def main():
a = int(input())
print(a + a**2 + a**3)
if __name__ == '__main__':
main()
| MOD = 10**9 + 7
K = int(input())
S = len(input())
FCT = [1]
for i in range(1, K+S+1):
FCT.append((FCT[-1] * i)%MOD)
def pmu(n, r, mod=MOD):
return (FCT[n] * pow(FCT[n-r], mod-2, mod)) % mod
def cmb(n, r, mod=MOD):
return (pmu(n, r) * pow(FCT[r], mod-2, mod)) % mod
def solve():
ans = 1
for i in range(S+1, K+S+1):
ans = (ans*26) % MOD
add = pow(25, i-S, MOD)
add = (add * cmb(i-1, i-S)) % MOD
ans = (ans + add) % MOD
return ans
if __name__ == "__main__":
print(solve())
| 0 | null | 11,450,012,550,112 | 115 | 124 |
a,b,c,d=map(int,input().split())
def ret(a,b,c,d):
return max(b*d,a*c,0 if (a*b<=0 or c*d<=0) else -1e64,a*d,b*c)
print(ret(a,b,c,d)) | import math
a, b, h, m = map(int, input().split())
ans = math.sqrt(a*a + b*b - 2*a*b*math.cos(math.pi*(h/6 + m/360 - m/30)))
print(ans)
| 0 | null | 11,572,596,838,750 | 77 | 144 |
import sys
ERROR_INPUT = 'input is invalid'
def main():
n = get_length()
arr = get_array(length=n)
sourtLi, count = selectionSort(li=arr, length=n)
print(*sourtLi)
print(count)
return 0
def get_length():
n = int(input())
if n < 0 or n > 100:
print(ERROR_INPUT)
sys.exit(1)
else:
return n
def get_array(length):
nums = input().split(' ')
return [str2int(string=n) for n in nums]
def str2int(string):
n = int(string)
if n < 0 or n > 100:
print(ERROR_INPUT)
sys.exit(1)
else:
return n
def selectionSort(li, length):
count = 0
for i in range(0, length - 1):
min_index = i
for j in range(i, length):
if li[j] < li[min_index]:
min_index = j
if i != min_index:
li[i], li[min_index] = li[min_index], li[i]
count += 1
return li, count
main() | #coding: utf-8
#ALDS1_2B
def pnt(s):
for i in xrange(len(s)):
print s[i],
print
n=int(raw_input())
a=map(int,raw_input().split())
cnt=0
for i in xrange(n):
mini = i
for j in xrange(i + 1, n):
if a[j] < a[mini]:
mini = j
if i != mini:
a[i], a[mini] = a[mini], a[i]
if i!=mini:
cnt+=1
pnt(a)
print cnt | 1 | 19,419,740,658 | null | 15 | 15 |
s_l = list(input())
t_l = list(input())
count_difference = 0
for s, t in zip(s_l, t_l):
if s != t:
count_difference += 1
print(count_difference)
| n=0
s=list(str(input()))
t=list(str(input()))
for i in range(len(s)):
if s[i] != t[i]:
n+=1
print(n) | 1 | 10,497,384,979,774 | null | 116 | 116 |
nn = int(input())
number_of_match = [0 for _ in range(10005)]
for xx in range(1,105):
xxxx = xx**2
for yy in range(1,105):
yyyy = yy**2
xxyy = xx*yy
for zz in range(1,105):
result = xxxx + yyyy + (zz)**2 + xxyy + (yy)*(zz) + (zz)*(xx)
if result < 10005:
number_of_match[result] += 1
for i in range(1,nn+1):
print(number_of_match[i]) | a, b = list(map(int, input().split()))
ret = (str(a) * b)
if a > b:
ret = (str(b) * a)
print("{}".format(ret))
| 0 | null | 46,354,578,822,060 | 106 | 232 |
x = int(input())
if x == 0:
print("1")
else:
print("0")
| n=int(input())
a=list(map(int,input().split()))[::-1]
number=2
if 1 not in a: print(-1);exit()
count=n-len(a[:a.index(1)+1])
a=a[:a.index(1)][::-1]
for i in a:
if i==number:
number+=1
else:
count+=1
print(count) | 0 | null | 58,708,551,610,620 | 76 | 257 |
def s0():return input()
def s1():return input().split()
def s2(n):return [input() for x in range(n)]
def s3(n):return [input().split() for _ in range(n)]
def s4(n):return [[x for x in s] for s in s2(n)]
def n0():return int(input())
def n1():return [int(x) for x in input().split()]
def n2(n):return [int(input()) for _ in range(n)]
def n3(n):return [[int(x) for x in input().split()] for _ in range(n)]
def t3(n):return [tuple(int(x) for x in input().split()) for _ in range(n)]
def p0(b,yes="Yes",no="No"): print(yes if b else no)
# from sys import setrecursionlimit
# setrecursionlimit(1000000)
# from collections import Counter,deque,defaultdict
# import itertools
# import math
# import networkx as nx
# from bisect import bisect_left,bisect_right
# from heapq import heapify,heappush,heappop
x,y,a,b,c=n1()
P=n1()
Q=n1()
R=n1()
P.sort()
Q.sort()
A=P[-x:]+Q[-y:]+R
A.sort()
print(sum(A[-x-y:])) | #三井住友2019_F
t1, t2 = map(int, input().split())
a1, a2 = map(int, input().split())
b1, b2 = map(int, input().split())
if (a1 > b1 and a2 > b2) or (a1 < b1 and a2 < b2):
print(0)
else:
if a1 < b1 and a2 > b2:
a1, b1 = b1, a1
a2, b2 = b2, a2
if t1 * (a1 - b1) > t2 * (b2 - a2):
print(0)
elif t1 * (a1 - b1) == t2 * (b2 - a2):
print('infinity')
else:
d = t2 * (b2 - a2) - t1 * (a1 - b1)
y = t1 * (a1 - b1)
if y % d == 0:
print(y // d * 2)
else:
print(y // d * 2 + 1) | 0 | null | 88,376,811,773,300 | 188 | 269 |
N, M = list(map(int, input().split()))
A = [0] * M
B = [0] * M
R = [0] * N
for i in range(N):
R[i] = set()
for i in range(M):
A[i], B[i] = list(map(int, input().split()))
R[A[i]-1].add(B[i]-1)
R[B[i]-1].add(A[i]-1)
stack = set()
visited = set()
max_groups = 0
for i in range(N):
if not i in visited:
stack.add(i)
groups = 0
while True:
current = stack.pop()
visited.add(current)
groups += 1
stack |= (R[current] - visited)
if not stack:
break
max_groups = max(max_groups,groups)
print(max_groups) | class UnionFind():
def __init__(self, N):
# parent of each node
self.parent = [n for n in range(N)]
# number of nodes in union
self.rank = [1] * N
def find(self, u):
if self.parent[u] == u:
return u
else:
# recursive call
return self.find(self.parent[u])
def union(self, u, v):
pu = self.find(u)
pv = self.find(v)
# same union
if pu == pv:
return
# let pv join into pu union
if self.rank[pu] < self.rank[pv]:
pu, pv = pv, pu
self.rank[pu] += self.rank[pv]
self.parent[pv] = pu
N, M = map(int, input().split())
UF = UnionFind(N)
for _ in range(M):
A, B = map(int, input().split())
A, B = A-1, B-1
UF.union(A, B)
ret = 0
for n in range(N):
ret = max(ret, UF.rank[n])
print(ret)
| 1 | 3,962,951,396,480 | null | 84 | 84 |
def isPalindrome(st):
l = len(st)
c = l//2
if l%2 == 1:
return st[:c] == st[c+1:][::-1]
else:
return st[:c] == st[c:][::-1]
S = input()
N = len(S)
if isPalindrome(S) and isPalindrome(S[:(N-1)//2]) and isPalindrome(S[(N+3)//2 - 1:]):
print('Yes')
else:
print('No')
| N, K=map(int, input().split())
A=list(map(int, input().split()))
F=list(map(int, input().split()))
A.sort()
F.sort(reverse=True)
l=-1
r=10**12+10
while l+1<r:
mid=(l+r)//2
s=0
for i in range(N):
s+=max(0, A[i]-mid//F[i])
if s<=K:
r=mid
else:
l=mid
print(r)
| 0 | null | 105,495,244,821,828 | 190 | 290 |
tmp = input().split(" ")
A = int(tmp[0])
B = int(tmp[1])
print(max([A - 2 * B, 0])) | n, k = list(map(int, input().split(' ')))
print(sum([tall >= k for tall in list(map(int, input().split(' ')))])) | 0 | null | 172,670,551,498,132 | 291 | 298 |
while True:
try:
a=input().split()
except:
break
b=int(a[0])+int(a[1])
print(len(str(b))) | #k = int(input())
#s = input()
#a, b = map(int, input().split())
#s, t = map(str, input().split())
#l = list(map(int, input().split()))
h,a = map(int, input().split())
ans = h // a
if (h % a != 0):
ans += 1
print(ans)
| 0 | null | 38,453,653,664,800 | 3 | 225 |
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
from collections import deque
sys.setrecursionlimit(10**7)
inf = 10**20
mod = 10**9 + 7
DR = [1, -1, 0, 0]
DC = [0, 0, 1, -1]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
fac = [-1] * (10**6+1)
finv = [-1] * (10**6+1)
inv = [-1] * (10**6+1)
fac[0] = fac[1] = 1
finv[0] = finv[1] = 1
inv[1] = 1
def initNCMMod(limit):
for i in range(2, limit):
fac[i] = fac[i-1] * i % mod
inv[i] = mod - inv[mod%i] * (mod // i) % mod
finv[i] = finv[i-1] * inv[i] % mod
initNCMMod(10**5 + 3)
def NCMMod(n, k):
if n < k:
return 0
if (n < 0 or k < 0):
return 0
return fac[n] * (finv[k] * finv[n-k] % mod) % mod
def main():
N, K =LI()
A = sorted(LI())
m = A[0]
if m < 0:
for i in range(N):
A[i] -= m
arr = []
cumA = [0] * (N+1)
for i in range(N):
A[i] %= mod
cumA[i+1] = A[i] + cumA[i]
cumA[i+1] %= mod
ans = 0
# [l, r) = A[l] + ... + A[r-1]
if K >= 2:
for d in range(K-2, N):
ans += NCMMod(d, K-2) * (((cumA[N] - cumA[d+1]) % mod - (cumA[N-d-1] - cumA[0]) % mod)) % mod
ans %= mod
print(ans)
main()
| def resolve():
N = int(input())
L = sorted(list(map(int, input().split())))
# print(L)
ans = 0
import bisect
for i in range(N):
for j in range(i+1, N):
a, b = L[i], L[j]
idx1 = bisect.bisect_left(L,b+a)
idx2 = bisect.bisect_right(L,b-a)
cnt = idx1 - idx2
if idx2 <= i <= idx1:
cnt -= 1
if idx2 <= j <= idx1:
cnt -= 1
if cnt > 0:
ans += cnt
# print("a: {} b: {} i: {} j: {} idx1: {}, idx2: {}".format(a, b, i, j, idx1, idx2))
# print(ans)
print(ans//3)
if '__main__' == __name__:
resolve() | 0 | null | 133,696,360,304,430 | 242 | 294 |
from bisect import bisect_right as br
from itertools import accumulate as ac
n,m,k=map(int,input().split())
a=list(ac([0]+list(map(int,input().split()))))
b=list(ac([0]+list(map(int,input().split()))))
l=0
for i in range(n+1):
if k<a[i]:
break
else:
l=max(l,i+br(b,k-a[i])-1)
print(l) |
n = int(input())
X = [int(x) for x in input().split()]
Y = [int(y) for y in input().split()]
d1 = 0
d2 = 0
d3 = 0
Di = []
for i in range(n) :
d1 += abs(X[i] - Y[i])
print(f"{d1:.6f}")
for i in range(n) :
d2 += abs(X[i] - Y[i]) ** 2
print(f"{(d2)**(1/2):.6f}")
for i in range(n) :
d3 += abs(X[i] - Y[i]) ** 3
print(f"{(d3)**(1/3):.6f}")
for i in range(n) :
Di.append(abs(X[i] - Y[i]))
print(f"{max(Di):.6f}")
| 0 | null | 5,465,560,526,496 | 117 | 32 |
from sys import stdin
n,k = map(int,stdin.readline().split())
a = list(map(int,stdin.readline().split()))
for i in range(n):
a[i] -= 1
d = {}
d[0] = 0
cur = 0
step = 0
while step < k:
cur = a[cur]
step += 1
if cur in d:
looplen = step - d[cur]
step += looplen * ((k-step)//looplen)
else:
d[cur] = step
print(cur + 1)
| import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,copy,functools
import time,random,resource
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(): return [list(map(int, l.split())) for l in sys.stdin.readlines()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
def pe(s): return print(str(s), file=sys.stderr)
def JA(a, sep): return sep.join(map(str, a))
def JAA(a, s, t): return s.join(t.join(map(str, b)) for b in a)
def main():
l,r,d = LI()
return r // d - (l-1) // d
print(main())
| 0 | null | 15,078,674,332,932 | 150 | 104 |
n, m = map(int, input().split())
a = list(map(int, input().split()))
dp = [0] + [float('inf')]*(n)
for i in range(m):
for j in range(a[i],n+1):
dp[j] = min(dp[j],dp[j-a[i]]+1)
print(dp[-1])
| # -*- coding: utf-8 -*-
import sys
sys.setrecursionlimit(10 ** 9)
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()))
INF=float('inf')
N,M=MAP()
C=LIST()
dp=[INF]*(N+1)
dp[0]=0
for i in range(N):
for j in range(M):
if i+C[j]<=N:
dp[i+C[j]]=min(dp[i+C[j]], dp[i]+1)
print(dp[N])
| 1 | 138,931,430,738 | null | 28 | 28 |
from bisect import bisect_left
N = int(input())
Lli = list(map(int,input().split()))
Lli.sort()
res = 0
for i in range(N-2):
for j in range(i+1,N-1):
ab = Lli[i]+Lli[j]
res += bisect_left(Lli,ab)-j-1
print(res) | N,M,K = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
a = [0]
b = [0]
for i in range(N):
a.append(a[i] + A[i])
for j in range(M):
b.append(b[j] + B[j])
ans = 0
j = M
for i in range(N+1):
if a[i] > K:
break
while a[i] + b[j] > K:
j -= 1
ans = max(ans, i+j)
print(ans) | 0 | null | 91,158,862,210,500 | 294 | 117 |
#coding:utf-8
num = input()
print num * num * num | x = int(input())
y = pow(x,3)
print(y)
| 1 | 277,123,258,412 | null | 35 | 35 |
def main():
day = [list(map(int, input().split())) for _ in range(2)]
print(1 if day[0][0] + 1 == day[1][0] else 0)
if __name__ == '__main__':
main()
| import sys
readline = sys.stdin.buffer.readline
sys.setrecursionlimit(10 ** 8)
INF = float('inf')
MOD = 10 ** 9 + 7
def main():
M1, D1 = map(int, readline().split())
M2, D2 = map(int, readline().split())
if M1 != M2:
print('1')
else:
print('0')
if __name__ == '__main__':
main() | 1 | 124,532,611,146,772 | null | 264 | 264 |
def readInt():
return list(map(int, input().split()))
h, w = readInt()
if h == 1 or w == 1:
print(1)
elif h*w%2 == 0:
print(h*w//2)
else:
print(h*w//2+1)
| H,W = map(int,input().split())
if(H == 1 or W == 1):
print("1")
elif((H*W)%2 == 0):
print(str((H*W)//2))
else:
print(str((H*W)//2+1)) | 1 | 51,115,367,945,600 | null | 196 | 196 |
def resolve():
n = int(input())
a = list(map(int, input().split()))
dict1 = {}
dict2 = {}
for i in range(n):
a1 = a[i] + i + 1
a2 = i + 1 - a[i]
if a1 in dict1:
dict1[a1] += 1
else:
dict1[a1] = 1
if a2 in dict2:
dict2[a2] += 1
else:
dict2[a2] = 1
ans = 0
for i in dict1:
if i in dict2:
ans += dict1[i]*dict2[i]
print(ans)
resolve() | n,m=map(int,input().split())
if n%2==1:
[print(i+1,n-i) for i in range(m)]
else:
[print(i+1,n-i) if i<m/2 else print(i+1,n-i-1) for i in range(m)]
| 0 | null | 27,308,762,005,170 | 157 | 162 |
n,m = map(int,input().split())
if n%2 ==1:
for i in range(1,m+1):
print(i,n-i)
else:
left_end = 1+m if m%2 == 1 else m
left_start = left_end//2
right_start = left_end+m//2
for i in range(1,m+1):
if i%2 == 1:
print(left_start,left_start+i)
left_start-=1
else:
print(right_start,right_start+i)
right_start-=1 | n=list(map(int,input().strip().split()))
m=list(map(int,input().strip().split()))
for i in range(n[0]-n[1]):
if(m[i+n[1]]>m[i]):
print("Yes")
else:
print("No") | 0 | null | 17,919,556,532,330 | 162 | 102 |
from itertools import permutations
n = int(input())
p = [int(i) for i in input().split()]
q = [int(i) for i in input().split()]
perm = list(permutations(sorted(p), n)) #; print(perm)
a = perm.index(tuple(p))
b = perm.index(tuple(q))
print(abs(a-b)) | from collections import Counter
N = int(input())
s = [input() for _ in range(N)]
c = Counter(s)
print(f'AC x {c["AC"] if c["AC"] else 0}')
print(f'WA x {c["WA"] if c["WA"] else 0}')
print(f'TLE x {c["TLE"] if c["TLE"] else 0}')
print(f'RE x {c["RE"] if c["RE"] else 0}') | 0 | null | 54,376,487,697,508 | 246 | 109 |
n = int(input())
if n < 10:
print("Yes")
exit(0)
for i in range(2, 10):
if n % i != 0:
continue
v = n // i
if v < 10:
print("Yes")
exit(0)
print("No") | import sys
n = int(input())
for i in range(1,10):
mod,ret = divmod(n,i)
if ret == 0 and mod <= 9:
print('Yes')
sys.exit()
print('No') | 1 | 160,360,192,263,908 | null | 287 | 287 |
s = input()
p = input()
found = False
for i in range(len(s)):
ring = s[i:] + s[:i]
if p in ring:
print('Yes')
found = True
break
if not found:
print('No') | x, n = map(int, input().split())
p = list(map(int, input().split()))
for i in range(x+1):
for j in [-1, 1]:
ans = x + i*j
if not p.count(ans):
print(ans)
exit(0)
| 0 | null | 7,950,741,406,960 | 64 | 128 |
while True:
m,f,r = map(int,input().split())
score = ""
if(m == -1 and f == -1 and r == -1): break
if(m == -1 or f == -1): score = "F"
elif(m+f >= 80): score = "A"
elif(m+f >= 65): score = "B"
elif(m+f >= 50): score = "C"
elif(m+f >= 30):
if(r >= 50): score = "C"
else: score = "D"
else:
score = "F"
print(score)
| 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)) | 1 | 1,207,136,868,030 | null | 57 | 57 |
N = int(input())
says = []
for _ in range(N):
A = int(input())
say = [list(map(int, input().split())) for _ in range(A)]
says.append(say)
# print(says)
max_upright_count = 0
for i in range(1 << N):
integrate = True
upright_count = 0
declares = [-1 for _ in range(N)]
for j in range(N):
if not integrate:
continue
# もし真偽不明の場合は正しいことを言う場合もあるから無視する
if (i >> j & 1) == 1:
upright_count += 1
for x, y in says[j]:
# print(i, j, x, y, declares)
if declares[x - 1] == -1:
declares[x - 1] = y
else:
if declares[x - 1] == y:
continue
else:
integrate = False
break
# print(bin(i), integrate, declares, upright_count)
for j in range(N):
# print((i >> j) & 1, declares[j])
if ((i >> j) & 1) != declares[j] and declares[j] != -1:
# print(False)
integrate = False
# print(integrate)
if integrate:
max_upright_count = max(max_upright_count, upright_count)
print(max_upright_count)
| import sys
input = sys.stdin.buffer.readline
import math
n = int(input())
mod = 1000000007
AB = []
for i in range(n):
a, b = map(int, input().split())
AB.append((a, b))
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
def toid(a, b):
flag = False
if a == 0 and b == 0:
return (0, 0)
elif a == 0:
return (0, 1)
elif b == 0:
return (1, 0)
else:
if a > 0 and b > 0:
g = math.gcd(a, b)
a //= g
b //= g
elif a > 0 and b < 0:
b = -b
g = math.gcd(a, b)
a //= g
b //= g
b = -b
elif a < 0 and b > 0:
a = -a
g = math.gcd(a, b)
a //= g
b //= g
b = -b
else:
a = -a
b = -b
g = math.gcd(a, b)
a //= g
b //= g
return (a, b)
def totg(a, b):
if a == 0 and b == 0:
return (0, 0)
elif a == 0:
return (1, 0)
elif b == 0:
return (0, 1)
else:
if a > 0 and b > 0:
g = math.gcd(a, b)
a //= g
b //= g
t = (b, -a)
elif a > 0 and b < 0:
b = -b
g = math.gcd(a, b)
a //= g
b //= g
b = -b
t = (-b, a)
elif a < 0 and b > 0:
a = -a
g = math.gcd(a, b)
a //= g
b //= g
a = -a
t = (b, -a)
else:
a = -a
b = -b
g = math.gcd(a, b)
a //= g
b //= g
a = -a
b = -b
t = (-b, a)
return t
d = {}
ans = 0
for i in range(n):
a, b = AB[i]
s = toid(a, b)
if s not in d:
d[s] = 1
else:
d[s] += 1
ans = 1
used = set()
for k1, v1 in d.items():
if k1 in used:
continue
if k1 == (0, 0):
continue
a, b = k1
k2 = totg(a, b)
if k2 in d:
v2 = d[k2]
else:
v2 = 0
temp = power(2, v1, mod)-1+power(2, v2, mod)-1+1
ans *= temp
ans %= mod
used.add(k1)
used.add(k2)
ans -= 1
if (0, 0) in d:
ans += d[(0, 0)]
print(ans%mod) | 0 | null | 71,551,724,283,208 | 262 | 146 |
X, Y = map(int, input().split())
award = [300000, 200000, 100000]
ans = 0
if X <= 3:
ans += award[X-1]
if Y <= 3:
ans += award[Y-1]
if X == 1 and Y == 1:
ans += 400000
print(ans)
| target = input()
now_height = []
now_area = [0]
answer = []
continued = 0
depth = 0
depth_list = []
for t in target:
# print(now_height,depth_list,now_area,answer,continued)
if t == '\\':
now_height.append(continued)
depth_list.append(depth)
now_area.append(0)
depth -= 1
elif t == '_':
pass
elif t == '/' and len(now_height) > 0:
depth += 1
started = now_height.pop()
temp_area = continued - started
# print(depth_list[-1],depth)
now_area[-1] += temp_area
if depth > depth_list[-1]:
while depth > depth_list[-1]:
temp = now_area.pop()
now_area[-1] += temp
depth_list.pop()
continued += 1
now_area = list(filter(lambda x:x != 0,now_area))
answer.extend(now_area)
print(sum(answer))
print(len(answer),*answer) | 0 | null | 70,301,912,407,132 | 275 | 21 |
ri = lambda S: [int(v) for v in S.split()]
N, A, B = ri(input())
q, r = divmod(N, A+B)
blue = (A * q) + r if r <= A else (A * q) + A
print(blue) | import itertools
N = int(input())
P = tuple(map(int, input().split()))
Q = tuple(map(int, input().split()))
l = [i+1 for i in range(N)]
for i, tpl in enumerate(itertools.permutations(l, N)):
if tpl == P:
a = i
if tpl == Q:
b = i
print(abs(a-b)) | 0 | null | 77,862,730,862,460 | 202 | 246 |
while True :
x = input()
if x==0:
break
else:
Count = 0
while x>0 :
Count += x%10
x /= 10
print '%d' %Count | import copy
class Dice:
def __init__(self, eyes: [int]):
self.__eyes = eyes
def top(self):
return self.__eyes[0]
def roll_s(self):
tmp = copy.copy(self.__eyes)
tmp[0] = self.__eyes[4]
tmp[1] = self.__eyes[0]
tmp[2] = self.__eyes[2]
tmp[3] = self.__eyes[3]
tmp[4] = self.__eyes[5]
tmp[5] = self.__eyes[1]
self.__eyes = tmp
def roll_e(self):
tmp = copy.copy(self.__eyes)
tmp[0] = self.__eyes[3]
tmp[1] = self.__eyes[1]
tmp[2] = self.__eyes[0]
tmp[3] = self.__eyes[5]
tmp[4] = self.__eyes[4]
tmp[5] = self.__eyes[2]
self.__eyes = tmp
def roll_n(self):
tmp = copy.copy(self.__eyes)
tmp[0] = self.__eyes[1]
tmp[1] = self.__eyes[5]
tmp[2] = self.__eyes[2]
tmp[3] = self.__eyes[3]
tmp[4] = self.__eyes[0]
tmp[5] = self.__eyes[4]
self.__eyes = tmp
def roll_w(self):
tmp = copy.copy(self.__eyes)
tmp[0] = self.__eyes[2]
tmp[1] = self.__eyes[1]
tmp[2] = self.__eyes[5]
tmp[3] = self.__eyes[0]
tmp[4] = self.__eyes[4]
tmp[5] = self.__eyes[3]
self.__eyes = tmp
def roll(self, direction: str):
if direction == 'N':
self.roll_n()
if direction == 'E':
self.roll_e()
if direction == 'S':
self.roll_s()
if direction == 'W':
self.roll_w()
def resolve():
eyes = list(map(int, input().split()))
directions = list(input())
dice = Dice(eyes)
for direction in directions:
dice.roll(direction)
print(dice.top())
resolve()
| 0 | null | 911,420,415,664 | 62 | 33 |
def main():
N = int(input())
count = 0
for a in range(N) :
a += 1
for b in range(N):
b += 1
c = N - a * b
if c <= 0 :
break
else :
count += 1
print(count)
if __name__ == '__main__':
main()
| N=int(input())
ans=0
for a in range(1,N):
q,m=divmod(N,a)
ans+=(N//a)-(m==0)
print(ans) | 1 | 2,591,564,133,120 | null | 73 | 73 |
import sys
dic = set()
L = sys.stdin.readlines()
for Ins in L[1:]:
ins, op = Ins.split()
if ins == 'insert':
dic.add(op)
if ins == 'find':
print('yes' if op in dic else 'no') | n = int(input())
dic = {}
for i in range(n):
line = input().split()
if line[0] == 'insert':
if dic.get(line[1]):
dic[line[1]] += 1
else:
dic[line[1]] = 1
elif line[0] == 'find':
if dic.get(line[1]):
print('yes')
else:
print('no') | 1 | 76,896,526,500 | null | 23 | 23 |
len_s = int(input())
s = [int(i) for i in input().split()]
len_t = int(input())
t = [int(i) for i in input().split()]
cnt = 0
for f in t:
i = 0
while i < len(s) and s[i] != f:
i += 1
if i < len(s):
cnt +=1
print(cnt) | n = int(input())
s = input().split()
q = int(input())
t = input().split()
res = 0
for i in t:
if i in s:
res +=1
print(res)
| 1 | 68,490,172,390 | null | 22 | 22 |
n = int(input())
print(n^1) | from queue import Queue
n = int(input())
A = [[0 for i in range(n)] for j in range(n)]
d = [-1 for i in range(n)]
for i in range(n):
u, k, *v = list(map(int, input().split()))
for j in v:
A[int(u)-1][int(j)-1] = 1
q = Queue()
q.put(0)
d[0] = 0
while not q.empty():
u = q.get()
# print('visited:', u)
for v in range(n):
# print(u, v)
if A[u][v] == 1 and d[v] == -1:
q.put(v)
d[v] = d[u] + 1
# print('-========')
for i in range(n):
print(i+1, d[i])
| 0 | null | 1,490,740,042,620 | 76 | 9 |
a, b = input().split()
a = int(a)
b = int(round(float(b) * 100))
print(a * b // 100) | import math , sys
from decimal import Decimal
A , B = list( map( Decimal , input().split()))
print( int(A * B ) ) | 1 | 16,607,640,640,500 | null | 135 | 135 |
N = int(input())
ans = N // 2
if N % 2 == 0: ans -= 1
print(ans) | def main():
n = int(raw_input())
data = {}
for a in xrange(1,n):
b = n-a
if a == b:
continue
data[(min(a,b), max(a, b))] = 1
print(len(data.keys()))
main() | 1 | 153,764,379,395,032 | null | 283 | 283 |
word = input()
if word == 'ABC':
print('ARC')
else:
print('ABC') | from math import *
PI = 3.1415926535898
while True:
try:
t = input()
ans = ""
ans += str(t/(60*60))
t %= 60*60
ans += ":"
ans += str(t/60)
t %= 60
ans += ":"
ans += str(t)
print ans
except EOFError:
break | 0 | null | 12,164,131,451,162 | 153 | 37 |
from collections import deque
n, q = map(int, input().split())
Q = deque()
for i in range(n):
name,time = input().split()
Q.append([name, int(time)])
sum =0
while Q:
qt = Q.popleft()
if qt[1] <= q:
sum += qt[1]
print(qt[0], sum)
else:
sum += q
qt[1] -= q
Q.append(qt) | class Queue():
def __init__(self):
self.el = []
def add(self, el):
self.el.append(el)
def delete(self):
return self.el.pop(0)
def action(self):
self.el[0]['time'] -= q
tmp = self.delete()
self.el.append(tmp)
n, q = map(int, raw_input().split())
qu = Queue()
for i in range(n):
name, time = raw_input().split()
time = int(time)
qu.add({'name':name, 'time':time})
time = 0
while qu.el:
#print qu.el
if qu.el[0]['time'] > q:
qu.action()
time += q
else:
time += qu.el[0]['time']
print qu.el[0]['name'], time
qu.delete() | 1 | 44,649,944,610 | null | 19 | 19 |
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
N = int(readline())
S = readline().strip()
if N % 2 == 0 and S == S[: N // 2] * 2:
print('Yes')
else:
print('No')
return
if __name__ == '__main__':
main()
| N=int(input())
S=list(input())
if N%2!=0:
print("No")
else:
s_1=S[:int(N/2)]
s_2=S[int(N/2):N]
if s_1==s_2:
print("Yes")
else:
print("No")
| 1 | 146,941,251,445,182 | null | 279 | 279 |
def gcd2(x,y):
if y == 0: return x
return gcd2(y,x % y)
def lcm2(x,y):
return x // gcd2(x,y) * y
a,b = map(int,input().split())
print(lcm2(a,b)) | import math
a,b = map(int,input().split())
if b>a:
a,b = b,a
l = (a*b)//(math.gcd(a,b))
print(l) | 1 | 113,162,366,044,768 | null | 256 | 256 |
def f(x):
if x=="r":
return 2
elif x=="s":
return 0
else:
return 1
N,K=map(int,input().split())
L=list(map(int,input().split()))
T=["*"]+list(map(f,input()))
Z=[[0,0,0] for _ in range(N+1)]
for x in range(1,N+1):
for a in range(3):
if x<=K:
Z[x][a]=L[a]*(T[x]==a)
else:
b=(a+1)%3
c=(b+1)%3
Z[x][a]=max(Z[x-K][b],Z[x-K][c])+L[a]*(T[x]==a)
X=0
for i in range(1,K+1):
X+=max(Z[-i])
print(X) | #abc149-d
n,k=map(int,input().split())
s,p,r=map(int,input().split())
f={'s':s,'p':p,'r':r}
t=str(input())
ans=0
for i in range(k):
a=i+k
last=t[i]
ans+=f[last]
while a<n-k:
if t[a]==last:
if t[a+k]==last:
if last=='s':
last='r'
else:
last='s'
else:
if last=='s':
if t[a+k]=='r':
last='p'
else:
last='r'
elif last=='r':
if t[a+k]=='s':
last='p'
else:
last='s'
else:
if t[a+k]=='r':
last='s'
else:
last='r'
else:
last=t[a]
ans+=f[last]
a+=k
if a<n:
if t[a]!=last:
ans+=f[t[a]]
print(ans) | 1 | 106,697,535,050,020 | null | 251 | 251 |
# simpleバージョン
class BinaryIndexedTree:
def __init__(self,size):
self.N = size
self.bit = [0]*(size+1)
def add(self,x,w): # 0-indexed
x += 1
while x <= self.N:
self.bit[x] += w
x += (x & -x)
def _sum(self,x): # 1-indexed
ret = 0
while x > 0:
ret += self.bit[x]
x -= (x & -x)
return ret
def sum(self,l,r): # [l,r)
return self._sum(r) - self._sum(l)
def __str__(self): # for debug
arr = [self.sum(i,i+1) for i in range(self.N)]
return str(arr)
class BIT:
""" 区間加算BIT(区間加算・区間合計取得) """
def __init__(self, N):
# 添字0が使えないので、内部的には全て1-indexedとして扱う
N += 1
self.N = N
self.data0 = [0] * N
self.data1 = [0] * N
def _add(self, data, k, x):
k += 1
while k < self.N:
data[k] += x
k += k & -k
def _get(self, data, k):
k += 1
s = 0
while k:
s += data[k]
k -= k & -k
return s
def add(self, l, r, x):
""" 区間[l,r)に値xを追加 """
self._add(self.data0, l, -x*(l-1))
self._add(self.data0, r, x*(r-1))
self._add(self.data1, l, x)
self._add(self.data1, r, -x)
def query(self, l, r):
""" 区間[l,r)の和を取得 """
return self._get(self.data1, r-1) * (r-1) + self._get(self.data0, r-1) \
- self._get(self.data1, l-1) * (l-1) - self._get(self.data0, l-1)
def ctoi(c):
return ord(c) - ord('a')
def main():
N = int(input())
S = input()
Q = int(input())
query = [input().split() for i in range(Q)]
bits = [BIT(N) for i in range(26)]
s = []
for i, c in enumerate(S):
bits[ctoi(c)].add(i,i+1,1)
s.append(c)
for a, b, c in query:
if a == '1':
i = int(b) - 1
bits[ctoi(s[i])].add(i,i+1,-1)
bits[ctoi(c)].add(i,i+1,1)
s[i] = c
else:
l = int(b) - 1
r = int(c)
a = 0
for i in range(26):
if bits[i].query(l,r):
a += 1
print(a)
if __name__ == "__main__":
main() | import sys
def input(): return sys.stdin.readline().rstrip()
from bisect import bisect_left,bisect
def main():
n=int(input())
S=list(input())
q=int(input())
set_s={chr(ord('a')+i):[] for i in range(26)}
for i,s in enumerate(S):
set_s[s].append(i)
for _ in range(q):
query=input().split()
if query[0]=="1":
i,c=int(query[1])-1,query[2]
if S[i]==c:continue
set_s[S[i]].remove(i)
set_s[c].insert(bisect_left(set_s[c],i),i)
S[i]=c
else:
l,r=int(query[1])-1,int(query[2])-1
ans=0
for i in range(26):
ss=chr(ord('a')+i)
if bisect(set_s[ss],r)>bisect_left(set_s[ss],l):
ans+=1
print(ans)
if __name__=='__main__':
main() | 1 | 62,497,092,433,610 | null | 210 | 210 |
a = int(input())
print(2*(22/7)*a) | import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
import numpy as np
def main():
n, m, k = map(int, input().split())
a = np.array(readline().split(), np.int64)
b = np.array(readline().split(), np.int64)
aa = a.cumsum()
ba = b.cumsum()
r = np.searchsorted(ba, k, side='right')
for i1, aae in enumerate(aa):
if k < aae:
break
r = max(r, np.searchsorted(ba, k - aae, side='right') + i1 + 1)
print(r)
if __name__ == '__main__':
main() | 0 | null | 20,965,276,620,650 | 167 | 117 |
a, b = map(int, input().split())
if (a >= 1) and (a <= 9) and (b >= 1) and (b <= 9):
print(a * b)
else:
print(-1)
| A,B,H,M = map(int, input().split())
m = M/60*360
h = H/12*360+M/60*30
kakudo = (h-m)%360
import math
cos = math.cos(math.radians(kakudo))
print(math.sqrt(A*A+B*B-2*A*B*cos)) | 0 | null | 89,353,480,092,910 | 286 | 144 |
input_list = [int(num) for num in input().split()]
D = input_list[0]
T = input_list[1]
S = input_list[2]
if D/S <= T:
print("Yes")
else:
print("No") | list1 = input().split(" ")
if int(list1[0]) <= int(list1[1]) * int(list1[2]):
print("Yes")
else:
print("No") | 1 | 3,547,965,356,408 | null | 81 | 81 |
from collections import defaultdict
from math import gcd
MOD = 1000000007
N = int(input())
both_zeros_cnt = 0
bads = defaultdict(lambda: [0, 0])
for _ in range(N):
A, B = map(int, input().split())
if A == 0 and B == 0:
both_zeros_cnt += 1
continue
if B < 0 or (B == 0 and A < 0):
A, B = -A, -B
g = gcd(A, B)
A, B = A // g, B // g
if A > 0:
bads[(A, B)][0] += 1
else:
bads[(B, -A)][1] += 1
NMAX = 2 * 10 ** 5 + 1
pow2 = [1] * (NMAX + 1)
for i in range(1, NMAX + 1):
pow2[i] = pow2[i - 1] * 2 % MOD
ans = 1
for k, l in bads.values():
ans *= pow2[k] + pow2[l] - 1
ans %= MOD
print((ans + both_zeros_cnt - 1) % MOD)
| import math
def modpow(a, n, p):
if n == 0:
return 1
if n == 1:
return a % p
elif n % 2 == 1:
return a * modpow(a, n-1, p) % p
else:
return modpow(a, n//2, p) **2 % p
MOD = 1000000007
n = int(input())
#初期値が0の辞書
from collections import defaultdict
pp = defaultdict(lambda: 0)
pm = defaultdict(lambda: 0)
def seiki(x,y):
tmp=math.gcd(x,y)
return (x//tmp,y//tmp)
a0b0 = 0
for i in range(n):
a, b = map(int, input().split())
if a == 0 and b == 0:
a0b0 += 1
elif a == 0:
pp[(0,1)] += 1
elif b == 0:
pm[(0,1)] += 1
elif a*b>0:
tmp = seiki(abs(a),abs(b))
pp[tmp] += 1
else:
tmp = seiki(abs(b),abs(a))
pm[tmp] += 1
ans = 1
for key in set(pp.keys()) | set(pm.keys()):
pp_v=pp[key]
pm_v=pm[key]
ans*=(modpow(2,pm_v,MOD)+modpow(2,pp_v,MOD)-1)
ans%=MOD
ans = (ans+a0b0-1) % MOD
print(ans)
| 1 | 20,976,717,919,170 | null | 146 | 146 |
import math
def fact(n):
ans = 1
for i in range(2, n+1):
ans*= i
return ans
def comb(n, c):
return fact(n)//(fact(n-c)*c)
s,w = map(int, input().split())
if(s >w):
print('safe')
else:
print('unsafe')
| def solve():
N,K = [int(i) for i in input().split()]
min_N = N
if min_N > K:
min_N = min_N - (min_N//K)*K
min_N = min(min_N, abs(min_N-K))
print(min_N)
if __name__ == "__main__":
solve() | 0 | null | 34,330,723,307,540 | 163 | 180 |
#!/usr/bin python3
# -*- coding: utf-8 -*-
h, w, k = map(int, input().split())
a = [list(map(int, list(input()))) for _ in range(h)]
ret = 100000
for i in range(2 ** (h-1)):
hi = [0] * h
for j in range(h-1):
hi[j+1] += hi[j] + (i >> j & 1)
cnt = max(hi)
pj = 0
x = []
while pj < w:
s = [0] * 10
fg = False
for j in range(pj, w):
for t in range(h):
s[hi[t]] += a[t][j]
if max(s)>k:
if j == pj:
cnt = 100000
fg = True
break
else:
x.append(j)
cnt += 1
pj = j
break
if j == w-1:
pj = w
break
if fg:
break
ret = min(ret, cnt)
print(ret) | from itertools import product
H, W, K = map(int, input().split())
grid = ""
for _ in range(H):
grid += input()
ans = 10000
for Hcut in product((0, 1), repeat = H-1):
Gr_num = sum(Hcut) + 1
old = [0]*Gr_num
cnt = 0
for i in range(W):
#縦一列のchocoを見る
choco = grid[i::W]
new = [0]*Gr_num
gr = 0
for j in range(H):
new[gr] += int(choco[j])
if j < H-1:
if Hcut[j] == 1:
gr += 1
#そもそも一列でオーバーしてたら詰み。
if max(new) > K:
cnt += 10000
break
#新しい一列を追加しても大丈夫か確認
check = [old[gr] + new[gr] for gr in range(Gr_num)]
if max(check) > K:
old = new[:]
cnt += 1
else:
old = check[:]
ans = min(ans, cnt+sum(Hcut))
print(ans) | 1 | 48,245,121,120,940 | null | 193 | 193 |
i = input()
if(i=='ABC'):
print('ARC')
else:
print('ABC')
| input_str = input()
if input_str == "ABC":
print("ARC")
else:
print("ABC") | 1 | 24,186,900,905,474 | null | 153 | 153 |
a, b, m = map(int, input().split())
a_list = [int(i) for i in input().split()]
b_list = [int(i) for i in input().split()]
money = []
for _ in range(m):
x, y, c = map(int, input().split())
x -= 1
y -= 1
total = a_list[x] +b_list[y] - c
money.append(total)
money.append(min(a_list) + min(b_list))
print(min(money)) | A, B, M = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
vals = []
for _ in range(M):
i, j, v = map(int, input().split())
vals.append( a[i - 1] + b[j - 1] - v)
vals.append(min(a) + min(b))
print(min(vals)) | 1 | 53,751,980,924,960 | null | 200 | 200 |
# 高橋君と青木君がモンスターを闘わせます。
# 高橋君のモンスターは体力が Aで攻撃力が Bです。 青木君のモンスターは体力が Cで攻撃力が Dです。
# 高橋君→青木君→高橋君→青木君→... の順に攻撃を行います。 攻撃とは、相手のモンスターの体力の値を自分のモンスターの攻撃力のぶんだけ減らすことをいいます。
# このことをどちらかのモンスターの体力が 0以下になるまで続けたとき、 先に自分のモンスターの体力が 0以下になった方の負け、そうでない方の勝ちです。
# 高橋君が勝つなら Yes、負けるなら No を出力してください。
A, B, C, D = map(int, input().split())
while A or C > 0:
aoki_hitpoint = C - B
if aoki_hitpoint <= 0:
C = 0
print("Yes")
exit()
else:
C = aoki_hitpoint
takahashi_hitpoint = A - D
if takahashi_hitpoint <= 0:
print("No")
A = 0
exit()
else:
A = takahashi_hitpoint | A,B,C,D = (int(x) for x in input().split())
while True:
C -= B
if C <= 0:
print('Yes')
break
else:
A -= D
if A <= 0:
print('No')
break | 1 | 29,872,074,713,820 | null | 164 | 164 |
n = int(input())
a = list(map(int,input().split()))
count = 0
for i in range(n):
minij =i
for j in range(i,n):
if a[j] < a[minij]:
minij = j
if a[i] > a[minij]:
count+=1
a[i],a[minij] = a[minij],a[i]
print(' '.join(map(str,a)))
print(count)
| n = int(input())
s = input().split(" ")
nums = list(map(int,s))
koukan = 0
for i in range(n):
minj = i
for j in range(i+1,n):
if nums[j] < nums[minj]:
minj = j
w = nums[i]
nums[i] = nums[minj]
nums[minj] = w
if i != minj:
koukan += 1
for i in range(n):
if i == n-1:
print(nums[i])
else:
print(nums[i],end=" ")
print(koukan) | 1 | 20,014,650,032 | null | 15 | 15 |
#from collections import defaultdict, deque
#import itertools
#import numpy as np
#import re
import bisect
def main():
N = int(input())
SS = []
for _ in range(N):
SS.append(input())
S = []
for s in SS:
while '()' in s:
s = s.replace('()', '')
S.append(s)
#print(S)
S = [s for s in S if s != '']
sum_op = 0
sum_cl = 0
S_both_op = []
S_both_cl = []
for s in S:
if not ')' in s:
sum_op += len(s)
elif not '(' in s:
sum_cl += len(s)
else:
pos = s.find('(')
if pos <= len(s) - pos:
S_both_op.append((pos, len(s)-pos)) #closeのほうが少ない、'))((('など -> (2,3)
else:
S_both_cl.append((pos, len(s)-pos)) #closeのほうが多い、')))(('など -> (3,2)
# S_both_opは、耐えられる中でより伸ばす順にしたほうがいい？
#S_both_op.sort(key=lambda x: (x[0], x[0]-x[1])) #closeの数が小さい順にsortかつclose-openが小さい=伸ばす側にsort
#S_both_cl.sort(key=lambda x: (x[0], x[0]-x[1])) #これもcloseの数が小さい順にsortかつclose-openが小さい=あまり縮まない順にsort
S_both_op.sort(key=lambda x: x[0])
S_both_cl.sort(key=lambda x: -x[1])
for p in S_both_op:
sum_op -= p[0]
if(sum_op < 0 ):
print('No')
exit()
sum_op += p[1]
for p in S_both_cl:
sum_op -= p[0]
if(sum_op < 0 ):
print('No')
exit()
sum_op += p[1]
if sum_op == sum_cl:
print('Yes')
else:
print('No')
if __name__ == "__main__":
main() | K = int(input())
# 10桁までやれば十分
runrun_table = [[0 for _ in range(10)] for _ in range(10)]
# i桁のルンルン数の種類 <= 3**(i-1)*9
for i in range(10):
runrun_table[0][i] = 1
for keta in range(1, 10):
for i in range(10):
if i == 0:
runrun_table[keta][i] = runrun_table[keta - 1][i] + \
runrun_table[keta - 1][i + 1]
elif i == 9:
runrun_table[keta][i] = runrun_table[keta - 1][i - 1] + \
runrun_table[keta - 1][i]
else:
runrun_table[keta][i] = runrun_table[keta - 1][i - 1] + \
runrun_table[keta - 1][i] + \
runrun_table[keta - 1][i + 1]
keta = 0
ans = ''
while sum(runrun_table[keta][1:]) < K:
K -= sum(runrun_table[keta][1:])
keta += 1
for piv in range(1, 10):
if runrun_table[keta][piv] >= K:
ans += str(piv)
keta -= 1
break
K -= runrun_table[keta][piv]
while keta >= 0:
if piv == 0:
piv_range = [0, 1]
elif piv == 9:
piv_range = [8, 9]
else:
piv_range = range(piv-1, piv+2)
for piv in piv_range:
if runrun_table[keta][piv] >= K:
ans += str(piv)
keta -= 1
break
K -= runrun_table[keta][piv]
print(ans)
| 0 | null | 31,817,267,589,308 | 152 | 181 |
def main():
s, t = map(str, input().split(' '))
a, b = map(int, input().split())
u = str(input())
if u == s:
print(str(a - 1) + ' ' + str(b))
else:
print(str(a) + ' ' + str(b - 1))
main() | S , T = input().split()
A , B =map(int,input().split())
U = input()
mydict = {S:A, T:B}
mydict[U] -= 1
print ( str( mydict[S] ) + " " +str( mydict[T] ) )
| 1 | 71,632,514,806,622 | null | 220 | 220 |
import sys
sys.setrecursionlimit(1000000000)
from itertools import count
from collections import defaultdict
ii = lambda: int(input())
mis = lambda: map(int, input().split())
lmis = lambda: list(mis())
INF = float('inf')
def meg(f, ok, ng):
while abs(ok-ng)>1:
mid = (ok+ng)//2
if f(mid):
ok=mid
else:
ng=mid
return ok
#
def main():
N, K = mis()
A = [0] + lmis()
for i in range(1, len(A)):
A[i] = ((A[i] - 1) + A[i-1]) % K
#
C = defaultdict(int)
ans = 0
for i in range(len(A)):
if i >= K:
C[A[i-K]] -= 1
a = A[i]
ans += C[a]
C[a] += 1
print(ans)
main()
| import math
import collections
import itertools
import heapq
import sys
def main():
S = sys.stdin.readline()
if S[2] == S[3] and S[4] == S[5]:
print("Yes")
else:
print("No")
if __name__ == "__main__":
main() | 0 | null | 89,929,084,383,680 | 273 | 184 |
n, m, l = map(int, input().split())
mat_a = []
mat_b = []
for i in range(n):
mat_a.append(list(map(int, input().split())))
for j in range(m):
mat_b.append(list(map(int, input().split())))
for p in range(n):
mat_c = []
for q in range(l):
sum = 0
for r in range(m):
sum += mat_a[p][r] * mat_b[r][q]
mat_c.append(sum)
print(' '.join(map(str, mat_c)))
| n, m, l = map(int, input().split())
A = [list(map(int, input().split())) for i in range(n)]
B = [list(map(int, input().split())) for j in range(m)]
c = [[0] * l for i in range(n)]
for i in range(n):
for j in range(l):
for k in range(m):
c[i][j] += A[i][k] * B[k][j]
print(*c[i])
| 1 | 1,444,276,819,842 | null | 60 | 60 |
from sys import stdin, stdout
def main():
N = int(stdin.readline())
A = [0] + list(map(int, stdin.readline().rstrip().split()))
dp = [0] * (N+1)
prefix = [0] * (N+1)
dp[1], prefix[1] = 0, A[1]
for i in range(3, N, 2):
prefix[i] = prefix[i-2]+A[i]
for i in range(2, N+1):
if i & 1:
dp[i] = max(dp[i-1], A[i] + dp[i-2])
else:
dp[i] = max(dp[i-2] + A[i], prefix[i-1])
stdout.write(str(dp[N])+"\n")
main()
| from heapq import heappush, heappop, heapify
from collections import deque, defaultdict, Counter
import itertools
from itertools import permutations, combinations, accumulate
import sys
import bisect
import string
import math
import time
def I(): return int(input())
def S(): return input()
def MI(): return map(int, input().split())
def MS(): return map(str, 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 input(): return sys.stdin.readline().rstrip()
def make4(initial, L, M, N, O):
return [[[[initial for i in range(O)]
for n in range(N)]
for m in range(M)]
for l in range(L)]
def make3(initial, L, M, N):
return [[[initial for n in range(N)]
for m in range(M)]
for l in range(L)]
def debug(table, *args):
ret = []
for name, val in table.items():
if val in args:
ret.append('{}: {}'.format(name, val))
print(' | '.join(ret), file=sys.stderr)
yn = {False: 'No', True: 'Yes'}
YN = {False: 'NO', True: 'YES'}
MOD = 10**9+7
inf = float('inf')
IINF = 10**19
l_alp = string.ascii_lowercase
u_alp = string.ascii_uppercase
ts = time.time()
sys.setrecursionlimit(10**6)
nums = ['1', '2', '3', '4', '5', '6', '7', '8', '9', '10']
show_flg = False
# show_flg = True
def main():
N = I()
A = LI()
dp_use = [-IINF] * 3
dp_not_use = [-IINF] * 3
dp_not_use[0] = 0
for i in range(N):
dp_use_next = [-IINF] * 3
dp_not_use_next = [-IINF] * 3
for j in range(3):
if j - 1 >= 0:
dp_not_use_next[j] = max(dp_use[j], dp_not_use[j-1])
else:
dp_not_use_next[j] = dp_use[j]
dp_use_next[j] = dp_not_use[j] + A[i]
# print('dp_use ', *[a if a > -10**10 else '-IINF' for a in dp_use_next])
# print('dp_not_use', *[a if a > -10**10 else '-IINF' for a in dp_not_use_next])
dp_use = dp_use_next
dp_not_use = dp_not_use_next
if N % 2 == 0:
print(max(dp_use[1], dp_not_use[0]))
else:
print(max(dp_use[2], dp_not_use[1]))
if __name__ == '__main__':
main()
| 1 | 37,341,674,804,586 | null | 177 | 177 |
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, log2
from itertools import accumulate, permutations, combinations, product
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 = 10 ** 9 + 7
N = INT()
A = LIST()
n = max(A).bit_length()
cnt = [0]*n
for x in A:
for i, y in enumerate("{:b}".format(x).zfill(n)[::-1]):
if y == "1":
cnt[i] += 1
ans = 0
for i, c in enumerate(cnt):
bit_sum = (c*(N-c)%mod) * pow(2, i, mod) % mod
ans = (ans+bit_sum)%mod
print(ans)
| import sys
print('Yes' if len(set(sys.stdin.read().strip())) >= 2 else 'No') | 0 | null | 88,505,320,652,378 | 263 | 201 |
def main():
num = list(map(int,input().split()))
if num[0]>2*num[1]:
print(num[0]-2*num[1])
else:
print(0)
main() | N,M=map(int, input().split())
print(max(0,N-2*M)) | 1 | 166,260,392,455,630 | null | 291 | 291 |
from math import factorial as fac
x,y=map(int,input().split())
a=(2*y-x)/3
b=(2*x-y)/3
mod=10**9+7
if a>=0 and b>=0 and a==int(a) and b==int(b):
a=int(a)
b=int(b)
a1=1
a2=1
n3=10**9+7
for i in range(a):
a1*=a+b-i
a2*=i+1
a1%=n3
a2%=n3
a2=pow(a2,n3-2,n3)
print((a1*a2)%n3)
else:
print(0) | #####################################################
# 組み合わせを10**9+7で割った余り、を高速に求めるアルゴリズム
# https://drken1215.hatenablog.com/entry/2018/06/08/210000
# https://qiita.com/derodero24/items/91b6468e66923a87f39f
# 全然理解できていない
MOD = 10**9 + 7
def comb(n, r):
if (r < 0 and r > n):
return 0
r = min(r, n - r)
return g1[n] * g2[r] * g2[n - r] % MOD
N = 10**6
# 元テーブル
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)
#####################################################
X, Y = map(int, input().split())
# X+Yが3の倍数のマスしか通りえない
if not (X + Y) % 3:
# (1,2)移動をn回、(2,1)移動をm回したとする
# n+2m = X, 2n+m = Y
# → n+m = (X+Y)/3
# n = (2n+m)-(n+m) = X - (X+Y)/3 = (-X+2Y)/3
# mも同様
n = (2 * Y - X) // 3
m = (2 * X - Y) // 3
if n >= 0 and m >= 0:
print(comb(n + m, n))
else:
print(0)
# X+Yが3の倍数でない場合
else:
print(0)
| 1 | 150,036,293,707,300 | null | 281 | 281 |
s = input()
t = input()
a = len(s) - len(t) + 1
c1= 0
for i in range(a):
c2 = 0
for j in range(len(t)):
if s[i+j] == t[j]:
c2 += 1
else:
continue
c1 = max(c1,c2)
print(len(t)-c1)
| S = input()
T = input()
ans = len(S)
for i in range(len(S)-len(T)+1):
tmp = 0
for j in range(len(T)):
if S[i+j] != T[j]:
tmp += 1
ans = min(ans, tmp)
print(ans) | 1 | 3,710,426,835,850 | null | 82 | 82 |
import sys, heapq
from collections import defaultdict
from itertools import product, permutations, combinations
sys.setrecursionlimit(10**7)
def input():
return sys.stdin.readline()[:-1]
N, u, v = map(int, input().split())
def dijkstra_heap(s,edge):
#始点sから各頂点への最短距離
d = [10**20] * N
used = [True] * N #True:未確定
d[s] = 0
used[s] = False
edgelist = []
for a,b in edge[s]:
heapq.heappush(edgelist,a*(10**6)+b)
while len(edgelist):
minedge = heapq.heappop(edgelist)
#まだ使われてない頂点の中から最小の距離のものを探す
if not used[minedge%(10**6)]:
continue
v = minedge%(10**6)
d[v] = minedge//(10**6)
used[v] = False
for e in edge[v]:
if used[e[1]]:
heapq.heappush(edgelist,(e[0]+d[v])*(10**6)+e[1])
return d
AB = [list(map(int, input().split())) for _ in range(N-1)]
adjl = [[] for _ in range(N)]
for ab in AB:
a, b = ab[0]-1, ab[1]-1
adjl[a].append([1, b])
adjl[b].append([1, a])
du = dijkstra_heap(u-1, adjl)
dv = dijkstra_heap(v-1, adjl)
dOK = [j for i, j in zip(du, dv) if i < j]
print(int(max(dOK)-1))
| lists = list(map(int,input().split()))
print(lists.index(0)+1) | 0 | null | 65,183,143,398,870 | 259 | 126 |
#DISCO presents ディスカバリーチャンネル コードコンテス a
def get_money(num):
if num==3:
return 100000
elif num==2:
return 200000
elif num==1:
return 300000
else:
return 0
x,y=map(int,input().split())
money=get_money(x)+get_money(y)
if x==y and x==1:
money+=400000
print(money) | X, Y = map(int, input().split(" "))
d = {1: 300000, 2: 200000, 3: 100000}
ans = 0
ans += d.get(X, 0)
ans += d.get(Y, 0)
if X == 1 and Y == 1:
ans += 400000
print(ans)
| 1 | 141,033,429,933,760 | null | 275 | 275 |
from collections import deque
import itertools
h, w = map(int, input().split())
g = [input() for _ in range(h)]
# x,yはスタートの座標
def bfs(x, y):
# 最初は全て未訪問なので-1で初期化
d = [[-1] * w for _ in range(h)]
# スタート地点への距離は0
d[x][y] = 0
q = deque([(x, y)])
while q:
tx, ty = q.popleft()
# 右、上、左、下
for dx, dy in [(1, 0), (0, 1), (-1, 0), (0, -1)]:
nx, ny = tx + dx, ty + dy
# グリッドの範囲(縦方向, 横方向)内、通路(壁ではない)、未訪問(== -1)の場合
if 0 <= nx < h and 0 <= ny < w and g[nx][ny] == '.' and d[nx][ny] < 0:
d[nx][ny] = d[tx][ty] + 1
q.append((nx, ny))
# 最終的なdを平坦化して最大値を返す
return max(list(itertools.chain.from_iterable(d)))
# 全てのマスについて
max_count = 0
for x in range(h):
for y in range(w):
# スタートが通路であるかチェックする必要がある
if g[x][y] == ".":
max_count = max(max_count, bfs(x, y))
print(max_count)
| # ITP1_10_B
import math
a, b, c = map(float, input().split())
s = a * b * math.sin(math.radians(c)) / 2
l = a + b + math.sqrt(a**2 + b**2 - 2 * a * b * math.cos(math.radians(c)))
h = b * math.sin(math.radians(c))
print(s)
print(l)
print(h)
| 0 | null | 47,389,360,513,600 | 241 | 30 |
import sys
# import re
import math
import collections
# import decimal
import bisect
import itertools
import fractions
# import functools
import copy
import heapq
import decimal
# import statistics
import queue
# import numpy as np
# sys.setrecursionlimit(10000001)
INF = 10 ** 16
# MOD = 10 ** 9 + 7
MOD = 998244353
def ni(): return int(sys.stdin.readline())
def ns(): return map(int, sys.stdin.readline().split())
def na(): return list(map(int, sys.stdin.readline().split()))
# ===CODE===
class ModCombination:
# https://atcoder.jp/contests/abc167/submissions/13058694
# https://ikatakos.com/pot/programming_algorithm/number_theory/mod_combination
def __init__(self, maxN, MOD):
self._maxN = maxN
self._MOD = MOD
self.facts = [1]
self.invs = [1]*(self._maxN+1)
fact = 1
for i in range(1, self._maxN+1):
fact *= i
fact %= self._MOD
self.facts.append(fact)
inv = pow(fact, self._MOD-2, self._MOD)
self.invs[self._maxN] = inv
for i in range(self._maxN, 1, -1):
inv *= i
inv %= self._MOD
self.invs[i-1] = inv
def nCr(self, n, r):
return self.facts[n]*self.invs[r]*self.invs[n-r] % self._MOD
def main():
n, m, k = ns()
mc = ModCombination(n, MOD)
result = 0
for ki in range(k + 1):
ans = 1
ans *= m % MOD
ans *= pow(m - 1, n - 1 - ki, MOD)
ans %= MOD
ans *= mc.nCr(n-1, ki)
ans %= MOD
result += ans
result %= MOD
print(result)
if __name__ == '__main__':
main()
| N,M,K = map(int,input().split())
mod = 998244353
n = 200050
frac = [1]*(n+1)
finv = [1]*(n+1)
for i in range(n):
frac[i+1] = (i+1)*frac[i]%mod
finv[-1] = pow(frac[-1],mod-2,mod)
for i in range(1,n+1):
finv[n-i] = finv[n-i+1]*(n-i+1)%mod
def nCr(n,r):
if n<0 or r<0 or n<r: return 0
r = min(r,n-r)
return frac[n]*finv[n-r]*finv[r]%mod
# M* n-1Ck*1^k*(M-1)^(N-1-k)
ans = 0
for i in range(K+1):
tmp=(M*nCr(N-1,i))%mod
tmp*=pow(M-1,N-1-i,mod)
ans += tmp%mod
print(ans%mod) | 1 | 23,081,788,086,028 | null | 151 | 151 |
N, K = map(int, input().split())
ans = min(N - K*(N//K), K - (N - K*(N//K)))
print(ans) | # -*- coding:utf-8 -*-
N,K = map(int,input().split())
ans = N % K
if abs(ans - K) < ans:
ans = abs(ans - K)
print(ans) | 1 | 39,340,325,682,240 | null | 180 | 180 |
from collections import deque
def main():
n, m = map(int, input().split())
adj = [[] for _ in range(n)]
for _ in range(m):
a, b = map(int, input().split())
adj[a - 1].append(b - 1)
adj[b - 1].append(a - 1)
ans = 0
visited = [False] * n
for i in range(n):
if visited[i]:
continue
q = deque()
q.append(i)
cnt = 1
visited[i] = True
while q:
u = q.popleft()
for v in adj[u]:
if not visited[v]:
q.append(v)
cnt += 1
visited[v] = True
ans = max(ans, cnt)
print(ans)
if __name__ == "__main__":
main()
| import sys
readline = sys.stdin.readline
N,X,M = map(int,readline().split())
nex = [(i ** 2) % M for i in range(M)]
cum = [i for i in range(M)]
ans = 0
while N:
if N & 1:
ans += cum[X]
X = nex[X]
cum = [cum[i] + cum[nex[i]] for i in range(M)]
nex = [nex[nex[i]] for i in range(M)]
N >>= 1
print(ans) | 0 | null | 3,436,024,217,092 | 84 | 75 |
print('1,1,1,2,1,2,1,5,2,2,1,5,1,2,1,14,1,5,1,5,2,2,1,15,2,2,5,4,1,4,1,51'.split(',')[int(input())-1]) | k = int(input())
s = "1,1,1,2,1,2,1,5,2,2,1,5,1,2,1,14,1,5,1,5,2,2,1,15,2,2,5,4,1,4,1,51"
l =s.split(",")
print(l[k-1]) | 1 | 49,855,749,115,480 | null | 195 | 195 |
def main():
n = int(input())
t = (n+1) // 2
if n == 1:
print(1)
elif n % 2 == 0:
print(0.5)
else:
print(t*1.0 / n)
main() | n,m = map(int,input().split())
graph = [[] for i in range(n)]
for i in range(m):
a,b = map(lambda z:int(z)-1,input().split())
graph[a].append(b)
graph[b].append(a)
size = [0 for i in range(n)]
check = [True for i in range(n)]
for i in range(n):
if check[i]:
tmp = 1
stack = [i]
check[i] = False
while stack:
now = stack.pop()
size[now] = tmp
tmp+=1
for to in graph[now]:
if check[to]:
check[to] = False
stack.append(to)
print(max(size))
| 0 | null | 90,258,090,881,170 | 297 | 84 |
print("A" if input().isupper() else "a") | print('a' if input() >= 'a' else 'A')
| 1 | 11,277,659,596,422 | null | 119 | 119 |
import sys,math
def solve():
a = float(input())
print(a**2*math.pi ,a*2*math.pi)
solve()
| n=int(input())
ans="No"
for i in range(1,10):
for j in range(1,10):
if n==i*j:
ans="Yes"
break
else:
continue
break
print(ans) | 0 | null | 80,149,848,414,368 | 46 | 287 |
S = str(input())
r = len(S)
print('x'*r) | import sys
#import time
from collections import deque, Counter, defaultdict
#from fractions import gcd
import bisect
import heapq
#import math
import itertools
import numpy as np
input = sys.stdin.readline
sys.setrecursionlimit(10**8)
inf = 10**18
MOD = 1000000007
ri = lambda : int(input())
rs = lambda : input().strip()
rl = lambda : list(map(int, input().split()))
k = ri()
reses=[]
cnt = 1
tmp = 7
for i in range(k+1):
res = tmp % k
if res==0:
print(cnt)
sys.exit(0)
tmp = res * 10 + 7
cnt += 1
print(-1) | 0 | null | 39,483,361,923,192 | 221 | 97 |
import re
N = int(input())
S = input()
result = ''
for i in range(len(S)):
if i == len(S) - 1:
result += S[i]
elif S[i] != S[i+1]:
result += S[i]
print(len(result))
| H,N = map(int,input().split())
a = list(map(int,input().split()))
a.sort()
reversed(a)
flag = True
for i in range(N):
H-=a[i]
if H<=0:
flag = False
print('Yes')
break
if flag == True:
print('No') | 0 | null | 124,295,683,797,308 | 293 | 226 |
n = int(input())
l = sorted(list(map(int, input().split())))
ans = 0
import bisect
for i in range(n-2):
for j in range(i+1, n-1):
ab = l[i]+l[j]
idx = bisect.bisect_left(l, ab)
ans += max(0, idx-j-1)
print(ans) | N = int(input())
L = list(map(int, input().split()))
L.sort(reverse=True)
ans = 0
for i in range(N-2):
for j in range(i+1, N-1):
ok = i
ng = N
while ng - ok > 1:
mid = (ok + ng) // 2
if L[mid] > L[i] - L[j]:
ok = mid
else:
ng = mid
if ok > j:
ans += ok - j
print(ans)
| 1 | 171,514,850,587,908 | null | 294 | 294 |
heap = []
while True:
try:
n = int(raw_input())
if len(heap) == 0:
heap.append(n)
elif len(heap) == 1:
if n <= heap[0]:
heap.append(n)
else:
heap.insert(0, n)
elif len(heap) == 2:
if n > heap[0]:
heap.insert(0, n)
elif n <= heap[1]:
heap.append(n)
else:
heap.insert(1, n)
elif n > heap[2]:
if n >= heap[0]:
heap.insert(0, n)
elif n >= heap[1]:
heap.insert(1, n)
else:
heap.insert(2, n)
heap.pop()
except (EOFError):
break
for num in heap:
print num | n = 0
list = []
while n < 10:
x = int(input())
list.append(x)
n += 1
list.sort()
print(list[9])
print(list[8])
print(list[7]) | 1 | 24,179,132 | null | 2 | 2 |
N=int(input())
X=input()
c=X.count('1')
r1=int(X,2)%(c-1) if c>1 else 0
r2=int(X,2)%(c+1)
d=[0]*(N+1)
for i in range(N):
d[i+1]=d[(i+1)%bin(i+1).count('1')]+1
for i in range(N):
if X[i]=='0':
n=(r2+pow(2,N-i-1,c+1))%(c+1)
else:
if c==1:
print(0)
continue
n=(r1-pow(2,N-i-1,c-1))%(c-1)
print(d[n]+1) | #import sys
#import numpy as np
import math
#from fractions import Fraction
import itertools
from collections import deque
from collections import Counter
#import heapq
#from fractions import gcd
#input=sys.stdin.readline
import bisect
n=int(input())
x=input()
p=0
for i in x:
if i=="1":
p+=1
rp=0
rq=0
for i in range(n):
if x[i]=="1":
rp+=pow(2,(n-1-i),p+1)
rp%=p+1
if p!=1:
rq+=pow(2,(n-1-i),p-1)
rq%=p-1
else:
rq=pow(2,(n-1-i))
def popcnt1(n):
return bin(n).count("1")
res=[0]*n
for i in range(1,n+1):
res[i-1]=i%popcnt1(i)
for i in range(n):
ans=0
if x[i]=="1":
if p==1:
print(0)
continue
q=rq-pow(2,(n-1-i),p-1)
q%=p-1
while True:
if q==0:
print(1+ans)
break
ans+=1
q=res[q-1]
else:
q=rp+pow(2,(n-1-i),p+1)
q%=p+1
while True:
if q==0:
print(1+ans)
break
ans+=1
q=res[q-1] | 1 | 8,282,977,504,260 | null | 107 | 107 |
m=f=r=0
while 1:
m,f,r=map(int,input().split())
x=m+f
if m==f==r==-1:break
elif m==-1 or f==-1 or x<30:print('F')
elif x>=80:print('A')
elif 65<=x<80:print('B')
elif 50<=x<65 or r>=50:print('C')
else:print('D') | """
9 5
-4 -3 -2 -1 0 1 2 3
"""
N,K = map(int,input().split())
A = list(map(int,input().split()))
A.sort()
Am = []
Ap = []
for a in A:
if a < 0:
Am.append(a)
else:
Ap.append(a)
mod = 10**9 + 7
ans = 1
if N == K:
for a in A:
ans *= a
ans %= mod
elif A[-1] < 0:
if K % 2 == 1:
for i in range(K):
ans *= Am[-1-i]
ans %= mod
else:
for i in range(K):
ans *= Am[i]
ans %= mod
else:
if K%2 == 1:
ans *= Ap[-1]
ans %= mod
K -= 1
del Ap[-1]
Amd = []
Apd = []
for i in range(len(Ap)//2):
Apd.append(Ap[-1-(2*i)]*Ap[-1-(2*i+1)])
for i in range(len(Am)//2):
Amd.append(Am[2*i]*Am[2*i+1])
Apd.append(-1)
Amd.append(-1)
ip = 0
im = 0
while K > 0:
if Apd[ip] >= Amd[im]:
ans *= Apd[ip]
ip += 1
else:
ans *= Amd[im]
im += 1
ans %= mod
K -= 2
ans %= mod
print(ans)
| 0 | null | 5,315,308,710,588 | 57 | 112 |
case_num = 1
while True:
tmp_num = int(input())
if tmp_num == 0:
break
else:
print("Case %d: %d" % (case_num,tmp_num))
case_num += 1
| [a,b] = raw_input().split(' ')
print int(a)*int(b), (int(a) + int(b)) * 2 | 0 | null | 404,424,031,450 | 42 | 36 |
for i in range(1,10001):
n = int(input())
if n:
print(f'Case {i}: {n}')
| i = 1
while True :
x = input()
if (x == 0) :
exit()
print "Case %d: %d" % (i, x)
i += 1 | 1 | 473,664,308,878 | null | 42 | 42 |
H1, M1, H2, M2, K = map(int, input().split())
s = 60 * H1 + M1
e = 60 * H2 + M2
ans = max(0, e - s - K)
print(ans)
| n,m = (int(i) for i in input().split())
array = [[int(i) for i in input().split()] for i in range(n)]
b = [int(input()) for i in range(m)]
for i in range(n):
ans = 0
for i2 in range(m):
ans += array[i][i2]*b[i2]
print(ans) | 0 | null | 9,702,071,445,980 | 139 | 56 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.