code1
stringlengths 17
427k
| code2
stringlengths 17
427k
| similar
int64 0
1
| pair_id
int64 2
181,637B
⌀ | question_pair_id
float64 3.7M
180,677B
⌀ | code1_group
int64 1
299
| code2_group
int64 1
299
|
|---|---|---|---|---|---|---|
A, B, C = map(int, input().split())
if A+B+C > 21:
print('bust')
else:
print('win') | import math
N = int(input())
M = []
sqr_N = math.floor(math.sqrt(N))
a = 0
for i in range(1, (sqr_N + 1)):
if N % i == 0:
a = i
a_pair = N // a
print(a + a_pair - 2) | 0 | null | 140,334,167,990,780 | 260 | 288 |
import math
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 -= g
cnt += 1
A[j + g] = v
return cnt
def shellSort(A, n):
cnt = 0
j = int(math.log(2 * n + 1, 3)) + 1
G = list(reversed([(3 ** i - 1)// 2 for i in range(1, j)]))
m = len(G)
for i in range(m):
cnt += insertionSort(A, n, G[i])
return A, cnt, G, m
n = int(input())
A = [int(input()) for i in range(n)]
ans, count, G, m = shellSort(A, n)
print(m)
print(' '.join(map(str,G)))
print(count)
[print(i) for i in A] | A,V=map(int,input().split())
B,W=map(int,input().split())
T=int(input())
if V<=W or (abs(A-B)/(V-W))>T:
print("NO")
else:
print("YES") | 0 | null | 7,558,943,068,510 | 17 | 131 |
# Aizu Problem ALDS_1_3_A: Stack
#
import sys, math, os
# read input:
PYDEV = os.environ.get('PYDEV')
if PYDEV=="True":
sys.stdin = open("sample-input.txt", "rt")
stack = []
for x in input().split():
if x == '+':
b = stack.pop()
a = stack.pop()
stack.append(a + b)
elif x == '-':
b = stack.pop()
a = stack.pop()
stack.append(a - b)
elif x == '*':
b = stack.pop()
a = stack.pop()
stack.append(a * b)
else:
stack.append(int(x))
print(stack[0]) | from collections import defaultdict
N = int(input())
A = list(map(int, input().split()))
Q = int(input())
d = defaultdict(int)
v = 0
ans = []
for a in A:
d[a] += 1
v += a
for i in range(Q):
B, C = map(int, input().split())
v += d[B] * (C - B)
d[C] += d[B]
d[B] = 0
ans.append(v)
for a in ans:
print(a)
| 0 | null | 6,095,109,855,648 | 18 | 122 |
def resolve():
# 十進数表記で1~9までの数字がK個入るN桁の数字の数を答える問題
S = input()
K = int(input())
n = len(S)
# dp[i][k][smaller]:
# i:桁数
# K:0以外の数字を使った回数
# smaller:iまでの桁で値以上になっていないかのフラグ
dp = [[[0] * 2 for _ in range(4)] for _ in range(105)]
dp[0][0][0] = 1
for i in range(n):
for j in range(4):
for k in range(2):
nd = int(S[i])
for d in range(10):
ni = i+1
nj = j
nk = k
if d != 0:
nj += 1
if nj > K:
continue
if k == 0:
if d > nd: # 値を超えている
continue
if d < nd:
nk += 1
dp[ni][nj][nk] += dp[i][j][k]
ans = dp[n][K][0] + dp[n][K][1]
print(ans)
if __name__ == "__main__":
resolve() | N = int(input())
A = list(map(int,input().split()))
ans = sum(A)
X = [0]*(10**5+1)
for x in A:
X[x] += 1
Q = int(input())
for _ in range(Q):
B,C = map(int,input().split())
ans += (C-B)*X[B]
X[C] += X[B]
X[B] = 0
print(ans)
| 0 | null | 44,238,192,180,968 | 224 | 122 |
roll = {"N": (1, 5, 2, 3, 0, 4),
"S": (4, 0, 2, 3, 5, 1),
"E": (3, 1, 0, 5, 4, 2),
"W": (2, 1, 5, 0, 4, 3)}
dice = input().split()
for direction in input():
dice = [dice[i] for i in roll[direction]]
print(dice[0])
| S = input()
l = [0] * (len(S)+1)
r = [0] * (len(S)+1)
for i in range(len(S)):
if S[i] == '<':
l[i+1] = l[i] + 1
for i in range(len(S)-1,-1,-1):
if S[i] == '>':
r[i] = r[i+1] + 1
print(sum([max(l[i],r[i]) for i in range(len(S)+1)]))
| 0 | null | 78,151,414,024,292 | 33 | 285 |
n = int(input())
s = input()
ans = s.count('R') * s.count('G') * s.count('B')
for i in range(n):
for j in range(i + 1, n):
if j * 2 - i >= n:
continue
if s[i] == s[j] or s[j] == s[2 * j - i] or s[i] == s[2 * j - i]:
continue
ans -= 1
print(ans)
| N = int(input())
S = list(input())
R = []
G = []
B = [0 for _ in range(N)]
b_cnt = 0
for i in range(N):
if S[i] == 'R':
R.append(i)
elif S[i] == 'G':
G.append(i)
else:
B[i] = 1
b_cnt += 1
answer = 0
for r in R:
for g in G:
answer += b_cnt
if (g-r)%2 == 0 and B[(r+g)//2] == 1:
answer -= 1
if 0 <= 2*g-r < N and B[2*g-r] == 1:
answer -= 1
if 0 <= 2*r-g < N and B[2*r-g] == 1:
answer -= 1
print(answer) | 1 | 36,275,132,520,096 | null | 175 | 175 |
import sys
#import cython
def main():
read = lambda: sys.stdin.readline().rstrip()
import collections
d = collections.defaultdict(int)
N = int(read())
A = list(map(int,read().split()))
cnt = 0
for i, x in enumerate(A):
d[i + x] += 1
if d[i-x] > 0: cnt += d[i-x]
print(cnt)
if __name__ == "__main__":
main() | #!/usr/bin/env python3
import sys
from typing import NamedTuple, List
class Game(NamedTuple):
c: List[int]
s: List[List[int]]
def solve(D: int, c: "List[int]", s: "List[List[int]]", t: "List[int]"):
from functools import reduce
ans = [0]
lasts = [0] * 26
sum_c = sum(c)
daily_loss = sum_c
bits = [BIT(D*2) for _ in range(26)]
for day, tt in enumerate(t, 1):
a = s[day-1][tt-1]
lasts[tt-1] = day
for i in range(26):
bits[i].add(day, lasts[i]*c[i])
a -= daily_loss
a += sum(b.sum(day)-b.sum(day-1) for b in bits)
ans.append(ans[-1]+a)
daily_loss += sum_c
return ans[1:]
# https://kopricky.github.io/code/For_Python/bit.html
class BIT:
def __init__(self, node_size):
self._node = node_size+1
self.bit = [0]*self._node
def add(self, index, add_val):
index += 1
while index < self._node:
self.bit[index] += add_val
index += index & -index
def sum(self, index):
index += 1
res = 0
while index > 0:
res += self.bit[index]
index -= index & -index
return res
# Generated by 1.1.7.1 https://github.com/kyuridenamida/atcoder-tools
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
D = int(next(tokens)) # type: int
c = [int(next(tokens)) for _ in range(26)] # type: "List[int]"
s = [[int(next(tokens)) for _ in range(26)] for _ in range(D)] # type: "List[List[int]]"
t = [int(next(tokens)) for _ in range(D)] # type: "List[int]"
print(*solve(D, c, s, t), sep="\n")
def test():
import doctest
doctest.testmod()
if __name__ == '__main__':
#test()
main()
| 0 | null | 18,129,895,913,220 | 157 | 114 |
def is_prime(n):
if n == 2: return True
if n < 2 or n % 2 == 0: return False
return pow(2, n - 1, n) == 1
count = 0
for i in range(int(input())):
if is_prime(int(input())) : count += 1
print(count) | def isPrimeNum(in_num):
if in_num <= 1:
return False
elif in_num == 2:
return True
elif in_num % 2 == 0:
return False
else:
if pow(2, in_num-1, in_num) == 1:
return True
else:
return False
num_len = int(input())
cnt = 0
for i in range(num_len):
num = int(input())
if isPrimeNum(num)==True:
cnt = cnt + 1
print(str(cnt)) | 1 | 9,508,119,268 | null | 12 | 12 |
x, n = map(int, input().split())
p = sorted(list(map(int, input().split())))
a = 100
b = 0
for i in range(0, 102):
if i not in p and abs(x - i) < a:
a = abs(x - i)
b = i
print(b)
| X, N = map(int, input().split())
p = list(map(int, input().split()))
ans = None
diff = 1000
if X not in p:
ans = X
else:
for i in range(-1, max(max(p), X)+2):
if i in p:continue
if abs(X - i) < diff:
diff = abs(X - i)
ans = i
print(ans)
| 1 | 14,074,192,262,318 | null | 128 | 128 |
import math
def main():
N = int(input())
if N % 2 == 0:
print("{:.11f}".format((N / 2) / N))
else:
print("{:.11f}".format(math.ceil(N / 2) / N))
if __name__ == "__main__":
main()
| N=int(input())
if 1<=N<=100:
if N%2==1:
print((N+1)/(2*N))
elif N%2==0:
print(1/2) | 1 | 177,499,022,815,578 | null | 297 | 297 |
n = int(input())
lst = []
while n % 2 == 0:
lst.append(2)
n //= 2
f = 3
while f * f <= n:
if n % f == 0:
lst.append(f)
n //= f
else:
f += 2
if n != 1:
lst.append(n)
#print(lst)
count = 0
while lst:
s = 0
i = 1
num = lst[0]
for ele in lst:
if ele == num:
s += 1
for j in range(s):
lst.remove(num)
while s > 0:
s -= i
i += 1
if s >= 0:
count += 1
#print(lst)
print(count) | import math
n = int(input())
m = n
answer = 0
i = 2
while i ** 2 <= m:
t = 0
while n % i == 0:
n //= i
t += 1
answer += int((-1+math.sqrt(1+8*t)) / 2)
i += 1
if n > 1000000:
answer += 1
print(answer)
| 1 | 16,821,349,803,820 | null | 136 | 136 |
from collections import deque
n, u, v = map(int, input().split())
u-=1; v-=1;
a = []; b = [];
dist = [[] for i in range(n)]
for i in range(n-1):
a, b = map(int, input().split())
a -= 1; b -= 1
dist[a].append(b)
dist[b].append(a)
def bfs(u):
d = [-1]*n
stack = deque([u])
d[u] = 0
while len(stack)!=0:
s = stack.popleft()
for t in dist[s]:
if d[t]==-1:
d[t] = d[s]+1
stack.append(t)
return d
A = bfs(v)
T = bfs(u)
ans=0
for i in range(n):
if A[i]>T[i]:
ans = max(A[i]-1, ans)
print(ans) | from collections import defaultdict
import sys
sys.setrecursionlimit(10 ** 6)
def depth(adj, node, parent=None):
ret = 0
for child in adj[node]:
if child == parent:
continue
d = depth(adj, child, node) + 1
ret = max(ret, d)
return ret
def main():
N, U, V = list(map(int, input().split(' ')))
U -= 1
V -= 1
adj = defaultdict(list)
for _ in range(N - 1):
A, B = list(map(lambda x: int(x) - 1, input().split(' ')))
adj[A].append(B)
adj[B].append(A)
path = [-1] * N
def find_path_on_tree(to_node, node, parent=None, d=0):
if node == to_node:
path[d] = node
return True
for child in adj[node]:
if child == parent:
continue
if not find_path_on_tree(to_node, child, node, d + 1):
continue
path[d] = node
return True
return False
find_path_on_tree(U, V) # to U from V
path = [node for node in path if node != -1]
dist = len(path) - 1
partial_depth = depth(adj, path[(dist // 2) + 1], path[dist // 2])
print(partial_depth + (dist // 2))
if __name__ == '__main__':
main() | 1 | 117,537,759,713,636 | null | 259 | 259 |
N = int(input())
A = list(map(int, input().split()))
l = {a: i for i, a in enumerate(A, start=1)}
print(' '.join([str(l[i+1]) for i in range(N)]))
| n=int(input())
s=list(map(int,input().split()))
p=[0]*n
for i in range(n):
p[s[i]-1]=i+1
print(*p) | 1 | 180,409,742,211,808 | null | 299 | 299 |
import numpy as np
last=[0]*26
D=int(input())
c=list(map(int, (input().split(' '))))
s=[]
a=[0]*D
sat=0
for i in range(D):
s.append(list(map(int, (input().split(' ')))))
for i in range(D):
a[i]=int(input())
last[a[i]-1] = i+1
sat += s[i][a[i]-1] - np.dot(c, list(map(lambda x: i+1-x, last)))
print(sat) | D=int(input())
c=list(map(int,input().split()))
s=[]
for i in range(D):
s.append(list(map(int,input().split())))
t=[]
for i in range(D):
t.append(int(input()))
last_di=[0]*26
m=0
for i in range(D):
m+=s[i][t[i]-1]
last_di[t[i]-1]=i+1
for j in range(26):
m-=c[j]*((i+1)-last_di[j])
print(m)
| 1 | 9,954,048,211,130 | null | 114 | 114 |
n,t=map(int,input().split())
ab=[[0]*2 for i in range(n+1)]
for i in range(1,n+1):
ab[i][0],ab[i][1]=map(int,input().split())
dp=[[0]*(t+3001) for i in range(n+1)]
ab.sort(key=lambda x:x[0])
for i in range(1,n+1):
for j in range(t):
dp[i][j]=max(dp[i][j],dp[i-1][j])
dp[i][j+ab[i][0]]=max(dp[i][j+ab[i][0]],dp[i-1][j]+ab[i][1])
ans=0
for i in range(n+1):
ans=max(ans,max(dp[i]))
print(ans) | N = int(input())
s,t = map(str,input().split())
ans = list()
for i in range(N):
ans.append(s[i])
ans.append(t[i])
for i in range(N*2):
print(ans[i],end='') | 0 | null | 131,541,801,057,530 | 282 | 255 |
n=input()
c=[]
A=[]
for i in ['S ','H ','C ','D ']:
for j in map(str,range(1,14)):
A.append(i+j)
for i in range(n):
A.remove(raw_input())
for i in range(len(A)):
print A[i] | import sys
SUITS = ('S', 'H', 'C', 'D')
cards = {suit:{i for i in range(1, 14)} for suit in SUITS}
n = input() # 読み捨て
for line in sys.stdin:
suit, number = line.split()
cards[suit].discard(int(number))
for suit in SUITS:
for i in cards[suit]:
print(suit, i) | 1 | 1,035,427,182,078 | null | 54 | 54 |
n = int(input())
a = [int(i) for i in input().split()]
if n // 2 == 1:
print(max(a))
exit()
if n < 20:
d = a.copy()
for i in range(1, n // 2):
b = [0] * n
c = -10 ** 24
ans = -10 ** 24
for j in range(i * 2, n):
c = max(c, a[j - 2])
b[j] = c + d[j]
ans = max(ans, c + d[j])
a = b.copy()
print(ans)
exit()
b = a[:10]
e = [True]*10
for i in range(1, n // 2):
c = [0] * 10
f = [False]*10
d = -10**24
for j in range(10):
if 2 * i + j >= n:
continue
if not e[j]:
continue
d = max(d, b[j])
c[j] = d + a[2 * i + j]
f[j] = True
e = f.copy()
b = c.copy()
ans = -10 ** 24
for i in range(10):
if e[i]:
ans = max(ans, b[i])
print(ans)
|
#f = open("C:/Users/naoki/Desktop/Atcoder/input.txt")
N = int(input())
A = list(map(int, input().split()))
A.insert(0, 0)
select_num = N//2
inf = -10e+100
Dp_f = [[inf] * (3) for _ in range(N+1)]
Dp_s = [[inf] * (3) for _ in range(N+1)]
# 3 次元はそれぞれStart~3つに該当
pre_margin = 0
for i in range(1,N+1):
Start = (i-1)//2
End = (i+1)//2
cur_margin = Start
for j in range(Start,End+1):
Dp_f[i][j-cur_margin] = max(Dp_s[i-1][j-pre_margin], Dp_f[i-1][j-pre_margin])
# [0] in 3rd dimension not chosen at last num
# must be transfered from [i-1]
for j in range(Start,End+1):
if j-1 == 0:
Dp_s[i][j-cur_margin] = 0 + A[i]
else:
Dp_s[i][j-cur_margin] = Dp_f[i-1][j-1-pre_margin]+A[i]
pre_margin = cur_margin
print(max(Dp_f[-1][select_num - cur_margin], Dp_s[-1][select_num - cur_margin]))
| 1 | 37,339,465,946,950 | null | 177 | 177 |
n = int(input())
a = [0] * n
x = [0] * n
y = [0] * n
for i in range(n):
a[i] = int(input())
t = [[int(j) for j in input().split()] for k in range(a[i])]
x[i] = [j[0] for j in t]
y[i] = [j[1] for j in t]
mx = 0
for bit in range(1<<n):
flag = True
tf = [0] * n
for i in range(n):
if bit & (1 << i):
tf[i] = 1
for i in range(n):
if tf[i] == 0:
continue
for j in range(a[i]):
if tf[x[i][j]-1] != y[i][j]:
flag = False
if flag: mx = max(mx, bin(bit).count("1"))
print(mx) | def f(n):
res = 0
s = 0
for i in range(1,n+1):
s += i
if s <=n:
res = i
else:
break
return res
n = int(input())
p =2
ans = 0
while p*p <= n:
e = 0
while n%p == 0:
e += 1
n//=p
ans += f(e)
p +=1
if n >1:
ans += 1
print(ans) | 0 | null | 69,296,477,818,150 | 262 | 136 |
def main():
n = list(input())
k = int(input())
N = len(n)
for i in range(N):
n[i] = int(n[i])
dp1 = [[0 for _ in range(k+1)] for _ in range(N+1)]
dp2 = [[0 for _ in range(k+1)] for _ in range(N+1)]
dp1[0][0] = 1
for i in range(N):
for j in range(k+1):
dp2[i+1][j] += dp2[i][j]
if j < k:
dp2[i+1][j+1] += dp2[i][j]*9
if n[i]:
dp2[i+1][j] += dp1[i][j]
if j == k:
continue
dp1[i+1][j+1] += dp1[i][j]
dp2[i+1][j+1] += dp1[i][j] * (n[i]-1)
else:
dp1[i+1][j] += dp1[i][j]
print(dp1[N][k]+dp2[N][k])
if __name__ == "__main__":
main() | import numpy as np
n = int(input())
a = list(map(int,input().split()))
mod = 10**9+7
ans = 0
a=np.array(a)
for i in range(60):
keta = a>>i & 1
num1 = int(keta.sum())
num0 = n - num1
ans+= ((2**i)%mod)*(num1*num0)
ans%=mod
print(ans) | 0 | null | 99,954,641,756,228 | 224 | 263 |
n=int(input())
arr=[input() for _ in range(n)]
dic={}
for i in range(n): #各単語の出現回数を数える
if arr[i] not in dic:
dic[arr[i]]=1
else:
dic[arr[i]]+=1
largest=max(dic.values()) #最大の出現回数を求める
ans=[]
for keys in dic.keys():
if dic[keys]==largest: #出現回数が最も多い単語を集計する
ans.append(keys)
ans=sorted(ans) #単語を辞書順に並べ替えて出力する
for words in ans:
print(words) | s = str(input())
apple = ["SUN","MON","TUE","WED","THU","FRI","SAT","SUN"]
print(7-apple.index(s)) | 0 | null | 101,595,179,499,560 | 218 | 270 |
n, k = list(map(int, input().split()))
mod = 10**9 + 7
# xの逆元を求める。フェルマーの小定理より、 x の逆元は x ^ (mod - 2) に等しい。計算時間はO(log(mod))程度。
def modinv(x):
return pow(x, mod-2, mod)
# 二項係数の左側の数字の最大値を max_len とする。nとかだと他の変数と被りそうなので。
# factori_table = [1, 1, 2, 6, 24, 120, ...] 要は factori_table[n] = n!
# 計算時間はO(max_len * log(mod))
max_len = 2 * n - 1 #適宜変更する
factori_table = [1] * (max_len + 1)
factori_inv_table = [1] * (max_len + 1)
for i in range(1, max_len + 1):
factori_table[i] = factori_table[i-1] * (i) % mod
factori_inv_table[i] = modinv(factori_table[i])
def binomial_coefficients(n, k):
# n! / (k! * (n-k)! )
if k <= 0 or k >= n:
return 1
return (factori_table[n] * factori_inv_table[k] * factori_inv_table[n-k]) % mod
if k >= n-1:
# nHn = 2n-1 C n
print(binomial_coefficients(2 * n - 1, n))
else:
# 移動がk回←→ 人数0の部屋がk個以下
# 人数0の部屋がちょうどj個のものは
# nCj(人数0の部屋の選び方) * jH(n-j) (余剰のj人を残りの部屋に入れる)
ans = 0
for j in range(k+1):
if j == 0:
ans += 1
else:
ans += binomial_coefficients(n, j) * binomial_coefficients(n-1, j)
ans %= mod
print(ans)
| n,k = map(int,input().split())
def cmb(n, r, mod):
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % mod
mod = 10**9+7 #出力の制限
g1 = [1, 1] # 元テーブル
g2 = [1, 1] #逆元テーブル
inverse = [0, 1] #逆元テーブル計算用テーブル
for i in range( 2, n + 1 ):
g1.append( ( g1[-1] * i ) % mod )
inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )
g2.append( (g2[-1] * inverse[-1]) % mod )
ans = 0
#con = cmb(n,k,mod)
#print(con)
for i in range(min(k+1,n+1)):
ans += cmb(n,i,mod)*cmb(n-1,i,mod)
ans %= mod
print(ans) | 1 | 66,887,749,303,494 | null | 215 | 215 |
K = int(input())
for i in range(0, K):
print("ACL", end="")
| n,k,*a=map(int,open(0).read().split())
for i in range(n-k):print("Yes" if a[i]<a[i+k] else "No") | 0 | null | 4,621,419,169,780 | 69 | 102 |
def solve():
N = int(input())
return N*N
print(solve()) | n = int(input())
s = n*n
print(s) | 1 | 144,866,998,278,660 | null | 278 | 278 |
S = input()
k = int(input())
from itertools import groupby
x = y = 0
g = [len(list(v)) for k,v in groupby(S)]
for c in g:
x += c//2
#print(len(S),g[0])
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
#print('?',y)
else:
y = k-1
print(x*k + y)
| k=int(input())
if k%2==0 or k%5==0:
print(-1)
exit()
ans=1
num=7
while num%k!=0:
num=10*num+7
num%=k
ans+=1
print(ans) | 0 | null | 90,961,768,954,332 | 296 | 97 |
# -*- coding:utf-8 -*-
a,b = input().split()
a,b = int(a),int(b)
d = int(a//b)
r = int(a%b)
print(d,r,format(a/b,'.6f')) | a, b = map(int, input().split())
print('{:d} {:d} {:.10f}'.format(a//b, a%b, a/b))
| 1 | 604,090,637,640 | null | 45 | 45 |
n,m = map(int,input().split())
# 受け取った文字をスペースで分けてリスト化
a = list(input().split())
# 文字列のリストの値を整数化
a_int = [int(i) for i in a]
# 夏休みの日数がリスト内の日数の合計より多ければ残日数を表示
if n >= sum(a_int):
print(n - sum(a_int))
# リスト内の日数の合計が夏休みの日数より多ければ-1を表示
else:
print("-1") | T1, T2 = map(int, input().split())
A1, A2 = map(int, input().split())
B1, B2 = map(int, input().split())
SA = T1 * A1 + T2 * A2
SB = T1 * B1 + T2 * B2
if SA == SB or A1 == B1:
print('infinity')
exit()
if SA > SB and A1 < B1:
M = (B1 - A1) * T1
d = SA - SB
cnt = M // d
ans = cnt * 2
if M % d != 0:
ans += 1
print(max(0, ans))
elif SB > SA and B1 < A1:
M = (A1 - B1) * T1
d = SB - SA
cnt = M // d
ans = cnt * 2
if M % d != 0:
ans += 1
print(max(0, ans))
else:
print(0)
| 0 | null | 81,788,692,584,576 | 168 | 269 |
MAX = 5 * 10**5
SENTINEL = 2 * 10**9
cnt = 0
def merge(A, left, mid, right):
n1 = mid - left;
n2 = right - mid;
L = A[left:left+n1]
R = A[mid:mid+n2]
global cnt
L.append(SENTINEL)
R.append(SENTINEL)
i = 0
j = 0
for k in range(left, right):
cnt += 1
if L[i] < R[j]:
A[k] = L[i]
i += 1
else:
A[k] = R[j]
j+= 1
def mergeSort(A, left, right):
if left + 1 < right:
mid = (left + right) // 2;
mergeSort(A, left, mid)
mergeSort(A, mid, right)
merge(A, left, mid, right)
n = int(input())
s = list(map(int, input().split()))
mergeSort(s, 0, len(s))
ans = []
for item in s:
ans.append(str(item))
print(' '.join(ans))
print(cnt)
| def merge(A, l, m, r):
L = A[l:m] + [SENTINEL]
R = A[m:r] + [SENTINEL]
i = 0
j = 0
for k in range(l, r):
if L[i] <= R[j]:
A[k] = L[i]
i += 1
else:
A[k] = R[j]
j += 1
global count
count += r - l
def merge_sort(A, l, r):
if l + 1 < r:
m = (l + r) // 2
merge_sort(A, l, m)
merge_sort(A, m, r)
merge(A, l, m, r)
SENTINEL = float('inf')
n = int(input())
A = list(map(int, input().split()))
count = 0
merge_sort(A, 0, len(A))
print(" ".join(map(str, A)))
print(count) | 1 | 109,623,676,808 | null | 26 | 26 |
for i in range(1,10001):
n = int(input())
if n:
print(f'Case {i}: {n}')
| case = 0
while 1:
case += 1
n = int(input())
if n == 0: break
print("Case {}: {}".format(case, n)) | 1 | 486,653,738,890 | null | 42 | 42 |
K = int(input())
A,B = map(int, input().split())
lst = list(range(A, B + 1))
for i in lst:
if(i % K == 0):
print("OK")
break
else:
print("NG") | S = list(input())
front_S = S[:(len(S)//2)]
S.reverse()
back_S=S[:(len(S)//2)]
count = 0
for i,j in zip(front_S,back_S):
if(i!=j):
count+=1
print(count) | 0 | null | 73,691,987,435,120 | 158 | 261 |
n = int(input())
cnt=0
for _ in range(n):
a,b=map(int,input().split())
if a==b:
cnt+=1
if cnt>=3:
break
else:
cnt=0
if cnt>=3:
print("Yes")
else:
print("No") | n = int(input())
f = 0
L = []
for i in range(n):
a,b = map(int, input().split())
L.append([a,b])
for i in range(2,n):
if(L[i-2][0] == L[i-2][1] and L[i-1][0] == L[i-1][1] and L[i][0] == L[i][1]):
f = 1
break
if(f):
print('Yes')
else:
print('No') | 1 | 2,506,571,743,930 | null | 72 | 72 |
def atc_158a(input_value: str) -> str:
if input_value == "AAA" or input_value == "BBB":
return "No"
return "Yes"
input_value = input()
print(atc_158a(input_value)) | def func(l):
i = 0
for num in range(l[0], l[1]+1):
#print(num)
if l[2] % num == 0:
#print(num)
i = i + 1
return i
if __name__ == '__main__':
N = input().split(" ")
l = []
for i in N:
l.append(int(i))
result = func(l)
print(result) | 0 | null | 27,647,659,842,188 | 201 | 44 |
s = input()
ans = ["x"] * len(s)
print(*ans,sep="") | t = input()
leng = len(t)
print('x' * leng) | 1 | 72,875,176,241,440 | null | 221 | 221 |
H,W = map(int,input().split())
grid = [[0] for _ in range(H)]
for i in range(H):
grid[i] = input()
dp = [[float('inf')]*W for _ in range(H)]
if grid[0][0] == '.':
dp[0][0] = 0
else:
dp[0][0] = 1
for y in range(H):
for x in range(W):
if x > 0:
if grid[y][x-1] == '.' and grid[y][x] == '#':
dp[y][x] = min(dp[y][x],dp[y][x-1]+1)
else:
dp[y][x] = min(dp[y][x],dp[y][x-1])
if y > 0:
if grid[y-1][x] == '.' and grid[y][x] == '#':
dp[y][x] = min(dp[y][x],dp[y-1][x]+1)
else:
dp[y][x] = min(dp[y][x],dp[y-1][x])
print(dp[-1][-1]) | import itertools,sys
def S(): return sys.stdin.readline().rstrip()
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
H,W = LI()
S = [S() for _ in range(H)]
dp = [[float('INF')]*W for _ in range(H)]
for i,j in itertools.product(range(H),range(W)):
if i==0:
if j==0:
dp[i][j] = 1 if S[i][j]=='#' else 0
else:
dp[i][j] = dp[i][j-1]+(1 if S[i][j]=='#' and S[i][j-1]=='.' else 0)
else:
if i==0:
dp[i][j] = dp[i-1][j]+(1 if S[i][j]=='#' and S[i-1][j]=='.' else 0)
else:
dp[i][j] = min(dp[i][j],dp[i][j-1]+(1 if S[i][j]=='#' and S[i][j-1]=='.' else 0))
dp[i][j] = min(dp[i][j],dp[i-1][j]+(1 if S[i][j]=='#' and S[i-1][j]=='.' else 0))
print(dp[-1][-1])
| 1 | 49,279,267,658,180 | null | 194 | 194 |
def answer(n: int, k: int) -> int:
digits = 0
while 0 < n:
n //= k
digits += 1
return digits
def main():
n, k = map(int, input().split())
print(answer(n, k))
if __name__ == '__main__':
main() | n=int(input())
A=list(map(int,input().split()))
B=list(map(int,input().split()))
for i in range(1,4):
cnt=0
for j in range(n):
cnt+=abs(A[j]-B[j])**i
print(cnt**(1/i))
cnt=0
for j in range(n):
cnt=max(cnt,abs(A[j]-B[j]))
print(cnt)
| 0 | null | 32,073,929,003,532 | 212 | 32 |
s = input()
ans = 0
if s[0] == "R":
ans += 1
if s[1] == "R":
ans += 1
if s[2] == "R":
ans += 1
elif s[1] == "R":
ans += 1
if s[2] == "R":
ans += 1
elif s[2] == "R":
ans += 1
print(ans) | s = int(input())
print((1000-s%1000)%1000) | 0 | null | 6,666,063,698,334 | 90 | 108 |
def selectionSort(a):
count = 0
for i in range(len(a)):
mini = i
for j in range(i,len(a)):
if a[j] < a[mini]:
mini = j
if i != mini:
ret = a[i]
a[i] = a[mini]
a[mini] = ret
count += 1
print(" ".join(map(str,a)))
print(count)
n = int(input())
a = list(map(int,input().split()))
selectionSort(a) | x = list(map(int,input().split()))
x.reverse()
a = x.index(0)
if a == 4:
print(x[a-1]-1)
else:
print(x[a+1]+1)
| 0 | null | 6,711,865,435,140 | 15 | 126 |
def my_print(s: str, args: [int]) -> str:
return s[int(args[0]): int(args[1]) + 1]
def my_reverse(s: str, args: list) -> str:
start = int(args[0])
end = int(args[1]) + 1
to_reverse_string = s[start:end]
return s[:start] + to_reverse_string[::-1] + s[end:]
def my_replace(s: str, args: list) -> str:
start = int(args[0])
end = int(args[1]) + 1
return s[:start] + args[2] + s[end:]
def resolve():
s = input()
n = int(input())
for _ in range(n):
f, *args = input().split()
if f == 'print':
print(my_print(s, args))
if f == 'reverse':
s = my_reverse(s, args)
if f == 'replace':
s = my_replace(s, args)
resolve()
| from collections import Counter, defaultdict
import sys
sys.setrecursionlimit(10 ** 5 + 10)
# input = sys.stdin.readline
from math import factorial
import heapq, bisect
import math
import itertools
import queue
from collections import deque
from fractions import Fraction
def main():
a, b , c = map(int, input().split())
if a / c <= b:
print("Yes")
else:
print("No")
if __name__ == '__main__':
main()
| 0 | null | 2,864,005,485,972 | 68 | 81 |
def countABC(n, s):
return s.count("ABC")
def main():
n = int(input())
s = str(input())
print(countABC(n, s))
if __name__ == '__main__':
main() | from queue import deque
h,w = map(int,input().split())
li = [input() for _ in range(h)]
inf = 10**10
dx = [1,0]
dy = [0,1]
que = deque()
#そのマスにたどり着くまでに色が変わった最小の回数を保存するリスト
flip_count = [[inf for i in range(w)]for j in range(h)]
if li[0][0] == "#":
flip_count[0][0] = 1
else:
flip_count[0][0] = 0
que.append([0,0])
while que:
k = que.popleft()
x = k[0]
y = k[1]
for i,j in zip(dx,dy):
nx = x + i
ny = y + j
if nx >= w or ny >= h:
continue
if flip_count[ny][nx] == inf:
que.append([nx,ny])
if li[ny][nx] != li[y][x]:
flip_count[ny][nx] = min(flip_count[ny][nx],flip_count[y][x]+1)
else:
flip_count[ny][nx] = min(flip_count[ny][nx],flip_count[y][x])
if li[-1][-1] == "#":
flip_count[-1][-1] += 1
print(flip_count[-1][-1]//2) | 0 | null | 74,524,455,043,400 | 245 | 194 |
# Problem D - String Equivalence
from collections import deque
# input
N = int(input())
char_list = [chr(i) for i in range(97, 97+26)]
def dfs(a_list, a_len):
if a_len==N:
print("".join(a_list))
return
else:
biggest = 97
count = len(set(a_list)) # N<=10だからさほど時間はかからない
for c in range(biggest, biggest + count + 1):
ch = chr(c)
a_list.append(ch)
dfs(a_list, a_len+1)
a_list.pop()
# initialization
a_nums = deque([])
# dfs search
dfs(a_nums, 0)
| N = int(input())
s = "a"
ans = []
def dfs(s,n):
if len(s) == n:
ans.append(s)
return
last = 0
for i in range(len(s)):
last = max(last,ord(s[i]))
limit = chr(last+1)
for i in range(26):
temp = chr(97+i)
if temp <= limit:
dfs(s+temp,n)
dfs(s,N)
print(*ans,sep="\n") | 1 | 52,097,696,052,194 | null | 198 | 198 |
def f(n):
ans=1
while n!=0:
ans+=1
n%=bin(n).count("1")
return ans
n=int(input())
x=input()
o=x.count("1")
if o==0:exit(print(*[1]*n))
if o==1:
if x[-1]=="1":
ans=[2]*n
ans[-1]=0
else:
ans=[1]*n
ans[-1]=2
ans[x.index("1")]=0
exit(print(*ans))
mo=0
mz=0
for i in range(n):
if x[n-i-1]=="1":
mo=(pow(2,i,o+1)+mo)%(o+1)
mz=(pow(2,i,o-1)+mz)%(o-1)
for i in range(n):
if x[i]=="1":
m=(mz-pow(2,n-i-1,o-1))%(o-1)
else:
m=(mo+pow(2,n-i-1,o+1))%(o+1)
print(f(m)) | N=int(input())
A=list(map(int,input().split()))
ans=1
if A.count(0)>0:
ans=0
for i in range(N):
ans*=A[i]
if ans>10**18:
ans=-1
break
print(ans) | 0 | null | 12,097,801,724,360 | 107 | 134 |
#coding:utf-8
import sys
abc=sys.stdin.readline()
nums=abc.split( ' ' )
for i in range( len( nums) ):
nums[i] = int( nums[i] )
nums.sort()
print( "{} {} {}".format( nums[0], nums[1], nums[2] ) ) | a, b, c = raw_input().split()
def ITP1(a, b, c):
if (a <= b):
if (b <= c):
print a, b, c
return
if (c <= b):
if (c <= a):
print c, a, b
return
if (a <= c):
print a, c, b
return
if (b <= a):
if (a <= c):
print b, a, c
return
if (c <= a):
if (c <= b):
print c, b, a
return
if (b <= c):
print b, c, a
return
ITP1(a, b, c) | 1 | 417,691,292,612 | null | 40 | 40 |
k=int(input())
a,b=map(int,input().split())
print("OK" if (a-1)//k!=b//k else"NG") | K=int(input())
A,B=map(int, input().split())
cnt=0
for i in range(B//K+1):
if A<=K*i and K*i<=B:
cnt+=1
print('OK' if cnt>0 else 'NG') | 1 | 26,661,195,365,348 | null | 158 | 158 |
from math import ceil,floor,factorial,gcd,sqrt,log2,cos,sin,tan,acos,asin,atan,degrees,radians,pi,inf
from itertools import accumulate,groupby,permutations,combinations,product,combinations_with_replacement
from collections import deque,defaultdict,Counter
from bisect import bisect_left,bisect_right
from operator import itemgetter
from heapq import heapify,heappop,heappush
from queue import Queue,LifoQueue,PriorityQueue
from copy import deepcopy
from time import time
from functools import reduce
import string
import sys
sys.setrecursionlimit(10 ** 7)
def input() : return sys.stdin.readline().strip()
def INT() : return int(input())
def MAP() : return map(int,input().split())
def MAP1() : return map(lambda x:int(x)-1,input().split())
def LIST() : return list(MAP())
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
def solve():
N, M, K = MAP()
F = [[] for _ in range(N)]
B = [[] for _ in range(N)]
uf = UnionFind(N) # 初期化
for i in range(M):
a, b = MAP()
F[a-1].append(b-1)
F[b-1].append(a-1)
uf.union(a-1, b-1) # グループを併合
for i in range(K):
c, d = MAP()
B[c-1].append(d-1)
B[d-1].append(c-1)
for i in range(N):
ans = uf.size(i) - len(F[i]) - 1
for x in B[i]:
if uf.same(i, x):
ans -= 1
print(ans)
if __name__ == '__main__':
solve() | m, d = input().split(' ')
M, D = input().split(' ')
if D == '1':
print(1)
else:
print(0) | 0 | null | 93,087,451,369,560 | 209 | 264 |
# coding=utf-8
def fib(number):
if number == 0 or number == 1:
return 1
memo1 = 1
memo2 = 1
for i in range(number-1):
memo1, memo2 = memo1+memo2, memo1
return memo1
if __name__ == '__main__':
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 | 1,957,290,370 | null | 7 | 7 |
num = int(input())
table = list(map(int, input().split()))
table2 = []
for i in range(num):
table2.append(0)
for j in range(len(table)):
table2[table[j]-1] += 1
for k in table2:
print(k) | import sys
def resolve(in_, out):
n = int(in_.readline())
b = [0] * (n + 1)
for a in map(int, in_.readline().split()):
b[a] += 1
out.write('\n'.join(map(str, b[1:])))
def main():
resolve(sys.stdin.buffer, sys.stdout)
if __name__ == '__main__':
main() | 1 | 32,475,051,618,520 | null | 169 | 169 |
from collections import defaultdict
h,w,m = map(int,input().split())
dh = defaultdict(int)
dw = defaultdict(int)
l=defaultdict(tuple)
for _ in range(m):
x,y = map(int,input().split())
dh[x]+=1
dw[y]+=1
l[(x,y)]=1
m = 0
for i in range(1,h+1):
if dh[i]>m:
m = dh[i]
hi=i
c=m
m = 0
for i in range(1,w+1):
d = dw[i]
if l[(hi,i)]==1:
d-=1
m = max(m,d)
c+=m
m = 0
wi=0
for i in range(1,w+1):
if dw[i]>m:
m = dw[i]
wi=i
c2=m
m = 0
for i in range(1,h+1):
d = dh[i]
if l[(i,wi)]==1:
d-=1
m = max(m,d)
c2+=m
print(max(c,c2)) | H, W, M = map(int, input().split())
h = [0 for _ in range(H+1)]
w = [0 for _ in range(W+1)]
hmax = 0
wmax = 0
Q = []
for _ in range(M):
a, b = map(int, input().split())
Q.append((a, b))
h[a] += 1
hmax = max(hmax, h[a])
w[b] += 1
wmax = max(wmax, w[b])
h_ok = False
w_ok = False
hm = [False for _ in range(H+1)]
wm = [False for _ in range(W+1)]
h_cnt = 0
w_cnt = 0
hw_cnt = 0
for a, b in Q:
if not hm[a] and h[a] == hmax:
hm[a] = True
h_cnt += 1
if not wm[b] and w[b] == wmax:
wm[b] = True
w_cnt += 1
if h[a] == hmax and w[b] == wmax:
hw_cnt += 1
if h_cnt*w_cnt - hw_cnt > 0:
print(hmax+wmax)
else:
print(hmax+wmax-1)
| 1 | 4,762,896,397,600 | null | 89 | 89 |
def rollDice(dice, direction):
buf = [x for x in dice]
if direction == "S":
buf[0] = dice[4]
buf[1] = dice[0]
buf[4] = dice[5]
buf[5] = dice[1]
elif direction == "E":
buf[0] = dice[3]
buf[2] = dice[0]
buf[3] = dice[5]
buf[5] = dice[2]
elif direction == "W":
buf[0] = dice[2]
buf[2] = dice[5]
buf[3] = dice[0]
buf[5] = dice[3]
elif direction == "N":
buf[0] = dice[1]
buf[1] = dice[5]
buf[4] = dice[0]
buf[5] = dice[4]
for i in range(6):
dice[i] = buf[i]
def rollDiceSide(dice):
buf = [x for x in dice]
buf[1] = dice[2]
buf[2] = dice[4]
buf[3] = dice[1]
buf[4] = dice[3]
for i in range(6):
dice[i] = buf[i]
d = list(map(int, input().split()))
n = int(input())
for i in range(n):
q1, q2 = list(map(int, input().split()))
wq = d.index(q1)
if wq == 1:
rollDice(d, "N")
elif wq == 2:
rollDice(d, "W")
elif wq == 3:
rollDice(d, "E")
elif wq == 4:
rollDice(d, "S")
elif wq == 5:
rollDice(d, "S")
rollDice(d, "S")
wq = d.index(q2)
if wq == 2:
rollDiceSide(d)
elif wq == 3:
rollDiceSide(d)
rollDiceSide(d)
rollDiceSide(d)
elif wq == 4:
rollDiceSide(d)
rollDiceSide(d)
print(d[2])
| X, N=map(int, input().split())
if N==0:print(X);exit()
p=sorted(list(map(int, input().split())))
m=X;i=0
for i in range(m,min(p)-2,-1):
if i not in p:break
M=X;j=0
for j in range(M,max(p)+2):
if j not in p:break
if abs(i-X)==abs(j-X):print(min(i,j))
elif abs(i-X)<abs(j-X):
print(i)
else:print(j) | 0 | null | 7,239,136,337,260 | 34 | 128 |
a,b=map(int,input().split())
print(a//b,a%b,"{0:10.20f}".format(a/b)) | S=input()
n=len(S)
print("Yes" if S=="hi"*(n//2) else "No")
| 0 | null | 27,006,590,080,070 | 45 | 199 |
import itertools
import sys
sys.setrecursionlimit(10**9)
def mi(): return map(int,input().split())
def ii(): return int(input())
def isp(): return input().split()
def deb(text): print("-------\n{}\n-------".format(text))
# x1+x2+x3+...xN = X (x>=0)
def nHk_list(N,X):
if N == 0: return []
elif N == 1: return [[X]]
border = [i for i in range(X+1)]
res = []
for S in itertools.combinations_with_replacement(border, N-1):
# print(S)
pre = 0
sub = []
for s in S:
sub.append(s-pre)
pre = s
sub.append(X-pre)
res.append(sub)
return res
INF=10**20
def main():
N=ii()
alphabet = ["a","b","c","d","e","f","g","h","i","j"]
ans = []
for c in range(1,N+1):
# print("___\nc",c)
for X in nHk_list(c,N-c):
# print("X:",X,"c:",c,"N-c:",N-c)
V = []
for i in range(len(X)):
x = X[i]
V.append(list(itertools.product(alphabet[:i+1],repeat=x)))
# print("V",V)
U = itertools.product(*V)
base = alphabet[:c]
for u in U:
char = ""
for i in range(c):
char += alphabet[i] + "".join(list(u[i]))
ans.append(char)
ans.sort()
# ans.append("".join(alphabet[:N]))
print(*ans,sep='\n')
if __name__ == "__main__":
main() | import bisect
n = int(input())
a = list(map(int,input().split()))
# ni - nj = ai + aj (i>j)
# ai - ni = - aj - nj
a1 = sorted([a[i] - (i+1) for i in range(n)])
a2 = sorted([- a[i] - (i+1) for i in range(n)])
ans = 0
for i in range(n):
left = bisect.bisect_left(a2, a1[i])
right = bisect.bisect_right(a2, a1[i])
ans += (right - left)
print(ans) | 0 | null | 39,242,269,855,630 | 198 | 157 |
while 1:
try:
a,b=map(int,input().split())
print(len(str(a+b)))
except:
break | n = int(input())
ans = (n + 1) * n // 2
for i in range(2, n + 1):
j = 1
while i * j <= n:
ans += i * j
j += 1
print(ans)
| 0 | null | 5,577,290,374,588 | 3 | 118 |
num=int(input())
r_1=int(input())
r_2=int(input())
max_profit=r_2-r_1
if r_1<r_2:
min_value=r_1
else:
min_value=r_2
for i in range(2,num):
x=int(input())
t=x-min_value
if max_profit<t:
max_profit=t
if x<min_value:
min_value=x
print(max_profit) | # -*- coding: utf-8 -*-
def maximum_profit(profits):
max_v = profits[1] - profits[0]
min_v = profits[0]
for j in range(1, len(profits)):
max_v = max(max_v, profits[j]-min_v)
min_v = min(min_v, profits[j])
print(max_v)
def to_int(v):
return int(v)
if __name__ == '__main__':
l = to_int(input())
profits = [to_int(input()) for i in range(l)]
maximum_profit(profits) | 1 | 13,451,941,368 | null | 13 | 13 |
n = int(input())
a = list(map(int, input().split()))
x = 0
for ai in a:
x ^= ai
for ai in a:
print(x ^ ai, end=' ') | from functools import reduce
from operator import xor
# via https://drken1215.hatenablog.com/entry/2020/06/22/122500
N, *A = map(int, open(0).read().split())
B = reduce(xor, A)
print(*map(lambda a: B^a, A)) | 1 | 12,600,721,515,648 | null | 123 | 123 |
n = int(input())
P = list(map(int, input().split()))
minSoFar = 2 * 10**5 + 1
ans = 0
for i in range(n):
if P[i] < minSoFar:
ans += 1
minSoFar = min(minSoFar, P[i])
print(ans) | N = int(input())
P = list(map(int, input().split()))
c = 10 ** 20
con = 0
for i in range(N):
if c > P[i]:
con += 1
c = P[i]
print(con)
| 1 | 85,445,871,516,958 | null | 233 | 233 |
def med(l):
t = len(l)
if t%2:
return l[t//2]
else: return (l[t//2]+l[t//2-1])/2
n = int(input())
a = []
b = []
for i in range(n):
x,y = map(int,input().split())
a+=[x]
b+=[y]
a.sort()
b.sort()
if n%2==0:
print(int((med(b)-med(a))*2)+1)
else:
print(med(b)-med(a)+1)
| N = int(input())
A, B = [], []
for i in range(N):
a, b = map(int, input().split())
A.append(a)
B.append(b)
A.sort()
B.sort()
if N % 2 == 1:
M = B[N // 2]
m = A[N // 2]
print(M - m + 1)
else:
M = (B[N // 2 - 1] + B[N // 2]) / 2
m = (A[N // 2 - 1] + A[N // 2]) / 2
print(int((M - m + 0.5) * 2))
| 1 | 17,354,267,888,882 | null | 137 | 137 |
n = int(input())
v = [[tuple(map(int, input().split()))for i in range(int(input()))]
for i in range(n)]
ans = 0
for i in range(2**n):
f = True
a = 0
for j in range(n):
if (i >> j) & 1:
if all(i >> (x - 1) & 1 == y for x, y in v[j]):
a += 1
else:
f = False
break
if f:
ans = max(ans, a)
print(ans)
| input()
s = set(map(int,input().split()))
n = int(input())
t = tuple(map(int,input().split()))
c = 0
for i in range(n):
if t[i] in s:
c += 1
print(c) | 0 | null | 60,759,122,353,552 | 262 | 22 |
x,y = list(input().split())
x = int(x)
y = int(y[0]+y[2]+y[3])
print(x*y//100) | import decimal as d
a,b=input().split()
print(int(int(a)*d.Decimal(b))) | 1 | 16,454,304,679,250 | null | 135 | 135 |
def INT():
return int(input())
def MI():
return map(int, input().split())
def LI():
return list(map(int, input().split()))
S = input()
if S[len(S) - 1] == "s":
S += "es"
else:
S += "s"
print(S) | n, x, y = map(int,input().split())
x, y = x-1, y-1
d=[0 for i in range(n)]
for i in range(n):
for j in range(i+1,n):
m = min(abs(i-j), abs(x-i)+abs(y-j)+1, abs(x-j)+abs(y-i)+1)
d[m] += 1
for i in range(n-1):
print(d[i+1]) | 0 | null | 23,125,206,764,970 | 71 | 187 |
# https://atcoder.jp/contests/abc165/tasks/abc165_c
from itertools import combinations_with_replacement
N, M, Q = map(int, input().split())
data = []
for _ in range(Q):
data.append(list(map(int, input().split())))
res = []
for A in combinations_with_replacement(range(1,M+1), N):
score = 0
for i in range(Q):
a,b,c,d = data[i]
if A[b-1] - A[a-1] == c:
score += d
res.append(score)
print(max(res)) | import os, sys, re, math
import itertools
N = int(input())
P = tuple([int(n) for n in input().split()])
Q = tuple([int(n) for n in input().split()])
nums = [n for n in range(1, N + 1)]
patterns = itertools.permutations(nums, N)
i = 0
for pattern in patterns:
if pattern == P:
pi = i
if pattern == Q:
qi = i
i += 1
print(abs(pi - qi)) | 0 | null | 64,004,411,825,982 | 160 | 246 |
import sys, bisect, math, itertools, string, queue, copy
# import numpy as np
# import scipy
# from collections import Counter,defaultdict,deque
# from itertools import permutations, combinations
# from heapq import heappop, heappush
# # input = sys.stdin.readline
# sys.setrecursionlimit(10**8)
# mod = 10**9+7
def inp(): return int(input())
def inpm(): return map(int,input().split())
def inpl(): return list(map(int, input().split()))
def inpls(): return list(input().split())
def inplm(n): return list(int(input()) for _ in range(n))
def inplL(n): return [list(input()) for _ in range(n)]
def inplT(n): return [tuple(input()) for _ in range(n)]
def inpll(n): return [list(map(int, input().split())) for _ in range(n)]
def inplls(n): return sorted([list(map(int, input().split())) for _ in range(n)])
n = inp()
s = input()
ans = ''
for t in s:
st = ord(t) + n
if(st > ord('Z')):
st = ord('A') + st - ord('Z') - 1
ans = ''.join([ans, chr(st)])
print(ans)
| N = int(input())
S = list(input())
M = len(S)
A = [""]*M
for i in range(M):
ref = 65 + (ord(S[i]) + N - 65) % 26
A[i] = chr(ref)
ans = "".join(A)
print(ans) | 1 | 134,952,690,997,296 | null | 271 | 271 |
def baseConv(n,ro,ri=10):
n = int(str(n),base=ri)
s = ""
nums = "0123456789abcdefghijklmnopqrstuvwxyz"
while n:
s += nums[n%ro]
n //= ro
return s[::-1]
n,k = map(int,input().split())
print(len(baseConv(n,k))) | N,K=map(int,input().split())
i=0
while True:
if N<K**i:
print(i)
break
i+=1 | 1 | 64,548,747,299,488 | null | 212 | 212 |
N = int(input())
S = input()
for s in S:
print(chr(65+(ord(s)+N-65)%26),end="") | n = int(input())
s = input()
sl = list(s)
answer = ""
for i in s:
t = ord(i)+n
if t <= 90:
answer += chr(t)
else :
answer += chr(ord("A") + abs(t-90)-1)
print(answer) | 1 | 134,664,467,546,740 | null | 271 | 271 |
n=int(input())
x,y=[list(map(int,input().split()))for _ in range(2)]
d=[abs(s-t)for s,t in zip(x,y)]
f=lambda n:sum([s**n for s in d])**(1/n)
print(f(1),f(2),f(3),max(d),sep='\n')
| from math import *
n = input()
x = map(float, raw_input().split())
y = map(float, raw_input().split())
for i in range(1,4):
temp = 0
for j in range(n):
temp += fabs(x[j]-y[j])**i
print pow(temp,1.0/i)
d = 0
for i in range(n):
if(fabs(x[i]-y[i]) > d):
d = fabs(x[i]-y[i])
print d | 1 | 214,867,041,510 | null | 32 | 32 |
N=int(input())
num = 7
i=1
a=[]
prir1=1
while i<=N:
xx=num%N
if xx==0:
print(i)
prir1=0
break
num=10*xx+7
i+=1
if prir1:
print(-1) | K = int(input())
s = 7
flg = False
cnt = 0
for i in range(K+1):
cnt += 1
if s % K == 0:
flg = True
break
s *= 10
s %= K
s += 7
if flg:
print(cnt)
else:
print(-1)
| 1 | 6,166,913,153,540 | null | 97 | 97 |
x = input()
print(x ** 3) | x = input()
print "%d" % (x ** 3) | 1 | 274,904,396,882 | null | 35 | 35 |
H = int(input())
W = int(input())
N = int(input())
tmp1 = min(H, W)
tmp2 = max(H, W)
for i in range(tmp1):
N = N - tmp2
if N <= 0:
print(i + 1)
break | H = int(input())
W = int(input())
N = int(input())
r = (N +max(H, W)-1)//max(H, W)
print(r)
| 1 | 88,419,561,045,882 | null | 236 | 236 |
a, b, m = map(int, input().split())
list_a = list(map(int, input().split()))
list_b = list(map(int, input().split()))
total = min(list_a) + min(list_b)
for i in range(m):
x, y, c = map(int, input().split())
price = list_a[x - 1] + list_b[y - 1] - c
total = min(price, total)
print(total)
| N = int(input())
A = list(map(int,input().split()))
a = 0
for i in range(1, N):
b = A[i]-A[i-1]
if b < 0:
A[i] = A[i-1]
a -= b
print(a) | 0 | null | 29,320,162,388,832 | 200 | 88 |
import itertools
##print(ord("A"))
a,b,= map(int,input().split())
ans= a-b*2
if ans <=0:
print(0)
else:
print(ans) | def main():
H, W, M = [int(s) for s in input().split()]
cols = [0] * W
rows = [0] * H
bombs = set()
for _ in range(M):
x, y = [int(s)-1 for s in input().split()]
bombs.add((x, y))
cols[y] += 1
rows[x] += 1
sc = sorted([(c, i) for i, c in enumerate(cols)], reverse=True)
sr = sorted([(c, i) for i, c in enumerate(rows)], reverse=True)
best = 0
for v1, c in sc:
for v2, r in sr:
if v1 + v2 <= best:
break
score = v1 + v2
if (r, c) in bombs:
score -= 1
best = max(best, score)
print(best)
main() | 0 | null | 85,672,162,882,840 | 291 | 89 |
import bisect
def resolve():
n = int(input())
l = sorted(list(map(int,input().split())))
ans = 0
for a in range(n):
for b in range(a+1,n):
c = bisect.bisect_left(l,l[a]+l[b])
if c > b:
ans += c-b-1
else:
pass
print(ans)
resolve() | from bisect import bisect_left
n = int(input())
L = sorted(list(map(int, input().split())))
# 二分探索
cnt = 0
for i in range(n):
for j in range(i+1, n):
a, b = L[i], L[j]
# c < a + b
r = bisect_left(L, a+b)
l = j+1
cnt += max(0, r-l)
print(cnt) | 1 | 171,649,245,364,960 | null | 294 | 294 |
H=int(input())
m=1
while (m<=H):
m*=2
print(m-1) | n=int(input())
i=1
c=0
while(n>=1):
c+=i
i*=2
n//=2
print(c)
| 1 | 80,312,649,075,680 | null | 228 | 228 |
s = int(input())
mod = 10**9+7
dp = [0]*(s+1)
dp[0] = 1
for i in range(1,s+1):
for j in range(0,(i-3)+1):
dp[i] += dp[j]
dp[i] %= mod
print(dp[s]) | def function(n):
if n < 3:
lis.append(0)
elif 3 <= n < 6:
lis.append(1)
else:
lis.append(lis[n-1] + lis[n-3])
def recri(s):
for n in range(s):
function(n)
# for n in range(20):
# print(function(n))
if __name__ == '__main__':
lis = []
s = int(input()) + 1
recri(s)
print(lis[s-1]%(10 ** 9 + 7)) | 1 | 3,261,913,837,820 | null | 79 | 79 |
n_turn = int(input())
t_point = h_point = 0
for i in range(n_turn):
t_card, h_card = input().split()
if t_card > h_card:
t_point += 3
elif t_card == h_card:
t_point += 1
h_point += 1
else:
h_point += 3
print("{} {}".format(t_point, h_point)) | point_a,point_b = 0,0
for i in range(int(input())):
k =[]
a,b = input().split()
k = [[i,j] for i,j in zip(a,b) if i != j]
if k == []:
if len(a) < len(b):
point_b+=3
elif len(a) > len(b):
point_a += 3
else:
point_a+=1
point_b+=1
elif ord(k[0][0]) < ord(k[0][1]):
point_b += 3
else :
point_a += 3
print(point_a,point_b) | 1 | 1,997,425,393,912 | null | 67 | 67 |
# -*- coding: utf-8 -*-
n = int(input())
st = []
for i in range(n):
st.append([str(i) for i in input().split()])
x = str(input())
tmp = 0
i = 0
while True:
if st[i][0] == x:
tmp += int(st[i][1])
break
else:
tmp += int(st[i][1])
i += 1
sum_t = 0
for i in range(n):
sum_t += int(st[i][1])
print(sum_t - tmp)
| #k = int(input())
#s = input()
#a, b = map(int, input().split())
#s, t = map(str, input().split())
#l = list(map(int, input().split()))
#l = [list(map(int,input().split())) for i in range(n)]
#a = [input() for _ in range(n)]
N = int(input())
seq = list(map(int, input().split()))
s = 0
for i in range(N):
s += seq[i]
s2 =0
for i in range(N):
s2 += seq[i]**2
s0 = (s**2 -s2)//2
print(s0%(10**9+7))
| 0 | null | 50,351,041,878,202 | 243 | 83 |
print((int(input())**2)) | # string
# a, b, c = input().split()
# str_list = list(input().split())
# number
# a, b, c = map(int, input().split())
# num_list = list(map(int, input().split()))
# lows
# str_list = [input() for _ in range(n)]
# many inputs
# num_list = []
# for i in range(n): num_list.append(list(map(int, input().split())))
x, k, d = map(int, input().split())
if x < 0:
x = -x
l = int(x/d)
if l < k:
print(abs(x - ((k-l)%2 + l) * d))
else:
print(abs(x - k*d)) | 0 | null | 75,276,500,174,968 | 278 | 92 |
f = open(0)
N, M, L = map(int, f.readline().split())
A = [list(map(int, f.readline().split())) for i in range(N)]
B = [list(map(int, f.readline().split())) for i in range(M)]
C = [[0]*L for i in range(N)]
for i in range(N):
for j in range(L):
C[i][j] = str(sum(A[i][k]*B[k][j] for k in range(M)))
for line in C:
print(*line)
| n, m, l = map(int, input().split()) # n = 3, c = 2, l = 3
a_matrix = [list(map(int, input().split())) for row in range(n)] # [[1, 2], [0, 3], [4, 5]]
b_matrix = [list(map(int, input().split())) for row in range(m)] # [[1, 2, 1], [0, 3, 2]]
result_matrix = [[0 for x in range(l)] for y in range(n)] # [[0, 0, 0], [0, 0, 0], [0, 0, 0]]
for i in range(n):
for j in range(l):
for k in range(m):
result_matrix[i][j] += a_matrix[i][k] * b_matrix[k][j]
for i in range(n):
print(' '.join(map(str, result_matrix[i]))) | 1 | 1,432,939,520,480 | null | 60 | 60 |
import sys
input = sys.stdin.readline
N = int(input())
A = list(map(int, input().split()))
A.sort(reverse=True)
l = [A[0]]
for i in range(1, N):
l.append(A[i])
l.append(A[i])
print(sum(l[:N-1])) | n = int(input())
al = list(map(int, input().split()))
al.sort(reverse=True)
ans = al[0]
for i in range(n-2):
ans += al[i//2+1]
print(ans) | 1 | 9,109,793,672,916 | null | 111 | 111 |
def main(R,C,K,V):
dp = [0]*(4*R*C)
dp[1+4*0+4*C*0] = V[0][0]
for k in range(4*R*C):
n = k%4
j = k//4%C
i = k//(4*C)
if n!=0:
if i != 0 and n==1:
dp[k] = max(dp[k-4*C-n:k-4*C-n+4])+V[i][j]
if j != 0:
dp[k] = max(dp[k],dp[k-4],dp[k-5]+V[i][j])
if n==0:
if i != 0:
dp[k] = max(dp[k-4*C-n:k-4*C-n+4])
print(max(dp[-5:-1]))
if __name__ == '__main__':
R,C,K = map(int,input().split())
C += 1
rcv = [list(map(int,input().split())) for _ in range(K)]
V = [[0]*C for _ in range(R)]
for i in range(K):
r,c,v = rcv[i]
r -= 1
c -= 1
V[r][c] = v
main(R,C,K,V) | N = int(input())
Stones = list(input())
count_red = 0
count_white = 0
for i in range(N):
if Stones[i] == "R":
count_red += 1
for i in range(count_red):
if Stones[i] == "W":
count_white += 1
print(count_white) | 0 | null | 5,906,464,497,190 | 94 | 98 |
def II(): return int(input())
def LII(): return list(map(int, input().split()))
n=II()
town=[LII() for _ in range(n)]
distance=0
for i in range(n-1):
for j in range(i+1,n):
[xi,yi]=town[i]
[xj,yj]=town[j]
distance += ((xi-xj)**2+(yi-yj)**2)**0.5
print(distance*2/n) | N = int(input())
n = input().split()
a = []
for i in range(N):
a.append(int(n[i]))
a = sorted(a)
print('{0} {1} {2}'.format(a[0], a[-1], sum(a))) | 0 | null | 74,284,253,351,168 | 280 | 48 |
import sys
W = input().lower()
T = sys.stdin.read().lower()
print(T.split().count(W)) | W=input()
count=0
while True:
text=input()
if text == 'END_OF_TEXT':
break
else:
ls = list(map(str, text.split()))
for s in ls:
if s.lower() == W.lower():
count += 1
print(count) | 1 | 1,805,378,468,820 | null | 65 | 65 |
n = int(input())
taro = 0
hanako = 0
for _ in range(n):
line = input().rstrip().split()
if line[0] > line[1]: taro += 3
elif line[0] < line[1]: hanako += 3
else:
taro += 1
hanako += 1
print(taro, hanako)
| N = int(input())
if (N - 1) % 2 == 0:
a = (N-1) / 2
print(int(a))
else:
b = N / 2 - 1
print(int(b)) | 0 | null | 77,602,577,395,460 | 67 | 283 |
x, y = [int(n) for n in input().split()]
while True:
tmp = x % y
if tmp == 0:
break
x, y = y, tmp
print(y) | import numpy as np
H, W = map(int,input().split())
if H == 1 or W == 1:
print(1)
else:
print(int(np.ceil((H * W) / 2))) | 0 | null | 25,545,811,435,468 | 11 | 196 |
ln = input().split()
print(ln[1]+ln[0]) | S,T = [i for i in input().split()]
print(T+S)
| 1 | 103,061,539,103,900 | null | 248 | 248 |
class Dice:
def __init__(self,l1,l2,l3,l4,l5,l6):
self.l1 = l1
self.l2 = l2
self.l3 = l3
self.l4 = l4
self.l5 = l5
self.l6 = l6
self.top = 1
self.front = 2
self.right = 3
def get_top(self):
return eval("self." + 'l' + str(self.top))
def move(self, order):
if order == 'S':
pretop = self.top
self.top = 7 - self.front
self.front = pretop
elif order == 'E':
pretop = self.top
self.top = 7 - self.right
self.right = pretop
elif order == 'N':
pretop = self.top
self.top = self.front
self.front = 7 - pretop
elif order == 'W':
pretop = self.top
self.top = self.right
self.right = 7 - pretop
l = list(map(int,input().split()))
orders = input()
d = Dice(l[0],l[1],l[2],l[3],l[4],l[5])
for order in orders:
d.move(order)
print(d.get_top()) | n=int(input())
s=100000
for i in range(n):
s=s*1.05
if s%1000==0:
s=s
else:
s=(s//1000)*1000+1000
print(int(s))
| 0 | null | 119,976,740,480 | 33 | 6 |
n=int(input())
a=list(map(int,input().split()))
M=10**9+7
cnt=[0]*n
ans=1
for i in range(n):
if a[i]==0:
cnt[a[i]]+=1
else:
ans*=(cnt[a[i]-1]-cnt[a[i]])
cnt[a[i]]+=1
ans%=M
for i in range(cnt[0]):
ans*=3-i
ans%=M
print(ans)
|
class dise:
def __init__(self, label):
self.label1 = label[0]
self.label2 = label[1]
self.label3 = label[2]
self.label4 = label[3]
self.label5 = label[4]
self.label6 = label[5]
def N_rotation(self):
reg = self.label1
self.label1 = self.label2
self.label2 = self.label6
self.label6 = self.label5
self.label5 = reg
def E_rotation(self):
reg = self.label1
self.label1 = self.label4
self.label4 = self.label6
self.label6 = self.label3
self.label3 = reg
def S_rotation(self):
reg = self.label1
self.label1 = self.label5
self.label5 = self.label6
self.label6 = self.label2
self.label2 = reg
def W_rotation(self):
reg = self.label1
self.label1 = self.label3
self.label3 = self.label6
self.label6 = self.label4
self.label4 = reg
dise1 = dise(input().split())
order = list(input())
for i in order:
if i == 'N':
dise1.N_rotation()
elif i == 'E':
dise1.E_rotation()
elif i == 'S':
dise1.S_rotation()
elif i == 'W':
dise1.W_rotation()
print(dise1.label1) | 0 | null | 64,986,481,753,590 | 268 | 33 |
u,s,e,w,n,b = list(map(int, input().split()))
rolls = input()
for roll in rolls:
if roll == 'N':
n,u,e,w,b,s = u,s,e,w,n,b
elif roll == 'S':
s,b,e,w,u,n = u,s,e,w,n,b
elif roll == 'E':
e,s,b,u,n,w = u,s,e,w,n,b
elif roll == 'W':
w,s,u,b,n,e = u,s,e,w,n,b
else:
print('Error')
raise(-1)
print(u) | l = list(map(int, input().split()))
s = input()
for c in s:
if c == "S":
l = [l[4], l[0], l[2], l[3], l[5], l[1]]
elif c == "N":
l = [l[1], l[5], l[2], l[3], l[0], l[4]]
elif c == "E":
l = [l[3], l[1], l[0], l[5], l[4], l[2]]
else:
l = [l[2], l[1], l[5], l[0], l[4], l[3]]
print(l[0])
| 1 | 234,908,521,948 | null | 33 | 33 |
inputted = list(map(int, input().split()))
K = inputted[0]
X = inputted[1]
total = 500 * K;
answer = 'Yes' if total >= X else 'No';
print(answer);
| n,k,c = map(int,input().split())
S = list(input())
L = [0]*k
nx = -1
cnt = 0
for i,s in enumerate(S):
if i <=nx: continue
if s =='o':
L[cnt] = i
nx = i + c
cnt += 1
if cnt ==k: break
R = [0]*k
nx = -1
cnt = 0
for i,s in enumerate(S[::-1]):
if i <=nx: continue
if s =='o':
R[cnt] = n-i-1
nx = i + c
cnt += 1
if cnt ==k: break
for l,r in zip(L,R[::-1]):
if l ==r:print(l+1) | 0 | null | 69,233,778,064,890 | 244 | 182 |
s,t=map(str,input().split())
a,b=map(int,input().split())
ss=input()
if ss==s:
a-=1
else:
b-=1
print(a,b) | N=input()
N=int(N)
q1, mod = divmod(N,2)
if mod == 0:
print(q1)
else:
print(q1 + 1) | 0 | null | 65,533,818,235,832 | 220 | 206 |
num = int(input())
hh = num // 3600
h2 = num % 3600
mm = h2 // 60
ss = h2 % 60
print(str(hh)+":"+str(mm)+":"+str(ss))
| s = int(raw_input())
print "%d:%d:%d" % (s / 3600, s / 60 % 60, s % 60) | 1 | 333,432,101,124 | null | 37 | 37 |
N = int(input())
*A, = map(int,input().split())
if N%2==0:
INF = 2* 10**9
dp = [[-INF]*N for _ in [0]*2]
dp[0][0] = A[0]
dp[1][1] = A[1]
for i in range(2,N,2):
a = A[i]
dp[0][i] = dp[0][i-2] + a
for i in range(3,N):
a = A[i]
dp[1][i] = max(dp[1][i-2],dp[0][i-3]) + a
print(max(dp[1][-1],dp[0][-2]))
else:
INF = 2* 10**9
dp = [[-INF]*N for _ in [0]*3]
dp[0][0] = A[0]
dp[1][1] = A[1]
dp[2][2] = A[2]
for i in range(2,N,2):
a = A[i]
dp[0][i] = dp[0][i-2] + a
for i in range(3,N):
a = A[i]
dp[1][i] = max(dp[1][i-2],dp[0][i-3]) + a
for i in range(4,N,2):
a = A[i]
dp[2][i] = max(dp[2][i-2],dp[1][i-3],dp[0][i-4]) + a
print(max(dp[2][-1],dp[1][-2],dp[0][-3])) | def find_primes(n):
ps = []
t = [True] * n
t[0] = t[1] = False
for i in range(2, n):
if not t[i]:
continue
ps.append(i)
for j in range(i, n, i):
t[j] = False
return ps
def solve(string):
n = int(string)
if n == 1:
return "0"
rn = int(n**0.5 + 1)
ps = find_primes(rn)
ans = 0
for i in ps:
k = 1
while n % (i**k) == 0:
ans += 1
n //= i**k
k += 1
return str(ans + (n >= rn))
if __name__ == '__main__':
import sys
print(solve(sys.stdin.read().strip()))
| 0 | null | 27,227,566,897,420 | 177 | 136 |
def resolve():
N, T = map(int, input().split())
AB = [list(map(int, input().split())) for _ in range(N)]
AB.sort()
dp = [[0] * (T + 1) for _ in range(N + 1)]
for i in range(N):
t, v = AB[i]
for j in range(T + 1):
if t + j <= T:
dp[i + 1][j + t] = max(dp[i + 1][j + t], dp[i][j] + v)
dp[i + 1][j] = max(dp[i + 1][j], dp[i][j])
ans = 0
for i, (t, v) in enumerate(AB):
ans = max(ans, dp[i][T - 1] + v)
print(ans)
if __name__ == "__main__":
resolve()
| def Qb():
a, b, c, k = map(int, input().split())
ra = min(k, a)
k -= ra
k -= b
rc = 0 if k <= 0 else -(min(k, c))
print(ra + rc)
if __name__ == '__main__':
Qb()
| 0 | null | 86,316,187,112,696 | 282 | 148 |
k = int(input())
a,b = [int(a) for a in input().split()]
c=0
for i in range (a,b+1):
if i%k!=0:
c+=1
if c==b-a+1:
print("NG")
else:
print("OK") |
def main():
k = int(input())
a, b = map(int, input().split())
flg = False
for i in range(a, b+1):
if i % k == 0:
print('OK')
flg = True
break
if not flg:
print('NG')
if __name__ == "__main__":
main()
| 1 | 26,537,040,000,352 | null | 158 | 158 |
K, X = [int(s) for s in input().split()]
print('Yes' if X <= K * 500 else 'No') | def resolve():
a,b = map(int, input().split())
if a*500 >= b:
print("Yes")
else:
print("No")
resolve() | 1 | 97,658,492,921,220 | null | 244 | 244 |
def merge(a,left,mid,right):
count=0
L=a[left:mid]+[float("inf")]
R=a[mid:right]+[float("inf")]
i,j=0,0
for k in range(left,right):
count+=1
if L[i]<=R[j]:
a[k]=L[i]
i+=1
else:
a[k]=R[j]
j+=1
return count
def mergeSort(a,left,right):
if left+1<right:
mid=(left+right)//2
countl=mergeSort(a,left,mid)
countr=mergeSort(a,mid,right)
return merge(a,left,mid,right)+countl+countr
return 0
n=int(input())
a=list(map(int,input().split()))
ans=mergeSort(a,0,n)
print(" ".join(map(str,a)))
print(ans)
| INF = 10000000000
def merge(A, left, mid, right):
global num
leftA = A[left:mid]
rightA = A[mid:right]
leftA.append(INF)
rightA.append(INF)
l = 0
r = 0
for i in range(left, right):
num += 1
if leftA[l] <= rightA[r]:
A[i] = leftA[l]
l += 1
else:
A[i] = rightA[r]
r += 1
def mergeSort(A, left, right):
if right - left < 2:
return
mid = left + (right - left) // 2
mergeSort(A, left, mid)
mergeSort(A, mid, right)
merge(A, left, mid, right)
if __name__ == "__main__":
n = int(input())
S = list(map(int, input().split()))
num = 0
mergeSort(S, 0, len(S))
print(" ".join(map(str, S)))
print(num) | 1 | 117,010,444,308 | null | 26 | 26 |
N, M = map(int, input().split(' '))
ac_set = set()
wa_cnt_list = [0] * N
ac_cnt, wa_cnt = 0, 0
for i in range(M):
num, res = input().split(' ')
num = int(num) - 1
if num not in ac_set:
if res == 'AC':
ac_cnt += 1
wa_cnt += wa_cnt_list[num]
ac_set.add(num)
else:
wa_cnt_list[num] += 1
print(ac_cnt, wa_cnt) | N,M=map(int,input().split())
AC=[0]*(N+1)
WA=[0]*(N+1)
ans=0
for _ in range(M):
p,s=input().split()
p=int(p)
if AC[p]==0:
if s=='AC':
AC[p]=1
ans+=WA[p]
else:
WA[p]+=1
print(sum(AC),ans)
| 1 | 93,833,976,147,388 | null | 240 | 240 |
def make_divisors(n):
lower_divisors , upper_divisors = [], []
i = 1
while i*i <= n:
if n % i == 0:
lower_divisors.append(i)
if i != n // i:
upper_divisors.append(n//i)
i += 1
return lower_divisors + upper_divisors[::-1]
def min2(x,y):
return x if x < y else y
N = int(input())
P = make_divisors(N)
L = len(P) + 1
res =float("inf")
for p in P:
res = min2((p - 1) + (N // p - 1), res)
print(res) | import math
N = int(input())
N_ = int(math.sqrt(N)) + 1
min_distance = N - 1
for i in range(1, N_):
p, r = divmod(N, i)
if r == 0:
if 1 <= p <= N:
distance = (i-1) + (p-1)
min_distance = min(min_distance, distance)
else:
continue
print(min_distance)
| 1 | 161,619,620,461,868 | null | 288 | 288 |
def az15():
n = input()
xs = map(int,raw_input().split())
xs.reverse()
for i in range(0,len(xs)):
print xs[i],
az15() | from math import gcd
a, b = [int(i) for i in input().split()]
print(int(a * b / gcd(a, b))) | 0 | null | 56,912,335,955,388 | 53 | 256 |
# AOJ ITP1_9_C
def numinput():
a = input().split()
for i in range(len(a)):
a[i] = int(a[i])
return a
def main():
SCORE_taro = 0
SCORE_hanako = 0
n = int(input())
for i in range(n):
words = input().split()
if words[0] > words[1]: SCORE_taro += 3
elif words[0] < words[1]: SCORE_hanako += 3
else:
SCORE_taro += 1; SCORE_hanako += 1
print(str(SCORE_taro) + " " + str(SCORE_hanako))
if __name__ == "__main__":
main()
| n = int(input())
score = [0, 0]
for i in range(n):
c = input().split()
if c[0] == c[1]:
score[0] += 1
score[1] += 1
elif c[0] < c[1]:
score[1] += 3
else:
score[0] += 3
print(*score) | 1 | 1,977,351,641,888 | null | 67 | 67 |
import sys
sys.setrecursionlimit(10 ** 5)
n, u, v = map(int, input().split())
u -= 1
v -= 1
es = [[] for i in range(n)]
for i in range(n-1):
a, b = map(int, input().split())
es[a-1].append(b-1)
es[b-1].append(a-1)
def dfs(v, dist, p=-1, d=0):
dist[v] = d
for nv in es[v]:
if nv == p:
continue
dfs(nv, dist, v, d+1)
def calc_dist(x):
dist = [-1] * n
dfs(x, dist)
return dist
dist_t = calc_dist(u)
dist_a = calc_dist(v)
mx = 0
for i in range(n):
if dist_t[i] < dist_a[i]:
mx = max(mx, dist_a[i])
ans = mx - 1
print(ans) | def resolve():
N, u, v = list(map(int, input().split()))
u, v = u-1, v-1
adjs = [ [] for _ in range(N)]
for _ in range(N-1):
a, b = list(map(lambda x: int(x)-1, input().split()))
adjs[a].append(b)
adjs[b].append(a)
dist_from_u = [float("inf") for _ in range(N)]
dist_from_u[u] = 0
import collections
q = collections.deque([u])
while q:
node = q.pop()
for adj in adjs[node]:
if dist_from_u[adj] > dist_from_u[node]+1:
dist_from_u[adj] = dist_from_u[node]+1
q.appendleft(adj)
#print(dist_from_u)
dist_from_v = [float("inf") for _ in range(N)]
dist_from_v[v] = 0
import collections
q = collections.deque([v])
while q:
node = q.pop()
for adj in adjs[node]:
if dist_from_v[adj] > dist_from_v[node]+1:
dist_from_v[adj] = dist_from_v[node]+1
q.appendleft(adj)
#print(dist_from_v)
length = 0
for i in range(N):
if dist_from_u[i] < dist_from_v[i] and length < dist_from_v[i]:
length = dist_from_v[i]
print(length-1)
if __name__ == "__main__":
resolve()
| 1 | 117,646,049,475,374 | null | 259 | 259 |
#!/usr/bin/env python3
import sys
# from scipy.special import comb
sys.setrecursionlimit(10**4)
from math import factorial
def comb(n, r):
'''
>>> comb(2, 1)
2
>>> comb(3, 2)
3
'''
if r == 0:
return 1
if n == 0 or r > n:
return 0
return factorial(n) // factorial(n - r) // factorial(r)
def f(S, i, k):
# ここに来るのは繰り下がりが発生していない状態...
if k == 0:
# 以降は0を選び続けるしかない
return 1
if len(S) <= i:
# 走破したのにK個使いきれていない
return 0
n = int(S[i])
if n == 0:
# 注目する桁が0の場合、0を選ぶしかない
return f(S, i+1, k)
# 注目する桁の数値nより小さい値を選べば、以降は繰り下げで選び放題
ret = (n - 1) * comb(len(S)-i-1, k-1) * pow(9, k-1)
ret += comb(len(S)-i-1, k) * pow(9, k)
# 注目する桁の数値nを選んだ場合、繰り下げができない状態が続行
ret += f(S, i+1, k-1)
return ret
def solve(S: str, K: int):
return f(S, 0, K)
# Generated by 1.1.7.1 https://github.com/kyuridenamida/atcoder-tools
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = next(tokens) # type: str
K = int(next(tokens)) # type: int
print(solve(N, K))
def test():
import doctest
doctest.testmod()
if __name__ == '__main__':
test()
main()
| # input
N = int(input())
K = int(input())
# defnition
N_bin = str(N)
digit_len_N = len(N_bin)
DP = [[[0]*(K+2) for _ in range(2)] for _ in range(digit_len_N+1)]
# DP[i][j][k]は、上位i桁目までで、(j==0 ?Nと同じになる可能性あり:必ずNより小さくなる)の時に、0以外の数がkこ出現する、数字の数
# initialize
DP[0][0][0] = 1
# solve with けたDP
for digit in range(digit_len_N):
max_digit = int(N_bin[digit])
for smaller in range(2): # smaller=0?Nと同じになる可能性あり:Nより小さいの確定
for k in range(K+1):
cand_digits = max_digit+1 if smaller == 0 else 10 # 小さい確定なら0~9の全部が候補
for next in range(cand_digits):
if next == max_digit and smaller == 0: # Nと同じになる可能性を残しつつ
if next == 0: # 0のときは,kの値が増えないので特別扱い
DP[digit+1][0][k] += DP[digit][0][k]
else:
DP[digit+1][0][k+1] += DP[digit][0][k]
else: # ここで、Nより必ず小さい道に行く
if next == 0: # 0のときは,kの値が増えないので特別扱い
DP[digit+1][1][k] += DP[digit][smaller][k]
else:
DP[digit+1][1][k+1] += DP[digit][smaller][k]
print(DP[-1][0][K]+DP[-1][1][K])
| 1 | 75,761,243,837,158 | null | 224 | 224 |
n = int(input())
num = list(map(int,input().split()))
ans = 0
m = num[0]
for i in range(1,n):
if m >= num[i]:
ans += m - num[i]
else:
m = num[i]
print(ans) | _, _, M = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
xyc = [tuple(map(int, input().split())) for i in range(M)]
print(min([min(A)+min(B)]+[A[x-1]+B[y-1]-c for x, y, c in xyc]))
| 0 | null | 29,412,985,623,174 | 88 | 200 |
m,n=map(int,input().split())
a=[]
b=[]
for _ in range(m):
a.append(map(int, input().split()))
for _ in range(n):
b.append(int(input()))
for ai in a:
sum = 0
for index, mi in enumerate(ai):
sum += mi*b[index]
print(sum)
| n, m = map(int, raw_input().split())
ans = []
aa = []
for i in range(n):
a = map(int, raw_input().split())
aa.append(a)
ans.append(0)
b = []
for i in range(m):
a = input()
b.append(a)
for i in range(n):
for j in range(m):
ans[i] += aa[i][j] * b[j]
for i in range(len(ans)):
print(ans[i]) | 1 | 1,156,035,284,180 | null | 56 | 56 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.