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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
u394731058 | p02989 | python | s904152908 | s902736131 | 89 | 75 | 14,820 | 14,300 | Accepted | Accepted | 15.73 | import sys
import collections as c
input = sys.stdin.readline
def main():
ans = 0
n = int(eval(input()))
d = list(map(int, input().split()))
d.sort()
g = d[n//2]
items_count = c.Counter(d)
gc = items_count[g]
if gc == 1 or d[n//2-1] != g:
ans += g - d[n//2-1]
print(ans)
if __name__ == '__main__':
main() | import sys
input = sys.stdin.readline
def main():
ans = 0
n = int(eval(input()))
d = list(map(int, input().split()))
d.sort()
ans += d[n//2] - d[n//2-1]
print(ans)
if __name__ == '__main__':
main() | 19 | 14 | 367 | 235 | import sys
import collections as c
input = sys.stdin.readline
def main():
ans = 0
n = int(eval(input()))
d = list(map(int, input().split()))
d.sort()
g = d[n // 2]
items_count = c.Counter(d)
gc = items_count[g]
if gc == 1 or d[n // 2 - 1] != g:
ans += g - d[n // 2 - 1]
print(ans)
if __name__ == "__main__":
main()
| import sys
input = sys.stdin.readline
def main():
ans = 0
n = int(eval(input()))
d = list(map(int, input().split()))
d.sort()
ans += d[n // 2] - d[n // 2 - 1]
print(ans)
if __name__ == "__main__":
main()
| false | 26.315789 | [
"-import collections as c",
"- g = d[n // 2]",
"- items_count = c.Counter(d)",
"- gc = items_count[g]",
"- if gc == 1 or d[n // 2 - 1] != g:",
"- ans += g - d[n // 2 - 1]",
"+ ans += d[n // 2] - d[n // 2 - 1]"
] | false | 0.040995 | 0.036881 | 1.111538 | [
"s904152908",
"s902736131"
] |
u489959379 | p03821 | python | s909679828 | s451918992 | 366 | 207 | 28,148 | 27,380 | Accepted | Accepted | 43.44 | import sys
sys.setrecursionlimit(10 ** 7)
f_inf = float('inf')
mod = 10 ** 9 + 7
def resolve():
n = int(eval(input()))
AB = [list(map(int, input().split())) for _ in range(n)][::-1]
res = 0
for i in range(n):
a, b = AB[i]
push = ((a + res + b - 1) // b) * b - a
res = push
print(res)
if __name__ == '__main__':
resolve()
| import sys
sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline
f_inf = float('inf')
mod = 10 ** 9 + 7
def resolve():
n = int(eval(input()))
AB = [list(map(int, input().split())) for _ in range(n)]
res = 0
for i in reversed(list(range(n))):
a, b = AB[i]
a += res
if a % b != 0:
res += (a // b + 1) * b - a
print(res)
if __name__ == '__main__':
resolve()
| 21 | 23 | 389 | 435 | import sys
sys.setrecursionlimit(10**7)
f_inf = float("inf")
mod = 10**9 + 7
def resolve():
n = int(eval(input()))
AB = [list(map(int, input().split())) for _ in range(n)][::-1]
res = 0
for i in range(n):
a, b = AB[i]
push = ((a + res + b - 1) // b) * b - a
res = push
print(res)
if __name__ == "__main__":
resolve()
| import sys
sys.setrecursionlimit(10**7)
input = sys.stdin.readline
f_inf = float("inf")
mod = 10**9 + 7
def resolve():
n = int(eval(input()))
AB = [list(map(int, input().split())) for _ in range(n)]
res = 0
for i in reversed(list(range(n))):
a, b = AB[i]
a += res
if a % b != 0:
res += (a // b + 1) * b - a
print(res)
if __name__ == "__main__":
resolve()
| false | 8.695652 | [
"+input = sys.stdin.readline",
"- AB = [list(map(int, input().split())) for _ in range(n)][::-1]",
"+ AB = [list(map(int, input().split())) for _ in range(n)]",
"- for i in range(n):",
"+ for i in reversed(list(range(n))):",
"- push = ((a + res + b - 1) // b) * b - a",
"- res = push",
"+ a += res",
"+ if a % b != 0:",
"+ res += (a // b + 1) * b - a"
] | false | 0.096654 | 0.146992 | 0.657544 | [
"s909679828",
"s451918992"
] |
u707498674 | p03835 | python | s785925784 | s549587120 | 1,294 | 19 | 2,940 | 3,060 | Accepted | Accepted | 98.53 | def main():
K, S = list(map(int, input().split()))
ans = sum((1 for X in range(K+1) for Y in range(K+1) if S-X-Y>=0 and S-X-Y<=K))
print(ans)
if __name__ == "__main__":
main() | def main():
K, S = list(map(int, input().split()))
ans = 0
for X in range(K+1):
Y_min = max(0, S-X-K)
Y_max = min(K, S-X)
ans += max(0, Y_max - Y_min + 1)
print(ans)
if __name__ == "__main__":
main() | 6 | 10 | 190 | 246 | def main():
K, S = list(map(int, input().split()))
ans = sum(
(
1
for X in range(K + 1)
for Y in range(K + 1)
if S - X - Y >= 0 and S - X - Y <= K
)
)
print(ans)
if __name__ == "__main__":
main()
| def main():
K, S = list(map(int, input().split()))
ans = 0
for X in range(K + 1):
Y_min = max(0, S - X - K)
Y_max = min(K, S - X)
ans += max(0, Y_max - Y_min + 1)
print(ans)
if __name__ == "__main__":
main()
| false | 40 | [
"- ans = sum(",
"- (",
"- 1",
"- for X in range(K + 1)",
"- for Y in range(K + 1)",
"- if S - X - Y >= 0 and S - X - Y <= K",
"- )",
"- )",
"+ ans = 0",
"+ for X in range(K + 1):",
"+ Y_min = max(0, S - X - K)",
"+ Y_max = min(K, S - X)",
"+ ans += max(0, Y_max - Y_min + 1)"
] | false | 0.049352 | 0.048149 | 1.024989 | [
"s785925784",
"s549587120"
] |
u028973125 | p03817 | python | s275472582 | s586609773 | 28 | 25 | 8,992 | 9,112 | Accepted | Accepted | 10.71 | import sys
x = int(sys.stdin.readline())
n = x // 11
r = x % 11
if r == 0:
print((2*n))
elif r <= 6:
print((2*n + 1))
else:
print((2 * (n+1))) | import sys
x = int(sys.stdin.readline())
n = x // 11
r = x % 11
if r == 0:
print((2*n))
elif r <= 6:
print((2*n+1))
else:
print((2*n+2)) | 11 | 12 | 159 | 155 | import sys
x = int(sys.stdin.readline())
n = x // 11
r = x % 11
if r == 0:
print((2 * n))
elif r <= 6:
print((2 * n + 1))
else:
print((2 * (n + 1)))
| import sys
x = int(sys.stdin.readline())
n = x // 11
r = x % 11
if r == 0:
print((2 * n))
elif r <= 6:
print((2 * n + 1))
else:
print((2 * n + 2))
| false | 8.333333 | [
"- print((2 * (n + 1)))",
"+ print((2 * n + 2))"
] | false | 0.089036 | 0.04642 | 1.918047 | [
"s275472582",
"s586609773"
] |
u419686324 | p04013 | python | s382722187 | s005331442 | 1,235 | 137 | 66,416 | 13,400 | Accepted | Accepted | 88.91 | N, A = list(map(int, input().split()))
X = [int(x) for x in input().split()]
m = {}
def f(rv, k, rest):
if k == 0:
if rv == 0:
return 1
else:
return 0
if rv < 0 or len(rest) < k:
return 0
def r(rv, k, rest):
fp = (rv, k, len(rest))
if fp in m: return m[fp]
ret = f(rv, k, rest)
m[fp] = ret
return ret
ans = r(rv , k , rest[1:])
ans += r(rv - rest[0], k - 1, rest[1:])
return ans
print((sum([f(k * A, k, sorted(X)) for k in range(1, N + 1)]))) | N, A = list(map(int, input().split()))
X = [int(x) - A for x in input().split()]
import functools
@functools.lru_cache(maxsize=None)
def f(acc, left):
if not left: return 0
ret = 0
y = acc + left[0]
ret += 1 if y == 0 else 0
ret += f(y, left[1:])
ret += f(acc, left[1:])
return ret
print((f(0, tuple(X)))) | 24 | 14 | 589 | 339 | N, A = list(map(int, input().split()))
X = [int(x) for x in input().split()]
m = {}
def f(rv, k, rest):
if k == 0:
if rv == 0:
return 1
else:
return 0
if rv < 0 or len(rest) < k:
return 0
def r(rv, k, rest):
fp = (rv, k, len(rest))
if fp in m:
return m[fp]
ret = f(rv, k, rest)
m[fp] = ret
return ret
ans = r(rv, k, rest[1:])
ans += r(rv - rest[0], k - 1, rest[1:])
return ans
print((sum([f(k * A, k, sorted(X)) for k in range(1, N + 1)])))
| N, A = list(map(int, input().split()))
X = [int(x) - A for x in input().split()]
import functools
@functools.lru_cache(maxsize=None)
def f(acc, left):
if not left:
return 0
ret = 0
y = acc + left[0]
ret += 1 if y == 0 else 0
ret += f(y, left[1:])
ret += f(acc, left[1:])
return ret
print((f(0, tuple(X))))
| false | 41.666667 | [
"-X = [int(x) for x in input().split()]",
"-m = {}",
"+X = [int(x) - A for x in input().split()]",
"+import functools",
"-def f(rv, k, rest):",
"- if k == 0:",
"- if rv == 0:",
"- return 1",
"- else:",
"- return 0",
"- if rv < 0 or len(rest) < k:",
"[email protected]_cache(maxsize=None)",
"+def f(acc, left):",
"+ if not left:",
"-",
"- def r(rv, k, rest):",
"- fp = (rv, k, len(rest))",
"- if fp in m:",
"- return m[fp]",
"- ret = f(rv, k, rest)",
"- m[fp] = ret",
"- return ret",
"-",
"- ans = r(rv, k, rest[1:])",
"- ans += r(rv - rest[0], k - 1, rest[1:])",
"- return ans",
"+ ret = 0",
"+ y = acc + left[0]",
"+ ret += 1 if y == 0 else 0",
"+ ret += f(y, left[1:])",
"+ ret += f(acc, left[1:])",
"+ return ret",
"-print((sum([f(k * A, k, sorted(X)) for k in range(1, N + 1)])))",
"+print((f(0, tuple(X))))"
] | false | 0.038535 | 0.040131 | 0.960234 | [
"s382722187",
"s005331442"
] |
u653837719 | p02769 | python | s845975890 | s869794896 | 286 | 257 | 81,264 | 54,128 | Accepted | Accepted | 10.14 | n, k = list(map(int, input().split()))
mod = 10 ** 9 + 7
fac = [1, 1]
finv = [1, 1]
inv = [0, 1]
for i in range(2, n+1):
fac.append(fac[-1] * i % mod)
inv.append(-inv[mod%i] * (mod // i) % mod)
finv.append(finv[-1] * inv[-1] % mod)
ans = 0
for i in range(min(n-1, k) + 1):
com1 = fac[n] * finv[i] * finv[n-i] % mod
com2 = fac[n-1] * finv[i] * finv[n-i-1] % mod
mul = com1 * com2 % mod
ans = (ans + mul) % mod
print(ans) | n, k = list(map(int, input().split()))
mod = 10 ** 9 + 7
'''
fac = [1, 1]
finv = [1, 1]
inv = [0, 1]
for i in range(2, n+1):
fac.append(fac[-1] * i % mod)
inv.append(-inv[mod%i] * (mod // i) % mod)
finv.append(finv[-1] * inv[-1] % mod)
'''
fac = [1]
finv = [0]*(n+4)
for i in range(n+3):
fac.append(fac[-1]*(i+1)%mod)
finv[-1] = pow(fac[-1],mod-2,mod)
for i in range(n+2,-1,-1):
finv[i] = finv[i+1]*(i+1)%mod
ans = 0
for i in range(min(n-1, k) + 1):
com1 = fac[n] * finv[i] * finv[n-i] % mod
com2 = fac[n-1] * finv[i] * finv[n-i-1] % mod
mul = com1 * com2 % mod
ans = (ans + mul) % mod
print(ans) | 20 | 29 | 464 | 658 | n, k = list(map(int, input().split()))
mod = 10**9 + 7
fac = [1, 1]
finv = [1, 1]
inv = [0, 1]
for i in range(2, n + 1):
fac.append(fac[-1] * i % mod)
inv.append(-inv[mod % i] * (mod // i) % mod)
finv.append(finv[-1] * inv[-1] % mod)
ans = 0
for i in range(min(n - 1, k) + 1):
com1 = fac[n] * finv[i] * finv[n - i] % mod
com2 = fac[n - 1] * finv[i] * finv[n - i - 1] % mod
mul = com1 * com2 % mod
ans = (ans + mul) % mod
print(ans)
| n, k = list(map(int, input().split()))
mod = 10**9 + 7
"""
fac = [1, 1]
finv = [1, 1]
inv = [0, 1]
for i in range(2, n+1):
fac.append(fac[-1] * i % mod)
inv.append(-inv[mod%i] * (mod // i) % mod)
finv.append(finv[-1] * inv[-1] % mod)
"""
fac = [1]
finv = [0] * (n + 4)
for i in range(n + 3):
fac.append(fac[-1] * (i + 1) % mod)
finv[-1] = pow(fac[-1], mod - 2, mod)
for i in range(n + 2, -1, -1):
finv[i] = finv[i + 1] * (i + 1) % mod
ans = 0
for i in range(min(n - 1, k) + 1):
com1 = fac[n] * finv[i] * finv[n - i] % mod
com2 = fac[n - 1] * finv[i] * finv[n - i - 1] % mod
mul = com1 * com2 % mod
ans = (ans + mul) % mod
print(ans)
| false | 31.034483 | [
"+\"\"\"",
"-for i in range(2, n + 1):",
"+for i in range(2, n+1):",
"- inv.append(-inv[mod % i] * (mod // i) % mod)",
"+ inv.append(-inv[mod%i] * (mod // i) % mod)",
"+\"\"\"",
"+fac = [1]",
"+finv = [0] * (n + 4)",
"+for i in range(n + 3):",
"+ fac.append(fac[-1] * (i + 1) % mod)",
"+finv[-1] = pow(fac[-1], mod - 2, mod)",
"+for i in range(n + 2, -1, -1):",
"+ finv[i] = finv[i + 1] * (i + 1) % mod"
] | false | 0.541428 | 0.305178 | 1.774137 | [
"s845975890",
"s869794896"
] |
u145950990 | p03013 | python | s380269615 | s362930070 | 252 | 224 | 7,700 | 13,216 | Accepted | Accepted | 11.11 | n,m = list(map(int,input().split()))
oks = [True]*(n+1)
for i in range(m):
a = int(eval(input()))
oks[a] = False
dp = [0]*(n+1)
dp[0] = 1
for i in range(n+1):
for j in range(i+1,min(n+1,i+3)):
if oks[j]:
dp[j] += dp[i]
dp[j] %= 1000000007
print((dp[n]))
| n,m = list(map(int,input().split()))
a = set([int(eval(input())) for i in range(m)])
mod = 10**9+7
dp = [0]*(n+1)
dp[0] = 1
for i in range(n):
if i+1<n+1 and not i+1 in a:
dp[i+1] += dp[i]
dp[i+1] %= mod
if i+2<n+1 and not i+2 in a:
dp[i+2] += dp[i]
dp[i+2] %= mod
print((dp[n])) | 13 | 15 | 296 | 321 | n, m = list(map(int, input().split()))
oks = [True] * (n + 1)
for i in range(m):
a = int(eval(input()))
oks[a] = False
dp = [0] * (n + 1)
dp[0] = 1
for i in range(n + 1):
for j in range(i + 1, min(n + 1, i + 3)):
if oks[j]:
dp[j] += dp[i]
dp[j] %= 1000000007
print((dp[n]))
| n, m = list(map(int, input().split()))
a = set([int(eval(input())) for i in range(m)])
mod = 10**9 + 7
dp = [0] * (n + 1)
dp[0] = 1
for i in range(n):
if i + 1 < n + 1 and not i + 1 in a:
dp[i + 1] += dp[i]
dp[i + 1] %= mod
if i + 2 < n + 1 and not i + 2 in a:
dp[i + 2] += dp[i]
dp[i + 2] %= mod
print((dp[n]))
| false | 13.333333 | [
"-oks = [True] * (n + 1)",
"-for i in range(m):",
"- a = int(eval(input()))",
"- oks[a] = False",
"+a = set([int(eval(input())) for i in range(m)])",
"+mod = 10**9 + 7",
"-for i in range(n + 1):",
"- for j in range(i + 1, min(n + 1, i + 3)):",
"- if oks[j]:",
"- dp[j] += dp[i]",
"- dp[j] %= 1000000007",
"+for i in range(n):",
"+ if i + 1 < n + 1 and not i + 1 in a:",
"+ dp[i + 1] += dp[i]",
"+ dp[i + 1] %= mod",
"+ if i + 2 < n + 1 and not i + 2 in a:",
"+ dp[i + 2] += dp[i]",
"+ dp[i + 2] %= mod"
] | false | 0.033911 | 0.030852 | 1.099172 | [
"s380269615",
"s362930070"
] |
u941284420 | p02983 | python | s671898079 | s320043229 | 765 | 658 | 3,064 | 3,064 | Accepted | Accepted | 13.99 | #!/usr/bin/env python3
import sys
MOD = 2019 # type: int
def solve(L: int, R: int):
list_lr_mod = []
ans = 2018
for i, x in enumerate(range(L, R + 1)):
list_lr_mod.append(x % MOD)
if i + 1 >= 2019:
print((0))
return
if 0 in list_lr_mod:
print((0))
return
for i in range(len(list_lr_mod) - 1):
for j in range(i + 1, len(list_lr_mod)):
tmp = list_lr_mod[i] * list_lr_mod[j]
ans = min(ans, tmp % MOD)
print(ans)
# Generated by 1.1.6 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
L = int(next(tokens)) # type: int
R = int(next(tokens)) # type: int
solve(L, R)
if __name__ == '__main__':
main()
| #!/usr/bin/env python3
import sys
MOD = 2019 # type: int
def solve(L: int, R: int):
list_lr_mod = []
ans = 2018
if R - L >= 2018:
print((0))
return
for i, x in enumerate(range(L, R + 1)):
xmod = x % MOD
if xmod == 0:
print((0))
return
else:
list_lr_mod.append(xmod)
for i in range(len(list_lr_mod) - 1):
for j in range(i + 1, len(list_lr_mod)):
tmp = list_lr_mod[i] * list_lr_mod[j]
ans = min(ans, tmp % MOD)
print(ans)
# Generated by 1.1.6 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
L = int(next(tokens)) # type: int
R = int(next(tokens)) # type: int
solve(L, R)
if __name__ == '__main__':
main()
| 41 | 43 | 1,030 | 1,063 | #!/usr/bin/env python3
import sys
MOD = 2019 # type: int
def solve(L: int, R: int):
list_lr_mod = []
ans = 2018
for i, x in enumerate(range(L, R + 1)):
list_lr_mod.append(x % MOD)
if i + 1 >= 2019:
print((0))
return
if 0 in list_lr_mod:
print((0))
return
for i in range(len(list_lr_mod) - 1):
for j in range(i + 1, len(list_lr_mod)):
tmp = list_lr_mod[i] * list_lr_mod[j]
ans = min(ans, tmp % MOD)
print(ans)
# Generated by 1.1.6 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
L = int(next(tokens)) # type: int
R = int(next(tokens)) # type: int
solve(L, R)
if __name__ == "__main__":
main()
| #!/usr/bin/env python3
import sys
MOD = 2019 # type: int
def solve(L: int, R: int):
list_lr_mod = []
ans = 2018
if R - L >= 2018:
print((0))
return
for i, x in enumerate(range(L, R + 1)):
xmod = x % MOD
if xmod == 0:
print((0))
return
else:
list_lr_mod.append(xmod)
for i in range(len(list_lr_mod) - 1):
for j in range(i + 1, len(list_lr_mod)):
tmp = list_lr_mod[i] * list_lr_mod[j]
ans = min(ans, tmp % MOD)
print(ans)
# Generated by 1.1.6 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
L = int(next(tokens)) # type: int
R = int(next(tokens)) # type: int
solve(L, R)
if __name__ == "__main__":
main()
| false | 4.651163 | [
"+ if R - L >= 2018:",
"+ print((0))",
"+ return",
"- list_lr_mod.append(x % MOD)",
"- if i + 1 >= 2019:",
"+ xmod = x % MOD",
"+ if xmod == 0:",
"- if 0 in list_lr_mod:",
"- print((0))",
"- return",
"+ else:",
"+ list_lr_mod.append(xmod)"
] | false | 0.037 | 0.036759 | 1.006555 | [
"s671898079",
"s320043229"
] |
u704563784 | p02659 | python | s925224292 | s602484328 | 26 | 21 | 9,936 | 9,148 | Accepted | Accepted | 19.23 | from decimal import *
n, m = input().split()
root2 = Decimal(n) * Decimal(m)
n = 0
y = Decimal(str(root2)).quantize(Decimal(str(10**(n*-1))), rounding=ROUND_DOWN)
print(y) | n, m = input().split()
n = int(n)
a, b = list(map(int, m.split('.')))
m = a*100 + b
print(((n*m)//100)) | 6 | 5 | 178 | 99 | from decimal import *
n, m = input().split()
root2 = Decimal(n) * Decimal(m)
n = 0
y = Decimal(str(root2)).quantize(Decimal(str(10 ** (n * -1))), rounding=ROUND_DOWN)
print(y)
| n, m = input().split()
n = int(n)
a, b = list(map(int, m.split(".")))
m = a * 100 + b
print(((n * m) // 100))
| false | 16.666667 | [
"-from decimal import *",
"-",
"-root2 = Decimal(n) * Decimal(m)",
"-n = 0",
"-y = Decimal(str(root2)).quantize(Decimal(str(10 ** (n * -1))), rounding=ROUND_DOWN)",
"-print(y)",
"+n = int(n)",
"+a, b = list(map(int, m.split(\".\")))",
"+m = a * 100 + b",
"+print(((n * m) // 100))"
] | false | 0.095989 | 0.080425 | 1.193521 | [
"s925224292",
"s602484328"
] |
u342869120 | p02665 | python | s616016887 | s329035212 | 84 | 77 | 86,588 | 86,524 | Accepted | Accepted | 8.33 | N = int(eval(input()))
*A, = list(map(int, input().split()))
Asum = [a for a in A]
for i in range(N-1, -1, -1):
Asum[i] += Asum[i+1]
ans = 0
v = 1 # 子になれる頂点数
for i in range(N+1):
if v < A[i]:
ans = -1
break
ans += v
p = v-A[i]
if i < N:
if p > Asum[i+1]:
ans = -1
break
v = min(Asum[i+1], 2*p)
print(ans)
| N = int(eval(input()))
*A, = list(map(int, input().split()))
Asum = [a for a in A]
for i in range(N-1, -1, -1):
Asum[i] += Asum[i+1]
ans = 0
v = 1 # 子になれる頂点数
for i in range(N+1):
if v < A[i]:
ans = -1
break
ans += v
p = v-A[i]
if i < N:
v = min(Asum[i+1], 2*p)
print(ans)
| 23 | 20 | 396 | 328 | N = int(eval(input()))
(*A,) = list(map(int, input().split()))
Asum = [a for a in A]
for i in range(N - 1, -1, -1):
Asum[i] += Asum[i + 1]
ans = 0
v = 1 # 子になれる頂点数
for i in range(N + 1):
if v < A[i]:
ans = -1
break
ans += v
p = v - A[i]
if i < N:
if p > Asum[i + 1]:
ans = -1
break
v = min(Asum[i + 1], 2 * p)
print(ans)
| N = int(eval(input()))
(*A,) = list(map(int, input().split()))
Asum = [a for a in A]
for i in range(N - 1, -1, -1):
Asum[i] += Asum[i + 1]
ans = 0
v = 1 # 子になれる頂点数
for i in range(N + 1):
if v < A[i]:
ans = -1
break
ans += v
p = v - A[i]
if i < N:
v = min(Asum[i + 1], 2 * p)
print(ans)
| false | 13.043478 | [
"- if p > Asum[i + 1]:",
"- ans = -1",
"- break"
] | false | 0.1057 | 0.119394 | 0.885307 | [
"s616016887",
"s329035212"
] |
u764860452 | p03031 | python | s508483560 | s509981009 | 37 | 23 | 3,064 | 3,188 | Accepted | Accepted | 37.84 | def main():
N,M=list(map(int,input().split()))
s=[list(map(int,input().split()))[1:] for i in range(M)]
p=list(map(int,input().split()))
ans=0
for i in range(2**N):
flag=True
for j in range(M):
if not ([(i>>k-1)&1 for k in s[j]].count(1)%2==p[j]):
flag=False
if flag:
ans+=1
print(ans)
if __name__=="__main__":
main() | import itertools
def main():
N,M=list(map(int,input().split()))
sw =[list(map(int, input().split())) for _ in range(M)]
p=[int(x) for x in input().split()]
ans=0
for i in itertools.product([0,1],repeat=N):
onof=True
for j in range(M):
counter=0
for k in sw[j][1:]:
counter+=i[k-1]
if counter%2!=p[j]:
onof=False
break
if onof:
ans+=1
print(ans)
if __name__=="__main__":
main() | 19 | 23 | 457 | 551 | def main():
N, M = list(map(int, input().split()))
s = [list(map(int, input().split()))[1:] for i in range(M)]
p = list(map(int, input().split()))
ans = 0
for i in range(2**N):
flag = True
for j in range(M):
if not ([(i >> k - 1) & 1 for k in s[j]].count(1) % 2 == p[j]):
flag = False
if flag:
ans += 1
print(ans)
if __name__ == "__main__":
main()
| import itertools
def main():
N, M = list(map(int, input().split()))
sw = [list(map(int, input().split())) for _ in range(M)]
p = [int(x) for x in input().split()]
ans = 0
for i in itertools.product([0, 1], repeat=N):
onof = True
for j in range(M):
counter = 0
for k in sw[j][1:]:
counter += i[k - 1]
if counter % 2 != p[j]:
onof = False
break
if onof:
ans += 1
print(ans)
if __name__ == "__main__":
main()
| false | 17.391304 | [
"+import itertools",
"+",
"+",
"- s = [list(map(int, input().split()))[1:] for i in range(M)]",
"- p = list(map(int, input().split()))",
"+ sw = [list(map(int, input().split())) for _ in range(M)]",
"+ p = [int(x) for x in input().split()]",
"- for i in range(2**N):",
"- flag = True",
"+ for i in itertools.product([0, 1], repeat=N):",
"+ onof = True",
"- if not ([(i >> k - 1) & 1 for k in s[j]].count(1) % 2 == p[j]):",
"- flag = False",
"- if flag:",
"+ counter = 0",
"+ for k in sw[j][1:]:",
"+ counter += i[k - 1]",
"+ if counter % 2 != p[j]:",
"+ onof = False",
"+ break",
"+ if onof:"
] | false | 0.035882 | 0.036677 | 0.978344 | [
"s508483560",
"s509981009"
] |
u389523677 | p02971 | python | s121650909 | s232025492 | 557 | 475 | 14,476 | 26,508 | Accepted | Accepted | 14.72 | N = int(eval(input()))
A = list(int(eval(input())) for k in range(N))
mx, mxn = sorted(A, reverse=True)[:2]
for i in range(N):
if A[i] == mx:
print(mxn)
else:
print(mx)
| N = int(eval(input()))
A = list(int(eval(input())) for k in range(N))
mx, mxn = sorted(A, reverse=True)[:2]
result = [mxn if x==mx else mx for x in A]
print(('\n'.join(map(str, result)))) | 10 | 7 | 192 | 181 | N = int(eval(input()))
A = list(int(eval(input())) for k in range(N))
mx, mxn = sorted(A, reverse=True)[:2]
for i in range(N):
if A[i] == mx:
print(mxn)
else:
print(mx)
| N = int(eval(input()))
A = list(int(eval(input())) for k in range(N))
mx, mxn = sorted(A, reverse=True)[:2]
result = [mxn if x == mx else mx for x in A]
print(("\n".join(map(str, result))))
| false | 30 | [
"-for i in range(N):",
"- if A[i] == mx:",
"- print(mxn)",
"- else:",
"- print(mx)",
"+result = [mxn if x == mx else mx for x in A]",
"+print((\"\\n\".join(map(str, result))))"
] | false | 0.036802 | 0.036754 | 1.001293 | [
"s121650909",
"s232025492"
] |
u298297089 | p03338 | python | s716471126 | s388180753 | 213 | 23 | 43,628 | 3,444 | Accepted | Accepted | 89.2 | from collections import Counter
N = int(eval(input()))
S = eval(input())
mx = 0
for i in range(1,N):
pre = Counter(S[:i])
back = Counter(S[i:])
tmp = 0
for k in list(pre.keys()):
if k in back:
tmp += 1
mx = max(mx, tmp)
print(mx)
| from collections import Counter
n = int(eval(input()))
s = eval(input())
ans = 0
for i in range(1,n-1):
a = Counter(s[:i])
b = Counter(s[i:])
cnt = 0
for k in list(a.keys()):
if k in b:
cnt += 1
if cnt > ans:
ans = cnt
print(ans) | 13 | 15 | 264 | 274 | from collections import Counter
N = int(eval(input()))
S = eval(input())
mx = 0
for i in range(1, N):
pre = Counter(S[:i])
back = Counter(S[i:])
tmp = 0
for k in list(pre.keys()):
if k in back:
tmp += 1
mx = max(mx, tmp)
print(mx)
| from collections import Counter
n = int(eval(input()))
s = eval(input())
ans = 0
for i in range(1, n - 1):
a = Counter(s[:i])
b = Counter(s[i:])
cnt = 0
for k in list(a.keys()):
if k in b:
cnt += 1
if cnt > ans:
ans = cnt
print(ans)
| false | 13.333333 | [
"-N = int(eval(input()))",
"-S = eval(input())",
"-mx = 0",
"-for i in range(1, N):",
"- pre = Counter(S[:i])",
"- back = Counter(S[i:])",
"- tmp = 0",
"- for k in list(pre.keys()):",
"- if k in back:",
"- tmp += 1",
"- mx = max(mx, tmp)",
"-print(mx)",
"+n = int(eval(input()))",
"+s = eval(input())",
"+ans = 0",
"+for i in range(1, n - 1):",
"+ a = Counter(s[:i])",
"+ b = Counter(s[i:])",
"+ cnt = 0",
"+ for k in list(a.keys()):",
"+ if k in b:",
"+ cnt += 1",
"+ if cnt > ans:",
"+ ans = cnt",
"+print(ans)"
] | false | 0.040913 | 0.035352 | 1.157316 | [
"s716471126",
"s388180753"
] |
u796942881 | p03103 | python | s168444281 | s775645431 | 241 | 174 | 22,804 | 25,836 | Accepted | Accepted | 27.8 | from sys import stdin
from operator import itemgetter
input = stdin.readline
N, M = list(map(int, input().split()))
AB = [[int(j) for j in input().split()] for i in range(N)]
def main():
AB.sort(key=itemgetter(0))
num = 0
yen = 0
for i in range(N):
if M < num + AB[i][1]:
yen += AB[i][0] * (M - num)
break
else:
yen += AB[i][0] * AB[i][1]
num += AB[i][1]
print(yen)
return
main()
| from sys import stdin
N, M = list(map(int, input().split()))
*AB, = list(map(int, stdin.read().split()))
def main():
A = AB[::2]
B = AB[1::2]
Z = list(zip(A, B))
Z = sorted(Z)
num = 0
yen = 0
for a, b in Z:
if M < num + b:
yen += a * (M - num)
break
else:
yen += a * b
num += b
print(yen)
return
main()
| 26 | 25 | 494 | 414 | from sys import stdin
from operator import itemgetter
input = stdin.readline
N, M = list(map(int, input().split()))
AB = [[int(j) for j in input().split()] for i in range(N)]
def main():
AB.sort(key=itemgetter(0))
num = 0
yen = 0
for i in range(N):
if M < num + AB[i][1]:
yen += AB[i][0] * (M - num)
break
else:
yen += AB[i][0] * AB[i][1]
num += AB[i][1]
print(yen)
return
main()
| from sys import stdin
N, M = list(map(int, input().split()))
(*AB,) = list(map(int, stdin.read().split()))
def main():
A = AB[::2]
B = AB[1::2]
Z = list(zip(A, B))
Z = sorted(Z)
num = 0
yen = 0
for a, b in Z:
if M < num + b:
yen += a * (M - num)
break
else:
yen += a * b
num += b
print(yen)
return
main()
| false | 3.846154 | [
"-from operator import itemgetter",
"-input = stdin.readline",
"-AB = [[int(j) for j in input().split()] for i in range(N)]",
"+(*AB,) = list(map(int, stdin.read().split()))",
"- AB.sort(key=itemgetter(0))",
"+ A = AB[::2]",
"+ B = AB[1::2]",
"+ Z = list(zip(A, B))",
"+ Z = sorted(Z)",
"- for i in range(N):",
"- if M < num + AB[i][1]:",
"- yen += AB[i][0] * (M - num)",
"+ for a, b in Z:",
"+ if M < num + b:",
"+ yen += a * (M - num)",
"- yen += AB[i][0] * AB[i][1]",
"- num += AB[i][1]",
"+ yen += a * b",
"+ num += b"
] | false | 0.116594 | 0.114525 | 1.018061 | [
"s168444281",
"s775645431"
] |
u545368057 | p02973 | python | s191187533 | s909405257 | 589 | 278 | 51,108 | 7,068 | Accepted | Accepted | 52.8 | """
A = a1,a2,a3,a4,...
同じ色のとき、i<jならai<aj
が成り立つときの最小の色の数
2 1 4 5 3
8
5
4
3
2
1
3
2
1
5
4
3
2 3
1 2
1
"""
from bisect import bisect_right
prev = 10**9+7
cnt = 0
As = [-prev]
n = int(eval(input()))
for _ in range(n):
a = int(eval(input()))
update = bisect_right(As,-a)
if update-1 == cnt:
As.append(-a)
cnt += 1
else:
As[update] = -a
prev = a
print(cnt)
| """
A = a1,a2,a3,a4,...
同じ色のとき、i<jならai<aj
が成り立つときの最小の色の数
"""
from bisect import bisect_right
prev = 10**9+7
cnt = 0
As = [-prev]
n = int(eval(input()))
for _ in range(n):
a = int(eval(input()))
update = bisect_right(As,-a)
if update-1 == cnt:
As.append(-a)
cnt += 1
else:
As[update] = -a
prev = a
print(cnt)
| 47 | 25 | 449 | 370 | """
A = a1,a2,a3,a4,...
同じ色のとき、i<jならai<aj
が成り立つときの最小の色の数
2 1 4 5 3
8
5
4
3
2
1
3
2
1
5
4
3
2 3
1 2
1
"""
from bisect import bisect_right
prev = 10**9 + 7
cnt = 0
As = [-prev]
n = int(eval(input()))
for _ in range(n):
a = int(eval(input()))
update = bisect_right(As, -a)
if update - 1 == cnt:
As.append(-a)
cnt += 1
else:
As[update] = -a
prev = a
print(cnt)
| """
A = a1,a2,a3,a4,...
同じ色のとき、i<jならai<aj
が成り立つときの最小の色の数
"""
from bisect import bisect_right
prev = 10**9 + 7
cnt = 0
As = [-prev]
n = int(eval(input()))
for _ in range(n):
a = int(eval(input()))
update = bisect_right(As, -a)
if update - 1 == cnt:
As.append(-a)
cnt += 1
else:
As[update] = -a
prev = a
print(cnt)
| false | 46.808511 | [
"-2 1 4 5 3",
"-8",
"-5",
"-4",
"-3",
"-2",
"-1",
"-3",
"-2",
"-1",
"-5",
"-4",
"-3",
"-2 3",
"-1 2",
"-1"
] | false | 0.04617 | 0.060029 | 0.769124 | [
"s191187533",
"s909405257"
] |
u212831449 | p03295 | python | s161193246 | s662935580 | 424 | 259 | 17,012 | 24,716 | Accepted | Accepted | 38.92 | n,m = list(map(int,input().split()))
s = []
for i in range(m):
a,b = list(map(int,input().split()))
s.append((b,a))
s.sort()
ans = 1
start = s[0][1]
end = s[0][0]
for i in range(1,m):
temp_start = s[i][1]
temp_end = s[i][0]
if temp_start >= end:
ans += 1
end = temp_end
print(ans) | n,m = list(map(int,input().split()))
l = []
for i in range(m):
a,b = list(map(int,input().split()))
l.append((a,b))
l = sorted(l, reverse=False, key=lambda x: x[1])
ans = 1
tmp = l[0][1]
for i in range(1,len(l)):
if tmp <= l[i][0]:
tmp = l[i][1]
ans += 1
print(ans)
| 19 | 18 | 329 | 319 | n, m = list(map(int, input().split()))
s = []
for i in range(m):
a, b = list(map(int, input().split()))
s.append((b, a))
s.sort()
ans = 1
start = s[0][1]
end = s[0][0]
for i in range(1, m):
temp_start = s[i][1]
temp_end = s[i][0]
if temp_start >= end:
ans += 1
end = temp_end
print(ans)
| n, m = list(map(int, input().split()))
l = []
for i in range(m):
a, b = list(map(int, input().split()))
l.append((a, b))
l = sorted(l, reverse=False, key=lambda x: x[1])
ans = 1
tmp = l[0][1]
for i in range(1, len(l)):
if tmp <= l[i][0]:
tmp = l[i][1]
ans += 1
print(ans)
| false | 5.263158 | [
"-s = []",
"+l = []",
"- s.append((b, a))",
"-s.sort()",
"+ l.append((a, b))",
"+l = sorted(l, reverse=False, key=lambda x: x[1])",
"-start = s[0][1]",
"-end = s[0][0]",
"-for i in range(1, m):",
"- temp_start = s[i][1]",
"- temp_end = s[i][0]",
"- if temp_start >= end:",
"+tmp = l[0][1]",
"+for i in range(1, len(l)):",
"+ if tmp <= l[i][0]:",
"+ tmp = l[i][1]",
"- end = temp_end"
] | false | 0.047427 | 0.047513 | 0.99818 | [
"s161193246",
"s662935580"
] |
u869919400 | p03807 | python | s045784610 | s567111729 | 262 | 226 | 62,448 | 62,448 | Accepted | Accepted | 13.74 | n = int(eval(input()))
arr = list(map(int, input().split()))
odd = 0
for i in range(n):
if arr[i] % 2 != 0:
odd += 1
if odd % 2 == 0:
print('YES')
else:
print('NO') | n = int(eval(input()))
arr = list(map(int, input().split()))
odd = 0
for i in range(n):
if arr[i] % 2 != 0:
odd += 1
print(('YES' if odd % 2 == 0 else 'NO')) | 12 | 7 | 191 | 167 | n = int(eval(input()))
arr = list(map(int, input().split()))
odd = 0
for i in range(n):
if arr[i] % 2 != 0:
odd += 1
if odd % 2 == 0:
print("YES")
else:
print("NO")
| n = int(eval(input()))
arr = list(map(int, input().split()))
odd = 0
for i in range(n):
if arr[i] % 2 != 0:
odd += 1
print(("YES" if odd % 2 == 0 else "NO"))
| false | 41.666667 | [
"-if odd % 2 == 0:",
"- print(\"YES\")",
"-else:",
"- print(\"NO\")",
"+print((\"YES\" if odd % 2 == 0 else \"NO\"))"
] | false | 0.047989 | 0.04413 | 1.087439 | [
"s045784610",
"s567111729"
] |
u814265211 | p03545 | python | s049146913 | s888589550 | 177 | 28 | 38,256 | 9,072 | Accepted | Accepted | 84.18 | A, B, C, D = list(map(int, list(eval(input()))))
if A-B-C-D == 7:
print(('{}{}{}{}{}{}{}{}'.format(A, '-', B, '-', C, '-', D, '=7')))
elif A-B-C+D == 7:
print(('{}{}{}{}{}{}{}{}'.format(A, '-', B, '-', C, '+', D, '=7')))
elif A-B+C-D == 7:
print(('{}{}{}{}{}{}{}{}'.format(A, '-', B, '+', C, '-', D, '=7')))
elif A-B+C+D == 7:
print(('{}{}{}{}{}{}{}{}'.format(A, '-', B, '+', C, '+', D, '=7')))
elif A+B-C-D == 7:
print(('{}{}{}{}{}{}{}{}'.format(A, '+', B, '-', C, '-', D, '=7')))
elif A+B-C+D == 7:
print(('{}{}{}{}{}{}{}{}'.format(A, '+', B, '-', C, '+', D, '=7')))
elif A+B+C-D == 7:
print(('{}{}{}{}{}{}{}{}'.format(A, '+', B, '+', C, '-', D, '=7')))
elif A+B+C+D == 7:
print(('{}{}{}{}{}{}{}{}'.format(A, '+', B, '+', C, '+', D, '=7')))
| ABCD = list(eval(input()))
for i in range(2 ** 3):
ptn = ['-'] * 3
for j in range(3):
if (i >> j) & 1:
ptn[len(ptn) - j - 1] = '+'
formula = ''.join([n + op for n, op in zip(ABCD, ptn + [''])])
if eval(formula) == 7:
print((formula + '=7'))
exit()
| 18 | 12 | 765 | 305 | A, B, C, D = list(map(int, list(eval(input()))))
if A - B - C - D == 7:
print(("{}{}{}{}{}{}{}{}".format(A, "-", B, "-", C, "-", D, "=7")))
elif A - B - C + D == 7:
print(("{}{}{}{}{}{}{}{}".format(A, "-", B, "-", C, "+", D, "=7")))
elif A - B + C - D == 7:
print(("{}{}{}{}{}{}{}{}".format(A, "-", B, "+", C, "-", D, "=7")))
elif A - B + C + D == 7:
print(("{}{}{}{}{}{}{}{}".format(A, "-", B, "+", C, "+", D, "=7")))
elif A + B - C - D == 7:
print(("{}{}{}{}{}{}{}{}".format(A, "+", B, "-", C, "-", D, "=7")))
elif A + B - C + D == 7:
print(("{}{}{}{}{}{}{}{}".format(A, "+", B, "-", C, "+", D, "=7")))
elif A + B + C - D == 7:
print(("{}{}{}{}{}{}{}{}".format(A, "+", B, "+", C, "-", D, "=7")))
elif A + B + C + D == 7:
print(("{}{}{}{}{}{}{}{}".format(A, "+", B, "+", C, "+", D, "=7")))
| ABCD = list(eval(input()))
for i in range(2**3):
ptn = ["-"] * 3
for j in range(3):
if (i >> j) & 1:
ptn[len(ptn) - j - 1] = "+"
formula = "".join([n + op for n, op in zip(ABCD, ptn + [""])])
if eval(formula) == 7:
print((formula + "=7"))
exit()
| false | 33.333333 | [
"-A, B, C, D = list(map(int, list(eval(input()))))",
"-if A - B - C - D == 7:",
"- print((\"{}{}{}{}{}{}{}{}\".format(A, \"-\", B, \"-\", C, \"-\", D, \"=7\")))",
"-elif A - B - C + D == 7:",
"- print((\"{}{}{}{}{}{}{}{}\".format(A, \"-\", B, \"-\", C, \"+\", D, \"=7\")))",
"-elif A - B + C - D == 7:",
"- print((\"{}{}{}{}{}{}{}{}\".format(A, \"-\", B, \"+\", C, \"-\", D, \"=7\")))",
"-elif A - B + C + D == 7:",
"- print((\"{}{}{}{}{}{}{}{}\".format(A, \"-\", B, \"+\", C, \"+\", D, \"=7\")))",
"-elif A + B - C - D == 7:",
"- print((\"{}{}{}{}{}{}{}{}\".format(A, \"+\", B, \"-\", C, \"-\", D, \"=7\")))",
"-elif A + B - C + D == 7:",
"- print((\"{}{}{}{}{}{}{}{}\".format(A, \"+\", B, \"-\", C, \"+\", D, \"=7\")))",
"-elif A + B + C - D == 7:",
"- print((\"{}{}{}{}{}{}{}{}\".format(A, \"+\", B, \"+\", C, \"-\", D, \"=7\")))",
"-elif A + B + C + D == 7:",
"- print((\"{}{}{}{}{}{}{}{}\".format(A, \"+\", B, \"+\", C, \"+\", D, \"=7\")))",
"+ABCD = list(eval(input()))",
"+for i in range(2**3):",
"+ ptn = [\"-\"] * 3",
"+ for j in range(3):",
"+ if (i >> j) & 1:",
"+ ptn[len(ptn) - j - 1] = \"+\"",
"+ formula = \"\".join([n + op for n, op in zip(ABCD, ptn + [\"\"])])",
"+ if eval(formula) == 7:",
"+ print((formula + \"=7\"))",
"+ exit()"
] | false | 0.091623 | 0.047529 | 1.927728 | [
"s049146913",
"s888589550"
] |
u217627525 | p03814 | python | s940634489 | s862868853 | 67 | 59 | 3,512 | 3,516 | Accepted | Accepted | 11.94 | s=eval(input())
a=0
find_a=0
z=len(s)-1
find_z=0
while find_a==0 or find_z==0:
if find_a==0 and s[a]=="A":
find_a=1
if find_z==0 and s[z]=="Z":
find_z=1
if find_a==0:
a+=1
if find_z==0:
z-=1
print((z-a+1)) | s=eval(input())
a=0
find_a=0
z=len(s)-1
find_z=0
while find_a==0 or find_z==0:
if find_a==0:
if s[a]=="A":
find_a=1
else:
a+=1
if find_z==0:
if s[z]=="Z":
find_z=1
else:
z-=1
print((z-a+1)) | 15 | 17 | 259 | 285 | s = eval(input())
a = 0
find_a = 0
z = len(s) - 1
find_z = 0
while find_a == 0 or find_z == 0:
if find_a == 0 and s[a] == "A":
find_a = 1
if find_z == 0 and s[z] == "Z":
find_z = 1
if find_a == 0:
a += 1
if find_z == 0:
z -= 1
print((z - a + 1))
| s = eval(input())
a = 0
find_a = 0
z = len(s) - 1
find_z = 0
while find_a == 0 or find_z == 0:
if find_a == 0:
if s[a] == "A":
find_a = 1
else:
a += 1
if find_z == 0:
if s[z] == "Z":
find_z = 1
else:
z -= 1
print((z - a + 1))
| false | 11.764706 | [
"- if find_a == 0 and s[a] == \"A\":",
"- find_a = 1",
"- if find_z == 0 and s[z] == \"Z\":",
"- find_z = 1",
"- a += 1",
"+ if s[a] == \"A\":",
"+ find_a = 1",
"+ else:",
"+ a += 1",
"- z -= 1",
"+ if s[z] == \"Z\":",
"+ find_z = 1",
"+ else:",
"+ z -= 1"
] | false | 0.085746 | 0.144527 | 0.593287 | [
"s940634489",
"s862868853"
] |
u001769145 | p03600 | python | s550725362 | s861638595 | 374 | 191 | 74,172 | 75,516 | Accepted | Accepted | 48.93 | # 63
n = int(eval(input()))
dp = [[int(x) for x in input().split()] for y in range(n)]
del_l = []
ans = 0
for i in range(n):
for j in range(i+1,n):
ans += dp[i][j]
for i in range(n-1):
for j in range(i+1,n):
for k in range(n):
if k in (i,j):
continue
if dp[i][j] > dp[i][k] + dp[k][j]:
print("-1")
exit()
elif dp[i][j] == dp[i][k] + dp[k][j]:
ans -= dp[i][j]
break
print(ans) | # 63
n = int(eval(input()))
dp = [[int(x) for x in input().split()] for y in range(n)]
del_l = []
ans = 0
for i in range(n-1):
for j in range(i+1,n):
for k in range(n):
if k in (i,j):
continue
if dp[i][j] > dp[i][k] + dp[k][j]:
print("-1")
exit()
elif dp[i][j] == dp[i][k] + dp[k][j]:
break
else:
ans += dp[i][j]
print(ans) | 25 | 22 | 538 | 474 | # 63
n = int(eval(input()))
dp = [[int(x) for x in input().split()] for y in range(n)]
del_l = []
ans = 0
for i in range(n):
for j in range(i + 1, n):
ans += dp[i][j]
for i in range(n - 1):
for j in range(i + 1, n):
for k in range(n):
if k in (i, j):
continue
if dp[i][j] > dp[i][k] + dp[k][j]:
print("-1")
exit()
elif dp[i][j] == dp[i][k] + dp[k][j]:
ans -= dp[i][j]
break
print(ans)
| # 63
n = int(eval(input()))
dp = [[int(x) for x in input().split()] for y in range(n)]
del_l = []
ans = 0
for i in range(n - 1):
for j in range(i + 1, n):
for k in range(n):
if k in (i, j):
continue
if dp[i][j] > dp[i][k] + dp[k][j]:
print("-1")
exit()
elif dp[i][j] == dp[i][k] + dp[k][j]:
break
else:
ans += dp[i][j]
print(ans)
| false | 12 | [
"-for i in range(n):",
"- for j in range(i + 1, n):",
"- ans += dp[i][j]",
"- ans -= dp[i][j]",
"+ else:",
"+ ans += dp[i][j]"
] | false | 0.182972 | 0.047217 | 3.875154 | [
"s550725362",
"s861638595"
] |
u130900604 | p02717 | python | s342246573 | s019604041 | 166 | 17 | 38,384 | 2,940 | Accepted | Accepted | 89.76 | def MI():return list(map(int,input().split()))
def LI():return list(MI())
x,y,z=MI()
x,y=y,x
x,z=z,x
print((x,y,z)) | x,y,z=list(map(int,input().split()))
print((z,x,y)) | 9 | 2 | 118 | 44 | def MI():
return list(map(int, input().split()))
def LI():
return list(MI())
x, y, z = MI()
x, y = y, x
x, z = z, x
print((x, y, z))
| x, y, z = list(map(int, input().split()))
print((z, x, y))
| false | 77.777778 | [
"-def MI():",
"- return list(map(int, input().split()))",
"-",
"-",
"-def LI():",
"- return list(MI())",
"-",
"-",
"-x, y, z = MI()",
"-x, y = y, x",
"-x, z = z, x",
"-print((x, y, z))",
"+x, y, z = list(map(int, input().split()))",
"+print((z, x, y))"
] | false | 0.047182 | 0.046721 | 1.009854 | [
"s342246573",
"s019604041"
] |
u254871849 | p02793 | python | s544070717 | s017465251 | 1,561 | 954 | 131,656 | 4,580 | Accepted | Accepted | 38.89 | import sys
MOD = 10 ** 9 + 7
from math import floor, sqrt
from bisect import bisect_right as bi_r
from collections import defaultdict
def prime_nums(n=10**6):
sieve = set(range(2, n + 1))
non_prime = set(range(2 * 2, n + 1, 2))
sieve -= non_prime
for i in range(3, floor(sqrt(n)) + 1, 2):
if i in sieve:
non_prime = set(range(i * 2, n + 1, i))
sieve -= non_prime
return sieve
p_nums = sorted(prime_nums())
def make_inv_table(n=10**6, p=MOD):
fac = [None] * (n + 1)
fac[0] = 1
for i in range(n):
fac[i+1] = fac[i] * (i + 1) % p
ifac = [None] * (n + 1)
ifac[n] = pow(fac[n], p-2, p)
for i in range(n, 0, -1):
ifac[i-1] = ifac[i] * i % p
inv = [None] * (n + 1)
for i in range(1, n+1):
inv[i] = ifac[i] * fac[i-1] % p
return inv
inv = make_inv_table()
n, *A = list(map(int, sys.stdin.read().split()))
def main():
facs = defaultdict(int)
for a in A:
if a == 1:
continue
for p in p_nums[:bi_r(p_nums, sqrt(a))]:
cnt = 0
while not a % p:
cnt += 1
a //= p
facs[p] = max(facs[p], cnt)
if a == 1:
break
else:
facs[a] = max(facs[a], 1)
lcm = 1
for f, c in list(facs.items()):
lcm *= pow(f, c, MOD)
lcm %= MOD
ans = 0
for a in A:
ans += lcm * inv[a] % MOD
ans %= MOD
return ans
if __name__ == '__main__':
ans = main()
print(ans) | import sys
from functools import reduce
MOD = 10 ** 9 + 7
def gcd(a, b):
while b:
a, b = b, a % b
return abs(a)
def lcm(a, b):
return abs(a // gcd(a, b) * b)
n, *A = list(map(int, sys.stdin.read().split()))
def main():
l = reduce(lcm, A, 1) % MOD
res = 0
for a in A:
res += l * pow(a, MOD-2, MOD) % MOD
res %= MOD
return res
if __name__ == '__main__':
ans = main()
print(ans) | 68 | 28 | 1,614 | 468 | import sys
MOD = 10**9 + 7
from math import floor, sqrt
from bisect import bisect_right as bi_r
from collections import defaultdict
def prime_nums(n=10**6):
sieve = set(range(2, n + 1))
non_prime = set(range(2 * 2, n + 1, 2))
sieve -= non_prime
for i in range(3, floor(sqrt(n)) + 1, 2):
if i in sieve:
non_prime = set(range(i * 2, n + 1, i))
sieve -= non_prime
return sieve
p_nums = sorted(prime_nums())
def make_inv_table(n=10**6, p=MOD):
fac = [None] * (n + 1)
fac[0] = 1
for i in range(n):
fac[i + 1] = fac[i] * (i + 1) % p
ifac = [None] * (n + 1)
ifac[n] = pow(fac[n], p - 2, p)
for i in range(n, 0, -1):
ifac[i - 1] = ifac[i] * i % p
inv = [None] * (n + 1)
for i in range(1, n + 1):
inv[i] = ifac[i] * fac[i - 1] % p
return inv
inv = make_inv_table()
n, *A = list(map(int, sys.stdin.read().split()))
def main():
facs = defaultdict(int)
for a in A:
if a == 1:
continue
for p in p_nums[: bi_r(p_nums, sqrt(a))]:
cnt = 0
while not a % p:
cnt += 1
a //= p
facs[p] = max(facs[p], cnt)
if a == 1:
break
else:
facs[a] = max(facs[a], 1)
lcm = 1
for f, c in list(facs.items()):
lcm *= pow(f, c, MOD)
lcm %= MOD
ans = 0
for a in A:
ans += lcm * inv[a] % MOD
ans %= MOD
return ans
if __name__ == "__main__":
ans = main()
print(ans)
| import sys
from functools import reduce
MOD = 10**9 + 7
def gcd(a, b):
while b:
a, b = b, a % b
return abs(a)
def lcm(a, b):
return abs(a // gcd(a, b) * b)
n, *A = list(map(int, sys.stdin.read().split()))
def main():
l = reduce(lcm, A, 1) % MOD
res = 0
for a in A:
res += l * pow(a, MOD - 2, MOD) % MOD
res %= MOD
return res
if __name__ == "__main__":
ans = main()
print(ans)
| false | 58.823529 | [
"+from functools import reduce",
"-from math import floor, sqrt",
"-from bisect import bisect_right as bi_r",
"-from collections import defaultdict",
"-def prime_nums(n=10**6):",
"- sieve = set(range(2, n + 1))",
"- non_prime = set(range(2 * 2, n + 1, 2))",
"- sieve -= non_prime",
"- for i in range(3, floor(sqrt(n)) + 1, 2):",
"- if i in sieve:",
"- non_prime = set(range(i * 2, n + 1, i))",
"- sieve -= non_prime",
"- return sieve",
"+def gcd(a, b):",
"+ while b:",
"+ a, b = b, a % b",
"+ return abs(a)",
"-p_nums = sorted(prime_nums())",
"+def lcm(a, b):",
"+ return abs(a // gcd(a, b) * b)",
"-def make_inv_table(n=10**6, p=MOD):",
"- fac = [None] * (n + 1)",
"- fac[0] = 1",
"- for i in range(n):",
"- fac[i + 1] = fac[i] * (i + 1) % p",
"- ifac = [None] * (n + 1)",
"- ifac[n] = pow(fac[n], p - 2, p)",
"- for i in range(n, 0, -1):",
"- ifac[i - 1] = ifac[i] * i % p",
"- inv = [None] * (n + 1)",
"- for i in range(1, n + 1):",
"- inv[i] = ifac[i] * fac[i - 1] % p",
"- return inv",
"-",
"-",
"-inv = make_inv_table()",
"- facs = defaultdict(int)",
"+ l = reduce(lcm, A, 1) % MOD",
"+ res = 0",
"- if a == 1:",
"- continue",
"- for p in p_nums[: bi_r(p_nums, sqrt(a))]:",
"- cnt = 0",
"- while not a % p:",
"- cnt += 1",
"- a //= p",
"- facs[p] = max(facs[p], cnt)",
"- if a == 1:",
"- break",
"- else:",
"- facs[a] = max(facs[a], 1)",
"- lcm = 1",
"- for f, c in list(facs.items()):",
"- lcm *= pow(f, c, MOD)",
"- lcm %= MOD",
"- ans = 0",
"- for a in A:",
"- ans += lcm * inv[a] % MOD",
"- ans %= MOD",
"- return ans",
"+ res += l * pow(a, MOD - 2, MOD) % MOD",
"+ res %= MOD",
"+ return res"
] | false | 1.90659 | 0.040558 | 47.009188 | [
"s544070717",
"s017465251"
] |
u923794601 | p03627 | python | s735780705 | s745889886 | 336 | 84 | 31,368 | 14,244 | Accepted | Accepted | 75 | #C_Make_A_Rectangle
import numpy as np
def MakeRectangle(N, A):
A = np.array(A)
length_list = list()
length_buff = 0
for length in np.sort(A)[::-1]:
if len(length_list) == 2:
break
if length_buff == length and length != 0:
length_list.append(length)
length_buff = 0
else:
length_buff = length
if len(length_list) < 2:
return 0
else:
return length_list[0] * length_list[1]
if __name__ == "__main__":
N = int(eval(input()))
A = list(map(int, input().split()))
S = MakeRectangle(N, A)
print(S) | #C_Make_A_Rectangle
def MakeRectangle(N, A):
A = sorted(A, reverse=True)
length_list = list()
length_buff = 0
for length in A:
if len(length_list) == 2:
break
if length_buff == length and length != 0:
length_list.append(length)
length_buff = 0
else:
length_buff = length
if len(length_list) < 2:
return 0
else:
return length_list[0] * length_list[1]
if __name__ == "__main__":
N = int(eval(input()))
A = list(map(int, input().split()))
S = MakeRectangle(N, A)
print(S) | 26 | 25 | 640 | 617 | # C_Make_A_Rectangle
import numpy as np
def MakeRectangle(N, A):
A = np.array(A)
length_list = list()
length_buff = 0
for length in np.sort(A)[::-1]:
if len(length_list) == 2:
break
if length_buff == length and length != 0:
length_list.append(length)
length_buff = 0
else:
length_buff = length
if len(length_list) < 2:
return 0
else:
return length_list[0] * length_list[1]
if __name__ == "__main__":
N = int(eval(input()))
A = list(map(int, input().split()))
S = MakeRectangle(N, A)
print(S)
| # C_Make_A_Rectangle
def MakeRectangle(N, A):
A = sorted(A, reverse=True)
length_list = list()
length_buff = 0
for length in A:
if len(length_list) == 2:
break
if length_buff == length and length != 0:
length_list.append(length)
length_buff = 0
else:
length_buff = length
if len(length_list) < 2:
return 0
else:
return length_list[0] * length_list[1]
if __name__ == "__main__":
N = int(eval(input()))
A = list(map(int, input().split()))
S = MakeRectangle(N, A)
print(S)
| false | 3.846154 | [
"-import numpy as np",
"-",
"-",
"- A = np.array(A)",
"+ A = sorted(A, reverse=True)",
"- for length in np.sort(A)[::-1]:",
"+ for length in A:"
] | false | 0.210333 | 0.110316 | 1.906645 | [
"s735780705",
"s745889886"
] |
u623231048 | p02958 | python | s823512512 | s628644852 | 30 | 17 | 3,444 | 2,940 | Accepted | Accepted | 43.33 | import copy
n = int(eval(input()))
li = list(map(int,input().split()))
if all([li[i] < li[i+1] for i in range(n-1)]):
print('YES')
exit()
for i in range(n):
for j in range(i+1,n):
a = copy.copy(li)
a[i],a[j] = a[j],a[i]
if all([a[i] < a[i+1] for i in range(n-1)]):
print('YES')
exit()
print('NO')
| n = int(eval(input()))
li = list(map(int,input().split()))
count = 0
for i in range(n):
if li[i] != i+1:
count += 1
if count <= 2:
print('YES')
else:
print('NO')
| 17 | 12 | 370 | 189 | import copy
n = int(eval(input()))
li = list(map(int, input().split()))
if all([li[i] < li[i + 1] for i in range(n - 1)]):
print("YES")
exit()
for i in range(n):
for j in range(i + 1, n):
a = copy.copy(li)
a[i], a[j] = a[j], a[i]
if all([a[i] < a[i + 1] for i in range(n - 1)]):
print("YES")
exit()
print("NO")
| n = int(eval(input()))
li = list(map(int, input().split()))
count = 0
for i in range(n):
if li[i] != i + 1:
count += 1
if count <= 2:
print("YES")
else:
print("NO")
| false | 29.411765 | [
"-import copy",
"-",
"-if all([li[i] < li[i + 1] for i in range(n - 1)]):",
"+count = 0",
"+for i in range(n):",
"+ if li[i] != i + 1:",
"+ count += 1",
"+if count <= 2:",
"- exit()",
"-for i in range(n):",
"- for j in range(i + 1, n):",
"- a = copy.copy(li)",
"- a[i], a[j] = a[j], a[i]",
"- if all([a[i] < a[i + 1] for i in range(n - 1)]):",
"- print(\"YES\")",
"- exit()",
"-print(\"NO\")",
"+else:",
"+ print(\"NO\")"
] | false | 0.058513 | 0.008012 | 7.302995 | [
"s823512512",
"s628644852"
] |
u785883180 | p02844 | python | s896962047 | s807831096 | 664 | 325 | 132,516 | 132,380 | Accepted | Accepted | 51.05 | n=int(eval(input()))
s=[int(c) for c in eval(input())]
count=0
for p in range(10):
for q in range(10):
for r in range(10):
if p in s[:n-2]:
inp=s.index(p)
if q in s[inp+1:n-1]:
inq=s[inp+1:n-1].index(q)+inp+1
if r in s[inq+1:]:
count+=1
print(count) | n=int(eval(input()))
s=[int(c) for c in eval(input())]
count=0
for p in range(10):
if p in s[:n-2]:
inp=s.index(p)
for q in range(10):
if q in s[inp+1:n-1]:
inq=s[inp+1:n-1].index(q)+inp+1
for r in range(10):
if r in s[inq+1:]:
count+=1
print(count) | 13 | 13 | 369 | 389 | n = int(eval(input()))
s = [int(c) for c in eval(input())]
count = 0
for p in range(10):
for q in range(10):
for r in range(10):
if p in s[: n - 2]:
inp = s.index(p)
if q in s[inp + 1 : n - 1]:
inq = s[inp + 1 : n - 1].index(q) + inp + 1
if r in s[inq + 1 :]:
count += 1
print(count)
| n = int(eval(input()))
s = [int(c) for c in eval(input())]
count = 0
for p in range(10):
if p in s[: n - 2]:
inp = s.index(p)
for q in range(10):
if q in s[inp + 1 : n - 1]:
inq = s[inp + 1 : n - 1].index(q) + inp + 1
for r in range(10):
if r in s[inq + 1 :]:
count += 1
print(count)
| false | 0 | [
"- for q in range(10):",
"- for r in range(10):",
"- if p in s[: n - 2]:",
"- inp = s.index(p)",
"- if q in s[inp + 1 : n - 1]:",
"- inq = s[inp + 1 : n - 1].index(q) + inp + 1",
"+ if p in s[: n - 2]:",
"+ inp = s.index(p)",
"+ for q in range(10):",
"+ if q in s[inp + 1 : n - 1]:",
"+ inq = s[inp + 1 : n - 1].index(q) + inp + 1",
"+ for r in range(10):"
] | false | 0.124297 | 0.117377 | 1.058959 | [
"s896962047",
"s807831096"
] |
u562935282 | p03212 | python | s655036064 | s276671284 | 91 | 83 | 3,060 | 2,940 | Accepted | Accepted | 8.79 | def check(var):
return (0 <= var <= N) and all(c in str(var) for c in '753')
def dfs(x):
res = 0
if check(x): res += 1
if x <= N:
for v in 3, 5, 7:
res += dfs(10 * x + v)
return res
N = int(eval(input()))
print((dfs(0)))
| def dfs(s):
res = 0
if int(s) > N: return res
if all(c in s for c in '753'): res += 1
for v in '753': res += dfs(s + v)
return res
N = int(eval(input()))
print((dfs('0')))
| 15 | 10 | 271 | 195 | def check(var):
return (0 <= var <= N) and all(c in str(var) for c in "753")
def dfs(x):
res = 0
if check(x):
res += 1
if x <= N:
for v in 3, 5, 7:
res += dfs(10 * x + v)
return res
N = int(eval(input()))
print((dfs(0)))
| def dfs(s):
res = 0
if int(s) > N:
return res
if all(c in s for c in "753"):
res += 1
for v in "753":
res += dfs(s + v)
return res
N = int(eval(input()))
print((dfs("0")))
| false | 33.333333 | [
"-def check(var):",
"- return (0 <= var <= N) and all(c in str(var) for c in \"753\")",
"-",
"-",
"-def dfs(x):",
"+def dfs(s):",
"- if check(x):",
"+ if int(s) > N:",
"+ return res",
"+ if all(c in s for c in \"753\"):",
"- if x <= N:",
"- for v in 3, 5, 7:",
"- res += dfs(10 * x + v)",
"+ for v in \"753\":",
"+ res += dfs(s + v)",
"-print((dfs(0)))",
"+print((dfs(\"0\")))"
] | false | 0.051267 | 0.060548 | 0.846711 | [
"s655036064",
"s276671284"
] |
u803848678 | p03326 | python | s029095279 | s476354619 | 1,998 | 419 | 3,368 | 21,660 | Accepted | Accepted | 79.03 | n, m = list(map(int, input().split()))
v = [list(map(int, input().split())) for i in range(n)]
ans = 0
op = [-1,1]
for i in range(2):
for j in range(2):
for k in range(2):
sx, sy, sz = op[i], op[j], op[k]
dp = [-float("inf")]*(m+1)
dp[0] = 0
for l, (x, y, z) in enumerate(v):
x *= sx
y *= sy
z *= sz
score = x+y+z
for h in range(min(m,l+1),0,-1):
dp[h] = max(dp[h], dp[h-1]+score)
ans = max(ans, dp[-1])
print(ans) | import numpy as np
n, m = list(map(int, input().split()))
v = [list(map(int, input().split())) for i in range(n)]
ans = 0
op = [-1,1]
for i in range(2):
for j in range(2):
for k in range(2):
sx, sy, sz = op[i], op[j], op[k]
dp = np.full(m+1, -np.inf, dtype=np.float64)
dp[0] = 0
for x, y, z in v:
x *= sx
y *= sy
z *= sz
dp[1:] = np.maximum(dp[1:], dp[:-1]+x+y+z)
ans = max(ans, dp[-1])
print((int(ans))) | 19 | 18 | 598 | 549 | n, m = list(map(int, input().split()))
v = [list(map(int, input().split())) for i in range(n)]
ans = 0
op = [-1, 1]
for i in range(2):
for j in range(2):
for k in range(2):
sx, sy, sz = op[i], op[j], op[k]
dp = [-float("inf")] * (m + 1)
dp[0] = 0
for l, (x, y, z) in enumerate(v):
x *= sx
y *= sy
z *= sz
score = x + y + z
for h in range(min(m, l + 1), 0, -1):
dp[h] = max(dp[h], dp[h - 1] + score)
ans = max(ans, dp[-1])
print(ans)
| import numpy as np
n, m = list(map(int, input().split()))
v = [list(map(int, input().split())) for i in range(n)]
ans = 0
op = [-1, 1]
for i in range(2):
for j in range(2):
for k in range(2):
sx, sy, sz = op[i], op[j], op[k]
dp = np.full(m + 1, -np.inf, dtype=np.float64)
dp[0] = 0
for x, y, z in v:
x *= sx
y *= sy
z *= sz
dp[1:] = np.maximum(dp[1:], dp[:-1] + x + y + z)
ans = max(ans, dp[-1])
print((int(ans)))
| false | 5.263158 | [
"+import numpy as np",
"+",
"- dp = [-float(\"inf\")] * (m + 1)",
"+ dp = np.full(m + 1, -np.inf, dtype=np.float64)",
"- for l, (x, y, z) in enumerate(v):",
"+ for x, y, z in v:",
"- score = x + y + z",
"- for h in range(min(m, l + 1), 0, -1):",
"- dp[h] = max(dp[h], dp[h - 1] + score)",
"+ dp[1:] = np.maximum(dp[1:], dp[:-1] + x + y + z)",
"-print(ans)",
"+print((int(ans)))"
] | false | 0.043543 | 0.242985 | 0.179201 | [
"s029095279",
"s476354619"
] |
u075012704 | p03014 | python | s589875418 | s556203239 | 1,929 | 1,379 | 309,128 | 319,900 | Accepted | Accepted | 28.51 | H, W = list(map(int, input().split()))
G = [list(eval(input())) for i in range(H)]
up = [[0] * W for i in range(H)] # あるマスから上に連続していくつ障害物のないマスが続くか
right = [[0] * W for i in range(H)] # あるマスから右に連続していくつ障害物のないマスが続くか
down = [[0] * W for i in range(H)] # あるマスから下に連続していくつ障害物のないマスが続くか
left = [[0] * W for i in range(H)] # あるマスから左に連続していくつ障害物のないマスが続くか
# up
for w in range(W):
for h in range(1, H):
if G[h - 1][w] == '#':
continue
up[h][w] = up[h - 1][w] + 1
# right
for h in range(H):
for w in reversed(list(range(W - 1))):
if G[h][w + 1] == '#':
continue
right[h][w] = right[h][w + 1] + 1
# down
for w in range(W):
for h in reversed(list(range(H - 1))):
if G[h + 1][w] == '#':
continue
down[h][w] = down[h + 1][w] + 1
# left
for h in range(H):
for w in range(1, W):
if G[h][w - 1] == '#':
continue
left[h][w] = left[h][w - 1] + 1
ans = 0
for h in range(H):
for w in range(W):
if G[h][w] == '#':
continue
ans = max(ans, up[h][w] + right[h][w] + down[h][w] + left[h][w] + 1)
print(ans)
| def main():
H, W = list(map(int, input().split()))
G = [list(input()) for i in range(H)]
up = [[0] * W for i in range(H)] # あるマスから上に連続していくつ障害物のないマスが続くか
right = [[0] * W for i in range(H)] # あるマスから右に連続していくつ障害物のないマスが続くか
down = [[0] * W for i in range(H)] # あるマスから下に連続していくつ障害物のないマスが続くか
left = [[0] * W for i in range(H)] # あるマスから左に連続していくつ障害物のないマスが続くか
# up
for w in range(W):
for h in range(1, H):
if G[h - 1][w] == '#':
continue
up[h][w] = up[h - 1][w] + 1
# right
for h in range(H):
for w in reversed(list(range(W - 1))):
if G[h][w + 1] == '#':
continue
right[h][w] = right[h][w + 1] + 1
# down
for w in range(W):
for h in reversed(list(range(H - 1))):
if G[h + 1][w] == '#':
continue
down[h][w] = down[h + 1][w] + 1
# left
for h in range(H):
for w in range(1, W):
if G[h][w - 1] == '#':
continue
left[h][w] = left[h][w - 1] + 1
ans = 0
for h in range(H):
for w in range(W):
if G[h][w] == '#':
continue
ans = max(ans, up[h][w] + right[h][w] + down[h][w] + left[h][w] + 1)
print(ans)
if __name__ == '__main__':
main() | 47 | 52 | 1,171 | 1,383 | H, W = list(map(int, input().split()))
G = [list(eval(input())) for i in range(H)]
up = [[0] * W for i in range(H)] # あるマスから上に連続していくつ障害物のないマスが続くか
right = [[0] * W for i in range(H)] # あるマスから右に連続していくつ障害物のないマスが続くか
down = [[0] * W for i in range(H)] # あるマスから下に連続していくつ障害物のないマスが続くか
left = [[0] * W for i in range(H)] # あるマスから左に連続していくつ障害物のないマスが続くか
# up
for w in range(W):
for h in range(1, H):
if G[h - 1][w] == "#":
continue
up[h][w] = up[h - 1][w] + 1
# right
for h in range(H):
for w in reversed(list(range(W - 1))):
if G[h][w + 1] == "#":
continue
right[h][w] = right[h][w + 1] + 1
# down
for w in range(W):
for h in reversed(list(range(H - 1))):
if G[h + 1][w] == "#":
continue
down[h][w] = down[h + 1][w] + 1
# left
for h in range(H):
for w in range(1, W):
if G[h][w - 1] == "#":
continue
left[h][w] = left[h][w - 1] + 1
ans = 0
for h in range(H):
for w in range(W):
if G[h][w] == "#":
continue
ans = max(ans, up[h][w] + right[h][w] + down[h][w] + left[h][w] + 1)
print(ans)
| def main():
H, W = list(map(int, input().split()))
G = [list(input()) for i in range(H)]
up = [[0] * W for i in range(H)] # あるマスから上に連続していくつ障害物のないマスが続くか
right = [[0] * W for i in range(H)] # あるマスから右に連続していくつ障害物のないマスが続くか
down = [[0] * W for i in range(H)] # あるマスから下に連続していくつ障害物のないマスが続くか
left = [[0] * W for i in range(H)] # あるマスから左に連続していくつ障害物のないマスが続くか
# up
for w in range(W):
for h in range(1, H):
if G[h - 1][w] == "#":
continue
up[h][w] = up[h - 1][w] + 1
# right
for h in range(H):
for w in reversed(list(range(W - 1))):
if G[h][w + 1] == "#":
continue
right[h][w] = right[h][w + 1] + 1
# down
for w in range(W):
for h in reversed(list(range(H - 1))):
if G[h + 1][w] == "#":
continue
down[h][w] = down[h + 1][w] + 1
# left
for h in range(H):
for w in range(1, W):
if G[h][w - 1] == "#":
continue
left[h][w] = left[h][w - 1] + 1
ans = 0
for h in range(H):
for w in range(W):
if G[h][w] == "#":
continue
ans = max(ans, up[h][w] + right[h][w] + down[h][w] + left[h][w] + 1)
print(ans)
if __name__ == "__main__":
main()
| false | 9.615385 | [
"-H, W = list(map(int, input().split()))",
"-G = [list(eval(input())) for i in range(H)]",
"-up = [[0] * W for i in range(H)] # あるマスから上に連続していくつ障害物のないマスが続くか",
"-right = [[0] * W for i in range(H)] # あるマスから右に連続していくつ障害物のないマスが続くか",
"-down = [[0] * W for i in range(H)] # あるマスから下に連続していくつ障害物のないマスが続くか",
"-left = [[0] * W for i in range(H)] # あるマスから左に連続していくつ障害物のないマスが続くか",
"-# up",
"-for w in range(W):",
"- for h in range(1, H):",
"- if G[h - 1][w] == \"#\":",
"- continue",
"- up[h][w] = up[h - 1][w] + 1",
"-# right",
"-for h in range(H):",
"- for w in reversed(list(range(W - 1))):",
"- if G[h][w + 1] == \"#\":",
"- continue",
"- right[h][w] = right[h][w + 1] + 1",
"-# down",
"-for w in range(W):",
"- for h in reversed(list(range(H - 1))):",
"- if G[h + 1][w] == \"#\":",
"- continue",
"- down[h][w] = down[h + 1][w] + 1",
"-# left",
"-for h in range(H):",
"- for w in range(1, W):",
"- if G[h][w - 1] == \"#\":",
"- continue",
"- left[h][w] = left[h][w - 1] + 1",
"-ans = 0",
"-for h in range(H):",
"+def main():",
"+ H, W = list(map(int, input().split()))",
"+ G = [list(input()) for i in range(H)]",
"+ up = [[0] * W for i in range(H)] # あるマスから上に連続していくつ障害物のないマスが続くか",
"+ right = [[0] * W for i in range(H)] # あるマスから右に連続していくつ障害物のないマスが続くか",
"+ down = [[0] * W for i in range(H)] # あるマスから下に連続していくつ障害物のないマスが続くか",
"+ left = [[0] * W for i in range(H)] # あるマスから左に連続していくつ障害物のないマスが続くか",
"+ # up",
"- if G[h][w] == \"#\":",
"- continue",
"- ans = max(ans, up[h][w] + right[h][w] + down[h][w] + left[h][w] + 1)",
"-print(ans)",
"+ for h in range(1, H):",
"+ if G[h - 1][w] == \"#\":",
"+ continue",
"+ up[h][w] = up[h - 1][w] + 1",
"+ # right",
"+ for h in range(H):",
"+ for w in reversed(list(range(W - 1))):",
"+ if G[h][w + 1] == \"#\":",
"+ continue",
"+ right[h][w] = right[h][w + 1] + 1",
"+ # down",
"+ for w in range(W):",
"+ for h in reversed(list(range(H - 1))):",
"+ if G[h + 1][w] == \"#\":",
"+ continue",
"+ down[h][w] = down[h + 1][w] + 1",
"+ # left",
"+ for h in range(H):",
"+ for w in range(1, W):",
"+ if G[h][w - 1] == \"#\":",
"+ continue",
"+ left[h][w] = left[h][w - 1] + 1",
"+ ans = 0",
"+ for h in range(H):",
"+ for w in range(W):",
"+ if G[h][w] == \"#\":",
"+ continue",
"+ ans = max(ans, up[h][w] + right[h][w] + down[h][w] + left[h][w] + 1)",
"+ print(ans)",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ main()"
] | false | 0.108615 | 0.110922 | 0.979207 | [
"s589875418",
"s556203239"
] |
u733814820 | p03107 | python | s627055692 | s746072586 | 35 | 25 | 3,956 | 3,188 | Accepted | Accepted | 28.57 | def resolve():
S = eval(input())
arr = []
for s in S:
if len(arr) != 0 and arr[-1] != s:
arr.pop()
else:
arr.append(s)
print((len(S) - len(arr)))
return
if __name__ == "__main__":
resolve()
| def resolve():
s = eval(input())
red = 0
blue = 0
for c in s:
if c == '0':
red += 1
else:
blue += 1
print((min(red, blue) * 2))
return
if __name__ == "__main__":
resolve()
| 14 | 14 | 229 | 212 | def resolve():
S = eval(input())
arr = []
for s in S:
if len(arr) != 0 and arr[-1] != s:
arr.pop()
else:
arr.append(s)
print((len(S) - len(arr)))
return
if __name__ == "__main__":
resolve()
| def resolve():
s = eval(input())
red = 0
blue = 0
for c in s:
if c == "0":
red += 1
else:
blue += 1
print((min(red, blue) * 2))
return
if __name__ == "__main__":
resolve()
| false | 0 | [
"- S = eval(input())",
"- arr = []",
"- for s in S:",
"- if len(arr) != 0 and arr[-1] != s:",
"- arr.pop()",
"+ s = eval(input())",
"+ red = 0",
"+ blue = 0",
"+ for c in s:",
"+ if c == \"0\":",
"+ red += 1",
"- arr.append(s)",
"- print((len(S) - len(arr)))",
"+ blue += 1",
"+ print((min(red, blue) * 2))"
] | false | 0.036888 | 0.036988 | 0.997299 | [
"s627055692",
"s746072586"
] |
u623814058 | p03475 | python | s681730097 | s369951818 | 95 | 84 | 9,212 | 9,120 | Accepted | Accepted | 11.58 | N=int(eval(input()))
C=[list(map(int,input().split())) for _ in range(N-1)]
for i in range(N-1):
c,s,f=C[i]
ans=s+c
for j in range(i+1,N-1):
nc,ns,nf=C[j]
# print('D',ans,nc,ns,nf,(ans-ns)%nf)
ans=max(ans,ns)
m=(ans-ns)%nf
if m!=0:ans+=nf-m
# print('D',ans,nc,ns,nf,(ans-ns)%nf)
ans+=nc
print(ans)
print((0)) | N=int(eval(input()))
C=[list(map(int,input().split())) for _ in range(N-1)]
for i in range(N-1):
c,s,f=C[i]
A=s+c
for j in range(i+1,N-1):
nc,ns,nf=C[j]
if A<ns:A=ns
elif (A-ns)%nf!=0:A+=nf-(A-ns)%nf
A+=nc
print(A)
print((0)) | 16 | 13 | 388 | 250 | N = int(eval(input()))
C = [list(map(int, input().split())) for _ in range(N - 1)]
for i in range(N - 1):
c, s, f = C[i]
ans = s + c
for j in range(i + 1, N - 1):
nc, ns, nf = C[j]
# print('D',ans,nc,ns,nf,(ans-ns)%nf)
ans = max(ans, ns)
m = (ans - ns) % nf
if m != 0:
ans += nf - m
# print('D',ans,nc,ns,nf,(ans-ns)%nf)
ans += nc
print(ans)
print((0))
| N = int(eval(input()))
C = [list(map(int, input().split())) for _ in range(N - 1)]
for i in range(N - 1):
c, s, f = C[i]
A = s + c
for j in range(i + 1, N - 1):
nc, ns, nf = C[j]
if A < ns:
A = ns
elif (A - ns) % nf != 0:
A += nf - (A - ns) % nf
A += nc
print(A)
print((0))
| false | 18.75 | [
"- ans = s + c",
"+ A = s + c",
"- # print('D',ans,nc,ns,nf,(ans-ns)%nf)",
"- ans = max(ans, ns)",
"- m = (ans - ns) % nf",
"- if m != 0:",
"- ans += nf - m",
"- # print('D',ans,nc,ns,nf,(ans-ns)%nf)",
"- ans += nc",
"- print(ans)",
"+ if A < ns:",
"+ A = ns",
"+ elif (A - ns) % nf != 0:",
"+ A += nf - (A - ns) % nf",
"+ A += nc",
"+ print(A)"
] | false | 0.040376 | 0.044877 | 0.8997 | [
"s681730097",
"s369951818"
] |
u597374218 | p03673 | python | s610681761 | s780175510 | 167 | 152 | 26,180 | 32,488 | Accepted | Accepted | 8.98 | N=int(eval(input()))
A=list(map(int,input().split()))
print((*(A[::-2]+A[N%2::2]))) | from collections import deque
n=int(eval(input()))
a=list(map(int,input().split()))
b=deque()
for i in range(n):
if i%2==0:
b.append(a[i])
else:
b.appendleft(a[i])
if n%2==0:
print((*b))
else:
print((*deque(reversed(b)))) | 3 | 13 | 77 | 255 | N = int(eval(input()))
A = list(map(int, input().split()))
print((*(A[::-2] + A[N % 2 :: 2])))
| from collections import deque
n = int(eval(input()))
a = list(map(int, input().split()))
b = deque()
for i in range(n):
if i % 2 == 0:
b.append(a[i])
else:
b.appendleft(a[i])
if n % 2 == 0:
print((*b))
else:
print((*deque(reversed(b))))
| false | 76.923077 | [
"-N = int(eval(input()))",
"-A = list(map(int, input().split()))",
"-print((*(A[::-2] + A[N % 2 :: 2])))",
"+from collections import deque",
"+",
"+n = int(eval(input()))",
"+a = list(map(int, input().split()))",
"+b = deque()",
"+for i in range(n):",
"+ if i % 2 == 0:",
"+ b.append(a[i])",
"+ else:",
"+ b.appendleft(a[i])",
"+if n % 2 == 0:",
"+ print((*b))",
"+else:",
"+ print((*deque(reversed(b))))"
] | false | 0.038389 | 0.040209 | 0.954736 | [
"s610681761",
"s780175510"
] |
u989345508 | p02678 | python | s493312982 | s429487857 | 1,000 | 767 | 39,276 | 39,384 | Accepted | Accepted | 23.3 | f=lambda:map(int,input().split());n,m=f();g=[[] for _ in range(n)]
for _ in [0]*m:a,b=f();g[a-1]+=[b-1];g[b-1]+=[a-1]
p=[0]*n;from queue import*;q=Queue();q.put(0)
while not q.empty():
v=q.get()
for c in g[v]:
if p[c]<1:p[c]=v+1;q.put(c)
print('Yes',*p[1:],sep='\n')
| f=lambda:map(int,input().split());n,m=f();g=[[] for _ in range(n)]
for _ in [0]*m:a,b=f();g[a-1]+=[b-1];g[b-1]+=[a-1]
p=[0]*n;from collections import*;q=deque([0])
while q:
for c in g[(v:=q.popleft())]:
if p[c]<1:p[c]=v+1;q.append(c)
print('Yes',*p[1:],sep='\n')
| 8 | 7 | 289 | 280 | f = lambda: map(int, input().split())
n, m = f()
g = [[] for _ in range(n)]
for _ in [0] * m:
a, b = f()
g[a - 1] += [b - 1]
g[b - 1] += [a - 1]
p = [0] * n
from queue import *
q = Queue()
q.put(0)
while not q.empty():
v = q.get()
for c in g[v]:
if p[c] < 1:
p[c] = v + 1
q.put(c)
print("Yes", *p[1:], sep="\n")
| f = lambda: map(int, input().split())
n, m = f()
g = [[] for _ in range(n)]
for _ in [0] * m:
a, b = f()
g[a - 1] += [b - 1]
g[b - 1] += [a - 1]
p = [0] * n
from collections import *
q = deque([0])
while q:
for c in g[(v := q.popleft())]:
if p[c] < 1:
p[c] = v + 1
q.append(c)
print("Yes", *p[1:], sep="\n")
| false | 12.5 | [
"-from queue import *",
"+from collections import *",
"-q = Queue()",
"-q.put(0)",
"-while not q.empty():",
"- v = q.get()",
"- for c in g[v]:",
"+q = deque([0])",
"+while q:",
"+ for c in g[(v := q.popleft())]:",
"- q.put(c)",
"+ q.append(c)"
] | false | 0.038178 | 0.036283 | 1.052239 | [
"s493312982",
"s429487857"
] |
u600402037 | p02843 | python | s061548881 | s565329959 | 1,091 | 17 | 21,228 | 3,060 | Accepted | Accepted | 98.44 | import sys
import numpy as np
sys.setrecursionlimit(10 ** 9)
stdin = sys.stdin
ri = lambda: int(rs())
rl = lambda: list(map(int, stdin.readline().split()))
rs = lambda: stdin.readline().rstrip() # ignore trailing spaces
X = ri()
q, r = divmod(X, 100)
bool = True
if q * 5 < r:
bool = False
elif X > 105 * 10 ** 6:
X -= 105 * 10 ** 6
#パソコン使い果たす
q, r = divmod(X, 100)
if q * 4 < r:
bool = False
elif X > 104 * 10 ** 6:
X -= 104 * 10 ** 6
q, r = divmod(X, 100)
if q * 3 < r:
bool = False
elif X > 103 * 10 ** 6:
X -= 103 * 10 ** 6
q, r = divmod(X, 100)
if q * 2 < r:
bool = False
elif X > 102 * 10 ** 6:
X -= 102 * 10 ** 6
#クッキー使い果たす
q, r = divmod(X, 100)
if q * 1 < r:
bool = False
elif X > 101 * 10 ** 6:
X -= 101 * 10 ** 6
#サンドイッチ使い果たす
q, r = divmod(X, 100)
if q * 0 < r:
bool = False
if X > 100 * 10 ** 6:
#おにぎり使い果たす 数が多すぎる
bool = False
print((1 if bool else 0))
| import sys
stdin = sys.stdin
ri = lambda: int(rs())
rl = lambda: list(map(int, stdin.readline().split()))
rs = lambda: stdin.readline().rstrip() # ignore trailing spaces
X = ri()
q, r = divmod(X, 100)
bool = True
if q * 5 < r:
bool = False
print((1 if bool else 0))
| 49 | 15 | 1,353 | 288 | import sys
import numpy as np
sys.setrecursionlimit(10**9)
stdin = sys.stdin
ri = lambda: int(rs())
rl = lambda: list(map(int, stdin.readline().split()))
rs = lambda: stdin.readline().rstrip() # ignore trailing spaces
X = ri()
q, r = divmod(X, 100)
bool = True
if q * 5 < r:
bool = False
elif X > 105 * 10**6:
X -= 105 * 10**6
# パソコン使い果たす
q, r = divmod(X, 100)
if q * 4 < r:
bool = False
elif X > 104 * 10**6:
X -= 104 * 10**6
q, r = divmod(X, 100)
if q * 3 < r:
bool = False
elif X > 103 * 10**6:
X -= 103 * 10**6
q, r = divmod(X, 100)
if q * 2 < r:
bool = False
elif X > 102 * 10**6:
X -= 102 * 10**6
# クッキー使い果たす
q, r = divmod(X, 100)
if q * 1 < r:
bool = False
elif X > 101 * 10**6:
X -= 101 * 10**6
# サンドイッチ使い果たす
q, r = divmod(X, 100)
if q * 0 < r:
bool = False
if X > 100 * 10**6:
# おにぎり使い果たす 数が多すぎる
bool = False
print((1 if bool else 0))
| import sys
stdin = sys.stdin
ri = lambda: int(rs())
rl = lambda: list(map(int, stdin.readline().split()))
rs = lambda: stdin.readline().rstrip() # ignore trailing spaces
X = ri()
q, r = divmod(X, 100)
bool = True
if q * 5 < r:
bool = False
print((1 if bool else 0))
| false | 69.387755 | [
"-import numpy as np",
"-sys.setrecursionlimit(10**9)",
"-elif X > 105 * 10**6:",
"- X -= 105 * 10**6",
"- # パソコン使い果たす",
"- q, r = divmod(X, 100)",
"- if q * 4 < r:",
"- bool = False",
"- elif X > 104 * 10**6:",
"- X -= 104 * 10**6",
"- q, r = divmod(X, 100)",
"- if q * 3 < r:",
"- bool = False",
"- elif X > 103 * 10**6:",
"- X -= 103 * 10**6",
"- q, r = divmod(X, 100)",
"- if q * 2 < r:",
"- bool = False",
"- elif X > 102 * 10**6:",
"- X -= 102 * 10**6",
"- # クッキー使い果たす",
"- q, r = divmod(X, 100)",
"- if q * 1 < r:",
"- bool = False",
"- elif X > 101 * 10**6:",
"- X -= 101 * 10**6",
"- # サンドイッチ使い果たす",
"- q, r = divmod(X, 100)",
"- if q * 0 < r:",
"- bool = False",
"- if X > 100 * 10**6:",
"- # おにぎり使い果たす 数が多すぎる",
"- bool = False"
] | false | 0.070247 | 0.039089 | 1.797103 | [
"s061548881",
"s565329959"
] |
u868701750 | p03610 | python | s672518951 | s588794902 | 39 | 17 | 4,268 | 3,188 | Accepted | Accepted | 56.41 | s = list(eval(input()))
ans = []
for i, _s in enumerate(s):
if not i % 2:
ans += [_s]
print((''.join(ans)))
| s = eval(input())
print((s[::2]))
| 6 | 2 | 117 | 27 | s = list(eval(input()))
ans = []
for i, _s in enumerate(s):
if not i % 2:
ans += [_s]
print(("".join(ans)))
| s = eval(input())
print((s[::2]))
| false | 66.666667 | [
"-s = list(eval(input()))",
"-ans = []",
"-for i, _s in enumerate(s):",
"- if not i % 2:",
"- ans += [_s]",
"-print((\"\".join(ans)))",
"+s = eval(input())",
"+print((s[::2]))"
] | false | 0.055465 | 0.15351 | 0.361314 | [
"s672518951",
"s588794902"
] |
u605880635 | p02630 | python | s238176633 | s867683001 | 313 | 268 | 15,040 | 15,008 | Accepted | Accepted | 14.38 | import sys
readline = sys.stdin.readline
def st(line):
tmp = ''
for l in line:
if l == '\n':
yield tmp
elif l == ' ':
yield tmp
tmp = ''
else:
tmp += l
N = int(eval(input()))
As = st(readline())
d = dict()
total = 0
for a in As:
a = int(a)
if a in d:
d[a] += 1
else:
d[a] = 1
total += a
Q = int(eval(input()))
queries = (list(map(int, readline().strip().split())) for _ in range(Q))
for que in queries:
b, c = que
if b not in d:
print(total)
continue
n_b = d[b]
d[b] = 0
if c not in d:
d[c] = 0
d[c] += n_b
total += (c - b) * n_b
print(total)
| import sys
readline = sys.stdin.readline
def st(line):
tmp = ''
for l in line:
if l == '\n':
yield tmp
elif l == ' ':
yield tmp
tmp = ''
else:
tmp += l
def solve():
N = int(eval(input()))
As = st(readline())
d = dict()
total = 0
for a in As:
a = int(a)
if a in d:
d[a] += 1
else:
d[a] = 1
total += a
Q = int(eval(input()))
queries = (list(map(int, readline().strip().split())) for _ in range(Q))
for que in queries:
b, c = que
if b not in d:
print(total)
continue
n_b = d[b]
d[b] = 0
if c not in d:
d[c] = 0
d[c] += n_b
total += (c - b) * n_b
print(total)
def main():
solve()
if __name__ == "__main__":
main() | 52 | 59 | 761 | 942 | import sys
readline = sys.stdin.readline
def st(line):
tmp = ""
for l in line:
if l == "\n":
yield tmp
elif l == " ":
yield tmp
tmp = ""
else:
tmp += l
N = int(eval(input()))
As = st(readline())
d = dict()
total = 0
for a in As:
a = int(a)
if a in d:
d[a] += 1
else:
d[a] = 1
total += a
Q = int(eval(input()))
queries = (list(map(int, readline().strip().split())) for _ in range(Q))
for que in queries:
b, c = que
if b not in d:
print(total)
continue
n_b = d[b]
d[b] = 0
if c not in d:
d[c] = 0
d[c] += n_b
total += (c - b) * n_b
print(total)
| import sys
readline = sys.stdin.readline
def st(line):
tmp = ""
for l in line:
if l == "\n":
yield tmp
elif l == " ":
yield tmp
tmp = ""
else:
tmp += l
def solve():
N = int(eval(input()))
As = st(readline())
d = dict()
total = 0
for a in As:
a = int(a)
if a in d:
d[a] += 1
else:
d[a] = 1
total += a
Q = int(eval(input()))
queries = (list(map(int, readline().strip().split())) for _ in range(Q))
for que in queries:
b, c = que
if b not in d:
print(total)
continue
n_b = d[b]
d[b] = 0
if c not in d:
d[c] = 0
d[c] += n_b
total += (c - b) * n_b
print(total)
def main():
solve()
if __name__ == "__main__":
main()
| false | 11.864407 | [
"-N = int(eval(input()))",
"-As = st(readline())",
"-d = dict()",
"-total = 0",
"-for a in As:",
"- a = int(a)",
"- if a in d:",
"- d[a] += 1",
"- else:",
"- d[a] = 1",
"- total += a",
"-Q = int(eval(input()))",
"-queries = (list(map(int, readline().strip().split())) for _ in range(Q))",
"-for que in queries:",
"- b, c = que",
"- if b not in d:",
"+def solve():",
"+ N = int(eval(input()))",
"+ As = st(readline())",
"+ d = dict()",
"+ total = 0",
"+ for a in As:",
"+ a = int(a)",
"+ if a in d:",
"+ d[a] += 1",
"+ else:",
"+ d[a] = 1",
"+ total += a",
"+ Q = int(eval(input()))",
"+ queries = (list(map(int, readline().strip().split())) for _ in range(Q))",
"+ for que in queries:",
"+ b, c = que",
"+ if b not in d:",
"+ print(total)",
"+ continue",
"+ n_b = d[b]",
"+ d[b] = 0",
"+ if c not in d:",
"+ d[c] = 0",
"+ d[c] += n_b",
"+ total += (c - b) * n_b",
"- continue",
"- n_b = d[b]",
"- d[b] = 0",
"- if c not in d:",
"- d[c] = 0",
"- d[c] += n_b",
"- total += (c - b) * n_b",
"- print(total)",
"+",
"+",
"+def main():",
"+ solve()",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ main()"
] | false | 0.039727 | 0.041954 | 0.946917 | [
"s238176633",
"s867683001"
] |
u821251381 | p02572 | python | s459740401 | s046751620 | 175 | 120 | 31,692 | 31,648 | Accepted | Accepted | 31.43 | N,*A = list(map(int,open(0).read().split()))
s = sum(A)
CS = [0 for i in range(N+1)]
CS[0] = s
for i in range(len(A)):
CS[i+1] = CS[i] - A[i]
CS.pop(0)
S = 0
for i,a in enumerate(A):
S+=CS[i]*a
S = (S%1000000007)
print(S) | N,*A = list(map(int,open(0).read().split()))
S_all = sum(A)**2
diag = sum([a**2 for a in A])
S = S_all-diag
S %= 1000000007
S = (S*pow(2,-1,1000000007))%1000000007
print(S)
| 14 | 10 | 236 | 179 | N, *A = list(map(int, open(0).read().split()))
s = sum(A)
CS = [0 for i in range(N + 1)]
CS[0] = s
for i in range(len(A)):
CS[i + 1] = CS[i] - A[i]
CS.pop(0)
S = 0
for i, a in enumerate(A):
S += CS[i] * a
S = S % 1000000007
print(S)
| N, *A = list(map(int, open(0).read().split()))
S_all = sum(A) ** 2
diag = sum([a**2 for a in A])
S = S_all - diag
S %= 1000000007
S = (S * pow(2, -1, 1000000007)) % 1000000007
print(S)
| false | 28.571429 | [
"-s = sum(A)",
"-CS = [0 for i in range(N + 1)]",
"-CS[0] = s",
"-for i in range(len(A)):",
"- CS[i + 1] = CS[i] - A[i]",
"-CS.pop(0)",
"-S = 0",
"-for i, a in enumerate(A):",
"- S += CS[i] * a",
"- S = S % 1000000007",
"+S_all = sum(A) ** 2",
"+diag = sum([a**2 for a in A])",
"+S = S_all - diag",
"+S %= 1000000007",
"+S = (S * pow(2, -1, 1000000007)) % 1000000007"
] | false | 0.03832 | 0.04854 | 0.789444 | [
"s459740401",
"s046751620"
] |
u046187684 | p02850 | python | s636726133 | s763908760 | 622 | 574 | 74,996 | 50,544 | Accepted | Accepted | 7.72 | from collections import deque
def solve(string):
n, *ab = list(map(int, string.split()))
# i != j => (ai, bi) != (aj, bj)
next_ = [dict([]) for _ in range(n + 1)]
color = [set([]) for _ in range(n + 1)]
queue = deque([1])
for a, b in zip(*[iter(ab)] * 2):
next_[a][b] = 0
next_[b][a] = 0
while len(queue) > 0:
c = queue.popleft()
_next = list(next_[c].items())
use = set(range(1, len(_next) + 1)) - color[c]
_next = (k for k, v in _next if v == 0)
for _n, u in zip(_next, use):
queue.append(_n)
next_[c][_n] = u
next_[_n][c] = u
color[c].add(u)
color[_n].add(u)
return str("{}\n{}".format(max([len(list(x.keys())) for x in next_]),
"\n".join(str(next_[a][b]) for a, b in zip(*[iter(ab)] * 2))))
if __name__ == '__main__':
import sys
print((solve(sys.stdin.read().strip())))
| from collections import deque
def solve(string):
n, *ab = list(map(int, string.split()))
next_ = [dict([]) for _ in range(n + 1)]
# color = [set([]) for _ in range(n + 1)]
queue = deque([1])
for a, b in zip(*[iter(ab)] * 2):
next_[a][b] = 0
next_[b][a] = 0
while len(queue) > 0:
c = queue.popleft()
_next = list(next_[c].items())
# use = set(range(1, len(_next) + 1)) - color[c]
use = set(range(1, len(_next) + 1)) - set(next_[c].values())
_next = (k for k, v in _next if v == 0)
for _n, u in zip(_next, use):
queue.append(_n)
next_[c][_n] = u
next_[_n][c] = u
# color[c].add(u)
# color[_n].add(u)
return str("{}\n{}".format(max([len(list(x.keys())) for x in next_]),
"\n".join(str(next_[a][b]) for a, b in zip(*[iter(ab)] * 2))))
if __name__ == '__main__':
import sys
print((solve(sys.stdin.read().strip())))
| 30 | 30 | 979 | 1,019 | from collections import deque
def solve(string):
n, *ab = list(map(int, string.split()))
# i != j => (ai, bi) != (aj, bj)
next_ = [dict([]) for _ in range(n + 1)]
color = [set([]) for _ in range(n + 1)]
queue = deque([1])
for a, b in zip(*[iter(ab)] * 2):
next_[a][b] = 0
next_[b][a] = 0
while len(queue) > 0:
c = queue.popleft()
_next = list(next_[c].items())
use = set(range(1, len(_next) + 1)) - color[c]
_next = (k for k, v in _next if v == 0)
for _n, u in zip(_next, use):
queue.append(_n)
next_[c][_n] = u
next_[_n][c] = u
color[c].add(u)
color[_n].add(u)
return str(
"{}\n{}".format(
max([len(list(x.keys())) for x in next_]),
"\n".join(str(next_[a][b]) for a, b in zip(*[iter(ab)] * 2)),
)
)
if __name__ == "__main__":
import sys
print((solve(sys.stdin.read().strip())))
| from collections import deque
def solve(string):
n, *ab = list(map(int, string.split()))
next_ = [dict([]) for _ in range(n + 1)]
# color = [set([]) for _ in range(n + 1)]
queue = deque([1])
for a, b in zip(*[iter(ab)] * 2):
next_[a][b] = 0
next_[b][a] = 0
while len(queue) > 0:
c = queue.popleft()
_next = list(next_[c].items())
# use = set(range(1, len(_next) + 1)) - color[c]
use = set(range(1, len(_next) + 1)) - set(next_[c].values())
_next = (k for k, v in _next if v == 0)
for _n, u in zip(_next, use):
queue.append(_n)
next_[c][_n] = u
next_[_n][c] = u
# color[c].add(u)
# color[_n].add(u)
return str(
"{}\n{}".format(
max([len(list(x.keys())) for x in next_]),
"\n".join(str(next_[a][b]) for a, b in zip(*[iter(ab)] * 2)),
)
)
if __name__ == "__main__":
import sys
print((solve(sys.stdin.read().strip())))
| false | 0 | [
"- # i != j => (ai, bi) != (aj, bj)",
"- color = [set([]) for _ in range(n + 1)]",
"+ # color = [set([]) for _ in range(n + 1)]",
"- use = set(range(1, len(_next) + 1)) - color[c]",
"+ # use = set(range(1, len(_next) + 1)) - color[c]",
"+ use = set(range(1, len(_next) + 1)) - set(next_[c].values())",
"- color[c].add(u)",
"- color[_n].add(u)",
"+ # color[c].add(u)",
"+ # color[_n].add(u)"
] | false | 0.059294 | 0.087939 | 0.674256 | [
"s636726133",
"s763908760"
] |
u606045429 | p02850 | python | s163599194 | s244155133 | 634 | 535 | 69,540 | 53,540 | Accepted | Accepted | 15.62 | from collections import deque
N, *AB = list(map(int, open(0).read().split()))
E = [set() for _ in range(N + 1)]
memo = {}
for i, (a, b) in enumerate(zip(*[iter(AB)] * 2)):
E[a].add(b)
E[b].add(a)
memo[(a, b)] = i
memo[(b, a)] = i
K = max(len(e) for e in E)
A = [0] * (N - 1)
Q = deque([(-1, 1)])
while Q:
p, v = Q.popleft()
C = (c for c in range(1, K + 1) if c != p)
for u in E[v]:
E[u].remove(v)
c = next(C)
Q.append((c, u))
A[memo[(v, u)]] = c
print(K)
for a in A:
print(a)
| from collections import deque
N, *AB = list(map(int, open(0).read().split()))
E = [set() for _ in range(N + 1)]
for i, (a, b) in enumerate(zip(*[iter(AB)] * 2)):
E[a].add((b, i))
E[b].add((a, i))
K = max(len(e) for e in E)
A = [0] * (N - 1)
Q = deque([(-1, 1)])
while Q:
p, v = Q.popleft()
C = (c for c in range(1, K + 1) if c != p)
for u, i in E[v]:
E[u].remove((v, i))
c = next(C)
Q.append((c, u))
A[i] = c
print(K)
for a in A:
print(a)
| 29 | 24 | 568 | 516 | from collections import deque
N, *AB = list(map(int, open(0).read().split()))
E = [set() for _ in range(N + 1)]
memo = {}
for i, (a, b) in enumerate(zip(*[iter(AB)] * 2)):
E[a].add(b)
E[b].add(a)
memo[(a, b)] = i
memo[(b, a)] = i
K = max(len(e) for e in E)
A = [0] * (N - 1)
Q = deque([(-1, 1)])
while Q:
p, v = Q.popleft()
C = (c for c in range(1, K + 1) if c != p)
for u in E[v]:
E[u].remove(v)
c = next(C)
Q.append((c, u))
A[memo[(v, u)]] = c
print(K)
for a in A:
print(a)
| from collections import deque
N, *AB = list(map(int, open(0).read().split()))
E = [set() for _ in range(N + 1)]
for i, (a, b) in enumerate(zip(*[iter(AB)] * 2)):
E[a].add((b, i))
E[b].add((a, i))
K = max(len(e) for e in E)
A = [0] * (N - 1)
Q = deque([(-1, 1)])
while Q:
p, v = Q.popleft()
C = (c for c in range(1, K + 1) if c != p)
for u, i in E[v]:
E[u].remove((v, i))
c = next(C)
Q.append((c, u))
A[i] = c
print(K)
for a in A:
print(a)
| false | 17.241379 | [
"-memo = {}",
"- E[a].add(b)",
"- E[b].add(a)",
"- memo[(a, b)] = i",
"- memo[(b, a)] = i",
"+ E[a].add((b, i))",
"+ E[b].add((a, i))",
"- for u in E[v]:",
"- E[u].remove(v)",
"+ for u, i in E[v]:",
"+ E[u].remove((v, i))",
"- A[memo[(v, u)]] = c",
"+ A[i] = c"
] | false | 0.046078 | 0.037261 | 1.236645 | [
"s163599194",
"s244155133"
] |
u282228874 | p03244 | python | s778738803 | s749152814 | 247 | 87 | 58,988 | 20,700 | Accepted | Accepted | 64.78 | n = int(eval(input()))
V = list(map(int,input().split()))
a = [0]*100000
b = [0]*100000
v1=[]
v2=[]
if len(set(V)) == 1:
print((n//2))
else:
for i in range(n):
if i%2 == 0:
a[V[i]-1] += 1
v1.append(V[i])
else:
b[V[i]-1] += 1
v2.append(V[i])
max1 = 0
max2 = 0
for j in range(len(a)):
if max1 < a[j]:
max1 = a[j]
c1 = j
for k in range(len(b)):
if max2 < b[k]:
max2=b[k]
c2=k
if c1 != c2:
print((n-max1-max2))
else:
a.sort()
b.sort()
print((min(n-max1-b[-2],n-max2-a[-2])))
| from collections import Counter
N = int(eval(input()))
V = list(map(int,input().split()))
zero = Counter(V[::2]).most_common()
one = Counter(V[1::2]).most_common()
if zero[0][0] != one[0][0]:
print((N-zero[0][1]-one[0][1]))
else:
if len(zero) == 1 and len(one) == 1:
print((N//2))
elif len(zero) == 1:
print((N-zero[0][1]-one[1][1]))
elif len(one) == 1:
print((N-zero[1][1]-one[0][1]))
else:
print((min(N-zero[1][1]-one[0][1],N-zero[0][1]-one[1][1]))) | 37 | 16 | 692 | 502 | n = int(eval(input()))
V = list(map(int, input().split()))
a = [0] * 100000
b = [0] * 100000
v1 = []
v2 = []
if len(set(V)) == 1:
print((n // 2))
else:
for i in range(n):
if i % 2 == 0:
a[V[i] - 1] += 1
v1.append(V[i])
else:
b[V[i] - 1] += 1
v2.append(V[i])
max1 = 0
max2 = 0
for j in range(len(a)):
if max1 < a[j]:
max1 = a[j]
c1 = j
for k in range(len(b)):
if max2 < b[k]:
max2 = b[k]
c2 = k
if c1 != c2:
print((n - max1 - max2))
else:
a.sort()
b.sort()
print((min(n - max1 - b[-2], n - max2 - a[-2])))
| from collections import Counter
N = int(eval(input()))
V = list(map(int, input().split()))
zero = Counter(V[::2]).most_common()
one = Counter(V[1::2]).most_common()
if zero[0][0] != one[0][0]:
print((N - zero[0][1] - one[0][1]))
else:
if len(zero) == 1 and len(one) == 1:
print((N // 2))
elif len(zero) == 1:
print((N - zero[0][1] - one[1][1]))
elif len(one) == 1:
print((N - zero[1][1] - one[0][1]))
else:
print((min(N - zero[1][1] - one[0][1], N - zero[0][1] - one[1][1])))
| false | 56.756757 | [
"-n = int(eval(input()))",
"+from collections import Counter",
"+",
"+N = int(eval(input()))",
"-a = [0] * 100000",
"-b = [0] * 100000",
"-v1 = []",
"-v2 = []",
"-if len(set(V)) == 1:",
"- print((n // 2))",
"+zero = Counter(V[::2]).most_common()",
"+one = Counter(V[1::2]).most_common()",
"+if zero[0][0] != one[0][0]:",
"+ print((N - zero[0][1] - one[0][1]))",
"- for i in range(n):",
"- if i % 2 == 0:",
"- a[V[i] - 1] += 1",
"- v1.append(V[i])",
"- else:",
"- b[V[i] - 1] += 1",
"- v2.append(V[i])",
"- max1 = 0",
"- max2 = 0",
"- for j in range(len(a)):",
"- if max1 < a[j]:",
"- max1 = a[j]",
"- c1 = j",
"- for k in range(len(b)):",
"- if max2 < b[k]:",
"- max2 = b[k]",
"- c2 = k",
"- if c1 != c2:",
"- print((n - max1 - max2))",
"+ if len(zero) == 1 and len(one) == 1:",
"+ print((N // 2))",
"+ elif len(zero) == 1:",
"+ print((N - zero[0][1] - one[1][1]))",
"+ elif len(one) == 1:",
"+ print((N - zero[1][1] - one[0][1]))",
"- a.sort()",
"- b.sort()",
"- print((min(n - max1 - b[-2], n - max2 - a[-2])))",
"+ print((min(N - zero[1][1] - one[0][1], N - zero[0][1] - one[1][1])))"
] | false | 0.058309 | 0.054316 | 1.07351 | [
"s778738803",
"s749152814"
] |
u457901067 | p02642 | python | s564611692 | s788542553 | 605 | 438 | 33,164 | 33,052 | Accepted | Accepted | 27.6 | #maspyさんを参考に
import sys
#import numpy as np
#from numba import njit
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
# この最適化がよくわからん。Numpyループなら行けるらしい
# 400msくらいは最低でもかかるけど、N=10^5でも2でも変わらんと言う
#@njit('(i4[::1],)', cache=True)
def solve(A):
# エラトステネス古いって値側のバリエーションとして配列をとるんや
# maxA = 10**6って言うのがポイントっぽいなあ。。
count = np.zeros(10**6 + 10, np.int32)
for x in A:
if count[x] > 1:
continue
count[::x] += 1
ret = 0
for x in A:
ret += count[x] == 1
return ret
def solve2(A):
count = [0 for _ in range(10**6 + 10)]
for x in A:
if count[x] > 1:
continue
for a in range(0,len(count),x):
count[a] += 1
ret = 0
for x in A:
ret += (1 if count[x] == 1 else 0)
#print(count[:24])
return ret
# このコードわからなかった。一行目のNをSKIPしたリストになっている。。
#A = np.array(read().split(), np.int32)[1:]
N = int(eval(input()))
A = list(map(int, input().split()))
# この手法だとソート不要なのか？？だから早いのか？？
print((solve2(A)))
| #maspyさんを参考に
import sys
#import numpy as np
#from numba import njit
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
# この最適化がよくわからん。Numpyループなら行けるらしい
# 400msくらいは最低でもかかるけど、N=10^5でも2でも変わらんと言う
#@njit('(i4[::1],)', cache=True)
def solve(A):
# エラトステネス古いって値側のバリエーションとして配列をとるんや
# maxA = 10**6って言うのがポイントっぽいなあ。。
count = np.zeros(10**6 + 10, np.int32)
for x in A:
if count[x] > 1:
continue
count[::x] += 1
ret = 0
for x in A:
ret += count[x] == 1
return ret
def solve2(A):
count = [0 for _ in range(10**6 + 10)]
for x in A:
if count[x] > 1:
continue
for a in range(0,len(count),x):
count[a] += 1
ret = 0
for x in A:
ret += (1 if count[x] == 1 else 0)
#print(count[:24])
return ret
# このコードわからなかった。一行目のNをSKIPしたリストになっている。。
#A = np.array(read().split(), np.int32)[1:]
N = int(eval(input()))
A = list(map(int, input().split()))
# この手法だとソート不要なのか？？だから早いのか？？
print((solve2(sorted(A))))
| 44 | 44 | 1,053 | 1,061 | # maspyさんを参考に
import sys
# import numpy as np
# from numba import njit
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
# この最適化がよくわからん。Numpyループなら行けるらしい
# 400msくらいは最低でもかかるけど、N=10^5でも2でも変わらんと言う
# @njit('(i4[::1],)', cache=True)
def solve(A):
# エラトステネス古いって値側のバリエーションとして配列をとるんや
# maxA = 10**6って言うのがポイントっぽいなあ。。
count = np.zeros(10**6 + 10, np.int32)
for x in A:
if count[x] > 1:
continue
count[::x] += 1
ret = 0
for x in A:
ret += count[x] == 1
return ret
def solve2(A):
count = [0 for _ in range(10**6 + 10)]
for x in A:
if count[x] > 1:
continue
for a in range(0, len(count), x):
count[a] += 1
ret = 0
for x in A:
ret += 1 if count[x] == 1 else 0
# print(count[:24])
return ret
# このコードわからなかった。一行目のNをSKIPしたリストになっている。。
# A = np.array(read().split(), np.int32)[1:]
N = int(eval(input()))
A = list(map(int, input().split()))
# この手法だとソート不要なのか？？だから早いのか？？
print((solve2(A)))
| # maspyさんを参考に
import sys
# import numpy as np
# from numba import njit
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
# この最適化がよくわからん。Numpyループなら行けるらしい
# 400msくらいは最低でもかかるけど、N=10^5でも2でも変わらんと言う
# @njit('(i4[::1],)', cache=True)
def solve(A):
# エラトステネス古いって値側のバリエーションとして配列をとるんや
# maxA = 10**6って言うのがポイントっぽいなあ。。
count = np.zeros(10**6 + 10, np.int32)
for x in A:
if count[x] > 1:
continue
count[::x] += 1
ret = 0
for x in A:
ret += count[x] == 1
return ret
def solve2(A):
count = [0 for _ in range(10**6 + 10)]
for x in A:
if count[x] > 1:
continue
for a in range(0, len(count), x):
count[a] += 1
ret = 0
for x in A:
ret += 1 if count[x] == 1 else 0
# print(count[:24])
return ret
# このコードわからなかった。一行目のNをSKIPしたリストになっている。。
# A = np.array(read().split(), np.int32)[1:]
N = int(eval(input()))
A = list(map(int, input().split()))
# この手法だとソート不要なのか？？だから早いのか？？
print((solve2(sorted(A))))
| false | 0 | [
"-print((solve2(A)))",
"+print((solve2(sorted(A))))"
] | false | 0.419847 | 0.333261 | 1.259812 | [
"s564611692",
"s788542553"
] |
u033606236 | p03625 | python | s713776742 | s128043201 | 105 | 97 | 14,252 | 18,600 | Accepted | Accepted | 7.62 | n = int(eval(input()))
a = sorted(list(map(int,input().split())),reverse=True)
a += [0]
b = -1
ans = [0,0]
count = 0
for i in range(n+1):
count += 1
if b != a[i]:
if count >= 4:
if ans[0]:
ans[1] = b
break
else:
ans[0] = b
ans[1] = b
break
elif count >= 2:
if ans[0]:
ans[1] = b
break
else:ans[0] = b
b = a[i]
count = 0
print((ans[0]*ans[1])) | from collections import Counter
n = int(eval(input()))
a = list(map(int,input().split()))
a = Counter(a)
ary = [0,0]
for i in a:
if a[i] >= 4:
ary.append(i)
ary.append(i)
elif a[i] >= 2:
ary.append(i)
ary.sort()
print((ary.pop()*ary.pop())) | 25 | 13 | 558 | 276 | n = int(eval(input()))
a = sorted(list(map(int, input().split())), reverse=True)
a += [0]
b = -1
ans = [0, 0]
count = 0
for i in range(n + 1):
count += 1
if b != a[i]:
if count >= 4:
if ans[0]:
ans[1] = b
break
else:
ans[0] = b
ans[1] = b
break
elif count >= 2:
if ans[0]:
ans[1] = b
break
else:
ans[0] = b
b = a[i]
count = 0
print((ans[0] * ans[1]))
| from collections import Counter
n = int(eval(input()))
a = list(map(int, input().split()))
a = Counter(a)
ary = [0, 0]
for i in a:
if a[i] >= 4:
ary.append(i)
ary.append(i)
elif a[i] >= 2:
ary.append(i)
ary.sort()
print((ary.pop() * ary.pop()))
| false | 48 | [
"+from collections import Counter",
"+",
"-a = sorted(list(map(int, input().split())), reverse=True)",
"-a += [0]",
"-b = -1",
"-ans = [0, 0]",
"-count = 0",
"-for i in range(n + 1):",
"- count += 1",
"- if b != a[i]:",
"- if count >= 4:",
"- if ans[0]:",
"- ans[1] = b",
"- break",
"- else:",
"- ans[0] = b",
"- ans[1] = b",
"- break",
"- elif count >= 2:",
"- if ans[0]:",
"- ans[1] = b",
"- break",
"- else:",
"- ans[0] = b",
"- b = a[i]",
"- count = 0",
"-print((ans[0] * ans[1]))",
"+a = list(map(int, input().split()))",
"+a = Counter(a)",
"+ary = [0, 0]",
"+for i in a:",
"+ if a[i] >= 4:",
"+ ary.append(i)",
"+ ary.append(i)",
"+ elif a[i] >= 2:",
"+ ary.append(i)",
"+ary.sort()",
"+print((ary.pop() * ary.pop()))"
] | false | 0.046253 | 0.130491 | 0.354457 | [
"s713776742",
"s128043201"
] |
u692453235 | p03486 | python | s023238366 | s344258613 | 33 | 28 | 9,320 | 8,936 | Accepted | Accepted | 15.15 | from collections import defaultdict
s = eval(input())
t = eval(input())
AL = "abcdefghijklmnopqrstuvwxyz"
S = defaultdict(int)
T = defaultdict(int)
for al in s:
S[al] += 1
for al in t:
T[al] += 1
ans_s = ""
for al in AL:
ans_s += al*S[al]
ans_t = ""
for al in reversed(list(AL)):
ans_t += al*T[al]
if ans_s < ans_t:
print("Yes")
else:
print("No") | s = eval(input())
t = eval(input())
S = "".join(sorted(list(s)))
T = "".join(sorted(list(t), reverse=True))
if S < T:
print("Yes")
else:
print("No") | 27 | 10 | 379 | 151 | from collections import defaultdict
s = eval(input())
t = eval(input())
AL = "abcdefghijklmnopqrstuvwxyz"
S = defaultdict(int)
T = defaultdict(int)
for al in s:
S[al] += 1
for al in t:
T[al] += 1
ans_s = ""
for al in AL:
ans_s += al * S[al]
ans_t = ""
for al in reversed(list(AL)):
ans_t += al * T[al]
if ans_s < ans_t:
print("Yes")
else:
print("No")
| s = eval(input())
t = eval(input())
S = "".join(sorted(list(s)))
T = "".join(sorted(list(t), reverse=True))
if S < T:
print("Yes")
else:
print("No")
| false | 62.962963 | [
"-from collections import defaultdict",
"-",
"-AL = \"abcdefghijklmnopqrstuvwxyz\"",
"-S = defaultdict(int)",
"-T = defaultdict(int)",
"-for al in s:",
"- S[al] += 1",
"-for al in t:",
"- T[al] += 1",
"-ans_s = \"\"",
"-for al in AL:",
"- ans_s += al * S[al]",
"-ans_t = \"\"",
"-for al in reversed(list(AL)):",
"- ans_t += al * T[al]",
"-if ans_s < ans_t:",
"+S = \"\".join(sorted(list(s)))",
"+T = \"\".join(sorted(list(t), reverse=True))",
"+if S < T:"
] | false | 0.043404 | 0.041742 | 1.039798 | [
"s023238366",
"s344258613"
] |
u063052907 | p03774 | python | s609985896 | s951122380 | 21 | 18 | 3,064 | 2,940 | Accepted | Accepted | 14.29 | # coding: utf-8
def manhattan(x1, y1, x2, y2):
return abs(x1-x2) + abs(y1-y2)
N, M = list(map(int, input().split()))
students = [eval(input()) for _ in range(N)]
c_points = [eval(input()) for _ in range(M)]
for s in students:
val = 400000001
ans = 0
a, b = list(map(int, s.split()))
for j, c in enumerate(c_points):
c, d = list(map(int, c.split()))
m_dis = manhattan(a,b,c,d)
if m_dis < val:
val = m_dis
ans = j+1
print(ans)
| # coding: utf-8
N, M = list(map(int, input().split()))
students = [list(map(int, input().split())) for _ in range(N)]
c_points = [list(map(int, input().split())) for _ in range(M)]
for a,b in students:
m_dis = [abs(a-c) + abs(b-d) for c,d in c_points]
print((m_dis.index(min(m_dis)) + 1))
| 19 | 8 | 487 | 297 | # coding: utf-8
def manhattan(x1, y1, x2, y2):
return abs(x1 - x2) + abs(y1 - y2)
N, M = list(map(int, input().split()))
students = [eval(input()) for _ in range(N)]
c_points = [eval(input()) for _ in range(M)]
for s in students:
val = 400000001
ans = 0
a, b = list(map(int, s.split()))
for j, c in enumerate(c_points):
c, d = list(map(int, c.split()))
m_dis = manhattan(a, b, c, d)
if m_dis < val:
val = m_dis
ans = j + 1
print(ans)
| # coding: utf-8
N, M = list(map(int, input().split()))
students = [list(map(int, input().split())) for _ in range(N)]
c_points = [list(map(int, input().split())) for _ in range(M)]
for a, b in students:
m_dis = [abs(a - c) + abs(b - d) for c, d in c_points]
print((m_dis.index(min(m_dis)) + 1))
| false | 57.894737 | [
"-def manhattan(x1, y1, x2, y2):",
"- return abs(x1 - x2) + abs(y1 - y2)",
"-",
"-",
"-students = [eval(input()) for _ in range(N)]",
"-c_points = [eval(input()) for _ in range(M)]",
"-for s in students:",
"- val = 400000001",
"- ans = 0",
"- a, b = list(map(int, s.split()))",
"- for j, c in enumerate(c_points):",
"- c, d = list(map(int, c.split()))",
"- m_dis = manhattan(a, b, c, d)",
"- if m_dis < val:",
"- val = m_dis",
"- ans = j + 1",
"- print(ans)",
"+students = [list(map(int, input().split())) for _ in range(N)]",
"+c_points = [list(map(int, input().split())) for _ in range(M)]",
"+for a, b in students:",
"+ m_dis = [abs(a - c) + abs(b - d) for c, d in c_points]",
"+ print((m_dis.index(min(m_dis)) + 1))"
] | false | 0.042292 | 0.041878 | 1.009882 | [
"s609985896",
"s951122380"
] |
u677440371 | p03325 | python | s798123899 | s683158604 | 96 | 63 | 4,148 | 4,148 | Accepted | Accepted | 34.38 | n = int(eval(input()))
a = [int(i) for i in input().split()]
a = sorted(list([x for x in a if (x % 2) == 0]), reverse=True)
ans = 0
for i in a:
while i % 2 == 0:
i //= 2
ans += 1
print((int(ans))) | n = int(eval(input()))
a = [int(i) for i in input().split()]
def count(number):
count = 0
while True:
if number % 2 == 0:
number //= 2
count += 1
else:
break
return count
a_2 = [int(i) for i in a if i % 2 == 0]
ans = 0
for i in a_2:
ans += count(i)
print(ans) | 10 | 19 | 222 | 344 | n = int(eval(input()))
a = [int(i) for i in input().split()]
a = sorted(list([x for x in a if (x % 2) == 0]), reverse=True)
ans = 0
for i in a:
while i % 2 == 0:
i //= 2
ans += 1
print((int(ans)))
| n = int(eval(input()))
a = [int(i) for i in input().split()]
def count(number):
count = 0
while True:
if number % 2 == 0:
number //= 2
count += 1
else:
break
return count
a_2 = [int(i) for i in a if i % 2 == 0]
ans = 0
for i in a_2:
ans += count(i)
print(ans)
| false | 47.368421 | [
"-a = sorted(list([x for x in a if (x % 2) == 0]), reverse=True)",
"+",
"+",
"+def count(number):",
"+ count = 0",
"+ while True:",
"+ if number % 2 == 0:",
"+ number //= 2",
"+ count += 1",
"+ else:",
"+ break",
"+ return count",
"+",
"+",
"+a_2 = [int(i) for i in a if i % 2 == 0]",
"-for i in a:",
"- while i % 2 == 0:",
"- i //= 2",
"- ans += 1",
"-print((int(ans)))",
"+for i in a_2:",
"+ ans += count(i)",
"+print(ans)"
] | false | 0.037143 | 0.051353 | 0.723277 | [
"s798123899",
"s683158604"
] |
u346395915 | p03013 | python | s168917535 | s130597861 | 467 | 151 | 460,020 | 13,848 | Accepted | Accepted | 67.67 | n, m = list(map(int,input().split()))
arr = [int(eval(input())) for _ in range(m)]
broken = set(arr)
mod = 10 ** 9 + 7
dp = [0] * (n+1)
dp[0] = 1
for i in range(1,n+1):
if i in broken:
continue
if i == 1:
dp[1] = dp[0]
continue
dp[i] = dp[i-1] + dp[i-2]
print((dp[n] % mod)) | n, m = list(map(int, input().split()))
li = [int(eval(input())) for _ in range(m)]
mod = 10**9 + 7
dp = [-1] * (n+1)
dp[0] = 1
for i in li:
dp[i] = 0
for i in range(1,n+1):
if dp[i] == 0:
continue
if i == 1:
dp[1] = 1
else:
dp[i] = (dp[i-1] + dp[i-2])%mod
print((dp[-1]))
| 20 | 20 | 329 | 334 | n, m = list(map(int, input().split()))
arr = [int(eval(input())) for _ in range(m)]
broken = set(arr)
mod = 10**9 + 7
dp = [0] * (n + 1)
dp[0] = 1
for i in range(1, n + 1):
if i in broken:
continue
if i == 1:
dp[1] = dp[0]
continue
dp[i] = dp[i - 1] + dp[i - 2]
print((dp[n] % mod))
| n, m = list(map(int, input().split()))
li = [int(eval(input())) for _ in range(m)]
mod = 10**9 + 7
dp = [-1] * (n + 1)
dp[0] = 1
for i in li:
dp[i] = 0
for i in range(1, n + 1):
if dp[i] == 0:
continue
if i == 1:
dp[1] = 1
else:
dp[i] = (dp[i - 1] + dp[i - 2]) % mod
print((dp[-1]))
| false | 0 | [
"-arr = [int(eval(input())) for _ in range(m)]",
"-broken = set(arr)",
"+li = [int(eval(input())) for _ in range(m)]",
"-dp = [0] * (n + 1)",
"+dp = [-1] * (n + 1)",
"+for i in li:",
"+ dp[i] = 0",
"- if i in broken:",
"+ if dp[i] == 0:",
"- dp[1] = dp[0]",
"- continue",
"- dp[i] = dp[i - 1] + dp[i - 2]",
"-print((dp[n] % mod))",
"+ dp[1] = 1",
"+ else:",
"+ dp[i] = (dp[i - 1] + dp[i - 2]) % mod",
"+print((dp[-1]))"
] | false | 0.043138 | 0.037871 | 1.139083 | [
"s168917535",
"s130597861"
] |
u437351386 | p03476 | python | s614348996 | s824509782 | 732 | 445 | 16,384 | 21,476 | Accepted | Accepted | 39.21 | #素数判定
import math
from itertools import accumulate
def sosuu(n):
if n==1:
return False
else:
for i in range(2,int(math.sqrt(n)+1)):
if n%i==0:
return False
return True
#入力
q=int(eval(input()))
l=[0]*q
r=[0]*q
for i in range(q):
l[i],r[i]=list(map(int,input().split()))
L=min(l)
R=max(r)
#累積和を作る
A=[]
for i in range(L,R+1):
if i%2==0:
A.append(0)
else:
if sosuu(i) and sosuu(int((i+1)/2)):
A.append(1)
else:
A.append(0)
s=[0]+A
S=list(accumulate(s))
for i in range(q):
#print(S[r[i]-L+1])
#print(S[l[i]-L])
print((S[r[i]-L+1]-S[l[i]-L]))
| import math
from itertools import accumulate
q=int(eval(input()))
l=[]
r=[]
for i in range(q):
a,b=list(map(int,input().split()))
l.append(a)
r.append(b)
def is_prime(n):
if n==1:
return False
elif n==2:
return True
else:
for i in range(2,int(math.sqrt(n)+1)):
if n%i==0:
return False
return True
l_min=min(l)
r_max=max(r)
ruiseki=[]
for i in range(l_min,r_max+1):
if i%2==1 and is_prime(i) and is_prime((i+1)//2):
ruiseki.append(1)
else:
ruiseki.append(0)
ruiseki=[0]+list(accumulate(ruiseki))
for i in range(q):
print((ruiseki[r[i]-l_min+1]-ruiseki[l[i]-l_min]))
| 39 | 38 | 649 | 674 | # 素数判定
import math
from itertools import accumulate
def sosuu(n):
if n == 1:
return False
else:
for i in range(2, int(math.sqrt(n) + 1)):
if n % i == 0:
return False
return True
# 入力
q = int(eval(input()))
l = [0] * q
r = [0] * q
for i in range(q):
l[i], r[i] = list(map(int, input().split()))
L = min(l)
R = max(r)
# 累積和を作る
A = []
for i in range(L, R + 1):
if i % 2 == 0:
A.append(0)
else:
if sosuu(i) and sosuu(int((i + 1) / 2)):
A.append(1)
else:
A.append(0)
s = [0] + A
S = list(accumulate(s))
for i in range(q):
# print(S[r[i]-L+1])
# print(S[l[i]-L])
print((S[r[i] - L + 1] - S[l[i] - L]))
| import math
from itertools import accumulate
q = int(eval(input()))
l = []
r = []
for i in range(q):
a, b = list(map(int, input().split()))
l.append(a)
r.append(b)
def is_prime(n):
if n == 1:
return False
elif n == 2:
return True
else:
for i in range(2, int(math.sqrt(n) + 1)):
if n % i == 0:
return False
return True
l_min = min(l)
r_max = max(r)
ruiseki = []
for i in range(l_min, r_max + 1):
if i % 2 == 1 and is_prime(i) and is_prime((i + 1) // 2):
ruiseki.append(1)
else:
ruiseki.append(0)
ruiseki = [0] + list(accumulate(ruiseki))
for i in range(q):
print((ruiseki[r[i] - l_min + 1] - ruiseki[l[i] - l_min]))
| false | 2.564103 | [
"-# 素数判定",
"+q = int(eval(input()))",
"+l = []",
"+r = []",
"+for i in range(q):",
"+ a, b = list(map(int, input().split()))",
"+ l.append(a)",
"+ r.append(b)",
"-def sosuu(n):",
"+",
"+def is_prime(n):",
"+ elif n == 2:",
"+ return True",
"- return True",
"+ return True",
"-# 入力",
"-q = int(eval(input()))",
"-l = [0] * q",
"-r = [0] * q",
"+l_min = min(l)",
"+r_max = max(r)",
"+ruiseki = []",
"+for i in range(l_min, r_max + 1):",
"+ if i % 2 == 1 and is_prime(i) and is_prime((i + 1) // 2):",
"+ ruiseki.append(1)",
"+ else:",
"+ ruiseki.append(0)",
"+ruiseki = [0] + list(accumulate(ruiseki))",
"- l[i], r[i] = list(map(int, input().split()))",
"-L = min(l)",
"-R = max(r)",
"-# 累積和を作る",
"-A = []",
"-for i in range(L, R + 1):",
"- if i % 2 == 0:",
"- A.append(0)",
"- else:",
"- if sosuu(i) and sosuu(int((i + 1) / 2)):",
"- A.append(1)",
"- else:",
"- A.append(0)",
"-s = [0] + A",
"-S = list(accumulate(s))",
"-for i in range(q):",
"- # print(S[r[i]-L+1])",
"- # print(S[l[i]-L])",
"- print((S[r[i] - L + 1] - S[l[i] - L]))",
"+ print((ruiseki[r[i] - l_min + 1] - ruiseki[l[i] - l_min]))"
] | false | 0.039349 | 0.071412 | 0.551009 | [
"s614348996",
"s824509782"
] |
u131925051 | p02693 | python | s231063060 | s613924681 | 22 | 20 | 9,184 | 9,152 | Accepted | Accepted | 9.09 | K = int(eval(input()))
score = input().split()
s1 = int(score[0])
s2 = int(score[1])
if ( s1 % K ) == 0:
print('OK')
elif ( s2 % K ) == 0:
print('OK')
elif ( s1 // K ) < ( s2 // K ):
print('OK')
else:
print('NG') | K = int(eval(input()))
A,B = list(map(int, input().split()))
for i in range(A, B+1):
if i % K == 0:
print('OK')
exit()
print('NG') | 12 | 7 | 225 | 129 | K = int(eval(input()))
score = input().split()
s1 = int(score[0])
s2 = int(score[1])
if (s1 % K) == 0:
print("OK")
elif (s2 % K) == 0:
print("OK")
elif (s1 // K) < (s2 // K):
print("OK")
else:
print("NG")
| K = int(eval(input()))
A, B = list(map(int, input().split()))
for i in range(A, B + 1):
if i % K == 0:
print("OK")
exit()
print("NG")
| false | 41.666667 | [
"-score = input().split()",
"-s1 = int(score[0])",
"-s2 = int(score[1])",
"-if (s1 % K) == 0:",
"- print(\"OK\")",
"-elif (s2 % K) == 0:",
"- print(\"OK\")",
"-elif (s1 // K) < (s2 // K):",
"- print(\"OK\")",
"-else:",
"- print(\"NG\")",
"+A, B = list(map(int, input().split()))",
"+for i in range(A, B + 1):",
"+ if i % K == 0:",
"+ print(\"OK\")",
"+ exit()",
"+print(\"NG\")"
] | false | 0.061847 | 0.078452 | 0.788346 | [
"s231063060",
"s613924681"
] |
u796942881 | p03111 | python | s533650050 | s682537875 | 70 | 18 | 3,064 | 3,064 | Accepted | Accepted | 74.29 | INF = 1000000007
def dfs(cur, a, b, c):
if cur == N:
return abs(a - A) + abs(b - B) + abs(c - C) - 30\
if 0 < min(a, b, c) else INF
ret1 = dfs(cur + 1, a + l[cur], b, c) + 10
ret2 = dfs(cur + 1, a, b + l[cur], c) + 10
ret3 = dfs(cur + 1, a, b, c + l[cur]) + 10
ret4 = dfs(cur + 1, a, b, c)
return min(ret1, ret2, ret3, ret4)
N, A, B, C = map(int, input().split())
l = [int(input()) for i in range(N)]
print(dfs(0, 0, 0, 0))
| from itertools import combinations
from itertools import permutations
def f(x, lst, rem):
d = abs(x - min(lst))
min_lst = min(lst)
tpl = None
for v in range(1, len(lst) - rem + 2):
for t in combinations(lst, v):
if abs(x - sum(t)) + 10 * (v - 1) < d:
d = abs(x - sum(t)) + 10 * (v - 1)
tpl = t
if tpl is None:
lst.remove(min_lst)
else:
for v in tpl:
lst.remove(v)
return d, lst
def main():
N, A, B, C = list(map(int, input().split()))
*L, = [int(eval(input())) for i in range(N)]
ans = int(1e9+7)
for ABC in permutations((A, B, C), 3):
lst = L[:]
accum = 0
for i, v in enumerate(ABC):
d, lst = f(v, lst, 3 - i)
accum += d
ans = min(ans, accum)
print(ans)
main()
| 21 | 37 | 496 | 877 | INF = 1000000007
def dfs(cur, a, b, c):
if cur == N:
return abs(a - A) + abs(b - B) + abs(c - C) - 30 if 0 < min(a, b, c) else INF
ret1 = dfs(cur + 1, a + l[cur], b, c) + 10
ret2 = dfs(cur + 1, a, b + l[cur], c) + 10
ret3 = dfs(cur + 1, a, b, c + l[cur]) + 10
ret4 = dfs(cur + 1, a, b, c)
return min(ret1, ret2, ret3, ret4)
N, A, B, C = map(int, input().split())
l = [int(input()) for i in range(N)]
print(dfs(0, 0, 0, 0))
| from itertools import combinations
from itertools import permutations
def f(x, lst, rem):
d = abs(x - min(lst))
min_lst = min(lst)
tpl = None
for v in range(1, len(lst) - rem + 2):
for t in combinations(lst, v):
if abs(x - sum(t)) + 10 * (v - 1) < d:
d = abs(x - sum(t)) + 10 * (v - 1)
tpl = t
if tpl is None:
lst.remove(min_lst)
else:
for v in tpl:
lst.remove(v)
return d, lst
def main():
N, A, B, C = list(map(int, input().split()))
(*L,) = [int(eval(input())) for i in range(N)]
ans = int(1e9 + 7)
for ABC in permutations((A, B, C), 3):
lst = L[:]
accum = 0
for i, v in enumerate(ABC):
d, lst = f(v, lst, 3 - i)
accum += d
ans = min(ans, accum)
print(ans)
main()
| false | 43.243243 | [
"-INF = 1000000007",
"+from itertools import combinations",
"+from itertools import permutations",
"-def dfs(cur, a, b, c):",
"- if cur == N:",
"- return abs(a - A) + abs(b - B) + abs(c - C) - 30 if 0 < min(a, b, c) else INF",
"- ret1 = dfs(cur + 1, a + l[cur], b, c) + 10",
"- ret2 = dfs(cur + 1, a, b + l[cur], c) + 10",
"- ret3 = dfs(cur + 1, a, b, c + l[cur]) + 10",
"- ret4 = dfs(cur + 1, a, b, c)",
"- return min(ret1, ret2, ret3, ret4)",
"+def f(x, lst, rem):",
"+ d = abs(x - min(lst))",
"+ min_lst = min(lst)",
"+ tpl = None",
"+ for v in range(1, len(lst) - rem + 2):",
"+ for t in combinations(lst, v):",
"+ if abs(x - sum(t)) + 10 * (v - 1) < d:",
"+ d = abs(x - sum(t)) + 10 * (v - 1)",
"+ tpl = t",
"+ if tpl is None:",
"+ lst.remove(min_lst)",
"+ else:",
"+ for v in tpl:",
"+ lst.remove(v)",
"+ return d, lst",
"-N, A, B, C = map(int, input().split())",
"-l = [int(input()) for i in range(N)]",
"-print(dfs(0, 0, 0, 0))",
"+def main():",
"+ N, A, B, C = list(map(int, input().split()))",
"+ (*L,) = [int(eval(input())) for i in range(N)]",
"+ ans = int(1e9 + 7)",
"+ for ABC in permutations((A, B, C), 3):",
"+ lst = L[:]",
"+ accum = 0",
"+ for i, v in enumerate(ABC):",
"+ d, lst = f(v, lst, 3 - i)",
"+ accum += d",
"+ ans = min(ans, accum)",
"+ print(ans)",
"+",
"+",
"+main()"
] | false | 0.07252 | 0.036139 | 2.006715 | [
"s533650050",
"s682537875"
] |
u133936772 | p03041 | python | s270272852 | s175435042 | 20 | 17 | 2,940 | 2,940 | Accepted | Accepted | 15 | n, k = list(map(int,input().split()))
s = eval(input())
ans = ''
for i in range(n):
if i == k-1:
ans += s[i].lower()
else:
ans += s[i]
print(ans) | _,k=input().split()
s=list(input())
k=int(k)-1
s[k]=s[k].lower()
print(*s,sep='')
| 9 | 5 | 153 | 85 | n, k = list(map(int, input().split()))
s = eval(input())
ans = ""
for i in range(n):
if i == k - 1:
ans += s[i].lower()
else:
ans += s[i]
print(ans)
| _, k = input().split()
s = list(input())
k = int(k) - 1
s[k] = s[k].lower()
print(*s, sep="")
| false | 44.444444 | [
"-n, k = list(map(int, input().split()))",
"-s = eval(input())",
"-ans = \"\"",
"-for i in range(n):",
"- if i == k - 1:",
"- ans += s[i].lower()",
"- else:",
"- ans += s[i]",
"-print(ans)",
"+_, k = input().split()",
"+s = list(input())",
"+k = int(k) - 1",
"+s[k] = s[k].lower()",
"+print(*s, sep=\"\")"
] | false | 0.047615 | 0.049781 | 0.956501 | [
"s270272852",
"s175435042"
] |
u285681431 | p02629 | python | s902314586 | s676366806 | 33 | 30 | 9,092 | 9,064 | Accepted | Accepted | 9.09 | n = int(eval(input()))
res = ""
while n:
n -= 1
res += chr(ord('a') + n % 26)
n //= 26
# print(n)
# print(res)
print((res[::-1]))
| N = int(eval(input()))
ans = ''
while N > 0:
N -= 1
ans += chr(ord('a') + N % 26)
N //= 26
print((ans[::-1]))
| 9 | 7 | 146 | 120 | n = int(eval(input()))
res = ""
while n:
n -= 1
res += chr(ord("a") + n % 26)
n //= 26
# print(n)
# print(res)
print((res[::-1]))
| N = int(eval(input()))
ans = ""
while N > 0:
N -= 1
ans += chr(ord("a") + N % 26)
N //= 26
print((ans[::-1]))
| false | 22.222222 | [
"-n = int(eval(input()))",
"-res = \"\"",
"-while n:",
"- n -= 1",
"- res += chr(ord(\"a\") + n % 26)",
"- n //= 26",
"- # print(n)",
"-# print(res)",
"-print((res[::-1]))",
"+N = int(eval(input()))",
"+ans = \"\"",
"+while N > 0:",
"+ N -= 1",
"+ ans += chr(ord(\"a\") + N % 26)",
"+ N //= 26",
"+print((ans[::-1]))"
] | false | 0.108556 | 0.156435 | 0.693939 | [
"s902314586",
"s676366806"
] |
u606045429 | p03639 | python | s744169850 | s335046951 | 70 | 63 | 14,636 | 14,252 | Accepted | Accepted | 10 | from collections import Counter
N = int(eval(input()))
A = [int(i) for i in input().split()]
C = Counter(4 if a % 4 == 0 else 2 if a % 2 == 0 else 1 for a in A)
if C[2] == 0:
print(("Yes" if C[1] <= C[4] + 1 else "No"))
else:
print(("Yes" if C[1] <= C[4] else "No"))
| N = int(eval(input()))
A = [int(i) for i in input().split()]
def solve():
f, t, o = 0, 0, 0
for a in A:
if a % 4 == 0:
f += 1
elif a % 2 == 0:
t += 1
else:
o += 1
if t == 0:
return (o <= f + 1)
else:
return (o <= f)
if solve():
print("Yes")
else:
print("No")
| 10 | 22 | 276 | 377 | from collections import Counter
N = int(eval(input()))
A = [int(i) for i in input().split()]
C = Counter(4 if a % 4 == 0 else 2 if a % 2 == 0 else 1 for a in A)
if C[2] == 0:
print(("Yes" if C[1] <= C[4] + 1 else "No"))
else:
print(("Yes" if C[1] <= C[4] else "No"))
| N = int(eval(input()))
A = [int(i) for i in input().split()]
def solve():
f, t, o = 0, 0, 0
for a in A:
if a % 4 == 0:
f += 1
elif a % 2 == 0:
t += 1
else:
o += 1
if t == 0:
return o <= f + 1
else:
return o <= f
if solve():
print("Yes")
else:
print("No")
| false | 54.545455 | [
"-from collections import Counter",
"-",
"-C = Counter(4 if a % 4 == 0 else 2 if a % 2 == 0 else 1 for a in A)",
"-if C[2] == 0:",
"- print((\"Yes\" if C[1] <= C[4] + 1 else \"No\"))",
"+",
"+",
"+def solve():",
"+ f, t, o = 0, 0, 0",
"+ for a in A:",
"+ if a % 4 == 0:",
"+ f += 1",
"+ elif a % 2 == 0:",
"+ t += 1",
"+ else:",
"+ o += 1",
"+ if t == 0:",
"+ return o <= f + 1",
"+ else:",
"+ return o <= f",
"+",
"+",
"+if solve():",
"+ print(\"Yes\")",
"- print((\"Yes\" if C[1] <= C[4] else \"No\"))",
"+ print(\"No\")"
] | false | 0.041605 | 0.032102 | 1.296046 | [
"s744169850",
"s335046951"
] |
u426534722 | p02274 | python | s871653865 | s582680235 | 1,420 | 1,270 | 27,480 | 27,476 | Accepted | Accepted | 10.56 | INF = float("inf")
cnt = 0
def merge(A, left, mid, right):
global cnt
L = A[left: mid] + [INF]
R = A[mid: right] + [INF]
i = j = 0
limit = mid - left
for k in range(left, right):
if L[i] <= R[j]:
A[k] = L[i]
i += 1
if i >= limit:
A[k + 1: right] = R[j: -1]
break
else:
cnt += limit - i
A[k] = R[j]
j += 1
def mergeSort(A, left, right):
if left + 1 < right:
mid = (left + right) // 2
mergeSort(A, left, mid)
mergeSort(A, mid, right)
merge(A, left, mid, right)
n = int(eval(input()))
S = list(map(int, input().split()))
mergeSort(S, 0, n)
print(cnt)
| INF = float("inf")
cnt = 0
def merge(A, left, mid, right):
global cnt
L = A[left: mid] + [INF]
R = A[mid: right] + [INF]
i = j = 0
limit = mid - left
for k in range(left, right):
if L[i] <= R[j]:
A[k] = L[i]
i += 1
else:
cnt += limit - i
A[k] = R[j]
j += 1
def mergeSort(A, left, right):
if left + 1 < right:
mid = (left + right) // 2
mergeSort(A, left, mid)
mergeSort(A, mid, right)
merge(A, left, mid, right)
n = int(eval(input()))
S = list(map(int, input().split()))
mergeSort(S, 0, n)
print(cnt)
| 30 | 27 | 752 | 657 | INF = float("inf")
cnt = 0
def merge(A, left, mid, right):
global cnt
L = A[left:mid] + [INF]
R = A[mid:right] + [INF]
i = j = 0
limit = mid - left
for k in range(left, right):
if L[i] <= R[j]:
A[k] = L[i]
i += 1
if i >= limit:
A[k + 1 : right] = R[j:-1]
break
else:
cnt += limit - i
A[k] = R[j]
j += 1
def mergeSort(A, left, right):
if left + 1 < right:
mid = (left + right) // 2
mergeSort(A, left, mid)
mergeSort(A, mid, right)
merge(A, left, mid, right)
n = int(eval(input()))
S = list(map(int, input().split()))
mergeSort(S, 0, n)
print(cnt)
| INF = float("inf")
cnt = 0
def merge(A, left, mid, right):
global cnt
L = A[left:mid] + [INF]
R = A[mid:right] + [INF]
i = j = 0
limit = mid - left
for k in range(left, right):
if L[i] <= R[j]:
A[k] = L[i]
i += 1
else:
cnt += limit - i
A[k] = R[j]
j += 1
def mergeSort(A, left, right):
if left + 1 < right:
mid = (left + right) // 2
mergeSort(A, left, mid)
mergeSort(A, mid, right)
merge(A, left, mid, right)
n = int(eval(input()))
S = list(map(int, input().split()))
mergeSort(S, 0, n)
print(cnt)
| false | 10 | [
"- if i >= limit:",
"- A[k + 1 : right] = R[j:-1]",
"- break"
] | false | 0.046347 | 0.11853 | 0.391017 | [
"s871653865",
"s582680235"
] |
u624475441 | p03645 | python | s544666204 | s653746230 | 1,607 | 199 | 4,724 | 46,660 | Accepted | Accepted | 87.62 | N,M=list(map(int,input().split()))
x=y=1
for _ in[0]*M:
a,b=list(map(int,input().split()))
if a==1: x|=1<<b
if b==N: y|=1<<a
print(('IM'*(x&y==1)+'POSSIBLE')) | n,m,*T=list(map(int,open(0).read().split()))
*S,=list(zip(T[::2],T[1::2]))
f=lambda e:set(s[e<2]for s in S if e in s)
print(('IM'*(f(1)&f(n)==set())+'POSSIBLE')) | 7 | 4 | 162 | 150 | N, M = list(map(int, input().split()))
x = y = 1
for _ in [0] * M:
a, b = list(map(int, input().split()))
if a == 1:
x |= 1 << b
if b == N:
y |= 1 << a
print(("IM" * (x & y == 1) + "POSSIBLE"))
| n, m, *T = list(map(int, open(0).read().split()))
(*S,) = list(zip(T[::2], T[1::2]))
f = lambda e: set(s[e < 2] for s in S if e in s)
print(("IM" * (f(1) & f(n) == set()) + "POSSIBLE"))
| false | 42.857143 | [
"-N, M = list(map(int, input().split()))",
"-x = y = 1",
"-for _ in [0] * M:",
"- a, b = list(map(int, input().split()))",
"- if a == 1:",
"- x |= 1 << b",
"- if b == N:",
"- y |= 1 << a",
"-print((\"IM\" * (x & y == 1) + \"POSSIBLE\"))",
"+n, m, *T = list(map(int, open(0).read().split()))",
"+(*S,) = list(zip(T[::2], T[1::2]))",
"+f = lambda e: set(s[e < 2] for s in S if e in s)",
"+print((\"IM\" * (f(1) & f(n) == set()) + \"POSSIBLE\"))"
] | false | 0.04565 | 0.058118 | 0.785464 | [
"s544666204",
"s653746230"
] |
u074220993 | p03485 | python | s739384468 | s460409084 | 117 | 26 | 27,080 | 8,976 | Accepted | Accepted | 77.78 | import numpy as np
X = np.array([int(x) for x in input().split()])
ans = np.ceil(np.mean(X))
print((int(ans))) | a, b = list(map(int, input().split()))
from math import ceil
print((ceil((a+b)/2))) | 4 | 3 | 111 | 77 | import numpy as np
X = np.array([int(x) for x in input().split()])
ans = np.ceil(np.mean(X))
print((int(ans)))
| a, b = list(map(int, input().split()))
from math import ceil
print((ceil((a + b) / 2)))
| false | 25 | [
"-import numpy as np",
"+a, b = list(map(int, input().split()))",
"+from math import ceil",
"-X = np.array([int(x) for x in input().split()])",
"-ans = np.ceil(np.mean(X))",
"-print((int(ans)))",
"+print((ceil((a + b) / 2)))"
] | false | 0.206508 | 0.042951 | 4.808028 | [
"s739384468",
"s460409084"
] |
u254871849 | p03425 | python | s952250186 | s927735631 | 45 | 40 | 11,596 | 10,812 | Accepted | Accepted | 11.11 | import sys
from collections import Counter
from itertools import combinations
MARCH = set('MARCH')
n = int(sys.stdin.readline().rstrip())
s = [x[0] for x in sys.stdin.read().split() if x[0] in MARCH]
def main():
c = Counter(s)
ways = 0
for comb in combinations('MARCH', 3):
res = 1
for i in comb:
res *= c.get(i, 0)
ways += res
return ways
if __name__ == '__main__':
ans = main()
print(ans) | import sys
from collections import Counter
from itertools import combinations
n, *s = [s[0] for s in sys.stdin.read().split()]
def main():
c = Counter(s)
res = 0
for i, j, k in combinations('MARCH', 3):
res += c[i] * c[j] * c[k]
print(res)
if __name__ == '__main__':
main() | 23 | 15 | 481 | 319 | import sys
from collections import Counter
from itertools import combinations
MARCH = set("MARCH")
n = int(sys.stdin.readline().rstrip())
s = [x[0] for x in sys.stdin.read().split() if x[0] in MARCH]
def main():
c = Counter(s)
ways = 0
for comb in combinations("MARCH", 3):
res = 1
for i in comb:
res *= c.get(i, 0)
ways += res
return ways
if __name__ == "__main__":
ans = main()
print(ans)
| import sys
from collections import Counter
from itertools import combinations
n, *s = [s[0] for s in sys.stdin.read().split()]
def main():
c = Counter(s)
res = 0
for i, j, k in combinations("MARCH", 3):
res += c[i] * c[j] * c[k]
print(res)
if __name__ == "__main__":
main()
| false | 34.782609 | [
"-MARCH = set(\"MARCH\")",
"-n = int(sys.stdin.readline().rstrip())",
"-s = [x[0] for x in sys.stdin.read().split() if x[0] in MARCH]",
"+n, *s = [s[0] for s in sys.stdin.read().split()]",
"- ways = 0",
"- for comb in combinations(\"MARCH\", 3):",
"- res = 1",
"- for i in comb:",
"- res *= c.get(i, 0)",
"- ways += res",
"- return ways",
"+ res = 0",
"+ for i, j, k in combinations(\"MARCH\", 3):",
"+ res += c[i] * c[j] * c[k]",
"+ print(res)",
"- ans = main()",
"- print(ans)",
"+ main()"
] | false | 0.03563 | 0.037392 | 0.952887 | [
"s952250186",
"s927735631"
] |
u186838327 | p03325 | python | s295091096 | s994486274 | 59 | 28 | 4,212 | 4,140 | Accepted | Accepted | 52.54 | n = int(eval(input()))
l = list(map(int, input().split()))
ans = 0
flag = 1
i = 1
while flag:
y = 2**i
m = list([x%y for x in l])
if 0 in m:
ans += m.count(0)
i += 1
else:
flag = 0
print(ans) | n = int(eval(input()))
A = list(map(int, input().split()))
ans = 0
for i in range(n):
a = A[i]
ans += format(a, 'b')[::-1].find('1')
print(ans)
| 15 | 7 | 225 | 152 | n = int(eval(input()))
l = list(map(int, input().split()))
ans = 0
flag = 1
i = 1
while flag:
y = 2**i
m = list([x % y for x in l])
if 0 in m:
ans += m.count(0)
i += 1
else:
flag = 0
print(ans)
| n = int(eval(input()))
A = list(map(int, input().split()))
ans = 0
for i in range(n):
a = A[i]
ans += format(a, "b")[::-1].find("1")
print(ans)
| false | 53.333333 | [
"-l = list(map(int, input().split()))",
"+A = list(map(int, input().split()))",
"-flag = 1",
"-i = 1",
"-while flag:",
"- y = 2**i",
"- m = list([x % y for x in l])",
"- if 0 in m:",
"- ans += m.count(0)",
"- i += 1",
"- else:",
"- flag = 0",
"+for i in range(n):",
"+ a = A[i]",
"+ ans += format(a, \"b\")[::-1].find(\"1\")"
] | false | 0.036034 | 0.034903 | 1.032399 | [
"s295091096",
"s994486274"
] |
u968166680 | p02586 | python | s443876109 | s773872488 | 2,081 | 829 | 168,936 | 198,404 | Accepted | Accepted | 60.16 | import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
R, C, K, *RCV = list(map(int, read().split()))
item = dict()
for r, c, v in zip(*[iter(RCV)] * 3):
item[(r - 1, c - 1)] = v
dp = [0] * (C + 1)
for i in range(R):
dp, dp_prev = [0] * (C + 1), dp
v = [0] * 4
for j in range(C):
for k in range(4):
if v[k] < dp_prev[j + 1]:
v[k] = dp_prev[j + 1]
if (i, j) in item:
for k in range(2, -1, -1):
if v[k + 1] < v[k] + item[(i, j)]:
v[k + 1] = v[k] + item[(i, j)]
dp[j + 1] = v[3]
print((dp[C]))
return
if __name__ == '__main__':
main()
| import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
R, C, K, *RCV = list(map(int, read().split()))
item = [[0] * C for _ in range(R)]
for r, c, v in zip(*[iter(RCV)] * 3):
item[r - 1][c - 1] = v
dp = [0] * (C + 1)
for i in range(R):
dp, dp_prev = [0] * (C + 1), dp
v = [0] * 4
for j in range(C):
for k in range(4):
if v[k] < dp_prev[j + 1]:
v[k] = dp_prev[j + 1]
if item[i][j] > 0:
for k in range(2, -1, -1):
if v[k + 1] < v[k] + item[i][j]:
v[k + 1] = v[k] + item[i][j]
dp[j + 1] = v[3]
print((dp[C]))
return
if __name__ == '__main__':
main()
| 38 | 38 | 880 | 895 | import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10**9)
INF = 1 << 60
MOD = 1000000007
def main():
R, C, K, *RCV = list(map(int, read().split()))
item = dict()
for r, c, v in zip(*[iter(RCV)] * 3):
item[(r - 1, c - 1)] = v
dp = [0] * (C + 1)
for i in range(R):
dp, dp_prev = [0] * (C + 1), dp
v = [0] * 4
for j in range(C):
for k in range(4):
if v[k] < dp_prev[j + 1]:
v[k] = dp_prev[j + 1]
if (i, j) in item:
for k in range(2, -1, -1):
if v[k + 1] < v[k] + item[(i, j)]:
v[k + 1] = v[k] + item[(i, j)]
dp[j + 1] = v[3]
print((dp[C]))
return
if __name__ == "__main__":
main()
| import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10**9)
INF = 1 << 60
MOD = 1000000007
def main():
R, C, K, *RCV = list(map(int, read().split()))
item = [[0] * C for _ in range(R)]
for r, c, v in zip(*[iter(RCV)] * 3):
item[r - 1][c - 1] = v
dp = [0] * (C + 1)
for i in range(R):
dp, dp_prev = [0] * (C + 1), dp
v = [0] * 4
for j in range(C):
for k in range(4):
if v[k] < dp_prev[j + 1]:
v[k] = dp_prev[j + 1]
if item[i][j] > 0:
for k in range(2, -1, -1):
if v[k + 1] < v[k] + item[i][j]:
v[k + 1] = v[k] + item[i][j]
dp[j + 1] = v[3]
print((dp[C]))
return
if __name__ == "__main__":
main()
| false | 0 | [
"- item = dict()",
"+ item = [[0] * C for _ in range(R)]",
"- item[(r - 1, c - 1)] = v",
"+ item[r - 1][c - 1] = v",
"- if (i, j) in item:",
"+ if item[i][j] > 0:",
"- if v[k + 1] < v[k] + item[(i, j)]:",
"- v[k + 1] = v[k] + item[(i, j)]",
"+ if v[k + 1] < v[k] + item[i][j]:",
"+ v[k + 1] = v[k] + item[i][j]"
] | false | 0.06737 | 0.074837 | 0.900219 | [
"s443876109",
"s773872488"
] |
u518042385 | p03074 | python | s672438189 | s907753164 | 86 | 79 | 6,108 | 4,120 | Accepted | Accepted | 8.14 | n,k=list(map(int,input().split()))
l=eval(input())
b=True
if l[0]=="1":
b=True
else:
b=False
l1=[]
c=1
l11=l[0]
for i in range(1,len(l)):
if l[i]!=l[i-1]:
l1.append(c)
c=1
else:
c+=1
l1.append(c)
if b:
if k>=len(l1)//2:
print(n)
else:
l2=[]
c1=0
for i in range(0,(len(l1)//2)):
c1+=l1[i*2+1]+l1[i*2]
l2.append(c1)
if len(l1)%2==1:
c2=l2[k-1]+l1[2*k]
for j in range(k,len(l2)):
c3=l2[j]-l2[j-k]+l1[2*(j+1)]
if c3>c2:
c2=c3
print(c2)
else:
c2=l2[k-1]+l1[2*k]
for j in range(k,len(l2)-1):
c3=l2[j]-l2[j-k]+l1[2*(j+1)]
if c3>c2:
c2=c3
c3=l2[-1]-l2[-1-k]
if c3>c2:
c2=c3
print(c2)
else:
if k>=(len(l1)//2)+1:
print(n)
else:
l2=[l1[0]]
c1=l1[0]
if len(l1)%2==1:
for i in range(1,(len(l1)//2)+1):
c1+=l1[2*i]+l1[2*i-1]
l2.append(c1)
c2=l2[k-1]+l1[2*k-1]
for i in range(k,len(l2)-1):
c3=l2[i]-l2[i-k]+l1[i*2+1]
if c3>c2:
c2=c3
c3=l2[len(l2)-1]-l2[len(l2)-1-k]
if c3>c2:
c2=c3
print(c2)
else:
for i in range(1,(len(l1)//2)):
c1+=l1[2*i]+l1[2*i-1]
l2.append(c1)
c2=l2[k-1]+l1[2*k-1]
for i in range(k,len(l2)):
c3=l2[i]-l2[i-k]+l1[i*2+1]
if c3>c2:
c2=c3
print(c2) | n,k=list(map(int,input().split()))
w=eval(input())
l=[]
c=0
w="1"+w
for i in range(1,1+n):
if w[i]!=w[i-1]:
l.append(c)
c=1
else:
c+=1
l.append(c)
if k>=len(l)//2:
print(n)
else:
if w[-1]=="0":
l.append(0)
s=l[0]
for i in range(1,1+k):
s+=l[2*i]+l[2*i-1]
s1=s
c1=l[0]+l[1]
for i in range(1,(len(l)+1)//2-k):
s1=s1-l[2*i-2]-l[2*i-1]+l[2*i-1+2*k]+l[2*i+2*k]
if s1>s:
s=s1
print(s) | 72 | 27 | 1,456 | 446 | n, k = list(map(int, input().split()))
l = eval(input())
b = True
if l[0] == "1":
b = True
else:
b = False
l1 = []
c = 1
l11 = l[0]
for i in range(1, len(l)):
if l[i] != l[i - 1]:
l1.append(c)
c = 1
else:
c += 1
l1.append(c)
if b:
if k >= len(l1) // 2:
print(n)
else:
l2 = []
c1 = 0
for i in range(0, (len(l1) // 2)):
c1 += l1[i * 2 + 1] + l1[i * 2]
l2.append(c1)
if len(l1) % 2 == 1:
c2 = l2[k - 1] + l1[2 * k]
for j in range(k, len(l2)):
c3 = l2[j] - l2[j - k] + l1[2 * (j + 1)]
if c3 > c2:
c2 = c3
print(c2)
else:
c2 = l2[k - 1] + l1[2 * k]
for j in range(k, len(l2) - 1):
c3 = l2[j] - l2[j - k] + l1[2 * (j + 1)]
if c3 > c2:
c2 = c3
c3 = l2[-1] - l2[-1 - k]
if c3 > c2:
c2 = c3
print(c2)
else:
if k >= (len(l1) // 2) + 1:
print(n)
else:
l2 = [l1[0]]
c1 = l1[0]
if len(l1) % 2 == 1:
for i in range(1, (len(l1) // 2) + 1):
c1 += l1[2 * i] + l1[2 * i - 1]
l2.append(c1)
c2 = l2[k - 1] + l1[2 * k - 1]
for i in range(k, len(l2) - 1):
c3 = l2[i] - l2[i - k] + l1[i * 2 + 1]
if c3 > c2:
c2 = c3
c3 = l2[len(l2) - 1] - l2[len(l2) - 1 - k]
if c3 > c2:
c2 = c3
print(c2)
else:
for i in range(1, (len(l1) // 2)):
c1 += l1[2 * i] + l1[2 * i - 1]
l2.append(c1)
c2 = l2[k - 1] + l1[2 * k - 1]
for i in range(k, len(l2)):
c3 = l2[i] - l2[i - k] + l1[i * 2 + 1]
if c3 > c2:
c2 = c3
print(c2)
| n, k = list(map(int, input().split()))
w = eval(input())
l = []
c = 0
w = "1" + w
for i in range(1, 1 + n):
if w[i] != w[i - 1]:
l.append(c)
c = 1
else:
c += 1
l.append(c)
if k >= len(l) // 2:
print(n)
else:
if w[-1] == "0":
l.append(0)
s = l[0]
for i in range(1, 1 + k):
s += l[2 * i] + l[2 * i - 1]
s1 = s
c1 = l[0] + l[1]
for i in range(1, (len(l) + 1) // 2 - k):
s1 = s1 - l[2 * i - 2] - l[2 * i - 1] + l[2 * i - 1 + 2 * k] + l[2 * i + 2 * k]
if s1 > s:
s = s1
print(s)
| false | 62.5 | [
"-l = eval(input())",
"-b = True",
"-if l[0] == \"1\":",
"- b = True",
"-else:",
"- b = False",
"-l1 = []",
"-c = 1",
"-l11 = l[0]",
"-for i in range(1, len(l)):",
"- if l[i] != l[i - 1]:",
"- l1.append(c)",
"+w = eval(input())",
"+l = []",
"+c = 0",
"+w = \"1\" + w",
"+for i in range(1, 1 + n):",
"+ if w[i] != w[i - 1]:",
"+ l.append(c)",
"-l1.append(c)",
"-if b:",
"- if k >= len(l1) // 2:",
"- print(n)",
"- else:",
"- l2 = []",
"- c1 = 0",
"- for i in range(0, (len(l1) // 2)):",
"- c1 += l1[i * 2 + 1] + l1[i * 2]",
"- l2.append(c1)",
"- if len(l1) % 2 == 1:",
"- c2 = l2[k - 1] + l1[2 * k]",
"- for j in range(k, len(l2)):",
"- c3 = l2[j] - l2[j - k] + l1[2 * (j + 1)]",
"- if c3 > c2:",
"- c2 = c3",
"- print(c2)",
"- else:",
"- c2 = l2[k - 1] + l1[2 * k]",
"- for j in range(k, len(l2) - 1):",
"- c3 = l2[j] - l2[j - k] + l1[2 * (j + 1)]",
"- if c3 > c2:",
"- c2 = c3",
"- c3 = l2[-1] - l2[-1 - k]",
"- if c3 > c2:",
"- c2 = c3",
"- print(c2)",
"+l.append(c)",
"+if k >= len(l) // 2:",
"+ print(n)",
"- if k >= (len(l1) // 2) + 1:",
"- print(n)",
"- else:",
"- l2 = [l1[0]]",
"- c1 = l1[0]",
"- if len(l1) % 2 == 1:",
"- for i in range(1, (len(l1) // 2) + 1):",
"- c1 += l1[2 * i] + l1[2 * i - 1]",
"- l2.append(c1)",
"- c2 = l2[k - 1] + l1[2 * k - 1]",
"- for i in range(k, len(l2) - 1):",
"- c3 = l2[i] - l2[i - k] + l1[i * 2 + 1]",
"- if c3 > c2:",
"- c2 = c3",
"- c3 = l2[len(l2) - 1] - l2[len(l2) - 1 - k]",
"- if c3 > c2:",
"- c2 = c3",
"- print(c2)",
"- else:",
"- for i in range(1, (len(l1) // 2)):",
"- c1 += l1[2 * i] + l1[2 * i - 1]",
"- l2.append(c1)",
"- c2 = l2[k - 1] + l1[2 * k - 1]",
"- for i in range(k, len(l2)):",
"- c3 = l2[i] - l2[i - k] + l1[i * 2 + 1]",
"- if c3 > c2:",
"- c2 = c3",
"- print(c2)",
"+ if w[-1] == \"0\":",
"+ l.append(0)",
"+ s = l[0]",
"+ for i in range(1, 1 + k):",
"+ s += l[2 * i] + l[2 * i - 1]",
"+ s1 = s",
"+ c1 = l[0] + l[1]",
"+ for i in range(1, (len(l) + 1) // 2 - k):",
"+ s1 = s1 - l[2 * i - 2] - l[2 * i - 1] + l[2 * i - 1 + 2 * k] + l[2 * i + 2 * k]",
"+ if s1 > s:",
"+ s = s1",
"+ print(s)"
] | false | 0.043652 | 0.084004 | 0.519644 | [
"s672438189",
"s907753164"
] |
u402629484 | p02642 | python | s366049708 | s183194628 | 1,270 | 665 | 51,772 | 51,592 | Accepted | Accepted | 47.64 | import sys
sys.setrecursionlimit(1000000000)
import math
from math import gcd
def lcm(a, b): return a * b // gcd(a, b)
from itertools import count, permutations, chain
from functools import lru_cache
from collections import deque, defaultdict
from pprint import pprint
ii = lambda: int(eval(input()))
mis = lambda: list(map(int, input().split()))
lmis = lambda: list(mis())
INF = float('inf')
N1097 = 10**9 + 7
def meg(f, ok, ng):
while abs(ok-ng)>1:
mid = (ok+ng)//2
if f(mid):
ok=mid
else:
ng=mid
return ok
def get_inv(n, modp):
return pow(n, modp-2, modp)
def factorials_list(n, modp): # 10**6
fs = [1]
for i in range(1, n+1):
fs.append(fs[-1] * i % modp)
return fs
def invs_list(n, fs, modp): # 10**6
invs = [get_inv(fs[-1], modp)]
for i in range(n, 1-1, -1):
invs.append(invs[-1] * i % modp)
invs.reverse()
return invs
def comb(n, k, modp):
num = 1
for i in range(n, n-k, -1):
num = num * i % modp
den = 1
for i in range(2, k+1):
den = den * i % modp
return num * get_inv(den, modp) % modp
def comb_from_list(n, k, modp, fs, invs):
return fs[n] * invs[n-k] * invs[k] % modp
#
class UnionFindEx:
def __init__(self, size):
#正なら根の番号、負ならグループサイズ
self.roots = [-1] * size
def getRootID(self, i):
r = self.roots[i]
if r < 0: #負なら根
return i
else:
r = self.getRootID(r)
self.roots[i] = r
return r
def getGroupSize(self, i):
return -self.roots[self.getRootID(i)]
def connect(self, i, j):
r1, r2 = self.getRootID(i), self.getRootID(j)
if r1 == r2:
return False
if self.getGroupSize(r1) < self.getGroupSize(r2):
r1, r2 = r2, r1
self.roots[r1] += self.roots[r2] #サイズ更新
self.roots[r2] = r1
return True
def get_primes(n):
ps = [2]
for i in range(3, n, 2):
for p in ps:
if i%p == 0:
break
else:
ps.append(i)
return ps
Yes = 'Yes'
No = 'No'
import numpy as np
def main():
N=ii()
A=lmis()
A.sort()
d = np.zeros(A[-1]+1, dtype=np.uint8)
for i in range(N):
a = A[i]
pa = A[i-1]
if a != pa:
d[a::a] += 1
else:
d[a] += 1
print((sum(d[a]==1 for a in A)))
main()
| '''
方針
1 ～ 10^6(Aの最大値) までの全ての数について、割り切れる数をカウント
カウント == 1 ならば、他の数では割り切れないので、そのような数の個数が答え
工夫
そのままの実装では、最悪ケース : 1 1 1 1 ... で、TLEする
対策として、
1. Aを昇順ソートする
2. A[i]がA[i-1]と同じならば、2倍以上の倍数についてはスキップ
とする
'''
import numpy as np
def main():
N = int(eval(input()))
A = list(map(int, input().split()))
A.sort()
d = np.zeros(A[-1]+1, dtype=np.uint64) # 約数カウント。配列長さは、Aの最大値+1 で十分
for i in range(N):
a = A[i]
a1 = A[i-1]
if a != a1: # 初出の数なら
d[a::a] += 1 # aからaごとに+1する (範囲内の全ての倍数に、約数カウント+1)
else: # 重複なら
d[a] += 1 # 自身のカウントを上げるだけで十分 (2倍以上はスキップ)
print((np.count_nonzero(d[A] == 1))) # Aのうち、約数カウントが1となったものの個数が答え
main()
| 110 | 31 | 2,545 | 764 | import sys
sys.setrecursionlimit(1000000000)
import math
from math import gcd
def lcm(a, b):
return a * b // gcd(a, b)
from itertools import count, permutations, chain
from functools import lru_cache
from collections import deque, defaultdict
from pprint import pprint
ii = lambda: int(eval(input()))
mis = lambda: list(map(int, input().split()))
lmis = lambda: list(mis())
INF = float("inf")
N1097 = 10**9 + 7
def meg(f, ok, ng):
while abs(ok - ng) > 1:
mid = (ok + ng) // 2
if f(mid):
ok = mid
else:
ng = mid
return ok
def get_inv(n, modp):
return pow(n, modp - 2, modp)
def factorials_list(n, modp): # 10**6
fs = [1]
for i in range(1, n + 1):
fs.append(fs[-1] * i % modp)
return fs
def invs_list(n, fs, modp): # 10**6
invs = [get_inv(fs[-1], modp)]
for i in range(n, 1 - 1, -1):
invs.append(invs[-1] * i % modp)
invs.reverse()
return invs
def comb(n, k, modp):
num = 1
for i in range(n, n - k, -1):
num = num * i % modp
den = 1
for i in range(2, k + 1):
den = den * i % modp
return num * get_inv(den, modp) % modp
def comb_from_list(n, k, modp, fs, invs):
return fs[n] * invs[n - k] * invs[k] % modp
#
class UnionFindEx:
def __init__(self, size):
# 正なら根の番号、負ならグループサイズ
self.roots = [-1] * size
def getRootID(self, i):
r = self.roots[i]
if r < 0: # 負なら根
return i
else:
r = self.getRootID(r)
self.roots[i] = r
return r
def getGroupSize(self, i):
return -self.roots[self.getRootID(i)]
def connect(self, i, j):
r1, r2 = self.getRootID(i), self.getRootID(j)
if r1 == r2:
return False
if self.getGroupSize(r1) < self.getGroupSize(r2):
r1, r2 = r2, r1
self.roots[r1] += self.roots[r2] # サイズ更新
self.roots[r2] = r1
return True
def get_primes(n):
ps = [2]
for i in range(3, n, 2):
for p in ps:
if i % p == 0:
break
else:
ps.append(i)
return ps
Yes = "Yes"
No = "No"
import numpy as np
def main():
N = ii()
A = lmis()
A.sort()
d = np.zeros(A[-1] + 1, dtype=np.uint8)
for i in range(N):
a = A[i]
pa = A[i - 1]
if a != pa:
d[a::a] += 1
else:
d[a] += 1
print((sum(d[a] == 1 for a in A)))
main()
| """
方針
1 ～ 10^6(Aの最大値) までの全ての数について、割り切れる数をカウント
カウント == 1 ならば、他の数では割り切れないので、そのような数の個数が答え
工夫
そのままの実装では、最悪ケース : 1 1 1 1 ... で、TLEする
対策として、
1. Aを昇順ソートする
2. A[i]がA[i-1]と同じならば、2倍以上の倍数についてはスキップ
とする
"""
import numpy as np
def main():
N = int(eval(input()))
A = list(map(int, input().split()))
A.sort()
d = np.zeros(A[-1] + 1, dtype=np.uint64) # 約数カウント。配列長さは、Aの最大値+1 で十分
for i in range(N):
a = A[i]
a1 = A[i - 1]
if a != a1: # 初出の数なら
d[a::a] += 1 # aからaごとに+1する (範囲内の全ての倍数に、約数カウント+1)
else: # 重複なら
d[a] += 1 # 自身のカウントを上げるだけで十分 (2倍以上はスキップ)
print((np.count_nonzero(d[A] == 1))) # Aのうち、約数カウントが1となったものの個数が答え
main()
| false | 71.818182 | [
"-import sys",
"-",
"-sys.setrecursionlimit(1000000000)",
"-import math",
"-from math import gcd",
"-",
"-",
"-def lcm(a, b):",
"- return a * b // gcd(a, b)",
"-",
"-",
"-from itertools import count, permutations, chain",
"-from functools import lru_cache",
"-from collections import deque, defaultdict",
"-from pprint import pprint",
"-",
"-ii = lambda: int(eval(input()))",
"-mis = lambda: list(map(int, input().split()))",
"-lmis = lambda: list(mis())",
"-INF = float(\"inf\")",
"-N1097 = 10**9 + 7",
"-",
"-",
"-def meg(f, ok, ng):",
"- while abs(ok - ng) > 1:",
"- mid = (ok + ng) // 2",
"- if f(mid):",
"- ok = mid",
"- else:",
"- ng = mid",
"- return ok",
"-",
"-",
"-def get_inv(n, modp):",
"- return pow(n, modp - 2, modp)",
"-",
"-",
"-def factorials_list(n, modp): # 10**6",
"- fs = [1]",
"- for i in range(1, n + 1):",
"- fs.append(fs[-1] * i % modp)",
"- return fs",
"-",
"-",
"-def invs_list(n, fs, modp): # 10**6",
"- invs = [get_inv(fs[-1], modp)]",
"- for i in range(n, 1 - 1, -1):",
"- invs.append(invs[-1] * i % modp)",
"- invs.reverse()",
"- return invs",
"-",
"-",
"-def comb(n, k, modp):",
"- num = 1",
"- for i in range(n, n - k, -1):",
"- num = num * i % modp",
"- den = 1",
"- for i in range(2, k + 1):",
"- den = den * i % modp",
"- return num * get_inv(den, modp) % modp",
"-",
"-",
"-def comb_from_list(n, k, modp, fs, invs):",
"- return fs[n] * invs[n - k] * invs[k] % modp",
"-",
"-",
"-#",
"-class UnionFindEx:",
"- def __init__(self, size):",
"- # 正なら根の番号、負ならグループサイズ",
"- self.roots = [-1] * size",
"-",
"- def getRootID(self, i):",
"- r = self.roots[i]",
"- if r < 0: # 負なら根",
"- return i",
"- else:",
"- r = self.getRootID(r)",
"- self.roots[i] = r",
"- return r",
"-",
"- def getGroupSize(self, i):",
"- return -self.roots[self.getRootID(i)]",
"-",
"- def connect(self, i, j):",
"- r1, r2 = self.getRootID(i), self.getRootID(j)",
"- if r1 == r2:",
"- return False",
"- if self.getGroupSize(r1) < self.getGroupSize(r2):",
"- r1, r2 = r2, r1",
"- self.roots[r1] += self.roots[r2] # サイズ更新",
"- self.roots[r2] = r1",
"- return True",
"-",
"-",
"-def get_primes(n):",
"- ps = [2]",
"- for i in range(3, n, 2):",
"- for p in ps:",
"- if i % p == 0:",
"- break",
"- else:",
"- ps.append(i)",
"- return ps",
"-",
"-",
"-Yes = \"Yes\"",
"-No = \"No\"",
"+\"\"\"",
"+方針",
"+ 1 ～ 10^6(Aの最大値) までの全ての数について、割り切れる数をカウント",
"+ カウント == 1 ならば、他の数では割り切れないので、そのような数の個数が答え",
"+工夫",
"+ そのままの実装では、最悪ケース : 1 1 1 1 ... で、TLEする",
"+ 対策として、",
"+ 1. Aを昇順ソートする",
"+ 2. A[i]がA[i-1]と同じならば、2倍以上の倍数についてはスキップ",
"+ とする",
"+\"\"\"",
"- N = ii()",
"- A = lmis()",
"+ N = int(eval(input()))",
"+ A = list(map(int, input().split()))",
"- d = np.zeros(A[-1] + 1, dtype=np.uint8)",
"+ d = np.zeros(A[-1] + 1, dtype=np.uint64) # 約数カウント。配列長さは、Aの最大値+1 で十分",
"- pa = A[i - 1]",
"- if a != pa:",
"- d[a::a] += 1",
"- else:",
"- d[a] += 1",
"- print((sum(d[a] == 1 for a in A)))",
"+ a1 = A[i - 1]",
"+ if a != a1: # 初出の数なら",
"+ d[a::a] += 1 # aからaごとに+1する (範囲内の全ての倍数に、約数カウント+1)",
"+ else: # 重複なら",
"+ d[a] += 1 # 自身のカウントを上げるだけで十分 (2倍以上はスキップ)",
"+ print((np.count_nonzero(d[A] == 1))) # Aのうち、約数カウントが1となったものの個数が答え"
] | false | 0.223179 | 0.388334 | 0.574708 | [
"s366049708",
"s183194628"
] |
u415905784 | p03108 | python | s174957239 | s215350693 | 738 | 524 | 36,624 | 36,312 | Accepted | Accepted | 29 | N, M = list(map(int, input().split()))
I = [[i, 1] for i in range(N)]
B = [0] * M
for i in range(M):
B[M - 1 - i] = [int(x) - 1 for x in input().split()]
NC = [0] * M
def n2(n):
return n * (n - 1) // 2
NC[-1] = n2(N)
def root(a):
#print(a, I[a][0])
if I[a][0] == a:
return a
else:
I[a][0] = root(I[a][0])
return I[a][0]
def union(a, b):
ra = root(a)
rb = root(b)
na = I[ra][1]
nb = I[rb][1]
if ra == rb:
return 0
if ra < rb:
I[rb][0] = ra
I[ra][1] += I[rb][1]
else:
I[ra][0] = rb
I[rb][1] += I[ra][1]
return n2(na + nb) - n2(na) - n2(nb)
for i in range(M - 1):
a, b = B[i]
NC[M - 2 - i] = NC[M - 1 - i] - union(a, b)
for nc in NC:
print(nc) | N, M = list(map(int, input().split()))
Bridge= [[int(i) for i in input().split()] for _ in range(M)]
Parent = [int(i) for i in range(N)]
Rank = [1] * N
def find(x):
if x == Parent[x]: return x
else:
Parent[x] = y = find(Parent[x])
return y
def unite(x, y, Total):
rx, ry = find(x), find(y)
if rx == ry: return Total
else:
Total -= Rank[rx] * Rank[ry]
if rx > ry:
Parent[rx] = ry
Rank[ry] += Rank[rx]
else:
Parent[ry] = rx
Rank[rx] += Rank[ry]
return Total
Total = N * (N - 1) // 2
Ans = [str(Total)] * M
for i in reversed(list(range(1, M))):
A, B = Bridge[i]
A -= 1
B -= 1
Total = unite(A, B, Total)
Ans[i - 1] = str(Total)
print(('\n'.join(Ans))) | 35 | 34 | 732 | 786 | N, M = list(map(int, input().split()))
I = [[i, 1] for i in range(N)]
B = [0] * M
for i in range(M):
B[M - 1 - i] = [int(x) - 1 for x in input().split()]
NC = [0] * M
def n2(n):
return n * (n - 1) // 2
NC[-1] = n2(N)
def root(a):
# print(a, I[a][0])
if I[a][0] == a:
return a
else:
I[a][0] = root(I[a][0])
return I[a][0]
def union(a, b):
ra = root(a)
rb = root(b)
na = I[ra][1]
nb = I[rb][1]
if ra == rb:
return 0
if ra < rb:
I[rb][0] = ra
I[ra][1] += I[rb][1]
else:
I[ra][0] = rb
I[rb][1] += I[ra][1]
return n2(na + nb) - n2(na) - n2(nb)
for i in range(M - 1):
a, b = B[i]
NC[M - 2 - i] = NC[M - 1 - i] - union(a, b)
for nc in NC:
print(nc)
| N, M = list(map(int, input().split()))
Bridge = [[int(i) for i in input().split()] for _ in range(M)]
Parent = [int(i) for i in range(N)]
Rank = [1] * N
def find(x):
if x == Parent[x]:
return x
else:
Parent[x] = y = find(Parent[x])
return y
def unite(x, y, Total):
rx, ry = find(x), find(y)
if rx == ry:
return Total
else:
Total -= Rank[rx] * Rank[ry]
if rx > ry:
Parent[rx] = ry
Rank[ry] += Rank[rx]
else:
Parent[ry] = rx
Rank[rx] += Rank[ry]
return Total
Total = N * (N - 1) // 2
Ans = [str(Total)] * M
for i in reversed(list(range(1, M))):
A, B = Bridge[i]
A -= 1
B -= 1
Total = unite(A, B, Total)
Ans[i - 1] = str(Total)
print(("\n".join(Ans)))
| false | 2.857143 | [
"-I = [[i, 1] for i in range(N)]",
"-B = [0] * M",
"-for i in range(M):",
"- B[M - 1 - i] = [int(x) - 1 for x in input().split()]",
"-NC = [0] * M",
"+Bridge = [[int(i) for i in input().split()] for _ in range(M)]",
"+Parent = [int(i) for i in range(N)]",
"+Rank = [1] * N",
"-def n2(n):",
"- return n * (n - 1) // 2",
"+def find(x):",
"+ if x == Parent[x]:",
"+ return x",
"+ else:",
"+ Parent[x] = y = find(Parent[x])",
"+ return y",
"-NC[-1] = n2(N)",
"+def unite(x, y, Total):",
"+ rx, ry = find(x), find(y)",
"+ if rx == ry:",
"+ return Total",
"+ else:",
"+ Total -= Rank[rx] * Rank[ry]",
"+ if rx > ry:",
"+ Parent[rx] = ry",
"+ Rank[ry] += Rank[rx]",
"+ else:",
"+ Parent[ry] = rx",
"+ Rank[rx] += Rank[ry]",
"+ return Total",
"-def root(a):",
"- # print(a, I[a][0])",
"- if I[a][0] == a:",
"- return a",
"- else:",
"- I[a][0] = root(I[a][0])",
"- return I[a][0]",
"-",
"-",
"-def union(a, b):",
"- ra = root(a)",
"- rb = root(b)",
"- na = I[ra][1]",
"- nb = I[rb][1]",
"- if ra == rb:",
"- return 0",
"- if ra < rb:",
"- I[rb][0] = ra",
"- I[ra][1] += I[rb][1]",
"- else:",
"- I[ra][0] = rb",
"- I[rb][1] += I[ra][1]",
"- return n2(na + nb) - n2(na) - n2(nb)",
"-",
"-",
"-for i in range(M - 1):",
"- a, b = B[i]",
"- NC[M - 2 - i] = NC[M - 1 - i] - union(a, b)",
"-for nc in NC:",
"- print(nc)",
"+Total = N * (N - 1) // 2",
"+Ans = [str(Total)] * M",
"+for i in reversed(list(range(1, M))):",
"+ A, B = Bridge[i]",
"+ A -= 1",
"+ B -= 1",
"+ Total = unite(A, B, Total)",
"+ Ans[i - 1] = str(Total)",
"+print((\"\\n\".join(Ans)))"
] | false | 0.041717 | 0.041551 | 1.004 | [
"s174957239",
"s215350693"
] |
u062147869 | p03329 | python | s459930644 | s713214916 | 649 | 291 | 3,828 | 3,060 | Accepted | Accepted | 55.16 | N = int(eval(input()))
A=[]
A.append(1)
for i in range(1,7):
A.append(6**i)
for i in range(1,6):
A.append(9**i)
A.sort()
dp=[10*5+5]*(N+1)
dp[0]=0
for i in range(1,N+1):
for s in range(len(A)):
if i-A[s]>=0:
dp[i]=min(dp[i-A[s]]+1,dp[i])
print((dp[N]))
| N = int(eval(input()))
def shin(n,q):
s = n
a = 0
while(s>0):
t=s%q
a +=t
s=(s-t)//q
return a
ans = N
for i in range(N+1):
c=shin(i,6)+shin(N-i,9)
ans = min(ans,c)
print(ans) | 15 | 14 | 291 | 229 | N = int(eval(input()))
A = []
A.append(1)
for i in range(1, 7):
A.append(6**i)
for i in range(1, 6):
A.append(9**i)
A.sort()
dp = [10 * 5 + 5] * (N + 1)
dp[0] = 0
for i in range(1, N + 1):
for s in range(len(A)):
if i - A[s] >= 0:
dp[i] = min(dp[i - A[s]] + 1, dp[i])
print((dp[N]))
| N = int(eval(input()))
def shin(n, q):
s = n
a = 0
while s > 0:
t = s % q
a += t
s = (s - t) // q
return a
ans = N
for i in range(N + 1):
c = shin(i, 6) + shin(N - i, 9)
ans = min(ans, c)
print(ans)
| false | 6.666667 | [
"-A = []",
"-A.append(1)",
"-for i in range(1, 7):",
"- A.append(6**i)",
"-for i in range(1, 6):",
"- A.append(9**i)",
"-A.sort()",
"-dp = [10 * 5 + 5] * (N + 1)",
"-dp[0] = 0",
"-for i in range(1, N + 1):",
"- for s in range(len(A)):",
"- if i - A[s] >= 0:",
"- dp[i] = min(dp[i - A[s]] + 1, dp[i])",
"-print((dp[N]))",
"+",
"+",
"+def shin(n, q):",
"+ s = n",
"+ a = 0",
"+ while s > 0:",
"+ t = s % q",
"+ a += t",
"+ s = (s - t) // q",
"+ return a",
"+",
"+",
"+ans = N",
"+for i in range(N + 1):",
"+ c = shin(i, 6) + shin(N - i, 9)",
"+ ans = min(ans, c)",
"+print(ans)"
] | false | 0.692348 | 0.09399 | 7.366186 | [
"s459930644",
"s713214916"
] |
u150984829 | p02269 | python | s340748353 | s460945220 | 5,060 | 4,550 | 38,880 | 40,932 | Accepted | Accepted | 10.08 | d=set()
for _ in[0]*int(eval(input())):
c,g=input().split()
if'i'==c[0]:d|=set([g])
else:print((['no','yes'][g in d]))
| d={}
for _ in[0]*int(eval(input())):
c,g=input().split()
if'i'==c[0]:d[g]=0
else:print((['no','yes'][g in d]))
| 5 | 5 | 118 | 110 | d = set()
for _ in [0] * int(eval(input())):
c, g = input().split()
if "i" == c[0]:
d |= set([g])
else:
print((["no", "yes"][g in d]))
| d = {}
for _ in [0] * int(eval(input())):
c, g = input().split()
if "i" == c[0]:
d[g] = 0
else:
print((["no", "yes"][g in d]))
| false | 0 | [
"-d = set()",
"+d = {}",
"- d |= set([g])",
"+ d[g] = 0"
] | false | 0.036962 | 0.03663 | 1.009067 | [
"s340748353",
"s460945220"
] |
u323680411 | p03986 | python | s619869480 | s799938801 | 99 | 38 | 3,572 | 3,500 | Accepted | Accepted | 61.62 | import sys
def main() -> None:
x = next_str()
s_cnt = 0
ans = 0
for v in x:
if v == 'S':
s_cnt += 1
if v == 'T':
if s_cnt == 0:
ans += 1
else:
s_cnt -= 1
ans += s_cnt
print(ans)
def next_str() -> str:
result = ""
while True:
tmp = sys.stdin.read(1)
if tmp.strip() != "":
result += tmp
elif tmp != '\r':
break
return result
if __name__ == '__main__':
main() | import sys
def main() -> None:
x = eval(input())
s_cnt = 0
ans = 0
for v in x:
if v == 'S':
s_cnt += 1
if v == 'T':
if s_cnt == 0:
ans += 1
else:
s_cnt -= 1
ans += s_cnt
print(ans)
def next_str() -> str:
result = ""
while True:
tmp = sys.stdin.read(1)
if tmp.strip() != "":
result += tmp
elif tmp != '\r':
break
return result
if __name__ == '__main__':
main() | 34 | 34 | 569 | 566 | import sys
def main() -> None:
x = next_str()
s_cnt = 0
ans = 0
for v in x:
if v == "S":
s_cnt += 1
if v == "T":
if s_cnt == 0:
ans += 1
else:
s_cnt -= 1
ans += s_cnt
print(ans)
def next_str() -> str:
result = ""
while True:
tmp = sys.stdin.read(1)
if tmp.strip() != "":
result += tmp
elif tmp != "\r":
break
return result
if __name__ == "__main__":
main()
| import sys
def main() -> None:
x = eval(input())
s_cnt = 0
ans = 0
for v in x:
if v == "S":
s_cnt += 1
if v == "T":
if s_cnt == 0:
ans += 1
else:
s_cnt -= 1
ans += s_cnt
print(ans)
def next_str() -> str:
result = ""
while True:
tmp = sys.stdin.read(1)
if tmp.strip() != "":
result += tmp
elif tmp != "\r":
break
return result
if __name__ == "__main__":
main()
| false | 0 | [
"- x = next_str()",
"+ x = eval(input())"
] | false | 0.041382 | 0.041264 | 1.002857 | [
"s619869480",
"s799938801"
] |
u353895424 | p03324 | python | s221847069 | s535240088 | 174 | 17 | 38,432 | 2,940 | Accepted | Accepted | 90.23 | d,n=list(map(int, input().split()))
if n == 100:
print((101 * n**d))
else:
print((100**d * n)) | d, n = list(map(int, input().split()))
if n == 100:
print((101*100**d))
else:
print((100**d*n))
| 5 | 5 | 96 | 98 | d, n = list(map(int, input().split()))
if n == 100:
print((101 * n**d))
else:
print((100**d * n))
| d, n = list(map(int, input().split()))
if n == 100:
print((101 * 100**d))
else:
print((100**d * n))
| false | 0 | [
"- print((101 * n**d))",
"+ print((101 * 100**d))"
] | false | 0.101452 | 0.036554 | 2.77542 | [
"s221847069",
"s535240088"
] |
u620868411 | p03617 | python | s087687721 | s135707189 | 40 | 17 | 3,064 | 2,940 | Accepted | Accepted | 57.5 | # -*- coding: utf-8 -*-
q,h,s,d = list(map(int,input().split()))
n = int(eval(input()))
q = 4*q
h = 2*h
if n%2==0:
t = q*n
t = min(t, h*n)
t = min(t, s*n)
t = min(t, d*n//2)
else:
t = q*n
t = min(t, h*n)
t = min(t, s*n)
t = min(t, (n//2)*d + min(q,h,s))
print(t)
| q,h,s,d = list(map(int, input().split()))
n = int(eval(input()))
q = 4*q
h = 2*h
x = min(q,h,s)
print(((n//2)*min(2*x,d)+(n%2)*x)) | 18 | 8 | 302 | 125 | # -*- coding: utf-8 -*-
q, h, s, d = list(map(int, input().split()))
n = int(eval(input()))
q = 4 * q
h = 2 * h
if n % 2 == 0:
t = q * n
t = min(t, h * n)
t = min(t, s * n)
t = min(t, d * n // 2)
else:
t = q * n
t = min(t, h * n)
t = min(t, s * n)
t = min(t, (n // 2) * d + min(q, h, s))
print(t)
| q, h, s, d = list(map(int, input().split()))
n = int(eval(input()))
q = 4 * q
h = 2 * h
x = min(q, h, s)
print(((n // 2) * min(2 * x, d) + (n % 2) * x))
| false | 55.555556 | [
"-# -*- coding: utf-8 -*-",
"-if n % 2 == 0:",
"- t = q * n",
"- t = min(t, h * n)",
"- t = min(t, s * n)",
"- t = min(t, d * n // 2)",
"-else:",
"- t = q * n",
"- t = min(t, h * n)",
"- t = min(t, s * n)",
"- t = min(t, (n // 2) * d + min(q, h, s))",
"-print(t)",
"+x = min(q, h, s)",
"+print(((n // 2) * min(2 * x, d) + (n % 2) * x))"
] | false | 0.034855 | 0.035098 | 0.99307 | [
"s087687721",
"s135707189"
] |
u714378447 | p03805 | python | s118302482 | s576571199 | 60 | 47 | 3,064 | 3,064 | Accepted | Accepted | 21.67 | import sys
sys.setrecursionlimit(6000)
n_node, n_path = [int(x) for x in input().split()]
A = [[0]*2 for x in range(n_path)]
for i in range(n_path):
A[i][0], A[i][1] = [int(x) for x in input().split()]
def serch(A, cur_node, old, n_node):
ans = 0
if len(old) == (n_node-1):
return 1
for i in range(len(A)):
if cur_node == A[i][0] and not(A[i][1] in old):
A_copy = A.copy()
A_copy.pop(i)
old_copy = old.copy()
old_copy.append(cur_node)
ans += serch(A_copy, A[i][1], old_copy, n_node)
elif cur_node == A[i][1] and not(A[i][0] in old):
A_copy = A.copy()
A_copy.pop(i)
old_copy = old.copy()
old_copy.append(cur_node)
ans += serch(A_copy, A[i][0], old_copy, n_node)
return ans
print((serch(A, 1, [], n_node)))
| N,M=list(map(int,input().split()))
his=[False]*N
A=[[0]*2 for i in range(M)]
for i in range(M):
a,b=list(map(int,input().split()))
A[i][0],A[i][1] =a-1,b-1
def search(now,his,A):
if all(his):
return 1
else:
cnt=0
for a in A:
if now in a:
nex=a[(a.index(now)+1)%2]
if not his[nex]:
his[nex]=True
cnt+=search(nex,his,A)
his[nex]=False
return cnt
his[0]=True
print((search(0,his,A))) | 38 | 28 | 802 | 567 | import sys
sys.setrecursionlimit(6000)
n_node, n_path = [int(x) for x in input().split()]
A = [[0] * 2 for x in range(n_path)]
for i in range(n_path):
A[i][0], A[i][1] = [int(x) for x in input().split()]
def serch(A, cur_node, old, n_node):
ans = 0
if len(old) == (n_node - 1):
return 1
for i in range(len(A)):
if cur_node == A[i][0] and not (A[i][1] in old):
A_copy = A.copy()
A_copy.pop(i)
old_copy = old.copy()
old_copy.append(cur_node)
ans += serch(A_copy, A[i][1], old_copy, n_node)
elif cur_node == A[i][1] and not (A[i][0] in old):
A_copy = A.copy()
A_copy.pop(i)
old_copy = old.copy()
old_copy.append(cur_node)
ans += serch(A_copy, A[i][0], old_copy, n_node)
return ans
print((serch(A, 1, [], n_node)))
| N, M = list(map(int, input().split()))
his = [False] * N
A = [[0] * 2 for i in range(M)]
for i in range(M):
a, b = list(map(int, input().split()))
A[i][0], A[i][1] = a - 1, b - 1
def search(now, his, A):
if all(his):
return 1
else:
cnt = 0
for a in A:
if now in a:
nex = a[(a.index(now) + 1) % 2]
if not his[nex]:
his[nex] = True
cnt += search(nex, his, A)
his[nex] = False
return cnt
his[0] = True
print((search(0, his, A)))
| false | 26.315789 | [
"-import sys",
"-",
"-sys.setrecursionlimit(6000)",
"-n_node, n_path = [int(x) for x in input().split()]",
"-A = [[0] * 2 for x in range(n_path)]",
"-for i in range(n_path):",
"- A[i][0], A[i][1] = [int(x) for x in input().split()]",
"+N, M = list(map(int, input().split()))",
"+his = [False] * N",
"+A = [[0] * 2 for i in range(M)]",
"+for i in range(M):",
"+ a, b = list(map(int, input().split()))",
"+ A[i][0], A[i][1] = a - 1, b - 1",
"-def serch(A, cur_node, old, n_node):",
"- ans = 0",
"- if len(old) == (n_node - 1):",
"+def search(now, his, A):",
"+ if all(his):",
"- for i in range(len(A)):",
"- if cur_node == A[i][0] and not (A[i][1] in old):",
"- A_copy = A.copy()",
"- A_copy.pop(i)",
"- old_copy = old.copy()",
"- old_copy.append(cur_node)",
"- ans += serch(A_copy, A[i][1], old_copy, n_node)",
"- elif cur_node == A[i][1] and not (A[i][0] in old):",
"- A_copy = A.copy()",
"- A_copy.pop(i)",
"- old_copy = old.copy()",
"- old_copy.append(cur_node)",
"- ans += serch(A_copy, A[i][0], old_copy, n_node)",
"- return ans",
"+ else:",
"+ cnt = 0",
"+ for a in A:",
"+ if now in a:",
"+ nex = a[(a.index(now) + 1) % 2]",
"+ if not his[nex]:",
"+ his[nex] = True",
"+ cnt += search(nex, his, A)",
"+ his[nex] = False",
"+ return cnt",
"-print((serch(A, 1, [], n_node)))",
"+his[0] = True",
"+print((search(0, his, A)))"
] | false | 0.040924 | 0.039477 | 1.036656 | [
"s118302482",
"s576571199"
] |
u387774811 | p02714 | python | s575564130 | s695777396 | 357 | 173 | 69,200 | 68,852 | Accepted | Accepted | 51.54 | N=int(eval(input()))
A=eval(input())
c=0
B1B=0
B1R=0
B1G=0
if A[0]=="B":
B1B+=1
elif A[0]=="R":
B1R+=1
else:
B1G+=1
for i in range(N-2):
B2=A[i+1]
for k in range(N-i-2):
B3=A[i+2+k]
if (B2=="B" and B3=="R")or (B2=="R" and B3=="B"):
c+=B1G
if (i+2+k)<=(i+1)*2:
if A[(i+1)*2-(i+2+k)]=="G":
c-=1
if (B2=="G" and B3=="R")or (B2=="R" and B3=="G"):
c+=B1B
if (i+2+k)<=(i+1)*2:
if A[(i+1)*2-(i+2+k)]=="B":
c-=1
if (B2=="B" and B3=="G")or (B2=="G" and B3=="B"):
c+=B1R
if (i+2+k)<=(i+1)*2:
if A[(i+1)*2-(i+2+k)]=="R":
c-=1
if B2=="B":
B1B+=1
elif B2=="R":
B1R+=1
else:
B1G+=1
print(c)
| N=int(eval(input()))
S=eval(input())
R=0
G=1
B=2
chk=[0]*N
lst=[[0 for e in range(3)] for f in range(N)]
if S[N-1]=="R":
chk[N-1]=0
lst[N-1][0]+=1
elif S[N-1]=="G":
chk[N-1]=1
lst[N-1][1]+=1
else:
chk[N-1]=2
lst[N-1][2]+=1
if N>=2:
for i in range(1,N):
lst[N-1-i][0]+=lst[N-i][0]
lst[N-1-i][1]+=lst[N-i][1]
lst[N-1-i][2]+=lst[N-i][2]
if S[N-1-i]=="R":
chk[N-1-i]=0
lst[N-1-i][0]+=1
elif S[N-1-i]=="G":
chk[N-1-i]=1
lst[N-1-i][1]+=1
else:
chk[N-1-i]=2
lst[N-1-i][2]+=1
ans=0
if N<=2:
print((0))
else:
for i in range(N-2):
for j in range(i+1,N-1):
if chk[i]!=chk[j]:
ans+=lst[j+1][3-chk[i]-chk[j]]
if 2*j-i<=N-1:
if chk[2*j-i]==3-chk[i]-chk[j]:
ans-=1
print(ans) | 38 | 42 | 669 | 750 | N = int(eval(input()))
A = eval(input())
c = 0
B1B = 0
B1R = 0
B1G = 0
if A[0] == "B":
B1B += 1
elif A[0] == "R":
B1R += 1
else:
B1G += 1
for i in range(N - 2):
B2 = A[i + 1]
for k in range(N - i - 2):
B3 = A[i + 2 + k]
if (B2 == "B" and B3 == "R") or (B2 == "R" and B3 == "B"):
c += B1G
if (i + 2 + k) <= (i + 1) * 2:
if A[(i + 1) * 2 - (i + 2 + k)] == "G":
c -= 1
if (B2 == "G" and B3 == "R") or (B2 == "R" and B3 == "G"):
c += B1B
if (i + 2 + k) <= (i + 1) * 2:
if A[(i + 1) * 2 - (i + 2 + k)] == "B":
c -= 1
if (B2 == "B" and B3 == "G") or (B2 == "G" and B3 == "B"):
c += B1R
if (i + 2 + k) <= (i + 1) * 2:
if A[(i + 1) * 2 - (i + 2 + k)] == "R":
c -= 1
if B2 == "B":
B1B += 1
elif B2 == "R":
B1R += 1
else:
B1G += 1
print(c)
| N = int(eval(input()))
S = eval(input())
R = 0
G = 1
B = 2
chk = [0] * N
lst = [[0 for e in range(3)] for f in range(N)]
if S[N - 1] == "R":
chk[N - 1] = 0
lst[N - 1][0] += 1
elif S[N - 1] == "G":
chk[N - 1] = 1
lst[N - 1][1] += 1
else:
chk[N - 1] = 2
lst[N - 1][2] += 1
if N >= 2:
for i in range(1, N):
lst[N - 1 - i][0] += lst[N - i][0]
lst[N - 1 - i][1] += lst[N - i][1]
lst[N - 1 - i][2] += lst[N - i][2]
if S[N - 1 - i] == "R":
chk[N - 1 - i] = 0
lst[N - 1 - i][0] += 1
elif S[N - 1 - i] == "G":
chk[N - 1 - i] = 1
lst[N - 1 - i][1] += 1
else:
chk[N - 1 - i] = 2
lst[N - 1 - i][2] += 1
ans = 0
if N <= 2:
print((0))
else:
for i in range(N - 2):
for j in range(i + 1, N - 1):
if chk[i] != chk[j]:
ans += lst[j + 1][3 - chk[i] - chk[j]]
if 2 * j - i <= N - 1:
if chk[2 * j - i] == 3 - chk[i] - chk[j]:
ans -= 1
print(ans)
| false | 9.52381 | [
"-A = eval(input())",
"-c = 0",
"-B1B = 0",
"-B1R = 0",
"-B1G = 0",
"-if A[0] == \"B\":",
"- B1B += 1",
"-elif A[0] == \"R\":",
"- B1R += 1",
"+S = eval(input())",
"+R = 0",
"+G = 1",
"+B = 2",
"+chk = [0] * N",
"+lst = [[0 for e in range(3)] for f in range(N)]",
"+if S[N - 1] == \"R\":",
"+ chk[N - 1] = 0",
"+ lst[N - 1][0] += 1",
"+elif S[N - 1] == \"G\":",
"+ chk[N - 1] = 1",
"+ lst[N - 1][1] += 1",
"- B1G += 1",
"-for i in range(N - 2):",
"- B2 = A[i + 1]",
"- for k in range(N - i - 2):",
"- B3 = A[i + 2 + k]",
"- if (B2 == \"B\" and B3 == \"R\") or (B2 == \"R\" and B3 == \"B\"):",
"- c += B1G",
"- if (i + 2 + k) <= (i + 1) * 2:",
"- if A[(i + 1) * 2 - (i + 2 + k)] == \"G\":",
"- c -= 1",
"- if (B2 == \"G\" and B3 == \"R\") or (B2 == \"R\" and B3 == \"G\"):",
"- c += B1B",
"- if (i + 2 + k) <= (i + 1) * 2:",
"- if A[(i + 1) * 2 - (i + 2 + k)] == \"B\":",
"- c -= 1",
"- if (B2 == \"B\" and B3 == \"G\") or (B2 == \"G\" and B3 == \"B\"):",
"- c += B1R",
"- if (i + 2 + k) <= (i + 1) * 2:",
"- if A[(i + 1) * 2 - (i + 2 + k)] == \"R\":",
"- c -= 1",
"- if B2 == \"B\":",
"- B1B += 1",
"- elif B2 == \"R\":",
"- B1R += 1",
"- else:",
"- B1G += 1",
"-print(c)",
"+ chk[N - 1] = 2",
"+ lst[N - 1][2] += 1",
"+if N >= 2:",
"+ for i in range(1, N):",
"+ lst[N - 1 - i][0] += lst[N - i][0]",
"+ lst[N - 1 - i][1] += lst[N - i][1]",
"+ lst[N - 1 - i][2] += lst[N - i][2]",
"+ if S[N - 1 - i] == \"R\":",
"+ chk[N - 1 - i] = 0",
"+ lst[N - 1 - i][0] += 1",
"+ elif S[N - 1 - i] == \"G\":",
"+ chk[N - 1 - i] = 1",
"+ lst[N - 1 - i][1] += 1",
"+ else:",
"+ chk[N - 1 - i] = 2",
"+ lst[N - 1 - i][2] += 1",
"+ans = 0",
"+if N <= 2:",
"+ print((0))",
"+else:",
"+ for i in range(N - 2):",
"+ for j in range(i + 1, N - 1):",
"+ if chk[i] != chk[j]:",
"+ ans += lst[j + 1][3 - chk[i] - chk[j]]",
"+ if 2 * j - i <= N - 1:",
"+ if chk[2 * j - i] == 3 - chk[i] - chk[j]:",
"+ ans -= 1",
"+print(ans)"
] | false | 0.035649 | 0.037696 | 0.945697 | [
"s575564130",
"s695777396"
] |
u678167152 | p02973 | python | s916429637 | s172261721 | 230 | 174 | 11,032 | 13,724 | Accepted | Accepted | 24.35 | N = int(eval(input()))
A = [int(eval(input())) for _ in range(N)]
from bisect import bisect_left, bisect_right, bisect, insort_left, insort_right, insort
def solve(N,A):
ans = 0
lis = []
for i in range(N):
ind = bisect_right(lis,-A[i])
if ind == len(lis):
lis.append(-A[i])
else:
lis[ind] = -A[i]
ans = len(lis)
return ans
print((solve(N,A))) | from bisect import *
def solve():
ans = 0
N = int(eval(input()))
A = [-int(eval(input())) for _ in range(N)]
lis = [A[0]]
for i in range(1,N):
if A[i]>=lis[-1]:
lis.append(A[i])
else:
ind = bisect_right(lis,A[i])
lis[ind] = A[i]
ans = len(lis)
return ans
print((solve())) | 17 | 15 | 414 | 351 | N = int(eval(input()))
A = [int(eval(input())) for _ in range(N)]
from bisect import bisect_left, bisect_right, bisect, insort_left, insort_right, insort
def solve(N, A):
ans = 0
lis = []
for i in range(N):
ind = bisect_right(lis, -A[i])
if ind == len(lis):
lis.append(-A[i])
else:
lis[ind] = -A[i]
ans = len(lis)
return ans
print((solve(N, A)))
| from bisect import *
def solve():
ans = 0
N = int(eval(input()))
A = [-int(eval(input())) for _ in range(N)]
lis = [A[0]]
for i in range(1, N):
if A[i] >= lis[-1]:
lis.append(A[i])
else:
ind = bisect_right(lis, A[i])
lis[ind] = A[i]
ans = len(lis)
return ans
print((solve()))
| false | 11.764706 | [
"-N = int(eval(input()))",
"-A = [int(eval(input())) for _ in range(N)]",
"-from bisect import bisect_left, bisect_right, bisect, insort_left, insort_right, insort",
"+from bisect import *",
"-def solve(N, A):",
"+def solve():",
"- lis = []",
"- for i in range(N):",
"- ind = bisect_right(lis, -A[i])",
"- if ind == len(lis):",
"- lis.append(-A[i])",
"+ N = int(eval(input()))",
"+ A = [-int(eval(input())) for _ in range(N)]",
"+ lis = [A[0]]",
"+ for i in range(1, N):",
"+ if A[i] >= lis[-1]:",
"+ lis.append(A[i])",
"- lis[ind] = -A[i]",
"+ ind = bisect_right(lis, A[i])",
"+ lis[ind] = A[i]",
"-print((solve(N, A)))",
"+print((solve()))"
] | false | 0.037841 | 0.07797 | 0.485319 | [
"s916429637",
"s172261721"
] |
u844789719 | p03212 | python | s802710034 | s224214989 | 1,065 | 869 | 4,028 | 3,320 | Accepted | Accepted | 18.4 | N = int(eval(input()))
array = []
for i in range(10**9):
res = ''
digit = 0
while i:
res = '0357'[i % 4] + res
i //= 4
if '3' in res and '5' in res and '7' in res and '0' not in res:
res = int(res)
if res > 10 ** 9:
break
array += [res]
array += [10**9]
for i in range(len(array)):
if array[i] > N:
print(i)
exit()
| N = int(eval(input()))
def resol_a(x, a):
if x < 10:
return int(x >= a)
d = 0
while x > 10**(d+1):
d += 1
f = x // 10 ** d
r = x % 10 ** d
c = resol_a(r, a)
b = resol_a(10 ** d - 1, a)
bb = resol_a(10 ** (d - 1), a)
if f > a:
return b + 1
elif f == a:
return b + c - bb
else:
return b
def resol_ab(x, a, b):
d = 0
if x < 100:
return (x >= 10 * b + a) + (x >= 10 * a + b)
while x > 10 ** (d + 1):
d += 1
f = x // 10 ** d
r = x % 10 ** d
if f > a:
return resol_ab((a+1)*10**d-1, a, b)
elif f == a:
return resol_ab(a * 10 ** d - 1, a, b) + max(resol_ab(r, a, b) - resol_ab(10 **
(d - 1), a, b), 0) + max(resol_a(r, b) - resol_a(10 ** (d - 1), b), 0)
elif f > b:
return resol_ab((b+1)*10 ** d - 1, a, b)
elif f == b:
return resol_ab(b * 10 ** d - 1, a, b) + max(resol_ab(r, a, b) - resol_ab(10 **
(d - 1), a, b), 0) + max(resol_a(r, a) - resol_a(10 ** (d - 1), a), 0)
else:
return resol_ab(10 ** d - 1, a, b)
def resol_abc(x, a, b, c):
if x < 1000:
A, B, C = str(a), str(b), str(c)
return sum([x >= int(_) for _ in [A+B+C, A+C+B, B+A+C, B+C+A, C+A+B, C+B+A]])
d = 0
while x > 10 ** (d + 1):
d += 1
f = x // 10 ** d
r = x % 10 ** d
if f > a:
return resol_abc((a+1)*10**d-1, a, b, c)
elif f == a:
return resol_abc(a*10**d-1, a, b, c)+max(resol_abc(r, a, b, c)-resol_abc(10**(d-1), a, b, c), 0)+max(resol_ab(r, b, c)-resol_ab(10**(d-1), b, c), 0)
elif f > b:
return resol_abc((b+1)*10**d-1, a, b, c)
elif f == b:
return resol_abc(b*10**d-1, a, b, c)+max(resol_abc(r, a, b, c)-resol_abc(10**(d-1), a, b, c), 0)+max(resol_ab(r, a, c)-resol_ab(10**(d-1), a, c), 0)
elif f > c:
return resol_abc((c+1)*10**d-1, a, b, c)
elif f == c:
return resol_abc(c*10**d-1, a, b, c)+max(resol_abc(r, a, b, c)-resol_abc(10**(d-1), a, b, c), 0)+max(resol_ab(r, a, b)-resol_ab(10**(d-1), a, b), 0)
else:
return resol_abc(10**d-1, a, b, c)
print((resol_abc(N, 7, 5, 3))) | 18 | 70 | 414 | 2,382 | N = int(eval(input()))
array = []
for i in range(10**9):
res = ""
digit = 0
while i:
res = "0357"[i % 4] + res
i //= 4
if "3" in res and "5" in res and "7" in res and "0" not in res:
res = int(res)
if res > 10**9:
break
array += [res]
array += [10**9]
for i in range(len(array)):
if array[i] > N:
print(i)
exit()
| N = int(eval(input()))
def resol_a(x, a):
if x < 10:
return int(x >= a)
d = 0
while x > 10 ** (d + 1):
d += 1
f = x // 10**d
r = x % 10**d
c = resol_a(r, a)
b = resol_a(10**d - 1, a)
bb = resol_a(10 ** (d - 1), a)
if f > a:
return b + 1
elif f == a:
return b + c - bb
else:
return b
def resol_ab(x, a, b):
d = 0
if x < 100:
return (x >= 10 * b + a) + (x >= 10 * a + b)
while x > 10 ** (d + 1):
d += 1
f = x // 10**d
r = x % 10**d
if f > a:
return resol_ab((a + 1) * 10**d - 1, a, b)
elif f == a:
return (
resol_ab(a * 10**d - 1, a, b)
+ max(resol_ab(r, a, b) - resol_ab(10 ** (d - 1), a, b), 0)
+ max(resol_a(r, b) - resol_a(10 ** (d - 1), b), 0)
)
elif f > b:
return resol_ab((b + 1) * 10**d - 1, a, b)
elif f == b:
return (
resol_ab(b * 10**d - 1, a, b)
+ max(resol_ab(r, a, b) - resol_ab(10 ** (d - 1), a, b), 0)
+ max(resol_a(r, a) - resol_a(10 ** (d - 1), a), 0)
)
else:
return resol_ab(10**d - 1, a, b)
def resol_abc(x, a, b, c):
if x < 1000:
A, B, C = str(a), str(b), str(c)
return sum(
[
x >= int(_)
for _ in [
A + B + C,
A + C + B,
B + A + C,
B + C + A,
C + A + B,
C + B + A,
]
]
)
d = 0
while x > 10 ** (d + 1):
d += 1
f = x // 10**d
r = x % 10**d
if f > a:
return resol_abc((a + 1) * 10**d - 1, a, b, c)
elif f == a:
return (
resol_abc(a * 10**d - 1, a, b, c)
+ max(resol_abc(r, a, b, c) - resol_abc(10 ** (d - 1), a, b, c), 0)
+ max(resol_ab(r, b, c) - resol_ab(10 ** (d - 1), b, c), 0)
)
elif f > b:
return resol_abc((b + 1) * 10**d - 1, a, b, c)
elif f == b:
return (
resol_abc(b * 10**d - 1, a, b, c)
+ max(resol_abc(r, a, b, c) - resol_abc(10 ** (d - 1), a, b, c), 0)
+ max(resol_ab(r, a, c) - resol_ab(10 ** (d - 1), a, c), 0)
)
elif f > c:
return resol_abc((c + 1) * 10**d - 1, a, b, c)
elif f == c:
return (
resol_abc(c * 10**d - 1, a, b, c)
+ max(resol_abc(r, a, b, c) - resol_abc(10 ** (d - 1), a, b, c), 0)
+ max(resol_ab(r, a, b) - resol_ab(10 ** (d - 1), a, b), 0)
)
else:
return resol_abc(10**d - 1, a, b, c)
print((resol_abc(N, 7, 5, 3)))
| false | 74.285714 | [
"-array = []",
"-for i in range(10**9):",
"- res = \"\"",
"- digit = 0",
"- while i:",
"- res = \"0357\"[i % 4] + res",
"- i //= 4",
"- if \"3\" in res and \"5\" in res and \"7\" in res and \"0\" not in res:",
"- res = int(res)",
"- if res > 10**9:",
"- break",
"- array += [res]",
"-array += [10**9]",
"-for i in range(len(array)):",
"- if array[i] > N:",
"- print(i)",
"- exit()",
"+",
"+",
"+def resol_a(x, a):",
"+ if x < 10:",
"+ return int(x >= a)",
"+ d = 0",
"+ while x > 10 ** (d + 1):",
"+ d += 1",
"+ f = x // 10**d",
"+ r = x % 10**d",
"+ c = resol_a(r, a)",
"+ b = resol_a(10**d - 1, a)",
"+ bb = resol_a(10 ** (d - 1), a)",
"+ if f > a:",
"+ return b + 1",
"+ elif f == a:",
"+ return b + c - bb",
"+ else:",
"+ return b",
"+",
"+",
"+def resol_ab(x, a, b):",
"+ d = 0",
"+ if x < 100:",
"+ return (x >= 10 * b + a) + (x >= 10 * a + b)",
"+ while x > 10 ** (d + 1):",
"+ d += 1",
"+ f = x // 10**d",
"+ r = x % 10**d",
"+ if f > a:",
"+ return resol_ab((a + 1) * 10**d - 1, a, b)",
"+ elif f == a:",
"+ return (",
"+ resol_ab(a * 10**d - 1, a, b)",
"+ + max(resol_ab(r, a, b) - resol_ab(10 ** (d - 1), a, b), 0)",
"+ + max(resol_a(r, b) - resol_a(10 ** (d - 1), b), 0)",
"+ )",
"+ elif f > b:",
"+ return resol_ab((b + 1) * 10**d - 1, a, b)",
"+ elif f == b:",
"+ return (",
"+ resol_ab(b * 10**d - 1, a, b)",
"+ + max(resol_ab(r, a, b) - resol_ab(10 ** (d - 1), a, b), 0)",
"+ + max(resol_a(r, a) - resol_a(10 ** (d - 1), a), 0)",
"+ )",
"+ else:",
"+ return resol_ab(10**d - 1, a, b)",
"+",
"+",
"+def resol_abc(x, a, b, c):",
"+ if x < 1000:",
"+ A, B, C = str(a), str(b), str(c)",
"+ return sum(",
"+ [",
"+ x >= int(_)",
"+ for _ in [",
"+ A + B + C,",
"+ A + C + B,",
"+ B + A + C,",
"+ B + C + A,",
"+ C + A + B,",
"+ C + B + A,",
"+ ]",
"+ ]",
"+ )",
"+ d = 0",
"+ while x > 10 ** (d + 1):",
"+ d += 1",
"+ f = x // 10**d",
"+ r = x % 10**d",
"+ if f > a:",
"+ return resol_abc((a + 1) * 10**d - 1, a, b, c)",
"+ elif f == a:",
"+ return (",
"+ resol_abc(a * 10**d - 1, a, b, c)",
"+ + max(resol_abc(r, a, b, c) - resol_abc(10 ** (d - 1), a, b, c), 0)",
"+ + max(resol_ab(r, b, c) - resol_ab(10 ** (d - 1), b, c), 0)",
"+ )",
"+ elif f > b:",
"+ return resol_abc((b + 1) * 10**d - 1, a, b, c)",
"+ elif f == b:",
"+ return (",
"+ resol_abc(b * 10**d - 1, a, b, c)",
"+ + max(resol_abc(r, a, b, c) - resol_abc(10 ** (d - 1), a, b, c), 0)",
"+ + max(resol_ab(r, a, c) - resol_ab(10 ** (d - 1), a, c), 0)",
"+ )",
"+ elif f > c:",
"+ return resol_abc((c + 1) * 10**d - 1, a, b, c)",
"+ elif f == c:",
"+ return (",
"+ resol_abc(c * 10**d - 1, a, b, c)",
"+ + max(resol_abc(r, a, b, c) - resol_abc(10 ** (d - 1), a, b, c), 0)",
"+ + max(resol_ab(r, a, b) - resol_ab(10 ** (d - 1), a, b), 0)",
"+ )",
"+ else:",
"+ return resol_abc(10**d - 1, a, b, c)",
"+",
"+",
"+print((resol_abc(N, 7, 5, 3)))"
] | false | 2.175743 | 0.580212 | 3.749912 | [
"s802710034",
"s224214989"
] |
u588341295 | p03061 | python | s926722438 | s044571983 | 1,797 | 708 | 117,028 | 89,580 | Accepted | Accepted | 60.6 | # -*- coding: utf-8 -*-
import sys
if sys.version_info.minor >= 5: from math import gcd
else: from fractions import gcd
def input(): return sys.stdin.readline().strip()
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(): return list(map(int, input().split()))
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7
class SegTree:
"""
以下のクエリを処理する
1.update: i番目の値をxに更新する
2.get_val: 区間[l, r)の値を得る
"""
def __init__(self, n, func, init):
"""
:param n: 要素数
:param func: 値の操作に使う関数(min, max, addなど)
:param init: 要素の初期値
"""
n += 1
self.n = n
self.func = func
self.init = init
# nより大きい2の冪数
n2 = 1
while n2 < n:
n2 <<= 1
self.n2 = n2
self.tree = [self.init] * (n2 << 1)
def update(self, i, x):
"""
i番目の値をxに更新
:param i: index(0-indexed)
:param x: update value
"""
i += self.n2
self.tree[i] = x
while i > 1:
self.tree[i >> 1] = x = self.func(x, self.tree[i ^ 1])
i >>= 1
def get_val(self, a, b):
"""
[a, b)の値を得る
:param a: index(0-indexed)
:param b: index(0-indexed)
"""
return self._get_val(a, b, 1, 0, self.n2)
def _get_val(self, a, b, k, l, r):
"""
[a, b)の値を得る内部関数
:param k: 現在調べている区間のtree内index
:param l, r: kが表す区間の左右端index [l, r)
:return: kが表す区間と[a, b)の共通区間内での最小値。共通区間を持たない場合は初期値
"""
# 範囲外なら初期値
if r <= a or b <= l:
return self.init
# [a,b)が完全に[l,r)を包含するならtree[k]の値を採用
if a <= l and r <= b:
return self.tree[k]
# 一部だけ範囲内なら2つに分けて再帰的に調査
m = (l + r) // 2
return self.func(
self._get_val(a, b, k << 1, l, m),
self._get_val(a, b, (k << 1) + 1, m, r)
)
N=INT()
A=LIST()
st=SegTree(N+2, gcd, 0)
for i in range(N):
st.update(i+1, A[i])
ans=0
for i in range(1, N+1):
ans=max(ans, gcd(st.get_val(0, i), st.get_val(i+1, N+2)))
print(ans)
| # -*- coding: utf-8 -*-
import sys
if sys.version_info.minor >= 5: from math import gcd
else: from fractions import gcd
def input(): return sys.stdin.readline().strip()
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(): return list(map(int, input().split()))
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7
class SegTree:
"""
以下のクエリを処理する
1.update: i番目の値をxに更新する
2.get_val: 区間[l, r)の値を得る
"""
def __init__(self, n, func, init):
"""
:param n: 要素数
:param func: 値の操作に使う関数(min, max, addなど)
:param init: 要素の初期値
"""
n += 1
self.n = n
self.func = func
self.init = init
# nより大きい2の冪数
n2 = 1
while n2 < n:
n2 <<= 1
self.n2 = n2
self.tree = [self.init] * (n2 << 1)
def update(self, i, x):
"""
i番目の値をxに更新
:param i: index(0-indexed)
:param x: update value
"""
i += self.n2
self.tree[i] = x
while i > 1:
self.tree[i >> 1] = x = self.func(x, self.tree[i ^ 1])
i >>= 1
def get_val(self, a, b):
"""
[a, b)の値を得る
:param a: index(0-indexed)
:param b: index(0-indexed)
"""
l = a + self.n2
r = b + self.n2
s = self.init
while l < r:
if r & 1:
r -= 1
s = self.func(s, self.tree[r])
if l & 1:
s = self.func(s, self.tree[l])
l += 1
l >>= 1
r >>= 1
return s
N=INT()
A=LIST()
st=SegTree(N+2, gcd, 0)
for i in range(N):
st.update(i+1, A[i])
ans=0
for i in range(1, N+1):
ans=max(ans, gcd(st.get_val(0, i), st.get_val(i+1, N+2)))
print(ans)
| 95 | 87 | 2,451 | 2,120 | # -*- coding: utf-8 -*-
import sys
if sys.version_info.minor >= 5:
from math import gcd
else:
from fractions import gcd
def input():
return sys.stdin.readline().strip()
def list3d(a, b, c, d):
return [[[d] * c for j in range(b)] for i in range(a)]
def ceil(x, y=1):
return int(-(-x // y))
def INT():
return int(eval(input()))
def MAP():
return list(map(int, input().split()))
def LIST():
return list(map(int, input().split()))
def Yes():
print("Yes")
def No():
print("No")
def YES():
print("YES")
def NO():
print("NO")
sys.setrecursionlimit(10**9)
INF = float("inf")
MOD = 10**9 + 7
class SegTree:
"""
以下のクエリを処理する
1.update: i番目の値をxに更新する
2.get_val: 区間[l, r)の値を得る
"""
def __init__(self, n, func, init):
"""
:param n: 要素数
:param func: 値の操作に使う関数(min, max, addなど)
:param init: 要素の初期値
"""
n += 1
self.n = n
self.func = func
self.init = init
# nより大きい2の冪数
n2 = 1
while n2 < n:
n2 <<= 1
self.n2 = n2
self.tree = [self.init] * (n2 << 1)
def update(self, i, x):
"""
i番目の値をxに更新
:param i: index(0-indexed)
:param x: update value
"""
i += self.n2
self.tree[i] = x
while i > 1:
self.tree[i >> 1] = x = self.func(x, self.tree[i ^ 1])
i >>= 1
def get_val(self, a, b):
"""
[a, b)の値を得る
:param a: index(0-indexed)
:param b: index(0-indexed)
"""
return self._get_val(a, b, 1, 0, self.n2)
def _get_val(self, a, b, k, l, r):
"""
[a, b)の値を得る内部関数
:param k: 現在調べている区間のtree内index
:param l, r: kが表す区間の左右端index [l, r)
:return: kが表す区間と[a, b)の共通区間内での最小値。共通区間を持たない場合は初期値
"""
# 範囲外なら初期値
if r <= a or b <= l:
return self.init
# [a,b)が完全に[l,r)を包含するならtree[k]の値を採用
if a <= l and r <= b:
return self.tree[k]
# 一部だけ範囲内なら2つに分けて再帰的に調査
m = (l + r) // 2
return self.func(
self._get_val(a, b, k << 1, l, m), self._get_val(a, b, (k << 1) + 1, m, r)
)
N = INT()
A = LIST()
st = SegTree(N + 2, gcd, 0)
for i in range(N):
st.update(i + 1, A[i])
ans = 0
for i in range(1, N + 1):
ans = max(ans, gcd(st.get_val(0, i), st.get_val(i + 1, N + 2)))
print(ans)
| # -*- coding: utf-8 -*-
import sys
if sys.version_info.minor >= 5:
from math import gcd
else:
from fractions import gcd
def input():
return sys.stdin.readline().strip()
def list3d(a, b, c, d):
return [[[d] * c for j in range(b)] for i in range(a)]
def ceil(x, y=1):
return int(-(-x // y))
def INT():
return int(eval(input()))
def MAP():
return list(map(int, input().split()))
def LIST():
return list(map(int, input().split()))
def Yes():
print("Yes")
def No():
print("No")
def YES():
print("YES")
def NO():
print("NO")
sys.setrecursionlimit(10**9)
INF = float("inf")
MOD = 10**9 + 7
class SegTree:
"""
以下のクエリを処理する
1.update: i番目の値をxに更新する
2.get_val: 区間[l, r)の値を得る
"""
def __init__(self, n, func, init):
"""
:param n: 要素数
:param func: 値の操作に使う関数(min, max, addなど)
:param init: 要素の初期値
"""
n += 1
self.n = n
self.func = func
self.init = init
# nより大きい2の冪数
n2 = 1
while n2 < n:
n2 <<= 1
self.n2 = n2
self.tree = [self.init] * (n2 << 1)
def update(self, i, x):
"""
i番目の値をxに更新
:param i: index(0-indexed)
:param x: update value
"""
i += self.n2
self.tree[i] = x
while i > 1:
self.tree[i >> 1] = x = self.func(x, self.tree[i ^ 1])
i >>= 1
def get_val(self, a, b):
"""
[a, b)の値を得る
:param a: index(0-indexed)
:param b: index(0-indexed)
"""
l = a + self.n2
r = b + self.n2
s = self.init
while l < r:
if r & 1:
r -= 1
s = self.func(s, self.tree[r])
if l & 1:
s = self.func(s, self.tree[l])
l += 1
l >>= 1
r >>= 1
return s
N = INT()
A = LIST()
st = SegTree(N + 2, gcd, 0)
for i in range(N):
st.update(i + 1, A[i])
ans = 0
for i in range(1, N + 1):
ans = max(ans, gcd(st.get_val(0, i), st.get_val(i + 1, N + 2)))
print(ans)
| false | 8.421053 | [
"- return self._get_val(a, b, 1, 0, self.n2)",
"-",
"- def _get_val(self, a, b, k, l, r):",
"- \"\"\"",
"- [a, b)の値を得る内部関数",
"- :param k: 現在調べている区間のtree内index",
"- :param l, r: kが表す区間の左右端index [l, r)",
"- :return: kが表す区間と[a, b)の共通区間内での最小値。共通区間を持たない場合は初期値",
"- \"\"\"",
"- # 範囲外なら初期値",
"- if r <= a or b <= l:",
"- return self.init",
"- # [a,b)が完全に[l,r)を包含するならtree[k]の値を採用",
"- if a <= l and r <= b:",
"- return self.tree[k]",
"- # 一部だけ範囲内なら2つに分けて再帰的に調査",
"- m = (l + r) // 2",
"- return self.func(",
"- self._get_val(a, b, k << 1, l, m), self._get_val(a, b, (k << 1) + 1, m, r)",
"- )",
"+ l = a + self.n2",
"+ r = b + self.n2",
"+ s = self.init",
"+ while l < r:",
"+ if r & 1:",
"+ r -= 1",
"+ s = self.func(s, self.tree[r])",
"+ if l & 1:",
"+ s = self.func(s, self.tree[l])",
"+ l += 1",
"+ l >>= 1",
"+ r >>= 1",
"+ return s"
] | false | 0.041982 | 0.037177 | 1.129252 | [
"s926722438",
"s044571983"
] |
u571281863 | p02678 | python | s473499423 | s582174421 | 413 | 324 | 56,848 | 56,568 | Accepted | Accepted | 21.55 | from collections import deque
N,M,*AB=map(int,open(0).read().split())
to=[[] for _ in range(N+1)]
for a,b in zip(*[iter(AB)]*2):
to[a].append(b)
to[b].append(a)
q=deque([1])
r=[None]*(N+1)
while q:
x=q.popleft()
for i in to[x]:
if r[i] is None:
q.append(i)
r[i]=x
print("Yes",*r[2:],sep="\n")
| from collections import deque
def main():
N,M,*AB=map(int,open(0).read().split())
to=[[] for _ in range(N+1)]
for a,b in zip(*[iter(AB)]*2):
to[a].append(b)
to[b].append(a)
q=deque([1])
r=[None]*(N+1)
while q:
x=q.popleft()
for i in to[x]:
if r[i] is None:
q.append(i)
r[i]=x
print("Yes",*r[2:],sep="\n")
if __name__=='__main__':
main()
| 15 | 18 | 330 | 381 | from collections import deque
N, M, *AB = map(int, open(0).read().split())
to = [[] for _ in range(N + 1)]
for a, b in zip(*[iter(AB)] * 2):
to[a].append(b)
to[b].append(a)
q = deque([1])
r = [None] * (N + 1)
while q:
x = q.popleft()
for i in to[x]:
if r[i] is None:
q.append(i)
r[i] = x
print("Yes", *r[2:], sep="\n")
| from collections import deque
def main():
N, M, *AB = map(int, open(0).read().split())
to = [[] for _ in range(N + 1)]
for a, b in zip(*[iter(AB)] * 2):
to[a].append(b)
to[b].append(a)
q = deque([1])
r = [None] * (N + 1)
while q:
x = q.popleft()
for i in to[x]:
if r[i] is None:
q.append(i)
r[i] = x
print("Yes", *r[2:], sep="\n")
if __name__ == "__main__":
main()
| false | 16.666667 | [
"-N, M, *AB = map(int, open(0).read().split())",
"-to = [[] for _ in range(N + 1)]",
"-for a, b in zip(*[iter(AB)] * 2):",
"- to[a].append(b)",
"- to[b].append(a)",
"-q = deque([1])",
"-r = [None] * (N + 1)",
"-while q:",
"- x = q.popleft()",
"- for i in to[x]:",
"- if r[i] is None:",
"- q.append(i)",
"- r[i] = x",
"-print(\"Yes\", *r[2:], sep=\"\\n\")",
"+",
"+def main():",
"+ N, M, *AB = map(int, open(0).read().split())",
"+ to = [[] for _ in range(N + 1)]",
"+ for a, b in zip(*[iter(AB)] * 2):",
"+ to[a].append(b)",
"+ to[b].append(a)",
"+ q = deque([1])",
"+ r = [None] * (N + 1)",
"+ while q:",
"+ x = q.popleft()",
"+ for i in to[x]:",
"+ if r[i] is None:",
"+ q.append(i)",
"+ r[i] = x",
"+ print(\"Yes\", *r[2:], sep=\"\\n\")",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ main()"
] | false | 0.039152 | 0.042186 | 0.928062 | [
"s473499423",
"s582174421"
] |
u386819480 | p03031 | python | s858782961 | s423964508 | 34 | 31 | 3,316 | 3,064 | Accepted | Accepted | 8.82 | #!/usr/bin/env python3
MOD = 2 # type: int
# Generated by 1.1.4 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)
def main():
# Failed to predict input format
N,M = list(map(int,input().split()))
from collections import defaultdict
d = defaultdict()
for i in range(M):
l = list(map(int,input().split()))
d[i] = l[1:]
# for k,v in d.items():
# print(k,v)
p = list(map(int,input().split()))
ans = 0
import itertools
s = ('on', 'off')
for i in itertools.product(s, repeat=N):
anst = 0
for k,v in list(d.items()):
if(len([x for x in v if(i[x-1] == 'on')])%2 == p[k]):
anst += 1
if(anst == M):
ans += 1
print(ans)
if __name__ == '__main__':
main()
| #!/usr/bin/env python3
MOD = 2 # type: int
def main():
N, M = list(map(int, input().split()))
k = []
s = []
for i in range(M):
l = input().split()
k.append(l[0])
s.append(list(map(int, l[1:])))
p = list(map(int, input().split()))
ans = 0
for i in range(1<<N):
t = [0] * M
for j in range(N):
if i>>j & 1:
for r in range(M):
# print(j+1, s[r])
if j+1 in s[r]:
t[r] += 1
f = True
for j in range(M):
if t[j]%2 != p[j]:
f = False
if f:
ans += 1
print(ans)
if __name__ == '__main__':
main()
| 38 | 40 | 919 | 782 | #!/usr/bin/env python3
MOD = 2 # type: int
# Generated by 1.1.4 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)
def main():
# Failed to predict input format
N, M = list(map(int, input().split()))
from collections import defaultdict
d = defaultdict()
for i in range(M):
l = list(map(int, input().split()))
d[i] = l[1:]
# for k,v in d.items():
# print(k,v)
p = list(map(int, input().split()))
ans = 0
import itertools
s = ("on", "off")
for i in itertools.product(s, repeat=N):
anst = 0
for k, v in list(d.items()):
if len([x for x in v if (i[x - 1] == "on")]) % 2 == p[k]:
anst += 1
if anst == M:
ans += 1
print(ans)
if __name__ == "__main__":
main()
| #!/usr/bin/env python3
MOD = 2 # type: int
def main():
N, M = list(map(int, input().split()))
k = []
s = []
for i in range(M):
l = input().split()
k.append(l[0])
s.append(list(map(int, l[1:])))
p = list(map(int, input().split()))
ans = 0
for i in range(1 << N):
t = [0] * M
for j in range(N):
if i >> j & 1:
for r in range(M):
# print(j+1, s[r])
if j + 1 in s[r]:
t[r] += 1
f = True
for j in range(M):
if t[j] % 2 != p[j]:
f = False
if f:
ans += 1
print(ans)
if __name__ == "__main__":
main()
| false | 5 | [
"-# Generated by 1.1.4 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)",
"+",
"+",
"- # Failed to predict input format",
"- from collections import defaultdict",
"-",
"- d = defaultdict()",
"+ k = []",
"+ s = []",
"- l = list(map(int, input().split()))",
"- d[i] = l[1:]",
"- # for k,v in d.items():",
"- # print(k,v)",
"+ l = input().split()",
"+ k.append(l[0])",
"+ s.append(list(map(int, l[1:])))",
"- import itertools",
"-",
"- s = (\"on\", \"off\")",
"- for i in itertools.product(s, repeat=N):",
"- anst = 0",
"- for k, v in list(d.items()):",
"- if len([x for x in v if (i[x - 1] == \"on\")]) % 2 == p[k]:",
"- anst += 1",
"- if anst == M:",
"+ for i in range(1 << N):",
"+ t = [0] * M",
"+ for j in range(N):",
"+ if i >> j & 1:",
"+ for r in range(M):",
"+ # print(j+1, s[r])",
"+ if j + 1 in s[r]:",
"+ t[r] += 1",
"+ f = True",
"+ for j in range(M):",
"+ if t[j] % 2 != p[j]:",
"+ f = False",
"+ if f:"
] | false | 0.056481 | 0.039017 | 1.447594 | [
"s858782961",
"s423964508"
] |
u600065151 | p02268 | python | s366216704 | s102498041 | 40 | 30 | 20,588 | 20,588 | Accepted | Accepted | 25 | def binarySearch():
n = int(eval(input()))
S = set(input().split())
q = int(eval(input()))
T = set(input().split())
print((len(S.intersection(T))))
binarySearch() | def binarySearch():
n = int(eval(input()))
S = set(input().split())
q = int(eval(input()))
T = set(input().split())
print((len(S & T)))
binarySearch() | 9 | 9 | 182 | 170 | def binarySearch():
n = int(eval(input()))
S = set(input().split())
q = int(eval(input()))
T = set(input().split())
print((len(S.intersection(T))))
binarySearch()
| def binarySearch():
n = int(eval(input()))
S = set(input().split())
q = int(eval(input()))
T = set(input().split())
print((len(S & T)))
binarySearch()
| false | 0 | [
"- print((len(S.intersection(T))))",
"+ print((len(S & T)))"
] | false | 0.042638 | 0.045653 | 0.933967 | [
"s366216704",
"s102498041"
] |
u011062360 | p02900 | python | s742436518 | s483327420 | 286 | 150 | 5,276 | 9,132 | Accepted | Accepted | 47.55 | import itertools
a, b = list(map(int, input().split()))
#約数
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
# divisors.sort()
return divisors
import math
def is_prime(n):
if n == 1: return False
for k in range(2, int(math.sqrt(n)) + 1):
if n % k == 0:
return False
return True
c = make_divisors(a)
d = make_divisors(b)
f = list(set(c) & set(d))
ans = []
for s in f:
if is_prime(s):
ans.append(s)
print((len(ans)+1)) | def prime_factorize(n):
a = []
while n % 2 == 0:
a.append(2)
n //= 2
f = 3
while f * f <= n:
if n % f == 0:
a.append(f)
n //= f
else:
f += 2
if n != 1:
a.append(n)
return a
a, b = list(map(int, input().split()))
list_A = set(prime_factorize(a))
list_B = set(prime_factorize(b))
ans = list_A & list_B
print((len(ans) + 1))
| 34 | 21 | 649 | 435 | import itertools
a, b = list(map(int, input().split()))
# 約数
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5) + 1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n // i)
# divisors.sort()
return divisors
import math
def is_prime(n):
if n == 1:
return False
for k in range(2, int(math.sqrt(n)) + 1):
if n % k == 0:
return False
return True
c = make_divisors(a)
d = make_divisors(b)
f = list(set(c) & set(d))
ans = []
for s in f:
if is_prime(s):
ans.append(s)
print((len(ans) + 1))
| def prime_factorize(n):
a = []
while n % 2 == 0:
a.append(2)
n //= 2
f = 3
while f * f <= n:
if n % f == 0:
a.append(f)
n //= f
else:
f += 2
if n != 1:
a.append(n)
return a
a, b = list(map(int, input().split()))
list_A = set(prime_factorize(a))
list_B = set(prime_factorize(b))
ans = list_A & list_B
print((len(ans) + 1))
| false | 38.235294 | [
"-import itertools",
"+def prime_factorize(n):",
"+ a = []",
"+ while n % 2 == 0:",
"+ a.append(2)",
"+ n //= 2",
"+ f = 3",
"+ while f * f <= n:",
"+ if n % f == 0:",
"+ a.append(f)",
"+ n //= f",
"+ else:",
"+ f += 2",
"+ if n != 1:",
"+ a.append(n)",
"+ return a",
"+",
"-# 約数",
"-def make_divisors(n):",
"- divisors = []",
"- for i in range(1, int(n**0.5) + 1):",
"- if n % i == 0:",
"- divisors.append(i)",
"- if i != n // i:",
"- divisors.append(n // i)",
"- # divisors.sort()",
"- return divisors",
"-",
"-",
"-import math",
"-",
"-",
"-def is_prime(n):",
"- if n == 1:",
"- return False",
"- for k in range(2, int(math.sqrt(n)) + 1):",
"- if n % k == 0:",
"- return False",
"- return True",
"-",
"-",
"-c = make_divisors(a)",
"-d = make_divisors(b)",
"-f = list(set(c) & set(d))",
"-ans = []",
"-for s in f:",
"- if is_prime(s):",
"- ans.append(s)",
"+list_A = set(prime_factorize(a))",
"+list_B = set(prime_factorize(b))",
"+ans = list_A & list_B"
] | false | 0.037797 | 0.038432 | 0.983488 | [
"s742436518",
"s483327420"
] |
u947883560 | p02975 | python | s233578189 | s080427206 | 578 | 68 | 15,580 | 17,392 | Accepted | Accepted | 88.24 | #!/usr/bin/env python3
import sys
from bisect import bisect_left
from collections import Counter
INF = float("inf")
KETA_MAX = 10
def yes():
print("Yes") # type: str
def no():
print("No") # type: str
def solve(N: int, a: "List[int]"):
keta = [Counter() for _ in range(KETA_MAX)]
for i in range(N):
x = a[i]
for j in range(KETA_MAX):
keta[j][x & 1] += 1
x >>= 1
for cnt in keta:
if cnt[1] == 0:
continue
elif cnt[1] == cnt[0]*2:
continue
else:
no()
return
yes()
return
# print(*keta, sep="\n")
# def solve(N: int, a: "List[int]"):
# a.sort()
# used = Counter(a)
# used_orig = used.copy()
# x = [a[0]]
# used[0] -= 1
# # print("first, ", a[0])
# # 2番目の帽子を全探索
# for i in range(1, N):
# # print("2nd, ", a[i])
# x.append(a[i])
# used[i] -= 1
# for j in range(2, N):
# cand = x[-1] ^ x[-2]
# # print("cand, ", cand)
# pl = bisect_left(a, cand)
# if pl >= len(a):
# break
# if cand == a[pl] and used[cand] > 0:
# x.append(cand)
# used[pl] -= 1
# else:
# break
# else:
# yes()
# print(x)
# print(used)
# return
# x = [a[0]]
# used = used_orig.copy()
# no()
# return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
a = [int(next(tokens)) for _ in range(N)] # type: "List[int]"
solve(N, a)
if __name__ == '__main__':
main()
| #!/usr/bin/env python3
import sys
from bisect import bisect_left
from collections import Counter
INF = float("inf")
def yes():
print("Yes") # type: str
def no():
print("No") # type: str
def solve(N: int, a: "List[int]"):
cnt = Counter(a)
v = list(cnt.values())
b = list(cnt.keys())
if len(cnt) == 3:
if all([x == v[0] for x in v]):
if b[0] ^ b[1] == b[2] or b[0] ^ b[2] == b[1]:
yes()
return
elif len(cnt) == 2:
if b[0] != 0:
b[1], b[0] = b[0], b[1]
if b[0] == 0 and cnt[b[1]] == cnt[b[0]]*2:
yes()
return
elif len(cnt) == 1:
if b[0] == 0:
yes()
return
no()
return
# print(*keta, sep="\n")
# def solve(N: int, a: "List[int]"):
# a.sort()
# used = Counter(a)
# used_orig = used.copy()
# x = [a[0]]
# used[0] -= 1
# # print("first, ", a[0])
# # 2番目の帽子を全探索
# for i in range(1, N):
# # print("2nd, ", a[i])
# x.append(a[i])
# used[i] -= 1
# for j in range(2, N):
# cand = x[-1] ^ x[-2]
# # print("cand, ", cand)
# pl = bisect_left(a, cand)
# if pl >= len(a):
# break
# if cand == a[pl] and used[cand] > 0:
# x.append(cand)
# used[pl] -= 1
# else:
# break
# else:
# yes()
# print(x)
# print(used)
# return
# x = [a[0]]
# used = used_orig.copy()
# no()
# return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
a = [int(next(tokens)) for _ in range(N)] # type: "List[int]"
solve(N, a)
if __name__ == '__main__':
main()
| 86 | 89 | 2,037 | 2,173 | #!/usr/bin/env python3
import sys
from bisect import bisect_left
from collections import Counter
INF = float("inf")
KETA_MAX = 10
def yes():
print("Yes") # type: str
def no():
print("No") # type: str
def solve(N: int, a: "List[int]"):
keta = [Counter() for _ in range(KETA_MAX)]
for i in range(N):
x = a[i]
for j in range(KETA_MAX):
keta[j][x & 1] += 1
x >>= 1
for cnt in keta:
if cnt[1] == 0:
continue
elif cnt[1] == cnt[0] * 2:
continue
else:
no()
return
yes()
return
# print(*keta, sep="\n")
# def solve(N: int, a: "List[int]"):
# a.sort()
# used = Counter(a)
# used_orig = used.copy()
# x = [a[0]]
# used[0] -= 1
# # print("first, ", a[0])
# # 2番目の帽子を全探索
# for i in range(1, N):
# # print("2nd, ", a[i])
# x.append(a[i])
# used[i] -= 1
# for j in range(2, N):
# cand = x[-1] ^ x[-2]
# # print("cand, ", cand)
# pl = bisect_left(a, cand)
# if pl >= len(a):
# break
# if cand == a[pl] and used[cand] > 0:
# x.append(cand)
# used[pl] -= 1
# else:
# break
# else:
# yes()
# print(x)
# print(used)
# return
# x = [a[0]]
# used = used_orig.copy()
# no()
# return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
a = [int(next(tokens)) for _ in range(N)] # type: "List[int]"
solve(N, a)
if __name__ == "__main__":
main()
| #!/usr/bin/env python3
import sys
from bisect import bisect_left
from collections import Counter
INF = float("inf")
def yes():
print("Yes") # type: str
def no():
print("No") # type: str
def solve(N: int, a: "List[int]"):
cnt = Counter(a)
v = list(cnt.values())
b = list(cnt.keys())
if len(cnt) == 3:
if all([x == v[0] for x in v]):
if b[0] ^ b[1] == b[2] or b[0] ^ b[2] == b[1]:
yes()
return
elif len(cnt) == 2:
if b[0] != 0:
b[1], b[0] = b[0], b[1]
if b[0] == 0 and cnt[b[1]] == cnt[b[0]] * 2:
yes()
return
elif len(cnt) == 1:
if b[0] == 0:
yes()
return
no()
return
# print(*keta, sep="\n")
# def solve(N: int, a: "List[int]"):
# a.sort()
# used = Counter(a)
# used_orig = used.copy()
# x = [a[0]]
# used[0] -= 1
# # print("first, ", a[0])
# # 2番目の帽子を全探索
# for i in range(1, N):
# # print("2nd, ", a[i])
# x.append(a[i])
# used[i] -= 1
# for j in range(2, N):
# cand = x[-1] ^ x[-2]
# # print("cand, ", cand)
# pl = bisect_left(a, cand)
# if pl >= len(a):
# break
# if cand == a[pl] and used[cand] > 0:
# x.append(cand)
# used[pl] -= 1
# else:
# break
# else:
# yes()
# print(x)
# print(used)
# return
# x = [a[0]]
# used = used_orig.copy()
# no()
# return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
a = [int(next(tokens)) for _ in range(N)] # type: "List[int]"
solve(N, a)
if __name__ == "__main__":
main()
| false | 3.370787 | [
"-KETA_MAX = 10",
"- keta = [Counter() for _ in range(KETA_MAX)]",
"- for i in range(N):",
"- x = a[i]",
"- for j in range(KETA_MAX):",
"- keta[j][x & 1] += 1",
"- x >>= 1",
"- for cnt in keta:",
"- if cnt[1] == 0:",
"- continue",
"- elif cnt[1] == cnt[0] * 2:",
"- continue",
"- else:",
"- no()",
"+ cnt = Counter(a)",
"+ v = list(cnt.values())",
"+ b = list(cnt.keys())",
"+ if len(cnt) == 3:",
"+ if all([x == v[0] for x in v]):",
"+ if b[0] ^ b[1] == b[2] or b[0] ^ b[2] == b[1]:",
"+ yes()",
"+ return",
"+ elif len(cnt) == 2:",
"+ if b[0] != 0:",
"+ b[1], b[0] = b[0], b[1]",
"+ if b[0] == 0 and cnt[b[1]] == cnt[b[0]] * 2:",
"+ yes()",
"- yes()",
"+ elif len(cnt) == 1:",
"+ if b[0] == 0:",
"+ yes()",
"+ return",
"+ no()"
] | false | 0.092581 | 0.04279 | 2.163635 | [
"s233578189",
"s080427206"
] |
u519968172 | p03592 | python | s234104453 | s269734162 | 86 | 29 | 65,896 | 9,060 | Accepted | Accepted | 66.28 | n,m,k=list(map(int,input().split()))
ans="No"
for i in range(n//2+1):
for j in range(m):
o=i*j+(m-j)*(n-i)
x=n*m-o
if o==k or x==k:
ans="Yes"
print(ans) | n,m,k=list(map(int,input().split()))
ans="No"
for i in range(n+1):
if (2*i-n)==0:
if k==m*n//2:
ans="Yes"
else:
if (k-n*m+m*i)%(2*i-n)==0 and 0<=(k-n*m+m*i)//(2*i-n)<=m:
ans="Yes"
print(ans) | 9 | 10 | 174 | 217 | n, m, k = list(map(int, input().split()))
ans = "No"
for i in range(n // 2 + 1):
for j in range(m):
o = i * j + (m - j) * (n - i)
x = n * m - o
if o == k or x == k:
ans = "Yes"
print(ans)
| n, m, k = list(map(int, input().split()))
ans = "No"
for i in range(n + 1):
if (2 * i - n) == 0:
if k == m * n // 2:
ans = "Yes"
else:
if (k - n * m + m * i) % (2 * i - n) == 0 and 0 <= (k - n * m + m * i) // (
2 * i - n
) <= m:
ans = "Yes"
print(ans)
| false | 10 | [
"-for i in range(n // 2 + 1):",
"- for j in range(m):",
"- o = i * j + (m - j) * (n - i)",
"- x = n * m - o",
"- if o == k or x == k:",
"+for i in range(n + 1):",
"+ if (2 * i - n) == 0:",
"+ if k == m * n // 2:",
"+ ans = \"Yes\"",
"+ else:",
"+ if (k - n * m + m * i) % (2 * i - n) == 0 and 0 <= (k - n * m + m * i) // (",
"+ 2 * i - n",
"+ ) <= m:"
] | false | 0.035465 | 0.069061 | 0.513529 | [
"s234104453",
"s269734162"
] |
u023127434 | p03493 | python | s728300616 | s816154823 | 28 | 24 | 9,016 | 8,916 | Accepted | Accepted | 14.29 | n = eval(input())
print((n.count("1"))) | s = eval(input())
print((s.count("1"))) | 2 | 2 | 32 | 32 | n = eval(input())
print((n.count("1")))
| s = eval(input())
print((s.count("1")))
| false | 0 | [
"-n = eval(input())",
"-print((n.count(\"1\")))",
"+s = eval(input())",
"+print((s.count(\"1\")))"
] | false | 0.047984 | 0.048202 | 0.995486 | [
"s728300616",
"s816154823"
] |
u347640436 | p03599 | python | s998254048 | s535390246 | 531 | 150 | 3,064 | 3,188 | Accepted | Accepted | 71.75 | A, B, C, D, E, F = list(map(int, input().split()))
w = set()
for i in range(F // (100 * A) + 1):
for j in range(F // (100 * B) + 1):
a = (A * i + B * j) * 100
if a < F:
w.add(a)
w.remove(0)
best_concentration = -1
best_a = -1
best_b = -1
for a in w:
for i in range((F - a) // C + 1):
for j in range((F - a) // D + 1):
b = C * i + D * j
if a + b > F:
continue
if b > E * a // 100:
continue
concentration = 100 * b / (a + b)
if concentration > best_concentration:
best_concentration = concentration
best_a = a
best_b = b
print((best_a + best_b, best_b))
| A, B, C, D, E, F = list(map(int, input().split()))
w = set()
for i in range(F // (100 * A) + 1):
for j in range(F // (100 * B) + 1):
a = (A * i + B * j) * 100
if a < F:
w.add(a)
w.remove(0)
s = set()
for i in range(F // C + 1):
for j in range(F // D + 1):
b = C * i + D * j
if b < F:
s.add(b)
s = list(s)
s.sort()
best_concentration = -1
best_a = -1
best_b = -1
for a in w:
for b in s:
if a + b > F:
continue
if b > E * a // 100:
continue
concentration = 100 * b / (a + b)
if concentration > best_concentration:
best_concentration = concentration
best_a = a
best_b = b
print((best_a + best_b, best_b))
| 27 | 34 | 756 | 790 | A, B, C, D, E, F = list(map(int, input().split()))
w = set()
for i in range(F // (100 * A) + 1):
for j in range(F // (100 * B) + 1):
a = (A * i + B * j) * 100
if a < F:
w.add(a)
w.remove(0)
best_concentration = -1
best_a = -1
best_b = -1
for a in w:
for i in range((F - a) // C + 1):
for j in range((F - a) // D + 1):
b = C * i + D * j
if a + b > F:
continue
if b > E * a // 100:
continue
concentration = 100 * b / (a + b)
if concentration > best_concentration:
best_concentration = concentration
best_a = a
best_b = b
print((best_a + best_b, best_b))
| A, B, C, D, E, F = list(map(int, input().split()))
w = set()
for i in range(F // (100 * A) + 1):
for j in range(F // (100 * B) + 1):
a = (A * i + B * j) * 100
if a < F:
w.add(a)
w.remove(0)
s = set()
for i in range(F // C + 1):
for j in range(F // D + 1):
b = C * i + D * j
if b < F:
s.add(b)
s = list(s)
s.sort()
best_concentration = -1
best_a = -1
best_b = -1
for a in w:
for b in s:
if a + b > F:
continue
if b > E * a // 100:
continue
concentration = 100 * b / (a + b)
if concentration > best_concentration:
best_concentration = concentration
best_a = a
best_b = b
print((best_a + best_b, best_b))
| false | 20.588235 | [
"+s = set()",
"+for i in range(F // C + 1):",
"+ for j in range(F // D + 1):",
"+ b = C * i + D * j",
"+ if b < F:",
"+ s.add(b)",
"+s = list(s)",
"+s.sort()",
"- for i in range((F - a) // C + 1):",
"- for j in range((F - a) // D + 1):",
"- b = C * i + D * j",
"- if a + b > F:",
"- continue",
"- if b > E * a // 100:",
"- continue",
"- concentration = 100 * b / (a + b)",
"- if concentration > best_concentration:",
"- best_concentration = concentration",
"- best_a = a",
"- best_b = b",
"+ for b in s:",
"+ if a + b > F:",
"+ continue",
"+ if b > E * a // 100:",
"+ continue",
"+ concentration = 100 * b / (a + b)",
"+ if concentration > best_concentration:",
"+ best_concentration = concentration",
"+ best_a = a",
"+ best_b = b"
] | false | 0.00731 | 0.078451 | 0.093179 | [
"s998254048",
"s535390246"
] |
u561992253 | p02838 | python | s626989394 | s620151092 | 532 | 462 | 122,936 | 122,808 | Accepted | Accepted | 13.16 | words = lambda t : list(map(t, input().split()))
n = int(eval(input()))
xs = words(int)
ys = [0]*60
for x in xs:
for i in range(60):
if x == 0:
continue
ys[i] += x & 1
x = x >> 1
ans = 0
for i,yi in enumerate(ys):
ans += 2**(i) * yi * (n-yi)
ans %= 10**9 + 7
print(ans)
| from functools import reduce
words = lambda t : list(map(t, input().split()))
n = int(eval(input()))
xs = words(int)
def func(y, x):
for i in range(60):
if x == 0:
continue
y[i] += x & 1
x = x >> 1
return y
ys = reduce(func, xs, [0]*60)
ans = 0
for i,yi in enumerate(ys):
ans += 2**(i) * yi * (n-yi)
ans %= 10**9 + 7
print(ans)
| 18 | 21 | 332 | 398 | words = lambda t: list(map(t, input().split()))
n = int(eval(input()))
xs = words(int)
ys = [0] * 60
for x in xs:
for i in range(60):
if x == 0:
continue
ys[i] += x & 1
x = x >> 1
ans = 0
for i, yi in enumerate(ys):
ans += 2 ** (i) * yi * (n - yi)
ans %= 10**9 + 7
print(ans)
| from functools import reduce
words = lambda t: list(map(t, input().split()))
n = int(eval(input()))
xs = words(int)
def func(y, x):
for i in range(60):
if x == 0:
continue
y[i] += x & 1
x = x >> 1
return y
ys = reduce(func, xs, [0] * 60)
ans = 0
for i, yi in enumerate(ys):
ans += 2 ** (i) * yi * (n - yi)
ans %= 10**9 + 7
print(ans)
| false | 14.285714 | [
"+from functools import reduce",
"+",
"-ys = [0] * 60",
"-for x in xs:",
"+",
"+",
"+def func(y, x):",
"- ys[i] += x & 1",
"+ y[i] += x & 1",
"+ return y",
"+",
"+",
"+ys = reduce(func, xs, [0] * 60)"
] | false | 0.039871 | 0.035891 | 1.110874 | [
"s626989394",
"s620151092"
] |
u585482323 | p03476 | python | s526883595 | s519054115 | 442 | 398 | 52,912 | 53,792 | Accepted | Accepted | 9.95 | #!usr/bin/env python3
from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS():return list(map(list, sys.stdin.readline().split()))
def S(): return list(sys.stdin.readline())[:-1]
def IR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = I()
return l
def LIR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = LI()
return l
def SR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = S()
return l
def LSR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = SR()
return l
mod = 1000000007
#A
def A():
return
#B
def B():
return
#C
def C():
return
#D
if __name__ == "__main__":
def check(n):
if n == 1:
return False
i = 2
while i*i <= n:
if n%i == 0:
return False
i += 1
return True
f = [0 for i in range(100001)]
for i in range(1,100001):
f[i] += f[i-1]
if check(i):
if check((i+1)//2):
f[i] += 1
q = I()
for i in range(q):
l,r = LI()
print((f[r]-f[l-1]))
#E
def E():
return
#F
def F():
return
#G
def G():
return
#H
def H():
return
#Solve
| #!usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
from itertools import permutations
import sys
import math
import bisect
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == "\n":
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
n = 10**5+1
p = 2
f = [1]*(n+1)
f[0] = 0
f[1] = 0
while p <= n:
while p <= n and not f[p]:
p += 1
j = 2*p
while j <= n:
f[j] = 0
j += p
p += 1
s = [1 if f[i] and f[(i+1)>>1] and i&1 else 0 for i in range(n+1)]
for i in range(n):
s[i+1] += s[i]
q = I()
for _ in range(q):
l,r = LI()
print((s[r]-s[l-1]))
return
#Solve
if __name__ == "__main__":
solve()
| 81 | 53 | 1,498 | 1,245 | #!usr/bin/env python3
from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI():
return list(map(int, sys.stdin.readline().split()))
def I():
return int(sys.stdin.readline())
def LS():
return list(map(list, sys.stdin.readline().split()))
def S():
return list(sys.stdin.readline())[:-1]
def IR(n):
l = [None for i in range(n)]
for i in range(n):
l[i] = I()
return l
def LIR(n):
l = [None for i in range(n)]
for i in range(n):
l[i] = LI()
return l
def SR(n):
l = [None for i in range(n)]
for i in range(n):
l[i] = S()
return l
def LSR(n):
l = [None for i in range(n)]
for i in range(n):
l[i] = SR()
return l
mod = 1000000007
# A
def A():
return
# B
def B():
return
# C
def C():
return
# D
if __name__ == "__main__":
def check(n):
if n == 1:
return False
i = 2
while i * i <= n:
if n % i == 0:
return False
i += 1
return True
f = [0 for i in range(100001)]
for i in range(1, 100001):
f[i] += f[i - 1]
if check(i):
if check((i + 1) // 2):
f[i] += 1
q = I()
for i in range(q):
l, r = LI()
print((f[r] - f[l - 1]))
# E
def E():
return
# F
def F():
return
# G
def G():
return
# H
def H():
return
# Solve
| #!usr/bin/env python3
from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations
import sys
import math
import bisect
def LI():
return [int(x) for x in sys.stdin.readline().split()]
def I():
return int(sys.stdin.readline())
def LS():
return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == "\n":
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
n = 10**5 + 1
p = 2
f = [1] * (n + 1)
f[0] = 0
f[1] = 0
while p <= n:
while p <= n and not f[p]:
p += 1
j = 2 * p
while j <= n:
f[j] = 0
j += p
p += 1
s = [1 if f[i] and f[(i + 1) >> 1] and i & 1 else 0 for i in range(n + 1)]
for i in range(n):
s[i + 1] += s[i]
q = I()
for _ in range(q):
l, r = LI()
print((s[r] - s[l - 1]))
return
# Solve
if __name__ == "__main__":
solve()
| false | 34.567901 | [
"-from collections import defaultdict",
"-from collections import deque",
"+from collections import defaultdict, deque",
"+from itertools import permutations",
"-import random",
"- return list(map(int, sys.stdin.readline().split()))",
"+ return [int(x) for x in sys.stdin.readline().split()]",
"- return list(map(list, sys.stdin.readline().split()))",
"+ return [list(x) for x in sys.stdin.readline().split()]",
"- return list(sys.stdin.readline())[:-1]",
"+ res = list(sys.stdin.readline())",
"+ if res[-1] == \"\\n\":",
"+ return res[:-1]",
"+ return res",
"- l = [None for i in range(n)]",
"- for i in range(n):",
"- l[i] = I()",
"- return l",
"+ return [I() for i in range(n)]",
"- l = [None for i in range(n)]",
"- for i in range(n):",
"- l[i] = LI()",
"- return l",
"+ return [LI() for i in range(n)]",
"- l = [None for i in range(n)]",
"- for i in range(n):",
"- l[i] = S()",
"- return l",
"+ return [S() for i in range(n)]",
"- l = [None for i in range(n)]",
"- for i in range(n):",
"- l[i] = SR()",
"- return l",
"+ return [LS() for i in range(n)]",
"+sys.setrecursionlimit(1000000)",
"-# A",
"-def A():",
"- return",
"-# B",
"-def B():",
"- return",
"-",
"-",
"-# C",
"-def C():",
"- return",
"-",
"-",
"-# D",
"-if __name__ == \"__main__\":",
"-",
"- def check(n):",
"- if n == 1:",
"- return False",
"- i = 2",
"- while i * i <= n:",
"- if n % i == 0:",
"- return False",
"- i += 1",
"- return True",
"-",
"- f = [0 for i in range(100001)]",
"- for i in range(1, 100001):",
"- f[i] += f[i - 1]",
"- if check(i):",
"- if check((i + 1) // 2):",
"- f[i] += 1",
"+def solve():",
"+ n = 10**5 + 1",
"+ p = 2",
"+ f = [1] * (n + 1)",
"+ f[0] = 0",
"+ f[1] = 0",
"+ while p <= n:",
"+ while p <= n and not f[p]:",
"+ p += 1",
"+ j = 2 * p",
"+ while j <= n:",
"+ f[j] = 0",
"+ j += p",
"+ p += 1",
"+ s = [1 if f[i] and f[(i + 1) >> 1] and i & 1 else 0 for i in range(n + 1)]",
"+ for i in range(n):",
"+ s[i + 1] += s[i]",
"- for i in range(q):",
"+ for _ in range(q):",
"- print((f[r] - f[l - 1]))",
"-# E",
"-def E():",
"- return",
"-",
"-",
"-# F",
"-def F():",
"- return",
"-",
"-",
"-# G",
"-def G():",
"- return",
"-",
"-",
"-# H",
"-def H():",
"+ print((s[r] - s[l - 1]))",
"+if __name__ == \"__main__\":",
"+ solve()"
] | false | 0.999865 | 0.172835 | 5.785098 | [
"s526883595",
"s519054115"
] |
u074220993 | p03608 | python | s640495665 | s745262356 | 1,990 | 411 | 9,924 | 46,252 | Accepted | Accepted | 79.35 | N, M, K = (int(x) for x in input().split())
R = [int(x)-1 for x in input().split()]
dist = [[10e8 for _ in range(N)] for _ in range(N)]
for i in range(N): dist[i][i] = 0
for _ in range(M):
a, b, c = (int(x) for x in input().split())
dist[a-1][b-1] = dist[b-1][a-1] = c
del a, b, c, K
for k in range(N):
for i in range(N):
for j in range(i,N):
dist[i][j] = dist[j][i] = min(dist[i][j], dist[i][k]+dist[k][j])
def mindist(x, X):
global dist
Y = X.copy()
Y.remove(x)
if len(Y) == 0: return 0
return min([dist[x][y] + mindist(y,Y) for y in Y])
ans = min([mindist(r, R) for r in R])
print(ans) | from itertools import permutations
import numpy as np
from scipy.sparse.csgraph import dijkstra
with open(0) as f:
N, M, R = list(map(int, f.readline().split()))
r = list(map(int, f.readline().split()))
path = [tuple(map(int, line.split())) for line in f.readlines()]
graph = np.full((N,N), np.inf)
for a, b, c in path:
graph[a-1, b-1] = c
graph[b-1, a-1] = c
graph = dijkstra(graph, directed=False)
ans = np.inf
permutation = list(permutations(r))
for p in permutation:
way = 0
for x,y in zip(p[:len(r)], p[1:]):
way += graph[x-1, y-1]
ans = min(ans, way)
print((int(ans))) | 24 | 23 | 668 | 631 | N, M, K = (int(x) for x in input().split())
R = [int(x) - 1 for x in input().split()]
dist = [[10e8 for _ in range(N)] for _ in range(N)]
for i in range(N):
dist[i][i] = 0
for _ in range(M):
a, b, c = (int(x) for x in input().split())
dist[a - 1][b - 1] = dist[b - 1][a - 1] = c
del a, b, c, K
for k in range(N):
for i in range(N):
for j in range(i, N):
dist[i][j] = dist[j][i] = min(dist[i][j], dist[i][k] + dist[k][j])
def mindist(x, X):
global dist
Y = X.copy()
Y.remove(x)
if len(Y) == 0:
return 0
return min([dist[x][y] + mindist(y, Y) for y in Y])
ans = min([mindist(r, R) for r in R])
print(ans)
| from itertools import permutations
import numpy as np
from scipy.sparse.csgraph import dijkstra
with open(0) as f:
N, M, R = list(map(int, f.readline().split()))
r = list(map(int, f.readline().split()))
path = [tuple(map(int, line.split())) for line in f.readlines()]
graph = np.full((N, N), np.inf)
for a, b, c in path:
graph[a - 1, b - 1] = c
graph[b - 1, a - 1] = c
graph = dijkstra(graph, directed=False)
ans = np.inf
permutation = list(permutations(r))
for p in permutation:
way = 0
for x, y in zip(p[: len(r)], p[1:]):
way += graph[x - 1, y - 1]
ans = min(ans, way)
print((int(ans)))
| false | 4.166667 | [
"-N, M, K = (int(x) for x in input().split())",
"-R = [int(x) - 1 for x in input().split()]",
"-dist = [[10e8 for _ in range(N)] for _ in range(N)]",
"-for i in range(N):",
"- dist[i][i] = 0",
"-for _ in range(M):",
"- a, b, c = (int(x) for x in input().split())",
"- dist[a - 1][b - 1] = dist[b - 1][a - 1] = c",
"-del a, b, c, K",
"-for k in range(N):",
"- for i in range(N):",
"- for j in range(i, N):",
"- dist[i][j] = dist[j][i] = min(dist[i][j], dist[i][k] + dist[k][j])",
"+from itertools import permutations",
"+import numpy as np",
"+from scipy.sparse.csgraph import dijkstra",
"-",
"-def mindist(x, X):",
"- global dist",
"- Y = X.copy()",
"- Y.remove(x)",
"- if len(Y) == 0:",
"- return 0",
"- return min([dist[x][y] + mindist(y, Y) for y in Y])",
"-",
"-",
"-ans = min([mindist(r, R) for r in R])",
"-print(ans)",
"+with open(0) as f:",
"+ N, M, R = list(map(int, f.readline().split()))",
"+ r = list(map(int, f.readline().split()))",
"+ path = [tuple(map(int, line.split())) for line in f.readlines()]",
"+graph = np.full((N, N), np.inf)",
"+for a, b, c in path:",
"+ graph[a - 1, b - 1] = c",
"+ graph[b - 1, a - 1] = c",
"+graph = dijkstra(graph, directed=False)",
"+ans = np.inf",
"+permutation = list(permutations(r))",
"+for p in permutation:",
"+ way = 0",
"+ for x, y in zip(p[: len(r)], p[1:]):",
"+ way += graph[x - 1, y - 1]",
"+ ans = min(ans, way)",
"+print((int(ans)))"
] | false | 0.047941 | 0.29193 | 0.164222 | [
"s640495665",
"s745262356"
] |
u945181840 | p02762 | python | s520695822 | s158921961 | 1,302 | 956 | 58,372 | 58,372 | Accepted | Accepted | 26.57 | import sys
read = sys.stdin.read
readline = sys.stdin.readline
class UnionFind():
# 作りたい要素数nで初期化
# 使用するインスタンス変数の初期化
def __init__(self, n):
self.n = n
# root[x]<0ならそのノードが根かつその値が木の要素数
# rootノードでその木の要素数を記録する
self.root = [-1] * (n + 1)
# 木をくっつける時にアンバランスにならないように調整する
self.rnk = [0] * (n + 1)
# ノードxのrootノードを見つける
def Find_Root(self, x):
if self.root[x] < 0:
return x
else:
# ここで代入しておくことで、後の繰り返しを避ける
self.root[x] = self.Find_Root(self.root[x])
return self.root[x]
# 木の併合、入力は併合したい各ノード
def Unite(self, x, y):
# 入力ノードのrootノードを見つける
x = self.Find_Root(x)
y = self.Find_Root(y)
# すでに同じ木に属していた場合
if x == y:
return
# 違う木に属していた場合rnkを見てくっつける方を決める
elif self.rnk[x] > self.rnk[y]:
self.root[x] += self.root[y]
self.root[y] = x
else:
self.root[y] += self.root[x]
self.root[x] = y
# rnkが同じ（深さに差がない場合）は1増やす
if self.rnk[x] == self.rnk[y]:
self.rnk[y] += 1
# xとyが同じグループに属するか判断
def isSameGroup(self, x, y):
return self.Find_Root(x) == self.Find_Root(y)
# ノードxが属する木のサイズを返す
def Count(self, x):
return -self.root[self.Find_Root(x)]
N, M, K, *ABCD = list(map(int, read().split()))
AB = ABCD[:M * 2]
CD = ABCD[M * 2:]
F = UnionFind(N)
friend = [[] for _ in range(N + 1)]
for A, B in zip(*[iter(AB)] * 2):
F.Unite(A, B)
friend[A].append(B)
friend[B].append(A)
block = [[] for _ in range(N + 1)]
for C, D in zip(*[iter(CD)] * 2):
block[C].append(D)
block[D].append(C)
answer = []
for i in range(1, N + 1):
cnt = F.Count(i) - 1
for j in block[i]:
if F.isSameGroup(i, j):
cnt -= 1
for j in friend[i]:
if F.isSameGroup(i, j):
cnt -= 1
answer.append(cnt)
print((' '.join(map(str, answer))))
| import sys
read = sys.stdin.read
readline = sys.stdin.readline
class UnionFind():
# 作りたい要素数nで初期化
# 使用するインスタンス変数の初期化
def __init__(self, n):
self.n = n
# root[x]<0ならそのノードが根かつその値が木の要素数
# rootノードでその木の要素数を記録する
self.root = [-1] * (n + 1)
# 木をくっつける時にアンバランスにならないように調整する
self.rnk = [0] * (n + 1)
# ノードxのrootノードを見つける
def Find_Root(self, x):
if self.root[x] < 0:
return x
else:
# ここで代入しておくことで、後の繰り返しを避ける
self.root[x] = self.Find_Root(self.root[x])
return self.root[x]
# 木の併合、入力は併合したい各ノード
def Unite(self, x, y):
# 入力ノードのrootノードを見つける
x = self.Find_Root(x)
y = self.Find_Root(y)
# すでに同じ木に属していた場合
if x == y:
return
# 違う木に属していた場合rnkを見てくっつける方を決める
elif self.rnk[x] > self.rnk[y]:
self.root[x] += self.root[y]
self.root[y] = x
else:
self.root[y] += self.root[x]
self.root[x] = y
# rnkが同じ（深さに差がない場合）は1増やす
if self.rnk[x] == self.rnk[y]:
self.rnk[y] += 1
# xとyが同じグループに属するか判断
def isSameGroup(self, x, y):
return self.Find_Root(x) == self.Find_Root(y)
# ノードxが属する木のサイズを返す
def Count(self, x):
return -self.root[self.Find_Root(x)]
N, M, K, *ABCD = list(map(int, read().split()))
AB = ABCD[:M * 2]
CD = ABCD[M * 2:]
F = UnionFind(N)
friend = [[] for _ in range(N + 1)]
for A, B in zip(*[iter(AB)] * 2):
F.Unite(A, B)
friend[A].append(B)
friend[B].append(A)
block = [[] for _ in range(N + 1)]
for C, D in zip(*[iter(CD)] * 2):
block[C].append(D)
block[D].append(C)
answer = []
for i in range(1, N + 1):
cnt = F.Count(i) - 1
for j in block[i]:
if F.isSameGroup(i, j):
cnt -= 1
cnt -= len(friend[i])
answer.append(cnt)
print((' '.join(map(str, answer))))
| 82 | 80 | 2,053 | 2,000 | import sys
read = sys.stdin.read
readline = sys.stdin.readline
class UnionFind:
# 作りたい要素数nで初期化
# 使用するインスタンス変数の初期化
def __init__(self, n):
self.n = n
# root[x]<0ならそのノードが根かつその値が木の要素数
# rootノードでその木の要素数を記録する
self.root = [-1] * (n + 1)
# 木をくっつける時にアンバランスにならないように調整する
self.rnk = [0] * (n + 1)
# ノードxのrootノードを見つける
def Find_Root(self, x):
if self.root[x] < 0:
return x
else:
# ここで代入しておくことで、後の繰り返しを避ける
self.root[x] = self.Find_Root(self.root[x])
return self.root[x]
# 木の併合、入力は併合したい各ノード
def Unite(self, x, y):
# 入力ノードのrootノードを見つける
x = self.Find_Root(x)
y = self.Find_Root(y)
# すでに同じ木に属していた場合
if x == y:
return
# 違う木に属していた場合rnkを見てくっつける方を決める
elif self.rnk[x] > self.rnk[y]:
self.root[x] += self.root[y]
self.root[y] = x
else:
self.root[y] += self.root[x]
self.root[x] = y
# rnkが同じ（深さに差がない場合）は1増やす
if self.rnk[x] == self.rnk[y]:
self.rnk[y] += 1
# xとyが同じグループに属するか判断
def isSameGroup(self, x, y):
return self.Find_Root(x) == self.Find_Root(y)
# ノードxが属する木のサイズを返す
def Count(self, x):
return -self.root[self.Find_Root(x)]
N, M, K, *ABCD = list(map(int, read().split()))
AB = ABCD[: M * 2]
CD = ABCD[M * 2 :]
F = UnionFind(N)
friend = [[] for _ in range(N + 1)]
for A, B in zip(*[iter(AB)] * 2):
F.Unite(A, B)
friend[A].append(B)
friend[B].append(A)
block = [[] for _ in range(N + 1)]
for C, D in zip(*[iter(CD)] * 2):
block[C].append(D)
block[D].append(C)
answer = []
for i in range(1, N + 1):
cnt = F.Count(i) - 1
for j in block[i]:
if F.isSameGroup(i, j):
cnt -= 1
for j in friend[i]:
if F.isSameGroup(i, j):
cnt -= 1
answer.append(cnt)
print((" ".join(map(str, answer))))
| import sys
read = sys.stdin.read
readline = sys.stdin.readline
class UnionFind:
# 作りたい要素数nで初期化
# 使用するインスタンス変数の初期化
def __init__(self, n):
self.n = n
# root[x]<0ならそのノードが根かつその値が木の要素数
# rootノードでその木の要素数を記録する
self.root = [-1] * (n + 1)
# 木をくっつける時にアンバランスにならないように調整する
self.rnk = [0] * (n + 1)
# ノードxのrootノードを見つける
def Find_Root(self, x):
if self.root[x] < 0:
return x
else:
# ここで代入しておくことで、後の繰り返しを避ける
self.root[x] = self.Find_Root(self.root[x])
return self.root[x]
# 木の併合、入力は併合したい各ノード
def Unite(self, x, y):
# 入力ノードのrootノードを見つける
x = self.Find_Root(x)
y = self.Find_Root(y)
# すでに同じ木に属していた場合
if x == y:
return
# 違う木に属していた場合rnkを見てくっつける方を決める
elif self.rnk[x] > self.rnk[y]:
self.root[x] += self.root[y]
self.root[y] = x
else:
self.root[y] += self.root[x]
self.root[x] = y
# rnkが同じ（深さに差がない場合）は1増やす
if self.rnk[x] == self.rnk[y]:
self.rnk[y] += 1
# xとyが同じグループに属するか判断
def isSameGroup(self, x, y):
return self.Find_Root(x) == self.Find_Root(y)
# ノードxが属する木のサイズを返す
def Count(self, x):
return -self.root[self.Find_Root(x)]
N, M, K, *ABCD = list(map(int, read().split()))
AB = ABCD[: M * 2]
CD = ABCD[M * 2 :]
F = UnionFind(N)
friend = [[] for _ in range(N + 1)]
for A, B in zip(*[iter(AB)] * 2):
F.Unite(A, B)
friend[A].append(B)
friend[B].append(A)
block = [[] for _ in range(N + 1)]
for C, D in zip(*[iter(CD)] * 2):
block[C].append(D)
block[D].append(C)
answer = []
for i in range(1, N + 1):
cnt = F.Count(i) - 1
for j in block[i]:
if F.isSameGroup(i, j):
cnt -= 1
cnt -= len(friend[i])
answer.append(cnt)
print((" ".join(map(str, answer))))
| false | 2.439024 | [
"- for j in friend[i]:",
"- if F.isSameGroup(i, j):",
"- cnt -= 1",
"+ cnt -= len(friend[i])"
] | false | 0.084252 | 0.066353 | 1.269745 | [
"s520695822",
"s158921961"
] |
u819048695 | p02883 | python | s406762227 | s363509551 | 758 | 532 | 120,140 | 119,500 | Accepted | Accepted | 29.82 | # E
n,k=list(map(int,input().split()))
a=list(map(int,input().split()))
a.sort()
f=list(map(int,input().split()))
f.sort(reverse=True)
x=1
i=0
while i>=0:
cnt=0
for j in range(n):
cnt+=max(0,a[j]-x//f[j])
if cnt>k:
i+=1
x=2**i
else:
break
while i>0:
cnt=0
for j in range(n):
cnt+=max(0,a[j]-x//f[j])
if cnt>k:
i-=1
x+=2**i
else:
i-=1
x-=2**i
y=x-1
cnt=0
for j in range(n):
cnt+=max(0,a[j]-y//f[j])
if cnt<=k:
print(y)
else:
cnt=0
for j in range(n):
cnt+=max(0,a[j]-x//f[j])
if cnt<=k:
print(x)
else:
print((x+1)) | def f(x):
cnt=0
for i in range(N):
num=x//F[i]
if A[i]>num:
cnt+=A[i]-num
return cnt
N,K=list(map(int,input().split()))
A=list(map(int,input().split()))
F=list(map(int,input().split()))
A.sort()
F.sort(reverse=True)
low=0
high=10**12+1
while high-low>0:
mid=(high+low)//2
xxx=f(mid)
if xxx<=K:
high=mid
else:
if low==mid:
low=high
else:
low=mid
print(low) | 41 | 29 | 696 | 485 | # E
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
a.sort()
f = list(map(int, input().split()))
f.sort(reverse=True)
x = 1
i = 0
while i >= 0:
cnt = 0
for j in range(n):
cnt += max(0, a[j] - x // f[j])
if cnt > k:
i += 1
x = 2**i
else:
break
while i > 0:
cnt = 0
for j in range(n):
cnt += max(0, a[j] - x // f[j])
if cnt > k:
i -= 1
x += 2**i
else:
i -= 1
x -= 2**i
y = x - 1
cnt = 0
for j in range(n):
cnt += max(0, a[j] - y // f[j])
if cnt <= k:
print(y)
else:
cnt = 0
for j in range(n):
cnt += max(0, a[j] - x // f[j])
if cnt <= k:
print(x)
else:
print((x + 1))
| def f(x):
cnt = 0
for i in range(N):
num = x // F[i]
if A[i] > num:
cnt += A[i] - num
return cnt
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
F = list(map(int, input().split()))
A.sort()
F.sort(reverse=True)
low = 0
high = 10**12 + 1
while high - low > 0:
mid = (high + low) // 2
xxx = f(mid)
if xxx <= K:
high = mid
else:
if low == mid:
low = high
else:
low = mid
print(low)
| false | 29.268293 | [
"-# E",
"-n, k = list(map(int, input().split()))",
"-a = list(map(int, input().split()))",
"-a.sort()",
"-f = list(map(int, input().split()))",
"-f.sort(reverse=True)",
"-x = 1",
"-i = 0",
"-while i >= 0:",
"+def f(x):",
"- for j in range(n):",
"- cnt += max(0, a[j] - x // f[j])",
"- if cnt > k:",
"- i += 1",
"- x = 2**i",
"+ for i in range(N):",
"+ num = x // F[i]",
"+ if A[i] > num:",
"+ cnt += A[i] - num",
"+ return cnt",
"+",
"+",
"+N, K = list(map(int, input().split()))",
"+A = list(map(int, input().split()))",
"+F = list(map(int, input().split()))",
"+A.sort()",
"+F.sort(reverse=True)",
"+low = 0",
"+high = 10**12 + 1",
"+while high - low > 0:",
"+ mid = (high + low) // 2",
"+ xxx = f(mid)",
"+ if xxx <= K:",
"+ high = mid",
"- break",
"-while i > 0:",
"- cnt = 0",
"- for j in range(n):",
"- cnt += max(0, a[j] - x // f[j])",
"- if cnt > k:",
"- i -= 1",
"- x += 2**i",
"- else:",
"- i -= 1",
"- x -= 2**i",
"-y = x - 1",
"-cnt = 0",
"-for j in range(n):",
"- cnt += max(0, a[j] - y // f[j])",
"-if cnt <= k:",
"- print(y)",
"-else:",
"- cnt = 0",
"- for j in range(n):",
"- cnt += max(0, a[j] - x // f[j])",
"- if cnt <= k:",
"- print(x)",
"- else:",
"- print((x + 1))",
"+ if low == mid:",
"+ low = high",
"+ else:",
"+ low = mid",
"+print(low)"
] | false | 0.05855 | 0.135683 | 0.431517 | [
"s406762227",
"s363509551"
] |
u490642448 | p03038 | python | s463047591 | s843421068 | 936 | 642 | 76,184 | 68,120 | Accepted | Accepted | 31.41 | n,m = list(map(int, input().split()))
a = list(map(int, input().split()))
cb = [list(map(int,input().split()))[::-1] for _ in range(m) ]
cb.append([-1,1])
a.sort()
cb.sort()
i= n-1
j = m
ans = 0
remain = n
while(remain > 0):
if( a[i] > cb[j][0] ):
ans += a[i]
i -= 1
remain -= 1
else:
ans += cb[j][0] * min(remain, cb[j][1])
remain -= cb[j][1]
j -= 1
print(ans) | import sys
input = sys.stdin.readline
n,m = list(map(int, input().split()))
a = list(map(int, input().split()))
cb = [list(map(int,input().split()))[::-1] for _ in range(m) ]
cb.append([-1,1])
a.sort()
cb.sort()
i= n-1
j = m
ans = 0
remain = n
while(remain > 0):
if( a[i] > cb[j][0] ):
ans += a[i]
i -= 1
remain -= 1
else:
ans += cb[j][0] * min(remain, cb[j][1])
remain -= cb[j][1]
j -= 1
print(ans)
| 24 | 27 | 438 | 481 | n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
cb = [list(map(int, input().split()))[::-1] for _ in range(m)]
cb.append([-1, 1])
a.sort()
cb.sort()
i = n - 1
j = m
ans = 0
remain = n
while remain > 0:
if a[i] > cb[j][0]:
ans += a[i]
i -= 1
remain -= 1
else:
ans += cb[j][0] * min(remain, cb[j][1])
remain -= cb[j][1]
j -= 1
print(ans)
| import sys
input = sys.stdin.readline
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
cb = [list(map(int, input().split()))[::-1] for _ in range(m)]
cb.append([-1, 1])
a.sort()
cb.sort()
i = n - 1
j = m
ans = 0
remain = n
while remain > 0:
if a[i] > cb[j][0]:
ans += a[i]
i -= 1
remain -= 1
else:
ans += cb[j][0] * min(remain, cb[j][1])
remain -= cb[j][1]
j -= 1
print(ans)
| false | 11.111111 | [
"+import sys",
"+",
"+input = sys.stdin.readline"
] | false | 0.03647 | 0.036713 | 0.993383 | [
"s463047591",
"s843421068"
] |
u846041485 | p03724 | python | s211885221 | s663005701 | 279 | 195 | 11,808 | 3,828 | Accepted | Accepted | 30.11 | import sys
n, m = list(map(int, sys.stdin.readline().split(' ')))
a = [0] * (2 * m)
for i in range(m):
a[2 * i], a[2 * i + 1] = list(map(int, sys.stdin.readline().split(' ')))
a.sort()
flag = False
tmp = 0
crr = 0
for i in range(2 * m):
nxt = a[i]
if crr == nxt:
tmp += 1
else:
if tmp & 1:
flag = True
break
tmp = 1
crr = nxt
if not flag:
print("YES")
else:
print("NO")
| import sys
n, m = list(map(int, sys.stdin.readline().split(' ')))
mlt = [0] * n
for i in range(m):
b, c = list(map(int, sys.stdin.readline().split(' ')))
b -= 1
c -= 1
mlt[b] += 1
mlt[c] += 1
flag = False
for i in range(n):
if mlt[i] & 1:
flag = True
break
if not flag:
print("YES")
else:
print("NO")
| 23 | 18 | 456 | 354 | import sys
n, m = list(map(int, sys.stdin.readline().split(" ")))
a = [0] * (2 * m)
for i in range(m):
a[2 * i], a[2 * i + 1] = list(map(int, sys.stdin.readline().split(" ")))
a.sort()
flag = False
tmp = 0
crr = 0
for i in range(2 * m):
nxt = a[i]
if crr == nxt:
tmp += 1
else:
if tmp & 1:
flag = True
break
tmp = 1
crr = nxt
if not flag:
print("YES")
else:
print("NO")
| import sys
n, m = list(map(int, sys.stdin.readline().split(" ")))
mlt = [0] * n
for i in range(m):
b, c = list(map(int, sys.stdin.readline().split(" ")))
b -= 1
c -= 1
mlt[b] += 1
mlt[c] += 1
flag = False
for i in range(n):
if mlt[i] & 1:
flag = True
break
if not flag:
print("YES")
else:
print("NO")
| false | 21.73913 | [
"-a = [0] * (2 * m)",
"+mlt = [0] * n",
"- a[2 * i], a[2 * i + 1] = list(map(int, sys.stdin.readline().split(\" \")))",
"-a.sort()",
"+ b, c = list(map(int, sys.stdin.readline().split(\" \")))",
"+ b -= 1",
"+ c -= 1",
"+ mlt[b] += 1",
"+ mlt[c] += 1",
"-tmp = 0",
"-crr = 0",
"-for i in range(2 * m):",
"- nxt = a[i]",
"- if crr == nxt:",
"- tmp += 1",
"- else:",
"- if tmp & 1:",
"- flag = True",
"- break",
"- tmp = 1",
"- crr = nxt",
"+for i in range(n):",
"+ if mlt[i] & 1:",
"+ flag = True",
"+ break"
] | false | 0.060434 | 0.042558 | 1.420054 | [
"s211885221",
"s663005701"
] |
u045939752 | p03806 | python | s739624014 | s187653931 | 1,771 | 1,509 | 3,924 | 3,924 | Accepted | Accepted | 14.79 | N, Ma, Mb = list(map(int, input().split()))
G = []
for i in range(N):
a, b, c = list(map(int, input().split()))
G.append( (a,b,c) )
M = 1 + min(sum([ a for a, b, c in G ]),
sum([ b for a, b, c in G ]) )
INF = 1000000000
dp = [INF] * (M * M)
dp[0] = 0
for a, b, c in G:
i = M - a - 1
while i >= 0:
j = M - b - 1
while j >= 0:
dp[(i+a)*M+(j+b)] = min(dp[(i+a)*M+(j+b)], dp[i*M+j] + c)
j -= 1
i -= 1
ans = INF
x = 1
while Ma * x < M and Mb * x < M:
ans = min(ans, dp[Ma * x * M + Mb * x])
x += 1
if ans >= INF:
ans = -1
print(ans)
| N, Ma, Mb = list(map(int, input().split()))
G = []
for i in range(N):
a, b, c = list(map(int, input().split()))
G.append( (a,b,c) )
M = 1 + min(sum([ a for a, b, c in G ]),
sum([ b for a, b, c in G ]) )
INF = 1000000000
dp = [INF] * (M * M)
dp[0] = 0
for a, b, c in G:
for i in reversed(list(range(0, M - a))):
for j in reversed(list(range(0, M - b))):
dp[(i+a)*M+(j+b)] = min(dp[(i+a)*M+(j+b)], dp[i*M+j] + c)
ans = INF
x = 1
while Ma * x < M and Mb * x < M:
ans = min(ans, dp[Ma * x * M + Mb * x])
x += 1
if ans >= INF:
ans = -1
print(ans)
| 29 | 24 | 595 | 575 | N, Ma, Mb = list(map(int, input().split()))
G = []
for i in range(N):
a, b, c = list(map(int, input().split()))
G.append((a, b, c))
M = 1 + min(sum([a for a, b, c in G]), sum([b for a, b, c in G]))
INF = 1000000000
dp = [INF] * (M * M)
dp[0] = 0
for a, b, c in G:
i = M - a - 1
while i >= 0:
j = M - b - 1
while j >= 0:
dp[(i + a) * M + (j + b)] = min(
dp[(i + a) * M + (j + b)], dp[i * M + j] + c
)
j -= 1
i -= 1
ans = INF
x = 1
while Ma * x < M and Mb * x < M:
ans = min(ans, dp[Ma * x * M + Mb * x])
x += 1
if ans >= INF:
ans = -1
print(ans)
| N, Ma, Mb = list(map(int, input().split()))
G = []
for i in range(N):
a, b, c = list(map(int, input().split()))
G.append((a, b, c))
M = 1 + min(sum([a for a, b, c in G]), sum([b for a, b, c in G]))
INF = 1000000000
dp = [INF] * (M * M)
dp[0] = 0
for a, b, c in G:
for i in reversed(list(range(0, M - a))):
for j in reversed(list(range(0, M - b))):
dp[(i + a) * M + (j + b)] = min(
dp[(i + a) * M + (j + b)], dp[i * M + j] + c
)
ans = INF
x = 1
while Ma * x < M and Mb * x < M:
ans = min(ans, dp[Ma * x * M + Mb * x])
x += 1
if ans >= INF:
ans = -1
print(ans)
| false | 17.241379 | [
"- i = M - a - 1",
"- while i >= 0:",
"- j = M - b - 1",
"- while j >= 0:",
"+ for i in reversed(list(range(0, M - a))):",
"+ for j in reversed(list(range(0, M - b))):",
"- j -= 1",
"- i -= 1"
] | false | 0.049169 | 0.049778 | 0.987756 | [
"s739624014",
"s187653931"
] |
u476386869 | p02596 | python | s265455886 | s613600013 | 699 | 107 | 9,196 | 9,168 | Accepted | Accepted | 84.69 | import sys
input = sys.stdin.readline
def main():
K = int(eval(input()))
if K%2==0:
print((-1))
return
if K % 7:
L = 9*K
else:
L = 9*K//7
a = 1
for i in range(1,L+1):
a = (a * 10) % L
if a == 1:
print(i)
return
print((-1))
main() | #!python3.8
# -*- coding: utf-8 -*-
# abc174/abc174_c
import sys
s2nn = lambda s: [int(c) for c in s.split(' ')]
ss2nn = lambda ss: [int(s) for s in list(ss)]
ss2nnn = lambda ss: [s2nn(s) for s in list(ss)]
i2s = lambda: sys.stdin.readline().rstrip()
i2n = lambda: int(i2s())
i2nn = lambda: s2nn(i2s())
ii2ss = lambda n: [i2s() for _ in range(n)]
ii2nn = lambda n: ss2nn(ii2ss(n))
ii2nnn = lambda n: ss2nnn(ii2ss(n))
def main():
K = i2n()
a = 0
if K % 7:
L = 9 * K
else:
L = 9 * K // 7
a = 1
for i in range(1, K + 10):
a = (a * 10) % L
if a == 1:
print(i)
return
print('-1')
return
main() | 23 | 32 | 353 | 712 | import sys
input = sys.stdin.readline
def main():
K = int(eval(input()))
if K % 2 == 0:
print((-1))
return
if K % 7:
L = 9 * K
else:
L = 9 * K // 7
a = 1
for i in range(1, L + 1):
a = (a * 10) % L
if a == 1:
print(i)
return
print((-1))
main()
| #!python3.8
# -*- coding: utf-8 -*-
# abc174/abc174_c
import sys
s2nn = lambda s: [int(c) for c in s.split(" ")]
ss2nn = lambda ss: [int(s) for s in list(ss)]
ss2nnn = lambda ss: [s2nn(s) for s in list(ss)]
i2s = lambda: sys.stdin.readline().rstrip()
i2n = lambda: int(i2s())
i2nn = lambda: s2nn(i2s())
ii2ss = lambda n: [i2s() for _ in range(n)]
ii2nn = lambda n: ss2nn(ii2ss(n))
ii2nnn = lambda n: ss2nnn(ii2ss(n))
def main():
K = i2n()
a = 0
if K % 7:
L = 9 * K
else:
L = 9 * K // 7
a = 1
for i in range(1, K + 10):
a = (a * 10) % L
if a == 1:
print(i)
return
print("-1")
return
main()
| false | 28.125 | [
"+#!python3.8",
"+# -*- coding: utf-8 -*-",
"+# abc174/abc174_c",
"-input = sys.stdin.readline",
"+s2nn = lambda s: [int(c) for c in s.split(\" \")]",
"+ss2nn = lambda ss: [int(s) for s in list(ss)]",
"+ss2nnn = lambda ss: [s2nn(s) for s in list(ss)]",
"+i2s = lambda: sys.stdin.readline().rstrip()",
"+i2n = lambda: int(i2s())",
"+i2nn = lambda: s2nn(i2s())",
"+ii2ss = lambda n: [i2s() for _ in range(n)]",
"+ii2nn = lambda n: ss2nn(ii2ss(n))",
"+ii2nnn = lambda n: ss2nnn(ii2ss(n))",
"- K = int(eval(input()))",
"- if K % 2 == 0:",
"- print((-1))",
"- return",
"+ K = i2n()",
"+ a = 0",
"- for i in range(1, L + 1):",
"+ for i in range(1, K + 10):",
"- print((-1))",
"+ print(\"-1\")",
"+ return"
] | false | 0.096848 | 0.055183 | 1.75503 | [
"s265455886",
"s613600013"
] |
u227082700 | p03589 | python | s181100107 | s239554093 | 1,511 | 1,350 | 3,060 | 3,060 | Accepted | Accepted | 10.66 | N=int(eval(input()))
for h in range(1,3501):
for n in range(1,3501):
if 1/h+1/n>=4/N:continue
w=(N*h*n)/(4*h*n-N*(h+n))
if w==int(w):print((h,n,int(w)));exit() | N=int(eval(input()))
for h in range(1,3501):
for n in range(1,3501):
if 1/h+1/n>=4/N:continue
if (N*h*n)%(4*h*n-N*(h+n))==0:print((h,n,(N*h*n)//(4*h*n-N*(h+n))));exit() | 6 | 5 | 170 | 174 | N = int(eval(input()))
for h in range(1, 3501):
for n in range(1, 3501):
if 1 / h + 1 / n >= 4 / N:
continue
w = (N * h * n) / (4 * h * n - N * (h + n))
if w == int(w):
print((h, n, int(w)))
exit()
| N = int(eval(input()))
for h in range(1, 3501):
for n in range(1, 3501):
if 1 / h + 1 / n >= 4 / N:
continue
if (N * h * n) % (4 * h * n - N * (h + n)) == 0:
print((h, n, (N * h * n) // (4 * h * n - N * (h + n))))
exit()
| false | 16.666667 | [
"- w = (N * h * n) / (4 * h * n - N * (h + n))",
"- if w == int(w):",
"- print((h, n, int(w)))",
"+ if (N * h * n) % (4 * h * n - N * (h + n)) == 0:",
"+ print((h, n, (N * h * n) // (4 * h * n - N * (h + n))))"
] | false | 0.049063 | 0.046529 | 1.054456 | [
"s181100107",
"s239554093"
] |
u945181840 | p03732 | python | s745793737 | s538748490 | 275 | 34 | 3,064 | 3,064 | Accepted | Accepted | 87.64 | import sys
from itertools import accumulate, product
from operator import itemgetter
read = sys.stdin.read
N, W, *wv = list(map(int, read().split()))
w1 = wv[0]
V = [[0] for _ in range(4)]
for w, v in sorted(zip(*[iter(wv)] * 2), key=itemgetter(1), reverse=True):
V[w - w1].append(v)
V = list(map(list, list(map(accumulate, V))))
n = [len(V[i]) for i in range(4)]
answer = 0
for a, b, c, d in product(list(range(n[0])), list(range(n[1])), list(range(n[2])), list(range(n[3]))):
if b + c * 2 + d * 3 + (a + b + c + d) * w1 > W:
continue
v = V[0][a] + V[1][b] + V[2][c] + V[3][d]
if v > answer:
answer = v
print(answer) | import sys
from itertools import accumulate, product
from operator import itemgetter
read = sys.stdin.read
N, W, *wv = list(map(int, read().split()))
w1 = wv[0]
V = [[0] for _ in range(4)]
for w, v in sorted(zip(*[iter(wv)] * 2), key=itemgetter(1), reverse=True):
V[w - w1].append(v)
V = list(map(list, list(map(accumulate, V))))
n = [len(V[i]) for i in range(4)]
answer = 0
for a, b, c in product(list(range(n[0])), list(range(n[1])), list(range(n[2]))):
tmp = b + c * 2 + (a + b + c) * w1
if tmp > W:
continue
d = min(n[3] - 1, (W - tmp) // (w1 + 3))
v = V[0][a] + V[1][b] + V[2][c] + V[3][d]
if v > answer:
answer = v
print(answer) | 25 | 27 | 643 | 676 | import sys
from itertools import accumulate, product
from operator import itemgetter
read = sys.stdin.read
N, W, *wv = list(map(int, read().split()))
w1 = wv[0]
V = [[0] for _ in range(4)]
for w, v in sorted(zip(*[iter(wv)] * 2), key=itemgetter(1), reverse=True):
V[w - w1].append(v)
V = list(map(list, list(map(accumulate, V))))
n = [len(V[i]) for i in range(4)]
answer = 0
for a, b, c, d in product(
list(range(n[0])), list(range(n[1])), list(range(n[2])), list(range(n[3]))
):
if b + c * 2 + d * 3 + (a + b + c + d) * w1 > W:
continue
v = V[0][a] + V[1][b] + V[2][c] + V[3][d]
if v > answer:
answer = v
print(answer)
| import sys
from itertools import accumulate, product
from operator import itemgetter
read = sys.stdin.read
N, W, *wv = list(map(int, read().split()))
w1 = wv[0]
V = [[0] for _ in range(4)]
for w, v in sorted(zip(*[iter(wv)] * 2), key=itemgetter(1), reverse=True):
V[w - w1].append(v)
V = list(map(list, list(map(accumulate, V))))
n = [len(V[i]) for i in range(4)]
answer = 0
for a, b, c in product(list(range(n[0])), list(range(n[1])), list(range(n[2]))):
tmp = b + c * 2 + (a + b + c) * w1
if tmp > W:
continue
d = min(n[3] - 1, (W - tmp) // (w1 + 3))
v = V[0][a] + V[1][b] + V[2][c] + V[3][d]
if v > answer:
answer = v
print(answer)
| false | 7.407407 | [
"-for a, b, c, d in product(",
"- list(range(n[0])), list(range(n[1])), list(range(n[2])), list(range(n[3]))",
"-):",
"- if b + c * 2 + d * 3 + (a + b + c + d) * w1 > W:",
"+for a, b, c in product(list(range(n[0])), list(range(n[1])), list(range(n[2]))):",
"+ tmp = b + c * 2 + (a + b + c) * w1",
"+ if tmp > W:",
"+ d = min(n[3] - 1, (W - tmp) // (w1 + 3))"
] | false | 0.073766 | 0.040668 | 1.813838 | [
"s745793737",
"s538748490"
] |
u555587832 | p02594 | python | s834362269 | s829018170 | 28 | 24 | 9,148 | 8,992 | Accepted | Accepted | 14.29 | a = int(eval(input()))
if a >= 30:
print('Yes')
else:
print('No')
| x = int(eval(input()))
if x >= 30:
print('Yes')
else:
print('No') | 5 | 5 | 72 | 71 | a = int(eval(input()))
if a >= 30:
print("Yes")
else:
print("No")
| x = int(eval(input()))
if x >= 30:
print("Yes")
else:
print("No")
| false | 0 | [
"-a = int(eval(input()))",
"-if a >= 30:",
"+x = int(eval(input()))",
"+if x >= 30:"
] | false | 0.044919 | 0.048164 | 0.932614 | [
"s834362269",
"s829018170"
] |
u844789719 | p03061 | python | s505221190 | s332965982 | 1,382 | 972 | 128,732 | 122,888 | Accepted | Accepted | 29.67 | N = int(eval(input()))
A = [int(_) for _ in input().split()]
class SegmentTree():
def __init__(self, array, f, e, size):
"""
Parameters
----------
array : list
to construct segment tree from
f : func
binary operation of the monoid
e :
identity element of the monoid
size : int
limit for array size
"""
self.f = f
self.e = e
self.size = size
self.n = n = len(array)
self.dat = dat = [e] * n + array + [e] * (2 * size - 2 * n)
for i in range(n - 1, 0, -1): # build
dat[i] = f(dat[i << 1], dat[i << 1 | 1])
def modify(self, p, v): # set value at position p (0-indexed)
f, n, dat = self.f, self.n, self.dat
p += n
dat[p] = v
while p > 1:
dat[p >> 1] = f(dat[p], dat[p ^ 1])
p >>= 1
def query(self, l, r): # result on interval [l, r) (0-indexed)
f, e, n, dat = self.f, self.e, self.n, self.dat
res = e
l += n
r += n
while l < r:
if l & 1:
res = f(res, dat[l])
l += 1
if r & 1:
r -= 1
res = f(res, dat[r])
l >>= 1
r >>= 1
return res
gcd = lambda x, y: gcd(y, x) if x < y else gcd(y, x % y) if y else x
e = 0
size = N
ST = SegmentTree(A, f=gcd, e=e, size=size)
ans = 1
for i, a in enumerate(A):
ST.modify(i, 0)
ans = max(ans, ST.query(0, N))
ST.modify(i, a)
print(ans)
| class SegmentTree():
def __init__(self, array, f, ti):
"""
Parameters
----------
array : list
to construct segment tree from
f : func
binary operation of the monoid
ti :
identity element of the monoid
"""
self.f = f
self.ti = ti
self.n = n = 2**(len(array).bit_length())
self.dat = dat = [ti] * n + array + [ti] * (n - len(array))
for i in range(n - 1, 0, -1): # build
dat[i] = f(dat[i << 1], dat[i << 1 | 1])
def update(self, p, v): # set value at position p (0-indexed)
f, n, dat = self.f, self.n, self.dat
p += n
dat[p] = v
while p > 1:
p >>= 1
dat[p] = f(dat[p << 1], dat[p << 1 | 1])
def query(self, l, r): # result on interval [l, r) (0-indexed)
f, ti, n, dat = self.f, self.ti, self.n, self.dat
res = ti
l += n
r += n
while l < r:
if l & 1:
res = f(res, dat[l])
l += 1
if r & 1:
r -= 1
res = f(dat[r], res)
l >>= 1
r >>= 1
return res
def gcd(x, y):
if x * y == 0:
return x + y
elif x > y:
return gcd(y, x)
else:
return gcd(y % x, x)
N = int(eval(input()))
A = [int(_) for _ in input().split()]
ST = SegmentTree(array=A, f=gcd, ti=0)
ans = 0
for i in range(N):
ans = max(ans, gcd(ST.query(0, i), ST.query(i + 1, N)))
print(ans)
| 61 | 60 | 1,638 | 1,609 | N = int(eval(input()))
A = [int(_) for _ in input().split()]
class SegmentTree:
def __init__(self, array, f, e, size):
"""
Parameters
----------
array : list
to construct segment tree from
f : func
binary operation of the monoid
e :
identity element of the monoid
size : int
limit for array size
"""
self.f = f
self.e = e
self.size = size
self.n = n = len(array)
self.dat = dat = [e] * n + array + [e] * (2 * size - 2 * n)
for i in range(n - 1, 0, -1): # build
dat[i] = f(dat[i << 1], dat[i << 1 | 1])
def modify(self, p, v): # set value at position p (0-indexed)
f, n, dat = self.f, self.n, self.dat
p += n
dat[p] = v
while p > 1:
dat[p >> 1] = f(dat[p], dat[p ^ 1])
p >>= 1
def query(self, l, r): # result on interval [l, r) (0-indexed)
f, e, n, dat = self.f, self.e, self.n, self.dat
res = e
l += n
r += n
while l < r:
if l & 1:
res = f(res, dat[l])
l += 1
if r & 1:
r -= 1
res = f(res, dat[r])
l >>= 1
r >>= 1
return res
gcd = lambda x, y: gcd(y, x) if x < y else gcd(y, x % y) if y else x
e = 0
size = N
ST = SegmentTree(A, f=gcd, e=e, size=size)
ans = 1
for i, a in enumerate(A):
ST.modify(i, 0)
ans = max(ans, ST.query(0, N))
ST.modify(i, a)
print(ans)
| class SegmentTree:
def __init__(self, array, f, ti):
"""
Parameters
----------
array : list
to construct segment tree from
f : func
binary operation of the monoid
ti :
identity element of the monoid
"""
self.f = f
self.ti = ti
self.n = n = 2 ** (len(array).bit_length())
self.dat = dat = [ti] * n + array + [ti] * (n - len(array))
for i in range(n - 1, 0, -1): # build
dat[i] = f(dat[i << 1], dat[i << 1 | 1])
def update(self, p, v): # set value at position p (0-indexed)
f, n, dat = self.f, self.n, self.dat
p += n
dat[p] = v
while p > 1:
p >>= 1
dat[p] = f(dat[p << 1], dat[p << 1 | 1])
def query(self, l, r): # result on interval [l, r) (0-indexed)
f, ti, n, dat = self.f, self.ti, self.n, self.dat
res = ti
l += n
r += n
while l < r:
if l & 1:
res = f(res, dat[l])
l += 1
if r & 1:
r -= 1
res = f(dat[r], res)
l >>= 1
r >>= 1
return res
def gcd(x, y):
if x * y == 0:
return x + y
elif x > y:
return gcd(y, x)
else:
return gcd(y % x, x)
N = int(eval(input()))
A = [int(_) for _ in input().split()]
ST = SegmentTree(array=A, f=gcd, ti=0)
ans = 0
for i in range(N):
ans = max(ans, gcd(ST.query(0, i), ST.query(i + 1, N)))
print(ans)
| false | 1.639344 | [
"-N = int(eval(input()))",
"-A = [int(_) for _ in input().split()]",
"-",
"-",
"- def __init__(self, array, f, e, size):",
"+ def __init__(self, array, f, ti):",
"- e :",
"+ ti :",
"- size : int",
"- limit for array size",
"- self.e = e",
"- self.size = size",
"- self.n = n = len(array)",
"- self.dat = dat = [e] * n + array + [e] * (2 * size - 2 * n)",
"+ self.ti = ti",
"+ self.n = n = 2 ** (len(array).bit_length())",
"+ self.dat = dat = [ti] * n + array + [ti] * (n - len(array))",
"- def modify(self, p, v): # set value at position p (0-indexed)",
"+ def update(self, p, v): # set value at position p (0-indexed)",
"- dat[p >> 1] = f(dat[p], dat[p ^ 1])",
"+ dat[p] = f(dat[p << 1], dat[p << 1 | 1])",
"- f, e, n, dat = self.f, self.e, self.n, self.dat",
"- res = e",
"+ f, ti, n, dat = self.f, self.ti, self.n, self.dat",
"+ res = ti",
"- res = f(res, dat[r])",
"+ res = f(dat[r], res)",
"-gcd = lambda x, y: gcd(y, x) if x < y else gcd(y, x % y) if y else x",
"-e = 0",
"-size = N",
"-ST = SegmentTree(A, f=gcd, e=e, size=size)",
"-ans = 1",
"-for i, a in enumerate(A):",
"- ST.modify(i, 0)",
"- ans = max(ans, ST.query(0, N))",
"- ST.modify(i, a)",
"+def gcd(x, y):",
"+ if x * y == 0:",
"+ return x + y",
"+ elif x > y:",
"+ return gcd(y, x)",
"+ else:",
"+ return gcd(y % x, x)",
"+",
"+",
"+N = int(eval(input()))",
"+A = [int(_) for _ in input().split()]",
"+ST = SegmentTree(array=A, f=gcd, ti=0)",
"+ans = 0",
"+for i in range(N):",
"+ ans = max(ans, gcd(ST.query(0, i), ST.query(i + 1, N)))"
] | false | 0.061665 | 0.064531 | 0.955592 | [
"s505221190",
"s332965982"
] |
u896741788 | p03103 | python | s925758980 | s787690683 | 518 | 312 | 28,652 | 87,664 | Accepted | Accepted | 39.77 | s,p=list(map(int,input().split()))
l=sorted([list(map(int,input().split())) for i in range(s)])
now,budget=0,0
for price,bottles in l:
if now+bottles>=p:print((budget+price*(p-now)));break
else:now+=bottles;budget+=price*bottles
| N,M=list(map(int,input().split()))
l=sorted(list(tuple(map(int,input().split()))for i in range(N)),key=lambda x:x[0])
c=0
ans=0
for v,k in l:
ans+=min(k,M-c)*v
c+=min(k,M-c)
if c==M:
print(ans);exit()
| 6 | 9 | 235 | 223 | s, p = list(map(int, input().split()))
l = sorted([list(map(int, input().split())) for i in range(s)])
now, budget = 0, 0
for price, bottles in l:
if now + bottles >= p:
print((budget + price * (p - now)))
break
else:
now += bottles
budget += price * bottles
| N, M = list(map(int, input().split()))
l = sorted(list(tuple(map(int, input().split())) for i in range(N)), key=lambda x: x[0])
c = 0
ans = 0
for v, k in l:
ans += min(k, M - c) * v
c += min(k, M - c)
if c == M:
print(ans)
exit()
| false | 33.333333 | [
"-s, p = list(map(int, input().split()))",
"-l = sorted([list(map(int, input().split())) for i in range(s)])",
"-now, budget = 0, 0",
"-for price, bottles in l:",
"- if now + bottles >= p:",
"- print((budget + price * (p - now)))",
"- break",
"- else:",
"- now += bottles",
"- budget += price * bottles",
"+N, M = list(map(int, input().split()))",
"+l = sorted(list(tuple(map(int, input().split())) for i in range(N)), key=lambda x: x[0])",
"+c = 0",
"+ans = 0",
"+for v, k in l:",
"+ ans += min(k, M - c) * v",
"+ c += min(k, M - c)",
"+ if c == M:",
"+ print(ans)",
"+ exit()"
] | false | 0.091713 | 0.116099 | 0.789956 | [
"s925758980",
"s787690683"
] |
u745514010 | p02679 | python | s928693755 | s243550971 | 763 | 584 | 55,076 | 158,816 | Accepted | Accepted | 23.46 | from collections import defaultdict
from math import gcd
mod = 1000000007
n = int(eval(input()))
plus = defaultdict(int)
minus = defaultdict(int)
a_0 = 0
b_0 = 0
a_b_0 = 0
xxx = 10 ** 10
for _ in range(n):
a, b = list(map(int, input().split()))
if a == 0 or b == 0:
if a == 0 and b == 0:
a_b_0 += 1
elif a == 0:
a_0 += 1
else:
b_0 += 1
continue
g = gcd(a, b)
a //= g
b //= g
if a * b < 0:
minus[(abs(a), abs(b))] += 1
else:
plus[(abs(b), abs(a))] += 1
total = 0
lst = []
for num, _ in list(minus.items()):
a1 = minus[num]
a2 = plus[num]
if a1 * a2 != 0:
total += a1 + a2
lst.append([a1, a2])
if a_0 > 0 and b_0 > 0:
total += a_0 + b_0
lst.append([a_0, b_0])
n -= a_b_0
ans = pow(2, n - total, mod)
for a, b in lst:
ans = (ans * (pow(2, a, mod) + pow(2, b, mod) - 1)) % mod
ans = (ans - 1 + a_b_0) % mod
print(ans)
| MOD = 10 ** 9 + 7
from math import gcd
from collections import defaultdict
n = int(eval(input()))
plus = defaultdict(int)
minus = defaultdict(int)
zero = [0, 0, 0]
for _ in range(n):
a, b = list(map(int, input().split()))
if a * b == 0:
if a == b == 0:
zero[0] += 1
elif a == 0:
zero[1] += 1
else:
zero[2] += 1
continue
g = gcd(a, b)
a //= g
b //= g
if a < 0:
a *= -1
b *= -1
if b >= 0:
s = str(a) + "-" + str(b)
plus[s] += 1
else:
s = str(-b) + "-" + str(a)
minus[s] += 1
pm = [[zero[1], zero[2]]]
cnt = sum(zero)
for key, value in list(plus.items()):
if minus[key] != 0:
pm.append([value, minus[key]])
cnt += value + minus[key]
ans = pow(2, n - cnt, MOD)
for p, m in pm:
ans *= (pow(2, p, MOD) + pow(2, m, MOD) - 1)
ans %= MOD
ans += zero[0] - 1
ans %= MOD
print(ans)
| 48 | 46 | 1,007 | 985 | from collections import defaultdict
from math import gcd
mod = 1000000007
n = int(eval(input()))
plus = defaultdict(int)
minus = defaultdict(int)
a_0 = 0
b_0 = 0
a_b_0 = 0
xxx = 10**10
for _ in range(n):
a, b = list(map(int, input().split()))
if a == 0 or b == 0:
if a == 0 and b == 0:
a_b_0 += 1
elif a == 0:
a_0 += 1
else:
b_0 += 1
continue
g = gcd(a, b)
a //= g
b //= g
if a * b < 0:
minus[(abs(a), abs(b))] += 1
else:
plus[(abs(b), abs(a))] += 1
total = 0
lst = []
for num, _ in list(minus.items()):
a1 = minus[num]
a2 = plus[num]
if a1 * a2 != 0:
total += a1 + a2
lst.append([a1, a2])
if a_0 > 0 and b_0 > 0:
total += a_0 + b_0
lst.append([a_0, b_0])
n -= a_b_0
ans = pow(2, n - total, mod)
for a, b in lst:
ans = (ans * (pow(2, a, mod) + pow(2, b, mod) - 1)) % mod
ans = (ans - 1 + a_b_0) % mod
print(ans)
| MOD = 10**9 + 7
from math import gcd
from collections import defaultdict
n = int(eval(input()))
plus = defaultdict(int)
minus = defaultdict(int)
zero = [0, 0, 0]
for _ in range(n):
a, b = list(map(int, input().split()))
if a * b == 0:
if a == b == 0:
zero[0] += 1
elif a == 0:
zero[1] += 1
else:
zero[2] += 1
continue
g = gcd(a, b)
a //= g
b //= g
if a < 0:
a *= -1
b *= -1
if b >= 0:
s = str(a) + "-" + str(b)
plus[s] += 1
else:
s = str(-b) + "-" + str(a)
minus[s] += 1
pm = [[zero[1], zero[2]]]
cnt = sum(zero)
for key, value in list(plus.items()):
if minus[key] != 0:
pm.append([value, minus[key]])
cnt += value + minus[key]
ans = pow(2, n - cnt, MOD)
for p, m in pm:
ans *= pow(2, p, MOD) + pow(2, m, MOD) - 1
ans %= MOD
ans += zero[0] - 1
ans %= MOD
print(ans)
| false | 4.166667 | [
"+MOD = 10**9 + 7",
"+from math import gcd",
"-from math import gcd",
"-mod = 1000000007",
"-a_0 = 0",
"-b_0 = 0",
"-a_b_0 = 0",
"-xxx = 10**10",
"+zero = [0, 0, 0]",
"- if a == 0 or b == 0:",
"- if a == 0 and b == 0:",
"- a_b_0 += 1",
"+ if a * b == 0:",
"+ if a == b == 0:",
"+ zero[0] += 1",
"- a_0 += 1",
"+ zero[1] += 1",
"- b_0 += 1",
"+ zero[2] += 1",
"- if a * b < 0:",
"- minus[(abs(a), abs(b))] += 1",
"+ if a < 0:",
"+ a *= -1",
"+ b *= -1",
"+ if b >= 0:",
"+ s = str(a) + \"-\" + str(b)",
"+ plus[s] += 1",
"- plus[(abs(b), abs(a))] += 1",
"-total = 0",
"-lst = []",
"-for num, _ in list(minus.items()):",
"- a1 = minus[num]",
"- a2 = plus[num]",
"- if a1 * a2 != 0:",
"- total += a1 + a2",
"- lst.append([a1, a2])",
"-if a_0 > 0 and b_0 > 0:",
"- total += a_0 + b_0",
"- lst.append([a_0, b_0])",
"-n -= a_b_0",
"-ans = pow(2, n - total, mod)",
"-for a, b in lst:",
"- ans = (ans * (pow(2, a, mod) + pow(2, b, mod) - 1)) % mod",
"-ans = (ans - 1 + a_b_0) % mod",
"+ s = str(-b) + \"-\" + str(a)",
"+ minus[s] += 1",
"+pm = [[zero[1], zero[2]]]",
"+cnt = sum(zero)",
"+for key, value in list(plus.items()):",
"+ if minus[key] != 0:",
"+ pm.append([value, minus[key]])",
"+ cnt += value + minus[key]",
"+ans = pow(2, n - cnt, MOD)",
"+for p, m in pm:",
"+ ans *= pow(2, p, MOD) + pow(2, m, MOD) - 1",
"+ ans %= MOD",
"+ans += zero[0] - 1",
"+ans %= MOD"
] | false | 0.074602 | 0.037077 | 2.012072 | [
"s928693755",
"s243550971"
] |
u697559326 | p03160 | python | s249236192 | s990840239 | 152 | 126 | 13,884 | 13,592 | Accepted | Accepted | 17.11 | import sys
input = sys.stdin.readline
def main():
#1:初期化
N = int(eval(input()))
#h = list(map(int, input().split()))
h = [int(x) for x in input().split()]
inf = float("inf")
dp = [inf]*(N)
#2:初期値
dp[0] = 0
#3:dp実行部(貰うDP)
for i in range(1,N):
dp[i] = min(dp[i], dp[i-1] + abs(h[i] - h[i-1]))
if(i>1): #2つ目の足場には二個前の足場がないので．
dp[i] = min(dp[i], dp[i-2] + abs(h[i] - h[i-2]))
# #3:dp実行部(配るDP)
# for i in range(N):
# if(i+1<N):
# dp[i+1] = min(dp[i+1], dp[i] + abs(h[i] - h[i+1]))
# if(i+2<N):
# dp[i+2] = min(dp[i+2], dp[i] + abs(h[i] - h[i+2]))
#4:出力
print((dp[N-1]))
if __name__ == '__main__':
main() | import sys
input = sys.stdin.readline
def main():
#1:初期化
N = int(eval(input()))
h = list(map(int, input().split()))
#h = [int(x) for x in input().split()]
inf = float("inf")
dp = [inf]*(N)
#2:初期値
dp[0] = 0
#3:dp実行部(貰うDP)
for i in range(1,N):
dp[i] = min(dp[i], dp[i-1] + abs(h[i] - h[i-1]))
if(i>1): #2つ目の足場には二個前の足場がないので．
dp[i] = min(dp[i], dp[i-2] + abs(h[i] - h[i-2]))
# #3:dp実行部(配るDP)
# for i in range(N):
# if(i+1<N):
# dp[i+1] = min(dp[i+1], dp[i] + abs(h[i] - h[i+1]))
# if(i+2<N):
# dp[i+2] = min(dp[i+2], dp[i] + abs(h[i] - h[i+2]))
#4:出力
print((dp[N-1]))
if __name__ == '__main__':
main() | 32 | 32 | 754 | 754 | import sys
input = sys.stdin.readline
def main():
# 1:初期化
N = int(eval(input()))
# h = list(map(int, input().split()))
h = [int(x) for x in input().split()]
inf = float("inf")
dp = [inf] * (N)
# 2:初期値
dp[0] = 0
# 3:dp実行部(貰うDP)
for i in range(1, N):
dp[i] = min(dp[i], dp[i - 1] + abs(h[i] - h[i - 1]))
if i > 1: # 2つ目の足場には二個前の足場がないので．
dp[i] = min(dp[i], dp[i - 2] + abs(h[i] - h[i - 2]))
# #3:dp実行部(配るDP)
# for i in range(N):
# if(i+1<N):
# dp[i+1] = min(dp[i+1], dp[i] + abs(h[i] - h[i+1]))
# if(i+2<N):
# dp[i+2] = min(dp[i+2], dp[i] + abs(h[i] - h[i+2]))
# 4:出力
print((dp[N - 1]))
if __name__ == "__main__":
main()
| import sys
input = sys.stdin.readline
def main():
# 1:初期化
N = int(eval(input()))
h = list(map(int, input().split()))
# h = [int(x) for x in input().split()]
inf = float("inf")
dp = [inf] * (N)
# 2:初期値
dp[0] = 0
# 3:dp実行部(貰うDP)
for i in range(1, N):
dp[i] = min(dp[i], dp[i - 1] + abs(h[i] - h[i - 1]))
if i > 1: # 2つ目の足場には二個前の足場がないので．
dp[i] = min(dp[i], dp[i - 2] + abs(h[i] - h[i - 2]))
# #3:dp実行部(配るDP)
# for i in range(N):
# if(i+1<N):
# dp[i+1] = min(dp[i+1], dp[i] + abs(h[i] - h[i+1]))
# if(i+2<N):
# dp[i+2] = min(dp[i+2], dp[i] + abs(h[i] - h[i+2]))
# 4:出力
print((dp[N - 1]))
if __name__ == "__main__":
main()
| false | 0 | [
"- # h = list(map(int, input().split()))",
"- h = [int(x) for x in input().split()]",
"+ h = list(map(int, input().split()))",
"+ # h = [int(x) for x in input().split()]"
] | false | 0.040838 | 0.059637 | 0.684767 | [
"s249236192",
"s990840239"
] |
u238940874 | p03308 | python | s401830180 | s095038606 | 21 | 17 | 3,060 | 2,940 | Accepted | Accepted | 19.05 | n=int(eval(input()))
a=list(map(int,input().split()))
ans=0
for i in range(n):
for j in range(n-1):
temp=abs(a[i]-a[j])
ans=max(ans,temp)
print(ans) | n=int(eval(input()))
a=list(map(int,input().split()))
print((max(a)-min(a))) | 8 | 3 | 169 | 70 | n = int(eval(input()))
a = list(map(int, input().split()))
ans = 0
for i in range(n):
for j in range(n - 1):
temp = abs(a[i] - a[j])
ans = max(ans, temp)
print(ans)
| n = int(eval(input()))
a = list(map(int, input().split()))
print((max(a) - min(a)))
| false | 62.5 | [
"-ans = 0",
"-for i in range(n):",
"- for j in range(n - 1):",
"- temp = abs(a[i] - a[j])",
"- ans = max(ans, temp)",
"-print(ans)",
"+print((max(a) - min(a)))"
] | false | 0.047262 | 0.046233 | 1.022244 | [
"s401830180",
"s095038606"
] |
u690326927 | p03288 | python | s041086256 | s056762251 | 20 | 17 | 2,940 | 2,940 | Accepted | Accepted | 15 | R = int(eval(input()))
if R < 1200:
print('ABC')
elif 1200 <= R < 2800:
print('ARC')
else:
print('AGC') | R = int(eval(input()))
print(('ABC' if R < 1200 else 'ARC' if 1200 <= R < 2800 else 'AGC'))
| 8 | 2 | 117 | 85 | R = int(eval(input()))
if R < 1200:
print("ABC")
elif 1200 <= R < 2800:
print("ARC")
else:
print("AGC")
| R = int(eval(input()))
print(("ABC" if R < 1200 else "ARC" if 1200 <= R < 2800 else "AGC"))
| false | 75 | [
"-if R < 1200:",
"- print(\"ABC\")",
"-elif 1200 <= R < 2800:",
"- print(\"ARC\")",
"-else:",
"- print(\"AGC\")",
"+print((\"ABC\" if R < 1200 else \"ARC\" if 1200 <= R < 2800 else \"AGC\"))"
] | false | 0.048063 | 0.047482 | 1.01223 | [
"s041086256",
"s056762251"
] |
u086503932 | p03309 | python | s231941955 | s390061097 | 186 | 164 | 26,832 | 30,932 | Accepted | Accepted | 11.83 | #!/usr/bin/env python3
import math
def main():
N = int(eval(input()))
A = list(map(int, input().split()))
A = [A[i] - i - 1 for i in range(N)]
A.sort()
diff = A[(N-1)//2]
print((sum([abs(a-diff) for a in A])))
if __name__ == "__main__":
main()
| N = int(eval(input()))
A = list(map(int, input().split()))
for i in range(N):
A[i] -= i+1
A.sort()
b = A[(N-1)//2]
ans = 0
for i in range(N):
ans += abs(A[i]-b)
print(ans) | 14 | 11 | 280 | 182 | #!/usr/bin/env python3
import math
def main():
N = int(eval(input()))
A = list(map(int, input().split()))
A = [A[i] - i - 1 for i in range(N)]
A.sort()
diff = A[(N - 1) // 2]
print((sum([abs(a - diff) for a in A])))
if __name__ == "__main__":
main()
| N = int(eval(input()))
A = list(map(int, input().split()))
for i in range(N):
A[i] -= i + 1
A.sort()
b = A[(N - 1) // 2]
ans = 0
for i in range(N):
ans += abs(A[i] - b)
print(ans)
| false | 21.428571 | [
"-#!/usr/bin/env python3",
"-import math",
"-",
"-",
"-def main():",
"- N = int(eval(input()))",
"- A = list(map(int, input().split()))",
"- A = [A[i] - i - 1 for i in range(N)]",
"- A.sort()",
"- diff = A[(N - 1) // 2]",
"- print((sum([abs(a - diff) for a in A])))",
"-",
"-",
"-if __name__ == \"__main__\":",
"- main()",
"+N = int(eval(input()))",
"+A = list(map(int, input().split()))",
"+for i in range(N):",
"+ A[i] -= i + 1",
"+A.sort()",
"+b = A[(N - 1) // 2]",
"+ans = 0",
"+for i in range(N):",
"+ ans += abs(A[i] - b)",
"+print(ans)"
] | false | 0.079786 | 0.043962 | 1.814902 | [
"s231941955",
"s390061097"
] |
u347640436 | p03167 | python | s782863673 | s650133955 | 699 | 256 | 43,648 | 43,632 | Accepted | Accepted | 63.38 | def main():
divisor = 10 ** 9 + 7
h, w = list(map(int, input().split()))
a = [eval(input()) for _ in range(h)]
dp = [[0] * w for _ in range(h)]
dp[0][0] = 1
for i in range(h):
ai = a[i]
dpi = dp[i]
if i + 1 < h:
ai1 = a[i + 1]
dpi1 = dp[i + 1]
for j in range(w):
if i + 1 < h and ai1[j] != '#':
dpi1[j] = (dpi1[j] + dpi[j]) % divisor
if j + 1 < w and ai[j + 1] != '#':
dpi[j + 1] = (dpi[j + 1] + dpi[j]) % divisor
print((dp[h - 1][w - 1]))
main() | def main():
divisor = 10 ** 9 + 7
h, w = list(map(int, input().split()))
a = [eval(input()) for _ in range(h)]
dp = [[0] * w for _ in range(h)]
dp[0][0] = 1
dp0 = dp[0]
a0 = a[0]
for j in range(1, w):
if a0[j] != '#':
dp0[j] = dp0[j - 1]
for i in range(1, h):
dpi = dp[i]
dpi1 = dp[i - 1]
ai = a[i]
if ai[0] != '#':
dpi[0] = dpi1[0]
for j in range(1, w):
if ai[j] != '#':
dpi[j] = (dpi1[j] + dpi[j - 1]) % divisor
print((dp[h - 1][w - 1]))
main()
| 19 | 22 | 528 | 524 | def main():
divisor = 10**9 + 7
h, w = list(map(int, input().split()))
a = [eval(input()) for _ in range(h)]
dp = [[0] * w for _ in range(h)]
dp[0][0] = 1
for i in range(h):
ai = a[i]
dpi = dp[i]
if i + 1 < h:
ai1 = a[i + 1]
dpi1 = dp[i + 1]
for j in range(w):
if i + 1 < h and ai1[j] != "#":
dpi1[j] = (dpi1[j] + dpi[j]) % divisor
if j + 1 < w and ai[j + 1] != "#":
dpi[j + 1] = (dpi[j + 1] + dpi[j]) % divisor
print((dp[h - 1][w - 1]))
main()
| def main():
divisor = 10**9 + 7
h, w = list(map(int, input().split()))
a = [eval(input()) for _ in range(h)]
dp = [[0] * w for _ in range(h)]
dp[0][0] = 1
dp0 = dp[0]
a0 = a[0]
for j in range(1, w):
if a0[j] != "#":
dp0[j] = dp0[j - 1]
for i in range(1, h):
dpi = dp[i]
dpi1 = dp[i - 1]
ai = a[i]
if ai[0] != "#":
dpi[0] = dpi1[0]
for j in range(1, w):
if ai[j] != "#":
dpi[j] = (dpi1[j] + dpi[j - 1]) % divisor
print((dp[h - 1][w - 1]))
main()
| false | 13.636364 | [
"- for i in range(h):",
"+ dp0 = dp[0]",
"+ a0 = a[0]",
"+ for j in range(1, w):",
"+ if a0[j] != \"#\":",
"+ dp0[j] = dp0[j - 1]",
"+ for i in range(1, h):",
"+ dpi = dp[i]",
"+ dpi1 = dp[i - 1]",
"- dpi = dp[i]",
"- if i + 1 < h:",
"- ai1 = a[i + 1]",
"- dpi1 = dp[i + 1]",
"- for j in range(w):",
"- if i + 1 < h and ai1[j] != \"#\":",
"- dpi1[j] = (dpi1[j] + dpi[j]) % divisor",
"- if j + 1 < w and ai[j + 1] != \"#\":",
"- dpi[j + 1] = (dpi[j + 1] + dpi[j]) % divisor",
"+ if ai[0] != \"#\":",
"+ dpi[0] = dpi1[0]",
"+ for j in range(1, w):",
"+ if ai[j] != \"#\":",
"+ dpi[j] = (dpi1[j] + dpi[j - 1]) % divisor"
] | false | 0.037358 | 0.062535 | 0.597404 | [
"s782863673",
"s650133955"
] |
u941407962 | p03716 | python | s457826132 | s397588725 | 1,898 | 553 | 126,552 | 120,592 | Accepted | Accepted | 70.86 | # ABC140E
class SegTree:
def __init__(self, init_val, ide_ele, seg_func):
self.segfunc = seg_func
N = len(init_val)
self.num = 2**(N-1).bit_length()
self.ide_ele = ide_ele
self.seg=[self.ide_ele]*2*self.num
for i in range(N):
self.seg[i+self.num-1]=init_val[i]
for i in range(self.num-2,-1,-1) :
self.seg[i]=self.segfunc(self.seg[2*i+1],self.seg[2*i+2])
def update(self, k, x):
k += self.num-1
self.seg[k] = x
while k+1:
k = (k-1)//2
self.seg[k] = self.segfunc(self.seg[k*2+1],self.seg[k*2+2])
def query(self, p, q):
if q<=p:
return self.ide_ele
p += self.num-1
q += self.num-2
res=self.ide_ele
while q-p>1:
if p&1 == 0:
res = self.segfunc(res,self.seg[p])
if q&1 == 1:
res = self.segfunc(res,self.seg[q])
q -= 1
p = p//2
q = (q-1)//2
if p == q:
res = self.segfunc(res,self.seg[p])
else:
res = self.segfunc(self.segfunc(res,self.seg[p]),self.seg[q])
return res
N, = list(map(int, input().split()))
A = list(map(int, input().split()))
B = sorted([(a, i) for i, a in enumerate(A)], key=lambda x:x[0])
z = dict()
for i, (b, j) in enumerate(B):
z[(b, j)] = i
ss = SegTree([3*N]*3*N, 3*N, min)
bs = []
y = 0
for i, x in enumerate(A):
if i == 2*N:
break
ss.update(z[(x, i)], z[(x, i)])
y += x
if i < N-1:
continue
if i == N-1:
bs.append(y)
else:
mx = ss.query(0, 3*N)
y = y - B[mx][0]
ss.update(mx, 3*N)
bs.append(y)
ss = SegTree([-1]*3*N, -1, max)
nbs = []
#tmp = set()
y = 0
for i, x in enumerate(A[::-1]):
if i == 2*N:
break
ss.update(z[(x, 3*N-i-1)], z[(x, 3*N-i-1)])
# tmp.add((x, i))
y += x
if i < N-1:
continue
if i == N-1:
nbs.append(y)
else:
mx = ss.query(0, 3*N)
# print(max(tmp), B[mx])
# tmp.remove(max(tmp))
y = y - B[mx][0]
ss.update(mx, -1)
nbs.append(y)
#print(B)
#print(bs)
#print(nbs)
r = -10**18
for i in range(N+1):
r = max(r, bs[i] - nbs[N-i])
print(r)
| from heapq import *
N, = list(map(int, input().split()))
A = list(map(int, input().split()))
s = sum(A[:N])
rs = [s] + [0] * N
l = []
for i in range(N):
heappush(l, A[i])
for i in range(N, 2*N):
s += A[i]
heappush(l, A[i])
x = heappop(l)
s -= x
rs[i-N+1] = s
l2 = []
s2 = 0
for i in range(2*N, 3*N):
heappush(l2, -A[i])
s2+=A[i]
rs2 = [0] * N + [s2]
for i in range(2*N-1, N-1, -1):
s2 += A[i]
heappush(l2, -A[i])
x = -heappop(l2)
# print(A[i])
# print(x)
s2 -= x
rs2[i-N] = s2
#print(rs2)
r = -10**18
for i in range(N+1):
c = rs[i] - rs2[i]
r = max(c, r)
print(r)
| 93 | 35 | 2,401 | 659 | # ABC140E
class SegTree:
def __init__(self, init_val, ide_ele, seg_func):
self.segfunc = seg_func
N = len(init_val)
self.num = 2 ** (N - 1).bit_length()
self.ide_ele = ide_ele
self.seg = [self.ide_ele] * 2 * self.num
for i in range(N):
self.seg[i + self.num - 1] = init_val[i]
for i in range(self.num - 2, -1, -1):
self.seg[i] = self.segfunc(self.seg[2 * i + 1], self.seg[2 * i + 2])
def update(self, k, x):
k += self.num - 1
self.seg[k] = x
while k + 1:
k = (k - 1) // 2
self.seg[k] = self.segfunc(self.seg[k * 2 + 1], self.seg[k * 2 + 2])
def query(self, p, q):
if q <= p:
return self.ide_ele
p += self.num - 1
q += self.num - 2
res = self.ide_ele
while q - p > 1:
if p & 1 == 0:
res = self.segfunc(res, self.seg[p])
if q & 1 == 1:
res = self.segfunc(res, self.seg[q])
q -= 1
p = p // 2
q = (q - 1) // 2
if p == q:
res = self.segfunc(res, self.seg[p])
else:
res = self.segfunc(self.segfunc(res, self.seg[p]), self.seg[q])
return res
(N,) = list(map(int, input().split()))
A = list(map(int, input().split()))
B = sorted([(a, i) for i, a in enumerate(A)], key=lambda x: x[0])
z = dict()
for i, (b, j) in enumerate(B):
z[(b, j)] = i
ss = SegTree([3 * N] * 3 * N, 3 * N, min)
bs = []
y = 0
for i, x in enumerate(A):
if i == 2 * N:
break
ss.update(z[(x, i)], z[(x, i)])
y += x
if i < N - 1:
continue
if i == N - 1:
bs.append(y)
else:
mx = ss.query(0, 3 * N)
y = y - B[mx][0]
ss.update(mx, 3 * N)
bs.append(y)
ss = SegTree([-1] * 3 * N, -1, max)
nbs = []
# tmp = set()
y = 0
for i, x in enumerate(A[::-1]):
if i == 2 * N:
break
ss.update(z[(x, 3 * N - i - 1)], z[(x, 3 * N - i - 1)])
# tmp.add((x, i))
y += x
if i < N - 1:
continue
if i == N - 1:
nbs.append(y)
else:
mx = ss.query(0, 3 * N)
# print(max(tmp), B[mx])
# tmp.remove(max(tmp))
y = y - B[mx][0]
ss.update(mx, -1)
nbs.append(y)
# print(B)
# print(bs)
# print(nbs)
r = -(10**18)
for i in range(N + 1):
r = max(r, bs[i] - nbs[N - i])
print(r)
| from heapq import *
(N,) = list(map(int, input().split()))
A = list(map(int, input().split()))
s = sum(A[:N])
rs = [s] + [0] * N
l = []
for i in range(N):
heappush(l, A[i])
for i in range(N, 2 * N):
s += A[i]
heappush(l, A[i])
x = heappop(l)
s -= x
rs[i - N + 1] = s
l2 = []
s2 = 0
for i in range(2 * N, 3 * N):
heappush(l2, -A[i])
s2 += A[i]
rs2 = [0] * N + [s2]
for i in range(2 * N - 1, N - 1, -1):
s2 += A[i]
heappush(l2, -A[i])
x = -heappop(l2)
# print(A[i])
# print(x)
s2 -= x
rs2[i - N] = s2
# print(rs2)
r = -(10**18)
for i in range(N + 1):
c = rs[i] - rs2[i]
r = max(c, r)
print(r)
| false | 62.365591 | [
"-# ABC140E",
"-class SegTree:",
"- def __init__(self, init_val, ide_ele, seg_func):",
"- self.segfunc = seg_func",
"- N = len(init_val)",
"- self.num = 2 ** (N - 1).bit_length()",
"- self.ide_ele = ide_ele",
"- self.seg = [self.ide_ele] * 2 * self.num",
"- for i in range(N):",
"- self.seg[i + self.num - 1] = init_val[i]",
"- for i in range(self.num - 2, -1, -1):",
"- self.seg[i] = self.segfunc(self.seg[2 * i + 1], self.seg[2 * i + 2])",
"-",
"- def update(self, k, x):",
"- k += self.num - 1",
"- self.seg[k] = x",
"- while k + 1:",
"- k = (k - 1) // 2",
"- self.seg[k] = self.segfunc(self.seg[k * 2 + 1], self.seg[k * 2 + 2])",
"-",
"- def query(self, p, q):",
"- if q <= p:",
"- return self.ide_ele",
"- p += self.num - 1",
"- q += self.num - 2",
"- res = self.ide_ele",
"- while q - p > 1:",
"- if p & 1 == 0:",
"- res = self.segfunc(res, self.seg[p])",
"- if q & 1 == 1:",
"- res = self.segfunc(res, self.seg[q])",
"- q -= 1",
"- p = p // 2",
"- q = (q - 1) // 2",
"- if p == q:",
"- res = self.segfunc(res, self.seg[p])",
"- else:",
"- res = self.segfunc(self.segfunc(res, self.seg[p]), self.seg[q])",
"- return res",
"-",
"+from heapq import *",
"-B = sorted([(a, i) for i, a in enumerate(A)], key=lambda x: x[0])",
"-z = dict()",
"-for i, (b, j) in enumerate(B):",
"- z[(b, j)] = i",
"-ss = SegTree([3 * N] * 3 * N, 3 * N, min)",
"-bs = []",
"-y = 0",
"-for i, x in enumerate(A):",
"- if i == 2 * N:",
"- break",
"- ss.update(z[(x, i)], z[(x, i)])",
"- y += x",
"- if i < N - 1:",
"- continue",
"- if i == N - 1:",
"- bs.append(y)",
"- else:",
"- mx = ss.query(0, 3 * N)",
"- y = y - B[mx][0]",
"- ss.update(mx, 3 * N)",
"- bs.append(y)",
"-ss = SegTree([-1] * 3 * N, -1, max)",
"-nbs = []",
"-# tmp = set()",
"-y = 0",
"-for i, x in enumerate(A[::-1]):",
"- if i == 2 * N:",
"- break",
"- ss.update(z[(x, 3 * N - i - 1)], z[(x, 3 * N - i - 1)])",
"- # tmp.add((x, i))",
"- y += x",
"- if i < N - 1:",
"- continue",
"- if i == N - 1:",
"- nbs.append(y)",
"- else:",
"- mx = ss.query(0, 3 * N)",
"- # print(max(tmp), B[mx])",
"- # tmp.remove(max(tmp))",
"- y = y - B[mx][0]",
"- ss.update(mx, -1)",
"- nbs.append(y)",
"-# print(B)",
"-# print(bs)",
"-# print(nbs)",
"+s = sum(A[:N])",
"+rs = [s] + [0] * N",
"+l = []",
"+for i in range(N):",
"+ heappush(l, A[i])",
"+for i in range(N, 2 * N):",
"+ s += A[i]",
"+ heappush(l, A[i])",
"+ x = heappop(l)",
"+ s -= x",
"+ rs[i - N + 1] = s",
"+l2 = []",
"+s2 = 0",
"+for i in range(2 * N, 3 * N):",
"+ heappush(l2, -A[i])",
"+ s2 += A[i]",
"+rs2 = [0] * N + [s2]",
"+for i in range(2 * N - 1, N - 1, -1):",
"+ s2 += A[i]",
"+ heappush(l2, -A[i])",
"+ x = -heappop(l2)",
"+ # print(A[i])",
"+ # print(x)",
"+ s2 -= x",
"+ rs2[i - N] = s2",
"+# print(rs2)",
"- r = max(r, bs[i] - nbs[N - i])",
"+ c = rs[i] - rs2[i]",
"+ r = max(c, r)"
] | false | 0.040757 | 0.041087 | 0.99195 | [
"s457826132",
"s397588725"
] |
u553987207 | p02614 | python | s216907276 | s128089494 | 60 | 51 | 9,212 | 9,112 | Accepted | Accepted | 15 | H, W, K = list(map(int, input().split()))
C = [[1 if c == "#" else 0 for c in eval(input())] for _ in range(H)]
ans = 0
for bith in range(1 << H):
for bitw in range(1 << W):
c = [x[:] for x in C]
for h in range(H):
if bith & (1 << h):
c[h] = [0] * W
for w in range(W):
if bitw & (1 << w):
for h in range(H):
c[h][w] = 0
count = sum(sum(x) for x in c)
if count == K:
ans += 1
print(ans) | H, W, K = list(map(int, input().split()))
M = [[1 if c == "#" else 0 for c in eval(input())] for _ in range(H)]
ans = 0
for hselection in range(1 << H):
for wselection in range(1 << W):
count = 0
for h in range(H):
if hselection & (1 << h):
continue
for w in range(W):
if wselection & (1 << w):
continue
count += M[h][w]
if count == K:
ans += 1
print(ans) | 17 | 17 | 521 | 492 | H, W, K = list(map(int, input().split()))
C = [[1 if c == "#" else 0 for c in eval(input())] for _ in range(H)]
ans = 0
for bith in range(1 << H):
for bitw in range(1 << W):
c = [x[:] for x in C]
for h in range(H):
if bith & (1 << h):
c[h] = [0] * W
for w in range(W):
if bitw & (1 << w):
for h in range(H):
c[h][w] = 0
count = sum(sum(x) for x in c)
if count == K:
ans += 1
print(ans)
| H, W, K = list(map(int, input().split()))
M = [[1 if c == "#" else 0 for c in eval(input())] for _ in range(H)]
ans = 0
for hselection in range(1 << H):
for wselection in range(1 << W):
count = 0
for h in range(H):
if hselection & (1 << h):
continue
for w in range(W):
if wselection & (1 << w):
continue
count += M[h][w]
if count == K:
ans += 1
print(ans)
| false | 0 | [
"-C = [[1 if c == \"#\" else 0 for c in eval(input())] for _ in range(H)]",
"+M = [[1 if c == \"#\" else 0 for c in eval(input())] for _ in range(H)]",
"-for bith in range(1 << H):",
"- for bitw in range(1 << W):",
"- c = [x[:] for x in C]",
"+for hselection in range(1 << H):",
"+ for wselection in range(1 << W):",
"+ count = 0",
"- if bith & (1 << h):",
"- c[h] = [0] * W",
"- for w in range(W):",
"- if bitw & (1 << w):",
"- for h in range(H):",
"- c[h][w] = 0",
"- count = sum(sum(x) for x in c)",
"+ if hselection & (1 << h):",
"+ continue",
"+ for w in range(W):",
"+ if wselection & (1 << w):",
"+ continue",
"+ count += M[h][w]"
] | false | 0.087526 | 0.050052 | 1.748706 | [
"s216907276",
"s128089494"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.