code1
stringlengths 16
427k
| code2
stringlengths 16
427k
| similar
int64 0
1
| pair_id
int64 2
178,025B
⌀ | question_pair_id
float64 27.1M
177,113B
⌀ | code1_group
int64 1
297
| code2_group
int64 1
297
|
|---|---|---|---|---|---|---|
n = int(input())
a = list(map(int, input().split()))
a = a[::-1]
for cnt, item in enumerate(a, 1):
if cnt == n:
print(item)
else:
print(item,end=' ')
|
import sys
sys.setrecursionlimit(10**6)
h, w, m = map(int, input().split())
# 各行各列に何個ずつあるか
hs = [0] * h
ws = [0] * w
# 座標を記録
s = set()
readline = sys.stdin.readline
for _ in range(m):
r, c = [int(i) for i in readline().split()]
r -= 1
c -= 1
hs[r] += 1
ws[c] += 1
s.add((r, c))
# 最大値
mh = 0
mw = 0
for i in range(h):
mh = max(mh, hs[i])
for j in range(w):
mw = max(mw, ws[j])
# 最大値をとっている行・列
si = []
sj = []
for i in range(h):
if mh == hs[i]:
si.append(i)
for j in range(w):
if mw == ws[j]:
sj.append(j)
# 爆破対象がないマスに爆弾を設置できれば尚良し。そこでmh+mwをansに仮に記録して、１個でも見つかればその座標を出力。見つからなければ、爆破対象があるマスに爆弾を設置するのが最大となるので、ans=mh+mw-1となる
ans = mh + mw
for i in si:
for j in sj:
if (i, j) in s:
continue
print(ans)
exit()
print(ans-1)
| 0 | null | 2,872,926,272,580 | 53 | 89 |
#!/usr/bin/env python3
from pprint import pprint
from collections import deque, defaultdict
import itertools
import math
import sys
sys.setrecursionlimit(10 ** 6)
input = sys.stdin.buffer.readline
INF = float('inf')
n_nodes = int(input())
graph = [[] for _ in range(n_nodes)]
for _ in range(n_nodes):
line = list(map(int, input().split()))
u, k = line[0], line[1]
if k > 0:
for v in line[2:]:
graph[u - 1].append(v - 1)
# pprint(graph)
def dfs(v):
global time
time += 1
for v_adj in graph[v]:
if d[v_adj] == -1:
d[v_adj] = time
dfs(v_adj)
f[v] = time
time += 1
d = [-1] * n_nodes
f = [-1] * n_nodes
time = 1
for v in range(n_nodes):
if d[v] == -1:
d[v] = time
dfs(v)
# pprint(d)
# pprint(f)
for v in range(n_nodes):
print(f"{v + 1} {d[v]} {f[v]}")
|
n = int(input())
s = list(input())
t = []
ans = 0
for i in range(1000):
t.append(str(i//100))
t.append(str(i//10%10))
t.append(str(i%10))
k = 0
p = 0
for j in range(3):
if t[j] in s[k:]:
p = s[k:].index(t[j]) + 1
k += p
else:
p = -1
break
if p != -1:
ans += 1
t.clear()
print(ans)
| 0 | null | 64,212,727,475,318 | 8 | 267 |
import sys
import math
input = sys.stdin.readline
def main():
k = int(input())
ans = 0
for a in range( 1 , k+1 ):
for b in range( a , k+1 ):
x = math.gcd( a , b )
for c in range( b , k+1 ):
y = math.gcd( x , c )
if a == b == c:
ans += y
elif a==b or b==c or c==a:
ans += 3 * y
else:
ans += 6 * y
print(ans)
main()
|
n=int(input())
x=list(map(float,input().split()))
y=list(map(float,input().split()))
d1=0
d2=0
d3=0
for i in range(n):
d1+=abs(x[i]-y[i])
d2+=(x[i]-y[i])**2
d3+=abs(x[i]-y[i])**3
from math import pow
d2=pow(d2,(1.0/2.0))
d3=pow(d3,(1.0/3.0))
di=max([abs(x[i]-y[i]) for i in range(n)])
print(d1)
print(d2)
print(d3)
print(di)
| 0 | null | 17,838,089,584,028 | 174 | 32 |
# -*- coding: utf-8 -*-
"""
Created on Thu Sep 3 23:43:13 2020
@author: liang
"""
N ,M ,Q = map(int, input().split())
A = list()
lis = list()
ans = 0
def make_list(n,m):
if n == N:
A.append(lis.copy())
return
for i in range(m,M+1):
lis.append(i)
make_list(n+1,i)
lis.pop()
make_list(0,1)
#print(A)
calc = [list(map(int,input().split())) for _ in range(Q)]
for a in A:
tmp = 0
for c in calc:
if a[c[1]-1] - a[c[0]-1] == c[2]:
tmp += c[3]
if tmp > ans:
ans = tmp
print(ans)
|
n, m, q = map(int,input().split())
a, b, c, d = [0] * q, [0] * q, [0] * q, [0] * q
for i in range(q):
a[i], b[i], c[i], d[i] = map(int,input().split())
def score(l):
res = 0
for i in range(q):
temp = l[b[i] - 1] - l[a[i] - 1]
if temp == c[i]:res += d[i]
return res
def dfs(l):
global ans
if len(l) == n:
ans = max(ans, score(l))
return #中で使われている関数の終了
if l:
temp = l[-1]
else:
temp = 1
for v in range(temp, m + 1):
l.append(v)
dfs(l)
l.pop()
ans = 0
dfs([])
print(ans)
| 1 | 27,648,278,832,000 | null | 160 | 160 |
N=int(input())
S=input()
ans=[]
for i in range(len(S)):
temp=ord(S[i])
if temp+N>90:
ans.append(chr(temp+N-26))
else:
ans.append(chr(temp+N))
print("".join(ans))
|
import sys
# input = sys.stdin.readline
def main():
N = int(input())
d = list(map(int,input().split()))
ans = 0
for i in range(N):
for j in range(N):
if i !=j:
ans += d[i]*d[j]
print(int(ans/2))
if __name__ == "__main__":
main()
| 0 | null | 151,904,803,821,472 | 271 | 292 |
MOD=10**9+7
N=int(input())
dp=[0]*(N+1)
dp[0]=1
for i in range(N+1):
for j in range(i-2):
dp[i]+=dp[j]
dp[i]%=MOD
print(dp[N])
|
L, R, d = map(int, input().split())
print(sum(1 for i in range(L, R + 1) if i % d == 0))
| 0 | null | 5,429,731,396,188 | 79 | 104 |
n = int(input())
str = input()
if (n%2 == 0) and (str[:(n//2)] == str[n//2:]):
print("Yes")
else:
print("No")
|
from itertools import accumulate
h,w,k=map(int,input().split())
s=[[0]*(w+1)]+[[0]+[int(i) for i in input()] for _ in range(h)]
for i in range(h+1):
s[i]=list(accumulate(s[i]))
for j in range(w+1):
for i in range(h):
s[i+1][j]+=s[i][j]
ans=10**18
for i in range(1<<h-1):
a=[]
for j in range(h-1):
if (i>>j)&1:a+=[j+1]
a+=[h]
cnt=len(a)-1
q=1
for j in range(1,w+1):
p=0
flag=0
for l in a:
if s[l][j]-s[l][j-1]-s[p][j]+s[p][j-1]>k:flag=1
elif s[l][j]-s[l][q-1]-s[p][j]+s[p][q-1]>k:
q=j
cnt+=1
break
else:p=l
if flag:break
else:
ans=min(cnt,ans)
print(ans)
| 0 | null | 97,370,144,599,640 | 279 | 193 |
n,a,b=map(int,input().split())
MOD = 1000000007
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
#実際に使うときは、MOD=10000007 などの剰余計算を組み込んで使うこと！
def repeated_square(x,n):
#nを2進数で表して順序反転
bit_n=bin(n)[2:][::-1]
ans=1
ni=x
if(bit_n[0]=="1"):
ans*=ni
for i in range(1,len(bit_n)):
ni=((ni%MOD)*(ni%MOD))%MOD
#i桁目が1なら、x^(2^i)を加える
if(bit_n[i]=="1"):
ans=((ans%MOD)*(ni%MOD))%MOD
return ans
alln=(repeated_square(2, n)-1)%MOD
print((alln-comb(n, a)-comb(n, b))%MOD)
|
k = 2 *10**5
mod = 10**9+7
n, a, b = map(int,input().split())
modinv_table = [-1]*(k+1)
for i in range(1,k+1):
modinv_table[i] = pow(i,-1,mod)
def binomial_coefficients(n,k):
ans = 1
for i in range(k):
ans *= n-i
ans *= modinv_table[i+1]
ans %= mod
return ans
print((pow(2,n,mod)-binomial_coefficients(n,a)-binomial_coefficients(n,b)-1)%mod)
| 1 | 66,034,980,467,498 | null | 214 | 214 |
n,k=map(int,input().split())
mod=10**9+7
ans=0
A=[0]*k
for i in range(k,0,-1):
a=0
A[i-1]=pow((k//i),n,mod)
m=i*2
while m<=k:
A[i-1]=(A[i-1]-A[m-1])%mod
m=m+i
ans=(ans+i*A[i-1])%mod
print(ans%mod)
|
import math
def pow(p,n):
bin_n=bin(n)[2:][::-1]
tmp=p;pn=1
for i in range(len(bin_n)):
if bin_n[i]=="1": pn=(pn*tmp)%mod
tmp=tmp*tmp%mod
return pn
mod=10**9+7
n,k=map(int,input().split())
ans=[0]*(k+1)
for i in range(k,0,-1):
div=set()
for x in range(1,int(i**0.5)+1):
if i%x==0: div.add(x);div.add(i//x)
ans[i]=pow(k//i,n)-sum([ans[j*i] for j in range(k//i,1,-1)])
ans[i]%=mod
print(sum(ans[i]*i for i in range(k+1))%mod)
| 1 | 36,741,664,078,180 | null | 176 | 176 |
a, b = map(int, input().split())
print('{0} {1} {2:f}'.format(a // b, a % b, a / b))
|
mod = 998244353
n, s = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
while a[-1] > s:
a.pop(-1)
if a == []:
print(0)
exit()
su = sum(a)
if su < s:
print(0)
exit()
if su == s:
print(pow(2, n - len(a), mod))
exit()
dp = [0] * (s + 1)
dp[0] = 1
for i in a:
newdp = [2 * j for j in dp]
for j in range(s - i + 1):
newdp[j+i] += dp[j]
dp = newdp
print(dp[s] * pow(2, n - len(a), mod) % mod)
| 0 | null | 9,158,543,525,500 | 45 | 138 |
N = int(input())
S = input()
l = [S[i:i+3] for i in range(0, len(S)-2)]
print(l.count('ABC'))
|
n,s = [input() for _ in range(2)]
print(s.count("ABC"))
| 1 | 99,400,162,550,052 | null | 245 | 245 |
S = list(str(input()))
T = list(str(input()))
s = 0
t = 0
len_s = len(S)
len_t = len(T)
i = 0
ans = []
while i < len_s-len_t+1:
cnt = 0
#print(S[i:i+len_t])
for ss, tt in zip(S[i:i+len_t], T):
#print(ss,tt)
if ss != tt:
cnt +=1
ans.append(cnt)
i += 1
#print(ans)
print(min(ans))
|
s = input()
t = input()
ans = 1001
if len(s)-len(t)==0:
temp = 0
for j in range(len(t)):
if s[j]!=t[j]:
temp+=1
ans = min(ans, temp)
else:
for i in range(len(s)-len(t)):
temp = 0
for j in range(len(t)):
if s[i+j]!=t[j]:
temp+=1
ans = min(ans, temp)
print(ans)
| 1 | 3,672,498,727,072 | null | 82 | 82 |
n,m = map(int,input().split())
s = list(input())
s.reverse()
for i in range(m):
s.append("1")
p = 0
ans = []
while p < n:
p += m
cnt = m
while s[p] == "1":
p -= 1
cnt -= 1
if cnt == 0:
print(-1)
exit()
ans.append(cnt)
ans.reverse()
print(*ans)
|
n,m=map(int,input().split())
s=input()[::-1]
ans=[]
now=0
while(now<n):
t=1
for i in reversed(range(1,m+1)):
if now+i>n or s[now+i]=='1':
continue
now=now+i
ans.append(i)
t=0
break
if t:
print(-1)
exit()
ans.reverse()
print(*ans,sep=' ')
| 1 | 139,077,366,164,740 | null | 274 | 274 |
K = int(input())
A, B = map(int, input().split())
ans = "NG"
for i in range(A, B + 1):
if i % K == 0:
ans = "OK"
break
print(ans)
|
# -*- coding: utf-8 -*-
def get_input() -> tuple:
"""
標準入力を取得する.
Returns:\n
tuple: 標準入力
"""
a, b, c, d = list(map(int, input().split()))
return a, b, c, d
def main(a: int, b: int, c: int, d: int) -> None:
"""
メイン処理.
Args:\n
a (int): 整数(-10**9 <= a <= b <= 10**9)
b (int): 整数(-10**9 <= a <= b <= 10**9)
c (int): 整数(-10**9 <= c <= d <= 10**9)
d (int): 整数(-10**9 <= c <= d <= 10**9)
"""
# 求解処理
ans = max([a * c, a * d, b * c, b * d])
# 結果出力
print(ans)
if __name__ == "__main__":
# 標準入力を取得
a, b, c, d = get_input()
# メイン処理
main(a, b, c, d)
| 0 | null | 14,788,282,878,148 | 158 | 77 |
N = int(input())//2
S = input()
print('Yes' if S[:N] == S[N:] else 'No')
|
n = int(input())
s = input()
if n % 2 == 1:
print("No")
else:
t = s[:n//2]
if t * 2 == s:
print("Yes")
else:
print("No")
| 1 | 146,883,256,136,120 | null | 279 | 279 |
def srch(u, cnt, Dst, Fst, Lst):
S = [u]
Fst[u] = cnt
while(len(S) > 0):
cnt += 1
u = S.pop()
if Dst[u] is not None and len(Dst[u]) > 0:
while(len(Dst[u])):
u1 = Dst[u].pop()
if Fst[u1] == 0:
S.append(u)
S.append(u1)
Fst[u1] = cnt
break
else:
Lst[u] = cnt
else:
Lst[u] = cnt
return cnt + 1
def main():
num = int(input())
Dst = [None for i in range(num + 1)]
Fst = [0] * (num + 1)
Lst = Fst[:]
for n in range(1, num+1):
a = list(map(int,input().split()))
u = a[0]
if a[1] > 0:
Dst[u] = a[2:]
Dst[u].reverse()
cnt = 1
for i in range(1,num):
if Fst[i] == 0:
cnt = srch(i, cnt, Dst, Fst, Lst)
for n in range(1, num+1):
print("{} {} {}".format(n,Fst[n],Lst[n]))
if __name__ == '__main__':
main()
|
n = int(input())
Adj = [[0]]
for _ in range(n):
Adj.append(list(map(int, input().split()))[2:])
visited = [False]*(n+1)
s = [0]*(n+1)
f = [0]*(n+1)
time = 0
def dfs(i):
global time
time += 1
s[i] = time
visited[i] = True
for j in Adj[i]:
if not visited[j]:
dfs(j)
time += 1
f[i] = time
while not all(visited[1:]):
i = visited[1:].index(False) + 1
dfs(i)
for i in range(1, n+1):
print(i,s[i], f[i])
| 1 | 2,827,422,622 | null | 8 | 8 |
s = raw_input().rstrip().split(" ")
ans=0
for i in range(int(s[0]),int(s[1])+1):
if int(s[2])%i==0:ans+=1
print ans
|
l = []
a,b,c = map(int,input().split())
for i in range(a,b+1):
if c % i == 0:
l.append(i)
ll = len(l)
print(str(ll))
| 1 | 565,703,754,792 | null | 44 | 44 |
N,M,L = map(int,input().split())
A = [list(map(int,input().split()))for i in range(N)]
B = [list(map(int,input().split()))for i in range(M)]
ANS = [[0]*L for i in range(N)]
for x in range(N):
for y in range(L):
for z in range(M):
ANS[x][y]+=B[z][y]*A[x][z]
for row in range(N):
print("%d"%ANS[row][0],end="")
for col in range(1,L):
print(" %d"%(ANS[row][col]),end="")
print()
|
N = input()
K = int(input())
if len(N) < K:
print(0)
exit()
ans = [1, int(N[-1]), 0, 0];
nine = [1, 9, 81, 729]
def combination(N,K):
if N < K:
return 0
elif K == 0:
return 1
elif K == 1:
return N
elif K == 2:
return N*(N-1)//2
else:
return N*(N-1)*(N-2)//6
for k in range(1, len(N)):
if int(N[-k-1]) > 0:
a = [1, 0, 0, 0]
for j in range(1, K+1):
a[j] += nine[j]*combination(k, j)
a[j] += (int(N[-k-1])-1)*combination(k, j-1)*nine[j-1] + ans[j-1]
ans = a
print(ans[K])
| 0 | null | 38,487,298,054,352 | 60 | 224 |
def cycle_getter(N, start):
"""
:param N: 移動回数
:param start: 初期条件
:return front: cycleまでの要素のリスト
cycle: cycle内の要素のリスト
end: cycle後の余った部分の要素のリスト
cnt: cycle回数
"""
p = start
front, cycle, end = [], [], []
cnt = 0
visit = {p:0}
L, R = N, -1
P = [p]
for i in range(1,N):
p = lift(p)
if p in visit:
"""
(L, R) = (サイクルに入るまでに移動した回数, サイクルの終端に着くまでに移動した回数)
[6,2,3,4,0,1,2] ⇒ (L, R) = (1, 6)
"""
L, R = visit[p], i
period = R-L
break
visit[p] = i
P.append(p)
front = P[:L]
if L != N:
cycle, end = P[L:R], P[L:L+(N-L)%period]
cnt = (N-L)//period
return front, cycle, end, cnt
################################################################################
import sys
input = sys.stdin.readline
def lift(x): return pow(x,2,M)
N, X, M = map(int, input().split())
front, cycle, end, cnt = cycle_getter(N,X)
# print(front, cycle, end, cnt)
print(sum(front)+sum(cycle)*cnt+sum(end))
|
x = int(input())
for i in range(-200,201):
for j in range(-200,201):
if i**5 - j**5 == x:
print(i,j)
exit()
| 0 | null | 14,212,618,843,822 | 75 | 156 |
M1,D1 = [ int(i) for i in input().split() ]
M2,D2 = [ int(i) for i in input().split() ]
print("1" if M1 != M2 else "0")
|
import math
r = float(raw_input())
l = 2 * math.pi * r
S = math.pi * r ** 2
print "%f %f" %(S, l)
| 0 | null | 62,664,489,477,668 | 264 | 46 |
x = int(input())
n=1
while 1:
angle_n = 360*n
if angle_n % x == 0:
ans = angle_n // x
break
else:
n += 1
print(ans)
|
def is_much_money(num_of_coin, yen):
if num_of_coin * 500 >= yen:
return "Yes"
else:
return "No"
if __name__ == "__main__":
num_of_coin, yen = input().split()
judgement = is_much_money(int(num_of_coin), int(yen))
print(judgement)
| 0 | null | 55,752,702,315,190 | 125 | 244 |
# coding: utf-8
import sys
#from operator import itemgetter
sysread = sys.stdin.buffer.readline
read = sys.stdin.buffer.read
#from heapq import heappop, heappush
#from collections import defaultdict
sys.setrecursionlimit(10**7)
#import math
#from itertools import product, accumulate, combinations, product
#import bisect
#import numpy as np
#from copy import deepcopy
#from collections import deque
#from decimal import Decimal
#from numba import jit
INF = 1 << 50
EPS = 1e-8
mod = 10 ** 9 + 7
def mapline(t = int):
return map(t, sysread().split())
def mapread(t = int):
return map(t, read().split())
def generate_inv(n,mod):
"""
逆元行列
n >= 2
Note: mod must bwe a prime number
"""
ret = [0, 1]
for i in range(2,n+1):
next = -ret[mod%i] * (mod // i)
next %= mod
ret.append(next)
return ret
def run():
N, *A = mapread()
maxA = max(A)
L = maxA.bit_length()
subs = [0] * L
for k in range(L):
sum = 0
for a in A:
if (a >> k) & 1:
sum += 1 << k
sum %= mod
subs[k] = sum
sumA = 0
for a in A:
sumA += a
sumA %= mod
ret = 0
ret += (sumA * N) % mod
ret += (sumA * N) % mod
sub_sum = 0
for a in A:
sums = 0
for k in range(L):
if (a >> k) & 1:
sums += subs[k] * 2
sums %= mod
sub_sum += sums
sub_sum %= mod
ret -= sub_sum
ret %= mod
inv = generate_inv(2, mod)
ret *= inv[2]
ret %= mod
print(ret)
if __name__ == "__main__":
run()
|
a,b = map(int,input().split())
ans = b if a >= 10 else b + 100 * (10-a)
print(ans)
| 0 | null | 93,080,483,455,944 | 263 | 211 |
n=int(input())
list={}
list1=[]
for i in range(n):
a,b=map(str,input().split())
if a=="insert":
list.setdefault(b,i)
if a=="find":
if b in list:
list1.append("yes")
else:
list1.append("no")
for i in list1:
print(i)
|
r = input()
print (int(r) ** 3)
| 0 | null | 181,962,344,300 | 23 | 35 |
def i_map(): return map(int, input().split())
a, b, c, d = i_map()
ans = max(a * c, a * d, b * c, b * d)
print(ans)
|
A,B,C = map(int,input().split())
if (A==B) and A !=C:
print("Yes")
elif (B==C ) and B !=A:
print("Yes")
elif (C==A ) and C !=B:
print("Yes")
else:
print("No")
| 0 | null | 35,561,826,005,060 | 77 | 216 |
while 1:
n, x = map(int, raw_input().split())
if n == 0 and x == 0:
break
count = 0
for i in xrange(1, n-1):
for j in xrange(i+1, n):
for k in xrange(j+1, n+1):
if i+j+k > x:
break
if i+j+k == x:
count += 1
print count
|
from itertools import product
for i, j in product(range(1,10), repeat=2):
print('%dx%d=%d' % (i, j, i*j))
| 0 | null | 653,974,089,190 | 58 | 1 |
s = "0" + input()
keta = len(s)
dp = [0] * (keta + 1)
kuri = 0
for i in range(keta):
ni = i + 1
num = int(s[-i - 1])
if kuri:
num += 1
kuri = 0
if num == 10:
kuri = 1
dp[ni] = dp[i]
elif num < 5:
dp[ni] = dp[i] + num
elif num > 5:
num %= 10
kuri = 1
dp[ni] = dp[i] + 10 - num
else:
nn = int(s[-ni - 1])
if nn < 5:
dp[ni] = dp[i] + num
else:
kuri = 1
dp[ni] = dp[i] + 10 - num
print(dp[keta] + kuri)
|
#!/usr/bin/env python3
import sys
INF = float("inf")
def solve(N: str):
# 下の桁から貪欲？
N = "0" + N
ans = 0
kuriagari = 0
for i in reversed(range(len(N))):
n = int(N[i])
if kuriagari == 1:
kuriagari = 0
n += 1
if 0 <= n <= 4:
ans += n
elif n == 5:
# print("上の桁を見て決める")
k = i-1
if 0 <= int(N[k]) <= 4:
# print("桁上がらない")
ans += 5
else:
# print("桁上がる")
ans += 5
kuriagari = 1
else:
ans += 10 - n
kuriagari = 1
# print("現状", ans, kuriagari)
print(ans)
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
a = next(tokens)
N = str(a) # type: str
solve(N)
if __name__ == '__main__':
main()
| 1 | 71,206,443,075,670 | null | 219 | 219 |
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()))
prn = lambda x: print(*x, sep='\n')
n_ = 2 * 10**6 + 5
mod = 10**9 + 7
fun = [1] * (n_ + 1)
for i in range(1, n_ + 1):
fun[i] = fun[i - 1] * i % mod
rev = [1] * (n_ + 1)
rev[n_] = pow(fun[n_], mod - 2, mod)
for i in range(n_ - 1, 0, -1):
rev[i] = rev[i + 1] * (i + 1) % mod
def nCr(n, r):
if r > n:
return 0
return fun[n] * rev[r] % mod * rev[n - r] % mod
def modinv(x, mod):
a, b = x, mod
u, v = 1, 0
while b:
t = a // b
a -= t * b; a, b = b, a
u -= t * v; u, v = v, u
return u % mod
inv26 = modinv(26, mod)
def solve():
k = ni()
s = ns()
n = len(s)
ans = 0
v = 1
u = pow(26, k, mod)
for i in range(n, n+k+1):
ans = (ans + nCr(i-1, n-1) * v * u) % mod
u = u * inv26 % mod
v = v * 25 % mod
print(ans)
return
solve()
|
def readinput():
n,k=map(int,input().split())
h=list(map(int,input().split()))
return n,k,h
def main(n,k,h):
if k>=n:
return 0
h.sort(reverse=True)
ans=0
for i in range(k,n):
ans+=h[i]
return ans
if __name__=='__main__':
n,k,h=readinput()
ans=main(n,k,h)
print(ans)
| 0 | null | 45,633,409,270,412 | 124 | 227 |
import sys
from sys import exit
from collections import deque
from copy import deepcopy
from bisect import bisect_left, bisect_right, insort_left, insort_right
from heapq import heapify, heappop, heappush
from itertools import product, permutations, combinations, combinations_with_replacement
from functools import reduce
from math import gcd, sin, cos, tan, asin, acos, atan, degrees, radians
sys.setrecursionlimit(10**6)
INF = 10**20
eps = 1.0e-20
MOD = 10**9+7
def lcm(x,y):
return x*y//gcd(x,y)
def lgcd(l):
return reduce(gcd,l)
def llcm(l):
return reduce(lcm,l)
def powmod(n,i,mod=MOD):
return pow(n,mod-1+i,mod) if i<0 else pow(n,i,mod)
def div2(x):
return x.bit_length()
def div10(x):
return len(str(x))-(x==0)
def intput():
return int(input())
def mint():
return map(int,input().split())
def lint():
return list(map(int,input().split()))
def ilint():
return int(input()), list(map(int,input().split()))
def judge(x, l=['Yes', 'No']):
print(l[0] if x else l[1])
def lprint(l, sep='\n'):
for x in l:
print(x, end=sep)
def ston(c, c0='a'):
return ord(c)-ord(c0)
def ntos(x, c0='a'):
return chr(x+ord(c0))
class counter(dict):
def __init__(self, *args):
super().__init__(args)
def add(self,x,d=1):
self.setdefault(x,0)
self[x] += d
def list(self):
l = []
for k in self:
l.extend([k]*self[k])
return l
class comb():
def __init__(self, n, mod=None):
self.l = [1]
self.n = n
self.mod = mod
def get(self,k):
l,n,mod = self.l, self.n, self.mod
k = n-k if k>n//2 else k
while len(l)<=k:
i = len(l)
l.append(l[i-1]*(n+1-i)//i if mod==None else (l[i-1]*(n+1-i)*powmod(i,-1,mod))%mod)
return l[k]
def pf(x,mode='counter'):
C = counter()
p = 2
while x>1:
k = 0
while x%p==0:
x //= p
k += 1
if k>0:
C.add(p,k)
p = p+2-(p==2) if p*p<x else x
if mode=='counter':
return C
S = set([1])
for k in C:
T = deepcopy(S)
for x in T:
for i in range(1,C[k]+1):
S.add(x*(k**i))
if mode=='set':
return S
if mode=='list':
return sorted(list(S))
class UnionFind():
# インデックスは0-start
# 初期化
def __init__(self, n):
self.n = n
self.parents = [-1]*n
self.group = n
# private function
def root(self, x):
if self.parents[x]<0:
return x
else:
self.parents[x] = self.root(self.parents[x])
return self.parents[x]
# x,yが属するグループの結合
def union(self, x, y):
x = self.root(x)
y = self.root(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
self.group -= 1
# x,yが同グループか判定
def same(self, x, y):
return self.root(x)==self.root(y)
# xと同じグループの要素数を取得
def size(self, x):
return -self.parents[self.root(x)]
######################################################
N,M,K=mint()
T=UnionFind(N)
block=[0]*N
for _ in range(M):
a,b=mint()
T.union(a-1,b-1)
block[a-1]+=1
block[b-1]+=1
for _ in range(K):
c,d=mint()
if T.same(c-1,d-1):
block[c-1]+=1
block[d-1]+=1
ans=[T.size(i)-block[i]-1 for i in range(N)]
lprint(ans,' ')
|
N = int(raw_input())
A = map(int, raw_input().split())
count = 0
for i in range(0, N):
min_j = i
c = 0
for j in range(i, N):
if A[j] < A[min_j]:
min_j = j
c = 1
A[i], A[min_j] = A[min_j], A[i]
count += c
print " ".join(map(str, A))
print count
| 0 | null | 30,856,944,269,128 | 209 | 15 |
N = int(input())
A = list(map(int, input().split()))
SUM = 0;
for X in range(len(A)-1):
if A[X] > A[X+1]:
SUM += A[X]-A[X+1]
A[X+1] = A[X]
print(SUM)
|
N = int(input())
A = list(map(int, input().split()))
ans = 0
for i in range(N-1):
if A[i] > A[i+1]:
diff = A[i] - A[i+1]
ans += diff
A[i+1] += diff
print(ans)
| 1 | 4,579,623,720,918 | null | 88 | 88 |
from itertools import combinations as comb
def get_ans(m, n):
ans = 0
for nums in comb(list(range(1, min(m+1,n-2))), 3):
if sum(nums) == n:
ans += 1
print(ans)
while True:
m, n = (int(x) for x in input().split())
if m==0 and n==0:
quit()
get_ans(m, n)
|
S = int(input())
h = S//3600
m = (S - (h*3600))//60
s = S - (h*3600 + m*60)
print("%d:%d:%d" %(h,m,s))
| 0 | null | 833,139,878,670 | 58 | 37 |
from sys import stdin
nii=lambda:map(int,stdin.readline().split())
lnii=lambda:list(map(int,stdin.readline().split()))
from math import gcd
n=int(input())
a=lnii()
g=a[0]
for i in range(n):
g=gcd(g,a[i])
def factorization(n):
p=2
fcr=set()
while p*p<=n:
while n%p==0:
fcr.add(p)
n//=p
p+=1
if n>1:
fcr.add(n)
return fcr
def eratosthenes(lim):
is_p=[1]*lim
is_p[0]=0
is_p[1]=0
for i in a:
fcr=factorization(i)
for j in fcr:
if is_p[j]:
for k in range(j,lim,j):
is_p[k]=0
else:
if g==1:
print('setwise coprime')
else:
print('not coprime')
exit()
return is_p
lim=10**6+1
is_p=eratosthenes(lim)
print('pairwise coprime')
|
from math import gcd
N = int(input())
num_lis = list(map(int, input().split()))
c1 = True #setwise
c2 = True #pairwise
def osa_k(max_num):
lis = [i for i in range(max_num+1)]
p = 2
while p**2 <= max_num:
if lis[p] == p:
for q in range(2*p, max_num+1, p):
if lis[q] == q:
lis[q] = p
p += 1
return lis
hoge = 0
for i in num_lis:
hoge = gcd(hoge, i)
if hoge > 1:
c1 = False
if c1:
d_lis = osa_k(max(num_lis))
tmp = set()
for i in num_lis:
num = i
new_tmp = set()
while num > 1:
d = d_lis[num]
new_tmp.add(d)
num //= d
for j in new_tmp:
if j in tmp:
c2 = False
break
else:
tmp.add(j)
else:
continue
break
else:
c2 = False
if c2:
print("pairwise coprime")
elif c1:
print("setwise coprime")
else:
print("not coprime")
| 1 | 4,104,760,552,992 | null | 85 | 85 |
import sys
sys.setrecursionlimit(10**9)
def main():
N,K = map(int,input().split())
A = [0] + sorted(list(map(int,input().split())))
MOD = 10**9+7
def get_fact(maxim,mod):
maxim += 1
fact = [0]*maxim
fact[0] = 1
for i in range(1,maxim):
fact[i] = fact[i-1] * i % mod
invfact = [0]*maxim
invfact[maxim-1] = pow(fact[maxim-1],mod-2,mod)
for i in reversed(range(maxim-1)):
invfact[i] = invfact[i+1] * (i+1) % mod
return fact, invfact
def powerful_comb(n,r,mod,fact,invfact):
if n < 0 or n < r: return 0
return fact[n] * invfact[r] * invfact[n-r] % mod
ans = 0
fact,invfact = get_fact(N,MOD)
for i in range(K,N+1):
ans += ((A[i]-A[N-i+1]) * powerful_comb(i-1,K-1,MOD,fact,invfact)) % MOD
print(ans % MOD)
# print(A)
if __name__ == "__main__":
main()
|
N, A, B = [int(a) for a in input().split()]
ans = 0
repseq = N // (A + B)
ans = repseq * A
lastseq = N%(A+B)
if A >= lastseq:
ans += lastseq
else:
ans += A
print(ans)
| 0 | null | 75,686,304,307,642 | 242 | 202 |
from functools import reduce
from fractions import gcd
import math
import bisect
import itertools
import sys
input = sys.stdin.readline
INF = float("inf")
MOD = 1000000007
# 処理内容
def main():
N = int(input())
a = 1
for _ in range(N):
a = a * 10 % MOD
b = 1
for _ in range(N):
b = b * 9 % MOD
c = 1
for _ in range(N):
c = c * 8 % MOD
ans = (a - 2*b + c) % MOD
print(ans)
if __name__ == '__main__':
main()
|
n = int(input())
mod = 10 ** 9 + 7
ans = (pow(10, n, mod) - pow(9, n, mod)) * 2 - (pow(10, n, mod) - pow(8, n, mod))
ans %= mod
print(ans)
| 1 | 3,162,236,225,282 | null | 78 | 78 |
n,m=map(int, input().split())
alist=[list(map(int, input().split())) for i in range(m)]
ans=-1
if n==1:
for i in range(9,-1,-1):
x=True
stri=str(i)
for j in range(m):
if stri[alist[j][0]-1]!=str(alist[j][1]):
x=False
if x:
ans=i
else:
for i in range(10**n-1,10**(n-1)-1,-1):
x=True
stri=str(i)
for j in range(m):
if stri[alist[j][0]-1]!=str(alist[j][1]):
x=False
if x:
ans=i
print(ans)
|
n,m = map(int,input().split())
li = [list(map(int,input().split())) for _ in range(m)]
if n==1 and all([i[1]==0 for i in li]):
print(0)
exit()
for i in range(10**(n-1),10**n):
p = list(map(int,list(str(i))))
for s,c in li:
if p[s-1] != c:break
else:
print(i)
exit()
print(-1)
| 1 | 60,912,462,674,492 | null | 208 | 208 |
import math
a, b, x = map(int,input().split())
v = a*a*b
if x > v/2:
y = 2*(b-(x/(a*a)))
naname = math.sqrt((y*y) + (a*a))
cosine = a/naname
print(math.degrees(math.acos(cosine)))
elif x < v/2:
y = 2*x/(b*a)
naname = math.sqrt((y*y)+(b*b))
cosine = b / naname
print(90-math.degrees(math.acos(cosine)))
else:
naname = math.sqrt((a*a)+(b*b))
cosine = a/naname
print(math.degrees(math.acos(cosine)))
|
N, K = map(int, input().split())
p_list = list(map(int, input().split()))
p_list = sorted(p_list)
print(sum(p_list[:K]))
| 0 | null | 87,613,206,551,420 | 289 | 120 |
n, m = map(int,input().split())
sum = n * (n - 1) / 2 + m * (m - 1) / 2
print(int(sum))
|
ri = lambda S: [int(v) for v in S.split()]
N, M = ri(input())
c = 0
c += (M * (M-1)) / 2
c += (N * (N-1)) / 2
print(int(c))
| 1 | 45,397,824,975,360 | null | 189 | 189 |
X = int(input())
flag = 0
for i in range(-150,150):
for j in range(-150,150):
if(i**5 - j**5 == X):
print(i,j)
flag = 1
break
if(flag==1):
break
|
a=int(input())
b=int(input())
if (a==1 and b==2) or (a==2 and b==1):
print('3')
if (a==1 and b==3) or (a==3 and b==1):
print('2')
if (a==2 and b==3) or (a==3 and b==2):
print('1')
| 0 | null | 68,354,124,217,120 | 156 | 254 |
n,x,m = map(int,input().split())
place = [0] * m
place[x] = 1
cur = [x]
ends = 0
for i in range(m):
x = (x**2) % m
if place[x] == 0:
place[x] = i+2
cur.append(x)
else:
ends = i+2
break
roopsum = sum(cur[place[x]-1:ends-1])
rooplen = ends - place[x]
curlen = cur[place[x]-1:]
mm = min(n,ends-1)
ans = 0
for i in range(mm):
ans += cur[i]
if n-mm == 0:
print(ans)
else:
roopamo = (n-mm) // rooplen
roopama = (n-mm) % rooplen
ans += roopamo * roopsum
for i in range(roopama):
ans += curlen[i]
print(ans)
|
n = input()
if n >= 'A' and n <= 'Z':
print('A')
if n >= 'a' and n <= 'z':
print('a')
| 0 | null | 7,008,680,794,410 | 75 | 119 |
N = int(input())
if N % 1000 != 0:
print(1000 - N % 1000)
elif N % 1000 == 0:
print(0)
|
N = int(input())
n = -(-N//1000)*1000
print(n-N)
| 1 | 8,467,679,918,070 | null | 108 | 108 |
print("Yes" if (lambda x: x[2] == x[3] and x[4] == x[5])(input()) else "No")
|
s = input()
flg = False
if s[2] == s[3] and s[4] == s[5]:
flg = True
print('Yes') if flg else print('No')
| 1 | 42,102,192,024,046 | null | 184 | 184 |
def main():
N,K = map(int, input().split())
R,S,P = map(int, input().split())
T = list(input())
score=0
for i in range(N):
if T[i] == 'r':
score+=P
if i+K<N and T[i+K]=='r':
T[i+K]='x'
if T[i]=='s':
score+=R
if i+K<N and T[i+K]=='s':
T[i+K]='x'
if T[i]=='p':
score+=S
if i+K<N and T[i+K]=='p':
T[i+K]='x'
print(score)
if __name__ == '__main__':
main()
|
n, m, k = map(int, input().split())
class UnionFind():
def __init__(self, n):
self.n = n
self.par = [-1 for i in range(self.n)]
def find(self, x):
if self.par[x] < 0:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
def unite(self, x, y):
p = self.find(x)
q = self.find(y)
if p == q:
return None
if p > q:
p, q = q, p
self.par[p] += self.par[q]
self.par[q] = p
def same(self, x, y):
return self.find(x) == self.find(y)
def size(self, x):
return -self.par[self.find(x)]
UF = UnionFind(n)
f_or_b = [0] * n
for i in range(m):
a, b = map(int, input().split())
UF.unite(a - 1, b - 1)
f_or_b[a - 1] += 1
f_or_b[b - 1] += 1
for i in range(k):
c, d = map(int, input().split())
if UF.same(c - 1, d - 1):
f_or_b[c - 1] += 1
f_or_b[d - 1] += 1
for i in range(n):
print(UF.size(i) - f_or_b[i] - 1, end=" ")
| 0 | null | 83,973,230,795,840 | 251 | 209 |
# coding=utf-8
from math import floor, ceil, sqrt, factorial, log, gcd
from itertools import accumulate, permutations, combinations, product, combinations_with_replacement
from bisect import bisect_left, bisect_right
from collections import Counter, defaultdict, deque
from heapq import heappop, heappush, heappushpop
import copy
import numpy as np
import sys
INF = float('inf')
mod = 10**9+7
sys.setrecursionlimit(10 ** 6)
def lcm(a, b): return a * b / gcd(a, b)
# 1 2 3
# a, b, c = LI()
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
# a = I()
def I(): return int(sys.stdin.buffer.readline())
# abc def
# a, b = LS()
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
# a = S()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
# 2
# 1
# 2
# [1, 2]
def IR(n): return [I() for i in range(n)]
# 2
# 1 2 3
# 4 5 6
# [[1,2,3], [4,5,6]]
def LIR(n): return [LI() for i in range(n)]
# 2
# abc
# def
# [abc, def]
def SR(n): return [S() for i in range(n)]
# 2
# abc def
# ghi jkl
# [[abc,def], [ghi,jkl]]
def LSR(n): return [LS() for i in range(n)]
# 2
# abcd
# efgh
# [[a,b,c,d], [e,f,g,h]]
def SRL(n): return [list(S()) for i in range(n)]
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
fact = [1, 1] # n! mod p
factinv = [1, 1] # (n!)^(-1) mod p
tmp = [0, 1] # factinv 計算用
def main():
x, y = LI()
ans = 0
if x > 2 * y or x < 0.5 * y or (x + y) % 3 != 0:
print(0)
return
n, m = map(int, [(2 * y - x) / 3, (2 * x - y) / 3])
for i in range(2, n + m + 1):
fact.append((fact[-1] * i) % mod)
tmp.append((-tmp[mod % i] * (mod // i)) % mod)
factinv.append((factinv[-1] * tmp[-1]) % mod)
print(cmb(n+m, n, mod))
if __name__ == "__main__":
main()
|
import sys
def input(): return sys.stdin.readline().rstrip()
def main():
mod = 10**9+7
x, y = map(int, input().split())
x2 = max(x, y)
y2 = min(x, y)
m = y2-(x2-y2)
if m < 0 or m % 3 != 0:
print(0)
else:
c = m // 3
n = c*2+(x2-y2)
bunshi = 1
bunbo = 1
for i in range(1, c+1):
bunbo= bunbo*i % mod
bunshi= bunshi*(n-i+1) % mod
ans = bunshi * pow(bunbo,-1,mod)
print(ans%mod)
if __name__ == '__main__':
main()
| 1 | 150,169,829,850,000 | null | 281 | 281 |
# forしながらif、ifでないときはforしないので、計算量減
# 初期入力 ２０２０－０７２７ 21：50
from collections import Counter
import sys
input = sys.stdin.readline #文字列では使わない
N = int(input())
*S, =input().strip()
"""
c =Counter(S)
ans =combinations_count(N, 3) -len(c)
"""
count =0
x100=0
x10=0
x1=0
for i in range(10):
if str(i) not in S:
continue
else:
x100 =S.index(str(i)) +1
for j in range(10):
if str(j) not in S[x100:]:
continue
else:
x10 =S[x100:].index(str(j)) +1
for k in range(10):
if str(k) in S[x100 +x10:]:
x1 =S[x100+x10:].index(str(k)) +1
count +=1
#print("aa",i,j,k,"bb",x100,x100+x10,x100+x10+x1)
print(count)
|
def resolve():
S = list(input())
T = list(input())
cnt = 0
for i in range(len(S)):
if S[i] != T[i]:
cnt += 1
print(cnt)
if '__main__' == __name__:
resolve()
| 0 | null | 69,392,453,881,312 | 267 | 116 |
a,b,c,d,e = map(int,input().split())
z = (c-a)*60 + (d-b)- e
print(z)
|
import math
import fractions
from functools import reduce
n, m = map(int,input().split())
a = list(map(int,input().split()))
a = [t // 2 for t in a]#リストの要素すべてを2で割る
def lcm_base(x, y):
return (x * y)//fractions.gcd(x,y)
def lcm_list(numbers): #最小公倍数を求める
return reduce(lcm_base, numbers, 1)
def num_dev2(x):
return bin(x)[::-1].find("1") #２で割り切れる回数を確認
lcm = lcm_list(a)
q = m//lcm #mは最小公倍数で何回割れるか
count = 0
dev2 = num_dev2(a[0])
for i in range(1,n):
if dev2 != num_dev2(a[i]):#リストのすべての要素の２で割れる回数は等しいか
count += 1
break
if count != 0:
print(0)
else:
print(math.ceil(q/2))
| 0 | null | 60,038,278,207,908 | 139 | 247 |
import sys
readline = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)
def main():
N = int(readline())
odd = 0
for i in range(1, N + 1):
if i % 2 == 1:
odd += 1
print(odd / N)
if __name__ == '__main__':
main()
|
if __name__ == '__main__':
N, M = map(int, input().split())
S = []
C = []
for i in range(M):
s, c = map(int, input().split())
s -= 1
S.append(s)
C.append(c)
for num in range(0, pow(10, N)):
st_num = str(num)
if len(str(st_num))!=N: continue
cnt = 0
for m in range(M):
if int(st_num[S[m]])==C[m]:
cnt += 1
if cnt==M:
print(st_num)
quit()
print(-1)
| 0 | null | 119,119,998,922,742 | 297 | 208 |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import sys
sys.setrecursionlimit(10**7)
from pprint import pprint as pp
from pprint import pformat as pf
# @pysnooper.snoop()
#import pysnooper # debug
import math
#from sortedcontainers import SortedList, SortedDict, SortedSet # no in atcoder
import bisect
class Solver:
def __init__(self, n, a_s):
self.n = n
self.a_s = a_s
self.extra = 1 if self.n % 2 == 0 else 2
self.dp = self.prepare_dp()
def prepare_dp(self):
dp = [None] * (self.n + 1)
for i, _ in enumerate(dp):
dp[i] = [-1 * math.inf] * (1 + self.extra)
dp[0][0] = 0
return dp
def run(self):
extra = 1 + self.n % 2
for i, a in enumerate(self.a_s):
for j in range(self.extra):
self.dp[i + 1][j + 1] = self.dp[i][j]
for j in range(self.extra + 1):
v = self.dp[i][j]
if (i + j) % 2 == 0:
v += a
self.dp[i + 1][j] = max(self.dp[i + 1][j], v)
#print('self.dp') # debug
#print(self.dp) # debug
return self.dp[n][extra]
if __name__ == '__main__':
n = int(input())
a_s = list(map(int, input().split()))
ans = Solver(n, a_s).run()
#print('ans') # debug
print(ans)
#print('\33[32m' + 'end' + '\033[0m') # debug
|
import sys
sys.setrecursionlimit(10 ** 9)
def solve(pick, idx):
if pick == 0: return 0
if idx >= n: return -float('inf')
if (pick, idx) in dp: return dp[pick, idx]
if n-idx+2 < pick*2: return -float('inf')
total = max(A[idx] + solve(pick-1, idx+2), solve(pick, idx+1))
dp[(pick, idx)] = total
return total
n = int(input())
A = list(map(int, input().split()))
dp = {}
pick = n//2
print(solve(pick, 0))
| 1 | 37,481,134,584,480 | null | 177 | 177 |
import math
import sys
import collections
import bisect
readline = sys.stdin.readline
def main():
n, m, k = map(int, readline().rstrip().split())
A = list(map(int, readline().rstrip().split()))
B = list(map(int, readline().rstrip().split()))
a, b = [0], [0]
for i in range(n):
a.append(a[i] + A[i])
for i in range(m):
b.append(b[i] + B[i])
ans = 0
j = m
for i in range(n + 1):
if a[i] > k:
break
while b[j] > k - a[i]:
j -= 1
ans = max(ans, i + j)
print(ans)
if __name__ == '__main__':
main()
|
N, K = list(map(int, input().split()))
H = list(map(int, input().split()))
H.sort()
remain = max(0, N-K)
H = H[:remain]
print(sum(H))
| 0 | null | 44,955,985,366,762 | 117 | 227 |
H,A=map(int,input().split())
count=0
while H >= 1:
H -= A
count += 1
print(count)
|
n, m = map(int, input().split())
ans = [0, 0]
ac = [0 for _ in range(n)]
for _ in range(m):
p, s = input().split()
p = int(p) - 1
if ac[p] == -1:
continue
elif s == "AC":
ans[0] += 1
ans[1] += ac[p]
ac[p] = -1
else:
ac[p] += 1
print(*ans)
| 0 | null | 85,270,440,711,820 | 225 | 240 |
N = int(input())
A = list(map(int,input().split()))
A.sort(reverse=True)
ans = 0
for i in range(N-1):
if i == 0:
ans += A[i]
else:
ans += A[1+(i-1)//2]
print(ans)
|
n, m = map(int, input().split())
h = [int(x) for x in input().split()]
cnt = [1] * n
for _ in range(m):
a, b = map(int, input().split())
if h[a-1] > h[b-1]:
cnt[b-1] = 0
elif h[a-1] < h[b-1]:
cnt[a-1] = 0
else:
cnt[a-1] = 0
cnt[b-1] = 0
print(cnt.count(1))
| 0 | null | 17,144,338,154,382 | 111 | 155 |
N,K=map(int,input().split())
lista=[]
for i in range(K):
d=input()
A=list(map(int,input().split()))
lista.extend(A)
print(N-len(list(set(lista))))
|
import sys, math
from functools import lru_cache
import numpy as np
import heapq
from collections import defaultdict
sys.setrecursionlimit(10**9)
MOD = 10**9+7
def input():
return sys.stdin.readline()[:-1]
def mi():
return map(int, input().split())
def ii():
return int(input())
def i2(n):
tmp = [list(mi()) for i in range(n)]
return [list(i) for i in zip(*tmp)]
def sieve(n):
res = [i for i in range(n)]
i = 2
while i*i < n:
if res[i] < i:
i += 1
continue
j = i*i
while j < n:
if res[j] == j:
res[j] = i
j += i
i += 1
return res
def factor(n, min_factor):
res = set()
while n > 1:
res.add(min_factor[n])
n //= min_factor[n]
return res
def main():
N = ii()
A = np.array(list(mi()))
m = max(A)
s = sieve(m+1)
d = defaultdict(bool)
g = np.gcd.reduce(A)
if g > 1:
print('not coprime')
return
for a in A:
f = factor(a, s)
for v in f:
if d[v]:
print('setwise coprime')
return
d[v] = True
print('pairwise coprime')
if __name__ == '__main__':
main()
| 0 | null | 14,380,838,456,320 | 154 | 85 |
import decimal
def multply(a: str, b: str) -> int:
return int(decimal.Decimal(a) * decimal.Decimal(b))
a, b = input().split()
print(multply(a, b))
|
A,B = input().split()
import decimal as d
d.getcontext().rounding = d.ROUND_DOWN
ans = round(d.Decimal(A)*d.Decimal(B),0)
print(ans)
| 1 | 16,537,550,769,870 | null | 135 | 135 |
from sys import stdin, stdout
n, m = map(int, stdin.readline().strip().split())
if m>=n:
print('unsafe')
else:
print('safe')
|
#!/usr/bin/env python3
import sys
def solve(S: int, W: int):
print("safe" if S > W else "unsafe")
return
# Generated by 1.1.6 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
S = int(next(tokens)) # type: int
W = int(next(tokens)) # type: int
solve(S, W)
if __name__ == '__main__':
main()
| 1 | 29,282,786,614,400 | null | 163 | 163 |
s=input()
t=input()
if len(s)+1==len(t) and s==t[:len(s)]:
print('Yes')
else:print('No')
|
s=list(input())
t=list(input())
t.pop(-1)
if s==t:
print('Yes')
else:
print('No')
| 1 | 21,297,457,654,128 | null | 147 | 147 |
n = int(input())
s = input()
print("".join(chr((ord(c)-ord("A")+n)%26+ord("A")) for c in s))
|
N = int(input())
S = input()
for i in range(len(S)):
print(chr(ord("A") + (ord(S[i]) - ord("A") + N) % 26), end="")
| 1 | 134,739,186,967,840 | null | 271 | 271 |
s = input()
s = s[::-1]
m = [0] * 2019
m[0] = 1
a = 0
d = 1
ans = 0
for si in s:
a = (a + int(si) * d) % 2019
d = (d * 10) % 2019
ans += m[a]
m[a] += 1
print(ans)
|
from collections import Counter
S = input()
S = S[::-1]
N = len(S)
counter = Counter()
counter[0] = 1
prev = 0
MOD = 2019
for i in range(N):
c = (int(S[i]) * pow(10, i, MOD) )%MOD
prev = (prev+c)%MOD
counter[prev] += 1
ans = 0
for k,v in counter.items():
ans += (v * (v-1))//2
print(ans)
| 1 | 30,846,856,007,968 | null | 166 | 166 |
import itertools
N = int(input())
flag = 0
for i, j in itertools.product(range(9), repeat=2):
if (i + 1) * (j + 1) == N:
print('Yes')
flag = 1
break
if flag == 0:
print('No')
|
N = int(input())
l = []
for _ in range(N):
s, t = input().split()
t = int(t)
l.append([s, t])
X = input()
ans = 0
found = False
for s in l:
if found:
ans += s[1]
continue
if s[0] == X:
found = True
print(ans)
| 0 | null | 128,741,123,461,180 | 287 | 243 |
import sys
input = sys.stdin.buffer.readline
import copy
def main():
N,M = map(int,input().split())
a = list(map(int,input().split()))
a.sort()
MOD = 10**9+7
fac = [0 for _ in range(N+1)]
fac[0],fac[1] = 1,1
invfac = copy.deepcopy(fac)
for i in range(2,N+1):
fac[i] = (fac[i-1]*i)%MOD
invfac[-1] = pow(fac[-1],MOD-2,MOD)
for i in range(N,0,-1):
invfac[i-1] = (invfac[i]*i)%MOD
def coef(x,y):
num = (((fac[x]*invfac[y])%MOD)*invfac[x-y]%MOD)
return num
p,m = 0,0
for i in range(N-M+1):
comb = coef(N-i-1,M-1)
p += a[-i-1]*comb
m += a[i]*comb
print((p-m)%MOD)
if __name__ == "__main__":
main()
|
N=int(input())
*X,=sorted(map(int,input().split()))
a=10**9
for p in range(X[0], X[-1]+1):
a=min(a, sum((n-p)**2 for n in X))
print(a)
| 0 | null | 80,258,170,797,828 | 242 | 213 |
import math
y = int(input())
print(360//math.gcd(y,360))
|
from math import gcd
x = int(input())
y = x * 360 // gcd(x, 360)
print(y//x)
| 1 | 13,085,829,709,140 | null | 125 | 125 |
#coding: utf-8
#itp1_9d
def rev(s,a,b):
b=b+1
t=s[a:b]
u=t[::-1]
x=s[:a]
y=s[b:]
return x+u+y
def rep(s,a,b,w):
b=b+1
x=s[:a]
y=s[b:]
return x+w+y
s=raw_input()
n=int(raw_input())
for i in xrange(n):
d=raw_input().split()
a=int(d[1])
b=int(d[2])
if d[0]=="print":
print s[a:b+1]
elif d[0]=="reverse":
s=rev(s,a,b)
elif d[0]=="replace":
w=d[3]
s=rep(s,a,b,w)
|
k,n=map(int,input().split())
a=[int(i) for i in input().split()]
saitanhiku=a[2]-a[1]
for i in range(n-1):
if a[i+1]-a[i]>=saitanhiku:
saitanhiku=a[i+1]-a[i]
if (k-a[n-1])+a[0]>=saitanhiku:
saitanhiku=k-a[n-1]+a[0]
print(k-saitanhiku)
| 0 | null | 22,614,135,784,640 | 68 | 186 |
import sys
readline = sys.stdin.readline
N,X,Y = map(int,readline().split())
X -= 1
Y -= 1
ans = [0] * N
for i in range(N - 1):
for j in range(i + 1, N):
val = min(abs(i - j),abs(i - X) + 1 + abs(j - Y), abs(i - Y) + 1 + abs(j - X))
ans[val] += 1
for i in range(1, len(ans)):
print(ans[i])
|
from collections import Counter
def main():
n,x,y=map(int,input().split())
x,y=x-1,y-1
ans=[]
for i in range(n):
dp = [n]*n
dp[i] = 0
calcstep(i, dp)
dp[y] = min(dp[y], dp[x]+1)
dp[x] = min(dp[x], dp[y]+1)
calcstep(x, dp)
calcstep(y, dp)
#print(i, dp)
ans += dp
ans = Counter(ans)
for i in range(1,n):
print(ans[i]//2)
def calcstep(i, dp):
for j in range(i, len(dp)-1):
if dp[j+1] > dp[j]+1:
dp[j+1] = dp[j]+1
else:
break
for j in range(1,i+1)[::-1]:
if dp[j-1] > dp[j]+1:
dp[j-1] = dp[j]+1
else:
break
if __name__ == "__main__":
main()
| 1 | 44,305,055,252,930 | null | 187 | 187 |
from itertools import combinations
n = int(input())
a = list(map(int, input().split()))
q = int(input())
m = list(map(int, input().split()))
answer = ['no']*q
for i in range(1, n+1):
for nums in combinations(a, i):
val = sum(nums)
if val in m:
index = [i for i, num in enumerate(m) if val == num]
for i in index:
answer[i] = 'yes'
for i in answer:
print(i)
|
def create_sums(ns):
if len(ns) == 0:
return set()
s = create_sums(ns[1:])
return {e + ns[0] for e in s} | s | {ns[0]}
def run_set():
_ = int(input()) # flake8: noqa
ns = [int(i) for i in input().split()]
sums = create_sums(ns)
_ = int(input()) # flake8: noqa
for q in (int(j) for j in input().split()):
if q in sums:
print("yes")
else:
print("no")
if __name__ == '__main__':
run_set()
| 1 | 98,934,789,138 | null | 25 | 25 |
N = int(input())
A = list(map(int, input().split()))
sm=0
mod=10**9+7
s=sum(A)
for i in A:
s-=i
sm+=i*s
sm%=mod
print(sm)
|
n=int(input())
for x in range(55000):
if int(x*1.08)==n:
print(x)
exit()
print(":(")
| 0 | null | 64,440,094,133,592 | 83 | 265 |
# modular inverse for positive a and b and nCk mod MOD depending on modinv
def egcd(a, b):
if a == 0:
return (b, 0, 1)
else:
g, y, x = egcd(b % a, a)
return (g, x - (b // a) * y, y)
def modinv(a, m):
g, x, y = egcd(a, m)
if g != 1:
raise Exception('modular inverse does not exist')
else:
return x % m
MOD = 10 ** 9 + 7
N,K = map(int,input().split())
a = list(map(int,input().split()))
a.sort()
Combination = []
for i in range(N):
if i < K - 1:
Combination.append(0)
elif i == K - 1:
Combination.append(1)
else:
Combination.append(Combination[-1] * i * modinv(i - K + 1, MOD) % MOD)
ans = 0
for i in range(N):
ans += a[i] * Combination[i]
ans -= a[i] * Combination[N - i - 1]
ans %= MOD
print(ans)
|
def main():
print(int(input())**2)
if __name__ == "__main__":
main()
| 0 | null | 120,750,773,344,268 | 242 | 278 |
i = input()
if(i=='ABC'):
print('ARC')
else:
print('ABC')
|
print(("ARC","ABC")[str(input())=="ARC"])
| 1 | 24,084,117,755,914 | null | 153 | 153 |
H=[]
W=[]
while 1:
h,w=map(int,raw_input().split())
if h==w==0:
break
H.append(h)
W.append("#"*w)
for i in xrange(len(W)):
for j in xrange(H[i]):
print(W[i])
print
|
while True:
s = input().split(" ")
H = int(s[0])
W = int(s[1])
if H == 0 and W == 0:
break
for i in range(H):
for j in range(W):
if j == W-1:
print("#")
else:
print("#",end="")
print("")
| 1 | 770,233,466,870 | null | 49 | 49 |
din = map(int, raw_input().split())
print ((din[1])/din[2] - (din[0]-1)/din[2])
|
import sys
input = sys.stdin.readline
# A - Number of Multiples
L, R, d = map(int, input().split())
ans = 0
for i in range(L, R + 1):
if i % d == 0:
ans += 1
print(ans)
| 1 | 7,585,538,155,870 | null | 104 | 104 |
n = int(input())
adj = [None]
for i in range(n):
adji = list(map(int, input().split()[2:]))
adj.append(adji)
isSearched = [None] + [False] * n
distance = [None] + [-1] * n
def BFS(u):
d = 0
isSearched[u] = True
distance[u] = d
edge = [u]
while edge:
q = list(edge)
edge = []
d += 1
for ce in q:
for ne in adj[ce]:
if not isSearched[ne]:
isSearched[ne] = True
edge.append(ne)
distance[ne] = d
BFS(1)
for i, x in enumerate(distance[1:], start=1):
print(i, x)
|
"""Depth First Search."""
n = int(input())
adj = [None]
for i in range(n):
adj_i = list(map(int, input().split()[2:]))
adj.append(adj_i)
# searched or not, number of vertex, discovery time and finishing time.
sndf = [None]
for i in range(1, n + 1):
sndf.append([False, i])
path = []
time = 0
def dfs(u):
global time
path.append(u)
sndf[u][0] = True
time += 1
sndf[u].append(time)
while path:
u = path[-1]
if adj[u]:
v = adj[u].pop(0)
if not sndf[v][0]:
sndf[v][0] = True
time += 1
sndf[v].append(time)
path.append(v)
else:
path.pop()
sndf[u][0] = True
time += 1
sndf[u].append(time)
for i in range(1, n + 1):
if not sndf[i][0]:
dfs(i)
for x in sndf[1:]:
print(*x[1:])
| 0 | null | 3,702,914,560 | 9 | 8 |
n = int(input())
z = input().split()
odd = 0
for i in range(n):
if i % 2 == 0:
if int(z[i]) % 2 == 1:
odd += 1
print(odd)
|
print(sum(map(lambda x:int(x)%2,open(0).read().split()[1::2])))
| 1 | 7,829,613,972,138 | null | 105 | 105 |
a,b = raw_input().strip().split(" ")
a = int(a)
b = int(b)
if a > b:
print "a > b"
elif a < b:
print "a < b"
else:
print "a == b"
|
a = input().split()
if -1000 > int(a[0]):
print('')
elif 1000 < int(a[0]):
print('')
elif -1000 > int(a[1]):
print('')
elif 1000 < int(a[1]):
print('')
elif int(a[0]) < int(a[1]):
print('a < b')
elif int(a[0]) > int(a[1]):
print('a > b')
elif int(a[0]) == int(a[1]):
print('a == b')
| 1 | 357,984,664,030 | null | 38 | 38 |
A11, A12, A13 = map(int, input().split())
A21, A22, A23 = map(int, input().split())
A31, A32, A33 = map(int, input().split())
N = int(input())
B = {int(input()) for _ in range(N)}
h1 = {A11, A12, A13}
h2 = {A21, A22, A23}
h3 = {A31, A32, A33}
v1 = {A11, A21, A31}
v2 = {A12, A22, A32}
v3 = {A13, A23, A33}
c1 = {A11, A22, A33}
c2 = {A13, A22, A31}
if len(h1 & B)==3 or len(h2 & B)==3 or len(h3 & B)==3 or len(v1 & B)==3 or len(v2 & B)==3 or len(v3 & B)==3 or len(c1 & B)==3 or len(c2 & B)==3:
print("Yes")
else:
print("No")
|
N = int(input())
A = list(map(int, input().split()))
if N % 2 == 0:
M = N // 2
even_A = [A[i* 2] for i in range(M)]
odd_A = [A[i* 2 + 1] for i in range(M)]
even_sum = []
_sum = 0
for a in even_A:
_sum += a
even_sum.append(_sum)
odd_sum = []
_sum = 0
for a in odd_A:
_sum += a
odd_sum.append(_sum)
ans = max(odd_sum[-1], even_sum[-1])
for i in range(M):
x = even_sum[i] + odd_sum[-1] - odd_sum[i]
ans = max(ans, x)
print(ans)
exit()
M = N // 2
# evenが元一つ多い
even_A = [A[i* 2] for i in range(M+1)]
odd_A = [A[i* 2 + 1] for i in range(M)]
even_sum = []
_sum = 0
for a in even_A:
_sum += a
even_sum.append(_sum)
odd_sum = []
_sum = 0
for a in odd_A:
_sum += a
odd_sum.append(_sum)
# 全て奇数
all_even = even_sum[-1] - min(even_A)
diff_odd_even = [odd_sum[k] - even_sum[k+1] for k in range(M)]
diff_max_odd_even = []
diff_max = diff_odd_even[-1]
for k in range(M):
diff_max = max(diff_max, diff_odd_even[-k-1])
diff_max_odd_even.append(diff_max)
diff_max_odd_even.reverse()
ans = all_even
for i in range(M):
x = even_sum[i] + odd_sum[-1] - odd_sum[i]
y = odd_sum[i] + even_sum[-1] - even_sum[i+1]
z = even_sum[i] + - odd_sum[i] + even_sum[-1] + diff_max_odd_even[i]
ans = max(ans, x, y, z)
print(ans)
| 0 | null | 48,520,478,445,196 | 207 | 177 |
n = int(input())
a = input().split()
a = [int(i) for i in a]
a.sort()
flg = "YES"
for i in range(n-1):
if (a[i] == a[i+1]):
flg = 'NO'
break
print(flg)
|
def check(seq):
return len(seq) != len(set(seq))
def main():
N = int(input())
A = list(map(int, input().split()))
ans = check(A)
if ans:
print("NO")
else:
print("YES")
main()
| 1 | 73,988,635,537,462 | null | 222 | 222 |
a = input()
b = input()
res = 0
for i, char in enumerate(a):
if char != b[i]:
res += 1
print(res)
|
if __name__ == "__main__":
S = input()
T = input()
ans = 0
for i in range(len(S)):
if S[i] != T[i]:
ans += 1
print(ans)
| 1 | 10,475,535,666,730 | null | 116 | 116 |
def getmax(x,y):
if x>y:
return x
else:
return y
N,M,K = map(int,input().split())
A = list(map(int,input().split()))
B = list(map(int,input().split()))
a,b = [0],[0]
for i in range(N): #a[i]にはAの本をi冊読んだ時の時間がそれぞれ保存されている．
a.append(a[i]+A[i]) #計算量を減らすため，a[i]（1冊前までにかかる時間）を用いる
for i in range(M):
b.append(b[i]+B[i])
ans,j = 0,M
for i in range(N+1):
if a[i]>K:
break
while b[j] > K-a[i]: #Bの本を読んだ場合の処理はここで実行される．
j -=1
ans = max(ans, i+j)
print(ans)
|
def function(arg):
xyabc, pa, qb, rc = arg.split('¥n')
X,Y,A,B,C = map(int, xyabc.split())
oishisa_A = list(map(int, pa.split()))
oishisa_B = list(map(int, qb.split()))
oishisa_C = list(map(int, rc.split()))
oishisa_A.sort(reverse=True)
oishisa_A = oishisa_A[:X] # at most X
oishisa_B.sort(reverse=True)
oishisa_B = oishisa_B[:Y] # at most Y
oishisa_C.sort(reverse=True)
oishisa = oishisa_A + oishisa_B + oishisa_C
oishisa.sort(reverse=True)
results = 0
for i in range(X+Y):
results += oishisa[i]
return results
if __name__ == '__main__':
xyabc = input()
pa = input()
qb = input()
rc = input()
print(function(xyabc+'¥n'+pa+'¥n'+qb+'¥n'+rc))
| 0 | null | 27,780,182,209,782 | 117 | 188 |
#coding:utf-8
buff = [int(x) for x in input().split()]
a = buff[0]
b = buff[1]
c = buff[2]
print(len([x for x in [x+a for x in range(b - a + 1)] if c%x==0]))
|
s = raw_input().rstrip().split(" ")
ans=0
for i in range(int(s[0]),int(s[1])+1):
if int(s[2])%i==0:ans+=1
print ans
| 1 | 549,017,179,822 | null | 44 | 44 |
import math
from math import gcd
INF = float("inf")
import sys
input=sys.stdin.readline
import itertools
def main():
n = int(input())
l = list(map(int, input().split()))
ans = INF
for i in range(1,101):
trial = 0
for k in l:
trial += (k-i)**2
ans = min(ans, trial)
print(ans)
if __name__=="__main__":
main()
|
from sys import stdin
from math import ceil
inp = lambda : stdin.readline().strip()
n, x, t = [int(x) for x in inp().split()]
print(ceil(n/x)*t)
| 0 | null | 34,880,821,531,556 | 213 | 86 |
a = int(input())
b = input()
print(b.count('ABC'))
|
import sys
from itertools import combinations
import math
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int, sys.stdin.readline().rstrip().split()))
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())
n = I()
s = S()
# print(s.count('ABC'))
ans = 0
for i in range(len(s)-2):
if s[i] == 'A' and s[i+1] == 'B' and s[i+2] == 'C':
ans += 1
print(ans)
| 1 | 99,518,113,506,244 | null | 245 | 245 |
import math
import copy
from copy import deepcopy
import sys
import fractions
# import numpy as np
from functools import reduce
# import statistics
import heapq
import collections
import itertools
sys.setrecursionlimit(100001)
# input = sys.stdin.readline
# sys.setrecursionlimit(10**6)
# ===FUNCTION===
def getInputInt():
inputNum = int(input())
return inputNum
def getInputListInt():
outputData = []
inputData = input().split()
outputData = [int(n) for n in inputData]
return outputData
def getSomeInputInt(n):
outputDataList = []
for i in range(n):
inputData = int(input())
outputDataList.append(inputData)
return outputDataList
def getSomeInputListInt(n):
inputDataList = []
outputDataList = []
for i in range(n):
inputData = input().split()
inputDataList = [int(n) for n in inputData]
outputDataList.append(inputDataList)
return outputDataList
# ===CODE===
# n, m = map(int, input().split())
n = int(input())
list = [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]
print(list[n-1])
|
import itertools,sys
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
N = I()
A = LI()
ans = float('INF')
sum_A = sum(A)
accumulate_A = list(itertools.accumulate(A))
for i in range(N-1):
ans = min(ans,abs(sum_A-accumulate_A[i]*2))
print(ans)
| 0 | null | 95,916,310,094,388 | 195 | 276 |
s = input()
n = int(input())
for i in range(n):
order, a, b, *c = input().split()
a = int(a)
b = int(b)
if order == 'replace':
s = s[:a] + c[0] + s[b+1:]
elif order[0] == 'r':
s = s[:a] + s[::-1][len(s)-b-1:len(s)-a]+ s[b+1:]
else:
print(s[a:b+1])
|
def solve():
N, T = map(int, input().split())
A = [list(map(int, input().split())) for _ in range(N)]
A.sort()
dp = [[0]*(T+1) for _ in range(N+1)]
for i in range(N):
for j in range(0,T+1):
dp[i+1][j] = max(dp[i+1][j],dp[i][j])
if j<T:
t = min(T,j+A[i][0])
dp[i+1][t] = max(dp[i+1][t],dp[i][j]+A[i][1])
ans = dp[-1][-1]
return ans
print(solve())
| 0 | null | 76,680,913,105,310 | 68 | 282 |
def solve(n, m, s):
if s.find("1"*m) >= 0:
return -1
s = s[::-1]
i = 0
path = []
while i < n:
for j in range(min(m, n-i), 0, -1):
ni = i+j
if s[ni] == "0":
i = ni
path.append(j)
break
return " ".join(map(str, path[::-1]))
n, m = map(int, input().split())
s = input()
print(solve(n, m, s))
|
def mk_tree(A,N):
B = [None for _ in range(N+1)]
B[0] = 1
#B[i]:深さiの頂点の個数
A_sum = [A[i] for i in range(N+1)]
for i in reversed(range(N)):
A_sum[i] += A_sum[i+1]
for i in range(1,N+1):
B[i] = min(2*(B[i-1]-A[i-1]),A_sum[i])
if B[N] == A[N]:
return sum(B)
else:
return -1
def main():
N = int(input())
A = list(map(int,input().split()))
print(mk_tree(A,N))
if __name__ == "__main__":
main()
| 0 | null | 79,000,168,894,380 | 274 | 141 |
INF = 10 ** 20
n, m = map(int, input().split())
c_lst = list(map(int, input().split()))
dp = [INF for _ in range(n + 1)]
dp[0] = 0
for coin in c_lst:
for price in range(coin, n + 1):
dp[price] = min(dp[price], dp[price - coin] + 1)
print(dp[n])
|
n, m = map(int, input().split())
C = sorted(tuple(map(int, input().split())))
dp = list(range(0, n+1))
for i in range(m):
c = C[i]
ndp = [50000] * (n+1)
for j in range(n+1):
if j < c:
ndp[j] = dp[j]
else:
ndp[j] = min(dp[j], ndp[j-c] + 1)
dp = ndp
print(ndp[-1])
| 1 | 139,339,040,178 | null | 28 | 28 |
N, X, M = map(int, input().split())
sup = 10**11
db = [[0]*M for _ in range(sup.bit_length())]
dbcum = [[0]*M for _ in range(sup.bit_length())]
db[0] = [i**2 %M for i in range(M)]
dbcum[0] = [i**2 %M for i in range(M)]
for i in range(1,sup.bit_length()):
for j in range(M):
db[i][j] = db[i-1][db[i-1][j]]
dbcum[i][j] = dbcum[i-1][j]+dbcum[i-1][db[i-1][j]]
ans = X
p = 0
N -= 1
while N:
if N%2:
ans += dbcum[p][X]
X = db[p][X]
p += 1
N >>= 1
print(ans)
|
#from statistics import median
#import collections
#aa = collections.Counter(a) # list to list || .most_common(2)で最大の2個とりだせるお a[0][0]
from math import gcd
from itertools import combinations,permutations,accumulate, product # (string,3) 3回
#from collections import deque
from collections import deque,defaultdict,Counter
import decimal
import re
import math
import bisect
import heapq
#
#
#
# pythonで無理なときは、pypyでやると正解するかも！！
#
#
# my_round_int = lambda x:np.round((x*2 + 1)//2)
# 四捨五入g
#
# インデックス系
# int min_y = max(0, i - 2), max_y = min(h - 1, i + 2);
# int min_x = max(0, j - 2), max_x = min(w - 1, j + 2);
#
#
import sys
sys.setrecursionlimit(10000000)
mod = 10**9 + 7
#mod = 9982443453
#mod = 998244353
INF = float('inf')
from sys import stdin
readline = stdin.readline
def readInts():
return list(map(int,readline().split()))
def readTuples():
return tuple(map(int,readline().split()))
def I():
return int(readline())
n,x,m = readInts()
lis = []
prv = None
dic = defaultdict(int)
for i in range(m):
if i == 0:
A = x%m
lis.append(A)
dic[A] = 1
else:
A = (A*A)%m
if dic[A]:
prv = A
break
else:
dic[A] = 1
lis.append(A)
cnt = None
for i in range(len(lis)):
if lis[i] == prv:
cnt = i
break
if cnt == None:
cnt = len(lis)
front_arr = lis[:cnt]
loop_arr = lis[cnt:]
if x == 0:
print(0)
exit()
len_loop_arr = len(loop_arr)
if n < cnt:
ans = sum(front_arr[:n])
else:
ans = sum(front_arr)
sum_loop_arr = sum(loop_arr)
n -= cnt
loop = n//len_loop_arr
rest = n - (loop*len_loop_arr)
mid = loop * sum_loop_arr
ans += mid
ans += sum(loop_arr[:rest])
print(ans)
| 1 | 2,810,695,828,580 | null | 75 | 75 |
s=input()
print("No" if s=="AAA" or s=="BBB" else "Yes")
|
str = input()
q = int(input())
for x in range(q):
en = input().split()
if en[0] == "print":
print(str[int(en[1]):int(en[2])+1])
elif en[0] == "reverse":
str = str[:int(en[1])] + str[int(en[1]):int(en[2])+1][::-1] + str[int(en[2])+1:]
else:
str = str[:int(en[1])] + en[3] + str[int(en[2])+1:]
| 0 | null | 28,419,940,849,120 | 201 | 68 |
a, b = map(int, input().split())
res = 'No'
if 500*a >= b:
res = 'Yes'
print(res)
|
k,x=(int(a) for a in input().split())
if(x<=k*500):
print("Yes")
else:
print("No")
| 1 | 98,192,842,190,660 | null | 244 | 244 |
n,t = map(int,input().split())
ab = [list(map(int,input().split())) for _ in range(n)]
ab.sort() # 食べるのが早い順にソート
# ナップザック問題に落とし込む
dp = [[0 for i in range(t+1)]for j in range(n+1)]
for i in range(n):
ti,vi = ab[i]
for j in range(t+1):
# 食べたほうがよい(t秒以内かつ満足度が上がるならば)
if j + ti <= t:
dp[i+1][j+ti] = max(dp[i+1][j+ti],dp[i][j]+vi)
# 食べなかった場合の最高値を更新
dp[i+1][j] = max(dp[i][j],dp[i+1][j])
ma = 0
for i in range(n):
# 最後にi番目の皿を食べることができる
ma = max(ma,dp[i][t-1]+ab[i][1])
print(ma)
|
# コード整理
import sys
from operator import itemgetter
input = sys.stdin.readline
#################
# 定数
#################
TIME = 0
VAL = 1
##################
# 入力処理
##################
N, T = [int(a) for a in input().split()]
time_value = [(-1, -1)] + [tuple(int(a) for a in input().split()) for _ in range(N)]
# Sort the array in the increasing order of value
time_value.sort(key = itemgetter(VAL))
###########################
# 動的計画法（Knapsack problem）のテーブル埋め
# 時間の最大値は T - 1
##########################
dp = [[-1] * T for _ in range(N + 1)] # (N+1)行 x T列 2次元リスト
for t in range(0, T):
dp[0][t] = 0
for n in range(1, N + 1):
dp[n][0] = 0
for t in range(1, T):
if time_value[n][TIME] > t:
dp[n][t] = dp[n - 1][t]
else:
dp[n][t] = max(dp[n - 1][t],
time_value[n][VAL] + dp[n - 1][t - time_value[n][TIME]])
##########################
# DPテーブルを用いて問題を解く
##########################
# t = T - 1に食べ始める料理が N, N-1, N-2, ..., 2, 1それぞれの場合で
# 美味しさの最大値を出し、更にその最大値を取る
# 最後に食べる料理がNの場合
val_acum = time_value[N][VAL]
t = T - 1 # N以外の料理を食べるのに使える時間
max_val = val_acum + dp[N - 1][t]
for n in range(N - 1, 0, -1): # 最後に食べる料理が n = N-1, N-2, ..., 2, 1の場合
val_acum += time_value[n][VAL] # 料理 N, N-1, ..., nの美味しさ合計
t -= time_value[n + 1][TIME] # その他の料理 1, 2, ..., n-1を食べるのに使える時間
if t < 0:
break
else:
max_val = max(max_val, val_acum + dp[n - 1][t])
print(max_val)
| 1 | 151,637,661,184,412 | null | 282 | 282 |
import math
a, b, x = [int(w) for w in input().split()]
if x > a * a * b / 2:
rad = math.atan(2*(a ** 2 * b - x) / a ** 3)
else:
rad = math.atan((a * b ** 2) / (2 * x))
print(math.degrees(rad))
|
from math import tan, pi, degrees
a, b, x = map(int, input().split())
def solve(isOK):
ng, ok = pi/2, 0
while abs(ok-ng) > 10**-12:
mid = (ng+ok) / 2
if isOK(mid):
ok = mid
else:
ng = mid
# print('ok:', ok)
print(degrees(ok))
def isOK1(theta):
return a*a*tan(theta)/2 + x/a <= a*b
def isOK2(theta):
return b*b/tan(theta)/2 >= x/a
if x/a >= a*b/2:
solve(isOK1)
else:
solve(isOK2)
| 1 | 162,997,039,122,144 | null | 289 | 289 |
N,A,B = map(int,input().split())
p = N // (A+B)
q = N % (A+B)
if q > A:
r = A
else:
r = q
print(A * p + r)
|
import random
name = input()
n = random.choice(name)
while name.find(n) > len(name) - 3:
n = random.choice(name)
num = name.find(n)
for i in range(3):
print(name[num + i], end = "")
| 0 | null | 35,106,472,454,350 | 202 | 130 |
m = input().split()
K = int(m[0])
X = int(m[1])
ans = 'Yes'
if 500 * K < X:
ans = 'No'
print(ans)
|
#E
from math import gcd
N=int(input())
A=list(map(int,input().split()))
GCD=A[0]
for i in range(1,N):
GCD=gcd(GCD,A[i])
def Fast_PFact(n):
List=[0 for i in range(n+1)]
List[1]=1
for i in range(2,n+1):
if List[i]==0:
cnt=1
while i*cnt<=n:
List[i*cnt]=i
cnt+=1
return List
if GCD==1:
P=Fast_PFact(10**6)
L=[False for i in range(10**6+1)]
flag=False
for i in range(N):
a=A[i]
while a>1:
if L[P[a]]:
flag=True
break
else:
L[P[a]]=True
divisor=P[a]
while divisor==P[a]:
a=int(a/divisor)
if flag:
ans="setwise coprime"
else:
ans="pairwise coprime"
else:
ans="not coprime"
print(ans)
| 0 | null | 51,261,065,305,040 | 244 | 85 |
n, m, l = list(map(lambda x: int(x), input().split(" ")))
A = list()
for i in range(n):
A.extend([list(map(lambda x: int(x), input().split(" ")))])
B = list()
for i in range(m):
B.extend([list(map(lambda x: int(x), input().split(" ")))])
C = list([[0 for l_ in range(l)]for n_ in range(n)])
for i in range(n):
for j in range(l):
for k in range(m):
C[i][j] += A[i][k] * B[k][j]
for a in C:
print("%d" % a[0], end="")
for b in a[1:]:
print(" %d" % b, end="")
print()
|
n,m,l=map(int,raw_input().split())
A=[]
B=[]
for i in range(n):
A.append(map(int,raw_input().split()))
for i in range(m):
B.append(map(int,raw_input().split()))
for i in range(n):
print(' '.join(map(str,[sum([A[i][j]*B[j][k] for j in range(m)]) for k in range(l)])))
| 1 | 1,413,277,929,732 | null | 60 | 60 |
N=int(input())
d=list(map(int,input().split()))
a=0
for i in range(len(d)):
for j in range(len(d)):
if i!=j and i>j:
a+=d[i]*d[j]
print(a)
|
s=input()
t=input()
n=len(s)
if s==t[:n] and len(t)==n+1:
print('Yes')
else:
print('No')
| 0 | null | 95,194,715,934,890 | 292 | 147 |
x = input()
if x == x.upper():
print("A")
else:
print("a")
|
n=input()
if n==n.upper():
print("A")
else:
print("a")
| 1 | 11,282,576,957,242 | null | 119 | 119 |
d = set()
n = int(input())
for i in range(n):
raw=input().split()
if raw[0] == 'insert':
d.add(raw[1])
else:
if raw[1] in d:
print('yes')
else:
print('no')
|
u = str(input())
len_ =len(u)
tmp = str()
for i in range(len_):
tmp = tmp + 'x'
print(tmp)
| 0 | null | 36,302,759,729,008 | 23 | 221 |
string = input()
string = string*2
if string.count(input()):
print("Yes")
else:
print("No")
|
s=input()*3
if s.find(input()) == -1 :
print('No')
else:
print('Yes')
| 1 | 1,726,974,660,710 | null | 64 | 64 |
s,t=map(str,input().split())
a,b=map(int,input().split())
u=input()
if u==s:
print("{0} {1}".format(a-1,b))
else:
print("{0} {1}".format(a,b-1))
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
var = int(raw_input())
h = str(var / 3600)
ms = var % 3600
m = str(ms / 60)
s = str(ms % 60)
print ":".join([h, m, s])
| 0 | null | 36,061,029,212,350 | 220 | 37 |
from sys import stdin
def isPrime(x):
if x == 2: return 1
elif x % 2 == 0: return 0
return pow(2, x - 1, x) == 1
n = int(stdin.readline())
print(sum([isPrime(int(stdin.readline())) for _ in range(n)]))
|
count = 0
for _ in range(int(input())):
n = int(input())
if n == 2 or pow(2,n-1,n) == 1:
count += 1
print(count)
| 1 | 10,933,383,890 | null | 12 | 12 |
N = int(input())
dp = [[0]*10 for _ in range(10)]
for a in range(N+1):
A = str(a)
dp[int(A[0])][int(A[-1])] += 1
ans = 0
for i in range(1,10):
for j in range(1,10):
ans += dp[i][j]*dp[j][i]
print(ans)
|
#from collections import deque,defaultdict
printn = lambda x: print(x,end='')
inn = lambda : int(input())
inl = lambda: list(map(int, input().split()))
inm = lambda: map(int, input().split())
ins = lambda : input().strip()
DBG = True # and False
BIG = 10**18
R = 10**9 + 7
def ddprint(x):
if DBG:
print(x)
def foo(n,x,y):
l = len(n)
sm = 0
if x==y and (l>1 or n[0]>=x):
sm = 1
if l==1:
return sm
for i in range(2,l):
sm += 10**(i-2)
if x==n[-1]:
sm += bar(n[:-1],y)
elif x<n[-1]:
sm += 10**(l-2)
#ddprint(f"foo {n=} {x=} {y=} {sm=}")
return sm
def bar(n,y):
l = len(n)
if l==1:
return 1 if n[0]>=y else 0
sm = (n[-1])*10**(l-2) + bar(n[:-1],y)
return sm
nn = inn()
nnn = nn
n = []
while nn>0:
n.append(nn%10)
nn //= 10
sm = 0
for a in range(1,nnn+1):
y = a%10
if y==0:
continue
aa = a
while aa>0:
x = aa
aa //= 10
sm += foo(n,y,x)
print(sm)
| 1 | 86,727,575,441,260 | null | 234 | 234 |
import sys
sys.setrecursionlimit(10000000)
MOD = 10 ** 9 + 7
INF = 10 ** 15
N,K = map(int,input().split())
W = [int(input()) for _ in range(N)]
r = 10 ** 10
l = 0
def ok(x):
cnt = 1
tot = 0
for i in range(N):
if tot + W[i] <= x:
tot += W[i]
else:
cnt += 1
if W[i] > x:
return False
tot = W[i]
return cnt <= K
while r - l > 1:
mid = (r + l)//2
if ok(mid):
r = mid
else:
l = mid
print(r)
|
def main():
L = [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]
K = int(input())
print(L[K-1])
if __name__ == "__main__":
main()
| 0 | null | 25,209,291,458,208 | 24 | 195 |
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
N, T = MAP()
AB = [LIST() for _ in range(N)]
AB.sort(key = lambda x:x[0])
t = [0]*T
ans = 0
for A, B in AB:
for i in range(T-1, 0, -1):
if t[i]:
if T <= i+A:
ans = max(ans, t[i]+B)
else:
t[i+A] = max(t[i+A], t[i]+B)
if T <= A:
ans = max(ans, B)
else:
t[A] = max(t[A], B)
ans = max(ans, max(t))
print(ans)
|
import math
a,b = [int(x) for x in input().split()]
ma = int(a//0.08)
mb = int(b//0.1)
fmindi = False
mindi = 9999999999999
for x in range(min(ma,mb),max(ma,mb)+2):
j = math.floor(x*0.08)
e = math.floor(x*0.1)
if j == a and e == b:
fmindi = True
mindi = min(mindi,x)
print(mindi if fmindi else -1)
| 0 | null | 104,059,299,941,380 | 282 | 203 |
num=[]
num=list(map(int,input().split()))
for i in range(5):
if num[i]==0:
print(i+1)
break
else:
continue
|
x_list = list(map(int, input().split()))
ans = 0
for i, x in enumerate(x_list):
if x == 0:
ans = i + 1
break
print(ans)
| 1 | 13,432,022,628,828 | null | 126 | 126 |
x, n = map(int, input().split())
p = list(map(int, input().split()))
for i in range(x+1):
for j in [-1, 1]:
ans = x + i*j
if not p.count(ans):
print(ans)
exit(0)
|
_ = input()
a = list(input())
cnt = 0
word = 0
for i in a:
if word == 0 and i == 'A':
word = 1
elif word == 1 and i =='B':
word = 2
elif word == 2 and i =='C':
word = 0
cnt += 1
else:
if i == 'A':
word = 1
else:
word = 0
print(cnt)
| 0 | null | 56,546,201,511,030 | 128 | 245 |
x = int(input())
dp = [0] * 100200
dp[100] = 1
dp[101] = 1
dp[102] = 1
dp[103] = 1
dp[104] = 1
dp[105] = 1
for i in range(100, x+1):
for p in [100, 101, 102, 103, 104, 105]:
dp[i+p] = max(dp[i], dp[i+p])
print(dp[x])
|
x=int(input())
print(1 if x%100<=(x//100)*5 else 0)
| 1 | 127,587,663,100,002 | null | 266 | 266 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.