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, K, S = [int(x) for x in input().split()]
result = [S] * K
if S == 10**9:
ex = 1
else:
ex = S+1
result.extend([ex] * (N - K))
print(*result)
| import collections
n=int(input())
a= list(map(int, input().split()))
aa=list(set(a))
sortaa=sorted(aa,reverse=True)
c = collections.Counter(a)
comf=[]
for i in range(len(aa)):
if i == 0:
comf.extend([sortaa[i] for ii in range(2*c[sortaa[i]]-1)])
else:
comf.extend([sortaa[i] for ii in range(2*c[sortaa[i]])])
print(sum(comf[:n-1])) | 0 | null | 50,275,979,103,766 | 238 | 111 |
import bisect, collections, copy, heapq, itertools, math, string, sys
input = lambda: sys.stdin.readline().rstrip()
sys.setrecursionlimit(10**7)
INF = float('inf')
MOD = 998244353
def I(): return int(input())
def F(): return float(input())
def SS(): return input()
def LI(): return [int(x) for x in input().split()]
def LI_(): return [int(x)-1 for x in input().split()]
def LF(): return [float(x) for x in input().split()]
def LSS(): return input().split()
def resolve():
N, K = LI()
LR = [LI() for _ in range(K)]
dp = [0] * (N + 1)
dp[0] = 1
a = [0] * (N + 1)
a[0] = 1
a[1] = -1
for i in range(N):
for l, r in LR:
left = min(i + l, N)
right = min(i + r + 1, N)
a[left] += dp[i]
a[right] -= dp[i]
dp[i+1] += dp[i] + a[i+1]
dp[i+1] %= MOD
# print(a)
# print(dp)
print(dp[-2])
if __name__ == '__main__':
resolve()
| import sys
sys.setrecursionlimit(10**7)
def I(): return int(sys.stdin.readline().rstrip())
def MI(): return map(int,sys.stdin.readline().rstrip().split())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split())) #空白あり
def LI2(): return list(map(int,sys.stdin.readline().rstrip())) #空白なし
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split()) #空白あり
def LS2(): return list(sys.stdin.readline().rstrip()) #空白なし
N = I()
A = [i*j for i in range(1,10) for j in range(1,10)]
print('Yes' if N in A else 'No')
| 0 | null | 81,388,266,667,902 | 74 | 287 |
N, M = map(int, input().split())
a, w = 0, 0
P = set()
W = {}
for _ in range(M):
p, S = map(str, input().split())
if p in P:
continue
if S == 'WA':
W.setdefault(p, 0)
W[p] += 1
if S == 'AC':
a += 1
P.add(p)
if p in W:
w += W[p]
print(a, w) | import sys
import os
import math
import bisect
import itertools
import collections
import heapq
import queue
import array
# 時々使う
# from scipy.sparse.csgraph import csgraph_from_dense, floyd_warshall
# from decimal import Decimal
# from collections import defaultdict, deque
# 再帰の制限設定
sys.setrecursionlimit(10000000)
def ii(): return int(sys.stdin.buffer.readline().rstrip())
def il(): return list(map(int, sys.stdin.buffer.readline().split()))
def fl(): return list(map(float, sys.stdin.buffer.readline().split()))
def iln(n): return [int(sys.stdin.buffer.readline().rstrip())
for _ in range(n)]
def iss(): return sys.stdin.buffer.readline().decode().rstrip()
def sl(): return list(map(str, sys.stdin.buffer.readline().decode().split()))
def isn(n): return [sys.stdin.buffer.readline().decode().rstrip()
for _ in range(n)]
def lcm(x, y): return (x * y) // math.gcd(x, y)
MOD = 10 ** 9 + 7
INF = float('inf')
def main():
if os.getenv("LOCAL"):
sys.stdin = open("input.txt", "r")
N = ii()
D = [il() for _ in range(N)]
for i in range(N - 2):
for j in range(i, i + 3):
if D[j][0] != D[j][1]:
break
else:
print('Yes')
exit()
else:
print('No')
if __name__ == '__main__':
main()
| 0 | null | 48,037,309,911,168 | 240 | 72 |
print((int(input())+1)//2-1) | S=input()
print(S.replace('?','D')) | 0 | null | 85,713,240,320,022 | 283 | 140 |
import math
deg = int(input())
li_x = list(map(int,input().split()))
li_y = list(map(int, input().split()))
p1_dis = 0.0
p2_dis = 0.0
p2_temp = 0.0
p3_dis = 0.0
p3_temp = 0.0
p4_dis = 0.0
p4_temp = [ ]
for i in range(deg):
p1_dis += math.fabs(li_x[i] - li_y[i])
p2_temp += (li_x[i] - li_y[i]) **2.0
p3_temp += math.fabs(li_x[i] - li_y[i]) **3.0
p4_temp.append( math.fabs(li_x[i] - li_y[i]) )
p2_dis = math.sqrt( p2_temp )
p3_dis = math.pow(p3_temp, 1.0/3.0)
p4_dis = max(p4_temp)
print('{0:.6f}'.format(p1_dis))
print('{0:.6f}'.format(p2_dis))
print('{0:.6f}'.format(p3_dis))
print('{0:.6f}'.format(p4_dis)) | print(str(input())[:3]) | 0 | null | 7,523,390,898,532 | 32 | 130 |
mod = 10**9 + 7
N = int(input())
A = [int(i) for i in input().split()]
# bitにしてor
# 一桁だけの時、111000なら3 * 3
maxl = 0
textlist = []
for i in range(N):
tmp = str(bin(A[i]))
tmp = tmp[2:]
length = len(tmp)
if maxl < length:
maxl = length
textlist.append(tmp)
zeros = {}
ones = {}
for i in range(maxl):
zeros[i] = 0
ones[i] = 0
for i in range(N):
tmp = textlist[i]
length = len(tmp)
if maxl < length:
maxl = length
for j in range(length):
if tmp[-j-1]== '1':
ones[j] += 1
for i in range(maxl):
zeros[i] = N-ones[i]
result = 0
n2 = 1
for i in range(maxl):
result = (result + n2 * (zeros[i] * ones[i])) % mod
n2 = (n2 * 2) % mod
print(result) | n,a,b=map(int,input().split())
c=max(a,b)
b=min(a,b)
a=c
MOD = pow(10,9) + 7
X=1
Y=1
for i in range(1,a+1):
X=X*(n+1-i)%MOD
Y=Y*i%MOD
if i==b:
b_X=X
b_Y=Y
a_X=X
a_Y=Y
def calc(X,Y,MOD):
return X*pow(Y,MOD-2,MOD)
ans=pow(2,n,MOD)%MOD-1-calc(a_X,a_Y,MOD)-calc(b_X,b_Y,MOD)
print(ans%MOD)
| 0 | null | 94,555,500,089,418 | 263 | 214 |
m1, d1 = [int(i) for i in input().split()]
m2, d2 = [int(i) for i in input().split()]
if m1 == m2:
print(0)
else:
print(1) | M1, D1 = [int(i) for i in input().split()]
M2, D2 = [int(i) for i in input().split()]
if D1>D2 and M2>M1:
print(1)
else:
print(0) | 1 | 124,372,978,326,200 | null | 264 | 264 |
M1, _ = map(int, input().split())
M2, _ = map(int, input().split())
ans = 1 if M1 != M2 else 0
print(ans) | N,M,X=map(int,input().split())
C=[list(map(int,input().split())) for _ in range(N)]
mx=10**9
ans=mx
def dfs(i,tt,level):
global ans
if i==N:
return
tt+=C[i][0]
lev=[]
for j in range(M):
lev.append(level[j]+C[i][j+1])
ok=True
for x in lev:
if x<X:
ok=False
break
if ok:
ans=min(ans,tt)
for j in range(i+1,N):
dfs(j,tt,lev)
for i in range(N):
dfs(i,0,[0]*M)
if ans==mx:
print(-1)
else:
print(ans)
| 0 | null | 73,631,364,681,788 | 264 | 149 |
import math
a, b, h, m = map(int, input().split())
m_h = m
if h ==0:
h = 12
if m == 0:
m_h = 0
m = 60
sub_degrees = abs((360/12) * h + (30/12) * (m_h/5) - (360/60) * m )
print(math.sqrt(a**2 + b**2 - 2 * a * b * math.cos(math.radians(sub_degrees)))) | import math
import sys
sys.setrecursionlimit(10**9)
def comb(n, r): # 普通のcombination計算
if r < 0 or r > n:
return 0
else:
n1 = math.factorial(n)
n21 = math.factorial(n - r)
n22 = math.factorial(r)
ans = n1 // (n21 * n22)
return ans
"""
solve(i, k, smaller)
:= i桁目以降について、0以外の値を残りk個使用可能という状況を考える。
このときi桁目までの部分が「等しい」か「strictに小さくなっている」かを
smallerフラグによって分岐する。
"""
def solve(i, k, smaller): # 再帰
# print(i, k, smaller)
if i == N:
if k == 0:
return 1
else:
return 0
if k == 0:
return 1
if smaller == True:
return comb(N - i, k) * pow(9, k)
else:
if S[i] == "0":
return solve(i + 1, k, False)
else:
"""
ex. S = 314159 の場合
000000〜099999 := a
100000〜299999 := b
300000〜314159 := c のように場合分け
"""
a = solve(i + 1, k, True)
b = solve(i + 1, k - 1, True) * (int(S[i]) - 1)
c = solve(i + 1, k - 1, False)
return a + b + c
# 問題文ではNだが、文字列として扱うのでSと名付ける
S = input()
# Sの桁数、問題文のNとは違う
N = len(S)
K = int(input())
ans = solve(0, K, False)
print(ans)
| 0 | null | 47,743,653,658,558 | 144 | 224 |
from collections import deque
while True:
s = input()
if s == '-': break
else: ds = deque(s)
ds.rotate(sum([int(input()) for _ in range(int(input()))])*-1)
print(''.join(ds)) | # Belongs to : midandfeed aka asilentvoice
while(1):
s = str(input())
if s == '-':
break
else:
n = int(input())
for _ in range(n):
h = int(input())
ans = s[h:] + s[:h]
s = ans
print(ans) | 1 | 1,931,225,666,720 | null | 66 | 66 |
n = list(input())
tmp = 0
for i in n:
tmp += int(i) % 9
ans = "Yes" if tmp % 9 == 0 else "No"
print(ans)
| from itertools import accumulate
n,k = map(int, input().split())
As = list(map(int, input().split()))
for i in range(k):
imos = [0] * (n+1)
for i,a in enumerate(As):
l = max(0, i-a)
r = min(n, i+a+1)
imos[l] += 1
imos[r] -= 1
acc = list(accumulate(imos))
# 指数関数的に増える
if acc[:-1] == As:
print(*As)
exit()
As = acc[:-1]
print(*As) | 0 | null | 9,907,182,105,418 | 87 | 132 |
N, K = map(int, input().split())
A = list(map(int, input().split()))
F = list(map(int, input().split()))
A.sort()
F.sort(reverse=True)
T = []
for i in range(N):
T.append(A[i]*F[i])
s = -1
l = 10**12
while(l-s > 1):
mid = (l-s)//2 + s
c = 0
for i in range(N):
if T[i] > mid:
if (T[i] - mid) % F[i] == 0:
c += (T[i] - mid) // F[i]
else:
c += (T[i] - mid) // F[i] + 1
if c > K:
s = mid
else:
l = mid
print(l) | n,k = map(int, input().split())
A = list(map(int,input().split()))
F = list(map(int,input().split()))
A.sort()
F.sort(reverse=True)
def is_ok(x):
c = 0
for a, f in zip(A, F):
c += max(0, a-x//f)
if c <= k:
return True
else:
return False
ng = -1
ok = 10**18
while ng+1 < ok:
c = (ng+ok)//2
if is_ok(c):
ok = c
else:
ng = c
print(ok)
| 1 | 164,575,031,615,340 | null | 290 | 290 |
n = int(input())
st = input()
if st[:n//2] == st[n//2:]: print("Yes")
else: print("No") | import math
def lcm(a, b):
return int(a * b/ math.gcd(a, b))
a, b = map(int, input().split())
print(lcm(a,b)) | 0 | null | 129,988,744,102,272 | 279 | 256 |
print("Yes" if input().count("7") > 0 else "No") | n = input()
if n.isupper():
print("A")
else :
print('a') | 0 | null | 22,816,015,013,142 | 172 | 119 |
N, M, K = map(int,input().split())
A = list(map(int,input().split()))
B = list(map(int,input().split()))
sumA = [0]
sumB = [0]
tmp = 0
answer = 0
st = 0
for i in range(N):
tmp = tmp + A[i]
sumA.append(tmp)
tmp = 0
for i in range(M):
tmp = tmp + B[i]
sumB.append(tmp)
for i in range(N, -1, -1):
booktmp = 0
for j in range(st, M + 1):
if sumA[i] + sumB[j] <= K:
booktmp = i + j
else:
st = j
break
answer = max(answer, booktmp)
if j == M:
break
print(answer)
| # 解説
import sys
pin = sys.stdin.readline
pout = sys.stdout.write
perr = sys.stderr.write
N, M, K = map(int, pin().split())
A = list(map(int, pin().split()))
B = list(map(int, pin().split()))
a = [0]
b = [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
for i in range(N + 1):
#Aの合計がKを超えるまで比較する
if a[i] > K:
break
# 超えていた場合に本の個数を減らす
while b[M] > K - a[i]:
M -= 1
ans = max(ans, M + i)
print(ans)
| 1 | 10,816,470,797,658 | null | 117 | 117 |
#B問題
ans = 0
n, k = map(int, input().split())
P = list(map(int, input().split()))
for i in range(k):
ans += min(P)
P.remove(min(P))
print(ans) | n = int(input())
a = list(map(int, input().split()))
t = 1
ans = 0
for i in range(n):
if t != a[i]:
ans += 1
a[i] = -1
else:
t += 1
if all([i == -1 for i in a]):
print(-1)
else:
print(ans) | 0 | null | 63,312,067,973,492 | 120 | 257 |
n = int(input())
lst = [int(i) for i in input().split()]
lst.sort()
#print(lst)
if 1 in lst:
count = 0
for i in range(n):
if lst[i] == 1:
count += 1
if count == 2:
break
if count == 1:
print(1)
else:
print(0)
else:
tf_lst = [1] * lst[n - 1]
count = 0
if n > 1:
pre = 0
for i in range(n):
tf_lst[pre:lst[i] - 1] = [0] * (lst[i] - pre - 1)
pre = lst[i]
if tf_lst[lst[i] - 1] == 0:
continue
if i <= n - 2:
if lst[i] == lst[i + 1]:
tf_lst[lst[i] - 1] = 0
for j in range(lst[i] * 2, lst[n - 1] + 1, lst[i]):
tf_lst[j - 1] = 0
#print(tf_lst)
for i in tf_lst:
count += i
else:
count += 1
print(count)
| import sys
x,n = map(int,input().split())
p = list(map(int,input().split()))
if p.count(x) == 0:
print(x)
else:
for i in range(1,110):
if p.count(x-i) == 0:
print(x-i)
sys.exit()
elif p.count(x+i) == 0:
print(x+i)
sys.exit()
| 0 | null | 14,331,686,252,960 | 129 | 128 |
from sys import stdin
readline = stdin.readline
def i_input(): return int(readline().rstrip())
def i_map(): return map(int, readline().rstrip().split())
def i_list(): return list(i_map())
def main():
A, B, C, D = i_map()
print(max([A * C, A * D, B * C, B * D]))
if __name__ == "__main__":
main()
| a, b, c, d = map(int, input().split())
if a>=0 and c>=0:
print(b*d)
elif b<=0 and d<=0:
print(a*c)
elif b<=0 and c>=0:
print(b*c)
elif a>=0 and d<=0:
print(a*d)
elif a<=0 and b>=0 and c<=0 and d>=0:
print(max([a*c, b*d]))
elif b<=0 and c<=0 and d>=0:
print(a*c)
elif a<=0 and b>=0 and d<=0:
print(a*c)
elif a<=0 and b>=0 and c>=0:
print(b*d)
elif a>=0 and c<=0 and d>=0:
print(b*d)
| 1 | 3,053,439,566,798 | null | 77 | 77 |
n = int(input())
s = str(input())
if n % 2 == 1:
print("No")
exit()
if s[:n // 2] == s[n // 2:]:
print("Yes")
exit()
print("No") | import sys
N = int(input())
S = input()
if N % 2 == 1:
print('No')
sys.exit()
if S[:N//2] == S[N//2:]:
print('Yes')
sys.exit()
print('No') | 1 | 147,062,666,207,512 | null | 279 | 279 |
import math
a, b, x = map(int, input().split())
x /= a
if a * b >= x * 2:
c = x * 2 / b
print(math.degrees(math.atan2(b, c)))
else:
c = (a * b - x) * 2 / a
print(math.degrees(math.atan2(c, a))) | import numpy as np
a,b,x=map(int,input().split())
if x<=a*a*b/2:
y=2*x/(a*b)
print(360/((2*np.pi)/np.arctan(b/y)))
else:
y=2*x/(a**2)-b
print(360/((2*np.pi)/np.arctan((b-y)/a))) | 1 | 163,086,872,217,512 | null | 289 | 289 |
# C - Sum of product of pairs
N = int(input())
A = list(int(a) for a in input().split())
MOD = 10**9 + 7
csA = [0] * (N+1)
for i in range(N):
csA[i+1] = csA[i] + A[i]
ans = 0
for i in range(N-1):
ans += (A[i] * (csA[N] - csA[i+1])) % MOD
print(ans%MOD) | import math
import sys
n=int(input())
d=list(map(int,input().split()))
if d[0]!=0 or 0 in d[1:]:
print(0)
sys.exit()
lis=[0 for i in range(n)]
for i in range(n):
lis[d[i]]+=1
for i in range(1,n-1):
if lis[i]==0 and lis[i+1]!=0:
print(0)
sys.exit()
s=1
i=0
while i+1<=n-1 and lis[i+1]!=0:
s=(s*pow(lis[i],lis[i+1],998244353))%998244353
i+=1
print(s)
| 0 | null | 79,191,757,896,030 | 83 | 284 |
debt = 100000.0
a = int(input())
for i in range(a):
debt = debt * 1.05
if(debt % 1000):
debt = (debt // 1000) * 1000 + 1000
print(int(debt))
| import math
d=100
for _ in[0]*int(input()):d=math.ceil(d*1.05)
print(int(d*1e3))
| 1 | 1,364,471,680 | null | 6 | 6 |
a = []
b = []
a = input().split()
b = input().split()
if a[0] == b[0]:
print("0")
else:
print("1")
| m,d=map(int,input().split())
if m in [1,3,5,7,8,10,12] and d==31:
print(1)
elif m ==2 and d==28:
print(1)
elif m in [4,6,9,11] and d==30:
print(1)
else:
print(0) | 1 | 124,886,461,900,762 | null | 264 | 264 |
d,t,s = input().split()
gool = int(d) / int(s)
if gool <= int(t):
print('Yes')
else:
print('No') | def main():
line1 = input()
line2 = input()
line3 = input()
n, m, k = list(map(int, line1.split()))
a = [0] + list(map(int, line2.split()))
b = [0] + list(map(int, line3.split()))
mark1, mark2 = 0, 0
for i in range(1, len(a)):
a[i] += a[i-1]
if a[i] > k:
mark1 = i
break
for i in range(1, len(b)):
b[i] += b[i-1]
if b[i] > k:
mark2 = i
break
if mark1:
a = a[:mark1]
if mark2:
b = b[:mark2]
ans = 0
for i in range(len(a)):
target = k - a[i]
tmp = 0
low, high = 0, len(b)
while low < high:
mid = (low + high) // 2
if b[mid] <= target:
tmp = mid
low = mid + 1
else:
high = mid - 1
ans = max(ans, i + tmp)
print(ans)
return
if __name__ == "__main__":
main() | 0 | null | 7,119,001,149,890 | 81 | 117 |
n = input();
ans = 100000;
for i in range(n):
ans = int(float(ans) * 1.05);
ans += 999;
ans /= 1000;
ans *= 1000;
print ans | #import sys
#input = sys.stdin.buffer.readline
#input = sys.stdin.readline
# mod=10**9+7
# rstrip().decode('utf-8')
# map(int,input().split())
# import numpy as np
def main():
n=int(input())
s=[]
t=[]
for i in range(n):
a,b=input().split()
s.append(a)
t.append(int(b))
x=input()
for i in range(n):
if x==s[i]:
ans=sum(t[i+1:])
print(ans)
exit(0)
if __name__ == "__main__":
main()
| 0 | null | 48,428,037,541,772 | 6 | 243 |
n=int(input())
ch=0
curr=0
for i in range (n):
a,b=map(int,input().split())
if a==b:
curr+=1
else:
curr=0
if curr>=3:
ch=1
if ch:
print("Yes")
else:
print("No") | n = int(input())
ren = 0
for i in range(n):
a, b = (int(x) for x in input().split())
if a == b:
ren += 1
elif ren >= 3:
continue
else:
ren = 0
if ren >= 3:
print("Yes")
else:
print("No") | 1 | 2,488,515,135,722 | null | 72 | 72 |
# https://atcoder.jp/contests/abc161/tasks/abc161_d
import sys
# sys.setrecursionlimit(100000)
import heapq
def input():
return sys.stdin.readline().strip()
def input_int():
return int(input())
def input_int_list():
return [int(i) for i in input().split()]
def main():
n = int(input())
if n < 10:
print(n)
return
cnt = 0
hq = [1, 2, 3, 4, 5, 6, 7, 8, 9]
while cnt < n:
i = heapq.heappop(hq)
cnt += 1
if cnt == n:
print(i)
return
r = int(str(i)[::-1][0])
heapq.heappush(hq, int(str(i) + str(r)))
if r != 9:
heapq.heappush(hq, int(str(i) + str(r + 1)))
if r != 0:
heapq.heappush(hq, int(str(i) + str(r - 1)))
return
if __name__ == "__main__":
main()
| import sys
import heapq
import re
from heapq import heapify, heappop, heappush
from itertools import permutations
from bisect import bisect_left, bisect_right
from collections import Counter, deque
from fractions import gcd
from math import factorial, sqrt, ceil
from functools import lru_cache, reduce
INF = 1 << 60
MOD = 1000000007
sys.setrecursionlimit(10 ** 7)
# UnionFind
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
# ダイクストラ
def dijkstra_heap(s, edge, n):
#始点sから各頂点への最短距離
d = [10**20] * n
used = [True] * n #True:未確定
d[s] = 0
used[s] = False
edgelist = []
for a,b in edge[s]:
heapq.heappush(edgelist,a*(10**6)+b)
while len(edgelist):
minedge = heapq.heappop(edgelist)
#まだ使われてない頂点の中から最小の距離のものを探す
if not used[minedge%(10**6)]:
continue
v = minedge%(10**6)
d[v] = minedge//(10**6)
used[v] = False
for e in edge[v]:
if used[e[1]]:
heapq.heappush(edgelist,(e[0]+d[v])*(10**6)+e[1])
return d
# 素因数分解
def factorization(n):
arr = []
temp = n
for i in range(2, int(-(-n**0.5//1))+1):
if temp%i==0:
cnt=0
while temp%i==0:
cnt+=1
temp //= i
arr.append([i, cnt])
if temp!=1:
arr.append([temp, 1])
if arr==[]:
arr.append([n, 1])
return arr
# 2数の最小公倍数
def lcm(x, y):
return (x * y) // gcd(x, y)
# リストの要素の最小公倍数
def lcm_list(numbers):
return reduce(lcm, numbers, 1)
# リストの要素の最大公約数
def gcd_list(numbers):
return reduce(gcd, numbers)
# 素数判定
def is_prime(n):
if n <= 1:
return False
p = 2
while True:
if p ** 2 > n:
break
if n % p == 0:
return False
p += 1
return True
# limit以下の素数を列挙
def eratosthenes(limit):
A = [i for i in range(2, limit+1)]
P = []
while True:
prime = min(A)
if prime > sqrt(limit):
break
P.append(prime)
i = 0
while i < len(A):
if A[i] % prime == 0:
A.pop(i)
continue
i += 1
for a in A:
P.append(a)
return P
# 同じものを含む順列
def permutation_with_duplicates(L):
if L == []:
return [[]]
else:
ret = []
# set（集合）型で重複を削除、ソート
S = sorted(set(L))
for i in S:
data = L[:]
data.remove(i)
for j in permutation_with_duplicates(data):
ret.append([i] + j)
return ret
# ここから書き始める
k = int(input())
queue = deque([str(i) for i in range(1, 10)])
ans = ""
for i in range(k):
ans = queue.popleft()
if ans[-1] != "0":
queue.append(ans + str(int(ans[-1]) - 1))
queue.append(ans + ans[-1])
if ans[-1] != "9":
queue.append(ans + str(int(ans[-1]) + 1))
print(ans) | 1 | 40,047,963,399,740 | null | 181 | 181 |
n, m = map(int, input().split())
data2 = []
for i in range(m):
data2.append(input().split())
graph = [[] for i in range(n)]
for i in range(0,m):
a, b = map(lambda z: int(z) - 1, data2[i])
graph[a].append(b)
graph[b].append(a)
size = [0 for i in range(n)]
check = [True for i in range(n)]
for i in range(n):
if check[i]:
tmp = 1
stack = [i]
check[i] = False
while stack:
now = stack.pop()
size[now] = tmp
tmp += 1
for to in graph[now]:
if check[to]:
check[to] = False
stack.append(to)
print(max(size)) | a, b, c, d = map(int, input().split())
x = [a, min(a+1, b), max(a, b-1), b]
y = [c, min(c+1, d), max(c, d-1), d]
ans = -int(1e19)
for i in x:
for j in y:
ans = max(ans, i*j)
print(ans) | 0 | null | 3,487,734,139,704 | 84 | 77 |
N, K = map(int, input().split())
A = list(map(int, input().split()))
mod = 10 ** 9 + 7
fact = [1, 1]
factinv = [1, 1]
inv = [0, 1]
def cmb(n, r):
if (r < 0) or (n < r):
return 0
r = min(r, n - r)
return fact[n] * factinv[r] * factinv[n - r] % mod
for i in range(2, N + 1):
fact.append((fact[-1] * i) % mod)
inv.append((-inv[mod % i] * (mod // i)) % mod)
factinv.append((factinv[-1] * inv[-1]) % mod)
A.sort()
ans = 0
for i, (n, x) in enumerate(zip(A, A[::-1])):
if i < K-1:
continue
ans += n * cmb(i, K - 1)
ans %= mod
ans -= x * cmb(i, K - 1)
ans %= mod
print(ans)
| n = int(input())
ans = 0 if n % 1000 == 0 else 1000 - n % 1000
print(ans) | 0 | null | 52,042,546,920,000 | 242 | 108 |
startX, countK, distanceD = map(int, input().split())
n = int(abs(startX) / distanceD)
ans = abs(startX) % distanceD
if n > countK:
ans += distanceD * (n - countK)
else:
if (countK - n) % 2 == 1:
ans= abs(ans - distanceD)
print(ans)
| #!/usr/bin/env python
# coding: utf-8
# In[15]:
N = int(input())
A = list(map(int, input().split()))
# In[17]:
total = sum(A)
ans = total
left = 0
for i in A:
left += i
right = total - left
ans = min(ans, abs(left - right))
# print(left, right, ans)
print(ans)
# In[ ]:
| 0 | null | 74,034,871,704,992 | 92 | 276 |
n = int(input())
if n == 1:
print(1)
elif n % 2 == 0:
print(0.5)
else:
import math
print(math.ceil(n/2)/n) | N,P = map(int,input().split())
S = input()
def solve(S,N,P):
if P == 2:
ans = 0
for i in range(N):
if int(S[i])%P == 0:
ans += i+1
return ans
if P == 5:
ans = 0
for i in range(N):
if int(S[i])%P == 0:
ans += i+1
return ans
S = S[::-1]
mod_list = [0]*P
mod_list[0] = 1
mod = P
tmp = 0
for i in range(N):
tmp = (tmp + int(S[i])*pow(10,i,mod))%mod
mod_list[tmp] += 1
ans = 0
for i in mod_list:
ans += i*(i-1)//2
return ans
print(solve(S,N,P)) | 0 | null | 117,237,013,639,104 | 297 | 205 |
N=int(input())
P=list(map(int,input().split()))
count=0
min=2*10**5
for i in range(N):
if P[i]<=min:
min=P[i]
count+=1
print(count)
| n = int(input())
p = list(map(int, input().split()))
ans = 1
p_min = p[0]
for i in range(1,n):
if p_min >= p[i]:
ans += 1
p_min = min(p_min, p[i])
print(ans) | 1 | 85,313,524,232,860 | null | 233 | 233 |
n,a,b = map(int,input().split())
mod = 10**9+7
def modInverse(a,p):
# Fermat's little theorem, a**(p-1) = 1 mod p
return pow(a,p-2,p)
def nCr(n,r,p=mod):
num = 1
den = 1
for i in range(r):
num = (num*(n-i)) % p
den = (den*(i+1)) % p
return num*modInverse(den,p)% p
ans = pow(2,n,mod)-1
print((ans-nCr(n,a)-nCr(n,b))%mod) | N = int(input())
A = [int(a) for a in input().split()]
print((sum(A)**2 - sum([a**2 for a in A]))//2) | 0 | null | 117,392,860,688,572 | 214 | 292 |
N=int(input())
print(-N%1000)
| N = int(input())
print(f"{-N % 1000}") | 1 | 8,435,778,222,242 | null | 108 | 108 |
import math
a,b,x=map(int,input().split())
if x>=a**2*b/2:
a=math.atan((2/a)*(b-x/(a**2)))
else:
a=math.atan(a*b**2/2/x)
print("{:.8f}".format(a*(180/math.pi))) | import sys
h, w, m = map(int, input().split(' '))
H = [0 for _ in range(h+1)]
W = [0 for _ in range(w+1)]
bomb = set()
for m in range(m):
i, j = map(int, input().split(' '))
bomb.add((i, j))
H[i] += 1
W[j] += 1
max_h = max(H)
max_w = max(W)
target_h = [i for i, v in enumerate(H) if v == max_h]
target_w = [i for i, v in enumerate(W) if v == max_w]
for m in target_h:
for n in target_w:
if (m, n) not in bomb:
print(max_h + max_w)
sys.exit()
print(max_h + max_w - 1) | 0 | null | 84,281,306,557,620 | 289 | 89 |
#70 C - 100 to 105 WA
X = int(input())
dp = [0]*(100010)
lst = [100,101,102,103,104,105]
for i in range(100,106):
dp[i] = 1
# dp[v] が存在するなら 1, しないなら 0
for v in range(100,X+1):
for w in range(6):
n = lst[w]
if dp[v-n] == 1:
dp[v] = 1
print(dp[X]) | N = int(input())
ans = 1000*(1+(int)((N-1)/1000))-N
print(ans) | 0 | null | 68,155,258,863,770 | 266 | 108 |
from collections import defaultdict
import sys
input = sys.stdin.buffer.readline
def mod_pow(x, n, mod=10**9 + 7) -> int:
"""
O(log n)
"""
if n == 0:
return 1
K = 1
while n > 1:
if n % 2 != 0:
K *= x
K %= mod
x *= x
x %= mod
n //= 2
return (K * x) % mod
MOD = 998244353
n = int(input())
D = [int(i) for i in input().strip().split()]
_max = max(D)
counts = defaultdict(int)
if D[0] != 0:
print(0)
sys.exit()
for d in D:
counts[d] += 1
if counts[0] != 1:
print(0)
sys.exit()
ans = 1
for i in range(1, _max + 1):
if i not in counts.keys():
print(0)
sys.exit()
elif i == 1:
continue
else:
x = counts[i - 1]
k = counts[i]
ans = (ans * mod_pow(x, k, MOD)) % MOD
print(ans)
| n = int(input())
d = list(map(int, input().split()))
a = [0] * n
for i in range(n):
a[d[i]] += 1
if a[0] == 1 and d[0] == 0:
ans = 1
for i in range(1, n):
ans *= a[i-1]**a[i]
ans %= 998244353
print(ans)
else:
print(0) | 1 | 154,792,007,337,520 | null | 284 | 284 |
import sys
input = sys.stdin.readline
N, D = map(int, input().split())
points = [list(map(int, input().split())) for _ in range(N)]
D_2 =pow(D, 2)
count = 0
for i in range(N):
a = pow(points[i][0], 2) + pow(points[i][1], 2)
if D_2 >= a:
count +=1
print(count)
| import sys
N, D = map(int, input().split())
ans = 0
for _ in range(N):
x, y = map(int, sys.stdin.readline().split())
if x **2 + y**2 <= D**2:
ans += 1
print(ans) | 1 | 5,985,047,483,688 | null | 96 | 96 |
import numpy as np
A,B,N = map(int,input().split())
if B <= N:
x = B-1
print(int(np.floor(A*x/B)))
else:
print(int(np.floor(A*N/B))) | import sys
input = sys.stdin.readline
def main():
a,b,n = map(int,input().split())
if n < b:
print((a*n)//b)
exit()
num = n//b
ans = (a*(b-1))//b
print(max(ans,(a*n)//b - a * (n//b)))
if __name__ == '__main__':
main()
| 1 | 28,290,572,850,972 | null | 161 | 161 |
import itertools
import functools
import math
from collections import Counter
from itertools import combinations
import re
N,K=map(int,input().split())
cnt = 1
while True:
if cnt > 10000:
break
if N // K**cnt == 0:
print(cnt)
exit()
cnt += 1
| #!python3
from collections import deque
LI = lambda: list(map(int, input().split()))
# input
N, M = LI()
S = input()
INF = 10 ** 6
def main():
w = [(INF, INF)] * (N + 1)
w[0] = (0, 0)
# (cost, index)
dq = deque([(0, 0)])
for i in range(1, N + 1):
if i - dq[0][1] > M:
dq.popleft()
if len(dq) == 0:
print(-1)
return
if S[i] == "0":
w[i] = (dq[0][0] + 1, i - dq[0][1])
dq.append((w[i][0], i))
ans = []
x = N
while x > 0:
d = w[x][1]
ans.append(d)
x -= d
ans = ans[::-1]
print(*ans)
if __name__ == "__main__":
main()
| 0 | null | 101,687,268,490,278 | 212 | 274 |
from collections import defaultdict, deque
import math
kMod = 1000000007
N = int(input())
key2count = defaultdict(lambda: [0, 0])
for _ in range(N):
a, b = map(int, input().split())
g = math.gcd(a, b)
if a < 0 or a == 0 and b < 0:
a, b = -a, -b
if g > 0:
a, b = a//g, b//g
idx = 0
if b <= 0:
idx = 1
a, b = -b, a
key2count[(a, b)][idx] += 1
ans = 1
for key, val in key2count.items():
if key == (0, 0):
continue
plus, minus = val
ans *= (pow(2, plus, kMod) + pow(2, minus, kMod)-1)
ans %= kMod
ans += sum(key2count[(0, 0)])
print((ans + kMod-1) % kMod) | import math
N = int(input())
T = []
for i in range(N):
a = list(map(int, input().split()))
T.append(a)
mod = 10**9+7
A = {}
c_zero = 0
a_zero = 0
b_zero = 0
for i in range(N):
if T[i][0] == 0 and T[i][1] == 0:
c_zero += 1
elif T[i][0] == 0:
a_zero += 1
elif T[i][1] == 0:
b_zero += 1
else:
t = math.gcd(abs(T[i][0]),abs(T[i][1]))
c = 0
if T[i][0] < 0:
T[i][0] *= -1
c += 1
if T[i][1] < 0:
T[i][1] *= -1
c += 1
if (T[i][0]//t,T[i][1]//t,c%2) in A:
A[T[i][0]//t,T[i][1]//t,c%2] += 1
else:
A[T[i][0]//t,T[i][1]//t,c%2] = 1
used = {}
for i in A.keys():
used[i] = 0
ans = 1
for k,v in A.items():
if used[k] == 0:
if k[2] == 1:
p = A.get((k[1],k[0],0),0)
if p != 0:
used[(k[1],k[0],0)] = 1
else:
p = A.get((k[1],k[0],1),0)
if p != 0:
used[(k[1],k[0],1)] = 1
ans *= ( pow(2,v,mod)+pow(2,p,mod) - 1 )
ans %= mod
ans *= ( pow(2,a_zero,mod)+pow(2,b_zero,mod) - 1 )
ans += c_zero
ans -= 1
print(ans%mod) | 1 | 20,955,490,955,700 | null | 146 | 146 |
from collections import Counter
def mpow(a,b,mod):
ret=1
while b>0:
if b&1:
ret=(ret*a)%mod
a=(a*a)%mod
b>>=1
return ret
n,p=map(int,input().split())
s=[int(i) for i in input()]
if p==2 or p==5:
ans=0
for i in range(n):
if s[i]%p==0:
ans+=i+1
print(ans)
else:
ans=0
d=Counter()
d[0]+=1
num=0
for i in range(n-1,-1,-1):
num=(num+s[i]*mpow(10,n-1-i,p))%p
ans+=d[num]
d[num]+=1
print(ans)
| import math
N, K = map(int, input().split())
As = list(map(int, input().split()))
def cut_num(a, cut_length):
return math.ceil(a/cut_length) - 1
"""cut length N binary search
if cut num > K, search more longer cut length,
"""
l = 1
r = max(As)
m = (l+r)//2
ans = r
while r > l + 1:
current_cut_num = sum([cut_num(a, m) for a in As])
if current_cut_num <= K:
r = m
else:
l = m
m = (l+r)//2
if sum([cut_num(a, l) for a in As]) <= K:
print(l)
else:
print(r) | 0 | null | 32,379,463,166,908 | 205 | 99 |
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
import numpy as np
MOD = 10 ** 9 +7
n,m = map(int,readline().split())
a = np.array(read().split(),np.int64)
a.sort()
def shake_cnt(x):
X=np.searchsorted(a,x-a)
return n*n-X.sum()
left = 0
right = 10 ** 6
while left+1 <right:
x = (left + right)//2
if shake_cnt(x) >= m:
left = x
else:
right = x
left,right
X=np.searchsorted(a,right-a)
Acum = np.zeros(n+1,np.int64)
Acum[1:] = np.cumsum(a)
shake = n * n -X.sum()
happy = (Acum[-1]-Acum[X]).sum()+(a*(n-X)).sum()
happy += (m-shake)*left
print(happy) | import sys
import itertools
# import numpy as np
import time
import math
sys.setrecursionlimit(10 ** 7)
from collections import defaultdict
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
n = int(input())
A = list(map(int, input().split()))
MOD = 10 ** 9 + 7
x = 1
ans = 0
for i in range(60):
ones = 0
zeros = 0
for a in A:
if a & (1 << i) > 0:
ones += 1
else:
zeros += 1
ans += (ones * zeros * x) % MOD
x *= 2
print(ans % MOD)
| 0 | null | 115,536,552,797,600 | 252 | 263 |
from collections import Counter,defaultdict,deque
from heapq import heappop,heappush
from bisect import bisect_left,bisect_right
import sys,math,itertools,fractions,pprint
sys.setrecursionlimit(10**8)
mod = 10**9+7
INF = float('inf')
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
def f(x):
cnt = 0
while x%2 == 0:
cnt += 1
x //= 2
return cnt
def lcm(x,y):
return x*y//math.gcd(x,y)
n,m = inpl()
a = inpl()
a = list(set(a))
c = list(set([f(x) for x in a]))
if len(c) != 1:
print(0)
quit()
c = c[0]
x = 1
for i in range(len(a)):
x = lcm(a[i]//2, x)
# print(x)
print((m+x)//(2*x)) | import numpy as np
import scipy.sparse as sps
import scipy.misc as spm
import collections as col
import functools as func
import itertools as ite
import fractions as frac
import math as ma
from math import cos,sin,tan,sqrt
import cmath as cma
import copy as cp
import sys
import re
import bisect as bs
sys.setrecursionlimit(10**7)
EPS = sys.float_info.epsilon
PI = np.pi; EXP = np.e; INF = np.inf
MOD = 10**9 + 7
def sinput(): return sys.stdin.readline().strip()
def iinput(): return int(sinput())
def imap(): return map(int, sinput().split())
def fmap(): return map(float, sinput().split())
def iarr(n=0):
if n: return [0 for _ in range(n)]
else: return list(imap())
def farr(): return list(fmap())
def sarr(n=0):
if n: return ["" for _ in range(n)]
else: return sinput().split()
def adj(n): return [[] for _ in range(n)]
#整数問題セット
def gcd(numbers): return func.reduce(frac.gcd, numbers)
def lcm(numbers): return func.reduce(LCM, numbers)
def inv(a): return pow(a, MOD-2, MOD) #逆元
def comb(n,r):
ans = 1
for i in range(r): ans *= n-i; ans *= inv(r-i); ans %= MOD
return ans
n,a,b = imap()
ans = pow(2,n,MOD) - comb(n,a) - comb(n,b) - 1
print(ans%MOD)
| 0 | null | 83,719,981,622,508 | 247 | 214 |
N, K, *A = map(int, open(0).read().split())
MOD = 10 ** 9 + 7
s = [] # v >= 0
t = [] # v < 0
for i in range(N):
if A[i] < 0:
t.append(A[i])
else:
s.append(A[i])
ok = False # ans > 0
if len(s) > 0:
if N == K:
ok = len(t) % 2 == 0
else:
ok = True
else:
ok = K % 2 == 0
ans = 1
if not ok:
x = sorted(A, key=lambda x: abs(x))
for i in range(K):
ans = ans * x[i] % MOD
else:
s.sort()
t.sort(key=lambda x: abs(x))
if K % 2 == 1:
ans = ans * s.pop() % MOD
p = []
while len(s) >= 2:
x = s.pop() * s.pop()
p.append(x)
while len(t) >= 2:
x = t.pop() * t.pop()
p.append(x)
p.sort(reverse=True)
for i in range(K // 2):
ans = ans * p[i] % MOD
print(ans)
| n, k = map(int, input().split())
a = list(map(int, input().split()))
mod = 10 ** 9 + 7
if max(a) < 0:
a.sort()
ans = 1
if k % 2 == 0:
for e in a[:k]:
ans *= e
ans %= mod
else:
for e in a[-k:]:
ans *= e
ans %= mod
print(ans)
elif k == n:
ans = 1
for e in a:
ans *= e
ans %= mod
print(ans)
else:
neg = []
pos = []
for e in a:
if e < 0:
neg.append(e)
else:
pos.append(e)
neg.sort()
pos.sort(reverse=True)
ans = 1
if k % 2:
ans *= pos.pop(0)
k -= 1
nums = [e1 * e2 for e1, e2 in zip(neg[::2], neg[1::2])]
nums += [e1 * e2 for e1, e2 in zip(pos[::2], pos[1::2])]
nums.sort(reverse=True)
for e in nums[:k//2]:
ans *= e
ans %= mod
print(ans)
| 1 | 9,474,180,518,000 | null | 112 | 112 |
import math
y=int(input())
cnt=0
for i in range (1,y+1):
for k in range(1,y+1):
for j in range(1,y+1):
a = [i,j,k]#リスト
ans = a[0]
for x in range(len(a)):
ans = math.gcd(ans, a[x])
cnt+=ans
print(cnt) | import math
K = int(input())
total = 0
for x in range(1, K+1):
for y in range(1, K+1):
for z in range(1, K+1):
total = total+math.gcd(x, math.gcd(y, z))
print(total)
| 1 | 35,600,313,659,680 | null | 174 | 174 |
def count_divisors(num, start, end):
"""
num: positive int
start: positive int
end: positive int(end > start)
returns numbers of devisors of i between start and end
>>> count_divisors(80, 5, 14)
3
>>> count_divisors(12, 1, 4)
4
"""
count = 0
for i in range(start, end+1):
if num % i == 0:
count += 1
return count
if __name__ == '__main__':
#import doctest
#doctest.testmod()
(a, b, c) = [int(i) for i in input().split(' ')]
print(count_divisors(c, a, b)) | x = input().split(" ")
a = 0
for i in range(int(x[0]),int(x[1]) + 1):
if int(x[2]) % int(i) == 0:
a += 1
print(a)
| 1 | 572,513,861,542 | null | 44 | 44 |
import sys
import time
import random
import math
from collections import deque
import heapq
import itertools
from decimal import Decimal
import bisect
from operator import itemgetter
MAX_INT = int(10e18)
MIN_INT = -MAX_INT
mod = 1000000000+7
sys.setrecursionlimit(1000000)
def IL(): return list(map(int,input().split()))
def SL(): return input().split()
def I(): return int(sys.stdin.readline())
def S(): return input()
def tami(ans):
res = 0
LastDay = [0]*26
for i in range(D):
res += s[i][ans[i]]
for j in range(26):
if ans[i] == j:
continue
res -= (i+1 - LastDay[j]) * c[j]
LastDay[ans[i]] = i+1
return res
def nasu():
res = []
LastDay = [0]*26
for d in range(1,D+1):
tmp = ["", 0]
for i in range(26):
if tmp[1] < s[d-1][i] + (d - LastDay[i]) * c[i]:
tmp = [i, s[d-1][i] + (d - LastDay[i]) * c[i]]
res.append(tmp[0])
LastDay[tmp[0]] = d
return res
def nbo(ans, score, num):
tmp_ans = ans[:]
for _ in range(num):
random_date = random.randint(0,D-1)
random_val = random.randint(0,25)
tmp_ans[random_date] = random_val
scoscore = tami(tmp_ans)
if scoscore > score:
return (True, tmp_ans, scoscore)
else:
return (False, tmp_ans, scoscore)
start = time.time()
D = I()
c = IL()
s = [IL() for i in range(D)]
ans = nasu()
#print(ans)
score = tami(ans)
#print(score)
end = time.time()
num = 4
while (time.time() - start) < 1.8:
judge, anans, scoscore = nbo(ans, score, num)
if judge == True:
ans, score = anans, scoscore
#print(ans)
#print(tami(ans))
for i in ans:
print(i+1) | def main():
N,M=map(int,input().split())
S=input()
c,l=N,[]
while c>0:
for i in range(M,0,-1):
if i<=c and S[c-i]=='0':
l+=[i]
c-=i
break
else:
l=[-1]
break
print(*l[::-1])
main()
| 0 | null | 74,209,865,976,532 | 113 | 274 |
import math
a, b, x = map(int, input().split())
if x/(a*a*b) <= 0.5: #水が水筒の半分以下の場合
h = x/a/b*2
hy2 = (h*h + b*b)
cosa = (hy2 + b*b - h*h )/(2*(hy2**0.5)*b)
d = 180 - math.degrees(math.acos(cosa)) - 90
else:
rest = (a*a*b - x)/a
tan = rest*2/(a*a) #空の部分の面積は、a*atanθ/2 = a*a*b - x
d = math.degrees(math.atan(tan))
print(d) | a, b, k = map(int, input().split())
ac, k = min(a, k), k - min(a, k)
bc = min(b, k)
print(a-ac, b-bc) | 0 | null | 133,659,378,646,720 | 289 | 249 |
from math import floor
a, b = map(int, input().split(' '))
d = False
for p in range(1009):
if floor(p * 0.08) == a and floor(p * 0.1) == b:
print(p)
d = True
break
if not d:
print(-1) | from collections import deque
import sys
sys.setrecursion = 10000000
def solve():
n = int(input())
print([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][n-1])
solve() | 0 | null | 53,285,078,015,920 | 203 | 195 |
n = int(input())
A = list(map(int,input().split()))
groups = []
prev = A[0]
for i in range(1,n):
if A[i] != prev:
groups.append(prev)
prev = A[i]
groups.append(prev)
if len(groups) == 1:
print(1000)
exit()
money = 1000
stock = 0
if groups[0] < groups[1]:
buy = money//groups[0]
stock += buy
money -= groups[0]*buy
for i in range(1,len(groups)-1):
if groups[i-1] < groups[i] and groups[i] > groups[i+1]:# 周辺の最高値
money += stock*groups[i]
stock = 0
elif groups[i-1] > groups[i] and groups[i] < groups[i+1]:# 周辺の最安値
buy = money//groups[i]
stock += buy
money -= groups[i]*buy
money += stock*groups[-1]
print(money) | 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() | 1 | 7,267,593,590,240 | null | 103 | 103 |
x=input()
y=input()
lst1=[]
lst1=list(x)
lst2=[]
lst2=list(y)
b=0
ans=0
while(b<len(x)):
if(not lst1[b]==lst2[b]):
ans=ans+1
b+=1
print(ans) | s = list(input())
t = list(input())
cnt = 0
for x,y in zip(s,t):
if x != y:
cnt += 1
print(cnt)
| 1 | 10,469,922,199,198 | null | 116 | 116 |
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))
| N = int(input())
C = input().split()
_C = C.copy()
for i in range(N):
for j in range(N-1, i, -1):
if (C[j][1] < C[j-1][1]):
C[j], C[j-1] = C[j-1], C[j]
print(*C)
print("Stable")
for i in range(N):
m = i
for j in range(i, N):
if (_C[j][1] < _C[m][1]):
m = j
_C[i], _C[m] = _C[m], _C[i]
print(*_C)
if(C ==_C):
print("Stable")
else:
print("Not stable") | 0 | null | 9,448,826,771,232 | 141 | 16 |
# -*- coding: utf-8 -*-
input = input().strip().split(" ")
a = int(input[0])
b = int(input[1])
print(a * b, 2 * a + 2 * b) | from decimal import Decimal
a,b,c = map(int, input().split())
def convert(x):
return Decimal(str(x)).sqrt()
if convert(a) + convert(b) < convert(c):
print('Yes')
else:
print('No') | 0 | null | 25,826,321,450,460 | 36 | 197 |
D = int(input())
c = list(map(int, input().split()))
s = [list(map(int, input().split())) for _ in range(D)]
t = [int(input()) - 1 for _ in range(D)]
def cal_score():
S = 0
last = [-1] * 26
score = 0
for d in range(D):
S += s[d][t[d]]
last[t[d]] = d
for i in range(26):
S -= c[i] * (d - last[i])
score += max(10 ** 6 + S, 0)
print(S)
if __name__ == "__main__":
cal_score() | n,k = map(int,input().split())
li = []
for i in range(k) :
gomi = input()
[li.append(int(j)) for j in input().split()]
st = set(li)
print(n - len(st)) | 0 | null | 17,241,259,095,466 | 114 | 154 |
import sys
import math
import fractions
from collections import defaultdict
stdin = sys.stdin
ns = lambda: stdin.readline().rstrip()
ni = lambda: int(stdin.readline().rstrip())
nm = lambda: map(int, stdin.readline().split())
nl = lambda: list(map(int, stdin.readline().split()))
mod=998244353
N,S=nm()
A=nl()
dp=[[0]*3001 for _ in range(3001)]#i i番目 j和がj
dp[0][A[0]]=1
dp[0][0]=2
for i in range(1,N):
for j in range(0,3001):
if(0<=(j-A[i])):
dp[i][j]=dp[i-1][j-A[i]]+2*dp[i-1][j]
else:
dp[i][j]=2*dp[i-1][j]
dp[i][j]%=mod
ans=dp[N-1][S]
print(ans%mod) | a,b = (input().split())
print(int(a)*int(b)) | 0 | null | 16,807,706,319,418 | 138 | 133 |
N = int(input())
print(input().count("ABC"))
""" 3文字ずつスライスし判定
S = input()
count = 0
# スライスでi+2文字目まで行くのでfor文範囲はN-2でとどめる
for i in range(N-2):
if S[i:i+3] == "ABC":
count += 1
print(count) """ | N = int(input())
S = input()
count = 0
for k in range(N-2):
if S[k:k+3] == 'ABC':
count += 1
print(count) | 1 | 99,055,810,604,896 | null | 245 | 245 |
N = int(input())
s = input()
ans = min(s.count('R'), s.count('W'), s[N-s.count('W'):].count('R'))
print(ans) | # import sys
# input = sys.stdin.readline
import collections
def main():
n = int(input())
s = input()
a_list = []
for i in range(n):
if s[i] == "W":
a_list.append(0)
else:
a_list.append(1)
r_count = sum(a_list)
print(r_count - sum(a_list[0:r_count]))
def input_list():
return list(map(int, input().split()))
def input_list_str():
return list(map(str, input().split()))
if __name__ == "__main__":
main()
| 1 | 6,248,611,011,390 | null | 98 | 98 |
import heapq
X,Y,A,B,C = map(int, input().split())
p_list = sorted([(-v, 'p') for v in map(int, input().split())])
q_list = sorted([(-v, 'q') for v in map(int, input().split())])
r_list = sorted([(-v, 'r') for v in map(int, input().split())])
res = 0
r_cnt = 0
for v, k in heapq.merge(p_list, q_list, r_list):
v = -v
if X+Y-r_cnt == 0:
break
if k == 'p':
if X != 0:
X -= 1
res += v
continue
if k == 'q':
if Y != 0:
Y -= 1
res += v
continue
res += v
r_cnt += 1
print(res)
| def LI():
return list(map(int, input().split()))
X, Y, A, B, C = LI()
red = LI()
green = LI()
mu = LI()
red.sort(reverse=True)
green.sort(reverse=True)
ans = red[:X]+green[:Y]+mu
ans.sort(reverse=True)
total = 0
for i in range(X+Y):
total += ans[i]
print(total)
| 1 | 44,808,964,713,060 | null | 188 | 188 |
import sys
input = sys.stdin.readline
def main():
X, Y = map(int, input().split())
ans = 0
for i in [X, Y]:
if i == 1:
ans += 300000
elif i == 2:
ans += 200000
elif i == 3:
ans += 100000
if X == Y == 1:
ans += 400000
print(ans)
if __name__ == "__main__":
main()
| def award(x):
return max(0, 4*(10**5) - x*(10**5))
x,y = map(int,input().split())
ans = award(x)
ans += award(y)
if x == 1 and y == 1:
ans += 4*(10**5)
print(ans) | 1 | 140,195,229,883,008 | null | 275 | 275 |
print(*input().split()[::-1],sep="") | n,k = input().split(" ")
cost = input().split(" ")
a = []
for i in cost:
a.append(int(i))
a.sort()
sum = 0
for i in range(int(k)):
sum += int(a[i])
print(sum) | 0 | null | 57,550,798,057,298 | 248 | 120 |
n = int(input())
print((pow(10,n) - pow(9, n) - pow(9, n) + pow(8, n))%(10**9+7)) | N = int(input())
a = list(map(int, input().split()))
cnt = 0
for i in range(0, N, 2):
if a[i] % 2 == 1:
cnt += 1
print(cnt) | 0 | null | 5,472,524,727,868 | 78 | 105 |
n, x, m = map(int, input().split())
amr = []
for i in range(n):
if i == 0:
x %= m
amr.append(x)
continue
x = pow(x, 2, m)
if x in amr:
break
if x == 0:
break
amr.append(x)
if x == 0:
print(sum(amr[:n]))
else:
idx = amr.index(x)
loop = sum(amr[idx:])
l = len(amr[idx:])
if n >= idx:
cnt = (n-idx)//l
print(cnt*loop + sum(amr[:idx]) + sum(amr[idx:idx+n-idx-cnt*l:]))
else:
print(sum(amr[:n]))
| N = int(input())
A = [int(i) for i in input().split(" ")]
Min = float("inf")
index = 0
L = 0
R = sum(A)
for i in range(0,len(A)):
L+=A[i]
R-=A[i]
diff = abs(L - R)
if diff < Min:
Min = diff
print(Min) | 0 | null | 72,122,150,052,320 | 75 | 276 |
A, B, N = map(int, input().split())
x = min(B-1, N)
ans = (A * x // B) - A * (x // B)
print(ans)
| import sys
from functools import lru_cache
from collections import defaultdict
inf = float('inf')
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10**6)
def input(): return sys.stdin.readline().rstrip()
def read():
return int(readline())
def reads():
return map(int, readline().split())
a,b,n=reads()
x=min(b-1,n)
print(int((a*x)/b))
| 1 | 28,061,318,324,390 | null | 161 | 161 |
import sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7 # 998244353
input=lambda:sys.stdin.readline().rstrip()
def resolve():
n = int(input())
A = list(map(int,input().split()))
if n & 1 == 0:
res = -INF
score = sum(A[::2])
res = max(res, score)
for i in range(n-1,-1,-1):
if i & 1:
score += A[i]
else:
score -= A[i]
res = max(res, score)
print(res)
return
front_dp = [None] * n
choose = -INF
not_choose = 0
for i in range(1, n, 2):
choose, not_choose = max(choose, not_choose) + A[i], not_choose + A[i-1]
front_dp[i] = max(choose, not_choose)
back_dp = [None] * n
choose = -INF
not_choose = 0
for i in range(n-2, -1, -2):
choose, not_choose = max(choose, not_choose) + A[i], not_choose + A[i+1]
back_dp[i] = max(choose, not_choose)
res = -INF
for i in range(1, n, 2):
if i + 2 < n:
res = max(res, front_dp[i] + back_dp[i+2])
res = max(res, front_dp[-2])
res = max(res, back_dp[1])
print(res)
resolve() | N, K = map(int, input().split())
A = list(map(int, input().split()))
# 丸太がすべてxの長さ以下になる回数を出し、それがＫ回以下か判定する
def f(x):
now = 0
for i in range(N):
now += (A[i]-1)//x
return now <= K
l = 0
r = 10**9
while r-l > 1:
mid = (r+l)//2
if f(mid):
r = mid
else:
l = mid
print(r) | 0 | null | 21,808,210,022,972 | 177 | 99 |
x, k, d = map(int, input().split())
def sgn(x):
if x > 0:
return 1
if x < 0:
return -1
return 0
if x > 0:
x1 = x - k * d
else:
x1 = x + k * d
if sgn(x) == sgn(x1):
print(abs(x1))
exit()
xright = x % d
xleft = x % d - d
#0目前
xr = (abs(x - xright) // d) % 2
if k % 2 == xr:
print(abs(xright))
elif k % 2 != xr:
print(abs(xleft)) | import sys
def input():
return sys.stdin.readline().rstrip('\n')
def calc(X, K, D):
X = abs(X)
n = X // D
if K <= n:
return abs(X - K * D)
if (K - n) % 2 == 0:
return abs(X - n * D)
else:
return abs(X - (n + 1) * D)
(X, K, D) = tuple([int(s) for s in input().split()])
print(calc(X, K, D)) | 1 | 5,172,612,450,060 | null | 92 | 92 |
n,k = map(int,input().split())
ke = 1
while(True):
if(n<k):
print(ke)
break
else:
n = n//k
ke += 1 | n,k= map(int,input().split())
temp = 1
cnt = 0
while n >= temp:
temp *= k
cnt += 1
print(max(1,cnt)) | 1 | 63,999,915,685,280 | null | 212 | 212 |
tes1 = input()
tes1 = int(tes1)
tes1 = tes1**3
print(tes1) | n = int(input())
print(n * n * n) | 1 | 283,254,589,200 | null | 35 | 35 |
#C
def gcd(a, b):
while b:
a, b = b, a % b
return a
K = int(input())
ans = 0
for a in range(1,K+1):
for b in range(a,K+1):
for c in range(b,K+1):
if a != b and b != c and a != c:
ans += 6*gcd(gcd(a,b),c)
elif a == b or b == c or a == c:
if a == b and b == c:
ans += gcd(gcd(a,b),c)
else:
ans += 3*gcd(gcd(a,b),c)
print(ans) | from math import gcd
from itertools import combinations_with_replacement
k = int(input())
lst = [i for i in range(1,k+1)]
itr = combinations_with_replacement(lst, 3)
ans = 0
for i in itr:
st = set(i)
num = len(st)
if num == 1:
ans += i[0]
elif num == 2:
a,b = st
ans += gcd(a,b) * 3
else:
ans += gcd(gcd(i[0],i[1]), i[2]) * 6
print(ans) | 1 | 35,330,828,744,056 | null | 174 | 174 |
from math import sqrt
N = int(input())
result = [0] * N
n = int(sqrt(N))
for x in range(1, n+1):
for y in range(1, n+1):
for z in range(1, n+1):
check = x**2 + y**2 + z**2 + x * y + y * z + z * x
if check <= N:
result[check-1] += 1
for i in result:
print(i)
| n=int(input())
l=[0]*(n+1)
for i in range(1,101):
for j in range(1,101):
for k in range(1,101):
s=i**2+j**2+k**2+i*k+i*j+j*k
if(s<=n):
l[s]+=1
for i in range(1,n+1):
print(l[i])
| 1 | 7,932,895,735,758 | null | 106 | 106 |
import sys
readline = sys.stdin.readline
inf = float('inf')
def main():
H, W = map(int, readline().split())
grid = []
grid.append(['*'] * (W+2))
for _ in range(H):
grid.append(['*'] + list(readline()[:-1]) + ['*'])
grid.append(['*']*(W+2))
DP = [[inf] * (W+2) for _ in range(H+2)]
DP[1][1] = (grid[1][1] == '#')*1
for i in range(1, H+1):
for j in range(1, W+1):
if i == 1 and j == 1:
continue
k = i
gridkj = grid[k][j]
if gridkj == '.':
DP[k][j] = min(DP[k][j-1], DP[k-1][j])
if gridkj == '#':
DP[k][j] = min(DP[k][j-1]+(grid[k][j-1] in ['.', '*']), DP[k-1][j] + (grid[k-1][j] in ['.', '*']))
ans = DP[H][W]
print(ans)
if __name__ == "__main__":
main()
| import sys
# import re
# import math
import collections
# import decimal
# import bisect
# import itertools
# import fractions
# import functools
import copy
# import heapq
# import decimal
# import statistics
import queue
sys.setrecursionlimit(10000001)
INF = 10 ** 16
MOD = 10 ** 9 + 7
MOD2 = 998244353
ni = lambda: int(sys.stdin.readline())
ns = lambda: map(int, sys.stdin.readline().split())
na = lambda: list(map(int, sys.stdin.readline().split()))
# ===CODE===
def main():
n = ni()
d = na()
c = collections.Counter(d)
lim = max(c)
flg = False
if d[0] != 0:
flg = True
if c[0] != 1:
flg = True
for i in range(lim + 1):
if i not in c.keys():
flg = True
break
if flg:
print(0)
exit(0)
ans = 1
for i in range(2, lim + 1):
ans *= pow(c[i - 1], c[i], MOD2)
ans %= MOD2
print(ans)
if __name__ == '__main__':
main()
| 0 | null | 101,959,001,238,730 | 194 | 284 |
N = input()
a = []
for i in range(int(N)):
s = input().split()
ss = [int(s[0]), int(s[1]), int(s[2])]
ss.sort()
if ss[2]**2 == ss[0]**2 + ss[1]**2:
print("YES")
else:
print("NO") | import collections
S1 = collections.deque()
s_a = 0
S2 = collections.deque()
for i, j in enumerate(input()):
if j == '\\':
S1.append(i)
elif j == '/':
if S1:
left_edge = S1.pop()
diff = i - left_edge
s_a += diff
new_puddle_a = diff
while True:
if S2:
if S2[-1][0] > left_edge:
new_puddle_a += S2[-1][1]
S2.pop()
else:
break
else:
break
new_puddle = (left_edge, new_puddle_a)
S2.append(new_puddle)
else:
pass
print(s_a)
num_of_puddles = len(S2)
puddles = str(num_of_puddles)
for i in range(num_of_puddles):
puddle = S2.popleft()
puddles += ' {0}'.format(str(puddle[1]))
else:
print(puddles) | 0 | null | 28,688,741,576 | 4 | 21 |
import sys
sys.setrecursionlimit(10**6)
def solve(n,a):
wa=0
for i in range(n):
if(i%2==0):
wa+=a[i]
kotae=wa
for i in range(n//2):
wa+=a[(n//2-i-1)*2+1]
wa-=a[(n//2-i-1)*2]
if(wa>kotae):
kotae=wa
return kotae
def dfs(n,a,k):
global zen
zen.append([n,k])
if(k==1):
return max(a)
ari=a[n-1]+dfs(n-2,a[:n-2],k-1)
if(n==k*2-1):
return ari
nasi=dfs(n-1,a[:n-1],k)
return max(ari,nasi)
n=int(input())
a=list(map(int,input().split()))
if(n%2==0):
print(solve(n,a))
else:
data=[[a[0],a[0]],[max(a[:2]),max(a[:2])]]
#data.append([max(a[:3]),sum(a[:3])-min(a[:3])])
data.append([max(a[:3]),a[0]+a[2]])
for i in range(3,n):
if(i%2==1):
ari=a[i]+data[i-2][0]
nasi=data[i-1][1]
saiyo=max(ari,nasi)
data.append([saiyo,saiyo])
else:
ooi=a[i]+data[i-2][1]
nasi=data[i-1][1]
ari=a[i]+data[i-2][0]
sukunai=max(ari,nasi)
data.append([sukunai,ooi])
print(data[n-1][0]) | n = int(input())
a = list(map(int, input().split()))
if n % 2 == 0:
ans, cnt = 0, 0
for i in range(n):
if i % 2 == 1:
ans += a[i]
cnt += a[i]
for i in range(n):
if i % 2 == 0:
cnt += a[i]
else:
cnt -= a[i]
ans = max(cnt, ans)
else:
a.insert(0, 0)
dp = [[0] * (n + 1) for _ in range(3)]
for i in range(3):
for j in range(1 + i, n + i - 1, 2):
if i == 0:
if j == 1:
dp[i][j] = a[j]
else:
dp[i][j] = dp[i][j - 2] + a[j]
else:
dp[i][j] = max(dp[i - 1][j - 1], dp[i][j - 2] + a[j])
ans = dp[2][n]
print(ans) | 1 | 37,328,954,568,288 | null | 177 | 177 |
D = int(input())
C = [int(i) for i in input().split()]
scores = [[int(i) for i in input().split()] for j in range(D)]
t = [int(input()) for i in range(D)]
ans = []
S = 0
last = [0]*26
for d in range(1,D+1):
S += scores[d-1][t[d-1]-1]
last[t[d-1]-1] = d
for i in range(26):
S -= C[i] * (d - last[i])
ans.append(S)
print("\n".join(map(str, ans))) | '''
N人を円周上に配置し、M本の線分で結ぶ。
このとき、線分を回転させていっても同じ人のペアが生まれないようにする。
基本的には、上から順に結べばよい。
'''
from collections import deque
def main():
N, M = map(int, input().split())
if N&1:
'''
・Nが奇数の場合
上から順に結ぶだけ。
dequeに 1,2,3,...,M*2 を突っ込んで、両端から取り出してペアにする。
'''
q = deque(range(M*2))
while q:
print(q.popleft()+1, q.pop()+1)
else:
'''
[Nが偶数の場合]
上から順に結ぶと、上下の線対称になり、同じ間隔のペアが生まれるためNG。
→ 半分以降は、1つずらしてペアを作っていく
簡単に解決するため、
・上から順に奇数間隔ペアを作る
・下から順に偶数間隔ペアを作る
この2つから、M個を順に、交互に取り出す。
'''
q1 = deque(range(N))
q2 = deque(range(N-1))
p1 = []
while q1:
p1.append((q1.popleft()+1, q1.pop()+1))
p2 = []
while len(q2)>=2:
p2.append((q2.popleft()+1, q2.pop()+1))
p2.reverse()
for _ in range(M):
print(*p1.pop())
p1, p2 = p2, p1
main()
| 0 | null | 19,196,527,666,822 | 114 | 162 |
from math import factorial
N = int(input())
A = list(map(int, input().split()))
n = {}
s = 0
for i in range(N):
if A[i] not in n:
n[A[i]] = 1
else:
n[A[i]] += 1
for j in n:
if n[j] > 1:
s += factorial(n[j]) // 2 // factorial(n[j]-2)
for i in range(N):
print(s-n[A[i]]+1)
| N=int(input())
A=list(map(int,input().split()))
d=dict()
for i in range(N):
if A[i] not in d:
d[A[i]]=0
d[A[i]]+=1
x=sum(x*(x-1)//2 for x in d.values())
for i in range(N):
y=d[A[i]]
print(x-y*(y-1)//2+(y-1)*(y-2)//2)
| 1 | 47,701,310,185,860 | null | 192 | 192 |
def resolve():
N, M = list(map(int, input().split()))
AB = {}
for _ in range(M):
a, b = list(map(int, input().split()))
a, b = a-1, b-1
if a not in AB:
AB[a] = []
if b not in AB:
AB[b] = []
AB[a].append(b)
AB[b].append(a)
import collections
q = collections.deque([0])
passed = [-1 for i in range(N)]
passed[0] = 0
while q:
node = q.pop()
for nxt in AB[node]:
if passed[nxt] == -1:
passed[nxt] = node
q.appendleft(nxt)
#print(metrics)
for m in passed:
if m == -1:
print("No")
return
print("Yes")
for i in range(1, N):
print(passed[i]+1)
if '__main__' == __name__:
resolve() | n,m=map(int,input().split())
graph=[[] for _ in range(n)]
for _ in range(m):
a,b=map(int,input().split())
graph[a-1].append(b-1)
graph[b-1].append(a-1)
sign=[-1]*n
sign[0]=0
work=[]
work_next=graph[0]
for x in work_next:
sign[x]=0
while work_next:
work=work_next[:]
work_next=[]
for x in work:
for y in graph[x]:
if sign[y]>=0 : continue
if y in work_next : continue
sign[y]=x
work_next.append(y)
if -1 in sign : print("No");exit()
print("Yes")
for i in range(1,n):
print(sign[i]+1) | 1 | 20,669,227,670,912 | null | 145 | 145 |
from sys import stdin
operate = {
'+': lambda lhs, rhs: lhs + rhs,
'-': lambda lhs, rhs: lhs - rhs,
'*': lambda lhs, rhs: lhs * rhs,
'/': lambda lhs, rhs: lhs // rhs,
}
while True:
arr = (stdin.readline().rstrip().split())
a, op, b = int(arr[0]), arr[1], int(arr[2])
if op == '?':
break
answer = operate[op](a, b)
print(answer)
| # -*- coding: utf-8 -*-
loop = 1
while(loop):
l = list(input().strip().split())
a = int(l[0])
b = int(l[2])
op = l[1]
if(op == "?"):
loop = 0
break;
elif(op == "+"):
ret = a + b
elif(op == "-"):
ret = a - b
elif(op == "*"):
ret = a * b
elif(op == "/"):
ret = a / b
else:
continue
print(int(ret)) | 1 | 694,871,534,380 | null | 47 | 47 |
X = input()
if X.isupper():
print("A")
else:
print("a") | import collections
n = int(input())
d = list(map(int,input().split()))
ma = max(d)
mod = 998244353
if d[0] != 0:
print(0)
exit()
p = [0 for i in range(ma+1)]
for i in range(n):
p[d[i]] += 1
if p[0] != 1:
print(0)
exit()
else:
ans = 1
for i in range(1,ma+1):
ans *= (p[i-1]**p[i])%mod
ans %= mod
print(ans) | 0 | null | 82,773,491,468,198 | 119 | 284 |
n,k=map(int,input().split())
li=list(map(int,input().split()))
li_sort=sorted(li)
ans=0
for i in range(k):
ans+=li_sort[i]
print(ans) | NK = input()
num = NK.split()
N = num[0]
K = num[1]
P = input()
Pn = P.split()
#print(Pn)
Pn_a = [int(i) for i in Pn]
Pn_b = sorted(Pn_a)
price = 0
for i in range(int(K)):
price += int(Pn_b[i])
print(price)
| 1 | 11,609,695,796,840 | null | 120 | 120 |
#!/usr/bin python3
# -*- coding: utf-8 -*-
from bisect import bisect_left, bisect_right
n = int(input())
s = list(input())
q = int(input())
al = 'abcdefghijklmnopqrstuvwxyz'
dicq = {i:[] for i in al}
for i, si in enumerate(s):
dicq[si].append(i)
def q1(iq, cq):
#print(iq,cq,s[iq],dicq[s[iq]],bisect_left(dicq[s[iq]], iq))
dicq[s[iq]].pop(bisect_left(dicq[s[iq]], iq)) #更新前から削除
s[iq] = cq
dicq[cq].insert(bisect_left(dicq[cq], iq), iq) #更新後に追加
def q2(l, r):
ret = 0
for ai in al:
if len(dicq[ai])==0: continue
li = bisect_left(dicq[ai], l)
ri = bisect_right(dicq[ai], r)
if li != ri:
ret += 1
elif li == len(dicq[ai]): continue
elif dicq[ai][li] == l:
ret += 1
# print(l,r,ai,dicq[ai],li,ri,ret)
print(ret)
for i in range(q):
fg, x, y = input().split()
if fg == '1':
q1(int(x)-1, y)
else:
q2(int(x)-1, int(y)-1)
| # D
from collections import Counter
n = int(input())
c = list(input())
d = Counter(c)
# print(d)
# print(d["R"])
e=Counter(c[:d["R"]])
# print(e["R"])
print(d["R"]-e["R"]) | 0 | null | 34,619,778,427,370 | 210 | 98 |
S = input()
print(S[0:3:1]) | b=[]
a=input()
print(a[0:3]) | 1 | 14,664,995,402,320 | null | 130 | 130 |
from collections import deque
alfabet=deque(input())
n=int(input())
reverse=0
for i in range(n):
operation_list=list(input().split())
if int(operation_list[0])==1:
reverse+=1
else:
if int(operation_list[1])==2 and reverse%2==0:
alfabet.append(operation_list[2])
elif int(operation_list[1])==2 and reverse%2==1:
alfabet.appendleft(operation_list[2])
elif int(operation_list[1])==1 and reverse%2==0:
alfabet.appendleft(operation_list[2])
elif int(operation_list[1])==1 and reverse%2==1:
alfabet.append(operation_list[2])
if reverse%2!=0:
alfabet.reverse()
print(''.join(alfabet)) | s=input()
q=int(input())
cnt=0
front=[]
rear=[]
for qq in range(q):
l=list(input().split())
if l[0]=='1':
cnt+=1
else:
if (cnt+int(l[1]))%2==1:
front.append(l[2])
else:
rear.append(l[2])
front=''.join(front[::-1])
rear=''.join(rear)
s=front+s+rear
print(s if cnt%2==0 else s[::-1]) | 1 | 57,232,582,303,772 | null | 204 | 204 |
import math
loopnum = int(input())
cnt = 0
for i in range(loopnum):
chknum = int(input())
rootnum = int(math.sqrt(chknum))
for j in range(2,rootnum+1):
if chknum % j == 0:
break
else:
cnt += 1
# TLE
#for j in range(2,chknum):
# if chknum % j == 0:
# break
#else:
# cnt += 1
print(cnt)
| import math
def prime_array(n=1000):
List = [2]
i = 3
while i <= n:
judge = True
for k in List :
if math.sqrt(i) < k :
break
if i%k == 0:
judge = False
break
if judge :
List.append(i)
i += 2
return List
def main():
cnt=0
prime_List=prime_array(10**4)
n=input()
for i in range(n):
a=input()
if a<=10**4:
for j in prime_List:
if a==j:
cnt+=1
break
else:
judge=True
for j in prime_List:
if a%j==0:
judge=False
break
if judge:
cnt+=1
print('%d' % cnt)
if __name__=='__main__':
main() | 1 | 9,828,002,600 | null | 12 | 12 |
a=int(input())
print(-(-a//2)) | N = int(input())
A = N / 2
A = int(A)
B = (N + 1) / 2
B = int(B)
if N % 2 == 0:
print(A)
else:
print(B)
| 1 | 59,253,953,887,612 | null | 206 | 206 |
r = int(input())
print(round(r * r / 1)) | hankei = input()
print(int(hankei)**2) | 1 | 144,851,439,182,238 | null | 278 | 278 |
n, k = map(int, input().split())
MOD = 10 ** 9 + 7
a = [0] *(k+1)
for x in range(1, k + 1):
a[x] = pow(k // x, n, MOD)
for x in range(k, 0, -1):
for i in range(2, k // x + 1):
a[x] -= a[x * i]
answer = sum([i * x for i,x in enumerate(a)])
print(answer % MOD) | n,k=map(int,input().split())
mod=10**9+7
ans=0
l=[0]*(k+1)
for i in range(k,0,-1):
l[i]=pow(k//i,n,mod)
for j in range(2*i,k+1,i):
l[i]-=l[j]
l[i]=pow(l[i],1,mod)
ans+=l[i]*i
ans=pow(ans,1,mod)
print(ans) | 1 | 36,881,249,907,762 | null | 176 | 176 |
from collections import Counter
n = int(input())
a_array = list(map(int, input().split()))
a_counter = Counter(a_array)
count_max = max(a_counter.values())
def nC2(n):
return n * (n - 1) // 2
nc2_array = [0] * (count_max + 1)
sum_comb = 0
for a, count in a_counter.items():
comb = nC2(count)
sum_comb += comb
nc2_array[count] = comb
nc2_array[count - 1] = nC2(count - 1)
for a in a_array:
a_count = a_counter[a]
ans = sum_comb - nc2_array[a_count] + nc2_array[a_count - 1]
print(ans) | while True:
n, x = map(int,input().split())
count=0
if n == x == 0:
break
else:
ls = []
for i in range(1,n+1):
ls.append(i)
for s in ls:
num1 = s
for j in ls:
if num1 == j:
break
else:
num2 = j
if x < num1+num2:
break
for k in ls:
if num1 == k:
break
elif num2 == k:
break
elif num1+num2+k == x:
count+=1
else:
pass
print(count) | 0 | null | 24,447,139,949,360 | 192 | 58 |
# 145 B
n = int(input())
s = input()
if len(s) % 2 == 0:
x = len(s) // 2
if s[:x] == s[x:]:
print("Yes")
else:
print("No")
else:
print("No") | n=int(input())
s=str(input())
d=True
if len(s)%2==0:
for i in range(len(s)//2):
if s[i]!=s[len(s)//2+i]:
d=False
else:
d=False
if d:
print('Yes')
else:
print('No') | 1 | 146,868,010,047,008 | null | 279 | 279 |
x = int(input());
h = x // 3600;
m = x % 3600 // 60;
s = x % 60;
print(h,m,s,sep=':'); | i = int(input())
h = i // 3600
i -= h * 3600
m = i // 60
i -= m * 60
s = i
print("{}:{}:{}".format(h, m, s))
| 1 | 327,312,841,838 | null | 37 | 37 |
from collections import defaultdict
n, s = map(int, input().split())
aa = tuple(sorted(map(int, input().split())))
MOD = 998244353
dp = [[0 for i in range(s + 1)] for j in range(n + 1)]
dp[0][0] = 1
for i in range(n):
for j in range(s + 1):
# 選ばない場合
dp[i + 1][j] += 2 * dp[i][j]
dp[i + 1][j] %= MOD
# j + a[i]を選んだ場合
if j + aa[i] <= s:
dp[i + 1][j + aa[i]] += dp[i][j]
dp[i + 1][j + aa[i]] %= MOD
print(dp[n][s]) | def main():
N, S = map(int, input().split())
A = list(map(int, input().split()))
MOD = 998244353
dp = [[0] * (S+5) for _ in range(N+5)]
dp[0][0] = 1
for i in range(N):
for j in range(S+1):
dp[i+1][j] += 2 * dp[i][j]
dp[i+1][j] %= MOD
if j + A[i] <= S:
dp[i+1][j+A[i]] += dp[i][j]
dp[i+1][j+A[i]] %= MOD
print(dp[N][S])
if __name__ == "__main__":
main() | 1 | 17,750,046,199,552 | null | 138 | 138 |
from collections import defaultdict
dic = defaultdict(int)
n,x,y = map(int,input().split())
for i in range(1,n+1):
for j in range(i,n+1):
val = min(abs(i-j), abs(x-i) + abs(y-j) + 1)
dic[val] += 1
for i in range(1,n):
print(dic[i]) | import sys
read = sys.stdin.read
readlines = sys.stdin.readlines
from collections import defaultdict
def main():
n, x, y= map(int, input().split())
edges = {e:[] for e in range(n)}
for i1 in range(1, n - 1):
edges[i1].append(i1-1)
edges[i1].append(i1+1)
edges[0].append(1)
edges[n-1].append(n-2)
edges[x-1].append(y-1)
edges[y-1].append(x-1)
dis = defaultdict(int)
for j1 in range(n):
seen = set()
cnt = 0
dis_each = [n] * n
nexts = [j1]
nextnext = []
while len(seen) < n:
for next in nexts:
if next not in seen:
seen.add(next)
dis_each[next] = cnt
nextnext += edges[next]
nexts = nextnext
nextnext = []
cnt += 1
for d in dis_each:
dis[d] += 1
for k1 in range(1, n):
print(dis[k1]//2)
if __name__ == '__main__':
main()
| 1 | 44,217,569,054,736 | null | 187 | 187 |
import sys
#fin = open("test.txt", "r")
fin = sys.stdin
n = int(fin.readline())
d = {}
for i in range(n):
op, str = fin.readline().split()
if op == "insert":
d[str] = 0
else:
if str in d:
print("yes")
else:
print("no") | class dictionary:
def __init__(self):
self._d = set()
def insert(self, s):
self._d.add(s)
def find(self, s):
if s in self._d:
print("yes")
else:
print("no")
if __name__ == '__main__':
dd = dictionary()
n = int(input())
for _ in range(n):
args = input().split()
if args[0] == "insert":
dd.insert(args[1])
elif args[0] == "find":
dd.find(args[1])
| 1 | 74,566,961,688 | null | 23 | 23 |
url = "https://atcoder.jp//contests/abc156/tasks/abc156_a"
def main():
n, r = list(map(int, input().split()))
print(r) if n >= 10 else print(r + 100 * (10 - n))
if __name__ == '__main__':
main()
| X,Y=map(int,input().split())
prize=[0,300000,200000,100000]
ans=0
for c in [X,Y]:
if c<=3:
ans+=prize[c]
if X==Y==1:
ans+=400000
print(ans) | 0 | null | 102,110,834,977,020 | 211 | 275 |
import functools, operator
r,c = tuple(int(n) for n in input().split())
A = [[int(a) for a in input().split()] for i in range(r)]
for a in A:
a.append(sum(a))
R = [functools.reduce(operator.add, x) for x in zip(*A)]
A.append(R)
for j in A:
print(" ".join(map(str,j)))
| n = int(input())
a = list(map(int, input().split()))
a = [(a[i], i) for i in range(n)]
a.sort(key=lambda x: -x[0])
dp = [[0 for _ in range(n+1)] for _ in range(n+1)]
for x in range(n+1):
for y in range(n+1):
if x + y > n:
break
active, idx = a[x+y-1]
if x > 0:
dp[x][y] = max(dp[x][y],
dp[x-1][y] + active * abs(idx - (x-1)))
if y > 0:
dp[x][y] = max(dp[x][y],
dp[x][y-1] + active * abs(idx - (n-y)))
ans = 0
for x in range(n+1):
ans = max(ans, dp[x][n-x])
print(ans) | 0 | null | 17,612,231,266,642 | 59 | 171 |
SIZE = 2**20 # 2**20 > N=500000
class SegmentTree:
def __init__(self, size):
self.size = size
self.seg = [0] * (2 * size)
def update(self, pos, ch):
# update leaf
i = self.size + pos - 1
self.seg[i] = 1 << (ord(ch)-ord('a'))
# update tree
while i > 0:
i = (i - 1) // 2
self.seg[i] = self.seg[i*2+1] | self.seg[i*2+2]
def _query(self, a, b, k, left, right):
if right<a or b<left:
return 0
if a<=left and right<=b:
return self.seg[k]
vl = self._query(a,b,k*2+1, left, (left+right)//2)
vr = self._query(a,b,k*2+2, (left+right)//2+1, right)
return vl | vr
def query(self, a, b):
return self._query(a,b,0,0,self.size-1)
def resolve():
N = int(input())
S = input().strip()
Q = int(input())
table = [[] for _ in range(26)]
sg = SegmentTree(SIZE)
for i,ch in enumerate(S):
sg.update(i, ch)
for i in range(Q):
query = input().strip().split()
if query[0] == '1':
pos = int(query[1])-1
sg.update(pos, query[2])
else:
left = int(query[1])-1
right = int(query[2])-1
bits = sg.query(left, right)
count = 0
for j in range(26):
count += (bits>>j) & 1
print(count)
resolve() | #153-A
H,A = map(int,input().split())
if H % A == 0:
print(H // A)
else:
print( H//A +1)
| 0 | null | 69,939,848,190,278 | 210 | 225 |
#N = int(input())
l = [int(x) for x in input().split()]
if l[0] == l[1]:
print("Yes")
else:
print("No") | a= list(map(int,input().split()))
n=a[0]
m=a[1]
if n==m:
print("Yes")
else:
print("No")
| 1 | 83,138,397,575,130 | null | 231 | 231 |
d=input()
a,b,c=d.split()
if(int(a)<int(b)<int(c)):print('Yes')
else:print('No') | x = raw_input().split()
y = map(int,x)
a = y[0]
b = y[1]
c = a*b
d = (a+b)*2
print c, d | 0 | null | 341,798,247,300 | 39 | 36 |
import numpy as np
A, B, H, M = map(int, input().split())
angle_h = 1./ 12.*(H + M/60.) * 2*np.pi
angle_m = M/60. * 2 * np.pi
hour = (A*np.sin(angle_h), A*np.cos(angle_h))
minute = (B*np.sin(angle_m), B*np.cos(angle_m))
dist = np.sqrt((hour[0] - minute[0])**2 + (hour[1] - minute[1])**2)
print(dist)
| import math
a,b,H,M=map(int,input().split())
theta_a = math.pi/6 * (H+M/60)
theta_b = math.pi*2*M/60
ans = math.sqrt((b*math.cos(theta_b) - a*math.cos(theta_a))**2 + (b*math.sin(theta_b) - a*math.sin(theta_a))**2)
print(ans) | 1 | 20,166,679,182,760 | null | 144 | 144 |
import bisect,collections,copy,itertools,math,string
import sys
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())
def main():
mod = 998244353
n, k = LI()
l = [0 for _ in range(k)]
r = [0 for _ in range(k)]
for i in range(k):
l[i], r[i] = LI()
dp = [0 for _ in range(n+1)]
dpsum = [0 for _ in range(n+1)]
dp[1], dpsum[1] = 1, 1
for i in range(2,n+1):
for el, er in zip(l, r):
dp[i] += dpsum[max(i-el, 0)] - dpsum[max(i-er-1, 0)]
dp[i] %= mod
dpsum[i] = (dpsum[i-1] + dp[i])%mod
print(dp[n])
main()
| N, K =map(int,input().split())
K = [tuple(map(int,input().split())) for i in range(K)]
M = 998244353
dp = [0] * N
dp[1] = 1
prefix = [1] * N
for i in range(1, N):
cur = 0
for L, R in K:
a = i - R
b = i - L
if b < 0:
continue
cur += prefix[b] - (prefix[a - 1] if a - 1 >= 0 else 0)
dp[i] = cur % M
prefix[i] = prefix[i - 1] + dp[i]
prefix[i] %= M
print(dp[N - 1]) | 1 | 2,730,548,321,380 | null | 74 | 74 |
from collections import deque
n = int(input())
d = deque()
for i in range(n):
line = input().split()
if len(line) == 2:
command, ele = line
else:
command = line[0]
if command == 'insert':
d.appendleft(ele)
elif command == 'delete':
if ele in d:
d.remove(ele)
elif command == 'deleteFirst':
d.popleft()
elif command == 'deleteLast':
d.pop()
print(' '.join(list(d))) |
while True:
s = str(input())
if s == '0': break
ans = 0
for c in s:
ans += int(c)
print(ans)
| 0 | null | 802,214,013,282 | 20 | 62 |