code1
stringlengths 16
24.5k
| code2
stringlengths 16
24.5k
| similar
int64 0
1
| pair_id
int64 2
181,637B
⌀ | question_pair_id
float64 3.71M
180,628B
⌀ | code1_group
int64 1
299
| code2_group
int64 1
299
|
|---|---|---|---|---|---|---|
n = int(input())
a = list(map(int, input().split()))
rbg = [0]*3
ans = 1
MOD = 1000000007
for i in a:
count=0
flg=True
for j in range(3):
if rbg[j]==i:
count+=1
if flg:
rbg[j]+=1
flg=False
ans*=count
ans%=MOD
print(ans)
|
N = int(input())
al = list(map(int,input().split()))
sss=0
pss=0
for i in range(1,N):
pss+=al[i-1]
sss+=al[i]*pss
print(sss%1000000007)
| 0 | null | 66,914,903,960,740 | 268 | 83 |
x = int(input())
now = 0
ans = 0
while True:
ans += 1
now += x
if now % 360 == 0:
print(ans)
exit()
|
# coding: utf-8
import sys
def merge(A, left, mid, right):
global count
L = A[left:mid]
R = A[mid:right]
L.append(sys.maxsize)
R.append(sys.maxsize)
i = 0
j = 0
for k in range(left,right):
if L[i] <= R[j]:
A[k] = L[i]
i += 1
else:
A[k] = R[j]
j += 1
count += 1
def mergeSort(A, left, right):
if left+1 < right:
mid = int((left + right)/2);
mergeSort(A, left, mid)
mergeSort(A, mid, right)
merge(A, left, mid, right)
n = int(input().rstrip())
A = list(map(int,input().rstrip().split()))
count = 0
mergeSort(A, 0, n)
print(" ".join(map(str,A)))
print(count)
| 0 | null | 6,629,365,418,210 | 125 | 26 |
H,W = map(int, input().split())
S = [input() for _ in range(H)]
inf = 10**6
L = [[inf]*W for _ in range(H)]
if S[0][0] == ".":
L[0][0] = 0
else:
L[0][0] = 1
for i in range(H):
for j in range(W):
n1 = inf
n2 = inf
if i > 0:
if S[i-1][j] == "." and S[i][j] == "#":
n1 = L[i-1][j] + 1
else:
n1 = L[i-1][j]
if j > 0:
if S[i][j-1] == "." and S[i][j] == "#":
n2 = L[i][j-1] + 1
else:
n2 = L[i][j-1]
L[i][j] = min(L[i][j], n1, n2)
print(L[-1][-1])
|
h, w = map(int, input().split())
M = [list(input()) for _ in range(h)]
count = [[int(1e18) for _ in range(w)] for _ in range(h)]
count[0][0] = 1 if M[0][0] == '#' else 0
# 同じ色かどうかを見る
for i in range(h):
for j in range(w):
if i + 1 < h:
v = 1 if M[i][j] != M[i + 1][j] else 0
count[i + 1][j] = min(count[i + 1][j], count[i][j] + v)
if j + 1 < w:
v = 1 if M[i][j] != M[i][j + 1] else 0
count[i][j + 1] = min(count[i][j + 1], count[i][j] + v)
print((count[h - 1][w - 1] + 1) // 2)
| 1 | 49,381,004,514,310 | null | 194 | 194 |
import numpy as np
from numba import njit
N = np.array([int(_) for _ in input()])
dp = np.array([[0, 0] for _ in range(len(N))])
@njit
def solve(N, dp):
dp[0, 0] = min(N[0], 11 - N[0])
dp[0, 1] = min(N[0] + 1, 10 - N[0])
for i in range(1, len(N)):
dp[i, 0] = min(dp[i - 1, 0] + N[i], dp[i - 1, 1] + 10 - N[i])
dp[i, 1] = min(dp[i - 1, 0] + N[i] + 1, dp[i - 1, 1] + 9 - N[i])
print(dp[-1][0])
solve(N, dp)
|
def main():
N = [int(x) for x in input()]
dp0 = 0
dp1 = 1
for n in N:
# そのまま払う
a = min(dp0 + n, dp1 + 10 - n)
# 1多めに払う
b = min(dp0 + n + 1, dp1 + 10 - (n+1))
dp0, dp1 = a, b
print(dp0)
if __name__ == '__main__':
main()
| 1 | 71,174,089,174,910 | null | 219 | 219 |
mod = 10**9 + 7
X, Y = map(int, input().split())
if (X+Y) % 3 != 0:
print(0)
exit()
a = (2*Y-X)//3
b = (2*X-Y)//3
if a < 0 or b < 0:
print(0)
exit()
m = min(a, b)
ifact = 1
for i in range(2, m+1):
ifact = (ifact * i) % mod
ifact = pow(ifact, mod-2, mod)
fact = 1
for i in range(a+b, a+b-m, -1):
fact = (fact * i) % mod
print(fact*ifact % mod)
|
import math
X,Y= list(map(int, input().split()))
def cmb(n, r, mod):
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % mod
mod = 10**9+7 #出力の制限
N = 10**6
g1 = [1, 1] # 元テーブル
g2 = [1, 1] #逆元テーブル
inverse = [0, 1] #逆元テーブル計算用テーブル
for i in range( 2, N + 1 ):
g1.append( ( g1[-1] * i ) % mod )
inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )
g2.append( (g2[-1] * inverse[-1]) % mod )
if((X+Y) % 3 != 0):
print(0)
exit()
s = (-X + 2 * Y) // 3
t = (-Y + 2 * X) // 3
#print(s,t)
ans = cmb(s+t, s, 10**9+7)
print(ans)
| 1 | 150,441,844,652,898 | null | 281 | 281 |
import sys
s = sys.stdin
cnt = 1
for i in s:
if int(i)== 0:
break
print("Case {0}: {1}".format(cnt,i),end="")
cnt += 1
|
N = int(input())
S = str(input())
flag = False
half = (N+1) // 2
if S[:half] == S[half:N]:
flag = True
if flag:
print("Yes")
else:
print("No")
| 0 | null | 73,768,177,113,218 | 42 | 279 |
def main():
import sys
input = sys.stdin.readline
n = int(input())
D = list(map(int,input().split()))
mod = 998244353
from collections import Counter
node_cnt = Counter(D)
set_d = sorted(list(set(D)))
if D[0]!=0:
print(0);exit()
if set_d[-1]!=len(set_d)-1:
print(0);exit()
ans = 0
pre = 1
if 0 in node_cnt:
if node_cnt[0]==1:
ans = 1
for k,v in sorted(node_cnt.items()):
ans*=pow(pre,v)
ans%=mod
pre = v
print(ans)
if __name__=='__main__':
main()
|
x = {"S": list(range(1, 14)), "H": list(range(1, 14)),
"C": list(range(1, 14)), "D": list(range(1, 14))}
n = int(input())
for i in range(n):
tmp = input().split()
key = tmp[0]
num = int(tmp[1])
x[key].remove(num)
keys = ["S", "H", "C", "D"]
for key in keys:
if len(x[key])==0:
pass
else:
for i in x[key]:
print(key, i)
| 0 | null | 78,119,568,701,108 | 284 | 54 |
# D - Bouquet
n,a,b = map(int,input().split())
MOD = 10**9+7
ans = pow(2,n,MOD)-1
a,b = min(a,b),max(a,b)
tmp = 1
for i in range(1,a+1):
tmp = tmp*(n+1-i)*pow(i,-1,MOD)
tmp %= MOD
ans = (ans-tmp)%MOD
for i in range(a+1,b+1):
tmp = tmp*(n+1-i)*pow(i,-1,MOD)
tmp %= MOD
ans = (ans-tmp)%MOD
print(ans)
|
h1, m1, h2, m2, k = map(int, input().split())
st = h1 * 60 + m1
ed = h2 * 60 + m2
ans = ed - st - k
if ans < 0:
ans = 0
print(ans)
| 0 | null | 42,221,530,132,000 | 214 | 139 |
def n0():return int(input())
def n1():return [int(x) for x in input().split()]
def n2(n):return [int(input()) for _ in range(n)]
def n3(n):return [[int(x) for x in input().split()] for _ in range(n)]
n,m=n1()
if n%2==0:
if m>=2:
e=n//2
s=1
l=e-s
c=0
while e>s and c<m:
print(s,e)
s+=1
e-=1
c+=1
e=n
s=n-l+1
while e>s and c<m:
print(s,e)
s+=1
e-=1
c+=1
else:
print(1,2)
else:
if m>=2:
e=n//2+1
s=1
l=e-s
c=0
while e>s and c<m :
print(s,e)
s+=1
e-=1
c+=1
e=n
s=n-l+1
while e>s and c<m:
print(s,e)
s+=1
e-=1
c+=1
else:
print(1,2)
|
import math
nums = [int(e) for e in input().split()]
n = nums[0]
m = nums[1]
x = -1
y = -1
ms = []
if n%2 == 0:
x = 1
y = n
count = True
while x < y:
if y-x <= n/2 and count:
y -= 1
count = False
ms += [[x,y]]
x += 1
y -= 1
else:
x = 1
y = n
while x < y:
ms += [[x, y]]
x += 1
y -= 1
# print(ms)
for i in range(m):
print(str(ms[i][0]) + " " + str(ms[i][1]))
| 1 | 28,517,503,214,490 | null | 162 | 162 |
def solve(n):
l = []
for i in range(int(n**(1/2))):
if n % (i+1) == 0:
a = i + 1
b = n // a
l.append(a+b-2)
return min(l)
print(solve(int(input())))
|
# collections.deque is implemented using doubly linked list at C level..
from collections import deque
linkedlist = deque()
for _ in range(int(input())):
input_command = input()
if input_command == 'deleteFirst':
linkedlist.popleft()
elif input_command == 'deleteLast':
linkedlist.pop()
else:
com, num = input_command.split()
if com == 'insert':
linkedlist.appendleft(num)
elif com == 'delete':
try:
linkedlist.remove(num)
except:
pass
print(' '.join(linkedlist))
| 0 | null | 80,993,803,882,328 | 288 | 20 |
L=[]
s=int(raw_input())
L+=divmod(s,3600)
L+=divmod(L[1],60)
print ("{0}:{1}:{2}").format(L[0],L[2],L[3])
|
S = int(input())
S = S % (24 * 3600)
hour = S // 3600
S %= 3600
minutes = S // 60
S %= 60
seconds = S
print("%d:%d:%d" % (hour, minutes, seconds))
| 1 | 331,461,873,340 | null | 37 | 37 |
S = list(map(int, list(input())))[::-1]
N = len(S)
CNT = [0]*2019
CNT[0] = 1
num = 0
d = 0
for i in range(N):
num += S[i]*pow(10, d, 2019)
num %= 2019
CNT[num] += 1
d += 1
ans = 0
for cnt in CNT:
ans += (cnt*(cnt - 1)) // 2
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,923,028,462,800 | null | 166 | 166 |
import sys
#UnionFindTreeクラスの定義
class UnionFind():
#クラスコンストラクタ
#selfはインスタンス自身
def __init__(self, n):
#親ノードを-1に初期化する
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]
#xとyの木を併合する
def union(self, x, y):
#x,yの根をX,Yとする
X = self.find(x)
Y = self.find(y)
#根が同じなら結合済み
if X == Y:
return
#ノード数が多い方をXとする
if self.parents[X] > self.parents[Y]:
X, Y = Y, X
#XにYのノード数を足す
self.parents[X] += self.parents[Y]
#Yの根を X>0 とする
self.parents[Y] = X
N, M = map(int, input().split())
info = [tuple(map(int, s.split())) for s in sys.stdin.readlines()]
#UnionFindインスタンスの生成
uf = UnionFind(N)
for a, b in info:
#インデックスを調整し、a,bの木を結合
a -= 1; b -= 1
uf.union(a, b)
c = 0
for i in range(N):
if uf.parents[i] < 0:
c += 1
print(c-1)
|
import sys
if sys.argv[-1] == 'ONLINE_JUDGE':
import os
import re
with open(__file__) as f:
source = f.read().split('###''nbacl')
for s in source[1:]:
s = re.sub("'''.*", '', s)
sp = s.split(maxsplit=1)
if os.path.dirname(sp[0]):
os.makedirs(os.path.dirname(sp[0]), exist_ok=True)
with open(sp[0], 'w') as f:
f.write(sp[1])
from nbmodule import cc
cc.compile()
import numpy as np
from numpy import int64
from nbmodule import solve
f = open(0)
N, M = [int(x) for x in f.readline().split()]
AB = np.fromstring(f.read(), dtype=int64, sep=' ').reshape((-1, 2))
ans = solve(N, AB)
print(ans)
'''
###nbacl nbmodule.py
import numpy as np
from numpy import int64
from numba import njit
from numba.types import i8
from numba.pycc import CC
import nbacl.dsu as dsu
cc = CC('nbmodule')
@cc.export('solve', (i8, i8[:, ::1]))
def solve(N, AB):
t = np.full(N, -1, dtype=int64)
for i in range(AB.shape[0]):
dsu.merge(t, AB[i, 0] - 1, AB[i, 1] - 1)
ret = 0
for _ in dsu.groups(t):
ret += 1
return ret - 1
if __name__ == '__main__':
cc.compile()
###nbacl nbacl/dsu.py
import numpy as np
from numpy import int64
from numba import njit
@njit
def dsu(t):
t = -1
@njit
def merge(t, x, y):
u = leader(t, x)
v = leader(t, y)
if u == v:
return u
if -t[u] < -t[v]:
u, v = v, u
t[u] += t[v]
t[v] = u
return u
@njit
def same(t, x, y):
return leader(t, x) == leader(t, y)
@njit
def leader(t, x):
if t[x] < 0:
return x
t[x] = leader(t, t[x])
return t[x]
@njit
def size(t, x):
return -t[leader(t, x)]
@njit
def groups(t):
for i in range(t.shape[0]):
if t[i] < 0:
yield i
'''
| 1 | 2,272,351,158,098 | null | 70 | 70 |
from collections import deque
n,m = map(int, input().split())
g = [[] for _ in range(n)]
for _ in range(m):
a,b = map(int, input().split())
a,b = a-1, b-1
g[a].append(b)
g[b].append(a)
stack = deque([0])
dist = [-1]*n
dist[0] = 0
while stack:
v = stack.popleft()
for nv in g[v]:
if dist[nv] == -1:
dist[nv] = v+1
stack.append(nv)
print("Yes")
print(*dist[1:], sep= "\n")
|
import sys
input = sys.stdin.readline
ins = lambda: input().rstrip()
ini = lambda: int(input().rstrip())
inm = lambda: map(int, input().split())
inl = lambda: list(map(int, input().split()))
s = ins()
print("ABC" if s == "ARC" else "ARC")
| 0 | null | 22,251,680,866,272 | 145 | 153 |
N = int(input())
S = list(input())
R_list = [0]*N
G_list = [0]*N
B_list = [0]*N
for key,val in enumerate(S):
if val=='R':
R_list[key] = R_list[key-1]+1
G_list[key] = G_list[key-1]
B_list[key] = B_list[key-1]
elif val=='G':
R_list[key] = R_list[key-1]
G_list[key] = G_list[key-1]+1
B_list[key] = B_list[key-1]
elif val=='B':
R_list[key] = R_list[key-1]
G_list[key] = G_list[key-1]
B_list[key] = B_list[key-1]+1
ans = 0
for i in range(N-2):
for j in range(i+1,N-1):
if S[i]==S[j]:
continue
a=2*(j+1)-(i+1)-1
check = [S[i],S[j]]
if 'R' not in check:
ans += R_list[-1]-R_list[j]
if a<N and S[a]=='R':
ans -= 1
elif 'G' not in check:
ans += G_list[-1]-G_list[j]
if a<N and S[a]=='G':
ans -= 1
elif 'B' not in check:
ans += B_list[-1]-B_list[j]
if a<N and S[a]=='B':
ans -= 1
print(ans)
|
N = int(input())
S = list(input())
r = 0
g = 0
b = 0
for i in range(N):
if S[i] == 'R':
r += 1
elif S[i] == 'G':
g += 1
else:
b += 1
allcnt = r * g * b
sub = 0
for i in range(N):
for j in range(i+1,N):
if S[i] == S[j]:
None
else:
k = 2*j-i
if k >= N or S[i] == S[k] or S[j] == S[k]:
None
else:
sub += 1
print(allcnt - sub)
| 1 | 36,202,945,949,756 | null | 175 | 175 |
import sys
sys.setrecursionlimit(10**9)
n,m = list(map(int,input().split()))
d = {}
for i in range(m):
fr, to = list(map(int,input().split()))
d[fr] = d.get(fr, []) + [to]
d[to] = d.get(to, []) + [fr]
visited = [0 for i in range(n+1)]
def connect(node, i):
visited[node] = i
if node in d:
for neig in d[node]:
if visited[neig] == 0:
connect(neig, i)
ans = 1
for key in range(1,n+1):
if visited[key] == 0:
connect(key, ans)
ans += 1
print(max(visited)-1)
|
a=int(input())
if a%2==0:
print(1/2)
else:
print(((a+1)/2)/a)
| 0 | null | 89,999,617,664,798 | 70 | 297 |
s = []
p = []
a = i = 0
for c in input():
if c == "\\":
s += [i]
elif c == "/" and s:
j = s.pop()
t = i-j
a += t
while p and p[-1][0] > j:
t += p[-1][1]
p.pop()
p += [(j,t)]
i += 1
print(a)
if p:
print(len(p),*list(zip(*p))[1])
else:
print(0)
|
ary = list(input())
s1 = []
s = 0
s2 = []
cnt = 0
for _ in ary:
if _ == '\\':
s1.append(cnt)
cnt += 1
elif _ == '/':
if s1:
old_cnt = s1.pop()
area = cnt - old_cnt
s += area
while s2:
if old_cnt < s2[-1][0]:
area += s2.pop()[1]
else:
break
s2.append((old_cnt, area))
cnt += 1
else:
cnt += 1
print(s)
print(len(s2), *[_[1] for _ in s2])
| 1 | 56,566,034,982 | null | 21 | 21 |
n=int(input())
a=list(map(int,input().split()))
tot=sum(a)
v=[1]
for q in a:
tot-=q
v.append(min(2*(v[-1]-q),tot))
if all([u>=0 for u in v]):
print(sum(v))
else:
print(-1)
|
import math
N = int(input())
# A = list(map(int, input().split()))
A = [int(x) for x in input().split(' ')]
a_max = [0] * (N+1)
a_min = [0] * (N+1)
a = [0] * (N+1)
#１．可・不可の判定
# 最下段からとりうる個数の範囲を考える
#0段目の範囲に１が含まれないならば”不可”(根＝１)
for i in range(N+1):
if i == 0:
a_max[N-i] = A[N-i]
a_min[N-i] = A[N-i]
else:
a_max[N-i] = a_max[N-i+1] + A[N-i]
a_min[N-i] = math.ceil(a_min[N-i+1]/2) + A[N-i]
#check print
# for i in range(N+1):
# print(str(i) + ':----')
# print(a_min[i],a_max[i])
#最上段から個数のカウント
for i in range(N+1):
if i == 0:
a[i] = 1
else:
a[i] = min((a[i-1] - A[i-1])*2 , a_max[i])
#不可は-1を、可は個数の合計を
if a_min[0] > 1:
print(-1)
else:
print(sum(a))
| 1 | 18,769,352,174,652 | null | 141 | 141 |
#左からn個目でendが特定の色の場合に
N,M,K = list(map(int,input().split()))
def xgcd(a, b):
x0, y0, x1, y1 = 1, 0, 0, 1
while b != 0:
q, a, b = a // b, b, a % b
x0, x1 = x1, x0 - q * x1
y0, y1 = y1, y0 - q * y1
return a, x0, y0
def modinv(a, m):
g, x, y = xgcd(a, m)
if g != 1:
raise Exception('modular inverse does not exist')
else:
return x % m
def combination(n, k, mod=1e9+7) -> int:
ret = 1
for i in range(1, k+1):
ret = (ret * (n-k+i) * modinv(i, mod))%mod
return int(ret)
def pow(base, exponent, mod=1e9+7) -> int:
if exponent == 0:
return 1
if exponent > 1:
d,m = divmod(exponent, 2)
return (base**m * pow(base, d, mod)**2 ) % mod
else:
return base
m = 998244353
res = 0
B = 1
if M != 1:
mi = modinv(M-1,m)
A = M * pow(M-1,N-1,m)
for k in range(K+1):
if k>0:
B = (B*(N-k)*modinv(k,m))%m
res = (res+ A*B)%m
A = (A*mi)%m
print (res)
else:
if K == N-1:
print(1)
else:
print(0)
|
N, M, K = map(int, input().split())
MOD = 998244353
n = N
fac = [1]*(n+1)
rev = [1]*(n+1)
for i in range(1,n+1):
fac[i] = i*fac[i-1]%MOD
rev[i] = pow(fac[i], MOD-2, MOD)
comb = lambda a,b:(fac[a]*rev[a-b]*rev[b])%MOD
ans = 0
for i in range(K+1):
ans += comb(N-1, N-1-i) * M * pow(M-1, N-1-i, MOD)
ans %= MOD
print(ans)
| 1 | 23,215,313,915,872 | null | 151 | 151 |
import sys
input = sys.stdin.readline
def I(): return int(input())
def MI(): return map(int, input().split())
def LI(): return list(map(int, input().split()))
def main():
mod=10**9+7
H=I()
ans=0
def f(x):
if x==0:
return 0
return f(x//2)*2 +1
print(f(H))
main()
|
import sys
sys.setrecursionlimit(1000000000)
ii = lambda: int(input())
mis = lambda: map(int, input().split())
lmis = lambda: list(mis())
mlmis = lambda: [-int(x) for x in input().split()]
INF = float('inf')
#
def main():
H,W,K=mis()
S = [input() for i in range(H)]
ranges = []
u = b = 0
while u < H:
if '#' in S[b]:
ranges.append(range(u, b+1))
u = b = b+1
elif b == H-1:
last = ranges.pop()
ranges.append(range(last[0], H))
break
else:
b += 1
c = 1
for ran in ranges:
l = r = 0
s = []
while l < W:
s.append(c)
if any(S[i][r]=='#' for i in ran):
c += 1
l = r = r+1
elif r == W-1:
for i, elem in enumerate(s):
if elem == c:
s[i] = c-1
break
else:
r += 1
for _ in ran:
print(' '.join(map(str, s)))
main()
| 0 | null | 112,160,207,332,732 | 228 | 277 |
from collections import deque
H, W = map(int, input().split())
S=[]
for _ in range(H):
S.append(input())
vx = [1, 0, -1, 0]
vy = [0, 1, 0, -1]
ans = 0
def func(si, sj):
queue = deque([si, sj])
seen = [[-1]*W for _ in range(H)]
seen[si][sj] = 0
while queue:
x = queue.popleft()
y = queue.popleft()
for i in range(4):
nx = x + vx[i]
ny = y + vy[i]
if nx<0 or nx>=H or ny<0 or ny>=W:
continue
if S[nx][ny]=="#" or seen[nx][ny]>=0:
continue
seen[nx][ny]=seen[x][y]+1
queue.append(nx)
queue.append(ny)
return seen[x][y]
ans = 0
for i in range(H):
for j in range(W):
if S[i][j]==".":
ans = max(ans, func(i, j))
print(ans)
|
h, w = map(int, input().split())
s = [input() for _ in range(h)]
def bfs(x, y):
q = []
dp = {}
def qpush(x, y, t):
if 0 <= x < w and 0 <= y < h and s[y][x] != '#' and (x, y) not in dp:
q.append((x, y))
dp[(x, y)] = t
qpush(x, y, 0)
while len(q) > 0:
(x, y) = q.pop(0)
qpush(x + 1, y, dp[(x, y)] + 1)
qpush(x, y - 1, dp[(x, y)] + 1)
qpush(x - 1, y, dp[(x, y)] + 1)
qpush(x, y + 1, dp[(x, y)] + 1)
return dp.get((x, y), 0)
t = 0
for y in range(h):
for x in range(w):
t = max(t, bfs(x, y))
print(t)
| 1 | 94,746,713,587,808 | null | 241 | 241 |
import sys
readline = sys.stdin.readline
sys.setrecursionlimit(10**8)
#mod = 10**9+7
#mod = 998244353
#INF = 10**18
#eps = 10**-7
def main():
N,K = map(int,readline().split())
A = list(map(int,readline().split()))
F = list(map(int,readline().split()))
A.sort()
F.sort(reverse=True)
ng = -1
ok = 10**12+100
while ok - ng > 1:
mid = (ok + ng) // 2
if sum(max(0,a-mid//f) for a,f in zip(A,F)) <= K:
ok = mid
else:
ng = mid
print(ok)
if __name__ == '__main__':
main()
|
import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")
n,k = list(map(int, input().split()))
a = list(map(int, input().split()))
f = list(map(int, input().split()))
a.sort()
f.sort(reverse=True)
def sub(x):
val = 0
for aa,ff in zip(a,f):
val += max(0, aa - (x//ff))
return val<=k
if sub(0):
ans = 0
else:
l = 0
r = sum(aa*ff for aa,ff in zip(a,f))
while l+1<r:
m = (l+r)//2
if sub(m):
r = m
else:
l = m
ans = r
print(ans)
| 1 | 165,353,648,592,472 | null | 290 | 290 |
N = int(input())
def solve(N):
fib = [1]*(N+1)
for i in range(2,N+1):
fib[i] = fib[i-1] + fib[i-2]
ans = fib[N]
return ans
print(solve(N))
|
def Fibonacci(n):
if n == 0 or n == 1:
dic[n] = 1
if n in dic.keys():
return dic[n]
dic[n] = Fibonacci(n-1) + Fibonacci(n-2)
return dic[n]
a = int(input())
dic ={}
print(Fibonacci(a))
| 1 | 1,799,174,442 | null | 7 | 7 |
# DP ver
import sys
input = sys.stdin.readline
def main():
X = int(input())
dp = [0] * (X+1)
dp[0] = 1
for base in range(100, X+1):
can_buy = False
for fraction in range(6):
pre_cost = base - (100 + fraction)
if dp[pre_cost] == 1:
can_buy = True
break
if can_buy:dp[base] = 1
print(dp[-1])
if __name__ == "__main__":
main()
|
N=int(input())
b=0
x = N //100
for y in range(100*x,105*x+1):
if N==y:
print(1)
exit()
print(0)
| 1 | 127,109,321,161,732 | null | 266 | 266 |
import sys
def input(): return sys.stdin.readline().strip()
def mapint(): return map(int, input().split())
sys.setrecursionlimit(10**9)
N = int(input())
ans = 0
if N%2==1:
print(0)
exit(0)
for i in range(1, 40):
cnt = N//(5**i)
ans += cnt//2
print(ans)
|
s = input()
s = '0' + s[::-1]
dp = [[0, 0] for _ in range(len(s) + 1)]
for i in range(len(s)):
for j in range(2):
if j == 0: #ぴったり
dp[i + 1][j] = min(dp[i]) + int(s[i])
else: #1枚多めに払う
dp[i + 1][j] = min(dp[i][1] + 9 - int(s[i]), dp[i][0] + 11 - int(s[i]))
print(min(dp[-1]))
| 0 | null | 93,575,234,787,868 | 258 | 219 |
N, K = map(int, input().split())
ans = 0
mod = 10 ** 9 + 7
for k in range(K, N + 2):
max_range = int(k * (2 * N - k + 1) / 2)
min_range = int((k-1) * k / 2)
tmp = (max_range - min_range + 1) % mod
ans += tmp
ans %= mod
print(ans)
|
N,K=map(int, input().split())
sum_ = 0
for k in range(K, N+2):
sum_ += k*(N-k+1)+1
sum_ = sum_ % (10**9+7)
print(sum_)
| 1 | 32,952,527,250,720 | null | 170 | 170 |
def main():
n = int(input())
a = list(map(int, input().split()))
dp = [-10**15]*(n+1)
dp[2] = max(a[0], a[1])
if n > 2:
dp[3] = max(a[:3])
aa = a[0]+a[2]
for i in range(4, n+1):
if i%2:
aa += a[i-1]
dp[i] = max(dp[i-1], dp[i-2]+a[i-1])
else:
dp[i] = max(aa, dp[i-2]+a[i-1])
print(dp[n])
if __name__ == "__main__":
main()
|
N = int(input())
S = [""]*N
Dict={}
ac=0
wa =0
tle =0
re=0
for i in range(N):
S[i] = str(input())
for j in S:
if j in Dict:
temp = Dict[j]
Dict[j] = temp + 1
else:
Dict[j] = 1
if "AC" in Dict:
ac = Dict["AC"]
if "WA" in Dict:
wa = Dict["WA"]
if "TLE" in Dict:
tle = Dict["TLE"]
if "RE" in Dict:
re = Dict["RE"]
print("AC x " , ac)
print("WA x " , wa)
print("TLE x " , tle)
print("RE x " , re)
| 0 | null | 23,015,329,605,462 | 177 | 109 |
from statistics import median
#import collections
#aa = collections.Counter(a) # list to list || .most_common(2)で最大の2個とりだせるお a[0][0]
from fractions import gcd
from itertools import combinations # (string,3) 3回
from collections import deque
from collections import defaultdict
import bisect
#
# d = m - k[i] - k[j]
# if kk[bisect.bisect_right(kk,d) - 1] == d:
#
#
#
# pythonで無理なときは、pypyでやると正解するかも！！
#
#
import sys
sys.setrecursionlimit(10000000)
mod = 10**9 + 7
def readInts():
return list(map(int,input().split()))
def main():
s = input()
if s[2] == s[3] and s[4] == s[5]:
print('Yes')
else:
print('No')
if __name__ == '__main__':
main()
|
s = input()
print("Yes" if s[2] == s[3] and s[4] == s[5] else "No")
| 1 | 41,887,390,620,812 | null | 184 | 184 |
from collections import deque
import sys
n = int(input())
if n == 1:
print('a')
sys.exit()
q = deque([])
q.append((1, 'a', '1'))
cur = 1
while cur != n:
num = len(q)
j = 0
while j < num:
a, b, c = q.popleft()
for i in range(1, max(map(int, list(c)))+2):
q.append((i, b + chr(96+i), c + str(i)))
j += 1
cur += 1
for i in range(len(q)):
a, b, c = q.popleft()
print(b)
|
n = int(input())
s = ['a']*(n)
#print(''.join(s))
def dfs(x,alp):
if x == n:
print(''.join(s))
return
for i in range(alp+1):
#print(x,alp,i)
s[x] = chr(i+ord("a"))
dfs(x+1,max(i+1,alp))
#print(alp)
dfs(0,0)
| 1 | 52,385,655,953,632 | null | 198 | 198 |
X, K, D = map(int,input().split())
res = 0
X = abs(X)
if X >= K * D:
res = X - K * D
else:
i = X // D
j = K - i
if j % 2 == 0:
res = X - D * i
else:
res = X - D * (i + 1)
print(abs(res))
|
# encoding:utf-8
import math
r = float(input())
area = r**2*math.pi
circumference = r * 2 * math.pi
area = ('%03.6f' % area)
circumference = ('%03.6f' % circumference)
print(area),
print(circumference)
| 0 | null | 2,889,258,774,304 | 92 | 46 |
n,k=map(int,input().split())
h=list(map(int,input().split()))
h.sort(reverse=1)
ans=0
for i in h:
if i>=k:ans+=1
print(ans)
|
while True:
H,W=map(int,raw_input().split())
if H==W==0:
break
elif H!=0 or W!=0:
print (('#'*W +'\n')*H)
| 0 | null | 89,837,019,511,708 | 298 | 49 |
from math import ceil
H, K = list(map(int, input().split()))
print(ceil(H/K))
|
import sys
from itertools import count
H, A = map(int, next(sys.stdin.buffer).split())
for i in count(1):
H -= A
if H <= 0:
break
print(i)
| 1 | 77,119,714,171,120 | null | 225 | 225 |
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():
a,b,n = rl()
if n >= b:
ans = (a * (b - 1)) // b - a * ((b - 1) // b)
else:
ans = a * n // b
print (ans)
mode = 's'
if mode == 'T':
t = ri()
for i in range(t):
solve()
else:
solve()
|
import sys
input = sys.stdin.readline
mod = 10**9 + 7
def main():
n = int(input())
A = list(map(int, input().split()))
candidates = [0] * (n+1)
candidates[0] = 3
ans = 1
for a in A:
ans *= candidates[a]
ans %= mod
candidates[a] -= 1
candidates[a+1] += 1
print(ans)
if __name__ == "__main__":
main()
| 0 | null | 79,058,427,003,280 | 161 | 268 |
s = input()
n = int(input())
ans = ''
i = 0
while i < n:
order = list(map(str, input().split(' ')))
if order[0] == 'print':
ans += s[int(order[1]):int(order[2])+1] + '\n'
elif order[0] == 'reverse':
i1 = int(order[1])
i2 = int(order[2])
s0 = s[:i1]
j = 0
while j < (i2 - i1 + 1):
s0 += s[i2 - j]
j += 1
s0 += s[i2+1:]
s = s0
else:
i1 = int(order[1])
i2 = int(order[2])
s = s[:i1] + order[3] + s[i2+1:]
i += 1
print(ans[:-1])
|
in_str = raw_input()
q = input()
for i in xrange(q):
order = raw_input().split()
a = int(order[1])
b = int(order[2])+1
if order[0] == "print":
print in_str[a:b]
if order[0] == "reverse":
temp_str = in_str[a:b]
in_str = in_str[:a] + temp_str[::-1] + in_str[b:]
if order[0] == "replace":
in_str = in_str[:a] + order[3] + in_str[b:]
| 1 | 2,118,433,842,418 | null | 68 | 68 |
n = int(input())
a = list(map(int,input().split()))
ans = "APPROVED"
for i in range(n):
if(a[i]%2==0)and((a[i]%3!=0)and(a[i]%5!=0)):
ans = "DENIED"
break
print(ans)
|
N=input()
I=list(map(int,input().split()))
E=list(filter(lambda x:x%2==0,I))
if len(E)==0:
print('APPROVED')
else:
O=list(filter(lambda r:r%3!=0 and r%5!=0,E))
if len(O)==0:
print('APPROVED')
else:
print('DENIED')
| 1 | 68,830,837,348,170 | null | 217 | 217 |
a,b = (int(x) for x in input().split())
if 0 < a < 10 and 0 < b < 10:
print(a*b)
else:
print(-1)
|
a,b=map(int, input().split())
if max(a,b)>9:
print("-1")
else:
print( a*b )
| 1 | 158,294,623,611,620 | null | 286 | 286 |
from collections import defaultdict
N=int(input())
S=input()
d = defaultdict(list)
for i in range(N):
d[int(S[i])].append(i)
ans = 0
for n1 in range(10):
if not d[n1]:continue
for n2 in range(10):
if not d[n2]:continue
if d[n1][0]>d[n2][-1]: continue
for n3 in range(10):
if not d[n3]:continue
if d[n1][0]>d[n3][-1] or d[n2][0]>d[n3][-1]:continue
for idx in d[n2]:
if idx>d[n1][0] and idx<d[n3][-1]:
ans += 1
break
print(ans)
|
X = int(input())
if X <= 599:
print(8)
elif X <= 799:
print(7)
elif X <= 999:
print(6)
elif X <= 1199:
print(5)
elif X <= 1399:
print(4)
elif X <= 1599:
print(3)
elif X <= 1799:
print(2)
elif X <= 1999:
print(1)
| 0 | null | 67,685,827,239,644 | 267 | 100 |
def main():
import sys
from collections import defaultdict
input = sys.stdin.readline
K = int(input())
S = len(input().strip())
mod = 10 ** 9 + 7
fact = [1] * (K + S + 1)
invfact = [1] * (K + S + 1)
for i in range(K + S):
fact[i+1] = (fact[i] * (i+1)) % mod
invfact[-1] = pow(fact[-1], mod-2, mod)
for i in range(K + S):
invfact[-2-i] = (invfact[-1-i] * (K + S - i)) % mod
def nCr(n, r):
if r == n or r == 0:
return 1
r = min(r, n - r)
return (fact[n] * invfact[n-r] * invfact[r]) % mod
ans = 0
for i in range(K+1):
ans += pow(25, i, mod) * nCr(i+S-1, S-1) * pow(26, K-i, mod)
ans %= mod
print(ans)
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()]
_LI = lambda : [int(x)-1 for x in sys.stdin.readline().split()]
NI = lambda : int(sys.stdin.readline())
SI = lambda : sys.stdin.readline().rstrip()
N = [0] + list(map(int,SI()))
ans = 0
for i in range(len(N)-1,-1,-1):
if N[i] < 6 and not(N[i] == 5 and (i > 0 and N[i-1] >= 5)):
ans += N[i]
else:
ans += 10 - N[i]
N[i-1] += 1
print(ans)
if __name__ == '__main__':
main()
| 0 | null | 41,906,890,554,320 | 124 | 219 |
import sys
sys.setrecursionlimit(10**9)
def mi(): return map(int,input().split())
def ii(): return int(input())
def isp(): return input().split()
def deb(text): print("-------\n{}\n-------".format(text))
INF=10**20
def main():
A,B=mi()
print(max(0,A-2*B))
if __name__ == "__main__":
main()
|
def main():
a,b = list(map(int, input().split()))
ans = a - 2*b
ans = 0 if ans < 0 else ans
print(ans)
if __name__ == '__main__':
main()
| 1 | 166,129,015,662,432 | null | 291 | 291 |
import queue
n,u,v = map(int, input().split())
u -= 1
v -= 1
path = [[] for i in range(n)]
for i in range(n-1):
a,b = map(int, input().split())
a -= 1
b -= 1
path[a].append(b)
path[b].append(a)
t = [10**9]*n
t[u]=0
q = queue.Queue()
q.put(u)
while not q.empty():
p = q.get()
for x in path[p]:
if t[x]>t[p]+1:
q.put(x)
t[x]=t[p]+1
a = [10**9]*n
a[v]=0
q = queue.Queue()
q.put(v)
while not q.empty():
p = q.get()
for x in path[p]:
if a[x]>a[p]+1:
q.put(x)
a[x]=a[p]+1
c = [a[i] for i in range(n) if a[i]>t[i]]
print(max(c)-1)
|
# coding: utf-8
n = int(input())
R = [ int(input()) for i in range(n)]
MIN = R[0]
MAXdiff = R[1]-R[0]
for i in range(1,n):
MAXdiff = max(MAXdiff,R[i]-MIN)
MIN = min(MIN,R[i])
print(MAXdiff)
| 0 | null | 58,557,877,026,010 | 259 | 13 |
N,K = list(map(int, input().split()))
A = [int(i) for i in input().split()]
for i in range(K,N):
if A[i] > A[i-K]:
print("Yes")
else:
print("No")
|
n,k=[int(x) for x in input().split()]
a=[int(x) for x in input().split()]
for i in range(n-k):
if a[i]<a[i+k]:
print("Yes")
else:
print("No")
| 1 | 7,116,347,805,232 | null | 102 | 102 |
# B - Iron Bar Cutting
N = int(input())
A = list(map(int, input().split()))
left = 0
right = sum(A)
ans = right
for a in A:
left += a
right -= a
diff = abs(right - left)
ans = min(ans, diff)
if left > right:
break
print(ans)
|
N = int(input())
A = list(map(int,input().split()))
LEFT = A[0]
RIGHT = sum(A[1:])
MIN = abs(LEFT-RIGHT)
for i in range(1,N-1):
LEFT += A[i]
RIGHT -= A[i]
MIN = min(MIN,abs(LEFT-RIGHT))
print(MIN)
| 1 | 142,487,590,343,250 | null | 276 | 276 |
n=int(input())
C = list(input())
ans = 0
N = n-1
for l in range(n):
if C[l] == "W":
for r in range(N,0,-1):
if r<=l:
print(ans)
exit()
if C[r] == "R":
#print(C)
C[l] = "R"
C[r] = "W"
#print(C)
#print("-----------------")
ans += 1
N = r-1
break
print(ans)
|
n=int(input())
c=input()
a=0
i=0
j=len(c)-1
while(i<j):
while(c[i]=="R" and i<j):
i+=1
while(c[j]=="W" and i<j):
j-=1
if i<j:
a+=1
i+=1
j-=1
print(a)
| 1 | 6,361,514,348,852 | null | 98 | 98 |
from itertools import combinations
n = int(input())
def dfs(s):
if len(s) == n:
print(s)
return 0
for i in range(ord('a'), ord(max(s))+2):
t = s
t += chr(i)
dfs(t)
dfs('a')
|
n = int(input())
def dfs(s, i):
if i == n:
print(s)
else:
for j in range(ord("a"), max(map(ord, list(s))) + 2):
dfs(s + chr(j), i + 1)
dfs("a", 1)
| 1 | 52,308,966,011,610 | null | 198 | 198 |
def main():
n = int(input())
even = n // 2
print(1 - even / n)
if __name__ == "__main__":
main()
|
n = input()
mod = 0
for i in range(len(n)):
mod += int(n[i])
mod %= 9
print("Yes") if mod == 0 else print("No")
| 0 | null | 90,978,298,139,620 | 297 | 87 |
N,A,B = map(int, input().split())
div, mod = divmod(N, A+B)
print(div*A + min(mod,A))
|
n = int(input())
z = list()
w = list()
for i in range(n):
x,y = list(map(int,input().split()))
z.append(x + y)
w.append(x - y)
ans = max(max(z) - min(z),max(w)-min(w))
print(ans)
| 0 | null | 29,340,318,300,172 | 202 | 80 |
s=raw_input().strip()
print s+('es' if s[-1]=='s' else 's')
|
MOD=10**9+7
N=int(input())
ans=pow(10,N,MOD)
ans-=2*pow(9,N,MOD)
ans+=pow(8,N,MOD)
ans%=MOD
print(ans)
| 0 | null | 2,739,126,994,328 | 71 | 78 |
N=int(input())
S=[]
T=[]
total=0
for i in range(N):
s,t=map(str,input().split())
t=int(t)
total+=t
S.append(s)
T.append(t)
X=input()
flag=True
a=0
j=0
while flag:
a+=T[j]
if S[j]==X:
flag=False
j+=1
print(total-a)
|
N=int(input())
s=[]
t=[]
for i in range(N):
x,y=input().split()
s.append(x)
t.append(int(y))
X=input()
begin_idx=s.index(X)+1
print(sum(t[begin_idx:]))
| 1 | 96,712,003,352,448 | null | 243 | 243 |
n, q = map(int, input().split())
l = []
for i in range(n):
t = []
for j in input().split():
t += [j]
t[1] = int(t[1])
l += [t]
c = 0
while len(l) > 0:
if l[0][1] > q:
l[0][1] -= q
l += [l[0]]
l.pop(0)
c += q
else:
c += l[0][1]
print(l[0][0], c)
l.pop(0)
|
import sys
from collections import deque
def m():
s=sys.stdin.readlines()
q=int(s[0].split()[1])
f=lambda x,y:(x,int(y))
d=deque(f(*e.split())for e in s[1:])
t,a=0,[]
while d:
k,v=d.popleft()
if v>q:v-=q;t+=q;d.append([k,v])
else:t+=v;a+=[f'{k} {t}']
print('\n'.join(a))
if'__main__'==__name__:m()
| 1 | 40,971,189,600 | null | 19 | 19 |
n = int(input())
count = 0
room = [int(0) for i in range(4) for j in range(3) for k in range(10)]
while count < n:
x = list(map(lambda k: int(k), input().split(" ")))
room[(x[0]-1)*30+(x[1]-1)*10+(x[2]-1)] += x[3]
count += 1
for i in range(4):
if i != 0:
print("####################")
for j in range(3):
for k in range(10):
print(" %d" % room[30*i+10*j+k], end="")
print("")
|
nb=4
nf=3
nr=10
d = {}
n = int(input())
for i in range(n):
[b,f,r,v] = map(int, input().split())
key = "%2d %2d %2d" % (b,f,r)
if key in d:
d[key] += v
else:
d[key] = v
for b in range(1,nb+1):
for f in range(1,nf+1):
for r in range(1,nr+1):
key = "%2d %2d %2d" % (b,f,r)
if key in d:
print(" "+str(d[key]),end="")
else:
print(" "+str(0),end="")
if r==nr:
print()
if r==nr and f==nf and b != nb:
print('####################')
| 1 | 1,110,061,273,888 | null | 55 | 55 |
n = int(input())
a = []
for i in range(n):
s,t = map(str, input().split())
t = int(t)
a.append([s,t])
x = input()
a.reverse()
ss = 0
for i in range(n):
if a[i][0] == x:
print (ss)
exit()
ss += a[i][1]
print (ss)
|
import sys
input = sys.stdin.readline
def main():
n,a,b = [int(i) for i in input().strip().split()]
if (b-a) % 2 == 0:
print(abs(b - a) // 2)
else:
ans = min(a - 1, n - b) + 1 + (b - a - 1) // 2
print(ans)
return
if __name__ == "__main__":
main()
| 0 | null | 103,103,756,225,440 | 243 | 253 |
import numpy as np
def divisors(N):
return sorted(sum((list({n, N // n}) for n in range(1, int(N ** 0.5) + 1) if not N % n), []))
def prime_factorize_dict(n):
d = dict()
while not n & 1:
d[2] = d.get(2, 0) + 1
n >>= 1
f = 3
while f * f <= n:
if not n % f:
d[f] = d.get(f, 0) + 1
n //= f
else:
f += 2
if n != 1:
d[n] = d.get(n, 0) + 1
return d
N = int(input())
count = 0
for n in divisors(N)[1:]:
M = N
while not M % n:
M //= n
count += M % n == 1
fact_Nm1 = np.array(list(prime_factorize_dict(N - 1).values()), dtype=np.int32)
print(count + np.prod(fact_Nm1 + 1) - 1)
|
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
n = int(input())
ans = len(make_divisors(n - 1))
divisors = []
for i in make_divisors(n):
j = n
if i != 1:
while j % i == 0:
j //= i
if (j - 1) % i == 0:
divisors.append(i)
print(ans + len(divisors) - 1)
| 1 | 41,562,068,385,778 | null | 183 | 183 |
import collections
N = int(input())
A = [0] * N
B = [0] * N
for i in range(N):
a, b = map(int, input().split())
A[i] = a
B[i] = b
A.sort()
B.sort()
N_q, N_mod = divmod(N, 2)
if N_mod == 1:
ans = B[N_q] - A[N_q] + 1
else:
ans = B[N_q - 1] - A[N_q - 1] + B[N_q] - A[N_q] + 1
print(ans)
|
n = int(input())
a = list(map(int,input().split()))
cumsum_a = a.copy()
for i in range(n-1, -1, -1):
cumsum_a[i] += cumsum_a[i+1]
ans = 0
childable_node = 1
for i in range(n + 1):
if a[i] > childable_node:
ans = -1
break
ans += childable_node
if i < n:
b_max1 = 2 * (childable_node - a[i])
b_max2 = cumsum_a[i + 1]
childable_node = min(b_max1, b_max2)
print(ans)
| 0 | null | 18,080,663,662,920 | 137 | 141 |
a = map(int, raw_input().split())
j = 0
for i in xrange(a[0], a[1]+1):
j=j if a[2] % i else j+1
print j
|
a, b, c = map(int, raw_input().split())
n = a
count = 0
while True:
x = c % n
if x == 0:
count += 1
if n == b:
break
else:
n += 1
print count
| 1 | 548,648,172,280 | null | 44 | 44 |
import math
N=int(input())
def era(n):
prime=[]
furui=list(range(2,n+1))
while furui[0]<math.sqrt(n):
prime.append(furui[0])
furui=[i for i in furui if i%furui[0]!=0]
return prime+furui
furui=era(10**6+7)
minfac=list(range(10**6+8))
for i in furui:
for j in range(i,(10**6+7)//i+1):
if minfac[i*j]==i*j:
minfac[i*j]=i
ans=0
for i in range(1,N):
temp=1
temp2=1
l=1
while i != 1:
if minfac[i]!=l:
temp*=temp2
temp2=2
else:
temp2+=1
l=minfac[i]
i//=l
temp*=temp2
ans+=temp
print(ans)
|
M = 10 ** 6
d = [0] * (M+1)
for a in range(1, M+1):
for b in range(a, M+1):
n = a * b
if n > M:
break
d[n] += 2 - (a==b)
N = int(input())
ans = 0
for c in range(1, N):
ans += d[N - c]
print(ans)
| 1 | 2,583,301,962,260 | null | 73 | 73 |
n = int(input())
aas = list(map(int, input().split()))
arr = [0]*(10**5+1)
res = 0
for i in aas:
arr[i] += 1
res += i
q = int(input())
for i in range(q):
b,c = map(int, input().split())
res += (c-b)*arr[b]
print(res)
arr[c] += arr[b]
arr[b] = 0
|
from collections import Counter
n = int(input())
a = list(map(int, input().split()))
q = int(input())
counter = Counter(a)
sum_res = sum(a) # はじめの合計、名前がsumだとsum関数とかぶってよくないので
# q回操作します。ループ変数は使わないので_とします（Pythonの慣習）
for _ in range(q):
before, after = map(int, input().split())
# 合計を変更します
sum_res -= before * counter[before]
sum_res += after * counter[before]
# 個数を変更します
counter[after] += counter[before]
counter[before] = 0
print(sum_res)
| 1 | 12,132,884,943,520 | null | 122 | 122 |
def fibonacci(n, memo=None):
if memo==None:
memo = [None]*n
if n<=1:
return 1
else:
if memo[n-2]==None:
memo[n-2] = fibonacci(n-2, memo)
if memo[n-1]==None:
memo[n-1] = fibonacci(n-1, memo)
return memo[n-1] + memo[n-2]
n = int(input())
print(fibonacci(n))
|
#coding:UTF-8
def FN(n):
if n==0 or n==1:
F[n]=1
return F[n]
if F[n]!=None:
return F[n]
F[n]=FN(n-1)+FN(n-2)
return F[n]
if __name__=="__main__":
n=int(input())
F=[None]*(n+1)
ans=FN(n)
print(ans)
| 1 | 2,052,539,540 | null | 7 | 7 |
from math import sqrt
N = int(input())
search_max = int(sqrt(N))
min_number = 10**12
for x in range(1, search_max + 1):
if N % x == 0:
y = N // x
if x + y < min_number:
min_number = x + y
print(min_number-2)
|
N = int(input())
p = 1
for i in range(1,int(N**0.5+1)):
if N%i == 0:
p = i
print(p+N//p-2)
| 1 | 161,551,370,746,190 | null | 288 | 288 |
N = int(input())
res = 0
for i in range(int(N**0.5)):
if(N % (i+1) == 0):
res = max(res, i+1)
print((res-1) + (N//res-1))
|
import math
a, b, C = map(float, input().split())
S = (a * b * math.sin(math.radians(C))) / 2
L = a + b + (math.sqrt(a**2 + b**2 - 2*a*b*math.cos(math.radians(C))))
h = b * math.sin(math.radians(C))
print("{:.8f}".format(S))
print("{:.8f}".format(L))
print("{:.8f}".format(h))
| 0 | null | 81,205,778,560,650 | 288 | 30 |
roop_num = int(input())
xy = [map(int, input().split()) for _ in range(roop_num)]
x, y = [list(i) for i in zip(*xy)]
z_counter = 0
flg = False
for i in range(roop_num):
if(x[i] == y[i]):
z_counter = z_counter +1
else:
z_counter = 0
if(z_counter == 3):
flg = True
break
if(flg):
print("Yes")
else:
print("No")
|
n = int(input())
s = 0
b = False
for _ in range(n):
w = input().split()
if w[0] == w[1]:
s += 1
if s == 3:
b = True
break
else:
s = 0
print('Yes' if b else 'No')
| 1 | 2,492,424,015,834 | null | 72 | 72 |
x,n = map(int,input().split())
if n == 0:
print(x)
else:
p = list(map(int,input().split()))
k = [i for i in range(-200,201)]
for i in range(n):
if p[i] in set(k):
k.remove(p[i])
minimum = 99999
ans = 0
for i in range(len(k)):
if abs(k[i] - x ) < minimum :
minimum = abs(k[i] - x)
ans = k[i]
print(ans)
|
x, n = map(int,input().split())
L = list(map(int,input().split()))
if n == 0 or x not in L:
print(x)
exit()
for i in range(102):
if (x-i) not in L:
print(x-i)
break
elif (x+i) not in L:
print(x+i)
break
| 1 | 13,981,758,770,090 | null | 128 | 128 |
# coding: utf-8
num_array = [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("{}".format(num_array[k-1]))
|
s = input()
for _ in range(int(input())):
code=input().split()
if code[0]=='print' :
print("".join(s[int(code[1]):int(code[2])+1]))
elif code[0]=='reverse':
s = s[:int(code[1])] + s[int(code[1]):int(code[2])+1][::-1] + s[int(code[2])+1:]
elif code[0]=='replace':
s = s[:int(code[1])] + code[3] + s[int(code[2])+1:]
| 0 | null | 26,210,047,798,870 | 195 | 68 |
def warshall_floid(d):
for k in range(1,n+1):
for i in range(1,n+1):
for j in range(1,n+1):
d[i][j] = min(d[i][j],d[i][k]+d[k][j])
return d
n,m,l = map(int,input().split())
d = [[10**13]*(n+1) for i in range(n+1)]
for i in range(m):
a,b,c = map(int,input().split())
d[a][b] = c
d[b][a] = c
for i in range(1,n+1):
d[i][i] = 0
d = warshall_floid(d)
for i in range(1,n+1):
for j in range(1,n+1):
if d[i][j] <= l:
d[i][j] = 1
else:
d[i][j] = 10**13
d = warshall_floid(d)
q = int(input())
for i in range(q):
s,t = map(int,input().split())
if d[s][t] >= 10**13:
print(-1)
else:
print(d[s][t]-1)
|
import sys
input = sys.stdin.readline
def main():
N, M, L = map(int, input().split())
dist = [[float('inf')] * N for _ in range(N)]
for _ in range(M):
A, B, C = map(int, input().split())
if C > L:
continue
A -= 1
B -= 1
dist[A][B] = C
dist[B][A] = C
for k in range(N):
for i in range(N):
for j in range(N):
dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j])
e = [[float('inf')] * N for _ in range(N)]
for i in range(N):
for j in range(N):
if dist[i][j] <= L:
e[i][j] = 1
for k in range(N):
for i in range(N):
for j in range(N):
e[i][j] = min(e[i][j], e[i][k] + e[k][j])
Q = int(input())
for _ in range(Q):
s, t = map(int, input().split())
s -= 1
t -= 1
if e[s][t] == float('inf'):
print(-1)
continue
ans = e[s][t]
print(ans-1)
if __name__ == "__main__":
main()
| 1 | 173,588,965,057,152 | null | 295 | 295 |
x, y = map(int, input().split())
mod = 10**9 + 7
if (2*x-y)%3 == 0 and (2*y-x)%3 == 0 and 2*x-y >= 0 and 2*y-x >= 0:
u = (2*x-y)//3
v = (2*y-x)//3
n = u + v
x = 1
y = 1
for i in range(u):
x = x*(n-i)%mod
y = y*(i+1)%mod
print((x * pow(y, mod-2, mod))%mod)
else:
print(0)
|
ii = lambda : int(input())
mi = lambda : map(int,input().split())
li = lambda : list(map(int,input().split()))
class com:
def __init__(self,max, mod = 1000000007):
self.fac = [0] * max
self.inv = [0] * max
self.finv = [0] * max
self.mod = mod
self.fac[0] = self.fac[1] = 1
self.finv[0] = self.finv[1] = 1
self.inv[1] = 1
for i in range(2,max):
self.fac[i] = self.fac[i-1] * i % mod
self.inv[i] = mod - self.inv[mod%i] * (mod//i) % mod
self.finv[i] = self.finv[i-1] * self.inv[i] % mod
def com(self, n, k):
if n < k: return 0
if n < 0 or k < 0: return 0
return self.fac[n] * (self.finv[k] * self.finv[n - k] % self.mod) % self.mod
def main():
x,y = mi()
if (x+y) % 3 != 0:
print(0)
return
step = (x+y)//3
if x < step or y < step:
print(0)
return
c = com(step+1)
ans = c.com(step, x - step)
print(ans)
main()
| 1 | 149,929,245,959,940 | null | 281 | 281 |
def is_prime(n):
if n == 2: return True
if n < 2 or n % 2 == 0: return False
return pow(2, n - 1, n) == 1
count = 0
for i in range(int(input())):
if is_prime(int(input())) : count += 1
print(count)
|
x,y,a,b,c = map(int,input().split())
p = list(map(int,input().split()))
q = list(map(int,input().split()))
r = list(map(int,input().split()))
from collections import deque
p = sorted(p)[a-x:]
q = sorted(q)[b-y:]
t = deque(sorted(p+q))
r = deque(reversed(sorted(r)))
# print(t,r)
while r:
if t[0] < r[0]:
t.popleft()
w = r.popleft()
t.append(w)
else:
break
ans = sum(t)
print(ans)
| 0 | null | 22,315,964,949,690 | 12 | 188 |
import math
a,b = map(int,input().split())
def lcm(a,b):
y = a*b / math.gcd(a,b)
return int(y)
print(lcm(a,b))
|
a,b=map(int,input().split())
#a,bの最大公約数
def gcd(a,b):
if(b==0):
return a
else:
return gcd(b, a%b)
#a,bの最小公倍数
def lcm(a,b):
return a*b//gcd(a,b)
print(lcm(a,b))
| 1 | 113,087,237,497,500 | null | 256 | 256 |
import os
import sys
if os.getenv("LOCAL"):
sys.stdin = open("_in.txt", "r")
sys.setrecursionlimit(10 ** 9)
INF = float("inf")
IINF = 10 ** 18
MOD = 10 ** 9 + 7
# MOD = 998244353
t1, t2 = list(map(int, sys.stdin.buffer.readline().split()))
a1, a2 = list(map(int, sys.stdin.buffer.readline().split()))
b1, b2 = list(map(int, sys.stdin.buffer.readline().split()))
da1 = t1 * a1
da2 = t2 * a2
db1 = t1 * b1
db2 = t2 * b2
if da1 + da2 > db1 + db2:
a1, b1 = b1, a1
a2, b2 = b2, a2
da1, db1 = db1, da1
da2, db2 = db2, da2
# b のほうがはやい
# 無限
if da1 + da2 == db1 + db2:
print('infinity')
exit()
# 1回も会わない
if da1 < db1:
print(0)
exit()
# t1 で出会う回数
cnt = abs(da1 - db1) / abs(da1 + da2 - db1 - db2)
ans = int(cnt) * 2 + 1
if cnt == int(cnt):
ans -= 1
print(ans)
|
from collections import defaultdict,deque
n = int(input())
d = defaultdict(list)
l = []
for i in range(n-1):
a,b = map(int,input().split())
d[a].append(b)
d[b].append(a)
l.append((a,b))
# print(d)
que = deque([a])
visited = [-1] + [False]*n
visited[a] = True
preans = defaultdict(list)
ans = defaultdict(int)
maxi = 1
while que:
v = que.popleft()
cnt = 1
for x in d[v]:
if not visited[x]:
while cnt in preans[v]:
cnt += 1
maxi = max(maxi,cnt)
preans[x].append(cnt)
ans[(v,x)] = cnt
ans[(x,v)] = cnt
que.append(x)
visited[x] = True
cnt += 1
# print(preans)
# print(ans)
print(maxi)
for i in l:
print(ans[i])
| 0 | null | 133,659,221,409,402 | 269 | 272 |
num = raw_input()
num_list = []
for i in range(int(num)):
a = raw_input()
num_list.append(int(a))
min_ans = num_list[0]
max_ans = float("-inf")
for i in num_list[1:]:
if i - min_ans > max_ans:
max_ans = i - min_ans
if i < min_ans:
min_ans = i
print max_ans
|
#cording by utf-8
n = int(input())
#maxv ?????§???
#minv ????°????
minv = int(input()) #?????????????°????
#print("minv",minv)
maxp = int(input()) #??????????????§???
maxp = maxp - minv
if maxp + minv < minv:
minv = maxp + minv
for i in range(2,n):
stock = int(input())
if minv > stock:
minv = stock
#print("minv",minv)
else:
profit = stock - minv
if profit > maxp:
maxp = profit
#print("maxp",maxp)
print(maxp)
| 1 | 14,006,106,020 | null | 13 | 13 |
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 = "")
|
n = int(input())
if n%2 == 1:
print(0)
exit()
point = 0
now = 10
while now <= n:
point += n//now
now *= 5
print(point)
| 0 | null | 65,192,257,545,842 | 130 | 258 |
N,K=map(int,input().split())
A=list(map(int,input().split()))
a=A[:]
for _ in range(K):
t=[0]*(N+1)
for i in range(N):
ti=a[i]
t[max(0,i-ti)]+=1
t[min(N,i+ti+1)]-=1
for i in range(N):
t[i+1]+=t[i]
a=t[:N]
if min(a)==N:
break
print(*a)
|
# https://atcoder.jp/contests/tokiomarine2020/tasks/tokiomarine2020_c
N, K = map(int, input().split())
A = list(map(int, input().split()))
while K > 0:
K -= 1
# imos法 (B)
B = [0] * (N + 1)
for i in range(N):
l = max(0, i - A[i])
r = min(N - 1, i + A[i])
B[l] += 1
if r + 1 < N:
B[r + 1] -= 1
C = 0
for j in range(N):
C += B[j]
A[j] = C
if set(A) == set([N]):
break
print(*A)
| 1 | 15,512,118,281,000 | null | 132 | 132 |
print("Yes" if (lambda x: x[2] == x[3] and x[4] == x[5])(input()) else "No")
|
def main():
n = int(input())
a = list(map(int, input().split()))
a.append(-1)
num_kabu = 0
money = 1000
for i in range(0, n):
if a[i+1] >= a[i]:
num_kabu += money//a[i]
money %= a[i]
if a[i+1] <a[i]:
money += num_kabu*a[i]
num_kabu = 0
print(money)
if __name__ =="__main__":
main()
| 0 | null | 24,565,524,540,188 | 184 | 103 |
n = int(input())
s = input()
q = int(input())
class SegmentTree:
def __init__(self, a, func=max, one=-10 ** 18):
self.logn = (len(a) - 1).bit_length()
self.n = 1 << self.logn
self.func = func
self.one = one
self.b = [self.one] * (2 * self.n - 1)
for i, j in enumerate(a):
self.b[i + self.n - 1] = j
for i in reversed(range(self.n - 1)):
self.b[i] = self.func(self.b[i * 2 + 1], self.b[i * 2 + 2])
self.ll = []
self.rr = []
i = self.n
for _ in range(self.logn+1):
for j in range(0, self.n, i):
self.ll.append(j)
self.rr.append(j + i)
i //= 2
def get_item(self, i):
return self.b[i + self.n - 1]
def update(self, index, x):
i = index + self.n - 1
self.b[i] = x
while i != 0:
i = (i - 1) // 2
self.b[i] = self.func(self.b[i * 2 + 1], self.b[i * 2 + 2])
def update_func(self, index, x):
i = index + self.n - 1
self.b[i] = self.func(self.b[i], x)
while i != 0:
i = (i - 1) // 2
self.b[i] = self.func(self.b[i * 2 + 1], self.b[i * 2 + 2])
def get_segment(self, l, r, i=0):
ll = self.ll[i]
rr = self.rr[i]
if l <= ll and rr <= r:
return self.b[i]
elif rr <= l or r <= ll:
return self.one
else:
return self.func(self.get_segment(l, r, i * 2 + 1),
self.get_segment(l, r, i * 2 + 2))
def get_int(s):
abc = "abcdefghijklmnopqrstuvwxyz"
return 1 << abc.index(s)
seg = SegmentTree([get_int(i) for i in s], int.__or__, 0)
for _ in range(q):
q, i, j = input().split()
if q == "1":
seg.update(int(i) - 1, get_int(j))
else:
aa = seg.get_segment(int(i) - 1, int(j))
ans = 0
for i in range(26):
if (aa >> i) & 1 == 1:
ans += 1
print(ans)
|
#1indexed
class BIT():
def __init__(self, n):
self.size = n
self.bit = [0] * (n+1)
def sum(self, i):
s = 0
while i > 0:
s += self.bit[i]
i -= i & -i
return s
def add(self, i, x):
while i <= self.size:
self.bit[i] += x
i += i & -i
n = int(input())
s = input()
q = int(input())
bit = [BIT(n+1) for i in range(26)]
for i in range(n):
bit[ord(s[i])-97].add(i+1, 1)
s = list(s)
for _ in range(q):
query, a, b = input().split()
if query == "1":
i = int(a)
c = ord(b)-97
bit[c].add(i, 1)
bit[ord(s[i-1])-97].add(i, -1)
s[i-1] = b
else:
ans = 0
for k in range(26):
if bit[k].sum(int(b))-bit[k].sum(int(a)-1) >= 1:
ans += 1
print(ans)
| 1 | 62,253,188,084,856 | null | 210 | 210 |
SN=[5,1,2,6]
WE=[4,1,3,6]
def EWSN(d):
global SN,WE
if d == "S" :
SN = SN[3:4] + SN[0:3]
WE[3] = SN[3]
WE[1] = SN[1]
elif d == "N":
SN = SN[1:4] + SN[0:1]
WE[3] = SN[3]
WE[1] = SN[1]
elif d == "E":
WE = WE[3:4] + WE[0:3]
SN[3] = WE[3]
SN[1] = WE[1]
elif d == "W":
WE = WE[1:4] + WE[0:1]
SN[3] = WE[3]
SN[1] = WE[1]
dice = list(map(int,input().split(" ")))
op = input()
for i in op:
EWSN(i)
print(dice[SN[1] - 1])
|
d=input().split()
s={'N':"152304",'W':"215043",'E':"310542",'S':"402351"}
for o in input():
d=[d[int(i)]for i in s[o]]
print(d[0])
| 1 | 229,797,271,200 | null | 33 | 33 |
n = int(input())
print((n+1)//2)
|
n = int(input())
aas = list(map(int, input().split()))
cnts = [0]*(n+1)
for i in range(n):
cnts[aas[i]] += 1
t = 0
for i in range(1,n+1):
tmp = cnts[i]
t += tmp*(tmp-1)//2
for i in range(n):
tmp = cnts[aas[i]]
print(int(t-tmp*(tmp-1)/2*(1-1/tmp*(tmp-2))))
| 0 | null | 53,360,312,692,500 | 206 | 192 |
# -*- coding: utf-8 -*-
import sys
def main():
N,K = list(map(int, sys.stdin.readline().split()))
A_list = list(map(int, sys.stdin.readline().split()))
A_list.sort(key=lambda x: -abs(x))
A_plus = []
A_minus = []
mod = 10**9 + 7
for val in A_list:
if val >= 0:
A_plus.append(val)
else:
A_minus.append(val)
ans = 1
cnt = 0
i_p = 0 # index of A_plus
i_m = 0 # index of A_minus
while (cnt < K):
if (K - cnt) == 1:
if i_p < len(A_plus):
ans *= A_plus[i_p]
ans %= mod
cnt += 1
i_p += 1
break
else:
ans2 = 1
for i in range( len(A_list)-K, len(A_list) ):
ans2 *= A_list[i]
ans2 %= mod
print(ans2)
return
if (i_m + 1) < len(A_minus):
if (i_p + 1) < len(A_plus):
if abs( A_plus[i_p] * A_plus[i_p + 1] ) > abs( A_minus[i_m] * A_minus[i_m + 1] ):
ans *= A_plus[i_p]
cnt += 1
i_p += 1
else:
ans *= (A_minus[i_m] * A_minus[i_m + 1])
cnt += 2
i_m += 2
else:
ans *= (A_minus[i_m] * A_minus[i_m + 1])
cnt += 2
i_m += 2
else:
ans *= A_plus[i_p]
cnt += 1
i_p += 1
ans %= mod
print(ans)
return
if __name__ == "__main__":
main()
|
import sys
input = sys.stdin.buffer.readline
def main():
N, K = map(int,input().split())
A = list(map(int,input().split()))
A.sort()
l, r = 0, N-1
MOD = 10**9+7
if K == N:
ans = 1
for num in A:
ans *= num
ans %= MOD
print(ans)
exit()
elif A[-1] < 0 and K%2 == 1:
ans = 1
for i in range(K):
ans *= A[-i-1]
ans %= MOD
print(ans)
exit()
ans = 1
if K%2 == 1:
ans *= A[-1]
r -= 1
for _ in range(K//2):
nl = A[l]*A[l+1]
nr = A[r]*A[r-1]
if nl > nr:
ans *= nl
l += 2
else:
ans *= nr
r -= 2
ans %= MOD
print(ans)
if __name__ == "__main__":
main()
| 1 | 9,395,690,068,088 | null | 112 | 112 |
while True:
h, w = list(map(int, input().split()))
a, b = divmod(w, 2)
c, d = divmod(h, 2)
if h == w == 0:
break
print(('#.' * a + '#' * b + '\n' + '.#' * a + '.' * b + '\n') * c
+ ('#.' * a + '#' * b + '\n') * d)
|
import sys
while 1:
H, W = map(int, raw_input().split())
if H==0 and W==0:
break
for i in range(H):
for j in range(W):
if (i+j)%2==0:
sys.stdout.write('#')
else:
sys.stdout.write('.')
sys.stdout.write('\n')
print ''
| 1 | 882,639,450,340 | null | 51 | 51 |
n = int(input())
a_list = list(map(int, input().split()))
sum_l = sum(a_list)
ans = 0
for i in range(n-1):
sum_l -= a_list[i]
ans += sum_l * a_list[i]
print(ans % 1000000007)
|
#!python3
import sys
iim = lambda: map(int, sys.stdin.readline().rstrip().split())
def _cmb(N, mod):
N1 = N + 1
fact = [1] * N1
inv = [1] * N1
for i in range(2, N1):
fact[i] = fact[i-1] * i % mod
inv[N] = pow(fact[N], mod-2, mod)
for i in range(N-1, 1, -1):
inv[i] = inv[i+1]*(i+1) % mod
def cmb(a, b):
return fact[a] * inv[b] % mod * inv[a-b] % mod
return cmb
def resolve():
K = int(input())
s = input()
ls = len(s) - 1
mod = 10**9+7
cmb = _cmb(ls+K, mod)
ans = 0
pp = 1 * pow(26, K, mod) % mod
px = 25 * pow(26, mod-2, mod) % mod
for i in range(K+1):
ans = (ans + cmb(ls+i, ls) * pp % mod) % mod
pp = pp * px % mod
print(ans)
if __name__ == "__main__":
resolve()
| 0 | null | 8,240,723,669,402 | 83 | 124 |
n,k=map(int,input().split())
W=[int(input()) for _ in range(n)]
def Wcheck(W,P,k):
i=0
for j in range(k):
temp_w=0
while temp_w+W[i]<=P:
temp_w=temp_w+W[i]
i=i+1
if i==len(W):
return len(W)
return i
def PSearch(W,start,end,k):
if start==end:
return start
mid=(start+end)//2
v=Wcheck(W,mid,k)
if v>=n:
return PSearch(W,start,mid,k)
else:
return PSearch(W,mid+1,end,k)
print(PSearch(W,0,1000000000,k))
|
a=[int(x) for x in input().split(" ")]
print(a.index(0)+1)
| 0 | null | 6,700,211,526,788 | 24 | 126 |
n = int(input())
a = list(map(int, input().split()))
a = [(i, j) for i, j in enumerate(a, start=1)]
a.sort(key=lambda x: x[1])
a = [str(i) for i, j in a]
print(' '.join(a))
|
n = int(input())
a = [int(e) for e in input().split()]
ans = [0] * n
for i in range(n):
s = a[i]
ans[s-1] = i+1
print(*ans)
| 1 | 180,608,986,005,982 | null | 299 | 299 |
input_line = input()
input_line_cubic = input_line ** 3
print input_line_cubic
|
class XCubic:
def exe(self, x):
return x*x*x
if __name__ == "__main__":
x = int(raw_input())
xc = XCubic()
print(xc.exe(x))
| 1 | 287,344,627,300 | null | 35 | 35 |
N, K = map(int, input().split())
A = list(map(int, input().split()))
answers = ["Yes" if A[i] > A[i-K] else "No" for i in range(K, N)]
print("\n".join(answers))
|
list_all=list(map(int,input().split()))
print(list_all[2],list_all[0],list_all[1])
| 0 | null | 22,768,608,096,128 | 102 | 178 |
n = int(input())
a = list(map(int, input().split()))
MOD = 1000000007
dic = {}
dic[0] = 3
for i in range(1,n+1):
dic[i] = 0
ans = 1
for i in range(n):
ans = ans * dic[a[i]] % MOD
dic[a[i]] -= 1
dic[a[i] + 1] += 1
print(ans)
|
MOD = 10**9 + 7
class ModInt:
def __init__(self, x):
self.x = x % MOD
def __str__(self):
return str(self.x)
__repr__ = __str__
def __add__(self, other):
return (
ModInt(self.x + other.x) if isinstance(other, ModInt) else
ModInt(self.x + other)
)
def __sub__(self, other):
return (
ModInt(self.x - other.x) if isinstance(other, ModInt) else
ModInt(self.x - other)
)
def __mul__(self, other):
return (
ModInt(self.x * other.x) if isinstance(other, ModInt) else
ModInt(self.x * other)
)
def __truediv__(self, other):
return (
ModInt(
self.x * pow(other.x, MOD - 2, MOD)
) if isinstance(other, ModInt) else
ModInt(self.x * pow(other, MOD - 2, MOD))
)
def __pow__(self, other):
return (
ModInt(pow(self.x, other.x, MOD)) if isinstance(other, ModInt) else
ModInt(pow(self.x, other, MOD))
)
__radd__ = __add__
def __rsub__(self, other):
return (
ModInt(other.x - self.x) if isinstance(other, ModInt) else
ModInt(other - self.x)
)
__rmul__ = __mul__
def __rtruediv__(self, other):
return (
ModInt(
other.x * pow(self.x, MOD - 2, MOD)
) if isinstance(other, ModInt) else
ModInt(other * pow(self.x, MOD - 2, MOD))
)
def __rpow__(self, other):
return (
ModInt(pow(other.x, self.x, MOD)) if isinstance(other, ModInt) else
ModInt(pow(other, self.x, MOD))
)
def solve(N, A):
ret = ModInt(1)
count = [3 if not i else 0 for i in range(N + 1)]
for a in A:
ret *= count[a]
if not ret:
break
count[a] -= 1
count[a + 1] += 1
return ret
if __name__ == "__main__":
N = int(input())
A = list(map(int, input().split()))
print(solve(N, A))
| 1 | 130,090,126,314,150 | null | 268 | 268 |
from sys import stdin
for line in stdin:
a,b = line.split(" ")
c = int(a)+int(b)
print(len(str(c)))
|
while 1:
try:
a,b=map(int,raw_input().split())
print len("%d"%(a+b))
except:break
| 1 | 134,615,670 | null | 3 | 3 |
N=int(input())
c=list(input())
R=c.count('R')
L=c[:R].count('R')
print(R-L)
|
n=int(input())
c=input()
d=c.count("R")
e=c[:d].count("R")
print(d-e)
| 1 | 6,257,035,193,420 | null | 98 | 98 |
k=int(input())
s=len(input())
def cmb(n,r,mod):
if r<0 or n<r:
return 0
r=min(r,n-r)
return g1[n]*g2[r]*g2[n-r]%mod
mod=10**9+7
g1=[1,1]#元table
g2=[1,1]#逆元table
inv=[0,1]#逆元table計算用
for i in range(2,k+s+1):
g1.append(g1[-1]*i%mod)
inv.append(-inv[mod%i]*(mod//i)%mod)
g2.append(g2[-1]*inv[-1]%mod)
ans=1
for i in range(1,k+1):
ans=(ans*26+cmb(i+s-1,s-1,mod)*pow(25,i,mod))%mod
print(ans)
|
# coding: UTF-8
from collections import deque
queue = deque()
ftime = deque()
n,quantum = map(int,input().split())
for i in range(n):
name,time = input().split()
time = int(time)
queue.append((name,time))
t = 0
while queue:
name,time = queue.popleft()
if time <= quantum:
t += time
ftime.append(name + " " + str(t))
else:
t += quantum
queue.append((name,time-quantum))
while ftime:
print(ftime.popleft())
| 0 | null | 6,423,676,496,202 | 124 | 19 |
N, K = map(int, input().split())
def sub_sum(l, r):
return (l + r) * (r - l + 1) / 2
ans = 0
for i in range(K, N+2):
l = sub_sum(0, i-1)
r = sub_sum(N-i+1, N)
ans += r - l + 1
ans = ans % (10**9+7)
print(int(ans))
|
def f(m):
return (((N+1)*((m*(m+1))//2))%p-((m*(m+1)*(2*m+1))//6)%p+m%p)%p
p = 10**9+7
N,K = map(int,input().split())
cnt = (f(N+1)-f(K-1))%p
print(cnt)
| 1 | 33,281,899,253,528 | null | 170 | 170 |
import sys
from bisect import bisect_left
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
N, D, A, *XH = map(int, read().split())
monster = [0] * N
for i, (x, h) in enumerate(zip(*[iter(XH)] * 2)):
monster[i] = (x, (h + A - 1) // A)
monster.sort()
pos = []
damage = []
idx = 0
cur_damage = 0
for x, h in monster:
while idx < len(pos) and pos[idx] < x:
cur_damage -= damage[idx]
idx += 1
if h > cur_damage:
pos.append(x + 2 * D)
damage.append(h - cur_damage)
cur_damage += h - cur_damage
print(sum(damage))
return
if __name__ == '__main__':
main()
|
N, D, A = map(int, input().split())
data = []
for _ in range(N):
data.append(tuple(map(int, input().split())))
data.sort()
queue = []
i = 0
j = 0
total = 0
height = 0
while i < N:
if j >= len(queue) or data[i][0] <= queue[j][0]:
x, h = data[i]
i += 1
if height < h:
count = (h - height + A - 1) // A
total += count
height += count * A
queue.append((x + D * 2, count * A))
else:
height -= queue[j][1]
j += 1
print(total)
| 1 | 82,467,053,050,330 | null | 230 | 230 |
n=int(input())
a=list(map(int,input().split()))
ans=[0]*(n+1)
for i in range(n-1):
ans[a[i]]+=1
ans.pop(0)
for j in ans:
print(j)
|
n = int(input())
A = list(map(int,input().split()))
ANS=[0]*(n)
for i in range(n-1):
a=A[i]
ANS[a-1]+=1
for i in range(n):
print(ANS[i])
| 1 | 32,411,669,715,520 | null | 169 | 169 |
# coding:utf-8
import sys
import math
import time
#import numpy as np
import collections
from collections import deque
from collections import Counter
import queue
import copy
import bisect
import heapq
import itertools
sys.setrecursionlimit(10**7)
#N, Q = map(int, input().split())
#G = [list(input()) for i in range(H)]
#INF = V * 10001
#A = [int(i) for i in input().split()]
#AB = [list(map(int, input().split())) for _ in range(K)]
A, B = map(int,input().split())
ans = 0
if(A<=2*B):
print(0)
else:
print(A-2*B)
|
from sys import stdin,stdout
def INPUT():return list(int(i) for i in stdin.readline().split())
import math
def inp():return stdin.readline()
def out(x):return stdout.write(x)
import math as M
MOD=10**9+7
import sys
#####################################
a,b=INPUT()
if a>=2*b:
print(a-2*b)
else:
print(0)
| 1 | 167,354,193,729,470 | null | 291 | 291 |
a,b,m = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
x = []
for i in range(m):
x.append(list(map(int, input().split())))
min_a = min(a)
min_b = min(b)
money = min_a + min_b
for i in range(m):
kingaku = a[x[i][0]-1] + b[x[i][1]-1] - x[i][2]
if kingaku < money:
money = kingaku
print(money)
|
import sys
input = sys.stdin.readline
s = list(input())
a = 0
#print(len(s))
for i in range((len(s) - 1) // 2):
#print(s[i], s[-2-i])
if s[i] != s[-2-i]:
a += 1
print(a)
| 0 | null | 87,168,410,160,210 | 200 | 261 |
H,W,K = map(int,input().split())
c = []
row = [0]*H
col = [0]*W
total = 0
for i in range(H):
c.append(list(input()))
for j in range(W):
if c[i][j] == '#':
row[i] += 1
col[j] += 1
total += 1
#print(total)
ans = 0
for i in range(2**(H+W)):
x = [0]*(H+W)
ii = i
for j in range(H+W):
x[j] = ii % 2
ii//=2
#print(x)
D = 0
for j in range(H):
D += row[j]*x[j]
for j in range(H,H+W):
D += col[j-H]*x[j]
for j in range(H):
for k in range(W):
if c[j][k] == '#':
D -= x[j]*x[H+k]
if total -D == K:
ans += 1
#print(x,ans)
print(ans)
|
def resolve():
# 十進数表記で1~9までの数字がK個入るN桁の数字の数を答える問題
S = input()
K = int(input())
n = len(S)
# dp[i][k][smaller]:
# i:桁数
# K:0以外の数字を使った回数
# smaller:iまでの桁で値以上になっていないかのフラグ
dp = [[[0] * 2 for _ in range(4)] for _ in range(105)]
dp[0][0][0] = 1
for i in range(n):
for j in range(4):
for k in range(2):
nd = int(S[i])
for d in range(10):
ni = i+1
nj = j
nk = k
if d != 0:
nj += 1
if nj > K:
continue
if k == 0:
if d > nd: # 値を超えている
continue
if d < nd:
nk += 1
dp[ni][nj][nk] += dp[i][j][k]
ans = dp[n][K][0] + dp[n][K][1]
print(ans)
if __name__ == "__main__":
resolve()
| 0 | null | 42,588,057,598,580 | 110 | 224 |
N = int(input())
l = list(map(int,input().split()))
def is_ok(n, su):
return l[n] > su
def binary_search(left, right, su):
while (abs(right - left) > 1):
mid = (left + right) // 2
if is_ok(mid, su): right = mid
else: left = mid
return right
l = sorted(l)
ans = 0
for i in range(2, N):
for j in range(1, i):
left = j
right = -1
ret = binary_search(right, left, l[i] - l[j])
if ret != right: ans += j - ret
print(ans)
|
from collections import deque
a = deque([])
for i in range(int(input())):
c = input().split()
if c[0] == "insert":
a.appendleft(c[1])
elif c[0] == "delete":
try:
a.remove(c[1])
except ValueError:
pass
elif c[0] == "deleteFirst":
a.popleft()
else:
a.pop()
for i,e in enumerate(a):
if i == len(a) - 1:
print(e)
else:
print(e, end=" ")
| 0 | null | 85,556,694,346,558 | 294 | 20 |
a, b, c, d = map(int, input().split())
if -(-c//b) > -(-a//d):
print('No')
exit()
print('Yes')
|
mod = 10**9+7
n,a,b = map(int,input().split())
base = pow(2,n,mod)-1
def comb(n,k):
comb = 1
for i in range(n-k+1,n+1):
comb *= i
comb %= mod
for i in range(1, k+1):
comb *= pow(i,mod-2,mod)
comb %= mod
return comb
print((base-comb(n,a)-comb(n,b))%mod)
| 0 | null | 48,057,133,269,600 | 164 | 214 |
a,b,c=map(int,input().split())
if (a==b and b==c) or (a!=b and b!=c and c!=a):
print("No")
else:
print("Yes")
|
a, b, c = [int(i) for i in input().split(" ")]
ab = a == b
bc = b == c
ca = c == a
cnt = 0
for r in [ab, bc, ca]:
if r:
cnt += 1
if cnt == 1:
print("Yes")
else:
print("No")
| 1 | 67,854,556,593,252 | null | 216 | 216 |
#!/usr/bin/env python3
# Generated by https://github.com/kyuridenamida/atcoder-tools
from typing import *
import collections
import functools
import itertools
import math
import sys
INF = float('inf')
def solve(N: int, a: "List[int]"):
c = 1
for i in a:
c += i == c
return len(a) - (c-1) if c != 1 else -1
def main():
sys.setrecursionlimit(10 ** 6)
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
a = [int(next(tokens)) for _ in range(N)] # type: "List[int]"
print(f'{solve(N, a)}')
if __name__ == '__main__':
main()
|
N=int(input())
A=[int(x) for x in input().split()]
start=0
for i in A:
if (start+1)==i:
start+=1
if start!=0:
print(len(A)-start)
else:
print(-1)
| 1 | 114,841,872,143,002 | null | 257 | 257 |
def linearSearch(S,t):
L = S + [t]
i = 0
while L[i] != t: i += 1
if i == len(L)-1: return 0
else : return 1
if __name__=='__main__':
n=int(input())
S=list(map(int,input().split()))
q=int(input())
T=list(map(int,input().split()))
cnt = 0
for t in T: cnt += linearSearch(S,t)
print(cnt)
|
MOD = int(1e9+7)
N = int(input())
# all posible list
Na = pow(10, N, MOD)
# number of list without 0
N0 = pow(9, N, MOD)
# number of list without both 0 and 9
N09 = pow(8, N, MOD)
M = Na - 2*N0 + N09
print(M%MOD)
| 0 | null | 1,638,170,869,094 | 22 | 78 |
class Combinatorics:
def __init__(self, N, mod):
'''
Preprocess for calculating binomial coefficients nCr (0 <= r <= n, 0 <= n <= N)
over the finite field Z/(mod)Z.
Input:
N (int): maximum n
mod (int): a prime number. The order of the field Z/(mod)Z over which nCr is calculated.
'''
self.mod = mod
self.fact = {i: None for i in range(N+1)} # n!
self.inverse = {i: None for i in range(1, N+1)} # inverse of n in the field Z/(MOD)Z
self.fact_inverse = {i: None for i in range(N+1)} # inverse of n! in the field Z/(MOD)Z
# preprocess
self.fact[0] = self.fact[1] = 1
self.fact_inverse[0] = self.fact_inverse[1] = 1
self.inverse[1] = 1
for i in range(2, N+1):
self.fact[i] = i * self.fact[i-1] % self.mod
q, r = divmod(self.mod, i)
self.inverse[i] = (- (q % self.mod) * self.inverse[r]) % self.mod
self.fact_inverse[i] = self.inverse[i] * self.fact_inverse[i-1] % self.mod
def perm(self, n, r):
'''
Calculate nPr = n! / (n-r)! % mod
'''
if n < r or n < 0 or r < 0:
return 0
else:
return (self.fact[n] * self.fact_inverse[n-r]) % self.mod
def binom(self, n, r):
'''
Calculate nCr = n! /(r! (n-r)!) % mod
'''
if n < r or n < 0 or r < 0:
return 0
else:
return self.fact[n] * (self.fact_inverse[r] * self.fact_inverse[n-r] % self.mod) % self.mod
def hom(self, n, r):
'''
Calculate nHr = {n+r-1}Cr % mod.
Assign r objects to one of n classes.
Arrangement of r circles and n-1 partitions:
o o o | o o | | | o | | | o o | | o
'''
if n == 0 and r > 0:
return 0
if n >= 0 and r == 0:
return 1
return self.binom(n + r - 1, r)
MOD = 10**9 + 7
N, K = map(int, input().split())
com = Combinatorics(N, MOD)
ans = 0
for i in range(min(K, N-1) + 1):
ans += (com.binom(N, i) * com.hom(N-i, i)) % MOD
ans %= MOD
print(ans)
|
U = 2 * 10 ** 5
mod = 10 ** 9 + 7
class Combination:
"""
SIZEが10^6程度以下の二項係数を何回も呼び出したいときに使う
使い方:
comb = Combination(SIZE, MOD)
comb(10, 3) => 120
"""
def __init__(self, N, MOD=10 ** 9 + 7):
self.MOD = MOD
self.fact, self.inv = self._make_factorial_list(N)
def __call__(self, n, k):
if k < 0 or k > n:
return 0
res = self.fact[n] * self.inv[k] % self.MOD
res = res * self.inv[n - k] % self.MOD
return res
def _make_factorial_list(self, N):
fact = [1] * (N + 1)
inv = [1] * (N + 1)
MOD = self.MOD
for i in range(1, N + 1):
fact[i] = (fact[i - 1] * i) % MOD
inv[N] = pow(fact[N], MOD - 2, MOD)
for i in range(N, 0, -1):
inv[i - 1] = (inv[i] * i) % MOD
return fact, inv
if __name__ == "__main__":
N, K = map(int, input().split())
comb = Combination(U + 5, mod)
ans = 1
for i in range(1, min(K + 1, N)):
vacant = comb(N, i)
person = comb(N - 1, i)
ans = (ans + vacant * person % mod) % mod
print(ans)
| 1 | 67,131,462,856,260 | null | 215 | 215 |
n = int(input())
x = 0
for i in range(1, 10):
if n % i == 0 and n / i < 10:
x += 1
break
else:
pass
if x == 1:
print('Yes')
else:
print('No')
|
import queue
N, U, V = map(int, input().rstrip().split())
U -= 1
V -= 1
v2e = [set() for _ in range(N)]
for _ in range(N-1):
a, b = map(lambda x: int(x)-1, input().rstrip().split())
v2e[a].add(b)
v2e[b].add(a)
q = queue.Queue()
q.put(U)
p = [-1] * N
p[U] = U
while True:
a = q.get()
if a == V:
break
for b in v2e[a]:
if p[b] == -1:
p[b] = a
q.put(b)
a = V
min_p = []
while True:
min_p.append(a)
if a == U:
break
a = p[a]
p = [-1] * N
p[min_p[(len(min_p)-1)//2-len(min_p)%2]] = min_p[(len(min_p)-1)//2-len(min_p)%2]
for a in v2e[min_p[(len(min_p)-1)//2-len(min_p)%2]]:
p[a] = a
p[min_p[-len(min_p)//2+len(min_p)%2]] = min_p[-len(min_p)//2+len(min_p)%2]
q = queue.Queue()
q.put((min_p[-len(min_p)//2+len(min_p)%2], 0))
while q.qsize() > 0:
a, d = q.get()
for b in v2e[a]:
if p[b] == -1:
p[b] = a
q.put((b, d + 1))
print(d + (len(min_p) - 2) // 2 + len(min_p) % 2)
| 0 | null | 139,001,687,022,738 | 287 | 259 |
a,b,c,d = map(int,input().split())
A = [a,b]
B = [c,d]
INF = float("INF")
M = -INF
for i in A:
for j in B:
M = max(i*j,M)
print(M)
|
import numpy as np
a = list(map(int, input().split()))
ans = -1*float('inf')
y = np.array(a[2:])
for i in a[:2]:
ans = max(ans, max(i*y))
print(ans)
| 1 | 3,086,009,796,232 | null | 77 | 77 |
# collections.deque is implemented using doubly linked list at C level..
from collections import deque
linkedlist = deque()
for _ in range(int(input())):
input_command = input()
if input_command == 'deleteFirst':
linkedlist.popleft()
elif input_command == 'deleteLast':
linkedlist.pop()
else:
com, num = input_command.split()
if com == 'insert':
linkedlist.appendleft(num)
elif com == 'delete':
try:
linkedlist.remove(num)
except:
pass
print(' '.join(linkedlist))
|
n = input()
lis = []
bot = 0
for i in xrange(n):
com = raw_input()
if com[0] == 'i':
lis.append(com[7:])
elif com[6] == ' ':
try:
lis.pop(~lis[::-1].index(com[7:]))
except:
pass
elif com[6] == 'F':
lis.pop()
else:
bot += 1
print ' '.join( map(str, reversed(lis[bot:])) )
| 1 | 51,455,105,116 | null | 20 | 20 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.