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
|
|---|---|---|---|---|---|---|
a,b=input().split()
c,d=input().split()
b=int(b)
d=int(d)
if d-b==1:
print("0")
else:
print("1")
|
def main():
N=int(input())
m=int(1e9+7)
print((pow(10,N,m)-pow(9,N,m)-pow(9,N,m)+pow(8,N,m))%m)
if __name__=='__main__':
main()
| 0 | null | 63,919,491,640,488 | 264 | 78 |
N = int(input())
ans = 0
for n in range(1, N+1):
if n%3 == 0:
pass
elif n%5 == 0:
pass
else:
ans += n
print(ans)
|
N = int(input())
flg = 'No'
for i in range(1,10):
for j in range(1, 10):
if N == i*j:
flg = 'Yes'
print(flg)
| 0 | null | 97,280,304,968,622 | 173 | 287 |
A = []
for i in range(3):
A += list(map(int,input().split()))
called = [False] * 9
bingo = ((0,1,2),(3,4,5),(6,7,8),(0,3,6),(1,4,7),(2,5,8),(0,4,8),(2,4,6))
N = int(input())
for i in range(N):
target = int(input())
if target in A:
called[A.index(target)] = True
for a,b,c in bingo:
if called[a] and called[b] and called[c]:
print("Yes")
break
else:
print("No")
|
a,b,c = map(int,input().split())
d,e,f = map(int,input().split())
g,h,i = map(int,input().split())
x = []
y = [a,b,c,d,e,f,g,h,i]
n = int(input())
for s in range(n):
x.append(int(input()))
for m in range(9):
if y[m] in x:
y[m] = 0
if y[0] == y[1] == y[2] == 0:
print("Yes")
elif y[3] == y[4] == y[5] == 0:
print("Yes")
elif y[6] == y[7] == y[8] == 0:
print("Yes")
elif y[0] == y[3] == y[6] == 0:
print("Yes")
elif y[1] == y[4] == y[7] == 0:
print("Yes")
elif y[2] == y[5] == y[8] == 0:
print("Yes")
elif y[0] == y[4] == y[8] == 0:
print("Yes")
elif y[2] == y[4] == y[6] == 0:
print("Yes")
else:
print("No")
| 1 | 60,096,864,411,420 | null | 207 | 207 |
n,k = map(int,input().split())
class Combination(): # nCr mod MOD など
"""
O(n+log(mod))の前計算を1回行うことで，O(1)でnCr mod mを求められる
n_max = 10**6のとき前処理は約950ms (PyPyなら約340ms, 10**7で約1800ms)
使用例：
C = Combination(10**6)
print(C.combi_mod(5, 3)) # 10
"""
def __init__(self, n_max, mod=10**9+7): # O(n+log(mod))
self.mod = mod
self.fac, self.facinv = self.prepare(n_max)
#self.modinv = self.make_modinv_list(n_max) ##なくても問題ないので、必要な時のみ使う
def prepare(self,n): # O(n+log(mod))
# 前処理(コンストラクタで自動的に実行)
# 1! ~ n! の計算
factorials = [1] # 0!の分
for m in range(1, n+1):
factorials.append(factorials[m-1]*m%self.mod)
# n!^-1 ~ 1!^-1 の計算
invs = [1] * (n+1)
invs[n] = pow(factorials[n], self.mod-2, self.mod)
for m in range(n, 1, -1):
invs[m-1] = invs[m]*m%self.mod
return factorials, invs # list
def make_modinv_list(self, n): # O(n)
# 0からnまでのmod逆元のリストを返す O(n)
modinv = [0] * (n+1)
modinv[1] = 1
for i in range(2, n+1):
# 整数aのMを法とした時の逆元a^-1は、(0<=a<=M-1)
# a == qM+rであるとき(qは商,rは余り)、
# a^-1 == -qr^-1 % M で与えられる。
modinv[i] = (self.mod - self.mod//i)*modinv[self.mod%i] % self.mod
return modinv
def perm_mod(self,n,r): # nPr % self.mod
if n < r:
return 0
if (n < 0 or r < 0):
return 0
return (self.fac[n] * self.facinv[n-r]) % self.mod
def combi_mod(self,n,r): # nCr % self.mod
if n < r:
return 0
if (n < 0 or r < 0):
return 0
return (((self.fac[n] * self.facinv[r]) % self.mod) * self.facinv[n-r]) % self.mod
def repeated_permutation(self,n,deno): # 重複順列
# n!/(deno[0]!*deno[1]!*...*deno[len(deno)-1]) % MOD
## n:int(分子),deno:分母のlist
if n < max(deno):
return 0
if (n < 0 or min(deno) < 0):
return 0
D = 1
for i in range(len(deno)):
D = D*self.facinv[deno[i]] % self.mod
return self.fac*D % self.mod # int ## == n!/(deno[0]!*deno[1]!*...*deno[len(deno)-1]) % MOD
def H(self,n,r): # 重複組合せ nHr % self.mod
now_n = len(self.fac)
if now_n < n+r-1: # もしself.facの長さが足りなかったら追加
for i in range(now_n+1, n+r-1+1):
self.fac.append(self.fac[i-1]*i%self.mod)
return self.combi_mod(n+r-1,r)
mod = 10**9+7
C = Combination(n,mod)
ans = 0
for i in range(min(k+1,n+1)):
ans += C.combi_mod(n,i)*C.H(n-i,i)
ans %= mod
print(ans)
|
from collections import Counter
a = map(int, input().split())
c = Counter(a)
d = {1: 300000, 2: 200000, 3: 100000}
ret = sum(c[rank] * d[rank] for rank in range(1, 3 + 1))
if c[1] == 2:
ret += 400000
print(ret)
| 0 | null | 103,756,358,956,480 | 215 | 275 |
N = int(input())
h = [2,4,5,7,9]
p = [0,1,6,8]
b = [3]
if h.count(N%10)==1:
print('hon')
if p.count(N%10)==1:
print('pon')
if b.count(N%10)==1:
print('bon')
|
n = int(input()[-1])
if n in [2,4,5,7,9]:
print("hon")
elif n in [0,1,6,8]:
print("pon")
else:
print("bon")
| 1 | 19,203,654,655,288 | null | 142 | 142 |
import numpy as np
N = int(input())
X = str(input())
num_one = X.count("1")
dp = [-1] * N
dp[0] = 0
def dfs(n):
if dp[n] == -1:
dp[n] = 1 + dfs(n % bin(n).count('1'))
return dp[n]
num_one = X.count("1")
bool_arr = np.array([True if X[N-i-1] == "1" else False for i in range(N)])
zero_ver = np.array([pow(2, i, num_one + 1) for i in range(N)])
zero_ver_sum = sum(zero_ver[bool_arr])
one_ver = -1
one_ver_sum = 0
flag = False
if num_one != 1:
one_ver = np.array([pow(2, i, num_one - 1) for i in range(N)])
one_ver_sum = sum(one_ver[bool_arr])
else:
flag = True
for i in range(1,N+1):
start = 0
if bool_arr[N-i] == False:
start = (zero_ver_sum + pow(2, N - i, num_one + 1)) % (num_one + 1)
print(dfs(start)+1)
else:
if flag:
print(0)
else:
start = (one_ver_sum - pow(2, N - i, num_one - 1)) % (num_one - 1)
print(dfs(start)+1)
|
def main():
N = int(input())
X = input()
def popcount(x):
'''xの立っているビット数をカウントする関数
(xは64bit整数)'''
# 2bitごとの組に分け、立っているビット数を2bitで表現する
x = x - ((x >> 1) & 0x5555555555555555)
# 4bit整数に 上位2bit + 下位2bit を計算した値を入れる
x = (x & 0x3333333333333333) + ((x >> 2) & 0x3333333333333333)
x = (x + (x >> 4)) & 0x0f0f0f0f0f0f0f0f # 8bitごと
x = x + (x >> 8) # 16bitごと
x = x + (x >> 16) # 32bitごと
x = x + (x >> 32) # 64bitごと = 全部の合計
return x & 0x0000007f
ans = []
f = [0] * N
# preprocess 1
for i in range(1, N):
pc = popcount(i)
j = i % pc
f[i] = f[j] + 1
# preprocess 2
X_COUNT = X.count("1")
X = tuple(map(int, tuple(X)))
rem_plus = [0] * N
rem_minus = [0] * N
two_factor = 1
for i in range(N):
rem_plus[i] = two_factor
two_factor *= 2
two_factor %= (X_COUNT+1)
if X_COUNT > 1:
two_factor = 1
for i in range(N):
rem_minus[i] = two_factor
two_factor *= 2
two_factor %= (X_COUNT-1)
X_rem_plus = 0
X_rem_minus = 0
two_factor = 1
for c in X[::-1]:
X_rem_plus += two_factor*c
X_rem_plus %= (X_COUNT+1)
two_factor *= 2
two_factor %= (X_COUNT+1)
if X_COUNT > 1:
two_factor = 1
for c in X[::-1]:
X_rem_minus += two_factor*c
X_rem_minus %= (X_COUNT-1)
two_factor *= 2
two_factor %= (X_COUNT-1)
for i, c in enumerate(X):
if c:
if X_COUNT > 1:
rem = X_rem_minus - rem_minus[N-1-i]
rem %= (X_COUNT-1)
ans.append(f[rem]+1)
elif X_COUNT == 1:
ans.append(0)
else:
ans.append(0)
else:
rem = X_rem_plus + rem_plus[N-1-i]
rem %= (X_COUNT+1)
ans.append(f[rem]+1)
print(*ans, sep="\n")
if __name__ == "__main__":
main()
| 1 | 8,159,787,883,420 | null | 107 | 107 |
def p(n):
if n == 1:
return 300000
elif n == 2:
return 200000
elif n == 3:
return 100000
else:
return 0
x, y = map(int, input().split())
ans = 0
if x == y == 1:
ans += 400000
ans += p(x) + p(y)
print(ans)
|
x, y = map(int, input().split())
prize = 0
if x <= 3:
prize += (300000 - (x - 1) * 100000)
if y <= 3:
prize += (300000 - (y - 1) * 100000)
if (x == 1) & (y == 1):
prize += 400000
print(prize)
| 1 | 140,808,279,525,912 | null | 275 | 275 |
n = int(raw_input())
a = map(int, raw_input().split())
count = 0
def merge(A, left, mid, right):
n1 = mid - left
n2 = right - mid
L = [0 for i in range(n1+1)]
R = [0 for i in range(n2+1)]
for i in range(n1):
L[i] = A[left + i]
for i in range(n2):
R[i] = A[mid + i]
L[n1] = 10**9 + 1
R[n2] = 10**9 + 2
i = 0
j = 0
for k in range(left, right):
global count
count += 1
if L[i] <= R[j]:
A[k] = L[i]
i += 1
else:
A[k] = R[j]
j += 1
def mergeSort(A, left, right):
if left + 1 < right:
mid = int((left + right) /2)
mergeSort(A, left, mid)
mergeSort(A, mid, right)
merge(A, left, mid, right)
mergeSort(a, 0, n)
print ' '.join(map(str, a))
print count
|
n = int(input())
s = list(map(int, input().split()))
cnt = 0
def merge(A, left, mid, right):
L = A[left:mid]
R = A[mid:right]
L.append(float('inf'))
R.append(float('inf'))
i = 0
j = 0
global cnt
for k in range(left, right):
cnt += 1
if L[i] <= R[j]:
A[k] = L[i]
i += 1
else:
A[k] = R[j]
j += 1
def mergeSort(A, left, right):
if left+1 < right:
mid = (left+right) // 2
mergeSort(A, left, mid)
mergeSort(A, mid, right)
merge(A, left, mid, right)
mergeSort(s, 0, n)
print(' '.join(map(str, s)))
print(cnt)
| 1 | 113,281,259,520 | null | 26 | 26 |
# coding: utf-8
# Your code here!
import bisect
N,D,A=map(int,input().split())
log=[]
loc=[]
ene=[]
for _ in range(N):
X,H=map(int,input().split())
log.append([X,H])
log.sort(key=lambda x:x[0])
for X,H in log:
loc.append(X)
ene.append(H)
syokan=[0]*N
power=0
for i in range(N):
temp=max(-((-ene[i]+power)//A),0)*A
power+=temp
rng=bisect.bisect_right(loc,loc[i]+2*D)
syokan[min(rng-1,N-1)]+=temp
power-=syokan[i]
#print(syokan)
#print(syokan)
print(sum(syokan)//A)
|
import sys
N = int(input())
array = list(map(int,input().split()))
if not ( 1 <= N <= 100 ): sys.exit()
if not ( 1 <= min(array) and max(array) <= 1000 ): sys.exit()
for I in array:
if I % 2 == 0 and not ( I % 3 == 0 or I % 5 == 0 ):
print('DENIED')
sys.exit()
print('APPROVED')
| 0 | null | 75,473,014,520,388 | 230 | 217 |
D, T, S = map(int, input().split())
print("Yes" if D <= (T*S) else 'No')
|
# A - Don't be late
D, T, S = map(int, input().split())
if (D + S - 1) // S <= T:
print('Yes')
else:
print('No')
| 1 | 3,594,760,808,308 | null | 81 | 81 |
data = raw_input()
while data.count('-1') < 3:
m,f,r = map(int,data.split(" "))
if m+f < 30 or m == -1 or f == -1:
print 'F'
elif m+f >=80:
print 'A'
elif m+f >= 65:
print 'B'
elif m+f >= 50 or (m+f >=30 and r>= 50):
print 'C'
elif m+f >= 30:
print 'D'
elif m+f <30:
print 'F'
data = raw_input()
|
from bisect import bisect_left
N, M = map(int, input().split())
A = list(map(int, input().split()))
A.sort()
def count(x):
ret = 0
for a in A:
ret += N - bisect_left(A, x - a)
return ret
overEq = 0
less = 10**7
while less - overEq > 1:
mid = (less + overEq) // 2
if count(mid) >= M:
overEq = mid
else:
less = mid
ans = 0
cnt = [0] * N
for a in A:
i = (N - bisect_left(A, overEq - a))
ans += i * a
if i > 0:
cnt[-i] += 1
for i in range(1, N):
cnt[i] += cnt[i - 1]
for a, c in zip(A, cnt):
ans += a * c
ans -= overEq * (count(overEq) - M)
print(ans)
| 0 | null | 54,875,188,897,540 | 57 | 252 |
n,m=map(int,input().split())
s=input()
ans=[]
cursor=n
actualfail=0
while cursor!=0:
if cursor<=m:
ans.append(cursor)
break
failflag=1
for i in range(m):
if s[cursor-m+i]=='0':
failflag=0
ans.append(m-i)
cursor-=m-i
break
if failflag==1:
actualfail=1
break
if actualfail==1:
print(-1)
else:
ans.reverse()
for i in ans:
print(i)
|
n,k=map(int,input().split())
h=input()
cnt=0
for i in range(n):
if h[i]=="1":
cnt+=1
else:
cnt=0
if cnt>=k:
print(-1)
exit()
h=h[::-1]
h+="0"
idx=0
ans=[]
while 1:
if idx+k>=n:
ans.append(n-idx)
break
for i in range(k,0,-1):
if h[idx+i]=="0":
ans.append(i)
idx+=i
break
ans=reversed(ans)
print(" ".join([str(x) for x in ans]))
| 1 | 138,883,494,743,460 | null | 274 | 274 |
import sys
n = [int(i) for i in sys.stdin.readline().rstrip()[::-1]]
ans = 0
i = 0
p = [n[i],10 - n[i]]
now = [0,0]
i += 1
ans = min(p[0], p[1] + 1)
for i in range(1,len(n)):
now[0] = min(p[0] + n[i]%10, p[1] + n[i]%10 + 1)
now[1] = min(p[0] + 10 - n[i]%10, p[1] + 9 - n[i]%10)
ans = min(now[0], now[1] + 1)
p[0],p[1] = now[0],now[1]
print(ans)
|
import sys, bisect, math, itertools, heapq, collections
from operator import itemgetter
# a.sort(key=itemgetter(i)) # i番目要素でsort
from functools import lru_cache
# @lru_cache(maxsize=None)
sys.setrecursionlimit(10**8)
input = sys.stdin.readline
INF = float('inf')
mod = 10**9+7
eps = 10**-7
def inp():
'''
一つの整数
'''
return int(input())
def inpl():
'''
一行に複数の整数
'''
return list(map(int, input().split()))
class SegmentTree():
def __init__(self, init_val, N):
"""
Parameters
----------
init_val:int
identity element
N:int
the number of nodes
"""
self.init_val=init_val
# Range Minimum Query
self.N0 = 2**(N-1).bit_length()
# 0-indexedで管理
self.data = [self.init_val] * (2 * self.N0)
def _segfunc(self, left, right):
res= left | right
return res
def update(self,k, x):
"""
Parameters
----------
k:int
target index(0-index)
x:any
target value
"""
k += self.N0-1
self.data[k] = x
while k > 0:
k = (k - 1) // 2
self.data[k] = self._segfunc(self.data[2*k+1], self.data[2*k+2])
def query(self, l, r):
"""
Parameters
----------
l,r:int
target range [l,r)
Return
----------
res:any
val
"""
L = l + self.N0
R = r + self.N0
s = self.init_val
while L < R:
if R & 1:
R -= 1
s = self._segfunc(s, self.data[R-1])
if L & 1:
s = self._segfunc(s,self.data[L-1])
L += 1
L >>= 1; R >>= 1
return s
n=inp()
s=input()
st = SegmentTree(0,n)
for i in range(n):
st.update(i,1<<(int.from_bytes(s[i].encode(),'little')-int.from_bytes('a'.encode(),'little')))
q = inp()
ans = []
for i in range(q):
mode, first, second = input().split()
if mode == "1":
st.update(int(first)-1,1<<(int.from_bytes(second.encode(),'little')-int.from_bytes('a'.encode(),'little')))
else:
ans.append(bin(st.query(int(first) - 1, int(second))).count("1"))
for i in ans:
print(i)
| 0 | null | 66,881,138,484,468 | 219 | 210 |
import math
def main():
A, B, H, M = map(int, input().split())
h_angle = 30 * H + 0.5 * M
if h_angle <= 90:
h_angle = math.radians(90 - h_angle)
else:
h_angle = math.radians(360 - (h_angle - 90))
m_angle = 6 * M
if m_angle <= 90:
m_angle = math.radians(90 - m_angle)
else:
m_angle = math.radians(360 - (m_angle - 90))
h_x = A * math.cos(h_angle)
h_y = A * math.sin(h_angle)
m_x = B * math.cos(m_angle)
m_y = B * math.sin(m_angle)
print(math.sqrt(abs(h_x - m_x)**2 + abs(h_y - m_y)**2))
if __name__ == '__main__':
main()
|
a,b,c,d = map(int, input().split())
z = 'BATTLE'
while z == 'BATTLE':
c -= b
if c <= 0:
z = 'Yes'
break
a -= d
if a <= 0:
z ='No'
break
print(z)
| 0 | null | 24,897,838,342,900 | 144 | 164 |
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)
|
from itertools import accumulate
import bisect
N, M, K = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
SA = [0] + list(accumulate(A))
SB = [0] + list(accumulate(B))
max_count = 0
for i in range(N + 1):
a_count = i
b_count = bisect.bisect_right(SB, K - SA[a_count]) - 1
if b_count >= 0:
count = a_count + b_count
if count > max_count:
max_count = count
print(max_count)
| 1 | 10,794,441,096,450 | null | 117 | 117 |
n,a,b=map(int, input().split())
if a==0:
print(0)
elif b==0:
print(n)
else:
quo=n//(a+b)
#商
if n%(a+b)==0:
rem=0
elif 1<=n%(a+b)<=a:
rem=n%(a+b)
else:
rem=a
print(quo*a+rem)
|
if __name__ == '__main__':
N, A, B = map(int, input().split())
base = pow(10, 100)
C = A+B
mod = N%C
n = N//C
if mod>A:
print(A*n+A)
else:
print(A*n+mod)
| 1 | 55,430,015,668,200 | null | 202 | 202 |
n = int(input())
S = set(input().split())
q = int(input())
T = set(input().split())
print(len(S & T))
|
import math
a,b = map(str, input().split())
b = b.replace(".","")
a = int(a)
b = int(b)
print(a * b // 100)
| 0 | null | 8,368,192,348,712 | 22 | 135 |
n = int(input())
ac = 0
wa = 0
tle = 0
re = 0
for _ in range(n):
s = input()
if s == 'AC':
ac += 1
elif s == 'WA':
wa += 1
elif s == 'TLE':
tle += 1
else:
re += 1
print('AC x ' + str(ac))
print('WA x ' + str(wa))
print('TLE x ' + str(tle))
print('RE x ' + str(re))
|
while(True):
num = input()
if num == '0':
break
x = 0
for i in num:
x += int(i)
print(x)
| 0 | null | 5,186,243,419,464 | 109 | 62 |
A = [1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51]
K = input()
k = int(K)
print(A[k-1])
|
n = int(input())
dp = [1] * (50)
for i in range(n):
dp[i + 2] = dp[i + 1] + dp[i]
print(dp[n])
| 0 | null | 24,969,796,598,802 | 195 | 7 |
import sys
input = sys.stdin.readline
from collections import *
X = int(input())
dp = [False]*(X+1)
dp[0] = True
for i in range(X+1):
for j in range(100, 106):
if i-j>=0:
dp[i] |= dp[i-j]
if dp[X]:
print(1)
else:
print(0)
|
X = int(input())
dp = [0] * (X + 110)
dp[0] = 1
for i in range(X):
if dp[i]:
for j in range(100, 106):
dp[i + j] = 1
print(dp[X])
| 1 | 127,276,688,549,780 | null | 266 | 266 |
k = int(input())
ans = k * "ACL"
print(ans)
|
N = int( input() )
D = list ( int(x) for x in input().split() )
if D[0] != 0:
ans = 0
else:
Ds = [ 0 for i in range( max(D) + 1 ) ]
for i in range( N ):
Ds[ D[i] ] += 1
ans = 1
if Ds[ 0 ] != 1:
ans = 0
else:
for i in range( 1 , max(D) + 1 ):
ans *= Ds[ i-1 ] ** Ds[i]
if ans == 0:
break
print( ans % 998244353 )
| 0 | null | 78,132,351,324,258 | 69 | 284 |
from collections import deque
def main():
n = int(input())
adj = [[]for i in range(n+1)]
ab = [list(map(int, input().split())) for i in range(n-1)]
for a, b in ab:
adj[a].append(b)
adj[b].append(a)
# dequeを使ったスタックによるDFS
# 子をindexで、親ノードを要素で
# 今回は彩色のためにどんな順番でpopされたかも保持しておく
order = []
parent = [0] * (n+1)
visited = [0] * (n+1)
visited[1] = 1
q = deque([1])
while q:
par = q.popleft()
order.append(par)
for chl in adj[par]:
if visited[chl]:
continue
# 行ったことなかったら1へ
visited[chl] = 1
parent[chl] = par
q.append(chl)
# 彩色
# 親と同じにならないように若い番号を割り当てて行く
cl = [None] * (n+1)
for par in order:
# 親の色
pc = cl[par]
# 彩色は1以上k以下
color = 1
for chl in adj[par]:
# 隣接リストの親は無視
if chl == parent[par]:
continue
# 親の色と同じなら色を変える
if pc == color:
color += 1
# カラーリストに子indexにcolorを入れる
cl[chl] = color
# 他の子は色を変える必要がある
color += 1
# 木グラフなので単純に次数最大で考えて問題ない
g = max([len(i) for i in adj])
print(g)
for a, b in ab:
# 親子関係が逆転しない出力ならこれでいいがそうとも限らない
if parent[a] != b:
print(cl[b])
else:
print(cl[a])
if __name__ == '__main__':
main()
|
# -*- coding: utf-8 -*-
#############
# Libraries #
#############
import sys
input = sys.stdin.readline
import math
from collections import deque
from fractions import gcd
from functools import lru_cache
#############
# Constants #
#############
MOD = 10**9+7
INF = float('inf')
#############
# Functions #
#############
######INPUT######
def inputI(): return int(input().strip())
def inputS(): return input().strip()
def inputIL(): return list(map(int,input().split()))
def inputSL(): return list(map(str,input().split()))
def inputILs(n): return list(int(input()) for _ in range(n))
def inputSLs(n): return list(input().strip() for _ in range(n))
def inputILL(n): return [list(map(int, input().split())) for _ in range(n)]
def inputSLL(n): return [list(map(str, input().split())) for _ in range(n)]
#####Inverse#####
def inv(n): return pow(n, MOD-2, MOD)
######Combination######
kaijo_memo = []
def kaijo(n):
if(len(kaijo_memo) > n):
return kaijo_memo[n]
if(len(kaijo_memo) == 0):
kaijo_memo.append(1)
while(len(kaijo_memo) <= n):
kaijo_memo.append(kaijo_memo[-1] * len(kaijo_memo) % MOD)
return kaijo_memo[n]
gyaku_kaijo_memo = []
def gyaku_kaijo(n):
if(len(gyaku_kaijo_memo) > n):
return gyaku_kaijo_memo[n]
if(len(gyaku_kaijo_memo) == 0):
gyaku_kaijo_memo.append(1)
while(len(gyaku_kaijo_memo) <= n):
gyaku_kaijo_memo.append(gyaku_kaijo_memo[-1] * pow(len(gyaku_kaijo_memo),MOD-2,MOD) % MOD)
return gyaku_kaijo_memo[n]
def nCr(n,r):
if(n == r):
return 1
if(n < r or r < 0):
return 0
ret = 1
ret = ret * kaijo(n) % MOD
ret = ret * gyaku_kaijo(r) % MOD
ret = ret * gyaku_kaijo(n-r) % MOD
return ret
######Factorization######
def factorization(n):
arr = []
temp = n
for i in range(2, int(-(-n**0.5//1))+1):
if temp%i==0:
cnt=0
while temp%i==0:
cnt+=1
temp //= i
arr.append([i, cnt])
if temp!=1:
arr.append([temp, 1])
if arr==[]:
arr.append([n, 1])
return arr
#####LCM#####
def lcm(a, b):
return a * b // gcd (a, b)
#############
# Main Code #
#############
N = inputI()
graph = [[] for _ in range(N)]
edges = []
for _ in range(N - 1):
a, b = inputIL()
edges.append((a-1, b-1))
for a, b in edges:
graph[a].append(b)
graph[b].append(a)
k = max(len(edges) for edges in graph)
colors = [color for color in range(1, k + 1)]
usedcolor = [ None for _ in range(N) ]
colored = {}
def youcanusethiscolor(u):
for c in colors:
if c == usedcolor[u]:
continue
yield c
for u in range(N):
color = youcanusethiscolor(u)
for v in graph[u]:
if (u,v) not in colored and (v,u) not in colored:
now = next(color)
colored[(u,v)] = colored[(v,u)] = now
usedcolor[v] = now
print(k)
for a,b in edges:
print(colored[(a,b)])
| 1 | 135,969,779,359,050 | null | 272 | 272 |
def is_leq_S(A, lim, K):
S = [0] * K
ai = 0
si = 0
while ai < len(A):
if S[si] + A[ai] <= lim:
S[si] += A[ai]
ai += 1
else:
si += 1
if si == K:
return False
return True
def main():
N, K = [int(_) for _ in input().split()]
A = []
for _ in range(N):
A.append(int(input()))
l = 0
r = 100000 * 100000
while l + 1 < r:
m = (l + r) // 2
if is_leq_S(A, m, K):
S = m
r = m
else:
l = m
print(S)
main()
|
n,k=map(int,input().split())
a=list(map(int,input().split()))
b=[0]*(n+1)
count=0
now=1
f=1
for _ in range(k):
if b[now]:
f=0
break
count+=1
b[now]=count
now=a[now-1]
if f:
print(now)
exit()
x=count-b[now]+1
y=(k-b[now]+1)%x
for i in range(y):
now=a[now-1]
print(now)
| 0 | null | 11,459,535,261,032 | 24 | 150 |
import math
from collections import Counter
N = int(input())
c = Counter()
ans = 0
for n in range(1, N + 1):
left = n // (10 ** int(math.log10(n)))
right = n % 10
c[(left, right)] += 1
for left, right in c.keys():
ans += c[(left, right)] * c[(right, left)]
print(ans)
|
n = int(input())
num = [[0 for _ in range(10)] for _ in range(10)]
for i in range(1, n + 1):
num[int(str(i)[0])][int(str(i)[-1])] += 1
ans = 0
for i in range(1, 10):
for j in range(1, 10):
ans += num[i][j] * num[j][i]
print(ans)
| 1 | 87,031,557,463,170 | null | 234 | 234 |
# B - Easy Linear Programming
A,B,C,K = map(int,input().split())
while True:
ans = 0
ans += min(A,K)
K -= min(A,K)
if K<=0:
break
K -= B
if K<=0:
break
ans -= K
break
print(ans)
|
import math
a,b,x=map(int,input().split())
v = a * b
x = x / a
if x < v/2:
c = x * 2 / b
d = math.sqrt(b * b + c * c)
print(math.degrees(math.asin(b/d)))
else:
rest = v - x
c = rest * 2 / a
d = math.sqrt(a * a + c * c)
print(math.degrees(math.acos(a/d)))
| 0 | null | 92,599,785,100,412 | 148 | 289 |
input = raw_input().split()
a = int(input[0])
b = int(input[1])
print "%d %d" % (a * b , 2 * (a + b))
|
n, x, m = map(int, input().split())
ans = []
c = [0]*m
flag = False
for i in range(n):
if c[x] == 1:
flag = True
break
ans.append(x)
c[x] = 1
x = x**2 % m
if flag:
p = ans.index(x)
l = len(ans) - p
d, e = divmod(n-p, l)
print(sum(ans[:p]) + d*sum(ans[p:]) + sum(ans[p:p+e]))
else:
print(sum(ans))
| 0 | null | 1,582,045,866,594 | 36 | 75 |
from sys import stdin
a, b = (int(x) for x in stdin.readline().rstrip().split())
area, perimeter = a * b, (a + b) * 2
print(area, perimeter)
|
a, b, c = map(int, input().split())
i = a
ans = 0
while i <= b:
if c % i == 0:
ans += 1
i += 1
print(ans)
| 0 | null | 425,364,622,460 | 36 | 44 |
def main():
a, b, c = map(int, input().split())
if a + b + c > 21:
print("bust")
else:
print("win")
if __name__ == "__main__":
main()
|
def gcd(x, y):
'''??????????????????????????????
x>=y?????¨??????gcd(x, y)??¨gcd(y, x%y)?????????????????¨????????¨??????'''
if x < y:
x, y = y, x
while y > 0:
x, y = y, x % y
return x
def test():
'''??? input =
147 105
->
21'''
x, y = map(int, input().split())
result = gcd(x, y)
print(result)
if __name__ == '__main__':
test()
| 0 | null | 59,689,257,019,750 | 260 | 11 |
s=[int(_) for _ in input()]
m = [0 for i in range(2019)]
d=0
m[d]+=1
p=1
for i in range(len(s)):
d=(d+s[-i-1]*p)%2019
m[d]+=1
p=(p*10)%2019
#print(d)
ans=0
for i in range(2019):
ans+=m[i]*(m[i]-1)//2
print(ans)
|
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
a = [aa-1 for aa in a]
check = [0 for i in range(n)]
count = 0
point = 0
check[0] = 1
path = [0]
for i in range(min(n, k)):
if i == 0 or check[point] == 0:
check[point] = i+1
point = a[point]
path.append(point)
else:
break
cycle_len = len(path)-check[point]
pre = check[point]
if pre > k:
print(path[k])
else:
k -= pre
k %= cycle_len
print(path[pre+k]+1)
| 0 | null | 26,591,605,767,608 | 166 | 150 |
n, k = map(int, input().split())
a = list(map(int, input().split()))
mod = 10 ** 9 + 7
plus = []
minus = []
for i in a:
if i >= 0: plus.append(i)
if i < 0: minus.append(-i)
plus.sort(reverse=True)
minus.sort(reverse=True)
ans = 1
if k == n:
for x in a:
ans = (ans * x) % mod
elif n == len(plus):
for x in plus[:k]:
ans = (ans * x) % mod
elif n == len(minus):
if k % 2 == 1:
ans = -1
minus.sort()
for x in minus[:k]:
ans = (ans * x) % mod
else:
i, j = 0, 0
if k % 2 == 1:
ans = plus[0]
i += 1
while i + j != k:
x_p = plus[i] * plus[i + 1] if i < len(plus) - 1 else 0
x_m = minus[j] * minus[j + 1] if j < len(minus) - 1 else 0
if x_p > x_m:
ans = (ans * x_p) % mod
i += 2
else:
ans = (ans * x_m) % mod
j += 2
print(ans)
|
n = int(input())
s = input()
c_curr = ""
ans = 0
for c in s:
if c != c_curr:
ans += 1
c_curr = c
print(ans)
| 0 | null | 90,061,658,251,630 | 112 | 293 |
#!usr/bin/env python3
def main():
while True:
numbers = input()
if int(numbers) == 0:
break
res = 0
for i in numbers:
res += int(i)
print(res)
if __name__ == '__main__':
main()
|
# -*-coding:utf-8
def main():
while True:
inputNumber = input()
if(inputNumber == '0'):
break
else:
print(sum(list(map(int, inputNumber))))
if __name__ == '__main__':
main()
| 1 | 1,557,898,046,340 | null | 62 | 62 |
n = int(input())
output = 0
for i in range(n):
if (i + 1) % 3 != 0 and (i + 1) % 5 != 0:output += i + 1
print(output)
|
# 1 <= N <= 1000000
N = int(input())
total = []
# N項目までに含まれる->N項目は含まない。だからN項目は+1で外す。
for x in range(1, N+1):
if x % 15 == 0:
"FizzBuzz"
elif x % 5 == 0:
"Buzz"
elif x % 3 == 0:
"Fizz"
else:
total.append(x) #リストに加える
print(sum(total))
| 1 | 34,921,359,510,662 | null | 173 | 173 |
s = input()
p = ""
if(s.endswith("s")):
p = s + "es"
else:
p = s + "s"
print(p)
|
x = input()
if x[-1] == "s":
y = x + "es"
else:
y = x + "s"
print(y)
| 1 | 2,369,035,782,442 | null | 71 | 71 |
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")
|
X,Y = map(int,input().split())
result = 'No'
for x in range(X+1):
if (2*x + 4*(X-x)) == Y:
result = 'Yes'
break
print(result)
| 1 | 13,760,286,820,450 | null | 127 | 127 |
s = input()
if s[0]==s[1] and s[0]==s[2]:
print("No")
else:
print("Yes")
|
a = input().split()
c = int(a[0]) * int(a[1])
d = (int(a[0])*2) + (int(a[1])*2)
print('%d %d' %(c,d))
| 0 | null | 27,717,667,042,232 | 201 | 36 |
def myAnswer(N:int,A:int,B:int) -> int:
ans = 0
BN = N - B
A1 = A - 1
while True:
if((B - A) % 2== 0):
ans += (B - A)//2
break
elif(A == 1):
ans += 1
B -= 1
elif(B == N):
ans += 1
A += 1
else:
if(BN > A1):
ans +=A1
B -= A1
A = 1
else:
ans += BN
A += BN
B = N
return ans
def modelAnswer():
tmp=1
def main():
N,A,B = map(int,input().split())
print(myAnswer(N,A,B))
if __name__ == '__main__':
main()
|
import sys
N, A, B = map(int, sys.stdin.readline().split())
if (B - A) % 2 == 0:
print((B - A) // 2)
else:
print(min(A + (B - A - 1) // 2, N - B + 1 + (B - A - 1) // 2))
| 1 | 109,332,990,738,970 | null | 253 | 253 |
n = int(input())
xpy = []
xmy = []
for i in range(n):
x,y = map(int,input().split())
xpy.append(x+y)
xmy.append(x-y)
xpy.sort()
xmy.sort()
print(max(abs(xpy[0]-xpy[-1]),abs(xmy[0]-xmy[-1])))
|
N=int(input())
A=[]
B=[]
for _ in range(N):
x,y=map(int, input().split())
A.append(x+y)
B.append(x-y)
A=sorted(A)
B=sorted(B)
print(max(A[-1]-A[0],B[-1]-A[0],A[-1]-A[0],B[-1]-B[0]))
| 1 | 3,408,891,286,820 | null | 80 | 80 |
M1,D1 = map(int,input().split())
M2,D2 = map(int,input().split())
print(1) if(M1 != M2) else print(0)
|
m,d=map(int,input().split())
n,e=map(int,input().split())
print(1 if m!=n else 0)
| 1 | 124,104,379,403,840 | null | 264 | 264 |
def main():
s=input()
ans=0
for i in range(0,int(len(s)/2)):
if s[i]!=s[-1*(i+1)]:
ans+=1
print(ans)
main()
|
#!/usr/bin/env python3
import sys
def input():
return sys.stdin.readline()[:-1]
def factorization(n):
arr = []
temp = n
for i in range(2, int(-(-n**0.5//1))+1):
if temp%i==0:
cnt=0
while temp%i==0:
cnt+=1
temp //= i
arr.append([i, cnt])
if temp!=1:
arr.append([temp, 1])
if arr==[]:
arr.append([n, 1])
return arr
def main():
N = int(input())
ans = 1e18
for i in range(1, N + 1):
if i * i > N:
break
if N % i != 0:
continue
j = N // i
ans = min(ans, i + j - 2)
print(ans)
if __name__ == '__main__':
main()
| 0 | null | 140,862,744,002,552 | 261 | 288 |
from collections import deque
from sys import stdin
A = input()
d = deque([])
e = deque([])
area = 0
areas = deque([])
for a,b in enumerate(A):
if b == "\\":
d.append(a)
elif b == "/" and d != deque([]):
x = d.pop()
area += a - x
areas.append([x,a,a-x])
menseki = 0
kaitou = []
prev_start,prev_end = 20000,0
while len(areas) > 0:
temp = areas.pop()
if temp[0] > prev_start and temp[1] < prev_end:
menseki += temp[2]
else:
if menseki != 0:
kaitou.append(menseki)
menseki = temp[2]
prev_start, prev_end = temp[0],temp[1]
if len(areas) == 0:
kaitou.append(menseki)
print(sum(kaitou))
kaitou.append(len(kaitou))
print(*kaitou[::-1])
|
line = input()
stack, edges, pools = [], [], []
for i in range(len(line)):
if line[i] == '\\':
stack.append(i)
elif line[i] == '/' and stack:
j = stack.pop()
tmp = i - j
while edges and edges[-1] > j:
edges.pop()
tmp += pools.pop()
edges.append(j)
pools.append(tmp)
print(sum(pools))
print(len(pools), *pools)
| 1 | 61,253,652,340 | null | 21 | 21 |
SIZE = 2**20 # 2**20 > N=500000
class SegmentTree:
def __init__(self, size):
self.size = size
self.seg = [0] * (2 * size)
def update(self, pos, ch):
# update leaf
i = self.size + pos - 1
self.seg[i] = 1 << (ord(ch)-ord('a'))
# update tree
while i > 0:
i = (i - 1) // 2
self.seg[i] = self.seg[i*2+1] | self.seg[i*2+2]
def _query(self, a, b, k, left, right):
if right<a or b<left:
return 0
if a<=left and right<=b:
return self.seg[k]
vl = self._query(a,b,k*2+1, left, (left+right)//2)
vr = self._query(a,b,k*2+2, (left+right)//2+1, right)
return vl | vr
def query(self, a, b):
return self._query(a,b,0,0,self.size-1)
def resolve():
N = int(input())
S = input().strip()
Q = int(input())
table = [[] for _ in range(26)]
sg = SegmentTree(SIZE)
for i,ch in enumerate(S):
sg.update(i, ch)
for i in range(Q):
query = input().strip().split()
if query[0] == '1':
pos = int(query[1])-1
sg.update(pos, query[2])
else:
left = int(query[1])-1
right = int(query[2])-1
bits = sg.query(left, right)
count = 0
for j in range(26):
count += (bits>>j) & 1
print(count)
resolve()
|
s=input()
l=len(s)
x=0
for i in range(l):
x=x+int(s[i])
if x%9==0:
print("Yes")
else:
print("No")
| 0 | null | 33,559,788,827,088 | 210 | 87 |
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()
|
while 1:
num = input()
if num == "0":
break
a = []
for i in range(len(num)):
a.append(int(num[i:i+1]))
print(sum(a))
| 0 | null | 53,802,746,077,538 | 250 | 62 |
import math
k = int(input())
ans = "NG"
pi = math.pi
print(2*k*pi)
|
import math
cnt = 0
N = int(input())
for n in range(N):
i = int(input())
if i == 2\
or i == 3\
or i == 5\
or i == 7:
cnt += 1
elif i % 2 == 0:
continue
else:
j = 3
prime = 1
while j >= 3 and j <= int(math.sqrt(i)):
if i % j == 0:
prime = 0
break
j += 2
if prime == 1:
cnt += 1
print(cnt)
| 0 | null | 15,605,997,074,540 | 167 | 12 |
N = int(input())
D = list(map(int, input().split()))
mod = 998244353
from collections import Counter, deque
def solve(N,D):
if D[0]!=0:
return 0
c = Counter(D)
if c[0]>1:
return 0
ans = 1
m = max(D)
for i in range(1,m):
if c[i]==0:
ans = 0
continue
ans *= pow(c[i],c[i+1],mod)
ans %= mod
return ans
print(solve(N,D))
|
import sys
input = sys.stdin.buffer.readline
def main():
N = int(input())
d = list(map(int,input().split()))
if d[0] != 0:
print(0)
else:
MOD = 998244353
use = [0 for _ in range(max(d)+1)]
for num in d:
use[num] += 1
if use[0] != 1:
print(0)
else:
ans,pa = 1,1
for num in use:
ans *= pow(pa,num,MOD)
ans %= MOD
pa = num
print(ans)
if __name__ == "__main__":
main()
| 1 | 154,721,070,226,718 | null | 284 | 284 |
X = int(input())
uresisa = (X // 500) * 1000 + ((X % 500) // 5) * 5
print(uresisa)
|
x=int(input())
gohyaku=0
goen=0
while x>5:
x-=500
gohyaku+=1
if x==5:
goen+=1
elif 0<=x<5:
pass
elif x<0:
x+=500
gohyaku-=1
while x>=5:
goen+=1
x-=5
print(gohyaku*1000+goen*5)
| 1 | 42,956,054,645,042 | null | 185 | 185 |
from collections import Counter
s = input()
MOD = 2019
ts = [0]
cur = 0
for i, j in enumerate(s[::-1], 1):
cur = (cur + pow(10, i, MOD) * int(j)) % MOD
ts.append(cur)
ct = Counter(ts)
res = 0
for k, v in ct.items():
if v > 1:
res += v * (v-1) // 2
print(res)
|
N=int(input())
res=[1000000000000]
for i in range(1,int(N**0.5)+1):
if(N%i==0):
res.append(i+N//i-2)
print(min(res))
| 0 | null | 96,020,986,443,264 | 166 | 288 |
def LI():
return list(map(int, input().split()))
X = int(input())
ans = X//500*1000
X = X % 500
ans += X//5*5
print(ans)
|
X = int(input())
gohyaku = X // 500
X = X - (gohyaku * 500)
goen = X // 5
print(gohyaku * 1000 + goen * 5)
| 1 | 42,577,151,788,420 | null | 185 | 185 |
H,W,K = map(int, input().split())
s = []
for i in range(H):
s.append(list(input()))
ans = [[0] * W for i in range(H)]
cnt = 0
flg = True
for i in range(H):
if '#' in s[i]:
cnt += 1
sb = 0
for j in range(W):
if s[i][j] == '#':
sb += 1
if sb > 1:
cnt += 1
ans[i][j] = cnt
if flg == False:
for k in range(i):
ans[k][j] = cnt
flg = True
else:
if i == 0 or flg == False:
flg = False
else:
for j in range(W):
ans[i][j] = ans[i-1][j]
#print(flg)
for i in range(H):
print(' '.join(map(str,ans[i])))
|
def resolve():
H, W, K = map(int, input().split())
G = [list(input()) for _ in range(H)]
ans = [[0] * W for _ in range(H)]
cnt, first = 1, -1
for i in range(H):
tmp = 0
if "#" in G[i]:
if first == -1:
first = i
for j in range(W):
if G[i][j] == "#":
tmp += 1
if tmp > 1:
cnt += 1
ans[i][j] = cnt
cnt += 1
else:
if i > 0:
ans[i] = ans[i - 1][:]
for q in range(first):
ans[q] = ans[first][:]
for i in range(H):
print(*ans[i])
if __name__ == "__main__":
resolve()
| 1 | 143,698,276,113,510 | null | 277 | 277 |
x = int(input())
print("Yes" if x >29 else "No")
|
n=int(input())
if 30<=n :
print('Yes')
else:
print('No')
| 1 | 5,684,336,252,540 | null | 95 | 95 |
n = int(input())
a = list(map(int,input().split()))
hidariwa = sum(a)
migiwa = 0
answer = hidariwa
for i in range(n):
hidariwa -= a[i]
migiwa +=a[i]
answer = min(abs(hidariwa-migiwa),answer)
print(answer)
|
import numpy as np
import itertools
N = int(input())
info = []
for i in range(N):
A = int(input())
for _ in range(A):
x,y = map(int,input().split())
info.append((i,x-1,y))
A = np.array(list(itertools.product([0,1],repeat=N)),np.bool)
for i,x,y in info:
bl = (~A[:,i]) | (A[:,x] == bool(y))
A = A[bl]
answer = A.sum(axis = 1).max()
print(answer)
| 0 | null | 131,976,991,625,880 | 276 | 262 |
import sys
def input(): return sys.stdin.readline().strip()
def main():
N, T = map(int, input().split())
cv = [tuple(map(int, input().split())) for _ in range(N)]
cv = sorted(cv, key=lambda x : x[0])
dp = [[0]*(T+1) for _ in range(N+1)]
dp_ext = [[0]*(T+1) for _ in range(N+1)]
values = [v for c, v in cv]
max_values = [max(values[i:]) for i in range(N)]
# 貰うdp
for i in range(N):
cost, value = cv[i]
for now in range(cost, T+1):
old = now - cost
dp[i+1][now] = max(dp[i][now], dp[i][old] + value)
for j in range(1, T+1):
dp[i+1][j] = max(dp[i+1][j], dp[i+1][j-1])
for j in range(1, T+1):
dp_ext[i+1][j] = max(dp[i+1][j], dp[i][j-1] + max_values[i], dp_ext[i][j])
print(dp_ext[N][T])
if __name__ == "__main__":
main()
|
s = input()
p = input()
if (s * 2).find(p) >= 0:
print("Yes")
else:
print("No")
| 0 | null | 76,551,063,301,462 | 282 | 64 |
a=input('').split()
a=list(map(int,a))
b=(a[0])
c=(a[1])
d=(a[2])
e=(a[3])
f=b*d
g=b*e
h=c*d
i=c*e
if f>g:
if h>f:
if i>h:
print(i)
else:
print(h)
else:
if i>f:
print(i)
else:
print(f)
else:
if h>g:
if i>h:
print(i)
else:
print(h)
else:
if i>g:
print(i)
else:
print(g)
|
n = int(input())
odd = 0
even = 0
for i in range(1,n+1):
if i % 2 == 0:
even += 1
else:
odd += 1
print(odd/n)
| 0 | null | 89,713,308,878,820 | 77 | 297 |
money = int(input())
while money > 1000 :
money -= 1000
print(1000 - money)
|
a = int(input())
num = a //1000
b = num*1000 - a
if b < 0:
c = (num+1)*1000-a
print(c)
else:
print(b)
| 1 | 8,373,051,137,410 | null | 108 | 108 |
K=int(input());S=""
for i in range(K):
S=S+"ACL"
print(S)
|
#input
N, M, L = map(int, input().split())
A = [0] * M
B = [0] * M
C = [0] * M
for i in range(M):
A[i], B[i], C[i] = map(int, input().split())
Q = int(input())
s = [0] * Q
t = [0] * Q
for i in range(Q):
s[i], t[i] = map(int, input().split())
#output
from scipy.sparse.csgraph import floyd_warshall, shortest_path, dijkstra, bellman_ford, johnson
from scipy.sparse import csr_matrix
import numpy as np
#便宜上A, Bを-1する。
for i in range(M):
A[i] -= 1
B[i] -= 1
#FW法で各経路の最短距離を計算する。
graph = csr_matrix((C, (A, B)), shape = (N, N))
dist_matrix = floyd_warshall(csgraph = graph, directed = False, return_predecessors = False)
graph2 = np.full((N, N), np.inf)
graph2[dist_matrix <= L] = 1
graph2 = csr_matrix(graph2)
dist_matrix2 = floyd_warshall(csgraph = graph2, directed = False, return_predecessors = False)
for q in range(Q):
if dist_matrix2[s[q]-1][t[q]-1] < 10000000:
print(int(dist_matrix2[s[q]-1][t[q]-1]-1))
else:
print(-1)
| 0 | null | 87,857,401,709,840 | 69 | 295 |
import sys
def main():
input = sys.stdin.buffer.readline
a, b, c = map(int, input().split())
if len(set([a, b, c])) == 2:
print("Yes")
else:
print("No")
if __name__ == "__main__":
main()
|
l = input().split(' ')
print('Yes' if len(set(l)) == 2 else 'No')
| 1 | 68,257,972,963,138 | null | 216 | 216 |
S = input()
if S == 'ABC':
answer = 'ARC'
elif S == 'ARC':
answer = 'ABC'
else:
answer = '入力間違い【ABC】【ARC】を入力'
print(answer)
|
S=input()
print("{}{}{}".format(S[0],'B' if S[1]!='B' else 'R',S[-1]))
| 1 | 24,170,914,731,390 | null | 153 | 153 |
#!usr/bin/env python3
from collections import defaultdict, deque, Counter, OrderedDict
from bisect import bisect_left, bisect_right
from functools import reduce, lru_cache
from heapq import heappush, heappop, heapify
import itertools
import math, fractions
import sys, copy
def L(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline().rstrip())
def SL(): return list(sys.stdin.readline().rstrip())
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()]
def LS(): return [list(x) for x in sys.stdin.readline().split()]
def IR(n): return [I() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def LIR1(n): return [LI1() for _ in range(n)]
def SR(n): return [SL() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
def LR(n): return [L() for _ in range(n)]
def perm(n, r): return math.factorial(n) // math.factorial(r)
def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r))
def make_list(n, *args, default=0): return [make_table(*args, default=default) for _ in range(n)] if len(args) > 0 else [default for _ in range(n)]
alphabets = "abcdefghijklmnopqrstuvwxyz"
ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
sys.setrecursionlimit(1000000)
dire = [[1, 0], [0, 1], [-1, 0], [0, -1]]
dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]]
MOD = 1000000007
INF = float("inf")
def main():
N, K = LI()
A = sorted(LI())
F = sorted(LI(), reverse=True)
left = -1
right = (10 ** 12) + 1
while right - left > 1:
tmp = 0
mid = (right + left) // 2
# print(left, mid, right, "-"*100)
for ai, fi in zip(A, F):
xi = mid // fi
tmp += max(0, ai - xi)
# print(ai, fi, xi, ai - xi)
if tmp <= K:
right = mid
else:
left = mid
print(right)
if __name__ == '__main__':
main()
|
N = int(input())
S,T = map(str,input().split())
slist = list(S)
tlist = list(T)
new = ''
for i in range(N):
new += slist[i]
new += tlist[i]
print(new)
| 0 | null | 138,606,369,551,302 | 290 | 255 |
dic=set()
n=int(input())
cmd=[list(input().split()) for i in range(n)]
for c, l in cmd:
if c=="insert":
dic.add(l)
if c=="find":
if l in dic:
print("yes")
else:
print("no")
|
# coding=utf-8
n = int(input())
dic = set()
for i in range(n):
cmd = input().split()
if cmd[0] == 'insert':
dic.add(cmd[1])
else:
if cmd[1] in dic:
print('yes')
else:
print('no')
| 1 | 75,504,360,710 | null | 23 | 23 |
n = input()
l = list( map(int, input().split()))
odd = [ c for c in l if (c % 2 == 0 ) and (( c % 3 != 0) and ( c % 5 !=0 ))]
if len( odd ) == 0:
print( "APPROVED" )
else:
print( "DENIED" )
|
s=input()
count=0
for i in range(0,len(list(s))-1):
if(s[i]!=s[i+1]):
count+=1
elif(s[i]==s[i+1]):
count+=0
if(count>1 or count==1):
print("Yes")
else:
print("No")
| 0 | null | 61,971,740,615,680 | 217 | 201 |
def main():
N,M=map(int,input().split())
if N%2!=0:
for i in range(1,M+1):
print(i,N-i+1)
else:
for i in range(1,(M+1)//2+1):
print(i,N-i+1)
for i in range((M+1)//2+1,M+1):
print(i,N-i)
if __name__=='__main__':
main()
|
if __name__ == '__main__':
nm = input()
nm = nm.split()
n = int(nm[0])
m = int(nm[1])
if n%2==1:
for i in range(1,m+1):
print(i,n+1-i)
if n%2==0:
t = n
f = 0
for i in range(1,m+1):
p = i-1+t-n
if p>=n-i-1 and f==0:
f = 1
n -= 1
print(i,n)
n -= 1
| 1 | 28,496,430,713,550 | null | 162 | 162 |
# https://atcoder.jp/contests/abc163/tasks/abc163_b
n, m = map(int, input().split())
a = list(map(int, input().split()))
day = sum(a)
if day <= n:
print(n-day)
else:
print('-1')
|
#from collections import deque,defaultdict
printn = lambda x: print(x,end='')
inn = lambda : int(input())
inl = lambda: list(map(int, input().split()))
inm = lambda: map(int, input().split())
ins = lambda : input().strip()
DBG = True # and False
BIG = 10**18
R = 10**9 + 7
#R = 998244353
def ddprint(x):
if DBG:
print(x)
l,r,d = inm()
sm = 0
for i in range(l,r+1):
if i%d==0:
sm += 1
print(sm)
| 0 | null | 19,829,195,285,310 | 168 | 104 |
# -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub
sys.setrecursionlimit(100000)
input = sys.stdin.readline
INF = 2**62-1
def read_int():
return int(input())
def read_int_n():
return list(map(int, input().split()))
def read_float():
return float(input())
def read_float_n():
return list(map(float, input().split()))
def read_str():
return input().strip()
def read_str_n():
return list(map(str, input().split()))
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.time()
ret = f(*args, **kwargs)
e = time.time()
error_print(e - s, 'sec')
return ret
return wrap
def f(n):
r = 2
ret = 1
for i in range(n, n-r, -1):
ret *= i
for i in range(1, r+1):
ret //= i
return ret * 2 + n
class Bisect:
def __init__(self, func):
self.__func = func
def bisect_left(self, x, lo, hi):
while lo < hi:
mid = (lo+hi)//2
if self.__func(mid) < x:
lo = mid+1
else:
hi = mid
return lo
def bisect_right(self, x, lo, hi):
while lo < hi:
mid = (lo+hi)//2
if x < self.__func(mid):
hi = mid
else:
lo = mid+1
return lo
@mt
def slv(N, M, A):
A.sort(reverse=True)
print(A)
b = Bisect(f)
i = b.bisect_left(M, 1, N)
if f(i) != M:
i -= 1
l = f(i)
ans = 0
for j in range(i):
ans += A[j] * 2
ans += A[j] * (i-1)
rem = M - l
print(i, l, rem)
j = 0
while rem != 0:
ans += A[j] + A[i]
rem -= 1
if rem == 0:
break
ans += A[j] + A[i]
rem -= 1
if rem == 0:
break
j += 1
return ans
import numpy as np
@mt
def slv2(N, M, A):
C = Counter(A)
L = 1 << (max(A).bit_length() + 1)
B = [C[i] for i in range(L)]
D = np.fft.rfft(B)
D *= D
E = list(map(int, np.round(np.fft.irfft(D))))
ans = 0
c = 0
i = L - 1
while c != M:
n = E[i]
if c + n > M:
n = M-c
c += n
ans += i * n
i -= 1
return ans
def main():
N, M = read_int_n()
A = read_int_n()
print(slv2(N, M,A))
# N = 10**5
# M = random.randint(1, N**2)
# A = [random.randint(1, 10**5) for _ in range(N)]
# print(slv(N, M, A))
if __name__ == '__main__':
main()
|
N,K = map(int,input().split())
a = list(map(int,input().split()))
for i in range(1,N-K+1):
if a[K+i-1]>a[i-1]:
print("Yes")
else:
print("No")
| 0 | null | 57,341,316,030,180 | 252 | 102 |
import math
N, M = map(int, input().split())
if N%2 == 1:
a = 1
b = N
for i in range(M):
print(a,b)
a += 1
b -= 1
else:
m = N//2 - 1
a = N//4
b = a + 1
c = N//2 + N//4
d = c + 2
for i in range(M):
if i%2 == 0:
print(a,b)
a -= 1
b += 1
else:
print(c,d)
c -= 1
d += 1
|
n,m=map(int,input().split())
oddflag=True
for i in range(1,m+1):
mid=(1+n)//2
if oddflag:
oddflag = False
print(i//2 + 1 , n - i//2)
else:
oddflag = True
print(mid + i//2, mid - i//2)
| 1 | 28,903,797,768,508 | null | 162 | 162 |
S = input()
l = len(S)
x = [0]*(l+1)
y = [0]*(l+1)
for i in range(l):
if S[i] == "<":
x[i+1] = x[i]+1
for i in range(l):
if S[l-i-1] == ">":
y[l-i-1] = y[l-i]+1
res = 0
for a, b in zip(x, y):
res += max(a, b)
print(res)
|
def main():
S = input()
N = len(S)
ret = [0] * (N + 1)
for i, c in enumerate(S, start=1):
if c == '<':
ret[i] = max(
ret[i],
ret[i - 1] + 1
)
for i, c in enumerate(reversed(S), start=1):
i = N - i
if c == '>':
ret[i] = max(
ret[i],
ret[i + 1] + 1
)
print(sum(ret))
if __name__ == '__main__':
main()
| 1 | 156,772,847,834,690 | null | 285 | 285 |
x,y=map(int,input().split())
k=[1,2,3]
l=[0,300000,200000,100000]
p=0
if x in k:
p+=l[x]
if y in k:
p+=l[y]
if x==1 and y==1:
p+=400000
print(p)
|
S = list(input())
if len(S) < 4:
print(int(S[0]) * int(S[-1]))
else:
print(-1)
| 0 | null | 149,772,744,221,672 | 275 | 286 |
def main2():
K = int(input())
rem = set()
n = ans = 0
while True:
n = n * 10 + 7
ans += 1
if n % K == 0:
print(ans)
break
else:
n = n % K
if n in rem:
print(-1)
break
else:
rem.add(n)
if __name__ == "__main__":
main2()
|
a = int(input())
print(2*(22/7)*a)
| 0 | null | 18,664,127,681,358 | 97 | 167 |
N = int(input())
A = list(map(int, input().split()))
# ex. 24 11 8 3 16
A.sort()
# ex. 3 8 11 16 24
cnt = 0
# Aの最大値が24なら25個用意する感じ
# indexと考える値を一致させて分かりやすくしている
# Trueで初期化
# 最後のインデックスはA[-1]
dp = [True] * (A[-1] + 1)
# エラトステネスの篩っぽいやつ
for i in range(N):
if dp[A[i]] == True:
# dp[A[i]], dp[2*A[i]], dp[3*A[i]],...をFalseにする
for j in range(A[i], A[-1] + 1, A[i]):
dp[j] = False
if i < N - 1:
# 次も同じ数字が存在するなら数えない、なぜならお互いに割れてしまって題意を満たさないから
# 次以降に出てくる同じ数字は既にFalseになっているのでもう走査する事はない
if A[i] != A[i + 1]:
cnt += 1
# i=N-1の時は次がないので無条件でcntを増やす
# elseの方が良さそうだが明示的にするためにelifを使った
elif i == N - 1:
cnt += 1
print(cnt)
|
def mondai(W, H, x, y, r):
if (x - r < 0 or
x + r > W or
y - r < 0 or
y + r > H):
print('No')
else:
print('Yes')
W, H, x, y, r = [int(x) for x in input().split()]
mondai(W, H, x, y, r)
| 0 | null | 7,439,320,742,590 | 129 | 41 |
n=int(input())
a=list(map(int,input().split()))
p=[]
m=[]
for i in range(n):
p.append(i+a[i])
m.append(i-a[i])
x=[0]*(2*n)
y=[0]*(2*n)
ans=0
for i in range(n):
if 0<=p[i]<=(2*n)-1:
x[p[i]]+=1
if 0<=m[i]<=(2*n)-1:
y[m[i]]+=1
for i in range(n):
ans+=x[i]*y[i]
print(ans)
|
from collections import defaultdict
n=int(input())
a=list(map(int,input().split()))
d=defaultdict(int)
for i in range(n):
d[i-a[i]]+=1
ans=0
for i in range(n):
ans+=d[i+a[i]]
print(ans)
| 1 | 25,970,673,841,642 | null | 157 | 157 |
N = int(input())
q, r = divmod(N, 2)
print((q + r) / N)
|
n = int(input())
if n%2 == 0:
print(1/2)
else:
n2 = (n//2) + 1
print(n2/n)
| 1 | 177,487,314,796,658 | null | 297 | 297 |
from math import cos, radians, sin, sqrt
def g(a, b, c):
c_rad = radians(c)
yield a * b * sin(c_rad) / 2
yield a + b + sqrt(a ** 2 + b ** 2 - 2 * a * b * cos(c_rad))
yield b * sin(c_rad)
a, b, c = list(map(int, input().split()))
for i in g(a, b, c):
print("{:.8f}".format(i))
|
#!/usr/bin/env python3
import math
import sys
def calculate_area(side_a, side_b, angle_c):
return (side_a*side_b*math.sin(math.radians(angle_c))) / 2
def calculate_perimeter(side_a, side_b, angle_c):
side_c = math.sqrt(side_a**2 + side_b**2
- 2*side_a*side_b*math.cos(math.radians(angle_c)))
return side_a + side_b + side_c
def calculate_height_from_side_a(side_a, area):
return (area*2)/side_a
def main():
nums = [float(num) for num in sys.stdin.readline().split()]
area = calculate_area(nums[0], nums[1], nums[2])
perimeter = calculate_perimeter(nums[0], nums[1], nums[2])
height_from_side_a = calculate_height_from_side_a(nums[0], area)
print(area)
print(perimeter)
print(height_from_side_a)
if __name__ == '__main__':
main()
| 1 | 174,824,820,352 | null | 30 | 30 |
x, y = map(int, input().split())
if x > y:
x, y = y, x
while x:
x, y = y % x, x
print(y)
|
S = input()
if (S[2] == S[3]) and (S[4] == S[5]):
print('Yes')
else:
print('No')
| 0 | null | 21,190,705,311,622 | 11 | 184 |
x = int(input())
ans = 0
ans += (x // 500) * 1000
ans += ((x % 500) // 5) * 5
print(ans)
|
#!/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(X: int):
return X//500*1000 + X % 500//5*5
def main():
sys.setrecursionlimit(10 ** 6)
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
X = int(next(tokens)) # type: int
print(f'{solve(X)}')
if __name__ == '__main__':
main()
| 1 | 42,886,515,370,748 | null | 185 | 185 |
string = input()
num = int(input())
o = 0
for _ in range(num):
source = input().split(' ')
if source[0] == 'print':
print(string[int(source[1]):int(source[2]) + 1])
elif source[0] == 'replace':
string = string[:int(source[1])] + source[3] + string[int(source[2]) + 1:]
else:
string = string[:int(source[1])] + string[int(source[1]):int(source[2]) + 1 ][::-1] + string[int(source[2]) + 1:]
|
def main():
N,M=map(int,input().split())
S=input()
c,l=N,[]
while c>0:
for i in range(M,0,-1):
if i<=c and S[c-i]=='0':
l+=[i]
c-=i
break
else:
l=[-1]
break
print(*l[::-1])
main()
| 0 | null | 70,484,172,308,372 | 68 | 274 |
h,w=map(int,input().split())
if h==1 or w==1:
print(1)
exit()
print(((h+1)//2)*((w+1)//2)+(h//2)*(w//2))
|
h, w = [int(i) for i in input().split()]
if h == 1 or w == 1:
print(1)
exit(0)
s = h * w
if s % 2 == 0:
print(s // 2)
exit(0)
print(s // 2 + 1)
| 1 | 50,609,446,124,708 | null | 196 | 196 |
W,H,x,y,r = map(int,input().split())
if x >= r and x <= W-r and y >= r and y <= H-r:
print('Yes')
else:
print('No')
|
n = int(input())
a = list(map(int,input().split()))
if 1 not in a:
print(-1)
exit()
x = 1
cnt = 0
for i in range(n):
if a[i] == x:
x += 1
else:
cnt += 1
print(cnt)
| 0 | null | 57,860,679,457,130 | 41 | 257 |
print(int(input()[:2] != input()[:2]))
|
a,b=map(int,input().split())
c,d=map(int,input().split())
print(c-a)
| 1 | 123,827,038,656,832 | null | 264 | 264 |
import sys
while(1):
H,W = map(int, raw_input().split())
if H==0 and W==0:
break
for i in range(H):
for j in range(W):
sys.stdout.write("#")
print ""
print ""
|
while True:
H,W=map(int,raw_input().split())
if H==W==0:
break
elif H!=0 or W!=0:
print (('#'*W +'\n')*H)
| 1 | 772,798,636,708 | null | 49 | 49 |
class Building(object):
def __init__(self):
self.floor = []
self.floor.extend([[0] * 10])
self.floor.extend([[0] * 10])
self.floor.extend([[0] * 10])
def change_resident(self, f, r, v):
self.floor[f][r] += v
def print_status(self):
for f in self.floor:
print(' {0}'.format(' '.join(map(str, f))))
if __name__ == '__main__':
# ?????????4?£??????????
buildings = []
for i in range(4):
buildings.append(Building())
# ??????????????\???
data_num = int(input())
data = []
for i in range(data_num):
data.append([int(x) for x in input().split(' ')])
# ??\?±?????????´??°
for d in data:
b = d[0]
f = d[1]
r = d[2]
v = d[3]
buildings[b-1].change_resident(f-1, r-1, v)
# ?????????????????¨???
buildings[0].print_status()
print('#' * 20)
buildings[1].print_status()
print('#' * 20)
buildings[2].print_status()
print('#' * 20)
buildings[3].print_status()
|
#!/usr/bin/env python3
import sys
input = iter(sys.stdin.read().splitlines()).__next__
sys.setrecursionlimit(10000)
R = int(input())
res = -1
if R <= 599:
res = 8
elif R <= 799:
res = 7
elif R <= 999:
res = 6
elif R <= 1199:
res = 5
elif R <= 1399:
res = 4
elif R <= 1599:
res = 3
elif R <= 1799:
res = 2
elif R <= 1999:
res = 1
print(res)
| 0 | null | 3,878,381,422,850 | 55 | 100 |
#!/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(N: int, X: "List[int]"):
return min([sum([(x-i)**2 for x in X]) for i in range(1, 100+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()
N = int(next(tokens)) # type: int
X = [int(next(tokens)) for _ in range(N)] # type: "List[int]"
print(f'{solve(N, X)}')
if __name__ == '__main__':
main()
|
n = input()
s = list(map(int,input().split()))
m = 10000000
for p in range(0,101):
t = 0
for x in s:
t+=(x-p)**2
m = min(t,m)
print(m)
| 1 | 65,330,961,151,722 | null | 213 | 213 |
n=int(input())
lipp = []
lipm = []
limm = []
allcnt = 0
for _ in range(n):
s = input()
cnt = 0
mi = 0
for x in s:
cnt += 1 if x == '(' else -1
mi = min(mi,cnt)
if cnt >= 0:
lipm.append([mi,cnt])
else:
limm.append([mi - cnt, -cnt])
allcnt += cnt
if allcnt != 0:
print('No')
exit()
lipm.sort(reverse = True)
limm.sort(reverse = True)
def solve(l):
now = 0
for mi, cnt in l:
if mi + now < 0:
print('No')
exit()
now += cnt
solve(lipm)
solve(limm)
print("Yes")
|
n = int(input())
a = []
b = []
for i in range(n):
s = input()
x = 0
y = 0
for c in s:
if c == '(':
y += 1
else:
if y >= 1:
y -= 1
else:
x += 1
if x < y: a.append([x, abs(x-y)])
else: b.append([y, abs(x-y)])
def calc(a):
ret = 0
for x, y in sorted(a):
if ret < x: return -1
ret += y
return ret
res1 = calc(a)
res2 = calc(b)
print("Yes" if res1 >= 0 and res1 == res2 else "No")
| 1 | 23,776,580,635,172 | null | 152 | 152 |
import math
a = int(input())
b = a /1000
B = math.ceil(b)
print(B * 1000 -a)
|
money = int(input())
while money > 1000 :
money -= 1000
print(1000 - money)
| 1 | 8,348,895,163,712 | null | 108 | 108 |
class Factorial:
def __init__(self, n, mod=10**9+7):
self.fac = [0] * (n+1)
self.ifac = [0] * (n+1)
self.fac[0] = 1
self.ifac[0] = 1
self.mod = mod
modmod = self.mod - 2
for i in range(n):
self.fac[i+1] = self.fac[i] * (i+1) % self.mod
self.ifac[i+1] = self.ifac[i] * pow(i+1, modmod, self.mod) % self.mod
def comb(self, n, r):
if n == 0 and r == 0:
return 1
if n < r or n < 0:
return 0
tmp = self.ifac[n-r] * self.ifac[r] % self.mod
return tmp * self.fac[n] % self.mod
def perm(self, n, r):
if n == 0 and r == 0:
return 1
if n < r or n < 0:
return 0
return (self.fac[n] * self.ifac[n-r]) % self.mod
def resolve():
n, k = map(int, input().split())
a = sorted(map(int, input().split()))
mod = 10 ** 9 + 7
fact = Factorial(n + 1)
mn, mx = 0, 0
for i in range(k, n+1):
mx = (mx + a[i-1] * fact.comb(i-1, k-1)) % mod
mn = (mn + a[n-i] * fact.comb(i-1, k-1)) % mod
ans = mx - mn
if ans < 0:
ans += mod
print(ans)
if __name__ == "__main__":
resolve()
|
lst = [input() for i in range(2)]
n = int(lst[0])
s = lst[1]
t = ''
for i in range(n//2):
t += s[i]
if n % 2 == 1:
print('No')
elif t + t == s:
print('Yes')
else:
print('No')
| 0 | null | 120,883,226,722,720 | 242 | 279 |
s=input()
count=s.count("B")
if count==3 or count==0:
print("No")
else:
print("Yes")
|
import sys
input = sys.stdin.readline
N = int(input())
A = list(map(int, input().split()))
ans = [0] * N
for a_i in A:
ans[a_i-1] += 1
for a in ans:
print(a)
| 0 | null | 43,501,628,464,980 | 201 | 169 |
n=int(input())
if n==0 or n==1:
print(0)
else:
print((10**n - (2*(9**n)-8**n))%(10**9+7))
|
# -*- coding: utf-8 -*-
from sys import stdin
input = stdin.readline
MOD = 10**9+7
def main():
n = int(input().strip())
buf = 9**n
ans = 10**n - buf - buf + 8**n
print(ans%MOD)
if __name__ == "__main__":
main()
| 1 | 3,155,985,004,868 | null | 78 | 78 |
x = int(input())
v500 = int(x // 500)
v5 = int((x % 500 ) //5)
print(v500 * 1000 + v5 * 5)
|
import sys
def getTheNumberOfCoin(n, m, c):
T = {}
for j in range(0, n+1):
T[j] = 100000
T[0] = 0
for i in range(0, m):
for j in range(c[i], n+1):
T[j] = min(T[j], T[j-c[i]]+1)
return T[n]
n, m = (int(x) for x in sys.stdin.readline().split())
c = sorted([int(x) for x in sys.stdin.readline().split()])
print(getTheNumberOfCoin(n, m, c))
| 0 | null | 21,526,012,382,058 | 185 | 28 |
N = int(input())
if N % 1000 != 0:
print(1000 - N % 1000)
elif N % 1000 == 0:
print(0)
|
def main(N):
surplus = N%1000
if surplus == 0:
return 0
else:
ans = 1000 - surplus
return ans
if __name__ == '__main__':
N = int(input())
ans = main(N)
print(ans)
| 1 | 8,468,465,732,192 | null | 108 | 108 |
while True:
[H,W]=[int(x) for x in input().split()]
if [H,W]==[0,0]:
break
unit="#."
for i in range(0,H):
print(unit*(W//2)+unit[0]*(W%2))
unit=unit[1]+unit[0]
print("")
|
from itertools import cycle
while True:
(H, W) = [int(i) for i in input().split(' ')]
if (H == W == 0):
break
it1 = cycle(['#', '.'])
it2 = cycle(['.', '#'])
str1 = ''
str2 = ''
for i in range(W):
str1 += next(it1)
str2 += next(it2)
for i in range(H):
if ((i % 2) == 0):
print(str1)
else:
print(str2)
print()
| 1 | 876,055,618,842 | null | 51 | 51 |
n = int(input())
a = list(map(int, input().split()))
mod = 10 ** 9 + 7
MAX = 60
acc = [0] * MAX
ans = [0] * MAX
num = a[0]
for i in range(MAX):
if num & 1:
acc[i] = 1
num >>= 1
for i, e in enumerate(a[1:], 1):
for j in range(MAX):
if e & 1:
ans[j] += i - acc[j]
acc[j] += 1
else:
ans[j] += acc[j]
e >>= 1
ans_num = 0
for i, e in enumerate(ans):
ans_num += pow(2, i, mod) * e
ans_num %= mod
print(ans_num)
|
from collections import Counter
n = int(input())
c = list(input())
count = Counter(c)
ans = float('inf')
w = 0
r = 0
if count.get('R'):
r = count['R']
ans = max(w, r)
for i in range(n):
if c[i]=='W':
w += 1
else:
r -= 1
ans =min(max(w,r), ans)
print(ans)
| 0 | null | 64,378,583,810,638 | 263 | 98 |
N, P = map(int, input().split())
S = input()
now = 0
hyou = [0] * P
hyou[0] = 1
cnt = 1
ans = 0
if P == 2 or P == 5:
for i, t in enumerate(S[::-1]):
temp = int(t)
if temp % P == 0:
ans += N - i
print(ans)
exit()
for i, t in enumerate(S[::-1]):
now = (now + int(t) * pow(10, i, P)) % P
ans += hyou[now]
hyou[now] += 1
print(ans)
|
s = input()[::-1]
MOD = 2019
cum = 0
cnt = [0] * 2019
cnt[0] = 1
d = 1
for c in s:
cum += int(c) * d
cum %= MOD
cnt[cum] += 1
d *= 10
d %= MOD
ans = 0
for v in cnt:
ans += v * (v - 1) // 2
print(ans)
| 0 | null | 44,458,972,826,632 | 205 | 166 |
import numpy as np
N = int(input())
A = []
B = []
for i in range(N):
a, b = [int(x) for x in input().split()]
A.append(a)
B.append(b)
C = np.array(A)
D = np.array(B)
m_inf = np.median(C)
m_sup = np.median(D)
if N % 2 == 0:
ans = 2 * m_sup - 2 * m_inf + 1
else:
ans = m_sup - m_inf + 1
print(int(ans))
|
N = int(input())
A = [0]*N
B = [0]*N
for i in range(N):
A[i], B[i] = map(int, input().split())
A = sorted(A)
B = sorted(B)
if N % 2 == 1:
print(B[(N+1)//2-1] - A[(N+1)//2-1] + 1)
else:
b = B[N//2-1] + B[N//2]
a = A[N//2-1] + A[N//2]
print(b-a+1)
| 1 | 17,298,704,012,668 | null | 137 | 137 |
from sys import stdin
input = stdin.readline
def solve():
n = int(input())
r = n % 1000
res = 0 if r == 0 else 1000 - r
print(res)
if __name__ == '__main__':
solve()
|
import sys
n = int(input())
if n % 1000 == 0:
print(0)
sys.exit()
while n > 1000:
n -= 1000
print(1000 - n)
| 1 | 8,521,966,101,768 | null | 108 | 108 |
number = int(input())
words = {}
answer = []
maxnum = 0
for i in range(number):
word = input()
if word in words:
words[word] += 1
else:
words[word] = 1
if maxnum < words[word]:
maxnum = words[word]
answer.clear()
answer.append(word)
elif maxnum == words[word]:
answer.append(word)
answer.sort()
for j in range(len(answer)):
print(answer[j])
|
N = int(input())
data = [list(map(int,input().split())) for i in range(N-1)]
G = {}
for i in range(1,N+1):
G[i] = []
for i in range(N-1):
G[data[i][0]].append((data[i][1],i+1))
G[data[i][1]].append((data[i][0],i+1))
M = max(len(G[i]) for i in range(1,N+1))
print(M)
from collections import deque
E = [0]+[-1]*(N-1) #辺
E[1] = 1
q = deque([[data[0][0],1],[data[0][1],1]])
while q:
n,i = q.pop()
c = 1
for dn,di in G[n]:
if E[di] != -1:
continue
else:
if c == E[i]:
E[di] = M
c += 1
q.append([dn,di])
else:
E[di] = c
c += 1
q.append([dn,di])
for i in range(1,N):
print(E[i])
| 0 | null | 103,020,249,779,572 | 218 | 272 |
N = int(input())
A = list(map(int, input().split()))
B = [0]*60
mod = 10 ** 9 + 7
for x in A:
temp = bin(x)[2:]
for i in range(len(temp)):
if temp[-1-i] == "1":
B[i] += 1
ans = 0
for i in range(60):
ans += (N-B[i])*B[i]*pow(2, i, mod)
ans %= mod
print(ans)
|
D = list(input())
ans = 0
cnt = 0
for i in D:
if i == 'R':
cnt += 1
else:
cnt = 0
if ans < cnt:
ans = cnt
print(ans)
| 0 | null | 64,030,038,504,046 | 263 | 90 |
N,K = map(int,input().split())
count = 0
for i in range(K,N+2):
min_1 = i*(i-1)//2
max_1 = (2*N-i+1)*i//2
num = max_1-min_1+1
count += num
print(count%(10**9+7))
|
x = int(input())
ans = 0
flag = False
for a in range((x//100)+1):
for b in range((x//101)+1):
for c in range((x//102)+1):
for d in range((x//103)+1):
for e in range((x//104)+1):
for f in range((x//105)+1):
if (100*a) + (101*b) + (102*c) + (103*d) + (104*e) + (105*f)== x:
ans += 1
flag = True
break
if flag:
break
if flag:
break
if flag:
break
if flag:
break
if flag:
break
if ans == 0:
print(0)
else:
print(1)
| 0 | null | 80,390,287,792,960 | 170 | 266 |
def solve(n):
l = []
for i in range(int(n**(1/2))):
if n % (i+1) == 0:
a = i + 1
b = n // a
l.append(a+b-2)
return min(l)
print(solve(int(input())))
|
#! python3
# coding:utf-8
s = list(input())
nickname = s[0]+s[1]+s[2]
print(nickname)
| 0 | null | 88,393,191,868,010 | 288 | 130 |
import sys
read = sys.stdin.read
readlines = sys.stdin.readlines
import numpy as np
def main():
n, k = map(int, input().split())
p = np.array(read().split(), np.int32)
p += 1
pcum = np.zeros(n + 1, np.int32)
pcum[1:] = p.cumsum()
sum_k = pcum[k:] - pcum[:-k]
print(sum_k.max()/2)
if __name__ == '__main__':
main()
|
from itertools import accumulate
N, K = map(int, input().split())
P = list(map(int, input().split()))
Q = list(map(lambda x: (x+1)/2, P))
Q_cum = list(accumulate([0] + Q))
res = 0
for i in range(N-K+1):
temp = Q_cum[i+K]- Q_cum[i]
res = max(res, temp)
print(res)
| 1 | 74,586,385,964,480 | null | 223 | 223 |
#! python3
# greatest_common_divisor.py
def greatest_common_divisor(x, y):
r = None
if x >= y:
r = x%y
if r == 0: return y
else:
r = y%x
if r == 0: return x
return greatest_common_divisor(y, r)
x, y = [int(n) for n in input().split(' ')]
print(greatest_common_divisor(x, y))
|
from collections import deque
def solver(K):
q = deque([i for i in range(1, 10)])
if K <= 9:
ans = q[K - 1]
else:
cnt = 9
for i in range(1, K):
c = q.popleft()
if c % 10 != 0:
q.append(c * 10 + (c % 10) - 1)
cnt += 1
if cnt >= K:
break
q.append(c * 10 + (c % 10))
cnt += 1
if cnt >= K:
break
if c % 10 != 9:
q.append(c * 10 + (c % 10) + 1)
cnt += 1
if cnt >= K:
break
ans = q[-1]
return ans
def run():
K = int(input())
ans = solver(K)
print(ans)
run()
| 0 | null | 19,857,941,810,208 | 11 | 181 |
def main():
import sys
input = sys.stdin.readline
inf = 1 << 60
N, M, L = map(int, input().split())
dist = [[inf] * N for _ in range(N)]
for _ in range(M):
A, B, C = map(int, input().split())
A -= 1
B -= 1
dist[A][B] = dist[B][A] = C
for k in range(N):
for i in range(N):
for j in range(N):
dist[i][j] = min(
dist[i][j],
dist[i][k] + dist[k][j]
)
g = [[inf] * N for _ in range(N)] # 到達に必要な補充回数
for A in range(N):
for B in range(N):
if dist[A][B] <= L:
g[A][B] = 1
for k in range(N):
for i in range(N):
for j in range(N):
g[i][j] = min(
g[i][j],
g[i][k] + g[k][j]
)
Q = int(input())
for _ in range(Q):
s, t = (int(x) - 1 for x in input().split())
d = g[s][t]
if d == inf:
print(-1)
else:
print(d - 1)
if __name__ == '__main__':
main()
|
import sys
import numpy as np
from scipy.sparse.csgraph import floyd_warshall
from scipy.sparse import csr_matrix
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
n, m, l = map(int, readline().split())
rest = np.array(read().split(), np.int64)
abc = rest[: m + m + m]
a = abc[::3]
b = abc[1::3]
c = abc[2::3]
st = rest[m + m + m + 1 :]
s = st[::2]
t = st[1::2]
dist_graph = csr_matrix((c, (a, b)), (n + 1, n + 1))
dist_path = floyd_warshall(dist_graph, directed=False)
cost_graph = np.full((n + 1, n + 1), np.inf)
np.fill_diagonal(cost_graph, 0)
cost_graph[dist_path <= l] = 1
cost_path = floyd_warshall(cost_graph, directed=False)
cost_path[cost_path == np.inf] = 0
cost_path = (cost_path).astype(int)
x = cost_path[s, t] - 1
print("\n".join(x.astype(str)))
| 1 | 173,441,969,032,420 | null | 295 | 295 |
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,copy,functools
import time,random,resource
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(): return [list(map(int, l.split())) for l in sys.stdin.readlines()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
def pe(s): return print(str(s), file=sys.stderr)
def JA(a, sep): return sep.join(map(str, a))
def JAA(a, s, t): return s.join(t.join(map(str, b)) for b in a)
def main():
l,r,d = LI()
return r // d - (l-1) // d
print(main())
|
import math
R = int(input())
p = math.pi
print(2 * p * R)
| 0 | null | 19,500,187,674,770 | 104 | 167 |
MOD = 998244353
def main():
# もらうdp + 累積和
N, K = (int(i) for i in input().split())
LR = [[int(i) for i in input().split()] for j in range(K)]
dp = [0] * (N+2)
dpsum = [0] * (N+1)
dp[1] = 1
dpsum[1] = 1
for i in range(2, N+1):
for le, ri in LR:
L = max(0, i - ri - 1)
R = i - le
if R < 1:
continue
dp[i] += dpsum[R] - dpsum[L]
dp[i] %= MOD
dpsum[i] += dpsum[i-1] + dp[i]
dpsum[i] %= MOD
print(dp[N])
# print(dpsum)
if __name__ == '__main__':
main()
|
def main():
n, k = map(int, input().split())
lr = [list(map(int, input().split())) for _ in range(k)]
dp = [0] * (n + 1)
dp[1] = 1
dpsum = [0] * (n + 1)
dpsum[1] = 1
mod = 998244353
for i in range(2, n + 1):
for j in range(k):
li = max(i - lr[j][1], 1)
ri = i - lr[j][0]
if ri < 0:
continue
dp[i] = (dp[i] + dpsum[ri] - dpsum[li - 1]) % mod
dpsum[i] = dpsum[i - 1] + dp[i]
print(dp[-1] % mod)
if __name__ == "__main__":
main()
| 1 | 2,754,899,369,530 | null | 74 | 74 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.