code1
stringlengths 16
24.5k
| code2
stringlengths 16
24.5k
| similar
int64 0
1
| pair_id
int64 2
181,637B
⌀ | question_pair_id
float64 3.71M
180,628B
⌀ | code1_group
int64 1
299
| code2_group
int64 1
299
|
|---|---|---|---|---|---|---|
from string import ascii_lowercase
N = int(input())
ans = ['a']
for i in range(1, N):
ans2 = []
for a in ans:
for b in ascii_lowercase[:len(set(a)) + 1]:
ans2 += [a + b]
ans = ans2
print('\n'.join(ans))
| def dfs(S, mx):
if len(S) == N:
print(S)
else:
for i in range(a, mx+2):
if i == mx+1:
dfs(S+chr(i), mx+1)
else:
dfs(S+chr(i), mx)
return
N = int(input())
a = ord('a')
dfs('a', a) | 1 | 52,184,775,009,080 | null | 198 | 198 |
import sys
n=int(input())
s=input()
if n%2==1:
print("No")
sys.exit()
else:
s1=s[:n//2]
s2=s[n//2:]
# print(s1,s2)
if s1==s2:
print("Yes")
else:
print("No") | r, c = map(int, input().split())
a, b, ans = [], [], []
for i in range(r):
a.append([int(x) for x in input().split()])
for i in range(c):
b.append(int(input()))
for i in range(r):
tmp = 0
for j in range(c):
tmp += a[i][j] * b[j]
ans.append(tmp)
for x in ans:
print(x) | 0 | null | 73,709,332,597,174 | 279 | 56 |
n = int(input())
a = [int(x) for x in input().split()]
s = 0
for i in a:
s ^= i
print(*[x ^ s for x in a]) | S = input()
if S =="AAA" or S == "BBB":
result = "No"
else:
result = "Yes"
print(result) | 0 | null | 33,792,235,041,162 | 123 | 201 |
A,B=map(int,input().split())
if A <10 and B <10:
print(A*B)
else:
print("-1")
| N = int(input())
D = list(map(int, input().split()))
mod = 998244353
counter = [0] * N
for d in D:
counter[d] += 1
if counter[0] != 1:
print(0)
exit()
ans = 1
for d in D[1:]:
ans = ans * counter[d-1] % mod
print(ans) | 0 | null | 155,863,301,135,428 | 286 | 284 |
import sys
input = sys.stdin.readline
#n = int(input())
#l = list(map(int, input().split()))
'''
a=[]
b=[]
for i in range():
A, B = map(int, input().split())
a.append(A)
b.append(B)'''
n=int(input())
a=""
l=[]
while n>0:
n-=1
mod=n%26
n//=26
l.append(mod)
#print(l)
for i in range(len(l))[::-1]:
a+=chr(97+l[i])
print(a) | import sys
n=int(input())
s=[list(input()) for i in range(n)]
L1=[]
L2=[]
for i in range(n):
ct3=0
l=[0]
for j in s[i]:
if j=='(':
ct3+=1
l.append(ct3)
else:
ct3-=1
l.append(ct3)
if l[-1]>=0:
L1.append((min(l),l[-1]))
else:
L2.append((min(l)-l[-1],-l[-1]))
L1.sort()
L1.reverse()
ct4=0
for i in L1:
if ct4+i[0]<0:
print('No')
sys.exit()
ct4+=i[1]
L2.sort()
L2.reverse()
ct5=0
for i in L2:
if ct5+i[0]<0:
print('No')
sys.exit()
ct5+=i[1]
if ct4!=ct5:
print('No')
sys.exit()
print('Yes') | 0 | null | 17,691,075,260,770 | 121 | 152 |
#!/usr/bin/env python3
import sys
# import math
# import re # re.compile(pattern) => ptn obj; p.search(s), p.match(s), p.finditer(s) => match obj; p.sub(after, s)
# from collections import deque # deque class. deque(L): dq.append(x), dq.appendleft(x), dq.pop(), dq.popleft(), dq.rotate()
# from collections import defaultdict # subclass of dict. defaultdict(facroty)
# from collections import Counter # subclass of dict. Counter(iter): c.elements(), c.most_common(n), c.subtract(iter)
# from heapq import heapify, heappush, heappop # built-in list. heapify(L) changes list in-place to min-heap in O(n), heappush(heapL, x) and heappop(heapL) in O(lgn).
# from heapq import nlargest, nsmallest # nlargest(n, iter[, key]) returns k-largest-list in O(n+klgn).
# from itertools import count, cycle, repeat # count(start[,step]), cycle(iter), repeat(elm[,n])
# from itertools import groupby # [(k, list(g)) for k, g in groupby('000112')] returns [('0',['0','0','0']), ('1',['1','1']), ('2',['2'])]
# from itertools import starmap # starmap(pow, [[2,5], [3,2]]) returns [32, 9]
# from itertools import product # product(iter, repeat=n)
# from itertools import accumulate # accumulate(iter[, f])
# from functools import reduce # reduce(f, iter[, init])
# from functools import lru_cache # @lrucache ...arguments of functions should be able to be keys of dict
# from bisect import bisect_left, bisect_right # bisect_left(a, x, lo=0, hi=len(a)) returns i such that all(val<x for val in a[lo:i]) and all(val>-=x for val in a[i:hi]).
# from copy import deepcopy # to copy multi-dimentional matrix without reference
# from fractions import gcd # for Python 3.4
def main():
mod = 1000000007 # 10^9+7
inf = float('inf')
sys.setrecursionlimit(10**6) # 1000 -> 1000000
def input(): return sys.stdin.readline().rstrip()
def ii(): return int(input())
def mi(): return map(int, input().split())
def mi_0(): return map(lambda x: int(x)-1, input().split())
def lmi(): return list(map(int, input().split()))
def lmi_0(): return list(map(lambda x: int(x)-1, input().split()))
def li(): return list(input())
h, w, k = mi()
L = []
for _ in range(h):
L.append(list(map(int, li())))
L_trans = [[None] * h for _ in range(w)]
for i in range(h):
for j in range(w):
L_trans[j][i] = L[i][j]
d = 2 ** (h-1)
cost = [float('inf')] * d
for state in range(d):
bit_count = bin(state)[2:].count('1')
separated = [[0] * (bit_count + 1) for _ in range(w)]
for i in range(w):
current = 0
for j in range(h):
if j >= 1 and 1 << (j-1) & state:
current += 1
if L_trans[i][j]:
separated[i][current] += 1
previous = [0] * (bit_count + 1)
cnt = 0
# print(separated)
for i in range(w):
if any(map(lambda x: x > k, separated[i])):
break
if all(map(lambda x: x <= k, [elm + previous[ind] for ind, elm in enumerate(separated[i])])):
# print(f"just add: {previous} {separated[i]}")
for ind, elm in enumerate(separated[i]):
previous[ind] += elm # 追加
else:
cnt += 1
# print(f"count up: {previous} {separated[i]}")
for ind, elm in enumerate(separated[i]):
previous[ind] = elm # 上書き
else:
cost[state] = bit_count + cnt
# print(cost)
print(min(cost))
if __name__ == "__main__":
main()
| import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
N, *A = map(int, read().split())
B = [0] * (N + 1)
for a in A:
B[a] += 1
total = 0
for b in B:
total += b * (b - 1) // 2
ans = [0] * N
for i, a in enumerate(A):
ans[i] = total - (B[a] - 1)
print('\n'.join(map(str, ans)))
return
if __name__ == '__main__':
main()
| 0 | null | 48,429,212,511,798 | 193 | 192 |
N, K = map(int, input().split())
R, S, P = map(int, input().split())
T = input()
scores = {'r': P, 's': R, 'p': S, 'default': 0}
win_flag = [False]*(N+1)
ans = 0
# Kの剰余で別々に考えていい
for i_k in range(K):
prev = 'default'
for i_n in range(i_k, N, K):
# K個前と違う手 もしくは K個前で勝たないことにした 場合
# => 点がもらえる
if (T[i_n] != prev) or (not win_flag[i_n-K]):
win_flag[i_n] = True
ans += scores[T[i_n]]
prev = T[i_n]
print(ans) | a = list(map(int, input().split()))
for i in range(10):
if a.count(i) == 2:
print('Yes')
exit()
print('No')
| 0 | null | 87,056,083,565,128 | 251 | 216 |
n = int(input())
cnt = 0
for i in range(1, 10):
if len(str(n//i)) == 1 and n%i == 0:
cnt +=1
if cnt >= 1:
print('Yes')
else :
print('No')
| n = int(input())
sumOfN = sum(int(i) for i in list(str(n)))
print("No" if sumOfN%9 else "Yes") | 0 | null | 81,785,318,457,158 | 287 | 87 |
from math import degrees, atan
a, b, x = map(int, input().split())
if a * a * b < x * 2:
c = 2 * (a * a * b - x) / a ** 3
else:
c = a * b * b / (2 * x)
print(degrees(atan(c))) | import math
a, b, x = map(int, input().split(" "))
cap = a * a * b
h = (x / cap) * b
if h / b >= 0.5:
gap = b - h
print(math.degrees(math.atan((gap / (a / 2)))))
else:
vol = h * a
gap = (vol / b) * 2
print(math.degrees(math.atan(b / gap))) | 1 | 163,143,010,048,810 | null | 289 | 289 |
n,m=map(int,input().split())
s=input()[::-1]
ans=[]
now=0
while(now<n):
t=1
for i in reversed(range(1,m+1)):
if now+i>n or s[now+i]=='1':
continue
now=now+i
ans.append(i)
t=0
break
if t:
print(-1)
exit()
ans.reverse()
print(*ans,sep=' ') | N, K = map(int, input().split())
numgcd = [0]*(K+1)
sumgcd = 0
mod = 10**9+7
for i in range(1, K+1)[::-1]:
numgcd[i] = pow(K//i, N, mod)
count = 2
while count*i <= K:
numgcd[i] -= numgcd[count*i]
count += 1
sumgcd += numgcd[i]*i
print(sumgcd%mod) | 0 | null | 88,226,714,325,480 | 274 | 176 |
n = int(input())
a = n // 100
b = n % 100
if 5 * a >= b :
print(1)
else :
print(0) | x = int(input())
dp = [True] + [False] * (x+110)
for i in range(len(dp)):
if not dp[i]: continue
for food in range(100, 106):
if i+food >= len(dp): continue
dp[i+food] = True
if dp[x]: print(1)
else: print(0) | 1 | 127,420,713,674,222 | null | 266 | 266 |
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
N = [int(x)-48 for x in read().rstrip()]
ans = 0
dp = [[0]*(len(N)+1) for i in range(2)]
dp[1][0] = 1
dp[0][0] = 0
for i in range(1, len(N)+1):
dp[0][i] = min(dp[0][i-1] + N[i-1],
dp[1][i-1] + (10 - N[i-1]))
dp[1][i] = min(dp[0][i-1] + N[i-1] + 1,
dp[1][i-1] + (10 - (N[i-1] + 1)))
print(dp[0][len(N)])
| s = "0"+input()
ans = 0
n = len(s)
f = 0
p = 0
for i in range(1,n+1):
n = int(s[-i])
# n += f
if p+(n>4) > 5:
f = 1
else:
# ans += f
f = 0
n += f
ans += min(n,10-n)
p = n
# ans += f
print(ans) | 1 | 71,287,555,045,260 | null | 219 | 219 |
n,m=map(int,input().split())
if (n>0) and (m>0):
print(int(n*(n-1)/2+m*(m-1)/2))
else:
print(int(max(n,m)*(max(n,m)-1)/2)) | n=int(input())
P=[int(x) for x in input().split()]
Q=[int(x) for x in input().split()]
p=tuple(P)
q=tuple(Q)
l=list(range(1,n+1))
L=[]
import itertools
for v in itertools.permutations(l):
L.append(v)
a=L.index(p)
b=L.index(q)
print(abs(a-b)) | 0 | null | 73,428,733,609,240 | 189 | 246 |
def check_p(p):
global k, ws
ct, nt = 0, 1
for w in ws:
if ct + w <= p:
ct += w
else:
nt += 1
if nt > k:
return False
ct = w
return True
n, k = map(int, input().split())
ws = [int(input()) for _ in range(n)]
l, r, p = max(ws), sum(ws), 0
while l < r:
p = (l + r) // 2
if check_p(p):
r = p
else:
l = p = p + 1
print(p) | import sys
input = lambda: sys.stdin.readline().rstrip()
sys.setrecursionlimit(10**7)
INF = 10**10
def I(): return int(input())
def F(): return float(input())
def SS(): return input()
def LI(): return [int(x) for x in input().split()]
def LI_(): return [int(x)-1 for x in input().split()]
def LF(): return [float(x) for x in input().split()]
def LSS(): return input().split()
def resolve():
n, k = LI()
Q = [I() for _ in range(n)]
def can_stack(p):
s = 0
truck_num = 1
for i in Q:
if s+i<=p:
s += i
else:
truck_num += 1
s = i
return truck_num<=k
ng = max(Q)-1
ok = sum(Q)
while abs(ok-ng)>1:
m = (ng+ok)//2
if can_stack(m):
ok = m
else:
ng = m
print(ok)
# for i in range(20):
# print(i, can_stack(i))
if __name__ == '__main__':
resolve()
| 1 | 91,273,064,834 | null | 24 | 24 |
H,N=map(int,input().split())
attack = list(map(int,input().split()))
total = sum(attack)
if H - total <= 0:
print("Yes")
else:
print("No") | h,n=map(int,input().split())
a=[int(x) for x in input().split()]
if sum(a) >= h:
print("Yes")
else:
print("No") | 1 | 77,772,020,816,292 | null | 226 | 226 |
C = input()
N = ord(C)
print(chr(N + 1)) | C = ord(input())
C += 1
print(chr(C))
| 1 | 92,011,740,471,600 | null | 239 | 239 |
import math
n,k=map(int,input().split())
A=list(map(int,input().split()))
low=1
high=max(A)
while low!=high:
mid=(low+high)//2
s=0
for i in range(n):
s+=math.ceil(A[i]/mid)-1
if s>k:
low=mid+1
else:
high=mid
print(low) | print((lambda x,y:'Yes'if y in x else'No')(input()*2,input()))
| 0 | null | 4,171,749,879,360 | 99 | 64 |
n, r0, g0 = map(int, input().split())
edges = [tuple(map(int, input().split())) for _ in range(n-1)]
connects = [[] for i in range(n+1)]
for e in edges:
connects[e[0]].append(e[1])
connects[e[1]].append(e[0])
rL, gL = [-1]*(n+1), [-1]*(n+1)
rL[r0], gL[g0] = 0, 0
from collections import deque
rQ, gQ = deque([r0]), deque([g0])
for L, Q in [(rL, rQ), (gL, gQ)]:
while Q:
node = Q.popleft()
for ni in connects[node]:
if L[ni] == -1:
L[ni] = L[node] + 1
### print((node, L[node]), (ni, L[ni]))
Q.append(ni)
print(max(gL[i] for i in range(1, n+1) if rL[i] < gL[i]) - 1) | W, H, x, y, r = map(int, raw_input().split())
if x < r:
print 'No'
elif W - x < r:
print 'No'
elif y < r:
print 'No'
elif H - y < r:
print 'No'
else:
print 'Yes' | 0 | null | 59,215,745,077,030 | 259 | 41 |
#!/usr/bin/env python
from sys import stdin, stderr
def main():
S = stdin.readline().strip()
if (len(S) % 2) != 0:
print('No')
return 0
for i in xrange(0, len(S), 2):
if S[i:i+2] != 'hi':
print('No')
return 0
print('Yes')
return 0
if __name__ == '__main__': main()
| n=int(input())
s=input()
ans=0
for i in range(10):
idx1=s.find(str(i))
for j in range(10):
idx2=s.find(str(j),idx1+1,n)
for k in range(10):
idx3=s.find(str(k),idx2+1,n)
if idx1==-1 or idx2==-1 or idx3==-1:
continue
else:
ans+=1
print(ans) | 0 | null | 90,821,308,994,140 | 199 | 267 |
# -*- coding: utf-8 -*-
S = input()
ans = 'Yes'
for i in range(len(S)//2):
if S[i] != S[len(S)-1-i]:
ans = 'No'
front = S[0:(len(S)-1)//2]
for i in range(len(front)//2):
if front[i] != front[len(front)-1-i]:
ans = 'No'
end = S[(len(S)+1)//2:]
for i in range(len(end)//2):
if end[i] != front[len(end)-1-i]:
ans = 'No'
print(ans) | s = input()
n = len(s)
n2 = (n+1)//2
for i in range(n):
if(s[i] != s[n-i-1]):
print("No")
exit()
for i in range((n-1)//2):
if(s[i] != s[n2-2-i]):
print("No")
exit()
if(s[n2+i] != s[n-i-1]):
print("No")
exit()
print("Yes") | 1 | 46,252,634,984,110 | null | 190 | 190 |
from math import floor
from fractions import Fraction
a,b = input().split()
a = int(a)
b = Fraction(b)
print(floor(a*b)) | from math import floor
from decimal import Decimal
if __name__ == '__main__':
a, b = input().split()
a = int(a)
b = Decimal(b)
print(floor(a * b)) | 1 | 16,525,248,675,412 | null | 135 | 135 |
S = list(input())
T = list(input())
mindiff = len(S)
for i in range(len(S) - len(T) +1):
diff = 0
for j in range(len(T)):
if(S[i+j] != T[j]):
diff += 1
pass
if(diff < mindiff):
mindiff = diff
print(mindiff)
| str = input()
str2 = input()
nums = str.split()
nums2 = str2.split()
if len(nums2) != int(nums[1]):
print("error")
else:
totalDamege = 0
for num in nums2:
totalDamege += int(num)
if int(nums[0]) <= totalDamege:
print("Yes")
else:
print("No")
| 0 | null | 40,830,455,874,350 | 82 | 226 |
# 0がX個、1がY個ある(ただしX+Y=N)とき、Xorの組み合わせ自体は N*(N-1)//2 通りある。
# しかし、それらの和をとることを考えてみた時
# (0,0)と(1,1)を選んだ場合はそのXORは0になることに注意すると、(0,1)の組み合わせの個数だけ数えれば良い。
# これは、たとえば 〇〇〇●●●●(X=3,Y=4)から〇と●を選ぶ組み合わせは何個あるか、という問いと同じことなので
# Nの値には依存することはなく、単純にX*Y通りとなる。
# よって
# ΣΣ A_i Xor A_j = X*Y
# この処理によって、O(N^2)が、O(N)(=Aの各数字を一通り調べる)に減らせる。
# これを各ケタについて計算し、合計すれば良い。
# ケタ数が60まで定まっているので 計算量は O(Nlog(max(A)))≦ O(N*60)
# あるケタのbitを取り出すには ビットシフト「>>」でずらして下1ケタだけを見ると便利。
N=int(input())
A=list(map(int,input().split()))
p=10**9+7
ans=0
for k in range(60):
cnt_z=0
cnt_o=0
#print(A)
for i in range(N):
s=A[i]%2
if s==0:
cnt_z +=1
else:
cnt_o +=1
A[i] >>= 1
ans += ((2**k)*cnt_z*cnt_o)%p
print(ans%p) | A = []
hit = []
for _ in range(3):
A.append(list(map(int, input().split())))
hit.append([False]*3)
N=int(input())
for _ in range(N):
b = int(input())
for i in range(3):
for j in range(3):
if A[i][j] == b:
hit[i][j] = True
break
for i in range(3):
if hit[i][0] and hit[i][1] and hit[i][2]:
print('Yes')
exit()
if hit[0][i] and hit[1][i] and hit[2][i]:
print('Yes')
exit()
if hit[1][1]:
if hit[0][0] and hit[2][2] or hit[2][0] and hit[0][2]:
print('Yes')
exit()
print('No')
| 0 | null | 90,893,482,074,118 | 263 | 207 |
s=set()
l = [0] * ( 10 ** 5 + 1 )
sum=0
N = int(input())
A = list(map(int, input().split()))
for i in range(len(A)):
l[A[i]] += 1
s.add(A[i])
sum += A[i]
Q = int(input())
for i in range(Q):
B, C = map(int, input().split())
if l[B] > 0:
s.add(C)
sum = sum + l[B] * ( C - B )
l[C] += l[B]
l[B] = 0
s.discard(B)
print(sum)
| def solve():
N = int(input())
A = [int(i) for i in input().split()]
counter = {}
total = 0
for num in A:
total += num
counter[num] = counter.get(num, 0) + 1
Q = int(input())
for i in range(Q):
B,C = [int(i) for i in input().split()]
if B in counter:
B_cnt = counter[B]
counter[C] = counter.get(C, 0) + B_cnt
total += (C-B) * B_cnt
counter[B] = 0
print(total)
if __name__ == "__main__":
solve() | 1 | 12,282,145,551,500 | null | 122 | 122 |
# -*- coding:utf-8 -*-
from collections import deque
result = deque()
def operation(command):
if command[0] == "insert":
result.appendleft(command[1])
elif command[0] == "delete":
if command[1] in result:
result.remove(command[1])
elif command[0] == "deleteFirst":
result.popleft()
elif command[0] == "deleteLast":
result.pop()
n = int(input())
for i in range(n):
command = input().split()
operation(command)
print(*result) | import sys
from collections import deque
queue = deque()
for _ in range(int(sys.stdin.readline())):
commands = sys.stdin.readline()[:-1].split(" ")
if commands[0] == "insert":
queue.appendleft(commands[1])
elif commands[0] == "delete":
try:
queue.remove(commands[1])
except ValueError:
pass
elif commands[0] == "deleteFirst":
queue.popleft()
elif commands[0] == "deleteLast":
queue.pop()
print(" ".join(queue)) | 1 | 49,845,638,180 | null | 20 | 20 |
n,k=map(int,input().split())
lst=[list(map(int,input().split())) for i in range(k)]
mod=998244353
dp=[0]*(2*n+10)
dp[0]=1
dp[1]=-1
for i in range(n):
for l,r in lst:
dp[i+l]+=dp[i]
dp[i+r+1]-=dp[i]
dp[i+1]+=dp[i]
dp[i+1]%=mod
print(dp[n-1]) | # -*- coding: utf-8 -*-
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
MOD = 998244353
class BIT2:
def __init__(self, N):
self.N = (N+1)
self.data0 = [0] * (N+1)
self.data1 = [0] * (N+1)
def _add(self, data, k, x):
while k < self.N: #k <= Nと同義
data[k] += x
k += k & -k
def _sum(self, data, k):
s = 0
while k:
s += data[k]
k -= k & -k
return s
def add(self, l, r, x):
self._add(self.data0, l, -x*(l-1))
self._add(self.data0, r, x*(r-1))
self._add(self.data1, l, x)
self._add(self.data1, r, -x)
def sum(self, l, r):
return self._sum(self.data1, r-1) * (r-1) + self._sum(self.data0, r-1) - self._sum(self.data1, l-1) * (l-1) - self._sum(self.data0, l-1)
N, K = map(int, readline().split())
bit = BIT2(N)
d = []
for _ in range(K):
L,R = map(int, readline().split())
d.append((L,R))
bit.add(1,2,1)
for i in range(2,N+1):
for k in range(K):
L,R = d[k]
tmp = bit.sum(max(1,i-R),max(1,i-L+1))%MOD
bit.add(i,i+1,tmp)
print(bit.sum(N,N+1)%MOD) | 1 | 2,734,523,095,172 | null | 74 | 74 |
h, w, k = map(int, input().split())
s = [input() for _ in range(h)]
ans = []
vacant = 0
cnt = 0
for x in range(h):
if s[x] == '.' * w:
vacant += 1
continue
else:
cnt += 1
tmp = []
yet = False
for y in range(w):
if s[x][y] == '#':
if not yet:
yet = True
else:
cnt += 1
tmp.append(cnt)
for _ in range(vacant + 1):
ans.append(tmp)
vacant = 0
for _ in range(vacant):
ans.append(ans[-1])
for a in ans:
print(*a, sep=" ") | import sys
input = sys.stdin.readline
from operator import itemgetter
sys.setrecursionlimit(10000000)
INF = 10**30
M = []
w = 0
h = 0
num = 1
def solve2(p, q, r, s, ans):
global num
for i in range(p, q+1):
for j in range(r, s+1):
ans[i][j] = num
num += 1
return ans
def solve(p, q, ans):
v = []
for i in range(p, q+1):
for j in range(w):
if M[i][j] == '#':
v.append(j)
v.sort()
prev = 0
for i, b in enumerate(v):
if i == len(v)-1:
ans = solve2(p, q, prev, w-1, ans)
else:
ans = solve2(p, q, prev, b, ans)
prev = b+1
return ans
def main():
global M, h, w
h, w, k = list(map(int, input().strip().split()))
M = [0] * h
G = [False] * h
ans = [[0] * w for _ in range(h)]
total1Row = 0
for i in range(h):
M[i] = input().strip()
if '#' in M[i]:
G[i] = True
total1Row += 1
prev = 0
vc = 0
for i, v in enumerate(G):
if v and vc == total1Row-1:
ans = solve(prev, h-1, ans)
elif v:
vc += 1
ans = solve(prev, i, ans)
prev = i+1
for i in range(h):
print(" ".join(str(s) for s in ans[i]))
if __name__ == '__main__':
main()
| 1 | 143,506,295,535,712 | null | 277 | 277 |
N, K = list(map(int, input().split(' ')))
marks = list(map(int, input().split(' ')))
for i in range(N-K):
if marks[i] < marks[K+i]:
print('Yes')
else:
print('No') | n, k = map(int, input().split())
a_nums = list(map(int, input().split()))
f_point = sum(a_nums[:k])
for i in range(n - k):
if a_nums[i] < a_nums[i + k]:
print("Yes")
else:
print("No") | 1 | 7,056,945,748,160 | null | 102 | 102 |
from sys import stdin
input = stdin.readline
a = input().rstrip()
if a.isupper():
print("A")
else:
print("a") | a = input()
al=[chr(ord('a') + i) for i in range(26)]
if a in al:
print("a")
else:
print("A") | 1 | 11,233,006,737,698 | null | 119 | 119 |
def fib(n):
if n ==0 or n == 1:
return 1
l = [0] * (n+1)
l[0] = 1
l[1] = 1
for i in range(2,n+1):
l[i] = l[i-2] + l[i-1]
return l[i]
print(fib(int(input())))
| # Aizu Problem ALDS_1_10_A: Fibonacci Number
#
import sys, math, os
# read input:
PYDEV = os.environ.get('PYDEV')
if PYDEV=="True":
sys.stdin = open("sample-input.txt", "rt")
n = int(input())
if n < 2:
print(1)
else:
a, b = 1, 1
for k in range(n - 1):
a, b = b, a + b
print(b) | 1 | 1,908,472,940 | null | 7 | 7 |
sectional_view = input()
list_index_down = []
list_index_area_left = []
list_area = []
for index_now, mark in enumerate(sectional_view):
if mark == "\\":
list_index_down += [index_now]
elif mark == "/" and list_index_down:
index_down_last = list_index_down.pop()
area = index_now - index_down_last
while ((list_index_area_left) and
(list_index_area_left[-1] > index_down_last)):
area += list_area.pop()
list_index_area_left.pop()
list_index_area_left.append(index_down_last)
list_area.append(area)
print(sum(list_area))
print(len(list_area),*(list_area))
| def marge_ponds(lx, area_of_pond):
global ponds
if ponds:
lp = ponds.pop()
if lp[0] > lx:
return marge_ponds(lx, area_of_pond + lp[1])
else:
ponds.append(lp)
return area_of_pond
terrains = input().strip()
x, last_x, ponds = 0, [], []
for terrain in terrains:
if terrain == '\\':
last_x.append(x)
elif terrain == '/':
if last_x:
lx = last_x.pop()
area_of_pond = marge_ponds(lx, x - lx)
ponds.append((lx, area_of_pond))
x += 1
print(sum(pond[1] for pond in ponds))
ponds.insert(0, (0, len(ponds)))
print(' '.join(map(str, [pond[1] for pond in ponds]))) | 1 | 61,505,132,338 | null | 21 | 21 |
n=int(input())
print(((n-1)//2+1)/n)
| n = int(input())
if n % 2 == 0:
n1 = n / 2
print(n1 / n)
else:
n2 = (n - 1) / 2
print((n2 + 1) / n) | 1 | 177,510,660,702,772 | null | 297 | 297 |
#!/usr/bin/env python3
l, r, d = map(int, input().split())
n = (l-1) // d + 1
m = r // d
print(m-n+1) | l, r, d = map(int, input().split())
num = 0
for i in range(r - l +1):
if (i + l) / d == int((i + l) / d):
num += 1
print(num)
| 1 | 7,638,921,157,290 | null | 104 | 104 |
ans = 0
n = 0
h = int(input())
while h != 1:
h = h//2
n += 1
for i in range(n + 1):
ans = ans + 2 ** i
print(ans) | H = int(input())
i = 1
cnt = 0
while H > 0:
H //= 2
cnt += i
i *= 2
print(cnt) | 1 | 80,161,585,117,380 | null | 228 | 228 |
import sys
import math
from collections import deque
sys.setrecursionlimit(1000000)
MOD = 10 ** 9 + 7
input = lambda: sys.stdin.readline().strip()
NI = lambda: int(input())
NMI = lambda: map(int, input().split())
NLI = lambda: list(NMI())
SI = lambda: input()
def make_grid(h, w, num): return [[int(num)] * w for _ in range(h)]
#隣接リスト 1-order
def make_adjlist_d(n, edges):
res = [[] for _ in range(n + 1)]
for edge in edges:
res[edge[0]].append(edge[1])
res[edge[1]].append(edge[0])
return res
def make_adjlist_nond(n, edges):
res = [[] for _ in range(n + 1)]
for edge in edges:
res[edge[0]].append(edge[1])
return res
#nCr
def cmb(n, r):
return math.factorial(n) // math.factorial(r) // math.factorial(n - r)
def main():
X, Y, A, B, C = NMI()
P = NLI()
Q = NLI()
R = NLI()
reds = [[1, p] for p in P]
greens = [[2, q] for q in Q]
skels = [[0, r] for r in R]
apples = reds + greens + skels
apples.sort(key=lambda x: x[1], reverse=True)
colors = [0, 0, 0]
limits = [10**9, X, Y]
ans = 0
for color, a in apples:
if sum(colors) >= X + Y:
break
if colors[color] <= limits[color] - 1:
colors[color] += 1
ans += a
continue
print(ans)
if __name__ == "__main__":
main() | x,y,a,b,c=map(int, input().split())
*p,=map(int, input().split())
*q,=map(int, input().split())
*r,=map(int, input().split())
from heapq import *
p=[-i for i in p]
q=[-i for i in q]
r=[-i for i in r]
heapify(p)
heapify(q)
heapify(r)
ans=0
cnt=0
pt=heappop(p)
qt=heappop(q)
rt=heappop(r)
n=x+y
while (x>=0 or y>=0) and cnt<n:
if rt==0:
if pt<=qt:
ans-=pt
x-=1
cnt+=1
if p and x>0: pt=heappop(p)
else: pt=0
else:
ans-=qt
y-=1
cnt+=1
if q and y>0: qt=heappop(q)
else: qt=0
elif pt<=rt:
ans-=pt
x-=1
cnt+=1
if p and x>0: pt=heappop(p)
else: pt=0
elif qt<=rt:
ans-=qt
y-=1
cnt+=1
if q and y>0: qt=heappop(q)
else: qt=0
else:
ans-=rt
cnt+=1
if r: rt=heappop(r)
else: rt=0
print(ans)
| 1 | 44,956,785,398,332 | null | 188 | 188 |
#!/usr/bin/python3
# -*- coding: utf-8 -*-
import sys
a, b, c = map(int, sys.stdin.readline().split())
num_div = 0
for x in range(a, b+1):
if c % x == 0:
num_div += 1
print(num_div)
| deglist = raw_input().split(" ")
a = int(deglist[0])
b = int(deglist[1])
c = int(deglist[2])
cnt = 0
for x in range(a, b+1):
if c % x == 0:
cnt += 1
print cnt | 1 | 552,118,866,460 | null | 44 | 44 |
import sys
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 = map(int, sys.stdin.readline().strip().split())
w = []
for i in range(n):
w.append(int(sys.stdin.readline()))
L = max(w)
if check(L):
print(L)
else:
R = sum(w)
assert check(R)
while L + 1 < R:
M = (L + R) // 2
if check(M):
R = M
else:
L = M
print(R) | n, k = list(map(int, input().split(' ')))
r, s, p = list(map(int, input().split(' ')))
d = dict(r=p,
s=r,
p=s)
ttt = input()
ans = 0
prevs = []
for i in range(n):
if i < k or ttt[i] != prevs[i-k]:
ans += d[ttt[i]]
prevs.append(ttt[i])
else:
prevs.append('hoge')
print(ans)
| 0 | null | 53,476,853,609,530 | 24 | 251 |
# ?????????????????°???????????????????¨??????????????????°??????
while 1:
# ?¨??????\???????????°???????????????
input_num = list(input())
# ???????????????"0"??\?????§??????
if int(input_num[0]) == 0:
break
# print(input_num)
# ??????????¨?????????????????????°
digitTotal = 0
for i in range(0, len(input_num)):
digitTotal += int(input_num[i])
print("{0}".format(digitTotal)) | while True:
ab = [int(x) for x in input().split()]
a, b = ab[0], ab[1]
if a == 0 and b == 0:
break
if a > b:
a, b = b, a
print("{0} {1}".format(a, b)) | 0 | null | 1,053,812,857,088 | 62 | 43 |
from itertools import accumulate
def myAnswer(N:int,A:list) -> int:
accum = list(accumulate(A))
ans = 10**10
now = accum.pop()
for a in accum:
if(abs(now - a - a) < ans):
ans = abs(now - 2*a)
return ans
def modelAnswer():
tmp=1
def main():
N = int(input())
A = list(map(int,input().split()))
print(myAnswer(N,A[:]))
if __name__ == '__main__':
main()
| n=int(input())
a=list(map(int,input().split()))
suma=sum(a)
f=0
p=suma-2*f
for i in a:
f+=i
p=min(p,abs(suma-2*f))
print(p) | 1 | 142,070,204,355,420 | null | 276 | 276 |
n = int(input())
xy = [map(int, input().split()) for _ in range(n)]
x, y = [list(i) for i in zip(*xy)]
count = 0
buf = 0
for xi, yi in zip(x, y):
if xi == yi:
buf += 1
else:
if buf > count:
count = buf
buf = 0
if buf > count:
count = buf
if count >= 3:
print('Yes')
else:
print('No') | def input_array():
return list(map(int,input().split()))
n=int(input())
D=[input_array() for i in range(n)]
count=0
for d in D:
if d[0]==d[1]:
count+=1
else:
count=0
if count==3:
break
if count==3:
print("Yes")
else:
print("No") | 1 | 2,488,806,940,168 | null | 72 | 72 |
import itertools
line1 = input().split()
rei = input().split()
rei =list(map(int,rei))
den =input().split()
den =list(map(int,den))
cupon =[list(map(int,input().split())) for i in range(int(line1[2]))]
rei_mi = min(rei)
den_mi =min(den)
no_total =rei_mi +den_mi
for s in range(int(line1[2])):
yes_total =int(rei[cupon[s][0]-1]) +int(den[cupon[s][1]-1]) - cupon[s][2]
if no_total > yes_total:
no_total =yes_total
print(no_total)
| N = int(input())
l = list(map(int,input().split()))
def is_ok(n, su):
return l[n] > su
def binary_search(left, right, su):
while (abs(right - left) > 1):
mid = (left + right) // 2
if is_ok(mid, su): right = mid
else: left = mid
return right
l = sorted(l)
ans = 0
for i in range(2, N):
for j in range(1, i):
left = j
right = -1
ret = binary_search(right, left, l[i] - l[j])
if ret != right: ans += j - ret
print(ans) | 0 | null | 112,725,109,538,042 | 200 | 294 |
import os, sys, re, math
N = int(input())
print(((N + 1) // 2) / N)
| t1, t2 = map(int, input().split())
a1, a2 = map(int, input().split())
b1, b2 = map(int, input().split())
a = a1 - b1
b = a2 - b2
if a < 0:
a = -a
b = -b
p = t1 * a + t2 * b
if p > 0:
print(0)
exit()
if p == 0:
print('infinity')
exit()
top = a * t1
p = -p
ans = (top // p + 1) * 2 - 1 - (top % p == 0)
print(ans) | 0 | null | 154,397,085,659,570 | 297 | 269 |
S = raw_input()
areas = []
stack = []
for i,c in enumerate(S):
if c == "\\":
stack.append(i)
elif c == "/":
if len(stack) > 0:
j = stack.pop()
area = i-j
while len(areas) > 0:
p,a = areas.pop()
if j < p:
area += a
else:
areas.append((p, a))
break
areas.append((j, area))
A = map(lambda x:x[1], areas)
print sum(A)
if len(A) == 0:
print "0"
else:
print len(A), " ".join(map(str, A))
| s = input()
length = len(s)
a = [0] * (length + 1)
b = [0] * length
y = 0
for i in range(length):
if s[i] == '/':
y += 1
elif s[i] == '\\':
y -= 1
a[i + 1] = y
m = -30000
for i in range(length, 0, -1):
m = max(m, a[i])
b[i - 1] = m
i = 0
memory = []
while i < length:
if a[i] > b[i]:
i += 1
continue
start = a[i]
i += 1
base = 1
d_from = s[i - 1]
ws_part = 0
while i < length + 1 and a[i] < start:
d_to = s[i]
ws_part += base
if d_from == '\\' and d_to == '\\':
base += 2
if d_from == '\\' and d_to == '_':
base += 1
if d_from == '/' and d_to == '/':
base -= 2
if d_from == '/' and d_to == '_':
base -= 1
if d_from == '_' and d_to == '\\':
base += 1
if d_from == '_' and d_to == '/':
base -= 1
d_from = d_to
i += 1
if ws_part > 0:
ws_part += 1
memory.append(ws_part // 2)
print(sum(memory))
if memory:
print(len(memory), ' '.join(map(str, memory)))
else:
print(len(memory))
| 1 | 58,441,476,772 | null | 21 | 21 |
n = int(input())
s = list(input())
p = s[0]
ans = 1
for i in s[1:]:
if p!=i:
p = i
ans += 1
print(ans)
| import math
from math import gcd
INF = float("inf")
import sys
input=sys.stdin.readline
import itertools
from collections import Counter
def main():
n = int(input())
s = input().rstrip()
ans = [s[0]]
now = s[0]
for i in s[1:]:
if i != now:
ans.append(i)
now = i
print(len(ans))
if __name__=="__main__":
main()
| 1 | 169,811,647,715,168 | null | 293 | 293 |
N, K = list(map(int, input().split(' ')))
marks = list(map(int, input().split(' ')))
for i in range(N-K):
if marks[i] < marks[K+i]:
print('Yes')
else:
print('No') | #左からn個目でendが特定の色の場合に
N,M,K = list(map(int,input().split()))
def xgcd(a, b):
x0, y0, x1, y1 = 1, 0, 0, 1
while b != 0:
q, a, b = a // b, b, a % b
x0, x1 = x1, x0 - q * x1
y0, y1 = y1, y0 - q * y1
return a, x0, y0
def modinv(a, m):
g, x, y = xgcd(a, m)
if g != 1:
raise Exception('modular inverse does not exist')
else:
return x % m
def combination(n, k, mod=1e9+7) -> int:
ret = 1
for i in range(1, k+1):
ret = (ret * (n-k+i) * modinv(i, mod))%mod
return int(ret)
def pow(base, exponent, mod=1e9+7) -> int:
if exponent == 0:
return 1
if exponent > 1:
d,m = divmod(exponent, 2)
return (base**m * pow(base, d, mod)**2 ) % mod
else:
return base
m = 998244353
res = 0
B = 1
if M != 1:
mi = modinv(M-1,m)
A = M * pow(M-1,N-1,m)
for k in range(K+1):
if k>0:
B = (B*(N-k)*modinv(k,m))%m
res = (res+ A*B)%m
A = (A*mi)%m
print (res)
else:
if K == N-1:
print(1)
else:
print(0) | 0 | null | 15,116,030,211,360 | 102 | 151 |
s=list(input())
t=list(input())
n=len(s)
m=len(t)
if m==n+1:
for i in range(n):
if s[i]==t[i]:
continue
if s[i]!=t[i]:
print('No')
exit()
print('Yes')
else:
print('No')
| a = [str(input()) for i in range(2)]
s = a[0]
t = a[1]
s_l = len(s)
S = s + t[s_l]
if S == t:
print('Yes')
else:
print('No') | 1 | 21,362,914,751,580 | null | 147 | 147 |
N=int(input())
a=0
ans=float('inf')
x=list(map(int,input().split()))
for i in range(100):
for j in range(N):
a=a+(x[j]-i-1)**2
#print(a)
ans=min(ans,a)
a=0
print(ans)
| a = [list(map(int, input().split())) for _ in range(3)]
n = int(input())
b = [int(input()) for _ in range(n)]
bingo = 'No'
for t in zip(*a):
a.append(list(t))
a.append([a[i][i] for i in range(3)])
a.append([a[i][2-i]for i in range(3)])
for line in a:
if all(item in b for item in line):
bingo = 'Yes'
break
print(bingo)
| 0 | null | 62,608,971,856,870 | 213 | 207 |
import sys
import fractions
input = lambda: sys.stdin.readline().rstrip()
def lcm(x, y):
return (x * y) // fractions.gcd(x, y)
def main():
a, b = map(int, input().split())
print(lcm(a, b))
if __name__ == '__main__':
main() | H,N = (int(x) for x in input().split())
A = [int(x) for x in input().split()]
if sum(A)>=H:
print('Yes')
else:
print('No') | 0 | null | 95,453,793,941,742 | 256 | 226 |
n = int(input())
arr = list(map(int,input().split()))
nums = list(set(arr))
nums.sort()
last = nums[-1]
from collections import Counter
arr = Counter(arr)
ans = 0
for i in nums:
if arr[i] == 1:
ans += 1
for j in range(last//i+1):
del arr[i*j]
print(ans) | n, m, l = [int (x) for x in input().split(' ')]
a = [[0 for i in range(m)] for j in range(n)]
b = [[0 for i in range(l)] for j in range(m)]
c = [[0 for i in range(l)] for j in range(n)]
for s in range(0,n):
a[s] = [int (x) for x in input().split(' ')]
for s in range(0,m):
b[s] = [int (x) for x in input().split(' ')]
for i in range(0,n):
for k in range(0,l):
result = 0
for j in range(0,m):
result += a[i][j] * b[j][k]
c[i][k] = result
for i in range(0,n):
c[i] = [str(c[i][j]) for j in range(0,l)]
print(' '.join(c[i])) | 0 | null | 7,866,631,406,580 | 129 | 60 |
a,b = map(str,input().split())
c = list(a)
d = list(b)
if len(c) == 1 and len(d) == 1:
print(int(a)*int(b))
else:
print(-1) | s=int(input())
a=s//3600
b=(s%3600)//60
c=(s%3600)%60
print(str(a)+":"+str(b)+":"+str(c))
| 0 | null | 79,003,142,083,060 | 286 | 37 |
W, H, x, y, r = map(int, input().split())
if x - r < 0 or x + r > W or y - r < 0 or y + r > H:
print('No')
else:
print('Yes')
| w,h,x,y,r=map(int,raw_input().split())
if min(x,y,w-x,h-y)<r:
print 'No'
else:
print 'Yes' | 1 | 461,031,826,102 | null | 41 | 41 |
def main():
n = int(input())
alp = 'abcdefghijklmnopqrstuvwxyz'
answer = ''
while n >= 1:
n -= 1
answer += alp[n % 26]
n //= 26
real_answer = ''
for i in range(1, len(answer) + 1):
real_answer += answer[-i]
print(real_answer)
if __name__ == '__main__':
main() | # https://atcoder.jp/contests/abc172/tasks/abc172_a
def calc(a):
return a + (a ** 2) + (a ** 3)
a = int(input())
print(calc(a)) | 0 | null | 11,118,604,004,948 | 121 | 115 |
while 1:
x,y = map( int , raw_input().split() )
if x == 0 and y == 0:
break
elif x <= y:
print "%d %d" %(x,y)
elif y < x :
print "%d %d" %(y,x) | from itertools import combinations
N,M = map(int,input().split())
a=["A" for i in range(0,N)]
b=["B" for i in range(0,M)]
tmp1=(len(list(combinations(a,2))))
tmp2=(len(list(combinations(b,2))))
print(tmp1+tmp2) | 0 | null | 22,978,947,905,898 | 43 | 189 |
import sys
import math
#r = map(int,input().split())
r = float(input())
print ('%.5f %.5f'% (r**2*math.pi, 2*r*math.pi)) | x = int(input())
A = str()
for i in range(x):
A = A + 'ACL'
i += 1
print(A) | 0 | null | 1,419,088,756,992 | 46 | 69 |
from scipy.sparse import csr_matrix
from scipy.sparse.csgraph import floyd_warshall
N, M, L = map(int, input().split())
start = []
goal = []
cost = []
for _ in range(M):
A, B, C = map(int, input().split())
A -= 1
B -= 1
start.append(A)
goal.append(B)
cost.append(C)
start.append(B)
goal.append(A)
cost.append(C)
graph = csr_matrix((cost, (start, goal)), shape = (N, N))
can_reach_with_L = floyd_warshall(graph, directed = False)
can_reach_with_L[can_reach_with_L > L] = 0
ans = floyd_warshall(can_reach_with_L, directed = False, unweighted = True)
Q = int(input())
for _ in range(Q):
s, t = map(int, input().split())
s -= 1
t -= 1
if ans[s][t] == float('inf'):
print(-1)
else:
print(int(ans[s][t] + 0.5) - 1)
| import sys
input=sys.stdin.readline
N,M,L=map(int,input().split())
def warshall_floyd(d):
#d[i][j]: iからjへの最短距離
for k in range(size_v):
for i in range(size_v):
for j in range(size_v):
d[i][j]=min(d[i][j],d[i][k]+d[k][j])
return d
# vlistに点のリスト、dist[vi][vj]に辺(vi,vj)のコストを入れて呼び出す
size_v=N+1
dist=[[float("inf")]*size_v for i in range(size_v)]
for _ in range(M):
A,B,C=map(int,input().split())
dist[A][B]=C
dist[B][A]=C
for i in range(size_v):
dist[i][i]=0 #自身のところに行くコストは0
dist=warshall_floyd(dist)
#print(dist)
dist2=[[float("inf")]*size_v for i in range(size_v)]
for i in range(size_v):
for j in range(size_v):
if dist[i][j]<=L:
dist2[i][j]=1
for i in range(size_v):
dist2[i][i]=0 #自身のところに行くコストは0
dist2=warshall_floyd(dist2)
#print(dist2)
Q=int(input())
for _ in range(Q):
s,t=map(int,input().split())
answer=dist2[s][t]-1
if answer==float("inf"):
print(-1)
else:
print(answer) | 1 | 173,423,687,704,696 | null | 295 | 295 |
import sys
sys.setrecursionlimit(10000000)
MOD = 10 ** 9 + 7
INF = 10 ** 15
def main():
K = int(input())
S = input()
M = len(S)
N = M + K
MAXN = N + 2
fact = [1]
for i in range(1,MAXN + 1):
fact.append(fact[-1]*i%MOD)
inv_fact = [-1] * (MAXN + 1)
inv_fact[-1] = pow(fact[-1],MOD - 2,MOD)
for i in range(MAXN - 1,-1,-1):
inv_fact[i] = inv_fact[i + 1]*(i + 1)%MOD
nck = lambda N,K: 0 if K > N or K < 0 else fact[N]*inv_fact[N - K]*inv_fact[K]%MOD
power25 = [1]
power26 = [1]
for i in range(N):
power25.append(power25[-1]*25%MOD)
power26.append(power26[-1]*26%MOD)
ans = 0
for i in range(M,N + 1):
ans += nck(i - 1,M - 1) * power25[i - M] * power26[N - i] % MOD
ans %= MOD
print(ans)
if __name__ == '__main__':
main() | def main():
n = int(input())
if n % 2 == 0 and n >= 10:
m = n // 2
k = 5
m5 = 0
while k <= m:
m5 += m // k
k *= 5
else:
m5 = 0
print(m5)
if __name__ == '__main__':
main()
| 0 | null | 64,712,247,567,140 | 124 | 258 |
n=int(input())
A=list(map(int,input().split()))
B=list(map(int,input().split()))
for i in range(1,4):
cnt=0
for j in range(n):
cnt+=abs(A[j]-B[j])**i
print(cnt**(1/i))
cnt=0
for j in range(n):
cnt=max(cnt,abs(A[j]-B[j]))
print(cnt)
| n = int(input())
print(int(n / 2) - 1 if n % 2 == 0 else int(n / 2)) | 0 | null | 76,599,227,299,972 | 32 | 283 |
n = int(input())
cum = 0
d = dict()
for _ in range(n):
a, b = input().split()
b = int(b)
cum += b
d[a] = cum
c = input()
print(cum - d[c]) | l,r,d=map(int,input().split())
count=0
for i in range(d,r+1,d):
if l<=i<=r:
count+=1
print(count) | 0 | null | 51,991,903,409,152 | 243 | 104 |
L,R,d = map(int,input().split())
print(int(R/d)-int((L-1)/d)) | import numpy as np
import math
n=int(input())
a=[]
for i in range(n):
a.append(list(map(int,input().split())))
a=np.array(a, dtype=object)
ans=0
for i in range(n):
for j in range(n):
if i==j:
continue
else:
x= (a[i]-a[j])**2
hei=math.sqrt(sum(x))
ans+= hei/n
print(ans)
| 0 | null | 78,150,358,712,206 | 104 | 280 |
def insertion_sort(seq):
print(' '.join(map(str, seq)))
for i in range(1, len(seq)):
key = seq[i]
j = i - 1
while j >= 0 and seq[j] > key:
seq[j+1] = seq[j]
j -= 1
seq[j+1] = key
print(' '.join(map(str, seq)))
return seq
n = int(input())
seq = list(map(int, input().split()))
insertion_sort(seq) | n=int(input())
a=[int(i) for i in input().split()]
aaa=" ".join(map(str,a))
print(aaa)
for i in range(1,n):
key=a[i]
j=i-1
while j >= 0 and a[j] > key:
a[j+1]=a[j]
j=j-1
a[j+1]=key
aaa=" ".join(map(str,a))
print(aaa) | 1 | 5,286,276,310 | null | 10 | 10 |
import math
import itertools
n=int(input())
k=int(input())
def comb(n,k):
return len(list(itertools.combinations(range(n), k)))
x=str(n)
m=len(x)
ans=0
for i in range(1,m):
ans+=(comb(i-1,k-1)*(9**k))
if k==1:
for i in range(1,10):
if i*(10**(m-1))<=n:
ans+=1
elif k==2:
for i in range(1,10):
if i*(10**(m-1))<=n:
for j in range(m-1):
for a in range(1,10):
if i*(10**(m-1))+a*(10**(j))<=n:
ans+=1
else:
break
else:
break
else:
po=[10**i for i in range(m)]
for i in range(1,10):
if i*po[m-1]<=n:
for j in range(m-1):
for a in range(1,10):
if i*po[m-1]+a*po[j]<=n:
for b in range(j):
for c in range(1,10):
ans+=(i*po[m-1]+a*po[j]+c*po[b]<=n)
else:
break
else:
break
print(ans)
| t = int(input())
if t >= 30:
print('Yes')
else:
print('No') | 0 | null | 40,835,238,532,708 | 224 | 95 |
N,K=int(input()),int(input())
def f(n,k):
if k<1: return 1
if n<10:
if k<2: return n
return 0
d,m=n//10,n%10
return f(d,k-1)*m+f(d-1,k-1)*(9-m)+f(d,k)
print(f(N,K)) | #!/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):
return (N//2 + N % 2) / 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
print(f'{solve(N)}')
if __name__ == '__main__':
main()
| 0 | null | 126,923,378,114,080 | 224 | 297 |
a, b = map(int, input().split())
i = 1
while True:
x = a * i
if x % b == 0:
print(x)
exit()
i += 1
| import math
def lcm(A, B):
return int((A * B) / math.gcd(A, B))
A, B = map(int, input().split())
print(lcm(A,B)) | 1 | 113,769,106,512,590 | null | 256 | 256 |
s = input()
ans = ''
for i in range(len(s)):
ans = ans + 'x'
print(ans) | s = input()
lenth = len(s)
print("x"*lenth) | 1 | 72,875,616,241,420 | null | 221 | 221 |
n = int(input())
Tp = 0
Hp = 0
tmp = "abcdefghijklmnopqrstuvwxyz"
alph = list(tmp)
for i in range(n):
Ta,Ha = input().split()
lTa = list(Ta)
lHa = list(Ha)
num = 0
if (len(Ta) <= len(Ha)): #definition of num
num = len(Ta)
else:
num = len(Ha)
if (Ta in Ha and lTa[0] == lHa[0]): #drow a
if (Ta == Ha):
Tp += 1
Hp += 1
else:
Hp += 3
elif (Ha in Ta and Ha != Ta and lTa[0] == lHa[0]):
Tp += 3
else:
for i in range(len(lTa)): # convert alphabet to number
for j in range(26):
if (lTa[i] == alph[j]):
lTa[i] = int(j)
else :
continue
for i in range(len(lHa)): # convert alphabet to number
for j in range(26):
if (lHa[i] == alph[j]):
lHa[i] = int(j)
else :
continue
for i in range(num):
if (lTa[i] < lHa[i]):
Hp +=3
break
elif (lHa[i] < lTa[i]):
Tp +=3
break
elif (lHa[i] == lTa[i]):
continue
print(Tp,Hp)
| t=0
h=0
n=input()
for _ in range (n):
s = raw_input().split()
if s[0] > s[1]:
t+=3
elif s[0] < s[1]:
h+=3
else:
t+=1
h+=1
print str(t) + " " + str(h)
| 1 | 1,999,403,019,702 | null | 67 | 67 |
for str in iter(input, "0"):
print(sum(int(c) for c in str)) | h,w,k=map(int, input().split())
Black = []
for i in range(h):
c = input()
for j in range(w):
if c[j] == "#":
Black.append((i,j))
# print(Black, len(Black))
ans = 0
for i in range(2 ** h):
for j in range(2 ** w):
a = len(Black)
for b in Black:
if ((i >> b[0]) & 1) or ((j >> b[1]) & 1):
# if b[0] != i - 1 and b[1] != j - 1:
a -= 1
if a == k:
ans += 1
# print(bin(i),bin(j))
print(ans) | 0 | null | 5,262,142,745,080 | 62 | 110 |
N,M = map(int,input().split())
L = map(int,input().split())
work = 0
for i in L :
work += i
if N >= work :
print ( N - work )
else :
print ("-1") | n,m = map(int,input().split())
a = list(map(int,input().split()))
for v in a:
n = n - v
if n < 0:
n = -1
break
print(n) | 1 | 31,789,327,020,150 | null | 168 | 168 |
import math
s = input()
ret = 0
s_len = len(s)
count = (int)(math.floor(s_len/2))
for i in range(count):
if s[i] != s[s_len-i-1]:
ret += 1
print("{}".format(ret)) | import copy
H, W, K = map(int, input().split())
tiles = [list(input()) for _ in range(H)]
count = 0
for num in range(2**(H+W)):
copied_tiles = copy.deepcopy(tiles)
for i in range(H+W):
if num>>i&1:
if i < H:
for j in range(W):
copied_tiles[i][j] = 'R'
else:
for j in range(H):
copied_tiles[j][i-H] = 'R'
black_c = 0
for i in range(H):
for j in range(W):
if copied_tiles[i][j] == '#':
black_c += 1
if black_c == K:
count += 1
print(count) | 0 | null | 64,611,085,311,228 | 261 | 110 |
count = 0
def main():
input()
A = [int(x) for x in list(input().split())]
merge_sort(A, 0, len(A))
print(*A)
print(count)
def merge_sort(A, left, right):
if left+1 < right:
mid = (left + right) // 2
merge_sort(A, left, mid)
merge_sort(A, mid, right)
merge(A, left, mid, right)
def merge(A, left, mid, right):
global count
n1 = mid - left
n2 = right - mid
# リストの左側を作成
L = A[left:mid]
# リストの右側を作成
R = A[mid:right]
# 終端追加
L.append(float("inf"))
R.append(float("inf"))
i = 0
j = 0
for k in range(left, right):
count += 1
if L[i] <= R[j]:
A[k] = L[i]
i += 1
else:
A[k] = R[j]
j += 1
if __name__ == '__main__':
main()
| c = 0
def merge(a,l,m,r):
global c
n1 = m-l
n2 = r-m
L = a[l:m]
R = a[m:r]
L.append(1000000009)
R.append(1000000009)
i,j = 0,0
for k in range(l,r):
if L[i]<=R[j]:
a[k] = L[i]
i += 1
else :
a[k] = R[j]
j += 1
c+=1
def mergeSort(a,l,r):
if l+1<r:
m = (l+r)//2
mergeSort(a,l,m)
mergeSort(a,m,r)
merge(a,l,m,r)
def main():
n = int(input())
a = list(map(int,input().split()))
mergeSort(a,0,n)
print (' '.join(map(str,a)))
print (c)
if __name__ == '__main__':
main()
| 1 | 113,103,972,950 | null | 26 | 26 |
def main():
from functools import reduce
def a_comb_mod(n, r):
mod = 1000000007
r = min(n-r,r)
if r == 0: return 1
numer = reduce(lambda x, y: x * y % mod, range(n, n - r, -1), 1)
denom = reduce(lambda x, y: x * y % mod, range(1,r + 1), 1)
denom_inv = pow(denom, mod - 2, mod)
return numer * denom_inv % mod
n, a, b = list(map(int, input().split()))
mod = 1000000007
print((pow(2, n, mod) - 1 - a_comb_mod(n, a) - a_comb_mod(n, b)) % mod)
if __name__ == '__main__':
main()
| n=input()
a=map(int, raw_input().split())
a.reverse()
for i in a:
print i, | 0 | null | 33,569,862,994,318 | 214 | 53 |
def f_strivore(MOD=10**9 + 7):
K = int(input())
S = input()
length = len(S)
class Combination(object):
"""素数 mod に対する二項係数の計算"""
__slots__ = ['mod', 'fact', 'factinv']
def __init__(self, max_val_arg: int = 10**6, mod: int = 10**9 + 7):
fac, inv = [1], []
fac_append, inv_append = fac.append, inv.append
for i in range(1, max_val_arg + 1):
fac_append(fac[-1] * i % mod)
inv_append(pow(fac[-1], -1, mod))
for i in range(max_val_arg, 0, -1):
inv_append((inv[-1] * i) % mod)
self.mod, self.fact, self.factinv = mod, fac, inv[::-1]
def combination(self, n, r):
return (0 if n < 0 or r < 0 or n < r
else self.fact[n] * self.factinv[r] * self.factinv[n - r] % self.mod)
comb = Combination(length + K).combination
f = [1] * (K + 1)
tmp = 1
for n in range(K + 1):
f[n] = (comb(length + n - 1, length - 1) * tmp) % MOD
tmp = (tmp * 25) % MOD
g = [1] * (K + 1)
for n in range(1, K + 1):
g[n] = (f[n] + 26 * g[n - 1]) % MOD
return g[K]
print(f_strivore()) | import sys
import numpy as np
n, k = map(int,input().split())
a = np.array(sorted(list(map(int, input().split()))))
f = np.array(sorted(list(map(int, input().split())), reverse=True))
asum = a.sum()
l,r = 0, 10**13
while l != r:
mid = (l+r)//2
can = (asum - np.minimum(mid//f, a).sum()) <= k
if can:
r = mid
else:
l = mid +1
print(l) | 0 | null | 88,920,156,171,418 | 124 | 290 |
N = int(input())
ans = 'No'
if N<=82:
for i in range(1,10):
if N%i==0 and len(str(N//i))==1:
ans = 'Yes'
print(ans)
| n = int(input())
for i in range(9, 0, -1):
if n % i == 0 and n // i <= 9:
print('Yes')
exit()
print('No') | 1 | 160,037,505,849,312 | null | 287 | 287 |
def solve():
S, W = map(int,input().split())
if S > W:
print("safe")
else:
print("unsafe")
if __name__ == '__main__':
solve()
| def main():
S, W = list(map(int, input().split()))
print("unsafe" if S <= W else "safe")
pass
if __name__ == '__main__':
main() | 1 | 29,130,601,624,290 | null | 163 | 163 |
S = input()
N = int(input())
for i in range(N):
operate = input().split()
if operate[0] == "replace":
n = int(operate[1])
m = int(operate[2])+1
left_str = S[:n]
right_str = S[m:]
center_str = operate[3]
S = left_str + center_str + right_str
elif operate[0] == "reverse":
n = int(operate[1])
m = int(operate[2])+1
left_str = S[:n]
center_str = S[n:m]
right_str = S[m:]
center_str = center_str[::-1]
S = left_str + center_str + right_str
elif operate[0] == "print":
n = int(operate[1])
m = int(operate[2])+1
left_str = S[:n]
center_str = S[n:m]
right_str = S[m:]
print(center_str)
| A,B=input().split()
a=int(A)
b=B[0]+B[2]+B[3]
print(a*int(b)//100) | 0 | null | 9,298,156,162,720 | 68 | 135 |
def prime_num(n):
f = 3
while f * f <= n:
if n % f == 0:
return 1
f += 2
return 0
x = int(input())
if x == 2:
print(x)
exit()
prime = (x//2)*2 + 1
while 1 == 1:
if prime_num(prime) == 0:
print(prime)
exit()
prime += 2 | N = int(input())
ans = ""
while N > 0:
N -=1
ans = chr(ord("a") + (N%26)) + ans
N //= 26
print(ans) | 0 | null | 58,824,536,374,930 | 250 | 121 |
n = int(input())
s = input()
t = s[:len(s)//2]
if 2*t == s:
print("Yes")
else:
print("No") | a = input()
hi_cnt = a.count('hi')
if hi_cnt > 0:
if hi_cnt * 2 == len(a):
print('Yes')
else:
print('No')
else:
print('No') | 0 | null | 99,912,055,979,900 | 279 | 199 |
from collections import deque
N = int(input())
K = 0
Ans = [0] * (N-1)
Edge = [[] for _ in range(N)]
for _ in range(N-1):
a, b = map(int, input().split())
a -= 1
b -= 1
Edge[a].append((b, _))
Edge[b].append((a, _))
Q = deque()
Q.append((0, 0))
P = [-1] * N
while Q:
now, color = Q.popleft()
cnt = 1
for nex, num in Edge[now]:
if cnt == color:
cnt += 1
if nex == P[now]:
continue
if Ans[num] != 0:
continue
Q.append((nex, cnt))
Ans[num] = cnt
K = max(cnt, K)
cnt += 1
print(K)
for a in Ans:
print(a) | # -*- coding: utf-8 -*-
import sys
import math
import os
import itertools
import string
import heapq
import _collections
from collections import Counter
from collections import defaultdict
from collections import deque
from functools import lru_cache
import bisect
import re
import queue
import decimal
class Scanner():
@staticmethod
def int():
return int(sys.stdin.readline().rstrip())
@staticmethod
def string():
return sys.stdin.readline().rstrip()
@staticmethod
def map_int():
return [int(x) for x in Scanner.string().split()]
@staticmethod
def string_list(n):
return [Scanner.string() for i in range(n)]
@staticmethod
def int_list_list(n):
return [Scanner.map_int() for i in range(n)]
@staticmethod
def int_cols_list(n):
return [Scanner.int() for i in range(n)]
class Math():
@staticmethod
def gcd(a, b):
if b == 0:
return a
return Math.gcd(b, a % b)
@staticmethod
def lcm(a, b):
return (a * b) // Math.gcd(a, b)
@staticmethod
def divisor(n):
res = []
i = 1
for i in range(1, int(n ** 0.5) + 1):
if n % i == 0:
res.append(i)
if i != n // i:
res.append(n // i)
return res
@staticmethod
def round_up(a, b):
return -(-a // b)
@staticmethod
def is_prime(n):
if n < 2:
return False
if n == 2:
return True
if n % 2 == 0:
return False
d = int(n ** 0.5) + 1
for i in range(3, d + 1, 2):
if n % i == 0:
return False
return True
@staticmethod
def fact(N):
res = {}
tmp = N
for i in range(2, int(N ** 0.5 + 1) + 1):
cnt = 0
while tmp % i == 0:
cnt += 1
tmp //= i
if cnt > 0:
res[i] = cnt
if tmp != 1:
res[tmp] = 1
if res == {}:
res[N] = 1
return res
def pop_count(x):
x = x - ((x >> 1) & 0x5555555555555555)
x = (x & 0x3333333333333333) + ((x >> 2) & 0x3333333333333333)
x = (x + (x >> 4)) & 0x0f0f0f0f0f0f0f0f
x = x + (x >> 8)
x = x + (x >> 16)
x = x + (x >> 32)
return x & 0x0000007f
MOD = int(1e09) + 7
INF = int(1e15)
class Edge:
def __init__(self, to_, id_):
self.to = to_
self.id = id_
ans = None
G = None
K = None
def dfs(to, c):
global G
global ans
nc = c % K + 1
for g in G[to]:
if ans[g.id] != -1:
continue
ans[g.id] = nc
dfs(g.to, nc)
nc = nc % K + 1
def solve():
global G
global ans
global K
N = Scanner.int()
G = [[] for _ in range(N)]
for i in range(N - 1):
x, y = Scanner.map_int()
x -= 1
y -= 1
G[x].append(Edge(y, i))
G[y].append(Edge(x, i))
K = 0
for i in range(N):
K = max(K, len(G[i]))
ans = [-1 for _ in range(N - 1)]
dfs(0, 0)
print(K)
print(*ans, sep='\n')
def main():
sys.setrecursionlimit(1000000)
# sys.stdin = open("sample.txt")
# T = Scanner.int()
# for _ in range(T):
# solve()
# print('YNeos'[not solve()::2])
solve()
if __name__ == "__main__":
main()
| 1 | 135,810,140,747,060 | null | 272 | 272 |
n = int(input()) % 10
if n == 3:
print('bon')
elif n == 0 or n == 1 or n == 6 or n == 8:
print('pon')
else:
print('hon') | pen = int(input()[-1])
if pen in [2, 4, 5, 7, 9]:
print('hon')
elif pen in [0, 1, 6, 8]:
print('pon')
elif pen in [3]:
print('bon')
| 1 | 19,126,510,868,800 | null | 142 | 142 |
import sys, re, os
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from fractions import gcd
def input(): return sys.stdin.readline().strip()
def STR(): return input()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def S_MAP(): return map(str, input().split())
def LIST(): return list(map(int, input().split()))
def S_LIST(): return list(map(str, input().split()))
sys.setrecursionlimit(10 ** 9)
inf = sys.maxsize
mod = 10 ** 9 + 7
arr = [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]
n = INT()
print(arr[n - 1]) | n = int(input())
a = list(map(int, input().split()))
b = a[0]
for v in a[1:]:
b ^= v
print(*map(lambda x: x ^ b, a))
| 0 | null | 31,124,644,916,328 | 195 | 123 |
n, k, c = map(int, input().split())
s = input()
work = [1]*n
rest = 0
for i in range(n):
if rest:
rest -= 1
work[i] = 0
continue
if s[i] == 'x':
work[i] = 0
elif s[i] == 'o':
rest = c
rest = 0
for i in reversed(range(n)):
if rest:
rest -= 1
work[i] = 0
continue
if s[i] == 'o':
rest = c
if k < sum(work):
print()
else:
for idx, bl in enumerate(work):
if bl:
print(idx+1)
| n,k,c=map(int,input().split())
s=input()
x,y=[0]*n,[0]*n
work1,work2=[],[]
last=-10**9;cnt=0
for i in range(n):
if s[i]=="o" and i-last>c:
cnt+=1
last=i
work1.append(i)
if cnt==k: break
nextw=10**9;cnt=0
for i in range(n-1,-1,-1):
if s[i]=="o" and nextw-i>c:
work2.append(i)
cnt+=1
nextw=i
if cnt==k: break
work2.reverse()
for i in range(k):
if work1[i]==work2[i]: print(work1[i]+1) | 1 | 40,621,577,132,960 | null | 182 | 182 |
str = list(input())
for _ in range(int(input())):
cmd = input().split()
a, b = map(int, cmd[1:3])
if cmd[0] == 'print':
for i in range(a, b + 1):
print(str[i], end='')
print('')
if cmd[0] == 'reverse':
str = str[:a] + list(reversed(str[a:b + 1])) + str[b + 1:]
if cmd[0] == 'replace':
p = cmd[3]
str = str[:a] + list(p) + str[b + 1:] | while True:
try:
a,b = list(map(int,input().split()))
print(len(str(a+b)))
except EOFError:
break
| 0 | null | 1,023,328,580,388 | 68 | 3 |
import itertools
h, w, k = map(int, input().split())
a = []
for i in range(h):
s = input()
a.append(s)
s = [[0 for i in range(w)] for i in range(h)]
ans = h+w
for grid in itertools.product([0,1], repeat=h-1):
ary = [[0]]
for i in range(h-1):
if grid[i] == 1:
ary.append([i+1])
else:
ary[-1].append(i+1)
# print (grid, ary)
wk = 0
for i in grid:
if i == 1:
wk += 1
# print (wk)
cnt = [0] * len(ary)
for j in range(w):
for ii, g in enumerate(ary):
for b in g:
if a[b][j] == '1':
cnt[ii] += 1
if any(W > k for W in cnt):
wk += 1
cnt = [0] * len(ary)
for ii, g in enumerate(ary):
for jj in g:
if a[jj][j] == '1':
cnt[ii] += 1
if any(W > k for W in cnt):
wk = h+w
break
ans = min(ans, wk)
print (ans) | N = int(input())
out_ans = []
while N > 26:
N -= 1
out_ans.append(int(N % 26))
N = (N // 26)
N -= 1
out_ans.append(int(N))
out_dic = ['a', 'b', 'c','d', 'e', 'f','g','h','i','j',
'k','l','m','n','o','p','q','r','s','t','u','v',
'w','x','y','z']
ans = ''
for i in range(len(out_ans)-1, -1, -1):
ans = ans + (out_dic[out_ans[i]])
print(ans) | 0 | null | 30,224,250,742,180 | 193 | 121 |
r = int(input()) % 1000
print((1000 - r) % 1000) | N = int(input())
ans = N%1000
if ans == 0:
print(0)
else:
print(1000-ans) | 1 | 8,476,371,161,788 | null | 108 | 108 |
# AOJ ITP1_9_C
def numinput():
a = input().split()
for i in range(len(a)):
a[i] = int(a[i])
return a
def main():
SCORE_taro = 0
SCORE_hanako = 0
n = int(input())
for i in range(n):
words = input().split()
if words[0] > words[1]: SCORE_taro += 3
elif words[0] < words[1]: SCORE_hanako += 3
else:
SCORE_taro += 1; SCORE_hanako += 1
print(str(SCORE_taro) + " " + str(SCORE_hanako))
if __name__ == "__main__":
main()
| n = int(input())
cards = [input().split() for i in range(n)]
taroScore = 0
hanakoScore = 0
for i in range(n):
sortedCards = sorted(cards[i])
if cards[i][0] == cards[i][1]:
taroScore += 1
hanakoScore += 1
elif cards[i][0] == sortedCards[0]:
hanakoScore += 3
else:
taroScore += 3
print(taroScore, hanakoScore)
| 1 | 1,967,791,911,328 | null | 67 | 67 |
a,b = map(int,input().split())
if a>9:
print(-1)
elif b>9:
print(-1)
else:
print(a*b) | N=int(input())
XL=[list(map(int,input().split())) for i in range(N)]
R=[]
for i in range(N):
a=max(0,XL[i][0]-XL[i][1])
b=XL[i][1]+XL[i][0]
R.append([b,a])
R.sort()
ans=0
con_l=0
for i in range(N):
if con_l <= R[i][1]:
ans += 1
con_l = R[i][0]
print(ans) | 0 | null | 123,764,261,820,910 | 286 | 237 |
def main():
n = int(input())
d = list(map(int,input().split()))
mod = 998244353
if d[0]!=0:
print(0)
return
D = {0:1}
for i in range(1,n):
if d[i]==0:
print(0)
return
if D.get(d[i]) == None:
D[d[i]] = 1
else:
D[d[i]] += 1
ans = 1
if sorted(D.keys())[-1]!=len(D.keys())-1:
print(0)
return
for k in range(1,len(D.keys())):
ans *= pow(D[k-1],D[k],mod)
ans = ans % mod
print(ans)
if __name__ == "__main__":
main()
| s = input()
n = len(s) + 1
A = [0] * n
for i in range(1, n):
if s[i - 1] == "<":
A[i] = A[i - 1] + 1
for i in range(n - 1, 0, -1):
if s[i - 1] == ">":
A[i - 1] = max(A[i - 1], A[i] + 1)
print(sum(A))
| 0 | null | 155,572,453,057,250 | 284 | 285 |
N,K = map(int,input().split())
A = list(map(int,input().split()))
for k in range(1,min(K+1,45)):
B = [0]*N
for i in range(N):
l = max(0,i-A[i])
r = min(N-1,i+A[i])
B[l] += 1
if r+1 < N:
B[r+1] -= 1
for i in range(1,N):
B[i] += B[i-1]
A = B
print(*A) | 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 | 16,217,629,688,578 | 132 | 136 |
from collections import Counter
n = list(input())
n.reverse()
x = [0]*(len(n))
a=0
ex=1
for i in range(len(n)):
a+=int(n[i])*ex
x[i]=a%2019
ex=ex*10%2019
c=Counter(x)
ans = c[0]
for i in c.keys():
b=c[i]
ans += b*(b-1)//2
print(ans)
| s = input()
len_s = len(s)
s_array = [int(i) for i in s]
mod = 2019
mod_array = [0]*mod
num = 0
mod_array[0] += 1
for i in range(len_s):
num = pow(10, i, mod) * s_array[len_s - i - 1] + num
num %= mod
mod_array[num] += 1
ans = 0
for i in mod_array:
ans += (i * (i - 1)) / 2
print(int(ans)) | 1 | 30,761,348,949,500 | null | 166 | 166 |
# 入力
N = int(input())
A = list(map(int, input().split()))
# 上限を決める
NowNode = 2**0
NextNode = (NowNode - A[0])*2
UpperLimit = [0] * (N+1)
UpperLimit[0] = 1
if A[0] == 1:
if N == 0:
print(1)
exit()
print(-1)
exit()
for d in range(1, N+1, 1):
NowNode = NextNode
NextNode = (NowNode - A[d]) * 2
UpperLimit[d] = NowNode
# print(UpperLimit)
UpperLimit[-1] = min(A[-1], UpperLimit[-1])
# 下から見ていく
NowNode = A[-1]
ans = 0
for d in range(N, -1, -1):
PrevNode = NowNode
if UpperLimit[d] < A[d]:
print(-1)
exit()
if NowNode + A[d] <= UpperLimit[d]:
NowNode += A[d]
else:
NowNode = UpperLimit[d]
ans += NowNode
# print(d, NowNode)
print(ans)
| n,*l=map(int,open(0).read().split())
e=[1]
for i in range(n): e+=[(e[-1]-l[i])*2]
a=t=0
for i in range(n,-1,-1):
if l[i]>e[i]: print(-1); break
t=min(l[i]+t,e[i]); a+=t
else: print(a) | 1 | 18,855,014,730,500 | null | 141 | 141 |
n=int(input())
xy=[[] for i in range(n)]
for i in range(n):
a=int(input())
for j in range(a):
x,y=map(int,input().split())
x-=1
xy[i].append((x,y))
ans=0
for i in range(1<<n):
cnt=bin(i).count("1")
if cnt<=ans:continue
for j in range(n):
if i&(1<<j):
for x,y in xy[j]:
if y==1 and i&(1<<x):continue
if y==0 and i&(1<<x)==0:continue
break
else:
continue
break
else:
ans=cnt
print(ans)
| from __future__ import absolute_import, print_function, unicode_literals
for a in xrange(1, 10):
for b in xrange(1, 10):
print('{}x{}={}'.format(a, b, a * b)) | 0 | null | 60,430,112,405,168 | 262 | 1 |
target = input()
now_height = []
now_area = [0]
answer = []
continued = 0
depth = 0
depth_list = []
for t in target:
# print(now_height,depth_list,now_area,answer,continued)
if t == '\\':
now_height.append(continued)
depth_list.append(depth)
now_area.append(0)
depth -= 1
elif t == '_':
pass
elif t == '/' and len(now_height) > 0:
depth += 1
started = now_height.pop()
temp_area = continued - started
# print(depth_list[-1],depth)
now_area[-1] += temp_area
if depth > depth_list[-1]:
while depth > depth_list[-1]:
temp = now_area.pop()
now_area[-1] += temp
depth_list.pop()
if len(now_height) == 0 or depth == depth_list[0]:
answer.append(sum(now_area))
now_area = [0]
depth_list = []
continued += 1
now_area = list(filter(lambda x:x != 0,now_area))
answer.extend(now_area)
print(sum(answer))
print(len(answer),*answer) | class Info:
def __init__(self,arg_start,arg_end,arg_S):
self.start = arg_start
self.end = arg_end
self.S = arg_S
POOL = []
LOC = []
cnt = 0
sum_S = 0
line = input()
for c in line:
if c == "\\":
LOC.append(cnt)
elif c == "/":
if len(LOC) == 0:
continue
tmp_start = LOC.pop()
tmp_end = cnt
tmp_S = tmp_end - tmp_start
sum_S += tmp_S
while len(POOL) > 0:
if POOL[-1].start > tmp_start and POOL[-1].end < tmp_end:
tmp_S += POOL[-1].S
POOL.pop()
else:
break
POOL.append(Info(tmp_start,tmp_end,tmp_S))
else:
pass
cnt += 1
lst = [len(POOL)]
for i in range(len(POOL)):
lst.append(POOL[i].S)
print(sum_S)
print(*lst)
| 1 | 59,814,135,872 | null | 21 | 21 |
import itertools
N = int(input())
P = list(map(int, input().split()))
Q = list(map(int, input().split()))
patterns = itertools.permutations(list(range(1, N+1)), N)
p_i = 0
q_i = 0
for i, ptn in enumerate(patterns):
p_same = True
q_same = True
for j, num in enumerate(ptn):
if P[j] != num:
p_same = False
if Q[j] != num:
q_same = False
if p_same:
p_i = i
if q_same:
q_i = i
print(abs(p_i-q_i)) | A,B = input().split()
if len(A)==2 or len(B)==2:
print(-1)
exit(0)
print(int(A)*int(B)) | 0 | null | 129,580,600,866,014 | 246 | 286 |
while True:
try:
a,b = map(int,raw_input().split())
c=str(a+b)
print len(c)
except EOFError:
break | import sys
if __name__ == "__main__":
for i in sys.stdin:
a,b = list(map(int,i.strip().split()))
print(len(str(a+b))) | 1 | 93,240,114 | null | 3 | 3 |
n=int(input())
a=list(map(int,input().split()))
ans=[0]*(n+1)
for i in range(n-1):
ans[a[i]]+=1
ans.pop(0)
for j in ans:
print(j) | n=int(input());l=list(map(int,input().split()));p=[0]*n;d=[0]*n;p[0]=l[0]
for i in range(1,n):p[i]=l[i]+p[i-2];d[i]=max(p[i-1]if(i&1)else d[i-1],l[i]+d[i-2])
print(d[-1]) | 0 | null | 34,760,371,721,060 | 169 | 177 |
from itertools import groupby
s=input()
if s[0]=='>':
s='<'+s
g=groupby(s)
a=[]
for i,j in g:
a.append(len(list(j)))
def sum(n):
return n*(n+1)//2
x=0
if len(a)%2==1:
a+=[1]
for i in range(0,len(a),2):
x+=sum(min(a[i],a[i+1])-1)
x+=sum(max(a[i],a[i+1]))
print(x)
| import sys
import copy
import math
import itertools
import numpy as np
S=input()
N = len(S)+1
a = [0]*N
b = [0]*N
for i in range(N-1):
if S[i]=="<":
a[i+1]=a[i]+1
for i in reversed(range(N-1)):
if S[i]==">":
b[i]=b[i+1]+1
for i in range(N):
if a[i] < b[i]:
a[i]=b[i]
print(sum(a)) | 1 | 156,701,279,327,202 | null | 285 | 285 |
from statistics import median
n=int(input())
A,B=[],[]
for _ in range(n):
a,b=map(int,input().split())
A.append(a*2)
B.append(b*2)
ma,mb = int(median(A)),int(median(B))
#print(ma,mb)
if n%2 == 0:
print(mb-ma+1)
else:
print((mb-ma)//2+1)
| import sys
sys.setrecursionlimit(10**6) #再帰関数の上限
import math
from copy import copy, deepcopy
from operator import itemgetter
from bisect import bisect_left, bisect, bisect_right#2分探索
#bisect_left(l,x), bisect(l,x)#aはソート済みである必要あり。aの中からx未満の要素数を返す。rightだと以下
from collections import deque
#deque(l), pop(), append(x), popleft(), appendleft(x)
##listでqueの代用をするとO(N)の計算量がかかってしまうので注意
from collections import Counter#文字列を個数カウント辞書に、
#S=Counter(l),S.most_common(x),S.keys(),S.values(),S.items()
from itertools import accumulate#累積和
#list(accumulate(l))
from heapq import heapify,heappop,heappush
#heapify(q),heappush(q,a),heappop(q) #q=heapify(q)としないこと、返り値はNone
#import fractions#古いatcoderコンテストの場合GCDなどはここからimportする
def input(): return sys.stdin.readline()[:-1]
def printl(li): print(*li, sep="\n")
def argsort(s, return_sorted=False):
inds=sorted(range(len(s)), key=lambda k: s[k])
if return_sorted: return inds, [s[i] for i in inds]
return inds
def alp2num(c,cap=False): return ord(c)-97 if not cap else ord(c)-65
def num2alp(i,cap=False): return chr(i+97) if not cap else chr(i+65)
def matmat(A,B):
K,N,M=len(B),len(A),len(B[0])
return [[sum([(A[i][k]*B[k][j]) for k in range(K)]) for j in range(M)] for i in range(N)]
def matvec(M,v):
N=len(v)
size=len(M)
return [sum([M[i][j]*v[j] for j in range(N)]) for i in range(size)]
def main():
mod = 10**9+7
#w.sort(key=itemgetter(1),reversed=True) #二個目の要素で降順並び替え
N = int(input())
#N, K = map(int, input().split())
#A = tuple(map(int, input().split())) #1行ベクトル
#L = tuple(int(input()) for i in range(N)) #改行ベクトル
s = tuple(tuple(map(int, input().split())) for i in range(N)) #改行行列
l=[(s[i][0]+s[i][1],s[i][0]-s[i][1]) for i in range(N)]
l.sort()
cur=l[0][0]
ans=1
for rob in l[1:]:
if cur>rob[1]:
continue
ans+=1
cur=rob[0]
print(ans)
if __name__ == "__main__":
main() | 0 | null | 53,382,993,417,170 | 137 | 237 |
#!python3
import sys
iim = lambda: map(int, sys.stdin.readline().rstrip().split())
def resolve():
N = int(sys.stdin.readline())
N1 = N - 1
ans = 0
for i in range(1, N):
ans += N1//i
print(ans)
if __name__ == "__main__":
resolve()
| from bisect import bisect_left,bisect_right
TO_ACII = 97
N = int(input())
S = ["0"] + list(input())
Q = int(input())
ABC = [[]for i in range(0,26,1)]#該当文字a:0 b:1 ...z:26 が何文字目に出てきたかを保持する配列
for i in range(1,N+1,1):
ABC[ord(S[i])-TO_ACII].append(i)
ans = []
for i in range(0,Q,1):
q = list(input().split())
if q[0]=="1":#文字変更
changed = S[int(q[1])]
ABC[ord(changed)-TO_ACII].pop(bisect_left(ABC[ord(changed)-TO_ACII],int(q[1])))
ABC[ord(q[2])-TO_ACII].insert(bisect_left(ABC[ord(q[2])-TO_ACII],int(q[1])),int(q[1]))
S[int(q[1])]=q[2]
else:
tmpans = 0
for i in range(0,26,1):
if bisect_right(ABC[i],int(q[1])-1)<len(ABC[i]) and int(q[2]) >= ABC[i][bisect_right(ABC[i],int(q[1])-1)]:
tmpans+=1
ans.append(tmpans)
for i in range(0,len(ans),1):
print(ans[i])
| 0 | null | 32,571,385,723,516 | 73 | 210 |
import sys
from fractions import gcd
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
def lcm(a, b):
return a * b // gcd(a, b)
def main():
N, M, *A = map(int, read().split())
A = list({a // 2 for a in A})
power = 1
while all(a % 2 == 0 for a in A):
A = [a // 2 for a in A]
power *= 2
if any(a % 2 == 0 for a in A):
print(0)
return
l = 1
for a in A:
l = lcm(l, a)
l *= power
ans = (M + l) // (2 * l)
print(ans)
return
if __name__ == '__main__':
main()
| def main():
x,n = map(int,input().split())
p = list(map(int,input().split()))
ans = -100
for i in range(-1,102):
if i not in p and abs(i-x) < abs(ans-x):
ans = i
print(ans)
return
if __name__ == '__main__':
main() | 0 | null | 58,253,747,074,898 | 247 | 128 |
n, q = map(int, input().split())
processes = [[li[0], int(li[1])] for li in [input().split() for _ in range(n)]]
elapsed_time = 0
while len(processes):
process = processes.pop(0)
if process[1] > q:
process[1] -= q
processes.append(process)
elapsed_time += q
else:
elapsed_time += process[1]
print(process[0], elapsed_time) | i = 1
while True :
x = input()
if (x == 0) :
exit()
print "Case %d: %d" % (i, x)
i += 1 | 0 | null | 257,792,570,420 | 19 | 42 |
n = int(input()) % 10
if n == 3:
print('bon')
elif n == 0 or n == 1 or n == 6 or n == 8:
print('pon')
else:
print('hon') | N = input ()
P = '0168'
H = '24579'
if N[-1] in P:
print ('pon')
elif N[-1] in H:
print ('hon')
else:
print ('bon') | 1 | 19,146,839,789,320 | null | 142 | 142 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.