code1
stringlengths 16
427k
| code2
stringlengths 16
427k
| similar
int64 0
1
| pair_id
int64 6.82M
181,637B
⌀ | question_pair_id
float64 101M
180,471B
⌀ | code1_group
int64 2
299
| code2_group
int64 2
299
|
|---|---|---|---|---|---|---|
from decimal import Decimal
a,b,c = map(str,input().split()) # Decimalを使う場合，文字列で渡す
a_sq = Decimal(a).sqrt()
b_sq = Decimal(b).sqrt()
c_sq = Decimal(c).sqrt()
if a_sq + b_sq < c_sq:
print("Yes")
else:
print("No") | S = input()
K = int(input())
ss = []
seq = 1
for a,b in zip(S,S[1:]):
if a==b:
seq += 1
else:
ss.append(seq)
seq = 1
ss.append(seq)
if len(ss)==1:
print(len(S)*K//2)
exit()
if S[0] != S[-1]:
ans = sum([v//2 for v in ss]) * K
print(ans)
else:
ans = sum([v//2 for v in ss[1:-1]]) * K
ans += (ss[0]+ss[-1])//2 * (K-1)
ans += ss[0]//2 + ss[-1]//2
print(ans) | 0 | null | 113,473,358,995,712 | 197 | 296 |
'''
Date : 2020-08-09 00:46:52
Author : ssyze
Description :
'''
n, k = map(int, input().split())
a = list(map(int, input().split()))
def check(m):
sum = 0
for i in range(len(a)):
sum += (a[i] - 1) // m
if sum > k:
return False
else:
return True
l = 1
r = 10**9
ans = 10**9
while l < r:
mid = (l + r) // 2
if check(mid) == 1:
r = mid
ans = mid
else:
l = mid + 1
print(ans)
| def solve():
N, K = map(int,input().split())
A = list(map(int,input().split()))
left = 0
right = 10 ** 9
while right - left > 1:
mid = (right+left) // 2
cnt = 0
for a in A:
cnt += (a-1) // mid
if cnt <= K:
right = mid
else:
left = mid
print(right)
if __name__ == '__main__':
solve()
| 1 | 6,556,800,914,092 | null | 99 | 99 |
#区間スケジューリング問題
N = int(input())
robots = {}
for _ in range(N):
X, L = list(map(int, input().split()))
robots[X] = (X-L, X+L)
#終端が早い順にソートして、取れるものから貪欲法でとっていく
robots_sorted = sorted(robots.items(), key=lambda x:x[1][1])
ans = 1
current_robot = robots_sorted[0]
for i in range(0, N):
if current_robot[1][1] > robots_sorted[i][1][0]:
continue
ans += 1
current_robot = robots_sorted[i]
print(ans)
|
X = int(input())
SUM = 0
(X * 1000 / 500)
Z = X // 500
A = X % 500
SUM = SUM + (Z * 1000)
B = A // 5
SUM = SUM + (B * 5)
print(int(SUM)) | 0 | null | 65,988,940,099,732 | 237 | 185 |
n = int(input())
l = list(map(int, input().split()))
r = {l[i]:0 for i in range(n)}
for i in range(n):
r[l[i]] += 1
t = list(r.items())
ans = 0
for i in range(len(t)-2):
for j in range(i+1, len(t)-1):
for k in range(j+1, len(t)):
y = sum([t[i][0], t[j][0], t[k][0]])
x = max([t[i][0], t[j][0], t[k][0]])
if 2*x < y:
ans += t[i][1] * t[j][1] * t[k][1]
print(ans) | from itertools import combinations
N = int(input())
L = list(map(int, input().split()))
count = 0
for C in combinations(L, 3):
l_list = list(C)
l_list.sort()
if l_list[2] > l_list[1] and l_list[1] > l_list[0]:
if l_list[2] < l_list[1] + l_list[0]:
count += 1
print(count) | 1 | 5,073,224,495,712 | null | 91 | 91 |
n = int(input())
(*x,) = map(int, input().split())
a = round(sum(x) / n)
print(sum(((i - a) ** 2) for i in x)) | from collections import deque
N = int(input())
d = {i:[] for i in range(1, N+1)}
q = deque([(1, "a")])
while q:
pos, s = q.popleft()
if pos == N+1:
break
d[pos].append(s)
size = len(set(s))
for i in range(size+1):
q.append((pos+1, s+chr(97+i)))
for i in d[N]:
print(i) | 0 | null | 58,780,003,255,288 | 213 | 198 |
st = input()
code = ord(st)
next_code = code + 1
print(chr(next_code)) | C = input()
ans = chr(ord(C) + 1)
print(ans)
| 1 | 92,224,517,947,118 | null | 239 | 239 |
from sys import stdin
N, M = [int(x) for x in stdin.readline().rstrip().split()]
if N == M:
print("Yes")
else:
print("No")
| N = int(input())
A = {}
for i in range(N):
s = input()
if s in A:
A[s] += 1
else:
A[s] = 1
s_max = max(A.values())
for j in sorted(k for k in A if A[k] == s_max):
print(j) | 0 | null | 76,658,744,641,478 | 231 | 218 |
N = int(input())
A = list(map(int,input().split()))
from collections import Counter
ctr = Counter(A)
tmp = sum(v*(v-1)//2 for v in ctr.values())
for a in A:
print(tmp - ctr[a] + 1) | N=int(input())
A= list(map(int,input().split()))
B=[0 for _ in range(N)]
for a in A:
B[a-1]+=1
for b in B:
print(b) | 0 | null | 40,313,328,397,540 | 192 | 169 |
a, b = map(int, raw_input().split())
print ("%d %d" % (a * b, 2 * (a + b))) | a,b = map(int, input().split())
c=a*b
d=2*(a+b)
print(c,d)
| 1 | 300,814,924,832 | null | 36 | 36 |
n = int(input())
buf = [0]*n
def solv(idx,char):
aida = n - idx
if idx == n:
print("".join(buf))
return
for i in range(char + 1):
buf[idx] = chr(ord('a') + i)
solv(idx+1,max(i + 1,char))
solv(0,0) | import sys
from collections import deque
input = sys.stdin.readline
def dfs(N):
alphabet = "abcdefghij"
stack = deque(["a"])
while stack:
s = stack.pop()
if len(s) == N:
print(s)
continue
suffixes = []
for al in alphabet:
suffixes.append(al)
if al not in s:
break
for suffix in reversed(suffixes):
stack.append("".join((s, suffix)))
def main():
N = int(input())
dfs(N)
if __name__ == "__main__":
main()
| 1 | 52,367,117,354,288 | null | 198 | 198 |
n = int(input())
print(((n + 1) // 2) / n)
| n = int(input())
ans = float("-INF")
min_v = int(input())
for _ in range(n-1):
r = int(input())
ans = max(ans, r - min_v)
min_v = min(min_v, r)
print(ans)
| 0 | null | 88,306,612,174,232 | 297 | 13 |
H, W, K = map(int, input().split())
a = [input() for _ in range(H)]
ans = [[-1 for _ in range(W)] for _ in range(H)]
i_cut_time = 0
j_cut_time = 0
for i in range(H):
if '#' in a[i]:
i_cut_time += 1
i_cut = []
start = 0
goal = -1
for i in range(H):
if len(i_cut) == i_cut_time-1:
break
if '#' in a[i]:
goal = i
i_cut.append([start, goal, i])
start = goal+1
for i in range(start, H):
if '#' in a[i]:
i_cut.append([start, H-1, i])
# print(i_cut)
cnt = 1
for s, g, p in i_cut:
j_cut = []
jstart = 0
jgoal = -1
for i in range(W):
if len(j_cut) == a[p].count('#')-1:
break
if a[p][i] == '#':
jgoal = i
j_cut.append([jstart, jgoal])
jstart = jgoal+1
j_cut.append([jstart, W-1])
# print(s, g, p, j_cut)
# for i in range(s, g+1):
for js, jg in j_cut:
for j in range(js, jg+1):
for i in range(s, g+1):
# print(i, j, cnt)
ans[i][j] = cnt
cnt += 1
# print(*ans, sep='\n')
for i in range(H):
print(*ans[i]) | import sys
from collections import deque
N, M = map(int, input().split())
G = [[] for _ in range(N)]
for _ in range(M):
a, b = map(int, sys.stdin.readline().split())
G[a-1].append(b-1)
G[b-1].append(a-1)
ars = [0] * N
todo = deque([0])
done = {0}
while todo:
p = todo.popleft()
for np in G[p]:
if np in done:
continue
todo.append(np)
ars[np] = p + 1
done.add(np)
if len(done) == N:
print("Yes")
for i in range(1, N):
print(ars[i])
else:
print("No") | 0 | null | 81,997,055,813,630 | 277 | 145 |
import sys
input = sys.stdin.readline
# C - Subarray Sum
n, k, s = map(int, input().split())
ans = ''
str_s = str(s)
if s < pow(10, 9):
str_another = str(s + 1)
else:
str_another = '1'
for i in range(n):
if i < k:
ans += str_s + ' '
else:
ans += str_another + ' '
print(ans[:len(ans)-1]) | N,K,S=[int(x) for x in input().rstrip().split()]
ans=[]
if S==10**9:
for i in range(N):
if i+1<=K:
ans.append(S)
else:
ans.append(1)
else:
for i in range(N):
if i+1<=K:
ans.append(S)
else:
ans.append(S+1)
print(*ans)
| 1 | 90,899,571,985,862 | null | 238 | 238 |
def bubble_sort(num_list):
list_b = num_list[:]
for i in range(len(list_b)-1):
for j in range(len(list_b)-1,i,-1):
if list_b[j][1] < list_b[j-1][1]:
list_b[j],list_b[j-1] = list_b[j-1],list_b[j]
return list_b
def selection_sort(num_list):
list_s = num_list[:]
for i in range(len(list_s)):
minj = i
for j in range(i,len(list_s)):
if list_s[minj][1] > list_s[j][1]:
minj = j
list_s[i],list_s[minj] = list_s[minj],list_s[i]
return list_s
def isStable(list_x, list_y):
leng = int(len(list_x))
for i in range(leng-1):
for j in range(i+1, leng):
for x in range(leng-1):
for y in range(x+1, leng):
if list_x[i][1]==list_x[j][1] and list_x[i]==list_y[y] and list_x[j] == list_y[x]:
return "Not stable"
return "Stable"
qnt = int(input())
num_list = input().split()
bs = bubble_sort(num_list)
ss = selection_sort(num_list)
print(" ".join(bs))
print(isStable(num_list,bs))
print(" ".join(ss))
print(isStable(num_list,ss)) | # import bisect
# from collections import Counter, deque
# import copy
# from heapq import heappush, heappop, heapify
# from fractions import gcd
# import itertools
# from operator import attrgetter, itemgetter
# import math
import sys
# import numpy as np
ipti = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)
def main():
n = int(input())
s = [0] * n
t = [0] * n
for i in range(n):
s[i], t[i] = input().split()
t[i] = int(t[i])
x = input()
idx = s.index(x)
ans = 0
for i in range(idx+1, n):
ans += t[i]
print(ans)
if __name__ == '__main__':
main() | 0 | null | 48,696,195,196,908 | 16 | 243 |
s=raw_input()
target=raw_input()
ring=s*2
ans="No"
for i in range(len(s)):
if ring[i:i+len(target)]==target:
ans="Yes"
break
print ans | #!usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == "\n":
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
t = LI()
a = LI()
b = LI()
a[0] -= b[0]
a[1] -= b[1]
if t[0]*a[0] == -t[1]*a[1]:
print("infinity")
return
if a[0] < 0:
a[0] *= -1
a[1] *= -1
if t[0]*a[0]+t[1]*a[1] > 0:
print(0)
return
A = t[0]*a[0]+t[1]*a[1]
k = t[0]*a[0]
l = 0
r = 10**20
while r-l > 1:
x = (l+r) >> 1
if A*x+k > 0:
l = x
else:
r = x
ans = 2*l+1
if A*r+k == 0:
ans += 1
print(ans)
return
#Solve
if __name__ == "__main__":
solve()
| 0 | null | 66,376,661,352,528 | 64 | 269 |
# imos解
n,d,a=map(int,input().split())
xh=[]
for i in range(n):
xx,hh=map(int,input().split())
xh.append([xx,hh])
xh.sort(key=lambda x:x[0])
xl=[x for x,h in xh]
# print(xh)
from math import ceil
from bisect import bisect_right
ans=0
damage=[0]*(n+1)
for i in range(n):
x,h=xh[i]
if damage[i]<h:
need=ceil((h-damage[i])/a)
right=x+2*d
# 爆発に巻き込まれる範囲の右端のindexを取得する
r_idx=bisect_right(xl,right)
# imosしながら爆発させる
damage[i]+=need*a
damage[r_idx]-=need*a
ans+=need
# imosの累積和を取る
damage[i+1]+=damage[i]
print(ans)
|
from bisect import bisect_right
N, D, A = map(int, input().split())
X = [list(map(int, input().split())) for _ in range(N)]
X.sort()
place = []
hps = []
for x, h in X:
place.append(x)
hps.append(h)
buf = [0] * (N + 2)
ans = 0
for i in range(N):
# Update
buf[i + 1] += buf[i]
# Calc count
tmp = -(-max(0, hps[i] - buf[i + 1] * A) // A)
ans += tmp
# Calc range
j = bisect_right(place, place[i] + D * 2)
buf[i + 1] += tmp
buf[min(j + 1, N + 1)] -= tmp
print(ans)
| 1 | 82,305,970,005,700 | null | 230 | 230 |
N = int(input())
a = list(map(int,input().split()))
loc = round(sum(a) / N)
print(sum(map(lambda x: (x - loc) ** 2,a))) | na, nb, m = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
min_a = min_b = 10**9
for i in range(na):
min_a = min(min_a, a[i])
for i in range(nb):
min_b = min(min_b, b[i])
ans = min_a + min_b
for i in range(m):
x, y, c = map(int, input().split())
x -= 1
y -= 1
ans = min(ans, a[x] + b[y] - c)
print(ans)
| 0 | null | 59,278,574,907,400 | 213 | 200 |
n,k = map(int,input().split())
A = sorted(list(map(int,input().split())))
F = sorted(list(map(int,input().split())))[::-1]
o = []
for a,f in zip(A,F):
o.append(a*f)
ok = max(o)
ng = -1
while ok - ng > 1:
mid = (ok+ng)//2
k1 = 0
for i in range(n):
k1 += max( 0 , A[i]- mid//F[i])
if k1<= k:
ok = mid
else:
ng = mid
print(ok)
| import numpy as np
def is_good(mid, key):
x = A - mid // F
return x[x > 0].sum() <= key
def binary_search(key):
bad, good = -1, 10 ** 18
while good - bad > 1:
mid = (bad + good) // 2
if is_good(mid, key):
good = mid
else:
bad = mid
return good
N, K = map(int, input().split())
A = np.array(input().split(), dtype=np.int64)
F = np.array(input().split(), dtype=np.int64)
A.sort()
F[::-1].sort()
print(binary_search(K))
| 1 | 164,257,044,838,880 | null | 290 | 290 |
from collections import defaultdict
from math import gcd
MOD = 1000000007
N = int(input())
zeros = 0
bads = defaultdict(lambda: [0, 0])
for _ in range(N):
x, y = map(int, input().split())
# 両方ゼロの時の例外処理
if x == 0 and y == 0:
zeros += 1
continue
# 180度回転
if y < 0 or (y == 0 and x < 0):
x, y = -x, -y
g = gcd(x, y)
x, y = x // g, y // g
if x > 0:
bads[(x, y)][0] += 1
else:
bads[(y, -x)][1] += 1
ans = 1
for k, l in bads.values():
ans *= (pow(2, k, MOD) - 1) + (pow(2, l, MOD) - 1) + 1
ans %= MOD
print((ans + zeros - 1) % MOD)
| from collections import defaultdict
import math
N = int(input())
d_ab = defaultdict(int)
d_ba = defaultdict(int)
mod = 1000000007
a0 = 0
b0 = 0
all0 = 0
for i in range(N):
A,B = map(int,input().split())
if A == 0 and B == 0:
all0 += 1
elif A == 0:
a0 += 1
elif B == 0:
b0 += 1
else:
gcd = math.gcd(A,B)
if (A < 0 and B > 0) or (A > 0 and B < 0):
minus_f = True
else:
minus_f = False
A //= gcd
B //= gcd
A = abs(A)
B = abs(B)
if minus_f:
d_ab[(-A,B)] += 1
d_ba[(B,A)] += 1
else:
d_ab[(A,B)] += 1
d_ba[(-B,A)] += 1
ans = 1
#print(d_ab)
#print(d_ba)
pairs = list(map(list,d_ab.keys()))
visited = defaultdict(int)
#print(pairs)
for pair in pairs:
ab = d_ab[tuple(pair)]
ba = d_ba[tuple(pair)]
r_pair = list(reversed(pair))
if r_pair[0] > 0 and r_pair[1] > 0:
r_pair[0] *= -1
elif r_pair[1] < 0:
r_pair[1] *= -1
r_pair = tuple(r_pair)
if ba != 0 and visited[tuple(pair)] == 0:
visited[r_pair] = 1
ans *= (pow(2,ab)+pow(2,ba)-1)
ans %= mod
if ba == 0 and visited[tuple(pair)] == 0:
ans *= (pow(2,ab))
ans %= mod
# print(ans)
#print(visited)
ans *= (pow(2,a0)+pow(2,b0)-1)
ans %= mod
ans += all0 -1
ans %= mod
print(ans) | 1 | 21,001,171,658,212 | null | 146 | 146 |
n,m = map(int,input().split())
prb = [[0] for _ in range(n+1)]
for _ in range(m):
sub = input().split()
p, s = int(sub[0]), sub[1]
lst = prb[p]
if lst[-1] == 1:
pass
elif s == "WA":
lst.append(0)
elif s == "AC":
lst.append(1)
prb[p] = lst
ac_prb = [lst for lst in prb if lst[-1] == 1]
ac_num = len(ac_prb)
pe_num = -2*ac_num
for prb in ac_prb:
pe_num += len(prb)
print(ac_num, pe_num) | from collections import defaultdict as dic
n, m = map(int, input().split())
ac = 0
pena = 0
d = dic(list)
for i in range(m):
pi, si = input().split()
d[pi].append(si)
for (k, v) in d.items():
pe = 0
flag = False
for aw in v:
if aw == 'WA':
pe += 1
else:
ac += 1
flag = True
break
if flag:
pena += pe
print(ac, pena)
| 1 | 93,631,414,797,818 | null | 240 | 240 |
import sys
input = sys.stdin.buffer.readline
def main():
N,K = map(int,input().split())
a = list(map(int,input().split()))
f = list(map(int,input().split()))
a.sort()
f.sort(reverse=True)
l,r = -1,max(a)*max(f)+1
while r-l>1:
mid = (r+l)//2
count = 0
for cost,dif in zip(a,f):
if mid >= cost*dif:
continue
rest = cost*dif-mid
count += -(-rest//dif)
if count <= K:
r = mid
else:
l = mid
print(r)
if __name__ == "__main__":
main()
| def is_leq_S(A, lim, K):
S = [0] * K
ai = 0
si = 0
while ai < len(A):
if S[si] + A[ai] <= lim:
S[si] += A[ai]
ai += 1
else:
si += 1
if si == K:
return False
return True
def main():
N, K = [int(_) for _ in input().split()]
A = []
for _ in range(N):
A.append(int(input()))
l = 0
r = 100000 * 100000
while l + 1 < r:
m = (l + r) // 2
if is_leq_S(A, m, K):
S = m
r = m
else:
l = m
print(S)
main()
| 0 | null | 82,222,821,995,294 | 290 | 24 |
# coding=utf-8
class Dice(object):
def __init__(self, label):
self.label = label
def _rotateS(self):
s1, s2, s3, s4, s5, s6 = self.label
self.label = [s5, s1, s3, s4, s6, s2]
def _rotateN(self):
s1, s2, s3, s4, s5, s6 = self.label
self.label = [s2, s6, s3, s4, s1, s5]
def _rotateE(self):
s1, s2, s3, s4, s5, s6 = self.label
self.label = [s4, s2, s1, s6, s5, s3]
def _rotateW(self):
s1, s2, s3, s4, s5, s6 = self.label
self.label = [s3, s2, s6, s1, s5, s4]
def _spinPos(self):
s1, s2, s3, s4, s5, s6 = self.label
self.label = [s1, s4, s2, s5, s3, s6]
def _spinNeg(self):
s1, s2, s3, s4, s5, s6 = self.label
self.label = [s1, s3, s5, s2, s4, s6]
def rotate(self, r):
if r == 'S':
self._rotateS()
elif r == 'N':
self._rotateN()
elif r == 'E':
self._rotateE()
elif r == 'W':
self._rotateW()
elif r == 'SP':
self._spinPos()
elif r == 'SN':
self._spinNeg()
elif r == '2S':
self._rotateS()
self._rotateS()
elif r == '2SP':
self._spinPos()
self._spinPos()
def getLabel(self, i):
return self.label[i - 1]
def match(self, top, front):
iTop = self.label.index(top) + 1
topRot = {1: '', 2: 'N', 3: 'W', 4: 'E', 5: 'S', 6: '2S'}
self.rotate(topRot[iTop])
iFront = self.label.index(front) + 1
frontRot = {2: '', 3: 'SN', 4: 'SP', 5: '2SP'}
self.rotate(frontRot[iFront])
def main():
d = Dice(map(int, raw_input().split()))
n = input()
for _ in xrange(n):
top, front = map(int, raw_input().split())
d.match(top, front)
print d.getLabel(3)
if __name__ == '__main__':
main() | import bisect, copy, heapq, math, sys
from collections import *
from functools import lru_cache
from itertools import accumulate, combinations, permutations, product
def input():
return sys.stdin.readline()[:-1]
def ruiseki(lst):
return [0]+list(accumulate(lst))
def celi(a,b):
return -(-a//b)
sys.setrecursionlimit(5000000)
mod=pow(10,9)+7
al=[chr(ord('a') + i) for i in range(26)]
direction=[[1,0],[0,1],[-1,0],[0,-1]]
x=int(input())
def is_prime(n):
if n == 1: return False
for k in range(2, int(math.sqrt(n)) + 1):
if n % k == 0:
return False
return True
ans=x
while not is_prime(ans):
ans+=1
print(ans) | 0 | null | 52,647,970,166,440 | 34 | 250 |
n, m = map(int, input().split())
a = []
b = []
for i in range(n):
ai = list(map(int, input().split()))
a.append(ai)
for i in range(m):
bi = int(input())
b.append(bi)
for i in range(n):
ci = 0
for j in range(m):
ci += a[i][j] * b[j]
print(ci) | N = int(input())
S = input()
assert len(S) == N
count = 0
# j-i = k-jを探す
for i in range(0, len(S)-2):
for j in range(i+1, len(S)-1):
k = j + (j - i)
if k < len(S):
if S[i] != S[j] and S[j] != S[k] and S[k] != S[i]:
count += 1
numR = 0
numG = 0
numB = 0
for s in S:
if s == 'R':
numR += 1
elif s == 'G':
numG += 1
else:
numB += 1
print(numR * numG * numB - count) | 0 | null | 18,627,906,405,120 | 56 | 175 |
def main():
data_count = int(input())
data = [list(map(int, input().split())) for i in range(data_count)]
for item in data:
item.sort()
print('YES') if item[0]**2 + item[1]**2 == item[2]**2 else print('NO')
main() | import math
import itertools
for i in range(int(input())):
a, b, c = sorted(map(int, input().split()))
print('YES' if a*a+b*b==c*c else 'NO') | 1 | 312,245,146 | null | 4 | 4 |
(h,n),*t=[list(map(int,o.split()))for o in open(0)]
d=[0]*10**8
for i in range(h):d[i+1]=min(b+d[i-a+1]for a,b in t)
print(d[h]) | N, X, M = map(int,input().split())
ans = 0
ls = [X%M] + [-1]*(M+1)
ls_app = [0]*(M+1)
for i in range(N):
a = ls[i]
ls_app[a] = i
ls[i+1] = pow(a,2,M)
if i+1 < N and ls_app[ls[i+1]] != 0:
b = ls[i+1]
L = ls_app[b]
R = i
len_roop = R - L + 1
p = (N - L) // len_roop
q = (N - L) % len_roop
break
else:
for i in range(N):
ans += ls[i]
print(ans)
exit()
sum_roop = 0
for i in range(L, R+1):
sum_roop += ls[i]
sum_edge = 0
for i in range(L, L+q):
sum_edge += ls[i]
for i in range(L):
ans += ls[i]
else:
ans += sum_roop * p + sum_edge
print(ans) | 0 | null | 41,755,041,650,498 | 229 | 75 |
n = int(input())
C = list(input())
W = C.count("W")
R = C.count("R")
# 仕切りより左側にある白石の数
w = 0
# 仕切りより右側にある赤石の数
r = R
ans = r
for i in range(n):
if C[i] == "W":
w += 1
else:
r -= 1
ans = min(ans, max(w, r))
print(ans) | n=int(input())
s = input()
Ra = s.count('R')
t = s[:Ra]
Rb = t.count('R')
print(Ra-Rb) | 1 | 6,278,896,929,580 | null | 98 | 98 |
n = int(input())
ans = 0
x = n // 2
for i in range(1, n + 1):
m = n // i
ans += i * ((m + 1) * m) // 2
print(ans)
| import math
def S(i):
return ((i * (i+1)) // 2)
N = int(input())
ans = 0
sqrt_N = math.floor(math.sqrt(N))
for K in range(1, N+1, 1):
if((N // K) < sqrt_N):
break
# 個別に足す
ans += S(N // K) * K
for NdivK in range(1, sqrt_N, 1):
# [N // K]が等しいKの区間を求める
Kbegin = N // (NdivK + 1)
Kend = N // NdivK
ans += (S(NdivK) * (S(Kend) - S(Kbegin)))
print(ans) | 1 | 10,952,900,305,902 | null | 118 | 118 |
input();print(input().count("ABC")) | import sys
s = input()
k = int(input())
n = len(s)
if n==1:
print(k//2)
sys.exit()
if n==2:
print(k if s[0]==s[1] else 0)
sys.exit()
i = 1
change = [0, 0]
same = True
while i<n:
if s[i-1]==s[i]:
if i==n-1:
same = False
change[0] += 1
i += 1
i += 1
if s[0]!=s[-1]:
same = False
if not same:
print(change[0]*k)
sys.exit()
i = 2
change[1] = 1
same = True
while i<n:
if s[i-1]==s[i]:
if i==n-1:
same = False
change[1] += 1
i += 1
i += 1
if same:
print(change[0]+change[1]*(k-1))
else:
print(change[0]*((k+1)//2)+change[1]*(k//2)) | 0 | null | 136,993,869,945,230 | 245 | 296 |
N = int(input())
A = [0 for n in range(N)]
XY = [0 for n in range(N)]
count_max = 0
for i in range(N):
A[i] = int(input())
xy = []
for j in range(A[i]):
x_y = list(map(int,input().split()))
xy.append(x_y)
XY[i] = xy
for i in range(2 ** N):
op = [0]*N
for j in range(N): # ポイント１
if ((i >> j) & 1):
op[N-1-j] = 1
flag = True
for k in range(len(op)):
if op[k] == 1:
for l in range(A[k]):
if XY[k][l][1] != op[XY[k][l][0]-1]:
flag = False
if flag:
if sum(op) > count_max:
count_max = sum(op)
print(count_max) | N = int(input())
W = [[-1]*N for _ in range(N)]
for i in range(N):
A = int(input())
for j in range(A):
x, y = [int(z) for z in input().split()]
x -= 1
W[i][x] = y
M = 0
for b in range(2**N):
d = [0] * N
for i in range(N):
if (b >> i) & 1:
d[i] = 1
ok = True
for i in range(N):
if d[i] == 1:
for j in range(N):
if W[i][j] == -1:
continue
if W[i][j] != d[j]:
ok =False
if ok == True:
M = max(M, sum(d))
print(M) | 1 | 121,559,238,491,590 | null | 262 | 262 |
n = input()
r = range(0,52)
for i in range(0,n):
x = map(str,raw_input().split(" "))
y = (int(x[1])-1)/13
if x[0] == "S":
y = 0
elif x[0] == "H":
y = 1
elif x[0] =="C":
y = 2
else:
y = 3
z = (int(x[1])-1)
r.remove(y*13+z)
s = "S"
for j in range(0,len(r)):
y = r[j]/13
z = r[j]%13
if y ==1:
s = "H"
elif y ==2:
s = "C"
elif y ==3:
s ="D"
print s+" "+str(z+1) | import sys
SUITS = ('S', 'H', 'C', 'D')
cards = {suit:{i for i in range(1, 14)} for suit in SUITS}
n = input() # 読み捨て
for line in sys.stdin:
suit, number = line.split()
cards[suit].discard(int(number))
for suit in SUITS:
for i in cards[suit]:
print(suit, i) | 1 | 1,045,852,323,906 | null | 54 | 54 |
n,k = map(int,input().split())
A = sorted(list(map(int,input().split())))
F = sorted(list(map(int,input().split())))[::-1]
o = []
for a,f in zip(A,F):
o.append(a*f)
ok = max(o)
ng = -1
while ok - ng > 1:
mid = (ok+ng)//2
k1 = 0
for i in range(n):
k1 += max( 0 , A[i]- mid//F[i])
if k1<= k:
ok = mid
else:
ng = mid
print(ok)
| X=int(input())
A=0
B=0
for i in range(-120,120):
for k in range(-120,120):
if i**5==X+k**5:
A=i
B=k
break
print(A,B) | 0 | null | 94,882,345,676,860 | 290 | 156 |
X = int(input())
flag = 0
for i in range(-150,150):
for j in range(-150,150):
if(i**5 - j**5 == X):
print(i,j)
flag = 1
break
if(flag==1):
break | X = int(input())
for a in range(-118,120):
for b in range(-119,119):
if a**5 - b**5 == X:
ans = (a,b)
break
print(ans[0],ans[1])
| 1 | 25,635,868,154,052 | null | 156 | 156 |
import sys, math, itertools
input = lambda: sys.stdin.readline().rstrip()
sys.setrecursionlimit(10**7)
INF = 10**20
MOD = 998244353
def I(): return int(input())
def F(): return float(input())
def S(): 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 LS(): return input().split()
def factorialMod(n, p):
fact = [0] * (n+1)
fact[0] = fact[1] = 1
factinv = [0] * (n+1)
factinv[0] = factinv[1] = 1
inv = [0] * (n+1)
inv[1] = 1
for i in range(2, n + 1):
fact[i] = (fact[i-1] * i) % p
inv[i] = (-inv[p % i] * (p // i)) % p
factinv[i] = (factinv[i-1] * inv[i]) % p
return fact, factinv
def combMod(n, r, fact, factinv, p):
if (r < 0) or (n < r):
return 0
r = min(r, n - r)
return fact[n] * factinv[r] * factinv[n-r] % p
def resolve():
N, M, K = LI()
ans = 0
fact, factinv = factorialMod(N, MOD)
for i in range(K + 1):
ans += combMod(N - 1, i, fact, factinv, MOD) * M * pow(M - 1, N - 1 - i, MOD)
ans %= MOD
print(ans)
if __name__ == '__main__':
resolve()
| N, M, K = map(int, input().split())
MOD = 998244353
n = N
fac = [1]*(n+1)
rev = [1]*(n+1)
for i in range(1,n+1):
fac[i] = i*fac[i-1]%MOD
rev[i] = pow(fac[i], MOD-2, MOD)
comb = lambda a,b:(fac[a]*rev[a-b]*rev[b])%MOD
ans = 0
for i in range(K+1):
ans += comb(N-1, N-1-i) * M * pow(M-1, N-1-i, MOD)
ans %= MOD
print(ans)
| 1 | 23,118,767,398,672 | null | 151 | 151 |
X = int(input())
yen500, yen5 = divmod(X, 500)
yen5 = yen5 // 5
print(yen500 * 1000 + yen5 * 5) | x = int(input());print((x//500)*1000 + ((x%500)//5)*5) | 1 | 42,746,050,168,416 | null | 185 | 185 |
from sys import stdin
import sys
import math
from functools import reduce
import functools
import itertools
from collections import deque,Counter,defaultdict
from operator import mul
import copy
# ! /usr/bin/env python
# -*- coding: utf-8 -*-
import heapq
sys.setrecursionlimit(10**6)
# INF = float("inf")
INF = 10**18
import bisect
import statistics
mod = 10**9+7
# mod = 998244353
A, B, N = map(int, input().split())
if N >= B-1:
print(A*(B-1)//B)
else:
print(A*N//B) | a, b, n = map(int, input().split())
if b > n:
x = n
else:
x = b - 1
print(int(a * x / b) - a * int(x / b)) | 1 | 28,166,148,912,242 | null | 161 | 161 |
#!/usr/bin/env python
from sys import stdin, stderr
def main():
K = int(stdin.readline())
A = [1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51]
print(A[K-1])
return 0
if __name__ == '__main__': main()
| [a,b,c] = list(map(int,input().split()))
if c-a-b<0:
print('No')
else:
left = 4*a*b
right = (c-a-b)**2
if left<right:
print('Yes')
else:
print('No') | 0 | null | 50,805,683,490,728 | 195 | 197 |
from sys import stdin
def main():
#入力
readline=stdin.readline
h,w,k=map(int,readline().split())
grid=[readline().strip() for _ in range(h)]
ans=float("inf")
for i in range(1<<(h-1)):
div=[(i>>j)&1 for j in range(h-1)]
l=len([0 for i in range(h-1) if div[i]])+1
cnt=[0]*l
tmp=0
for j in range(w):
now=0
flag=False
for i_2 in range(h):
if grid[i_2][j]=="1":
cnt[now]+=1
if cnt[now]>k:
flag=True
break
if i_2<h-1 and div[i_2]==1: now+=1
if flag:
tmp+=1
cnt=[0]*l
now=0
flag=False
for i_2 in range(h):
if grid[i_2][j]=="1":
cnt[now]+=1
if cnt[now]>k:
flag=True
break
if i_2<h-1 and div[i_2]==1: now+=1
if flag: break
else:
tmp+=l-1
ans=min(ans,tmp)
print(ans)
if __name__=="__main__":
main() | from itertools import product
H, W, K = map(int, input().split())
G = [list(map(int, list(input()))) for _ in range(H)]
ans = float("inf")
for pattern in product([0, 1], repeat = H - 1):
div = [0] + [i for i, p in enumerate(pattern, 1) if p == 1] + [H]
rows = []
for i in range(len(div) - 1):
row = []
for j in range(W):
tmp = 0
for k in range(div[i], div[i + 1]):
tmp += G[k][j]
row.append(tmp)
rows.append(row)
flag = True
for row in rows:
if [r for r in row if r > K]:
flag = False
break
if not flag:
continue
tmp_ans = 0
cnt = [0] * len(rows)
w = 0
while w < W:
for r in range(len(rows)):
cnt[r] += rows[r][w]
if [c for c in cnt if c > K]:
cnt = [0] * len(rows)
tmp_ans += 1
w -= 1
w += 1
tmp_ans += pattern.count(1)
ans = min(ans, tmp_ans)
print(ans) | 1 | 48,606,658,152,640 | null | 193 | 193 |
N,M = map(int,input().split())
S = input()
c = 0
flag = 0
for i in S:
if i == '0':
if c >= M:
flag = 1
break
c = 0
else:
c += 1
if flag == 1:
print(-1)
else:
T = S[::-1]
now = 0
ans = []
while now != N:
delta = 0
for i in range(1,M+1):
if now + i == N:
delta = i
break
if T[now+i] == '0':
delta = i
ans.append(delta)
now += delta
Answer = ans[::-1]
print(*Answer) | import bisect
N = int(input())
Ls = list(map(int, input().split(" ")))
Ls.sort()
ans = 0
for i in range(0,N-2):
for j in range(i+1,N-1):
k = bisect.bisect_left(Ls,Ls[i]+Ls[j])
ans += k - (j + 1)
print(ans) | 0 | null | 155,287,759,922,802 | 274 | 294 |
num = input()
L = num.split()
D = int(L[0])
T = int(L[1])
S = int(L[2])
if D / S <= T:
print("Yes")
else:
print("No") | A = list(map(float, input().split()))
if(A[0]/A[2] <= A[1]):
print("Yes")
else:
print("No") | 1 | 3,516,048,180,306 | null | 81 | 81 |
n,m = map(int,input().split())
ans = 0
for i in range(n-1):
ans = ans + i+1
for b in range(m-1):
ans = ans + b+1
print(ans) | import math
n = int(input())
m = n//2
if n % 2 == 0:
print(m)
else:
print(m+1)
| 0 | null | 52,336,723,796,202 | 189 | 206 |
A1 = list(map(int, input().split()))
A2 = list(map(int, input().split()))
A3 = list(map(int, input().split()))
N = int(input())
B = [int(input()) for i in range(N)]
result = ''
for b in B:
if b in A1:
a = A1.index(b)
A1.remove(b)
A1.insert(a, 0)
elif b in A2:
a = A2.index(b)
A2.remove(b)
A2.insert(a, 0)
elif b in A3:
a = A3.index(b)
A3.remove(b)
A3.insert(a, 0)
else:
pass
if A1.count(0) == 3:
result ='y'
elif A2.count(0) == 3:
result ='y'
elif A3.count(0) == 3:
result ='y'
for m in range(3):
if A1[m] == 0 and A2[m] == 0 and A3[m] == 0:
result ='y'
else:
pass
if A1[0] == 0 and A2[1] == 0 and A3[2] == 0:
result = 'y'
elif A1[2] == 0 and A2[1] == 0 and A3[0] == 0:
result = 'y'
if result == 'y':
print('Yes')
else:
print('No')
| x = int(input())
ans = x // 500 * 1000
x = x % 500
ans += x // 5 * 5
print(ans) | 0 | null | 51,377,709,504,690 | 207 | 185 |
n = int(input())
a = list(map(int, input().split()))
MOD = 1000000007
dic = {}
dic[0] = 3
for i in range(1,n+1):
dic[i] = 0
ans = 1
for i in range(n):
ans = ans * dic[a[i]] % MOD
dic[a[i]] -= 1
dic[a[i] + 1] += 1
print(ans) | import sys
input = sys.stdin.readline
mod = 10**9 + 7
def main():
n = int(input())
A = list(map(int, input().split()))
candidates = [0] * (n+1)
candidates[0] = 3
ans = 1
for a in A:
ans *= candidates[a]
ans %= mod
candidates[a] -= 1
candidates[a+1] += 1
print(ans)
if __name__ == "__main__":
main()
| 1 | 129,716,421,546,560 | null | 268 | 268 |
import sys
import math
from collections import defaultdict
sys.setrecursionlimit(10**7)
def input():
return sys.stdin.readline()[:-1]
mod = 10**9 + 7
def I(): return int(input())
def LI(): return list(map(int, input().split()))
def LIR(row,col):
if row <= 0:
return [[] for _ in range(col)]
elif col == 1:
return [I() for _ in range(row)]
else:
read_all = [LI() for _ in range(row)]
return map(list, zip(*read_all))
#################
T1,T2 = LI()
A1,A2 = LI()
B1,B2 = LI()
if A1 > B1 and A2 > B2:
print(0)
exit()
if A1 < B1 and A2 < B2:
print(0)
exit()
if A1 > B1:
t = (A1-B1)*T1 / (B2-A2)
delta = (A1-B1)*T1+(A2-B2)*T2
if t == T2:
print('infinity')
exit()
elif t > T2:
print(0)
exit()
else:
if delta > 0:
print(math.floor((T2-t)*(B2-A2)/delta) + 1)
exit()
else:
x = (A1-B1)*T1 / (-delta)
if int(x) == x:
print(2*int(x))
else:
print(2*math.floor(x)+1)
else:
t = (B1-A1)*T1 / (A2-B2)
delta = (B1-A1)*T1+(B2-A2)*T2
if t == T2:
print('infinity')
exit()
elif t > T2:
print(0)
exit()
else:
if delta > 0:
print(math.floor((T2-t)*(A2-B2)/delta) + 1)
exit()
else:
x = (B1-A1)*T1 / (-delta)
if int(x) == x:
print(2*int(x))
else:
print(2*math.floor(x)+1) | import sys
sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def main():
t1,t2=MI()
a1,a2=MI()
b1,b2=MI()
if a1<b1:a1,a2,b1,b2=b1,b2,a1,a2
if a1*t1+a2*t2==b1*t1+b2*t2:
print("infinity")
exit()
if a1*t1+a2*t2>b1*t1+b2*t2:
print(0)
exit()
x=a1*t1-b1*t1
y=b1*t1+b2*t2-(a1*t1+a2*t2)
ans=(x//y)*2
if x%y:
ans+=1
print(ans)
main() | 1 | 131,321,543,538,212 | null | 269 | 269 |
import sys
l = sys.stdin.readlines()
minv = int(l[1])
maxv = -1000000000
for r in map(int,l[2:]):
m = r-minv
if maxv < m:
maxv = m
if m < 0: minv = r
elif m < 0: minv = r
print(maxv) | n=int(input())
R=[int(input()) for i in range(n)]
mini=10**10
maxi=-10**10
for r in R:
maxi=max([maxi,r-mini])
mini=min([mini,r])
print(maxi)
| 1 | 12,737,811,068 | null | 13 | 13 |
import math
A, B = map(str,input().split(" "))
B_ = int(B.split(".")[0])*100 + int(B.split(".")[1])
print(int(A) * B_ // 100)
| a, b = input().split()
a = int(a)
b1, b2 = b.split('.')
b = int(b1 + b2)
print(a * b // 100) | 1 | 16,415,185,620,022 | null | 135 | 135 |
N = int(input())
S = input()
assert len(S) == N
count = 0
# j-i = k-jを探す
for i in range(0, len(S)-2):
for j in range(i+1, len(S)-1):
k = j + (j - i)
if k < len(S):
if S[i] != S[j] and S[j] != S[k] and S[k] != S[i]:
count += 1
numR = 0
numG = 0
numB = 0
for s in S:
if s == 'R':
numR += 1
elif s == 'G':
numG += 1
else:
numB += 1
print(numR * numG * numB - count) | from collections import defaultdict
def main():
_, S = open(0).read().split()
indices, doubled_indices = defaultdict(list), defaultdict(set)
for i, c in enumerate(S):
indices[c].append(i)
doubled_indices[c].add(2 * i)
cnt = S.count("R") * S.count("G") * S.count("B")
for x, y, z in ["RGB", "GBR", "BRG"]:
cnt -= sum(i + j in doubled_indices[z] for i in indices[x] for j in indices[y])
print(cnt)
if __name__ == "__main__":
main() | 1 | 36,206,964,382,140 | null | 175 | 175 |
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**9)
n, u, v = map(int, input().split())
GRAPH = {i:[] for i in range(1, n + 1)}
for _ in range(n - 1):
a, b = map(int, input().split())
GRAPH[a].append(b)
GRAPH[b].append(a)
def dfs(now, prev = 0):
PARENT[now] = prev
DEPTH[now] = DEPTH[prev] + 1
if len(GRAPH[now]) == 1:
LEAVES.append((DEPTH[now], now))
for w in GRAPH[now]:
if w == prev:
continue
next = w
dfs(next, now)
PARENT = {}
DEPTH = {0:-1}
LEAVES = []
dfs(v)
PATH = {i:False for i in range(1, n + 1)}
now = u
while True:
PATH[now] = True
if now == v:
break
now = PARENT[now]
LEAVES.sort(reverse = True)
for leaf in LEAVES:
now = leaf[1]
while True:
if PATH[now]:
break
now = PARENT[now]
lca = now
du, dv = DEPTH[u] - DEPTH[lca], DEPTH[lca]
if du < dv:
print(leaf[0] - 1)
exit()
| import sys
sys.setrecursionlimit(10**9)
f=lambda:map(int,sys.stdin.readline().split())
n,st,sa=f()
g=[set() for _ in range(n)]
for _ in range(n-1):
a,b=f()
g[a-1].add(b-1)
g[b-1].add(a-1)
def dfs(l,v,p=-1,d=0):
l[v]=d
for c in g[v]:
if c!=p: dfs(l,c,v,d+1)
lt=[0]*n
dfs(lt,st-1)
la=[0]*n
dfs(la,sa-1)
print(max(la[i] for i in range(n) if lt[i]<la[i])-1) | 1 | 117,410,535,464,730 | null | 259 | 259 |
N = int(input())
List = [list(map(str, input().split())) for i in range(0,N)]
X = str(input())
yoroshiosu = 0
samu = 0
for i in range (0, N):
if X == List[i][0]:
yoroshiosu =1
elif yoroshiosu == 0:
continue
else:
samu+=int(List[i][1])
print(samu)
| '''
Created on 2020/08/20
@author: harurun
'''
def main():
import itertools
import sys
pin=sys.stdin.readline
pout=sys.stdout.write
perr=sys.stderr.write
N=int(pin())
S=[]
T=[]
for _ in [0]*N:
s,t=pin().split()
S.append(s)
T.append(int(t))
U=list(itertools.accumulate(T))
X=pin()[:-1]
print(sum(T)-U[S.index(X)])
return
main() | 1 | 96,640,144,486,038 | null | 243 | 243 |
def abc169c_multiplication3():
a, b = input().split()
a = int(a)
b = int(b[0] + b[2] + b[3])
print(a * b // 100)
abc169c_multiplication3()
| a, b = map(float, input().split())
ib = b * 100
ans = int(a) * round(ib) // 100
print(ans) | 1 | 16,670,387,147,820 | null | 135 | 135 |
n=int(input())
llist=list(map(int,input().split()))
ans=0
for i in range(n):
for j in range(n-i-1):
for k in range(n-i-j-2):
ii=llist[i]
ji=llist[i+j+1]
ki=llist[i+j+k+2]
if ji != ii and ji != ki and ii != ki:
if max(ii,ji,ki)*2 < ji+ii+ki:
ans+=1
print(ans) | n = int(input())
L = list(map(int,input().split()))
ans = 0
for i in range(n-2):
for j in range(i+1,n-1):
for k in range(j+1,n):
if L[i]!=L[j] and L[i]!=L[k] and L[j]!=L[k] and abs(L[j]-L[k])<L[i]<L[j]+L[k]:
ans += 1
print(ans) | 1 | 5,071,703,989,260 | null | 91 | 91 |
for i in range(int(raw_input())):
a, b, c = [int(j) ** 2 for j in raw_input().split()]
if a+b==c or a+c==b or b+c==a:
print 'YES'
else:
print 'NO' | # coding:utf-8
def main():
N = int(input().rstrip())
for i in range(N):
ls = list(map(int, input().split(' ')))
ls.sort()
if(ls[0]**2 + ls[1]**2 == ls[2]**2):
print('YES')
else:
print('NO')
if __name__ == "__main__":
main() | 1 | 386,424,212 | null | 4 | 4 |
import sys
read = sys.stdin.read
readlines = sys.stdin.readlines
import numba
def main():
@numba.njit
def solve(n):
r = 0
for i1 in range(1, n + 1):
y = n // i1
r += y * (y + 1) // 2 * i1
return r
no = int(input())
print(solve(no))
if __name__ == '__main__':
main() | #!/usr/bin/env python
# -*- coding: utf-8 -*-
def main():
X = int(input())
print(X ^ 1)
if __name__ == "__main__":
main()
| 0 | null | 6,983,296,770,534 | 118 | 76 |
import bisect
def main():
n = int(input())
l = sorted(list(int(i) for i in input().split()))
cnt = 0
for i in range(n - 2):
a = l[i]
for j in range(i + 1, n-1):
b = l[j]
cnt += bisect.bisect_left(l, a+b)-(j+1)
print(cnt)
if __name__ == "__main__":
main()
| ### ----------------
### ここから
### ----------------
import sys
from io import StringIO
import unittest
def yn(b):
print("Yes" if b==1 else "No")
return
def bin_search(arr,ls,c):
l=ls-1
r = len(arr)
while (r-l) > 1:
m = l + (r-l)//2
if arr[m] >= c:
r = m
else:
l = m
return l-ls+1
def resolve():
readline=sys.stdin.readline
n=int(readline())
arr=list(map(int, readline().rstrip().split()))
arr.sort()
ans=0
for i in range(n-2):
for j in range(i+1,n-1):
c = arr[i] + arr[j]
ans += bin_search(arr,j+1,c)
print(ans)
return
if 'doTest' not in globals():
resolve()
sys.exit()
### ----------------
### ここまで
### ----------------
| 1 | 172,414,750,761,608 | null | 294 | 294 |
s = input()
right = [0]*(len(s)+1)
for i in range(len(s)):
if s[i] == '<':
right[i+1] = right[i] + 1
left = [0]*(len(s)+1)
for i in range(len(s)-1, -1, -1):
if s[i] == '>':
left[i] = left[i+1] + 1
ans = 0
for i in range(len(s)+1):
ans += max(right[i], left[i])
print(ans) | def decode():
[n, k] = [int(x) for x in input().split(" ")]
ws = []
for _ in range(n):
ws.append(int(input()))
return n, k, ws
def check(k, ws, p):
sum_w = ws[0]
tr = 1
for w in ws[1:]:
if sum_w + w <= p:
sum_w += w
else:
sum_w = w
tr += 1
if tr > k:
return False
return True
if __name__ == '__main__':
n, k, ws = decode()
lo = max(ws)
hi = sum(ws)
while lo <= hi:
p = (lo + hi) // 2
if check(k, ws, p):
hi = p - 1
ans = p
else:
lo = p + 1
print(ans)
| 0 | null | 78,281,727,795,960 | 285 | 24 |
def dfs(s,n):
if len(s) == n:
print(s)
else:
for i in range(len(set(s))+1):
dfs(''.join([s,chr(97+i)]),n)
N = int(input())
dfs('a',N) | N = int(input())
a_num = 97
def dfs(s, n): #s: 現在の文字列, n: 残りの文字数, cnt: 現在の文字列の最大の値
if n == 0:
print(s)
return
for i in range(ord("a"), ord(max(s))+2):
dfs(s+chr(i), n-1)
dfs("a", N-1)
| 1 | 52,679,810,923,768 | null | 198 | 198 |
import sys
mod=10**9+7 ; inf=float("inf")
from math import sqrt, ceil
from collections import deque, Counter, defaultdict #すべてのkeyが用意されてる defaultdict(int)で初期化
# input=lambda: sys.stdin.readline().strip()
sys.setrecursionlimit(11451419)
from decimal import ROUND_HALF_UP,Decimal #変換後の末尾桁を0や0.01で指定
#Decimal((str(0.5)).quantize(Decimal('0'), rounding=ROUND_HALF_UP))
from functools import lru_cache
#メモ化再帰defの冒頭に毎回 @lru_cache(maxsize=10**10)
#引数にlistはだめ
#######ここまでテンプレ#######
#ソート、"a"+"b"、再帰ならPython3の方がいい
#######ここから天ぷら########
h,w,k=map(int,input().split())
# R=[]
A=[[0]*w for i in range(h)]
dp=[[[0 for j in range(w)] for i in range(h)] for i in range(4)]
for s in sys.stdin.readlines():
x,y,v=map(int,s.split())
x-=1;y-=1
A[x][y]=v
# dp[x][y][1]=v
# dp[x][y][2]=v
# dp[x][y][3]=v;
dp[1][0][0]=A[0][0]
for i in range(h):
for j in range(w):
for k in range(4):
here=dp[k][i][j]
if i<h-1:
dp[0][i+1][j] = max(here,dp[0][i+1][j])
dp[1][i+1][j] = max(here+A[i+1][j], dp[1][i+1][j])
if j<w-1:
dp[k][i][j+1] = max(dp[k][i][j+1], here)
if k<=2:
dp[k+1][i][j+1]= max(dp[k+1][i][j+1],here+ A[i][j+1])
ans=0
for i in range(4):
ans=max(ans, dp[i][-1][-1])
print(ans) | import math
x = int(input())
ans = 0
y = 100
while y < x:
y += y//100
ans += 1
print(ans) | 0 | null | 16,244,253,745,500 | 94 | 159 |
H, N = map(int, input().split())
list_A = list(map(int,input().split()))
sum_list_A = sum(list_A)
if sum_list_A >= H:
print("Yes")
else:
print("No") | import sys
a,b,c = map(int,sys.stdin.readline().split())
counter = 0
for n in range(a,b+1):
if c % n == 0:
counter += 1
print(counter) | 0 | null | 39,349,599,651,010 | 226 | 44 |
N,M=list(map(int, input().split()))
if N==M:
print('Yes')
else:
print('No') | def main():
N, M = map(int, input().split())
if N == M:
return "Yes"
return "No"
if __name__ == '__main__':
print(main())
| 1 | 83,394,263,446,282 | null | 231 | 231 |
import copy
import itertools
h, w, k = map(int, input().split())
#s= list(input())
s = []
min = 100000
for i in range(h):
s.append( [int(s) for s in list(input())])
#s.append([1]*w)
dbg_cnt = 0
l = list(range(h-1))
for i in range(h):
p = list(itertools.combinations(l, i))
for j in p:
tmp = list(j)
tmps = []
q = 0
tmps.append([])
#print(dbg_cnt)
#dbg_cnt += 1
for r in range(h):
tmps[q].append(copy.copy(s[r]))
if(q < len(tmp) and r==tmp[q]):
tmps.append([])
q += 1
#print(tmps)
count = i
sums = [0] * len(tmps)
precut = 1
exitflg = 0
for r in range(w): #550000
for q in range(len(tmps)):
for t in tmps[q]:
sums[q] += t[r] #5500000
cutflg = 0
for q in range(len(tmps)):
if sums[q] > k : #5500000
cutflg = 1
if cutflg == 1:
#print('cut')
count += 1
sums = [0] * len(tmps)
for q in range(len(tmps)):
for t in tmps[q]:
sums[q] += t[r] #5500000
for q in range(len(tmps)): #5500000
if sums[q] > k :
exitflg = 1
#print('exit')
#print(exitflg)
if exitflg == 0:
if min > count:
min = count
print(min) | import sys
def input(): return sys.stdin.readline().rstrip()
def main():
h,w,k=map(int,input().split())
S=[input() for _ in range(h)]
final_ans=10**10
for row_lis in range(1<<(h-1)):
lst=[0]*h
q,ans=0,0
for r in range(h-1):
if (row_lis>>r)&1==0:
lst[r+1]=q
else:
q+=1
lst[r+1]=q
ans+=1
data=[0]*h
for j in range(w):
for i in range(h):
data[lst[i]]+=int(S[i][j])
if data[lst[i]]>k:
ans+=1
break
else:
continue
data=[0]*h
for i in range(h):
data[lst[i]]+=int(S[i][j])
if data[lst[i]]>k:
break
else:
continue
break
else:
final_ans=min(final_ans,ans)
print(final_ans)
if __name__=='__main__':
main() | 1 | 48,687,441,440,000 | null | 193 | 193 |
n = int(raw_input())
a = map(int, raw_input().split())
print min(a), max(a), sum(a) | input()
list=[int(i) for i in input().split()]
print(min(list),max(list),sum(list))
| 1 | 731,518,195,430 | null | 48 | 48 |
W,H,x,y,r = [int(s) for s in input().split()]
if 0 <= (x-r) <= (x+r) <= W:
if 0 <= (y-r) <= (y+r) <= H:
print("Yes")
else:
print("No")
else:
print("No") | in_str = input().split(" ")
in_width = int(in_str[0])
in_hight = int(in_str[1])
in_x = int(in_str[2])
in_y = int(in_str[3])
in_r = int(in_str[4])
#x check
if (0 <= in_x - in_r) & (in_x + in_r <= in_width):
#y check
if (0 <= in_y - in_r) & (in_y + in_r <= in_hight):
print("Yes")
else:
print("No")
else:
print("No") | 1 | 449,745,092,508 | null | 41 | 41 |
class dictionary:
def __init__(self):
self._d = set()
def insert(self, s):
self._d.add(s)
def find(self, s):
if s in self._d:
print("yes")
else:
print("no")
if __name__ == '__main__':
dd = dictionary()
n = int(input())
for _ in range(n):
args = input().split()
if args[0] == "insert":
dd.insert(args[1])
elif args[0] == "find":
dd.find(args[1])
| def dictionary():
n = int(input())
s = set()
for i in range(n):
command, value = input().split()
if command == 'insert':
s.add(value)
elif command == 'find':
if value in s:
print('yes')
else:
print('no')
if __name__ == '__main__':
dictionary() | 1 | 76,375,290,630 | null | 23 | 23 |
#!/usr/bin/env python3
import sys
from itertools import chain
# import numpy as np
# from itertools import combinations as comb
# from bisect import bisect_left, bisect_right, insort_left, insort_right
# from collections import Counter
MOD = 1000000007 # type: int
OFFSET = 10 ** 100
def k_in_n(k, n):
"""0〜n までの数からちょうど k 個の数を選ぶ時の最大最小"""
minimum = (k * (k - 1)) // 2
maximum = (k * (2 * n - k + 1)) // 2
return (minimum, maximum)
def solve(N: int, K: int):
keep = None # まだ加算されていない範囲
answer = 0
for k in range(K, N + 2):
if keep is None:
keep = k_in_n(k, N)
else:
minmax = k_in_n(k, N)
if minmax[0] + OFFSET <= keep[1]:
keep[0] -= OFFSET
keep[1] = minimum[1]
else:
answer = (answer + keep[1] - keep[0] + 1) % MOD
keep = minmax
if keep is not None:
answer = (answer + keep[1] - keep[0] + 1) % MOD
return answer
def main():
tokens = chain(*(line.split() for line in sys.stdin))
# N, K = map(int, input().split())
# N, K = input().strip()
# N, K = int(input())
N = int(next(tokens)) # type: int
K = int(next(tokens)) # type: int
answer = solve(N, K)
print(answer)
if __name__ == "__main__":
main()
| import math
pi=math.pi
r=float(input())
menseki=r*r*pi
ensyu=2*r*pi
print(str(menseki)+" "+str(ensyu))
| 0 | null | 16,971,023,415,808 | 170 | 46 |
count = {}
for i in range(26):
count[(i)] = 0
while True:
try:
x = raw_input()
except:
break
for i in range(len(x)):
if(ord('a') <= ord(x[i]) and ord(x[i]) <= ord('z')):
count[(ord(x[i])-ord('a'))] += 1
elif(ord('A') <= ord(x[i]) and ord(x[i]) <= ord('Z')):
count[(ord(x[i])-ord('A'))] += 1
for i in range(26):
print '%s : %d' %(chr(i+ord('a')), count[(i)])
exit(0) | import sys
count = [0 for _ in range(ord("a"), ord("z") + 1)]
for line in sys.stdin:
for c in list(line.lower()):
if "a" <= c <= "z":
count[ord(c) - ord("a")] += 1
for i, n in enumerate(count):
print("{ch} : {cnt}".format(ch = chr(ord("a") + i), cnt = n))
| 1 | 1,673,924,881,792 | null | 63 | 63 |
"RPN using stack for AOJ ALDS1_3_A: Stack"
# coding: utf-8
def rpn(exp):
"""
rpn calculation
>>> rpn(['1', '2', '+', '3', '4', '-', '*'])
-3
"""
stack = []
for elem in exp:
if elem == '+':
stack.append(int(stack.pop()) + int(stack.pop()))
elif elem == '-':
stack.append(-int(stack.pop()) + int(stack.pop()))
elif elem == '*':
stack.append(int(stack.pop()) * int(stack.pop()))
elif elem == '/':
stack.append(int(stack.pop()) / int(stack.pop()))
else:
stack.append(elem)
print(stack.pop())
def main():
"main function"
exp = list(input().split(' '))
rpn(exp)
if __name__ == '__main__':
# import doctest
# doctest.testmod()
main() | from bisect import bisect_right
def bisectsearch_right(L,a):
i=bisect_right(L,a)
return(i)
N,M,K= list(map(int, input().split()))
A= list(map(int, input().split()))
B= list(map(int, input().split()))
Asum=[0]*N
Bsum=[0]*M
Asum[0]=A[0]
Bsum[0]=B[0]
for i in range(1,N):
Asum[i]=Asum[i-1]+A[i]
for j in range(1,M):
Bsum[j]=Bsum[j-1]+B[j]
# print(Asum)
# print(Bsum)
ans=[0]*(N+1)
ans[0]=bisectsearch_right(Bsum,K)
# print(ans[0])
for i in range(1,N+1):
if Asum[i-1]>K:
continue
j=bisectsearch_right(Bsum,K-Asum[i-1])
# print(j)
ans[i]=i+j
# print(ans)
print(max(ans))
| 0 | null | 5,356,122,913,830 | 18 | 117 |
import sys
from fractions import gcd
input = sys.stdin.readline
N = int(input())
a = list(map(int, input().split()))
mod = 10 ** 9 + 7
g = 0
lcm = 1
for x in a:
g = gcd(lcm, x)
lcm *= x // g
lcm %= mod
res = 0
for x in a:
res += lcm * pow(x, mod - 2, mod) % mod
res %= mod
print(res) | import itertools
def LI():
return tuple(map(int, input().split()))
N = int(input())
P = LI()
Q = LI()
Nlist = list(range(1, N+1))
count = 1
for v in itertools.permutations(Nlist, N):
if P == v:
p = count
if Q == v:
q = count
count += 1
print(abs(p-q))
| 0 | null | 94,386,582,265,792 | 235 | 246 |
import sys
input = sys.stdin.readline
from bisect import bisect_left
from itertools import accumulate
def func(A, N, M, x):
count = 0
for Ai in A:
idx = bisect_left(A, x - Ai)
count += N - idx
if count >= M:
return True
else:
return False
def main():
N, M = map(int, input().split())
A = sorted(list(map(int, input().split())))
A_rev = list(reversed(A))
B = [0] + list(accumulate(A_rev))
min_ = 0
max_ = 2 * 10 ** 5 + 1
while max_ - min_ > 1:
mid = (min_ + max_) // 2
if func(A, N, M, mid):
min_ = mid
else:
max_ = mid
ans = 0
count = 0
for Ai in A_rev:
idx = bisect_left(A, min_-Ai)
ans += Ai * (N - idx) + B[N-idx]
count += N - idx
print(ans-(count-M)*min_)
if __name__ == '__main__':
main() | def make_divisors(n: int) -> list:
return_list = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
return_list.append(i)
if i != n // i:
return_list.append(n//i)
return sorted(return_list)
X = int(input())
list = make_divisors(X)
mlist = []
for li in list[::-1]:
mlist.append(-li)
mlist += list
B = -120
while True:
for i in mlist:
if ((B + i) ** 5) - (B ** 5) == X:
print(B+i,B)
exit()
B += 1
| 0 | null | 66,916,624,345,788 | 252 | 156 |
# アライグマはモンスターと戦っています。モンスターの体力はHです。
# アライグマはN種類の必殺技を使うことができ、i番目の必殺技を使うとモンスターの体力を Ai
# 減らすことができます。 必殺技を使う以外の方法でモンスターの体力を減らすことはできません。
# モンスターの体力を0以下にすればアライグマの勝ちです。
# アライグマが同じ必殺技を2度以上使うことなくモンスターに勝つことができるなら Yes を、
# できないなら No を出力してください。
H, N = map(int, input().split())
damege = map(int, input().split())
total_damege = sum(damege)
if H - total_damege <= 0:
print('Yes')
else:
print('No') | HP, N = map(int, input().split())
ATK = list(map(int, input().split()))
print('Yes' if sum(ATK) >= HP else 'No') | 1 | 77,999,992,627,248 | null | 226 | 226 |
# coding: utf-8
import itertools
def main():
n, m, q = map(int, input().split())
matrix = []
for _ in range(q):
row = list(map(int, input().split()))
matrix.append(row)
# print(matrix)
A = list(range(1, m+1))
ans = 0
for tmp_A in itertools.combinations_with_replacement(A, n):
tmp_A = sorted(list(tmp_A))
tmp_ans = 0
for row in matrix:
# print("row", row)
# print("tmp_A", tmp_A)
tmp = tmp_A[row[1] - 1] - tmp_A[row[0]- 1]
if row[2] == tmp:
tmp_ans += row[3]
if tmp_ans >= ans:
ans = tmp_ans
print(ans)
main() | while 1:
n=input()
if len(n)==1:break
for i in range(int(input())):
a=int(input())
n=n[a:]+n[:a]
print(n)
| 0 | null | 14,767,270,225,728 | 160 | 66 |
def main():
n = input()
x = "abcdefghijklmnopqrstuvwxyz"
print(x[x.index(n)+1])
if __name__ == '__main__':
main() | def next_alphabet():
# 入力
C = input()
return chr(ord(C)+1)
result = next_alphabet()
print(result) | 1 | 92,385,849,677,168 | null | 239 | 239 |
n = int(input())
s = set()
for i in range(10):
for j in range(i, 10):
s.add(i*j)
print('Yes' if n in s else 'No') | import sys
K = int(sys.stdin.readline())
S = sys.stdin.readline().rstrip('\n')
# ## COMBINATION (MOD) ###
N_MAX = 10**6 # 問題サイズに合わせて変えておく
MOD = 10**9 + 7
inv = [0] * (N_MAX + 2)
inv[0] = 0 # 逆元テーブル計算用テーブル
inv[1] = 1
for i in range(2, N_MAX + 2):
q, r = divmod(MOD, i)
inv[i] = -inv[r] * q % MOD
# K 文字追加
ans = 0
ln = len(S)
p = pow(26, K, MOD)
for i in range(1, K + 2):
ans += p % MOD
ans %= MOD
# pre
p = p * (ln + i - 1) * inv[i] * 25 * inv[26] % MOD
# suf
# s2 = (s2 * inv[26]) % MOD
print(ans)
| 0 | null | 86,579,827,072,462 | 287 | 124 |
while True:
m, f, r = map(int, raw_input().split())
p = ""
if m == -1 and f == -1 and r == -1:
break
if m == -1 or f == -1:
p = "F"
else:
s = m + f
if s >= 80:
p = "A"
elif s >= 65:
p = "B"
elif s >= 50:
p = "C"
elif s >= 30:
p = "C" if r >= 50 else "D"
else:
p = "F"
print(p) | #coding:utf-8
m = 0
f = 0
r = 0
while m + f + r >-3:
m , f, r =[int(i) for i in input().rstrip().split(" ")]
if m+f+r == -3:
break
if m == -1:
print("F")
elif f == -1:
print("F")
elif m+f <30:
print("F")
elif m+f <50:
if r>=50:
print("C")
else:
print("D")
elif m+f <65:
print("C")
elif m+f <80:
print("B")
else:
print("A") | 1 | 1,237,376,486,698 | null | 57 | 57 |
list = [int(x) for x in input().split()]
list.sort()
print(list[0], list[1], list[2]) | a,b,c=map(int,input().split())
if a>b:
a,b = b,a
if c<a:
a,b,c = c,a,b
if c<b:
a,b,c = a,c,b
print(a,b,c) | 1 | 418,559,035,222 | null | 40 | 40 |
import sys
input = sys.stdin.readline
A = int(input())
B = int(input())
print(list({1,2,3}-{A,B})[0])
| a = int(input())
b =int(input())
set_ = set([1,2,3])
set_.remove(a)
set_.remove(b)
print(set_.pop()) | 1 | 110,412,700,353,202 | null | 254 | 254 |
from itertools import combinations
N=int(input())
d=list(map(int,input().split()))
c=list(combinations(d,2))
ans=0
for i in range(len(c)):
a=c[i][0]*c[i][1]
ans+=a
print(ans)
| import itertools
def resolve():
n = int(input())
d = tuple(map(int,input().split()))
ans = 0
for a in itertools.combinations(d,2):
ans += a[0]*a[1]
print(ans)
resolve() | 1 | 169,024,094,403,192 | null | 292 | 292 |
import sys
input = sys.stdin.readline
import collections
# 持っているビスケットを叩き、1枚増やす
# ビスケット A枚を 1円に交換する
# 1円をビスケット B枚に交換する
def main():
x = int(input())
for a in range(-200, 200):
for b in range(-200, 200):
ans = a ** 5 - b ** 5
if ans == x:
print(a, b)
exit()
def bi(num, a, b, x):
print((a * num) + (b * len(str(b))))
if (a * num) + (b * len(str(b))) <= x:
return False
return True
def input_list():
return list(map(int, input().split()))
def input_list_str():
return list(map(str, input().split()))
if __name__ == "__main__":
main()
| # https://atcoder.jp/contests/abc152/submissions/9693323
import sys
read = sys.stdin.read
N, *A = map(int, read().split())
mod = 10 ** 9 + 7
def min_factor(n):
sieve = list(range(n + 1))
sieve[2::2] = [2] * (n // 2)
for i in range(3, int(n ** 0.5) + 2, 2):
if sieve[i] == i:
sieve[i * i::2 * i] = [i] * ((n - i * i) // (2 * i) + 1)
return sieve
def prime_factorize(n):
a = {}
while n != 1:
b = table[n]
if b in a:
a[b] += 1
else:
a[b] = 1
n //= b
return a
table = min_factor(10**6)
dic = {}
for i in A:
for key, value in prime_factorize(i).items():
if key in dic:
dic[key] = max(dic[key], value)
else:
dic[key] = value
lcm = 1
for i, j in dic.items():
lcm *= pow(i, j, mod)
lcm %= mod
answer = sum(lcm * pow(i, mod - 2, mod) for i in A) % mod
print(answer)
| 0 | null | 56,400,308,598,900 | 156 | 235 |
n = input()
A=[int(j) for j in input().split()]
nums = [0,0,0]
ans = 1
for a in A:
ans = (ans*nums.count(a))%(10**9 +7)
for i in range(len(nums)):
if nums[i] == a:
nums[i] = a+1
break
print(ans) | #!/usr/bin/env pytho3
n = int(input())
a = list(map(int,input().split()))
# ３種類の値をもち、自分より前に同じ色の人がa[i]となる組み合わせ
# コーナーケースとして、全部同じ色なら3通り、あとは*6したらいい
# n<=10**5
# 先頭を色１、次にa[i] == 0になった点を色2,3にしてしていい。前から埋める
# 前から見ていって、それぞれの色の今の人数をcolorとして
# color.count(a[i]) == 2 ならans *= 2, ==3 ans *= 3
# 2ケースのみRE
mod = 10**9 + 7
if a == list(range(n)): print(3)
else:
k = 0
ans = 6
color = [0,0,0]
for person in range(n):
#print(color,person)
bit = 0#すでにcolor == a[i]が出てきているか?
if a[person] == 0:
if k == 3:#REになるケース
print(0)
exit()
color[k] = 1
k += 1
continue
for num in range(3):
if color[num] == a[person]:
bit += 1
if bit == 1:
color[num] += 1
if num == 2:
ans *= bit
ans = ans % mod
print(ans)
| 1 | 130,585,334,175,660 | null | 268 | 268 |
N = int(input())
A1 = list(map(str,input().split()))
A2 = A1[:]
def bubbleSort(A, N):
flag = 0
i = 0
while flag == 0:
flag = 1
for j in range(N-1, i, -1):
if A[j][1] < A[j-1][1]:
A[j], A[j-1] = A[j-1], A[j]
flag = 0
i += 1
return A
def selectSort(A, N):
for i in range(N):
minj = i
for j in range(i, N):
if A[j][1] < A[minj][1]:
minj = j
if A[i][1] != A[minj][1]:
A[i], A[minj] = A[minj], A[i]
return A
def stable(Ab, As, N):
for i in range(N):
if Ab[i] != As[i]:
return False
return True
bubbleSort(A1, N)
selectSort(A2, N)
print(" ".join(map(str, A1)))
print("Stable")
print(" ".join(map(str, A2)))
if stable(A1, A2, N):
print("Stable")
else:
print("Not stable") | n=int(input())
l=list(map(int,input().split()))
f=0
for i in l:
if(i%2==0):
if(i%3!=0 and i%5!=0):
f=1
break
if(f==1):
print("DENIED")
else:
print("APPROVED")
| 0 | null | 34,347,128,555,532 | 16 | 217 |
N = int(input())
A = list(map(int, input().split()))
Q = int(input())
B = []
C = []
for q in range(Q):
b, c = map(int, input().split())
B.append(b)
C.append(c)
sam = sum(A)
baketu = [0]*(100001)
for a in A:
baketu[a] += 1
for q in range(Q):
sam = sam + baketu[B[q]] * (C[q] - B[q])
baketu[C[q]] += baketu[B[q]]
baketu[B[q]] = 0
#print(baketu)
print(sam) | #!/usr/bin/env python3
def next_line():
return input()
def next_int():
return int(input())
def next_int_array_one_line():
return list(map(int, input().split()))
def next_int_array_multi_lines(size):
return [int(input()) for _ in range(size)]
def next_str_array(size):
return [input() for _ in range(size)]
def main():
n = next_int()
ar = next_int_array_one_line()
num = [0] * 100001
for a in ar:
num[a] += 1
q = next_int()
res = 0
for i in range(len(num)):
res += num[i] * i
for i in range(q):
b, c = map(int, input().split())
res += (c-b) * num[b]
num[c] += num[b]
num[b] = 0
print(res)
if __name__ == '__main__':
main()
| 1 | 12,107,913,068,972 | null | 122 | 122 |
a, v = map(int, input().split())
b, w = map(int, input().split())
t = int(input())
if a <= b:
print("YES" if a + v * t >= b + w * t else "NO")
else:
print("YES" if b - w * t >= a - v * t else "NO")
| import sys
sys.setrecursionlimit(300000)
def I(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def MI0(): return map(lambda s: int(s) - 1, sys.stdin.readline().split())
def LMI(): return list(map(int, sys.stdin.readline().split()))
def LMI0(): return list(map(lambda s: int(s) - 1, sys.stdin.readline().split()))
MOD = 10 ** 9 + 7
INF = float('inf')
A, V = MI()
B, W = MI()
T = I()
d = max(0, V - W)
if abs(A - B) - d * T <= 0:
print('YES')
else:
print('NO') | 1 | 15,060,224,578,002 | null | 131 | 131 |
N=int(input())
ans=[0 for _ in range(10001)]
for i in range(1,100):
for j in range(1,100):
for k in range(1,100):
v=i*i+j*j+k*k+i*j+j*k+k*i
if v<10001:
ans[v]+=1
for i in range(N):
print(ans[i+1]) | import collections
a = collections.deque()
for i in range(int(input())):
b = input()
# 命令がinsertだった場合、
if b[0] == 'i':
# キーxを先頭に追加(数字は文字列bの7文字目以降にある)
a.appendleft(b[7:])
# 命令がdeleteだった場合
elif b[6] == ' ':
# 命令のキーが含まれる場合そのキーのデータを消すが、なければ何もしない
try:
a.remove(b[7:])
except:
pass
# 命令がdeleteFirstだった場合
elif len(b) > 10:
a.popleft()
# 命令がdeleteLastだった場合
elif len(b) > 6:
a.pop()
print(*a)
| 0 | null | 4,053,439,709,088 | 106 | 20 |
radius = int(input())
print(44/7*radius) | N,K = map(int,input().split())
S = [tuple(map(int,input().split())) for _ in range(K)]
MOD=998244353
dp=[0]*N
dp[0]=1
for i in range(N-1):
x = dp[i]
dp[0]=0
for k in range(K):
l,r = S[k]
if i+l < N:
dp[i+l]+=x
dp[i+l]%=MOD
if i+r+1 < N:
dp[i+r+1]-=x
dp[i+r+1]%=MOD
dp[i+1]+=dp[i]
dp[i+1]%=MOD
print(dp[-1]%MOD) | 0 | null | 17,038,511,166,300 | 167 | 74 |
import sys
sys.setrecursionlimit(10 ** 9)
class UnionFind():
def __init__(self, n):
self.n = n
self.root = [-1]*(n+1)
self.rank = [0]*(n+1)
def find(self, x):#親となる要素を探索
if self.root[x] < 0:
return x
else:
self.root[x] = self.find(self.root[x])#再帰
return self.root[x]
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
elif self.rank[x] > self.rank[y]:#深い木に連結
self.root[x] += self.root[y]
self.root[y] = x#yの親をxとする
else:
self.root[y] += self.root[x]
self.root[x] = y
if self.rank[x] == self.rank[y]:
self.rank[y] += 1
def issame(self, x, y):#x, yが同じ集合か判定
return self.find(x) == self.find(y)
def count(self, x):#要素の個数
return (-1)*self.root[self.find(x)]
n, m = map(int, input().split())
uf = UnionFind(n)
for i in range(m):
a, b = map(int, input().split())
uf.unite(a-1, b-1)
ans = set()
for i in range(n):
ans.add(uf.find(i))
print(len(ans)-1) | n,m = list(map(int, input().split()))
graph = [set() for _ in range(n)]
for _ in range(m):
a,b = list(map(int, input().split()))
graph[a-1].add(b-1)
graph[b-1].add(a-1)
stack = []
group = [-1] * n
gid = 0
i = 0
for i in range(n):
if group[i] >= 0:
continue
group[i] = gid
stack.append(i)
while stack:
current = stack.pop()
for neighbor in graph[current]:
if group[neighbor] == -1:
group[neighbor] = gid
stack.append(neighbor)
gid += 1
print(gid-1) | 1 | 2,276,855,572,386 | null | 70 | 70 |
import functools
def sign(x):
if x>0:
return 1
elif x==0:
return 0
else:
return -1
def multiply(x,y):
ans = x*y
if ans>=10**9+7 or ans<0:
ans %= (10**9+7)
return ans
N,K = map(int,input().split())
A = list(map(int,input().split()))
A.sort()
if (A[-1]<0 and K%2==1):
combi = A[-K:]
if K >1:
answer = functools.reduce(multiply,combi)
elif K == N:
answer = functools.reduce(multiply,A)
else:
signs = 1
i,j = 0,0
for _ in range(K):
if abs(A[i]) > abs(A[N-j-1]):
signs *= sign(A[i])
i += 1
else:
signs *= sign(A[N-j-1])
j += 1
combi = A[N-j:] + A[:i]
del A[N-j:]
del A[:i]
combi = combi[::-1]
if signs == -1:
if A:
if combi[-1]<0:
del combi[0]
combi.append(A[-1])
elif A[0]>=0:
del combi[0]
combi.append(A[-1])
elif A[0]<0 and A[-1] >0:
if combi[0]*A[0] > combi[-1]*A[-1]:
del combi[-1]
combi.insert(0,A[0])
else:
del combi[0]
combi.append(A[-1])
elif A[-1] <= 0:
del combi[-1]
combi.insert(0,A[0])
answer = functools.reduce(multiply,combi)
print(answer)
| #153-A
H,A = map(int,input().split())
if H % A == 0:
print(H // A)
else:
print( H//A +1)
| 0 | null | 43,326,693,330,860 | 112 | 225 |
n = int(input())
a = list(map(int, input().split()))
ans = 10 ** 16
a_1 = 0
a_2 = sum(a)
for i in range(n - 1):
a_1 += a[i]
a_2 -= a[i]
ans = min(ans, abs(a_1 - a_2))
print(ans) | # coding: UTF-8
CONTEST_NUM = 26
class Optimizer:
def __init__(self, days, s, c):
self._days = days
self._s = s
self._c = c
def optimize(self):
# 貪欲法による手法
t = []
for d in range(self._days):
max_d_value = 0
max_contest = 0
for i in range(CONTEST_NUM):
d_value = self._s[d][i] + self._c[i] * (d + 1)
if d_value > max_d_value:
max_d_value = d_value
max_contest = i
t.append(max_contest + 1)
return t
def main():
## 引数読み込み
days = int(input()) # D
c = tuple(map(int, input().split())) # c[i]
s = [] # s[d][i]
for i in range(days):
s.append(tuple(map(int, input().split())))
## 試しに指標計算
t = Optimizer(days, s, c).optimize()
## print out
for v in t:
print(v)
if __name__ == "__main__":
main()
| 0 | null | 75,862,025,628,440 | 276 | 113 |
import sys
import string
s = sys.stdin.read().lower()
for a in string.ascii_lowercase:
print('{0} : {1}'.format(a, s.count(a))) | MOD = 1000000007
def mod_pow(x , y):
if y == 0:
return 1
if y == 1:
return x
r = mod_pow(x , y // 2)
r2 = (r * r) % MOD
if y % 2 == 0:
return r2 % MOD
else:
return (r2 * x) % MOD
N , K = map(int , input().split())
result = 0
memo = {}
for g in range(K , 0 , -1):
comb = mod_pow(K // g , N)
for j in range(2 , K // g + 1):
comb = (comb - memo[j * g] + MOD) % MOD
memo[g] = comb
result = (result + comb * g) % MOD
print(result)
| 0 | null | 19,098,627,917,810 | 63 | 176 |
import sys
input = sys.stdin.readline
n = int(input())
a = list(map(int, input().split()))
rbg = [-1, -1, -1]
ans = 1
mod = 10 ** 9 + 7
for A in a:
ans *= rbg.count(A - 1)
ans %= mod
for i in range(3):
if rbg[i] == A - 1:
rbg[i] = A
break
print(ans)
| import math
r = float(input())
S = math.pi * r * r
L = 2 * math.pi * r
print("{0:.10f}".format(S),end=" ")
print("{0:.10f}".format(L)) | 0 | null | 65,534,456,045,508 | 268 | 46 |
import sys
p = 0
for line in sys.stdin:
ls = line.strip('\n')
if p == 0:
if ls =='-': break
letters = ls
p = 1
elif p == 1:
m = int(ls)
p =2
elif p == 2:
h = int(ls)
letters = letters[h:] + letters[:h]
if m > 1:
m -= 1
else:
print letters
p = 0 | import itertools
def my_index(l, x):
if x in l:
return l.index(x)
else:
return -1
if __name__ == "__main__":
N = int(input())
S = [int(c) for c in input()]
table = list(range(10))
count = 0
for p in itertools.product(table, repeat=3): # 重複を許して1~9の数値を３つならべる
target = list(p)
s1_index = my_index(S, target[0])
if s1_index == -1:
continue
s1 = S[s1_index+1:]
s2_index = my_index(s1, target[1])
if s2_index == -1:
continue
s2 = s1[s2_index+1:]
s3_index = my_index(s2, target[2])
if s3_index == -1:
continue
count += 1
print(count)
| 0 | null | 65,287,875,664,400 | 66 | 267 |
s = input()*2
print('Yes' if input() in s else 'No') | N=input()
N=N+N
S=input()
if S in N:
print("Yes")
else:
print("No")
| 1 | 1,744,357,090,880 | null | 64 | 64 |
tp = hp = 0
for i in range(int(input())):
taro, hana = map(list, input().split())
short = min(len(taro), len(hana))
result = 0
for k in range(short):
if ord(taro[k]) != ord(hana[k]):
result = ord(taro[k]) - ord(hana[k])
break
if not result:
if len(taro) < len(hana):
result = -1
elif len(taro) > len(hana):
result = 1
if result > 0:
tp += 3
elif result < 0:
hp += 3
else:
tp += 1
hp += 1
print(tp, hp)
| # D - Maze Master
# https://atcoder.jp/contests/abc151/tasks/abc151_d
from collections import deque
def main():
height, width = [int(num) for num in input().split()]
maze = [input() for _ in range(height)]
ans = 0
next_to = ((0, 1), (1, 0), (0, -1), (-1, 0))
for start_x in range(height):
for start_y in range(width):
if maze[start_x][start_y] == '#':
continue
queue = deque()
queue.append((start_x, start_y))
reached = [[-1] * width for _ in range(height)]
reached[start_x][start_y] = 0
while queue:
now_x, now_y = queue.popleft()
for move_x, move_y in next_to:
adj_x, adj_y = now_x + move_x, now_y + move_y
# Python は index = -1 が通ってしまうことに注意。
# except IndexError では回避できない。
if (not 0 <= adj_x < height
or not 0 <= adj_y < width
or maze[adj_x][adj_y] == '#'
or reached[adj_x][adj_y] != -1):
continue
queue.append((adj_x, adj_y))
reached[adj_x][adj_y] = reached[now_x][now_y] + 1
most_distant = max(max(row) for row in reached)
ans = max(most_distant, ans)
print(ans)
if __name__ == '__main__':
main()
| 0 | null | 48,401,739,332,832 | 67 | 241 |
mark = ["S","H","C","D"]
numbers = ["1","2","3","4","5","6","7","8","9","10","11","12","13"]
cardlist = {}
for m in mark:
for n in numbers:
key = m + " " + n
cardlist[key] = 0
n = int(input())
for _ in range(n):
card = input()
cardlist[card] = 1
for card in cardlist:
if cardlist[card] == 0:
print(card)
| from sys import stdin
import sys
import math
from functools import reduce
import functools
import itertools
from collections import deque
n = int(stdin.readline().rstrip())
s = stdin.readline().rstrip()
num_r = s.count('R')
num_g = s.count('G')
num_b = s.count('B')
num_ng = 0
for i in range(n):
for j in range(i+1,n):
k = j+(j-i)
if k < n and s[i] != s[j] and s[j] != s[k] and s[k] != s[i]:
num_ng += 1
print(num_r*num_g*num_b-num_ng) | 0 | null | 18,636,593,146,950 | 54 | 175 |
from collections import Counter
n,p = map(int,input().split())
s = input()
n = len(s)
mod = [0] * (n+1)
ten = [0] * n
a = 1
for i in range(n):
ten[i] = a
a = a * 10 % p
ans = 0
if p != 2 and p != 5:
rui = 0
for i in range(n):
rui = (int(s[n-1-i]) * ten[i] + rui) % p
mod[n-1-i] = rui
b = Counter(mod)
c = list(b.values())
c.sort(reverse = True)
for i in c:
if i > 1:
ans += i * (i-1) // 2
else:
break
elif p == 2:
for i in range(n):
if int(s[i]) % 2 == 0:
ans += i+1
else:
for i in range(n):
if int(s[i]) % 5 == 0:
ans += i+1
print(ans) | from sys import stdin
from collections import defaultdict, Counter
N, P = map(int, stdin.readline().split())
S, = stdin.readline().split()
ans = 0
# 2 cases
if P == 2 or P == 5:
digitdiv = []
for i in range(N):
if int(S[i]) % P == 0:
ans += i + 1
else:
#
count = Counter()
prefix = []
ten = 1
mod = 0
for i in range(N):
x = (int(S[N - i - 1])*ten + mod) % P
prefix.append(x)
count[x] += 1
ten = (ten * 10) % P
mod = x
prefix.append(0)
count[0] += 1
for val in count.values():
ans += val*(val - 1)//2
print (ans)
| 1 | 58,144,304,832,084 | null | 205 | 205 |
str = input()
if str < 'a':
print('A')
else:
print('a') | alpha = input()
text = 'abcdefghijklmnopqrstuvwxyz'
if alpha in text:
print('a')
else:
print('A') | 1 | 11,215,944,972,836 | null | 119 | 119 |
N = int(input())
S = [input() for _ in range(N)]
S.sort()
res = 0
cnt = 1
for i in range(N-1):
if S[i] == S[i+1]:
cnt+=1
else:
res = max(res,cnt)
cnt = 1
res = max(res,cnt)
cnt = 1
ans = []
for i in range(N-1):
if S[i] == S[i+1]:
cnt+=1
else:
if res == cnt:
ans.append(S[i])
cnt = 1
if cnt == res:
ans.append(S[i+1])
for i in range(len(ans)):
print(ans[i])
| import math
import statistics
import collections
a=int(input())
#b,c=int(input()),int(input())
# c=[]
# for i in b:
# c.append(i)
#e1,e2 = map(int,input().split())
# f = list(map(int,input().split()))
g = [input() for _ in range(a)]
# h = []
# for i in range(e1):
# h.append(list(map(int,input().split())))
g.sort()
ma=0
count=1
#最大値求める
for i in range(a-1):
if g[i]==g[i+1]:
count+=1
else:
ma=max(ma,count)
count=1
ma=max(ma,count)
count=1
ans=[]
#最大値の位置
for i in range(a-1):
if g[i]==g[i+1]:
count+=1
else:
if count==ma:
ans.append(g[i])
count=1
if count==ma:
ans.append(g[-1])
for i in ans:
print(i)
| 1 | 70,320,454,659,272 | null | 218 | 218 |
from collections import deque
n, u, v = map(int, input().split())
u-=1; v-=1;
a = []; b = [];
dist = [[] for i in range(n)]
for i in range(n-1):
a, b = map(int, input().split())
a -= 1; b -= 1
dist[a].append(b)
dist[b].append(a)
def bfs(u):
d = [-1]*n
stack = deque([u])
d[u] = 0
while len(stack)!=0:
s = stack.popleft()
for t in dist[s]:
if d[t]==-1:
d[t] = d[s]+1
stack.append(t)
return d
A = bfs(v)
T = bfs(u)
ans=0
for i in range(n):
if A[i]>T[i]:
ans = max(A[i]-1, ans)
print(ans) | from collections import deque
def read():
N, u, v = list(map(int, input().strip().split()))
G = [list() for i in range(N+1)]
for i in range(N-1):
a, b = list(map(int, input().strip().split()))
G[a].append(b)
G[b].append(a)
return N, u, v, G
def bfs(N, G, start):
depth = [-1 for i in range(N+1)]
depth[start] = 0
q = deque()
q.append(start)
while(len(q) > 0):
s = q.popleft()
for t in G[s]:
if depth[t] == -1:
depth[t] = depth[s] + 1
q.append(t)
return depth
def solve(N, u, v, G):
depth_u = bfs(N, G, u)
depth_v = bfs(N, G, v)
most_deepest_node = u
for i in range(1, N+1):
if depth_u[i] < depth_v[i]:
if depth_v[i] > depth_v[most_deepest_node]:
most_deepest_node = i
neighbor_node = G[most_deepest_node][0]
step_u = depth_u[neighbor_node]
step_v = depth_v[neighbor_node]
return step_v
if __name__ == '__main__':
inputs = read()
print('%d' % solve(*inputs))
| 1 | 117,319,801,426,340 | null | 259 | 259 |
from itertools import combinations
n,m,x = map(int, input().split())
ca = [list(map(int, input().split())) for _ in range(n)]
ans = float("inf")
for i in range(1, n+1):
for i1 in combinations(ca, i):
nums = [0]*(m+1)
for i2 in i1:
for i3 in range(m+1): nums[i3] += i2[i3]
if min(nums[1:]) >= x:
if nums[0] < ans: ans = nums[0]
if ans == float("inf"): print(-1)
else: print(ans) | N, M, X = [int(i) for i in input().split()]
CA = []
for i in range(N):
CA.append([int(j) for j in input().split()])
#print(CA)
mcost = 10**10
for i in range(2**N):
learn = [0]*M
cost = 0
bn = str(bin(i))[2:].zfill(N)
#print(bn)
for j,b in enumerate(bn):
if b == "1":
cost += CA[j][0]
for m in range(M):
learn[m] += CA[j][m+1]
learn.sort()
#print(learn)
if learn[0] >= X:
mcost = min(mcost, cost)
if mcost == 10**10:
mcost = -1
print(mcost) | 1 | 22,228,799,904,172 | null | 149 | 149 |
#coding:utf-8
from copy import deepcopy
n = int(input())
c = ["white" for i in range(n)]
d = [0 for i in range(n)]
f = [0 for i in range(n)]
S = []
class DFS:
def __init__(self, key, color="white",nex=None):
self.color = color
self.nex = nex
self.key = key
objListCopy = [DFS(i+1) for i in range(n)]
for i in range(n):
data = list(map(int,input().split()))
times = data[1]
obj = objListCopy[i]
for j in range(times):
index = data[2+j] - 1
nextobj = DFS(index+1)
obj.nex = nextobj
obj = obj.nex
time = 1
objList = objListCopy[:]
def check(first,time):
obj = objList[first]
c[first] = "gray"
d[first] = time
f[first] = time
S.append(first+1)
while S != []:
index = S[-1] - 1
u = objList[index]
v = u.nex
time += 1
if v != None:
if c[v.key - 1] == "white":
objList[index] = v
index = v.key - 1
v = objList[index]
c[v.key-1] = "gray"
d[index] = time
S.append(v.key)
else:
objList[index] = v
time -= 1
else:
S.pop()
c[u.key-1] = "black"
f[index] = time
return time
for i in range(n):
if f[i] == 0:
objList = deepcopy(objListCopy)
time = check(i,time) + 1
k = 1
for i,j in zip(d,f):
print(k,i,j)
k += 1
| # 隣接リスト
n = int(input())
graph = []
for _ in range(n):
tmp = list(map(int, input().split()))
if tmp[1] == 0:
graph.append([])
else:
graph.append(tmp[2:])
#print(graph)
check = [0]*n
count = 0
go = [0]*n
back = [0]*n
def dfs(v):
#print(v)
global count
if check[v] == 0:
check[v] = 1
count += 1
go[v] = count
tolist = graph[v]
if len(tolist) > 0:
for i in tolist:
dfs(i-1)
count += 1
back[v] = count
while True:
if 0 in check:
k = check.index(0)
dfs(k)
else:
break
#print("check\t:{}".format(check))
#print("go\t:{}".format(go))
#print("back\t:{}".format(back))
for i in range(n):
print("{} {} {}".format(i+1, go[i], back[i]))
| 1 | 2,651,731,210 | null | 8 | 8 |
n,m,l=map(int, input().split())
a=[]
b=[]
for i in range(n):
a.append(list(map(int, input().split())))
for j in range(m):
b.append(list(map(int, input().split())))
for i in range(n):
ci=[0]*l
for k in range(l):
for j in range(m):
ci[k]+=a[i][j]*b[j][k]
print(*ci)
| n, a, b = map(int, input().split())
if (a+b) % 2 == 0:
print((b-a)//2)
else:
if b == a + 1:
print(min(b-1, n-a))
else:
cnt_1 = a + (b-a-1)//2
cnt_n = n - b + 1 + (b-a-1)//2
print(min(cnt_1, cnt_n))
| 0 | null | 55,625,029,867,748 | 60 | 253 |
res_list = [[[0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]],
[[0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]],
[[0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]],
[[0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]]
n = int(input())
for i in range(n):
io_rec = list(map(int, input().split(" ")))
bld_num = io_rec[0] - 1
floor_num = io_rec[1] - 1
room_num = io_rec[2] - 1
io_headcnt = io_rec[3]
res_list[bld_num][floor_num][room_num] += io_headcnt
for i in range(4):
if i:
print("#" * 20)
bld = res_list[i]
for j in bld:
floor_str = map(str, j)
print(" " + " ".join(floor_str)) | x=int(input())
li=list(map(int, input().split()))
res=0
i=0
while i<x:
if li[i]%2!=0:
res+=1
i+=2
print(res) | 0 | null | 4,464,361,243,408 | 55 | 105 |
from itertools import accumulate
n,k = map(int, input().split())
As = list(map(int, input().split()))
for i in range(k):
imos = [0] * (n+1)
for i,a in enumerate(As):
l = max(0, i-a)
r = min(n, i+a+1)
imos[l] += 1
imos[r] -= 1
acc = list(accumulate(imos))
# 指数関数的に増える
if acc[:-1] == As:
print(*As)
exit()
As = acc[:-1]
print(*As) | a,b,k=map(int,input().split())
if a>=k:
print(str(a-k)+' '+str(b))
elif a<k and b-(k-a)>=0:
print('0 '+str(b-(k-a)))
else:
print('0 0') | 0 | null | 59,569,459,955,790 | 132 | 249 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.