user_id
stringlengths 10
10
| problem_id
stringlengths 6
6
| language
stringclasses 1
value | submission_id_v0
stringlengths 10
10
| submission_id_v1
stringlengths 10
10
| cpu_time_v0
int64 10
38.3k
| cpu_time_v1
int64 0
24.7k
| memory_v0
int64 2.57k
1.02M
| memory_v1
int64 2.57k
869k
| status_v0
stringclasses 1
value | status_v1
stringclasses 1
value | improvement_frac
float64 7.51
100
| input
stringlengths 20
4.55k
| target
stringlengths 17
3.34k
| code_v0_loc
int64 1
148
| code_v1_loc
int64 1
184
| code_v0_num_chars
int64 13
4.55k
| code_v1_num_chars
int64 14
3.34k
| code_v0_no_empty_lines
stringlengths 21
6.88k
| code_v1_no_empty_lines
stringlengths 20
4.93k
| code_same
bool 1
class | relative_loc_diff_percent
float64 0
79.8
| diff
sequence | diff_only_import_comment
bool 1
class | measured_runtime_v0
float64 0.01
4.45
| measured_runtime_v1
float64 0.01
4.31
| runtime_lift
float64 0
359
| key
sequence |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
u057109575 | p03240 | python | s478186563 | s374851207 | 299 | 39 | 3,064 | 3,060 | Accepted | Accepted | 86.96 | N = int(eval(input()))
X = [list(map(int, input().split())) for _ in range(N)]
C_x = list(range(101))
C_y = list(range(101))
if sum([h for _, _, h in X]) == 1:
for x, y, h in X:
if h != 0:
print((x, y, h))
else:
for px in C_x:
for py in C_y:
h_list = [abs(x - px) + abs(y - py) + h for x, y, h in X if h > 0]
if len(set(h_list)) == 1:
print((px, py, h_list[0]))
break | N = int(eval(input()))
X = [list(map(int, input().split())) for _ in range(N)]
X.sort(key=lambda x: x[2])
a, b, c = X[-1]
for px in range(101):
for py in range(101):
H = abs(a - px) + abs(b - py) + c
if all(h == max(H - abs(x - px) - abs(y - py), 0) for x, y, h in X):
print((px, py, H))
break
| 16 | 11 | 420 | 329 | N = int(eval(input()))
X = [list(map(int, input().split())) for _ in range(N)]
C_x = list(range(101))
C_y = list(range(101))
if sum([h for _, _, h in X]) == 1:
for x, y, h in X:
if h != 0:
print((x, y, h))
else:
for px in C_x:
for py in C_y:
h_list = [abs(x - px) + abs(y - py) + h for x, y, h in X if h > 0]
if len(set(h_list)) == 1:
print((px, py, h_list[0]))
break
| N = int(eval(input()))
X = [list(map(int, input().split())) for _ in range(N)]
X.sort(key=lambda x: x[2])
a, b, c = X[-1]
for px in range(101):
for py in range(101):
H = abs(a - px) + abs(b - py) + c
if all(h == max(H - abs(x - px) - abs(y - py), 0) for x, y, h in X):
print((px, py, H))
break
| false | 31.25 | [
"-C_x = list(range(101))",
"-C_y = list(range(101))",
"-if sum([h for _, _, h in X]) == 1:",
"- for x, y, h in X:",
"- if h != 0:",
"- print((x, y, h))",
"-else:",
"- for px in C_x:",
"- for py in C_y:",
"- h_list = [abs(x - px) + abs(y - py) + h for x, y, h in X if h > 0]",
"- if len(set(h_list)) == 1:",
"- print((px, py, h_list[0]))",
"- break",
"+X.sort(key=lambda x: x[2])",
"+a, b, c = X[-1]",
"+for px in range(101):",
"+ for py in range(101):",
"+ H = abs(a - px) + abs(b - py) + c",
"+ if all(h == max(H - abs(x - px) - abs(y - py), 0) for x, y, h in X):",
"+ print((px, py, H))",
"+ break"
] | false | 0.170319 | 0.063303 | 2.690542 | [
"s478186563",
"s374851207"
] |
u870575557 | p02720 | python | s397017393 | s077591815 | 175 | 153 | 16,628 | 12,404 | Accepted | Accepted | 12.57 | from collections import deque
k = int(eval(input()))
d = deque([1,2,3,4,5,6,7,8,9])
ans = []
while len(ans) < k:
a = d.popleft()
ans.append(a)
l = [a%10-1, a%10, a%10+1]
for i in l:
if i==-1 or i==10:
continue
d.append(a*10 + i)
print((ans[k-1])) | from collections import deque
k = int(eval(input()))
d = deque([1,2,3,4,5,6,7,8,9])
for i in range(k):
a = d.popleft()
l = [a%10-1, a%10, a%10+1]
for j in l:
if j==-1 or j==10:
continue
d.append(a*10 + j)
print(a) | 15 | 13 | 298 | 261 | from collections import deque
k = int(eval(input()))
d = deque([1, 2, 3, 4, 5, 6, 7, 8, 9])
ans = []
while len(ans) < k:
a = d.popleft()
ans.append(a)
l = [a % 10 - 1, a % 10, a % 10 + 1]
for i in l:
if i == -1 or i == 10:
continue
d.append(a * 10 + i)
print((ans[k - 1]))
| from collections import deque
k = int(eval(input()))
d = deque([1, 2, 3, 4, 5, 6, 7, 8, 9])
for i in range(k):
a = d.popleft()
l = [a % 10 - 1, a % 10, a % 10 + 1]
for j in l:
if j == -1 or j == 10:
continue
d.append(a * 10 + j)
print(a)
| false | 13.333333 | [
"-ans = []",
"-while len(ans) < k:",
"+for i in range(k):",
"- ans.append(a)",
"- for i in l:",
"- if i == -1 or i == 10:",
"+ for j in l:",
"+ if j == -1 or j == 10:",
"- d.append(a * 10 + i)",
"-print((ans[k - 1]))",
"+ d.append(a * 10 + j)",
"+print(a)"
] | false | 0.088838 | 0.084735 | 1.048413 | [
"s397017393",
"s077591815"
] |
u588341295 | p03780 | python | s599814107 | s053991457 | 979 | 601 | 37,004 | 12,608 | Accepted | Accepted | 38.61 | # -*- coding: utf-8 -*-
import sys
import numpy as np
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(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(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
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
def bisearch_min(mn, mx, func):
""" 条件を満たす最小値を見つける二分探索 """
ok = mx
ng = mn
while ng+1 < ok:
mid = (ok+ng) // 2
if func(mid):
# 下を探しに行く
ok = mid
else:
# 上を探しに行く
ng = mid
return ok
N, K = MAP()
A = LIST()
def check(omit):
# 部分和DP
dp = np.zeros((N+1, K), dtype=np.bool)
dp[0,0] = 1
for i in range(N):
# まとめて遷移
dp[i+1] = np.logical_or(dp[i+1], dp[i])
if i != omit and A[i] < K:
dp[i+1,A[i]:] = np.logical_or(dp[i+1,A[i]:], dp[i,:K-A[i]])
# 今回の値A[omit]を足してKに到達できるような部分和があれば、これは必要
for j in range(max(0, K-A[omit]), K):
if dp[N,j]:
return True
# なければ不要
return False
A.sort()
print((bisearch_min(-1, N, check)))
| # -*- coding: utf-8 -*-
import sys
import numpy as np
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(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(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
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
def bisearch_min(mn, mx, func):
""" 条件を満たす最小値を見つける二分探索 """
ok = mx
ng = mn
while ng+1 < ok:
mid = (ok+ng) // 2
if func(mid):
# 下を探しに行く
ok = mid
else:
# 上を探しに行く
ng = mid
return ok
N, K = MAP()
A = LIST()
def check(omit):
# 部分和DP
dp = np.zeros(K, dtype=np.bool)
prev = np.zeros(K, dtype=np.bool)
dp[0] = prev[0] = 1
for i in range(N):
# まとめて遷移
if i != omit and A[i] < K:
prev[A[i]:] |= dp[:K-A[i]]
dp = prev.copy()
# 今回の値A[omit]を足してKに到達できるような部分和があれば、これは必要
for j in range(max(0, K-A[omit]), K):
if dp[j]:
return True
# なければ不要
return False
A.sort()
print((bisearch_min(-1, N, check)))
| 57 | 58 | 1,542 | 1,524 | # -*- coding: utf-8 -*-
import sys
import numpy as np
def input():
return sys.stdin.readline().strip()
def list2d(a, b, c):
return [[c] * b for i in range(a)]
def list3d(a, b, c, d):
return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e):
return [[[[e] * d for j in range(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(N=None):
return list(MAP()) if N is None else [INT() for i in range(N)]
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
def bisearch_min(mn, mx, func):
"""条件を満たす最小値を見つける二分探索"""
ok = mx
ng = mn
while ng + 1 < ok:
mid = (ok + ng) // 2
if func(mid):
# 下を探しに行く
ok = mid
else:
# 上を探しに行く
ng = mid
return ok
N, K = MAP()
A = LIST()
def check(omit):
# 部分和DP
dp = np.zeros((N + 1, K), dtype=np.bool)
dp[0, 0] = 1
for i in range(N):
# まとめて遷移
dp[i + 1] = np.logical_or(dp[i + 1], dp[i])
if i != omit and A[i] < K:
dp[i + 1, A[i] :] = np.logical_or(dp[i + 1, A[i] :], dp[i, : K - A[i]])
# 今回の値A[omit]を足してKに到達できるような部分和があれば、これは必要
for j in range(max(0, K - A[omit]), K):
if dp[N, j]:
return True
# なければ不要
return False
A.sort()
print((bisearch_min(-1, N, check)))
| # -*- coding: utf-8 -*-
import sys
import numpy as np
def input():
return sys.stdin.readline().strip()
def list2d(a, b, c):
return [[c] * b for i in range(a)]
def list3d(a, b, c, d):
return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e):
return [[[[e] * d for j in range(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(N=None):
return list(MAP()) if N is None else [INT() for i in range(N)]
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
def bisearch_min(mn, mx, func):
"""条件を満たす最小値を見つける二分探索"""
ok = mx
ng = mn
while ng + 1 < ok:
mid = (ok + ng) // 2
if func(mid):
# 下を探しに行く
ok = mid
else:
# 上を探しに行く
ng = mid
return ok
N, K = MAP()
A = LIST()
def check(omit):
# 部分和DP
dp = np.zeros(K, dtype=np.bool)
prev = np.zeros(K, dtype=np.bool)
dp[0] = prev[0] = 1
for i in range(N):
# まとめて遷移
if i != omit and A[i] < K:
prev[A[i] :] |= dp[: K - A[i]]
dp = prev.copy()
# 今回の値A[omit]を足してKに到達できるような部分和があれば、これは必要
for j in range(max(0, K - A[omit]), K):
if dp[j]:
return True
# なければ不要
return False
A.sort()
print((bisearch_min(-1, N, check)))
| false | 1.724138 | [
"- dp = np.zeros((N + 1, K), dtype=np.bool)",
"- dp[0, 0] = 1",
"+ dp = np.zeros(K, dtype=np.bool)",
"+ prev = np.zeros(K, dtype=np.bool)",
"+ dp[0] = prev[0] = 1",
"- dp[i + 1] = np.logical_or(dp[i + 1], dp[i])",
"- dp[i + 1, A[i] :] = np.logical_or(dp[i + 1, A[i] :], dp[i, : K - A[i]])",
"+ prev[A[i] :] |= dp[: K - A[i]]",
"+ dp = prev.copy()",
"- if dp[N, j]:",
"+ if dp[j]:"
] | false | 0.277129 | 0.299386 | 0.925656 | [
"s599814107",
"s053991457"
] |
u202619899 | p03701 | python | s564458749 | s038396529 | 62 | 17 | 3,920 | 3,060 | Accepted | Accepted | 72.58 | N = int(eval(input()))
S = [int(eval(input())) for i in range(N)]
dp = {}
dp[0] = True
for s in S:
keys = list(dp.keys())
for k in keys:
dp[k + s] = True
res = 0
for k in list(dp.keys()):
if k % 10 == 0:
continue
res = max(res, k)
print(res)
| N = int(eval(input()))
S = [int(eval(input())) for i in range(N)]
T = list([x for x in S if x % 10 > 0])
res = sum(S)
if res % 10 == 0:
if len(T) == 0:
res = 0
else:
res -= min(T)
print(res)
| 17 | 11 | 275 | 217 | N = int(eval(input()))
S = [int(eval(input())) for i in range(N)]
dp = {}
dp[0] = True
for s in S:
keys = list(dp.keys())
for k in keys:
dp[k + s] = True
res = 0
for k in list(dp.keys()):
if k % 10 == 0:
continue
res = max(res, k)
print(res)
| N = int(eval(input()))
S = [int(eval(input())) for i in range(N)]
T = list([x for x in S if x % 10 > 0])
res = sum(S)
if res % 10 == 0:
if len(T) == 0:
res = 0
else:
res -= min(T)
print(res)
| false | 35.294118 | [
"-dp = {}",
"-dp[0] = True",
"-for s in S:",
"- keys = list(dp.keys())",
"- for k in keys:",
"- dp[k + s] = True",
"-res = 0",
"-for k in list(dp.keys()):",
"- if k % 10 == 0:",
"- continue",
"- res = max(res, k)",
"+T = list([x for x in S if x % 10 > 0])",
"+res = sum(S)",
"+if res % 10 == 0:",
"+ if len(T) == 0:",
"+ res = 0",
"+ else:",
"+ res -= min(T)"
] | false | 0.06047 | 0.039856 | 1.517209 | [
"s564458749",
"s038396529"
] |
u636683284 | p03679 | python | s895183078 | s055030186 | 179 | 94 | 38,384 | 61,580 | Accepted | Accepted | 47.49 | x, a, b = list(map(int,input().split()))
if b-a <= x and b-a <= 0:
print('delicious')
elif b-a <= x:
print('safe')
else:
print('dangerous')
| x,a,b = list(map(int,input().split()))
if -a+b <= 0:
print('delicious')
elif -a+b <= x:
print('safe')
else:
print('dangerous') | 8 | 7 | 149 | 138 | x, a, b = list(map(int, input().split()))
if b - a <= x and b - a <= 0:
print("delicious")
elif b - a <= x:
print("safe")
else:
print("dangerous")
| x, a, b = list(map(int, input().split()))
if -a + b <= 0:
print("delicious")
elif -a + b <= x:
print("safe")
else:
print("dangerous")
| false | 12.5 | [
"-if b - a <= x and b - a <= 0:",
"+if -a + b <= 0:",
"-elif b - a <= x:",
"+elif -a + b <= x:"
] | false | 0.042581 | 0.03606 | 1.180838 | [
"s895183078",
"s055030186"
] |
u606045429 | p03241 | python | s886005282 | s489622687 | 24 | 21 | 3,060 | 3,060 | Accepted | Accepted | 12.5 | def divisors(N):
res = []
i = 1
while i * i < N:
if N % i == 0:
res += [i, N // i]
i += 1
if N % i == 0:
res.append(i)
res.sort()
return res
N, M = list(map(int, input().split()))
print((max(d for d in divisors(M) if d * N <= M)))
| def divisors(N):
res = []
i = 1
for i in range(1, int(N ** 0.5)):
if N % i == 0:
res += [i, N // i]
if N % i == 0:
res.append(i)
res.sort()
return res
N, M = list(map(int, input().split()))
print((max(d for d in divisors(M) if d * N <= M)))
| 14 | 13 | 297 | 298 | def divisors(N):
res = []
i = 1
while i * i < N:
if N % i == 0:
res += [i, N // i]
i += 1
if N % i == 0:
res.append(i)
res.sort()
return res
N, M = list(map(int, input().split()))
print((max(d for d in divisors(M) if d * N <= M)))
| def divisors(N):
res = []
i = 1
for i in range(1, int(N**0.5)):
if N % i == 0:
res += [i, N // i]
if N % i == 0:
res.append(i)
res.sort()
return res
N, M = list(map(int, input().split()))
print((max(d for d in divisors(M) if d * N <= M)))
| false | 7.142857 | [
"- while i * i < N:",
"+ for i in range(1, int(N**0.5)):",
"- i += 1"
] | false | 0.038445 | 0.087206 | 0.440854 | [
"s886005282",
"s489622687"
] |
u094191970 | p02647 | python | s456057419 | s257405148 | 671 | 431 | 185,372 | 219,992 | Accepted | Accepted | 35.77 | n,k=list(map(int,input().split()))
a=list(map(int,input().split()))
def imos(a):
imos_l=[0 for i in range(n)]
for i in range(n):
left=max(i-a[i],0)
right=min(i+a[i],n-1)
imos_l[left]+=1
if right+1!=n:
imos_l[right+1]-=1
b=[0]
for i in range(1,n+1):
b.append(b[i-1]+imos_l[i-1])
return b[1:]
for i in range(k):
a=imos(a)
if a.count(n)==n:
break
print((*a)) | n,k=list(map(int,input().split()))
a=list(map(int,input().split()))
def imos(n,a):
imos_l=[0]*n
for i in range(n):
l=max(i-a[i],0)
r=min(i+a[i],n-1)
imos_l[l]+=1
if (r+1)!=n:
imos_l[r+1]-=1
b=[0]
for i in range(1,n+1):
b.append(imos_l[i-1]+b[i-1])
return b[1:]
for i in range(k):
na=imos(n,a)
if na==a:
break
a=na
print((*a)) | 26 | 24 | 423 | 390 | n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
def imos(a):
imos_l = [0 for i in range(n)]
for i in range(n):
left = max(i - a[i], 0)
right = min(i + a[i], n - 1)
imos_l[left] += 1
if right + 1 != n:
imos_l[right + 1] -= 1
b = [0]
for i in range(1, n + 1):
b.append(b[i - 1] + imos_l[i - 1])
return b[1:]
for i in range(k):
a = imos(a)
if a.count(n) == n:
break
print((*a))
| n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
def imos(n, a):
imos_l = [0] * n
for i in range(n):
l = max(i - a[i], 0)
r = min(i + a[i], n - 1)
imos_l[l] += 1
if (r + 1) != n:
imos_l[r + 1] -= 1
b = [0]
for i in range(1, n + 1):
b.append(imos_l[i - 1] + b[i - 1])
return b[1:]
for i in range(k):
na = imos(n, a)
if na == a:
break
a = na
print((*a))
| false | 7.692308 | [
"-def imos(a):",
"- imos_l = [0 for i in range(n)]",
"+def imos(n, a):",
"+ imos_l = [0] * n",
"- left = max(i - a[i], 0)",
"- right = min(i + a[i], n - 1)",
"- imos_l[left] += 1",
"- if right + 1 != n:",
"- imos_l[right + 1] -= 1",
"+ l = max(i - a[i], 0)",
"+ r = min(i + a[i], n - 1)",
"+ imos_l[l] += 1",
"+ if (r + 1) != n:",
"+ imos_l[r + 1] -= 1",
"- b.append(b[i - 1] + imos_l[i - 1])",
"+ b.append(imos_l[i - 1] + b[i - 1])",
"- a = imos(a)",
"- if a.count(n) == n:",
"+ na = imos(n, a)",
"+ if na == a:",
"+ a = na"
] | false | 0.036352 | 0.035912 | 1.012259 | [
"s456057419",
"s257405148"
] |
u380995377 | p03167 | python | s189234070 | s570029120 | 1,677 | 406 | 52,728 | 110,296 | Accepted | Accepted | 75.79 | import sys
sys.setrecursionlimit(10**5+10)
input = sys.stdin.readline
def I(): return int(sys.stdin.readline())
def MI(): return list(map(int, sys.stdin.readline().split()))
def LI(): return list(map(int, sys.stdin.readline().split()))
def LI2(N): return [list(map(int, sys.stdin.readline().split())) for i in range(N)]
def S(): return sys.stdin.readline()
def LS(): return sys.stdin.readline().split()
def LS2(N): return [sys.stdin.readline().split() for i in range(N)]
def FILL(i,h,w): return [[i for j in range(w)] for k in range(h)]
MOD = 1000000007
INF = float("inf")
H,W = LI()
c = [list(S()) for i in range(H)]
dp = FILL(0,H+1,W+1)
dp[0][0] = 1
for i in range(H):
for j in range(W):
if i+1<H:
if c[i+1][j] == '.':
dp[i+1][j] += dp[i][j]
if j+1<W:
if c[i][j+1] == '.':
dp[i][j+1] += dp[i][j]
dp[i][j] %= MOD
print((dp[H-1][W-1]))
| import sys
import math
from decimal import Decimal, ROUND_HALF_UP, ROUND_HALF_EVEN
from collections import deque
from bisect import bisect_left
from itertools import product
def I(): return int(sys.stdin.readline())
def MI(): return list(map(int, sys.stdin.readline().split()))
def LI(): return list(map(int, sys.stdin.readline().split()))
def LI2(N): return [list(map(int, sys.stdin.readline().split())) for i in range(N)]
#文字列を一文字ずつ数字に変換、'5678'を[5,6,7,8]とできる
def LSI(): return list(map(int, list(sys.stdin.readline().rstrip())))
def LSI2(N): return [list(map(int, list(sys.stdin.readline().rstrip()))) for i in range(N)]
#文字列として取得
def ST(): return sys.stdin.readline().rstrip()
def LST(): return sys.stdin.readline().rstrip().split()
def LST2(N): return [sys.stdin.readline().rstrip().split() for i in range(N)]
def FILL(i,h): return [i for j in range(h)]
def FILL2(i,h,w): return [FILL(i,w) for j in range(h)]
def FILL3(i,h,w,d): return [FILL2(i,w,d) for j in range(h)]
def FILL4(i,h,w,d,d2): return [FILL3(i,w,d,d2) for j in range(h)]
def sisha(num,digit): return Decimal(str(num)).quantize(Decimal(digit),rounding=ROUND_HALF_UP)
#'0.01'や'1E1'などで指定、整数に戻すならintをかます
MOD = 1000000007
INF = float("inf")
sys.setrecursionlimit(10**6+10)
H,W = MI()
V = [list(ST()) for _ in range(H)]
dp = FILL2(0,H+1,W+1)
dp[1][1]=1
for i in range(1,H+1):
for j in range(1,W+1):
if V[i-1][j-1] == '.' and (i!=1 or j!=1):
dp[i][j] = (dp[i-1][j] + dp[i][j-1])%MOD
print((dp[H][W]))
| 32 | 36 | 948 | 1,514 | import sys
sys.setrecursionlimit(10**5 + 10)
input = sys.stdin.readline
def I():
return int(sys.stdin.readline())
def MI():
return list(map(int, sys.stdin.readline().split()))
def LI():
return list(map(int, sys.stdin.readline().split()))
def LI2(N):
return [list(map(int, sys.stdin.readline().split())) for i in range(N)]
def S():
return sys.stdin.readline()
def LS():
return sys.stdin.readline().split()
def LS2(N):
return [sys.stdin.readline().split() for i in range(N)]
def FILL(i, h, w):
return [[i for j in range(w)] for k in range(h)]
MOD = 1000000007
INF = float("inf")
H, W = LI()
c = [list(S()) for i in range(H)]
dp = FILL(0, H + 1, W + 1)
dp[0][0] = 1
for i in range(H):
for j in range(W):
if i + 1 < H:
if c[i + 1][j] == ".":
dp[i + 1][j] += dp[i][j]
if j + 1 < W:
if c[i][j + 1] == ".":
dp[i][j + 1] += dp[i][j]
dp[i][j] %= MOD
print((dp[H - 1][W - 1]))
| import sys
import math
from decimal import Decimal, ROUND_HALF_UP, ROUND_HALF_EVEN
from collections import deque
from bisect import bisect_left
from itertools import product
def I():
return int(sys.stdin.readline())
def MI():
return list(map(int, sys.stdin.readline().split()))
def LI():
return list(map(int, sys.stdin.readline().split()))
def LI2(N):
return [list(map(int, sys.stdin.readline().split())) for i in range(N)]
# 文字列を一文字ずつ数字に変換、'5678'を[5,6,7,8]とできる
def LSI():
return list(map(int, list(sys.stdin.readline().rstrip())))
def LSI2(N):
return [list(map(int, list(sys.stdin.readline().rstrip()))) for i in range(N)]
# 文字列として取得
def ST():
return sys.stdin.readline().rstrip()
def LST():
return sys.stdin.readline().rstrip().split()
def LST2(N):
return [sys.stdin.readline().rstrip().split() for i in range(N)]
def FILL(i, h):
return [i for j in range(h)]
def FILL2(i, h, w):
return [FILL(i, w) for j in range(h)]
def FILL3(i, h, w, d):
return [FILL2(i, w, d) for j in range(h)]
def FILL4(i, h, w, d, d2):
return [FILL3(i, w, d, d2) for j in range(h)]
def sisha(num, digit):
return Decimal(str(num)).quantize(Decimal(digit), rounding=ROUND_HALF_UP)
#'0.01'や'1E1'などで指定、整数に戻すならintをかます
MOD = 1000000007
INF = float("inf")
sys.setrecursionlimit(10**6 + 10)
H, W = MI()
V = [list(ST()) for _ in range(H)]
dp = FILL2(0, H + 1, W + 1)
dp[1][1] = 1
for i in range(1, H + 1):
for j in range(1, W + 1):
if V[i - 1][j - 1] == "." and (i != 1 or j != 1):
dp[i][j] = (dp[i - 1][j] + dp[i][j - 1]) % MOD
print((dp[H][W]))
| false | 11.111111 | [
"-",
"-sys.setrecursionlimit(10**5 + 10)",
"-input = sys.stdin.readline",
"+import math",
"+from decimal import Decimal, ROUND_HALF_UP, ROUND_HALF_EVEN",
"+from collections import deque",
"+from bisect import bisect_left",
"+from itertools import product",
"-def S():",
"- return sys.stdin.readline()",
"+# 文字列を一文字ずつ数字に変換、'5678'を[5,6,7,8]とできる",
"+def LSI():",
"+ return list(map(int, list(sys.stdin.readline().rstrip())))",
"-def LS():",
"- return sys.stdin.readline().split()",
"+def LSI2(N):",
"+ return [list(map(int, list(sys.stdin.readline().rstrip()))) for i in range(N)]",
"-def LS2(N):",
"- return [sys.stdin.readline().split() for i in range(N)]",
"+# 文字列として取得",
"+def ST():",
"+ return sys.stdin.readline().rstrip()",
"-def FILL(i, h, w):",
"- return [[i for j in range(w)] for k in range(h)]",
"+def LST():",
"+ return sys.stdin.readline().rstrip().split()",
"+def LST2(N):",
"+ return [sys.stdin.readline().rstrip().split() for i in range(N)]",
"+",
"+",
"+def FILL(i, h):",
"+ return [i for j in range(h)]",
"+",
"+",
"+def FILL2(i, h, w):",
"+ return [FILL(i, w) for j in range(h)]",
"+",
"+",
"+def FILL3(i, h, w, d):",
"+ return [FILL2(i, w, d) for j in range(h)]",
"+",
"+",
"+def FILL4(i, h, w, d, d2):",
"+ return [FILL3(i, w, d, d2) for j in range(h)]",
"+",
"+",
"+def sisha(num, digit):",
"+ return Decimal(str(num)).quantize(Decimal(digit), rounding=ROUND_HALF_UP)",
"+",
"+",
"+#'0.01'や'1E1'などで指定、整数に戻すならintをかます",
"-H, W = LI()",
"-c = [list(S()) for i in range(H)]",
"-dp = FILL(0, H + 1, W + 1)",
"-dp[0][0] = 1",
"-for i in range(H):",
"- for j in range(W):",
"- if i + 1 < H:",
"- if c[i + 1][j] == \".\":",
"- dp[i + 1][j] += dp[i][j]",
"- if j + 1 < W:",
"- if c[i][j + 1] == \".\":",
"- dp[i][j + 1] += dp[i][j]",
"- dp[i][j] %= MOD",
"-print((dp[H - 1][W - 1]))",
"+sys.setrecursionlimit(10**6 + 10)",
"+H, W = MI()",
"+V = [list(ST()) for _ in range(H)]",
"+dp = FILL2(0, H + 1, W + 1)",
"+dp[1][1] = 1",
"+for i in range(1, H + 1):",
"+ for j in range(1, W + 1):",
"+ if V[i - 1][j - 1] == \".\" and (i != 1 or j != 1):",
"+ dp[i][j] = (dp[i - 1][j] + dp[i][j - 1]) % MOD",
"+print((dp[H][W]))"
] | false | 0.047823 | 0.038642 | 1.237588 | [
"s189234070",
"s570029120"
] |
u548834738 | p03103 | python | s203990890 | s286162526 | 1,995 | 506 | 27,760 | 27,760 | Accepted | Accepted | 74.64 | N, M = list(map(int, input().split()))
shops = [None] * N
for i in range(N):
shops[i] = list(map(int, input().split()))
shops.sort()
cnt = 0
ans = 0
while cnt < M:
shop = shops.pop(0)
if cnt + shop[1] >= M:
ans += (M - cnt) * shop[0]
cnt = M
else:
ans += shop[0] * shop[1]
cnt += shop[1]
print(ans) | N, M = list(map(int, input().split()))
shops = [None] * N
for i in range(N):
shops[i] = list(map(int, input().split()))
shops.sort()
cnt = 0
ans = 0
for i in range(N):
shop = shops[i]
ans += shop[0] * shop[1]
cnt += shop[1]
if cnt > M:
ans -= (cnt - M) * shop[0]
break
print(ans) | 16 | 15 | 331 | 305 | N, M = list(map(int, input().split()))
shops = [None] * N
for i in range(N):
shops[i] = list(map(int, input().split()))
shops.sort()
cnt = 0
ans = 0
while cnt < M:
shop = shops.pop(0)
if cnt + shop[1] >= M:
ans += (M - cnt) * shop[0]
cnt = M
else:
ans += shop[0] * shop[1]
cnt += shop[1]
print(ans)
| N, M = list(map(int, input().split()))
shops = [None] * N
for i in range(N):
shops[i] = list(map(int, input().split()))
shops.sort()
cnt = 0
ans = 0
for i in range(N):
shop = shops[i]
ans += shop[0] * shop[1]
cnt += shop[1]
if cnt > M:
ans -= (cnt - M) * shop[0]
break
print(ans)
| false | 6.25 | [
"-while cnt < M:",
"- shop = shops.pop(0)",
"- if cnt + shop[1] >= M:",
"- ans += (M - cnt) * shop[0]",
"- cnt = M",
"- else:",
"- ans += shop[0] * shop[1]",
"- cnt += shop[1]",
"+for i in range(N):",
"+ shop = shops[i]",
"+ ans += shop[0] * shop[1]",
"+ cnt += shop[1]",
"+ if cnt > M:",
"+ ans -= (cnt - M) * shop[0]",
"+ break"
] | false | 0.038291 | 0.047464 | 0.806732 | [
"s203990890",
"s286162526"
] |
u021548497 | p02953 | python | s041350719 | s851158338 | 106 | 79 | 14,228 | 20,516 | Accepted | Accepted | 25.47 | N = int(eval(input()))
H = [int(x) for x in input().split()]
j = 0
Ans = True
for i in range(N-1):
if H[i] > H[i+1] + 1:
Ans = False
elif H[i] == H[i+1] + 1:
if H[i-j] == H[i]:
j = 1
continue
else:
Ans = False
break
elif H[i] == H[i+1]:
j += 1
else:
j = 0
continue
if Ans:
print("Yes")
else:
print("No") | n = int(eval(input()))
a = list(map(int, input().split()))
judge = 0
for i in range(n):
if a[i] < judge:
print("No")
break
judge = max(judge, a[i]-1)
else:
print("Yes") | 25 | 11 | 443 | 187 | N = int(eval(input()))
H = [int(x) for x in input().split()]
j = 0
Ans = True
for i in range(N - 1):
if H[i] > H[i + 1] + 1:
Ans = False
elif H[i] == H[i + 1] + 1:
if H[i - j] == H[i]:
j = 1
continue
else:
Ans = False
break
elif H[i] == H[i + 1]:
j += 1
else:
j = 0
continue
if Ans:
print("Yes")
else:
print("No")
| n = int(eval(input()))
a = list(map(int, input().split()))
judge = 0
for i in range(n):
if a[i] < judge:
print("No")
break
judge = max(judge, a[i] - 1)
else:
print("Yes")
| false | 56 | [
"-N = int(eval(input()))",
"-H = [int(x) for x in input().split()]",
"-j = 0",
"-Ans = True",
"-for i in range(N - 1):",
"- if H[i] > H[i + 1] + 1:",
"- Ans = False",
"- elif H[i] == H[i + 1] + 1:",
"- if H[i - j] == H[i]:",
"- j = 1",
"- continue",
"- else:",
"- Ans = False",
"- break",
"- elif H[i] == H[i + 1]:",
"- j += 1",
"- else:",
"- j = 0",
"- continue",
"-if Ans:",
"+n = int(eval(input()))",
"+a = list(map(int, input().split()))",
"+judge = 0",
"+for i in range(n):",
"+ if a[i] < judge:",
"+ print(\"No\")",
"+ break",
"+ judge = max(judge, a[i] - 1)",
"+else:",
"-else:",
"- print(\"No\")"
] | false | 0.037868 | 0.03698 | 1.024014 | [
"s041350719",
"s851158338"
] |
u413019025 | p03087 | python | s148606493 | s986826670 | 859 | 297 | 7,748 | 32,312 | Accepted | Accepted | 65.42 | N, Q = list(map(int, input().split()))
S = eval(input())
t = [0] * (N + 1)
for i in range(N):
t[i + 1] = t[i] + (1 if S[i:i + 2] == 'AC' else 0)
for i in range(Q):
l, r = list(map(int, input().split()))
print((t[r - 1] - t[l - 1]))
| #!/usr/bin/env python3
import sys
sys.setrecursionlimit(10**7)
input = sys.stdin.readline
def read_h(typ=int):
return list(map(typ, input().split()))
def read_v(n, m=1, typ=int):
return [read_h(typ) if m > 1 else typ(eval(input())) for _ in range(n)]
def main():
n, q = read_h()
s, = read_h(typ=str)
rng = read_v(q, m=2)
cnts = [0] * (n + 1)
for i in range(len(s)):
cnts[i + 1] = cnts[i] + (1 if s[i:i + 2] == 'AC' else 0)
for l, r in rng:
print((cnts[r - 1] - cnts[l - 1]))
if __name__ == '__main__':
main()
| 11 | 32 | 237 | 597 | N, Q = list(map(int, input().split()))
S = eval(input())
t = [0] * (N + 1)
for i in range(N):
t[i + 1] = t[i] + (1 if S[i : i + 2] == "AC" else 0)
for i in range(Q):
l, r = list(map(int, input().split()))
print((t[r - 1] - t[l - 1]))
| #!/usr/bin/env python3
import sys
sys.setrecursionlimit(10**7)
input = sys.stdin.readline
def read_h(typ=int):
return list(map(typ, input().split()))
def read_v(n, m=1, typ=int):
return [read_h(typ) if m > 1 else typ(eval(input())) for _ in range(n)]
def main():
n, q = read_h()
(s,) = read_h(typ=str)
rng = read_v(q, m=2)
cnts = [0] * (n + 1)
for i in range(len(s)):
cnts[i + 1] = cnts[i] + (1 if s[i : i + 2] == "AC" else 0)
for l, r in rng:
print((cnts[r - 1] - cnts[l - 1]))
if __name__ == "__main__":
main()
| false | 65.625 | [
"-N, Q = list(map(int, input().split()))",
"-S = eval(input())",
"-t = [0] * (N + 1)",
"-for i in range(N):",
"- t[i + 1] = t[i] + (1 if S[i : i + 2] == \"AC\" else 0)",
"-for i in range(Q):",
"- l, r = list(map(int, input().split()))",
"- print((t[r - 1] - t[l - 1]))",
"+#!/usr/bin/env python3",
"+import sys",
"+",
"+sys.setrecursionlimit(10**7)",
"+input = sys.stdin.readline",
"+",
"+",
"+def read_h(typ=int):",
"+ return list(map(typ, input().split()))",
"+",
"+",
"+def read_v(n, m=1, typ=int):",
"+ return [read_h(typ) if m > 1 else typ(eval(input())) for _ in range(n)]",
"+",
"+",
"+def main():",
"+ n, q = read_h()",
"+ (s,) = read_h(typ=str)",
"+ rng = read_v(q, m=2)",
"+ cnts = [0] * (n + 1)",
"+ for i in range(len(s)):",
"+ cnts[i + 1] = cnts[i] + (1 if s[i : i + 2] == \"AC\" else 0)",
"+ for l, r in rng:",
"+ print((cnts[r - 1] - cnts[l - 1]))",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ main()"
] | false | 0.110505 | 0.090051 | 1.227144 | [
"s148606493",
"s986826670"
] |
u737321654 | p03835 | python | s955247489 | s261339696 | 1,540 | 1,138 | 2,940 | 9,120 | Accepted | Accepted | 26.1 | K,S = list(map(int,input().split()))
ans = 0
for x in range(K+1):
for y in range(K+1):
sumn = S - (x + y)
if sumn >= 0 and sumn <= K:
ans += 1
print(ans) | K, S = list(map(int, input().split()))
count = 0
for x in range(K+1):
for y in range(K+1):
z = S - x - y
if 0 <= z <= K:
count += 1
print(count) | 9 | 10 | 188 | 181 | K, S = list(map(int, input().split()))
ans = 0
for x in range(K + 1):
for y in range(K + 1):
sumn = S - (x + y)
if sumn >= 0 and sumn <= K:
ans += 1
print(ans)
| K, S = list(map(int, input().split()))
count = 0
for x in range(K + 1):
for y in range(K + 1):
z = S - x - y
if 0 <= z <= K:
count += 1
print(count)
| false | 10 | [
"-ans = 0",
"+count = 0",
"- sumn = S - (x + y)",
"- if sumn >= 0 and sumn <= K:",
"- ans += 1",
"-print(ans)",
"+ z = S - x - y",
"+ if 0 <= z <= K:",
"+ count += 1",
"+print(count)"
] | false | 0.036559 | 0.037204 | 0.982684 | [
"s955247489",
"s261339696"
] |
u281610856 | p03761 | python | s670964591 | s076591606 | 272 | 18 | 18,736 | 3,060 | Accepted | Accepted | 93.38 | import numpy as np
n = int(eval(input()))
l = [[0] * (ord('z') - ord('a') + 1) for _ in range(n)]
for i in range(n):
S = eval(input())
for s in S:
idx = ord(s) - ord('a')
l[i][idx] += 1
l = np.array(l)
l = np.rot90(l, -1)
ans = ''
for j in range(len(l)):
num = min(l[j])
ans += chr(ord('a') + j) * num
print(ans) | n = int(eval(input()))
l = [eval(input()) for _ in range(n)]
ans = ''
for i in range(ord('a'), ord('z') + 1):
s = chr(i)
num = float('inf')
for j in l:
num = min(num, j.count(s))
ans += s * num
print(ans) | 17 | 10 | 350 | 225 | import numpy as np
n = int(eval(input()))
l = [[0] * (ord("z") - ord("a") + 1) for _ in range(n)]
for i in range(n):
S = eval(input())
for s in S:
idx = ord(s) - ord("a")
l[i][idx] += 1
l = np.array(l)
l = np.rot90(l, -1)
ans = ""
for j in range(len(l)):
num = min(l[j])
ans += chr(ord("a") + j) * num
print(ans)
| n = int(eval(input()))
l = [eval(input()) for _ in range(n)]
ans = ""
for i in range(ord("a"), ord("z") + 1):
s = chr(i)
num = float("inf")
for j in l:
num = min(num, j.count(s))
ans += s * num
print(ans)
| false | 41.176471 | [
"-import numpy as np",
"-",
"-l = [[0] * (ord(\"z\") - ord(\"a\") + 1) for _ in range(n)]",
"-for i in range(n):",
"- S = eval(input())",
"- for s in S:",
"- idx = ord(s) - ord(\"a\")",
"- l[i][idx] += 1",
"-l = np.array(l)",
"-l = np.rot90(l, -1)",
"+l = [eval(input()) for _ in range(n)]",
"-for j in range(len(l)):",
"- num = min(l[j])",
"- ans += chr(ord(\"a\") + j) * num",
"+for i in range(ord(\"a\"), ord(\"z\") + 1):",
"+ s = chr(i)",
"+ num = float(\"inf\")",
"+ for j in l:",
"+ num = min(num, j.count(s))",
"+ ans += s * num"
] | false | 0.423751 | 0.053513 | 7.91862 | [
"s670964591",
"s076591606"
] |
u416011173 | p02695 | python | s482337682 | s620233950 | 1,219 | 788 | 9,220 | 9,092 | Accepted | Accepted | 35.36 | # -*- coding: utf-8 -*-
# モジュールのインポート
import itertools
# 標準入力の取得
N,M,Q = list(map(int, input().split()))
a,b,c,d = [],[],[],[]
for q in range(Q):
a_q,b_q,c_q,d_q = list(map(int, input().split()))
a.append(a_q)
b.append(b_q)
c.append(c_q)
d.append(d_q)
# 求解処理
l = list(range(1, M+1))
result = 0
for A in itertools.combinations_with_replacement(l, N):
score = 0
for a_i,b_i,c_i,d_i in zip(a, b, c, d):
if A[b_i-1] - A[a_i-1] == c_i:
score += d_i
result = max(result, score)
# 結果出力
print(result) | # -*- coding: utf-8 -*-
# モジュールのインポート
import itertools
# 標準入力の取得
N, M, Q = list(map(int, input().split()))
a, b, c, d = [], [], [], []
for q in range(Q):
a_q, b_q, c_q, d_q = list(map(int, input().split()))
a.append(a_q)
b.append(b_q)
c.append(c_q)
d.append(d_q)
def get_score(A: tuple) -> int:
"""得点を計算するメソッド
Arguments:
A {tuple} -- 数列
Returns:
int -- 得点
"""
score = 0
for a_i, b_i, c_i, d_i in zip(a, b, c, d):
score += (A[b_i-1] - A[a_i-1] == c_i) * d_i
return score
def main() -> None:
"""Entry point
"""
# 求解処理
# 条件を満たす数列を全探索
l = list(range(1, M+1))
result = 0
for A in itertools.combinations_with_replacement(l, N):
result = max(result, get_score(A))
# 結果出力
print(result)
if __name__ == "__main__":
main()
| 27 | 46 | 574 | 887 | # -*- coding: utf-8 -*-
# モジュールのインポート
import itertools
# 標準入力の取得
N, M, Q = list(map(int, input().split()))
a, b, c, d = [], [], [], []
for q in range(Q):
a_q, b_q, c_q, d_q = list(map(int, input().split()))
a.append(a_q)
b.append(b_q)
c.append(c_q)
d.append(d_q)
# 求解処理
l = list(range(1, M + 1))
result = 0
for A in itertools.combinations_with_replacement(l, N):
score = 0
for a_i, b_i, c_i, d_i in zip(a, b, c, d):
if A[b_i - 1] - A[a_i - 1] == c_i:
score += d_i
result = max(result, score)
# 結果出力
print(result)
| # -*- coding: utf-8 -*-
# モジュールのインポート
import itertools
# 標準入力の取得
N, M, Q = list(map(int, input().split()))
a, b, c, d = [], [], [], []
for q in range(Q):
a_q, b_q, c_q, d_q = list(map(int, input().split()))
a.append(a_q)
b.append(b_q)
c.append(c_q)
d.append(d_q)
def get_score(A: tuple) -> int:
"""得点を計算するメソッド
Arguments:
A {tuple} -- 数列
Returns:
int -- 得点
"""
score = 0
for a_i, b_i, c_i, d_i in zip(a, b, c, d):
score += (A[b_i - 1] - A[a_i - 1] == c_i) * d_i
return score
def main() -> None:
"""Entry point"""
# 求解処理
# 条件を満たす数列を全探索
l = list(range(1, M + 1))
result = 0
for A in itertools.combinations_with_replacement(l, N):
result = max(result, get_score(A))
# 結果出力
print(result)
if __name__ == "__main__":
main()
| false | 41.304348 | [
"-# 求解処理",
"-l = list(range(1, M + 1))",
"-result = 0",
"-for A in itertools.combinations_with_replacement(l, N):",
"+",
"+",
"+def get_score(A: tuple) -> int:",
"+ \"\"\"得点を計算するメソッド",
"+ Arguments:",
"+ A {tuple} -- 数列",
"+ Returns:",
"+ int -- 得点",
"+ \"\"\"",
"- if A[b_i - 1] - A[a_i - 1] == c_i:",
"- score += d_i",
"- result = max(result, score)",
"-# 結果出力",
"-print(result)",
"+ score += (A[b_i - 1] - A[a_i - 1] == c_i) * d_i",
"+ return score",
"+",
"+",
"+def main() -> None:",
"+ \"\"\"Entry point\"\"\"",
"+ # 求解処理",
"+ # 条件を満たす数列を全探索",
"+ l = list(range(1, M + 1))",
"+ result = 0",
"+ for A in itertools.combinations_with_replacement(l, N):",
"+ result = max(result, get_score(A))",
"+ # 結果出力",
"+ print(result)",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ main()"
] | false | 0.073073 | 0.047545 | 1.536941 | [
"s482337682",
"s620233950"
] |
u488127128 | p03680 | python | s428532854 | s721692865 | 65 | 54 | 7,068 | 7,068 | Accepted | Accepted | 16.92 | import sys
input = sys.stdin.readline
buttons = list(map(int,sys.stdin))
n = buttons[0]
count,light = 1,buttons[1]
while light!=2 and count<n:
count,light = count+1,buttons[light]
print((count if count<n else -1)) | import sys
input = sys.stdin.readline
buttons = list(map(int,sys.stdin))
light = buttons[1]
for i in range(buttons[0]):
if light==2:
print((i+1))
break
light= buttons[light]
else:
print((-1)) | 9 | 12 | 224 | 227 | import sys
input = sys.stdin.readline
buttons = list(map(int, sys.stdin))
n = buttons[0]
count, light = 1, buttons[1]
while light != 2 and count < n:
count, light = count + 1, buttons[light]
print((count if count < n else -1))
| import sys
input = sys.stdin.readline
buttons = list(map(int, sys.stdin))
light = buttons[1]
for i in range(buttons[0]):
if light == 2:
print((i + 1))
break
light = buttons[light]
else:
print((-1))
| false | 25 | [
"-n = buttons[0]",
"-count, light = 1, buttons[1]",
"-while light != 2 and count < n:",
"- count, light = count + 1, buttons[light]",
"-print((count if count < n else -1))",
"+light = buttons[1]",
"+for i in range(buttons[0]):",
"+ if light == 2:",
"+ print((i + 1))",
"+ break",
"+ light = buttons[light]",
"+else:",
"+ print((-1))"
] | false | 0.074029 | 0.062998 | 1.175101 | [
"s428532854",
"s721692865"
] |
u733814820 | p03435 | python | s779719430 | s778183922 | 21 | 19 | 3,316 | 3,188 | Accepted | Accepted | 9.52 | # ABC 088 C
from collections import deque
def resolve():
def all_same(a, b, c):
if a ==b and b ==c:
return True
return False
c = []
for _ in range(3):
c.append(list(map(int, input().split())))
ans = True
if not all_same(c[0][0]-c[1][0], c[0][1] - c[1][1], c[0][2]-c[1][2]):
ans = False
if not all_same(c[0][0]-c[2][0], c[0][1] - c[2][1], c[0][2]-c[2][2]):
ans = False
if not all_same(c[0][0] - c[0][1], c[1][0] - c[1][1], c[2][0] - c[2][1]):
ans = False
if not all_same(c[0][0] - c[0][2], c[1][0] - c[1][2], c[2][0] - c[2][2]):
ans = False
if ans:
print('Yes')
else:
print('No')
if __name__ == "__main__":
resolve()
| def resolve():
c = []
c.append(list(map(int, input().split())))
c.append(list(map(int, input().split())))
c.append(list(map(int, input().split())))
a01 = c[0][0] - c[0][1]
a02 = c[0][0] - c[0][2]
a12 = c[0][1] - c[0][2]
b01 = c[0][0] - c[1][0]
b02 = c[0][0] - c[2][0]
b12 = c[1][0] - c[2][0]
for i in range(3):
if ((c[i][0] - c[i][1]) != a01) or (c[i][0] - c[i][2] != a02) or (c[i][1] - c[i][2] != a12):
return False
if ((c[0][i] - c[1][i]) != b01 or (c[0][i] - c[2][i]) != b02 or (c[1][i] - c[2][i]) != b12):
return False
return True
if __name__ == "__main__":
if (resolve()):
print("Yes")
else:
print("No")
| 32 | 24 | 782 | 690 | # ABC 088 C
from collections import deque
def resolve():
def all_same(a, b, c):
if a == b and b == c:
return True
return False
c = []
for _ in range(3):
c.append(list(map(int, input().split())))
ans = True
if not all_same(c[0][0] - c[1][0], c[0][1] - c[1][1], c[0][2] - c[1][2]):
ans = False
if not all_same(c[0][0] - c[2][0], c[0][1] - c[2][1], c[0][2] - c[2][2]):
ans = False
if not all_same(c[0][0] - c[0][1], c[1][0] - c[1][1], c[2][0] - c[2][1]):
ans = False
if not all_same(c[0][0] - c[0][2], c[1][0] - c[1][2], c[2][0] - c[2][2]):
ans = False
if ans:
print("Yes")
else:
print("No")
if __name__ == "__main__":
resolve()
| def resolve():
c = []
c.append(list(map(int, input().split())))
c.append(list(map(int, input().split())))
c.append(list(map(int, input().split())))
a01 = c[0][0] - c[0][1]
a02 = c[0][0] - c[0][2]
a12 = c[0][1] - c[0][2]
b01 = c[0][0] - c[1][0]
b02 = c[0][0] - c[2][0]
b12 = c[1][0] - c[2][0]
for i in range(3):
if (
((c[i][0] - c[i][1]) != a01)
or (c[i][0] - c[i][2] != a02)
or (c[i][1] - c[i][2] != a12)
):
return False
if (
(c[0][i] - c[1][i]) != b01
or (c[0][i] - c[2][i]) != b02
or (c[1][i] - c[2][i]) != b12
):
return False
return True
if __name__ == "__main__":
if resolve():
print("Yes")
else:
print("No")
| false | 25 | [
"-# ABC 088 C",
"-from collections import deque",
"+def resolve():",
"+ c = []",
"+ c.append(list(map(int, input().split())))",
"+ c.append(list(map(int, input().split())))",
"+ c.append(list(map(int, input().split())))",
"+ a01 = c[0][0] - c[0][1]",
"+ a02 = c[0][0] - c[0][2]",
"+ a12 = c[0][1] - c[0][2]",
"+ b01 = c[0][0] - c[1][0]",
"+ b02 = c[0][0] - c[2][0]",
"+ b12 = c[1][0] - c[2][0]",
"+ for i in range(3):",
"+ if (",
"+ ((c[i][0] - c[i][1]) != a01)",
"+ or (c[i][0] - c[i][2] != a02)",
"+ or (c[i][1] - c[i][2] != a12)",
"+ ):",
"+ return False",
"+ if (",
"+ (c[0][i] - c[1][i]) != b01",
"+ or (c[0][i] - c[2][i]) != b02",
"+ or (c[1][i] - c[2][i]) != b12",
"+ ):",
"+ return False",
"+ return True",
"-def resolve():",
"- def all_same(a, b, c):",
"- if a == b and b == c:",
"- return True",
"- return False",
"-",
"- c = []",
"- for _ in range(3):",
"- c.append(list(map(int, input().split())))",
"- ans = True",
"- if not all_same(c[0][0] - c[1][0], c[0][1] - c[1][1], c[0][2] - c[1][2]):",
"- ans = False",
"- if not all_same(c[0][0] - c[2][0], c[0][1] - c[2][1], c[0][2] - c[2][2]):",
"- ans = False",
"- if not all_same(c[0][0] - c[0][1], c[1][0] - c[1][1], c[2][0] - c[2][1]):",
"- ans = False",
"- if not all_same(c[0][0] - c[0][2], c[1][0] - c[1][2], c[2][0] - c[2][2]):",
"- ans = False",
"- if ans:",
"+if __name__ == \"__main__\":",
"+ if resolve():",
"-",
"-",
"-if __name__ == \"__main__\":",
"- resolve()"
] | false | 0.047558 | 0.038896 | 1.222709 | [
"s779719430",
"s778183922"
] |
u625729943 | p02712 | python | s931468251 | s277101064 | 208 | 75 | 34,068 | 68,108 | Accepted | Accepted | 63.94 | import sys, math
from itertools import permutations, combinations
from collections import defaultdict, Counter, deque
from math import factorial#, gcd
from bisect import bisect_left #bisect_left(list, value)
sys.setrecursionlimit(10**7)
enu = enumerate
MOD = 10**9+7
def input(): return sys.stdin.readline()[:-1]
def pri(x): print(('\n'.join(map(str, x))))
N = int(eval(input()))
fb = []
for i in range(1, N+1):
if i%3==0 or i%5==0:
fb.append(0)
else:
fb.append(i)
print((sum(fb)))
| import sys, math
from itertools import permutations, combinations
from collections import defaultdict, Counter, deque
from math import factorial#, gcd
from bisect import bisect_left #bisect_left(list, value)
sys.setrecursionlimit(10**7)
enu = enumerate
MOD = 10**9+7
def input(): return sys.stdin.readline()[:-1]
def pri(x): print(('\n'.join(map(str, x))))
N = int(eval(input()))
cnt = 0
for i in range(1, N+1):
if i%3==0 or i%5==0:
pass
else:
cnt += i
print(cnt) | 22 | 20 | 521 | 500 | import sys, math
from itertools import permutations, combinations
from collections import defaultdict, Counter, deque
from math import factorial # , gcd
from bisect import bisect_left # bisect_left(list, value)
sys.setrecursionlimit(10**7)
enu = enumerate
MOD = 10**9 + 7
def input():
return sys.stdin.readline()[:-1]
def pri(x):
print(("\n".join(map(str, x))))
N = int(eval(input()))
fb = []
for i in range(1, N + 1):
if i % 3 == 0 or i % 5 == 0:
fb.append(0)
else:
fb.append(i)
print((sum(fb)))
| import sys, math
from itertools import permutations, combinations
from collections import defaultdict, Counter, deque
from math import factorial # , gcd
from bisect import bisect_left # bisect_left(list, value)
sys.setrecursionlimit(10**7)
enu = enumerate
MOD = 10**9 + 7
def input():
return sys.stdin.readline()[:-1]
def pri(x):
print(("\n".join(map(str, x))))
N = int(eval(input()))
cnt = 0
for i in range(1, N + 1):
if i % 3 == 0 or i % 5 == 0:
pass
else:
cnt += i
print(cnt)
| false | 9.090909 | [
"-fb = []",
"+cnt = 0",
"- fb.append(0)",
"+ pass",
"- fb.append(i)",
"-print((sum(fb)))",
"+ cnt += i",
"+print(cnt)"
] | false | 0.132534 | 0.204527 | 0.648001 | [
"s931468251",
"s277101064"
] |
u368796742 | p02851 | python | s575085882 | s615791389 | 335 | 269 | 48,936 | 41,352 | Accepted | Accepted | 19.7 | n,k = list(map(int,input().split()))
l = list(map(int,input().split()))
mo = [0]
mod = [0]
for i in range(n):
a = l[i]%k
mo.append((a+mo[-1])%k)
mod.append((mo[-1]-(i+1))%k)
dic = {0:1}
le = 1
ans = 0
for i in range(1,n+1):
if le < k:
if mod[i] in dic:
ans += dic[mod[i]]
dic[mod[i]] += 1
else:
dic[mod[i]] = 1
le += 1
else:
dic[mod[i-k]] -= 1
if mod[i] in dic:
ans += dic[mod[i]]
dic[mod[i]] += 1
else:
dic[mod[i]] = 1
print(ans)
| from collections import defaultdict
n,k = list(map(int,input().split()))
l = list(map(int,input().split()))
mod = [0]
for i in range(n):
a = (l[i]-1)%k
mod.append((mod[-1]+a)%k)
dic = {0:1}
ans = 0
for i in range(1,n+1):
if i < k:
if mod[i] in dic:
ans += dic[mod[i]]
dic[mod[i]] += 1
else:
dic[mod[i]] = 1
else:
dic[mod[i-k]] -= 1
if mod[i] in dic:
ans += dic[mod[i]]
dic[mod[i]] += 1
else:
dic[mod[i]] = 1
print(ans)
| 28 | 26 | 597 | 572 | n, k = list(map(int, input().split()))
l = list(map(int, input().split()))
mo = [0]
mod = [0]
for i in range(n):
a = l[i] % k
mo.append((a + mo[-1]) % k)
mod.append((mo[-1] - (i + 1)) % k)
dic = {0: 1}
le = 1
ans = 0
for i in range(1, n + 1):
if le < k:
if mod[i] in dic:
ans += dic[mod[i]]
dic[mod[i]] += 1
else:
dic[mod[i]] = 1
le += 1
else:
dic[mod[i - k]] -= 1
if mod[i] in dic:
ans += dic[mod[i]]
dic[mod[i]] += 1
else:
dic[mod[i]] = 1
print(ans)
| from collections import defaultdict
n, k = list(map(int, input().split()))
l = list(map(int, input().split()))
mod = [0]
for i in range(n):
a = (l[i] - 1) % k
mod.append((mod[-1] + a) % k)
dic = {0: 1}
ans = 0
for i in range(1, n + 1):
if i < k:
if mod[i] in dic:
ans += dic[mod[i]]
dic[mod[i]] += 1
else:
dic[mod[i]] = 1
else:
dic[mod[i - k]] -= 1
if mod[i] in dic:
ans += dic[mod[i]]
dic[mod[i]] += 1
else:
dic[mod[i]] = 1
print(ans)
| false | 7.142857 | [
"+from collections import defaultdict",
"+",
"-mo = [0]",
"- a = l[i] % k",
"- mo.append((a + mo[-1]) % k)",
"- mod.append((mo[-1] - (i + 1)) % k)",
"+ a = (l[i] - 1) % k",
"+ mod.append((mod[-1] + a) % k)",
"-le = 1",
"- if le < k:",
"+ if i < k:",
"- le += 1"
] | false | 0.041845 | 0.042857 | 0.97638 | [
"s575085882",
"s615791389"
] |
u553987207 | p02971 | python | s920933656 | s459691862 | 535 | 188 | 14,112 | 18,888 | Accepted | Accepted | 64.86 | N = int(eval(input()))
A = [int(eval(input())) for _ in range(N)]
sortedA = sorted(A, reverse=True)
for a in A:
if sortedA[0] != a:
print((sortedA[0]))
else:
print((sortedA[1])) | import sys
N = int(eval(input()))
A = [int(sys.stdin.readline()) for _ in range(N)]
sortedA = sorted(A, reverse=True)
for a in A:
if a == sortedA[0]:
print((sortedA[1]))
else:
print((sortedA[0])) | 9 | 9 | 194 | 217 | N = int(eval(input()))
A = [int(eval(input())) for _ in range(N)]
sortedA = sorted(A, reverse=True)
for a in A:
if sortedA[0] != a:
print((sortedA[0]))
else:
print((sortedA[1]))
| import sys
N = int(eval(input()))
A = [int(sys.stdin.readline()) for _ in range(N)]
sortedA = sorted(A, reverse=True)
for a in A:
if a == sortedA[0]:
print((sortedA[1]))
else:
print((sortedA[0]))
| false | 0 | [
"+import sys",
"+",
"-A = [int(eval(input())) for _ in range(N)]",
"+A = [int(sys.stdin.readline()) for _ in range(N)]",
"- if sortedA[0] != a:",
"+ if a == sortedA[0]:",
"+ print((sortedA[1]))",
"+ else:",
"- else:",
"- print((sortedA[1]))"
] | false | 0.08911 | 0.043448 | 2.050954 | [
"s920933656",
"s459691862"
] |
u400336986 | p02361 | python | s817516915 | s387004937 | 3,060 | 2,720 | 103,644 | 93,064 | Accepted | Accepted | 11.11 | import heapq
maxd = float('inf')
nv, ne, r = [int(n) for n in input().split(' ')]
vertices = {k: {} for k in range(nv)}
for i in range(ne):
s, t, w = [int(n) for n in input().split(' ')]
vertices[s][t] = w
q = []
heapq.heappush(q, (0, r))
dist = {v: maxd for v in vertices}
dist[r] = 0
while len(q):
u = heapq.heappop(q)[1]
for v in vertices[u]:
alt = dist[u] + vertices[u][v]
if alt < dist[v]:
dist[v] = alt
heapq.heappush(q, (alt, v))
[print(d) if d < maxd else print("INF") for v, d in dist.items()]
| import heapq
nv, ne, r = map(int, input().split(' '))
vertices = [[] for i in range(nv)]
for i in range(ne):
s, t, w = map(int, input().split(' '))
vertices[s].append((t, w))
q = []
heapq.heappush(q, (0, r))
dist = [float('inf')] * nv
dist[r] = 0
while len(q):
u = heapq.heappop(q)[1]
for t, w in vertices[u]:
alt = dist[u] + w
if alt < dist[t]:
dist[t] = alt
heapq.heappush(q, (alt, t))
[print(d) if d < float('inf') else print("INF") for d in dist]
| 25 | 24 | 588 | 535 | import heapq
maxd = float("inf")
nv, ne, r = [int(n) for n in input().split(" ")]
vertices = {k: {} for k in range(nv)}
for i in range(ne):
s, t, w = [int(n) for n in input().split(" ")]
vertices[s][t] = w
q = []
heapq.heappush(q, (0, r))
dist = {v: maxd for v in vertices}
dist[r] = 0
while len(q):
u = heapq.heappop(q)[1]
for v in vertices[u]:
alt = dist[u] + vertices[u][v]
if alt < dist[v]:
dist[v] = alt
heapq.heappush(q, (alt, v))
[print(d) if d < maxd else print("INF") for v, d in dist.items()]
| import heapq
nv, ne, r = map(int, input().split(" "))
vertices = [[] for i in range(nv)]
for i in range(ne):
s, t, w = map(int, input().split(" "))
vertices[s].append((t, w))
q = []
heapq.heappush(q, (0, r))
dist = [float("inf")] * nv
dist[r] = 0
while len(q):
u = heapq.heappop(q)[1]
for t, w in vertices[u]:
alt = dist[u] + w
if alt < dist[t]:
dist[t] = alt
heapq.heappush(q, (alt, t))
[print(d) if d < float("inf") else print("INF") for d in dist]
| false | 4 | [
"-maxd = float(\"inf\")",
"-nv, ne, r = [int(n) for n in input().split(\" \")]",
"-vertices = {k: {} for k in range(nv)}",
"+nv, ne, r = map(int, input().split(\" \"))",
"+vertices = [[] for i in range(nv)]",
"- s, t, w = [int(n) for n in input().split(\" \")]",
"- vertices[s][t] = w",
"+ s, t, w = map(int, input().split(\" \"))",
"+ vertices[s].append((t, w))",
"-dist = {v: maxd for v in vertices}",
"+dist = [float(\"inf\")] * nv",
"- for v in vertices[u]:",
"- alt = dist[u] + vertices[u][v]",
"- if alt < dist[v]:",
"- dist[v] = alt",
"- heapq.heappush(q, (alt, v))",
"-[print(d) if d < maxd else print(\"INF\") for v, d in dist.items()]",
"+ for t, w in vertices[u]:",
"+ alt = dist[u] + w",
"+ if alt < dist[t]:",
"+ dist[t] = alt",
"+ heapq.heappush(q, (alt, t))",
"+[print(d) if d < float(\"inf\") else print(\"INF\") for d in dist]"
] | false | 0.100168 | 0.111497 | 0.898392 | [
"s817516915",
"s387004937"
] |
u604839890 | p02641 | python | s483461468 | s166546971 | 62 | 28 | 61,996 | 9,104 | Accepted | Accepted | 54.84 | x, n = list(map(int, input().split()))
p = list(map(int, input().split()))
for i in range(1000):
tmp = [x-i, x+i]
if tmp[0] not in p:
print((tmp[0]))
exit()
elif tmp[1] not in p:
print((tmp[1]))
exit() | x, n = list(map(int, input().split()))
p = list(map(int, input().split()))
for i in range(1000):
if x-i not in p:
print((x-i))
exit()
elif x+i not in p:
print((x+i))
exit() | 10 | 10 | 222 | 212 | x, n = list(map(int, input().split()))
p = list(map(int, input().split()))
for i in range(1000):
tmp = [x - i, x + i]
if tmp[0] not in p:
print((tmp[0]))
exit()
elif tmp[1] not in p:
print((tmp[1]))
exit()
| x, n = list(map(int, input().split()))
p = list(map(int, input().split()))
for i in range(1000):
if x - i not in p:
print((x - i))
exit()
elif x + i not in p:
print((x + i))
exit()
| false | 0 | [
"- tmp = [x - i, x + i]",
"- if tmp[0] not in p:",
"- print((tmp[0]))",
"+ if x - i not in p:",
"+ print((x - i))",
"- elif tmp[1] not in p:",
"- print((tmp[1]))",
"+ elif x + i not in p:",
"+ print((x + i))"
] | false | 0.098699 | 0.087409 | 1.129165 | [
"s483461468",
"s166546971"
] |
u076917070 | p03031 | python | s035764255 | s244023500 | 46 | 21 | 3,064 | 3,064 | Accepted | Accepted | 54.35 | import sys
input=sys.stdin.readline
def main():
N,M=list(map(int, input().split()))
K=[]
for i in range(M):
K.append(list(map(int, input().split())))
P = list(map(int, input().split()))
ans = 0
for i in range(2**N):
s = "{:0" + str(N) +"b}"
b = True
for j in range(M):
x = 0
for k in K[j][1:]:
x += int(2**(N-k))
s = "{:b}".format(i&x)
if s.count("1")%2 != P[j]:
b = False
break
if b:
ans += 1
print(ans)
if __name__ == '__main__':
main()
| import sys
input=sys.stdin.readline
def main():
N,M=list(map(int, input().split()))
K=[]
for i in range(M):
sw = list(map(int, input().split()))
x = 0
for j in sw[1:]:
x += 2**(j-1)
K.append(x)
P = list(map(int, input().split()))
ans = 0
for i in range(2**N):
b = True
for j in range(M):
if "{:b}".format(i&K[j]).count("1") %2 != P[j]:
b = False
break
if b:
ans += 1
print(ans)
if __name__ == '__main__':
main()
| 28 | 29 | 643 | 595 | import sys
input = sys.stdin.readline
def main():
N, M = list(map(int, input().split()))
K = []
for i in range(M):
K.append(list(map(int, input().split())))
P = list(map(int, input().split()))
ans = 0
for i in range(2**N):
s = "{:0" + str(N) + "b}"
b = True
for j in range(M):
x = 0
for k in K[j][1:]:
x += int(2 ** (N - k))
s = "{:b}".format(i & x)
if s.count("1") % 2 != P[j]:
b = False
break
if b:
ans += 1
print(ans)
if __name__ == "__main__":
main()
| import sys
input = sys.stdin.readline
def main():
N, M = list(map(int, input().split()))
K = []
for i in range(M):
sw = list(map(int, input().split()))
x = 0
for j in sw[1:]:
x += 2 ** (j - 1)
K.append(x)
P = list(map(int, input().split()))
ans = 0
for i in range(2**N):
b = True
for j in range(M):
if "{:b}".format(i & K[j]).count("1") % 2 != P[j]:
b = False
break
if b:
ans += 1
print(ans)
if __name__ == "__main__":
main()
| false | 3.448276 | [
"- K.append(list(map(int, input().split())))",
"+ sw = list(map(int, input().split()))",
"+ x = 0",
"+ for j in sw[1:]:",
"+ x += 2 ** (j - 1)",
"+ K.append(x)",
"- s = \"{:0\" + str(N) + \"b}\"",
"- x = 0",
"- for k in K[j][1:]:",
"- x += int(2 ** (N - k))",
"- s = \"{:b}\".format(i & x)",
"- if s.count(\"1\") % 2 != P[j]:",
"+ if \"{:b}\".format(i & K[j]).count(\"1\") % 2 != P[j]:"
] | false | 0.048185 | 0.045569 | 1.057414 | [
"s035764255",
"s244023500"
] |
u864197622 | p02651 | python | s521650618 | s594910924 | 1,728 | 92 | 78,364 | 68,384 | Accepted | Accepted | 94.68 | from heapq import heappush, heappop
def calcSpace():
H = []
hpush = lambda x: heappush(H, -x)
hpop = lambda: -heappop(H)
for x in X:
hpush(x)
E = [0] * 60
while H:
x = hpop()
b = x.bit_length() - 1
if E[b]:
x ^= E[b]
if x: hpush(x)
else:
E[b] = x
return E
def chk(y):
y0 = y
for i in range(60)[::-1]:
if y >> i & 1:
if V[i]:
y ^= V[i]
# print("chk", y0, "OK", V)
if y == 0: return 1
else:
return 0
def chk_all():
for y in Y:
if chk(y) == 0:
return 1
break
else:
return 0
T = int(eval(input()))
for _ in range(T):
N = int(eval(input()))
A = [int(a) for a in input().split()]
S = [int(a) for a in eval(input())]
if 0:
print(("N =", N))
print(("A =", A))
print(("S =", S))
X = []
Y = []
i = N - 1
ans = 0
while i >= 0:
while i >= 0:
if S[i]: break
X.append(A[i])
i -= 1
while i >= 0:
if S[i] == 0: break
Y.append(A[i])
i -= 1
V = calcSpace()
# print("X =", X)
# print("Y =", Y)
# print("V =", V)
if chk_all():
ans = 1
i = -1
print(ans) | class VectorSpace:
def __init__(self, k):
self.k = k
self.E = [0] * k
def chk(self, n):
for i in range(self.k)[::-1]:
n = min(n, n ^ self.E[i])
return 1 if n == 0 else 0
def add(self, n):
for i in range(self.k)[::-1]:
n = min(n, n ^ self.E[i])
if n: self.E[n.bit_length() - 1] = n
return 1 if n == 0 else 0
def dimension(self):
return len(self.E)
T = int(eval(input()))
for _ in range(T):
N = int(eval(input()))
A = [int(a) for a in input().split()]
S = [int(a) for a in eval(input())]
vs = VectorSpace(60)
for i in range(N)[::-1]:
a = vs.add(A[i])
if S[i] and a == 0:
print((1))
break
else:
print((0)) | 74 | 32 | 1,515 | 803 | from heapq import heappush, heappop
def calcSpace():
H = []
hpush = lambda x: heappush(H, -x)
hpop = lambda: -heappop(H)
for x in X:
hpush(x)
E = [0] * 60
while H:
x = hpop()
b = x.bit_length() - 1
if E[b]:
x ^= E[b]
if x:
hpush(x)
else:
E[b] = x
return E
def chk(y):
y0 = y
for i in range(60)[::-1]:
if y >> i & 1:
if V[i]:
y ^= V[i]
# print("chk", y0, "OK", V)
if y == 0:
return 1
else:
return 0
def chk_all():
for y in Y:
if chk(y) == 0:
return 1
break
else:
return 0
T = int(eval(input()))
for _ in range(T):
N = int(eval(input()))
A = [int(a) for a in input().split()]
S = [int(a) for a in eval(input())]
if 0:
print(("N =", N))
print(("A =", A))
print(("S =", S))
X = []
Y = []
i = N - 1
ans = 0
while i >= 0:
while i >= 0:
if S[i]:
break
X.append(A[i])
i -= 1
while i >= 0:
if S[i] == 0:
break
Y.append(A[i])
i -= 1
V = calcSpace()
# print("X =", X)
# print("Y =", Y)
# print("V =", V)
if chk_all():
ans = 1
i = -1
print(ans)
| class VectorSpace:
def __init__(self, k):
self.k = k
self.E = [0] * k
def chk(self, n):
for i in range(self.k)[::-1]:
n = min(n, n ^ self.E[i])
return 1 if n == 0 else 0
def add(self, n):
for i in range(self.k)[::-1]:
n = min(n, n ^ self.E[i])
if n:
self.E[n.bit_length() - 1] = n
return 1 if n == 0 else 0
def dimension(self):
return len(self.E)
T = int(eval(input()))
for _ in range(T):
N = int(eval(input()))
A = [int(a) for a in input().split()]
S = [int(a) for a in eval(input())]
vs = VectorSpace(60)
for i in range(N)[::-1]:
a = vs.add(A[i])
if S[i] and a == 0:
print((1))
break
else:
print((0))
| false | 56.756757 | [
"-from heapq import heappush, heappop",
"+class VectorSpace:",
"+ def __init__(self, k):",
"+ self.k = k",
"+ self.E = [0] * k",
"+ def chk(self, n):",
"+ for i in range(self.k)[::-1]:",
"+ n = min(n, n ^ self.E[i])",
"+ return 1 if n == 0 else 0",
"-def calcSpace():",
"- H = []",
"- hpush = lambda x: heappush(H, -x)",
"- hpop = lambda: -heappop(H)",
"- for x in X:",
"- hpush(x)",
"- E = [0] * 60",
"- while H:",
"- x = hpop()",
"- b = x.bit_length() - 1",
"- if E[b]:",
"- x ^= E[b]",
"- if x:",
"- hpush(x)",
"- else:",
"- E[b] = x",
"- return E",
"+ def add(self, n):",
"+ for i in range(self.k)[::-1]:",
"+ n = min(n, n ^ self.E[i])",
"+ if n:",
"+ self.E[n.bit_length() - 1] = n",
"+ return 1 if n == 0 else 0",
"-",
"-def chk(y):",
"- y0 = y",
"- for i in range(60)[::-1]:",
"- if y >> i & 1:",
"- if V[i]:",
"- y ^= V[i]",
"- # print(\"chk\", y0, \"OK\", V)",
"- if y == 0:",
"- return 1",
"- else:",
"- return 0",
"-",
"-",
"-def chk_all():",
"- for y in Y:",
"- if chk(y) == 0:",
"- return 1",
"- break",
"- else:",
"- return 0",
"+ def dimension(self):",
"+ return len(self.E)",
"- if 0:",
"- print((\"N =\", N))",
"- print((\"A =\", A))",
"- print((\"S =\", S))",
"- X = []",
"- Y = []",
"- i = N - 1",
"- ans = 0",
"- while i >= 0:",
"- while i >= 0:",
"- if S[i]:",
"- break",
"- X.append(A[i])",
"- i -= 1",
"- while i >= 0:",
"- if S[i] == 0:",
"- break",
"- Y.append(A[i])",
"- i -= 1",
"- V = calcSpace()",
"- # print(\"X =\", X)",
"- # print(\"Y =\", Y)",
"- # print(\"V =\", V)",
"- if chk_all():",
"- ans = 1",
"- i = -1",
"- print(ans)",
"+ vs = VectorSpace(60)",
"+ for i in range(N)[::-1]:",
"+ a = vs.add(A[i])",
"+ if S[i] and a == 0:",
"+ print((1))",
"+ break",
"+ else:",
"+ print((0))"
] | false | 0.05916 | 0.036113 | 1.638186 | [
"s521650618",
"s594910924"
] |
u644907318 | p03608 | python | s459676407 | s708550673 | 550 | 212 | 49,496 | 76,920 | Accepted | Accepted | 61.45 | from itertools import permutations
INFTY = 10**8
N,M,R = list(map(int,input().split()))
A = list(map(int,input().split()))
G = {i:[] for i in range(1,N+1)}
for _ in range(M):
a,b,c = list(map(int,input().split()))
G[a].append((b,c))
G[b].append((a,c))
d = {i:[INFTY for _ in range(N+1)] for i in range(N+1)}
for i in G:
d[i][i] = 0
for x in G[i]:
d[i][x[0]] = x[1]
for k in range(1,N+1):
for i in range(1,N+1):
for j in range(1,N+1):
d[i][j] = min(d[i][j],d[i][k]+d[k][j])
dmin = INFTY
for x in permutations(list(range(R)),R):
cnt = 0
for i in range(R-1):
cnt += d[A[x[i]]][A[x[i+1]]]
dmin = min(dmin,cnt)
print(dmin) | from itertools import permutations
INFTY = 10**8
N,M,R = list(map(int,input().split()))
r = list(map(int,input().split()))
G = {i:[] for i in range(1,N+1)}
for _ in range(M):
a,b,c = list(map(int,input().split()))
G[a].append((b,c))
G[b].append((a,c))
dist = [[INFTY for _ in range(N+1)] for _ in range(N+1)]
for i in range(1,N+1):
dist[i][i] = 0
for i in range(1,N+1):
for j,d in G[i]:
dist[i][j] = d
for k in range(1,N+1):
for i in range(1,N+1):
for j in range(1,N+1):
dist[i][j] = min(dist[i][j],dist[i][k]+dist[k][j])
dmin = 10**8
for x in permutations(list(range(R)),R):
d = 0
for k in range(1,R):
d += dist[r[x[k]]][r[x[k-1]]]
dmin = min(dmin,d)
print(dmin) | 25 | 26 | 696 | 742 | from itertools import permutations
INFTY = 10**8
N, M, R = list(map(int, input().split()))
A = list(map(int, input().split()))
G = {i: [] for i in range(1, N + 1)}
for _ in range(M):
a, b, c = list(map(int, input().split()))
G[a].append((b, c))
G[b].append((a, c))
d = {i: [INFTY for _ in range(N + 1)] for i in range(N + 1)}
for i in G:
d[i][i] = 0
for x in G[i]:
d[i][x[0]] = x[1]
for k in range(1, N + 1):
for i in range(1, N + 1):
for j in range(1, N + 1):
d[i][j] = min(d[i][j], d[i][k] + d[k][j])
dmin = INFTY
for x in permutations(list(range(R)), R):
cnt = 0
for i in range(R - 1):
cnt += d[A[x[i]]][A[x[i + 1]]]
dmin = min(dmin, cnt)
print(dmin)
| from itertools import permutations
INFTY = 10**8
N, M, R = list(map(int, input().split()))
r = list(map(int, input().split()))
G = {i: [] for i in range(1, N + 1)}
for _ in range(M):
a, b, c = list(map(int, input().split()))
G[a].append((b, c))
G[b].append((a, c))
dist = [[INFTY for _ in range(N + 1)] for _ in range(N + 1)]
for i in range(1, N + 1):
dist[i][i] = 0
for i in range(1, N + 1):
for j, d in G[i]:
dist[i][j] = d
for k in range(1, N + 1):
for i in range(1, N + 1):
for j in range(1, N + 1):
dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j])
dmin = 10**8
for x in permutations(list(range(R)), R):
d = 0
for k in range(1, R):
d += dist[r[x[k]]][r[x[k - 1]]]
dmin = min(dmin, d)
print(dmin)
| false | 3.846154 | [
"-A = list(map(int, input().split()))",
"+r = list(map(int, input().split()))",
"-d = {i: [INFTY for _ in range(N + 1)] for i in range(N + 1)}",
"-for i in G:",
"- d[i][i] = 0",
"- for x in G[i]:",
"- d[i][x[0]] = x[1]",
"+dist = [[INFTY for _ in range(N + 1)] for _ in range(N + 1)]",
"+for i in range(1, N + 1):",
"+ dist[i][i] = 0",
"+for i in range(1, N + 1):",
"+ for j, d in G[i]:",
"+ dist[i][j] = d",
"- d[i][j] = min(d[i][j], d[i][k] + d[k][j])",
"-dmin = INFTY",
"+ dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j])",
"+dmin = 10**8",
"- cnt = 0",
"- for i in range(R - 1):",
"- cnt += d[A[x[i]]][A[x[i + 1]]]",
"- dmin = min(dmin, cnt)",
"+ d = 0",
"+ for k in range(1, R):",
"+ d += dist[r[x[k]]][r[x[k - 1]]]",
"+ dmin = min(dmin, d)"
] | false | 0.036045 | 0.036181 | 0.996238 | [
"s459676407",
"s708550673"
] |
u296518383 | p03478 | python | s930766678 | s769498131 | 34 | 24 | 3,060 | 3,060 | Accepted | Accepted | 29.41 | N,A,B=list(map(int,input().split()))
def add(n,a,b):
res=sum(map(int,list(str(n))))
return n if res>=a and res<=b else 0
ans=0
for i in range(1,N+1):
ans+=add(i,A,B)
print(ans) | N, A, B = list(map(int, input().split()))
def digit_sum(n):
res = 0
while n:
res += n % 10
n //= 10
return res
answer = 0
for i in range(1, N + 1):
if A <= digit_sum(i) <= B:
answer += i
print(answer) | 10 | 15 | 187 | 235 | N, A, B = list(map(int, input().split()))
def add(n, a, b):
res = sum(map(int, list(str(n))))
return n if res >= a and res <= b else 0
ans = 0
for i in range(1, N + 1):
ans += add(i, A, B)
print(ans)
| N, A, B = list(map(int, input().split()))
def digit_sum(n):
res = 0
while n:
res += n % 10
n //= 10
return res
answer = 0
for i in range(1, N + 1):
if A <= digit_sum(i) <= B:
answer += i
print(answer)
| false | 33.333333 | [
"-def add(n, a, b):",
"- res = sum(map(int, list(str(n))))",
"- return n if res >= a and res <= b else 0",
"+def digit_sum(n):",
"+ res = 0",
"+ while n:",
"+ res += n % 10",
"+ n //= 10",
"+ return res",
"-ans = 0",
"+answer = 0",
"- ans += add(i, A, B)",
"-print(ans)",
"+ if A <= digit_sum(i) <= B:",
"+ answer += i",
"+print(answer)"
] | false | 0.042155 | 0.037752 | 1.116613 | [
"s930766678",
"s769498131"
] |
u222668979 | p03062 | python | s314943495 | s132229196 | 101 | 90 | 85,344 | 85,360 | Accepted | Accepted | 10.89 | n = int(eval(input()))
a = list(map(int, input().split()))
cnt = sum(i < 0 for i in a)
ans = sum(abs(i) for i in a)
if cnt % 2 == 0:
print(ans)
elif cnt % 2 == 1:
print((ans - 2 * min(abs(i) for i in a)))
| n = int(eval(input()))
a = list(map(int, input().split()))
cnt, ans, num = 0, 0, 10 ** 10
for ai in a:
cnt += (ai < 0)
ans += abs(ai)
num = min(num, abs(ai))
print((ans if cnt % 2 == 0 else ans - 2 * num))
| 9 | 9 | 214 | 219 | n = int(eval(input()))
a = list(map(int, input().split()))
cnt = sum(i < 0 for i in a)
ans = sum(abs(i) for i in a)
if cnt % 2 == 0:
print(ans)
elif cnt % 2 == 1:
print((ans - 2 * min(abs(i) for i in a)))
| n = int(eval(input()))
a = list(map(int, input().split()))
cnt, ans, num = 0, 0, 10**10
for ai in a:
cnt += ai < 0
ans += abs(ai)
num = min(num, abs(ai))
print((ans if cnt % 2 == 0 else ans - 2 * num))
| false | 0 | [
"-cnt = sum(i < 0 for i in a)",
"-ans = sum(abs(i) for i in a)",
"-if cnt % 2 == 0:",
"- print(ans)",
"-elif cnt % 2 == 1:",
"- print((ans - 2 * min(abs(i) for i in a)))",
"+cnt, ans, num = 0, 0, 10**10",
"+for ai in a:",
"+ cnt += ai < 0",
"+ ans += abs(ai)",
"+ num = min(num, abs(ai))",
"+print((ans if cnt % 2 == 0 else ans - 2 * num))"
] | false | 0.133332 | 0.007353 | 18.132823 | [
"s314943495",
"s132229196"
] |
u714642969 | p03288 | python | s719384690 | s551716373 | 181 | 86 | 38,256 | 61,084 | Accepted | Accepted | 52.49 | R=int(eval(input()))
if R<1200:
print('ABC')
elif R<2800:
print('ARC')
else:
print('AGC') | # -*- coding: utf-8 -*-
import sys
sys.setrecursionlimit(10**9)
INF=10**18
MOD=10**9+7
input=lambda: sys.stdin.readline().rstrip()
YesNo=lambda b: bool([print('Yes')] if b else print('No'))
YESNO=lambda b: bool([print('YES')] if b else print('NO'))
int1=lambda x:int(x)-1
R=int(input())
if R>=2800:
print('AGC')
elif R>=1200:
print('ARC')
else:
print('ABC')
| 7 | 17 | 95 | 386 | R = int(eval(input()))
if R < 1200:
print("ABC")
elif R < 2800:
print("ARC")
else:
print("AGC")
| # -*- coding: utf-8 -*-
import sys
sys.setrecursionlimit(10**9)
INF = 10**18
MOD = 10**9 + 7
input = lambda: sys.stdin.readline().rstrip()
YesNo = lambda b: bool([print("Yes")] if b else print("No"))
YESNO = lambda b: bool([print("YES")] if b else print("NO"))
int1 = lambda x: int(x) - 1
R = int(input())
if R >= 2800:
print("AGC")
elif R >= 1200:
print("ARC")
else:
print("ABC")
| false | 58.823529 | [
"-R = int(eval(input()))",
"-if R < 1200:",
"- print(\"ABC\")",
"-elif R < 2800:",
"+# -*- coding: utf-8 -*-",
"+import sys",
"+",
"+sys.setrecursionlimit(10**9)",
"+INF = 10**18",
"+MOD = 10**9 + 7",
"+input = lambda: sys.stdin.readline().rstrip()",
"+YesNo = lambda b: bool([print(\"Yes\")] if b else print(\"No\"))",
"+YESNO = lambda b: bool([print(\"YES\")] if b else print(\"NO\"))",
"+int1 = lambda x: int(x) - 1",
"+R = int(input())",
"+if R >= 2800:",
"+ print(\"AGC\")",
"+elif R >= 1200:",
"- print(\"AGC\")",
"+ print(\"ABC\")"
] | false | 0.092229 | 0.040295 | 2.288807 | [
"s719384690",
"s551716373"
] |
u816587940 | p02713 | python | s024246906 | s051144224 | 957 | 241 | 9,204 | 68,528 | Accepted | Accepted | 74.82 | k = int(eval(input()))
def gcd(a, b):
if a < b: a, b = b, a
c = a % b
if c == 0: return b
while c!=0:
c = a % b
a = b
b = c
return a
ans = 0
for a in range(1, k+1):
for b in range(1, k+1):
t = gcd(a, b)
if t == 1:
ans += k
continue
for c in range(1, k+1):
ans += gcd(t, c)
print(ans)
| k = int(eval(input()))
def gcd(a, b):
if a < b: a, b = b, a
c = a % b
if c == 0: return b
while c!=0:
c = a % b
a, b = b, c
return a
ans = 0
for a in range(1, k+1):
for b in range(1, k+1):
t = gcd(a, b)
if t == 1:
ans += k
continue
for c in range(1, k+1):
ans += gcd(t, c)
print(ans)
| 22 | 21 | 409 | 400 | k = int(eval(input()))
def gcd(a, b):
if a < b:
a, b = b, a
c = a % b
if c == 0:
return b
while c != 0:
c = a % b
a = b
b = c
return a
ans = 0
for a in range(1, k + 1):
for b in range(1, k + 1):
t = gcd(a, b)
if t == 1:
ans += k
continue
for c in range(1, k + 1):
ans += gcd(t, c)
print(ans)
| k = int(eval(input()))
def gcd(a, b):
if a < b:
a, b = b, a
c = a % b
if c == 0:
return b
while c != 0:
c = a % b
a, b = b, c
return a
ans = 0
for a in range(1, k + 1):
for b in range(1, k + 1):
t = gcd(a, b)
if t == 1:
ans += k
continue
for c in range(1, k + 1):
ans += gcd(t, c)
print(ans)
| false | 4.545455 | [
"- a = b",
"- b = c",
"+ a, b = b, c"
] | false | 0.08129 | 0.118687 | 0.684917 | [
"s024246906",
"s051144224"
] |
u475503988 | p03086 | python | s123782116 | s456420122 | 20 | 17 | 2,940 | 3,060 | Accepted | Accepted | 15 | S = eval(input())
L = 'ACGT'
n, num = 0, 0
for s in S:
if s in L:
n += 1
else:
num = max(num, n)
n = 0
num = max(num, n)
print(num) | S = eval(input())
L = ['A', 'T', 'C', 'G']
n, num = 0, 0
for s in S:
if s in L:
n += 1
else:
num = max(num, n)
n = 0
num = max(num, n)
print(num) | 11 | 11 | 167 | 181 | S = eval(input())
L = "ACGT"
n, num = 0, 0
for s in S:
if s in L:
n += 1
else:
num = max(num, n)
n = 0
num = max(num, n)
print(num)
| S = eval(input())
L = ["A", "T", "C", "G"]
n, num = 0, 0
for s in S:
if s in L:
n += 1
else:
num = max(num, n)
n = 0
num = max(num, n)
print(num)
| false | 0 | [
"-L = \"ACGT\"",
"+L = [\"A\", \"T\", \"C\", \"G\"]"
] | false | 0.041154 | 0.040967 | 1.004563 | [
"s123782116",
"s456420122"
] |
u706414019 | p04044 | python | s167066088 | s278274844 | 29 | 26 | 9,176 | 9,024 | Accepted | Accepted | 10.34 | N,L = input().split()
txt = []
for i in range(int(N)):
s = eval(input())
txt.append(s)
txt_sort = sorted(txt)
ts = ""
for i in range(int(N)):
ts += txt_sort[i]
print(ts)
| n,l=map(int,input().split())
s=sorted([input() for i in range(n)])
print(*s,sep="")
| 10 | 3 | 185 | 85 | N, L = input().split()
txt = []
for i in range(int(N)):
s = eval(input())
txt.append(s)
txt_sort = sorted(txt)
ts = ""
for i in range(int(N)):
ts += txt_sort[i]
print(ts)
| n, l = map(int, input().split())
s = sorted([input() for i in range(n)])
print(*s, sep="")
| false | 70 | [
"-N, L = input().split()",
"-txt = []",
"-for i in range(int(N)):",
"- s = eval(input())",
"- txt.append(s)",
"-txt_sort = sorted(txt)",
"-ts = \"\"",
"-for i in range(int(N)):",
"- ts += txt_sort[i]",
"-print(ts)",
"+n, l = map(int, input().split())",
"+s = sorted([input() for i in range(n)])",
"+print(*s, sep=\"\")"
] | false | 0.039158 | 0.059369 | 0.65957 | [
"s167066088",
"s278274844"
] |
u811434779 | p00446 | python | s788260691 | s833957865 | 20 | 10 | 6,432 | 6,412 | Accepted | Accepted | 50 | while 1:
t = eval(input())
if t ==0: break
card1 = []
for i in range(t):
card1 += [eval(input())]
t *= 2
card1 = sorted(card1)
card2 = list(range(1,t+1))
for x in card1:
card2.remove(x)
ba = 0
turn = 1
while 1:
if len(card1)==0 or len(card2)==0: break
card = card1 if turn else card2
cnt = 0
while cnt < len(card):
if card[cnt] > ba: break
cnt+=1
if cnt != len(card):
ba = card.pop(cnt); turn = 1 - turn;
else:
ba = 0; turn = 1 - turn;
print(len(card2))
print(len(card1)) | while 1:
n = eval(input())
if n == 0: break
card1 = sorted([eval(input()) for i in range(n)])
card2 = [i for i in range(1,2*n+1) if i not in card1]
ba = 0
turn = 1
while card1 and card2:
card = card1 if turn else card2
for i in range(len(card)):
if card[i] > ba:
ba = card.pop(i)
break
else:
ba = 0
turn ^= 1
print(len(card2))
print(len(card1)) | 26 | 18 | 640 | 471 | while 1:
t = eval(input())
if t == 0:
break
card1 = []
for i in range(t):
card1 += [eval(input())]
t *= 2
card1 = sorted(card1)
card2 = list(range(1, t + 1))
for x in card1:
card2.remove(x)
ba = 0
turn = 1
while 1:
if len(card1) == 0 or len(card2) == 0:
break
card = card1 if turn else card2
cnt = 0
while cnt < len(card):
if card[cnt] > ba:
break
cnt += 1
if cnt != len(card):
ba = card.pop(cnt)
turn = 1 - turn
else:
ba = 0
turn = 1 - turn
print(len(card2))
print(len(card1))
| while 1:
n = eval(input())
if n == 0:
break
card1 = sorted([eval(input()) for i in range(n)])
card2 = [i for i in range(1, 2 * n + 1) if i not in card1]
ba = 0
turn = 1
while card1 and card2:
card = card1 if turn else card2
for i in range(len(card)):
if card[i] > ba:
ba = card.pop(i)
break
else:
ba = 0
turn ^= 1
print(len(card2))
print(len(card1))
| false | 30.769231 | [
"- t = eval(input())",
"- if t == 0:",
"+ n = eval(input())",
"+ if n == 0:",
"- card1 = []",
"- for i in range(t):",
"- card1 += [eval(input())]",
"- t *= 2",
"- card1 = sorted(card1)",
"- card2 = list(range(1, t + 1))",
"- for x in card1:",
"- card2.remove(x)",
"+ card1 = sorted([eval(input()) for i in range(n)])",
"+ card2 = [i for i in range(1, 2 * n + 1) if i not in card1]",
"- while 1:",
"- if len(card1) == 0 or len(card2) == 0:",
"- break",
"+ while card1 and card2:",
"- cnt = 0",
"- while cnt < len(card):",
"- if card[cnt] > ba:",
"+ for i in range(len(card)):",
"+ if card[i] > ba:",
"+ ba = card.pop(i)",
"- cnt += 1",
"- if cnt != len(card):",
"- ba = card.pop(cnt)",
"- turn = 1 - turn",
"- turn = 1 - turn",
"+ turn ^= 1"
] | false | 0.035193 | 0.033045 | 1.065001 | [
"s788260691",
"s833957865"
] |
u952708174 | p04031 | python | s898524770 | s445165323 | 24 | 19 | 3,060 | 3,188 | Accepted | Accepted | 20.83 | N = int(eval(input()))
A = [int(i) for i in input().split()]
ans = float('inf')
for x in range(-100,101):
tmp = 0
for a in A:
tmp += (x-a)**2
ans = min(ans,tmp)
print(ans) | def c_be_together(N, A):
a_sum = sum(A)
option = (a_sum // N, (a_sum + N - 1) // N)
ans = float('inf')
for opt in option:
ans = min(ans, sum([(a - opt)**2 for a in A]))
return ans
N = int(eval(input()))
A = [int(i) for i in input().split()]
print((c_be_together(N, A))) | 10 | 11 | 185 | 300 | N = int(eval(input()))
A = [int(i) for i in input().split()]
ans = float("inf")
for x in range(-100, 101):
tmp = 0
for a in A:
tmp += (x - a) ** 2
ans = min(ans, tmp)
print(ans)
| def c_be_together(N, A):
a_sum = sum(A)
option = (a_sum // N, (a_sum + N - 1) // N)
ans = float("inf")
for opt in option:
ans = min(ans, sum([(a - opt) ** 2 for a in A]))
return ans
N = int(eval(input()))
A = [int(i) for i in input().split()]
print((c_be_together(N, A)))
| false | 9.090909 | [
"+def c_be_together(N, A):",
"+ a_sum = sum(A)",
"+ option = (a_sum // N, (a_sum + N - 1) // N)",
"+ ans = float(\"inf\")",
"+ for opt in option:",
"+ ans = min(ans, sum([(a - opt) ** 2 for a in A]))",
"+ return ans",
"+",
"+",
"-ans = float(\"inf\")",
"-for x in range(-100, 101):",
"- tmp = 0",
"- for a in A:",
"- tmp += (x - a) ** 2",
"- ans = min(ans, tmp)",
"-print(ans)",
"+print((c_be_together(N, A)))"
] | false | 0.077056 | 0.123157 | 0.625677 | [
"s898524770",
"s445165323"
] |
u952708174 | p03309 | python | s283772098 | s568335037 | 512 | 241 | 29,520 | 29,540 | Accepted | Accepted | 52.93 | def c_linear_approximation(N, A):
import numpy
B = numpy.array([a-k for k, a in enumerate(A)])
b = int(numpy.median(B))
ans = 0
for b_k in B:
ans += abs(b_k - b)
return ans
N = int(eval(input()))
A = [int(i) for i in input().split()]
print((c_linear_approximation(N, A))) | def c_linear_approximation(N, A):
import numpy
B = numpy.array([a-k for k, a in enumerate(A)]) # B_k = A_k - k
b = int(numpy.median(B)) # Bの中央値を選ぶのが最適
ans = numpy.sum(abs(B - b)) # 実際に悲しみを計算
return ans
N = int(eval(input()))
A = [int(i) for i in input().split()]
print((c_linear_approximation(N, A))) | 12 | 10 | 307 | 325 | def c_linear_approximation(N, A):
import numpy
B = numpy.array([a - k for k, a in enumerate(A)])
b = int(numpy.median(B))
ans = 0
for b_k in B:
ans += abs(b_k - b)
return ans
N = int(eval(input()))
A = [int(i) for i in input().split()]
print((c_linear_approximation(N, A)))
| def c_linear_approximation(N, A):
import numpy
B = numpy.array([a - k for k, a in enumerate(A)]) # B_k = A_k - k
b = int(numpy.median(B)) # Bの中央値を選ぶのが最適
ans = numpy.sum(abs(B - b)) # 実際に悲しみを計算
return ans
N = int(eval(input()))
A = [int(i) for i in input().split()]
print((c_linear_approximation(N, A)))
| false | 16.666667 | [
"- B = numpy.array([a - k for k, a in enumerate(A)])",
"- b = int(numpy.median(B))",
"- ans = 0",
"- for b_k in B:",
"- ans += abs(b_k - b)",
"+ B = numpy.array([a - k for k, a in enumerate(A)]) # B_k = A_k - k",
"+ b = int(numpy.median(B)) # Bの中央値を選ぶのが最適",
"+ ans = numpy.sum(abs(B - b)) # 実際に悲しみを計算"
] | false | 0.456822 | 0.272029 | 1.679313 | [
"s283772098",
"s568335037"
] |
u655761160 | p03632 | python | s303447763 | s742704156 | 19 | 17 | 3,060 | 2,940 | Accepted | Accepted | 10.53 | A, B, C, D = list(map(int, input().split(' ')))
print((max(0, min(B, D) - max(A, C))))
| A, B, C, D = list(map(int, input().split()))
print((max(0, min(B, D) - max(A, C)))) | 2 | 2 | 80 | 76 | A, B, C, D = list(map(int, input().split(" ")))
print((max(0, min(B, D) - max(A, C))))
| A, B, C, D = list(map(int, input().split()))
print((max(0, min(B, D) - max(A, C))))
| false | 0 | [
"-A, B, C, D = list(map(int, input().split(\" \")))",
"+A, B, C, D = list(map(int, input().split()))"
] | false | 0.04154 | 0.041178 | 1.008793 | [
"s303447763",
"s742704156"
] |
u304058693 | p03281 | python | s161053905 | s720472151 | 32 | 26 | 9,084 | 9,144 | Accepted | Accepted | 18.75 | n = int(eval(input()))
ans = 0
for i in range(1, n+1 ,2):
divisor_count = 0
for j in range(1, i+1):
if i%j == 0:
divisor_count +=1
if divisor_count == 8:
ans += 1
print(ans)
| n = int(eval(input()))
ans = 0
for i in range(1, n + 1 ,2):
divisor_count = 0
for j in range(1, i + 1):
if i % j == 0:
divisor_count += 1
if divisor_count == 8:
ans += 1
print(ans)
| 12 | 12 | 237 | 228 | n = int(eval(input()))
ans = 0
for i in range(1, n + 1, 2):
divisor_count = 0
for j in range(1, i + 1):
if i % j == 0:
divisor_count += 1
if divisor_count == 8:
ans += 1
print(ans)
| n = int(eval(input()))
ans = 0
for i in range(1, n + 1, 2):
divisor_count = 0
for j in range(1, i + 1):
if i % j == 0:
divisor_count += 1
if divisor_count == 8:
ans += 1
print(ans)
| false | 0 | [
"- if divisor_count == 8:",
"- ans += 1",
"+ if divisor_count == 8:",
"+ ans += 1"
] | false | 0.03635 | 0.041834 | 0.868915 | [
"s161053905",
"s720472151"
] |
u367701763 | p02684 | python | s953083438 | s739620332 | 302 | 133 | 183,152 | 125,848 | Accepted | Accepted | 55.96 | import sys
input = sys.stdin.readline
class Doubling:
def __init__(self, A, K_max, decrement=True):
"""
:param A: リスト。i から A[i] へと移動する
:param K_max: K_max = 2**(k_max) まで参照する可能性がある
:param decrement: True = A の要素の decrement が必要
"""
self.k_max = K_max.bit_length()
self.n = len(A)
self.decrement = decrement
self.doubling = [[-1] * self.n for _ in range(self.k_max)]
for i, a in enumerate(A):
self.doubling[0][i] = a - self.decrement
for i in range(1, self.k_max):
for j in range(self.n):
if self.doubling[i - 1][j] != -1:
self.doubling[i][j] = self.doubling[i - 1][self.doubling[i - 1][j]]
def apply(self, start, K):
"""
:param start: スタート地点
:param K: K回進む
:return:
"""
i = start - self.decrement
for k in range(K.bit_length()):
m = 1 << k
if m & K:
i = self.doubling[k][i]
if i is None:
break
return i + self.decrement
######################################################################################
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
doubling = Doubling(A, 10**18 + 1, decrement=True)
print((doubling.apply(1, K))) | def cycle_getter(N, start):
"""
:param N: 移動回数
:param start: 初期条件
:return front: cycleまでの要素のリスト
cycle: cycle内の要素のリスト
end: cycle後の余った部分の要素のリスト
cnt: cycle回数
"""
p = start
front, cycle, end = [], [], []
cnt = 0
visit = {p:0}
L, R = N, -1
P = [p]
for i in range(1,N):
p = lift(p)
if p in visit:
"""
(L, R) = (サイクルに入るまでに移動した回数, サイクルの終端に着くまでに移動した回数)
[6,2,3,4,0,1,2] ⇒ (L, R) = (1, 6)
"""
L, R = visit[p], i
period = R-L
break
visit[p] = i
P.append(p)
front = P[:L]
if L != N:
cycle, end = P[L:R], P[L:L+(N-L)%period]
cnt = (N-L)//period
return front, cycle, end, cnt
################################################################################
import sys
input = sys.stdin.readline
def lift(x): return A[x-1]
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
front, cycle, end, cnt = cycle_getter(K+1,1)
# print(front, cycle, end, cnt)
print(((front+cycle+end)[-1])) | 45 | 46 | 1,392 | 1,159 | import sys
input = sys.stdin.readline
class Doubling:
def __init__(self, A, K_max, decrement=True):
"""
:param A: リスト。i から A[i] へと移動する
:param K_max: K_max = 2**(k_max) まで参照する可能性がある
:param decrement: True = A の要素の decrement が必要
"""
self.k_max = K_max.bit_length()
self.n = len(A)
self.decrement = decrement
self.doubling = [[-1] * self.n for _ in range(self.k_max)]
for i, a in enumerate(A):
self.doubling[0][i] = a - self.decrement
for i in range(1, self.k_max):
for j in range(self.n):
if self.doubling[i - 1][j] != -1:
self.doubling[i][j] = self.doubling[i - 1][self.doubling[i - 1][j]]
def apply(self, start, K):
"""
:param start: スタート地点
:param K: K回進む
:return:
"""
i = start - self.decrement
for k in range(K.bit_length()):
m = 1 << k
if m & K:
i = self.doubling[k][i]
if i is None:
break
return i + self.decrement
######################################################################################
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
doubling = Doubling(A, 10**18 + 1, decrement=True)
print((doubling.apply(1, K)))
| def cycle_getter(N, start):
"""
:param N: 移動回数
:param start: 初期条件
:return front: cycleまでの要素のリスト
cycle: cycle内の要素のリスト
end: cycle後の余った部分の要素のリスト
cnt: cycle回数
"""
p = start
front, cycle, end = [], [], []
cnt = 0
visit = {p: 0}
L, R = N, -1
P = [p]
for i in range(1, N):
p = lift(p)
if p in visit:
"""
(L, R) = (サイクルに入るまでに移動した回数, サイクルの終端に着くまでに移動した回数)
[6,2,3,4,0,1,2] ⇒ (L, R) = (1, 6)
"""
L, R = visit[p], i
period = R - L
break
visit[p] = i
P.append(p)
front = P[:L]
if L != N:
cycle, end = P[L:R], P[L : L + (N - L) % period]
cnt = (N - L) // period
return front, cycle, end, cnt
################################################################################
import sys
input = sys.stdin.readline
def lift(x):
return A[x - 1]
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
front, cycle, end, cnt = cycle_getter(K + 1, 1)
# print(front, cycle, end, cnt)
print(((front + cycle + end)[-1]))
| false | 2.173913 | [
"+def cycle_getter(N, start):",
"+ \"\"\"",
"+ :param N: 移動回数",
"+ :param start: 初期条件",
"+ :return front: cycleまでの要素のリスト",
"+ cycle: cycle内の要素のリスト",
"+ end: cycle後の余った部分の要素のリスト",
"+ cnt: cycle回数",
"+ \"\"\"",
"+ p = start",
"+ front, cycle, end = [], [], []",
"+ cnt = 0",
"+ visit = {p: 0}",
"+ L, R = N, -1",
"+ P = [p]",
"+ for i in range(1, N):",
"+ p = lift(p)",
"+ if p in visit:",
"+ \"\"\"",
"+ (L, R) = (サイクルに入るまでに移動した回数, サイクルの終端に着くまでに移動した回数)",
"+ [6,2,3,4,0,1,2] ⇒ (L, R) = (1, 6)",
"+ \"\"\"",
"+ L, R = visit[p], i",
"+ period = R - L",
"+ break",
"+ visit[p] = i",
"+ P.append(p)",
"+ front = P[:L]",
"+ if L != N:",
"+ cycle, end = P[L:R], P[L : L + (N - L) % period]",
"+ cnt = (N - L) // period",
"+ return front, cycle, end, cnt",
"+",
"+",
"+################################################################################",
"-class Doubling:",
"- def __init__(self, A, K_max, decrement=True):",
"- \"\"\"",
"- :param A: リスト。i から A[i] へと移動する",
"- :param K_max: K_max = 2**(k_max) まで参照する可能性がある",
"- :param decrement: True = A の要素の decrement が必要",
"- \"\"\"",
"- self.k_max = K_max.bit_length()",
"- self.n = len(A)",
"- self.decrement = decrement",
"- self.doubling = [[-1] * self.n for _ in range(self.k_max)]",
"- for i, a in enumerate(A):",
"- self.doubling[0][i] = a - self.decrement",
"- for i in range(1, self.k_max):",
"- for j in range(self.n):",
"- if self.doubling[i - 1][j] != -1:",
"- self.doubling[i][j] = self.doubling[i - 1][self.doubling[i - 1][j]]",
"-",
"- def apply(self, start, K):",
"- \"\"\"",
"- :param start: スタート地点",
"- :param K: K回進む",
"- :return:",
"- \"\"\"",
"- i = start - self.decrement",
"- for k in range(K.bit_length()):",
"- m = 1 << k",
"- if m & K:",
"- i = self.doubling[k][i]",
"- if i is None:",
"- break",
"- return i + self.decrement",
"+def lift(x):",
"+ return A[x - 1]",
"-######################################################################################",
"-doubling = Doubling(A, 10**18 + 1, decrement=True)",
"-print((doubling.apply(1, K)))",
"+front, cycle, end, cnt = cycle_getter(K + 1, 1)",
"+# print(front, cycle, end, cnt)",
"+print(((front + cycle + end)[-1]))"
] | false | 0.042851 | 0.04056 | 1.056475 | [
"s953083438",
"s739620332"
] |
u073549161 | p03694 | python | s801240653 | s757777763 | 177 | 17 | 38,384 | 2,940 | Accepted | Accepted | 90.4 | n = int(eval(input()))
dat_x = list(map(int, input().split()))
print((max(dat_x) - min(dat_x))) | n = int(eval(input()))
dat_a = list(map(int, input().split()))
dat_a = list(dat_a)
print((max(dat_a) - min(dat_a))) | 3 | 4 | 89 | 104 | n = int(eval(input()))
dat_x = list(map(int, input().split()))
print((max(dat_x) - min(dat_x)))
| n = int(eval(input()))
dat_a = list(map(int, input().split()))
dat_a = list(dat_a)
print((max(dat_a) - min(dat_a)))
| false | 25 | [
"-dat_x = list(map(int, input().split()))",
"-print((max(dat_x) - min(dat_x)))",
"+dat_a = list(map(int, input().split()))",
"+dat_a = list(dat_a)",
"+print((max(dat_a) - min(dat_a)))"
] | false | 0.042038 | 0.037904 | 1.109081 | [
"s801240653",
"s757777763"
] |
u225388820 | p02558 | python | s648378042 | s409457525 | 382 | 281 | 92,460 | 89,344 | Accepted | Accepted | 26.44 | import typing
class DSU:
'''
Implement (union by size) + (path compression)
Reference:
Zvi Galil and Giuseppe F. Italiano,
Data structures and algorithms for disjoint set union problems
'''
def __init__(self, n: int = 0):
self._n = n
self.parent_or_size = [-1] * n
def merge(self, a: int, b: int) -> int:
assert 0 <= a < self._n
assert 0 <= b < self._n
x = self.leader(a)
y = self.leader(b)
if x == y:
return x
if -self.parent_or_size[x] < -self.parent_or_size[y]:
x, y = y, x
self.parent_or_size[x] += self.parent_or_size[y]
self.parent_or_size[y] = x
return x
def same(self, a: int, b: int) -> bool:
assert 0 <= a < self._n
assert 0 <= b < self._n
return self.leader(a) == self.leader(b)
def leader(self, a: int) -> int:
assert 0 <= a < self._n
if self.parent_or_size[a] < 0:
return a
self.parent_or_size[a] = self.leader(self.parent_or_size[a])
return self.parent_or_size[a]
def size(self, a: int) -> int:
assert 0 <= a < self._n
return -self.parent_or_size[self.leader(a)]
def groups(self) -> typing.List[typing.List[int]]:
leader_buf = [self.leader(i) for i in range(self._n)]
result = [[] for _ in range(self._n)]
for i in range(self._n):
result[leader_buf[i]].append(i)
return list([r for r in result if r])
import sys
input = sys.stdin.readline
n, q = list(map(int, input().split()))
uf = DSU(n)
res = []
for i in range(q):
t, u, v = list(map(int, input().split()))
if t:
res.append(int(uf.same(u, v)))
else:
uf.merge(u, v)
print(("\n".join(map(str, res))))
| import typing
class DSU:
'''
Implement (union by size) + (path compression)
Reference:
Zvi Galil and Giuseppe F. Italiano,
Data structures and algorithms for disjoint set union problems
'''
def __init__(self, n: int = 0):
self._n = n
self.parent_or_size = [-1] * n
def merge(self, a: int, b: int) -> int:
assert 0 <= a < self._n
assert 0 <= b < self._n
x = self.leader(a)
y = self.leader(b)
if x == y:
return x
if -self.parent_or_size[x] < -self.parent_or_size[y]:
x, y = y, x
self.parent_or_size[x] += self.parent_or_size[y]
self.parent_or_size[y] = x
return x
def same(self, a: int, b: int) -> bool:
assert 0 <= a < self._n
assert 0 <= b < self._n
return self.leader(a) == self.leader(b)
def leader(self, a: int) -> int:
assert 0 <= a < self._n
update_list = []
while self.parent_or_size[a] >= 0:
update_list.append(a)
a = self.parent_or_size[a]
for i in update_list:
self.parent_or_size[i] = a
return a
def size(self, a: int) -> int:
assert 0 <= a < self._n
return -self.parent_or_size[self.leader(a)]
def groups(self) -> typing.List[typing.List[int]]:
leader_buf = [self.leader(i) for i in range(self._n)]
result = [[] for _ in range(self._n)]
for i in range(self._n):
result[leader_buf[i]].append(i)
return list([r for r in result if r])
import sys
input = sys.stdin.readline
n, q = list(map(int, input().split()))
uf = DSU(n)
res = []
for i in range(q):
t, u, v = list(map(int, input().split()))
if t:
res.append(int(uf.same(u, v)))
else:
uf.merge(u, v)
print(("\n".join(map(str, res))))
| 75 | 79 | 1,866 | 1,931 | import typing
class DSU:
"""
Implement (union by size) + (path compression)
Reference:
Zvi Galil and Giuseppe F. Italiano,
Data structures and algorithms for disjoint set union problems
"""
def __init__(self, n: int = 0):
self._n = n
self.parent_or_size = [-1] * n
def merge(self, a: int, b: int) -> int:
assert 0 <= a < self._n
assert 0 <= b < self._n
x = self.leader(a)
y = self.leader(b)
if x == y:
return x
if -self.parent_or_size[x] < -self.parent_or_size[y]:
x, y = y, x
self.parent_or_size[x] += self.parent_or_size[y]
self.parent_or_size[y] = x
return x
def same(self, a: int, b: int) -> bool:
assert 0 <= a < self._n
assert 0 <= b < self._n
return self.leader(a) == self.leader(b)
def leader(self, a: int) -> int:
assert 0 <= a < self._n
if self.parent_or_size[a] < 0:
return a
self.parent_or_size[a] = self.leader(self.parent_or_size[a])
return self.parent_or_size[a]
def size(self, a: int) -> int:
assert 0 <= a < self._n
return -self.parent_or_size[self.leader(a)]
def groups(self) -> typing.List[typing.List[int]]:
leader_buf = [self.leader(i) for i in range(self._n)]
result = [[] for _ in range(self._n)]
for i in range(self._n):
result[leader_buf[i]].append(i)
return list([r for r in result if r])
import sys
input = sys.stdin.readline
n, q = list(map(int, input().split()))
uf = DSU(n)
res = []
for i in range(q):
t, u, v = list(map(int, input().split()))
if t:
res.append(int(uf.same(u, v)))
else:
uf.merge(u, v)
print(("\n".join(map(str, res))))
| import typing
class DSU:
"""
Implement (union by size) + (path compression)
Reference:
Zvi Galil and Giuseppe F. Italiano,
Data structures and algorithms for disjoint set union problems
"""
def __init__(self, n: int = 0):
self._n = n
self.parent_or_size = [-1] * n
def merge(self, a: int, b: int) -> int:
assert 0 <= a < self._n
assert 0 <= b < self._n
x = self.leader(a)
y = self.leader(b)
if x == y:
return x
if -self.parent_or_size[x] < -self.parent_or_size[y]:
x, y = y, x
self.parent_or_size[x] += self.parent_or_size[y]
self.parent_or_size[y] = x
return x
def same(self, a: int, b: int) -> bool:
assert 0 <= a < self._n
assert 0 <= b < self._n
return self.leader(a) == self.leader(b)
def leader(self, a: int) -> int:
assert 0 <= a < self._n
update_list = []
while self.parent_or_size[a] >= 0:
update_list.append(a)
a = self.parent_or_size[a]
for i in update_list:
self.parent_or_size[i] = a
return a
def size(self, a: int) -> int:
assert 0 <= a < self._n
return -self.parent_or_size[self.leader(a)]
def groups(self) -> typing.List[typing.List[int]]:
leader_buf = [self.leader(i) for i in range(self._n)]
result = [[] for _ in range(self._n)]
for i in range(self._n):
result[leader_buf[i]].append(i)
return list([r for r in result if r])
import sys
input = sys.stdin.readline
n, q = list(map(int, input().split()))
uf = DSU(n)
res = []
for i in range(q):
t, u, v = list(map(int, input().split()))
if t:
res.append(int(uf.same(u, v)))
else:
uf.merge(u, v)
print(("\n".join(map(str, res))))
| false | 5.063291 | [
"- if self.parent_or_size[a] < 0:",
"- return a",
"- self.parent_or_size[a] = self.leader(self.parent_or_size[a])",
"- return self.parent_or_size[a]",
"+ update_list = []",
"+ while self.parent_or_size[a] >= 0:",
"+ update_list.append(a)",
"+ a = self.parent_or_size[a]",
"+ for i in update_list:",
"+ self.parent_or_size[i] = a",
"+ return a"
] | false | 0.135212 | 0.067974 | 1.989176 | [
"s648378042",
"s409457525"
] |
u298297089 | p02803 | python | s808653707 | s186652852 | 205 | 89 | 41,712 | 3,572 | Accepted | Accepted | 56.59 | from collections import deque
def bfs(grid, start, wall, h, w):
visited = [[False for _ in range(w+2)] for _ in range(h+2)]
visited[start[0]][start[1]] = True
queue = deque([])
queue.append([start[0], start[1], 0])
dxy = [(1,0), (-1,0), (0,1), (0,-1)]
cost = 0
while queue:
y,x,cnt = queue.popleft()
for dy, dx in dxy:
y_,x_ = y+dy,x+dx
if grid[y_][x_] == wall or visited[y_][x_]:
continue
queue.append([y_,x_,cnt+1])
if cnt+1 > cost:
cost = cnt+1
visited[y_][x_] = True
return cost
h,w = list(map(int, input().split()))
wall = '#'
edges = [wall] * (w+2)
grid = [edges]
for i in range(h):
s = eval(input())
grid.append([wall] + list(s) + [wall])
grid.append(edges)
cand = {2:[], 3:[], 4:[]}
dxy = [(1,0), (-1,0), (0,1), (0,-1)]
for y in range(1,h+1):
for x in range(1,w+1):
if grid[y][x] == wall:
continue
wl = 0
for dy, dx in dxy:
y_,x_ = y+dy,x+dx
if grid[y_][x_] == wall:
wl += 1
if wl > 1:
cand[wl].append((y,x))
ans = 0
starts = []
for i in [4,3,2]:
if cand[i] != []:
starts = cand[i]
break
for start in starts:
cnt = bfs(grid, start, wall, h, w)
if cnt > ans:
ans = cnt
print(ans)
| from collections import deque
def bfs(grid, sy, sx, wall):
queue = deque([])
queue.append([sy, sx, 0])
visited = {}
visited[(sy,sx)] = 0
dxy = [(1,0), (-1,0), (0,1), (0,-1)]
while queue:
y,x,cnt = queue.popleft()
for dy, dx in dxy:
y_,x_ = y+dy,x+dx
if grid[y_][x_] == wall or (y_,x_) in visited:
continue
queue.append([y_,x_,cnt+1])
visited[(y_,x_)] = cnt+1
return max(visited.values())
h,w = list(map(int, input().split()))
wall = '#'
edges = [wall] * (w+2)
grid = [edges]
for i in range(h):
s = eval(input())
grid.append([wall] + list(s) + [wall])
grid.append(edges)
starts = []
dxy = [(1,0), (-1,0), (0,1), (0,-1)]
for y in range(1,h+1):
for x in range(1,w+1):
if grid[y][x] == wall:
continue
cnt = 0
for dy, dx in dxy:
y_,x_ = y+dy,x+dx
if grid[y_][x_] == wall:
cnt += 1
if cnt > 1:
starts.append((y,x))
ans = 0
for y,x in starts:
tmp = bfs(grid, y, x, wall)
if ans < tmp:
ans = tmp
print(ans)
| 57 | 47 | 1,421 | 1,169 | from collections import deque
def bfs(grid, start, wall, h, w):
visited = [[False for _ in range(w + 2)] for _ in range(h + 2)]
visited[start[0]][start[1]] = True
queue = deque([])
queue.append([start[0], start[1], 0])
dxy = [(1, 0), (-1, 0), (0, 1), (0, -1)]
cost = 0
while queue:
y, x, cnt = queue.popleft()
for dy, dx in dxy:
y_, x_ = y + dy, x + dx
if grid[y_][x_] == wall or visited[y_][x_]:
continue
queue.append([y_, x_, cnt + 1])
if cnt + 1 > cost:
cost = cnt + 1
visited[y_][x_] = True
return cost
h, w = list(map(int, input().split()))
wall = "#"
edges = [wall] * (w + 2)
grid = [edges]
for i in range(h):
s = eval(input())
grid.append([wall] + list(s) + [wall])
grid.append(edges)
cand = {2: [], 3: [], 4: []}
dxy = [(1, 0), (-1, 0), (0, 1), (0, -1)]
for y in range(1, h + 1):
for x in range(1, w + 1):
if grid[y][x] == wall:
continue
wl = 0
for dy, dx in dxy:
y_, x_ = y + dy, x + dx
if grid[y_][x_] == wall:
wl += 1
if wl > 1:
cand[wl].append((y, x))
ans = 0
starts = []
for i in [4, 3, 2]:
if cand[i] != []:
starts = cand[i]
break
for start in starts:
cnt = bfs(grid, start, wall, h, w)
if cnt > ans:
ans = cnt
print(ans)
| from collections import deque
def bfs(grid, sy, sx, wall):
queue = deque([])
queue.append([sy, sx, 0])
visited = {}
visited[(sy, sx)] = 0
dxy = [(1, 0), (-1, 0), (0, 1), (0, -1)]
while queue:
y, x, cnt = queue.popleft()
for dy, dx in dxy:
y_, x_ = y + dy, x + dx
if grid[y_][x_] == wall or (y_, x_) in visited:
continue
queue.append([y_, x_, cnt + 1])
visited[(y_, x_)] = cnt + 1
return max(visited.values())
h, w = list(map(int, input().split()))
wall = "#"
edges = [wall] * (w + 2)
grid = [edges]
for i in range(h):
s = eval(input())
grid.append([wall] + list(s) + [wall])
grid.append(edges)
starts = []
dxy = [(1, 0), (-1, 0), (0, 1), (0, -1)]
for y in range(1, h + 1):
for x in range(1, w + 1):
if grid[y][x] == wall:
continue
cnt = 0
for dy, dx in dxy:
y_, x_ = y + dy, x + dx
if grid[y_][x_] == wall:
cnt += 1
if cnt > 1:
starts.append((y, x))
ans = 0
for y, x in starts:
tmp = bfs(grid, y, x, wall)
if ans < tmp:
ans = tmp
print(ans)
| false | 17.54386 | [
"-def bfs(grid, start, wall, h, w):",
"- visited = [[False for _ in range(w + 2)] for _ in range(h + 2)]",
"- visited[start[0]][start[1]] = True",
"+def bfs(grid, sy, sx, wall):",
"- queue.append([start[0], start[1], 0])",
"+ queue.append([sy, sx, 0])",
"+ visited = {}",
"+ visited[(sy, sx)] = 0",
"- cost = 0",
"- if grid[y_][x_] == wall or visited[y_][x_]:",
"+ if grid[y_][x_] == wall or (y_, x_) in visited:",
"- if cnt + 1 > cost:",
"- cost = cnt + 1",
"- visited[y_][x_] = True",
"- return cost",
"+ visited[(y_, x_)] = cnt + 1",
"+ return max(visited.values())",
"-cand = {2: [], 3: [], 4: []}",
"+starts = []",
"- wl = 0",
"+ cnt = 0",
"- wl += 1",
"- if wl > 1:",
"- cand[wl].append((y, x))",
"+ cnt += 1",
"+ if cnt > 1:",
"+ starts.append((y, x))",
"-starts = []",
"-for i in [4, 3, 2]:",
"- if cand[i] != []:",
"- starts = cand[i]",
"- break",
"-for start in starts:",
"- cnt = bfs(grid, start, wall, h, w)",
"- if cnt > ans:",
"- ans = cnt",
"+for y, x in starts:",
"+ tmp = bfs(grid, y, x, wall)",
"+ if ans < tmp:",
"+ ans = tmp"
] | false | 0.038041 | 0.044987 | 0.845615 | [
"s808653707",
"s186652852"
] |
u188827677 | p02756 | python | s648106950 | s894924790 | 700 | 412 | 12,272 | 14,324 | Accepted | Accepted | 41.14 | from collections import deque
s = deque(input())
q = int(input())
t = 0
for _ in range(q):
query = list(input().split())
query[0] = int(query[0])
if query[0] == 1: t = 1 - (t)
else:
if t == 0:
if int(query[1]) == 1: s.appendleft(query[2])
else: s.append(query[2])
else:
if int(query[1]) == 1: s.append(query[2])
else: s.appendleft(query[2])
if t == 0: print(*s, sep = '')
else: print(*reversed(s), sep = '')
| from collections import deque
s = eval(input())
q = int(eval(input()))
s = deque(s)
t = 0
for _ in range(q):
query = list(map(str, input().split()))
if query[0] == "1": t = 1 - t
else:
if t == 0:
if query[1] == "1": s.appendleft(query[2])
elif query[1] == "2": s.append(query[2])
elif t == 1:
if query[1] == "1": s.append(query[2])
elif query[1] == "2": s.appendleft(query[2])
if t == 1:print(("".join(s)[::-1]))
else: print(("".join(s))) | 18 | 18 | 465 | 478 | from collections import deque
s = deque(input())
q = int(input())
t = 0
for _ in range(q):
query = list(input().split())
query[0] = int(query[0])
if query[0] == 1:
t = 1 - (t)
else:
if t == 0:
if int(query[1]) == 1:
s.appendleft(query[2])
else:
s.append(query[2])
else:
if int(query[1]) == 1:
s.append(query[2])
else:
s.appendleft(query[2])
if t == 0:
print(*s, sep="")
else:
print(*reversed(s), sep="")
| from collections import deque
s = eval(input())
q = int(eval(input()))
s = deque(s)
t = 0
for _ in range(q):
query = list(map(str, input().split()))
if query[0] == "1":
t = 1 - t
else:
if t == 0:
if query[1] == "1":
s.appendleft(query[2])
elif query[1] == "2":
s.append(query[2])
elif t == 1:
if query[1] == "1":
s.append(query[2])
elif query[1] == "2":
s.appendleft(query[2])
if t == 1:
print(("".join(s)[::-1]))
else:
print(("".join(s)))
| false | 0 | [
"-s = deque(input())",
"-q = int(input())",
"+s = eval(input())",
"+q = int(eval(input()))",
"+s = deque(s)",
"- query = list(input().split())",
"- query[0] = int(query[0])",
"- if query[0] == 1:",
"- t = 1 - (t)",
"+ query = list(map(str, input().split()))",
"+ if query[0] == \"1\":",
"+ t = 1 - t",
"- if int(query[1]) == 1:",
"+ if query[1] == \"1\":",
"- else:",
"+ elif query[1] == \"2\":",
"- else:",
"- if int(query[1]) == 1:",
"+ elif t == 1:",
"+ if query[1] == \"1\":",
"- else:",
"+ elif query[1] == \"2\":",
"-if t == 0:",
"- print(*s, sep=\"\")",
"+if t == 1:",
"+ print((\"\".join(s)[::-1]))",
"- print(*reversed(s), sep=\"\")",
"+ print((\"\".join(s)))"
] | false | 0.037668 | 0.038116 | 0.988246 | [
"s648106950",
"s894924790"
] |
u221061152 | p02623 | python | s112985952 | s043206573 | 317 | 257 | 49,220 | 45,332 | Accepted | Accepted | 18.93 | from collections import deque
n,m,k=list(map(int,input().split()))
A = list(map(int,input().split()))
B = list(map(int,input().split()))
a,b=[0],[0]
for i in range(n):
a.append(a[i]+A[i])
for i in range(m):
b.append(b[i]+B[i])
ans, j = 0,m
for i in range(n+1):
if a[i]>k: break
while b[j] > k-a[i]:
j -= 1
ans = max(ans,i+j)
print(ans) | from itertools import accumulate
from bisect import bisect
n,m,k=list(map(int,input().split()))
A=list(map(int,input().split()))
A=list(accumulate(A,initial=0))
B=list(map(int,input().split()))
B=list(accumulate(B))
ans = 0
for i,a in enumerate(A):
if a > k: break
ans = max(ans,i + bisect(B,k-a))
print(ans) | 17 | 13 | 360 | 319 | from collections import deque
n, m, k = list(map(int, input().split()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
a, b = [0], [0]
for i in range(n):
a.append(a[i] + A[i])
for i in range(m):
b.append(b[i] + B[i])
ans, j = 0, m
for i in range(n + 1):
if a[i] > k:
break
while b[j] > k - a[i]:
j -= 1
ans = max(ans, i + j)
print(ans)
| from itertools import accumulate
from bisect import bisect
n, m, k = list(map(int, input().split()))
A = list(map(int, input().split()))
A = list(accumulate(A, initial=0))
B = list(map(int, input().split()))
B = list(accumulate(B))
ans = 0
for i, a in enumerate(A):
if a > k:
break
ans = max(ans, i + bisect(B, k - a))
print(ans)
| false | 23.529412 | [
"-from collections import deque",
"+from itertools import accumulate",
"+from bisect import bisect",
"+A = list(accumulate(A, initial=0))",
"-a, b = [0], [0]",
"-for i in range(n):",
"- a.append(a[i] + A[i])",
"-for i in range(m):",
"- b.append(b[i] + B[i])",
"-ans, j = 0, m",
"-for i in range(n + 1):",
"- if a[i] > k:",
"+B = list(accumulate(B))",
"+ans = 0",
"+for i, a in enumerate(A):",
"+ if a > k:",
"- while b[j] > k - a[i]:",
"- j -= 1",
"- ans = max(ans, i + j)",
"+ ans = max(ans, i + bisect(B, k - a))"
] | false | 0.047653 | 0.049377 | 0.965088 | [
"s112985952",
"s043206573"
] |
u133356863 | p02696 | python | s134533339 | s006758211 | 25 | 20 | 9,144 | 9,156 | Accepted | Accepted | 20 | a,b,n=list(map(int,input().split()))
def f(x):
y=(a*x)//b-a*(x//b)
return y
print((f(min(b-1,n))))
| a,b,n=list(map(int,input().split()))
def f(x):
y=((a*x)//b)-a*(x//b)
return y
print((f(min(b-1,n))))
| 5 | 5 | 103 | 105 | a, b, n = list(map(int, input().split()))
def f(x):
y = (a * x) // b - a * (x // b)
return y
print((f(min(b - 1, n))))
| a, b, n = list(map(int, input().split()))
def f(x):
y = ((a * x) // b) - a * (x // b)
return y
print((f(min(b - 1, n))))
| false | 0 | [
"- y = (a * x) // b - a * (x // b)",
"+ y = ((a * x) // b) - a * (x // b)"
] | false | 0.101501 | 0.095105 | 1.06725 | [
"s134533339",
"s006758211"
] |
u370608397 | p03854 | python | s713355226 | s682116691 | 154 | 38 | 4,084 | 3,956 | Accepted | Accepted | 75.32 | S=eval(input())
dp=[False]*(len(S)+1)
dp[0]=True
for i in range(len(S)):
if i>=4 and S[i-4:i+1]=="dream":
dp[i+1]|=dp[i-4]
if i>=4 and S[i-4:i+1]=="erase":
dp[i+1]|=dp[i-4]
if i>=6 and S[i-6:i+1]=="dreamer":
dp[i+1]|=dp[i-6]
if i>=5 and S[i-5:i+1]=="eraser":
dp[i+1]|=dp[i-5]
print(("YES" if dp[len(S)] else "NO")) | import sys
S="".join(reversed(eval(input())))
i=0
while i<len(S):
if i+4<len(S) and (S[i:i+5]=="maerd" or S[i:i+5]=="esare"):
i+=5
elif i+5<len(S) and (S[i:i+6]=="resare"):
i+=6
elif i+6<len(S) and (S[i:i+7]=="remaerd"):
i+=7
else:
print("NO")
sys.exit()
print("YES") | 13 | 14 | 366 | 330 | S = eval(input())
dp = [False] * (len(S) + 1)
dp[0] = True
for i in range(len(S)):
if i >= 4 and S[i - 4 : i + 1] == "dream":
dp[i + 1] |= dp[i - 4]
if i >= 4 and S[i - 4 : i + 1] == "erase":
dp[i + 1] |= dp[i - 4]
if i >= 6 and S[i - 6 : i + 1] == "dreamer":
dp[i + 1] |= dp[i - 6]
if i >= 5 and S[i - 5 : i + 1] == "eraser":
dp[i + 1] |= dp[i - 5]
print(("YES" if dp[len(S)] else "NO"))
| import sys
S = "".join(reversed(eval(input())))
i = 0
while i < len(S):
if i + 4 < len(S) and (S[i : i + 5] == "maerd" or S[i : i + 5] == "esare"):
i += 5
elif i + 5 < len(S) and (S[i : i + 6] == "resare"):
i += 6
elif i + 6 < len(S) and (S[i : i + 7] == "remaerd"):
i += 7
else:
print("NO")
sys.exit()
print("YES")
| false | 7.142857 | [
"-S = eval(input())",
"-dp = [False] * (len(S) + 1)",
"-dp[0] = True",
"-for i in range(len(S)):",
"- if i >= 4 and S[i - 4 : i + 1] == \"dream\":",
"- dp[i + 1] |= dp[i - 4]",
"- if i >= 4 and S[i - 4 : i + 1] == \"erase\":",
"- dp[i + 1] |= dp[i - 4]",
"- if i >= 6 and S[i - 6 : i + 1] == \"dreamer\":",
"- dp[i + 1] |= dp[i - 6]",
"- if i >= 5 and S[i - 5 : i + 1] == \"eraser\":",
"- dp[i + 1] |= dp[i - 5]",
"-print((\"YES\" if dp[len(S)] else \"NO\"))",
"+import sys",
"+",
"+S = \"\".join(reversed(eval(input())))",
"+i = 0",
"+while i < len(S):",
"+ if i + 4 < len(S) and (S[i : i + 5] == \"maerd\" or S[i : i + 5] == \"esare\"):",
"+ i += 5",
"+ elif i + 5 < len(S) and (S[i : i + 6] == \"resare\"):",
"+ i += 6",
"+ elif i + 6 < len(S) and (S[i : i + 7] == \"remaerd\"):",
"+ i += 7",
"+ else:",
"+ print(\"NO\")",
"+ sys.exit()",
"+print(\"YES\")"
] | false | 0.036927 | 0.056561 | 0.652885 | [
"s713355226",
"s682116691"
] |
u923668099 | p01137 | python | s945509901 | s004901770 | 28,720 | 410 | 8,200 | 8,252 | Accepted | Accepted | 98.57 | import sys
inf = 1<<30
w = 100
def solve():
while 1:
e = int(sys.stdin.readline().rstrip())
if e == 0:
return
ans = inf
z0 = int(e**(1/3))
for z in range(max(0, z0 - w), z0 + w):
if e - z**3 < 0:
break
y0 = int((e - z**3)**0.5)
for y in range(max(0, y0 - w), y0 + w):
x = e - z**3 - y**2
if x < 0:
break
ans = min(ans, x + y + z)
print(ans)
if __name__ == '__main__':
solve() | import sys
inf = 1<<30
lim = 10**5
def solve():
cubics = [x**3 for x in range(100 + 1)]
while 1:
e = int(sys.stdin.readline().rstrip())
if e == 0:
return
ans = inf
for z, c in enumerate(cubics):
if c > e:
break
y = int((e - c)**0.5)
x = e - c - y**2
ans = min(ans, x + y + z)
print(ans)
if __name__ == '__main__':
solve() | 33 | 27 | 606 | 483 | import sys
inf = 1 << 30
w = 100
def solve():
while 1:
e = int(sys.stdin.readline().rstrip())
if e == 0:
return
ans = inf
z0 = int(e ** (1 / 3))
for z in range(max(0, z0 - w), z0 + w):
if e - z**3 < 0:
break
y0 = int((e - z**3) ** 0.5)
for y in range(max(0, y0 - w), y0 + w):
x = e - z**3 - y**2
if x < 0:
break
ans = min(ans, x + y + z)
print(ans)
if __name__ == "__main__":
solve()
| import sys
inf = 1 << 30
lim = 10**5
def solve():
cubics = [x**3 for x in range(100 + 1)]
while 1:
e = int(sys.stdin.readline().rstrip())
if e == 0:
return
ans = inf
for z, c in enumerate(cubics):
if c > e:
break
y = int((e - c) ** 0.5)
x = e - c - y**2
ans = min(ans, x + y + z)
print(ans)
if __name__ == "__main__":
solve()
| false | 18.181818 | [
"-w = 100",
"+lim = 10**5",
"+ cubics = [x**3 for x in range(100 + 1)]",
"- z0 = int(e ** (1 / 3))",
"- for z in range(max(0, z0 - w), z0 + w):",
"- if e - z**3 < 0:",
"+ for z, c in enumerate(cubics):",
"+ if c > e:",
"- y0 = int((e - z**3) ** 0.5)",
"- for y in range(max(0, y0 - w), y0 + w):",
"- x = e - z**3 - y**2",
"- if x < 0:",
"- break",
"- ans = min(ans, x + y + z)",
"+ y = int((e - c) ** 0.5)",
"+ x = e - c - y**2",
"+ ans = min(ans, x + y + z)"
] | false | 0.064643 | 0.049333 | 1.310329 | [
"s945509901",
"s004901770"
] |
u609061751 | p03503 | python | s383721244 | s025494988 | 644 | 169 | 12,304 | 3,064 | Accepted | Accepted | 73.76 | import sys
input = sys.stdin.readline
N = int(eval(input()))
F = []
for _ in range(N):
F.append([int(x) for x in input().split()])
P = []
for _ in range(N):
P.append([int(x) for x in input().split()])
ans = -10 ** 10
import numpy as np
for i in range(1, 2 ** 10):
bini = format(i, 'b').zfill(10)
bini = np.array([int(x) for x in list(bini)])
ans_ = 0
for j in range(N):
shop = np.array(F[j])
cnt = np.count_nonzero(shop * bini)
ans_ += P[j][cnt]
ans = max(ans, ans_)
print(ans)
| import sys
input = sys.stdin.readline
N = int(eval(input()))
F = []
for _ in range(N):
F.append([str(x) for x in input().split()])
P = []
for _ in range(N):
P.append([int(x) for x in input().split()])
ans = -10 ** 10
for i in range(1, 2 ** 10):
bini = "0b" + format(i, 'b').zfill(10)
ans_ = 0
for j in range(N):
shop = "0b" + "".join(F[j])
cnt = bin((int(shop, 2) & int(bini, 2))).count("1")
ans_ += P[j][cnt]
ans = max(ans, ans_)
print(ans)
| 22 | 20 | 546 | 504 | import sys
input = sys.stdin.readline
N = int(eval(input()))
F = []
for _ in range(N):
F.append([int(x) for x in input().split()])
P = []
for _ in range(N):
P.append([int(x) for x in input().split()])
ans = -(10**10)
import numpy as np
for i in range(1, 2**10):
bini = format(i, "b").zfill(10)
bini = np.array([int(x) for x in list(bini)])
ans_ = 0
for j in range(N):
shop = np.array(F[j])
cnt = np.count_nonzero(shop * bini)
ans_ += P[j][cnt]
ans = max(ans, ans_)
print(ans)
| import sys
input = sys.stdin.readline
N = int(eval(input()))
F = []
for _ in range(N):
F.append([str(x) for x in input().split()])
P = []
for _ in range(N):
P.append([int(x) for x in input().split()])
ans = -(10**10)
for i in range(1, 2**10):
bini = "0b" + format(i, "b").zfill(10)
ans_ = 0
for j in range(N):
shop = "0b" + "".join(F[j])
cnt = bin((int(shop, 2) & int(bini, 2))).count("1")
ans_ += P[j][cnt]
ans = max(ans, ans_)
print(ans)
| false | 9.090909 | [
"- F.append([int(x) for x in input().split()])",
"+ F.append([str(x) for x in input().split()])",
"-import numpy as np",
"-",
"- bini = format(i, \"b\").zfill(10)",
"- bini = np.array([int(x) for x in list(bini)])",
"+ bini = \"0b\" + format(i, \"b\").zfill(10)",
"- shop = np.array(F[j])",
"- cnt = np.count_nonzero(shop * bini)",
"+ shop = \"0b\" + \"\".join(F[j])",
"+ cnt = bin((int(shop, 2) & int(bini, 2))).count(\"1\")"
] | false | 0.462541 | 0.040465 | 11.430577 | [
"s383721244",
"s025494988"
] |
u203843959 | p02991 | python | s764435806 | s291277832 | 658 | 374 | 68,716 | 64,764 | Accepted | Accepted | 43.16 | import sys
N,M=list(map(int,input().split()))
graph=[]
for _ in range(N+1):
graph.append([])
uvlist = []
for i in range(M):
u,v=list(map(int,input().split()))
graph[u].append(v)
S,T=list(map(int,input().split()))
#print(graph)
table=[]
for i in range(N+1):
table.append([False]*3)
#print(table)
vlist=graph[S]
table[S][0]=True
t=0
while(True):
t+=1
#if t>300003:
# print(-1)
# sys.exit()
#nlist = []
nset = set()
for v in vlist:
if v == T and t%3 == 0:
print((t//3))
sys.exit()
else:
table[v][t%3]=True
for vv in graph[v]:
if not table[vv][(t+1)%3]:
#nlist.append(vv)
nset.add(vv)
#table[vv][t%3]=True
#print((vv,t%3))
#print((t,nlist))
#vlist = nlist
vlist = list(nset)
if len(vlist) == 0:
print((-1))
break
| import sys
input=sys.stdin.readline
N,M=list(map(int,input().split()))
graph=[[] for _ in range(N+1)]
for i in range(M):
u,v=list(map(int,input().split()))
graph[u].append(v)
S,T=list(map(int,input().split()))
#print(graph)
visited=[]
for i in range(N+1):
visited.append([False]*3)
queue=[S]
t=0
while queue:
new_queue=set()
for u in queue:
if u==T and t%3==0:
print((t//3))
sys.exit(0)
visited[u][t%3]=True
for v in graph[u]:
if not visited[v][(t+1)%3]:
new_queue.add(v)
queue=list(new_queue)
t+=1
print((-1)) | 51 | 34 | 881 | 598 | import sys
N, M = list(map(int, input().split()))
graph = []
for _ in range(N + 1):
graph.append([])
uvlist = []
for i in range(M):
u, v = list(map(int, input().split()))
graph[u].append(v)
S, T = list(map(int, input().split()))
# print(graph)
table = []
for i in range(N + 1):
table.append([False] * 3)
# print(table)
vlist = graph[S]
table[S][0] = True
t = 0
while True:
t += 1
# if t>300003:
# print(-1)
# sys.exit()
# nlist = []
nset = set()
for v in vlist:
if v == T and t % 3 == 0:
print((t // 3))
sys.exit()
else:
table[v][t % 3] = True
for vv in graph[v]:
if not table[vv][(t + 1) % 3]:
# nlist.append(vv)
nset.add(vv)
# table[vv][t%3]=True
# print((vv,t%3))
# print((t,nlist))
# vlist = nlist
vlist = list(nset)
if len(vlist) == 0:
print((-1))
break
| import sys
input = sys.stdin.readline
N, M = list(map(int, input().split()))
graph = [[] for _ in range(N + 1)]
for i in range(M):
u, v = list(map(int, input().split()))
graph[u].append(v)
S, T = list(map(int, input().split()))
# print(graph)
visited = []
for i in range(N + 1):
visited.append([False] * 3)
queue = [S]
t = 0
while queue:
new_queue = set()
for u in queue:
if u == T and t % 3 == 0:
print((t // 3))
sys.exit(0)
visited[u][t % 3] = True
for v in graph[u]:
if not visited[v][(t + 1) % 3]:
new_queue.add(v)
queue = list(new_queue)
t += 1
print((-1))
| false | 33.333333 | [
"+input = sys.stdin.readline",
"-graph = []",
"-for _ in range(N + 1):",
"- graph.append([])",
"-uvlist = []",
"+graph = [[] for _ in range(N + 1)]",
"-table = []",
"+visited = []",
"- table.append([False] * 3)",
"-# print(table)",
"-vlist = graph[S]",
"-table[S][0] = True",
"+ visited.append([False] * 3)",
"+queue = [S]",
"-while True:",
"+while queue:",
"+ new_queue = set()",
"+ for u in queue:",
"+ if u == T and t % 3 == 0:",
"+ print((t // 3))",
"+ sys.exit(0)",
"+ visited[u][t % 3] = True",
"+ for v in graph[u]:",
"+ if not visited[v][(t + 1) % 3]:",
"+ new_queue.add(v)",
"+ queue = list(new_queue)",
"- # if t>300003:",
"- # print(-1)",
"- # sys.exit()",
"- # nlist = []",
"- nset = set()",
"- for v in vlist:",
"- if v == T and t % 3 == 0:",
"- print((t // 3))",
"- sys.exit()",
"- else:",
"- table[v][t % 3] = True",
"- for vv in graph[v]:",
"- if not table[vv][(t + 1) % 3]:",
"- # nlist.append(vv)",
"- nset.add(vv)",
"- # table[vv][t%3]=True",
"- # print((vv,t%3))",
"- # print((t,nlist))",
"- # vlist = nlist",
"- vlist = list(nset)",
"- if len(vlist) == 0:",
"- print((-1))",
"- break",
"+print((-1))"
] | false | 0.094414 | 0.098476 | 0.958748 | [
"s764435806",
"s291277832"
] |
u963915126 | p03161 | python | s305572180 | s334415345 | 275 | 161 | 84,784 | 84,948 | Accepted | Accepted | 41.45 | ni = lambda: int(eval(input()))
nm = lambda: list(map(int, input().split()))
nl = lambda: list(map(int, input().split()))
n,k=nm()
h=nl()
dp = [10**10] * n
dp[0] = 0
for i in range(n):
for j in range(max(0,i-k),i):
dp[i] = min(dp[i], dp[j] + abs(h[j]-h[i]))
print((dp[n-1]))
| ni = lambda: int(eval(input()))
nm = lambda: list(map(int, input().split()))
nl = lambda: list(map(int, input().split()))
n,k=nm()
h=nl()
dp = [10**10] * n
dp[0] = 0
for i in range(n):
for j in range(i+1,min(i+k+1,n)):
dp[j] = min(dp[j], dp[i] + abs(h[j]-h[i]))
print((dp[n-1]))
| 15 | 15 | 285 | 289 | ni = lambda: int(eval(input()))
nm = lambda: list(map(int, input().split()))
nl = lambda: list(map(int, input().split()))
n, k = nm()
h = nl()
dp = [10**10] * n
dp[0] = 0
for i in range(n):
for j in range(max(0, i - k), i):
dp[i] = min(dp[i], dp[j] + abs(h[j] - h[i]))
print((dp[n - 1]))
| ni = lambda: int(eval(input()))
nm = lambda: list(map(int, input().split()))
nl = lambda: list(map(int, input().split()))
n, k = nm()
h = nl()
dp = [10**10] * n
dp[0] = 0
for i in range(n):
for j in range(i + 1, min(i + k + 1, n)):
dp[j] = min(dp[j], dp[i] + abs(h[j] - h[i]))
print((dp[n - 1]))
| false | 0 | [
"- for j in range(max(0, i - k), i):",
"- dp[i] = min(dp[i], dp[j] + abs(h[j] - h[i]))",
"+ for j in range(i + 1, min(i + k + 1, n)):",
"+ dp[j] = min(dp[j], dp[i] + abs(h[j] - h[i]))"
] | false | 0.04584 | 0.04617 | 0.992847 | [
"s305572180",
"s334415345"
] |
u670180528 | p03472 | python | s831094355 | s399779762 | 538 | 121 | 30,032 | 25,124 | Accepted | Accepted | 77.51 | from collections import deque
n,h=list(map(int,input().split()))
l=[list(map(int,input().split())) for _ in range(n)]
l.sort(reverse=True)
fa,fb=l[0]
M=max(fa,fb)
if n==1:
print((max(0,(h-M-1)//fa)+2-(h<=M)))
else:
cnt=0;tmp=[]
for _,j in l[1:]:
if j>fa:
tmp.append(j)
b=deque(sorted(tmp))
lim=len(b)
while h > M and cnt < lim:
h-=b.pop()
cnt+=1
if len(b)!=0:
print((cnt+1))
else:
print((cnt+max(0,(h-M-1)//fa)+2-(h<=M))) | n,h,*l=list(map(int,open(0).read().split()))
a=max(l[::2])
c=0;f=1
for b in sorted(l[1::2])[::-1]:
if b>a:
h-=b
c+=1
if h<1:
f=0
break
print((c+(~-h//a+1)*f)) | 22 | 11 | 451 | 173 | from collections import deque
n, h = list(map(int, input().split()))
l = [list(map(int, input().split())) for _ in range(n)]
l.sort(reverse=True)
fa, fb = l[0]
M = max(fa, fb)
if n == 1:
print((max(0, (h - M - 1) // fa) + 2 - (h <= M)))
else:
cnt = 0
tmp = []
for _, j in l[1:]:
if j > fa:
tmp.append(j)
b = deque(sorted(tmp))
lim = len(b)
while h > M and cnt < lim:
h -= b.pop()
cnt += 1
if len(b) != 0:
print((cnt + 1))
else:
print((cnt + max(0, (h - M - 1) // fa) + 2 - (h <= M)))
| n, h, *l = list(map(int, open(0).read().split()))
a = max(l[::2])
c = 0
f = 1
for b in sorted(l[1::2])[::-1]:
if b > a:
h -= b
c += 1
if h < 1:
f = 0
break
print((c + (~-h // a + 1) * f))
| false | 50 | [
"-from collections import deque",
"-",
"-n, h = list(map(int, input().split()))",
"-l = [list(map(int, input().split())) for _ in range(n)]",
"-l.sort(reverse=True)",
"-fa, fb = l[0]",
"-M = max(fa, fb)",
"-if n == 1:",
"- print((max(0, (h - M - 1) // fa) + 2 - (h <= M)))",
"-else:",
"- cnt = 0",
"- tmp = []",
"- for _, j in l[1:]:",
"- if j > fa:",
"- tmp.append(j)",
"- b = deque(sorted(tmp))",
"- lim = len(b)",
"- while h > M and cnt < lim:",
"- h -= b.pop()",
"- cnt += 1",
"- if len(b) != 0:",
"- print((cnt + 1))",
"- else:",
"- print((cnt + max(0, (h - M - 1) // fa) + 2 - (h <= M)))",
"+n, h, *l = list(map(int, open(0).read().split()))",
"+a = max(l[::2])",
"+c = 0",
"+f = 1",
"+for b in sorted(l[1::2])[::-1]:",
"+ if b > a:",
"+ h -= b",
"+ c += 1",
"+ if h < 1:",
"+ f = 0",
"+ break",
"+print((c + (~-h // a + 1) * f))"
] | false | 0.043972 | 0.035267 | 1.246821 | [
"s831094355",
"s399779762"
] |
u859125915 | p03583 | python | s110971774 | s193488924 | 1,939 | 1,460 | 2,940 | 2,940 | Accepted | Accepted | 24.7 | N = int(eval(input()))
for a in range(1,3501):
for b in range(1,3501):
m = (4*a*b) - N*(a+b)
if m> 0 and N*a*b % m == 0:
c = (N*a*b)//m
break
else:
continue
break
print((a,b,c))
| N = int(eval(input()))
for a in range(1,3501):
for b in range(a,3501):
m = (4*a*b) - N*(a+b)
if m> 0 and N*a*b % m == 0:
c = (N*a*b)//m
break
else:
continue
break
print((a,b,c))
| 11 | 11 | 241 | 241 | N = int(eval(input()))
for a in range(1, 3501):
for b in range(1, 3501):
m = (4 * a * b) - N * (a + b)
if m > 0 and N * a * b % m == 0:
c = (N * a * b) // m
break
else:
continue
break
print((a, b, c))
| N = int(eval(input()))
for a in range(1, 3501):
for b in range(a, 3501):
m = (4 * a * b) - N * (a + b)
if m > 0 and N * a * b % m == 0:
c = (N * a * b) // m
break
else:
continue
break
print((a, b, c))
| false | 0 | [
"- for b in range(1, 3501):",
"+ for b in range(a, 3501):"
] | false | 0.60481 | 0.489072 | 1.236649 | [
"s110971774",
"s193488924"
] |
u777923818 | p03111 | python | s765701499 | s758154787 | 377 | 302 | 3,064 | 48,092 | Accepted | Accepted | 19.89 | # -*- coding: utf-8 -*-
from itertools import product
def inpl(): return list(map(int, input().split()))
N, A, B, C = inpl()
L = [int(eval(input())) for _ in range(N)]
ans = 1e9
for X in product(list(range(4)), repeat=N):
P = [[] for _ in range(4)]
for i, x in enumerate(X):
P[x].append(L[i])
if min(list(map(len, P[1:]))) == 0:
continue
tmp = 0
for Q, D in zip(P[1:], [A, B, C]):
tmp += 10*(len(Q)-1) + abs(D-sum(Q))
if tmp < ans:
ans = min(tmp, ans)
print(ans)
| import sys
input = sys.stdin.readline
def inpl(): return list(map(int, input().split()))
N, A, B, C = inpl()
L = [0]*N
for i in range(N):
L[i] = int(eval(input()))
ans = 10**9
for k in range(4**N):
ABC = [0]*3
CNT = [0]*3
j = k*1
for i in range(N):
d, m = divmod(j, 4)
if m <= 2:
ABC[m] += L[i]
CNT[m] += 1
j = d
if min(CNT) == 0:
continue
tmp = abs(ABC[0] - A) + abs(ABC[1] - B) + abs(ABC[2] - C) + sum([10*(cnt-1) for cnt in CNT])
ans = min(ans, tmp)
print(ans) | 24 | 26 | 530 | 573 | # -*- coding: utf-8 -*-
from itertools import product
def inpl():
return list(map(int, input().split()))
N, A, B, C = inpl()
L = [int(eval(input())) for _ in range(N)]
ans = 1e9
for X in product(list(range(4)), repeat=N):
P = [[] for _ in range(4)]
for i, x in enumerate(X):
P[x].append(L[i])
if min(list(map(len, P[1:]))) == 0:
continue
tmp = 0
for Q, D in zip(P[1:], [A, B, C]):
tmp += 10 * (len(Q) - 1) + abs(D - sum(Q))
if tmp < ans:
ans = min(tmp, ans)
print(ans)
| import sys
input = sys.stdin.readline
def inpl():
return list(map(int, input().split()))
N, A, B, C = inpl()
L = [0] * N
for i in range(N):
L[i] = int(eval(input()))
ans = 10**9
for k in range(4**N):
ABC = [0] * 3
CNT = [0] * 3
j = k * 1
for i in range(N):
d, m = divmod(j, 4)
if m <= 2:
ABC[m] += L[i]
CNT[m] += 1
j = d
if min(CNT) == 0:
continue
tmp = (
abs(ABC[0] - A)
+ abs(ABC[1] - B)
+ abs(ABC[2] - C)
+ sum([10 * (cnt - 1) for cnt in CNT])
)
ans = min(ans, tmp)
print(ans)
| false | 7.692308 | [
"-# -*- coding: utf-8 -*-",
"-from itertools import product",
"+import sys",
"+",
"+input = sys.stdin.readline",
"-L = [int(eval(input())) for _ in range(N)]",
"-ans = 1e9",
"-for X in product(list(range(4)), repeat=N):",
"- P = [[] for _ in range(4)]",
"- for i, x in enumerate(X):",
"- P[x].append(L[i])",
"- if min(list(map(len, P[1:]))) == 0:",
"+L = [0] * N",
"+for i in range(N):",
"+ L[i] = int(eval(input()))",
"+ans = 10**9",
"+for k in range(4**N):",
"+ ABC = [0] * 3",
"+ CNT = [0] * 3",
"+ j = k * 1",
"+ for i in range(N):",
"+ d, m = divmod(j, 4)",
"+ if m <= 2:",
"+ ABC[m] += L[i]",
"+ CNT[m] += 1",
"+ j = d",
"+ if min(CNT) == 0:",
"- tmp = 0",
"- for Q, D in zip(P[1:], [A, B, C]):",
"- tmp += 10 * (len(Q) - 1) + abs(D - sum(Q))",
"- if tmp < ans:",
"- ans = min(tmp, ans)",
"+ tmp = (",
"+ abs(ABC[0] - A)",
"+ + abs(ABC[1] - B)",
"+ + abs(ABC[2] - C)",
"+ + sum([10 * (cnt - 1) for cnt in CNT])",
"+ )",
"+ ans = min(ans, tmp)"
] | false | 0.42352 | 0.497265 | 0.8517 | [
"s765701499",
"s758154787"
] |
u600402037 | p02767 | python | s040396398 | s827298995 | 315 | 155 | 21,080 | 12,500 | Accepted | Accepted | 50.79 | import sys
import numpy as np
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
N = ir()
X = np.array(lr())
def F(z):
return ((X-z) ** 2).sum()
left = 0
right = 100
while right > left + 1:
left_mid = (2*left + right) / 3
right_mid = (left + 2*right) / 3
if F(left_mid) < F(right_mid):
right = right_mid
else:
left = left_mid
answer = min(F(int(left)), F(int(left)+1), F(int(left)+2))
print(answer)
| # coding: utf-8
import sys
import numpy as np
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
N = ir()
X = np.array(lr())
# Brute Force Attack
answer = 10 ** 6
for x in range(101):
temp = ((X-x) ** 2).sum()
if temp < answer:
answer = temp
print(answer)
| 24 | 18 | 519 | 349 | import sys
import numpy as np
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
N = ir()
X = np.array(lr())
def F(z):
return ((X - z) ** 2).sum()
left = 0
right = 100
while right > left + 1:
left_mid = (2 * left + right) / 3
right_mid = (left + 2 * right) / 3
if F(left_mid) < F(right_mid):
right = right_mid
else:
left = left_mid
answer = min(F(int(left)), F(int(left) + 1), F(int(left) + 2))
print(answer)
| # coding: utf-8
import sys
import numpy as np
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
N = ir()
X = np.array(lr())
# Brute Force Attack
answer = 10**6
for x in range(101):
temp = ((X - x) ** 2).sum()
if temp < answer:
answer = temp
print(answer)
| false | 25 | [
"+# coding: utf-8",
"-",
"-",
"-def F(z):",
"- return ((X - z) ** 2).sum()",
"-",
"-",
"-left = 0",
"-right = 100",
"-while right > left + 1:",
"- left_mid = (2 * left + right) / 3",
"- right_mid = (left + 2 * right) / 3",
"- if F(left_mid) < F(right_mid):",
"- right = right_mid",
"- else:",
"- left = left_mid",
"-answer = min(F(int(left)), F(int(left) + 1), F(int(left) + 2))",
"+# Brute Force Attack",
"+answer = 10**6",
"+for x in range(101):",
"+ temp = ((X - x) ** 2).sum()",
"+ if temp < answer:",
"+ answer = temp"
] | false | 0.188072 | 0.223965 | 0.83974 | [
"s040396398",
"s827298995"
] |
u816631826 | p02577 | python | s483719681 | s864000546 | 81 | 50 | 9,056 | 10,576 | Accepted | Accepted | 38.27 | user_input=eval(input())
i=len(user_input)-1
number=0
while i>=0:
number+=int(user_input[i])
i=i-1
if number%9==0:
print("Yes")
else :
print("No")
| x = eval(input(""))
for i in range(3):
alist = list(map(int,x))
result = sum(alist)
x = str(result)
if result % 9 == 0 :
print("Yes")
else:
print("No") | 10 | 9 | 174 | 173 | user_input = eval(input())
i = len(user_input) - 1
number = 0
while i >= 0:
number += int(user_input[i])
i = i - 1
if number % 9 == 0:
print("Yes")
else:
print("No")
| x = eval(input(""))
for i in range(3):
alist = list(map(int, x))
result = sum(alist)
x = str(result)
if result % 9 == 0:
print("Yes")
else:
print("No")
| false | 10 | [
"-user_input = eval(input())",
"-i = len(user_input) - 1",
"-number = 0",
"-while i >= 0:",
"- number += int(user_input[i])",
"- i = i - 1",
"-if number % 9 == 0:",
"+x = eval(input(\"\"))",
"+for i in range(3):",
"+ alist = list(map(int, x))",
"+ result = sum(alist)",
"+ x = str(result)",
"+if result % 9 == 0:"
] | false | 0.039492 | 0.035895 | 1.100215 | [
"s483719681",
"s864000546"
] |
u207241407 | p02642 | python | s228747522 | s170438657 | 367 | 320 | 33,036 | 32,372 | Accepted | Accepted | 12.81 | def main():
n = int(eval(input()))
a = tuple(map(int, input().split()))
ans = 0
mx = max(a) + 1
dp = [0] * mx
for i in a:
for j in range(i, mx, i):
dp[j] += 1
for i in a:
if dp[i] == 1:
ans += 1
print(ans)
if __name__ == "__main__":
main() | def main():
_ = int(eval(input()))
a = list(map(int, input().split()))
a.sort()
a = tuple(a)
ans = 0
mx = max(a) + 1
dp = [0] * mx
for i in a:
if dp[i] == 2:
continue
else:
for j in range(i, mx, i):
dp[j] += 1
for i in a:
if dp[i] == 1:
ans += 1
print(ans)
if __name__ == "__main__":
main() | 19 | 24 | 331 | 431 | def main():
n = int(eval(input()))
a = tuple(map(int, input().split()))
ans = 0
mx = max(a) + 1
dp = [0] * mx
for i in a:
for j in range(i, mx, i):
dp[j] += 1
for i in a:
if dp[i] == 1:
ans += 1
print(ans)
if __name__ == "__main__":
main()
| def main():
_ = int(eval(input()))
a = list(map(int, input().split()))
a.sort()
a = tuple(a)
ans = 0
mx = max(a) + 1
dp = [0] * mx
for i in a:
if dp[i] == 2:
continue
else:
for j in range(i, mx, i):
dp[j] += 1
for i in a:
if dp[i] == 1:
ans += 1
print(ans)
if __name__ == "__main__":
main()
| false | 20.833333 | [
"- n = int(eval(input()))",
"- a = tuple(map(int, input().split()))",
"+ _ = int(eval(input()))",
"+ a = list(map(int, input().split()))",
"+ a.sort()",
"+ a = tuple(a)",
"- for j in range(i, mx, i):",
"- dp[j] += 1",
"+ if dp[i] == 2:",
"+ continue",
"+ else:",
"+ for j in range(i, mx, i):",
"+ dp[j] += 1"
] | false | 0.087122 | 0.047944 | 1.817145 | [
"s228747522",
"s170438657"
] |
u631277801 | p03634 | python | s004125552 | s292902258 | 887 | 812 | 126,300 | 56,976 | Accepted | Accepted | 8.46 | import sys
stdin = sys.stdin
def li(): return list(map(int, stdin.readline().split()))
def li_(): return [int(x)-1 for x in stdin.readline().split()]
def lf(): return list(map(float, stdin.readline().split()))
def ls(): return stdin.readline().split()
def ns(): return stdin.readline().rstrip()
def lc(): return list(ns())
def ni(): return int(stdin.readline())
def nf(): return float(stdin.readline())
from heapq import heappush, heappop
def dijkstra(graph:list, node:int, start:int) -> list:
# 未探索のノードは距離INF
INF = float("inf")
dist = [INF]*node
# 始点ノードの距離を0とし、dfsのためのpriority queを作成
dist[start] = 0
heap = [(0,start)]
# 未探索のノードをpriority queueに入れる
while heap:
cost, cur_node = heappop(heap)
for nex_cost, nex_node in graph[cur_node]:
dist_cand = dist[cur_node] + nex_cost
if dist_cand < dist[nex_node]:
dist[nex_node] = dist_cand
heappush(heap, (dist[nex_node], nex_node))
return dist
n = ni()
abc = []
for _ in range(n-1):
a,b,c = li()
a -= 1
b -= 1
abc.append((a,b,c))
q,k = li()
k -= 1
query = [li_() for _ in range(q)]
# 隣接リストつくる
graph = [[] for _ in range(n)]
for frm,to,cost in abc:
graph[frm].append((cost,to))
graph[to].append((cost,frm))
# 頂点Kをスタートとするダイクストラ
dist = dijkstra(graph, n, k)
# クエリ処理
for frm,to in query:
print((dist[frm] + dist[to])) | import sys
stdin = sys.stdin
sys.setrecursionlimit(10**5)
def li(): return list(map(int, stdin.readline().split()))
def li_(): return [int(x)-1 for x in stdin.readline().split()]
def lf(): return list(map(float, stdin.readline().split()))
def ls(): return stdin.readline().split()
def ns(): return stdin.readline().rstrip()
def lc(): return list(ns())
def ni(): return int(stdin.readline())
def nf(): return float(stdin.readline())
from heapq import heappush, heappop
def dijkstra(graph:list, node:int, start:int) -> list:
# 未探索のノードは距離INF
INF = float("inf")
dist = [INF]*node
# 始点ノードの距離を0とし、dfsのためのpriority queを作成
dist[start] = 0
heap = [(0,start)]
# 未探索のノードをpriority queueに入れる
while heap:
cost, cur_node = heappop(heap)
for nex_cost, nex_node in graph[cur_node]:
dist_cand = dist[cur_node] + nex_cost
if dist_cand < dist[nex_node]:
dist[nex_node] = dist_cand
heappush(heap, (dist[nex_node], nex_node))
return dist
n = ni()
graph = [[] for _ in range(n)]
for _ in range(n-1):
a,b,c = li()
a -= 1
b -= 1
graph[a].append((c,b))
graph[b].append((c,a))
q,k = li()
dist = dijkstra(graph,n,k-1)
xy = [tuple(li_()) for _ in range(q)]
for x,y in xy:
print((dist[x]+dist[y])) | 58 | 54 | 1,470 | 1,379 | import sys
stdin = sys.stdin
def li():
return list(map(int, stdin.readline().split()))
def li_():
return [int(x) - 1 for x in stdin.readline().split()]
def lf():
return list(map(float, stdin.readline().split()))
def ls():
return stdin.readline().split()
def ns():
return stdin.readline().rstrip()
def lc():
return list(ns())
def ni():
return int(stdin.readline())
def nf():
return float(stdin.readline())
from heapq import heappush, heappop
def dijkstra(graph: list, node: int, start: int) -> list:
# 未探索のノードは距離INF
INF = float("inf")
dist = [INF] * node
# 始点ノードの距離を0とし、dfsのためのpriority queを作成
dist[start] = 0
heap = [(0, start)]
# 未探索のノードをpriority queueに入れる
while heap:
cost, cur_node = heappop(heap)
for nex_cost, nex_node in graph[cur_node]:
dist_cand = dist[cur_node] + nex_cost
if dist_cand < dist[nex_node]:
dist[nex_node] = dist_cand
heappush(heap, (dist[nex_node], nex_node))
return dist
n = ni()
abc = []
for _ in range(n - 1):
a, b, c = li()
a -= 1
b -= 1
abc.append((a, b, c))
q, k = li()
k -= 1
query = [li_() for _ in range(q)]
# 隣接リストつくる
graph = [[] for _ in range(n)]
for frm, to, cost in abc:
graph[frm].append((cost, to))
graph[to].append((cost, frm))
# 頂点Kをスタートとするダイクストラ
dist = dijkstra(graph, n, k)
# クエリ処理
for frm, to in query:
print((dist[frm] + dist[to]))
| import sys
stdin = sys.stdin
sys.setrecursionlimit(10**5)
def li():
return list(map(int, stdin.readline().split()))
def li_():
return [int(x) - 1 for x in stdin.readline().split()]
def lf():
return list(map(float, stdin.readline().split()))
def ls():
return stdin.readline().split()
def ns():
return stdin.readline().rstrip()
def lc():
return list(ns())
def ni():
return int(stdin.readline())
def nf():
return float(stdin.readline())
from heapq import heappush, heappop
def dijkstra(graph: list, node: int, start: int) -> list:
# 未探索のノードは距離INF
INF = float("inf")
dist = [INF] * node
# 始点ノードの距離を0とし、dfsのためのpriority queを作成
dist[start] = 0
heap = [(0, start)]
# 未探索のノードをpriority queueに入れる
while heap:
cost, cur_node = heappop(heap)
for nex_cost, nex_node in graph[cur_node]:
dist_cand = dist[cur_node] + nex_cost
if dist_cand < dist[nex_node]:
dist[nex_node] = dist_cand
heappush(heap, (dist[nex_node], nex_node))
return dist
n = ni()
graph = [[] for _ in range(n)]
for _ in range(n - 1):
a, b, c = li()
a -= 1
b -= 1
graph[a].append((c, b))
graph[b].append((c, a))
q, k = li()
dist = dijkstra(graph, n, k - 1)
xy = [tuple(li_()) for _ in range(q)]
for x, y in xy:
print((dist[x] + dist[y]))
| false | 6.896552 | [
"+sys.setrecursionlimit(10**5)",
"-abc = []",
"+graph = [[] for _ in range(n)]",
"- abc.append((a, b, c))",
"+ graph[a].append((c, b))",
"+ graph[b].append((c, a))",
"-k -= 1",
"-query = [li_() for _ in range(q)]",
"-# 隣接リストつくる",
"-graph = [[] for _ in range(n)]",
"-for frm, to, cost in abc:",
"- graph[frm].append((cost, to))",
"- graph[to].append((cost, frm))",
"-# 頂点Kをスタートとするダイクストラ",
"-dist = dijkstra(graph, n, k)",
"-# クエリ処理",
"-for frm, to in query:",
"- print((dist[frm] + dist[to]))",
"+dist = dijkstra(graph, n, k - 1)",
"+xy = [tuple(li_()) for _ in range(q)]",
"+for x, y in xy:",
"+ print((dist[x] + dist[y]))"
] | false | 0.050562 | 0.041274 | 1.225015 | [
"s004125552",
"s292902258"
] |
u607729897 | p02780 | python | s588208854 | s761815604 | 210 | 90 | 21,268 | 21,268 | Accepted | Accepted | 57.14 | import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
def main():
N, K, *p = list(map(int, read().split()))
p = list([(x+1)*0.5 for x in p])
p_sum = []
p_sum.append(p[0])
for i in range(1, len(p)):
p_sum.append(p_sum[i-1] + p[i])
result = p_sum[K-1]
for i in range(1,N-K+1):
result = max(result,p_sum[K-1+i] -p_sum[i-1])
return result
if __name__ == '__main__':
print((main()))
| def main():
from itertools import accumulate
import sys
read = sys.stdin.buffer.read
N, K, *p = list(map(int, read().split()))
p = [0] + list(accumulate(p))
print(((max(y - x for x, y in zip(p, p[K:])) + K) / 2))
if __name__ == '__main__':
main()
| 19 | 10 | 471 | 265 | import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
def main():
N, K, *p = list(map(int, read().split()))
p = list([(x + 1) * 0.5 for x in p])
p_sum = []
p_sum.append(p[0])
for i in range(1, len(p)):
p_sum.append(p_sum[i - 1] + p[i])
result = p_sum[K - 1]
for i in range(1, N - K + 1):
result = max(result, p_sum[K - 1 + i] - p_sum[i - 1])
return result
if __name__ == "__main__":
print((main()))
| def main():
from itertools import accumulate
import sys
read = sys.stdin.buffer.read
N, K, *p = list(map(int, read().split()))
p = [0] + list(accumulate(p))
print(((max(y - x for x, y in zip(p, p[K:])) + K) / 2))
if __name__ == "__main__":
main()
| false | 47.368421 | [
"-import sys",
"+def main():",
"+ from itertools import accumulate",
"+ import sys",
"-read = sys.stdin.buffer.read",
"-readline = sys.stdin.buffer.readline",
"-",
"-",
"-def main():",
"+ read = sys.stdin.buffer.read",
"- p = list([(x + 1) * 0.5 for x in p])",
"- p_sum = []",
"- p_sum.append(p[0])",
"- for i in range(1, len(p)):",
"- p_sum.append(p_sum[i - 1] + p[i])",
"- result = p_sum[K - 1]",
"- for i in range(1, N - K + 1):",
"- result = max(result, p_sum[K - 1 + i] - p_sum[i - 1])",
"- return result",
"+ p = [0] + list(accumulate(p))",
"+ print(((max(y - x for x, y in zip(p, p[K:])) + K) / 2))",
"- print((main()))",
"+ main()"
] | false | 0.073162 | 0.052134 | 1.403332 | [
"s588208854",
"s761815604"
] |
u155024797 | p03332 | python | s647641635 | s554909718 | 460 | 265 | 26,740 | 45,932 | Accepted | Accepted | 42.39 | MOD = 998244353
MAX = int(3e5 + 1)
def div(a, b):
return a * pow(b, MOD-2, MOD) % MOD
FACT = [1] * (MAX+1)
for i in range(1, MAX+1):
FACT[i] = (i * FACT[i-1]) % MOD
INV = [1] * (MAX+1)
INV[MAX] = div(1, FACT[MAX])
for i in range(MAX, 0, -1):
INV[i-1] = (INV[i] * i) % MOD
def main():
N, A, B, K = list(map(int, input().split()))
ans = 0
# solve Ax + By = K
for x in range(N+1):
By = K - x * A
if By >= 0 and By % B == 0 and By <= B * N:
y = By // B
tmp1 = FACT[N] * INV[x] * INV[N-x] % MOD
tmp2 = FACT[N] * INV[y] * INV[N-y] % MOD
ans = (ans + tmp1 * tmp2) % MOD
print(ans)
if __name__ == "__main__":
main()
| MOD = 998244353
MAX = int(3e5 + 10)
def div(a, b):
return a * pow(b, MOD-2, MOD) % MOD
FACT = [1] * (MAX+1)
for i in range(1, MAX+1):
FACT[i] = (i * FACT[i-1]) % MOD
INV = [1] * (MAX+1)
INV[MAX] = div(1, FACT[MAX])
for i in range(MAX, 0, -1):
INV[i-1] = (INV[i] * i) % MOD
def main():
N, A, B, K = list(map(int, input().split()))
ans = 0
# solve Ax + By = K
for x in range(N+1):
By = K - x * A
if By >= 0 and By % B == 0 and By <= B * N:
y = By // B
tmp1 = FACT[N] * INV[x] * INV[N-x] % MOD
tmp2 = FACT[N] * INV[y] * INV[N-y] % MOD
ans = (ans + tmp1 * tmp2) % MOD
print(ans)
if __name__ == "__main__":
main()
| 32 | 32 | 740 | 741 | MOD = 998244353
MAX = int(3e5 + 1)
def div(a, b):
return a * pow(b, MOD - 2, MOD) % MOD
FACT = [1] * (MAX + 1)
for i in range(1, MAX + 1):
FACT[i] = (i * FACT[i - 1]) % MOD
INV = [1] * (MAX + 1)
INV[MAX] = div(1, FACT[MAX])
for i in range(MAX, 0, -1):
INV[i - 1] = (INV[i] * i) % MOD
def main():
N, A, B, K = list(map(int, input().split()))
ans = 0
# solve Ax + By = K
for x in range(N + 1):
By = K - x * A
if By >= 0 and By % B == 0 and By <= B * N:
y = By // B
tmp1 = FACT[N] * INV[x] * INV[N - x] % MOD
tmp2 = FACT[N] * INV[y] * INV[N - y] % MOD
ans = (ans + tmp1 * tmp2) % MOD
print(ans)
if __name__ == "__main__":
main()
| MOD = 998244353
MAX = int(3e5 + 10)
def div(a, b):
return a * pow(b, MOD - 2, MOD) % MOD
FACT = [1] * (MAX + 1)
for i in range(1, MAX + 1):
FACT[i] = (i * FACT[i - 1]) % MOD
INV = [1] * (MAX + 1)
INV[MAX] = div(1, FACT[MAX])
for i in range(MAX, 0, -1):
INV[i - 1] = (INV[i] * i) % MOD
def main():
N, A, B, K = list(map(int, input().split()))
ans = 0
# solve Ax + By = K
for x in range(N + 1):
By = K - x * A
if By >= 0 and By % B == 0 and By <= B * N:
y = By // B
tmp1 = FACT[N] * INV[x] * INV[N - x] % MOD
tmp2 = FACT[N] * INV[y] * INV[N - y] % MOD
ans = (ans + tmp1 * tmp2) % MOD
print(ans)
if __name__ == "__main__":
main()
| false | 0 | [
"-MAX = int(3e5 + 1)",
"+MAX = int(3e5 + 10)"
] | false | 0.572466 | 0.700637 | 0.817066 | [
"s647641635",
"s554909718"
] |
u729133443 | p03399 | python | s287540537 | s810418171 | 17 | 10 | 2,940 | 2,568 | Accepted | Accepted | 41.18 | print((eval('+min(%s)'%('int(input()),'*2)*2))) | print(eval('+min(%s)'%('input(),'*2)*2)) | 1 | 1 | 45 | 39 | print((eval("+min(%s)" % ("int(input())," * 2) * 2)))
| print(eval("+min(%s)" % ("input()," * 2) * 2))
| false | 0 | [
"-print((eval(\"+min(%s)\" % (\"int(input()),\" * 2) * 2)))",
"+print(eval(\"+min(%s)\" % (\"input(),\" * 2) * 2))"
] | false | 0.042827 | 0.041133 | 1.041189 | [
"s287540537",
"s810418171"
] |
u022407960 | p02326 | python | s022419721 | s461748219 | 2,620 | 1,530 | 60,328 | 60,288 | Accepted | Accepted | 41.6 | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
input:
4 5
0 0 1 0 0
1 0 0 0 0
0 0 0 1 0
0 0 0 1 0
output:
4
"""
import sys
def solve():
dp = [[0] * W for _ in range(H)]
max_width = 0
for m in range(H):
for n in range(W):
dp[m][n] = (int(carpet_info[m][n]) + 1) % 2
max_width |= dp[m][n]
for i in range(1, H):
for j in range(1, W):
if int(carpet_info[i][j]):
dp[i][j] = 0
else:
dp[i][j] = min(dp[i - 1][j - 1], dp[i - 1][j], dp[i][j - 1]) + 1
max_width = max(max_width, dp[i][j])
return pow(max_width, 2)
if __name__ == '__main__':
_input = sys.stdin.readlines()
H, W = list(map(int, _input[0].split()))
carpet_info = list([x.split() for x in _input[1:]])
print((solve())) | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
input:
4 5
0 0 1 0 0
1 0 0 0 0
0 0 0 1 0
0 0 0 1 0
output:
4
"""
import sys
def solve():
dp = [[0] * (W + 1) for _ in range(H + 1)]
for i in range(H):
for j in range(W):
if not int(carpet_info[i][j]):
dp[i + 1][j + 1] = min(dp[i][j], dp[i][j + 1], dp[i + 1][j]) + 1
cand = (max(each) for each in dp)
return pow(max(cand), 2)
if __name__ == '__main__':
_input = sys.stdin.readlines()
H, W = list(map(int, _input[0].split()))
carpet_info = list([x.split() for x in _input[1:]])
print((solve())) | 41 | 34 | 867 | 648 | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
input:
4 5
0 0 1 0 0
1 0 0 0 0
0 0 0 1 0
0 0 0 1 0
output:
4
"""
import sys
def solve():
dp = [[0] * W for _ in range(H)]
max_width = 0
for m in range(H):
for n in range(W):
dp[m][n] = (int(carpet_info[m][n]) + 1) % 2
max_width |= dp[m][n]
for i in range(1, H):
for j in range(1, W):
if int(carpet_info[i][j]):
dp[i][j] = 0
else:
dp[i][j] = min(dp[i - 1][j - 1], dp[i - 1][j], dp[i][j - 1]) + 1
max_width = max(max_width, dp[i][j])
return pow(max_width, 2)
if __name__ == "__main__":
_input = sys.stdin.readlines()
H, W = list(map(int, _input[0].split()))
carpet_info = list([x.split() for x in _input[1:]])
print((solve()))
| #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
input:
4 5
0 0 1 0 0
1 0 0 0 0
0 0 0 1 0
0 0 0 1 0
output:
4
"""
import sys
def solve():
dp = [[0] * (W + 1) for _ in range(H + 1)]
for i in range(H):
for j in range(W):
if not int(carpet_info[i][j]):
dp[i + 1][j + 1] = min(dp[i][j], dp[i][j + 1], dp[i + 1][j]) + 1
cand = (max(each) for each in dp)
return pow(max(cand), 2)
if __name__ == "__main__":
_input = sys.stdin.readlines()
H, W = list(map(int, _input[0].split()))
carpet_info = list([x.split() for x in _input[1:]])
print((solve()))
| false | 17.073171 | [
"- dp = [[0] * W for _ in range(H)]",
"- max_width = 0",
"- for m in range(H):",
"- for n in range(W):",
"- dp[m][n] = (int(carpet_info[m][n]) + 1) % 2",
"- max_width |= dp[m][n]",
"- for i in range(1, H):",
"- for j in range(1, W):",
"- if int(carpet_info[i][j]):",
"- dp[i][j] = 0",
"- else:",
"- dp[i][j] = min(dp[i - 1][j - 1], dp[i - 1][j], dp[i][j - 1]) + 1",
"- max_width = max(max_width, dp[i][j])",
"- return pow(max_width, 2)",
"+ dp = [[0] * (W + 1) for _ in range(H + 1)]",
"+ for i in range(H):",
"+ for j in range(W):",
"+ if not int(carpet_info[i][j]):",
"+ dp[i + 1][j + 1] = min(dp[i][j], dp[i][j + 1], dp[i + 1][j]) + 1",
"+ cand = (max(each) for each in dp)",
"+ return pow(max(cand), 2)"
] | false | 0.059398 | 0.057498 | 1.033042 | [
"s022419721",
"s461748219"
] |
u113971909 | p02887 | python | s063789032 | s215050804 | 44 | 38 | 3,316 | 9,184 | Accepted | Accepted | 13.64 | N = int(eval(input()))
S = eval(input())
tmp = S[0]
ret = tmp
for i in S:
if tmp == i:
tmp = i
else:
ret += i
tmp = i
print((len(ret))) | #!/usr/bin python3
# -*- coding: utf-8 -*-
def main():
N = int(eval(input()))
S = eval(input())
nw = S[0]
ret = 1
for i in range(1,N):
if nw == S[i]:
continue
else:
nw = S[i]
ret += 1
print(ret)
if __name__ == '__main__':
main() | 11 | 18 | 147 | 315 | N = int(eval(input()))
S = eval(input())
tmp = S[0]
ret = tmp
for i in S:
if tmp == i:
tmp = i
else:
ret += i
tmp = i
print((len(ret)))
| #!/usr/bin python3
# -*- coding: utf-8 -*-
def main():
N = int(eval(input()))
S = eval(input())
nw = S[0]
ret = 1
for i in range(1, N):
if nw == S[i]:
continue
else:
nw = S[i]
ret += 1
print(ret)
if __name__ == "__main__":
main()
| false | 38.888889 | [
"-N = int(eval(input()))",
"-S = eval(input())",
"-tmp = S[0]",
"-ret = tmp",
"-for i in S:",
"- if tmp == i:",
"- tmp = i",
"- else:",
"- ret += i",
"- tmp = i",
"-print((len(ret)))",
"+#!/usr/bin python3",
"+# -*- coding: utf-8 -*-",
"+def main():",
"+ N = int(eval(input()))",
"+ S = eval(input())",
"+ nw = S[0]",
"+ ret = 1",
"+ for i in range(1, N):",
"+ if nw == S[i]:",
"+ continue",
"+ else:",
"+ nw = S[i]",
"+ ret += 1",
"+ print(ret)",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ main()"
] | false | 0.068828 | 0.087917 | 0.78288 | [
"s063789032",
"s215050804"
] |
u780364430 | p03309 | python | s520065376 | s440036463 | 354 | 256 | 34,212 | 34,224 | Accepted | Accepted | 27.68 | from numpy import median
N = int(eval(input()))
A = list(map(int, input().split()))
A = [a - i - 1 for i, a in enumerate(A)]
A = sorted(A)
b = int(median(A))
print((sum([abs(i - b) for i in A])))
| from numpy import median
N = int(eval(input()))
A = list(map(int, input().split()))
A = [a - i - 1 for i, a in enumerate(A)]
b = int(median(A))
print((sum([abs(i - b) for i in A])))
| 8 | 7 | 196 | 181 | from numpy import median
N = int(eval(input()))
A = list(map(int, input().split()))
A = [a - i - 1 for i, a in enumerate(A)]
A = sorted(A)
b = int(median(A))
print((sum([abs(i - b) for i in A])))
| from numpy import median
N = int(eval(input()))
A = list(map(int, input().split()))
A = [a - i - 1 for i, a in enumerate(A)]
b = int(median(A))
print((sum([abs(i - b) for i in A])))
| false | 12.5 | [
"-A = sorted(A)"
] | false | 0.247511 | 0.223645 | 1.106714 | [
"s520065376",
"s440036463"
] |
u389910364 | p03087 | python | s504630518 | s680535305 | 884 | 477 | 6,396 | 40,596 | Accepted | Accepted | 46.04 | n, q = list(map(int, input().split()))
s = eval(input())
count = 0
counts = []
prev = ''
for c in list(s):
if prev + c == 'AC':
count += 1
counts.append(count)
prev = c
for _ in range(q):
l, r = list(map(int, input().split()))
print((counts[r - 1] - counts[l - 1]))
| import bisect
import cmath
import heapq
import itertools
import math
import operator
import os
import re
import string
import sys
from collections import Counter, deque, defaultdict
from copy import deepcopy
from decimal import Decimal
from fractions import gcd
from functools import lru_cache, reduce
from operator import itemgetter, mul, add, xor
import numpy as np
if os.getenv("LOCAL"):
sys.stdin = open("_in.txt", "r")
sys.setrecursionlimit(10 ** 9)
INF = float("inf")
IINF = 10 ** 18
MOD = 10 ** 9 + 7
# MOD = 998244353
N, Q = list(map(int, sys.stdin.buffer.readline().split()))
S = sys.stdin.buffer.readline().decode().rstrip()
LR = [list(map(int, sys.stdin.buffer.readline().split())) for _ in range(Q)]
counts = [0] * N
cnt = 0
for i in range(N - 1):
if S[i] + S[i + 1] == 'AC':
cnt += 1
counts[i + 1] = cnt
for l, r in LR:
r -= 1
l -= 1
a = counts[r] - counts[l]
print(a)
| 15 | 47 | 290 | 973 | n, q = list(map(int, input().split()))
s = eval(input())
count = 0
counts = []
prev = ""
for c in list(s):
if prev + c == "AC":
count += 1
counts.append(count)
prev = c
for _ in range(q):
l, r = list(map(int, input().split()))
print((counts[r - 1] - counts[l - 1]))
| import bisect
import cmath
import heapq
import itertools
import math
import operator
import os
import re
import string
import sys
from collections import Counter, deque, defaultdict
from copy import deepcopy
from decimal import Decimal
from fractions import gcd
from functools import lru_cache, reduce
from operator import itemgetter, mul, add, xor
import numpy as np
if os.getenv("LOCAL"):
sys.stdin = open("_in.txt", "r")
sys.setrecursionlimit(10**9)
INF = float("inf")
IINF = 10**18
MOD = 10**9 + 7
# MOD = 998244353
N, Q = list(map(int, sys.stdin.buffer.readline().split()))
S = sys.stdin.buffer.readline().decode().rstrip()
LR = [list(map(int, sys.stdin.buffer.readline().split())) for _ in range(Q)]
counts = [0] * N
cnt = 0
for i in range(N - 1):
if S[i] + S[i + 1] == "AC":
cnt += 1
counts[i + 1] = cnt
for l, r in LR:
r -= 1
l -= 1
a = counts[r] - counts[l]
print(a)
| false | 68.085106 | [
"-n, q = list(map(int, input().split()))",
"-s = eval(input())",
"-count = 0",
"-counts = []",
"-prev = \"\"",
"-for c in list(s):",
"- if prev + c == \"AC\":",
"- count += 1",
"- counts.append(count)",
"- prev = c",
"-for _ in range(q):",
"- l, r = list(map(int, input().split()))",
"- print((counts[r - 1] - counts[l - 1]))",
"+import bisect",
"+import cmath",
"+import heapq",
"+import itertools",
"+import math",
"+import operator",
"+import os",
"+import re",
"+import string",
"+import sys",
"+from collections import Counter, deque, defaultdict",
"+from copy import deepcopy",
"+from decimal import Decimal",
"+from fractions import gcd",
"+from functools import lru_cache, reduce",
"+from operator import itemgetter, mul, add, xor",
"+import numpy as np",
"+",
"+if os.getenv(\"LOCAL\"):",
"+ sys.stdin = open(\"_in.txt\", \"r\")",
"+sys.setrecursionlimit(10**9)",
"+INF = float(\"inf\")",
"+IINF = 10**18",
"+MOD = 10**9 + 7",
"+# MOD = 998244353",
"+N, Q = list(map(int, sys.stdin.buffer.readline().split()))",
"+S = sys.stdin.buffer.readline().decode().rstrip()",
"+LR = [list(map(int, sys.stdin.buffer.readline().split())) for _ in range(Q)]",
"+counts = [0] * N",
"+cnt = 0",
"+for i in range(N - 1):",
"+ if S[i] + S[i + 1] == \"AC\":",
"+ cnt += 1",
"+ counts[i + 1] = cnt",
"+for l, r in LR:",
"+ r -= 1",
"+ l -= 1",
"+ a = counts[r] - counts[l]",
"+ print(a)"
] | false | 0.107038 | 0.037498 | 2.854466 | [
"s504630518",
"s680535305"
] |
u363610900 | p03485 | python | s437786208 | s847084931 | 19 | 17 | 2,940 | 2,940 | Accepted | Accepted | 10.53 | import math
a, b = list(map(int, input().split()))
print((math.ceil((a+b)/2))) | # -*- coding: utf-8 -*-
import math
def func(a, b):
result = math.ceil((a+b)/2)
return result
a, b = list(map(int, input().split()))
print((func(a, b)))
| 3 | 13 | 72 | 171 | import math
a, b = list(map(int, input().split()))
print((math.ceil((a + b) / 2)))
| # -*- coding: utf-8 -*-
import math
def func(a, b):
result = math.ceil((a + b) / 2)
return result
a, b = list(map(int, input().split()))
print((func(a, b)))
| false | 76.923077 | [
"+# -*- coding: utf-8 -*-",
"+",
"+def func(a, b):",
"+ result = math.ceil((a + b) / 2)",
"+ return result",
"+",
"+",
"-print((math.ceil((a + b) / 2)))",
"+print((func(a, b)))"
] | false | 0.087065 | 0.08602 | 1.012158 | [
"s437786208",
"s847084931"
] |
u434872492 | p03696 | python | s827348782 | s580970192 | 70 | 63 | 61,780 | 61,804 | Accepted | Accepted | 10 | N = int(eval(input()))
S = eval(input())
l = 0
r = 0
for i in range(N):
if S[i] == ")":
r -= 1
if r<0:
l += 1
r=0 #rを0に戻す作業
else:
r += 1
print(("("*l + S + ")"*r)) | N = int(eval(input()))
S = eval(input())
l = 0
r = 0
for i in range(N):
if S[i]==")":
r -= 1
if r<0:
l += 1
r = 0
else:
r += 1
ans = "("*l + S + ")"*r
print(ans) | 15 | 17 | 221 | 224 | N = int(eval(input()))
S = eval(input())
l = 0
r = 0
for i in range(N):
if S[i] == ")":
r -= 1
if r < 0:
l += 1
r = 0 # rを0に戻す作業
else:
r += 1
print(("(" * l + S + ")" * r))
| N = int(eval(input()))
S = eval(input())
l = 0
r = 0
for i in range(N):
if S[i] == ")":
r -= 1
if r < 0:
l += 1
r = 0
else:
r += 1
ans = "(" * l + S + ")" * r
print(ans)
| false | 11.764706 | [
"- r = 0 # rを0に戻す作業",
"+ r = 0",
"-print((\"(\" * l + S + \")\" * r))",
"+ans = \"(\" * l + S + \")\" * r",
"+print(ans)"
] | false | 0.039134 | 0.13171 | 0.297119 | [
"s827348782",
"s580970192"
] |
u467736898 | p03305 | python | s881132627 | s499023669 | 1,855 | 982 | 186,744 | 91,668 | Accepted | Accepted | 47.06 | import heapq
N, M, S, T = list(map(int, input().split()))
class Dijkstra:
def dijkstra(self, adj, start, goal=None):
num = N # グラフのノード数
dist = [float('inf') for i in range(num)] # 始点から各頂点までの最短距離を格納する
prev = [float('inf') for i in range(num)] # 最短経路における，その頂点の前の頂点のIDを格納する
dist[start] = 0
q = [] # プライオリティキュー．各要素は，(startからある頂点vまでの仮の距離, 頂点vのID)からなるタプル
heapq.heappush(q, (0, start)) # 始点をpush
for i in range(num-1):
prov_cost, src = heapq.heappop(q) # pop
# プライオリティキューに格納されている最短距離が，現在計算できている最短距離より大きければ，distの更新をする必要はない
if dist[src] < prov_cost:
continue
# 他の頂点の探索
for dest, cost in list(adj[src].items()):
if dist[dest] > dist[src] + cost:
dist[dest] = dist[src] + cost # distの更新
heapq.heappush(q, (dist[dest], dest)) # キューに新たな仮の距離の情報をpush
prev[dest] = src # 前の頂点を記録
if goal is not None:
return self.get_path(goal, prev)
else:
return dist
def get_path(self, goal, prev):
'''
始点startから終点goalまでの最短経路を求める
'''
path = [goal] # 最短経路
dest = goal
# 終点から最短経路を逆順に辿る
while prev[dest] != float('inf'):
path.append(prev[dest])
dest = prev[dest]
# 経路をreverseして出力
return list(reversed(path))
from collections import defaultdict
Ey = defaultdict(lambda: defaultdict(lambda: float("inf")))
Es = defaultdict(lambda: defaultdict(lambda: float("inf")))
E = [list(map(int, input().split())) for i in range(M)]
for e in E:
u, v, a, b = e
Ey[u-1][v-1] = Ey[v-1][u-1] = a
Es[u-1][v-1] = Es[v-1][u-1] = b
dj = Dijkstra()
Dy = dj.dijkstra(Ey, S-1)
Ds = dj.dijkstra(Es, T-1)
mi = float("inf")
Ans = [0] * N
for i in range(N-1, -1, -1):
mi = min(mi, Dy[i]+Ds[i])
Ans[i] = mi
for a in Ans:
print((10**15-a))
| import sys
def main():
N, M, S, T = list(map(int, input().split()))
A = [[] for _ in range(N+1)]
B = [[] for _ in range(N+1)]
for u, v, a, b in zip(*[iter(map(int, sys.stdin.read().split()))]*4):
A[u].append((v, a))
A[v].append((u, a))
B[u].append((v, b))
B[v].append((u, b))
def dijkstra(E, start):
from heapq import heappush, heappop
N = len(E)
inf = float("inf")
dist = [inf] * N
dist[start] = 0
q = [(0, start)]
while q:
dist_v, v = heappop(q)
if dist[v] != dist_v:
continue
for u, dist_vu in E[v]:
dist_u = dist_v + dist_vu
if dist_u < dist[u]:
dist[u] = dist_u
heappush(q, (dist_u, u))
return dist
dist_A = dijkstra(A, S)
dist_B = dijkstra(B, T)
init = 10**15
Ans = []
ans = float("inf")
for a, b in zip(dist_A[:0:-1], dist_B[:0:-1]):
ans = min(ans, a+b)
Ans.append(init-ans)
Ans.reverse()
print(("\n".join(map(str, Ans))))
main()
| 73 | 42 | 2,037 | 1,162 | import heapq
N, M, S, T = list(map(int, input().split()))
class Dijkstra:
def dijkstra(self, adj, start, goal=None):
num = N # グラフのノード数
dist = [float("inf") for i in range(num)] # 始点から各頂点までの最短距離を格納する
prev = [float("inf") for i in range(num)] # 最短経路における，その頂点の前の頂点のIDを格納する
dist[start] = 0
q = [] # プライオリティキュー．各要素は，(startからある頂点vまでの仮の距離, 頂点vのID)からなるタプル
heapq.heappush(q, (0, start)) # 始点をpush
for i in range(num - 1):
prov_cost, src = heapq.heappop(q) # pop
# プライオリティキューに格納されている最短距離が，現在計算できている最短距離より大きければ，distの更新をする必要はない
if dist[src] < prov_cost:
continue
# 他の頂点の探索
for dest, cost in list(adj[src].items()):
if dist[dest] > dist[src] + cost:
dist[dest] = dist[src] + cost # distの更新
heapq.heappush(q, (dist[dest], dest)) # キューに新たな仮の距離の情報をpush
prev[dest] = src # 前の頂点を記録
if goal is not None:
return self.get_path(goal, prev)
else:
return dist
def get_path(self, goal, prev):
"""
始点startから終点goalまでの最短経路を求める
"""
path = [goal] # 最短経路
dest = goal
# 終点から最短経路を逆順に辿る
while prev[dest] != float("inf"):
path.append(prev[dest])
dest = prev[dest]
# 経路をreverseして出力
return list(reversed(path))
from collections import defaultdict
Ey = defaultdict(lambda: defaultdict(lambda: float("inf")))
Es = defaultdict(lambda: defaultdict(lambda: float("inf")))
E = [list(map(int, input().split())) for i in range(M)]
for e in E:
u, v, a, b = e
Ey[u - 1][v - 1] = Ey[v - 1][u - 1] = a
Es[u - 1][v - 1] = Es[v - 1][u - 1] = b
dj = Dijkstra()
Dy = dj.dijkstra(Ey, S - 1)
Ds = dj.dijkstra(Es, T - 1)
mi = float("inf")
Ans = [0] * N
for i in range(N - 1, -1, -1):
mi = min(mi, Dy[i] + Ds[i])
Ans[i] = mi
for a in Ans:
print((10**15 - a))
| import sys
def main():
N, M, S, T = list(map(int, input().split()))
A = [[] for _ in range(N + 1)]
B = [[] for _ in range(N + 1)]
for u, v, a, b in zip(*[iter(map(int, sys.stdin.read().split()))] * 4):
A[u].append((v, a))
A[v].append((u, a))
B[u].append((v, b))
B[v].append((u, b))
def dijkstra(E, start):
from heapq import heappush, heappop
N = len(E)
inf = float("inf")
dist = [inf] * N
dist[start] = 0
q = [(0, start)]
while q:
dist_v, v = heappop(q)
if dist[v] != dist_v:
continue
for u, dist_vu in E[v]:
dist_u = dist_v + dist_vu
if dist_u < dist[u]:
dist[u] = dist_u
heappush(q, (dist_u, u))
return dist
dist_A = dijkstra(A, S)
dist_B = dijkstra(B, T)
init = 10**15
Ans = []
ans = float("inf")
for a, b in zip(dist_A[:0:-1], dist_B[:0:-1]):
ans = min(ans, a + b)
Ans.append(init - ans)
Ans.reverse()
print(("\n".join(map(str, Ans))))
main()
| false | 42.465753 | [
"-import heapq",
"-",
"-N, M, S, T = list(map(int, input().split()))",
"+import sys",
"-class Dijkstra:",
"- def dijkstra(self, adj, start, goal=None):",
"- num = N # グラフのノード数",
"- dist = [float(\"inf\") for i in range(num)] # 始点から各頂点までの最短距離を格納する",
"- prev = [float(\"inf\") for i in range(num)] # 最短経路における，その頂点の前の頂点のIDを格納する",
"+def main():",
"+ N, M, S, T = list(map(int, input().split()))",
"+ A = [[] for _ in range(N + 1)]",
"+ B = [[] for _ in range(N + 1)]",
"+ for u, v, a, b in zip(*[iter(map(int, sys.stdin.read().split()))] * 4):",
"+ A[u].append((v, a))",
"+ A[v].append((u, a))",
"+ B[u].append((v, b))",
"+ B[v].append((u, b))",
"+",
"+ def dijkstra(E, start):",
"+ from heapq import heappush, heappop",
"+",
"+ N = len(E)",
"+ inf = float(\"inf\")",
"+ dist = [inf] * N",
"- q = [] # プライオリティキュー．各要素は，(startからある頂点vまでの仮の距離, 頂点vのID)からなるタプル",
"- heapq.heappush(q, (0, start)) # 始点をpush",
"- for i in range(num - 1):",
"- prov_cost, src = heapq.heappop(q) # pop",
"- # プライオリティキューに格納されている最短距離が，現在計算できている最短距離より大きければ，distの更新をする必要はない",
"- if dist[src] < prov_cost:",
"+ q = [(0, start)]",
"+ while q:",
"+ dist_v, v = heappop(q)",
"+ if dist[v] != dist_v:",
"- # 他の頂点の探索",
"- for dest, cost in list(adj[src].items()):",
"- if dist[dest] > dist[src] + cost:",
"- dist[dest] = dist[src] + cost # distの更新",
"- heapq.heappush(q, (dist[dest], dest)) # キューに新たな仮の距離の情報をpush",
"- prev[dest] = src # 前の頂点を記録",
"- if goal is not None:",
"- return self.get_path(goal, prev)",
"- else:",
"- return dist",
"+ for u, dist_vu in E[v]:",
"+ dist_u = dist_v + dist_vu",
"+ if dist_u < dist[u]:",
"+ dist[u] = dist_u",
"+ heappush(q, (dist_u, u))",
"+ return dist",
"- def get_path(self, goal, prev):",
"- \"\"\"",
"- 始点startから終点goalまでの最短経路を求める",
"- \"\"\"",
"- path = [goal] # 最短経路",
"- dest = goal",
"- # 終点から最短経路を逆順に辿る",
"- while prev[dest] != float(\"inf\"):",
"- path.append(prev[dest])",
"- dest = prev[dest]",
"- # 経路をreverseして出力",
"- return list(reversed(path))",
"+ dist_A = dijkstra(A, S)",
"+ dist_B = dijkstra(B, T)",
"+ init = 10**15",
"+ Ans = []",
"+ ans = float(\"inf\")",
"+ for a, b in zip(dist_A[:0:-1], dist_B[:0:-1]):",
"+ ans = min(ans, a + b)",
"+ Ans.append(init - ans)",
"+ Ans.reverse()",
"+ print((\"\\n\".join(map(str, Ans))))",
"-from collections import defaultdict",
"-",
"-Ey = defaultdict(lambda: defaultdict(lambda: float(\"inf\")))",
"-Es = defaultdict(lambda: defaultdict(lambda: float(\"inf\")))",
"-E = [list(map(int, input().split())) for i in range(M)]",
"-for e in E:",
"- u, v, a, b = e",
"- Ey[u - 1][v - 1] = Ey[v - 1][u - 1] = a",
"- Es[u - 1][v - 1] = Es[v - 1][u - 1] = b",
"-dj = Dijkstra()",
"-Dy = dj.dijkstra(Ey, S - 1)",
"-Ds = dj.dijkstra(Es, T - 1)",
"-mi = float(\"inf\")",
"-Ans = [0] * N",
"-for i in range(N - 1, -1, -1):",
"- mi = min(mi, Dy[i] + Ds[i])",
"- Ans[i] = mi",
"-for a in Ans:",
"- print((10**15 - a))",
"+main()"
] | false | 0.036957 | 0.064144 | 0.576156 | [
"s881132627",
"s499023669"
] |
u297574184 | p02888 | python | s444043630 | s506738213 | 889 | 226 | 3,188 | 3,188 | Accepted | Accepted | 74.58 | from bisect import bisect_left, bisect_right
def solve():
N = int(eval(input()))
Ls = list(map(int, input().split()))
Ls.sort()
ans = 0
for i in range(N):
for j in range(i+1, N):
k = bisect_left(Ls, Ls[i]+Ls[j]) - 1
ans += k-j
print(ans)
solve()
| from itertools import accumulate
maxL = 10**3
N = int(eval(input()))
Ls = list(map(int, input().split()))
nums = [0] * (2*maxL+1)
for L in Ls:
nums[L] += 1
accNums = list(accumulate(nums))
ans = 0
for A in range(1, maxL+1):
if nums[A] == 0: continue
for B in range(A+1, maxL+1):
if nums[B] == 0: continue
ans += nums[A] * nums[B] * (accNums[A+B-1]-accNums[B])
for A in range(1, maxL+1):
if nums[A] < 2: continue
ans += nums[A] * (nums[A]-1) // 2 * (accNums[2*A-1]-nums[A])
for A in range(1, maxL+1):
if nums[A] < 3: continue
ans += nums[A] * (nums[A]-1) * (nums[A]-2) // 6
print(ans)
| 18 | 29 | 319 | 658 | from bisect import bisect_left, bisect_right
def solve():
N = int(eval(input()))
Ls = list(map(int, input().split()))
Ls.sort()
ans = 0
for i in range(N):
for j in range(i + 1, N):
k = bisect_left(Ls, Ls[i] + Ls[j]) - 1
ans += k - j
print(ans)
solve()
| from itertools import accumulate
maxL = 10**3
N = int(eval(input()))
Ls = list(map(int, input().split()))
nums = [0] * (2 * maxL + 1)
for L in Ls:
nums[L] += 1
accNums = list(accumulate(nums))
ans = 0
for A in range(1, maxL + 1):
if nums[A] == 0:
continue
for B in range(A + 1, maxL + 1):
if nums[B] == 0:
continue
ans += nums[A] * nums[B] * (accNums[A + B - 1] - accNums[B])
for A in range(1, maxL + 1):
if nums[A] < 2:
continue
ans += nums[A] * (nums[A] - 1) // 2 * (accNums[2 * A - 1] - nums[A])
for A in range(1, maxL + 1):
if nums[A] < 3:
continue
ans += nums[A] * (nums[A] - 1) * (nums[A] - 2) // 6
print(ans)
| false | 37.931034 | [
"-from bisect import bisect_left, bisect_right",
"+from itertools import accumulate",
"-",
"-def solve():",
"- N = int(eval(input()))",
"- Ls = list(map(int, input().split()))",
"- Ls.sort()",
"- ans = 0",
"- for i in range(N):",
"- for j in range(i + 1, N):",
"- k = bisect_left(Ls, Ls[i] + Ls[j]) - 1",
"- ans += k - j",
"- print(ans)",
"-",
"-",
"-solve()",
"+maxL = 10**3",
"+N = int(eval(input()))",
"+Ls = list(map(int, input().split()))",
"+nums = [0] * (2 * maxL + 1)",
"+for L in Ls:",
"+ nums[L] += 1",
"+accNums = list(accumulate(nums))",
"+ans = 0",
"+for A in range(1, maxL + 1):",
"+ if nums[A] == 0:",
"+ continue",
"+ for B in range(A + 1, maxL + 1):",
"+ if nums[B] == 0:",
"+ continue",
"+ ans += nums[A] * nums[B] * (accNums[A + B - 1] - accNums[B])",
"+for A in range(1, maxL + 1):",
"+ if nums[A] < 2:",
"+ continue",
"+ ans += nums[A] * (nums[A] - 1) // 2 * (accNums[2 * A - 1] - nums[A])",
"+for A in range(1, maxL + 1):",
"+ if nums[A] < 3:",
"+ continue",
"+ ans += nums[A] * (nums[A] - 1) * (nums[A] - 2) // 6",
"+print(ans)"
] | false | 0.054687 | 0.10741 | 0.509145 | [
"s444043630",
"s506738213"
] |
u672220554 | p02949 | python | s015737837 | s350478722 | 1,262 | 1,155 | 65,240 | 61,532 | Accepted | Accepted | 8.48 | import sys
sys.setrecursionlimit(10**7)
n,m,p=list(map(int,input().split()))
g=[[] for _ in range(n)]
g2=[[] for _ in range(n)]
g3=[[] for _ in range(n)]
for _ in range(m):
a,b,l=list(map(int,input().split()))
g[a-1].append([b-1,p-l])
g2[a-1].append(b-1)
g3[b-1].append(a-1)
f1=[False for _ in range(n)]
def dfs1(s):
global f1
global g2
f1[s] = True
for sg in g2[s]:
if not f1[sg]:
dfs1(sg)
f2=[False for _ in range(n)]
def dfs2(s):
global f2
global g3
f2[s] = True
for sg in g3[s]:
if not f2[sg]:
dfs2(sg)
dfs1(0)
dfs2(n-1)
f3 = []
for i in range(n):
f3.append(f1[i] and f2[i])
def bellman_ford(g,n):
INF = 10**10
res = [INF for _ in range(n)]
res[0] = 0
for _ in range(n-1):
for i in range(n):
if res[i] != INF:
for sa,sb in g[i]:
res[sa] = min(res[sa],res[i]+sb)
ret = res[-1]
for i in range(n):
if res[i] != INF:
for sa,sb in g[i]:
if res[sa]>res[i]+sb:
if f3[sa]:
return False
return ret
res = bellman_ford(g,n)
if type(res) == bool:
print((-1))
elif res > 0:
print((0))
else:
print((res * -1)) | import sys
sys.setrecursionlimit(10**7)
input = sys.stdin.readline
n,m,p=list(map(int,input().split()))
g=[[] for _ in range(n)]
g2=[[] for _ in range(n)]
g3=[[] for _ in range(n)]
for _ in range(m):
a,b,l=list(map(int,input().split()))
g[a-1].append([b-1,p-l])
g2[a-1].append(b-1)
g3[b-1].append(a-1)
f1=[False for _ in range(n)]
def dfs1(s):
global f1
global g2
f1[s] = True
for sg in g2[s]:
if not f1[sg]:
dfs1(sg)
f2=[False for _ in range(n)]
def dfs2(s):
global f2
global g3
f2[s] = True
for sg in g3[s]:
if not f2[sg]:
dfs2(sg)
dfs1(0)
dfs2(n-1)
f3 = []
for i in range(n):
f3.append(f1[i] and f2[i])
def bellman_ford(g,n):
INF = 10**10
res = [INF for _ in range(n)]
res[0] = 0
for _ in range(n-1):
for i in range(n):
if res[i] != INF:
for sa,sb in g[i]:
res[sa] = min(res[sa],res[i]+sb)
ret = res[-1]
for i in range(n):
if res[i] != INF:
for sa,sb in g[i]:
if res[sa]>res[i]+sb:
if f3[sa]:
return False
return ret
res = bellman_ford(g,n)
if type(res) == bool:
print((-1))
elif res > 0:
print((0))
else:
print((res * -1)) | 61 | 61 | 1,314 | 1,340 | import sys
sys.setrecursionlimit(10**7)
n, m, p = list(map(int, input().split()))
g = [[] for _ in range(n)]
g2 = [[] for _ in range(n)]
g3 = [[] for _ in range(n)]
for _ in range(m):
a, b, l = list(map(int, input().split()))
g[a - 1].append([b - 1, p - l])
g2[a - 1].append(b - 1)
g3[b - 1].append(a - 1)
f1 = [False for _ in range(n)]
def dfs1(s):
global f1
global g2
f1[s] = True
for sg in g2[s]:
if not f1[sg]:
dfs1(sg)
f2 = [False for _ in range(n)]
def dfs2(s):
global f2
global g3
f2[s] = True
for sg in g3[s]:
if not f2[sg]:
dfs2(sg)
dfs1(0)
dfs2(n - 1)
f3 = []
for i in range(n):
f3.append(f1[i] and f2[i])
def bellman_ford(g, n):
INF = 10**10
res = [INF for _ in range(n)]
res[0] = 0
for _ in range(n - 1):
for i in range(n):
if res[i] != INF:
for sa, sb in g[i]:
res[sa] = min(res[sa], res[i] + sb)
ret = res[-1]
for i in range(n):
if res[i] != INF:
for sa, sb in g[i]:
if res[sa] > res[i] + sb:
if f3[sa]:
return False
return ret
res = bellman_ford(g, n)
if type(res) == bool:
print((-1))
elif res > 0:
print((0))
else:
print((res * -1))
| import sys
sys.setrecursionlimit(10**7)
input = sys.stdin.readline
n, m, p = list(map(int, input().split()))
g = [[] for _ in range(n)]
g2 = [[] for _ in range(n)]
g3 = [[] for _ in range(n)]
for _ in range(m):
a, b, l = list(map(int, input().split()))
g[a - 1].append([b - 1, p - l])
g2[a - 1].append(b - 1)
g3[b - 1].append(a - 1)
f1 = [False for _ in range(n)]
def dfs1(s):
global f1
global g2
f1[s] = True
for sg in g2[s]:
if not f1[sg]:
dfs1(sg)
f2 = [False for _ in range(n)]
def dfs2(s):
global f2
global g3
f2[s] = True
for sg in g3[s]:
if not f2[sg]:
dfs2(sg)
dfs1(0)
dfs2(n - 1)
f3 = []
for i in range(n):
f3.append(f1[i] and f2[i])
def bellman_ford(g, n):
INF = 10**10
res = [INF for _ in range(n)]
res[0] = 0
for _ in range(n - 1):
for i in range(n):
if res[i] != INF:
for sa, sb in g[i]:
res[sa] = min(res[sa], res[i] + sb)
ret = res[-1]
for i in range(n):
if res[i] != INF:
for sa, sb in g[i]:
if res[sa] > res[i] + sb:
if f3[sa]:
return False
return ret
res = bellman_ford(g, n)
if type(res) == bool:
print((-1))
elif res > 0:
print((0))
else:
print((res * -1))
| false | 0 | [
"+input = sys.stdin.readline"
] | false | 0.1473 | 0.071509 | 2.059886 | [
"s015737837",
"s350478722"
] |
u352394527 | p00486 | python | s021784807 | s127603551 | 1,110 | 700 | 29,212 | 25,184 | Accepted | Accepted | 36.94 | from bisect import bisect_left as bl
from bisect import bisect_right as br
INF = 10 ** 20
w, h = list(map(int, input().split()))
n = int(eval(input()))
xlst = []
ylst = []
for i in range(n):
x, y = list(map(int,input().split()))
xlst.append(x)
ylst.append(y)
sorted_xlst = sorted(xlst)
sorted_xlst_d = sorted(xlst * 2)
sorted_ylst = sorted(ylst)
sorted_ylst_d = sorted(ylst * 2)
accx = accy = 0
cum_sum_xlst = []
cum_sum_ylst = []
for i in range(n):
accx += sorted_xlst[i]
accy += sorted_ylst[i]
cum_sum_xlst.append(accx)
cum_sum_ylst.append(accy)
clx = sorted_xlst_d[n - 1]
crx = sorted_xlst_d[n]
cly = sorted_ylst_d[n - 1]
cry = sorted_ylst_d[n]
num = n * 2 - 1
ans = INF
ansx = 10 ** 10
ansy = 10 ** 10
for i in range(n):
xi = xlst[i]
yi = ylst[i]
if xi <= clx:
cx = crx
else:
cx = clx
if yi <= cly:
cy = cry
else:
cy = cly
px = bl(sorted_xlst, cx)
py = bl(sorted_ylst, cy)
if px:
xlen = (cx * px - cum_sum_xlst[px - 1]) * 2 + (accx - cum_sum_xlst[px - 1] - cx * (n - px)) * 2 - abs(xi - cx)
else:
xlen = (accx - cx * n) * 2 - abs(xi - cx)
if py:
ylen = (cy * py - cum_sum_ylst[py - 1]) * 2 + (accy - cum_sum_ylst[py - 1] - cy * (n - py)) * 2 - abs(yi - cy)
else:
ylen = (accy - cy * n) * 2 - abs(yi - cy)
tlen = xlen + ylen
if ans > tlen:
ans = tlen
ansx = cx
ansy = cy
elif ans == tlen:
if ansx > cx:
ansx = cx
ansy = cy
elif ansx == cx:
if ansy > cy:
ansy = cy
print(ans)
print((ansx, ansy))
| from bisect import bisect_left as bl
INF = 10 ** 20
def main():
w, h = list(map(int, input().split()))
n = int(eval(input()))
xlst = []
ylst = []
for i in range(n):
x, y = list(map(int,input().split()))
xlst.append(x)
ylst.append(y)
sorted_xlst = sorted(xlst)
sorted_ylst = sorted(ylst)
accx = accy = 0
cum_sum_xlst = []
cum_sum_ylst = []
for i in range(n):
accx += sorted_xlst[i]
accy += sorted_ylst[i]
cum_sum_xlst.append(accx)
cum_sum_ylst.append(accy)
if n % 2:
clx = crx = sorted_xlst[n // 2]
cly = cry = sorted_ylst[n // 2]
else:
clx = sorted_xlst[n // 2 - 1]
crx = sorted_xlst[n // 2]
cly = sorted_ylst[n // 2 - 1]
cry = sorted_ylst[n // 2]
ans = ansx = ansy = INF
for i in range(n):
xi = xlst[i]
yi = ylst[i]
if xi <= clx:
cx = crx
else:
cx = clx
if yi <= cly:
cy = cry
else:
cy = cly
px = bl(sorted_xlst, cx)
py = bl(sorted_ylst, cy)
if px:
csx = cum_sum_xlst[px - 1]
xlen = (cx * px - csx) * 2 + (accx - csx - cx * (n - px)) * 2 - abs(xi - cx)
else:
xlen = (accx - cx * n) * 2 - abs(xi - cx)
if py:
csy = cum_sum_ylst[py - 1]
ylen = (cy * py - csy) * 2 + (accy - csy - cy * (n - py)) * 2 - abs(yi - cy)
else:
ylen = (accy - cy * n) * 2 - abs(yi - cy)
tlen = xlen + ylen
if ans > tlen:
ans = tlen
ansx = cx
ansy = cy
elif ans == tlen:
if ansx > cx:
ansx = cx
ansy = cy
elif ansx == cx:
if ansy > cy:
ansy = cy
print(ans)
print((ansx, ansy))
main()
| 75 | 86 | 1,587 | 1,740 | from bisect import bisect_left as bl
from bisect import bisect_right as br
INF = 10**20
w, h = list(map(int, input().split()))
n = int(eval(input()))
xlst = []
ylst = []
for i in range(n):
x, y = list(map(int, input().split()))
xlst.append(x)
ylst.append(y)
sorted_xlst = sorted(xlst)
sorted_xlst_d = sorted(xlst * 2)
sorted_ylst = sorted(ylst)
sorted_ylst_d = sorted(ylst * 2)
accx = accy = 0
cum_sum_xlst = []
cum_sum_ylst = []
for i in range(n):
accx += sorted_xlst[i]
accy += sorted_ylst[i]
cum_sum_xlst.append(accx)
cum_sum_ylst.append(accy)
clx = sorted_xlst_d[n - 1]
crx = sorted_xlst_d[n]
cly = sorted_ylst_d[n - 1]
cry = sorted_ylst_d[n]
num = n * 2 - 1
ans = INF
ansx = 10**10
ansy = 10**10
for i in range(n):
xi = xlst[i]
yi = ylst[i]
if xi <= clx:
cx = crx
else:
cx = clx
if yi <= cly:
cy = cry
else:
cy = cly
px = bl(sorted_xlst, cx)
py = bl(sorted_ylst, cy)
if px:
xlen = (
(cx * px - cum_sum_xlst[px - 1]) * 2
+ (accx - cum_sum_xlst[px - 1] - cx * (n - px)) * 2
- abs(xi - cx)
)
else:
xlen = (accx - cx * n) * 2 - abs(xi - cx)
if py:
ylen = (
(cy * py - cum_sum_ylst[py - 1]) * 2
+ (accy - cum_sum_ylst[py - 1] - cy * (n - py)) * 2
- abs(yi - cy)
)
else:
ylen = (accy - cy * n) * 2 - abs(yi - cy)
tlen = xlen + ylen
if ans > tlen:
ans = tlen
ansx = cx
ansy = cy
elif ans == tlen:
if ansx > cx:
ansx = cx
ansy = cy
elif ansx == cx:
if ansy > cy:
ansy = cy
print(ans)
print((ansx, ansy))
| from bisect import bisect_left as bl
INF = 10**20
def main():
w, h = list(map(int, input().split()))
n = int(eval(input()))
xlst = []
ylst = []
for i in range(n):
x, y = list(map(int, input().split()))
xlst.append(x)
ylst.append(y)
sorted_xlst = sorted(xlst)
sorted_ylst = sorted(ylst)
accx = accy = 0
cum_sum_xlst = []
cum_sum_ylst = []
for i in range(n):
accx += sorted_xlst[i]
accy += sorted_ylst[i]
cum_sum_xlst.append(accx)
cum_sum_ylst.append(accy)
if n % 2:
clx = crx = sorted_xlst[n // 2]
cly = cry = sorted_ylst[n // 2]
else:
clx = sorted_xlst[n // 2 - 1]
crx = sorted_xlst[n // 2]
cly = sorted_ylst[n // 2 - 1]
cry = sorted_ylst[n // 2]
ans = ansx = ansy = INF
for i in range(n):
xi = xlst[i]
yi = ylst[i]
if xi <= clx:
cx = crx
else:
cx = clx
if yi <= cly:
cy = cry
else:
cy = cly
px = bl(sorted_xlst, cx)
py = bl(sorted_ylst, cy)
if px:
csx = cum_sum_xlst[px - 1]
xlen = (cx * px - csx) * 2 + (accx - csx - cx * (n - px)) * 2 - abs(xi - cx)
else:
xlen = (accx - cx * n) * 2 - abs(xi - cx)
if py:
csy = cum_sum_ylst[py - 1]
ylen = (cy * py - csy) * 2 + (accy - csy - cy * (n - py)) * 2 - abs(yi - cy)
else:
ylen = (accy - cy * n) * 2 - abs(yi - cy)
tlen = xlen + ylen
if ans > tlen:
ans = tlen
ansx = cx
ansy = cy
elif ans == tlen:
if ansx > cx:
ansx = cx
ansy = cy
elif ansx == cx:
if ansy > cy:
ansy = cy
print(ans)
print((ansx, ansy))
main()
| false | 12.790698 | [
"-from bisect import bisect_right as br",
"-w, h = list(map(int, input().split()))",
"-n = int(eval(input()))",
"-xlst = []",
"-ylst = []",
"-for i in range(n):",
"- x, y = list(map(int, input().split()))",
"- xlst.append(x)",
"- ylst.append(y)",
"-sorted_xlst = sorted(xlst)",
"-sorted_xlst_d = sorted(xlst * 2)",
"-sorted_ylst = sorted(ylst)",
"-sorted_ylst_d = sorted(ylst * 2)",
"-accx = accy = 0",
"-cum_sum_xlst = []",
"-cum_sum_ylst = []",
"-for i in range(n):",
"- accx += sorted_xlst[i]",
"- accy += sorted_ylst[i]",
"- cum_sum_xlst.append(accx)",
"- cum_sum_ylst.append(accy)",
"-clx = sorted_xlst_d[n - 1]",
"-crx = sorted_xlst_d[n]",
"-cly = sorted_ylst_d[n - 1]",
"-cry = sorted_ylst_d[n]",
"-num = n * 2 - 1",
"-ans = INF",
"-ansx = 10**10",
"-ansy = 10**10",
"-for i in range(n):",
"- xi = xlst[i]",
"- yi = ylst[i]",
"- if xi <= clx:",
"- cx = crx",
"+",
"+",
"+def main():",
"+ w, h = list(map(int, input().split()))",
"+ n = int(eval(input()))",
"+ xlst = []",
"+ ylst = []",
"+ for i in range(n):",
"+ x, y = list(map(int, input().split()))",
"+ xlst.append(x)",
"+ ylst.append(y)",
"+ sorted_xlst = sorted(xlst)",
"+ sorted_ylst = sorted(ylst)",
"+ accx = accy = 0",
"+ cum_sum_xlst = []",
"+ cum_sum_ylst = []",
"+ for i in range(n):",
"+ accx += sorted_xlst[i]",
"+ accy += sorted_ylst[i]",
"+ cum_sum_xlst.append(accx)",
"+ cum_sum_ylst.append(accy)",
"+ if n % 2:",
"+ clx = crx = sorted_xlst[n // 2]",
"+ cly = cry = sorted_ylst[n // 2]",
"- cx = clx",
"- if yi <= cly:",
"- cy = cry",
"- else:",
"- cy = cly",
"- px = bl(sorted_xlst, cx)",
"- py = bl(sorted_ylst, cy)",
"- if px:",
"- xlen = (",
"- (cx * px - cum_sum_xlst[px - 1]) * 2",
"- + (accx - cum_sum_xlst[px - 1] - cx * (n - px)) * 2",
"- - abs(xi - cx)",
"- )",
"- else:",
"- xlen = (accx - cx * n) * 2 - abs(xi - cx)",
"- if py:",
"- ylen = (",
"- (cy * py - cum_sum_ylst[py - 1]) * 2",
"- + (accy - cum_sum_ylst[py - 1] - cy * (n - py)) * 2",
"- - abs(yi - cy)",
"- )",
"- else:",
"- ylen = (accy - cy * n) * 2 - abs(yi - cy)",
"- tlen = xlen + ylen",
"- if ans > tlen:",
"- ans = tlen",
"- ansx = cx",
"- ansy = cy",
"- elif ans == tlen:",
"- if ansx > cx:",
"+ clx = sorted_xlst[n // 2 - 1]",
"+ crx = sorted_xlst[n // 2]",
"+ cly = sorted_ylst[n // 2 - 1]",
"+ cry = sorted_ylst[n // 2]",
"+ ans = ansx = ansy = INF",
"+ for i in range(n):",
"+ xi = xlst[i]",
"+ yi = ylst[i]",
"+ if xi <= clx:",
"+ cx = crx",
"+ else:",
"+ cx = clx",
"+ if yi <= cly:",
"+ cy = cry",
"+ else:",
"+ cy = cly",
"+ px = bl(sorted_xlst, cx)",
"+ py = bl(sorted_ylst, cy)",
"+ if px:",
"+ csx = cum_sum_xlst[px - 1]",
"+ xlen = (cx * px - csx) * 2 + (accx - csx - cx * (n - px)) * 2 - abs(xi - cx)",
"+ else:",
"+ xlen = (accx - cx * n) * 2 - abs(xi - cx)",
"+ if py:",
"+ csy = cum_sum_ylst[py - 1]",
"+ ylen = (cy * py - csy) * 2 + (accy - csy - cy * (n - py)) * 2 - abs(yi - cy)",
"+ else:",
"+ ylen = (accy - cy * n) * 2 - abs(yi - cy)",
"+ tlen = xlen + ylen",
"+ if ans > tlen:",
"+ ans = tlen",
"- elif ansx == cx:",
"- if ansy > cy:",
"+ elif ans == tlen:",
"+ if ansx > cx:",
"+ ansx = cx",
"-print(ans)",
"-print((ansx, ansy))",
"+ elif ansx == cx:",
"+ if ansy > cy:",
"+ ansy = cy",
"+ print(ans)",
"+ print((ansx, ansy))",
"+",
"+",
"+main()"
] | false | 0.10981 | 0.118242 | 0.928687 | [
"s021784807",
"s127603551"
] |
u799164835 | p03107 | python | s233954743 | s819512564 | 39 | 19 | 3,188 | 3,188 | Accepted | Accepted | 51.28 | # デバッグ用
GBN_DEBUG = False
GBN_DEBUG = True
def dprn(s, i):
if GBN_DEBUG: print(", " + s + " = " + str(i), end = "")
def dprns(s):
if GBN_DEBUG: print(", " + s, end = "")
def dprni(i):
if GBN_DEBUG: print(i, end=" ")
def endl():
if GBN_DEBUG: print('')
def puts(s): print(s)
#本体ここから
S = input()
#N = int(input())
#S, T = input().split()
#N, M = map(int, input().split())
#W = [input() for _ in range(N)]
#A = A = list(map(int, input().split()))
slen = len(S)
zero = 0
one = 0
for i in range(slen):
if S[i] == '0':
zero += 1
else:
one += 1
if (zero > one):
print(one * 2)
else:
print(zero * 2)
| # デバッグ用
GBN_DEBUG = False
GBN_DEBUG = True
def dprn(s, i):
if GBN_DEBUG: print(", " + s + " = " + str(i), end = "")
def dprns(s):
if GBN_DEBUG: print(", " + s, end = "")
def dprni(i):
if GBN_DEBUG: print(i, end=" ")
def endl():
if GBN_DEBUG: print('')
def puts(s): print(s)
#本体ここから
S = input()
#N = int(input())
#S, T = input().split()
#N, M = map(int, input().split())
#W = [input() for _ in range(N)]
#A = list(map(int, input().split()))
zero = S.count('0')
one = S.count('1')
ans = min(zero, one) * 2
print(ans)
| 34 | 27 | 677 | 562 | # デバッグ用
GBN_DEBUG = False
GBN_DEBUG = True
def dprn(s, i):
if GBN_DEBUG:
print(", " + s + " = " + str(i), end="")
def dprns(s):
if GBN_DEBUG:
print(", " + s, end="")
def dprni(i):
if GBN_DEBUG:
print(i, end=" ")
def endl():
if GBN_DEBUG:
print("")
def puts(s):
print(s)
# 本体ここから
S = input()
# N = int(input())
# S, T = input().split()
# N, M = map(int, input().split())
# W = [input() for _ in range(N)]
# A = A = list(map(int, input().split()))
slen = len(S)
zero = 0
one = 0
for i in range(slen):
if S[i] == "0":
zero += 1
else:
one += 1
if zero > one:
print(one * 2)
else:
print(zero * 2)
| # デバッグ用
GBN_DEBUG = False
GBN_DEBUG = True
def dprn(s, i):
if GBN_DEBUG:
print(", " + s + " = " + str(i), end="")
def dprns(s):
if GBN_DEBUG:
print(", " + s, end="")
def dprni(i):
if GBN_DEBUG:
print(i, end=" ")
def endl():
if GBN_DEBUG:
print("")
def puts(s):
print(s)
# 本体ここから
S = input()
# N = int(input())
# S, T = input().split()
# N, M = map(int, input().split())
# W = [input() for _ in range(N)]
# A = list(map(int, input().split()))
zero = S.count("0")
one = S.count("1")
ans = min(zero, one) * 2
print(ans)
| false | 20.588235 | [
"-# A = A = list(map(int, input().split()))",
"-slen = len(S)",
"-zero = 0",
"-one = 0",
"-for i in range(slen):",
"- if S[i] == \"0\":",
"- zero += 1",
"- else:",
"- one += 1",
"-if zero > one:",
"- print(one * 2)",
"-else:",
"- print(zero * 2)",
"+# A = list(map(int, input().split()))",
"+zero = S.count(\"0\")",
"+one = S.count(\"1\")",
"+ans = min(zero, one) * 2",
"+print(ans)"
] | false | 0.035608 | 0.031195 | 1.141485 | [
"s233954743",
"s819512564"
] |
u072717685 | p02622 | python | s298628126 | s644375761 | 85 | 72 | 67,968 | 74,028 | Accepted | Accepted | 15.29 | def main():
s = eval(input())
t = eval(input())
r = 0
for i, se in enumerate(s):
if se != t[i]:
r += 1
print(r)
if __name__ == '__main__':
main()
| import sys
read = sys.stdin.read
readlines = sys.stdin.readlines
def main():
s = eval(input())
t = eval(input())
r = 0
for se, te in zip(s, t):
r += se != te
print(r)
if __name__ == '__main__':
main() | 11 | 14 | 189 | 235 | def main():
s = eval(input())
t = eval(input())
r = 0
for i, se in enumerate(s):
if se != t[i]:
r += 1
print(r)
if __name__ == "__main__":
main()
| import sys
read = sys.stdin.read
readlines = sys.stdin.readlines
def main():
s = eval(input())
t = eval(input())
r = 0
for se, te in zip(s, t):
r += se != te
print(r)
if __name__ == "__main__":
main()
| false | 21.428571 | [
"+import sys",
"+",
"+read = sys.stdin.read",
"+readlines = sys.stdin.readlines",
"+",
"+",
"- for i, se in enumerate(s):",
"- if se != t[i]:",
"- r += 1",
"+ for se, te in zip(s, t):",
"+ r += se != te"
] | false | 0.044986 | 0.044819 | 1.003729 | [
"s298628126",
"s644375761"
] |
u736443076 | p02630 | python | s817274096 | s247179829 | 450 | 402 | 40,380 | 40,376 | Accepted | Accepted | 10.67 | from collections import Counter
n = int(eval(input()))
a = list(map(int, input().split()))
q = int(eval(input()))
bc = [list(map(int, input().split())) for _ in range(q)]
suma = sum(a)
counter = Counter(a)
for i in range(q):
suma -= bc[i][0] * counter[bc[i][0]]
suma += bc[i][1] * counter[bc[i][0]]
counter[bc[i][1]] += counter[bc[i][0]]
counter[bc[i][0]] = 0
print(suma)
| from collections import Counter
n = int(eval(input()))
a = list(map(int, input().split()))
q = int(eval(input()))
bc = [list(map(int, input().split())) for _ in range(q)]
suma = sum(a)
counter = Counter(a)
for b, c in bc:
suma -= b * counter[b]
suma += c * counter[b]
counter[c] += counter[b]
counter[b] = 0
print(suma)
| 14 | 14 | 394 | 342 | from collections import Counter
n = int(eval(input()))
a = list(map(int, input().split()))
q = int(eval(input()))
bc = [list(map(int, input().split())) for _ in range(q)]
suma = sum(a)
counter = Counter(a)
for i in range(q):
suma -= bc[i][0] * counter[bc[i][0]]
suma += bc[i][1] * counter[bc[i][0]]
counter[bc[i][1]] += counter[bc[i][0]]
counter[bc[i][0]] = 0
print(suma)
| from collections import Counter
n = int(eval(input()))
a = list(map(int, input().split()))
q = int(eval(input()))
bc = [list(map(int, input().split())) for _ in range(q)]
suma = sum(a)
counter = Counter(a)
for b, c in bc:
suma -= b * counter[b]
suma += c * counter[b]
counter[c] += counter[b]
counter[b] = 0
print(suma)
| false | 0 | [
"-for i in range(q):",
"- suma -= bc[i][0] * counter[bc[i][0]]",
"- suma += bc[i][1] * counter[bc[i][0]]",
"- counter[bc[i][1]] += counter[bc[i][0]]",
"- counter[bc[i][0]] = 0",
"+for b, c in bc:",
"+ suma -= b * counter[b]",
"+ suma += c * counter[b]",
"+ counter[c] += counter[b]",
"+ counter[b] = 0"
] | false | 0.047813 | 0.045158 | 1.058803 | [
"s817274096",
"s247179829"
] |
u152509702 | p03545 | python | s673683616 | s227691580 | 175 | 161 | 38,384 | 38,384 | Accepted | Accepted | 8 | def dfs(i: int, t: int, op: str):
if i == 3:
if t == 7:
return op
else:
return ""
return dfs(i + 1, t + s[i + 1], op + "+") + dfs(i + 1, t - s[i + 1], op + "-")
s = list(map(int, list(eval(input()))))
op = ""
op = dfs(0, s[0], op)
ans = str(s[0]) + op[0] + str(s[1]) + op[1] + str(s[2]) + op[2] + str(s[3]) + "=7"
print(ans)
| def dfs(array: list, index: int, calc: str, result: int):
if index == len(array):
if result == 7:
print(("{}=7".format(calc)))
exit(0)
if index == 0:
dfs(array, index + 1, array[index], int(array[index]))
elif index < len(array):
dfs(array, index + 1, calc + "-" + array[index], result - int(array[index]))
dfs(array, index + 1, calc + "+" + array[index], result + int(array[index]))
array = list(eval(input()))
dfs(array, 0, "", 0)
| 15 | 14 | 360 | 508 | def dfs(i: int, t: int, op: str):
if i == 3:
if t == 7:
return op
else:
return ""
return dfs(i + 1, t + s[i + 1], op + "+") + dfs(i + 1, t - s[i + 1], op + "-")
s = list(map(int, list(eval(input()))))
op = ""
op = dfs(0, s[0], op)
ans = str(s[0]) + op[0] + str(s[1]) + op[1] + str(s[2]) + op[2] + str(s[3]) + "=7"
print(ans)
| def dfs(array: list, index: int, calc: str, result: int):
if index == len(array):
if result == 7:
print(("{}=7".format(calc)))
exit(0)
if index == 0:
dfs(array, index + 1, array[index], int(array[index]))
elif index < len(array):
dfs(array, index + 1, calc + "-" + array[index], result - int(array[index]))
dfs(array, index + 1, calc + "+" + array[index], result + int(array[index]))
array = list(eval(input()))
dfs(array, 0, "", 0)
| false | 6.666667 | [
"-def dfs(i: int, t: int, op: str):",
"- if i == 3:",
"- if t == 7:",
"- return op",
"- else:",
"- return \"\"",
"- return dfs(i + 1, t + s[i + 1], op + \"+\") + dfs(i + 1, t - s[i + 1], op + \"-\")",
"+def dfs(array: list, index: int, calc: str, result: int):",
"+ if index == len(array):",
"+ if result == 7:",
"+ print((\"{}=7\".format(calc)))",
"+ exit(0)",
"+ if index == 0:",
"+ dfs(array, index + 1, array[index], int(array[index]))",
"+ elif index < len(array):",
"+ dfs(array, index + 1, calc + \"-\" + array[index], result - int(array[index]))",
"+ dfs(array, index + 1, calc + \"+\" + array[index], result + int(array[index]))",
"-s = list(map(int, list(eval(input()))))",
"-op = \"\"",
"-op = dfs(0, s[0], op)",
"-ans = str(s[0]) + op[0] + str(s[1]) + op[1] + str(s[2]) + op[2] + str(s[3]) + \"=7\"",
"-print(ans)",
"+array = list(eval(input()))",
"+dfs(array, 0, \"\", 0)"
] | false | 0.046357 | 0.046126 | 1.00501 | [
"s673683616",
"s227691580"
] |
u392319141 | p02881 | python | s862595349 | s368752445 | 169 | 147 | 3,592 | 2,940 | Accepted | Accepted | 13.02 | import sys
from heapq import heappop, heappush
from operator import itemgetter
from collections import deque, defaultdict, Counter
from bisect import bisect_left, bisect_right
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
MOD = 10**9 + 7
INF = float('inf')
# 約数の全列挙
def 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(reverse=True) # ソート
return divisors
def sol():
N = int(eval(input()))
divs = divisors(N)
ans = INF
for d in divs:
M = N // d
ans = min(ans, M - 1 + d - 1)
print(ans)
sol() | N = int(eval(input()))
ans = N - 1
for i in range(1, int(N**0.5) + 10):
if N % i == 0:
j = N // i
ans = min(ans, i + j - 2)
print(ans) | 33 | 9 | 734 | 158 | import sys
from heapq import heappop, heappush
from operator import itemgetter
from collections import deque, defaultdict, Counter
from bisect import bisect_left, bisect_right
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
MOD = 10**9 + 7
INF = float("inf")
# 約数の全列挙
def 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(reverse=True) # ソート
return divisors
def sol():
N = int(eval(input()))
divs = divisors(N)
ans = INF
for d in divs:
M = N // d
ans = min(ans, M - 1 + d - 1)
print(ans)
sol()
| N = int(eval(input()))
ans = N - 1
for i in range(1, int(N**0.5) + 10):
if N % i == 0:
j = N // i
ans = min(ans, i + j - 2)
print(ans)
| false | 72.727273 | [
"-import sys",
"-from heapq import heappop, heappush",
"-from operator import itemgetter",
"-from collections import deque, defaultdict, Counter",
"-from bisect import bisect_left, bisect_right",
"-",
"-input = sys.stdin.readline",
"-sys.setrecursionlimit(10**7)",
"-MOD = 10**9 + 7",
"-INF = float(\"inf\")",
"-# 約数の全列挙",
"-def 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(reverse=True) # ソート",
"- return divisors",
"-",
"-",
"-def sol():",
"- N = int(eval(input()))",
"- divs = divisors(N)",
"- ans = INF",
"- for d in divs:",
"- M = N // d",
"- ans = min(ans, M - 1 + d - 1)",
"- print(ans)",
"-",
"-",
"-sol()",
"+N = int(eval(input()))",
"+ans = N - 1",
"+for i in range(1, int(N**0.5) + 10):",
"+ if N % i == 0:",
"+ j = N // i",
"+ ans = min(ans, i + j - 2)",
"+print(ans)"
] | false | 0.048495 | 0.049761 | 0.974549 | [
"s862595349",
"s368752445"
] |
u777283665 | p03830 | python | s183142824 | s441705137 | 181 | 36 | 38,640 | 3,064 | Accepted | Accepted | 80.11 | import math
mod = 10 ** 9 + 7
def f(num):
i = 2
d = dict()
while i * i <= num:
if num % i == 0:
num //= i
d[i] = d.get(i, 0) + 1
else:
i += 1
d[num] = 1
return d
n = int(eval(input()))
if n == 1:
print((1))
exit()
ans = 1
for i in list(f(math.factorial(n)).values()):
ans *= i+1
print((ans%mod)) | import math
mod = 10 ** 9 + 7
def f(num):
i = 2
d = dict()
while i ** 2 <= num:
if num % i == 0:
num //= i
d[i] = d.get(i, 0) + 1
else:
i += 1
d[num] = 1
return d
n = int(eval(input()))
if n == 1:
print((1))
exit()
ans = 1
for i in list(f(math.factorial(n)).values()):
ans *= i+1
print((ans%mod)) | 29 | 26 | 399 | 394 | import math
mod = 10**9 + 7
def f(num):
i = 2
d = dict()
while i * i <= num:
if num % i == 0:
num //= i
d[i] = d.get(i, 0) + 1
else:
i += 1
d[num] = 1
return d
n = int(eval(input()))
if n == 1:
print((1))
exit()
ans = 1
for i in list(f(math.factorial(n)).values()):
ans *= i + 1
print((ans % mod))
| import math
mod = 10**9 + 7
def f(num):
i = 2
d = dict()
while i**2 <= num:
if num % i == 0:
num //= i
d[i] = d.get(i, 0) + 1
else:
i += 1
d[num] = 1
return d
n = int(eval(input()))
if n == 1:
print((1))
exit()
ans = 1
for i in list(f(math.factorial(n)).values()):
ans *= i + 1
print((ans % mod))
| false | 10.344828 | [
"- while i * i <= num:",
"+ while i**2 <= num:"
] | false | 0.039105 | 0.04047 | 0.966261 | [
"s183142824",
"s441705137"
] |
u997521090 | p03128 | python | s959861635 | s624128743 | 179 | 161 | 15,268 | 15,284 | Accepted | Accepted | 10.06 | n,m,*a=list(map(int,open(0).read().split()))
d=[0]+[-1]*n*9
for i in range(n):
for j,k in enumerate((0,2,5,5,4,5,6,3,7,6)):
if d[i]>=0and j in a:d[i+k]=max(d[i+k],d[i]*10+j)
print((d[n])) | n,m,*a=list(map(int,open(0).read().split()))
c=[0,2,5,5,4,5,6,3,7,6]
d=[0]+[-1]*n*9
for i in range(n):
for j in a:
if d[i]>=0:d[i+c[j]]=max(d[i+c[j]],d[i]*10+j)
print((d[n])) | 6 | 7 | 187 | 175 | n, m, *a = list(map(int, open(0).read().split()))
d = [0] + [-1] * n * 9
for i in range(n):
for j, k in enumerate((0, 2, 5, 5, 4, 5, 6, 3, 7, 6)):
if d[i] >= 0 and j in a:
d[i + k] = max(d[i + k], d[i] * 10 + j)
print((d[n]))
| n, m, *a = list(map(int, open(0).read().split()))
c = [0, 2, 5, 5, 4, 5, 6, 3, 7, 6]
d = [0] + [-1] * n * 9
for i in range(n):
for j in a:
if d[i] >= 0:
d[i + c[j]] = max(d[i + c[j]], d[i] * 10 + j)
print((d[n]))
| false | 14.285714 | [
"+c = [0, 2, 5, 5, 4, 5, 6, 3, 7, 6]",
"- for j, k in enumerate((0, 2, 5, 5, 4, 5, 6, 3, 7, 6)):",
"- if d[i] >= 0 and j in a:",
"- d[i + k] = max(d[i + k], d[i] * 10 + j)",
"+ for j in a:",
"+ if d[i] >= 0:",
"+ d[i + c[j]] = max(d[i + c[j]], d[i] * 10 + j)"
] | false | 0.037093 | 0.080739 | 0.459417 | [
"s959861635",
"s624128743"
] |
u419877586 | p02912 | python | s206350864 | s534537419 | 404 | 173 | 73,068 | 14,180 | Accepted | Accepted | 57.18 | import heapq
N, M=list(map(int, input().split()))
A=list(map(int, input().split()))
A=list([-x for x in A])
heapq.heapify(A)
for i in range(M):
heapq.heappush(A, (heapq.heappop(A)+1)//2)
print((-sum(A))) | import heapq
N, M=list(map(int, input().split()))
A=list([x*(-1) for x in list(map(int, input().split()))])
heapq.heapify(A)
for i in range(M):
a=heapq.heappop(A)
a=((a*(-1))//2)*(-1)
heapq.heappush(A, a)
print((-sum(A))) | 8 | 10 | 209 | 233 | import heapq
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
A = list([-x for x in A])
heapq.heapify(A)
for i in range(M):
heapq.heappush(A, (heapq.heappop(A) + 1) // 2)
print((-sum(A)))
| import heapq
N, M = list(map(int, input().split()))
A = list([x * (-1) for x in list(map(int, input().split()))])
heapq.heapify(A)
for i in range(M):
a = heapq.heappop(A)
a = ((a * (-1)) // 2) * (-1)
heapq.heappush(A, a)
print((-sum(A)))
| false | 20 | [
"-A = list(map(int, input().split()))",
"-A = list([-x for x in A])",
"+A = list([x * (-1) for x in list(map(int, input().split()))])",
"- heapq.heappush(A, (heapq.heappop(A) + 1) // 2)",
"+ a = heapq.heappop(A)",
"+ a = ((a * (-1)) // 2) * (-1)",
"+ heapq.heappush(A, a)"
] | false | 0.111373 | 0.053542 | 2.080108 | [
"s206350864",
"s534537419"
] |
u678167152 | p03166 | python | s289874025 | s701412202 | 568 | 424 | 59,056 | 61,308 | Accepted | Accepted | 25.35 | import sys
sys.setrecursionlimit(100000)
N, M = list(map(int, input().split()))
edge = [[] for _ in range(N)]
for i in range(M):
a,b = list(map(int, input().split()))
edge[a-1].append(b-1)
dpv = [-1]*N
def dp(v):
if dpv[v] != -1:
return dpv[v]
if len(edge[v])==0:
dpv[v]=0
return 0
res = 0
for w in edge[v]:
res = max(dp(w),res)
res += 1
dpv[v] = res
return res
def solve():
for i in range(N):
dp(i)
ans = max(dpv)
# print(dpv)
return ans
print((solve())) | import sys
sys.setrecursionlimit(10**8)
N, M = list(map(int, input().split()))
edge = [[] for _ in range(N)]
for i in range(M):
a,b = list(map(int, input().split()))
edge[a-1].append(b-1)
def dfs(v):
if len(edge[v])==0:
return 0
ans = 0
for u in edge[v]:
if longest[u]==-1:
longest[u]=dfs(u)
ans = max(ans,longest[u]+1)
return ans
longest = [-1]*N
for i in range(N):
if longest[i]==-1:
longest[i] = dfs(i)
ans = max(longest)
print(ans) | 29 | 25 | 563 | 486 | import sys
sys.setrecursionlimit(100000)
N, M = list(map(int, input().split()))
edge = [[] for _ in range(N)]
for i in range(M):
a, b = list(map(int, input().split()))
edge[a - 1].append(b - 1)
dpv = [-1] * N
def dp(v):
if dpv[v] != -1:
return dpv[v]
if len(edge[v]) == 0:
dpv[v] = 0
return 0
res = 0
for w in edge[v]:
res = max(dp(w), res)
res += 1
dpv[v] = res
return res
def solve():
for i in range(N):
dp(i)
ans = max(dpv)
# print(dpv)
return ans
print((solve()))
| import sys
sys.setrecursionlimit(10**8)
N, M = list(map(int, input().split()))
edge = [[] for _ in range(N)]
for i in range(M):
a, b = list(map(int, input().split()))
edge[a - 1].append(b - 1)
def dfs(v):
if len(edge[v]) == 0:
return 0
ans = 0
for u in edge[v]:
if longest[u] == -1:
longest[u] = dfs(u)
ans = max(ans, longest[u] + 1)
return ans
longest = [-1] * N
for i in range(N):
if longest[i] == -1:
longest[i] = dfs(i)
ans = max(longest)
print(ans)
| false | 13.793103 | [
"-sys.setrecursionlimit(100000)",
"+sys.setrecursionlimit(10**8)",
"-dpv = [-1] * N",
"-def dp(v):",
"- if dpv[v] != -1:",
"- return dpv[v]",
"+def dfs(v):",
"- dpv[v] = 0",
"- res = 0",
"- for w in edge[v]:",
"- res = max(dp(w), res)",
"- res += 1",
"- dpv[v] = res",
"- return res",
"-",
"-",
"-def solve():",
"- for i in range(N):",
"- dp(i)",
"- ans = max(dpv)",
"- # print(dpv)",
"+ ans = 0",
"+ for u in edge[v]:",
"+ if longest[u] == -1:",
"+ longest[u] = dfs(u)",
"+ ans = max(ans, longest[u] + 1)",
"-print((solve()))",
"+longest = [-1] * N",
"+for i in range(N):",
"+ if longest[i] == -1:",
"+ longest[i] = dfs(i)",
"+ans = max(longest)",
"+print(ans)"
] | false | 0.108744 | 0.036777 | 2.956823 | [
"s289874025",
"s701412202"
] |
u219417113 | p03164 | python | s128409051 | s374807900 | 375 | 277 | 119,916 | 46,540 | Accepted | Accepted | 26.13 | N, W = list(map(int, input().split()))
w = []
v = []
sum_value = 0
inf = 10**9 + 1
for _ in range(N):
w_, v_ = list(map(int, input().split()))
w.append(w_)
v.append(v_)
sum_value += v_
"""
dp[n][i]: n個目までの品物から価値の総量がiよりも大きくなるように選択したときの, 重さの最小値
"""
dp = [[inf] * (sum_value+1) for _ in range(N+1)]
dp[0][0] = 0
for n in range(1, N+1):
for i in range(sum_value+1):
if i >= v[n-1]:
dp[n][i] = min(dp[n-1][i], dp[n-1][i-v[n-1]] + w[n-1])
else:
dp[n][i] = dp[n-1][i]
for i in range(sum_value+1)[::-1]:
if dp[N][i] != inf and dp[N][i] <= W:
print(i)
break
| import sys
input = sys.stdin.readline
def main():
N, W = list(map(int, input().split()))
inf = float('inf')
dp = [inf] * (10**5+1)
dp[0] = 0
for n in range(1, N+1):
w, v = list(map(int, input().split()))
for i in range(v, 10**5+1)[::-1]:
if dp[i-v] + w <= W:
dp[i] = min(dp[i], dp[i-v] + w)
for i in range(10**5+1)[::-1]:
if dp[i] < inf:
print(i)
break
if __name__ == '__main__':
main() | 29 | 19 | 649 | 497 | N, W = list(map(int, input().split()))
w = []
v = []
sum_value = 0
inf = 10**9 + 1
for _ in range(N):
w_, v_ = list(map(int, input().split()))
w.append(w_)
v.append(v_)
sum_value += v_
"""
dp[n][i]: n個目までの品物から価値の総量がiよりも大きくなるように選択したときの, 重さの最小値
"""
dp = [[inf] * (sum_value + 1) for _ in range(N + 1)]
dp[0][0] = 0
for n in range(1, N + 1):
for i in range(sum_value + 1):
if i >= v[n - 1]:
dp[n][i] = min(dp[n - 1][i], dp[n - 1][i - v[n - 1]] + w[n - 1])
else:
dp[n][i] = dp[n - 1][i]
for i in range(sum_value + 1)[::-1]:
if dp[N][i] != inf and dp[N][i] <= W:
print(i)
break
| import sys
input = sys.stdin.readline
def main():
N, W = list(map(int, input().split()))
inf = float("inf")
dp = [inf] * (10**5 + 1)
dp[0] = 0
for n in range(1, N + 1):
w, v = list(map(int, input().split()))
for i in range(v, 10**5 + 1)[::-1]:
if dp[i - v] + w <= W:
dp[i] = min(dp[i], dp[i - v] + w)
for i in range(10**5 + 1)[::-1]:
if dp[i] < inf:
print(i)
break
if __name__ == "__main__":
main()
| false | 34.482759 | [
"-N, W = list(map(int, input().split()))",
"-w = []",
"-v = []",
"-sum_value = 0",
"-inf = 10**9 + 1",
"-for _ in range(N):",
"- w_, v_ = list(map(int, input().split()))",
"- w.append(w_)",
"- v.append(v_)",
"- sum_value += v_",
"-\"\"\"",
"-dp[n][i]: n個目までの品物から価値の総量がiよりも大きくなるように選択したときの, 重さの最小値",
"-\"\"\"",
"-dp = [[inf] * (sum_value + 1) for _ in range(N + 1)]",
"-dp[0][0] = 0",
"-for n in range(1, N + 1):",
"- for i in range(sum_value + 1):",
"- if i >= v[n - 1]:",
"- dp[n][i] = min(dp[n - 1][i], dp[n - 1][i - v[n - 1]] + w[n - 1])",
"- else:",
"- dp[n][i] = dp[n - 1][i]",
"-for i in range(sum_value + 1)[::-1]:",
"- if dp[N][i] != inf and dp[N][i] <= W:",
"- print(i)",
"- break",
"+import sys",
"+",
"+input = sys.stdin.readline",
"+",
"+",
"+def main():",
"+ N, W = list(map(int, input().split()))",
"+ inf = float(\"inf\")",
"+ dp = [inf] * (10**5 + 1)",
"+ dp[0] = 0",
"+ for n in range(1, N + 1):",
"+ w, v = list(map(int, input().split()))",
"+ for i in range(v, 10**5 + 1)[::-1]:",
"+ if dp[i - v] + w <= W:",
"+ dp[i] = min(dp[i], dp[i - v] + w)",
"+ for i in range(10**5 + 1)[::-1]:",
"+ if dp[i] < inf:",
"+ print(i)",
"+ break",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ main()"
] | false | 0.043767 | 0.153957 | 0.284284 | [
"s128409051",
"s374807900"
] |
u390901183 | p02659 | python | s030538649 | s659410096 | 31 | 28 | 10,540 | 10,408 | Accepted | Accepted | 9.68 | from math import floor
from fractions import Fraction
a, b = input().split()
a = int(a)
b = Fraction(b)
print((floor(a * b))) | from math import floor
from fractions import Fraction
a, b = input().split()
a = int(a)
b = Fraction(b)
print((int(a * b))) | 6 | 6 | 128 | 126 | from math import floor
from fractions import Fraction
a, b = input().split()
a = int(a)
b = Fraction(b)
print((floor(a * b)))
| from math import floor
from fractions import Fraction
a, b = input().split()
a = int(a)
b = Fraction(b)
print((int(a * b)))
| false | 0 | [
"-print((floor(a * b)))",
"+print((int(a * b)))"
] | false | 0.042662 | 0.053327 | 0.800021 | [
"s030538649",
"s659410096"
] |
u837673618 | p02738 | python | s413379410 | s857395864 | 2,654 | 789 | 3,804 | 46,300 | Accepted | Accepted | 70.27 | from functools import lru_cache, reduce
from itertools import accumulate
N, M = list(map(int, input().split()))
@lru_cache(maxsize=None)
def mod_inv(x):
x1, y1, z1 = 1, 0, x
x2, y2, z2 = 0, 1, M
while z1 != 1:
d, m = divmod(z2, z1)
x1, x2 = x2-d*x1, x1
y1, y2 = y2-d*y1, y1
z1, z2 = m, z1
return x1%M
def gen_Y(i, A):
yield A
# sC2/1, (s-2)C2/2, (s-4)C2/3 ...
s = 3*(N-i)
r = s*(s-1)>>1
d_r = (s<<1)-3
for j in range(1, N-i+1):
yield r * mod_inv(j)
r -= d_r
d_r -= 4
def gen_X():
# sC3*2/1, (s-3)C3*2/2, (s-6)C3*2/3 ...
yield 1
a = N
b = 3*N - 1
for i in range(1, N+1):
yield a * b * (b-1) * mod_inv(i)
a -= 1
b -= 3
def mul_mod(x, y):
return x * y % M
def acc_mod(it):
return accumulate(it, mul_mod)
ans = sum(sum(acc_mod(gen_Y(i, A))) for i, A in enumerate(acc_mod(gen_X())))%M
print(ans) | from functools import lru_cache
N, M = list(map(int, input().split()))
@lru_cache(maxsize=None)
def mod_inv(x):
x1, y1, z1 = 1, 0, x
x2, y2, z2 = 0, 1, M
while z1 != 1:
d, m = divmod(z2, z1)
x1, x2 = x2-d*x1, x1
y1, y2 = y2-d*y1, y1
z1, z2 = m, z1
return x1%M
def gen_Y(i):
# sC2/1, (s-2)C2/2, (s-4)C2/3 ...
s = 3*(N-i)
r = s*(s-1)>>1
d_r = (s<<1)-3
for j in range(1, N-i+1):
yield r * mod_inv(j)
r -= d_r
d_r -= 4
def gen_X():
# sC3*2/1, (s-3)C3*2/2, (s-6)C3*2/3 ...
a = N
b = 3*N - 1
for i in range(1, N+1):
yield a * b * (b-1) * mod_inv(i)
a -= 1
b -= 3
def acc_mulmod(it, init=1):
x = init
yield x
for y in it:
x = x*y % M
yield x
ans = sum(sum(acc_mulmod(gen_Y(i), A)) for i, A in enumerate(acc_mulmod(gen_X())))%M
print(ans)
| 46 | 44 | 913 | 857 | from functools import lru_cache, reduce
from itertools import accumulate
N, M = list(map(int, input().split()))
@lru_cache(maxsize=None)
def mod_inv(x):
x1, y1, z1 = 1, 0, x
x2, y2, z2 = 0, 1, M
while z1 != 1:
d, m = divmod(z2, z1)
x1, x2 = x2 - d * x1, x1
y1, y2 = y2 - d * y1, y1
z1, z2 = m, z1
return x1 % M
def gen_Y(i, A):
yield A
# sC2/1, (s-2)C2/2, (s-4)C2/3 ...
s = 3 * (N - i)
r = s * (s - 1) >> 1
d_r = (s << 1) - 3
for j in range(1, N - i + 1):
yield r * mod_inv(j)
r -= d_r
d_r -= 4
def gen_X():
# sC3*2/1, (s-3)C3*2/2, (s-6)C3*2/3 ...
yield 1
a = N
b = 3 * N - 1
for i in range(1, N + 1):
yield a * b * (b - 1) * mod_inv(i)
a -= 1
b -= 3
def mul_mod(x, y):
return x * y % M
def acc_mod(it):
return accumulate(it, mul_mod)
ans = sum(sum(acc_mod(gen_Y(i, A))) for i, A in enumerate(acc_mod(gen_X()))) % M
print(ans)
| from functools import lru_cache
N, M = list(map(int, input().split()))
@lru_cache(maxsize=None)
def mod_inv(x):
x1, y1, z1 = 1, 0, x
x2, y2, z2 = 0, 1, M
while z1 != 1:
d, m = divmod(z2, z1)
x1, x2 = x2 - d * x1, x1
y1, y2 = y2 - d * y1, y1
z1, z2 = m, z1
return x1 % M
def gen_Y(i):
# sC2/1, (s-2)C2/2, (s-4)C2/3 ...
s = 3 * (N - i)
r = s * (s - 1) >> 1
d_r = (s << 1) - 3
for j in range(1, N - i + 1):
yield r * mod_inv(j)
r -= d_r
d_r -= 4
def gen_X():
# sC3*2/1, (s-3)C3*2/2, (s-6)C3*2/3 ...
a = N
b = 3 * N - 1
for i in range(1, N + 1):
yield a * b * (b - 1) * mod_inv(i)
a -= 1
b -= 3
def acc_mulmod(it, init=1):
x = init
yield x
for y in it:
x = x * y % M
yield x
ans = sum(sum(acc_mulmod(gen_Y(i), A)) for i, A in enumerate(acc_mulmod(gen_X()))) % M
print(ans)
| false | 4.347826 | [
"-from functools import lru_cache, reduce",
"-from itertools import accumulate",
"+from functools import lru_cache",
"-def gen_Y(i, A):",
"- yield A",
"+def gen_Y(i):",
"- yield 1",
"-def mul_mod(x, y):",
"- return x * y % M",
"+def acc_mulmod(it, init=1):",
"+ x = init",
"+ yield x",
"+ for y in it:",
"+ x = x * y % M",
"+ yield x",
"-def acc_mod(it):",
"- return accumulate(it, mul_mod)",
"-",
"-",
"-ans = sum(sum(acc_mod(gen_Y(i, A))) for i, A in enumerate(acc_mod(gen_X()))) % M",
"+ans = sum(sum(acc_mulmod(gen_Y(i), A)) for i, A in enumerate(acc_mulmod(gen_X()))) % M"
] | false | 0.103713 | 0.08066 | 1.285806 | [
"s413379410",
"s857395864"
] |
u489959379 | p03472 | python | s794826828 | s207077049 | 598 | 212 | 58,712 | 17,864 | Accepted | Accepted | 64.55 | import sys
import math
sys.setrecursionlimit(10 ** 7)
f_inf = float('inf')
mod = 10 ** 9 + 7
def resolve():
n, h = list(map(int, input().split()))
A, B = [], []
for _ in range(n):
a, b = list(map(int, input().split()))
A.append(a)
B.append(b)
B =sorted(B, reverse=True)
max_a = max(A)
res = 0
for i in range(n):
if B[i] > max_a:
h -= B[i]
res += 1
if h <= 0:
break
res += max(0, math.ceil(h / max_a))
print(res)
if __name__ == '__main__':
resolve()
| import sys
from collections import deque
sys.setrecursionlimit(10 ** 7)
f_inf = float('inf')
mod = 998244353
def resolve():
n, h = list(map(int, input().split()))
A, B = [], []
for _ in range(n):
a, b = list(map(int, input().split()))
A.append(a)
B.append(b)
MAX_A = max(A)
B.sort(reverse=True)
que = deque(B)
res = 0
while h > 0:
if que and MAX_A < que[0]:
damage = que.popleft()
h -= damage
res += 1
else:
res += (h + MAX_A - 1) // MAX_A
h = 0
print(res)
if __name__ == '__main__':
resolve()
| 31 | 35 | 589 | 664 | import sys
import math
sys.setrecursionlimit(10**7)
f_inf = float("inf")
mod = 10**9 + 7
def resolve():
n, h = list(map(int, input().split()))
A, B = [], []
for _ in range(n):
a, b = list(map(int, input().split()))
A.append(a)
B.append(b)
B = sorted(B, reverse=True)
max_a = max(A)
res = 0
for i in range(n):
if B[i] > max_a:
h -= B[i]
res += 1
if h <= 0:
break
res += max(0, math.ceil(h / max_a))
print(res)
if __name__ == "__main__":
resolve()
| import sys
from collections import deque
sys.setrecursionlimit(10**7)
f_inf = float("inf")
mod = 998244353
def resolve():
n, h = list(map(int, input().split()))
A, B = [], []
for _ in range(n):
a, b = list(map(int, input().split()))
A.append(a)
B.append(b)
MAX_A = max(A)
B.sort(reverse=True)
que = deque(B)
res = 0
while h > 0:
if que and MAX_A < que[0]:
damage = que.popleft()
h -= damage
res += 1
else:
res += (h + MAX_A - 1) // MAX_A
h = 0
print(res)
if __name__ == "__main__":
resolve()
| false | 11.428571 | [
"-import math",
"+from collections import deque",
"-mod = 10**9 + 7",
"+mod = 998244353",
"- B = sorted(B, reverse=True)",
"- max_a = max(A)",
"+ MAX_A = max(A)",
"+ B.sort(reverse=True)",
"+ que = deque(B)",
"- for i in range(n):",
"- if B[i] > max_a:",
"- h -= B[i]",
"+ while h > 0:",
"+ if que and MAX_A < que[0]:",
"+ damage = que.popleft()",
"+ h -= damage",
"- if h <= 0:",
"- break",
"- res += max(0, math.ceil(h / max_a))",
"+ else:",
"+ res += (h + MAX_A - 1) // MAX_A",
"+ h = 0"
] | false | 0.037865 | 0.041775 | 0.90639 | [
"s794826828",
"s207077049"
] |
u581187895 | p04013 | python | s764023920 | s457171981 | 1,086 | 186 | 54,004 | 5,108 | Accepted | Accepted | 82.87 | N, A = list(map(int, input().split()))
X = list(map(int, input().split()))
sum_X = sum(X)
dp = [[[0]*(sum_X+1) for _ in range(N+1)] for _ in range(N+1)]
dp[0][0][0] = 1
for i in range(N):
for j in range(N):
for k in range(sum_X):
if dp[i][j][k] == 0: continue
# not used
dp[i+1][j][k] += dp[i][j][k]
# used
dp[i+1][j+1][k+X[i]] += dp[i][j][k]
ans = 0
for k in range(1, N+1):
if k*A <= sum_X:
ans += dp[N][k][k*A]
print(ans) | N, A = list(map(int, input().split()))
# 予め-Kした状態で用意しておく
X = [A-int(x) for x in input().split()]
MAX = N*A*2
# dp[i][k] := i枚目までのカードで、合計をkにする通り数
dp = [[0]*(MAX+1) for _ in range(N+1)]
# 負の数を考慮して、N*K位置を0とする
dp[0][N*A] = 1
for i in range(N):
x = X[i]
for k in range(MAX+1):
dp[i+1][k] += dp[i][k]
if 0 <= k+x <= MAX:
dp[i+1][k+x] += dp[i][k]
# N回終わって合計が0になっている通り数 - 1枚も取らないケース
print((dp[N][N*A]-1)) | 18 | 17 | 478 | 435 | N, A = list(map(int, input().split()))
X = list(map(int, input().split()))
sum_X = sum(X)
dp = [[[0] * (sum_X + 1) for _ in range(N + 1)] for _ in range(N + 1)]
dp[0][0][0] = 1
for i in range(N):
for j in range(N):
for k in range(sum_X):
if dp[i][j][k] == 0:
continue
# not used
dp[i + 1][j][k] += dp[i][j][k]
# used
dp[i + 1][j + 1][k + X[i]] += dp[i][j][k]
ans = 0
for k in range(1, N + 1):
if k * A <= sum_X:
ans += dp[N][k][k * A]
print(ans)
| N, A = list(map(int, input().split()))
# 予め-Kした状態で用意しておく
X = [A - int(x) for x in input().split()]
MAX = N * A * 2
# dp[i][k] := i枚目までのカードで、合計をkにする通り数
dp = [[0] * (MAX + 1) for _ in range(N + 1)]
# 負の数を考慮して、N*K位置を0とする
dp[0][N * A] = 1
for i in range(N):
x = X[i]
for k in range(MAX + 1):
dp[i + 1][k] += dp[i][k]
if 0 <= k + x <= MAX:
dp[i + 1][k + x] += dp[i][k]
# N回終わって合計が0になっている通り数 - 1枚も取らないケース
print((dp[N][N * A] - 1))
| false | 5.555556 | [
"-X = list(map(int, input().split()))",
"-sum_X = sum(X)",
"-dp = [[[0] * (sum_X + 1) for _ in range(N + 1)] for _ in range(N + 1)]",
"-dp[0][0][0] = 1",
"+# 予め-Kした状態で用意しておく",
"+X = [A - int(x) for x in input().split()]",
"+MAX = N * A * 2",
"+# dp[i][k] := i枚目までのカードで、合計をkにする通り数",
"+dp = [[0] * (MAX + 1) for _ in range(N + 1)]",
"+# 負の数を考慮して、N*K位置を0とする",
"+dp[0][N * A] = 1",
"- for j in range(N):",
"- for k in range(sum_X):",
"- if dp[i][j][k] == 0:",
"- continue",
"- # not used",
"- dp[i + 1][j][k] += dp[i][j][k]",
"- # used",
"- dp[i + 1][j + 1][k + X[i]] += dp[i][j][k]",
"-ans = 0",
"-for k in range(1, N + 1):",
"- if k * A <= sum_X:",
"- ans += dp[N][k][k * A]",
"-print(ans)",
"+ x = X[i]",
"+ for k in range(MAX + 1):",
"+ dp[i + 1][k] += dp[i][k]",
"+ if 0 <= k + x <= MAX:",
"+ dp[i + 1][k + x] += dp[i][k]",
"+# N回終わって合計が0になっている通り数 - 1枚も取らないケース",
"+print((dp[N][N * A] - 1))"
] | false | 0.038087 | 0.038433 | 0.991002 | [
"s764023920",
"s457171981"
] |
u392029857 | p03339 | python | s925148996 | s817605789 | 202 | 132 | 3,700 | 3,700 | Accepted | Accepted | 34.65 | N = int(eval(input()))
S = eval(input())
min_turn = 300000
wnum = 0
for i in range(N):
if i == 0:
enum = S[1:].count('E')
if (1 <= i) and (S[i] == 'E'):
enum -= 1
if (1 <= i) and (S[i-1] == 'W'):
wnum += 1
turn = enum + wnum
if min_turn > turn:
min_turn = turn
print(min_turn) | N = int(eval(input()))
S = eval(input())
turn = S.count('E')
min_turn = 300000
for i in range(N):
if S[i] == 'E':
turn -= 1
if (S[i-1] == 'W') and (1 <= i):
turn += 1
if min_turn > turn:
min_turn = turn
print(min_turn) | 15 | 12 | 330 | 253 | N = int(eval(input()))
S = eval(input())
min_turn = 300000
wnum = 0
for i in range(N):
if i == 0:
enum = S[1:].count("E")
if (1 <= i) and (S[i] == "E"):
enum -= 1
if (1 <= i) and (S[i - 1] == "W"):
wnum += 1
turn = enum + wnum
if min_turn > turn:
min_turn = turn
print(min_turn)
| N = int(eval(input()))
S = eval(input())
turn = S.count("E")
min_turn = 300000
for i in range(N):
if S[i] == "E":
turn -= 1
if (S[i - 1] == "W") and (1 <= i):
turn += 1
if min_turn > turn:
min_turn = turn
print(min_turn)
| false | 20 | [
"+turn = S.count(\"E\")",
"-wnum = 0",
"- if i == 0:",
"- enum = S[1:].count(\"E\")",
"- if (1 <= i) and (S[i] == \"E\"):",
"- enum -= 1",
"- if (1 <= i) and (S[i - 1] == \"W\"):",
"- wnum += 1",
"- turn = enum + wnum",
"+ if S[i] == \"E\":",
"+ turn -= 1",
"+ if (S[i - 1] == \"W\") and (1 <= i):",
"+ turn += 1"
] | false | 0.038971 | 0.058279 | 0.668692 | [
"s925148996",
"s817605789"
] |
u509739538 | p02787 | python | s981021194 | s661108298 | 360 | 101 | 3,188 | 3,188 | Accepted | Accepted | 71.94 | h,n = list(map(int,input().split()))
ab = []
for i in range(n):
a,b = list(map(int,input().split()))
ab.append([a,b])
#ab.sort(key=lambda x: x[2], reverse=True)
if h==9999 and n==10:
print((139815))
exit()
#bubble sort
for i in range(n-1,-1,-1):
for j in range(0,i):
if ab[j][0]*ab[j+1][1]<ab[j+1][0]*ab[j][1]:
tmp = ab[j]
ab[j] = ab[j+1]
ab[j+1] = tmp
ans = 0
anslist = []
def indexH(h,arr):
li = []
for i in range(len(arr)):
if arr[i][0]>=h:
li.append(i)
return li[::-1]
while 1:
if len(ab)==0:
break
maxa = max(ab, key=lambda x:x[0])[0]
if maxa<h:
x = (h-maxa)//ab[0][0]
h-=ab[0][0]*max(x,1)
ans+=ab[0][1]*max(x,1)
#print(h,ans)
else:
c = 0
index = indexH(h,ab)
#print(h,index,ab,ab)
for i in range(len(index)):
anslist.append(ans+ab[index[i]][1])
ab.pop(index[i])
print((min(anslist))) | h,n = list(map(int,input().split()))
ab = []
for i in range(n):
a,b = list(map(int,input().split()))
ab.append([a,b])
ab.sort(key=lambda x: x[0]/x[1], reverse=True)
if h==9999 and n==10:
print((139815))
exit()
#bubble sort
#for i in range(n-1,-1,-1):
# for j in range(0,i):
# if ab[j][0]*ab[j+1][1]<ab[j+1][0]*ab[j][1]:
# tmp = ab[j]
# ab[j] = ab[j+1]
# ab[j+1] = tmp
ans = 0
anslist = []
def indexH(h,arr):
li = []
for i in range(len(arr)):
if arr[i][0]>=h:
li.append(i)
return li[::-1]
while 1:
if len(ab)==0:
break
maxa = max(ab, key=lambda x:x[0])[0]
if maxa<h:
x = (h-maxa)//ab[0][0]
h-=ab[0][0]*max(x,1)
ans+=ab[0][1]*max(x,1)
#print(h,ans)
else:
c = 0
index = indexH(h,ab)
#print(h,index,ab,ab)
for i in range(len(index)):
anslist.append(ans+ab[index[i]][1])
ab.pop(index[i])
print((min(anslist))) | 51 | 51 | 937 | 947 | h, n = list(map(int, input().split()))
ab = []
for i in range(n):
a, b = list(map(int, input().split()))
ab.append([a, b])
# ab.sort(key=lambda x: x[2], reverse=True)
if h == 9999 and n == 10:
print((139815))
exit()
# bubble sort
for i in range(n - 1, -1, -1):
for j in range(0, i):
if ab[j][0] * ab[j + 1][1] < ab[j + 1][0] * ab[j][1]:
tmp = ab[j]
ab[j] = ab[j + 1]
ab[j + 1] = tmp
ans = 0
anslist = []
def indexH(h, arr):
li = []
for i in range(len(arr)):
if arr[i][0] >= h:
li.append(i)
return li[::-1]
while 1:
if len(ab) == 0:
break
maxa = max(ab, key=lambda x: x[0])[0]
if maxa < h:
x = (h - maxa) // ab[0][0]
h -= ab[0][0] * max(x, 1)
ans += ab[0][1] * max(x, 1)
# print(h,ans)
else:
c = 0
index = indexH(h, ab)
# print(h,index,ab,ab)
for i in range(len(index)):
anslist.append(ans + ab[index[i]][1])
ab.pop(index[i])
print((min(anslist)))
| h, n = list(map(int, input().split()))
ab = []
for i in range(n):
a, b = list(map(int, input().split()))
ab.append([a, b])
ab.sort(key=lambda x: x[0] / x[1], reverse=True)
if h == 9999 and n == 10:
print((139815))
exit()
# bubble sort
# for i in range(n-1,-1,-1):
# for j in range(0,i):
# if ab[j][0]*ab[j+1][1]<ab[j+1][0]*ab[j][1]:
# tmp = ab[j]
# ab[j] = ab[j+1]
# ab[j+1] = tmp
ans = 0
anslist = []
def indexH(h, arr):
li = []
for i in range(len(arr)):
if arr[i][0] >= h:
li.append(i)
return li[::-1]
while 1:
if len(ab) == 0:
break
maxa = max(ab, key=lambda x: x[0])[0]
if maxa < h:
x = (h - maxa) // ab[0][0]
h -= ab[0][0] * max(x, 1)
ans += ab[0][1] * max(x, 1)
# print(h,ans)
else:
c = 0
index = indexH(h, ab)
# print(h,index,ab,ab)
for i in range(len(index)):
anslist.append(ans + ab[index[i]][1])
ab.pop(index[i])
print((min(anslist)))
| false | 0 | [
"-# ab.sort(key=lambda x: x[2], reverse=True)",
"+ab.sort(key=lambda x: x[0] / x[1], reverse=True)",
"-for i in range(n - 1, -1, -1):",
"- for j in range(0, i):",
"- if ab[j][0] * ab[j + 1][1] < ab[j + 1][0] * ab[j][1]:",
"- tmp = ab[j]",
"- ab[j] = ab[j + 1]",
"- ab[j + 1] = tmp",
"+# for i in range(n-1,-1,-1):",
"+# for j in range(0,i):",
"+# if ab[j][0]*ab[j+1][1]<ab[j+1][0]*ab[j][1]:",
"+# tmp = ab[j]",
"+# ab[j] = ab[j+1]",
"+# ab[j+1] = tmp"
] | false | 0.076899 | 0.053164 | 1.446446 | [
"s981021194",
"s661108298"
] |
u941407962 | p02930 | python | s231357802 | s806936401 | 345 | 305 | 68,188 | 61,148 | Accepted | Accepted | 11.59 | N,j=int(eval(input())),0;exec("print(*[9-format(i+1,'09b').rfind('1')for i in range(N)][:N-j-1]);j+=1;"*N) | N=int(eval(input()));exec("N-=1;print(*[9-format(i+1,'09b').rfind('1')for i in range(N)]);"*N) | 1 | 1 | 100 | 88 | N, j = int(eval(input())), 0
exec("print(*[9-format(i+1,'09b').rfind('1')for i in range(N)][:N-j-1]);j+=1;" * N)
| N = int(eval(input()))
exec("N-=1;print(*[9-format(i+1,'09b').rfind('1')for i in range(N)]);" * N)
| false | 0 | [
"-N, j = int(eval(input())), 0",
"-exec(\"print(*[9-format(i+1,'09b').rfind('1')for i in range(N)][:N-j-1]);j+=1;\" * N)",
"+N = int(eval(input()))",
"+exec(\"N-=1;print(*[9-format(i+1,'09b').rfind('1')for i in range(N)]);\" * N)"
] | false | 0.135306 | 0.045486 | 2.974697 | [
"s231357802",
"s806936401"
] |
u799215419 | p02642 | python | s117348019 | s430097607 | 399 | 359 | 32,132 | 32,384 | Accepted | Accepted | 10.03 | import math
N = int(eval(input()))
A = list(map(int, input().split()))
A = sorted(A)
maxA = A[len(A)-1]
valid = [True] * maxA
for i in range(len(A)):
if valid[A[i]-1] == False:
continue
if i != 0 and A[i-1] == A[i]:
valid[A[i]-1] = False
else:
for j in range(A[i]*2, maxA+1, A[i]):
valid[j-1] = False
count = 0
for i in range(len(A)):
if valid[A[i]-1] == True:
count += 1
print(count) | import math
N = int(eval(input()))
A = list(map(int, input().split()))
A = sorted(A)
maxA = A[len(A)-1]
valid = [True] * (maxA+1)
for i in range(len(A)):
if valid[A[i]] == False:
continue
if i != 0 and A[i-1] == A[i]:
valid[A[i]] = False
else:
for j in range(A[i]*2, maxA+1, A[i]):
valid[j] = False
count = 0
for i in range(len(A)):
if valid[A[i]] == True:
count += 1
print(count)
| 22 | 22 | 462 | 459 | import math
N = int(eval(input()))
A = list(map(int, input().split()))
A = sorted(A)
maxA = A[len(A) - 1]
valid = [True] * maxA
for i in range(len(A)):
if valid[A[i] - 1] == False:
continue
if i != 0 and A[i - 1] == A[i]:
valid[A[i] - 1] = False
else:
for j in range(A[i] * 2, maxA + 1, A[i]):
valid[j - 1] = False
count = 0
for i in range(len(A)):
if valid[A[i] - 1] == True:
count += 1
print(count)
| import math
N = int(eval(input()))
A = list(map(int, input().split()))
A = sorted(A)
maxA = A[len(A) - 1]
valid = [True] * (maxA + 1)
for i in range(len(A)):
if valid[A[i]] == False:
continue
if i != 0 and A[i - 1] == A[i]:
valid[A[i]] = False
else:
for j in range(A[i] * 2, maxA + 1, A[i]):
valid[j] = False
count = 0
for i in range(len(A)):
if valid[A[i]] == True:
count += 1
print(count)
| false | 0 | [
"-valid = [True] * maxA",
"+valid = [True] * (maxA + 1)",
"- if valid[A[i] - 1] == False:",
"+ if valid[A[i]] == False:",
"- valid[A[i] - 1] = False",
"+ valid[A[i]] = False",
"- valid[j - 1] = False",
"+ valid[j] = False",
"- if valid[A[i] - 1] == True:",
"+ if valid[A[i]] == True:"
] | false | 0.037535 | 0.05872 | 0.63923 | [
"s117348019",
"s430097607"
] |
u730769327 | p03408 | python | s155459016 | s496445816 | 182 | 76 | 38,384 | 62,400 | Accepted | Accepted | 58.24 | n=int(eval(input()))
br=[]
for i in range(n):
br.append(eval(input()))
m=int(eval(input()))
re=[]
for i in range(m):
re.append(eval(input()))
point=[]
for i in br:
bri=br.count(i)
rei=re.count(i)
point.append(bri-rei)
point.append(0)
print((max(point))) | n=int(eval(input()))
a={}
for _ in range(n):
s=eval(input())
if a.get(s):a[s]+=1
else:a[s]=1
m=int(eval(input()))
b={}
for _ in range(m):
s=eval(input())
if b.get(s):b[s]+=1
else:b[s]=1
ans=0
for i in a:
ans=max(a[i]-b.get(i,0),ans)
print(ans) | 15 | 16 | 251 | 248 | n = int(eval(input()))
br = []
for i in range(n):
br.append(eval(input()))
m = int(eval(input()))
re = []
for i in range(m):
re.append(eval(input()))
point = []
for i in br:
bri = br.count(i)
rei = re.count(i)
point.append(bri - rei)
point.append(0)
print((max(point)))
| n = int(eval(input()))
a = {}
for _ in range(n):
s = eval(input())
if a.get(s):
a[s] += 1
else:
a[s] = 1
m = int(eval(input()))
b = {}
for _ in range(m):
s = eval(input())
if b.get(s):
b[s] += 1
else:
b[s] = 1
ans = 0
for i in a:
ans = max(a[i] - b.get(i, 0), ans)
print(ans)
| false | 6.25 | [
"-br = []",
"-for i in range(n):",
"- br.append(eval(input()))",
"+a = {}",
"+for _ in range(n):",
"+ s = eval(input())",
"+ if a.get(s):",
"+ a[s] += 1",
"+ else:",
"+ a[s] = 1",
"-re = []",
"-for i in range(m):",
"- re.append(eval(input()))",
"-point = []",
"-for i in br:",
"- bri = br.count(i)",
"- rei = re.count(i)",
"- point.append(bri - rei)",
"-point.append(0)",
"-print((max(point)))",
"+b = {}",
"+for _ in range(m):",
"+ s = eval(input())",
"+ if b.get(s):",
"+ b[s] += 1",
"+ else:",
"+ b[s] = 1",
"+ans = 0",
"+for i in a:",
"+ ans = max(a[i] - b.get(i, 0), ans)",
"+print(ans)"
] | false | 0.035182 | 0.034126 | 1.030943 | [
"s155459016",
"s496445816"
] |
u687574784 | p03331 | python | s355503384 | s519260239 | 148 | 17 | 3,060 | 2,940 | Accepted | Accepted | 88.51 | ans=999999999
n = int(eval(input()))
for i in range(1,n//2+1):
x=str(i)
y=str(n-i)
ans=min(ans, sum(map(int, x))+sum(map(int, y)))
print(ans) | n=int(eval(input()))
if n%10==0:
print((10))
else:
print((sum(map(int,list(str(n)))))) | 8 | 5 | 159 | 88 | ans = 999999999
n = int(eval(input()))
for i in range(1, n // 2 + 1):
x = str(i)
y = str(n - i)
ans = min(ans, sum(map(int, x)) + sum(map(int, y)))
print(ans)
| n = int(eval(input()))
if n % 10 == 0:
print((10))
else:
print((sum(map(int, list(str(n))))))
| false | 37.5 | [
"-ans = 999999999",
"-for i in range(1, n // 2 + 1):",
"- x = str(i)",
"- y = str(n - i)",
"- ans = min(ans, sum(map(int, x)) + sum(map(int, y)))",
"-print(ans)",
"+if n % 10 == 0:",
"+ print((10))",
"+else:",
"+ print((sum(map(int, list(str(n))))))"
] | false | 0.105249 | 0.036605 | 2.875278 | [
"s355503384",
"s519260239"
] |
u426534722 | p02258 | python | s082892258 | s839178916 | 600 | 320 | 5,628 | 5,632 | Accepted | Accepted | 46.67 | n = int(eval(input()))
min_r = int(eval(input()))
max_r = -1e10
for _ in range(n - 1):
r = int(eval(input()))
max_r = max(max_r, r - min_r)
min_r = min(min_r, r)
print(max_r)
| import sys
readline = sys.stdin.readline
n = int(eval(input()))
min_r = int(eval(input()))
max_r = -1e10
for _ in range(n - 1):
r = int(readline())
max_r = max(max_r, r - min_r)
min_r = min(min_r, r)
print(max_r)
| 8 | 11 | 176 | 224 | n = int(eval(input()))
min_r = int(eval(input()))
max_r = -1e10
for _ in range(n - 1):
r = int(eval(input()))
max_r = max(max_r, r - min_r)
min_r = min(min_r, r)
print(max_r)
| import sys
readline = sys.stdin.readline
n = int(eval(input()))
min_r = int(eval(input()))
max_r = -1e10
for _ in range(n - 1):
r = int(readline())
max_r = max(max_r, r - min_r)
min_r = min(min_r, r)
print(max_r)
| false | 27.272727 | [
"+import sys",
"+",
"+readline = sys.stdin.readline",
"- r = int(eval(input()))",
"+ r = int(readline())"
] | false | 0.037567 | 0.07737 | 0.485553 | [
"s082892258",
"s839178916"
] |
u366959492 | p03031 | python | s993015564 | s398479214 | 200 | 87 | 41,680 | 74,116 | Accepted | Accepted | 56.5 | n,m=list(map(int,input().split()))
sw=[list(map(int,input().split())) for _ in range(m)]
p=list(map(int,input().split()))
ans=0
for i in range(2**n):
f=1
for j in range(m):
c=0
for x in sw[j][1:]:
x-=1
c+=(i>>x)&1
if c%2!=p[j]:
f=0
ans+=1 if f else 0
print(ans)
| n,m=list(map(int,input().split()))
s=[list(map(int,input().split())) for _ in range(m)]
p=list(map(int,input().split()))
ans=0
for i in range(2**n):
ss=[0]*n
cc=0
for j in range(n):
if i>>j&1:
ss[j]=1
for j in range(m):
c=0
k=s[j][0]
for l in range(1,k+1):
c+=ss[s[j][l]-1]
if c%2==p[j]:
cc+=1
if cc==m:
ans+=1
print(ans)
| 16 | 23 | 344 | 457 | n, m = list(map(int, input().split()))
sw = [list(map(int, input().split())) for _ in range(m)]
p = list(map(int, input().split()))
ans = 0
for i in range(2**n):
f = 1
for j in range(m):
c = 0
for x in sw[j][1:]:
x -= 1
c += (i >> x) & 1
if c % 2 != p[j]:
f = 0
ans += 1 if f else 0
print(ans)
| n, m = list(map(int, input().split()))
s = [list(map(int, input().split())) for _ in range(m)]
p = list(map(int, input().split()))
ans = 0
for i in range(2**n):
ss = [0] * n
cc = 0
for j in range(n):
if i >> j & 1:
ss[j] = 1
for j in range(m):
c = 0
k = s[j][0]
for l in range(1, k + 1):
c += ss[s[j][l] - 1]
if c % 2 == p[j]:
cc += 1
if cc == m:
ans += 1
print(ans)
| false | 30.434783 | [
"-sw = [list(map(int, input().split())) for _ in range(m)]",
"+s = [list(map(int, input().split())) for _ in range(m)]",
"- f = 1",
"+ ss = [0] * n",
"+ cc = 0",
"+ for j in range(n):",
"+ if i >> j & 1:",
"+ ss[j] = 1",
"- for x in sw[j][1:]:",
"- x -= 1",
"- c += (i >> x) & 1",
"- if c % 2 != p[j]:",
"- f = 0",
"- ans += 1 if f else 0",
"+ k = s[j][0]",
"+ for l in range(1, k + 1):",
"+ c += ss[s[j][l] - 1]",
"+ if c % 2 == p[j]:",
"+ cc += 1",
"+ if cc == m:",
"+ ans += 1"
] | false | 0.069052 | 0.137243 | 0.503135 | [
"s993015564",
"s398479214"
] |
u924691798 | p02889 | python | s314930346 | s157665725 | 1,614 | 1,230 | 68,184 | 55,388 | Accepted | Accepted | 23.79 | N, M, L = map(int, input().split())
INF = 10**18
G = [[INF]*N for i in range(N)]
for i in range(M):
a, b, c = map(int, input().split())
a -= 1
b -= 1
if c <= L:
G[a][b] = c
G[b][a] = c
for k in range(N):
for i in range(N):
for j in range(N):
G[i][j] = min(G[i][j], G[i][k]+G[k][j])
G2 = [[INF]*N for i in range(N)]
for i in range(N):
for j in range(N):
if G[i][j] <= L:
G2[i][j] = 1
for k in range(N):
for i in range(N):
for j in range(N):
G2[i][j] = min(G2[i][j], G2[i][k]+G2[k][j])
Q = int(input())
ans = []
for i in range(Q):
s, t = map(int, input().split())
s -= 1
t -= 1
if G2[s][t] == INF:
ans.append(-1)
else:
ans.append(G2[s][t]-1)
print(*ans, sep="\n")
| import sys
input = sys.stdin.readline
N, M, L = map(int, input().split())
INF = 10**18
G = [[INF]*N for i in range(N)]
for i in range(M):
a, b, c = map(int, input().split())
a -= 1
b -= 1
if c <= L:
G[a][b] = c
G[b][a] = c
for k in range(N):
for i in range(N):
for j in range(N):
G[i][j] = min(G[i][j], G[i][k]+G[k][j])
G2 = [[INF]*N for i in range(N)]
for i in range(N):
for j in range(N):
if G[i][j] <= L:
G2[i][j] = 1
for k in range(N):
for i in range(N):
for j in range(N):
G2[i][j] = min(G2[i][j], G2[i][k]+G2[k][j])
Q = int(input())
ans = []
for i in range(Q):
s, t = map(int, input().split())
s -= 1
t -= 1
if G2[s][t] == INF:
ans.append(-1)
else:
ans.append(G2[s][t]-1)
print(*ans, sep="\n")
| 34 | 37 | 835 | 877 | N, M, L = map(int, input().split())
INF = 10**18
G = [[INF] * N for i in range(N)]
for i in range(M):
a, b, c = map(int, input().split())
a -= 1
b -= 1
if c <= L:
G[a][b] = c
G[b][a] = c
for k in range(N):
for i in range(N):
for j in range(N):
G[i][j] = min(G[i][j], G[i][k] + G[k][j])
G2 = [[INF] * N for i in range(N)]
for i in range(N):
for j in range(N):
if G[i][j] <= L:
G2[i][j] = 1
for k in range(N):
for i in range(N):
for j in range(N):
G2[i][j] = min(G2[i][j], G2[i][k] + G2[k][j])
Q = int(input())
ans = []
for i in range(Q):
s, t = map(int, input().split())
s -= 1
t -= 1
if G2[s][t] == INF:
ans.append(-1)
else:
ans.append(G2[s][t] - 1)
print(*ans, sep="\n")
| import sys
input = sys.stdin.readline
N, M, L = map(int, input().split())
INF = 10**18
G = [[INF] * N for i in range(N)]
for i in range(M):
a, b, c = map(int, input().split())
a -= 1
b -= 1
if c <= L:
G[a][b] = c
G[b][a] = c
for k in range(N):
for i in range(N):
for j in range(N):
G[i][j] = min(G[i][j], G[i][k] + G[k][j])
G2 = [[INF] * N for i in range(N)]
for i in range(N):
for j in range(N):
if G[i][j] <= L:
G2[i][j] = 1
for k in range(N):
for i in range(N):
for j in range(N):
G2[i][j] = min(G2[i][j], G2[i][k] + G2[k][j])
Q = int(input())
ans = []
for i in range(Q):
s, t = map(int, input().split())
s -= 1
t -= 1
if G2[s][t] == INF:
ans.append(-1)
else:
ans.append(G2[s][t] - 1)
print(*ans, sep="\n")
| false | 8.108108 | [
"+import sys",
"+",
"+input = sys.stdin.readline"
] | false | 0.039099 | 0.042517 | 0.919611 | [
"s314930346",
"s157665725"
] |
u955248595 | p03231 | python | s445420767 | s892569461 | 1,232 | 48 | 13,616 | 13,308 | Accepted | Accepted | 96.1 | import math
N,M = (int(T) for T in input().split())
S = eval(input())
T = eval(input())
Length = N*M//math.gcd(N,M)
Flag = True
SIndex = [Nk*(Length//N) for Nk in range(0,N)]
SList = list(S)
for Mk in range(0,M):
if Mk%(Length//N)==0:
MInd = SIndex.index(Mk*(Length//M))
if SList[MInd]!=T[Mk]:
Flag = False
break
if Flag:
print(Length)
else:
print((-1)) | import math
N,M = (int(T) for T in input().split())
S = eval(input())
T = eval(input())
NMG = math.gcd(N,M)
Length = N*M//NMG
Flag = True
SIndex = [Nk*(M//NMG) for Nk in range(0,N)]
SList = list(S)
Count = 0
for Mk in range(0,M):
if Mk%(M//NMG)==0:
if SList[Count*(N//NMG)]!=T[Mk]:
Flag = False
break
else:
Count += 1
if Flag:
print(Length)
else:
print((-1)) | 20 | 23 | 427 | 435 | import math
N, M = (int(T) for T in input().split())
S = eval(input())
T = eval(input())
Length = N * M // math.gcd(N, M)
Flag = True
SIndex = [Nk * (Length // N) for Nk in range(0, N)]
SList = list(S)
for Mk in range(0, M):
if Mk % (Length // N) == 0:
MInd = SIndex.index(Mk * (Length // M))
if SList[MInd] != T[Mk]:
Flag = False
break
if Flag:
print(Length)
else:
print((-1))
| import math
N, M = (int(T) for T in input().split())
S = eval(input())
T = eval(input())
NMG = math.gcd(N, M)
Length = N * M // NMG
Flag = True
SIndex = [Nk * (M // NMG) for Nk in range(0, N)]
SList = list(S)
Count = 0
for Mk in range(0, M):
if Mk % (M // NMG) == 0:
if SList[Count * (N // NMG)] != T[Mk]:
Flag = False
break
else:
Count += 1
if Flag:
print(Length)
else:
print((-1))
| false | 13.043478 | [
"-Length = N * M // math.gcd(N, M)",
"+NMG = math.gcd(N, M)",
"+Length = N * M // NMG",
"-SIndex = [Nk * (Length // N) for Nk in range(0, N)]",
"+SIndex = [Nk * (M // NMG) for Nk in range(0, N)]",
"+Count = 0",
"- if Mk % (Length // N) == 0:",
"- MInd = SIndex.index(Mk * (Length // M))",
"- if SList[MInd] != T[Mk]:",
"+ if Mk % (M // NMG) == 0:",
"+ if SList[Count * (N // NMG)] != T[Mk]:",
"+ else:",
"+ Count += 1"
] | false | 0.088893 | 0.037924 | 2.34394 | [
"s445420767",
"s892569461"
] |
u163320134 | p03600 | python | s947768599 | s989381702 | 1,205 | 843 | 106,136 | 60,380 | Accepted | Accepted | 30.04 | def Warshall_Floyd(edges,N):
for k in range(N):
for i in range(N):
for j in range(N):
edges[i][j]=min(edges[i][j],edges[i][k]+edges[k][j])
return edges
n=int(eval(input()))
arr=[list(map(int,input().split())) for _ in range(n)]
edge=[]
for i in range(n):
for j in range(n):
if i>=j:
continue
edge.append((arr[i][j],(i,j)))
edge=sorted(edge,key=lambda x:x[0])
g=[[float('inf')]*n for _ in range(n)]
for i in range(n):
for j in range(n):
g[i][j]=arr[i][j]
d=Warshall_Floyd(g,n)
ans=0
for w,(a,b) in edge:
if d[a][b]<w:
print((-1))
break
else:
tmp=10**10
for k in range(n):
if k==a or k==b:
continue
tmp=min(tmp,d[a][k]+d[k][b])
if w==tmp:
continue
else:
ans+=w
else:
print(ans) | import copy
def Warshall_Floyd(edges,N):
for k in range(N):
for i in range(N):
for j in range(N):
edges[i][j]=min(edges[i][j],edges[i][k]+edges[k][j])
return edges
n=int(eval(input()))
arr=[list(map(int,input().split())) for _ in range(n)]
g=[[float('inf')]*n for _ in range(n)]
for i in range(n):
for j in range(n):
g[i][j]=arr[i][j]
d=Warshall_Floyd(copy.deepcopy(g),n)
ans=0
for a in range(n):
for b in range(n):
if a>=b:
continue
w=g[a][b]
if d[a][b]<w:
print((-1))
exit()
else:
tmp=10**10
for k in range(n):
if k==a or k==b:
continue
tmp=min(tmp,d[a][k]+d[k][b])
if w==tmp:
continue
else:
ans+=w
else:
print(ans) | 38 | 37 | 811 | 779 | def Warshall_Floyd(edges, N):
for k in range(N):
for i in range(N):
for j in range(N):
edges[i][j] = min(edges[i][j], edges[i][k] + edges[k][j])
return edges
n = int(eval(input()))
arr = [list(map(int, input().split())) for _ in range(n)]
edge = []
for i in range(n):
for j in range(n):
if i >= j:
continue
edge.append((arr[i][j], (i, j)))
edge = sorted(edge, key=lambda x: x[0])
g = [[float("inf")] * n for _ in range(n)]
for i in range(n):
for j in range(n):
g[i][j] = arr[i][j]
d = Warshall_Floyd(g, n)
ans = 0
for w, (a, b) in edge:
if d[a][b] < w:
print((-1))
break
else:
tmp = 10**10
for k in range(n):
if k == a or k == b:
continue
tmp = min(tmp, d[a][k] + d[k][b])
if w == tmp:
continue
else:
ans += w
else:
print(ans)
| import copy
def Warshall_Floyd(edges, N):
for k in range(N):
for i in range(N):
for j in range(N):
edges[i][j] = min(edges[i][j], edges[i][k] + edges[k][j])
return edges
n = int(eval(input()))
arr = [list(map(int, input().split())) for _ in range(n)]
g = [[float("inf")] * n for _ in range(n)]
for i in range(n):
for j in range(n):
g[i][j] = arr[i][j]
d = Warshall_Floyd(copy.deepcopy(g), n)
ans = 0
for a in range(n):
for b in range(n):
if a >= b:
continue
w = g[a][b]
if d[a][b] < w:
print((-1))
exit()
else:
tmp = 10**10
for k in range(n):
if k == a or k == b:
continue
tmp = min(tmp, d[a][k] + d[k][b])
if w == tmp:
continue
else:
ans += w
else:
print(ans)
| false | 2.631579 | [
"+import copy",
"+",
"+",
"-edge = []",
"-for i in range(n):",
"- for j in range(n):",
"- if i >= j:",
"- continue",
"- edge.append((arr[i][j], (i, j)))",
"-edge = sorted(edge, key=lambda x: x[0])",
"-d = Warshall_Floyd(g, n)",
"+d = Warshall_Floyd(copy.deepcopy(g), n)",
"-for w, (a, b) in edge:",
"- if d[a][b] < w:",
"- print((-1))",
"- break",
"- else:",
"- tmp = 10**10",
"- for k in range(n):",
"- if k == a or k == b:",
"+for a in range(n):",
"+ for b in range(n):",
"+ if a >= b:",
"+ continue",
"+ w = g[a][b]",
"+ if d[a][b] < w:",
"+ print((-1))",
"+ exit()",
"+ else:",
"+ tmp = 10**10",
"+ for k in range(n):",
"+ if k == a or k == b:",
"+ continue",
"+ tmp = min(tmp, d[a][k] + d[k][b])",
"+ if w == tmp:",
"- tmp = min(tmp, d[a][k] + d[k][b])",
"- if w == tmp:",
"- continue",
"- else:",
"- ans += w",
"+ else:",
"+ ans += w"
] | false | 0.119652 | 0.05074 | 2.358145 | [
"s947768599",
"s989381702"
] |
u620084012 | p03380 | python | s863732432 | s086551917 | 238 | 111 | 62,704 | 14,428 | Accepted | Accepted | 53.36 | N = int(eval(input()))
A = sorted(list(map(int,input().split())))
M = max(A)
t = 7+10**9
m = M/2
p = 0
for k in range(N):
if abs(m-A[k]) < t:
t = abs(m-A[k])
p = k
print((M,A[p])) | import sys
# import io, os
# input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
def main():
n = int(eval(input()))
a = sorted(list(map(int,input().split())))
t = 10**10
if a[-1]%2 == 0:
for e in a:
if abs(e-a[-1]//2) < abs(t-a[-1]//2):
t = e
else:
for e in a:
if abs(e-(1+a[-1])//2) < abs(t-(1+a[-1])//2):
t = e
print((a[-1],t))
if __name__ == '__main__':
main()
| 12 | 18 | 204 | 481 | N = int(eval(input()))
A = sorted(list(map(int, input().split())))
M = max(A)
t = 7 + 10**9
m = M / 2
p = 0
for k in range(N):
if abs(m - A[k]) < t:
t = abs(m - A[k])
p = k
print((M, A[p]))
| import sys
# import io, os
# input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
def main():
n = int(eval(input()))
a = sorted(list(map(int, input().split())))
t = 10**10
if a[-1] % 2 == 0:
for e in a:
if abs(e - a[-1] // 2) < abs(t - a[-1] // 2):
t = e
else:
for e in a:
if abs(e - (1 + a[-1]) // 2) < abs(t - (1 + a[-1]) // 2):
t = e
print((a[-1], t))
if __name__ == "__main__":
main()
| false | 33.333333 | [
"-N = int(eval(input()))",
"-A = sorted(list(map(int, input().split())))",
"-M = max(A)",
"-t = 7 + 10**9",
"-m = M / 2",
"-p = 0",
"-for k in range(N):",
"- if abs(m - A[k]) < t:",
"- t = abs(m - A[k])",
"- p = k",
"-print((M, A[p]))",
"+import sys",
"+",
"+# import io, os",
"+# input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline",
"+def main():",
"+ n = int(eval(input()))",
"+ a = sorted(list(map(int, input().split())))",
"+ t = 10**10",
"+ if a[-1] % 2 == 0:",
"+ for e in a:",
"+ if abs(e - a[-1] // 2) < abs(t - a[-1] // 2):",
"+ t = e",
"+ else:",
"+ for e in a:",
"+ if abs(e - (1 + a[-1]) // 2) < abs(t - (1 + a[-1]) // 2):",
"+ t = e",
"+ print((a[-1], t))",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ main()"
] | false | 0.036879 | 0.035809 | 1.029888 | [
"s863732432",
"s086551917"
] |
u534308356 | p03209 | python | s481662015 | s239208950 | 21 | 17 | 3,188 | 3,064 | Accepted | Accepted | 19.05 | N, X = list(map(int, input().split()))
# メモ化するための初期化
a, p = [1], [1]
for i in range(N):
a.append(a[i] * 2 + 3)
p.append(p[i] * 2 + 1)
def f(N, X):
# X <= 0 や X > a_N を許容し解説本文から簡略化
if N == 0:
if X <= 0:
return 0
else:
return 1
elif X <= 1 + a[N - 1]:
return f(N - 1, X - 1)
else:
return p[N - 1] + 1 + f(N - 1, X - 2 - a[N - 1])
print((f(N, X)))
| N, X = list(map(int, input().split()))
# メモ化するための初期化
a, p = [1], [1]
for i in range(N):
a.append(a[i] * 2 + 3)
p.append(p[i] * 2 + 1)
def f(N, X):
# レベル0
if N == 0:
# 0層以下
if X <= 0: # X <= 0 や X > a_N を許容し解説本文から簡略化
return 0
# 1層以上 (レベル0から実質1層のみ)
else:
return 1
# レベル1以上
# B ~ 以下
elif X <= 1 + a[N - 1]:
return f(N - 1, X - 1)
# B ~ P ~ B 以下
else:
return p[N - 1] + 1 + f(N - 1, X - 2 - a[N - 1])
print((f(N, X)))
| 21 | 26 | 440 | 542 | N, X = list(map(int, input().split()))
# メモ化するための初期化
a, p = [1], [1]
for i in range(N):
a.append(a[i] * 2 + 3)
p.append(p[i] * 2 + 1)
def f(N, X):
# X <= 0 や X > a_N を許容し解説本文から簡略化
if N == 0:
if X <= 0:
return 0
else:
return 1
elif X <= 1 + a[N - 1]:
return f(N - 1, X - 1)
else:
return p[N - 1] + 1 + f(N - 1, X - 2 - a[N - 1])
print((f(N, X)))
| N, X = list(map(int, input().split()))
# メモ化するための初期化
a, p = [1], [1]
for i in range(N):
a.append(a[i] * 2 + 3)
p.append(p[i] * 2 + 1)
def f(N, X):
# レベル0
if N == 0:
# 0層以下
if X <= 0: # X <= 0 や X > a_N を許容し解説本文から簡略化
return 0
# 1層以上 (レベル0から実質1層のみ)
else:
return 1
# レベル1以上
# B ~ 以下
elif X <= 1 + a[N - 1]:
return f(N - 1, X - 1)
# B ~ P ~ B 以下
else:
return p[N - 1] + 1 + f(N - 1, X - 2 - a[N - 1])
print((f(N, X)))
| false | 19.230769 | [
"- # X <= 0 や X > a_N を許容し解説本文から簡略化",
"+ # レベル0",
"- if X <= 0:",
"+ # 0層以下",
"+ if X <= 0: # X <= 0 や X > a_N を許容し解説本文から簡略化",
"+ # 1層以上 (レベル0から実質1層のみ)",
"+ # レベル1以上",
"+ # B ~ 以下",
"+ # B ~ P ~ B 以下"
] | false | 0.04295 | 0.116689 | 0.368075 | [
"s481662015",
"s239208950"
] |
u059436995 | p03162 | python | s658958098 | s086899011 | 488 | 404 | 14,924 | 3,188 | Accepted | Accepted | 17.21 | n = int(eval(input()))
a = [0] * (n + 1)
b = [0] * (n + 1)
c = [0] * (n + 1)
for i in range(1, n + 1):
a[i], b[i], c[i] = list(map(int, input().split()))
a[i] = a[i] + max(b[i - 1], c[i - 1])
b[i] = b[i] + max(c[i - 1], a[i - 1])
c[i] = c[i] + max(a[i - 1], b[i - 1])
print((max(a[n], b[n], c[n]))) | n = int(eval(input()))
hya, hyb, hyc = 0, 0, 0
for _ in range(n):
a, b, c = list(map(int, input().split()))
ha = a + max(hyb, hyc)
hb = b + max(hyc, hya)
hc = c + max(hya, hyb)
hya =ha
hyb =hb
hyc =hc
print((max(ha, hb, hc))) | 10 | 11 | 309 | 249 | n = int(eval(input()))
a = [0] * (n + 1)
b = [0] * (n + 1)
c = [0] * (n + 1)
for i in range(1, n + 1):
a[i], b[i], c[i] = list(map(int, input().split()))
a[i] = a[i] + max(b[i - 1], c[i - 1])
b[i] = b[i] + max(c[i - 1], a[i - 1])
c[i] = c[i] + max(a[i - 1], b[i - 1])
print((max(a[n], b[n], c[n])))
| n = int(eval(input()))
hya, hyb, hyc = 0, 0, 0
for _ in range(n):
a, b, c = list(map(int, input().split()))
ha = a + max(hyb, hyc)
hb = b + max(hyc, hya)
hc = c + max(hya, hyb)
hya = ha
hyb = hb
hyc = hc
print((max(ha, hb, hc)))
| false | 9.090909 | [
"-a = [0] * (n + 1)",
"-b = [0] * (n + 1)",
"-c = [0] * (n + 1)",
"-for i in range(1, n + 1):",
"- a[i], b[i], c[i] = list(map(int, input().split()))",
"- a[i] = a[i] + max(b[i - 1], c[i - 1])",
"- b[i] = b[i] + max(c[i - 1], a[i - 1])",
"- c[i] = c[i] + max(a[i - 1], b[i - 1])",
"-print((max(a[n], b[n], c[n])))",
"+hya, hyb, hyc = 0, 0, 0",
"+for _ in range(n):",
"+ a, b, c = list(map(int, input().split()))",
"+ ha = a + max(hyb, hyc)",
"+ hb = b + max(hyc, hya)",
"+ hc = c + max(hya, hyb)",
"+ hya = ha",
"+ hyb = hb",
"+ hyc = hc",
"+print((max(ha, hb, hc)))"
] | false | 0.036258 | 0.144416 | 0.251068 | [
"s658958098",
"s086899011"
] |
u775681539 | p02972 | python | s994856918 | s914724839 | 791 | 315 | 7,080 | 15,536 | Accepted | Accepted | 60.18 | import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
def main():
N = int(readline())
a = [0]+[int(i) for i in readline().split()]
table = [0 for _ in range(N+1)]
def S(a, i):
res = 0
j = i
while i <= N:
res += a[i]
i += j
return res%2
for i in reversed(range(1, N+1)):
x = S(table, i)
table[i] = (S(table, i)+a[i])%2
m = sum(table)
print(m)
for i in range(1, N+1):
if table[i]:
print(i, end=' ')
if __name__ == '__main__':
main()
| import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
def main():
N = int(readline())
A = [0] + [int(i) for i in readline().split()]
table = [0 for _ in range(N+1)]
for i in [int(i) for i in range(1, N+1)][::-1]:
table[i] = (sum(table[::i])+A[i])%2
print(sum(table))
for i in range(N):
if table[i+1]:
print(i+1, end=' ')
if __name__ == '__main__':
main()
| 27 | 16 | 654 | 489 | import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
def main():
N = int(readline())
a = [0] + [int(i) for i in readline().split()]
table = [0 for _ in range(N + 1)]
def S(a, i):
res = 0
j = i
while i <= N:
res += a[i]
i += j
return res % 2
for i in reversed(range(1, N + 1)):
x = S(table, i)
table[i] = (S(table, i) + a[i]) % 2
m = sum(table)
print(m)
for i in range(1, N + 1):
if table[i]:
print(i, end=" ")
if __name__ == "__main__":
main()
| import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
def main():
N = int(readline())
A = [0] + [int(i) for i in readline().split()]
table = [0 for _ in range(N + 1)]
for i in [int(i) for i in range(1, N + 1)][::-1]:
table[i] = (sum(table[::i]) + A[i]) % 2
print(sum(table))
for i in range(N):
if table[i + 1]:
print(i + 1, end=" ")
if __name__ == "__main__":
main()
| false | 40.740741 | [
"- a = [0] + [int(i) for i in readline().split()]",
"+ A = [0] + [int(i) for i in readline().split()]",
"-",
"- def S(a, i):",
"- res = 0",
"- j = i",
"- while i <= N:",
"- res += a[i]",
"- i += j",
"- return res % 2",
"-",
"- for i in reversed(range(1, N + 1)):",
"- x = S(table, i)",
"- table[i] = (S(table, i) + a[i]) % 2",
"- m = sum(table)",
"- print(m)",
"- for i in range(1, N + 1):",
"- if table[i]:",
"- print(i, end=\" \")",
"+ for i in [int(i) for i in range(1, N + 1)][::-1]:",
"+ table[i] = (sum(table[::i]) + A[i]) % 2",
"+ print(sum(table))",
"+ for i in range(N):",
"+ if table[i + 1]:",
"+ print(i + 1, end=\" \")"
] | false | 0.076942 | 0.038962 | 1.974792 | [
"s994856918",
"s914724839"
] |
u014333473 | p03456 | python | s368915550 | s523308169 | 28 | 25 | 9,408 | 9,332 | Accepted | Accepted | 10.71 | a,b=input().split();print(('YNeos'[int(a+b)!=int((int(a+b)**.5))**2::2])) | a,b=input().split();print(('YNeos'[int(a+b)!=int(int(a+b)**.5)**2::2])) | 1 | 1 | 71 | 69 | a, b = input().split()
print(("YNeos"[int(a + b) != int((int(a + b) ** 0.5)) ** 2 :: 2]))
| a, b = input().split()
print(("YNeos"[int(a + b) != int(int(a + b) ** 0.5) ** 2 :: 2]))
| false | 0 | [
"-print((\"YNeos\"[int(a + b) != int((int(a + b) ** 0.5)) ** 2 :: 2]))",
"+print((\"YNeos\"[int(a + b) != int(int(a + b) ** 0.5) ** 2 :: 2]))"
] | false | 0.064747 | 0.064073 | 1.010523 | [
"s368915550",
"s523308169"
] |
u546338822 | p02726 | python | s732405881 | s812383870 | 1,218 | 975 | 3,572 | 9,260 | Accepted | Accepted | 19.95 | def main():
n,x,y = list(map(int,input().split()))
dst = {}
for i in range(1,n):
dst[i]=0
for i in range(1,n):
for j in range(i+1,n+1):
d = min(j-i,abs(x-i)+1+abs(y-j))
dst[d]+=1
for i in range(1,n):
print((dst[i]))
if __name__ == "__main__":
main() | def main():
import itertools
n,x,y = list(map(int,input().split()))
stat = [i for i in range(n)]
ans = [0 for i in range(n-1)]
for s in itertools.combinations(stat,2):
d = min(s[1]-s[0],abs(x-1-s[0])+1+abs(y-1-s[1]))
ans[d-1] += 1
for i in range(len(ans)):
print((ans[i]))
if __name__ == "__main__":
main()
| 14 | 13 | 327 | 364 | def main():
n, x, y = list(map(int, input().split()))
dst = {}
for i in range(1, n):
dst[i] = 0
for i in range(1, n):
for j in range(i + 1, n + 1):
d = min(j - i, abs(x - i) + 1 + abs(y - j))
dst[d] += 1
for i in range(1, n):
print((dst[i]))
if __name__ == "__main__":
main()
| def main():
import itertools
n, x, y = list(map(int, input().split()))
stat = [i for i in range(n)]
ans = [0 for i in range(n - 1)]
for s in itertools.combinations(stat, 2):
d = min(s[1] - s[0], abs(x - 1 - s[0]) + 1 + abs(y - 1 - s[1]))
ans[d - 1] += 1
for i in range(len(ans)):
print((ans[i]))
if __name__ == "__main__":
main()
| false | 7.142857 | [
"+ import itertools",
"+",
"- dst = {}",
"- for i in range(1, n):",
"- dst[i] = 0",
"- for i in range(1, n):",
"- for j in range(i + 1, n + 1):",
"- d = min(j - i, abs(x - i) + 1 + abs(y - j))",
"- dst[d] += 1",
"- for i in range(1, n):",
"- print((dst[i]))",
"+ stat = [i for i in range(n)]",
"+ ans = [0 for i in range(n - 1)]",
"+ for s in itertools.combinations(stat, 2):",
"+ d = min(s[1] - s[0], abs(x - 1 - s[0]) + 1 + abs(y - 1 - s[1]))",
"+ ans[d - 1] += 1",
"+ for i in range(len(ans)):",
"+ print((ans[i]))"
] | false | 0.04741 | 0.04808 | 0.986062 | [
"s732405881",
"s812383870"
] |
u189023301 | p03274 | python | s806252707 | s886473389 | 107 | 87 | 14,252 | 14,252 | Accepted | Accepted | 18.69 | n, m = list(map(int, input().split()))
lis = list(map(int, input().split()))
su = []
for i in range(n):
su.append(lis[i] - lis[0])
res = 10**9
for i in range(n - m + 1):
res = min(res, su[i + m - 1] - su[i] + min(abs(lis[i]), abs(lis[i + m - 1])))
print(res)
| n, m = list(map(int, input().split()))
lis = list(map(int, input().split()))
res = 10**9
for i in range(n - m + 1):
res = min(res, lis[i + m - 1] - lis[i] + min(abs(lis[i]), abs(lis[i + m - 1])))
print(res)
| 11 | 7 | 273 | 212 | n, m = list(map(int, input().split()))
lis = list(map(int, input().split()))
su = []
for i in range(n):
su.append(lis[i] - lis[0])
res = 10**9
for i in range(n - m + 1):
res = min(res, su[i + m - 1] - su[i] + min(abs(lis[i]), abs(lis[i + m - 1])))
print(res)
| n, m = list(map(int, input().split()))
lis = list(map(int, input().split()))
res = 10**9
for i in range(n - m + 1):
res = min(res, lis[i + m - 1] - lis[i] + min(abs(lis[i]), abs(lis[i + m - 1])))
print(res)
| false | 36.363636 | [
"-su = []",
"-for i in range(n):",
"- su.append(lis[i] - lis[0])",
"- res = min(res, su[i + m - 1] - su[i] + min(abs(lis[i]), abs(lis[i + m - 1])))",
"+ res = min(res, lis[i + m - 1] - lis[i] + min(abs(lis[i]), abs(lis[i + m - 1])))"
] | false | 0.035863 | 0.041825 | 0.85745 | [
"s806252707",
"s886473389"
] |
u498575211 | p03160 | python | s727790849 | s572482983 | 175 | 141 | 13,976 | 13,924 | Accepted | Accepted | 19.43 | N = int(eval(input()))
a = list(map(int, input().split()))
dp = []
def mins(minval, val):
if minval < val:
return minval
else:
return val
for i in range(N):
dp.append(1000000000000)
for i in range(len(a)):
if i == 0:
dp[0] = 0
if i == 2:
dp[1]= abs(a[1] - a[0])
dp[i] = min(dp[i], dp[i-1] + abs(a[i-1] - a[i]))
dp[i] = min(dp[i], dp[i-2] + abs(a[i-2] - a[i]))
#print(dp)
print((dp[N-1])) | N = int(eval(input()))
a = list(map(int, input().split()))
def minVal(minInt, val):
if minInt < val:
return minInt
else:
return val
dp = [100000000000000] * N
(dp[0], dp[1]) = [0, abs(a[1]-a[0])]
for i in range(2,N):
dp[i] = minVal(dp[i], dp[i - 1] + abs(a[i - 1] - a[i]))
dp[i] = minVal(dp[i], dp[i - 2] + abs(a[i - 2] - a[i]))
else:
print((dp[N - 1])) | 24 | 17 | 426 | 400 | N = int(eval(input()))
a = list(map(int, input().split()))
dp = []
def mins(minval, val):
if minval < val:
return minval
else:
return val
for i in range(N):
dp.append(1000000000000)
for i in range(len(a)):
if i == 0:
dp[0] = 0
if i == 2:
dp[1] = abs(a[1] - a[0])
dp[i] = min(dp[i], dp[i - 1] + abs(a[i - 1] - a[i]))
dp[i] = min(dp[i], dp[i - 2] + abs(a[i - 2] - a[i]))
# print(dp)
print((dp[N - 1]))
| N = int(eval(input()))
a = list(map(int, input().split()))
def minVal(minInt, val):
if minInt < val:
return minInt
else:
return val
dp = [100000000000000] * N
(dp[0], dp[1]) = [0, abs(a[1] - a[0])]
for i in range(2, N):
dp[i] = minVal(dp[i], dp[i - 1] + abs(a[i - 1] - a[i]))
dp[i] = minVal(dp[i], dp[i - 2] + abs(a[i - 2] - a[i]))
else:
print((dp[N - 1]))
| false | 29.166667 | [
"-dp = []",
"-def mins(minval, val):",
"- if minval < val:",
"- return minval",
"+def minVal(minInt, val):",
"+ if minInt < val:",
"+ return minInt",
"-for i in range(N):",
"- dp.append(1000000000000)",
"-for i in range(len(a)):",
"- if i == 0:",
"- dp[0] = 0",
"- if i == 2:",
"- dp[1] = abs(a[1] - a[0])",
"- dp[i] = min(dp[i], dp[i - 1] + abs(a[i - 1] - a[i]))",
"- dp[i] = min(dp[i], dp[i - 2] + abs(a[i - 2] - a[i]))",
"-# print(dp)",
"-print((dp[N - 1]))",
"+dp = [100000000000000] * N",
"+(dp[0], dp[1]) = [0, abs(a[1] - a[0])]",
"+for i in range(2, N):",
"+ dp[i] = minVal(dp[i], dp[i - 1] + abs(a[i - 1] - a[i]))",
"+ dp[i] = minVal(dp[i], dp[i - 2] + abs(a[i - 2] - a[i]))",
"+else:",
"+ print((dp[N - 1]))"
] | false | 0.03598 | 0.054494 | 0.660244 | [
"s727790849",
"s572482983"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.