code1
stringlengths 16
24.5k
| code2
stringlengths 16
24.5k
| similar
int64 0
1
| pair_id
int64 2
181,637B
⌀ | question_pair_id
float64 3.71M
180,628B
⌀ | code1_group
int64 1
299
| code2_group
int64 1
299
|
|---|---|---|---|---|---|---|
import sys
input = sys.stdin.readline
from itertools import accumulate
n = int(input())
A = list(map(int, input().split()))
if n == 0:
if A[0] == 1:
print(1)
else:
print(-1)
exit()
C = list(accumulate(A[::-1]))[::-1] + [0]
B = [-1]*(n+1)
B[0] = 1 - A[0]
for i in range(1, n+1):
B[i] = min(C[i+1], 2*B[i-1]-A[i])
if B[i] < 0 or B[i] < B[i-1] - A[i]:
print(-1)
exit()
ans = sum(A) + sum(B)
print(ans)
|
N = int(input())
A = list(map(int, input().split()))
if N == 0 and A[0] == 1:
print(1)
exit()
if A[0] != 0:
print(-1)
exit()
sum_leaf = sum(A)
ans = 1
before_top = 1
for i in range(1, len(A)):
if A[i] <= before_top*2:
ans += min(sum_leaf, before_top*2)
before_top = min(sum_leaf, before_top*2) - A[i]
sum_leaf -= A[i]
else:
print(-1)
exit()
print(ans)
| 1 | 18,845,930,081,976 | null | 141 | 141 |
s = input().split()
d = int(s[0])
t = int(s[1])
s = int(s[2])
if d <= t * s:
print("Yes")
else:
print("No")
|
A = [[[0 for i in range(10)] for i in range(3)] for i in range(4)]
info = int(input())
for i in range(info):
b,f,r,v = [int(i) for i in input().split()]
A[b-1][f-1][r-1] += v
if A[b-1][f-1][r-1] < 0:
A[b-1][f-1][r-1] = 0
elif A[b-1][f-1][r-1] > 9:
A[b-1][f-1][r-1] = 9
for i in range(3):
print(' '+' '.join([str(i) for i in A[0][i]]))
print('#'*20)
for i in range(3):
print(' '+' '.join([str(i) for i in A[1][i]]))
print('#'*20)
for i in range(3):
print(' '+' '.join([str(i) for i in A[2][i]]))
print('#'*20)
for i in range(3):
print(' '+' '.join([str(i) for i in A[3][i]]))
| 0 | null | 2,340,430,747,172 | 81 | 55 |
tmp = input().split(" ")
N = int(tmp[0])
M = int(tmp[1])
ary = list(map(lambda n: int(n), input().split(" ")))
n = sum(ary)
print(-1) if N < n else print(N - n)
|
# abc155_c.py
# https://atcoder.jp/contests/abc155/tasks/abc155_c
# C - Poll /
# 実行時間制限: 2 sec / メモリ制限: 1024 MB
# 配点: 300点
# 問題文
# N枚の投票用紙があり、i (1≤i≤N) 枚目には文字列 Siが書かれています。
# 書かれた回数が最も多い文字列を全て、辞書順で小さい順に出力してください。
# 制約
# 1≤N≤2×105
# Siは英小文字のみからなる文字列 (1≤i≤N)
# Siの長さは 1 以上 10 以下 (1≤i≤N)
# 入力
# 入力は以下の形式で標準入力から与えられる。
# N
# S1
# :
# SN
# 出力
# あてはまる文字列を全て辞書順で小さい順に、改行区切りで出力せよ。
# 入力例 1
# 7
# beat
# vet
# beet
# bed
# vet
# bet
# beet
# 出力例 1
# beet
# vet
# 書かれた回数は beet と vet が 2回、beat と bed と bet が 1 回です。したがって、2回書かれた beet と vet を出力します。
# 入力例 2
# 8
# buffalo
# buffalo
# buffalo
# buffalo
# buffalo
# buffalo
# buffalo
# buffalo
# 出力例 2
# buffalo
# 入力例 3
# 7
# bass
# bass
# kick
# kick
# bass
# kick
# kick
# 出力例 3
# kick
# 入力例 4
# 4
# ushi
# tapu
# nichia
# kun
# 出力例 4
# kun
# nichia
# tapu
# ushi
global FLAG_LOG
FLAG_LOG = False
def log(value):
# FLAG_LOG = True
# FLAG_LOG = False
if FLAG_LOG:
print(str(value))
def calculation(lines):
# S = lines[0]
N = int(lines[0])
# N, M = list(map(int, lines[0].split()))
# values = list(map(int, lines[1].split()))
# values = list(map(int, lines[2].split()))
values = list()
for i in range(N):
values.append(lines[i+1])
# valueses = list()
# for i in range(N):
# valueses.append(list(map(int, lines[i+1].split())))
dic = dict()
for value in values:
if value in dic:
dic[value] += 1
else:
dic[value] = 1
tmp = list()
for key in dic:
tmp.append(dic[key])
ma = max(tmp)
results = list()
for key in dic:
if dic[key] == ma:
results.append(key)
results.sort()
return results
# 引数を取得
def get_input_lines():
line = input()
N = int(line)
lines = list()
lines.append(line)
for _ in range(N):
lines.append(input())
return lines
# テストデータ
def get_testdata(pattern):
if pattern == 1:
lines_input = ['7', 'beat', 'vet', 'beet', 'bed', 'vet', 'bet', 'beet']
lines_export = ['beet', 'vet']
if pattern == 2:
lines_input = ['8', 'buffalo', 'buffalo', 'buffalo', 'buffalo', 'buffalo', 'buffalo', 'buffalo', 'buffalo']
lines_export = ['buffalo']
if pattern == 3:
lines_input = ['7', 'bass', 'bass', 'kick', 'kick', 'bass', 'kick', 'kick']
lines_export = ['kick']
if pattern == 4:
lines_input = ['4', 'ushi', 'tapu', 'nichia', 'kun']
lines_export = ['kun', 'nichia', 'tapu', 'ushi']
return lines_input, lines_export
# 動作モード判別
def get_mode():
import sys
args = sys.argv
global FLAG_LOG
if len(args) == 1:
mode = 0
FLAG_LOG = False
else:
mode = int(args[1])
FLAG_LOG = True
return mode
# 主処理
def main():
import time
started = time.time()
mode = get_mode()
if mode == 0:
lines_input = get_input_lines()
else:
lines_input, lines_export = get_testdata(mode)
lines_result = calculation(lines_input)
for line_result in lines_result:
print(line_result)
# if mode > 0:
# print(f'lines_input=[{lines_input}]')
# print(f'lines_export=[{lines_export}]')
# print(f'lines_result=[{lines_result}]')
# if lines_result == lines_export:
# print('OK')
# else:
# print('NG')
# finished = time.time()
# duration = finished - started
# print(f'duration=[{duration}]')
# 起動処理
if __name__ == '__main__':
main()
| 0 | null | 51,098,991,028,400 | 168 | 218 |
print(eval(input().strip().replace(' ','*')))
|
import sys
def log(s):
# print("| " + str(s), file=sys.stderr)
pass
def output(x):
print(x, flush=True)
def input_ints():
return list(map(int, input().split()))
def main():
f = input_ints()
print(f[0] * f[1])
main()
| 1 | 15,910,303,101,950 | null | 133 | 133 |
N = int(input())
result = {}
result["AC"] = 0
result["WA"] = 0
result["TLE"] = 0
result["RE"] = 0
for i in range(N):
judge = input()
result[judge] += 1
for key, value in result.items():
print(f"{key} x {value}")
|
X, Y = list(map(int, input().split()))
judge = 0
for a in range(X + 1):
if (Y - a*2 - (X-a)*4 ) == 0:
print("Yes")
judge = 1
break
if judge == 0:
print("No")
| 0 | null | 11,195,581,575,202 | 109 | 127 |
class UnionFind():
#https://note.nkmk.me/python-union-find/
#note.nkmk.me 2019-08-18
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())
#初期入力、集合とユニオンファインド
import sys
input = sys.stdin.readline
N,M,K = (int(x) for x in input().split())
#接続（友好関係、ブロック関係）
uf =UnionFind(N+1)
conn_fri ={i:set() for i in range(1,N+1)}
conn_blo ={i:set() for i in range(1,N+1)}
for i in range(M):
a,b = (int(x) for x in input().split())
uf.union(a,b)
conn_fri[a].add(b)
conn_fri[b].add(a)
for i in range(K):
c,d = (int(x) for x in input().split())
conn_blo[c].add(d)
conn_blo[d].add(c)
#友達候補の数＝同じグループにいる、友達関係でない、ブロック関係でない
ans ={i:0 for i in range(1,N+1)}
for i in range(1,N+1):
root =uf.find(i)
all =uf.size(root)
same_groop_block =0
for j in conn_blo[i]:
if uf.same(i,j): #同じグループにいるけどブロック関係
same_groop_block +=1
ans[i] =all -len(conn_fri[i]) -same_groop_block -1 #-1 自分を引く
#出力
print(*ans.values())
#print(all)
|
n = int(input())
d = set()
for i in range(n):
com = input().split()
if com[0] == "insert":
d.add(com[1])
else:
print("yes" if com[1] in d else "no")
| 0 | null | 30,737,512,454,000 | 209 | 23 |
x=input()
i=1
while (x!='0'):
print("Case {0}: {1}".format(i,x));
i+=1;
x=input()
|
n = int(input())
s, t = input().split()
s_and_t = s[0]
for i in range(len(s)):
if(i >= 1):
s_and_t += s[i]
s_and_t += t[i]
print(s_and_t)
| 0 | null | 56,006,383,417,758 | 42 | 255 |
n=int(input())
l = [int(x) for x in input().split(' ')]
c=0
for i in range(0,len(l),2):
if((i+1)%2!=0 and l[i]%2!=0):
c+=1
print(c)
|
N = int(input())
A = list(map(int,input().split()))
count = 0
for i in range(0,N,2):
if A[i]%2 != 0:
count += 1
print(count)
| 1 | 7,756,162,300,668 | null | 105 | 105 |
import sys
input = sys.stdin.readline
N, K = map(int, input().split())
A = list(map(int, 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()))
ans = []
for i in range(k,n):
ans.append(a[i] - a[i-k])
for j in ans:
if j > 0:
print('Yes')
else:
print('No')
| 1 | 7,081,333,501,050 | null | 102 | 102 |
def pre_combi1(n, p):
fact = [1]*(n+1) # fact[n] = (n! mod p)
factinv = [1]*(n+1) # factinv[n] = ((n!)^(-1) mod p)
inv = [0]*(n+1) # factinv 計算用
inv[1] = 1
# 前処理
for i in range(2, n + 1):
fact[i]= fact[i-1] * i % p
inv[i]= -inv[p % i] * (p // i) % p
factinv[i]= factinv[i-1] * inv[i] % p
return fact, factinv
def combi1(n, r, p, fact, factinv):
if r < 0 or n < r:
return 0
r = min(r, n-r)
return fact[n] * factinv[r] * factinv[n-r] % p
import sys
x,y=map(int,input().split())
if (x+y)%3 > 0:
print(0)
sys.exit()
n=(x+y)//3
r=x-n
f,inv=pre_combi1(n,1000000007)
print(combi1(n,r,1000000007,f,inv))
|
def solve():
print(eval(input().replace(' ', '*')))
if __name__ == '__main__':
solve()
| 0 | null | 82,662,432,849,728 | 281 | 133 |
import math
a,b,x=map(int,input().split())
if x>=a**2*b/2:
a=math.atan((2/a)*(b-x/(a**2)))
else:
a=math.atan(a*b**2/2/x)
print("{:.8f}".format(a*(180/math.pi)))
|
n,k=map(int,input().split())
print(min(n%k,-n%k))
| 0 | null | 101,644,417,974,110 | 289 | 180 |
n = int(input())
mod = 10**9+7
ls = list(map(int,input().split()))
di = [i**2 for i in ls]
print((((sum(ls)**2)-(sum(di)))//2)%mod)
|
k,n,*a=map(int,open(0).read().split())
l=k-a[n-1]+a[0]
for i in range(n-1):
l=max(l,a[i+1]-a[i])
print(k-l)
| 0 | null | 23,726,832,886,558 | 83 | 186 |
import bisect
def main():
n = int(input())
l = sorted(list(int(i) for i in input().split()))
cnt = 0
for i in range(n - 2):
a = l[i]
for j in range(i + 1, n-1):
b = l[j]
cnt += bisect.bisect_left(l, a+b)-(j+1)
print(cnt)
if __name__ == "__main__":
main()
|
#!/usr/bin/env python3
import sys
from collections import deque, Counter
from heapq import heappop, heappush
from bisect import bisect_right
from itertools import accumulate
sys.setrecursionlimit(10**6)
INF = 10**12
m = 10**9 + 7
def main():
N, T = map(int, input().split())
AB = []
for _ in range(N):
AB.append(list(map(int, input().split())))
AB.sort()
dp = [0] * (T + 1)
ans = 0
for i in range(N-1):
for j in range(T, -1, -1):
if j + AB[i][0] <= T:
dp[j + AB[i][0]] = max(dp[j + AB[i][0]], dp[j] + AB[i][1])
ans = max(ans, dp[T-1]+AB[i+1][1])
print(ans)
if __name__ == "__main__":
main()
| 0 | null | 161,869,458,318,568 | 294 | 282 |
import sys
list = map(int,sys.stdin.readline().split())
list.sort()
print(' '.join(map(str,list)))
|
a, b, n = map(int,input().split())
if n >= b:
print(int(a - a / b))
else:
print(int(a * n / b) - a * int(n / b))
| 0 | null | 14,305,145,686,808 | 40 | 161 |
n = int(input())
ans = [0 for x in range(10001)]
for i in range(1, 100):
for j in range(1, 100):
for k in range(1, 100):
v = i*i + j*j + k*k + i*j + i*k + j*k
if v < 10001:
ans[v] += 1
for i in range(n):
print(ans[i+1])
|
# n=int(input())
# n,k=map(int,input().split())
# arr=list(map(int,input().split()))
#ls=list(map(int,input().split()))
#for i in range(m):
# for _ in range(int(input())):
#from collections import Counter
#from fractions import Fraction
n=int(input())
arr=list(map(int,input().split()))
var=arr[0]
for i in range(1,n):
var^=arr[i]
for i in range(n):
print(arr[i]^var,end=" ")
#ls = [list(map(int, input().split())) for i in range(n)]
#for _ in range(int(input())):
| 0 | null | 10,297,404,793,440 | 106 | 123 |
N = int(input())
X_ls = list(map(int, input().split(' ')))
rst = -1
for i in range(min(X_ls), max(X_ls) + 1):
val = 0
for j in X_ls:
val += (i - j) ** 2
if rst == -1:
rst = val
else:
rst = min(rst, val)
print(rst)
|
N, K = map(int, input().split())
MOD = 10**9 + 7
ans = 0
A = [0 for _ in range(K+1)]
for i in range(1,K+1):
ans += pow(K//i, N, MOD) * (i - A[i])
ans %= MOD
#print(ans, i)
j = 2*i
while j <= K:
A[j] += i - A[i]
j += i
print(ans)
| 0 | null | 50,947,005,669,690 | 213 | 176 |
import math
h,a=map(int,input().split())
num = h/a
ans = math.ceil(num)
print(ans)
|
import math
H, A = [int(i) for i in input().split()]
print(math.ceil(H / A))
| 1 | 76,880,331,954,242 | null | 225 | 225 |
def main():
M1, D1 = map(int, input().split())
M2, D2 = map(int, input().split())
if D2 == 1:
print(1)
else:
print(0)
if __name__ == "__main__":
main()
|
# -*- coding: utf-8 -*-
N = int(input())
S = input()
ans = 0
for i in range(1000):
pw = list("{0:03d}".format(i))
if pw[0] in S:
w1 = S.index(pw[0])
if pw[1] in S[w1+1:]:
w2 = w1+1 + S[w1+1:].index(pw[1])
if pw[2] in S[w2+1:]:
ans += 1
print(ans)
| 0 | null | 126,889,463,675,332 | 264 | 267 |
#152_B
a, b = map(int, input().split())
s1 = ''
for i in range(a):
s1 = s1 + str(b)
s2 = ''
for i in range(b):
s2 = s2 + str(a)
if s1 < s2:
print(s1)
else:
print(s2)
|
a,b = input().split()
aaa = a * int(b)
bbb = b * int(a)
print(min(aaa, bbb))
| 1 | 84,241,164,888,160 | null | 232 | 232 |
n = int(input())
s0=list(str(n))
ans=0
if len(s0)==1:
print(n)
exit()
if len(s0)==2:
for i in range(1,n+1):
s1=list(str(i))
if s1[-1]=='0':
continue
if s1[0]==s1[-1]:
ans+=1
if int(s1[-1])*10+int(s1[0])<=n:
ans+=1
print(ans)
exit()
for i in range(1,n+1):
s1=list(str(i))
if s1[-1]=='0':
continue
if s1[0]==s1[-1]:
ans+=1
for j in range(2,len(s0)):#nより小さい桁数のものを足す
ans+=10**(j-2)
if int(s0[0])>int(s1[-1]):#nより入れ替えた数の最高位数が小さいとき、全て足す
ans+=10**(len(s0)-2)
elif s0[0]==s1[-1]:#nと入れ替えた数の最高位数が同じ時
ans+=int(''.join(s0[1:len(s0)-1]))+1
if int(s0[-1])<int(s1[0]):
ans-=1
print(ans)
|
from collections import defaultdict
N = int(input())
d = defaultdict(int)
for i in range(1, N+1):
s = str(i)
top = int(s[0])
end = int(s[-1])
d[(top, end)] += 1
counter = 0
for i in range(1, N+1):
s = str(i)
top = int(s[0])
end = int(s[-1])
if (end, top) in d:
counter += d[(end, top)]
print(counter)
| 1 | 86,406,168,797,770 | null | 234 | 234 |
H, A = map(int, input().split())
res = H // A
H -= A * res
print(res + 1 if H > 0 else res)
|
H = int(input())
count = 0
while H != 1:
H //= 2
count += 1
ans = 0
for i in range(count +1):
ans += 2 ** i
print(ans)
| 0 | null | 78,634,319,452,128 | 225 | 228 |
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())
def LIST1() : return list(MAP1())
def solve():
N = INT()
a = []
b = []
for i in range(N):
A, B = MAP()
a.append(A)
b.append(B)
a.sort()
b.sort()
if N % 2 == 1:
am = a[(N+1)//2-1]
bm = b[(N+1)//2-1]
ans = bm - am + 1
else:
am = ( a[N//2-1]+a[N//2] ) / 2
bm = ( b[N//2-1]+b[N//2] ) / 2
ans = int( ( bm - am ) * 2 + 1 )
print(ans)
if __name__ == '__main__':
solve()
|
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()
cnt = 0
if(N % 2 == 1):
l = A[N//2]
r = B[N//2]
cnt = r - l + 1
else:
l = A[N//2-1] + A[N//2]
r = B[N//2-1] + B[N//2]
cnt = r - l + 1
print(cnt)
| 1 | 17,234,033,336,566 | null | 137 | 137 |
import math
a,b = map(int,input().split())
print(int(a * b / math.gcd(a,b)))
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
?????§?????????
FX????????§????????°?????????????????¨????????????????????¨??§????????????????????????????????¨?????§????????????
????????°????????????100???????????? 1000???????????????????????????????????? 1?????? 108???????????£??????????£??????¨???
(108??? ?????? 100???) ???? 1000?????? == 8000??????????????????????????¨?????§????????????
???????????¨????????????????????? t ?????????????????? Rt (t=0,1,2,,,n???1)???
??\?????¨??????????????????????????§??????????????? Rj???Ri (????????????j>i ??¨??????) ????????§??????
?±??????????????????????
"""
import math
# ?????????
cnt = -1000000000
n = int(input().strip())
min = int(input().strip())
for i in range(1,n):
a =int(input().strip())
x = a - min
if cnt < x:
cnt = x
if min > a:
min = a
print(cnt)
| 0 | null | 56,586,112,607,828 | 256 | 13 |
import sys
def input():
return sys.stdin.readline()[:-1]
def main():
A, B, C = map(int,input().split())
K = int(input())
count = 0
while A >= B:
B = B * 2
count += 1
while B >= C:
C = C * 2
count += 1
if count <= K:
print("Yes")
else:
print("No")
if __name__ == "__main__":
main()
|
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)
| 0 | null | 64,219,389,101,812 | 101 | 262 |
n, m = map(int,input().split())
lst = list(map(int,input().split()))
lst2 = []
for i in range(n):
lst3 = [lst[i]]
lst2.append(lst3)
for i in range(m):
a, b = map(int,input().split())
a = a - 1
b = b - 1
lst2[a].append(lst2[b][0])
lst2[b].append(lst2[a][0])
ans = 0
for i in range(n):
x = lst2[i][0]
lst2[i].sort()
lst2[i].reverse()
if (len(lst2[i]) == 1):
ans = ans + 1
elif (x == lst2[i][0]):
lst2[i].pop(0)
y = lst2[i][0]
if (x != y):
ans = ans + 1
print(ans)
|
import math
r=int(input())
L=2*math.pi*r
print('{0}'.format(L))
| 0 | null | 28,329,415,692,200 | 155 | 167 |
n, a, b = map(int, input().split())
# 偶奇一致
if a % 2 == b % 2:
print((b - a) // 2)
else:
left = a - 1
right = n - b
if left > right:
cnt = right + 1
left = min(a + cnt, n)
print((n - left) // 2 + cnt)
else:
cnt = left + 1
right = max(b - cnt, 1)
print((right - 1) // 2 + cnt)
|
from sys import stdin
import math
import re
import queue
input = stdin.readline
MOD = 1000000007
def solve():
N,A,B = map(int, input().split())
if(abs(A - B)%2 == 0):
print(abs(A-B)//2)
return
print(min(A-1,N-B)+1+(B-A-1)//2)
if __name__ == '__main__':
solve()
| 1 | 109,259,531,643,312 | null | 253 | 253 |
def resolve():
N = int(input())
g = {}
edges_to_idx = {}
edges = []
for i in range(N-1):
a, b = list(map(int, input().split()))
g.setdefault(a-1, [])
g[a-1].append(b-1)
g.setdefault(b-1, [])
g[b-1].append(a-1)
edges_to_idx.setdefault("{}-{}".format(a-1, b-1), i)
edges_to_idx.setdefault("{}-{}".format(b-1, a-1), i)
edges.append((a-1, b-1))
nodes = [(None, 0)]
colors = [None for _ in range(N-1)]
maxdeg = 0
while nodes:
prevcol, node = nodes.pop()
maxdeg = max(maxdeg, len(g[node]))
idx = 0
for col in range(1, len(g[node])+1):
if col == prevcol:
continue
nxt = g[node][idx]
coloridx = edges_to_idx["{}-{}".format(node, nxt)]
if colors[coloridx] is not None:
idx += 1
if idx >= len(g[node]):
break
nxt = g[node][idx]
coloridx = edges_to_idx["{}-{}".format(node, nxt)]
colors[coloridx] = col
nodes.append((col, nxt))
idx += 1
if idx >= len(g[node]):
break
print(maxdeg)
for col in colors:
print(col)
if '__main__' == __name__:
resolve()
|
import sys
sys.setrecursionlimit(10 ** 9)
n = int(input())
tree = [[] for _ in range(n)]
dic = {}
for i in range(n - 1):
a, b = map(int, input().split())
tree[a - 1].append(b - 1)
tree[b - 1].append(a - 1)
dic[(a - 1, b - 1)] = i
ans = [0 for _ in range(n - 1)]
max_color = 0
def dfs(pos, before_pos, before_color):
global max_color
color = 1
for next_pos in tree[pos]:
if color == before_color:
color += 1
if next_pos == before_pos:
continue
before = min(pos, next_pos)
after = max(pos, next_pos)
ans_ind = dic[(before, after)]
if pos < next_pos:
ans[ans_ind] = color
else:
ans[ans_ind] = color
max_color = max(color, max_color)
dfs(next_pos, pos, color)
color += 1
dfs(0, -1, -1)
print(max_color)
for i in ans:
print(i)
| 1 | 136,374,887,742,720 | null | 272 | 272 |
h=int(input())
w=int(input())
n=int(input())
print(-(-n//max(h,w)))
|
n,m = map(int,raw_input().split(" "))
a = []
for i in range(0,n):
b = map(int,raw_input().split(" "))
a.append(b)
for j in range(0,m):
k = input()
for i in range(0,n):
a[i][j] = a[i][j] * k
for i in range(0,n):
s = 0
for j in range(0,m):
s = s + a[i][j]
print str(s)
| 0 | null | 44,870,365,866,832 | 236 | 56 |
x,y,a,b,c = map(int,input().split())
R=list(map(int,input().split()) )
G=list(map(int,input().split()) )
W=list(map(int,input().split()) )
R.sort(reverse=True)
G.sort(reverse=True)
Z = W+R[0:x] + G[0:y]
Z.sort(reverse=True)
print(sum(Z[0:x+y]))
|
n = int(input())
lx = list(map(int,input().split()))
lc=[]
for i in range(1,101):
c = 0
for x in lx:
c += (i-x)**2
lc.append(c)
print(min(lc))
| 0 | null | 54,931,046,979,512 | 188 | 213 |
import sys
n=int(input())
if n%2:
print(0)
sys.exit()
# 10->50->2500の個数
cnt=0
v=10
while 1:
cnt+=n//v
if n//v==0:
break
v*=5
print(cnt)
|
H, N = map(int, input().split())
dp = [10 ** 9] * (H + 1)
dp[0] = 0
for _ in range(N):
a, b = map(int, input().split())
for i in range(H):
idx = min(H, i + a)
dp[idx] = min(dp[idx], dp[i] + b)
print(dp[H])
| 0 | null | 98,453,567,358,680 | 258 | 229 |
input()
print(sum([int(x) % 2 for x in input().split()[::2]]))
|
N = int(input())
A = list(map(int, input().split()))
print(sum([i&1 and a&1 for i,a in enumerate(A,1)]))
| 1 | 7,736,171,234,610 | null | 105 | 105 |
N = int(input())
ans = [0]*4
for i in range(N):
s = input()
if s == "AC":
ans[0] += 1
elif s == "WA":
ans[1] += 1
elif s == "TLE":
ans[2] += 1
elif s == "RE":
ans[3] += 1
print("AC x "+ str(ans[0]),"WA x "+ str(ans[1]),"TLE x "+ str(ans[2]),"RE x "+ str(ans[3]),sep = "\n" )
|
import bisect
N, M = map(int, input().split())
A = [int(x) for x in input().split()]
A.sort()
INF = 10 ** 9
A.append(INF)
left, right = 0, 2 * max(A)
while left + 1 < right:
mid = (left + right) >> 1
cnt = sum(N - bisect.bisect_left(A, mid-A[i]) for i in range(N))
if cnt >= M:
left = mid
else:
right = mid
acc = [0]
for i in range(N):
acc.append(acc[-1] + A[i])
ans = 0
cnt, min_val = 0, INF
for i in range(N):
idx = bisect.bisect_left(A, left-A[i])
cnt += N - idx
min_val = min(min_val, A[i] + A[idx])
ans += (N - idx) * A[i] + acc[N] - acc[idx]
ans -= (cnt - M) * min_val
print(ans)
| 0 | null | 58,117,535,136,444 | 109 | 252 |
N=int(input())
MOD=10**9+7
ans=10**N %MOD
ans=ans-2*9**N %MOD
ans=ans+8**N %MOD
print(ans%MOD)
|
#!/usr/bin/env python3
# encoding:utf-8
import copy
import random
import bisect #bisect_left これで二部探索の大小検索が行える
import fractions #最小公倍数などはこっち
import math
import sys
import collections
from decimal import Decimal # 10進数で考慮できる
mod = 10**9+7
sys.setrecursionlimit(mod) # 再帰回数上限はでdefault1000
d = collections.deque()
def LI(): return list(map(int, sys.stdin.readline().split()))
N = int(input())
all = (10 **N) % mod
no_zero = (9**N) % mod
no_nine = (9**N)
no_zero_nine = 8 ** N
A = 1
no_zero = 1
no_nine = 1
no_zero_nine = 1
for i in range(N):
A = A * 10 % mod
no_zero = no_zero * 9 % mod
no_zero_nine = no_zero_nine * 8 % mod
ans = (A - (no_zero * 2 - no_zero_nine)) % mod
print(ans)
| 1 | 3,177,438,126,588 | null | 78 | 78 |
N = int(input())
ret = False
if N % 2 == 0:
S = input()
if S[:N//2] == S[N//2:]:
ret = True
if ret:
print("Yes")
else:
print("No")
|
import sys
n=int(input())
s=list(input())
if n%2!=0:
print('No')
sys.exit()
a=s[:n//2]
b=s[n//2:]
cnt=0
for i in range(n//2):
if a[i]!=b[i]:
cnt+=1
if cnt==0:
print('Yes')
else:
print('No')
| 1 | 147,330,904,184,320 | null | 279 | 279 |
A = int(input())
B = int(input())
print(3 if A+B==3 else 2 if A+B==4 else 1)
|
import sys
def solve():
input = sys.stdin.readline
A = int(input())
B = int(input())
C = list(set([1, 2, 3]) - set([A, B]))
print(C[0])
return 0
if __name__ == "__main__":
solve()
| 1 | 110,835,359,944,428 | null | 254 | 254 |
X = int(input())
r = X%100
x5 = r//5
r5 = r%5
if r5:
x5+=1
if x5*100 <= X:
print(1)
else:
print(0)
|
# C - 100 to 105
# https://atcoder.jp/contests/sumitrust2019/tasks/sumitb2019_c
x = int(input())
d, m = divmod(x, 100)
D = [0] * 5
for i in range(4, -1, -1):
D[i], m = divmod(m, i + 1)
if d >= sum(D):
print(1)
else:
print(0)
| 1 | 127,458,651,115,668 | null | 266 | 266 |
N = int(input())
print(int(N / 2 + 0.5) /N)
|
N=int(input())
result=0
for i in range(0,N+1):
if i%2 != 0:
result+=1
else:
result+=0
print(float(result/N))
| 1 | 177,313,751,655,040 | null | 297 | 297 |
N = int(input())
p = [[None] for i in range(N)]
for i in range(N):
p[i] = list(map(int, input().split()))
p.sort()
#print(p)
INFINITE = 5 * 10**9
maxUp = {}
minDown = {}
for i in range(1, N):
maxUp[i] = max(maxUp.get(i-1, -INFINITE), p[i-1][1] - p[i-1][0])
for i in range(1, N):
minDown[i] = min(minDown.get(i-1, INFINITE), p[i-1][0] + p[i-1][1])
#print(maxUp)
#print(minDown)
ans = -INFINITE
for i in range(1, N):
ans = max(ans,
p[i][0] - p[i][1] + maxUp.get(i, -INFINITE)
)
ans = max(ans,
p[i][0] + p[i][1] - minDown.get(i, INFINITE)
)
print(ans)
|
n = int(input())
xy = []
for _ in range(n):
xy.append(list(map(int, input().split())))
tmp1 = []
tmp2 = []
for i in range(n):
tmp1.append([xy[i][0]+xy[i][1], xy[i][0], xy[i][1]])
tmp2.append([xy[i][0]-xy[i][1], xy[i][0], xy[i][1]])
tmp1.sort()
tmp2.sort()
ans = 0
if (tmp1[-1][2]-tmp1[0][2])*(tmp1[-1][1]-tmp1[0][1]) >= 0:
tmp = tmp1[-1][0]-tmp1[0][0]
ans = max(tmp, ans)
if (tmp2[-1][2]-tmp2[0][2])*(tmp2[-1][1]-tmp2[0][1]) <= 0:
tmp = tmp2[-1][0]-tmp2[0][0]
ans = max(tmp, ans)
print(ans)
| 1 | 3,443,952,937,828 | null | 80 | 80 |
n,q = map(int,input().split())
queue = []
for i in range(n):
p,t = map(str,(input().split()))
t = int(t)
queue.append([p,t])
total_time = 0
while len(queue) > 0:
x = queue.pop(0)
if x[1] > q :
total_time += q
x[1] -= q
queue.append(x)
else:
total_time += x[1]
print(x[0],total_time)
|
n, q = list(map(int, input().split()))
que = []
for i in range(n):
p, t = input().split()
que.append([p, int(t)])
total = 0
while True:
if q >= que[0][1]:
total += que[0][1]
print(que[0][0], total)
que.pop(0)
else:
total += q
que[0][1] -= q
que.append(que[0])
que.pop(0)
if len(que) == 0:
break
| 1 | 41,824,762,510 | null | 19 | 19 |
n = int(input())
ansl = []
def dfs(s, max_s):
if len(s) == n:
ansl.append(s)
return
ascii_lowercase = 'abcdefghijklmnopqrstuvwxyz'
for i in range(max_s+1):
dfs(s+ascii_lowercase[i], max(i+1, max_s))
dfs("", 0)
for a in ansl:
print(a)
|
n = int(input())
a = ["a","b","c","d","e","f","g","h","i","j"]
def dfs(s):
m = len(s)
if m == n:
ans = ""
for i in range(n):
ans += a[int(s[i])]
print(ans)
else:
for i in range(int(max(list(s)))+2):
dfs(s+str(i))
dfs("0")
| 1 | 52,100,352,362,272 | null | 198 | 198 |
class SegmentTree:
def __init__(self,n):
self.siz = 1
while self.siz < n: self.siz *= 2
self.node = [0]*(2*self.siz-1)
def update(self,i,x):
i += self.siz-1
self.node[i] = x
while i > 0:
i = (i-1)//2
self.node[i] = self.node[i*2+1] | self.node[i*2+2]
def query(self,a,b,k=0,l=0,r=-1):
if r < 0: r = self.siz
if r <= a or b <= l: return 0
if a <= l and r <= b: return self.node[k]
vl = self.query(a,b,k*2+1,l,(l+r)//2)
vr = self.query(a,b,k*2+2,(l+r)//2,r)
return vl | vr
n = int(input())
st = SegmentTree(n)
s = list(input())
def f(c): return 1<<(ord(c) - ord("a"))
for i in range(n): st.update(i,f(s[i]))
q = int(input())
for _ in range(q):
typ,x,y = input().split()
if typ == "1":
i,c = int(x)-1,y
if s[i] == c: continue
st.update(i,f(c))
s[i] = c
else:
l,r = int(x)-1,int(y)
print(bin(st.query(l,r)).count("1"))
|
class SegmentTree():
"""一点更新、区間取得クエリをそれぞれO(logN)で答えるデータ構造を構築する。
built(array) := arrayを初期値とするセグメント木を構築する O(N)。
update(i, val) := i番目の要素をvalに変更する。
get_val(l, r) := 区間[l, r)に対する二項演算の畳み込みの結果を返す。
"""
def __init__(self, n, op, e):
"""要素数、二項演算、単位元を引数として渡す
例) 区間最小値 SegmentTree(n, min, 10 ** 18)
区間和 SegmentTree(n, lambda a, b : a + b, 0)
"""
self.n = n
self.op = op
self.e = e
self.size = 2 ** ((n - 1).bit_length())
self.node = [self.e] * (2 * self.size)
def build(self, array):
"""arrayを初期値とするセグメント木を構築する"""
for i in range(self.n):
self.node[self.size + i] = array[i]
for i in range(self.size - 1, 0, -1):
self.node[i] = self.op(self.node[i << 1], self.node[(i << 1) + 1])
def update(self, i, val):
"""i番目の要素をvalに変更する"""
i += self.size
self.node[i] = val
while i > 1:
i >>= 1
self.node[i] = self.op(self.node[i << 1], self.node[(i << 1) + 1])
def get_val(self, l, r):
"""[l, r)の畳み込みの結果を返す"""
l, r = l + self.size, r + self.size
res_l, res_r = self.e, self.e
while l < r:
if l & 1:
res_l = self.op(res_l, self.node[l])
l += 1
if r & 1:
r -= 1
res_r = self.op(self.node[r], res_r)
l, r = l >> 1, r >> 1
return self.op(res_l, res_r)
ALPH = "abcdefghijklmnopqrstuvwxyz"
to_int = {char: i for i, char in enumerate(ALPH)}
n = int(input())
s = input()
q = int(input())
query = [list(input().split()) for i in range(q)]
init = [0] * n
for i, char in enumerate(s):
init[i] = 1 << to_int[char]
op = lambda a, b: a | b
st = SegmentTree(n, op, 0)
st.build(init)
for i in range(q):
if query[i][0] == "1":
_, ind, char = query[i]
ind = int(ind) - 1
st.update(ind, 1 << to_int[char])
else:
_, l, r = query[i]
l, r = int(l) - 1, int(r)
print(bin(st.get_val(l, r)).count("1"))
| 1 | 62,435,022,033,188 | null | 210 | 210 |
import sys
input=sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
from itertools import accumulate
from itertools import permutations
from itertools import combinations
from collections import defaultdict
from collections import Counter
import fractions
import math
from collections import deque
from bisect import bisect_left
from bisect import insort_left
import itertools
from heapq import heapify
from heapq import heappop
from heapq import heappush
import heapq
import numpy as np
INF = float("inf")
#d = defaultdict(int)
#d = defaultdict(list)
#N = int(input())
#A = list(map(int,input().split()))
#S = list(input())
#S.remove("\n")
#N,M = map(int,input().split())
#S,T = map(str,input().split())
#A = [int(input()) for _ in range(N)]
#S = [input() for _ in range(N)]
#A = [list(map(int,input().split())) for _ in range(N)]
N = int(input())
if N == 1:
print("a")
else:
S = list("abcdefghij")
Q = deque([("a",1)]) #文字列、種類
while len(Q) != 0:
s,kind = Q.popleft()
for i in range(kind+1):
news = s+S[i]
if len(news) == N+1:
break
if len(news) == N:
print(news)
if i == kind:
Q.append((news,kind+1))
else:
Q.append((news,kind))
|
def find(x):
if par[x] == x:
return x
else:
par[x] = find(par[x]) #経路圧縮
return par[x]
def same(x,y):
return find(x) == find(y)
def unite(x,y):
x = find(x)
y = find(y)
if x == y:
return 0
par[x] = y
size[y] = size[x] + size[y]
size[x] = 0
N,M = map(int,input().split())
par = [ i for i in range(N+1)]
size = [1 for _ in range(N+1)]
for _ in range(M):
a,b = map(int,input().split())
unite(a,b)
A = size.count(0)
print(N-A-1)
| 0 | null | 27,473,355,756,794 | 198 | 70 |
while True:
H,W = map(int, raw_input().split(" "))
if H == 0 and W == 0:
break
else:
for h in xrange(H):
print "#" * W
print ""
|
n, k = map(int, input().split())
a = n % k
if (a <= int(k/2)):
print(a)
else:
print(k-a)
| 0 | null | 20,197,201,898,048 | 49 | 180 |
def main():
S = input()
N = len(S)
S1 = S[0:(N - 1) // 2]
S2 = S[(N + 3) // 2 - 1:]
if S == S[::-1] and S1 == S1[::-1] and S2 == S2[::-1]:
print('Yes')
else:
print('No')
if __name__ == '__main__':
main()
|
def isPalindrome(st):
l = len(st)
c = l//2
if l%2 == 1:
return st[:c] == st[c+1:][::-1]
else:
return st[:c] == st[c:][::-1]
S = input()
N = len(S)
if isPalindrome(S) and isPalindrome(S[:(N-1)//2]) and isPalindrome(S[(N+3)//2 - 1:]):
print('Yes')
else:
print('No')
| 1 | 46,113,328,462,348 | null | 190 | 190 |
n = int(input())
A = list(map(int,input().split()))
f = 1
c = 0
while f == 1:
f = 0
for j in range(n-1,0,-1):
if A[j] < A[j-1]:
inc = A[j]
A[j] = A[j-1]
A[j-1] = inc
f = 1
c += 1
print(" ".join(map(str,A)))
print(c)
|
N = int(input())
ans = (N + N%2)/(2*N)
print(ans)
| 0 | null | 88,754,717,517,710 | 14 | 297 |
n = input().split(" ")
for i,j in enumerate(n,1):
if 0 == int(j):
print(i)
|
P = 10**9+7
N, K = map(int, input().split())
S = list(map(int, input().split()))
S.sort()
ans = 0
c = 1
for i in range(N-K+1):
ans += (S[K-1+i]*c)%P
ans -= (S[N-K-i]*c)%P
ans %= P
c = c*(K+i)*pow(i+1, P-2, P)%P
print(ans)
| 0 | null | 54,511,224,499,648 | 126 | 242 |
n, m = list(map(int, input().split()))
s = input()
if s.find('1' * m) != -1:
print('-1')
exit(0)
i = n
rans = []
flag = True
while flag:
for j in range(m, 1 - 1, -1):
if i - j == 0:
flag = False
if i - j >= 0 and s[i - j] == '0':
rans.append(j)
i = i - j
break
print(' '.join(map(str,reversed(rans))))
|
import copy
n, k = map(int,input().split())
a = [0] + list(map(int,input().split()))
dist = [-1] * (n+1)
dist[1] = 0
cn = 1
d = 0
cycle = 0
while True:
d += 1
nn = a[cn]
if d == k:
ans = nn
break
if dist[nn] == -1:
dist[nn] = copy.deepcopy(d)
elif cycle == 0:
cycle = d - dist[nn]
k = (k - d) % cycle + d
if d == k:
ans = nn
break
cn = nn
print(ans)
| 0 | null | 80,731,079,043,538 | 274 | 150 |
s=input()
ans=0
if s=="SSS":
ans=0
if s=="SSR" or s=="SRS" or s=="RSS" or s=="RSR":
ans=1
if s=="RRS" or s=="SRR":
ans=2
if s=="RRR":
ans=3
print(ans)
|
S=input()
result=0
count=0
for i in S:
if i == "R":
count+=1
if count>result:
result=count
else:
count=0
print(result)
| 1 | 4,863,709,981,020 | null | 90 | 90 |
n = int(input())
S = list(map(int, input().split()))
def merge(A, left, mid, right):
cnt = 0
n1 = mid - left
n2 = right - mid
L = [0]*(n1+1)
R = [0]*(n2+1)
for i in range(n1):
L[i] = A[left + i]
for i in range(n2):
R[i] = A[mid + i]
L[n1] = float("inf")
R[n2] = float("inf")
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
return cnt
def merge_sort(A, left, right):
if left + 1 < right:
mid = (left + right)//2
cnt_left = merge_sort(A, left, mid)
cnt_right = merge_sort(A, mid, right)
cnt_merge = merge(A, left, mid, right)
cnt = cnt_left + cnt_right + cnt_merge
else:
cnt = 0
return cnt
cnt = merge_sort(S, 0, n)
print(' '.join( map(str, S) ))
print(cnt)
|
N = int(input())
*A, = list(map(int, input().split()))
count = 0
def merge(a, left, mid, right):
global count
la = a[left:mid] + [float("inf")]
ra = a[mid:right] + [float("inf")]
i, j = 0, 0
for k in range(left, right):
count += 1
if la[i] <= ra[j]:
a[k] = la[i]
i += 1
else:
a[k] = ra[j]
j += 1
def merge_sort(a, left, right):
if left + 1 < right:
mid = int((left + right) / 2)
merge_sort(a, left, mid)
merge_sort(a, mid, right)
merge(a, left, mid, right)
merge_sort(A, 0, N)
print(*A)
print(count)
| 1 | 109,285,394,500 | null | 26 | 26 |
n = int(input())
p = 10
a = 0
if n % 2 == 0:
while p <= n:
a += n // p
p *= 5
print(a)
|
N = int(input())
if N % 2 == 1:
print(0)
else:
rlt = 0
i = 10
while N // i > 0:
rlt += N // i
i *= 5
print(rlt)
| 1 | 116,110,028,820,138 | null | 258 | 258 |
N=int(input())
n=len(str(N))
res=0
for a in range(1,N+1):
a0=str(a)[0]
a1=str(a)[-1]
if a0=='0' or a1=='0':
a_res=res
continue
for i in range(1,n+1):
if i==1:
if a0==a1:
res+=1
elif i==2:
if 10*int(a1)+int(a0)<=N:
res+=1
elif i==n:
n0=str(N)[0]
n1=str(N)[-1]
if n0<a1:
res+=0
elif n0>a1:
res+=10**(i-2)
else:
res+=(N-int(a1)*10**(i-1))//10+1
if n1<a0:
res-=1
else:
res+=10**(i-2)
print(res)
|
s, t = map(str, input().split())
ans = t + s
print(ans)
| 0 | null | 94,344,927,008,570 | 234 | 248 |
import sys
input = sys.stdin.readline
from collections import *
S = input()[:-1]
if S=='SUN':
print(7)
elif S=='MON':
print(6)
elif S=='TUE':
print(5)
elif S=='WED':
print(4)
elif S=='THU':
print(3)
elif S=='FRI':
print(2)
elif S=='SAT':
print(1)
|
W, H, x, y, r = map(int, input().split())
if (x-r >= 0 and y-r >= 0 and x+r <= W and y+r <= H): print("Yes")
else: print("No")
| 0 | null | 66,676,233,298,038 | 270 | 41 |
while True:
H, W = map(int, input().split())
if not(H or W):
break
for j in range(W):
print('#', end='')
print()
for i in range(H-2):
print('#', end='')
for j in range(W-2):
print('.', end='')
print('#')
for j in range(W):
print('#', end='')
print('\n')
|
s=input()
h=s/3600
m=s/60-h*60
s=s-h*3600-m*60
print str(h)+":"+str(m)+":"+str(s)
| 0 | null | 582,993,224,048 | 50 | 37 |
class Combination():
def __init__(self, N:int, P:int):
self.N = N
self.P = P
self.fact = [1, 1]
self.factinv = [1, 1]
self.inv = [0, 1]
for i in range(2, N+1):
self.fact.append((self.fact[-1] * i) % P)
self.inv.append((-self.inv[P % i] * (P // i)) % P)
self.factinv.append((self.factinv[-1] * self.inv[-1]) % P)
def getComb(self, n:int, k:int):
if (k < 0) or (n < k):
return 0
k = min(k, n - k)
return self.fact[n] * self.factinv[k] % self.P * self.factinv[n-k] % self.P
def main():
n,k = map(int,input().split())
MOD = 10**9 +7
COMB = Combination(n,MOD)
ans = 0
for i in range(min(n, k+1)):
ans += COMB.getComb(n,i) * COMB.getComb(n-1,i)
ans %= MOD
print(ans)
if __name__ == "__main__":
main()
|
N=2*10**5+1
mod=10**9+7
f=[None]*N
fi=[None]*N
f[0]=1
for i in range(1,N):
f[i]=i*f[i-1]%mod
for i in range(N):
fi[i]=pow(f[i],mod-2,mod)
def com(n,k):
return f[n]*fi[n-k]%mod*fi[k]%mod
def hcom(n,k):
return com(n+k-1,n-1)
n,k=map(int,input().split())
ans=1
for i in range(1,min(k+1,n)):
ans=(ans+com(n,i)*hcom(n-i,i)%mod)%mod
print(ans)
| 1 | 67,180,856,328,548 | null | 215 | 215 |
s=input()
ans="No"
if len(s)%2==0:
if s=="hi"*(len(s)//2):
ans="Yes"
print(ans)
|
s=input()
if len(s)%2==0 and s == 'hi'*(len(s)//2):
print('Yes')
else:
print('No')
| 1 | 53,427,074,890,644 | null | 199 | 199 |
from collections import defaultdict
def main():
n, x, y = map(int, input().split())
ans = defaultdict(int)
for i in range(1, n + 1):
for j in range(i + 1, n + 1):
l = min(abs(i - j), abs(i - x) + abs(y - j) + 1, abs(i - y) + abs(x - j) + 1)
ans[l] += 1
[print(ans[i]) for i in range(1, n)]
if __name__ == '__main__':
main()
|
n, x, y = list(map(int, input().split()))
x = x-1
y = y-1
ans = [0] * (n-1)
for i in range(n):
for j in range(i+1, n):
shortest = min(abs(j-i), abs(x-i)+abs(y-j)+1, abs(y-i)+abs(x-j)+1)
ans[shortest-1] += 1
for a in ans:
print(a)
| 1 | 44,229,659,665,090 | null | 187 | 187 |
import sys
import numpy as np
from math import ceil as C, floor as F, sqrt
from collections import defaultdict as D, Counter as CNT
from functools import reduce as R
ALP = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
alp = 'abcdefghijklmnopqrstuvwxyz'
def _X(): return sys.stdin.readline().rstrip().split(' ')
def _S(ss): return tuple(ss) if len(ss) > 1 else ss[0]
def S(): return _S(_X())
def Ss(): return list(S())
def _I(ss): return tuple([int(s) for s in ss]) if isinstance(ss, tuple) else int(ss)
def I(): return _I(S())
def _Is(ss): return list(ss) if isinstance(ss, tuple) else [ss]
def Is(): return _Is(I())
n = I()
ans = D(int)
for _ in range(n):
s = S()
ans[s] += 1
for x in ['AC', 'WA', 'TLE', 'RE']:
print('{} x {}'.format(x, ans[x]))
|
n = int(input())
count_list = [0] * 4
for i in range(n):
text = input()
if text == "AC":
count_list[0] += 1
elif text == "WA":
count_list[1] += 1
elif text == "RE":
count_list[3] += 1
else:
count_list[2] += 1
print("AC x " + str(count_list[0]))
print("WA x " + str(count_list[1]))
print("TLE x " + str(count_list[2]))
print("RE x " + str(count_list[3]))
| 1 | 8,647,952,104,830 | null | 109 | 109 |
def main():
n = input()
A = []
for i in xrange(n):
A.append(map(int,raw_input().split()))
c,d = bfs(n,A)
for i in xrange(n):
if c[i] == -1:
print i+1, -1
else:
print i+1, d[i]
def bfs(n,A):
color = [-1]*n
d = [-1]*n
Q = []
d[0] = 0
Q.append(0)
while(True):
if len(Q)==0:
break
u = Q.pop(0)
for i in A[u][2:]:
if color[i-1] == -1:
color[i-1] = 0
d[i-1] = d[u]+1
Q.append(i-1)
color[u] = 1
return color, d
if __name__ == '__main__':
main()
|
W,H,x,y,r =map(int,input().split())
if (r<=x and x+r<=W and r<=y and y+r<=H):
print("Yes")
else:
print("No")
| 0 | null | 219,695,134,372 | 9 | 41 |
import sys
sys.setrecursionlimit(10**6)
n,k = map(int, input().split())
h = list(map(int, input().split()))
h.sort()
l = -1; r = n # 二分探索時は探索範囲は取り得る値+-1しておく
while l+1 < r:
c = (l+r)//2
if h[c] < k:
l = c
else:
r = c
print(n-(l+1))
|
A = [list(map(int, input().split())) for i in range(3)]
N = int(input())
for n in range(N):
b = int(input())
for i in range(3):
for j in range(3):
if b == A[i][j]:
A[i][j] = 0
for i in range(3):
if A[i] == [0, 0, 0]:
print('Yes')
exit()
vertical = [_[i] for _ in A]
if vertical == [0, 0, 0]:
print('Yes')
exit()
if A[0][0] == A[1][1] == A[2][2] == 0 or A[0][2] == A[1][1] == A[2][0] == 0:
print('Yes')
exit()
else:
print('No')
| 0 | null | 119,207,511,118,078 | 298 | 207 |
def main():
t1,t2=map(int,input().split())
a1,a2=map(int,input().split())
b1,b2=map(int,input().split())
if a1<b1:
a1,b1,a2,b2 = b1,a1,b2,a2
d1 = a1*t1
d2 = b1*t1
dd1 = d1 - d2
d1 += a2*t2
d2 += b2*t2
if d1 == d2:
return "infinity"
dd2 = d1 - d2
if dd1 * dd2 > 0:
return 0
else:
d1 += a1*t1
d2 += b1*t1
dd3 = d1 - d2
if dd2 * dd3 > 0:
return 1
else:
d1 += a2*t2
d2 += b2*t2
dd4 = d1 - d2
if dd3 * dd4 > 0:
return 2
else:
if dd1 > dd3:
if dd1 % (dd1-dd3) == 0:
return (dd1 // (dd1-dd3) )*2
else:
return (dd1 // (dd1-dd3) )*2+1
else:
if dd2 % (dd2-dd4) == 0:
return (dd2 // (dd2-dd4) )*2 +1
else:
return (dd2 // (dd2-dd4) )*2+2
print(main())
|
import sys
from collections import defaultdict
def input():
return sys.stdin.readline().rstrip()
def main():
T1, T2 = map(int, input().split())
A1, A2 = map(int, input().split())
B1, B2 = map(int, input().split())
len1 = T1 * A1 + T2 * A2
len2 = T1 * B1 + T2 * B2
first1 = T1 * A1
first2 = T1 * B1
second1 = T2 * A2
second2 = T2 * B2
if len1 == len2:
print("infinity")
exit()
if len1 > len2:
if first1 < first2:
a, b = divmod(first2 - first1, len1 - len2)
if b == 0:
print(a * 2)
exit()
else:
print(a * 2+1)
exit()
else:
print(0)
exit()
if len2 > len1:
if first2 < first1:
a, b = divmod(first1 - first2, len2 - len1)
if b == 0:
print(a * 2 )
exit()
else:
print(a * 2+1)
exit()
else:
print(0)
exit()
if __name__ == "__main__":
main()
| 1 | 131,521,909,256,088 | null | 269 | 269 |
N = int(input())
S = list(input())
check = S[0]
count =1
for i in range(1,N):
if(check!=S[i]):
check=S[i]
count +=1
print(count)
|
from itertools import groupby
N = int(input())
S = input()
g = groupby(S)
print(len(list(g)))
| 1 | 170,373,953,949,658 | null | 293 | 293 |
from collections import OrderedDict
n, x, y = map(int, input().split())
x = x-1
y = y-1
dist_hist = OrderedDict({i: 0 for i in range(1, n)})
for i in range(n-1):
for j in range(i+1, n):
if i<=x and j>=y:
dist = j-i + 1 - (y-x)
elif i<=x and x<j<y:
dist = min(j-i, x-i + 1 + y-j)
elif x<i<y and y<=j:
dist = min(i-x + 1 + j-y, j-i)
elif x<i<y and x<j<y:
dist = min(j-i, i-x + 1 + y-j)
else:
dist = j - i
dist_hist[dist] += 1
[print(value) for value in dist_hist.values()]
|
### ----------------
### ここから
### ----------------
import sys
from io import StringIO
import unittest
def yn(b):
print("Yes" if b==1 else "No")
return
def resolve():
readline=sys.stdin.readline
n,x,y=map(int, readline().rstrip().split())
ans = [0] * (n-1)
for i in range(1,n+1):
for j in range(i+1,n+1):
d1 = abs(i-x) + abs(j-x)
d2 = abs(i-y) + abs(j-y)
d3 = abs(i-x) + abs(j-y) + 1
d4 = abs(i-y) + abs(j-x) + 1
d5 = abs(i-j)
d=min(d1,d2,d3,d4,d5)
ans[d-1]+=1
for a in ans:
print(a)
#arr=list(map(int, readline().rstrip().split()))
#n=int(readline())
#ss=readline().rstrip()
#yn(1)
return
if 'doTest' not in globals():
resolve()
sys.exit()
### ----------------
### ここまで
### ----------------
| 1 | 44,054,918,130,432 | null | 187 | 187 |
def main():
H1, M1, H2, M2, K = map(int, input().split())
t1 = 60*H1 + M1
t2 = 60*H2 + M2
d = 0
if t1 <= t2:
d = t2 - t1
else:
d = 60*24 - t1 + t2
print(max(0, d - K))
if __name__ == "__main__":
main()
|
#!python3
import sys
input = sys.stdin.readline
def resolve():
N = int(input())
S = list(input())
Q = int(input())
c0 = ord('a')
smap = [1<<(i-c0) for i in range(c0, ord('z')+1)]
T = [0]*N + [smap[ord(S[i])-c0] for i in range(N)]
for i in range(N-1, 0, -1):
i2 = i << 1
T[i] = T[i2] | T[i2|1]
ans = []
#print(T)
for cmd, i, j in zip(*[iter(sys.stdin.read().split())]*3):
i = int(i) - 1
if cmd == "1":
if S[i] == j:
continue
S[i] = j
i0 = N + i
T[i0] = smap[ord(j)-c0]
while i0 > 1:
i0 = i0 >> 1
T[i0] = T[i0+i0] | T[i0-~i0]
elif cmd == "2":
i += N
j = int(j) + N
d1 = 0
while i < j:
if i & 1:
d1 |= T[i]
i += 1
if j & 1:
j -= 1
d1 |= T[j]
i >>= 1; j >>=1
ans.append(bin(d1).count('1'))
print(*ans, sep="\n")
if __name__ == "__main__":
resolve()
| 0 | null | 40,461,712,870,140 | 139 | 210 |
import sys
sys.setrecursionlimit(10**8)
def ii(): return int(sys.stdin.readline())
def mi(): return map(int, sys.stdin.readline().split())
def li(): return list(map(int, sys.stdin.readline().split()))
def li2(N): return [list(map(int, sys.stdin.readline().split())) for _ in range(N)]
def dp2(ini, i, j): return [[ini]*i for _ in range(j)]
def dp3(ini, i, j, k): return [[[ini]*i for _ in range(j)] for _ in range(k)]
#import bisect #bisect.bisect_left(B, a)
#from collections import defaultdict #d = defaultdict(int) d[key] += value
#from itertools import accumulate #list(accumulate(A))
N, M = mi()
C = li()
'''
# 二次元DP
dp = dp2(float('inf'), N+1, M+1)
dp[0][0] = 0
for i in range(1, M+1):
for j in range(N+1):
#if j == 0:
#dp[i][j] = 0
dp[i][j] = min(dp[i-1][j], dp[i][j])
c = C[i-1]
if j+c <= N:
dp[i][j+c] = min(dp[i][j]+1, dp[i-1][j+c])
#print(dp)
print(dp[M][N])
'''
# 1次元DP
dp = [float('inf') for i in range(N+1)]
dp[0] = 0
for i in range(M):
for j in range(N+1):
c = C[i]
if j+c <= N:
dp[j+c] = min(dp[j]+1, dp[j+c])
print(dp[N])
|
def main():
n, k = map(int, input().split())
arr = list(map(int, input().split()))
L, R = 0, max(arr)
while L+1 < R:
P = (L+R+1)//2
cnt = 0
for a in arr:
if P < a:
if a % P == 0:
cnt += a//P - 1
else:
cnt += a//P
if cnt <= k:
R = P
else:
L = P
print(R)
if __name__ == "__main__":
main()
| 0 | null | 3,347,960,892,100 | 28 | 99 |
import sys
from collections import deque
import copy
import math
def main():
A, B, N = map(int, input().split())
if B - 1 <= N:
x = B - 1
else:
x = N
ans = math.floor(A * x / B) - A * math.floor(x / B)
print(ans)
if __name__ == '__main__':
main()
|
a,b,n = map(int,input().split())
if b <= n:
k = b-1
else:
k = n
m = int(k*a/b) - a*int(k/b)
print(m)
| 1 | 28,299,378,711,580 | null | 161 | 161 |
h,w = map(int,input().split())
grid = []
for _ in range(h):
grid.append(list(input()))
dp = [[0]*(w+1) for i in range(h+1)]
#dp[i][j] = i,jでの最小の操作回数
if grid[0][0] == '#':
dp[0][0] += 1
for i in range(1,h):
p = 0
if grid[i][0] == '#' and grid[i-1][0] == '.':
p += 1
dp[i][0] = dp[i-1][0] + p
for i in range(1,w):
p = 0
if grid[0][i] == '#' and grid[0][i-1] == '.':
p += 1
dp[0][i] = dp[0][i-1] + p
for x in range(1,h):
for y in range(1,w):
a,b = 0,0
if grid[x][y] == '#' and grid[x-1][y] == '.':
a += 1
if grid[x][y] == '#' and grid[x][y-1] == '.':
b += 1
dp[x][y] = min(dp[x-1][y] + a,dp[x][y-1] + b)
print(dp[h-1][w-1])
#print(dp)
|
h, w = map(int, input().split())
g = [[0] * w for _ in range(h)]#白が1、黒が０
for i in range(h):
s = list(input())
for j in range(w):
if s[j] == '.':
g[i][j] = 1
INF = 10**9
dp = [[INF] * w for _ in range(h)]
if g[0][0] == 0:
dp[0][0] = 1
else:
dp[0][0] = 0
for i in range(h):
for j in range(w):
for dx, dy in ((1, 0), (0, 1)):
nx = j + dx
ny = i + dy
if ny >= h or nx >= w:
continue
add = 0
if g[ny][nx] == 0 and g[i][j] == 1:
add = 1
dp[ny][nx] = min(dp[ny][nx], dp[i][j] + add)
print(dp[h-1][w-1])
| 1 | 49,114,536,696,202 | null | 194 | 194 |
x = int(input())
dp = [False] * (x + 1)
dp[0] = True
items = [100, 101, 102, 103, 104, 105]
for i in items:
for j in range(x + 1):
if j + i >= x + 1:
break
dp[j + i] |= dp[j]
if dp[x]:
print(1)
else:
print(0)
|
X = int(input())
q,mod = divmod(X,100)
if 5*q<mod:
print(0)
else:
print(1)
| 1 | 126,841,922,101,062 | null | 266 | 266 |
while True:
s = input()
if s == '-': break
l = sum([int(input()) for _ in range(int(input()))]) % len(s)
print(s[l:]+s[:l])
|
N = int(input())
X_ls = list(map(int, input().split(' ')))
rst = -1
for i in range(min(X_ls), max(X_ls) + 1):
val = 0
for j in X_ls:
val += (i - j) ** 2
if rst == -1:
rst = val
else:
rst = min(rst, val)
print(rst)
| 0 | null | 33,648,997,282,702 | 66 | 213 |
N = int(input())
X = list(map(int,input().split()))
ans = float("inf")
for loc in range(-100,101):
temp = 0
for x in X:
temp += (loc-x)**2
ans = min(temp,ans)
print(ans)
|
x = int(input())
n_500 = int(x / 500)
h = 1000 * n_500
x -= 500 * n_500
n_5 = int(x / 5)
h += 5 * n_5
print(int(h))
| 0 | null | 54,146,736,432,380 | 213 | 185 |
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]
n=int(input())
lis=make_divisors(n)
#print(lis)
ans=float('inf')
l=len(lis)
for i in range(l//2):
ans=min(ans,lis[i]+lis[-1*(i+1)]-2)
if l%2:
ans=min(ans,2*(lis[l//2]-1))
print(ans)
|
x, k, d = map(int, input().split())
def sgn(x):
if x > 0:
return 1
if x < 0:
return -1
return 0
if x > 0:
x1 = x - k * d
else:
x1 = x + k * d
if sgn(x) == sgn(x1):
print(abs(x1))
exit()
xright = x % d
xleft = x % d - d
#0目前
xr = (abs(x - xright) // d) % 2
if k % 2 == xr:
print(abs(xright))
elif k % 2 != xr:
print(abs(xleft))
| 0 | null | 83,623,703,061,100 | 288 | 92 |
n = input()
x = list(map(int,raw_input().split()))
y = list(map(int,raw_input().split()))
gap = []
gap1 = 0.0
gap2 = 0.0
gap3 = 0.0
a = 0.0
for i in range(n):
gap.append(abs(x[i]-y[i]))
for i in range(n):
gap1 += gap[i]
print gap1
for i in range(n):
gap2 += gap[i] ** 2
print pow(gap2,0.5)
for i in range(n):
gap3 += gap[i] ** 3
print pow(gap3,0.3333333333)
print max(gap)
|
from math import sqrt
def g():
_ = input()
x = list(map(int, input().split()))
y = list(map(int, input().split()))
f1 = lambda it: abs(it[0]-it[1])
f2 = lambda it: (it[0]-it[1]) ** 2
f3 = lambda it: abs(it[0]-it[1]) ** 3
yield sum(map(f1, zip(x, y)))
yield sqrt(sum(map(f2, zip(x, y))))
yield sum(map(f3, zip(x, y))) ** (1/3)
yield max(map(f1, zip(x, y)))
for n in g():
print("{:.6f}".format(n))
| 1 | 212,625,406,822 | null | 32 | 32 |
N = int(input())
A = list(map(int, input().split()))
iStock = 0
iMoney = 1000
for i in range(N-1):
if A[i] < A[i + 1]:
# A[i]Day 株購入 & A[i+1]Day 株売却
iStock = iMoney // A[i]
iMoney %= A[i]
iMoney += iStock * A[i+1]
print(iMoney)
|
N = int(input())
A = list(map(int, input().split()))
Stock = 0
Money = 1000
for i in range(N-1):
if A[i] < A[i + 1]:
Stock = Money // A[i]
Money %= A[i]
Money += Stock * A[i+1]
print(Money)
| 1 | 7,407,464,240,992 | null | 103 | 103 |
#!/usr/bin/env python3
# Generated by https://github.com/kyuridenamida/atcoder-tools
from typing import *
import collections
import functools as fts
import itertools as its
import math
import sys
INF = float('inf')
def solve(S: str, T: str):
return len(T) - max(sum(s == t for s, t in zip(S[i:], T)) for i in range(len(S) - len(T) + 1))
def main():
sys.setrecursionlimit(10 ** 6)
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
S = next(tokens) # type: str
T = next(tokens) # type: str
print(f'{solve(S, T)}')
if __name__ == '__main__':
main()
|
import sys
#input = sys.stdin.buffer.readline
def main():
H,W,K = map(int,input().split())
s = [list(map(str,input())) for _ in range(H)]
ans = [[0 for _ in range(W)] for _ in range(H)]
up,down = 0,1
count = 1
for i in range(H):
if "#" not in s[i]:
if down != H:
down += 1
else:
for x in range(up,down):
for y in range(W):
ans[x][y] = ans[up-1][y]
else:
now = 0
for j in range(W):
if s[i][j] == "#":
for x in range(up,down):
for y in range(now,j+1):
ans[x][y] = count
now = j+1
count += 1
if s[i][-1] == ".":
for x in range(up,down):
for y in range(now,W):
ans[x][y] = count-1
up = down
down += 1
for i in range(H):
print(*ans[i])
if __name__ == "__main__":
main()
| 0 | null | 73,900,792,339,260 | 82 | 277 |
a, b = map(int, input().split())
ans = -1
for money in range(pow(10, 4)):
if int(money*0.08) == a and int(money*0.1) == b:
ans = money
break
print(ans)
|
MOD = int(1e9+7)
N = int(input())
# all posible list
Na = pow(10, N, MOD)
# number of list without 0
N0 = pow(9, N, MOD)
# number of list without both 0 and 9
N09 = pow(8, N, MOD)
M = Na - 2*N0 + N09
print(M%MOD)
| 0 | null | 29,975,969,002,140 | 203 | 78 |
n = int(input())
s = [None] * n
for i in range(n):
s[i] = input()
print(len(list(set(s))))
|
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
N, *A = map(int, read().split())
C = [0] * N
for a in A:
C[a-1] += 1
print(*C, sep='\n')
return
if __name__ == '__main__':
main()
| 0 | null | 31,193,208,230,844 | 165 | 169 |
def get_sieve_of_eratosthenes(n):
import math
if not isinstance(n, int):
raise TypeError('n is int type.')
if n < 2:
raise ValueError('n is more than 2')
prime = []
limit = math.sqrt(n)
data = [i + 1 for i in range(1, n)]
while True:
p = data[0]
if limit <= p:
return prime + data
prime.append(p)
data = [e for e in data if e % p != 0]
def abc149c_next_prime():
import bisect
x = int(input())
list = get_sieve_of_eratosthenes(100003)
idx = bisect.bisect_left(list, x)
print(list[idx])
abc149c_next_prime()
|
def main():
X = int(input())
if X == 2:
print(2)
exit()
if X % 2 == 0:
X += 1
while True:
flag = True
for i in range(3, X, 2):
if X % i == 0:
flag = False
break
if flag is True:
print(X)
break
else:
X += 2
if __name__ == '__main__':
main()
| 1 | 105,857,460,403,348 | null | 250 | 250 |
from collections import deque
import sys
sys.setrecursionlimit(10**7)
N,u,v=map(int, input().split())
D=[[] for i in range(N)]
for i in range(N-1):
a,b=map(int, input().split())
a-=1
b-=1
D[a].append(b)
D[b].append(a)
Taka=[0]*(N+1)
Aoki=[0]*(N+1)
def f(n,p,A):
for i in D[n]:
if i!=p:
A[i]=A[n]+1
f(i,n,A)
f(u-1,-1,Taka)
f(v-1,-1,Aoki)
ans=0
for i in range(N):
if Taka[i]<Aoki[i]:
ans=max(ans,Aoki[i]-1)
print(ans)
|
import sys
import math
def check(k, w, P):
i = 0
for t in range(k):
p = 0
while p + w[i] <= P:
p += w[i]
i += 1
if i == len(w):
return True
return False
def allocate(k, w):
t = [0] * k
le = 0
ri = 100000 * 10000
while ri - le > 1:
P = (ri + le) / 2
if check(k, w, P):
ri = P
else:
le = P
return ri
if __name__ == "__main__":
w = sys.stdin.readlines()
k = int(w[0].split()[1])
del w[0]
w = [int(wi) for wi in w]
print allocate(k, w)
| 0 | null | 58,948,200,857,950 | 259 | 24 |
import sys
sys.setrecursionlimit(10 ** 8)
n, u, v = map(int, input().split())
to = [[] for _ in range(n + 1)]
for _ in range(n - 1):
a, b = map(int, input().split())
to[a].append(b)
to[b].append(a)
def DFS(s, dist, to, d = 0, p = -1):
dist[s] = d
for v in to[s]:
if v == p:
continue
DFS(v, dist, to, d + 1, s)
def calcDist(s, dist, to):
DFS(s, dist, to)
distU = [0] * (n + 1)
distV = [0] * (n + 1)
calcDist(u, distU, to)
calcDist(v, distV, to)
ans = 0
for i in range(n + 1):
if distU[i] < distV[i]:
ans = max(ans, distV[i])
print(ans - 1)
|
n, u, v = map(int, input().split())
tree = [[] for i in range(n+1)]
for i in range(n-1):
a, b = map(int, input().split())
tree[a].append(b)
tree[b].append(a)
dist1 = [100005]*(n+1)
q = []
q.append(v)
dist1[v] = 0
while q:
now = q.pop()
for next in tree[now]:
if dist1[next] == 100005:
q.append(next)
dist1[next] = dist1[now] + 1
dist2 = [100005]*(n+1)
q = []
q.append(u)
dist2[u] = 0
while q:
now = q.pop()
for next in tree[now]:
if dist2[next] == 100005:
q.append(next)
dist2[next] = dist2[now] + 1
for i in range(1, n+1):
if dist1[i] <= dist2[i]:
dist2[i] = -1
for i in range(1, n+1):
if dist2[i] != -1:
dist2[i] = 100005
q = []
q.append(u)
dist2[u] = 0
while q:
now = q.pop()
for next in tree[now]:
if dist2[next] == 100005:
q.append(next)
dist2[next] = dist2[now] + 1
ans = 0
for i in range(1, n+1):
if dist2[i] != -1:
ans = max(ans, dist1[i])
print(ans-1)
| 1 | 117,487,491,005,680 | null | 259 | 259 |
n = int(input())
lis = list(map(int, input().split()))
cnt = 0
a = 1
for i in range(n):
if lis[i] == a:
cnt += 1
a += 1
if cnt == 0:
print(-1)
else:
print(n-cnt)
|
n = int(input())
a = list(map(int,input().split()))
cnt = 0
for v in a:
if v == cnt+1:
cnt += 1
print(-1 if cnt==0 else n-cnt)
| 1 | 114,387,245,156,320 | null | 257 | 257 |
import collections
n = int(input())
s_ls = []
dic = collections.defaultdict(int)
for i in range(n):
[s,t] = [j for j in input().split()]
s_ls.append(s)
dic[s] = int(t)
x = input()
f = 0
ans = 0
for i in range(n):
if f:
ans += dic[s_ls[i]]
if x == s_ls[i]:
f = 1
print(ans)
|
import math
r = float(raw_input())
print '%.5f %.5f' % (r*r*math.pi, 2*r*math.pi)
| 0 | null | 48,838,826,613,818 | 243 | 46 |
import sys
input = sys.stdin.buffer.readline
import copy
def main():
N,M = map(int,input().split())
a = list(map(int,input().split()))
a.sort()
MOD = 10**9+7
fac = [0 for _ in range(N+1)]
fac[0],fac[1] = 1,1
invfac = copy.deepcopy(fac)
for i in range(2,N+1):
fac[i] = (fac[i-1]*i)%MOD
invfac[-1] = pow(fac[-1],MOD-2,MOD)
for i in range(N,0,-1):
invfac[i-1] = (invfac[i]*i)%MOD
def coef(x,y):
num = (((fac[x]*invfac[y])%MOD)*invfac[x-y]%MOD)
return num
p,m = 0,0
for i in range(N-M+1):
comb = coef(N-i-1,M-1)
p += a[-i-1]*comb
m += a[i]*comb
print((p-m)%MOD)
if __name__ == "__main__":
main()
|
class Combination:
def __init__(self, n_max, mod=10**9+7):
# O(n_max + log(mod))
self.mod = mod
f = 1
self.fac = fac = [f]
for i in range(1, n_max+1):
f = f * i % mod
fac.append(f)
f = pow(f, mod-2, mod)
self.facinv = facinv = [f]
for i in range(n_max, 0, -1):
f = f * i % mod
facinv.append(f)
facinv.reverse()
# "n 要素" は区別できる n 要素
# "k グループ" はちょうど k グループ
def __call__(self, n, r): # self.C と同じ
return self.fac[n] * self.facinv[r] % self.mod * self.facinv[n-r] % self.mod
def C(self, n, r):
if not 0 <= r <= n: return 0
return self.fac[n] * self.facinv[r] % self.mod * self.facinv[n-r] % self.mod
def P(self, n, r):
if not 0 <= r <= n: return 0
return self.fac[n] * self.facinv[n-r] % self.mod
def H(self, n, r):
if (n == 0 and r > 0) or r < 0: return 0
return self.fac[n+r-1] * self.facinv[r] % self.mod * self.facinv[n-1] % self.mod
def rising_factorial(self, n, r): # 上昇階乗冪 n * (n+1) * ... * (n+r-1)
return self.fac[n+r-1] * self.facinv[n-1] % self.mod
def stirling_first(self, n, k): # 第 1 種スターリング数 lru_cache を使うと O(nk) # n 要素を k 個の巡回列に分割する場合の数
if n == k: return 1
if k == 0: return 0
return (self.stirling_first(n-1, k-1) + (n-1)*self.stirling_first(n-1, k)) % self.mod
def stirling_second(self, n, k): # 第 2 種スターリング数 O(k + log(n)) # n 要素を区別のない k グループに分割する場合の数
if n == k: return 1 # n==k==0 のときのため
return self.facinv[k] * sum((-1)**(k-m) * self.C(k, m) * pow(m, n, self.mod) for m in range(1, k+1)) % self.mod
def balls_and_boxes_3(self, n, k): # n 要素を区別のある k グループに分割する場合の数 O(k + log(n))
return sum((-1)**(k-m) * self.C(k, m) * pow(m, n, self.mod) for m in range(1, k+1)) % self.mod
def bernoulli(self, n): # ベルヌーイ数 lru_cache を使うと O(n**2 * log(mod))
if n == 0: return 1
if n % 2 and n >= 3: return 0 # 高速化
return (- pow(n+1, self.mod-2, self.mod) * sum(self.C(n+1, k) * self.bernoulli(k) % self.mod for k in range(n))) % self.mod
def faulhaber(self, k, n): # べき乗和 0^k + 1^k + ... + (n-1)^k
# bernoulli に lru_cache を使うと O(k**2 * log(mod)) bernoulli が計算済みなら O(k * log(mod))
return pow(k+1, self.mod-2, self.mod) * sum(self.C(k+1, j) * self.bernoulli(j) % self.mod * pow(n, k-j+1, self.mod) % self.mod for j in range(k+1)) % self.mod
def lah(self, n, k): # n 要素を k 個の空でない順序付き集合に分割する場合の数 O(1)
return self.C(n-1, k-1) * self.fac[n] % self.mod * self.facinv[k] % self.mod
def bell(self, n, k): # n 要素を k グループ以下に分割する場合の数 O(k**2 + k*log(mod))
return sum(self.stirling_second(n, j) for j in range(1, k+1)) % self.mod
# x * x が選ばれ、かつそれ以外はすべて x 以下が選ばれる場合の数
N, K = map(int, input().split())
A = sorted(map(int, input().split()))
ans_max = ans_min = 0
mod = 10**9+7
comb = Combination(101010)
for i, a in enumerate(A):
ans_max += a * comb.C(i, K-1)
ans_min += a * comb.C(N-1-i, K-1)
ans = (ans_max - ans_min) % mod
print(ans)
| 1 | 95,538,060,794,720 | null | 242 | 242 |
#!/usr/bin/env python3
# Generated by https://github.com/kyuridenamida/atcoder-tools
from typing import *
import collections
import functools
import itertools
import math
import sys
INF = float('inf')
def solve(H: int):
return 1 if H == 1 else solve(H//2) * 2 + 1
def main():
sys.setrecursionlimit(10 ** 6)
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
H = int(next(tokens)) # type: int
print(f'{solve(H)}')
if __name__ == '__main__':
main()
|
n = int(input())
def saiki(i):
if i > 1:
return 2 * saiki(i // 2) + 1
if i == 1:
return 1
print(saiki(n))
| 1 | 79,618,040,054,810 | null | 228 | 228 |
s=input()
t=input()
lent=len(t)
num=lent
ls=[]
count=0
for i in range(len(s)-lent+1):
st=s[i:i+num]
num+=1
for j in range(lent):
if st[j]!=t[j]:
count+=1
ls.append(count)
count=0
print(min(ls))
|
s = input()
t = input()
ans = len(t)
for i in range(len(s) - len(t) + 1):
tmp = s[i:i+len(t)]
count = 0
for t1, t2 in zip(tmp, t):
if t1 != t2:
count += 1
ans = min(ans, count)
print(ans)
| 1 | 3,673,936,918,948 | null | 82 | 82 |
S=input()
cnt=0
for i in range(len(S)//2):
cnt+=S[i]!=S[-i-1]
print(cnt)
|
n = int(input())
a,b = divmod(n,2)
print(a+b)
| 0 | null | 89,531,954,067,030 | 261 | 206 |
n=int(input())
a=list(map(int,input().split()))+[0]
b=[0]*(n+1)
b[0]=1-a[0]
r=sum(a)-a[0]-a[1]
for i in range(1,n+1):
b[i]=min(r,b[i-1]*2-a[i])
r-=a[i+1]
if any(i<0 for i in b):print(-1)
else:print(sum(a)+sum(b))
|
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, tan, asin, acos, atan, radians, degrees, log2, gcd
from itertools import accumulate, permutations, combinations, combinations_with_replacement, product, groupby
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left, insort, insort_left
from heapq import heappush, heappop, heapify
from functools import reduce, lru_cache
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def TUPLE(): return tuple(map(int, input().split()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7
#mod = 998244353
from decimal import *
#import numpy as np
#decimal.getcontext().prec = 10
N = INT()
A = LIST()
LR = [[A[-1], A[-1]]]
for i, b in enumerate(A[::-1][1:], 1):
if N-i+1 < 30:
LR.append([-(-LR[-1][0]//2)+b, min(LR[-1][1]+b, pow(2, N-i+1))])
else:
LR.append([-(-LR[-1][0]//2)+b, LR[-1][1]+b])
LR = LR[::-1]
if LR[0][0] <= 1 <= LR[0][1]:
pass
else:
print(-1)
exit()
ans = 1
tmp = 1
for i, (L, R) in enumerate(LR[1:], 1):
tmp = min(2*tmp-A[i], R-A[i])
ans += tmp+A[i]
print(ans)
| 1 | 18,880,698,828,868 | null | 141 | 141 |
N, K = list(map(int, input().split(' ')))
marks = list(map(int, input().split(' ')))
for i in range(N-K):
if marks[i] < marks[K+i]:
print('Yes')
else:
print('No')
|
N,K=list(map(int, input().split()))
A=list(map(int, input().split()))
ans=[None]*(N-K)
for i in range(N-K):
if A[K+i]>A[i]:
ans[i]='Yes'
else:
ans[i]='No'
print(*ans, sep='\n')
| 1 | 7,097,475,381,052 | null | 102 | 102 |
N = int(input())
A = list(map(int, input().split()))
subordinate_cnt = [0] * N
for boss_num in A:
subordinate_cnt[boss_num - 1] += 1
print("\n".join(map(str, subordinate_cnt)))
|
N = int(input())
A = list(map(int,input().split()))
buka = [0]*N
for p in range(N-1):
buka[A[p] -1] += 1
for q in range(N):
print(buka[q])
| 1 | 32,455,990,805,030 | null | 169 | 169 |
n, k = map(int, input().split())
a_nums = list(map(int, input().split()))
f_point = sum(a_nums[:k])
for i in range(n - k):
if a_nums[i] < a_nums[i + k]:
print("Yes")
else:
print("No")
|
n, k = map(int, input().split())
al = list(map(int, input().split()))
for i in range(k, n):
if al[i-k] < al[i]:
print('Yes')
else:
print('No')
| 1 | 7,088,988,909,412 | null | 102 | 102 |
n = int(input())
a = list(map(int,input().split()))
ans = {i:0 for i in range(n)}
for i in a:
ans[i-1] += 1
for i in ans.values():
print(i)
|
n=int(input())
a=list(map(int,input().split()))
if n//2==1:
print(max(a))
exit()
if n%2==0:
#iは桁数、jはそれまでに余計に飛ばした数
#dp[i][j]
dp=[[-10**9]*2 for _ in range(n)]
for i in range(n):
if i<2:
dp[i][0]=a[i]
if i>=2:
dp[i][0]=dp[i-2][0]+a[i]
if i>=3:
dp[i][1]=max(dp[i-2][1]+a[i],dp[i-3][0]+a[i])
#print(dp)
print(max([dp[-1][1],dp[-1][0],dp[n-2][0]]))
else:
#iは桁数、jはそれまでに余計に飛ばした数
#dp[i][j]
dp=[[-10**9]*3 for _ in range(n)]
for i in range(n):
if i<2:
dp[i][0]=a[i]
if i>=2:
dp[i][0]=dp[i-2][0]+a[i]
if i>=3:
dp[i][1]=max(dp[i-2][1]+a[i],dp[i-3][0]+a[i])
if i>=4:
dp[i][2]=max([dp[i-2][2]+a[i],dp[i-3][1]+a[i],dp[i-4][0]+a[i]])
#print(dp)
print(max([dp[-1][2],dp[-1][1],dp[-1][0]-a[0],dp[-1][0]-a[-1]]))
| 0 | null | 35,000,394,688,480 | 169 | 177 |
n = int(input())
if n%2 == 1:
print(0)
else:
answer = 0
count = 1
n=n//2
while 5**count <= n:
answer += n//pow(5,count)
count+=1
print(answer)
|
N=int(input())
if N%2:
print(0)
else:
X=0
Y=N//5
while Y:
X+=Y//2
Y//=5
print(X)
| 1 | 115,773,186,498,870 | null | 258 | 258 |
def linearSearch(S, T):
cnt = 0
for e in T:
if e in S:
cnt += 1
return cnt
def main():
n = int(input())
s = list(map(int, input().split()))
q = int(input())
t = list(map(int, input().split()))
print(linearSearch(s, t))
if __name__ == "__main__":
main()
|
n = int(input())
s = [int(i) for i in input().split()]
q = int(input())
t = [int(i) for i in input().split()]
ans = 0
for si in set(s):
if si in t:
ans += 1
print(ans)
| 1 | 66,138,179,338 | null | 22 | 22 |
N=int(input())
r=[0]*10000
for i in range(1,101):
for j in range(1,101):
for k in range(1,101):
v = i*i + j*j + k*k + i*j + i*k + k*j
if v <= 10000:
r[v-1] += 1
for i in range(N):
print(r[i])
|
import math
n = int(input())
# 1以外のNの約数
divisors = []
for i in range(1, int(math.sqrt(n)) + 1):
if n % i == 0:
divisors.append(i)
if i ** 2 != n:
divisors.append(n // i)
divisors.sort()
candidates = set()
for k in divisors[1:]:
tmp = n
while True:
if tmp % k != 0:
break
tmp = tmp // k
if (tmp - 1) % k == 0:
candidates.add(k)
# N-1の約数
divisors = []
for i in range(1, int(math.sqrt(n-1)) + 1):
if (n-1) % i == 0:
divisors.append(i)
if i ** 2 != n-1:
divisors.append((n-1) // i)
for k in divisors[1:]:
candidates.add(k)
print(len(candidates))
| 0 | null | 24,653,470,224,388 | 106 | 183 |
a,b,c=map(int,input().split())
y=0
for i in range(b-a+1):
j=1
while (i+a)*j <= c:
if (i+a)*j==c:
y+=1
break
j+=1
print(y)
|
S = input()
l_s = len(S)
cnt = 0
for i in range(0,l_s//2):
if S[i] != S[-i-1]:
cnt += 1
print(cnt)
| 0 | null | 60,126,669,348,942 | 44 | 261 |
mod = 10**9 + 7
max_N = 2 * 10**5
def power(b, e):
if e == 0: return 1
half = power(b, e // 2)
if e % 2 == 0:
return (half * half) % mod
else:
return (((half * half) % mod) * b) % mod
def mod_inv(n):
return power(n, mod - 2)
fac = [1] * (max_N + 1)
for i in range(1, max_N + 1):
fac[i] = (i * fac[i - 1]) % mod
fac_inv = [1] * (max_N + 1)
fac_inv[max_N] = mod_inv(fac[max_N])
for i in range(max_N - 1, -1, -1):
fac_inv[i] = (fac_inv[i + 1] * (i + 1)) % mod
def choose(n, k):
return (((fac[n] * fac_inv[k]) % mod) * fac_inv[n - k]) % mod
if __name__ == "__main__":
line = input().split(" ")
N, K = int(line[0]), int(line[1])
K = min(K, N - 1)
ans = 0
for i in range(K + 1):
ans = (ans + (choose(N, i) * choose(N - i - 1 + i, i)) % mod) % mod
print(ans)
|
def solve(a, b):
if a % b == 0:
return b
else:
return solve(b, a % b)
while True:
try:
a, b = map(int, input().split())
lcm = solve(a,b)
print(lcm, a * b // lcm)
except:
break
| 0 | null | 33,355,383,967,348 | 215 | 5 |
nums = [int(e) for e in input().split()]
if nums[0] > nums[1]:
print("safe")
else:
print("unsafe")
|
s,w = map(int,input().split())
print("safe") if s > w else print("unsafe")
| 1 | 29,351,084,796,798 | null | 163 | 163 |
import numpy as np
class Combination :
def __init__ (self, N=10**6, mod=10**9+7) :
self.mod = mod
self.fact = [1, 1]
self.factinv = [1, 1]
self.inv = [0, 1]
for i in range(2, N+1) :
self.fact.append( (self.fact[-1] * i) % mod )
self.inv .append( (-self.inv[mod%i] * (mod//i) ) % mod )
self.factinv.append( (self.factinv[-1] * self.inv[-1]) % mod )
def nCr(self, n, r) :
if ( r < 0 ) or ( n < r ) : return 0
r = min(r, n-r)
return self.fact[n]*self.factinv[r]*self.factinv[n-r] % self.mod
def nPr(self, n, r) :
if ( r < 0 ) or ( n < r ) : return 0
return self.fact[n]*self.factinv[n-r] % self.mod
n, k = map(int, input().split())
mod = 10**9+7
comb = Combination(2*10**5+100)
ans = 0
for m in range(min(n+1,k+1)) :
ans = ans%mod + (comb.nCr(n,m) * comb.nCr(n-1, n-m-1))%mod
print(ans%mod)
|
N = int(input())
A = map(int, input().split())
B = [3 if i == 0 else 0 for i in range(N + 1)]
MOD = 1000000007
ans = 1
for a in A:
ans = ans * B[a] % MOD
if ans == 0:
break
else:
B[a] -= 1
B[a + 1] += 1
print(ans)
| 0 | null | 98,816,486,761,188 | 215 | 268 |
n = input()
multiplication_table_List = []
for i in range(1,10):
for j in range(1,10):
multiplication_table_List.append(str(i*j))
if n in multiplication_table_List:
print('Yes')
else:
print('No')
|
n = int(input())
for i in range(1,11):
if i==10:
print("No")
break
if n%i == 0 and n/i < 10:
print("Yes")
break
| 1 | 160,226,320,440,626 | null | 287 | 287 |
rate = int(input())
print(10 - rate // 200)
|
# -*- coding: utf-8 -*-
def main():
import sys
input = sys.stdin.readline
x = int(input())
print(10 - x // 200)
if __name__ == '__main__':
main()
| 1 | 6,719,343,045,148 | null | 100 | 100 |
import math
h, a = map(int, input().split())
print(math.ceil(h/a))
|
import numpy as np
from scipy.sparse import csr_matrix
from scipy.sparse.csgraph import floyd_warshall
n, m, l = map(int, input().split())
INF = 1 << 60
# 距離のmatrixを作る
dist = [[INF] * n for _ in range(n)]
# 対角行列の成分は０
for i in range(n):
dist[i][i] = 0
# 燃料の最大値より小さい場合に辺が張れる
for _ in range(m):
a, b, c = map(int, input().split())
a -= 1
b -= 1
if c > l:
continue
dist[a][b] = c
dist[b][a] = c
# 全点間の最短距離を求める
dist = floyd_warshall(csr_matrix(dist))
# 初期状態を１にする。燃料が足りない経路は迂回したいのでINFを置いておく
dist2 = np.full_like(dist, 1)
dist2[np.where(dist > l)] = INF
# 足し込むことで何回給油するべきかがわかる
dist2 = floyd_warshall(dist2, directed=False)
dist2 = dist2.astype(int)
# 無限大の経路は辿れない。-1を出力したいので０を置いていく
dist2[dist2 == INF] = 0
q = int(input())
# 初期状態を１としているので、１を引いて答えとする
ans = []
for _ in range(q):
s, t = map(int, input().split())
ans.append(dist2[s - 1, t - 1] - 1)
print(*ans, sep="\n")
| 0 | null | 124,773,367,196,992 | 225 | 295 |
n = int(input())
s = ""
al = "abcdefghijklmnopqrstuvwxyz"
while n > 0:
o = (n-1) % 26
n = (n-1) // 26
s += al[int(o)]
print(s[::-1])
|
def num2alpha(num):
if num<=26:
return chr(64+num)
elif num%26==0:
return num2alpha(num//26-1)+chr(90)
else:
return num2alpha(num//26)+chr(64+num%26)
n = int(input())
ans = num2alpha(n)
print(ans.lower())
| 1 | 11,933,353,231,900 | null | 121 | 121 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.