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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
u847467233 | p01094 | python | s695297362 | s293976439 | 130 | 100 | 5,624 | 5,624 | Accepted | Accepted | 23.08 | # AOJ 1609: Look for the Winner!
# Python3 2018.7.13 bal4u
while True:
n = int(eval(input()))
if n == 0: break
c = list(input().split())
c = [ord(i)-ord('A') for i in c]
f = [0]*26
max1 = max2 = 0
x1 = x2 = -1
k, i = n, 0;
while i < n:
x = c[i]
i, k = i+1, k-1
f[x] += 1;
if f[x] > max1:
if x1 < 0 or x == x1: max1 = f[x]; x1 = x
else: max2 = max1; x2 = x1; max1 = f[x]; x1 = x
elif f[x] > max2: max2 = f[x]; x2 = x
if max2+k < max1: break
if max1 == max2: print("TIE")
else: print((chr(x1+ord('A')), i))
| # AOJ 1609: Look for the Winner!
# Python3 2018.7.13 bal4u
A = ord('A')
while True:
n = int(eval(input()))
if n == 0: break
c = list(input().split())
c = [ord(i)-A for i in c]
f = [0]*26
max1 = max2 = 0
x1 = x2 = -1
k, i = n, 0;
while i < n:
x = c[i]
i, k = i+1, k-1
f[x] += 1;
if f[x] > max1:
if x1 < 0 or x == x1: max1 = f[x]; x1 = x
else: max2 = max1; x2 = x1; max1 = f[x]; x1 = x
elif f[x] > max2: max2 = f[x]; x2 = x
if max2+k < max1: break
if max1 == max2: print("TIE")
else: print((chr(x1+A), i))
| 24 | 25 | 551 | 551 | # AOJ 1609: Look for the Winner!
# Python3 2018.7.13 bal4u
while True:
n = int(eval(input()))
if n == 0:
break
c = list(input().split())
c = [ord(i) - ord("A") for i in c]
f = [0] * 26
max1 = max2 = 0
x1 = x2 = -1
k, i = n, 0
while i < n:
x = c[i]
i, k = i + 1, k - 1
f[x] += 1
if f[x] > max1:
if x1 < 0 or x == x1:
max1 = f[x]
x1 = x
else:
max2 = max1
x2 = x1
max1 = f[x]
x1 = x
elif f[x] > max2:
max2 = f[x]
x2 = x
if max2 + k < max1:
break
if max1 == max2:
print("TIE")
else:
print((chr(x1 + ord("A")), i))
| # AOJ 1609: Look for the Winner!
# Python3 2018.7.13 bal4u
A = ord("A")
while True:
n = int(eval(input()))
if n == 0:
break
c = list(input().split())
c = [ord(i) - A for i in c]
f = [0] * 26
max1 = max2 = 0
x1 = x2 = -1
k, i = n, 0
while i < n:
x = c[i]
i, k = i + 1, k - 1
f[x] += 1
if f[x] > max1:
if x1 < 0 or x == x1:
max1 = f[x]
x1 = x
else:
max2 = max1
x2 = x1
max1 = f[x]
x1 = x
elif f[x] > max2:
max2 = f[x]
x2 = x
if max2 + k < max1:
break
if max1 == max2:
print("TIE")
else:
print((chr(x1 + A), i))
| false | 4 | [
"+A = ord(\"A\")",
"- c = [ord(i) - ord(\"A\") for i in c]",
"+ c = [ord(i) - A for i in c]",
"- print((chr(x1 + ord(\"A\")), i))",
"+ print((chr(x1 + A), i))"
] | false | 0.044959 | 0.043283 | 1.038719 | [
"s695297362",
"s293976439"
] |
u679439110 | p03043 | python | s224712713 | s767965107 | 62 | 54 | 3,860 | 2,940 | Accepted | Accepted | 12.9 | n, k = list(map(int, input().split()))
j = 0
while k > 2 ** j:
j += 1
jl = [j]
for i in range(2, n+1):
p = jl[i - 2]
if k <= i:
p = 0
else:
while True:
p -= 1
if k > i * (2**p):
p += 1
break
jl.append(p)
ans = 0
for j in jl:
ans += 2**(-j) / n
# print(jl)
print(ans)
| n, k = list(map(int, input().split()))
ans = 0
for i in range(1, n+1):
j = 0
while True:
if i * 2**j >= k:
break
j += 1
ans += 2**(-j)/n
print(ans)
| 28 | 13 | 391 | 197 | n, k = list(map(int, input().split()))
j = 0
while k > 2**j:
j += 1
jl = [j]
for i in range(2, n + 1):
p = jl[i - 2]
if k <= i:
p = 0
else:
while True:
p -= 1
if k > i * (2**p):
p += 1
break
jl.append(p)
ans = 0
for j in jl:
ans += 2 ** (-j) / n
# print(jl)
print(ans)
| n, k = list(map(int, input().split()))
ans = 0
for i in range(1, n + 1):
j = 0
while True:
if i * 2**j >= k:
break
j += 1
ans += 2 ** (-j) / n
print(ans)
| false | 53.571429 | [
"-j = 0",
"-while k > 2**j:",
"- j += 1",
"-jl = [j]",
"-for i in range(2, n + 1):",
"- p = jl[i - 2]",
"- if k <= i:",
"- p = 0",
"- else:",
"- while True:",
"- p -= 1",
"- if k > i * (2**p):",
"- p += 1",
"- break",
"- jl.append(p)",
"-for j in jl:",
"+for i in range(1, n + 1):",
"+ j = 0",
"+ while True:",
"+ if i * 2**j >= k:",
"+ break",
"+ j += 1",
"-# print(jl)"
] | false | 0.06912 | 0.061116 | 1.130961 | [
"s224712713",
"s767965107"
] |
u811841526 | p02422 | python | s496497316 | s217823393 | 30 | 20 | 7,692 | 5,616 | Accepted | Accepted | 33.33 | s = eval(input())
n = int(eval(input()))
for _ in range(n):
line = input().split()
command, args = line[0], line[1:]
start = int(args[0])
end = int(args[1]) + 1
if command == 'replace':
s = s[:start] + args[2] + s[end:]
elif command == 'reverse':
s = s[:start] + str(''.join(list(reversed(s[start:end])))) + s[end:]
elif command == 'print':
print((s[start:end])) | s = eval(input())
q = int(eval(input()))
for i in range(q):
line = eval(input())
if 'print' in line:
op, a, b = line.split()
a = int(a)
b = int(b)
print((s[a:b+1]))
elif 'reverse' in line:
op, a, b = line.split()
a = int(a)
b = int(b)
reversed_substring = ''.join(list(reversed(s[a:b+1])))
s = s[:a] + reversed_substring + s[b+1:]
elif 'replace' in line:
op, a, b, p = line.split()
a = int(a)
b = int(b)
s = s[:a] + p + s[b+1:]
| 13 | 21 | 412 | 549 | s = eval(input())
n = int(eval(input()))
for _ in range(n):
line = input().split()
command, args = line[0], line[1:]
start = int(args[0])
end = int(args[1]) + 1
if command == "replace":
s = s[:start] + args[2] + s[end:]
elif command == "reverse":
s = s[:start] + str("".join(list(reversed(s[start:end])))) + s[end:]
elif command == "print":
print((s[start:end]))
| s = eval(input())
q = int(eval(input()))
for i in range(q):
line = eval(input())
if "print" in line:
op, a, b = line.split()
a = int(a)
b = int(b)
print((s[a : b + 1]))
elif "reverse" in line:
op, a, b = line.split()
a = int(a)
b = int(b)
reversed_substring = "".join(list(reversed(s[a : b + 1])))
s = s[:a] + reversed_substring + s[b + 1 :]
elif "replace" in line:
op, a, b, p = line.split()
a = int(a)
b = int(b)
s = s[:a] + p + s[b + 1 :]
| false | 38.095238 | [
"-n = int(eval(input()))",
"-for _ in range(n):",
"- line = input().split()",
"- command, args = line[0], line[1:]",
"- start = int(args[0])",
"- end = int(args[1]) + 1",
"- if command == \"replace\":",
"- s = s[:start] + args[2] + s[end:]",
"- elif command == \"reverse\":",
"- s = s[:start] + str(\"\".join(list(reversed(s[start:end])))) + s[end:]",
"- elif command == \"print\":",
"- print((s[start:end]))",
"+q = int(eval(input()))",
"+for i in range(q):",
"+ line = eval(input())",
"+ if \"print\" in line:",
"+ op, a, b = line.split()",
"+ a = int(a)",
"+ b = int(b)",
"+ print((s[a : b + 1]))",
"+ elif \"reverse\" in line:",
"+ op, a, b = line.split()",
"+ a = int(a)",
"+ b = int(b)",
"+ reversed_substring = \"\".join(list(reversed(s[a : b + 1])))",
"+ s = s[:a] + reversed_substring + s[b + 1 :]",
"+ elif \"replace\" in line:",
"+ op, a, b, p = line.split()",
"+ a = int(a)",
"+ b = int(b)",
"+ s = s[:a] + p + s[b + 1 :]"
] | false | 0.035953 | 0.03495 | 1.028697 | [
"s496497316",
"s217823393"
] |
u150984829 | p02258 | python | s477253969 | s868393916 | 140 | 80 | 19,832 | 5,636 | Accepted | Accepted | 42.86 | import sys
s=1e10;b=-s
eval(input())
for r in map(int,sys.stdin.readlines()):
if b<r-s:b=r-s
if s>r:s=r
print(b)
| import sys
def m():
s=1e10;b=-s
eval(input())
for r in map(int,sys.stdin):
if b<r-s:b=r-s
if s>r:s=r
print(b)
if'__main__'==__name__:m()
| 7 | 9 | 115 | 147 | import sys
s = 1e10
b = -s
eval(input())
for r in map(int, sys.stdin.readlines()):
if b < r - s:
b = r - s
if s > r:
s = r
print(b)
| import sys
def m():
s = 1e10
b = -s
eval(input())
for r in map(int, sys.stdin):
if b < r - s:
b = r - s
if s > r:
s = r
print(b)
if "__main__" == __name__:
m()
| false | 22.222222 | [
"-s = 1e10",
"-b = -s",
"-eval(input())",
"-for r in map(int, sys.stdin.readlines()):",
"- if b < r - s:",
"- b = r - s",
"- if s > r:",
"- s = r",
"-print(b)",
"+",
"+def m():",
"+ s = 1e10",
"+ b = -s",
"+ eval(input())",
"+ for r in map(int, sys.stdin):",
"+ if b < r - s:",
"+ b = r - s",
"+ if s > r:",
"+ s = r",
"+ print(b)",
"+",
"+",
"+if \"__main__\" == __name__:",
"+ m()"
] | false | 0.066487 | 0.085838 | 0.774562 | [
"s477253969",
"s868393916"
] |
u814986259 | p03244 | python | s675966872 | s967489607 | 130 | 105 | 17,688 | 21,084 | Accepted | Accepted | 19.23 | import collections
n = int(eval(input()))
v = list(map(int, input().split()))
odd = collections.defaultdict(int)
even = collections.defaultdict(int)
for i in range(n):
if i % 2 == 0:
even[v[i]] += 1
else:
odd[v[i]] += 1
even = list(even.items())
odd = list(odd.items())
even.sort(key=lambda x: x[1], reverse=True)
odd.sort(key=lambda x: x[1], reverse=True)
if even[0][0] == odd[0][0]:
if len(even) == 1 and len(odd) == 1:
print((n // 2))
elif len(even) == 1:
print((n - (even[0][1] + odd[1][1])))
elif len(odd) == 1:
print((n - (even[1][1] + odd[0][1])))
else:
print((min(n - (even[1][1] + odd[0][1]),
n - (even[0][1] + odd[1][1]))))
else:
print((n - (even[0][1] + odd[0][1])))
| import collections
n=int(eval(input()))
v=list(map(int,input().split()))
odd=[v[i] for i in range(n) if i%2==0]
even=[v[i] for i in range(n) if i%2==1]
o=(collections.Counter(odd)).most_common()
e=(collections.Counter(even)).most_common()
o.append((0,0))
e.append((0,0))
if o[0][0]==e[0][0]:
print((n-max(e[0][1]+o[1][1],e[1][1]+o[0][1])))
else:
print((n-(e[0][1] +o[0][1]))) | 33 | 13 | 791 | 381 | import collections
n = int(eval(input()))
v = list(map(int, input().split()))
odd = collections.defaultdict(int)
even = collections.defaultdict(int)
for i in range(n):
if i % 2 == 0:
even[v[i]] += 1
else:
odd[v[i]] += 1
even = list(even.items())
odd = list(odd.items())
even.sort(key=lambda x: x[1], reverse=True)
odd.sort(key=lambda x: x[1], reverse=True)
if even[0][0] == odd[0][0]:
if len(even) == 1 and len(odd) == 1:
print((n // 2))
elif len(even) == 1:
print((n - (even[0][1] + odd[1][1])))
elif len(odd) == 1:
print((n - (even[1][1] + odd[0][1])))
else:
print((min(n - (even[1][1] + odd[0][1]), n - (even[0][1] + odd[1][1]))))
else:
print((n - (even[0][1] + odd[0][1])))
| import collections
n = int(eval(input()))
v = list(map(int, input().split()))
odd = [v[i] for i in range(n) if i % 2 == 0]
even = [v[i] for i in range(n) if i % 2 == 1]
o = (collections.Counter(odd)).most_common()
e = (collections.Counter(even)).most_common()
o.append((0, 0))
e.append((0, 0))
if o[0][0] == e[0][0]:
print((n - max(e[0][1] + o[1][1], e[1][1] + o[0][1])))
else:
print((n - (e[0][1] + o[0][1])))
| false | 60.606061 | [
"-odd = collections.defaultdict(int)",
"-even = collections.defaultdict(int)",
"-for i in range(n):",
"- if i % 2 == 0:",
"- even[v[i]] += 1",
"- else:",
"- odd[v[i]] += 1",
"-even = list(even.items())",
"-odd = list(odd.items())",
"-even.sort(key=lambda x: x[1], reverse=True)",
"-odd.sort(key=lambda x: x[1], reverse=True)",
"-if even[0][0] == odd[0][0]:",
"- if len(even) == 1 and len(odd) == 1:",
"- print((n // 2))",
"- elif len(even) == 1:",
"- print((n - (even[0][1] + odd[1][1])))",
"- elif len(odd) == 1:",
"- print((n - (even[1][1] + odd[0][1])))",
"- else:",
"- print((min(n - (even[1][1] + odd[0][1]), n - (even[0][1] + odd[1][1]))))",
"+odd = [v[i] for i in range(n) if i % 2 == 0]",
"+even = [v[i] for i in range(n) if i % 2 == 1]",
"+o = (collections.Counter(odd)).most_common()",
"+e = (collections.Counter(even)).most_common()",
"+o.append((0, 0))",
"+e.append((0, 0))",
"+if o[0][0] == e[0][0]:",
"+ print((n - max(e[0][1] + o[1][1], e[1][1] + o[0][1])))",
"- print((n - (even[0][1] + odd[0][1])))",
"+ print((n - (e[0][1] + o[0][1])))"
] | false | 0.040195 | 0.048273 | 0.832671 | [
"s675966872",
"s967489607"
] |
u607563136 | p03162 | python | s951920126 | s852518962 | 543 | 345 | 50,216 | 50,364 | Accepted | Accepted | 36.46 | def main():
N = int(eval(input()))
v = [list(map(int,input().split())) for _ in range(N)]
dp = [[0]*3 for _ in range(N+1)]
for i in range(N):
for j in range(3):
for k in range(3):
if j==k:continue
dp[i+1][k] = max(dp[i+1][k],dp[i][j]+v[i][k])
print((max(dp[N][i] for i in range(3))))
main() | def main():
N = int(eval(input()))
v = [list(map(int,input().split())) for _ in range(N)]
dp = [[0]*3 for _ in range(N+1)]
for i in range(N):
dp[i+1][0] = max(dp[i][1],dp[i][2]) + v[i][0]
dp[i+1][1] = max(dp[i][0],dp[i][2]) + v[i][1]
dp[i+1][2] = max(dp[i][0],dp[i][1]) + v[i][2]
print((max(dp[N][i] for i in range(3))))
main() | 13 | 11 | 368 | 378 | def main():
N = int(eval(input()))
v = [list(map(int, input().split())) for _ in range(N)]
dp = [[0] * 3 for _ in range(N + 1)]
for i in range(N):
for j in range(3):
for k in range(3):
if j == k:
continue
dp[i + 1][k] = max(dp[i + 1][k], dp[i][j] + v[i][k])
print((max(dp[N][i] for i in range(3))))
main()
| def main():
N = int(eval(input()))
v = [list(map(int, input().split())) for _ in range(N)]
dp = [[0] * 3 for _ in range(N + 1)]
for i in range(N):
dp[i + 1][0] = max(dp[i][1], dp[i][2]) + v[i][0]
dp[i + 1][1] = max(dp[i][0], dp[i][2]) + v[i][1]
dp[i + 1][2] = max(dp[i][0], dp[i][1]) + v[i][2]
print((max(dp[N][i] for i in range(3))))
main()
| false | 15.384615 | [
"- for j in range(3):",
"- for k in range(3):",
"- if j == k:",
"- continue",
"- dp[i + 1][k] = max(dp[i + 1][k], dp[i][j] + v[i][k])",
"+ dp[i + 1][0] = max(dp[i][1], dp[i][2]) + v[i][0]",
"+ dp[i + 1][1] = max(dp[i][0], dp[i][2]) + v[i][1]",
"+ dp[i + 1][2] = max(dp[i][0], dp[i][1]) + v[i][2]"
] | false | 0.087378 | 0.038676 | 2.259212 | [
"s951920126",
"s852518962"
] |
u923172145 | p02550 | python | s838630708 | s095001760 | 156 | 79 | 86,940 | 87,388 | Accepted | Accepted | 49.36 | import sys
N, X, M = list(map(int, input().split()))
if N == 1:
print(X)
sys.exit()
ans = 0
ans += X - (X%M)
X %= M
def fun(x):
return (x * x) % M
appear_list = [X]
appear_set = {X}
x = X
i_0 = 1
sum_0 = x
while fun(x) not in appear_set:
x = fun(x)
appear_list.append(x)
appear_set.add(x)
sum_0 += x
i_0 += 1
#print(appear_list, x, fun(x))
#print(i_0, N, appear_set)
if i_0 == N:
print((ans + sum_0))
sys.exit()
ans += sum_0
N -= i_0
x = fun(x)
appear_set_2 = {x}
sum_1 = x
sum_list = [0,x]
i_1 = 1
while fun(x) not in appear_set_2:
x = fun(x)
appear_set_2.add(x)
sum_1 += x
sum_list.append(sum_1)
i_1 += 1
sum_0 -= sum_1
i_0 -= i_1
#print(N % i_1)
ans += sum_1 * (N // i_1) + sum_list[(N % i_1)]
print(ans)
| import sys
N, X, M = list(map(int, input().split()))
if N == 1: #例外
print(X)
sys.exit()
ans = 0
ans += X - (X%M) #XがMより大きい場合、超過分を先に計上する。
X %= M #これで 0 <= X <= M-1 が成り立つようにできた。
def fun(x): #問題の関数を用意（いちいち中身を書いていると面倒くさいため）
return (x * x) % M
appear_set = {X} #すでに現れた数を格納する
i_0 = 1 #今までに調べた個数。現在は「X」の1つだけ。
x = X #このxに何度も関数funを作用させる
sum_0 = x #現在までの和
# ①：すでに出現したことのある数が現れるまで、ループを回す。
# この途中で目標回数Nに到達するなら、その時点で答えを出力する(31-33行目)。
while fun(x) not in appear_set: #次のxが初めて現れる数なら続ける。
x = fun(x) #xにfunを作用
appear_set.add(x) #xを「現れたものリスト」に格納
sum_0 += x #和の更新
i_0 += 1 #調べた個数の更新
if i_0 == N: #目標回数に到達したら、その時点で答えを出力して終了。
print((ans + sum_0))
sys.exit()
# 現在、xには系列に初めて現れた最後の数が入っている。
# 次の数であるfun(x)は、前に現れたことのある数。したがって、ここからループが始まる。
# 整理のため、ここまでの和を計上し、残り回数も減らしておく。
ans += sum_0
N -= i_0
# ②：ループの性質を調べるため、もう一度ループを回したい。
# 欲しいものは3つ。
# 1.ループ１週の和
# 2.ループの途中までの和を記録した配列。
# 3.ループの長さ
# 以下、先ほどと異なる部分を中心に説明する。
x = fun(x) # 次の数へ行く(ループの最初の数)
appear_set_2 = {x}
sum_1 = x # 欲しいもの1。ループ１周の和を記録する。
sum_list = [0,x] # 欲しいもの2。i番目の要素がi番目までの数までの和を示すよう、この後要素を追加する。
i_1 = 1 # すでに調べた個数をカウントする。現在は「x」の1個だけ。
# このi_1が、最終的にループの長さ(欲しいもの3)になる。
# 以下、60行目以外の処理は先ほどと同様。
while fun(x) not in appear_set_2:
x = fun(x)
appear_set_2.add(x)
sum_1 += x
sum_list.append(sum_1) #途中までの和を記録。
i_1 += 1
# ③：上で求めた３つの情報（一周の和sum_1, 途中までの和の記録sum_list, ループ長i_1）
# を使って答えを求める。
ans += sum_1 * (N // i_1) + sum_list[(N % i_1)]
print(ans) | 60 | 67 | 823 | 1,497 | import sys
N, X, M = list(map(int, input().split()))
if N == 1:
print(X)
sys.exit()
ans = 0
ans += X - (X % M)
X %= M
def fun(x):
return (x * x) % M
appear_list = [X]
appear_set = {X}
x = X
i_0 = 1
sum_0 = x
while fun(x) not in appear_set:
x = fun(x)
appear_list.append(x)
appear_set.add(x)
sum_0 += x
i_0 += 1
# print(appear_list, x, fun(x))
# print(i_0, N, appear_set)
if i_0 == N:
print((ans + sum_0))
sys.exit()
ans += sum_0
N -= i_0
x = fun(x)
appear_set_2 = {x}
sum_1 = x
sum_list = [0, x]
i_1 = 1
while fun(x) not in appear_set_2:
x = fun(x)
appear_set_2.add(x)
sum_1 += x
sum_list.append(sum_1)
i_1 += 1
sum_0 -= sum_1
i_0 -= i_1
# print(N % i_1)
ans += sum_1 * (N // i_1) + sum_list[(N % i_1)]
print(ans)
| import sys
N, X, M = list(map(int, input().split()))
if N == 1: # 例外
print(X)
sys.exit()
ans = 0
ans += X - (X % M) # XがMより大きい場合、超過分を先に計上する。
X %= M # これで 0 <= X <= M-1 が成り立つようにできた。
def fun(x): # 問題の関数を用意（いちいち中身を書いていると面倒くさいため）
return (x * x) % M
appear_set = {X} # すでに現れた数を格納する
i_0 = 1 # 今までに調べた個数。現在は「X」の1つだけ。
x = X # このxに何度も関数funを作用させる
sum_0 = x # 現在までの和
# ①：すでに出現したことのある数が現れるまで、ループを回す。
# この途中で目標回数Nに到達するなら、その時点で答えを出力する(31-33行目)。
while fun(x) not in appear_set: # 次のxが初めて現れる数なら続ける。
x = fun(x) # xにfunを作用
appear_set.add(x) # xを「現れたものリスト」に格納
sum_0 += x # 和の更新
i_0 += 1 # 調べた個数の更新
if i_0 == N: # 目標回数に到達したら、その時点で答えを出力して終了。
print((ans + sum_0))
sys.exit()
# 現在、xには系列に初めて現れた最後の数が入っている。
# 次の数であるfun(x)は、前に現れたことのある数。したがって、ここからループが始まる。
# 整理のため、ここまでの和を計上し、残り回数も減らしておく。
ans += sum_0
N -= i_0
# ②：ループの性質を調べるため、もう一度ループを回したい。
# 欲しいものは3つ。
# 1.ループ１週の和
# 2.ループの途中までの和を記録した配列。
# 3.ループの長さ
# 以下、先ほどと異なる部分を中心に説明する。
x = fun(x) # 次の数へ行く(ループの最初の数)
appear_set_2 = {x}
sum_1 = x # 欲しいもの1。ループ１周の和を記録する。
sum_list = [0, x] # 欲しいもの2。i番目の要素がi番目までの数までの和を示すよう、この後要素を追加する。
i_1 = 1 # すでに調べた個数をカウントする。現在は「x」の1個だけ。
# このi_1が、最終的にループの長さ(欲しいもの3)になる。
# 以下、60行目以外の処理は先ほどと同様。
while fun(x) not in appear_set_2:
x = fun(x)
appear_set_2.add(x)
sum_1 += x
sum_list.append(sum_1) # 途中までの和を記録。
i_1 += 1
# ③：上で求めた３つの情報（一周の和sum_1, 途中までの和の記録sum_list, ループ長i_1）
# を使って答えを求める。
ans += sum_1 * (N // i_1) + sum_list[(N % i_1)]
print(ans)
| false | 10.447761 | [
"-if N == 1:",
"+if N == 1: # 例外",
"-ans += X - (X % M)",
"-X %= M",
"+ans += X - (X % M) # XがMより大きい場合、超過分を先に計上する。",
"+X %= M # これで 0 <= X <= M-1 が成り立つようにできた。",
"-def fun(x):",
"+def fun(x): # 問題の関数を用意（いちいち中身を書いていると面倒くさいため）",
"-appear_list = [X]",
"-appear_set = {X}",
"-x = X",
"-i_0 = 1",
"-sum_0 = x",
"-while fun(x) not in appear_set:",
"- x = fun(x)",
"- appear_list.append(x)",
"- appear_set.add(x)",
"- sum_0 += x",
"- i_0 += 1",
"- # print(appear_list, x, fun(x))",
"- # print(i_0, N, appear_set)",
"- if i_0 == N:",
"+appear_set = {X} # すでに現れた数を格納する",
"+i_0 = 1 # 今までに調べた個数。現在は「X」の1つだけ。",
"+x = X # このxに何度も関数funを作用させる",
"+sum_0 = x # 現在までの和",
"+# ①：すでに出現したことのある数が現れるまで、ループを回す。",
"+# この途中で目標回数Nに到達するなら、その時点で答えを出力する(31-33行目)。",
"+while fun(x) not in appear_set: # 次のxが初めて現れる数なら続ける。",
"+ x = fun(x) # xにfunを作用",
"+ appear_set.add(x) # xを「現れたものリスト」に格納",
"+ sum_0 += x # 和の更新",
"+ i_0 += 1 # 調べた個数の更新",
"+ if i_0 == N: # 目標回数に到達したら、その時点で答えを出力して終了。",
"+# 現在、xには系列に初めて現れた最後の数が入っている。",
"+# 次の数であるfun(x)は、前に現れたことのある数。したがって、ここからループが始まる。",
"+# 整理のため、ここまでの和を計上し、残り回数も減らしておく。",
"-x = fun(x)",
"+# ②：ループの性質を調べるため、もう一度ループを回したい。",
"+# 欲しいものは3つ。",
"+# 1.ループ１週の和",
"+# 2.ループの途中までの和を記録した配列。",
"+# 3.ループの長さ",
"+# 以下、先ほどと異なる部分を中心に説明する。",
"+x = fun(x) # 次の数へ行く(ループの最初の数)",
"-sum_1 = x",
"-sum_list = [0, x]",
"-i_1 = 1",
"+sum_1 = x # 欲しいもの1。ループ１周の和を記録する。",
"+sum_list = [0, x] # 欲しいもの2。i番目の要素がi番目までの数までの和を示すよう、この後要素を追加する。",
"+i_1 = 1 # すでに調べた個数をカウントする。現在は「x」の1個だけ。",
"+# このi_1が、最終的にループの長さ(欲しいもの3)になる。",
"+# 以下、60行目以外の処理は先ほどと同様。",
"- sum_list.append(sum_1)",
"+ sum_list.append(sum_1) # 途中までの和を記録。",
"-sum_0 -= sum_1",
"-i_0 -= i_1",
"-# print(N % i_1)",
"+# ③：上で求めた３つの情報（一周の和sum_1, 途中までの和の記録sum_list, ループ長i_1）",
"+# を使って答えを求める。"
] | false | 0.041658 | 0.037106 | 1.122655 | [
"s838630708",
"s095001760"
] |
u502389123 | p03549 | python | s537413571 | s291296641 | 20 | 18 | 3,188 | 3,064 | Accepted | Accepted | 10 | N, M = list(map(int, input().split()))
p = 0.5 ** M
q = 1 - p
i = 0
sum = 0
while True:
num = (i + 1) * (100 * (N-M) + 1900 * M) * p * (q ** i)
if num < 10 ** (-6):
break
sum += num
i += 1
print((int(sum+1)))
| N, M = list(map(int, input().split()))
print((2**M * (100*(N-M) + 1900*M))) | 14 | 3 | 240 | 70 | N, M = list(map(int, input().split()))
p = 0.5**M
q = 1 - p
i = 0
sum = 0
while True:
num = (i + 1) * (100 * (N - M) + 1900 * M) * p * (q**i)
if num < 10 ** (-6):
break
sum += num
i += 1
print((int(sum + 1)))
| N, M = list(map(int, input().split()))
print((2**M * (100 * (N - M) + 1900 * M)))
| false | 78.571429 | [
"-p = 0.5**M",
"-q = 1 - p",
"-i = 0",
"-sum = 0",
"-while True:",
"- num = (i + 1) * (100 * (N - M) + 1900 * M) * p * (q**i)",
"- if num < 10 ** (-6):",
"- break",
"- sum += num",
"- i += 1",
"-print((int(sum + 1)))",
"+print((2**M * (100 * (N - M) + 1900 * M)))"
] | false | 0.046568 | 0.04597 | 1.013006 | [
"s537413571",
"s291296641"
] |
u724687935 | p03033 | python | s267402927 | s194154842 | 1,697 | 1,517 | 137,436 | 108,348 | Accepted | Accepted | 10.61 | import sys
from heapq import heappush, heappop
I = sys.stdin.readlines()
N, Q = list(map(int, I[0].split()))
P = []
for i in range(1, N + 1):
s, t, x = list(map(int, I[i].split()))
P.append((s - x, t - 1 - x, x))
P.sort()
INF = float('inf')
P.append((INF, INF, INF))
q = []
cur = 0
s, t, x = P[cur]
for i in range(N + 1, N + Q + 1):
d = int(I[i])
while s <= d:
heappush(q, (x, t))
cur += 1
s, t, x = P[cur]
ans = -1
while len(q) > 0:
x1, t1 = q[0]
if d <= t1:
ans = x1
break
else:
heappop(q)
print(ans)
| import sys
from heapq import heappush, heappop
N, Q = map(int, input().split())
P = []
for i in range(1, N + 1):
s, t, x = map(int, sys.stdin.readline().split())
P.append((s - x, t - 1 - x, x))
P.sort()
q = []
cur = 0
ans = [-1] * Q
for i, d in enumerate(map(int, sys.stdin)):
while cur < N and P[cur][0] <= d:
s, t, x = P[cur]
heappush(q, (x, t))
cur += 1
while q:
x, t = q[0]
if d <= t:
ans[i] = x
break
else:
heappop(q)
print(*ans, sep='\n')
| 33 | 29 | 639 | 577 | import sys
from heapq import heappush, heappop
I = sys.stdin.readlines()
N, Q = list(map(int, I[0].split()))
P = []
for i in range(1, N + 1):
s, t, x = list(map(int, I[i].split()))
P.append((s - x, t - 1 - x, x))
P.sort()
INF = float("inf")
P.append((INF, INF, INF))
q = []
cur = 0
s, t, x = P[cur]
for i in range(N + 1, N + Q + 1):
d = int(I[i])
while s <= d:
heappush(q, (x, t))
cur += 1
s, t, x = P[cur]
ans = -1
while len(q) > 0:
x1, t1 = q[0]
if d <= t1:
ans = x1
break
else:
heappop(q)
print(ans)
| import sys
from heapq import heappush, heappop
N, Q = map(int, input().split())
P = []
for i in range(1, N + 1):
s, t, x = map(int, sys.stdin.readline().split())
P.append((s - x, t - 1 - x, x))
P.sort()
q = []
cur = 0
ans = [-1] * Q
for i, d in enumerate(map(int, sys.stdin)):
while cur < N and P[cur][0] <= d:
s, t, x = P[cur]
heappush(q, (x, t))
cur += 1
while q:
x, t = q[0]
if d <= t:
ans[i] = x
break
else:
heappop(q)
print(*ans, sep="\n")
| false | 12.121212 | [
"-I = sys.stdin.readlines()",
"-N, Q = list(map(int, I[0].split()))",
"+N, Q = map(int, input().split())",
"- s, t, x = list(map(int, I[i].split()))",
"+ s, t, x = map(int, sys.stdin.readline().split())",
"-INF = float(\"inf\")",
"-P.append((INF, INF, INF))",
"-s, t, x = P[cur]",
"-for i in range(N + 1, N + Q + 1):",
"- d = int(I[i])",
"- while s <= d:",
"+ans = [-1] * Q",
"+for i, d in enumerate(map(int, sys.stdin)):",
"+ while cur < N and P[cur][0] <= d:",
"+ s, t, x = P[cur]",
"- s, t, x = P[cur]",
"- ans = -1",
"- while len(q) > 0:",
"- x1, t1 = q[0]",
"- if d <= t1:",
"- ans = x1",
"+ while q:",
"+ x, t = q[0]",
"+ if d <= t:",
"+ ans[i] = x",
"- print(ans)",
"+print(*ans, sep=\"\\n\")"
] | false | 0.03892 | 0.065618 | 0.59312 | [
"s267402927",
"s194154842"
] |
u861886710 | p02683 | python | s700060656 | s865761107 | 96 | 69 | 9,220 | 9,236 | Accepted | Accepted | 28.12 |
N, M, X = list(map(int, input().split()))
C = []
A = []
for i in range(N):
t = list(map(int, input().split()))
C.append(t[0])
A.append(t[1:])
result = -1
"""
<< bit演算に関する演算子
左辺の値を右辺の値だけ左へシフトすることを意味する
https://www.javadrive.jp/python/num/index4.html
下記の場合、1からNまで2真数でシフトしていく感じ
"""
for i in range(1 << N):
#初期化
t = [0] * M
c = 0
#print(i)
for j in range(N):
#print(j)
if(i >> j ) & 1 == 0 :
continue
c += C[j]
for k in range(M):
t[k] += A[j][k]
if all(x >= X for x in t):
if result == -1:
result = c
else:
result = min(result, c)
print(result) | def check(learn_total):
for i in range(m):
if learn_total[i] < x:
return False
return True
def calc_price(bit):
price_total = 0 # 値段の合計
learn_total = [0] * m # 理解度
for i in range(n):
if (bit >> i) & 1: # i桁目が0か1か見て、i番目を買うか買わないか判定します
price_total += c[i] # 買うので、i番目の値段を加算します
learn = a[i] # 「i番目の参考書を読んで増える、各アルゴリズムの理解度」のリストです
for j, le in enumerate(learn): # 理解度を足します。 enumerateを使うと、range(n)よりスマートです
learn_total[j] += le
# 条件を満たすか、check関数で確認します
if check(learn_total):
return price_total
else:
return INF
if __name__ == '__main__':
INF = float("inf")
n, m, x = list(map(int, input().split()))
# 空のリストを作って、appendで追加していきます
c = [] # 参考書の値段です
a = [] # 各参考書に入る理解度です
for i in range(n):
c_temp, *a_temp = list(map(int, input().split())) # こうすると、2つ目以降をリストで受け取れます
c.append(c_temp)
a.append(a_temp)
ans = INF
for bit in range(1 << n):
price = calc_price(bit) # 条件を満たすなら価格、満たさないならINFが返ってきます
ans = min(ans, price) # 答えを更新します
if ans == INF:
print((-1))
else:
print(ans)
| 37 | 50 | 711 | 1,267 | N, M, X = list(map(int, input().split()))
C = []
A = []
for i in range(N):
t = list(map(int, input().split()))
C.append(t[0])
A.append(t[1:])
result = -1
"""
<< bit演算に関する演算子
左辺の値を右辺の値だけ左へシフトすることを意味する
https://www.javadrive.jp/python/num/index4.html
下記の場合、1からNまで2真数でシフトしていく感じ
"""
for i in range(1 << N):
# 初期化
t = [0] * M
c = 0
# print(i)
for j in range(N):
# print(j)
if (i >> j) & 1 == 0:
continue
c += C[j]
for k in range(M):
t[k] += A[j][k]
if all(x >= X for x in t):
if result == -1:
result = c
else:
result = min(result, c)
print(result)
| def check(learn_total):
for i in range(m):
if learn_total[i] < x:
return False
return True
def calc_price(bit):
price_total = 0 # 値段の合計
learn_total = [0] * m # 理解度
for i in range(n):
if (bit >> i) & 1: # i桁目が0か1か見て、i番目を買うか買わないか判定します
price_total += c[i] # 買うので、i番目の値段を加算します
learn = a[i] # 「i番目の参考書を読んで増える、各アルゴリズムの理解度」のリストです
for j, le in enumerate(learn): # 理解度を足します。 enumerateを使うと、range(n)よりスマートです
learn_total[j] += le
# 条件を満たすか、check関数で確認します
if check(learn_total):
return price_total
else:
return INF
if __name__ == "__main__":
INF = float("inf")
n, m, x = list(map(int, input().split()))
# 空のリストを作って、appendで追加していきます
c = [] # 参考書の値段です
a = [] # 各参考書に入る理解度です
for i in range(n):
c_temp, *a_temp = list(map(int, input().split())) # こうすると、2つ目以降をリストで受け取れます
c.append(c_temp)
a.append(a_temp)
ans = INF
for bit in range(1 << n):
price = calc_price(bit) # 条件を満たすなら価格、満たさないならINFが返ってきます
ans = min(ans, price) # 答えを更新します
if ans == INF:
print((-1))
else:
print(ans)
| false | 26 | [
"-N, M, X = list(map(int, input().split()))",
"-C = []",
"-A = []",
"-for i in range(N):",
"- t = list(map(int, input().split()))",
"- C.append(t[0])",
"- A.append(t[1:])",
"-result = -1",
"-\"\"\"",
"-<< bit演算に関する演算子",
"-左辺の値を右辺の値だけ左へシフトすることを意味する",
"-https://www.javadrive.jp/python/num/index4.html",
"-下記の場合、1からNまで2真数でシフトしていく感じ",
"-\"\"\"",
"-for i in range(1 << N):",
"- # 初期化",
"- t = [0] * M",
"- c = 0",
"- # print(i)",
"- for j in range(N):",
"- # print(j)",
"- if (i >> j) & 1 == 0:",
"- continue",
"- c += C[j]",
"- for k in range(M):",
"- t[k] += A[j][k]",
"- if all(x >= X for x in t):",
"- if result == -1:",
"- result = c",
"- else:",
"- result = min(result, c)",
"-print(result)",
"+def check(learn_total):",
"+ for i in range(m):",
"+ if learn_total[i] < x:",
"+ return False",
"+ return True",
"+",
"+",
"+def calc_price(bit):",
"+ price_total = 0 # 値段の合計",
"+ learn_total = [0] * m # 理解度",
"+ for i in range(n):",
"+ if (bit >> i) & 1: # i桁目が0か1か見て、i番目を買うか買わないか判定します",
"+ price_total += c[i] # 買うので、i番目の値段を加算します",
"+ learn = a[i] # 「i番目の参考書を読んで増える、各アルゴリズムの理解度」のリストです",
"+ for j, le in enumerate(learn): # 理解度を足します。 enumerateを使うと、range(n)よりスマートです",
"+ learn_total[j] += le",
"+ # 条件を満たすか、check関数で確認します",
"+ if check(learn_total):",
"+ return price_total",
"+ else:",
"+ return INF",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ INF = float(\"inf\")",
"+ n, m, x = list(map(int, input().split()))",
"+ # 空のリストを作って、appendで追加していきます",
"+ c = [] # 参考書の値段です",
"+ a = [] # 各参考書に入る理解度です",
"+ for i in range(n):",
"+ c_temp, *a_temp = list(map(int, input().split())) # こうすると、2つ目以降をリストで受け取れます",
"+ c.append(c_temp)",
"+ a.append(a_temp)",
"+ ans = INF",
"+ for bit in range(1 << n):",
"+ price = calc_price(bit) # 条件を満たすなら価格、満たさないならINFが返ってきます",
"+ ans = min(ans, price) # 答えを更新します",
"+ if ans == INF:",
"+ print((-1))",
"+ else:",
"+ print(ans)"
] | false | 0.038315 | 0.037759 | 1.014705 | [
"s700060656",
"s865761107"
] |
u471684875 | p03835 | python | s150258638 | s647119281 | 1,888 | 1,521 | 2,940 | 2,940 | Accepted | Accepted | 19.44 | k,s=list(map(int,input().split()))
ans=0
for i in range(0,k+1):
for j in range(0,k+1):
x=i
y=j
z=s-i-j
if 0<=z<=k:
ans+=1
else:
ans+=0
print(ans)
| k,s=list(map(int,input().split()))
ans=0
for i in range(k+1):
for j in range(k+1):
z=s-i-j
if k>=z>=0:
ans+=1
#print(i,j,z)
print(ans)
| 16 | 9 | 227 | 181 | k, s = list(map(int, input().split()))
ans = 0
for i in range(0, k + 1):
for j in range(0, k + 1):
x = i
y = j
z = s - i - j
if 0 <= z <= k:
ans += 1
else:
ans += 0
print(ans)
| k, s = list(map(int, input().split()))
ans = 0
for i in range(k + 1):
for j in range(k + 1):
z = s - i - j
if k >= z >= 0:
ans += 1
# print(i,j,z)
print(ans)
| false | 43.75 | [
"-for i in range(0, k + 1):",
"- for j in range(0, k + 1):",
"- x = i",
"- y = j",
"+for i in range(k + 1):",
"+ for j in range(k + 1):",
"- if 0 <= z <= k:",
"+ if k >= z >= 0:",
"- else:",
"- ans += 0",
"+ # print(i,j,z)"
] | false | 0.039075 | 0.036939 | 1.057842 | [
"s150258638",
"s647119281"
] |
u729133443 | p03722 | python | s428124792 | s077279780 | 359 | 211 | 45,144 | 14,364 | Accepted | Accepted | 41.23 | n,m=list(map(int,input().split()))
e=[]
for _ in range(m):
a,b,c=list(map(int,input().split()))
e.append([a-1,b-1,-c])
M=10**18
d=[0]+[M]*~-n
k=0
v=0
while k<n*2:
k+=1
if k==n:v=d[-1]
f=0
for a,b,c in e:
if d[b]>d[a]+c:
d[b]=d[a]+c
f=1
if not f:
break
if not v or v==d[-1]:
print((-d[-1]))
else:
print('inf') | from scipy.sparse import*
m=csr_matrix
n,*t=list(map(int,open(0).read().split()))
s=[n+1]*2
r,c,d=t[1::3],t[2::3],[-c for c in t[3::3]]
u=set(csgraph.depth_first_order(m((d,(c,r)),s),n,1,0))
r,c,d=list(zip(*[(r,c,d)for r,c,d in zip(r,c,d)if r in u and c in u]))
try:print((-int(csgraph.bellman_ford(m((d,(r,c)),s),1,[1])[0,n])))
except:print('inf') | 23 | 9 | 392 | 342 | n, m = list(map(int, input().split()))
e = []
for _ in range(m):
a, b, c = list(map(int, input().split()))
e.append([a - 1, b - 1, -c])
M = 10**18
d = [0] + [M] * ~-n
k = 0
v = 0
while k < n * 2:
k += 1
if k == n:
v = d[-1]
f = 0
for a, b, c in e:
if d[b] > d[a] + c:
d[b] = d[a] + c
f = 1
if not f:
break
if not v or v == d[-1]:
print((-d[-1]))
else:
print("inf")
| from scipy.sparse import *
m = csr_matrix
n, *t = list(map(int, open(0).read().split()))
s = [n + 1] * 2
r, c, d = t[1::3], t[2::3], [-c for c in t[3::3]]
u = set(csgraph.depth_first_order(m((d, (c, r)), s), n, 1, 0))
r, c, d = list(zip(*[(r, c, d) for r, c, d in zip(r, c, d) if r in u and c in u]))
try:
print((-int(csgraph.bellman_ford(m((d, (r, c)), s), 1, [1])[0, n])))
except:
print("inf")
| false | 60.869565 | [
"-n, m = list(map(int, input().split()))",
"-e = []",
"-for _ in range(m):",
"- a, b, c = list(map(int, input().split()))",
"- e.append([a - 1, b - 1, -c])",
"-M = 10**18",
"-d = [0] + [M] * ~-n",
"-k = 0",
"-v = 0",
"-while k < n * 2:",
"- k += 1",
"- if k == n:",
"- v = d[-1]",
"- f = 0",
"- for a, b, c in e:",
"- if d[b] > d[a] + c:",
"- d[b] = d[a] + c",
"- f = 1",
"- if not f:",
"- break",
"-if not v or v == d[-1]:",
"- print((-d[-1]))",
"-else:",
"+from scipy.sparse import *",
"+",
"+m = csr_matrix",
"+n, *t = list(map(int, open(0).read().split()))",
"+s = [n + 1] * 2",
"+r, c, d = t[1::3], t[2::3], [-c for c in t[3::3]]",
"+u = set(csgraph.depth_first_order(m((d, (c, r)), s), n, 1, 0))",
"+r, c, d = list(zip(*[(r, c, d) for r, c, d in zip(r, c, d) if r in u and c in u]))",
"+try:",
"+ print((-int(csgraph.bellman_ford(m((d, (r, c)), s), 1, [1])[0, n])))",
"+except:"
] | false | 0.078604 | 0.400926 | 0.196057 | [
"s428124792",
"s077279780"
] |
u185037583 | p02780 | python | s515585628 | s655600418 | 256 | 192 | 71,792 | 23,524 | Accepted | Accepted | 25 | n, k = list(map(int, input().split()))
p = [(int(i)+1.0)/2.0 for i in input().split()]
ans = 0
for i in range(k):
ans += p[i]
tmp1 = ans
for i in range(k, n):
tmp2 = (tmp1 - p[i-k])+p[i]
ans = max(ans, tmp2)
tmp1 = tmp2
print(('{:.12f}'.format(ans)))
| n, k = list(map(int, input().split()))
p = [(int(i)+1.0)/2.0 for i in input().split()]
ans = tmp = sum(p[:k])
for i in range(k,n):
tmp += p[i]-p[i-k]
ans = max(ans, tmp)
print(('{:.12f}'.format(ans)))
| 11 | 7 | 269 | 207 | n, k = list(map(int, input().split()))
p = [(int(i) + 1.0) / 2.0 for i in input().split()]
ans = 0
for i in range(k):
ans += p[i]
tmp1 = ans
for i in range(k, n):
tmp2 = (tmp1 - p[i - k]) + p[i]
ans = max(ans, tmp2)
tmp1 = tmp2
print(("{:.12f}".format(ans)))
| n, k = list(map(int, input().split()))
p = [(int(i) + 1.0) / 2.0 for i in input().split()]
ans = tmp = sum(p[:k])
for i in range(k, n):
tmp += p[i] - p[i - k]
ans = max(ans, tmp)
print(("{:.12f}".format(ans)))
| false | 36.363636 | [
"-ans = 0",
"-for i in range(k):",
"- ans += p[i]",
"-tmp1 = ans",
"+ans = tmp = sum(p[:k])",
"- tmp2 = (tmp1 - p[i - k]) + p[i]",
"- ans = max(ans, tmp2)",
"- tmp1 = tmp2",
"+ tmp += p[i] - p[i - k]",
"+ ans = max(ans, tmp)"
] | false | 0.086679 | 0.04882 | 1.775461 | [
"s515585628",
"s655600418"
] |
u367130284 | p03716 | python | s423696652 | s765321529 | 361 | 268 | 38,340 | 36,308 | Accepted | Accepted | 25.76 | from heapq import*;n,*a=list(map(int,open(0).read().split()));b,h,c,p=a[:n],heappushpop,[-i for i in a[n:][::-1]],heapify;s,d=sum(b),c[:n];t=sum(d);p(b);p(d);r,l=[s],[t]
for i in range(n,n*2):s+=a[i]-h(b,a[i]);t+=c[i]-h(d,c[i]);r+=[s];l+=[t]
print((max(list(map(sum,list(zip(r,l[::-1]))))))) | def f(a):
q=a[:n];s=sum(q);heapify(q);yield s
for e in a[n:2*n]:s+=e-heappushpop(q,e);yield s
from heapq import*;n,*a=list(map(int,open(0).read().split()));print((max(list(map(sum,list(zip(f(a),list(f([-e for e in a[::-1]]))[::-1]))))))) | 3 | 4 | 273 | 222 | from heapq import *
n, *a = list(map(int, open(0).read().split()))
b, h, c, p = a[:n], heappushpop, [-i for i in a[n:][::-1]], heapify
s, d = sum(b), c[:n]
t = sum(d)
p(b)
p(d)
r, l = [s], [t]
for i in range(n, n * 2):
s += a[i] - h(b, a[i])
t += c[i] - h(d, c[i])
r += [s]
l += [t]
print((max(list(map(sum, list(zip(r, l[::-1])))))))
| def f(a):
q = a[:n]
s = sum(q)
heapify(q)
yield s
for e in a[n : 2 * n]:
s += e - heappushpop(q, e)
yield s
from heapq import *
n, *a = list(map(int, open(0).read().split()))
print((max(list(map(sum, list(zip(f(a), list(f([-e for e in a[::-1]]))[::-1])))))))
| false | 25 | [
"+def f(a):",
"+ q = a[:n]",
"+ s = sum(q)",
"+ heapify(q)",
"+ yield s",
"+ for e in a[n : 2 * n]:",
"+ s += e - heappushpop(q, e)",
"+ yield s",
"+",
"+",
"-b, h, c, p = a[:n], heappushpop, [-i for i in a[n:][::-1]], heapify",
"-s, d = sum(b), c[:n]",
"-t = sum(d)",
"-p(b)",
"-p(d)",
"-r, l = [s], [t]",
"-for i in range(n, n * 2):",
"- s += a[i] - h(b, a[i])",
"- t += c[i] - h(d, c[i])",
"- r += [s]",
"- l += [t]",
"-print((max(list(map(sum, list(zip(r, l[::-1])))))))",
"+print((max(list(map(sum, list(zip(f(a), list(f([-e for e in a[::-1]]))[::-1])))))))"
] | false | 0.042069 | 0.041204 | 1.021002 | [
"s423696652",
"s765321529"
] |
u537962130 | p03146 | python | s457488841 | s756168038 | 166 | 64 | 38,256 | 61,868 | Accepted | Accepted | 61.45 | def resolve():
s=int(eval(input()))
l=[s]
while 1:
if s%2==0:
s//=2
else:
s=3*s+1
if s in l:
l.append(s)
break
l.append(s)
print((len(l)))
resolve() | s=int(eval(input()))
t=[]
k=1
while s not in t:
t+=[s]
s=3*s+1 if s%2 else s//2
k+=1
print(k) | 14 | 8 | 177 | 97 | def resolve():
s = int(eval(input()))
l = [s]
while 1:
if s % 2 == 0:
s //= 2
else:
s = 3 * s + 1
if s in l:
l.append(s)
break
l.append(s)
print((len(l)))
resolve()
| s = int(eval(input()))
t = []
k = 1
while s not in t:
t += [s]
s = 3 * s + 1 if s % 2 else s // 2
k += 1
print(k)
| false | 42.857143 | [
"-def resolve():",
"- s = int(eval(input()))",
"- l = [s]",
"- while 1:",
"- if s % 2 == 0:",
"- s //= 2",
"- else:",
"- s = 3 * s + 1",
"- if s in l:",
"- l.append(s)",
"- break",
"- l.append(s)",
"- print((len(l)))",
"-",
"-",
"-resolve()",
"+s = int(eval(input()))",
"+t = []",
"+k = 1",
"+while s not in t:",
"+ t += [s]",
"+ s = 3 * s + 1 if s % 2 else s // 2",
"+ k += 1",
"+print(k)"
] | false | 0.037573 | 0.036618 | 1.026089 | [
"s457488841",
"s756168038"
] |
u785578220 | p03779 | python | s055769659 | s231814934 | 32 | 24 | 2,940 | 2,940 | Accepted | Accepted | 25 | a = int(eval(input()))
s = 0
if a < 3:print(a)
else:
for i in range(1,a):
s+=i
if s-i < a <= s:
print(i)
break | a = int(eval(input()))
s = 0
for i in range(1,a+1):
s+=i
if s>=a:
print(i)
break | 10 | 7 | 158 | 92 | a = int(eval(input()))
s = 0
if a < 3:
print(a)
else:
for i in range(1, a):
s += i
if s - i < a <= s:
print(i)
break
| a = int(eval(input()))
s = 0
for i in range(1, a + 1):
s += i
if s >= a:
print(i)
break
| false | 30 | [
"-if a < 3:",
"- print(a)",
"-else:",
"- for i in range(1, a):",
"- s += i",
"- if s - i < a <= s:",
"- print(i)",
"- break",
"+for i in range(1, a + 1):",
"+ s += i",
"+ if s >= a:",
"+ print(i)",
"+ break"
] | false | 0.044347 | 0.047822 | 0.927329 | [
"s055769659",
"s231814934"
] |
u091852005 | p02780 | python | s525261141 | s674842656 | 429 | 216 | 25,604 | 25,060 | Accepted | Accepted | 49.65 | n, k = list(map(int, input().split()))
p = list(map(int, input().split()))
import numpy as np
exps = np.array(p) / 2 + 0.5
s = exps[:k].sum()
m = s
for i in range(1, n - k + 1):
s = s - exps[i-1] + exps[i+k-1]
if s > m:
m = s
print(m) | n, k = list(map(int, input().split()))
p = list(map(int, input().split()))
import numpy as np
exps = np.array(p) / 2 + 0.5
# s = exps[:k].sum()
# m = s
# for i in range(1, n - k + 1):
# s = s - exps[i-1] + exps[i+k-1]
# if s > m:
# m = s
# print(m)
cum = exps.cumsum()
diff = cum[k-1:n] - np.r_[0, cum[:n-k]]
print((diff.max())) | 13 | 17 | 258 | 355 | n, k = list(map(int, input().split()))
p = list(map(int, input().split()))
import numpy as np
exps = np.array(p) / 2 + 0.5
s = exps[:k].sum()
m = s
for i in range(1, n - k + 1):
s = s - exps[i - 1] + exps[i + k - 1]
if s > m:
m = s
print(m)
| n, k = list(map(int, input().split()))
p = list(map(int, input().split()))
import numpy as np
exps = np.array(p) / 2 + 0.5
# s = exps[:k].sum()
# m = s
# for i in range(1, n - k + 1):
# s = s - exps[i-1] + exps[i+k-1]
# if s > m:
# m = s
# print(m)
cum = exps.cumsum()
diff = cum[k - 1 : n] - np.r_[0, cum[: n - k]]
print((diff.max()))
| false | 23.529412 | [
"-s = exps[:k].sum()",
"-m = s",
"-for i in range(1, n - k + 1):",
"- s = s - exps[i - 1] + exps[i + k - 1]",
"- if s > m:",
"- m = s",
"-print(m)",
"+# s = exps[:k].sum()",
"+# m = s",
"+# for i in range(1, n - k + 1):",
"+# s = s - exps[i-1] + exps[i+k-1]",
"+# if s > m:",
"+# m = s",
"+# print(m)",
"+cum = exps.cumsum()",
"+diff = cum[k - 1 : n] - np.r_[0, cum[: n - k]]",
"+print((diff.max()))"
] | false | 0.289239 | 0.992712 | 0.291363 | [
"s525261141",
"s674842656"
] |
u197553307 | p03457 | python | s930121576 | s934352823 | 522 | 461 | 48,780 | 48,780 | Accepted | Accepted | 11.69 | N = int(eval(input()))
In = [list(map(int, input().split())) for _ in range(N)]
s = (0, 0)
t = 0
success = True
for move in In:
before_x, before_y = s
tn, after_x, after_y = move
dist_xy = abs(after_x - before_x) + abs(after_y - before_y)
walk = tn - t
if walk < dist_xy:
success *= False
if walk % 2 == 0 and dist_xy % 2 != 0:
success *= False
elif walk % 2 != 0 and dist_xy % 2 == 0:
success *= False
s = (after_x, after_y)
t = tn
print(("Yes" if success else "No")) | N = int(eval(input()))
In = [list(map(int, input().split())) for _ in range(N)]
s = (0, 0)
t = 0
success = True
for move in In:
before_x, before_y = s
tn, after_x, after_y = move
dist_xy = abs(after_x - before_x) + abs(after_y - before_y)
walk = tn - t
if walk < dist_xy:
success *= False
break
if walk % 2 == 0 and dist_xy % 2 != 0:
success *= False
break
elif walk % 2 != 0 and dist_xy % 2 == 0:
success *= False
break
s = (after_x, after_y)
t = tn
print(("Yes" if success else "No")) | 26 | 29 | 546 | 591 | N = int(eval(input()))
In = [list(map(int, input().split())) for _ in range(N)]
s = (0, 0)
t = 0
success = True
for move in In:
before_x, before_y = s
tn, after_x, after_y = move
dist_xy = abs(after_x - before_x) + abs(after_y - before_y)
walk = tn - t
if walk < dist_xy:
success *= False
if walk % 2 == 0 and dist_xy % 2 != 0:
success *= False
elif walk % 2 != 0 and dist_xy % 2 == 0:
success *= False
s = (after_x, after_y)
t = tn
print(("Yes" if success else "No"))
| N = int(eval(input()))
In = [list(map(int, input().split())) for _ in range(N)]
s = (0, 0)
t = 0
success = True
for move in In:
before_x, before_y = s
tn, after_x, after_y = move
dist_xy = abs(after_x - before_x) + abs(after_y - before_y)
walk = tn - t
if walk < dist_xy:
success *= False
break
if walk % 2 == 0 and dist_xy % 2 != 0:
success *= False
break
elif walk % 2 != 0 and dist_xy % 2 == 0:
success *= False
break
s = (after_x, after_y)
t = tn
print(("Yes" if success else "No"))
| false | 10.344828 | [
"+ break",
"+ break",
"+ break"
] | false | 0.035714 | 0.045348 | 0.787549 | [
"s930121576",
"s934352823"
] |
u533039576 | p03033 | python | s217071562 | s287444030 | 1,548 | 1,296 | 166,484 | 132,948 | Accepted | Accepted | 16.28 | from heapq import heappush, heappop
from operator import itemgetter
import sys
input = sys.stdin.readline
class PseudoSet():
def __init__(self):
self.s = [] # set
self.e = [] # erase candidate
def insert(self, x):
heappush(self.s, x)
def erase(self, x):
heappush(self.e, x)
def get_min(self):
while self.e and self.e[0] == self.s[0]:
_ = heappop(self.s)
_ = heappop(self.e)
return self.s[0] if len(self.s) > 0 else None
n, q = map(int, input().split())
stx = []
events = []
for i in range(n):
s, t, x = map(int, input().split())
stx.append((s, t, x))
events.append((s - x, +1, i))
events.append((t - x, -1, i))
for i in range(q):
d = int(input())
events.append((d, 2, i))
ans = [-1] * q
events.sort(key=itemgetter(0, 1))
# print(events)
ps = PseudoSet()
for c, t, i in events:
if t == 1:
ps.insert(stx[i][2])
elif t == -1:
ps.erase(stx[i][2])
else:
# t == 0
m = ps.get_min()
if m is not None:
ans[i] = m
print(*ans, sep='\n')
| from heapq import heappush, heappop
from operator import itemgetter
import sys
input = sys.stdin.readline
class PseudoSet():
def __init__(self):
self.s = [] # set
self.e = [] # erase candidate
def insert(self, x):
heappush(self.s, x)
def erase(self, x):
heappush(self.e, x)
def get_min(self):
while self.e and self.e[0] == self.s[0]:
_ = heappop(self.s)
_ = heappop(self.e)
return self.s[0] if len(self.s) > 0 else None
n, q = map(int, input().split())
events = []
for i in range(n):
s, t, x = map(int, input().split())
events.append((s - x, +1, x))
events.append((t - x, -1, x))
for i in range(q):
d = int(input())
events.append((d, 2, i))
ans = [-1] * q
events.sort(key=itemgetter(0, 1))
# print(events)
ps = PseudoSet()
for c, t, z in events:
if t == 1:
ps.insert(z)
elif t == -1:
ps.erase(z)
else:
# t == 2
m = ps.get_min()
if m is not None:
ans[z] = m
print(*ans, sep='\n')
| 52 | 50 | 1,164 | 1,111 | from heapq import heappush, heappop
from operator import itemgetter
import sys
input = sys.stdin.readline
class PseudoSet:
def __init__(self):
self.s = [] # set
self.e = [] # erase candidate
def insert(self, x):
heappush(self.s, x)
def erase(self, x):
heappush(self.e, x)
def get_min(self):
while self.e and self.e[0] == self.s[0]:
_ = heappop(self.s)
_ = heappop(self.e)
return self.s[0] if len(self.s) > 0 else None
n, q = map(int, input().split())
stx = []
events = []
for i in range(n):
s, t, x = map(int, input().split())
stx.append((s, t, x))
events.append((s - x, +1, i))
events.append((t - x, -1, i))
for i in range(q):
d = int(input())
events.append((d, 2, i))
ans = [-1] * q
events.sort(key=itemgetter(0, 1))
# print(events)
ps = PseudoSet()
for c, t, i in events:
if t == 1:
ps.insert(stx[i][2])
elif t == -1:
ps.erase(stx[i][2])
else:
# t == 0
m = ps.get_min()
if m is not None:
ans[i] = m
print(*ans, sep="\n")
| from heapq import heappush, heappop
from operator import itemgetter
import sys
input = sys.stdin.readline
class PseudoSet:
def __init__(self):
self.s = [] # set
self.e = [] # erase candidate
def insert(self, x):
heappush(self.s, x)
def erase(self, x):
heappush(self.e, x)
def get_min(self):
while self.e and self.e[0] == self.s[0]:
_ = heappop(self.s)
_ = heappop(self.e)
return self.s[0] if len(self.s) > 0 else None
n, q = map(int, input().split())
events = []
for i in range(n):
s, t, x = map(int, input().split())
events.append((s - x, +1, x))
events.append((t - x, -1, x))
for i in range(q):
d = int(input())
events.append((d, 2, i))
ans = [-1] * q
events.sort(key=itemgetter(0, 1))
# print(events)
ps = PseudoSet()
for c, t, z in events:
if t == 1:
ps.insert(z)
elif t == -1:
ps.erase(z)
else:
# t == 2
m = ps.get_min()
if m is not None:
ans[z] = m
print(*ans, sep="\n")
| false | 3.846154 | [
"-stx = []",
"- stx.append((s, t, x))",
"- events.append((s - x, +1, i))",
"- events.append((t - x, -1, i))",
"+ events.append((s - x, +1, x))",
"+ events.append((t - x, -1, x))",
"-for c, t, i in events:",
"+for c, t, z in events:",
"- ps.insert(stx[i][2])",
"+ ps.insert(z)",
"- ps.erase(stx[i][2])",
"+ ps.erase(z)",
"- # t == 0",
"+ # t == 2",
"- ans[i] = m",
"+ ans[z] = m"
] | false | 0.04176 | 0.037932 | 1.100921 | [
"s217071562",
"s287444030"
] |
u785578220 | p03032 | python | s897848463 | s025011502 | 42 | 37 | 3,064 | 3,064 | Accepted | Accepted | 11.9 | n,k = list(map(int,input().split()))
v = list(map(int,input().split()))
m=[]
M = min(n,k) +1
for i in range(M):
for j in range(M-i):
# print(i,j)
t=sorted(v[:i]+v[:~j:-1])
while t and(k-i-j)*t[0]<0:t.pop(0);j+=1
m.append(sum(t))
print((max(m)))
| N,K = list(map(int,input().split()))
V = list(map(int,input().split()))
import heapq
m = min(N,K)
M = 0
for i in range(m+1):
for j in range(m-i+1):
v1 = V[:i]
v3 = V[N-j:]
# print(v1,v3)
v = v1+v3
heapq.heapify(v)
h = K - len(v)
while v and len(v) and h >0:
q = heapq.heappop(v)
h-=1
if q > 0:
heapq.heappush(v,q)
break
tmp = sum(v)
# print(v,v3)
M = max(M,tmp)
print(M) | 13 | 23 | 260 | 539 | n, k = list(map(int, input().split()))
v = list(map(int, input().split()))
m = []
M = min(n, k) + 1
for i in range(M):
for j in range(M - i):
# print(i,j)
t = sorted(v[:i] + v[:~j:-1])
while t and (k - i - j) * t[0] < 0:
t.pop(0)
j += 1
m.append(sum(t))
print((max(m)))
| N, K = list(map(int, input().split()))
V = list(map(int, input().split()))
import heapq
m = min(N, K)
M = 0
for i in range(m + 1):
for j in range(m - i + 1):
v1 = V[:i]
v3 = V[N - j :]
# print(v1,v3)
v = v1 + v3
heapq.heapify(v)
h = K - len(v)
while v and len(v) and h > 0:
q = heapq.heappop(v)
h -= 1
if q > 0:
heapq.heappush(v, q)
break
tmp = sum(v)
# print(v,v3)
M = max(M, tmp)
print(M)
| false | 43.478261 | [
"-n, k = list(map(int, input().split()))",
"-v = list(map(int, input().split()))",
"-m = []",
"-M = min(n, k) + 1",
"-for i in range(M):",
"- for j in range(M - i):",
"- # print(i,j)",
"- t = sorted(v[:i] + v[:~j:-1])",
"- while t and (k - i - j) * t[0] < 0:",
"- t.pop(0)",
"- j += 1",
"- m.append(sum(t))",
"-print((max(m)))",
"+N, K = list(map(int, input().split()))",
"+V = list(map(int, input().split()))",
"+import heapq",
"+",
"+m = min(N, K)",
"+M = 0",
"+for i in range(m + 1):",
"+ for j in range(m - i + 1):",
"+ v1 = V[:i]",
"+ v3 = V[N - j :]",
"+ # print(v1,v3)",
"+ v = v1 + v3",
"+ heapq.heapify(v)",
"+ h = K - len(v)",
"+ while v and len(v) and h > 0:",
"+ q = heapq.heappop(v)",
"+ h -= 1",
"+ if q > 0:",
"+ heapq.heappush(v, q)",
"+ break",
"+ tmp = sum(v)",
"+ # print(v,v3)",
"+ M = max(M, tmp)",
"+print(M)"
] | false | 0.106104 | 0.038667 | 2.744076 | [
"s897848463",
"s025011502"
] |
u352394527 | p00503 | python | s839471796 | s219062217 | 2,050 | 1,050 | 14,324 | 14,320 | Accepted | Accepted | 48.78 | n, k = list(map(int, input().split()))
plst = []
xlst = []
ylst = []
dlst = []
for i in range(n):
x1,y1,d1,x2,y2,d2 = list(map(int, input().split()))
plst.append((x1,y1,d1,x2,y2,d2))
xlst.append(x1)
xlst.append(x2)
ylst.append(y1)
ylst.append(y2)
dlst.append(d1)
dlst.append(d2)
xlst = list(set(xlst))
ylst = list(set(ylst))
dlst = list(set(dlst))
xlst.sort()
ylst.sort()
dlst.sort()
xdic = {}
ydic = {}
ddic = {}
for i, v in enumerate(xlst):
xdic[v] = i
for i, v in enumerate(ylst):
ydic[v] = i
for i, v in enumerate(dlst):
ddic[v] = i
new_map = [[[0] * len(dlst) for _ in ylst] for _ in xlst]
for p in plst:
x1, y1, d1, x2, y2, d2 = p
x1, y1, d1, x2, y2, d2 = xdic[x1], ydic[y1], ddic[d1], xdic[x2], ydic[y2], ddic[d2]
for x in range(x1, x2):
for y in range(y1, y2):
for d in range(d1, d2):
new_map[x][y][d] += 1
ans = 0
for i in range(len(xlst) - 1):
for j in range(len(ylst) - 1):
for z in range(len(dlst) - 1):
x, y, d = xdic[xlst[i]], ydic[ylst[j]], ddic[dlst[z]]
if new_map[x][y][d] >= k:
ans += (xlst[i + 1] - xlst[i]) *(ylst[j + 1] - ylst[j]) * (dlst[z + 1] - dlst[z])
print(ans)
| def main():
n, k = list(map(int, input().split()))
plst = []
xlst = []
ylst = []
dlst = []
for i in range(n):
x1,y1,d1,x2,y2,d2 = list(map(int, input().split()))
plst.append((x1,y1,d1,x2,y2,d2))
xlst.append(x1)
xlst.append(x2)
ylst.append(y1)
ylst.append(y2)
dlst.append(d1)
dlst.append(d2)
xlst = list(set(xlst))
ylst = list(set(ylst))
dlst = list(set(dlst))
xlst.sort()
ylst.sort()
dlst.sort()
xdic = {}
ydic = {}
ddic = {}
for i, v in enumerate(xlst):
xdic[v] = i
for i, v in enumerate(ylst):
ydic[v] = i
for i, v in enumerate(dlst):
ddic[v] = i
new_map = [[[0] * len(dlst) for _ in ylst] for _ in xlst]
for p in plst:
x1, y1, d1, x2, y2, d2 = p
x1, y1, d1, x2, y2, d2 = xdic[x1], ydic[y1], ddic[d1], xdic[x2], ydic[y2], ddic[d2]
for x in range(x1, x2):
for y in range(y1, y2):
for d in range(d1, d2):
new_map[x][y][d] += 1
ans = 0
for i in range(len(xlst) - 1):
xlsti = xlst[i]
xlsti1 = xlst[i + 1]
x = xdic[xlsti]
for j in range(len(ylst) - 1):
ylstj = ylst[j]
ylstj1 = ylst[j + 1]
y = ydic[ylstj]
for z in range(len(dlst) - 1):
dlstz = dlst[z]
dlstz1 = dlst[z + 1]
d = ddic[dlstz]
if new_map[x][y][d] >= k:
ans += (xlsti1 - xlsti) * (ylstj1 - ylstj) * (dlstz1 - dlstz)
print(ans)
main()
| 54 | 65 | 1,211 | 1,481 | n, k = list(map(int, input().split()))
plst = []
xlst = []
ylst = []
dlst = []
for i in range(n):
x1, y1, d1, x2, y2, d2 = list(map(int, input().split()))
plst.append((x1, y1, d1, x2, y2, d2))
xlst.append(x1)
xlst.append(x2)
ylst.append(y1)
ylst.append(y2)
dlst.append(d1)
dlst.append(d2)
xlst = list(set(xlst))
ylst = list(set(ylst))
dlst = list(set(dlst))
xlst.sort()
ylst.sort()
dlst.sort()
xdic = {}
ydic = {}
ddic = {}
for i, v in enumerate(xlst):
xdic[v] = i
for i, v in enumerate(ylst):
ydic[v] = i
for i, v in enumerate(dlst):
ddic[v] = i
new_map = [[[0] * len(dlst) for _ in ylst] for _ in xlst]
for p in plst:
x1, y1, d1, x2, y2, d2 = p
x1, y1, d1, x2, y2, d2 = xdic[x1], ydic[y1], ddic[d1], xdic[x2], ydic[y2], ddic[d2]
for x in range(x1, x2):
for y in range(y1, y2):
for d in range(d1, d2):
new_map[x][y][d] += 1
ans = 0
for i in range(len(xlst) - 1):
for j in range(len(ylst) - 1):
for z in range(len(dlst) - 1):
x, y, d = xdic[xlst[i]], ydic[ylst[j]], ddic[dlst[z]]
if new_map[x][y][d] >= k:
ans += (
(xlst[i + 1] - xlst[i])
* (ylst[j + 1] - ylst[j])
* (dlst[z + 1] - dlst[z])
)
print(ans)
| def main():
n, k = list(map(int, input().split()))
plst = []
xlst = []
ylst = []
dlst = []
for i in range(n):
x1, y1, d1, x2, y2, d2 = list(map(int, input().split()))
plst.append((x1, y1, d1, x2, y2, d2))
xlst.append(x1)
xlst.append(x2)
ylst.append(y1)
ylst.append(y2)
dlst.append(d1)
dlst.append(d2)
xlst = list(set(xlst))
ylst = list(set(ylst))
dlst = list(set(dlst))
xlst.sort()
ylst.sort()
dlst.sort()
xdic = {}
ydic = {}
ddic = {}
for i, v in enumerate(xlst):
xdic[v] = i
for i, v in enumerate(ylst):
ydic[v] = i
for i, v in enumerate(dlst):
ddic[v] = i
new_map = [[[0] * len(dlst) for _ in ylst] for _ in xlst]
for p in plst:
x1, y1, d1, x2, y2, d2 = p
x1, y1, d1, x2, y2, d2 = (
xdic[x1],
ydic[y1],
ddic[d1],
xdic[x2],
ydic[y2],
ddic[d2],
)
for x in range(x1, x2):
for y in range(y1, y2):
for d in range(d1, d2):
new_map[x][y][d] += 1
ans = 0
for i in range(len(xlst) - 1):
xlsti = xlst[i]
xlsti1 = xlst[i + 1]
x = xdic[xlsti]
for j in range(len(ylst) - 1):
ylstj = ylst[j]
ylstj1 = ylst[j + 1]
y = ydic[ylstj]
for z in range(len(dlst) - 1):
dlstz = dlst[z]
dlstz1 = dlst[z + 1]
d = ddic[dlstz]
if new_map[x][y][d] >= k:
ans += (xlsti1 - xlsti) * (ylstj1 - ylstj) * (dlstz1 - dlstz)
print(ans)
main()
| false | 16.923077 | [
"-n, k = list(map(int, input().split()))",
"-plst = []",
"-xlst = []",
"-ylst = []",
"-dlst = []",
"-for i in range(n):",
"- x1, y1, d1, x2, y2, d2 = list(map(int, input().split()))",
"- plst.append((x1, y1, d1, x2, y2, d2))",
"- xlst.append(x1)",
"- xlst.append(x2)",
"- ylst.append(y1)",
"- ylst.append(y2)",
"- dlst.append(d1)",
"- dlst.append(d2)",
"-xlst = list(set(xlst))",
"-ylst = list(set(ylst))",
"-dlst = list(set(dlst))",
"-xlst.sort()",
"-ylst.sort()",
"-dlst.sort()",
"-xdic = {}",
"-ydic = {}",
"-ddic = {}",
"-for i, v in enumerate(xlst):",
"- xdic[v] = i",
"-for i, v in enumerate(ylst):",
"- ydic[v] = i",
"-for i, v in enumerate(dlst):",
"- ddic[v] = i",
"-new_map = [[[0] * len(dlst) for _ in ylst] for _ in xlst]",
"-for p in plst:",
"- x1, y1, d1, x2, y2, d2 = p",
"- x1, y1, d1, x2, y2, d2 = xdic[x1], ydic[y1], ddic[d1], xdic[x2], ydic[y2], ddic[d2]",
"- for x in range(x1, x2):",
"- for y in range(y1, y2):",
"- for d in range(d1, d2):",
"- new_map[x][y][d] += 1",
"-ans = 0",
"-for i in range(len(xlst) - 1):",
"- for j in range(len(ylst) - 1):",
"- for z in range(len(dlst) - 1):",
"- x, y, d = xdic[xlst[i]], ydic[ylst[j]], ddic[dlst[z]]",
"- if new_map[x][y][d] >= k:",
"- ans += (",
"- (xlst[i + 1] - xlst[i])",
"- * (ylst[j + 1] - ylst[j])",
"- * (dlst[z + 1] - dlst[z])",
"- )",
"-print(ans)",
"+def main():",
"+ n, k = list(map(int, input().split()))",
"+ plst = []",
"+ xlst = []",
"+ ylst = []",
"+ dlst = []",
"+ for i in range(n):",
"+ x1, y1, d1, x2, y2, d2 = list(map(int, input().split()))",
"+ plst.append((x1, y1, d1, x2, y2, d2))",
"+ xlst.append(x1)",
"+ xlst.append(x2)",
"+ ylst.append(y1)",
"+ ylst.append(y2)",
"+ dlst.append(d1)",
"+ dlst.append(d2)",
"+ xlst = list(set(xlst))",
"+ ylst = list(set(ylst))",
"+ dlst = list(set(dlst))",
"+ xlst.sort()",
"+ ylst.sort()",
"+ dlst.sort()",
"+ xdic = {}",
"+ ydic = {}",
"+ ddic = {}",
"+ for i, v in enumerate(xlst):",
"+ xdic[v] = i",
"+ for i, v in enumerate(ylst):",
"+ ydic[v] = i",
"+ for i, v in enumerate(dlst):",
"+ ddic[v] = i",
"+ new_map = [[[0] * len(dlst) for _ in ylst] for _ in xlst]",
"+ for p in plst:",
"+ x1, y1, d1, x2, y2, d2 = p",
"+ x1, y1, d1, x2, y2, d2 = (",
"+ xdic[x1],",
"+ ydic[y1],",
"+ ddic[d1],",
"+ xdic[x2],",
"+ ydic[y2],",
"+ ddic[d2],",
"+ )",
"+ for x in range(x1, x2):",
"+ for y in range(y1, y2):",
"+ for d in range(d1, d2):",
"+ new_map[x][y][d] += 1",
"+ ans = 0",
"+ for i in range(len(xlst) - 1):",
"+ xlsti = xlst[i]",
"+ xlsti1 = xlst[i + 1]",
"+ x = xdic[xlsti]",
"+ for j in range(len(ylst) - 1):",
"+ ylstj = ylst[j]",
"+ ylstj1 = ylst[j + 1]",
"+ y = ydic[ylstj]",
"+ for z in range(len(dlst) - 1):",
"+ dlstz = dlst[z]",
"+ dlstz1 = dlst[z + 1]",
"+ d = ddic[dlstz]",
"+ if new_map[x][y][d] >= k:",
"+ ans += (xlsti1 - xlsti) * (ylstj1 - ylstj) * (dlstz1 - dlstz)",
"+ print(ans)",
"+",
"+",
"+main()"
] | false | 0.036205 | 0.03632 | 0.996847 | [
"s839471796",
"s219062217"
] |
u227082700 | p03912 | python | s588797698 | s534588566 | 425 | 368 | 19,384 | 76,652 | Accepted | Accepted | 13.41 | n,m=list(map(int,input().split()))
a=list(map(int,input().split()))
from collections import Counter
mo=[[]for _ in range(m)]
for i in a:mo[i%m].append(i)
ans=len(mo[0])//2
if m%2==0:ans+=len(mo[m//2])//2
for i in range(1,0--m//2):
if len(mo[i])>len(mo[m-i]):d=Counter(mo[i])
elif len(mo[i])==len(mo[m-i]):
ans+=len(mo[i])
continue
else:d=Counter(mo[m-i])
anss=0
for j in d:anss+=d[j]//2
ans+=min(len(mo[i]),len(mo[m-i]))+min(abs(len(mo[i])-len(mo[m-i]))//2,anss)
print(ans) | n,m=list(map(int,input().split()))
x=list(map(int,input().split()))
a=[[]for _ in range(m)]
for i in x:a[i%m].append(i)
b=[]
from collections import Counter
for i in range(m):
d=Counter(a[i])
ans=0
for j in d:ans+=2*(d[j]//2)
b.append([len(a[i]),ans])
ans=0
if m%2==0:ans+=len(a[m//2])//2
ans+=len(a[0])//2
for i in range(1,0--m//2):
sc,sp=b[i]
tc,tp=b[m-i]
v=min(sc,tc)
ans+=v
ans+=min(sp,sc-v)//2
ans+=min(tp,tc-v)//2
print(ans) | 17 | 22 | 503 | 465 | n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
from collections import Counter
mo = [[] for _ in range(m)]
for i in a:
mo[i % m].append(i)
ans = len(mo[0]) // 2
if m % 2 == 0:
ans += len(mo[m // 2]) // 2
for i in range(1, 0 - -m // 2):
if len(mo[i]) > len(mo[m - i]):
d = Counter(mo[i])
elif len(mo[i]) == len(mo[m - i]):
ans += len(mo[i])
continue
else:
d = Counter(mo[m - i])
anss = 0
for j in d:
anss += d[j] // 2
ans += min(len(mo[i]), len(mo[m - i])) + min(
abs(len(mo[i]) - len(mo[m - i])) // 2, anss
)
print(ans)
| n, m = list(map(int, input().split()))
x = list(map(int, input().split()))
a = [[] for _ in range(m)]
for i in x:
a[i % m].append(i)
b = []
from collections import Counter
for i in range(m):
d = Counter(a[i])
ans = 0
for j in d:
ans += 2 * (d[j] // 2)
b.append([len(a[i]), ans])
ans = 0
if m % 2 == 0:
ans += len(a[m // 2]) // 2
ans += len(a[0]) // 2
for i in range(1, 0 - -m // 2):
sc, sp = b[i]
tc, tp = b[m - i]
v = min(sc, tc)
ans += v
ans += min(sp, sc - v) // 2
ans += min(tp, tc - v) // 2
print(ans)
| false | 22.727273 | [
"-a = list(map(int, input().split()))",
"+x = list(map(int, input().split()))",
"+a = [[] for _ in range(m)]",
"+for i in x:",
"+ a[i % m].append(i)",
"+b = []",
"-mo = [[] for _ in range(m)]",
"-for i in a:",
"- mo[i % m].append(i)",
"-ans = len(mo[0]) // 2",
"+for i in range(m):",
"+ d = Counter(a[i])",
"+ ans = 0",
"+ for j in d:",
"+ ans += 2 * (d[j] // 2)",
"+ b.append([len(a[i]), ans])",
"+ans = 0",
"- ans += len(mo[m // 2]) // 2",
"+ ans += len(a[m // 2]) // 2",
"+ans += len(a[0]) // 2",
"- if len(mo[i]) > len(mo[m - i]):",
"- d = Counter(mo[i])",
"- elif len(mo[i]) == len(mo[m - i]):",
"- ans += len(mo[i])",
"- continue",
"- else:",
"- d = Counter(mo[m - i])",
"- anss = 0",
"- for j in d:",
"- anss += d[j] // 2",
"- ans += min(len(mo[i]), len(mo[m - i])) + min(",
"- abs(len(mo[i]) - len(mo[m - i])) // 2, anss",
"- )",
"+ sc, sp = b[i]",
"+ tc, tp = b[m - i]",
"+ v = min(sc, tc)",
"+ ans += v",
"+ ans += min(sp, sc - v) // 2",
"+ ans += min(tp, tc - v) // 2"
] | false | 0.043355 | 0.081062 | 0.534845 | [
"s588797698",
"s534588566"
] |
u241159583 | p02802 | python | s565114842 | s486752772 | 302 | 243 | 33,692 | 32,060 | Accepted | Accepted | 19.54 | n,m = list(map(int, input().split()))
ps = [input().split() for _ in range(m)]
problem = [0] * n
pp = [0]*n
b = ""
for p,s in ps:
if problem[int(p)-1] == 0:
if s == "WA":pp[int(p)-1] += 1
else: problem[int(p)-1] = 1
ac = 0
pe = 0
for i in range(n):
if problem[i] == 1:
ac += 1
pe += pp[i]
print((ac,pe)) | n,m = list(map(int, input().split()))
ps = [list(input().split()) for _ in range(m)]
P = [0] * (n+1)
pena = [0] * (n+1)
for p,s in ps:
p = int(p)
if s == "WA":
if P[p] == 0: pena[p] += 1
else:
P[p] = 1
ans = [0,0]
for p,pe in zip(P,pena):
p = int(p)
if p == 0: continue
ans[0] += 1
ans[1] += pe
print((" ".join(map(str, ans)))) | 17 | 18 | 352 | 381 | n, m = list(map(int, input().split()))
ps = [input().split() for _ in range(m)]
problem = [0] * n
pp = [0] * n
b = ""
for p, s in ps:
if problem[int(p) - 1] == 0:
if s == "WA":
pp[int(p) - 1] += 1
else:
problem[int(p) - 1] = 1
ac = 0
pe = 0
for i in range(n):
if problem[i] == 1:
ac += 1
pe += pp[i]
print((ac, pe))
| n, m = list(map(int, input().split()))
ps = [list(input().split()) for _ in range(m)]
P = [0] * (n + 1)
pena = [0] * (n + 1)
for p, s in ps:
p = int(p)
if s == "WA":
if P[p] == 0:
pena[p] += 1
else:
P[p] = 1
ans = [0, 0]
for p, pe in zip(P, pena):
p = int(p)
if p == 0:
continue
ans[0] += 1
ans[1] += pe
print((" ".join(map(str, ans))))
| false | 5.555556 | [
"-ps = [input().split() for _ in range(m)]",
"-problem = [0] * n",
"-pp = [0] * n",
"-b = \"\"",
"+ps = [list(input().split()) for _ in range(m)]",
"+P = [0] * (n + 1)",
"+pena = [0] * (n + 1)",
"- if problem[int(p) - 1] == 0:",
"- if s == \"WA\":",
"- pp[int(p) - 1] += 1",
"- else:",
"- problem[int(p) - 1] = 1",
"-ac = 0",
"-pe = 0",
"-for i in range(n):",
"- if problem[i] == 1:",
"- ac += 1",
"- pe += pp[i]",
"-print((ac, pe))",
"+ p = int(p)",
"+ if s == \"WA\":",
"+ if P[p] == 0:",
"+ pena[p] += 1",
"+ else:",
"+ P[p] = 1",
"+ans = [0, 0]",
"+for p, pe in zip(P, pena):",
"+ p = int(p)",
"+ if p == 0:",
"+ continue",
"+ ans[0] += 1",
"+ ans[1] += pe",
"+print((\" \".join(map(str, ans))))"
] | false | 0.052193 | 0.0491 | 1.063008 | [
"s565114842",
"s486752772"
] |
u837673618 | p02709 | python | s250942576 | s127469250 | 838 | 760 | 9,960 | 9,584 | Accepted | Accepted | 9.31 |
N = int(eval(input()))
A = list(map(int, input().split()))
AI = sorted(((a, i) for i, a in enumerate(A, 1)), reverse=True)
def solve(a, i, prev):
pl, pr, ps = i, 0, 0
for l, r, s in prev:
yield l, r-1, max(s+abs(r-i)*a, ps+abs(i-pl)*a)
pl, pr, ps = l, r, s
yield pl+1, pr, ps+abs(i-pl)*a
prev = [(1, N, 0)]
for a,i in AI:
prev = [*solve(a,i, prev)]
print((max(s for l, r, s in prev)))
| N = int(eval(input()))
def solve(a, i, prev):
r = N - len(prev) - i + 1
p = -i*a
for j, s in enumerate(prev):
yield max(p+abs(j-i)*a, s+abs(j+r)*a)
p = s
yield s+abs(len(prev)-i)*a
pd = [0]
A = list(map(int, input().split()))
for a,i in sorted(((a, i) for i, a in enumerate(A, 1)), reverse=True):
pd = [*solve(a,i, pd)]
print((max(pd)))
| 18 | 16 | 409 | 359 | N = int(eval(input()))
A = list(map(int, input().split()))
AI = sorted(((a, i) for i, a in enumerate(A, 1)), reverse=True)
def solve(a, i, prev):
pl, pr, ps = i, 0, 0
for l, r, s in prev:
yield l, r - 1, max(s + abs(r - i) * a, ps + abs(i - pl) * a)
pl, pr, ps = l, r, s
yield pl + 1, pr, ps + abs(i - pl) * a
prev = [(1, N, 0)]
for a, i in AI:
prev = [*solve(a, i, prev)]
print((max(s for l, r, s in prev)))
| N = int(eval(input()))
def solve(a, i, prev):
r = N - len(prev) - i + 1
p = -i * a
for j, s in enumerate(prev):
yield max(p + abs(j - i) * a, s + abs(j + r) * a)
p = s
yield s + abs(len(prev) - i) * a
pd = [0]
A = list(map(int, input().split()))
for a, i in sorted(((a, i) for i, a in enumerate(A, 1)), reverse=True):
pd = [*solve(a, i, pd)]
print((max(pd)))
| false | 11.111111 | [
"-A = list(map(int, input().split()))",
"-AI = sorted(((a, i) for i, a in enumerate(A, 1)), reverse=True)",
"- pl, pr, ps = i, 0, 0",
"- for l, r, s in prev:",
"- yield l, r - 1, max(s + abs(r - i) * a, ps + abs(i - pl) * a)",
"- pl, pr, ps = l, r, s",
"- yield pl + 1, pr, ps + abs(i - pl) * a",
"+ r = N - len(prev) - i + 1",
"+ p = -i * a",
"+ for j, s in enumerate(prev):",
"+ yield max(p + abs(j - i) * a, s + abs(j + r) * a)",
"+ p = s",
"+ yield s + abs(len(prev) - i) * a",
"-prev = [(1, N, 0)]",
"-for a, i in AI:",
"- prev = [*solve(a, i, prev)]",
"-print((max(s for l, r, s in prev)))",
"+pd = [0]",
"+A = list(map(int, input().split()))",
"+for a, i in sorted(((a, i) for i, a in enumerate(A, 1)), reverse=True):",
"+ pd = [*solve(a, i, pd)]",
"+print((max(pd)))"
] | false | 0.037537 | 0.112413 | 0.333924 | [
"s250942576",
"s127469250"
] |
u057079894 | p03835 | python | s327696508 | s940827165 | 1,943 | 1,414 | 2,940 | 2,940 | Accepted | Accepted | 27.23 | n,s=list(map(int,input().split()))
ans=0
for i in range(n+1):
for j in range(n+1):
if s-i-j>-1 and s-i-j<n+1:
ans+=1
print(ans)
| n,s=list(map(int,input().split()))
ans=0
for i in range(n+1):
if s-i>n*2 or s-i<0:
continue
for j in range(n+1):
if -1<s-i-j<n+1:
ans+=1
print(ans)
| 7 | 9 | 140 | 168 | n, s = list(map(int, input().split()))
ans = 0
for i in range(n + 1):
for j in range(n + 1):
if s - i - j > -1 and s - i - j < n + 1:
ans += 1
print(ans)
| n, s = list(map(int, input().split()))
ans = 0
for i in range(n + 1):
if s - i > n * 2 or s - i < 0:
continue
for j in range(n + 1):
if -1 < s - i - j < n + 1:
ans += 1
print(ans)
| false | 22.222222 | [
"+ if s - i > n * 2 or s - i < 0:",
"+ continue",
"- if s - i - j > -1 and s - i - j < n + 1:",
"+ if -1 < s - i - j < n + 1:"
] | false | 0.036182 | 0.041872 | 0.864109 | [
"s327696508",
"s940827165"
] |
u079022693 | p03163 | python | s681651213 | s510373790 | 417 | 236 | 118,512 | 92,960 | Accepted | Accepted | 43.41 | def main():
N,W=list(map(int,input().split()))
w=[0]*(N+1)
v=[0]*(N+1)
for i in range(1,N+1):
a,b=list(map(int,input().split()))
w[i]=a
v[i]=b
dp=[[0]*(W+1) for _ in range(N+1)]
for i in range(1,N+1):
for j in range(W+1):
if j-w[i]>=0:
dp[i][j]=max(dp[i-1][j],dp[i-1][j-w[i]]+v[i])
else:
dp[i][j]=dp[i-1][j]
print((dp[N][W]))
if __name__=="__main__":
main() | from sys import stdin
import numpy as np
def main():
#入力
readline=stdin.readline
inf=10**12
n,max_w=list(map(int,readline().split()))
w=[0]*n
v=[0]*n
for i in range(n):
w[i],v[i]=list(map(int,readline().split()))
dp=np.full((n+1,max_w+1),-inf,dtype=np.int64)
dp[0][0]=0
for i in range(n):
dp[i+1,:w[i]]=dp[i,:w[i]]
dp[i+1,w[i]:]=np.maximum(dp[i,w[i]:],dp[i,:max_w-w[i]+1]+v[i])
print((dp[n].max()))
if __name__=="__main__":
main() | 20 | 22 | 484 | 512 | def main():
N, W = list(map(int, input().split()))
w = [0] * (N + 1)
v = [0] * (N + 1)
for i in range(1, N + 1):
a, b = list(map(int, input().split()))
w[i] = a
v[i] = b
dp = [[0] * (W + 1) for _ in range(N + 1)]
for i in range(1, N + 1):
for j in range(W + 1):
if j - w[i] >= 0:
dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - w[i]] + v[i])
else:
dp[i][j] = dp[i - 1][j]
print((dp[N][W]))
if __name__ == "__main__":
main()
| from sys import stdin
import numpy as np
def main():
# 入力
readline = stdin.readline
inf = 10**12
n, max_w = list(map(int, readline().split()))
w = [0] * n
v = [0] * n
for i in range(n):
w[i], v[i] = list(map(int, readline().split()))
dp = np.full((n + 1, max_w + 1), -inf, dtype=np.int64)
dp[0][0] = 0
for i in range(n):
dp[i + 1, : w[i]] = dp[i, : w[i]]
dp[i + 1, w[i] :] = np.maximum(dp[i, w[i] :], dp[i, : max_w - w[i] + 1] + v[i])
print((dp[n].max()))
if __name__ == "__main__":
main()
| false | 9.090909 | [
"+from sys import stdin",
"+import numpy as np",
"+",
"+",
"- N, W = list(map(int, input().split()))",
"- w = [0] * (N + 1)",
"- v = [0] * (N + 1)",
"- for i in range(1, N + 1):",
"- a, b = list(map(int, input().split()))",
"- w[i] = a",
"- v[i] = b",
"- dp = [[0] * (W + 1) for _ in range(N + 1)]",
"- for i in range(1, N + 1):",
"- for j in range(W + 1):",
"- if j - w[i] >= 0:",
"- dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - w[i]] + v[i])",
"- else:",
"- dp[i][j] = dp[i - 1][j]",
"- print((dp[N][W]))",
"+ # 入力",
"+ readline = stdin.readline",
"+ inf = 10**12",
"+ n, max_w = list(map(int, readline().split()))",
"+ w = [0] * n",
"+ v = [0] * n",
"+ for i in range(n):",
"+ w[i], v[i] = list(map(int, readline().split()))",
"+ dp = np.full((n + 1, max_w + 1), -inf, dtype=np.int64)",
"+ dp[0][0] = 0",
"+ for i in range(n):",
"+ dp[i + 1, : w[i]] = dp[i, : w[i]]",
"+ dp[i + 1, w[i] :] = np.maximum(dp[i, w[i] :], dp[i, : max_w - w[i] + 1] + v[i])",
"+ print((dp[n].max()))"
] | false | 0.031911 | 0.180087 | 0.177196 | [
"s681651213",
"s510373790"
] |
u638456847 | p03600 | python | s625045990 | s869556862 | 378 | 281 | 42,588 | 23,548 | Accepted | Accepted | 25.66 | import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
def main():
N = int(readline())
A = [[int(i) for i in readline().split()] for _ in range(N)]
ans = 0
for i in range(N-1):
for j in range(i+1,N):
d = A[i][j]
flag = True
for k in range(N):
if k == i or k == j:
continue
tmp = A[i][k] + A[k][j]
if tmp < d:
print((-1))
exit()
elif tmp == d:
flag = False
break
if flag:
ans += d
print(ans)
if __name__ == "__main__":
main()
| import numpy as np
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
def main():
N = int(readline())
A = np.array(read().split(), dtype=np.int64).reshape(N,N)
INF = 10**15
ans = 0
for i in range(N):
B = A[i,:] + A
np.fill_diagonal(B, INF)
B[:,i] = INF
C = B.min(axis=1)
C[i] = 0
if (C < A[i,:]).sum() > 0:
print((-1))
exit()
else:
index = C > A[i,:]
ans += A[i, index].sum()
print((ans // 2))
if __name__ == "__main__":
main()
| 34 | 31 | 799 | 636 | import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
def main():
N = int(readline())
A = [[int(i) for i in readline().split()] for _ in range(N)]
ans = 0
for i in range(N - 1):
for j in range(i + 1, N):
d = A[i][j]
flag = True
for k in range(N):
if k == i or k == j:
continue
tmp = A[i][k] + A[k][j]
if tmp < d:
print((-1))
exit()
elif tmp == d:
flag = False
break
if flag:
ans += d
print(ans)
if __name__ == "__main__":
main()
| import numpy as np
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
def main():
N = int(readline())
A = np.array(read().split(), dtype=np.int64).reshape(N, N)
INF = 10**15
ans = 0
for i in range(N):
B = A[i, :] + A
np.fill_diagonal(B, INF)
B[:, i] = INF
C = B.min(axis=1)
C[i] = 0
if (C < A[i, :]).sum() > 0:
print((-1))
exit()
else:
index = C > A[i, :]
ans += A[i, index].sum()
print((ans // 2))
if __name__ == "__main__":
main()
| false | 8.823529 | [
"+import numpy as np",
"- A = [[int(i) for i in readline().split()] for _ in range(N)]",
"+ A = np.array(read().split(), dtype=np.int64).reshape(N, N)",
"+ INF = 10**15",
"- for i in range(N - 1):",
"- for j in range(i + 1, N):",
"- d = A[i][j]",
"- flag = True",
"- for k in range(N):",
"- if k == i or k == j:",
"- continue",
"- tmp = A[i][k] + A[k][j]",
"- if tmp < d:",
"- print((-1))",
"- exit()",
"- elif tmp == d:",
"- flag = False",
"- break",
"- if flag:",
"- ans += d",
"- print(ans)",
"+ for i in range(N):",
"+ B = A[i, :] + A",
"+ np.fill_diagonal(B, INF)",
"+ B[:, i] = INF",
"+ C = B.min(axis=1)",
"+ C[i] = 0",
"+ if (C < A[i, :]).sum() > 0:",
"+ print((-1))",
"+ exit()",
"+ else:",
"+ index = C > A[i, :]",
"+ ans += A[i, index].sum()",
"+ print((ans // 2))"
] | false | 0.037186 | 0.23871 | 0.155779 | [
"s625045990",
"s869556862"
] |
u427344224 | p03163 | python | s147797380 | s937659933 | 737 | 540 | 171,912 | 120,044 | Accepted | Accepted | 26.73 | N, W = list(map(int, input().split()))
items = [list(map(int, input().split())) for _ in range(N)]
dp = [[0 for _ in range(W+1)] for _ in range(N+1)]
for i in range(N):
for j in range(W+1):
if j - items[i][0] >= 0:
dp[i+1][j] = max(dp[i][j], dp[i][j - items[i][0]] + items[i][1])
else:
dp[i+1][j] = dp[i][j]
print((dp[N][W]))
| N, W = list(map(int, input().split()))
items = []
for _ in range(N):
items.append(tuple(map(int, input().split())))
dp = [[0] * (W + 1) for _ in range(N+1)]
for i in range(N):
for w in range(W + 1):
if w - items[i][0] >= 0:
dp[i+1][w] = max(dp[i][w], dp[i][w - items[i][0]] + items[i][1])
else:
dp[i+1][w] = dp[i][w]
print((dp[N][W]))
| 12 | 14 | 375 | 390 | N, W = list(map(int, input().split()))
items = [list(map(int, input().split())) for _ in range(N)]
dp = [[0 for _ in range(W + 1)] for _ in range(N + 1)]
for i in range(N):
for j in range(W + 1):
if j - items[i][0] >= 0:
dp[i + 1][j] = max(dp[i][j], dp[i][j - items[i][0]] + items[i][1])
else:
dp[i + 1][j] = dp[i][j]
print((dp[N][W]))
| N, W = list(map(int, input().split()))
items = []
for _ in range(N):
items.append(tuple(map(int, input().split())))
dp = [[0] * (W + 1) for _ in range(N + 1)]
for i in range(N):
for w in range(W + 1):
if w - items[i][0] >= 0:
dp[i + 1][w] = max(dp[i][w], dp[i][w - items[i][0]] + items[i][1])
else:
dp[i + 1][w] = dp[i][w]
print((dp[N][W]))
| false | 14.285714 | [
"-items = [list(map(int, input().split())) for _ in range(N)]",
"-dp = [[0 for _ in range(W + 1)] for _ in range(N + 1)]",
"+items = []",
"+for _ in range(N):",
"+ items.append(tuple(map(int, input().split())))",
"+dp = [[0] * (W + 1) for _ in range(N + 1)]",
"- for j in range(W + 1):",
"- if j - items[i][0] >= 0:",
"- dp[i + 1][j] = max(dp[i][j], dp[i][j - items[i][0]] + items[i][1])",
"+ for w in range(W + 1):",
"+ if w - items[i][0] >= 0:",
"+ dp[i + 1][w] = max(dp[i][w], dp[i][w - items[i][0]] + items[i][1])",
"- dp[i + 1][j] = dp[i][j]",
"+ dp[i + 1][w] = dp[i][w]"
] | false | 0.041658 | 0.041066 | 1.014437 | [
"s147797380",
"s937659933"
] |
u123756661 | p02952 | python | s426288579 | s848519294 | 168 | 73 | 38,384 | 68,324 | Accepted | Accepted | 56.55 | n=int(eval(input()))
if n==100000:
print((90909))
elif n<100:
print((min(9,n)))
elif n<1000:
print((9+(n-99)))
elif n<10000:
print((909))
else:
print((909+(n-9999))) | n=int(eval(input()))
ans=0
for i in range(1,n+1):
if len(str(i))%2: ans+=1
print(ans) | 11 | 5 | 179 | 87 | n = int(eval(input()))
if n == 100000:
print((90909))
elif n < 100:
print((min(9, n)))
elif n < 1000:
print((9 + (n - 99)))
elif n < 10000:
print((909))
else:
print((909 + (n - 9999)))
| n = int(eval(input()))
ans = 0
for i in range(1, n + 1):
if len(str(i)) % 2:
ans += 1
print(ans)
| false | 54.545455 | [
"-if n == 100000:",
"- print((90909))",
"-elif n < 100:",
"- print((min(9, n)))",
"-elif n < 1000:",
"- print((9 + (n - 99)))",
"-elif n < 10000:",
"- print((909))",
"-else:",
"- print((909 + (n - 9999)))",
"+ans = 0",
"+for i in range(1, n + 1):",
"+ if len(str(i)) % 2:",
"+ ans += 1",
"+print(ans)"
] | false | 0.037263 | 0.069226 | 0.538288 | [
"s426288579",
"s848519294"
] |
u753803401 | p02996 | python | s446121749 | s629839306 | 1,154 | 712 | 67,808 | 84,828 | Accepted | Accepted | 38.3 | n = int(eval(input()))
ab = sorted([list(map(int, input().split())) for _ in range(n)], key=lambda x: (x[1], x[0]))
tt = 0
for i in ab:
tt += i[0]
if tt > i[1]:
print("No")
exit()
print("Yes")
| def main():
import sys
input = sys.stdin.readline
n = int(input().rstrip('\n'))
ab = [list(map(int, input().rstrip('\n').split())) for _ in range(n)]
ab = sorted(ab, key=lambda x: x[1])
t = 0
for a, b in ab:
t += a
if t > b:
print("No")
exit()
print("Yes")
if __name__ == '__main__':
main()
| 9 | 17 | 219 | 385 | n = int(eval(input()))
ab = sorted(
[list(map(int, input().split())) for _ in range(n)], key=lambda x: (x[1], x[0])
)
tt = 0
for i in ab:
tt += i[0]
if tt > i[1]:
print("No")
exit()
print("Yes")
| def main():
import sys
input = sys.stdin.readline
n = int(input().rstrip("\n"))
ab = [list(map(int, input().rstrip("\n").split())) for _ in range(n)]
ab = sorted(ab, key=lambda x: x[1])
t = 0
for a, b in ab:
t += a
if t > b:
print("No")
exit()
print("Yes")
if __name__ == "__main__":
main()
| false | 47.058824 | [
"-n = int(eval(input()))",
"-ab = sorted(",
"- [list(map(int, input().split())) for _ in range(n)], key=lambda x: (x[1], x[0])",
"-)",
"-tt = 0",
"-for i in ab:",
"- tt += i[0]",
"- if tt > i[1]:",
"- print(\"No\")",
"- exit()",
"-print(\"Yes\")",
"+def main():",
"+ import sys",
"+",
"+ input = sys.stdin.readline",
"+ n = int(input().rstrip(\"\\n\"))",
"+ ab = [list(map(int, input().rstrip(\"\\n\").split())) for _ in range(n)]",
"+ ab = sorted(ab, key=lambda x: x[1])",
"+ t = 0",
"+ for a, b in ab:",
"+ t += a",
"+ if t > b:",
"+ print(\"No\")",
"+ exit()",
"+ print(\"Yes\")",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ main()"
] | false | 0.169433 | 0.1882 | 0.90028 | [
"s446121749",
"s629839306"
] |
u761320129 | p03563 | python | s471933732 | s055941766 | 19 | 17 | 3,316 | 2,940 | Accepted | Accepted | 10.53 | R,G = int(eval(input())), int(eval(input()))
d = G-R
print((G+d))
| R = int(eval(input()))
G = int(eval(input()))
print((G-R + G)) | 3 | 3 | 54 | 50 | R, G = int(eval(input())), int(eval(input()))
d = G - R
print((G + d))
| R = int(eval(input()))
G = int(eval(input()))
print((G - R + G))
| false | 0 | [
"-R, G = int(eval(input())), int(eval(input()))",
"-d = G - R",
"-print((G + d))",
"+R = int(eval(input()))",
"+G = int(eval(input()))",
"+print((G - R + G))"
] | false | 0.05541 | 0.048994 | 1.130958 | [
"s471933732",
"s055941766"
] |
u332906195 | p02629 | python | s343868563 | s192605850 | 31 | 28 | 8,964 | 9,136 | Accepted | Accepted | 9.68 | N, ans = int(eval(input())), ''
while N > 0:
N = N - 1
ans += chr(N % 26 + ord('a'))
N //= 26
print((ans[::-1]))
| N, ans = int(eval(input())), ''
while N > 0:
N -= 1
ans += chr(N % 26 + ord('a'))
N //= 26
print((ans[::-1]))
| 6 | 6 | 122 | 119 | N, ans = int(eval(input())), ""
while N > 0:
N = N - 1
ans += chr(N % 26 + ord("a"))
N //= 26
print((ans[::-1]))
| N, ans = int(eval(input())), ""
while N > 0:
N -= 1
ans += chr(N % 26 + ord("a"))
N //= 26
print((ans[::-1]))
| false | 0 | [
"- N = N - 1",
"+ N -= 1"
] | false | 0.048689 | 0.049416 | 0.985285 | [
"s343868563",
"s192605850"
] |
u426534722 | p02412 | python | s742178874 | s548653187 | 810 | 730 | 7,636 | 5,628 | Accepted | Accepted | 9.88 | import itertools
while(True):
n, x = [int(i) for i in input().split()]
if n == 0 and x == 0: break
cnt = 0
for li in itertools.combinations(list(range(1, n + 1)),3):
if sum(li) == x: cnt += 1
print(cnt) | from itertools import combinations
while True:
n, x = list(map(int, input().split()))
if n == x == 0:
break
cnt = 0
for li in combinations(list(range(1, n + 1)), 3):
if sum(li) == x:
cnt += 1
print(cnt)
| 8 | 11 | 231 | 250 | import itertools
while True:
n, x = [int(i) for i in input().split()]
if n == 0 and x == 0:
break
cnt = 0
for li in itertools.combinations(list(range(1, n + 1)), 3):
if sum(li) == x:
cnt += 1
print(cnt)
| from itertools import combinations
while True:
n, x = list(map(int, input().split()))
if n == x == 0:
break
cnt = 0
for li in combinations(list(range(1, n + 1)), 3):
if sum(li) == x:
cnt += 1
print(cnt)
| false | 27.272727 | [
"-import itertools",
"+from itertools import combinations",
"- n, x = [int(i) for i in input().split()]",
"- if n == 0 and x == 0:",
"+ n, x = list(map(int, input().split()))",
"+ if n == x == 0:",
"- for li in itertools.combinations(list(range(1, n + 1)), 3):",
"+ for li in combinations(list(range(1, n + 1)), 3):"
] | false | 0.036835 | 0.036219 | 1.017015 | [
"s742178874",
"s548653187"
] |
u332906195 | p02780 | python | s737247646 | s286007107 | 416 | 144 | 137,936 | 24,804 | Accepted | Accepted | 65.38 | N, K = list(map(int, input().split()))
P = list(map(int, input().split()))
P_sum = [0]
for p in P:
P_sum.append(P_sum[-1] + p)
max_sum, max_P = 0, None
for i in range(N - K + 1):
if max_sum < P_sum[i + K] - P_sum[i]:
max_sum = P_sum[i + K] - P_sum[i]
max_P = P[i:i + K]
print((sum([(p * (p + 1) // 2) / p for p in max_P])))
| N, K = list(map(int, input().split()))
P = list(map(int, input().split()))
P_sum = [0]
for p in P:
P_sum.append(P_sum[-1] + (p + 1) / 2)
print((max([P_sum[i + K] - P_sum[i] for i in range(N - K + 1)])))
| 13 | 7 | 354 | 206 | N, K = list(map(int, input().split()))
P = list(map(int, input().split()))
P_sum = [0]
for p in P:
P_sum.append(P_sum[-1] + p)
max_sum, max_P = 0, None
for i in range(N - K + 1):
if max_sum < P_sum[i + K] - P_sum[i]:
max_sum = P_sum[i + K] - P_sum[i]
max_P = P[i : i + K]
print((sum([(p * (p + 1) // 2) / p for p in max_P])))
| N, K = list(map(int, input().split()))
P = list(map(int, input().split()))
P_sum = [0]
for p in P:
P_sum.append(P_sum[-1] + (p + 1) / 2)
print((max([P_sum[i + K] - P_sum[i] for i in range(N - K + 1)])))
| false | 46.153846 | [
"- P_sum.append(P_sum[-1] + p)",
"-max_sum, max_P = 0, None",
"-for i in range(N - K + 1):",
"- if max_sum < P_sum[i + K] - P_sum[i]:",
"- max_sum = P_sum[i + K] - P_sum[i]",
"- max_P = P[i : i + K]",
"-print((sum([(p * (p + 1) // 2) / p for p in max_P])))",
"+ P_sum.append(P_sum[-1] + (p + 1) / 2)",
"+print((max([P_sum[i + K] - P_sum[i] for i in range(N - K + 1)])))"
] | false | 0.039273 | 0.039261 | 1.00029 | [
"s737247646",
"s286007107"
] |
u226155577 | p03552 | python | s382968736 | s723229185 | 1,149 | 17 | 47,580 | 3,188 | Accepted | Accepted | 98.52 | N, Z, W = list(map(int, input().split()))
*A, = list(map(int, input().split()))
import sys
sys.setrecursionlimit(10**6)
memo = {}
def dfs(i, turn):
if (i, turn) in memo:
return memo[i, turn]
if turn == 0:
# X
if i == 0:
res = abs(W - A[-1])
else:
res = abs(A[i-1] - A[-1])
for j in range(i+1, N):
res = max(res, dfs(j, 1))
else:
# Y
if i == 0:
res = abs(Z - A[-1])
else:
res = abs(A[i-1] - A[-1])
for j in range(i+1, N):
res = min(res, dfs(j, 0))
memo[i, turn] = res
return res
print((dfs(0, 0)))
| N, Z, W = list(map(int, input().split()))
*A, = list(map(int, input().split()))
if N == 1:
print((abs(A[0] - W)))
else:
print((max(abs(A[-1] - W), abs(A[-2] - A[-1]))))
| 29 | 6 | 677 | 166 | N, Z, W = list(map(int, input().split()))
(*A,) = list(map(int, input().split()))
import sys
sys.setrecursionlimit(10**6)
memo = {}
def dfs(i, turn):
if (i, turn) in memo:
return memo[i, turn]
if turn == 0:
# X
if i == 0:
res = abs(W - A[-1])
else:
res = abs(A[i - 1] - A[-1])
for j in range(i + 1, N):
res = max(res, dfs(j, 1))
else:
# Y
if i == 0:
res = abs(Z - A[-1])
else:
res = abs(A[i - 1] - A[-1])
for j in range(i + 1, N):
res = min(res, dfs(j, 0))
memo[i, turn] = res
return res
print((dfs(0, 0)))
| N, Z, W = list(map(int, input().split()))
(*A,) = list(map(int, input().split()))
if N == 1:
print((abs(A[0] - W)))
else:
print((max(abs(A[-1] - W), abs(A[-2] - A[-1]))))
| false | 79.310345 | [
"-import sys",
"-",
"-sys.setrecursionlimit(10**6)",
"-memo = {}",
"-",
"-",
"-def dfs(i, turn):",
"- if (i, turn) in memo:",
"- return memo[i, turn]",
"- if turn == 0:",
"- # X",
"- if i == 0:",
"- res = abs(W - A[-1])",
"- else:",
"- res = abs(A[i - 1] - A[-1])",
"- for j in range(i + 1, N):",
"- res = max(res, dfs(j, 1))",
"- else:",
"- # Y",
"- if i == 0:",
"- res = abs(Z - A[-1])",
"- else:",
"- res = abs(A[i - 1] - A[-1])",
"- for j in range(i + 1, N):",
"- res = min(res, dfs(j, 0))",
"- memo[i, turn] = res",
"- return res",
"-",
"-",
"-print((dfs(0, 0)))",
"+if N == 1:",
"+ print((abs(A[0] - W)))",
"+else:",
"+ print((max(abs(A[-1] - W), abs(A[-2] - A[-1]))))"
] | false | 0.050093 | 0.048909 | 1.024209 | [
"s382968736",
"s723229185"
] |
u254871849 | p03221 | python | s016667089 | s688473171 | 445 | 348 | 46,444 | 32,208 | Accepted | Accepted | 21.8 | import sys
from collections import defaultdict
def fill(s):
while len(s) < 6: s = '0' + s
return s
def create_id(p, o):
return fill(str(p)) + fill(str(o))
n, m, *py = map(int, sys.stdin.read().split())
py = zip(*[iter(py)] * 2)
def main():
db = defaultdict(list)
i = 0
for p, y in py:
db[p].append((y, i))
i += 1
res = [None] * m
for p in db:
db[p].sort()
for i in range(len(db[p])):
res[db[p][i][1]] = create_id(p, i + 1)
print(*res, sep='\n')
if __name__ == '__main__':
main()
| import sys
def fill(s): return '0' * (6 - len(s)) + s
def create_id(p, o): return fill(str(p)) + fill(str(o))
n, m, *py = map(int, sys.stdin.read().split())
pyi = sorted(zip(*[iter(py)] * 2 + [range(m)]))
def main():
res = [None] * m
prev = j = None
for p, y, i in pyi:
j = j + 1 if p == prev else 1
res[i] = create_id(p, j)
prev = p
print(*res, sep='\n')
if __name__ == '__main__':
main()
| 29 | 19 | 597 | 460 | import sys
from collections import defaultdict
def fill(s):
while len(s) < 6:
s = "0" + s
return s
def create_id(p, o):
return fill(str(p)) + fill(str(o))
n, m, *py = map(int, sys.stdin.read().split())
py = zip(*[iter(py)] * 2)
def main():
db = defaultdict(list)
i = 0
for p, y in py:
db[p].append((y, i))
i += 1
res = [None] * m
for p in db:
db[p].sort()
for i in range(len(db[p])):
res[db[p][i][1]] = create_id(p, i + 1)
print(*res, sep="\n")
if __name__ == "__main__":
main()
| import sys
def fill(s):
return "0" * (6 - len(s)) + s
def create_id(p, o):
return fill(str(p)) + fill(str(o))
n, m, *py = map(int, sys.stdin.read().split())
pyi = sorted(zip(*[iter(py)] * 2 + [range(m)]))
def main():
res = [None] * m
prev = j = None
for p, y, i in pyi:
j = j + 1 if p == prev else 1
res[i] = create_id(p, j)
prev = p
print(*res, sep="\n")
if __name__ == "__main__":
main()
| false | 34.482759 | [
"-from collections import defaultdict",
"- while len(s) < 6:",
"- s = \"0\" + s",
"- return s",
"+ return \"0\" * (6 - len(s)) + s",
"-py = zip(*[iter(py)] * 2)",
"+pyi = sorted(zip(*[iter(py)] * 2 + [range(m)]))",
"- db = defaultdict(list)",
"- i = 0",
"- for p, y in py:",
"- db[p].append((y, i))",
"- i += 1",
"- for p in db:",
"- db[p].sort()",
"- for i in range(len(db[p])):",
"- res[db[p][i][1]] = create_id(p, i + 1)",
"+ prev = j = None",
"+ for p, y, i in pyi:",
"+ j = j + 1 if p == prev else 1",
"+ res[i] = create_id(p, j)",
"+ prev = p"
] | false | 0.042175 | 0.12435 | 0.339163 | [
"s016667089",
"s688473171"
] |
u442636632 | p02676 | python | s818349852 | s232678503 | 30 | 27 | 9,128 | 9,156 | Accepted | Accepted | 10 | K = int(eval(input()))
S = eval(input())
def result(K: int, S: str) -> str:
s_len = len(S)
if s_len <= K:
return S
else:
answer = ''
i = 0
while i <= K-1:
answer += S[i]
i += 1
answer += '...'
return answer
print((result(K, S)))
| K = int(eval(input()))
S = eval(input())
def result(K: int, S: str) -> str:
if len(S) <= K:
return S
else:
answer = S[:K]
return answer + '...'
print((result(K, S)))
| 15 | 9 | 313 | 192 | K = int(eval(input()))
S = eval(input())
def result(K: int, S: str) -> str:
s_len = len(S)
if s_len <= K:
return S
else:
answer = ""
i = 0
while i <= K - 1:
answer += S[i]
i += 1
answer += "..."
return answer
print((result(K, S)))
| K = int(eval(input()))
S = eval(input())
def result(K: int, S: str) -> str:
if len(S) <= K:
return S
else:
answer = S[:K]
return answer + "..."
print((result(K, S)))
| false | 40 | [
"- s_len = len(S)",
"- if s_len <= K:",
"+ if len(S) <= K:",
"- answer = \"\"",
"- i = 0",
"- while i <= K - 1:",
"- answer += S[i]",
"- i += 1",
"- answer += \"...\"",
"- return answer",
"+ answer = S[:K]",
"+ return answer + \"...\""
] | false | 0.043222 | 0.035421 | 1.220234 | [
"s818349852",
"s232678503"
] |
u248364740 | p03037 | python | s571527788 | s063762380 | 221 | 196 | 16,716 | 9,200 | Accepted | Accepted | 11.31 | #!/usr/bin/env python3
# -*- coding: utf-8 -*-
N, M = list(map(int, input().split()))
L = []
R = []
for i in range(M):
l, r, = list(map(int, input().split()))
L.append(l)
R.append(r)
max_l = 0
min_r = N
for i in range(M):
if max_l < L[i]:
max_l = L[i]
if min_r > R[i]:
min_r = R[i]
if max_l > min_r:
print((0))
else:
print((min_r - max_l + 1))
| n, m = list(map(int, input().strip().split()))
max_left = 0
min_right = n
for _ in range(m):
l_tmp, r_tmp = list(map(int, input().strip().split()))
if max_left < l_tmp:
max_left = l_tmp
if r_tmp < min_right:
min_right = r_tmp
if min_right < max_left:
print((0))
else:
print((min_right - max_left + 1))
| 21 | 15 | 393 | 338 | #!/usr/bin/env python3
# -*- coding: utf-8 -*-
N, M = list(map(int, input().split()))
L = []
R = []
for i in range(M):
(
l,
r,
) = list(map(int, input().split()))
L.append(l)
R.append(r)
max_l = 0
min_r = N
for i in range(M):
if max_l < L[i]:
max_l = L[i]
if min_r > R[i]:
min_r = R[i]
if max_l > min_r:
print((0))
else:
print((min_r - max_l + 1))
| n, m = list(map(int, input().strip().split()))
max_left = 0
min_right = n
for _ in range(m):
l_tmp, r_tmp = list(map(int, input().strip().split()))
if max_left < l_tmp:
max_left = l_tmp
if r_tmp < min_right:
min_right = r_tmp
if min_right < max_left:
print((0))
else:
print((min_right - max_left + 1))
| false | 28.571429 | [
"-#!/usr/bin/env python3",
"-# -*- coding: utf-8 -*-",
"-N, M = list(map(int, input().split()))",
"-L = []",
"-R = []",
"-for i in range(M):",
"- (",
"- l,",
"- r,",
"- ) = list(map(int, input().split()))",
"- L.append(l)",
"- R.append(r)",
"-max_l = 0",
"-min_r = N",
"-for i in range(M):",
"- if max_l < L[i]:",
"- max_l = L[i]",
"- if min_r > R[i]:",
"- min_r = R[i]",
"-if max_l > min_r:",
"+n, m = list(map(int, input().strip().split()))",
"+max_left = 0",
"+min_right = n",
"+for _ in range(m):",
"+ l_tmp, r_tmp = list(map(int, input().strip().split()))",
"+ if max_left < l_tmp:",
"+ max_left = l_tmp",
"+ if r_tmp < min_right:",
"+ min_right = r_tmp",
"+if min_right < max_left:",
"- print((min_r - max_l + 1))",
"+ print((min_right - max_left + 1))"
] | false | 0.035556 | 0.034831 | 1.020804 | [
"s571527788",
"s063762380"
] |
u655663334 | p02624 | python | s712982183 | s764829153 | 1,961 | 531 | 339,304 | 339,360 | Accepted | Accepted | 72.92 | import numpy as np
N = int(eval(input()))
Xarray = np.arange(1, N+1)
Xans = ((N // Xarray) * (2 * Xarray + ((N // Xarray) - 1) * Xarray)) // 2
print((sum(Xans))) | import numpy as np
N = int(eval(input()))
Xarray = np.arange(1, N+1)
Xans = ((N // Xarray) * (2 * Xarray + ((N // Xarray) - 1) * Xarray)) // 2
print((np.sum(Xans))) | 8 | 8 | 163 | 169 | import numpy as np
N = int(eval(input()))
Xarray = np.arange(1, N + 1)
Xans = ((N // Xarray) * (2 * Xarray + ((N // Xarray) - 1) * Xarray)) // 2
print((sum(Xans)))
| import numpy as np
N = int(eval(input()))
Xarray = np.arange(1, N + 1)
Xans = ((N // Xarray) * (2 * Xarray + ((N // Xarray) - 1) * Xarray)) // 2
print((np.sum(Xans)))
| false | 0 | [
"-print((sum(Xans)))",
"+print((np.sum(Xans)))"
] | false | 0.584527 | 0.557322 | 1.048815 | [
"s712982183",
"s764829153"
] |
u887207211 | p03260 | python | s407889508 | s371757896 | 20 | 18 | 3,316 | 2,940 | Accepted | Accepted | 10 | A, B = list(map(int,input().split()))
if(A%2 == B%2 == 1):
print("Yes")
else:
print("No") | A, B = list(map(int,input().split()))
if((A*B)%2 == 1):
print("Yes")
else:
print("No") | 5 | 5 | 91 | 88 | A, B = list(map(int, input().split()))
if A % 2 == B % 2 == 1:
print("Yes")
else:
print("No")
| A, B = list(map(int, input().split()))
if (A * B) % 2 == 1:
print("Yes")
else:
print("No")
| false | 0 | [
"-if A % 2 == B % 2 == 1:",
"+if (A * B) % 2 == 1:"
] | false | 0.240542 | 0.092736 | 2.593818 | [
"s407889508",
"s371757896"
] |
u987164499 | p03327 | python | s167478663 | s064776913 | 306 | 17 | 66,540 | 2,940 | Accepted | Accepted | 94.44 | from sys import stdin
import fractions
n = int(stdin.readline().rstrip())
if n <1000:
print("ABC")
else:
print("ABD") | n = int(eval(input()))
if n < 1000:
print("ABC")
else:
print("ABD") | 10 | 5 | 137 | 73 | from sys import stdin
import fractions
n = int(stdin.readline().rstrip())
if n < 1000:
print("ABC")
else:
print("ABD")
| n = int(eval(input()))
if n < 1000:
print("ABC")
else:
print("ABD")
| false | 50 | [
"-from sys import stdin",
"-import fractions",
"-",
"-n = int(stdin.readline().rstrip())",
"+n = int(eval(input()))"
] | false | 0.072674 | 0.037204 | 1.953399 | [
"s167478663",
"s064776913"
] |
u368249389 | p02959 | python | s226303738 | s488190231 | 277 | 158 | 82,148 | 18,752 | Accepted | Accepted | 42.96 | # Problem C - City Savers
# input
N = int(eval(input()))
a_list = list(map(int, input().split()))
b_list = list(map(int, input().split()))
# initialization
max_monster = 0
# count
for i in range(N):
b = b_list[i]
if a_list[i]<=b:
max_monster += a_list[i]
b_list[i] -= a_list[i]
a_list[i] = 0
else:
max_monster += b
b_list[i] = 0
b = b_list[i]
if a_list[i+1]<=b:
max_monster += a_list[i+1]
a_list[i+1] = 0
else:
max_monster += b
a_list[i+1] -= b_list[i]
# output
print(max_monster)
| # Problem C - City Savers
# input
N = int(eval(input()))
a_nums = list(map(int, input().split()))
b_nums = list(map(int, input().split()))
# initialization
ans_monsters = 0
# count
for i in range(len(b_nums)):
# round 1
if b_nums[i]>=a_nums[i]:
ans_monsters += a_nums[i]
b_nums[i] -= a_nums[i]
else:
ans_monsters += b_nums[i]
b_nums[i] = 0
# round 2
if b_nums[i]>0:
if b_nums[i]>=a_nums[i+1]:
ans_monsters += a_nums[i+1]
a_nums[i+1] = 0
else:
ans_monsters += b_nums[i]
a_nums[i+1] -= b_nums[i]
# output
print(ans_monsters)
| 31 | 31 | 606 | 668 | # Problem C - City Savers
# input
N = int(eval(input()))
a_list = list(map(int, input().split()))
b_list = list(map(int, input().split()))
# initialization
max_monster = 0
# count
for i in range(N):
b = b_list[i]
if a_list[i] <= b:
max_monster += a_list[i]
b_list[i] -= a_list[i]
a_list[i] = 0
else:
max_monster += b
b_list[i] = 0
b = b_list[i]
if a_list[i + 1] <= b:
max_monster += a_list[i + 1]
a_list[i + 1] = 0
else:
max_monster += b
a_list[i + 1] -= b_list[i]
# output
print(max_monster)
| # Problem C - City Savers
# input
N = int(eval(input()))
a_nums = list(map(int, input().split()))
b_nums = list(map(int, input().split()))
# initialization
ans_monsters = 0
# count
for i in range(len(b_nums)):
# round 1
if b_nums[i] >= a_nums[i]:
ans_monsters += a_nums[i]
b_nums[i] -= a_nums[i]
else:
ans_monsters += b_nums[i]
b_nums[i] = 0
# round 2
if b_nums[i] > 0:
if b_nums[i] >= a_nums[i + 1]:
ans_monsters += a_nums[i + 1]
a_nums[i + 1] = 0
else:
ans_monsters += b_nums[i]
a_nums[i + 1] -= b_nums[i]
# output
print(ans_monsters)
| false | 0 | [
"-a_list = list(map(int, input().split()))",
"-b_list = list(map(int, input().split()))",
"+a_nums = list(map(int, input().split()))",
"+b_nums = list(map(int, input().split()))",
"-max_monster = 0",
"+ans_monsters = 0",
"-for i in range(N):",
"- b = b_list[i]",
"- if a_list[i] <= b:",
"- max_monster += a_list[i]",
"- b_list[i] -= a_list[i]",
"- a_list[i] = 0",
"+for i in range(len(b_nums)):",
"+ # round 1",
"+ if b_nums[i] >= a_nums[i]:",
"+ ans_monsters += a_nums[i]",
"+ b_nums[i] -= a_nums[i]",
"- max_monster += b",
"- b_list[i] = 0",
"- b = b_list[i]",
"- if a_list[i + 1] <= b:",
"- max_monster += a_list[i + 1]",
"- a_list[i + 1] = 0",
"- else:",
"- max_monster += b",
"- a_list[i + 1] -= b_list[i]",
"+ ans_monsters += b_nums[i]",
"+ b_nums[i] = 0",
"+ # round 2",
"+ if b_nums[i] > 0:",
"+ if b_nums[i] >= a_nums[i + 1]:",
"+ ans_monsters += a_nums[i + 1]",
"+ a_nums[i + 1] = 0",
"+ else:",
"+ ans_monsters += b_nums[i]",
"+ a_nums[i + 1] -= b_nums[i]",
"-print(max_monster)",
"+print(ans_monsters)"
] | false | 0.041099 | 0.106563 | 0.385679 | [
"s226303738",
"s488190231"
] |
u870576013 | p02640 | python | s689212394 | s201887122 | 23 | 21 | 9,160 | 9,120 | Accepted | Accepted | 8.7 | x, y = list(map(int, input().split()))
if y%2 == 0:
if x*2 <= y and x*4 >= y:
print('Yes')
exit()
print('No')
exit() | import sys
X, Y = list(map(int, input().split()))
a = 2 * X
if a == Y:
print('Yes')
sys.exit()
for i in range(X):
a = a + 2
if a == Y:
print('Yes')
sys.exit()
print('No') | 7 | 16 | 126 | 207 | x, y = list(map(int, input().split()))
if y % 2 == 0:
if x * 2 <= y and x * 4 >= y:
print("Yes")
exit()
print("No")
exit()
| import sys
X, Y = list(map(int, input().split()))
a = 2 * X
if a == Y:
print("Yes")
sys.exit()
for i in range(X):
a = a + 2
if a == Y:
print("Yes")
sys.exit()
print("No")
| false | 56.25 | [
"-x, y = list(map(int, input().split()))",
"-if y % 2 == 0:",
"- if x * 2 <= y and x * 4 >= y:",
"+import sys",
"+",
"+X, Y = list(map(int, input().split()))",
"+a = 2 * X",
"+if a == Y:",
"+ print(\"Yes\")",
"+ sys.exit()",
"+for i in range(X):",
"+ a = a + 2",
"+ if a == Y:",
"- exit()",
"+ sys.exit()",
"-exit()"
] | false | 0.035896 | 0.036922 | 0.972209 | [
"s689212394",
"s201887122"
] |
u644907318 | p03739 | python | s572409377 | s606278655 | 249 | 102 | 63,216 | 85,580 | Accepted | Accepted | 59.04 | n = int(eval(input()))
A = list(map(int,input().split()))
B = A[:]
for i in range(1,n):
B[i] += B[i-1]
C = B[:]
cnt1 = 0
cnt2 = 0
if B[0]<=0:
cnt1 += abs(1-B[0])
cnt2 += 1-B[0]
B[0] += cnt2
for i in range(1,n):
if i%2==0:
if B[i]+cnt2<=0:
cnt1 += abs(1-B[i]-cnt2)
cnt2 += 1-B[i]-cnt2
B[i] += cnt2
else:
if B[i]+cnt2>=0:
cnt1 += abs(-1-B[i]-cnt2)
cnt2 += -1-B[i]-cnt2
B[i] += cnt2
cnt3 = 0
cnt4 = 0
if C[0]>=0:
cnt3 += abs(-1-C[0])
cnt4 += -1-C[0]
C[0] += cnt4
for i in range(1,n):
if i%2==0:
if C[i]+cnt4>=0:
cnt3 += abs(-1-C[i]-cnt4)
cnt4 += -1-C[i]-cnt4
C[i] += cnt4
else:
if C[i]+cnt4<=0:
cnt3 += abs(1-C[i]-cnt4)
cnt4 += 1-C[i]-cnt4
C[i] += cnt4
print((min(cnt1,cnt3))) | n = int(eval(input()))
A = list(map(int,input().split()))
B = A[:]
cntp = 0
totp = 0
for i in range(n):
if i%2==0:
if B[i]>=1-totp:
totp += B[i]
else:
cntp += 1-totp-B[i]
totp = 1
else:
if B[i]<=-1-totp:
totp += B[i]
else:
cntp += B[i]+1+totp
totp = -1
cntm = 0
totm = 0
for i in range(n):
if i%2==0:
if B[i]<=-1-totm:
totm += B[i]
else:
cntm += B[i]+1+totm
totm = -1
else:
if B[i]>=1-totm:
totm += B[i]
else:
cntm += 1-totm-B[i]
totm = 1
print((min(cntp,cntm))) | 41 | 34 | 925 | 711 | n = int(eval(input()))
A = list(map(int, input().split()))
B = A[:]
for i in range(1, n):
B[i] += B[i - 1]
C = B[:]
cnt1 = 0
cnt2 = 0
if B[0] <= 0:
cnt1 += abs(1 - B[0])
cnt2 += 1 - B[0]
B[0] += cnt2
for i in range(1, n):
if i % 2 == 0:
if B[i] + cnt2 <= 0:
cnt1 += abs(1 - B[i] - cnt2)
cnt2 += 1 - B[i] - cnt2
B[i] += cnt2
else:
if B[i] + cnt2 >= 0:
cnt1 += abs(-1 - B[i] - cnt2)
cnt2 += -1 - B[i] - cnt2
B[i] += cnt2
cnt3 = 0
cnt4 = 0
if C[0] >= 0:
cnt3 += abs(-1 - C[0])
cnt4 += -1 - C[0]
C[0] += cnt4
for i in range(1, n):
if i % 2 == 0:
if C[i] + cnt4 >= 0:
cnt3 += abs(-1 - C[i] - cnt4)
cnt4 += -1 - C[i] - cnt4
C[i] += cnt4
else:
if C[i] + cnt4 <= 0:
cnt3 += abs(1 - C[i] - cnt4)
cnt4 += 1 - C[i] - cnt4
C[i] += cnt4
print((min(cnt1, cnt3)))
| n = int(eval(input()))
A = list(map(int, input().split()))
B = A[:]
cntp = 0
totp = 0
for i in range(n):
if i % 2 == 0:
if B[i] >= 1 - totp:
totp += B[i]
else:
cntp += 1 - totp - B[i]
totp = 1
else:
if B[i] <= -1 - totp:
totp += B[i]
else:
cntp += B[i] + 1 + totp
totp = -1
cntm = 0
totm = 0
for i in range(n):
if i % 2 == 0:
if B[i] <= -1 - totm:
totm += B[i]
else:
cntm += B[i] + 1 + totm
totm = -1
else:
if B[i] >= 1 - totm:
totm += B[i]
else:
cntm += 1 - totm - B[i]
totm = 1
print((min(cntp, cntm)))
| false | 17.073171 | [
"-for i in range(1, n):",
"- B[i] += B[i - 1]",
"-C = B[:]",
"-cnt1 = 0",
"-cnt2 = 0",
"-if B[0] <= 0:",
"- cnt1 += abs(1 - B[0])",
"- cnt2 += 1 - B[0]",
"- B[0] += cnt2",
"-for i in range(1, n):",
"+cntp = 0",
"+totp = 0",
"+for i in range(n):",
"- if B[i] + cnt2 <= 0:",
"- cnt1 += abs(1 - B[i] - cnt2)",
"- cnt2 += 1 - B[i] - cnt2",
"- B[i] += cnt2",
"+ if B[i] >= 1 - totp:",
"+ totp += B[i]",
"+ else:",
"+ cntp += 1 - totp - B[i]",
"+ totp = 1",
"- if B[i] + cnt2 >= 0:",
"- cnt1 += abs(-1 - B[i] - cnt2)",
"- cnt2 += -1 - B[i] - cnt2",
"- B[i] += cnt2",
"-cnt3 = 0",
"-cnt4 = 0",
"-if C[0] >= 0:",
"- cnt3 += abs(-1 - C[0])",
"- cnt4 += -1 - C[0]",
"- C[0] += cnt4",
"-for i in range(1, n):",
"+ if B[i] <= -1 - totp:",
"+ totp += B[i]",
"+ else:",
"+ cntp += B[i] + 1 + totp",
"+ totp = -1",
"+cntm = 0",
"+totm = 0",
"+for i in range(n):",
"- if C[i] + cnt4 >= 0:",
"- cnt3 += abs(-1 - C[i] - cnt4)",
"- cnt4 += -1 - C[i] - cnt4",
"- C[i] += cnt4",
"+ if B[i] <= -1 - totm:",
"+ totm += B[i]",
"+ else:",
"+ cntm += B[i] + 1 + totm",
"+ totm = -1",
"- if C[i] + cnt4 <= 0:",
"- cnt3 += abs(1 - C[i] - cnt4)",
"- cnt4 += 1 - C[i] - cnt4",
"- C[i] += cnt4",
"-print((min(cnt1, cnt3)))",
"+ if B[i] >= 1 - totm:",
"+ totm += B[i]",
"+ else:",
"+ cntm += 1 - totm - B[i]",
"+ totm = 1",
"+print((min(cntp, cntm)))"
] | false | 0.112959 | 0.047963 | 2.355146 | [
"s572409377",
"s606278655"
] |
u812576525 | p03208 | python | s066710761 | s613195384 | 296 | 248 | 16,560 | 8,512 | Accepted | Accepted | 16.22 | from collections import Counter
N, K = list(map(int,input().split()))
H = []
for i in range(N):
H.append(int(eval(input())))
H = sorted(H,reverse = False)
C = Counter(H)
CH = list(C.values())
cnt = 0
for i in range(len(CH)):
if CH[i] >= K:
cnt += 1
break
ans = 999999999999999
for i in range(N-K+1):
ans = min(ans,H[K-1+i] - H[i])
if cnt != 0:
print('0')
else:
print(ans) | from collections import Counter
N, K = list(map(int,input().split()))
H = [int(eval(input())) for _ in range(N)]
H = sorted(H,reverse = False)
ans = 999999999999999
for i in range(N-K+1):
ans =min(ans , H[K-1+i] - H[i])
print(ans) | 23 | 10 | 428 | 239 | from collections import Counter
N, K = list(map(int, input().split()))
H = []
for i in range(N):
H.append(int(eval(input())))
H = sorted(H, reverse=False)
C = Counter(H)
CH = list(C.values())
cnt = 0
for i in range(len(CH)):
if CH[i] >= K:
cnt += 1
break
ans = 999999999999999
for i in range(N - K + 1):
ans = min(ans, H[K - 1 + i] - H[i])
if cnt != 0:
print("0")
else:
print(ans)
| from collections import Counter
N, K = list(map(int, input().split()))
H = [int(eval(input())) for _ in range(N)]
H = sorted(H, reverse=False)
ans = 999999999999999
for i in range(N - K + 1):
ans = min(ans, H[K - 1 + i] - H[i])
print(ans)
| false | 56.521739 | [
"-H = []",
"-for i in range(N):",
"- H.append(int(eval(input())))",
"+H = [int(eval(input())) for _ in range(N)]",
"-C = Counter(H)",
"-CH = list(C.values())",
"-cnt = 0",
"-for i in range(len(CH)):",
"- if CH[i] >= K:",
"- cnt += 1",
"- break",
"-if cnt != 0:",
"- print(\"0\")",
"-else:",
"- print(ans)",
"+print(ans)"
] | false | 0.036318 | 0.041599 | 0.873044 | [
"s066710761",
"s613195384"
] |
u631277801 | p03222 | python | s319230295 | s401914785 | 36 | 21 | 3,064 | 3,064 | Accepted | Accepted | 41.67 | import sys
stdin = sys.stdin
sys.setrecursionlimit(10**5)
def li(): return list(map(int, stdin.readline().split()))
def li_(): return [int(x)-1 for x in stdin.readline().split()]
def lf(): return list(map(float, stdin.readline().split()))
def ls(): return stdin.readline().split()
def ns(): return stdin.readline().rstrip()
def lc(): return list(ns())
def ni(): return int(stdin.readline())
def nf(): return float(stdin.readline())
h,w,k = li()
MOD = 10**9+7
cnt = [[0 for _ in range(w)] for _ in range(h+1)]
cnt[0][0] = 1
nex_list = []
for i in range(1<<(w-1)):
if not "11" in bin(i)[2:]:
nex_list.append(i)
for hi in range(1,h+1):
for bit in nex_list:
changed = [0]*w
for i, b in enumerate(bin(bit)[2:].zfill(w-1)):
if b == "1":
cnt[hi][i] += cnt[hi-1][i+1]
cnt[hi][i+1] += cnt[hi-1][i]
changed[i] = 1
changed[i+1] = 1
for j,c in enumerate(changed):
if c == 0:
cnt[hi][j] += cnt[hi-1][j]
for wj in range(w):
cnt[hi][wj] %= MOD
print((cnt[h][k-1]))
| import sys
stdin = sys.stdin
sys.setrecursionlimit(10 ** 7)
def li(): return list(map(int, stdin.readline().split()))
def li_(): return [int(x) - 1 for x in stdin.readline().split()]
def lf(): return list(map(float, stdin.readline().split()))
def ls(): return stdin.readline().split()
def ns(): return stdin.readline().rstrip()
def lc(): return list(ns())
def ni(): return int(stdin.readline())
def nf(): return float(stdin.readline())
h,w,k = li()
k -= 1
MOD = 10**9 + 7
# 遷移行列
if w > 1:
matrix = [[0]*w for _ in range(w)]
for num in range(1 << (w-1)):
if "11" in bin(num):
continue
ex = False
for i, bit in enumerate(bin(num)[2:].zfill(w-1)):
if bit == "1":
ex = True
matrix[i][i+1] += 1
matrix[i+1][i] += 1
elif ex:
ex = False
else:
matrix[i][i] += 1
if not ex:
matrix[w-1][w-1] += 1
# 適用
dp = [1] + [0]*(w-1)
for hi in range(h):
nex = [0]*w
for wj in range(w):
for wk in range(w):
nex[wj] += matrix[wj][wk] * dp[wk]
nex[wj] %= MOD
dp = nex
print((dp[k]))
else:
print((1)) | 45 | 56 | 1,203 | 1,299 | import sys
stdin = sys.stdin
sys.setrecursionlimit(10**5)
def li():
return list(map(int, stdin.readline().split()))
def li_():
return [int(x) - 1 for x in stdin.readline().split()]
def lf():
return list(map(float, stdin.readline().split()))
def ls():
return stdin.readline().split()
def ns():
return stdin.readline().rstrip()
def lc():
return list(ns())
def ni():
return int(stdin.readline())
def nf():
return float(stdin.readline())
h, w, k = li()
MOD = 10**9 + 7
cnt = [[0 for _ in range(w)] for _ in range(h + 1)]
cnt[0][0] = 1
nex_list = []
for i in range(1 << (w - 1)):
if not "11" in bin(i)[2:]:
nex_list.append(i)
for hi in range(1, h + 1):
for bit in nex_list:
changed = [0] * w
for i, b in enumerate(bin(bit)[2:].zfill(w - 1)):
if b == "1":
cnt[hi][i] += cnt[hi - 1][i + 1]
cnt[hi][i + 1] += cnt[hi - 1][i]
changed[i] = 1
changed[i + 1] = 1
for j, c in enumerate(changed):
if c == 0:
cnt[hi][j] += cnt[hi - 1][j]
for wj in range(w):
cnt[hi][wj] %= MOD
print((cnt[h][k - 1]))
| import sys
stdin = sys.stdin
sys.setrecursionlimit(10**7)
def li():
return list(map(int, stdin.readline().split()))
def li_():
return [int(x) - 1 for x in stdin.readline().split()]
def lf():
return list(map(float, stdin.readline().split()))
def ls():
return stdin.readline().split()
def ns():
return stdin.readline().rstrip()
def lc():
return list(ns())
def ni():
return int(stdin.readline())
def nf():
return float(stdin.readline())
h, w, k = li()
k -= 1
MOD = 10**9 + 7
# 遷移行列
if w > 1:
matrix = [[0] * w for _ in range(w)]
for num in range(1 << (w - 1)):
if "11" in bin(num):
continue
ex = False
for i, bit in enumerate(bin(num)[2:].zfill(w - 1)):
if bit == "1":
ex = True
matrix[i][i + 1] += 1
matrix[i + 1][i] += 1
elif ex:
ex = False
else:
matrix[i][i] += 1
if not ex:
matrix[w - 1][w - 1] += 1
# 適用
dp = [1] + [0] * (w - 1)
for hi in range(h):
nex = [0] * w
for wj in range(w):
for wk in range(w):
nex[wj] += matrix[wj][wk] * dp[wk]
nex[wj] %= MOD
dp = nex
print((dp[k]))
else:
print((1))
| false | 19.642857 | [
"-sys.setrecursionlimit(10**5)",
"+sys.setrecursionlimit(10**7)",
"+k -= 1",
"-cnt = [[0 for _ in range(w)] for _ in range(h + 1)]",
"-cnt[0][0] = 1",
"-nex_list = []",
"-for i in range(1 << (w - 1)):",
"- if not \"11\" in bin(i)[2:]:",
"- nex_list.append(i)",
"-for hi in range(1, h + 1):",
"- for bit in nex_list:",
"- changed = [0] * w",
"- for i, b in enumerate(bin(bit)[2:].zfill(w - 1)):",
"- if b == \"1\":",
"- cnt[hi][i] += cnt[hi - 1][i + 1]",
"- cnt[hi][i + 1] += cnt[hi - 1][i]",
"- changed[i] = 1",
"- changed[i + 1] = 1",
"- for j, c in enumerate(changed):",
"- if c == 0:",
"- cnt[hi][j] += cnt[hi - 1][j]",
"- for wj in range(w):",
"- cnt[hi][wj] %= MOD",
"-print((cnt[h][k - 1]))",
"+# 遷移行列",
"+if w > 1:",
"+ matrix = [[0] * w for _ in range(w)]",
"+ for num in range(1 << (w - 1)):",
"+ if \"11\" in bin(num):",
"+ continue",
"+ ex = False",
"+ for i, bit in enumerate(bin(num)[2:].zfill(w - 1)):",
"+ if bit == \"1\":",
"+ ex = True",
"+ matrix[i][i + 1] += 1",
"+ matrix[i + 1][i] += 1",
"+ elif ex:",
"+ ex = False",
"+ else:",
"+ matrix[i][i] += 1",
"+ if not ex:",
"+ matrix[w - 1][w - 1] += 1",
"+ # 適用",
"+ dp = [1] + [0] * (w - 1)",
"+ for hi in range(h):",
"+ nex = [0] * w",
"+ for wj in range(w):",
"+ for wk in range(w):",
"+ nex[wj] += matrix[wj][wk] * dp[wk]",
"+ nex[wj] %= MOD",
"+ dp = nex",
"+ print((dp[k]))",
"+else:",
"+ print((1))"
] | false | 0.075959 | 0.097959 | 0.775418 | [
"s319230295",
"s401914785"
] |
u832039789 | p03219 | python | s610982074 | s745720594 | 20 | 17 | 3,316 | 2,940 | Accepted | Accepted | 15 | x,y = list(map(int,input().split()))
print((x+y//2))
| a,b = list(map(int,input().split()))
print((a+b//2))
| 2 | 2 | 46 | 46 | x, y = list(map(int, input().split()))
print((x + y // 2))
| a, b = list(map(int, input().split()))
print((a + b // 2))
| false | 0 | [
"-x, y = list(map(int, input().split()))",
"-print((x + y // 2))",
"+a, b = list(map(int, input().split()))",
"+print((a + b // 2))"
] | false | 0.066263 | 0.066809 | 0.991834 | [
"s610982074",
"s745720594"
] |
u814986259 | p03450 | python | s419744644 | s448528901 | 2,000 | 1,731 | 40,052 | 9,000 | Accepted | Accepted | 13.45 | N, M = list(map(int, input().split()))
LRD = [tuple(map(int, input().split())) for i in range(M)]
class unionFind:
parent = []
def __init__(self, N):
self.parent = [i for i in range(N)]
self.weight = [0]*N
def root(self, x):
if self.parent[x] == x:
return(x)
else:
p = self.root(self.parent[x])
self.weight[x] += self.weight[self.parent[x]]
self.parent[x] = p
return(self.parent[x])
def same(self, x, y):
x, y = x-1, y-1
return(self.root(x) == self.root(y))
def unite(self, x, y, w):
w -= self.getWeight(x)
w += self.getWeight(y)
x, y = x-1, y-1
x = self.root(x)
y = self.root(y)
if x == y:
return
else:
self.parent[x] = y
self.weight[x] = self.weight[y]+w
return
def getWeight(self, x):
x -= 1
self.root(x)
return(self.weight[x])
G = unionFind(N)
flag = True
for l, r, d in LRD:
if G.same(l, r) == False:
G.unite(l, r, d)
else:
if G.getWeight(l) - G.getWeight(r) == d:
continue
else:
flag = False
break
if flag:
print("Yes")
else:
print("No")
| class unionFind:
parent = []
def __init__(self, N):
self.parent = [i for i in range(N)]
self.weight = [0]*N
def root(self, x):
if self.parent[x] == x:
return(x)
else:
p = self.root(self.parent[x])
self.weight[x] += self.weight[self.parent[x]]
self.parent[x] = p
return(self.parent[x])
def same(self, x, y):
x, y = x-1, y-1
return(self.root(x) == self.root(y))
def unite(self, x, y, w):
w -= self.getWeight(x)
w += self.getWeight(y)
x, y = x-1, y-1
x = self.root(x)
y = self.root(y)
if x == y:
return
else:
self.parent[x] = y
self.weight[x] = self.weight[y]+w
return
def getWeight(self, x):
x -= 1
self.root(x)
return(self.weight[x])
def main():
import sys
input = sys.stdin.readline
N, M = list(map(int, input().split()))
G = unionFind(N)
for i in range(M):
L, R, D = list(map(int, input().split()))
if G.same(L, R):
x = G.getWeight(L)
y = G.getWeight(R)
if x == y + D:
continue
else:
print("No")
exit(0)
else:
G.unite(L, R, D)
print("Yes")
main()
| 60 | 61 | 1,344 | 1,422 | N, M = list(map(int, input().split()))
LRD = [tuple(map(int, input().split())) for i in range(M)]
class unionFind:
parent = []
def __init__(self, N):
self.parent = [i for i in range(N)]
self.weight = [0] * N
def root(self, x):
if self.parent[x] == x:
return x
else:
p = self.root(self.parent[x])
self.weight[x] += self.weight[self.parent[x]]
self.parent[x] = p
return self.parent[x]
def same(self, x, y):
x, y = x - 1, y - 1
return self.root(x) == self.root(y)
def unite(self, x, y, w):
w -= self.getWeight(x)
w += self.getWeight(y)
x, y = x - 1, y - 1
x = self.root(x)
y = self.root(y)
if x == y:
return
else:
self.parent[x] = y
self.weight[x] = self.weight[y] + w
return
def getWeight(self, x):
x -= 1
self.root(x)
return self.weight[x]
G = unionFind(N)
flag = True
for l, r, d in LRD:
if G.same(l, r) == False:
G.unite(l, r, d)
else:
if G.getWeight(l) - G.getWeight(r) == d:
continue
else:
flag = False
break
if flag:
print("Yes")
else:
print("No")
| class unionFind:
parent = []
def __init__(self, N):
self.parent = [i for i in range(N)]
self.weight = [0] * N
def root(self, x):
if self.parent[x] == x:
return x
else:
p = self.root(self.parent[x])
self.weight[x] += self.weight[self.parent[x]]
self.parent[x] = p
return self.parent[x]
def same(self, x, y):
x, y = x - 1, y - 1
return self.root(x) == self.root(y)
def unite(self, x, y, w):
w -= self.getWeight(x)
w += self.getWeight(y)
x, y = x - 1, y - 1
x = self.root(x)
y = self.root(y)
if x == y:
return
else:
self.parent[x] = y
self.weight[x] = self.weight[y] + w
return
def getWeight(self, x):
x -= 1
self.root(x)
return self.weight[x]
def main():
import sys
input = sys.stdin.readline
N, M = list(map(int, input().split()))
G = unionFind(N)
for i in range(M):
L, R, D = list(map(int, input().split()))
if G.same(L, R):
x = G.getWeight(L)
y = G.getWeight(R)
if x == y + D:
continue
else:
print("No")
exit(0)
else:
G.unite(L, R, D)
print("Yes")
main()
| false | 1.639344 | [
"-N, M = list(map(int, input().split()))",
"-LRD = [tuple(map(int, input().split())) for i in range(M)]",
"-",
"-",
"-G = unionFind(N)",
"-flag = True",
"-for l, r, d in LRD:",
"- if G.same(l, r) == False:",
"- G.unite(l, r, d)",
"- else:",
"- if G.getWeight(l) - G.getWeight(r) == d:",
"- continue",
"+def main():",
"+ import sys",
"+",
"+ input = sys.stdin.readline",
"+ N, M = list(map(int, input().split()))",
"+ G = unionFind(N)",
"+ for i in range(M):",
"+ L, R, D = list(map(int, input().split()))",
"+ if G.same(L, R):",
"+ x = G.getWeight(L)",
"+ y = G.getWeight(R)",
"+ if x == y + D:",
"+ continue",
"+ else:",
"+ print(\"No\")",
"+ exit(0)",
"- flag = False",
"- break",
"-if flag:",
"+ G.unite(L, R, D)",
"-else:",
"- print(\"No\")",
"+",
"+",
"+main()"
] | false | 0.117952 | 0.045131 | 2.61356 | [
"s419744644",
"s448528901"
] |
u440161695 | p04030 | python | s844445650 | s512864100 | 21 | 17 | 3,316 | 2,940 | Accepted | Accepted | 19.05 | from collections import deque
s=deque(eval(input()))
A=deque()
for i in range(len(s)):
a=s.popleft()
if a=="B":
if len(A)>0:
A.pop()
else:
A.append(a)
print(("".join(A))) | t=""
for x in eval(input()):
if x=="B":
t=t[:-1]
else:t+=x
print(t) | 11 | 6 | 192 | 80 | from collections import deque
s = deque(eval(input()))
A = deque()
for i in range(len(s)):
a = s.popleft()
if a == "B":
if len(A) > 0:
A.pop()
else:
A.append(a)
print(("".join(A)))
| t = ""
for x in eval(input()):
if x == "B":
t = t[:-1]
else:
t += x
print(t)
| false | 45.454545 | [
"-from collections import deque",
"-",
"-s = deque(eval(input()))",
"-A = deque()",
"-for i in range(len(s)):",
"- a = s.popleft()",
"- if a == \"B\":",
"- if len(A) > 0:",
"- A.pop()",
"+t = \"\"",
"+for x in eval(input()):",
"+ if x == \"B\":",
"+ t = t[:-1]",
"- A.append(a)",
"-print((\"\".join(A)))",
"+ t += x",
"+print(t)"
] | false | 0.046277 | 0.047107 | 0.982389 | [
"s844445650",
"s512864100"
] |
u064434060 | p02954 | python | s253556827 | s478528586 | 242 | 196 | 49,036 | 48,624 | Accepted | Accepted | 19.01 | S = str(eval(input()))
n = int(len(S))
ans = [str(0) for i in range(n)]
cntLo = 0
cntRo = 0
cntLe = 0
cntRe = 0
for i in range(n-1):
if S[i] == "R" and S[i+1] == "L":
j = 1
k = 1
while i-j >= 0 and S[i-j] == "R":
if j % 2 == 0:
cntRe += 1
else:
cntRo += 1
j += 1
while i+1+k <= n-1 and S[i+1+k] == "L":
if k % 2 == 0:
cntLe += 1
else:
cntLo += 1
k += 1
ans[i] = str(cntRe + cntLo+1)
ans[i+1] = str(cntRo + cntLe+1)
cntLo = 0
cntRo = 0
cntLe = 0
cntRe = 0
print((" ".join(ans))) |
s=str(eval(input()))
res=[0]*len(s)
nr=0
nl=0
for i in range(len(s)):
if s[i]=="L":
nl+=1
if i==len(s)-1:
res[i-nl+1]+=(nl+1)//2
res[i-nl]+=nl//2
if nr!=0:
res[i]+=nr//2
res[i-1]+=(nr+1)//2
nr=0
elif s[i]=="R":
nr+=1
if nl!=0:
res[i-nl]+=(nl+1)//2
res[i-nl-1]+=nl//2
nl=0
res=[str(x) for x in res]
print((" ".join(res))) | 30 | 26 | 718 | 413 | S = str(eval(input()))
n = int(len(S))
ans = [str(0) for i in range(n)]
cntLo = 0
cntRo = 0
cntLe = 0
cntRe = 0
for i in range(n - 1):
if S[i] == "R" and S[i + 1] == "L":
j = 1
k = 1
while i - j >= 0 and S[i - j] == "R":
if j % 2 == 0:
cntRe += 1
else:
cntRo += 1
j += 1
while i + 1 + k <= n - 1 and S[i + 1 + k] == "L":
if k % 2 == 0:
cntLe += 1
else:
cntLo += 1
k += 1
ans[i] = str(cntRe + cntLo + 1)
ans[i + 1] = str(cntRo + cntLe + 1)
cntLo = 0
cntRo = 0
cntLe = 0
cntRe = 0
print((" ".join(ans)))
| s = str(eval(input()))
res = [0] * len(s)
nr = 0
nl = 0
for i in range(len(s)):
if s[i] == "L":
nl += 1
if i == len(s) - 1:
res[i - nl + 1] += (nl + 1) // 2
res[i - nl] += nl // 2
if nr != 0:
res[i] += nr // 2
res[i - 1] += (nr + 1) // 2
nr = 0
elif s[i] == "R":
nr += 1
if nl != 0:
res[i - nl] += (nl + 1) // 2
res[i - nl - 1] += nl // 2
nl = 0
res = [str(x) for x in res]
print((" ".join(res)))
| false | 13.333333 | [
"-S = str(eval(input()))",
"-n = int(len(S))",
"-ans = [str(0) for i in range(n)]",
"-cntLo = 0",
"-cntRo = 0",
"-cntLe = 0",
"-cntRe = 0",
"-for i in range(n - 1):",
"- if S[i] == \"R\" and S[i + 1] == \"L\":",
"- j = 1",
"- k = 1",
"- while i - j >= 0 and S[i - j] == \"R\":",
"- if j % 2 == 0:",
"- cntRe += 1",
"- else:",
"- cntRo += 1",
"- j += 1",
"- while i + 1 + k <= n - 1 and S[i + 1 + k] == \"L\":",
"- if k % 2 == 0:",
"- cntLe += 1",
"- else:",
"- cntLo += 1",
"- k += 1",
"- ans[i] = str(cntRe + cntLo + 1)",
"- ans[i + 1] = str(cntRo + cntLe + 1)",
"- cntLo = 0",
"- cntRo = 0",
"- cntLe = 0",
"- cntRe = 0",
"-print((\" \".join(ans)))",
"+s = str(eval(input()))",
"+res = [0] * len(s)",
"+nr = 0",
"+nl = 0",
"+for i in range(len(s)):",
"+ if s[i] == \"L\":",
"+ nl += 1",
"+ if i == len(s) - 1:",
"+ res[i - nl + 1] += (nl + 1) // 2",
"+ res[i - nl] += nl // 2",
"+ if nr != 0:",
"+ res[i] += nr // 2",
"+ res[i - 1] += (nr + 1) // 2",
"+ nr = 0",
"+ elif s[i] == \"R\":",
"+ nr += 1",
"+ if nl != 0:",
"+ res[i - nl] += (nl + 1) // 2",
"+ res[i - nl - 1] += nl // 2",
"+ nl = 0",
"+res = [str(x) for x in res]",
"+print((\" \".join(res)))"
] | false | 0.079782 | 0.071347 | 1.118215 | [
"s253556827",
"s478528586"
] |
u057964173 | p03147 | python | s858859373 | s547395479 | 179 | 165 | 38,256 | 38,384 | Accepted | Accepted | 7.82 | import sys
def input(): return sys.stdin.readline().strip()
def resolve():
n=int(eval(input()))
l=list(map(int,input().split()))
l=[0]+l
ans=0
for i in range(len(l)-1):
ans+=max(l[i+1]-l[i],0)
print(ans)
resolve() | import sys
def input(): return sys.stdin.readline().strip()
def resolve():
n=int(eval(input()))
l=list(map(int,input().split()))
ans=l[0]
# 数列の値が増えてたらその分を追加で足す必要がある
# 減ってたら前の花を育ててる途中で水やり完了してる
for i in range(len(l)-1):
ans+=max(l[i+1]-l[i],0)
print(ans)
resolve() | 12 | 13 | 251 | 305 | import sys
def input():
return sys.stdin.readline().strip()
def resolve():
n = int(eval(input()))
l = list(map(int, input().split()))
l = [0] + l
ans = 0
for i in range(len(l) - 1):
ans += max(l[i + 1] - l[i], 0)
print(ans)
resolve()
| import sys
def input():
return sys.stdin.readline().strip()
def resolve():
n = int(eval(input()))
l = list(map(int, input().split()))
ans = l[0]
# 数列の値が増えてたらその分を追加で足す必要がある
# 減ってたら前の花を育ててる途中で水やり完了してる
for i in range(len(l) - 1):
ans += max(l[i + 1] - l[i], 0)
print(ans)
resolve()
| false | 7.692308 | [
"- l = [0] + l",
"- ans = 0",
"+ ans = l[0]",
"+ # 数列の値が増えてたらその分を追加で足す必要がある",
"+ # 減ってたら前の花を育ててる途中で水やり完了してる"
] | false | 0.125187 | 0.046197 | 2.709815 | [
"s858859373",
"s547395479"
] |
u358254559 | p03164 | python | s073588147 | s429813445 | 1,966 | 588 | 320,916 | 173,052 | Accepted | Accepted | 70.09 | n,w = list(map(int, input().split()))
wv = []
vsum=0
for _ in range(n):
tmp = list(map(int,input().split()))
wv.append(tmp)
vsum += tmp[1]
dp = [[float("inf") for i in range(vsum+1)] for j in range(n+1)]
dp[0][0]=0
for i in range(1,n+1):
now_w,now_v =wv[i-1]
for v in range(vsum+1):
dp[i][v] = dp[i-1][v]
if v - now_v >= 0:
dp[i][v] = min(dp[i][v],dp[i-1][v-now_v] + now_w)
ans=0
for val in range(len(dp[-1])):
if dp[-1][val] <= w:
ans=val
print(ans) | n,w = list(map(int, input().split()))
wv = []
vsum=0
for _ in range(n):
tmp = list(map(int,input().split()))
wv.append(tmp)
vsum += tmp[1]
INF = 1 << 30
dp = [[INF for i in range(vsum+1)] for j in range(n+1)]
dp[0][0]=0
for i in range(1,n+1):
now_w,now_v =wv[i-1]
for v in range(vsum+1):
dp[i][v] = dp[i-1][v]
if v - now_v >= 0:
dp[i][v] = min(dp[i][v],dp[i-1][v-now_v] + now_w)
ans=0
for val in range(len(dp[-1])):
if dp[-1][val] <= w:
ans=val
print(ans) | 23 | 25 | 529 | 537 | n, w = list(map(int, input().split()))
wv = []
vsum = 0
for _ in range(n):
tmp = list(map(int, input().split()))
wv.append(tmp)
vsum += tmp[1]
dp = [[float("inf") for i in range(vsum + 1)] for j in range(n + 1)]
dp[0][0] = 0
for i in range(1, n + 1):
now_w, now_v = wv[i - 1]
for v in range(vsum + 1):
dp[i][v] = dp[i - 1][v]
if v - now_v >= 0:
dp[i][v] = min(dp[i][v], dp[i - 1][v - now_v] + now_w)
ans = 0
for val in range(len(dp[-1])):
if dp[-1][val] <= w:
ans = val
print(ans)
| n, w = list(map(int, input().split()))
wv = []
vsum = 0
for _ in range(n):
tmp = list(map(int, input().split()))
wv.append(tmp)
vsum += tmp[1]
INF = 1 << 30
dp = [[INF for i in range(vsum + 1)] for j in range(n + 1)]
dp[0][0] = 0
for i in range(1, n + 1):
now_w, now_v = wv[i - 1]
for v in range(vsum + 1):
dp[i][v] = dp[i - 1][v]
if v - now_v >= 0:
dp[i][v] = min(dp[i][v], dp[i - 1][v - now_v] + now_w)
ans = 0
for val in range(len(dp[-1])):
if dp[-1][val] <= w:
ans = val
print(ans)
| false | 8 | [
"-dp = [[float(\"inf\") for i in range(vsum + 1)] for j in range(n + 1)]",
"+INF = 1 << 30",
"+dp = [[INF for i in range(vsum + 1)] for j in range(n + 1)]"
] | false | 0.036632 | 0.057845 | 0.633266 | [
"s073588147",
"s429813445"
] |
u391731808 | p03131 | python | s801104057 | s632457837 | 24 | 17 | 3,316 | 2,940 | Accepted | Accepted | 29.17 | K,A,B = list(map(int,input().split()))
if B-A<=2 or K<A:print((K+1))
else:print((((K-A+1)//2)*(B-A) + A + 1 - (K-A)%2)) | K,A,B = list(map(int,input().split()))
if B<=A+1 or K<=A: ans = K+1
else: ans = 1+K-((K-A+1)//2)*2 + (B-A)*((K-A+1)//2)
print(ans) | 3 | 4 | 111 | 127 | K, A, B = list(map(int, input().split()))
if B - A <= 2 or K < A:
print((K + 1))
else:
print((((K - A + 1) // 2) * (B - A) + A + 1 - (K - A) % 2))
| K, A, B = list(map(int, input().split()))
if B <= A + 1 or K <= A:
ans = K + 1
else:
ans = 1 + K - ((K - A + 1) // 2) * 2 + (B - A) * ((K - A + 1) // 2)
print(ans)
| false | 25 | [
"-if B - A <= 2 or K < A:",
"- print((K + 1))",
"+if B <= A + 1 or K <= A:",
"+ ans = K + 1",
"- print((((K - A + 1) // 2) * (B - A) + A + 1 - (K - A) % 2))",
"+ ans = 1 + K - ((K - A + 1) // 2) * 2 + (B - A) * ((K - A + 1) // 2)",
"+print(ans)"
] | false | 0.037053 | 0.038221 | 0.969438 | [
"s801104057",
"s632457837"
] |
u787562674 | p03273 | python | s379080458 | s271084933 | 24 | 20 | 3,064 | 3,064 | Accepted | Accepted | 16.67 | H, W= list(map(int, input().split()))
A = [eval(input()) for i in range(H)]
v_list = []
reverse_list = [""]*W
h_list = []
# 1行全てが "." のとき削除する関数
def delete(h, input, output):
for i in range(h):
if "#" in input[i]:
output.append(input[i])
delete(H, A, v_list)
# 転置する関数
for i in range(W):
for j in range(len(v_list)):
reverse_list[i] = reverse_list[i] + v_list[j][i]
delete(W, reverse_list, h_list)
result_list = [""]*(len(h_list[0]))
# 転置する関数
for i in range(len(h_list[0])):
for j in range(len(h_list)):
result_list[i] = result_list[i] + h_list[j][i]
for s in result_list:
print(s)
| H, W= list(map(int, input().split()))
A = [eval(input()) for i in range(H)]
v_list = []
reverse_list = [""]*W
h_list = []
# 1行全てが "." のとき削除する関数
def delete(h, input, output):
for i in range(h):
if "#" in input[i]:
output.append(input[i])
# 転置する関数
def reverse(w, h, input, output):
for i in range(w):
for j in range(h):
output[i] = output[i] + input[j][i]
delete(H, A, v_list)
reverse(W, len(v_list), v_list, reverse_list)
delete(W, reverse_list, h_list)
result_list = [""]*(len(h_list[0]))
reverse(len(h_list[0]), len(h_list), h_list, result_list)
for s in result_list:
print(s)
| 32 | 31 | 660 | 657 | H, W = list(map(int, input().split()))
A = [eval(input()) for i in range(H)]
v_list = []
reverse_list = [""] * W
h_list = []
# 1行全てが "." のとき削除する関数
def delete(h, input, output):
for i in range(h):
if "#" in input[i]:
output.append(input[i])
delete(H, A, v_list)
# 転置する関数
for i in range(W):
for j in range(len(v_list)):
reverse_list[i] = reverse_list[i] + v_list[j][i]
delete(W, reverse_list, h_list)
result_list = [""] * (len(h_list[0]))
# 転置する関数
for i in range(len(h_list[0])):
for j in range(len(h_list)):
result_list[i] = result_list[i] + h_list[j][i]
for s in result_list:
print(s)
| H, W = list(map(int, input().split()))
A = [eval(input()) for i in range(H)]
v_list = []
reverse_list = [""] * W
h_list = []
# 1行全てが "." のとき削除する関数
def delete(h, input, output):
for i in range(h):
if "#" in input[i]:
output.append(input[i])
# 転置する関数
def reverse(w, h, input, output):
for i in range(w):
for j in range(h):
output[i] = output[i] + input[j][i]
delete(H, A, v_list)
reverse(W, len(v_list), v_list, reverse_list)
delete(W, reverse_list, h_list)
result_list = [""] * (len(h_list[0]))
reverse(len(h_list[0]), len(h_list), h_list, result_list)
for s in result_list:
print(s)
| false | 3.125 | [
"+# 転置する関数",
"+def reverse(w, h, input, output):",
"+ for i in range(w):",
"+ for j in range(h):",
"+ output[i] = output[i] + input[j][i]",
"+",
"+",
"-# 転置する関数",
"-for i in range(W):",
"- for j in range(len(v_list)):",
"- reverse_list[i] = reverse_list[i] + v_list[j][i]",
"+reverse(W, len(v_list), v_list, reverse_list)",
"-# 転置する関数",
"-for i in range(len(h_list[0])):",
"- for j in range(len(h_list)):",
"- result_list[i] = result_list[i] + h_list[j][i]",
"+reverse(len(h_list[0]), len(h_list), h_list, result_list)"
] | false | 0.070065 | 0.070142 | 0.998894 | [
"s379080458",
"s271084933"
] |
u228223940 | p03112 | python | s795821708 | s489375947 | 1,965 | 888 | 16,144 | 12,188 | Accepted | Accepted | 54.81 | import bisect
a,b,q = list(map(int,input().split()))
s = [int(eval(input())) for i in range(a)]
t = [int(eval(input())) for i in range(b)]
x = [int(eval(input())) for i in range(q)]
ans = 10**100
for i in range(q):
ans = 10**100
s_idx = bisect.bisect_left(s,x[i])
t_idx = bisect.bisect_left(t,x[i])
s_idx -= 1
t_idx -= 1
#print(x[i],s_idx,t_idx)
for j in range(2):
for k in range(2):
ans = min(ans,abs(x[i] - s[min(s_idx+j,a-1)]) + abs(s[min(s_idx+j,a-1)] - t[min(t_idx+k,b-1)]),abs(x[i] - t[min(t_idx+k,b-1)]) + abs(s[min(s_idx+j,a-1)] - t[min(t_idx+k,b-1)]))
print(ans) | import sys
import bisect
input = sys.stdin.readline
def f(x):
if 0<=x and a-1>= x:
return True
return False
def g(x):
if 0<=x and b-1>= x:
return True
return False
a,b,q = list(map(int,input().split()))
s = []
t = []
for i in range(a):
S = int(eval(input()))
s.append(S)
for i in range(b):
T = int(eval(input()))
t.append(T)
s.sort()
t.sort()
for i in range(q):
x = int(eval(input()))
p = bisect.bisect_left(s,x)
m = bisect.bisect_left(t,x)
res = []
if f(p) and g(m):
res.append(max(t[m],s[p])-x)
if f(p) and g(m-1):
res.append(min(s[p]-x,x-t[m-1])+s[p]-t[m-1])
if f(p-1) and g(m):
res.append(t[m]-s[p-1]+min(t[m]-x,x-s[p-1]))
if f(p-1) and g(m-1):
res.append(x-min(t[m-1],s[p-1]))
print((min(res))) | 22 | 40 | 637 | 837 | import bisect
a, b, q = list(map(int, input().split()))
s = [int(eval(input())) for i in range(a)]
t = [int(eval(input())) for i in range(b)]
x = [int(eval(input())) for i in range(q)]
ans = 10**100
for i in range(q):
ans = 10**100
s_idx = bisect.bisect_left(s, x[i])
t_idx = bisect.bisect_left(t, x[i])
s_idx -= 1
t_idx -= 1
# print(x[i],s_idx,t_idx)
for j in range(2):
for k in range(2):
ans = min(
ans,
abs(x[i] - s[min(s_idx + j, a - 1)])
+ abs(s[min(s_idx + j, a - 1)] - t[min(t_idx + k, b - 1)]),
abs(x[i] - t[min(t_idx + k, b - 1)])
+ abs(s[min(s_idx + j, a - 1)] - t[min(t_idx + k, b - 1)]),
)
print(ans)
| import sys
import bisect
input = sys.stdin.readline
def f(x):
if 0 <= x and a - 1 >= x:
return True
return False
def g(x):
if 0 <= x and b - 1 >= x:
return True
return False
a, b, q = list(map(int, input().split()))
s = []
t = []
for i in range(a):
S = int(eval(input()))
s.append(S)
for i in range(b):
T = int(eval(input()))
t.append(T)
s.sort()
t.sort()
for i in range(q):
x = int(eval(input()))
p = bisect.bisect_left(s, x)
m = bisect.bisect_left(t, x)
res = []
if f(p) and g(m):
res.append(max(t[m], s[p]) - x)
if f(p) and g(m - 1):
res.append(min(s[p] - x, x - t[m - 1]) + s[p] - t[m - 1])
if f(p - 1) and g(m):
res.append(t[m] - s[p - 1] + min(t[m] - x, x - s[p - 1]))
if f(p - 1) and g(m - 1):
res.append(x - min(t[m - 1], s[p - 1]))
print((min(res)))
| false | 45 | [
"+import sys",
"+input = sys.stdin.readline",
"+",
"+",
"+def f(x):",
"+ if 0 <= x and a - 1 >= x:",
"+ return True",
"+ return False",
"+",
"+",
"+def g(x):",
"+ if 0 <= x and b - 1 >= x:",
"+ return True",
"+ return False",
"+",
"+",
"-s = [int(eval(input())) for i in range(a)]",
"-t = [int(eval(input())) for i in range(b)]",
"-x = [int(eval(input())) for i in range(q)]",
"-ans = 10**100",
"+s = []",
"+t = []",
"+for i in range(a):",
"+ S = int(eval(input()))",
"+ s.append(S)",
"+for i in range(b):",
"+ T = int(eval(input()))",
"+ t.append(T)",
"+s.sort()",
"+t.sort()",
"- ans = 10**100",
"- s_idx = bisect.bisect_left(s, x[i])",
"- t_idx = bisect.bisect_left(t, x[i])",
"- s_idx -= 1",
"- t_idx -= 1",
"- # print(x[i],s_idx,t_idx)",
"- for j in range(2):",
"- for k in range(2):",
"- ans = min(",
"- ans,",
"- abs(x[i] - s[min(s_idx + j, a - 1)])",
"- + abs(s[min(s_idx + j, a - 1)] - t[min(t_idx + k, b - 1)]),",
"- abs(x[i] - t[min(t_idx + k, b - 1)])",
"- + abs(s[min(s_idx + j, a - 1)] - t[min(t_idx + k, b - 1)]),",
"- )",
"- print(ans)",
"+ x = int(eval(input()))",
"+ p = bisect.bisect_left(s, x)",
"+ m = bisect.bisect_left(t, x)",
"+ res = []",
"+ if f(p) and g(m):",
"+ res.append(max(t[m], s[p]) - x)",
"+ if f(p) and g(m - 1):",
"+ res.append(min(s[p] - x, x - t[m - 1]) + s[p] - t[m - 1])",
"+ if f(p - 1) and g(m):",
"+ res.append(t[m] - s[p - 1] + min(t[m] - x, x - s[p - 1]))",
"+ if f(p - 1) and g(m - 1):",
"+ res.append(x - min(t[m - 1], s[p - 1]))",
"+ print((min(res)))"
] | false | 0.059258 | 0.097286 | 0.609107 | [
"s795821708",
"s489375947"
] |
u536113865 | p03356 | python | s627675164 | s505503581 | 968 | 842 | 77,916 | 14,452 | Accepted | Accepted | 13.02 | f = lambda: list(map(int,input().split()))
class UnionFind(object):
def __init__(self, size):
self.parent = [i for i in range(size)]
self.rank = [0 for _ in range(size)]
def find(self, x):
if self.parent[x] == x:
return x
else:
return self.find(self.parent[x])
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.rank[x] < self.rank[y]:
self.parent[x] = y
else:
self.parent[y] = x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
def same(self, x, y):
return self.find(x) == self.find(y)
n,m = f()
p = list(f())
u = UnionFind(n)
for _ in range(m):
x,y = f()
u.unite(x-1, y-1)
gnum = [set() for _ in range(n)]
pnum = [set() for _ in range(n)]
for i in range(n):
root = u.find(i)
gnum[root].add(i)
pnum[root].add(p[i]-1)
ans = 0
for i in range(n):
ans += len(gnum[i]&pnum[i])
print(ans)
| f = lambda: list(map(int,input().split()))
class UnionFind(object):
def __init__(self, size):
self.parent = [i for i in range(size)]
self.rank = [0 for _ in range(size)]
def find(self, x):
if self.parent[x] == x:
return x
else:
return self.find(self.parent[x])
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.rank[x] < self.rank[y]:
self.parent[x] = y
else:
self.parent[y] = x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
def same(self, x, y):
return self.find(x) == self.find(y)
n,m = f()
p = list(f())
u = UnionFind(n)
for _ in range(m):
x,y = f()
u.unite(x-1, y-1)
ans = 0
for i in range(n):
if u.find(i)==u.find(p[i]-1):
ans += 1
print(ans)
| 49 | 45 | 1,078 | 939 | f = lambda: list(map(int, input().split()))
class UnionFind(object):
def __init__(self, size):
self.parent = [i for i in range(size)]
self.rank = [0 for _ in range(size)]
def find(self, x):
if self.parent[x] == x:
return x
else:
return self.find(self.parent[x])
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.rank[x] < self.rank[y]:
self.parent[x] = y
else:
self.parent[y] = x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
def same(self, x, y):
return self.find(x) == self.find(y)
n, m = f()
p = list(f())
u = UnionFind(n)
for _ in range(m):
x, y = f()
u.unite(x - 1, y - 1)
gnum = [set() for _ in range(n)]
pnum = [set() for _ in range(n)]
for i in range(n):
root = u.find(i)
gnum[root].add(i)
pnum[root].add(p[i] - 1)
ans = 0
for i in range(n):
ans += len(gnum[i] & pnum[i])
print(ans)
| f = lambda: list(map(int, input().split()))
class UnionFind(object):
def __init__(self, size):
self.parent = [i for i in range(size)]
self.rank = [0 for _ in range(size)]
def find(self, x):
if self.parent[x] == x:
return x
else:
return self.find(self.parent[x])
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.rank[x] < self.rank[y]:
self.parent[x] = y
else:
self.parent[y] = x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
def same(self, x, y):
return self.find(x) == self.find(y)
n, m = f()
p = list(f())
u = UnionFind(n)
for _ in range(m):
x, y = f()
u.unite(x - 1, y - 1)
ans = 0
for i in range(n):
if u.find(i) == u.find(p[i] - 1):
ans += 1
print(ans)
| false | 8.163265 | [
"-gnum = [set() for _ in range(n)]",
"-pnum = [set() for _ in range(n)]",
"-for i in range(n):",
"- root = u.find(i)",
"- gnum[root].add(i)",
"- pnum[root].add(p[i] - 1)",
"- ans += len(gnum[i] & pnum[i])",
"+ if u.find(i) == u.find(p[i] - 1):",
"+ ans += 1"
] | false | 0.046604 | 0.035121 | 1.326929 | [
"s627675164",
"s505503581"
] |
u580920947 | p03160 | python | s167700390 | s037406513 | 417 | 228 | 22,784 | 52,208 | Accepted | Accepted | 45.32 | #!/usr/bin/env python
# -*- coding: utf-8 -*-
import numpy as np
def main():
INF = 10 ** 8
N = int(eval(input()))
weights = np.array(list(map(int, input().split()))).astype(int)
dp_table = np.empty(N).astype(int)
dp_table.fill(INF)
dp_table[0] = 0
dp_table[1] = abs(weights[1] - weights[0])
for i in range(2, N):
dp_table[i] = min(dp_table[i-1] + abs(weights[i] - weights[i-1]), dp_table[i-2] + abs(weights[i] - weights[i-2]))
print((dp_table[N-1]))
return 0
if __name__ == "__main__":
main()
| #!/usr/bin/env python
def chmin(a, b):
return b if a > b else a
def chmax(a, b):
return b if a < b else a
def main(N, h):
INF = 10 ** 9
dp = [INF] * (10 ** 5 + 10)
dp[0] = 0
dp[1] = abs(h[1] - h[0])
for i in range(2, N):
dp[i] = chmin(dp[i], dp[i-1] + abs(h[i] - h[i-1]))
dp[i] = chmin(dp[i], dp[i-2] + abs(h[i] - h[i-2]))
return dp[N-1]
if __name__ == '__main__':
N = int(eval(input()))
h = list(map(int, input().split()))
print((main(N, h)))
| 22 | 22 | 571 | 521 | #!/usr/bin/env python
# -*- coding: utf-8 -*-
import numpy as np
def main():
INF = 10**8
N = int(eval(input()))
weights = np.array(list(map(int, input().split()))).astype(int)
dp_table = np.empty(N).astype(int)
dp_table.fill(INF)
dp_table[0] = 0
dp_table[1] = abs(weights[1] - weights[0])
for i in range(2, N):
dp_table[i] = min(
dp_table[i - 1] + abs(weights[i] - weights[i - 1]),
dp_table[i - 2] + abs(weights[i] - weights[i - 2]),
)
print((dp_table[N - 1]))
return 0
if __name__ == "__main__":
main()
| #!/usr/bin/env python
def chmin(a, b):
return b if a > b else a
def chmax(a, b):
return b if a < b else a
def main(N, h):
INF = 10**9
dp = [INF] * (10**5 + 10)
dp[0] = 0
dp[1] = abs(h[1] - h[0])
for i in range(2, N):
dp[i] = chmin(dp[i], dp[i - 1] + abs(h[i] - h[i - 1]))
dp[i] = chmin(dp[i], dp[i - 2] + abs(h[i] - h[i - 2]))
return dp[N - 1]
if __name__ == "__main__":
N = int(eval(input()))
h = list(map(int, input().split()))
print((main(N, h)))
| false | 0 | [
"-# -*- coding: utf-8 -*-",
"-import numpy as np",
"+def chmin(a, b):",
"+ return b if a > b else a",
"-def main():",
"- INF = 10**8",
"- N = int(eval(input()))",
"- weights = np.array(list(map(int, input().split()))).astype(int)",
"- dp_table = np.empty(N).astype(int)",
"- dp_table.fill(INF)",
"- dp_table[0] = 0",
"- dp_table[1] = abs(weights[1] - weights[0])",
"+def chmax(a, b):",
"+ return b if a < b else a",
"+",
"+",
"+def main(N, h):",
"+ INF = 10**9",
"+ dp = [INF] * (10**5 + 10)",
"+ dp[0] = 0",
"+ dp[1] = abs(h[1] - h[0])",
"- dp_table[i] = min(",
"- dp_table[i - 1] + abs(weights[i] - weights[i - 1]),",
"- dp_table[i - 2] + abs(weights[i] - weights[i - 2]),",
"- )",
"- print((dp_table[N - 1]))",
"- return 0",
"+ dp[i] = chmin(dp[i], dp[i - 1] + abs(h[i] - h[i - 1]))",
"+ dp[i] = chmin(dp[i], dp[i - 2] + abs(h[i] - h[i - 2]))",
"+ return dp[N - 1]",
"- main()",
"+ N = int(eval(input()))",
"+ h = list(map(int, input().split()))",
"+ print((main(N, h)))"
] | false | 0.29509 | 0.048055 | 6.140689 | [
"s167700390",
"s037406513"
] |
u493520238 | p02888 | python | s012720325 | s722350669 | 1,520 | 342 | 3,188 | 74,540 | Accepted | Accepted | 77.5 | import bisect
def main():
n = int(eval(input()))
ll = list(map(int, input().split()))
ll.sort()
ans = 0
for i in range(n-2):
e1 = ll[i]
for j in range(i+1, n-1):
e2 = ll[j]
# ans += bisect.bisect_left(ll[j+1:], e1+e2)
comb = bisect.bisect_left(ll, e1+e2)
comb -= (j+1)
ans += max(comb,0)
print(ans)
if __name__ == "__main__":
main() | import bisect
n = int(eval(input()))
ll = list(map(int, input().split()))
ll.sort()
ans = 0
for i in range(n-2):
e1 = ll[i]
for j in range(i+1, n-1):
e2 = ll[j]
comb = bisect.bisect_left(ll, e1+e2)
comb -= (j+1)
ans += max(comb,0)
print(ans)
| 22 | 17 | 456 | 296 | import bisect
def main():
n = int(eval(input()))
ll = list(map(int, input().split()))
ll.sort()
ans = 0
for i in range(n - 2):
e1 = ll[i]
for j in range(i + 1, n - 1):
e2 = ll[j]
# ans += bisect.bisect_left(ll[j+1:], e1+e2)
comb = bisect.bisect_left(ll, e1 + e2)
comb -= j + 1
ans += max(comb, 0)
print(ans)
if __name__ == "__main__":
main()
| import bisect
n = int(eval(input()))
ll = list(map(int, input().split()))
ll.sort()
ans = 0
for i in range(n - 2):
e1 = ll[i]
for j in range(i + 1, n - 1):
e2 = ll[j]
comb = bisect.bisect_left(ll, e1 + e2)
comb -= j + 1
ans += max(comb, 0)
print(ans)
| false | 22.727273 | [
"-",
"-def main():",
"- n = int(eval(input()))",
"- ll = list(map(int, input().split()))",
"- ll.sort()",
"- ans = 0",
"- for i in range(n - 2):",
"- e1 = ll[i]",
"- for j in range(i + 1, n - 1):",
"- e2 = ll[j]",
"- # ans += bisect.bisect_left(ll[j+1:], e1+e2)",
"- comb = bisect.bisect_left(ll, e1 + e2)",
"- comb -= j + 1",
"- ans += max(comb, 0)",
"- print(ans)",
"-",
"-",
"-if __name__ == \"__main__\":",
"- main()",
"+n = int(eval(input()))",
"+ll = list(map(int, input().split()))",
"+ll.sort()",
"+ans = 0",
"+for i in range(n - 2):",
"+ e1 = ll[i]",
"+ for j in range(i + 1, n - 1):",
"+ e2 = ll[j]",
"+ comb = bisect.bisect_left(ll, e1 + e2)",
"+ comb -= j + 1",
"+ ans += max(comb, 0)",
"+print(ans)"
] | false | 0.041058 | 0.07764 | 0.528825 | [
"s012720325",
"s722350669"
] |
u223646582 | p03038 | python | s169808164 | s406291117 | 568 | 469 | 31,780 | 22,492 | Accepted | Accepted | 17.43 | import sys
sys.setrecursionlimit(1000000)
from collections import defaultdict
N, M = list(map(int, input().split()))
A = sorted(list(map(int, input().split())))
dict = defaultdict(int)
for i in range(M):
B, C = list(map(int, input().split()))
dict[C] += B
idx = 0
for k, v in sorted(list(dict.items()), key=lambda x: -x[0]):
for _ in range(v):
if idx+1 <= len(A):
if A[idx] < k:
A[idx] = k
idx += 1
else:
print((sum(A)))
exit()
else:
print((sum(A)))
exit()
print((sum(A)))
| N, M = list(map(int, input().split()))
A = sorted([int(i) for i in input().split()])
BC = [tuple(map(int, input().split())) for _ in range(M)]
BC.sort(key=lambda x: x[1], reverse=True)
ans = 0
j = 0
b = 0
for i in range(N):
if j < M and A[i] < BC[j][1]:
ans += BC[j][1]
b += 1
if b == BC[j][0]:
j += 1
b = 0
else:
ans += A[i]
print(ans)
| 30 | 18 | 565 | 413 | import sys
sys.setrecursionlimit(1000000)
from collections import defaultdict
N, M = list(map(int, input().split()))
A = sorted(list(map(int, input().split())))
dict = defaultdict(int)
for i in range(M):
B, C = list(map(int, input().split()))
dict[C] += B
idx = 0
for k, v in sorted(list(dict.items()), key=lambda x: -x[0]):
for _ in range(v):
if idx + 1 <= len(A):
if A[idx] < k:
A[idx] = k
idx += 1
else:
print((sum(A)))
exit()
else:
print((sum(A)))
exit()
print((sum(A)))
| N, M = list(map(int, input().split()))
A = sorted([int(i) for i in input().split()])
BC = [tuple(map(int, input().split())) for _ in range(M)]
BC.sort(key=lambda x: x[1], reverse=True)
ans = 0
j = 0
b = 0
for i in range(N):
if j < M and A[i] < BC[j][1]:
ans += BC[j][1]
b += 1
if b == BC[j][0]:
j += 1
b = 0
else:
ans += A[i]
print(ans)
| false | 40 | [
"-import sys",
"-",
"-sys.setrecursionlimit(1000000)",
"-from collections import defaultdict",
"-",
"-A = sorted(list(map(int, input().split())))",
"-dict = defaultdict(int)",
"-for i in range(M):",
"- B, C = list(map(int, input().split()))",
"- dict[C] += B",
"-idx = 0",
"-for k, v in sorted(list(dict.items()), key=lambda x: -x[0]):",
"- for _ in range(v):",
"- if idx + 1 <= len(A):",
"- if A[idx] < k:",
"- A[idx] = k",
"- idx += 1",
"- else:",
"- print((sum(A)))",
"- exit()",
"- else:",
"- print((sum(A)))",
"- exit()",
"-print((sum(A)))",
"+A = sorted([int(i) for i in input().split()])",
"+BC = [tuple(map(int, input().split())) for _ in range(M)]",
"+BC.sort(key=lambda x: x[1], reverse=True)",
"+ans = 0",
"+j = 0",
"+b = 0",
"+for i in range(N):",
"+ if j < M and A[i] < BC[j][1]:",
"+ ans += BC[j][1]",
"+ b += 1",
"+ if b == BC[j][0]:",
"+ j += 1",
"+ b = 0",
"+ else:",
"+ ans += A[i]",
"+print(ans)"
] | false | 0.043011 | 0.042403 | 1.014335 | [
"s169808164",
"s406291117"
] |
u489124637 | p02659 | python | s828718206 | s166075054 | 392 | 33 | 77,596 | 10,524 | Accepted | Accepted | 91.58 | from decimal import Decimal
import math
A,B = input().split()
A = int(A)
B = Decimal(B)
print((int(math.floor(A*B)))) | #有理数演算
from math import floor
from fractions import Fraction
a, b = input().split()
a = int(a)
b = Fraction(b)
print((floor(a * b))) | 8 | 9 | 125 | 140 | from decimal import Decimal
import math
A, B = input().split()
A = int(A)
B = Decimal(B)
print((int(math.floor(A * B))))
| # 有理数演算
from math import floor
from fractions import Fraction
a, b = input().split()
a = int(a)
b = Fraction(b)
print((floor(a * b)))
| false | 11.111111 | [
"-from decimal import Decimal",
"-import math",
"+# 有理数演算",
"+from math import floor",
"+from fractions import Fraction",
"-A, B = input().split()",
"-A = int(A)",
"-B = Decimal(B)",
"-print((int(math.floor(A * B))))",
"+a, b = input().split()",
"+a = int(a)",
"+b = Fraction(b)",
"+print((floor(a * b)))"
] | false | 0.043607 | 0.044931 | 0.970533 | [
"s828718206",
"s166075054"
] |
u197615397 | p02346 | python | s493752006 | s172642505 | 2,630 | 2,400 | 18,528 | 18,596 | Accepted | Accepted | 8.75 | import math
class SegmentTree:
__slots__ = ["elem_size", "tree_size", "tree"]
def __init__(self, a: list, default: int):
real_size = len(a)
self.elem_size = 1 << math.ceil(math.log2(real_size))
self.tree_size = 2 * self.elem_size + 1
self.tree = [default] * (self.elem_size - 1) + a + [default] * (self.elem_size - real_size)
def get_range_index(self, x, y, k=0, l_end=0, r_end=None):
'''[x, y], tree[k], [l_end, r_end)'''
if r_end is None:
r_end = self.elem_size
if l_end == x and y == r_end-1:
return [k]
mid = (l_end + r_end) // 2
left_y = y if y < mid-1 else mid-1
right_x = x if x > mid else mid
left = self.get_range_index(x, left_y, 2*k+1, l_end, mid) if x <= left_y else []
right = self.get_range_index(right_x, y, 2*k+2, mid, r_end) if right_x <= y else []
return left + right
def get_value(self, x, y):
tree = self.tree
index_list = self.get_range_index(x, y)
return sum(tree[n] for n in index_list)
def update_tree(self, k: int):
tree = self.tree
while k > 0:
k = (k-1) // 2
left, right = tree[2*k+1], tree[2*k+2]
tree[k] = left + right
def set_value(self, i: int, value: int, op: str):
k = self.elem_size - 1 + i
if op == "=":
self.tree[k] = value
elif op == "+":
self.tree[k] += value
self.update_tree(k)
n, q = list(map(int, input().split()))
rsq = SegmentTree([0]*n, 0)
ans = []
for _ in [0]*q:
c, x, y = list(map(int, input().split()))
if c == 0:
rsq.set_value(x-1, y, "+")
else:
ans.append(rsq.get_value(x-1, y-1))
print(("\n".join([str(n) for n in ans]))) | import math
class SegmentTree:
__slots__ = ["elem_size", "tree_size", "tree"]
def __init__(self, a: list, default: int):
real_size = len(a)
self.elem_size = 1 << math.ceil(math.log2(real_size))
self.tree_size = 2 * self.elem_size + 1
self.tree = [default] * (self.elem_size - 1) + a + [default] * (self.elem_size - real_size)
def get_range_index(self, x, y, k=0, l_end=0, r_end=None):
'''[x, y], tree[k], [l_end, r_end)'''
default, tree = 0, self.tree
if r_end is None:
r_end = self.elem_size
if l_end == x and y == r_end-1:
return tree[k]
mid = (l_end + r_end) // 2
left_y = y if y < mid-1 else mid-1
right_x = x if x > mid else mid
left = self.get_range_index(x, left_y, 2*k+1, l_end, mid) if x <= left_y else default
right = self.get_range_index(right_x, y, 2*k+2, mid, r_end) if right_x <= y else default
return left + right
def get_value(self, x, y):
tree = self.tree
return self.get_range_index(x, y)
# return sum(tree[n] for n in index_list)
def update_tree(self, k: int):
tree = self.tree
while k > 0:
k = (k-1) // 2
left, right = tree[2*k+1], tree[2*k+2]
tree[k] = left + right
def set_value(self, i: int, value: int, op: str):
k = self.elem_size - 1 + i
if op == "=":
self.tree[k] = value
elif op == "+":
self.tree[k] += value
self.update_tree(k)
n, q = list(map(int, input().split()))
rsq = SegmentTree([0]*n, 0)
ans = []
for _ in [0]*q:
c, x, y = list(map(int, input().split()))
if c == 0:
rsq.set_value(x-1, y, "+")
else:
ans.append(rsq.get_value(x-1, y-1))
print(("\n".join([str(n) for n in ans]))) | 61 | 62 | 1,845 | 1,893 | import math
class SegmentTree:
__slots__ = ["elem_size", "tree_size", "tree"]
def __init__(self, a: list, default: int):
real_size = len(a)
self.elem_size = 1 << math.ceil(math.log2(real_size))
self.tree_size = 2 * self.elem_size + 1
self.tree = (
[default] * (self.elem_size - 1)
+ a
+ [default] * (self.elem_size - real_size)
)
def get_range_index(self, x, y, k=0, l_end=0, r_end=None):
"""[x, y], tree[k], [l_end, r_end)"""
if r_end is None:
r_end = self.elem_size
if l_end == x and y == r_end - 1:
return [k]
mid = (l_end + r_end) // 2
left_y = y if y < mid - 1 else mid - 1
right_x = x if x > mid else mid
left = (
self.get_range_index(x, left_y, 2 * k + 1, l_end, mid)
if x <= left_y
else []
)
right = (
self.get_range_index(right_x, y, 2 * k + 2, mid, r_end)
if right_x <= y
else []
)
return left + right
def get_value(self, x, y):
tree = self.tree
index_list = self.get_range_index(x, y)
return sum(tree[n] for n in index_list)
def update_tree(self, k: int):
tree = self.tree
while k > 0:
k = (k - 1) // 2
left, right = tree[2 * k + 1], tree[2 * k + 2]
tree[k] = left + right
def set_value(self, i: int, value: int, op: str):
k = self.elem_size - 1 + i
if op == "=":
self.tree[k] = value
elif op == "+":
self.tree[k] += value
self.update_tree(k)
n, q = list(map(int, input().split()))
rsq = SegmentTree([0] * n, 0)
ans = []
for _ in [0] * q:
c, x, y = list(map(int, input().split()))
if c == 0:
rsq.set_value(x - 1, y, "+")
else:
ans.append(rsq.get_value(x - 1, y - 1))
print(("\n".join([str(n) for n in ans])))
| import math
class SegmentTree:
__slots__ = ["elem_size", "tree_size", "tree"]
def __init__(self, a: list, default: int):
real_size = len(a)
self.elem_size = 1 << math.ceil(math.log2(real_size))
self.tree_size = 2 * self.elem_size + 1
self.tree = (
[default] * (self.elem_size - 1)
+ a
+ [default] * (self.elem_size - real_size)
)
def get_range_index(self, x, y, k=0, l_end=0, r_end=None):
"""[x, y], tree[k], [l_end, r_end)"""
default, tree = 0, self.tree
if r_end is None:
r_end = self.elem_size
if l_end == x and y == r_end - 1:
return tree[k]
mid = (l_end + r_end) // 2
left_y = y if y < mid - 1 else mid - 1
right_x = x if x > mid else mid
left = (
self.get_range_index(x, left_y, 2 * k + 1, l_end, mid)
if x <= left_y
else default
)
right = (
self.get_range_index(right_x, y, 2 * k + 2, mid, r_end)
if right_x <= y
else default
)
return left + right
def get_value(self, x, y):
tree = self.tree
return self.get_range_index(x, y)
# return sum(tree[n] for n in index_list)
def update_tree(self, k: int):
tree = self.tree
while k > 0:
k = (k - 1) // 2
left, right = tree[2 * k + 1], tree[2 * k + 2]
tree[k] = left + right
def set_value(self, i: int, value: int, op: str):
k = self.elem_size - 1 + i
if op == "=":
self.tree[k] = value
elif op == "+":
self.tree[k] += value
self.update_tree(k)
n, q = list(map(int, input().split()))
rsq = SegmentTree([0] * n, 0)
ans = []
for _ in [0] * q:
c, x, y = list(map(int, input().split()))
if c == 0:
rsq.set_value(x - 1, y, "+")
else:
ans.append(rsq.get_value(x - 1, y - 1))
print(("\n".join([str(n) for n in ans])))
| false | 1.612903 | [
"+ default, tree = 0, self.tree",
"- return [k]",
"+ return tree[k]",
"- else []",
"+ else default",
"- else []",
"+ else default",
"- index_list = self.get_range_index(x, y)",
"- return sum(tree[n] for n in index_list)",
"+ return self.get_range_index(x, y)",
"+ # return sum(tree[n] for n in index_list)"
] | false | 0.050048 | 0.05673 | 0.882211 | [
"s493752006",
"s172642505"
] |
u933622697 | p03212 | python | s326440812 | s009275254 | 105 | 18 | 3,316 | 3,064 | Accepted | Accepted | 82.86 | from collections import deque
N = int(eval(input()))
stack = deque()
num_753 = 0
def dfs():
global stack, num_753
s = stack.pop()
if int(s) > N:
return
is_contained = 1 if all(s.count(c) > 0 for c in '753') else 0
num_753 += is_contained
for next_s in '357':
stack.append(s + next_s)
stack.append('0')
while stack:
dfs()
# Output
print(num_753)
| # DP Solution (DP[...] = Bool if values which satisfy ... exist)
from itertools import product
N_str = input()
len_N = len(N_str)
N = int(N_str)
# DP Initialization
dp = [[[[[0] * 2 for _ in range(2)] for _ in range(2)] for _ in range(2)]
for _ in range(len_N)]
# dp[digit][is_max][is_3][is_5][is_7]
# "non 3, 5, 7" and "not max" values exist
for l in range(len_N):
dp[l][0][0][0][0] = 1
# DP at 0 digit
for m in range(10):
digit_0 = int(N_str[0])
if m > digit_0:
continue
if m in [3, 5, 7]:
dp[0][digit_0 == m][m == 3][m == 5][m == 7] = 1
# Current DP inherits last DP values
for l, m, n, o, p in product(range(len_N - 1), range(10), range(2), range(2),
range(2)):
if m in [3, 5, 7]:
digit_lp1 = int(N_str[l + 1])
dp[l+1][0][n or m == 3][o or m == 5][p or m == 7] += \
dp[l][0][n][o][p]
if digit_lp1 < m:
continue
dp[l+1][digit_lp1 == m][n or m == 3][o or m == 5][p or m == 7] += \
dp[l][1][n][o][p]
print(dp[-1][0][1][1][1] + dp[-1][1][1][1][1])
| 29 | 40 | 422 | 1,135 | from collections import deque
N = int(eval(input()))
stack = deque()
num_753 = 0
def dfs():
global stack, num_753
s = stack.pop()
if int(s) > N:
return
is_contained = 1 if all(s.count(c) > 0 for c in "753") else 0
num_753 += is_contained
for next_s in "357":
stack.append(s + next_s)
stack.append("0")
while stack:
dfs()
# Output
print(num_753)
| # DP Solution (DP[...] = Bool if values which satisfy ... exist)
from itertools import product
N_str = input()
len_N = len(N_str)
N = int(N_str)
# DP Initialization
dp = [
[[[[0] * 2 for _ in range(2)] for _ in range(2)] for _ in range(2)]
for _ in range(len_N)
]
# dp[digit][is_max][is_3][is_5][is_7]
# "non 3, 5, 7" and "not max" values exist
for l in range(len_N):
dp[l][0][0][0][0] = 1
# DP at 0 digit
for m in range(10):
digit_0 = int(N_str[0])
if m > digit_0:
continue
if m in [3, 5, 7]:
dp[0][digit_0 == m][m == 3][m == 5][m == 7] = 1
# Current DP inherits last DP values
for l, m, n, o, p in product(range(len_N - 1), range(10), range(2), range(2), range(2)):
if m in [3, 5, 7]:
digit_lp1 = int(N_str[l + 1])
dp[l + 1][0][n or m == 3][o or m == 5][p or m == 7] += dp[l][0][n][o][p]
if digit_lp1 < m:
continue
dp[l + 1][digit_lp1 == m][n or m == 3][o or m == 5][p or m == 7] += dp[l][1][n][
o
][p]
print(dp[-1][0][1][1][1] + dp[-1][1][1][1][1])
| false | 27.5 | [
"-from collections import deque",
"+# DP Solution (DP[...] = Bool if values which satisfy ... exist)",
"+from itertools import product",
"-N = int(eval(input()))",
"-stack = deque()",
"-num_753 = 0",
"-",
"-",
"-def dfs():",
"- global stack, num_753",
"- s = stack.pop()",
"- if int(s) > N:",
"- return",
"- is_contained = 1 if all(s.count(c) > 0 for c in \"753\") else 0",
"- num_753 += is_contained",
"- for next_s in \"357\":",
"- stack.append(s + next_s)",
"-",
"-",
"-stack.append(\"0\")",
"-while stack:",
"- dfs()",
"-# Output",
"-print(num_753)",
"+N_str = input()",
"+len_N = len(N_str)",
"+N = int(N_str)",
"+# DP Initialization",
"+dp = [",
"+ [[[[0] * 2 for _ in range(2)] for _ in range(2)] for _ in range(2)]",
"+ for _ in range(len_N)",
"+]",
"+# dp[digit][is_max][is_3][is_5][is_7]",
"+# \"non 3, 5, 7\" and \"not max\" values exist",
"+for l in range(len_N):",
"+ dp[l][0][0][0][0] = 1",
"+# DP at 0 digit",
"+for m in range(10):",
"+ digit_0 = int(N_str[0])",
"+ if m > digit_0:",
"+ continue",
"+ if m in [3, 5, 7]:",
"+ dp[0][digit_0 == m][m == 3][m == 5][m == 7] = 1",
"+# Current DP inherits last DP values",
"+for l, m, n, o, p in product(range(len_N - 1), range(10), range(2), range(2), range(2)):",
"+ if m in [3, 5, 7]:",
"+ digit_lp1 = int(N_str[l + 1])",
"+ dp[l + 1][0][n or m == 3][o or m == 5][p or m == 7] += dp[l][0][n][o][p]",
"+ if digit_lp1 < m:",
"+ continue",
"+ dp[l + 1][digit_lp1 == m][n or m == 3][o or m == 5][p or m == 7] += dp[l][1][n][",
"+ o",
"+ ][p]",
"+print(dp[-1][0][1][1][1] + dp[-1][1][1][1][1])"
] | false | 0.051799 | 0.082319 | 0.629241 | [
"s326440812",
"s009275254"
] |
u883048396 | p03659 | python | s598255141 | s440768534 | 144 | 131 | 23,788 | 23,784 | Accepted | Accepted | 9.03 | def 解():
iN = int(eval(input()))
aA = [int(_) for _ in input().split()]
iD = sum(aA)
iF = 0
minDiff = 10**9 * 2
for a in aA[:-1] :
iF += a
thisDiff = abs(iD - 2*iF)
minDiff = min(minDiff , thisDiff)
print(minDiff)
解()
| def 解():
iN = int(eval(input()))
aA = [int(_) for _ in input().split()]
aDiff = [0]*(iN-1)
iD = sum(aA)
iF = 0
for i in range(iN-1):
iF += aA[i]
aDiff[i] = abs(iD - 2*iF)
print((min(aDiff)))
解()
| 13 | 11 | 277 | 242 | def 解():
iN = int(eval(input()))
aA = [int(_) for _ in input().split()]
iD = sum(aA)
iF = 0
minDiff = 10**9 * 2
for a in aA[:-1]:
iF += a
thisDiff = abs(iD - 2 * iF)
minDiff = min(minDiff, thisDiff)
print(minDiff)
解()
| def 解():
iN = int(eval(input()))
aA = [int(_) for _ in input().split()]
aDiff = [0] * (iN - 1)
iD = sum(aA)
iF = 0
for i in range(iN - 1):
iF += aA[i]
aDiff[i] = abs(iD - 2 * iF)
print((min(aDiff)))
解()
| false | 15.384615 | [
"+ aDiff = [0] * (iN - 1)",
"- minDiff = 10**9 * 2",
"- for a in aA[:-1]:",
"- iF += a",
"- thisDiff = abs(iD - 2 * iF)",
"- minDiff = min(minDiff, thisDiff)",
"- print(minDiff)",
"+ for i in range(iN - 1):",
"+ iF += aA[i]",
"+ aDiff[i] = abs(iD - 2 * iF)",
"+ print((min(aDiff)))"
] | false | 0.036465 | 0.047888 | 0.761465 | [
"s598255141",
"s440768534"
] |
u638282348 | p03283 | python | s986219329 | s830936420 | 2,362 | 1,747 | 21,568 | 22,312 | Accepted | Accepted | 26.04 | import numpy as np
N, M, Q = list(map(int, input().split()))
table = np.zeros((N, N), np.int64)
for _ in range(M):
L, R = [int(n) - 1 for n in input().split()]
table[L][R] += 1
table = np.rot90(np.rot90(table, k=-1).cumsum(axis=0).cumsum(axis=1), k=1).tolist()
for _ in range(Q):
p, q = [int(n) - 1 for n in input().split()]
print((table[p][q])) | import numpy as np
N, M, Q = list(map(int, input().split()))
table = [[0] * N for _ in range(N)]
for _ in range(M):
L, R = [int(n) - 1 for n in input().split()]
table[L][R] += 1
table = np.rot90(np.rot90(table, k=-1).cumsum(axis=0).cumsum(axis=1), k=1).tolist()
for _ in range(Q):
p, q = [int(n) - 1 for n in input().split()]
print((table[p][q])) | 10 | 10 | 372 | 373 | import numpy as np
N, M, Q = list(map(int, input().split()))
table = np.zeros((N, N), np.int64)
for _ in range(M):
L, R = [int(n) - 1 for n in input().split()]
table[L][R] += 1
table = np.rot90(np.rot90(table, k=-1).cumsum(axis=0).cumsum(axis=1), k=1).tolist()
for _ in range(Q):
p, q = [int(n) - 1 for n in input().split()]
print((table[p][q]))
| import numpy as np
N, M, Q = list(map(int, input().split()))
table = [[0] * N for _ in range(N)]
for _ in range(M):
L, R = [int(n) - 1 for n in input().split()]
table[L][R] += 1
table = np.rot90(np.rot90(table, k=-1).cumsum(axis=0).cumsum(axis=1), k=1).tolist()
for _ in range(Q):
p, q = [int(n) - 1 for n in input().split()]
print((table[p][q]))
| false | 0 | [
"-table = np.zeros((N, N), np.int64)",
"+table = [[0] * N for _ in range(N)]"
] | false | 0.256257 | 0.563329 | 0.454897 | [
"s986219329",
"s830936420"
] |
u191874006 | p03101 | python | s895011315 | s007685277 | 20 | 17 | 3,188 | 2,940 | Accepted | Accepted | 15 | #!/usr/bin/env python3
import re
n = eval(input())
n = re.split(" ",n)
m = eval(input())
m = re.split(" ",m)
a = int(n[0])* int(n[1])
b = (int(m[0]) * int(n[1])) + (int(m[1]) * int(n[0]))
b = a-b
c = int(m[0]) * int(m[1])
print((b+c)) | #!/usr/bin/env python3
#ABC121 A
H,W = list(map(int,input().split()))
h,w = list(map(int,input().split()))
print(((H-h)*(W-w)))
| 15 | 7 | 238 | 122 | #!/usr/bin/env python3
import re
n = eval(input())
n = re.split(" ", n)
m = eval(input())
m = re.split(" ", m)
a = int(n[0]) * int(n[1])
b = (int(m[0]) * int(n[1])) + (int(m[1]) * int(n[0]))
b = a - b
c = int(m[0]) * int(m[1])
print((b + c))
| #!/usr/bin/env python3
# ABC121 A
H, W = list(map(int, input().split()))
h, w = list(map(int, input().split()))
print(((H - h) * (W - w)))
| false | 53.333333 | [
"-import re",
"-",
"-n = eval(input())",
"-n = re.split(\" \", n)",
"-m = eval(input())",
"-m = re.split(\" \", m)",
"-a = int(n[0]) * int(n[1])",
"-b = (int(m[0]) * int(n[1])) + (int(m[1]) * int(n[0]))",
"-b = a - b",
"-c = int(m[0]) * int(m[1])",
"-print((b + c))",
"+# ABC121 A",
"+H, W = list(map(int, input().split()))",
"+h, w = list(map(int, input().split()))",
"+print(((H - h) * (W - w)))"
] | false | 0.045614 | 0.041796 | 1.091357 | [
"s895011315",
"s007685277"
] |
u754022296 | p02861 | python | s806754016 | s751086977 | 414 | 375 | 3,064 | 3,064 | Accepted | Accepted | 9.42 | import math
import itertools
n = int(eval(input()))
xy = [ list(map(int, input().split())) for _ in range(n) ]
p = itertools.permutations(xy, n)
c = 0
for i in p:
for j in range(n-1):
c += ( (i[j][0]-i[j+1][0])**2 + (i[j][1]-i[j+1][1])**2 )**0.5
l = math.factorial(n)
print((c/l)) | from itertools import permutations
from math import factorial
def d(a, b):
x1, y1 = a
x2, y2 = b
return ((x1-x2)**2 + (y1-y2)**2)**0.5
cnt = 0
n = int(eval(input()))
XY = [list(map(int, input().split())) for _ in range(n)]
for l in permutations(XY):
for i in range(n-1):
cnt += d(l[i], l[i+1])
cnt /= factorial(n)
print(cnt) | 13 | 15 | 296 | 345 | import math
import itertools
n = int(eval(input()))
xy = [list(map(int, input().split())) for _ in range(n)]
p = itertools.permutations(xy, n)
c = 0
for i in p:
for j in range(n - 1):
c += ((i[j][0] - i[j + 1][0]) ** 2 + (i[j][1] - i[j + 1][1]) ** 2) ** 0.5
l = math.factorial(n)
print((c / l))
| from itertools import permutations
from math import factorial
def d(a, b):
x1, y1 = a
x2, y2 = b
return ((x1 - x2) ** 2 + (y1 - y2) ** 2) ** 0.5
cnt = 0
n = int(eval(input()))
XY = [list(map(int, input().split())) for _ in range(n)]
for l in permutations(XY):
for i in range(n - 1):
cnt += d(l[i], l[i + 1])
cnt /= factorial(n)
print(cnt)
| false | 13.333333 | [
"-import math",
"-import itertools",
"+from itertools import permutations",
"+from math import factorial",
"+",
"+def d(a, b):",
"+ x1, y1 = a",
"+ x2, y2 = b",
"+ return ((x1 - x2) ** 2 + (y1 - y2) ** 2) ** 0.5",
"+",
"+",
"+cnt = 0",
"-xy = [list(map(int, input().split())) for _ in range(n)]",
"-p = itertools.permutations(xy, n)",
"-c = 0",
"-for i in p:",
"- for j in range(n - 1):",
"- c += ((i[j][0] - i[j + 1][0]) ** 2 + (i[j][1] - i[j + 1][1]) ** 2) ** 0.5",
"-l = math.factorial(n)",
"-print((c / l))",
"+XY = [list(map(int, input().split())) for _ in range(n)]",
"+for l in permutations(XY):",
"+ for i in range(n - 1):",
"+ cnt += d(l[i], l[i + 1])",
"+cnt /= factorial(n)",
"+print(cnt)"
] | false | 0.041314 | 0.0394 | 1.048573 | [
"s806754016",
"s751086977"
] |
u699296734 | p02714 | python | s469000725 | s716275591 | 193 | 174 | 69,228 | 74,860 | Accepted | Accepted | 9.84 | a=int(eval(input()))
moji=eval(input())
r=set()
g=set()
b=set()
for i in range(a):
if moji[i]=="R":
r.add(i)
elif moji[i]=="G":
g.add(i)
else:
b.add(i)
res=len(r)*len(g)*len(b)
if len(r)==0 or len(g)==0 or len(b)==0:
print((0))
else:
min_len={0:r,1:g,2:b}
a1=[]
for i in range(3):
a1.append(min_len[i])
for i in a1[0]:
for j in a1[1]:
if -abs(i-j)+min(i,j) in a1[2]:
res-=1
if abs(i-j)+max(i,j) in a1[2]:
res-=1
if abs(i-j)%2==0 and int(abs(i-j)/2)+min(i,j) in a1[2]:
res-=1
print(res)
| a=int(eval(input()))
moji=eval(input())
r=[]
g=[]
b=[]
for i in range(a):
if moji[i]=="R":
r.append(i)
elif moji[i]=="G":
g.append(i)
else:
b.append(i)
res=len(r)*len(g)*len(b)
if len(r)==0 or len(g)==0 or len(b)==0:
print((0))
else:
min_len={0:r,1:g,2:b}
if len(min_len[0])>len(min_len[1]):
tmp=min_len[0]
min_len[0]=min_len[1]
min_len[1]=tmp
if len(min_len[1])>len(min_len[2]):
tmp=min_len[1]
min_len[1]=min_len[2]
min_len[2]=tmp
if len(min_len[0])>len(min_len[1]):
tmp=min_len[0]
min_len[0]=min_len[1]
min_len[1]=tmp
a1=[]
for i in range(3):
a1.append(min_len[i])
A=set(a1[0])
B=set(a1[1])
C=set(a1[2])
for i in A:
for j in B:
if -abs(i-j)+min(i,j) in C:
res-=1
if abs(i-j)+max(i,j) in C:
res-=1
if abs(i-j)%2==0 and int(abs(i-j)/2)+min(i,j) in C:
res-=1
print(res)
| 31 | 44 | 653 | 1,055 | a = int(eval(input()))
moji = eval(input())
r = set()
g = set()
b = set()
for i in range(a):
if moji[i] == "R":
r.add(i)
elif moji[i] == "G":
g.add(i)
else:
b.add(i)
res = len(r) * len(g) * len(b)
if len(r) == 0 or len(g) == 0 or len(b) == 0:
print((0))
else:
min_len = {0: r, 1: g, 2: b}
a1 = []
for i in range(3):
a1.append(min_len[i])
for i in a1[0]:
for j in a1[1]:
if -abs(i - j) + min(i, j) in a1[2]:
res -= 1
if abs(i - j) + max(i, j) in a1[2]:
res -= 1
if abs(i - j) % 2 == 0 and int(abs(i - j) / 2) + min(i, j) in a1[2]:
res -= 1
print(res)
| a = int(eval(input()))
moji = eval(input())
r = []
g = []
b = []
for i in range(a):
if moji[i] == "R":
r.append(i)
elif moji[i] == "G":
g.append(i)
else:
b.append(i)
res = len(r) * len(g) * len(b)
if len(r) == 0 or len(g) == 0 or len(b) == 0:
print((0))
else:
min_len = {0: r, 1: g, 2: b}
if len(min_len[0]) > len(min_len[1]):
tmp = min_len[0]
min_len[0] = min_len[1]
min_len[1] = tmp
if len(min_len[1]) > len(min_len[2]):
tmp = min_len[1]
min_len[1] = min_len[2]
min_len[2] = tmp
if len(min_len[0]) > len(min_len[1]):
tmp = min_len[0]
min_len[0] = min_len[1]
min_len[1] = tmp
a1 = []
for i in range(3):
a1.append(min_len[i])
A = set(a1[0])
B = set(a1[1])
C = set(a1[2])
for i in A:
for j in B:
if -abs(i - j) + min(i, j) in C:
res -= 1
if abs(i - j) + max(i, j) in C:
res -= 1
if abs(i - j) % 2 == 0 and int(abs(i - j) / 2) + min(i, j) in C:
res -= 1
print(res)
| false | 29.545455 | [
"-r = set()",
"-g = set()",
"-b = set()",
"+r = []",
"+g = []",
"+b = []",
"- r.add(i)",
"+ r.append(i)",
"- g.add(i)",
"+ g.append(i)",
"- b.add(i)",
"+ b.append(i)",
"+ if len(min_len[0]) > len(min_len[1]):",
"+ tmp = min_len[0]",
"+ min_len[0] = min_len[1]",
"+ min_len[1] = tmp",
"+ if len(min_len[1]) > len(min_len[2]):",
"+ tmp = min_len[1]",
"+ min_len[1] = min_len[2]",
"+ min_len[2] = tmp",
"+ if len(min_len[0]) > len(min_len[1]):",
"+ tmp = min_len[0]",
"+ min_len[0] = min_len[1]",
"+ min_len[1] = tmp",
"- for i in a1[0]:",
"- for j in a1[1]:",
"- if -abs(i - j) + min(i, j) in a1[2]:",
"+ A = set(a1[0])",
"+ B = set(a1[1])",
"+ C = set(a1[2])",
"+ for i in A:",
"+ for j in B:",
"+ if -abs(i - j) + min(i, j) in C:",
"- if abs(i - j) + max(i, j) in a1[2]:",
"+ if abs(i - j) + max(i, j) in C:",
"- if abs(i - j) % 2 == 0 and int(abs(i - j) / 2) + min(i, j) in a1[2]:",
"+ if abs(i - j) % 2 == 0 and int(abs(i - j) / 2) + min(i, j) in C:"
] | false | 0.039973 | 0.038978 | 1.025513 | [
"s469000725",
"s716275591"
] |
u024807881 | p03062 | python | s872695369 | s974926426 | 79 | 54 | 11,396 | 14,116 | Accepted | Accepted | 31.65 | from sys import stdin
readline = stdin.readline
n = readline()
aa = list(map(int, readline().split()))
r = 0
mi = 1000000000
m = 0
for a in aa:
if a < 0:
m += 1
b = abs(a)
r += b
if b < mi:
mi = b
print((r - mi * 2 * (m % 2)))
| def main():
_, *aa = list(map(int, open(0).read().split()))
bb = tuple(map(abs, aa))
m = tuple(a for a in aa if a < 0)
print((sum(bb) - min(bb)*2*(len(m)%2)))
if __name__ == "__main__":
main() | 17 | 10 | 269 | 219 | from sys import stdin
readline = stdin.readline
n = readline()
aa = list(map(int, readline().split()))
r = 0
mi = 1000000000
m = 0
for a in aa:
if a < 0:
m += 1
b = abs(a)
r += b
if b < mi:
mi = b
print((r - mi * 2 * (m % 2)))
| def main():
_, *aa = list(map(int, open(0).read().split()))
bb = tuple(map(abs, aa))
m = tuple(a for a in aa if a < 0)
print((sum(bb) - min(bb) * 2 * (len(m) % 2)))
if __name__ == "__main__":
main()
| false | 41.176471 | [
"-from sys import stdin",
"+def main():",
"+ _, *aa = list(map(int, open(0).read().split()))",
"+ bb = tuple(map(abs, aa))",
"+ m = tuple(a for a in aa if a < 0)",
"+ print((sum(bb) - min(bb) * 2 * (len(m) % 2)))",
"-readline = stdin.readline",
"-n = readline()",
"-aa = list(map(int, readline().split()))",
"-r = 0",
"-mi = 1000000000",
"-m = 0",
"-for a in aa:",
"- if a < 0:",
"- m += 1",
"- b = abs(a)",
"- r += b",
"- if b < mi:",
"- mi = b",
"-print((r - mi * 2 * (m % 2)))",
"+",
"+if __name__ == \"__main__\":",
"+ main()"
] | false | 0.036082 | 0.060754 | 0.593911 | [
"s872695369",
"s974926426"
] |
u608088992 | p02891 | python | s972945337 | s357621495 | 22 | 17 | 3,444 | 3,064 | Accepted | Accepted | 22.73 | import sys, collections, copy
def solve():
S = list(eval(input()))
S2 = copy.deepcopy(S)
K = int(eval(input()))
lens = len(S)
head_change = 0
for i in range(1, lens):
if S[i] == S[i - 1]:
head_change += 1
S[i] = "Changed"
inner_change = 1
S2[0] = "Changed"
for i in range(1, lens):
if S2[i] == S2[i-1]:
inner_change += 1
S2[i] = "Changed"
if lens == 1: print((K // 2))
elif S[lens-1] != "Changed" and S[0] == S[lens - 1]:
if S2[lens-1] != "Changed":
print((head_change + inner_change * (K - 1)))
else:
print(((head_change + inner_change) * (K // 2) + head_change * (K % 2)))
else:
print((head_change * K))
#print(S)
return 0
if __name__ == "__main__":
solve() | import sys
def solve():
input = sys.stdin.readline
S = list(input().strip("\n"))
K = int(eval(input()))
N = len(S)
head, tail, joint = 0, 0, 0
inside = 0
if S[0] == S[N-1]: #ジョイント部を考える必要がある場合
isInitial = True
current = S[0]
currentLength = 1
for i in range(1, N):
if S[i] == current: currentLength += 1
else:
if isInitial:
head = currentLength // 2
isInitial = False
else: inside += currentLength // 2
current = S[i]
currentLength = 1
if isInitial: #全て同じ文字の場合
totalLength = N * K
print((totalLength // 2))
else:
tail = currentLength // 2
for i in range(N):
if S[i] == current: currentLength += 1
else:
joint = currentLength // 2
break
print((head + tail + joint * (K - 1) + inside * K))
else:
current = S[0]
currentLength = 1
for i in range(1, N):
if S[i] == current: currentLength += 1
else:
inside += currentLength // 2
current = S[i]
currentLength = 1
inside += currentLength // 2
print((inside * K))
#print(head, tail, joint, inside)
return 0
if __name__ == "__main__":
solve() | 34 | 49 | 853 | 1,496 | import sys, collections, copy
def solve():
S = list(eval(input()))
S2 = copy.deepcopy(S)
K = int(eval(input()))
lens = len(S)
head_change = 0
for i in range(1, lens):
if S[i] == S[i - 1]:
head_change += 1
S[i] = "Changed"
inner_change = 1
S2[0] = "Changed"
for i in range(1, lens):
if S2[i] == S2[i - 1]:
inner_change += 1
S2[i] = "Changed"
if lens == 1:
print((K // 2))
elif S[lens - 1] != "Changed" and S[0] == S[lens - 1]:
if S2[lens - 1] != "Changed":
print((head_change + inner_change * (K - 1)))
else:
print(((head_change + inner_change) * (K // 2) + head_change * (K % 2)))
else:
print((head_change * K))
# print(S)
return 0
if __name__ == "__main__":
solve()
| import sys
def solve():
input = sys.stdin.readline
S = list(input().strip("\n"))
K = int(eval(input()))
N = len(S)
head, tail, joint = 0, 0, 0
inside = 0
if S[0] == S[N - 1]: # ジョイント部を考える必要がある場合
isInitial = True
current = S[0]
currentLength = 1
for i in range(1, N):
if S[i] == current:
currentLength += 1
else:
if isInitial:
head = currentLength // 2
isInitial = False
else:
inside += currentLength // 2
current = S[i]
currentLength = 1
if isInitial: # 全て同じ文字の場合
totalLength = N * K
print((totalLength // 2))
else:
tail = currentLength // 2
for i in range(N):
if S[i] == current:
currentLength += 1
else:
joint = currentLength // 2
break
print((head + tail + joint * (K - 1) + inside * K))
else:
current = S[0]
currentLength = 1
for i in range(1, N):
if S[i] == current:
currentLength += 1
else:
inside += currentLength // 2
current = S[i]
currentLength = 1
inside += currentLength // 2
print((inside * K))
# print(head, tail, joint, inside)
return 0
if __name__ == "__main__":
solve()
| false | 30.612245 | [
"-import sys, collections, copy",
"+import sys",
"- S = list(eval(input()))",
"- S2 = copy.deepcopy(S)",
"+ input = sys.stdin.readline",
"+ S = list(input().strip(\"\\n\"))",
"- lens = len(S)",
"- head_change = 0",
"- for i in range(1, lens):",
"- if S[i] == S[i - 1]:",
"- head_change += 1",
"- S[i] = \"Changed\"",
"- inner_change = 1",
"- S2[0] = \"Changed\"",
"- for i in range(1, lens):",
"- if S2[i] == S2[i - 1]:",
"- inner_change += 1",
"- S2[i] = \"Changed\"",
"- if lens == 1:",
"- print((K // 2))",
"- elif S[lens - 1] != \"Changed\" and S[0] == S[lens - 1]:",
"- if S2[lens - 1] != \"Changed\":",
"- print((head_change + inner_change * (K - 1)))",
"+ N = len(S)",
"+ head, tail, joint = 0, 0, 0",
"+ inside = 0",
"+ if S[0] == S[N - 1]: # ジョイント部を考える必要がある場合",
"+ isInitial = True",
"+ current = S[0]",
"+ currentLength = 1",
"+ for i in range(1, N):",
"+ if S[i] == current:",
"+ currentLength += 1",
"+ else:",
"+ if isInitial:",
"+ head = currentLength // 2",
"+ isInitial = False",
"+ else:",
"+ inside += currentLength // 2",
"+ current = S[i]",
"+ currentLength = 1",
"+ if isInitial: # 全て同じ文字の場合",
"+ totalLength = N * K",
"+ print((totalLength // 2))",
"- print(((head_change + inner_change) * (K // 2) + head_change * (K % 2)))",
"+ tail = currentLength // 2",
"+ for i in range(N):",
"+ if S[i] == current:",
"+ currentLength += 1",
"+ else:",
"+ joint = currentLength // 2",
"+ break",
"+ print((head + tail + joint * (K - 1) + inside * K))",
"- print((head_change * K))",
"- # print(S)",
"+ current = S[0]",
"+ currentLength = 1",
"+ for i in range(1, N):",
"+ if S[i] == current:",
"+ currentLength += 1",
"+ else:",
"+ inside += currentLength // 2",
"+ current = S[i]",
"+ currentLength = 1",
"+ inside += currentLength // 2",
"+ print((inside * K))",
"+ # print(head, tail, joint, inside)"
] | false | 0.107065 | 0.037289 | 2.871205 | [
"s972945337",
"s357621495"
] |
u094191970 | p02554 | python | s655955949 | s020131519 | 31 | 28 | 9,092 | 9,108 | Accepted | Accepted | 9.68 | n=int(eval(input()))
mod=10**9+7
ans=pow(10,n,mod)
ans-=pow(9,n,mod)*2
ans+=pow(8,n,mod)
print((ans%mod)) | n=int(eval(input()))
mod=10**9+7
ans=pow(10,n,mod)-pow(9,n,mod)*2+pow(8,n,mod)
print((ans%mod)) | 6 | 4 | 102 | 90 | n = int(eval(input()))
mod = 10**9 + 7
ans = pow(10, n, mod)
ans -= pow(9, n, mod) * 2
ans += pow(8, n, mod)
print((ans % mod))
| n = int(eval(input()))
mod = 10**9 + 7
ans = pow(10, n, mod) - pow(9, n, mod) * 2 + pow(8, n, mod)
print((ans % mod))
| false | 33.333333 | [
"-ans = pow(10, n, mod)",
"-ans -= pow(9, n, mod) * 2",
"-ans += pow(8, n, mod)",
"+ans = pow(10, n, mod) - pow(9, n, mod) * 2 + pow(8, n, mod)"
] | false | 0.0362 | 0.036395 | 0.994655 | [
"s655955949",
"s020131519"
] |
u460386402 | p02572 | python | s445824953 | s990017822 | 156 | 127 | 31,500 | 31,672 | Accepted | Accepted | 18.59 | n=int(eval(input()))
a=list(map(int,input().split()))
s=sum(a)
ans=0
for i in range(n-1):
s-=a[i]
ans+=a[i]*s
if ans>(10**9+7):
ans=ans%(10**9+7)
print(ans) | n=int(eval(input()))
a=list(map(int,input().split()))
s=sum(a)
ans=0
for i in range(n-1):
s-=a[i]
ans+=a[i]*s
print((ans%(10**9+7)))
| 10 | 8 | 169 | 136 | n = int(eval(input()))
a = list(map(int, input().split()))
s = sum(a)
ans = 0
for i in range(n - 1):
s -= a[i]
ans += a[i] * s
if ans > (10**9 + 7):
ans = ans % (10**9 + 7)
print(ans)
| n = int(eval(input()))
a = list(map(int, input().split()))
s = sum(a)
ans = 0
for i in range(n - 1):
s -= a[i]
ans += a[i] * s
print((ans % (10**9 + 7)))
| false | 20 | [
"- if ans > (10**9 + 7):",
"- ans = ans % (10**9 + 7)",
"-print(ans)",
"+print((ans % (10**9 + 7)))"
] | false | 0.036226 | 0.036916 | 0.981315 | [
"s445824953",
"s990017822"
] |
u533074609 | p02760 | python | s719949614 | s276689789 | 20 | 18 | 3,064 | 3,064 | Accepted | Accepted | 10 | bingo = [list(map(int, input().split())) for i in range(3)]
n = int(eval(input()))
nums = [int(eval(input())) for i in range(n)]
res = 'No'
for num in nums:
for i in range(3):
if num in bingo[i]:
j = bingo[i].index(num)
bingo[i][j] = 0
if sum(bingo[i]) == 0 or sum([row[j] for row in bingo]) == 0:
res = 'Yes'
elif (i + j) % 2 == 0:
if i + j == 2 and sum([bingo[0][2], bingo[1][1], bingo[2][0]]) == 0:
res = 'Yes'
elif i == j and sum([bingo[0][0], bingo[1][1], bingo[2][2]]) == 0:
res = 'Yes'
break
if res == 'Yes':
break
print(res) | bingo = [list(map(int, input().split())) for i in range(3)]
n = int(eval(input()))
for i in range(n):
num = int(eval(input()))
for j in range(3):
for k in range(3):
if bingo[j][k] == num:
bingo[j][k] = 0
break;
res = 'No'
for i in range(3):
if bingo[i][0] == bingo[i][1] == bingo[i][2] == 0:
res = 'Yes'
break
elif bingo[0][i] == bingo[1][i] == bingo[2][i] == 0:
res = 'Yes'
break
if bingo[0][2] == bingo[1][1] == bingo[2][0] == 0:
res = 'Yes'
elif bingo[0][0] == bingo[1][1] == bingo[2][2] == 0:
res = 'Yes'
print(res) | 20 | 22 | 711 | 636 | bingo = [list(map(int, input().split())) for i in range(3)]
n = int(eval(input()))
nums = [int(eval(input())) for i in range(n)]
res = "No"
for num in nums:
for i in range(3):
if num in bingo[i]:
j = bingo[i].index(num)
bingo[i][j] = 0
if sum(bingo[i]) == 0 or sum([row[j] for row in bingo]) == 0:
res = "Yes"
elif (i + j) % 2 == 0:
if i + j == 2 and sum([bingo[0][2], bingo[1][1], bingo[2][0]]) == 0:
res = "Yes"
elif i == j and sum([bingo[0][0], bingo[1][1], bingo[2][2]]) == 0:
res = "Yes"
break
if res == "Yes":
break
print(res)
| bingo = [list(map(int, input().split())) for i in range(3)]
n = int(eval(input()))
for i in range(n):
num = int(eval(input()))
for j in range(3):
for k in range(3):
if bingo[j][k] == num:
bingo[j][k] = 0
break
res = "No"
for i in range(3):
if bingo[i][0] == bingo[i][1] == bingo[i][2] == 0:
res = "Yes"
break
elif bingo[0][i] == bingo[1][i] == bingo[2][i] == 0:
res = "Yes"
break
if bingo[0][2] == bingo[1][1] == bingo[2][0] == 0:
res = "Yes"
elif bingo[0][0] == bingo[1][1] == bingo[2][2] == 0:
res = "Yes"
print(res)
| false | 9.090909 | [
"-nums = [int(eval(input())) for i in range(n)]",
"+for i in range(n):",
"+ num = int(eval(input()))",
"+ for j in range(3):",
"+ for k in range(3):",
"+ if bingo[j][k] == num:",
"+ bingo[j][k] = 0",
"+ break",
"-for num in nums:",
"- for i in range(3):",
"- if num in bingo[i]:",
"- j = bingo[i].index(num)",
"- bingo[i][j] = 0",
"- if sum(bingo[i]) == 0 or sum([row[j] for row in bingo]) == 0:",
"- res = \"Yes\"",
"- elif (i + j) % 2 == 0:",
"- if i + j == 2 and sum([bingo[0][2], bingo[1][1], bingo[2][0]]) == 0:",
"- res = \"Yes\"",
"- elif i == j and sum([bingo[0][0], bingo[1][1], bingo[2][2]]) == 0:",
"- res = \"Yes\"",
"- break",
"- if res == \"Yes\":",
"+for i in range(3):",
"+ if bingo[i][0] == bingo[i][1] == bingo[i][2] == 0:",
"+ res = \"Yes\"",
"+ elif bingo[0][i] == bingo[1][i] == bingo[2][i] == 0:",
"+ res = \"Yes\"",
"+ break",
"+if bingo[0][2] == bingo[1][1] == bingo[2][0] == 0:",
"+ res = \"Yes\"",
"+elif bingo[0][0] == bingo[1][1] == bingo[2][2] == 0:",
"+ res = \"Yes\""
] | false | 0.047273 | 0.042105 | 1.122738 | [
"s719949614",
"s276689789"
] |
u625007136 | p02683 | python | s296924715 | s682225342 | 68 | 62 | 9,112 | 9,252 | Accepted | Accepted | 8.82 | import sys
input = sys.stdin.readline
import math
def bit_check(n,m,x,c,a):
mx = 2**n
bit = n
acc_m = 10**9 + 1
for i in range(1,mx):
acc_u = [0] * m
can = 0
for b in range(bit):
r = i & (1 << b)
#print(x,type(x))
if r != 0:
v = int(math.log2(r))
#print(i,(1 <<b ),v,c[v])
for j in range(m):
acc_u[j] += a[v][j]
can += c[v]
#print(can,acc_u)
#print(all([s >= 10 for s in acc_u]))
if can < acc_m and all([s >= x for s in acc_u]):
acc_m = can
if acc_m > 10**9:
return -1
else:
return acc_m
if __name__ == "__main__":
n,m,x = list(map(int,input().split()))
c = []
a = []
for i in range(n):
ca = list(map(int,input().split()))
c.append(ca[0])
a.append(ca[1:])
print((bit_check(n,m,x,c,a)))
| import sys
input = sys.stdin.readline
import math
def skill_up(bit,m,x,c,a):
acc_m = 10**9 + 1
for can,acc_u in aaa(bit,m,x,c,a):
if can < acc_m and all([s >= x for s in acc_u]):
acc_m = can
if acc_m > 10**9:
return -1
else:
return acc_m
def aaa(bit,m,x,c,a):
mx = 2**bit
for i in range(1,mx):
acc_u = [0] * m
can = 0
for b in range(bit):
r = i & (1 << b)
#print(x,type(x))
if r != 0:
v = int(math.log2(r))
#print(i,(1 <<b ),v,c[v])
for j in range(m):
acc_u[j] += a[v][j]
can += c[v]
#print(can,acc_u)
#print(all([s >= 10 for s in acc_u]))
yield can,acc_u
if __name__ == "__main__":
n,m,x = list(map(int,input().split()))
c = []
a = []
for i in range(n):
ca = list(map(int,input().split()))
c.append(ca[0])
a.append(ca[1:])
#print(bit_check(n,m,x,c,a))
print((skill_up(n,m,x,c,a)))
| 40 | 45 | 989 | 1,100 | import sys
input = sys.stdin.readline
import math
def bit_check(n, m, x, c, a):
mx = 2**n
bit = n
acc_m = 10**9 + 1
for i in range(1, mx):
acc_u = [0] * m
can = 0
for b in range(bit):
r = i & (1 << b)
# print(x,type(x))
if r != 0:
v = int(math.log2(r))
# print(i,(1 <<b ),v,c[v])
for j in range(m):
acc_u[j] += a[v][j]
can += c[v]
# print(can,acc_u)
# print(all([s >= 10 for s in acc_u]))
if can < acc_m and all([s >= x for s in acc_u]):
acc_m = can
if acc_m > 10**9:
return -1
else:
return acc_m
if __name__ == "__main__":
n, m, x = list(map(int, input().split()))
c = []
a = []
for i in range(n):
ca = list(map(int, input().split()))
c.append(ca[0])
a.append(ca[1:])
print((bit_check(n, m, x, c, a)))
| import sys
input = sys.stdin.readline
import math
def skill_up(bit, m, x, c, a):
acc_m = 10**9 + 1
for can, acc_u in aaa(bit, m, x, c, a):
if can < acc_m and all([s >= x for s in acc_u]):
acc_m = can
if acc_m > 10**9:
return -1
else:
return acc_m
def aaa(bit, m, x, c, a):
mx = 2**bit
for i in range(1, mx):
acc_u = [0] * m
can = 0
for b in range(bit):
r = i & (1 << b)
# print(x,type(x))
if r != 0:
v = int(math.log2(r))
# print(i,(1 <<b ),v,c[v])
for j in range(m):
acc_u[j] += a[v][j]
can += c[v]
# print(can,acc_u)
# print(all([s >= 10 for s in acc_u]))
yield can, acc_u
if __name__ == "__main__":
n, m, x = list(map(int, input().split()))
c = []
a = []
for i in range(n):
ca = list(map(int, input().split()))
c.append(ca[0])
a.append(ca[1:])
# print(bit_check(n,m,x,c,a))
print((skill_up(n, m, x, c, a)))
| false | 11.111111 | [
"-def bit_check(n, m, x, c, a):",
"- mx = 2**n",
"- bit = n",
"+def skill_up(bit, m, x, c, a):",
"+ for can, acc_u in aaa(bit, m, x, c, a):",
"+ if can < acc_m and all([s >= x for s in acc_u]):",
"+ acc_m = can",
"+ if acc_m > 10**9:",
"+ return -1",
"+ else:",
"+ return acc_m",
"+",
"+",
"+def aaa(bit, m, x, c, a):",
"+ mx = 2**bit",
"- if can < acc_m and all([s >= x for s in acc_u]):",
"- acc_m = can",
"- if acc_m > 10**9:",
"- return -1",
"- else:",
"- return acc_m",
"+ yield can, acc_u",
"- print((bit_check(n, m, x, c, a)))",
"+ # print(bit_check(n,m,x,c,a))",
"+ print((skill_up(n, m, x, c, a)))"
] | false | 0.007328 | 0.044687 | 0.163976 | [
"s296924715",
"s682225342"
] |
u793868662 | p03545 | python | s409802726 | s384916684 | 181 | 162 | 38,512 | 38,256 | Accepted | Accepted | 10.5 | def resolve():
s = eval(input())
a = s[0]
b = s[1]
c = s[2]
d = s[3]
for i in range(8):
op1 = "+" if i>>0 & 1 else "-"
op2 = "+" if i>>1 & 1 else "-"
op3 = "+" if i>>2 & 1 else "-"
test = a + op1 + b + op2 + c + op3 + d
if eval(test) == 7:
print((test + "=7"))
exit()
resolve() | def resolve():
s = eval(input())
def dfs(i, f):
if i == 3:
return f.split(",")
return dfs(i+1, f + "+" + s[i+1]) + dfs(i+1, f + "-" + s[i+1])
for i in dfs(0, s[0]):
if eval(i) == 7:
print((i + "=7"))
exit()
resolve() | 16 | 12 | 373 | 292 | def resolve():
s = eval(input())
a = s[0]
b = s[1]
c = s[2]
d = s[3]
for i in range(8):
op1 = "+" if i >> 0 & 1 else "-"
op2 = "+" if i >> 1 & 1 else "-"
op3 = "+" if i >> 2 & 1 else "-"
test = a + op1 + b + op2 + c + op3 + d
if eval(test) == 7:
print((test + "=7"))
exit()
resolve()
| def resolve():
s = eval(input())
def dfs(i, f):
if i == 3:
return f.split(",")
return dfs(i + 1, f + "+" + s[i + 1]) + dfs(i + 1, f + "-" + s[i + 1])
for i in dfs(0, s[0]):
if eval(i) == 7:
print((i + "=7"))
exit()
resolve()
| false | 25 | [
"- a = s[0]",
"- b = s[1]",
"- c = s[2]",
"- d = s[3]",
"- for i in range(8):",
"- op1 = \"+\" if i >> 0 & 1 else \"-\"",
"- op2 = \"+\" if i >> 1 & 1 else \"-\"",
"- op3 = \"+\" if i >> 2 & 1 else \"-\"",
"- test = a + op1 + b + op2 + c + op3 + d",
"- if eval(test) == 7:",
"- print((test + \"=7\"))",
"+",
"+ def dfs(i, f):",
"+ if i == 3:",
"+ return f.split(\",\")",
"+ return dfs(i + 1, f + \"+\" + s[i + 1]) + dfs(i + 1, f + \"-\" + s[i + 1])",
"+",
"+ for i in dfs(0, s[0]):",
"+ if eval(i) == 7:",
"+ print((i + \"=7\"))"
] | false | 0.036671 | 0.046841 | 0.782882 | [
"s409802726",
"s384916684"
] |
u706414019 | p03472 | python | s488967531 | s156974505 | 269 | 149 | 33,116 | 14,680 | Accepted | Accepted | 44.61 | import sys,math
import numpy as np
input = sys.stdin.readline
a_max=0
a = []
b = []
N,H = list(map(int,input().split()))
for i in range(N):
an,bn = list(map(int,input().split()))
b.append(bn)
a_max = max(a_max,an)
b = np.array(b)
b = sorted(list(b[b>=a_max]))
cnt = 0
for i in range(len(b)):
H -= b.pop()
cnt += 1
if H <=0:
print(cnt)
exit()
cnt += math.ceil(H/a_max)
print(cnt)
| import sys,math
input = sys.stdin.readline
a_max=0
b = []
N,H = list(map(int,input().split()))
for i in range(N):
an,bn = list(map(int,input().split()))
b.append(bn)
a_max = max(a_max,an)
b = sorted([ bn for bn in b if bn>=a_max])
cnt = 0
for i in range(len(b)):
H -= b.pop()
cnt += 1
if H <=0:
print(cnt)
exit()
cnt += math.ceil(H/a_max)
print(cnt) | 26 | 22 | 436 | 401 | import sys, math
import numpy as np
input = sys.stdin.readline
a_max = 0
a = []
b = []
N, H = list(map(int, input().split()))
for i in range(N):
an, bn = list(map(int, input().split()))
b.append(bn)
a_max = max(a_max, an)
b = np.array(b)
b = sorted(list(b[b >= a_max]))
cnt = 0
for i in range(len(b)):
H -= b.pop()
cnt += 1
if H <= 0:
print(cnt)
exit()
cnt += math.ceil(H / a_max)
print(cnt)
| import sys, math
input = sys.stdin.readline
a_max = 0
b = []
N, H = list(map(int, input().split()))
for i in range(N):
an, bn = list(map(int, input().split()))
b.append(bn)
a_max = max(a_max, an)
b = sorted([bn for bn in b if bn >= a_max])
cnt = 0
for i in range(len(b)):
H -= b.pop()
cnt += 1
if H <= 0:
print(cnt)
exit()
cnt += math.ceil(H / a_max)
print(cnt)
| false | 15.384615 | [
"-import numpy as np",
"-a = []",
"-b = np.array(b)",
"-b = sorted(list(b[b >= a_max]))",
"+b = sorted([bn for bn in b if bn >= a_max])"
] | false | 0.396853 | 0.041644 | 9.529715 | [
"s488967531",
"s156974505"
] |
u597374218 | p03424 | python | s690933973 | s048841899 | 30 | 24 | 8,992 | 9,088 | Accepted | Accepted | 20 | N=eval(input())
S=input().split()
print(("Three" if len(set(S))==3 else "Four")) | N=eval(input())
S=eval(input())
print(("Four" if "Y" in S else "Three")) | 3 | 3 | 74 | 60 | N = eval(input())
S = input().split()
print(("Three" if len(set(S)) == 3 else "Four"))
| N = eval(input())
S = eval(input())
print(("Four" if "Y" in S else "Three"))
| false | 0 | [
"-S = input().split()",
"-print((\"Three\" if len(set(S)) == 3 else \"Four\"))",
"+S = eval(input())",
"+print((\"Four\" if \"Y\" in S else \"Three\"))"
] | false | 0.03783 | 0.039377 | 0.960717 | [
"s690933973",
"s048841899"
] |
u867320886 | p02936 | python | s706678179 | s809072713 | 1,817 | 911 | 49,456 | 94,956 | Accepted | Accepted | 49.86 | n,q=list(map(int,input().split()))
edge=[[] for i in range(n)]
for i in range(n-1):
a,b=list(map(int,input().split()))
edge[a-1].append(b-1)
base_score = [0]*n
for i in range(q):
p,x=list(map(int,input().split()))
base_score[p-1] += x
score=[0]*n
for i,bs in enumerate(base_score):
score[i] = bs
for j in edge[i]:
base_score[j] += bs
print((*score)) | n,q,*abpx=list(map(int,open(0).read().split()))
edge=[[] for i in range(n)]
for a,b in zip(abpx[:-2*q:2],abpx[1:-2*q:2]):
edge[a-1].append(b-1)
edge[b-1].append(a-1)
base_score = [0]*n
for p,x in zip(abpx[-2*q::2],abpx[-2*q+1::2]):
base_score[p-1] += x
score=[0]*n
check=[0]*n
update_n=[0]
check[0] = 1
while update_n:
current_n = update_n.pop()
score[current_n] = base_score[current_n]
for next_n in edge[current_n]:
if check[next_n]:
continue
else:
check[next_n] = 1
base_score[next_n] += base_score[current_n]
update_n += next_n,
print((*score)) | 19 | 26 | 387 | 660 | n, q = list(map(int, input().split()))
edge = [[] for i in range(n)]
for i in range(n - 1):
a, b = list(map(int, input().split()))
edge[a - 1].append(b - 1)
base_score = [0] * n
for i in range(q):
p, x = list(map(int, input().split()))
base_score[p - 1] += x
score = [0] * n
for i, bs in enumerate(base_score):
score[i] = bs
for j in edge[i]:
base_score[j] += bs
print((*score))
| n, q, *abpx = list(map(int, open(0).read().split()))
edge = [[] for i in range(n)]
for a, b in zip(abpx[: -2 * q : 2], abpx[1 : -2 * q : 2]):
edge[a - 1].append(b - 1)
edge[b - 1].append(a - 1)
base_score = [0] * n
for p, x in zip(abpx[-2 * q :: 2], abpx[-2 * q + 1 :: 2]):
base_score[p - 1] += x
score = [0] * n
check = [0] * n
update_n = [0]
check[0] = 1
while update_n:
current_n = update_n.pop()
score[current_n] = base_score[current_n]
for next_n in edge[current_n]:
if check[next_n]:
continue
else:
check[next_n] = 1
base_score[next_n] += base_score[current_n]
update_n += (next_n,)
print((*score))
| false | 26.923077 | [
"-n, q = list(map(int, input().split()))",
"+n, q, *abpx = list(map(int, open(0).read().split()))",
"-for i in range(n - 1):",
"- a, b = list(map(int, input().split()))",
"+for a, b in zip(abpx[: -2 * q : 2], abpx[1 : -2 * q : 2]):",
"+ edge[b - 1].append(a - 1)",
"-for i in range(q):",
"- p, x = list(map(int, input().split()))",
"+for p, x in zip(abpx[-2 * q :: 2], abpx[-2 * q + 1 :: 2]):",
"-for i, bs in enumerate(base_score):",
"- score[i] = bs",
"- for j in edge[i]:",
"- base_score[j] += bs",
"+check = [0] * n",
"+update_n = [0]",
"+check[0] = 1",
"+while update_n:",
"+ current_n = update_n.pop()",
"+ score[current_n] = base_score[current_n]",
"+ for next_n in edge[current_n]:",
"+ if check[next_n]:",
"+ continue",
"+ else:",
"+ check[next_n] = 1",
"+ base_score[next_n] += base_score[current_n]",
"+ update_n += (next_n,)"
] | false | 0.040248 | 0.038255 | 1.052081 | [
"s706678179",
"s809072713"
] |
u398846051 | p03986 | python | s502731417 | s390374564 | 94 | 72 | 3,500 | 5,092 | Accepted | Accepted | 23.4 | X = eval(input())
st = 0
s = 0
t = 0
for x in X:
if x == "S":
st += min(s, t)
if t > 0:
s -= min(s, t)
t = 0
s += 1
elif x == "T" and s > 0:
t += 1
st += min(s, t)
print((len(X) - 2 * st)) | X = eval(input())
s = 0
t = 0
stack = []
for x in X:
if x == "S":
stack.append(x)
elif x == "T" and (len(stack)==0 or stack[-1] == "T"):
stack.append(x)
else:
stack.pop()
print((len(stack))) | 15 | 12 | 258 | 229 | X = eval(input())
st = 0
s = 0
t = 0
for x in X:
if x == "S":
st += min(s, t)
if t > 0:
s -= min(s, t)
t = 0
s += 1
elif x == "T" and s > 0:
t += 1
st += min(s, t)
print((len(X) - 2 * st))
| X = eval(input())
s = 0
t = 0
stack = []
for x in X:
if x == "S":
stack.append(x)
elif x == "T" and (len(stack) == 0 or stack[-1] == "T"):
stack.append(x)
else:
stack.pop()
print((len(stack)))
| false | 20 | [
"-st = 0",
"+stack = []",
"- st += min(s, t)",
"- if t > 0:",
"- s -= min(s, t)",
"- t = 0",
"- s += 1",
"- elif x == \"T\" and s > 0:",
"- t += 1",
"-st += min(s, t)",
"-print((len(X) - 2 * st))",
"+ stack.append(x)",
"+ elif x == \"T\" and (len(stack) == 0 or stack[-1] == \"T\"):",
"+ stack.append(x)",
"+ else:",
"+ stack.pop()",
"+print((len(stack)))"
] | false | 0.042007 | 0.04123 | 1.01884 | [
"s502731417",
"s390374564"
] |
u407160848 | p02698 | python | s130610509 | s766684891 | 1,986 | 1,409 | 366,892 | 366,540 | Accepted | Accepted | 29.05 | from bisect import bisect_left
import sys
sys.setrecursionlimit(10**7)
# input = sys.stdin.readline
# スペース区切りの入力を読み込んで数値リストにして返します。
def get_nums_l():
return [ int(s) for s in input().split(" ")]
def log(*args):
print("DEBUG:", *args, file=sys.stderr)
INF = 999999999999999999999999
n = int(input())
A = [-INF] + get_nums_l()
log(n)
log(A)
edges = [ [] for _ in range(n+1) ]
for _ in range(n-1):
#for line in map(lambda s: s.strip(), sys.stdin.readlines()):
line = input()
log(line)
u,v = map(int, line.split())
edges[u].append(v)
edges[v].append(u)
def dfs(dp, u, p=None):
# log(u)
# log(dp)
# dpの中でA[u]以上の値が入っている最小のindex
i = bisect_left(dp, A[u])
old = dp[i]
dp[i] = A[u]
# 有効値(INF以外)が入っている最大のindex
ans[u] = bisect_left(dp, INF) - 1
for v in edges[u]:
if v == p:
continue
dfs(dp, v, u)
# 巻き戻し
dp[i] = old
# ans[i] = ノード1からノードiへの経路中の最長増加部分列長
ans = [0] * (n+1)
# dp[i] = 最長増加部分列長がiの場合の末尾ノード値の最小
# dp[0]は使用しないので負の無限大を入れておく
dp = [INF] * (n+1)
dp[0] = -INF
dfs(dp, 1, None)
for i in range(1, n+1):
print(ans[i])
| from bisect import bisect_left
import sys
sys.setrecursionlimit(10**7)
input = sys.stdin.readline
# スペース区切りの入力を読み込んで数値リストにして返します。
def get_nums_l():
return [ int(s) for s in input().split(" ")]
def log(*args):
print("DEBUG:", *args, file=sys.stderr)
INF = 999999999999999999999999
n = int(input())
A = [-INF] + get_nums_l()
log(n)
log(A)
edges = [ [] for _ in range(n+1) ]
for _ in range(n-1):
#for line in map(lambda s: s.strip(), sys.stdin.readlines()):
line = input().strip()
log(line)
u,v = map(int, line.split())
edges[u].append(v)
edges[v].append(u)
def dfs(dp, u, p=None):
# log(u)
# log(dp)
# dpの中でA[u]以上の値が入っている最小のindex
i = bisect_left(dp, A[u])
old = dp[i]
dp[i] = A[u]
# 有効値(INF以外)が入っている最大のindex
ans[u] = bisect_left(dp, INF) - 1
for v in edges[u]:
if v == p:
continue
dfs(dp, v, u)
# 巻き戻し
dp[i] = old
# ans[i] = ノード1からノードiへの経路中の最長増加部分列長
ans = [0] * (n+1)
# dp[i] = 最長増加部分列長がiの場合の末尾ノード値の最小
# dp[0]は使用しないので負の無限大を入れておく
dp = [INF] * (n+1)
dp[0] = -INF
dfs(dp, 1, None)
for i in range(1, n+1):
print(ans[i])
| 63 | 63 | 1,191 | 1,197 | from bisect import bisect_left
import sys
sys.setrecursionlimit(10**7)
# input = sys.stdin.readline
# スペース区切りの入力を読み込んで数値リストにして返します。
def get_nums_l():
return [int(s) for s in input().split(" ")]
def log(*args):
print("DEBUG:", *args, file=sys.stderr)
INF = 999999999999999999999999
n = int(input())
A = [-INF] + get_nums_l()
log(n)
log(A)
edges = [[] for _ in range(n + 1)]
for _ in range(n - 1):
# for line in map(lambda s: s.strip(), sys.stdin.readlines()):
line = input()
log(line)
u, v = map(int, line.split())
edges[u].append(v)
edges[v].append(u)
def dfs(dp, u, p=None):
# log(u)
# log(dp)
# dpの中でA[u]以上の値が入っている最小のindex
i = bisect_left(dp, A[u])
old = dp[i]
dp[i] = A[u]
# 有効値(INF以外)が入っている最大のindex
ans[u] = bisect_left(dp, INF) - 1
for v in edges[u]:
if v == p:
continue
dfs(dp, v, u)
# 巻き戻し
dp[i] = old
# ans[i] = ノード1からノードiへの経路中の最長増加部分列長
ans = [0] * (n + 1)
# dp[i] = 最長増加部分列長がiの場合の末尾ノード値の最小
# dp[0]は使用しないので負の無限大を入れておく
dp = [INF] * (n + 1)
dp[0] = -INF
dfs(dp, 1, None)
for i in range(1, n + 1):
print(ans[i])
| from bisect import bisect_left
import sys
sys.setrecursionlimit(10**7)
input = sys.stdin.readline
# スペース区切りの入力を読み込んで数値リストにして返します。
def get_nums_l():
return [int(s) for s in input().split(" ")]
def log(*args):
print("DEBUG:", *args, file=sys.stderr)
INF = 999999999999999999999999
n = int(input())
A = [-INF] + get_nums_l()
log(n)
log(A)
edges = [[] for _ in range(n + 1)]
for _ in range(n - 1):
# for line in map(lambda s: s.strip(), sys.stdin.readlines()):
line = input().strip()
log(line)
u, v = map(int, line.split())
edges[u].append(v)
edges[v].append(u)
def dfs(dp, u, p=None):
# log(u)
# log(dp)
# dpの中でA[u]以上の値が入っている最小のindex
i = bisect_left(dp, A[u])
old = dp[i]
dp[i] = A[u]
# 有効値(INF以外)が入っている最大のindex
ans[u] = bisect_left(dp, INF) - 1
for v in edges[u]:
if v == p:
continue
dfs(dp, v, u)
# 巻き戻し
dp[i] = old
# ans[i] = ノード1からノードiへの経路中の最長増加部分列長
ans = [0] * (n + 1)
# dp[i] = 最長増加部分列長がiの場合の末尾ノード値の最小
# dp[0]は使用しないので負の無限大を入れておく
dp = [INF] * (n + 1)
dp[0] = -INF
dfs(dp, 1, None)
for i in range(1, n + 1):
print(ans[i])
| false | 0 | [
"-# input = sys.stdin.readline",
"+input = sys.stdin.readline",
"- line = input()",
"+ line = input().strip()"
] | false | 0.078767 | 0.037833 | 2.081945 | [
"s130610509",
"s766684891"
] |
u634159866 | p03127 | python | s132147635 | s899886369 | 127 | 68 | 14,228 | 14,252 | Accepted | Accepted | 46.46 | N = int(eval(input()))
A = list(map(int, input().split()))
x=0
key = min(A)
while x==0:
for i in range(N):
if int(A[i]%key)==0:
A[i]=key
else:
A[i]=A[i]%key
if min(A)==key:
print(key)
break
else:
key = min(A) | N = int(eval(input()))
List = list(map(int, input().split()))
while len(List)!=1:
m = min(List)
List = [e%m for e in List]
List = [e for e in List if e>0]
List.append(m)
print(m) | 16 | 10 | 306 | 203 | N = int(eval(input()))
A = list(map(int, input().split()))
x = 0
key = min(A)
while x == 0:
for i in range(N):
if int(A[i] % key) == 0:
A[i] = key
else:
A[i] = A[i] % key
if min(A) == key:
print(key)
break
else:
key = min(A)
| N = int(eval(input()))
List = list(map(int, input().split()))
while len(List) != 1:
m = min(List)
List = [e % m for e in List]
List = [e for e in List if e > 0]
List.append(m)
print(m)
| false | 37.5 | [
"-A = list(map(int, input().split()))",
"-x = 0",
"-key = min(A)",
"-while x == 0:",
"- for i in range(N):",
"- if int(A[i] % key) == 0:",
"- A[i] = key",
"- else:",
"- A[i] = A[i] % key",
"- if min(A) == key:",
"- print(key)",
"- break",
"- else:",
"- key = min(A)",
"+List = list(map(int, input().split()))",
"+while len(List) != 1:",
"+ m = min(List)",
"+ List = [e % m for e in List]",
"+ List = [e for e in List if e > 0]",
"+ List.append(m)",
"+print(m)"
] | false | 0.047029 | 0.007643 | 6.15342 | [
"s132147635",
"s899886369"
] |
u562935282 | p03330 | python | s540529668 | s567668698 | 1,507 | 182 | 7,668 | 5,620 | Accepted | Accepted | 87.92 | def iin(): return int(eval(input()))
def nl(): return list(map(int, input().split()))
def ary(r, c, v): return [[v for _ in range(c)] for _ in range(r)]
N, C = nl()
d = [nl() for _ in range(C)]
c = [nl() for _ in range(N)]
color_count_by_r = []
for i in range(3):
color_count_by_r.append(dict())
for i in range(N):
for j in range(N):
color_count_by_r[(i + j) % 3][c[i][j]] = color_count_by_r[(i + j) % 3].get(c[i][j], 0) + 1
ans = float('inf')
for c0 in range(1, C + 1):
for c1 in range(1, C + 1):
if c0 == c1:
continue
for c2 in range(1, C + 1):
if c0 == c2 or c1 == c2:
continue
cost = 0
for i in range(3):
for j in range(1, C + 1):
next_color = [c0, c1, c2][i]
cost += color_count_by_r[i].get(j, 0) * d[j - 1][next_color - 1]
ans = min(ans, cost)
print(ans) | n, c = list(map(int, input().split()))
D = [list(map(int, input().split())) for _ in range(c)]
C = [list(map(int, input().split())) for _ in range(n)]
for i in range(n):
for j in range(n):
C[i][j] -= 1
cnt_color_by_r = [dict() for _ in range(3)]
for r in range(3):
for clr in range(c):
cnt_color_by_r[r][clr] = 0
for i in range(n):
for j in range(n):
cnt_color_by_r[(i + j) % 3][C[i][j]] += 1
costs = [[0 for _ in range(c)] for _ in range(3)]
for r in range(3):
for after in range(c):
cost = 0
for before in range(c):
cost += D[before][after] * cnt_color_by_r[r][before]
costs[r][after] = cost
cost_r0 = list(sorted([(after, costs[0][after]) for after in range(c)], key=lambda x: x[1]))[:3]
cost_r1 = list(sorted([(after, costs[1][after]) for after in range(c)], key=lambda x: x[1]))[:3]
cost_r2 = list(sorted([(after, costs[2][after]) for after in range(c)], key=lambda x: x[1]))[:3]
ans = float('inf')
for c0, cost0 in cost_r0:
for c1, cost1 in cost_r1:
for c2, cost2 in cost_r2:
if c0 != c1 and c1 != c2 and c2 != c0:
ans = min(ans, cost0 + cost1 + cost2)
print(ans) | 30 | 39 | 954 | 1,226 | def iin():
return int(eval(input()))
def nl():
return list(map(int, input().split()))
def ary(r, c, v):
return [[v for _ in range(c)] for _ in range(r)]
N, C = nl()
d = [nl() for _ in range(C)]
c = [nl() for _ in range(N)]
color_count_by_r = []
for i in range(3):
color_count_by_r.append(dict())
for i in range(N):
for j in range(N):
color_count_by_r[(i + j) % 3][c[i][j]] = (
color_count_by_r[(i + j) % 3].get(c[i][j], 0) + 1
)
ans = float("inf")
for c0 in range(1, C + 1):
for c1 in range(1, C + 1):
if c0 == c1:
continue
for c2 in range(1, C + 1):
if c0 == c2 or c1 == c2:
continue
cost = 0
for i in range(3):
for j in range(1, C + 1):
next_color = [c0, c1, c2][i]
cost += color_count_by_r[i].get(j, 0) * d[j - 1][next_color - 1]
ans = min(ans, cost)
print(ans)
| n, c = list(map(int, input().split()))
D = [list(map(int, input().split())) for _ in range(c)]
C = [list(map(int, input().split())) for _ in range(n)]
for i in range(n):
for j in range(n):
C[i][j] -= 1
cnt_color_by_r = [dict() for _ in range(3)]
for r in range(3):
for clr in range(c):
cnt_color_by_r[r][clr] = 0
for i in range(n):
for j in range(n):
cnt_color_by_r[(i + j) % 3][C[i][j]] += 1
costs = [[0 for _ in range(c)] for _ in range(3)]
for r in range(3):
for after in range(c):
cost = 0
for before in range(c):
cost += D[before][after] * cnt_color_by_r[r][before]
costs[r][after] = cost
cost_r0 = list(
sorted([(after, costs[0][after]) for after in range(c)], key=lambda x: x[1])
)[:3]
cost_r1 = list(
sorted([(after, costs[1][after]) for after in range(c)], key=lambda x: x[1])
)[:3]
cost_r2 = list(
sorted([(after, costs[2][after]) for after in range(c)], key=lambda x: x[1])
)[:3]
ans = float("inf")
for c0, cost0 in cost_r0:
for c1, cost1 in cost_r1:
for c2, cost2 in cost_r2:
if c0 != c1 and c1 != c2 and c2 != c0:
ans = min(ans, cost0 + cost1 + cost2)
print(ans)
| false | 23.076923 | [
"-def iin():",
"- return int(eval(input()))",
"-",
"-",
"-def nl():",
"- return list(map(int, input().split()))",
"-",
"-",
"-def ary(r, c, v):",
"- return [[v for _ in range(c)] for _ in range(r)]",
"-",
"-",
"-N, C = nl()",
"-d = [nl() for _ in range(C)]",
"-c = [nl() for _ in range(N)]",
"-color_count_by_r = []",
"-for i in range(3):",
"- color_count_by_r.append(dict())",
"-for i in range(N):",
"- for j in range(N):",
"- color_count_by_r[(i + j) % 3][c[i][j]] = (",
"- color_count_by_r[(i + j) % 3].get(c[i][j], 0) + 1",
"- )",
"+n, c = list(map(int, input().split()))",
"+D = [list(map(int, input().split())) for _ in range(c)]",
"+C = [list(map(int, input().split())) for _ in range(n)]",
"+for i in range(n):",
"+ for j in range(n):",
"+ C[i][j] -= 1",
"+cnt_color_by_r = [dict() for _ in range(3)]",
"+for r in range(3):",
"+ for clr in range(c):",
"+ cnt_color_by_r[r][clr] = 0",
"+for i in range(n):",
"+ for j in range(n):",
"+ cnt_color_by_r[(i + j) % 3][C[i][j]] += 1",
"+costs = [[0 for _ in range(c)] for _ in range(3)]",
"+for r in range(3):",
"+ for after in range(c):",
"+ cost = 0",
"+ for before in range(c):",
"+ cost += D[before][after] * cnt_color_by_r[r][before]",
"+ costs[r][after] = cost",
"+cost_r0 = list(",
"+ sorted([(after, costs[0][after]) for after in range(c)], key=lambda x: x[1])",
"+)[:3]",
"+cost_r1 = list(",
"+ sorted([(after, costs[1][after]) for after in range(c)], key=lambda x: x[1])",
"+)[:3]",
"+cost_r2 = list(",
"+ sorted([(after, costs[2][after]) for after in range(c)], key=lambda x: x[1])",
"+)[:3]",
"-for c0 in range(1, C + 1):",
"- for c1 in range(1, C + 1):",
"- if c0 == c1:",
"- continue",
"- for c2 in range(1, C + 1):",
"- if c0 == c2 or c1 == c2:",
"- continue",
"- cost = 0",
"- for i in range(3):",
"- for j in range(1, C + 1):",
"- next_color = [c0, c1, c2][i]",
"- cost += color_count_by_r[i].get(j, 0) * d[j - 1][next_color - 1]",
"- ans = min(ans, cost)",
"+for c0, cost0 in cost_r0:",
"+ for c1, cost1 in cost_r1:",
"+ for c2, cost2 in cost_r2:",
"+ if c0 != c1 and c1 != c2 and c2 != c0:",
"+ ans = min(ans, cost0 + cost1 + cost2)"
] | false | 0.063822 | 0.080464 | 0.793169 | [
"s540529668",
"s567668698"
] |
u729133443 | p02889 | python | s862528097 | s660391178 | 441 | 286 | 31,000 | 23,176 | Accepted | Accepted | 35.15 | from scipy.sparse import*
f=csgraph.floyd_warshall
t=list(map(int,open('/dev/fd/0').read().split()))
n,m,l=t[:3]
m=m*3+3
for i in f(f(csr_matrix((t[5:m:3],(t[3:m:3],t[4:m:3])),[n+1]*2),0)<=l)[t[m+1::2],t[m+2::2]].clip(0,n)%n-1:print(i) | def main():
import sys
import numpy as np
from scipy.sparse import csr_matrix
from scipy.sparse.csgraph import floyd_warshall
t=np.fromstring(sys.stdin.buffer.read(),'i',sep=' ')
n,m,l=t[:3]
t=t[3:]
m*=3
print(('\n'.join(map(str,list(map(int,floyd_warshall(floyd_warshall(csr_matrix((t[2:m:3],(t[:m:3],t[1:m:3])),[n+1]*2),0)<=l)[t[m+1::2],t[m+2::2]].clip(0,n)%n-1))))))
main() | 6 | 11 | 233 | 396 | from scipy.sparse import *
f = csgraph.floyd_warshall
t = list(map(int, open("/dev/fd/0").read().split()))
n, m, l = t[:3]
m = m * 3 + 3
for i in (
f(f(csr_matrix((t[5:m:3], (t[3:m:3], t[4:m:3])), [n + 1] * 2), 0) <= l)[
t[m + 1 :: 2], t[m + 2 :: 2]
].clip(0, n)
% n
- 1
):
print(i)
| def main():
import sys
import numpy as np
from scipy.sparse import csr_matrix
from scipy.sparse.csgraph import floyd_warshall
t = np.fromstring(sys.stdin.buffer.read(), "i", sep=" ")
n, m, l = t[:3]
t = t[3:]
m *= 3
print(
(
"\n".join(
map(
str,
list(
map(
int,
floyd_warshall(
floyd_warshall(
csr_matrix(
(t[2:m:3], (t[:m:3], t[1:m:3])), [n + 1] * 2
),
0,
)
<= l
)[t[m + 1 :: 2], t[m + 2 :: 2]].clip(0, n)
% n
- 1,
)
),
)
)
)
)
main()
| false | 45.454545 | [
"-from scipy.sparse import *",
"+def main():",
"+ import sys",
"+ import numpy as np",
"+ from scipy.sparse import csr_matrix",
"+ from scipy.sparse.csgraph import floyd_warshall",
"-f = csgraph.floyd_warshall",
"-t = list(map(int, open(\"/dev/fd/0\").read().split()))",
"-n, m, l = t[:3]",
"-m = m * 3 + 3",
"-for i in (",
"- f(f(csr_matrix((t[5:m:3], (t[3:m:3], t[4:m:3])), [n + 1] * 2), 0) <= l)[",
"- t[m + 1 :: 2], t[m + 2 :: 2]",
"- ].clip(0, n)",
"- % n",
"- - 1",
"-):",
"- print(i)",
"+ t = np.fromstring(sys.stdin.buffer.read(), \"i\", sep=\" \")",
"+ n, m, l = t[:3]",
"+ t = t[3:]",
"+ m *= 3",
"+ print(",
"+ (",
"+ \"\\n\".join(",
"+ map(",
"+ str,",
"+ list(",
"+ map(",
"+ int,",
"+ floyd_warshall(",
"+ floyd_warshall(",
"+ csr_matrix(",
"+ (t[2:m:3], (t[:m:3], t[1:m:3])), [n + 1] * 2",
"+ ),",
"+ 0,",
"+ )",
"+ <= l",
"+ )[t[m + 1 :: 2], t[m + 2 :: 2]].clip(0, n)",
"+ % n",
"+ - 1,",
"+ )",
"+ ),",
"+ )",
"+ )",
"+ )",
"+ )",
"+",
"+",
"+main()"
] | false | 0.66047 | 0.593972 | 1.111955 | [
"s862528097",
"s660391178"
] |
u562935282 | p02947 | python | s234387269 | s628646164 | 569 | 270 | 22,372 | 18,188 | Accepted | Accepted | 52.55 | from collections import defaultdict
n = int(eval(input()))
d = defaultdict(int)
ans = 0
for _ in range(n):
s = eval(input())
s = str(sorted(s))
ans += d[s]
d[s] += 1
print(ans)
| def main():
from collections import defaultdict
import sys
input = sys.stdin.readline
N = int(eval(input()))
d = defaultdict(int)
def string_sort(s):
return ''.join(sorted(s))
ans = 0
for _ in range(N):
s = string_sort(input().rstrip())
ans += d[s]
d[s] += 1
print(ans)
if __name__ == '__main__':
main()
# import sys
#
# sys.setrecursionlimit(10 ** 7)
#
# input = sys.stdin.readline
# rstrip()
# int(input())
# map(int, input().split())
| 12 | 31 | 194 | 540 | from collections import defaultdict
n = int(eval(input()))
d = defaultdict(int)
ans = 0
for _ in range(n):
s = eval(input())
s = str(sorted(s))
ans += d[s]
d[s] += 1
print(ans)
| def main():
from collections import defaultdict
import sys
input = sys.stdin.readline
N = int(eval(input()))
d = defaultdict(int)
def string_sort(s):
return "".join(sorted(s))
ans = 0
for _ in range(N):
s = string_sort(input().rstrip())
ans += d[s]
d[s] += 1
print(ans)
if __name__ == "__main__":
main()
# import sys
#
# sys.setrecursionlimit(10 ** 7)
#
# input = sys.stdin.readline
# rstrip()
# int(input())
# map(int, input().split())
| false | 61.290323 | [
"-from collections import defaultdict",
"+def main():",
"+ from collections import defaultdict",
"+ import sys",
"-n = int(eval(input()))",
"-d = defaultdict(int)",
"-ans = 0",
"-for _ in range(n):",
"- s = eval(input())",
"- s = str(sorted(s))",
"- ans += d[s]",
"- d[s] += 1",
"-print(ans)",
"+ input = sys.stdin.readline",
"+ N = int(eval(input()))",
"+ d = defaultdict(int)",
"+",
"+ def string_sort(s):",
"+ return \"\".join(sorted(s))",
"+",
"+ ans = 0",
"+ for _ in range(N):",
"+ s = string_sort(input().rstrip())",
"+ ans += d[s]",
"+ d[s] += 1",
"+ print(ans)",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ main()",
"+# import sys",
"+#",
"+# sys.setrecursionlimit(10 ** 7)",
"+#",
"+# input = sys.stdin.readline",
"+# rstrip()",
"+# int(input())",
"+# map(int, input().split())"
] | false | 0.066434 | 0.043307 | 1.53401 | [
"s234387269",
"s628646164"
] |
u806403461 | p03338 | python | s226891100 | s681869140 | 20 | 18 | 3,316 | 3,060 | Accepted | Accepted | 10 | n = int(eval(input()))
s = eval(input())
s = list(s)
ans = 0
count = 0
for a in range(1, n):
l1 = list(set(s[:a]))
l2 = list(set(s[a:]))
length1 = len(l1)
for x in range(length1):
if l1[x] in l2:
count += 1
ans = max(ans, count)
count = 0
print(ans)
| n = int(eval(input()))
s = eval(input())
s = list(s)
ans = 0
count = 0
for a in range(1, n):
l1 = list(set(s[:a]))
l2 = set(s[a:])
length1 = len(l1)
for x in range(length1):
if l1[x] in l2:
count += 1
ans = max(ans, count)
count = 0
print(ans)
| 20 | 20 | 306 | 300 | n = int(eval(input()))
s = eval(input())
s = list(s)
ans = 0
count = 0
for a in range(1, n):
l1 = list(set(s[:a]))
l2 = list(set(s[a:]))
length1 = len(l1)
for x in range(length1):
if l1[x] in l2:
count += 1
ans = max(ans, count)
count = 0
print(ans)
| n = int(eval(input()))
s = eval(input())
s = list(s)
ans = 0
count = 0
for a in range(1, n):
l1 = list(set(s[:a]))
l2 = set(s[a:])
length1 = len(l1)
for x in range(length1):
if l1[x] in l2:
count += 1
ans = max(ans, count)
count = 0
print(ans)
| false | 0 | [
"- l2 = list(set(s[a:]))",
"+ l2 = set(s[a:])"
] | false | 0.034384 | 0.035909 | 0.957521 | [
"s226891100",
"s681869140"
] |
u229429359 | p02713 | python | s033821080 | s077114443 | 1,502 | 1,373 | 9,184 | 9,172 | Accepted | Accepted | 8.59 | import math
K =int(eval(input()))
L = [0 for _ in range(K)]
for a in range(1,K+1):
for b in range(1,K+1):
L[math.gcd(a,b)-1] +=1
s = 0
for c in range(1,K+1):
for k in range(K):
for _ in range(L[k]):
s += math.gcd(c,k+1)
print(s) | import math
K = int(eval(input()))
s = 0
for a in range(1,K+1):
for b in range(1,K+1):
x = math.gcd(a,b)
for c in range(1,K+1):
s += math.gcd(x,c)
print(s)
| 12 | 9 | 263 | 174 | import math
K = int(eval(input()))
L = [0 for _ in range(K)]
for a in range(1, K + 1):
for b in range(1, K + 1):
L[math.gcd(a, b) - 1] += 1
s = 0
for c in range(1, K + 1):
for k in range(K):
for _ in range(L[k]):
s += math.gcd(c, k + 1)
print(s)
| import math
K = int(eval(input()))
s = 0
for a in range(1, K + 1):
for b in range(1, K + 1):
x = math.gcd(a, b)
for c in range(1, K + 1):
s += math.gcd(x, c)
print(s)
| false | 25 | [
"-L = [0 for _ in range(K)]",
"+s = 0",
"- L[math.gcd(a, b) - 1] += 1",
"-s = 0",
"-for c in range(1, K + 1):",
"- for k in range(K):",
"- for _ in range(L[k]):",
"- s += math.gcd(c, k + 1)",
"+ x = math.gcd(a, b)",
"+ for c in range(1, K + 1):",
"+ s += math.gcd(x, c)"
] | false | 0.157385 | 0.150494 | 1.045787 | [
"s033821080",
"s077114443"
] |
u015593272 | p02819 | python | s247657523 | s401713477 | 164 | 149 | 13,232 | 12,504 | Accepted | Accepted | 9.15 | import numpy as np
def judge_prime(num):
FLAG = True
for i in range(2, int(np.sqrt(num))+1):
if (num%i == 0):
FLAG = False
if (num == 2):
FLAG = True
return(FLAG)
X = int(eval(input()))
while (True):
flag = judge_prime(X)
if (flag):
break
X += 1
print(X) | import numpy as np
def judge_prime(num):
FLAG = True
# for i in range(2, int(np.sqrt(num))+1):
for i in range(2, int(num**0.5)+1):
if (num%i == 0):
FLAG = False
if (num == 2):
FLAG = True
return(FLAG)
X = int(eval(input()))
while (True):
flag = judge_prime(X)
if (flag):
break
X += 1
print(X) | 25 | 27 | 365 | 410 | import numpy as np
def judge_prime(num):
FLAG = True
for i in range(2, int(np.sqrt(num)) + 1):
if num % i == 0:
FLAG = False
if num == 2:
FLAG = True
return FLAG
X = int(eval(input()))
while True:
flag = judge_prime(X)
if flag:
break
X += 1
print(X)
| import numpy as np
def judge_prime(num):
FLAG = True
# for i in range(2, int(np.sqrt(num))+1):
for i in range(2, int(num**0.5) + 1):
if num % i == 0:
FLAG = False
if num == 2:
FLAG = True
return FLAG
X = int(eval(input()))
while True:
flag = judge_prime(X)
if flag:
break
X += 1
print(X)
| false | 7.407407 | [
"- for i in range(2, int(np.sqrt(num)) + 1):",
"+ # for i in range(2, int(np.sqrt(num))+1):",
"+ for i in range(2, int(num**0.5) + 1):"
] | false | 0.200254 | 0.036882 | 5.429583 | [
"s247657523",
"s401713477"
] |
u107269931 | p02945 | python | s984404377 | s806795754 | 20 | 17 | 3,060 | 2,940 | Accepted | Accepted | 15 | a = list(map(int,input().split()))
x = a[0] + a[1]
y = a[0] - a[1]
z = a[0] * a[1]
if x >= y and x >= z:
print(x)
elif y >= x and y >= z:
print(y)
else:
print(z)
| a = list(map(int,input().split()))
x = a[0] + a[1]
y = a[0] - a[1]
z = a[0] * a[1]
print((max([x,y,z])))
| 14 | 8 | 185 | 113 | a = list(map(int, input().split()))
x = a[0] + a[1]
y = a[0] - a[1]
z = a[0] * a[1]
if x >= y and x >= z:
print(x)
elif y >= x and y >= z:
print(y)
else:
print(z)
| a = list(map(int, input().split()))
x = a[0] + a[1]
y = a[0] - a[1]
z = a[0] * a[1]
print((max([x, y, z])))
| false | 42.857143 | [
"-if x >= y and x >= z:",
"- print(x)",
"-elif y >= x and y >= z:",
"- print(y)",
"-else:",
"- print(z)",
"+print((max([x, y, z])))"
] | false | 0.046298 | 0.049197 | 0.941074 | [
"s984404377",
"s806795754"
] |
u554954744 | p02724 | python | s446187267 | s602480219 | 184 | 161 | 38,384 | 38,384 | Accepted | Accepted | 12.5 | x = int(eval(input()))
ans = 0
ans += x//500 * 1000
x %= 500
ans += x//5 * 5
print(ans) | x = int(eval(input()))
c500 = x//500
x %= 500
c5 = x//5
ans = c500*1000 + c5*5
print(ans) | 7 | 7 | 88 | 90 | x = int(eval(input()))
ans = 0
ans += x // 500 * 1000
x %= 500
ans += x // 5 * 5
print(ans)
| x = int(eval(input()))
c500 = x // 500
x %= 500
c5 = x // 5
ans = c500 * 1000 + c5 * 5
print(ans)
| false | 0 | [
"-ans = 0",
"-ans += x // 500 * 1000",
"+c500 = x // 500",
"-ans += x // 5 * 5",
"+c5 = x // 5",
"+ans = c500 * 1000 + c5 * 5"
] | false | 0.039628 | 0.043124 | 0.91894 | [
"s446187267",
"s602480219"
] |
u724687935 | p02821 | python | s518285926 | s590326494 | 1,268 | 499 | 14,428 | 54,936 | Accepted | Accepted | 60.65 | from bisect import bisect_left
def check(x, m):
# 幸福度が x 以上となる握手が m 通り以上か
cnt = 0
for i in range(N):
y = x - A[i]
p = bisect_left(A, y)
cnt += N - p
return cnt >= m
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
A.sort()
S = [0] * (N + 1)
for i, a in enumerate(A):
S[i + 1] = S[i] + a
ok = 0
ng = 2 * 10 ** 5 + 1
while abs(ok - ng) > 1:
mid = (ok + ng) // 2
if check(mid, M):
ok = mid
else:
ng = mid
X = ok
ans = 0
cnt = 0
amari = 2 * 10 ** 5 + 1
for i in range(N):
Aj = X - A[i]
j = bisect_left(A, Aj)
ans += S[N] - S[j] + A[i] * (N - j)
cnt += N - j
if j < N:
amari = min(amari, A[i] + A[j])
print((ans - (cnt - M) * amari))
| from bisect import bisect_left
def solve(m):
r = N - 1
l = 0
cnt = 0
while 0 <= r and l < N:
if A[r] + A[l] < m:
l += 1
else:
cnt += N - l
r -= 1
return cnt
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
A.sort()
S = [0] * (N + 1)
for i in range(N):
S[i + 1] = S[i] + A[i]
# [ok, ng) - Maximum
# (ng, ok] - Minimum
# ok が 最終的な答え
ok = 0
ng = 10 ** 21
while abs(ok - ng) > 1:
mid = (ok + ng) // 2
cnt = solve(mid)
if cnt >= M:
ok = mid
else:
ng = mid
X = ok
amari = float('inf')
cnt = 0
score = 0
for i, Ai in enumerate(A):
Aj = X - Ai
j = bisect_left(A, Aj)
score += S[N] - S[j] + Ai * (N - j)
cnt += N - j
if j < N:
amari = min(amari, A[i] + A[j])
print((score - (cnt - M) * amari))
| 43 | 49 | 797 | 894 | from bisect import bisect_left
def check(x, m):
# 幸福度が x 以上となる握手が m 通り以上か
cnt = 0
for i in range(N):
y = x - A[i]
p = bisect_left(A, y)
cnt += N - p
return cnt >= m
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
A.sort()
S = [0] * (N + 1)
for i, a in enumerate(A):
S[i + 1] = S[i] + a
ok = 0
ng = 2 * 10**5 + 1
while abs(ok - ng) > 1:
mid = (ok + ng) // 2
if check(mid, M):
ok = mid
else:
ng = mid
X = ok
ans = 0
cnt = 0
amari = 2 * 10**5 + 1
for i in range(N):
Aj = X - A[i]
j = bisect_left(A, Aj)
ans += S[N] - S[j] + A[i] * (N - j)
cnt += N - j
if j < N:
amari = min(amari, A[i] + A[j])
print((ans - (cnt - M) * amari))
| from bisect import bisect_left
def solve(m):
r = N - 1
l = 0
cnt = 0
while 0 <= r and l < N:
if A[r] + A[l] < m:
l += 1
else:
cnt += N - l
r -= 1
return cnt
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
A.sort()
S = [0] * (N + 1)
for i in range(N):
S[i + 1] = S[i] + A[i]
# [ok, ng) - Maximum
# (ng, ok] - Minimum
# ok が 最終的な答え
ok = 0
ng = 10**21
while abs(ok - ng) > 1:
mid = (ok + ng) // 2
cnt = solve(mid)
if cnt >= M:
ok = mid
else:
ng = mid
X = ok
amari = float("inf")
cnt = 0
score = 0
for i, Ai in enumerate(A):
Aj = X - Ai
j = bisect_left(A, Aj)
score += S[N] - S[j] + Ai * (N - j)
cnt += N - j
if j < N:
amari = min(amari, A[i] + A[j])
print((score - (cnt - M) * amari))
| false | 12.244898 | [
"-def check(x, m):",
"- # 幸福度が x 以上となる握手が m 通り以上か",
"+def solve(m):",
"+ r = N - 1",
"+ l = 0",
"- for i in range(N):",
"- y = x - A[i]",
"- p = bisect_left(A, y)",
"- cnt += N - p",
"- return cnt >= m",
"+ while 0 <= r and l < N:",
"+ if A[r] + A[l] < m:",
"+ l += 1",
"+ else:",
"+ cnt += N - l",
"+ r -= 1",
"+ return cnt",
"-for i, a in enumerate(A):",
"- S[i + 1] = S[i] + a",
"+for i in range(N):",
"+ S[i + 1] = S[i] + A[i]",
"+# [ok, ng) - Maximum",
"+# (ng, ok] - Minimum",
"+# ok が 最終的な答え",
"-ng = 2 * 10**5 + 1",
"+ng = 10**21",
"- if check(mid, M):",
"+ cnt = solve(mid)",
"+ if cnt >= M:",
"-ans = 0",
"+amari = float(\"inf\")",
"-amari = 2 * 10**5 + 1",
"-for i in range(N):",
"- Aj = X - A[i]",
"+score = 0",
"+for i, Ai in enumerate(A):",
"+ Aj = X - Ai",
"- ans += S[N] - S[j] + A[i] * (N - j)",
"+ score += S[N] - S[j] + Ai * (N - j)",
"-print((ans - (cnt - M) * amari))",
"+print((score - (cnt - M) * amari))"
] | false | 0.036052 | 0.078292 | 0.46048 | [
"s518285926",
"s590326494"
] |
u877415670 | p02838 | python | s977310986 | s109115626 | 353 | 315 | 124,528 | 124,424 | Accepted | Accepted | 10.76 | n = int(eval(input()))
a = list(map(int, input().split()))
mod = 10**9 + 7
pows = [pow(2, i, mod) for i in range(60)]
count = [0]*60
for i in range(n):
bit = a[i]
for g in range(60):
count[g] += bit%2
bit //= 2
if bit == 0:
break
ans = 0
num = [0]*60
for i in range(n):
bit = a[i]
for g in range(60):
if bit % 2 == 1:
num[g] += n - count[g]
else:
num[g] += count[g]
bit //= 2
for i in range(60):
ans += num[i]*pows[i]
print((ans//2 % mod))
| n = int(eval(input()))
a = list(map(int, input().split()))
mod = 10**9 + 7
pows = [pow(2, i, mod) for i in range(60)]
count = [0]*60
num = [0]*60
ans = 0
for i in range(n):
bit = a[i]
for g in range(60):
if bit % 2 == 1:
count[g] += 1
num[g] += i+1 - count[g]
else:
num[g] += count[g]
bit //= 2
for i in range(60):
ans += num[i]*pows[i]
print((ans % mod))
| 33 | 24 | 579 | 448 | n = int(eval(input()))
a = list(map(int, input().split()))
mod = 10**9 + 7
pows = [pow(2, i, mod) for i in range(60)]
count = [0] * 60
for i in range(n):
bit = a[i]
for g in range(60):
count[g] += bit % 2
bit //= 2
if bit == 0:
break
ans = 0
num = [0] * 60
for i in range(n):
bit = a[i]
for g in range(60):
if bit % 2 == 1:
num[g] += n - count[g]
else:
num[g] += count[g]
bit //= 2
for i in range(60):
ans += num[i] * pows[i]
print((ans // 2 % mod))
| n = int(eval(input()))
a = list(map(int, input().split()))
mod = 10**9 + 7
pows = [pow(2, i, mod) for i in range(60)]
count = [0] * 60
num = [0] * 60
ans = 0
for i in range(n):
bit = a[i]
for g in range(60):
if bit % 2 == 1:
count[g] += 1
num[g] += i + 1 - count[g]
else:
num[g] += count[g]
bit //= 2
for i in range(60):
ans += num[i] * pows[i]
print((ans % mod))
| false | 27.272727 | [
"-for i in range(n):",
"- bit = a[i]",
"- for g in range(60):",
"- count[g] += bit % 2",
"- bit //= 2",
"- if bit == 0:",
"- break",
"+num = [0] * 60",
"-num = [0] * 60",
"- num[g] += n - count[g]",
"+ count[g] += 1",
"+ num[g] += i + 1 - count[g]",
"-print((ans // 2 % mod))",
"+print((ans % mod))"
] | false | 0.044036 | 0.044184 | 0.996649 | [
"s977310986",
"s109115626"
] |
u989345508 | p03637 | python | s822474650 | s612863833 | 95 | 73 | 11,096 | 14,252 | Accepted | Accepted | 23.16 | x=[0,0,0]
n=int(eval(input()))
for i in input().split():
if int(i)%4==0:
x[0]+=1
elif int(i)%2==0:
x[1]+=1
else:
x[2]+=1
if x[1]==0:
if x[0]+1>=x[2]:
print("Yes")
else:
print("No")
else:
if x[0]>=x[2]:
print("Yes")
else:
print("No")
#print(x)
| n=int(eval(input()))
a=[int(i) for i in input().split()]
x,y,z=0,0,0
for i in range(n):
if a[i]%4==0:
x+=1
elif a[i]%2==0:
y+=1
else:
z+=1
if y>0:
if z<=x:
print("Yes")
else:
print("No")
else:
if z<=x+1:
print("Yes")
else:
print("No")
| 20 | 20 | 340 | 332 | x = [0, 0, 0]
n = int(eval(input()))
for i in input().split():
if int(i) % 4 == 0:
x[0] += 1
elif int(i) % 2 == 0:
x[1] += 1
else:
x[2] += 1
if x[1] == 0:
if x[0] + 1 >= x[2]:
print("Yes")
else:
print("No")
else:
if x[0] >= x[2]:
print("Yes")
else:
print("No")
# print(x)
| n = int(eval(input()))
a = [int(i) for i in input().split()]
x, y, z = 0, 0, 0
for i in range(n):
if a[i] % 4 == 0:
x += 1
elif a[i] % 2 == 0:
y += 1
else:
z += 1
if y > 0:
if z <= x:
print("Yes")
else:
print("No")
else:
if z <= x + 1:
print("Yes")
else:
print("No")
| false | 0 | [
"-x = [0, 0, 0]",
"-for i in input().split():",
"- if int(i) % 4 == 0:",
"- x[0] += 1",
"- elif int(i) % 2 == 0:",
"- x[1] += 1",
"+a = [int(i) for i in input().split()]",
"+x, y, z = 0, 0, 0",
"+for i in range(n):",
"+ if a[i] % 4 == 0:",
"+ x += 1",
"+ elif a[i] % 2 == 0:",
"+ y += 1",
"- x[2] += 1",
"-if x[1] == 0:",
"- if x[0] + 1 >= x[2]:",
"+ z += 1",
"+if y > 0:",
"+ if z <= x:",
"- if x[0] >= x[2]:",
"+ if z <= x + 1:",
"-# print(x)"
] | false | 0.101625 | 0.100366 | 1.012544 | [
"s822474650",
"s612863833"
] |
u870262604 | p02913 | python | s224857556 | s155422421 | 478 | 437 | 44,908 | 44,508 | Accepted | Accepted | 8.58 | import sys
sys.setrecursionlimit(10 ** 7)
debug = True
debug = False
def dprint(*objects):
if debug == True:
print((*objects))
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x) - 1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def II(): return int(sys.stdin.readline())
def SI(): return sys.stdin.readline().strip()
INF = 10 ** 18
MOD = 10 ** 9 + 7
def main():
N = II()
S = SI()
mark = [-1 for i in range(N)]
from collections import defaultdict
posd = defaultdict(list)
for i, c in enumerate(S):
posd[c].append(i)
for i in range(N):
si = S[i]
# headの文字の位置のリスト
pos_list = posd[si]
for pos in pos_list:
if pos >= i:
# 自分より前のところだけを探す
continue
# この場合は直前により長いシーケンスを見ているので見なくていい
if pos > 0 and S[pos - 1] == S[i - 1]:
continue
# どこまであうかをやっていく
for j in range(N):
# 前回見たシーケンスは見ない
# 自分のところまで来てたらやめる
if pos+j == i:
break
# 突き抜けたらやめる
if i+j == N:
break
you = pos + j
me = i + j
# 違ったらやめる
if S[you] != S[me]:
break
# 同じなら、マークする
mark[you] = max(mark[you], j)
dprint(mark)
print((max(mark)+1))
main() | import sys
sys.setrecursionlimit(10 ** 7)
debug = True
debug = False
def dprint(*objects):
if debug == True:
print((*objects))
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x) - 1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def II(): return int(sys.stdin.readline())
def SI(): return sys.stdin.readline().strip()
INF = 10 ** 18
MOD = 10 ** 9 + 7
def main():
N = II()
S = SI()
#mark = [-1 for i in range(N)]
ans = -1
from collections import defaultdict
posd = defaultdict(list)
for i, c in enumerate(S):
posd[c].append(i)
for i in range(N):
si = S[i]
# headの文字の位置のリスト
pos_list = posd[si]
for pos in pos_list:
if pos >= i:
# 自分より前のところだけを探す
continue
# この場合は直前により長いシーケンスを見ているので見なくていい
if pos > 0 and S[pos - 1] == S[i - 1]:
continue
# どこまであうかをやっていく
for j in range(N):
# 前回見たシーケンスは見ない
# 自分のところまで来てたらやめる
if pos+j == i:
break
# 突き抜けたらやめる
if i+j == N:
break
you = pos + j
me = i + j
# 違ったらやめる
if S[you] != S[me]:
break
# 同じなら、マークする
ans = max(ans, j)
#mark[you] = max(mark[you], j)
#dprint(mark)
#print(max(mark)+1)
print((ans + 1))
main() | 74 | 75 | 1,653 | 1,722 | import sys
sys.setrecursionlimit(10**7)
debug = True
debug = False
def dprint(*objects):
if debug == True:
print((*objects))
def LI():
return [int(x) for x in sys.stdin.readline().split()]
def LI_():
return [int(x) - 1 for x in sys.stdin.readline().split()]
def LF():
return [float(x) for x in sys.stdin.readline().split()]
def LS():
return sys.stdin.readline().split()
def II():
return int(sys.stdin.readline())
def SI():
return sys.stdin.readline().strip()
INF = 10**18
MOD = 10**9 + 7
def main():
N = II()
S = SI()
mark = [-1 for i in range(N)]
from collections import defaultdict
posd = defaultdict(list)
for i, c in enumerate(S):
posd[c].append(i)
for i in range(N):
si = S[i]
# headの文字の位置のリスト
pos_list = posd[si]
for pos in pos_list:
if pos >= i:
# 自分より前のところだけを探す
continue
# この場合は直前により長いシーケンスを見ているので見なくていい
if pos > 0 and S[pos - 1] == S[i - 1]:
continue
# どこまであうかをやっていく
for j in range(N):
# 前回見たシーケンスは見ない
# 自分のところまで来てたらやめる
if pos + j == i:
break
# 突き抜けたらやめる
if i + j == N:
break
you = pos + j
me = i + j
# 違ったらやめる
if S[you] != S[me]:
break
# 同じなら、マークする
mark[you] = max(mark[you], j)
dprint(mark)
print((max(mark) + 1))
main()
| import sys
sys.setrecursionlimit(10**7)
debug = True
debug = False
def dprint(*objects):
if debug == True:
print((*objects))
def LI():
return [int(x) for x in sys.stdin.readline().split()]
def LI_():
return [int(x) - 1 for x in sys.stdin.readline().split()]
def LF():
return [float(x) for x in sys.stdin.readline().split()]
def LS():
return sys.stdin.readline().split()
def II():
return int(sys.stdin.readline())
def SI():
return sys.stdin.readline().strip()
INF = 10**18
MOD = 10**9 + 7
def main():
N = II()
S = SI()
# mark = [-1 for i in range(N)]
ans = -1
from collections import defaultdict
posd = defaultdict(list)
for i, c in enumerate(S):
posd[c].append(i)
for i in range(N):
si = S[i]
# headの文字の位置のリスト
pos_list = posd[si]
for pos in pos_list:
if pos >= i:
# 自分より前のところだけを探す
continue
# この場合は直前により長いシーケンスを見ているので見なくていい
if pos > 0 and S[pos - 1] == S[i - 1]:
continue
# どこまであうかをやっていく
for j in range(N):
# 前回見たシーケンスは見ない
# 自分のところまで来てたらやめる
if pos + j == i:
break
# 突き抜けたらやめる
if i + j == N:
break
you = pos + j
me = i + j
# 違ったらやめる
if S[you] != S[me]:
break
# 同じなら、マークする
ans = max(ans, j)
# mark[you] = max(mark[you], j)
# dprint(mark)
# print(max(mark)+1)
print((ans + 1))
main()
| false | 1.333333 | [
"- mark = [-1 for i in range(N)]",
"+ # mark = [-1 for i in range(N)]",
"+ ans = -1",
"- mark[you] = max(mark[you], j)",
"- dprint(mark)",
"- print((max(mark) + 1))",
"+ ans = max(ans, j)",
"+ # mark[you] = max(mark[you], j)",
"+ # dprint(mark)",
"+ # print(max(mark)+1)",
"+ print((ans + 1))"
] | false | 0.179006 | 0.046982 | 3.810109 | [
"s224857556",
"s155422421"
] |
u074220993 | p03472 | python | s272994864 | s300425661 | 251 | 94 | 14,904 | 32,336 | Accepted | Accepted | 62.55 | N, H = list(map(int, input().split()))
slash = 0
Throw = []
for _ in range(N):
a, b = list(map(int, input().split()))
slash = max(slash, a)
if b > a: Throw.append(b)
#slash=斬撃最大ダメージ、投げてslash超のダメージが出るならばその刀をダメージが大きい順に投げる
Throw = sorted([th for th in Throw if th > slash], reverse=True)
dmg, cnt = 0, 0
for throw in Throw:
if dmg >= H: break
dmg += throw
cnt += 1
if dmg < H:
from math import ceil
cnt += ceil((H-dmg)/slash)
print(cnt) |
def main():
with open(0) as f:
N, H = list(map(int, f.readline().split()))
ab = list(map(int, f.read().split()))
max_slash = max(ab[0::2])
throw = sorted([x for x in ab[1::2] if x > max_slash], reverse=True)
cnt = 0
for t in throw:
if H <= 0:
break
H += -t
cnt += 1
if H > 0:
cnt += (H+max_slash-1)//max_slash
print(cnt)
main()
| 18 | 20 | 474 | 436 | N, H = list(map(int, input().split()))
slash = 0
Throw = []
for _ in range(N):
a, b = list(map(int, input().split()))
slash = max(slash, a)
if b > a:
Throw.append(b)
# slash=斬撃最大ダメージ、投げてslash超のダメージが出るならばその刀をダメージが大きい順に投げる
Throw = sorted([th for th in Throw if th > slash], reverse=True)
dmg, cnt = 0, 0
for throw in Throw:
if dmg >= H:
break
dmg += throw
cnt += 1
if dmg < H:
from math import ceil
cnt += ceil((H - dmg) / slash)
print(cnt)
| def main():
with open(0) as f:
N, H = list(map(int, f.readline().split()))
ab = list(map(int, f.read().split()))
max_slash = max(ab[0::2])
throw = sorted([x for x in ab[1::2] if x > max_slash], reverse=True)
cnt = 0
for t in throw:
if H <= 0:
break
H += -t
cnt += 1
if H > 0:
cnt += (H + max_slash - 1) // max_slash
print(cnt)
main()
| false | 10 | [
"-N, H = list(map(int, input().split()))",
"-slash = 0",
"-Throw = []",
"-for _ in range(N):",
"- a, b = list(map(int, input().split()))",
"- slash = max(slash, a)",
"- if b > a:",
"- Throw.append(b)",
"-# slash=斬撃最大ダメージ、投げてslash超のダメージが出るならばその刀をダメージが大きい順に投げる",
"-Throw = sorted([th for th in Throw if th > slash], reverse=True)",
"-dmg, cnt = 0, 0",
"-for throw in Throw:",
"- if dmg >= H:",
"- break",
"- dmg += throw",
"- cnt += 1",
"-if dmg < H:",
"- from math import ceil",
"+def main():",
"+ with open(0) as f:",
"+ N, H = list(map(int, f.readline().split()))",
"+ ab = list(map(int, f.read().split()))",
"+ max_slash = max(ab[0::2])",
"+ throw = sorted([x for x in ab[1::2] if x > max_slash], reverse=True)",
"+ cnt = 0",
"+ for t in throw:",
"+ if H <= 0:",
"+ break",
"+ H += -t",
"+ cnt += 1",
"+ if H > 0:",
"+ cnt += (H + max_slash - 1) // max_slash",
"+ print(cnt)",
"- cnt += ceil((H - dmg) / slash)",
"-print(cnt)",
"+",
"+main()"
] | false | 0.127482 | 0.127258 | 1.001759 | [
"s272994864",
"s300425661"
] |
u575431498 | p03673 | python | s710256418 | s287087101 | 149 | 55 | 33,604 | 27,204 | Accepted | Accepted | 63.09 | n = int(eval(input()))
a = [int(e) for e in input().split()]
ans = []
if n % 2 == 0:
for e in a[n-1::-2]:
ans.append(str(e))
for e in a[0::2]:
ans.append(str(e))
else:
for e in a[n-1::-2]:
ans.append(str(e))
for e in a[1::2]:
ans.append(str(e))
print((' '.join(ans))) | n = int(eval(input()))
a = [e for e in input().split()]
print((' '.join(a[n-1::-2] + a[n%2::2]))) | 15 | 4 | 322 | 93 | n = int(eval(input()))
a = [int(e) for e in input().split()]
ans = []
if n % 2 == 0:
for e in a[n - 1 :: -2]:
ans.append(str(e))
for e in a[0::2]:
ans.append(str(e))
else:
for e in a[n - 1 :: -2]:
ans.append(str(e))
for e in a[1::2]:
ans.append(str(e))
print((" ".join(ans)))
| n = int(eval(input()))
a = [e for e in input().split()]
print((" ".join(a[n - 1 :: -2] + a[n % 2 :: 2])))
| false | 73.333333 | [
"-a = [int(e) for e in input().split()]",
"-ans = []",
"-if n % 2 == 0:",
"- for e in a[n - 1 :: -2]:",
"- ans.append(str(e))",
"- for e in a[0::2]:",
"- ans.append(str(e))",
"-else:",
"- for e in a[n - 1 :: -2]:",
"- ans.append(str(e))",
"- for e in a[1::2]:",
"- ans.append(str(e))",
"-print((\" \".join(ans)))",
"+a = [e for e in input().split()]",
"+print((\" \".join(a[n - 1 :: -2] + a[n % 2 :: 2])))"
] | false | 0.038434 | 0.075936 | 0.50614 | [
"s710256418",
"s287087101"
] |
u327532412 | p02659 | python | s432337898 | s634582660 | 27 | 22 | 9,888 | 9,092 | Accepted | Accepted | 18.52 | import decimal
A, B = input().split()
A = decimal.Decimal(A)
B = decimal.Decimal(B) * 100
print((decimal.Decimal(A * B // 100))) | A, B = input().split()
A = int(A)
B = round(float(B) * 100)
print((A * B // 100))
| 5 | 4 | 130 | 83 | import decimal
A, B = input().split()
A = decimal.Decimal(A)
B = decimal.Decimal(B) * 100
print((decimal.Decimal(A * B // 100)))
| A, B = input().split()
A = int(A)
B = round(float(B) * 100)
print((A * B // 100))
| false | 20 | [
"-import decimal",
"-",
"-A = decimal.Decimal(A)",
"-B = decimal.Decimal(B) * 100",
"-print((decimal.Decimal(A * B // 100)))",
"+A = int(A)",
"+B = round(float(B) * 100)",
"+print((A * B // 100))"
] | false | 0.040158 | 0.037693 | 1.065421 | [
"s432337898",
"s634582660"
] |
u175034939 | p03137 | python | s629205395 | s000770210 | 1,538 | 117 | 13,968 | 13,968 | Accepted | Accepted | 92.39 | n,m = list(map(int,input().split()))
a = list(map(int,input().split()))
a.sort(reverse=True)
if n >= m:
print((0))
exit()
b = []
for i in range(m-1):
b.append(abs(a[i+1]-a[i]))
b.sort(reverse=True)
for i in range(n-1):
b.pop(0)
print((sum(b))) | n,m = list(map(int,input().split()))
a = list(map(int,input().split()))
a.sort(reverse=True)
if n >= m:
print((0))
exit()
b = []
for i in range(m-1):
b.append(abs(a[i+1]-a[i]))
b.sort()
print((sum(b[:m-n]))) | 17 | 14 | 275 | 231 | n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
a.sort(reverse=True)
if n >= m:
print((0))
exit()
b = []
for i in range(m - 1):
b.append(abs(a[i + 1] - a[i]))
b.sort(reverse=True)
for i in range(n - 1):
b.pop(0)
print((sum(b)))
| n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
a.sort(reverse=True)
if n >= m:
print((0))
exit()
b = []
for i in range(m - 1):
b.append(abs(a[i + 1] - a[i]))
b.sort()
print((sum(b[: m - n])))
| false | 17.647059 | [
"-b.sort(reverse=True)",
"-for i in range(n - 1):",
"- b.pop(0)",
"-print((sum(b)))",
"+b.sort()",
"+print((sum(b[: m - n])))"
] | false | 0.16782 | 0.035082 | 4.783674 | [
"s629205395",
"s000770210"
] |
u203843959 | p03283 | python | s436338460 | s705881570 | 2,730 | 569 | 55,256 | 56,412 | Accepted | Accepted | 79.16 | N,M,Q=list(map(int,input().split()))
xmat,cmat=[],[]
for i in range(N+1):
xmat.append([0]*(N+1))
cmat.append([0]*(N+1))
for i in range(M):
l,r=list(map(int,input().split()))
xmat[l][r]+=1
#print(xmat)
for i in range(1,N+1):
for j in range(1,N+1):
cmat[i][j]=xmat[i][j]+cmat[i][j-1]
#print(cmat)
for i in range(Q):
p,q=list(map(int,input().split()))
ans=0
for k in range(p,q+1):
ans+=cmat[k][q]-cmat[k][p-1]
print(ans)
| import sys
input=sys.stdin.readline
N,M,Q=list(map(int,input().split()))
xmat=[[0]*(N+1) for _ in range(N+1)]
for i in range(M):
l,r=list(map(int,input().split()))
xmat[l][r]+=1
#print(xmat)
smat=[[0]*(N+1) for _ in range(N+1)]
for i in range(1,N+1):
for j in range(1,N+1):
smat[i][j]=xmat[i][j]+smat[i][j-1]+smat[i-1][j]-smat[i-1][j-1]
#print(smat)
for i in range(Q):
p,q=list(map(int,input().split()))
print((smat[q][q]-smat[p-1][q]-smat[q][p-1]+smat[p-1][p-1])) | 23 | 19 | 452 | 479 | N, M, Q = list(map(int, input().split()))
xmat, cmat = [], []
for i in range(N + 1):
xmat.append([0] * (N + 1))
cmat.append([0] * (N + 1))
for i in range(M):
l, r = list(map(int, input().split()))
xmat[l][r] += 1
# print(xmat)
for i in range(1, N + 1):
for j in range(1, N + 1):
cmat[i][j] = xmat[i][j] + cmat[i][j - 1]
# print(cmat)
for i in range(Q):
p, q = list(map(int, input().split()))
ans = 0
for k in range(p, q + 1):
ans += cmat[k][q] - cmat[k][p - 1]
print(ans)
| import sys
input = sys.stdin.readline
N, M, Q = list(map(int, input().split()))
xmat = [[0] * (N + 1) for _ in range(N + 1)]
for i in range(M):
l, r = list(map(int, input().split()))
xmat[l][r] += 1
# print(xmat)
smat = [[0] * (N + 1) for _ in range(N + 1)]
for i in range(1, N + 1):
for j in range(1, N + 1):
smat[i][j] = xmat[i][j] + smat[i][j - 1] + smat[i - 1][j] - smat[i - 1][j - 1]
# print(smat)
for i in range(Q):
p, q = list(map(int, input().split()))
print((smat[q][q] - smat[p - 1][q] - smat[q][p - 1] + smat[p - 1][p - 1]))
| false | 17.391304 | [
"+import sys",
"+",
"+input = sys.stdin.readline",
"-xmat, cmat = [], []",
"-for i in range(N + 1):",
"- xmat.append([0] * (N + 1))",
"- cmat.append([0] * (N + 1))",
"+xmat = [[0] * (N + 1) for _ in range(N + 1)]",
"+smat = [[0] * (N + 1) for _ in range(N + 1)]",
"- cmat[i][j] = xmat[i][j] + cmat[i][j - 1]",
"-# print(cmat)",
"+ smat[i][j] = xmat[i][j] + smat[i][j - 1] + smat[i - 1][j] - smat[i - 1][j - 1]",
"+# print(smat)",
"- ans = 0",
"- for k in range(p, q + 1):",
"- ans += cmat[k][q] - cmat[k][p - 1]",
"- print(ans)",
"+ print((smat[q][q] - smat[p - 1][q] - smat[q][p - 1] + smat[p - 1][p - 1]))"
] | false | 0.062368 | 0.037366 | 1.669106 | [
"s436338460",
"s705881570"
] |
u022407960 | p02315 | python | s477275235 | s554387424 | 420 | 380 | 8,336 | 8,260 | Accepted | Accepted | 9.52 | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
input:
4 5
4 2
5 2
2 1
8 3
output:
13
"""
import sys
from collections import namedtuple
# def solve():
# for i, item in enumerate(item_list, 1):
# for cp in range(1, real_cp + 1):
# # capacity allows putting in, calculate value
# if item.w <= cp:
# values[i][cp] = max(values[i - 1][cp], values[i - 1][cp - item.w] + item.v)
# # can't put in, skip current item
# else:
# values[i][cp] = values[i - 1][cp]
#
# return values[c_items][real_cp]
def solve_2():
dp = [0] * (real_cp + 1)
for item in item_list:
v, w = item.v, item.w
for cp in range(real_cp - w, -1, -1):
dp[cp + w] = max(dp[cp + w], dp[cp] + v)
return dp[-1]
if __name__ == '__main__':
_input = sys.stdin.readlines()
c_items, real_cp = list(map(int, _input[0].split()))
items = [x.split() for x in _input[1:]]
Item = namedtuple('Item', ('v', 'w'))
item_list = [Item(int(v), int(w)) for v, w in items]
# values = [[0] * (real_cp + 1) for _ in range(c_items + 1)]
print((solve_2())) | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
input:
4 5
4 2
5 2
2 1
8 3
output:
13
"""
import sys
from collections import namedtuple
def solve():
dp = [0] * (real_cp + 1)
for item in item_list:
v, w = item.v, item.w
# for cp in range(real_cp - w, -1, -1):
# dp[cp + w] = max(dp[cp + w], dp[cp] + v)
for cp in range(real_cp, w - 1, -1):
dp[cp] = max(dp[cp], dp[cp - w] + v)
return dp[-1]
if __name__ == '__main__':
_input = sys.stdin.readlines()
c_items, real_cp = list(map(int, _input[0].split()))
items = [x.split() for x in _input[1:]]
Item = namedtuple('Item', ('v', 'w'))
item_list = [Item(int(v), int(w)) for v, w in items]
print((solve())) | 52 | 40 | 1,214 | 780 | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
input:
4 5
4 2
5 2
2 1
8 3
output:
13
"""
import sys
from collections import namedtuple
# def solve():
# for i, item in enumerate(item_list, 1):
# for cp in range(1, real_cp + 1):
# # capacity allows putting in, calculate value
# if item.w <= cp:
# values[i][cp] = max(values[i - 1][cp], values[i - 1][cp - item.w] + item.v)
# # can't put in, skip current item
# else:
# values[i][cp] = values[i - 1][cp]
#
# return values[c_items][real_cp]
def solve_2():
dp = [0] * (real_cp + 1)
for item in item_list:
v, w = item.v, item.w
for cp in range(real_cp - w, -1, -1):
dp[cp + w] = max(dp[cp + w], dp[cp] + v)
return dp[-1]
if __name__ == "__main__":
_input = sys.stdin.readlines()
c_items, real_cp = list(map(int, _input[0].split()))
items = [x.split() for x in _input[1:]]
Item = namedtuple("Item", ("v", "w"))
item_list = [Item(int(v), int(w)) for v, w in items]
# values = [[0] * (real_cp + 1) for _ in range(c_items + 1)]
print((solve_2()))
| #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
input:
4 5
4 2
5 2
2 1
8 3
output:
13
"""
import sys
from collections import namedtuple
def solve():
dp = [0] * (real_cp + 1)
for item in item_list:
v, w = item.v, item.w
# for cp in range(real_cp - w, -1, -1):
# dp[cp + w] = max(dp[cp + w], dp[cp] + v)
for cp in range(real_cp, w - 1, -1):
dp[cp] = max(dp[cp], dp[cp - w] + v)
return dp[-1]
if __name__ == "__main__":
_input = sys.stdin.readlines()
c_items, real_cp = list(map(int, _input[0].split()))
items = [x.split() for x in _input[1:]]
Item = namedtuple("Item", ("v", "w"))
item_list = [Item(int(v), int(w)) for v, w in items]
print((solve()))
| false | 23.076923 | [
"-# def solve():",
"-# for i, item in enumerate(item_list, 1):",
"-# for cp in range(1, real_cp + 1):",
"-# # capacity allows putting in, calculate value",
"-# if item.w <= cp:",
"-# values[i][cp] = max(values[i - 1][cp], values[i - 1][cp - item.w] + item.v)",
"-# # can't put in, skip current item",
"-# else:",
"-# values[i][cp] = values[i - 1][cp]",
"-#",
"-# return values[c_items][real_cp]",
"-def solve_2():",
"+",
"+def solve():",
"- for cp in range(real_cp - w, -1, -1):",
"- dp[cp + w] = max(dp[cp + w], dp[cp] + v)",
"+ # for cp in range(real_cp - w, -1, -1):",
"+ # dp[cp + w] = max(dp[cp + w], dp[cp] + v)",
"+ for cp in range(real_cp, w - 1, -1):",
"+ dp[cp] = max(dp[cp], dp[cp - w] + v)",
"- # values = [[0] * (real_cp + 1) for _ in range(c_items + 1)]",
"- print((solve_2()))",
"+ print((solve()))"
] | false | 0.048424 | 0.04838 | 1.00091 | [
"s477275235",
"s554387424"
] |
u057964173 | p03254 | python | s668441190 | s046421241 | 19 | 17 | 3,064 | 3,064 | Accepted | Accepted | 10.53 | def resolve():
n,x=list(map(int, input().split()))
l=list(map(int, input().split()))
l.sort()
num=0
cnt=0
for i in range(n-1):
if num+l[i]<=x:
num+=l[i]
cnt+=1
if l[n-1]==x-num:
cnt+=1
print(cnt)
resolve() | def resolve():
import sys
n,x=list(map(int, input().split()))
l=list(map(int, input().split()))
l.sort()
cnt=0
for i in range(n):
if l[i]<=x:
x-=l[i]
cnt+=1
else:
print(i)
sys.exit()
if cnt==n and x>0:
cnt-=1
print(cnt)
resolve() | 14 | 17 | 284 | 343 | def resolve():
n, x = list(map(int, input().split()))
l = list(map(int, input().split()))
l.sort()
num = 0
cnt = 0
for i in range(n - 1):
if num + l[i] <= x:
num += l[i]
cnt += 1
if l[n - 1] == x - num:
cnt += 1
print(cnt)
resolve()
| def resolve():
import sys
n, x = list(map(int, input().split()))
l = list(map(int, input().split()))
l.sort()
cnt = 0
for i in range(n):
if l[i] <= x:
x -= l[i]
cnt += 1
else:
print(i)
sys.exit()
if cnt == n and x > 0:
cnt -= 1
print(cnt)
resolve()
| false | 17.647059 | [
"+ import sys",
"+",
"- num = 0",
"- for i in range(n - 1):",
"- if num + l[i] <= x:",
"- num += l[i]",
"+ for i in range(n):",
"+ if l[i] <= x:",
"+ x -= l[i]",
"- if l[n - 1] == x - num:",
"- cnt += 1",
"+ else:",
"+ print(i)",
"+ sys.exit()",
"+ if cnt == n and x > 0:",
"+ cnt -= 1"
] | false | 0.052284 | 0.044018 | 1.187786 | [
"s668441190",
"s046421241"
] |
u778814286 | p03456 | python | s049402159 | s426176782 | 184 | 18 | 13,588 | 3,188 | Accepted | Accepted | 90.22 | a, b = input().split()
ab = int(a+b)
import numpy as np
print(('Yes' if np.sqrt(ab)%1 == 0 else 'No')) | a, b = input().split()
ab = int(a+b)
print(('Yes' if (ab**0.5)%1 == 0 else 'No')) | 7 | 5 | 109 | 85 | a, b = input().split()
ab = int(a + b)
import numpy as np
print(("Yes" if np.sqrt(ab) % 1 == 0 else "No"))
| a, b = input().split()
ab = int(a + b)
print(("Yes" if (ab**0.5) % 1 == 0 else "No"))
| false | 28.571429 | [
"-import numpy as np",
"-",
"-print((\"Yes\" if np.sqrt(ab) % 1 == 0 else \"No\"))",
"+print((\"Yes\" if (ab**0.5) % 1 == 0 else \"No\"))"
] | false | 0.253483 | 0.007686 | 32.980043 | [
"s049402159",
"s426176782"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.