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
list | 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
list |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
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.