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
|
|---|---|---|---|---|---|---|
S=input()
if (S[2]==S[3]) and (S[4]==S[5]):print('Yes')
else:print('No') | n = int(input())
numOfColors = 0
edges = [[] for j in range(n+1)]
ngColor = [-1]*(n+1)
outsI = [[] for j in range(n+1)]
outs = [0]*(n-1)
for i in range(n-1):
a, b = map(int, input().split())
edges[a].append(b)
outsI[a].append(i)
numOfColors = len(edges[1])
for i in range(2, len(edges)):
numOfColors = max(len(edges[i])+1, numOfColors)
#print(edges)
#print(outsI)
for i in range(len(edges[1])):
ngColor[edges[1][i]] = i+1
outs[outsI[1][i]] = i+1
queue = []
queue.extend(edges[1])
while queue != []:
v = queue.pop(0)
c = 0
for i in range(len(edges[v])):
c += 1
if c == ngColor[v]:
c += 1
ngColor[edges[v][i]] = c
outs[outsI[v][i]] = c
queue.extend(edges[v])
#print(ngColor)
print(numOfColors)
for out in outs:
print(out)
| 0 | null | 89,313,661,259,004 | 184 | 272 |
import collections
N=int(input())
A=list(map(int,input().split()))
D = collections.Counter(A)
s=0
for i in D:
s+=D[i]*(D[i]-1)//2
for i in range(N):
print(s-(D[A[i]]-1)) | while(True):
try:
(a, b) = map(int, input().split(" "))
(x, y) = (a, b)
while (x != 0):
(x, y) = (y%x, x)
print("%s %s" %(y, a*b//y))
except:
break | 0 | null | 23,744,256,756,700 | 192 | 5 |
from collections import Counter
N, P = map(int, input().split())
S = input()
if 10 % P == 0:
ans = 0
for i, s in enumerate(S, start=1):
if int(s) % P != 0:
continue
ans += i
print(ans)
else:
X = [0]
for i, s in enumerate(S[::-1]):
X.append((X[-1] + pow(10, i, P) * int(s)) % P)
C = Counter(X)
ans = 0
for v in C.values():
ans += v * (v - 1) // 2
print(ans)
| ## coding: UTF-8
N, P = map(int,input().split())
S = input()[::-1]
remainder = [0] * P
tmp = 0
rad = 1 #10**(i) % P
'''
if(P == 2 or P == 5):
for i in range(N):
r = int(S[i])
tmp += r * rad
tmp %= P
remainder[tmp] += 1
rad *= 10
'''
if(P == 2):
ans = 0
for i in range(N):
r = int(S[i])
if(r % 2 == 0):
ans += N-i
print(ans)
elif(P == 5):
ans = 0
for i in range(N):
r = int(S[i])
if(r % 5 == 0):
ans += N-i
print(ans)
else:
for i in range(N):
r = int(S[i])
tmp += r * rad
tmp %= P
remainder[tmp] += 1
rad *= 10
rad %= P
remainder[0] += 1
#print(remainder)
ans = 0
for i in range(P):
e = remainder[i]
ans += e*(e-1)/2
print(int(ans))
| 1 | 58,007,556,005,982 | null | 205 | 205 |
x = list(map(int,input().split()))
if(len(str(x[0])) < 2 and len(str(x[1])) < 2):
print(x[0] * x[1])
else:
print(-1) | #144-A
A,B = map(int,input().split())
if 1 <= A <= 9 and 1 <= B <= 9:
print(A*B)
else:
print(-1)
| 1 | 158,559,637,640,726 | null | 286 | 286 |
#!/usr/bin/env python3
def main():
if int(input()) >= 30:
print('Yes')
else:
print('No')
if __name__ == "__main__":
main()
| a=int(input())
b=int(input())
ab={a,b}
s={1,2,3}
ss=s-ab
print(list(ss)[0]) | 0 | null | 58,434,765,549,202 | 95 | 254 |
A, B, C, K = map(int, input().split())
count_A = 0
count_B = 0
count_C = 0
count = 0
if A >= K:
count_A += K
else: # A < K
K -= A
count_A += A
if B >= K:
count_B += K
else:
K -= B
count_B += B
count_C += K
print(count_A - count_C)
| #!/usr/bin/env python
# -*- coding: utf-8 -*-
import math
n = input()
debt = 1e5
for i in range(0, n):
debt *= 1.05
debt = math.ceil(debt/1000) * 1000
print int(debt) | 0 | null | 10,878,271,563,080 | 148 | 6 |
N=int(input())
x=[0]*N
for i in range(N):
x[i]=list(map(int,input().split()))
#print(x)
z=[0]*N
w=[0]*N
for i in range(N):
z[i]=x[i][0]+x[i][1]
w[i]=x[i][0]-x[i][1]
print(max(max(z)-min(z),max(w)-min(w)))
| N = int(input())
M0 = M1 = -float('inf')
m0 = m1 = float('inf')
for _ in range(N):
x, y = map(int, input().split())
M0 = max(M0, x - y)
m0 = min(m0, x - y)
M1 = max(M1, x + y)
m1 = min(m1, x + y)
print(max(M0 - m0, M1 - m1)) | 1 | 3,379,673,569,078 | null | 80 | 80 |
a1, a2, a3 = map(int, input().split())
x = a1 + a2 + a3
print('win' if x <= 21 else 'bust') | n,m,l = map(int, input().split())
count = n+m+l
if count > 21:
print("bust")
else:
print("win")
| 1 | 118,821,130,865,120 | null | 260 | 260 |
n="0"+input()
k=int(input())
dp=[[[0]*5,[0]*5] for _ in range(len(n))]
dp[0][1][0]=1
for i in range(1,len(n)):
x=int(n[i])
for j in range(4):
if dp[i-1][1][j]:
dp[i][1][j+(x!=0)]=1
if x>1:
dp[i][0][j+1]+=(x-1)
dp[i][0][j]+=1
elif x==1:
dp[i][0][j]+=1
if dp[i-1][0][j]:
dp[i][0][j]+=dp[i-1][0][j]
dp[i][0][j+1]+=(dp[i-1][0][j]*9)
dp[i][0][0]=1
print(dp[-1][0][k]+dp[-1][1][k]) | # from collections import defaultdict
import math
def comb(n, r):
return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))
N = int(input())
K = int(input())
keta = len(str(N))
dp = [[0]*(keta) for i in range(4)]
ans = 0
for k in range(1, 4):
for i in range(1, keta):
if i<k:
continue
else:
dp[k][i] = comb(i-1, i-k)*(9**k)
#print(dp)
# dp[k][i]: i桁で、k個の0でない数
ans += sum(dp[K]) # (N の桁)-1 までの累積和
count = 0
for j in range(keta):
t = int(str(N)[j])
if j==0:
count+=1
ans += sum(dp[K-count])*(t-1)
if count == K: # K==1
ans+=t
break
continue
elif j==keta-1:
if t!=0:
count+=1
if count==K:
ans+=t
break
if t !=0:
count+=1
if count==K:
ans+=sum(dp[K-count+1][:keta-j]) #0のとき
ans+=t
break
ans += sum(dp[K-count][:keta-j])*(t-1) #0より大きいとき
ans += sum(dp[K-count+1][:keta-j]) #0のとき
print(ans) | 1 | 76,100,273,301,702 | null | 224 | 224 |
from sys import stdin, stdout
n,k=map(int,input().split())
a=[int(o) for o in input().split()]
prod=1
for i in range(k,n):
prev=a[i-k]
if a[i]>prev: stdout.write("Yes\n")
else: stdout.write("No\n")
| T1, T2 = map(int, input().split())
A1, A2 = map(int, input().split())
B1, B2 = map(int, input().split())
c1 = T1*A1-T1*B1
c2 = T2*A2-T2*B2
if c1 > 0:
c1 *= -1
c2 *= -1
power = c1+c2
if power == 0:
print('infinity')
elif power < 0:
print(0)
else:
ans = 2*(-c1//power)+(c1%power > 0)
print(ans) | 0 | null | 69,641,209,483,032 | 102 | 269 |
# https://atcoder.jp/contests/abc167/tasks/abc167_d
# コンテスト中は周期性を用いたが、今回はdoublingで解いてみる
import sys
sys.setrecursionlimit(1 << 25)
read = sys.stdin.readline
ra = range
enu = enumerate
def exit(*argv, **kwarg):
print(*argv, **kwarg)
sys.exit()
def mina(*argv, sub=1): return list(map(lambda x: x - sub, argv))
# 受け渡されたすべての要素からsubだけ引く.リストを*をつけて展開しておくこと
def ints(): return list(map(int, read().split()))
MOD = 10**9 + 7
INF = 2**31 # 2147483648 > 10**9
# default import
from collections import defaultdict, Counter, deque
from operator import itemgetter, xor, add
from itertools import product, permutations, combinations
from bisect import bisect_left, bisect_right # , insort_left, insort_right
from functools import reduce
N, K = ints()
A = mina(*ints())
# 10^18のは60bitで表せるのでnxt tableをつくるのに最大1.2 * 10^7 ぐらい。ギリ間に合いそう
nxt = [[-1] * N for _ in ra(K.bit_length())] # [k][v]...vから2^k回移動したノード
# 初期化
for v, nx in enu(A):
nxt[0][v] = nx
# テーブル埋め
for k in ra(K.bit_length() - 1):
for v in ra(N):
nxt[k + 1][v] = nxt[k][nxt[k][v]]
# 答えの取得
now = 0 # はじめは0地点にいる
for k in ra(K.bit_length()):
if (K >> k) & 1:
# kbit目が立ってたらこの回数分だけ移動
now = nxt[k][now]
print(now + 1)
| n,k = map(int,input().split())
a = list(map(int,input().split()))
next = [[0]*n for _ in range(60)]
for v in range(n):
next[0][v] = a[v]-1
for d in range(60-1):
for v in range(n):
next[d+1][v] = next[d][next[d][v]]
v = 0
for d in range(60):
if k>>d&1:
v = next[d][v]
print(v+1) | 1 | 22,810,130,669,378 | null | 150 | 150 |
import os, sys, re, math
C = input()
print(chr(ord(C) + 1))
| n = int(input())
L11= [0] * 10
L12= [0] * 10
L13= [0] * 10
L21= [0] * 10
L22= [0] * 10
L23= [0] * 10
L31= [0] * 10
L32= [0] * 10
L33= [0] * 10
L41= [0] * 10
L42= [0] * 10
L43= [0] * 10
for i in range(n):
b,f,r,v = map(int, input().split())
r -= 1
if b == 1:
if f == 1:
L11[r] += v
if f == 2:
L12[r] += v
if f == 3:
L13[r] += v
if b == 2:
if f == 1:
L21[r] += v
if f == 2:
L22[r] += v
if f == 3:
L23[r] += v
if b == 3:
if f == 1:
L31[r] += v
if f == 2:
L32[r] += v
if f == 3:
L33[r] += v
if b == 4:
if f == 1:
L41[r] += v
if f == 2:
L42[r] += v
if f == 3:
L43[r] += v
def PV(L):
for i in range(9):
print(" " + str(L[i]), end="")
print(" " + str(L[9]))
def PL():
print("#" * 20)
PV(L11)
PV(L12)
PV(L13)
PL()
PV(L21)
PV(L22)
PV(L23)
PL()
PV(L31)
PV(L32)
PV(L33)
PL()
PV(L41)
PV(L42)
PV(L43) | 0 | null | 46,817,396,056,718 | 239 | 55 |
# 問題：https://atcoder.jp/contests/abc142/tasks/abc142_c
n = int(input())
a = list(map(int, input().strip().split()))
appear_attendance_number = {}
for i in range(n):
appear_attendance_number[a[i]-1] = i+1
res = []
for i in range(n):
res.append(appear_attendance_number[i])
print(' '.join(map(str, res)))
| import math
from decimal import Decimal
A, B = input().split()
A = int(A)
B = Decimal(B)
C = A * B
ans = math.floor(C)
print(ans)
| 0 | null | 98,586,865,435,538 | 299 | 135 |
n = int(input())
print((n+1)//2)
| def main():
n = int(input())
div, mod = divmod(n, 2)
if mod != 0:
print(div + 1)
else:
print(div)
if __name__ == '__main__':
main() | 1 | 58,669,906,949,980 | null | 206 | 206 |
N = int(input())
X = list(map(int, input().split()))
count = 0
ave = round(sum(X) / len(X))
for i in X:
count += (i - ave)**2
print(count) | #hは時間,mは60未満の分,sは60未満の秒
S=int(input())
h=int(S/3600)
m=int(S%3600/60)
s=int(S%3600%60)
print(str(h)+":"+str(m)+":"+str(s))
| 0 | null | 32,838,510,319,158 | 213 | 37 |
n = int(input())
a = 0
b = 0
for _ in range(n):
word_a, word_b = input().split()
words = [word_a, word_b]
words.sort()
if word_a == word_b:
a += 1
b += 1
elif words.index(word_a) == 1:
a += 3
else:
b += 3
print(a, b) | ans = list(map(int, input().split(' '))).index(0) + 1
print(ans) | 0 | null | 7,663,638,956,010 | 67 | 126 |
from collections import defaultdict
def main():
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
S = [0] * (N + 1) # 累積和
for i in range(1, N + 1):
S[i] = S[i - 1] + A[i - 1]
T = [(s - i) % K for i, s in enumerate(S)]
counter = defaultdict(int)
ans = 0
for j in range(N + 1):
if j >= K:
counter[T[j - K]] -= 1
ans += counter[T[j]]
counter[T[j]] += 1
print(ans)
if __name__ == '__main__':
main()
| import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")
n,k = list(map(int, input().split()))
a = list(map(int, input().split()))
def cumsum(a):
"""※ aを破壊する
l[i] = sum(a[:i]) なるlを返す
sum(a[i:j]) == l[j+1] - l[i]
"""
c = 0
n = len(a)
a.insert(0, 0)
for i in range(1, n+1):
a[i] = a[i-1]+a[i]
return a
a = cumsum(a)
aa = [((item - i)%k) for i,item in enumerate(a)]
ans = 0
from collections import defaultdict
c = defaultdict(int)
for i in range(min(k, len(aa))):
c[aa[i]] += 1
for i,item in enumerate(aa):
c[item] -= 1
# print(c, item)
ans += c[item]
if i+k<n+1:
c[aa[i+k]] += 1
print(ans) | 1 | 136,951,328,236,646 | null | 273 | 273 |
def isprime(n):
if n == 2:
return True
if n % 2 == 0:
return False
i = 3
while i * i <= n:
if n % i == 0:
return False
i += 2
return True
result = 0
for i in range(int(input())):
result += isprime(int(input()))
print(result) | #coding: UTF-8
def isPrime(n):
if n == 1:
return False
import math
m = math.floor(math.sqrt(n))
for i in range(2,m+1):
if n % i == 0:
return False
return True
n = int(input())
count = 0
for j in range(n):
m = int(input())
if isPrime(m):
count += 1
print(count)
| 1 | 9,340,355,372 | null | 12 | 12 |
n = map(int, input().split())
print('bust' if sum(n) >= 22 else 'win') | import bisect
N = int(input())
Kaijo = [1 for _ in range(N)]
for i in range(2,N+1):
Kaijo[-i] = Kaijo[1-i]*i
#print(Kaijo)
L = [i+1 for i in range(N)]
P = list(map(int,input().split()))
PN = 0
for i in range(N-1):
k = bisect.bisect_left(L, P[i])
L.remove(P[i])
PN += k*Kaijo[i+1]
#print(PN)
L = [i+1 for i in range(N)]
Q = list(map(int,input().split()))
QN = 0
for i in range(N-1):
k = bisect.bisect_left(L, Q[i])
L.remove(Q[i])
QN += k*Kaijo[i+1]
ans = abs(PN-QN)
print(ans) | 0 | null | 109,268,888,895,222 | 260 | 246 |
import math
n=int(input())
def koch(d,p1,p2):
if d==0:
return
s=[0,0]
t=[0,0]
u=[0,0]
s[0]=2/3*p1[0]+1/3*p2[0]
s[1]=2/3*p1[1]+1/3*p2[1]
t[0]=1/3*p1[0]+2/3*p2[0]
t[1]=1/3*p1[1]+2/3*p2[1]
u[0]=s[0]+(t[0]-s[0])*math.cos(math.pi/3)-(t[1]-s[1])*math.sin(math.pi/3)
u[1]=s[1]+(t[0]-s[0])*math.sin(math.pi/3)+(t[1]-s[1])*math.cos(math.pi/3)
koch(d-1,p1,s)
print(*s)
koch(d-1,s,u)
print(*u)
koch(d-1,u,t)
print(*t)
koch(d-1,t,p2)
print(0,0)
koch(n,[0,0],[100,0])
print(100,0)
| W, H, x, y, r = map(int, input().split())
if x - r < 0 or x + r > W or y - r < 0 or y + r > H:
print('No')
else:
print('Yes')
| 0 | null | 293,816,572,442 | 27 | 41 |
a, b, h, m = map(int, input().split())
import math
s = abs(360*((h/12)+(m/720)) - 360*(m/60))
print(math.sqrt(a**2+b**2-2*a*b*math.cos(math.radians(s))))
| s = input()[::-1]
size = len(s)
s += "4"
ans = 0
bef = 0
for i in range(size):
v1 = int(s[i])
v2 = int(s[i+1])
if v1+bef>=6 or (v1+bef>=5 and v2>=5):
ans += 10-(v1+bef)
bef = 1
else:
ans += (v1+bef)
bef = 0
ans += bef
print(ans) | 0 | null | 45,400,126,738,372 | 144 | 219 |
n,a,b=map(int,input().split())
k = n//(a+b)
print(k*a + min(a,n%(a+b))) | import sys
def MI(): return map(int,sys.stdin.readline().rstrip().split())
N,A,B = MI()
q = N // (A+B)
r = N % (A+B)
print(q*A+min(r,A))
| 1 | 55,851,444,034,110 | null | 202 | 202 |
N, M = map(int, input().split())
A = list(set(map(lambda x : int(x)//2, input().split())))
def _gcd(a, b):
return a if b == 0 else _gcd(b, a%b)
def _lcm(a,b):
return (a*b) // _gcd(a,b)
lcm = A[0]
for ai in A[1:]:
lcm = _lcm(lcm, ai)
ret = (M//lcm + 1)//2
for ai in A[1:]:
if (lcm // ai) % 2 == 0:
ret = 0
break
print(ret)
| from math import gcd
from functools import reduce
import sys
input = sys.stdin.readline
def lcm(a, b):
return a*b // gcd(a, b)
def count_factor_2(num):
count = 0
while num % 2 == 0:
num //= 2
count += 1
return count
def main():
n, m = map(int, input().split())
A = list(map(lambda x: x//2, set(map(int, input().split()))))
check = len(set(map(count_factor_2, A)))
if check != 1:
print(0)
return
lcm_a = reduce(lcm, A)
step = lcm_a * 2
ans = (m + lcm_a) // step
print(ans)
if __name__ == "__main__":
main()
| 1 | 102,216,494,101,652 | null | 247 | 247 |
S,W = list(map(int,input().split()))
if W >= S:print('unsafe')
else: print('safe') | n, m = map(int, input().split())
C = list(map(int, input().split()))
INF = 10**5
dp = [INF for _ in range(n+1)]
dp[0] = 0
for i in range(n):
for c in C:
if i + c <= n:
dp[i+c] = min(dp[i+c], dp[i]+1)
print(dp[n]) | 0 | null | 14,785,855,294,558 | 163 | 28 |
while True:
x,y=map(int,input().split())
if (x==0) & (y==0):
break
else:
if x>y:
print(y,x)
else:
print(x,y) | while True:
x, y = map(int, input().split())
if x == 0 and y == 0:
break
if x <= y:
print(f'{x} {y}')
else:
print(f'{y} {x}')
| 1 | 527,373,028,800 | null | 43 | 43 |
#!/usr/bin/env python3
print("x"*len(input()))
| import math
c = math.cos(math.radians(60))
s = math.sin(math.radians(60))
def koch(d,p1,p2):
if d == 0:
return
sx = (2 * p1[0] + p2[0]) / 3
sy = (2 * p1[1] + p2[1]) / 3
tx = (p1[0] + p2[0] * 2) / 3
ty = (p1[1] + p2[1] * 2) / 3
dx = tx - sx
dy = ty - sy
ux = dx * c - dy * s + sx
uy = dx * s + dy * c + sy
koch(d-1,p1,(sx,sy))
print("{0:.8f} {1:.8f}".format(sx,sy))
koch(d-1,(sx,sy),(ux,uy))
print("{0:.8f} {1:.8f}".format(ux,uy))
koch(d-1,(ux,uy),(tx,ty))
print("{0:.8f} {1:.8f}".format(tx,ty))
koch(d-1,(tx,ty),p2)
n = int(input())
print("{0:.8f} {1:.8f}".format(0,0))
koch(n,(0,0),(100,0))
print("{0:.8f} {1:.8f}".format(100,0))
| 0 | null | 36,433,500,888,690 | 221 | 27 |
def prime_numbers(n):
cnds = [True] * n
for x in xrange(2, int(n**0.5 + 1)):
if cnds[x]:
for m in xrange(2*x, n, x):
cnds[m] = False
return [i for i in xrange(2, n) if cnds[i]]
def is_prime(n):
return all(n % m for m in primes if m < n)
primes = prime_numbers(10**4)
N = input()
print sum(is_prime(input()) for i in range(N)) | def f(i):
if i == 2:return 1
return pow(2, i-1, i) == 1
print(sum(1 for n in range(int(input())) if f(int(input())))) | 1 | 9,257,387,502 | null | 12 | 12 |
#!/usr/bin/env python3
n = int(input())
a = []
for _ in range(n):
a.append([[*map(int, input().split())] for _ in range(int(input()))])
ans = 0
for i in range(2**n):
hone = set()
unki = set()
for j in range(n):
if i >> j & 1:
hone |= {j + 1}
for k in a[j]:
if k[1] == 1:
hone |= {k[0]}
else:
unki |= {k[0]}
else:
unki |= {j + 1}
if hone & unki == set():
ans = max(ans, len(hone))
print(ans)
| from itertools import product
n = int(input())
a = [[] for i in range(n)]
for i in range(n):
c = int(input())
for j in range(c):
x, y = map(int, input().split())
x-=1
a[i].append([x, y])
ans = 0
for c in product([1, 0], repeat=n):
f = True
for i, p in enumerate(c):
if p == 1:
for x, y in a[i]:
if c[x] != y:
f = False
break
if not f:
break
if f:
ans = max(ans, sum(c))
print(ans)
| 1 | 121,726,204,757,038 | null | 262 | 262 |
input_data = list(map(int,input().split()))
time = input_data[0] / input_data[2]
if time > input_data[1]:
print('No')
else:
print('Yes')
| D, T, S = map(float, input().split())
if D / S <= T:
print("Yes")
else:
print("No") | 1 | 3,594,352,627,772 | null | 81 | 81 |
n = int(input())
l = list(map(int, input().split()))
f = 1; c = 0
while f > 0:
f = 0
for j in range(n-1, 0, -1):
if l[j] < l[j-1]:
l[j], l[j-1] = l[j-1], l[j]
f = 1; c += 1
print(*l)
print(c)
| n = int(input())
a = list(map(int,input().split()))
a = sorted(a)
aMax = a[-1]
l = len(a)
count = 0
k = 0
kSet = set()
for i in range(n):
value = a[i]
if not(value in kSet):
if i != 0 and a[i-1] == value:
count -= 1
kSet.add(value)
continue
count += 1
j = 2
k = 0
while k < aMax:
k = a[i] * j
kSet.add(k)
j += 1
print(count) | 0 | null | 7,147,899,925,152 | 14 | 129 |
n = int(input())
S = []
T = []
for _ in range(n):
s, t = input().split()
S.append(s)
T.append(int(t))
x = input()
index = S.index(x)
if index == n - 1:
print(0)
else:
print(sum(T[index+1:]))
| n = int(input())
dp = [0]*(n+1)
for i in range(n+1):
if i == 0:
dp[i] = 1
elif i == 1:
dp[i] = 1
else:
dp[i] = dp[i-1] + dp[i-2]
print(dp[n])
| 0 | null | 48,712,242,979,510 | 243 | 7 |
def solve():
X = int(input())
a,b = divmod(X, 500)
print(1000*a + 5*(b//5))
if __name__ == "__main__":
solve() | import math
h=[int(input())for _ in range(2)]
n=int(input())
print(math.ceil(n/max(h))) | 0 | null | 65,821,708,359,008 | 185 | 236 |
n = int(input())
s = input()
if n % 2 == 1:
print('No')
else:
head = s[:n // 2]
tail = s[n // 2:]
if head == tail:
print('Yes')
else:
print('No')
| n = int(input())
s = input()
ans = 'No'
if n%2 == 0:
mid = int(n/2)
if s[:mid] == s[mid:]:
ans = 'Yes'
print(ans) | 1 | 146,336,769,035,620 | null | 279 | 279 |
N=int(input())
xp=yp=0
xn=yn=10**9
zs=[0]*N
ws=[0]*N
for i in range(N):
xi,yi=map(int,input().split())
zs[i]=xi+yi
ws[i]=xi-yi
zs.sort()
ws.sort()
ans=max(zs[-1]-zs[0],ws[-1]-ws[0])
print(ans) | def check(n, k, w, p):
i = 0
for j in range(k):
s = 0
while s + w[i] <= p:
s += w[i]
i += 1
if i == n:
return n
return i
n, k = map(int, input().split())
w = [int(input()) for _ in range(n)]
left, right = 0, 10 ** 10
while right - left > 1:
mid = (left + right) // 2
v = check(n, k, w, mid)
if v >= n:
right = mid
else:
left = mid
print(right)
| 0 | null | 1,758,499,563,610 | 80 | 24 |
n = int(input())
S, T = input().split()
ans = ""
for i in range(n):
ans += S[i]+T[i]
print(ans) | N=int(input())
S,T=input().split()
list=[]
for i in range(N):
list.append(S[i]+T[i])
print(''.join(list))
| 1 | 112,249,727,206,948 | null | 255 | 255 |
import math
def comb(x,y):
return math.factorial(x)//(math.factorial(x-y)*math.factorial(y))
n,m = map(int,input().split())
ans1=0
ans2=0
if n > 1:
ans1=comb(n,2)
if m > 1:
ans2=comb(m,2)
print(ans1+ans2) | import math
N,M=map(int,input().split())
al=math.factorial(N+M)/(math.factorial(2)*math.factorial(N+M-2))
di=N*M
print(int(al)-int(di)) | 1 | 45,539,735,000,440 | null | 189 | 189 |
# Nを１位上９以下の2つの整数の積として表せるならYes,できないならNo
N = int(input())
for i in range(1, 9+1):
if N%i == 0 and N//i <= 9:
print('Yes')
exit()
print('No') | n = int(input())
z= 0
for x in range(1,10):
for y in range(1,10):
if n == x * y:
z += 1
if z == 0:
print('No')
else:
print('Yes') | 1 | 159,947,730,386,272 | null | 287 | 287 |
def m():
MOD = 998244353
N = int(input())
D = [0] + list(map(int, input().split()))
if D[1] != 0:
return 0
tree = {1:1}
for i in range(2, N + 1):
if D[i] == 0: return 0
tree[D[i] + 1] = tree[D[i] + 1] + 1 if tree.get(D[i] + 1, False) else 1
height = len(tree.keys())+1
cnt = 1
for i in range(2, height):
if not tree.get(i, 0):
return 0
cnt = cnt * pow(tree[i-1], tree[i]) % MOD
return cnt
print(m())
| class SegmentTree():
def __init__(self, array, f, ti):
"""
Parameters
----------
array : list
to construct segment tree from
f : func
binary operation of the monoid
ti :
identity element of the monoid
"""
self.f = f
self.ti = ti
self.n = n = 2**(len(array).bit_length())
self.dat = dat = [ti] * n + array + [ti] * (n - len(array))
for i in range(n - 1, 0, -1): # build
dat[i] = f(dat[i << 1], dat[i << 1 | 1])
def update(self, p, v): # set value at position p (0-indexed)
f, n, dat = self.f, self.n, self.dat
p += n
dat[p] = v
while p > 1:
p >>= 1
dat[p] = f(dat[p << 1], dat[p << 1 | 1])
def query(self, l, r): # result on interval [l, r) (0-indexed)
f, ti, n, dat = self.f, self.ti, self.n, self.dat
res = ti
l += n
r += n
while l < r:
if l & 1:
res = f(res, dat[l])
l += 1
if r & 1:
r -= 1
res = f(dat[r], res)
l >>= 1
r >>= 1
return res
N, M = [int(_) for _ in input().split()]
S = [i if v == '0' else 10**5 + 5 for i, v in enumerate(input())]
ST = SegmentTree(S, min, 10**5 + 5)
i = N
ans = [i]
while i:
i2 = ST.query(max(0, i - M), i)
if i2 == 10**5 + 5:
print(-1)
exit()
i = i2
ans += [i]
ans = ans[::-1]
print(' '.join(str(b - a) for a, b in zip(ans, ans[1:])))
| 0 | null | 146,592,335,587,450 | 284 | 274 |
n,k=map(int,input().split())
a=list(map(int,input().split()))
visit=[0 for i in range(n)]
goal,loop=[],[]
now=0
while visit[now]!=2 :
if visit[now]==0 :
goal.append(now)
else :
loop.append(now)
visit[now]+=1
now=a[now]-1
if len(goal)>k :
print(goal[k]+1)
else :
res=len(goal)-len(loop)
print(loop[(k-res)%len(loop)]+1) | import collections
a = collections.deque()
for i in range(int(input())):
b = input()
# 命令がinsertだった場合、
if b[0] == 'i':
# キーxを先頭に追加(数字は文字列bの7文字目以降にある)
a.appendleft(b[7:])
# 命令がdeleteだった場合
elif b[6] == ' ':
# 命令のキーが含まれる場合そのキーのデータを消すが、なければ何もしない
try:
a.remove(b[7:])
except:
pass
# 命令がdeleteFirstだった場合
elif len(b) > 10:
a.popleft()
# 命令がdeleteLastだった場合
elif len(b) > 6:
a.pop()
print(*a)
| 0 | null | 11,394,030,578,788 | 150 | 20 |
import sys
n = int(sys.stdin.readline())
dict = {}
for _ in range(n):
op, key = input().split()
if op == "insert":
dict[key] = "insert"
continue
if op == "find":
print("yes") if key in dict.keys() else print("no")
| n = int(input())
index = set()
for _ in range(n):
command, string = input().split()
if command == "insert":
index.add(string)
else:
if string in index:
print("yes")
else:
print("no")
| 1 | 80,992,874,852 | null | 23 | 23 |
# author: Taichicchi
# created: 15.09.2020 21:22:26
import sys
X, K, D = map(int, input().split())
X = abs(X)
if X >= K * D:
print(X - (K * D))
else:
k = K - X // D
x = X - D * (X // D)
if k % 2:
print(abs(x - D))
else:
print(x)
| x, k, d = [int(i) for i in input().split()]
if x < 0:
x = -x
l = min(k, x // d)
k -= l
x -= l * d
if k % 2 == 0:
print(x)
else:
print(d - x) | 1 | 5,249,934,039,938 | null | 92 | 92 |
if __name__ == '__main__':
while True:
# ??????????????\???
deck = input()
if deck == '-':
break
shuffle_count = int(input())
positions = [int(input()) for _ in range(shuffle_count)]
# ?????£??????????????????
for p in positions:
first_half = deck[:p]
second_half = deck[p:]
deck = second_half + first_half
# ???????????????
print(deck) | import os
import sys
import numpy as np
def solve(N, M, A):
# n 以上上がる方法だけを試した時に、M 回以上の握手を行うことができるか
ok = 0
ng = 202020
while ok + 1 < ng:
c = ok+ng >> 1
cnt = 0
idx_A = N-1
for a1 in A:
while idx_A >= 0 and A[idx_A]+a1 < c:
idx_A -= 1
cnt += idx_A + 1
if cnt >= M:
ok = c
else:
ng = c
idx_A = N-1
cum_A = np.zeros(len(A)+1, dtype=np.int64)
cum_A[1:] = np.cumsum(A)
ans = 0
cnt = 0
for a1 in A:
while idx_A >= 0 and A[idx_A]+a1 < ok:
idx_A -= 1
cnt += idx_A + 1
ans += cum_A[idx_A+1] + (idx_A+1)*a1
ans -= (cnt-M) * ok
return ans
# >>> numba compile >>>
numba_config = [
[solve, "i8(i8,i8,i8[:])"],
]
if sys.argv[-1] == "ONLINE_JUDGE":
from numba import njit
from numba.pycc import CC
cc = CC("my_module")
for func, signature in numba_config:
vars()[func.__name__] = njit(signature)(func)
cc.export(func.__name__, signature)(func)
cc.compile()
exit()
elif os.name == "posix":
exec(f"from my_module import {','.join(func.__name__ for func, _ in numba_config)}")
else:
from numba import njit
for func, signature in numba_config:
vars()[func.__name__] = njit(signature, cache=True)(func)
print("compiled!", file=sys.stderr)
# <<< numba compile <<<
def main():
N, M = map(int, input().split())
A = np.array(sorted(map(int, input().split()), reverse=True), dtype=np.int64)
ans = solve(N, M, A)
print(ans)
main()
| 0 | null | 55,251,363,523,002 | 66 | 252 |
a,b,c=map(int,input().split())
d={"a":a,"b":b,"c":c}
for i in range(int(input())+1):
if d["a"]<d["b"]<d["c"]:
print("Yes")
exit()
elif d["a"]>=d["c"]: d["c"]*=2
elif d["a"]>=d["b"]: d["b"]*=2
elif d["b"]>=d["c"]: d["c"]*=2
print("No")
| S = input()
l = len(S)
a = ''
for i in range(len(S)):
a = a + 'x'
print(a) | 0 | null | 39,727,527,573,672 | 101 | 221 |
# -*- coding:utf-8 -*-
n = int(input())
import sys
a = input()
a = a.split()
a = [int(i) for i in a]
a.reverse()
for i in range(n-1):
print(a[i],end = ' ')
print(a[n-1]) | import math
import numpy as np
A, B, H, M = [int(i) for i in input().split()]
ji = np.array([A*math.cos(-math.pi/6*(H+M/60) + math.pi/2), A*math.sin(-math.pi/6*(H+M/60) + math.pi/2)])
hun = np.array([B*math.cos(-math.pi/30*M + math.pi/2), B*math.sin(-math.pi/30*M + math.pi/2)])
print(math.sqrt(((ji-hun)**2).sum())) | 0 | null | 10,490,402,277,600 | 53 | 144 |
#from statistics import median
#import collections
#aa = collections.Counter(a) # list to list || .most_common(2)で最大の2個とりだせるお a[0][0]
from fractions import gcd
from itertools import combinations,permutations,accumulate # (string,3) 3回
#from collections import deque
from collections import deque,defaultdict,Counter
import decimal
import re
#import bisect
#
# d = m - k[i] - k[j]
# if kk[bisect.bisect_right(kk,d) - 1] == d:
#
#
#
# pythonで無理なときは、pypyでやると正解するかも！！
#
#
import sys
sys.setrecursionlimit(10000000)
mod = 10**9 + 7
#mod = 9982443453
def readInts():
return list(map(int,input().split()))
def I():
return int(input())
ln = len(input())
print('x'*ln)
| l = len(input())
print('x'*l) | 1 | 72,898,286,152,968 | null | 221 | 221 |
import sys
input = sys.stdin.readline
class Node:
def __init__(self, val):
self.val = val
self.prev = None
self.next = None
class DoublyLinkedList:
def __init__(self):
self.sentinel = Node(None)
self.sentinel.prev = self.sentinel
self.sentinel.next = self.sentinel
def insert(self, val):
node = Node(val)
node.prev = self.sentinel
node.next = self.sentinel.next
self.sentinel.next.prev = node
self.sentinel.next = node
def delete(self, val):
self.delete_node(self.search(val))
def deleteFirst(self):
self.delete_node(self.sentinel.next)
def deleteLast(self):
self.delete_node(self.sentinel.prev)
def search(self, val):
cursor = self.sentinel.next
while cursor != self.sentinel and cursor.val != val:
cursor = cursor.next
return cursor
def delete_node(self, node):
if node == self.sentinel:
return
node.prev.next = node.next
node.next.prev = node.prev
n = int(input())
linked_list = DoublyLinkedList()
for index in range(n):
command = input().rstrip()
if command[0] == 'i':
linked_list.insert(command[7:])
elif command[6] == 'F':
linked_list.deleteFirst()
elif command[6] == 'L':
linked_list.deleteLast()
else:
linked_list.delete(command[7:])
node = linked_list.sentinel.next
output = []
while node != linked_list.sentinel:
output.append(node.val)
node = node.next
print(" ".join(map(str, output)))
| n = int(raw_input())
num_list = [int(raw_input()) for i in xrange(n)]
minv = num_list[0]
maxv = -1000000000
for i in xrange(1, n):
tmp = num_list[i] - minv
maxv = tmp if tmp > maxv else maxv
minv = num_list[i] if minv > num_list[i] else minv
# print "i = %d, tmp = %d, maxv = %d, minv = %d" % (i, tmp, maxv, minv)
print maxv | 0 | null | 30,066,268,672 | 20 | 13 |
while True:
H, W = map(int, input().split())
if not(H or W):
break
print('#' * W)
for i in range(H-2):
print('#', end='')
for j in range(W-2):
print('.', end='')
print('#')
print('#' * W, end='\n\n') | while(True):
h,w = [int(i) for i in input().split()]
if h == 0 and w == 0:
break
for i in range(h):
out = ''
for j in range(w):
if j == 0 or j == (w-1) or i == 0 or i == (h-1):
out += '#'
else :
out += '.'
print(out)
print('') | 1 | 804,548,707,328 | null | 50 | 50 |
n = int(input())
S = 100000
for i in range(n):
S = int(S*1.05)
slist = list(str(S))
if slist[-3:] == ['0','0','0'] :
S = S
else:
S = S - int(slist[-3])*100 - int(slist[-2])*10 - int(slist[-1])*1 + 1000
print(S)
| a=100000
n=int(input())
for i in range(n):
a=a*1.05
if a%1000 !=0:
a=a-(a%1000)+1000
print(int(a))
| 1 | 1,261,336,028 | null | 6 | 6 |
H, A = map(int, input().split())
print(abs(-1*H//A)) | import numpy as np
h, a = map(int, input().split())
print(int(np.ceil(h / a))) | 1 | 77,078,356,858,228 | null | 225 | 225 |
while True:
try:
print len(list(str(sum(map(int,raw_input().split())))))
except:
break | import sys
for line in sys.stdin:
a = int(line.split()[0])
b = int(line.split()[1])
s = a + b
print(len(str(s))) | 1 | 116,431,172 | null | 3 | 3 |
import numpy as np
from numba import njit
N = np.array([int(_) for _ in input()])
def solve(N):
p, q = 0, 1
for x in N:
p, q = min(p + x, q + 10 - x), min(p + x + 1, q + 9 - x)
print(p)
solve(N)
| def getN():
return int(input())
def getNM():
return map(int, input().split())
def getList():
return list(map(int, input().split()))
def getArray(intn):
return [int(input()) for i in range(intn)]
def input():
return sys.stdin.readline().rstrip()
def rand_N(ran1, ran2):
return random.randint(ran1, ran2)
def rand_List(ran1, ran2, rantime):
return [random.randint(ran1, ran2) for i in range(rantime)]
def rand_ints_nodup(ran1, ran2, rantime):
ns = []
while len(ns) < rantime:
n = random.randint(ran1, ran2)
if not n in ns:
ns.append(n)
return sorted(ns)
def rand_query(ran1, ran2, rantime):
r_query = []
while len(r_query) < rantime:
n_q = rand_ints_nodup(ran1, ran2, 2)
if not n_q in r_query:
r_query.append(n_q)
return sorted(r_query)
from collections import defaultdict, deque, Counter
from sys import exit
from decimal import *
import heapq
import math
from fractions import gcd
import random
import string
import copy
from itertools import combinations, permutations, product
from operator import mul, itemgetter
from functools import reduce
from bisect import bisect_left, bisect_right
import sys
sys.setrecursionlimit(1000000000)
mod = 10 ** 9 + 7
#############
# Main Code #
#############
N = input()
N = [int(i) for i in N]
# 数え上げ問題なので多分dp
dp = [[0, 0] for i in range(len(N))]
# ぴったし払うための最小値
dp[0][0] = min(N[0], 11 - N[0])
# お釣りをもらう用の紙幣を１枚余分にとっておく場合の最小値
dp[0][1] = min(N[0] + 1, 10 - N[0])
for i in range(1, len(N)):
# dp[i - 1][1] + 10 - N[i]:とっておいた紙幣を使用し、お釣りを10 - N[i]枚もらう
dp[i][0] = min(dp[i - 1][0] + N[i], dp[i - 1][1] + 10 - N[i])
# dp[i - 1][1] + 9 - N[i]:お釣りを10 - N[i]枚もらい、そのうち１枚は次のお釣りを
# もらう試行のためにとっておく
dp[i][1] = min(dp[i - 1][0] + N[i] + 1, dp[i - 1][1] + 9 - N[i])
print(dp[len(N) - 1][0]) | 1 | 70,882,216,366,430 | null | 219 | 219 |
x = int(input())
if 30 <= x:
print("Yes")
else:
print("No") | x = int(input())
money = 100
year = 0
while True:
money = money + money*100//10000
year += 1
if money >= x:
print(year)
exit() | 0 | null | 16,507,639,946,520 | 95 | 159 |
import re
import sys
import math
import itertools
import bisect
from copy import copy
from collections import deque,Counter
from decimal import Decimal
import functools
def v(): return input()
def k(): return int(input())
def S(): return input().split()
def I(): return map(int,input().split())
def X(): return list(input())
def L(): return list(input().split())
def l(): return list(map(int,input().split()))
def lcm(a,b): return a*b//math.gcd(a,b)
sys.setrecursionlimit(10 ** 6)
mod = 10**9+7
cnt = 0
ans = 0
inf = float("inf")
al = "abcdefghijklmnopqrstuvwxyz"
AL = al.upper()
n=k()
l=l()
a=[]
for i in range(n):
a.append(0)
for i in range(n-1):
a[l[i]-1]+=1
for i in range(n):
print(a[i])
| def count(i, s):
left = right = 0
for e in s:
if e == "(":
left += 1
else:
if left == 0:
right += 1
else:
left -= 1
return left-right, left, right, i
n = int(input())
S = [input() for i in range(n)]
s1 = []
s2 = []
for i, e in enumerate(S):
c = count(i, e)
# print(i, c)
if c[0] >= 0:
s1.append((c[2], c[3]))
else:
s2.append((-c[1], c[3]))
s1.sort()
s2.sort()
# print(s1, s2)
s = []
for e in s1:
s.append(S[e[1]])
for e in s2:
s.append(S[e[1]])
# print(s)
_, left, right, _ = count(0, "".join(s))
if left == right == 0:
print("Yes")
else:
print("No")
| 0 | null | 28,055,034,634,312 | 169 | 152 |
h, a = list(map(int, input().split()))
b = h/a
if int(b) == b:
print(int(b))
else:
print(int(b)+1) | import sys
A, B, M = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
c = []
for e in sys.stdin:
c.append(list(map(int, e.split())))
ans = min(a) + min(b)
for i in range(len(c)):
temp_val = a[c[i][0]-1] + b[c[i][1]-1] - c[i][2]
if temp_val < ans:
ans = temp_val
print(ans) | 0 | null | 65,522,035,916,148 | 225 | 200 |
s = list(input())
s = list(set(s))
print('Yes') if len(s) >1 else print('No') | S=list(input())
countA=0
countB=0
for i in range(3):
if S[i]=="A":
countA+=1
else:
countB+=1
if countA!=0 and countB!=0:
print("Yes")
else:
print("No") | 1 | 54,667,112,077,692 | null | 201 | 201 |
a = [list(map(int, input().split())) for i in range(3)]
n =int(input())
for k in range(n):
b = int(input())
for i in range(3):
for j in range(3):
if a[i][j] == b:
a[i][j] = 0
row0 = a[0] == [0, 0, 0]
row1 = a[1] == [0, 0, 0]
row2 = a[2] == [0, 0, 0]
colum0 = [a[0][0], a[1][0], a[2][0]] == [0, 0, 0]
colum1 = [a[0][1], a[1][1], a[2][1]] == [0, 0, 0]
colum2 = [a[0][2], a[1][2], a[2][2]] == [0, 0, 0]
diag0 = [a[0][0], a[1][1], a[2][2]] == [0, 0, 0]
diag1 = [a[2][0], a[1][1], a[0][2]] == [0, 0, 0]
if row0 or row1 or row2 or colum0 or colum1 or colum2 or diag0 or diag1:
print('Yes')
break
else:
print('No') | # encoding: utf-8
def main():
n = input()
t = map(int, raw_input().split())
q = input()
s = map(int, raw_input().split())
sum = 0
for a in s:
sum += 1 if a in t else 0
print sum
main() | 0 | null | 30,141,353,461,040 | 207 | 22 |
import sys, os
if 'local' in os.environ :
sys.stdin = open('./input.txt', 'r')
f = lambda:list(map(int, input().split()))
def gcd(a,b):
return b if a == 0 else gcd(b%a, a)
def quick_pow(x,n, mod):
ans= 1
while n:
if n&1:
ans *= x
ans %= mod
x *= x
x %= mod
n >>= 1
return ans
def solve():
mod = 1000000007
n = f()[0]
dirs = {}
all0 = 0
x0 = 0
y0 = 0
for _ in range(n):
a,b = f()
if a ==0 and b == 0:
all0 += 1
continue
if a == 0:
x0 += 1
continue
if b == 0:
y0 += 1
continue
if a <0:
a = -a
b = -b
g = gcd(abs(a),abs(b))
a //= g
b //= g
if a*b >0:
if (a,b) not in dirs:
dirs[(a,b)] = {}
dirs[(a,b)][0] = 0
dirs[(a,b)][1] = 0
dirs[(a,b)][0] = dirs[(a,b)][0]+ 1
else:
if (-b,a) not in dirs:
dirs[(-b,a)] = {}
dirs[(-b,a)][0] = 0
dirs[(-b,a)][1] = 0
dirs[(-b,a)][1] = dirs[(-b,a)][1] + 1
ans = 1
ans *= (quick_pow(2, x0, mod) + quick_pow(2, y0, mod)-1 + mod) % mod
ans %= mod
for _, l in dirs.items():
ans *= (quick_pow(2, l[0], mod) + quick_pow(2, l[1], mod)-1 + mod)%mod
ans %= mod
ans -= 1
if all0:
ans+= all0
ans += mod
ans%= mod
print(ans)
solve()
| s = sum(int(i) for i in input())
if s % 9 == 0:
print("Yes")
else:
print("No") | 0 | null | 12,590,025,206,688 | 146 | 87 |
data=list(map(int,input().split()))
if data[0]/data[1]<=data[2]:
print('Yes')
else:
print('No') | import sys
read = sys.stdin.buffer.read
def main():
N, D, A, *XH = map(int, read().split())
monster = [0] * N
for i, (x, h) in enumerate(zip(*[iter(XH)] * 2)):
monster[i] = (x, (h + A - 1) // A)
monster.sort()
X = [x for x, h in monster]
S = [0] * (N + 1)
idx = 0
ans = 0
for i, (x, h) in enumerate(monster):
d = h - S[i]
if d > 0:
right = x + 2 * D
while idx < N and X[idx] <= right:
idx += 1
S[i] += d
S[idx] -= d
ans += d
S[i + 1] += S[i]
print(ans)
return
if __name__ == '__main__':
main()
| 0 | null | 42,809,979,292,900 | 81 | 230 |
n, k = map(int, input().split())
#n=num of lagage
#k=num of trucks
a = []
#import sys
#input = sys.stdin.readline
a = [int(input()) for _ in range(n)]
def isOk(mx):
num_t = 0
t = 0
for i in range(n):
if a[i]>mx:
return False
t += a[i]
if t>mx:
t = a[i]
num_t += 1
if num_t == k:
return False
return True
l = sum(a)//k - 1
r = sum(a)
while l<r:
m = (l+r)//2
if isOk(m):
r = m
else:
m += 1
l = m
print(m)
| #from statistics import median
#import collections
#aa = collections.Counter(a) # list to list || .most_common(2)で最大の2個とりだせるお a[0][0]
from fractions import gcd
from itertools import combinations,permutations,accumulate # (string,3) 3回
#from collections import deque
from collections import deque,defaultdict,Counter
import decimal
import re
#import bisect
#
# d = m - k[i] - k[j]
# if kk[bisect.bisect_right(kk,d) - 1] == d:
#
#
#
# pythonで無理なときは、pypyでやると正解するかも！！
#
#
# my_round_int = lambda x:np.round((x*2 + 1)//2)
# 四捨五入
import sys
sys.setrecursionlimit(10000000)
mod = 10**9 + 7
#mod = 9982443453
def readInts():
return list(map(int,input().split()))
def I():
return int(input())
n = I()
S = input()
ans = 0
for i in range(1000):
nya = str(i).zfill(3)
x = S.find(nya[0])
y = S.find(nya[1], x+1)
z = S.find(nya[2], y+1)
if x != -1 and y != -1 and z != -1:
ans += 1
print(ans)
| 0 | null | 64,282,261,018,528 | 24 | 267 |
str = input()
for q in range(int(input())):
com, *num = input().strip().split()
a, b = int(num[0]), int(num[1])
if com == 'print':
print(str[a:b+1])
elif com == 'replace':
str = str[:a] + num[2] + str[b+1:]
else: # com == 'reverse'
str = str[:a] + str[a:b+1][::-1] + str[b+1:] | def getN():
return int(input())
def getNM():
return map(int, input().split())
def getList():
return list(map(int, input().split()))
def getArray(intn):
return [int(input()) for i in range(intn)]
def input():
return sys.stdin.readline().rstrip()
from collections import defaultdict, deque, Counter
from sys import exit
import heapq
import math
import fractions
import copy
from itertools import permutations
from operator import mul
from functools import reduce
from bisect import bisect_left, bisect_right
import sys
sys.setrecursionlimit(1000000000)
mod = 10 ** 9 + 7
A, B, M = getNM()
# それぞれ冷蔵庫の値段
ref_a = getList()
ref_b = getList()
# 一枚だけ使える
ticket = [getList() for i in range(M)]
ans = min(ref_a) + min(ref_b)
for i in ticket:
opt = ref_a[i[0] - 1] + ref_b[i[1] - 1] - i[2]
ans = min(ans, opt)
print(ans) | 0 | null | 28,163,956,778,844 | 68 | 200 |
# coding: utf-8
list = []
for i in range(10):
list.append(int(input()))
slist = sorted(list)
for i in range(3):
print(slist[9-i]) | r=map(float,raw_input().split())
x=r[0]-r[2]
y=r[1]-r[3]
if x<0:
x=x*-1
if y<0:
y=y*-1
print (x**2+y**2)**0.5 | 0 | null | 81,088,699,888 | 2 | 29 |
import math
r = input()
s = r * r * math.pi
l = 2 * r * math.pi
print "%.6f %.6f" %(s, l) | k = int(input())
num = 7 % k
ans = 1
mod = [0 for _ in range(k)]
mod[num] = 1
while(num):
num = (num * 10 + 7) % k
if mod[num] > 0:
ans = -1
break
ans += 1
mod[num] += 1
print(ans)
| 0 | null | 3,420,562,643,970 | 46 | 97 |
m1, d1 = map(int, input().split())
m2, d2 = map(int, input().split())
print(1 if m2 == m1 % 12 + 1 and d2 == 1 else 0) | n_1 = list(map(int, input().split()))
n_2 = list(map(int, input().split()))
if n_1[0] != n_2[0]:
print(1)
else:
print(0) | 1 | 123,953,800,651,372 | null | 264 | 264 |
n = int(input())
cum = 0
d = dict()
for _ in range(n):
a, b = input().split()
b = int(b)
cum += b
d[a] = cum
c = input()
print(cum - d[c]) | N = int(input())
ST = [list(input().split()) for _ in [0]*N]
X = input()
ans = 0
for i,st in enumerate(ST):
s,t = st
if X==s:
break
for s,t in ST[i+1:]:
ans += int(t)
print(ans) | 1 | 96,831,756,151,140 | null | 243 | 243 |
def main():
s = input()
print(s[:3])
if __name__ == '__main__':
main()
| import math
n = int(input())
x = list(map(int, input().split()))
y = list(map(int, input().split()))
tmp = [[0 for i in range(6)] for j in range(n+1)]
absDiff = abs(x[0]-y[0])
tmp[0][3] = tmp[0][0] = absDiff
tmp[0][4] = tmp[0][1] = absDiff ** 2
tmp[0][5] = tmp[0][2] = absDiff ** 3
max = absDiff
for i in range(1, n, 1):
absDiff = abs(x[i]-y[i])
tmp[i][0] = absDiff
tmp[i][1] = absDiff ** 2
tmp[i][2] = absDiff ** 3
tmp[i][3] = tmp[i-1][3] + tmp[i][0]
tmp[i][4] = tmp[i-1][4] + tmp[i][1]
tmp[i][5] = tmp[i-1][5] + tmp[i][2]
if absDiff > max:
max = absDiff
print(tmp[n-1][3])
print(math.sqrt(tmp[n-1][4]))
print(tmp[n-1][5] ** (1/3))
print(max) | 0 | null | 7,502,519,491,950 | 130 | 32 |
def getprimes(n):
primes = []
for i in xrange(2, n+1):
isprime = True
for j in xrange(len(primes)):
if i % primes[j] == 0:
isprime = False
break
if isprime:
primes.append(i)
return primes
n = int(raw_input())
primes = getprimes(10000)
count = 0
for _ in xrange(n):
x = int(raw_input())
isprime = True
for i in xrange(len(primes)):
if primes[i] >= x:
break
if x % primes[i] == 0:
isprime = False
break
if isprime:
count += 1
print count | class Queue:
def __init__(self,values):
self.values = values
def empty(self):
if len(self.values) == 0:
return True
else:
return False
def enqueue(self,v):
self.values.append(v)
def dequeue(self):
if len(self.values) <= 0:
raise
else:
v = self.values[0]
del self.values[0]
return v
n,q = map(int,raw_input().split(' '))
processes = []
for i in range(n):
n,t = raw_input().split(' ')
processes.append((n,int(t)))
queue = Queue(processes)
clock = 0
done = []
while not queue.empty():
p = queue.dequeue()
n = p[0]
t = p[1]
if t <= q:
clock+=t
done.append((n,clock))
else:
queue.enqueue((n,t-q))
clock+=q
for p in done:
print p[0],p[1] | 0 | null | 28,063,467,012 | 12 | 19 |
import sys
n,a,b = map(int,input().split())
if a == 0:
print(0)
sys.exit()
if b == 0:
print(n)
sys.exit()
if n%(a+b) <= a:
print(n//(a+b)*a + n%(a+b))
else:
print(n//(a+b)*a + a)
| from collections import defaultdict
N = int(input())
A = list(map(int, input().split()))
INF = 10 ** 9 + 7
D = defaultdict(int)
for a in A:
for i in range(61):
# a の i ビット目がたっているか否か
D[1 << i] += bool(a & (1 << i))
ans = 0
for key, value in D.items():
ans += key * value * (N - value)
ans %= INF
print(ans % INF) | 0 | null | 89,496,474,188,788 | 202 | 263 |
from math import log2, ceil
class SegTree:
#####単位元######
ide_ele = 0
def __init__(self, init_val):
n = len(init_val)
self.num = 2**ceil(log2(n))
self.seg = [self.ide_ele] * (2 * self.num - 1)
for i in range(n):
self.seg[i + self.num - 1] = init_val[i]
# built
for i in range(self.num - 2, -1, -1):
self.seg[i] = self.segfunc(self.seg[2 * i + 1], self.seg[2 * i + 2])
#####segfunc######
def segfunc(self, x, y):
return x|y
def update(self, k, x):
k += self.num - 1
self.seg[k] = x
while k:
k = (k - 1) // 2
self.seg[k] = self.segfunc(self.seg[k * 2 + 1], self.seg[k * 2 + 2])
def query(self, a, b, k, l, r):
if r <= a or b <= l:
return self.ide_ele
if a <= l and r <= b:
return self.seg[k]
else:
vl = self.query(a, b, k*2+1, l, (l+r)//2)
vr = self.query(a, b, k*2+2, (l+r)//2, r)
return self.segfunc(vl, vr)
N = int(input())
S = input()
Q = int(input())
li = [1 << (ord(s) - ord('a')) for s in S]
seg_tree = SegTree(li)
ans = []
for _ in range(Q):
i, l, r = input().split()
i = int(i)
l = int(l)
if i == 1:
seg_tree.update(l-1, 1 << (ord(r) - ord('a')))
else:
r = int(r)
num = seg_tree.query(l-1, r, 0, 0, seg_tree.num)
ans.append(bin(num).count('1'))
for a in ans:
print(a)
| X = int(input())
if X == 2:
print(2)
exit()
count = 0
if X % 2 == 0:
X += 1
while True:
now = X + count
k = 3
while k*k <= now:
if now % k == 0:
count += 2
break
else:
k += 2
continue
if k*k > now:
break
print(now) | 0 | null | 84,112,081,096,920 | 210 | 250 |
from collections import defaultdict
N = int(input())
S = defaultdict(int)
for i in range(N):
S[input()] += 1
m = max(S.values())
for s in sorted(filter(lambda x: S[x] == m, S)):
print(s) | n, T = map(int, input().split())
food = []
for _ in range(n):
a, b = map(int, input().split())
food.append((a, b))
dp1 = [[0]*T for _ in range(1+n)]
dp2 = [[0]*T for _ in range(1+n)]
for i in range(n):
for j in range(T):
dp1[i+1][j] = dp1[i][j]
if j - food[i][0] >= 0:
dp1[i+1][j] = max(dp1[i+1][j], dp1[i][j-food[i][0]] + food[i][1])
for i in range(n-1, -1, -1):
for j in range(T):
dp2[i][j] = dp2[i+1][j]
if j - food[i][0] >= 0:
dp2[i][j] = max(dp2[i][j], dp2[i+1][j-food[i][0]] + food[i][1])
res = 0
for i in range(n):
for j in range(T):
res = max(res, food[i][1] + dp1[i][j] + dp2[i+1][T-1-j])
print(res) | 0 | null | 111,147,800,496,378 | 218 | 282 |
import sys
def input(): return sys.stdin.readline().rstrip()
def main():
n, k =map(int,input().split())
A = list(map(int,input().split())) + [0]
while k > 0:
B = [0] * (n + 1)
for i, a in enumerate(A):
B[max(0, i - a)] += 1
B[min(n, i + a + 1)] -= 1
if B[0] == n:
flag = True
for i in range(1, n+1):
B[i] += B[i-1]
if B[i] != n and i < n:
flag = False
A = B[:]
if flag:
break
k -= 1
print(" ".join(map(str, B[:-1])))
if __name__=='__main__':
main() | N, K = map(int, input().split())
A = list(map(int, input().split()))
imos = [0]*(N+1)
# 全体でO(NlogN) ≒ 10^6
for k in range(K): # 下のifによってO(logN)で抑えられる.
if min(A) == N:
break
imos = [0]*(N+1)
for i,a in enumerate(A): # O(N)
imos[max(0, i-a)] += 1
imos[min(N, i + a + 1)] -= 1
A = [imos[0]]
for i in range(1,len(imos)-1): # O(N)
A.append(A[i - 1] + imos[i])
print(*A, sep=" ") | 1 | 15,456,953,762,590 | null | 132 | 132 |
class Dice(object):
def __init__(self, top, south, east, west, north, bottom):
self.top = top
self.south = south
self.east = east
self.west = west
self.north = north
self.bottom = bottom
def get_top(self):
return self.top
def rotate(self, directions):
for direction in directions:
if direction == 'S':
self.prev_top = self.top
self.top = self.north
self.north = self.bottom
self.bottom = self.south
self.south = self.prev_top
elif direction == 'E':
self.prev_top = self.top
self.top = self.west
self.west = self.bottom
self.bottom = self.east
self.east = self.prev_top
elif direction == 'W':
self.prev_top = self.top
self.top = self.east
self.east = self.bottom
self.bottom = self.west
self.west = self.prev_top
elif direction == 'N':
self.prev_top = self.top
self.top = self.south
self.south = self.bottom
self.bottom = self.north
self.north = self.prev_top
dice = Dice(*map(int, input().split()))
dice.rotate(input())
print(dice.get_top()) | 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) | 0 | null | 6,584,054,088,852 | 33 | 124 |
arr = list([])
for i in range(10):
arr.append(int(input()))
arr.sort(reverse=True)
for i in range(3):
print arr[i]
| height = [int(input()) for i in range(10)]
sort = sorted(height, reverse=True)
for i in range(3):
print(sort[i]) | 1 | 27,513,008 | null | 2 | 2 |
A, B, M=map(int, input().split())
a=list(map(int, input().split()))
b=list(map(int, input().split()))
c = [list(map(int, input().split())) for i in range(M)]
# とりあえず最小
minc=min(a)+min(b)
for v in c:
minc = min(minc, (a[v[0]-1]+b[v[1]-1]-v[2]))
print(minc) | from collections import defaultdict, Counter
from heapq import heapify, heappop, heappush
from sys import stdin
def main():
n = int(input())
a = [int(x) for x in input().split()]
if n % 2 == 0:
if n == 2:
print(max(a))
return
v = [[None for j in range(2)] for i in range(n)]
v[0][0] = a[0]
v[1][1] = a[1]
for i in range(2, n):
for j in range(2):
c = []
if v[i-2][j] is not None:
c.append(v[i-2][j])
if j >= 1 and i >= 3:
if v[i-3][j-1] is not None:
c.append(v[i-3][j-1])
if len(c) == 0:
continue
v[i][j] = max(c) + a[i]
c = [v[n-1][j] for j in range(2) if v[n-1][j] is not None]
print(max(c))
else:
if n == 3:
print(max(a))
return
v = [[None for j in range(3)] for i in range(n)]
v[0][0] = a[0]
v[1][1] = a[1]
v[2][0] = a[0]+a[2]
v[2][2] = a[2]
for i in range(3, n):
for j in range(3):
c = []
if v[i-2][j] is not None:
c.append(v[i-2][j])
if j >= 1:
if v[i-3][j-1] is not None:
c.append(v[i-3][j-1])
if j >= 2 and i >= 4:
if v[i-4][j-2] is not None:
c.append(v[i-4][j-2])
if len(c) == 0:
continue
v[i][j] = max(c) + a[i]
c = [v[n-1][j] for j in range(1, 3) if v[n-1][j] is not None]
print(max(c))
def input(): return stdin.readline().rstrip()
main()
| 0 | null | 45,409,617,051,128 | 200 | 177 |
# coding: UTF-8
def find_comb(n,x):
count = 0
#探索
for i in range(1,n-1):
for j in range(i+1,n):
k = x - i - j #←がi < j < k <= nを満たせばその時点で総和がxとなる
if j < k <= n:
count += 1
print count
while(1):
n,x = map(int, raw_input().split(" "))
if(n == 0 and x == 0):
break
find_comb(n,x)
| cards = list()
pattern = ["S", "H", "C","D"]
n = int(input())
for i in range(n) :
s, r = input().split() #文字列として読み込み
r = int(r) #sは文字列、rは数値
if(s == "S") :
cards.append(0 + r)
elif(s == "H") :
cards.append(13 + r)
elif(s == "C") :
cards.append(26 + r)
else :
cards.append(39 + r)
for i in range(1, 53) :
if not(i in cards) :
print(pattern[(i - 1) // 13], (i - 1) % 13 + 1)
| 0 | null | 1,150,007,867,140 | 58 | 54 |
import sys
from functools import reduce
X, Y = map(int, input().split())
mod = 10**9 + 7
if (X+Y)%3 != 0:
print(0)
sys.exit()
if 2 * min(X, Y) < max(X, Y):
print(0)
sys.exit()
def f(n, A):
if A == 0:
return 1
bunsi = reduce(lambda x, y: x*y%mod, range(n, n-A, -1))
bunbo = reduce(lambda x, y: x*y%mod, range(1, A+1))
return bunsi * pow(bunbo, mod-2, mod) % mod
ans = 0
r, d = 0, 0
if X == Y:
r, d = X//3, Y//3
ans = f(r+d, d)%mod
else:
r = abs(X-Y) + ((X+Y) - 3*abs(X-Y))//6
d = ((X+Y) - 3*abs(X-Y))//6
ans = f(r+d, d)%mod
print(ans) | n, m = map(int, input().split())
coins = list(map(int, input().split()))
memo = [0] + [10**7] * n
for coin in coins:
for i in range(coin, n+1):
memo[i] = min(memo[i], memo[i-coin]+1)
print(memo[-1])
| 0 | null | 75,200,986,529,490 | 281 | 28 |
if __name__ == '__main__':
p_taro, p_hanako = 0, 0
n = int(input())
for i in range(n):
animal_taro, animal_hanako = input().split()
if animal_taro > animal_hanako:
p_taro += 3
elif animal_taro < animal_hanako:
p_hanako += 3
else:
p_taro, p_hanako = p_taro+1, p_hanako+1
print(p_taro, p_hanako) | S = input()
flg = True
for i in range(len(S)):
if flg == True and S[i] == "h":
flg = False
continue
elif flg == False and S[i] == "i":
flg = True
continue
else:
print("No")
break
else:
if flg == False:
print("No")
else:
print("Yes") | 0 | null | 27,672,517,427,968 | 67 | 199 |
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
# class UnionFind():
# par = []
# sizes = []
# def __init__(self, N):
# self.par = [i for i in range(N)]
# self.sizes = [1 for _ in range(N)]
# def root(self, x: int)-> int:
# if (self.par[x] == x):
# return x
# return self.root(self.par[x])
# def unite(self, x: int, y: int):
# rootX = self.root(x)
# rootY = self.root(y)
# if rootX == rootY:
# return
# self.par[rootX] = rootY
# self.sizes[rootY] += self.sizes[rootX]
# def maxSize(self)-> int:
# return max(self.sizes)
def friends(N, As):
uf = UnionFind(N)
setAs = list(set(As))
for val in setAs:
uf.union(val[0]-1, val[1]-1)
ans = 0
for i in range(N):
temp = uf.size(i)
if ans < temp:
ans = temp
return ans
if __name__ == "__main__":
nm = list(map(int, input().split()))
As =[tuple(map(int, input().split())) for _ in range(nm[1])]
print(friends(nm[0], As)) | n,m=map(int,input().split())
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1]*n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x=self.find(x)
y=self.find(y)
if x== y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
uf = UnionFind(n)
ans=0
for i in range(m):
a, b = map(int,input().split())
a -= 1
b -= 1
uf.union(a, b)
for i in range(n):
ans = max(ans, uf.size(i))
print(ans) | 1 | 3,949,538,737,428 | null | 84 | 84 |
# -*- coding: utf-8 -*-
import sys
sys.setrecursionlimit(10**9)
INF=10**18
MOD=10**9+7
input=lambda: sys.stdin.readline().rstrip()
YesNo=lambda b: print('Yes' if b else 'No')
YESNO=lambda b: print('YES' if b else 'NO')
def main():
N,M=map(int,input().split())
c=list(map(int,input().split()))
dp=[[INF]*10**6 for _ in range(M+1)]
dp[0][0]=0
ans=INF
for i in range(M):
for money in range(N+1):
dp[i+1][money]=min(dp[i+1][money],dp[i][money])
if money-c[i]>=0:
dp[i+1][money]=min(dp[i+1][money],dp[i][money-c[i]]+1,dp[i+1][money-c[i]]+1)
print(dp[M][N])
if __name__ == '__main__':
main()
| n, m = map(int, input().split())
c = list(map(int, input().split()))
dp = [0] * (n+1)
for i in range(1, n+1):
dpi = 10 ** 9
for j in range(m):
if(i-c[j]>=0):
tmp = dp[i-c[j]] + 1
if(tmp < dpi):
dpi = tmp
dp[i] = dpi
print(dp[n])
| 1 | 143,158,410,672 | null | 28 | 28 |
n, m = map(int, input().split())
a = [int(s) for s in input().split()]
days = n - sum(a)
print(days) if days >= 0 else print(-1) | n, m = map(int, input().split())
work = list(map(int, input().split()))
if n - sum(work) < 0:
print("-1")
else:
print(n - sum(work))
| 1 | 31,815,911,376,700 | null | 168 | 168 |
import math
a,b,h,m=map(int,input().split())
hc=360/12*h+30/60*m #時針の角度
mc=360/60*m #分針の角度
hm=abs(hc-mc) #時針と分針の角度の差
if hm > 180:
hm=360-hm
mcos=math.cos(math.radians(hm))
c=a**2+b**2-(2*a*b*mcos) #余剰定理
print(math.sqrt(c)) | a=[int(input()) for i in range(10)]
a.sort()
a.reverse()
print(a[0])
print(a[1])
print(a[2]) | 0 | null | 10,044,146,557,962 | 144 | 2 |
N = int(input())
if (N % 10 == 0) or (N % 10 == 1) or (N % 10 == 6) or (N % 10 == 8):
print("pon")
elif N % 10 == 3:
print("bon")
else:
print("hon") | N = int(input())
number1 = [2,4,5,7,9]
number2 = [3]
number3 = [0,1,6,8]
if N % 10 in number1:
print('hon')
elif N % 10 in number2:
print('bon')
elif N % 10 in number3:
print('pon') | 1 | 19,381,767,928,640 | null | 142 | 142 |
def main():
n = int(input())
S = list(map(int, input().split()))
q = int(input())
T = list(map(int, input().split()))
res = 0
for i in T:
if i in S:
res += 1
print(res)
if __name__ == '__main__':
main()
| class UnionFind:
def __init__(self, n):
self.t = [-1] * (n + 1)
def flatten(self):
for i, _ in enumerate(self.t):
self.find_root(i)
def union(self, a, b):
ra = self.find_root(a)
rb = self.find_root(b)
if ra != rb:
self.t[max(ra, rb)] = min(ra, rb)
def find_root(self, x):
t = []
while self.t[x] > 0:
t.append(x)
x = self.t[x]
for _t in t:
self.t[_t] = x
return x
def solve(string):
n, m, k, *abcd = map(int, string.split())
r = [0] * (n + 1)
uf = UnionFind(n)
for a, b in zip(*[iter(abcd[:2 * m])] * 2):
r[a] += 1
r[b] += 1
uf.union(a, b)
uf.flatten()
for i, v in enumerate(uf.t):
uf.t[i] = i if v < 0 else v
mp = {k: set([]) for k in set(uf.t[1:])}
for i, v in enumerate(uf.t[1:], start=1):
mp[v].add(i)
for c, d in zip(*[iter(abcd[2 * m:])] * 2):
r[c] += 1 if d in mp[uf.t[c]] else 0
r[d] += 1 if c in mp[uf.t[d]] else 0
mp = {k: len(v) for k, v in mp.items()}
return " ".join([str(mp[uf.t[i]] - 1 - r[i]) for i in range(1, n + 1)])
if __name__ == '__main__':
import sys
print(solve(sys.stdin.read().strip()))
| 0 | null | 30,842,047,859,546 | 22 | 209 |
[X,Y] = list(map(int,input().split()))
n = (-1*X+2*Y)//3
m = (2*X-Y)//3
if (X+Y)%3 !=0:
print(0)
elif n<0 or m<0:
print(0)
else:
MAXN = (10**6)+10
MOD = 10**9 + 7
f = [1]
for i in range(MAXN):
f.append(f[-1] * (i+1) % MOD)
def nCr(n, r, mod=MOD):
return f[n] * pow(f[r], mod-2, mod) * pow(f[n-r], mod-2, mod) % mod
print(nCr(n+m,n,10**9 + 7))
| import math
I=list(map(int,input().split()))
X=(2*I[1]-I[0])//3
Y=(2*I[0]-I[1])//3
n=X+Y
r=X
if (X<0 or Y<0 or (I[0]+I[1])%3!=0):
print(0)
exit()
def cmb(n, r, p):
if (r < 0) or (n < r):
return 0
r = min(r, n - r)
return fact[n] * factinv[r] * factinv[n-r] % p
p = 10 ** 9 + 7
N = 10 ** 6
fact = [1, 1]
factinv = [1, 1]
inv = [0, 1]
for i in range(2, N + 1):
fact.append((fact[-1] * i) % p)
inv.append((-inv[p % i] * (p // i)) % p)
factinv.append((factinv[-1] * inv[-1]) % p)
print(cmb(n, r, p)) | 1 | 150,367,308,180,860 | null | 281 | 281 |
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) | # coding: utf-8
def main():
N = int(input())
A = list(map(int, input().split()))
ans = -1
tmp = 1
flg = False
for a in A:
if a == tmp:
tmp += 1
flg = True
if flg:
ans = N - tmp + 1
print(ans)
if __name__ == "__main__":
main()
| 1 | 114,851,073,479,828 | null | 257 | 257 |
# D
from collections import Counter
n = int(input())
c = list(input())
d = Counter(c)
# print(d)
# print(d["R"])
e=Counter(c[:d["R"]])
# print(e["R"])
print(d["R"]-e["R"]) | n = int(input())
max_div_num = 1
for i in range(2, int(n**(1/2) + 1)):
if n % i == 0:
max_div_num = max(i, max_div_num)
x = max_div_num
y = n // max_div_num
print(x + y - 2) | 0 | null | 83,795,329,101,400 | 98 | 288 |
K, N = map(int,input().split())
A = [int(a) for a in input().split()]
dif = [A[i+1] - A[i] for i in range(N-1)]
dif.append(K + A[0] - A[N-1])
print(K - max(dif)) | # C - Traveling Salesman around Lake
K,N = map(int,input().split())
A = list(map(int,input().split()))
tmp = 0
for i in range(N):
tmp = max(tmp, (A[i]-A[i-1])%K)
print(K-tmp) | 1 | 43,328,128,154,338 | null | 186 | 186 |
# -*-coding:utf-8-*-
def get_input():
while True:
try:
yield "".join(input())
except EOFError:
break
if __name__=="__main__":
array = list(get_input())
for i in range(len(array)):
temp = array[i].split()
a = int(temp[0])
b = int(temp[1])
ans = a + b
print(len(str(ans))) | def counts(num):
countlist.append(len(str(num[0] + num[1])))
countlist = []
flag = True
while flag :
try:
counts(map(int, raw_input().split()))
except:
flag = False
for x in countlist:
print x | 1 | 56,747,690 | null | 3 | 3 |
import sys
readline = sys.stdin.readline
readall = sys.stdin.read
ns = lambda: readline().rstrip()
ni = lambda: int(readline().rstrip())
nm = lambda: map(int, readline().split())
nl = lambda: list(map(int, readline().split()))
prl = lambda x: print(*x ,sep='\n')
s,w = nm()
print('unsafe' if s <= w else 'safe') | from __future__ import division, print_function
import sys
if sys.version_info[0] < 3:
from __builtin__ import xrange as range
from future_builtins import ascii, filter, hex, map, oct, zip
import os, sys, bisect, copy
from collections import defaultdict, Counter, deque
#from functools import lru_cache #use @lru_cache(None)
if os.path.exists('in.txt'): sys.stdin=open('in.txt','r')
if os.path.exists('out.txt'): sys.stdout=open('out.txt', 'w')
#
def input(): return sys.stdin.readline()
def mapi(arg=0): return map(int if arg==0 else str,input().split())
#------------------------------------------------------------------
s,w = mapi()
if w>=s:
print("unsafe")
else:
print("safe")
| 1 | 28,987,536,143,852 | null | 163 | 163 |
N = int(input())
xy = [list(map(int, input().split())) for i in range(N)]
z = [x + y for x, y in xy]
w = [x - y for x, y in xy]
print(max(max(z) - min(z), max(w) - min(w))) | n = int(input())
plus,minus = [],[]
for i in range(n):
a,b = map(int,input().split())
plus.append(a+b)
minus.append(a-b)
plus.sort()
minus.sort()
print(max(plus[-1]-plus[0],minus[-1]-minus[0])) | 1 | 3,443,195,434,980 | null | 80 | 80 |
n,k = map(int,input().split())
MOD = 10**9+7
# g[i]:gcd(A1,A2,,,An)=iとなる数列の個数
g = [0 for _ in range(k)]
for i in range(k,0,-1):
g[i-1] = pow(k//i,n,MOD)
#ここまででg[x]=gcdがxの倍数となる数列の個数となっているので、
#ここからgcdが2x,3x,,,となる数列の個数を引いていく。
for j in range(2,k+1):
if i*j > k:
break
g[i-1] -= g[i*j-1]
g[i-1] %= MOD
#print(g)
ans = 0
for i in range(k):
ans += (i+1)*g[i]
ans %= MOD
print(ans)
| n, m = map(int, input().split())
ht = list(map(int, input().split()))
rd = [list(map(int, input().split())) for _ in range(m)]
flg = [1] * n
for i in rd:
if ht[i[0]-1] <= ht[i[1]-1]:
flg[i[0]-1] = 0
if ht[i[0]-1] >= ht[i[1]-1]:
flg[i[1]-1] = 0
print(sum(flg)) | 0 | null | 30,915,827,471,538 | 176 | 155 |
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") | n,a,b = map(int,input().split())
if a < b:
a,b = b,a
if (a - b) %2 == 0:
print((a-b)//2)
else:
print(min(a-1,n-b)+1+(b-a)//2) | 0 | null | 57,979,686,296,952 | 102 | 253 |
n = int(input())
s = list(input())
p = s[0]
ans = 1
for i in s[1:]:
if p!=i:
p = i
ans += 1
print(ans)
| input()
s=input()
t,a=s[0],1
for c in s:
if c!=t: a+=1; t=c
print(a) | 1 | 170,026,724,473,858 | null | 293 | 293 |
if __name__ == "__main__":
alpha = input()
if alpha in ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z']:
print('A')
else:
print('a') | S = input()
print( 'A' if S.isupper() else 'a' ) | 1 | 11,392,147,302,972 | null | 119 | 119 |
while True:
x = input()
if x == '0': break
print(sum(list(map(int,list(x)))))
|
def search(start, N, X, Y):
dist = [0 for _ in range(N)]
if start <= X:
for i in range(X):
dist[i] = abs(start - i)
for i in range(Y, N):
dist[i] = (X - start) + 1 + (i - Y)
for i in range(X, (Y - X) // 2 + X + 1):
dist[i] = (i - start)
for i in range((Y - X) // 2 + X + 1, Y):
dist[i] = (X - start) + 1 + (Y - i)
elif start >= Y:
for i in range(Y, N):
dist[i] = abs(start - i)
for i in range(X):
dist[i] = (start - Y) + 1 + (X - i)
for i in range(X, (Y - X) // 2 + X):
dist[i] = (start - Y) + 1 + (i - X)
for i in range((Y - X) // 2 + X, Y):
dist[i] = (start - i)
else:
toX = min(start - X, Y - start + 1)
toY = min(Y - start, start - X + 1)
dist[start] = 0
for i in range(X):
dist[i] = (X - i) + toX
for i in range(Y, N):
dist[i] = toY + (i - Y)
for i in range(X, start):
dist[i] = min(start - i, Y - start + 1 + i - X)
for i in range(start + 1, Y):
dist[i] = min(i - start, start - X + 1 + Y - i)
return dist
def main():
N, X, Y = [int(n) for n in input().split(" ")]
#N, X, Y = 10, 3, 8
X = X - 1
Y = Y - 1
lenD = []
for i in range(N):
d = search(i, N, X, Y)
lenD.append(d)
kcounter = [0 for _ in range(N - 1)]
for i in range(N):
for j in range(i + 1, N):
k = lenD[i][j]
kcounter[k - 1] += 1
for k in kcounter:
print(k)
main() | 0 | null | 22,797,129,354,006 | 62 | 187 |
import sys; input = sys.stdin.buffer.readline
sys.setrecursionlimit(10**7)
from collections import defaultdict
import bisect
con = 10 ** 9 + 7; INF = float("inf")
def getlist():
return list(map(int, input().split()))
def Binary_Search(A, N, M):
#初期化
left = 0
right = 10 ** 7
ans = 0
#累積和
Asum = [0]
for i in range(N):
Asum.append(Asum[i] + A[-1 - i])
leftj = [INF, INF]
rightj = [0, 0]
#二分探索
while left <= right:
mid = (left + right) // 2
var = 0
happiness = 0
for i in range(N):
ind = bisect.bisect_left(A, mid - A[i])
ind = N - ind
var += ind
happiness += ind * A[i] + Asum[ind]
# print(var, happiness)
if var == M:
return happiness
elif var > M:
leftj = min(leftj, [var, -mid])
left = mid + 1
else:
ans = max(ans, happiness)
rightj = max(rightj, [var, -mid])
right = mid - 1
# print(ans)
# print(leftj)
# print(rightj)
ans = ans + (M - rightj[0]) * (-leftj[1])
return ans
#処理内容
def main():
N, M = getlist()
A = getlist()
A.sort()
ans = Binary_Search(A, N, M)
print(ans)
if __name__ == '__main__':
main() | import sys
import bisect
input = sys.stdin.readline
class Bisect(object):
def bisect_max(self, reva, func,M):
ok = 0 # exist
ng = 4*(10**5) # not exist
while abs(ok-ng) > 1:
cnt = (ok + ng) // 2
if func(cnt,reva,M):
ok = cnt
else:
ng = cnt
return ok
def solve1(tgt,reva,M):
res=0
n = len(reva)
for i in range(n):
tmp = bisect.bisect_left(reva,tgt-reva[i])
tmp = n - tmp
res += tmp
if M <= res:
return True
else:
return False
N,M = map(int,input().split())
a = list(map(int,input().split()))
a.sort(reverse=True)
reva = a[::-1]
bs = Bisect()
Kmax = (bs.bisect_max(reva,solve1,M))
r=[0]
for i in range(N):
r.append(r[i]+a[i])
res = 0
cnt = 0
t = 0
for i in range(N):
tmp = bisect.bisect_left(reva,Kmax-reva[N-i-1])
tmp2 = bisect.bisect_right(reva,Kmax-reva[N-i-1])
if tmp!=tmp2:
t = 1
tmp = N - tmp
cnt += tmp
res += tmp*a[i]+r[tmp]
if t==1:
res -= (cnt-M)*Kmax
print(res)
| 1 | 107,973,284,448,032 | null | 252 | 252 |
class Queue:
queue_list = []
def enqueue(self, a):
self.queue_list.append(a)
def dequeue(self):
return self.queue_list.pop(0)
def isEmpty(self):
return len(self.queue_list) == 0
n, q = list(map(lambda x: int(x), input().strip().split()))
queue = Queue()
for i in range(n):
queue.enqueue(input().strip().split())
sum_time = 0
while not queue.isEmpty():
name, time = queue.dequeue()
if int(time) <= q:
sum_time += int(time)
print(name + ' ' + str(sum_time))
else:
queue.enqueue([name, str(int(time) - q)])
sum_time += q
| import sys
readline = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)
def main():
N = int(readline())
dp = [[0] * 10 for _ in range(10)]
ans = 0
for i in range(1, N + 1):
s = str(i)
first = int(s[0])
second = int(s[-1])
ans += 2 * dp[second][first]
if first == second:
ans += 1
dp[first][second] += 1
print(ans)
if __name__ == '__main__':
main()
| 0 | null | 43,065,319,752,224 | 19 | 234 |
n = input()
n += n
if input() in n:
print("Yes")
else:
print("No") | s=input()
p=input()
s2=s*2
ren=s2.count(p)
if ren==0:
print('No')
else:
print('Yes')
| 1 | 1,755,700,590,950 | null | 64 | 64 |
while True:
n = input()
if n == "0":
break
ans = sum([int(x) for x in n])
print(ans) | a, b, c, d, K = map(int, input().split())
hour = (c-a) * 60
min = d - b
ans = hour + min - K
print(ans)
| 0 | null | 9,782,309,966,368 | 62 | 139 |
N=int(input())
AB=[list(map(int,input().split())) for i in range(N)]
from collections import defaultdict
d=defaultdict(int)
d2=defaultdict(int)
a0=0
b0=0
c0=0
from math import gcd
for a,b in AB:
if a==b==0:
c0+=1
elif a==0:
a0+=1
elif b==0:
b0+=1
else:
if a<0:
a,b=-a,-b
g=gcd(a,b)
a,b=a//g,b//g
if b>0:
d[(a,b)]+=1
else:
d2[(-b,a)]+=1
m=10**9+7
a=1
for k,v in d.items():
if k in d2:
a=a*(pow(2,v,m)+pow(2,d2[k],m)-1)%m
else:
a=a*pow(2,v,m)%m
for k,v in d2.items():
if k not in d:
a=a*pow(2,v,m)%m
print((a*(pow(2,a0,m)+pow(2,b0,m)-1)-1+c0)%m) | s = str(input())
p = str(input())
connect = s + s
if p in connect:
print('Yes')
else:
print('No')
| 0 | null | 11,435,118,706,418 | 146 | 64 |
N = int(input())
a = N // 2
b = N % 2
print(a + b)
| n = int(input())
ans = n // 2
if n % 2 != 0: ans += 1
print(ans) | 1 | 59,159,281,067,392 | null | 206 | 206 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.