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
|
|---|---|---|---|---|---|---|
ptn=["23542","14631",
"12651","15621",
"13641","32453"]
def rNO(d):
global ptn
for i,e in enumerate(ptn):
if d in e:
return i
return 0
dice = list(input().split(" "))
n = int(input())
for i in range(n):
q = input().split()
for i,e in enumerate(dice):
if e == q[0] :
q1 = i + 1
if e == q[1]:
q2 = i + 1
qq=str(q1) + str(q2)
ans = rNO(qq)
print(dice[ans])
|
def right(a,b,a1,a2,a3,a4,a5,a6):
b1=a6
b2=a5
b3=a4
b4=a3
b5=a2
b6=a1
if a>b:
tmp_a=a
a=b
b=tmp_a
if [a,b]==[a1,a2]:
right_side=[a3,b3]
elif [a,b]==[a1,a3]:
right_side=[a5,b5]
elif [a,b]==[a1,a4]:
right_side=[a2,b2]
elif [a,b]==[a1, a5]:
right_side=[a4,b4]
elif [a,b]==[a2, a3]:
right_side=[a1,b1]
elif [a, b]==[a2, a4]:
right_side=[a6,b6]
elif [a,b]==[a2,a6]:
right_side=[a3,b3]
elif [a,b]==[a3, a5]:
right_side=[a1,b1]
elif [a,b]==[a3, a6]:
right_side=[a5,b5]
elif [a, b]==[a4, a5]:
right_side=[a6,b6]
elif [a,b]==[a4,a6]:
right_side=[a2,b2]
elif [a,b]==[a5,a6]:
right_side=[a4,b4]
return right_side
initial=list( map(int,input().split()))
num_of_q=int(input())
for i in range(0, num_of_q):
a=list(map(int, input().split()))
flag=0
if a[0]>a[1]:
flag=1
answer=right(*a,*initial)
print(answer[flag])
| 1 | 254,404,286,050 | null | 34 | 34 |
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
N=I()
A=LI()
from collections import defaultdict
dd = defaultdict(int)
for i in range(N):
dd[A[i]]+=1
ans=0
for k,v in dd.items():
ans+=(v*(v-1))//2
for i in range(N):
a=A[i]
v=dd[A[i]]
temp=ans
temp-=(v*(v-1))//2
temp+=((v-1)*(v-2))//2
print(temp)
main()
|
from collections import Counter
N = int(input())
A = list(map(int, input().split()))
cA = Counter(A)
allS = 0
for key in cA:
allS += cA[key] * (cA[key] - 1) / 2
for i in range(N):
if A[i] in cA.keys():
print(int(allS - (cA[A[i]] - 1)))
else:
print(int(allS))
| 1 | 47,766,054,279,328 | null | 192 | 192 |
s_list = input()
t_list = input()
n = len(s_list)
if s_list == t_list[:-1]:
print('Yes')
else:
print('No')
|
import sys
stdin=sys.stdin
ip=lambda: int(sp())
fp=lambda: float(sp())
lp=lambda:list(map(int,stdin.readline().split()))
sp=lambda:stdin.readline().rstrip()
yp='Yes'
np='No'
s=sp()
t=sp()
l=len(s)
if s[0:l]==t[0:l]:
print(yp)
else:
print(np)
| 1 | 21,329,553,001,946 | null | 147 | 147 |
import math
n = int(input())
s = 0
for i in range(1,n+1):
for j in range(1,n+1):
for k in range(1,n+1):
s += math.gcd(math.gcd(i,j),k)
print(s)
|
from math import gcd
K = int(input())
sum = 0
for a in range(1, K+1):
for b in range(1, K+1):
p = gcd(a, b)
for c in range(1, K+1):
sum += gcd(p, c)
print(sum)
| 1 | 35,444,964,145,328 | null | 174 | 174 |
n, m, l = map(int, input().split())
a = [list(map(int, input().split())) for _ in range(n)]
b = [list(map(int, input().split())) for _ in range(m)]
for i in range(n):
for j in range(l):
print(sum(a[i][k] * b[k][j] for k in range(m)), end='')
if j != l - 1:
print(' ', end='')
print('')
|
n,m,l = map(int,input().split())
a = [list(map(int,input().split(" "))) for i in range(n)]
b = [list(map(int,input().split(" "))) for j in range(m)]
for i in range(n):
for j in range(l):
c = 0
for k in range(m):
c += a[i][k]*b[k][j]
print(c,end="")
if j != l-1:
print("",end=" ")
print()
| 1 | 1,453,390,168,858 | null | 60 | 60 |
input_data = [int(i) for i in input().split()]
if input_data[0] > input_data[1]:
print("a > b")
elif input_data[0] < input_data[1]:
print("a < b")
else :
print("a == b")
|
params = input().rstrip().split(' ')
square = int(params[0]) * int(params[1])
length = (int(params[0]) + int(params[1])) * 2
print(square, length)
| 0 | null | 332,464,410,460 | 38 | 36 |
def ABC_swap():
# 入力
X, Y, Z = map(int, input().split())
A = X
B = Y
C = Z
# 入れ替え処理
A, B = B, A
A, C = C, A
# 表示
print(A, B, C)
ABC_swap()
|
def main():
N = int(input())
S = str(input())
ans = ''
alphabet = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z']
for i in range(len(S)):
c = alphabet.index(S[i]) + N
if c > 25:
c = c - 26
ans = ans + alphabet[c]
print(ans)
main()
| 0 | null | 86,609,093,024,230 | 178 | 271 |
n,m,k=map(int,input().split())
mod=998244353
MAX_N=n+5
fac = [1,1] + [0]*MAX_N
finv = [1,1] + [0]*MAX_N
inv = [0,1] + [0]*MAX_N
for i in range(2,MAX_N):
fac[i] = fac[i-1] * i % mod
inv[i] = mod - inv[mod % i] * (mod // i) % mod
finv[i] = finv[i-1] * inv[i] % mod
def nCk(n,k):
if n<k:
return 0
if n<0 or k<0:
return 0
return fac[n] * (finv[k] * finv[n-k] % mod) % mod
ans=0
for i in range(k+1):
ans+=nCk(n-1,i)*m*pow(m-1,n-i-1,mod)
ans%=mod
print(ans)
|
n,m,k=map(int, input().split())
mod=998244353
ans=0
c=1
for i in range(k+1):
ans+=c*m*pow(m-1, n-1-i, mod)
ans%=mod
c*=(n-i-1)*pow(i+1, mod-2, mod)
c%=mod
print(ans%mod)
| 1 | 23,078,733,015,570 | null | 151 | 151 |
#from statistics import median
#import collections
#aa = collections.Counter(a) # list to list || .most_common(2)で最大の2個とりだせるお a[0][0]
from fractions import gcd
from itertools import combinations,permutations,accumulate # (string,3) 3回
#from collections import deque
from collections import deque,defaultdict,Counter
import decimal
import re
#import bisect
#
# d = m - k[i] - k[j]
# if kk[bisect.bisect_right(kk,d) - 1] == d:
#
#
#
# pythonで無理なときは、pypyでやると正解するかも！！
#
#
# my_round_int = lambda x:np.round((x*2 + 1)//2)
# 四捨五入
import sys
sys.setrecursionlimit(10000000)
mod = 10**9 + 7
#mod = 9982443453
def readInts():
return list(map(int,input().split()))
def I():
return int(input())
n,k = readInts()
H = sorted(readInts(),reverse=True)
if n <= k:
print(0)
else:
print(sum(H[k:]))
|
N, K = map(int, input().split())
p = list(map(int, input().split()))
cost = 0
for i in range(K):
cost += min(p)
p.remove(min(p))
print(cost)
| 0 | null | 45,367,450,330,950 | 227 | 120 |
n = int(input())
s = input()
def some(s):
a, b = s[:n//2], s[n//2:]
if n % 2 or a != b: return "No"
return "Yes"
print(some(s))
|
rate = int(input())
print(10 - rate//200)
| 0 | null | 76,630,156,323,682 | 279 | 100 |
H, W = map(int,input().split())
if H == 1 or W == 1:
print(1)
else:
ans = H*W
if ans % 2:
print(ans//2+1)
else:
print(ans//2)
|
N = int(input())
S = input()
if N<4:
print(0)
else:
a = [0] * N
R, G, B = 0, 0, 0
for i in range(N):
if S[i] == "R":
a[i] = 1
R += 1
if S[i] == "G":
a[i] = 2
G += 1
if S[i] == "B":
a[i] = 4
B += 1
rgb = R * G * B
cnt = 0
for i in range(N-2):
for d in range(1, (N-i-1) // 2+1):
if a[i] + a[i+d] + a[i+2*d] == 7:
cnt += 1
print(rgb -cnt)
| 0 | null | 43,326,382,529,422 | 196 | 175 |
def main():
H, W, M = map(int, input().split())
hw = [tuple(list(map(int, input().split()))) for _ in [0]*M]
hw_set = set(hw)
h_count = [0 for i in range(H+1)]
w_count = [0 for i in range(W+1)]
for h, w in hw:
h_count[h] += 1
w_count[w] += 1
h_m = max(h_count)
w_m = max(w_count)
h_list = []
w_list = []
for i in range(H+1):
if h_count[i] == h_m:
h_list.append(i)
for i in range(W+1):
if w_count[i] == w_m:
w_list.append(i)
#print(h_list, w_list)
for i in h_list:
for j in w_list:
if (i, j) not in hw_set:
print(h_m+w_m)
return
print(h_m+w_m-1)
main()
|
a,b,c = map(int,input().split())
print("Yes") if (a == b or b == c or c == a) and not(a == b and b == c and c == a) else print("No")
| 0 | null | 36,544,663,877,848 | 89 | 216 |
def main():
L, R, d = map(int, input().split())
ans = 0
for i in range(L, R + 1):
if i % d == 0:
ans += 1
print(ans)
if __name__ == "__main__":
main()
|
def main():
n = int(input())
operation = [input().split() for _ in range(n)]
dictionary = {}
for command, char in operation:
if command == "insert":
dictionary[char] = True
elif command == "find":
try:
if dictionary[char]:
print("yes")
except KeyError:
print("no")
return
if __name__ == "__main__":
main()
| 0 | null | 3,770,278,556,580 | 104 | 23 |
#!/usr/bin/env python3
import sys
import collections as cl
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def main():
n, k = MI()
amari = n % k
print(min(amari, k - amari))
main()
|
n,k=map(int,input().split())
a=n//k
print(min(abs(n-a*k),abs(n-(a+1)*k)))
| 1 | 39,313,893,077,472 | null | 180 | 180 |
count = 0
m = 0
G = []
def insertionSort(A, n, g):
global count
for i in range(g,n):
v = A[i]
j = i - g
while j >= 0 and A[j] > v:
A[j+g] = A[j]
j = j - g
count += 1
A[j+g] = v
def shellSort(A, n):
global count
global m
global G
count = 0
g = 1
while g <= n:
G.append(g)
g = 3*g + 1
G.reverse()
m = len(G)
for g in G:
insertionSort(A, n, g)
A = []
n = int(input())
for _ in range(n):
A.append(int(input()))
shellSort(A,n)
print(m)
print(" ".join(map(str, G)))
print(count)
for a in A:
print(a)
|
def main():
h,w,k=map(int,input().split())
grid=[input() for _ in [0]*h]
ans=[[0]*w for _ in [0]*h]
berry=0
for i in range(h):
if "#" in grid[i]:
cnt=0
berry+=1
for j in range(w):
if grid[i][j]=="#":
cnt+=1
if cnt>1:
berry+=1
ans[i][j]=berry
for i in range(1,h):
if ans[i][0]==0:
for j in range(w):
ans[i][j]=ans[i-1][j]
for i in range(h-2,-1,-1):
if ans[i][0]==0:
for j in range(w):
ans[i][j]=ans[i+1][j]
for i in ans:
print(*i)
main()
| 0 | null | 72,218,275,361,892 | 17 | 277 |
l = range(1, 10)
for i in ["%dx%d=%d" % (x, y, x*y) for x in l for y in l]:
print i
|
for x in range(1, 10):
for y in range(1, 10):
print('%dx%d=%d' % (x,y,x*y))
| 1 | 1,167,012 | null | 1 | 1 |
N = int(input())
d = {}
for i in [None]*N:
a, b = input().split()
if a == "insert":
d[b] = 1
else:
print("yes" if b in d else "no")
|
X, N =map(int, input().split())
p_list=list(map(int, input().split()))
#i=N
#1st Xがp_listにあるか
#あれば+=!
#なければ答え
#|X-i|=1がp_listにあるか
#あれば+=!
#なければ答え
i=N
j=0
while True:
if X-j not in p_list:
print(X-j)
exit()
elif X+j not in p_list:
print(X+j)
exit()
else:
j+=1
| 0 | null | 7,090,302,859,210 | 23 | 128 |
import math
n = int(input())
a = list(map(int,input().split()))
s = sorted(a,reverse=True)
max = s[0]
for i in range(3,n+1):
max += s[math.ceil(i/2)-1]
print(max)
|
N = int(input())
A = list(map(int, input().split()))
A.sort(reverse=True)
max_num, *p = A
node_num = N-1
q = [(2*i <= node_num) + (2*i+1 <= node_num) for i in range(1, node_num+1)]
# print(q)
# print(max_1, max_2, sum(p_i*q_i for p_i, q_i in zip(p, q)))
r = max_num + sum(p_i*q_i for p_i, q_i in zip(p, q))
print(r)
| 1 | 9,219,042,909,930 | null | 111 | 111 |
import math
#import numpy as np
import queue
from collections import deque,defaultdict
import heapq as hpq
from sys import stdin,setrecursionlimit
#from scipy.sparse.csgraph import dijkstra
#from scipy.sparse import csr_matrix
ipt = stdin.readline
setrecursionlimit(10**7)
def main():
n,t = map(int,ipt().split())
dp = [[0,0] for i in range(t)]
for _ in range(n):
a,b = map(int,ipt().split())
for i in range(t-1,a-1,-1):
di = dp[i][1]
dpi = dp[i-a][1]+b
if di < dpi:
dp[i][1] = dpi
for i in dp:
if i[1] < i[0]+b:
i[1] = i[0]+b
for i in range(t-1,a-1,-1):
di = dp[i][0]
dpi = dp[i-a][0]+b
if di < dpi:
dp[i][0] = dpi
print(dp[t-1][1])
return
if __name__ == '__main__':
main()
|
n=int(input())
ans=0
if n%2==0:
for i in range(1,26):
ans+=(n//(2*5**i))
print(ans)
| 0 | null | 134,021,267,580,860 | 282 | 258 |
n, k = map(int, input().split())
mod = 10**9 + 7
cnt = [0]*(k + 1)
ans = 0
for i in range(k, 0, -1):
cnt[i] = (pow(k//i, n, mod) - sum(cnt[2*i:k+1:i])) % mod
ans = (ans + i*cnt[i]) % mod
print(ans)
|
N,K = map(int,input().split())
mod = 10**9+7
ans = [0]*(K+1)
result = 0
for i in range(K,0,-1):
c = K//i
ans[i] += pow(c,N,mod)
for j in range(i,K+1,i):
if i != j:
ans[i] -= ans[j]
result += i*ans[i] % mod
print(result%mod)
| 1 | 36,586,772,310,396 | null | 176 | 176 |
k,s=open(0);k=int(k);print(s[:k]+'...'*(k<~-len(s)))
|
k = int(input())
s = input()
sen = ''
if len(s) <= k:
print(s)
else:
for i in range(k):
sen = sen + s[i]
print(sen+'...')
| 1 | 19,599,349,150,982 | null | 143 | 143 |
input_line = input().rstrip().split(' ')
l = int(input_line[0])
r = int(input_line[1])
d = int(input_line[2])
output = 0
for i in range(l,r+1):
if i % d == 0:
output = output + 1
print(output)
|
import sys
INF = 1 << 60
MOD = 10**9 + 7 # 998244353
sys.setrecursionlimit(2147483647)
input = lambda:sys.stdin.readline().rstrip()
def resolve():
l, r, d = map(int, input().split())
print(r // d - (l - 1) // d)
resolve()
| 1 | 7,578,968,980,252 | null | 104 | 104 |
def insertionSort(A,n,g):
cnt = 0
for i in range(g,n):
v = A[i]
j = i - g
while j >= 0 and A[j] > v:
A[j+g] = A[j]
j = j - g
cnt += 1
A[j+g] = v
return cnt
def shellsort(A,n):
cnt = 0
h = 1
G = []
while h <= n:
G.append(h)
h = 3*h + 1
G.reverse()
m = len(G)
print(m)
print(" ".join(map(str,G)))
for i in range(m):
cnt += insertionSort(A,n,G[i])
print(cnt)
for i in A:
print(i)
n = int(input())
A = []
for _ in range(n):
A.append(int(input()))
shellsort(A,n)
|
#176-B
N = input()
sum = 0
for i in range(1,len(N)+1):
sum += int(N[-i])
if int(sum) % 9 == 0:
print('Yes')
else:
print('No')
| 0 | null | 2,202,634,079,602 | 17 | 87 |
n,m = map(int, input().split())
AC = [False]*n
WA = [0]*n
for i in range(m):
p,s = input().split()
p = int(p)-1
if AC[p] == False:
if s == 'WA':
WA[p] += 1
else:
AC[p] = True
wa = 0
for i in range(n):
if AC[i]:
wa += WA[i]
print(AC.count(True),wa)
|
X, K, D = map(int, input().split())
X = abs(X)
div, mod = divmod(X, D)
if X > D * K:
ans = X - D * K
elif (K - div) % 2 == 0:
ans = mod
else:
ans = D - mod
print(ans)
| 0 | null | 49,316,788,180,870 | 240 | 92 |
N = int(input())
num_odd = int(N/2+0.5)
print(num_odd/N)
|
N = input()[::-1]
l = len(N)
dp = [[0,0] for i in range(l+1)]
for i in range(l):
dp[i+1][0] = min(dp[i][0] + int(N[i]), dp[i][1] + int(N[i]) + 1)
if i == 0:
dp[i+1][1] = 10 - int(N[i])
else:
dp[i+1][1] = min(dp[i][0] + 10 - int(N[i]), dp[i][1] + 9 - int(N[i]))
print(min(dp[-1][0],dp[-1][1]+1))
| 0 | null | 123,941,217,239,240 | 297 | 219 |
x=list(map(int,input().split()))
if x[0]>x[2]:
print(str(x[0]-x[2])+" "+str(x[1]))
elif x[0]+x[1]>x[2]:
print("0"+" "+str(x[0]+x[1]-x[2]))
else:
print("0"+" "+"0")
|
a, b, k = [int(i) for i in input().split()]
a_1 = a
b_1 = b
k_1 = k
if a < k:
a_1 = 0
k_1 = k - a
b_1 = b - k_1
if b_1 < 0:
b_1 = 0
else:
a_1 = a - k
print(a_1, b_1)
| 1 | 104,820,418,140,580 | null | 249 | 249 |
n, k = map(int, input().split())
a = list(map(int, input().split()))
for i in range(0, n - k):
print("Yes" if a[i + k] > a[i] else "No")
|
A = int (input ())
B = int (input ())
N = int (input ())
if A < B:
X = N//B
if N%B == 0:
print (X)
else:
print (X+1)
else:
X = N//A
if N%A == 0:
print (X)
else:
print (X+1)
| 0 | null | 48,209,726,968,172 | 102 | 236 |
import numpy as np
mod = 10**9+7
n=int(input())
A=np.array(list(map(int,input().split())))
ans = 0
for i in range(60):
n1 = np.count_nonzero((A>>i)&1)
n0 = n-n1
ans += (2**i)*n1*n0 % mod
ans %= mod
print(ans)
|
def main():
h,a = map(int,input().split())
ans = h // a
if h % a != 0:
ans += 1
print(ans)
main()
| 0 | null | 100,272,028,964,900 | 263 | 225 |
import sys
input = sys.stdin.readline
def main():
S = input().rstrip()
ans = S[:3]
print(ans)
if __name__ == "__main__":
main()
|
def a():
a = "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"
list_a = a.split(sep=",")
k = int(input())
print(list_a[k-1])
if __name__ == '__main__':
a()
| 0 | null | 32,333,061,207,868 | 130 | 195 |
data = [int(i) for i in input().split()]
if data[0] < data[1]:
print('a < b')
elif data[0] > data[1]:
print('a > b')
else:
print('a == b')
|
a,b = list(map(int, input().split()))
if a > b:
sep = '>'
elif a < b:
sep = '<'
else:
sep = '=='
print('a', sep, 'b')
| 1 | 355,023,537,760 | null | 38 | 38 |
s = input()
ans = ''
for i in range(len(s)):
s_i = s[i]
if s_i == '?':
ans += 'D'
continue
ans += s_i
print(ans)
|
t = list(input())
for i in range(len(t)-1, -1, -1):
if t[i] == '?':
t[i] = 'D'
print(''.join(list(map(str, t))))
| 1 | 18,416,639,317,760 | null | 140 | 140 |
N, M = map(int, input().split())
A = list(map(int, input().split()))
dp = [[1<<60]*(N+1) for _ in range(M+1)]
dp[0][0] = 0
for i in range(M):
for j in range(N+1):
if A[i] <= j:
dp[i+1][j] = min(dp[i][j], dp[i+1][j-A[i]] + 1)
else:
dp[i + 1][j] = dp[i][j]
print(dp[M][N])
|
# -*- coding: utf-8 -*-
def inpl(): return list(map(int, input().split()))
n, m = inpl()
C = sorted(inpl())
DP = list(range(n+1))
for c in C[1:]:
for i in range(n-c+1):
if DP[i] + 1 < DP[i+c]:
DP[i+c] = DP[i] + 1
print(DP[-1])
| 1 | 141,901,298,332 | null | 28 | 28 |
N = input()
inpa = input().split(" ")
count =0
for x in range(0,int(N),2):
if int(inpa[x])%2==1:
count = count + 1
print(count)
|
a,b = map(int,input().split())
ans = b if a >= 10 else b + 100 * (10-a)
print(ans)
| 0 | null | 35,705,458,897,922 | 105 | 211 |
a = []
for i in range(3):
t = [int(x) for x in input().split()]
a.append(t)
n = int(input())
b = [int(input()) for i in range(n)]
m = [[0 for j in range(3)] for i in range(3)]
for i in range(3):
for j in range(3):
for k in b:
if (a[i][j] == k):
m[i][j] = 1
for i in range(3):
if (m[i][0] and m[i][1] and m[i][2]):
print("Yes")
exit()
for i in range(3):
if (m[0][i] and m[1][i] and m[2][i]):
print("Yes")
exit()
if ((m[0][0] and m[1][1] and m[2][2]) or (m[0][2] and m[1][1] and m[2][0])):
print("Yes")
exit()
print("No")
|
import numpy as np
a = [list(map(int,input().split())) for i in range(3)]
n = int(input())
for i in range(n):
b = int(input())
for j in range(3):
if b in a[j]:
idx = a[j].index(b)
a[j][idx] = 0
np_a = np.array(a)
np_t = np_a.T
d = 0
u = 0
for i in range(3):
r = np_a[i]
c = np_t[i]
d += r[i]
u += r[2-i]
if r.sum() and c.sum():
continue
print("Yes")
exit()
if d and u:
print("No")
else:
print("Yes")
| 1 | 59,873,682,304,748 | null | 207 | 207 |
import sys
from collections import deque,defaultdict
I=sys.stdin.readline
def ii():
return int(I().strip())
def li():
return list(map(int,I().strip().split()))
def mi():
return map(int,I().strip().split())
def main():
n=ii()
arr=li()
p=1000
for i in range(n-1):
if arr[i]==arr[i+1]:
pass
elif arr[i]<arr[i+1]:
buy=p//arr[i]
p+=(arr[i+1]-arr[i])*buy
print(p)
if __name__ == '__main__':
main()
|
n=int(input())
A=list(map(int,input().split()))
g=1000
for s1,s2 in zip(A[:-1],A[1:]):
if s1<s2:
stockNum=g//s1
g+=stockNum*(s2-s1)
print(g)
| 1 | 7,398,151,185,572 | null | 103 | 103 |
s = input()
S = list(s)
if len(set(S)) == 1:
print('No')
else:
print('Yes')
|
s = list(input())
if len(set(s)) == 2:
print("Yes")
else:
print("No")
| 1 | 54,677,825,323,250 | null | 201 | 201 |
a = input()[::-1]
add = 0
ans = [1] + [0] * 2018
ans_int = 0
d = 1
for i in range(len(a)):
add = (add + int(a[i]) * d) % 2019
d = (10 * d) %2019
ans[add] += 1
for i in range(len(ans)):
a =((ans[i] - 1) * ans[i]) /2
ans_int += a
print(int(ans_int))
|
t = input()
t = t.replace('?', 'D')
print(t)
| 0 | null | 24,668,376,319,750 | 166 | 140 |
print(0--int(input())//2)
|
# -*- coding: utf-8 -*-
# モジュールのインポート
import math
def get_input() -> int:
"""
標準入力の取得
Returns:\n
int: 標準入力
"""
N = int(input())
return N
def main(N: int) -> None:
"""
求解処理
Args:
N (int): ページ数
"""
result = math.ceil(N/2)
# 結果出力
print(result)
if __name__ == "__main__":
N = get_input()
main(N)
| 1 | 58,787,065,388,546 | null | 206 | 206 |
k=int(input())
line="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"
nums=line.split(",")
#print(nums)
print(nums[k-1])
|
import sys
sys.setrecursionlimit(1000000)
input = sys.stdin.readline
from bisect import *
from collections import *
from heapq import *
INF = 500000
mod = 10**9+7
l = [1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51]
K = int(input())-1
print(l[K])
# a, b, c = input(), input(), input()
# la, lb, lc = len(a), len(b), len(c)
# for i in range(1, min(la, lb)):
# S = ''
# for j in range(i):
# if a[la-i+j] == b[j]:
# S += b[j]
# continue
# elif a[la-i+j] == '?':
# S += b[j]
# elif b[j] == '?':
# S += c[j]
| 1 | 49,794,246,138,400 | null | 195 | 195 |
a,b = map(int,input().split())
print("{} {} {:.8f}".format(a//b,a%b,a/b))
|
import sys
if __name__ == "__main__":
a,b = map(int, raw_input().split())
print "%d %d %f" %(a/b, a%b, a*1.0/b)
| 1 | 614,137,700,026 | null | 45 | 45 |
n = int(input())
l = []
for i in range(1,n+1) :
if i%3 != 0 and i%5 != 0 :
l.append(i)
print(sum(l))
|
def resolve():
n = int(input())
ans = 0
for i in range(1,n+1):
if i%3!=0 and i%5!=0:
ans += i
print(ans)
resolve()
| 1 | 34,952,023,011,608 | null | 173 | 173 |
X, Y, Z = [int(x) for x in input().split()]
print('{} {} {}'.format(Z, X, Y))
|
import math
import sys
H,A = map(int, input().split())
print(math.ceil(H/A))
| 0 | null | 57,573,223,193,212 | 178 | 225 |
def main():
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
from collections import Counter, deque
#from collections import defaultdict
from itertools import combinations, permutations, accumulate, groupby, product
from bisect import bisect_left,bisect_right
from heapq import heapify, heappop, heappush
import math
#inf = 10**17
mod = 10**9 + 7
def ncr(n, r, mod):
r = min(r, n-r)
numer = denom = 1
for i in range(1, r+1):
numer = numer * (n+1-i) % mod
denom = denom * i % mod
return numer * pow(denom, mod-2, mod) % mod
n = input().rstrip()
k = int(input())
ln = len(n)
if ln < k:
print(0)
exit()
res = 0
if k == 1:
if ln >= 2:
res += ncr(ln-1, 1, mod) * 9
res += int(n[0])
if k == 2:
if ln >= 3:
res += ncr(ln-1, 2, mod) * (9**k)
res += ncr(ln-1, 1, mod) * 9 * (int(n[0])-1)
for i in range(1, ln):
if n[i] != '0':
if i == ln-1:
res += int(n[i])
else:
res += ncr(ln-i-1, 1, mod) * 9
res += int(n[i])
break
if k == 3:
if ln >= 4:
res += ncr(ln-1, 3, mod) * (9**k)
res += ncr(ln-1, 2, mod) * 81 * (int(n[0])-1)
for i in range(1, ln-1):
if n[i] != '0':
if ln-i-1 >= 2:
res += ncr(ln-i-1, 2, mod) * 81
res += ncr(ln-i-1, 1, mod) * 9 * (int(n[i])-1)
for j in range(i+1, ln):
if n[j] != '0':
if j != ln-1:
res += ncr(ln-j-1, 1, mod) * 9
res += int(n[j])
break
break
print(res)
if __name__ == '__main__':
main()
|
def nCkpow(n,k):
if n<k:
return 0
y=1
for i in range(k):
y*=n-i
y//=i+1
y*=9
return y
def f(s,m,k):
#print(m,k)
if len(s)-m<k:
return 0
if k==0:
return 1
if s[m]=='0':
return f(s,m+1,k)
l=len(s)-m
y=nCkpow(l-1,k)
y+=(int(s[m])-1)*nCkpow(l-1,k-1)
return y+f(s,m+1,k-1)
N=input()
K=int(input())
print(f(N,0,K))
| 1 | 75,514,437,696,608 | null | 224 | 224 |
N = int(input())
def dfs(ans, MAX):
if len(ans) == N:
print(ans)
return
for i in range(MAX-95):
dfs(ans + chr(97+i), max(MAX, 97+i))
dfs('a', 97)
|
def main():
n = int(input())
A = list(map(int,input().split()))
A.sort()
A_max = A[-1]
g = []
table = [True]*(A_max+1)
for i,a in enumerate(A):
if table[a]:
temp = a
while A_max >= temp:
table[temp] = False
temp+=a
if i==n-1 or a!=A[i+1]:
g.append(a)
print(len(g))
main()
| 0 | null | 33,283,959,165,632 | 198 | 129 |
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)
|
# でつoO(YOU PLAY WITH THE CARDS YOU'RE DEALT..)
import sys
def main(N, A):
dp = [0] * (N + 1)
dp[0] = 1000
for i in range(1, N + 1):
dp[i] = dp[i - 1]
for j in range(1, i):
dp[i] = max(dp[i], (dp[j] // A[j - 1]) * A[i - 1] + dp[j] % A[j - 1])
print(dp[N])
if __name__ == '__main__':
input = sys.stdin.readline
N = int(input())
*A, = map(int, input().split())
main(N, A)
| 0 | null | 8,500,792,054,052 | 113 | 103 |
S = input()
count = 0
for i in range(len(S)//2):
if S[i] != S[len(S)-i-1]:
count = count+1
print(count)
|
s = list(input())
s1 = s[:len(s)//2]
s2 = s[-(-len(s)//2):][::-1]
cnt = 0
while True:
if s1 == s2:
break
for i in range(len(s1)):
if s1[i] != s2[i]:
s1[i] = s2[i]
cnt += 1
print(cnt)
| 1 | 120,155,810,660,798 | null | 261 | 261 |
def main():
N = int(input())
total = 0
for i in range(N):
i = i + 1
if i % 3 == 0 and i % 5 == 0:
continue
elif i % 3 == 0:
continue
elif i % 5 == 0:
continue
total = total + i
print(total)
main()
|
a,b,c,d=map(int,input().split())
maxxy=max(a*c,a*d,b*c,b*d)
print(maxxy)
| 0 | null | 19,052,338,538,588 | 173 | 77 |
#abc175b
n=int(input())
l=list(map(int,input().split()))
l.sort()
cnt=0
for i in range(n):
for j in range(i):
for k in range(j):
if l[k]!=l[j] and l[i]!=l[j] and l[k]+l[j]>l[i]:
cnt+=1
print(cnt)
|
N = int(input())
L = [int(x) for x in input().split()]
L.sort()
cnt = 0
for i in range(len(L) - 2):
for j in range(i+1, len(L)-1):
for k in range(j+1, len(L)):
a = L[i]
b = L[j]
c = L[k]
p = a + b > c
s = a != b
t = b != c
if p and s and t:
cnt += 1
print(cnt)
| 1 | 5,015,982,816,010 | null | 91 | 91 |
N,K = list(map(int, input().split()))
A = list(map(int, input().split()))
from itertools import accumulate
if K>=50:
print(*[N]*N)
exit()
for _ in range(K):
ans=[0]*(N+1)
for i,a in enumerate(A):
ans[max(0,i-a)]+=1
ans[min(i+a+1,N)]-=1
A = list(accumulate(ans))[:-1]
if all(i == N for i in A):
break
print(*A)
|
import sys
n=int(input())
a=input()
a=[int(s)for s in a.split()]
M=1
Q=1
m=sum(a)
if a[0]>=1:
if a[0]==1 and n==0:
print(1)
sys.exit()
else:
print(-1)
sys.exit()
for i in range(n):
M=2*M-a[i+1]
if M<0:
print(-1)
sys.exit()
M1=M+a[i+1]
m=m-a[i]
Q=Q+min(M1,m)
print(Q)
| 0 | null | 17,184,801,587,850 | 132 | 141 |
import sys
read = sys.stdin.read
readline = sys.stdin.buffer.readline
sys.setrecursionlimit(10 ** 8)
INF = float('inf')
MOD = 10 ** 9 + 7
def main():
H, W, M = map(int, readline().split())
row = [0] * H
column = [0] * W
grid = set()
for _ in range(M):
h, w = map(int, readline().split())
row[h-1] += 1
column[w-1] += 1
grid.add((h-1,w-1))
max_row = max(row)
max_column = max(column)
idx_row = [i for i,x in enumerate(row) if x == max_row]
idx_column = [i for i,x in enumerate(column) if x == max_column]
ans = max_row+max_column
flag = False
for h in idx_row:
for w in idx_column:
if not (h,w) in grid:
flag = True
break
if flag:
print(ans)
else:
print(ans-1)
if __name__ == '__main__':
main()
|
S,T,A,B,U = open(0).read().split()
if S==U:
print(int(A)-1,B)
else:
print(A,int(B)-1)
| 0 | null | 38,459,989,756,288 | 89 | 220 |
input = raw_input()
print int(input) ** 3
|
a=int(input())
resultado=str(a*a*a)
print resultado
| 1 | 279,273,899,872 | null | 35 | 35 |
from _collections import deque
def cacl(seq):
score = 0
for a, b, c, d in req:
if seq[b-1] - seq[a-1] == c:
score += d
return score
n, m, q = list(map(int, input().split()))
req = [list(map(int, input().split())) for _ in range(q)]
ans = 0
que = deque()
for i in range(1, m+1):
que.append([i])
while que:
seq = que.popleft()
if len(seq) == n:
score = cacl(seq)
ans = max(ans, score)
else:
for i in range(seq[-1], m + 1):
seq_next = seq + [i]
que.append(seq_next)
print(ans)
|
import math
import numpy as np
import sys
import os
from operator import mul
from operator import itemgetter
sys.setrecursionlimit(10**7)
def _S(): return sys.stdin.readline().rstrip()
def I(): return int(_S())
def LS(): return list(_S().split())
def LI(): return list(map(int,LS()))
if os.getenv("LOCAL"):
inputFile = basename_without_ext = os.path.splitext(os.path.basename(__file__))[0]+'.txt'
sys.stdin = open(inputFile, "r")
INF = float("inf")
IINF = 10 ** 18
MOD = 10 ** 9 + 7
# MOD = 998244353
N,M = LI()
H = LI()
AB = [LI() for _ in range(M)]
p = []
d = {}
for i in range(N):
# p.append((i,H[i]))
d[i]=H[i]
# p.sort(key=itemgetter(1),reverse=True)
# print(p)
# print(d)
# g = np.zeros(shape=(N,N),dtype='int')
g = [set()] * N
a = [True] * N
for i in range(M):
f = AB[i][0]-1
t = AB[i][1]-1
if d[t]>d[f]:
a[f]=False
elif d[f]>d[t]:
a[t]=False
else:
a[f]=False
a[t]=False
# print(a)
print(sum(a))
# print(g[f])
# g[f] = np.append(g[f],t)
# g[t] = np.append(g[t],f)
# g[f][t]=1
# g[t][f]=1
# print(g)
# list.sort(key=itemgetter(0))
# for i in range(N):
# a = np.where(g[0]==1)
# print(a)
| 0 | null | 26,409,724,471,042 | 160 | 155 |
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))
|
N=int(input())
L= list(map(int,input().split()))
L_sorted=sorted(L,reverse=False)#昇順
count=0
for i in range(N):
for j in range(i+1,N):
a=L_sorted[i]
b=L_sorted[j]
n=a+b
fin=N
sta=0
while sta+1<fin:
m=((fin-sta)//2)+sta
if L_sorted[m]<n:
sta=m
else:
fin=m
count+=sta-j
print(count)
| 0 | null | 142,387,364,740,152 | 256 | 294 |
from collections import deque
n,q = tuple([int(i) for i in input().split()])
lines = [input().split() for i in range(n)]
pro = deque([[i[0], int(i[1])] for i in lines])
time = 0
while True:
left = pro.popleft()
if left[1] - q > 0:
time += q
pro.append([left[0], left[1] - q])
else:
time += left[1]
print(' '.join([left[0], str(time)]))
if len(pro) == 0:
break;
|
class process:
def __init__(self, name, time):
self.name = name
self.time = time
def queue(q, ps):
time = 0
while len(ps) != 0:
p = ps.pop(0)
if p.time > q:
p.time -= q
time += q
ps.append(p)
else:
time += p.time
print p.name + " " + str(time)
if __name__ == "__main__":
L = map(int, raw_input().split())
N = L[0]
q = L[1]
processes = []
for i in range(N):
L = raw_input().split()
processes.append(process(L[0], int(L[1])))
queue(q, processes)
| 1 | 40,292,295,900 | null | 19 | 19 |
# https://atcoder.jp/contests/abc164/tasks/abc164_d
import sys
input = sys.stdin.readline
S = input().rstrip()
res = 0
T = [0]
x = 0
p = 1
L = len(S)
MOD = 2019
for s in reversed(S):
""" 累積和 """
x = (int(s)*p + x)%MOD
p = p*10%MOD
T.append(x)
reminder = [0]*2019
for i in range(L+1):
reminder[T[i]%MOD] += 1
for c in reminder:
res += c*(c-1)//2
print(res)
|
from sys import exit
A, B, C, K = [int(x) for x in input().split()]
if A + B >= K:
print(min(A, K))
exit()
print(A - (K - (A + B)))
| 0 | null | 26,331,779,942,130 | 166 | 148 |
from collections import deque
n = int(input())
d = [-1]*n
d[0] = 0
M = []
for i in range(n):
adj = list(map(int,input().split()))
if adj[1] == 0:
M += [[]]
else:
M += [adj[2:]]
Q = deque([0])
while Q != deque([]):
u = Q.popleft()
for i in range(len(M[u])):
v = M[u][i]-1
if d[v] == -1:
d[v] = d[u] + 1
Q.append(v)
for i in range(n):
print(i+1,d[i])
|
import sys
def resolve(in_):
N, K = map(int, next(in_).split())
A = map(int, next(in_).split())
number_plus1 = list(i + 1 for i in A)
v = [0] * N
v[0] = sum(number_plus1[:K])
for i, (before, after) in enumerate(zip(number_plus1, number_plus1[K:]), 1):
v[i] = v[i - 1] - before + after
expected = max(v) / 2
return expected
def main():
answer = resolve(sys.stdin.buffer)
print(f'{answer:.12f}')
if __name__ == '__main__':
main()
| 0 | null | 37,570,510,399,670 | 9 | 223 |
s = input()
t = input()
len_s = len(s)
len_t = len(t)
ans = len_t
for i in range(len_s - len_t + 1):
tmp_cnt = 0
tmp_s = s[i:i + len_t]
for c1, c2 in zip(tmp_s, t):
if c1 != c2:
tmp_cnt += 1
ans = min(ans, tmp_cnt)
print(ans)
|
S = input()
T = input()
ans = 99999999
for i in range(len(S)-len(T)+1):
word = S[i:i+len(T)]
cnt = 0
for j in range(len(word)):
if word[j]!=T[j]:
cnt+=1
ans = min(ans,cnt)
print(ans)
| 1 | 3,681,290,945,190 | null | 82 | 82 |
global cnt
cnt = 0
def merge(A, left, mid, right):
L = A[left:mid] + [float("inf")]
R = A[mid:right] + [float("inf")]
i = 0
j = 0
global cnt
for k in range(left, right):
if L[i] <= R[j]:
A[k] = L[i]
i += 1
else:
A[k] = R[j]
j += 1
cnt += 1
def mergesort(A, left, right):
rsl = []
if left+1 < right:
mid = int((left+right)/2)
mergesort(A, left, mid)
mergesort(A, mid, right)
rsl = merge(A, left, mid, right)
return rsl
n = int(input())
S = list(map(int, input().split()))
mergesort(S, 0, n)
print(*S)
print(cnt)
|
n=int(input())
ans=0
tmp=0
p=1
if n%2==0:
k=n//2
while True:
tmp =k//pow(5,p)
ans+=tmp
p+=1
if tmp==0:
break
print(ans)
| 0 | null | 57,772,020,775,520 | 26 | 258 |
#!/usr/bin/env python3
(R, C, K), *D = [[*map(int,o.split())] for o in open(0)]
V = [[0] * C for _ in [None] * R]
for r, c, v in D:
V[r - 1][c - 1] = v
dp = [[[-1] * C for _ in [None] * R] for _ in [None] * 4]
dp[0][0][0] = 0
for r in range(R):
for c in range(C):
v = V[r][c]
for i in range(4):
if dp[i][r][c] > -1:
if r < R - 1:
dp[0][r + 1][c] = max(dp[0][r + 1][c], dp[i][r][c])
if c < C - 1:
dp[i][r][c + 1] = max(dp[i][r][c + 1], dp[i][r][c])
if i < 3 and v:
if r < R - 1:
dp[0][r + 1][c] = max(dp[0][r + 1][c], dp[i][r][c] + v)
if c < C - 1:
dp[i + 1][r][c + 1] = max(dp[i + 1][r][c + 1], dp[i][r][c] + v)
v = V[R - 1][C - 1]
ans = dp[3][R - 1][C - 1]
for i in range(3):
ans = max(ans, dp[i][R - 1][C - 1] + v)
print(ans)
|
import sys
input = sys.stdin.readline
def main():
R, C,K = map(int, input().split())
dp = [[[0]*(C+1) for k in range(R+1)] for _ in range(4)]
# dp[r][c][j] :=r index c columns already j cnt
dp[0][0][0] = 0
D = [[0 for i in range(C+1)] for j in range(R+1)]
import random
for i in range(K):
r, c, v = map(int,input().split())
D[r][c] = v
for i in range(R+1):
for j in range(C+1):
if D[i][j] > 0:
v = D[i][j]
M = max(dp[k][i-1][j] for k in range(4))
dp[0][i][j] = max(dp[0][i][j-1], M)
dp[1][i][j] = max(dp[0][i][j-1]+v, dp[1][i][j-1], M+v)
dp[2][i][j] = max(dp[1][i][j-1]+v, dp[2][i][j-1])
dp[3][i][j] = max(dp[2][i][j-1]+v, dp[3][i][j-1])
else:
M = max(dp[k][i-1][j] for k in range(4))
dp[0][i][j] = max(dp[0][i][j-1], M)
dp[1][i][j] = dp[1][i][j-1]
dp[2][i][j] = dp[2][i][j-1]
dp[3][i][j] = dp[3][i][j-1]
ans = max(dp[i][-1][-1] for i in range(4))
print(ans)
main()
| 1 | 5,638,115,846,890 | null | 94 | 94 |
contests = ['ABC', 'ARC']
before_contest = input()
print(contests[0] if before_contest == contests[1] else contests[1])
|
input_str = input()
if input_str == "ABC":
print("ARC")
else:
print("ABC")
| 1 | 24,201,085,337,312 | null | 153 | 153 |
li = []
for i, s in enumerate(input()):
if s == "\\":
li.append([i, 0])
elif s == "/":
if li:
if li[-1][1] == 0:
li[-1][1] = i - li[-1][0]
else:
for j in range(len(li) - 1, -1, -1):
if li[j][1] == 0:
li = li[:j] + [[li[j][0], sum(tuple(zip(*li[j + 1:]))[1]) + i - li[j][0]]]
break
ans = []
for a in li:
if a[1] != 0:
ans.append(a[1])
print(sum(ans))
print(len(ans), *ans)
|
import sys, os, math, bisect, itertools, collections, heapq, queue
# from scipy.sparse.csgraph import csgraph_from_dense, floyd_warshall
from decimal import Decimal
from collections import defaultdict, deque
import copy
sys.setrecursionlimit(10000000)
ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))
fl = lambda: list(map(float, sys.stdin.buffer.readline().split()))
iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]
iss = lambda: sys.stdin.buffer.readline().decode().rstrip()
sl = lambda: list(map(str, sys.stdin.buffer.readline().decode().split()))
isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]
lcm = lambda x, y: (x * y) // math.gcd(x, y)
MOD = 10 ** 9 + 7
MAX = float('inf')
def calc_water(u, l, h):
return ((u + l) * h) // 2
def main():
if os.getenv("LOCAL"):
sys.stdin = open("input.txt", "r")
S = iss()
stack = []
water = []
sum = 0
for i in range(len(S)):
s = S[i]
if s == '\\':
stack.append(i)
elif s == '/' and len(stack) > 0:
j = stack.pop()
sum += i - j
area = i - j
while len(water) > 0 and water[-1][0] > j:
w = water.pop()
area += w[1]
water.append([j, area])
ret = []
for i, w in water:
ret.append(w)
print(sum)
print(len(ret), *ret)
if __name__ == '__main__':
main()
| 1 | 60,498,760,458 | null | 21 | 21 |
N, M, K = map(int, input().split())
mod = 998244353
fact = [1 for i in range(N+1)]
fact_inv = [1 for i in range(N+1)]
for i in range(1, N+1):
fact[i] = fact[i-1] * i %mod
fact_inv[i] = pow(fact[i], mod-2, mod)
ans = 0
for k in range(K+1):
x = M *pow(M-1, N-1-k, mod) *fact[N-1] *fact_inv[k] *fact_inv[N-1-k]
ans += x %mod
ans = ans %mod
print(ans)
|
class Factorial():
def __init__(self, mod=10**9 + 7):
self.mod = mod
self._factorial = [1]
self._size = 1
self._factorial_inv = [1]
self._size_inv = 1
def __call__(self, n):
return self.fact(n)
def fact(self, n):
''' n! % mod '''
if n >= self.mod:
return 0
self._make(n)
return self._factorial[n]
def _make(self, n):
if n >= self.mod:
n = self.mod
if self._size < n+1:
for i in range(self._size, n+1):
self._factorial.append(self._factorial[i-1]*i % self.mod)
self._size = n+1
def fact_inv(self, n):
''' n!^-1 % mod '''
if n >= self.mod:
raise ValueError('Modinv is not exist! arg={}'.format(n))
self._make(n)
if self._size_inv < n+1:
self._factorial_inv += [-1] * (n+1-self._size_inv)
self._size_inv = n+1
if self._factorial_inv[n] == -1:
self._factorial_inv[n] = self.modinv(self._factorial[n])
return self._factorial_inv[n]
@staticmethod
def xgcd(a, b):
'''
Return (gcd(a, b), x, y) such that a*x + b*y = gcd(a, b)
'''
x0, x1, y0, y1 = 0, 1, 1, 0
while a != 0:
(q, a), b = divmod(b, a), a
y0, y1 = y1, y0 - q * y1
x0, x1 = x1, x0 - q * x1
return b, x0, y0
def modinv(self, n):
g, x, _ = self.xgcd(n, self.mod)
if g != 1:
raise ValueError('Modinv is not exist! arg={}'.format(n))
return x % self.mod
def comb(self, n, r):
''' nCr % mod '''
if r > n:
return 0
t = self(n)*self.fact_inv(n-r) % self.mod
return t*self.fact_inv(r) % self.mod
def comb_with_repetition(self, n, r):
''' nHr % mod '''
t = self(n+r-1)*self.fact_inv(n-1) % self.mod
return t*self.fact_inv(r) % self.mod
def perm(self, n, r):
''' nPr % mod '''
if r > n:
return 0
return self(n)*self.fact_inv(n-r) % self.mod
n, m, k = map(int, input().split())
mod = 998244353
comb = Factorial(mod).comb
s = 0
for i in range(k+1, n):
t = comb(n-1, i)*m % mod
t = t*pow(m-1, n-1-i, mod) % mod
s = (s+t) % mod
ans = (pow(m, n, mod)-s) % mod
print(ans)
| 1 | 23,140,158,036,740 | null | 151 | 151 |
# coding: UTF-8
import sys
import numpy as np
# f = open("input.txt", "r")
# sys.stdin = f
s = str(input())
t = str(input())
ans = 0
for i, j in zip(s,t):
if i != j:
ans += 1
print(ans)
|
n = int(input())
a = list(map(int, input().split(" ")))
for lil_a in a[-1:0:-1]:
print("%d "%lil_a, end="")
print("%d"%a[0])
| 0 | null | 5,739,767,823,962 | 116 | 53 |
N,M,Q=map(int,input().split())
abcd=[]
for i in range(Q):
abcd.append(list(map(int,input().split())))
abcd[i][0]-=1
abcd[i][1]-=1
def calcScore(target):
score=0
for i in range(Q):
if target[abcd[i][1]]-target[abcd[i][0]]==abcd[i][2]:
score+=abcd[i][3]
return score
def makeTarget():
list=[1]*N
list[-1]=0
while True:
list[-1]+=1
for i in range(len(list)):
if list[-i-1]>M:
if len(list)==i+1:return
list[-i-2]+=1
list[-i-1]=0
for i in range(len(list)-1):
if list[i]>list[i+1]:list[i+1]=list[i]
yield list.copy()
ans=0
for i in makeTarget():
ans=max(ans,calcScore(i))
print(ans)
|
def main():
N, A, B = list(map(int, input().split()))
if (A ^ B) & 1:
return min((A - 1) + 1 + (B - A - 1) // 2,
(N - B) + 1 + (N - (A + N - B + 1)) // 2)
return (B - A) // 2
print(main())
| 0 | null | 68,304,697,112,962 | 160 | 253 |
N=input()
L=[int(N[i]) for i in range(len(N))]
P=0
OT=0
for i in range(len(L)-1):
if 0 <= L[i] <= 3:
P += L[i] + OT
OT = 0
elif L[i] == 4:
if OT == 1 and L[i+1]>=5:
P += 5
else:
P += OT+L[i]
OT = 0
elif L[i] == 5:
if OT == 1:
P += 4
else:
if L[i+1] >= 5:
P += 1 + 4
OT = 1
else:
P += 5
else:
if OT == 1:
P += 9-L[i]
OT = 1
else:
P += 10 - L[i]
OT = 1
Pone = 0
if OT==0:
Pone = min(L[-1],11-L[-1])
elif OT==1 and L[-1]<=4:
Pone = 1+L[-1]
else:
Pone = 10-L[-1]
print(P+Pone)
|
s = input()
nums = list(reversed([int(c) for c in s])) + [0]
r = (0, 1) # no borrow, with borrow
for i in range(len(nums)):
# print(r)
next_no_borrow = min(r[0] + nums[i], r[1] + nums[i] + 1)
next_borrow = min(10 - nums[i] + r[0], 9 - nums[i] + r[1])
r = (next_no_borrow, next_borrow)
print(min(r))
| 1 | 70,999,110,248,810 | null | 219 | 219 |
import sys
def insertionSort(A, n, g):
for i in range(g, n):
global cnt
v = A[i]
j = i - g
while j >= 0 and A[j] > v:
A[j+g] = A[j]
j = j - g
cnt += 1
A[j+g] = v
def shellSort(A, n):
global m
global G
for i in range(0, m):
insertionSort(A, n, G[i])
n = int(input())
A = []
for i in range(n):
A.append(int(input()))
if n == 1:
print(1)
print(1)
print(0)
print(A[0])
sys.exit()
t = n - 1
G = []
G.append(t)
while t != 1:
t = t//2
G.append(t)
m = len(G)
cnt = 0
shellSort(A, n)
print(m)
print(' '.join(map(str, G)))
print(cnt)
for i in range(n):
print(A[i])
|
def printing(m, G, cnt, A):
print(m)
for i in range(len(G)):
if i != len(G) - 1:
print(G[i], end=' ')
else:
print(G[i])
print(cnt)
for i in A:
print(i)
def insertionSort(A, n, g, cnt):
for i in range(g, n):
v = A[i]
j = i - g
while j >= 0 and A[j] > v:
A[j+g] = A[j]
j = j - g
cnt += 1
A[j+g] = v
return cnt
def shellSort(A, n, cnt):
m = 0
G = [1]
while True:
formulate = 3 * G[m] + 1
if N > formulate:
G.append(formulate)
else:
break
m += 1
for i in range(len(G) // 2):
G[i], G[-1 - i] = G[-1 - i], G[i]
for i in range(m + 1):
cnt = insertionSort(A, n, G[i], cnt)
printing(m + 1, G, cnt, A)
N = int(input())
inputList = []
for i in range(N):
inputList.append(int(input()))
# inputList = list(map(int, '''5
# 5 1 4 3 2'''.split()))
# N = inputList.pop(0)
cnt = 0
shellSort(inputList, N, cnt)
| 1 | 28,223,482,752 | null | 17 | 17 |
s=input()
if s.count('A') and s.count('B'): print('Yes')
else: print('No')
|
print(eval("'ACL'*"+input()))
| 0 | null | 28,644,490,776,132 | 201 | 69 |
def solve(x):
if len(x) <= 1:
return 0
else:
return (1 if x[0] != x[-1] else 0) + solve(x[1:-1])
s = input()
print(solve(s))
|
from collections import Counter
N=int(input())
Alist=list(map(int,input().split()))
count=Counter(Alist)
flag=True
for value in count.values():
if value>1:
flag=False
print('YES' if flag else 'NO')
| 0 | null | 97,356,511,783,378 | 261 | 222 |
X, Y, A, B, C = map(int, input().split(' '))
apples = []
for p in map(int, input().split(' ')):
apples.append((p, 0))
for q in map(int, input().split(' ')):
apples.append((q, 1))
for r in map(int, input().split(' ')):
apples.append((r, 2))
apples.sort(reverse=True)
pq = []
r = []
x = X
y = Y
for d, t in apples:
if t == 0:
if x > 0:
x -= 1
pq.append(d)
else:
continue
elif t == 1:
if y > 0:
y -= 1
pq.append(d)
else:
continue
else:
r.append(d)
pq_len = len(pq)
for i in range(len(r)):
if i >= pq_len:
break
if r[i] <= pq[-(i + 1)]:
break
pq[-(i + 1)] = r[i]
print(sum(pq))
|
n = int(input())
for i in range(1,n+1):
x = i
if x % 3 == 0:
print('', i, end='')
else:
while True:
if x % 10 == 3:
print('', i, end='')
break
x //= 10
if x == 0:
break
print()
| 0 | null | 22,852,022,256,216 | 188 | 52 |
def resolve():
n = int(input())
ans = [0]*n
a = list(map(int,input().split()))
for i in a:
ans[i-1] += 1
for i in ans:
print(i)
resolve()
|
N = int(input())
ls = list(map(int,input().split()))
cnt = [0] * (N+1)
for i in range(N-1):
cnt[ls[i]] += 1
for i in range(1,N+1):
print(cnt[i])
| 1 | 32,453,967,466,818 | null | 169 | 169 |
from queue import Queue
n, q_time = map(int, input().split())
qu = Queue()
for i in range(n):
p_name, p_time = input().split()
p_time = int(p_time)
qu.put((p_name, p_time))
t = 0
while True:
if qu.empty():
break
p_name, p_time = qu.get()
if p_time <= q_time:
t += p_time
print(f'{p_name} {t}')
else:
t += q_time
qu.put((p_name, p_time - q_time))
|
n,q = map(int,input().split())
queue = []
for i in range(n):
name,time = input().split()
queue.append((name, int(time)))
t = 0
while queue:
name,time = queue.pop(0)
t += min(q, time)
if time > q:
queue.append((name, time-q))
else:
print(name,t)
| 1 | 43,195,491,842 | null | 19 | 19 |
import sys
input =sys.stdin.readline
def solve():
s = input().rstrip()
n = len(s)
dp = [[float("Inf")]*2 for _ in range(n+1)]
dp[0][0] = 0
dp[0][1] = 1
for i in range(0,n):
number = int(s[i])
dp[i+1][0] = min([dp[i][0]+number,dp[i][0]+(10-number)+1,dp[i+1][0]])
if number != 9:
dp[i+1][1] = min([dp[i][0]+number+1,dp[i][0]+(10-number),dp[i+1][1]])
dp[i+1][0] = min(dp[i][1] +(10-number),dp[i+1][0])
dp[i+1][1] = min(dp[i][1] + (10-number-1),dp[i+1][1])
#print(dp)
print(min(dp[n][0],dp[n][1]+1))
solve()
|
N = input()
keta = len(N)
dp = [[10**18 for i in range(2)] for j in range(keta)]
t = int(N[-1])
dp[0][0] = t
dp[0][1] = 10 - t
for i in range(keta - 2, -1, -1):
t = int(N[i])
#print(keta-i,i,t)
dp[keta-i-1][0] = min(dp[keta-i-2][0]+t,dp[keta-i-2][1]+t+1)
dp[keta-i-1][1] = min(dp[keta-i-2][0]+(10-t),dp[keta-i-2][1]+(10-(t+1)))
#a, b = min(a + t, b + (t + 1)), min(a + (10 - t), b + (10 - (t + 1)))
#print(dp)
print(min(dp[keta-1][0],dp[keta-1][1]+1))
| 1 | 70,953,497,612,614 | null | 219 | 219 |
a,b = map(int,input().split())
c,d = map(int,input().split())
if ((a+1)==c or (a==12 and c==1)):
if d ==1:
print(1)
else:
print(0)
|
from collections import defaultdict
INF = float("inf")
N, *A = map(int, open(0).read().split())
I = defaultdict(lambda: -INF)
O = defaultdict(lambda: -INF)
O[(0, 0)] = 0
for i, a in enumerate(A, 1):
j = (i - 1) // 2
for n in [j, j + 1]:
I[(i, n)] = a + O[(i - 1, n - 1)]
O[(i, n)] = max(O[(i - 1, n)], I[(i - 1, n)])
print(max(I[(N, N // 2)], O[(N, N // 2)]))
| 0 | null | 80,615,499,782,900 | 264 | 177 |
N = int(input())
S = list(input())
ans = 'No'
n = int(N / 2)
if S[:n] == S[n:]:
ans = 'Yes'
print(ans)
|
H, W, K = map(int, input().split())
c = []
b_h = [0] * H
b_w = [0] * W
b = 0
for h in range(H):
c.append(input().rstrip())
for w in range(W):
if c[h][w] == "#":
b_h[h] += 1
b_w[w] += 1
b += 1
ans = 0
for hi in range(2 ** H):
for wi in range(2 ** W):
bsum = b
for h in range(H):
if hi & (2 ** h) != 0:
bsum -= b_h[h]
for w in range(W):
if wi & 2 ** w != 0:
if c[h][w] == '#':
bsum += 1
for w in range(W):
if wi & (2 ** w) != 0:
bsum -= b_w[w]
if bsum == K:
ans += 1
print(ans)
| 0 | null | 77,593,308,586,510 | 279 | 110 |
import numpy as np
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
from numba import njit
def getInputs():
D = int(readline())
CS = np.array(read().split(), np.int32)
C = CS[:26]
S = CS[26:].reshape((-1, 26))
return D, C, S
@njit('(i8, i4[:], i4[:, :], i4[:], )', cache=True)
def _compute_score1(D, C, S, out):
score = 0
last = np.zeros(26, np.int32)
for d in range(len(out)):
i = out[d]
score += S[d, i]
last[i] = d + 1
score -= np.sum(C * (d + 1 - last))
return last, score
def _update_score():
pass
@njit('(i8, i4[:], i4[:, :], i4[:], i8, )', cache=True)
def _random_update(D, C, S, out, score):
d = np.random.randint(0, D)
q = np.random.randint(0, 26)
p = out[d]
if p == q:
return out, score
out[d] = q
_, new_score = _compute_score1(D, C, S, out)
if score < new_score:
score = new_score
else:
out[d] = p
return out, score
@njit('(i8, i4[:], i4[:, :], i4[:], i8, i8, )', cache=True)
def _random_swap(D, C, S, out, score, delta):
d1 = np.random.randint(0, D)
d2 = np.random.randint(max(0, d1 - delta), min(D, d1 + delta))
#p, q = out[[d1, d2]]
p = out[d1]
q = out[d2]
if d1 == d2 or p == q:
return out, score
#out[[d1, d2]] = (q, p)
out[d1] = q
out[d2] = p
_, new_score = _compute_score1(D, C, S, out)
if score < new_score:
score = new_score
else:
#out[[d1, d2]] = (p, q)
out[d1] = p
out[d2] = q
return out, score
def step1(D, C, S):
out = []
LAST = 0
for d in range(D):
max_score = -10000000
best_i = 0
for i in range(26):
out.append(i)
last, score = _compute_score1(D, C, S, np.array(out, np.int32))
if max_score < score:
max_score = score
LAST = last
best_i = i
out.pop()
out.append(best_i)
return np.array(out), LAST, max_score
def step2(D, C, S, out, score):
for _ in range(48 * 10 ** 3):
flag = np.random.rand() >= 0.5
out = out.astype(np.int32)
if flag:
out, score = _random_update(D, C, S, out, score)
else:
out, score = _random_swap(D, C, S, out, score, 13)
return out, score
def output(out):
out += 1
print('\n'.join(out.astype(str).tolist()))
D, C, S = getInputs()
out, _, score = step1(D, C, S)
#print(score)
out, score = step2(D, C, S, out, score)
output(out)
#print(score)
|
import sys
from time import time
from random import randrange, random
input = lambda: sys.stdin.buffer.readline()
DEBUG_MODE = False
st = time()
def get_time():
return time() - st
L = 26
D = int(input())
C = list(map(int, input().split()))
S = [list(map(int, input().split())) for _ in range(D)]
ans = [randrange(L) for _ in range(D)]
class BinaryIndexedTree:
def __init__(self, n):
self.n = n
self.data = [0] * (self.n+1)
def sum(self, i):
res = 0
while i > 0:
res += self.data[i]
i -= i & -i
return res
def add(self, i, x):
if i <= 0: raise IndexError
while i <= self.n:
self.data[i] += x
i += i & -i
def lower_bound(self, x):
if x <= 0: return 0
cur, s, k = 0, 0, 1 << (self.n.bit_length()-1)
while k:
nxt = cur + k
if nxt <= self.n and s + self.data[nxt] < x:
s += self.data[nxt]
cur = nxt
k >>= 1
return cur + 1
def rsum(x):
return x*(x+1)//2
b = [BinaryIndexedTree(D) for _ in range(L)]
score = 0
for d, cont in enumerate(ans):
b[cont].add(d+1, 1)
score += S[d][cont]
for i in range(L):
m = b[i].sum(D)
tmp = 0
s = [0]
for j in range(1, m+1):
s.append(b[i].lower_bound(j))
s.append(D+1)
for j in range(len(s)-1):
x = s[j+1] - s[j] - 1
tmp += rsum(x)
score -= tmp*C[i]
def chg(d, p, q):
diff = 0
d += 1
o = b[p].sum(d)
d1 = b[p].lower_bound(o-1)
d2 = b[p].lower_bound(o+1)
diff += rsum(d-d1) * C[p]
diff += rsum(d2-d) * C[p]
diff -= rsum(d2-d1) * C[p]
o = b[q].sum(d)
d1 = b[q].lower_bound(o)
d2 = b[q].lower_bound(o+1)
diff += rsum(d2-d1) * C[q]
diff -= rsum(d-d1) * C[q]
diff -= rsum(d2-d) * C[q]
d -= 1
diff -= S[d][p]
diff += S[d][q]
ans[d] = q
b[p].add(d+1, -1)
b[q].add(d+1, 1)
return diff
while True:
if random() >= 0.8:
d, q = randrange(D), randrange(L)
p = ans[d]
diff = chg(d, p, q)
if diff > 0:
score += diff
else:
chg(d, q, p)
else:
d1 = randrange(D-1)
d2 = randrange(d1+1, min(d1+3, D))
p, q = ans[d1], ans[d2]
diff = chg(d1, p, q)
diff += chg(d2, q, p)
if diff > 0:
score += diff
else:
chg(d1, q, p)
chg(d2, p, q)
if DEBUG_MODE: print(score)
if get_time() >= 1.7: break
if DEBUG_MODE: print(score)
else:
for x in ans: print(x+1)
| 1 | 9,715,551,961,408 | null | 113 | 113 |
S = input()
N = len(S)
def kaibun(s):
n = len(s)
f_kaibun = True
for i in range(int(n/2)):
j = n-1-i
if j <= i:
break
if s[i] != s[j]:
f_kaibun = False
break
return f_kaibun
if kaibun(S) and kaibun(S[0:int(round((N-1)/2))]) and kaibun(S[int(round((N+3)/2))-1:N]):
print('Yes')
else:
print('No')
|
import numpy as np
inp = input
#fin = open("case_21.txt")
#inp = fin.readline
X, Y, A, B, C = map(int, inp().split())
#red = np.array(list(map(int, inp().split())), np.int32)
#green = np.array(list(map(int, inp().split())), np.int32)
#white = np.array(list(map(int, inp().split())), np.int32)
red = list(map(int, inp().split()))
green = list(map(int, inp().split()))
white = list(map(int, inp().split()))
red.sort(reverse=True)
green.sort(reverse=True)
white.sort(reverse=True)
#fin.close()
#red[::-1].sort()
#green[::-1].sort()
#white[::-1].sort()
idr = 0
idg = 0
idw = 0
total = 0.0
countr = 0
countg = 0
countw = 0
while X > countr and Y > countg and (X+Y > countr+countg+countw):
if red[idr] >= green[idg]:
if idw >= C or red[idr] >= white[idw]:
#eat red
total += red[idr]
idr += 1
countr += 1
elif idw < C:
#eat white
total += white[idw]
idw += 1
countw += 1
else:
if idw >= C or green[idg] >= white[idw]:
# eat green
total += green[idg]
idg += 1
countg += 1
else:
#eat white
total += white[idw]
idw += 1
countw += 1
#eat remain
if Y <= countg:
while X > countr+countw:
# compare red 1st
if idw < C and red[idr] < white[idw]:
# eat white
total += white[idw]
idw += 1
else:
# eat red
total += red[idr]
idr += 1
countr += 1
if X <= countr:
while Y > countg+countw:
# compare green 1st
if idw < C and green[idg] < white[idw]:
# eat white
total += white[idw]
idw += 1
else:
# eat green
total += green[idg]
idg += 1
countg += 1
print(int(total))
| 0 | null | 45,431,983,312,508 | 190 | 188 |
n = int(input())
l = list(range(0,n+1))
print(sum([i for i in l if i % 3 != 0 and i % 5 != 0]))
|
N = int(input())
ans = 0
for n in range(1, N+1):
if n%3 == 0:
pass
elif n%5 == 0:
pass
else:
ans += n
print(ans)
| 1 | 35,121,590,736,590 | null | 173 | 173 |
n = int(input())
A = list(map(int, input().split(' ')))
q = int(input())
M = list(map(int, input().split(' ')))
# 上限と下限でフィルター
max_A = 0
min_A = float('inf')
for num in A:
max_A += num
if num < min_A:
min_A = num
def rec(i, m):
if m < 0:
return False
elif m == 0:
return True
if i >= n:
return False
rst = rec(i+1, m - A[i]) or rec(i+1, m)
return rst
for m in M:
if m < min_A or max_A < m:
print('no')
elif rec(0, m):
print('yes')
else:
print('no')
|
n = int(input())
n_li = list(map(int, input().split()))
q = int(input())
q_li = list(map(int, input().split()))
ans = [0]*q
tmp_li = []
for i in range(2**n):
check = [0]*n
for j in range(n):
if ((i >> j) & 1):
check[n - 1 - j] = 1
tmp = 0
for a in range(n):
if check[a] == 1:
tmp += n_li[a]
tmp_li.append(tmp)
for k in range(q):
if q_li[k] in tmp_li:
ans[k] = 1
for x in ans:
if x == 1:
print('yes')
else:
print('no')
| 1 | 97,595,416,800 | null | 25 | 25 |
import sys
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
def resolve():
N, M = lr()
if N%2 == 1:
for i in range(0, M):
print(f'{2+i} {1+2*M-i}')
else:
k = N//4
for i in range(M):
if i < k:
print(f'{i+1} {N-i}')
else:
print(f'{i+2} {N-i}')
resolve()
|
N, M = map(int, input().split())
ans = []
if N % 2 == 1:
l, r = 1, N - 1
while l < r:
ans.append((l, r))
l += 1
r -= 1
else:
l, r = 1, N - 1
flag = False
while l < r:
if not flag and r - l <= N // 2:
r -= 1
flag = True
ans.append((l, r))
l += 1
r -= 1
for i in range(M):
print(ans[i][0], ans[i][1])
| 1 | 28,533,462,757,440 | null | 162 | 162 |
import sys
R, C, K = map(int, input().split())
item = [[0] * (C + 1) for _ in range(R + 1)] # dp配列と合わせるために, 0行目, 0列目を追加している.
for s in sys.stdin.readlines():
r, c, v = map(int, s.split())
item[r][c] = v
dp = [[[0] * (C + 1) for _ in range(R + 1)] for _ in range(4)]
for i in range(R + 1):
for j in range(C + 1):
for k in range(4):
here = dp[k][i][j]
# 次の行に移動する場合
if i + 1 <= R:
# 移動先のアイテムを取らない場合
dp[0][i + 1][j] = max(dp[0][i + 1][j], here)
# 移動先のアイテムを取る場合
dp[1][i + 1][j] = max(dp[1][i + 1][j], here + item[i + 1][j])
# 次の列に移動する場合
if j + 1 <= C:
# 移動先のアイテムを取らない場合
dp[k][i][j + 1] = max(dp[k][i][j + 1], here)
# 現在のkが3未満のときのみ, 移動先のアイテムを取ることが可能
if k < 3:
dp[k + 1][i][j + 1] = max(dp[k + 1][i][j + 1], here + item[i][j + 1])
ans = 0
for k in range(4):
ans = max(ans, dp[k][-1][-1])
print(ans)
|
ma = lambda :map(int,input().split())
lma = lambda :list(map(int,input().split()))
tma = lambda :tuple(map(int,input().split()))
ni = lambda:int(input())
yn = lambda fl:print("Yes") if fl else print("No")
import collections
import math
import itertools
import heapq as hq
R,C,K = ma()
V = [[0 for i in range(R+1)] for j in range(C+1)]
for i in range(K):
r,c,v = ma()
V[c][r] = v
dp_prev = [[0]*4 for i in range(C+1)]
dp_nex = [[0]*4 for i in range(C+1)] #dp[h][k] h列目でmax kこまで選んだ時の最大値
for r in range(1,R+1):
for c in range(1,C+1):
v = V[c][r]
for k in range(4):
if k==0:
dp_nex[c][0] = max(dp_prev[c][3],dp_nex[c-1][0])
elif k >0:
dp_nex[c][k] = max(dp_nex[c-1][k],dp_nex[c-1][k-1]+v,dp_prev[c][3]+v)
dp_prev,dp_nex = dp_nex,dp_prev
#print(dp_prev)
print(dp_prev[C][3])
| 1 | 5,621,980,106,908 | null | 94 | 94 |
import sys
sys.setrecursionlimit(10**7)
n = int(input())
def dfs(s):
if len(s) == n:
print(s)
return 0
for x in map(chr, range(97, ord(max(s))+2)):
dfs(s+x)
dfs('a')
|
l = "abcdefghij"
def dfs(a, mx):
if len(a) == n:
print(a)
return
for i, s in enumerate(l):
if i == mx+1:
dfs(a+s, mx+1)
break
else:
dfs(a+s, mx)
n = int(input())
dfs("a", 0)
| 1 | 52,396,364,354,400 | null | 198 | 198 |
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
# import numpy as np
# sys.setrecursionlimit(10000001)
INF = 10 ** 16
# MOD = 10 ** 9 + 7
MOD = 998244353
def ni(): return int(sys.stdin.readline())
def ns(): return map(int, sys.stdin.readline().split())
def na(): return list(map(int, sys.stdin.readline().split()))
# ===CODE===
class ModCombination:
# https://atcoder.jp/contests/abc167/submissions/13058694
# https://ikatakos.com/pot/programming_algorithm/number_theory/mod_combination
def __init__(self, maxN, MOD):
self._maxN = maxN
self._MOD = MOD
self.facts = [1]
self.invs = [1]*(self._maxN+1)
fact = 1
for i in range(1, self._maxN+1):
fact *= i
fact %= self._MOD
self.facts.append(fact)
inv = pow(fact, self._MOD-2, self._MOD)
self.invs[self._maxN] = inv
for i in range(self._maxN, 1, -1):
inv *= i
inv %= self._MOD
self.invs[i-1] = inv
def nCr(self, n, r):
return self.facts[n]*self.invs[r]*self.invs[n-r] % self._MOD
def main():
n, m, k = ns()
mc = ModCombination(n, MOD)
result = 0
for ki in range(k + 1):
ans = 1
ans *= m % MOD
ans *= pow(m - 1, n - 1 - ki, MOD)
ans %= MOD
ans *= mc.nCr(n-1, ki)
ans %= MOD
result += ans
result %= MOD
print(result)
if __name__ == '__main__':
main()
|
def comb(n,r,m):
if 2*r > n:
r = n - r
nume,deno = 1,1
for i in range(1,r+1):
nume *= (n-i+1)
nume %= m
deno *= i
deno %= m
return (nume * pow(deno,m-2,m)) % m
def main():
N,M,K = map(int,input().split())
mod = 998244353
ans,comb_r = pow(M-1,N-1,mod),1
for r in range(1,K+1):
comb_r = (comb_r * (N-r) * pow(r,mod-2,mod)) % mod
ans = (ans + comb_r * pow(M-1,N-r-1,mod)) % mod
ans = (ans * M) % mod
print(ans)
if __name__ == "__main__":
main()
| 1 | 23,141,724,313,600 | null | 151 | 151 |
from itertools import accumulate
def solve(string):
n, m, k, *ab = map(int, string.split())
a, b = [0] + ab[:n], [0] + ab[n:]
a, b = list(accumulate(a)), list(accumulate(b))
i, j = n, 0
while a[i] > k:
i -= 1
while j <= m and a[i] + b[j] <= k:
j += 1
ans = i + j - 1
for i in range(i, -1, -1):
while j <= m and a[i] + b[j] <= k:
j += 1
ans = max(ans, i + j - 1)
return str(ans)
if __name__ == '__main__':
import sys
print(solve(sys.stdin.read().strip()))
|
N, M, K = map(int,input().split())
A = list(map(int,input().split()))
B = list(map(int,input().split()))
Asum = [0]
Bsum = [0]
a = 0
b = 0
for i in range(N):
a += A[i]
Asum.append(a)
for i in range(M):
b += B[i]
Bsum.append(b)
Asum.append(0)
Bsum.append(0)
res, j = 0, M
for i in range(N+1):
if Asum[i] > K:
break
while Asum[i] + Bsum[j] > K:
j -= 1
res = max(res,i+j)
print(res)
| 1 | 10,777,852,120,608 | null | 117 | 117 |
n = int(input())
a = list(map(int, input().split()))
m = 65 # a<2**m
mod = 10**9+7
xor_num = [0]*m
for i in range(n):
for j in range(m):
if ((a[i] >> j) & 1):
xor_num[j] += 1
b = 1
ans = 0
for i in range(m):
ans += b*xor_num[i]*(n-xor_num[i])
b *= 2
b %= mod
print(ans%mod)
|
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
N, *A = map(int, read().split())
ans = 0
p = 1
for _ in range(60):
n = 0
for i in range(N):
A[i], d = A[i] // 2, A[i] % 2
n += d
ans = (ans + n * (N - n) * p) % MOD
p = p * 2 % MOD
print(ans)
return
if __name__ == '__main__':
main()
| 1 | 122,871,905,927,464 | null | 263 | 263 |
mod = 1000000007
n,k = map(int, input().split())
d = [0]*(k+1)
for i in range(1,k+1):
d[i] = pow(k//i,n,mod)
for i in range(k,0,-1):
for j in range(2*i,k+1,i):
d[i] -= d[j]
d[i] %= mod
ans = 0
for i in range(1,k+1):
ans += d[i]*i
ans %= mod
print(ans)
|
N, K = map(int, input().split())
MOD = 10 ** 9 + 7
c = [0] * (K + 1)
for i in range(K, 0, -1):
t = pow(K // i, N, MOD)
for j in range(2, K // i + 1):
t -= c[i * j]
t %= MOD
c[i] = t
result = 0
for i in range(1, K + 1):
result += c[i] * i
result %= MOD
print(result)
| 1 | 36,772,892,945,488 | null | 176 | 176 |
from collections import defaultdict
h, w, m = map(int, input().split())
targets = []
targets_count_w = defaultdict(int)
targets_count_h = defaultdict(int)
for _ in range(m):
y, x = map(int, input().split())
y -= 1
x -= 1
targets_count_w[x] += 1
targets_count_h[y] += 1
targets.append((y, x))
max_w = max(targets_count_w.values())
max_h = max(targets_count_h.values())
y_idx = defaultdict(bool)
x_idx = defaultdict(bool)
max_count_x = 0
max_count_y = 0
for i in range(w):
if targets_count_w[i] == max_w:
x_idx[i] = True
max_count_x += 1
for i in range(h):
if targets_count_h[i] == max_h:
y_idx[i] = True
max_count_y += 1
ans = max_w + max_h
kumi = max_count_x*max_count_y
for ty, tx in targets:
if y_idx[ty] and x_idx[tx]:
kumi -= 1
if kumi == 0:
break
if kumi == 0:
print(ans-1)
else:
print(ans)
|
s = input()
#print(s.replace("?", "D"))
ans = []
for i in s:
if i == "P":
ans.append("P")
else:
ans.append("D")
print("".join(ans))
| 0 | null | 11,625,575,632,220 | 89 | 140 |
# import bisect
# from collections import Counter, defaultdict, deque
# import copy
# from heapq import heappush, heappop, heapify
# from fractions import gcd
# import itertools
# from operator import attrgetter, itemgetter
# import math
import sys
# import numpy as np
ipti = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)
def main():
x, y = list(map(int,ipti().split()))
prize = [300000, 200000, 100000, 0]
if x == y == 1:
print(1000000)
else:
x = 4 if x > 3 else x
y = 4 if y > 3 else y
print(prize[x-1]+prize[y-1])
if __name__ == '__main__':
main()
|
M,N = map(int,input().rstrip().split(" "))
ans=False
for a in range(M + 1):
b=M-a
if 2 * a + 4 * b == N:
ans=True
if ans:
print("Yes")
else:
print("No")
| 0 | null | 77,424,238,599,520 | 275 | 127 |
while True:
s = raw_input()
if s == '-':
break
m = input()
for i in range(m):
h = input()
s = s[h:]+s[:h]
print s
|
while True:
text = input()
if text == '-':
break
m = int(input())
for _ in range(m):
h = int(input())
text = text[h:] + text[:h]
print(text)
| 1 | 1,921,611,277,610 | null | 66 | 66 |
lit = input()
length = len(lit)
times = 0
if length != 1:
for i in range(int(length/2)):
if lit[i] != lit[length-1-i]:
times += 1
print(times)
else:
print(times)
|
from collections import deque
n = int(input())
Q = deque()
for _ in range(n):
query = input()
if query=='deleteFirst':
Q.popleft()
elif query=='deleteLast':
Q.pop()
else:
q, x = query.split()
if q=='insert':
Q.appendleft(x)
else:
try:
Q.remove(x)
except ValueError:
pass
print(' '.join(Q))
| 0 | null | 60,016,656,250,268 | 261 | 20 |
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)
|
from collections import Counter
N=int(input())
D=list(map(int, input().split() ))
d=dict(Counter(D))
p=998244353
#print(d)
maxi=max(d)
ans=1
if D[0]!=0:
print(0)
else:
if d[0]!=1:
print(0)
else:
for i in range(1,maxi+1):
if i not in d:
print(0)
exit()
else:
s = (d[i-1]**d[i])%p
ans = (ans * s)%p
print(ans)
| 1 | 154,541,344,944,458 | null | 284 | 284 |
import sys
stdin = sys.stdin
inf = 1 << 60
mod = 1000000007
ni = lambda: int(ns())
nin = lambda y: [ni() for _ in range(y)]
na = lambda: list(map(int, stdin.readline().split()))
nan = lambda y: [na() for _ in range(y)]
nf = lambda: float(ns())
nfn = lambda y: [nf() for _ in range(y)]
nfa = lambda: list(map(float, stdin.readline().split()))
nfan = lambda y: [nfa() for _ in range(y)]
ns = lambda: stdin.readline().rstrip()
nsn = lambda y: [ns() for _ in range(y)]
ncl = lambda y: [list(ns()) for _ in range(y)]
nas = lambda: stdin.readline().split()
n, k = na()
def modpow(n, p, m):
if p == 0:
return 1
if p % 2 == 0:
t = modpow(n, p // 2, m)
return t * t % m
return n * modpow(n, p - 1, m) % m
d = [0] * (k + 1)
ans = 0
for i in range(k, 0, -1):
d[i] = modpow(k // i, n, mod)
j = 2
while j * i <= k:
d[i] -= d[j * i]
j += 1
ans += d[i] * i % mod
print(ans % mod)
|
N = int(input())
if N == 1:
print(1)
elif N%2 == 0:
print(0.5)
else:
print((N+1)/2/N)
| 0 | null | 107,225,563,979,532 | 176 | 297 |
n = int(input())
m = list(map(int, input().split()))
count = 0
flag = 1
while flag:
flag = 0
for j in range(n-1, 0, -1):
if m[j] < m[j-1]:
m[j], m[j-1] = m[j-1], m[j]
count += 1
flag = 1
print(" ".join(str(x) for x in m))
print(count)
|
def bubblesort(N, A):
"""Do BubbleSort"""
m = 0
flag = True
while(flag):
flag = False
for i in range(N-1, 0, -1):
if (A[i-1] > A[i]):
tmp = A[i-1]
A[i-1] = A[i]
m += 1
A[i] = tmp
flag = True
b = list(map(str, A))
print(" ".join(b))
print(m)
A = []
N = int(input())
s = input()
A = list(map(int, s.split()))
bubblesort(N, A)
| 1 | 18,325,395,180 | null | 14 | 14 |
s = input()
p = input()
if (s * 2).find(p) >= 0:
print("Yes")
else:
print("No")
|
N, M=map(int, input().split(" "))
print(int((N*(N-1))/2+(M*(M-1))/2))
| 0 | null | 23,748,343,096,180 | 64 | 189 |
def main():
import sys
K=int(sys.stdin.readline())
print('ACL'*K)
main()
|
n = input()
if n[0]=="7":
print("Yes")
exit()
if n[1]=="7":
print("Yes")
exit()
if n[2]=="7":
print("Yes")
exit()
print("No")
| 0 | null | 18,109,520,010,780 | 69 | 172 |
n=int(input())
a=list(map(int,input().split()))
c=0;b=1;i=0
while b:
b=0
for j in range(0,n-i-1):
if a[j]>a[j+1]:a[j],a[j+1]=a[j+1],a[j];b=1;c+=1
i+=1
print(*a)
print(c)
|
N,K = map(int,input().split())
i = 0
while True:
if N >= K ** i:
i += 1
else:
break
print(i)
| 0 | null | 32,120,129,048,800 | 14 | 212 |
n=int(input())
r="ACL"*n
print(r)
|
s = input().rstrip().split(' ')
a = int(s[0])
b = int(s[1])
c = int(s[2])
if a < b and b < c:
print("Yes")
else:
print("No")
| 0 | null | 1,300,253,476,820 | 69 | 39 |
k=int(input())
s=input()
n=len(s)
if(n<=k):
print(s)
else:
print(s[:k]+'...')
|
n = int(input())
p = input()
if n>=len(p):
print(p)
else:
print(p[:n] + '...')
| 1 | 19,797,859,014,122 | null | 143 | 143 |
import sys
a, b, c = map(int, sys.stdin.readline().split())
if(a < b < c):
print("Yes")
else:
print("No")
|
def combination(n, r, m):
res = 1
r = min(r, n - r)
for i in range(r):
res = res * (n - i) % m
res = res * pow(i + 1, m - 2, m) % m
return res
mod = 10**9 + 7
n, a, b = map(int, input().split())
total = pow(2, n, mod) - 1
total -= (combination(n, a, mod) + combination(n, b, mod)) % mod
print(total % mod)
| 0 | null | 33,285,218,285,940 | 39 | 214 |
def main():
alphabets = "abcdefghijklmnopqrstuvwxyz"
c = input()
print(alphabets[alphabets.index(c)+1])
main()
|
def main():
C = input()
ans = chr(ord(C) + 1)
print(ans)
if __name__ == "__main__":
main()
| 1 | 91,719,300,495,460 | null | 239 | 239 |
# #
# author : samars_diary #
# 13-09-2020 │ 12:41:59 #
# #
import sys, os.path
#if(os.path.exists('input.txt')):
#sys.stdin = open('input.txt',"r")
#sys.stdout = open('output.txt',"w")
sys.setrecursionlimit(10 ** 5)
def mod(): return 10**9+7
def i(): return sys.stdin.readline().strip()
def ii(): return int(sys.stdin.readline())
def li(): return list(sys.stdin.readline().strip())
def mii(): return map(int, sys.stdin.readline().split())
def lii(): return list(map(int, sys.stdin.readline().strip().split()))
#print=sys.stdout.write
def solve():
n,x,t=mii()
print(t*(n//x)+t*(bool(n%x)))
solve()
|
import math
def main(n: int, x: int, t: int):
print(math.ceil(n / x) * t)
if __name__ == '__main__':
n, x, t = map(int, input().split())
main(n, x, t)
| 1 | 4,230,959,204,868 | null | 86 | 86 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.