user_id
stringlengths 10
10
| problem_id
stringlengths 6
6
| language
stringclasses 1
value | submission_id_v0
stringlengths 10
10
| submission_id_v1
stringlengths 10
10
| cpu_time_v0
int64 10
38.3k
| cpu_time_v1
int64 0
24.7k
| memory_v0
int64 2.57k
1.02M
| memory_v1
int64 2.57k
869k
| status_v0
stringclasses 1
value | status_v1
stringclasses 1
value | improvement_frac
float64 7.51
100
| input
stringlengths 20
4.55k
| target
stringlengths 17
3.34k
| code_v0_loc
int64 1
148
| code_v1_loc
int64 1
184
| code_v0_num_chars
int64 13
4.55k
| code_v1_num_chars
int64 14
3.34k
| code_v0_no_empty_lines
stringlengths 21
6.88k
| code_v1_no_empty_lines
stringlengths 20
4.93k
| code_same
bool 1
class | relative_loc_diff_percent
float64 0
79.8
| diff
sequence | diff_only_import_comment
bool 1
class | measured_runtime_v0
float64 0.01
4.45
| measured_runtime_v1
float64 0.01
4.31
| runtime_lift
float64 0
359
| key
sequence |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
u903005414 | p03862 | python | s465516278 | s499732766 | 154 | 127 | 14,052 | 14,060 | Accepted | Accepted | 17.53 | N, x = list(map(int, input().split()))
A = list(map(int, input().split()))
# if len(A) % 2 == 0:
# A = A + [0]
# print('A', A)
ans = 0
for i in range(1, N):
total = A[i - 1] + A[i]
diff = total - x
if diff <= 0:
continue
v1 = min(A[i], diff)
v2 = diff - v1
A[i] -= v1
A[i - 1] -= v2
ans += v1 + v2
# print('A', A)
print(ans)
| N, x = list(map(int, input().split()))
A = list(map(int, input().split()))
sum_A = sum(A)
for i in range(1, N):
diff = A[i - 1] + A[i] - x
if diff <= 0:
continue
v1 = min(A[i], diff)
v2 = diff - v1
A[i] -= v1
A[i - 1] -= v2
# print('A', A)
ans = sum_A - sum(A)
print(ans)
| 20 | 15 | 388 | 317 | N, x = list(map(int, input().split()))
A = list(map(int, input().split()))
# if len(A) % 2 == 0:
# A = A + [0]
# print('A', A)
ans = 0
for i in range(1, N):
total = A[i - 1] + A[i]
diff = total - x
if diff <= 0:
continue
v1 = min(A[i], diff)
v2 = diff - v1
A[i] -= v1
A[i - 1] -= v2
ans += v1 + v2
# print('A', A)
print(ans)
| N, x = list(map(int, input().split()))
A = list(map(int, input().split()))
sum_A = sum(A)
for i in range(1, N):
diff = A[i - 1] + A[i] - x
if diff <= 0:
continue
v1 = min(A[i], diff)
v2 = diff - v1
A[i] -= v1
A[i - 1] -= v2
# print('A', A)
ans = sum_A - sum(A)
print(ans)
| false | 25 | [
"-# if len(A) % 2 == 0:",
"-# A = A + [0]",
"-# print('A', A)",
"-ans = 0",
"+sum_A = sum(A)",
"- total = A[i - 1] + A[i]",
"- diff = total - x",
"+ diff = A[i - 1] + A[i] - x",
"- ans += v1 + v2",
"+ans = sum_A - sum(A)"
] | false | 0.034864 | 0.03586 | 0.972231 | [
"s465516278",
"s499732766"
] |
u252828980 | p02898 | python | s071937398 | s006015450 | 52 | 43 | 11,908 | 11,912 | Accepted | Accepted | 17.31 | x, y = list(map(int,input().split()))
li = list(map(int, input().split()))
num = 0
for i in range(len(li)):
if li[i] >= y:
num += 1
print(num) | n,h = list(map(int,input().split()))
L = list(map(int,input().split()))
L = [x for x in L if x >=h]
print((len(L))) | 8 | 4 | 156 | 110 | x, y = list(map(int, input().split()))
li = list(map(int, input().split()))
num = 0
for i in range(len(li)):
if li[i] >= y:
num += 1
print(num)
| n, h = list(map(int, input().split()))
L = list(map(int, input().split()))
L = [x for x in L if x >= h]
print((len(L)))
| false | 50 | [
"-x, y = list(map(int, input().split()))",
"-li = list(map(int, input().split()))",
"-num = 0",
"-for i in range(len(li)):",
"- if li[i] >= y:",
"- num += 1",
"-print(num)",
"+n, h = list(map(int, input().split()))",
"+L = list(map(int, input().split()))",
"+L = [x for x in L if x >= h]",
"+print((len(L)))"
] | false | 0.04141 | 0.078644 | 0.526553 | [
"s071937398",
"s006015450"
] |
u454524105 | p02780 | python | s139166855 | s685313649 | 211 | 140 | 23,652 | 32,008 | Accepted | Accepted | 33.65 | n, k = (int(x) for x in input().split())
p = [int(x) / 2 + 0.5 for x in input().split()]
ans_i = ans = sum(p[:k])
i = 0
while i < n - k:
ans_i = ans_i - p[i] + p[i+k]
ans = max(ans, ans_i)
i += 1
print(ans)
| n, k = list(map(int, input().split()))
p = list(map(int, input().split()))
e = lambda x: 0.5*(x+1)
if k == 1:
res = e(max(p))
else:
s = [0]
s[0] = sum(p[:k])
for i in range(1, n-k+1):
s.append(s[i-1] - p[i-1] + p[i+k-1])
idx = s.index(max(s))
res = sum([e(p[i]) for i in range(idx, idx+k)])
print(res) | 9 | 13 | 227 | 339 | n, k = (int(x) for x in input().split())
p = [int(x) / 2 + 0.5 for x in input().split()]
ans_i = ans = sum(p[:k])
i = 0
while i < n - k:
ans_i = ans_i - p[i] + p[i + k]
ans = max(ans, ans_i)
i += 1
print(ans)
| n, k = list(map(int, input().split()))
p = list(map(int, input().split()))
e = lambda x: 0.5 * (x + 1)
if k == 1:
res = e(max(p))
else:
s = [0]
s[0] = sum(p[:k])
for i in range(1, n - k + 1):
s.append(s[i - 1] - p[i - 1] + p[i + k - 1])
idx = s.index(max(s))
res = sum([e(p[i]) for i in range(idx, idx + k)])
print(res)
| false | 30.769231 | [
"-n, k = (int(x) for x in input().split())",
"-p = [int(x) / 2 + 0.5 for x in input().split()]",
"-ans_i = ans = sum(p[:k])",
"-i = 0",
"-while i < n - k:",
"- ans_i = ans_i - p[i] + p[i + k]",
"- ans = max(ans, ans_i)",
"- i += 1",
"-print(ans)",
"+n, k = list(map(int, input().split()))",
"+p = list(map(int, input().split()))",
"+e = lambda x: 0.5 * (x + 1)",
"+if k == 1:",
"+ res = e(max(p))",
"+else:",
"+ s = [0]",
"+ s[0] = sum(p[:k])",
"+ for i in range(1, n - k + 1):",
"+ s.append(s[i - 1] - p[i - 1] + p[i + k - 1])",
"+ idx = s.index(max(s))",
"+ res = sum([e(p[i]) for i in range(idx, idx + k)])",
"+print(res)"
] | false | 0.036298 | 0.032349 | 1.12208 | [
"s139166855",
"s685313649"
] |
u477977638 | p03031 | python | s078255662 | s707603438 | 129 | 39 | 3,188 | 3,064 | Accepted | Accepted | 69.77 | n,m=list(map(int,input().split()))
info=[list(map(int,input().split())) for i in range(m)]
p=list(map(int,input().split()))
ans=0
for i in range(2**n):
tmp=0
f=1
for mm in range(m):
tmp=0
for j in info[mm][1:]:
tmp+=int(str(format(i,'b').zfill(n))[int(j)-1])
if tmp%2!=p[mm]:
f=0
if f==1:
ans+=1
print(ans)
| import sys
input = sys.stdin.readline
input = sys.stdin.buffer.readline
def II(): return int(eval(input()))
def MI(): return list(map(int,input().split()))
def LI(): return list(map(int,input().split()))
def TI(): return tuple(map(int,input().split()))
# mod=10**9+7
# rstrip().decode('utf-8')
def main():
n,m=MI()
ks=[LI() for _ in range(m)]
s=[i[1:] for i in ks]
p=LI()
ans=0
for i in range(1<<n):
li=[0]*m
for j in range(n):
for k in range(m):
if 1&i>>j:
if j+1 in s[k]:
li[k]=1-li[k]
if p==li:
ans+=1
print(ans)
if __name__ == "__main__":
main()
| 19 | 43 | 358 | 631 | n, m = list(map(int, input().split()))
info = [list(map(int, input().split())) for i in range(m)]
p = list(map(int, input().split()))
ans = 0
for i in range(2**n):
tmp = 0
f = 1
for mm in range(m):
tmp = 0
for j in info[mm][1:]:
tmp += int(str(format(i, "b").zfill(n))[int(j) - 1])
if tmp % 2 != p[mm]:
f = 0
if f == 1:
ans += 1
print(ans)
| import sys
input = sys.stdin.readline
input = sys.stdin.buffer.readline
def II():
return int(eval(input()))
def MI():
return list(map(int, input().split()))
def LI():
return list(map(int, input().split()))
def TI():
return tuple(map(int, input().split()))
# mod=10**9+7
# rstrip().decode('utf-8')
def main():
n, m = MI()
ks = [LI() for _ in range(m)]
s = [i[1:] for i in ks]
p = LI()
ans = 0
for i in range(1 << n):
li = [0] * m
for j in range(n):
for k in range(m):
if 1 & i >> j:
if j + 1 in s[k]:
li[k] = 1 - li[k]
if p == li:
ans += 1
print(ans)
if __name__ == "__main__":
main()
| false | 55.813953 | [
"-n, m = list(map(int, input().split()))",
"-info = [list(map(int, input().split())) for i in range(m)]",
"-p = list(map(int, input().split()))",
"-ans = 0",
"-for i in range(2**n):",
"- tmp = 0",
"- f = 1",
"- for mm in range(m):",
"- tmp = 0",
"- for j in info[mm][1:]:",
"- tmp += int(str(format(i, \"b\").zfill(n))[int(j) - 1])",
"- if tmp % 2 != p[mm]:",
"- f = 0",
"- if f == 1:",
"- ans += 1",
"-print(ans)",
"+import sys",
"+",
"+input = sys.stdin.readline",
"+input = sys.stdin.buffer.readline",
"+",
"+",
"+def II():",
"+ return int(eval(input()))",
"+",
"+",
"+def MI():",
"+ return list(map(int, input().split()))",
"+",
"+",
"+def LI():",
"+ return list(map(int, input().split()))",
"+",
"+",
"+def TI():",
"+ return tuple(map(int, input().split()))",
"+",
"+",
"+# mod=10**9+7",
"+# rstrip().decode('utf-8')",
"+def main():",
"+ n, m = MI()",
"+ ks = [LI() for _ in range(m)]",
"+ s = [i[1:] for i in ks]",
"+ p = LI()",
"+ ans = 0",
"+ for i in range(1 << n):",
"+ li = [0] * m",
"+ for j in range(n):",
"+ for k in range(m):",
"+ if 1 & i >> j:",
"+ if j + 1 in s[k]:",
"+ li[k] = 1 - li[k]",
"+ if p == li:",
"+ ans += 1",
"+ print(ans)",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ main()"
] | false | 0.124254 | 0.062936 | 1.974281 | [
"s078255662",
"s707603438"
] |
u761529120 | p02990 | python | s499431607 | s669489890 | 627 | 330 | 69,976 | 45,788 | Accepted | Accepted | 47.37 | import math
def comb(n, k):
return math.factorial(n) // math.factorial(k) // math.factorial(n - k)
def main():
MOD = 10 ** 9 + 7
N, K = list(map(int, input().split()))
for i in range(1,K+1):
if i > N - K + 1:
print((0))
continue
blue = comb(N-K+1,i) % MOD
red = comb(K-1,i-1) % MOD
ans = blue * red % MOD
print(ans)
main() | from operator import mul
from functools import reduce
def cmb(n,r):
r = min(n-r,r)
if r == 0: return 1
over = reduce(mul, list(range(n, n - r, -1)))
under = reduce(mul, list(range(1,r + 1)))
return over // under
def main():
N, K = list(map(int, input().split()))
MOD = 10 ** 9 + 7
for i in range(1,K+1):
if N - K + 1 < i:
print((0))
continue
blue = cmb(K-1,i-1)
red = cmb(N-K+1,N-K-i+1)
ans = blue * red
ans %= MOD
print(ans)
if __name__ == "__main__":
main() | 21 | 27 | 432 | 586 | import math
def comb(n, k):
return math.factorial(n) // math.factorial(k) // math.factorial(n - k)
def main():
MOD = 10**9 + 7
N, K = list(map(int, input().split()))
for i in range(1, K + 1):
if i > N - K + 1:
print((0))
continue
blue = comb(N - K + 1, i) % MOD
red = comb(K - 1, i - 1) % MOD
ans = blue * red % MOD
print(ans)
main()
| from operator import mul
from functools import reduce
def cmb(n, r):
r = min(n - r, r)
if r == 0:
return 1
over = reduce(mul, list(range(n, n - r, -1)))
under = reduce(mul, list(range(1, r + 1)))
return over // under
def main():
N, K = list(map(int, input().split()))
MOD = 10**9 + 7
for i in range(1, K + 1):
if N - K + 1 < i:
print((0))
continue
blue = cmb(K - 1, i - 1)
red = cmb(N - K + 1, N - K - i + 1)
ans = blue * red
ans %= MOD
print(ans)
if __name__ == "__main__":
main()
| false | 22.222222 | [
"-import math",
"+from operator import mul",
"+from functools import reduce",
"-def comb(n, k):",
"- return math.factorial(n) // math.factorial(k) // math.factorial(n - k)",
"+def cmb(n, r):",
"+ r = min(n - r, r)",
"+ if r == 0:",
"+ return 1",
"+ over = reduce(mul, list(range(n, n - r, -1)))",
"+ under = reduce(mul, list(range(1, r + 1)))",
"+ return over // under",
"+ N, K = list(map(int, input().split()))",
"- N, K = list(map(int, input().split()))",
"- if i > N - K + 1:",
"+ if N - K + 1 < i:",
"- blue = comb(N - K + 1, i) % MOD",
"- red = comb(K - 1, i - 1) % MOD",
"- ans = blue * red % MOD",
"+ blue = cmb(K - 1, i - 1)",
"+ red = cmb(N - K + 1, N - K - i + 1)",
"+ ans = blue * red",
"+ ans %= MOD",
"-main()",
"+if __name__ == \"__main__\":",
"+ main()"
] | false | 0.137927 | 0.03676 | 3.752151 | [
"s499431607",
"s669489890"
] |
u312025627 | p02881 | python | s538490325 | s931663214 | 240 | 179 | 39,664 | 39,152 | Accepted | Accepted | 25.42 | def main():
N = int(eval(input()))
def trial_division(n):
divs = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divs.append(i)
if i != n//i:
divs.append(n//i)
return divs
divs = trial_division(N)
d = len(divs)
ans = float('inf')
for i in range(d):
for j in range(i, d):
if divs[i] * divs[j] == N:
ans = min(ans, divs[i] - 1 + divs[j] - 1)
print(ans)
if __name__ == '__main__':
main()
| def main():
N = int(eval(input()))
def trial_division(n):
divs = []
for i in range(1, int(n**0.5)+1):
if n % i == 0 and i != n//i:
divs.append((i, n//i))
elif n % i == 0 and i == n//i:
divs.append((i, i))
return divs
divs = trial_division(N)
ans = 10**13
for d1, d2 in divs:
ans = min(ans, d1 + d2 - 2)
print(ans)
if __name__ == '__main__':
main()
| 24 | 20 | 566 | 480 | def main():
N = int(eval(input()))
def trial_division(n):
divs = []
for i in range(1, int(n**0.5) + 1):
if n % i == 0:
divs.append(i)
if i != n // i:
divs.append(n // i)
return divs
divs = trial_division(N)
d = len(divs)
ans = float("inf")
for i in range(d):
for j in range(i, d):
if divs[i] * divs[j] == N:
ans = min(ans, divs[i] - 1 + divs[j] - 1)
print(ans)
if __name__ == "__main__":
main()
| def main():
N = int(eval(input()))
def trial_division(n):
divs = []
for i in range(1, int(n**0.5) + 1):
if n % i == 0 and i != n // i:
divs.append((i, n // i))
elif n % i == 0 and i == n // i:
divs.append((i, i))
return divs
divs = trial_division(N)
ans = 10**13
for d1, d2 in divs:
ans = min(ans, d1 + d2 - 2)
print(ans)
if __name__ == "__main__":
main()
| false | 16.666667 | [
"- if n % i == 0:",
"- divs.append(i)",
"- if i != n // i:",
"- divs.append(n // i)",
"+ if n % i == 0 and i != n // i:",
"+ divs.append((i, n // i))",
"+ elif n % i == 0 and i == n // i:",
"+ divs.append((i, i))",
"- d = len(divs)",
"- ans = float(\"inf\")",
"- for i in range(d):",
"- for j in range(i, d):",
"- if divs[i] * divs[j] == N:",
"- ans = min(ans, divs[i] - 1 + divs[j] - 1)",
"+ ans = 10**13",
"+ for d1, d2 in divs:",
"+ ans = min(ans, d1 + d2 - 2)"
] | false | 0.039657 | 0.041661 | 0.951898 | [
"s538490325",
"s931663214"
] |
u888721916 | p02952 | python | s092926747 | s698607450 | 170 | 58 | 38,256 | 3,064 | Accepted | Accepted | 65.88 | N = int(eval(input()))
keta = len(str(N))
if keta%2 == 0:
N = 10**(keta-1)-1
total = N
keta = len(str(N))
if keta == 3:
total -= 90
elif keta == 5:
total -= 100000-90910
print(total) | N = int(eval(input()))
total = 0
for i in range(1,N+1):
keta = len(str(i))
if keta%2 != 0:
total += 1
print(total)
| 13 | 8 | 202 | 145 | N = int(eval(input()))
keta = len(str(N))
if keta % 2 == 0:
N = 10 ** (keta - 1) - 1
total = N
keta = len(str(N))
if keta == 3:
total -= 90
elif keta == 5:
total -= 100000 - 90910
print(total)
| N = int(eval(input()))
total = 0
for i in range(1, N + 1):
keta = len(str(i))
if keta % 2 != 0:
total += 1
print(total)
| false | 38.461538 | [
"-keta = len(str(N))",
"-if keta % 2 == 0:",
"- N = 10 ** (keta - 1) - 1",
"-total = N",
"-keta = len(str(N))",
"-if keta == 3:",
"- total -= 90",
"-elif keta == 5:",
"- total -= 100000 - 90910",
"+total = 0",
"+for i in range(1, N + 1):",
"+ keta = len(str(i))",
"+ if keta % 2 != 0:",
"+ total += 1"
] | false | 0.036314 | 0.063915 | 0.568171 | [
"s092926747",
"s698607450"
] |
u102461423 | p04049 | python | s576764163 | s320802157 | 1,404 | 1,030 | 3,572 | 3,948 | Accepted | Accepted | 26.64 | import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
N,K = list(map(int,input().split()))
AB = [[int(x) for x in input().split()] for _ in range(N-1)]
graph = [[] for _ in range(N+1)]
for a,b in AB:
graph[a].append(b)
graph[b].append(a)
def count_nbd(x,R,parent):
# parentを含まない部分木
# xを含む、xから半径R内の点の個数を数える
count = 0
visited = [False] * (N+1)
visited[x] = True
visited[parent] = True
count += 1
q = [x]
for _ in range(R):
qq = []
for y in q:
for z in graph[y]:
if visited[z]:
continue
visited[z] = True
qq.append(z)
count += 1
q = qq
return count
if K&1:
# 辺の中点に中心がある場合
R = (K-1)//2
x = max(count_nbd(x,R,y) + count_nbd(y,R,x) for x,y in AB)
else:
# 頂点が中心
R = K//2
x = max(count_nbd(x,R,0) for x in range(1,N+1))
answer = N-x
print(answer) | import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
from collections import deque
N,K = list(map(int,readline().split()))
m = list(map(int,read().split()))
AB = list(zip(m,m))
graph = [[] for _ in range(N+1)]
for a,b in AB:
graph[a].append(b)
graph[b].append(a)
def F(a,b,K):
INF = 10 ** 9
if a == b:
# 中心が1点
q = deque([a])
r = K // 2
else:
# 中心が辺
q = deque([a,b])
r = (K-1)//2
dist = [INF] * (N+1)
for x in q:
dist[x] = 0
pop = q.popleft; append = q.append
cnt = len(q)
while q:
v = pop()
dw = dist[v] + 1
if dw > r:
break
for w in graph[v]:
if dist[w] == INF:
cnt += 1
dist[w] = dw
append(w)
return N - cnt
if K & 1:
answer = min(F(a,b,K) for a,b in AB)
else:
answer = min(F(a,a,K) for a in range(1,N+1))
print(answer) | 44 | 48 | 987 | 1,036 | import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
N, K = list(map(int, input().split()))
AB = [[int(x) for x in input().split()] for _ in range(N - 1)]
graph = [[] for _ in range(N + 1)]
for a, b in AB:
graph[a].append(b)
graph[b].append(a)
def count_nbd(x, R, parent):
# parentを含まない部分木
# xを含む、xから半径R内の点の個数を数える
count = 0
visited = [False] * (N + 1)
visited[x] = True
visited[parent] = True
count += 1
q = [x]
for _ in range(R):
qq = []
for y in q:
for z in graph[y]:
if visited[z]:
continue
visited[z] = True
qq.append(z)
count += 1
q = qq
return count
if K & 1:
# 辺の中点に中心がある場合
R = (K - 1) // 2
x = max(count_nbd(x, R, y) + count_nbd(y, R, x) for x, y in AB)
else:
# 頂点が中心
R = K // 2
x = max(count_nbd(x, R, 0) for x in range(1, N + 1))
answer = N - x
print(answer)
| import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
from collections import deque
N, K = list(map(int, readline().split()))
m = list(map(int, read().split()))
AB = list(zip(m, m))
graph = [[] for _ in range(N + 1)]
for a, b in AB:
graph[a].append(b)
graph[b].append(a)
def F(a, b, K):
INF = 10**9
if a == b:
# 中心が1点
q = deque([a])
r = K // 2
else:
# 中心が辺
q = deque([a, b])
r = (K - 1) // 2
dist = [INF] * (N + 1)
for x in q:
dist[x] = 0
pop = q.popleft
append = q.append
cnt = len(q)
while q:
v = pop()
dw = dist[v] + 1
if dw > r:
break
for w in graph[v]:
if dist[w] == INF:
cnt += 1
dist[w] = dw
append(w)
return N - cnt
if K & 1:
answer = min(F(a, b, K) for a, b in AB)
else:
answer = min(F(a, a, K) for a in range(1, N + 1))
print(answer)
| false | 8.333333 | [
"-input = sys.stdin.readline",
"-sys.setrecursionlimit(10**7)",
"-N, K = list(map(int, input().split()))",
"-AB = [[int(x) for x in input().split()] for _ in range(N - 1)]",
"+read = sys.stdin.buffer.read",
"+readline = sys.stdin.buffer.readline",
"+readlines = sys.stdin.buffer.readlines",
"+from collections import deque",
"+",
"+N, K = list(map(int, readline().split()))",
"+m = list(map(int, read().split()))",
"+AB = list(zip(m, m))",
"-def count_nbd(x, R, parent):",
"- # parentを含まない部分木",
"- # xを含む、xから半径R内の点の個数を数える",
"- count = 0",
"- visited = [False] * (N + 1)",
"- visited[x] = True",
"- visited[parent] = True",
"- count += 1",
"- q = [x]",
"- for _ in range(R):",
"- qq = []",
"- for y in q:",
"- for z in graph[y]:",
"- if visited[z]:",
"- continue",
"- visited[z] = True",
"- qq.append(z)",
"- count += 1",
"- q = qq",
"- return count",
"+def F(a, b, K):",
"+ INF = 10**9",
"+ if a == b:",
"+ # 中心が1点",
"+ q = deque([a])",
"+ r = K // 2",
"+ else:",
"+ # 中心が辺",
"+ q = deque([a, b])",
"+ r = (K - 1) // 2",
"+ dist = [INF] * (N + 1)",
"+ for x in q:",
"+ dist[x] = 0",
"+ pop = q.popleft",
"+ append = q.append",
"+ cnt = len(q)",
"+ while q:",
"+ v = pop()",
"+ dw = dist[v] + 1",
"+ if dw > r:",
"+ break",
"+ for w in graph[v]:",
"+ if dist[w] == INF:",
"+ cnt += 1",
"+ dist[w] = dw",
"+ append(w)",
"+ return N - cnt",
"- # 辺の中点に中心がある場合",
"- R = (K - 1) // 2",
"- x = max(count_nbd(x, R, y) + count_nbd(y, R, x) for x, y in AB)",
"+ answer = min(F(a, b, K) for a, b in AB)",
"- # 頂点が中心",
"- R = K // 2",
"- x = max(count_nbd(x, R, 0) for x in range(1, N + 1))",
"-answer = N - x",
"+ answer = min(F(a, a, K) for a in range(1, N + 1))"
] | false | 0.08112 | 0.054433 | 1.490278 | [
"s576764163",
"s320802157"
] |
u729133443 | p03997 | python | s670809345 | s640448371 | 35 | 19 | 27,884 | 2,940 | Accepted | Accepted | 45.71 | i=input;print((i()+i())*i()/2) | a,b,h=list(map(int,open(0)));print(((a+b)*h//2)) | 1 | 1 | 28 | 40 | i = input
print((i() + i()) * i() / 2)
| a, b, h = list(map(int, open(0)))
print(((a + b) * h // 2))
| false | 0 | [
"-i = input",
"-print((i() + i()) * i() / 2)",
"+a, b, h = list(map(int, open(0)))",
"+print(((a + b) * h // 2))"
] | false | 0.035779 | 0.03658 | 0.978103 | [
"s670809345",
"s640448371"
] |
u970197315 | p02793 | python | s502853896 | s729298384 | 1,898 | 904 | 6,200 | 69,080 | Accepted | Accepted | 52.37 | from fractions import gcd
def lcm(x,y):
return (x*y)//gcd(x,y)
n=int(eval(input()))
a=list(map(int,input().split()))
mod=10**9+7
lcm_val=a[0]
for i in range(n-1):
lcm_val=lcm(lcm_val,a[i+1])
# print(lcm_val)
b=[]
ans=0
for aa in a:
ans+=lcm_val//aa
print((ans%mod)) | from fractions import gcd
def lcm(a,b):
return a*b//gcd(a,b)
n=int(eval(input()))
a=list(map(int,input().split()))
ans=0
mod=10**9+7
l=a[0]
for i in range(1,n):
l=lcm(l,a[i])
l%=mod
for aa in a:
# mod(10**9+7)逆元
ans+=l*pow(aa,mod-2,mod)%mod
ans%=mod
print(ans) | 16 | 16 | 279 | 279 | from fractions import gcd
def lcm(x, y):
return (x * y) // gcd(x, y)
n = int(eval(input()))
a = list(map(int, input().split()))
mod = 10**9 + 7
lcm_val = a[0]
for i in range(n - 1):
lcm_val = lcm(lcm_val, a[i + 1])
# print(lcm_val)
b = []
ans = 0
for aa in a:
ans += lcm_val // aa
print((ans % mod))
| from fractions import gcd
def lcm(a, b):
return a * b // gcd(a, b)
n = int(eval(input()))
a = list(map(int, input().split()))
ans = 0
mod = 10**9 + 7
l = a[0]
for i in range(1, n):
l = lcm(l, a[i])
l %= mod
for aa in a:
# mod(10**9+7)逆元
ans += l * pow(aa, mod - 2, mod) % mod
ans %= mod
print(ans)
| false | 0 | [
"-def lcm(x, y):",
"- return (x * y) // gcd(x, y)",
"+def lcm(a, b):",
"+ return a * b // gcd(a, b)",
"+ans = 0",
"-lcm_val = a[0]",
"-for i in range(n - 1):",
"- lcm_val = lcm(lcm_val, a[i + 1])",
"-# print(lcm_val)",
"-b = []",
"-ans = 0",
"+l = a[0]",
"+for i in range(1, n):",
"+ l = lcm(l, a[i])",
"+l %= mod",
"- ans += lcm_val // aa",
"-print((ans % mod))",
"+ # mod(10**9+7)逆元",
"+ ans += l * pow(aa, mod - 2, mod) % mod",
"+ ans %= mod",
"+print(ans)"
] | false | 0.054726 | 0.054847 | 0.997792 | [
"s502853896",
"s729298384"
] |
u506287026 | p03564 | python | s112334176 | s117851900 | 25 | 17 | 2,940 | 2,940 | Accepted | Accepted | 32 | N = int(eval(input()))
K = int(eval(input()))
min_m = 10 ** 10
for i in range(2 ** N):
m = 1
for n in range(N):
if i & (1 << n):
m *= 2
else:
m += K
min_m = min(min_m, m)
print(min_m)
| N = int(eval(input()))
K = int(eval(input()))
# min_m = 10 ** 10
# for i in range(2 ** N):
# m = 1
# for n in range(N):
# if i & (1 << n):
# m *= 2
# else:
# m += K
# min_m = min(min_m, m)
m = 1
for i in range(N):
m = min(m * 2, m + K)
print(m)
| 14 | 18 | 239 | 309 | N = int(eval(input()))
K = int(eval(input()))
min_m = 10**10
for i in range(2**N):
m = 1
for n in range(N):
if i & (1 << n):
m *= 2
else:
m += K
min_m = min(min_m, m)
print(min_m)
| N = int(eval(input()))
K = int(eval(input()))
# min_m = 10 ** 10
# for i in range(2 ** N):
# m = 1
# for n in range(N):
# if i & (1 << n):
# m *= 2
# else:
# m += K
# min_m = min(min_m, m)
m = 1
for i in range(N):
m = min(m * 2, m + K)
print(m)
| false | 22.222222 | [
"-min_m = 10**10",
"-for i in range(2**N):",
"- m = 1",
"- for n in range(N):",
"- if i & (1 << n):",
"- m *= 2",
"- else:",
"- m += K",
"- min_m = min(min_m, m)",
"-print(min_m)",
"+# min_m = 10 ** 10",
"+# for i in range(2 ** N):",
"+# m = 1",
"+# for n in range(N):",
"+# if i & (1 << n):",
"+# m *= 2",
"+# else:",
"+# m += K",
"+# min_m = min(min_m, m)",
"+m = 1",
"+for i in range(N):",
"+ m = min(m * 2, m + K)",
"+print(m)"
] | false | 0.036275 | 0.035996 | 1.007751 | [
"s112334176",
"s117851900"
] |
u043048943 | p03475 | python | s786891480 | s285116655 | 2,425 | 215 | 42,620 | 41,836 | Accepted | Accepted | 91.13 | N = int(eval(input()))
dia = []
for _ in range(N-1):
c,s,f = list(map(int,input().split()))
dia.append((c,s,f))
for i in range(N-1):
time = 0
for j in range(i,N-1):
c,s,f = dia[j]
while time > s:
s += f
time = s + c
print(time)
print((0))
| N = int(eval(input()))
dia = [0]*(N-1)
for i in range(N-1):
c,s,f = list(map(int,input().split()))
dia[i] = (c,s,f)
for i in range(N-1):
time = 0
for j in range(i,N-1):
c,s,f = dia[j]
if time > s:
x = (time - s)/f
if x.is_integer():
s += int(x)*f
else:
s += int(x+1)*f
time = s + c
# while time > s:
# s += f
# time = s + c
print(time)
print((0))
| 23 | 31 | 312 | 514 | N = int(eval(input()))
dia = []
for _ in range(N - 1):
c, s, f = list(map(int, input().split()))
dia.append((c, s, f))
for i in range(N - 1):
time = 0
for j in range(i, N - 1):
c, s, f = dia[j]
while time > s:
s += f
time = s + c
print(time)
print((0))
| N = int(eval(input()))
dia = [0] * (N - 1)
for i in range(N - 1):
c, s, f = list(map(int, input().split()))
dia[i] = (c, s, f)
for i in range(N - 1):
time = 0
for j in range(i, N - 1):
c, s, f = dia[j]
if time > s:
x = (time - s) / f
if x.is_integer():
s += int(x) * f
else:
s += int(x + 1) * f
time = s + c
# while time > s:
# s += f
# time = s + c
print(time)
print((0))
| false | 25.806452 | [
"-dia = []",
"-for _ in range(N - 1):",
"+dia = [0] * (N - 1)",
"+for i in range(N - 1):",
"- dia.append((c, s, f))",
"+ dia[i] = (c, s, f)",
"- while time > s:",
"- s += f",
"+ if time > s:",
"+ x = (time - s) / f",
"+ if x.is_integer():",
"+ s += int(x) * f",
"+ else:",
"+ s += int(x + 1) * f",
"+ # while time > s:",
"+ # s += f",
"+ # time = s + c"
] | false | 0.085983 | 0.045772 | 1.878521 | [
"s786891480",
"s285116655"
] |
u089230684 | p02959 | python | s092508192 | s136586499 | 153 | 104 | 18,624 | 98,728 | Accepted | Accepted | 32.03 | N = int(eval(input()))
Monsters = [int(i) for i in input().split()]
Heroes = [int(i) for i in input().split()]
res = 0
for i in range(N):
r = Monsters[i] - Heroes[i]
if r >= 0:
Monsters[i] -= Heroes[i]
res += Heroes[i]
else:
res += Monsters[i]
Monsters[i] = 0
k = Monsters[i+1] + r
if k >= 0:
res -= r
Monsters[i+1] += r
else:
res += Monsters[i+1]
Monsters[i+1] = 0
print(res) | import sys
input=sys.stdin.buffer.readline
import os
from math import*
n=int(eval(input()))
arr=list(map(int,input().split()))
brr=list(map(int,input().split()))
ans=0
for i in range(n):
if arr[i]>=brr[i]:
ans+=brr[i]
else:
if arr[i]+arr[i+1]>=brr[i]:
ans+=brr[i]
arr[i+1]=arr[i]+arr[i+1]-brr[i]
else:
ans+=arr[i]+arr[i+1]
arr[i+1]=0
print(ans) | 21 | 21 | 507 | 380 | N = int(eval(input()))
Monsters = [int(i) for i in input().split()]
Heroes = [int(i) for i in input().split()]
res = 0
for i in range(N):
r = Monsters[i] - Heroes[i]
if r >= 0:
Monsters[i] -= Heroes[i]
res += Heroes[i]
else:
res += Monsters[i]
Monsters[i] = 0
k = Monsters[i + 1] + r
if k >= 0:
res -= r
Monsters[i + 1] += r
else:
res += Monsters[i + 1]
Monsters[i + 1] = 0
print(res)
| import sys
input = sys.stdin.buffer.readline
import os
from math import *
n = int(eval(input()))
arr = list(map(int, input().split()))
brr = list(map(int, input().split()))
ans = 0
for i in range(n):
if arr[i] >= brr[i]:
ans += brr[i]
else:
if arr[i] + arr[i + 1] >= brr[i]:
ans += brr[i]
arr[i + 1] = arr[i] + arr[i + 1] - brr[i]
else:
ans += arr[i] + arr[i + 1]
arr[i + 1] = 0
print(ans)
| false | 0 | [
"-N = int(eval(input()))",
"-Monsters = [int(i) for i in input().split()]",
"-Heroes = [int(i) for i in input().split()]",
"-res = 0",
"-for i in range(N):",
"- r = Monsters[i] - Heroes[i]",
"- if r >= 0:",
"- Monsters[i] -= Heroes[i]",
"- res += Heroes[i]",
"+import sys",
"+",
"+input = sys.stdin.buffer.readline",
"+import os",
"+from math import *",
"+",
"+n = int(eval(input()))",
"+arr = list(map(int, input().split()))",
"+brr = list(map(int, input().split()))",
"+ans = 0",
"+for i in range(n):",
"+ if arr[i] >= brr[i]:",
"+ ans += brr[i]",
"- res += Monsters[i]",
"- Monsters[i] = 0",
"- k = Monsters[i + 1] + r",
"- if k >= 0:",
"- res -= r",
"- Monsters[i + 1] += r",
"+ if arr[i] + arr[i + 1] >= brr[i]:",
"+ ans += brr[i]",
"+ arr[i + 1] = arr[i] + arr[i + 1] - brr[i]",
"- res += Monsters[i + 1]",
"- Monsters[i + 1] = 0",
"-print(res)",
"+ ans += arr[i] + arr[i + 1]",
"+ arr[i + 1] = 0",
"+print(ans)"
] | false | 0.062321 | 0.036757 | 1.695476 | [
"s092508192",
"s136586499"
] |
u678167152 | p03608 | python | s120215194 | s000797516 | 520 | 303 | 61,144 | 70,760 | Accepted | Accepted | 41.73 | from itertools import groupby, accumulate, product, permutations, combinations
def solve():
ans = float('inf')
N, M, R = list(map(int, input().split()))
r = list(map(int, input().split()))
d = [[float('inf')]*N for _ in range(N)]
for i in range(M):
a,b,c = list(map(int, input().split()))
d[a-1][b-1] = c
d[b-1][a-1] = c
for i in range(N):
d[i][i] = 0 #自身への最短経路は0
#三重ループ
for k in range(N):
for i in range(N):
for j in range(N):
d[i][j] = min(d[i][j], d[i][k]+d[k][j])
for p in permutations(r,R):
cnt = 0
for i in range(R-1):
if d[p[i]-1][p[i+1]-1]<float('inf'):
cnt += d[p[i]-1][p[i+1]-1]
else:
break
else:
ans = min(ans,cnt)
return ans
print((solve())) | N, M, R = list(map(int, input().split()))
r = list(map(int, input().split()))
d = [[float('inf')]*N for _ in range(N)]
for i in range(M): #ひとまず枝があるペアは枝の長さをセット
a,b,t = list(map(int, input().split()))
d[a-1][b-1] = t
d[b-1][a-1] = t
for i in range(N):
d[i][i] = 0 #自身への最短経路は0
#三重ループ
for k in range(N):
for i in range(N):
for j in range(N):
d[i][j] = min(d[i][j], d[i][k]+d[k][j])
from itertools import groupby, accumulate, product, permutations, combinations
ans = float('inf')
for p in permutations(r,R):
cnt = 0
for i in range(1,R):
cnt += d[p[i-1]-1][p[i]-1]
ans = min(ans,cnt)
print(ans) | 28 | 25 | 866 | 634 | from itertools import groupby, accumulate, product, permutations, combinations
def solve():
ans = float("inf")
N, M, R = list(map(int, input().split()))
r = list(map(int, input().split()))
d = [[float("inf")] * N for _ in range(N)]
for i in range(M):
a, b, c = list(map(int, input().split()))
d[a - 1][b - 1] = c
d[b - 1][a - 1] = c
for i in range(N):
d[i][i] = 0 # 自身への最短経路は0
# 三重ループ
for k in range(N):
for i in range(N):
for j in range(N):
d[i][j] = min(d[i][j], d[i][k] + d[k][j])
for p in permutations(r, R):
cnt = 0
for i in range(R - 1):
if d[p[i] - 1][p[i + 1] - 1] < float("inf"):
cnt += d[p[i] - 1][p[i + 1] - 1]
else:
break
else:
ans = min(ans, cnt)
return ans
print((solve()))
| N, M, R = list(map(int, input().split()))
r = list(map(int, input().split()))
d = [[float("inf")] * N for _ in range(N)]
for i in range(M): # ひとまず枝があるペアは枝の長さをセット
a, b, t = list(map(int, input().split()))
d[a - 1][b - 1] = t
d[b - 1][a - 1] = t
for i in range(N):
d[i][i] = 0 # 自身への最短経路は0
# 三重ループ
for k in range(N):
for i in range(N):
for j in range(N):
d[i][j] = min(d[i][j], d[i][k] + d[k][j])
from itertools import groupby, accumulate, product, permutations, combinations
ans = float("inf")
for p in permutations(r, R):
cnt = 0
for i in range(1, R):
cnt += d[p[i - 1] - 1][p[i] - 1]
ans = min(ans, cnt)
print(ans)
| false | 10.714286 | [
"+N, M, R = list(map(int, input().split()))",
"+r = list(map(int, input().split()))",
"+d = [[float(\"inf\")] * N for _ in range(N)]",
"+for i in range(M): # ひとまず枝があるペアは枝の長さをセット",
"+ a, b, t = list(map(int, input().split()))",
"+ d[a - 1][b - 1] = t",
"+ d[b - 1][a - 1] = t",
"+for i in range(N):",
"+ d[i][i] = 0 # 自身への最短経路は0",
"+# 三重ループ",
"+for k in range(N):",
"+ for i in range(N):",
"+ for j in range(N):",
"+ d[i][j] = min(d[i][j], d[i][k] + d[k][j])",
"-",
"-def solve():",
"- ans = float(\"inf\")",
"- N, M, R = list(map(int, input().split()))",
"- r = list(map(int, input().split()))",
"- d = [[float(\"inf\")] * N for _ in range(N)]",
"- for i in range(M):",
"- a, b, c = list(map(int, input().split()))",
"- d[a - 1][b - 1] = c",
"- d[b - 1][a - 1] = c",
"- for i in range(N):",
"- d[i][i] = 0 # 自身への最短経路は0",
"- # 三重ループ",
"- for k in range(N):",
"- for i in range(N):",
"- for j in range(N):",
"- d[i][j] = min(d[i][j], d[i][k] + d[k][j])",
"- for p in permutations(r, R):",
"- cnt = 0",
"- for i in range(R - 1):",
"- if d[p[i] - 1][p[i + 1] - 1] < float(\"inf\"):",
"- cnt += d[p[i] - 1][p[i + 1] - 1]",
"- else:",
"- break",
"- else:",
"- ans = min(ans, cnt)",
"- return ans",
"-",
"-",
"-print((solve()))",
"+ans = float(\"inf\")",
"+for p in permutations(r, R):",
"+ cnt = 0",
"+ for i in range(1, R):",
"+ cnt += d[p[i - 1] - 1][p[i] - 1]",
"+ ans = min(ans, cnt)",
"+print(ans)"
] | false | 0.075738 | 0.037895 | 1.998646 | [
"s120215194",
"s000797516"
] |
u863442865 | p03170 | python | s125870473 | s037837538 | 680 | 76 | 4,084 | 3,828 | Accepted | Accepted | 88.82 | def main():
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10000000)
from collections import Counter, deque
#from collections import defaultdict
from itertools import combinations, permutations, accumulate
#from itertools import product
from bisect import bisect_left,bisect_right
import heapq
from math import floor, ceil
#from operator import itemgetter
#inf = 10**17
#mod = 10**9 + 7
N,K = list(map(int, input().split()))
a = list(map(int, input().split()))
dp = [0]*(K+1)
for i in range(1, K+1):
for j in a:
if i-j < 0:
continue
if dp[i-j] == 0:
dp[i] = 1
break
if dp[K]:
print('First')
else:
print('Second')
if __name__ == '__main__':
main() | def main():
N, K, *A = list(map(int, open(0).read().split()))
dp = [0] * (K + 1)
for i in range(K):
if dp[i]:
continue
for a in A:
if i + a > K:
break
dp[i + a] = 1
print(("First" if dp[-1] else "Second"))
if __name__ == "__main__":
main()
| 33 | 13 | 864 | 332 | def main():
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10000000)
from collections import Counter, deque
# from collections import defaultdict
from itertools import combinations, permutations, accumulate
# from itertools import product
from bisect import bisect_left, bisect_right
import heapq
from math import floor, ceil
# from operator import itemgetter
# inf = 10**17
# mod = 10**9 + 7
N, K = list(map(int, input().split()))
a = list(map(int, input().split()))
dp = [0] * (K + 1)
for i in range(1, K + 1):
for j in a:
if i - j < 0:
continue
if dp[i - j] == 0:
dp[i] = 1
break
if dp[K]:
print("First")
else:
print("Second")
if __name__ == "__main__":
main()
| def main():
N, K, *A = list(map(int, open(0).read().split()))
dp = [0] * (K + 1)
for i in range(K):
if dp[i]:
continue
for a in A:
if i + a > K:
break
dp[i + a] = 1
print(("First" if dp[-1] else "Second"))
if __name__ == "__main__":
main()
| false | 60.606061 | [
"- import sys",
"-",
"- input = sys.stdin.readline",
"- sys.setrecursionlimit(10000000)",
"- from collections import Counter, deque",
"-",
"- # from collections import defaultdict",
"- from itertools import combinations, permutations, accumulate",
"-",
"- # from itertools import product",
"- from bisect import bisect_left, bisect_right",
"- import heapq",
"- from math import floor, ceil",
"-",
"- # from operator import itemgetter",
"- # inf = 10**17",
"- # mod = 10**9 + 7",
"- N, K = list(map(int, input().split()))",
"- a = list(map(int, input().split()))",
"+ N, K, *A = list(map(int, open(0).read().split()))",
"- for i in range(1, K + 1):",
"- for j in a:",
"- if i - j < 0:",
"- continue",
"- if dp[i - j] == 0:",
"- dp[i] = 1",
"+ for i in range(K):",
"+ if dp[i]:",
"+ continue",
"+ for a in A:",
"+ if i + a > K:",
"- if dp[K]:",
"- print(\"First\")",
"- else:",
"- print(\"Second\")",
"+ dp[i + a] = 1",
"+ print((\"First\" if dp[-1] else \"Second\"))"
] | false | 0.095599 | 0.036683 | 2.606097 | [
"s125870473",
"s037837538"
] |
u077291787 | p03208 | python | s747342203 | s776559116 | 208 | 115 | 14,236 | 14,236 | Accepted | Accepted | 44.71 | # ABC115C - Christmas Eve
def main():
n, k = list(map(int, input().rstrip().split()))
lst = sorted(list(map(int, [input().rstrip() for _ in range(n)])))
ans = lst[k - 1] - lst[0]
for i, j in zip(lst, lst[k - 1 :]):
ans = min(ans, j - i)
print(ans)
if __name__ == "__main__":
main() | # ABC115C - Christmas Eve
import sys
input = sys.stdin.readline
def main():
n, k = list(map(int, input().rstrip().split()))
lst = sorted(list(map(int, [input().rstrip() for _ in range(n)])))
ans = lst[k - 1] - lst[0]
for i, j in zip(lst, lst[k - 1 :]):
ans = min(ans, j - i)
print(ans)
if __name__ == "__main__":
main() | 12 | 15 | 326 | 368 | # ABC115C - Christmas Eve
def main():
n, k = list(map(int, input().rstrip().split()))
lst = sorted(list(map(int, [input().rstrip() for _ in range(n)])))
ans = lst[k - 1] - lst[0]
for i, j in zip(lst, lst[k - 1 :]):
ans = min(ans, j - i)
print(ans)
if __name__ == "__main__":
main()
| # ABC115C - Christmas Eve
import sys
input = sys.stdin.readline
def main():
n, k = list(map(int, input().rstrip().split()))
lst = sorted(list(map(int, [input().rstrip() for _ in range(n)])))
ans = lst[k - 1] - lst[0]
for i, j in zip(lst, lst[k - 1 :]):
ans = min(ans, j - i)
print(ans)
if __name__ == "__main__":
main()
| false | 20 | [
"+import sys",
"+",
"+input = sys.stdin.readline",
"+",
"+"
] | false | 0.037805 | 0.105951 | 0.356816 | [
"s747342203",
"s776559116"
] |
u426764965 | p03229 | python | s896155967 | s656719347 | 215 | 78 | 7,764 | 13,028 | Accepted | Accepted | 63.72 | # https://atcoder.jp/contests/tenka1-2018-beginner/submissions/6799465
def tenka18beg_c():
N = int(eval(input()))
A = [int(eval(input())) for _ in range(N)]
A.sort()
if N % 2 == 0:
lower = A[:N//2]
upper = A[N//2:]
ans = (2 * sum(upper) - upper[0]) - (2 * sum(lower) - lower[-1])
else:
lower = A[:N//2]
upper = A[N//2 + 1:]
mid = A[N//2]
x = 2 * sum(upper) - 2 * sum(lower) - mid + lower[-1] # 中央が +2* -1* -1* のパターン
y = 2 * sum(upper) - 2 * sum(lower) + mid - upper[0] # 中央が +1* +1* -2* のパターン
ans = max(x, y)
print(ans)
tenka18beg_c() | import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
def tenka18beg_c():
# https://atcoder.jp/contests/tenka1-2018-beginner/submissions/6799465
inp = list(map(int, read().split()))
N = inp[0]
A = inp[1:]
A.sort()
if N % 2 == 0:
lower = A[:N//2]
upper = A[N//2:]
ans = (2 * sum(upper) - upper[0]) - (2 * sum(lower) - lower[-1])
else:
lower = A[:N//2]
upper = A[N//2 + 1:]
mid = A[N//2]
x = 2 * sum(upper) - 2 * sum(lower) - mid + lower[-1] # 中央が +2* -1* -1* のパターン
y = 2 * sum(upper) - 2 * sum(lower) + mid - upper[0] # 中央が +1* +1* -2* のパターン
ans = max(x, y)
print(ans)
tenka18beg_c() | 20 | 26 | 641 | 778 | # https://atcoder.jp/contests/tenka1-2018-beginner/submissions/6799465
def tenka18beg_c():
N = int(eval(input()))
A = [int(eval(input())) for _ in range(N)]
A.sort()
if N % 2 == 0:
lower = A[: N // 2]
upper = A[N // 2 :]
ans = (2 * sum(upper) - upper[0]) - (2 * sum(lower) - lower[-1])
else:
lower = A[: N // 2]
upper = A[N // 2 + 1 :]
mid = A[N // 2]
x = 2 * sum(upper) - 2 * sum(lower) - mid + lower[-1] # 中央が +2* -1* -1* のパターン
y = 2 * sum(upper) - 2 * sum(lower) + mid - upper[0] # 中央が +1* +1* -2* のパターン
ans = max(x, y)
print(ans)
tenka18beg_c()
| import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
def tenka18beg_c():
# https://atcoder.jp/contests/tenka1-2018-beginner/submissions/6799465
inp = list(map(int, read().split()))
N = inp[0]
A = inp[1:]
A.sort()
if N % 2 == 0:
lower = A[: N // 2]
upper = A[N // 2 :]
ans = (2 * sum(upper) - upper[0]) - (2 * sum(lower) - lower[-1])
else:
lower = A[: N // 2]
upper = A[N // 2 + 1 :]
mid = A[N // 2]
x = 2 * sum(upper) - 2 * sum(lower) - mid + lower[-1] # 中央が +2* -1* -1* のパターン
y = 2 * sum(upper) - 2 * sum(lower) + mid - upper[0] # 中央が +1* +1* -2* のパターン
ans = max(x, y)
print(ans)
tenka18beg_c()
| false | 23.076923 | [
"-# https://atcoder.jp/contests/tenka1-2018-beginner/submissions/6799465",
"+import sys",
"+",
"+read = sys.stdin.buffer.read",
"+readline = sys.stdin.buffer.readline",
"+readlines = sys.stdin.buffer.readlines",
"+",
"+",
"- N = int(eval(input()))",
"- A = [int(eval(input())) for _ in range(N)]",
"+ # https://atcoder.jp/contests/tenka1-2018-beginner/submissions/6799465",
"+ inp = list(map(int, read().split()))",
"+ N = inp[0]",
"+ A = inp[1:]"
] | false | 0.044793 | 0.036617 | 1.223277 | [
"s896155967",
"s656719347"
] |
u780475861 | p02834 | python | s128180738 | s069520790 | 535 | 347 | 45,236 | 36,316 | Accepted | Accepted | 35.14 | import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
import numpy as np
n, u, v = list(map(int, readline().split()))
m = list(map(int,read().split()))
data = list(zip(m,m))
graph = [[] for _ in range(n+1)]
for a,b in data:
graph[a].append(b)
graph[b].append(a)
def dfs(v):
dist = [None] * (n + 1)
dist[v] = 0
stack = [v]
while stack:
x = stack.pop()
for y in graph[x]:
if dist[y] is None:
dist[y] = dist[x] + 1
stack.append(y)
return dist
res = 0
du, dv = dfs(u), dfs(v)
for i in range(1, n+1):
dvi = dv[i]
if du[i] <= dvi:
if dvi > res:
res = dvi
print((res - 1)) | import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
n, u, v = list(map(int, readline().split()))
m = list(map(int,read().split()))
data = list(zip(m,m))
graph = [[] for _ in range(n+1)]
for a,b in data:
graph[a].append(b)
graph[b].append(a)
def dfs(v):
dist = [None] * (n + 1)
dist[v] = 0
stack = [v]
while stack:
x = stack.pop()
for y in graph[x]:
if dist[y] is None:
dist[y] = dist[x] + 1
stack.append(y)
return dist
res = 0
du, dv = dfs(u), dfs(v)
for i in range(1, n+1):
dvi = dv[i]
if du[i] <= dvi:
if dvi > res:
res = dvi
print((res - 1)) | 35 | 33 | 767 | 745 | import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
import numpy as np
n, u, v = list(map(int, readline().split()))
m = list(map(int, read().split()))
data = list(zip(m, m))
graph = [[] for _ in range(n + 1)]
for a, b in data:
graph[a].append(b)
graph[b].append(a)
def dfs(v):
dist = [None] * (n + 1)
dist[v] = 0
stack = [v]
while stack:
x = stack.pop()
for y in graph[x]:
if dist[y] is None:
dist[y] = dist[x] + 1
stack.append(y)
return dist
res = 0
du, dv = dfs(u), dfs(v)
for i in range(1, n + 1):
dvi = dv[i]
if du[i] <= dvi:
if dvi > res:
res = dvi
print((res - 1))
| import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
n, u, v = list(map(int, readline().split()))
m = list(map(int, read().split()))
data = list(zip(m, m))
graph = [[] for _ in range(n + 1)]
for a, b in data:
graph[a].append(b)
graph[b].append(a)
def dfs(v):
dist = [None] * (n + 1)
dist[v] = 0
stack = [v]
while stack:
x = stack.pop()
for y in graph[x]:
if dist[y] is None:
dist[y] = dist[x] + 1
stack.append(y)
return dist
res = 0
du, dv = dfs(u), dfs(v)
for i in range(1, n + 1):
dvi = dv[i]
if du[i] <= dvi:
if dvi > res:
res = dvi
print((res - 1))
| false | 5.714286 | [
"-import numpy as np",
"-"
] | false | 0.035639 | 0.10313 | 0.345573 | [
"s128180738",
"s069520790"
] |
u891217808 | p02727 | python | s514024169 | s612367341 | 482 | 360 | 107,660 | 108,780 | Accepted | Accepted | 25.31 | import heapq
x, y, a, b, c = list(map(int, input().split()))
ps = sorted(list(map(int, input().split())), reverse=True)[:x]
qs = sorted(list(map(int, input().split())), reverse=True)[:y]
rs = sorted(list(map(int, input().split())))
apples = ps + qs
heapq.heapify(apples)
m = heapq.heappop(apples)
M = rs.pop()
while 1:
if m < M:
heapq.heappush(apples, M)
if rs:
m = heapq.heappop(apples)
M = rs.pop()
else:
break
else:
heapq.heappush(apples, m)
break
print((sum(apples)))
| x, y, a, b, c = list(map(int, input().split()))
ps = sorted(list(map(int, input().split())), reverse=True)[:x]
qs = sorted(list(map(int, input().split())), reverse=True)[:y]
rs = list(map(int, input().split()))
apples = sorted(ps + qs + rs, reverse=True)
print((sum(apples[:x+y])))
| 21 | 6 | 570 | 279 | import heapq
x, y, a, b, c = list(map(int, input().split()))
ps = sorted(list(map(int, input().split())), reverse=True)[:x]
qs = sorted(list(map(int, input().split())), reverse=True)[:y]
rs = sorted(list(map(int, input().split())))
apples = ps + qs
heapq.heapify(apples)
m = heapq.heappop(apples)
M = rs.pop()
while 1:
if m < M:
heapq.heappush(apples, M)
if rs:
m = heapq.heappop(apples)
M = rs.pop()
else:
break
else:
heapq.heappush(apples, m)
break
print((sum(apples)))
| x, y, a, b, c = list(map(int, input().split()))
ps = sorted(list(map(int, input().split())), reverse=True)[:x]
qs = sorted(list(map(int, input().split())), reverse=True)[:y]
rs = list(map(int, input().split()))
apples = sorted(ps + qs + rs, reverse=True)
print((sum(apples[: x + y])))
| false | 71.428571 | [
"-import heapq",
"-",
"-rs = sorted(list(map(int, input().split())))",
"-apples = ps + qs",
"-heapq.heapify(apples)",
"-m = heapq.heappop(apples)",
"-M = rs.pop()",
"-while 1:",
"- if m < M:",
"- heapq.heappush(apples, M)",
"- if rs:",
"- m = heapq.heappop(apples)",
"- M = rs.pop()",
"- else:",
"- break",
"- else:",
"- heapq.heappush(apples, m)",
"- break",
"-print((sum(apples)))",
"+rs = list(map(int, input().split()))",
"+apples = sorted(ps + qs + rs, reverse=True)",
"+print((sum(apples[: x + y])))"
] | false | 0.102314 | 0.122395 | 0.835935 | [
"s514024169",
"s612367341"
] |
u597374218 | p02603 | python | s522874356 | s967217071 | 32 | 26 | 9,164 | 9,196 | Accepted | Accepted | 18.75 | N=int(eval(input()))
A=list(map(int,input().split()))
money=1000
for i in range(N-1):
stock=0
if A[i]<A[i+1]:
stock=money//A[i]
money+=(A[i+1]-A[i])*stock
print(money) | N=int(eval(input()))
A=list(map(int,input().split()))
dp=[0]*N
dp[0]=1000
for i in range(1,N):
dp[i]=max(dp[i-1],dp[i-1]//A[i-1]*A[i]+dp[i-1]%A[i-1])
print((dp[-1])) | 9 | 7 | 193 | 167 | N = int(eval(input()))
A = list(map(int, input().split()))
money = 1000
for i in range(N - 1):
stock = 0
if A[i] < A[i + 1]:
stock = money // A[i]
money += (A[i + 1] - A[i]) * stock
print(money)
| N = int(eval(input()))
A = list(map(int, input().split()))
dp = [0] * N
dp[0] = 1000
for i in range(1, N):
dp[i] = max(dp[i - 1], dp[i - 1] // A[i - 1] * A[i] + dp[i - 1] % A[i - 1])
print((dp[-1]))
| false | 22.222222 | [
"-money = 1000",
"-for i in range(N - 1):",
"- stock = 0",
"- if A[i] < A[i + 1]:",
"- stock = money // A[i]",
"- money += (A[i + 1] - A[i]) * stock",
"-print(money)",
"+dp = [0] * N",
"+dp[0] = 1000",
"+for i in range(1, N):",
"+ dp[i] = max(dp[i - 1], dp[i - 1] // A[i - 1] * A[i] + dp[i - 1] % A[i - 1])",
"+print((dp[-1]))"
] | false | 0.036051 | 0.036635 | 0.984048 | [
"s522874356",
"s967217071"
] |
u204842730 | p02922 | python | s256666695 | s735254986 | 175 | 17 | 38,384 | 2,940 | Accepted | Accepted | 90.29 | # coding: utf-8
import sys
a,b = list(map(int,input().split()))
ans = 0
tap = 1
if(b==1):
print((0))
sys.exit()
while(1):
tap += a-1
ans+=1
if(tap>=b):
print(ans)
break | a,b= list(map(int,input().split()))
tap=1
ans=0
while tap<b:
tap+=a-1
ans+=1
print(ans) | 14 | 7 | 209 | 95 | # coding: utf-8
import sys
a, b = list(map(int, input().split()))
ans = 0
tap = 1
if b == 1:
print((0))
sys.exit()
while 1:
tap += a - 1
ans += 1
if tap >= b:
print(ans)
break
| a, b = list(map(int, input().split()))
tap = 1
ans = 0
while tap < b:
tap += a - 1
ans += 1
print(ans)
| false | 50 | [
"-# coding: utf-8",
"-import sys",
"-",
"+tap = 1",
"-tap = 1",
"-if b == 1:",
"- print((0))",
"- sys.exit()",
"-while 1:",
"+while tap < b:",
"- if tap >= b:",
"- print(ans)",
"- break",
"+print(ans)"
] | false | 0.074767 | 0.038344 | 1.949876 | [
"s256666695",
"s735254986"
] |
u360090862 | p03044 | python | s729217731 | s563255955 | 1,217 | 890 | 154,272 | 88,748 | Accepted | Accepted | 26.87 | import math
import sys
sys.setrecursionlimit(30000)
N=int(eval(input()))
edges=[[] for i in range(N+1)]
d=[-1 for i in range(N+1)]
for i in range(1,N):
u,v,w=[int(i) for i in input().split()]
edges[u].append([v,w])
edges[v].append([u,w])
def kyori(u):
for v,w in edges[u]:
if d[v]==-1:
d[v]=d[u]+w
kyori(v)
d[1]=0
kyori(1)
for i in d[1:]:
if i%2==0:
print((1))
else:
print((0)) | import math
import sys
sys.setrecursionlimit(100000)
N=int(eval(input()))
edges=[[] for i in range(N+1)]
d=[-1 for i in range(N+1)]
for i in range(1,N):
u,v,w=[int(i) for i in input().split()]
edges[u].append([v,w])
edges[v].append([u,w])
def kyori(u):
for v,w in edges[u]:
if d[v]==-1:
d[v]=d[u]+w
kyori(v)
d[1]=0
kyori(1)
for i in d[1:]:
if i%2==0:
print((1))
else:
print((0)) | 22 | 22 | 406 | 407 | import math
import sys
sys.setrecursionlimit(30000)
N = int(eval(input()))
edges = [[] for i in range(N + 1)]
d = [-1 for i in range(N + 1)]
for i in range(1, N):
u, v, w = [int(i) for i in input().split()]
edges[u].append([v, w])
edges[v].append([u, w])
def kyori(u):
for v, w in edges[u]:
if d[v] == -1:
d[v] = d[u] + w
kyori(v)
d[1] = 0
kyori(1)
for i in d[1:]:
if i % 2 == 0:
print((1))
else:
print((0))
| import math
import sys
sys.setrecursionlimit(100000)
N = int(eval(input()))
edges = [[] for i in range(N + 1)]
d = [-1 for i in range(N + 1)]
for i in range(1, N):
u, v, w = [int(i) for i in input().split()]
edges[u].append([v, w])
edges[v].append([u, w])
def kyori(u):
for v, w in edges[u]:
if d[v] == -1:
d[v] = d[u] + w
kyori(v)
d[1] = 0
kyori(1)
for i in d[1:]:
if i % 2 == 0:
print((1))
else:
print((0))
| false | 0 | [
"-sys.setrecursionlimit(30000)",
"+sys.setrecursionlimit(100000)"
] | false | 0.035947 | 0.037454 | 0.959749 | [
"s729217731",
"s563255955"
] |
u150984829 | p02262 | python | s932722285 | s886450007 | 11,310 | 10,410 | 53,324 | 53,328 | Accepted | Accepted | 7.96 | import sys
n = int(input())
A = [int(e)for e in sys.stdin]
cnt = 0
G = [int((2.0555**i-1)/1.0555)for i in range(19,0,-1)]+[1]
G = [v for v in G if v <= n]
def insertionSort(A, n, g):
global cnt
for i in range(g, n):
v = A[i]
j = i - g
while j >= 0 and A[j] > v:
A[j+g] = A[j]
j = j - g
cnt += 1
A[j+g] = v
for g in G:
insertionSort(A, n, g)
print(len(G))
print(*G)
print(cnt)
print(*A,sep='\n')
| import sys
n = int(input())
A = [int(e)for e in sys.stdin]
cnt = 0
G = [int((2.0555**i-1)/1.0555)for i in range(19,1,-1)]+[1]
G = [v for v in G if v <= n]
def insertionSort(A, n, g):
global cnt
for i in range(g, n):
v = A[i]
j = i - g
while j >= 0 and A[j] > v:
A[j+g] = A[j]
j = j - g
cnt += 1
A[j+g] = v
for g in G:
insertionSort(A, n, g)
print(len(G))
print(*G)
print(cnt)
print(*A,sep='\n')
| 22 | 22 | 496 | 496 | import sys
n = int(input())
A = [int(e) for e in sys.stdin]
cnt = 0
G = [int((2.0555**i - 1) / 1.0555) for i in range(19, 0, -1)] + [1]
G = [v for v in G if v <= n]
def insertionSort(A, n, g):
global cnt
for i in range(g, n):
v = A[i]
j = i - g
while j >= 0 and A[j] > v:
A[j + g] = A[j]
j = j - g
cnt += 1
A[j + g] = v
for g in G:
insertionSort(A, n, g)
print(len(G))
print(*G)
print(cnt)
print(*A, sep="\n")
| import sys
n = int(input())
A = [int(e) for e in sys.stdin]
cnt = 0
G = [int((2.0555**i - 1) / 1.0555) for i in range(19, 1, -1)] + [1]
G = [v for v in G if v <= n]
def insertionSort(A, n, g):
global cnt
for i in range(g, n):
v = A[i]
j = i - g
while j >= 0 and A[j] > v:
A[j + g] = A[j]
j = j - g
cnt += 1
A[j + g] = v
for g in G:
insertionSort(A, n, g)
print(len(G))
print(*G)
print(cnt)
print(*A, sep="\n")
| false | 0 | [
"-G = [int((2.0555**i - 1) / 1.0555) for i in range(19, 0, -1)] + [1]",
"+G = [int((2.0555**i - 1) / 1.0555) for i in range(19, 1, -1)] + [1]"
] | false | 0.066333 | 0.039744 | 1.669009 | [
"s932722285",
"s886450007"
] |
u330799501 | p02694 | python | s112194204 | s856563495 | 39 | 32 | 9,148 | 9,148 | Accepted | Accepted | 17.95 | #k = int(input())
#s = input()
#a, b = map(int, input().split())
#l = list(map(int, input().split()))
x = int(eval(input()))
yokin = 100
for i in range(1, 100000000000):
yokin *= 101
yokin = yokin //100
if (yokin >= x):
print(i)
break
| #k = int(input())
#s = input()
#a, b = map(int, input().split())
#l = list(map(int, input().split()))
x = int(eval(input()))
yokin = 100
for i in range(1, 100000000000):
yokin += yokin // 100
if (yokin >= x):
print(i)
break
| 15 | 14 | 274 | 258 | # k = int(input())
# s = input()
# a, b = map(int, input().split())
# l = list(map(int, input().split()))
x = int(eval(input()))
yokin = 100
for i in range(1, 100000000000):
yokin *= 101
yokin = yokin // 100
if yokin >= x:
print(i)
break
| # k = int(input())
# s = input()
# a, b = map(int, input().split())
# l = list(map(int, input().split()))
x = int(eval(input()))
yokin = 100
for i in range(1, 100000000000):
yokin += yokin // 100
if yokin >= x:
print(i)
break
| false | 6.666667 | [
"- yokin *= 101",
"- yokin = yokin // 100",
"+ yokin += yokin // 100"
] | false | 0.059942 | 0.051516 | 1.163557 | [
"s112194204",
"s856563495"
] |
u492447501 | p02779 | python | s350672590 | s169472860 | 155 | 88 | 32,948 | 25,168 | Accepted | Accepted | 43.23 | import sys
N = int(eval(input()))
*A, = list(map(int, input().split()))
D = {}
for i in range(N):
e = A[i]
if not(e in D):
D[e] = 1
else:
D[e] = D[e] + 1
for key in D:
if D[key]>=2:
print("NO")
sys.exit()
print("YES") | N = int(eval(input()))
*A, = list(map(int, input().split()))
if len(set(A))==len(A):
print("YES")
else:
print("NO") | 20 | 7 | 277 | 118 | import sys
N = int(eval(input()))
(*A,) = list(map(int, input().split()))
D = {}
for i in range(N):
e = A[i]
if not (e in D):
D[e] = 1
else:
D[e] = D[e] + 1
for key in D:
if D[key] >= 2:
print("NO")
sys.exit()
print("YES")
| N = int(eval(input()))
(*A,) = list(map(int, input().split()))
if len(set(A)) == len(A):
print("YES")
else:
print("NO")
| false | 65 | [
"-import sys",
"-",
"-D = {}",
"-for i in range(N):",
"- e = A[i]",
"- if not (e in D):",
"- D[e] = 1",
"- else:",
"- D[e] = D[e] + 1",
"-for key in D:",
"- if D[key] >= 2:",
"- print(\"NO\")",
"- sys.exit()",
"-print(\"YES\")",
"+if len(set(A)) == len(A):",
"+ print(\"YES\")",
"+else:",
"+ print(\"NO\")"
] | false | 0.040622 | 0.108318 | 0.375028 | [
"s350672590",
"s169472860"
] |
u624475441 | p03262 | python | s061256480 | s844870790 | 139 | 87 | 14,596 | 16,040 | Accepted | Accepted | 37.41 | from functools import reduce
N,X=list(map(int,input().split()))
d=[abs(x-X) for x in map(int,input().split())]
def gcd(a,b):
while b:
a, b = b, a % b
return a
print((reduce(gcd,d))) | from fractions import gcd
from functools import reduce
_,X,*A=list(map(int,open(0).read().split()))
print((reduce(gcd,[abs(a-X)for a in A]))) | 11 | 4 | 202 | 136 | from functools import reduce
N, X = list(map(int, input().split()))
d = [abs(x - X) for x in map(int, input().split())]
def gcd(a, b):
while b:
a, b = b, a % b
return a
print((reduce(gcd, d)))
| from fractions import gcd
from functools import reduce
_, X, *A = list(map(int, open(0).read().split()))
print((reduce(gcd, [abs(a - X) for a in A])))
| false | 63.636364 | [
"+from fractions import gcd",
"-N, X = list(map(int, input().split()))",
"-d = [abs(x - X) for x in map(int, input().split())]",
"-",
"-",
"-def gcd(a, b):",
"- while b:",
"- a, b = b, a % b",
"- return a",
"-",
"-",
"-print((reduce(gcd, d)))",
"+_, X, *A = list(map(int, open(0).read().split()))",
"+print((reduce(gcd, [abs(a - X) for a in A])))"
] | false | 0.034814 | 0.04405 | 0.790325 | [
"s061256480",
"s844870790"
] |
u440566786 | p02925 | python | s345972416 | s327833870 | 1,300 | 1,198 | 131,328 | 131,712 | Accepted | Accepted | 7.85 | import sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7
input=lambda :sys.stdin.readline().rstrip()
def resolve():
from itertools import product
n=int(eval(input()))
match=[[0]*n for _ in range(n)]
V=0 # V=n(n-1)/2
for i,j in product(list(range(n)),repeat=2):
if(i>=j): continue
match[i][j]=V
V+=1
def toID(i,j):
if(i>j): i,j=j,i
return match[i][j]
E=[[] for _ in range(V)]
for i in range(n):
A=list([int(x)-1 for x in input().split()])
for j in range(1,n-1):
E[toID(i,A[j-1])].append(toID(i,A[j]))
# あとは頂点VのグラフをdfsしてLongest pathの長さを求める
# -1: unchecked, -2: checked and uncalculated
dp=[-1]*V
flag=True
def dfs(v):
global flag
dp[v]=-2
length=0
for nv in E[v]:
if(dp[nv]==-2):
print((-1))
exit()
if(dp[nv]==-1):
dfs(nv)
length=max(length,dp[nv]+1)
dp[v]=length
# calculate
for i in range(V): dfs(i)
print((max(dp)+1 if(flag) else -1))
resolve() | import sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7
input=lambda :sys.stdin.readline().rstrip()
def resolve():
from itertools import product
n=int(eval(input()))
match=[[0]*n for _ in range(n)]
V=0 # V=n(n-1)/2
for i,j in product(list(range(n)),repeat=2):
if(i>=j): continue
match[i][j]=V
V+=1
def toID(i,j):
if(i>j): i,j=j,i
return match[i][j]
E=[[] for _ in range(V)]
for i in range(n):
A=list([int(x)-1 for x in input().split()])
for j in range(1,n-1):
E[toID(i,A[j-1])].append(toID(i,A[j]))
# 頂点数Vの有向グラフをdfsしてLongest pathの長さを求める
# -1: unchecked, -2: checked and uncalculated
dp=[-1]*V
def dfs(v):
if(dp[v]>=0): return
dp[v]=-2
length=0
for nv in E[v]:
if(dp[nv]==-2):
print((-1))
exit()
if(dp[nv]==-1):
dfs(nv)
length=max(length,dp[nv]+1)
dp[v]=length
# calculate
for i in range(V): dfs(i)
print((max(dp)+1))
resolve() | 44 | 43 | 1,150 | 1,127 | import sys
sys.setrecursionlimit(2147483647)
INF = float("inf")
MOD = 10**9 + 7
input = lambda: sys.stdin.readline().rstrip()
def resolve():
from itertools import product
n = int(eval(input()))
match = [[0] * n for _ in range(n)]
V = 0 # V=n(n-1)/2
for i, j in product(list(range(n)), repeat=2):
if i >= j:
continue
match[i][j] = V
V += 1
def toID(i, j):
if i > j:
i, j = j, i
return match[i][j]
E = [[] for _ in range(V)]
for i in range(n):
A = list([int(x) - 1 for x in input().split()])
for j in range(1, n - 1):
E[toID(i, A[j - 1])].append(toID(i, A[j]))
# あとは頂点VのグラフをdfsしてLongest pathの長さを求める
# -1: unchecked, -2: checked and uncalculated
dp = [-1] * V
flag = True
def dfs(v):
global flag
dp[v] = -2
length = 0
for nv in E[v]:
if dp[nv] == -2:
print((-1))
exit()
if dp[nv] == -1:
dfs(nv)
length = max(length, dp[nv] + 1)
dp[v] = length
# calculate
for i in range(V):
dfs(i)
print((max(dp) + 1 if (flag) else -1))
resolve()
| import sys
sys.setrecursionlimit(2147483647)
INF = float("inf")
MOD = 10**9 + 7
input = lambda: sys.stdin.readline().rstrip()
def resolve():
from itertools import product
n = int(eval(input()))
match = [[0] * n for _ in range(n)]
V = 0 # V=n(n-1)/2
for i, j in product(list(range(n)), repeat=2):
if i >= j:
continue
match[i][j] = V
V += 1
def toID(i, j):
if i > j:
i, j = j, i
return match[i][j]
E = [[] for _ in range(V)]
for i in range(n):
A = list([int(x) - 1 for x in input().split()])
for j in range(1, n - 1):
E[toID(i, A[j - 1])].append(toID(i, A[j]))
# 頂点数Vの有向グラフをdfsしてLongest pathの長さを求める
# -1: unchecked, -2: checked and uncalculated
dp = [-1] * V
def dfs(v):
if dp[v] >= 0:
return
dp[v] = -2
length = 0
for nv in E[v]:
if dp[nv] == -2:
print((-1))
exit()
if dp[nv] == -1:
dfs(nv)
length = max(length, dp[nv] + 1)
dp[v] = length
# calculate
for i in range(V):
dfs(i)
print((max(dp) + 1))
resolve()
| false | 2.272727 | [
"- # あとは頂点VのグラフをdfsしてLongest pathの長さを求める",
"+ # 頂点数Vの有向グラフをdfsしてLongest pathの長さを求める",
"- flag = True",
"- global flag",
"+ if dp[v] >= 0:",
"+ return",
"- print((max(dp) + 1 if (flag) else -1))",
"+ print((max(dp) + 1))"
] | false | 0.038561 | 0.112909 | 0.341521 | [
"s345972416",
"s327833870"
] |
u952708174 | p04031 | python | s445165323 | s459335856 | 19 | 17 | 3,188 | 3,060 | Accepted | Accepted | 10.53 | def c_be_together(N, A):
a_sum = sum(A)
option = (a_sum // N, (a_sum + N - 1) // N)
ans = float('inf')
for opt in option:
ans = min(ans, sum([(a - opt)**2 for a in A]))
return ans
N = int(eval(input()))
A = [int(i) for i in input().split()]
print((c_be_together(N, A))) | def c_be_together(N, A):
a_sum = sum(A)
option = (a_sum // N, (a_sum + N - 1) // N) # 平均値の小数切り捨て|切り上げ
ans = min(sum([(a - opt)**2 for a in A]) for opt in option) # コストを計算
return ans
N = int(eval(input()))
A = [int(i) for i in input().split()]
print((c_be_together(N, A))) | 11 | 9 | 300 | 290 | def c_be_together(N, A):
a_sum = sum(A)
option = (a_sum // N, (a_sum + N - 1) // N)
ans = float("inf")
for opt in option:
ans = min(ans, sum([(a - opt) ** 2 for a in A]))
return ans
N = int(eval(input()))
A = [int(i) for i in input().split()]
print((c_be_together(N, A)))
| def c_be_together(N, A):
a_sum = sum(A)
option = (a_sum // N, (a_sum + N - 1) // N) # 平均値の小数切り捨て|切り上げ
ans = min(sum([(a - opt) ** 2 for a in A]) for opt in option) # コストを計算
return ans
N = int(eval(input()))
A = [int(i) for i in input().split()]
print((c_be_together(N, A)))
| false | 18.181818 | [
"- option = (a_sum // N, (a_sum + N - 1) // N)",
"- ans = float(\"inf\")",
"- for opt in option:",
"- ans = min(ans, sum([(a - opt) ** 2 for a in A]))",
"+ option = (a_sum // N, (a_sum + N - 1) // N) # 平均値の小数切り捨て|切り上げ",
"+ ans = min(sum([(a - opt) ** 2 for a in A]) for opt in option) # コストを計算"
] | false | 0.123157 | 0.040725 | 3.024127 | [
"s445165323",
"s459335856"
] |
u667024514 | p03264 | python | s808893982 | s009347869 | 20 | 17 | 3,316 | 2,940 | Accepted | Accepted | 15 | import math
n = int(eval(input()))
if n % 2 == 1:
print((math.floor(n/2) * math.ceil(n/2)))
else:
print((int(n/2) ** 2)) | import math
n = int(eval(input()))
print((int(math.floor(n/2) * math.ceil(n/2)))) | 6 | 3 | 119 | 75 | import math
n = int(eval(input()))
if n % 2 == 1:
print((math.floor(n / 2) * math.ceil(n / 2)))
else:
print((int(n / 2) ** 2))
| import math
n = int(eval(input()))
print((int(math.floor(n / 2) * math.ceil(n / 2))))
| false | 50 | [
"-if n % 2 == 1:",
"- print((math.floor(n / 2) * math.ceil(n / 2)))",
"-else:",
"- print((int(n / 2) ** 2))",
"+print((int(math.floor(n / 2) * math.ceil(n / 2))))"
] | false | 0.03688 | 0.065768 | 0.560766 | [
"s808893982",
"s009347869"
] |
u903629757 | p02621 | python | s343101779 | s285023866 | 32 | 28 | 9,136 | 9,048 | Accepted | Accepted | 12.5 | a = eval(input())
b = int(a)
print((b+b**2+b**3))
| a=int(eval(input()))
print((a+a**2+a**3)) | 3 | 2 | 44 | 34 | a = eval(input())
b = int(a)
print((b + b**2 + b**3))
| a = int(eval(input()))
print((a + a**2 + a**3))
| false | 33.333333 | [
"-a = eval(input())",
"-b = int(a)",
"-print((b + b**2 + b**3))",
"+a = int(eval(input()))",
"+print((a + a**2 + a**3))"
] | false | 0.045643 | 0.044984 | 1.014646 | [
"s343101779",
"s285023866"
] |
u150984829 | p00009 | python | s810998351 | s155450424 | 290 | 170 | 15,016 | 15,012 | Accepted | Accepted | 41.38 | import sys
a=[True]*500000
for i in range(3,999,2):
if a[i//2]:a[(i*i)//2::i]=[False]*len(a[(i*i)//2::i])
for e in map(int,sys.stdin):print(([e-1,sum(a[:(e+1)//2])][e>3]))
| import sys
a=[1]*500000
for i in range(3,999,2):
if a[i//2]:a[(i*i)//2::i]=[0]*len(a[(i*i)//2::i])
[print([e-1,sum(a[:(e+1)//2])][e>3])for e in map(int,sys.stdin)]
| 5 | 5 | 175 | 169 | import sys
a = [True] * 500000
for i in range(3, 999, 2):
if a[i // 2]:
a[(i * i) // 2 :: i] = [False] * len(a[(i * i) // 2 :: i])
for e in map(int, sys.stdin):
print(([e - 1, sum(a[: (e + 1) // 2])][e > 3]))
| import sys
a = [1] * 500000
for i in range(3, 999, 2):
if a[i // 2]:
a[(i * i) // 2 :: i] = [0] * len(a[(i * i) // 2 :: i])
[print([e - 1, sum(a[: (e + 1) // 2])][e > 3]) for e in map(int, sys.stdin)]
| false | 0 | [
"-a = [True] * 500000",
"+a = [1] * 500000",
"- a[(i * i) // 2 :: i] = [False] * len(a[(i * i) // 2 :: i])",
"-for e in map(int, sys.stdin):",
"- print(([e - 1, sum(a[: (e + 1) // 2])][e > 3]))",
"+ a[(i * i) // 2 :: i] = [0] * len(a[(i * i) // 2 :: i])",
"+[print([e - 1, sum(a[: (e + 1) // 2])][e > 3]) for e in map(int, sys.stdin)]"
] | false | 0.059827 | 0.062 | 0.96495 | [
"s810998351",
"s155450424"
] |
u502731482 | p03944 | python | s086377064 | s890828294 | 50 | 18 | 3,188 | 3,064 | Accepted | Accepted | 64 |
w, h, n = list(map(int, input().split()))
x, y, a = [0] * n, [0] * n, [0] * n
for i in range(n):
x[i], y[i], a[i] = list(map(int, input().split()))
fill_area = [[0] * w for _ in range(h)]
def fill(l, r, d, u, area):
for i in range(d, u):
for j in range(l, r):
if area[i][j] == 0:
area[i][j] = 1
for i in range(n):
if a[i] == 1:
fill(0, x[i], 0, h, fill_area)
elif a[i] == 2:
fill(x[i], w, 0, h, fill_area)
elif a[i] == 3:
fill(0, w, h - y[i], h, fill_area)
else:
fill(0, w, 0, h - y[i], fill_area)
"""
for j in range(h):
print(fill_area[j])
print()
"""
#print(sum(map(sum, fill_area)))
print((h * w - sum(map(sum, fill_area)))) | w, h, n = list(map(int, input().split()))
x, y, a = [0] * n, [0] * n, [0] * n
for i in range(n):
x[i], y[i], a[i] = list(map(int, input().split()))
start, end = [0, 0], [w, h]
for i in range(n):
if a[i] == 1 and x[i] > start[0]:
start[0] = x[i]
elif a[i] == 2 and x[i] < end[0]:
end[0] = x[i]
elif a[i] == 3 and start[1] < y[i]:
start[1] = y[i]
elif a[i] == 4 and end[1] > y[i]:
end[1] = y[i]
if (end[0] - start[0]) <= 0 or (end[1] - start[1]) <= 0:
print((0))
else:
print(( (end[0] - start[0]) * (end[1] - start[1]))) | 32 | 23 | 779 | 594 | w, h, n = list(map(int, input().split()))
x, y, a = [0] * n, [0] * n, [0] * n
for i in range(n):
x[i], y[i], a[i] = list(map(int, input().split()))
fill_area = [[0] * w for _ in range(h)]
def fill(l, r, d, u, area):
for i in range(d, u):
for j in range(l, r):
if area[i][j] == 0:
area[i][j] = 1
for i in range(n):
if a[i] == 1:
fill(0, x[i], 0, h, fill_area)
elif a[i] == 2:
fill(x[i], w, 0, h, fill_area)
elif a[i] == 3:
fill(0, w, h - y[i], h, fill_area)
else:
fill(0, w, 0, h - y[i], fill_area)
"""
for j in range(h):
print(fill_area[j])
print()
"""
# print(sum(map(sum, fill_area)))
print((h * w - sum(map(sum, fill_area))))
| w, h, n = list(map(int, input().split()))
x, y, a = [0] * n, [0] * n, [0] * n
for i in range(n):
x[i], y[i], a[i] = list(map(int, input().split()))
start, end = [0, 0], [w, h]
for i in range(n):
if a[i] == 1 and x[i] > start[0]:
start[0] = x[i]
elif a[i] == 2 and x[i] < end[0]:
end[0] = x[i]
elif a[i] == 3 and start[1] < y[i]:
start[1] = y[i]
elif a[i] == 4 and end[1] > y[i]:
end[1] = y[i]
if (end[0] - start[0]) <= 0 or (end[1] - start[1]) <= 0:
print((0))
else:
print(((end[0] - start[0]) * (end[1] - start[1])))
| false | 28.125 | [
"-fill_area = [[0] * w for _ in range(h)]",
"-",
"-",
"-def fill(l, r, d, u, area):",
"- for i in range(d, u):",
"- for j in range(l, r):",
"- if area[i][j] == 0:",
"- area[i][j] = 1",
"-",
"-",
"+start, end = [0, 0], [w, h]",
"- if a[i] == 1:",
"- fill(0, x[i], 0, h, fill_area)",
"- elif a[i] == 2:",
"- fill(x[i], w, 0, h, fill_area)",
"- elif a[i] == 3:",
"- fill(0, w, h - y[i], h, fill_area)",
"- else:",
"- fill(0, w, 0, h - y[i], fill_area)",
"- \"\"\"",
"- for j in range(h):",
"- print(fill_area[j])",
"- print()",
"- \"\"\"",
"-# print(sum(map(sum, fill_area)))",
"-print((h * w - sum(map(sum, fill_area))))",
"+ if a[i] == 1 and x[i] > start[0]:",
"+ start[0] = x[i]",
"+ elif a[i] == 2 and x[i] < end[0]:",
"+ end[0] = x[i]",
"+ elif a[i] == 3 and start[1] < y[i]:",
"+ start[1] = y[i]",
"+ elif a[i] == 4 and end[1] > y[i]:",
"+ end[1] = y[i]",
"+if (end[0] - start[0]) <= 0 or (end[1] - start[1]) <= 0:",
"+ print((0))",
"+else:",
"+ print(((end[0] - start[0]) * (end[1] - start[1])))"
] | false | 0.041101 | 0.036709 | 1.119638 | [
"s086377064",
"s890828294"
] |
u102461423 | p03008 | python | s221075477 | s769333753 | 993 | 186 | 228,508 | 39,664 | Accepted | Accepted | 81.27 | import sys
input = sys.stdin.readline
def F(N,A,B):
# n 個のどんぐりを持っている
# a個がbの価値に変換できる
AB = [(x,y) for x,y in zip(A,B) if x < y]
dp = [0] * (N+1)
for n in range(N+1):
x = n
for a,b in AB:
if n >= a:
y = dp[n-a] + b
if x < y:
x = y
dp[n] = x
return dp[N]
N = int(eval(input()))
A = [int(x) for x in input().split()]
B = [int(x) for x in input().split()]
answer = F(F(N,A,B),B,A)
print(answer) | import sys
input = sys.stdin.readline
def F(N,A,B):
AB = list(zip(A,B))
AB = [(a,b) for a,b in AB if a < b] # 有用なやつだけ
AB.sort(key = lambda x: x[1]/x[0], reverse = True)
if len(AB) == 0:
return N
if len(AB) == 1:
a,b = AB[0]
x = N//a
return N + (b-a) * x
if len(AB) == 2:
(a,b),(c,d) = AB
# 2種類目の硬価はa回未満しか使わない：ac個はa優先なので
return max(N + (N - i * c) // a * (b-a) + i * (d-c) for i in range(a))
# 効率の良いものから並んでいる
dp = [0] * (N+1)
for n in range(N+1):
x = n
for a,b in AB:
if n >= a:
y = dp[n-a] + b
if x < y:
x = y
dp[n] = x
return dp[N]
N = int(eval(input()))
A = [int(x) for x in input().split()]
B = [int(x) for x in input().split()]
answer = F(F(N,A,B),B,A)
print(answer)
AB = [(1,2),(3,4)]
(a,b),(c,d) = AB
| 24 | 39 | 521 | 928 | import sys
input = sys.stdin.readline
def F(N, A, B):
# n 個のどんぐりを持っている
# a個がbの価値に変換できる
AB = [(x, y) for x, y in zip(A, B) if x < y]
dp = [0] * (N + 1)
for n in range(N + 1):
x = n
for a, b in AB:
if n >= a:
y = dp[n - a] + b
if x < y:
x = y
dp[n] = x
return dp[N]
N = int(eval(input()))
A = [int(x) for x in input().split()]
B = [int(x) for x in input().split()]
answer = F(F(N, A, B), B, A)
print(answer)
| import sys
input = sys.stdin.readline
def F(N, A, B):
AB = list(zip(A, B))
AB = [(a, b) for a, b in AB if a < b] # 有用なやつだけ
AB.sort(key=lambda x: x[1] / x[0], reverse=True)
if len(AB) == 0:
return N
if len(AB) == 1:
a, b = AB[0]
x = N // a
return N + (b - a) * x
if len(AB) == 2:
(a, b), (c, d) = AB
# 2種類目の硬価はa回未満しか使わない：ac個はa優先なので
return max(N + (N - i * c) // a * (b - a) + i * (d - c) for i in range(a))
# 効率の良いものから並んでいる
dp = [0] * (N + 1)
for n in range(N + 1):
x = n
for a, b in AB:
if n >= a:
y = dp[n - a] + b
if x < y:
x = y
dp[n] = x
return dp[N]
N = int(eval(input()))
A = [int(x) for x in input().split()]
B = [int(x) for x in input().split()]
answer = F(F(N, A, B), B, A)
print(answer)
AB = [(1, 2), (3, 4)]
(a, b), (c, d) = AB
| false | 38.461538 | [
"- # n 個のどんぐりを持っている",
"- # a個がbの価値に変換できる",
"- AB = [(x, y) for x, y in zip(A, B) if x < y]",
"+ AB = list(zip(A, B))",
"+ AB = [(a, b) for a, b in AB if a < b] # 有用なやつだけ",
"+ AB.sort(key=lambda x: x[1] / x[0], reverse=True)",
"+ if len(AB) == 0:",
"+ return N",
"+ if len(AB) == 1:",
"+ a, b = AB[0]",
"+ x = N // a",
"+ return N + (b - a) * x",
"+ if len(AB) == 2:",
"+ (a, b), (c, d) = AB",
"+ # 2種類目の硬価はa回未満しか使わない：ac個はa優先なので",
"+ return max(N + (N - i * c) // a * (b - a) + i * (d - c) for i in range(a))",
"+ # 効率の良いものから並んでいる",
"+AB = [(1, 2), (3, 4)]",
"+(a, b), (c, d) = AB"
] | false | 0.036797 | 0.060962 | 0.603608 | [
"s221075477",
"s769333753"
] |
u614550445 | p03275 | python | s577292691 | s667176100 | 795 | 578 | 86,372 | 85,860 | Accepted | Accepted | 27.3 | N = int(eval(input()))
A = [int(_) for _ in input().split()]
class BIT:
# index 1~
def __init__(self, n):
self.size = n
self.tree = [0] * (n + 1)
def sum(self, i):
s = 0
while i > 0:
s += self.tree[i]
i -= i & -i
return s
def add(self, i, x):
while i <= self.size:
self.tree[i] += x
i += i & -i
def sub_problem(x):
S = [0] * (N + 1)
for i in range(N):
S[i + 1] = S[i] + 1 if A[i] >= x else S[i] - 1
geta = abs(min(S)) + 1
for i in range(N + 1):
S[i] += geta
forward = 0
bit = BIT(max(S))
for s in S:
forward += bit.sum(s)
bit.add(s, 1)
return forward >= M // 2 # TEST これだと通らないはず
M = N * (N + 1) // 2 # (N+1)C2
sorted_A = sorted(A)
inf = 0
sup = N
while sup - inf > 1:
mid = (sup + inf) // 2
x = sorted_A[mid]
if sub_problem(x):
inf = mid
else:
sup = mid
print((sorted_A[inf]))
| N = int(eval(input()))
A = [int(_) for _ in input().split()]
def sub_problem(x):
S = [0] * (N + 1)
for i in range(N):
S[i + 1] = S[i] + 1 if A[i] >= x else S[i] - 1
geta = abs(min(S)) + 1
for i in range(N + 1):
S[i] += geta
forward = 0
size = max(S)
bit = [0] * (size + 1)
for s in S:
i = s
while i > 0:
forward += bit[i]
i -= i & -i
i = s
while i <= size:
bit[i] += 1
i += i & -i
return forward >= (M + 1) // 2
M = N * (N + 1) // 2 # (N+1)C2
sorted_A = sorted(A)
inf = 0
sup = N
while sup - inf > 1:
mid = (sup + inf) // 2
x = sorted_A[mid]
if sub_problem(x):
inf = mid
else:
sup = mid
print((sorted_A[inf]))
| 53 | 45 | 1,041 | 822 | N = int(eval(input()))
A = [int(_) for _ in input().split()]
class BIT:
# index 1~
def __init__(self, n):
self.size = n
self.tree = [0] * (n + 1)
def sum(self, i):
s = 0
while i > 0:
s += self.tree[i]
i -= i & -i
return s
def add(self, i, x):
while i <= self.size:
self.tree[i] += x
i += i & -i
def sub_problem(x):
S = [0] * (N + 1)
for i in range(N):
S[i + 1] = S[i] + 1 if A[i] >= x else S[i] - 1
geta = abs(min(S)) + 1
for i in range(N + 1):
S[i] += geta
forward = 0
bit = BIT(max(S))
for s in S:
forward += bit.sum(s)
bit.add(s, 1)
return forward >= M // 2 # TEST これだと通らないはず
M = N * (N + 1) // 2 # (N+1)C2
sorted_A = sorted(A)
inf = 0
sup = N
while sup - inf > 1:
mid = (sup + inf) // 2
x = sorted_A[mid]
if sub_problem(x):
inf = mid
else:
sup = mid
print((sorted_A[inf]))
| N = int(eval(input()))
A = [int(_) for _ in input().split()]
def sub_problem(x):
S = [0] * (N + 1)
for i in range(N):
S[i + 1] = S[i] + 1 if A[i] >= x else S[i] - 1
geta = abs(min(S)) + 1
for i in range(N + 1):
S[i] += geta
forward = 0
size = max(S)
bit = [0] * (size + 1)
for s in S:
i = s
while i > 0:
forward += bit[i]
i -= i & -i
i = s
while i <= size:
bit[i] += 1
i += i & -i
return forward >= (M + 1) // 2
M = N * (N + 1) // 2 # (N+1)C2
sorted_A = sorted(A)
inf = 0
sup = N
while sup - inf > 1:
mid = (sup + inf) // 2
x = sorted_A[mid]
if sub_problem(x):
inf = mid
else:
sup = mid
print((sorted_A[inf]))
| false | 15.09434 | [
"-",
"-",
"-class BIT:",
"- # index 1~",
"- def __init__(self, n):",
"- self.size = n",
"- self.tree = [0] * (n + 1)",
"-",
"- def sum(self, i):",
"- s = 0",
"- while i > 0:",
"- s += self.tree[i]",
"- i -= i & -i",
"- return s",
"-",
"- def add(self, i, x):",
"- while i <= self.size:",
"- self.tree[i] += x",
"- i += i & -i",
"- bit = BIT(max(S))",
"+ size = max(S)",
"+ bit = [0] * (size + 1)",
"- forward += bit.sum(s)",
"- bit.add(s, 1)",
"- return forward >= M // 2 # TEST これだと通らないはず",
"+ i = s",
"+ while i > 0:",
"+ forward += bit[i]",
"+ i -= i & -i",
"+ i = s",
"+ while i <= size:",
"+ bit[i] += 1",
"+ i += i & -i",
"+ return forward >= (M + 1) // 2"
] | false | 0.047269 | 0.007054 | 6.701332 | [
"s577292691",
"s667176100"
] |
u540761833 | p03338 | python | s933933860 | s220742724 | 22 | 17 | 3,316 | 2,940 | Accepted | Accepted | 22.73 | from collections import Counter
N = int(eval(input()))
S = eval(input())
array = []
for i in range(1,N):
S1 = list(S[:i])
S2 = list(S[i:])
S1c = Counter(S1)
S2c = Counter(S2)
suma = 0
for k in S1c:
if k in S2c:
suma += 1
array.append(suma)
print((max(array))) | N = int(eval(input()))
S = eval(input())
ans = 0
for i in range(1,N):
a = set(S[:i])
b = set(S[i:])
ans = max(ans,len(a&b))
print(ans)
| 15 | 9 | 307 | 148 | from collections import Counter
N = int(eval(input()))
S = eval(input())
array = []
for i in range(1, N):
S1 = list(S[:i])
S2 = list(S[i:])
S1c = Counter(S1)
S2c = Counter(S2)
suma = 0
for k in S1c:
if k in S2c:
suma += 1
array.append(suma)
print((max(array)))
| N = int(eval(input()))
S = eval(input())
ans = 0
for i in range(1, N):
a = set(S[:i])
b = set(S[i:])
ans = max(ans, len(a & b))
print(ans)
| false | 40 | [
"-from collections import Counter",
"-",
"-array = []",
"+ans = 0",
"- S1 = list(S[:i])",
"- S2 = list(S[i:])",
"- S1c = Counter(S1)",
"- S2c = Counter(S2)",
"- suma = 0",
"- for k in S1c:",
"- if k in S2c:",
"- suma += 1",
"- array.append(suma)",
"-print((max(array)))",
"+ a = set(S[:i])",
"+ b = set(S[i:])",
"+ ans = max(ans, len(a & b))",
"+print(ans)"
] | false | 0.078563 | 0.078255 | 1.003936 | [
"s933933860",
"s220742724"
] |
u525065967 | p02632 | python | s680533778 | s868518428 | 1,882 | 1,411 | 226,804 | 226,844 | Accepted | Accepted | 25.03 | k = int(eval(input()))
s = eval(input())
# nCr(n, r, m)
mod = 1000000007
n = len(s) + k
fac = [1,1] # 階乗 n!
inv = [0,1] # 逆元 1/n
finv = [1,1] # 逆元の階乗 (n^-1)! = (1/n)!
for i in range(2, n+1):
fac.append( (fac[-1] * i ) % mod )
inv.append( (-inv[mod%i] * (mod//i)) % mod )
finv.append( (finv[-1] * inv[-1]) % mod )
def nCr(n, r, m):
if (n<0 or r<0 or n<r): return 0
r = min(r, n-r)
return fac[n] * finv[n-r] * finv[r] % m
# a^n mod m
def modpow(a, n, m):
x = 1
while n > 0:
if n & 1: x *= a
a *= a; a %= m
n >>= 1
return x
n = len(s)
ans = 0
for i in range(k+1):
a = modpow(25, i, mod)
b = modpow(26, k-i, mod)
c = nCr(n-1+i, n-1, mod)
ans += a * b * c
ans %= mod
print(ans)
| k = int(eval(input()))
s = eval(input())
# nCr(n, r, m)
mod = 1000000007
n = len(s) + k
fac = [1,1] # 階乗 n!
inv = [0,1] # 逆元 1/n
finv = [1,1] # 逆元の階乗 (n^-1)! = (1/n)!
for i in range(2, n+1):
fac.append( (fac[-1] * i ) % mod )
inv.append( (-inv[mod%i] * (mod//i)) % mod )
finv.append( (finv[-1] * inv[-1]) % mod )
def nCr(n, r, m):
if (n<0 or r<0 or n<r): return 0
r = min(r, n-r)
return fac[n] * finv[n-r] * finv[r] % m
# a^n mod m
def modpow(a, n, m):
x = 1
while n > 0:
if n & 1: x = x * a % m
a = a * a % m
n >>= 1
return x
n = len(s)
ans = 0
for i in range(k+1):
ans += modpow(25, i, mod) * modpow(26, k-i, mod) * nCr(i+n-1, n-1, mod)
ans %= mod
print(ans)
| 39 | 36 | 785 | 758 | k = int(eval(input()))
s = eval(input())
# nCr(n, r, m)
mod = 1000000007
n = len(s) + k
fac = [1, 1] # 階乗 n!
inv = [0, 1] # 逆元 1/n
finv = [1, 1] # 逆元の階乗 (n^-1)! = (1/n)!
for i in range(2, n + 1):
fac.append((fac[-1] * i) % mod)
inv.append((-inv[mod % i] * (mod // i)) % mod)
finv.append((finv[-1] * inv[-1]) % mod)
def nCr(n, r, m):
if n < 0 or r < 0 or n < r:
return 0
r = min(r, n - r)
return fac[n] * finv[n - r] * finv[r] % m
# a^n mod m
def modpow(a, n, m):
x = 1
while n > 0:
if n & 1:
x *= a
a *= a
a %= m
n >>= 1
return x
n = len(s)
ans = 0
for i in range(k + 1):
a = modpow(25, i, mod)
b = modpow(26, k - i, mod)
c = nCr(n - 1 + i, n - 1, mod)
ans += a * b * c
ans %= mod
print(ans)
| k = int(eval(input()))
s = eval(input())
# nCr(n, r, m)
mod = 1000000007
n = len(s) + k
fac = [1, 1] # 階乗 n!
inv = [0, 1] # 逆元 1/n
finv = [1, 1] # 逆元の階乗 (n^-1)! = (1/n)!
for i in range(2, n + 1):
fac.append((fac[-1] * i) % mod)
inv.append((-inv[mod % i] * (mod // i)) % mod)
finv.append((finv[-1] * inv[-1]) % mod)
def nCr(n, r, m):
if n < 0 or r < 0 or n < r:
return 0
r = min(r, n - r)
return fac[n] * finv[n - r] * finv[r] % m
# a^n mod m
def modpow(a, n, m):
x = 1
while n > 0:
if n & 1:
x = x * a % m
a = a * a % m
n >>= 1
return x
n = len(s)
ans = 0
for i in range(k + 1):
ans += modpow(25, i, mod) * modpow(26, k - i, mod) * nCr(i + n - 1, n - 1, mod)
ans %= mod
print(ans)
| false | 7.692308 | [
"- x *= a",
"- a *= a",
"- a %= m",
"+ x = x * a % m",
"+ a = a * a % m",
"- a = modpow(25, i, mod)",
"- b = modpow(26, k - i, mod)",
"- c = nCr(n - 1 + i, n - 1, mod)",
"- ans += a * b * c",
"+ ans += modpow(25, i, mod) * modpow(26, k - i, mod) * nCr(i + n - 1, n - 1, mod)"
] | false | 0.100312 | 0.048907 | 2.051084 | [
"s680533778",
"s868518428"
] |
u740267532 | p02694 | python | s961051512 | s720938343 | 25 | 22 | 9,164 | 9,168 | Accepted | Accepted | 12 | import math
X = int(eval(input()))
a, b = 100, 1
while 1:
a += math.floor(a * 0.01)
if a >= X:
print(b)
break
b += 1 | import math
X = int(eval(input()))
a, b = 100, 1
while 1:
a += int(a * 0.01)
if a >= X:
print(b)
break
b += 1 | 9 | 9 | 146 | 139 | import math
X = int(eval(input()))
a, b = 100, 1
while 1:
a += math.floor(a * 0.01)
if a >= X:
print(b)
break
b += 1
| import math
X = int(eval(input()))
a, b = 100, 1
while 1:
a += int(a * 0.01)
if a >= X:
print(b)
break
b += 1
| false | 0 | [
"- a += math.floor(a * 0.01)",
"+ a += int(a * 0.01)"
] | false | 0.038895 | 0.03689 | 1.054341 | [
"s961051512",
"s720938343"
] |
u852690916 | p02881 | python | s069915762 | s515839434 | 420 | 150 | 3,060 | 2,940 | Accepted | Accepted | 64.29 | N = int(eval(input()))
a, b = 1, N
for n in range(2,N):
if n*n == N:
a = b = n
break
elif n*n > N:
break
elif N%n == 0:
a, b = n, N//n
print((a+b-2)) | N=int(eval(input()))
ans = 10**12
for n in range(1,int(N**0.5)+1):
if N%n==0:
ans = min(ans, n + N//n - 2)
print(ans) | 13 | 6 | 199 | 128 | N = int(eval(input()))
a, b = 1, N
for n in range(2, N):
if n * n == N:
a = b = n
break
elif n * n > N:
break
elif N % n == 0:
a, b = n, N // n
print((a + b - 2))
| N = int(eval(input()))
ans = 10**12
for n in range(1, int(N**0.5) + 1):
if N % n == 0:
ans = min(ans, n + N // n - 2)
print(ans)
| false | 53.846154 | [
"-a, b = 1, N",
"-for n in range(2, N):",
"- if n * n == N:",
"- a = b = n",
"- break",
"- elif n * n > N:",
"- break",
"- elif N % n == 0:",
"- a, b = n, N // n",
"-print((a + b - 2))",
"+ans = 10**12",
"+for n in range(1, int(N**0.5) + 1):",
"+ if N % n == 0:",
"+ ans = min(ans, n + N // n - 2)",
"+print(ans)"
] | false | 0.044785 | 0.045756 | 0.978773 | [
"s069915762",
"s515839434"
] |
u539367121 | p02900 | python | s662080238 | s887644948 | 88 | 69 | 9,192 | 9,460 | Accepted | Accepted | 21.59 | import math
a,b=list(map(int,input().split()))
gcd=math.gcd(a,b)
def prime_factorization(n):
i=2
prime=[]
if n%i==0:
n//=i
prime.append(2)
while n%i==0:
n//=i
i+=1
while i*i<=n:
if n%i:
i+=2
else:
n//=i
prime.append(i)
while n%i==0:
n//=i
if n>1:
prime.append(n)
return prime
print((len(prime_factorization(gcd))+1)) | import math
a,b=list(map(int,input().split()))
gcd=math.gcd(a,b)
def prime_factorization(n):
i=2
prime=[]
if n%i==0:
n//=i
prime.append(2)
while n%i==0:
n//=i
i+=1
k=int(n**0.5)+1
for j in range(i,k+1,2):
if n%j==0:
n//=j
prime.append(j)
while n%j==0:
n//=j
if n>1:
prime.append(n)
return prime
print((len(prime_factorization(gcd))+1)) | 26 | 25 | 411 | 421 | import math
a, b = list(map(int, input().split()))
gcd = math.gcd(a, b)
def prime_factorization(n):
i = 2
prime = []
if n % i == 0:
n //= i
prime.append(2)
while n % i == 0:
n //= i
i += 1
while i * i <= n:
if n % i:
i += 2
else:
n //= i
prime.append(i)
while n % i == 0:
n //= i
if n > 1:
prime.append(n)
return prime
print((len(prime_factorization(gcd)) + 1))
| import math
a, b = list(map(int, input().split()))
gcd = math.gcd(a, b)
def prime_factorization(n):
i = 2
prime = []
if n % i == 0:
n //= i
prime.append(2)
while n % i == 0:
n //= i
i += 1
k = int(n**0.5) + 1
for j in range(i, k + 1, 2):
if n % j == 0:
n //= j
prime.append(j)
while n % j == 0:
n //= j
if n > 1:
prime.append(n)
return prime
print((len(prime_factorization(gcd)) + 1))
| false | 3.846154 | [
"- while i * i <= n:",
"- if n % i:",
"- i += 2",
"- else:",
"- n //= i",
"- prime.append(i)",
"- while n % i == 0:",
"- n //= i",
"+ k = int(n**0.5) + 1",
"+ for j in range(i, k + 1, 2):",
"+ if n % j == 0:",
"+ n //= j",
"+ prime.append(j)",
"+ while n % j == 0:",
"+ n //= j"
] | false | 0.056885 | 0.035001 | 1.625218 | [
"s662080238",
"s887644948"
] |
u389910364 | p03108 | python | s912134989 | s391377482 | 1,063 | 819 | 55,956 | 50,088 | Accepted | Accepted | 22.95 | class UnionFind:
def __init__(self, nodes):
self._parents = {k: k for k in nodes}
self._ranks = {k: 0 for k in nodes}
self._sizes = {k: 1 for k in nodes}
def union(self, x, y):
"""
x が属する木と y が属する木を併合
:param x:
:param y:
:return:
"""
x = self.find(x)
y = self.find(y)
if x != y:
# rank が小さい方が下
if self._ranks[x] > self._ranks[y]:
self._parents[y] = x
self._sizes[x] += self._sizes[y]
else:
self._parents[x] = y
self._sizes[y] += self._sizes[x]
if self._ranks[x] == self._ranks[y]:
self._ranks[y] += 1
def find(self, x):
"""
x が属する木の root
:param x:
:return:
"""
if self._parents[x] == x:
return x
self._parents[x] = self.find(self._parents[x])
return self._parents[x]
def size(self, x):
"""
x が属する木のノード数
:param x:
:return:
"""
return self._sizes[self.find(x)]
n, m = list(map(int, input().split()))
bridges = []
for _ in range(m):
bridges.append(list(map(int, input().split())))
def c2(n):
# n から2個選ぶ組み合わせ nC2
return int(n * (n - 1) / 2)
bridges.reverse()
uf = UnionFind(nodes=[i + 1 for i in range(n)])
# 便利さ; つながってる島の組み合わせの数
useful = 0
useful_history = []
for bridge in bridges:
useful_history.append(useful)
if uf.find(bridge[0]) != uf.find(bridge[1]):
# 新しくつながったので便利さを更新
size0 = uf.size(bridge[0])
size1 = uf.size(bridge[1])
useful += c2(size0 + size1) - c2(size0) - c2(size1)
uf.union(bridge[0], bridge[1])
for u in reversed(useful_history):
print((useful - u))
| import bisect
import cmath
import heapq
import itertools
import math
import operator
import os
import re
import string
import sys
from collections import Counter, deque, defaultdict
from copy import deepcopy
from decimal import Decimal
from fractions import gcd
from functools import lru_cache, reduce
from operator import itemgetter, mul, add, xor
import numpy as np
if os.getenv("LOCAL"):
sys.stdin = open("_in.txt", "r")
sys.setrecursionlimit(10 ** 9)
INF = float("inf")
IINF = 10 ** 18
MOD = 10 ** 9 + 7
# MOD = 998244353
class UnionFind:
def __init__(self, size=None, nodes=None):
"""
size か nodes どっちか指定。
nodes は set、size は list を使う。
set の最悪計算量は O(N) なので size 指定のほうが若干速い
:param int size:
:param collections.Iterable nodes:
"""
assert size is not None or nodes is not None
if size is not None:
self._parents = [i for i in range(size)]
self._ranks = [0 for _ in range(size)]
self._sizes = [1 for _ in range(size)]
else:
self._parents = {k: k for k in nodes}
self._ranks = {k: 0 for k in nodes}
self._sizes = {k: 1 for k in nodes}
def unite(self, x, y):
"""
x が属する木と y が属する木を併合
:param x:
:param y:
:return:
"""
x = self.root(x)
y = self.root(y)
if x == y:
return
# rank が小さい方が下
if self._ranks[x] > self._ranks[y]:
# x が root
self._parents[y] = x
self._sizes[x] += self._sizes[y]
else:
# y が root
self._parents[x] = y
self._sizes[y] += self._sizes[x]
if self._ranks[x] == self._ranks[y]:
self._ranks[y] += 1
def root(self, x):
"""
x が属する木の root
:param x:
:return:
"""
if self._parents[x] == x:
return x
self._parents[x] = self.root(self._parents[x])
return self._parents[x]
def size(self, x):
"""
x が属する木のノード数
:param x:
:return:
"""
return self._sizes[self.root(x)]
N, M = list(map(int, sys.stdin.buffer.readline().split()))
AB = [list(map(int, sys.stdin.buffer.readline().split())) for _ in range(M)]
AB.reverse()
uf = UnionFind(size=N)
ans = (N - 1) * N // 2
hist = []
for a, b in AB:
a -= 1
b -= 1
hist.append(ans)
if uf.root(a) != uf.root(b):
ans -= uf.size(a) * uf.size(b)
uf.unite(a, b)
hist.reverse()
print(*hist, sep='\n')
| 76 | 110 | 1,882 | 2,692 | class UnionFind:
def __init__(self, nodes):
self._parents = {k: k for k in nodes}
self._ranks = {k: 0 for k in nodes}
self._sizes = {k: 1 for k in nodes}
def union(self, x, y):
"""
x が属する木と y が属する木を併合
:param x:
:param y:
:return:
"""
x = self.find(x)
y = self.find(y)
if x != y:
# rank が小さい方が下
if self._ranks[x] > self._ranks[y]:
self._parents[y] = x
self._sizes[x] += self._sizes[y]
else:
self._parents[x] = y
self._sizes[y] += self._sizes[x]
if self._ranks[x] == self._ranks[y]:
self._ranks[y] += 1
def find(self, x):
"""
x が属する木の root
:param x:
:return:
"""
if self._parents[x] == x:
return x
self._parents[x] = self.find(self._parents[x])
return self._parents[x]
def size(self, x):
"""
x が属する木のノード数
:param x:
:return:
"""
return self._sizes[self.find(x)]
n, m = list(map(int, input().split()))
bridges = []
for _ in range(m):
bridges.append(list(map(int, input().split())))
def c2(n):
# n から2個選ぶ組み合わせ nC2
return int(n * (n - 1) / 2)
bridges.reverse()
uf = UnionFind(nodes=[i + 1 for i in range(n)])
# 便利さ; つながってる島の組み合わせの数
useful = 0
useful_history = []
for bridge in bridges:
useful_history.append(useful)
if uf.find(bridge[0]) != uf.find(bridge[1]):
# 新しくつながったので便利さを更新
size0 = uf.size(bridge[0])
size1 = uf.size(bridge[1])
useful += c2(size0 + size1) - c2(size0) - c2(size1)
uf.union(bridge[0], bridge[1])
for u in reversed(useful_history):
print((useful - u))
| import bisect
import cmath
import heapq
import itertools
import math
import operator
import os
import re
import string
import sys
from collections import Counter, deque, defaultdict
from copy import deepcopy
from decimal import Decimal
from fractions import gcd
from functools import lru_cache, reduce
from operator import itemgetter, mul, add, xor
import numpy as np
if os.getenv("LOCAL"):
sys.stdin = open("_in.txt", "r")
sys.setrecursionlimit(10**9)
INF = float("inf")
IINF = 10**18
MOD = 10**9 + 7
# MOD = 998244353
class UnionFind:
def __init__(self, size=None, nodes=None):
"""
size か nodes どっちか指定。
nodes は set、size は list を使う。
set の最悪計算量は O(N) なので size 指定のほうが若干速い
:param int size:
:param collections.Iterable nodes:
"""
assert size is not None or nodes is not None
if size is not None:
self._parents = [i for i in range(size)]
self._ranks = [0 for _ in range(size)]
self._sizes = [1 for _ in range(size)]
else:
self._parents = {k: k for k in nodes}
self._ranks = {k: 0 for k in nodes}
self._sizes = {k: 1 for k in nodes}
def unite(self, x, y):
"""
x が属する木と y が属する木を併合
:param x:
:param y:
:return:
"""
x = self.root(x)
y = self.root(y)
if x == y:
return
# rank が小さい方が下
if self._ranks[x] > self._ranks[y]:
# x が root
self._parents[y] = x
self._sizes[x] += self._sizes[y]
else:
# y が root
self._parents[x] = y
self._sizes[y] += self._sizes[x]
if self._ranks[x] == self._ranks[y]:
self._ranks[y] += 1
def root(self, x):
"""
x が属する木の root
:param x:
:return:
"""
if self._parents[x] == x:
return x
self._parents[x] = self.root(self._parents[x])
return self._parents[x]
def size(self, x):
"""
x が属する木のノード数
:param x:
:return:
"""
return self._sizes[self.root(x)]
N, M = list(map(int, sys.stdin.buffer.readline().split()))
AB = [list(map(int, sys.stdin.buffer.readline().split())) for _ in range(M)]
AB.reverse()
uf = UnionFind(size=N)
ans = (N - 1) * N // 2
hist = []
for a, b in AB:
a -= 1
b -= 1
hist.append(ans)
if uf.root(a) != uf.root(b):
ans -= uf.size(a) * uf.size(b)
uf.unite(a, b)
hist.reverse()
print(*hist, sep="\n")
| false | 30.909091 | [
"+import bisect",
"+import cmath",
"+import heapq",
"+import itertools",
"+import math",
"+import operator",
"+import os",
"+import re",
"+import string",
"+import sys",
"+from collections import Counter, deque, defaultdict",
"+from copy import deepcopy",
"+from decimal import Decimal",
"+from fractions import gcd",
"+from functools import lru_cache, reduce",
"+from operator import itemgetter, mul, add, xor",
"+import numpy as np",
"+",
"+if os.getenv(\"LOCAL\"):",
"+ sys.stdin = open(\"_in.txt\", \"r\")",
"+sys.setrecursionlimit(10**9)",
"+INF = float(\"inf\")",
"+IINF = 10**18",
"+MOD = 10**9 + 7",
"+# MOD = 998244353",
"- def __init__(self, nodes):",
"- self._parents = {k: k for k in nodes}",
"- self._ranks = {k: 0 for k in nodes}",
"- self._sizes = {k: 1 for k in nodes}",
"+ def __init__(self, size=None, nodes=None):",
"+ \"\"\"",
"+ size か nodes どっちか指定。",
"+ nodes は set、size は list を使う。",
"+ set の最悪計算量は O(N) なので size 指定のほうが若干速い",
"+ :param int size:",
"+ :param collections.Iterable nodes:",
"+ \"\"\"",
"+ assert size is not None or nodes is not None",
"+ if size is not None:",
"+ self._parents = [i for i in range(size)]",
"+ self._ranks = [0 for _ in range(size)]",
"+ self._sizes = [1 for _ in range(size)]",
"+ else:",
"+ self._parents = {k: k for k in nodes}",
"+ self._ranks = {k: 0 for k in nodes}",
"+ self._sizes = {k: 1 for k in nodes}",
"- def union(self, x, y):",
"+ def unite(self, x, y):",
"- x = self.find(x)",
"- y = self.find(y)",
"- if x != y:",
"- # rank が小さい方が下",
"- if self._ranks[x] > self._ranks[y]:",
"- self._parents[y] = x",
"- self._sizes[x] += self._sizes[y]",
"- else:",
"- self._parents[x] = y",
"- self._sizes[y] += self._sizes[x]",
"- if self._ranks[x] == self._ranks[y]:",
"- self._ranks[y] += 1",
"+ x = self.root(x)",
"+ y = self.root(y)",
"+ if x == y:",
"+ return",
"+ # rank が小さい方が下",
"+ if self._ranks[x] > self._ranks[y]:",
"+ # x が root",
"+ self._parents[y] = x",
"+ self._sizes[x] += self._sizes[y]",
"+ else:",
"+ # y が root",
"+ self._parents[x] = y",
"+ self._sizes[y] += self._sizes[x]",
"+ if self._ranks[x] == self._ranks[y]:",
"+ self._ranks[y] += 1",
"- def find(self, x):",
"+ def root(self, x):",
"- self._parents[x] = self.find(self._parents[x])",
"+ self._parents[x] = self.root(self._parents[x])",
"- return self._sizes[self.find(x)]",
"+ return self._sizes[self.root(x)]",
"-n, m = list(map(int, input().split()))",
"-bridges = []",
"-for _ in range(m):",
"- bridges.append(list(map(int, input().split())))",
"-",
"-",
"-def c2(n):",
"- # n から2個選ぶ組み合わせ nC2",
"- return int(n * (n - 1) / 2)",
"-",
"-",
"-bridges.reverse()",
"-uf = UnionFind(nodes=[i + 1 for i in range(n)])",
"-# 便利さ; つながってる島の組み合わせの数",
"-useful = 0",
"-useful_history = []",
"-for bridge in bridges:",
"- useful_history.append(useful)",
"- if uf.find(bridge[0]) != uf.find(bridge[1]):",
"- # 新しくつながったので便利さを更新",
"- size0 = uf.size(bridge[0])",
"- size1 = uf.size(bridge[1])",
"- useful += c2(size0 + size1) - c2(size0) - c2(size1)",
"- uf.union(bridge[0], bridge[1])",
"-for u in reversed(useful_history):",
"- print((useful - u))",
"+N, M = list(map(int, sys.stdin.buffer.readline().split()))",
"+AB = [list(map(int, sys.stdin.buffer.readline().split())) for _ in range(M)]",
"+AB.reverse()",
"+uf = UnionFind(size=N)",
"+ans = (N - 1) * N // 2",
"+hist = []",
"+for a, b in AB:",
"+ a -= 1",
"+ b -= 1",
"+ hist.append(ans)",
"+ if uf.root(a) != uf.root(b):",
"+ ans -= uf.size(a) * uf.size(b)",
"+ uf.unite(a, b)",
"+hist.reverse()",
"+print(*hist, sep=\"\\n\")"
] | false | 0.036588 | 0.043886 | 0.833694 | [
"s912134989",
"s391377482"
] |
u426250125 | p03470 | python | s292071687 | s715518603 | 30 | 27 | 9,148 | 8,964 | Accepted | Accepted | 10 | N = int(eval(input()))
d = list(set([int(eval(input())) for n in range(N)]))
print((len(d))) | N = int(eval(input()))
ans = len(set([int(eval(input())) for n in range(N)]))
print(ans) | 3 | 3 | 80 | 78 | N = int(eval(input()))
d = list(set([int(eval(input())) for n in range(N)]))
print((len(d)))
| N = int(eval(input()))
ans = len(set([int(eval(input())) for n in range(N)]))
print(ans)
| false | 0 | [
"-d = list(set([int(eval(input())) for n in range(N)]))",
"-print((len(d)))",
"+ans = len(set([int(eval(input())) for n in range(N)]))",
"+print(ans)"
] | false | 0.045677 | 0.165952 | 0.275243 | [
"s292071687",
"s715518603"
] |
u799691369 | p03212 | python | s155827510 | s711913290 | 62 | 54 | 3,060 | 3,064 | Accepted | Accepted | 12.9 | N = int(eval(input()))
def fes(cul='0'):
if int(cul) > N:
return 0
counter = 0
if "3" in cul and "5" in cul and "7" in cul:
counter += 1
counter += fes(cul + "3")
counter += fes(cul + "5")
counter += fes(cul + "7")
return counter
print((fes())) | N = int(eval(input()))
def fes(cul=0):
if cul > N:
return 0
counter = 0
if "3" in str(cul) and "5" in str(cul) and "7" in str(cul):
counter += 1
counter += fes(cul * 10 + 3)
counter += fes(cul * 10 + 5)
counter += fes(cul * 10 + 7)
return counter
print((fes())) | 15 | 16 | 298 | 317 | N = int(eval(input()))
def fes(cul="0"):
if int(cul) > N:
return 0
counter = 0
if "3" in cul and "5" in cul and "7" in cul:
counter += 1
counter += fes(cul + "3")
counter += fes(cul + "5")
counter += fes(cul + "7")
return counter
print((fes()))
| N = int(eval(input()))
def fes(cul=0):
if cul > N:
return 0
counter = 0
if "3" in str(cul) and "5" in str(cul) and "7" in str(cul):
counter += 1
counter += fes(cul * 10 + 3)
counter += fes(cul * 10 + 5)
counter += fes(cul * 10 + 7)
return counter
print((fes()))
| false | 6.25 | [
"-def fes(cul=\"0\"):",
"- if int(cul) > N:",
"+def fes(cul=0):",
"+ if cul > N:",
"- if \"3\" in cul and \"5\" in cul and \"7\" in cul:",
"+ if \"3\" in str(cul) and \"5\" in str(cul) and \"7\" in str(cul):",
"- counter += fes(cul + \"3\")",
"- counter += fes(cul + \"5\")",
"- counter += fes(cul + \"7\")",
"+ counter += fes(cul * 10 + 3)",
"+ counter += fes(cul * 10 + 5)",
"+ counter += fes(cul * 10 + 7)"
] | false | 0.054776 | 0.056387 | 0.971427 | [
"s155827510",
"s711913290"
] |
u620084012 | p03262 | python | s260457726 | s960910976 | 135 | 98 | 14,252 | 14,252 | Accepted | Accepted | 27.41 | def gcd(a,b):
if b == 0:
return a
return gcd(b,a%b)
N, S = list(map(int,input().split()))
x = list(map(int,input().split()))
x.append(S)
x = sorted(x)
t = x[1]-x[0]
for k in range(N):
t = gcd(t,x[k+1]-x[k])
print(t) | N, X = list(map(int,input().split()))
x = list(map(int,input().split()))
def gcd(a,b):
if b == 0:
return a
return gcd(b,a%b)
ans = abs(X-x[0])
for k in range(1,N):
ans = gcd(ans,abs(x[k]-x[k-1]))
print(ans)
| 15 | 12 | 246 | 234 | def gcd(a, b):
if b == 0:
return a
return gcd(b, a % b)
N, S = list(map(int, input().split()))
x = list(map(int, input().split()))
x.append(S)
x = sorted(x)
t = x[1] - x[0]
for k in range(N):
t = gcd(t, x[k + 1] - x[k])
print(t)
| N, X = list(map(int, input().split()))
x = list(map(int, input().split()))
def gcd(a, b):
if b == 0:
return a
return gcd(b, a % b)
ans = abs(X - x[0])
for k in range(1, N):
ans = gcd(ans, abs(x[k] - x[k - 1]))
print(ans)
| false | 20 | [
"+N, X = list(map(int, input().split()))",
"+x = list(map(int, input().split()))",
"+",
"+",
"-N, S = list(map(int, input().split()))",
"-x = list(map(int, input().split()))",
"-x.append(S)",
"-x = sorted(x)",
"-t = x[1] - x[0]",
"-for k in range(N):",
"- t = gcd(t, x[k + 1] - x[k])",
"-print(t)",
"+ans = abs(X - x[0])",
"+for k in range(1, N):",
"+ ans = gcd(ans, abs(x[k] - x[k - 1]))",
"+print(ans)"
] | false | 0.033137 | 0.040839 | 0.811406 | [
"s260457726",
"s960910976"
] |
u598684283 | p03587 | python | s725079027 | s512507499 | 28 | 22 | 8,960 | 8,936 | Accepted | Accepted | 21.43 | print((str(eval(input())).count("1"))) | print((input().count("1"))) | 1 | 1 | 30 | 25 | print((str(eval(input())).count("1")))
| print((input().count("1")))
| false | 0 | [
"-print((str(eval(input())).count(\"1\")))",
"+print((input().count(\"1\")))"
] | false | 0.050159 | 0.008185 | 6.128267 | [
"s725079027",
"s512507499"
] |
u925567828 | p02881 | python | s630553873 | s291167879 | 168 | 152 | 3,064 | 3,060 | Accepted | Accepted | 9.52 | import math
N = int(eval(input()))
lst =[]
#N = a*bとする。 ここで、a<=bが成り立つ。
#√a の全探索
length= math.ceil(math.sqrt(N))
for i in range(length):
if(N %(i+1) == 0):
lst.append(i+1)
a = max(lst)
b = round(N/a)
ans = a+b -2
print(ans) | import math
n = int(eval(input()))
a=0
b=0
root_n = math.sqrt(n)
#繰り上げ
root_n = math.ceil(root_n)
yakusuu =[]
for i in range(1,root_n+1):
if(n%i == 0):
yakusuu.append(i)
a = max(yakusuu)
b = n / a
print((int(a+b-2)))
| 14 | 15 | 243 | 238 | import math
N = int(eval(input()))
lst = []
# N = a*bとする。 ここで、a<=bが成り立つ。
# √a の全探索
length = math.ceil(math.sqrt(N))
for i in range(length):
if N % (i + 1) == 0:
lst.append(i + 1)
a = max(lst)
b = round(N / a)
ans = a + b - 2
print(ans)
| import math
n = int(eval(input()))
a = 0
b = 0
root_n = math.sqrt(n)
# 繰り上げ
root_n = math.ceil(root_n)
yakusuu = []
for i in range(1, root_n + 1):
if n % i == 0:
yakusuu.append(i)
a = max(yakusuu)
b = n / a
print((int(a + b - 2)))
| false | 6.666667 | [
"-N = int(eval(input()))",
"-lst = []",
"-# N = a*bとする。 ここで、a<=bが成り立つ。",
"-# √a の全探索",
"-length = math.ceil(math.sqrt(N))",
"-for i in range(length):",
"- if N % (i + 1) == 0:",
"- lst.append(i + 1)",
"-a = max(lst)",
"-b = round(N / a)",
"-ans = a + b - 2",
"-print(ans)",
"+n = int(eval(input()))",
"+a = 0",
"+b = 0",
"+root_n = math.sqrt(n)",
"+# 繰り上げ",
"+root_n = math.ceil(root_n)",
"+yakusuu = []",
"+for i in range(1, root_n + 1):",
"+ if n % i == 0:",
"+ yakusuu.append(i)",
"+a = max(yakusuu)",
"+b = n / a",
"+print((int(a + b - 2)))"
] | false | 0.049786 | 0.052823 | 0.942508 | [
"s630553873",
"s291167879"
] |
u353919145 | p03449 | python | s387495668 | s073453692 | 22 | 11 | 3,064 | 2,568 | Accepted | Accepted | 50 | length = int(eval(input()))
first = input().split(" ")
second = input().split(" ")
i = 0
sweet = 0
sugars = 0
while i < length:
j = i
k = 0
while k<=i:
sweet = sweet + int(first[k])
k = k + 1
while j < length:
sweet = sweet + int(second[j])
j = j + 1
if sweet > sugars:
sugars = sweet
sweet = 0
i = i + 1
print(sugars) | n = int(input())
t = [int(i) for i in input().split(" ")]
b = [int(i) for i in input().split(" ")]
mina = None
tot = sum(t) + sum(b)
tn = sum(t) - t[0]
bn = 0
for s in range(n):
if mina == None or mina > tn + bn:
mina = tn + bn
if s == n-1:
break
tn -= t[s+1]
bn += b[s]
print(tot - mina) | 20 | 17 | 399 | 325 | length = int(eval(input()))
first = input().split(" ")
second = input().split(" ")
i = 0
sweet = 0
sugars = 0
while i < length:
j = i
k = 0
while k <= i:
sweet = sweet + int(first[k])
k = k + 1
while j < length:
sweet = sweet + int(second[j])
j = j + 1
if sweet > sugars:
sugars = sweet
sweet = 0
i = i + 1
print(sugars)
| n = int(input())
t = [int(i) for i in input().split(" ")]
b = [int(i) for i in input().split(" ")]
mina = None
tot = sum(t) + sum(b)
tn = sum(t) - t[0]
bn = 0
for s in range(n):
if mina == None or mina > tn + bn:
mina = tn + bn
if s == n - 1:
break
tn -= t[s + 1]
bn += b[s]
print(tot - mina)
| false | 15 | [
"-length = int(eval(input()))",
"-first = input().split(\" \")",
"-second = input().split(\" \")",
"-i = 0",
"-sweet = 0",
"-sugars = 0",
"-while i < length:",
"- j = i",
"- k = 0",
"- while k <= i:",
"- sweet = sweet + int(first[k])",
"- k = k + 1",
"- while j < length:",
"- sweet = sweet + int(second[j])",
"- j = j + 1",
"- if sweet > sugars:",
"- sugars = sweet",
"- sweet = 0",
"- i = i + 1",
"-print(sugars)",
"+n = int(input())",
"+t = [int(i) for i in input().split(\" \")]",
"+b = [int(i) for i in input().split(\" \")]",
"+mina = None",
"+tot = sum(t) + sum(b)",
"+tn = sum(t) - t[0]",
"+bn = 0",
"+for s in range(n):",
"+ if mina == None or mina > tn + bn:",
"+ mina = tn + bn",
"+ if s == n - 1:",
"+ break",
"+ tn -= t[s + 1]",
"+ bn += b[s]",
"+print(tot - mina)"
] | false | 0.051987 | 0.05426 | 0.958094 | [
"s387495668",
"s073453692"
] |
u017810624 | p03346 | python | s255374290 | s666673794 | 445 | 408 | 20,532 | 18,888 | Accepted | Accepted | 8.31 | n=int(eval(input()))
p=[int(eval(input())) for i in range(n)]
l=[-1 for i in range(n)]
for i in range(n):
l[p[i]-1]=i
ans=[]
ct=1
for i in range(n-1):
if l[i]<l[i+1]:
ct+=1
else:
ans.append(ct)
ct=1
ans.append(ct)
ct=1
print((n-max(ans))) | n=int(eval(input()))
p=[int(eval(input())) for i in range(n)]
dp=[0]*n
ans=0
for i in range(n):
if p[i]!=1:
dp[p[i]-1]=dp[p[i]-2]+1
else:
dp[0]=1
print((n-max(dp))) | 16 | 10 | 257 | 171 | n = int(eval(input()))
p = [int(eval(input())) for i in range(n)]
l = [-1 for i in range(n)]
for i in range(n):
l[p[i] - 1] = i
ans = []
ct = 1
for i in range(n - 1):
if l[i] < l[i + 1]:
ct += 1
else:
ans.append(ct)
ct = 1
ans.append(ct)
ct = 1
print((n - max(ans)))
| n = int(eval(input()))
p = [int(eval(input())) for i in range(n)]
dp = [0] * n
ans = 0
for i in range(n):
if p[i] != 1:
dp[p[i] - 1] = dp[p[i] - 2] + 1
else:
dp[0] = 1
print((n - max(dp)))
| false | 37.5 | [
"-l = [-1 for i in range(n)]",
"+dp = [0] * n",
"+ans = 0",
"- l[p[i] - 1] = i",
"-ans = []",
"-ct = 1",
"-for i in range(n - 1):",
"- if l[i] < l[i + 1]:",
"- ct += 1",
"+ if p[i] != 1:",
"+ dp[p[i] - 1] = dp[p[i] - 2] + 1",
"- ans.append(ct)",
"- ct = 1",
"-ans.append(ct)",
"-ct = 1",
"-print((n - max(ans)))",
"+ dp[0] = 1",
"+print((n - max(dp)))"
] | false | 0.041167 | 0.03809 | 1.080808 | [
"s255374290",
"s666673794"
] |
u426108351 | p03557 | python | s916322833 | s357642584 | 485 | 313 | 105,572 | 22,720 | Accepted | Accepted | 35.46 | import bisect
N = int(eval(input()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = list(map(int, input().split()))
A.sort()
B.sort()
C.sort()
ans = 0
for i in range(N):
a = bisect.bisect_left(A, B[i])
c = bisect.bisect_right(C, B[i])
ans += a*(N-c)
print(ans)
| from bisect import *
n = int(eval(input()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
c = list(map(int, input().split()))
a.sort()
b.sort()
c.sort()
ans = 0
for i in range(n):
ans += bisect_left(a, b[i])*(n-bisect_right(c, b[i]))
print(ans)
| 15 | 15 | 311 | 286 | import bisect
N = int(eval(input()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = list(map(int, input().split()))
A.sort()
B.sort()
C.sort()
ans = 0
for i in range(N):
a = bisect.bisect_left(A, B[i])
c = bisect.bisect_right(C, B[i])
ans += a * (N - c)
print(ans)
| from bisect import *
n = int(eval(input()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
c = list(map(int, input().split()))
a.sort()
b.sort()
c.sort()
ans = 0
for i in range(n):
ans += bisect_left(a, b[i]) * (n - bisect_right(c, b[i]))
print(ans)
| false | 0 | [
"-import bisect",
"+from bisect import *",
"-N = int(eval(input()))",
"-A = list(map(int, input().split()))",
"-B = list(map(int, input().split()))",
"-C = list(map(int, input().split()))",
"-A.sort()",
"-B.sort()",
"-C.sort()",
"+n = int(eval(input()))",
"+a = list(map(int, input().split()))",
"+b = list(map(int, input().split()))",
"+c = list(map(int, input().split()))",
"+a.sort()",
"+b.sort()",
"+c.sort()",
"-for i in range(N):",
"- a = bisect.bisect_left(A, B[i])",
"- c = bisect.bisect_right(C, B[i])",
"- ans += a * (N - c)",
"+for i in range(n):",
"+ ans += bisect_left(a, b[i]) * (n - bisect_right(c, b[i]))"
] | false | 0.152235 | 0.040332 | 3.77458 | [
"s916322833",
"s357642584"
] |
u829203929 | p03044 | python | s975093394 | s697478585 | 636 | 541 | 39,956 | 85,952 | Accepted | Accepted | 14.94 | # coding: utf-8
from collections import deque
n = int(eval(input()))
lw = [[] for _ in range(n+1)]
for i in range(n-1):
u,v,w = list(map(int,input().split()))
lw[u].append((v,w))
lw[v].append((u,w))
#print(lw)
ans = [-1] * (n+1)
q = deque()
ans[1] = 0
q.append(1)
while q:
r = q.popleft()
prev = ans[r]
for x in lw[r]:
#print(x)
y = x[0]
if ans[y] >= 0:
continue
q.append(y)
if x[1]%2==0:
ans[y] = ans[r]
else:
ans[y] = 1 - ans[r]
for x in ans[1:]:
print(x)
| # coding: utf-8
import sys
import copy
sys.setrecursionlimit(10 ** 9)
def dfs(seen, graph, i):
for v, w in graph[i]:
if seen[v-1] != -1:
continue
seen[v-1] = abs((w % 2) - seen[i])
dfs(seen, graph, v-1)
def main():
n = int(input())
graph = [[] for _ in range(n)]
for _ in range(n-1):
ui, vi, wi = map(int, input().split())
graph[ui-1].append((vi, wi))
graph[vi-1].append((ui, wi))
seen = [-1 for _ in range(n)]
seen[0] = 0
for i in range(n-1):
dfs(seen, graph, i)
print(*seen, sep='\n')
main()
| 34 | 31 | 601 | 657 | # coding: utf-8
from collections import deque
n = int(eval(input()))
lw = [[] for _ in range(n + 1)]
for i in range(n - 1):
u, v, w = list(map(int, input().split()))
lw[u].append((v, w))
lw[v].append((u, w))
# print(lw)
ans = [-1] * (n + 1)
q = deque()
ans[1] = 0
q.append(1)
while q:
r = q.popleft()
prev = ans[r]
for x in lw[r]:
# print(x)
y = x[0]
if ans[y] >= 0:
continue
q.append(y)
if x[1] % 2 == 0:
ans[y] = ans[r]
else:
ans[y] = 1 - ans[r]
for x in ans[1:]:
print(x)
| # coding: utf-8
import sys
import copy
sys.setrecursionlimit(10**9)
def dfs(seen, graph, i):
for v, w in graph[i]:
if seen[v - 1] != -1:
continue
seen[v - 1] = abs((w % 2) - seen[i])
dfs(seen, graph, v - 1)
def main():
n = int(input())
graph = [[] for _ in range(n)]
for _ in range(n - 1):
ui, vi, wi = map(int, input().split())
graph[ui - 1].append((vi, wi))
graph[vi - 1].append((ui, wi))
seen = [-1 for _ in range(n)]
seen[0] = 0
for i in range(n - 1):
dfs(seen, graph, i)
print(*seen, sep="\n")
main()
| false | 8.823529 | [
"-from collections import deque",
"+import sys",
"+import copy",
"-n = int(eval(input()))",
"-lw = [[] for _ in range(n + 1)]",
"-for i in range(n - 1):",
"- u, v, w = list(map(int, input().split()))",
"- lw[u].append((v, w))",
"- lw[v].append((u, w))",
"-# print(lw)",
"-ans = [-1] * (n + 1)",
"-q = deque()",
"-ans[1] = 0",
"-q.append(1)",
"-while q:",
"- r = q.popleft()",
"- prev = ans[r]",
"- for x in lw[r]:",
"- # print(x)",
"- y = x[0]",
"- if ans[y] >= 0:",
"+sys.setrecursionlimit(10**9)",
"+",
"+",
"+def dfs(seen, graph, i):",
"+ for v, w in graph[i]:",
"+ if seen[v - 1] != -1:",
"- q.append(y)",
"- if x[1] % 2 == 0:",
"- ans[y] = ans[r]",
"- else:",
"- ans[y] = 1 - ans[r]",
"-for x in ans[1:]:",
"- print(x)",
"+ seen[v - 1] = abs((w % 2) - seen[i])",
"+ dfs(seen, graph, v - 1)",
"+",
"+",
"+def main():",
"+ n = int(input())",
"+ graph = [[] for _ in range(n)]",
"+ for _ in range(n - 1):",
"+ ui, vi, wi = map(int, input().split())",
"+ graph[ui - 1].append((vi, wi))",
"+ graph[vi - 1].append((ui, wi))",
"+ seen = [-1 for _ in range(n)]",
"+ seen[0] = 0",
"+ for i in range(n - 1):",
"+ dfs(seen, graph, i)",
"+ print(*seen, sep=\"\\n\")",
"+",
"+",
"+main()"
] | false | 0.043367 | 0.043554 | 0.995718 | [
"s975093394",
"s697478585"
] |
u844895214 | p02607 | python | s581587882 | s586534637 | 115 | 29 | 27,096 | 9,036 | Accepted | Accepted | 74.78 | import sys
from collections import deque
import numpy as np
import math
sys.setrecursionlimit(10**6)
def S(): return sys.stdin.readline().rstrip()
def SL(): return list(map(str,sys.stdin.readline().rstrip().split()))
def I(): return int(sys.stdin.readline().rstrip())
def IL(): return list(map(int,sys.stdin.readline().rstrip().split()))
def Main():
n = I()
a = list(IL())
c = 0
for rep in range(0,n,2):
if a[rep]%2:
c += 1
print(c)
return
if __name__=='__main__':
Main() | import sys
def I(): return int(sys.stdin.readline().rstrip())
def IL(): return list(map(int,sys.stdin.readline().rstrip().split()))
if __name__=='__main__':
n = I()
a = list(IL())
c = 0
for i,item in enumerate(a):
if (i+1)%2==1 and item%2==1:
c+=1
print(c)
exit() | 22 | 13 | 530 | 314 | import sys
from collections import deque
import numpy as np
import math
sys.setrecursionlimit(10**6)
def S():
return sys.stdin.readline().rstrip()
def SL():
return list(map(str, sys.stdin.readline().rstrip().split()))
def I():
return int(sys.stdin.readline().rstrip())
def IL():
return list(map(int, sys.stdin.readline().rstrip().split()))
def Main():
n = I()
a = list(IL())
c = 0
for rep in range(0, n, 2):
if a[rep] % 2:
c += 1
print(c)
return
if __name__ == "__main__":
Main()
| import sys
def I():
return int(sys.stdin.readline().rstrip())
def IL():
return list(map(int, sys.stdin.readline().rstrip().split()))
if __name__ == "__main__":
n = I()
a = list(IL())
c = 0
for i, item in enumerate(a):
if (i + 1) % 2 == 1 and item % 2 == 1:
c += 1
print(c)
exit()
| false | 40.909091 | [
"-from collections import deque",
"-import numpy as np",
"-import math",
"-",
"-sys.setrecursionlimit(10**6)",
"-",
"-",
"-def S():",
"- return sys.stdin.readline().rstrip()",
"-",
"-",
"-def SL():",
"- return list(map(str, sys.stdin.readline().rstrip().split()))",
"-def Main():",
"+if __name__ == \"__main__\":",
"- for rep in range(0, n, 2):",
"- if a[rep] % 2:",
"+ for i, item in enumerate(a):",
"+ if (i + 1) % 2 == 1 and item % 2 == 1:",
"- return",
"-",
"-",
"-if __name__ == \"__main__\":",
"- Main()",
"+ exit()"
] | false | 0.036021 | 0.081122 | 0.444031 | [
"s581587882",
"s586534637"
] |
u691018832 | p03862 | python | s277749660 | s872682169 | 130 | 119 | 13,040 | 12,528 | Accepted | Accepted | 8.46 | import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)
n, x, *a = list(map(int, read().split()))
memo = 0
cnt = 0
if a[0] > x:
cnt += a[0] - x
a[0] = x
for i in range(n - 1):
if a[i + 1] > x:
cnt += a[i + 1] - x
a[i + 1] = x
v = a[i] + a[i + 1] - memo
if v > x:
memo = v - x
else:
memo = 0
cnt += memo
print(cnt)
| import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)
n, x, *a = list(map(int, read().split()))
memo = [0] * n
ans = 0
if a[0] > x:
ans += a[0] - x
a[0] = x
for i in range(n - 1):
memo[i] = a[i] + a[i + 1]
for i, check in enumerate(memo):
if check > x:
ans += check - x
memo[i + 1] -= check - x
print(ans)
| 23 | 19 | 482 | 444 | import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10**7)
n, x, *a = list(map(int, read().split()))
memo = 0
cnt = 0
if a[0] > x:
cnt += a[0] - x
a[0] = x
for i in range(n - 1):
if a[i + 1] > x:
cnt += a[i + 1] - x
a[i + 1] = x
v = a[i] + a[i + 1] - memo
if v > x:
memo = v - x
else:
memo = 0
cnt += memo
print(cnt)
| import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10**7)
n, x, *a = list(map(int, read().split()))
memo = [0] * n
ans = 0
if a[0] > x:
ans += a[0] - x
a[0] = x
for i in range(n - 1):
memo[i] = a[i] + a[i + 1]
for i, check in enumerate(memo):
if check > x:
ans += check - x
memo[i + 1] -= check - x
print(ans)
| false | 17.391304 | [
"-memo = 0",
"-cnt = 0",
"+memo = [0] * n",
"+ans = 0",
"- cnt += a[0] - x",
"+ ans += a[0] - x",
"- if a[i + 1] > x:",
"- cnt += a[i + 1] - x",
"- a[i + 1] = x",
"- v = a[i] + a[i + 1] - memo",
"- if v > x:",
"- memo = v - x",
"- else:",
"- memo = 0",
"- cnt += memo",
"-print(cnt)",
"+ memo[i] = a[i] + a[i + 1]",
"+for i, check in enumerate(memo):",
"+ if check > x:",
"+ ans += check - x",
"+ memo[i + 1] -= check - x",
"+print(ans)"
] | false | 0.132287 | 0.132676 | 0.997073 | [
"s277749660",
"s872682169"
] |
u803617136 | p02813 | python | s086164290 | s357776212 | 172 | 53 | 38,384 | 8,052 | Accepted | Accepted | 69.19 | N = int(eval(input()))
def factorial(num):
if num == 1:
return 1
return num * factorial(num - 1)
def count_order(group):
numbers = [i for i in range(1, N + 1)]
res = 1
for i in range(len(group) - 1):
num = group[i]
res += numbers.index(num) * pattern[-(i + 1)]
numbers.pop(numbers.index(num))
return res
P = list(map(int, input().split()))
Q = list(map(int, input().split()))
pattern = [factorial(i) for i in range(1, N)]
res_p = count_order(P)
res_q = count_order(Q)
print((abs(res_p - res_q)))
| from itertools import permutations
n = int(eval(input()))
P = list(map(int, input().split()))
Q = list(map(int, input().split()))
comb = list(permutations([i for i in range(1, n + 1)]))
comb.sort()
a = 0
b = 0
for i in range(len(comb)):
if list(comb[i]) == P:
a = i
if list(comb[i]) == Q:
b = i
ans = abs(a - b)
print(ans) | 25 | 16 | 574 | 357 | N = int(eval(input()))
def factorial(num):
if num == 1:
return 1
return num * factorial(num - 1)
def count_order(group):
numbers = [i for i in range(1, N + 1)]
res = 1
for i in range(len(group) - 1):
num = group[i]
res += numbers.index(num) * pattern[-(i + 1)]
numbers.pop(numbers.index(num))
return res
P = list(map(int, input().split()))
Q = list(map(int, input().split()))
pattern = [factorial(i) for i in range(1, N)]
res_p = count_order(P)
res_q = count_order(Q)
print((abs(res_p - res_q)))
| from itertools import permutations
n = int(eval(input()))
P = list(map(int, input().split()))
Q = list(map(int, input().split()))
comb = list(permutations([i for i in range(1, n + 1)]))
comb.sort()
a = 0
b = 0
for i in range(len(comb)):
if list(comb[i]) == P:
a = i
if list(comb[i]) == Q:
b = i
ans = abs(a - b)
print(ans)
| false | 36 | [
"-N = int(eval(input()))",
"+from itertools import permutations",
"-",
"-def factorial(num):",
"- if num == 1:",
"- return 1",
"- return num * factorial(num - 1)",
"-",
"-",
"-def count_order(group):",
"- numbers = [i for i in range(1, N + 1)]",
"- res = 1",
"- for i in range(len(group) - 1):",
"- num = group[i]",
"- res += numbers.index(num) * pattern[-(i + 1)]",
"- numbers.pop(numbers.index(num))",
"- return res",
"-",
"-",
"+n = int(eval(input()))",
"-pattern = [factorial(i) for i in range(1, N)]",
"-res_p = count_order(P)",
"-res_q = count_order(Q)",
"-print((abs(res_p - res_q)))",
"+comb = list(permutations([i for i in range(1, n + 1)]))",
"+comb.sort()",
"+a = 0",
"+b = 0",
"+for i in range(len(comb)):",
"+ if list(comb[i]) == P:",
"+ a = i",
"+ if list(comb[i]) == Q:",
"+ b = i",
"+ans = abs(a - b)",
"+print(ans)"
] | false | 0.082887 | 0.078498 | 1.055911 | [
"s086164290",
"s357776212"
] |
u221264296 | p02911 | python | s586201971 | s153297268 | 349 | 282 | 8,704 | 4,680 | Accepted | Accepted | 19.2 | n, k, q = (int(i) for i in input().split())
a = [k]*n
d = [0]+[a[i]-a[i-1] for i in range(1,n)]+[0]
for i in range(q):
x = int(eval(input()))-1
d[0]-=1
d[x]+=1
d[x+1]-=1
d[n]+=1
a[0]+=d[0]
for i in range(1,n):a[i] = a[i-1]+d[i]
for i in range(n): print(("Yes" if a[i]>0 else "No")) | n, k, q = (int(i) for i in input().split())
t = [0]*n
for i in range(q):
x= int(eval(input()))-1
t[x]+=1
for i in range(n):
print(("Yes" if k>q-t[i] else "No")) | 12 | 7 | 294 | 164 | n, k, q = (int(i) for i in input().split())
a = [k] * n
d = [0] + [a[i] - a[i - 1] for i in range(1, n)] + [0]
for i in range(q):
x = int(eval(input())) - 1
d[0] -= 1
d[x] += 1
d[x + 1] -= 1
d[n] += 1
a[0] += d[0]
for i in range(1, n):
a[i] = a[i - 1] + d[i]
for i in range(n):
print(("Yes" if a[i] > 0 else "No"))
| n, k, q = (int(i) for i in input().split())
t = [0] * n
for i in range(q):
x = int(eval(input())) - 1
t[x] += 1
for i in range(n):
print(("Yes" if k > q - t[i] else "No"))
| false | 41.666667 | [
"-a = [k] * n",
"-d = [0] + [a[i] - a[i - 1] for i in range(1, n)] + [0]",
"+t = [0] * n",
"- d[0] -= 1",
"- d[x] += 1",
"- d[x + 1] -= 1",
"- d[n] += 1",
"-a[0] += d[0]",
"-for i in range(1, n):",
"- a[i] = a[i - 1] + d[i]",
"+ t[x] += 1",
"- print((\"Yes\" if a[i] > 0 else \"No\"))",
"+ print((\"Yes\" if k > q - t[i] else \"No\"))"
] | false | 0.038247 | 0.038322 | 0.99804 | [
"s586201971",
"s153297268"
] |
u427344224 | p03201 | python | s252251950 | s147170400 | 1,410 | 610 | 33,692 | 33,424 | Accepted | Accepted | 56.74 | N = int(eval(input()))
A_list = list(map(int, input().split()))
two_list = [2 ** i for i in range(32)]
count = 0
items = {}
for a in A_list:
if a in items:
items[a] += 1
else:
items[a] = 1
A_list.sort(reverse=True)
for a in A_list:
if items[a] >= 1:
for t in two_list:
m = t -a
if m in items:
if m == a and items[a] >= 2:
count += 1
items[a] -= 1
items[m] -= 1
break
elif m != a and items[m] >= 1 and items[a] >=1:
count += 1
items[a] -= 1
items[m] -= 1
break
print(count) | N = int(eval(input()))
A_list = list(map(int, input().split()))
two_list = [2 ** i for i in range(32)]
count = 0
items = {}
for a in A_list:
if a in list(items.keys()):
items[a] += 1
else:
items[a] = 1
A_list.sort(reverse=True)
import bisect
for a in A_list:
if items[a] >= 1:
index = bisect.bisect_left(two_list, a)
for t in two_list[index:]:
m = t - a
if m in list(items.keys()):
if m == a and items[a] >= 2:
count += 1
items[a] -= 2
break
elif m != a and items[m] >= 1 and items[a] >= 1:
count += 1
items[a] -= 1
items[m] -= 1
break
print(count)
| 31 | 31 | 756 | 804 | N = int(eval(input()))
A_list = list(map(int, input().split()))
two_list = [2**i for i in range(32)]
count = 0
items = {}
for a in A_list:
if a in items:
items[a] += 1
else:
items[a] = 1
A_list.sort(reverse=True)
for a in A_list:
if items[a] >= 1:
for t in two_list:
m = t - a
if m in items:
if m == a and items[a] >= 2:
count += 1
items[a] -= 1
items[m] -= 1
break
elif m != a and items[m] >= 1 and items[a] >= 1:
count += 1
items[a] -= 1
items[m] -= 1
break
print(count)
| N = int(eval(input()))
A_list = list(map(int, input().split()))
two_list = [2**i for i in range(32)]
count = 0
items = {}
for a in A_list:
if a in list(items.keys()):
items[a] += 1
else:
items[a] = 1
A_list.sort(reverse=True)
import bisect
for a in A_list:
if items[a] >= 1:
index = bisect.bisect_left(two_list, a)
for t in two_list[index:]:
m = t - a
if m in list(items.keys()):
if m == a and items[a] >= 2:
count += 1
items[a] -= 2
break
elif m != a and items[m] >= 1 and items[a] >= 1:
count += 1
items[a] -= 1
items[m] -= 1
break
print(count)
| false | 0 | [
"- if a in items:",
"+ if a in list(items.keys()):",
"+import bisect",
"+",
"- for t in two_list:",
"+ index = bisect.bisect_left(two_list, a)",
"+ for t in two_list[index:]:",
"- if m in items:",
"+ if m in list(items.keys()):",
"- items[a] -= 1",
"- items[m] -= 1",
"+ items[a] -= 2"
] | false | 0.037103 | 0.038031 | 0.975607 | [
"s252251950",
"s147170400"
] |
u539367121 | p02972 | python | s588006792 | s034803966 | 633 | 177 | 97,744 | 19,016 | Accepted | Accepted | 72.04 | n=int(eval(input()))
a=[0]+list(map(int,input().split()))
m=0
ans=[]
c=[0]*(n+1)
for i in reversed(list(range(1,n+1))):
if a[i]%2!=c[i]%2:
m+=1
ans.append(i)
j=1
r=set()
while j*j<=i:
if i%j==0:
r.add(j)
r.add(i//j)
j+=1
for j in r:
c[j]+=1
c[j]%=2
print(m)
print((*sorted(ans))) | n=int(eval(input()))
a=list(map(int,input().split()))
ans=[]
b=[0]*n
for i in reversed(list(range(n))):
if sum(b[i::i+1])%2!=a[i]:
b[i]+=1
ans.append(i+1)
print((sum(b)))
print((*sorted(ans)))
| 23 | 12 | 370 | 215 | n = int(eval(input()))
a = [0] + list(map(int, input().split()))
m = 0
ans = []
c = [0] * (n + 1)
for i in reversed(list(range(1, n + 1))):
if a[i] % 2 != c[i] % 2:
m += 1
ans.append(i)
j = 1
r = set()
while j * j <= i:
if i % j == 0:
r.add(j)
r.add(i // j)
j += 1
for j in r:
c[j] += 1
c[j] %= 2
print(m)
print((*sorted(ans)))
| n = int(eval(input()))
a = list(map(int, input().split()))
ans = []
b = [0] * n
for i in reversed(list(range(n))):
if sum(b[i :: i + 1]) % 2 != a[i]:
b[i] += 1
ans.append(i + 1)
print((sum(b)))
print((*sorted(ans)))
| false | 47.826087 | [
"-a = [0] + list(map(int, input().split()))",
"-m = 0",
"+a = list(map(int, input().split()))",
"-c = [0] * (n + 1)",
"-for i in reversed(list(range(1, n + 1))):",
"- if a[i] % 2 != c[i] % 2:",
"- m += 1",
"- ans.append(i)",
"- j = 1",
"- r = set()",
"- while j * j <= i:",
"- if i % j == 0:",
"- r.add(j)",
"- r.add(i // j)",
"- j += 1",
"- for j in r:",
"- c[j] += 1",
"- c[j] %= 2",
"-print(m)",
"+b = [0] * n",
"+for i in reversed(list(range(n))):",
"+ if sum(b[i :: i + 1]) % 2 != a[i]:",
"+ b[i] += 1",
"+ ans.append(i + 1)",
"+print((sum(b)))"
] | false | 0.041227 | 0.051879 | 0.794665 | [
"s588006792",
"s034803966"
] |
u883048396 | p04013 | python | s737543269 | s684804659 | 305 | 252 | 5,228 | 5,236 | Accepted | Accepted | 17.38 | iN,iA =[int(x) for x in input().split()]
aX = [int(x) - iA for x in input().split()]
#解法2
iMX = max(aX + [iA])
dp = [[0]*(2 * iN*iMX + 1) for _ in range(iN+1)]
for j in range(0,iN+1):
for t in range(0,2*iN*iMX):
if j == 0 and t == iN * iMX :
dp[j][t] = 1
elif j >= 0 and ( t - aX[j-1] < 0 or t - aX[j-1] > 2*iN*iMX):
dp[j][t] = dp[j-1][t]
elif j >= 0 and ( 0 <= t - aX[j-1] <= 2*iN*iMX):
dp[j][t] = dp[j-1][t] + dp[j-1][t-aX[j-1]]
else:
dp[j][t] = 0
print((dp[iN][iN*iMX] -1 ))
| iN,iA =[int(x) for x in input().split()]
aX = [int(x) - iA for x in input().split()]
#解法2そのまま
iMX = max(aX + [iA])
iULim = iN*iMX
iULim2 = 2*iULim
#y0..yjから0枚以上選んだ合計をt-iN*iMXにするような選び方の総数
dp = [[0]*(iULim2 + 1) for _ in range(iN+1)]
for j in range(0,iN+1):
for t in range(0,iULim2):
if j == 0 and t == iULim :
dp[j][t] = 1
elif t - aX[j-1] < 0 or t - aX[j-1] > iULim2:
dp[j][t] = dp[j-1][t]
elif 0 <= t - aX[j-1] <= iULim2:
dp[j][t] = dp[j-1][t] + dp[j-1][t-aX[j-1]]
else:
dp[j][t] = 0
print((dp[iN][iN*iMX] -1 ))
| 19 | 22 | 581 | 621 | iN, iA = [int(x) for x in input().split()]
aX = [int(x) - iA for x in input().split()]
# 解法2
iMX = max(aX + [iA])
dp = [[0] * (2 * iN * iMX + 1) for _ in range(iN + 1)]
for j in range(0, iN + 1):
for t in range(0, 2 * iN * iMX):
if j == 0 and t == iN * iMX:
dp[j][t] = 1
elif j >= 0 and (t - aX[j - 1] < 0 or t - aX[j - 1] > 2 * iN * iMX):
dp[j][t] = dp[j - 1][t]
elif j >= 0 and (0 <= t - aX[j - 1] <= 2 * iN * iMX):
dp[j][t] = dp[j - 1][t] + dp[j - 1][t - aX[j - 1]]
else:
dp[j][t] = 0
print((dp[iN][iN * iMX] - 1))
| iN, iA = [int(x) for x in input().split()]
aX = [int(x) - iA for x in input().split()]
# 解法2そのまま
iMX = max(aX + [iA])
iULim = iN * iMX
iULim2 = 2 * iULim
# y0..yjから0枚以上選んだ合計をt-iN*iMXにするような選び方の総数
dp = [[0] * (iULim2 + 1) for _ in range(iN + 1)]
for j in range(0, iN + 1):
for t in range(0, iULim2):
if j == 0 and t == iULim:
dp[j][t] = 1
elif t - aX[j - 1] < 0 or t - aX[j - 1] > iULim2:
dp[j][t] = dp[j - 1][t]
elif 0 <= t - aX[j - 1] <= iULim2:
dp[j][t] = dp[j - 1][t] + dp[j - 1][t - aX[j - 1]]
else:
dp[j][t] = 0
print((dp[iN][iN * iMX] - 1))
| false | 13.636364 | [
"-# 解法2",
"+# 解法2そのまま",
"-dp = [[0] * (2 * iN * iMX + 1) for _ in range(iN + 1)]",
"+iULim = iN * iMX",
"+iULim2 = 2 * iULim",
"+# y0..yjから0枚以上選んだ合計をt-iN*iMXにするような選び方の総数",
"+dp = [[0] * (iULim2 + 1) for _ in range(iN + 1)]",
"- for t in range(0, 2 * iN * iMX):",
"- if j == 0 and t == iN * iMX:",
"+ for t in range(0, iULim2):",
"+ if j == 0 and t == iULim:",
"- elif j >= 0 and (t - aX[j - 1] < 0 or t - aX[j - 1] > 2 * iN * iMX):",
"+ elif t - aX[j - 1] < 0 or t - aX[j - 1] > iULim2:",
"- elif j >= 0 and (0 <= t - aX[j - 1] <= 2 * iN * iMX):",
"+ elif 0 <= t - aX[j - 1] <= iULim2:"
] | false | 0.045236 | 0.046258 | 0.977908 | [
"s737543269",
"s684804659"
] |
u729133443 | p03206 | python | s170012504 | s431828130 | 172 | 18 | 38,256 | 2,940 | Accepted | Accepted | 89.53 | print(('Christmas'+' Eve'*(25-int(eval(input()))))) | print((-int(eval(input('Christmas')))%5*' Eve')) | 1 | 1 | 43 | 40 | print(("Christmas" + " Eve" * (25 - int(eval(input())))))
| print((-int(eval(input("Christmas"))) % 5 * " Eve"))
| false | 0 | [
"-print((\"Christmas\" + \" Eve\" * (25 - int(eval(input())))))",
"+print((-int(eval(input(\"Christmas\"))) % 5 * \" Eve\"))"
] | false | 0.145017 | 0.11048 | 1.312615 | [
"s170012504",
"s431828130"
] |
u600402037 | p03078 | python | s156155712 | s236898043 | 168 | 35 | 14,020 | 5,104 | Accepted | Accepted | 79.17 | import numpy as np
from heapq import *
X, Y, Z, K = list(map(int, input().split()))
A = [int(x) for x in input().split()]
B = [int(x) for x in input().split()]
C = [int(x) for x in input().split()]
A.sort(reverse=True)
B.sort(reverse=True)
C.sort(reverse=True)
h = []
heappush(h, (-A[0]-B[0]-C[0], 0, 0, 0))
used = set()
result = []
for _ in range(K):
sum, i, j, k = heappop(h)
result.append(-sum)
if i < X-1 and (i+1, j, k) not in used:
heappush(h, (-A[i+1]-B[j]-C[k], i+1, j, k))
used.add((i+1, j, k))
if j < Y-1 and (i, j+1, k) not in used:
heappush(h, (-A[i]-B[j+1]-C[k], i, j+1, k))
used.add((i, j+1, k))
if k < Z-1 and (i, j, k+1) not in used:
heappush(h, (-A[i]-B[j]-C[k+1], i, j, k+1))
used.add((i, j, k+1))
for v in result:
print(v)
| from heapq import heappop, heappush
X, Y, Z, K = list(map(int, input().split()))
A = [int(x) for x in input().split()]
B = [int(x) for x in input().split()]
C = [int(x) for x in input().split()]
A.sort(reverse=True)
B.sort(reverse=True)
C.sort(reverse=True)
h = []
heappush(h, (-A[0]-B[0]-C[0], 0, 0, 0))
used = set()
result = []
for _ in range(K):
sum, i, j, k = heappop(h)
result.append(-sum)
if i < X-1 and (i+1, j, k) not in used:
heappush(h, (-A[i+1]-B[j]-C[k], i+1, j, k))
used.add((i+1, j, k))
if j < Y-1 and (i, j+1, k) not in used:
heappush(h, (-A[i]-B[j+1]-C[k], i, j+1, k))
used.add((i, j+1, k))
if k < Z-1 and (i, j, k+1) not in used:
heappush(h, (-A[i]-B[j]-C[k+1], i, j, k+1))
used.add((i, j, k+1))
for v in result:
print(v)
| 32 | 31 | 847 | 843 | import numpy as np
from heapq import *
X, Y, Z, K = list(map(int, input().split()))
A = [int(x) for x in input().split()]
B = [int(x) for x in input().split()]
C = [int(x) for x in input().split()]
A.sort(reverse=True)
B.sort(reverse=True)
C.sort(reverse=True)
h = []
heappush(h, (-A[0] - B[0] - C[0], 0, 0, 0))
used = set()
result = []
for _ in range(K):
sum, i, j, k = heappop(h)
result.append(-sum)
if i < X - 1 and (i + 1, j, k) not in used:
heappush(h, (-A[i + 1] - B[j] - C[k], i + 1, j, k))
used.add((i + 1, j, k))
if j < Y - 1 and (i, j + 1, k) not in used:
heappush(h, (-A[i] - B[j + 1] - C[k], i, j + 1, k))
used.add((i, j + 1, k))
if k < Z - 1 and (i, j, k + 1) not in used:
heappush(h, (-A[i] - B[j] - C[k + 1], i, j, k + 1))
used.add((i, j, k + 1))
for v in result:
print(v)
| from heapq import heappop, heappush
X, Y, Z, K = list(map(int, input().split()))
A = [int(x) for x in input().split()]
B = [int(x) for x in input().split()]
C = [int(x) for x in input().split()]
A.sort(reverse=True)
B.sort(reverse=True)
C.sort(reverse=True)
h = []
heappush(h, (-A[0] - B[0] - C[0], 0, 0, 0))
used = set()
result = []
for _ in range(K):
sum, i, j, k = heappop(h)
result.append(-sum)
if i < X - 1 and (i + 1, j, k) not in used:
heappush(h, (-A[i + 1] - B[j] - C[k], i + 1, j, k))
used.add((i + 1, j, k))
if j < Y - 1 and (i, j + 1, k) not in used:
heappush(h, (-A[i] - B[j + 1] - C[k], i, j + 1, k))
used.add((i, j + 1, k))
if k < Z - 1 and (i, j, k + 1) not in used:
heappush(h, (-A[i] - B[j] - C[k + 1], i, j, k + 1))
used.add((i, j, k + 1))
for v in result:
print(v)
| false | 3.125 | [
"-import numpy as np",
"-from heapq import *",
"+from heapq import heappop, heappush"
] | false | 0.035491 | 0.036046 | 0.984608 | [
"s156155712",
"s236898043"
] |
u864197622 | p03181 | python | s773893654 | s491534668 | 946 | 636 | 83,360 | 80,560 | Accepted | Accepted | 32.77 | from collections import deque
from functools import reduce
f = lambda a: (a+1) % M
g = lambda a, b: a * b % M
init = 1
N, M = list(map(int, input().split()))
X = [[] for i in range(N)]
for i in range(N-1):
x, y = list(map(int, input().split()))
X[x-1].append(y-1)
X[y-1].append(x-1)
P = [-1] * N
Q = deque([0])
T = []
while Q:
i = deque.popleft(Q)
T.append(i)
for a in X[i]:
if a != P[i]:
P[a] = i
X[a].remove(i)
deque.append(Q, a)
BU = [0] * N # Bottom Up
TD = [1] * N # Top Down
for i in T[::-1]:
BU[i] = reduce(g, [f(BU[j]) for j in X[i]]) if len(X[i]) else init
for i in T:
B = [1] * (len(X[i]) + 1)
for k, j in enumerate(X[i]):
B[k+1] = g(B[k], f(BU[j]))
a = init
for k in range(len(X[i]))[::-1]:
j = X[i][k]
TD[j] = f(g(TD[i], g(a, B[k])))
a = g(a, f(BU[j]))
for t in [g(a, b) for a, b in zip(BU, TD)]:
print(t)
| import sys
input = sys.stdin.readline
from collections import deque
from functools import reduce
f = lambda a: (a+1) % M
g = lambda a, b: a * b % M
init = 1
N, M = list(map(int, input().split()))
X = [[] for i in range(N)]
for i in range(N-1):
x, y = list(map(int, input().split()))
X[x-1].append(y-1)
X[y-1].append(x-1)
P = [-1] * N
Q = deque([0])
T = []
while Q:
i = deque.popleft(Q)
T.append(i)
for a in X[i]:
if a != P[i]:
P[a] = i
X[a].remove(i)
deque.append(Q, a)
BU = [0] * N # Bottom Up
TD = [1] * N # Top Down
for i in T[::-1]:
BU[i] = reduce(g, [f(BU[j]) for j in X[i]]) if len(X[i]) else init
for i in T:
B = [1] * (len(X[i]) + 1)
for k, j in enumerate(X[i]):
B[k+1] = g(B[k], f(BU[j]))
a = init
for k in range(len(X[i]))[::-1]:
j = X[i][k]
TD[j] = f(g(TD[i], g(a, B[k])))
a = g(a, f(BU[j]))
for t in [g(a, b) for a, b in zip(BU, TD)]:
print(t) | 42 | 45 | 976 | 1,017 | from collections import deque
from functools import reduce
f = lambda a: (a + 1) % M
g = lambda a, b: a * b % M
init = 1
N, M = list(map(int, input().split()))
X = [[] for i in range(N)]
for i in range(N - 1):
x, y = list(map(int, input().split()))
X[x - 1].append(y - 1)
X[y - 1].append(x - 1)
P = [-1] * N
Q = deque([0])
T = []
while Q:
i = deque.popleft(Q)
T.append(i)
for a in X[i]:
if a != P[i]:
P[a] = i
X[a].remove(i)
deque.append(Q, a)
BU = [0] * N # Bottom Up
TD = [1] * N # Top Down
for i in T[::-1]:
BU[i] = reduce(g, [f(BU[j]) for j in X[i]]) if len(X[i]) else init
for i in T:
B = [1] * (len(X[i]) + 1)
for k, j in enumerate(X[i]):
B[k + 1] = g(B[k], f(BU[j]))
a = init
for k in range(len(X[i]))[::-1]:
j = X[i][k]
TD[j] = f(g(TD[i], g(a, B[k])))
a = g(a, f(BU[j]))
for t in [g(a, b) for a, b in zip(BU, TD)]:
print(t)
| import sys
input = sys.stdin.readline
from collections import deque
from functools import reduce
f = lambda a: (a + 1) % M
g = lambda a, b: a * b % M
init = 1
N, M = list(map(int, input().split()))
X = [[] for i in range(N)]
for i in range(N - 1):
x, y = list(map(int, input().split()))
X[x - 1].append(y - 1)
X[y - 1].append(x - 1)
P = [-1] * N
Q = deque([0])
T = []
while Q:
i = deque.popleft(Q)
T.append(i)
for a in X[i]:
if a != P[i]:
P[a] = i
X[a].remove(i)
deque.append(Q, a)
BU = [0] * N # Bottom Up
TD = [1] * N # Top Down
for i in T[::-1]:
BU[i] = reduce(g, [f(BU[j]) for j in X[i]]) if len(X[i]) else init
for i in T:
B = [1] * (len(X[i]) + 1)
for k, j in enumerate(X[i]):
B[k + 1] = g(B[k], f(BU[j]))
a = init
for k in range(len(X[i]))[::-1]:
j = X[i][k]
TD[j] = f(g(TD[i], g(a, B[k])))
a = g(a, f(BU[j]))
for t in [g(a, b) for a, b in zip(BU, TD)]:
print(t)
| false | 6.666667 | [
"+import sys",
"+",
"+input = sys.stdin.readline"
] | false | 0.064082 | 0.120077 | 0.533676 | [
"s773893654",
"s491534668"
] |
u525065967 | p03290 | python | s641130027 | s378104761 | 23 | 18 | 3,064 | 3,064 | Accepted | Accepted | 21.74 | d,g = list(map(int,input().split()))
P,C = [0]*d,[0]*d
for i in range(d): P[i],C[i] = list(map(int,input().split()))
ans = 10**9
for bin in range(1<<d):
cnt = tot = rest_max_bit = 0
for i in range(d):
if bin & 1<<i:
t = (i + 1)*100
tot += P[i]*t + C[i]
cnt += P[i]
else: rest_max_bit = i
if tot < g:
t = (rest_max_bit + 1)*100
p = (g - tot + t - 1)//t
if p >= P[rest_max_bit]: continue
cnt += p
ans = min(ans, cnt)
print(ans)
| d, g = list(map(int,input().split()))
data = [list(map(int,input().split())) for _ in range(d)]
def dfs(d, rest): # difficulty, rest score
if d <= 0: return 10**9
num, bonus = data[d-1] # num of problems, bonus
# now, use or don't use difficulty d?
use = min(rest//(d*100), num) # num when use
score = use * d * 100 # score when use
if use == num: score += bonus # ?perfect
if rest - score > 0: # ?rest
use += dfs(d-1, rest - score) # rest of score -> recursion
not_use = dfs(d-1, rest) # num when don't use -> recursion
return min(use, not_use)
print((dfs(d, g)))
| 19 | 16 | 532 | 618 | d, g = list(map(int, input().split()))
P, C = [0] * d, [0] * d
for i in range(d):
P[i], C[i] = list(map(int, input().split()))
ans = 10**9
for bin in range(1 << d):
cnt = tot = rest_max_bit = 0
for i in range(d):
if bin & 1 << i:
t = (i + 1) * 100
tot += P[i] * t + C[i]
cnt += P[i]
else:
rest_max_bit = i
if tot < g:
t = (rest_max_bit + 1) * 100
p = (g - tot + t - 1) // t
if p >= P[rest_max_bit]:
continue
cnt += p
ans = min(ans, cnt)
print(ans)
| d, g = list(map(int, input().split()))
data = [list(map(int, input().split())) for _ in range(d)]
def dfs(d, rest): # difficulty, rest score
if d <= 0:
return 10**9
num, bonus = data[d - 1] # num of problems, bonus
# now, use or don't use difficulty d?
use = min(rest // (d * 100), num) # num when use
score = use * d * 100 # score when use
if use == num:
score += bonus # ?perfect
if rest - score > 0: # ?rest
use += dfs(d - 1, rest - score) # rest of score -> recursion
not_use = dfs(d - 1, rest) # num when don't use -> recursion
return min(use, not_use)
print((dfs(d, g)))
| false | 15.789474 | [
"-P, C = [0] * d, [0] * d",
"-for i in range(d):",
"- P[i], C[i] = list(map(int, input().split()))",
"-ans = 10**9",
"-for bin in range(1 << d):",
"- cnt = tot = rest_max_bit = 0",
"- for i in range(d):",
"- if bin & 1 << i:",
"- t = (i + 1) * 100",
"- tot += P[i] * t + C[i]",
"- cnt += P[i]",
"- else:",
"- rest_max_bit = i",
"- if tot < g:",
"- t = (rest_max_bit + 1) * 100",
"- p = (g - tot + t - 1) // t",
"- if p >= P[rest_max_bit]:",
"- continue",
"- cnt += p",
"- ans = min(ans, cnt)",
"-print(ans)",
"+data = [list(map(int, input().split())) for _ in range(d)]",
"+",
"+",
"+def dfs(d, rest): # difficulty, rest score",
"+ if d <= 0:",
"+ return 10**9",
"+ num, bonus = data[d - 1] # num of problems, bonus",
"+ # now, use or don't use difficulty d?",
"+ use = min(rest // (d * 100), num) # num when use",
"+ score = use * d * 100 # score when use",
"+ if use == num:",
"+ score += bonus # ?perfect",
"+ if rest - score > 0: # ?rest",
"+ use += dfs(d - 1, rest - score) # rest of score -> recursion",
"+ not_use = dfs(d - 1, rest) # num when don't use -> recursion",
"+ return min(use, not_use)",
"+",
"+",
"+print((dfs(d, g)))"
] | false | 0.038424 | 0.067119 | 0.572473 | [
"s641130027",
"s378104761"
] |
u224554402 | p02725 | python | s809142452 | s325324436 | 124 | 111 | 26,444 | 32,104 | Accepted | Accepted | 10.48 | p,q= input().split()
a,b =(int(p), int(q))
f = list(map(int,input().split()))
f_list = list(f)
out_dis =f_list[0] + a -f_list[b-1]
dis_list=[out_dis]
for i in range(b-1):
dis = f_list[i+1]-f_list[i]
dis_list.append(dis)
print((int((sum(dis_list)-max(dis_list))))) | k , n= list(map(int, input().split()))
a_list = list(map(int, input().split()))
diff_list = []
for i in range(n-1):
diff_list.append(a_list[i+1]- a_list[i])
diff_list.append(k-a_list[n-1] + a_list[0])
print((sum(diff_list)-max(diff_list))) | 11 | 7 | 274 | 241 | p, q = input().split()
a, b = (int(p), int(q))
f = list(map(int, input().split()))
f_list = list(f)
out_dis = f_list[0] + a - f_list[b - 1]
dis_list = [out_dis]
for i in range(b - 1):
dis = f_list[i + 1] - f_list[i]
dis_list.append(dis)
print((int((sum(dis_list) - max(dis_list)))))
| k, n = list(map(int, input().split()))
a_list = list(map(int, input().split()))
diff_list = []
for i in range(n - 1):
diff_list.append(a_list[i + 1] - a_list[i])
diff_list.append(k - a_list[n - 1] + a_list[0])
print((sum(diff_list) - max(diff_list)))
| false | 36.363636 | [
"-p, q = input().split()",
"-a, b = (int(p), int(q))",
"-f = list(map(int, input().split()))",
"-f_list = list(f)",
"-out_dis = f_list[0] + a - f_list[b - 1]",
"-dis_list = [out_dis]",
"-for i in range(b - 1):",
"- dis = f_list[i + 1] - f_list[i]",
"- dis_list.append(dis)",
"-print((int((sum(dis_list) - max(dis_list)))))",
"+k, n = list(map(int, input().split()))",
"+a_list = list(map(int, input().split()))",
"+diff_list = []",
"+for i in range(n - 1):",
"+ diff_list.append(a_list[i + 1] - a_list[i])",
"+diff_list.append(k - a_list[n - 1] + a_list[0])",
"+print((sum(diff_list) - max(diff_list)))"
] | false | 0.008725 | 0.044812 | 0.194708 | [
"s809142452",
"s325324436"
] |
u391875425 | p03427 | python | s383076383 | s310999521 | 189 | 18 | 38,256 | 3,064 | Accepted | Accepted | 90.48 | import math
n=int(eval(input()))
s = str(n)
array = list(map(int, list(s)))
a1=sum(array)
size = int (math.log10(n))
a2=int(n/(10**size))-1+size*9
print((max(a1,a2)))
| n = int(eval(input()))
c = None
res = 0
for i in range(1, len(str(n))+1):
c = '9' * i
if int(c) <= n:
continue
else:
for j in range(9, -1, -1):
if int(str(j) + str(c)[1:]) <= n:
c = str(j) + str(c)[1:]
break
break
for i in range(len(c)):
res += int(c[i])
print(res) | 8 | 16 | 166 | 358 | import math
n = int(eval(input()))
s = str(n)
array = list(map(int, list(s)))
a1 = sum(array)
size = int(math.log10(n))
a2 = int(n / (10**size)) - 1 + size * 9
print((max(a1, a2)))
| n = int(eval(input()))
c = None
res = 0
for i in range(1, len(str(n)) + 1):
c = "9" * i
if int(c) <= n:
continue
else:
for j in range(9, -1, -1):
if int(str(j) + str(c)[1:]) <= n:
c = str(j) + str(c)[1:]
break
break
for i in range(len(c)):
res += int(c[i])
print(res)
| false | 50 | [
"-import math",
"-",
"-s = str(n)",
"-array = list(map(int, list(s)))",
"-a1 = sum(array)",
"-size = int(math.log10(n))",
"-a2 = int(n / (10**size)) - 1 + size * 9",
"-print((max(a1, a2)))",
"+c = None",
"+res = 0",
"+for i in range(1, len(str(n)) + 1):",
"+ c = \"9\" * i",
"+ if int(c) <= n:",
"+ continue",
"+ else:",
"+ for j in range(9, -1, -1):",
"+ if int(str(j) + str(c)[1:]) <= n:",
"+ c = str(j) + str(c)[1:]",
"+ break",
"+ break",
"+for i in range(len(c)):",
"+ res += int(c[i])",
"+print(res)"
] | false | 0.041406 | 0.036307 | 1.14044 | [
"s383076383",
"s310999521"
] |
u249218427 | p02678 | python | s067945516 | s451952776 | 483 | 409 | 46,016 | 46,172 | Accepted | Accepted | 15.32 | # -*- coding: utf-8 -*-
import sys
N, M, *AB = list(map(int, sys.stdin.buffer.read().split()))
list_path = [[] for _ in range(N+1)]
for i in range(M):
A,B = AB[2*i:2*i+2]
list_path[A].append(B)
list_path[B].append(A)
list_bfs = [1]
list_flg = [0 for _ in range(N+1)]
list_flg[1] = 1
while len(list_bfs)>0:
list_tmp = []
for i in list_bfs:
for j in list_path[i]:
if list_flg[j]==0:
list_tmp.append(j)
list_flg[j] = i
list_bfs = list_tmp
print('Yes')
for i in list_flg[2:]:
print(i)
| # -*- coding: utf-8 -*-
import sys
N, M, *AB = list(map(int, sys.stdin.buffer.read().split()))
list_path = [[] for _ in range(N+1)]
for i in range(M):
A,B = AB[2*i],AB[2*i+1]
list_path[A].append(B)
list_path[B].append(A)
list_bfs = [1]
list_flg = [0 for _ in range(N+1)]
list_flg[1] = 1
while len(list_bfs)>0:
list_tmp = []
for i in list_bfs:
for j in list_path[i]:
if list_flg[j]==0:
list_tmp.append(j)
list_flg[j] = i
list_bfs = list_tmp
print('Yes')
for i in list_flg[2:]:
print(i) | 28 | 28 | 548 | 551 | # -*- coding: utf-8 -*-
import sys
N, M, *AB = list(map(int, sys.stdin.buffer.read().split()))
list_path = [[] for _ in range(N + 1)]
for i in range(M):
A, B = AB[2 * i : 2 * i + 2]
list_path[A].append(B)
list_path[B].append(A)
list_bfs = [1]
list_flg = [0 for _ in range(N + 1)]
list_flg[1] = 1
while len(list_bfs) > 0:
list_tmp = []
for i in list_bfs:
for j in list_path[i]:
if list_flg[j] == 0:
list_tmp.append(j)
list_flg[j] = i
list_bfs = list_tmp
print("Yes")
for i in list_flg[2:]:
print(i)
| # -*- coding: utf-8 -*-
import sys
N, M, *AB = list(map(int, sys.stdin.buffer.read().split()))
list_path = [[] for _ in range(N + 1)]
for i in range(M):
A, B = AB[2 * i], AB[2 * i + 1]
list_path[A].append(B)
list_path[B].append(A)
list_bfs = [1]
list_flg = [0 for _ in range(N + 1)]
list_flg[1] = 1
while len(list_bfs) > 0:
list_tmp = []
for i in list_bfs:
for j in list_path[i]:
if list_flg[j] == 0:
list_tmp.append(j)
list_flg[j] = i
list_bfs = list_tmp
print("Yes")
for i in list_flg[2:]:
print(i)
| false | 0 | [
"- A, B = AB[2 * i : 2 * i + 2]",
"+ A, B = AB[2 * i], AB[2 * i + 1]"
] | false | 0.045229 | 0.045326 | 0.997874 | [
"s067945516",
"s451952776"
] |
u860002137 | p03393 | python | s652914142 | s849215848 | 26 | 21 | 3,436 | 3,316 | Accepted | Accepted | 19.23 | import sys
from collections import deque
s = deque(list(map(str, input().rstrip())))
# 辞書の最後は-1
if "".join(s) == "zyxwvutsrqponmlkjihgfedcba":
print((-1))
sys.exit()
# 使える文字リスト作成
s = [ord(x) for x in s]
# 26文字未満なら、未使用の１文字を追加して終わり
if len(s) < 26:
can_use = set(range(97, 123)) - set(s)
s = s + [min(can_use)]
# 26文字の時は例外処理を入れる
else:
add = []
s = s[::-1]
prev = s[0]
add.append(prev)
# 末尾がzならzを消去し、1文字前をzにして終わり
if prev == 122:
s[1] = 122
s = s[::-1]
s = s[:-1]
# そうでなければ、初めて増加する値が減少するタイミングまで見る
# 減少するポイントで、その時点で使える中で最小の文字に差し替え
else:
for i in range(1, len(s)):
if prev > s[i]:
add = [x for x in add if x > s[i]]
s[i] = (min(add))
s = s[::-1]
s = s[:-i]
break
prev = s[i]
add.append(prev)
# 文字列に戻す処理
s = [chr(x) for x in s]
print(("".join(s))) | import sys
from collections import deque
s = deque(list(map(str, input().rstrip())))
# 辞書の最後は-1
if "".join(s) == "zyxwvutsrqponmlkjihgfedcba":
print((-1))
sys.exit()
# 使える文字リスト作成
s = [ord(x) for x in s]
# 26文字未満なら、未使用の１文字を追加して終わり
if len(s) < 26:
can_use = set(range(97, 123)) - set(s)
s = s + [min(can_use)]
# 26文字の時は例外処理を入れる
else:
add = []
s = s[::-1]
prev = s[0]
add.append(prev)
# 末尾がzならzを消去し、1文字前をzにして終わり
if prev == 122:
s[1] = 122
s = s[::-1][:-1]
# そうでなければ、初めて増加する値が減少するタイミングまで見る
# 減少するポイントで、その時点で使える中で最小の文字に差し替え
else:
for i in range(1, len(s)):
if prev > s[i]:
add = [x for x in add if x > s[i]]
s[i] = (min(add))
s = s[::-1][:-i]
break
prev = s[i]
add.append(prev)
# 文字列に戻す処理
s = [chr(x) for x in s]
print(("".join(s))) | 47 | 45 | 983 | 945 | import sys
from collections import deque
s = deque(list(map(str, input().rstrip())))
# 辞書の最後は-1
if "".join(s) == "zyxwvutsrqponmlkjihgfedcba":
print((-1))
sys.exit()
# 使える文字リスト作成
s = [ord(x) for x in s]
# 26文字未満なら、未使用の１文字を追加して終わり
if len(s) < 26:
can_use = set(range(97, 123)) - set(s)
s = s + [min(can_use)]
# 26文字の時は例外処理を入れる
else:
add = []
s = s[::-1]
prev = s[0]
add.append(prev)
# 末尾がzならzを消去し、1文字前をzにして終わり
if prev == 122:
s[1] = 122
s = s[::-1]
s = s[:-1]
# そうでなければ、初めて増加する値が減少するタイミングまで見る
# 減少するポイントで、その時点で使える中で最小の文字に差し替え
else:
for i in range(1, len(s)):
if prev > s[i]:
add = [x for x in add if x > s[i]]
s[i] = min(add)
s = s[::-1]
s = s[:-i]
break
prev = s[i]
add.append(prev)
# 文字列に戻す処理
s = [chr(x) for x in s]
print(("".join(s)))
| import sys
from collections import deque
s = deque(list(map(str, input().rstrip())))
# 辞書の最後は-1
if "".join(s) == "zyxwvutsrqponmlkjihgfedcba":
print((-1))
sys.exit()
# 使える文字リスト作成
s = [ord(x) for x in s]
# 26文字未満なら、未使用の１文字を追加して終わり
if len(s) < 26:
can_use = set(range(97, 123)) - set(s)
s = s + [min(can_use)]
# 26文字の時は例外処理を入れる
else:
add = []
s = s[::-1]
prev = s[0]
add.append(prev)
# 末尾がzならzを消去し、1文字前をzにして終わり
if prev == 122:
s[1] = 122
s = s[::-1][:-1]
# そうでなければ、初めて増加する値が減少するタイミングまで見る
# 減少するポイントで、その時点で使える中で最小の文字に差し替え
else:
for i in range(1, len(s)):
if prev > s[i]:
add = [x for x in add if x > s[i]]
s[i] = min(add)
s = s[::-1][:-i]
break
prev = s[i]
add.append(prev)
# 文字列に戻す処理
s = [chr(x) for x in s]
print(("".join(s)))
| false | 4.255319 | [
"- s = s[::-1]",
"- s = s[:-1]",
"+ s = s[::-1][:-1]",
"- s = s[::-1]",
"- s = s[:-i]",
"+ s = s[::-1][:-i]"
] | false | 0.033383 | 0.06601 | 0.505731 | [
"s652914142",
"s849215848"
] |
u090406054 | p03730 | python | s302560136 | s826480599 | 161 | 27 | 9,092 | 9,028 | Accepted | Accepted | 83.23 | a,b,c=list(map(int,input().split()))
for i in range(1,1000000):
if (i*b+c)%a==0:
print('YES')
exit()
print('NO') | a,b,c=list(map(int,input().split()))
for i in range(1,10000):
if (i*b+c)%a==0:
print('YES')
exit()
print('NO')
| 7 | 7 | 127 | 126 | a, b, c = list(map(int, input().split()))
for i in range(1, 1000000):
if (i * b + c) % a == 0:
print("YES")
exit()
print("NO")
| a, b, c = list(map(int, input().split()))
for i in range(1, 10000):
if (i * b + c) % a == 0:
print("YES")
exit()
print("NO")
| false | 0 | [
"-for i in range(1, 1000000):",
"+for i in range(1, 10000):"
] | false | 0.152438 | 0.081981 | 1.859433 | [
"s302560136",
"s826480599"
] |
u678167152 | p02658 | python | s884834183 | s447646494 | 81 | 48 | 84,516 | 21,744 | Accepted | Accepted | 40.74 | def solve():
N = int(eval(input()))
A = list(map(int, input().split()))
if 0 in A:
return 0
prod = 1
for i in range(N):
if 10**18//prod < A[i]:
return -1
prod *= A[i]
return prod
print((solve())) | def solve():
n = int(eval(input()))
a = list(map(int, input().split()))
ans = 1
if 0 in a: return 0
for i in a:
ans *= i
if ans > int(1e18): return -1
return ans
print((solve()))
| 12 | 15 | 258 | 242 | def solve():
N = int(eval(input()))
A = list(map(int, input().split()))
if 0 in A:
return 0
prod = 1
for i in range(N):
if 10**18 // prod < A[i]:
return -1
prod *= A[i]
return prod
print((solve()))
| def solve():
n = int(eval(input()))
a = list(map(int, input().split()))
ans = 1
if 0 in a:
return 0
for i in a:
ans *= i
if ans > int(1e18):
return -1
return ans
print((solve()))
| false | 20 | [
"- N = int(eval(input()))",
"- A = list(map(int, input().split()))",
"- if 0 in A:",
"+ n = int(eval(input()))",
"+ a = list(map(int, input().split()))",
"+ ans = 1",
"+ if 0 in a:",
"- prod = 1",
"- for i in range(N):",
"- if 10**18 // prod < A[i]:",
"+ for i in a:",
"+ ans *= i",
"+ if ans > int(1e18):",
"- prod *= A[i]",
"- return prod",
"+ return ans"
] | false | 0.038618 | 0.037842 | 1.020525 | [
"s884834183",
"s447646494"
] |
u077898957 | p03308 | python | s676784799 | s752011594 | 20 | 17 | 2,940 | 2,940 | Accepted | Accepted | 15 | n = eval(input())
a = sorted(map(int,input().split()))
print((a[-1]-a[0]))
| n=int(eval(input()))
A=list(map(int,input().split()))
print((max(A)-min(A)))
| 3 | 3 | 69 | 71 | n = eval(input())
a = sorted(map(int, input().split()))
print((a[-1] - a[0]))
| n = int(eval(input()))
A = list(map(int, input().split()))
print((max(A) - min(A)))
| false | 0 | [
"-n = eval(input())",
"-a = sorted(map(int, input().split()))",
"-print((a[-1] - a[0]))",
"+n = int(eval(input()))",
"+A = list(map(int, input().split()))",
"+print((max(A) - min(A)))"
] | false | 0.078544 | 0.065438 | 1.200281 | [
"s676784799",
"s752011594"
] |
u867848444 | p03053 | python | s356997912 | s018879594 | 657 | 491 | 121,308 | 121,692 | Accepted | Accepted | 25.27 | h,w=list(map(int,input().split()))
a=[list(eval(input())) for i in range(h)]
#上下左右のマスを黒くしていく
#BFS
from collections import deque
def bfs():
dx=[0,1,0,-1]
dy=[1,0,-1,0]
log=[[0]*w for i in range(h)]
que=deque()
for i in range(h):
for j in range(w):
if a[i][j]=='#':
que.append((i,j))
while que:
#queの先頭を取り出す
p=que.popleft()
for i in range(4):
nx=p[0]+dx[i]
ny=p[1]+dy[i]
if not(0<=nx<h and 0<=ny<w):continue
if a[nx][ny]=='#':continue
que.append((nx,ny))
log[nx][ny]=log[p[0]][p[1]]+1
a[nx][ny]='#'
return log
G=bfs()
ans=0
for i in range(h):
for j in range(w):
if ans<G[i][j]:
ans=G[i][j]
print(ans) | h,w=list(map(int,input().split()))
a=[list(eval(input())) for i in range(h)]
#上下左右のマスを黒くしていく
#BFS
from collections import deque
def bfs():
dx=[0,1,0,-1]
dy=[1,0,-1,0]
log=[[-1]*w for i in range(h)]
que=deque()
for i in range(h):
for j in range(w):
if a[i][j]=='#':
que.append((i,j))
log[i][j]=0
while que:
#queの先頭を取り出す
p=que.popleft()
for i in range(4):
nx=p[0]+dx[i]
ny=p[1]+dy[i]
if not(0<=nx<h and 0<=ny<w):continue
if log[nx][ny]!=-1:continue
que.append((nx,ny))
log[nx][ny]=log[p[0]][p[1]]+1
return log
G=bfs()
ans=0
for i in range(h):
for j in range(w):
if ans<G[i][j]:
ans=G[i][j]
print(ans)
#print(*G,sep='\n') | 39 | 40 | 826 | 851 | h, w = list(map(int, input().split()))
a = [list(eval(input())) for i in range(h)]
# 上下左右のマスを黒くしていく
# BFS
from collections import deque
def bfs():
dx = [0, 1, 0, -1]
dy = [1, 0, -1, 0]
log = [[0] * w for i in range(h)]
que = deque()
for i in range(h):
for j in range(w):
if a[i][j] == "#":
que.append((i, j))
while que:
# queの先頭を取り出す
p = que.popleft()
for i in range(4):
nx = p[0] + dx[i]
ny = p[1] + dy[i]
if not (0 <= nx < h and 0 <= ny < w):
continue
if a[nx][ny] == "#":
continue
que.append((nx, ny))
log[nx][ny] = log[p[0]][p[1]] + 1
a[nx][ny] = "#"
return log
G = bfs()
ans = 0
for i in range(h):
for j in range(w):
if ans < G[i][j]:
ans = G[i][j]
print(ans)
| h, w = list(map(int, input().split()))
a = [list(eval(input())) for i in range(h)]
# 上下左右のマスを黒くしていく
# BFS
from collections import deque
def bfs():
dx = [0, 1, 0, -1]
dy = [1, 0, -1, 0]
log = [[-1] * w for i in range(h)]
que = deque()
for i in range(h):
for j in range(w):
if a[i][j] == "#":
que.append((i, j))
log[i][j] = 0
while que:
# queの先頭を取り出す
p = que.popleft()
for i in range(4):
nx = p[0] + dx[i]
ny = p[1] + dy[i]
if not (0 <= nx < h and 0 <= ny < w):
continue
if log[nx][ny] != -1:
continue
que.append((nx, ny))
log[nx][ny] = log[p[0]][p[1]] + 1
return log
G = bfs()
ans = 0
for i in range(h):
for j in range(w):
if ans < G[i][j]:
ans = G[i][j]
print(ans)
# print(*G,sep='\n')
| false | 2.5 | [
"- log = [[0] * w for i in range(h)]",
"+ log = [[-1] * w for i in range(h)]",
"+ log[i][j] = 0",
"- if a[nx][ny] == \"#\":",
"+ if log[nx][ny] != -1:",
"- a[nx][ny] = \"#\"",
"+# print(*G,sep='\\n')"
] | false | 0.036757 | 0.041867 | 0.877946 | [
"s356997912",
"s018879594"
] |
u925364229 | p03165 | python | s176277097 | s854036425 | 1,818 | 1,593 | 307,848 | 308,360 | Accepted | Accepted | 12.38 | import sys
s = sys.stdin.readline()
t = sys.stdin.readline()
# dp[i][j] = LCS(s[:i],t[:j])
sLen, tLen = len(s),len(t),
dp = [ [( 0 , -1 )]*(tLen+1) for _ in range(sLen+1) ]
for i in range(1,sLen+1):
for j in range(1,tLen+1):
comp = [ dp[i][j-1][0],dp[i-1][j-1][0]+int(s[i-1]==t[j-1]),dp[i-1][j][0]]
argmax = comp.index(max(comp))
dp[i][j] = ( comp[argmax] , argmax )
ans = ""
i,j = sLen, tLen
for _ in range(sLen+tLen):
if dp[i][j][1] == 0:
j -= 1
elif dp[i][j][1] == 1:
ans += s[i-1]
i -= 1
j -= 1
elif dp[i][j][1] == 2:
i -= 1
else:
break
print((ans[::-1])) | import sys
def solve():
# dp[i][j] = LCS(s[:i+1],t[:j+1])
sLen, tLen = len(s),len(t),
dp = [ [( 0 , -1 )]*(tLen+1) for _ in range(sLen+1) ]
for i in range(1,sLen+1):
for j in range(1,tLen+1):
comp = [ dp[i][j-1][0],dp[i-1][j-1][0]+int(s[i-1]==t[j-1]),dp[i-1][j][0]]
argmax = comp.index(max(comp))
dp[i][j] = ( comp[argmax] , argmax )
ans = ""
i,j = sLen, tLen
for _ in range(sLen+tLen):
if dp[i][j][1] == 0:
j -= 1
elif dp[i][j][1] == 1:
ans += s[i-1]
i -= 1
j -= 1
elif dp[i][j][1] == 2:
i -= 1
else:
break
return ans[::-1]
if __name__ == '__main__':
s = sys.stdin.readline()
t = sys.stdin.readline()
print((solve())) | 29 | 31 | 682 | 842 | import sys
s = sys.stdin.readline()
t = sys.stdin.readline()
# dp[i][j] = LCS(s[:i],t[:j])
sLen, tLen = (
len(s),
len(t),
)
dp = [[(0, -1)] * (tLen + 1) for _ in range(sLen + 1)]
for i in range(1, sLen + 1):
for j in range(1, tLen + 1):
comp = [
dp[i][j - 1][0],
dp[i - 1][j - 1][0] + int(s[i - 1] == t[j - 1]),
dp[i - 1][j][0],
]
argmax = comp.index(max(comp))
dp[i][j] = (comp[argmax], argmax)
ans = ""
i, j = sLen, tLen
for _ in range(sLen + tLen):
if dp[i][j][1] == 0:
j -= 1
elif dp[i][j][1] == 1:
ans += s[i - 1]
i -= 1
j -= 1
elif dp[i][j][1] == 2:
i -= 1
else:
break
print((ans[::-1]))
| import sys
def solve():
# dp[i][j] = LCS(s[:i+1],t[:j+1])
sLen, tLen = (
len(s),
len(t),
)
dp = [[(0, -1)] * (tLen + 1) for _ in range(sLen + 1)]
for i in range(1, sLen + 1):
for j in range(1, tLen + 1):
comp = [
dp[i][j - 1][0],
dp[i - 1][j - 1][0] + int(s[i - 1] == t[j - 1]),
dp[i - 1][j][0],
]
argmax = comp.index(max(comp))
dp[i][j] = (comp[argmax], argmax)
ans = ""
i, j = sLen, tLen
for _ in range(sLen + tLen):
if dp[i][j][1] == 0:
j -= 1
elif dp[i][j][1] == 1:
ans += s[i - 1]
i -= 1
j -= 1
elif dp[i][j][1] == 2:
i -= 1
else:
break
return ans[::-1]
if __name__ == "__main__":
s = sys.stdin.readline()
t = sys.stdin.readline()
print((solve()))
| false | 6.451613 | [
"-s = sys.stdin.readline()",
"-t = sys.stdin.readline()",
"-# dp[i][j] = LCS(s[:i],t[:j])",
"-sLen, tLen = (",
"- len(s),",
"- len(t),",
"-)",
"-dp = [[(0, -1)] * (tLen + 1) for _ in range(sLen + 1)]",
"-for i in range(1, sLen + 1):",
"- for j in range(1, tLen + 1):",
"- comp = [",
"- dp[i][j - 1][0],",
"- dp[i - 1][j - 1][0] + int(s[i - 1] == t[j - 1]),",
"- dp[i - 1][j][0],",
"- ]",
"- argmax = comp.index(max(comp))",
"- dp[i][j] = (comp[argmax], argmax)",
"-ans = \"\"",
"-i, j = sLen, tLen",
"-for _ in range(sLen + tLen):",
"- if dp[i][j][1] == 0:",
"- j -= 1",
"- elif dp[i][j][1] == 1:",
"- ans += s[i - 1]",
"- i -= 1",
"- j -= 1",
"- elif dp[i][j][1] == 2:",
"- i -= 1",
"- else:",
"- break",
"-print((ans[::-1]))",
"+",
"+def solve():",
"+ # dp[i][j] = LCS(s[:i+1],t[:j+1])",
"+ sLen, tLen = (",
"+ len(s),",
"+ len(t),",
"+ )",
"+ dp = [[(0, -1)] * (tLen + 1) for _ in range(sLen + 1)]",
"+ for i in range(1, sLen + 1):",
"+ for j in range(1, tLen + 1):",
"+ comp = [",
"+ dp[i][j - 1][0],",
"+ dp[i - 1][j - 1][0] + int(s[i - 1] == t[j - 1]),",
"+ dp[i - 1][j][0],",
"+ ]",
"+ argmax = comp.index(max(comp))",
"+ dp[i][j] = (comp[argmax], argmax)",
"+ ans = \"\"",
"+ i, j = sLen, tLen",
"+ for _ in range(sLen + tLen):",
"+ if dp[i][j][1] == 0:",
"+ j -= 1",
"+ elif dp[i][j][1] == 1:",
"+ ans += s[i - 1]",
"+ i -= 1",
"+ j -= 1",
"+ elif dp[i][j][1] == 2:",
"+ i -= 1",
"+ else:",
"+ break",
"+ return ans[::-1]",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ s = sys.stdin.readline()",
"+ t = sys.stdin.readline()",
"+ print((solve()))"
] | false | 0.048995 | 0.037823 | 1.295361 | [
"s176277097",
"s854036425"
] |
u235210692 | p02727 | python | s232904593 | s471141110 | 223 | 172 | 29,444 | 29,608 | Accepted | Accepted | 22.87 | x,y,a,b,c=[int(i) for i in input().split()]
red_list=[int(i) for i in input().split()]
green_list=[int(i) for i in input().split()]
non_col_list=[int(i) for i in input().split()]
red_list.sort()
green_list.sort()
non_col_list.sort()
eat_red=[]
eat_green=[]
for i in range(x):
eat_red.append(red_list.pop())
for i in range(y):
eat_green.append(green_list.pop())
ans_list=eat_green+eat_red+non_col_list
ans_list.sort()
ans=0
for i in range(x+y):
ans+=ans_list.pop()
print(ans) | x,y,a,b,c=[int(i) for i in input().split()]
p=[int(i) for i in input().split()]
q=[int(i) for i in input().split()]
r=[int(i) for i in input().split()]
p.sort()
q.sort()
r.sort()
p=p[-x:]
q=q[-y:]
ans=p+q+r
ans.sort()
ans=ans[-x-y:]
print((sum(ans)))
| 25 | 16 | 516 | 267 | x, y, a, b, c = [int(i) for i in input().split()]
red_list = [int(i) for i in input().split()]
green_list = [int(i) for i in input().split()]
non_col_list = [int(i) for i in input().split()]
red_list.sort()
green_list.sort()
non_col_list.sort()
eat_red = []
eat_green = []
for i in range(x):
eat_red.append(red_list.pop())
for i in range(y):
eat_green.append(green_list.pop())
ans_list = eat_green + eat_red + non_col_list
ans_list.sort()
ans = 0
for i in range(x + y):
ans += ans_list.pop()
print(ans)
| x, y, a, b, c = [int(i) for i in input().split()]
p = [int(i) for i in input().split()]
q = [int(i) for i in input().split()]
r = [int(i) for i in input().split()]
p.sort()
q.sort()
r.sort()
p = p[-x:]
q = q[-y:]
ans = p + q + r
ans.sort()
ans = ans[-x - y :]
print((sum(ans)))
| false | 36 | [
"-red_list = [int(i) for i in input().split()]",
"-green_list = [int(i) for i in input().split()]",
"-non_col_list = [int(i) for i in input().split()]",
"-red_list.sort()",
"-green_list.sort()",
"-non_col_list.sort()",
"-eat_red = []",
"-eat_green = []",
"-for i in range(x):",
"- eat_red.append(red_list.pop())",
"-for i in range(y):",
"- eat_green.append(green_list.pop())",
"-ans_list = eat_green + eat_red + non_col_list",
"-ans_list.sort()",
"-ans = 0",
"-for i in range(x + y):",
"- ans += ans_list.pop()",
"-print(ans)",
"+p = [int(i) for i in input().split()]",
"+q = [int(i) for i in input().split()]",
"+r = [int(i) for i in input().split()]",
"+p.sort()",
"+q.sort()",
"+r.sort()",
"+p = p[-x:]",
"+q = q[-y:]",
"+ans = p + q + r",
"+ans.sort()",
"+ans = ans[-x - y :]",
"+print((sum(ans)))"
] | false | 0.087437 | 0.07974 | 1.096522 | [
"s232904593",
"s471141110"
] |
u229478139 | p02406 | python | s965000834 | s399538120 | 30 | 20 | 5,872 | 5,868 | Accepted | Accepted | 33.33 | n = int(input())
for i in range(1, n + 1):
if i % 3 == 0 or str(i).find("3") != -1:
print(" {}".format(i), end = '')
print()
| n = int(input())
for i in range(1, n + 1):
if i % 3 == 0 or '3' in str(i):
print(' ' + str(i), end='')
print()
| 5 | 5 | 141 | 127 | n = int(input())
for i in range(1, n + 1):
if i % 3 == 0 or str(i).find("3") != -1:
print(" {}".format(i), end="")
print()
| n = int(input())
for i in range(1, n + 1):
if i % 3 == 0 or "3" in str(i):
print(" " + str(i), end="")
print()
| false | 0 | [
"- if i % 3 == 0 or str(i).find(\"3\") != -1:",
"- print(\" {}\".format(i), end=\"\")",
"+ if i % 3 == 0 or \"3\" in str(i):",
"+ print(\" \" + str(i), end=\"\")"
] | false | 0.049965 | 0.050252 | 0.994302 | [
"s965000834",
"s399538120"
] |
u535803878 | p03634 | python | s696198258 | s721765467 | 905 | 408 | 164,968 | 145,152 | Accepted | Accepted | 54.92 | import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")
n = int(eval(input()))
from collections import defaultdict
ns = defaultdict(set)
for i in range(n-1):
u,v,c = list(map(int, input().split()))
u -= 1
v -= 1
ns[u].add((c,v))
ns[v].add((c,u))
# print(ns)
k = len(bin(n-1))-2
# 深さ
def cdepth(root=0):
# rootを根としたときの深さ
ps = [None] * n
ps[0] = -1
q = [0]
while q:
u = q.pop()
for c,v in ns[u]:
if ps[v] is None:
ps[v] = u
q.append(v)
# psを元から持っている場合、引数のnsをpsにしてこの下だけで良い
depth = [None] * n
depth[root] = 0
q = [root]
while q:
u = q.pop()
for c,v in ns[u]:
if depth[v] is None:
depth[v] = depth[u] + 1
q.append(v)
return depth, ps
def dijkstra(start):
import heapq
vals = [None] * n
h = [(0, start)] # (距離, ノード番号)
vals[start] = 0
while h:
val, u = heapq.heappop(h)
for d, v in ns[u]:
if vals[v] is None or vals[v]>val+d:
vals[v] = val+d
heapq.heappush(h, (vals[v], v))
return vals
# ダブリング
def double(ps):
# global: n=psのサイズ
k = 0
while pow(2,k)<n:
k += 1
prev = [[None]*n for _ in range(k)] # ノードjから2^i個上の上司
for j in range(n):
prev[0][j] = ps[j]
for i in range(1,k):
for j in range(n):
p = prev[i-1][j]
if p>=0:
prev[i][j] = prev[i-1][p]
else:
prev[i][j] = p
return prev
# k: 必要桁数を定める必要アリ
def cprev(u,i):
"""uからi個上の頂点を返す
"""
for j in range(k):
if i>>j&1:
u = prev[j][u]
return u
# k: 必要桁数を定める必要アリ
def lca(u,v):
if depth[u]<depth[v]:
v = cprev(v, depth[v]-depth[u])
else:
u = cprev(u, depth[u]-depth[v])
if u==v:
return u
for i in range(k-1, -1, -1):
if prev[i][u]!=prev[i][v]:
u = prev[i][u]
v = prev[i][v]
return prev[0][u]
dist = dijkstra(0)
depth, ps = cdepth(0)
prev = double(ps)
q,K = list(map(int, input().split()))
K -= 1
ans = [None]*q
for i in range(q):
x,y = list(map(int, input().split()))
x -= 1
y -= 1
l1 = lca(x,K)
l2 = lca(y,K)
# print(x,y,l1,l2)
ans[i] = (dist[x]+dist[K]-2*dist[l1]) + (dist[y]+dist[K]-2*dist[l2])
write("\n".join(map(str, ans))) | import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")
n = int(eval(input()))
from collections import defaultdict
ns = defaultdict(set)
for i in range(n-1):
u,v,c = list(map(int, input().split()))
u -= 1
v -= 1
ns[u].add((c,v))
ns[v].add((c,u))
# print(ns)
k = len(bin(n-1))-2
# 深さ
def cdepth(root=0):
# rootを根としたときの深さ
ps = [None] * n
ps[0] = -1
q = [0]
while q:
u = q.pop()
for c,v in ns[u]:
if ps[v] is None:
ps[v] = u
q.append(v)
# psを元から持っている場合、引数のnsをpsにしてこの下だけで良い
depth = [None] * n
depth[root] = 0
q = [root]
while q:
u = q.pop()
for c,v in ns[u]:
if depth[v] is None:
depth[v] = depth[u] + 1
q.append(v)
return depth, ps
def dijkstra(start):
import heapq
vals = [None] * n
h = [(0, start)] # (距離, ノード番号)
vals[start] = 0
while h:
val, u = heapq.heappop(h)
for d, v in ns[u]:
if vals[v] is None or vals[v]>val+d:
vals[v] = val+d
heapq.heappush(h, (vals[v], v))
return vals
# ダブリング
def double(ps):
# global: n=psのサイズ
k = 0
while pow(2,k)<n:
k += 1
prev = [[None]*n for _ in range(k)] # ノードjから2^i個上の上司
for j in range(n):
prev[0][j] = ps[j]
for i in range(1,k):
for j in range(n):
p = prev[i-1][j]
if p>=0:
prev[i][j] = prev[i-1][p]
else:
prev[i][j] = p
return prev
# k: 必要桁数を定める必要アリ
def cprev(u,i):
"""uからi個上の頂点を返す
"""
for j in range(k):
if i>>j&1:
u = prev[j][u]
return u
# k: 必要桁数を定める必要アリ
def lca(u,v):
if depth[u]<depth[v]:
v = cprev(v, depth[v]-depth[u])
else:
u = cprev(u, depth[u]-depth[v])
if u==v:
return u
for i in range(k-1, -1, -1):
if prev[i][u]!=prev[i][v]:
u = prev[i][u]
v = prev[i][v]
return prev[0][u]
q,K = list(map(int, input().split()))
K -= 1
dist = dijkstra(K)
ans = [None]*q
for i in range(q):
x,y = list(map(int, input().split()))
x -= 1
y -= 1
ans[i] = dist[x] + dist[y]
write("\n".join(map(str, ans))) | 110 | 105 | 2,577 | 2,431 | import sys
input = lambda: sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x + "\n")
n = int(eval(input()))
from collections import defaultdict
ns = defaultdict(set)
for i in range(n - 1):
u, v, c = list(map(int, input().split()))
u -= 1
v -= 1
ns[u].add((c, v))
ns[v].add((c, u))
# print(ns)
k = len(bin(n - 1)) - 2
# 深さ
def cdepth(root=0):
# rootを根としたときの深さ
ps = [None] * n
ps[0] = -1
q = [0]
while q:
u = q.pop()
for c, v in ns[u]:
if ps[v] is None:
ps[v] = u
q.append(v)
# psを元から持っている場合、引数のnsをpsにしてこの下だけで良い
depth = [None] * n
depth[root] = 0
q = [root]
while q:
u = q.pop()
for c, v in ns[u]:
if depth[v] is None:
depth[v] = depth[u] + 1
q.append(v)
return depth, ps
def dijkstra(start):
import heapq
vals = [None] * n
h = [(0, start)] # (距離, ノード番号)
vals[start] = 0
while h:
val, u = heapq.heappop(h)
for d, v in ns[u]:
if vals[v] is None or vals[v] > val + d:
vals[v] = val + d
heapq.heappush(h, (vals[v], v))
return vals
# ダブリング
def double(ps):
# global: n=psのサイズ
k = 0
while pow(2, k) < n:
k += 1
prev = [[None] * n for _ in range(k)] # ノードjから2^i個上の上司
for j in range(n):
prev[0][j] = ps[j]
for i in range(1, k):
for j in range(n):
p = prev[i - 1][j]
if p >= 0:
prev[i][j] = prev[i - 1][p]
else:
prev[i][j] = p
return prev
# k: 必要桁数を定める必要アリ
def cprev(u, i):
"""uからi個上の頂点を返す"""
for j in range(k):
if i >> j & 1:
u = prev[j][u]
return u
# k: 必要桁数を定める必要アリ
def lca(u, v):
if depth[u] < depth[v]:
v = cprev(v, depth[v] - depth[u])
else:
u = cprev(u, depth[u] - depth[v])
if u == v:
return u
for i in range(k - 1, -1, -1):
if prev[i][u] != prev[i][v]:
u = prev[i][u]
v = prev[i][v]
return prev[0][u]
dist = dijkstra(0)
depth, ps = cdepth(0)
prev = double(ps)
q, K = list(map(int, input().split()))
K -= 1
ans = [None] * q
for i in range(q):
x, y = list(map(int, input().split()))
x -= 1
y -= 1
l1 = lca(x, K)
l2 = lca(y, K)
# print(x,y,l1,l2)
ans[i] = (dist[x] + dist[K] - 2 * dist[l1]) + (dist[y] + dist[K] - 2 * dist[l2])
write("\n".join(map(str, ans)))
| import sys
input = lambda: sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x + "\n")
n = int(eval(input()))
from collections import defaultdict
ns = defaultdict(set)
for i in range(n - 1):
u, v, c = list(map(int, input().split()))
u -= 1
v -= 1
ns[u].add((c, v))
ns[v].add((c, u))
# print(ns)
k = len(bin(n - 1)) - 2
# 深さ
def cdepth(root=0):
# rootを根としたときの深さ
ps = [None] * n
ps[0] = -1
q = [0]
while q:
u = q.pop()
for c, v in ns[u]:
if ps[v] is None:
ps[v] = u
q.append(v)
# psを元から持っている場合、引数のnsをpsにしてこの下だけで良い
depth = [None] * n
depth[root] = 0
q = [root]
while q:
u = q.pop()
for c, v in ns[u]:
if depth[v] is None:
depth[v] = depth[u] + 1
q.append(v)
return depth, ps
def dijkstra(start):
import heapq
vals = [None] * n
h = [(0, start)] # (距離, ノード番号)
vals[start] = 0
while h:
val, u = heapq.heappop(h)
for d, v in ns[u]:
if vals[v] is None or vals[v] > val + d:
vals[v] = val + d
heapq.heappush(h, (vals[v], v))
return vals
# ダブリング
def double(ps):
# global: n=psのサイズ
k = 0
while pow(2, k) < n:
k += 1
prev = [[None] * n for _ in range(k)] # ノードjから2^i個上の上司
for j in range(n):
prev[0][j] = ps[j]
for i in range(1, k):
for j in range(n):
p = prev[i - 1][j]
if p >= 0:
prev[i][j] = prev[i - 1][p]
else:
prev[i][j] = p
return prev
# k: 必要桁数を定める必要アリ
def cprev(u, i):
"""uからi個上の頂点を返す"""
for j in range(k):
if i >> j & 1:
u = prev[j][u]
return u
# k: 必要桁数を定める必要アリ
def lca(u, v):
if depth[u] < depth[v]:
v = cprev(v, depth[v] - depth[u])
else:
u = cprev(u, depth[u] - depth[v])
if u == v:
return u
for i in range(k - 1, -1, -1):
if prev[i][u] != prev[i][v]:
u = prev[i][u]
v = prev[i][v]
return prev[0][u]
q, K = list(map(int, input().split()))
K -= 1
dist = dijkstra(K)
ans = [None] * q
for i in range(q):
x, y = list(map(int, input().split()))
x -= 1
y -= 1
ans[i] = dist[x] + dist[y]
write("\n".join(map(str, ans)))
| false | 4.545455 | [
"-dist = dijkstra(0)",
"-depth, ps = cdepth(0)",
"-prev = double(ps)",
"+dist = dijkstra(K)",
"- l1 = lca(x, K)",
"- l2 = lca(y, K)",
"- # print(x,y,l1,l2)",
"- ans[i] = (dist[x] + dist[K] - 2 * dist[l1]) + (dist[y] + dist[K] - 2 * dist[l2])",
"+ ans[i] = dist[x] + dist[y]"
] | false | 0.094119 | 0.046402 | 2.02834 | [
"s696198258",
"s721765467"
] |
u843169619 | p02406 | python | s306959107 | s699590660 | 30 | 20 | 5,876 | 6,124 | Accepted | Accepted | 33.33 | n = int(input())
for i in range(1,n+1):
if i % 3 == 0:
print(" {0}".format(i), end="")
else:
x = i
while x != 0:
if x % 10 == 3:
print(" {0}".format(i), end="")
break;
x //= 10;
print("")
| n=int(input())
d=[]
for i in range(3,n+1):
if i%3==0 or "3" in str(i):
d.append(i)
print(' ',end="")
print(*d)
| 12 | 7 | 287 | 129 | n = int(input())
for i in range(1, n + 1):
if i % 3 == 0:
print(" {0}".format(i), end="")
else:
x = i
while x != 0:
if x % 10 == 3:
print(" {0}".format(i), end="")
break
x //= 10
print("")
| n = int(input())
d = []
for i in range(3, n + 1):
if i % 3 == 0 or "3" in str(i):
d.append(i)
print(" ", end="")
print(*d)
| false | 41.666667 | [
"-for i in range(1, n + 1):",
"- if i % 3 == 0:",
"- print(\" {0}\".format(i), end=\"\")",
"- else:",
"- x = i",
"- while x != 0:",
"- if x % 10 == 3:",
"- print(\" {0}\".format(i), end=\"\")",
"- break",
"- x //= 10",
"-print(\"\")",
"+d = []",
"+for i in range(3, n + 1):",
"+ if i % 3 == 0 or \"3\" in str(i):",
"+ d.append(i)",
"+print(\" \", end=\"\")",
"+print(*d)"
] | false | 0.036444 | 0.043931 | 0.829567 | [
"s306959107",
"s699590660"
] |
u124589361 | p02972 | python | s650316726 | s171702214 | 1,956 | 239 | 36,928 | 21,260 | Accepted | Accepted | 87.78 | #######################################
import numpy as np
#######################################
n = int(eval(input()))
a = np.array(list(map(int, input().split())))
ret = np.zeros(n+1, dtype="int")
tmp = list(range(n+1))
ret2 = []
for i in reversed(list(range(n))):
if sum(ret[::i+1][1:])%2 != a[i]:
ret[i+1] = 1
ret2.append(i+1)
print((sum(ret[1:])))
print((" ".join(list(map(str, ret2[::-1]))))) | n = int(eval(input()))
a = list(map(int, input().split()))
ret = [0]*(n+1)
ret2 = []
for i in reversed(list(range(n))):
if sum(ret[::i+1][1:])%2 != a[i]:
ret[i+1] = 1
ret2.append(i+1)
print((sum(ret[1:])))
print((" ".join(list(map(str, ret2[::-1]))))) | 16 | 12 | 418 | 265 | #######################################
import numpy as np
#######################################
n = int(eval(input()))
a = np.array(list(map(int, input().split())))
ret = np.zeros(n + 1, dtype="int")
tmp = list(range(n + 1))
ret2 = []
for i in reversed(list(range(n))):
if sum(ret[:: i + 1][1:]) % 2 != a[i]:
ret[i + 1] = 1
ret2.append(i + 1)
print((sum(ret[1:])))
print((" ".join(list(map(str, ret2[::-1])))))
| n = int(eval(input()))
a = list(map(int, input().split()))
ret = [0] * (n + 1)
ret2 = []
for i in reversed(list(range(n))):
if sum(ret[:: i + 1][1:]) % 2 != a[i]:
ret[i + 1] = 1
ret2.append(i + 1)
print((sum(ret[1:])))
print((" ".join(list(map(str, ret2[::-1])))))
| false | 25 | [
"-#######################################",
"-import numpy as np",
"-",
"-#######################################",
"-a = np.array(list(map(int, input().split())))",
"-ret = np.zeros(n + 1, dtype=\"int\")",
"-tmp = list(range(n + 1))",
"+a = list(map(int, input().split()))",
"+ret = [0] * (n + 1)"
] | false | 0.166484 | 0.037845 | 4.399089 | [
"s650316726",
"s171702214"
] |
u698919163 | p02630 | python | s449543521 | s438796316 | 789 | 494 | 32,092 | 20,948 | Accepted | Accepted | 37.39 | N = int(eval(input()))
A = list(map(int,input().split()))
Q = int(eval(input()))
import numpy as np
num_count = [0]*(10**5+1)
num_count = np.array(num_count)
tmp = np.arange(10**5+1)
tmp_sum = sum(A)
for i in A:
num_count[i] += 1
for q in range(Q):
B,C = list(map(int,input().split()))
tmp_C = C*(num_count[B])
tmp_B = B*(num_count[B])
num_count[C] += num_count[B]
num_count[B] = 0
tmp_sum = tmp_sum + tmp_C - tmp_B
print(tmp_sum) | N = int(eval(input()))
A = list(map(int,input().split()))
num_count = [0]*(10**5+1)
tmp_sum = sum(A)
for i in A:
num_count[i] += 1
for q in range(int(eval(input()))):
B,C = list(map(int,input().split()))
gain = C*(num_count[B])
loss = B*(num_count[B])
num_count[C] += num_count[B]
num_count[B] = 0
tmp_sum = tmp_sum + gain - loss
print(tmp_sum)
| 20 | 16 | 465 | 376 | N = int(eval(input()))
A = list(map(int, input().split()))
Q = int(eval(input()))
import numpy as np
num_count = [0] * (10**5 + 1)
num_count = np.array(num_count)
tmp = np.arange(10**5 + 1)
tmp_sum = sum(A)
for i in A:
num_count[i] += 1
for q in range(Q):
B, C = list(map(int, input().split()))
tmp_C = C * (num_count[B])
tmp_B = B * (num_count[B])
num_count[C] += num_count[B]
num_count[B] = 0
tmp_sum = tmp_sum + tmp_C - tmp_B
print(tmp_sum)
| N = int(eval(input()))
A = list(map(int, input().split()))
num_count = [0] * (10**5 + 1)
tmp_sum = sum(A)
for i in A:
num_count[i] += 1
for q in range(int(eval(input()))):
B, C = list(map(int, input().split()))
gain = C * (num_count[B])
loss = B * (num_count[B])
num_count[C] += num_count[B]
num_count[B] = 0
tmp_sum = tmp_sum + gain - loss
print(tmp_sum)
| false | 20 | [
"-Q = int(eval(input()))",
"-import numpy as np",
"-",
"-num_count = np.array(num_count)",
"-tmp = np.arange(10**5 + 1)",
"-for q in range(Q):",
"+for q in range(int(eval(input()))):",
"- tmp_C = C * (num_count[B])",
"- tmp_B = B * (num_count[B])",
"+ gain = C * (num_count[B])",
"+ loss = B * (num_count[B])",
"- tmp_sum = tmp_sum + tmp_C - tmp_B",
"+ tmp_sum = tmp_sum + gain - loss"
] | false | 0.492447 | 0.046505 | 10.589177 | [
"s449543521",
"s438796316"
] |
u007270338 | p02238 | python | s379116415 | s705130659 | 40 | 30 | 6,640 | 6,372 | Accepted | Accepted | 25 | #coding:utf-8
from copy import deepcopy
n = int(eval(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
| #coding:utf-8
from copy import deepcopy
n = int(eval(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
objList = [DFS(i+1) for i in range(n)]
for i in range(n):
data = list(map(int,input().split()))
times = data[1]
obj = objList[i]
for j in range(times):
index = data[2+j] - 1
nextobj = DFS(index+1)
obj.nex = nextobj
obj = obj.nex
time = 1
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
if v != None:
objList[index] = v
if c[v.key - 1] == "white":
index = v.key - 1
v = objList[index]
c[v.key-1] = "gray"
time += 1
d[index] = time
S.append(v.key)
else:
S.pop()
c[u.key-1] = "black"
time += 1
f[index] = time
return time
for i in range(n):
if f[i] == 0:
time = check(i,time) + 1
k = 1
for i,j in zip(d,f):
print((k,i,j))
k += 1
| 71 | 68 | 1,583 | 1,462 | # coding:utf-8
from copy import deepcopy
n = int(eval(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
| # coding:utf-8
from copy import deepcopy
n = int(eval(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
objList = [DFS(i + 1) for i in range(n)]
for i in range(n):
data = list(map(int, input().split()))
times = data[1]
obj = objList[i]
for j in range(times):
index = data[2 + j] - 1
nextobj = DFS(index + 1)
obj.nex = nextobj
obj = obj.nex
time = 1
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
if v != None:
objList[index] = v
if c[v.key - 1] == "white":
index = v.key - 1
v = objList[index]
c[v.key - 1] = "gray"
time += 1
d[index] = time
S.append(v.key)
else:
S.pop()
c[u.key - 1] = "black"
time += 1
f[index] = time
return time
for i in range(n):
if f[i] == 0:
time = check(i, time) + 1
k = 1
for i, j in zip(d, f):
print((k, i, j))
k += 1
| false | 4.225352 | [
"-objListCopy = [DFS(i + 1) for i in range(n)]",
"+objList = [DFS(i + 1) for i in range(n)]",
"- obj = objListCopy[i]",
"+ obj = objList[i]",
"-objList = objListCopy[:]",
"- time += 1",
"+ objList[index] = v",
"- objList[index] = v",
"+ time += 1",
"- else:",
"- objList[index] = v",
"- time -= 1",
"+ time += 1",
"- objList = deepcopy(objListCopy)"
] | false | 0.064753 | 0.035498 | 1.824127 | [
"s379116415",
"s705130659"
] |
u346812984 | p03017 | python | s531233203 | s826748459 | 75 | 51 | 6,260 | 3,572 | Accepted | Accepted | 32 | N, A, B, C, D = list(map(int, input().split()))
S = ["#"] + list(eval(input()))
flag = True
for i in range(A, C):
if S[i] == "#" and S[i + 1] == "#":
flag = False
break
else:
for i in range(B, D):
if S[i] == "#" and S[i + 1] == "#":
flag = False
break
if flag:
if C < D:
print("Yes")
else:
for i in range(B, D + 1):
if S[i - 1] == "." and S[i] == "." and S[i + 1] == ".":
print("Yes")
break
else:
print("No")
else:
print("No")
| import sys
sys.setrecursionlimit(10 ** 6)
INF = float("inf")
MOD = 10 ** 9 + 7
def input():
return sys.stdin.readline().strip()
def main():
N, A, B, C, D = list(map(int, input().split()))
A -= 1
B -= 1
C -= 1
D -= 1
S = eval(input())
# 二個以上連続で岩があったら無理
for i in range(A + 1, max(C, D)):
if S[i] == S[i + 1] == "#":
print("No")
return
# 追い抜かす必要がない
if C < D:
print("Yes")
return
else:
# 追い抜かす必要がある
# 3つ以上連続で岩が置かれていない区間があれば良い
for i in range(B - 1, D):
if S[i] == S[i + 1] == S[i + 2] == ".":
print("Yes")
return
print("No")
return
if __name__ == "__main__":
main()
| 26 | 43 | 590 | 785 | N, A, B, C, D = list(map(int, input().split()))
S = ["#"] + list(eval(input()))
flag = True
for i in range(A, C):
if S[i] == "#" and S[i + 1] == "#":
flag = False
break
else:
for i in range(B, D):
if S[i] == "#" and S[i + 1] == "#":
flag = False
break
if flag:
if C < D:
print("Yes")
else:
for i in range(B, D + 1):
if S[i - 1] == "." and S[i] == "." and S[i + 1] == ".":
print("Yes")
break
else:
print("No")
else:
print("No")
| import sys
sys.setrecursionlimit(10**6)
INF = float("inf")
MOD = 10**9 + 7
def input():
return sys.stdin.readline().strip()
def main():
N, A, B, C, D = list(map(int, input().split()))
A -= 1
B -= 1
C -= 1
D -= 1
S = eval(input())
# 二個以上連続で岩があったら無理
for i in range(A + 1, max(C, D)):
if S[i] == S[i + 1] == "#":
print("No")
return
# 追い抜かす必要がない
if C < D:
print("Yes")
return
else:
# 追い抜かす必要がある
# 3つ以上連続で岩が置かれていない区間があれば良い
for i in range(B - 1, D):
if S[i] == S[i + 1] == S[i + 2] == ".":
print("Yes")
return
print("No")
return
if __name__ == "__main__":
main()
| false | 39.534884 | [
"-N, A, B, C, D = list(map(int, input().split()))",
"-S = [\"#\"] + list(eval(input()))",
"-flag = True",
"-for i in range(A, C):",
"- if S[i] == \"#\" and S[i + 1] == \"#\":",
"- flag = False",
"- break",
"-else:",
"- for i in range(B, D):",
"- if S[i] == \"#\" and S[i + 1] == \"#\":",
"- flag = False",
"- break",
"-if flag:",
"+import sys",
"+",
"+sys.setrecursionlimit(10**6)",
"+INF = float(\"inf\")",
"+MOD = 10**9 + 7",
"+",
"+",
"+def input():",
"+ return sys.stdin.readline().strip()",
"+",
"+",
"+def main():",
"+ N, A, B, C, D = list(map(int, input().split()))",
"+ A -= 1",
"+ B -= 1",
"+ C -= 1",
"+ D -= 1",
"+ S = eval(input())",
"+ # 二個以上連続で岩があったら無理",
"+ for i in range(A + 1, max(C, D)):",
"+ if S[i] == S[i + 1] == \"#\":",
"+ print(\"No\")",
"+ return",
"+ # 追い抜かす必要がない",
"+ return",
"- for i in range(B, D + 1):",
"- if S[i - 1] == \".\" and S[i] == \".\" and S[i + 1] == \".\":",
"+ # 追い抜かす必要がある",
"+ # 3つ以上連続で岩が置かれていない区間があれば良い",
"+ for i in range(B - 1, D):",
"+ if S[i] == S[i + 1] == S[i + 2] == \".\":",
"- break",
"- else:",
"- print(\"No\")",
"-else:",
"- print(\"No\")",
"+ return",
"+ print(\"No\")",
"+ return",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ main()"
] | false | 0.045709 | 0.144288 | 0.316788 | [
"s531233203",
"s826748459"
] |
u723711163 | p02720 | python | s864848905 | s230836863 | 480 | 143 | 5,736 | 5,960 | Accepted | Accepted | 70.21 | K = int(eval(input()))
queue = []
for i in range(1, 10):
queue.append(i)
while K != 0:
if K <= len(queue):
print((queue[K-1]))
exit(0)
K -= 1
num = queue.pop(0)
if K == 0:
print(num)
exit(0)
o = int(str(num)[-1])
for n in [o-1, o, o+1]:
if n == -1 or n == 10: continue
queue.append( int(str(num)+str(n)) ) | from collections import deque
K = int(eval(input()))
queue = deque([i for i in range(1,10)])
while K != 0:
if K <= len(queue):
print((queue[K-1]))
exit(0)
K -= 1
num = queue.popleft()
o = int(str(num)[-1])
for n in [o-1, o, o+1]:
if n == -1 or n == 10: continue
queue.append( int(str(num)+str(n)) ) | 21 | 17 | 359 | 336 | K = int(eval(input()))
queue = []
for i in range(1, 10):
queue.append(i)
while K != 0:
if K <= len(queue):
print((queue[K - 1]))
exit(0)
K -= 1
num = queue.pop(0)
if K == 0:
print(num)
exit(0)
o = int(str(num)[-1])
for n in [o - 1, o, o + 1]:
if n == -1 or n == 10:
continue
queue.append(int(str(num) + str(n)))
| from collections import deque
K = int(eval(input()))
queue = deque([i for i in range(1, 10)])
while K != 0:
if K <= len(queue):
print((queue[K - 1]))
exit(0)
K -= 1
num = queue.popleft()
o = int(str(num)[-1])
for n in [o - 1, o, o + 1]:
if n == -1 or n == 10:
continue
queue.append(int(str(num) + str(n)))
| false | 19.047619 | [
"+from collections import deque",
"+",
"-queue = []",
"-for i in range(1, 10):",
"- queue.append(i)",
"+queue = deque([i for i in range(1, 10)])",
"- num = queue.pop(0)",
"- if K == 0:",
"- print(num)",
"- exit(0)",
"+ num = queue.popleft()"
] | false | 0.120926 | 0.071283 | 1.696429 | [
"s864848905",
"s230836863"
] |
u608088992 | p03464 | python | s161994849 | s981307912 | 126 | 101 | 14,252 | 14,196 | Accepted | Accepted | 19.84 | from math import ceil
N = int(eval(input()))
A = [int(a) for a in input().split()]
if A[-1] != 2: print((-1))
else:
PossibleMin, PossibleMax = A[-1], A[-1] + 1
for i in reversed(list(range(N-1))):
PossibleMin = ceil(PossibleMin/A[i]) * A[i]
PossibleMax = (PossibleMax//A[i]) * A[i] + A[i] - 1
if PossibleMax >= PossibleMin: print((PossibleMin, PossibleMax))
else: print((-1))
| import sys
def solve():
input = sys.stdin.readline
K = int(eval(input()))
A = [int(a) for a in input().split()]
if A[K-1] != 2: print((-1))
else:
minN, maxN = 2, 3
for i in reversed(list(range(K - 1))):
if maxN < A[i]:
print((-1))
break
else:
lb = (minN - 1) // A[i]
hb = maxN // A[i]
if lb == hb:
print((-1))
break
else:
minN = A[i] * (lb + 1)
maxN = A[i] * hb + A[i] - 1
else: print((minN, maxN))
return 0
if __name__ == "__main__":
solve() | 12 | 27 | 402 | 704 | from math import ceil
N = int(eval(input()))
A = [int(a) for a in input().split()]
if A[-1] != 2:
print((-1))
else:
PossibleMin, PossibleMax = A[-1], A[-1] + 1
for i in reversed(list(range(N - 1))):
PossibleMin = ceil(PossibleMin / A[i]) * A[i]
PossibleMax = (PossibleMax // A[i]) * A[i] + A[i] - 1
if PossibleMax >= PossibleMin:
print((PossibleMin, PossibleMax))
else:
print((-1))
| import sys
def solve():
input = sys.stdin.readline
K = int(eval(input()))
A = [int(a) for a in input().split()]
if A[K - 1] != 2:
print((-1))
else:
minN, maxN = 2, 3
for i in reversed(list(range(K - 1))):
if maxN < A[i]:
print((-1))
break
else:
lb = (minN - 1) // A[i]
hb = maxN // A[i]
if lb == hb:
print((-1))
break
else:
minN = A[i] * (lb + 1)
maxN = A[i] * hb + A[i] - 1
else:
print((minN, maxN))
return 0
if __name__ == "__main__":
solve()
| false | 55.555556 | [
"-from math import ceil",
"+import sys",
"-N = int(eval(input()))",
"-A = [int(a) for a in input().split()]",
"-if A[-1] != 2:",
"- print((-1))",
"-else:",
"- PossibleMin, PossibleMax = A[-1], A[-1] + 1",
"- for i in reversed(list(range(N - 1))):",
"- PossibleMin = ceil(PossibleMin / A[i]) * A[i]",
"- PossibleMax = (PossibleMax // A[i]) * A[i] + A[i] - 1",
"- if PossibleMax >= PossibleMin:",
"- print((PossibleMin, PossibleMax))",
"+",
"+def solve():",
"+ input = sys.stdin.readline",
"+ K = int(eval(input()))",
"+ A = [int(a) for a in input().split()]",
"+ if A[K - 1] != 2:",
"+ print((-1))",
"- print((-1))",
"+ minN, maxN = 2, 3",
"+ for i in reversed(list(range(K - 1))):",
"+ if maxN < A[i]:",
"+ print((-1))",
"+ break",
"+ else:",
"+ lb = (minN - 1) // A[i]",
"+ hb = maxN // A[i]",
"+ if lb == hb:",
"+ print((-1))",
"+ break",
"+ else:",
"+ minN = A[i] * (lb + 1)",
"+ maxN = A[i] * hb + A[i] - 1",
"+ else:",
"+ print((minN, maxN))",
"+ return 0",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ solve()"
] | false | 0.051739 | 0.051948 | 0.995983 | [
"s161994849",
"s981307912"
] |
u191874006 | p03071 | python | s456995385 | s956627395 | 166 | 67 | 38,384 | 65,540 | Accepted | Accepted | 59.64 | #!/usr/bin/env python3
import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(2147483647)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
a,b = LI()
ans = max(a+a-1,a+b,b+b-1)
print(ans) | #!/usr/bin/env python3
import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(2147483647)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
a, b = LI()
if a != b:
print((max(a, b)*2-1))
else:
print((a+b)) | 22 | 24 | 610 | 632 | #!/usr/bin/env python3
import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(2147483647)
from heapq import heappush, heappop, heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float("inf")
def I():
return int(sys.stdin.readline())
def LI():
return list(map(int, sys.stdin.readline().split()))
a, b = LI()
ans = max(a + a - 1, a + b, b + b - 1)
print(ans)
| #!/usr/bin/env python3
import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(2147483647)
from heapq import heappush, heappop, heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float("inf")
def I():
return int(sys.stdin.readline())
def LI():
return list(map(int, sys.stdin.readline().split()))
a, b = LI()
if a != b:
print((max(a, b) * 2 - 1))
else:
print((a + b))
| false | 8.333333 | [
"-ans = max(a + a - 1, a + b, b + b - 1)",
"-print(ans)",
"+if a != b:",
"+ print((max(a, b) * 2 - 1))",
"+else:",
"+ print((a + b))"
] | false | 0.043482 | 0.044252 | 0.982595 | [
"s456995385",
"s956627395"
] |
u723583932 | p03163 | python | s802649422 | s757824433 | 483 | 320 | 120,728 | 41,824 | Accepted | Accepted | 33.75 | #d
n,W=list(map(int,input().split()))
w=[0]
v=[0]
for i in range(n):
x,y=list(map(int,input().split()))
w.append(x)
v.append(y)
dp=[[0]*(W+1) for i in range(110)]
for i in range(1,n+1):
for j in range(W+1):
dp[i][j]=dp[i-1][j]#if文Falseのときの値に困らないように
if j-w[i]>=0:
dp[i][j]=max(dp[i][j],dp[i-1][j-w[i]]+v[i])
print((dp[n][W]))
| n,W=list(map(int,input().split()))
x=[0]+[-1]*W
for i in range(n):
w,v=list(map(int,input().split()))
for j in range(W-w,-1,-1):
if x[j]>=0:
x[j+w]=max(x[j+w],x[j]+v)
print((max(x))) | 17 | 11 | 373 | 209 | # d
n, W = list(map(int, input().split()))
w = [0]
v = [0]
for i in range(n):
x, y = list(map(int, input().split()))
w.append(x)
v.append(y)
dp = [[0] * (W + 1) for i in range(110)]
for i in range(1, n + 1):
for j in range(W + 1):
dp[i][j] = dp[i - 1][j] # if文Falseのときの値に困らないように
if j - w[i] >= 0:
dp[i][j] = max(dp[i][j], dp[i - 1][j - w[i]] + v[i])
print((dp[n][W]))
| n, W = list(map(int, input().split()))
x = [0] + [-1] * W
for i in range(n):
w, v = list(map(int, input().split()))
for j in range(W - w, -1, -1):
if x[j] >= 0:
x[j + w] = max(x[j + w], x[j] + v)
print((max(x)))
| false | 35.294118 | [
"-# d",
"-w = [0]",
"-v = [0]",
"+x = [0] + [-1] * W",
"- x, y = list(map(int, input().split()))",
"- w.append(x)",
"- v.append(y)",
"-dp = [[0] * (W + 1) for i in range(110)]",
"-for i in range(1, n + 1):",
"- for j in range(W + 1):",
"- dp[i][j] = dp[i - 1][j] # if文Falseのときの値に困らないように",
"- if j - w[i] >= 0:",
"- dp[i][j] = max(dp[i][j], dp[i - 1][j - w[i]] + v[i])",
"-print((dp[n][W]))",
"+ w, v = list(map(int, input().split()))",
"+ for j in range(W - w, -1, -1):",
"+ if x[j] >= 0:",
"+ x[j + w] = max(x[j + w], x[j] + v)",
"+print((max(x)))"
] | false | 0.050887 | 0.039812 | 1.278203 | [
"s802649422",
"s757824433"
] |
u707124227 | p02708 | python | s054754250 | s467503708 | 131 | 64 | 9,176 | 63,588 | Accepted | Accepted | 51.15 | n,k=list(map(int,input().split()))
ans=0
for i in range(k,n+2):
maxs=i*(2*n-i+1)//2
mins=i*(i-1)//2
ans+=maxs-mins+1
ans%=10**9+7
#print('#####')
#print(i)
#print(ans)
print((ans%(10**9+7)))
| n,k=list(map(int,input().split()))
mod=pow(10,9)+7
ans=0
for i in range(k,n+2):
ans+=(i*(n+n-i+1))//2-(i*(i-1))//2+1
ans%=mod
print(ans) | 11 | 7 | 207 | 144 | n, k = list(map(int, input().split()))
ans = 0
for i in range(k, n + 2):
maxs = i * (2 * n - i + 1) // 2
mins = i * (i - 1) // 2
ans += maxs - mins + 1
ans %= 10**9 + 7
# print('#####')
# print(i)
# print(ans)
print((ans % (10**9 + 7)))
| n, k = list(map(int, input().split()))
mod = pow(10, 9) + 7
ans = 0
for i in range(k, n + 2):
ans += (i * (n + n - i + 1)) // 2 - (i * (i - 1)) // 2 + 1
ans %= mod
print(ans)
| false | 36.363636 | [
"+mod = pow(10, 9) + 7",
"- maxs = i * (2 * n - i + 1) // 2",
"- mins = i * (i - 1) // 2",
"- ans += maxs - mins + 1",
"- ans %= 10**9 + 7",
"- # print('#####')",
"- # print(i)",
"- # print(ans)",
"-print((ans % (10**9 + 7)))",
"+ ans += (i * (n + n - i + 1)) // 2 - (i * (i - 1)) // 2 + 1",
"+ ans %= mod",
"+print(ans)"
] | false | 0.051042 | 0.144661 | 0.352835 | [
"s054754250",
"s467503708"
] |
u514401521 | p02843 | python | s784629146 | s056660472 | 540 | 173 | 3,064 | 39,152 | Accepted | Accepted | 67.96 | from itertools import combinations
import sys
"""
10の６条
ijklm
"""
X = int(eval(input()))
P = [1, 2, 3, 4, 5]
if 1 <= X <= 99:
print("0")
sys.exit(0)
a = X % 100
b = X // 100
if a == 0:
print("1")
sys.exit(0)
for i in range(20):
for j in range(25):
for k in range(34):
for l in range(50):
ans = 5 * i + 4 * j + 3 * k + 2 * l
if a -ans <= b - (i + j + k + l) and a - ans >= 0:
print("1")
sys.exit(0)
print('0') | X = int(eval(input()))
flag = False
for i in range(X + 1):
if 100 * i <= X <= 105 * i:
flag = True
if flag:
print((1))
else:
print((0)) | 30 | 9 | 548 | 153 | from itertools import combinations
import sys
"""
10の６条
ijklm
"""
X = int(eval(input()))
P = [1, 2, 3, 4, 5]
if 1 <= X <= 99:
print("0")
sys.exit(0)
a = X % 100
b = X // 100
if a == 0:
print("1")
sys.exit(0)
for i in range(20):
for j in range(25):
for k in range(34):
for l in range(50):
ans = 5 * i + 4 * j + 3 * k + 2 * l
if a - ans <= b - (i + j + k + l) and a - ans >= 0:
print("1")
sys.exit(0)
print("0")
| X = int(eval(input()))
flag = False
for i in range(X + 1):
if 100 * i <= X <= 105 * i:
flag = True
if flag:
print((1))
else:
print((0))
| false | 70 | [
"-from itertools import combinations",
"-import sys",
"-",
"-\"\"\"",
"-10の６条",
"-ijklm",
"-\"\"\"",
"-P = [1, 2, 3, 4, 5]",
"-if 1 <= X <= 99:",
"- print(\"0\")",
"- sys.exit(0)",
"-a = X % 100",
"-b = X // 100",
"-if a == 0:",
"- print(\"1\")",
"- sys.exit(0)",
"-for i in range(20):",
"- for j in range(25):",
"- for k in range(34):",
"- for l in range(50):",
"- ans = 5 * i + 4 * j + 3 * k + 2 * l",
"- if a - ans <= b - (i + j + k + l) and a - ans >= 0:",
"- print(\"1\")",
"- sys.exit(0)",
"-print(\"0\")",
"+flag = False",
"+for i in range(X + 1):",
"+ if 100 * i <= X <= 105 * i:",
"+ flag = True",
"+if flag:",
"+ print((1))",
"+else:",
"+ print((0))"
] | false | 0.263554 | 0.038621 | 6.824148 | [
"s784629146",
"s056660472"
] |
u038024401 | p02832 | python | s227251313 | s200991576 | 126 | 109 | 26,012 | 24,744 | Accepted | Accepted | 13.49 | N = int(eval(input()))
a = list(map(int, input().split()))
A = []
i = 1
j = 0
while j != N:
if a[j] == i:
i += 1
j += 1
else:
if i == 1:
print((-1))
else:
print((N-(i-1))) | N = int(eval(input()))
a = list(map(int, input().split()))
i = 0
for j in range(N):
if a[j] == i+1:
i += 1
else:
if i == 0:
print((-1))
else:
print((N-i))
| 15 | 12 | 216 | 193 | N = int(eval(input()))
a = list(map(int, input().split()))
A = []
i = 1
j = 0
while j != N:
if a[j] == i:
i += 1
j += 1
else:
if i == 1:
print((-1))
else:
print((N - (i - 1)))
| N = int(eval(input()))
a = list(map(int, input().split()))
i = 0
for j in range(N):
if a[j] == i + 1:
i += 1
else:
if i == 0:
print((-1))
else:
print((N - i))
| false | 20 | [
"-A = []",
"-i = 1",
"-j = 0",
"-while j != N:",
"- if a[j] == i:",
"+i = 0",
"+for j in range(N):",
"+ if a[j] == i + 1:",
"- j += 1",
"- if i == 1:",
"+ if i == 0:",
"- print((N - (i - 1)))",
"+ print((N - i))"
] | false | 0.0374 | 0.038364 | 0.97486 | [
"s227251313",
"s200991576"
] |
u150603590 | p03607 | python | s370717375 | s564451803 | 285 | 206 | 7,388 | 11,884 | Accepted | Accepted | 27.72 |
if __name__ == '__main__':
N=int(eval(input()))
sheet=[]
for i in range(N):
temp=int(eval(input()))
sheet.append(temp)
sheet.sort()
count=0
i=0
while i<N:
s=sheet[i]
j=i
while i<N and sheet[i]==s:
i+=1
d=i-j
if d%2==1:
count+=1
print(count) |
if __name__ == '__main__':
N=int(eval(input()))
sheet=set()
for i in range(N):
temp=int(eval(input()))
if temp in sheet:
sheet.remove(temp)
else:
sheet.add(temp)
print((len(sheet)))
| 20 | 11 | 361 | 243 | if __name__ == "__main__":
N = int(eval(input()))
sheet = []
for i in range(N):
temp = int(eval(input()))
sheet.append(temp)
sheet.sort()
count = 0
i = 0
while i < N:
s = sheet[i]
j = i
while i < N and sheet[i] == s:
i += 1
d = i - j
if d % 2 == 1:
count += 1
print(count)
| if __name__ == "__main__":
N = int(eval(input()))
sheet = set()
for i in range(N):
temp = int(eval(input()))
if temp in sheet:
sheet.remove(temp)
else:
sheet.add(temp)
print((len(sheet)))
| false | 45 | [
"- sheet = []",
"+ sheet = set()",
"- sheet.append(temp)",
"- sheet.sort()",
"- count = 0",
"- i = 0",
"- while i < N:",
"- s = sheet[i]",
"- j = i",
"- while i < N and sheet[i] == s:",
"- i += 1",
"- d = i - j",
"- if d % 2 == 1:",
"- count += 1",
"- print(count)",
"+ if temp in sheet:",
"+ sheet.remove(temp)",
"+ else:",
"+ sheet.add(temp)",
"+ print((len(sheet)))"
] | false | 0.0331 | 0.032975 | 1.003787 | [
"s370717375",
"s564451803"
] |
u391589398 | p02684 | python | s481507912 | s877329016 | 143 | 123 | 32,292 | 32,432 | Accepted | Accepted | 13.99 | N, K = list(map(int, input().split()))
A = tuple([int(n) - 1 for n in input().split()])
costs = [-1] * N
loc = 0
if K <= N:
for i in range(K):
loc = A[loc]
print((loc + 1))
else:
costs[loc] = 0
for i in range(1, K):
loc = A[loc]
if costs[loc] >= 0:
break
costs[loc] = i
offset = costs[loc]
loop = i - offset
K -= i
K %= loop
for _ in range(K):
loc = A[loc]
print((loc + 1)) | N, K = list(map(int, input().split()))
# A = tuple(map(lambda n: int(n) - 1, input().split()))
A = tuple(map(int, input().split()))
costs = [-1] * N
loc = 1
if K <= N:
for i in range(K):
loc = A[loc - 1]
print(loc)
else:
costs[loc - 1] = 0
for i in range(1, K):
loc = A[loc - 1]
if costs[loc - 1] >= 0:
break
costs[loc - 1] = i
offset = costs[loc - 1]
loop = i - offset
K -= i
K %= loop
for _ in range(K):
loc = A[loc - 1]
print(loc) | 30 | 31 | 497 | 557 | N, K = list(map(int, input().split()))
A = tuple([int(n) - 1 for n in input().split()])
costs = [-1] * N
loc = 0
if K <= N:
for i in range(K):
loc = A[loc]
print((loc + 1))
else:
costs[loc] = 0
for i in range(1, K):
loc = A[loc]
if costs[loc] >= 0:
break
costs[loc] = i
offset = costs[loc]
loop = i - offset
K -= i
K %= loop
for _ in range(K):
loc = A[loc]
print((loc + 1))
| N, K = list(map(int, input().split()))
# A = tuple(map(lambda n: int(n) - 1, input().split()))
A = tuple(map(int, input().split()))
costs = [-1] * N
loc = 1
if K <= N:
for i in range(K):
loc = A[loc - 1]
print(loc)
else:
costs[loc - 1] = 0
for i in range(1, K):
loc = A[loc - 1]
if costs[loc - 1] >= 0:
break
costs[loc - 1] = i
offset = costs[loc - 1]
loop = i - offset
K -= i
K %= loop
for _ in range(K):
loc = A[loc - 1]
print(loc)
| false | 3.225806 | [
"-A = tuple([int(n) - 1 for n in input().split()])",
"+# A = tuple(map(lambda n: int(n) - 1, input().split()))",
"+A = tuple(map(int, input().split()))",
"-loc = 0",
"+loc = 1",
"- loc = A[loc]",
"- print((loc + 1))",
"+ loc = A[loc - 1]",
"+ print(loc)",
"- costs[loc] = 0",
"+ costs[loc - 1] = 0",
"- loc = A[loc]",
"- if costs[loc] >= 0:",
"+ loc = A[loc - 1]",
"+ if costs[loc - 1] >= 0:",
"- costs[loc] = i",
"- offset = costs[loc]",
"+ costs[loc - 1] = i",
"+ offset = costs[loc - 1]",
"- loc = A[loc]",
"- print((loc + 1))",
"+ loc = A[loc - 1]",
"+ print(loc)"
] | false | 0.059808 | 0.070415 | 0.849376 | [
"s481507912",
"s877329016"
] |
u603049633 | p02317 | python | s369311036 | s296954004 | 1,180 | 140 | 18,772 | 18,744 | Accepted | Accepted | 88.14 | from bisect import bisect
import sys
n = int(eval(input()))
A = [int(i.rstrip("\n")) for i in sys.stdin.readlines()]
#?????????i+1??§???????¢??????¨??????????????????????´????????°???????????´?
L = []
def LIS():
L.append(A[0])
length = 0
for i in range(n):
if L[length] < A[i]:
length += 1
L.append(A[i])
else:
if A[i] in L: continue
j = bisect(L, A[i], 0, length) #L????????§?????????A[i]??\?????¨????????????????????????
L[j] = A[i]
return length + 1
print((LIS())) | from bisect import bisect_left
import sys
n = int(eval(input()))
A = [int(i.rstrip("\n")) for i in sys.stdin.readlines()]
def LIS():
L = A[:1]
for i in A[1:]:
if L[-1] < i:
L.append(i)
else:
j = bisect_left(L, i)
L[j] = i
return len(L)
print((LIS())) | 20 | 17 | 572 | 325 | from bisect import bisect
import sys
n = int(eval(input()))
A = [int(i.rstrip("\n")) for i in sys.stdin.readlines()]
# ?????????i+1??§???????¢??????¨??????????????????????´????????°???????????´?
L = []
def LIS():
L.append(A[0])
length = 0
for i in range(n):
if L[length] < A[i]:
length += 1
L.append(A[i])
else:
if A[i] in L:
continue
j = bisect(
L, A[i], 0, length
) # L????????§?????????A[i]??\?????¨????????????????????????
L[j] = A[i]
return length + 1
print((LIS()))
| from bisect import bisect_left
import sys
n = int(eval(input()))
A = [int(i.rstrip("\n")) for i in sys.stdin.readlines()]
def LIS():
L = A[:1]
for i in A[1:]:
if L[-1] < i:
L.append(i)
else:
j = bisect_left(L, i)
L[j] = i
return len(L)
print((LIS()))
| false | 15 | [
"-from bisect import bisect",
"+from bisect import bisect_left",
"-# ?????????i+1??§???????¢??????¨??????????????????????´????????°???????????´?",
"-L = []",
"- L.append(A[0])",
"- length = 0",
"- for i in range(n):",
"- if L[length] < A[i]:",
"- length += 1",
"- L.append(A[i])",
"+ L = A[:1]",
"+ for i in A[1:]:",
"+ if L[-1] < i:",
"+ L.append(i)",
"- if A[i] in L:",
"- continue",
"- j = bisect(",
"- L, A[i], 0, length",
"- ) # L????????§?????????A[i]??\\?????¨????????????????????????",
"- L[j] = A[i]",
"- return length + 1",
"+ j = bisect_left(L, i)",
"+ L[j] = i",
"+ return len(L)"
] | false | 0.076126 | 0.046871 | 1.624152 | [
"s369311036",
"s296954004"
] |
u697559326 | p03161 | python | s392146022 | s680036008 | 1,954 | 431 | 13,980 | 52,448 | Accepted | Accepted | 77.94 | N,K = list(map(int,input().split()))
H = [int(x) for x in input().split()]
def main(N,K,H):
dp = [0]*N
for i in range(1,N):
L = [dp[j]+abs(H[i]-H[j]) for j in range(max(0,i-K),i)]
dp[i] = min(L)
print((dp[-1]))
main(N,K,H)
| #1:初期化
N, K = list(map(int,input().split()))
#h = list(map(int, input().split()))
h = [int(x) for x in input().split()] #こっちのほうが早い？
#inf = float("inf")
dp = [0]*(N)
#2:初期値
dp[0] = 0
#3:dp実行部(貰うDP)
for i in range(1,N):
L = [dp[j]+abs(h[i]-h[j]) for j in range(max(0,i-K),i)]
dp[i] = min(L)
# for k in range(1,min(N-i-1,K)+1):
# dp[i+k] = min(dp[i+k], dp[i] + abs(h[i] - h[i+k]))
#print(dp,i,k)
#4:出力
print((dp[N-1])) | 10 | 20 | 253 | 455 | N, K = list(map(int, input().split()))
H = [int(x) for x in input().split()]
def main(N, K, H):
dp = [0] * N
for i in range(1, N):
L = [dp[j] + abs(H[i] - H[j]) for j in range(max(0, i - K), i)]
dp[i] = min(L)
print((dp[-1]))
main(N, K, H)
| # 1:初期化
N, K = list(map(int, input().split()))
# h = list(map(int, input().split()))
h = [int(x) for x in input().split()] # こっちのほうが早い？
# inf = float("inf")
dp = [0] * (N)
# 2:初期値
dp[0] = 0
# 3:dp実行部(貰うDP)
for i in range(1, N):
L = [dp[j] + abs(h[i] - h[j]) for j in range(max(0, i - K), i)]
dp[i] = min(L)
# for k in range(1,min(N-i-1,K)+1):
# dp[i+k] = min(dp[i+k], dp[i] + abs(h[i] - h[i+k]))
# print(dp,i,k)
# 4:出力
print((dp[N - 1]))
| false | 50 | [
"+# 1:初期化",
"-H = [int(x) for x in input().split()]",
"-",
"-",
"-def main(N, K, H):",
"- dp = [0] * N",
"- for i in range(1, N):",
"- L = [dp[j] + abs(H[i] - H[j]) for j in range(max(0, i - K), i)]",
"- dp[i] = min(L)",
"- print((dp[-1]))",
"-",
"-",
"-main(N, K, H)",
"+# h = list(map(int, input().split()))",
"+h = [int(x) for x in input().split()] # こっちのほうが早い？",
"+# inf = float(\"inf\")",
"+dp = [0] * (N)",
"+# 2:初期値",
"+dp[0] = 0",
"+# 3:dp実行部(貰うDP)",
"+for i in range(1, N):",
"+ L = [dp[j] + abs(h[i] - h[j]) for j in range(max(0, i - K), i)]",
"+ dp[i] = min(L)",
"+# for k in range(1,min(N-i-1,K)+1):",
"+# dp[i+k] = min(dp[i+k], dp[i] + abs(h[i] - h[i+k]))",
"+# print(dp,i,k)",
"+# 4:出力",
"+print((dp[N - 1]))"
] | false | 0.043438 | 0.042792 | 1.01509 | [
"s392146022",
"s680036008"
] |
u731896389 | p02402 | python | s196417653 | s455522516 | 30 | 20 | 8,600 | 8,568 | Accepted | Accepted | 33.33 | n = int(eval(input()))
a = list(map(int,input().split()))
print((min(a),max(a),sum(a))) | eval(input())
a = list(map(int,input().split()))
print((min(a),max(a),sum(a))) | 3 | 3 | 81 | 72 | n = int(eval(input()))
a = list(map(int, input().split()))
print((min(a), max(a), sum(a)))
| eval(input())
a = list(map(int, input().split()))
print((min(a), max(a), sum(a)))
| false | 0 | [
"-n = int(eval(input()))",
"+eval(input())"
] | false | 0.03942 | 0.041853 | 0.941863 | [
"s196417653",
"s455522516"
] |
u004423772 | p03476 | python | s611956216 | s775885825 | 1,096 | 1,006 | 59,236 | 53,632 | Accepted | Accepted | 8.21 | Q = int(eval(input()))
is_prime = {i:True for i in range(10**5+1)}
is_prime[0], is_prime[1] = False, False
for i in range(2, 10**5+1):
if is_prime[i]:
for j in range(i*2, 10**5+1, i):
is_prime[j] = False
s = [0] * (10**5+1)
for i in range(1, 10**5):
s[i+1] = s[i] + int(is_prime[i] and is_prime[(i+1)//2])
for _ in range(Q):
left, right = list(map(int, input().split()))
print((s[right+1]-s[left])) | Q = int(eval(input()))
is_prime = [True for i in range(10**5+1)]
is_prime[0], is_prime[1] = False, False
for i in range(2, 10**5+1):
if is_prime[i]:
for j in range(i*2, 10**5+1, i):
is_prime[j] = False
s = [0] * (10**5+1)
for i in range(1, 10**5):
s[i+1] = s[i] + int(is_prime[i] and is_prime[(i+1)//2])
for _ in range(Q):
left, right = list(map(int, input().split()))
print((s[right+1]-s[left])) | 13 | 13 | 432 | 430 | Q = int(eval(input()))
is_prime = {i: True for i in range(10**5 + 1)}
is_prime[0], is_prime[1] = False, False
for i in range(2, 10**5 + 1):
if is_prime[i]:
for j in range(i * 2, 10**5 + 1, i):
is_prime[j] = False
s = [0] * (10**5 + 1)
for i in range(1, 10**5):
s[i + 1] = s[i] + int(is_prime[i] and is_prime[(i + 1) // 2])
for _ in range(Q):
left, right = list(map(int, input().split()))
print((s[right + 1] - s[left]))
| Q = int(eval(input()))
is_prime = [True for i in range(10**5 + 1)]
is_prime[0], is_prime[1] = False, False
for i in range(2, 10**5 + 1):
if is_prime[i]:
for j in range(i * 2, 10**5 + 1, i):
is_prime[j] = False
s = [0] * (10**5 + 1)
for i in range(1, 10**5):
s[i + 1] = s[i] + int(is_prime[i] and is_prime[(i + 1) // 2])
for _ in range(Q):
left, right = list(map(int, input().split()))
print((s[right + 1] - s[left]))
| false | 0 | [
"-is_prime = {i: True for i in range(10**5 + 1)}",
"+is_prime = [True for i in range(10**5 + 1)]"
] | false | 0.20183 | 0.14212 | 1.420134 | [
"s611956216",
"s775885825"
] |
u607563136 | p02708 | python | s861213325 | s661328732 | 129 | 82 | 20,000 | 20,048 | Accepted | Accepted | 36.43 | def rui_sum(n,k):
k_lsum = (k-1)*k//2
k_usum = k*n - (k-1)*k//2
return k_usum - k_lsum + 1
n, k = list(map(int,input().split()))
cnt = []
for i in range(k,n+2):
cnt.append(rui_sum(n,i))
print((sum(cnt)%(10**9+7))) | n, k = list(map(int,input().split()))
cnt = []
for i in range(k,n+2):
cnt.append(i*n -(i-1)*i +1)
print((sum(cnt)%(10**9+7))) | 13 | 8 | 245 | 139 | def rui_sum(n, k):
k_lsum = (k - 1) * k // 2
k_usum = k * n - (k - 1) * k // 2
return k_usum - k_lsum + 1
n, k = list(map(int, input().split()))
cnt = []
for i in range(k, n + 2):
cnt.append(rui_sum(n, i))
print((sum(cnt) % (10**9 + 7)))
| n, k = list(map(int, input().split()))
cnt = []
for i in range(k, n + 2):
cnt.append(i * n - (i - 1) * i + 1)
print((sum(cnt) % (10**9 + 7)))
| false | 38.461538 | [
"-def rui_sum(n, k):",
"- k_lsum = (k - 1) * k // 2",
"- k_usum = k * n - (k - 1) * k // 2",
"- return k_usum - k_lsum + 1",
"-",
"-",
"- cnt.append(rui_sum(n, i))",
"+ cnt.append(i * n - (i - 1) * i + 1)"
] | false | 0.12726 | 0.085023 | 1.496768 | [
"s861213325",
"s661328732"
] |
u571281863 | p02659 | python | s083833584 | s767091089 | 29 | 20 | 10,068 | 9,160 | Accepted | Accepted | 31.03 | from decimal import *
A,B=list(map(str,input().split()))
A=Decimal(A)
B=Decimal(B)
print((int(A*B))) | A,B=input().split()
print((int(A)*int(B[:1]+B[-2:])//100)) | 5 | 2 | 96 | 57 | from decimal import *
A, B = list(map(str, input().split()))
A = Decimal(A)
B = Decimal(B)
print((int(A * B)))
| A, B = input().split()
print((int(A) * int(B[:1] + B[-2:]) // 100))
| false | 60 | [
"-from decimal import *",
"-",
"-A, B = list(map(str, input().split()))",
"-A = Decimal(A)",
"-B = Decimal(B)",
"-print((int(A * B)))",
"+A, B = input().split()",
"+print((int(A) * int(B[:1] + B[-2:]) // 100))"
] | false | 0.042902 | 0.075188 | 0.570603 | [
"s083833584",
"s767091089"
] |
u802977614 | p02647 | python | s494297948 | s199269807 | 564 | 484 | 184,608 | 184,236 | Accepted | Accepted | 14.18 | import sys, bisect, math, itertools, heapq, collections
from operator import itemgetter
# a.sort(key=itemgetter(i)) # i番目要素でsort
from functools import lru_cache
# @lru_cache(maxsize=None)
sys.setrecursionlimit(10**8)
input = sys.stdin.readline
INF = float('inf')
mod = 10**9 + 7
eps = 10**-7
def inp():
'''
一つの整数
'''
return int(eval(input()))
def inpl():
'''
一行に複数の整数
'''
return list(map(int, input().split()))
def str_inp():
'''
文字列をリストとして読み込む
'''
return list(input()[:-1])
n, k = inpl()
a = inpl()
dp = [(0, 0)] * n
changed=set(range(n))
for j in range(k):
for i in changed:
l = max(0, i - a[i])
r = min(n - 1, i + a[i])
dp[i] = (l, r)
imos = [0] * n
for i in range(n):
l, r = dp[i]
imos[l] += 1
if r < n - 1:
imos[r + 1] -= 1
tmp = 0
for i in range(n):
tmp += imos[i]
a[i] = tmp
if j>50:
break
print((*a))
| import sys, bisect, math, itertools, heapq, collections
from operator import itemgetter
# a.sort(key=itemgetter(i)) # i番目要素でsort
from functools import lru_cache
# @lru_cache(maxsize=None)
sys.setrecursionlimit(10**8)
input = sys.stdin.readline
INF = float('inf')
mod = 10**9 + 7
eps = 10**-7
def inp():
'''
一つの整数
'''
return int(eval(input()))
def inpl():
'''
一行に複数の整数
'''
return list(map(int, input().split()))
def str_inp():
'''
文字列をリストとして読み込む
'''
return list(input()[:-1])
n, k = inpl()
a = inpl()
dp = [(0, 0)] * n
changed = set(range(n))
for j in range(k):
for i in changed:
l = max(0, i - a[i])
r = min(n - 1, i + a[i])
dp[i] = (l, r)
imos = [0] * n
for i in range(n):
l, r = dp[i]
imos[l] += 1
if r < n - 1:
imos[r + 1] -= 1
tmp = 0
for i in range(n):
tmp += imos[i]
a[i] = tmp
if imos[0]==n:
break
print((*a))
| 55 | 55 | 1,019 | 1,027 | import sys, bisect, math, itertools, heapq, collections
from operator import itemgetter
# a.sort(key=itemgetter(i)) # i番目要素でsort
from functools import lru_cache
# @lru_cache(maxsize=None)
sys.setrecursionlimit(10**8)
input = sys.stdin.readline
INF = float("inf")
mod = 10**9 + 7
eps = 10**-7
def inp():
"""
一つの整数
"""
return int(eval(input()))
def inpl():
"""
一行に複数の整数
"""
return list(map(int, input().split()))
def str_inp():
"""
文字列をリストとして読み込む
"""
return list(input()[:-1])
n, k = inpl()
a = inpl()
dp = [(0, 0)] * n
changed = set(range(n))
for j in range(k):
for i in changed:
l = max(0, i - a[i])
r = min(n - 1, i + a[i])
dp[i] = (l, r)
imos = [0] * n
for i in range(n):
l, r = dp[i]
imos[l] += 1
if r < n - 1:
imos[r + 1] -= 1
tmp = 0
for i in range(n):
tmp += imos[i]
a[i] = tmp
if j > 50:
break
print((*a))
| import sys, bisect, math, itertools, heapq, collections
from operator import itemgetter
# a.sort(key=itemgetter(i)) # i番目要素でsort
from functools import lru_cache
# @lru_cache(maxsize=None)
sys.setrecursionlimit(10**8)
input = sys.stdin.readline
INF = float("inf")
mod = 10**9 + 7
eps = 10**-7
def inp():
"""
一つの整数
"""
return int(eval(input()))
def inpl():
"""
一行に複数の整数
"""
return list(map(int, input().split()))
def str_inp():
"""
文字列をリストとして読み込む
"""
return list(input()[:-1])
n, k = inpl()
a = inpl()
dp = [(0, 0)] * n
changed = set(range(n))
for j in range(k):
for i in changed:
l = max(0, i - a[i])
r = min(n - 1, i + a[i])
dp[i] = (l, r)
imos = [0] * n
for i in range(n):
l, r = dp[i]
imos[l] += 1
if r < n - 1:
imos[r + 1] -= 1
tmp = 0
for i in range(n):
tmp += imos[i]
a[i] = tmp
if imos[0] == n:
break
print((*a))
| false | 0 | [
"- if j > 50:",
"+ if imos[0] == n:"
] | false | 0.043594 | 0.041698 | 1.045455 | [
"s494297948",
"s199269807"
] |
u799164835 | p02784 | python | s449268553 | s824710805 | 55 | 42 | 13,964 | 13,964 | Accepted | Accepted | 23.64 | H, N = list(map(int,input().split()))
A = list(map(int, input().split()))
ans = 0
for i in range(N):
ans += A[i]
if ans >= H:
print('Yes')
else:
print('No')
| # printデバッグ用
import sys
argVec = sys.argv
if len(argVec) > 1:
GBN_DEBUG = True
else:
GBN_DEBUG = False
def dprn(s, i):
if GBN_DEBUG:
print(", " + s + " = " + str(i), end = "")
def dprns(s):
if GBN_DEBUG:
print(", " + s, end = "")
def dprni(i):
if GBN_DEBUG:
print(str(i), end=" ")
#S = input()
#N = int(input())
#S, T = input().split()
H, N = map(int, input().split())
#W = [input() for _ in range(N)]
A = list(map(int, input().split()))
if sum(A) >= H:
print('Yes')
else:
print('No')
| 11 | 31 | 175 | 574 | H, N = list(map(int, input().split()))
A = list(map(int, input().split()))
ans = 0
for i in range(N):
ans += A[i]
if ans >= H:
print("Yes")
else:
print("No")
| # printデバッグ用
import sys
argVec = sys.argv
if len(argVec) > 1:
GBN_DEBUG = True
else:
GBN_DEBUG = False
def dprn(s, i):
if GBN_DEBUG:
print(", " + s + " = " + str(i), end="")
def dprns(s):
if GBN_DEBUG:
print(", " + s, end="")
def dprni(i):
if GBN_DEBUG:
print(str(i), end=" ")
# S = input()
# N = int(input())
# S, T = input().split()
H, N = map(int, input().split())
# W = [input() for _ in range(N)]
A = list(map(int, input().split()))
if sum(A) >= H:
print("Yes")
else:
print("No")
| false | 64.516129 | [
"-H, N = list(map(int, input().split()))",
"+# printデバッグ用",
"+import sys",
"+",
"+argVec = sys.argv",
"+if len(argVec) > 1:",
"+ GBN_DEBUG = True",
"+else:",
"+ GBN_DEBUG = False",
"+",
"+",
"+def dprn(s, i):",
"+ if GBN_DEBUG:",
"+ print(\", \" + s + \" = \" + str(i), end=\"\")",
"+",
"+",
"+def dprns(s):",
"+ if GBN_DEBUG:",
"+ print(\", \" + s, end=\"\")",
"+",
"+",
"+def dprni(i):",
"+ if GBN_DEBUG:",
"+ print(str(i), end=\" \")",
"+",
"+",
"+# S = input()",
"+# N = int(input())",
"+# S, T = input().split()",
"+H, N = map(int, input().split())",
"+# W = [input() for _ in range(N)]",
"-ans = 0",
"-for i in range(N):",
"- ans += A[i]",
"-if ans >= H:",
"+if sum(A) >= H:"
] | false | 0.041194 | 0.041972 | 0.981463 | [
"s449268553",
"s824710805"
] |
u022407960 | p02378 | python | s213555939 | s657134397 | 70 | 60 | 8,536 | 9,156 | Accepted | Accepted | 14.29 | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
input:
3 4 6
0 0
0 2
0 3
1 1
2 1
2 3
output:
3
"""
import sys
def dfs(current, matching, visited):
for target in range(y_num):
if not visited[target] and target in adj_table[current]:
visited[target] = True
''' Matching[target] = -1: target not assigned to any of x.
And dfs(matching[target], matching, visited) = True
indicates that source in x has been already assigned
to another target in y. '''
if matching[target] == -1 or dfs(matching[target], matching, visited):
matching[target] = current
return True
return False
def mbm():
res = 0
matching = [-1] * y_num
for source in range(x_num):
visited = [False] * y_num
if dfs(source, matching, visited):
res += 1
return res
if __name__ == '__main__':
_input = sys.stdin.readlines()
x_num, y_num, e_num = list(map(int, _input[0].split()))
edges = [x.split() for x in _input[1:]]
adj_table = tuple([] for _ in range(x_num))
for edge in edges:
vx, vy = list(map(int, edge))
adj_table[vx].append(vy)
print((mbm())) | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
input:
3 4 6
0 0
0 2
0 3
1 1
2 1
2 3
output:
3
"""
import sys
def dfs(current, matching, visited):
for target in range(y_num):
if not visited[target] and target in adj_table[current]:
visited[target] = True
''' Matching[target] = -1: target not assigned to any of x.
And dfs(matching[target], matching, visited) = True
indicates that source in x has been already assigned
to another target in y. '''
if matching[target] == -1 or dfs(matching[target], matching, visited):
matching[target] = current
return True
return False
def mbm():
res = 0
matching = [-1] * y_num
for source in range(x_num):
visited = [False] * y_num
if dfs(source, matching, visited):
res += 1
return res
if __name__ == '__main__':
_input = sys.stdin.readlines()
x_num, y_num, e_num = list(map(int, _input[0].split()))
edges = [x.split() for x in _input[1:]]
adj_table = tuple(set() for _ in range(x_num))
for edge in edges:
vx, vy = list(map(int, edge))
adj_table[vx].add(vy)
print((mbm())) | 53 | 53 | 1,267 | 1,267 | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
input:
3 4 6
0 0
0 2
0 3
1 1
2 1
2 3
output:
3
"""
import sys
def dfs(current, matching, visited):
for target in range(y_num):
if not visited[target] and target in adj_table[current]:
visited[target] = True
""" Matching[target] = -1: target not assigned to any of x.
And dfs(matching[target], matching, visited) = True
indicates that source in x has been already assigned
to another target in y. """
if matching[target] == -1 or dfs(matching[target], matching, visited):
matching[target] = current
return True
return False
def mbm():
res = 0
matching = [-1] * y_num
for source in range(x_num):
visited = [False] * y_num
if dfs(source, matching, visited):
res += 1
return res
if __name__ == "__main__":
_input = sys.stdin.readlines()
x_num, y_num, e_num = list(map(int, _input[0].split()))
edges = [x.split() for x in _input[1:]]
adj_table = tuple([] for _ in range(x_num))
for edge in edges:
vx, vy = list(map(int, edge))
adj_table[vx].append(vy)
print((mbm()))
| #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
input:
3 4 6
0 0
0 2
0 3
1 1
2 1
2 3
output:
3
"""
import sys
def dfs(current, matching, visited):
for target in range(y_num):
if not visited[target] and target in adj_table[current]:
visited[target] = True
""" Matching[target] = -1: target not assigned to any of x.
And dfs(matching[target], matching, visited) = True
indicates that source in x has been already assigned
to another target in y. """
if matching[target] == -1 or dfs(matching[target], matching, visited):
matching[target] = current
return True
return False
def mbm():
res = 0
matching = [-1] * y_num
for source in range(x_num):
visited = [False] * y_num
if dfs(source, matching, visited):
res += 1
return res
if __name__ == "__main__":
_input = sys.stdin.readlines()
x_num, y_num, e_num = list(map(int, _input[0].split()))
edges = [x.split() for x in _input[1:]]
adj_table = tuple(set() for _ in range(x_num))
for edge in edges:
vx, vy = list(map(int, edge))
adj_table[vx].add(vy)
print((mbm()))
| false | 0 | [
"- adj_table = tuple([] for _ in range(x_num))",
"+ adj_table = tuple(set() for _ in range(x_num))",
"- adj_table[vx].append(vy)",
"+ adj_table[vx].add(vy)"
] | false | 0.039171 | 0.080496 | 0.486623 | [
"s213555939",
"s657134397"
] |
u287500079 | p03252 | python | s555136185 | s307864717 | 512 | 292 | 3,632 | 63,212 | Accepted | Accepted | 42.97 | import sys
s = str(eval(input()))
t = str(eval(input()))
l = len(s)
tmp = [[], []]
for i in range(l):
if (not s[i] in tmp[0]) and (not t[i] in tmp[1]):
tmp[0].append(s[i])
tmp[1].append(t[i])
else:
if s[i] in tmp[0]:
tmp2 = 0
for j in range(len(tmp[0])):
if s[i] == tmp[0][j]:
tmp2 = j
if t[i] != tmp[1][tmp2]:
print('No')
sys.exit()
else:
print('No')
sys.exit()
print('Yes')
| import sys, re, os
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, acos, atan, asin
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 eval(input())
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def S_MAP(): return list(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
dx = [0, 0, 1, -1, 1, -1, -1, 1]
dy = [1, -1, 0, 0, 1, -1, 1, -1]
s = STR()
t = STR()
l = len(s)
tmp = [[], []]
for i in range(len(s)):
if not s[i] in tmp[0] and not t[i] in tmp[1]:
tmp[0].append(s[i])
tmp[1].append(t[i])
else:
if s[i] in tmp[0] and t[i] in tmp[1]:
if tmp[0].index(s[i]) != tmp[1].index(t[i]):
print('No')
exit()
else:
print('No')
exit()
print('Yes')
| 22 | 39 | 553 | 1,260 | import sys
s = str(eval(input()))
t = str(eval(input()))
l = len(s)
tmp = [[], []]
for i in range(l):
if (not s[i] in tmp[0]) and (not t[i] in tmp[1]):
tmp[0].append(s[i])
tmp[1].append(t[i])
else:
if s[i] in tmp[0]:
tmp2 = 0
for j in range(len(tmp[0])):
if s[i] == tmp[0][j]:
tmp2 = j
if t[i] != tmp[1][tmp2]:
print("No")
sys.exit()
else:
print("No")
sys.exit()
print("Yes")
| import sys, re, os
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, acos, atan, asin
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 eval(input())
def INT():
return int(eval(input()))
def MAP():
return list(map(int, input().split()))
def S_MAP():
return list(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
dx = [0, 0, 1, -1, 1, -1, -1, 1]
dy = [1, -1, 0, 0, 1, -1, 1, -1]
s = STR()
t = STR()
l = len(s)
tmp = [[], []]
for i in range(len(s)):
if not s[i] in tmp[0] and not t[i] in tmp[1]:
tmp[0].append(s[i])
tmp[1].append(t[i])
else:
if s[i] in tmp[0] and t[i] in tmp[1]:
if tmp[0].index(s[i]) != tmp[1].index(t[i]):
print("No")
exit()
else:
print("No")
exit()
print("Yes")
| false | 43.589744 | [
"-import sys",
"+import sys, re, os",
"+from collections import deque, defaultdict, Counter",
"+from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, acos, atan, asin",
"+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",
"-s = str(eval(input()))",
"-t = str(eval(input()))",
"+",
"+def input():",
"+ return sys.stdin.readline().strip()",
"+",
"+",
"+def STR():",
"+ return eval(input())",
"+",
"+",
"+def INT():",
"+ return int(eval(input()))",
"+",
"+",
"+def MAP():",
"+ return list(map(int, input().split()))",
"+",
"+",
"+def S_MAP():",
"+ return list(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",
"+dx = [0, 0, 1, -1, 1, -1, -1, 1]",
"+dy = [1, -1, 0, 0, 1, -1, 1, -1]",
"+s = STR()",
"+t = STR()",
"-for i in range(l):",
"- if (not s[i] in tmp[0]) and (not t[i] in tmp[1]):",
"+for i in range(len(s)):",
"+ if not s[i] in tmp[0] and not t[i] in tmp[1]:",
"- if s[i] in tmp[0]:",
"- tmp2 = 0",
"- for j in range(len(tmp[0])):",
"- if s[i] == tmp[0][j]:",
"- tmp2 = j",
"- if t[i] != tmp[1][tmp2]:",
"+ if s[i] in tmp[0] and t[i] in tmp[1]:",
"+ if tmp[0].index(s[i]) != tmp[1].index(t[i]):",
"- sys.exit()",
"+ exit()",
"- sys.exit()",
"+ exit()"
] | false | 0.037383 | 0.036726 | 1.017885 | [
"s555136185",
"s307864717"
] |
u747602774 | p04031 | python | s856492478 | s571355692 | 19 | 17 | 3,064 | 3,064 | Accepted | Accepted | 10.53 | N=int(eval(input()))
li=list(map(int,input().split()))
ave1=sum(li)//N
ave2=sum(li)//N+1
ave3=sum(li)//N-1
ans1=0
ans2=0
ans3=0
for n in range(len(li)):
ans1+=(li[n]-ave1)**2
ans2+=(li[n]-ave2)**2
ans3+=(li[n]-ave3)**2
print((min(ans1,ans2,ans3))) | N=int(eval(input()))
li=list(map(int,input().split()))
ave1=sum(li)//N
ave2=sum(li)//N+1
ans1=0
ans2=0
for n in range(len(li)):
ans1+=(li[n]-ave1)**2
ans2+=(li[n]-ave2)**2
print((min(ans1,ans2))) | 13 | 10 | 257 | 200 | N = int(eval(input()))
li = list(map(int, input().split()))
ave1 = sum(li) // N
ave2 = sum(li) // N + 1
ave3 = sum(li) // N - 1
ans1 = 0
ans2 = 0
ans3 = 0
for n in range(len(li)):
ans1 += (li[n] - ave1) ** 2
ans2 += (li[n] - ave2) ** 2
ans3 += (li[n] - ave3) ** 2
print((min(ans1, ans2, ans3)))
| N = int(eval(input()))
li = list(map(int, input().split()))
ave1 = sum(li) // N
ave2 = sum(li) // N + 1
ans1 = 0
ans2 = 0
for n in range(len(li)):
ans1 += (li[n] - ave1) ** 2
ans2 += (li[n] - ave2) ** 2
print((min(ans1, ans2)))
| false | 23.076923 | [
"-ave3 = sum(li) // N - 1",
"-ans3 = 0",
"- ans3 += (li[n] - ave3) ** 2",
"-print((min(ans1, ans2, ans3)))",
"+print((min(ans1, ans2)))"
] | false | 0.037067 | 0.044519 | 0.832613 | [
"s856492478",
"s571355692"
] |
u057109575 | p02755 | python | s050569294 | s603295957 | 168 | 67 | 38,384 | 61,924 | Accepted | Accepted | 60.12 | A, B = list(map(int, input().split()))
def floor(x, f):
res = int(x / f)
if int(res * f) < x:
res += 1
return res
ra = [floor(A, 0.08), floor(A + 1, 0.08)]
rb = [floor(B, 0.1), floor(B + 1, 0.1)]
if ra[1] <= rb[0] or rb[1] <= ra[0]:
print((-1))
else:
print((max(ra[0], rb[0])))
|
A, B = list(map(int, input().split()))
def floor_inv(x, f):
res = int(x / f)
if int(res * f) < x:
res += 1
return res
lb1 = floor_inv(A, 0.08)
ub1 = floor_inv(A + 1, 0.08)
lb2 = floor_inv(B, 0.10)
ub2 = floor_inv(B + 1, 0.10)
if ub1 <= lb2 or ub2 <= lb1:
print((-1))
else:
print((max(lb1, lb2)))
| 15 | 21 | 313 | 341 | A, B = list(map(int, input().split()))
def floor(x, f):
res = int(x / f)
if int(res * f) < x:
res += 1
return res
ra = [floor(A, 0.08), floor(A + 1, 0.08)]
rb = [floor(B, 0.1), floor(B + 1, 0.1)]
if ra[1] <= rb[0] or rb[1] <= ra[0]:
print((-1))
else:
print((max(ra[0], rb[0])))
| A, B = list(map(int, input().split()))
def floor_inv(x, f):
res = int(x / f)
if int(res * f) < x:
res += 1
return res
lb1 = floor_inv(A, 0.08)
ub1 = floor_inv(A + 1, 0.08)
lb2 = floor_inv(B, 0.10)
ub2 = floor_inv(B + 1, 0.10)
if ub1 <= lb2 or ub2 <= lb1:
print((-1))
else:
print((max(lb1, lb2)))
| false | 28.571429 | [
"-def floor(x, f):",
"+def floor_inv(x, f):",
"-ra = [floor(A, 0.08), floor(A + 1, 0.08)]",
"-rb = [floor(B, 0.1), floor(B + 1, 0.1)]",
"-if ra[1] <= rb[0] or rb[1] <= ra[0]:",
"+lb1 = floor_inv(A, 0.08)",
"+ub1 = floor_inv(A + 1, 0.08)",
"+lb2 = floor_inv(B, 0.10)",
"+ub2 = floor_inv(B + 1, 0.10)",
"+if ub1 <= lb2 or ub2 <= lb1:",
"- print((max(ra[0], rb[0])))",
"+ print((max(lb1, lb2)))"
] | false | 0.03623 | 0.036532 | 0.99173 | [
"s050569294",
"s603295957"
] |
u758815106 | p03167 | python | s923093329 | s890366126 | 646 | 113 | 48,308 | 82,240 | Accepted | Accepted | 82.51 | #import
#import math
#import numpy as np
#= int(input())
#= input()
#= list(map(int, input().split()))
#= [input(), input()]
#= [list(map(int, input().split())) for _ in range(N)]
#= {i:[] for i in range(N)}
def mod(num):
return num % (10 ** 9 + 7)
H, W = list(map(int, input().split()))
dp = [[0] * W for _ in range(H)]
for i in range(H):
a = eval(input())
for j in range(W):
if a[j] == "#":
dp[i][j] = -1
dp[0][0] = 1
for row in range(H):
for col in range(W):
if row != 0 or col != 0:
if row == 0:
if dp[row][col] != -1:
dp[row][col] = dp[row][col - 1]
else:
dp[row][col] = 0
elif col == 0:
if dp[row][col] != -1:
dp[row][col] = dp[row - 1][col]
else:
dp[row][col] = 0
else:
if dp[row][col] != -1:
dp[row][col] = mod(dp[row - 1][col] + dp[row][col - 1])
else:
dp[row][col] = 0
print((dp[-1][-1])) |
def mod(num):
return num % (10 ** 9 + 7)
H, W = list(map(int, input().split()))
dp = [[0] * W for _ in range(H)]
for i in range(H):
a = eval(input())
for j in range(W):
if a[j] == "#":
dp[i][j] = -1
dp[0][0] = 1
for col in range(1, W):
if dp[0][col] != -1:
dp[0][col] = dp[0][col - 1]
else:
dp[0][col] = 0
for row in range(1, H):
for col in range(W):
if dp[row][col] != -1:
if col == 0:
dp[row][col] = dp[row - 1][col]
else:
dp[row][col] = mod(dp[row - 1][col] + dp[row][col - 1])
else:
dp[row][col] = 0
print((dp[-1][-1])) | 43 | 32 | 1,127 | 691 | # import
# import math
# import numpy as np
# = int(input())
# = input()
# = list(map(int, input().split()))
# = [input(), input()]
# = [list(map(int, input().split())) for _ in range(N)]
# = {i:[] for i in range(N)}
def mod(num):
return num % (10**9 + 7)
H, W = list(map(int, input().split()))
dp = [[0] * W for _ in range(H)]
for i in range(H):
a = eval(input())
for j in range(W):
if a[j] == "#":
dp[i][j] = -1
dp[0][0] = 1
for row in range(H):
for col in range(W):
if row != 0 or col != 0:
if row == 0:
if dp[row][col] != -1:
dp[row][col] = dp[row][col - 1]
else:
dp[row][col] = 0
elif col == 0:
if dp[row][col] != -1:
dp[row][col] = dp[row - 1][col]
else:
dp[row][col] = 0
else:
if dp[row][col] != -1:
dp[row][col] = mod(dp[row - 1][col] + dp[row][col - 1])
else:
dp[row][col] = 0
print((dp[-1][-1]))
| def mod(num):
return num % (10**9 + 7)
H, W = list(map(int, input().split()))
dp = [[0] * W for _ in range(H)]
for i in range(H):
a = eval(input())
for j in range(W):
if a[j] == "#":
dp[i][j] = -1
dp[0][0] = 1
for col in range(1, W):
if dp[0][col] != -1:
dp[0][col] = dp[0][col - 1]
else:
dp[0][col] = 0
for row in range(1, H):
for col in range(W):
if dp[row][col] != -1:
if col == 0:
dp[row][col] = dp[row - 1][col]
else:
dp[row][col] = mod(dp[row - 1][col] + dp[row][col - 1])
else:
dp[row][col] = 0
print((dp[-1][-1]))
| false | 25.581395 | [
"-# import",
"-# import math",
"-# import numpy as np",
"-# = int(input())",
"-# = input()",
"-# = list(map(int, input().split()))",
"-# = [input(), input()]",
"-# = [list(map(int, input().split())) for _ in range(N)]",
"-# = {i:[] for i in range(N)}",
"-for row in range(H):",
"+for col in range(1, W):",
"+ if dp[0][col] != -1:",
"+ dp[0][col] = dp[0][col - 1]",
"+ else:",
"+ dp[0][col] = 0",
"+for row in range(1, H):",
"- if row != 0 or col != 0:",
"- if row == 0:",
"- if dp[row][col] != -1:",
"- dp[row][col] = dp[row][col - 1]",
"- else:",
"- dp[row][col] = 0",
"- elif col == 0:",
"- if dp[row][col] != -1:",
"- dp[row][col] = dp[row - 1][col]",
"- else:",
"- dp[row][col] = 0",
"+ if dp[row][col] != -1:",
"+ if col == 0:",
"+ dp[row][col] = dp[row - 1][col]",
"- if dp[row][col] != -1:",
"- dp[row][col] = mod(dp[row - 1][col] + dp[row][col - 1])",
"- else:",
"- dp[row][col] = 0",
"+ dp[row][col] = mod(dp[row - 1][col] + dp[row][col - 1])",
"+ else:",
"+ dp[row][col] = 0"
] | false | 0.03662 | 0.037359 | 0.980227 | [
"s923093329",
"s890366126"
] |
u141786930 | p02887 | python | s821396502 | s850784954 | 39 | 26 | 4,212 | 3,316 | Accepted | Accepted | 33.33 | from collections import deque
def main():
n = int(eval(input()))
s = eval(input())
que = deque(s)
ans = 0
q2 = ''
while len(que)>0:
q1 = que.popleft()
if q1 == q2:
continue
else:
ans += 1
q2 = q1
print(ans)
if __name__ == '__main__':
main() | def main():
n = int(eval(input()))
s = eval(input())
ans = 0
q2 = ''
for i in s:
q1 = i
if q1 != q2:
ans += 1
q2 = q1
print(ans)
if __name__ == '__main__':
main() | 21 | 15 | 348 | 238 | from collections import deque
def main():
n = int(eval(input()))
s = eval(input())
que = deque(s)
ans = 0
q2 = ""
while len(que) > 0:
q1 = que.popleft()
if q1 == q2:
continue
else:
ans += 1
q2 = q1
print(ans)
if __name__ == "__main__":
main()
| def main():
n = int(eval(input()))
s = eval(input())
ans = 0
q2 = ""
for i in s:
q1 = i
if q1 != q2:
ans += 1
q2 = q1
print(ans)
if __name__ == "__main__":
main()
| false | 28.571429 | [
"-from collections import deque",
"-",
"-",
"- que = deque(s)",
"- while len(que) > 0:",
"- q1 = que.popleft()",
"- if q1 == q2:",
"- continue",
"- else:",
"+ for i in s:",
"+ q1 = i",
"+ if q1 != q2:"
] | false | 0.044722 | 0.009027 | 4.954262 | [
"s821396502",
"s850784954"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.