code1
stringlengths 17
427k
| code2
stringlengths 17
427k
| similar
int64 0
1
| pair_id
int64 2
181,637B
⌀ | question_pair_id
float64 3.7M
180,677B
⌀ | code1_group
int64 1
299
| code2_group
int64 1
299
|
|---|---|---|---|---|---|---|
N=input()
N=int(N)
q1, mod = divmod(N,2)
if mod == 0:
print(q1)
else:
print(q1 + 1) | #B
A, B, C, D=map(int, input().split())
A_survive=0
C_survive=0
while A>0:
A-=D
A_survive+=1
while C>0:
C-=B
C_survive+=1
if A_survive >= C_survive:
print('Yes')
else:
print('No') | 0 | null | 44,351,893,220,242 | 206 | 164 |
N = int(input())
A = list(map(int, input().split()))
if A[0] == 1:
if len(A) > 1:
print(-1)
exit()
else:
print(1)
exit()
elif A[0] > 1:
print(-1)
exit()
S = [0] * (N + 2)
for i in range(N, -1, -1):
S[i] = S[i + 1] + A[i]
sec = [0] * (N + 1)
sec[0] = 1
for i in range(1, N + 1):
a = A[i]
v = sec[i - 1] * 2
if v < a:
print(-1)
exit()
sec[i] = min(v - a, S[i + 1])
print(sum(A) + sum(sec[:-1]))
# print(sec)
# print(A) | N,K = map(int,input().split())
li = []
count = 0
for i in range(K):
d = int(input())
a = list(map(int,input().split()))
for j in range(d):
li.append(a[j])
for i in range(N):
if i+1 not in li:
count += 1
print(count) | 0 | null | 21,675,817,992,070 | 141 | 154 |
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)
| s = list(input())
if s.count('R') == 3:
print(3)
elif s.count('R') == 1:
print(1)
elif s.count('R') == 0:
print(0)
else:
if s[1] == 'R':
print(2)
else:
print(1) | 0 | null | 69,634,655,454,286 | 271 | 90 |
from decimal import *
import math
a, b, c = list(map(int, input().split()))
print('Yes' if c - a - b> 0 and 4*a*b < (c - a - b)**2 else 'No') | from decimal import Decimal
a, b, c = [Decimal(x) for x in input().split()]
result = a.sqrt() + b.sqrt() < c.sqrt()
print('Yes' if result else 'No') | 1 | 51,635,523,365,452 | null | 197 | 197 |
import sys
a=[]
for t in range(4):
a.append([])
for f in range(3):
a[t].append([])
for r in range(10):
a[t][f].append(0)
lines = [line for line in sys.stdin]
n = lines[0]
for l in lines[1:]:
b, f, r, v = map(int,l.split())
b -= 1
f -= 1
r -= 1
a[b][f][r] += v
for i,t in enumerate(a):
for f in t:
print (" " +" ".join(map(str,f)))
if len(a) != i +1:
print ('#'*20) | print("".join([" " + str(i) for i in range(1, int(input()) + 1) if i % 3 == 0 or '3' in str(i)]))
| 0 | null | 1,022,769,099,362 | 55 | 52 |
from bisect import bisect_left,insort_left
n=int(input())
s=list(input())
lindex=[[] for _ in range(26)]
for i in range(n):
lindex[ord(s[i])-97].append(i)
q=int(input())
for i in range(q):
q1,q2,q3=input().split()
if q1=='1':
q2=int(q2)-1
idx=bisect_left(lindex[ord(s[q2])-97],q2)
if s[q2]!=q3:
del lindex[ord(s[q2])-97][idx]
insort_left(lindex[ord(q3)-97],q2)
s[q2]=q3
else:
l=int(q2)-1
r=int(q3)-1
cnt=0
for j in range(26):
if len(lindex[j])==0:
continue
idx=bisect_left(lindex[j],l)
if len(lindex[j])>idx and lindex[j][idx]<=r:
cnt+=1
print(cnt) | T=input()
print(T.replace('?','D')) | 0 | null | 40,560,893,692,800 | 210 | 140 |
r, c = list(map(int, input().split(' ')))
matrix = []
for i in range(r):
matrix.append(input())
ans = 0
cost = {} # cost[(i, j), (p, q)] -> (i,j) -> (p,q) の minコスト (20 * 20 * 20 * 20 = 1.6 * 1e4)
for i in range(r):
for j in range(c):
if matrix[i][j] == '#': # !!!
continue
start = (i, j)
cost[(i,j), (i,j)] = 0
q = [start]
while q:
ti, tj = q.pop(0)
for ni, nj in [(ti-1, tj), (ti, tj-1), (ti+1, tj), (ti, tj+1)]:
if ni < 0 or nj < 0 or ni >= r or nj >= c or matrix[ni][nj] == '#':
continue
if cost.get(((i,j), (ni, nj)), 99999999999999999) > cost[(i,j), (ti, tj)] + 1:
cost[(i,j), (ni, nj)] = cost[(i,j), (ti, tj)] + 1
ans = max(ans, cost[(i,j), (ni, nj)])
#print('i,j = ', (i,j), 'ni,nj = ', (ni,nj), 'ans = ', cost[(i,j), (ni, nj)])
q.append((ni, nj))
print(ans) | from collections import deque
from copy import deepcopy
# 初期入力
import sys
input = sys.stdin.readline
H,W = (int(i) for i in input().split())
map_initial =[["#"]*(W+2) for i in range(H+2)] #周囲を壁にするため＋２
for h in range(1,H+1):
map_initial[h] =["#"] +list(input().strip()) +["#"]
def BSF(x,y):
dist =0
map =deepcopy(map_initial)
if map[x][y] =="#":
return dist
dq =set()
dq.add((x,y))
dq_sarch =set()
while len(dq) >0:
h,w =dq.pop()
map[h][w] ="#" #通り済を壁にする
if map[h+1][w]==".":
dq_sarch.add((h+1,w))
if map[h-1][w]==".":
dq_sarch.add((h-1,w))
if map[h][w+1]==".":
dq_sarch.add((h,w+1))
if map[h][w-1]==".":
dq_sarch.add((h,w-1))
if len(dq)==0:
dq =deepcopy(dq_sarch)
dq_sarch.clear()
dist +=1
#print(h,w,dist,end="\t")
return dist-1
#スタート位置を全探索し、最長距離を探す
dist_all =[]
for i in range(1,H+1):
for j in range(1,W+1):
dist_all.append(BSF(i,j) )
print(max(dist_all)) | 1 | 94,629,042,943,448 | null | 241 | 241 |
a,b,c = map(int,input().split())
tmp = a
a = b
b = tmp
tmp = a
a = c
c = tmp
print(a,b,c) | n = int(input())
fact={}
i = 2
while n != 1:
if n % i == 0:
n = n/i
if i in fact:
fact[i] += 1
else:
fact[i] = 1
else:
i += 1
if i > (n**(1/2)+1):
if n in fact:
fact[n] += 1
else:
fact[n] = 1
break
if fact == {}:
print(0)
else:
ans = 0
for v in fact.values():
#print(v)
for i in range(1,v+1):
if v - i >= 0:
ans +=1
v = v-i
print(ans) | 0 | null | 27,572,191,799,670 | 178 | 136 |
N = int(input())
cnt = 0
for i in range(1,N//2 + 1):
if N - i != i:
cnt += 1
print(cnt) | def resolve():
N = int(input())
S = str(input())
print(S.count('ABC'))
return
resolve() | 0 | null | 126,669,466,926,310 | 283 | 245 |
n, q = map(int, input().split(' '))
L = []
i = 0
while i < n:
name, time = map(str, input().split(' '))
L.append([name, int(time)])
i += 1
t = 0
fin = []
while len(L) != 0:
if L[0][1] > q:
t += q
name = L[0][0]
time = L[0][1] - q
L.append([name, time])
L.pop(0)
else:
t += L[0][1]
name = L[0][0]
time = t
fin.append([name, time])
L.pop(0)
ans = ''
for f in fin:
ans += f[0] + ' ' + str(f[1]) + '\n'
print(ans[:-1])
| def Queue(l, nowtime, sec):
if len(l) == 1:
print(l[0][0], nowtime + l[0][1])
return [], 0
else:
tl = l.pop(0)
if tl[1] <= sec:
nowtime += tl[1]
print(tl[0], nowtime)
return l, nowtime
else:
nowtime += sec
l.append([tl[0], tl[1] - sec])
return l, nowtime
if __name__ == '__main__':
N, sec = input().split()
N, sec = int(N), int(sec)
lists = list()
for i in range(N):
obj, times = input().split()
lists.append([obj, int(times)])
now = 0
while lists:
lists, now = Queue(lists, now, sec)
| 1 | 42,620,387,040 | null | 19 | 19 |
a = list(map(int, input().split()))
sum_a = sum(a)
if sum_a >= 22:
print('bust')
else:
print('win') | # ABC149
# A Blackjack
A = list(map(int, input().split()))
a = sum(A)
if a > 21:
print("bust")
else:
print("win")
| 1 | 118,551,432,334,918 | null | 260 | 260 |
S = input()
if len(S)//2 * "hi" == S:
print("Yes")
else:
print("No") | s = input().split("hi")
f = 0
for i in s:
if i != "":
f = 1
break
if f == 0:
print("Yes")
else:
print("No") | 1 | 53,050,223,463,222 | null | 199 | 199 |
import math
x, k, d = map(int, input().split())
x = abs(x)
straight = min(k, math.floor(x / d))
k -= straight
x -= straight * d
if(k % 2 == 0):
print(x)
else:
print(abs(x - d)) | def solve(string):
x, k, d = map(int, string.split())
x = abs(x)
if k % 2:
x = min(x - d, x + d, key=abs)
k -= 1
k, d = k // 2, d * 2
if x < k * d:
return str(min(x % d, abs((x % d) - d)))
else:
return str(x - k * d)
if __name__ == '__main__':
import sys
print(solve(sys.stdin.read().strip()))
| 1 | 5,263,612,978,790 | null | 92 | 92 |
(X,N) = map(int,input().split())
if N == 0:
print(X)
else:
p = list(map(int,input().split()))
for i in range(N+1):
if (X - i) not in p:
print(X-i)
break
elif(X+i) not in p:
print(X+i)
break | X, N = map(int, input().split()) #6,5
p = list(map(int, input().split())) #[4,7,10,6,5]
q = [(abs(X-i),i) for i in range(0,102) if not i in p]
q.sort()
print(q[0][1]) | 1 | 14,069,807,104,068 | null | 128 | 128 |
import sys
N, D = map(int,input().split())
X = [0]*N
Y = [0]*N
for i in range(N):
X[i], Y[i] = map(int,input().split())
def solve():
ret = 0
for i in range(N):
if X[i]*X[i]+Y[i]*Y[i] <= D*D:
ret += 1
return ret
print(solve()) |
count = 0
n, d = map(int, input().split())
for _ in range(n):
l, m = map(int, input().split())
z = (l ** 2 + m ** 2) ** 0.5
if z <= d:
count += 1
print(count)
| 1 | 5,937,866,550,430 | null | 96 | 96 |
ma = lambda :map(int,input().split())
ni = lambda:int(input())
import collections
import math
import itertools
gcd = math.gcd
n = ni()
A = list(ma())
tot = 0
for a in A:
tot = tot^a
ans = []
for a in A:
ans.append(tot^a)
print(*ans)
| import math
while True:
n = int(input())
if n == 0: break
s = list(map(int,input().split()))
dis = 0
mean = sum(s)
mean /= n
for s in s:
dis += (s-mean)**2
print('{0:.5f}'.format(math.sqrt(dis/n)))
| 0 | null | 6,356,948,417,252 | 123 | 31 |
n = int(input())
print(int(n/2+0.9))
| n = int(input())
if (n%2 == 1):
n = n + 1
print(int(n/2)) | 1 | 59,185,423,650,820 | null | 206 | 206 |
import itertools
##print(ord("A"))
a,b,= map(int,input().split())
ans= a-b*2
if ans <=0:
print(0)
else:
print(ans) | def power_set(A, s):
if len(A) == 0:
return {s}
else:
return power_set(A[1:], s) | power_set(A[1:], s+A[0])
def main():
n = int(input())
A = input()
#print(n)
A = list(map(int, A.split()))
q = int(input())
m = input()
ms = list(map(int, m.split()))
powerset = power_set(A, 0)
for m in ms:
if m in powerset:
print('yes')
else:
print('no')
if __name__ == '__main__':
main() | 0 | null | 83,377,191,198,840 | 291 | 25 |
n = int(raw_input())
a = []
a.append(int(raw_input()))
Min = a[0]
Max = -1*10**9
for j in range(1,n):
a.append(int(raw_input()))
Max = max(Max,a[j]-Min)
Min = min(Min,a[j])
print Max | #coding: utf-8
n = int(input())
R = []
#input_value?????????
for i in range(n):
R.append(int(input()))
max_dif = -2000000000
min_value = R[0]
for i in range(1, n):
max_dif = max(max_dif, R[i] - min_value)
min_value = min(min_value, R[i])
print(max_dif) | 1 | 13,280,430,022 | null | 13 | 13 |
A, B, K = map(int, input().split())
if A + B == 0:
print(0, 0)
elif A - K >= 0:
print(A-K, B)
elif A + B- K >= 0:
print(0, A+B-K)
else:
print(0, 0) | input_line = list(map(int,input().split(' ')))
if(input_line[0]>=input_line[2]):
input_line[0] -= input_line[2]
elif((input_line[0]+input_line[1])>=input_line[2]):
input_line[1] -= (input_line[2]-input_line[0])
input_line[0] = 0
else:
input_line[0] = 0
input_line[1] = 0
print(input_line[0],input_line[1])
| 1 | 104,141,887,421,692 | null | 249 | 249 |
n, k, s = map(int, input().split())
ai = s
ls1 = [ai] * k
for aj in reversed(range(10 ** 9 + 1)):
if aj != ai:
ls2 = [aj] * (n - k)
break
print(" ".join(map(str, (ls1 + ls2)))) | n, k = map(int, input().split())
A = [*map(int, input().split())]
for i in range(n-k): print('Yes' if A[i] < A[i+k] else 'No')
| 0 | null | 48,993,032,655,600 | 238 | 102 |
A,B,K = list(map(int,input().split()))
if A>= K:
print(str(A-K) + ' ' + str(B))
elif A < K :
print(str(0) + ' ' + str(max(B+A-K,0)))
| def solve():
a, b, k = map(int, input().split())
if a > k:
print(a-k, b)
elif a <= k < a+b:
print(0, b-k+a)
else:
print(0, 0)
if __name__ == '__main__':
solve()
| 1 | 103,953,336,631,750 | null | 249 | 249 |
#!/usr/bin/env python3
import sys
from itertools import chain
MAX = 10 ** 18
def solve(N: int, A: "List[int]"):
A = sorted(A)
answer = 1
for a in A:
answer *= a
if answer > MAX:
return -1
return answer
def main():
tokens = chain(*(line.split() for line in sys.stdin))
# N, A = map(int, line.split())
N = int(next(tokens)) # type: int
A = [int(next(tokens)) for _ in range(N)] # type: "List[int]"
answer = solve(N, A)
print(answer)
if __name__ == "__main__":
main()
| n,m = map(int,input().split())
ans="No"
if n==m :
ans="Yes"
print(ans)
| 0 | null | 49,919,183,424,278 | 134 | 231 |
input_str = input()
translate_num = (int(input_str))**3
print(translate_num) | x = input()
print x**3 | 1 | 272,643,701,352 | null | 35 | 35 |
A, B, C, K = map(int, input().split())
sum = 0
if A > K:
print(K)
elif A + B > K:
print(A)
else:
print(A-(K-A-B)) # =(A+B-(K-(A+B))) | A, B, C, K = map(int, input().split())
ans = 0
if A > K:
ans += 1*K
else:
ans += 1*A
K = K - A
if B > K:
ans += 0*K
else:
ans += 0*B
K = K - B
if C > K:
ans += -1*K
else:
ans += -1*C
print(ans)
| 1 | 21,984,275,249,388 | null | 148 | 148 |
h,w,k=map(int,input().split())
cho=[]
for _ in range(h):
a=list(input())
for f in range(w):
a[f]=int(a[f])
cho.append(a)
ans=1000000000009
for i in range(2**(h-1)):
cut=0
cut_n=[]
b=[]
for j in range(h-1):
if (i>>j)&1:
cut_n.append(j+1)
cut+=1
if len(cut_n)==0:
ok=1
dp=0
for i in range(w):
wa=0
for j in range(h):
wa+=cho[j][i]
if dp+wa>k:
cut+=1
dp=wa
else:
dp+=wa
if wa>k:
ok+=1
break
if ok==1:
ans=min(ans,cut)
else:
st=0
for t in range(len(cut_n)):
if t==len(cut_n)-1:
b.append(cut_n[t]-st)
b.append(h-cut_n[t])
else:
b.append(cut_n[t]-st)
st=cut_n[t]
dp=[0 for _ in range(len(b))]
ok=1
for y in range(w):
for g in dp:
if g>k:
ok+=1
break
st=0
ch=0
c=[]
for e in range(len(b)):
p=b[e]
temp=0
for q in range(p):
temp+=cho[st+q][y]
dp[e]+=cho[st+q][y]
c.append(temp)
st+=p
for g in dp:
if g>k:
ch+=1
if ch!=0:
cut+=1
dp=c
for last in c:
if last>k:
ok+=1
if ok==1:
ans=min(ans,cut)
print(ans)
| def main():
H, W, K = map(int, input().split())
chocolate = [list(map(int,list(input()))) for _ in range(H)]
choco = [[0]*W for _ in range(H)]
ids = [0] * H
ans = 10 ** 9
for bit in range(1<<(H-1)):
group_id = 0
for i in range(H):
ids[i] = group_id
if (bit>>i)&1:
group_id += 1
group_id += 1
for i in range(group_id):
for j in range(W):
choco[i][j] = 0
for i in range(H):
for j in range(W):
choco[ids[i]][j] += chocolate[i][j]
if any(choco[i][j] > K for i in range(group_id) for j in range(W)):
continue
num = group_id - 1
now = [0] * group_id
def add(j):
for i in range(group_id):
now[i] += choco[i][j]
if any(now[i] > K for i in range(group_id)):
return False
else:
return True
for j in range(W):
if not add(j):
num += 1
now = [0] * group_id
add(j)
ans = min(ans, num)
print(ans)
if __name__ == "__main__":
main() | 1 | 48,682,197,378,658 | null | 193 | 193 |
n=int(input())
a=list(map(int,input().split()))
d=1
mx=[]
for i in range(n+1):
d-=a[i]
mx.append(d)
d*=2
mx.append(1)
f=mx[n]>=0
d=0
c=0
for i in range(n,-1,-1):
d+=a[i]
c+=d
t=(d+1)//2
if t>mx[i-1]:
f=False
break
d=min(d,mx[i-1])
print(c if f else -1)
| import sys
H = int(next(sys.stdin.buffer))
ans = 0
i = 1
while H > 0:
H //= 2
ans += i
i *= 2
print(ans) | 0 | null | 49,321,710,292,480 | 141 | 228 |
import sys
sys.setrecursionlimit(10000000)
n = int(input())
G = [[] for i in range(n)]
d = [0 for i in range(n)]
f = [0 for i in range(n)]
color = [0 for i in range(n)]
stamp = 0
def dfs(u):
global stamp
if d[u]:
return
stamp += 1
d[u] = stamp
for v in G[u]:
if color[v] != 0:
continue
color[v] = 1
dfs(v)
color[u] = 2
stamp += 1
f[u] = stamp
color[0] = 1
for i in range(n):
inp = list(map(int, input().split()))
u = inp[0]
u -= 1
k = inp[1]
for j in range(k):
v = inp[j+2]
v -= 1
G[u].append(v)
#G[v].append(u)
for i in range(n):
dfs(i)
for i in range(n):
print("{0} {1} {2}".format(i+1, d[i], f[i]))
| import sys
sys.setrecursionlimit(10**9)
from collections import deque
n = int(input())
u = [[] for i in range(n+1)] #隣接リスト
for i in range(n):
v = list(map(int, input().split()))
u[v[0]] = v[1:] #v = [次数, 頂点...]
d = [-1] * (n+1)
f = [-1] * (n+1)
visited = [False] * (n+1)
visited[0] = True
time = 1
#再帰
def dfs(c):
global time
d[c] = time
time += 1
visited[c] = True
for i in range(1, u[c][0]+1):
if not visited[u[c][i]]:
dfs(u[c][i])
f[c] = time
time += 1
"""
探索は元の始点から到達可能なすべての頂点を発見するまで続き、
未発見の頂点が残っていれば、
その中の番号が一番小さい１つを新たな始点として探索を続けます。
"""
while False in visited:
dfs(visited.index(False))
for i in range(1, n+1):
print(i, d[i], f[i])
| 1 | 2,858,157,728 | null | 8 | 8 |
N = int(input())
ans = pow(10, N, mod=1000000007) - pow(9, N, mod=1000000007) - pow(9, N, mod=1000000007) + pow(8, N, mod=1000000007)
ans %= 1000000007
print(ans)
| def paint(h, w):
print("\n".join(["#" * w] * h))
while True:
H, W = map(int, input().split())
if H == W == 0: break
paint(H, W)
print()
| 0 | null | 1,951,548,175,610 | 78 | 49 |
N, M = map(int, input().split())
A = list(map(int, input().split()))
k = sum(A) / (4*M)
print('Yes' if [a >= k for a in A].count(True) >= M else 'No') | n,m=map(int,input().split())
A=list(map(int,input().split()))
ans=0
for i in range(n):
if 4*m*A[i]<sum(A):
continue
else:
ans+=1
if ans<m:
print('No')
else:
print('Yes') | 1 | 38,888,988,824,868 | null | 179 | 179 |
n = input()
print "%d:%d:%d" % (n/3600,(n/60)%60,n%60) | N=input().split()
X=N[0]
Y=N[1]
Z=N[2]
print(Z + ' ' + X + ' ' + Y) | 0 | null | 19,290,362,715,932 | 37 | 178 |
input()
S = set(input().split())
input()
T = set(input().split())
print(len(S & T))
| num = input()
num_list = []
num_list = num.split()
if int(num_list[0]) == int(num_list[1]):
print('a','b',sep=' == ')
elif int(num_list[0]) > int(num_list[1]):
print('a','b',sep=' > ')
else:
print('a','b',sep=' < ') | 0 | null | 213,549,042,028 | 22 | 38 |
M=10**9+7
n,k=map(int,input().split())
l=[1]
f=1
for i in range(n):
f=f*(i+1)%M
l+=[f]
a=0
for i in range(min(n,k+1)):
c=l[n]*l[n-1]%M
p=l[i]**2*l[n-i]*l[n-i-1]%M
a+=c*pow(p,M-2,M)
print(a%M) | import numpy as np
import math
from decimal import *
#from numba import njit
def getVar():
return map(int, input().split())
def getArray():
return list(map(int, input().split()))
def getNumpy():
return np.array(list(map(int, input().split())), dtype='int64')
def factorization(n):
d = {}
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
d.update({i: cnt})
if temp!=1:
d.update({temp: 1})
if d==[]:
d.update({n:1})
return d
def main():
N = int(input())
d = factorization(N)
count = 0
for v in d.values():
i = 1
while(v >= i):
v -= i
i += 1
count += 1
print(count)
main() | 0 | null | 41,918,292,880,420 | 215 | 136 |
import math
a, b, C = map(int, input().split())
C = math.radians(C)
S, h = (1/2)*a*b*math.sin(C), b*math.sin(C)
L = a+b+math.sqrt((a**2)+(b**2)-(2*a*b*math.cos(C)))
print("{0:.8f}".format(S))
print("{0:.8f}".format(L))
print("{0:.8f}".format(h)) | #10_B
import math
a,b,C=map(int,input().split())
S=a*b*math.sin((C*2*math.pi)/360)/2
c=math.sqrt(a**2+b**2-2*a*b*math.cos((C*2*math.pi)/360))
L=a+b+c
h=2*float(S)/a
print(str(S)+'\n'+str(L)+'\n'+str(h)+'\n')
| 1 | 168,643,144,730 | null | 30 | 30 |
import copy
import random
D = list(map(int, input().split()))
q = int(input())
for x in range(q):
y, z = map(int, input().split())
while True:
r = random.randint(0,3)
if r == 0:
Dt = copy.copy(D)
temp = Dt[0]
Dt[0] = Dt[4]
Dt[4] = Dt[5]
Dt[5] = Dt[1]
Dt[1] = temp
elif r== 1:
Dt = copy.copy(D)
temp = Dt[0]
Dt[0] = Dt[2]
Dt[2] = Dt[5]
Dt[5] = Dt[3]
Dt[3] = temp
elif r== 2:
Dt = copy.copy(D)
temp = Dt[0]
Dt[0] = Dt[3]
Dt[3] = Dt[5]
Dt[5] = Dt[2]
Dt[2] = temp
elif r == 3:
Dt = copy.copy(D)
temp = Dt[0]
Dt[0] = Dt[1]
Dt[1] = Dt[5]
Dt[5] = Dt[4]
Dt[4] = temp
D = copy.copy(Dt)
if Dt[0] == y and Dt[1] == z:
print(Dt[2])
break
| from sys import stdin
from copy import deepcopy
import queue
class Dice:
def __init__(self, nums):
self.labels = [None] + [ nums[i] for i in range(6) ]
self.pos = {
"E" : 3,
"W" : 4,
"S" : 2,
"N" : 5,
"T" : 1,
"B" : 6
}
def rolled(dice, queries):
d = deepcopy(dice)
for q in queries:
if q == "E":
d.pos["T"], d.pos["E"], d.pos["B"], d.pos["W"] = d.pos["W"], d.pos["T"], d.pos["E"], d.pos["B"]
elif q == "W":
d.pos["T"], d.pos["E"], d.pos["B"], d.pos["W"] = d.pos["E"], d.pos["B"], d.pos["W"], d.pos["T"]
elif q == "S":
d.pos["T"], d.pos["S"], d.pos["B"], d.pos["N"] = d.pos["N"], d.pos["T"], d.pos["S"], d.pos["B"]
elif q == "N":
d.pos["T"], d.pos["S"], d.pos["B"], d.pos["N"] = d.pos["S"], d.pos["B"], d.pos["N"], d.pos["T"]
else:
return d
nums = [int(x) for x in stdin.readline().rstrip().split()]
q = int(stdin.readline().rstrip())
dice = Dice(nums)
# TとSに対応するクエリを記憶し, resをすぐに呼び出せるようにする
memo = [[False] * 7 for i in range(7)]
memo[dice.pos["T"]][dice.pos["S"]] = ""
# クエリとさいころの東面を記憶
res = { "" : dice.labels[dice.pos["E"]] }
# BFSで探索, 解を求めたらreturn Trueで抜け出す
# diceの中身をいじってはならない
def solve(T, S):
que = queue.Queue()
que.put(dice)
sol_q = ["E", "N", "S", "W"]
while not que.empty():
d = que.get()
if d.pos["T"] == T and d.pos["S"] == S:
break
else:
for i in sol_q:
d_next = Dice.rolled(d, i)
que.put(d_next)
memo[d_next.pos["T"]][d_next.pos["S"]] = memo[d.pos["T"]][d.pos["S"]] + i
res[memo[d_next.pos["T"]][d_next.pos["S"]]] = d_next.labels[d_next.pos["E"]]
else:
return memo[T][S]
for i in range(q):
ts = [int(x) for x in stdin.readline().rstrip().split()]
T = dice.labels.index(ts[0])
S = dice.labels.index(ts[1])
if solve(T, S) != False:
print(res[memo[T][S]])
| 1 | 257,065,533,228 | null | 34 | 34 |
while True:
n = int(input())
if n == 0:
break
s = list(map(int, input().split()))
kei = 0
for p in s:
kei += p
m = kei / n
a = 0
for p in s:
a += ((p - m)**2) / n
import math
h = math.sqrt(a)
print(h) | # -*- coding: utf-8 -*-
import sys
import os
import math
while True:
N = int(input())
if N == 0:
break
scores = list(map(float, input().split()))
n = len(scores)
mean = sum(scores) / n
variance = 0
for score in scores:
variance += (score - mean) ** 2
variance /= n
print(math.sqrt(variance)) | 1 | 190,907,984,320 | null | 31 | 31 |
# coding: utf-8
# Your code here!
n = int(input())
m = [1,1]
if n == 0:
print(1)
elif n == 1:
print(1)
else:
for i in range(2, n+1):
m.append( m[i-1] + m[i-2] )
print(m.pop())
| import sys
input = sys.stdin.readline
n, s = map(int,input().split())
A = list(map(int,input().split()))
mod = 998244353
l = 3050
M = [1] # i!のmod
m = 1
for i in range(1, l):
m = (m * i) % mod
M.append(m)
def pow(x, y, mod): # x**y の mod を返す関数
ans = 1
while y > 0:
if y % 2 == 1:
ans = (ans * x) % mod
x = (x**2) % mod
y //= 2
return ans
def inv(x, mod): # x の mod での逆元を返す関数
return pow(x, mod-2, mod)
D = [0] * 3050
M2 = [1]
M2I = [0] * l
for i in range(l-1):
M2.append((M2[-1] * 2) % mod)
for i in range(l):
M2I[i] = inv(M2[i], mod)
i2 = inv(2,mod)
D[0] = M2[n]
for i in range(n):
for j in range(l-1,-1,-1):
if j - A[i] >= 0:
D[j] = (D[j] + D[j-A[i]] * i2) % mod
# print(D[:10])
print(D[s])
| 0 | null | 8,905,472,193,790 | 7 | 138 |
#!/usr/bin/env python3
def pow(N,R,mod):
ans = 1
i = 0
while((R>>i)>0):
if (R>>i)&1:
ans *= N
ans %= mod
N = (N*N)%mod
i += 1
return ans%mod
def main():
N,K = map(int,input().split())
li = [0 for _ in range(K)]
mod = 10**9+7
ans = 0
for i in range(K,0,-1):
mm = K//i
mm = pow(mm,N,mod)
for j in range(2,(K//i)+1):
mm -= li[i*j-1]
li[i-1] = mm
ans += (i*mm)%mod
ans %= mod
print(ans)
if __name__ == '__main__':
main()
| import math
import itertools
N=int(input())
P=list(map(int,input().split()))
Q=list(map(int,input().split()))
ls=[]
for i in range(1,N+1):
ls.append(i)
ls2 = list(itertools.permutations(ls,N))
#print(ls2)
cnt1 = 0
cnt2 = 0
for j in range(math.factorial(N)):
for i in range(N):
#print(j,i,P[i],ls2[j][i])
if P[i] == ls2[j][i]:
cnt1 += 1
if Q[i] == ls2[j][i]:
cnt2 += 1
#print("cnt1",cnt1,"cnt2",cnt2)
if cnt1 == N:
a = j
if cnt2 == N:
b = j
cnt1 = 0
cnt2 = 0
#print(a,b)
print(abs(a-b))
| 0 | null | 68,941,028,520,362 | 176 | 246 |
N, *A = map(int, open(0).read().split())
mod = 10 ** 9 + 7
ans = 0
for bit in range(60):
ctr = [0, 0]
for i in range(N):
ctr[A[i] >> bit & 1] += 1
ans += (1 << bit) * (ctr[0] * ctr[1])
ans %=mod
print(ans)
| def main():
n = int(input())
A = sorted(map(int, input().split()), reverse=True)
ans = 0
mod = 10 ** 9 + 7
m=A[0]
for i in range(61):
cnt0 = cnt1 = 0
if m < 2 ** i:
break
for j, a in enumerate(A):
if a < 2 ** i:
cnt0 += n - j
break
if (a >> i) & 1:
cnt1 += 1
else:
cnt0 += 1
ans += (((2 ** i) % mod) * ((cnt1 * cnt0) % mod)) % mod
ans %= mod
print(ans)
if __name__ == "__main__":
main() | 1 | 122,843,658,571,732 | null | 263 | 263 |
n=int(input())
p=list(map(int,input().split()))
check=200001
cnt=0
for i in range(n):
if check > p[i]:
check = p[i]
cnt+=1
print(cnt) | n = int(input())
p = list(map(int, input().split()))
minp = 2*10**5
ans = 0
for i in range(n):
if minp >= p[i]:
minp = p[i]
ans += 1
print(ans) | 1 | 85,354,155,789,380 | null | 233 | 233 |
a = input()
s = a[0],a[1],a[2]
print("".join(s))
| # -*- coding: utf-8 -*-
def conv_input(arr):
ret = []
for e in arr:
ret.append((e[0], int(e[1])))
return ret
def conv_output(conv_arr):
ret = []
for e in conv_arr:
ret.append(e[0] + str(e[1]))
return ret
def is_stable(arr1, arr2):
ret = 'Stable'
for a1, a2 in zip(arr1, arr2):
if a1 == a2:
continue
else:
ret = 'Not stable'
break
return ret
def bubble_sort(n, arr):
flag = True
while flag:
flag = False
for i in reversed(range(n)):
if i is 0:
break
if arr[i][1] < arr[i - 1][1]:
tmp = arr[i]
arr[i] = arr[i - 1]
arr[i - 1] = tmp
flag = True
return arr
def selection_sort(n, arr):
for i in range(n):
minj = i
for j in range(i, n):
if arr[j][1] < arr[minj][1]:
minj = j
if i != minj:
tmp = arr[minj]
arr[minj] = arr[i]
arr[i] = tmp
return arr
if __name__ == '__main__':
n = int(input())
arr1 = arr2 = [str(s) for s in input().split()]
arr1 = conv_output(bubble_sort(n, conv_input(arr1)))
print(' '.join(map(str, arr1)))
print('Stable')
arr2 = conv_output(selection_sort(n, conv_input(arr2)))
print(' '.join(map(str, arr2)))
print(is_stable(arr1, arr2)) | 0 | null | 7,362,645,900,600 | 130 | 16 |
n=int(input())
s=input()
num=n
for i in range(1,n):
if s[i-1]==s[i]:
num-=1
print(num)
| lst = []
num = int(input())
while num != 0:
lst.append(num)
num = int(input())
it = zip(range(len(lst)), lst)
for (c, v) in it:
print("Case " + str(c+1) + ": " + str(v)) | 0 | null | 85,674,397,990,000 | 293 | 42 |
#!/usr/bin/env python3
#import
#import math
#import numpy as np
#= int(input())
S = input()
K = int(input())
ls = len(S)
t1 = []
t = 1
for i in range(1, ls):
if S[i - 1] == S[i]:
t += 1
else:
if t > 1:
t1.append(t)
t = 1
if t > 1 or t == ls:
t1.append(t)
ans = 0
for t in t1:
ans += t // 2
if len(t1) == 1:
if t1[0] == ls:
print(ls * K // 2)
else:
if S[0] != S[-1]:
print(ans * K)
else:
ta = t1[0]
tb = t1[-1]
print(ans * K - (ta // 2 + tb // 2 - (ta + tb) // 2) * (K - 1))
| #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) | 1 | 175,660,826,506,308 | null | 296 | 296 |
import sys
from math import log10, floor
print('\n'.join(map(str, [floor(log10(sum(map(int, ab.split())))) + 1 for ab in sys.stdin]))) | s = input()
l = len(s)
print('x'*l) | 0 | null | 36,647,345,794,142 | 3 | 221 |
w,h,x,y,r=map(int,raw_input().split())
if min(x,y,w-x,h-y)<r:
print 'No'
else:
print 'Yes' | import sys
def insertionSort( nums, n, g ):
cnt = 0
i = g
while i < n:
v = nums[i]
j = i - g
while 0 <= j and v < nums[j]:
nums[ j+g ] = nums[j]
j -= g
cnt += 1
nums[ j+g ] = v
i += 1
return cnt
def shellSort( nums, n ):
g = []
val =0
for i in range( n ):
val = 3*val+1
if n < val:
break
g.append( val )
g.reverse( )
m = len( g )
print( m )
print( " ".join( map( str, g ) ) )
cnt = 0
for i in range( m ):
cnt += insertionSort( nums, n, g[i] )
print( cnt )
n = int( sys.stdin.readline( ) )
nums = []
for i in range( n ):
nums.append( int( sys.stdin.readline( ) ) )
cnt = 0
shellSort( nums, n )
print( "\n".join( map( str, nums ) ) ) | 0 | null | 245,038,404,534 | 41 | 17 |
D = int(input())
c = list(map(int,input().split()))
s = [list(map(int,input().split())) for _ in range(D)]
t = [int(input())-1 for _ in range(D)]
S = 0
last = [-1]*26
score = 0;
for d in range(D):
S += s[d][t[d]]
last[t[d]] = d
for i in range(26):
S-=c[i]*(d - last[i])
score +=max(10**6+S,0)
print(S)
| D=int(input())
c=[None]+list(map(int, input().split()))
s=[None]+[list(map(int, input().split())) for _ in range(D)]
T=[None]+[int(input()) for _ in range(D)]
lastdi=[None]+[0]*26
v=0
for i in range(1, D+1):
v+=s[i][T[i]-1]
lastdi[T[i]]=i
for x in range(1, 27):
v-=(i-lastdi[x])*c[x]
print(v) | 1 | 10,036,435,939,168 | null | 114 | 114 |
# -*- coding:utf-8 -*-
import math
def insertion_sort(num_list, length, interval):
cnt = 0
for i in range(interval, length):
v = num_list[i]
j = i - interval
while j >= 0 and num_list[j] > v:
num_list[j+interval] = num_list[j]
j = j - interval
cnt = cnt + 1
num_list[j+interval] = v
return cnt
def shell_sort(num_list, length):
cnt = 0
h = 4
intervals = [1,]
while length > h:
intervals.append(h)
h = 3 * h + 1
for i in reversed(range(len(intervals))):
cnt = cnt + insertion_sort(num_list, length, intervals[i])
print(len(intervals))
show_list(intervals)
print(cnt)
def show_list(list):
i = len(list) - 1;
while i > 0:
print(list[i], end=" ")
i = i - 1
print(list[i])
input_num = int(input())
input_list = list()
for i in range(input_num):
input_list.append(int(input()))
shell_sort(input_list, input_num)
for num in input_list:
print(num) | class solve:
def __init__(self, n):
pass
def insertionsort(self, A, n, g):
for i in range(g, n):
v = A[i]
j = i - g
while j >= 0 and A[j] > v:
A[j + g] = A[j]
j = j - g
self.cnt += 1
A[j + g] = v
def shellsort(self, A, n):
self.cnt = 0
self.G = [1]
f = 1
while f * 3 + 1 <= n:
f = f * 3 + 1
self.G.append(f)
self.G = list(reversed(self.G))
self.m = len(self.G)
for g in self.G:
self.insertionsort(A, n, g)
n, *A = map(int, open(0).read().split())
solver = solve(n)
solver.shellsort(A, n)
print(solver.m)
print(' '.join(map(str, solver.G)))
print(solver.cnt)
print('\n'.join(map(str, A)))
| 1 | 31,049,330,862 | null | 17 | 17 |
S = input()
if S[0] == 'R' and S[1] == 'R' and S[2] == 'R':
ans = 3
elif (S[0] == 'R' and S[1] == 'R' and S[2] == 'S') or (S[0] == 'S' and S[1] == 'R' and S[2] == 'R'):
ans = 2
elif S[0] == 'S' and S[1] == 'S' and S[2] == 'S':
ans = 0
else:
ans = 1
print(ans)
| import sys
import math
import bisect
from collections import defaultdict,deque
# input = sys.stdin.readline
def inar():
return [int(el) for el in input().split()]
# def find(a,b,c):
# gc=math.gcd(a,b)
# return math.gcd(gc,c)
def main():
n=int(input())
string=input()
r=[]
g=[]
b=[]
for i in range(n):
if string[i]=="R":
r.append(i)
elif string[i]=="G":
g.append(i)
else:
b.append(i)
ans=0
r.sort()
g.sort()
b.sort()
# print(r)
# print(g)
# print(b)
# print(len(b))
# ans1=0
# fir=[]
# for i in range(len(r)):
# for j in range(len(g)):
# for k in range(len(b)):
# ls=[r[i],g[j],b[k]]
# ls.sort()
# if ls[1]-ls[0]!=ls[2]-ls[1]:
# ans1+=1
# fir.append(ans1)
# # print(ans1)
# print("-------------------check---------------")
# are=[]
for i in range(len(r)):
for j in range(len(g)):
ans+=len(b)
chota=min(g[j],r[i])
bada=max(g[j],r[i])
diff=bada-chota
left=bisect.bisect_left(b,bada+diff)
right=bisect.bisect_left(b,chota-diff)
lol=(bada+chota)
if lol%2==0:
beech=lol//2
ind=bisect.bisect_left(b,beech)
if ind<len(b) and b[ind]==beech:
ans-=1
if (left<len(b) and b[left]==bada+diff):
ans-=1
if (right<len(b) and b[right]==chota-diff):
ans-=1
# are.append(ans)
print(ans)
# for i in range(len(are)):
# print(are[i],fir[i])
if __name__ == '__main__':
main()
| 0 | null | 20,414,078,927,032 | 90 | 175 |
import math
K = int(input())
rst = 0
for i in range(1, K + 1):
for j in range(1, K + 1):
tmp = math.gcd(i, j)
for k in range(1, K + 1):
rst += math.gcd(tmp, k)
print(rst)
| import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
def main():
N = int(readline())
L = [int(i) for i in readline().split()]
#まず三角形ができる組みを考える
#三重ループでも間に合うので三重ループを回す
L.sort()
cnt = 0
for i in range(N):
for j in range(i+1, N):
for k in range(j+1, N):
if L[k] < L[i] + L[j]:
if (L[i] != L[j]) & (L[j] != L[k]) & (L[k] != L[i]):
cnt += 1
print(cnt)
if __name__ == '__main__':
main() | 0 | null | 20,340,914,487,550 | 174 | 91 |
N,T=map(int,input().split())
G=[list(map(int,input().split())) for _ in range(N)]
G.sort()
dp=[0]*(60000)
for g in G:
for i in range(T-1,-1,-1):
dp[i+g[0]]=max(dp[i+g[0]],dp[i]+g[1])
print(max(dp))
| #!/usr/bin/env python
import sys
input = sys.stdin.buffer.readline
sys.setrecursionlimit(10**6)
INF = float("inf")
def main():
N,T = map(int,input().split())
AB = [(0,0)] + [tuple(map(int,input().split())) for _ in range(N)]
# 最後に食べるものを全探索し, それ以外でDPしたくなる
# 普通にやると TLE だが, 左から,右から で事前にDPしておくことで計算量を落とせる
# このとき, 配列添字を 1〜N にしておくと楽
# 1番目の料理を最後に食べるとき : dp1[0][] + b + dp2[2][], このときに index out of range しないのが嬉しい
# 2番目の料理を最後に食べるとき : dp1[1][] + b + dp2[3][]
# ...
# N番目の料理を最後に食べるとき : dp1[N-1][] + b + dp2[N+1][], dp2 は N+2 の長さがあると良さそう
# dp1[i][j] : 1〜i 番目の料理から選んで T 分以内に食べるときの美味しさの和の最大値
dp1 = [[0 for _ in range(T+1)] for _ in range(N+1)]
for i in range(1,N+1):
a,b = AB[i]
for j in range(T+1):
# 食べる
if j >= a:
dp1[i][j] = max(dp1[i-1][j], dp1[i-1][j-a] + b)
# 食べない
else:
dp1[i][j] = dp1[i-1][j]
# dp2[i][j] : i〜N 番目の料理から選んで T 分以内に食べるときの美味しさの和の最大値
dp2 = [[0 for _ in range(T+1)] for _ in range(N+2)]
for i in range(N,0,-1):
a,b = AB[i]
for j in range(T+1):
# 食べる
if j >= a:
dp2[i][j] = max(dp2[i+1][j], dp2[i+1][j-a] + b)
# 食べない
else:
dp2[i][j] = dp2[i+1][j]
# 最後に食べる料理で全探索
ans = 0
for i in range(1,N+1):
a,b = AB[i]
for j in range(T):
ans = max(ans, dp1[i-1][j] + b + dp2[i+1][T-1-j])
print(ans)
if __name__ == "__main__":
main() | 1 | 151,825,299,275,388 | null | 282 | 282 |
A1,A2,A3=map(int, input().split())
print('win' if A1+A2+A3 <= 21 else 'bust') | A,B,C = map(int,input().split())
if A+B+C <= 21:
print("win")
else:
print("bust") | 1 | 118,747,800,681,888 | null | 260 | 260 |
n = int(input())
a = n//2 if n%2==0 else (n//2)+1
print(a) | import math
print(math.ceil(int(input())/2)) | 1 | 58,812,692,732,288 | null | 206 | 206 |
s=input()
t=input()
max_=0
for i in range(len(s)-len(t)+1):
c = 0
for j in range(len(t)):
if s[i+j] == t[j]:
c += 1
max_ = max(max_, c)
print(len(t)-max_)
| # import itertools
# import math
# import sys
# sys.setrecursionlimit(500*500)
# import numpy as np
# import heapq
# from collections import deque
# N = int(input())
S = input()
T = input()
# n, *a = map(int, open(0))
# N, M = map(int, input().split())
# A = list(map(int, input().split()))
# B = list(map(int, input().split()))
# tree = [[] for _ in range(N + 1)]
# B_C = [list(map(int,input().split())) for _ in range(M)]
# S = input()
# B_C = sorted(B_C, reverse=True, key=lambda x:x[1])
# all_cases = list(itertools.permutations(P))
# a = list(itertools.combinations_with_replacement(range(1, M + 1), N))
# itertools.product((0,1), repeat=n)
# A = np.array(A)
# cum_A = np.cumsum(A)
# cum_A = np.insert(cum_A, 0, 0)
# def dfs(tree, s):
# for l in tree[s]:
# if depth[l[0]] == -1:
# depth[l[0]] = depth[s] + l[1]
# dfs(tree, l[0])
# dfs(tree, 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
ma = 0
s = len(S)
t = len(T)
for i in range(s - t + 1):
cnt = 0
for j in range(t):
if S[i + j] == T[j]:
cnt += 1
if cnt > ma:
ma = cnt
print(t - ma) | 1 | 3,660,348,400,192 | null | 82 | 82 |
# -*- coding: utf-8 -*-
n, k = map(int,input().split())
p = [int(i) for i in input().split()]
p.sort()
print(sum(p[:k]))
| n,k = map(int,input().split())
l = list(map(int,input().split()))
l.sort()
price = 0
for i in range(k) :
price += l[i]
print(price) | 1 | 11,616,596,698,648 | null | 120 | 120 |
def main():
a = list(map(int, list(input())))
n = len(a)
dp = [[0, 0] for _ in [0]*(n+1)]
dp[0][1] = 1
for i in range(n):
dp[i+1][0] = min(dp[i][0]+a[i], dp[i][1]+10-a[i])
dp[i+1][1] = min(dp[i][0]+a[i]+1, dp[i][1]+9-a[i])
print(dp[n][0])
main()
| kuri_now = False
cost = [0, 1, 2, 3, 4, 5, 4, 3, 2, 1, 0]
kuri = [0, 0, 0, 0, 0, 0.5, 1, 1, 1, 1, 1]
result = 0
for digit in reversed(input()):
digit = int(digit)
if kuri_now == 0:
result += cost[digit]
kuri_now = kuri[digit]
elif kuri_now == 1:
result += cost[digit + 1]
kuri_now = kuri[digit + 1]
else:
if cost[digit] <= cost[digit + 1]:
result += cost[digit]
kuri_now = kuri[digit]
else:
result += cost[digit + 1]
kuri_now = kuri[digit + 1]
if kuri_now == 1:
result += 1
print(result) | 1 | 70,891,960,696,250 | null | 219 | 219 |
n = int(input())
S = list(str(input()))
S = [{ord(c)-ord('a')} for c in S]
def segfunc(x, y):
return x | y
def init(init_val):
# set_val
for i in range(n):
seg[i+num-1] = init_val[i]
# built
for i in range(num-2, -1, -1):
seg[i] = segfunc(seg[2*i+1], seg[2*i+2])
def update(k, x):
k += num - 1
seg[k] = x
while k:
k = (k-1)//2
seg[k] = segfunc(seg[2*k+1], seg[2*k+2])
def query(p, q):
if q <= p:
return ide_ele
p += num - 1
q += num - 2
res = ide_ele
while q-p>1:
if p&1 == 0:
res = segfunc(res, seg[p])
if q&1 == 1:
res = segfunc(res, seg[q])
q -= 1
p = p//2
q = (q-1)//2
if p == q:
res = segfunc(res, seg[p])
else:
res = segfunc(segfunc(res, seg[p]), seg[q])
return res
# identity element
ide_ele = set()
# num: n以上の最小の2のべき乗
num = 2**(n-1).bit_length()
seg = [ide_ele]*2*num
init(S)
import sys
input = sys.stdin.readline
q = int(input())
for i in range(q):
t, x, y = map(str, input().split())
if t == '1':
x = int(x)
y = ord(y)-ord('a')
update(x-1, {y})
else:
x = int(x)
y = int(y)
print(len(query(x-1, y)))
| # セグメント木 最新バージョン
#verify
class SegTree():
# 1-indexed
def __init__(self, lists, function, basement):
self.n = len(lists)
self.K = (self.n-1).bit_length()
self.f = function
self.b = basement
self.seg = [basement]*(2**(self.K+1)+1)
X = 2**self.K
for i, v in enumerate(lists):
self.seg[i+X] = v
for i in range(X-1, 0, -1):
self.seg[i] = self.f(self.seg[i << 1], self.seg[i << 1 | 1])
def update(self, k, value):
X = 2**self.K
k += X
self.seg[k] = value
while k:
k = k >> 1
self.seg[k] = self.f(self.seg[k << 1], self.seg[(k << 1) | 1])
def query(self, L, R):
num = 2**self.K
L += num
R += num
vL = self.b
vR = self.b
while L < R:
if L & 1:
vL = self.f(vL, self.seg[L])
L += 1
if R & 1:
R -= 1
vR = self.f(self.seg[R], vR)
L >>= 1
R >>= 1
return self.f(vL, vR)
def find_max_index(self, L, R, X):
# [L,R)でX以下の物で最大indexを取得
return self.fMi(L, R, X, 1, 0, 2**self.K)
def find_min_index(self, L, R, X):
# [L,R) でX以下の物で最小のindexを取得する
return self.fmi(L, R, X, 1, 0, 2**self.K)
def fMi(self, a, b, x, k, l, r):
if self.seg[k] > x or r <= a or b <= l:
return -1
else:
if k >= 2**self.K:
return k-2**self.K
else:
vr = self.fMi(a, b, x, (k << 1) | 1, (l + r) // 2, r)
if vr != -1:
return vr
return self.fMi(a, b, x, k << 1, l, (l + r) // 2)
def fmi(self, a, b, x, k, l, r):
if self.seg[k] > x or r <= a or b <= l:
return -1
else:
if k >= 2**self.K:
return k-2**self.K
else:
vl = self.fmi(a, b, x, k << 1, l, (l+r)//2)
if vl != -1:
return vl
return self.fmi(a, b, x, k << 1 | 1, (l+r)//2, r)
N = int(input())
S = list(input())
Q = int(input())
que = [tuple(input().split()) for i in range(Q)]
alpha = "abcdefghijklmnopqrstuvwxyz"
Data = {alpha[i]: [0]*N for i in range(26)}
for i in range(N):
Data[S[i]][i] += 1
SEG = {alpha[i]: SegTree(Data[alpha[i]], max, 0) for i in range(26)}
for X, u, v in que:
if X == "1":
u = int(u)-1
NOW = S[u]
S[u] = v
SEG[NOW].update(u, 0)
SEG[v].update(u,1)
else:
s, t = int(u)-1, int(v)-1
res = 0
for j in range(26):
res += SEG[alpha[j]].query(s, t+1)
print(res)
| 1 | 62,702,462,475,512 | null | 210 | 210 |
N = int(input())
S = str(input())
#print(N,S)
stack = []
while len(S) > 0:
if len(stack) == 0:
stack.append(S[0])
S = S[1:]
elif S[0] == stack[-1]:
S = S[1:]
elif S[0] != stack[-1]:
stack.append(S[0])
S = S[1:]
#print(S,stack)
print(len(stack))
| import sys
d_num = int(sys.stdin.readline().strip())
graph_list = []
for _ in range(0, d_num):
array = sys.stdin.readline().strip().split(" ")
if len(array) <= 2:
graph_list.append([])
else:
graph_list.append([int(array[i]) - 1 for i in range(2, len(array))])
t = 1
result = [[] for _ in range(0, d_num)]
searched_list = []
stack = []
while True:
if len(stack) == 0:
ll = filter(lambda x: x not in searched_list, range(0, d_num))
if len(ll) == 0:
break
stack.append(ll[0])
result[ll[0]].append(t)
searched_list.append(ll[0])
else:
node = stack[-1]
children = filter(lambda x: x not in searched_list, graph_list[node])
if len(children) != 0:
next_node = children[0]
stack.append(next_node)
result[next_node].append(t)
searched_list.append(next_node)
else:
stack.pop()
result[node].append(t)
t += 1
s = ""
for i in range(0, len(result)):
print str(i+1) + " " + str(result[i][0]) + " " + str(result[i][1]) | 0 | null | 84,652,313,322,950 | 293 | 8 |
#!/usr/bin/env python3
from pprint import pprint
import sys
sys.setrecursionlimit(10 ** 6)
H, W, M = map(int, input().split())
num_bombs_each_row = [0] * H
num_bombs_each_col = [0] * W
bombs = set()
for _ in range(M):
h, w = map(int, input().split())
# 0-index
h -= 1
w -= 1
bombs.add((h, w))
num_bombs_each_row[h] += 1
num_bombs_each_col[w] += 1
max_bombs_in_row = max(num_bombs_each_row)
max_bombs_in_col = max(num_bombs_each_col)
rows_with_max_bombs = []
for row in range(H):
if num_bombs_each_row[row] == max_bombs_in_row:
rows_with_max_bombs.append(row)
cols_with_max_bombs = []
for col in range(W):
if num_bombs_each_col[col] == max_bombs_in_col:
cols_with_max_bombs.append(col)
found = False
for row in rows_with_max_bombs:
for col in cols_with_max_bombs:
if (row, col) not in bombs:
found = True
break
ans = max_bombs_in_row + max_bombs_in_col
if found:
print(ans)
else:
print(ans - 1)
| h, w, m = map(int, input().split())
a_list = []
b_list = []
h_list = [0 for _ in range(h)]
w_list = [0 for _ in range(w)]
for i in range(m):
a, b = map(int, input().split())
a_list.append([a,b])
h_list[a - 1] += 1
w_list[b - 1] += 1
h_max = max(h_list)
w_max = max(w_list)
w_flag = [0 for _ in range(w)]
for i in range(w):
if w_list[i] == w_max:
w_flag[i] = 1
h_flag = [0 for _ in range(h)]
for i in range(h):
if h_list[i] == h_max:
h_flag[i] = 1
flag = 0
for i in range(m):
if h_flag[a_list[i][0] - 1] == 1 and w_flag[a_list[i][1] - 1] == 1:
flag += 1
s = sum(h_flag) * sum(w_flag)
print(h_max + w_max - 1 if flag == s else h_max + w_max)
| 1 | 4,669,306,425,828 | null | 89 | 89 |
n,*aa = map(int, open(0).read().split())
from collections import Counter
c = Counter(aa)
for i in range(1,n+1):
print(c[i]) | N = int(input())
L = list(map(int,input().split()))
ans = [0 for i in range(N)]
for i in range(len(L)):
ans[L[i]-1] += 1
for i in range(N):
print(ans[i]) | 1 | 32,363,624,612,030 | null | 169 | 169 |
print('YNeos'[eval(input().replace(' ','!='))::2]) | from sys import stdin
def main():
input = stdin.readline
n, k, c = map(int, input().split())
s = input()
l, r = [], []
cur = 0
count = 0
while cur <= n:
if s[cur] == "o":
count += 1
l.append((count, cur+1))
cur += c
cur += 1
cur = n
count = k
while cur >= 0:
if s[cur] == "o":
r.append((count, cur+1))
count -= 1
cur -= c
cur -= 1
ans = (i[1] for i in set(l) & set(r))
for i in sorted(ans):
print(i)
if __name__ == '__main__':
main() | 0 | null | 62,126,448,979,338 | 231 | 182 |
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:]
| k = int(input())
sum = 0
def gcd(x, y): # ユークリッドの互除法
if y > x:
y,x = x,y
while y > 0:
r = x%y
x = y
y = r
return x
import math
for i in range(1,k+1):
for m in range(1,k+1):
sub = gcd(i,m)
for l in range(1,k+1):
sum += gcd(sub,l)
print(sum)
| 0 | null | 18,682,336,224,960 | 68 | 174 |
R, C, K = map(int, input().split())
V = [[0]*(C+1) for _ in range(R+1)]
for _ in range(K):
r, c, v = map(int, input().split())
V[r][c] = v
max_p = [0]*(C+1)
for i in range(R+1):
now0, now1, now2, now3 = [[0]*(C+1) for _ in range(4)]
for j in range(C+1):
v = V[i][j]
la = lb = 0
if j > 0:
la = now0[j-1]
lb = now1[j-1]
now2[j] = max(now2[j], now2[j-1], lb + v)
now3[j] = max(now3[j], now3[j-1], now2[j-1] + v)
if i > 0:
now0[j] = max(now0[j], max_p[j], la)
now1[j] = max(now1[j], max_p[j] + v, la + v, lb)
max_p[j] = max(now0[j], now1[j], now2[j], now3[j])
print(max(now0[C], now1[C], now2[C], now3[C]))
| def e_picking_goods():
# 参考: https://atcoder.jp/contests/abc175/submissions/16044254
R, C, K = [int(i) for i in input().split()]
Goods = [[0] * (C + 1) for _ in range(R + 1)]
for _ in range(K):
r, c, v = [int(i) for i in input().split()]
Goods[r][c] = v
# editorial に対し、行の情報を除去する
dp = [[0] * 4 for _ in range(C + 1)]
for i in range(1, R + 1):
dp_next = [[0] * 4 for _ in range(C + 1)]
for j in range(1, C + 1):
up_max = max(dp[j]) # 上のマスで 0~3 回アイテムを拾っていたときの、価値の最大値
v = Goods[i][j]
# 左か上から来て、アイテムを拾わない
dp_next[j][0] = max(up_max, dp_next[j - 1][0])
# 上から来て拾う or 左から来て拾う or 左から来て拾わない
dp_next[j][1] = max(up_max + v, dp_next[j - 1][0] + v, dp_next[j - 1][1])
# 左から来て k-1 個拾っており、ここで拾う or k 個拾っており、ここで拾わない
for k in range(2, 4):
dp_next[j][k] = max(dp_next[j - 1][k - 1] + v, dp_next[j - 1][k])
dp = dp_next # 次の行へ注目を移す
return max(dp[-1])
print(e_picking_goods()) | 1 | 5,588,665,849,980 | null | 94 | 94 |
n = int(input())
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
divisors.sort()
return divisors
p = make_divisors(n)
x = 0
i = 1
ans = 0
def countf(x):
for j in range(1,x+2):
if (1+j)*j//2 > x:
return j - 1
while n != 1:
if n % p[i] == 0:
x += 1
n = n // p[i]
else:
if x != 0:
ans += countf(x)
x = 0
i += 1
ans += countf(x)
print(ans) | R,C,k = map(int,input().split())
dp0 = [[0]*(C+1) for i in range(R+1)]
dp1 = [[0]*(C+1) for i in range(R+1)]
dp2 = [[0]*(C+1) for i in range(R+1)]
dp3 = [[0]*(C+1) for i in range(R+1)]
item = [[0]*(C+1) for i in range(R+1)]
for i in range(k):
r,c,v = map(int,input().split())
# item[r][c] = v
dp1[r][c] = v
# for i in range(R+1):
# print(item[i])
for i in range(1,R+1):
for j in range(1,C+1):
# a = item[i][j]
# dp0[i][j] = max(dp0[i-1][j],dp1[i-1][j],dp2[i-1][j],dp3[i-1][j],dp0[i][j-1])
# dp1[i][j] = max(dp0[i][j-1]+a,dp1[i][j-1])
# dp2[i][j] = max(dp1[i][j-1]+a,dp2[i][j-1])
# dp3[i][j] = max(dp2[i][j-1]+a,dp3[i][j-1])
# dp0[i][j] = max(dp0[i-1][j],dp1[i-1][j],dp2[i-1][j],dp3[i-1][j],dp0[i][j-1],dp0[i][j])
dp3[i][j] = max(dp2[i][j-1]+dp1[i][j],dp3[i][j-1])
dp2[i][j] = max(dp1[i][j-1]+dp1[i][j],dp2[i][j-1])
dp1[i][j] = max(dp1[i-1][j]+dp1[i][j],dp2[i-1][j]+dp1[i][j],dp3[i-1][j]+dp1[i][j],dp1[i][j-1],dp1[i][j])
# for i in range(R+1):
# print(dp2[i])
print(max(dp0[R][C],dp1[R][C],dp2[R][C],dp3[R][C])) | 0 | null | 11,275,291,599,780 | 136 | 94 |
from itertools import accumulate
N, M = map(int, input().split())
A = sorted(list(map(int, input().split())))
ruiseki = list(accumulate(A[::-1]))
def syakutori(mid):
x = 0
cnt = 0
ans = 0
for i in range(N)[::-1]: # 大きい方から
while x < N:
if A[i] + A[x] >= mid:
cnt += N - x
if N - x >= 1:
ans += A[i] * (N - x) + ruiseki[N - x - 1]
break
else:
x += 1
return cnt, ans
# 自分以上の数の個数がM個以上になる値のうち最大のもの
ok = 0
ng = 10 ** 15
while ok + 1 < ng:
mid = (ok + ng) // 2
cnt, ans = syakutori(mid)
if cnt >= M:
ok = mid
else:
ng = mid
# okで終わってる場合はcntがM個以上の場合があるから過分を引く
# ngで終わってる場合は残りM-cnt個のokを足す
print(ans + ok * (M - cnt)) | A,V = map(int,input().split(" "))
B,W = map(int,input().split(" "))
T, = map(int,input().split(" "))
kyori = abs(A-B)
dif = V-W
if dif>0:
if kyori/dif<=T:
print("YES")
else:
print("NO")
else:
print("NO") | 0 | null | 61,496,336,386,810 | 252 | 131 |
n,m,l=map(int,raw_input().split())
A=[]
B=[]
for i in range(n):
A.append(map(int,raw_input().split()))
for i in range(m):
B.append(map(int,raw_input().split()))
for i in range(n):
print(' '.join(map(str,[sum([A[i][j]*B[j][k] for j in range(m)]) for k in range(l)]))) | n = int(input())
i = 1
for i in range(1, n + 1):
if i % 3 == 0:
print(' {0}'.format(i), end = '')
else:
st = str(i)
for x in range(0, len(st)):
if st[x] == '3':
print(' {0}'.format(i), end = '')
break
print() | 0 | null | 1,178,887,368,260 | 60 | 52 |
n = int(input())
res = 0
a = n // 500
n %= 500
b = n // 5
print(1000*a + 5*b) | from sys import stdin
rs = stdin.readline
ri = lambda : int(rs())
ril = lambda : list(map(int, rs().split()))
def main():
N = ri()
c = rs()
x = 0
y = c.count('R')
for e in c:
if x == y:
break
elif e == 'W':
x += 1
else:
y -= 1
print(y)
if __name__ == '__main__':
main()
| 0 | null | 24,660,753,897,084 | 185 | 98 |
#pdf見た
n = int(input())
xl = [list(map(int,input().split())) for i in range(n)]
sf = []
choice = -1e+9
for x,l in xl:
sf.append([x-l,x+l])
sf.sort(key=lambda x:x[1])
cnt = 0
for s,f in sf:
if choice <= s:
cnt += 1
choice = f
print(cnt) | import math
a, b, c = map(int, input().split())
PI = 3.1415926535897932384
c = math.radians(c)
print('{:.5f}'.format(a * b * math.sin(c) / 2))
A = a - b * math.cos(c)
B = b * math.sin(c)
print('{:.5f}'.format(math.sqrt(A * A + B * B) + a + b))
print('{:.5f}'.format(B))
| 0 | null | 45,322,730,893,842 | 237 | 30 |
a=input()
if(a=='AAA' or a=='BBB'):
print('No')
else:
print('Yes')
|
def resolve():
def dfs(v):
dist = [-1] * N
stack = [v]
dist[v] = 0
while stack:
v = stack.pop()
for to in G[v]:
if dist[to] != -1:
continue
dist[to] = dist[v] + 1
stack.append(to)
return dist
N, taka, aoki = map(int, input().split())
taka -= 1
aoki -= 1
G = [[] for _ in range(N)]
for i in range(N - 1):
a, b = map(lambda x: int(x) - 1, input().split())
G[a].append(b)
G[b].append(a)
dist_Tk = dfs(taka)
dist_Ao = dfs(aoki)
ans = 0
for i in range(N):
if dist_Tk[i] < dist_Ao[i]:
ans = max(ans, dist_Ao[i] - 1)
print(ans)
if __name__ == "__main__":
resolve() | 0 | null | 86,196,723,793,572 | 201 | 259 |
w=input()
c=0
while True:
t=input()
if t=='END_OF_TEXT':
print(c)
break
c+=t.lower().split().count(w)
|
N = int(input())
A_list = list(map(int,input().split()))
A_set = set(A_list)
if len(A_list) == len(A_set):
print("YES")
else:
print("NO") | 0 | null | 37,958,197,977,468 | 65 | 222 |
N,M=map(int,input().split())
a=M//2
b=M-a
c=1
d=2*a+1
for i in range(a):
print(c,d)
c+=1
d-=1
e=2*a+2
f=2*M+1
for i in range(b):
print(e,f)
e+=1
f-=1 | import sys
sys.setrecursionlimit(10 ** 8)
input = sys.stdin.readline
def main():
N, M = [int(x) for x in input().split()]
ans = [[] for j in range(M)]
if N % 2:
for i in range(M):
ans[i].append(i + 1)
ans[i].append(N - i - 1)
else:
memo = 0
f = False
for i in range(M):
memo = i
if (i + 1) * 4 >= N:
f = True
break
ans[i].append(i + 1)
ans[i].append(N - i - 1)
if f:
for j in range(memo, M):
ans[j].append(j + 1)
ans[j].append(N - j - 2)
for a in ans:
print(*a)
if __name__ == '__main__':
main()
| 1 | 28,591,666,334,220 | null | 162 | 162 |
n,k=map(int,input().split())
lst_1=list(map(int,input().split()))
# print(lst_1)
lst_2=[]
for i in range(n-k):
temp=1
temp=lst_1[i+k]/lst_1[i]
lst_2.append(temp)
for i in lst_2:
if i>1:
print("Yes")
else:print("No")
| N, K = map(int, input().split())
A = list(map(int, input().split()))
l = 0
r = l + K
while r < N:
ans = 'Yes' if A[l] < A[r] else 'No'
print(ans)
l += 1
r += 1
| 1 | 7,107,196,184,480 | null | 102 | 102 |
def main():
H,W,M = map(int,input().split())
s = []
h_cnt = [0 for i in range(H)]
w_cnt = [0 for i in range(W)]
for i in range(M):
h,w = map(int,input().split())
s.append([h-1,w-1])
h_cnt[h-1] += 1
w_cnt[w-1] += 1
h_m,w_m = max(h_cnt), max(w_cnt)
h_mp,w_mp = [],[]
for i in range(H):
if h_cnt[i] == h_m:
h_mp.append(i)
for i in range(W):
if w_cnt[i] == w_m:
w_mp.append(i)
f = 0
for i in range(M):
if h_cnt[s[i][0]] == h_m and w_cnt[s[i][1]] == w_m:
f += 1
if len(w_mp)*len(h_mp)-f<1:
print(h_m+w_m-1)
else:
print(h_m+w_m)
if __name__ == "__main__":
main()
| from collections import defaultdict
h, w, m = map(int, input().split())
targets = defaultdict(int)
targets_count_yoko = defaultdict(int)
targets_count_tate = defaultdict(int)
for _ in range(m):
y, x = map(int, input().split())
y -= 1
x -= 1
targets_count_yoko[x] += 1
targets_count_tate[y] += 1
targets[(y, x)] = -1
max_row = max(targets_count_yoko.values())
max_line = max(targets_count_tate.values())
y_idx = defaultdict(bool)
x_idx = defaultdict(bool)
max_count_x = 0
max_count_y = 0
for i in range(w):
if targets_count_yoko[i] == max_row:
x_idx[i] = True
max_count_x += 1
for i in range(h):
if targets_count_tate[i] == max_line:
y_idx[i] = True
max_count_y += 1
ans = max_line + max_row
kumi = max_count_x*max_count_y
for key_y, key_x in targets.keys():
if y_idx[key_y] and x_idx[key_x]:
kumi -= 1
if kumi == 0:
break
if kumi == 0:
print(ans-1)
else:
print(ans)
| 1 | 4,722,988,143,286 | null | 89 | 89 |
N = int(input())
A = list(map(int, input().split()))
A.sort()
ans = 0
for i in range(N):
for j in range(i + 1, N):
for k in range(j + 1, N):
if A[i] + A[j] > A[k] and A[i] != A[j] and A[j] != A[k] and A[k] != A[i]:
ans += 1
print(ans)
| #!/usr/bin/env python3
# Generated by https://github.com/kyuridenamida/atcoder-tools
from typing import *
import collections
import functools as fts
import itertools as its
import math
import sys
INF = float('inf')
def solve(N: int, L: "List[int]"):
L.sort()
return sum(L[i] not in [L[j], L[k]] and L[j] != L[k] and L[i] + L[j] > L[k] for i in range(N) for j in range(i+1, N) for k in range(j+1, N))
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
L = [int(next(tokens)) for _ in range(N)] # type: "List[int]"
print(f'{solve(N, L)}')
if __name__ == '__main__':
main()
| 1 | 5,044,951,330,650 | null | 91 | 91 |
import sys
n = input()
for i in range(1,n+1):
x = i
if x%3==0:
sys.stdout.write(' %d' % i)
continue
while x<=n:
if x%10==3:
sys.stdout.write(' %d' % i)
break
else:
x /= 10
if x==0:
break
sys.stdout.write('\n') | n,k=map(int,input().split())
mod=10**9+7
U = 4*10**5+1
MOD = 10**9+7
fact = [1]*(U+1)
fact_inv = [1]*(U+1)
for i in range(1,U+1):
fact[i] = (fact[i-1]*i)%MOD
fact_inv[U] = pow(fact[U],MOD-2,MOD)
for i in range(U,0,-1):
fact_inv[i-1] = (fact_inv[i]*i)%MOD
def comb(n,k):
if k < 0 or k > n:
return 0
x = fact[n]
x *= fact_inv[k]
x %= MOD
x *= fact_inv[n-k]
x %= MOD
return x
if n-1<=k:
print(comb(2*n-1,n-1))
else:
ans=0
for i in range(1+k):
ans+=comb(n,i)*comb(n-1,n-i-1)
ans%=mod
print(ans)
| 0 | null | 34,101,861,068,700 | 52 | 215 |
import math
Max = 1000001
prime = Max*[1]
def sieve():
prime[0] = 0
prime[1] = 0
for i in range(2,Max):
if prime[i]==1:
j = 2*i
while j < Max:
prime[j] = 0
j += i
def Howmany(x):
res = 1
while x>=res:
x -= res
res += 1
return res-1
N = int(input())
sieve()
ans = 0
R = int(math.sqrt(N))
for i in range(2, R):
if prime[i]==1 and N%i==0:
cnt = 0
while N%i==0:
N //= i
cnt+=1
ans += Howmany(cnt)
if N!=1:
ans += 1
print(ans)
| import math
from collections import defaultdict
from itertools import accumulate
N=int(input())
data=defaultdict(int)
result=0
for i in range(2,int(math.sqrt(N))+1):
while N%i==0:
N//=i
data[i]+=1
if N!=1:
data[N]+=1
cumsum=list(accumulate(range(1,10**6*2)))
for value in data.values():
for i in range(10**6*2):
if value<cumsum[i]:
result+=i
break
if result==0:
if N!=1:
result=1
print(result) | 1 | 16,934,681,176,572 | null | 136 | 136 |
MOD = 10**9 + 7
def main():
import sys
input = sys.stdin.buffer.readline
_ = int(input())
A = [int(i) for i in input().split()]
def gcd(x, y):
if y == 0:
return x
while y != 0:
x, y = y, x % y
return x
def lcm(x, y):
return x*y//gcd(x, y)
L = A[0]
for a in A[1:]:
L = lcm(L, a)
L %= MOD
ans = 0
for a in A:
ans += L*pow(a, MOD-2, MOD)
print(ans % MOD)
if __name__ == '__main__':
main()
| s = map(int, raw_input().split())
s.sort()
print ' '.join(map(str, s)) | 0 | null | 44,297,447,817,700 | 235 | 40 |
import math
a,b=map(int,input().split())
A=[int(x) for x in input().split()]
if a<=sum(A):
print("Yes")
else:
print("No") | # 最大公約数を求める
def gcm(m, n):
# mを小さくする
if m > n:
_temp = n
n = m
m = _temp
while m != 0:
#print("{}, {}".format(m, n))
m, n = n % m, m
return n
a, b, = map(int, input().split())
g = gcm(a, b)
print("{}".format((int)(a * b / g))) | 0 | null | 95,703,301,574,020 | 226 | 256 |
def makeRelation():
visited=[False]*(N+1)
g=0 # group
for n in range(1,N+1):
if visited[n]:
continue
q={n}
D.append(set())
while q:
j=q.pop()
for i in F[j]: # search for friend
if not visited[i]:
visited[i]=True
q.add(i)
D[g]|={i}
g+=1
def main():
makeRelation()
#print(D)
for g in D:
for d in g:
ans[d]=len(g) - len(F[d]) - len(g&B[d]) - 1
print(*ans[1:])
if __name__=='__main__':
N, M, K = map(int, input().split())
F=[set() for n in range(N+1)]
AB=[list(map(int, input().split())) for m in range(M)]
for a,b in AB:
F[a].add(b)
F[b].add(a)
B=[set() for n in range(N+1)]
CD=[list(map(int, input().split())) for k in range(K)]
for c,d in CD:
B[c].add(d)
B[d].add(c)
D=[]
#print(F)
#print(B)
ans=[0]*(N+1)
main() | import sys
for line in sys.stdin:
l = line.replace('\n', '')
a, b = l.split()
a = int(a)
b = int(b)
print(len(str(a+b))) | 0 | null | 30,826,261,054,688 | 209 | 3 |
import os
import sys
import numpy as np
def solve(N, U, V, AB):
G = [[0]*0 for _ in range(N+1)]
for idx_ab in range(len(AB)):
a, b = AB[idx_ab]
G[a].append(b)
G[b].append(a)
P1 = np.zeros(N+1, dtype=np.int64)
def dfs1(u):
st = [u]
while st:
v = st.pop()
p = P1[v]
for u in G[v]:
if p != u:
st.append(u)
P1[u] = v
dfs1(U)
path_u2v = [U]
v = V
while v != U:
v = P1[v]
path_u2v.append(v)
path_u2v.reverse()
l = len(path_u2v)
half = (l-2) // 2
c = path_u2v[half]
ng = path_u2v[half+1]
Depth = np.zeros(N+1, dtype=np.int64)
def dfs2(c):
st = [c]
P = np.zeros(N+1, dtype=np.int64)
while st:
v = st.pop()
p = P[v]
d = Depth[v]
for u in G[v]:
if p != u and u != ng:
st.append(u)
P[u] = v
Depth[u] = d + 1
dfs2(c)
c_ = path_u2v[l-1-half]
v = c_
while v != c:
Depth[v] = 0
v = P1[v]
d = l%2
ans = max(Depth) + half + d
return ans
# >>> numba compile >>>
numba_config = [
[solve, "i8(i8,i8,i8,i8[:,:])"],
]
if sys.argv[-1] == "ONLINE_JUDGE":
from numba import njit
from numba.pycc import CC
cc = CC("my_module")
for func, signature in numba_config:
vars()[func.__name__] = njit(signature)(func)
cc.export(func.__name__, signature)(func)
cc.compile()
exit()
elif os.name == "posix":
exec(f"from my_module import {','.join(func.__name__ for func, _ in numba_config)}")
else:
from numba import njit
for func, signature in numba_config:
vars()[func.__name__] = njit(signature, cache=True)(func)
print("compiled!", file=sys.stderr)
# <<< numba compile <<<
def main():
N, u, v = map(int, input().split())
if N==2:
print(0)
return
AB = np.array(sys.stdin.read().split(), dtype=np.int64).reshape(N-1, 2)
ans = solve(N, u, v, AB)
print(ans)
main()
| import sys
input=sys.stdin.readline
n,u,v = map(int, input().split())
link = [[] for _ in range(n)]
for i in range(n-1):
tmp = list(map(int,input().split()))
link[tmp[0]-1].append(tmp[1]-1)
link[tmp[1]-1].append(tmp[0]-1)
from collections import deque
Q = deque()
Q.append([v-1,0])
visited=[-1]*n
visited[v-1]=0
while Q:
now,cnt = Q.popleft()
for nxt in link[now]:
if visited[nxt]!=-1:
continue
visited[nxt]=cnt+1
Q.append([nxt,cnt+1])
Q = deque()
Q.append([u-1,0])
v_taka=[-1]*n
v_taka[u-1]=0
while Q:
now,cnt = Q.popleft()
for nxt in link[now]:
if v_taka[nxt]!=-1:
continue
if visited[nxt] <= cnt+1:
continue
v_taka[nxt]=cnt+1
Q.append([nxt,cnt+1])
ans=-1
for i in range(n):
if v_taka[i] == -1:
continue
if ans < visited[i]:
ans=visited[i]
print(ans-1) | 1 | 117,750,454,550,820 | null | 259 | 259 |
# D - Caracal vs Monster
H = int(input())
def rec(x):
if x==1:
return 1
else:
return 2*rec(x//2)+1
print(rec(H)) | H = int(input())
for i in range(0, 10**20 + 1):
if 2**i <= H < 2 ** (i + 1):
break
print(2 ** (i + 1) - 1) | 1 | 79,919,341,072,032 | null | 228 | 228 |
import sys
input = sys.stdin.readline
def main():
N, K, S = map(int, input().split())
if S == 10 ** 9:
ans = [S] * K + [1] * (N - K)
else:
ans = [S] * K + [10 ** 9] * (N - K)
print(" ".join(map(str, ans)))
if __name__ == "__main__":
main()
| a,b,c=map(int, input().split(" "))
if a>c :
k=c
c=a
a=k
if c<b :
k=b
b=c
c=k
if b<a :
k=b
b=a
a=k
a,b,c=map(str,(a,b,c))
print(a+' '+b+' '+c) | 0 | null | 45,580,499,608,180 | 238 | 40 |
n, k = map(int, input().split())
A = list(map(int, input().split()))
now = 1000
for i in range(k, n):
#print(A[i], A[i-k])
if A[i] > A[i-k]:
print("Yes")
else:
print("No") | N = int(input())
A = list(map(int, input().split()))
MOD = 10**9+7
def gcd(x, y):
while(x % y != 0 and y % x != 0):
if(x > y):
x = x % y
else:
y = y % x
if(x > y):
return y
else:
return x
def lcm(x, y, MOD):
return x * y // gcd(x, y)
X = 1
ans = 0
for i in range(N):
X = lcm(X, A[i], MOD)
for i in range(N):
ans = (ans + X*pow(A[i], MOD-2, MOD))%MOD
print(ans) | 0 | null | 47,241,903,422,288 | 102 | 235 |
def main():
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
from collections import Counter, deque
#from collections import defaultdict
from itertools import combinations, permutations, accumulate, groupby, product
from bisect import bisect_left,bisect_right
from heapq import heapify, heappop, heappush
import math
#inf = 10**17
#mod = 10**9 + 7
n,t = map(int, input().split())
ab = [list(map(int, input().split())) for _ in range(n)]
ab.sort(key=lambda x: x[1])
ab.sort(key=lambda x: x[0])
dp = [-1]*(t+1)
dp[0] = 0
for a, b in ab:
for j in range(t-1, -1, -1):
if dp[j] >= 0:
if j+a<=t:
dp[j+a] = max(dp[j+a], dp[j]+b)
else:
dp[-1] = max(dp[-1], dp[j]+b)
print(max(dp))
if __name__ == '__main__':
main() | n,t=map(int,input().split())
dp=[[-1 for j in range(2)] for i in range(t+1)]
dp[0][0]=0
d=[]
for i in range(n):
d.append(list(map(int,input().split())))
d.sort()
for i in range(n):
for j in range(t,-1,-1):
for k in range(1,-1,-1):
if k==0:
if dp[j][k]>=0 and j+d[i][0]<t:
dp[j+d[i][0]][k]=max(dp[j+d[i][0]][k],dp[j][k]+d[i][1])
if k==1:
if dp[j][0]>=0:
dp[j][k]=max(dp[j][k],dp[j][0]+d[i][1])
ans=0
for i in range(t+1):
for j in range(2):
ans=max(ans,dp[i][j])
print(ans)
| 1 | 151,653,704,493,248 | null | 282 | 282 |
# Aizu Problem 0003: Is it a Right Triangle?
#
import sys, math, os
# read input:
PYDEV = os.environ.get('PYDEV')
if PYDEV=="True":
sys.stdin = open("sample-input.txt", "rt")
N = int(input())
for __ in range(N):
a, b, c = sorted([int(_) for _ in input().split()])
print("YES" if c**2 == a**2 + b**2 else "NO") | from collections import defaultdict
def main():
n = int(input())
a = list(map(int, input().split(" ")))
d = defaultdict(lambda:0)
for i in range(n):
d[a[i]] += 1
if max(d.values()) >1:
print("NO")
else:
print("YES")
if __name__ == "__main__":
main() | 0 | null | 37,182,915,259,748 | 4 | 222 |
S = int(input())
A = [0,0,1]
if S == 1 or S == 2:
print(0)
elif S == 3:
print(1)
else:
for i in range(3,S):
A += [A[i-1] + A[i-3]]
print(A[i] % (10 ** 9 + 7)) | L = int(input())
num = L / 3
print(num**3) | 0 | null | 25,241,126,215,566 | 79 | 191 |
N=int(input())
if N==1:
print(0)
exit()
def primeryNum(n):
border=int(n**0.5)+1
ary=list(range(int(n**0.5)+2))
ary[1]=0
for a in ary:
if a>border: break
elif a==0: continue
for i in range(a*2,int(n**0.5)+2,a):
ary[i]=0
return ary
primeryNumL=primeryNum(N)
# print(primeryNumL)
ans=0
N_=N
for x in primeryNumL:
if x==0 or N%x!=0:
continue
n=N
cnt=0
while n%x==0:
cnt+=1
n/=x
N_//=x**cnt
buf=cnt-1
res=1
# print(x,cnt)
for i in range(2,cnt+1):
if buf<i:
break
buf-=i
res+=1
ans+=res
if N_>1:
ans+=1
print(ans)
| def resolve():
N = int(input())
def prime_factorize(n):
a = []
while n % 2 == 0:
a.append(2)
n //= 2
f = 3
while f * f <= n:
if n % f == 0:
a.append(f)
n //= f
else:
f += 2
if n != 1:
a.append(n)
return a
a = prime_factorize(N)
count_dict = {}
total_key = 0
for i in range(1024):
total_key += i
for j in range(total_key-i, total_key):
count_dict[j] = i-1
a_element_counter = {}
for i in a:
if i not in a_element_counter:
a_element_counter[i] = 0
a_element_counter[i] += 1
ans = 0
for e in a_element_counter.values():
ans += count_dict[e]
print(ans)
if __name__ == "__main__":
resolve() | 1 | 17,040,596,208,830 | null | 136 | 136 |
my_set = set()
n = int(input())
for _ in range(n):
command, dna = input().split()
if command == 'insert':
my_set.add(dna)
elif dna in my_set:
print('yes')
else:
print('no')
| if __name__ == "__main__":
n = int(input())
ops = []
words = []
for _ in range(n):
op, word = input().split()
ops.append(op)
words.append(word)
db = set()
for op, word in zip(ops, words):
if op=='insert':
db.add(word)
else:
if word in db:
print("yes")
else:
print("no")
| 1 | 78,409,218,408 | null | 23 | 23 |
N=int(input())
A=N/3
print(A*A*A) | l = int(input())
ll = float(l)
a=0
b=0
c=0
if(ll%3 == 0):
a=ll/3
b=ll/3
c=ll/3
else:
a=ll/3
b=a
c=ll-a-b
print(a*b*c) | 1 | 47,163,855,858,430 | null | 191 | 191 |
import sys
import numpy as np
from collections import defaultdict
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
N, K = lr()
A = np.array([1] + lr())
A = (A-1) % K
N += 1
# 累積和が同じになっている箇所に注目、要素がK-1離れている組み合わせは無理
Acum = (A.cumsum() % K).tolist()
answer = 0
dic = defaultdict(int)
for i, cur in enumerate(Acum):
answer += dic[cur]
dic[cur] += 1
if i >= K-1:
vanish = Acum[i-(K-1)]
dic[vanish] -= 1
print(answer)
# 10 | from collections import defaultdict
n, k = map(int, input().split())
seq = list(map(int, input().split()))
count = defaultdict(int)
count[0] = 1
prefix = [0]*(n+1)
ans = 0
for i in range(n):
pre = prefix[i+1] = (prefix[i] + seq[i] - 1)%k
if i >= k - 1:
count[prefix[i - k + 1]] -= 1
ans += count[pre]
count[pre] += 1
print(ans) | 1 | 137,504,402,515,662 | null | 273 | 273 |
#!/usr/bin/env python
import sys
input = sys.stdin.buffer.readline
sys.setrecursionlimit(10**6)
inf = float("inf")
import numpy as np
import scipy.sparse.csgraph as csg
def main():
N,M,L = map(int,input().split())
ABC = [tuple(map(int,input().split())) for _ in range(M)]
Q = int(input())
ST = [tuple(map(int,input().split())) for _ in range(Q)]
# 町の最短距離を求める
A = np.array([[inf]*N]*N)
for a,b,c in ABC:
A[a-1][b-1] = c
A[b-1][a-1] = c
A = csg.floyd_warshall(A)
# 求めた町の距離が L以下 に 1の辺をはる (給油なしでたどり着ける)
B = np.array([[inf]*N]*N)
for i in range(N):
for j in range(N):
if A[i][j] <= L:
B[i][j] = 1
# 最短距離を求める
B = csg.floyd_warshall(B)
for s,t in ST:
if B[s-1][t-1] == inf:
print(-1)
else:
print(int(B[s-1][t-1] - 1))
if __name__ == "__main__":
main() | N, M, L = map(int, input().split())
INF = float('inf')
d1 = [[INF]*N for _ in range(N)]
for _ in range(M):
a, b, c = map(int, input().split())
a -= 1
b -= 1
d1[a][b] = c
d1[b][a] = c
for i in range(N):
d1[i][i] = 0
for k in range(N):
for i in range(N):
for j in range(N):
d1[i][j] = min(d1[i][k] + d1[k][j], d1[i][j])
d2 = [[INF]*N for _ in range(N)]
for i in range(N):
for j in range(N):
if i == j:
d2[i][j] = 0
if d1[i][j] <= L and i != j:
d2[i][j] = 1
for k in range(N):
for i in range(N):
for j in range(N):
d2[i][j] = min(d2[i][k] + d2[k][j], d2[i][j])
Q = int(input())
for _ in range(Q):
s, t = map(int, input().split())
s -= 1
t -= 1
if d2[s][t] == INF:
print(-1)
else:
print(d2[s][t]-1)
| 1 | 173,488,332,843,278 | null | 295 | 295 |
a, b, c = map(int, input().split())
i = a
j = 0
while(a <= i and i <= b) :
if(c % i == 0) :
i += 1
j += 1
else :
i += 1
else :
print(j)
| import math
while True:
try:
a = list(map(int,input().split()))
b = (math.gcd(a[0],a[1]))
c = ((a[0]*a[1])//math.gcd(a[0],a[1]))
print(b,c)
except EOFError:
break
| 0 | null | 278,933,616,290 | 44 | 5 |
L, R, d = map(int, input().split())
if L%d==0:
st = L
else:
st = (L//d+1)*d
count = 0
for i in range(st, R+1, d):
if i <= R:
count += 1
else:
break
print(count) | import sys
read = sys.stdin.read
readline = sys.stdin.readline
count = 0
l, r, d= [int(x) for x in readline().rstrip().split()]
#print(l,r,d)
for i in range(l,r+1):
if i % d == 0:
count += 1
print(count)
| 1 | 7,506,421,666,628 | null | 104 | 104 |
'''
Created on 2020/08/20
@author: harurun
'''
def main():
import sys
pin=sys.stdin.readline
pout=sys.stdout.write
perr=sys.stderr.write
N=int(pin())
print((N-1)//2)
return
main() | n = int(input())
ans = 0
if n % 2 == 0:
for i in range(1, 36):
k = 5**i*2
ans += n//k
print(ans)
else:
print(ans) | 0 | null | 134,767,731,775,832 | 283 | 258 |
from collections import Counter,defaultdict,deque
from heapq import heappop,heappush
from bisect import bisect_left,bisect_right
import sys,math,itertools,fractions
sys.setrecursionlimit(10**8)
mod = 10**9+7
INF = float('inf')
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
n = inp()
a = inpl()
if 0 in set(a):
print(0)
quit()
res = 1
for x in a:
res *= x
if res > 10**18:
print(-1)
quit()
print(res) | N = int(input())
A = [int(a) for a in input().split()]
if A.count(0):
print(0)
exit(0)
ans=1
for a in A:
ans *= a
if ans > 10**18:
print(-1)
break
else:
print(ans)
| 1 | 16,215,788,046,918 | null | 134 | 134 |
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
from operator import itemgetter
# 区間スケジューリング
N = int(readline())
m = map(int,read().split())
XL = zip(m,m)
LR = [(x-l,x+l) for x,l in XL]
LR.sort(key = itemgetter(1))
INF = 10 ** 18
prev_R = -INF
cnt = 0
for L,R in LR:
if prev_R > L:
continue
cnt += 1
prev_R = R
print(cnt)
| n = int(input())
robot = [0]*n
for i in range(n):
x,l = map(int,input().split())
robot[i] = (x+l, x-l)
robot.sort()
#print(robot)
ans = 1
right = robot[0][0]
for i in range(1,n):
if right <= robot[i][1]:
right = robot[i][0]
ans += 1
print(ans) | 1 | 89,739,114,698,002 | null | 237 | 237 |
from collections import Counter
N = int(input())
A = list(map(int, input().split()))
Q = int(input())
su = sum(A)
counter = Counter(A)
lis = {}
for i in range(Q):
B, C = map(int, input().split())
su -= B * counter[B]
su += C * counter[B]
counter[C] += counter[B]
counter[B] = 0
print(su) | from collections import defaultdict as d
n=int(input())
a=list(map(int,input().split()))
p=d(int)
l=0
for i in a:
p[i]+=1
l+=i
for i in range(int(input())):
b,c=map(int,input().split())
l+=p[b]*(c-b)
p[c]+=p[b]
p[b]=0
print(l) | 1 | 12,179,965,788,650 | null | 122 | 122 |
NK = input()
num = NK.split()
N = num[0]
K = num[1]
P = input()
Pn = P.split()
#print(Pn)
Pn_a = [int(i) for i in Pn]
Pn_b = sorted(Pn_a)
price = 0
for i in range(int(K)):
price += int(Pn_b[i])
print(price)
| S = input()
l = [0] * (len(S)+1)
r = [0] * (len(S)+1)
for i in range(len(S)):
if S[i] == '<':
l[i+1] = l[i] + 1
for i in range(len(S)-1,-1,-1):
if S[i] == '>':
r[i] = r[i+1] + 1
print(sum([max(l[i],r[i]) for i in range(len(S)+1)]))
| 0 | null | 83,859,355,763,050 | 120 | 285 |
import sys
def input(): return sys.stdin.readline().rstrip()
def main():
n=int(input())
A=list(map(int, input().split()))
ans = 0
mod = 10**9 + 7
for i in range(60):
q = sum(map(lambda x:((x >> i) & 0b1),A))
ans += q*(n-q)*pow(2, i, mod)
ans = ans % mod
print(ans)
if __name__=='__main__':
main() | import numpy as np
n = int(input())
a = list(map(int,input().split()))
mod = 10**9+7
ans = 0
a=np.array(a)
for i in range(60):
keta = a>>i & 1
num1 = int(keta.sum())
num0 = n - num1
ans+= ((2**i)%mod)*(num1*num0)
ans%=mod
print(ans) | 1 | 122,952,018,467,198 | null | 263 | 263 |
N = int(input())
plus = []
minus = []
for _ in range(N):
x, y = map(int, input().split())
plus.append(x + y)
minus.append(x - y)
print(max(max(plus) - min(plus), max(minus) - min(minus)))
| 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())
from collections import defaultdict
from collections import deque
import bisect
from decimal import *
from functools import reduce
def main():
N = I()
Dots = defaultdict()
xpyp = []
xpyn = []
xnyp = []
xnyn = []
for i in range(N):
x, y = MI()
Dots[i] = (x, y)
xpyp.append(x + y)
xpyn.append(x - y)
xnyp.append(- x + y)
xnyn.append(- x - y)
xpyp_max = max(xpyp) - min(xpyp)
xpyn_max = max(xpyn) - min(xpyn)
xnyp_max = max(xnyp) - min(xnyp)
xnyn_max = max(xnyn) - min(xnyn)
print(max(xpyp_max, xpyn_max, xnyp_max, xnyn_max))
if __name__ == "__main__":
main()
| 1 | 3,459,025,788,350 | null | 80 | 80 |
from bisect import bisect_left, bisect_right, insort_left
n = int(input())
s = list(input())
q = int(input())
d = {}
flag = {}
for i in list('abcdefghijklmnopqrstuvwxyz'):
d.setdefault(i, []).append(-1)
flag.setdefault(i, []).append(-1)
for i in range(n):
d.setdefault(s[i], []).append(i)
for i in range(q):
q1,q2,q3 = map(str,input().split())
if q1 == '1':
q2 = int(q2) - 1
if s[q2] != q3:
insort_left(flag[s[q2]],q2)
insort_left(d[q3],q2)
s[q2] = q3
else:
ans = 0
q2 = int(q2) - 1
q3 = int(q3) - 1
if q2 == q3:
print(1)
continue
for string,l in d.items():
res = 0
if d[string] != [-1]:
left = bisect_left(l,q2)
right = bisect_right(l,q3)
else:
left = 0
right = 0
if string in flag:
left2 = bisect_left(flag[string],q2)
right2 = bisect_right(flag[string],q3)
else:
left2 = 0
right2 = 0
if left != right:
if right - left > right2 - left2:
res = 1
ans += res
#print(string,l,res)
print(ans)
| from bisect import bisect_left, bisect, insort
def main():
n = int(input())
s = list(input())
q = int(input())
_is = {chr(i):[] for i in range(ord("a"), ord("a")+27)}
for i, si in enumerate(s):
_is[si].append(i)
for _ in range(q):
t, i, c = input().split()
i = int(i)-1
if t == "1":
if s[i] != c:
index = bisect_left(_is[s[i]], i)
del _is[s[i]][index]
insort(_is[c], i)
s[i] = c
else:
c = int(c) - 1
cnt = 0
for _isi in _is.values():
if _isi:
is_in = bisect(_isi, c)-bisect_left(_isi, i)
if is_in:
cnt += 1
print(cnt)
if __name__ == "__main__":
main()
| 1 | 62,899,528,341,890 | null | 210 | 210 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.