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
|
|---|---|---|---|---|---|---|
s = input()
for _ in range(int(input())):
c = input().split()
a = int(c[1])
b = int(c[2])
if c[0] == "replace":
s = s[:a] + c[3] + s[b+1:]
elif c[0] == "reverse":
s = s[:a] + s[a:b+1][::-1] + s[b+1:]
else:
print(s[a:b+1])
| N=int(input())
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])[1:]
F = make_divisors(N)
count = 0
for f in F:
n = N
while 1:
if n % f != 0:
n = n % f
else:
n = n // f
if n < f:
break
if n == 1: count += 1
print(count + len(make_divisors(N-1))) | 0 | null | 21,880,738,892,140 | 68 | 183 |
numberOfArray=int(input())
arrayList=list(map(int,input().split()))
def bubbleSort():
frag=1
count=0
while frag:
frag=0
for i in range(1,numberOfArray):
if arrayList[i-1]>arrayList[i]:
arrayList[i-1],arrayList[i]=arrayList[i],arrayList[i-1]
frag=1
count+=1
arrayForReturn=str(arrayList[0])
for i2 in range(1,numberOfArray):
arrayForReturn+=" "+str(arrayList[i2])
print(arrayForReturn)
print(count)
#------------------main--------------
bubbleSort()
| import sys
sys.setrecursionlimit(10**8)
N = int(input())
X = input()
if X == '0':
for _ in range(N):
print(1)
exit()
mem = [None] * (200005)
mem[0] = 0
def f(n):
if mem[n] is not None: return mem[n]
c = bin(n).count('1')
r = 1 + f(n%c)
mem[n] = r
return r
for i in range(200005):
f(i)
cnt = X.count('1')
a,b = cnt+1, cnt-1
ans = [None] * N
n = 0
for c in X:
n *= 2
n += int(c)
n %= a
for i,c in reversed(list(enumerate(X))):
if c=='1': continue
ans[i] = mem[(n+pow(2,N-i-1,a))%a] + 1
if b:
n = 0
for c in X:
n *= 2
n += int(c)
n %= b
for i,c in reversed(list(enumerate(X))):
if c=='0': continue
ans[i] = mem[(n-pow(2,N-i-1,b))%b] + 1
else:
for i in range(N):
if ans[i] is None:
ans[i] = 0
print(*ans, sep='\n') | 0 | null | 4,067,761,157,490 | 14 | 107 |
X, Y, A, B, C = map(int, input().split())
P = list(map(int, input().split()))
Q = list(map(int, input().split()))
R = list(map(int, input().split()))
P.sort(reverse=True)
Q.sort(reverse=True)
temp = P[:X] + Q[:Y] + R
temp.sort(reverse=True)
ans = sum(temp[:X+Y])
print(ans) | # -*- coding: utf-8 -*-
import sys
def main():
N = int( sys.stdin.readline() )
c_list = list(sys.stdin.readline().rstrip())
num_R = c_list.count("R")
cnt = 0
for i in range(num_R):
if c_list[i] == "W":
cnt += 1
print(cnt)
if __name__ == "__main__":
main()
| 0 | null | 25,747,808,935,748 | 188 | 98 |
from math import pi
r = float(input())
S = r * r * pi
L = 2 * r * pi
print(f'{(S):.6f} {(L):.6f}')
| x,y,a,b,c=map(int,input().split())
p=list(map(int,input().split()))
q=list(map(int,input().split()))
r=list(map(int,input().split()))
p=sorted(p,reverse=True)
q=sorted(q,reverse=True)
r=sorted(r)
box=[]
ans=0
for i in range(x):
box.append(p[i])
for j in range(y):
box.append(q[j])
box = box + r
box=sorted(box,reverse=True)
for k in range(x+y):
ans+=box[k]
print(ans) | 0 | null | 22,824,181,578,660 | 46 | 188 |
def find(x):
if parent[x]<0:
return x
else:
parent[x]=find(parent[x])
return parent[x]
def same(x,y):
return find(x)==find(y)
def union(x,y):
root_x=find(x)
root_y=find(y)
if root_x==root_y:
return
if parent[root_x]>parent[root_y]:
root_x,root_y=root_y,root_x
parent[root_x]+=parent[root_y]
parent[root_y]=root_x
def members(n,x):
root=find(x)
return [i for i in range(n) if find(i)==root]
def get_size(x):
return -parent[find(x)]
def get_root():
return [i for i, root in enumerate(parent) if root<0]
N,M=map(int,input().split())
parent=[-1 for i in range(N)]
for i in range(M):
a,b=map(int,input().split())
a=a-1
b=b-1
union(a,b)
ans=0
for i in parent:
if i<0:
ans+=1
print(ans-1) | import sys
from bisect import *
from collections import deque
pl=1
#from math import *
from copy import *
#sys.setrecursionlimit(10**6)
if pl:
input=sys.stdin.readline
else:
sys.stdin=open('input.txt', 'r')
sys.stdout=open('outpt.txt','w')
def li():
return [int(xxx) for xxx in input().split()]
def fi():
return int(input())
def si():
return list(input().rstrip())
def mi():
return map(int,input().split())
def find(i):
if i==a[i]:
return i
a[i]=find(a[i])
return a[i]
def union(x,y):
xs=find(x)
ys=find(y)
if xs!=ys:
if rank[xs]<rank[ys]:
xs,ys=ys,xs
rank[xs]+=1
a[ys]=xs
t=1
while t>0:
t-=1
n,m=mi()
a=[i for i in range(n+1)]
rank=[0 for i in range(n+1)]
for i in range(m):
x,y=mi()
union(x,y)
s=set()
for i in range(1,n+1):
a[i]=find(i)
s.add(a[i])
print(len(s)-1)
| 1 | 2,251,036,738,048 | null | 70 | 70 |
n = int(input())
s = input()
c_curr = ""
ans = 0
for c in s:
if c != c_curr:
ans += 1
c_curr = c
print(ans)
| n = int(input())
a = list(map(int,input().split()))
number = len(a)
count = 0
for i in range(0,number,2):
if a[i]%2 == 1:
count += 1
print(count)
| 0 | null | 89,257,334,802,610 | 293 | 105 |
N,A,B = map(int, input().split())
div, mod = divmod(N, A+B)
print(div*A + min(mod,A)) | n, a, b = map(int, input().split())
div, mod = divmod(n, a + b)
print(div * a + min(a, mod)) | 1 | 55,465,912,600,322 | null | 202 | 202 |
N, M, K = map(int, input().split())
A = [0] + list(map(int, input().split()))
B = [0] + list(map(int, input().split()))
for i in range(1, N+1):
A[i] += A[i-1]
i = N
total = 0
ans = 0
for j in range(M+1):
total += B[j]
while i >= 0 and A[i]+total > K:
i -= 1
if A[i]+total <= K:
ans = max(ans, i+j)
print(ans) | n, m, k = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
a = [0 for i in range(n+1)]
b = [0 for j in range(m+1)]
for i in range(n):
a[i+1] = a[i]+A[i]
for j in range(m):
b[j+1] = b[j]+B[j]
j = m
res = 0
for i in range(n+1):
if a[i] > k:
break
while k - a[i] < b[j]:
j -= 1
res = max(res, i+j)
print(res) | 1 | 10,787,025,430,298 | null | 117 | 117 |
import sys
input = sys.stdin.readline
import collections
import bisect
def main():
n = int(input())
l = input_list()
l.sort()
ans = 0
for i in range(n-2):
for j in range(i+1, n-1):
ind = bisect.bisect_left(l, l[i]+l[j])
num = ind - 1 - j
ans += num
print(ans)
def input_list():
return list(map(int, input().split()))
def input_list_str():
return list(map(str, input().split()))
if __name__ == "__main__":
main()
| import itertools # accumulate, compress, permutations(nPr), combinations(nCr)
import bisect # bisect_left(insert位置), bisect_right(slice用)
# import math # factorical（階乗) # hypot(距離)
# import heapq
# from fractions import gcd # Python3.5以前 # lcm（最小公倍数） = (a*b)//gcd(a,b)
# from fractions import Fraction
# from math import gcd # Python3.6以降
# --------------------------------------------------------------
n = int(input())
bo = list(map(int,input().split()))
cnt = 0
bo.sort()
for a in range(n-1):
for b in range(a+1,n):
cnt += bisect.bisect_left(bo, bo[a]+bo[b]) - (b+1)
print(cnt) | 1 | 172,175,084,733,790 | null | 294 | 294 |
[[print("{}x{}={}".format(i,j,i*j))for j in range(1,10)]for i in range(1,10)]
| i = 0
while i < 9:
i = i + 1
j = 0
while j < 9:
j = j + 1
print (str(i) + 'x' + str(j) + '=' + str(i*j))
| 1 | 3,394,952 | null | 1 | 1 |
s = input()
t = input()
print(sum(s[i] != t[i] for i in range(len(s))))
| # -*- coding: utf-8 -*-
import sys
point = '.'
sharp = '#'
while True:
H, W = map(int, raw_input().split())
if H == W == 0:
break
for h in xrange(H):
for w in xrange(W):
if h % 2 == 0:
if w % 2 == 0:
sys.stdout.write(sharp),
else:
sys.stdout.write(point),
else:
if w % 2 == 0:
sys.stdout.write(point)
else:
sys.stdout.write(sharp)
print
print | 0 | null | 5,719,676,557,280 | 116 | 51 |
val = input()
if val[2:3] == val[3:4] and val[4:5] == val[5:6]:
print("Yes")
else:
print("No") | s = input()
print('Yes') if s[2:3] == s[3:4] and s[4:5] == s[5:6] else print('No') | 1 | 42,049,354,915,200 | null | 184 | 184 |
A,B = map(int,input().split())
if A<=9 and B<=9:print(A*B)
else : print(-1) | if __name__ == '__main__':
A, B = map(int, input().split())
print(A*B)
| 0 | null | 86,673,755,843,990 | 286 | 133 |
N = int(input())
ans = [0 for _ in range(10050)]
for i in range(1, 105):
for j in range(1, 105):
for k in range(1, 105):
v = i**2 + j**2 + k**2 + i*j + j*k + k*i
if v<10050:
ans[v] += 1
for i in range(N):
print(ans[i+1]) | N = int(input())
L = [0]*10001
for x in range(1,101):
for y in range(1,101):
for z in range(1,101):
if x**2 + y**2 + z**2 + x*y + y*z +z*x <= 10000:
L[x**2 + y**2 + z**2 + x*y + y*z +z*x] += 1
for k in range(1,N+1):
print(L[k])
| 1 | 8,012,842,401,710 | null | 106 | 106 |
import bisect
N = int(input())
L = list(map(int, input().split()))
L.sort()
ans = 0
for i in range(N - 1, 1, -1):
for j in range(i - 1, 0, -1):
x = bisect.bisect(L, L[i] - L[j])
ans += max((j - x), 0)
print(ans)
| import sys
input = sys.stdin.readline
# D - Triangles
def binary_search(i, j):
global N
left = j
right = N
while right - left > 1:
mid = (left + right) // 2
if is_match(mid, i, j):
left = mid
else:
right = mid
return left
def is_match(mid, i, j):
global L
a = L[i]
b = L[j]
c = L[mid]
if b < c + a and c < a + b:
return True
else:
return False
N = int(input())
L = list(map(int, input().split()))
L.sort()
ans = 0
for i in range(N - 2):
for j in range(i + 1, N - 1):
k = binary_search(i, j)
if k > j and k < N:
ans += k - j
print(ans) | 1 | 172,168,981,806,302 | null | 294 | 294 |
x=input()
y=x.split(" ")
n=int(y[0])
g=input()
h=g.split(" ")
su=0
for b in h:
su+=int(b)
if(su>n):
print(-1)
else:
print(n-su)
| n, m = map(int, input().split())
work = list(map(int, input().split()))
if n - sum(work) < 0:
print("-1")
else:
print(n - sum(work))
| 1 | 31,793,176,767,856 | null | 168 | 168 |
# https://atcoder.jp/contests/abc159/tasks/abc159_e
import sys
ans = sys.maxsize
H, W, K = map(int, input().split())
s = [input() for _ in range(H)]
for h in range(1 << (H - 1)):
g = 0
ids = [-1 for _ in range(H)]
for i in range(H):
ids[i] = g
if (h >> i) & 1:
g += 1
g += 1
num = g - 1
if num >= ans:
continue
c = [[0] * W for _ in range(g)]
for i in range(H):
for j in range(W):
c[ids[i]][j] = c[ids[i]][j] + (s[i][j] == '1')
now = [0 for _ in range(g)]
def add(j):
for i in range(g):
now[i] += c[i][j]
for i in range(g):
if now[i] > K:
return False
return True
for j in range(W):
if not add(j):
num += 1
if num >= ans:
continue
now = [0 for _ in range(g)]
if not add(j):
num = sys.maxsize
break
ans = min(ans, num)
print(ans)
| '''ika tako ABC164Dの類題
基本は、1桁目、2桁目と下から10進数の数字として見て、
素数ｐで割った余りを考え、余りが同じである数字のスタートとエンドを
選ぶ組み合わせの数が答。
但し、10進数で考えているので、ｐが2と5のケースは別扱い。
末尾が2、5の倍数なら2の倍数。先頭の数字を0番目として、
i番目に2、5の倍数が出てきたら、
そこを右端とする部分文字列は i+1 個作れる。
'''
from collections import defaultdict
def solve2(s):
ans = 0
for i, c in enumerate(s):
if c in '02468':
ans += i + 1
return ans
def solve5(s):
ans = 0
for i, c in enumerate(s):
if c in '05':
ans += i + 1
return ans
def solve_other(s, p):
reminders = defaultdict(lambda: 0)
tmp = 0
mul = 1
for c in s[::-1]:
c = int(c)
tmp = (tmp + c * mul) % p
mul = mul * 10 % p
reminders[tmp] += 1
reminders[0] += 1
ans = 0
for r, cnt in reminders.items():
ans += cnt * (cnt - 1) // 2
return ans
n, p = list(map(int, input().split()))
s = input()
if p == 2:
print(solve2(s))
elif p == 5:
print(solve5(s))
else:
print(solve_other(s, p)) | 0 | null | 53,325,653,178,588 | 193 | 205 |
A = int(input())
print(A//2+A%2) | print('Yes' if input() in ['hi'*i for i in range(1,6)] else 'No') | 0 | null | 55,870,131,754,428 | 206 | 199 |
import re
import sys
import math
import itertools
import bisect
from copy import copy
from collections import deque,Counter
from decimal import Decimal
import functools
def s(): return input()
def k(): return int(input())
def S(): return input().split()
def I(): return map(int,input().split())
def X(): return list(input())
def L(): return list(input().split())
def l(): return list(map(int,input().split()))
def lcm(a,b): return a*b//math.gcd(a,b)
sys.setrecursionlimit(10 ** 9)
mod = 10**9+7
cnt = 0
ans = 0
inf = float("inf")
p = L()
a,b = I()
u = s()
if u == p[0]:
a -=1
else:
b-=1
print("{} {}".format(a,b))
| # -*- coding: utf-8 -*-
s, t = map(str, input().split())
a, b = map(int, input().split())
u = str(input())
dic = {s:a, t:b}
dic[u] = dic[u] - 1
print(dic[s], dic[t]) | 1 | 72,178,320,115,626 | null | 220 | 220 |
X = int(input())
rankArr=[2000,1800,1600,1400,1200,1000,800,600,400]
for i in range(1,len(rankArr)):
if rankArr[i] <= X and X < rankArr[i-1] :
print(i)
exit() | N = int(input())
if N % 2 == 1:
print(0)
else:
n = 0
i = 1
while True:
if N < 2*5**i:
break
n += (N // 5**i // 2)
i += 1
print(n)
| 0 | null | 61,618,452,559,708 | 100 | 258 |
from sys import stdin
int3 = sorted([int(x) for x in stdin.readline().rstrip().split()])
print(*int3)
| N = list(map(int, input().split(' ')))
N.sort()
print('%d %d %d' % (N[0], N[1], N[2])) | 1 | 417,581,633,272 | null | 40 | 40 |
n = int( input() )
x = list(map(int, input().split()))
y = list(map(int, input().split()))
for i in range(1,4):
s=0
m=0
for j in range(n):
s+=(abs(x[j]-y[j]))**i
if (abs(x[j]-y[j])) > m:
m=(abs(x[j]-y[j]))
print(s**(1/i))
print(m) | def main():
import sys
from collections import defaultdict
input = sys.stdin.readline
K = int(input())
S = len(input().strip())
mod = 10 ** 9 + 7
fact = [1] * (K + S + 1)
invfact = [1] * (K + S + 1)
for i in range(K + S):
fact[i+1] = (fact[i] * (i+1)) % mod
invfact[-1] = pow(fact[-1], mod-2, mod)
for i in range(K + S):
invfact[-2-i] = (invfact[-1-i] * (K + S - i)) % mod
def nCr(n, r):
if r == n or r == 0:
return 1
r = min(r, n - r)
return (fact[n] * invfact[n-r] * invfact[r]) % mod
ans = 0
for i in range(K+1):
ans += pow(25, i, mod) * nCr(i+S-1, S-1) * pow(26, K-i, mod)
ans %= mod
print(ans)
if __name__ == '__main__':
main() | 0 | null | 6,565,702,579,960 | 32 | 124 |
# -*- coding: utf-8 -*-
import sys
from sys import stdin
import math
n, k = map(int, stdin.readline().split())
w = list([int(stdin.readline().rstrip()) for i in range(n)])
def main2():
def is_ok():
cnt_track = w_tmp = 0
for w_i in w:
w_tmp += w_i
if w_tmp > m:
w_tmp = w_i
cnt_track += 1
if cnt_track >= k:
return 0
return 1
r = sum(w)
l = max(math.ceil(r/k),max(w))
while l < r:
m = (l + r) // 2
# print("%d %d %d " % (l, r, m))
if is_ok():
r = m
else:
l = m + 1
print(r)
if __name__ == '__main__':
main2()
|
nk=input().split()
n=int(nk[0])
k=int(nk[1])
weight=[int(input()) for i in range(n)]
def ok(m):
load=0
track=1
# sum all the weight and count the track number we need
for i in range(n):
load+=weight[i]
if load==m:
load=0
if i!=n-1:
track+=1
elif load>m:
if weight[i]>m:
return False
else:
load=weight[i]
track+=1
else:
continue
if track<=k:
return True
else:
return False
low=0
high=sum(weight)
while low+1<high:
# low<mid<high
#not ok(l) and ok(h)
mid=(low+high)//2
if ok(mid):
high=mid
else:
low=mid
print(high) | 1 | 88,325,727,062 | null | 24 | 24 |
n=int(input())
s,t=map(str,input().split())
S=list(s)
T=list(t)
for i in range(n):
print(S[i],end="")
print(T[i],end="")
| S=int(input())
a,s=divmod(S,60)
h,m=divmod(a,60)
print(str(h)+':'+str(m)+':'+str(s))
| 0 | null | 56,135,275,642,604 | 255 | 37 |
S=str(input())
if S[-1]=='s':
S = S + 'es'
else:
S = S + 's'
print(S)
| from math import copysign
K,N = map(int,input().split())
A = list(map(int,input().split()))
max_dist = K - A[N-1] + A[0]
s = 0
for i in range(0,N-1):
if max_dist < A[i+1] - A[i]:
max_dist = A[i+1] - A[i]
s = i + 1
B = list(map(lambda x: int(copysign(x+K, x)), A[:s]))
A = A[s:] + B
ans = 0
for j in range(N):
if j == 0:
continue
ans += A[j] - A[j-1]
print(ans) | 0 | null | 22,771,431,975,640 | 71 | 186 |
def main():
n = int(input())
a = list(map(int, input().split()))
mod = 10 ** 9 + 7
s = sum(a)
ans = 0
for i in range(n):
s -= a[i]
ans = (ans + a[i] * s) % mod
print(ans)
main() | #coding: UTF-8
N=int(input())
p=[int(input()) for i in range(0,N)]
maxv=p[1]-p[0]
buy=p[0]
for i in range(1,N):
if p[i]-buy>maxv:
maxv=p[i]-buy
if p[i]<buy:
buy=p[i]
print(maxv) | 0 | null | 1,904,345,613,658 | 83 | 13 |
def main():
n = int(input())
points = [0, 0]
for i in range(n):
t, h = input().split(' ')
points = map(lambda x, y: x+y, points, judge(t, h))
print("{0[0]} {0[1]}".format(list(points)))
def judge(t, h):
if t < h:
return (0, 3)
elif t > h:
return (3, 0)
return (1, 1)
if __name__ == '__main__': main() | N, K = map(int, input().split())
snuke = [False] * (N + 1)
for _ in range(K):
d = int(input())
A = list(map(int, input().split()))
for a in A:
snuke[a] = True
ans = 0
for i in range(1, N + 1):
if snuke[i] == False:
ans += 1
print(ans)
| 0 | null | 13,265,115,619,702 | 67 | 154 |
n = input()
K = int(input())
L = len(n)
dp = [[[0] * (K + 2) for _ in range(2)] for __ in range(L + 1)]
dp[0][1][0] = 1
for i in range(L):
d = int(n[i])
for j in [0, 1]:
for k in range(K + 1):
if j == 0:
dp[i + 1][j][k] += dp[i][j][k]
dp[i + 1][j][k + 1] += dp[i][j][k] * 9
else:
if d > 0:
dp[i + 1][0][k] += dp[i][j][k]
dp[i + 1][0][k + 1] += dp[i][j][k] * (d - 1)
dp[i + 1][1][k + 1] += dp[i][j][k]
else:
dp[i + 1][1][k] += dp[i][j][k]
print(dp[L][0][K] + dp[L][1][K])
| x,k,d = list(map(int,input().split()))
x = abs(x)
m = x // d
if m >= k:
ans = x - (d*k)
elif (k-m) % 2 == 0:
ans = x - (d*m)
else:
ans = x - (d*m) - d
print(abs(ans)) | 0 | null | 40,546,747,885,280 | 224 | 92 |
s=input()
if s[-1]!='s':print(s+'s')
else:print(s+'es') | word = input()
if (word.endswith('s')):
print(word + 'es')
else:
print(word + 's') | 1 | 2,399,623,866,948 | null | 71 | 71 |
A = list(map(int, input().split()))
ans = 'Yes' if (len(A) - 1) == len(set(A)) else 'No'
print(ans) | print('Yes' if len(set([i for i in input().split()])) == 2 else 'No') | 1 | 67,769,676,329,940 | null | 216 | 216 |
import math
x1,y1,x2,y2=map(float,raw_input().split())
print "%.5f"%(float(math.sqrt((x1-x2)**2+(y1-y2)**2))) |
x = raw_input()
print(int(x)**3) | 0 | null | 221,467,702,940 | 29 | 35 |
N=int(input())
S=input()
code=list(set(list(S)))
ans=0
for i in code:
for j in code:
for k in code:
count=0
for s in S:
if count==0:
if s==i:
count+=1
elif count==1:
if s==j:
count+=1
elif count==2:
if s==k:
count+=1
if count==3:
ans+=1
break
print(ans) | def II(): return int(input())
def MI(): return map(int, input().split())
def LI(): return list(map(int, input().split()))
N=II()
ans=0
List=[[-1 for _ in range(N)] for _ in range(N)]
for j in range(N):
A=II()
for i in range(A):
x,y=MI()
x-=1
List[j][x]=y
for i in range(1<<N):
honests=[0]*N
for j in range(N):
if 1&(i>>j):
honests[j]=1
ok=True
for j in range(N):
if honests[j]:
for k in range(N):
if List[j][k]==-1:
continue
if List[j][k]!=honests[k]:
ok=False
if ok:
ans=max(ans,honests.count(1))
print(ans) | 0 | null | 125,324,289,734,020 | 267 | 262 |
n = input()
R = []
for i in range(n):
R.append(input())
min_v = R[0]
max_v = -1000000000000
for i in range(1, n):
temp = R[i] - min_v
if (temp >= max_v):
max_v = temp
temp = R[i]
if (min_v >= temp):
min_v = temp
print max_v | N = int(input())
maxv = -2*10**10
minv = int(input())
for i in range(N-1):
_ = int(input())
maxv = max(maxv,_-minv)
minv = min(minv,_)
print(maxv)
| 1 | 13,453,389,432 | null | 13 | 13 |
n,k=map(int,input().split())
ans=n%k
print(min(ans,abs(ans-k))) | n, m = map(int, input().split())
A = [list(map(int, input().split())) for _ in [None] * n]
b = [int(input()) for _ in [None] * m]
for a in A:
print(sum([i * j for i, j in zip(a, b)]))
| 0 | null | 20,272,779,664,168 | 180 | 56 |
n,k=map(int,input().split())
mod=10**9+7
def inv(x):
return pow(x,mod-2,mod)
N=2*10**5
Fact=[0 for i in range(N+1)]
Finv=[0 for i in range(N+1)]
Fact[0]=1
for i in range(N):
Fact[i+1]=(Fact[i]*(i+1))%mod
Finv[N]=inv(Fact[N])
for i in range(N-1,-1,-1):
Finv[i]=((i+1)*Finv[i+1])%mod
def C(a,b):
return (Fact[a]*(Finv[b]*Finv[a-b])%mod)%mod
ans=0
for i in range(min(n,k+1)):
ans+=(C(n,i)*C(n-1,i))%mod
ans%=mod
print(ans)
| import os
import sys
import numpy as np
def solve(N, M, A):
# n 以上上がる方法だけを試した時に、M 回以上の握手を行うことができるか
ok = 0
ng = 202020
while ok + 1 < ng:
c = ok+ng >> 1
cnt = 0
idx_A = N-1
for a1 in A:
while idx_A >= 0 and A[idx_A]+a1 < c:
idx_A -= 1
cnt += idx_A + 1
if cnt >= M:
ok = c
else:
ng = c
idx_A = N-1
cum_A = np.zeros(len(A)+1, dtype=np.int64)
cum_A[1:] = np.cumsum(A)
ans = 0
cnt = 0
for a1 in A:
while idx_A >= 0 and A[idx_A]+a1 < ok:
idx_A -= 1
cnt += idx_A + 1
ans += cum_A[idx_A+1] + (idx_A+1)*a1
ans -= (cnt-M) * ok
return ans
# >>> numba compile >>>
numba_config = [
[solve, "i8(i8,i8,i8[:])"],
]
if sys.argv[-1] == "ONLINE_JUDGE":
from numba import njit
from numba.pycc import CC
cc = CC("my_module")
for func, signature in numba_config:
vars()[func.__name__] = njit(signature)(func)
cc.export(func.__name__, signature)(func)
cc.compile()
exit()
elif os.name == "posix":
exec(f"from my_module import {','.join(func.__name__ for func, _ in numba_config)}")
else:
from numba import njit
for func, signature in numba_config:
vars()[func.__name__] = njit(signature, cache=True)(func)
print("compiled!", file=sys.stderr)
# <<< numba compile <<<
def main():
N, M = map(int, input().split())
A = np.array(sorted(map(int, input().split()), reverse=True), dtype=np.int64)
ans = solve(N, M, A)
print(ans)
main()
| 0 | null | 88,030,988,519,540 | 215 | 252 |
M_1, D_1 = map(int, input().split(" "))
M_2, D_2 = map(int, input().split(" "))
print(0 if M_1 == M_2 else 1) | from sys import stdin
import sys
sys.setrecursionlimit(10**7)
def main():
_in = [_.rstrip() for _ in stdin.readlines()]
N, K = list(map(int, _in[0].split(' '))) # type:list(int)
L_R_arr = []
for i in range(K):
_ = list(map(int, _in[i+1].split(' '))) # type:list(int)
L_R_arr.append(_)
# vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
dp = [0] * N
sdp = [0] * (N+1)
dp[0] = 1
for i in range(N):
for L, R in L_R_arr:
right = max(0, i-L+1)
left = max(0, i-R)
dp[i] += sdp[right] - sdp[left]
else:
sdp[i+1] = (sdp[i] + dp[i]) % 998244353
ans = dp[-1] % 998244353
# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
print(ans)
if __name__ == "__main__":
main()
| 0 | null | 63,383,718,149,252 | 264 | 74 |
# 問題：https://atcoder.jp/contests/abc142/tasks/abc142_b
n, k = map(int, input().strip().split())
h = list(map(int, input().strip().split()))
res = 0
for i in range(n):
if h[i] < k:
continue
res += 1
print(res)
| N,K=map(int,input().split())
H=list(map(int,input().split()))
P=0
for i in range(N):
if K<=H[i]:
P+=1
print(P) | 1 | 178,138,170,942,940 | null | 298 | 298 |
n = int(input())
S = set(input().split())
q = int(input())
T = set(input().split())
print(len(S & T))
| input()
a = set(input().split())
input()
b = set(input().split())
print(len(a & b))
| 1 | 67,882,304,802 | null | 22 | 22 |
import sys
input = sys.stdin.buffer.readline
N, K = map(int, input().split())
LR = [list(map(int, input().split())) for _ in range(K)]
mod = 998244353
dp = [0]*(N+1)
tmp = 1
for i in range(N-1):
tmp = (tmp + dp[i]) % mod
# dp[i] = tmp
for l, r in LR:
dp[min(i+l, N)] = (dp[min(i+l, N)] + tmp) % mod
dp[min(i+r+1, N)] = (dp[min(i+r+1, N)] - tmp) % mod
print(dp[N-1]) | #BITを使ってみる
n, k = map(int, input().split())
lr = []
for _ in range(k):
l, r = map(int, input().split())
lr.append((l, r))
mod = 998244353
class BinaryIndexedTree():
def __init__(self, n, mod=None):
self.n = n
self.mod = mod
self.bit = [0]*n
def add(self, i, w):
x = i+1
while x<=self.n:
self.bit[x-1] += w
if self.mod is not None:
self.bit[x-1] %= mod
x += x & -x
def sum(self, l, r):
return self._sum(r-1) - self._sum(l-1)
def _sum(self, i):
ret = 0
x = i+1
while x>0:
ret += self.bit[x-1]
if self.mod is not None:
ret %= self.mod
x -= x & -x
return ret
bit = BinaryIndexedTree(2*n+1, mod)
bit.add(n+1, 1)
for i in range(n+2, 2*n+1):
for l, r in lr:
bit.add(i, bit.sum(i-r, i-l+1))
print(bit.bit[2*n]) | 1 | 2,716,112,826,196 | null | 74 | 74 |
h, w, k = map(int, input().split())
s = [list(map(int, input())) for _ in range(h)]
ans = float("inf")
for sep in range(1 << (h-1)):
g_id = [0] * h
cur = 0
for i in range(h-1):
g_id[i] = cur
if sep >> i & 1: cur += 1
g_id[h-1] = cur
g_num = cur+1
ng = False
for i in range(w):
tmp = [0] * g_num
for j in range(h): tmp[g_id[j]] += s[j][i]
if any([x > k for x in tmp]): ng = True; break
if ng: continue
res = g_num-1
gs = [0] * g_num
for i in range(h):
gs[g_id[i]] += s[i][0]
for i in range(1, w):
tmp = gs[::]
for j in range(h):
tmp[g_id[j]] += s[j][i]
if any([x > k for x in tmp]):
res += 1
gs = [0] * g_num
for j in range(h): gs[g_id[j]] += s[j][i]
ans = min(ans, res)
print(ans)
| N = int(input())
A = list(map(int,input().split()))
ma = max(A)
l = [0 for _ in range(ma + 10)]
for i in range(N):
temp = A[i]
while(temp <= ma + 5):
l[temp] += 1
temp += A[i]
ans = 0
for i in range(N):
if l[A[i]] == 1: ans += 1
print(ans) | 0 | null | 31,403,299,113,552 | 193 | 129 |
import sys
sys.setrecursionlimit(10**7)
def main():
s=input()
k=int(input())
n=len(s)
def dp(i,j,smaller):
# i桁目以降について、0以外の値を残りj個使用可能という状況を考える。i桁目までは決定している。残りn-i桁
# このときi桁目までの部分が「等しい」か「strict に小さくなっている」かを smaller フラグによって分岐する。
if n==i: # 0でない数字をk個つかえなかったパターン。
return 0 if j>0 else 1
if smaller:# 残りのn-i桁の中からj桁選び好きな数字にできる。j桁以外はすべて0
if j==0:
return 1
elif j==1:
return (n-i)*9
elif j==2:
return ((n-i)*(n-i-1))//2*9**2
elif j==3:
return ((n-i)*(n-i-1)*(n-i-2))//6*9**3
if j==0: # i桁目以降はすべて0で決まり
return 1
ret=0
# i+1桁目が0なら0を使うしかない
if s[i]=='0':
ret+=dp(i+1,j,smaller)
else:
ret+=dp(i+1,j-1,smaller) # i+1桁目でsと同じ数字を使う
ret+=(int(s[i])-1)*dp(i+1,j-1,True) # i+1桁目で0より大きくs未満の数字使う
ret+=dp(i+1,j,True) # i+1桁目で0を使う。
return ret
print(dp(0,k,False))
if __name__=='__main__':
main()
| import sys
def input(): return sys.stdin.readline().rstrip()
def main():
s=input()
n=len(s)
K=int(input())
dp_0=[[0]*(K+1) for _ in range(n+1)]
dp_1=[[0]*(K+1) for _ in range(n+1)]
dp_0[0][0]=1
for i in range(n):
for j in range(K+1):
for k in range(2):
nd=int(s[i])-0
for d in range(10):
ni=i+1
nj=j
if d!=0:nj+=1
if nj>K:continue
if k==0:
if d>nd:continue
if d<nd:dp_1[ni][nj]+=dp_0[i][j]
else:dp_0[ni][nj]+=dp_0[i][j]
else:dp_1[ni][nj]+=dp_1[i][j]
print(dp_0[n][K]+dp_1[n][K])
if __name__=='__main__':
main() | 1 | 75,924,302,547,928 | null | 224 | 224 |
a = input()
al=[chr(ord('a') + i) for i in range(26)]
if a in al:
print("a")
else:
print("A") | while True:
h, w = map(int, input().split())
if h == 0 and w == 0:
break
for i in range(h):
print('#'*w)
print()
| 0 | null | 6,024,307,617,088 | 119 | 49 |
n,m,l= map(int,input().split())
a = [list(map(int,input().split())) for i in range(n)]
b = [list(map(int,input().split())) for i in range(m)]
for u in range(n):
for w in range(l):
c=0
for z in range(m):
c+=a[u][z]*b[z][w]
if w==l-1:
print(c)
else:
print(c,end=" ")
| n, m, l = map(int, input().split())
A = []
B = []
for line in range(n):
A.append(list(map(int, input().split())))
for line in range(m):
B.append(list(map(int, input().split())))
C = []
for lines in range(n):
C.append([sum([A[lines][i] * B[i][j] for i in range(m)]) for j in range(l)])
print(" ".join(map(str, C[lines]))) | 1 | 1,436,473,233,540 | null | 60 | 60 |
W, H, x, y, r = map(int, input().split())
if x - r >= 0 and x + r <= W and y - r >= 0 and y + r <= H:
print("Yes")
else:
print("No")
| def getN():
return int(input())
def getNM():
return map(int, input().split())
def getList():
return list(map(int, input().split()))
def getArray(intn):
return [int(input()) for i in range(intn)]
def input():
return sys.stdin.readline().rstrip()
def rand_N(ran1, ran2):
return random.randint(ran1, ran2)
def rand_List(ran1, ran2, rantime):
return [random.randint(ran1, ran2) for i in range(rantime)]
def rand_ints_nodup(ran1, ran2, rantime):
ns = []
while len(ns) < rantime:
n = random.randint(ran1, ran2)
if not n in ns:
ns.append(n)
return sorted(ns)
def rand_query(ran1, ran2, rantime):
r_query = []
while len(r_query) < rantime:
n_q = rand_ints_nodup(ran1, ran2, 2)
if not n_q in r_query:
r_query.append(n_q)
return sorted(r_query)
from collections import defaultdict, deque, Counter
from sys import exit
from decimal import *
import heapq
import math
from fractions import gcd
import random
import string
import copy
from itertools import combinations, permutations, product
from operator import mul
from functools import reduce
from bisect import bisect_left, bisect_right
import sys
sys.setrecursionlimit(1000000000)
mod = 10 ** 9 + 7
#############
# Main Code #
#############
X, Y, A, B, C = getNM()
P = getList()
Q = getList()
R = getList()
P.sort()
Q.sort()
lista = P[-X:] + Q[-Y:] + R
lista.sort()
print(sum(lista[-(X + Y):])) | 0 | null | 22,563,033,925,052 | 41 | 188 |
N=int(input())
result=N/2
if N%2 != 0:
result+=0.5
print(int(result)) | n=int(input())
print(int(n/2)+int(n%2)) | 1 | 59,139,120,684,932 | null | 206 | 206 |
# -*- coding: utf-8 -*-
import sys
for line in sys.stdin.readlines():
a, b = map(int, line.strip().split())
n = a + b
ans = 1
while(n >= 10):
n /= 10
ans += 1
print ans | n = int(input())
num = list(map(int, input().split()))
print(" ".join(map(str, num)))
for i in range(len(num)-1):
key = num[i+1]
j = i
while j >= 0 and num[j] > key:
num[j+1] = num[j]
j -= 1
num[j+1] = key
print(" ".join(map(str, num))) | 0 | null | 3,099,745,880 | 3 | 10 |
n = int(input())
print(sum((n - 1) // i for i in range(1, n))) | h,n = map(int, input().split())
magics = [tuple(map(int, input().split())) for _ in range(n)]
max_a = sorted(magics, key=lambda x: x[0], reverse=True)[0][0]
dp = [0]*(h+max_a)
for i in range(1, h+max_a):
dp[i] = min(dp[i-a]+b for a,b in magics)
print(min(dp[h:])) | 0 | null | 41,945,128,571,298 | 73 | 229 |
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))
INF=10**20
def main():
A,B=mi()
print(max(0,A-2*B))
if __name__ == "__main__":
main() | a,b=map(int,input().split());print([0,a-b*2][a-b*2>0]) | 1 | 166,169,026,518,380 | null | 291 | 291 |
i = 1
while i < 10 :
j = 1
while j < 10 :
print(str(i) + "x" + str(j) + "=" + str(i*j))
j += 1
i += 1
| for i in range(1, 10):
for j in range(1, 10):
print('%dx%d=%d' % (i, j, i*j)) | 1 | 579,468 | null | 1 | 1 |
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") | def main():
n = int(input())
dss = [list(map(int, input().split())) for _ in range(n)]
ans = "No"
Count = 0
for ds in dss:
if ds[0] == ds[1]:
Count += 1
else:
Count = 0
if Count == 3:
ans = "Yes"
print(ans)
if __name__ == "__main__":
main()
| 1 | 2,493,981,609,658 | null | 72 | 72 |
a,b = map(int,input().split())
k = str(a)
l = str(b)
X = k*b
Y = l*a
if (X < Y):
print(X)
else:
print(Y) | # Comparing Strings
a, b = map(int, input().split())
a, b = min(a, b), max(a, b)
ans = ''.join([str(a) for e in range(b)])
print(ans)
| 1 | 84,524,951,900,920 | null | 232 | 232 |
S = input() *2
N = input()
if N in S:
print("Yes")
else:
print("No") | n = int(input())
A = list(map(int, input().split()))
print(' '.join(list(map(str, A))))
for i in range(1,n):
key = A[i]
j = i - 1
while j >= 0 and A[j] > key:
A[j+1] = A[j]
j -= 1
A[j+1] = key
print(' '.join(list(map(str, A)))) | 0 | null | 869,271,179,392 | 64 | 10 |
s = input().split("hi")
f = 0
for i in s:
if i != "":
f = 1
break
if f == 0:
print("Yes")
else:
print("No") | #!usr/bin/env pypy3
from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
import sys
import math
import bisect
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == "\n":
return res[:-1]
return res
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def lcm(a, b): return a * b // math.gcd(a, b)
def extgcd(a, b):
if b:
d, y, x = extgcd(b, a%b)
y -= (a/b)*x
return d, x, y
else:
return a, 1, 0
sys.setrecursionlimit(1000000)
MOD = 1000000007
def main():
n, a, b = LI()
a1, a2 = 1, 1
for i in range(1, a+1):
a1 = a1 * (n - i + 1) % MOD
a2 = a2 * i % MOD
b1, b2 = 1, 1
for i in range(1, b+1):
b1 = b1 * (n - i + 1) % MOD
b2 = b2 * i % MOD
nca = a1 * pow(a2, MOD-2, MOD) % MOD
ncb = b1 * pow(b2, MOD-2, MOD) % MOD
print((pow(2, n, MOD) - 1 - nca - ncb) % MOD)
main()
| 0 | null | 59,593,934,954,120 | 199 | 214 |
import sys
input = lambda: sys.stdin.readline().rstrip()
def main():
s = input()
days = ['','SAT','FRI','THU','WED','TUE','MON','SUN']
print(days.index(s))
if __name__ == '__main__':
main() | a,b,m=map(int,input().split())
alist=list(map(int,input().split()))
blist=list(map(int,input().split()))
minimum=100000000000000
for i in range(m):
x,y,z=map(int,input().split())
minimum=min(minimum,alist[x-1]+blist[y-1]-z)
alist.sort()
blist.sort()
minimum=min(minimum,alist[0]+blist[0])
print(minimum) | 0 | null | 93,389,297,604,460 | 270 | 200 |
X, Y = map(int, input().split())
MOD = 10 ** 9 + 7
def modpow(x, n):
ret = 1
while n > 0:
if n & 1:
ret = ret * x % MOD
x = x * x % MOD
n >>= 1
return ret
def modinv(x):
return modpow(x, MOD - 2)
def modf(x):
ret = 1
for i in range(2, x + 1):
ret *= i
ret %= MOD
return ret
ans = 0
if (X + Y) % 3 == 0:
m = (2 * X - Y) // 3
n = (2 * Y - X) // 3
if m >= 0 and n >= 0:
ans = modf(m + n) * modinv(modf(n) * modf(m))
ans %= MOD
print(ans) | # ABC145 D
X,Y=map(int,input().split())
a,b=-1,-1
if not (2*X-Y)%3:
b=(2*X-Y)//3
if not (2*Y-X)%3:
a=(2*Y-X)//3
N=10**6
p=10**9+7
f,finv,inv=[0]*N,[0]*N,[0]*N
def nCr_init(L,p):
for i in range(L+1):
if i<=1:
f[i],finv[i],inv[i]=1,1,1
else:
f[i]=(f[i-1]*i)%p
inv[i]=(p-inv[p%i]*(p//i))%p
finv[i]=(finv[i-1]*inv[i])%p
def nCr(n,r,p):
if 0<=r<=n and 0<=n:
return (f[n]*finv[n-r]*finv[r])%p
else:
return 0
nCr_init(a+b+1,p)
if a>=0 and b>=0:
print(nCr(a+b,b,p))
else:
print(0) | 1 | 149,732,098,879,726 | null | 281 | 281 |
from sys import stdin
data = stdin.readlines()
n = int(data[0].split()[0])
l = []
for i in range(n):
l.append(data[i+1].split()[0])
print(len(set(l))) | i=1
while True:
x = int(input())
if x==0:
break
print('Case ',i,': ',x,sep='')
i=i+1;
| 0 | null | 15,419,704,168,452 | 165 | 42 |
dataList = [1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51]
input_k = input('')
k_index = int(input_k)
print(dataList[k_index - 1])
| K = int(input())
S = input()
X = len(S)
mod = 10**9+7
temp = pow(26,K,mod)
ans = pow(26,K,mod)
Y = 25*pow(26, mod-2, mod)
for i in range(X+1,K+X+1):
temp *= Y
temp %= mod
temp *= i-1
temp %= mod
temp *= pow(i-X, mod-2, mod)
temp %= mod
ans += temp
ans %= mod
print(ans) | 0 | null | 31,420,776,912,002 | 195 | 124 |
import math
import sys
#t=int(sys.stdin.readline())
t=1
for _ in range(t):
n,m=map(int,input().split())
print(math.ceil(n/m))
| L=map(int, raw_input().split())
L=sorted(L)
for i in range(len(L)):
print L[i], | 0 | null | 38,759,949,546,458 | 225 | 40 |
n, k, c = map(int, input().split())
s = input()
l = [0 for i in range(k+1)]
r = [0 for i in range(k+1)]
cnt = 0
kaime = 1
for i in range(n):
if kaime > k: break
if cnt > 0:
cnt -= 1
else:
if s[i] == 'o':
l[kaime] = i
kaime += 1
cnt = c
cnt = 0
kaime = k
for j in range(n):
i = n-1 - j
if kaime < 1: break
if cnt > 0:
cnt -= 1
else:
if s[i] == 'o':
r[kaime] = i
kaime -= 1
cnt = c
for i in range(1, k+1):
if l[i] == r[i]:
print(l[i]+1) | def f(s):
a=[-c]
for i,s in enumerate(s,1):
if s<'x'and a[-1]+c<i:a+=i,
return a[1:k+1]
n,s=open(0)
n,k,c=map(int,n.split())
for a,b in zip(f(s[:n]),f(s[-2::-1])[::-1]):
if a==n+1-b:print(a) | 1 | 40,623,713,718,508 | null | 182 | 182 |
a=int(input())
result=a+a**2+a**3
print(int(result)) | from collections import Counter
N, P = map(int, input().split())
Ss = input()
if P == 2 or P == 5:
ans = 0
for i, S in enumerate(Ss):
if int(S)%P == 0:
ans += i+1
else:
As = [0]
A = 0
D = 1
for S in Ss[::-1]:
S = int(S)
A = (A + S*D) % P
As.append(A)
D = D*10 % P
cnt = Counter()
ans = 0
for A in As:
ans += cnt[A]
cnt[A] += 1
print(ans)
| 0 | null | 34,042,127,512,670 | 115 | 205 |
import math
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 9)
def main():
n = int(input())
mod = 10 ** 9 + 7
h = {}
zero = 0
for i in range(n):
a, b = map(int, input().split())
if a == 0 and b == 0:
zero += 1
continue
m = (0, 0)
if b == 0:
m = (1, 0)
elif b > 0:
g = math.gcd(a, b)
m = (a // g, b // g)
else:
g = math.gcd(a, b)
m = (-1 * (a // g), -1 * (b // g))
if m not in h:
h[m] = set()
h[m].add(i)
h2 = {}
for m in h:
mi1 = (-1 * m[1], m[0])
if mi1 in h and mi1 not in h2:
h2[m] = mi1
mi2 = (m[1], -1 * m[0])
if mi2 in h and mi2 not in h2:
h2[m] = mi2
ans = 1
left = n - zero
for k, v in h2.items():
s1 = len(h[k])
s2 = len(h[v])
# print(s1, s2)
r = (pow(2, s1 + s2, mod) - (pow(2, s1, mod) - 1) * (pow(2, s2, mod) - 1)) % mod
ans *= r
ans %= mod
left -= (s1 + s2)
ans *= pow(2, left, mod)
ans -= 1
ans += zero
print(ans % mod)
if __name__ == '__main__':
main()
| # coding: utf-8
import sys
from collections import defaultdict
from math import gcd
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
# 0除算、グループ分け
MOD = 10 ** 9 + 7
N = ir()
AB = [lr() for _ in range(N)] # 0-indexed
dic = defaultdict(set)
zero = [set() for _ in range(3)]
for i, (a, b) in enumerate(AB, 1):
g = gcd(a, b)
#print('g, a, b:', g, a, b)
if a != 0 and b != 0:
a //= g; b //= g
if a < 0:
a *= -1; b *= -1
dic[(a, b)].add(i)
elif a == 0:
if b == 0:
zero[0].add(i)
else:
zero[1].add(i)
elif b == 0:
zero[2].add(i)
answer = 1
used = set()
for k, v in dic.items():
a, b = k
k2 = (-b, a)
if -b < 0:
k2 = (b, -a)
if k in used:
continue
if k2 in dic:
v2 = dic[k2]
answer *= (-1 + pow(2, len(v), MOD) + pow(2, len(v2), MOD))
used.add((k2))
else:
answer *= pow(2, len(v), MOD)
used.add(k)
answer %= MOD
# zero
answer *= -1 + pow(2, len(zero[1]), MOD) + pow(2, len(zero[2]), MOD)
answer += len(zero[0])
answer -= 1 # 何も選ばなかった場合
print(answer % MOD)
# np.int64とint型の違いに注意
# 07 | 1 | 20,960,911,214,840 | null | 146 | 146 |
import re
import sys
INF=10000000000000
sys.setrecursionlimit(10**6)
def merge(A,left,mid,right):
count=0
L=A[left:mid]
R=A[mid:right]
L.append(INF)
R.append(INF)
i=0
j=0
for k in range(left,right):
if(L[i] <= R[j]):
A[k] = L[i]
i+=1
count+=1
else:
A[k] = R[j]
j+=1
count+=1
return count
def mergeSort(A,left,right):
count=0
if(left+1<right):
mid=(left+right)//2
count+=mergeSort(A, left, mid)
count+=mergeSort(A, mid, right)
count+=merge(A, left, mid, right)
return count
count=0
n=int(input())
s=list(map(int,input().split()))
count=mergeSort(s, 0, n)
print(re.sub("[\[\]\,]","",str(s)))
print(count)
| K = int(input())
c = ''
for i in range(1,K+1):
c += 'ACL'
print(c)
| 0 | null | 1,161,790,036,808 | 26 | 69 |
import sys
readline = sys.stdin.buffer.readline
sys.setrecursionlimit(10 ** 8)
INF = float('inf')
MOD = 10 ** 9 + 7
def main():
M1, D1 = map(int, readline().split())
M2, D2 = map(int, readline().split())
if M1 != M2:
print('1')
else:
print('0')
if __name__ == '__main__':
main() | n = list(map(int,input().split()))
num = 0
for i,x in enumerate(n):
if (x == 0):
num = i+1
break;
print(num) | 0 | null | 69,040,937,391,650 | 264 | 126 |
data = input()
data = data.split()
print("Yes") if int(data[0]) / int(data[2]) <= int(data[1]) else print("No") | # import numpy as np
import sys, math
from itertools import permutations, combinations
from collections import defaultdict, Counter, deque
from math import factorial, gcd
from bisect import bisect_left, bisect_right
sys.setrecursionlimit(10 ** 7)
enu = enumerate
MOD = 10 ** 9 + 7
input = lambda: sys.stdin.readline()[:-1]
pl = lambda x: print(*x, sep="\n")
N = int(input())
L = [input() for _ in range(N)]
up = []
do = []
for li in L:
l = li.count("(")
r = li.count(")")
ext_neg = 0
ext_pos = 0
tl, tr = 0, 0
if 0 <= l - r:
for op in li:
if op == "(":
tl += 1
elif op == ")":
tr += 1
ext_neg = min(ext_neg, tl - tr)
ext_pos = max(ext_pos, tl - tr)
up.append((l - r, ext_neg, ext_pos))
else:
for op in li[::-1]:
if op == ")":
tl += 1
elif op == "(":
tr += 1
ext_neg = min(ext_neg, tl - tr)
ext_pos = max(ext_pos, tl - r)
do.append((r - l, ext_neg, ext_pos))
up.sort(key=lambda tup: (-tup[1], -tup[0]))
do.sort(key=lambda tup: (-tup[1], -tup[0]))
# print(up)
# print(do)
curl = 0
for upi in up:
dif, ext_neg, ext_pos = upi
if curl + ext_neg < 0:
print("No")
exit()
curl += dif
curr = 0
for doi in do:
dif, ext_neg, ext_pos = doi
if curr + ext_neg < 0:
print("No")
exit()
curr += dif
if curl == curr:
print("Yes")
else:
print("No")
| 0 | null | 13,589,279,192,042 | 81 | 152 |
import math
A, B, H, M = map(int,input().split())
#時針:0.5°/min
#分針:6.0°/min
print(math.sqrt(A ** 2 + B ** 2 - 2 * A * B * math.cos(5.5 * (H * 60 + M) * math.pi / 180 ))) | import math
a, b, h, m = map(int, input().split())
dega = - 30*h - 0.5*m + 90
degb = - 6*m + 90
x_a = a*math.cos(math.radians(dega))
y_a = a*math.sin(math.radians(dega))
x_b = b*math.cos(math.radians(degb))
y_b = b*math.sin(math.radians(degb))
# print(dega, degb)
# print(x_a, x_b, y_a, y_b)
print(((x_a-x_b)**2+(y_a-y_b)**2)**0.5)
| 1 | 20,158,248,689,050 | null | 144 | 144 |
for i in range(len(input()) - 1):print("x",end="")
print("x") | def main():
INF = 10 ** 18
N = int(input())
A = list(map(int, input().split(' ')))
K = 1 + N % 2 # 余分な×を入れられる個数
# dp[i][j]: i個目までの要素で余分な×をj個使った際の最大値
dp = [[- INF for _ in range(K + 1)] for _ in range(N + 1)]
dp[0][0] = 0
for i in range(N):
for j in range(K + 1):
if j < K:
# 余分な×を使う場合
dp[i + 1][j + 1] = max(dp[i + 1][j + 1], dp[i][j])
# 余分な×を使わない場合
now = dp[i][j]
if (i + j) % 2 == 0:
# 基本はi % 2 == 0の時にA[i]を足していく
# ただ、余分な×がj個入っていると、その分ずれる
now += A[i]
dp[i + 1][j] = max(dp[i + 1][j], now)
print(dp[N][K])
if __name__ == '__main__':
main()
| 0 | null | 55,287,147,667,892 | 221 | 177 |
N=int(input())
A=list(map(int,input().split()))
ans=0
tree=1
node=sum(A)
flag=0
for i in A:
ans+=i
node-=i
if i>tree:
ans=-1
break
tree-=i
if tree<node:
ans+=tree
else:
ans+=node
tree=2*tree
print(ans) | def main():
n = int(input())
a = list(map(int,input().split()))
ki = [0 for i in range(n+1)]
ki[0] = 1
for i in range(1,n+1):
ki[i] = 2*(ki[i-1] - a[i-1])
if ki[i]<=0:
print(-1)
return
if ki[-1]<a[-1]:
print(-1)
return
ki[-1] = a[-1]
for i in range(n):
ki[n-1-i] = min(ki[n-1-i],ki[n-i]+a[n-1-i])
print(sum(ki))
if __name__ == "__main__":
main()
| 1 | 18,927,131,618,048 | null | 141 | 141 |
import math
A, B, H, M = map(int, input().split())
c = math.cos(math.radians(360 - abs(30 * H + 0.5 * M - 6 * M)))
X_2 = A ** 2 + B ** 2 - 2 * A * B * c
X = math.sqrt(X_2)
print(X) |
from math import cos, pi
A, B, H, M = map(int, input().split())
theta = abs(M * 6 - (H * 30 + M / 2)) / 360 * 2 * pi
c = (A ** 2 + B ** 2 - 2 * A * B * cos(theta)) ** 0.5
print(c)
| 1 | 20,040,937,416,412 | null | 144 | 144 |
while True:
H,W = list(map(int, input().split()))
if (H == 0 and W == 0):
break
else:
for n in range(H):
s = ""
for m in range(W):
if (0 < n and n < H-1) and (0 < m and m < W-1):
s += "."
else:
s += "#"
print(s)
print("") | while True:
H, W = map(int, input().split())
if H == 0 and W == 0:
break
for i, h in enumerate((range(H - 1))):
if i == 0:
print('#' * W)
else:
print('#' + '.' * (W - 2) + '#')
print('#' * W)
print()
| 1 | 821,459,511,332 | null | 50 | 50 |
h, a = map(int,input().split())
print(h//a + min(h%a,1))
| #A問題
S = input()
if S == "RRR":
print(3)
if S == "RRS"or S == "SRR" :
print(2)
if S == "RSR"or S == "RSS" or S == "SRS" or S == "SSR":
print(1)
if S == "SSS":
print(0) | 0 | null | 40,854,989,253,792 | 225 | 90 |
import sys
input = sys.stdin.readline
n = int(input())
a = 0
if n % 2 == 1:
a == 0
else:
n = n // 2
k = 5
while k <= n:
a += n // k
k *= 5
print(a) | import itertools
N = int(input())
l = []
for i in itertools.permutations(list(range(1,N+1))):
l.append(i)
P = tuple(map(int,input().split()))
Q = tuple(map(int,input().split()))
a = 1
b = 1
for i in l:
if i < P:
a += 1
for i in l:
if i < Q:
b += 1
print(abs(a-b)) | 0 | null | 108,561,834,369,408 | 258 | 246 |
n, x = int(input()), list(map(int, input().split()))
px = 0
a = 100 ** 100
for i in range(100):
s = 0
for j in x:
s += (i-j) ** 2
if a > s:
a = s
print(a) | n=int(input())
x=list(map(int,input().split()))
m=10**15
for i in range(101):
t=x[:]
s=sum(list(map(lambda x:(x-i)**2,t)))
m=min(m,s)
print(m) | 1 | 65,134,426,150,222 | null | 213 | 213 |
n = int(input())
s = [int(x) for x in input().split()]
cnt = 0
for i in range(n) :
for j in range(n - 1, i, -1) :
if s[j - 1] > s[j] :
s[j - 1], s[j] = s[j], s[j - 1]
cnt += 1
print(" ".join(map(str, s)))
print(cnt)
| n=int(input())
a=list(map(int,input().split(' ')))
sw=0
flag=False
for i in range(n):
flag=False
for j in range(i+1,n)[::-1]:
if a[j]<a[j-1]:
a[j],a[j-1]=a[j-1],a[j]
flag=True
sw=sw+1
if not flag: break
print(" ".join(map(str,a)))
print(str(sw)) | 1 | 17,217,898,688 | null | 14 | 14 |
N, K = (int(x) for x in input().split())
ans=0
while(N>=1):
N = int(N/K)
ans+=1
print(ans) | import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")
n,k = map(int , input().split())
i = 0
while pow(k, i)<=n:
i += 1
print(i) | 1 | 64,245,562,380,830 | null | 212 | 212 |
n = int(input())
if n == 2 * int(n / 2):
p = 1 / 2
else:
p = (n + 1) / (2 * n)
print(p) | from collections import Counter
N, P = map(int, input().split())
S = input()
if 10 % P == 0:
ans = 0
for i, s in enumerate(S, start=1):
if int(s) % P != 0:
continue
ans += i
print(ans)
else:
X = [0]
for i, s in enumerate(S[::-1]):
X.append((X[-1] + pow(10, i, P) * int(s)) % P)
C = Counter(X)
ans = 0
for v in C.values():
ans += v * (v - 1) // 2
print(ans)
| 0 | null | 117,374,388,260,294 | 297 | 205 |
def solve():
n = int(input())
print((n+1)//2)
solve() | from scipy.sparse import csr_matrix
from scipy.sparse.csgraph import floyd_warshall
def solve():
N, M, L = map(int, input().split())
dist = [[0 for _ in range(N)] for _ in range(N)]
for i in range(M):
a, b, c = map(int, input().split())
dist[a-1][b-1] = c
dist[b-1][a-1] = c
fw = floyd_warshall(csr_matrix(dist))
ok = [[0 for _ in range(N)] for _ in range(N)]
for i in range(N):
for j in range(N):
if fw[i][j] <= L:
ok[i][j] = 1
ans = floyd_warshall(csr_matrix(ok))
Q = int(input())
for i in range(Q):
s, t = map(lambda x: int(x)-1, input().split())
if ans[s][t] < N:
print(int(ans[s][t])-1)
else:
print(-1)
if __name__ == '__main__':
solve() | 0 | null | 115,992,832,349,900 | 206 | 295 |
n = int(input())
c = list(input())
r = c.count('R')
w = c.count('W')
ans = 0
for i in range(r):
if c[i] == 'R':
pass
elif c[i] == 'W':
ans += 1
print(ans) | import sys
input = sys.stdin.readline
N = int(input())
S = input()[:-1]
R = S.count('R')
accR = [0]
for Si in S:
accR.append(accR[-1]+(1 if Si=='R' else 0))
ans = 10**18
for i in range(N+1):
ans = min(ans, abs(i-R)+abs(i-accR[i]))
print(ans) | 1 | 6,341,518,382,190 | null | 98 | 98 |
import math
john=[]
while True:
try:
john.append(input())
except EOFError:
break
for i in john:
k=list(map(int,i.split()))
print(int(math.gcd(k[0],k[1])),int(k[0]*k[1]/math.gcd(k[0],k[1])))
| x=int(input())
x+=1
print(x%2) | 0 | null | 1,452,843,878,818 | 5 | 76 |
n = int(input())
from decimal import Decimal
def calc(n):
for i in range(60000):
if int(Decimal(i) * Decimal('1.08')) == n:
return i
return ':('
print(calc(n)) | import math
def main2():
n = int(input())
x = int(math.ceil(n / 1.08))
if int(x*1.08) == n:
print(x)
else:
print(":(")
if __name__ == "__main__":
main2() | 1 | 125,980,601,047,408 | null | 265 | 265 |
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") | ans = -1
a = 0
K = int(input())
if K % 2 == 0:
ans = -1
elif K % 5 == 0:
ans = -1
else:
for i in range(0, K):
a = (10 * a + 7) % K
if a == 0:
ans = i + 1
break
print(ans) | 0 | null | 3,269,375,100,732 | 41 | 97 |
import string
N = int(input())
alph = string.ascii_lowercase
ans = []
A = [0]
def search():
if len(A) == N:
ans.append(tuple(A))
return
mx = max(A)
for i in range(mx + 2):
A.append(i)
search()
A.pop()
return
search()
for a in ans:
print(''.join(alph[i] for i in a))
| A,B,C,D=map(int,input().split())
x=(A-1)//D+1
y=(C-1)//B+1
if x<y:
print("No")
else:
print("Yes")
| 0 | null | 40,984,671,718,188 | 198 | 164 |
import sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7
input=lambda:sys.stdin.readline().rstrip()
from collections import defaultdict
def resolve():
n,k=map(int,input().split())
A=list(map(int,input().split()))
S=[0]*(n+1)
for i in range(n):
S[i+1]=S[i]+A[i]
for i in range(n+1):
S[i]-=i
S[i]%=k
ans=0
D=defaultdict(int)
for i in range(n+1):
s=S[i]
ans+=D[s]
D[s]+=1
if(i>=k-1):
D[S[i-k+1]]-=1
print(ans)
resolve() | n,k=map(int,input().split())
a=list(map(int,input().split()))
dp=[0]
mp={0:1}
ans=0
for t in range(n):
i=a[t]
if t>=k-1:
mp[dp[-k]]-=1
num=(dp[-1]+i-1)%k
if num in mp.keys():
ans += mp[num]
mp[num] += 1
else:
mp[num] = 1
dp.append(num)
print(ans) | 1 | 137,358,722,687,792 | null | 273 | 273 |
n=int(input())
arr1=[]
arr2=[]
for _ in range(n):
s=input()
cnt1=0
cnt2=0
for i in range(len(s)):
if s[i]=='(':
cnt1+=1
else:
if cnt1==0:
cnt2+=1
else:
cnt1-=1
if cnt1-cnt2>=0:
arr1.append([cnt1,cnt2])
else:
arr2.append([cnt1,cnt2])
arr1=sorted(arr1,key=lambda x:x[1])
arr2=sorted(arr2,reverse=True,key=lambda x:x[0])
arr=arr1+arr2
cnt=0
for a,b in arr:
if b>cnt:
print('No')
break
else:
cnt+=a-b
else:
if cnt==0:
print('Yes')
else:
print('No') | import sys
n=int(input())
a=[]
b=[]
for i in range(n):
s=input()
overall=0
minimum=0
current=0
for j in range(len(s)):
if s[j]=='(':
current+=1
else:
current-=1
minimum=min(current,minimum)
overall=current
if overall>=0:
a.append([overall,minimum])
else:
b.append([overall,minimum])
finalsum=0
a=sorted(a, key=lambda t:t[1])
a.reverse()
b=sorted(b, key=lambda t:t[0]-t[1])
b.reverse()
for i in a:
if finalsum+i[1]<0:
print('No')
sys.exit()
finalsum+=i[0]
for i in b:
if finalsum+i[1]<0:
print('No')
sys.exit()
finalsum+=i[0]
if finalsum==0:
print('Yes')
else:
print('No') | 1 | 23,656,960,519,618 | null | 152 | 152 |
# B-81
# 標準入力 N
N = int(input())
num_list = [1, 2, 3, 4, 5, 6, 7, 8, 9]
j = 0
for i in range(1, 9 + 1):
if (N / i) in num_list:
j += 1
if j == 0:
print('No')
else:
print('Yes')
| N=int(input())
ok=0
for i in range(1,10):
j = N/i
if j==int(j) and 1<=j<=9:
ok=1
print('Yes')
break
if ok==0:print('No') | 1 | 160,382,473,229,788 | null | 287 | 287 |
def resolve():
k,n = map(int,input().split())
a = list(map(int,input().split()))
l = a[0]+k-a[-1]
for i in range(1,n):
l = max(l,a[i]-a[i-1])
print(k-l)
resolve() | def Dis(X,Y,p):
D = 0
for x, y in zip(X, Y):
dis = abs(x - y) ** p
D += dis
result = D ** (1/p)
print(result)
def Dis_Che(X, Y):
print(max(abs(x-y) for x, y in zip(X, Y)))
n = int(input())
X = list(map(int, input().split()))
Y = list(map(int, input().split()))
for p in range(1,4):
Dis(X, Y, p)
Dis_Che(X,Y)
| 0 | null | 21,891,966,526,848 | 186 | 32 |
n,x,y = map(int,input().split())
cnt_l = [0]*n
from collections import deque
# 幅優先探索
def bfs(start):
queue = deque()
queue.append(start)
step_counts = [-1]*(n+1)
step_counts[start] = 0
while(queue):
i = queue.popleft()
cnt = step_counts[i]
# 隣のグラフを取得
if(i==x):
nex_l = (i-1,y,i+1)
elif(i==y):
nex_l = (i-1,x,i+1)
else:
nex_l = (i-1,i+1)
cnt += 1
for j in nex_l:
# 端より先だと止める
if(j < 1 or n < j):
continue
# 訪問済みだと止める
if(step_counts[j]!=-1):
continue
queue.append(j)
step_counts[j] = cnt
cnt_l[cnt] += 1
for i in range(1,n+1):
bfs(i)
for i in range(1,n):
# (a,b),(b,a)のペアがあるため//2
print(cnt_l[i]//2)
| W = str(input())
words = []
while True:
line = str(input())
if line == 'END_OF_TEXT':
break
words += line.lower().split()
cnt = 0
for word in words:
if W == word:
cnt += 1
print(cnt)
| 0 | null | 23,132,160,074,422 | 187 | 65 |
def cmb(n, r, p):
if (r < 0) or (n < r):
return 0
r = min(r, n - r)
return fact[n] * factinv[r] * factinv[n - r] % p
p = 10 ** 9 + 7
N = 10 ** 5 + 1 # N は必要分だけ用意する
fact = [1, 1]
factinv = [1, 1]
inv = [0, 1]
for i in range(2, N + 1):
fact.append((fact[-1] * i) % p)
inv.append((-inv[p % i] * (p // i)) % p)
factinv.append((factinv[-1] * inv[-1]) % p)
N, K = map(int, input().split())
A = list(map(int, input().split()))
A.sort()
ans = 0
for ri in range(2):
for i in range(N):
now = cmb(i, K - 1, p)
if ri == 1:
now = - now
ans += A[i] * now
ans %= p
A.sort(reverse=True)
print(ans) | class Combination:
def __init__(self, n_max, mod=10**9+7):
self.mod = mod
self.modinv = self.make_modinv_list(n_max)
self.fac, self.facinv = self.make_factorial_list(n_max)
def __call__(self, n, r):
return self.fac[n] * self.facinv[r] % self.mod * self.facinv[n-r] % self.mod
def make_factorial_list(self, n):
# 階乗のリストと階乗のmod逆元のリストを返す O(n)
# self.make_modinv_list()が先に実行されている必要がある
fac = [1]
facinv = [1]
for i in range(1, n+1):
fac.append(fac[i-1] * i % self.mod)
facinv.append(facinv[i-1] * self.modinv[i] % self.mod)
return fac, facinv
def make_modinv_list(self, n):
# 0からnまでのmod逆元のリストを返す O(n)
modinv = [0] * (n+1)
modinv[1] = 1
for i in range(2, n+1):
modinv[i] = self.mod - self.mod//i * modinv[self.mod%i] % self.mod
return modinv
N,K = map(int,input().split())
A = list(map(int,input().split()))
A.sort()
MOD = 10**9+7
comb = Combination(10**5+1)
ans = 0
for i in range(N-K+1):
ans -= A[i] * comb(N - i - 1, K - 1) % MOD
ans %= MOD
A = A[::-1]
for i in range(N-K+1):
ans += A[i] * comb(N - i - 1, K - 1) % MOD
ans %= MOD
print(ans % MOD) | 1 | 96,131,520,359,126 | null | 242 | 242 |
n,*a = map(int,open(0).read().split())
cnt = [3]+[0]*n
ans = 1
mod = 10**9+7
for i in a:
ans = ans * cnt[i] % mod
cnt[i] -= 1
cnt[i+1] += 1
print(ans) | 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
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 LIST() : return list(MAP())
n = INT()
a = LIST()
ans = 1
r = 0
g = 0
b = 0
for x in a:
ans = ans * ( (r == x) + (g == x) + (b == x) ) % (10**9+7)
if r == x:
r += 1
elif g == x:
g += 1
else:
b += 1
print(ans) | 1 | 129,901,039,872,252 | null | 268 | 268 |
# Vicfred
# https://atcoder.jp/contests/abc154/tasks/abc154_a
# simulation
s, t = input().split()
a, b = list(map(int, input().split()))
u = input()
balls = {}
balls[s] = a
balls[t] = b
balls[u] = balls[u] - 1
print(balls[s], balls[t])
| s = input().split()
n = list(map(int, input().split()))
U = input()
n[s.index(U)] -= 1
print(n[0], n[1]) | 1 | 72,017,915,444,992 | null | 220 | 220 |
A=int(input())
B=int(input())
print(6-(A+B)) | bingo=[]
for i in range(3):
a=list(map(int,input().split()))
bingo.append(a)
n=int(input())
for i in range(n):
b=int(input())
for j in range(3):
if b in bingo[j]:
bingo[j][bingo[j].index(b)]=0
def hantei(l):
for i in range(3):
if all([l[i][j]==0 for j in range(3)]):
return 'Yes'
elif all([l[j][i]==0 for j in range(3)]):
return 'Yes'
elif l[0][0]==0 and l[1][1]==0 and l[2][2]==0:
return 'Yes'
elif l[0][2]==0 and l[1][1]==0 and l[2][0]==0:
return 'Yes'
else:
continue
return 'No'
#print(bingo)
print(hantei(bingo)) | 0 | null | 85,086,508,916,288 | 254 | 207 |
K=int(input());S=""
for i in range(K):
S=S+"ACL"
print(S) | k = int(input())
text = "ACL" * k
print(text) | 1 | 2,186,462,758,942 | null | 69 | 69 |
import sys
input = sys.stdin.readline
from collections import *
def bfs(s):
q = deque([s])
dist = [-1]*N
dist[s] = 0
while q:
v = q.popleft()
for nv in G[v]:
if dist[nv]==-1:
dist[nv] = dist[v]+1
q.append(nv)
if s==V-1:
is_leaf[v] = False
return dist
N, U, V = map(int, input().split())
G = [[] for _ in range(N)]
for _ in range(N-1):
A, B = map(int, input().split())
G[A-1].append(B-1)
G[B-1].append(A-1)
is_leaf = [True]*N
d1 = bfs(V-1)
d2 = bfs(U-1)
ans = 0
for i in range(N):
if not is_leaf[i] and d2[i]<=d1[i]:
ans = max(ans, d1[i])
print(ans) | from collections import deque
N, u, v = map(int, input().split())
u -= 1
v -= 1
graph = [[] for _ in range(N)]
for _ in range(N-1):
a, b = map(lambda x:int(x)-1, input().split())
graph[a] += [b]
graph[b] += [a]
def bfs(s):
dist = [-1]*N
q = deque([s])
dist[s] = 0
while q:
u = q.popleft()
for v in graph[u]:
if dist[v] == -1:
dist[v] = dist[u] + 1
q.append(v)
return dist
d1 = bfs(u)
d2 = bfs(v)
ans = 0
for i in range(N):
if d1[i] < d2[i]:
ans = max(ans, d2[i]-1)
print(ans)
| 1 | 117,293,077,454,432 | null | 259 | 259 |
#A
import math
n = int(input())
print((math.ceil(n / 2)) / n)
| n = int(input())
s_taro,s_hanako = 0,0
for trial in range(n):
taro,hanako = list(map(str, input().split()))
if taro > hanako:
s_taro += 3
elif taro < hanako:
s_hanako += 3
else:
s_taro += 1
s_hanako += 1
print(s_taro, s_hanako) | 0 | null | 89,808,179,833,340 | 297 | 67 |
mount_list = []
for i in range(10):
mount_list.append(int(input()))
mount_list.sort(reverse = True)
for i in range(3):
print(mount_list[i])
| from collections import deque
n, q = map(int, input().split())
Q = deque()
for i in range(n):
name,time = input().split()
Q.append([name, int(time)])
sum =0
while Q:
qt = Q.popleft()
if qt[1] <= q:
sum += qt[1]
print(qt[0], sum)
else:
sum += q
qt[1] -= q
Q.append(qt) | 0 | null | 21,681,911,930 | 2 | 19 |
import sys
sys.setrecursionlimit(10 ** 8)
ini = lambda: int(sys.stdin.readline())
inl = lambda: [int(x) for x in sys.stdin.readline().split()]
ins = lambda: sys.stdin.readline().rstrip()
debug = lambda *a, **kw: print("\033[33m", *a, "\033[0m", **dict(file=sys.stderr, **kw))
def solve():
n, a, b = inl()
if a > b:
a, b = b, a
if (b - a) % 2 == 0:
return (b - a) // 2
d1 = a - 1
d2 = n - b
if d1 < d2:
return d1 + 1 + (b - a) // 2
else:
return d2 + 1 + (b - a) // 2
print(solve())
| import math
h1,m1,h2,m2,k=map(int,input().split())
start=60*h1+m1
end=60*h2+m2
print(end-start-k)
"""
a=[]
temp=input().split()
for i in range(n):
a.append(int(temp[i])-1)
routetemp=[]
routetemp.append(0)
while True:
if a[routetemp[-1]] in routetemp:
roop=len(routetemp)-routetemp.index(a[routetemp[-1]])
pre=routetemp.index(a[routetemp[-1]])
break
routetemp.append(a[routetemp[-1]])
#print(routetemp)
#print(a)
#print(roop)
#print(pre)
num=(k-pre)%roop
#print(num)
print(routetemp[pre+num]+1)
""" | 0 | null | 63,607,100,631,062 | 253 | 139 |
n = int(input())
s = [input() for i in range(n)]
z = ['AC','WA','TLE','RE']
for j in z:
print(j+' x '+str(s.count(j)))
| n,k=map(int,input().split())
p=list(map(int,input().split()))
a=[0]*n
b=[0]*n
for i in range(n):
a[i]=(p[i]+1)/2
b[0]=a[0]
for i in range(1,n):
b[i]=b[i-1]+a[i]
ans=b[k-1]
for i in range(1,n-k+1):
ans=max(ans,b[i+k-1]-b[i-1])
print(ans) | 0 | null | 41,648,516,778,180 | 109 | 223 |
line = list(input())
print(''.join(line[:3])) | a=list(map(str,input().split()))
print(a[0][0]+a[0][1]+a[0][2]) | 1 | 14,824,238,904,860 | null | 130 | 130 |
N, M = [int(_) for _ in input().split()]
l = 1
r = N
ans = []
for _ in range(M - M // 2):
ans += [l, r]
l += 1
r -= 1
if (r - l) % 2 == (l + N - r) % 2:
r -= 1
for _ in range(M // 2):
ans += [l, r]
l += 1
r -= 1
ans = ans[:2 * M]
print('\n'.join(f'{a} {b}' for a, b in zip(ans[::2], ans[1::2])))
| n, m = map(int, input().split())
if n%2 == 1:
a = 1
b = n+1
ans = []
for i in range(m):
a += 1
b -= 1
ans.append((a, b))
else:
a = 1
b = n+1
S = set()
ans = []
for i in range(m):
a += 1
b -= 1
r = min(b-a, n-(b-a))
if r in S or r == n//2:
b -= 1
r = min(b-a, n-(b-a))
ans.append((a, b))
S.add(r)
for i in range(m):
print(*ans[i])
| 1 | 28,793,632,448,502 | null | 162 | 162 |
# フェルマーの小定理
def main():
from builtins import pow
K = int(input())
S = input()
m = 1000000007
result = 0
a = 1
b = 1
t = pow(26, K, m)
u = pow(26, m - 2, m) * 25 % m
l = len(S)
for i in range(K + 1):
# result += pow(26, K - i, m) * mcomb(len(S) - 1 + i, i) * pow(25, i, m)
result += t * (a * pow(b, m - 2, m))
result %= m
t *= u
t %= m
a *= l + i
a %= m
b *= i + 1
b %= m
print(result)
main()
| def f_strivore(MOD=10**9 + 7):
K = int(input())
S = input()
length = len(S)
class Combination(object):
"""素数 mod に対する二項係数の計算"""
__slots__ = ['mod', 'fact', 'factinv']
def __init__(self, max_val_arg: int = 10**6, mod: int = 10**9 + 7):
fac, inv = [1], []
fac_append, inv_append = fac.append, inv.append
for i in range(1, max_val_arg + 1):
fac_append(fac[-1] * i % mod)
inv_append(pow(fac[-1], -1, mod))
for i in range(max_val_arg, 0, -1):
inv_append((inv[-1] * i) % mod)
self.mod, self.fact, self.factinv = mod, fac, inv[::-1]
def combination(self, n, r):
return (0 if n < 0 or r < 0 or n < r
else self.fact[n] * self.factinv[r] * self.factinv[n - r] % self.mod)
comb = Combination(length + K).combination
f = [1] * (K + 1)
tmp = 1
for n in range(K + 1):
f[n] = (comb(length + n - 1, length - 1) * tmp) % MOD
tmp = (tmp * 25) % MOD
g = [1] * (K + 1)
for n in range(1, K + 1):
g[n] = (f[n] + 26 * g[n - 1]) % MOD
return g[K]
print(f_strivore()) | 1 | 12,818,925,132,562 | null | 124 | 124 |
MOD = 10**9 + 7
N = 2 * 10**6 + 10 # N は必要分だけ用意する
fact = [1, 1] # fact[n] = (n! mod MOD)
factinv = [1, 1] # factinv[n] = ((n!)^(-1) mod MOD)
inv = [0, 1]
def nCr(n, r, mod):
if (r < 0) or (n < r):
return 0
r = min(r, n - r)
return fact[n] * factinv[r] * factinv[n-r] % mod
for i in range(2, N + 1):
fact.append((fact[-1] * i) % MOD)
inv.append((-inv[MOD % i] * (MOD // i)) % MOD)
factinv.append((factinv[-1] * inv[-1]) % MOD)
k = int(input())
s = len(input())
ans = 0
for i in range(k+1):
ansp = pow(26,i,MOD) * pow(25,k-i,MOD) * nCr(s+k-1-i,s-1,MOD) % MOD
ans = (ans + ansp) % MOD
print(ans)
| N=int(input())
S,T=input().split()
list=[]
for i in range(N):
list.append(S[i]+T[i])
print(''.join(list))
| 0 | null | 62,725,793,810,848 | 124 | 255 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.