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
|
|---|---|---|---|---|---|---|
if __name__ == '__main__':
s = input()
q = int(input())
for i in range(q):
code = input().split()
op, a, b = code[0], int(code[1]), int(code[2])
if op == 'print':
print(s[a:b+1])
elif op == 'reverse':
s = s[:a] + s[a:b+1][::-1] + s[b+1:]
elif op == 'replace':
s = s[:a] + code[3] + s[b+1:] | str = raw_input()
q = input()
for ans in range(q):
ans = raw_input()
ans1 = ans.split(' ')
if ans1[0] == 'replace':
str = str[0:int(ans1[1])]+ans1[3]+ str[int(ans1[2])+1:len(str)]
if ans1[0] == 'reverse':
str = str[0:int(ans1[1])]+ str[int(ans1[1]):int(ans1[2])+1][::-1] + str[int(ans1[2])+1:len(str)]
if ans1[0] == 'print':
print str[int(ans1[1]):int(ans1[2])+1] | 1 | 2,114,377,800,638 | null | 68 | 68 |
#input
K = int(input())
S = str(input())
#output
# (o以外) o (o以外) o (f以外) f (何でも)
#こちらもmodで割った余り。maxが決まっていて、大きくない時はこちらが早い。
mod = pow(10, 9) + 7
n_ = 5 * pow(10, 6)
fun = [1] * (n_+1)
for i in range(1, n_+1):
fun[i] = fun[i-1] * i % mod
rev = [1] * (n_+1)
rev[n_] = pow(fun[n_], mod-2, mod)
for i in range(n_-1, 0, -1):
rev[i] = rev[i+1] * (i+1) % mod
def cmb(n,r):
if n < 0 or r < 0 or r > n: return 0
return fun[n] * rev[r] % mod * rev[n-r] % mod
#重複組み合わせはH(n, r) = cmb(n+r-1, r)
L = len(S)
answer = 0
for i in range(K+1):
answer += pow(25, i, mod) * pow(26, K-i, mod) * cmb(L-1+i, i)
answer %= mod
print(answer) | MAXN = 2*10**6+2
p = 10**9 + 7
fact = [1] * MAXN
invfact = [1] * MAXN
for i in range(1, MAXN):
fact[i] = fact[i-1] * i % p
invfact[MAXN-1] = pow(fact[MAXN-1], p-2, p)
for i in range(MAXN-1, 0, -1):
invfact[i-1] = invfact[i] * i % p
def nCk(n, k):
return fact[n] * invfact[n-k] * invfact[k] % p
K = int(input())
N = len(input())
ans = 0
for i in range(N, N+K+1):
ans += pow(25, i-N, p) * nCk(i-1, N-1) * pow(26, N+K-i, p) % p
ans %= p
print(ans)
| 1 | 12,782,871,138,348 | null | 124 | 124 |
N, K, C = map(int, input().split())
S = input()
must = set()
i = len(S)+C
for j in range(K):
i = S.rindex("o", 0, i-C)
must.add(i)
if i<=C or "o" not in S[:i-C]:
i = -C-1
for j in range(K):
i = S.index("o", i+C+1)
if i in must:
print(i+1) | N,K,C = map(int,input().split())
S = list(input())
F = []
maru = 0
last = -10**9
span = C
for i in range(N):
if S[i]=="o" and span >= C:
maru += 1
last = i
F.append([maru,last])
span = 0
else:
span += 1
F.append([maru,last])
#print(F)
s = S[::-1]
maru = 0
last = 10**9
span = C
E = []
for i in range(N):
if s[i] == "o" and span >= C:
maru += 1
last = N-1-i
E.append([maru,last])
span = 0
else:
E.append([maru,last])
span += 1
E = E[::-1]
#print(E)
F = [[0,-10**9]] + F + [[0,10**9]]
E = [[0,-10**9]] + E + [[0,10**9]]
#print(F)
#print(E)
ans = []
for i in range(1,N+1):
cnt = F[i-1][0] + E[i+1][0]
if S[i-1] == "o":
if E[i+1][1] - F[i-1][1] < C:
cnt -= 1
if cnt == K-1:
ans.append(i)
#print(F[i-1],E[i+1],cnt)
for i in range(len(ans)):
print(ans[i]) | 1 | 40,367,275,027,652 | null | 182 | 182 |
R,C,k = map(int,input().split())
dp1 = [[0]*(C+1) for i in range(R+1)]
dp2 = [[0]*(C+1) for i in range(R+1)]
dp3 = [[0]*(C+1) for i in range(R+1)]
item = [[0]*(C+1) for i in range(R+1)]
for i in range(k):
r,c,v = map(int,input().split())
dp1[r][c] = v
for i in range(1,R+1):
for j in range(1,C+1):
a = dp1[i][j]
dp3[i][j] = max(dp2[i][j-1]+a,dp3[i][j-1])
dp2[i][j] = max(dp1[i][j-1]+a,dp2[i][j-1])
dp1[i][j] = max(dp1[i-1][j]+a,dp2[i-1][j]+a,dp3[i-1][j]+a,dp1[i][j-1],a)
print(max(dp1[R][C],dp2[R][C],dp3[R][C])) | import sys
import copy
R, C, K = map(int, input().split())
item = [[0] * (C + 1) for _ in range(R + 1)] # dp配列と合わせるために, 0行目, 0列目を追加している.
for s in sys.stdin.readlines():
r, c, v = map(int, s.split())
r -= 1
c -= 1
item[r][c] = v
dp0 = [[0] * (C+1) for r in range(R+1)]
dp1 = [[0] * (C+1) for r in range(R+1)]
dp2 = [[0] * (C+1) for r in range(R+1)]
dp3 = [[0] * (C+1) for r in range(R+1)]
for r in range(R):
for c in range(C):
dp3[r][c] = max(dp3[r][c], dp2[r][c] + item[r][c])
dp2[r][c] = max(dp2[r][c], dp1[r][c] + item[r][c])
dp1[r][c] = max(dp1[r][c], dp0[r][c] + item[r][c])
dp1[r][c+1] = max(dp1[r][c], dp1[r][c+1])
dp2[r][c+1] = max(dp2[r][c], dp2[r][c+1])
dp3[r][c+1] = max(dp3[r][c], dp3[r][c+1])
dp0[r+1][c] = max(dp0[r+1][c], dp1[r][c])
dp0[r+1][c] = max(dp0[r+1][c], dp2[r][c])
dp0[r+1][c] = max(dp0[r+1][c], dp3[r][c])
ans = max(dp0[R-1][C-1], dp1[R-1][C-1])
ans = max(ans, dp3[R-1][C-1])
ans = max(ans, dp2[R-1][C-1])
print(ans) | 1 | 5,606,447,442,600 | null | 94 | 94 |
inp = [int(input()) for i in range(10)]
m1, m2, m3 = 0, 0, 0
for h in inp:
if(h > m1):
m3 = m2
m2 = m1
m1 = h
elif(h > m2):
m3 = m2
m2 = h
elif(h > m3):
m3 = h
print(m1)
print(m2)
print(m3) | 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()
| 0 | null | 457,070,478,048 | 2 | 52 |
n = int(input())
p = list("zabcdefghijklmnopqrstuvwxy")
num = ""
while n > 26:
a = p[n % 26]
num += a
if n % 26 == 0:
n = n // 26 - 1
else:
n = n // 26
num += p[n%26]
new_num = num[::-1]
print(new_num)
| import sys
readline = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)
def main():
A = list(map(int, readline().split()))
if sum(A) >= 22:
print("bust")
else:
print("win")
if __name__ == '__main__':
main()
| 0 | null | 65,172,775,465,390 | 121 | 260 |
import itertools as it
import math
def Dist (x1,y1,x2,y2):
dis = (x2 - x1)**2 + (y2 - y1)**2
return math.sqrt(dis)
N = int(input())
Pos = []
res = 0
for i in range(N):
pos = list(map(int,input().split()))
Pos.append(pos)
array = list(it.permutations(i for i in range(N)))
for i in range(math.factorial(N)):
for j in range(N-1):
res += Dist(Pos[array[i][j]][0],Pos[array[i][j]][1],Pos[array[i][j+1]][0],Pos[array[i][j+1]][1])
print(res / math.factorial(N)) | import bisect,collections,copy,heapq,itertools,math,string
import sys
def S(): return sys.stdin.readline().rstrip()
def M(): return map(int,sys.stdin.readline().rstrip().split())
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LS(): return list(sys.stdin.readline().rstrip().split())
n, m = M()
print(n*(n-1)//2 + m*(m-1)//2) | 0 | null | 97,178,986,481,476 | 280 | 189 |
while True:
h=[]
S=input()
if S=="-":
break
m=int(input())
for i in range(m):
h=int(input())
if len(S)==h:
pass
else:
S=S[h:]+S[:h]
print(S) | def main():
while True:
strDeck = input()
if strDeck == "-":
break
else:
intTime = int(input())
intNum = 0
for _ in range(intTime):
intNum += int(input())
intLenDeck = len(strDeck)
intShuffle = intNum % intLenDeck
print(strDeck[intShuffle:]+strDeck[:intShuffle])
if __name__ == '__main__':
main()
| 1 | 1,905,239,859,952 | null | 66 | 66 |
#!/usr/bin/env python3
def pow(N,R,mod):
ans = 1
i = 0
while((R>>i)>0):
if (R>>i)&1:
ans *= N
ans %= mod
N = (N*N)%mod
i += 1
return ans%mod
def main():
N,K = map(int,input().split())
li = [0 for _ in range(K)]
mod = 10**9+7
ans = 0
for i in range(K,0,-1):
mm = K//i
mm = pow(mm,N,mod)
for j in range(2,(K//i)+1):
mm -= li[i*j-1]
li[i-1] = mm
ans += (i*mm)%mod
ans %= mod
print(ans)
if __name__ == '__main__':
main()
| cnt = [0 for i in range (26)]
alphabet = 'abcdefghijklmnopqrstuvwxyz'
str = open(0).read()
for x in str:
for k in range(len(alphabet)):
if x == alphabet[k] or x == alphabet[k].upper():
cnt[k] = cnt[k] + 1
break
for i in range(26):
print(alphabet[i], ':', cnt[i])
| 0 | null | 19,182,846,142,162 | 176 | 63 |
a, b, c = map(int, input().split())
k = int(input())
while a >= b and k > 0:
b = b*2
k = k-1
while b >= c and k > 0:
c = c*2
k = k-1
if a < b < c:
print('Yes')
else:
print('No') | import os
import sys
from collections import defaultdict, Counter
from itertools import product, permutations,combinations, accumulate
from operator import itemgetter
from bisect import bisect_left,bisect
from heapq import heappop,heappush,heapify
from math import ceil, floor, sqrt
from copy import deepcopy
def main():
a,b,c = map(int, input().split())
k = int(input())
flag = False
if a < b < c:
print("Yes")
sys.exit()
for i in range(k):
if a < b < c:
c *= 2
if a >= b:
if b >= c:
c *= 2
else:
b *= 2
else:
if b >= c:
c *= 2
else:
b *= 2
if a < b < c:
print("Yes")
else:
print("No")
if __name__ == '__main__':
main()
| 1 | 6,855,881,198,208 | null | 101 | 101 |
import sys
def LI(): return list(map(int,sys.stdin.readline().rstrip().split())) #空白あり
N,K = LI()
A = LI()
for i in range(N):
A[i] -= 1
B = [0] # Aの累積和をKで割ったもの
for i in range(N):
B.append((B[-1]+A[i]) % K)
from collections import defaultdict
# 要素の個数がKを超えないことに注意
if N < K:
d = defaultdict(int)
for n in B:
d[n] += 1
ans = 0
for n in d.keys():
m = d[n]
ans += m*(m-1)//2
print(ans)
else:
d = defaultdict(int)
ans = 0
for i in range(N): # A[i]から始まる部分列を考える
if i == 0:
for j in range(K):
d[B[j]] += 1
ans += d[B[i]]-1
elif i <= N-K+1:
d[B[K+i-1]] += 1
d[B[i-1]] -= 1
ans += d[B[i]]-1
else:
d[B[i-1]] -= 1
ans += d[B[i]]-1
print(ans)
| n,k = map(int,input().split())
s = 0
for i in range(k,n+2):
s += i*(n*2+1-i)//2 - i*(i-1)//2 + 1
print(s%1000000007)
| 0 | null | 85,058,157,995,360 | 273 | 170 |
N, R = (int(x) for x in input().split())
if N > 9:
print(R)
else:
print(R + (100 * (10 - N))) | import math
a,b,c,d = map(int,input().split(" "))
taka = math.ceil(c/b)
aoki = math.ceil(a/d)
if taka <= aoki:
print("Yes")
else:
print("No") | 0 | null | 46,654,410,597,620 | 211 | 164 |
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)
| n,m,l = [int(x) for x in input().split()]
A = [[int(x) for x in input().split()] for _ in range(n)]
B = [[int(x) for x in input().split()] for _ in range(m)]
ans = []
for i in range(n):
blocks = []
for j in range(l):
block = 0
for k in range(m):
block += A[i][k]*B[k][j]
blocks.append(block)
ans.append(blocks)
for _ in ans:
print(*_)
| 0 | null | 88,877,435,109,600 | 297 | 60 |
import numpy as np
def min_steps_v2(n, a, b):
n = np.int64(n)
a = np.int64(a)
b = np.int64(b)
if (b - a) % 2 == 0:
return np.int64(int(b - a) // 2)
# odd case
a_diff = a - 1
b_diff = n - b
if a_diff > b_diff:
steps_to_even = n - b + 1
remain_steps = min_steps_v2(n, a + (n - b) + 1, n)
else:
steps_to_even = a
remain_steps = min_steps_v2(n, 1, b - a)
return steps_to_even + remain_steps
numbers = input().split(' ')
n = int(numbers[0])
a = int(numbers[1])
b = int(numbers[2])
print(min_steps_v2(n, a, b))
| li =[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]
a=int(input())
a-=1
print(li[a])
| 0 | null | 79,561,591,415,900 | 253 | 195 |
N,M = (int(a) for a in input().split())
x = N*(N-1)/2
y = M*(M-1)/2
print(int(x+y)) | # coding: utf-8
# Your code here!
def check(P):
i = 0
for j in range(k):
s = 0
while s + T[i] <= P:
s += T[i]
i += 1
if i == n:
return n
return i
def solve():
left = 0
right = 100000 * 10000
mid = 0
while right - left > 1:
mid = (left + right) // 2
v = check(mid)
if v >= n:
right = mid
else:
left = mid
return right
tmp = list(map(int, input().split()))
n = tmp[0]
k = tmp[1]
T = []
for i in range(n):
T.append(int(input()))
ans = solve()
print(ans)
| 0 | null | 22,839,842,240,358 | 189 | 24 |
def main():
n = int(input())
l = list(map(int, input().split()))
if 0 in l:
print(0)
return
prod = 1
for i in l:
prod *= i
if prod > 1000000000000000000:
print(-1)
return
print(prod)
if __name__ == '__main__':
main() | N = int(input())
AS = [int(i) for i in input().split()]
m = 10 ** 18
acc = 1
if 0 in AS:
print(0)
import sys
sys.exit()
for i in AS:
acc *= i
if acc > m:
print('-1')
import sys
sys.exit()
print(acc)
| 1 | 16,289,734,514,240 | null | 134 | 134 |
def Bfun():
vals = [int(i) for i in input().split()]
a = vals[0]
b = vals[1]
c = vals[2]
d = vals[3]
res2 = a//d + (1 if(a % d > 0) else 0)
res1 = c//b + (1 if(c % b > 0) else 0)
res = "Yes" if(res1 <= res2) else "No"
print(res)
Bfun() | n = int(input())
s = list(map(int, input().split()))
q = int(input())
t = list(map(int, input().split()))
count = 0
for item in t:
if item in s:
count += 1
print(count) | 0 | null | 14,834,481,513,632 | 164 | 22 |
def main():
n = int(input())
a = list(map(lambda i:int(i)-1, input().split(" ")))
d = {}
for i in range(n):
d[i]=0
for i in range(n-1):
d[a[i]] += 1
for i in range(n):
print(d[i])
if __name__ == "__main__":
main() | N = int(input())
A_lis = list(map(int,input().split()))
ls = [0] * N
for i in range(N-1):
ls[A_lis[i]-1] += 1
for a in ls:
print(a) | 1 | 32,523,781,624,380 | null | 169 | 169 |
x,y = map(int,input().split())
ans = 0
for i in [x,y]:
if i==3:ans+=100000
elif i==2:ans+=200000
elif i==1:ans+=300000
if x==y==1:
ans += 400000
print(ans) | x, y = map(int, input().split())
ans = 0
for i in [x, y]:
if i <= 3:
ans += 4 - i
if x == 1 and y == 1:
ans += 4
print(ans * 100000) | 1 | 140,307,524,349,662 | null | 275 | 275 |
import math
x = float(input())
print("%.6f %.6f"%(x*x*math.pi, x*2*math.pi))
| c = 0
while True:
x = int(input())
if x == 0:
break;
c += 1
print('Case', str(c) + ':', x) | 0 | null | 577,164,696,092 | 46 | 42 |
n = input()
c = input()
i = 0
while 1:
l = c.find('W')
r = c.rfind('R')
if l == -1 or r == -1 or l >= r:
break
c = c[:l] + 'R' + c[l + 1:r] + 'W' + c[r + 1:]
i += 1
print(i)
| n = int(input())
C = list(input())
if "R" not in C:
print(0)
exit()
W = C.count("W")
R = C.count("R")
w = 0
r = R
ans = float('inf')
for c in C:
if c == "W":
w += 1
else:
r -= 1
ans = min(ans, max(w, r))
print(ans) | 1 | 6,284,044,032,992 | null | 98 | 98 |
#10_B
import math
a,b,C=map(int,input().split())
S=a*b*math.sin((C*2*math.pi)/360)/2
c=math.sqrt(a**2+b**2-2*a*b*math.cos((C*2*math.pi)/360))
L=a+b+c
h=2*float(S)/a
print(str(S)+'\n'+str(L)+'\n'+str(h)+'\n')
| s=input()
si=s[::-1]
a=s[:(len(s)-1)//2]
b=s[(len(s)+1)//2:]
if s == si :
if a == a[::-1] and b == b[::-1]:
print(("Yes"))
exit()
print("No") | 0 | null | 23,066,928,975,244 | 30 | 190 |
n = int(input())
R = (int(input()) for _ in range(n))
ret = -(10 ** 9)
mn = next(R)
for r in R:
ret = max(ret, r - mn)
mn = min(mn, r)
print(ret) | n = int(input())
maximum_profit = -10**9
r0 = int(input())
r_min = r0
for i in range(1, n):
r1 = int(input())
if r0 < r_min:
r_min = r0
profit = r1 - r_min
if profit > maximum_profit:
maximum_profit = profit
r0 = r1
print(maximum_profit) | 1 | 12,347,689,290 | null | 13 | 13 |
l = [x+' '+y for x in ['S','H','C','D'] for y in [str(i) for i in range(1,14)]]
n = int(input())
while n > 0:
l.remove(input())
n -= 1
for i in l:
print(i) | # coding: UTF-8
n = input()
for n in range(n):
inputs = map(int,raw_input().split())
if inputs[0]**2 == inputs[1]**2 + inputs[2]**2 or\
inputs[1]**2 == inputs[0]**2 + inputs[2]**2 or\
inputs[2]**2 == inputs[0]**2 + inputs[1]**2:
print "YES"
else:
print "NO" | 0 | null | 523,614,020,028 | 54 | 4 |
r=input().split()
N=int(r[0])
d_pre=input().split()
d=[int(s) for s in d_pre]
ans=N-sum(d)
if ans>=0:
print(ans)
else:
print(-1) | N,M=map(int,input().split())
pos=[]
for i in range(M):
array=list(map(int,input().split()))
pos.append(array)
flg=True
num=[-1 for i in range(N)]
for i in range(M):
if num[pos[i][0]-1]==-1 or num[pos[i][0]-1]==pos[i][1]:
if pos[i][0]-1!=0 or pos[i][1]!=0:
num[pos[i][0]-1]=pos[i][1]
else:
if N==1:
num[pos[i][0]-1]=pos[i][1]
else:
flg=False
else:
flg=False
for i in range(len(num)):
if num[i]==-1:
if i==0:
if N==1:
num[i]=0
else:
num[i]=1
else:
num[i]=0
ans=0
for i in range(N):
ans+=num[i]*10**(N-i-1)
if flg:
print(ans)
else:
print("-1") | 0 | null | 46,352,284,956,262 | 168 | 208 |
s = list(map(int,input().split()))
h = 60 * (s[2]-s[0])
m = s[3] - s[1]
k = s[4]
print(h+m-k) | a,b,c = map (int,input().split())
if b < a :
a , b = b , a
if c < a :
a , c = c , a
if c < b :
b , c = c , b
print(a,b,c)
| 0 | null | 9,332,574,801,100 | 139 | 40 |
print("Yes" if "7" in list(input()) else "No") | n = list(input())
if '7' in n:
print('Yes')
else:
print('No')
| 1 | 34,143,743,052,900 | null | 172 | 172 |
k = int(input())
ans = 0
def gcd(a,b):
if a % b == 0:
return b
c = a % b
return gcd(b,c)
for l in range(1,k+1):
for m in range(l,k+1):
for n in range(m,k+1):
tmp1 = gcd(l,n)
tmp2= gcd(tmp1,m)
if (l==m==n):
ans+=tmp2
elif(l==m or m==n):
ans+= 3*tmp2
else:
ans += 6*tmp2
print(ans) | n,k=map(int,input().split())
while n>k:
n=n%k
if n>k//2:
n=abs(n-k)
print(n) | 0 | null | 37,266,199,634,158 | 174 | 180 |
import sys
import numpy as np
n, k = map(int,input().split())
a = np.array(sorted(list(map(int, input().split()))))
f = np.array(sorted(list(map(int, input().split())), reverse=True))
asum = a.sum()
l,r = 0, 10**13
while l != r:
mid = (l+r)//2
can = (asum - np.minimum(mid//f, a).sum()) <= k
if can:
r = mid
else:
l = mid +1
print(l) | def main():
import numpy as np
n, k = map(int, input().split())
aa = np.array(sorted(list(map(int, input().split()))), dtype=np.int64)
f = np.array(sorted(list(map(int, input().split())),
reverse=True), dtype=np.int64)
a = 0
b = 10**12+10
while a+1 < b:
med = (a+b)//2
if np.sum(np.maximum(aa-med//f, np.zeros(n, dtype=np.int64))) > k:
a = med+1
else:
b = med
if a == b:
print(a)
else:
if np.sum(np.maximum(aa-a//f, np.zeros(n, dtype=np.int64))) > k:
print(b)
else:
print(a)
main()
| 1 | 165,046,189,348,378 | null | 290 | 290 |
a,b = map(int,input().split())
astart, aend = int(a//0.08+1), int((a+1)//0.08) #[astart, aend)
bstart, bend = int(b//0.10+1), int((b+1)//0.10)
alst = set(range(astart,aend))
blst = set(range(bstart,bend))
share = alst & blst
if len(share) == 0:
print(-1)
else:
print(list(share)[0]) | import math
a,b=map(int,input().split())
ast=math.ceil(a*12.5)
aend=math.ceil((a+1)*12.5)-1
bst=b*10
bend=(b+1)*10-1
flag=0
for i in range(bst,bend+1):
if ast<=i<=aend:
print(i)
flag=1
break
if flag==0:
print(-1) | 1 | 56,527,993,073,828 | null | 203 | 203 |
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)) | while True:
i,e,r = map(int,raw_input().split())
if i == e == r == -1:
break
if i == -1 or e == -1 :
print 'F'
elif i+e >= 80 :
print 'A'
elif i+e >= 65 :
print 'B'
elif i+e >= 50 :
print 'C'
elif i+e >= 30 :
if r >= 50 :
print 'C'
else :
print 'D'
else :
print 'F' | 1 | 1,229,636,737,318 | null | 57 | 57 |
'''
l = input().split()
l = list(map(int, l))
a,b,c = l[0],l[1],l[2]
'''
a,b,c = map(int, input().split())
if a > b:
a,b = b,a
if b > c:
b,c = c,b
if a > b:
a,b = b,a
print(a,b,c)
| def main():
A = int(input())
B = int(input())
ans = 6 - A - B
print(ans)
if __name__ == "__main__":
main()
| 0 | null | 55,845,327,556,420 | 40 | 254 |
N,M = map(int,input().split())
home = list(map(int,input().split()))
if N - sum(home) < 0:
print("-1")
else:
print(N - sum(home)) | N=int(input())
D=[{} for _ in range(N+1)]
for i in range(1,N+1):
A=int(input())
for k in range(A):
p,x=map(int,input().split())
D[i][p]=x
Max=0
for x in range(2**N):
y=x
B=["*"]*(N+1)
for i in range(N):
B[i+1]=y%2
y>>=1
Flag=True
for i in range(1,N+1):
if B[i]==1:
for k in D[i]:
Flag&=(B[k]==D[i][k])
if Flag:
Max=max(Max,B.count(1))
print(Max)
| 0 | null | 76,693,343,965,810 | 168 | 262 |
n = int(input())
#lis = list(map(int,input().split()))
for i in range(1,10):
q = n // i
r = n % i
if r == 0 and q < 10:
print("Yes")
exit()
print("No") | N=int(input())
for num in range(1,10):
if (N/num).is_integer() and 1<=(N/num)<=9:
print("Yes")
break
else:
print("No") | 1 | 159,352,647,488,400 | null | 287 | 287 |
n, m, k = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
a_rui = [0]
b_rui = [0]
counta = 0
countb = 0
for i in range(n):
a_rui.append(a_rui[i]+a[i])
if a_rui[i+1] <= k:
counta = i+1
for i in range(m):
b_rui.append(b_rui[i]+b[i])
if b_rui[i] <= k:
countb = i+1
# print(counta, countb)
# print(a_rui, b_rui)
ans = 0
for i in range(counta+1):
# print("DFGHj")
# print(i, countb)
while a_rui[i]+b_rui[countb] > k:
# print(a_rui[i]+b_rui[countb], i, countb)
countb -= 1
# print(i, countb)
ans = max(ans, i+countb)
print(ans)
| import math
a, b, h, m = map(int, input().split())
theta_a = (60*h+m)/720*2*math.pi
theta_b = m/60*2*math.pi
theta_a_b = abs(theta_a-theta_b)
ans = math.sqrt(a**2+b**2-2*a*b*math.cos(theta_a_b))
print(ans) | 0 | null | 15,394,662,004,580 | 117 | 144 |
c=str(input())
print('Yes' if c[2]==c[3] and c[4]==c[5] else'No') | List=list(input())
if List[2]==List[3] and List[4]==List[5]:
print("Yes")
else:print("No") | 1 | 41,932,712,450,112 | null | 184 | 184 |
N=int(input())
S=list(input())
S.insert(0,0)
R=S.count("R")
G=S.count("G")
B=S.count("B")
ans=R*G*B
for i in range(1,N-1):
for j in range(i+1,N):
k=2*j-i
if k<N+1 and S[i]!=S[j] and S[j]!=S[k] and S[k]!=S[i]:
ans-=1
print(ans)
| w = input().lower()
cnt = 0
while 1:
l = input().split()
if "END_OF_TEXT" in l: break
for e in l:
if e.lower() == w: cnt += 1
print(cnt)
| 0 | null | 18,960,445,007,868 | 175 | 65 |
n,m = list(map(int, input("").split()))
h = list(map(int, input("").split()))
p = [1] * n
for i in range(m):
a,b = map(int, input().split())
if h[a-1] <= h[b-1]:
p[a-1]=0
if h[a-1] >= h[b-1]:
p[b-1]=0
print(sum(p)) | n,m=map(int,input().split())
way=[[] for i in range(n)]
H = list(map(int,input().split()))
for i in range(m):
a,b=map(int,input().split())
way[a-1].append(b-1)
way[b-1].append(a-1)
ans=0
for i in range(n):
high=True
for j in way[i]:
if H[i]<=H[j]:
high=0
break
if high:
ans+=1
print(ans) | 1 | 25,167,322,900,148 | null | 155 | 155 |
from collections import Counter,defaultdict,deque
from heapq import heappop,heappush,heapify
import sys,bisect,math,itertools,fractions,pprint
sys.setrecursionlimit(10**8)
mod = 10**9+7
INF = float('inf')
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
def inpln(n): return list(int(sys.stdin.readline()) for i in range(n))
class Combination:
"""
comb = Combination(1000000)
print(comb(5, 3)) # 10
"""
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
n,k = inpl()
m = min(n-1,k)
res = 1
if m == 1:
print((n-1)*n%mod)
quit()
comb = Combination(n+10)
for i in range(m):
res += comb(n,i+1) * comb(n-1,n-i-2)
res %= mod
print(res) | N, K = map(int, input().split())
def createFacArr(n, mod):
'''
二項係数計算用の配列の作成
Parameters
n : int
配列のサイズ
mod : int
あまり
Returns
fac : list
階乗のリスト
finv : list
modの逆元のリスト
ivn : list
'''
fac = [0] * n
finv = [0] * n
inv = [0] * n
fac[0], fac[1] = 1, 1
finv[0], finv[1] = 1, 1
inv[1] = 1
for i in range(2, n):
fac[i] = fac[i-1] * i % mod
inv[i] = mod - inv[mod%i] * (mod // i) % mod
finv[i] = finv[i-1] * inv[i] % mod
return fac, finv
def comb(n ,k, mod, fac, finv):
'''
二項係数の計算
Parameters
n : int
元集合
k : int
元集合から選択する数
mod : int
あまり
fac : list
階乗のリスト
finv : list
逆元のリスト
Returns
c : int
nCkの組み合わせの数
'''
if n < k:
return 0
if n < 0 or k < 0:
return 0
return fac[n] * (finv[k] * finv[n-k] % mod) % mod
K = min(N-1, K)
ans = 0
MOD = 10 ** 9 + 7
fac, finv = createFacArr(N+100, MOD)
for i in range(K+1):
# iは0の個数
ans += comb(N, i, MOD, fac, finv) * comb(N-1, N-i-1, MOD, fac, finv) % MOD
ans %= MOD
print(ans)
| 1 | 67,065,522,632,838 | null | 215 | 215 |
x = int(input())
c_500 = 0
c_5 = 0
while True:
temp = x - 500
if temp < 0:
break
else:
c_500 += 1
x = temp
while True:
temp = x - 5
if temp < 0:
break
else:
c_5 += 1
x = temp
print(c_500 * 2 * 500 + c_5 * 5)
| n, k, s = map(int, input().split())
ans = []
for i in range(k):
ans.append(s)
for i in range(n-k):
if s == 10**9:
ans.append(10**9-1)
else:
ans.append(s+1)
print(*ans, sep=' ')
| 0 | null | 67,142,978,825,352 | 185 | 238 |
import math
def main():
X=int(input())
for a in range(-120,120):
flag=0
for b in range(-120,120):
if pow(a,5)-pow(b,5)==X:
print("{} {}".format(a,b))
flag=1
break
if flag==1:
break
if __name__=="__main__":
main()
| 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, *A = map(int, read().split())
ans = 0
p = 1
for _ in range(60):
n = 0
for i in range(N):
A[i], d = A[i] // 2, A[i] % 2
n += d
ans = (ans + n * (N - n) * p) % MOD
p = p * 2 % MOD
print(ans)
return
if __name__ == '__main__':
main()
| 0 | null | 74,325,247,076,480 | 156 | 263 |
n, k = map(int, input().split())
w = [int(input()) for _ in range(n)]
def check(p):
i = 0
for _ in range(k):
s = 0
while s + w[i] <= p:
s += w[i]
i += 1
if i == n:
return True
return False
ng, ok = 0, 10**9
while ok-ng > 1:
mid = (ng+ok)//2
if check(mid):
ok = mid
else:
ng = mid
print(ok)
| n,k = map(int,input().split())
w = []
for _ in range(n):
w.append(int(input()))
def enough(p,k,w):
count = 0
in_truck = 0
for x in w:
if x > p:
return False
else:
if in_truck + x > p:
count += 1
in_truck = x
else:
in_truck += x
if in_truck > 0:
count += 1
return k >= count
maximum = sum(w)
minimum = 1
while True:
if minimum == maximum:
break
else:
tmpp = (maximum + minimum) // 2
if enough(tmpp,k,w):
maximum = tmpp
else:
minimum = tmpp + 1
print(minimum)
| 1 | 85,485,059,008 | null | 24 | 24 |
def input_array():
return list(map(int,input().split()))
n=int(input())
D=[input_array() for i in range(n)]
count=0
for d in D:
if d[0]==d[1]:
count+=1
else:
count=0
if count==3:
break
if count==3:
print("Yes")
else:
print("No") | N=int(input())
count=0
a=0
for i in range(N):
D=list(map(int,input().split()))
if D[0]==D[1]:
count+=1
if count>=3:
a=1
break
else:
count=0
if a==1:
print("Yes")
else:
print("No") | 1 | 2,509,290,105,278 | null | 72 | 72 |
from itertools import combinations_with_replacement
n, m, q = map(int, input().split())
abcd = [list(map(int, input().split())) for i in range(q)]
ans = 0
for i in combinations_with_replacement(range(1, m + 1), n):
cnt = 0
for a, b, c, d in abcd:
if i[b - 1] - i[a - 1] == c:
cnt += d
ans = max(ans, cnt)
print(ans) | n, m, q = map(int, input().split())
a = [0] * q
b = [0] * q
c = [0] * q
d = [0] * q
for i in range(q):
a[i], b[i], c[i], d[i] = map(int, input().split())
score = []
# 数列Aの全探索
import copy
def dfs(A):
if len(A) == n+1:
# score計算
tmp = 0
#print(A)
for i in range(q):
if A[b[i]] - A[a[i]] == c[i]:
tmp += d[i]
score.append(tmp)
return
else:
tmp = A[-1]
arr = copy.copy(A)
arr.append(tmp)
while(arr[-1] <= m):
dfs(arr)
arr[-1] += 1
dfs([1])
print(max(score))
| 1 | 27,584,115,081,940 | null | 160 | 160 |
k = int(input())
s = input()
a = list(s.split())
if len(s) <= k:
print(s)
elif len(s) > k:
print((s[0:k] + '...')) | 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') | 0 | null | 10,736,551,049,880 | 143 | 64 |
N,M = map(int,input().split())
a = [-1]*N
ans = 0
for i in range(M):
s,c = map(int,input().split())
if a[s-1] == -1:
a[s-1] = c
elif a[s-1] != c:
ans = -1
break
if a[0] == 0 and N>1:
ans = -1
if ans != -1:
if a[0] == -1 and N>1:
a[0] = 1
if a[0] == -1 and N == 1:
a[0] = 0
for i in range(N):
if a[i] == -1:
a[i] = 0
a[i] = str(a[i])
ans = "".join(a)
print(ans)
| def lstToInt(l,x=0):
if len(l) == 0:
return x
else:
return lstToInt(l[1:], x*10 + l[0])
n,m = map(int,input().split())
c = [-1]*n
for i in range(m):
s, num = map(int,input().split())
if c[s-1] != -1 and c[s-1] != num:
print(-1)
exit()
elif s == 1 and num == 0 and n != 1:
print(-1)
exit()
else:
c[s-1] = num
if c[0] == -1 and n != 1:
c[0] = 1
ans = lstToInt(list(0 if c[i] == -1 else c[i] for i in range(n)))
print(ans) | 1 | 60,506,456,371,968 | null | 208 | 208 |
N = int(input())
if N-(N//10*10)==3:
print('bon')
elif N-(N//10*10)==0 or N-(N//10*10)==1 or N-(N//10*10)==6 or N-(N//10*10)==8:
print('pon')
else:
print('hon') | from collections import deque
def solver(K):
q = deque([i for i in range(1, 10)])
if K <= 9:
ans = q[K - 1]
else:
cnt = 9
for i in range(1, K):
c = q.popleft()
if c % 10 != 0:
q.append(c * 10 + (c % 10) - 1)
cnt += 1
if cnt >= K:
break
q.append(c * 10 + (c % 10))
cnt += 1
if cnt >= K:
break
if c % 10 != 9:
q.append(c * 10 + (c % 10) + 1)
cnt += 1
if cnt >= K:
break
ans = q[-1]
return ans
def run():
K = int(input())
ans = solver(K)
print(ans)
run()
| 0 | null | 29,415,955,092,480 | 142 | 181 |
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
X,Y,A,B,C = map(int,readline().split())
P = list(map(int,readline().split()))
Q = list(map(int,readline().split()))
R = list(map(int,readline().split()))
P = sorted(P,reverse=True)
Q = sorted(Q,reverse=True)
R = sorted(R,reverse=True)
P = P[:X]
Q = Q[:Y]
PQR = sorted(P+Q+R,reverse = True)
ans = sum(PQR[:X+Y])
print(ans) |
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:])) | 1 | 44,699,023,847,632 | null | 188 | 188 |
N=int(input())
l=list(map(int,input().split()))
ans=1
cnt=[0]*(N+1)
mod=10**9+7
cnt[0]=3
for i in l:
ans=ans*cnt[i]%mod
cnt[i]-=1
cnt[i+1]+=1
print(ans) | n = int(input())
A=[int(i) for i in input().split()]
MOD = 1000000007
ans = 1
cnt = [0]*(n+1)
cnt[0]=3
for i in range(n):
ans = ans * cnt[A[i]] %MOD
cnt[A[i]]-=1
cnt[A[i]+1]+=1
if ans==0:
break
print(ans)
| 1 | 130,677,704,914,172 | null | 268 | 268 |
n, m = map(int, input().split())
num = [-1 for _ in range(n)]
for _ in range(m):
s, c = map(int, input().split())
s -= 1
if n >= 2 and s == 0 and c == 0:
print(-1)
exit()
elif num[s] != -1 and num[s] != c:
print(-1)
exit()
else:
num[s] = c
if num[0] == -1 and n != 1:
num[0] = 1
elif num[0] == -1 and n == 1:
num[0] = 0
num = ["0" if n == -1 else str(n) for n in num]
print("".join(num)) | N,M=map(int,input().split())
x=[-1]*N
for _ in range(M):
s,c=map(int,input().split())
s-=1
if (s==c==0 and N>1 or
x[s]!=-1 and x[s]!=c):
print(-1)
exit()
x[s]=c
if x[0]==-1:
x[0]=0+(N>1)
for i in range(N):
if x[i]==-1: x[i]=0
print(''.join(map(str,x)))
| 1 | 60,407,454,675,730 | null | 208 | 208 |
a=[]
for i in range(3):
da=list(map(int,input().split()))
for j in da:
a.append(j)
n=int(input())
for i in range (n):
b=int(input())
for j in range(len(a)):
if a[j] == b:
a[j]=0
for i in range (3):
if a[i] == a[i+3] and a[i+3]==a[i+6]:
print('Yes')
exit()
for i in range(3):
if a[3*i]==a[3*i+1] and a[3*i]==a[3*i+2]:
print('Yes')
exit()
if a[0]==a[4] and a[0]==a[8]:
print('Yes')
exit()
if a[2]==a[4] and a[2]==a[6]:
print('Yes')
exit()
print('No') | a = []
for i in range(3):
l,m,n = map(int,input().split())
a.append([l,m,n])
n = int(input())
b = []
for i in range(n):
b.append(int(input()))
#print(a)
#print(b)
for i in range(3):
for j in range(3):
for k in range(n):
if a[i][j] == b[k]:
a[i][j] = 0
tmp = 0
for i in range(3):
if a[i][0]+a[i][1]+a[i][2] == 0:
tmp = 1
elif a[0][i]+a[1][i]+a[2][i] == 0:
tmp = 1
if a[0][0]+a[1][1]+a[2][2] ==0:
tmp = 1
elif a[0][2]+a[1][1]+a[2][0] ==0:
tmp = 1
if tmp == 1:
print('Yes')
else:
print('No')
| 1 | 60,093,900,756,790 | null | 207 | 207 |
import sys
input = sys.stdin.readline
def I(): return int(input())
def MI(): return map(int, input().split())
def LI(): return list(map(int, input().split()))
def main():
mod=10**9+7
from math import gcd
a,b=MI()
print((a*b)//gcd(a,b))
main()
| #!/usr/bin/env python
# -*- coding: utf-8 -*-
h = [int(input()) for i in range(10)]
h.sort()
h.reverse()
print(h[0])
print(h[1])
print(h[2]) | 0 | null | 56,880,072,507,948 | 256 | 2 |
def merge(A, left, mid, right, c):
global counter
n1 = mid - left
n2 = right - mid
L = [0] * (n1+1)
R = [0] * (n2+1)
for i in range(n1):
L[i] = A[left + i]
for i in range(n2):
R[i] = A[mid + i]
L[n1] = 1000000000
R[n2] = 1000000000
i = 0
j = 0
for k in range(left,right):
c += 1
if L[i] <= R[j]:
A[k] = L[i]
i += 1
else :
A[k] = R[j]
j += 1
L.pop()
R.pop()
return c
def mergeSort(A, left, right, c):
if left+1 < right:
mid = int((left + right)/2)
c = mergeSort(A, left, mid, c)
c = mergeSort(A, mid, right, c)
c = merge(A, left, mid, right, c)
return c
if __name__ == '__main__':
num = int(input())
m = list(map(int,input().split()))
c = 0
c = mergeSort(m, 0, num, c)
print(' '.join(map(str,m)))
print(str(c))
| D = int(input())
C = list(map(int, input().split()))
S = [list(map(int, input().split())) for _ in range(D)]
L = [0]*26
v = 0
ans = [0]*D
import copy
for i in range(1, D+1):
max_score = -float('inf')
max_idx = 0
for j in range(26):
temp = v
temp += S[i-1][j]
L_ = copy.copy(L)
L_[j] = i
for k in range(26):
for l in range(i, min(i+14, D+1)):
temp -= C[k]*(i-L_[k])
if temp >= max_score:
max_score = temp
max_idx = j
v = max_score
L[max_idx] = i
ans[i-1] = max_idx+1
print(*ans, sep='\n')
| 0 | null | 4,912,011,414,410 | 26 | 113 |
n,k=map(int,input().split())
m=n%k
print(min(m,abs(m-k))) | 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) | 1 | 39,372,579,280,002 | null | 180 | 180 |
from sys import exit
def gcd(x,y):
if x == 0: return y
else: return gcd(y%x,x)
N = int(input())
A = list(map(int,input().split()))
is_prime = [True]*(10**6+10)
is_prime[0] = False
is_prime[1] = False
for i in range(2,10**6+10):
if not is_prime[i]:
continue
else:
for j in range(i*i,10**6+10,i):
is_prime[j] = False
g = 0
for i in A:
g = gcd(g,i)
if g != 1:
print("not coprime")
exit(0)
prime = [p for p in A if is_prime[p]]
used = [False]*(10**6+10)
notprime = [np for np in A if not is_prime[np]]
small_prime = [p for p in range(10**3+10) if is_prime[p]]
for p in prime:
used[p] = True
for np in notprime:
for p in small_prime:
if np == 1: break
if np % p != 0: continue
if used[p]:
print("setwise coprime")
exit(0)
used[p] = True
while np % p == 0:
np //= p
if np > 1:
if used[np]:
print("setwise coprime")
exit(0)
used[np] = True
print("pairwise coprime") | import math
from functools import reduce
from collections import deque
N = int(input())
A = list(map(int, input().split()))
def gcd_list(numbers):
return reduce(math.gcd, numbers)
max_A = max(A)
if max_A == 1:
print('pairwise coprime')
exit()
# エラトステネスの篩により素数を高速で求める
# そのかんにある数値がふるい落とされたその素数をメモしておく
D = [0] * (max_A + 1)
is_prime = [True] * (max_A + 1)
is_prime[0] = False
is_prime[1] = False
prime = deque()
for i in range(2, int(max_A ** 0.5) + 1):
if not is_prime[i]:
continue
for j in range(i * 2, max_A + 1, i):
is_prime[j] = False
D[j] = i
for i in range(len(is_prime)):
if is_prime[i]:
D[i] = i
pairwise = True
check = [0] * (max_A + 1)
new_A = A[:]
for i in range(N):
min_prime = D[new_A[i]]
while True:
if D[min_prime] == 0:
break
check[D[min_prime]] += 1
while new_A[i] % min_prime == 0:
new_A[i] //= min_prime
min_prime = new_A[i]
# print(check)
# print(D)
# print(check)
if max(check) > 1:
pairwise = False
# print(check)
if pairwise:
print('pairwise coprime')
else:
if gcd_list(A) == 1:
print('setwise coprime')
else:
print('not coprime')
| 1 | 4,128,975,494,140 | null | 85 | 85 |
n = int(raw_input())
a = map(int, raw_input().split())
print min(a), max(a), sum(a) | while True:
card = input()
if card == '-':
break
times = int(input())
while times:
h = int(input())
card = card[h:] + card[:h]
times -= 1
print(card) | 0 | null | 1,315,861,344,600 | 48 | 66 |
import sys
input = sys.stdin.readline
N = int(input())
S = list(input().rstrip())
ord_a = ord("a")
class Bit:
def __init__(self, n):
self.size = n
self.tree = [0] * (n + 1)
def sum(self, i):
s = 0
while i > 0:
s += self.tree[i]
i -= i & -i
return s
def add(self, i, x):
while i <= self.size:
self.tree[i] += x
i += i & -i
bits = [Bit(N) for _ in range(26)]
for i in range(N):
s = S[i]
bits[ord(s) - ord_a].add(i + 1, 1)
Q = int(input())
for _ in range(Q):
query = input().rstrip().split()
if query[0] == "1":
i, c = int(query[1]), query[2]
bits[ord(S[i - 1]) - ord_a].add(i, -1)
S[i - 1] = c
bits[ord(S[i - 1]) - ord_a].add(i, 1)
else:
l, r = int(query[1]), int(query[2])
res = 0
for bit in bits:
if l != 1:
res += int(bit.sum(r) - bit.sum(l - 1) > 0)
else:
res += int(bit.sum(r) > 0)
print(res) | #####segfunc######
def segfunc(x, y):
return x | y
def init(init_val):
# set_val
for i in range(n):
seg[i + num - 1] = set(init_val[i])
# built
for i in range(num - 2, -1, -1):
seg[i] = segfunc(seg[2 * i + 1], seg[2 * i + 2])
def update(k, x):
k += num - 1
seg[k] = set(x)
while k:
k = (k - 1) // 2
seg[k] = segfunc(seg[k * 2 + 1], seg[k * 2 + 2])
def query(p, q):
if q <= p:
return ide_ele
p += num - 1
q += num - 2
res = ide_ele
while q - p > 1:
if p & 1 == 0:
res = segfunc(res, seg[p])
if q & 1 == 1:
res = segfunc(res, seg[q])
q -= 1
p = p // 2
q = (q - 1) // 2
if p == q:
res = segfunc(res, seg[p])
else:
res = segfunc(segfunc(res, seg[p]), seg[q])
return res
#####単位元######
ide_ele = set()
n = int(input())
S = input().strip()
Q = int(input())
num = 2 ** (n - 1).bit_length()
seg = [set()] * 2 * num
init(S)
for _ in range(Q):
a, b, c = [x for x in input().split()]
if a == "1":
update(int(b) - 1, c)
else:
print(len(query(int(b) - 1, int(c))))
| 1 | 62,648,792,673,212 | null | 210 | 210 |
A, B = map(int, input().split())
if(500*A >= B):
print('Yes')
else:
print('No') | k, m = list(map(int, input().split()))
if 500 * k >= m:
print('Yes')
elif 500 * k < m:
print('No')
else:
print('No') | 1 | 98,426,112,924,064 | null | 244 | 244 |
import itertools as itl
n = int(input())
A = list(map(int, input().split()))
q = int(input())
M = list(map(int, input().split()))
S = []
for i in range(n):
cmb = list(itl.combinations(A, i+1))
for j in cmb:
S.append(sum(j))
for m in M:
flg = False
for s in S:
if s == m:
flg = True
break
if flg:
print("yes")
else:
print("no")
| s=input()
print(s+"es" if s[-1]=='s' else s+"s") | 0 | null | 1,237,440,804,960 | 25 | 71 |
n = int(input())
arr = [0] * n
for i in input().split():
i = int(i)
arr[i - 1] += 1
for i in range(n):
print(arr[i]) | # 160 A
S = input()
print('Yes') if S[2:3] == S[3:4] and S[4:5] == S[5:6] else print('No') | 0 | null | 37,131,139,036,010 | 169 | 184 |
table = []
r, c = map(int, input().strip().split())
[table.append(input().strip().split()) for i in range(r)]
table.append([])
for j in range(r + 1):
for k in range(c + 1):
if j == r and k != c:
lastrow = sum(map(int, [table[x][k] for x in range(r)]))
table[-1].append(lastrow)
if k == c:
print(sum(map(int, table[j])))
break
print(table[j][k],end=' ') | r, c = map(int, input().split())
a = [0]*(c+1)
for _ in range(r):
v = list(map(int, input().split()))
v.append(sum(v))
print(*v)
a = [x+y for x, y in zip(a, v)]
print(*a) | 1 | 1,378,111,798,520 | null | 59 | 59 |
from math import gcd
mod = 1000000007
n = int(input())
counter = {}
zeros = 0
for i in range(n):
a, b = map(int, input().split())
if (a == 0 and b == 0):
zeros += 1
continue
g = gcd(a, b)
a //= g
b //= g
if (b < 0):
a = -a
b = -b
if (b == 0 and a < 0):
a = -a
counter[(a, b)] = counter.get((a, b), 0)+1
counted = set()
ans = 1
for s, s_count in counter.items():
if s not in counted:
if s[0] > 0 and s[1] >= 0:
t = (-s[1], s[0])
else:
t = (s[1], -s[0])
t_count = counter.get(t, 0)
now = pow(2, s_count, mod)-1
now += pow(2, t_count, mod)-1
now += 1
ans *= now
ans %= mod
counted.add(s)
counted.add(t)
print((ans - 1 + zeros) % mod)
| import math
N=int(input())
A={}
mod=10**9+7
AZ,BZ,ZZ=0,0,0
for i in range(N):
a,b=map(int, input().split())
if a==b and a==0:
ZZ+=1
elif a==0:
AZ+=1
if (0,-1) not in A:
A[(0,-1)]=1
else:
A[(0,-1)]+=1
elif b==0:
BZ+=1
if (1,0) not in A:
A[(1,0)]=1
else:
A[(1,0)]+=1
else:
if a<0:
a*=-1
b*=-1
d=math.gcd(abs(a),abs(b))
a//=d
b//=d
if (a,b) not in A:
A[(a,b)]=1
else:
A[(a,b)]+=1
c=0
D=[]
for x,y in A:
if (y,-x) in A:
D.append((A[(x,y)],A[(y,-x)]))
c+=A[(x,y)]+A[(y,-x)]
n=N-c-ZZ
p=pow(2,n,mod)
ans=p
for a,b in D:
f=pow(2,a+b,mod)-(pow(2,a,mod)-1)*(pow(2,b,mod)-1)
ans*=f
ans-=1
print((ans+ZZ)%mod) | 1 | 20,979,652,844,218 | null | 146 | 146 |
import sys
# import math
# import bisect
# import numpy as np
# from decimal import Decimal
# from numba import njit, i8, u1, b1 #JIT compiler
# from itertools import combinations, product
# from collections import Counter, deque, defaultdict
# sys.setrecursionlimit(10 ** 6)
MOD = 10 ** 9 + 7
INF = 10 ** 9
PI = 3.14159265358979323846
def read_str(): return sys.stdin.readline().strip()
def read_int(): return int(sys.stdin.readline().strip())
def read_ints(): return map(int, sys.stdin.readline().strip().split())
def read_ints2(x): return map(lambda num: int(num) - x, sys.stdin.readline().strip().split())
def read_str_list(): return list(sys.stdin.readline().strip().split())
def read_int_list(): return list(map(int, sys.stdin.readline().strip().split()))
def GCD(a: int, b: int) -> int: return b if a%b==0 else GCD(b, a%b)
def LCM(a: int, b: int) -> int: return (a * b) // GCD(a, b)
def Main():
n = read_int()
a = read_int_list()
ans = 1
cnt = [3] + [0] * n
for x in a:
ans = ans * cnt[x] % MOD
cnt[x] -= 1
cnt[x + 1] += 1
print(ans)
if __name__ == '__main__':
Main() | s = input();
p = input();
if(p in s + s):
print("Yes");
else:
print("No");
| 0 | null | 65,800,850,805,788 | 268 | 64 |
import sys
input = sys.stdin.readline
sys.setrecursionlimit(100000)
# mod = 10 ** 9 + 7
mod = 998244353
def read_values():
return map(int, input().split())
def read_index():
return map(lambda x: int(x) - 1, input().split())
def read_list():
return list(read_values())
def read_lists(N):
return [read_list() for n in range(N)]
class V:
def __init__(self, f, v=None):
self.f = f
self.v = v
def __str__(self):
return str(self.v)
def ud(self, n):
if n is None:
return
if self.v is None:
self.v = n
return
self.v = self.f(self.v, n)
def main():
N, P = read_values()
S = input().strip()
if P in (2, 5):
res = 0
for i, s in enumerate(S):
if int(s) % P == 0:
res += i + 1
print(res)
else:
r = 0
D = {0: 1}
res = 0
d = 1
for i, s in enumerate(S[::-1]):
r += int(s) * d
r %= P
d *= 10
d %= P
c = D.setdefault(r, 0)
res += c
D[r] += 1
print(res)
if __name__ == "__main__":
main()
|
def main():
N, P = map(int, input().split())
S = input()
ans = 0
mods = [0 for i in range(N+1)]
digits = 1
if P == 2 or P == 5:
for i in range(N-1, -1, -1):
if int(S[i])%P == 0:
ans += i+1
print(ans)
return
for i in range(N-1, -1, -1):
mods[i] = (int(S[i]) * digits % P + mods[i+1]) % P
digits = digits * 10 % P
count = [0 for i in range(P)]
for i in range(N, -1, -1):
ans += count[mods[i]]
count[mods[i]] += 1
print(ans)
main() | 1 | 58,138,828,463,660 | null | 205 | 205 |
from bisect import bisect_left
from itertools import accumulate
N, M = map(int, input().split())
A = sorted(list(map(int, input().split())))
Acum = [0] + list(accumulate(A))
left = 0
right = max(A) * 2 + 1
while left + 1 < right:
mid = (left + right) // 2
tmp = 0
for i in range(N):
bi = bisect_left(A, mid - A[i])
tmp += N - bi
if tmp <= M:
right = mid
else:
left = mid
cnt = 0
answer = 0
for i in range(N):
bi = bisect_left(A, right - A[i])
cnt += N - bi
answer += Acum[N] - Acum[bi] + A[i] * (N - bi)
print(answer + (M - cnt) * left) | def make_text():
temp = []
while True:
row = input().split()
if row == ['END_OF_TEXT']:
break
temp.append(list(map(lambda x: x.lower(), row)))
return temp
def find_word(word,text):
num = 0
for row in text:
for t in row:
if t == word:
num += 1
return num
if __name__ == '__main__':
w = input()
t = make_text()
num = find_word(w,t)
print(num)
| 0 | null | 54,863,317,262,040 | 252 | 65 |
from sys import exit
for i in input():
if i == '7':
print('Yes')
exit()
print('No')
| N = int(input())
A = list(map(int, input().split()))
idx = [0] * N
for i, val in enumerate(A):
idx[val-1] = i + 1
for i in idx:
print(i,end=" ") | 0 | null | 108,030,623,263,360 | 172 | 299 |
N = int(input())
XY_list = [[] for _ in range(N)]
for i in range(N):
num = int(input())
for j in range(num):
person, state = map(int, input().split())
XY_list[i].append([person - 1, state])
ans = 0
for i in range(1 << N):
bool = True
for j in range(N):
if (i >> j) & 1 == 1:
for person, state in XY_list[j]:
if (i >> person) & 1 != state:
bool = False
break
if bool:
ans = max(ans, bin(i)[2:].count("1"))
print(ans)
| N=int(input())
Ins=[[] for _ in range(N)]
ans=0
#0-indexedにしておく
for i in range(N):
A=int(input())
for _ in range(A):
x,y=map(int,input().split())
Ins[i].append((x-1,y))
for i in range(2**N):
flag=1
honest=[]
unkind=[]
for j in range(N):
if (i>>j)&1:
honest.append(j)
else:
unkind.append(j)
#ここまでは想定の組み合わせを作る作業
for k in honest:
#honestな人の証言を見ていく
for l in Ins[k]:
if l[1]==1 and l[0] in unkind:
flag=0
break
#honestな人がある人物をhonestと答えたのにも関わらず
#その人がunkindに入るような組み合わせは駄目...ケース1
elif l[1]==0 and l[0] in honest:
flag=0
break
#honestな人がある人物をunkindと答えたのにも関わらず
#その人がhonestに入るような組み合わせは駄目...ケース2
if flag==1:
ans=max(ans,len(honest))
#ケース1にもケース2にも該当しない場合
#現在のhonestの人数をansと比較して大きい方を採用
print(ans) | 1 | 121,573,592,210,182 | null | 262 | 262 |
from math import ceil
N,K = list(map(int, input().split()))
A = list(map(int, input().split()))
F = list(map(int, input().split()))
A.sort(reverse=True)
F.sort()
wk = 0
for i in range(N):
wk += A[i] * F[i]
#print(wk)
def is_ok(arg):
# 条件を満たすかどうか？問題ごとに定義
cnt = 0
for i in range(N):
a,f = A[i], F[i]
if a*f <= arg:
continue
else:
#(a-k) * f <= arg
# a - arg/f <= k
cnt += ceil(a-arg/f)
return cnt <= K
def meguru_bisect(ng, ok):
'''
初期値のng,okを受け取り,is_okを満たす最小(最大)のokを返す
まずis_okを定義すべし
ng ok は とり得る最小の値-1 とり得る最大の値+1
最大最小が逆の場合はよしなにひっくり返す
'''
while (abs(ok - ng) > 1):
mid = (ok + ng) // 2
if is_ok(mid):
ok = mid
else:
ng = mid
return ok
ng = -1
ok = 10**12 + 10
ans = meguru_bisect(ng,ok)
print(ans) | import math
N,K = map(int,input().split())
A = sorted(list(map(int,input().split())))
F = sorted(list(map(int,input().split())),reverse=True)
high = 0
for i in range(N):
high = max(high,A[i]*F[i])
low = -1
while high-low>1:
mid = (high+low)//2
flag = 1
T = K
for i in range(N):
if A[i]*F[i]<=mid:continue
else:
T -= math.ceil(A[i]-mid/F[i])
if T<0:
flag = 0
break
if flag==1:
high = mid
else:
low = mid
print(high) | 1 | 165,103,906,447,008 | null | 290 | 290 |
# 貪欲+山登り(日付をランダムに2つ選んで更新)
import time
import random
d = int(input())
dd = d * (d + 1) // 2
*C, = map(int, input().split())
S = [list(map(int, input().split())) for i in range(d)]
T = []
L = [-1 for j in range(26)]
for i in range(d):
max_diff = -10**7
arg_max = 0
for j in range(26):
memo = L[j]
L[j] = i
diff = S[i][j] - sum([C[k] * (i - L[k]) for k in range(26)])
if diff > max_diff:
max_diff = diff
arg_max = j
L[j] = memo
T.append(arg_max)
L[arg_max] = i
def calc_score(T):
L = [-1 for j in range(26)]
X = [0 for j in range(26)]
score = 0
for i in range(d):
score += S[i][T[i]]
X[T[i]] += (d - i) * (i - L[T[i]])
L[T[i]] = i
for j in range(26):
score -= C[j] * (dd - X[j])
return score
score = calc_score(T)
start = time.time()
cnt = 0
while True:
now = time.time()
if now - start > 1.8:
break
i0, i1 = tuple(random.sample(range(d), 2))
arg_max = (0, 0)
max_diff = 0
for j0 in range(26):
for j1 in range(26):
memo = (T[i0], T[i1])
T[i0], T[i1] = j0, j1
new_score = calc_score(T)
if new_score - score > max_diff:
max_diff = new_score - score
arg_max = (j0, j1)
T[i0], T[i1] = memo
if max_diff > 0:
T[i0], T[i1] = arg_max
score += max_diff
cnt += 1
for t in T:
print(t + 1)
| d=int(input())
C=[int(i) for i in input().split()]
s=[[int(i) for i in input().split()] for q in range(d)]
sco=0
L=[0 for i in range(26)]
ans=[]
#calc
for i in range(d):
mayou=0
est=s[i][0]+C[0]*(i+1-L[0])
for p in range(1,26):
if s[i][p]+C[p]*(i+1-L[p]) > est:
mayou=p
est=s[i][p]+C[p]*(i+1-L[p])
ans.append(mayou)
L[mayou]=i+1
print(mayou+1) #output
| 1 | 9,678,496,588,478 | null | 113 | 113 |
s,t,a,b,x,y=map(int,open(0).read().split())
if a*s+b*t==x*s+y*t:
print('infinity')
exit()
if a<x:a,b,x,y=x,y,a,b
if a*s+b*t>x*s+y*t:
print(0)
exit()
n=(a*s-x*s)/(x*s+y*t-(a*s+b*t))
m=int(n)
print(m*2+(n>m)) | import sys
def ISI(): return map(int, sys.stdin.readline().rstrip().split())
a, b = ISI()
if a<2*b:print(0)
else:print(a-2*b) | 0 | null | 148,760,255,240,480 | 269 | 291 |
count = 1
while True:
x = input()
if x == 0:
break
print ("Case %d: %d" % (count, x))
count += 1 | d=input().split()
s={'N':"152304",'W':"215043",'E':"310542",'S':"402351"}
for o in input():
d=[d[int(i)]for i in s[o]]
print(d[0])
| 0 | null | 358,939,488,898 | 42 | 33 |
def main(A,B,C,K):
ans=False
while K >= 0:
if A < B:
if B < C:
ans=True
return ans
else:
C = C * 2
else:
B = B * 2
K=K-1
return ans
A,B,C=map(int, input().split())
K=int(input())
ans=main(A,B,C,K)
print('Yes' if ans else 'No') | A,B,C=map(int,input().split())
K=int(input())
ans="No"
for _ in range(K+1):
if A>=B:
B*=2
elif B>=C:
C*=2
else:
ans="Yes"
print(ans)
| 1 | 6,862,838,514,542 | null | 101 | 101 |
P = 10**9 + 7
K = int(input())
S = input()
L = len(S)
d = [0]*(L+K+1)
d[0] = 1
for i in range(1, L+K+1):
d[i] = (d[i-1]*i)%P
ans = 0
for i in range(K+1):
temp = pow(26, i, P) * pow(25, K-i, P)
temp %= P
temp *= d[L-1+K-i]
temp %= P
temp *= pow(d[L-1], P-2, P)
temp %= P
temp *= pow(d[K-i], P-2, P)
temp %= P
ans += temp
ans %= P
print(ans) | MOD = 10**9+7
k = int(input())
s = input()
n = len(s)
U = n+k
fact = [0]*(U+1)
fact[0] = 1
for i in range(1, U+1):
fact[i] = fact[i-1]*i % MOD
invfact = [0]*(U+1)
invfact[U] = pow(fact[U], MOD-2, MOD)
for i in reversed(range(U)):
invfact[i] = invfact[i+1]*(i+1) % MOD
def nCr(n, r):
if r < 0 or n < r:
return 0
return fact[n]*invfact[r]*invfact[n-r]
ans = 0
for x in range(k+1):
ans += pow(26, x, MOD)*nCr(n+k-x-1, n-1)*pow(25, k-x, MOD)
ans %= MOD
print(ans) | 1 | 12,829,572,819,018 | null | 124 | 124 |
import math
x = int(input())
n = 100
y = 0
while x > n:
# 小数点以下切り捨て
n += n // 100
y += 1
print(y) | def call(n):
s = ""
for x in range(1, n + 1):
y = x
if y % 3 == 0:
s = s + " " + str(x)
else:
while y != 0:
if y % 10 == 3:
s = s + " " + str(x)
break
y = int(y / 10)
return s
n = int(input())
print(call(n)) | 0 | null | 14,110,142,153,532 | 159 | 52 |
from itertools import accumulate
from collections import defaultdict, deque
def resolve():
N, K = map(int, input().split())
A = list(map(int, input().split()))
A = accumulate([a % K for a in A])
A = [0] + list(A)
# 区間 [i,j] の和(累積和): dj+1−di
# 区間 [i,j] の要素の数(0_indの為 +1): j−i+1
# 上記を一般化: dr−dl=r−l となるものの個数を求める
# r−l<K の時、mod K において式変形が成り立つ, dr−r=dl−l
# rを固定し辞書で管理すれば、dl−lと同じ値なので個数を求められる。
cnt = defaultdict(int)
q = deque()
ans = 0
for r in range(N + 1):
t = (A[r] - r) % K
ans += cnt[t]
cnt[t] += 1
q.append(t)
if len(q) == K:
left = q.popleft()
cnt[left] -= 1
print(ans)
if __name__ == "__main__":
resolve()
| #!/usr/bin/env python3
from itertools import accumulate
n, k = map(int, input().split())
a = list(map(int, input().split()))
s = [0] + list(accumulate(a))
def f(x):
return (x + n * k) % k
ans = 0
dic = {}
for i in range(n + 1):
if i >= k:
prev = f(s[i - k] - (i - k))
dic[prev] -= 1
cur = f(s[i] - i)
if cur in dic:
ans += dic[cur]
dic[cur] += 1
else:
dic[cur] = 1
print(ans)
| 1 | 137,630,845,685,102 | null | 273 | 273 |
N=int(input())
*A,=map(int, input().split())
M=10**3
P=[]
isp=[True]*M
for n in range(2,M):
if isp[n]==False: continue
P.append(n)
for m in range(n*n, M, n):
isp[m]=False
from collections import defaultdict
D=[defaultdict(int) for _ in range(N)]
for i in range(N):
a=A[i]
for p in P:
while a>1:
if a%p==0:
D[i][p]+=1
a//=p
else:
break
else:
break
if a>1:
D[i][a]+=1
d=defaultdict(int)
for i in range(N):
for k,v in D[i].items():
d[k] = max(d[k], v)
MOD = 10**9+7
class Mint:
def __init__(self, value=0):
self.value = value % MOD
if self.value < 0: self.value += MOD
@staticmethod
def get_value(x): return x.value if isinstance(x, Mint) else x
def inverse(self):
a, b = self.value, MOD
u, v = 1, 0
while b:
t = a // b
b, a = a - t * b, b
v, u = u - t * v, v
if u < 0: u += MOD
return u
def __repr__(self): return str(self.value)
def __eq__(self, other): return self.value == other.value
def __neg__(self): return Mint(-self.value)
def __hash__(self): return hash(self.value)
def __bool__(self): return self.value != 0
def __iadd__(self, other):
self.value += Mint.get_value(other)
if self.value >= MOD: self.value -= MOD
return self
def __add__(self, other):
new_obj = Mint(self.value)
new_obj += other
return new_obj
__radd__ = __add__
def __isub__(self, other):
self.value -= Mint.get_value(other)
if self.value < 0: self.value += MOD
return self
def __sub__(self, other):
new_obj = Mint(self.value)
new_obj -= other
return new_obj
def __rsub__(self, other):
new_obj = Mint(Mint.get_value(other))
new_obj -= self
return new_obj
def __imul__(self, other):
self.value = self.value * Mint.get_value(other) % MOD
return self
def __mul__(self, other):
new_obj = Mint(self.value)
new_obj *= other
return new_obj
__rmul__ = __mul__
def __ifloordiv__(self, other):
other = other if isinstance(other, Mint) else Mint(other)
self *= other.inverse()
return self
def __floordiv__(self, other):
new_obj = Mint(self.value)
new_obj //= other
return new_obj
def __rfloordiv__(self, other):
new_obj = Mint(Mint.get_value(other))
new_obj //= self
return new_obj
gcd=Mint(1)
for k,v in d.items():
gcd *= pow(k,v,MOD)
print(sum([gcd//a for a in A]))
| def gcd(a, b):
if b==0:
return a
return gcd(b, a%b)
def lcm(a, b):
return a*(b//gcd(a, b))
mod = int(1e9+7)
def ext_gcd(a, b, x, y):
if b==0:
x[0] = 1
y[0] = 0
return a
g = ext_gcd(b, a%b, y, x)
y[0]-=a//b*x[0]
return g
def mod_inv(a):
x = [0]
y = [0]
ext_gcd(a, mod, x, y)
return (x[0]%mod + mod)%mod;
n = int(input())
vs = list(map(int, input().split()))
l = 1
for x in vs:
l = lcm(l, x)
l = l%mod;
ans = 0
for x in vs:
ans = (ans + ((l*mod_inv(x))%mod))%mod
print(ans)
| 1 | 87,466,866,312,000 | null | 235 | 235 |
# coding=utf-8
a, b, c = map(int, raw_input().rstrip().split())
print sum([1 if not c % i else 0 for i in range(a, b+1)]) | import sys
x = int(input())
import math
# 素数判定関数
def isPrime(num):
# 2未満の数字は素数ではない
if num < 2: return False
# 2は素数
elif num == 2: return True
# 偶数は素数ではない
elif num % 2 == 0: return False
# 3 ~ numまでループし、途中で割り切れる数があるか検索
# 途中で割り切れる場合は素数ではない
for i in range(3, math.floor(math.sqrt(num))+1, 2):
if num % i == 0:
return False
# 素数
return True
# 素数判定
def callIsPrime(input_num=1000):
numbers = []
# ループしながら素数を検索する
for i in range(1, input_num):
if isPrime(i):
numbers.append(i)
# 素数配列を返す
return numbers
# 関数の呼び出し
# print(callIsPrime(100000+4)[-1])
for i in callIsPrime(100000+4):
if i>=x:
print(i)
sys.exit() | 0 | null | 53,086,366,148,658 | 44 | 250 |
inputa = input()
print(inputa.swapcase()) | word = input()
print(str.swapcase(word))
| 1 | 1,510,328,444,800 | null | 61 | 61 |
N = int(input())
kuku = []
for i in range(1,10):
for j in range(1,10):
kuku.append(i*j)
if N in kuku:
print('Yes')
else:
print('No') | import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")
n = int(input())
for i in range(1,10):
if n%i==0 and n//i<10:
ans = "Yes"
break
else:
ans = "No"
print(ans) | 1 | 160,187,736,469,878 | null | 287 | 287 |
from scipy.special import comb
from collections import Counter
N = int(input())
A = list(map(int, input().split()))
C = Counter(A)
x = 0
for c in C.values():
x += comb(c, 2, exact=True)
for i in range(N):
y = x - comb(C[A[i]], 2, exact=True) + comb(C[A[i]] - 1, 2, exact=True)
print(y)
| import copy
N = int(input())
A = list(map(int, input().split()))
A_sum = 0
A2 = []
idx = dict()
for i in A:
if i in idx:
idx[i] += 1
else:
idx[i] = 1
for key in idx:
if idx[key] == 1:
idx[key] = [idx[key], 0]
else:
temp = int(idx[key] * (idx[key] - 1)/2)
A_sum += temp
temp = temp - int(temp * (idx[key] - 2) / idx[key])
idx[key] = [idx[key], temp]
for i in range(N):
key = A[i]
print(A_sum - idx[key][1])
| 1 | 47,524,943,899,862 | null | 192 | 192 |
#Eans
import sys, math, itertools, collections, bisect
mans = float('inf')
mod = 10 **9 +7
ans = 0
count = 0
pro = 0
N, M = map(int, input().split())
A = sorted(map(int, input().split()))
B = [0] + A[:]
for i in range(N):
B [i+1] += B[i]
#print('A', A)
#print('B', B)
def solve_binary(mid):
tmp = 0
for i, ai in enumerate(A):
tmp += N - bisect.bisect_left(A, mid-ai)
#bisect.bisect_left(A, mid-ai)はaiに固定した時の、もう片方の最小の値のインデックス
#tmpは、aiに固定した時のありうる個数（M)
return tmp >= M
def binary_search(N):
ok = 0
ng = N
while abs(ok - ng ) > 1:
mid = (ok + ng) // 2
if solve_binary(mid):
ok = mid
else:
ng = mid
return ok
binresult = binary_search(2*10**5+1)
#Xを二分探索で得る
#binresult=ok
#print(binresult)
for i, ai in enumerate(A):
ans += ai*(N - bisect.bisect_left(A, binresult-ai)) + B[N] - B[bisect.bisect_left(A, binresult-ai)]
#print(ans, '=', ai, '*', N-bisect.bisect_left(A, binresult-ai), '+', B[N], '-', B[bisect.bisect_left(A, binresult-ai
count += N - bisect.bisect_left(A, binresult-ai)
ans -= binresult * (count-M)
print(ans) | import sys
def solve():
readline = sys.stdin.buffer.readline
mod = 10 ** 9 + 7
k = int(readline())
s = str(readline().rstrip().decode('utf-8'))
print(s if len(s) <= k else s[:k] + "...")
if __name__ == '__main__':
solve()
| 0 | null | 63,987,808,017,764 | 252 | 143 |
if __name__ == "__main__":
S = input()
list_s = [s for s in S]
ans = 0
if list_s[0] == 'S' and list_s[1] == 'S' and list_s[2] == 'S':
ans = 0
elif list_s[0] == 'S' and list_s[1] == 'S' and list_s[2] == 'R':
ans = 1
elif list_s[0] == 'S' and list_s[1] == 'R' and list_s[2] == 'R':
ans = 2
elif list_s[0] == 'R' and list_s[1] == 'R' and list_s[2] == 'R':
ans = 3
elif list_s[0] == 'R' and list_s[1] == 'S' and list_s[2] == 'R':
ans = 1
elif list_s[0] == 'R' and list_s[1] == 'R' and list_s[2] == 'S':
ans = 2
elif list_s[0] == 'R' and list_s[1] == 'S' and list_s[2] == 'S':
ans = 1
elif list_s[0] == 'S' and list_s[1] == 'R' and list_s[2] == 'S':
ans = 1
print(ans)
| s = input()
if s in ["RRR"]:
print(3)
if s in ["RRS", "SRR"]:
print(2)
if s in ["RSR", "RSS", "SRS", "SSR"]:
print(1)
if s == "SSS":
print(0) | 1 | 4,919,132,009,040 | null | 90 | 90 |
def mlt(): return map(int, input().split())
x, a, b = mlt()
dp = [0 for n in range(x)]
for n in range(1, x+1):
for k in range(n+1, x+1):
d1 = k-n
d2 = abs(a-n)+1+abs(b-k)
ds = min(d1, d2)
dp[ds] += 1
print(*dp[1:], sep='\n')
| # AOJ ITP1_7_C
def numinput():
a = input().split()
for i in range(len(a)):
a[i] = int(a[i])
return a
def main():
a = numinput()
r = a[0]; c = a[1]
M = []
for i in range(r):
M.append(numinput()) # あ、そうか。。
sum = 0
for j in range(c): sum += M[i][j]
M[i].append(sum)
list = []
for j in range(c + 1):
sum = 0
for i in range(r): sum += M[i][j]
list.append(sum)
M.append(list)
for i in range(r + 1):
_str_ = ""
for j in range(c):
_str_ += str(M[i][j]) + " "
_str_ += str(M[i][c])
print(_str_)
if __name__ == "__main__":
main()
| 0 | null | 22,874,309,047,074 | 187 | 59 |
N=int(input())
a=list(map(int,input().split()))
a_all=0
for i in range(N):
a_all^=a[i]
ans=[]
for j in range(N):
ans.append(a_all^a[j])
print(*ans) | N, K = map(int, input().split())
A = list(map(int, input().split()))
visited = [-1 for _ in range(N)]
visited[0] = 0
k = 0
k = A[k] - 1
count = 0
while visited[k] == -1:
count += 1
visited[k] = count
k = A[k]-1
roop = count - visited[k] + 1
beforeroop = visited[k]
if K < beforeroop:
k = 0
for _ in range(K):
k = A[k] - 1
print(k+1)
else:
K = K - beforeroop
K = K % roop
for _ in range(K):
k = A[k]-1
print(k+1) | 0 | null | 17,641,864,117,830 | 123 | 150 |
k, n = map(int, input().split())
a = list(map(int, input().split()))
diff = []
for i in range(len(a)):
if (i == len(a) - 1):
distance = a[0] + (k - a[-1])
else:
tar2 = a[i + 1]
tar1 = a[i]
distance = tar2 - tar1
diff.append(distance)
# スタート位置を見つける
index = diff.index(max(diff))
ans = sum(diff) - max(diff)
print(ans)
# print(index)
# > 2なので、15~5は避ける。
# if (index == len(diff)):
| K, N = [int(x) for x in input().split()]
A = [int(x) for x in input().split()]
ans = 0
del_A = []
for i in range(N):
if(i==(N-1)):
del_A.append(A[0]+K-A[i])
else:
del_A.append(A[i+1]-A[i])
print(sum(del_A)-max(del_A)) | 1 | 43,433,661,042,628 | null | 186 | 186 |
import math
a, b, h, m = list(map(int, input().split()))
ang = abs(h * 30 + m * 0.5 - m * 6)
print(math.sqrt(a ** 2 + b ** 2 - 2 * a * b * math.cos(ang * math.pi / 180))) | from collections import Counter
import sys
import math
sys.setrecursionlimit(10 ** 6)
mod = 1000000007
inf = int(1e18)
def main():
a, b, h, m = map(int, input().split())
x1 = a * math.cos(2 * math.pi * (h % 12 / 12 + m / 60 / 12))
y1 = a * math.sin(2 * math.pi * (h % 12 / 12 + m / 60 / 12))
x2 = b * math.cos(2 * math.pi * (m / 60))
y2 = b * math.sin(2 * math.pi * (m / 60))
print(((x1 - x2)**2 + (y1 - y2)**2)**(1/2))
main()
| 1 | 20,154,032,084,680 | null | 144 | 144 |
N = int(input())
p_list = []
for i in range(N):
s = input().split(' ')
p_list.append(s)
X = input()
flg = False
time = 0
count = 0
for sound in p_list:
if sound[0] == X:
time = int(sound[1])
flg = True
if flg:
count += int(sound[1])
print(count-time) | N = int(input())
S = []
T = []
for _ in range(N):
s, t = input().split()
S.append(s)
T.append(int(t))
ind = S.index(input())
ans = sum(T[ind+1:])
print(ans)
| 1 | 96,939,225,158,988 | null | 243 | 243 |
s = int(input())
MOD = 1000000007
def mod(n):
return n % MOD
MAX = 1000000 #適当な数を入力
fac, finv, inv = [[0]*MAX for i in range(3)]
def combinit(): #MAXまでの下準備
fac[0] = fac[1] = 1
finv[0] = finv[1] = 1
inv[1] = 1
for i in range(2, MAX):
fac[i] = fac[i - 1] * i % MOD
inv[i] = MOD - inv[MOD%i] * (MOD // i) % MOD
finv[i] = finv[i - 1] * inv[i] % MOD
def modcomb(n, k): #mod(nCk)を計算、ただしn<MAX
if (n < k):
return 0
if (n < 0 or k < 0):
return 0
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD
combinit() #下準備の実行 O(MAX)
ans = 0
count = 0
s -= 3
while s >= 0:
ans += modcomb(s + count, count)
count += 1
s -= 3
print(mod(ans)) | n,m,x=map(int,input().split())
c=[list(map(int,input().split())) for _ in range(n)]
import itertools
sum_min=10**7
for i in itertools.product([0,1],repeat=n):
level=[0]*m
for j in range(m):
level[j]=sum(i[k]*c[k][j+1] for k in range(n))
for l in range(m):
if level[l]<x:
break
else:
sum_min=min(sum_min,sum(i[k]*c[k][0] for k in range(n)))
print(sum_min if sum_min!=10**7 else -1) | 0 | null | 12,756,978,969,812 | 79 | 149 |
N = input()
R = [int(raw_input()) for _ in xrange(N)]
S = [0 for i in xrange(N)]
S[N-1] = R[N-1]
for i in xrange(N-2, -1, -1):
S[i] = max(R[i], S[i+1])
ans = float('-inf')
for i in xrange(N-1):
ans = max(ans, S[i+1]-R[i])
print ans | import heapq
X, Y, A, B, C = map(int, input().split())
pl = list(map(int, input().split()))
ql = list(map(int, input().split()))
rl = list(map(int, input().split()))
pl.sort()
ql.sort()
rl.sort(reverse=True)
pl_x_larges = pl[A-X:A]
ql_y_larges = ql[B-Y:B]
pq_xy = pl_x_larges + ql_y_larges
pq_xy.sort()
for i, r in enumerate(rl):
if r > pq_xy[i]:
pq_xy[i] = r
else:
break
print(sum(pq_xy)) | 0 | null | 22,372,982,881,820 | 13 | 188 |
n, m, q = map(int, input().split())
candidate = []
def gen(cur):
if len(cur) == n:
candidate.append(cur)
else:
t = cur[-1]
for tv in range(t, m + 1):
nex = cur[:]
nex.append(tv)
gen(nex)
for i in range(1, m + 1):
arr = [i]
gen(arr)
ask = []
for _ in range(q):
ask.append(list(map(int, input().split())))
ans = 0
for cv in candidate:
tmp = 0
for av in ask:
if cv[av[1] - 1] - cv[av[0] - 1] == av[2]:
tmp += av[3]
ans = max(ans, tmp)
print(ans) | from itertools import combinations_with_replacement
N, M, Q = map(int, input().split())
abcdn = [tuple(map(int, input().split())) for _ in range(Q)]
mx = 0
for AN in combinations_with_replacement(range(1, M+1), N):
score = 0
for a, b, c, d in abcdn:
score += d if AN[b-1] - AN[a-1] == c else 0
mx = max(score, mx)
print(mx) | 1 | 27,511,720,687,330 | null | 160 | 160 |
H,A = map(int,input().split())
cnt = 0
while(True) :
H = H - A
cnt += 1
if H <= 0 :
break
print(cnt) | while True:
(x, y) = [int(i) for i in input().split()]
if x < y:
print(x, y)
elif x > y:
print(y, x)
elif x == y:
if x == 0 and 0 == y:
break
print(x, y) | 0 | null | 38,828,319,509,822 | 225 | 43 |
n=int(input())
start=[[[0 for i in range(10)] for j in range(3)] for k in range(4)]
for i in range(n):
b,f,r,v=[int(i) for i in input().split()]
start[b-1][f-1][r-1]+=v
for i in range(4):
for j in range(3):
for k in range(10):
print(" ",end="")
print(start[i][j][k],end="")
print()
if i<=2:
for m in range(20):
print("#",end="")
print()
| arr = [[[0 for i in range(10)] for j in range(3)] for k in range(4)]
for i in range(int(input())):
b,f,r,v = map(int, input().split())
arr[b-1][f-1][r-1] += v
for i in range(4):
for j in range(3):
for k in range(10):
if k == 0:
print ("", end=" ")
if k == 9:
print(arr[i][j][k])
else:
print(arr[i][j][k], end=" ")
if i != 3:
print("#"*20) | 1 | 1,106,105,023,872 | null | 55 | 55 |
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
sys.setrecursionlimit(10000001)
INF = 10 ** 16
MOD = 10 ** 9 + 7
ni = lambda: int(sys.stdin.readline())
ns = lambda: map(int, sys.stdin.readline().split())
na = lambda: list(map(int, sys.stdin.readline().split()))
# ===CODE===
def main():
n = ni()
a = na()
d = [0, 0, 0]
ans = 1
for ai in a:
ans *= d.count(ai)
ans %= MOD
for i in range(3):
if d[i] == ai:
d[i] += 1
break
print(ans)
if __name__ == '__main__':
main()
| N = int(input())
A = list(map(int,input().split()))
C = [0,0,0]
Ans = 1
MOD = 1000000007
for a in A:
ask = C.count(a)
if ask==0:
Ans=0
break
ind = C.index(a)
C[ind] += 1
Ans = (Ans*ask)%MOD
print(Ans)
| 1 | 130,356,907,081,832 | null | 268 | 268 |
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
MOD = 998244353
n, k = map(int, input().split())
s = list()
for i in range(k):
s.append(tuple(map(int, input().split())))
dp = [0] + [0] * n
diff = [0] + [0] * n
dp[1] = 1
for i in range(1, n):
for j, k in s:
if i + j > n:
continue
diff[i + j] += dp[i]
if i + k + 1 > n:
continue
diff[i + k + 1] -= dp[i]
dp[i] = (dp[i - 1] + diff[i]) % MOD
dp[i + 1] = (dp[i] + diff[i + 1]) % MOD
print(dp[n])
| def resolve():
n, k = map(int, input().split())
S = []
L, R = [], []
for _ in range(k):
l1, r1 = map(int, input().split())
L.append(l1)
R.append(r1)
dp = [0 for i in range(n + 1)]
dpsum = [0 for i in range(n + 1)]
dp[1] = 1
dpsum[1] = 1
for i in range(2, n + 1):
for j in range(k):
Li = i - R[j]
Ri = i - L[j]
if Ri < 0:
continue
Li = max(1, Li)
dp[i] += dpsum[Ri] - dpsum[Li - 1] # dp[Li] ~ dp[Ri]
dp[i] %= 998244353
dpsum[i] = (dpsum[i - 1] + dp[i]) % 998244353
print(dp[n])
resolve() | 1 | 2,681,295,745,116 | null | 74 | 74 |
import copy
H, W, K, = list(map(int, input().split()))
C = [0] * H
for i in range(H):
C[i] = input()
C[i] = [1 if(C[i][j] == "#") else 0 for j in range(W)]
h = 2 ** H
w = 2 ** W
ans = 0
for i in range(2 ** H):
w = 2 ** W
for j in range(2 ** W):
D = copy.deepcopy(C)
for k in range(H):
for l in range(W):
if(bin(h)[k + 3] == "1" or bin(w)[l + 3] == "1"):
D[k][l] = 0
ans += (sum(map(sum, D)) == K)
w += 1
h += 1
print(ans) | import sys
def input(): return sys.stdin.readline().rstrip()
from itertools import product
def main():
h, w, k = map(int,input().split())
C = [input() for _ in range(h)]
comb_list = list(product([False, True], repeat = h + w))
ans = 0
for comb in comb_list:
cunt = 0
for i in range(h):
if not comb[i]:
continue
for j in range(w):
if not comb[h+j]:
continue
if C[i][j] == '#':
cunt += 1
if cunt == k:
ans += 1
print(ans)
if __name__=='__main__':
main() | 1 | 8,898,768,031,680 | null | 110 | 110 |
import math
x = int(input())
n = 100
y = 0
while x > n:
# 小数点以下切り捨て
n += n // 100
y += 1
print(y) | X=int(input())
i=0
t=100
while(t<X):
t *= 101
t = int(t//100)
i += 1
print(i) | 1 | 27,274,716,733,042 | null | 159 | 159 |
card = []
suit = ["S","H","C","D"]
for s in suit:
for i in range(1,14):
card.append(s + " " + str(i))
n = int(input())
for i in range(n):
card.remove(input())
for c in card:
print(c) | import math
n = int(input())
sq = int(math.sqrt(n))
i=sq
for i in range(sq,0,-1):
if n%i==0:
j=n//i
break
print(i+j-2) | 0 | null | 81,436,718,802,560 | 54 | 288 |
n, m = map(int, input().split())
A = list(map(int, input().split()))
s = 0
for i in range(m):
s += A[i]
if s > n:
print(-1)
elif s <= n:
print(n - s) | import sys
from collections import deque
input = sys.stdin.readline
def dfs(N):
alphabet = "abcdefghij"
stack = deque(["a"])
while stack:
s = stack.pop()
if len(s) == N:
print(s)
continue
for suffix in reversed(alphabet[:len(set(s)) + 1]):
stack.append("".join((s, suffix)))
def main():
N = int(input())
dfs(N)
if __name__ == "__main__":
main()
| 0 | null | 42,214,067,913,238 | 168 | 198 |
import sys
from collections import Counter
from itertools import combinations
def input():
return sys.stdin.readline().strip()
sys.setrecursionlimit(20000000)
MOD = 10 ** 9 + 7
INF = float("inf")
def main():
N = int(input())
L = list(map(int, input().split()))
count = Counter(L)
key = count.keys()
set_list = combinations(key, 3)
answer = 0
for s in set_list:
a = s[0]
b = s[1]
c = s[2]
if (a + b) > c and (b + c) > a and (c + a) > b:
answer += count[a] * count[b] * count[c]
print(answer)
if __name__ == "__main__":
main()
| A, B, N = map(int, input().split())
if N >= B - 1:
print(int(A * (B - 1) / B))
else:
print(int(A * N / B)) | 0 | null | 16,541,285,937,892 | 91 | 161 |
#ABC157E
n = int(input())
s = list(input())
q = int(input())
bits = [[0 for _ in range(n+1)] for _ in range(26)]
sl = []
for alp in s:
alpord = ord(alp) - 97
sl.append(alpord)
#print(bits) #test
#print(sl) #test
#print('クエリ開始') #test
def query(pos):
ret = [0] * 26
p = pos
while p > 0:
for i in range(26):
ret[i] += bits[i][p]
p -= p&(-p)
return ret
def update(pos, a, x):
r = pos
while r <= n:
bits[a][r] += x
r += r&(-r)
for i in range(n):
update(i+1, sl[i], 1)
#print(bits) #test
for _ in range(q):
quer, xx, yy = map(str, input().split())
if quer == '1':
x = int(xx)
y = ord(yy) - 97
if sl[x-1] == y:
continue
else:
update(x, sl[x-1], -1)
update(x, y, 1)
sl[x-1] = y
#print('クエリ1でした') #test
#print(bits) #test
#print(sl) #test
else:
x = int(xx)
y = int(yy)
cnt1 = query(y)
cnt2 = query(x-1)
#print('クエリ2です') #test
#print(cnt1) #test
#print(cnt2) #test
ans = 0
for i in range(26):
if cnt1[i] - cnt2[i] > 0:
ans += 1
print(ans) | import sys
sys.setrecursionlimit(2147483647)
INF = 1 << 60
MOD = 10**9 + 7 # 998244353
input = lambda:sys.stdin.readline().rstrip()
class SegmentTree(object):
def __init__(self, A, dot, unit):
n = 1 << (len(A) - 1).bit_length()
tree = [unit] * (2 * n)
for i, v in enumerate(A):
tree[i + n] = v
for i in range(n - 1, 0, -1):
tree[i] = dot(tree[i << 1], tree[i << 1 | 1])
self._n = n
self._tree = tree
self._dot = dot
self._unit = unit
def __getitem__(self, i):
return self._tree[i + self._n]
def update(self, i, v):
i += self._n
self._tree[i] = v
while i != 1:
i >>= 1
self._tree[i] = self._dot(self._tree[i << 1], self._tree[i << 1 | 1])
def add(self, i, v):
self.update(i, self[i] + v)
def sum(self, l, r):
l += self._n
r += self._n
l_val = r_val = self._unit
while l < r:
if l & 1:
l_val = self._dot(l_val, self._tree[l])
l += 1
if r & 1:
r -= 1
r_val = self._dot(self._tree[r], r_val)
l >>= 1
r >>= 1
return self._dot(l_val, r_val)
def resolve():
n = int(input())
trees = [[0] * n for _ in range(26)]
character = [None] * n
for i, c in enumerate(input()):
c = ord(c) - ord('a')
character[i] = c
trees[c][i] = 1
for i in range(26):
trees[i] = SegmentTree(trees[i], max, 0)
for _ in range(int(input())):
q, *A = input().split()
if q == '1':
i, c = A
i = int(i) - 1
c = ord(c) - ord('a')
trees[character[i]].update(i, 0)
character[i] = c
trees[c].update(i, 1)
else:
l, r = map(int, A)
l -= 1
print(sum(trees[i].sum(l, r) for i in range(26)))
resolve() | 1 | 62,410,601,974,468 | null | 210 | 210 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.