code1
stringlengths 16
427k
| code2
stringlengths 16
427k
| similar
int64 0
1
| pair_id
int64 2
181,637B
⌀ | question_pair_id
float64 3.71M
180,629B
⌀ | code1_group
int64 1
299
| code2_group
int64 1
299
|
|---|---|---|---|---|---|---|
n,m=map(int,input().split())
lst=list(map(int,input().split()))
dp=[[float("inf") for i in range(n+1)] for j in range(m+1)]
for i in range(m+1):
dp[i][0]=0
for i in range(1,m+1):
for j in range(1,n+1):
if j-lst[i-1]>=0:
dp[i][j]=min(dp[i-1][j],dp[i][j-lst[i-1]]+1)
else : dp[i][j]=dp[i-1][j]
print(int(dp[m][n]))
| n, m = map(int, input().split())
c = list(map(int, input().split()))
dp = [float("inf")] * (n+1)
dp[0] = 0
for i in range(1, n + 1):
for j in range(m):
if i >= c[j]:
dp[i] = min(dp[i], dp[i-c[j]]+1)
print(dp[n])
| 1 | 146,241,640,072 | null | 28 | 28 |
A, B, K = map(int, input().split())
a = A - K
if a >= 0:
print(a, B)
elif a < 0:
b = B + a
print(0, max(b,0))
| import numpy as np
inp = input()
A, B, K = int(inp.split(' ')[0]), int(inp.split(' ')[1]), int(inp.split(' ')[2])
if K>A:
B = np.max([0, B-(K-A)])
A = np.max([0, A-K])
print(f'{A} {B}') | 1 | 104,233,922,794,122 | null | 249 | 249 |
n = int(input())
dp = [0] * 45
dp[0], dp[1] = 1, 1
for i in range(2, 44+1):
dp[i] += dp[i-1] + dp[i-2]
print(dp[n])
| from string import ascii_lowercase, ascii_uppercase
l = ascii_lowercase
u = ascii_uppercase
def conv(c):
if c in l:
return u[l.index(c)]
if c in u:
return l[u.index(c)]
return c
open(1, 'w').write("".join(map(conv, open(0).readline())))
| 0 | null | 758,276,848,252 | 7 | 61 |
#/usr/bin/python
def solve():
n, k = map(int, input().split())
a = sorted(map(int, input().split()), reverse=True)
mod = 10 ** 9 + 7
l = 0
r = n - 1
ans = 1
if k % 2 == 1:
ans = a[0]
l = 1
# If the maximum number is negative and k is odd, the answer is the product of the first k numbers.
if ans < 0:
mul = 1
for i in range(k):
mul = mul * a[i] % mod
return mul
# otherwise, multiply the leftmost two products and the rightmost two products, whichever is larger.
for i in range(k//2):
l_mul = a[l] * a[l+1]
r_mul = a[r] * a[r-1]
if l_mul >= r_mul:
ans = ans * l_mul % mod
l += 2
else:
ans = ans * r_mul % mod
r -= 2
return ans
print(solve())
| N, K = map(int, input().split())
A = list(map(int, input().split()))
B = []
T = {"mi":0, "pu":0, "zero":0}
for i in range(N):
if A[i] < 0:
T["mi"] += 1
elif A[i] == 0:
T["zero"] += 1
else:
T["pu"] += 1
mod = 10**9+7
for i in range(N):
if A[i] < 0:
B.append([A[i]*(-1), 1])
else:
B.append([A[i], 0])
A.sort()
B.sort(reverse=True)
ans = 1
c = 0
for i in range(K):
ans *= B[i][0]
ans %= mod
c += B[i][1]
if c % 2 == 0:
print(ans)
elif K > T["pu"]+T["mi"]:
print(0)
elif T["mi"] == 1 and K > T["pu"]:
ans = 1
for i in range(N):
ans *= A[i]
ans %= mod
if T["zero"] != 0:
ans = 0
print(ans)
elif T["pu"] == 1 and K > T["mi"]:
ans = 1
for i in range(N):
ans *= A[i]
ans %= mod
if T["zero"] != 0:
ans = 0
print(ans)
elif T["pu"] == 0:
ans = 1
A.reverse()
for i in range(K):
ans *= A[i]
ans %= mod
if T["zero"] != 0:
ans = 0
print(ans)
elif N == K:
ans = 1
for i in range(N):
ans *= A[i]
ans %= mod
print(ans)
else:
change1 = B[K-1][1]
change2 = (change1 + 1)%2
chindex1 = K-1
chindex2 = -1
for i in range(K-1, -1, -1):
if B[i][1] == change2:
chindex2 = i
break
afterindex1 = -1
afterindex2 = -1
for i in range(K, N):
if B[i][1] == change2:
afterindex1 = i
break
for i in range(K, N):
if B[i][1] == change1:
afterindex2 = i
break
result1 = 0
result2 = 0
if chindex1 >= 0 and afterindex1 >= 0:
ans = 1
for i in range(N):
if i <= K-1 or i == afterindex1:
if i != chindex1:
ans *= B[i][0]
ans %= mod
result1 = ans
if chindex2 >= 0 and afterindex2 >= 0:
ans = 1
for i in range(N):
if i <= K-1 or i == afterindex2:
if i != chindex2:
ans *= B[i][0]
ans %= mod
result2 = ans
if result1 == 0 and result2 == 0:
print(0)
elif result1 == 0:
print(result2)
elif result2 == 0:
print(result1)
elif B[afterindex1][0]*B[chindex2][0] - B[afterindex2][0]*B[chindex1][0] > 0:
print(result1)
else:
print(result2) | 1 | 9,498,571,251,780 | null | 112 | 112 |
n,k=map(int,input().split())
L=list(range(n+1))
cnt=0
ans=0
def calc(i):
smallest=(i-1)*i//2
largest=(2*n-i+1)*i//2
return largest-smallest+1
for i in range(k,n+2):
cnt+=calc(i)
cnt%=(10**9+7)
print(cnt) | #!/usr/bin/env python3
import sys
from itertools import chain
# import numpy as np
# from itertools import combinations as comb
# from bisect import bisect_left, bisect_right, insort_left, insort_right
# from collections import Counter
MOD = 1000000007 # type: int
OFFSET = 10 ** 100
def k_in_n(k, n):
"""0〜n までの数からちょうど k 個の数を選ぶ時の最大最小"""
minimum = (k * (k - 1)) // 2
maximum = (k * (2 * n - k + 1)) // 2
return (minimum, maximum)
def solve(N: int, K: int):
keep = None # まだ加算されていない範囲
answer = 0
for k in range(K, N + 2):
if keep is None:
keep = k_in_n(k, N)
else:
minmax = k_in_n(k, N)
if minmax[0] + OFFSET <= keep[1]:
keep[0] -= OFFSET
keep[1] = minimum[1]
else:
answer = (answer + keep[1] - keep[0] + 1) % MOD
keep = minmax
if keep is not None:
answer = (answer + keep[1] - keep[0] + 1) % MOD
return answer
def main():
tokens = chain(*(line.split() for line in sys.stdin))
# N, K = map(int, input().split())
# N, K = input().strip()
# N, K = int(input())
N = int(next(tokens)) # type: int
K = int(next(tokens)) # type: int
answer = solve(N, K)
print(answer)
if __name__ == "__main__":
main()
| 1 | 33,137,660,201,770 | null | 170 | 170 |
#!/usr/bin/env python3
import sys
sys.setrecursionlimit(10**8)
INF = float("inf")
def yes():
print("Yes") # type: str
def no():
print("No") # type: str
def solve(N: int, S: "List[str]"):
def seq_positive(ls):
state = 0
for l, st in ls:
if state+l < 0:
return False
state += st
return True
# 部分括弧列の特徴量を計算する。
# 経過中の最小値と、最終到達値
left_seq = []
right_seq = []
total = 0
for s in S:
state = 0
lower = 0
for c in s:
if c == "(":
state += 1
else:
state -= 1
lower = min(lower, state)
if state > 0:
left_seq.append((lower, state))
else:
right_seq.append((lower-state, -state))
total += state
left_seq.sort(reverse=True)
right_seq.sort(reverse=True)
# print(left_seq)
# print(right_seq)
if seq_positive(left_seq) and seq_positive(right_seq) and total == 0:
yes()
else:
no()
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
S = [next(tokens) for _ in range(N)] # type: "List[str]"
solve(N, S)
if __name__ == '__main__':
main()
| # coding: utf-8
import sys
from operator import itemgetter
sysread = sys.stdin.readline
read = sys.stdin.read
from heapq import heappop, heappush
#from collections import defaultdict
sys.setrecursionlimit(10**7)
#import math
#from itertools import combinations, product
#import bisect# lower_bound etc
#import numpy as np
#import queue# queue,get(), queue.put()
def run():
N = int(input())
current = 0
ways = []
dic = {'(': 1, ')': -1}
SS = read().split()
for S in SS:
path = [0]
for s in S:
path.append(path[-1]+ dic[s])
ways.append((path[-1], min(path)))
ways_pos = sorted([(a,b) for a,b in ways if a >= 0], key = lambda x:x[0], reverse=True)
ways_neg = sorted([(a,b) for a,b in ways if a < 0], key = lambda x:(x[0] - x[1]), reverse=True)
tmp = []
for go, max_depth in ways_pos:
if current + max_depth >= 0:
current += go
else:
tmp.append((go, max_depth))
for go, max_depth in tmp:
if current + max_depth >= 0:
current += go
else:
print('No')
return None
tmp =[]
for go, max_depth in ways_neg:
if current + max_depth >= 0:
current += go
else:
tmp.append((go, max_depth))
for go, max_depth in tmp:
if current + max_depth >= 0:
current += go
else:
print('No')
return None
if current == 0:
print('Yes')
else:
print('No')
if __name__ == "__main__":
run() | 1 | 23,594,246,356,472 | null | 152 | 152 |
N,K = list(map(int, input().split()))
A = [int(i) for i in input().split()]
for i in range(K,N):
if A[i] > A[i-K]:
print("Yes")
else:
print("No") | N,K = map(int, input().split())
A = list(map(int, input().split()))
for i in range(K+1,N+1):
if A[i-K-1] < A[i-1]:
print("Yes")
else:
print("No") | 1 | 7,117,753,630,730 | null | 102 | 102 |
import sys
def insertionSort( nums, n, g ):
cnt = 0
i = g
while i < n:
v = nums[i]
j = i - g
while 0 <= j and v < nums[j]:
nums[ j+g ] = nums[j]
j -= g
cnt += 1
nums[ j+g ] = v
i += 1
return cnt
def shellSort( nums, n ):
g = []
val = 1
while val <= n:
g.append( val )
val = 3*val+1
g.reverse( )
m = len( g )
print( m )
print( " ".join( map( str, g ) ) )
cnt = 0
for i in range( m ):
cnt += insertionSort( nums, n, g[i] )
print( cnt )
n = int( sys.stdin.readline( ) )
nums = []
for i in range( n ):
nums.append( int( sys.stdin.readline( ) ) )
shellSort( nums, n )
print( "\n".join( map( str, nums ) ) ) | s = input()
if (s.isupper()):
print('A')
else:
print('a') | 0 | null | 5,661,941,091,592 | 17 | 119 |
#!/usr/bin/env python3
import sys
from itertools import chain
# import numpy as np
# from itertools import combinations as comb
# from bisect import bisect_left, bisect_right, insort_left, insort_right
# from collections import Counter
def solve(N: int, P: "List[int]"):
min_p = P[0]
count = 0
for p in P:
if p <= min_p:
min_p = p
count += 1
return count
def main():
tokens = chain(*(line.split() for line in sys.stdin))
N = int(next(tokens)) # type: int
P = [int(next(tokens)) for _ in range(N)] # type: "List[int]"
answer = solve(N, P)
print(answer)
if __name__ == "__main__":
main()
| from statistics import median
#import collections
#aa = collections.Counter(a) # list to list || .most_common(2)で最大の2個とりだせるお a[0][0]
from fractions import gcd
from itertools import combinations # (string,3) 3回
from collections import deque
from collections import defaultdict
import bisect
#
# d = m - k[i] - k[j]
# if kk[bisect.bisect_right(kk,d) - 1] == d:
#
#
#
# pythonで無理なときは、pypyでやると正解するかも！！
#
#
import sys
sys.setrecursionlimit(10000000)
mod = 10**9 + 7
def readInts():
return list(map(int,input().split()))
def main():
n,a,b = readInts()
ab = abs(a-b)
if ab % 2 == 0:
print(ab//2)
else:
print(min(a + (ab-1)//2, n - b + 1 + (ab-1)//2))
if __name__ == '__main__':
main()
| 0 | null | 97,037,546,333,080 | 233 | 253 |
import itertools
N, K = map(int, input().split())
p = list(map(int, input().split()))
pos = [(p[i]+1)/2 for i in range(N)]
pos_acum = list(itertools.accumulate(pos))
ans = pos_acum[K-1]
for i in range(N-K):
ans = max(ans, pos_acum[K+i]-pos_acum[i])
print(ans) | n,k=map(int,input().split())
p=list(map(int,input().split()))
li=[sum(p[0:k])]
for i in range(n-k):
li.append(li[i]-p[i]+p[i+k])
print((max(li)+k)/2) | 1 | 74,989,106,650,940 | null | 223 | 223 |
def main():
s = input()
t = input()
ans = 0
for i, char in enumerate(s):
if char != t[i]:
ans += 1
print(ans)
if __name__ == '__main__':
main()
| A = list(map(int, input().split()))
for i in range(len(A)):
if A[i] == 0: print(i+1) | 0 | null | 12,026,686,510,968 | 116 | 126 |
from collections import Counter
N = int(input())
X = list(map(int, input().split()))
MOD = 998244353
ctr = Counter(X)
if X[0] == 0 and ctr[0] == 1:
ans = 1
for i in range(1, max(X) + 1):
ans *= pow(ctr[i - 1], ctr[i], MOD)
ans %= MOD
print(ans)
else:
print(0)
| 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,699,534,945,020 | null | 284 | 284 |
n = int(input())
AC,WA,TLE,RE = 0,0,0,0
for x in range(n):
s = input()
if s == 'AC':
AC = AC + 1
elif s == 'WA':
WA = WA + 1
elif s == 'TLE':
TLE = TLE + 1
elif s == 'RE':
RE = RE + 1
print('AC x ' + str(AC))
print('WA x ' + str(WA))
print('TLE x ' + str(TLE))
print('RE x ' + str(RE))
| a=int(input())
b=[input() for i in range(a)]
c=0
d=0
e=0
f=0
for i in range(a):
if b[i]=="AC":
c=c+1
if b[i]=="WA":
d=d+1
if b[i]=="TLE":
e=e+1
if b[i]=="RE":
f=f+1
print("AC","x",c)
print("WA","x",d)
print("TLE","x",e)
print("RE","x",f) | 1 | 8,641,750,866,800 | null | 109 | 109 |
n=int(input())
S=[int(i) for i in input().split()]
q=int(input())
T=[int(i) for i in input().split()]
def solve(i,m,n,S):
if sum(S)<m:
return False
if m==0:
return True
elif i>=n:
return False
res=solve(i+1,m,n,S) or solve(i+1,m-S[i],n,S)
return res
for i in range(q):
attempt=solve(0,T[i],n,S)
if attempt:
print("yes")
else:
print("no")
| _ = int(input())
hoge = [int(x) for x in input().split()]
_ = int(input())
def exSearch(i, m):
if m == 0:
return True
if i >= len(hoge) or m > sum(hoge):
return False
res = exSearch(i+1, m) or exSearch(i+1, m-hoge[i])
return res
if __name__ == '__main__':
for val in (int(x) for x in input().split()):
if exSearch(0, val):
print ('yes')
else:
print ('no')
| 1 | 94,600,942,242 | null | 25 | 25 |
n,k = list(map(int,input().split()))
A = list(map(int,input().split()))
if k == 1:exit(print(A[0]))
t = 0
dp = [-1] * n
dp[0] = 0
flg = 0
for i in range(1,k+1):
t = A[t]-1
if dp[t] != -1:
flg = 1
break
dp[t] = i
if flg == 0:
exit(print(t+1))
elif k == 2:
exit(print(t+1))
l = i - dp[t]
K = (k-dp[t])%l + dp[t]
for i in range(n):
if dp[i] == K:exit(print(i+1))
| # 貪欲+山登り(2点交換+1点更新)
import time
import random
d = int(input())
dd = d * (d + 1) // 2
*C, = map(int, input().split())
S = [list(map(int, input().split())) for i in range(d)]
# 貪欲法による初期解の構築
T = []
L = [-1 for j in range(26)]
for i in range(d):
max_diff = -10**7
arg_max = 0
for j in range(26):
memo = L[j]
L[j] = i
diff = S[i][j] - sum([C[k] * (i - L[k]) for k in range(26)])
if diff > max_diff:
max_diff = diff
arg_max = j
L[j] = memo
T.append(arg_max)
L[arg_max] = i
def calc_score(T):
L = [-1 for j in range(26)]
X = [0 for j in range(26)]
score = 0
for i in range(d):
score += S[i][T[i]]
X[T[i]] += (d - i) * (i - L[T[i]])
L[T[i]] = i
for j in range(26):
score -= C[j] * (dd - X[j])
return score
score = calc_score(T)
start = time.time()
while True:
now = time.time()
if now - start > 1.8:
break
# 1点更新
i = random.choice(range(d))
j = random.choice(range(26))
memo = T[i]
T[i] = j
new_score = calc_score(T)
T[i] = memo
if new_score > score:
T[i] = j
score = new_score
# 2点交換
i0 = random.choice(range(d))
z = random.choice(range(10))
i1 = i0 - z if i0 > z else i0 + z
T[i0], T[i1] = T[i1], T[i0]
new_score = calc_score(T)
T[i0], T[i1] = T[i1], T[i0]
if new_score > score:
T[i0], T[i1] = T[i1], T[i0]
score = new_score
# 2点交換
i0 = random.choice(range(d))
z = random.choice(range(10))
i1 = i0 - z if i0 > z else i0 + z
T[i0], T[i1] = T[i1], T[i0]
new_score = calc_score(T)
T[i0], T[i1] = T[i1], T[i0]
if new_score > score:
T[i0], T[i1] = T[i1], T[i0]
score = new_score
for t in T:
print(t + 1)
| 0 | null | 16,284,579,039,260 | 150 | 113 |
from collections import defaultdict
def dfs(N, tree, v):
s = []
done = [False for _ in range(N)]
dist = [0 for _ in range(N)]
done[v] = True
dist[v] = 0
s.append(v)
while 0 < len(s):
v = s.pop()
# process
# print(v, tree[v], dist[v])
for i in tree[v]:
if not done[i]:
done[i] = True
dist[i] = dist[v] + 1
s.append(i)
return dist
def main():
N, u, v = map(int, input().split())
u -= 1
v -= 1
tree = defaultdict(list)
for _ in range(N - 1):
A, B = map(int, input().split())
A -= 1
B -= 1
tree[A].append(B)
tree[B].append(A)
u_dist = dfs(N, tree, u)
v_dist = dfs(N, tree, v)
# print(u_dist)
# print(v_dist)
ans = 0
for u1, v1 in zip(u_dist, v_dist):
if u1 < v1:
ans = max(ans, v1 - 1)
print(ans)
main()
| import sys
input = sys.stdin.readline
N,u,v=map(int,input().split())
E=[tuple(map(int,input().split())) for i in range(N-1)]
EDGE=[[] for i in range(N+1)]
for x,y in E:
EDGE[x].append(y)
EDGE[y].append(x)
from collections import deque
T=[-1]*(N+1)
Q=deque()
Q.append(u)
T[u]=0
while Q:
x=Q.pop()
for to in EDGE[x]:
if T[to]==-1:
T[to]=T[x]+1
Q.append(to)
A=[-1]*(N+1)
Q=deque()
Q.append(v)
A[v]=0
while Q:
x=Q.pop()
for to in EDGE[x]:
if A[to]==-1:
A[to]=A[x]+1
Q.append(to)
OK=[0]*(N+1)
for i in range(N+1):
if T[i]<A[i]:
OK[i]=1
ANS=0
for i in range(N+1):
if OK[i]==1:
ANS=max(ANS,A[i])
print(max(0,ANS-1)) | 1 | 117,559,940,344,392 | null | 259 | 259 |
#k = int(input())
#s = input()
#a, b = map(int, input().split())
#l = list(map(int, input().split()))
n = int(input())
a = list(map(int, input().split()))
ans = "APPROVED"
for i in range(n):
if (a[i] % 2 == 0):
if (a[i] % 3 == 0 or a[i] % 5 == 0):
pass
else:
ans = "DENIED"
break
print(ans)
| n = input()
x = int(n)
for i in range(3,x+1) :
if i%3 == 0 or '3' in str(i) :
print('',i,end='')
print()
| 0 | null | 34,881,591,797,040 | 217 | 52 |
h = int(input())
w = int(input())
n = int(input())
v = max(h,w)
cnt = (n-1)//v + 1
print(cnt) | h, w, n = map(int, [input() for _ in range(3)])
print((n-1)//max(h, w)+1) | 1 | 88,926,916,126,020 | null | 236 | 236 |
n = int(input())
L, R = [], []
for i in range(n):
a, b = 0, 0
for c in input():
if c == '(':
b += 1
if c == ')':
if b > 0:
b -= 1
else:
a += 1
if -a + b > 0:
L.append((a, b))
else:
R.append((a, b))
L.sort(key=lambda x: x[0])
R.sort(key=lambda x: x[1], reverse=True)
x = 0
for a, b in L + R:
x -= a
if x < 0:
print('No')
exit()
x += b
if x == 0:
print('Yes')
else:
print('No')
| #関数リスト
import sys
from copy import deepcopy
input = sys.stdin.readline
def RD(): return input().rstrip()
def I(): return int(input().rstrip())
def MI(): return map(int, input().split())
def MF(): return map(float,input().split())
def LI(): return list(map(int, input().split()))
def LF(): return list(map(float,input().split()))
def main():
d = [[]]*10
keta = I()
num = input().rstrip()
for i in range(keta):
temp = int(num[i])
if len(d[temp]) == 0:
d[temp] = [int(keta-i)]
else:
d[temp].append(int(keta-i))
result = 0
for j in range(1000):
a = j // 100
b = (j % 100) // 10
c = ((j % 100) % 10)
try:
a_num = d[a][0]
except:
continue
try:
if a == b:
b_num = d[b][1]
else:
index = 0
while True:
b_num = d[b][index]
if b_num < a_num:
break
else:
index += 1
except:
continue
try:
if a == c and a == b:
c_num = d[c][2]
elif a == c or b == c:
c_num = min(d[c][1:])
else:
c_num = min(d[c])
except:
continue
if a_num > b_num and b_num > c_num:
result += 1
print(result)
if __name__ == "__main__":
main() | 0 | null | 76,002,219,330,378 | 152 | 267 |
N = int(input())
P = list(map(int, input().split()))
temp = P[0]
res = 1
for i in range(1,N):
if P[i] <= temp:
temp = P[i]
res += 1
print(res) | (N,) = map(int, input().split())
As = list(enumerate(map(int, input().split())))
As.sort(key=lambda x: -x[1])
dp = [[0] * (N + 1) for _ in range(N + 1)]
for i, (pos, val) in enumerate(As):
for j in range(i + 1):
k = i - j
dp[j + 1][k] = max(dp[j + 1][k], dp[j][k] + abs(j - pos) * val)
dp[j][k + 1] = max(dp[j][k + 1], dp[j][k] + abs(N - 1 - k - pos) * val)
print(max(dp[i][N - i] for i in range(N + 1)))
| 0 | null | 59,744,791,575,670 | 233 | 171 |
charge, n_coin = map(int,input().split())
coin_ls = list(map(int, input().split()))
coin_ls = [0] + coin_ls
dp = [[float('inf')] * (charge+1) for _ in range(n_coin+1)]
dp[0][0] = 0
for coin_i in range(1,n_coin+1):
for now_charge in range(0,charge+1):
if now_charge - coin_ls[coin_i] >= 0:
dp[coin_i][now_charge] = min(dp[coin_i][now_charge], dp[coin_i][now_charge-coin_ls[coin_i]]+1)
dp[coin_i][now_charge] = min(dp[coin_i-1][now_charge], dp[coin_i][now_charge])
print(dp[n_coin][charge])
| suuretsu = [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]
number = int(input(''))
print(suuretsu[number - 1]) | 0 | null | 25,108,688,667,868 | 28 | 195 |
N = int(input())
count = {}
max_count = 0
for _ in range(N):
s = input()
if s not in count:
count[s] = 0
count[s] += 1
max_count = max(max_count, count[s])
longest = []
for s, c in count.items():
if c == max_count:
longest.append(s)
longest.sort()
for s in longest:
print(s) | setting = input().split();
package_count = int(setting[0]);
truck_count = int(setting[1]);
packages = [];
for i in range(package_count):
packages.append(int(input()));
def allocation():
max_p = sum(packages);
left = 0;
right = max_p;
while left < right:
mid = (left + right) // 2;
load = calculate_load(mid);
if load >= package_count:
right = mid;
else:
left = mid + 1;
return right;
def calculate_load(p):
i = 0;
j = 0;
current_truck_p = p;
while i < package_count and j < truck_count:
if packages[i] <= current_truck_p:
current_truck_p -= packages[i];
i += 1;
else:
j += 1;
current_truck_p = p;
return i;
print(allocation());
| 0 | null | 34,897,502,640,000 | 218 | 24 |
import sys
def MI(): return map(int,sys.stdin.readline().rstrip().split())
a,b,c = MI()
if c < a+b:
print('No')
else:
print('Yes' if 4*a*b < (c-a-b)**2 else 'No')
| import sys
input = sys.stdin.readline
n = int(input())
l=[[]]
nn = []
for _ in range(n+1):
l.append([])
for i in range(n-1):
a,b = map(int,input().split())
l[a].append(b)
l[b].append(a)
nn.append(b)
ml = list(map(len,l))
m = max(ml)
co = []
for i in range(n+1):
co.append( set(range(1,ml[i]+1) ))
col = [0]*(n+1)
col[1] = 1
for i in range(1,n+1):
for la in l[i]:
if col[la] ==0:
col[la] = co[i].pop()
co[la].discard(col[la])
print(m)
for i in range(n-1):
print(col[nn[i]])
| 0 | null | 93,989,059,742,890 | 197 | 272 |
a,b,c,d = map(int,input().split())
t_deth=(a+d-1)//d
a_deth=(c+b-1)//b
if t_deth>=a_deth:
print('Yes')
else:
print('No') | a,b,c,d=map(int,input().split())
while True:
c=c-b
if c<=0:
break
a=a-d
if a<=0:
break
if a>c:
print('Yes')
else:
print('No') | 1 | 29,621,802,281,628 | null | 164 | 164 |
n = int(input())
A = [int(i) for i in input().split()]
product = 1
A.sort()
for i in range(n):
product *= A[i]
if(product > 10**18):
print("-1")
break
if(product <= 10**18):
print(product) | def main():
N = int(input())
A = list(map(int,input().split()));
if 0 in A:
print(0)
return
prod = 1
for a in A:
prod *= a
if prod > 10**18:
print(-1)
return
print(prod)
main() | 1 | 16,201,270,680,930 | null | 134 | 134 |
def main():
N = int(input())
print(IsPrime(N))
def IsPrime(N):
count = 0
for i in range(N):
inputNum = int(input())
if(inputNum == 2):
count += 1
continue
elif(inputNum % 2 == 0):
continue
flag = 0
for j in range(3, int(pow(inputNum, 1/2))+1):
if(inputNum % j == 0):
flag = 1
break
else:
continue
if(flag == 0):
count += 1
return count
if __name__ == '__main__':
main() | n = int(input())
A=[int(i) for i in input().split()]
MOD = 1000000007
ans = 1
cnt = [0]*(n+1)
cnt[0]=3
for i in range(n):
ans = ans * cnt[A[i]] %MOD
cnt[A[i]]-=1
cnt[A[i]+1]+=1
if ans==0:
break
print(ans)
| 0 | null | 65,411,995,392,604 | 12 | 268 |
n = int(input())
t = 0
h = 0
for _ in range(n):
a_lst = input().rstrip().split(" ")
#print(a_lst)
b_lst = sorted(a_lst)
#print(b_lst)
if a_lst[0] == a_lst[1]:
t += 1
h += 1
elif a_lst == b_lst:
h += 3
else:
t += 3
print(t, h)
| A, B = 0, 0
num = int(input())
for i in range(num):
a, b = input().split()
if a < b:
B += 3
elif a > b:
A += 3
else:
A += 1
B += 1
print(A, B)
| 1 | 1,984,143,329,508 | null | 67 | 67 |
x = raw_input()
a, b = x.split()
a = int(a)
b = int(b)
#d
d = a / b
d = d
#r
r = a % b
#f
f = float(a) / float(b)
print("%d %d %.5f" %(d, r, f)) | 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()
L=[]
for i in range(N):
L.append([A[i],i])
L.sort()
ans=[]
for i in range(N):
ans.append(L[i][1]+1)
print(' '.join(map(str, ans)))
main()
| 0 | null | 90,565,583,990,368 | 45 | 299 |
a = list(map(int, input().split()))
x = 0
y = 0
for i in range(0,a[1]):
x = x + a[0]*(10**i)
for i in range(0,a[0]):
y = y + a[1]*(10**i)
if x<=y:
print(y)
else:
print(x) | N ,a, b = map(int,input().split())
MOD = pow(10,9) + 7
A = 1
for i in range(a):
A = A*(N-i)*pow(i+1,MOD-2,MOD)%MOD
B = 1
for i in range(b):
B = B*(N-i)*pow(i+1,MOD-2,MOD)%MOD
alll = pow(2,N,MOD) -1
#nota = cmb(N,a,MOD)
#notb = cmb(N,b,MOD)
ans = alll - (A+B)
ans = ans%MOD
print(ans) | 0 | null | 75,134,878,645,972 | 232 | 214 |
import math
n=int(input())
x=list(map(int,input().split()))
y=list(map(int,input().split()))
a=[1,2,3,4]
for i in a:
num=0
if i==1:
for j in range(len(x)):
num+=abs(x[j]-y[j])
print(num)
elif i==2 or i==3:
for j in range(len(x)):
num+=(abs(x[j]-y[j]))**i
num=math.pow(num,1/i)
print(num)
else:
b=[]
for j in range(len(x)):
b.append(abs(x[j]-y[j]))
print(float(max(b)))
| N=int(input())
item={"AC":0,"WA":0,"TLE":0,"RE":0}
for n in range(N):
S=input()
if S=="AC":
item["AC"]+=1
elif S=="WA":
item["WA"]+=1
elif S=="TLE":
item["TLE"]+=1
else:
item["RE"]+=1
print("AC x",end=" ")
print(item["AC"])
print("WA x",end=" ")
print(item["WA"])
print("TLE x",end=" ")
print(item["TLE"])
print("RE x",end=" ")
print(item["RE"])
| 0 | null | 4,490,885,743,998 | 32 | 109 |
import math
n = int(raw_input())
def isPrime(a):
if a==2 or a==3:
return 1
if a<2 or a%2==0:
return 0
i = int(math.sqrt(a))+1
for x in xrange(3,i):
if a%x==0:
return 0
return 1
cnt = 0
for _ in xrange(n):
a = int(raw_input())
cnt += isPrime(a)
print cnt | def is_prime(x):
if x == 1:
return False
l = x ** 0.5
n = 2
while n <= l:
if x % n == 0:
return False
n += 1
return True
import sys
def solve():
file_input = sys.stdin
N = file_input.readline()
cnt = 0
for l in file_input:
x = int(l)
if is_prime(x):
cnt += 1
print(cnt)
solve() | 1 | 10,313,996,798 | null | 12 | 12 |
import sys
X=int(input())
for A in range(800):
for B in range(-800,A+1):
if X==A**5-B**5:
print('{} {}'.format(A,B))
sys.exit() | s=list(map(str,input()))
if s[2]==s[3] and s[4]==s[5]:
print('Yes')
else:
print('No')
| 0 | null | 33,906,397,275,570 | 156 | 184 |
while(1):
n, x = map(int, input().split())
t = 0
if n == x == 0:
break
for i in range(1, n+1):
for j in range(i+1, n+1):
for k in range(j+1, n+1):
if i+j+k == x:
if i != j and j != k and k != i:
t += 1
#print(i, j, k)
print(t) |
while True:
n,x = map(int, input().split())
if n==0 and x==0:
break
ans=0
for i in range(1,n+1):
for j in range(i+1,n+1):
for k in range(j+1,n+1):
if i+j+k==x:
ans=ans+1
print(ans)
| 1 | 1,275,900,115,698 | null | 58 | 58 |
import math
a,b,c=(int(x) for x in input().split())
x=c-a-b
if x>0:
if x*x-4*a*b>0:
print('Yes')
else:
print('No')
else:
print('No')
| n = int(input())
a = list(map(int,input().split()))
s = sum(a)
x = 0
m = s
for i in range(n):
x += a[i]
m = min(m, abs(s-x*2))
print(m)
| 0 | null | 96,930,546,399,520 | 197 | 276 |
n,k=map(int,input().split())
a=list(map(int,input().split()))
a.sort()
mod=10**9+7
ans=1
i=0
j=-1
k_1=k
while k_1>1:
if a[i]*a[i+1]>a[j]*a[j-1]:
ans=ans*a[i]*a[i+1]%mod
i+=2
k_1-=2
else:
ans=ans*a[j]%mod
j-=1
k_1-=1
if k_1==1:
ans=ans*a[j]%mod
if a[-1]<0 and k%2==1:
ans=1
for i in a[n-k:]:
ans=ans*i%mod
print(ans)
| 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) | 0 | null | 4,727,250,835,730 | 112 | 14 |
A,V = map(int,input().split())
B,W = map(int,input().split())
T = int(input())
w = abs(A-B)
if w <= (V-W)*T:
print('YES')
else:
print('NO')
| a, v = map(int, input().split())
b, w = map(int, input().split())
t = int(input())
if a == b:
print('YES')
elif a < b:
if b + w * t <= a + v * t:
print('YES')
else:
print('NO')
else:
if a - v * t <= b - w * t:
print('YES')
else:
print('NO')
| 1 | 15,187,361,343,298 | null | 131 | 131 |
def main():
n = int(input())
points = [0, 0]
for i in range(n):
t, h = input().split(' ')
points = map(lambda x, y: x+y, points, judge(t, h))
print("{0[0]} {0[1]}".format(list(points)))
def judge(t, h):
if t < h:
return (0, 3)
elif t > h:
return (3, 0)
return (1, 1)
if __name__ == '__main__': main() | n=int(input())
a=0
b=0
while n!=0:
n=n//2
a+=2**b
b+=1
print(a) | 0 | null | 41,010,715,071,230 | 67 | 228 |
#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 bisect
#
# d = m - k[i] - k[j]
# if kk[bisect.bisect_right(kk,d) - 1] == d:
#
#
#
# pythonで無理なときは、pypyでやると正解するかも！！
#
#
import sys
sys.setrecursionlimit(10000000)
mod = 10**9 + 7
#mod = 9982443453
def readInts():
return list(map(int,input().split()))
def I():
return int(input())
S = input()
k = I()
from itertools import groupby
x = y = 0
g = [len(list(v)) for k,v in groupby(S)]
for c in g:
x += c//2
if S[-1] == S[0]:
if g[-1]%2 == 0 or g[0]%2 == 0:
pass
elif len(S) == 1:
y = k//2
elif len(S) == g[0]:
y = k//2
else:
y = k-1
print(x * k + y)
| import sys, math
while True:
n = int(input())
if n == 0:
sys.exit()
s = list(map(int, input().split()))
m = sum(s) / n
S = 0
for i in range(n):
S += (s[i] - m) ** 2
S /= n
a = math.sqrt(S)
print(a)
| 0 | null | 88,070,025,720,950 | 296 | 31 |
import sys
input = lambda: sys.stdin.readline().rstrip()
n=int(input())
s=0 ; st=set() ; ans=[[] for i in range(n)] ; v=0
def dfs(g,v):
global s,st,ans
if v in st: return
else: st.add(v)
s+=1
ans[v].append(s)
for i in g[v]:
dfs(g,i)
s+=1
ans[v].append(s)
g=[]
for _ in range(n):
a=[int(i)-1 for i in input().split()]
if a[1]==-1: g.append([])
else: g.append(a[2:])
for i in range(n):
if i in st : continue
else : dfs(g,i)
for i in range(len(ans)):
print(i+1,*ans[i])
| from collections import Counter
MOD = 998244353
N = int(input())
D = list(map(int, input().split()))
if D[0] != 0:
print(0)
exit()
C = sorted(Counter(D).most_common(), key=lambda x: x[0])
if C[0][1] > 1:
print(0)
exit()
ans = 1
for i in range(1, len(C)):
if C[i][0] - C[i-1][0] > 1:
print(0)
exit()
ans *= C[i - 1][1] ** C[i][1]
print(ans % MOD)
| 0 | null | 77,184,857,122,930 | 8 | 284 |
import itertools
N = int(input())
D = [int(x) for x in input().split()]
ans = 0
for v in itertools.combinations(D,2):
ans += v[0]*v[1]
print(ans)
| n=int(input())
A=input().split()
def findProductSum(A,n):
product = 0
for i in range (n):
for j in range ( i+1,n):
product = product + int(A[i])*int(A[j])
return product
print(findProductSum(A,n)) | 1 | 168,816,307,728,960 | null | 292 | 292 |
memo = {}
def fib(n):
"""
:param n: non-negative integer
:return: n-th fibonacci number
"""
if n == 0 or n == 1:
return 1
try:
return memo[n]
except KeyError:
pass
res = fib(n-1) + fib(n-2)
memo[n] = res
return res
n = int(input())
print(fib(n))
| n = int(input())
dp = [0 for _ in range(45)]
def fib_dp(n):
dp[0] = 1
dp[1] = 1
for i in range(2, n+1):
dp[i] = dp[i-1] + dp[i-2]
return dp[n]
print(fib_dp(n)) | 1 | 2,171,925,390 | null | 7 | 7 |
import sys
from collections import defaultdict
input = sys.stdin.readline
mod = 998244353
def extgcd(a,b):
r = [1,0,a]
w = [0,1,b]
while w[2] != 1:
q = r[2]//w[2]
r2 = w
w2 = [r[0]-q*w[0],r[1]-q*w[1],r[2]-q*w[2]]
r = r2
w = w2
return [w[0],w[1]]
def mod_inv(a,m):
x = extgcd(a,m)[0]
return ( m + x%m ) % m
def main():
n,s = map(int,input().split())
a = list(map(int, input().split()))
dp = [[0 for _ in range(s+1)] for _ in range(n+1)]
dp[0][0] = pow(2,n,mod)
MODINV2 = mod_inv(2,mod)
ans = 0
for i in range(n):
for j in range(s,-1,-1):
if j-a[i] < 0:
continue
dp[i+1][j] += dp[i][j-a[i]]*MODINV2
dp[i+1][j] %= mod
for j in range(s,-1,-1):
if j == s:
ans += dp[i+1][j]
ans %= mod
else:
dp[i+1][j] += dp[i][j]
dp[i+1][j] %= mod
print(ans)
if __name__ == "__main__":
main() | def main():
n, s = map(int, input().split())
a = list(map(int, input().split()))
mod = 998244353
dp = [[0]*(3001) for _ in range(n+1)]
dp[0][0] = 1
for i in range(1, n+1):
ai = a[i-1]
for j in range(ai):
dp[i][j] += dp[i-1][j]*2
dp[i][j] %= mod
for j in range(ai, 3001):
dp[i][j] += dp[i-1][j]*2 + dp[i-1][j-ai]
dp[i][j] %= mod
print(dp[n][s])
if __name__ == "__main__":
main() | 1 | 17,610,012,458,522 | null | 138 | 138 |
n, d = map(int, input().split())
x, y = zip(*[list(map(int, input().split())) for i in range(n)])
ans = 0
for i in range(n):
if x[i]**2 + y[i]**2 <= d**2:
ans += 1
print(ans) | X = int(input())
for i in range(1, 1000):
if 100 * i <= X and X <= 105 * i:
print(1)
exit()
print(0)
| 0 | null | 66,360,703,402,760 | 96 | 266 |
while True:
c=input()
if c=="-":
break
cards=list(c)
m=int(input())
for i in range(m):
h=int(input())
for i in range(h):
s=cards.pop(0)
cards+=s
print("".join(cards)) | 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)) | 1 | 1,909,037,001,600 | null | 66 | 66 |
import io
import os
from collections import defaultdict
DEBUG = False
if not DEBUG:
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
R, C, K = [int(x) for x in input().split()]
grid = [[0 for c in range(C)] for r in range(R)]
for r, c, v in ((int(x) for x in input().split()) for i in range(K)):
grid[r - 1][c - 1] = v
else:
import random
random.seed(0)
R, C = 3000, 3000
# 2 * 10**5 / 90 * 10**5 full
grid = [
[int(random.randint(1, 90) <= 2) * random.randint(0, 10 ** 9) for c in range(C)]
for r in range(R)
]
print(sum(bool(grid[r][c]) for r in range(R) for c in range(C)))
print("done gen")
from timeit import default_timer as timer
startTime = timer()
currRow = [[0 for i in range(3 + 1)] for c in range(C + 1)]
prevRow = [0 for c in range(C + 1)]
nextPrevRow = [0 for c in range(C + 1)]
inf = float("inf")
for r in range(R):
for c in range(C):
for numTakenThisRow in range(3 + 1):
best = max(
currRow[c - 1][numTakenThisRow], # came from left
prevRow[c], # came from top, didn't take curr
currRow[c - 1][numTakenThisRow - 1] + grid[r][c]
if numTakenThisRow
else 0, # came from left, took curr
prevRow[c] + grid[r][c]
if numTakenThisRow == 1
else 0, # came from top, took curr
)
currRow[c][numTakenThisRow] = best
nextPrevRow[c] = max(currRow[c][i] for i in range(3 + 1))
prevRow, nextPrevRow = nextPrevRow, prevRow
print(prevRow[C - 1])
if DEBUG:
print(timer() - startTime)
| s=str(input())
k=int(input())
ans=0
count=1
c1=0
c2=0
if len(set(s))==1:
print(len(s)*k//2)
exit()
if s[0]==s[-1]:
for i in range(len(s)-1):
if s[i]==s[i+1]:
count+=1
else:
if 2<=count:
ans+=count//2
count=1
ans+=count//2
i=0
while s[i]==s[0]:
c1+=1
i+=1
i=len(s)-1
while s[i]==s[-1]:
c2+=1
i-=1
#print(c1,c2)
ans*=k
if c1%2==1 and c2%2==1:
ans+=k-1
print(ans)
else:
for i in range(len(s)-1):
if s[i]==s[i+1]:
count+=1
else:
if 2<=count:
ans+=count//2
count=1
ans+=count//2
print(ans*k) | 0 | null | 90,771,283,398,398 | 94 | 296 |
a, b = map(int, input().split())
s=int(a)*int(b)
t=(int(a)+int(b))*2
print(s, t)
| from decimal import Decimal
a,b,c = map(int,input().split())
a = Decimal(a) ** Decimal(0.5)
b = Decimal(b) ** Decimal(0.5)
c = Decimal(c) ** Decimal(0.5)
if Decimal(a) + Decimal(b) < Decimal(c):
print('Yes')
else:
print('No') | 0 | null | 25,889,866,556,522 | 36 | 197 |
n = int(input())
tscore = 0
hscore = 0
for i in range(n):
wlist = []
t,h = map(str, input().split())
wlist.append(t)
wlist.append(h)
order = sorted(wlist, key = str.lower)
if (t.lower() == h.lower()):
tscore += 1
hscore += 1
elif (order[1] == t):
tscore += 3
elif (order[1] ==h ):
hscore += 3
print(tscore, hscore)
| def cardgame(animal1, animal2, taro, hanako):
if animal1==animal2:
return [taro+1, hanako+1]
anim_list = sorted([animal1, animal2])
if anim_list[0]==animal1:
return [taro, hanako+3]
else:
return [taro+3, hanako]
n = int(input())
taro, hanako = 0, 0
for i in range(n):
data = input().split()
result = cardgame(data[0], data[1], taro, hanako)
taro, hanako = result[0], result[1]
print(taro, end=" ")
print(hanako)
| 1 | 1,994,742,994,108 | null | 67 | 67 |
n,k = map(int,input().split())
a = abs(n-k*(n//k))
b = abs(n-k*(-(-n//k)))
print(min(a,b)) | def repint(n, k):
if n % k == 0:
return 0
res = abs((n % k) - k)
if (n % k) > res:
return res
return (n % k)
n, k = map(int, input().split())
print(repint(n, k)) | 1 | 39,062,790,862,348 | null | 180 | 180 |
from fractions import Fraction
import sys
def input():
return sys.stdin.readline().rstrip('\n')
ZERO = Fraction(0, 1)
Z = 1000000007
class Pow:
def __init__(self, n):
self.N = n
self.e = [1] * (n + 1)
for i in range(n):
self.e[i + 1] = (self.e[i] * 2) % Z
def get(self, n):
if self.N >= n:
return self.e[n]
else:
for i in range(self.N + 1, n + 1):
self.e += [(self.e[i] * 2) % Z]
return self.e[n]
def calc(N, G):
zz = 0
r = {}
r_max = 0
for a, b in G:
if b == 0:
if a == 0:
zz += 1
else:
if 0 in r:
r[0][1][1] += 1
else:
r[0] = {1: [0, 1]}
r_max = max(r_max, r[0][1][1])
else:
if a == 0:
if 0 in r:
r[0][1][0] += 1
else:
r[0] = {1: [1, 0]}
r_max = max(r_max, r[0][1][0])
else:
f = Fraction(a, b)
if f > 0:
i = f.numerator
j = f.denominator
if i in r:
if j in r[i]:
r[i][j][0] += 1
else:
r[i][j] = [1, 0]
else:
r[i] = {j: [1, 0]}
r_max = max(r_max, r[i][j][0])
else:
i = f.denominator
j = -f.numerator
if i in r:
if j in r[i]:
r[i][j][1] += 1
else:
r[i][j] = [0, 1]
else:
r[i] = {j: [0, 1]}
r_max = max(r_max, r[i][j][1])
ans = 1
pow = Pow(r_max)
for i in r:
for j in r[i]:
ans = (ans * (pow.get(r[i][j][0]) + pow.get(r[i][j][1]) - 1)) % Z
return (ans + zz - 1) % Z
N = int(input())
G = [tuple([int(s) for s in input().split()]) for _ in range(N)]
print(calc(N, G)) | import math
def main():
N = int(input())
d = {}
zb = 0
za = 0
zab = 0
r = 0
mod = 10**9 + 7
for i in range(N):
a, b = map(int, input().split())
if a== 0 and b == 0:
zab += 1
elif b == 0:
zb += 1
elif a == 0:
za += 1
else:
if a < 0:
a = -a
b = -b
x = math.gcd(abs(a), abs(b))
if (a//x, b//x) in d:
d[(a//x, b//x)] += 1
else:
d[(a//x, b//x)] = 1
used = set()
l = []
for x in d:
if x in used:
continue
a, b = x[0], x[1]
used.add(x)
if a * b > 0:
t = (abs(b), -abs(a))
if t in d:
used.add(t)
l.append((d[x], d[t]))
else:
l.append((d[x], 0))
else:
t = (abs(b), abs(a))
if t in d:
used.add(t)
l.append((d[x], d[t]))
else:
l.append((d[x], 0))
r = pow(2, za) + pow(2, zb) - 1
for i in l:
r *= (pow(2, i[0]) + pow(2, i[1]) - 1)
r %= mod
return (r - 1 + zab) % mod
print(main())
| 1 | 21,077,499,912,092 | null | 146 | 146 |
n = int(input())
a = [n]
if n != 2:
a.append(n - 1)
def div_(N, k):
while N % k == 0:
N /= k
if N % k == 1:
a.append(k)
for k in range(2, int(n ** 0.5) + 1):
if n % k == 0:
div_(n,k)
if k != n / k:
div_(n, n // k)
if (n - 1) % k == 0:
a.append(k)
if k != (n - 1) / k:
a.append((n - 1) // k)
print(len(a)) | n = int(input())
a = list(map(int, input().split()))
a.sort()
def main(a):
if 0 in a:
ans = 0
else:
ans = 1
for item in a:
ans *= item
if ans > 1000000000000000000:
ans = -1
break
return ans
ans = main(a)
print(ans)
| 0 | null | 28,637,671,056,498 | 183 | 134 |
N = int(input())
A = list(map(int, input().split()))
DP_odd = [0, 0, A[0]]
DP_even = [0, max(A[0], A[1])]
if N >= 3:
DP_odd = [DP_even[0], max(DP_odd[1] + A[2], DP_even[1]), DP_odd[2] + A[2]]
for i in range(3, N):
if (i + 1) % 2 == 1:
DP_odd = [max(DP_odd[0] + A[i], DP_even[0]), max(DP_odd[1] + A[i], DP_even[1]), DP_odd[2] + A[i]]
else:
DP_even = [max(DP_even[0] + A[i], DP_odd[1]), max(DP_even[1] + A[i], DP_odd[2])]
if N % 2 == 1:
ans = DP_odd[1]
else:
ans = DP_even[1]
print(ans) | n=int(input())
a=list(map(int,input().split()))
if n%2==0:
dp=[[0 for i in range(2)] for j in range(n)]
dp[0][0]=a[0]
dp[1][1]=a[1]
for i in range(2,n):
if i==2:
dp[i][0]=dp[i-2][0]+a[i]
dp[i][1]=dp[i-2][1]+a[i]
else:
dp[i][0]=dp[i-2][0]+a[i]
dp[i][1]=max(dp[i-2][1],dp[i-3][0])+a[i]
print(max(dp[n-1][1],dp[n-2][0]))
else:
dp=[[0 for i in range(3)] for j in range(n)]
dp[0][0]=a[0]
dp[1][1]=a[1]
dp[2][2]=a[2]
for i in range(2,n):
if i==2:
dp[i][0]=dp[i-2][0]+a[i]
dp[i][1]=dp[i-2][1]+a[i]
else:
dp[i][0]=dp[i-2][0]+a[i]
dp[i][1]=max(dp[i-2][1],dp[i-3][0])+a[i]
dp[i][2]=max(dp[i-2][2],dp[i-3][1],dp[i-4][0])+a[i]
print(max(dp[n-1][2],dp[n-2][1],dp[n-3][0])) | 1 | 37,536,342,096,100 | null | 177 | 177 |
N, K = list(map(int, input().split()))
H = list(map(int, input().split()))
H = sorted(H, reverse=True)
for i in range(min(K,len(H))):
H[i] = 0
print(sum(H)) | n, r = map(int, input().split())
print(r + 100 * max(10 - n, 0))
| 0 | null | 71,154,566,870,702 | 227 | 211 |
def draft(A, K, N):
for _ in range(1, K+1):# 2 * 10**5
tmp = [0]*(N+1)
for i in range(N):# 2 * 10**5
L = max(0, i - A[i])
R = min(N, i + A[i]+1)
tmp[L] += 1
tmp[R] -= 1
f = True
for i in range(N):
tmp[i+1] += tmp[i]
A[i] = tmp[i]
if A[i] != N:
f = False
if f:
break
for i in range(N):
print(A[i], end=" ")
def main():
N, K = map(int, input().split())
A = list(map(int, input().split()))
draft(A, K, N)
if __name__ == "__main__":
main()
| class Dice(object):
def __init__(self,List):
self.face=List
def n_spin(self,List):
temp=List[0]
List[0]=List[1]
List[1]=List[5]
List[5]=List[4]
List[4]=temp
def s_spin(self,List):
temp=List[0]
List[0]=List[4]
List[4]=List[5]
List[5]=List[1]
List[1]=temp
def e_spin(self,List):
temp=List[0]
List[0]=List[3]
List[3]=List[5]
List[5]=List[2]
List[2]=temp
def w_spin(self,List):
temp=List[0]
List[0]=List[2]
List[2]=List[5]
List[5]=List[3]
List[3]=temp
dice = Dice(map(int,raw_input().split()))
command = list(raw_input())
for k in command:
if k=='N':
dice.n_spin(dice.face)
elif k=='S':
dice.s_spin(dice.face)
elif k=='E':
dice.e_spin(dice.face)
else:
dice.w_spin(dice.face)
print dice.face[0] | 0 | null | 7,790,900,947,664 | 132 | 33 |
n, d, a = map(int, input().split())
xh = []
for _ in range(n):
x, h = map(int, input().split())
h = (h - 1) // a + 1
xh.append([x, h])
xh.sort()
damage = xh[0][1]
ans = damage
damage_lst = [[xh[0][0] + d * 2, damage]]
pos = 0
for i, (x, h) in enumerate(xh[1:], start = 1):
while x > damage_lst[pos][0]:
damage -= damage_lst[pos][1]
pos += 1
if pos == i:
break
damage_tmp = max(h - damage, 0)
ans += damage_tmp
damage += damage_tmp
damage_lst.append([x + d * 2, damage_tmp])
print(ans) |
if __name__ == "__main__":
n = int(input())
nums = [int(s) for s in input().split()]
odds = [0]
for num in nums[::2]:
odds.append(num + odds[-1])
res = [0]
for i, num in enumerate(nums[1::2]):
res.append(max(res[-1]+num, odds[i+1]))
if n % 2 == 0:
print(res[-1])
else:
ans = float('-inf')
for i, r in enumerate(res):
ans = max(ans, res[i] + odds[-1] - odds[i+1])
print(ans)
| 0 | null | 59,650,050,719,520 | 230 | 177 |
# 入出力から得点を計算する
import sys
input = lambda: sys.stdin.readline().rstrip()
D = int(input())
c = list(map(int, input().split()))
s = [[int(i) for i in input().split()] for _ in range(D)]
t = []
for i in range(D):
tmp = int(input())
t.append(tmp)
# 得点
result = 0
# 最後に開催された日を保存しておく
last_day = [0 for _ in range(26)]
for i in range(len(t)):
# 選んだコンテスト
choose = t[i] - 1
# 最終開催日を更新
last_day[choose] = i + 1
# そのコンテストを選んだ時の本来のポイント
result += s[i][choose]
# そこから満足度低下分をマイナス
for j in range(26):
result -= c[j] * ((i+1) - last_day[j])
# result += tmp_point
print(result)
# print(c,s,t)
| D = int(input())
C = list(map(int, input().split()))
S = [list(map(int, input().split())) for _ in range(D)]
T = [int(input()) for _ in range(D)]
v = 0
last = [0] * 26
for d in range(D):
# ct:current type
ct= T[d] - 1
last[ct] = d + 1
# 今回の満足度
v += S[d][ct]
# 不満度を引く
v -= sum([C[t] * (d + 1 - last[t]) for t in range(26)])
print(v) | 1 | 9,929,623,637,088 | null | 114 | 114 |
A, B = map(int, input().split())
ans = A*B
if A > 9 or B > 9:
ans = -1
print(ans) | (A,B)=input().split()
(A,B)=(int(A),int(B))
if 1<=A<=9 and 1<=B<=9:
print(A*B)
else:
print(-1) | 1 | 157,697,711,505,290 | null | 286 | 286 |
# pythonの場合、ライブラリ関数でgcdがある？ただし、配列まとめてというわけではない模様
from math import gcd
def main():
N = int(input())
A = list(map(int,input().split()))
pc = True
maxA = max(A)
cnts = [ 0 for _ in range(maxA+1) ]
for a in A:
cnts[a] += 1
for i in range(2,maxA):
if pc:
# 素因数ごとに、A内での登場回数を数える
# 2つあったらその2つのcommon dividerとして、1以外にそれがあることが確定する
cnt = 0
for j in range(i,maxA+1,i):
cnt += cnts[j]
if 1 < cnt:
# Aの素因数で重複があれば、pcでない
pc = False
break
sc = False
if pc == False:
gcdResult = 0
for a in A:
# 配列全要素に対してgcdを呼んでるが、結果的に、それが1になればsc、ならなければnot sc
gcdResult=gcd(gcdResult,a)
if gcdResult == 1:
sc = True
if pc:
print("pairwise coprime")
elif sc:
print("setwise coprime")
else:
print("not coprime")
if __name__ == "__main__":
main()
| A,B,C,D=map(int,input().split())
while 1:
C=C-B
if C<=0:
print("Yes")
break
A=A-D
if A<=0:
print("No")
break | 0 | null | 16,832,056,271,680 | 85 | 164 |
N = int(raw_input())
A = raw_input().split(" ")
count = 0
flag = 1
i = 0
while flag == 1:
flag = 0
for j in reversed(range(i+1, N)):
if int(A[j]) < int(A[j-1]):
temp = A[j]
A[j] = A[j-1]
A[j-1] = temp
count += 1
flag = 1
i += 1
print " ".join(A)
print count | n = int(input())
li = list(map(int, input().split()))
cnt = 0
flag = True
while flag:
flag = False
for i in range(n-1,0,-1):
if li[i] < li[i-1]:
li[i], li[i-1] = li[i-1], li[i]
flag = True
cnt +=1
print(*li)
print(cnt) | 1 | 17,018,292,368 | null | 14 | 14 |
# coding: utf-8
# Your code here!
[n,x,t] = input().split()
n = int(n)
x = int(x)
t = int(t)
i = 1
while True:
if i*x >= n:
break
i += 1
print(i*t) | n, k = [int(x) for x in input().split()]
a_list = [int(x) for x in input().split()]
a_list.sort()
mod = 10 ** 9 + 7
temp_list = [1] * (n + 1)
for i in range(1, n + 1):
temp_list[i] = i * temp_list[i - 1] % mod
i_temp_list = [1] * (n + 1)
i_temp_list[-1] = pow(temp_list[-1], mod - 2, mod)
for i in range(n, 0, -1):
i_temp_list[i - 1] = i_temp_list[i] * i % mod
y = k - 1
ans = 0
for i in range(k - 1, n):
x = i
num = temp_list[x] * i_temp_list[y] * i_temp_list[x - y] % mod
ans += a_list[i] * num % mod
for i in range(n - k + 1):
x = n - 1 - i
num = temp_list[x] * i_temp_list[y] * i_temp_list[x - y] % mod
ans -= a_list[i] * num % mod
ans %= mod
print(ans) | 0 | null | 50,157,889,365,612 | 86 | 242 |
import math
while 1:
n = input()
if n == 0:
break
x = map(float,raw_input().split())
m = float(sum(x)/n)
s = 0
for i in x:
s += (i-m) ** 2
print math.sqrt(s/n) | n = int(input().rstrip())
num_list = [int(x) for x in input().rstrip().split(" ")]
count = 0
for i in range(0,n,2):
count += num_list[i]%2!=0
print(count) | 0 | null | 3,983,727,961,850 | 31 | 105 |
from collections import deque
N = int(input())
# 有向グラフと見る、G[親] = [子1, 子2, ...]
G = [[] for _ in range(N + 1)]
# 子ノードを記録、これで辺の番号を管理
G_order = []
# a<bが保証されている、aを親、bを子とする
for i in range(N - 1):
a, b = map(lambda x: int(x) - 1, input().split())
G[a].append(b)
G_order.append(b)
# どこでも良いが、ここでは0をrootとする
que = deque([0])
# 各頂点と「親」を結ぶ辺の色
# 頂点0をrootとするのでC[0]=0で確定(「無色」), 他を調べる
colors = [0] * N
# BFS
while que:
# prt = 親
# 幅優先探索
prt = que.popleft()
color = 0
# cld = 子
for cld in G[prt]:
color += 1
# 「今考えている頂点とその親を結ぶ辺の色」と同じ色は使えないので次の色にする
if color == colors[prt]:
color += 1
colors[cld] = color
que.append(cld)
# それぞれの頂点とその親を結ぶ辺の色
# print(colors)
# 必要な最小の色数
print(max(colors))
# 辺の番号順に色を出力
for i in G_order:
print(colors[i])
| n = int(input())
S = list(map(int, input().split()))
q = int(input())
T = list(map(int, input().split()))
C = []
for s in S:
for t in T:
if s == t and not s in C: C.append(s)
print(len(C)) | 0 | null | 68,360,806,037,660 | 272 | 22 |
def solve():
R, C, K = map(int, input().split())
item = [[0]*C for _ in range(R)]
for i in range(K):
r,c,v = map(int, input().split())
item[r-1][c-1] = v
last_dp = [[0]*(C+1) for _ in range(5)]
for i in range(1,R+1):
dp = [[0]*(C+1) for _ in range(5)]
for j in range(1,C+1):
for k in range(4): #横から取らない
dp[k][j] = dp[k][j-1]
#上から取らない
dp[0][j] = max(dp[0][j],last_dp[-1][j])
if item[i-1][j-1]>0:
#上からとる
dp[1][j] = max(dp[1][j],last_dp[-1][j]+item[i-1][j-1])
for k in range(1,4): #横から取る
dp[k][j] = max(dp[k][j],dp[k-1][j-1]+item[i-1][j-1])
for k in range(4):
dp[-1][j] = max(dp[-1][j],dp[k][j])
last_dp = dp
ans = last_dp[-1][-1]
return ans
print(solve()) | 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():
#各行では連続した区間
#行ごとに見ないと話が進まん，降りるタイミぐは各列高々3000こ，来るタイミングも同様
mod=10**9+7
R,C,K=MI()
S=[[0]*(C+1) for _ in range(R+1)]
for i in range(K):
r,c,v=MI()
S[r][c]=v
dp1=[[0]*(C+1)for _ in range(R+1)]
dp2=[[0]*(C+1)for _ in range(R+1)]
dp3=[[0]*(C+1)for _ in range(R+1)]
# dp[i][j][k]はi行j列まで見てその行でk個以下
for i in range(R+1):
for j in range(C+1):
#S(i,j)からの移動を考える
#右へ移動，-,拾わない，拾う
if j+1<=C:
dp1[i][j+1]=max(dp1[i][j+1],dp1[i][j],S[i][j+1])
dp2[i][j+1]=max(dp2[i][j+1],dp2[i][j],dp1[i][j]+S[i][j+1])
dp3[i][j+1]=max(dp3[i][j+1],dp3[i][j],dp2[i][j]+S[i][j+1])
#下へ
if i+1<=R:
temp=max(dp1[i][j],dp2[i][j],dp3[i][j])
dp1[i+1][j]=temp+S[i+1][j]
ans=max(dp1[-1][-1],dp2[-1][-1],dp3[-1][-1])
# for i in range(R+1):
# print(dp[i])
print(ans)
main()
| 1 | 5,523,372,181,340 | null | 94 | 94 |
import sys
import bisect
input = sys.stdin.readline
n, d, a = map(int, input().split())
xh = sorted([tuple(map(int, input().split()))for _ in range(n)])
x_list = [x for x, h in xh]
damage = [0]*(n+1)
ans = 0
for i in range(n):
x, h = xh[i]
h -= damage[i]
if h <= 0:
damage[i+1] += damage[i]
continue
cnt = -(-h//a)
ans += cnt
damage[i] += cnt*a
end_idx = bisect.bisect_right(x_list, x+2*d)
damage[end_idx] -= cnt*a
damage[i+1] += damage[i]
print(ans) | import math
import bisect
n,d,a = map(int,input().split())
x = [0]*n
h = [0]*n
for i in range(n):
x[i] , h[i] = map(int, input().split())
itv = [[0 for i in range(2)] for j in range(n)]
for i in range(n):
itv[i][0] = x[i]
itv[i][1] = h[i]
itv.sort()
ans = 0
x.sort()
x.append(1145141919810)
h.append(0)
imos = [0]*(n+1)
atk = math.ceil(itv[0][1]/a)
imos[0] += atk * a
b = bisect.bisect(x,itv[0][0] + (2*d))
imos[b] -= atk * a
ans += atk
for i in range(1,n):
atk = 0
imos[i] += imos[i-1]
if itv[i][1] > imos[i]:
atk = math.ceil((itv[i][1]-imos[i])/a)
imos[i] += atk * a
b = bisect.bisect(x,itv[i][0] + (2*d))
imos[b] -= atk * a
ans += atk
print(ans) | 1 | 81,834,905,770,942 | null | 230 | 230 |
def abc177_e():
n = int(input())
A = [int(x) for x in input().split()]
def prime_factorize(n:int)->set:
''' nの素因数分解 '''
arr = []
while n % 2 == 0:
arr.append(2)
n = n // 2
f = 3
while f*f <= n:
if n%f == 0:
arr.append(f)
n = n // f
else:
f += 2
if n != 1:
arr.append(n)
return set(arr)
import math
gcd_all = A[0]
factors = [0]*(10**6 + 1)
pairwise = True
for ai in A:
gcd_all = math.gcd(gcd_all, ai)
for p in prime_factorize(ai):
if factors[p]: pairwise = False
factors[p] = 1
if pairwise: ans = 'pairwise coprime'
elif gcd_all == 1: ans = 'setwise coprime'
else: ans = 'not coprime'
print(ans)
if __name__ == '__main__':
abc177_e() | import math
INF=float('inf')
ans1='pairwise coprime'
ans2='setwise coprime'
ans3='not coprime'
n=int(input())
A=list(map(int,input().split()))
P=[0]*(10**6+1)
for i in A:
P[i]+=1
pairwise=True
for i in range(2,10**6+1):
cnt=0
for j in range(i,10**6+1,i):
cnt+=P[j]
if cnt>1:
pairwise=False
break
if pairwise:
print(ans1)
exit()
g=math.gcd(A[0],A[1])
for i in A:
g=math.gcd(g,i)
if g==1:
print(ans2)
else:
print(ans3) | 1 | 4,090,055,286,372 | null | 85 | 85 |
def bfs(x0, y0, maze, dis):
from collections import deque
max_x = len(maze[0])
max_y = len(maze)
dis[y0][x0] = 0
dxy = [[-1, 0], [1, 0], [0, -1], [0, 1]]
q = deque()
q.append([x0, y0, dis[y0][x0]])
while len(q) > 0:
x, y, d = q.popleft()
for dx, dy in dxy:
nx = x + dx
ny = y + dy
if 0 > nx or max_x <= nx or 0 > ny or max_y <= ny:
continue
if maze[ny][nx] == "#":
continue
if dis[ny][nx] != -1:
continue
dis[ny][nx] = d + 1
q.append([nx, ny, dis[ny][nx]])
return
h, w = map(int, input().split())
s = [[] for _ in range(h)]
for i in range(h):
s[i] = input()
ans = 0
for i in range(h):
for j in range(w):
dis = [[-1] * w for _ in range(h)]
if s[i][j] != "#":
bfs(j, i, s, dis)
d = 0
for k in range(h):
for l in range(w):
d = max(d, dis[k][l])
ans = max(ans, d)
print(ans) | # import sys
# sys.setrecursionlimit(10 ** 6)
# import bisect
from collections import deque
# from decorator import stop_watch
#
#
# @stop_watch
def solve(H, W, Ss):
Ss = ['#' + S + '#' for S in Ss]
Ss = ['#' * (W + 2)] + Ss + ['#' * (W + 2)]
# for S in Ss:
# print(S)
ans = 0
for i in range(1, H + 1):
for j in range(1, W + 1):
if Ss[i][j] == '#':
continue
visited = [[-1] * (W + 2) for _ in range(H + 2)]
now = 0
visited[i][j] = now
q = deque([(i, j, now)])
while q:
x, y, n = q.popleft()
# for v in visited:
# print(v)
# input()
if Ss[x + 1][y] == '.' \
and visited[x + 1][y] < 0:
q.append((x + 1, y, n + 1))
visited[x + 1][y] = n + 1
if Ss[x - 1][y] == '.' \
and visited[x - 1][y] < 0:
q.append((x - 1, y, n + 1))
visited[x - 1][y] = n + 1
if Ss[x][y + 1] == '.' \
and visited[x][y + 1] < 0:
q.append((x, y + 1, n + 1))
visited[x][y + 1] = n + 1
if Ss[x][y - 1] == '.' \
and visited[x][y - 1] < 0:
q.append((x, y - 1, n + 1))
visited[x][y - 1] = n + 1
ans = max(ans, max([max(v) for v in visited]))
print(ans)
if __name__ == '__main__':
H, W = map(int, input().split())
Ss = [input() for _ in range(H)]
solve(H, W, Ss)
| 1 | 94,809,084,979,432 | null | 241 | 241 |
def cub():
x = input()
print x ** 3
cub() | i = int(raw_input())
print i**3 | 1 | 280,921,626,848 | null | 35 | 35 |
#
import sys
import math
import numpy as np
import itertools
n = int(input())
# n行の複数列ある数値をそれぞれの配列へ
a, b = [0]*n, [0]*n
for i in range(n): a[i], b[i] = map(int, input().split())
#print(a,b)
a.sort()
b.sort()
if n % 2 == 0:
t = a[n//2-1] + a[n//2]
s = b[n//2-1] + b[n//2]
print(s-t+1)
else:
t = a[n//2]
s = b[n//2]
print(s-t+1)
| N = int(input())
C1 = list(input().split())
C2 = C1[:]
def get_card_suit(card):
return card[:1]
def get_card_value(card):
return card[1:]
def bubble_sort(card):
r_exists = True
while r_exists == True:
r_exists = False
i = N - 1
while i >= 1:
if get_card_value(card[i]) < get_card_value(card[i - 1]):
card[i], card[i - 1] = card[i - 1], card[i]
r_exists = True
i -= 1
def select_sort(card):
i = 0
while i < N:
min_j = i
j = i
while j < N:
if get_card_value(card[j]) < get_card_value(card[min_j]):
min_j = j
j += 1
card[i], card[min_j] = card[min_j], card[i]
i += 1
def output(card):
s = ''
for x in card:
s = s + str(x) + ' '
print(s.rstrip())
def is_stable():
i = 0
while i < N:
if get_card_suit(C1[i]) != get_card_suit(C2[i]):
return False
i += 1
return True
bubble_sort(C1)
select_sort(C2)
output(C1)
print('Stable')
output(C2)
if is_stable() == True:
print('Stable')
else:
print('Not stable')
| 0 | null | 8,675,663,744,288 | 137 | 16 |
import bisect
import math
N, D, A = map(int, input().split())
cusum = [0] * (N+1)
X = []
XH =[]
for i in range(N):
xi, hi = map(int, input().split())
X += [xi]
XH += [(xi, hi)]
X = sorted(X)
XH = sorted(XH)
cusumD = 0
ans = 0
for i, (xi, hi) in enumerate(XH):
cusumD -= cusum[i]
hi = max(0, hi-cusumD)
r = bisect.bisect_right(X, xi+2*D)
b = int(math.ceil(hi/A))
d = b * A
ans += b
cusumD += d
cusum[r] += d
print(ans)
| r, c = [int(s) for s in input().split()]
rows = [[0 for i in range(c + 1)] for j in range(r + 1)]
for rc in range(r):
in_row = [int(s) for s in input().split()]
for cc, val in enumerate(in_row):
rows[rc][cc] = val
rows[rc][-1] += val
rows[-1][cc] += val
rows[-1][-1] += val
for row in rows:
print(' '.join([str(i) for i in row])) | 0 | null | 41,910,035,392,292 | 230 | 59 |
s=input()
print("YNeos"[s == len(s) * s[0]::2]) | S=input()
if S.count('A')==1 or S.count('A')==2:
print('Yes')
else:
print('No') | 1 | 54,705,380,716,480 | null | 201 | 201 |
class Dice(object):
def __init__(self, num):
self.num = num
def rotate_S(self):
self.num = [self.num[4], self.num[0], self.num[2], self.num[3], self.num[5], self.num[1]]
def rotate_N(self):
self.num = [self.num[1], self.num[5], self.num[2], self.num[3], self.num[0], self.num[4]]
def rotate_W(self):
self.num = [self.num[2], self.num[1], self.num[5], self.num[0], self.num[4], self.num[3]]
def rotate_E(self):
self.num = [self.num[3], self.num[1], self.num[0], self.num[5], self.num[4], self.num[2]]
def get_right_num(self, a, b):
top_index = self.num.index(a) + 1
front_index = self.num.index(b) + 1
if [top_index, front_index] in [[2, 3], [3, 5], [5, 4], [4, 2]]:
return self.num[0]
elif [top_index, front_index] in [[1, 4], [4, 6], [6, 3], [3, 1]]:
return self.num[1]
elif [top_index, front_index] in [[1, 2], [2, 6], [6, 5], [5, 1]]:
return self.num[2]
elif [top_index, front_index] in [[1, 5], [5, 6], [6, 2], [2, 1]]:
return self.num[3]
elif [top_index, front_index] in [[1, 3], [3, 6], [6, 4], [4, 1]]:
return self.num[4]
elif [top_index, front_index] in [[2, 4], [4, 5], [5, 3], [3, 2]]:
return self.num[5]
dice = Dice(map(int, raw_input().split()))
Q = input()
for q in range(Q):
num_set = map(int, raw_input().split())
print dice.get_right_num(num_set[0], num_set[1]) | from sys import stdin
nii=lambda:map(int,stdin.readline().split())
lnii=lambda:list(map(int,stdin.readline().split()))
x,y,a,b,c=nii()
p=sorted(lnii(),reverse=True)
q=sorted(lnii(),reverse=True)
r=sorted(lnii(),reverse=True)
l=p[:x]+q[:y]
l.sort()
ans=0
for i in range(x+y):
if i<c:
ans+=max(l[i],r[i])
else:
ans+=l[i]
print(ans) | 0 | null | 22,608,524,596,870 | 34 | 188 |
K = int(input())
k = K - 1
numbers = {
0: 1
}
while k > 0:
k -= 1
for i in range(len(numbers)):
n = numbers[i]
if n == 9:
continue
if abs(numbers.get(i - 1, n) - (n + 1)) <= 1 and abs(numbers.get(i + 1, n) - (n + 1)) <= 1:
numbers[i] += 1
j = i - 1
while j >= 0:
numbers[j] = max(numbers[j + 1] - 1, 0)
j -= 1
break
else:
for key in numbers.keys():
numbers[key] = 0
numbers[len(numbers)] = 1
print(''.join([str(numbers[i]) for i in range(len(numbers))])[::-1])
| def main():
from collections import deque
K = int(input())
if K <= 9:
print(K)
return
q = deque()
for i in range(1, 10):
q.append(i)
count = 9
while True:
get_num = q.popleft()
for i in range(-1, 2):
add_num = get_num % 10 + i
if 0 <= add_num and add_num <= 9:
q.append(get_num * 10 + add_num)
count += 1
if count == K:
print(q.pop())
return
if __name__ == '__main__':
main() | 1 | 39,749,968,697,450 | null | 181 | 181 |
import sys
def gcd(a, b):
while b:
a, b = b, a%b
return a
# print(gcd(54, 20))
# print(gcd(147, 105))
input = sys.stdin.readline()
input = input.split(" ")
input = [int(i) for i in input]
print(gcd(input[0], input[1])) | import math
a=100
for _ in[0]*int(input()):a=math.ceil(a*1.05)
print(a*1000)
| 0 | null | 4,530,384,672 | 11 | 6 |
import math
s = input()
n = len(s)
cnt = 0
for i in range(n):
if(s[i] != s[n-1-i]):
cnt = cnt + 1
print(math.ceil(cnt/2))
| #!/usr/bin/env python3
import sys
from functools import reduce
from operator import mul
MOD = 998244353 # type: int
class ModInt:
def __init__(self, x):
self.x = x % MOD
def __str__(self):
return str(self.x)
__repr__ = __str__
def __add__(self, other):
return (
ModInt(self.x + other.x) if isinstance(other, ModInt) else
ModInt(self.x + other)
)
def __sub__(self, other):
return (
ModInt(self.x - other.x) if isinstance(other, ModInt) else
ModInt(self.x - other)
)
def __mul__(self, other):
return (
ModInt(self.x * other.x) if isinstance(other, ModInt) else
ModInt(self.x * other)
)
def __truediv__(self, other):
return (
ModInt(
self.x * pow(other.x, MOD - 2, MOD)
) if isinstance(other, ModInt) else
ModInt(self.x * pow(other, MOD - 2, MOD))
)
def __pow__(self, other):
return (
ModInt(pow(self.x, other.x, MOD)) if isinstance(other, ModInt) else
ModInt(pow(self.x, other, MOD))
)
__radd__ = __add__
def __rsub__(self, other):
return (
ModInt(other.x - self.x) if isinstance(other, ModInt) else
ModInt(other - self.x)
)
__rmul__ = __mul__
def __rtruediv__(self, other):
return (
ModInt(
other.x * pow(self.x, MOD - 2, MOD)
) if isinstance(other, ModInt) else
ModInt(other * pow(self.x, MOD - 2, MOD))
)
def __rpow__(self, other):
return (
ModInt(pow(other.x, self.x, MOD)) if isinstance(other, ModInt) else
ModInt(pow(other, self.x, MOD))
)
def combinations_count(n, r):
r = min(r, n - r)
numer = reduce(mul, range(n, n - r, -1), 1)
denom = reduce(mul, range(1, r + 1), 1)
return numer // denom
def solve(N: int, M: int, K: int):
SUM = ModInt(0)
n_1Ck = [ModInt(1) for k in range(K + 1)]
for i in range(1, K + 1):
n_1Ck[i] = n_1Ck[i-1] * (N-i) / i
for k in range(0, K + 1):
SUM += M * n_1Ck[k] * (pow(M - 1, N - 1 - k, MOD))
print(SUM)
return
# Generated by 1.1.6 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
M = int(next(tokens)) # type: int
K = int(next(tokens)) # type: int
solve(N, M, K)
if __name__ == '__main__':
main()
| 0 | null | 71,457,490,808,242 | 261 | 151 |
a = input().split()
n, d = int(a[0]), int(a[1])
x = []
a = d * d
res = 0
for i in range(n):
[x, y] = input().split()
if int(x)**2 + int(y)**2 <= a:
res += 1
print(res)
| import sys
N, D = map(int,input().split())
X = [0]*N
Y = [0]*N
for i in range(N):
X[i], Y[i] = map(int,input().split())
def solve():
ret = 0
for i in range(N):
if X[i]*X[i]+Y[i]*Y[i] <= D*D:
ret += 1
return ret
print(solve()) | 1 | 5,878,577,179,198 | null | 96 | 96 |
import time
a=int(input())
time.sleep(1.975)
print(a+a*a+a*a*a) | n = input()
k = int(input())
dp0 = [[0]*(k+1) for _ in range(len(n)+1)]
dp1 = [[0]*(k+1) for _ in range(len(n)+1)]
dp0[0][0] = 1
for i in range(len(n)):
for j in range(k+1):
if int(n[i]) == 0:
dp0[i+1][j] += dp0[i][j]
if int(n[i]) > 0:
dp1[i+1][j] += dp0[i][j]
if j < k:
dp0[i+1][j+1] += dp0[i][j]
dp1[i+1][j+1] += dp0[i][j]*(int(n[i])-1)
if j < k:
dp1[i+1][j+1] += dp1[i][j]*9
dp1[i+1][j] += dp1[i][j]
print(dp0[len(n)][k]+dp1[len(n)][k]) | 0 | null | 43,219,018,965,408 | 115 | 224 |
i = 1
while True:
a = int(input())
if (a == 0):
break
else:
print("Case " + str(i) + ": " + str(a))
i += 1 | s = input()
if 'A' in s and 'B' in s:
print('Yes')
else:
print('No') | 0 | null | 27,602,265,963,350 | 42 | 201 |
from math import *
def distance (p,n,x,y):
dis = 0.0
if p == "inf":
for i in range(0,n) :
if dis < abs(x[i]-y[i]):
dis = abs(x[i]-y[i])
else :
for i in range(0,n) :
dis += abs(x[i]-y[i])**p
dis = dis ** (1.0/p)
return dis
if __name__ == '__main__' :
n = int(input())
x = map(int,raw_input().split())
y = map(int,raw_input().split())
print distance(1,n,x,y)
print distance(2,n,x,y)
print distance(3,n,x,y)
v = distance('inf',n,x,y)
print "%.6f" % v | import math
n = int(input())
x = list(map(int,input().split()))
y = list(map(int,input().split()))
p1 = p2 = p3 = p = 0
for x,y in zip(x,y):
d = abs(x-y)
p1 += d
p2 += d**2
p3 += d**3
if d>p: p = d
print('{0:.5f}\n{1:.5f}\n{2:.5f}\n{3:.5f}'.format(p1,math.sqrt(p2),math.pow(p3,1/3),p))
| 1 | 209,978,529,060 | null | 32 | 32 |
from time import time
start = time()
import random
def solve(c_list, days, now):
r = sum(c_list[i]*(now-days[i]) for i in range(26))
return r
d = int(input())
c = list(map(int, input().split()))
s = [list(map(int, input().split())) for _i in range(d)]
last_days = [-1 for _i in range(26)]
result = []
score = 0
for today in range(d):
checker = [c[j]*(today-last_days[j]) for j in range(26)]
y = sum(checker)
finder = [s[today][j]-(y-checker[j]) for j in range(26)]
x = finder.index(max(finder))
last_days[x] = today
result.append(x+1)
score += s[today][x] - solve(c, last_days, today)
def change(problems, days):
last_days = [-1 for _i in range(26)]
score = 0
for i in range(d):
score += s[i][problems[i]-1]
last_days[problems[i]-1] = i
score -= sum([c[j]*(i-last_days[j]) for j in range(26)])
return score
change_list = result.copy()
hantei = True
coun = 0
while hantei:
if random.randrange(2)<1:
x, y = random.randrange(0, d), random.randrange(0, d)
while x == y:
y = random.randrange(0, d)
change_list[x], change_list[y] = change_list[y], change_list[x]
next_score = change(change_list, d)
if next_score >= score:
score = next_score
result[x], result[y] = result[y], result[x]
elif random.randrange(100)==5:
score = next_score
result[x], result[y] = result[y], result[x]
else:
change_list[x], change_list[y] = change_list[y], change_list[x]
else:
x = random.randrange(0, d)
y = random.randrange(1, 27)
while change_list[x] == y:
x = random.randrange(0, d)
y = random.randrange(1, 27)
change_list[x], z = y, change_list[x]
next_score = change(change_list, d)
if next_score >= score:
score = next_score
result[x] = y
else:
change_list[x] = z
coun += 1
if coun ==100:
coun = 0
if time()-start >= 1.8:
hantei = False
for i in result:
print(i) | import sys
import numpy as np
from numba import njit
@njit('(i8[:],)', cache=True)
def solve(inp):
def bitree_sum(bit, t, i):
s = 0
while i > 0:
s += bit[t, i]
i ^= i & -i
return s
def bitree_add(bit, n, t, i, x):
while i <= n:
bit[t, i] += x
i += i & -i
def bitree_lower_bound(bit, n, d, t, x):
sum_ = 0
pos = 0
for i in range(d, -1, -1):
k = pos + (1 << i)
if k <= n and sum_ + bit[t, k] < x:
sum_ += bit[t, k]
pos += 1 << i
return pos + 1
def initial_score(d, ccc, sss):
bit_n = d + 3
bit = np.zeros((26, bit_n), dtype=np.int64)
INF = 10 ** 18
for t in range(26):
bitree_add(bit, bit_n, t, bit_n - 1, INF)
ttt = np.zeros(d, dtype=np.int64)
last = np.full(26, -1, dtype=np.int64)
score = 0
for i in range(d):
best_t = 0
best_diff = -INF
costs = ccc * (i - last)
costs_sum = costs.sum()
for t in range(26):
tmp_diff = sss[i, t] - costs_sum + costs[t]
if best_diff < tmp_diff:
best_t = t
best_diff = tmp_diff
ttt[i] = best_t
last[best_t] = i
score += best_diff
bitree_add(bit, bit_n, best_t, i + 2, 1)
return bit, score, ttt
def calculate_score(d, ccc, sss, ttt):
last = np.full(26, -1, dtype=np.int64)
score = 0
for i in range(d):
t = ttt[i]
last[t] = i
score += sss[i, t] - (ccc * (i - last)).sum()
return score
def pinpoint_change(bit, bit_n, bit_d, d, ccc, sss, ttt, permissible):
cd = np.random.randint(0, d)
ct = np.random.randint(0, 26)
while ttt[cd] == ct:
ct = np.random.randint(0, 26)
diff = 0
t = ttt[cd]
k = bitree_sum(bit, t, cd + 2)
c = bitree_lower_bound(bit, bit_n, bit_d, t, k - 1) - 2
e = bitree_lower_bound(bit, bit_n, bit_d, t, k + 1) - 2
b = ccc[t]
diff -= b * (cd - c) * (e - cd)
diff -= sss[cd, t]
k = bitree_sum(bit, ct, cd + 2)
c = bitree_lower_bound(bit, bit_n, bit_d, ct, k) - 2
e = bitree_lower_bound(bit, bit_n, bit_d, ct, k + 1) - 2
b = ccc[ct]
diff += b * (cd - c) * (e - cd)
diff += sss[cd, ct]
if diff > permissible:
bitree_add(bit, bit_n, t, cd + 2, -1)
bitree_add(bit, bit_n, ct, cd + 2, 1)
ttt[cd] = ct
else:
diff = 0
return diff
def swap_change(bit, bit_n, bit_d, d, ccc, sss, ttt, permissible):
cd1 = np.random.randint(0, d - 1)
cd2 = cd1 + 1
ct1 = ttt[cd1]
ct2 = ttt[cd2]
if ct1 == ct2:
return 0
diff = 0
k = bitree_sum(bit, ct1, cd1 + 2)
c = bitree_lower_bound(bit, bit_n, bit_d, ct1, k - 1) - 2
e = bitree_lower_bound(bit, bit_n, bit_d, ct1, k + 1) - 2
diff += ccc[ct1] * (e + c - cd1 - cd2)
k = bitree_sum(bit, ct2, cd2 + 2)
c = bitree_lower_bound(bit, bit_n, bit_d, ct2, k - 1) - 2
e = bitree_lower_bound(bit, bit_n, bit_d, ct2, k + 1) - 2
diff -= ccc[ct2] * (e + c - cd1 - cd2)
diff -= sss[cd1, ct1] + sss[cd2, ct2]
diff += sss[cd1, ct2] + sss[cd2, ct1]
if diff > permissible:
bitree_add(bit, bit_n, ct1, cd1 + 2, -1)
bitree_add(bit, bit_n, ct1, cd2 + 2, 1)
bitree_add(bit, bit_n, ct2, cd1 + 2, 1)
bitree_add(bit, bit_n, ct2, cd2 + 2, -1)
ttt[cd1] = ct2
ttt[cd2] = ct1
else:
diff = 0
return diff
d = inp[0]
ccc = inp[1:27]
sss = np.zeros((d, 26), dtype=np.int64)
for r in range(d):
sss[r] = inp[27 + r * 26:27 + (r + 1) * 26]
bit, score, ttt = initial_score(d, ccc, sss)
bit_n = d + 3
bit_d = int(np.log2(bit_n))
loop = 4 * 10 ** 6
permissible_min = -3000.0
method_border = 0.5
best_score = score
best_ttt = ttt.copy()
for lp in range(loop):
permissible = (1 - lp / loop) * permissible_min
if np.random.random() < method_border:
diff = pinpoint_change(bit, bit_n, bit_d, d, ccc, sss, ttt, permissible)
else:
diff = swap_change(bit, bit_n, bit_d, d, ccc, sss, ttt, permissible)
score += diff
# print(lp, score, calculate_score(d, ccc, sss, ttt))
if score > best_score:
best_score = score
best_ttt = ttt.copy()
return best_ttt + 1
inp = np.fromstring(sys.stdin.read(), dtype=np.int64, sep=' ')
ans = solve(inp)
print('\n'.join(map(str, ans)))
| 1 | 9,719,748,652,070 | null | 113 | 113 |
from math import ceil
def point(x,y,r,s,p):
if y == 'r':
y = p
if y == 's':
y = r
if y == 'p':
y = s
return ceil(x/2) * y
n,k = map(int,input().split())
r,s,p = map(int,input().split())
t = list(input())
ans = 0
for _ in range(k):
l = t[_::k]
x = 1
y = l[0]
for i in l[1:]:
if i != y:
ans += point(x,y,r,s,p)
x = 1
y = i
else:
x += 1
ans += point(x,y,r,s,p)
print(ans) | N = int(input())
a_array = []
b_array = []
for i in range(N):
a, b = map(int, input().split())
a_array.append(a)
b_array.append(b)
a_array.sort()
b_array.sort()
if N % 2 != 0:
mid_min = a_array[(N - 1) // 2]
mid_max = b_array[(N - 1) // 2]
print(mid_max - mid_min + 1)
else:
mid_min = (a_array[N // 2 - 1] + a_array[N // 2]) / 2
mid_max = (b_array[N // 2 - 1] + b_array[N // 2]) / 2
print(int((mid_max - mid_min) * 2) + 1)
| 0 | null | 61,888,346,137,408 | 251 | 137 |
A, B, M = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
ans = min(a) + min(b)
for i in range(M):
x, y, c = map(int, input().split())
ans = min(ans, a[x-1] + b[y-1] - c)
print(ans) | import sys
from collections import Counter as cc
def input(): return sys.stdin.readline().rstrip()
def ii(): return int(input())
def mi(): return map(int, input().split())
def li(): return list(mi())
def main():
mod = 10**9 + 7
n = ii()
a = li()
t = [0]*(n)
ans = 1
for i in range(n):
if a[i] == 0:
tmp = 3
else:
tmp = t[a[i]-1]
ans *= tmp-t[a[i]]
ans %= mod
t[a[i]] += 1
print(ans)
if __name__ == '__main__':
main() | 0 | null | 92,377,518,220,252 | 200 | 268 |
def main():
K, X = map(int, input().split())
m = K * 500
if m >= X:
print('Yes')
else:
print('No')
main() | A, B, C, D = map(int, input().split())
result = False
while A > 0 and C > 0:
C -= B
if C <= 0:
result = 'Yes'
break
A -= D
if A <= 0:
result = 'No'
break
print(result) | 0 | null | 64,305,986,939,648 | 244 | 164 |
import sys
import math
def str_input():
S = raw_input()
if S[len(S)-1] == "\r":
return S[:len(S)-1]
return S
W = str_input()
cnt = 0
while 1:
S = str_input()
if (S == "END_OF_TEXT"):
break
S = S.lower().split()
cnt += S.count(W)
print cnt | # -*- coding: utf-8 -*-
import sys
w = sys.stdin.readline().strip()
count = 0
while True:
t = list(map(str, input().split()))
if 'END_OF_TEXT' in t:
break
for i in range(len(t)):
if t[i].lower() == w:
count += 1
print(count)
| 1 | 1,805,150,098,816 | null | 65 | 65 |
table = [[ 0 for i in range(13)] for j in range(4)]
n = int(input())
i = 0
while i < n:
s,num = input().split()
num = int(num)
if s == "S":
table[0][num-1] = 1
elif s == "H":
table[1][num-1] = 1
elif s == "C":
table[2][num-1] = 1
else: # D
table[3][num-1] = 1
i += 1
for i,elem_i in enumerate(table):
for j,elem_j in enumerate(elem_i):
if elem_j ==1:
continue
if i == 0:
s_str='S'
elif i == 1:
s_str='H'
elif i == 2:
s_str='C'
else:
s_str='D'
print (s_str + " " + str(j+1))
| cards = []
mark = ["S","H","C","D"]
for i in range(4):
mk = mark[i]
for j in range(1,14):
cards.append("{} {}".format(mk,j))
n = int(input())
for _ in range(n):
card = input()
cards.remove(card)
for i in cards:
print(i) | 1 | 1,033,662,596,700 | null | 54 | 54 |
k = int(input())
a, b = map(int,input().split())
list1 = []
x =(k+a-1)//k
y = b // k
for i in range(x,y+1):
list1.append(i)
if list1 == []:
print('NG')
else:
print('OK')
| K = int(input())
A, B = [int(i) for i in input().split(' ')]
for i in range(A, B+1):
if i % K == 0:
print('OK')
exit()
print('NG')
| 1 | 26,454,282,360,422 | null | 158 | 158 |
while True:
try:
a = map(int,raw_input().split(' '))
s = a[0] + a[1]
c = 0
while s > 0:
s = s / 10
c = c + 1
if s <= 0:
print c
break
except (EOFError):
break | # coding: utf-8
import codecs
import sys
sys.stdout = codecs.getwriter("shift_jis")(sys.stdout) # ??????
sys.stdin = codecs.getreader("shift_jis")(sys.stdin) # ??\???
# ??\??¬?????????print??????????????´?????? print(u'?????????') ??¨??????
# ??\??¬?????????input??? input(u'?????????') ??§OK
# ??°?¢???????????????????????????´??????6,7???????????????????????¢??????
"""
DEBUG = 0
if DEBUG == 0:
a = []
for i in range(200):
deglist=[int(x) for x in input().split(" ")]
a.append(deglist)
else:
a = [[5,7],[1,99],[1000,999]]
for i in range(len(a)):
wa = a[i][0] + a[i][1]
print len(str(wa))
"""
while True:
try:
a,b = map(int, raw_input().split())
print len(str(a+b))
except EOFError:
break | 1 | 101,921,402 | null | 3 | 3 |
N,A,B=map(int,input().split())
ans=min(A-1,N-B)+1+(B-A-1)//2
sum=0
if (B-A)%2==0:
sum=(B-A)//2
ans=min(sum,ans)
print(ans) | from collections import deque
n, u, v = map(int, input().split())
u -= 1
v -= 1
tree = [[] for _ in range(n)]
for _ in range(n-1):
a, b = map(lambda x : int(x) - 1, input().split())
tree[a].append(b)
tree[b].append(a)
q = deque()
q.append((u, 0))
depth = [0] * n
visited = set()
while q:
p, d = q.popleft()
depth[p] = d
visited.add(p)
for x in tree[p]:
if not x in visited:
q.append((x, d+1))
q.append((v, 0))
visited.clear()
max_case = max(depth[v] - 1, 0)
while q:
p, d = q.popleft()
visited.add(p)
is_leaf = True
for x in tree[p]:
if not x in visited:
q.append((x, d+1))
is_leaf = False
if is_leaf and depth[p] < d:
max_case = max(max_case, d - 1)
print(max_case)
| 0 | null | 113,865,453,999,616 | 253 | 259 |
# -*- coding: utf-8 -*-
"""
Created on Tue Apr 28 21:57:22 2020
"""
import sys
#import numpy as np
sys.setrecursionlimit(10 ** 9)
#def input():
# return sys.stdin.readline()[:-1]
mod = 10**9+7
S = input()
if S[2] == S[3] and S[4] == S[5]:
ans = 'Yes'
else:
ans = 'No'
print(ans)
| S,W = list(map(int,input().split()))
if W >= S:print('unsafe')
else: print('safe') | 0 | null | 35,734,170,108,682 | 184 | 163 |
import sys
sys.setrecursionlimit(10 ** 5 * 2)
N, K = map(int, input().split())
A = [0] + list(map(int, input().split()))
top = -1
hist = []
finished = [True] + [False for _ in range(N)]
seen = [True] + [False for _ in range(N)]
def dfs(cur):
global hist, finished, seen, top
hist.append(cur)
seen[cur] = True
nex = A[cur]
if seen[nex] and not finished[nex]:
top = nex
return
dfs(nex)
if not top == -1:
return
hist.pop()
finished[cur] = True
dfs(1)
cycle = []
while not hist == []:
i = hist.pop()
cycle.append(i)
if i == top:
break
cycle.reverse()
cur = 1
while not cur == top and not K == 0:
cur = A[cur]
K -= 1
if cur == top:
cur = cycle[K % len(cycle)]
print(cur) | import math
import sys
# sys.setrecursionlimit(100000)
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 = input_int()
_x = []
_y = []
for _ in range(n):
x, y = input_int_list()
# 座標系を45度回転させて考える
_x.append(x - y)
_y.append(x + y)
ans = max(max(_x) - min(_x), max(_y) - min(_y))
print(ans)
return
if __name__ == "__main__":
main()
| 0 | null | 13,084,049,447,412 | 150 | 80 |
def main():
s = input()
s = list(reversed(s))
s.append('0')
dp = [[10**10 for _ in range(2)] for _ in range(len(s)+1)]
dp[0][0] = 0
for i in range(len(s)):
for j in range(2):
x = int(s[i])
x += j
for a in range(10):
ni = i+1
nj = 0
b = a-x
if b < 0:
nj = 1
b += 10
dp[ni][nj] = min(dp[ni][nj], dp[i][j]+a+b)
print(dp[len(s)][0])
main()
| import sys
n = sys.stdin.readline().rstrip()
l = len(n)
def main():
dp0 = [None] * (l + 1)
dp1 = [None] * (l + 1)
dp0[0] = 0
dp1[0] = 1
for i in range(l):
d = int(n[i])
dp0[i+1] = min(dp0[i]+d, dp1[i]+10-d)
dp1[i+1] = min(dp0[i]+d+1, dp1[i]+10-d-1)
return dp0[l]
if __name__ == '__main__':
ans = main()
print(ans) | 1 | 70,911,513,229,088 | null | 219 | 219 |
def resolve():
import numpy as np
d = int(input())
C = list(map(int, input().split()))
S = []
for _ in range(d):
_S = list(map(int, input().split()))
S.append(_S)
S = np.array(S)
T = []
for _ in range(d):
T.append(int(input()))
last = [-1 for i in range(26)]
score = 0
for i in range(d):
# max_idx = np.argmax(S[i])
# print(max_idx + 1)
score += S[i][T[i] - 1]
last[T[i] - 1] = i
for j in range(26):
score -= C[j] * (i - last[j])
print(score)
resolve() | D = int(input())
c = [0]+list(map(int, input().split()))
s = [[0]]+[[0]+list(map(int, input().split())) for _ in range(D)]
t = [0]+[int(input()) for _ in range(D)]
ans = 0
last = [0]*(27)
for d in range(1,D+1):
ans += s[d][t[d]]
last[t[d]] = d
for i in range(1,27):
ans -= c[i] * (d-last[i])
print(ans) | 1 | 9,906,105,348,864 | null | 114 | 114 |
a = [i for i in input().split()]
b = []
for i in a:
if i == "+":
x = int(b.pop())
y = int(b.pop())
z = x + y
b.append(z)
elif i == "-":
x = int(b.pop())
y = int(b.pop())
z = y - x
b.append(z)
elif i == "*":
x = int(b.pop())
y = int(b.pop())
z = x * y
b.append(z)
else:
b.append(int(i))
print(b[0])
| N=int(input())
A=map(int, input().split())
A=list(A)
ans= [0] * len(A)
for i,a in enumerate(A):
ans[a-1]= i+1
print(' '.join(map(str,ans)))
| 0 | null | 90,826,738,498,550 | 18 | 299 |
n=int(input())
p=list(map(int,input().split()))
a=n
c=0
for i in p:
if i<=a:
a=i
c+=1
print(c) | n = int(input()[-1])
if n in [2,4,5,7,9]:
print("hon")
elif n in [0,1,6,8]:
print("pon")
else:
print("bon") | 0 | null | 52,567,115,578,080 | 233 | 142 |
h, w = map(int, input().split())
if h==1 or w == 1:
print(1)
else:
ans = h * w //2 + (h*w)%2
print(ans) | def resolve():
'''
code here
'''
H, W = [int(item) for item in input().split()]
if H == 1 or W == 1:
res = 1
elif H % 2 == 1 and W % 2 == 1:
res = H * W // 2 +1
else:
res = H * W // 2
print(res)
if __name__ == "__main__":
resolve()
| 1 | 50,900,128,683,538 | null | 196 | 196 |
import math
x1, y1, x2, y2 = map(float, input().split())
line = (x2 - x1) ** 2 + (y2 - y1) ** 2
line = math.sqrt(line)
print(line)
| data = list(map(float, input().split()))
print(((data[2]-data[0])**2+(data[3]-data[1])**2)**0.5)
| 1 | 151,432,964,282 | null | 29 | 29 |
import sys
read = sys.stdin.readline
import time
import math
import itertools as it
def inpl():
return list(map(int, input().split()))
st = time.perf_counter()
# ------------------------------
N, K = inpl()
A = inpl()
for i in range(K, N):
if A[i] > A[i-K]:
print('Yes')
else:
print('No')
# -----------------------------
ed = time.perf_counter()
print('time:', ed-st, file=sys.stderr)
| operand = ["+", "-", "*"]
src = [x if x in operand else int(x) for x in input().split(" ")]
stack = []
for s in src:
if isinstance(s, int):
stack.append(s)
elif s == "+":
b, a = stack.pop(), stack.pop()
stack.append(a+b)
elif s == "-":
b, a = stack.pop(), stack.pop()
stack.append(a-b)
elif s == "*":
b, a = stack.pop(), stack.pop()
stack.append(a*b)
print(stack[0]) | 0 | null | 3,545,709,439,372 | 102 | 18 |
D=int(input())
c=list(map(int,input().split()))
s=[list(map(int,input().split())) for i in range(D)]
t=[int(input())-1 for i in range(D)]
v=[]
S=0
last=[0]*27
for d in range(D):
S+=s[d][t[d]]
last[t[d]]=d+1
for i in range(26):
S-=c[i]*(d+1 - last[i])
print(S)
| import numpy as np
D = int(input())
C = np.array(list(map(int, input().split())))
S = []
for i in range(D):
s = list(map(int, input().split()))
S.append(s)
S = np.array(S)
T = [int(input()) for _ in range(D)]
last = np.zeros(26, dtype=np.int64)
def decrease(d, last):
res = np.sum(C * (d - last))
# print(d, res, C * (d - last))
return res
manzoku = 0
# kaisai = dict()
# print(S, T, C)
for day, t in enumerate(T):
t -= 1
manzoku += S[day, t] # d 日目にタイプi のコンテストを開催した場合、満足度が S[d,i]増加することが予め分かっています。
last[t] = day + 1
manzoku -= decrease(day + 1, last)
print(manzoku)
| 1 | 9,848,592,349,692 | null | 114 | 114 |
n = int(input())
ret = 0
b = 1
while n > 0:
ret += b
n //= 2
b *= 2
print(ret)
| import math
H = int(input())
ans = 2 ** int(math.log2(H) + 1) - 1
print(ans)
| 1 | 79,817,558,906,384 | null | 228 | 228 |
s=0
while True:
i=input()
if i == '0': break
s+=1
print("Case {}: {}".format(s,i)) | N,K=map(int,input().split())
p=list(map(int,input().split()))
q=[]
q.append(0)
for i in range(len(p)):
q.append(q[-1]+p[i])
maxi=q[K]-q[0]
for i in range(1,N-K+1):
sub=q[K+i]-q[i]
if sub>=maxi:
maxi=sub
print((maxi+K)/2) | 0 | null | 37,889,356,001,972 | 42 | 223 |
while True:
line = input()
if line=='-':
break
loop = int(input())
for i in range(loop):
x = int(input())
line = line[x:] + line[:x]
print(line)
| while 1:
w=raw_input()
if w=='-': break
n=int(raw_input())
for i in range(n):
l=int(raw_input())
w=w[l:]+w[:l]
print w | 1 | 1,918,970,785,718 | null | 66 | 66 |
line = input()
data = line.split()
height = int(data[0])
wei = int(data[1])
if height !=1 and wei !=1:
if height %2 ==0:
if wei %2 ==0:
print(int(wei/2)*height)
else:
print(int(wei/2)*height+int(height/2))
else:
if wei %2 ==0:
print(int(height/2)* wei + int(wei/2))
else:
print(wei* int(height/2) + int(wei/2)+1)
else:
print(1) | import math
n=input()
m=math.radians(60)
def kock(n, p1x, p1y, p2x, p2y):
if(n == 0):
return
sx=(2*p1x+1*p2x)/3
sy=(2*p1y+1*p2y)/3
tx=(1*p1x+2*p2x)/3
ty=(1*p1y+2*p2y)/3
ux=(tx-sx)*math.cos(m)-(ty-sy)*math.sin(m)+sx
uy=(tx-sx)*math.sin(m)+(ty-sy)*math.cos(m)+sy
kock(n-1, p1x, p1y, sx, sy)
print round(sx,8),round(sy, 8)
kock(n-1, sx, sy, ux, uy)
print round(ux, 8),round(uy, 8)
kock(n-1, ux, uy, tx, ty)
print round(tx, 8),round(ty, 8)
kock(n-1, tx, ty, p2x, p2y)
p1x = 0.00000000
p1y = 0.00000000
p2x = 100.00000000
p2y = 0.00000000
print p1x, p1y
kock(n, p1x, p1y, p2x, p2y)
print p2x, p2y | 0 | null | 25,636,735,956,480 | 196 | 27 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.