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
|
|---|---|---|---|---|---|---|
A,B=input().split()
A=int(A)
B=100*int(B[0])+10*int(B[2])+int(B[3])
print(A*B//100) | # C
from decimal import Decimal
A,B = map(Decimal,input().split())
ans = A * B
print(int(ans)) | 1 | 16,509,677,373,920 | null | 135 | 135 |
n,a,b = map(int,input().split())
mod = 10**9+7
def comb(N,x):
numerator = 1
for i in range(N-x+1,N+1):
numerator = numerator *i%mod
denominator = 1
for j in range(1,x+1):
denominator = denominator *j%mod
d = pow(denominator,mod-2,mod)
return (numerator*d)%mod
al = pow(2,n,mod)-1
ac =comb(n,a)
bc =comb(n,b)
print((al-ac-bc)%mod) | n = int(input())
al = list(map(int, input().split()))
flg = True
for a in al:
if a%2 == 0:
if a%3 == 0 or a%5 == 0:
continue
else:
flg = False
break
if flg:
print('APPROVED')
else:
print('DENIED') | 0 | null | 67,463,011,825,440 | 214 | 217 |
def pre_combi1(n, p):
fact = [1]*(n+1) # fact[n] = (n! mod p)
factinv = [1]*(n+1) # factinv[n] = ((n!)^(-1) mod p)
inv = [0]*(n+1) # factinv 計算用
inv[1] = 1
# 前処理
for i in range(2, n + 1):
fact[i]= fact[i-1] * i % p
inv[i]= -inv[p % i] * (p // i) % p
factinv[i]= factinv[i-1] * inv[i] % p
return fact, factinv
def combi1(n, r, p, fact, factinv):
"""
k<n<10**7でpが素数のときのnCr % pを求める
"""
# 本処理
if r < 0 or n < r:
return 0
r = min(r, n-r)
return fact[n] * factinv[r] * factinv[n-r] % p
p=998244353
fact,finv=pre_combi1(2*10**5+1,p)
n,m,k=map(int,input().split())
ans=0
dup=[0] * n
dup[0] = 1
for j in range(1,n):
dup[j]=dup[j-1]*(m-1) % p
for i in range(k+1):
ans += m*combi1(n-1,i,p,fact,finv)*dup[n-i-1]
ans %= p
print(ans) | def main():
N,M,K=map(int,input().split())
MOD=998244353
E=0
n_=1
for i in range(1,N):
n_=(n_*i)%MOD
nr_ = 1
nr_array=[]
for i in range(1,N-1):
nr_ = (nr_ * i) % MOD
nr_array.append(nr_)
m=1
Mk_array=[1]
for i in range(1,N):
m=(m*(M-1))%MOD
Mk_array.append(m)
r_=1
for i in range(0,K+1):
if i!=0 and i!=N-1:
r_ = (r_ * i) % MOD
nr_=nr_array.pop()
power_r=pow(r_,MOD-2,MOD)
power_nr=pow(nr_,MOD-2,MOD)
Mk=Mk_array.pop()
if i!=0 and i!=N-1:
E+=(n_*power_r*power_nr*Mk)%MOD
else:
E+=Mk%MOD
res=(M*E)%MOD
print(res)
if __name__=="__main__":
main()
| 1 | 23,184,704,762,688 | null | 151 | 151 |
import sys
n,m=map(int,input().split())
ans=[0]*n
for i in range(m):
s,c=map(int,input().split())
s-=1
if ans[s]!=0 and ans[s]!=c:
print(-1)
sys.exit()
else:
ans[s]=c
if n==3 and m==1 and ans==[0,0,0]:
print(-1)
sys.exit()
if n!=1 and ans[0]==0:
ans[0]=1
for i in range(n):
ans[i]=str(ans[i])
print("".join(ans)) | #!/usr/bin/env python3
from collections import defaultdict, Counter
from itertools import product, groupby, count, permutations, combinations
from math import pi, sqrt
from collections import deque
from bisect import bisect, bisect_left, bisect_right
from string import ascii_lowercase
from functools import lru_cache
import sys
sys.setrecursionlimit(10000)
INF = float("inf")
YES, Yes, yes, NO, No, no = "YES", "Yes", "yes", "NO", "No", "no"
dy4, dx4 = [0, 1, 0, -1], [1, 0, -1, 0]
dy8, dx8 = [0, -1, 0, 1, 1, -1, -1, 1], [1, 0, -1, 0, 1, 1, -1, -1]
def inside(y, x, H, W):
return 0 <= y < H and 0 <= x < W
def ceil(a, b):
return (a + b - 1) // b
def sum_of_arithmetic_progression(s, d, n):
return n * (2 * s + (n - 1) * d) // 2
def gcd(a, b):
if b == 0:
return a
return gcd(b, a % b)
def lcm(a, b):
g = gcd(a, b)
return a / g * b
def solve():
N, M = map(int, input().split())
ans = [None] * N
for _ in range(M):
S, C = map(int, input().split())
S -= 1
if ans[S] is None:
ans[S] = C
else:
if ans[S] != C:
print(-1)
return
if N != 1 and ans[0] == 0:
print(-1)
return
if ans[0] is None:
if N == 1:
ans[0] = 0
else:
ans[0] = 1
for i in range(1, N):
if ans[i] is None:
ans[i] = 0
print(*ans, sep="")
def main():
solve()
if __name__ == '__main__':
main()
| 1 | 60,845,037,032,980 | null | 208 | 208 |
x = input()
if x == "ABC":
print("ARC")
else:
print("ABC") | import math
n, a, b = map(int, input().split())
mod = 10**9 + 7
ans = pow(2, n, mod) - 1
x = 1
y = 1
for i in range(a):
x = x*(n - i)%mod
y = y*(i + 1)%mod
ans -= x*pow(y, mod - 2, mod)%mod
x = 1
y = 1
for i in range(b):
x = x*(n - i)%mod
y = y*(i + 1)%mod
ans -= x*pow(y, mod - 2, mod)%mod
print(ans%mod)
| 0 | null | 45,191,612,052,352 | 153 | 214 |
import itertools
while True:
n,x=map(int,input().split())
if n==0 and x==0:
break
z=list(range(1,n+1))
a=list(itertools.combinations(z,3))
b=[]
for i in a:
b+=[sum(i)]
print(b.count(x)) | import itertools
while True:
n, x = map(int, input().split())
if n == x == 0:
break
result = 0
for i in itertools.combinations(range(1, n + 1), 3):
if sum(i) == x:
result += 1
print(result) | 1 | 1,303,929,805,750 | null | 58 | 58 |
input()
print(1 if int(input().split()[1])==1 else 0) | word = input()
if word.endswith('s'):
print(word+"es")
else:
print(word+"s") | 0 | null | 63,494,131,869,278 | 264 | 71 |
n, d, a = map(int, input().split())
xh = []
for _ in range(n):
x, h = map(int, input().split())
h = (h - 1) // a + 1
xh.append([x, h])
xh.sort()
damage = xh[0][1]
ans = damage
damage_lst = [[xh[0][0] + d * 2, damage]]
pos = 0
for i, (x, h) in enumerate(xh[1:], start = 1):
while x > damage_lst[pos][0]:
damage -= damage_lst[pos][1]
pos += 1
if pos == i:
break
damage_tmp = max(h - damage, 0)
ans += damage_tmp
damage += damage_tmp
damage_lst.append([x + d * 2, damage_tmp])
print(ans) | N, D, A = map(int, input().split())
H = [list(map(int, input().split())) for i in range(N)]
H.sort(key = lambda x:x[0])
INF = int(1e18)
H.append((INF, INF))
ans = 0
S = [0] * (N + 1)
l, r = 0, 0
while l < N:
while H[r][0] - H[l][0] <= D * 2: r += 1
h = H[l][1] - S[l]
num = (h - 1) // A + 1 if h > 0 else 0
ans += num
S[l] += A * num
S[r] -= A * num
l += 1
S[l] += S[l - 1]
print(ans)
| 1 | 82,188,560,407,720 | null | 230 | 230 |
N, X, M = map(int, input().split())
existence = [False] * M
a = []
A = X
for i in range(N):
if existence[A]:
break
existence[A] = True
a.append(A)
A = A * A % M
for i in range(len(a)):
if a[i] == A:
loop_start = i
break
else:
loop_start = len(a)
result = sum(a[:loop_start])
N -= loop_start
if N != 0:
a = a[loop_start:]
loops = N // len(a)
remainder = N % len(a)
result += sum(a) * loops + sum(a[:remainder])
print(result)
| n,x,m=map(int,input().split())
logn = (10**10).bit_length()
doubling = []
sumd = []
for _ in range(logn):
tmpd = [-1] * m
doubling.append(tmpd)
tmps = [0] * m
sumd.append(tmps)
for i in range(m):
doubling[0][i] = i * i % m
sumd[0][i] = i
for i in range(1,logn):
for j in range(m):
doubling[i][j] = doubling[i-1][doubling[i-1][j]]
sumd[i][j] = sumd[i-1][j] + sumd[i-1][doubling[i-1][j]]
now = x
pos = 0
result = 0
while n:
if n & 1:
result += sumd[pos][now]
now = doubling[pos][now]
n = n >> 1
pos += 1
print(result)
| 1 | 2,811,781,748,990 | null | 75 | 75 |
x=(int)(input())
y=x+(int)(pow(x,2))+(int)(pow(x,3))
print("{}".format(y)) |
def resolve():
import sys
input = sys.stdin.readline
n = int(input().rstrip())
print(n + n*n + n*n*n)
if __name__ == "__main__":
resolve()
| 1 | 10,174,402,965,628 | null | 115 | 115 |
import sys,queue,math,copy,itertools,bisect,collections,heapq
def main():
sys.setrecursionlimit(10**7)
INF = 10**18
MOD = 10**9 + 7
LI = lambda : [int(x) for x in sys.stdin.readline().split()]
NI = lambda : int(sys.stdin.readline())
N = NI()
N0 = 2**(N.bit_length())
st = [0] * (N0*2)
def gindex(l, r):
L = l + N0; R = r + N0
lm = (L // (L & -L)) // 2
rm = (R // (R & -R)) // 2
while L < R:
if R <= rm:
yield R - 1
if L <= lm:
yield L - 1
L //= 2; R //= 2
while L > 0:
yield L - 1
L //= 2
def update(i,s):
x = 2 ** (ord(s) - ord('a'))
i += N0-1
st[i] = x
while i > 0:
i = (i-1) // 2
st[i] = st[i*2+1] | st[i*2+2]
def query(l,r):
l += N0
r += N0
ret = 0
while l < r:
if l % 2:
ret |= st[l-1]
l += 1
if r % 2:
r -= 1
ret |= st[r-1]
l //= 2 ; r //= 2
return ret
for i,s in enumerate(sys.stdin.readline().rstrip()):
update(i+1,s)
Q = NI()
for _ in range(Q):
c,a,b = sys.stdin.readline().split()
if c == '1':
update(int(a),b)
else:
ret = query(int(a),int(b)+1)
cnt = 0
b = 1
for i in range(26):
cnt += (b & ret) > 0
b <<= 1
print(cnt)
if __name__ == '__main__':
main() | import sys,queue,math,copy,itertools,bisect,collections,heapq
def main():
sys.setrecursionlimit(10**7)
INF = 10**18
MOD = 10**9 + 7
LI = lambda : [int(x) for x in sys.stdin.readline().split()]
NI = lambda : int(sys.stdin.readline())
N = NI()
R = 2**(N.bit_length())
st = [0] * (R*2)
def update(i,s):
x = 2 ** (ord(s) - ord('a'))
i += R-1
st[i] = x
while i > 0:
i = (i-1) // 2
st[i] = st[i*2+1] | st[i*2+2]
def query(l,r):
l += R-1
r += R-2
ret = 0
while l+1 < r:
if l % 2 == 0:
ret |= st[l]
if r % 2 == 1:
ret |= st[r]
r -= 1
l = l // 2
r = (r-1) // 2
if l == r:
ret |= st[l]
else:
ret |= st[l] | st[r]
return ret
for i,s in enumerate(sys.stdin.readline().rstrip()):
update(i+1,s)
Q = NI()
for _ in range(Q):
c,a,b = sys.stdin.readline().split()
if c == '1':
update(int(a),b)
else:
ret = query(int(a),int(b)+1)
cnt = 0
b = 1
for i in range(26):
cnt += (b & ret) > 0
b <<= 1
print(cnt)
if __name__ == '__main__':
main() | 1 | 62,821,961,720,320 | null | 210 | 210 |
#!/usr/bin/env python3
from collections import deque, Counter
from heapq import heappop, heappush
from bisect import bisect_right
def main():
N, D, A = map(int, input().split())
XH = [None] * N
X = [None] * N
for i in range(N):
XH[i] = tuple(map(int, input().split()))
X[i] = XH[i][0]
XH.sort()
X.sort()
ans = 0
S = [0] * (N+1)# 与えたダメージ
for i in range(N):
if S[i] < XH[i][1]:
# あと何回攻撃する？
need = (XH[i][1]-S[i]+A-1)//A
# 爆弾が届く範囲
j = bisect_right(X,X[i]+2*D)
# imos法
S[i] += need*A
S[j] -= need*A
ans += need
S[i+1] += S[i]
print(ans)
if __name__ == "__main__":
main()
| from bisect import bisect
n,d,a=map(int,input().split())
monster=[list(map(int,input().split())) for i in range(n)]
monster.sort(key=lambda i:i[0])
r=[monster[i][0] for i in range(n)]
hp=[monster[i][1] for i in range(n)]
#print(r,hp)
d=2*d
i,ans,damages=0,0,[0]*n
while i<n:
if i>0:
damages[i]+=damages[i-1]
s=hp[i]+damages[i]
else:
s=hp[i]
if s>0:
cnt=(s+a-1)//a
ans+=cnt
#print(ans)
damage=cnt*a
damages[i]-=damage
zone=bisect(r,r[i]+d)
if zone<n:
damages[zone]+=damage
i+=1
#print(damages)
#print(hp)
print(ans)
| 1 | 82,184,833,431,608 | null | 230 | 230 |
import math
a,b,c = map(float,input().split())
sinc = math.sin(c*math.pi/180)
cosc = math.cos(c*math.pi/180)
c = math.sqrt(a**2+b**2-2*a*b*cosc)
s = a*b*sinc/2.0
print(s)
print(a+b+c)
print(s/a*2.0)
| import math
a,b,c=map(int,input().split())
s=a/2*b*math.sin(math.radians(c))
l=a+b+math.sqrt(a**2+b**2-2*a*b*math.cos(math.radians(c)))
h=b*math.sin(math.radians(c))
print('{:.5f}\n{:.5f}\n{:.5f}'.format(s,l,h))
| 1 | 170,834,366,112 | null | 30 | 30 |
a,b,c=map(int,input().split())
k=int(input())
while k>0:
if a<b:
break
b*=2
k-=1
while k>0:
if b<c:
break
c*=2
k-=1
if a<b<c:
print('Yes')
else:
print('No') | # C - gacha
n = int(input())
s = []
c = 1
for i in range(n):
s.append(input())
s.sort()
for j in range(1,n):
if s[j-1] != s[j]:
c += 1
print(c)
| 0 | null | 18,565,400,270,092 | 101 | 165 |
n, k = [ int( val ) for val in raw_input( ).split( " " ) ]
w = [ int( raw_input( ) ) for val in range( n ) ]
sumW = sum( w )
maxW = max( w )
minP = 0
if 1 == k:
minP = sumW
elif n == k:
minP = maxW
else:
left = maxW
right = 100000*10000
while left <= right:
middle = ( left+right )//2
truckCnt = i = loadings = 0
while i < n:
loadings += w[i]
if middle < loadings:
truckCnt += 1
if k < truckCnt+1:
break
loadings = w[i]
i += 1
if truckCnt+1 <= k:
minP = middle
if k < truckCnt+1:
left = middle + 1
else:
right = middle - 1
print( minP ) | 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)
| 1 | 88,348,508,710 | null | 24 | 24 |
s = int(input())
mod = 10**9 + 7
f = [0]*2001
g = [0]*2001
f[3]=1
f[4]=1
g[3]=1
g[4]=2
for i in range(4,s+1):
f[i]=1 + g[i-3]
f[i]%=mod
g[i]=f[i] + g[i-1]
g[i]%=mod
print(f[s]) | from math import factorial
def comb(a,b):
return factorial(a)//(factorial(b)*factorial(a-b))
n = int(input())
ans=0
for i in range(1,n//3+1):
ans+=comb(n-3*i+(i-1),i-1)
print(ans%(10**9+7))
| 1 | 3,330,550,123,938 | null | 79 | 79 |
import sys
for line in sys.stdin:
a, b = map(int, line.split())
c = a * b
while b:
a, b = b, a % b
print(str(a) + ' ' + str(c / a)) | import math
r = int(input())
pi = int(math.pi)
a = (pi * (r)**2)
ans = a / pi
print(int(ans))
| 0 | null | 72,282,680,145,562 | 5 | 278 |
import sys
import math
from collections import deque
sys.setrecursionlimit(1000000)
MOD = 10 ** 9 + 7
input = lambda: sys.stdin.readline().strip()
NI = lambda: int(input())
NMI = lambda: map(int, input().split())
NLI = lambda: list(NMI())
SI = lambda: input()
def make_grid(h, w, num): return [[int(num)] * w for _ in range(h)]
def main():
N, K = NMI()
A = NLI()
F = NLI()
A.sort()
F.sort(reverse=True)
ok = 10**13
ng = 0
for i in range(100):
mid = (ok+ng) // 2
limits = [mid//f for f in F]
ks = [max(a-l, 0) for a, l in zip(A, limits)]
if sum(ks) <= K:
ok = mid
else:
ng = mid
print(ok)
if __name__ == "__main__":
main() | import numpy as np
n, m, x = map(int, input().split())
data = []
for i in range(n):
temp = list(map(int, input().split()))
data.append(temp)
# ------------------------
# 今回の場合は、MとNが異様に小さいので、全探索して、Xを超える条件をMinで取るのがBetter
cost = 10 ** 17
# 0の場合は全部がOFFなので、はじく。
for bit in range(1, 2 ** n):
# print(bit)
ttt = np.zeros(m + 1)
for j in range(n):
# onの場合
if (bit >> j & 1):
#print('OK!', j)
tar = np.array(data[j])
ttt += tar
check = np.where(ttt[1:] >= x)[0]
if (len(check) == m):
cost = min(cost, ttt[0])
else:
pass
if (cost == 10 ** 17):
print(-1)
else:
print(int(cost))
| 0 | null | 93,402,059,662,050 | 290 | 149 |
n = int(input()); x = 0
for i in range(1, n): x += (n-1)//i
print(x) | n=int(input())
for i in range(n,10**6):
for j in range(2,int(i**0.5)+1):
if i%j==0:
break
else:
print(i)
break | 0 | null | 54,213,728,970,730 | 73 | 250 |
import itertools
N,M,K=map(int,input().split())
A=list(map(int,input().split()))
B=list(map(int,input().split()))
A_=[0]+list(itertools.accumulate(A))
B_=[0]+list(itertools.accumulate(B))
ans=0
j=M
for i in range(N+1):
a=A_[i]
K_a=K-a
while (j>=0 and B_[j]>K_a):
j-=1
if a+B_[j]<=K:
ans=max(ans,i+j)
print(ans)
|
def main():
N_satu, M_satu, K_fun = map(int, input().split())
A_fun = list(map(int, input().split()))
B_fun = list(map(int, input().split()))
SumOf_A = [0]
SumOf_B = [0]
for i in range(N_satu):
next_val = SumOf_A[i] + A_fun[i]
SumOf_A.append(next_val)
for i in range(M_satu):
next_val = SumOf_B[i] + B_fun[i]
SumOf_B.append(next_val)
index_b = M_satu
max_cnt = 0
for i in range(N_satu + 1):
if (SumOf_A[i] > K_fun):
break
while (SumOf_A[i] + SumOf_B[index_b] > K_fun):
index_b -= 1
max_cnt = max(max_cnt, i + index_b)
print(max_cnt)
if __name__ == '__main__':
main()
| 1 | 10,809,968,252,722 | null | 117 | 117 |
s = "1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51"
t = s.split(", ")
k = int(input())
print(t[k-1]) | k = int(input())
s = "1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51"
l = s.split(",")
print(int(l[k-1])) | 1 | 49,996,622,102,622 | null | 195 | 195 |
import sys
for i in sys.stdin.readlines()[:-1]:
h,w = map(int,i.strip().split())
for i in range(h):
for j in range(w):
if (i+j) % 2 == 0:
print('#',end='')
else:
print('.',end='')
print()
print() | #!/usr/bin/env python3
import sys
def input():
return sys.stdin.readline()[:-1]
def factorization(n):
arr = []
temp = n
for i in range(2, int(-(-n**0.5//1))+1):
if temp%i==0:
cnt=0
while temp%i==0:
cnt+=1
temp //= i
arr.append([i, cnt])
if temp!=1:
arr.append([temp, 1])
if arr==[]:
arr.append([n, 1])
return arr
def main():
N = int(input())
ans = 1e18
for i in range(1, N + 1):
if i * i > N:
break
if N % i != 0:
continue
j = N // i
ans = min(ans, i + j - 2)
print(ans)
if __name__ == '__main__':
main()
| 0 | null | 81,580,876,898,534 | 51 | 288 |
N = int(input())
s = [0] * N
for i in range(N):
s[i] = input()
d = set()
for v in s:
d.add(v)
print(len(d))
| def main():
# データ入力
n, q = input().split()
n = int( n )
q = int( q )
name = []
time = []
for i in range(n):
tmp_n, tmp_t = input().split()
name.append( tmp_n )
time.append( int( tmp_t ) )
# 処理
count = 0
while n > 0:
if time[0] > q:
time[0] -= q
count += q
time.append( time[0] )
time.pop( 0 )
name.append( name[0] )
name.pop( 0 )
else :
count += time[0]
print( name[0], end=" " )
print( str( count ) )
time.pop( 0 )
name.pop( 0 )
n -= 1
if __name__ == '__main__':
main()
| 0 | null | 15,277,844,556,272 | 165 | 19 |
while 1:
N = int(input())
if not N:
break
*A, = map(int, input().split())
V = sum(A)/N
print((sum((a - V)**2 for a in A)/N)**0.5)
| while True:
n=int(input())
if n==0:break
s=list(map(float,input().split()))
print((sum(map(lambda x: x*x,s))/n-(sum(s)/n)**2)**.5)
| 1 | 192,271,478,148 | null | 31 | 31 |
M1, D1 = [int(x) for x in input().split()]
M2, D2 = [int(x) for x in input().split()]
print(0 if M1 == M2 else 1) | m, d = map(int,input().split())
n, e = map(int,input().split())
print(int(e == 1)) | 1 | 124,542,350,192,096 | null | 264 | 264 |
def i():
return int(input())
def i2():
return map(int,input().split())
def s():
return str(input())
def l():
return list(input())
def intl():
return list(int(k) for k in input().split())
n = i()
s = s()
cnt = 0
for i in range(n-2):
if s[i]+s[i+1]+s[i+2] == "ABC":
cnt += 1
print(cnt) | import sys
import os
import math
import bisect
import itertools
import collections
import heapq
import queue
import array
# 時々使う
# from scipy.sparse.csgraph import csgraph_from_dense, floyd_warshall
# from decimal import Decimal
# from collections import defaultdict, deque
# 再帰の制限設定
sys.setrecursionlimit(10000000)
def ii(): return int(sys.stdin.buffer.readline().rstrip())
def il(): return list(map(int, sys.stdin.buffer.readline().split()))
def fl(): return list(map(float, sys.stdin.buffer.readline().split()))
def iln(n): return [int(sys.stdin.buffer.readline().rstrip())
for _ in range(n)]
def iss(): return sys.stdin.buffer.readline().decode().rstrip()
def sl(): return list(map(str, sys.stdin.buffer.readline().decode().split()))
def isn(n): return [sys.stdin.buffer.readline().decode().rstrip()
for _ in range(n)]
def lcm(x, y): return (x * y) // math.gcd(x, y)
# MOD = 10 ** 9 + 7
MOD = 998244353
INF = float('inf')
def main():
if os.getenv("LOCAL"):
sys.stdin = open("input.txt", "r")
N, K = il()
D = [il() for _ in range(K)]
dp = [0] * (N)
dp[0] = 1
acc = 0
for i in range(1, N):
for l, r in D:
if i - l >= 0:
acc += dp[i-l]
acc %= MOD
if i - r - 1 >= 0:
acc -= dp[i-r-1]
acc %= MOD
dp[i] = acc
print(dp[-1])
if __name__ == '__main__':
main()
| 0 | null | 50,830,518,956,204 | 245 | 74 |
# 解説を参考に作成
# import sys
# sys.setrecursionlimit(10 ** 6)
# import bisect
# from collections import deque
def inverse(a, p):
"""逆元"""
a_, p_ = a, p
x, y = 1, 0
while p_:
t = a_ // p_
a_ -= t * p_
a_, p_ = p_, a_
x -= t * y
x, y = y, x
x %= p
return x
# from decorator import stop_watch
#
#
# @stop_watch
def solve(n, k):
mod = 10 ** 9 + 7
ans = 0
p_mod = [1, 1]
for i in range(2, n + 1):
p_mod.append((p_mod[-1] * i) % mod)
for i in range(min(n, k + 1)):
if i == 0:
ans += 1
elif i == 1:
ans += n * (n - 1)
else:
nCi = p_mod[n] * inverse(p_mod[n - i], mod) % mod * inverse(p_mod[i], mod) % mod
nmHi = (p_mod[n - 1] * inverse(p_mod[n - i - 1], mod) % mod) * inverse(p_mod[i], mod) % mod
# ans += cmb2(n, i, mod) * cmb2(n - 1, i, mod)
ans += nCi * nmHi % mod
ans %= mod
print(ans)
if __name__ == '__main__':
# S = input()
# N = int(input())
n, k = map(int, input().split())
# Ai = [int(i) for i in input().split()]
# Bi = [int(i) for i in input().split()]
# ABi = [[int(i) for i in input().split()] for _ in range(N)]
solve(n, k)
# # test
# from random import randint
# from func import random_str
# solve()
| import sys
sys.setrecursionlimit(2147483647)
INF = 1 << 60
MOD = 10**9 + 7 # 998244353
input = lambda:sys.stdin.readline().rstrip()
class modfact(object):
def __init__(self, n):
fact, invfact = [1] * (n + 1), [1] * (n + 1)
for i in range(1, n + 1): fact[i] = i * fact[i - 1] % MOD
invfact[n] = pow(fact[n], MOD - 2, MOD)
for i in range(n - 1, -1, -1): invfact[i] = invfact[i + 1] * (i + 1) % MOD
self._fact, self._invfact = fact, invfact
def inv(self, n):
return self._fact[n - 1] * self._invfact[n] % MOD
def fact(self, n):
return self._fact[n]
def invfact(self, n):
return self._invfact[n]
def comb(self, n, k):
if k < 0 or n < k: return 0
return self._fact[n] * self._invfact[k] % MOD * self._invfact[n - k] % MOD
def perm(self, n, k):
if k < 0 or n < k: return 0
return self._fact[n] * self._invfact[n - k] % MOD
def resolve():
n, k = map(int, input().split())
mf = modfact(n)
res = 0
for i in range(min(k + 1, n)):
res += mf.comb(n, i) * mf.comb(n - 1, i) % MOD
res %= MOD
print(res)
resolve() | 1 | 67,181,020,882,598 | null | 215 | 215 |
XY=list(map(int,input().split()))
prize=0
for xy in XY:
if xy==1:
prize+=300000
elif xy==2:
prize+=200000
elif xy==3:
prize+=100000
if sum(XY)==2:
prize+=400000
print(prize) | # -*- coding: utf-8 -*-
import math
import itertools
import sys
import copy
# 入力
#A, B, C, D = map(int, input().split())
#L = list(map(int, input().split()))
#S = list(str(input()))
#N = int(input())
X, Y = map(int, input().split())
sum = 0
if X == 1 :
sum += 300000
elif X == 2 :
sum += 200000
elif X == 3 :
sum += 100000
if Y == 1 :
sum += 300000
elif Y == 2 :
sum += 200000
elif Y == 3 :
sum += 100000
if X == 1 and Y == 1 :
sum += 400000
print (sum)
| 1 | 140,205,517,434,340 | null | 275 | 275 |
r,c = map(int,raw_input().split())
a = [map(int,raw_input().split()) for _ in range(r)]
b = [0 for _ in range(c)]
for i in range(r) :
s = 0
for j in range(c) :
s = s + a[i][j]
b[j] = b[j] + a[i][j]
a[i].append(s)
print ' '.join(map(str,a[i]))
b.append(sum(b))
print ' '.join(map(str,b)) | # 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()
| 1 | 1,364,057,347,392 | null | 59 | 59 |
s = input()
count = 0
max = 0
for i in range(len(s)):
if s[i] == 'S':
count =0
else:
count += 1
if count > max:
max = count
print(max) | import sys
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
read = sys.stdin.buffer.read
sys.setrecursionlimit(10 ** 7)
INF = float('inf')
H, W = map(int, readline().split())
masu = []
for _ in range(H):
masu.append(readline().rstrip().decode('utf-8'))
# print(masu)
dp = [[INF]*W for _ in range(H)]
dp[0][0] = int(masu[0][0] == "#")
dd = [(1, 0), (0, 1)]
# 配るDP
for i in range(H):
for j in range(W):
for dx, dy in dd:
ni = i + dy
nj = j + dx
# はみ出す場合
if (ni >= H or nj >= W):
continue
add = 0
if masu[ni][nj] == "#" and masu[i][j] == ".":
add = 1
dp[ni][nj] = min(dp[ni][nj], dp[i][j] + add)
# print(dp)
ans = dp[H-1][W-1]
print(ans) | 0 | null | 27,277,886,920,368 | 90 | 194 |
X = int(input())
for i in range(-201, 201):
done = False
for j in range(-201, 201):
if i ** 5 - j ** 5 == X:
print(i, j)
done = True
break
if done:
break | n = int(input())
A = [int(i) for i in input().split()]
product = 1
A.sort()
for i in range(n):
product *= A[i]
if(product > 10**18):
print("-1")
break
if(product <= 10**18):
print(product) | 0 | null | 20,923,164,674,880 | 156 | 134 |
import typing
def binary_serch(x:int, b_sum:list):
l = 0
r = len(b_sum) - 1
mid = (l + r + 1) // 2
res = mid
while True:
if x == b_sum[mid]:
return mid
elif x < b_sum[mid]:
res = mid - 1
r = mid
mid = (l + r + 1) // 2
elif b_sum[mid] < x:
res = mid
l = mid
mid = (l + r + 1) // 2
if l + 1 == r:
return res
n, m, k = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
b_sum = [0] * (m + 2)
for i in range(m):
b_sum[i + 1] = b[i] + b_sum[i]
b_sum[-1] = 10 ** 9 + 1
a = [0] + a
pass_k = 0
ans = 0
for i in range(n + 1):
if pass_k + a[i] <= k:
pass_k += a[i]
book = i
book += binary_serch(k - pass_k, b_sum)
ans = max(ans, book)
else:
break
print(ans) | x = int(input())
count_500 = 0
count_5 = 0
count_500 = x // 500
x -= 500 * count_500
count_5 = x // 5
x -= 5 * count_5
print(1000 * count_500 + 5 * count_5) | 0 | null | 26,705,904,938,812 | 117 | 185 |
import sys
readline = sys.stdin.buffer.readline
sys.setrecursionlimit(10 ** 8)
INF = float('inf')
MOD = 10 ** 9 + 7
def main():
N = int(readline())
A = list(map(int, readline().split()))
R = 0
G = 0
B = 0
ans = 1
for i in range(N):
a = A[i]
count = 0
if R==a:
R+=1
count+=1
if G==a:
count+=1
if B==a:
count+=1
else:
if G==a:
G+=1
count+=1
if B==a:
count+=1
else:
if B==a:
B+=1
count+=1
else:
print(0)
exit()
ans*=count
ans%=MOD
print(ans)
if __name__ == '__main__':
main() | R, C, K = map(int, input().split())
# = int(input())
p = []
for k in range(K):
p.append(list(map(int, input().split())))
maps = [[0 for _ in range(C)] for _ in range(R)]
for k in range(K):
maps[p[k][0]-1][p[k][1]-1] += p[k][2]
point1 = [[0 for _ in range(C)] for _ in range(R)]
point2 = [[0 for _ in range(C)] for _ in range(R)]
point3 = [[0 for _ in range(C)] for _ in range(R)]
point1[0][0] = maps[0][0]
for r in range(R):
for c in range(C):
a, b, d = point1[r][c], point2[r][c], point3[r][c]
if c < C - 1:
x = maps[r][c+1]
point1[r][c+1] = max(point1[r][c+1], x, a)
point2[r][c+1] = max(point2[r][c+1], a + x, b)
point3[r][c+1] = max(point3[r][c+1], b + x, d)
if r < R - 1:
point1[r+1][c] = maps[r+1][c] + max(a, b, d)
print(max(point1[-1][-1], point2[-1][-1], point3[-1][-1])) | 0 | null | 67,707,410,270,358 | 268 | 94 |
a,b = map(int,(input().split()))
result = a - (b * 2)
if result <= 0:
result = 0
print(result)
| import math
A,B,H,M=map(int,input().split())
b=30*H+30*(M/60)
c=6*M
d=math.fabs(b-c)
d=math.radians(d)
f=0
f=A**2+B**2-2*A*B*(math.cos(d))
print(math.fabs(math.sqrt(f)))
| 0 | null | 93,615,778,900,996 | 291 | 144 |
n = int(input())
S = list(map(int, input().split()))
q = int(input())
T = list(map(int, input().split()))
C = []
for s in S:
for t in T:
if s == t and not s in C: C.append(s)
print(len(C)) | n = int(input())
S = set(map(int, input().split()))
q = int(input())
T = tuple(map(int, input().split()))
cnt = 0
for n in T:
cnt += n in S
print(cnt) | 1 | 69,367,985,230 | null | 22 | 22 |
# coding: utf-8
# Your code here!
N=int(input())
count=-1
for i in range(N//2+1):
count+=1
if N%2==0:
print(count-1)
else:
print(count) | a, b = map(int, raw_input().split())
d = a / b
r = a % b
f = a * 1.0 / b
print '%d %d %f' % (d,r,f) | 0 | null | 76,777,670,854,612 | 283 | 45 |
n,k=map(int,input().split())
a=list(map(int,input().split()))
f=list(map(int,input().split()))
a.sort()
f.sort()
f.reverse()
l=-1;r=max(a)*max(f)+1
sum=sum(a)
while abs(l-r)>1:
x=(l+r)//2
ct=0
for i in range(n):
ct+=max(a[i]-(x//f[i]),0)
if ct<=k:
r=x
else:
l=x
print(r) | print(+(input()<'1')) | 0 | null | 83,801,960,682,930 | 290 | 76 |
import sys
N,K=map(int, sys.stdin.readline().split())
LR=[ map(int, sys.stdin.readline().split()) for _ in range(K) ]
dp=[0]*(N+1)
sum_dp=[0]
mod=998244353
i=1
dp[i]=1
sum_dp.append(sum_dp[-1]+dp[i])
for i in range(2,N+1):
for l,r in LR:
dp[i]+=sum_dp[max(0,i-l)]-sum_dp[max(0,i-r-1)]
dp[i]%=mod
sum_dp.append( (sum_dp[-1]+dp[i])%mod )
print dp[-1]
| import sys
sys.setrecursionlimit(10 ** 9)
# input = sys.stdin.readline ####
def int1(x): return int(x) - 1
def II(): return int(input())
def MI(): return map(int, input().split())
def MI1(): return map(int1, input().split())
def LI(): return list(map(int, input().split()))
def LI1(): return list(map(int1, input().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def MS(): return input().split()
def LS(): return list(input())
def LLS(rows_number): return [LS() for _ in range(rows_number)]
def printlist(lst, k=' '): print(k.join(list(map(str, lst))))
INF = float('inf')
# from math import ceil, floor, log2
# from collections import deque, defaultdict
# from itertools import combinations as comb, combinations_with_replacement as comb_w, accumulate, product, permutations
# from heapq import heapify, heappop, heappush
# import numpy as np # cumsum
# from bisect import bisect_left, bisect_right
def solve():
N, K = MI()
S = []
mod = 998244353
for i in range(K):
l, r = MI()
S.append((l, r))
dp = [0] * (N+1)
dp[1] = 1
C = [0] * (N+1)
C[1] = 1
for i in range(2, N+1):
for s in S:
l = max(1, i - s[1])
r = i - s[0]
if r < 1:
continue
dp[i] += (C[r] - C[l-1]) % mod
C[i] += (dp[i] + C[i-1]) % mod
print(dp[N] % mod)
if __name__ == '__main__':
solve()
| 1 | 2,684,278,749,178 | null | 74 | 74 |
s=input()
l=input().split()
m=[int(i) for i in l]
print("{} {} {}".format(min(m),max(m),sum(m)))
| t = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
c = [t[0]*a[0],t[1]*a[1]]
d = [t[0]*b[0],t[1]*b[1]]
if sum(c)==sum(d):
print('infinity')
exit()
elif c[0]==d[0]:
print('infinity')
exit()
if sum(d)>sum(c) and d[0]>c[0]:
print(0)
exit()
elif sum(c)>sum(d) and c[0]>d[0]:
print(0)
exit()
else:
n = (c[0]-d[0])/(sum(d)-sum(c))
if n==int(n):
print(2*int(n))
else:
print(2*int(n)+1)
| 0 | null | 66,072,321,936,100 | 48 | 269 |
n = int(input())
A = [[0 for i in range(n)] for j in range(n)]
for i in range(n):
u, k, *v = list(map(int, input().split()))
for j in v:
A[int(u)-1][int(j)-1] = 1
# A[int(j)-1][int(u)-1] = 1
# for row in A:
# msg = ' '.join(map(str, row))
# # print(msg)
d = [-1] * n
f = [-1] * n
t = 0
# recursive
def dfs(u):
global t
# print('visit:', str(u), str(t))
t += 1
d[u] = t
for i in range(len(A[u])):
if A[u][i] == 1 and d[i] == -1:
dfs(i)
t += 1
f[u] = t
for i in range(n):
if d[i] == -1:
# print('start from:', str(i))
dfs(i)
for i in range(n):
print(str(i+1), str(d[i]), str(f[i]))
| import math
N, K = map(int, input().split())
A = list(map(float, input().split()))
min_A = 0
max_A = 10**10
while( max_A - min_A > 1):
now = (min_A + max_A) // 2
temp = 0
for i in A:
if i > now:
temp += (i // now)
if temp > K:
min_A = now
else:
max_A = now
print(int(min_A) + 1) | 0 | null | 3,256,607,779,490 | 8 | 99 |
n = int(input())
s = input()
nr = s.count('R')
nw = len(s)-nr
a = ('R'*nr)+('W'*nw)
c = 0
for i in range(n):
if(s[i:i+1] != a[i:i+1]):
c += 1
print(c // 2) | n = int(input())
S = [c for c in input()]
ans = 0
i = 0
j = n-1
while i < j:
if S[i] == "W":
if S[j] == "R":
S[i] = "R"
S[j] = "W"
j -= 1
i += 1
ans += 1
else:
j -= 1
else:
i += 1
print(ans) | 1 | 6,248,029,114,444 | null | 98 | 98 |
# AOJ ITP1_8_D
def numinput():
a = input().split()
for i in range(len(a)):
a[i] = int(a[i])
return a
def main():
string = input()
string += string
p = input()
# 文字列を2倍してその中から探す。
# 1≦pの長さ≦sの長さなのでこれでいい。
# 文字列含有には「文字列」.find(「探したい文字列」)を使う。
if string.find(p) >= 0: print("Yes")
else: print("No")
if __name__ == "__main__":
main()
| # -*- coding: utf-8 -*-
#############
# Libraries #
#############
import sys
input = sys.stdin.readline
import math
#from math import gcd
import bisect
import heapq
from collections import defaultdict
from collections import deque
from collections import Counter
from functools import lru_cache
#############
# Constants #
#############
MOD = 10**9+7
INF = float('inf')
AZ = "abcdefghijklmnopqrstuvwxyz"
#############
# Functions #
#############
######INPUT######
def I(): return int(input().strip())
def S(): return input().strip()
def IL(): return list(map(int,input().split()))
def SL(): return list(map(str,input().split()))
def ILs(n): return list(int(input()) for _ in range(n))
def SLs(n): return list(input().strip() for _ in range(n))
def ILL(n): return [list(map(int, input().split())) for _ in range(n)]
def SLL(n): return [list(map(str, input().split())) for _ in range(n)]
#####Shorten#####
def DD(arg): return defaultdict(arg)
#####Inverse#####
def inv(n): return pow(n, MOD-2, MOD)
######Combination######
kaijo_memo = []
def kaijo(n):
if(len(kaijo_memo) > n): return kaijo_memo[n]
if(len(kaijo_memo) == 0): kaijo_memo.append(1)
while(len(kaijo_memo) <= n): kaijo_memo.append(kaijo_memo[-1] * len(kaijo_memo) % MOD)
return kaijo_memo[n]
gyaku_kaijo_memo = []
def gyaku_kaijo(n):
if(len(gyaku_kaijo_memo) > n): return gyaku_kaijo_memo[n]
if(len(gyaku_kaijo_memo) == 0): gyaku_kaijo_memo.append(1)
while(len(gyaku_kaijo_memo) <= n): gyaku_kaijo_memo.append(gyaku_kaijo_memo[-1] * pow(len(gyaku_kaijo_memo),MOD-2,MOD) % MOD)
return gyaku_kaijo_memo[n]
def nCr(n,r):
if n == r: return 1
if n < r or r < 0: return 0
ret = 1
ret = ret * kaijo(n) % MOD
ret = ret * gyaku_kaijo(r) % MOD
ret = ret * gyaku_kaijo(n-r) % MOD
return ret
######Factorization######
def factorization(n):
arr = []
temp = n
for i in range(2, int(-(-n**0.5//1))+1):
if temp%i==0:
cnt=0
while temp%i==0:
cnt+=1
temp //= i
arr.append([i, cnt])
if temp!=1: arr.append([temp, 1])
if arr==[]: arr.append([n, 1])
return arr
#####MakeDivisors######
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
return divisors
#####MakePrimes######
def make_primes(N):
max = int(math.sqrt(N))
seachList = [i for i in range(2,N+1)]
primeNum = []
while seachList[0] <= max:
primeNum.append(seachList[0])
tmp = seachList[0]
seachList = [i for i in seachList if i % tmp != 0]
primeNum.extend(seachList)
return primeNum
#####GCD#####
def gcd(a, b):
while b: a, b = b, a % b
return a
#####LCM#####
def lcm(a, b):
return a * b // gcd (a, b)
#####BitCount#####
def count_bit(n):
count = 0
while n:
n &= n-1
count += 1
return count
#####ChangeBase#####
def base_10_to_n(X, n):
if X//n: return base_10_to_n(X//n, n)+[X%n]
return [X%n]
def base_n_to_10(X, n):
return sum(int(str(X)[-i-1])*n**i for i in range(len(str(X))))
def base_10_to_n_without_0(X, n):
X -= 1
if X//n: return base_10_to_n_without_0(X//n, n)+[X%n]
return [X%n]
#####IntLog#####
def int_log(n, a):
count = 0
while n>=a:
n //= a
count += 1
return count
#############
# Main Code #
#############
N,M,L = IL()
class WarshallFloyd():
def __init__(self, N):
self.N = N
self.d = [[float("inf") for i in range(N)] for i in range(N)]
def add(self, u, v, c, directed=False):
if directed is False:
self.d[u][v] = c
self.d[v][u] = c
else:
self.d[u][v] = c
def WarshallFloyd_search(self):
for k in range(self.N):
for i in range(self.N):
for j in range(self.N):
self.d[i][j] = min(self.d[i][j], self.d[i][k] + self.d[k][j])
hasNegativeCycle = False
for i in range(self.N):
if self.d[i][i] < 0:
hasNegativeCycle = True
break
for i in range(self.N):
self.d[i][i] = 0
return hasNegativeCycle, self.d
W = WarshallFloyd(N)
for _ in range(M):
u,v,c = IL()
if c>L: continue
W.add(u-1,v-1,c)
_,d = W.WarshallFloyd_search()
W = WarshallFloyd(N)
for u in range(N):
for v in range(u+1,N):
if d[u][v] > L: continue
W.add(u,v,1)
_,d = W.WarshallFloyd_search()
Q = I()
for _ in range(Q):
s,t = IL()
if d[s-1][t-1] == INF:
print(-1)
else:
print(d[s-1][t-1]-1)
| 0 | null | 87,918,639,167,198 | 64 | 295 |
# 問題：https://atcoder.jp/contests/abc142/tasks/abc142_b
n, k = map(int, input().strip().split())
h = list(map(int, input().strip().split()))
res = 0
for i in range(n):
if h[i] < k:
continue
res += 1
print(res)
| import sys
import math
import itertools
import bisect
from copy import copy
from collections import deque,Counter
from decimal import Decimal
def s(): return input()
def i(): 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 ** 9)
mod = 10**9+7
count = 0
N,K = I()
h = l()
for i in range(N):
if h[i] >= K:
count += 1
print(count)
| 1 | 178,096,287,053,102 | null | 298 | 298 |
#!/usr/bin/env python3
from typing import *
YES = 'Yes'
NO = 'No'
# def solve(D: int, T: int, S: int) -> str:
def solve(D, T, S):
return YES if D <= T*S else NO
def main():
D, T, S = map(int, input().split())
a = solve(D, T, S)
print(a)
if __name__ == '__main__':
main()
| #!/usr/bin/python3
cmdvar_numlist=input()
cmdvar_spritd=cmdvar_numlist.split()
D,T,S=list(map(int,cmdvar_spritd))
if D/S<=T:
print("Yes")
else:
print("No") | 1 | 3,501,561,818,820 | null | 81 | 81 |
class Point:
def __init__(self, x, y):
super().__init__()
self.x = x
self.y = y
def solve(p1, p2):
s_x = p1.x + (p2.x - p1.x) * (1/3)
s_y = p1.y + (p2.y - p1.y) * (1/3)
t_x = p1.x + (p2.x - p1.x) * (2/3)
t_y = p1.y + (p2.y - p1.y) * (2/3)
u_x = (p2.x + p1.x) * (1/2) + (p1.y - p2.y) * (1/6) * pow(3, 1/2)
u_y = (p2.y + p1.y) * (1/2) + (p2.x - p1.x) * (1/6) * pow(3, 1/2)
s = Point(s_x, s_y)
t = Point(t_x, t_y)
u = Point(u_x, u_y)
return [s, u, t]
if __name__ == "__main__":
n = int(input())
P = [Point(0, 0), Point(100, 0)]
for i in range(n):
TMP = []
for j in range(len(P) - 1):
TMP.append(P[j])
TMP += solve(P[j], P[j+1])
TMP.append(P[-1])
P = TMP
for p in P:
print('{} {}'.format(p.x, p.y))
| import math
R = int(input())
p = math.pi
print(2 * p * R) | 0 | null | 15,765,717,197,010 | 27 | 167 |
D = int(input())
cs = list(map(int, input().split()))
ss = [input().split() for l in range(D)]
ts = [int(input()) for i in range(D)]
ans=0
all_cs=sum(cs)
cs_last=[0]*26
def c0(d):
mainas=0
for i in range(26):
#print(cs[i]*(d-cs_last[i]))
mainas-=cs[i]*(d-cs_last[i])
return mainas
for i in range(D):
cs_last[ts[i]-1]=i+1
ans+=int(ss[i][ts[i]-1])+c0(i+1)
print(ans) | D = int(input())
c = [int(x) for x in input().split()]
s = []
for i in range(D):
s.append([int(x) for x in input().split()])
ans = 0
nissuu = [0] * 26
for i in range(D):
t = int(input())
for j in range(26):
if j == t-1:
nissuu[j] = 0
else:
nissuu[j] += 1
ans -= c[j]*nissuu[j]
ans += s[i][t-1]
print(ans) | 1 | 10,005,740,622,582 | null | 114 | 114 |
def gcd(a, b):
while b:
a, b = b, a % b
return a
def lcm(a, b):
return a * b // gcd(a, b)
def main():
from math import ceil
n, m, *a = map(int, open(0).read().split())
c = 0
t = a[0]
while t % 2 == 0:
c += 1
t = t // 2
for x in a[1:]:
d = 0
while x % 2 == 0:
d += 1
x = x // 2
if d != c:
print(0)
break
t = lcm(t, x)
else:
ans = ceil(m // 2 ** (c-1) // t / 2)
print(ans)
if __name__ == "__main__":
main()
| def gcd(a, b):
while b != 0:
a, b = b, a % b
return a
def lcm(a, b):
return a * b // gcd(a, b)
def two(val):
ret = 0
tmp = val
while True:
if tmp != 0 and tmp % 2 == 0:
ret += 1
tmp = tmp // 2
else:
break
return ret
n, m = map(int, input().split())
a_list = list(map(int, input().split()))
b_list = []
for item in a_list:
b_list.append(item // 2)
cnt = -1
for item in b_list:
ret = two(item)
if cnt == -1:
cnt = ret
elif cnt != ret:
print(0)
exit()
val = b_list[0]
for item in b_list:
val = lcm(item, val)
ret = m // val
tmp1 = ret // 2
tmp2 = ret % 2
print(tmp1 + tmp2)
| 1 | 102,047,364,389,440 | null | 247 | 247 |
import math
def solve():
N = int(input())
A = list(map(int, input().split()))
A.sort(reverse = True)
A_half = math.ceil(N/2)
A_pre = A[:A_half]
A_post = A[A_half:]
ret = sum(A_pre)
for i in range(len(A_post)-1):
ret += min(A_pre[i],A_pre[(i+1)%A_half])
print(ret)
solve() | n = int(input())
v = 'abcdefghij'
def dfs(s):
if len(s) == n:
print (s)
return
for i in range(len(set(s))+1):
dfs(s+v[i])
dfs('a') | 0 | null | 30,741,497,610,668 | 111 | 198 |
import sys
N=input()
i = 1
for i in range(1,N+1):
if (i % 3) == 0 :
sys.stdout.write(" ")
sys.stdout.write("%d" % i)
else:
if (i % 10 ) == 3 :
sys.stdout.write(' ')
sys.stdout.write("%d" % i)
else:
if (i/10)%10 == 3:
#print (i/10)%10,"a"
sys.stdout.write(' ')
sys.stdout.write("%d" % i)
else:
if (i/100)%10 == 3:
sys.stdout.write(' ')
sys.stdout.write("%d" % i)
else:
if (i/100)%10 == 3:
sys.stdout.write(' ')
sys.stdout.write("%d" % i)
else:
if(i/1000)%10 == 3:
sys.stdout.write(' ')
sys.stdout.write("%d" % i)
print "" | n = int(input())
s = input()
ans = 0
for i in range(n-2):
if s[i:i+3] == "ABC":
ans += 1
print(ans) | 0 | null | 50,073,295,260,922 | 52 | 245 |
S = input()
T = input()
judge = T[0:len(S)]
if judge == S:
print("Yes")
else:
print("No") | N = int(input())
x = 0
for i in range(1,N+1):
if i%3 == 0:
print(" %d"%i,end = "");
else:
x = i
while (x):
if x%10 == 3:
print(" %d"%i,end = "")
break
x //= 10
print()
| 0 | null | 11,241,115,760,928 | 147 | 52 |
def bubble(x):
x = x + []
n = len(x)
for i in range(n):
for j in range(i+1,n)[::-1]:
if x[j] % 10 < x[j-1] % 10:
x[j], x[j-1] = x[j-1], x[j]
return x
def selection(x):
x = x + []
n = len(x)
for i in range(n):
mini = i
for j in range(i, n):
if x[j] % 10 < x[mini] % 10:
mini = j
if i != mini:
x[i], x[mini] = x[mini], x[i]
return x
def order(x):
y = []
for i in range(1,9):
y.extend([e for e in x if e % 10 == i])
return y
def output(x):
for e in x:
print 'SHDC'[e/10]+str(e % 10),
print
def check(x, y):
output(x)
if y == order(x):
print 'Stable'
else:
print 'Not stable'
return
n = input()
x = []
for s in raw_input().split():
x.append('SHDC'.index(s[0])*10 + int(s[1]))
x0 = order(x)
check(bubble(x), x0)
check(selection(x), x0) | a,b,c=map(int,input().split())
import math
d=math.sin(math.radians(c))
print(a*b*d/2)
e=math.cos(math.radians(c))
x=math.sqrt(a**2+b**2-2*a*b*e)
print(a+b+x)
print(2*(a*b*d/2)/a)
| 0 | null | 97,222,124,890 | 16 | 30 |
W, H, x, y, r = map(int, input().split())
if r <= x <= W - r and r <= y <= H - r:
print("Yes")
else:
print("No")
| n = int(input())
maxv = -20000000000
minv = int(input())
for i in range(n-1):
R = int(input())
maxv = max(maxv, R - minv)
minv = min(minv, R)
print(maxv) | 0 | null | 226,016,962,922 | 41 | 13 |
a,b=map(str, input().split())
s=b+a
print(s) | S, T = map(str, input().split())
print("{}{}".format(T, S)) | 1 | 102,683,939,639,268 | null | 248 | 248 |
import os, sys, re, math
N = int(input())
D = [int(n) for n in input().split()]
value = 0
for i in range(len(D) - 1):
for j in range(i + 1, len(D)):
value += D[i] * D[j]
print(value)
| import numpy as np
a, b, c, d = map(int, input().split())
hoge = []
hoge.append(a*c)
hoge.append(a*d)
hoge.append(b*c)
hoge.append(b*d)
print(max(hoge)) | 0 | null | 85,748,157,631,718 | 292 | 77 |
import sys
from collections import Counter
from collections import deque
import heapq
import math
import fractions
import bisect
import itertools
def input(): return sys.stdin.readline().strip()
def mp(): return map(int,input().split())
def lmp(): return list(map(int,input().split()))
a,b,c,d,k=mp()
print(c*60+d-a*60-b-k) | def make_bit(n):
bit = []
for i in range(2**n):
bit.append(bin(i)[2::])
i = 0
while i < len(bit):
while len(bit[i]) < len(bin(2**n-1)[2::]):
bit[i] = "0" + bit[i]
i += 1
return bit
h, w, k = map(int, input().split())
c = [list(input()) for _ in range(h)]
h_pats = make_bit(h)
w_pats = make_bit(w)
ans = 0
for h_pat in h_pats:
for w_pat in w_pats:
cnt = 0
for i in range(h):
for j in range(w):
if h_pat[i] == "1" or w_pat[j] == "1":
continue
if c[i][j] == "#":
cnt += 1
if cnt == k:
ans += 1
print(ans) | 0 | null | 13,491,374,110,392 | 139 | 110 |
W,H,x,y,r=map(int,input().split())
print('Yes') if x+r<=W and y+r<=H and r<=x and r<=y else print('No')
| from collections import Counter
S = input()
L = len(list(S))
dp = [0] * L
dp[0] = 1
T = [0] * L
T[0] = int(S[-1])
for i in range(1, L):
dp[i] = dp[i - 1] * 10
dp[i] %= 2019
T[i] = int(S[-(i+1)]) * dp[i] + T[i - 1]
T[i] %= 2019
ans = 0
for k, v in Counter(T).items():
if k == 0:
ans += v
ans += v * (v - 1) // 2
else:
ans += v * (v - 1) // 2
print(ans)
| 0 | null | 15,698,662,903,142 | 41 | 166 |
s = input()
num = int(input())
for i in range(num):
L = input().split()
if L[0] == 'print':
print(s[int(L[1]):int(L[2])+1])
elif L[0] == 'reverse':
ts = s[int(L[1]):int(L[2])+1]
s = s[:int(L[1])] + ts[:: -1] + s[int(L[2])+1:]
elif L[0] == 'replace':
s = s[:int(L[1])] + L[3] + s[int(L[2])+1:]
| from collections import deque
n = int(input())
d = deque()
for _i in range(n):
line = input().split()
order = line[0]
if order in ('insert', 'delete'):
key = line[1]
if order == 'insert':
d.appendleft(key)
elif order == 'delete':
try:
d.remove(key)
except ValueError:
pass
elif order == 'deleteFirst':
d.popleft()
elif order == 'deleteLast':
d.pop()
else:
raise ValueError('Invalid order: {order}')
print(' '.join(d))
| 0 | null | 1,060,368,321,276 | 68 | 20 |
def solve(n):
if n % 2 == 0:
return n // 2 - 1
else:
return (n - 1) // 2
def main():
n = int(input())
res = solve(n)
print(res)
def test():
assert solve(4) == 1
assert solve(999999) == 499999
if __name__ == "__main__":
test()
main()
| N = int(input())
XL = [list(map(int, input().split())) for x in range(N)]
XL = sorted(XL, key=lambda x: x[0]+x[1])
cnt = 0
prev_right = -10**9+10
for x, l in XL:
left = x - l
right = x + l
if left >= prev_right:
cnt += 1
prev_right = right
print(cnt)
| 0 | null | 121,563,869,941,738 | 283 | 237 |
n = int(input())
a = list(map(int, input().split()))
ans = 1000
stock = 0
for i in range(n-1):
if a[i+1] > a[i]:
buy = ans//a[i]
stock += buy
ans -= buy*a[i]
else:
ans += stock*a[i]
stock = 0
ans += stock*a[-1]
print(ans)
| N, K = map(int, input().split())
A = list(map(int, input().split()))
B = []
T = {"mi":0, "pu":0, "zero":0}
for i in range(N):
if A[i] < 0:
T["mi"] += 1
elif A[i] == 0:
T["zero"] += 1
else:
T["pu"] += 1
mod = 10**9+7
for i in range(N):
if A[i] < 0:
B.append([A[i]*(-1), 1])
else:
B.append([A[i], 0])
A.sort()
B.sort(reverse=True)
ans = 1
c = 0
for i in range(K):
ans *= B[i][0]
ans %= mod
c += B[i][1]
if c % 2 == 0:
print(ans)
elif K > T["pu"]+T["mi"]:
print(0)
elif T["mi"] == 1 and K > T["pu"]:
ans = 1
for i in range(N):
ans *= A[i]
ans %= mod
if T["zero"] != 0:
ans = 0
print(ans)
elif T["pu"] == 1 and K > T["mi"]:
ans = 1
for i in range(N):
ans *= A[i]
ans %= mod
if T["zero"] != 0:
ans = 0
print(ans)
elif T["pu"] == 0:
ans = 1
A.reverse()
for i in range(K):
ans *= A[i]
ans %= mod
if T["zero"] != 0:
ans = 0
print(ans)
elif N == K:
ans = 1
for i in range(N):
ans *= A[i]
ans %= mod
print(ans)
else:
change1 = B[K-1][1]
change2 = (change1 + 1)%2
chindex1 = K-1
chindex2 = -1
for i in range(K-1, -1, -1):
if B[i][1] == change2:
chindex2 = i
break
afterindex1 = -1
afterindex2 = -1
for i in range(K, N):
if B[i][1] == change2:
afterindex1 = i
break
for i in range(K, N):
if B[i][1] == change1:
afterindex2 = i
break
result1 = 0
result2 = 0
if chindex1 >= 0 and afterindex1 >= 0:
ans = 1
for i in range(N):
if i <= K-1 or i == afterindex1:
if i != chindex1:
ans *= B[i][0]
ans %= mod
result1 = ans
if chindex2 >= 0 and afterindex2 >= 0:
ans = 1
for i in range(N):
if i <= K-1 or i == afterindex2:
if i != chindex2:
ans *= B[i][0]
ans %= mod
result2 = ans
if result1 == 0 and result2 == 0:
print(0)
elif result1 == 0:
print(result2)
elif result2 == 0:
print(result1)
elif B[afterindex1][0]*B[chindex2][0] - B[afterindex2][0]*B[chindex1][0] > 0:
print(result1)
else:
print(result2) | 0 | null | 8,443,278,720,800 | 103 | 112 |
class Dice:
def __init__(self, labels):
self.up = labels[0]
self.front = labels[1]
self.right = labels[2]
self.left = labels[3]
self.back = labels[4]
self.down = labels[5]
def east(self):
self.up, self.right, self.down, self.left = self.left, self.up, self.right, self.down
def north(self):
self.up, self.back, self.down, self.front = self.front, self.up, self.back, self.down
def south(self):
self.up, self.front, self.down, self.back = self.back, self.up, self.front, self.down
def west(self):
self.up, self.left, self.down, self.right = self.right, self.up, self.left, self.down
dice = Dice(list(map(int, input().split())))
for cmd in list(input()):
if cmd == 'E':
dice.east()
if cmd == 'N':
dice.north()
if cmd == 'S':
dice.south()
if cmd == 'W':
dice.west()
print(dice.up) | class Dice(object):
"""docstring for Dice"""
def __init__(self, numeric_column):
self.numeric_column=numeric_column
def roll_to_S_direction(self):
self.numeric_column=[self.numeric_column[4],self.numeric_column[0],self.numeric_column[2],self.numeric_column[3],self.numeric_column[5],self.numeric_column[1]]
def roll_to_N_direction(self):
self.numeric_column=[self.numeric_column[1],self.numeric_column[5],self.numeric_column[2],self.numeric_column[3],self.numeric_column[0],self.numeric_column[4]]
def roll_to_E_direction(self):
self.numeric_column=[self.numeric_column[3],self.numeric_column[1],self.numeric_column[0],self.numeric_column[5],self.numeric_column[4],self.numeric_column[2]]
def roll_to_W_direction(self):
self.numeric_column=[self.numeric_column[2],self.numeric_column[1],self.numeric_column[5],self.numeric_column[0],self.numeric_column[4],self.numeric_column[3]]
dice=Dice(map(int,raw_input().split()))
direction=raw_input()
for i in direction:
if i=='S': dice.roll_to_S_direction()
elif i=='N': dice.roll_to_N_direction()
elif i=='E': dice.roll_to_E_direction()
else: dice.roll_to_W_direction()
print dice.numeric_column[0] | 1 | 243,900,569,862 | null | 33 | 33 |
import sys
import math
from enum import Enum
while True:
n=int(input())
if n==0:
break
s=list(map(int,input().split()))
sum1=0
for i in range(len(s)):
sum1+=s[i]
a=sum1/len(s)
sum2=0
for i in range(len(s)):
sum2+=s[i]*s[i]
b=sum2/len(s)
print("%.10f"%(math.sqrt(b-a*a)))
| def ii():return int(input())
def iim():return map(int,input().split())
def iil():return list(map(int,input().split()))
def ism():return map(str,input().split())
def isl():return list(map(str,input().split()))
#from fractions import Fraction
from math import gcd
mod = int(1e9+7)
n = ii()
cnd = {}
azero = 0
bzero = 0
allzero = 0
for _ in range(n):
a,b = iim()
if a == 0:
if b != 0:
azero += 1
else:
allzero += 1
elif b == 0:
bzero += 1
else:
'''
ratio = Fraction(a,b)
before = cnd.get(ratio,False)
if before:
cnd[ratio] = [before[0]+1,before[1]]
else:
invratio = Fraction(-b,a)
check = cnd.get(invratio,False)
if check:
cnd[invratio] = [check[0],check[1]+1]
else:
cnd[ratio] = [1,0]
'''
g = gcd(a,b)
a //= g
b //= g
if a < 0:
a *= -1
b *= -1
cnd[(a,b)] = cnd.get((a,b),0)+1
noreg = 0
if azero == 0 or bzero == 0:
noreg += max(azero,bzero)
ans = 1
else:
ans = (2**azero%mod + 2**bzero%mod - 1)%mod
#print('ans block')
#print(ans,noreg)
#print(cnd)
for k,item in cnd.items():
a,b = k
if b>0:
m = cnd.get((b,-a),False)
if m:
ans *= (2**item%mod+2**m%mod-1)%mod
else:
noreg += item
else:
m = cnd.get((-b,a),False)
if not m:
noreg += item
#print('hoge')
print(int((ans*((2**noreg)%mod)-1+allzero)%mod)) | 0 | null | 10,657,193,363,812 | 31 | 146 |
N=int(raw_input())
max=(-1)*(10**9)
x1=input()
min=x1
for i in range(N-1):
x=int(raw_input())
if max < x-min:
max=x-min
if min>x:
min=x
print max | import sys
def get_maximum_profit():
element_number = int(input())
v0 = int(input())
v1 = int(input())
min_v = min(v0, v1)
max_profit = v1-v0
for v in map(int, sys.stdin.readlines()):
max_profit = max(max_profit, v-min_v)
min_v = min(min_v, v)
print(max_profit)
if __name__ == '__main__':
get_maximum_profit() | 1 | 12,820,261,252 | null | 13 | 13 |
#import numpy as np
import math
#from decimal import *
#from numba import njit
#@njit
def main():
(N, M, K) = map(int, input().split())
MOD = 998244353
fact = [1]*(N+1)
factinv = [1]*(N+1)
for i in range(1,N+1):
fact[i] = fact[i-1]*i % MOD
factinv[i] = pow(fact[i], MOD-2, MOD)
def comb(n, k):
return fact[n] * factinv[k] * factinv[n-k] % MOD
ans = 0
for k in range(K+1):
ans += (comb(N-1,k)*M*pow(M-1, N-k-1, MOD))%MOD
print(ans%MOD)
main()
| def num2alpha(num):
if num<=26:
return chr(64+num)
elif num%26==0:
return num2alpha(num//26-1)+chr(90)
else:
return num2alpha(num//26)+chr(64+num%26)
print(num2alpha(int(input())).lower()) | 0 | null | 17,609,692,106,858 | 151 | 121 |
from sys import stdin
A, B = [int(x) for x in stdin.readline().rstrip().split()]
if A > 2*B:
print(A - 2*B)
else:
print(0) | __author__= 'CIPHER'
str = input()
numList = str.split(' ')
numList = [ int(x) for x in numList]
#print(numList)
result = 1
length = 0
for x in numList:
result *= x
length += x
print(result,2*length) | 0 | null | 83,755,682,530,780 | 291 | 36 |
import math
from math import gcd,pi,sqrt
INF = float("inf")
MOD = 10**9 + 7
import sys
sys.setrecursionlimit(10**6)
import itertools
from collections import Counter,deque
def i_input(): return int(input())
def i_map(): return map(int, input().split())
def i_list(): return list(i_map())
def i_row(N): return [i_input() for _ in range(N)]
def i_row_list(N): return [i_list() for _ in range(N)]
def s_input(): return input()
def s_map(): return input().split()
def s_list(): return list(s_map())
def s_row(N): return [s_input for _ in range(N)]
def s_row_str(N): return [s_list() for _ in range(N)]
def s_row_list(N): return [list(s_input()) for _ in range(N)]
def main():
n,a,b = i_map()
s = pow(2,n,MOD) - 1
def fur(n,r):
p,q = 1, 1
for i in range(r):
p = p*(n-i)%MOD
q = q*(i+1)%MOD
return (p * pow(q,MOD-2,MOD)) % MOD
print((s - fur(n,a) - fur(n,b)) % MOD)
if __name__=="__main__":
main()
| #!/usr/bin/env python3
from collections import defaultdict, Counter
from itertools import product, groupby, count, permutations, combinations
from math import pi, sqrt
from collections import deque
from bisect import bisect, bisect_left, bisect_right
from string import ascii_lowercase
from functools import lru_cache
import sys
sys.setrecursionlimit(10000)
INF = float("inf")
YES, Yes, yes, NO, No, no = "YES", "Yes", "yes", "NO", "No", "no"
dy4, dx4 = [0, 1, 0, -1], [1, 0, -1, 0]
dy8, dx8 = [0, -1, 0, 1, 1, -1, -1, 1], [1, 0, -1, 0, 1, 1, -1, -1]
def inside(y, x, H, W):
return 0 <= y < H and 0 <= x < W
def ceil(a, b):
return (a + b - 1) // b
def sum_of_arithmetic_progression(s, d, n):
return n * (2 * s + (n - 1) * d) // 2
def gcd(a, b):
if b == 0:
return a
return gcd(b, a % b)
def lcm(a, b):
g = gcd(a, b)
return a / g * b
def solve():
N = int(input())
X = list(map(int, input().split()))
ans = INF
for p in range(0, 102):
t = 0
for x in X:
t += (x - p) ** 2
ans = min(ans, t)
print(ans)
def main():
solve()
if __name__ == '__main__':
main()
| 0 | null | 65,990,604,665,570 | 214 | 213 |
#!/usr/bin/env python3
numbers = input().split(" ")
n = int(numbers[0])
m = int(numbers[1])
numbers = input().split(" ")
h = [int(x) for x in numbers]
h.insert(0, 0)
is_good = [1] * (n + 1)
for i in range(m):
numbers = input().split(" ")
a = int(numbers[0])
b = int(numbers[1])
if h[a] <= h[b]:
is_good[a] = 0
if h[a] >= h[b]:
is_good[b] = 0
print(is_good.count(1) - 1)
| N, M = map(int, input().split())
scs = [tuple(map(int, input().split())) for _ in range(M)]
if N == 1:
L, R = 0, 9
elif N == 2:
L, R = 10, 99
else:
L, R = 100, 999
for x in range(L, R+1):
strX = str(x)
for s, c in scs:
if strX[s-1] != str(c):
break
else:
print(x)
break
else:
print(-1)
| 0 | null | 43,086,651,619,730 | 155 | 208 |
N = int(input())
A = list(map(int, input().split()))
cnt = [0] * (100001)
ans = sum(A)
for a in A:
cnt[a] += 1
Q = int(input())
for _ in range(Q):
B, C = map(int, input().split())
cnt[C] += cnt[B]
ans += cnt[B] * (C-B)
cnt[B] = 0
print(ans) | import sys
def input(): return sys.stdin.readline().rstrip()
from collections import Counter
def main():
n = int(input())
A = list(map(int,input().split()))
Q = int(input())
S = sum(A)
cunt_A = Counter(A)
for q in range(Q):
b, c = map(int,input().split())
S += (c-b)*cunt_A[b]
cunt_A[c] += cunt_A[b]
cunt_A[b] = 0
print(S)
if __name__=='__main__':
main() | 1 | 12,175,938,123,972 | null | 122 | 122 |
# D - Sum of Divisors
N = int(input())
ans = (1 + N) * N
for i in range(2, N//2 + 1):
j = 2
while True:
if i * j <= N:
ans += i * j
j += 1
else:
break
print(ans - 1) | N = int(input())
ans = 0
l = N//2
for i in range(1, l+1): #約数についてのループ
n = N//i
ans += i*n*(n+1)//2
# 約数がl+1より大きい時は、それを約数に持つ数は1個しかない(それ自身)
ans += (l+1+N)*(N-l)//2
print(ans) | 1 | 11,076,396,277,380 | null | 118 | 118 |
#!/usr/bin/env python
from __future__ import division, print_function
from sys import stdin
def fibo(n):
a, b = 1, 1
while n:
a, b = b, a + b
n -= 1
return a
print(fibo(int(stdin.readline()))) | class Main:
S = input()
if S[-1] == 's':
print(S+'es')
else :
print(S+'s') | 0 | null | 1,204,291,255,892 | 7 | 71 |
A,B,N = map(int,input().split())
if N >= B - 1:
x = B - 1
else:
x = N
print(A*(x%B)//B) | A,B,N = list(map(int, input().split()))
#floor(A*x // B vs A * (x/B)
#x= pB + q (0<=q<B)
# Ap +(Aq// B) - AP
x = B-1 if B<=N else N
print((A*x) // B) | 1 | 28,157,563,491,190 | null | 161 | 161 |
n, k = (int(x) for x in input().split())
A = list(int(x) for x in input().split())
MOD = 10**9 + 7
A.sort()
l = 0
r = n - 1
flag = False # マイナスになってしまうかフラグ
ans = 1
if k % 2 == 1:
ans = A[r]
r -= 1
k -= 1
if ans < 0:
flag = True
if flag: # どうしてもマイナスになってしまう場合(kが奇数で要素すべてがマイナスの場合)
while k:
ans *= A[r] * A[r - 1] % MOD
ans %= MOD
r -= 2
k -= 2
else: # 必ず0以上にできる場合
while k:
x = A[l] * A[l + 1]
y = A[r] * A[r - 1]
if x > y:
ans *= x % MOD
ans %= MOD
l += 2
else:
ans *= y % MOD
ans %= MOD
r -= 2
k -= 2
print(ans)
| def solve():
MOD = 10**9 + 7
N, K = map(int, input().split())
As = list(map(int, input().split()))
if K == N:
ans = 1
for A in As:
ans *= A
ans %= MOD
print(ans)
return
As.sort(key=lambda x: abs(x))
if max(As) < 0 and K%2 != 0:
ans = 1
for A in As[:K]:
ans *= A
ans %= MOD
print(ans)
return
pos0As, negAs = [], []
for A in As:
if A >= 0:
pos0As.append(A)
elif A < 0:
negAs.append(A)
pos0As.sort()
negAs.sort(reverse=True)
ans = 1
rest = K
while rest > 0:
if rest == 1:
ans *= pos0As.pop()
rest -= 1
else:
if len(pos0As) < 2:
ans *= negAs.pop()
ans *= negAs.pop()
rest -= 2
elif len(negAs) < 2:
ans *= pos0As.pop()
rest -= 1
else:
pPos0 = pos0As[-1] * pos0As[-2]
pNeg = negAs[-1] * negAs[-2]
if pPos0 >= pNeg:
ans *= pos0As.pop()
rest -= 1
else:
ans *= negAs.pop()
ans *= negAs.pop()
rest -= 2
ans %= MOD
print(ans)
solve()
| 1 | 9,393,802,701,982 | null | 112 | 112 |
x=int(input())
n=x//500
m=x%500
k=m//5
print(1000*n+5*k) | h,w,k = map(int, input().split())
s = [list(map(str,list(input()))) for i in range(h)]
ans =0
for ii in range(1<<h):
for jj in range(1<<w):
cnt = 0
for i in range(h):
for j in range(w):
if (ii >> i & 1):
continue
if (jj >> j & 1):
continue
if (s[i][j] == '#'):
cnt += 1
if cnt == k:
ans += 1
print(ans)
| 0 | null | 26,042,292,260,010 | 185 | 110 |
def main():
n = int(input())
xym, xyM, x_ym, x_yM = 10**9, -10**9, 10**9, -10**9
for _ in range(n):
x, y = map(int, input().split())
xy, x_y = x+y, x-y
xym, xyM, x_ym, x_yM = min(xym, xy), max(xyM, xy), min(x_ym, x_y), max(x_yM, x_y)
print(max(xyM-xym, x_yM-x_ym))
if __name__ == "__main__":
main() | n=int(input())
zp=[]
zl=[]
for i in range(n):
a,b=map(int,input().split())
zp.append(a+b)
zl.append(a-b)
ans=max((max(zp)-min(zp)),(max(zl)-min(zl)))
print(ans) | 1 | 3,404,958,281,582 | null | 80 | 80 |
from collections import defaultdict as dd
from collections import deque
import bisect
import heapq
def ri():
return int(input())
def rl():
return list(map(int, input().split()))
def solve():
n = ri()
L = [0] * (n + 1)
for i in rl():
L[i] += 1
for i in range(1, n + 1):
print (L[i])
mode = 's'
if mode == 'T':
t = ri()
for i in range(t):
solve()
else:
solve()
| def f():
n, m = map(int, input().split())
num = [set() for i in range(n)]
for i in range(m):
s, c = map(int, input().split())
num[s-1].add(c)
s = []
for i in num:
if len(i) > 1:
print(-1)
return
if len(i) == 1:
for x in i:
s.append(x)
break
else:
s.append(0)
if s[0] == 0 and n != 1:
if len(num[0]) > 0:
print(-1)
return
else:
s[0] = 1
print(''.join(str(x) for x in s))
f() | 0 | null | 46,716,320,039,578 | 169 | 208 |
X = int(input())
N = int(X**(1/5))
ans = [0,0]
for i in range(-2*N-1, 2*N+2):
for j in range(-2*N-1, 2*N+2):
if i**5-j**5==X:
ans = [i, j]
ans = [str(i) for i in ans]
ans = ' '.join(ans)
print(ans) | N, P = map(int, input().split())
S = input()
if P == 2 or P == 5:
cnt = 0
cnt_a = 0
for s in S[::-1]:
if int(s) % P == 0:
cnt_a += 1
cnt += cnt_a
else:
r_lst = [0] * P
r_lst[0] = 1
cnt = 0
num = 0
for i, s in enumerate(S[::-1]):
num = (num + int(s) * pow(10, i, P)) % P
cnt += r_lst[num]
r_lst[num] += 1
print(cnt)
| 0 | null | 41,705,416,748,398 | 156 | 205 |
import sys
from itertools import accumulate
read = sys.stdin.buffer.read
input = sys.stdin.buffer.readline
inputs = sys.stdin.buffer.readlines
import bisect
n,m=map(int,input().split())
A=list(map(int,input().split()))
A.sort()
def hand(x):
cnt=0
for i in range(n):
k=n-bisect.bisect_left(A,x-A[-i-1])
if k==0:
break
cnt+=k
if cnt>=m:
break
return cnt
def main():
l=0
h=2*10**5+1
mid=(l+h)//2
while l+1<h:
mid=(l+h)//2
if hand(mid)<m:
h=mid
else:
l=mid
B = list(accumulate(A[::-1]))[::-1]
ans=0
cnt=0
for i in range(n):
index=bisect.bisect_left(A,l-A[-i-1]+1)
if n==index:
break
else:
ans+=(n-index)*A[-i-1]+B[index]
cnt+=(n-index)
ans+=(m-cnt)*l
print(ans)
if __name__ == "__main__":
main()
| W, H, x, y, r = map(int, input().split())
if r <= x <= W - r and r <= y <= H - r:
print("Yes")
else:
print("No")
| 0 | null | 54,066,466,112,470 | 252 | 41 |
s=input()
if s=="RSR":
print("1")
else:
ans=s.count("R")
print(ans)
| import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, tan, asin, acos, atan, radians, degrees, log2, gcd
from itertools import accumulate, permutations, combinations, combinations_with_replacement, product, groupby
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left, insort, insort_left
from heapq import heappush, heappop
from functools import reduce, lru_cache
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def TUPLE(): return tuple(map(int, input().split()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = 10**6#float('inf')
mod = 10 ** 9 + 7
#mod = 998244353
from decimal import *
#import numpy as np
#decimal.getcontext().prec = 10
#階乗#
lim = 4*10**5 #必要そうな階乗の限界を入力
fact = [1] * (lim+1)
for n in range(1, lim+1):
fact[n] = n * fact[n-1] % mod
#階乗の逆元#
fact_inv = [1]*(lim+1)
fact_inv[lim] = pow(fact[lim], mod-2, mod)
for n in range(lim, 0, -1):
fact_inv[n-1] = n*fact_inv[n]%mod
def C(n, r):
return (fact[n]*fact_inv[r]%mod)*fact_inv[n-r]%mod
n, k = MAP()
if n-1 <= k:
print(C(2*n-1, n))
exit()
ans = 0
for i in range(k+1):
ans += C(n, i) * C(n-1, i) % mod
ans %= mod
print(ans)
| 0 | null | 35,930,043,342,274 | 90 | 215 |
from sys import stdin, setrecursionlimit
input = stdin.buffer.readline
N = int(input())
A = list(map(int, input().split()))
max_A = max(A)
if max_A == 1:
print("pairwise coprime")
exit()
class Prime:
def __init__(self, n):
self.prime_factor = [i for i in range(n + 1)]
self.prime = []
for i in range(2, n + 1):
if self.prime_factor[i] == i:
for j in range(2, n // i + 1):
self.prime_factor[i * j] = i
self.prime.append(i)
#print(self.prime_factor)
#print(self.prime)
def factorize(self, m):
ret = []
while m != 1:
if not ret:
ret = [[self.prime_factor[m], 1]]
elif self.prime_factor[m] == ret[-1][0]:
ret[-1][1] += 1
else:
ret.append([self.prime_factor[m], 1])
m //= self.prime_factor[m]
return ret
def divisors(self, m):
ret = []
for i in range(1, int(m ** 0.5) + 1):
if m % i == 0:
ret.append(i)
if i != m // i:
ret.append(m // i)
#self.divisors.sort()
return ret
pm = Prime(max_A)
def is_pairwise_coprime(arr):
cnt = [0] * (max_A + 1)
for a in arr:
for b, c in pm.factorize(a):
cnt[b] += 1
if max(cnt[2:]) <= 1:
return 1
else:
return 0
def gcd(a, b):
while b:
a, b = b, a % b
return a
def is_setwise_coprime(A):
gcd_a = 0
for a in A:
gcd_a = gcd(gcd_a, a)
if gcd_a == 1:
return 1
else:
return 0
if is_pairwise_coprime(A):
print("pairwise coprime")
elif is_setwise_coprime(A):
print("setwise coprime")
else:
print("not coprime") | mod=998244353
N,M,K=map(int,input().split())
MAX_N=N+1
Fact=[0 for i in range(MAX_N+1)]
Finv=[0 for i in range(MAX_N+1)]
Fact[0]=1
for i in range(MAX_N):
Fact[i+1]=(i+1)*Fact[i]
Fact[i+1]%=mod
Finv[-1]=pow(Fact[-1],mod-2,mod)
for i in range(MAX_N-1,-1,-1):
Finv[i]=(i+1)*Finv[i+1]
Finv[i]%=mod
def C(n,k):
return (Fact[n]*Finv[k]*Finv[n-k])%mod
'''
i in range(K+1)で総和を取る
隣り合うブロックの色が同じ色なのはi通り
隣り合うブロックの色が異なるのはN-1-i通り
｜の選び方はN-1Ci
同じものをつなげてN-i個のブロックと見なせる
これに対してM*((M-1)のN-1-i)乗だけある
0<=i<=K
よりN-1-i>=N-1-K>=0
問題なし
'''
ans=0
for i in range(K+1):
ans+=(C(N-1,i)*M*pow(M-1,N-1-i,mod))%mod
ans%=mod
print(ans) | 0 | null | 13,557,169,014,260 | 85 | 151 |
n, k = map(int, input().split())
mod = 10**9+7
R = 200010
f = [1]*R
p = 1
for i in range(1, R):
p = f[i] = p*i%mod
finv = [1]*R
p = finv[-1] = pow(f[-1], mod-2, mod)
for i in range(R-2, 0, -1):
p = finv[i] = p*(i+1)%mod
def comb(n, k):
return f[n]*finv[n-k]*finv[k]%mod
ans = 0
for m in range(min(k, n-1)+1):
x = comb(n, m)
y = comb(n-1, m)
ans += x*y%mod
print(ans%mod) | """ Atcorder practice 20200719 """
# test programm for practice
def __main__():
""" def for calc """
num_input = int(input())
if num_input < 1 or num_input > 10:
raise ValueError
#elif num_input % 1 != 0:
#raise ValueError
else:
print(num_input + num_input**2 + num_input**3)
if __name__ == "__main__":
__main__()
| 0 | null | 38,661,651,056,510 | 215 | 115 |
class Unionfind(): # 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 group_cnt(self): # グループの数
return sum(x < 0 for x in self.parents)
n, m = map(int, input().split())
ab = [list(map(int, input().split())) for _ in range(m)]
uf = Unionfind(n)
for a, b in ab:
uf.union(a - 1, b - 1)
print(uf.group_cnt() - 1)
| class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1]*n
for i in range(n):
self.parents[i] = i
# 要素xが所属するグループの根を返す
def root(self, x) -> int:
if self.parents[x] == x:
return x
else:
self.parents[x] = self.root(self.parents[x])
return self.parents[x]
def unite(self, x, y):
x = self.root(x)
y = self.root(y)
if x == y:
return
elif x > y:
u.parents[x] = y
elif x < y:
u.parents[y] = x
def same(self, x, y) -> bool:
return self.root(x) == self.root(y)
n, m = map(int, input().split())
cnt = n
u = UnionFind(n)
for i in range(m):
a, b = map(int, input().split())
if u.same(a-1, b-1):
continue
else:
u.unite(a-1, b-1)
cnt -= 1
if cnt > 0:
print(cnt-1)
else:
print(cnt)
| 1 | 2,305,354,019,580 | null | 70 | 70 |
# シェルソート
# http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=ALDS1_2_D&lang=jp
# 挿入ソートを応用してn個の整数を含む数列Aを昇順に整列するプログラム
def show(array):
for i in range(len(array)):
if (i+1) >= len(array):
print(array[i])
else:
print(array[i], end=' ')
def insertion_sort(c, g):
n = len(c)
count = 0
for i in range(g, n):
v = c[i]
j = i - g
while j >= 0 and c[j] > v:
c[j+g] = c[j]
j = j - g
count += 1
c[j+g] = v
return c, count
def shell_sort(c, G):
counts = 0
for g in G:
co, count = insertion_sort(c, g)
counts += count
return co, counts
def main():
n = int(input())
c = [int(input()) for _ in range(n)]
# For making G
n = len(c)
g = []
for m in range(1, 100):
t = (3 ** m - 1) // 2
if t > n:
break
g.append(t)
g = g[::-1]
result, count = shell_sort(c, g)
print(m-1)
show(g)
print(count)
for num in result:
print(num)
main()
| def insertion_sort(a, n, g, cnt):
for i in range(g,n,1):
v = a[i]
j = i - g #initial value
while j>=0 and a[j]>v:
a[j+g]=a[j]
j -= g
cnt += 1
a[j+g] = v
return a, cnt
def shell_sort(a,n,m,g):
cnt = 0
for i in range(m):
sorted_list, cnt = insertion_sort(a,n,g[i],cnt)
return sorted_list, cnt
def seqforshell(n):
seq = [1]
next_num = 3*seq[0] + 1
while next_num<n:
seq.insert(0, next_num)
next_num = 3*next_num + 1
return seq
if __name__ == "__main__":
a = []
n = int(input())
for i in range(n):
a.append(int(input()))
g = seqforshell(n)
m = len(g)
res, cnt = shell_sort(a,n,m,g)
print(m)
print(*g)
print(cnt)
for i in range(n):
print(res[i])
| 1 | 30,380,788,350 | null | 17 | 17 |
raw_input()
num_list = map(int, raw_input().split(" "))
print "%d %d %d" % (min(num_list), max(num_list), sum(num_list)) | n, xs = int(input()), map(int,raw_input().split())
print min(xs), max(xs), sum(xs) | 1 | 719,930,929,688 | null | 48 | 48 |
n = int(input())
s = list(input())
c = 0
for i in range(1000) :
num_1 = i // 100
num_2 = (i - num_1*100) // 10
num_3 = (i - num_1*100 - num_2*10) % 100
if str(num_1) not in s :
continue
if str(num_2) not in s :
continue
if str(num_3) not in s :
continue
for j in range(n-2) :
if int(s[j]) == num_1 :
for k in range(j+1,n-1) :
if int(s[k]) == num_2 :
for l in range(k+1,n) :
if int(s[l]) == num_3 :
c += 1
break
break
break
print(c)
| # 解説AC
# 解説放送と
# https://twitter.com/kyopro_friends/status/1274710268262547456?s=20
# で理解
MOD = 10**9 + 7
def main():
K = int(input())
S = input()
N = len(S)
m = N+K + 5
fac = [0] * m
finv = [0] * m
inv = [0] * m
def COMBinitialize(m):
fac[0] = 1
finv[0] = 1
if m > 1:
fac[1] = 1
finv[1] = 1
inv[1] = 1
for i in range(2, m):
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 COMB(n, k):
if n < k:
return 0
if n < 0 or k < 0:
return 0
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD
COMBinitialize(m)
ans = 0
for i in range(K+1):
v = COMB(N-1+K-i, N-1)
v %= MOD
v *= pow(25, (K-i), MOD)
v %= MOD
v *= pow(26, i, MOD)
v %= MOD
ans += v
ans %= MOD
print(ans)
if __name__ == '__main__':
main()
| 0 | null | 70,743,961,877,732 | 267 | 124 |
import sys
def solve(a, b):
for i in range(1, 10000):
if int(i * 0.08) == a and int(i * 0.1) == b:
return i
return -1
def main():
input = sys.stdin.buffer.readline
a, b = map(int, input().split())
print(solve(a, b))
if __name__ == "__main__":
main()
| import sys
input = sys.stdin.readline
#l = list(map(int, input().split()))
#import numpy as np
#arr = np.array([int(i) for i in input().split()])
'''
a,b=[],[]
for i in range(n):
A, B = map(int, input().split())
a.append(A)
b.append(B)'''
n=int(input())
a,x=[],[]
for i in range(n):
A = int(input())
a.append(A)
B=[]
for j in range(A):
B.append(list(map(int, input().split())))
x.append(B)
ma=0
for i in range(2**n):
now=0
flg=True
e=[0]*n
for j in range(n):
if (i>>j)&1:
now+=1
e[j]=1
for j in range(n):
#print(e)
if (i>>j)&1:
if e[j]==0:
flg=False
break
elif not flg:
break
for k in range(a[j]):
"""if e[x[j][k][0]-1]==-1:
if x[j][k][1] and
e[x[j][k][0]-1]=x[j][k][1]"""
if (e[x[j][k][0]-1]==0 and x[j][k][1]==1) or (e[x[j][k][0]-1]==1 and x[j][k][1]==0):
flg=False
break
if flg and ma<now:
ma=now
#print(ma)
print(ma)
| 0 | null | 88,976,646,398,562 | 203 | 262 |
A ,V= map(int, input().split())
B ,W= map(int, input().split())
T = int(input())
if V <= W:
print("NO")
elif abs(A - B) / (V - W) <= T:
print("YES")
else:
print("NO") | a = input().split()
b = input().split()
t = input()
dist = abs(int(a[0])-int(b[0]))
len = int(int(a[1]) - int(b[1]))*int(t)
if (dist > len):
print("NO")
else:
print("YES") | 1 | 15,206,028,770,670 | null | 131 | 131 |
N = int(input())
A_li = list(map(int, input().split()))
is_rising = False
money = 1000
stock = 0
for i in range(N - 1):
if i == 0:
if A_li[0] < A_li[1]:
# できるだけ買う
stock = money // A_li[0]
money -= A_li[0] * stock
is_rising = True
else:
if is_rising:
if A_li[i] > A_li[i + 1]:
# 全て売る
money += A_li[i] * stock
stock = 0
is_rising = False
else:
if A_li[i] < A_li[i + 1]:
# できるだけ買う
stock = money // A_li[i]
money -= A_li[i] * stock
is_rising = True
if i + 1 == N - 1:
# 全て売って終了
money += A_li[i+1] * stock
stock = 0
print(money)
| if __name__ == "__main__":
a=input()
a=int(a)
ans=a+a*a+a*a*a
print(ans) | 0 | null | 8,747,932,321,182 | 103 | 115 |
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, tan, asin, acos, atan, radians, degrees, log2, gcd
from itertools import accumulate, permutations, combinations, combinations_with_replacement, product, groupby
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left, insort, insort_left
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(str, input().split()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7
#import numpy as np
from decimal import *
K = INT()
if K <= 9:
print(K)
exit()
n = [-1]*11
n[-1] = 9
cnt = 9
def DFS(n):
global cnt
for i in range(1, 11):
if n[-i] == 9:
continue
elif n[-i-1] != -1 and n[-i] == n[-i-1]+1:
continue
else:
if n[-i] == -1:
n[-i] = 1
else:
n[-i] += 1
for j in range(i-1, 0, -1):
n[-j] = max(0, n[-j-1] - 1)
break
cnt += 1
if cnt == K:
print(*n[bisect(n, -1):], sep = "")
exit()
DFS(n)
DFS(n)
| k=int(input())
if k<=9:
print(k)
exit(0)
ans=[1,2,3,4,5,6,7,8,9]
i=0
while len(ans)<k:
v=ans[i]
mod=v%10
if mod==0:
ans.append(10*v+mod)
ans.append(10*v+mod+1)
elif mod==9:
ans.append(10*v+mod-1)
ans.append(10*v+mod)
else:
ans.append(10*v+mod-1)
ans.append(10*v+mod)
ans.append(10*v+mod+1)
i+=1
print(ans[k-1])
| 1 | 39,811,707,276,070 | null | 181 | 181 |
def nextPrime(x):
for i in range(x, x*2):
a = 0
for w in range(2, i+1):
if i%w ==0:
break
else:
a = w
if i == a + 1:
return i if x != 2 else 2
def main():
x = int(input())
print(nextPrime(x))
if __name__ == '__main__':
main() | a=[int(input()) for i in range(10)]
a.sort()
a.reverse()
print(a[0])
print(a[1])
print(a[2]) | 0 | null | 52,873,721,881,380 | 250 | 2 |
import sys
from collections import deque
n,m=map(int,input().split())
s=input()
if n<=m:
print(n)
sys.exit()
lst=[0]*(n+1)
for i in range(1,m+1):
if s[i]=="0":
lst[i]=i
left=1
right=m+1
k=0
while left<n:
if s[left]=="0":
while right-left<=m:
if s[right]=="0":
lst[right]=right-left
right+=1
if right==n+1:
k=n
break
left+=1
if left==right or k==n:
break
if lst[n]==0:
print(-1)
else:
ans=deque([])
while k>0:
c=lst[k]
ans.appendleft(c)
k-=c
print(*ans) | from math import gcd
def main():
a, b = map(int, input().split())
ans = a * b // gcd(a, b)
print(ans)
if __name__ == "__main__":
main()
| 0 | null | 125,904,187,803,940 | 274 | 256 |
import math as mt
a,b,h,m=map(int, input().split())
print(mt.sqrt(a**2+b**2-2*a*b*mt.cos(2*mt.pi*(1/12*(h+m/60)-m/60))))
| import math
def abs(num):
if num < 0:
return -num
return num
def main():
abhm = [int(_x) for _x in input().split()]
HL = abhm[0]
ML = abhm[1]
H = abhm[2]
M = abhm[3]
radian = 2.0 * math.pi * abs(M / 60.0 - (H + M / 60.0) / 12.0)
length = math.sqrt(HL * HL + ML * ML - 2 * HL * ML * math.cos(radian))
print(length)
main()
| 1 | 20,176,425,681,270 | null | 144 | 144 |
print(int(input())*6.28) | def i():
return int(input())
def i2():
return map(int,input().split())
def s():
return str(input())
def l():
return list(input())
def intl():
return list(int(k) for k in input().split())
n = i()
a = intl()
for i in range(n):
if a[i]%2 == 0:
if a[i]%3 != 0 and a[i]%5 !=0:
print("DENIED")
exit()
print("APPROVED") | 0 | null | 50,058,273,987,012 | 167 | 217 |
X=int(input())
i=1
a=0
while True:
a=a+X
if a%360==0:
print(i)
break
i+=1 | import math
x = int(input())
y = 360
lcm = x * y // math.gcd(x, y)
print(lcm//x)
| 1 | 13,200,591,237,692 | null | 125 | 125 |
n = int(input())
a = n // 2
b = n % 2
print(a+b)
| N=int(input())
if N&0b1:
ans=N//2+1
else:
ans=N//2
print(ans) | 1 | 59,239,815,083,682 | null | 206 | 206 |
A, V = map(int, input().split())
B, W = map(int, input().split())
T = int(input())
if W>=V:
print('NO')
exit()
if abs(A-B)/(V-W) > T:
print('NO')
exit()
print('YES') | A, V = map(int, input().split())
B, W = map(int, input().split())
T = int(input())
set_position = abs(B-A)
move = V-W
if move*T >= set_position:
print("YES")
else:
print("NO") | 1 | 15,113,679,428,510 | null | 131 | 131 |
H, W = map(int, input().split())
stage = []
scores = []
for _ in range(H):
stage.append(list(input()))
scores.append([float('inf')] * W)
if stage[0][0] == '#':
scores[0][0] = 1
else:
scores[0][0] = 0
move = [[0, 1], [1, 0]]
for y in range(H):
for x in range(W):
for dx, dy in move:
nx, ny = x + dx, y + dy
if H <= ny or W <= nx:
continue
if stage[ny][nx] == '#' and stage[y][x] == '.':
scores[ny][nx] = min(scores[ny][nx], scores[y][x] + 1)
else:
scores[ny][nx] = min(scores[ny][nx], scores[y][x])
# print(*scores, sep='\n')
print(scores[-1][-1]) | import math
n, k = map(int, input().split())
w = [int(input()) for i in range(n)]
def check(P): # 最駄積載量Pのk台のトラックで何個目の荷物まで積めるか。積める荷物の数をreturn
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
# 今、条件より1<=w<=10,000であり、1<=n<=100000
# つまり、トラックの最大積載量の取りうる最大値はこれらが一つのトラックに乗る時、つまり100000*10000
# 従ってこの範囲でPを探索すればよい
# 二分探索を使うことができる（これらのmidをPと仮定してcheckで積める個数を調べる
#→これがnよりも大きければPはもっと小さくて良いと言うことなのでrightをmidに、小さければleftをmidに！
def solve():
left = 0
right = 100000*10000
while (right - left) > 1:
mid = (left + right) / 2
v = check(mid)
if (v >= n): # ?
right = mid
else:
left = mid
return right
ans = math.floor(solve())
print(ans)
| 0 | null | 24,732,552,612,020 | 194 | 24 |
import sys
sys.setrecursionlimit(10**6) #再帰関数の上限
import math
from copy import copy, deepcopy
from operator import itemgetter
from bisect import bisect_left, bisect, bisect_right#2分探索
#bisect_left(l,x), bisect(l,x)#aはソート済みである必要あり。aの中からx未満の要素数を返す。rightだと以下
from collections import deque
#deque(l), pop(), append(x), popleft(), appendleft(x)
##listでqueの代用をするとO(N)の計算量がかかってしまうので注意
from collections import Counter#文字列を個数カウント辞書に、
#S=Counter(l),S.most_common(x),S.keys(),S.values(),S.items()
from itertools import accumulate#累積和
#list(accumulate(l))
from heapq import heapify,heappop,heappush
#heapify(q),heappush(q,a),heappop(q) #q=heapify(q)としないこと、返り値はNone
#import fractions#古いatcoderコンテストの場合GCDなどはここからimportする
def input(): return sys.stdin.readline()[:-1]
def printl(li): print(*li, sep="\n")
def argsort(s, return_sorted=False):
inds=sorted(range(len(s)), key=lambda k: s[k])
if return_sorted: return inds, [s[i] for i in inds]
return inds
def alp2num(c,cap=False): return ord(c)-97 if not cap else ord(c)-65
def num2alp(i,cap=False): return chr(i+97) if not cap else chr(i+65)
def matmat(A,B):
K,N,M=len(B),len(A),len(B[0])
return [[sum([(A[i][k]*B[k][j]) for k in range(K)]) for j in range(M)] for i in range(N)]
def matvec(M,v):
N=len(v)
size=len(M)
return [sum([M[i][j]*v[j] for j in range(N)]) for i in range(size)]
def main():
mod = 10**9+7
#w.sort(key=itemgetter(1),reversed=True) #二個目の要素で降順並び替え
N = int(input())
#N, K = map(int, input().split())
#A = tuple(map(int, input().split())) #1行ベクトル
#L = tuple(int(input()) for i in range(N)) #改行ベクトル
s = tuple(tuple(map(int, input().split())) for i in range(N)) #改行行列
l=[(s[i][0]+s[i][1],s[i][0]-s[i][1]) for i in range(N)]
l.sort()
cur=l[0][0]
ans=1
for rob in l[1:]:
if cur>rob[1]:
continue
ans+=1
cur=rob[0]
print(ans)
if __name__ == "__main__":
main() | n = int(input())
l = [[] for _ in range(n)]
d = [[] for _ in range(n)]
for i in range(n):
l[i] = list(map(int,input().split()))
d[i] = [l[i][0]-l[i][1],l[i][0]+l[i][1]]
d.sort(key=lambda x:x[1])
ma = -9999999
c = 0
for i in range(n):
if(d[i][0] >= ma):
ma = d[i][1]
c += 1
print(c) | 1 | 89,890,926,448,338 | null | 237 | 237 |
r = int(input())
n = (r*r) / 3.14
print(int(n / (1/3.14))) | def calc_r(r):
return r*r
r = int(input())
result = calc_r(r)
print(result)
| 1 | 145,540,823,433,252 | null | 278 | 278 |
while True:
n=input()
if n=="-":
break
for i in range(int(input())):
h=int(input())
n=n[h:]+n[:h]
print(n)
| if __name__ == "__main__":
num_list =map( int, raw_input().split())
print num_list[0] * num_list[1],
print 2 * ( num_list[0] + num_list[1] ) | 0 | null | 1,113,058,567,488 | 66 | 36 |
K = int(input())
s = len(input())
mod = 10 ** 9 + 7
N = 2 * 10**6
fac = [1, 1]
finv = [1, 1]
inv = [0, 1]
for i in range(2, N + 1):
fac.append( ( fac[-1] * i ) % mod )
inv.append( mod - ( inv[mod % i] * (mod // i) % mod ) )
finv.append( finv[-1] * inv[-1] % mod )
def cmb(n, r):
return fac[n] * ( finv[r] * finv[n-r] % mod ) % mod
p25 = [1]
p26 = [1]
for i in range(K):
p25.append(p25[i]*25%mod)
p26.append(p26[i]*26%mod)
ans = 0
for i in range(K+1):
ans += ( cmb(s+K-i-1, s-1) * p25[K-i] % mod ) * p26[i] % mod
ans %= mod
print(ans) | import sys
import itertools
# import numpy as np
import time
import math
from heapq import heappop, heappush
from collections import defaultdict
from collections import Counter
from collections import deque
from itertools import permutations
sys.setrecursionlimit(10 ** 7)
INF = 10 ** 18
MOD = 10 ** 9 + 7
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
# map(int, input().split())
N = int(input())
S = list(input())
Q = int(input())
q_list = [list(input().split()) for _ in range(Q)]
bit_tree = [[0] * (N+1) for _ in range(26)]
def BIT_add(i, tree):
while i <= N:
tree[i] += 1
i += i&(-i)
def BIT_sub(i, tree):
while i <= N:
tree[i] -= 1
i += i&(-i)
def BIT_sum(i, tree):
s = 0
while i:
s += tree[i]
i -= i&(-i)
return s
for i in range(N):
x = ord(S[i]) - ord('a')
BIT_add(i + 1, bit_tree[x])
for q in range(Q):
line = q_list[q]
if line[0] == '1':
i, c = line[1:]
i = int(i) - 1
old_c = ord(S[i]) - ord('a')
new_c = ord(c) - ord('a')
BIT_sub(i + 1, bit_tree[old_c])
BIT_add(i + 1, bit_tree[new_c])
S[i] = c
else:
l, r = map(int, line[1:])
now = 0
for i in range(26):
cnt = BIT_sum(r, bit_tree[i]) - BIT_sum(l - 1, bit_tree[i])
if cnt > 0:
now += 1
print(now) | 0 | null | 37,675,959,020,928 | 124 | 210 |
x=input().split()
y=list(map(int,x))
a=y[0]
b=y[1]
c=y[2]
if a < b and b < c:
print('Yes')
else:
print('No') | s = input().rstrip().split(' ')
a = int(s[0])
b = int(s[1])
c = int(s[2])
if a < b and b < c:
print("Yes")
else:
print("No") | 1 | 382,927,401,080 | null | 39 | 39 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.