code1
stringlengths 16
427k
| code2
stringlengths 16
427k
| similar
int64 0
1
| pair_id
int64 6.82M
181,637B
⌀ | question_pair_id
float64 101M
180,471B
⌀ | code1_group
int64 2
299
| code2_group
int64 2
299
|
|---|---|---|---|---|---|---|
list = [int(s) for s in input().split()]
list.sort()
print(" ".join(map(str,list))) | N, K = list(map(int, input().split()))
H = list(map(int, input().split()))
H.sort()
remain = max(0, N-K)
H = H[:remain]
print(sum(H))
| 0 | null | 39,797,073,471,392 | 40 | 227 |
def check(s, p):
for i in range(len(s)):
count = 0
for j in range(len(p)):
if s[(i+j) % len(s)] != p[j]:
break
count += 1
if count == len(p):
return True
return False
s = raw_input()
p = raw_input()
flag = check(s, p)
if flag:
print("Yes")
else:
print("No") | str1, str2 = input()*2, input()
if str2 in str1:
print("Yes")
else:
print("No")
| 1 | 1,747,189,050,240 | null | 64 | 64 |
import sys
input = sys.stdin.readline
P = 2019
def main():
S = input().rstrip()
N = len(S)
count = [0] * P
count[0] += 1
T = 0
for i in range(N):
T = (T + int(S[(N - 1) - i]) * pow(10, i, mod=P)) % P
count[T] += 1
ans = 0
for k in count:
ans = (ans + k * (k - 1) // 2)
print(ans)
if __name__ == "__main__":
main()
| N = int(input())
a = N // 2
b = N % 2
print(a + b)
| 0 | null | 45,052,256,348,272 | 166 | 206 |
N = input()
ans = "Yes" if (N[2] == N[3]) and (N[4] == N[5]) else "No"
print(ans) | """
最小公倍数LCMを求めて、LCMを各Aで除した商を合計すればよい
"""
from math import gcd
def lcm(a,b):
return a*b//gcd(a,b)
def main():
mod = 10**9 +7
N = int(input())
A = list(map(int,input().split()))
l = A[0]
for i in range(1,N):
l = lcm(l,A[i])
ans = 0
for a in A:
ans += l//a
print(ans%mod)
main() | 0 | null | 65,238,504,610,140 | 184 | 235 |
from itertools import product
H, W, K = map(int, input().split())
grid = ""
for _ in range(H):
grid += input()
ans = 10000
for Hcut in product((0, 1), repeat = H-1):
Gr_num = sum(Hcut) + 1
old = [0]*Gr_num
cnt = 0
for i in range(W):
#縦一列のchocoを見る
choco = grid[i::W]
new = [0]*Gr_num
gr = 0
for j in range(H):
new[gr] += int(choco[j])
if j < H-1:
if Hcut[j] == 1:
gr += 1
#そもそも一列でオーバーしてたら詰み。
if max(new) > K:
cnt += 10000
break
#新しい一列を追加しても大丈夫か確認
check = [old[gr] + new[gr] for gr in range(Gr_num)]
if max(check) > K:
old = new[:]
cnt += 1
else:
old = check[:]
ans = min(ans, cnt+sum(Hcut))
print(ans) | from operator import itemgetter
N,M = map(int,input().split())
PS = [list(map(str,input().split())) for i in range(M)]
for i in range(M) :
PS[i][0] = int(PS[i][0])
submits = [["null"] for i in range(N)]
for i in range(M) :
submits[PS[i][0]-1][0] = PS[i][0]-1
submits[PS[i][0]-1].append(PS[i][1])
ac = 0
pena = 0
for i in range(len(submits)) :
if submits[i][0] == "null" :
continue
flag = False
wabuf1 = 0
for j in range(1,len(submits[i])) :
if submits[i][j] == "AC" :
ac += 1
flag = True
break
else :
wabuf1 += 1
if flag == True :
pena += wabuf1
print(ac,pena) | 0 | null | 70,764,223,201,152 | 193 | 240 |
import sys
input = sys.stdin.readline
n, k = map(int, input().split())
*a, = map(int, input().split())
s = [0]*(n+1)
for i in range(len(a)):
s[i+1] = s[i] + a[i]
for i in range(len(s)):
s[i] = (s[i] - i)%k
from collections import defaultdict
cnt = defaultdict(int)
left = 0
right = k-1
if right > n:
right = n
for i in range(right+1):
cnt[s[i]] += 1
ans = 0
while left < right:
ans += cnt[s[left]]-1
if right == n:
cnt[s[left]] -= 1
left += 1
else:
cnt[s[left]] -= 1
left += 1
right += 1
cnt[s[right]] += 1
print(ans)
| import math
r=input()
p=math.pi
print "{0:.6f} {1:.6f}".format(r*r*p,2*r*p) | 0 | null | 69,074,155,504,640 | 273 | 46 |
from bisect import bisect_left, bisect_right
n,m = map(int, input().split())
al = list(map(int, input().split()))
al.sort()
ok, ng = 0, 10**18+1
while abs(ok-ng) > 1:
mid = (ok+ng)//2
ok_flag = True
cnt = 0
# print('-----')
# print(ok,ng,mid)
for i,a in enumerate(al):
rem = mid-a
cnt_a = n-bisect_left(al,rem)
# cnt_a = min(n-i-1, cnt_a)
cnt += cnt_a
# print(i,a,cnt_a)
if cnt >= m:
ok = mid
else:
ng = mid
min_sum = ok
cum_sums = [0]
csum = 0
for a in al:
csum += a
cum_sums.append(csum)
# print(min_sum)
ans = 0
cnt = 0
for i,a in enumerate(al):
rem = min_sum - a
ind = bisect_left(al, rem)
# ind = ind if 0 <= ind < n else None
# ind = max(i+1,ind)
csum = cum_sums[n] - cum_sums[ind]
# print(i,a,csum)
ans += csum
ans += a*(n-ind)
cnt += (n-ind)
ans -= (cnt-m)*min_sum
print(ans)
# print(min_sum) | n=int(input())
*a,=map(int,input().split())
cnt=[0,0,0]
ans=1
mod=10**9+7
for aa in a:
tmp=0
for c in cnt:
if aa==c:
tmp+=1
if tmp>0:
for i in range(3):
if cnt[i]==aa:
cnt[i]+=1
break
ans*=tmp
ans%=mod
print(ans) | 0 | null | 119,141,372,924,886 | 252 | 268 |
N = int(input())
A = list(map(int,input().split()))
B = [0]*N
for i in range(N):
B[A[i]-1] = i+1
print(" ".join(map(str,B))) | import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")
n = int(input())
a = list(map(int, input().split()))
aa = [(num,i) for i,num in enumerate(a)]
aa.sort()
write(" ".join(map(str, [item[1]+1 for item in aa]))) | 1 | 181,061,898,022,720 | null | 299 | 299 |
a, b = map(int, input().split())
if a <= 2 * b:
x = 0
else:
x = a - 2 * b
print(int(x)) | s=input()
for _ in range(int(input())):
a=input().split()
if a[0][0]=='p':print(s[int(a[1]):int(a[2])+1])
else:
t=a[3]if'p'==a[0][2]else s[int(a[1]):int(a[2])+1][::-1]
s=s[0:int(a[1])]+t+s[int(a[2])+1:] | 0 | null | 84,304,654,166,838 | 291 | 68 |
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, gcd
from itertools import accumulate, permutations, combinations, product, groupby, combinations_with_replacement
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7
lim = 2*(10**6) # 必要そうな階乗の限界を入れる
fact = [1] * (lim+1)
fact_inv = [1] * (lim+1)
for n in range(1, lim+1):
fact[n] = (fact[n-1] * n) % mod
fact_inv[lim] = pow(fact[lim], mod-2, mod)
for n in range(lim, 0, -1):
fact_inv[n-1] = (n * fact_inv[n]) % mod
def C(n, r):
return (((fact[n] * fact_inv[r]) % mod) * fact_inv[n-r]) % mod
K = INT()
S = input()
L = len(S)
ans = 0
for i in range(K+1):
ans += pow(26, K-i, mod)*pow(25, i, mod)*C(i+L-1, i)
ans %= mod
print(ans)
| import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import accumulate, permutations, combinations, product
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from fractions import gcd
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7
N, A, B = MAP()
if abs(A-B)%2 == 0:
print(abs(A-B)//2)
else:
A, B = min(A, B), max(A, B)
print(min((N-B)-(-(B-A)//2), A-1-(-(B-A)//2)))
| 0 | null | 61,302,037,500,600 | 124 | 253 |
a,b,c =raw_input().split()
a,b,c = map(int,(a,b,c))
ls = list((a,b,c))
ls.sort()
string_ans=''
for k in ls:
string=''
string = str(k)+" "
string_ans = string_ans + string
print string_ans.strip() | l=sorted(map(int,raw_input().split()))
print l[0], l[1], l[2] | 1 | 410,866,353,832 | null | 40 | 40 |
N,K = list(map(int,input().split()))
P = list(map(int,input().split()))
def bubblesort(l):
for index in range(len(l)-1, 0, -1):
for low in range(index):
if l[low] > l[low+1]:
tmp = l[low+1]
l[low+1] = l[low]
l[low] = tmp
return l
bubblesort(P)
sum = 0
for i in range(K):
sum = sum + P[i]
print(sum) | a,b=map(int,input().split())
s=list(map(int,input().split()))
ans=0
s=sorted(s)
for i in range(b):
ans+=s[i]
print(ans)
| 1 | 11,589,397,505,096 | null | 120 | 120 |
from collections import deque
def main():
n, m = map(int, input().split())
to = [[] for _ in range(n+1)]
for _ in range(m):
a, b = map(int, input().split())
to[a].append(b)
to[b].append(a)
q = deque([1])
ans = [None]*(n+1)
while q:
p = q.pop()
for child in to[p]:
if ans[child] is None:
ans[child] = p
q.appendleft(child)
print("Yes")
print("\n".join(list(map(str, ans[2:]))))
if __name__ == "__main__":
main() | from collections import deque
N,M = map(int, input().split())
E = [[] for _ in range(N)]
for _ in range(M):
a,b = map(int, input().split())
E[a-1].append(b-1)
E[b-1].append(a-1)
q = deque()
q.append(0)
ans = [0]*N
while q:
par = q.popleft()
for e in E[par]:
if ans[e] > 0:
continue
ans[e] = par+1
q.append(e)
print("Yes")
for i in range(1, N):
print(ans[i]) | 1 | 20,470,942,948,480 | null | 145 | 145 |
N=int(input())
S=list(input() for _ in range(N))
from collections import Counter
cnt=Counter(S)
max_cnt=cnt.most_common()[0][1]
ans=[]
for k, v in cnt.items():
if v!=max_cnt:
continue
ans.append(k)
print(*sorted(ans), sep="\n") | H, N = [int(v) for v in input().rstrip().split()]
A = [int(v) for v in input().rstrip().split()]
total = sum(A)
r = 'Yes' if H <= total else 'No'
print(r)
| 0 | null | 73,982,878,925,942 | 218 | 226 |
import math
a, b, h, m = [int(i) for i in input().split()]
theta = math.radians(h / 12 * 360 - m / 60 * 360 + m / 60 / 12 * 360)
print(math.sqrt(a**2 + b**2 - 2 * a * b * math.cos(theta))) |
#入力:N,M(int:整数)
def input2():
return map(int,input().split())
d,t,s=input2()
if d/s >t:
print("No")
else:
print("Yes") | 0 | null | 11,897,066,570,610 | 144 | 81 |
# 入力
InpList=[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=int(input())
result=0
# 処理
print(InpList[K-1]) | A, B, M = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
# 割引券を使用しない場合は各品の最低金額合計が解となる
ans = min(a) + min(b)
# 割引券を使用して安くなるケースがないか調べる
for _ in range(M):
x, y, c = map(int, input().split())
tmp = a[x-1] + b[y-1] - c
if tmp < ans:
ans = tmp
print(ans)
| 0 | null | 52,040,341,583,440 | 195 | 200 |
a, b, m = map(int, input().split())
list_a = list(map(int, input().split()))
list_b = list(map(int, input().split()))
total = min(list_a) + min(list_b)
for i in range(m):
x, y, c = map(int, input().split())
price = list_a[x - 1] + list_b[y - 1] - c
total = min(price, total)
print(total)
|
N = int(input())
ans = [0] * (N + 1)
for x in range(1, 100):
for y in range(1, 100):
for z in range(1, 100):
n = x**2 + y**2 + z**2 + x*y + y*z + z*x
if n <= N:
ans[n] += 1
print(*ans[1:], sep="\n")
| 0 | null | 31,039,000,634,110 | 200 | 106 |
import string
N = int(input())
S = input()
a = string.ascii_uppercase
# a = ABCDEFGHIJKLMNOPQRSTUVWXYZ
ans = ''
for s in S:
ans += a[(a.index(s) + N) % len(a)]
print(ans) | n = int(input())
s = input()
if n%2==0 and s[0:(n+1)//2] == s[(n+1)//2:]:
print('Yes')
else:
print('No') | 0 | null | 141,376,214,884,800 | 271 | 279 |
def check(p):
s = w[0]
track = 1
for i in range(1, n):
if s + w[i] <= p:
s += w[i]
else:
track += 1
if track > k: return False
s = w[i]
return True
n, k = [int(i) for i in input().split()]
w = []
for i in range(n):
w.append(int(input()))
L = max(w)
R = sum(w)
if check(L):
print(L)
else:
while L + 1 < R:
M = (L + R) // 2
if check(M):
R = M
else:
L = M
print(R) | from sys import stdin
N, K = [int(_) for _ in stdin.readline().rstrip().split()]
W = [int(stdin.readline().rstrip()) for _ in range(N)]
def check(P):
i = 0
for _ in range(K):
s = 0
while s+W[i] <= P:
s += W[i]
i += 1
if i == N:
return N
return i
def solver():
mid, l, u = 0, 0, 100000*10000
while u-l > 1:
mid = (l+u)//2
v = check(mid)
if v >= N:
u = mid
else:
l = mid
return u
print(solver())
| 1 | 85,897,427,212 | null | 24 | 24 |
N,M,K=map(int,input().split())
mod=998244353
fact=[1 for i in range(N+1)]
for i in range(1,N):
fact[i+1]=(fact[i]*(i+1))%mod
def nCk(n,k):
return fact[n]*pow(fact[n-k]*fact[k],mod-2,mod)
result=0
for k in range(K+1):
result+=nCk(N-1,k)*M*pow(M-1,N-k-1,mod)
result=int(result)%mod
print(result) | N,M,K=map(int,input().split())
P=998244353
class FactInv:
def __init__(self,N,P):
fact=[];ifact=[];fact=[1]*(N+1);ifact=[0]*(N+1)
for i in range(1,N):
fact[i+1]=(fact[i]*(i+1))%P
ifact[-1]=pow(fact[-1],P-2,P)
for i in range(N,0,-1):
ifact[i-1]=(ifact[i]*i)%P
self.fact=fact;self.ifact=ifact;self.P=P
def comb(self,n,k):
return (self.fact[n]*self.ifact[k]*self.ifact[n-k])%self.P
FI=FactInv(N+10,P)
ans=0
for k in range(0,K+1):
ans+=(M*FI.comb(N-1,k)*pow(M-1,N-1-k,P))%P
ans%=P
print(ans) | 1 | 23,216,877,912,840 | null | 151 | 151 |
def merge(A, left, mid, right):
L = A[left:mid] + [2147483648]
R = A[mid:right] + [2147483648]
i = 0
j = 0
for k in range(left, right):
if L[i] <= R[j]:
A[k] = L[i]
i += 1
else:
A[k] = R[j]
j += 1
global c
c += right - left
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)
c = 0
n = int(input())
A = list(map(int, input().split()))
mergeSort(A, 0, n)
print(" ".join(map(str, A)))
print(c)
| import math
N = int(input())
print(math.floor((N - 1)/2)) | 0 | null | 77,028,832,815,312 | 26 | 283 |
# E - Bullet
from collections import Counter
from math import gcd
n = int(input())
counter = Counter() # 各ベクトルの個数
for i in range(n):
a, b = map(int, input().split())
if b < 0:
a, b = -a, -b # 180度回転して第1〜2象限に
elif b == 0:
a = abs(a)
if not a == b == 0:
# 既約化
g = gcd(a, b)
a //= g
b //= g
counter[(a, b)] += 1
modulus = 1000000007
vs = set(counter)
# 第2象限のベクトルと直交するベクトルを追加
vs.update((b, -a) for a, b in counter if a <= 0)
# 第1象限のベクトルのみ抽出
vs = [(a, b) for a, b in vs if a > 0]
ncomb = 1 # イワシの選び方の個数
for a, b in vs:
# 互いに仲が悪いイワシ群
n1 = counter[(a, b)]
n2 = counter[(-b, a)]
# それぞれの群から好きな数だけイワシを選ぶ (0匹選ぶことも含む)
m = pow(2, n1, modulus) + pow(2, n2, modulus) - 1
ncomb = ncomb * m % modulus
ncomb -= 1 # 1匹も選ばない場合を除く
# (0, 0)のイワシを1匹だけ選ぶ
ncomb += counter[(0, 0)]
print(ncomb % modulus)
| import sys
input = sys.stdin.buffer.readline
import math
n = int(input())
mod = 1000000007
AB = []
for i in range(n):
a, b = map(int, input().split())
AB.append((a, b))
def power(a, n, mod):
bi=str(format(n,"b")) #2進数
res=1
for i in range(len(bi)):
res=(res*res) %mod
if bi[i]=="1":
res=(res*a) %mod
return res
def toid(a, b):
flag = False
if a == 0 and b == 0:
return (0, 0)
elif a == 0:
return (0, 1)
elif b == 0:
return (1, 0)
else:
if a > 0 and b > 0:
g = math.gcd(a, b)
a //= g
b //= g
elif a > 0 and b < 0:
b = -b
g = math.gcd(a, b)
a //= g
b //= g
b = -b
elif a < 0 and b > 0:
a = -a
g = math.gcd(a, b)
a //= g
b //= g
b = -b
else:
a = -a
b = -b
g = math.gcd(a, b)
a //= g
b //= g
return (a, b)
def totg(a, b):
if a == 0 and b == 0:
return (0, 0)
elif a == 0:
return (1, 0)
elif b == 0:
return (0, 1)
else:
if a > 0 and b > 0:
g = math.gcd(a, b)
a //= g
b //= g
t = (b, -a)
elif a > 0 and b < 0:
b = -b
g = math.gcd(a, b)
a //= g
b //= g
b = -b
t = (-b, a)
elif a < 0 and b > 0:
a = -a
g = math.gcd(a, b)
a //= g
b //= g
a = -a
t = (b, -a)
else:
a = -a
b = -b
g = math.gcd(a, b)
a //= g
b //= g
a = -a
b = -b
t = (-b, a)
return t
d = {}
ans = 0
for i in range(n):
a, b = AB[i]
s = toid(a, b)
if s not in d:
d[s] = 1
else:
d[s] += 1
ans = 1
used = set()
for k1, v1 in d.items():
if k1 in used:
continue
if k1 == (0, 0):
continue
a, b = k1
k2 = totg(a, b)
if k2 in d:
v2 = d[k2]
else:
v2 = 0
temp = power(2, v1, mod)-1+power(2, v2, mod)-1+1
ans *= temp
ans %= mod
used.add(k1)
used.add(k2)
ans -= 1
if (0, 0) in d:
ans += d[(0, 0)]
print(ans%mod) | 1 | 20,856,281,459,310 | null | 146 | 146 |
import sys
N=int(input())
A=list(map(int,input().split()))
M=10**9+7
G={k:0 for k in range(-1,max(A)+1)}
G[-1]=3
X=1
for a in A:
X*=G[a-1]-G[a]
X%=M
G[a]+=1
print(X)
| #https://atcoder.jp/contests/abc164/tasks/abc164_b
A,B,C,D = map(int,input().split())
Senkou_N,Senkou_Amari = divmod(C,B)
if Senkou_Amari != 0:
Senkou_N += 1
Koukou_N,Koukou_Amari = divmod(A,D)
if Koukou_Amari != 0:
Koukou_N += 1
if Senkou_N <= Koukou_N:
print("Yes")
else:
print("No") | 0 | null | 79,458,739,790,300 | 268 | 164 |
#!/usr/bin/env python3
n = int(input())
s = input()
print(*[chr((ord(i) + n - 65) % 26 + 65)for i in s], sep="")
| N=int(input())
*X,=sorted(map(int,input().split()))
a=10**9
for p in range(X[0], X[-1]+1):
a=min(a, sum((n-p)**2 for n in X))
print(a) | 0 | null | 100,224,715,739,456 | 271 | 213 |
alpha = str(input())
if alpha.isupper():
ans = 'A'
else:
ans = 'a'
print(ans)
| def main():
n = int(input())
A = [int(x) for x in input().split()]
if 0 in A:
print(0)
return
mul = 1
for a in A:
mul *= a
if mul > 1e18:
print(-1)
return
print(mul)
main() | 0 | null | 13,787,144,975,318 | 119 | 134 |
import heapq
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)
r.sort(reverse=True)
ans=[]
for i in range(x):
ans.append(p[i])
for j in range(y):
ans.append(q[j])
ans.sort()
heapq.heapify(ans)
for j in range(c):
min_a=heapq.heappop(ans)
if min_a<=r[j]:
heapq.heappush(ans,r[j])
else:
heapq.heappush(ans,min_a)
break
print(sum(ans))
| a,b = raw_input().split(" ")
a = int(a)
b = int(b)
if a < b:
print "a < b"
elif a > b:
print "a > b"
else:
print "a == b" | 0 | null | 22,420,462,480,068 | 188 | 38 |
xy = list(map(int,input().split()))
prise = 0
for i in xy:
if i == 1:
prise += 300000
elif i == 2:
prise += 200000
elif i == 3:
prise += 100000
if sum(xy) == 2:
prise += 400000
print(prise) | x, y = map(int, input().split())
a = max(0, 100000 * (4 - x))
b = max(0, 100000 * (4 - y))
c = 400000 if x == 1 and y == 1 else 0
print(a + b + c)
| 1 | 140,557,668,548,980 | null | 275 | 275 |
# A - A?C
# 'ABC'には'ARC'を、'ARC'には'ABC'を返す
S = str(input())
if S == 'ABC':
print('ARC')
elif S == 'ARC':
print('ABC')
| n = int(input())
x = list(map(int, input().split()))
ans = 10**6
for i in range(1, 101):
str = 0
for j in x:
str += (j-i)**2
ans = min(ans, str)
print(ans) | 0 | null | 44,839,497,344,990 | 153 | 213 |
#template
def inputlist(): return [int(j) for j in input().split()]
#template
N = int(input())
lis = ['0']*N
time = [0]*N
for i in range(N):
lis[i],time[i] = input().split()
sing = input()
index = -1
for i in range(N):
if lis[i] == sing:
index = i
break
ans = 0
for i in range(index+1,N):
ans += int(time[i])
print(ans) | n=int(input())
s=[""]*n
t=[0]*n
for i in range(n):
s[i],t[i]=input().split()
t[i]=int(t[i])
x=input()
c=0
for i in range(n):
if s[i]==x:
c=i
break
ans=0
for i in range(c+1,n):
ans+=t[i]
print(ans) | 1 | 96,923,522,972,770 | null | 243 | 243 |
def pow_mod(a, b, p):
res = 1
mul = a
for i in range(len(bin(b)) - 2):
if (1 << i) & b:
res = (res * mul) % p
mul = (mul ** 2) % p
return res
def comb_mod(n, r, p, factorial, invert_factorial):
return (factorial[n] * invert_factorial[r] * invert_factorial[n - r]) % p
def main():
p = 10 ** 9 + 7
n, k = map(int, input().split())
factorial = [1] * (n + 1)
for i in range(1, n + 1):
factorial[i] = (factorial[i - 1] * i) % p
invert_factorial = [0] * (n + 1)
invert_factorial[n] = pow_mod(factorial[n], p - 2, p)
for i in range(n - 1, -1, -1):
invert_factorial[i] = (invert_factorial[i + 1] * (i + 1)) % p
res = 0
for i in range(min(k + 1, n)):
res = (res + comb_mod(n, i, p, factorial, invert_factorial)
* comb_mod(n - 1, i, p, factorial, invert_factorial)) % p
print(res)
main()
| N = int(input())
D = [list(map(int,input().split())) for _ in range(N)]
cnt = 0
for i in range(N):
cnt = cnt + 1 if D[i][0] == D[i][1] else 0
if cnt == 3:
print('Yes')
exit()
print('No') | 0 | null | 35,038,721,474,692 | 215 | 72 |
from heapq import heappush, heappop
import sys
input = sys.stdin.readline
N = int(input())
pos = []
zero = []
neg = []
for _ in range(N):
S = input().rstrip()
m = s = 0
for c in S:
if c == '(':
s += 1
else:
s -= 1
m = min(m, s)
if s > 0:
heappush(pos, (-m, s)) # take larger mins first
elif s == 0:
heappush(zero, (m, s))
else:
heappush(neg, (m - s, s)) # take smaller mins first
num = 0
while pos:
m, s = heappop(pos)
if num - m < 0:
print('No')
exit()
num += s
while zero:
m, s = heappop(zero)
if num + m < 0:
print('No')
exit()
while neg:
m, s = heappop(neg)
m += s
if num + m < 0:
print('No')
exit()
num += s
if num == 0:
print('Yes')
else:
print('No')
| N=int(input())
n= str(N)
total=0
for i in range(len(n)):
k = n[i]
k = int(k)
total += k
if total%9==0:
print("Yes")
else:
print("No") | 0 | null | 13,959,179,494,468 | 152 | 87 |
n = int(input())
A = list(map(int, input().split()))
mod = 10 ** 9 + 7
ans = 0
for k in range(60):
x, y = 0, 0
for a in A:
x += 1 & a >> k
tmp = x * (n - x) % mod
tmp *= 2**k%mod
ans += tmp
ans %= mod
print(ans)
| import sys
n, u, v = map(int, sys.stdin.readline().split())
graph = [[] for _ in range(n+1)]
for i in range(n-1):
a, b = map(int, sys.stdin.readline().split())
graph[a].append(b)
graph[b].append(a)
def dfs(v):
dist = [-1] * (n+1)
dist[v] = 0
stack = [v]
while stack:
now = stack.pop()
dw = dist[now] + 1
for ne in graph[now]:
if dist[ne] >= 0:
continue
dist[ne] = dw
stack.append(ne)
return dist
Takahashi = dfs(u)
Aoki = dfs(v)
ans = 0
for t, a in zip(Takahashi[1:], Aoki[1:]):
if t < a:
ans = max(ans, a - 1)
print(ans)
| 0 | null | 120,045,383,556,366 | 263 | 259 |
"""
高橋君はとりあえず、青木君から最も遠い木の端を目指すのがベスト。
また、目指すべき木の端までの距離に関しては、高橋くんよりも自分の方が近くなくてはならない。
また、高橋君が捕まるときは、必ず木の端の一歩手前のノードになる。
つまり、青木君が移動しなくてはいけない最大距離は、高橋君が目指す木の端までの距離-1、ということになる。
とりま、高橋くん、青木君の初期位置から各ノードまでの距離を調べて、上記の条件にマッチする端を見つける。
"""
from collections import deque
N,u,v = map(int,input().split())
edges = [[] for _ in range(N+1)]
for _ in range(N-1):
a,b = map(int,input().split())
edges[a].append(b)
edges[b].append(a)
takahashi = [None]*(N+1)
que = deque([(0,u,0)])
while que:
step,cur,par = que.popleft()
takahashi[cur] = step
for nx in edges[cur]:
if nx == par:
continue
que.append((step+1,nx,cur))
aoki = [None]*(N+1)
que = deque([(0,v,0)])
while que:
step,cur,par = que.popleft()
aoki[cur] = step
for nx in edges[cur]:
if nx == par:
continue
que.append((step+1,nx,cur))
ans = 0
for i in range(1,N+1):
if takahashi[i] < aoki[i]:
ans = max(ans,aoki[i]-1)
print(ans) | n = int(input())
a = [int(s) for s in input().split()]
ans = 'APPROVED'
for num in a:
if num % 2 == 0:
if num % 3 != 0 and num % 5 != 0:
ans = 'DENIED'
break
print(ans) | 0 | null | 92,958,970,374,970 | 259 | 217 |
n, m, x = map(int, input().split())
c = [0] * n
a = [0] * n
for i in range(n):
c[i], *a[i] = list(map(int, input().split()))
ans = 10 ** 9
for i in range(2 ** n):
csum = 0
asum = [0] * m
for j in range(n):
if (i >> j) & 1:
csum += c[j]
for k in range(m):
asum[k] += a[j][k]
if len(list(filter(lambda v: v >= x, asum))) == m:
ans = min(ans, csum)
print(-1 if ans == 10 ** 9 else ans)
| n = int(input())
s = list(input())
ans = ''
for i in s:
ascii_code = (ord(i) + n)
if ascii_code >= 91:
ascii_code -= 26
ans += chr(ascii_code)
print(ans)
| 0 | null | 78,456,529,321,440 | 149 | 271 |
while True:
a, op, b = map(str, input().split(" "))
if op == "?":
break
a, b = int(a), int(b)
if op == "+":
c = a + b
elif op == "-":
c = a - b
elif op == "*":
c = a * b
else:
c = a // b
print(c)
| n, k = map(int, input().split())
MOD = 10 ** 9 + 7
def factorial(n):
global fct
global invfct
fct = [0] * (n + 1)
fct[0] = 1
for i in range(1, n+1):
fct[i] = fct[i-1] * i % MOD
invfct = [0] * (n + 1)
invfct[n] = pow(fct[n], MOD - 2, MOD)
for i in range(n-1, -1, -1):
invfct[i] = invfct[i+1] * (i + 1) % MOD
def binomial(n, k):
return fct[n] * invfct[n-k] % MOD * invfct[k] % MOD
factorial(2 * n)
if k >= n:
print(binomial(2 * n - 1, n) % MOD)
else:
answer = 0
for i in range(k+1):
answer += binomial(n, i) * binomial(n-1, i)
answer %= MOD
print(answer)
| 0 | null | 34,015,576,764,092 | 47 | 215 |
def f():
N = int(input())
UP = []
DOWN = []
for _ in range(N):
S = input()
c = 0
minC = 0
for s in S:
if s == '(':
c += 1
else:
c -= 1
minC = min(minC, c)
if c >= 0:
UP.append((minC, c))
else:
DOWN.append((c - minC, c))
c = 0
for up in sorted(UP, reverse=True):
if c + up[0] < 0:
return False
c += up[1]
for down in sorted(DOWN, reverse=True):
if c + down[1] - down[0] < 0:
return False
c += down[1]
if c != 0:
return False
return True
if f():
print('Yes')
else:
print('No')
| from operator import itemgetter
from itertools import chain
N = int(input())
L = []
R = []
for i in range(N):
S = input()
low = 0
var = 0
for s in S:
if s == '(':
var += 1
else:
var -= 1
low = min(low, var)
if var >= 0:
L.append((low, var))
else:
R.append((low, var))
L.sort(key=itemgetter(0), reverse=True)
R.sort(key=lambda x: x[0] - x[1])
pos = 0
for i, (low, var) in enumerate(chain(L, R)):
if pos + low < 0:
ans = 'No'
break
pos += var
else:
ans = 'Yes' if pos == 0 else 'No'
print(ans)
| 1 | 23,583,308,907,258 | null | 152 | 152 |
import math
s=input()
if(s[len(s)-1]=='s'):
print(s+'es')
else:
print(s+'s') | class Main:
S = input()
if S[-1] == 's':
print(S+'es')
else :
print(S+'s') | 1 | 2,378,101,477,252 | null | 71 | 71 |
# coding: utf-8
while True:
h, w = map(int, input().split())
if h == 0 and w == 0:
exit()
else:
print('#' * w)
for _ in range(h - 2):
print('#' + '.' * (w - 2) + '#')
print('#' * w)
print()
| from collections import deque
import sys
input=sys.stdin.readline
S=input().rstrip()
string = deque([S[i] for i in range(len(S))])
reverse = False
for _ in range(int(input())):
q = input().rstrip().split()
if q[0] == "1":
reverse = not reverse
else:
if q[1] == "1":
if reverse:
string.append(q[2])
else:
string.appendleft(q[2])
else:
if reverse:
string.appendleft(q[2])
else:
string.append(q[2])
string = list(string)
if reverse:
string = string[::-1]
print("".join(string))
| 0 | null | 28,880,444,303,820 | 50 | 204 |
import collections
s = input()
mod = 2019
n = len(s)
t = [0]*(n+1)
for i in range(1,n+1):
t[i] = (t[i-1] + int(s[n-i]) * pow(10, i-1, mod)) % mod
c = collections.Counter(t)
num = c.values()
ans = 0
for i in num:
ans += i*(i-1) // 2
print(ans) | from sys import exit
n = int(input())
num_list = [int(i) for i in input().split()]
if 0 in num_list:
print(0)
exit()
ans = 1
for i in range(n):
ans *= num_list[i]
if ans > 10**18:
print(-1)
exit()
print(ans) | 0 | null | 23,475,108,250,632 | 166 | 134 |
A, B, C, K = map(int, input().split())
D = A + B
if D >= K:
print(min(K,A))
else:
K -= D
print(A-K)
| A, B, C, K = map(int, input().split())
num = 0
if K - A <= 0:
num = K
else:
K -= A
num = A
if K - B > 0:
K -= B
num += (-1)*K
print(num) | 1 | 21,769,925,542,372 | null | 148 | 148 |
def buble(lst):
src_list = list(lst)
flag=True
while flag:
flag = False
for idx in range(len(lst)-1, 0, -1):
if int(lst[idx][1]) < int(lst[idx-1][1]):
tmp=lst[idx]
lst[idx]=lst[idx-1]
lst[idx-1]=tmp
flag=True
flag_stable = True
for num in range(0, 9):
tmp1 = []
tmp2 = []
for i in range(0, len(lst)):
if int(lst[i][1]) == num:
tmp1.append(lst[i])
if int(src_list[i][1]) == num:
tmp2.append(src_list[i])
if tmp1 != tmp2:
flag_stable = False
break
print " ".join(lst)
if flag_stable:
print "Stable"
else:
print "Not stable"
def selection(lst):
src_list = list(lst)
for i in range(len(lst)):
m = i
for j in range(i,len(lst)):
if int(lst[m][1]) > int(lst[j][1]):
m=j
tmp=lst[i]
lst[i]=lst[m]
lst[m]=tmp
flag_stable = True
for num in range(0, 9):
tmp1 = []
tmp2 = []
for i in range(0, len(lst)):
if int(lst[i][1]) == num:
tmp1.append(lst[i])
if int(src_list[i][1]) == num:
tmp2.append(src_list[i])
if tmp1 != tmp2:
flag_stable = False
break
print " ".join(lst)
if flag_stable:
print "Stable"
else:
print "Not stable"
n=raw_input()
lst1 = raw_input().split()
lst2 = list(lst1)
buble(lst1)
selection(lst2) | #インプットdataの格納
n, k = map(int, input().split())
n_list = list()
for i in range(n):
n_list.append(int(input()))
#data処理
left = 0
right = 100000*10000
while (right - left) > 1:
mid = (left + right) // 2
i = 0
for j in range(k):
weight = 0
while i < n:
if (weight + n_list[i]) > mid:
break
else:
weight += n_list[i]
i += 1
if i >= n:
right = mid
else:
left = mid
#結果表示
print(right)
| 0 | null | 59,175,864,160 | 16 | 24 |
s = int(input())
mod = 10**9+7
dp = [0]*(s+1)
dp[0] = 1
for i in range(1,s+1):
for j in range(0,(i-3)+1):
dp[i] += dp[j]
dp[i] %= mod
print(dp[s]) | dp = [-1] * 2005
mod = 1000000007
def DP(S):
if S == 0:
return 1
if(dp[S] != -1):
return dp[S]
ret = 0
for i in range(3, S+1):
ret = (ret + DP(S-i)) % mod
dp[S] = ret
return ret
n = int(input())
print(DP(n)) | 1 | 3,249,026,986,602 | null | 79 | 79 |
class Dice:
def __init__(self,t,f,r,l,b,u):
self.t = t
self.f = f
self.r = r
self.l = l
self.b = b
self.u = u
self.a=[t,f,r,l,b,u]
self.direction={'S':(4,0,2,3,5,1),'N':(1,5,2,3,0,4),'E':(3,1,0,5,4,2),'W':(2,1,5,0,4,3),'Y':(0,3,1,4,2,5)}
def roll(self,d):
self.a=[self.a[i] for i in self.direction[d]]
self.t = self.a[0]
self.f = self.a[1]
self.r = self.a[2]
self.l = self.a[3]
self.b = self.a[4]
self.u = self.a[5]
t,f,r,l,b,u=map(int,input().split())
dice=Dice(t,f,r,l,b,u)
n=int(input())
s='SSSEWW'
yw='YYY'
for j in range(n):
t,f=map(int,input().split())
for d in s:
if dice.t==t:
break
dice.roll(d)
for t in yw:
if dice.f==f:
break
dice.roll(t)
print(dice.r)
| s, t = input("").split(" ")
res = t + s
print(res) | 0 | null | 51,518,551,659,358 | 34 | 248 |
N = int(input())
D = list(map(int, input().split()))
M = 998244353
from collections import Counter
if D[0] != 0:
print(0)
exit(0)
cd = Counter(D)
if cd[0] != 1:
print(0)
exit(0)
tmp = sorted(cd.items(), key=lambda x: x[0])
ans = 1
for kx in range(1, max(D)+1):
ans *= pow(cd[kx-1], cd[kx],M)
ans %= M
print(ans)
| from collections import deque
def BFS():
color=["white" for _ in range(h)]
D=[-1 for _ in range(h)]
M=[[] for _ in range(h)]
for i in range(h-1):
M[i].append(i+1)
M[i+1].append(i)
queue=deque([])
for i in line:
queue.append(i)
D[i]=i
color[i]="gray"
while len(queue)>0:
u=queue.popleft()
for i in M[u]:
if D[i]==-1 and color[i]=="white":
D[i]=D[u]
color[i]="gray"
queue.append(i)
return D
h,w,k=map(int,input().split())
S=[list(input()) for _ in range(h)]
M=[[0 for _ in range(w)] for _ in range(h)]
num,line=0,[]
for i in range(h):
if S[i].count("#")!=0:
p=num
for j in range(w):
if S[i][j]=="#":
num +=1
elif num==p:
M[i][j]=num+1
continue
M[i][j]=num
line.append(i)
D=BFS()
for i in range(h):
M[i]=M[D[i]]
for i in range(h):
print(*M[i]) | 0 | null | 149,883,166,131,918 | 284 | 277 |
n = int(input())
for i in range(1000):
for j in range(-1000,1000):
if (i**5-j**5)==n:
print(i,j)
exit() | #!/usr/bin/env python3
def main():
import sys
input = sys.stdin.readline
X = int(input())
for a in range(-150, 151):
for b in range(-150, 151):
if a ** 5 - b ** 5 == X:
print(a, b, sep=' ')
return
if __name__ == '__main__':
main()
| 1 | 25,691,573,671,160 | null | 156 | 156 |
x=int(input())
i=0
while (i+1)*100 <= x:
i+=1
nokori = x-i*100
num = ((nokori - 1) // 5) + 1
if num <= i:
print(1)
exit()
print(0) | x=int(input())
if x>=2100:
print(1)
exit()
ans=[0]*2100
for a in range(22):
for b in range(22):
for c in range(22):
for d in range(22):
for e in range(22):
for f in range(21):
y=a*100+b*101+c*102+d*103+e*104+f*105
if y<=2099:
ans[y]=1
print(ans[x]) | 1 | 127,291,719,375,788 | null | 266 | 266 |
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
C = readline().strip()
print(chr(ord(C) + 1))
return
if __name__ == '__main__':
main()
| from collections import defaultdict
(h,n),*ab = [list(map(int, s.split())) for s in open(0)]
mxa = max(a for a,b in ab)
dp = defaultdict(lambda: float('inf'))
dp[0] = 0
for i in range(1, h+mxa):
dp[i] = min(dp[i-a] + b for a,b in ab)
print(min(v for k,v in dp.items() if k>=h)) | 0 | null | 86,220,626,727,872 | 239 | 229 |
from bisect import bisect_left
from itertools import accumulate
def resolve():
def getCount(x):
cnt = 0
for a in A:
# X未満の個数
idx = bisect_left(A, x - a)
# X以上の個数
cnt += N - idx
# X以上を使う！と決めた時、M個以上になるか
return cnt >= M
N, M = map(int, input().split())
A = sorted(map(int, input().split()))
ng = 10 ** 9
ok = 0
# X以上を使う！と決めるとX以上の個数が自明にわかる。
while ng - ok > 1:
mid = (ok + ng) // 2
if getCount(mid):
ok = mid
else:
ng = mid
# M個以上あることがわかれば、Mよりも余分な数(同じ値が複数ある場合)
# はすべてXである事がわかるため、差分だけ引けば良い。
B = [0] + list(accumulate(A))
ans = 0
cnt = 0
for i in range(N):
idx = bisect_left(A, ok - A[i])
ans += B[N] - B[idx] + A[i] * (N - idx)
cnt += N - idx
rest = (cnt - M) * ok
print(ans - rest)
if __name__ == "__main__":
resolve()
| N = int(input())
alist = list(map(int, input().split()))
blist = []
for i in range(N):
blist.append([alist[i],i+1])
blist.sort()
for i in range(N):
print(blist[i][1],end=" ") | 0 | null | 144,171,230,610,040 | 252 | 299 |
s = input()
s = s[::-1]
L = [0]
cnt = 1
for i in range(len(s)):
L.append((L[-1]+(int(s[i])*cnt))%2019)
cnt *= 10
cnt %= 2019
D = dict()
for j in L:
if j in D:
D[j] += 1
else:
D[j] = 1
ans = 0
for k in D.values():
ans += k * (k-1) //2
print(ans) | from collections import defaultdict
s = input()
rests = [0]
n = 0
a = 0
m = 1
c = defaultdict(int)
c[0] += 1
for i in list(s)[::-1]:
n = n + int(i)*m
c[n % 2019] += 1
m = m * 10 % 2019
for v in c.values():
a += v * (v-1) // 2
print(a)
| 1 | 30,990,115,407,482 | null | 166 | 166 |
# coding=utf-8
import sys
n, q = map(int, sys.stdin.readline().split())
queue = []
total_time = 0
finished_loop = 0
for i in range(n):
name, time = input().split()
queue.append([name, int(time)])
while queue:
n -= finished_loop
finished_loop = 0
for i in range(n):
poped = queue.pop(0)
name = poped[0]
time = poped[1]
if time > q:
queue.append([name, time - q])
total_time += q
else:
total_time += time
print(name, total_time)
finished_loop += 1 | n,q = map(int,input().split())
name = []
time = []
for i in range(n):
a = input().split()
name.append(a[0])
time.append(int(a[1]))
s = 0
while name:
if time[0]> q:
time[0] -= q
time.append(time.pop(0))
name.append(name.pop(0))
s += q
else:
s += time[0]
time.pop(0)
print(name.pop(0),s) | 1 | 44,118,655,210 | null | 19 | 19 |
import bisect, collections, copy, heapq, itertools, math, string
import sys
def I(): return int(sys.stdin.readline().rstrip())
def MI(): return map(int, sys.stdin.readline().rstrip().split())
def LI(): return list(map(int, sys.stdin.readline().rstrip().split()))
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())
def main():
A, B = MI()
x = 10 * B
for i in range(x, x + 10):
y = int(i * 8 / 100)
if y == A:
print(i)
exit()
print(-1)
if __name__ == "__main__":
main()
| a, b = map(int, input().split())
ans = -1
for money in range(pow(10, 4)):
if int(money*0.08) == a and int(money*0.1) == b:
ans = money
break
print(ans) | 1 | 56,505,906,125,788 | null | 203 | 203 |
s = input()
n = len(s)
t = s[:(n-1)//2]
u = s[(n+3)//2-1:]
if (s == s[::-1]
and t == t[::-1]
and u == u[::-1]):
print('Yes')
else:
print('No')
| import collections
MOD = 998244353
def main():
N = int(input())
D = [int(_) for _ in input().split()]
Dmax = max(D)
cc = collections.Counter(D)
if D[0] != 0: return 0
if cc[0] != 1: return 0
for i in range(Dmax+1):
if cc[i] == 0: return 0
output = 1
for i in sorted(cc.keys()):
if i in (0, 1): continue
output *= pow(cc[i-1], cc[i], MOD)
output %= MOD
return output
if __name__ == '__main__':
print(main())
| 0 | null | 100,285,967,327,062 | 190 | 284 |
n = int(input())
g = []
for i in range(n):
a = list(map(int,input().split()))
g.append(a[2:])
d = [0]*n
f = [0]*n
global t
t = 0
def find(x):
global t
if len(g[x-1]) == 0:
t += 1
f[x-1] = t
else:
for i in g[x-1]:
if d[i-1] == 0:
t += 1
d[i-1] = t
find(i)
t += 1
f[x-1] = t
for i in range(n):
if d[i] == 0:
t += 1
d[i] = t
find(i+1)
for i in range(n):
print(i+1, d[i], f[i])
| import copy
class Dice2:
def __init__(self, nums):
self.nums = nums
self.dic = \
{(1,2):3, (1,3):5, (1,4):2, (1,5):4, (2,3):1, (2,4):6, (2,6):3, (3,5):1, (3,6):5, (4,5):6, (4,6):2, (5,6):4}
def output_right(self, x):
x[0] = self.nums.index(x[0]) + 1
x[1] = self.nums.index(x[1]) + 1
nums = self.nums
y = copy.deepcopy(x)
x.sort()
key = tuple(x)
if tuple(y)==key:
return nums[self.dic[key]-1]
else:
return nums[6-self.dic[key]]
dice = Dice2(list(map(int, input().split())))
q = int(input())
for i in range(q):
print(dice.output_right(list(map(int, input().split())))) | 0 | null | 124,483,956,648 | 8 | 34 |
n,k = map(int,input().split())
h = list(map(int,input().split()))
h.sort(reverse = True)
m = 0
for i in range(k,n):
m += h[i]
print(m) | n = int(input())
A = list(map(int, input().split()))
total = 0
min_ = A[0]
for i in range(n):
if A[i] > min_:
min_ = A[i]
else:
total += (min_ - A[i])
print(total) | 0 | null | 42,061,955,791,670 | 227 | 88 |
N,K=map(int,input().split())
A=list(map(int,input().split()))
B=[0]*N
B[0]=1
if B[0] in A:c=B[0]
for i in range(1,N):
B[i]=A[B[i-1]-1]
d=B.index(B[-1])+1
if K<=N:print(B[K]);exit()
print(B[d-1+(K+1-d)%(N-d)])
| # -*- coding: utf-8 -*-
import sys
sys.setrecursionlimit(10**6)
N,K=map(int, sys.stdin.readline().split())
A=[None]+map(int, sys.stdin.readline().split())
visit=[ 0 for _ in range(N+1) ]
L=[] #閉路になった町番号を順番に記録する
def func(fro):
global K
to=A[fro]
visit[fro]+=1
if visit[fro]==2:
L.append(fro)
if visit[to]<=1: #閉路ループは2回まで許可する
K-=1 #操作回数を減らす
if K==0: #Kが途中でゼロになれば、その時に移動しようとしていたtoが答え
print to
quit()
func(to)
func(1)
K-=1
l=len(L)
print L[K%l]
| 1 | 22,842,210,259,760 | null | 150 | 150 |
from scipy.sparse.csgraph import floyd_warshall
N,M,L = list(map(int, input().split()))
edges = [[0] * N for _ in range(N)]
for _ in range(M):
A,B,C = list(map(int, input().split()))
edges[A-1][B-1] = C
edges[B-1][A-1] = C
Q = int(input())
queries = []
for _ in range(Q):
queries.append(list(map(int,input().split())))
# use flord warshall to find min path between all towns
edges = floyd_warshall(edges)
# if the two towns can be travelled to on one tank, add to our fuel graph with distance 1
for i in range(N):
for j in range(N):
if edges[i][j] <= L:
edges[i][j] = 1
else:
edges[i][j] = 0
# use flord warshall to find min number of fuel tanks to travel between two towns
edges = floyd_warshall(edges)
for query in queries:
s = query[0] - 1
t = query[1] - 1
num_tanks = edges[s][t] - 1
if num_tanks != float('inf'):
print(int(num_tanks))
else:
print("-1")
| from collections import defaultdict, deque
import math
kMod = 1000000007
N = int(input())
key2count = defaultdict(lambda: [0, 0])
for _ in range(N):
a, b = map(int, input().split())
g = math.gcd(a, b)
if a < 0 or a == 0 and b < 0:
a, b = -a, -b
if g > 0:
a, b = a//g, b//g
idx = 0
if b <= 0:
idx = 1
a, b = -b, a
key2count[(a, b)][idx] += 1
ans = 1
for key, val in key2count.items():
if key == (0, 0):
continue
plus, minus = val
ans *= (pow(2, plus, kMod) + pow(2, minus, kMod)-1)
ans %= kMod
ans += sum(key2count[(0, 0)])
print((ans + kMod-1) % kMod) | 0 | null | 96,938,626,086,822 | 295 | 146 |
def hash1(m, key):
return key % m
def hash2(m, key):
return 1 + key % (m - 1)
def hash(m, key, i):
return (hash1(m, key) + i * hash2(m, key) ) % m
def insert(T, key):
i = 0
l = len(T)
while True:
h = hash(1046527,key,i)
if (T[h] == None ):
T[h] = key
return h
elif (T[h] == key):
return h
else:
i += 1
def search(T,key):
l = len(T)
i = 0
while True:
h = hash(1046527,key,i)
if(T[h] == key):
return h
elif(T[h] is None or h >= l):
return -1
else:
i += 1
def find(T, key):
a = search(T,key)
if(a == -1):
print('no')
else:
print('yes')
dict = {'A' : '1', 'C' : '2', 'G' : '3', 'T' : '4'}
data = []
T = [None]*1046527
n = int(input())
while n > 0:
st = input()
d = list(st.split())
### convert key to num(1~4)
tmp_key = ''
for x in list(d[1]):
tmp_key += dict[x]
data.append([d[0],int(tmp_key)])
n -= 1
for com in data:
if(com[0] == 'insert'):
insert(T,com[1])
else:
find(T,com[1]) | # coding: utf-8
# Your code here!
dic = set()
def insert(s):
dic.add(s)
def find(s):
if s in dic:
print("yes")
else:
print("no")
i = int(input())
for c in range(i):
op,s = map(str,input().split())
if op == "insert":
insert(s)
elif op == "find":
find(s)
| 1 | 77,950,931,252 | null | 23 | 23 |
# coding:utf-8
class FLOOR:
def __init__(self):
self.room = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
class BUILD:
def __init__(self):
self.floor = [FLOOR(), FLOOR(), FLOOR()]
# 3??????10??¨?±????4?£?
all_rooms = [BUILD(), BUILD(), BUILD(), BUILD()]
# ??\???
n = int(input())
for i in range(n):
b, f, r, v = map(int, input().split())
all_rooms[b-1].floor[f-1].room[r-1] += v
for b in range(4):
for f in range(3):
display = []
for r in range(10):
display.append(str(all_rooms[b].floor[f].room[r]))
print(' ' + ' '.join(display))
if (b < 3):
print('#'*20) | N=int(input())
l=[[[0 for i in range(10)]for j in range(3)]for k in range(4)]
for i in range(N):
b, f, r, v = map(lambda x: int(x)-1, input().split())
l[b][f][r]+=v+1
for j in range(4):
for k in l[j]:
print(" "+" ".join(map(str, k)))
if j < 3:
print("####################") | 1 | 1,103,106,133,668 | null | 55 | 55 |
def main():
N = int(input())
A = [int(a) for a in input().split()]
xor_all = A[0]
for i in range(1, N):
xor_all ^= A[i]
for i in range(N):
if i != N - 1:
print(A[i]^xor_all, end=" ")
else:
print(A[i]^xor_all)
if __name__ == "__main__":
main() | from functools import reduce
N = int(input())
A = [int(x) for x in input().split()]
SUM=reduce(lambda a, b: a^b, A)
[print(SUM^A[i]) for i in range(N)] | 1 | 12,368,834,291,592 | null | 123 | 123 |
a = int(input())
print(a*((a+1)*(a+1)-a)) | from collections import deque
q = deque()
for _ in range(int(input())):
b=input()
if b[0] == 'i':
q.appendleft(b[7:])
elif b[6] == ' ':
try:
q.remove(b[7:])
except:
pass
elif len(b) > 10:
q.popleft()
elif len(b) > 6:
q.pop()
print(*q)
| 0 | null | 5,090,669,196,360 | 115 | 20 |
A = int(input())
B = int(input())
anss = set([1, 2, 3])
anss.remove(A)
anss.remove(B)
for i in anss:
print(i)
| a=input()
b=input()
if (a=="1" and b=="2")or(a=="2" and b=="1"):
print("3")
if (a=="1" and b=="3")or(a=="3" and b=="1"):
print("2")
if (a=="3" and b=="2")or(a=="2" and b=="3"):
print("1") | 1 | 110,748,149,811,560 | null | 254 | 254 |
n, m, l = map(int, raw_input().split())
matrix_a = []
matrix_b = []
for i in range(n):
line = map(int, raw_input().split())
matrix_a.append(line)
for i in range(m):
line = map(int, raw_input().split())
matrix_b.append(line)
for i in range(n):
result = []
for j in range(l):
tmp = 0
for k in range(m):
tmp += matrix_a[i][k] * matrix_b[k][j]
result.append(tmp)
print " ".join(map(str, result)) | r,cr,c = map(int,input().split())
matrix_a = [list(map(int,input().split())) for i in range(r)]
matrix_b = [list(map(int,input().split())) for i in range(cr)]
matrix_c = [ [0 for a in range(c)] for b in range(r)]
for j in range(r):
for k in range(c):
for l in range(cr):
matrix_c[j][k] += matrix_a[j][l]*matrix_b[l][k]
for x in matrix_c:
print(" ".join(list(map(str,x)))) | 1 | 1,409,462,864,590 | null | 60 | 60 |
N = int(input())
S = input()
base = ord("A")
ans = ""
for i in range(len(S)):
p = (ord(S[i])-base)
s = (p+N) % 26
ans += chr(s+base)
print(ans) | def main():
n = int(input())
# n, k = map(int, input().split())
# h = list(map(int, input().split()))
s = input()
ans = ""
for i in s:
ans += chr((ord(i) - ord("A") + n)% 26 + ord("A"))
print(ans)
if __name__ == '__main__':
main()
| 1 | 134,714,088,033,000 | null | 271 | 271 |
import sys, itertools
print(len(set(itertools.islice(sys.stdin.buffer, 1, None)))) | #! /usr/bin/env python3
noOfInputs = int(input())
for i in range(noOfInputs):
numsInStr = input().split()
nums = []
for n in numsInStr:
nums.append(int(n))
largest = max(nums)
nums.remove(max(nums))
#print(nums)
if (largest**2 == sum([i**2 for i in nums])):
print('YES')
else:
print('NO') | 0 | null | 15,214,403,812,428 | 165 | 4 |
line = '#.'*150
while True:
H, W = map(int, raw_input().split())
if H == W == 0: break
for i in range(H):
print line[i%2:i%2+W]
print '' | from collections import deque
H, W, K = map(int, input().split())
S = []
for _ in range(H):
S.append(list(input()))
def cut(bit):
"""
横の切れ目の場所をビットで管理する。
"00...0" <= bit <= "11...1"(H - 1桁)の時に、縦に入れる切れ目の最小回数を返す。
"""
end = [] # 板チョコを横区切りにした結果、上から何段目で各板チョコのピースが終わるか
for i in range(H - 1):
if bit[i] == '1':
end.append(i)
end.append(H - 1)
chocolates = [0] * (len(end))
#print("end={}".format(end))
"""
ここまでで板チョコを横に切ったわけだが、こうして分割した横長の部分板チョコを
上からsection = 0, 1, 2,..., len(end)-1と呼び分けることにする。
"""
cut = 0
whites_sum = [0] * len(end) # w列目までの白チョコの累積数をsectionごとに管理。cutが入れば初期化。
for w in range(W):
whites = [0] * len(end) # whites[section] = (w列目にある白チョコをsectionごとに保存)
section = 0 # 現在のsection
coarse = False # 横切りが荒過ぎて１列に白チョコがK個より多く並んだ場合に探索を打ち切るフラグ
for h in range(H + 1):
# sectionを跨いだ場合の処理
if h > end[section]:
if whites[section] > K:
coarse = True
break
elif whites_sum[section] + whites[section] > K:
cut += 1
whites_sum = whites
whites = [0] * len(end)
section += 1
else:
whites_sum[section] += whites[section]
section += 1
# 白チョコカウント
if h < H and S[h][w] == '1':
whites[section] += 1
# coarseフラグが立っていたら-1を返す。
if coarse:
return -1
return cut
ans = 10 ** 10
for h in range(2 ** (H - 1)):
bit = bin(h)[2:] # "0b..."を除くため
l = len(bit)
bit = '0' * (H - 1 - l) + bit # bitの桁数をH - 1にする。
#print("bit={}".format(bit))
vertical_cuts = cut(bit)
if vertical_cuts != -1:
preans = vertical_cuts + bit.count('1')
ans = min(ans, preans)
#print("vertical_cut={}, cut={} -> ans={}".format(vertical_cuts, preans, ans))
print(ans)
| 0 | null | 24,744,292,108,800 | 51 | 193 |
l=sorted(list(map(int, input().split())))
if l[0]==l[1]!=l[2] or l[0]!=l[1]==l[2]:
print("Yes")
else:
print("No") | x = list(map(int, input().split()))
if len(set(x))==2:
kotae='Yes'
else:
kotae='No'
print(kotae) | 1 | 68,075,048,102,192 | null | 216 | 216 |
[N, M] = [int(i) for i in input().split()]
print(int(N*max(N-1, 0)/2) + int(M*max(M-1, 0)/2)) | N, M = (int(x) for x in input().split())
ans=0
if N>=2:
ans+=N*(N-1)/2
if M>=2:
ans+=M*(M-1)/2
print(int(ans)) | 1 | 45,542,301,351,360 | null | 189 | 189 |
n = int(input())
S = input()
ans = 0
nums = list(map(str, range(10)))
for i in nums:
s1 = S.find(i)
if s1 < 0:
continue
for j in nums:
s2 = S.find(j, s1+1)
if s2 < 0:
continue
for k in nums:
s3 = S.find(k, s2+1)
if s3 > 0:
ans += 1
print(ans) | import statistics
import sys
data_sets = sys.stdin.read().split("\n")
for i in data_sets[1:-1:2]:
data_set = [int(j) for j in i.split()]
print(statistics.pstdev(data_set)) | 0 | null | 64,761,744,130,108 | 267 | 31 |
while True:
a, b = map(int, input().split())
if a == 0 and b == 0:
break
for n in range(a):
mark1 = "#"
mark2 = "."
outLen = ""
if n % 2 == 0 :
mark1 = "."
mark2 = "#"
for m in range(b):
if m % 2 != 0:
outLen = outLen + mark1
else:
outLen = outLen + mark2
print(outLen)
print("")
| # 累積和
import numpy as np
from numba import njit
@njit(cache=True)
def loop(n, k, A):
for _ in [0] * k:
B = np.zeros(n + 1, dtype=np.int64)
for i in range(n):
left = max(0, i - A[i])
right = min(n, i + A[i] + 1)
B[left] += 1
B[right] -= 1
A = np.cumsum(B)[:-1]
#print(A)
if np.all(A == n):
return A
break
return A
def main():
n, k = map(int, input().split())
a = list(map(int, input().split()))
A = np.array(a, dtype=np.int64)
A = loop(n, k, A)
print(*A)
if __name__ == "__main__":
main()
| 0 | null | 8,092,017,573,328 | 51 | 132 |
n = int(input())
l = list(map(int,input().split()))
from itertools import accumulate
cum=list(accumulate(l))
tot=sum(l)
ans=2020202020*100000
for i in cum:
ans=min(ans, abs(tot-i*2))
print(ans)
| N = int(input())
A = list(map(int, input().split()))
sum_A = sum(A)
sum_now = 0
cost = 99999999999
for a in A:
sum_now += a
cost = min(cost, abs(sum_now - (sum_A - sum_now)))
print(cost)
| 1 | 142,564,990,438,278 | null | 276 | 276 |
import numpy as np
n = int(input())
A = list(map(int, input().strip().split()))
arr = np.array(A)
print(' '.join(map(str, np.argsort(arr) + 1)))
| n = int(input())
a = list(map(int, input().split()))
order = [0] * (n + 1)
for i in range(n):
order[a[i]] = i + 1
print(*order[1:])
| 1 | 180,989,793,339,328 | null | 299 | 299 |
n, u, v = map(int, input().split())
matrix = [[] for _ in range(n)]
import sys
sys.setrecursionlimit(10**8)
for _ in range(n-1):
a,b = map(int, input().split())
matrix[a-1].append(b-1)
matrix[b-1].append(a-1)
C = [0]*n
D = [0]*n
def dfs(x, pre, cnt, c):
c[x] = cnt
cnt += 1
for a in matrix[x]:
if a == pre:
continue
dfs(a, x, cnt, c)
dfs(v-1, -1, 0, C)
dfs(u-1, -1, 0, D)
ans=0
for i in range(n):
if C[i] > D[i]:
ans = max(ans, C[i]-1)
print(ans) | n,u,v=map(int,input().split())
tree=[[]for _ in range(n)]
for i in range(n-1):
a,b = map(int,input().split())
tree[a-1].append(b-1)
tree[b-1].append(a-1)
va=[-1]*n
q=[v-1]
va[v-1]=0
while q:
x=q.pop()
for j in tree[x]:
if va[j]==-1:
q.append(j)
va[j]=va[x]+1
q=[u-1]
vt=[-1]*n
vt[u-1]=0
ans=0
while q:
x=q.pop()
ans=max(ans,va[x])
for j in tree[x]:
if vt[j]==-1:
if vt[x]+1<va[j]:
q.append(j)
vt[j]=vt[x]+1
elif vt[x]+1==va[j]:
vt[j]=vt[x]+1
print(ans-1) | 1 | 117,709,633,003,680 | null | 259 | 259 |
while(True):
a = input()
if '?' in a:
break
print(int(eval(a)))
| listA=[]
listOP=[]
listB=[]
count=0
while True:
a,op,b=input().split()
listA.append(int(a))
listOP.append(op)
listB.append(int(b))
if op=="?":
del listA[len(listA)-1]
del listOP[len(listOP)-1]
del listB[len(listB)-1]
break
#入力パートここまで。計算出力パートここから
while count<=len(listA)-1:
if listOP[count]=="+":
print(listA[count]+listB[count])
elif listOP[count]=="-":
print(listA[count]-listB[count])
elif listOP[count]=="*":
print(listA[count]*listB[count])
elif listOP[count]=="/":
print(listA[count]//listB[count])
else:
print("ERROR")
count+=1
| 1 | 669,090,411,132 | null | 47 | 47 |
MOD = 10**9 + 7
def modpow(a: int, p: int, mod: int) -> int:
# return a**p (mod MOD) O(log p)
res = 1
while p > 0:
if p & 1 > 0:
res = res * a % mod
a = a**2 % mod
p >>= 1
return res
def comb(N, x):
numerator = 1
for i in range(N-x+1, N+1):
numerator = numerator * i % MOD
denominator = 1
for j in range(1, x+1):
denominator = denominator * j % MOD
d = modpow(denominator, MOD-2, MOD)
return numerator * d
n,a,b=map(int,input().split())
ans = (modpow(2,n,MOD)-1 - comb(n,a) - comb(n,b)) % MOD
print(ans) | n, a, b = map(int, input().split())
mod = 10**9+7
ans = pow(2, n, mod) - 1
up = 1
bo = 1
for i in range(b):
up = up*(n-i)%mod
bo = bo*(i+1)%mod
if i == a-1:
acombs = up*pow(bo, mod-2, mod)%mod
bcombs = up*pow(bo, mod-2, mod)%mod
print((ans - acombs - bcombs)%mod)
| 1 | 66,010,505,260,348 | null | 214 | 214 |
from collections import deque
d = deque()
for a in range(int(input())):
com = input().split()
if com[0] == "insert":
d.appendleft(com[1])
elif com[0] == "delete":
if com[1] in d:
d.remove(com[1])
elif com[0] == "deleteFirst":
d.popleft()
elif com[0] == "deleteLast":
d.pop()
else:
break
print(*d)
| N = int(input())
A = list(map(int, input().split()))
ans = 0
h = A[0]
for a in A:
if h > a:
ans += h - a
else:
h = a
print(ans) | 0 | null | 2,287,041,704,806 | 20 | 88 |
def main():
x = input()
x1, x2, x3 = x.split(' ')
a = int(x1)
b = int(x2)
c = int(x3)
if a < b < c:
print("Yes")
else:
print("No")
if __name__ == "__main__":
main() | from collections import deque
n = int(input())
que = deque()
for _ in range(n):
cmd = input()
if cmd == 'deleteFirst':
try:
que.popleft()
except:
pass
elif cmd == 'deleteLast':
try:
que.pop()
except:
pass
else:
cmd, x = cmd.split()
if cmd == 'insert':
que.appendleft(x)
elif cmd == 'delete':
try:
que.remove(x)
except:
pass
print(*que)
| 0 | null | 224,612,251,680 | 39 | 20 |
#AGC039-A Connection and Disconnection
"""
sをk回繰り返して得られる文字列tを、全て隣り合う文字が異なるようにする
為に必要な操作回数を求めよ
解法：
最初と最後だけ愚直にカウント
あとは中間部分を連結してそれをk-1回繰り返す
"""
import sys
readline = sys.stdin.buffer.readline
def even(n): return 1 if n%2==0 else 0
s = readline().rstrip().decode('utf-8')
k = int(readline())
first = 0
last = 0
l = 0
r = len(s)
#全部同じ文字だとまずい
if len(set(s)) == 1:
print(len(s)*k//2)
exit()
if s[0] == s[-1]:
res = s[0]
for idx,i in enumerate(s):
if i == res:
first += 1
else:
l = idx
break
res = s[-1]
for idx,i in enumerate(s[::-1]):
if i == res:
last += 1
else:
r = len(s)-idx
break
count = 0
res = ""
for i in s[l:r]:
if res == "":
res = i
elif res == i:
count += 1
res = ""
else:
res = i
print(first//2+last//2+(first+last)//2*(k-1)+count*k) | scores = []
while True:
a_score = [int(x) for x in input().split( )]
if a_score[0] == a_score[1] == a_score[2] == -1:
break
else:
scores.append(a_score)
for s in scores:
m,f,r = [int(x) for x in s]
if m == -1 or f == -1:
print('F')
elif m + f >= 80:
print('A')
elif m + f >= 65:
print('B')
elif m + f >= 50 or r >= 50:
print('C')
elif m + f >= 30:
print('D')
else:
print('F')
| 0 | null | 88,573,431,103,940 | 296 | 57 |
n=int(input())
a=list(map(int,input().split()))
t=1
for i in range(n):
if a[i]%2==0 and a[i]%3==0:
t=1
elif a[i]%2==0 and a[i]%5==0:
t=1
elif a[i]%2==1:
t=1
else:
t=0
break
if t==1:
print("APPROVED")
else:
print("DENIED")
| #155_B
n = int(input())
a = list(map(int, input().split()))
judge = True
for i in range(n):
if a[i]%2 == 0:
if a[i]%3 != 0 and a[i]%5 != 0:
judge = False
break
if judge:
print('APPROVED')
else:
print('DENIED') | 1 | 69,199,568,696,218 | null | 217 | 217 |
import sys
def check(x_list, f, r, v):
x_list[f][r] += v
def peo(x_list):
for i in range(3):
for j in range(10):
sys.stdout.write(" %d" %(x_list[i][j]))
print ("")
A_bill = [[0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0]]
B_bill = [[0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0]]
C_bill = [[0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0]]
D_bill = [[0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0]]
n = input()
for i in range(n):
x = raw_input()
b, f, r, v = x.split()
b = int(b)
f = int(f)
r = int(r)
v = int(v)
if b == 1:
check(A_bill, f-1,r-1,v)
elif b == 2:
check(B_bill, f-1,r-1,v)
elif b == 3:
check(C_bill, f-1,r-1,v)
elif b == 4:
check(D_bill, f-1,r-1,v)
peo(A_bill)
print("####################")
peo(B_bill)
print("####################")
peo(C_bill)
print("####################")
peo(D_bill) | N= int(input())
n = N % 10
if n == 2 or n==4 or n ==5 or n == 7 or n == 9:
print('hon')
elif n == 0 or n ==1 or n == 6 or n == 8:
print('pon')
elif n == 3:
print('bon') | 0 | null | 10,216,341,008,642 | 55 | 142 |
from sys import stdin,stdout
import bisect
import math
def st():
return list(stdin.readline().strip())
def inp():
return int(stdin.readline())
def li():
return list(map(int,stdin.readline().split()))
def mp():
return map(int,stdin.readline().split())
def pr(n):
stdout.write(str(n)+"\n")
def soe(limit):
l=[1]*(limit+1)
prime=[]
for i in range(2,limit+1):
if l[i]:
for j in range(i*i,limit+1,i):
l[j]=0
for i in range(2,limit+1):
if l[i]:
prime.append(i)
return prime
def segsoe(low,high):
limit=int(high**0.5)+1
prime=soe(limit)
n=high-low+1
l=[0]*(n+1)
for i in range(len(prime)):
lowlimit=(low//prime[i])*prime[i]
if lowlimit<low:
lowlimit+=prime[i]
if lowlimit==prime[i]:
lowlimit+=prime[i]
for j in range(lowlimit,high+1,prime[i]):
l[j-low]=1
for i in range(low,high+1):
if not l[i-low]:
if i!=1:
print(i)
def power(a,n):
r=1
while n:
if n&1:
r=(r*a)
a*=a
n=n>>1
return r
def solve():
s=input()
n=len(s)
a=s[:(n-1)//2]
b=a[::-1]
c=s[(n+3)//2 -1 :]
d=c[::-1]
if s==s[::-1] and a==b and c==d:
print("Yes")
else:
print("No")
for _ in range(1):
solve()
| n, m = map(int,input().split())
a = list(map(int,input().split()))
i = 0
s = 0
sum = sum(a)
for i in range(n):
if a[i]/sum >= 1/(4*m):
s += 1
if s >= m:
print('Yes')
else:
print('No')
| 0 | null | 42,576,229,853,000 | 190 | 179 |
a = str(input())
b = str(input())
if a[:len(a)] == b[:len(a)] and len(b)==len(a)+1:
print("Yes")
else:
print("No") | s = input()
t = input()
for i in range(len(s)):
if not s[i] == t[i]:
print("No")
exit()
print("Yes") | 1 | 21,304,717,984,708 | null | 147 | 147 |
while True:
x, y = map(int, input().split())
if x == 0 and y == 0:
break
if x > y:
x, y = y, x
print(x, y)
| s = raw_input()#,k = map(int, raw_input().split(' '))
print 'Yes ' if len(s) >= 6 and s[2] == s[3] and s[4] == s[5] else 'No' #f(n,k)
| 0 | null | 21,210,375,092,778 | 43 | 184 |
N = int(input())
S = list(input())
Q = int(input())
class Bit:
"""1-indexed"""
def __init__(self, n):
self.size = n
self.tree = [0] * (n + 1)
def sum(self, i):
s = 0
while i > 0:
s += self.tree[i]
i -= i & -i
return s
def add(self, i, x):
while i <= self.size:
self.tree[i] += x
i += i & -i
en2asc = lambda s: ord(s) - 97
Bits = [Bit(N) for _ in range(26)]
for i, s in enumerate(S):
Bits[en2asc(s)].add(i + 1, 1)
for _ in range(Q):
q = input().split()
if q[0] == '1':
i, c = int(q[1]), q[2]
old = S[i - 1]
Bits[en2asc(old)].add(i, -1)
Bits[en2asc(c)].add(i, 1)
S[i - 1] = c
else:
l, r = int(q[1]), int(q[2])
ans = 0
for b in Bits:
ans += bool(b.sum(r) - b.sum(l - 1))
print(ans)
| a, v = map(int, input().split())
b, w = map(int, input().split())
t = int(input())
ans = abs(b - a) - (v - w) * t
if ans > 0:
print('NO')
else:
print('YES')
| 0 | null | 38,838,258,565,050 | 210 | 131 |
a = int(input())
c=0
for i in range(a + 1):
if bool(i%3!=0 and i % 5 != 0):
c += i
print(c) | import sys
def input():
return sys.stdin.readline()[:-1]
def main():
N = int(input())
A = list(map(int,input().split()))
zougen = [-1 if A[i] > A[i + 1] else 1 for i in range(N - 1)]
money = 1000
kabu = 0
for i in range(N-1):
if zougen[i] == 1:
kabu += money // A[i]
money = money % A[i]
else:
money += kabu * A[i]
kabu = 0
print(A[-1] * kabu + money)
if __name__ == "__main__":
main() | 0 | null | 21,073,840,629,352 | 173 | 103 |
from math import log2
print(2 ** int(log2(int(input())) + 1) - 1) | print({'ABC':'ARC', 'ARC':'ABC'}[input()]) | 0 | null | 52,153,834,129,178 | 228 | 153 |
n=int(input())
s=[input() for i in range(n)]
ac=s.count("AC")
wa=s.count("WA")
tle=s.count("TLE")
re=s.count("RE")
print("AC x "+str(ac))
print("WA x "+str(wa))
print("TLE x "+str(tle))
print("RE x "+str(re)) | #import sys
import numpy as np
#input = sys.stdin.readline
def main():
n, k=map(int, input().split())
a=np.array(list(map(int, input().split())), dtype=np.int64)
f=np.array(list(map(int, input().split())), dtype=np.int64)
a=np.sort(a)
f=np.sort(f)[::-1]
l,r=0,10**12
while l<=r:
m=(l+r)//2
tr=np.clip(a-m//f,0,None).sum()
if tr>k:
l=m+1
else:
r=m-1
print(l)
if __name__ == '__main__':
main() | 0 | null | 87,043,948,437,558 | 109 | 290 |
# coding: utf-8
import sys
#from operator import itemgetter
sysread = sys.stdin.buffer.readline
read = sys.stdin.buffer.read
#from heapq import heappop, heappush
#from collections import defaultdict
sys.setrecursionlimit(10**7)
#import math
#from itertools import product, accumulate, combinations, product
#import bisect# lower_bound etc
#import numpy as np
#from copy import deepcopy
#from collections import deque
def sum_count(arr):
mem = arr[:]
while True:
if len(mem) == 1:break
tmp = []
while True:
if len(mem) == 1:
tmp.append(mem[-1])
mem = tmp[:]
break
if len(mem) == 0:
mem = tmp[:]
break
x1, x2 = mem.pop(), mem.pop()
tmp.append(int(x1) + int(x2))
return int(mem[0])
def run():
N = int(input())
X = list(input())[::-1]
lis_bf = []
lis_af = []
count1 = sum_count(X)
sum_val_bf, sum_val_af = 0, 0
if count1 <= 1:
for i in range(N):
tmp_af = 0
if int(X[i]):
tmp_af = pow(2, i, count1 + 1)
lis_af.append(tmp_af)
sum_val_af += tmp_af
sum_val_af %= count1 + 1
for i in list(range(N))[::-1]:
ans = 0
if X[i] == '1':
print(0)
continue
else:
next_val = (sum_val_af + pow(2, i, count1 + 1)) % (count1 + 1)
# print(next_val)
ans += 1
# print(f'i : {i}, next_val : {next_val}')
while True:
if next_val == 0: break
val = next_val
count_n = sum_count(list(bin(val)[2:]))
next_val = val % count_n
ans += 1
# print(f'next_val : {next_val}')
print(ans)
return None
for i in range(N):
tmp_bf, tmp_af = 0,0
if int(X[i]):
tmp_bf = pow(2, i , count1-1)
tmp_af = pow(2, i, count1+1)
lis_bf.append(tmp_bf)
lis_af.append(tmp_af)
sum_val_bf += tmp_bf
sum_val_bf %= count1-1
sum_val_af += tmp_af
sum_val_af %= count1 + 1
for i in list(range(N))[::-1]:
ans = 0
if X[i] == '1':
next_val = (sum_val_bf - lis_bf[i]) % (count1-1)
else:
next_val = (sum_val_af + pow(2, i, count1+1)) % (count1+1)
#print(next_val)
ans += 1
#print(f'i : {i}, next_val : {next_val}')
while True:
if next_val == 0:break
val = next_val
count_n = sum_count(list(bin(val)[2:]))
next_val = val % count_n
ans += 1
#print(f'next_val : {next_val}')
print(ans)
if __name__ == "__main__":
run()
| #D
N=int(input())
X=str(input())
CNT=0
for i in range(N):
if X[i]=="1":
CNT+=1
NUM=int(X,2)
to0_cnt=[0 for i in range(N)]
for i in range(1,N):
ans=0
num=i
while True:
cnt=0
for j in bin(num)[2:]:
if j=="1":
cnt+=1
if cnt==0:
break
r=num%cnt
ans+=1
if r==0:
break
num=r
to0_cnt[i]=ans
R=[NUM%(CNT+1),NUM%(CNT-1) if CNT!=1 else 0]
for i in range(N):
if X[i]=="0":
cnt=CNT+1
r=(R[0]+pow(2,N-i-1,cnt))%cnt
else:
cnt=CNT-1
if NUM-pow(2,N-i-1)==0:
print(0)
continue
r=(R[1]-pow(2,N-i-1,cnt))%cnt
ans=1+to0_cnt[r]
print(ans) | 1 | 8,209,931,530,070 | null | 107 | 107 |
import sys
import collections
input = sys.stdin.readline
MOD = 998244353
def main():
N = int(input())
D = list(map(int, input().split()))
if D[0] != 0:
print(0)
return
D.sort()
Dmax = max(D)
Ditems = collections.Counter(D).items()
Dcount = list(zip(*Ditems))
Dset = set(Dcount[0])
if Dset != set(range(Dmax+1)):
print(0)
return
if Dcount[1][0] != 1:
print(0)
return
ans = 1
for i in range(2, Dmax+1):
ans *= pow(Dcount[1][i-1], Dcount[1][i], MOD)
ans %= MOD
print(ans%MOD)
if __name__ == "__main__":
main()
| n = int(input())
s = input()
a = s.split()
def value(a, i):
return int(a[i][-1])
def isstable(s, a, n):
for i in range(n - 1):
if value(a, i) == value(a, i + 1):
v1 = s.index(a[i])
v2 = s.index(a[i + 1])
if v1 > v2:
return "Not stable"
return "Stable"
for i in range(n - 1):
for j in range(i + 1, n)[::-1]:
if value(a, j) < value(a, j - 1):
a[j], a[j - 1] = a[j - 1], a[j]
print(" ".join(a))
print(isstable(s.split(), a, n))
a = s.split()
for i in range(n - 1):
minj = i
for j in range(i + 1, n):
if value(a, j) < value(a, minj):
minj = j
a[i], a[minj] = a[minj], a[i]
print(" ".join(a))
print(isstable(s.split(), a, n))
| 0 | null | 77,633,374,001,260 | 284 | 16 |
N=str(input())
NN=0
for i in range(len(N)):
NN=NN+int(N[i])
if NN%9==0:print('Yes')
else:print('No') | # coding:UTF-8
import sys
from math import factorial
MOD = 998244353
INF = 10000000000
def main():
n, k = list(map(int, input().split())) # スペース区切り連続数字
lrList = [list(map(int, input().split())) for _ in range(k)] # スペース区切り連続数字(行列)
s = []
for l, r in lrList:
for i in range(l, r+1):
s.append(i)
s.sort()
sum = [0] * (n + 1)
Interm = [0] * (2 * n + 1)
sum[1] = 1
for i in range(1, n):
for j in range(k):
l, r = lrList[j][0], lrList[j][1]
Interm[i+l] += sum[i]
Interm[i+r+1] -= sum[i]
sum[i+1] = (sum[i] + Interm[i+1]) % MOD
# result = Interm[n]
result = (sum[n] - sum[n-1]) % MOD
# ------ 出力 ------#
print("{}".format(result))
if __name__ == '__main__':
main()
| 0 | null | 3,577,817,388,012 | 87 | 74 |
def ok(P):
cnt = 0
truck = 0
for w in W + [0]:
if w > P:
return False
if truck + w <= P:
truck += w
else:
truck = w
cnt += 1
if cnt + 1 <= K:
return True
else:
return False
N, K = map(int, input().split())
W = [int(input()) for _ in range(N)]
l, r = 0, 10**10
while r - l > 1:
c = (l + r) // 2
if ok(c):
r = c
else:
l = c
print(r)
| import sys
from collections import deque
d = deque()
n = int(input())
lines = sys.stdin.readlines()
for i in range(n):
ins = lines[i].split()
command = ins[0]
if command == "insert":
d.appendleft(ins[1])
elif command == "delete":
try:
d.remove(ins[1])
except:
pass
elif command == "deleteFirst":
d.popleft()
elif command == "deleteLast":
d.pop()
print(" ".join(d)) | 0 | null | 69,118,510,940 | 24 | 20 |
def resolve():
N = int(input())
X = [int(x) for x in input().split(" ")]
min_X = min(X)
max_X = max(X)
# sigma(Xi-P) = X**2 - 2*Xi*P + P**2
sum_of_x = sum(X)
sum_of_squared = 0
for x in X:
sum_of_squared += x**2
temp_sum_of_cost = sum_of_squared - 2 * min_X * sum_of_x + N * min_X**2
for p in range(min_X, max_X+1):
sum_of_cost = sum_of_squared - 2 * p * sum_of_x + N * p**2
if sum_of_cost < temp_sum_of_cost:
temp_sum_of_cost = sum_of_cost
print(temp_sum_of_cost)
if __name__ == "__main__":
resolve() | import numpy as np
import queue
H,W=map(int,input().split())
S=list()
for i in range(H):
S.append(input())
ans=0
for i in range(H):
for j in range(W):
if S[i][j]==".":
L=[[-1]*W for i in range(H)]
L[i][j]=0
q=queue.Queue()
q.put([i,j])
while not q.empty():
r=q.get()
for k,l in [[1,0],[0,-1],[0,1],[-1,0]]:
if r[0]+k>=0 and r[0]+k<H and r[1]+l>=0 and r[1]+l<W and S[r[0]+k][r[1]+l]=="." and L[r[0]+k][r[1]+l]==-1:
L[r[0]+k][r[1]+l]=L[r[0]][r[1]]+1
q.put([r[0]+k,r[1]+l])
ans=max(ans,max(list(map(lambda x:max(x),L))))
print(ans)
| 0 | null | 80,223,505,561,148 | 213 | 241 |
n,*a=map(int,open(0).read().split())
b=[0]*n
for i in range(n):
b[a[i]-1]=str(i+1)
print(' '.join(b)) | class UnionFind():
def __init__(self,n):
self.n=n
self.root=[-1]*n
self.rank=[-1]*n
def Find_Root(self,x):
if self.root[x]<0:return x
else:
self.root[x]=self.Find_Root(self.root[x])
return self.root[x]
def Unite(self,x,y):
x=self.Find_Root(x)
y=self.Find_Root(y)
if x==y:return
elif self.rank[x]>self.rank[y]:
self.root[x] +=self.root[y]
self.root[y]=x
else:
self.root[y] +=self.root[x]
self.root[x]=y
if self.rank[x]==self.rank[y]:
self.rank[y] +=1
def isSameGroup(self,x,y):
return self.Find_Root(x)==self.Find_Root(y)
def size(self,x):
return -self.root[self.Find_Root(x)]
def members(self,x):
root=self.Find_Root(x)
return [i for i in range(self.n) if self.Find_Root(i)==root]
def roots(self):
return[i for i,j in enumerate(self.root) if j<0]
def group_members(self):
return {i:self.members(i) for i in self.roots()}
def group_count(self):
return len(self.roots())
N,K=map(int,input().split())
P=list(map(int,input().split()))
C=list(map(int,input().split()))
UnionFind=UnionFind(N+1)
for i in range(N):
UnionFind.Unite(i+1,P[i])
D=UnionFind.group_members()
E=[]
for i in D:
A,length=D[i],len(D[i])
if A[0]==0:continue
index,F=A[0]-1,[]
while len(F)!=length:
index=P[index]-1
F.append(C[index])
E.append(F)
ans=-float("inf")
for A in E:
length=len(A)
if sum(A)<0:
A=A*2
for i in range(length):
point=0
for j in range(min(K,length)):
point +=A[i+j]
ans=max(ans,point)
else:
div,mod=divmod(K,length)
base=(div-1)*sum(A)
A=A*3
for i in range(length):
point=0
for j in range(mod+length):
point +=A[i+j]
ans=max(ans,base+point)
print(ans) | 0 | null | 93,512,006,643,872 | 299 | 93 |
n=int(input())
slist=[]
tlist=[]
ans=0
yn=0
for i in range(n):
s,t=input().split()
slist.append(s)
tlist.append(int(t))
x=input()
for i in range(n):
if yn==1:
ans+=tlist[i]
if x==slist[i]:
yn=1
print(ans)
| N = int(input())
name=[""]*N
time=[0]*N
for i in range(N):
a=input()
name[i]=a.split()[0]
time[i]=int(a.split()[1])
print(sum(time[name.index(input())+1:])) | 1 | 97,030,609,195,840 | null | 243 | 243 |
# 初期入力
r = int(input())
#mennseki_r =3.14*r*r
#mennseki_1 =3.14*1*1
#kotae =int(mennseki_r / mennseki_1)
kotae=r*r
print(kotae) | r = int(input())
ans = r * r
print(ans) | 1 | 145,388,900,565,860 | null | 278 | 278 |
n = int(input())
for i in range(1,n+1):
x = i
if x % 3 == 0:
print('', i, end='')
else:
while True:
if x % 10 == 3:
print('', i, end='')
break
x //= 10
if x == 0:
break
print() | n = int(raw_input())
print "",
for e in [i for i in range(1,n+1) if i%3==0 or str(i).count('3')>0]: print e, | 1 | 933,501,535,298 | null | 52 | 52 |
import sys
sys.setrecursionlimit(10**6)
from math import floor,ceil,sqrt,factorial,log
mod = 10 ** 9 + 7
inf = float('inf')
ninf = -float('inf')
#整数input
def ii(): return int(sys.stdin.readline().rstrip()) #int(input())
def mii(): return map(int,sys.stdin.readline().rstrip().split())
def limii(): return list(mii()) #list(map(int,input().split()))
def lin(n:int): return [ii() for _ in range(n)]
def llint(n: int): return [limii() for _ in range(n)]
#文字列input
def ss(): return sys.stdin.readline().rstrip() #input()
def mss(): return sys.stdin.readline().rstrip().split()
def limss(): return list(mss()) #list(input().split())
def lst(n:int): return [ss() for _ in range(n)]
def llstr(n: int): return [limss() for _ in range(n)]
#本当に貪欲法か？ DP法では？？
#本当に貪欲法か？ DP法では？？
#本当に貪欲法か？ DP法では？？
h,w=mii()
mat=[list(ss()) for _ in range(h)]
chk=[[0]*w for _ in range(h)]
for i in range(h):
for j in range(w):
if i==0:
if j==0:
if mat[i][j]=="#":
chk[i][j]+=1
else:
if mat[i][j]!=mat[i][j-1] and mat[i][j]=="#":
chk[i][j]=chk[i][j-1]+1
else:
chk[i][j]=chk[i][j-1]
else:
if j==0:
if mat[i][j]!=mat[i-1][j] and mat[i][j]=="#":
chk[i][j]=chk[i-1][j]+1
else:
chk[i][j]=chk[i-1][j]
else:
if mat[i][j]==mat[i-1][j] and mat[i][j]==mat[i][j-1]:
chk[i][j]=min(chk[i-1][j],chk[i][j-1])
elif mat[i][j]!=mat[i-1][j] and mat[i][j]==mat[i][j-1] and mat[i][j]=="#":
chk[i][j]=min(chk[i-1][j]+1,chk[i][j-1])
elif mat[i][j]!=mat[i][j-1] and mat[i][j]==mat[i-1][j] and mat[i][j]=="#":
chk[i][j]=min(chk[i-1][j],1+chk[i][j-1])
elif mat[i][j]=="#":
chk[i][j]=min(chk[i-1][j]+1,1+chk[i][j-1])
else:
chk[i][j]=min(chk[i-1][j],chk[i][j-1])
print(chk[-1][-1])
#print(chk) | N, K = map(int, input().split())
p = map(int, input().split())
print(sum(sorted(p)[:K])) | 0 | null | 30,472,360,982,958 | 194 | 120 |
#!/usr/bin/env python3
def main():
A, B, C, D = map(int, input().split())
print('Yes' if - (-A // D) >= -(-C // B) else 'No')
if __name__ == '__main__':
main()
| # -*- coding: utf-8 -*-
A, B, C, D = map(int, input().split())
i = 0
while A > 0 and C > 0:
i += 1
if i % 2 == 1:
# 高橋くんの攻撃
C -= B
else:
# 青木くんの攻撃
A -= D
if C <= 0:
print("Yes")
else:
print("No") | 1 | 29,641,684,790,770 | null | 164 | 164 |
a,b,c,k=map(int,input().split())
ans=a
if a>k: ans=k
if a+b<k: ans-=(k-(a+b))
print(ans)
| n,a,b = map(int,input().split())
if (b - a)%2 == 0:
x = (b - a)//2
y = min(max(a-1,b-1),max(n-a,n-b))
print(min(x,y))
else:
p = max(a-1,b-1)
q = max(n-a,n-b)
r = a-1+1+(b-(a-1)-1-1)//2
s = n-b+1+(n-(n-b+1)-a)//2
#print(p,q,r,s)
print(min(p,q,r,s)) | 0 | null | 65,813,153,745,004 | 148 | 253 |
# -*- coding: utf-8 -*-
"""
コッホ曲線
参考：https://www.mynote-jp.com/entry/2016/04/30/201249
https://atarimae.biz/archives/23930
・回転行列を使うと、向きの変わった座標が出せる。
・そのために行列の計算方法も確認。
→m行n列成分は、「左の行列のm行目」と「右の行列のn列目」の内積
"""
from math import sin, cos, radians
N = int(input())
def dfs(p1x, p1y, p2x, p2y, depth):
if depth == N:
return
sx = p1x + (p2x-p1x)/3
tx = p1x + (p2x-p1x)/3*2
sy = p1y + (p2y-p1y)/3
ty = p1y + (p2y-p1y)/3*2
# s,tを基準の位置として左回りに60度回転させる
ux = sx + (tx-sx) * cos(radians(60)) - (ty-sy) * sin(radians(60))
uy = sy + (tx-sx) * sin(radians(60)) + (ty-sy) * cos(radians(60))
# 再帰が終了した場所から出力していけば、線分上の各頂点の順番になる
dfs(p1x, p1y, sx, sy, depth+1)
print(sx, sy)
dfs(sx, sy, ux, uy, depth+1)
print(ux, uy)
dfs(ux, uy, tx, ty, depth+1)
print(tx, ty)
dfs(tx, ty, p2x, p2y, depth+1)
print(0, 0)
dfs(0, 0, 100, 0, 0)
print(100, 0)
| def solve():
s, t = input().split()
print(t+s)
if __name__ == '__main__':
solve()
| 0 | null | 51,717,456,829,732 | 27 | 248 |
N=int(input());a=0
for i in range(1,N + 1):b=N//i;a+=(b*(b+1)*i//2)
print(a)
| import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
from collections import deque
sys.setrecursionlimit(10**7)
inf = 10**20
mod = 10**9 + 7
DR = [1, -1, 0, 0]
DC = [0, 0, 1, -1]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
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 main():
n = I()
ans = 0
N = 10**7 + 1
prime = [True] * N
prime[1] = False
n_yaku = [1] * N
min_prime = [1] * N
for i in range(2, N):
if not prime[i]:
continue
n_yaku[i] = 2
min_prime[i] = i
num = i + i
while num < N:
min_prime[num] = i
prime[num] = False
num += i
for i in range(2, N):
if prime[i]:
continue
j = i
cnt = 0
while j % min_prime[i] == 0:
# print('j: ', j)
# print('prime: ', min_prime[i])
j //= min_prime[i]
cnt += 1
n_yaku[i] = n_yaku[j] * (cnt + 1)
ans = 0
for i in range(1, n+1):
ans += i * n_yaku[i]
print(ans)
main()
| 1 | 10,908,203,557,470 | null | 118 | 118 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.