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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
u035907840 | p03165 | python | s239541483 | s780614770 | 815 | 349 | 428,824 | 144,428 | Accepted | Accepted | 57.18 | s = eval(input())
t = eval(input())
S, T = len(s), len(t)
dp = [[0]*(T+1) for _ in range(S+1)]
prev = [[(-1,-1)]*(T+1) for _ in range(S+1)]
for i in range(S):
for j in range(T):
r = max(dp[i][j-1], dp[i-1][j])
p = (i, j-1) if r == dp[i][j-1] else (i-1, j)
if s[i] == t[j]:
r = max(dp[i-1][j-1] + 1, r)
p = (i-1, j-1) if r == dp[i-1][j-1] + 1 else p
dp[i][j] = r
prev[i][j] = p
ans = ''
i, j = S - 1, T - 1
while i >= 0 and j >= 0:
if prev[i][j] == (i-1, j-1):
ans += s[i]
i, j = prev[i][j]
print((ans[::-1])) | def solve(S, T):
L1 = len(S)
L2 = len(T)
dp = [[0]*(L2+1) for i in range(L1+1)]
for i in range(L1-1, -1, -1):
for j in range(L2-1, -1, -1):
r = max(dp[i+1][j], dp[i][j+1])
if S[i] == T[j]:
r = max(r, dp[i+1][j+1] + 1)
dp[i][j] = r
# dp[0][0] が長さの解
# ここからは復元処理
res = []
i = 0; j = 0
while i < L1 and j < L2:
if S[i] == T[j]:
res.append(S[i])
i += 1; j += 1
elif dp[i][j] == dp[i+1][j]:
i += 1
elif dp[i][j] == dp[i][j+1]:
j += 1
return "".join(res)
S = eval(input())
T = eval(input())
print((solve(S,T))) | 26 | 30 | 610 | 694 | s = eval(input())
t = eval(input())
S, T = len(s), len(t)
dp = [[0] * (T + 1) for _ in range(S + 1)]
prev = [[(-1, -1)] * (T + 1) for _ in range(S + 1)]
for i in range(S):
for j in range(T):
r = max(dp[i][j - 1], dp[i - 1][j])
p = (i, j - 1) if r == dp[i][j - 1] else (i - 1, j)
if s[i] == t[j]:
r = max(dp[i - 1][j - 1] + 1, r)
p = (i - 1, j - 1) if r == dp[i - 1][j - 1] + 1 else p
dp[i][j] = r
prev[i][j] = p
ans = ""
i, j = S - 1, T - 1
while i >= 0 and j >= 0:
if prev[i][j] == (i - 1, j - 1):
ans += s[i]
i, j = prev[i][j]
print((ans[::-1]))
| def solve(S, T):
L1 = len(S)
L2 = len(T)
dp = [[0] * (L2 + 1) for i in range(L1 + 1)]
for i in range(L1 - 1, -1, -1):
for j in range(L2 - 1, -1, -1):
r = max(dp[i + 1][j], dp[i][j + 1])
if S[i] == T[j]:
r = max(r, dp[i + 1][j + 1] + 1)
dp[i][j] = r
# dp[0][0] が長さの解
# ここからは復元処理
res = []
i = 0
j = 0
while i < L1 and j < L2:
if S[i] == T[j]:
res.append(S[i])
i += 1
j += 1
elif dp[i][j] == dp[i + 1][j]:
i += 1
elif dp[i][j] == dp[i][j + 1]:
j += 1
return "".join(res)
S = eval(input())
T = eval(input())
print((solve(S, T)))
| false | 13.333333 | [
"-s = eval(input())",
"-t = eval(input())",
"-S, T = len(s), len(t)",
"-dp = [[0] * (T + 1) for _ in range(S + 1)]",
"-prev = [[(-1, -1)] * (T + 1) for _ in range(S + 1)]",
"-for i in range(S):",
"- for j in range(T):",
"- r = max(dp[i][j - 1], dp[i - 1][j])",
"- p = (i, j - 1) if r == dp[i][j - 1] else (i - 1, j)",
"- if s[i] == t[j]:",
"- r = max(dp[i - 1][j - 1] + 1, r)",
"- p = (i - 1, j - 1) if r == dp[i - 1][j - 1] + 1 else p",
"- dp[i][j] = r",
"- prev[i][j] = p",
"-ans = \"\"",
"-i, j = S - 1, T - 1",
"-while i >= 0 and j >= 0:",
"- if prev[i][j] == (i - 1, j - 1):",
"- ans += s[i]",
"- i, j = prev[i][j]",
"-print((ans[::-1]))",
"+def solve(S, T):",
"+ L1 = len(S)",
"+ L2 = len(T)",
"+ dp = [[0] * (L2 + 1) for i in range(L1 + 1)]",
"+ for i in range(L1 - 1, -1, -1):",
"+ for j in range(L2 - 1, -1, -1):",
"+ r = max(dp[i + 1][j], dp[i][j + 1])",
"+ if S[i] == T[j]:",
"+ r = max(r, dp[i + 1][j + 1] + 1)",
"+ dp[i][j] = r",
"+ # dp[0][0] が長さの解",
"+ # ここからは復元処理",
"+ res = []",
"+ i = 0",
"+ j = 0",
"+ while i < L1 and j < L2:",
"+ if S[i] == T[j]:",
"+ res.append(S[i])",
"+ i += 1",
"+ j += 1",
"+ elif dp[i][j] == dp[i + 1][j]:",
"+ i += 1",
"+ elif dp[i][j] == dp[i][j + 1]:",
"+ j += 1",
"+ return \"\".join(res)",
"+",
"+",
"+S = eval(input())",
"+T = eval(input())",
"+print((solve(S, T)))"
] | false | 0.073026 | 0.070611 | 1.034201 | [
"s239541483",
"s780614770"
] |
u716530146 | p03274 | python | s251474415 | s250550584 | 125 | 96 | 15,324 | 14,604 | Accepted | Accepted | 23.2 | #!/usr/bin/env python3
import sys, math, itertools, heapq, collections, bisect, string, copy
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')
sys.setrecursionlimit(10**8)
inf = float('inf')
mod = 10**9+7
ans = inf
count = 0; pro = 1
n, k = list(map(int, input().split()))
A=[]; B=[]
x=list(map(int,input().split()))
for i in range(n-(k-1)):
candi = max(abs(x[i+k-1]),abs(x[i]))
if x[i+k-1]*x[i]<0:
candi += 2*min(abs(x[i+k-1]), abs(x[i]))
ans = min(ans, candi)
print(ans)
| #!/usr/bin/env python3
import sys, math, itertools, collections, bisect
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')
inf = float('inf') ;mod = 10**9+7
mans = inf ;ans = 0 ;count = 0 ;pro = 1
n,k = list(map(int,input().split()))
X = list(map(int,input().split()))
for i in range(n-k+1):
fi = X[i]
en = X[i+k-1]
if fi <= 0 and en >= 0:
mans = min(mans,min(-fi,en)-fi+en)
else:
mans=min(mans,max(abs(fi),abs(en)))
print(mans) | 19 | 16 | 527 | 472 | #!/usr/bin/env python3
import sys, math, itertools, heapq, collections, bisect, string, copy
input = lambda: sys.stdin.buffer.readline().rstrip().decode("utf-8")
sys.setrecursionlimit(10**8)
inf = float("inf")
mod = 10**9 + 7
ans = inf
count = 0
pro = 1
n, k = list(map(int, input().split()))
A = []
B = []
x = list(map(int, input().split()))
for i in range(n - (k - 1)):
candi = max(abs(x[i + k - 1]), abs(x[i]))
if x[i + k - 1] * x[i] < 0:
candi += 2 * min(abs(x[i + k - 1]), abs(x[i]))
ans = min(ans, candi)
print(ans)
| #!/usr/bin/env python3
import sys, math, itertools, collections, bisect
input = lambda: sys.stdin.buffer.readline().rstrip().decode("utf-8")
inf = float("inf")
mod = 10**9 + 7
mans = inf
ans = 0
count = 0
pro = 1
n, k = list(map(int, input().split()))
X = list(map(int, input().split()))
for i in range(n - k + 1):
fi = X[i]
en = X[i + k - 1]
if fi <= 0 and en >= 0:
mans = min(mans, min(-fi, en) - fi + en)
else:
mans = min(mans, max(abs(fi), abs(en)))
print(mans)
| false | 15.789474 | [
"-import sys, math, itertools, heapq, collections, bisect, string, copy",
"+import sys, math, itertools, collections, bisect",
"-sys.setrecursionlimit(10**8)",
"-ans = inf",
"+mans = inf",
"+ans = 0",
"-A = []",
"-B = []",
"-x = list(map(int, input().split()))",
"-for i in range(n - (k - 1)):",
"- candi = max(abs(x[i + k - 1]), abs(x[i]))",
"- if x[i + k - 1] * x[i] < 0:",
"- candi += 2 * min(abs(x[i + k - 1]), abs(x[i]))",
"- ans = min(ans, candi)",
"-print(ans)",
"+X = list(map(int, input().split()))",
"+for i in range(n - k + 1):",
"+ fi = X[i]",
"+ en = X[i + k - 1]",
"+ if fi <= 0 and en >= 0:",
"+ mans = min(mans, min(-fi, en) - fi + en)",
"+ else:",
"+ mans = min(mans, max(abs(fi), abs(en)))",
"+print(mans)"
] | false | 0.076403 | 0.046885 | 1.629595 | [
"s251474415",
"s250550584"
] |
u197968862 | p02583 | python | s794009777 | s771236932 | 222 | 139 | 31,012 | 9,052 | Accepted | Accepted | 37.39 | n = int(eval(input()))
l = list(map(int,input().split()))
nums = set([])
for i in range(n):
for j in range(i,n):
for k in range(j,n):
if l[i] == l[j] or l[i] == l[k] or l[j] == l[k]:
continue
else:
ver = [l[i],l[j],l[k]]
num = [i,j,k]
ver.sort()
num.sort()
if ver[0] + ver[1] > ver[2]:
nums.add(tuple(num))
print((len(nums)))
| n = int(eval(input()))
l = list(map(int,input().split()))
ans = 0
for i in range(n):
for j in range(i,n):
for k in range(j,n):
if l[i] == l[j] or l[i] == l[k] or l[j] == l[k]:
continue
else:
ver = [l[i],l[j],l[k]]
ver.sort()
if ver[0] + ver[1] > ver[2]:
ans += 1
print(ans)
| 18 | 16 | 489 | 405 | n = int(eval(input()))
l = list(map(int, input().split()))
nums = set([])
for i in range(n):
for j in range(i, n):
for k in range(j, n):
if l[i] == l[j] or l[i] == l[k] or l[j] == l[k]:
continue
else:
ver = [l[i], l[j], l[k]]
num = [i, j, k]
ver.sort()
num.sort()
if ver[0] + ver[1] > ver[2]:
nums.add(tuple(num))
print((len(nums)))
| n = int(eval(input()))
l = list(map(int, input().split()))
ans = 0
for i in range(n):
for j in range(i, n):
for k in range(j, n):
if l[i] == l[j] or l[i] == l[k] or l[j] == l[k]:
continue
else:
ver = [l[i], l[j], l[k]]
ver.sort()
if ver[0] + ver[1] > ver[2]:
ans += 1
print(ans)
| false | 11.111111 | [
"-nums = set([])",
"+ans = 0",
"- num = [i, j, k]",
"- num.sort()",
"- nums.add(tuple(num))",
"-print((len(nums)))",
"+ ans += 1",
"+print(ans)"
] | false | 0.059124 | 0.036011 | 1.641841 | [
"s794009777",
"s771236932"
] |
u816631826 | p03853 | python | s025420604 | s598470047 | 37 | 18 | 4,596 | 3,060 | Accepted | Accepted | 51.35 | h,w = map(int, input().split())
stage = [list(input()) for i in range(h)]
ans = [0 for i in range(2*h)]
for i in range(h):
ans[2*i] = stage[i]
ans[2*i+1] = stage[i]
for i in ans:
for j in i:
print(j, end = "")
print()
| H, W = list(map(int, input().split()))
C = []
for i in range(H):
C.append(eval(input()))
for i in range(H):
print((C[i]))
print((C[i])) | 10 | 8 | 250 | 139 | h, w = map(int, input().split())
stage = [list(input()) for i in range(h)]
ans = [0 for i in range(2 * h)]
for i in range(h):
ans[2 * i] = stage[i]
ans[2 * i + 1] = stage[i]
for i in ans:
for j in i:
print(j, end="")
print()
| H, W = list(map(int, input().split()))
C = []
for i in range(H):
C.append(eval(input()))
for i in range(H):
print((C[i]))
print((C[i]))
| false | 20 | [
"-h, w = map(int, input().split())",
"-stage = [list(input()) for i in range(h)]",
"-ans = [0 for i in range(2 * h)]",
"-for i in range(h):",
"- ans[2 * i] = stage[i]",
"- ans[2 * i + 1] = stage[i]",
"-for i in ans:",
"- for j in i:",
"- print(j, end=\"\")",
"- print()",
"+H, W = list(map(int, input().split()))",
"+C = []",
"+for i in range(H):",
"+ C.append(eval(input()))",
"+for i in range(H):",
"+ print((C[i]))",
"+ print((C[i]))"
] | false | 0.037212 | 0.035002 | 1.063133 | [
"s025420604",
"s598470047"
] |
u627600101 | p02788 | python | s275065242 | s614235432 | 1,073 | 907 | 75,260 | 49,160 | Accepted | Accepted | 15.47 | N, D, A = list(map(int, input().split()))
monster = []
for k in range(N):
monster.append(list(map(int, input().split())))
monster.sort(key = lambda x: x[0])
for k in range(N):
monster[k][1] = int((monster[k][1]-0.1)//A + 1)
ans = 0
final = monster[-1][0]
ruiseki = 0
minuslist = []
j = 0
for k in range(N):
while (j < len(minuslist)):
if monster[k][0] >= minuslist[j][0]:
ruiseki -= minuslist[j][1]
j += 1
else:
break
if ruiseki < monster[k][1]:
ans += monster[k][1] - ruiseki
if monster[k][0] + 2*D +1 <= final:
minuslist.append([monster[k][0]+2*D+1, monster[k][1] - ruiseki])
ruiseki = monster[k][1]
print(ans)
| from collections import deque
N, D, A = list(map(int, input().split()))
monster = []
for k in range(N):
monster.append(list(map(int, input().split())))
monster.sort(key = lambda x: x[0])
for k in range(N):
monster[k][1] = int((monster[k][1]-0.1)//A + 1)
ans = 0
monster = deque(monster)
final = monster[-1][0]
ruiseki = 0
minuslist = deque()
while len(monster) > 0:
while len(minuslist) > 0:
if monster[0][0] >= minuslist[0][0]:
ruiseki -= minuslist[0][1]
minuslist.popleft()
else:
break
if ruiseki < monster[0][1]:
ans += monster[0][1] - ruiseki
if monster[0][0] + 2*D +1 <= final:
minuslist.append([monster[0][0]+2*D+1, monster[0][1] - ruiseki])
ruiseki = monster[0][1]
monster.popleft()
print(ans) | 28 | 29 | 689 | 778 | N, D, A = list(map(int, input().split()))
monster = []
for k in range(N):
monster.append(list(map(int, input().split())))
monster.sort(key=lambda x: x[0])
for k in range(N):
monster[k][1] = int((monster[k][1] - 0.1) // A + 1)
ans = 0
final = monster[-1][0]
ruiseki = 0
minuslist = []
j = 0
for k in range(N):
while j < len(minuslist):
if monster[k][0] >= minuslist[j][0]:
ruiseki -= minuslist[j][1]
j += 1
else:
break
if ruiseki < monster[k][1]:
ans += monster[k][1] - ruiseki
if monster[k][0] + 2 * D + 1 <= final:
minuslist.append([monster[k][0] + 2 * D + 1, monster[k][1] - ruiseki])
ruiseki = monster[k][1]
print(ans)
| from collections import deque
N, D, A = list(map(int, input().split()))
monster = []
for k in range(N):
monster.append(list(map(int, input().split())))
monster.sort(key=lambda x: x[0])
for k in range(N):
monster[k][1] = int((monster[k][1] - 0.1) // A + 1)
ans = 0
monster = deque(monster)
final = monster[-1][0]
ruiseki = 0
minuslist = deque()
while len(monster) > 0:
while len(minuslist) > 0:
if monster[0][0] >= minuslist[0][0]:
ruiseki -= minuslist[0][1]
minuslist.popleft()
else:
break
if ruiseki < monster[0][1]:
ans += monster[0][1] - ruiseki
if monster[0][0] + 2 * D + 1 <= final:
minuslist.append([monster[0][0] + 2 * D + 1, monster[0][1] - ruiseki])
ruiseki = monster[0][1]
monster.popleft()
print(ans)
| false | 3.448276 | [
"+from collections import deque",
"+",
"+monster = deque(monster)",
"-minuslist = []",
"-j = 0",
"-for k in range(N):",
"- while j < len(minuslist):",
"- if monster[k][0] >= minuslist[j][0]:",
"- ruiseki -= minuslist[j][1]",
"- j += 1",
"+minuslist = deque()",
"+while len(monster) > 0:",
"+ while len(minuslist) > 0:",
"+ if monster[0][0] >= minuslist[0][0]:",
"+ ruiseki -= minuslist[0][1]",
"+ minuslist.popleft()",
"- if ruiseki < monster[k][1]:",
"- ans += monster[k][1] - ruiseki",
"- if monster[k][0] + 2 * D + 1 <= final:",
"- minuslist.append([monster[k][0] + 2 * D + 1, monster[k][1] - ruiseki])",
"- ruiseki = monster[k][1]",
"+ if ruiseki < monster[0][1]:",
"+ ans += monster[0][1] - ruiseki",
"+ if monster[0][0] + 2 * D + 1 <= final:",
"+ minuslist.append([monster[0][0] + 2 * D + 1, monster[0][1] - ruiseki])",
"+ ruiseki = monster[0][1]",
"+ monster.popleft()"
] | false | 0.060331 | 0.092338 | 0.653375 | [
"s275065242",
"s614235432"
] |
u038021590 | p03700 | python | s499953438 | s216404128 | 609 | 202 | 30,508 | 106,612 | Accepted | Accepted | 66.83 | import numpy as np
N, A, B = list(map(int, input().split()))
H = np.zeros(shape=N, dtype='int64')
for _ in range(N):
h = int(eval(input()))
H[_] = h
def calc(num, a):
a -= num * B
a = (a - 1)//(A - B) + 1
if sum(a[a > 0]) <= num:
return True
else:
return False
start = 0
end = 10 ** 10
while end - start > 1:
mid = (start + end) // 2
if calc(mid, H.copy()):
end = mid
else:
start = mid
print(end)
| N, A, B = list(map(int, input().split()))
H = [int(eval(input())) for _ in range(N)]
def calc(num, a):
cnt = 0
for i, h in enumerate(a):
x = h - num * B
x = (x - 1) // (A - B) + 1
if x > 0:
cnt += x
if cnt <= num:
return True
else:
return False
start = 0
end = 10 ** 10
while end - start > 1:
mid = (start + end) // 2
if calc(mid, H[:]):
end = mid
else:
start = mid
print(end)
| 29 | 28 | 488 | 494 | import numpy as np
N, A, B = list(map(int, input().split()))
H = np.zeros(shape=N, dtype="int64")
for _ in range(N):
h = int(eval(input()))
H[_] = h
def calc(num, a):
a -= num * B
a = (a - 1) // (A - B) + 1
if sum(a[a > 0]) <= num:
return True
else:
return False
start = 0
end = 10**10
while end - start > 1:
mid = (start + end) // 2
if calc(mid, H.copy()):
end = mid
else:
start = mid
print(end)
| N, A, B = list(map(int, input().split()))
H = [int(eval(input())) for _ in range(N)]
def calc(num, a):
cnt = 0
for i, h in enumerate(a):
x = h - num * B
x = (x - 1) // (A - B) + 1
if x > 0:
cnt += x
if cnt <= num:
return True
else:
return False
start = 0
end = 10**10
while end - start > 1:
mid = (start + end) // 2
if calc(mid, H[:]):
end = mid
else:
start = mid
print(end)
| false | 3.448276 | [
"-import numpy as np",
"-",
"-H = np.zeros(shape=N, dtype=\"int64\")",
"-for _ in range(N):",
"- h = int(eval(input()))",
"- H[_] = h",
"+H = [int(eval(input())) for _ in range(N)]",
"- a -= num * B",
"- a = (a - 1) // (A - B) + 1",
"- if sum(a[a > 0]) <= num:",
"+ cnt = 0",
"+ for i, h in enumerate(a):",
"+ x = h - num * B",
"+ x = (x - 1) // (A - B) + 1",
"+ if x > 0:",
"+ cnt += x",
"+ if cnt <= num:",
"- if calc(mid, H.copy()):",
"+ if calc(mid, H[:]):"
] | false | 0.18947 | 0.057112 | 3.3175 | [
"s499953438",
"s216404128"
] |
u750822433 | p02707 | python | s926756432 | s571707723 | 275 | 158 | 52,492 | 32,304 | Accepted | Accepted | 42.55 | N = int(eval(input()))
A = list(map(int, input().split()))
d = {}
for i in range(N - 1):
if A[i] in d:
d[A[i]].append(i + 2)
else:
d[A[i]] = [i + 2]
for i in range(1, N + 1):
if i in d:
print((len(d[i])))
else:
print((0)) | N=int(eval(input()))
a=[int(i) for i in input().split()]
result=[0]*N
for i in a:
result[i-1]+=1
for i in range(N):
print((result[i]))
| 16 | 7 | 277 | 142 | N = int(eval(input()))
A = list(map(int, input().split()))
d = {}
for i in range(N - 1):
if A[i] in d:
d[A[i]].append(i + 2)
else:
d[A[i]] = [i + 2]
for i in range(1, N + 1):
if i in d:
print((len(d[i])))
else:
print((0))
| N = int(eval(input()))
a = [int(i) for i in input().split()]
result = [0] * N
for i in a:
result[i - 1] += 1
for i in range(N):
print((result[i]))
| false | 56.25 | [
"-A = list(map(int, input().split()))",
"-d = {}",
"-for i in range(N - 1):",
"- if A[i] in d:",
"- d[A[i]].append(i + 2)",
"- else:",
"- d[A[i]] = [i + 2]",
"-for i in range(1, N + 1):",
"- if i in d:",
"- print((len(d[i])))",
"- else:",
"- print((0))",
"+a = [int(i) for i in input().split()]",
"+result = [0] * N",
"+for i in a:",
"+ result[i - 1] += 1",
"+for i in range(N):",
"+ print((result[i]))"
] | false | 0.037409 | 0.037048 | 1.009753 | [
"s926756432",
"s571707723"
] |
u677121387 | p03476 | python | s586832973 | s650195056 | 671 | 440 | 12,756 | 13,360 | Accepted | Accepted | 34.43 | q = int(eval(input()))
ll = []
rr = []
for i in range(q):
l,r = list(map(int,input().split()))
ll.append(l)
rr.append(r)
m = min(ll)
M = max(rr)
cnt = [0]*(M+2)
def is_prime(n):
if n == 1:
return False
for i in range(2,int(n**0.5)+1):
if n%i == 0:
return False
return True
s = 0
for i in range(m,M+1,2):
if is_prime(i) and is_prime((i+1)//2):
s += 1
cnt[i] = s
for i in range(q):
print((cnt[rr[i]]-cnt[ll[i]-2])) | q = int(eval(input()))
ll = []
rr = []
for i in range(q):
l,r = list(map(int,input().split()))
ll.append(l)
rr.append(r)
def f(n):
flag = [True]*(n+1)
flag[0] = flag[1] = False
for i in range(2,int(n**0.5)+1):
if flag[i]:
x = 2*i
while x <= n:
flag[x] = False
x += i
return flag
m = max(rr)
j = f(m)
cnt = [0]*(m+1)
for i in range(1,m+1):
cnt[i] = cnt[i-1]
if i%2 != 0 and j[i] and j[(i+1)//2]:
cnt[i] += 1
for i in range(q):
print((cnt[rr[i]]-cnt[ll[i]-1])) | 28 | 29 | 501 | 587 | q = int(eval(input()))
ll = []
rr = []
for i in range(q):
l, r = list(map(int, input().split()))
ll.append(l)
rr.append(r)
m = min(ll)
M = max(rr)
cnt = [0] * (M + 2)
def is_prime(n):
if n == 1:
return False
for i in range(2, int(n**0.5) + 1):
if n % i == 0:
return False
return True
s = 0
for i in range(m, M + 1, 2):
if is_prime(i) and is_prime((i + 1) // 2):
s += 1
cnt[i] = s
for i in range(q):
print((cnt[rr[i]] - cnt[ll[i] - 2]))
| q = int(eval(input()))
ll = []
rr = []
for i in range(q):
l, r = list(map(int, input().split()))
ll.append(l)
rr.append(r)
def f(n):
flag = [True] * (n + 1)
flag[0] = flag[1] = False
for i in range(2, int(n**0.5) + 1):
if flag[i]:
x = 2 * i
while x <= n:
flag[x] = False
x += i
return flag
m = max(rr)
j = f(m)
cnt = [0] * (m + 1)
for i in range(1, m + 1):
cnt[i] = cnt[i - 1]
if i % 2 != 0 and j[i] and j[(i + 1) // 2]:
cnt[i] += 1
for i in range(q):
print((cnt[rr[i]] - cnt[ll[i] - 1]))
| false | 3.448276 | [
"-m = min(ll)",
"-M = max(rr)",
"-cnt = [0] * (M + 2)",
"-def is_prime(n):",
"- if n == 1:",
"- return False",
"+def f(n):",
"+ flag = [True] * (n + 1)",
"+ flag[0] = flag[1] = False",
"- if n % i == 0:",
"- return False",
"- return True",
"+ if flag[i]:",
"+ x = 2 * i",
"+ while x <= n:",
"+ flag[x] = False",
"+ x += i",
"+ return flag",
"-s = 0",
"-for i in range(m, M + 1, 2):",
"- if is_prime(i) and is_prime((i + 1) // 2):",
"- s += 1",
"- cnt[i] = s",
"+m = max(rr)",
"+j = f(m)",
"+cnt = [0] * (m + 1)",
"+for i in range(1, m + 1):",
"+ cnt[i] = cnt[i - 1]",
"+ if i % 2 != 0 and j[i] and j[(i + 1) // 2]:",
"+ cnt[i] += 1",
"- print((cnt[rr[i]] - cnt[ll[i] - 2]))",
"+ print((cnt[rr[i]] - cnt[ll[i] - 1]))"
] | false | 0.044062 | 0.09246 | 0.476552 | [
"s586832973",
"s650195056"
] |
u561083515 | p02777 | python | s265088370 | s964019618 | 20 | 17 | 3,316 | 2,940 | Accepted | Accepted | 15 | S,T = list(map(str,input().split()))
A,B = list(map(int,input().split()))
U = eval(input())
if S == U:
A -= 1
elif T == U:
B -= 1
print((A,B)) | S,T = list(map(str, input().split()))
A,B = list(map(int, input().split()))
U = eval(input())
if S == U:
A -= 1
else:
B -= 1
print((A,B)) | 10 | 10 | 141 | 136 | S, T = list(map(str, input().split()))
A, B = list(map(int, input().split()))
U = eval(input())
if S == U:
A -= 1
elif T == U:
B -= 1
print((A, B))
| S, T = list(map(str, input().split()))
A, B = list(map(int, input().split()))
U = eval(input())
if S == U:
A -= 1
else:
B -= 1
print((A, B))
| false | 0 | [
"-elif T == U:",
"+else:"
] | false | 0.042864 | 0.043369 | 0.988363 | [
"s265088370",
"s964019618"
] |
u008718882 | p02681 | python | s686419079 | s501219761 | 23 | 21 | 9,116 | 9,084 | Accepted | Accepted | 8.7 | S = eval(input())
T = eval(input())
def f(S, T):
if len(T) - len(S) != 1:
return 'No'
for i in range(len(S)):
if S[i] != T[i]:
return 'No'
return 'Yes'
print((f(S, T))) | S = eval(input())
T = eval(input())
def f():
if S == T[:len(T) - 1]:
return 'Yes'
else:
return 'No'
print((f()))
| 12 | 10 | 207 | 134 | S = eval(input())
T = eval(input())
def f(S, T):
if len(T) - len(S) != 1:
return "No"
for i in range(len(S)):
if S[i] != T[i]:
return "No"
return "Yes"
print((f(S, T)))
| S = eval(input())
T = eval(input())
def f():
if S == T[: len(T) - 1]:
return "Yes"
else:
return "No"
print((f()))
| false | 16.666667 | [
"-def f(S, T):",
"- if len(T) - len(S) != 1:",
"+def f():",
"+ if S == T[: len(T) - 1]:",
"+ return \"Yes\"",
"+ else:",
"- for i in range(len(S)):",
"- if S[i] != T[i]:",
"- return \"No\"",
"- return \"Yes\"",
"-print((f(S, T)))",
"+print((f()))"
] | false | 0.0429 | 0.041326 | 1.038098 | [
"s686419079",
"s501219761"
] |
u706414019 | p02608 | python | s753133514 | s866588853 | 917 | 107 | 9,564 | 69,404 | Accepted | Accepted | 88.33 | #AIsing2020 c
import sys,math,collections,itertools
input = sys.stdin.readline
N = int(eval(input()))
ans = [0]*N
for x in range(1,101):
for y in range(1,101):
for z in range(1,101):
n = x**2+y**2+z**2+x*y+y*z+z*x
if n <= N:
ans[n-1] +=1
for i in range(N):
print((ans[i]))
| #AIsing2020 c
import sys,math,collections,itertools
input = sys.stdin.readline
N = int(eval(input()))
ans = [0]*N
for x in range(1,101):
for y in range(x+1,101):
for z in range(y+1,101):
n = x**2+y**2+z**2+x*y+y*z+z*x
if n <= N:
ans[n-1] +=6
for x in range(1,101):
y = x
for z in range(1,101):
if z == x:
continue
else:
n = x**2+y**2+z**2+x*y+y*z+z*x
if n <= N:
ans[n-1] +=3
for x in range(1,101):
y = x
z = x
n = x**2+y**2+z**2+x*y+y*z+z*x
if n <= N:
ans[n-1] +=1
for i in range(N):
print((ans[i]))
| 19 | 35 | 370 | 724 | # AIsing2020 c
import sys, math, collections, itertools
input = sys.stdin.readline
N = int(eval(input()))
ans = [0] * N
for x in range(1, 101):
for y in range(1, 101):
for z in range(1, 101):
n = x**2 + y**2 + z**2 + x * y + y * z + z * x
if n <= N:
ans[n - 1] += 1
for i in range(N):
print((ans[i]))
| # AIsing2020 c
import sys, math, collections, itertools
input = sys.stdin.readline
N = int(eval(input()))
ans = [0] * N
for x in range(1, 101):
for y in range(x + 1, 101):
for z in range(y + 1, 101):
n = x**2 + y**2 + z**2 + x * y + y * z + z * x
if n <= N:
ans[n - 1] += 6
for x in range(1, 101):
y = x
for z in range(1, 101):
if z == x:
continue
else:
n = x**2 + y**2 + z**2 + x * y + y * z + z * x
if n <= N:
ans[n - 1] += 3
for x in range(1, 101):
y = x
z = x
n = x**2 + y**2 + z**2 + x * y + y * z + z * x
if n <= N:
ans[n - 1] += 1
for i in range(N):
print((ans[i]))
| false | 45.714286 | [
"- for y in range(1, 101):",
"- for z in range(1, 101):",
"+ for y in range(x + 1, 101):",
"+ for z in range(y + 1, 101):",
"- ans[n - 1] += 1",
"+ ans[n - 1] += 6",
"+for x in range(1, 101):",
"+ y = x",
"+ for z in range(1, 101):",
"+ if z == x:",
"+ continue",
"+ else:",
"+ n = x**2 + y**2 + z**2 + x * y + y * z + z * x",
"+ if n <= N:",
"+ ans[n - 1] += 3",
"+for x in range(1, 101):",
"+ y = x",
"+ z = x",
"+ n = x**2 + y**2 + z**2 + x * y + y * z + z * x",
"+ if n <= N:",
"+ ans[n - 1] += 1"
] | false | 1.752361 | 0.391546 | 4.475487 | [
"s753133514",
"s866588853"
] |
u285891772 | p03044 | python | s315942378 | s289017239 | 959 | 738 | 106,488 | 108,088 | Accepted | Accepted | 23.04 | import sys, re
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, tan, asin, acos, atan, radians, degrees#, log2
from collections import deque, defaultdict, Counter
from itertools import accumulate, permutations, combinations, combinations_with_replacement, product, groupby
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from fractions import gcd
from heapq import heappush, heappop, heapify
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(): return list(map(int, input().split()))
def ZIP(n): return list(zip(*(MAP() for _ in range(n))))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7
N = INT()
uvw = [LIST() for _ in range(N-1)]
graph = [[] for _ in range(N)]
for u, v, w in uvw:
graph[u-1].append([v-1, w])
graph[v-1].append([u-1, w])
#print(graph)
step = [-1]*N
step[0] = 0
def DFS(n):
for x, w in graph[n]:
#print(x, w)
if step[x] == -1:
if (w+step[n])%2:
step[x] = 1
else:
step[x] = 0
#print(step)
DFS(x)
DFS(0)
for ans in step:
print(ans)
| import sys, re
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, tan, asin, acos, atan, radians, degrees#, log2
from collections import deque, defaultdict, Counter
from itertools import accumulate, permutations, combinations, combinations_with_replacement, product, groupby
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from fractions import gcd
from heapq import heappush, heappop, heapify
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(): return list(map(int, input().split()))
def ZIP(n): return list(zip(*(MAP() for _ in range(n))))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7
N = INT()
uvw = [LIST() for _ in range(N-1)]
graph = defaultdict(list)
for u, v, w in uvw:
graph[u-1].append((v-1, w))
graph[v-1].append((u-1, w))
#print(graph)
color = [0]*N
color[0] = 1
def DFS(node):
for x, w in graph[node]:
if not color[x]:
if w%2 == 0:
color[x] = color[node]
else:
color[x] = color[node]*(-1)
DFS(x)
DFS(0)
for x in color:
if x == 1:
print((0))
elif x == -1:
print((1))
else:
print("HOGE")
| 50 | 56 | 1,289 | 1,349 | import sys, re
from math import (
ceil,
sqrt,
hypot,
factorial,
pi,
sin,
cos,
tan,
asin,
acos,
atan,
radians,
degrees,
) # , log2
from collections import deque, defaultdict, Counter
from itertools import (
accumulate,
permutations,
combinations,
combinations_with_replacement,
product,
groupby,
)
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from fractions import gcd
from heapq import heappush, heappop, heapify
from functools import reduce
def input():
return sys.stdin.readline().strip()
def INT():
return int(eval(input()))
def MAP():
return list(map(int, input().split()))
def LIST():
return list(map(int, input().split()))
def ZIP(n):
return list(zip(*(MAP() for _ in range(n))))
sys.setrecursionlimit(10**9)
INF = float("inf")
mod = 10**9 + 7
N = INT()
uvw = [LIST() for _ in range(N - 1)]
graph = [[] for _ in range(N)]
for u, v, w in uvw:
graph[u - 1].append([v - 1, w])
graph[v - 1].append([u - 1, w])
# print(graph)
step = [-1] * N
step[0] = 0
def DFS(n):
for x, w in graph[n]:
# print(x, w)
if step[x] == -1:
if (w + step[n]) % 2:
step[x] = 1
else:
step[x] = 0
# print(step)
DFS(x)
DFS(0)
for ans in step:
print(ans)
| import sys, re
from math import (
ceil,
sqrt,
hypot,
factorial,
pi,
sin,
cos,
tan,
asin,
acos,
atan,
radians,
degrees,
) # , log2
from collections import deque, defaultdict, Counter
from itertools import (
accumulate,
permutations,
combinations,
combinations_with_replacement,
product,
groupby,
)
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from fractions import gcd
from heapq import heappush, heappop, heapify
from functools import reduce
def input():
return sys.stdin.readline().strip()
def INT():
return int(eval(input()))
def MAP():
return list(map(int, input().split()))
def LIST():
return list(map(int, input().split()))
def ZIP(n):
return list(zip(*(MAP() for _ in range(n))))
sys.setrecursionlimit(10**9)
INF = float("inf")
mod = 10**9 + 7
N = INT()
uvw = [LIST() for _ in range(N - 1)]
graph = defaultdict(list)
for u, v, w in uvw:
graph[u - 1].append((v - 1, w))
graph[v - 1].append((u - 1, w))
# print(graph)
color = [0] * N
color[0] = 1
def DFS(node):
for x, w in graph[node]:
if not color[x]:
if w % 2 == 0:
color[x] = color[node]
else:
color[x] = color[node] * (-1)
DFS(x)
DFS(0)
for x in color:
if x == 1:
print((0))
elif x == -1:
print((1))
else:
print("HOGE")
| false | 10.714286 | [
"-graph = [[] for _ in range(N)]",
"+graph = defaultdict(list)",
"- graph[u - 1].append([v - 1, w])",
"- graph[v - 1].append([u - 1, w])",
"+ graph[u - 1].append((v - 1, w))",
"+ graph[v - 1].append((u - 1, w))",
"-step = [-1] * N",
"-step[0] = 0",
"+color = [0] * N",
"+color[0] = 1",
"-def DFS(n):",
"- for x, w in graph[n]:",
"- # print(x, w)",
"- if step[x] == -1:",
"- if (w + step[n]) % 2:",
"- step[x] = 1",
"+def DFS(node):",
"+ for x, w in graph[node]:",
"+ if not color[x]:",
"+ if w % 2 == 0:",
"+ color[x] = color[node]",
"- step[x] = 0",
"- # print(step)",
"+ color[x] = color[node] * (-1)",
"-for ans in step:",
"- print(ans)",
"+for x in color:",
"+ if x == 1:",
"+ print((0))",
"+ elif x == -1:",
"+ print((1))",
"+ else:",
"+ print(\"HOGE\")"
] | false | 0.100771 | 0.045736 | 2.203329 | [
"s315942378",
"s289017239"
] |
u284854859 | p02798 | python | s774280649 | s871886909 | 2,000 | 1,169 | 223,596 | 65,416 | Accepted | Accepted | 41.55 |
def main():
import sys
input = sys.stdin.readline
n = int(eval(input()))
a = tuple(map(int,input().split()))
b = tuple(map(int,input().split()))
dg = 20
pp = 20
dp = [10**5]*(10**7)
new = set([])
for i in range(n):
s = (1<<i)
dp[s*pp+i] = i
new.add(s*dg+i)
for k in range(n-1):
tank = set([])
if len(new) == 0:
break
for popelt in new:
s,idx = popelt//dg,popelt%dg
if (k-idx)%2 == 0:
fr = a[idx]
else:
fr = b[idx]
cnt = 0
for j in range(n):
if (s>>j)&1 == 0:
if (j-k)%2 == 1:
val = a[j]
else:
val = b[j]
if val >= fr and dp[(s+(1<<j))*pp+j] > dp[s*pp+idx]+j-cnt:
dp[(s+(1<<j))*pp+j] = dp[s*pp+idx]+j-cnt
tank.add((s+(1<<j))*dg + j)
else:
cnt += 1
new = tank
res = 10**5
s = (2**n-1)*pp
for i in range(n):
if res > dp[s+i]:
res = dp[s+i]
if res == 10**5:
print((-1))
else:
print(res)
if __name__ == '__main__':
main() | import sys
input = sys.stdin.readline
def count(P):
res = 0
#A1 ... AnのBIT(1-indexed)
BIT = [0]*(N+1)
#A1 ~ Aiまでの和 O(logN)
def BIT_query(idx):
res_sum = 0
while idx > 0:
res_sum += BIT[idx]
idx -= idx&(-idx)
return res_sum
#Ai += x O(logN)
def BIT_update(idx,x):
while idx <= N:
BIT[idx] += x
idx += idx&(-idx)
return
Pi = [None]*N
for i in range(N):
Pi[P[i]] = i
for i in range(N):
p = Pi[i]
res += i-BIT_query(p+1)
BIT_update(p+1, 1)
return res
N = int(eval(input()))
A = tuple(map(int,input().split()))
B = tuple(map(int,input().split()))
uhalf = -(-N//2)
dhalf = N - uhalf
inf = 10**9+7
ans = inf
for S in range(1<<N):
card = [A[i] if S&(1<<i) else B[i] for i in range(N)]
parity = [(1&(S>>i))^(i&1) for i in range(N)]
even = [(card[i], i) for i in range(N) if parity[i]]
odd = [(card[i], i) for i in range(N) if not parity[i]]
if len(even) != uhalf or len(odd) != dhalf:
continue
even.sort()
odd.sort()
if any(e[0] > o[0] for e, o in zip(even, odd)) or any(e[0] < o[0] for e, o in zip(even[1:], odd)):
continue
perm = [even[i//2][1] if not i&1 else odd[i//2][1] for i in range(N)]
ans = min(ans, count(perm))
print((ans if ans < inf else -1))
| 58 | 55 | 1,351 | 1,422 | def main():
import sys
input = sys.stdin.readline
n = int(eval(input()))
a = tuple(map(int, input().split()))
b = tuple(map(int, input().split()))
dg = 20
pp = 20
dp = [10**5] * (10**7)
new = set([])
for i in range(n):
s = 1 << i
dp[s * pp + i] = i
new.add(s * dg + i)
for k in range(n - 1):
tank = set([])
if len(new) == 0:
break
for popelt in new:
s, idx = popelt // dg, popelt % dg
if (k - idx) % 2 == 0:
fr = a[idx]
else:
fr = b[idx]
cnt = 0
for j in range(n):
if (s >> j) & 1 == 0:
if (j - k) % 2 == 1:
val = a[j]
else:
val = b[j]
if (
val >= fr
and dp[(s + (1 << j)) * pp + j] > dp[s * pp + idx] + j - cnt
):
dp[(s + (1 << j)) * pp + j] = dp[s * pp + idx] + j - cnt
tank.add((s + (1 << j)) * dg + j)
else:
cnt += 1
new = tank
res = 10**5
s = (2**n - 1) * pp
for i in range(n):
if res > dp[s + i]:
res = dp[s + i]
if res == 10**5:
print((-1))
else:
print(res)
if __name__ == "__main__":
main()
| import sys
input = sys.stdin.readline
def count(P):
res = 0
# A1 ... AnのBIT(1-indexed)
BIT = [0] * (N + 1)
# A1 ~ Aiまでの和 O(logN)
def BIT_query(idx):
res_sum = 0
while idx > 0:
res_sum += BIT[idx]
idx -= idx & (-idx)
return res_sum
# Ai += x O(logN)
def BIT_update(idx, x):
while idx <= N:
BIT[idx] += x
idx += idx & (-idx)
return
Pi = [None] * N
for i in range(N):
Pi[P[i]] = i
for i in range(N):
p = Pi[i]
res += i - BIT_query(p + 1)
BIT_update(p + 1, 1)
return res
N = int(eval(input()))
A = tuple(map(int, input().split()))
B = tuple(map(int, input().split()))
uhalf = -(-N // 2)
dhalf = N - uhalf
inf = 10**9 + 7
ans = inf
for S in range(1 << N):
card = [A[i] if S & (1 << i) else B[i] for i in range(N)]
parity = [(1 & (S >> i)) ^ (i & 1) for i in range(N)]
even = [(card[i], i) for i in range(N) if parity[i]]
odd = [(card[i], i) for i in range(N) if not parity[i]]
if len(even) != uhalf or len(odd) != dhalf:
continue
even.sort()
odd.sort()
if any(e[0] > o[0] for e, o in zip(even, odd)) or any(
e[0] < o[0] for e, o in zip(even[1:], odd)
):
continue
perm = [even[i // 2][1] if not i & 1 else odd[i // 2][1] for i in range(N)]
ans = min(ans, count(perm))
print((ans if ans < inf else -1))
| false | 5.172414 | [
"-def main():",
"- import sys",
"+import sys",
"- input = sys.stdin.readline",
"- n = int(eval(input()))",
"- a = tuple(map(int, input().split()))",
"- b = tuple(map(int, input().split()))",
"- dg = 20",
"- pp = 20",
"- dp = [10**5] * (10**7)",
"- new = set([])",
"- for i in range(n):",
"- s = 1 << i",
"- dp[s * pp + i] = i",
"- new.add(s * dg + i)",
"- for k in range(n - 1):",
"- tank = set([])",
"- if len(new) == 0:",
"- break",
"- for popelt in new:",
"- s, idx = popelt // dg, popelt % dg",
"- if (k - idx) % 2 == 0:",
"- fr = a[idx]",
"- else:",
"- fr = b[idx]",
"- cnt = 0",
"- for j in range(n):",
"- if (s >> j) & 1 == 0:",
"- if (j - k) % 2 == 1:",
"- val = a[j]",
"- else:",
"- val = b[j]",
"- if (",
"- val >= fr",
"- and dp[(s + (1 << j)) * pp + j] > dp[s * pp + idx] + j - cnt",
"- ):",
"- dp[(s + (1 << j)) * pp + j] = dp[s * pp + idx] + j - cnt",
"- tank.add((s + (1 << j)) * dg + j)",
"- else:",
"- cnt += 1",
"- new = tank",
"- res = 10**5",
"- s = (2**n - 1) * pp",
"- for i in range(n):",
"- if res > dp[s + i]:",
"- res = dp[s + i]",
"- if res == 10**5:",
"- print((-1))",
"- else:",
"- print(res)",
"+input = sys.stdin.readline",
"-if __name__ == \"__main__\":",
"- main()",
"+def count(P):",
"+ res = 0",
"+ # A1 ... AnのBIT(1-indexed)",
"+ BIT = [0] * (N + 1)",
"+ # A1 ~ Aiまでの和 O(logN)",
"+ def BIT_query(idx):",
"+ res_sum = 0",
"+ while idx > 0:",
"+ res_sum += BIT[idx]",
"+ idx -= idx & (-idx)",
"+ return res_sum",
"+",
"+ # Ai += x O(logN)",
"+ def BIT_update(idx, x):",
"+ while idx <= N:",
"+ BIT[idx] += x",
"+ idx += idx & (-idx)",
"+ return",
"+",
"+ Pi = [None] * N",
"+ for i in range(N):",
"+ Pi[P[i]] = i",
"+ for i in range(N):",
"+ p = Pi[i]",
"+ res += i - BIT_query(p + 1)",
"+ BIT_update(p + 1, 1)",
"+ return res",
"+",
"+",
"+N = int(eval(input()))",
"+A = tuple(map(int, input().split()))",
"+B = tuple(map(int, input().split()))",
"+uhalf = -(-N // 2)",
"+dhalf = N - uhalf",
"+inf = 10**9 + 7",
"+ans = inf",
"+for S in range(1 << N):",
"+ card = [A[i] if S & (1 << i) else B[i] for i in range(N)]",
"+ parity = [(1 & (S >> i)) ^ (i & 1) for i in range(N)]",
"+ even = [(card[i], i) for i in range(N) if parity[i]]",
"+ odd = [(card[i], i) for i in range(N) if not parity[i]]",
"+ if len(even) != uhalf or len(odd) != dhalf:",
"+ continue",
"+ even.sort()",
"+ odd.sort()",
"+ if any(e[0] > o[0] for e, o in zip(even, odd)) or any(",
"+ e[0] < o[0] for e, o in zip(even[1:], odd)",
"+ ):",
"+ continue",
"+ perm = [even[i // 2][1] if not i & 1 else odd[i // 2][1] for i in range(N)]",
"+ ans = min(ans, count(perm))",
"+print((ans if ans < inf else -1))"
] | false | 0.131311 | 0.046171 | 2.843996 | [
"s774280649",
"s871886909"
] |
u075012704 | p03546 | python | s377852920 | s868116333 | 198 | 87 | 40,668 | 73,988 | Accepted | Accepted | 56.06 | H, W = list(map(int, input().split()))
C = [list(map(int, input().split())) for i in range(10)]
G = [list(map(int, input().split())) for i in range(H)]
for k in range(10):
for i in range(10):
for j in range(10):
C[i][j] = min(C[i][j], C[i][k] + C[k][j])
ans = 0
for row in G:
for x in row:
if x >= 0:
ans += C[x][1]
print(ans)
| H, W = list(map(int, input().split()))
C = [list(map(int, input().split())) for _ in range(10)]
A = [list(map(int, input().split())) for _ in range(H)]
for k in range(10):
for i in range(10):
for j in range(10):
C[i][j] = min(C[i][j], C[i][k] + C[k][j])
ans = 0
for h in range(H):
for w in range(W):
if A[h][w] == -1:
continue
ans += C[A[h][w]][1]
print(ans)
| 16 | 19 | 387 | 432 | H, W = list(map(int, input().split()))
C = [list(map(int, input().split())) for i in range(10)]
G = [list(map(int, input().split())) for i in range(H)]
for k in range(10):
for i in range(10):
for j in range(10):
C[i][j] = min(C[i][j], C[i][k] + C[k][j])
ans = 0
for row in G:
for x in row:
if x >= 0:
ans += C[x][1]
print(ans)
| H, W = list(map(int, input().split()))
C = [list(map(int, input().split())) for _ in range(10)]
A = [list(map(int, input().split())) for _ in range(H)]
for k in range(10):
for i in range(10):
for j in range(10):
C[i][j] = min(C[i][j], C[i][k] + C[k][j])
ans = 0
for h in range(H):
for w in range(W):
if A[h][w] == -1:
continue
ans += C[A[h][w]][1]
print(ans)
| false | 15.789474 | [
"-C = [list(map(int, input().split())) for i in range(10)]",
"-G = [list(map(int, input().split())) for i in range(H)]",
"+C = [list(map(int, input().split())) for _ in range(10)]",
"+A = [list(map(int, input().split())) for _ in range(H)]",
"-for row in G:",
"- for x in row:",
"- if x >= 0:",
"- ans += C[x][1]",
"+for h in range(H):",
"+ for w in range(W):",
"+ if A[h][w] == -1:",
"+ continue",
"+ ans += C[A[h][w]][1]"
] | false | 0.038253 | 0.03762 | 1.016814 | [
"s377852920",
"s868116333"
] |
u075595666 | p03999 | python | s693540188 | s189988357 | 20 | 18 | 3,064 | 3,060 | Accepted | Accepted | 10 | s = eval(input())
l = len(s)-1
ans = 0
for j in range(2**l):
L = 0
for i in range(l):
if (j>>i)&1 == 1:
m = s[L:i+1]
ans += int(m)
L = i+1
ans += int(s[L:])
print(ans) | def dfs(i, f):
if i == n - 1:
return sum(list(map(int, f.split("+"))))
# 式 f の末尾に "+" を追加するかしないかして次の数字を追加
return dfs(i + 1, f + s[i + 1]) + dfs(i + 1, f + "+" + s[i + 1])
s = eval(input())
n = len(s)
print((dfs(0, s[0]))) | 13 | 8 | 203 | 242 | s = eval(input())
l = len(s) - 1
ans = 0
for j in range(2**l):
L = 0
for i in range(l):
if (j >> i) & 1 == 1:
m = s[L : i + 1]
ans += int(m)
L = i + 1
ans += int(s[L:])
print(ans)
| def dfs(i, f):
if i == n - 1:
return sum(list(map(int, f.split("+"))))
# 式 f の末尾に "+" を追加するかしないかして次の数字を追加
return dfs(i + 1, f + s[i + 1]) + dfs(i + 1, f + "+" + s[i + 1])
s = eval(input())
n = len(s)
print((dfs(0, s[0])))
| false | 38.461538 | [
"+def dfs(i, f):",
"+ if i == n - 1:",
"+ return sum(list(map(int, f.split(\"+\"))))",
"+ # 式 f の末尾に \"+\" を追加するかしないかして次の数字を追加",
"+ return dfs(i + 1, f + s[i + 1]) + dfs(i + 1, f + \"+\" + s[i + 1])",
"+",
"+",
"-l = len(s) - 1",
"-ans = 0",
"-for j in range(2**l):",
"- L = 0",
"- for i in range(l):",
"- if (j >> i) & 1 == 1:",
"- m = s[L : i + 1]",
"- ans += int(m)",
"- L = i + 1",
"- ans += int(s[L:])",
"-print(ans)",
"+n = len(s)",
"+print((dfs(0, s[0])))"
] | false | 0.049569 | 0.04286 | 1.156541 | [
"s693540188",
"s189988357"
] |
u562935282 | p02720 | python | s997948564 | s210276613 | 133 | 95 | 12,404 | 11,972 | Accepted | Accepted | 28.57 | from collections import deque
K = int(eval(input()))
dq = deque()
for x in range(1, 10):
dq.append(x)
idx = 1
while idx < K:
x = dq.popleft()
idx += 1
r = x % 10
if r > 0:
nx = (x * 10) + (r - 1)
dq.append(nx)
nx = (x * 10) + (r)
dq.append(nx)
if r < 9:
nx = (x * 10) + (r + 1)
dq.append(nx)
ans = dq.popleft()
print(ans)
| def main():
from collections import deque
K = int(eval(input()))
dq = deque()
for x in range(1, 10):
dq.append(x)
idx = 0
while dq:
x = dq.popleft()
idx += 1
if idx == K:
print(x)
return
r = x % 10
if r > 0:
dq.append(x * 10 + r - 1)
dq.append(x * 10 + r)
if r < 9:
dq.append(x * 10 + r + 1)
if __name__ == '__main__':
main()
# import sys
#
# sys.setrecursionlimit(10 ** 7)
#
# input = sys.stdin.readline
# rstrip()
# int(input())
# map(int, input().split())
| 28 | 36 | 415 | 635 | from collections import deque
K = int(eval(input()))
dq = deque()
for x in range(1, 10):
dq.append(x)
idx = 1
while idx < K:
x = dq.popleft()
idx += 1
r = x % 10
if r > 0:
nx = (x * 10) + (r - 1)
dq.append(nx)
nx = (x * 10) + (r)
dq.append(nx)
if r < 9:
nx = (x * 10) + (r + 1)
dq.append(nx)
ans = dq.popleft()
print(ans)
| def main():
from collections import deque
K = int(eval(input()))
dq = deque()
for x in range(1, 10):
dq.append(x)
idx = 0
while dq:
x = dq.popleft()
idx += 1
if idx == K:
print(x)
return
r = x % 10
if r > 0:
dq.append(x * 10 + r - 1)
dq.append(x * 10 + r)
if r < 9:
dq.append(x * 10 + r + 1)
if __name__ == "__main__":
main()
# import sys
#
# sys.setrecursionlimit(10 ** 7)
#
# input = sys.stdin.readline
# rstrip()
# int(input())
# map(int, input().split())
| false | 22.222222 | [
"-from collections import deque",
"+def main():",
"+ from collections import deque",
"-K = int(eval(input()))",
"-dq = deque()",
"-for x in range(1, 10):",
"- dq.append(x)",
"-idx = 1",
"-while idx < K:",
"- x = dq.popleft()",
"- idx += 1",
"- r = x % 10",
"- if r > 0:",
"- nx = (x * 10) + (r - 1)",
"- dq.append(nx)",
"- nx = (x * 10) + (r)",
"- dq.append(nx)",
"- if r < 9:",
"- nx = (x * 10) + (r + 1)",
"- dq.append(nx)",
"-ans = dq.popleft()",
"-print(ans)",
"+ K = int(eval(input()))",
"+ dq = deque()",
"+ for x in range(1, 10):",
"+ dq.append(x)",
"+ idx = 0",
"+ while dq:",
"+ x = dq.popleft()",
"+ idx += 1",
"+ if idx == K:",
"+ print(x)",
"+ return",
"+ r = x % 10",
"+ if r > 0:",
"+ dq.append(x * 10 + r - 1)",
"+ dq.append(x * 10 + r)",
"+ if r < 9:",
"+ dq.append(x * 10 + r + 1)",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ main()",
"+# import sys",
"+#",
"+# sys.setrecursionlimit(10 ** 7)",
"+#",
"+# input = sys.stdin.readline",
"+# rstrip()",
"+# int(input())",
"+# map(int, input().split())"
] | false | 0.067397 | 0.043285 | 1.557034 | [
"s997948564",
"s210276613"
] |
u151171672 | p03163 | python | s266385103 | s686716989 | 416 | 243 | 119,408 | 40,432 | Accepted | Accepted | 41.59 | def solve(items, n, w):
f = [[0] * (w + 1) for _ in range(n + 1)]
for i in range(1, n + 1):
wi, vi = items[i-1]
for j in range(w + 1):
f[i][j] = f[i-1][j]
if j >= wi:
f[i][j] = max(f[i][j], f[i-1][j-wi] + vi)
return f[n][w]
def main():
inp = lambda: [int(x) for x in input().split()]
n, w = inp()
items = [inp() for _ in range(n)]
print((solve(items, n, w)))
if __name__ == '__main__':
main()
| def solve(items, n, w):
dp = [0] * (w+1)
for i in range(n):
wi, vi = items[i]
for j in range(w, wi-1, -1):
dp[j] = max(dp[j], dp[j-wi] + vi)
return dp[w]
def main():
inp = lambda: [int(x) for x in input().split()]
n, w = inp()
items = [inp() for _ in range(n)]
print((solve(items, n, w)))
if __name__ == '__main__':
main()
| 20 | 19 | 502 | 404 | def solve(items, n, w):
f = [[0] * (w + 1) for _ in range(n + 1)]
for i in range(1, n + 1):
wi, vi = items[i - 1]
for j in range(w + 1):
f[i][j] = f[i - 1][j]
if j >= wi:
f[i][j] = max(f[i][j], f[i - 1][j - wi] + vi)
return f[n][w]
def main():
inp = lambda: [int(x) for x in input().split()]
n, w = inp()
items = [inp() for _ in range(n)]
print((solve(items, n, w)))
if __name__ == "__main__":
main()
| def solve(items, n, w):
dp = [0] * (w + 1)
for i in range(n):
wi, vi = items[i]
for j in range(w, wi - 1, -1):
dp[j] = max(dp[j], dp[j - wi] + vi)
return dp[w]
def main():
inp = lambda: [int(x) for x in input().split()]
n, w = inp()
items = [inp() for _ in range(n)]
print((solve(items, n, w)))
if __name__ == "__main__":
main()
| false | 5 | [
"- f = [[0] * (w + 1) for _ in range(n + 1)]",
"- for i in range(1, n + 1):",
"- wi, vi = items[i - 1]",
"- for j in range(w + 1):",
"- f[i][j] = f[i - 1][j]",
"- if j >= wi:",
"- f[i][j] = max(f[i][j], f[i - 1][j - wi] + vi)",
"- return f[n][w]",
"+ dp = [0] * (w + 1)",
"+ for i in range(n):",
"+ wi, vi = items[i]",
"+ for j in range(w, wi - 1, -1):",
"+ dp[j] = max(dp[j], dp[j - wi] + vi)",
"+ return dp[w]"
] | false | 0.058562 | 0.039608 | 1.478542 | [
"s266385103",
"s686716989"
] |
u905203728 | p03775 | python | s277530424 | s055133863 | 36 | 30 | 3,064 | 2,940 | Accepted | Accepted | 16.67 | n=int(eval(input()))
if n==6983776800:print((5));exit()
def prime_factorize(n):
a=[]
while n%2==0:
a.append(2)
n //=2
f=3
while f**2<=n:
if n%f==0:
a.append(f)
n //=f
else:f +=2
if n!=1:a.append(n)
return a
F=prime_factorize(n)
A,B=1,1
for i in F[::-1]:
if A<=B:A *=i
else:B *=i
print((max(len(str(A)),len(str(B))))) | ans=100
n=int(eval(input()))
for i in range(1,int(n**0.5)+1):
if n%i==0:
a,b=str(i),str(n//i)
ans=min(ans,max(len(a),len(b)))
print(ans) | 24 | 7 | 420 | 156 | n = int(eval(input()))
if n == 6983776800:
print((5))
exit()
def prime_factorize(n):
a = []
while n % 2 == 0:
a.append(2)
n //= 2
f = 3
while f**2 <= n:
if n % f == 0:
a.append(f)
n //= f
else:
f += 2
if n != 1:
a.append(n)
return a
F = prime_factorize(n)
A, B = 1, 1
for i in F[::-1]:
if A <= B:
A *= i
else:
B *= i
print((max(len(str(A)), len(str(B)))))
| ans = 100
n = int(eval(input()))
for i in range(1, int(n**0.5) + 1):
if n % i == 0:
a, b = str(i), str(n // i)
ans = min(ans, max(len(a), len(b)))
print(ans)
| false | 70.833333 | [
"+ans = 100",
"-if n == 6983776800:",
"- print((5))",
"- exit()",
"-",
"-",
"-def prime_factorize(n):",
"- a = []",
"- while n % 2 == 0:",
"- a.append(2)",
"- n //= 2",
"- f = 3",
"- while f**2 <= n:",
"- if n % f == 0:",
"- a.append(f)",
"- n //= f",
"- else:",
"- f += 2",
"- if n != 1:",
"- a.append(n)",
"- return a",
"-",
"-",
"-F = prime_factorize(n)",
"-A, B = 1, 1",
"-for i in F[::-1]:",
"- if A <= B:",
"- A *= i",
"- else:",
"- B *= i",
"-print((max(len(str(A)), len(str(B)))))",
"+for i in range(1, int(n**0.5) + 1):",
"+ if n % i == 0:",
"+ a, b = str(i), str(n // i)",
"+ ans = min(ans, max(len(a), len(b)))",
"+print(ans)"
] | false | 0.036512 | 0.040609 | 0.899127 | [
"s277530424",
"s055133863"
] |
u098012509 | p02698 | python | s327626694 | s389482626 | 1,331 | 760 | 124,056 | 207,328 | Accepted | Accepted | 42.9 | import sys
import bisect
import collections
sys.setrecursionlimit(10 ** 8)
input = sys.stdin.readline
def main():
N = int(eval(input()))
A = [int(x) for x in input().split()]
UV = [[int(x) for x in input().split()] for _ in range(N - 1)]
T = [[] for j in range(N + 1)]
for u, v in UV:
T[u].append(v)
T[v].append(u)
s = collections.deque()
lis = []
s.append([1, lis])
v = set()
ans = [0] * (N + 1)
memo = [[] for j in range(N + 1)]
while s:
c = s[-1]
ci, clis = c[0], c[1]
# lis処理
if ci not in v:
if len(clis) == 0:
clis.append(A[ci - 1])
memo[ci].append(-1)
else:
if clis[-1] < A[ci - 1]:
clis.append(A[ci - 1])
memo[ci].append(-1)
else:
i = bisect.bisect_left(clis, A[ci - 1])
memo[ci].append(i)
memo[ci].append(clis[i])
clis[i] = A[ci - 1]
v.add(ci)
ans[ci] = len(clis)
if len(T[ci]) >= 1:
n = T[ci].pop()
if n in v:
continue
s.append([n, clis])
continue
if memo[ci][0] == -1:
if len(clis) >= 1:
clis.pop()
else:
clis[memo[ci][0]] = memo[ci][1]
s.pop()
for i in range(1, N + 1):
print((ans[i]))
if __name__ == '__main__':
main()
| import sys
import bisect
import collections
sys.setrecursionlimit(10 ** 8)
input = sys.stdin.readline
def main():
N = int(eval(input()))
A = [int(x) for x in input().split()]
UV = [[int(x) for x in input().split()] for _ in range(N - 1)]
T = [[] for j in range(N + 1)]
for u, v in UV:
T[u].append(v)
T[v].append(u)
s = collections.deque()
lis = []
s.append([1, lis])
v = set()
ans = [0] * (N + 1)
memo = [[] for j in range(N + 1)]
while s:
c = s[-1]
ci = c[0]
# lis処理
if ci not in v:
if len(lis) == 0:
lis.append(A[ci - 1])
memo[ci].append(-1)
else:
if lis[-1] < A[ci - 1]:
lis.append(A[ci - 1])
memo[ci].append(-1)
else:
i = bisect.bisect_left(lis, A[ci - 1])
memo[ci].append(i)
memo[ci].append(lis[i])
lis[i] = A[ci - 1]
v.add(ci)
ans[ci] = len(lis)
if len(T[ci]) >= 1:
n = T[ci].pop()
if n in v:
continue
s.append([n, lis])
continue
if memo[ci][0] == -1:
if len(lis) >= 1:
lis.pop()
else:
lis[memo[ci][0]] = memo[ci][1]
s.pop()
for i in range(1, N + 1):
print((ans[i]))
if __name__ == '__main__':
main()
| 73 | 73 | 1,594 | 1,570 | import sys
import bisect
import collections
sys.setrecursionlimit(10**8)
input = sys.stdin.readline
def main():
N = int(eval(input()))
A = [int(x) for x in input().split()]
UV = [[int(x) for x in input().split()] for _ in range(N - 1)]
T = [[] for j in range(N + 1)]
for u, v in UV:
T[u].append(v)
T[v].append(u)
s = collections.deque()
lis = []
s.append([1, lis])
v = set()
ans = [0] * (N + 1)
memo = [[] for j in range(N + 1)]
while s:
c = s[-1]
ci, clis = c[0], c[1]
# lis処理
if ci not in v:
if len(clis) == 0:
clis.append(A[ci - 1])
memo[ci].append(-1)
else:
if clis[-1] < A[ci - 1]:
clis.append(A[ci - 1])
memo[ci].append(-1)
else:
i = bisect.bisect_left(clis, A[ci - 1])
memo[ci].append(i)
memo[ci].append(clis[i])
clis[i] = A[ci - 1]
v.add(ci)
ans[ci] = len(clis)
if len(T[ci]) >= 1:
n = T[ci].pop()
if n in v:
continue
s.append([n, clis])
continue
if memo[ci][0] == -1:
if len(clis) >= 1:
clis.pop()
else:
clis[memo[ci][0]] = memo[ci][1]
s.pop()
for i in range(1, N + 1):
print((ans[i]))
if __name__ == "__main__":
main()
| import sys
import bisect
import collections
sys.setrecursionlimit(10**8)
input = sys.stdin.readline
def main():
N = int(eval(input()))
A = [int(x) for x in input().split()]
UV = [[int(x) for x in input().split()] for _ in range(N - 1)]
T = [[] for j in range(N + 1)]
for u, v in UV:
T[u].append(v)
T[v].append(u)
s = collections.deque()
lis = []
s.append([1, lis])
v = set()
ans = [0] * (N + 1)
memo = [[] for j in range(N + 1)]
while s:
c = s[-1]
ci = c[0]
# lis処理
if ci not in v:
if len(lis) == 0:
lis.append(A[ci - 1])
memo[ci].append(-1)
else:
if lis[-1] < A[ci - 1]:
lis.append(A[ci - 1])
memo[ci].append(-1)
else:
i = bisect.bisect_left(lis, A[ci - 1])
memo[ci].append(i)
memo[ci].append(lis[i])
lis[i] = A[ci - 1]
v.add(ci)
ans[ci] = len(lis)
if len(T[ci]) >= 1:
n = T[ci].pop()
if n in v:
continue
s.append([n, lis])
continue
if memo[ci][0] == -1:
if len(lis) >= 1:
lis.pop()
else:
lis[memo[ci][0]] = memo[ci][1]
s.pop()
for i in range(1, N + 1):
print((ans[i]))
if __name__ == "__main__":
main()
| false | 0 | [
"- ci, clis = c[0], c[1]",
"+ ci = c[0]",
"- if len(clis) == 0:",
"- clis.append(A[ci - 1])",
"+ if len(lis) == 0:",
"+ lis.append(A[ci - 1])",
"- if clis[-1] < A[ci - 1]:",
"- clis.append(A[ci - 1])",
"+ if lis[-1] < A[ci - 1]:",
"+ lis.append(A[ci - 1])",
"- i = bisect.bisect_left(clis, A[ci - 1])",
"+ i = bisect.bisect_left(lis, A[ci - 1])",
"- memo[ci].append(clis[i])",
"- clis[i] = A[ci - 1]",
"+ memo[ci].append(lis[i])",
"+ lis[i] = A[ci - 1]",
"- ans[ci] = len(clis)",
"+ ans[ci] = len(lis)",
"- s.append([n, clis])",
"+ s.append([n, lis])",
"- if len(clis) >= 1:",
"- clis.pop()",
"+ if len(lis) >= 1:",
"+ lis.pop()",
"- clis[memo[ci][0]] = memo[ci][1]",
"+ lis[memo[ci][0]] = memo[ci][1]"
] | false | 0.080235 | 0.065182 | 1.230946 | [
"s327626694",
"s389482626"
] |
u581187895 | p03044 | python | s364825321 | s147964534 | 702 | 626 | 79,408 | 40,700 | Accepted | Accepted | 10.83 | import sys
sys.setrecursionlimit(10 ** 7)
N = int(input())
G = [[] for _ in range(N+1)]
for _ in range(N-1):
v, u, w = map(int, input().split())
G[v].append((u, w))
G[u].append((v, w))
res = [0]*(N+1)
# 現在頂点v を c に塗る。p は v の親
def dfs(v, p, c):
res[v] = c
for e, w in G[v]:
if e == p:
continue
if w&1:
# エッジの重みが奇数だったら、次のノードは異色 1-c で塗る
dfs(e, v, 1-c)
else:
#エッジの重みが偶数だったら、次のノードも同色 c で塗る
dfs(e, v, c)
# res:start[1:] even:cor==0
dfs(1, 0, 0)
[print(r) for r in res[1:]]
| import sys
from collections import deque
sys.setrecursionlimit(10 ** 7)
N = int(input())
G = [[] for _ in range(N+1)]
for _ in range(N-1):
v, u, w = map(int, input().split())
G[v].append((u, w))
G[u].append((v, w))
deq = deque()
deq.append(1)
res = [-1]*(N+1)
res[1] = 0
while deq:
x = deq.popleft()
for e, w in G[x]:
if res[e] == -1:
res[e] = (res[x]+w)%2
deq.append(e)
[print(r) for r in res[1:]]
| 27 | 24 | 563 | 451 | import sys
sys.setrecursionlimit(10**7)
N = int(input())
G = [[] for _ in range(N + 1)]
for _ in range(N - 1):
v, u, w = map(int, input().split())
G[v].append((u, w))
G[u].append((v, w))
res = [0] * (N + 1)
# 現在頂点v を c に塗る。p は v の親
def dfs(v, p, c):
res[v] = c
for e, w in G[v]:
if e == p:
continue
if w & 1:
# エッジの重みが奇数だったら、次のノードは異色 1-c で塗る
dfs(e, v, 1 - c)
else:
# エッジの重みが偶数だったら、次のノードも同色 c で塗る
dfs(e, v, c)
# res:start[1:] even:cor==0
dfs(1, 0, 0)
[print(r) for r in res[1:]]
| import sys
from collections import deque
sys.setrecursionlimit(10**7)
N = int(input())
G = [[] for _ in range(N + 1)]
for _ in range(N - 1):
v, u, w = map(int, input().split())
G[v].append((u, w))
G[u].append((v, w))
deq = deque()
deq.append(1)
res = [-1] * (N + 1)
res[1] = 0
while deq:
x = deq.popleft()
for e, w in G[x]:
if res[e] == -1:
res[e] = (res[x] + w) % 2
deq.append(e)
[print(r) for r in res[1:]]
| false | 11.111111 | [
"+from collections import deque",
"-res = [0] * (N + 1)",
"-# 現在頂点v を c に塗る。p は v の親",
"-def dfs(v, p, c):",
"- res[v] = c",
"- for e, w in G[v]:",
"- if e == p:",
"- continue",
"- if w & 1:",
"- # エッジの重みが奇数だったら、次のノードは異色 1-c で塗る",
"- dfs(e, v, 1 - c)",
"- else:",
"- # エッジの重みが偶数だったら、次のノードも同色 c で塗る",
"- dfs(e, v, c)",
"-",
"-",
"-# res:start[1:] even:cor==0",
"-dfs(1, 0, 0)",
"+deq = deque()",
"+deq.append(1)",
"+res = [-1] * (N + 1)",
"+res[1] = 0",
"+while deq:",
"+ x = deq.popleft()",
"+ for e, w in G[x]:",
"+ if res[e] == -1:",
"+ res[e] = (res[x] + w) % 2",
"+ deq.append(e)"
] | false | 0.007621 | 0.043261 | 0.17616 | [
"s364825321",
"s147964534"
] |
u556589653 | p03048 | python | s828448918 | s628423360 | 379 | 271 | 40,684 | 40,684 | Accepted | Accepted | 28.5 | R,G,B,N = list(map(int,input().split()))
ans = 0
for i in range(0,N//R+1):
for j in range(0,N//G+1):
k = N - i*R -j*G
if k%B == 0 and k>= 0:
ans += 1
print(ans)
| R,G,B,N = list(map(int,input().split()))
ans = 0
for i in range(0,N//R+1):
for j in range(0,(N-i*R)//G+1):
k = N - i*R -j*G
if k%B == 0 and k>= 0:
ans += 1
print(ans)
| 8 | 8 | 178 | 184 | R, G, B, N = list(map(int, input().split()))
ans = 0
for i in range(0, N // R + 1):
for j in range(0, N // G + 1):
k = N - i * R - j * G
if k % B == 0 and k >= 0:
ans += 1
print(ans)
| R, G, B, N = list(map(int, input().split()))
ans = 0
for i in range(0, N // R + 1):
for j in range(0, (N - i * R) // G + 1):
k = N - i * R - j * G
if k % B == 0 and k >= 0:
ans += 1
print(ans)
| false | 0 | [
"- for j in range(0, N // G + 1):",
"+ for j in range(0, (N - i * R) // G + 1):"
] | false | 0.136399 | 0.206139 | 0.661683 | [
"s828448918",
"s628423360"
] |
u227082700 | p03378 | python | s352684298 | s131320920 | 20 | 17 | 3,060 | 3,060 | Accepted | Accepted | 15 | n,m,x=list(map(int,input().split()))
a=list(map(int,input().split()))
b=[0+(i in a)for i in range(n+1)]
print((min(sum(b[:x]),sum(b[x:])))) | from bisect import bisect_left
n,m,x=list(map(int,input().split()))
a=list(map(int,input().split()))
b=bisect_left(a,x)
print((min(b,m-b))) | 4 | 5 | 134 | 135 | n, m, x = list(map(int, input().split()))
a = list(map(int, input().split()))
b = [0 + (i in a) for i in range(n + 1)]
print((min(sum(b[:x]), sum(b[x:]))))
| from bisect import bisect_left
n, m, x = list(map(int, input().split()))
a = list(map(int, input().split()))
b = bisect_left(a, x)
print((min(b, m - b)))
| false | 20 | [
"+from bisect import bisect_left",
"+",
"-b = [0 + (i in a) for i in range(n + 1)]",
"-print((min(sum(b[:x]), sum(b[x:]))))",
"+b = bisect_left(a, x)",
"+print((min(b, m - b)))"
] | false | 0.047709 | 0.007515 | 6.348278 | [
"s352684298",
"s131320920"
] |
u506858457 | p02862 | python | s939690106 | s778187409 | 1,634 | 219 | 3,064 | 29,428 | Accepted | Accepted | 86.6 | '''
Aは移動関数と同数：xとy方向に合計で3進んでいるから
Bは移動回数の内、(i+1,j+2)を選んだ回数：
1回でx方向には1進み、y方向には2進む
進み方は2通りしかないので、全体の内、1通りを選んだ回数を求めればOK
'''
X,Y=list(map(int,input().split()))
if (X+Y)%3!=0:#まず、条件に合わないケースを除外
print((0))
exit()
A=int((X+Y)/3)
B=int((2*Y-X)/3)
if A<0 or B<0:
print((0))
exit()
MOD=10**9+7
def comb(n,k):#組合せを求める関数
tmp=1
for i in range(n-k+1,n+1):#分子：n*(n-1)*...*(n-k+1)
tmp*=i
tmp%=MOD
for i in range(1,k+1):#分母：k!
tmp*=pow(i,MOD-2,MOD)#分母なので逆元にする
tmp%=MOD
return tmp
ans = comb(A,B)#上記説明の通り。要は組み合わせの問題
print((ans%MOD)) | #ika tako
'''
A.ダメなケースを除外できるか、B.組合せの数を問題に応じて求められるか
階乗や逆元はfor文で求める。
ダメなケースを除外した上で、最終X,Y に行くには、二つの選択肢
(i+1,j+2),(i+2,j+1)の組合せの数を求める。
組合せの数を求める時は、階乗と逆元を使う。
逆元は一通り、全て求めておいて、配列invsに格納して、後で使う。
'''
def prepare(n, MOD):
f = 1
for m in range(1, n + 1):
f = f * m % MOD
fn = f#n!を求める
inv = pow(f, MOD - 2, MOD)
invs = [1] * (n + 1)#[1, 1, 1]のイメージ、逆元？格納テーブル
invs[n] = inv#配列の一番最後のデータ
for m in range(n, 1, -1):#n*(n-1)*(n-2)*...と上から掛けている
inv = inv * m % MOD#逆元を一通り、求めて、配列invsに格納する
invs[m - 1] = inv
return fn, invs
def solve(x, y):#ダメなケースの除外
d, m = divmod(x + y, 3)#商と余り
if m != 0 or x < d or y < d:
#Xとyの合計は3の倍数、x、yがd移動回数以下はあり得ない（1回1個は進む）
return 0
#c = d - x これだと範囲外参照でエラー
c = abs(d - x)#nCr=nC(n-r)、Cの後ろのrと(n-r)を入れ替えても同じ
MOD = 10 ** 9 + 7
f, invs = prepare(d, MOD)
return f * invs[c] * invs[d - c] % MOD
#fはn!、invs[c],invs[d - c] はc!,(d-c)!の逆元？
#nCr=n!/(r!*(n-r)!)
x, y = list(map(int, input().split()))
print((solve(x, y))) | 27 | 40 | 557 | 1,062 | """
Aは移動関数と同数：xとy方向に合計で3進んでいるから
Bは移動回数の内、(i+1,j+2)を選んだ回数：
1回でx方向には1進み、y方向には2進む
進み方は2通りしかないので、全体の内、1通りを選んだ回数を求めればOK
"""
X, Y = list(map(int, input().split()))
if (X + Y) % 3 != 0: # まず、条件に合わないケースを除外
print((0))
exit()
A = int((X + Y) / 3)
B = int((2 * Y - X) / 3)
if A < 0 or B < 0:
print((0))
exit()
MOD = 10**9 + 7
def comb(n, k): # 組合せを求める関数
tmp = 1
for i in range(n - k + 1, n + 1): # 分子：n*(n-1)*...*(n-k+1)
tmp *= i
tmp %= MOD
for i in range(1, k + 1): # 分母：k!
tmp *= pow(i, MOD - 2, MOD) # 分母なので逆元にする
tmp %= MOD
return tmp
ans = comb(A, B) # 上記説明の通り。要は組み合わせの問題
print((ans % MOD))
| # ika tako
"""
A.ダメなケースを除外できるか、B.組合せの数を問題に応じて求められるか
階乗や逆元はfor文で求める。
ダメなケースを除外した上で、最終X,Y に行くには、二つの選択肢
(i+1,j+2),(i+2,j+1)の組合せの数を求める。
組合せの数を求める時は、階乗と逆元を使う。
逆元は一通り、全て求めておいて、配列invsに格納して、後で使う。
"""
def prepare(n, MOD):
f = 1
for m in range(1, n + 1):
f = f * m % MOD
fn = f # n!を求める
inv = pow(f, MOD - 2, MOD)
invs = [1] * (n + 1) # [1, 1, 1]のイメージ、逆元？格納テーブル
invs[n] = inv # 配列の一番最後のデータ
for m in range(n, 1, -1): # n*(n-1)*(n-2)*...と上から掛けている
inv = inv * m % MOD # 逆元を一通り、求めて、配列invsに格納する
invs[m - 1] = inv
return fn, invs
def solve(x, y): # ダメなケースの除外
d, m = divmod(x + y, 3) # 商と余り
if m != 0 or x < d or y < d:
# Xとyの合計は3の倍数、x、yがd移動回数以下はあり得ない（1回1個は進む）
return 0
# c = d - x これだと範囲外参照でエラー
c = abs(d - x) # nCr=nC(n-r)、Cの後ろのrと(n-r)を入れ替えても同じ
MOD = 10**9 + 7
f, invs = prepare(d, MOD)
return f * invs[c] * invs[d - c] % MOD
# fはn!、invs[c],invs[d - c] はc!,(d-c)!の逆元？
# nCr=n!/(r!*(n-r)!)
x, y = list(map(int, input().split()))
print((solve(x, y)))
| false | 32.5 | [
"+# ika tako",
"-Aは移動関数と同数：xとy方向に合計で3進んでいるから",
"-Bは移動回数の内、(i+1,j+2)を選んだ回数：",
"-1回でx方向には1進み、y方向には2進む",
"-進み方は2通りしかないので、全体の内、1通りを選んだ回数を求めればOK",
"+A.ダメなケースを除外できるか、B.組合せの数を問題に応じて求められるか",
"+階乗や逆元はfor文で求める。",
"+ダメなケースを除外した上で、最終X,Y に行くには、二つの選択肢",
"+(i+1,j+2),(i+2,j+1)の組合せの数を求める。",
"+組合せの数を求める時は、階乗と逆元を使う。",
"+逆元は一通り、全て求めておいて、配列invsに格納して、後で使う。",
"-X, Y = list(map(int, input().split()))",
"-if (X + Y) % 3 != 0: # まず、条件に合わないケースを除外",
"- print((0))",
"- exit()",
"-A = int((X + Y) / 3)",
"-B = int((2 * Y - X) / 3)",
"-if A < 0 or B < 0:",
"- print((0))",
"- exit()",
"-MOD = 10**9 + 7",
"-def comb(n, k): # 組合せを求める関数",
"- tmp = 1",
"- for i in range(n - k + 1, n + 1): # 分子：n*(n-1)*...*(n-k+1)",
"- tmp *= i",
"- tmp %= MOD",
"- for i in range(1, k + 1): # 分母：k!",
"- tmp *= pow(i, MOD - 2, MOD) # 分母なので逆元にする",
"- tmp %= MOD",
"- return tmp",
"+def prepare(n, MOD):",
"+ f = 1",
"+ for m in range(1, n + 1):",
"+ f = f * m % MOD",
"+ fn = f # n!を求める",
"+ inv = pow(f, MOD - 2, MOD)",
"+ invs = [1] * (n + 1) # [1, 1, 1]のイメージ、逆元？格納テーブル",
"+ invs[n] = inv # 配列の一番最後のデータ",
"+ for m in range(n, 1, -1): # n*(n-1)*(n-2)*...と上から掛けている",
"+ inv = inv * m % MOD # 逆元を一通り、求めて、配列invsに格納する",
"+ invs[m - 1] = inv",
"+ return fn, invs",
"-ans = comb(A, B) # 上記説明の通り。要は組み合わせの問題",
"-print((ans % MOD))",
"+def solve(x, y): # ダメなケースの除外",
"+ d, m = divmod(x + y, 3) # 商と余り",
"+ if m != 0 or x < d or y < d:",
"+ # Xとyの合計は3の倍数、x、yがd移動回数以下はあり得ない（1回1個は進む）",
"+ return 0",
"+ # c = d - x これだと範囲外参照でエラー",
"+ c = abs(d - x) # nCr=nC(n-r)、Cの後ろのrと(n-r)を入れ替えても同じ",
"+ MOD = 10**9 + 7",
"+ f, invs = prepare(d, MOD)",
"+ return f * invs[c] * invs[d - c] % MOD",
"+",
"+",
"+# fはn!、invs[c],invs[d - c] はc!,(d-c)!の逆元？",
"+# nCr=n!/(r!*(n-r)!)",
"+x, y = list(map(int, input().split()))",
"+print((solve(x, y)))"
] | false | 0.400572 | 0.080289 | 4.989096 | [
"s939690106",
"s778187409"
] |
u392319141 | p03805 | python | s828160603 | s349263608 | 25 | 23 | 3,064 | 3,064 | Accepted | Accepted | 8 | from itertools import permutations
N, M = list(map(int, input().split()))
edges =[set() for _ in range(N)]
for _ in range(M):
fr, to = list(map(int, input().split()))
fr -= 1
to -= 1
edges[fr].add(to)
edges[to].add(fr)
ans = 0
for perm in permutations(list(range(1, N)), r=N-1):
for prev, now in zip((0,) + perm, perm):
if not now in edges[prev]:
break
else:
ans += 1
print(ans)
| from itertools import permutations
N, M = list(map(int, input().split()))
edges = [set() for _ in range(N)]
for _ in range(M):
fr, to = list(map(int, input().split()))
fr -= 1
to -= 1
edges[fr].add(to)
edges[to].add(fr)
def existsPath(path):
for fr, to in zip(path, path[1:]):
if not to in edges[fr]:
return False
return True
ans = 0
for path in permutations(list(range(1, N)), r=N-1):
if existsPath((0,) + path):
ans += 1
print(ans)
| 21 | 23 | 441 | 503 | from itertools import permutations
N, M = list(map(int, input().split()))
edges = [set() for _ in range(N)]
for _ in range(M):
fr, to = list(map(int, input().split()))
fr -= 1
to -= 1
edges[fr].add(to)
edges[to].add(fr)
ans = 0
for perm in permutations(list(range(1, N)), r=N - 1):
for prev, now in zip((0,) + perm, perm):
if not now in edges[prev]:
break
else:
ans += 1
print(ans)
| from itertools import permutations
N, M = list(map(int, input().split()))
edges = [set() for _ in range(N)]
for _ in range(M):
fr, to = list(map(int, input().split()))
fr -= 1
to -= 1
edges[fr].add(to)
edges[to].add(fr)
def existsPath(path):
for fr, to in zip(path, path[1:]):
if not to in edges[fr]:
return False
return True
ans = 0
for path in permutations(list(range(1, N)), r=N - 1):
if existsPath((0,) + path):
ans += 1
print(ans)
| false | 8.695652 | [
"+",
"+",
"+def existsPath(path):",
"+ for fr, to in zip(path, path[1:]):",
"+ if not to in edges[fr]:",
"+ return False",
"+ return True",
"+",
"+",
"-for perm in permutations(list(range(1, N)), r=N - 1):",
"- for prev, now in zip((0,) + perm, perm):",
"- if not now in edges[prev]:",
"- break",
"- else:",
"+for path in permutations(list(range(1, N)), r=N - 1):",
"+ if existsPath((0,) + path):"
] | false | 0.069793 | 0.039262 | 1.777629 | [
"s828160603",
"s349263608"
] |
u119148115 | p02794 | python | s037044991 | s938224030 | 2,821 | 1,660 | 75,192 | 74,076 | Accepted | Accepted | 41.16 | import sys
def I(): return int(sys.stdin.readline().rstrip())
def MI(): return list(map(int,sys.stdin.readline().rstrip().split()))
N = I()
dist = [[100]*(N+1) for _ in range(N+1)] # 2点間の最短距離
edges = {}
for i in range(N-1):
a,b = MI()
dist[a][b] = 1
dist[b][a] = 1
edges[(a,b)] = i
edges[(b,a)] = i
for i in range(1,N+1):
dist[i][i] = 0
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])
M = I()
A = [] # uとvを結ぶ経路上にある辺の集合
for _ in range(M):
u,v = MI()
B = set()
while True:
if dist[u][v] == 1:
B.add(edges[(u,v)])
break
else:
for i in range(1,N+1):
if dist[u][i] == dist[u][v]-1 and dist[i][v] == 1:
B.add(edges[(i,v)])
v = i
break
A.append(B)
# 包除原理
ans = 0
for i in range(2**M):
C = set()
a = 0
for j in range(M):
if (i >> j) & 1:
C = C | A[j]
a = 1-a
l = len(C)
if a == 0:
ans += pow(2,N-1-l)
else:
ans -= pow(2,N-1-l)
print(ans)
| import sys
def I(): return int(sys.stdin.readline().rstrip())
def MI(): return list(map(int,sys.stdin.readline().rstrip().split()))
N = I()
dist = [[100]*(N+1) for _ in range(N+1)] # 2点間の最短距離
edges = {}
for i in range(N-1):
a,b = MI()
dist[a][b] = 1
dist[b][a] = 1
edges[(a,b)] = i
edges[(b,a)] = i
for i in range(1,N+1):
dist[i][i] = 0
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])
M = I()
A = [] # uとvを結ぶ経路上にある辺の集合
for _ in range(M):
u,v = MI()
B = set()
while True:
if dist[u][v] == 1:
B.add(edges[(u,v)])
break
else:
for i in range(1,N+1):
if dist[u][i] == dist[u][v]-1 and dist[i][v] == 1:
B.add(edges[(i,v)])
v = i
break
A.append(B)
# 包除原理
ans = 0
for i in range(2**M):
C = set()
a = 0
for j in range(M):
if (i >> j) & 1:
C |= A[j]
a += 1
l = len(C)
a %= 2
ans += (-1)**a * 2**(N-1-l)
print(ans)
| 57 | 55 | 1,226 | 1,182 | import sys
def I():
return int(sys.stdin.readline().rstrip())
def MI():
return list(map(int, sys.stdin.readline().rstrip().split()))
N = I()
dist = [[100] * (N + 1) for _ in range(N + 1)] # 2点間の最短距離
edges = {}
for i in range(N - 1):
a, b = MI()
dist[a][b] = 1
dist[b][a] = 1
edges[(a, b)] = i
edges[(b, a)] = i
for i in range(1, N + 1):
dist[i][i] = 0
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])
M = I()
A = [] # uとvを結ぶ経路上にある辺の集合
for _ in range(M):
u, v = MI()
B = set()
while True:
if dist[u][v] == 1:
B.add(edges[(u, v)])
break
else:
for i in range(1, N + 1):
if dist[u][i] == dist[u][v] - 1 and dist[i][v] == 1:
B.add(edges[(i, v)])
v = i
break
A.append(B)
# 包除原理
ans = 0
for i in range(2**M):
C = set()
a = 0
for j in range(M):
if (i >> j) & 1:
C = C | A[j]
a = 1 - a
l = len(C)
if a == 0:
ans += pow(2, N - 1 - l)
else:
ans -= pow(2, N - 1 - l)
print(ans)
| import sys
def I():
return int(sys.stdin.readline().rstrip())
def MI():
return list(map(int, sys.stdin.readline().rstrip().split()))
N = I()
dist = [[100] * (N + 1) for _ in range(N + 1)] # 2点間の最短距離
edges = {}
for i in range(N - 1):
a, b = MI()
dist[a][b] = 1
dist[b][a] = 1
edges[(a, b)] = i
edges[(b, a)] = i
for i in range(1, N + 1):
dist[i][i] = 0
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])
M = I()
A = [] # uとvを結ぶ経路上にある辺の集合
for _ in range(M):
u, v = MI()
B = set()
while True:
if dist[u][v] == 1:
B.add(edges[(u, v)])
break
else:
for i in range(1, N + 1):
if dist[u][i] == dist[u][v] - 1 and dist[i][v] == 1:
B.add(edges[(i, v)])
v = i
break
A.append(B)
# 包除原理
ans = 0
for i in range(2**M):
C = set()
a = 0
for j in range(M):
if (i >> j) & 1:
C |= A[j]
a += 1
l = len(C)
a %= 2
ans += (-1) ** a * 2 ** (N - 1 - l)
print(ans)
| false | 3.508772 | [
"- C = C | A[j]",
"- a = 1 - a",
"+ C |= A[j]",
"+ a += 1",
"- if a == 0:",
"- ans += pow(2, N - 1 - l)",
"- else:",
"- ans -= pow(2, N - 1 - l)",
"+ a %= 2",
"+ ans += (-1) ** a * 2 ** (N - 1 - l)"
] | false | 0.041493 | 0.121065 | 0.342736 | [
"s037044991",
"s938224030"
] |
u197615397 | p00496 | python | s609199930 | s520275700 | 3,080 | 2,640 | 8,972 | 8,452 | Accepted | Accepted | 14.29 | def solve():
N, T, S = list(map(int, input().split()))
a = [tuple(map(int, input().split())) for _ in [0]*N]
dp = {0: 0}
for fun, time in a:
for _t, _f in list(dp.copy().items()):
new_time = _t + time
new_fun = fun + _f
if _t < S < new_time:
new_time = S + time
if new_time <= T and (new_time not in dp or new_fun > dp[new_time]):
dp[new_time] = new_fun
print((max(dp.values())))
if __name__ == "__main__":
solve() | def solve():
N, T, S = list(map(int, input().split()))
a = [tuple(map(int, input().split())) for _ in [0]*N]
dp = [float("-inf")]*(T+1)
dp[0] = 0
for fun, mise_time in a:
for prev_time, from_fun, to_fun in zip(list(range(T-mise_time, -1, -1)), dp[T-mise_time::-1], dp[::-1]):
new_time = prev_time + mise_time
new_fun = fun + from_fun
if prev_time < S < new_time:
new_time = S + mise_time
if new_time > T:
continue
to_fun = dp[new_time]
if new_fun > to_fun:
dp[new_time] = new_fun
print((max(dp)))
if __name__ == "__main__":
solve() | 19 | 23 | 538 | 711 | def solve():
N, T, S = list(map(int, input().split()))
a = [tuple(map(int, input().split())) for _ in [0] * N]
dp = {0: 0}
for fun, time in a:
for _t, _f in list(dp.copy().items()):
new_time = _t + time
new_fun = fun + _f
if _t < S < new_time:
new_time = S + time
if new_time <= T and (new_time not in dp or new_fun > dp[new_time]):
dp[new_time] = new_fun
print((max(dp.values())))
if __name__ == "__main__":
solve()
| def solve():
N, T, S = list(map(int, input().split()))
a = [tuple(map(int, input().split())) for _ in [0] * N]
dp = [float("-inf")] * (T + 1)
dp[0] = 0
for fun, mise_time in a:
for prev_time, from_fun, to_fun in zip(
list(range(T - mise_time, -1, -1)), dp[T - mise_time :: -1], dp[::-1]
):
new_time = prev_time + mise_time
new_fun = fun + from_fun
if prev_time < S < new_time:
new_time = S + mise_time
if new_time > T:
continue
to_fun = dp[new_time]
if new_fun > to_fun:
dp[new_time] = new_fun
print((max(dp)))
if __name__ == "__main__":
solve()
| false | 17.391304 | [
"- dp = {0: 0}",
"- for fun, time in a:",
"- for _t, _f in list(dp.copy().items()):",
"- new_time = _t + time",
"- new_fun = fun + _f",
"- if _t < S < new_time:",
"- new_time = S + time",
"- if new_time <= T and (new_time not in dp or new_fun > dp[new_time]):",
"+ dp = [float(\"-inf\")] * (T + 1)",
"+ dp[0] = 0",
"+ for fun, mise_time in a:",
"+ for prev_time, from_fun, to_fun in zip(",
"+ list(range(T - mise_time, -1, -1)), dp[T - mise_time :: -1], dp[::-1]",
"+ ):",
"+ new_time = prev_time + mise_time",
"+ new_fun = fun + from_fun",
"+ if prev_time < S < new_time:",
"+ new_time = S + mise_time",
"+ if new_time > T:",
"+ continue",
"+ to_fun = dp[new_time]",
"+ if new_fun > to_fun:",
"- print((max(dp.values())))",
"+ print((max(dp)))"
] | false | 0.092318 | 0.090379 | 1.021456 | [
"s609199930",
"s520275700"
] |
u813098295 | p02780 | python | s279634439 | s786081578 | 1,542 | 245 | 26,972 | 24,548 | Accepted | Accepted | 84.11 | class BIT:
def __init__(self, n):
self.node = [ 0 for _ in range(n+1) ]
def add(self, idx, w):
i = idx
while i < len(self.node) - 1:
self.node[i] += w
i |= (i + 1)
def sum_(self, idx):
ret, i = 0, idx-1
while i >= 0:
ret += self.node[i]
i = (i & (i + 1)) - 1
return ret
def sum(self, l, r):
return self.sum_(r) - self.sum_(l)
n, k = list(map(int, input().split()))
tree = BIT(n)
p = [ int(x) for x in input().split() ]
for i in range(n):
tree.add(i, (1+p[i])/2)
ans = 0
for i in range(n-k+1):
ans = max(ans, tree.sum(i, i+k))
print(ans) | N, K = list(map(int, input().split()))
p = [int(x) for x in input().split()]
p = [(x + 1) / 2 for x in p]
S = [0 for _ in range(N + 1)]
for i in range(N):
S[i + 1] += S[i] + p[i]
ans = 0
for i in range(N - K + 1):
ans = max(ans, S[i + K] - S[i])
print(ans) | 33 | 14 | 698 | 275 | class BIT:
def __init__(self, n):
self.node = [0 for _ in range(n + 1)]
def add(self, idx, w):
i = idx
while i < len(self.node) - 1:
self.node[i] += w
i |= i + 1
def sum_(self, idx):
ret, i = 0, idx - 1
while i >= 0:
ret += self.node[i]
i = (i & (i + 1)) - 1
return ret
def sum(self, l, r):
return self.sum_(r) - self.sum_(l)
n, k = list(map(int, input().split()))
tree = BIT(n)
p = [int(x) for x in input().split()]
for i in range(n):
tree.add(i, (1 + p[i]) / 2)
ans = 0
for i in range(n - k + 1):
ans = max(ans, tree.sum(i, i + k))
print(ans)
| N, K = list(map(int, input().split()))
p = [int(x) for x in input().split()]
p = [(x + 1) / 2 for x in p]
S = [0 for _ in range(N + 1)]
for i in range(N):
S[i + 1] += S[i] + p[i]
ans = 0
for i in range(N - K + 1):
ans = max(ans, S[i + K] - S[i])
print(ans)
| false | 57.575758 | [
"-class BIT:",
"- def __init__(self, n):",
"- self.node = [0 for _ in range(n + 1)]",
"-",
"- def add(self, idx, w):",
"- i = idx",
"- while i < len(self.node) - 1:",
"- self.node[i] += w",
"- i |= i + 1",
"-",
"- def sum_(self, idx):",
"- ret, i = 0, idx - 1",
"- while i >= 0:",
"- ret += self.node[i]",
"- i = (i & (i + 1)) - 1",
"- return ret",
"-",
"- def sum(self, l, r):",
"- return self.sum_(r) - self.sum_(l)",
"-",
"-",
"-n, k = list(map(int, input().split()))",
"-tree = BIT(n)",
"+N, K = list(map(int, input().split()))",
"-for i in range(n):",
"- tree.add(i, (1 + p[i]) / 2)",
"+p = [(x + 1) / 2 for x in p]",
"+S = [0 for _ in range(N + 1)]",
"+for i in range(N):",
"+ S[i + 1] += S[i] + p[i]",
"-for i in range(n - k + 1):",
"- ans = max(ans, tree.sum(i, i + k))",
"+for i in range(N - K + 1):",
"+ ans = max(ans, S[i + K] - S[i])"
] | false | 0.037925 | 0.053724 | 0.705928 | [
"s279634439",
"s786081578"
] |
u875291233 | p03108 | python | s102683636 | s139608380 | 812 | 587 | 27,880 | 27,192 | Accepted | Accepted | 27.71 | class UnionFind:
def __init__(self, size):
self.parent = [-1 for i in range(size)]#非負なら親ノード，負ならグループの要素数
def root(self, x): #root(x): xの根ノードを返す．
if self.parent[x] < 0:
return x
else:
while self.parent[x] >= 0 and self.parent[self.parent[x]] >= 0:
self.parent[x] = self.parent[self.parent[x]]
x = self.parent[x]
# self.parent[x] = self.root(self.parent[x]) #xをxの根に直接つなぐ
return (x if self.parent[x] < 0 else self.parent[x])
def merge(self, x, y): #merge(x,y): xのいるグループと$y$のいるグループをまとめる
x = self.root(x)
y = self.root(y)
if x == y:
return False
if self.parent[x] > self.parent[y]: #xの要素数がyの要素数より「小さい」とき入れ替える
x,y=y,x
self.parent[x] += self.parent[y] #xの要素数を更新
self.parent[y] = x #yをxにつなぐ
return True
def issame(self, x, y): #same(x,y): xとyが同じグループにあるならTrue
return self.root(x) == self.root(y)
def size(self,x): #size(x): xのいるグループの要素数を返す
return -self.parent[self.root(x)]
n,m=[int(i) for i in input().split()]
A=[[int(i)-1 for i in input().split()] for _ in range(m)]
ans = [0]*(m+1)
a = n*(n-1)//2
ans[0] = a
uf = UnionFind(n)
for i in range(m):
j = m-i-1
v1 = A[j][0]
v2 = A[j][1]
# print(v1,v2)
if not uf.issame(v1,v2):
# print(uf.parent)
a -= uf.size(v1) * uf.size(v2)
uf.merge(v1,v2)
ans[i+1]=a
for i in range(m):
print((ans[m-i-1]))
| import sys
input = sys.stdin.readline
class UnionFind:
def __init__(self, size):
self.parent = [-1 for i in range(size)]#非負なら親ノード，負ならグループの要素数
def root(self, x): #root(x): xの根ノードを返す．
if self.parent[x] < 0:
return x
elif self.parent[self.parent[x]] < 0:
return self.parent[x]
else:
self.parent[x] = self.root(self.parent[x]) #xをxの根に直接つなぐ
return self.parent[x]
def merge(self, x, y): #merge(x,y): xのいるグループと$y$のいるグループをまとめる
x = self.root(x)
y = self.root(y)
if x == y:
return False
if self.parent[x] > self.parent[y]: #xの要素数がyの要素数より「小さい」とき入れ替える
x,y=y,x
self.parent[x] += self.parent[y] #xの要素数を更新
self.parent[y] = x #yをxにつなぐ
return True
def issame(self, x, y): #same(x,y): xとyが同じグループにあるならTrue
return self.root(x) == self.root(y)
def size(self,x): #size(x): xのいるグループの要素数を返す
return -self.parent[self.root(x)]
n,m=[int(i) for i in input().split()]
A=[[int(i)-1 for i in input().split()] for _ in range(m)]
ans = [0]*(m+1)
a = n*(n-1)//2
ans[0] = a
uf = UnionFind(n)
for i in range(m):
j = m-i-1
v1 = A[j][0]
v2 = A[j][1]
# print(v1,v2)
if not uf.issame(v1,v2):
# print(uf.parent)
a -= uf.size(v1) * uf.size(v2)
uf.merge(v1,v2)
ans[i+1]=a
for i in range(m):
print((ans[m-i-1]))
| 64 | 66 | 1,609 | 1,530 | class UnionFind:
def __init__(self, size):
self.parent = [-1 for i in range(size)] # 非負なら親ノード，負ならグループの要素数
def root(self, x): # root(x): xの根ノードを返す．
if self.parent[x] < 0:
return x
else:
while self.parent[x] >= 0 and self.parent[self.parent[x]] >= 0:
self.parent[x] = self.parent[self.parent[x]]
x = self.parent[x]
# self.parent[x] = self.root(self.parent[x]) #xをxの根に直接つなぐ
return x if self.parent[x] < 0 else self.parent[x]
def merge(self, x, y): # merge(x,y): xのいるグループと$y$のいるグループをまとめる
x = self.root(x)
y = self.root(y)
if x == y:
return False
if self.parent[x] > self.parent[y]: # xの要素数がyの要素数より「小さい」とき入れ替える
x, y = y, x
self.parent[x] += self.parent[y] # xの要素数を更新
self.parent[y] = x # yをxにつなぐ
return True
def issame(self, x, y): # same(x,y): xとyが同じグループにあるならTrue
return self.root(x) == self.root(y)
def size(self, x): # size(x): xのいるグループの要素数を返す
return -self.parent[self.root(x)]
n, m = [int(i) for i in input().split()]
A = [[int(i) - 1 for i in input().split()] for _ in range(m)]
ans = [0] * (m + 1)
a = n * (n - 1) // 2
ans[0] = a
uf = UnionFind(n)
for i in range(m):
j = m - i - 1
v1 = A[j][0]
v2 = A[j][1]
# print(v1,v2)
if not uf.issame(v1, v2):
# print(uf.parent)
a -= uf.size(v1) * uf.size(v2)
uf.merge(v1, v2)
ans[i + 1] = a
for i in range(m):
print((ans[m - i - 1]))
| import sys
input = sys.stdin.readline
class UnionFind:
def __init__(self, size):
self.parent = [-1 for i in range(size)] # 非負なら親ノード，負ならグループの要素数
def root(self, x): # root(x): xの根ノードを返す．
if self.parent[x] < 0:
return x
elif self.parent[self.parent[x]] < 0:
return self.parent[x]
else:
self.parent[x] = self.root(self.parent[x]) # xをxの根に直接つなぐ
return self.parent[x]
def merge(self, x, y): # merge(x,y): xのいるグループと$y$のいるグループをまとめる
x = self.root(x)
y = self.root(y)
if x == y:
return False
if self.parent[x] > self.parent[y]: # xの要素数がyの要素数より「小さい」とき入れ替える
x, y = y, x
self.parent[x] += self.parent[y] # xの要素数を更新
self.parent[y] = x # yをxにつなぐ
return True
def issame(self, x, y): # same(x,y): xとyが同じグループにあるならTrue
return self.root(x) == self.root(y)
def size(self, x): # size(x): xのいるグループの要素数を返す
return -self.parent[self.root(x)]
n, m = [int(i) for i in input().split()]
A = [[int(i) - 1 for i in input().split()] for _ in range(m)]
ans = [0] * (m + 1)
a = n * (n - 1) // 2
ans[0] = a
uf = UnionFind(n)
for i in range(m):
j = m - i - 1
v1 = A[j][0]
v2 = A[j][1]
# print(v1,v2)
if not uf.issame(v1, v2):
# print(uf.parent)
a -= uf.size(v1) * uf.size(v2)
uf.merge(v1, v2)
ans[i + 1] = a
for i in range(m):
print((ans[m - i - 1]))
| false | 3.030303 | [
"+import sys",
"+",
"+input = sys.stdin.readline",
"+",
"+",
"+ elif self.parent[self.parent[x]] < 0:",
"+ return self.parent[x]",
"- while self.parent[x] >= 0 and self.parent[self.parent[x]] >= 0:",
"- self.parent[x] = self.parent[self.parent[x]]",
"- x = self.parent[x]",
"- # self.parent[x] = self.root(self.parent[x]) #xをxの根に直接つなぐ",
"- return x if self.parent[x] < 0 else self.parent[x]",
"+ self.parent[x] = self.root(self.parent[x]) # xをxの根に直接つなぐ",
"+ return self.parent[x]"
] | false | 0.033141 | 0.044136 | 0.750872 | [
"s102683636",
"s139608380"
] |
u482808969 | p03610 | python | s270635792 | s805654727 | 1,041 | 167 | 135,432 | 39,536 | Accepted | Accepted | 83.96 | s = eval(input())
ans = ""
for i in range(len(s)):
if i % 2 == 0:
ans += s[i]
print(ans) | s=eval(input())
print((s[::2])) | 6 | 2 | 99 | 24 | s = eval(input())
ans = ""
for i in range(len(s)):
if i % 2 == 0:
ans += s[i]
print(ans)
| s = eval(input())
print((s[::2]))
| false | 66.666667 | [
"-ans = \"\"",
"-for i in range(len(s)):",
"- if i % 2 == 0:",
"- ans += s[i]",
"-print(ans)",
"+print((s[::2]))"
] | false | 0.044558 | 0.085096 | 0.523622 | [
"s270635792",
"s805654727"
] |
u223646582 | p03660 | python | s832984352 | s698945645 | 1,156 | 658 | 127,460 | 72,036 | Accepted | Accepted | 43.08 | import sys
sys.setrecursionlimit(1000000)
N = int(eval(input()))
G = {k: [] for k in range(N+1)}
for _ in range(N-1):
a, b = list(map(int, input().split()))
# 無向グラフ
G[a].append(b)
G[b].append(a)
def dfs(v, p, c, distance): # 現在の頂点v, vの親p, 現在の距離c
distance[v] = c
for nv in G[v]:
if visited[nv] is False:
if nv == p:
continue
dfs(nv, v, c+1, distance)
return
distance_f = [-1]*(N+1)
visited = [False] * (N+1)
dfs(1, -1, 0, distance_f)
distance_s = [-1]*(N+1)
visited = [False] * (N+1)
dfs(N, -1, 0, distance_s)
# print(distance_f)
# print(distance_s)
c = 0
for i in range(2, N):
if distance_f[i] <= distance_s[i]:
c += 1
elif distance_f[i] > distance_s[i]:
c -= 1
if c > 0:
print('Fennec')
elif c <= 0:
print('Snuke')
| from collections import deque
N = int(eval(input()))
G = {k: [] for k in range(N)}
for _ in range(N-1):
a, b = list(map(int, input().split()))
# 無向グラフ
G[a-1].append(b-1)
G[b-1].append(a-1)
def bfs(i):
visited = [-1 for _ in range(N)]
visited[i] = 0
que = deque([(i, 0)])
while que:
ci, d = que.popleft()
for ni in G[ci]:
if visited[ni] == -1:
visited[ni] = d+1
que.append((ni, d+1))
return visited
F = bfs(0)
S = bfs(N-1)
ans = 0
for i in range(N):
if F[i] <= S[i]:
ans += 1
else:
ans -= 1
if ans > 0:
print('Fennec')
else:
print('Snuke')
| 45 | 41 | 867 | 705 | import sys
sys.setrecursionlimit(1000000)
N = int(eval(input()))
G = {k: [] for k in range(N + 1)}
for _ in range(N - 1):
a, b = list(map(int, input().split()))
# 無向グラフ
G[a].append(b)
G[b].append(a)
def dfs(v, p, c, distance): # 現在の頂点v, vの親p, 現在の距離c
distance[v] = c
for nv in G[v]:
if visited[nv] is False:
if nv == p:
continue
dfs(nv, v, c + 1, distance)
return
distance_f = [-1] * (N + 1)
visited = [False] * (N + 1)
dfs(1, -1, 0, distance_f)
distance_s = [-1] * (N + 1)
visited = [False] * (N + 1)
dfs(N, -1, 0, distance_s)
# print(distance_f)
# print(distance_s)
c = 0
for i in range(2, N):
if distance_f[i] <= distance_s[i]:
c += 1
elif distance_f[i] > distance_s[i]:
c -= 1
if c > 0:
print("Fennec")
elif c <= 0:
print("Snuke")
| from collections import deque
N = int(eval(input()))
G = {k: [] for k in range(N)}
for _ in range(N - 1):
a, b = list(map(int, input().split()))
# 無向グラフ
G[a - 1].append(b - 1)
G[b - 1].append(a - 1)
def bfs(i):
visited = [-1 for _ in range(N)]
visited[i] = 0
que = deque([(i, 0)])
while que:
ci, d = que.popleft()
for ni in G[ci]:
if visited[ni] == -1:
visited[ni] = d + 1
que.append((ni, d + 1))
return visited
F = bfs(0)
S = bfs(N - 1)
ans = 0
for i in range(N):
if F[i] <= S[i]:
ans += 1
else:
ans -= 1
if ans > 0:
print("Fennec")
else:
print("Snuke")
| false | 8.888889 | [
"-import sys",
"+from collections import deque",
"-sys.setrecursionlimit(1000000)",
"-G = {k: [] for k in range(N + 1)}",
"+G = {k: [] for k in range(N)}",
"- G[a].append(b)",
"- G[b].append(a)",
"+ G[a - 1].append(b - 1)",
"+ G[b - 1].append(a - 1)",
"-def dfs(v, p, c, distance): # 現在の頂点v, vの親p, 現在の距離c",
"- distance[v] = c",
"- for nv in G[v]:",
"- if visited[nv] is False:",
"- if nv == p:",
"- continue",
"- dfs(nv, v, c + 1, distance)",
"- return",
"+def bfs(i):",
"+ visited = [-1 for _ in range(N)]",
"+ visited[i] = 0",
"+ que = deque([(i, 0)])",
"+ while que:",
"+ ci, d = que.popleft()",
"+ for ni in G[ci]:",
"+ if visited[ni] == -1:",
"+ visited[ni] = d + 1",
"+ que.append((ni, d + 1))",
"+ return visited",
"-distance_f = [-1] * (N + 1)",
"-visited = [False] * (N + 1)",
"-dfs(1, -1, 0, distance_f)",
"-distance_s = [-1] * (N + 1)",
"-visited = [False] * (N + 1)",
"-dfs(N, -1, 0, distance_s)",
"-# print(distance_f)",
"-# print(distance_s)",
"-c = 0",
"-for i in range(2, N):",
"- if distance_f[i] <= distance_s[i]:",
"- c += 1",
"- elif distance_f[i] > distance_s[i]:",
"- c -= 1",
"-if c > 0:",
"+F = bfs(0)",
"+S = bfs(N - 1)",
"+ans = 0",
"+for i in range(N):",
"+ if F[i] <= S[i]:",
"+ ans += 1",
"+ else:",
"+ ans -= 1",
"+if ans > 0:",
"-elif c <= 0:",
"+else:"
] | false | 0.108157 | 0.041232 | 2.62314 | [
"s832984352",
"s698945645"
] |
u863442865 | p03168 | python | s759144036 | s714582687 | 1,696 | 240 | 3,700 | 42,348 | Accepted | Accepted | 85.85 | def main():
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10000000)
from collections import Counter, deque
#from collections import defaultdict
from itertools import combinations, permutations
#from itertools import accumulate, product
from bisect import bisect_left,bisect_right
from math import floor, ceil
#from operator import itemgetter
#mod = 1000000007
N = int(eval(input()))
p = list(map(float, input().split()))
#dp[j]:裏がj枚でる確率
dp = [1] + [0]*(N//2)
for i in range(N):
for j in range(i+1, -1, -1):
if j==0:
dp[j] = dp[j]*p[i]
elif j<=(N//2):
dp[j] = dp[j-1]*(1-p[i]) + dp[j] * p[i]
res = sum(dp)
print(('{:.9f}'.format(res)))
if __name__ == '__main__':
main() | #コインで裏をn回出す確率
def main():
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10000000)
from collections import Counter, deque
#from collections import defaultdict
from itertools import combinations, permutations
#from itertools import accumulate, product
from bisect import bisect_left,bisect_right
from math import floor, ceil
#from operator import itemgetter
#mod = 1000000007
N = int(eval(input()))
p = tuple(map(float, input().split()))
#dp[j]:裏がj枚でる確率
dp = [1] + [0]*(N//2)
for i in range(N):
for j in range(i+1, -1, -1):
if j==0:
dp[j] = dp[j]*p[i]
elif j<=(N//2):
dp[j] = dp[j-1]*(1-p[i]) + dp[j] * p[i]
res = sum(dp)
print(('{:.9f}'.format(res)))
if __name__ == '__main__':
main() | 29 | 32 | 845 | 865 | def main():
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10000000)
from collections import Counter, deque
# from collections import defaultdict
from itertools import combinations, permutations
# from itertools import accumulate, product
from bisect import bisect_left, bisect_right
from math import floor, ceil
# from operator import itemgetter
# mod = 1000000007
N = int(eval(input()))
p = list(map(float, input().split()))
# dp[j]:裏がj枚でる確率
dp = [1] + [0] * (N // 2)
for i in range(N):
for j in range(i + 1, -1, -1):
if j == 0:
dp[j] = dp[j] * p[i]
elif j <= (N // 2):
dp[j] = dp[j - 1] * (1 - p[i]) + dp[j] * p[i]
res = sum(dp)
print(("{:.9f}".format(res)))
if __name__ == "__main__":
main()
| # コインで裏をn回出す確率
def main():
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10000000)
from collections import Counter, deque
# from collections import defaultdict
from itertools import combinations, permutations
# from itertools import accumulate, product
from bisect import bisect_left, bisect_right
from math import floor, ceil
# from operator import itemgetter
# mod = 1000000007
N = int(eval(input()))
p = tuple(map(float, input().split()))
# dp[j]:裏がj枚でる確率
dp = [1] + [0] * (N // 2)
for i in range(N):
for j in range(i + 1, -1, -1):
if j == 0:
dp[j] = dp[j] * p[i]
elif j <= (N // 2):
dp[j] = dp[j - 1] * (1 - p[i]) + dp[j] * p[i]
res = sum(dp)
print(("{:.9f}".format(res)))
if __name__ == "__main__":
main()
| false | 9.375 | [
"+# コインで裏をn回出す確率",
"- p = list(map(float, input().split()))",
"+ p = tuple(map(float, input().split()))"
] | false | 0.006689 | 0.036221 | 0.184669 | [
"s759144036",
"s714582687"
] |
u667024514 | p03808 | python | s846706918 | s721428853 | 125 | 87 | 14,996 | 14,292 | Accepted | Accepted | 30.4 | n=int(eval(input()))
lis=list(map(int,input().split()))
num=(n*(n+1))//2
ll=sum(lis)
if ll%num!=0:
print("NO")
exit()
ans=0
for i in range(n):
if abs(lis[i]-lis[i-1]-ll//num)%n!=0:
print("NO")
exit()
ans+=abs(lis[i]-lis[i-1]-ll//num)//n
if ans == ll//num:print("YES")
else:print("NO")
| n = int(eval(input()))
lis = list(map(int,input().split()))
if sum(lis) % sum([i for i in range(1,n+1)]) != 0:
print("NO")
exit()
key = sum(lis) // sum([i for i in range(1,n+1)])
li = [-lis[i]+lis[i-1]+key for i in range(n)]
for num in li:
if num < 0 or num % n != 0:
print("NO")
exit()
print("YES") | 15 | 12 | 309 | 332 | n = int(eval(input()))
lis = list(map(int, input().split()))
num = (n * (n + 1)) // 2
ll = sum(lis)
if ll % num != 0:
print("NO")
exit()
ans = 0
for i in range(n):
if abs(lis[i] - lis[i - 1] - ll // num) % n != 0:
print("NO")
exit()
ans += abs(lis[i] - lis[i - 1] - ll // num) // n
if ans == ll // num:
print("YES")
else:
print("NO")
| n = int(eval(input()))
lis = list(map(int, input().split()))
if sum(lis) % sum([i for i in range(1, n + 1)]) != 0:
print("NO")
exit()
key = sum(lis) // sum([i for i in range(1, n + 1)])
li = [-lis[i] + lis[i - 1] + key for i in range(n)]
for num in li:
if num < 0 or num % n != 0:
print("NO")
exit()
print("YES")
| false | 20 | [
"-num = (n * (n + 1)) // 2",
"-ll = sum(lis)",
"-if ll % num != 0:",
"+if sum(lis) % sum([i for i in range(1, n + 1)]) != 0:",
"-ans = 0",
"-for i in range(n):",
"- if abs(lis[i] - lis[i - 1] - ll // num) % n != 0:",
"+key = sum(lis) // sum([i for i in range(1, n + 1)])",
"+li = [-lis[i] + lis[i - 1] + key for i in range(n)]",
"+for num in li:",
"+ if num < 0 or num % n != 0:",
"- ans += abs(lis[i] - lis[i - 1] - ll // num) // n",
"-if ans == ll // num:",
"- print(\"YES\")",
"-else:",
"- print(\"NO\")",
"+print(\"YES\")"
] | false | 0.042194 | 0.046098 | 0.915303 | [
"s846706918",
"s721428853"
] |
u186838327 | p03324 | python | s574810602 | s824369634 | 455 | 18 | 3,060 | 2,940 | Accepted | Accepted | 96.04 | d, n = list(map(int, input().split()))
i = 0
j = 1
ans = 0
while i < n:
if j%(100**d) == 0 and j%(100**(d+1)) != 0:
i +=1
ans = j
j +=1
print(ans) | d, n = list(map(int, input().split()))
if n != 100:
print((n*100**d))
else:
print(((n+1)*100**d)) | 10 | 5 | 173 | 99 | d, n = list(map(int, input().split()))
i = 0
j = 1
ans = 0
while i < n:
if j % (100**d) == 0 and j % (100 ** (d + 1)) != 0:
i += 1
ans = j
j += 1
print(ans)
| d, n = list(map(int, input().split()))
if n != 100:
print((n * 100**d))
else:
print(((n + 1) * 100**d))
| false | 50 | [
"-i = 0",
"-j = 1",
"-ans = 0",
"-while i < n:",
"- if j % (100**d) == 0 and j % (100 ** (d + 1)) != 0:",
"- i += 1",
"- ans = j",
"- j += 1",
"-print(ans)",
"+if n != 100:",
"+ print((n * 100**d))",
"+else:",
"+ print(((n + 1) * 100**d))"
] | false | 0.342253 | 0.031738 | 10.783596 | [
"s574810602",
"s824369634"
] |
u823044869 | p03835 | python | s453741283 | s367419080 | 1,910 | 1,239 | 2,940 | 2,940 | Accepted | Accepted | 35.13 | k, s = list(map(int,input().split()))
counter = 0
for x in range(k+1):
for y in range(k+1):
if (s- (x + y) <= k) and (s - (x+ y) >= 0):
counter += 1
print(counter) | k, s = list(map(int,input().split()))
count = 0
for i in range(k+1):
for j in range(k+1):
if 0 <= s-i-j <=k:
count+=1
print(count)
| 10 | 9 | 201 | 147 | k, s = list(map(int, input().split()))
counter = 0
for x in range(k + 1):
for y in range(k + 1):
if (s - (x + y) <= k) and (s - (x + y) >= 0):
counter += 1
print(counter)
| k, s = list(map(int, input().split()))
count = 0
for i in range(k + 1):
for j in range(k + 1):
if 0 <= s - i - j <= k:
count += 1
print(count)
| false | 10 | [
"-counter = 0",
"-for x in range(k + 1):",
"- for y in range(k + 1):",
"- if (s - (x + y) <= k) and (s - (x + y) >= 0):",
"- counter += 1",
"-print(counter)",
"+count = 0",
"+for i in range(k + 1):",
"+ for j in range(k + 1):",
"+ if 0 <= s - i - j <= k:",
"+ count += 1",
"+print(count)"
] | false | 0.076793 | 0.045933 | 1.671852 | [
"s453741283",
"s367419080"
] |
u759412327 | p02641 | python | s804637001 | s311076949 | 120 | 27 | 26,720 | 9,048 | Accepted | Accepted | 77.5 | import numpy as np
X,N = list(map(int,input().split()))
P = list(map(int,input().split()))
A = []
for n in range(102):
if n not in P:
A+=[abs(n-X)]
else:
A+=[100]
print((np.argmin(A))) | X,N = list(map(int,input().split()))
P = list(map(int,input().split()))
for n in range(51):
if X-n not in P:
print((X-n))
break
if X+n not in P:
print((X+n))
break | 12 | 10 | 201 | 183 | import numpy as np
X, N = list(map(int, input().split()))
P = list(map(int, input().split()))
A = []
for n in range(102):
if n not in P:
A += [abs(n - X)]
else:
A += [100]
print((np.argmin(A)))
| X, N = list(map(int, input().split()))
P = list(map(int, input().split()))
for n in range(51):
if X - n not in P:
print((X - n))
break
if X + n not in P:
print((X + n))
break
| false | 16.666667 | [
"-import numpy as np",
"-",
"-A = []",
"-for n in range(102):",
"- if n not in P:",
"- A += [abs(n - X)]",
"- else:",
"- A += [100]",
"-print((np.argmin(A)))",
"+for n in range(51):",
"+ if X - n not in P:",
"+ print((X - n))",
"+ break",
"+ if X + n not in P:",
"+ print((X + n))",
"+ break"
] | false | 0.33077 | 0.078795 | 4.197848 | [
"s804637001",
"s311076949"
] |
u612721349 | p03760 | python | s010634672 | s176844326 | 172 | 17 | 38,384 | 2,940 | Accepted | Accepted | 90.12 | from itertools import zip_longest
print(("".join(["".join(a) for a in zip_longest(eval(input()),eval(input()),fillvalue="")]))) | a,b=list(eval(input())),list(eval(input()))
l=len(a+b)
ans=""
for i in range(l):
if i % 2 == 0:
ans += a.pop(0)
else:
ans += b.pop(0)
print(ans) | 2 | 9 | 114 | 152 | from itertools import zip_longest
print(
(
"".join(
[
"".join(a)
for a in zip_longest(eval(input()), eval(input()), fillvalue="")
]
)
)
)
| a, b = list(eval(input())), list(eval(input()))
l = len(a + b)
ans = ""
for i in range(l):
if i % 2 == 0:
ans += a.pop(0)
else:
ans += b.pop(0)
print(ans)
| false | 77.777778 | [
"-from itertools import zip_longest",
"-",
"-print(",
"- (",
"- \"\".join(",
"- [",
"- \"\".join(a)",
"- for a in zip_longest(eval(input()), eval(input()), fillvalue=\"\")",
"- ]",
"- )",
"- )",
"-)",
"+a, b = list(eval(input())), list(eval(input()))",
"+l = len(a + b)",
"+ans = \"\"",
"+for i in range(l):",
"+ if i % 2 == 0:",
"+ ans += a.pop(0)",
"+ else:",
"+ ans += b.pop(0)",
"+print(ans)"
] | false | 0.03624 | 0.042712 | 0.848474 | [
"s010634672",
"s176844326"
] |
u701513230 | p02596 | python | s192362403 | s944064530 | 231 | 210 | 9,180 | 8,952 | Accepted | Accepted | 9.09 | K = int(eval(input()))
for i in range(K):
if i == 0:
N= 7%K
else:
N = (10*N+7)%K
if N == 0:
print((i+1))
break
else:
print((-1)) | K = int(eval(input()))
num = 7%K
for i in range(K):
if num%K ==0:
print((i+1))
break
else:
num = (num*10 + 7)%K
else:
print((-1)) | 12 | 13 | 178 | 156 | K = int(eval(input()))
for i in range(K):
if i == 0:
N = 7 % K
else:
N = (10 * N + 7) % K
if N == 0:
print((i + 1))
break
else:
print((-1))
| K = int(eval(input()))
num = 7 % K
for i in range(K):
if num % K == 0:
print((i + 1))
break
else:
num = (num * 10 + 7) % K
else:
print((-1))
| false | 7.692308 | [
"+num = 7 % K",
"- if i == 0:",
"- N = 7 % K",
"- else:",
"- N = (10 * N + 7) % K",
"- if N == 0:",
"+ if num % K == 0:",
"+ else:",
"+ num = (num * 10 + 7) % K"
] | false | 0.109168 | 0.102245 | 1.067709 | [
"s192362403",
"s944064530"
] |
u241159583 | p03695 | python | s697953444 | s950925933 | 19 | 17 | 3,188 | 3,064 | Accepted | Accepted | 10.53 | n = int(eval(input()))
A = list(map(int, input().split()))
c = []
other = 0
for a in A:
if a< 400:c.append(1)
elif a < 800: c.append(2)
elif a < 1200: c.append(3)
elif a < 1600: c.append(4)
elif a < 2000: c.append(5)
elif a < 2400: c.append(6)
elif a < 2800: c.append(7)
elif a < 3200: c.append(8)
else: other+=1
c = set(c)
if c: print((len(c), len(c)+other))
else: print((1, other)) | n = int(eval(input()))
A = list(map(int, input().split()))
color = []
other = 0
for a in A:
if a < 400: color.append(1)
elif a < 800: color.append(2)
elif a < 1200: color.append(3)
elif a < 1600: color.append(4)
elif a < 2000: color.append(5)
elif a < 2400: color.append(6)
elif a < 2800: color.append(7)
elif a < 3200: color.append(8)
else: other += 1
c = len(set(color))
if color: print((c, c+other))
else: print((1, other)) | 17 | 17 | 425 | 468 | n = int(eval(input()))
A = list(map(int, input().split()))
c = []
other = 0
for a in A:
if a < 400:
c.append(1)
elif a < 800:
c.append(2)
elif a < 1200:
c.append(3)
elif a < 1600:
c.append(4)
elif a < 2000:
c.append(5)
elif a < 2400:
c.append(6)
elif a < 2800:
c.append(7)
elif a < 3200:
c.append(8)
else:
other += 1
c = set(c)
if c:
print((len(c), len(c) + other))
else:
print((1, other))
| n = int(eval(input()))
A = list(map(int, input().split()))
color = []
other = 0
for a in A:
if a < 400:
color.append(1)
elif a < 800:
color.append(2)
elif a < 1200:
color.append(3)
elif a < 1600:
color.append(4)
elif a < 2000:
color.append(5)
elif a < 2400:
color.append(6)
elif a < 2800:
color.append(7)
elif a < 3200:
color.append(8)
else:
other += 1
c = len(set(color))
if color:
print((c, c + other))
else:
print((1, other))
| false | 0 | [
"-c = []",
"+color = []",
"- c.append(1)",
"+ color.append(1)",
"- c.append(2)",
"+ color.append(2)",
"- c.append(3)",
"+ color.append(3)",
"- c.append(4)",
"+ color.append(4)",
"- c.append(5)",
"+ color.append(5)",
"- c.append(6)",
"+ color.append(6)",
"- c.append(7)",
"+ color.append(7)",
"- c.append(8)",
"+ color.append(8)",
"-c = set(c)",
"-if c:",
"- print((len(c), len(c) + other))",
"+c = len(set(color))",
"+if color:",
"+ print((c, c + other))"
] | false | 0.052287 | 0.037359 | 1.399586 | [
"s697953444",
"s950925933"
] |
u052332717 | p03556 | python | s914169562 | s428248947 | 38 | 28 | 2,940 | 2,940 | Accepted | Accepted | 26.32 | n = int(eval(input()))
count = 1
while True:
if count**2 <= n and n < (count+1)**2:
print((count**2))
break
else:
count += 1 | n = int(eval(input()))
if n == 1:
print((1))
for i in range(1,n+1):
if i**2>n:
print(((i-1)**2))
break
| 8 | 9 | 155 | 127 | n = int(eval(input()))
count = 1
while True:
if count**2 <= n and n < (count + 1) ** 2:
print((count**2))
break
else:
count += 1
| n = int(eval(input()))
if n == 1:
print((1))
for i in range(1, n + 1):
if i**2 > n:
print(((i - 1) ** 2))
break
| false | 11.111111 | [
"-count = 1",
"-while True:",
"- if count**2 <= n and n < (count + 1) ** 2:",
"- print((count**2))",
"+if n == 1:",
"+ print((1))",
"+for i in range(1, n + 1):",
"+ if i**2 > n:",
"+ print(((i - 1) ** 2))",
"- else:",
"- count += 1"
] | false | 0.050991 | 0.049571 | 1.028662 | [
"s914169562",
"s428248947"
] |
u577311000 | p00033 | python | s976944736 | s327773651 | 30 | 20 | 7,616 | 7,584 | Accepted | Accepted | 33.33 | # -*- coding: utf-8 -*-
import sys
sys.setrecursionlimit(10**6)
def dfs(balls,B=-1,C=-1,cp=0):
if cp==len(balls): return True
ball = balls[cp]
if B<ball:
is_find = dfs(balls,ball,C,cp+1)
if is_find: return True
if C<ball:
is_find = dfs(balls,B,ball,cp+1)
if is_find: return True
return False
def main():
N = int(input().strip())
for _ in range(N):
balls = list(map(int,input().split(' ')))
is_find = dfs(balls)
if is_find: print('YES')
else: print('NO')
if __name__=='__main__':
main()
"""
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
""" | # -*- coding: utf-8 -*-
import sys
sys.setrecursionlimit(10**6)
"""
def dfs(balls,B=-1,C=-2,cp=0):
if cp==len(balls): return True
ball = balls[cp]
if B<ball:
is_find = dfs(balls,ball,C,cp+1)
if is_find: return True
if C<ball:
is_find = dfs(balls,B,ball,cp+1)
if is_find: return True
return False
"""
def dfs(balls):
B, C = -2, -1
for ball in balls:
if C<ball:
C = ball
continue
if B<ball:
B = ball
continue
return False
return True
def main():
N = int(input().strip())
for _ in range(N):
balls = list(map(int,input().split(' ')))
is_find = dfs(balls)
if is_find: print('YES')
else: print('NO')
if __name__=='__main__':
main()
"""
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
""" | 32 | 46 | 601 | 777 | # -*- coding: utf-8 -*-
import sys
sys.setrecursionlimit(10**6)
def dfs(balls, B=-1, C=-1, cp=0):
if cp == len(balls):
return True
ball = balls[cp]
if B < ball:
is_find = dfs(balls, ball, C, cp + 1)
if is_find:
return True
if C < ball:
is_find = dfs(balls, B, ball, cp + 1)
if is_find:
return True
return False
def main():
N = int(input().strip())
for _ in range(N):
balls = list(map(int, input().split(" ")))
is_find = dfs(balls)
if is_find:
print("YES")
else:
print("NO")
if __name__ == "__main__":
main()
"""
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
"""
| # -*- coding: utf-8 -*-
import sys
sys.setrecursionlimit(10**6)
"""
def dfs(balls,B=-1,C=-2,cp=0):
if cp==len(balls): return True
ball = balls[cp]
if B<ball:
is_find = dfs(balls,ball,C,cp+1)
if is_find: return True
if C<ball:
is_find = dfs(balls,B,ball,cp+1)
if is_find: return True
return False
"""
def dfs(balls):
B, C = -2, -1
for ball in balls:
if C < ball:
C = ball
continue
if B < ball:
B = ball
continue
return False
return True
def main():
N = int(input().strip())
for _ in range(N):
balls = list(map(int, input().split(" ")))
is_find = dfs(balls)
if is_find:
print("YES")
else:
print("NO")
if __name__ == "__main__":
main()
"""
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
"""
| false | 30.434783 | [
"+\"\"\"",
"+def dfs(balls,B=-1,C=-2,cp=0):",
"+\tif cp==len(balls): \treturn True",
"+\tball = balls[cp]",
"+\tif B<ball:",
"+\t\tis_find = dfs(balls,ball,C,cp+1)",
"+\t\tif is_find: return True",
"+\tif C<ball:",
"+\t\tis_find = dfs(balls,B,ball,cp+1)",
"+\t\tif is_find: return True",
"+\treturn False",
"+\"\"\"",
"-def dfs(balls, B=-1, C=-1, cp=0):",
"- if cp == len(balls):",
"- return True",
"- ball = balls[cp]",
"- if B < ball:",
"- is_find = dfs(balls, ball, C, cp + 1)",
"- if is_find:",
"- return True",
"- if C < ball:",
"- is_find = dfs(balls, B, ball, cp + 1)",
"- if is_find:",
"- return True",
"- return False",
"+def dfs(balls):",
"+ B, C = -2, -1",
"+ for ball in balls:",
"+ if C < ball:",
"+ C = ball",
"+ continue",
"+ if B < ball:",
"+ B = ball",
"+ continue",
"+ return False",
"+ return True"
] | false | 0.049486 | 0.077886 | 0.635366 | [
"s976944736",
"s327773651"
] |
u600402037 | p02793 | python | s976343616 | s204474557 | 1,740 | 1,478 | 272,076 | 6,136 | Accepted | Accepted | 15.06 | import sys
import numpy as np
from fractions import gcd
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
N = ir()
A = lr()
MOD = 10 ** 9 + 7
lcm = 1
for a in A:
lcm *= a // gcd(lcm, a)
A = np.array(A)
B = lcm // A
answer = np.sum(B) % MOD
print(answer)
| import sys
from fractions import gcd
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
MOD = 10 ** 9 + 7
N = ir()
A = lr()
# lcm
lcm = 1
answer = 0
for a in A:
coef = a // gcd(lcm, a)
answer *= coef
lcm *= coef
answer += lcm // a
answer %= MOD
print((answer%MOD))
| 19 | 21 | 337 | 364 | import sys
import numpy as np
from fractions import gcd
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
N = ir()
A = lr()
MOD = 10**9 + 7
lcm = 1
for a in A:
lcm *= a // gcd(lcm, a)
A = np.array(A)
B = lcm // A
answer = np.sum(B) % MOD
print(answer)
| import sys
from fractions import gcd
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
MOD = 10**9 + 7
N = ir()
A = lr()
# lcm
lcm = 1
answer = 0
for a in A:
coef = a // gcd(lcm, a)
answer *= coef
lcm *= coef
answer += lcm // a
answer %= MOD
print((answer % MOD))
| false | 9.52381 | [
"-import numpy as np",
"+MOD = 10**9 + 7",
"-MOD = 10**9 + 7",
"+# lcm",
"+answer = 0",
"- lcm *= a // gcd(lcm, a)",
"-A = np.array(A)",
"-B = lcm // A",
"-answer = np.sum(B) % MOD",
"-print(answer)",
"+ coef = a // gcd(lcm, a)",
"+ answer *= coef",
"+ lcm *= coef",
"+ answer += lcm // a",
"+ answer %= MOD",
"+print((answer % MOD))"
] | false | 0.339786 | 0.046747 | 7.2686 | [
"s976343616",
"s204474557"
] |
u580404776 | p03556 | python | s758876724 | s363425186 | 37 | 17 | 3,060 | 2,940 | Accepted | Accepted | 54.05 | N=int(eval(input()))
ans=0
for i in range(int(N**0.5)+1):
if i**2 <=N:
ans=i**2
print(ans) | n = int(eval(input()))
print((int(n**0.5)**2)) | 7 | 2 | 111 | 39 | N = int(eval(input()))
ans = 0
for i in range(int(N**0.5) + 1):
if i**2 <= N:
ans = i**2
print(ans)
| n = int(eval(input()))
print((int(n**0.5) ** 2))
| false | 71.428571 | [
"-N = int(eval(input()))",
"-ans = 0",
"-for i in range(int(N**0.5) + 1):",
"- if i**2 <= N:",
"- ans = i**2",
"-print(ans)",
"+n = int(eval(input()))",
"+print((int(n**0.5) ** 2))"
] | false | 0.043614 | 0.043116 | 1.011539 | [
"s758876724",
"s363425186"
] |
u520276780 | p03044 | python | s710737187 | s638800700 | 843 | 765 | 84,128 | 72,480 | Accepted | Accepted | 9.25 | from collections import deque
n = int(eval(input()))
ed = [[] for _ in range(n)]
for _ in range(n-1):
u,v,w = list(map(int, input().split( )))
ed[u-1].append([v-1,w])
ed[v-1].append([u-1,w])#こっちも必要
c = [0]*n
done = [0]*n#無向だから
Q = deque()
Q.append(0)
while Q:
u = Q.popleft()
for e in ed[u]:
if not done[e[0]]:
c[e[0]] = (e[1]&1) ^ c[u]
Q.append(e[0])
done[e[0]] = 1
for i in range(n):
print((c[i])) | n=int(eval(input()))
e=[[] for _ in range(n)]
for _ in range(n-1):
xi,yi,wi=list(map(int, input().split()))
xi-=1;yi-=1
e[yi].append((xi,wi))
e[xi].append((yi,wi))
c=[0]*n
used=[0]*n
from collections import deque
q=deque()
q.append(0)
while q:
u=q.popleft()
for v,w in e[u]:
if not used[v]:
c[v]=(c[u]+w)%2
used[v]=1
q.append(v)
for i in c:
print(i) | 25 | 24 | 482 | 435 | from collections import deque
n = int(eval(input()))
ed = [[] for _ in range(n)]
for _ in range(n - 1):
u, v, w = list(map(int, input().split()))
ed[u - 1].append([v - 1, w])
ed[v - 1].append([u - 1, w]) # こっちも必要
c = [0] * n
done = [0] * n # 無向だから
Q = deque()
Q.append(0)
while Q:
u = Q.popleft()
for e in ed[u]:
if not done[e[0]]:
c[e[0]] = (e[1] & 1) ^ c[u]
Q.append(e[0])
done[e[0]] = 1
for i in range(n):
print((c[i]))
| n = int(eval(input()))
e = [[] for _ in range(n)]
for _ in range(n - 1):
xi, yi, wi = list(map(int, input().split()))
xi -= 1
yi -= 1
e[yi].append((xi, wi))
e[xi].append((yi, wi))
c = [0] * n
used = [0] * n
from collections import deque
q = deque()
q.append(0)
while q:
u = q.popleft()
for v, w in e[u]:
if not used[v]:
c[v] = (c[u] + w) % 2
used[v] = 1
q.append(v)
for i in c:
print(i)
| false | 4 | [
"+n = int(eval(input()))",
"+e = [[] for _ in range(n)]",
"+for _ in range(n - 1):",
"+ xi, yi, wi = list(map(int, input().split()))",
"+ xi -= 1",
"+ yi -= 1",
"+ e[yi].append((xi, wi))",
"+ e[xi].append((yi, wi))",
"+c = [0] * n",
"+used = [0] * n",
"-n = int(eval(input()))",
"-ed = [[] for _ in range(n)]",
"-for _ in range(n - 1):",
"- u, v, w = list(map(int, input().split()))",
"- ed[u - 1].append([v - 1, w])",
"- ed[v - 1].append([u - 1, w]) # こっちも必要",
"-c = [0] * n",
"-done = [0] * n # 無向だから",
"-Q = deque()",
"-Q.append(0)",
"-while Q:",
"- u = Q.popleft()",
"- for e in ed[u]:",
"- if not done[e[0]]:",
"- c[e[0]] = (e[1] & 1) ^ c[u]",
"- Q.append(e[0])",
"- done[e[0]] = 1",
"-for i in range(n):",
"- print((c[i]))",
"+q = deque()",
"+q.append(0)",
"+while q:",
"+ u = q.popleft()",
"+ for v, w in e[u]:",
"+ if not used[v]:",
"+ c[v] = (c[u] + w) % 2",
"+ used[v] = 1",
"+ q.append(v)",
"+for i in c:",
"+ print(i)"
] | false | 0.046898 | 0.044198 | 1.061096 | [
"s710737187",
"s638800700"
] |
u864197622 | p02563 | python | s684531183 | s405462643 | 2,277 | 1,384 | 203,056 | 203,536 | Accepted | Accepted | 39.22 | def fft(f, n, w, p, g):
d = n // 2
v = w
while d >= 1:
u = 1
for i in range(d):
for j in range(i, n, 2*d):
f[j], f[j+d] = (f[j] + f[j+d]) % p, u * (f[j] - f[j+d]) % p
u = u * v % p
v = v * v % p
d //= 2
def ifft(f, n, invw, p, g):
d = 1
while d < n:
v = pow(invw, n // (2 * d), p)
u = 1
for i in range(d):
for j in range(i, n, 2*d):
f[j+d] *= u
f[j], f[j+d] = (f[j] + f[j+d]) % p, (f[j] - f[j+d]) % p
u = u * v % p
d *= 2
def convolve(a, b):
p, g = 998244353, 3
n0, n1 = len(a), len(b)
n = 1 << (max(n0, n1) - 1).bit_length() + 1
a = a + [0] * (n-n0)
b = b + [0] * (n-n1)
w = pow(g, (p - 1) // n, p)
invw = pow(w, p-2, p)
fft(a, n, w, p, g), fft(b, n, w, p, g)
for i in range(n):
a[i] = a[i] * b[i] % p
ifft(a, n, invw, p, g)
invn = pow(n, p - 2, p)
return [a[i] * invn % p for i in range(n0 + n1 - 1)]
N, M = list(map(int, input().split()))
A = [int(a) for a in input().split()]
B = [int(a) for a in input().split()]
print((*convolve(A, B)))
| p, g = 998244353, 3
def convolve(a, b):
def fft(f):
d = n // 2
v = w
while d >= 1:
u = 1
for i in range(d):
for j in range(i, n, 2*d):
f[j], f[j+d] = (f[j] + f[j+d]) % p, u * (f[j] - f[j+d]) % p
u = u * v % p
v = v * v % p
d //= 2
def ifft(f):
d = 1
while d < n:
v = pow(invw, n // (2 * d), p)
u = 1
for i in range(d):
for j in range(i, n, 2*d):
f[j+d] *= u
f[j], f[j+d] = (f[j] + f[j+d]) % p, (f[j] - f[j+d]) % p
u = u * v % p
d *= 2
n0, n1 = len(a), len(b)
n = 1 << (max(n0, n1) - 1).bit_length() + 1
a = a + [0] * (n-n0)
b = b + [0] * (n-n1)
w = pow(g, (p - 1) // n, p)
invw = pow(w, p-2, p)
fft(a), fft(b)
for i in range(n):
a[i] = a[i] * b[i] % p
ifft(a)
invn = pow(n, p - 2, p)
return [a[i] * invn % p for i in range(n0 + n1 - 1)]
N, M = list(map(int, input().split()))
A = [int(a) for a in input().split()]
B = [int(a) for a in input().split()]
print((*convolve(A, B)))
| 41 | 43 | 1,212 | 1,236 | def fft(f, n, w, p, g):
d = n // 2
v = w
while d >= 1:
u = 1
for i in range(d):
for j in range(i, n, 2 * d):
f[j], f[j + d] = (f[j] + f[j + d]) % p, u * (f[j] - f[j + d]) % p
u = u * v % p
v = v * v % p
d //= 2
def ifft(f, n, invw, p, g):
d = 1
while d < n:
v = pow(invw, n // (2 * d), p)
u = 1
for i in range(d):
for j in range(i, n, 2 * d):
f[j + d] *= u
f[j], f[j + d] = (f[j] + f[j + d]) % p, (f[j] - f[j + d]) % p
u = u * v % p
d *= 2
def convolve(a, b):
p, g = 998244353, 3
n0, n1 = len(a), len(b)
n = 1 << (max(n0, n1) - 1).bit_length() + 1
a = a + [0] * (n - n0)
b = b + [0] * (n - n1)
w = pow(g, (p - 1) // n, p)
invw = pow(w, p - 2, p)
fft(a, n, w, p, g), fft(b, n, w, p, g)
for i in range(n):
a[i] = a[i] * b[i] % p
ifft(a, n, invw, p, g)
invn = pow(n, p - 2, p)
return [a[i] * invn % p for i in range(n0 + n1 - 1)]
N, M = list(map(int, input().split()))
A = [int(a) for a in input().split()]
B = [int(a) for a in input().split()]
print((*convolve(A, B)))
| p, g = 998244353, 3
def convolve(a, b):
def fft(f):
d = n // 2
v = w
while d >= 1:
u = 1
for i in range(d):
for j in range(i, n, 2 * d):
f[j], f[j + d] = (f[j] + f[j + d]) % p, u * (f[j] - f[j + d]) % p
u = u * v % p
v = v * v % p
d //= 2
def ifft(f):
d = 1
while d < n:
v = pow(invw, n // (2 * d), p)
u = 1
for i in range(d):
for j in range(i, n, 2 * d):
f[j + d] *= u
f[j], f[j + d] = (f[j] + f[j + d]) % p, (f[j] - f[j + d]) % p
u = u * v % p
d *= 2
n0, n1 = len(a), len(b)
n = 1 << (max(n0, n1) - 1).bit_length() + 1
a = a + [0] * (n - n0)
b = b + [0] * (n - n1)
w = pow(g, (p - 1) // n, p)
invw = pow(w, p - 2, p)
fft(a), fft(b)
for i in range(n):
a[i] = a[i] * b[i] % p
ifft(a)
invn = pow(n, p - 2, p)
return [a[i] * invn % p for i in range(n0 + n1 - 1)]
N, M = list(map(int, input().split()))
A = [int(a) for a in input().split()]
B = [int(a) for a in input().split()]
print((*convolve(A, B)))
| false | 4.651163 | [
"-def fft(f, n, w, p, g):",
"- d = n // 2",
"- v = w",
"- while d >= 1:",
"- u = 1",
"- for i in range(d):",
"- for j in range(i, n, 2 * d):",
"- f[j], f[j + d] = (f[j] + f[j + d]) % p, u * (f[j] - f[j + d]) % p",
"- u = u * v % p",
"- v = v * v % p",
"- d //= 2",
"-",
"-",
"-def ifft(f, n, invw, p, g):",
"- d = 1",
"- while d < n:",
"- v = pow(invw, n // (2 * d), p)",
"- u = 1",
"- for i in range(d):",
"- for j in range(i, n, 2 * d):",
"- f[j + d] *= u",
"- f[j], f[j + d] = (f[j] + f[j + d]) % p, (f[j] - f[j + d]) % p",
"- u = u * v % p",
"- d *= 2",
"+p, g = 998244353, 3",
"- p, g = 998244353, 3",
"+ def fft(f):",
"+ d = n // 2",
"+ v = w",
"+ while d >= 1:",
"+ u = 1",
"+ for i in range(d):",
"+ for j in range(i, n, 2 * d):",
"+ f[j], f[j + d] = (f[j] + f[j + d]) % p, u * (f[j] - f[j + d]) % p",
"+ u = u * v % p",
"+ v = v * v % p",
"+ d //= 2",
"+",
"+ def ifft(f):",
"+ d = 1",
"+ while d < n:",
"+ v = pow(invw, n // (2 * d), p)",
"+ u = 1",
"+ for i in range(d):",
"+ for j in range(i, n, 2 * d):",
"+ f[j + d] *= u",
"+ f[j], f[j + d] = (f[j] + f[j + d]) % p, (f[j] - f[j + d]) % p",
"+ u = u * v % p",
"+ d *= 2",
"+",
"- fft(a, n, w, p, g), fft(b, n, w, p, g)",
"+ fft(a), fft(b)",
"- ifft(a, n, invw, p, g)",
"+ ifft(a)"
] | false | 0.065018 | 0.088068 | 0.738272 | [
"s684531183",
"s405462643"
] |
u912237403 | p00005 | python | s709229275 | s873998857 | 20 | 10 | 4,204 | 4,208 | Accepted | Accepted | 50 | import sys
def gcm(a,b):
if a%b==0: return b
return gcm(b,a%b)
for s in sys.stdin:
a,b=list(map(int,s.split()))
c=gcm(a,b)
print(c,a/c*b) | import sys
def gcm(a,b):
if a%b==0: return b
return gcm(b,a%b)
for s in sys.stdin:
a,b=list(map(int,s.split()))
if a<b:a,b=b,a
c=gcm(a,b)
print(c,a/c*b) | 9 | 10 | 159 | 179 | import sys
def gcm(a, b):
if a % b == 0:
return b
return gcm(b, a % b)
for s in sys.stdin:
a, b = list(map(int, s.split()))
c = gcm(a, b)
print(c, a / c * b)
| import sys
def gcm(a, b):
if a % b == 0:
return b
return gcm(b, a % b)
for s in sys.stdin:
a, b = list(map(int, s.split()))
if a < b:
a, b = b, a
c = gcm(a, b)
print(c, a / c * b)
| false | 10 | [
"+ if a < b:",
"+ a, b = b, a"
] | false | 0.041727 | 0.041594 | 1.003192 | [
"s709229275",
"s873998857"
] |
u596276291 | p03944 | python | s983732975 | s427686811 | 51 | 47 | 3,188 | 3,444 | Accepted | Accepted | 7.84 | def main():
w, h, n = list(map(int, input().split()))
f = [[1] * w for _ in range(h)]
for _ in range(n):
x, y, a = list(map(int, input().split()))
if a == 1:
for i in range(h):
for j in range(x):
f[i][j] = 0
if a == 2:
for i in range(h):
for j in range(x, w):
f[i][j] = 0
if a == 3:
for i in range(h - y, h):
for j in range(w):
f[i][j] = 0
if a == 4:
for i in range(h - y):
for j in range(w):
f[i][j] = 0
ans = 0
for l in f:
ans += sum(l)
print(ans)
if __name__ == '__main__':
main()
| from collections import defaultdict
def main():
W, H, N = list(map(int, input().split()))
field = [[1] * W for _ in range(H)]
for _ in range(N):
x, y, a = list(map(int, input().split()))
y_s, y_e = 0, H
x_s, x_e = 0, W
if a == 1:
x_s, x_e = 0, x
elif a == 2:
x_s, x_e = x, W
elif a == 3:
y_s, y_e = H - y, H
elif a == 4:
y_s, y_e = 0, H - y
for y in range(y_s, y_e):
for x in range(x_s, x_e):
field[y][x] = 0
print((sum([sum(line) for line in field])))
if __name__ == '__main__':
main()
| 30 | 27 | 772 | 664 | def main():
w, h, n = list(map(int, input().split()))
f = [[1] * w for _ in range(h)]
for _ in range(n):
x, y, a = list(map(int, input().split()))
if a == 1:
for i in range(h):
for j in range(x):
f[i][j] = 0
if a == 2:
for i in range(h):
for j in range(x, w):
f[i][j] = 0
if a == 3:
for i in range(h - y, h):
for j in range(w):
f[i][j] = 0
if a == 4:
for i in range(h - y):
for j in range(w):
f[i][j] = 0
ans = 0
for l in f:
ans += sum(l)
print(ans)
if __name__ == "__main__":
main()
| from collections import defaultdict
def main():
W, H, N = list(map(int, input().split()))
field = [[1] * W for _ in range(H)]
for _ in range(N):
x, y, a = list(map(int, input().split()))
y_s, y_e = 0, H
x_s, x_e = 0, W
if a == 1:
x_s, x_e = 0, x
elif a == 2:
x_s, x_e = x, W
elif a == 3:
y_s, y_e = H - y, H
elif a == 4:
y_s, y_e = 0, H - y
for y in range(y_s, y_e):
for x in range(x_s, x_e):
field[y][x] = 0
print((sum([sum(line) for line in field])))
if __name__ == "__main__":
main()
| false | 10 | [
"+from collections import defaultdict",
"+",
"+",
"- w, h, n = list(map(int, input().split()))",
"- f = [[1] * w for _ in range(h)]",
"- for _ in range(n):",
"+ W, H, N = list(map(int, input().split()))",
"+ field = [[1] * W for _ in range(H)]",
"+ for _ in range(N):",
"+ y_s, y_e = 0, H",
"+ x_s, x_e = 0, W",
"- for i in range(h):",
"- for j in range(x):",
"- f[i][j] = 0",
"- if a == 2:",
"- for i in range(h):",
"- for j in range(x, w):",
"- f[i][j] = 0",
"- if a == 3:",
"- for i in range(h - y, h):",
"- for j in range(w):",
"- f[i][j] = 0",
"- if a == 4:",
"- for i in range(h - y):",
"- for j in range(w):",
"- f[i][j] = 0",
"- ans = 0",
"- for l in f:",
"- ans += sum(l)",
"- print(ans)",
"+ x_s, x_e = 0, x",
"+ elif a == 2:",
"+ x_s, x_e = x, W",
"+ elif a == 3:",
"+ y_s, y_e = H - y, H",
"+ elif a == 4:",
"+ y_s, y_e = 0, H - y",
"+ for y in range(y_s, y_e):",
"+ for x in range(x_s, x_e):",
"+ field[y][x] = 0",
"+ print((sum([sum(line) for line in field])))"
] | false | 0.085595 | 0.043146 | 1.983851 | [
"s983732975",
"s427686811"
] |
u882370611 | p02971 | python | s178525578 | s763122959 | 607 | 542 | 14,636 | 14,112 | Accepted | Accepted | 10.71 | N=int(eval(input()))
a=[int(eval(input())) for i in range(N)]
m=sorted(a)[-1]
n=sorted(a)[-2]
for i in range(N):
if a[i]==m:
print(n)
else:
print(m)
| N=int(eval(input()))
a=[int(eval(input())) for i in range(N)]
b=sorted(a)
m=b[-1]
n=b[-2]
for i in range(N):
if a[i]==m:
print(n)
else:
print(m)
| 10 | 11 | 163 | 160 | N = int(eval(input()))
a = [int(eval(input())) for i in range(N)]
m = sorted(a)[-1]
n = sorted(a)[-2]
for i in range(N):
if a[i] == m:
print(n)
else:
print(m)
| N = int(eval(input()))
a = [int(eval(input())) for i in range(N)]
b = sorted(a)
m = b[-1]
n = b[-2]
for i in range(N):
if a[i] == m:
print(n)
else:
print(m)
| false | 9.090909 | [
"-m = sorted(a)[-1]",
"-n = sorted(a)[-2]",
"+b = sorted(a)",
"+m = b[-1]",
"+n = b[-2]"
] | false | 0.041828 | 0.042655 | 0.980614 | [
"s178525578",
"s763122959"
] |
u203588891 | p02681 | python | s853634650 | s018023296 | 87 | 19 | 67,232 | 9,040 | Accepted | Accepted | 78.16 | import sys;input=lambda:sys.stdin.readline().rstrip();aint=lambda:int(input());ints=lambda:list(map(int,input().split()))
import math;floor,ceil=lambda x:int(math.floor(x)),lambda x:int(math.ceil(x))
from functools import reduce;gcd=lambda*x:reduce(math.gcd,x);lcm=lambda*x:reduce(lambda x,y:(x*y)//gcd(x,y),x,1)
from collections import deque
Yes=lambda b:print("Yes"if b else"No");YES=lambda b:print("YES"if b else"NO")
is_even=lambda x:True if x%2==0 else False
def main():
s=input()
t=input()
n=len(s)
flg=0
for i in range(n):
if s[i]!=t[i]:
flg=1
Yes(flg==0)
if __name__ == '__main__':
main()
| import sys;input=lambda:sys.stdin.readline().rstrip()
Yes=lambda b:print("Yes"if b else"No")
s,t=input(),input()
Yes(s==t[:-1])
| 20 | 5 | 648 | 132 | import sys
input = lambda: sys.stdin.readline().rstrip()
aint = lambda: int(input())
ints = lambda: list(map(int, input().split()))
import math
floor, ceil = lambda x: int(math.floor(x)), lambda x: int(math.ceil(x))
from functools import reduce
gcd = lambda *x: reduce(math.gcd, x)
lcm = lambda *x: reduce(lambda x, y: (x * y) // gcd(x, y), x, 1)
from collections import deque
Yes = lambda b: print("Yes" if b else "No")
YES = lambda b: print("YES" if b else "NO")
is_even = lambda x: True if x % 2 == 0 else False
def main():
s = input()
t = input()
n = len(s)
flg = 0
for i in range(n):
if s[i] != t[i]:
flg = 1
Yes(flg == 0)
if __name__ == "__main__":
main()
| import sys
input = lambda: sys.stdin.readline().rstrip()
Yes = lambda b: print("Yes" if b else "No")
s, t = input(), input()
Yes(s == t[:-1])
| false | 75 | [
"-aint = lambda: int(input())",
"-ints = lambda: list(map(int, input().split()))",
"-import math",
"-",
"-floor, ceil = lambda x: int(math.floor(x)), lambda x: int(math.ceil(x))",
"-from functools import reduce",
"-",
"-gcd = lambda *x: reduce(math.gcd, x)",
"-lcm = lambda *x: reduce(lambda x, y: (x * y) // gcd(x, y), x, 1)",
"-from collections import deque",
"-",
"-YES = lambda b: print(\"YES\" if b else \"NO\")",
"-is_even = lambda x: True if x % 2 == 0 else False",
"-",
"-",
"-def main():",
"- s = input()",
"- t = input()",
"- n = len(s)",
"- flg = 0",
"- for i in range(n):",
"- if s[i] != t[i]:",
"- flg = 1",
"- Yes(flg == 0)",
"-",
"-",
"-if __name__ == \"__main__\":",
"- main()",
"+s, t = input(), input()",
"+Yes(s == t[:-1])"
] | false | 0.064021 | 0.036631 | 1.747727 | [
"s853634650",
"s018023296"
] |
u690536347 | p03221 | python | s992238908 | s078002408 | 1,234 | 806 | 82,388 | 40,936 | Accepted | Accepted | 34.68 | from collections import defaultdict as dd
d=dd(int)
n,m=list(map(int,input().split()))
l=[[i]+list(map(int,input().split()))+[0] for i in range(m)]
o=sorted(l,key=lambda x:x[2])
for i,j in enumerate(o):
d[j[1]]+=1
o[i][3]=d[j[1]]
for i in sorted(o):
print(('{0:06d}'.format(i[1])+'{0:06d}'.format(i[3]))) | from collections import defaultdict as dd
d=dd(int)
n,m=list(map(int,input().split()))
l=[[i]+list(map(int,input().split()))+[0] for i in range(m)]
o=sorted(l,key=lambda x:x[2])
for i,j in enumerate(o):
d[j[1]]+=1
o[i][3]=d[j[1]]
for i in sorted(o):
print(("%06d%06d"%(i[1],i[3])))
| 13 | 13 | 317 | 295 | from collections import defaultdict as dd
d = dd(int)
n, m = list(map(int, input().split()))
l = [[i] + list(map(int, input().split())) + [0] for i in range(m)]
o = sorted(l, key=lambda x: x[2])
for i, j in enumerate(o):
d[j[1]] += 1
o[i][3] = d[j[1]]
for i in sorted(o):
print(("{0:06d}".format(i[1]) + "{0:06d}".format(i[3])))
| from collections import defaultdict as dd
d = dd(int)
n, m = list(map(int, input().split()))
l = [[i] + list(map(int, input().split())) + [0] for i in range(m)]
o = sorted(l, key=lambda x: x[2])
for i, j in enumerate(o):
d[j[1]] += 1
o[i][3] = d[j[1]]
for i in sorted(o):
print(("%06d%06d" % (i[1], i[3])))
| false | 0 | [
"- print((\"{0:06d}\".format(i[1]) + \"{0:06d}\".format(i[3])))",
"+ print((\"%06d%06d\" % (i[1], i[3])))"
] | false | 0.076811 | 0.076659 | 1.001989 | [
"s992238908",
"s078002408"
] |
u064246852 | p03645 | python | s676880910 | s834044375 | 1,209 | 659 | 11,436 | 21,852 | Accepted | Accepted | 45.49 | n,m = list(map(int,input().split()))
ahoge = []
hanege = []
for i in range(m):
ai,bi = list(map(int,input().split()))
if ai == 1:
ahoge.append(bi)
if bi == n:
hanege.append(ai)
ahoge.sort()
hanege.sort()
def bis(i):
under = 0
upper = len(hanege)-1
while under <= upper:
l = (under+upper)//2
if i == hanege[l]:
return 1
elif i < hanege[l]:
upper = l-1
elif i > hanege[l]:
under = l+1
return 0
flag = 0
for i in ahoge:
if bis(i) == 1:
print("POSSIBLE")
flag = 1
break
if flag == 0:
print("IMPOSSIBLE") | N,M = list(map(int,input().split()))
l = []
r = []
for i in range(M):
a,b = list(map(int,input().split()))
if a == 1:
l.append(b)
elif b == N:
r.append(a)
s = set(l).intersection(set(r))
print(("POSSIBLE" if len(s) else "IMPOSSIBLE")) | 31 | 11 | 661 | 258 | n, m = list(map(int, input().split()))
ahoge = []
hanege = []
for i in range(m):
ai, bi = list(map(int, input().split()))
if ai == 1:
ahoge.append(bi)
if bi == n:
hanege.append(ai)
ahoge.sort()
hanege.sort()
def bis(i):
under = 0
upper = len(hanege) - 1
while under <= upper:
l = (under + upper) // 2
if i == hanege[l]:
return 1
elif i < hanege[l]:
upper = l - 1
elif i > hanege[l]:
under = l + 1
return 0
flag = 0
for i in ahoge:
if bis(i) == 1:
print("POSSIBLE")
flag = 1
break
if flag == 0:
print("IMPOSSIBLE")
| N, M = list(map(int, input().split()))
l = []
r = []
for i in range(M):
a, b = list(map(int, input().split()))
if a == 1:
l.append(b)
elif b == N:
r.append(a)
s = set(l).intersection(set(r))
print(("POSSIBLE" if len(s) else "IMPOSSIBLE"))
| false | 64.516129 | [
"-n, m = list(map(int, input().split()))",
"-ahoge = []",
"-hanege = []",
"-for i in range(m):",
"- ai, bi = list(map(int, input().split()))",
"- if ai == 1:",
"- ahoge.append(bi)",
"- if bi == n:",
"- hanege.append(ai)",
"-ahoge.sort()",
"-hanege.sort()",
"-",
"-",
"-def bis(i):",
"- under = 0",
"- upper = len(hanege) - 1",
"- while under <= upper:",
"- l = (under + upper) // 2",
"- if i == hanege[l]:",
"- return 1",
"- elif i < hanege[l]:",
"- upper = l - 1",
"- elif i > hanege[l]:",
"- under = l + 1",
"- return 0",
"-",
"-",
"-flag = 0",
"-for i in ahoge:",
"- if bis(i) == 1:",
"- print(\"POSSIBLE\")",
"- flag = 1",
"- break",
"-if flag == 0:",
"- print(\"IMPOSSIBLE\")",
"+N, M = list(map(int, input().split()))",
"+l = []",
"+r = []",
"+for i in range(M):",
"+ a, b = list(map(int, input().split()))",
"+ if a == 1:",
"+ l.append(b)",
"+ elif b == N:",
"+ r.append(a)",
"+s = set(l).intersection(set(r))",
"+print((\"POSSIBLE\" if len(s) else \"IMPOSSIBLE\"))"
] | false | 0.054176 | 0.052904 | 1.024033 | [
"s676880910",
"s834044375"
] |
u744920373 | p03221 | python | s165073809 | s349550693 | 582 | 495 | 47,072 | 32,068 | Accepted | Accepted | 14.95 | import sys
sys.setrecursionlimit(10**8)
def ii(): 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 _ in range(N)]
def dp2(ini, i, j): return [[ini]*i for _ in range(j)]
def dp3(ini, i, j, k): return [[[ini]*i for _ in range(j)] for _ in range(k)]
import bisect #bisect.bisect_left(B, a)
#from collections import defaultdict #d = defaultdict(int) d[key] += value
def ume(x):
x = str(x)
if len(x) < 6:
return '0'*(6-len(x)) + x
return x
def main():
N, M = mi()
'''
l = dp2(0, 3, M)
cnt = [0]*(N+1)
ans = dp2(0, 2, M)
for i in range(M):
p, y = mi()
l[i][0], l[i][1], l[i][2] = p-1, y, i
cnt[p] += 1
for i in range(N):
cnt[i+1] += cnt[i]
l.sort(key=lambda x: x[0])
for i in range(N):
ichibu = l[cnt[i]:cnt[i+1]]
ichibu.sort(key=lambda x: x[1])
for j in range(cnt[i+1]-cnt[i]):
ans[ichibu[j][2]][0] = ichibu[j][0]+1
ans[ichibu[j][2]][1] = j+1
for x, y in ans:
print(ume(x)+ume(y))
'''
l = li2(M)
pos = [[] for _ in range(N+1)]
ans = dp2(0, 2, M)
for a, b in l:
pos[a].append(b)
for a in pos:
a.sort()
for i, a in enumerate(l):
ind = bisect.bisect_left(pos[a[0]], a[1])
l[i][1] = ind+1
print((ume(l[i][0])+ume(l[i][1])))
if __name__ == "__main__":
main() | import sys
sys.setrecursionlimit(10**8)
def ii(): 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 _ in range(N)]
def dp2(ini, i, j): return [[ini]*i for _ in range(j)]
def dp3(ini, i, j, k): return [[[ini]*i for _ in range(j)] for _ in range(k)]
import bisect #bisect.bisect_left(B, a)
#from collections import defaultdict #d = defaultdict(int) d[key] += value
def main():
N, M = mi()
l = dp2(0, 3, M)
for i in range(M):
p, x = mi()
l[i][0], l[i][1], l[i][2] = p, x, i
l.sort(key=lambda x :(x[0], x[1]))
ans = ['' for _ in range(M)]
cnt = 0
bf = 1
for i in range(M):
a = l[i][0]
if a > bf:
cnt = i
b, c = str(i+1-cnt), l[i][2]
ans[c] = str(a).zfill(6) + b.zfill(6)
bf = a
for a in ans:
print(a)
if __name__ == "__main__":
main() | 61 | 36 | 1,612 | 1,061 | import sys
sys.setrecursionlimit(10**8)
def ii():
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 _ in range(N)]
def dp2(ini, i, j):
return [[ini] * i for _ in range(j)]
def dp3(ini, i, j, k):
return [[[ini] * i for _ in range(j)] for _ in range(k)]
import bisect # bisect.bisect_left(B, a)
# from collections import defaultdict #d = defaultdict(int) d[key] += value
def ume(x):
x = str(x)
if len(x) < 6:
return "0" * (6 - len(x)) + x
return x
def main():
N, M = mi()
"""
l = dp2(0, 3, M)
cnt = [0]*(N+1)
ans = dp2(0, 2, M)
for i in range(M):
p, y = mi()
l[i][0], l[i][1], l[i][2] = p-1, y, i
cnt[p] += 1
for i in range(N):
cnt[i+1] += cnt[i]
l.sort(key=lambda x: x[0])
for i in range(N):
ichibu = l[cnt[i]:cnt[i+1]]
ichibu.sort(key=lambda x: x[1])
for j in range(cnt[i+1]-cnt[i]):
ans[ichibu[j][2]][0] = ichibu[j][0]+1
ans[ichibu[j][2]][1] = j+1
for x, y in ans:
print(ume(x)+ume(y))
"""
l = li2(M)
pos = [[] for _ in range(N + 1)]
ans = dp2(0, 2, M)
for a, b in l:
pos[a].append(b)
for a in pos:
a.sort()
for i, a in enumerate(l):
ind = bisect.bisect_left(pos[a[0]], a[1])
l[i][1] = ind + 1
print((ume(l[i][0]) + ume(l[i][1])))
if __name__ == "__main__":
main()
| import sys
sys.setrecursionlimit(10**8)
def ii():
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 _ in range(N)]
def dp2(ini, i, j):
return [[ini] * i for _ in range(j)]
def dp3(ini, i, j, k):
return [[[ini] * i for _ in range(j)] for _ in range(k)]
import bisect # bisect.bisect_left(B, a)
# from collections import defaultdict #d = defaultdict(int) d[key] += value
def main():
N, M = mi()
l = dp2(0, 3, M)
for i in range(M):
p, x = mi()
l[i][0], l[i][1], l[i][2] = p, x, i
l.sort(key=lambda x: (x[0], x[1]))
ans = ["" for _ in range(M)]
cnt = 0
bf = 1
for i in range(M):
a = l[i][0]
if a > bf:
cnt = i
b, c = str(i + 1 - cnt), l[i][2]
ans[c] = str(a).zfill(6) + b.zfill(6)
bf = a
for a in ans:
print(a)
if __name__ == "__main__":
main()
| false | 40.983607 | [
"-def ume(x):",
"- x = str(x)",
"- if len(x) < 6:",
"- return \"0\" * (6 - len(x)) + x",
"- return x",
"-",
"-",
"- \"\"\"",
"- cnt = [0]*(N+1)",
"- ans = dp2(0, 2, M)",
"- p, y = mi()",
"- l[i][0], l[i][1], l[i][2] = p-1, y, i",
"- cnt[p] += 1",
"- for i in range(N):",
"- cnt[i+1] += cnt[i]",
"- l.sort(key=lambda x: x[0])",
"- for i in range(N):",
"- ichibu = l[cnt[i]:cnt[i+1]]",
"- ichibu.sort(key=lambda x: x[1])",
"- for j in range(cnt[i+1]-cnt[i]):",
"- ans[ichibu[j][2]][0] = ichibu[j][0]+1",
"- ans[ichibu[j][2]][1] = j+1",
"- for x, y in ans:",
"- print(ume(x)+ume(y))",
"- \"\"\"",
"- l = li2(M)",
"- pos = [[] for _ in range(N + 1)]",
"- ans = dp2(0, 2, M)",
"- for a, b in l:",
"- pos[a].append(b)",
"- for a in pos:",
"- a.sort()",
"- for i, a in enumerate(l):",
"- ind = bisect.bisect_left(pos[a[0]], a[1])",
"- l[i][1] = ind + 1",
"- print((ume(l[i][0]) + ume(l[i][1])))",
"+ p, x = mi()",
"+ l[i][0], l[i][1], l[i][2] = p, x, i",
"+ l.sort(key=lambda x: (x[0], x[1]))",
"+ ans = [\"\" for _ in range(M)]",
"+ cnt = 0",
"+ bf = 1",
"+ for i in range(M):",
"+ a = l[i][0]",
"+ if a > bf:",
"+ cnt = i",
"+ b, c = str(i + 1 - cnt), l[i][2]",
"+ ans[c] = str(a).zfill(6) + b.zfill(6)",
"+ bf = a",
"+ for a in ans:",
"+ print(a)"
] | false | 0.073923 | 0.076363 | 0.968044 | [
"s165073809",
"s349550693"
] |
u516272298 | p03543 | python | s511521112 | s846003694 | 21 | 17 | 3,316 | 3,060 | Accepted | Accepted | 19.05 | n = list(map(int,eval(input())))
if n[0] == n[1] == n[2] or n[1] == n[2] ==n[3]:
print("Yes")
else:
print("No") | n = int(eval(input()))
n = str(n)
if n[0] == n[1] == n[2] or n[1] == n[2] == n[3]:
print("Yes")
else:
print("No") | 5 | 6 | 117 | 120 | n = list(map(int, eval(input())))
if n[0] == n[1] == n[2] or n[1] == n[2] == n[3]:
print("Yes")
else:
print("No")
| n = int(eval(input()))
n = str(n)
if n[0] == n[1] == n[2] or n[1] == n[2] == n[3]:
print("Yes")
else:
print("No")
| false | 16.666667 | [
"-n = list(map(int, eval(input())))",
"+n = int(eval(input()))",
"+n = str(n)"
] | false | 0.119213 | 0.044739 | 2.664609 | [
"s511521112",
"s846003694"
] |
u414980766 | p02888 | python | s390179105 | s289680784 | 1,006 | 853 | 3,188 | 3,188 | Accepted | Accepted | 15.21 | N = int(eval(input()))
L = sorted(list(map(int, input().split())))
res = 0
for i in range(N - 1, 1, - 1):
j = i - 1
k = 0
while j > k:
while j > k and L[i] >= L[j] + L[k]:
k += 1
res += j - k
j -= 1
print(res) | N = int(eval(input()))
L = sorted(list(map(int, input().split())))
res = 0
for i in range(N - 1, 1, - 1):
j = i - 1
k = 0
while j > k:
if L[i] < L[j] + L[k]:
res += j - k
j -= 1
else:
k += 1
print(res) | 12 | 13 | 262 | 271 | N = int(eval(input()))
L = sorted(list(map(int, input().split())))
res = 0
for i in range(N - 1, 1, -1):
j = i - 1
k = 0
while j > k:
while j > k and L[i] >= L[j] + L[k]:
k += 1
res += j - k
j -= 1
print(res)
| N = int(eval(input()))
L = sorted(list(map(int, input().split())))
res = 0
for i in range(N - 1, 1, -1):
j = i - 1
k = 0
while j > k:
if L[i] < L[j] + L[k]:
res += j - k
j -= 1
else:
k += 1
print(res)
| false | 7.692308 | [
"- while j > k and L[i] >= L[j] + L[k]:",
"+ if L[i] < L[j] + L[k]:",
"+ res += j - k",
"+ j -= 1",
"+ else:",
"- res += j - k",
"- j -= 1"
] | false | 0.054567 | 0.035252 | 1.547911 | [
"s390179105",
"s289680784"
] |
u784022244 | p03575 | python | s768266716 | s783251905 | 28 | 18 | 3,188 | 3,064 | Accepted | Accepted | 35.71 | import sys
sys.setrecursionlimit(10**6)
N,M=list(map(int, input().split()))
S=[[] for _ in range(N)]
for i in range(M):
a,b=list(map(int, input().split()))
S[a-1].append((i,b-1))
S[b-1].append((i,a-1))
def dfs(start, goal, exclude):
for i,b in S[start]:
if i==exclude or (b in dones):
continue
if b==goal:
dones.append(b)
break
else:
dones.append(b)
dfs(b,goal,exclude)
if goal not in dones:
return True
ans=[]
for i in range(N):
#m番目の辺について考える
for m,b in S[i]:
dones=[]
is_bridge=dfs(i,b,m)
#print(is_bridge)
if is_bridge and m not in ans:
ans.append(m)
print((len(ans))) | N,M=list(map(int, input().split()))
G=[[] for _ in range(N)]
for i in range(M):
a,b=list(map(int, input().split()))
G[a-1].append((i,b-1))
G[b-1].append((i,a-1))
L=[-1]*M
def dfs(start,goal,pre,num):
if start==goal:
return False
done[start]=1
for i,next_node in G[start]:
if next_node==pre or i==num or done[next_node]==1:
continue
if not dfs(next_node,goal,start,num):
return False
return True
for a in range(N):
for t in G[a]:
i,b=t
done=[0]*N
if L[i]==-1:
#print(dfs(a,b,-1,i))
if dfs(a,b,-1,i):
L[i]=1
else:
L[i]=0
print((sum(L)))
#print(L) | 32 | 32 | 680 | 652 | import sys
sys.setrecursionlimit(10**6)
N, M = list(map(int, input().split()))
S = [[] for _ in range(N)]
for i in range(M):
a, b = list(map(int, input().split()))
S[a - 1].append((i, b - 1))
S[b - 1].append((i, a - 1))
def dfs(start, goal, exclude):
for i, b in S[start]:
if i == exclude or (b in dones):
continue
if b == goal:
dones.append(b)
break
else:
dones.append(b)
dfs(b, goal, exclude)
if goal not in dones:
return True
ans = []
for i in range(N):
# m番目の辺について考える
for m, b in S[i]:
dones = []
is_bridge = dfs(i, b, m)
# print(is_bridge)
if is_bridge and m not in ans:
ans.append(m)
print((len(ans)))
| N, M = list(map(int, input().split()))
G = [[] for _ in range(N)]
for i in range(M):
a, b = list(map(int, input().split()))
G[a - 1].append((i, b - 1))
G[b - 1].append((i, a - 1))
L = [-1] * M
def dfs(start, goal, pre, num):
if start == goal:
return False
done[start] = 1
for i, next_node in G[start]:
if next_node == pre or i == num or done[next_node] == 1:
continue
if not dfs(next_node, goal, start, num):
return False
return True
for a in range(N):
for t in G[a]:
i, b = t
done = [0] * N
if L[i] == -1:
# print(dfs(a,b,-1,i))
if dfs(a, b, -1, i):
L[i] = 1
else:
L[i] = 0
print((sum(L)))
# print(L)
| false | 0 | [
"-import sys",
"-",
"-sys.setrecursionlimit(10**6)",
"-S = [[] for _ in range(N)]",
"+G = [[] for _ in range(N)]",
"- S[a - 1].append((i, b - 1))",
"- S[b - 1].append((i, a - 1))",
"+ G[a - 1].append((i, b - 1))",
"+ G[b - 1].append((i, a - 1))",
"+L = [-1] * M",
"-def dfs(start, goal, exclude):",
"- for i, b in S[start]:",
"- if i == exclude or (b in dones):",
"+def dfs(start, goal, pre, num):",
"+ if start == goal:",
"+ return False",
"+ done[start] = 1",
"+ for i, next_node in G[start]:",
"+ if next_node == pre or i == num or done[next_node] == 1:",
"- if b == goal:",
"- dones.append(b)",
"- break",
"- else:",
"- dones.append(b)",
"- dfs(b, goal, exclude)",
"- if goal not in dones:",
"- return True",
"+ if not dfs(next_node, goal, start, num):",
"+ return False",
"+ return True",
"-ans = []",
"-for i in range(N):",
"- # m番目の辺について考える",
"- for m, b in S[i]:",
"- dones = []",
"- is_bridge = dfs(i, b, m)",
"- # print(is_bridge)",
"- if is_bridge and m not in ans:",
"- ans.append(m)",
"-print((len(ans)))",
"+for a in range(N):",
"+ for t in G[a]:",
"+ i, b = t",
"+ done = [0] * N",
"+ if L[i] == -1:",
"+ # print(dfs(a,b,-1,i))",
"+ if dfs(a, b, -1, i):",
"+ L[i] = 1",
"+ else:",
"+ L[i] = 0",
"+print((sum(L)))",
"+# print(L)"
] | false | 0.079816 | 0.102416 | 0.779332 | [
"s768266716",
"s783251905"
] |
u123756661 | p03061 | python | s076153033 | s841432996 | 1,496 | 355 | 63,984 | 84,792 | Accepted | Accepted | 76.27 | def div(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)
return divisors
n=int(eval(input()))
at=[int(i) for i in input().split()]
a=set(at)
d={}
for i,j in enumerate(a):
t=div(j)
for k in t:
if k in d:
d[k]+=1
elif i==0 or k not in d:
d[k]=1
ans=1
for i in d:
x=0
for j in at:
if j%i: x+=1
if x<2: ans=max(ans,i)
print(ans)
| n=int(eval(input()))
a=[int(i) for i in input().split()]
d={}
for i,j in enumerate(a):
if i<2:
k=1
while 1:
if k*k>j: break
if j%k==0:
if k in d:
d[k]+=1
else:
d[k]=1
if j%k==0 and k*k!=j:
if j//k in d:
d[j//k]+=1
else:
d[j//k]=1
k+=1
else:
for k in d:
if j%k==0:
if k in d:
d[k]+=1
elif j%k==0 and k*k!=j:
if j//k in d:
d[j//k]+=1
#print(d)
ans=chk=0
for i in d:
if d[i]>=n-1:
ans=max(ans,i)
print(ans)
| 28 | 33 | 551 | 762 | def div(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)
return divisors
n = int(eval(input()))
at = [int(i) for i in input().split()]
a = set(at)
d = {}
for i, j in enumerate(a):
t = div(j)
for k in t:
if k in d:
d[k] += 1
elif i == 0 or k not in d:
d[k] = 1
ans = 1
for i in d:
x = 0
for j in at:
if j % i:
x += 1
if x < 2:
ans = max(ans, i)
print(ans)
| n = int(eval(input()))
a = [int(i) for i in input().split()]
d = {}
for i, j in enumerate(a):
if i < 2:
k = 1
while 1:
if k * k > j:
break
if j % k == 0:
if k in d:
d[k] += 1
else:
d[k] = 1
if j % k == 0 and k * k != j:
if j // k in d:
d[j // k] += 1
else:
d[j // k] = 1
k += 1
else:
for k in d:
if j % k == 0:
if k in d:
d[k] += 1
elif j % k == 0 and k * k != j:
if j // k in d:
d[j // k] += 1
# print(d)
ans = chk = 0
for i in d:
if d[i] >= n - 1:
ans = max(ans, i)
print(ans)
| false | 15.151515 | [
"-def div(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)",
"- return divisors",
"-",
"-",
"-at = [int(i) for i in input().split()]",
"-a = set(at)",
"+a = [int(i) for i in input().split()]",
"- t = div(j)",
"- for k in t:",
"- if k in d:",
"- d[k] += 1",
"- elif i == 0 or k not in d:",
"- d[k] = 1",
"-ans = 1",
"+ if i < 2:",
"+ k = 1",
"+ while 1:",
"+ if k * k > j:",
"+ break",
"+ if j % k == 0:",
"+ if k in d:",
"+ d[k] += 1",
"+ else:",
"+ d[k] = 1",
"+ if j % k == 0 and k * k != j:",
"+ if j // k in d:",
"+ d[j // k] += 1",
"+ else:",
"+ d[j // k] = 1",
"+ k += 1",
"+ else:",
"+ for k in d:",
"+ if j % k == 0:",
"+ if k in d:",
"+ d[k] += 1",
"+ elif j % k == 0 and k * k != j:",
"+ if j // k in d:",
"+ d[j // k] += 1",
"+# print(d)",
"+ans = chk = 0",
"- x = 0",
"- for j in at:",
"- if j % i:",
"- x += 1",
"- if x < 2:",
"+ if d[i] >= n - 1:"
] | false | 0.037139 | 0.183258 | 0.202658 | [
"s076153033",
"s841432996"
] |
u263830634 | p03488 | python | s067777754 | s110655480 | 1,170 | 184 | 3,316 | 13,568 | Accepted | Accepted | 84.27 | s = list(eval(input()))
x, y = list(map(int, input().split()))
X = [0]
Y = [0]
flag = True
tmp = 0
for i in s:
if i == 'F':
tmp += 1
else:
if flag:
X.append(tmp)
else:
Y.append(tmp)
tmp = 0
flag = not flag
if flag:
X.append(tmp)
else:
Y.append(tmp)
# print (X)
# print (Y)
x -= X[1]
X[1] = 0
x = abs(x)
y = abs(y)
total_X = sum(X)
total_Y = sum(Y)
lst_X = [0] * (total_X + 1)
lst_X[0] = 1
for i in X:
if i == 0:
continue
for j in range(total_X - i, -1, -1):
if lst_X[j] == 1:
lst_X[j + i] = 1
# print (lst_X)
lst_Y = [0] * (total_Y + 1)
lst_Y[0] = 1
for i in Y:
if i == 0:
continue
for j in range(total_Y - i, -1, -1):
if lst_Y[j] == 1:
lst_Y[j + i] = 1
# print (lst_Y)
if x > total_X or y > total_Y:
print ('No')
exit()
if (total_X - x) % 2 == (total_Y - y) % 2 == 0 and lst_X[(total_X - x) // 2] == 1 and lst_Y[(total_Y - y) // 2]:
print ('Yes')
else:
print ('No') | import numpy as np
s = list(eval(input()))
x, y = list(map(int, input().split()))
X = [0]
Y = [0]
flag = True
tmp = 0
for i in s:
if i == 'F':
tmp += 1
else:
if flag:
X.append(tmp)
else:
Y.append(tmp)
tmp = 0
flag = not flag
if flag:
X.append(tmp)
else:
Y.append(tmp)
# print (X)
# print (Y)
x -= X[1]
X[1] = 0
x = abs(x)
y = abs(y)
total_X = sum(X)
total_Y = sum(Y)
lst_X = np.zeros(total_X + 1, dtype = np.int32)
lst_X[0] = 1
for i in X:
if i == 0:
continue
# print (lst_X)
# print (lst_X[i:])
# print (lst_X[:-i])
# print (np.maximum(lst_X[i:], lst_X[:-i]))
lst_X[i:] = np.maximum(lst_X[i:], lst_X[:-i])
# print (lst_X)
lst_Y = np.zeros(total_Y + 1)
lst_Y[0] = 1
for i in Y:
if i == 0:
continue
lst_Y[i:] = np.maximum(lst_Y[i:], lst_Y[:-i])
if x > total_X or y > total_Y:
print ('No')
exit()
if (total_X - x) % 2 == (total_Y - y) % 2 == 0 and int(lst_X[(total_X - x) // 2]) == 1 and int(lst_Y[(total_Y - y) // 2]) == 1:
print ('Yes')
else:
print ('No') | 65 | 66 | 1,098 | 1,165 | s = list(eval(input()))
x, y = list(map(int, input().split()))
X = [0]
Y = [0]
flag = True
tmp = 0
for i in s:
if i == "F":
tmp += 1
else:
if flag:
X.append(tmp)
else:
Y.append(tmp)
tmp = 0
flag = not flag
if flag:
X.append(tmp)
else:
Y.append(tmp)
# print (X)
# print (Y)
x -= X[1]
X[1] = 0
x = abs(x)
y = abs(y)
total_X = sum(X)
total_Y = sum(Y)
lst_X = [0] * (total_X + 1)
lst_X[0] = 1
for i in X:
if i == 0:
continue
for j in range(total_X - i, -1, -1):
if lst_X[j] == 1:
lst_X[j + i] = 1
# print (lst_X)
lst_Y = [0] * (total_Y + 1)
lst_Y[0] = 1
for i in Y:
if i == 0:
continue
for j in range(total_Y - i, -1, -1):
if lst_Y[j] == 1:
lst_Y[j + i] = 1
# print (lst_Y)
if x > total_X or y > total_Y:
print("No")
exit()
if (
(total_X - x) % 2 == (total_Y - y) % 2 == 0
and lst_X[(total_X - x) // 2] == 1
and lst_Y[(total_Y - y) // 2]
):
print("Yes")
else:
print("No")
| import numpy as np
s = list(eval(input()))
x, y = list(map(int, input().split()))
X = [0]
Y = [0]
flag = True
tmp = 0
for i in s:
if i == "F":
tmp += 1
else:
if flag:
X.append(tmp)
else:
Y.append(tmp)
tmp = 0
flag = not flag
if flag:
X.append(tmp)
else:
Y.append(tmp)
# print (X)
# print (Y)
x -= X[1]
X[1] = 0
x = abs(x)
y = abs(y)
total_X = sum(X)
total_Y = sum(Y)
lst_X = np.zeros(total_X + 1, dtype=np.int32)
lst_X[0] = 1
for i in X:
if i == 0:
continue
# print (lst_X)
# print (lst_X[i:])
# print (lst_X[:-i])
# print (np.maximum(lst_X[i:], lst_X[:-i]))
lst_X[i:] = np.maximum(lst_X[i:], lst_X[:-i])
# print (lst_X)
lst_Y = np.zeros(total_Y + 1)
lst_Y[0] = 1
for i in Y:
if i == 0:
continue
lst_Y[i:] = np.maximum(lst_Y[i:], lst_Y[:-i])
if x > total_X or y > total_Y:
print("No")
exit()
if (
(total_X - x) % 2 == (total_Y - y) % 2 == 0
and int(lst_X[(total_X - x) // 2]) == 1
and int(lst_Y[(total_Y - y) // 2]) == 1
):
print("Yes")
else:
print("No")
| false | 1.515152 | [
"+import numpy as np",
"+",
"-lst_X = [0] * (total_X + 1)",
"+lst_X = np.zeros(total_X + 1, dtype=np.int32)",
"- for j in range(total_X - i, -1, -1):",
"- if lst_X[j] == 1:",
"- lst_X[j + i] = 1",
"+ # print (lst_X)",
"+ # print (lst_X[i:])",
"+ # print (lst_X[:-i])",
"+ # print (np.maximum(lst_X[i:], lst_X[:-i]))",
"+ lst_X[i:] = np.maximum(lst_X[i:], lst_X[:-i])",
"-lst_Y = [0] * (total_Y + 1)",
"+lst_Y = np.zeros(total_Y + 1)",
"- for j in range(total_Y - i, -1, -1):",
"- if lst_Y[j] == 1:",
"- lst_Y[j + i] = 1",
"-# print (lst_Y)",
"+ lst_Y[i:] = np.maximum(lst_Y[i:], lst_Y[:-i])",
"- and lst_X[(total_X - x) // 2] == 1",
"- and lst_Y[(total_Y - y) // 2]",
"+ and int(lst_X[(total_X - x) // 2]) == 1",
"+ and int(lst_Y[(total_Y - y) // 2]) == 1"
] | false | 0.041613 | 0.209081 | 0.199028 | [
"s067777754",
"s110655480"
] |
u504836877 | p04046 | python | s830933891 | s669878261 | 645 | 428 | 51,284 | 27,004 | Accepted | Accepted | 33.64 | H,W,A,B = list(map(int, input().split()))
def cmb(n, r, mod):
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % mod
mod = 10**9+7 #出力の制限
n = 3*10**5
g1 = [1, 1] # 元テーブル
g2 = [1, 1] #逆元テーブル
inverse = [0, 1] #逆元テーブル計算用テーブル
for i in range( 2, n + 1 ):
g1.append( ( g1[-1] * i ) % mod )
inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )
g2.append( (g2[-1] * inverse[-1]) % mod )
L = []
i = H-A
j = B+1
while i > 0 and j <= W:
L.append((i, j))
i -= 1
j += 1
ans = 0
for t in L:
i = t[0]
j = t[1]
ans += (cmb(i+j-2, i-1, mod) * cmb(H-i+W-j, H-i, mod)) % mod
ans %= mod
print(ans) | H,W,A,B = list(map(int, input().split()))
def cmb(n, r, mod):
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % mod
mod = 10**9+7 #出力の制限
g1 = [1, 1] # 元テーブル
g2 = [1, 1] #逆元テーブル
inverse = [0, 1] #逆元テーブル計算用テーブル
for i in range( 2, H+W + 1 ):
g1.append( ( g1[-1] * i ) % mod )
inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )
g2.append( (g2[-1] * inverse[-1]) % mod )
ans = 0
for h in range(1, H-A+1):
ans += cmb(h-1+B-1, h-1, mod)*cmb(H-h+W-B-1, H-h, mod)
ans %= mod
print(ans) | 35 | 24 | 709 | 571 | H, W, A, B = list(map(int, input().split()))
def cmb(n, r, mod):
if r < 0 or r > n:
return 0
r = min(r, n - r)
return g1[n] * g2[r] * g2[n - r] % mod
mod = 10**9 + 7 # 出力の制限
n = 3 * 10**5
g1 = [1, 1] # 元テーブル
g2 = [1, 1] # 逆元テーブル
inverse = [0, 1] # 逆元テーブル計算用テーブル
for i in range(2, n + 1):
g1.append((g1[-1] * i) % mod)
inverse.append((-inverse[mod % i] * (mod // i)) % mod)
g2.append((g2[-1] * inverse[-1]) % mod)
L = []
i = H - A
j = B + 1
while i > 0 and j <= W:
L.append((i, j))
i -= 1
j += 1
ans = 0
for t in L:
i = t[0]
j = t[1]
ans += (cmb(i + j - 2, i - 1, mod) * cmb(H - i + W - j, H - i, mod)) % mod
ans %= mod
print(ans)
| H, W, A, B = list(map(int, input().split()))
def cmb(n, r, mod):
if r < 0 or r > n:
return 0
r = min(r, n - r)
return g1[n] * g2[r] * g2[n - r] % mod
mod = 10**9 + 7 # 出力の制限
g1 = [1, 1] # 元テーブル
g2 = [1, 1] # 逆元テーブル
inverse = [0, 1] # 逆元テーブル計算用テーブル
for i in range(2, H + W + 1):
g1.append((g1[-1] * i) % mod)
inverse.append((-inverse[mod % i] * (mod // i)) % mod)
g2.append((g2[-1] * inverse[-1]) % mod)
ans = 0
for h in range(1, H - A + 1):
ans += cmb(h - 1 + B - 1, h - 1, mod) * cmb(H - h + W - B - 1, H - h, mod)
ans %= mod
print(ans)
| false | 31.428571 | [
"-n = 3 * 10**5",
"-for i in range(2, n + 1):",
"+for i in range(2, H + W + 1):",
"-L = []",
"-i = H - A",
"-j = B + 1",
"-while i > 0 and j <= W:",
"- L.append((i, j))",
"- i -= 1",
"- j += 1",
"-for t in L:",
"- i = t[0]",
"- j = t[1]",
"- ans += (cmb(i + j - 2, i - 1, mod) * cmb(H - i + W - j, H - i, mod)) % mod",
"+for h in range(1, H - A + 1):",
"+ ans += cmb(h - 1 + B - 1, h - 1, mod) * cmb(H - h + W - B - 1, H - h, mod)"
] | false | 1.337803 | 0.073675 | 18.158265 | [
"s830933891",
"s669878261"
] |
u790710233 | p02901 | python | s099045470 | s779895025 | 435 | 283 | 78,680 | 45,272 | Accepted | Accepted | 34.94 | n, m = list(map(int, input().split()))
can_open = []
cost = []
for _ in range(m):
a, b = list(map(int, input().split()))
cost.append(a)
it = list(map(int, input().split()))
x = 0
for c in it:
x += 1 << (c-1)
can_open.append(x)
n_bit = 1 << n
INF = 10**18
dp = [[INF]*(m+1) for _ in range(n_bit)]
dp[0][0] = 0
for j in range(n_bit):
for i in range(m):
dp[j][i+1] = min(dp[j][i+1], dp[j][i])
dp[j | can_open[i]][i +
1] = min(dp[j | can_open[i]][i+1], dp[j][i+1]+cost[i])
print((dp[-1][-1] if dp[-1][-1] != INF else -1))
| n, m = list(map(int, input().split()))
can_open = []
cost = []
for _ in range(m):
a, b = list(map(int, input().split()))
cost.append(a)
it = list(map(int, input().split()))
x = 0
for c in it:
x += 1 << (c-1)
can_open.append(x)
n_bit = 1 << n
INF = 10**18
dp = [INF]*n_bit
dp[0] = 0
for j in range(n_bit):
for i in range(m):
dp[j | can_open[i]] = min(dp[j | can_open[i]], dp[j]+cost[i])
print((dp[-1] if dp[-1] != INF else -1))
| 24 | 22 | 604 | 475 | n, m = list(map(int, input().split()))
can_open = []
cost = []
for _ in range(m):
a, b = list(map(int, input().split()))
cost.append(a)
it = list(map(int, input().split()))
x = 0
for c in it:
x += 1 << (c - 1)
can_open.append(x)
n_bit = 1 << n
INF = 10**18
dp = [[INF] * (m + 1) for _ in range(n_bit)]
dp[0][0] = 0
for j in range(n_bit):
for i in range(m):
dp[j][i + 1] = min(dp[j][i + 1], dp[j][i])
dp[j | can_open[i]][i + 1] = min(
dp[j | can_open[i]][i + 1], dp[j][i + 1] + cost[i]
)
print((dp[-1][-1] if dp[-1][-1] != INF else -1))
| n, m = list(map(int, input().split()))
can_open = []
cost = []
for _ in range(m):
a, b = list(map(int, input().split()))
cost.append(a)
it = list(map(int, input().split()))
x = 0
for c in it:
x += 1 << (c - 1)
can_open.append(x)
n_bit = 1 << n
INF = 10**18
dp = [INF] * n_bit
dp[0] = 0
for j in range(n_bit):
for i in range(m):
dp[j | can_open[i]] = min(dp[j | can_open[i]], dp[j] + cost[i])
print((dp[-1] if dp[-1] != INF else -1))
| false | 8.333333 | [
"-dp = [[INF] * (m + 1) for _ in range(n_bit)]",
"-dp[0][0] = 0",
"+dp = [INF] * n_bit",
"+dp[0] = 0",
"- dp[j][i + 1] = min(dp[j][i + 1], dp[j][i])",
"- dp[j | can_open[i]][i + 1] = min(",
"- dp[j | can_open[i]][i + 1], dp[j][i + 1] + cost[i]",
"- )",
"-print((dp[-1][-1] if dp[-1][-1] != INF else -1))",
"+ dp[j | can_open[i]] = min(dp[j | can_open[i]], dp[j] + cost[i])",
"+print((dp[-1] if dp[-1] != INF else -1))"
] | false | 0.039917 | 0.082746 | 0.482406 | [
"s099045470",
"s779895025"
] |
u968166680 | p02862 | python | s946548318 | s252520946 | 888 | 233 | 82,164 | 54,512 | Accepted | Accepted | 73.76 | from sys import stdin, setrecursionlimit
setrecursionlimit(10 ** 9)
INF = 1 << 60
def input():
return stdin.readline().strip()
X, Y = list(map(int, input().split()))
if (X + Y) % 3:
print((0))
exit()
n = (X + Y) // 3
x = (2 * X - Y) // 3
y = (-X + 2 * Y) // 3
if x < 0 or y < 0:
print((0))
exit()
MOD = 1000000007
COM_MAX = n
fac, finv, inv = [0] * (COM_MAX + 1), [0] * (COM_MAX + 1), [0] * (COM_MAX + 1)
fac[0] = fac[1] = 1
finv[0] = finv[1] = 1
inv[1] = 1
for i in range(2, COM_MAX + 1):
fac[i] = fac[i - 1] * i % MOD
inv[i] = MOD - inv[MOD % i] * (MOD // i) % MOD
finv[i] = finv[i - 1] * inv[i] % MOD
def mod_com(n, k):
if n < k:
return 0
if n < 0 or k < 0:
return 0
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD
print((mod_com(n, x)))
| from sys import stdin, setrecursionlimit
setrecursionlimit(10 ** 9)
INF = 1 << 60
def input():
return stdin.readline().strip()
X, Y = list(map(int, input().split()))
n = (X + Y) // 3
x = (2 * X - Y) // 3
y = (-X + 2 * Y) // 3
if (X + Y) % 3 or x < 0 or y < 0:
print((0))
exit()
MOD = 1000000007
COM_MAX = n
fac, finv, inv = [0] * (COM_MAX + 1), [0] * (COM_MAX + 1), [0] * (COM_MAX + 1)
fac[0] = fac[1] = 1
finv[0] = finv[1] = 1
inv[1] = 1
for i in range(2, COM_MAX + 1):
fac[i] = fac[i - 1] * i % MOD
inv[i] = MOD - inv[MOD % i] * (MOD // i) % MOD
finv[i] = finv[i - 1] * inv[i] % MOD
def mod_com(n, k):
if n < k:
return 0
if n < 0 or k < 0:
return 0
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD
print((mod_com(n, x)))
| 46 | 42 | 852 | 822 | from sys import stdin, setrecursionlimit
setrecursionlimit(10**9)
INF = 1 << 60
def input():
return stdin.readline().strip()
X, Y = list(map(int, input().split()))
if (X + Y) % 3:
print((0))
exit()
n = (X + Y) // 3
x = (2 * X - Y) // 3
y = (-X + 2 * Y) // 3
if x < 0 or y < 0:
print((0))
exit()
MOD = 1000000007
COM_MAX = n
fac, finv, inv = [0] * (COM_MAX + 1), [0] * (COM_MAX + 1), [0] * (COM_MAX + 1)
fac[0] = fac[1] = 1
finv[0] = finv[1] = 1
inv[1] = 1
for i in range(2, COM_MAX + 1):
fac[i] = fac[i - 1] * i % MOD
inv[i] = MOD - inv[MOD % i] * (MOD // i) % MOD
finv[i] = finv[i - 1] * inv[i] % MOD
def mod_com(n, k):
if n < k:
return 0
if n < 0 or k < 0:
return 0
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD
print((mod_com(n, x)))
| from sys import stdin, setrecursionlimit
setrecursionlimit(10**9)
INF = 1 << 60
def input():
return stdin.readline().strip()
X, Y = list(map(int, input().split()))
n = (X + Y) // 3
x = (2 * X - Y) // 3
y = (-X + 2 * Y) // 3
if (X + Y) % 3 or x < 0 or y < 0:
print((0))
exit()
MOD = 1000000007
COM_MAX = n
fac, finv, inv = [0] * (COM_MAX + 1), [0] * (COM_MAX + 1), [0] * (COM_MAX + 1)
fac[0] = fac[1] = 1
finv[0] = finv[1] = 1
inv[1] = 1
for i in range(2, COM_MAX + 1):
fac[i] = fac[i - 1] * i % MOD
inv[i] = MOD - inv[MOD % i] * (MOD // i) % MOD
finv[i] = finv[i - 1] * inv[i] % MOD
def mod_com(n, k):
if n < k:
return 0
if n < 0 or k < 0:
return 0
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD
print((mod_com(n, x)))
| false | 8.695652 | [
"-if (X + Y) % 3:",
"- print((0))",
"- exit()",
"-if x < 0 or y < 0:",
"+if (X + Y) % 3 or x < 0 or y < 0:"
] | false | 0.262421 | 0.917338 | 0.286068 | [
"s946548318",
"s252520946"
] |
u729133443 | p02731 | python | s728942247 | s017760788 | 165 | 10 | 38,256 | 2,572 | Accepted | Accepted | 93.94 | print((int(eval(input()))**3/27)) | print(input()**3/27.0) | 1 | 1 | 25 | 21 | print((int(eval(input())) ** 3 / 27))
| print(input() ** 3 / 27.0)
| false | 0 | [
"-print((int(eval(input())) ** 3 / 27))",
"+print(input() ** 3 / 27.0)"
] | false | 0.078056 | 0.03586 | 2.17669 | [
"s728942247",
"s017760788"
] |
u936985471 | p02834 | python | s125715412 | s943119591 | 617 | 353 | 29,360 | 33,432 | Accepted | Accepted | 42.79 | N,u,v=list(map(int,input().split()))
E=[[] for i in range(N)]
for i in range(N-1):
a,b=list(map(int,input().split()))
E[a-1].append(b-1)
E[b-1].append(a-1)
distU=[0]*N
distV=[0]*N
stack=[]
stack.append([u-1,0,-1])
while stack:
node=stack.pop()
e=node[0]
dist=node[1]
parent=node[2]
distU[e]=dist
children=E[e]
for child in children:
if child==parent:
continue
stack.append([child,dist+1,e])
stack=[]
stack.append([v-1,0,-1])
while stack:
node=stack.pop()
e=node[0]
dist=node[1]
parent=node[2]
distV[e]=dist
children=E[e]
for child in children:
if child==parent:
continue
stack.append([child,dist+1,e])
maxdist=0
for i in range(N):
if maxdist<distV[i] and distU[i]<distV[i]:
maxdist=distV[i]
print((maxdist-1))
| import sys
readline = sys.stdin.readline
# 青木君からの到達距離 - 高橋君からの到達距離が最も大きい場所に逃げるべき
# そこに到達したときに、
# 高橋君と青木君の距離が偶数のとき
# 青 - x - x - x - 高
# 青 - x - x - 高 - x
# x - 青 - x - 高 - x
# x - 青 - x - x - 高
# x - x - 青 - x - 高
# x - x - 青- 高 - x
# x - x - x - 終 - x
# 青木君からの距離 - 1が答え
# 高橋君と青木君の距離が奇数のとき
# 青 - x - x - 高
# 青 - x - 高 - x
# x - 青 - 高 - x
# x - 青 - x - 高
# x - x - 青 - 高
# x - x - 終 - x
# やっぱり青木君からの距離 - 1が答え
# つまり、
# ・[青木君からの距離が遠い場所について]
# ・[青木君からの距離 - 1]が答え
N,u,v = list(map(int,readline().split()))
G = [[] for i in range(N)]
for i in range(N - 1):
a,b = list(map(int,readline().split()))
G[a - 1].append(b - 1)
G[b - 1].append(a - 1)
dist_from_u = [0 for i in range(N)] # 高橋君からの距離
dist_from_v = [0 for i in range(N)] # 青木君からの距離
stack = []
# 頂点, 高橋君からの距離, 親
stack.append([u - 1,0,-1])
while stack:
e, dist, parent = stack.pop()
dist_from_u[e] = dist
for child in G[e]:
if child == parent:
continue
stack.append([child, dist + 1, e])
stack = []
# 頂点, 青木君からの距離, 親
stack.append([v - 1,0,-1])
while stack:
e, dist, parent = stack.pop()
dist_from_v[e] = dist
for child in G[e]:
if child == parent:
continue
stack.append([child, dist + 1, e])
maxdiff_from_v = 0
for i in range(N):
if dist_from_u[i] < dist_from_v[i]:
if maxdiff_from_v < dist_from_v[i]:
maxdiff_from_v = dist_from_v[i]
print((maxdiff_from_v - 1))
| 44 | 65 | 818 | 1,434 | N, u, v = list(map(int, input().split()))
E = [[] for i in range(N)]
for i in range(N - 1):
a, b = list(map(int, input().split()))
E[a - 1].append(b - 1)
E[b - 1].append(a - 1)
distU = [0] * N
distV = [0] * N
stack = []
stack.append([u - 1, 0, -1])
while stack:
node = stack.pop()
e = node[0]
dist = node[1]
parent = node[2]
distU[e] = dist
children = E[e]
for child in children:
if child == parent:
continue
stack.append([child, dist + 1, e])
stack = []
stack.append([v - 1, 0, -1])
while stack:
node = stack.pop()
e = node[0]
dist = node[1]
parent = node[2]
distV[e] = dist
children = E[e]
for child in children:
if child == parent:
continue
stack.append([child, dist + 1, e])
maxdist = 0
for i in range(N):
if maxdist < distV[i] and distU[i] < distV[i]:
maxdist = distV[i]
print((maxdist - 1))
| import sys
readline = sys.stdin.readline
# 青木君からの到達距離 - 高橋君からの到達距離が最も大きい場所に逃げるべき
# そこに到達したときに、
# 高橋君と青木君の距離が偶数のとき
# 青 - x - x - x - 高
# 青 - x - x - 高 - x
# x - 青 - x - 高 - x
# x - 青 - x - x - 高
# x - x - 青 - x - 高
# x - x - 青- 高 - x
# x - x - x - 終 - x
# 青木君からの距離 - 1が答え
# 高橋君と青木君の距離が奇数のとき
# 青 - x - x - 高
# 青 - x - 高 - x
# x - 青 - 高 - x
# x - 青 - x - 高
# x - x - 青 - 高
# x - x - 終 - x
# やっぱり青木君からの距離 - 1が答え
# つまり、
# ・[青木君からの距離が遠い場所について]
# ・[青木君からの距離 - 1]が答え
N, u, v = list(map(int, readline().split()))
G = [[] for i in range(N)]
for i in range(N - 1):
a, b = list(map(int, readline().split()))
G[a - 1].append(b - 1)
G[b - 1].append(a - 1)
dist_from_u = [0 for i in range(N)] # 高橋君からの距離
dist_from_v = [0 for i in range(N)] # 青木君からの距離
stack = []
# 頂点, 高橋君からの距離, 親
stack.append([u - 1, 0, -1])
while stack:
e, dist, parent = stack.pop()
dist_from_u[e] = dist
for child in G[e]:
if child == parent:
continue
stack.append([child, dist + 1, e])
stack = []
# 頂点, 青木君からの距離, 親
stack.append([v - 1, 0, -1])
while stack:
e, dist, parent = stack.pop()
dist_from_v[e] = dist
for child in G[e]:
if child == parent:
continue
stack.append([child, dist + 1, e])
maxdiff_from_v = 0
for i in range(N):
if dist_from_u[i] < dist_from_v[i]:
if maxdiff_from_v < dist_from_v[i]:
maxdiff_from_v = dist_from_v[i]
print((maxdiff_from_v - 1))
| false | 32.307692 | [
"-N, u, v = list(map(int, input().split()))",
"-E = [[] for i in range(N)]",
"+import sys",
"+",
"+readline = sys.stdin.readline",
"+# 青木君からの到達距離 - 高橋君からの到達距離が最も大きい場所に逃げるべき",
"+# そこに到達したときに、",
"+# 高橋君と青木君の距離が偶数のとき",
"+# 青 - x - x - x - 高",
"+# 青 - x - x - 高 - x",
"+# x - 青 - x - 高 - x",
"+# x - 青 - x - x - 高",
"+# x - x - 青 - x - 高",
"+# x - x - 青- 高 - x",
"+# x - x - x - 終 - x",
"+# 青木君からの距離 - 1が答え",
"+# 高橋君と青木君の距離が奇数のとき",
"+# 青 - x - x - 高",
"+# 青 - x - 高 - x",
"+# x - 青 - 高 - x",
"+# x - 青 - x - 高",
"+# x - x - 青 - 高",
"+# x - x - 終 - x",
"+# やっぱり青木君からの距離 - 1が答え",
"+# つまり、",
"+# ・[青木君からの距離が遠い場所について]",
"+# ・[青木君からの距離 - 1]が答え",
"+N, u, v = list(map(int, readline().split()))",
"+G = [[] for i in range(N)]",
"- a, b = list(map(int, input().split()))",
"- E[a - 1].append(b - 1)",
"- E[b - 1].append(a - 1)",
"-distU = [0] * N",
"-distV = [0] * N",
"+ a, b = list(map(int, readline().split()))",
"+ G[a - 1].append(b - 1)",
"+ G[b - 1].append(a - 1)",
"+dist_from_u = [0 for i in range(N)] # 高橋君からの距離",
"+dist_from_v = [0 for i in range(N)] # 青木君からの距離",
"+# 頂点, 高橋君からの距離, 親",
"- node = stack.pop()",
"- e = node[0]",
"- dist = node[1]",
"- parent = node[2]",
"- distU[e] = dist",
"- children = E[e]",
"- for child in children:",
"+ e, dist, parent = stack.pop()",
"+ dist_from_u[e] = dist",
"+ for child in G[e]:",
"+# 頂点, 青木君からの距離, 親",
"- node = stack.pop()",
"- e = node[0]",
"- dist = node[1]",
"- parent = node[2]",
"- distV[e] = dist",
"- children = E[e]",
"- for child in children:",
"+ e, dist, parent = stack.pop()",
"+ dist_from_v[e] = dist",
"+ for child in G[e]:",
"-maxdist = 0",
"+maxdiff_from_v = 0",
"- if maxdist < distV[i] and distU[i] < distV[i]:",
"- maxdist = distV[i]",
"-print((maxdist - 1))",
"+ if dist_from_u[i] < dist_from_v[i]:",
"+ if maxdiff_from_v < dist_from_v[i]:",
"+ maxdiff_from_v = dist_from_v[i]",
"+print((maxdiff_from_v - 1))"
] | false | 0.036754 | 0.034574 | 1.06306 | [
"s125715412",
"s943119591"
] |
u170201762 | p02902 | python | s574696954 | s066776536 | 1,560 | 1,150 | 140,552 | 126,424 | Accepted | Accepted | 26.28 | INF = float('inf')
from collections import defaultdict
from heapq import heappop, heappush
class Graph(object):
def __init__(self):
self.graph = defaultdict(list)
def __len__(self):
return len(self.graph)
def add_edge(self, From, To, cost=1):
self.graph[From].append((To,cost))
def get_nodes(self):
return list(self.graph.keys())
class Dijkstra(object):
def __init__(self, graph, start):
self.g = graph.graph
self.dist = defaultdict(lambda:INF)
self.dist[start] = 0
self.prev = defaultdict(lambda: None)
self.Q = []
heappush(self.Q,(self.dist[start], start))
while self.Q:
dist_u, u = heappop(self.Q)
if self.dist[u] < dist_u:
continue
for v, cost in self.g[u]:
alt = dist_u + cost
if self.dist[v] > alt:
self.dist[v] = alt
self.prev[v] = u
heappush(self.Q,(alt, v))
def shortest_distance(self, goal):
return self.dist[goal]
def shortest_path(self, goal):
path = []
node = goal
while node is not None:
path.append(node)
node = self.prev[node]
return path[::-1]
N, M = list(map(int,input().split()))
g = Graph()
for i in range(M):
a,b = list(map(int,input().split()))
a -= 1
b -= 1
g.add_edge(a,b)
g.add_edge(a,b+N)
g.add_edge(a+N,b)
ans = INF
j = -1
for i in range(N):
d = Dijkstra(g,i).dist
if d[i+N] < ans:
ans = int(d[i+N])
j = i
if ans != INF:
path = Dijkstra(g,j).shortest_path(j+N)[:-1]
print(ans)
for node in path:
print((node+1))
else:
print((-1)) | INF = float('inf')
from collections import defaultdict
from heapq import heappop, heappush
class Graph(object):
def __init__(self):
self.graph = defaultdict(list)
def __len__(self):
return len(self.graph)
def add_edge(self, From, To, cost=1):
self.graph[From].append((To,cost))
def get_nodes(self):
return list(self.graph.keys())
class Dijkstra(object):
def __init__(self, graph, start):
self.g = graph.graph
self.dist = defaultdict(lambda:INF)
self.dist[start] = 0
self.prev = defaultdict(lambda: None)
self.Q = []
heappush(self.Q,(self.dist[start], start))
while self.Q:
dist_u, u = heappop(self.Q)
if self.dist[u] < dist_u:
continue
for v, cost in self.g[u]:
alt = dist_u + cost
if self.dist[v] > alt:
self.dist[v] = alt
self.prev[v] = u
heappush(self.Q,(alt, v))
def shortest_distance(self, goal):
return self.dist[goal]
def shortest_path(self, goal):
path = []
node = goal
while node is not None:
path.append(node)
node = self.prev[node]
return path[::-1]
N, M = list(map(int,input().split()))
g = Graph()
for i in range(M):
a,b = list(map(int,input().split()))
a -= 1
b -= 1
g.add_edge(a,b)
ans = INF
d = [Dijkstra(g,i).dist for i in range(N)]
k = -1
l = -1
for i in range(N-1):
for j in range(i+1,N):
if d[i][j]+d[j][i] < ans:
k = i
l = j
ans = d[i][j]+d[j][i]
if ans != INF:
path = Dijkstra(g,k).shortest_path(l)[:-1]+Dijkstra(g,l).shortest_path(k)[:-1]
print(ans)
for node in path:
print((node+1))
else:
print((-1)) | 78 | 78 | 1,823 | 1,911 | INF = float("inf")
from collections import defaultdict
from heapq import heappop, heappush
class Graph(object):
def __init__(self):
self.graph = defaultdict(list)
def __len__(self):
return len(self.graph)
def add_edge(self, From, To, cost=1):
self.graph[From].append((To, cost))
def get_nodes(self):
return list(self.graph.keys())
class Dijkstra(object):
def __init__(self, graph, start):
self.g = graph.graph
self.dist = defaultdict(lambda: INF)
self.dist[start] = 0
self.prev = defaultdict(lambda: None)
self.Q = []
heappush(self.Q, (self.dist[start], start))
while self.Q:
dist_u, u = heappop(self.Q)
if self.dist[u] < dist_u:
continue
for v, cost in self.g[u]:
alt = dist_u + cost
if self.dist[v] > alt:
self.dist[v] = alt
self.prev[v] = u
heappush(self.Q, (alt, v))
def shortest_distance(self, goal):
return self.dist[goal]
def shortest_path(self, goal):
path = []
node = goal
while node is not None:
path.append(node)
node = self.prev[node]
return path[::-1]
N, M = list(map(int, input().split()))
g = Graph()
for i in range(M):
a, b = list(map(int, input().split()))
a -= 1
b -= 1
g.add_edge(a, b)
g.add_edge(a, b + N)
g.add_edge(a + N, b)
ans = INF
j = -1
for i in range(N):
d = Dijkstra(g, i).dist
if d[i + N] < ans:
ans = int(d[i + N])
j = i
if ans != INF:
path = Dijkstra(g, j).shortest_path(j + N)[:-1]
print(ans)
for node in path:
print((node + 1))
else:
print((-1))
| INF = float("inf")
from collections import defaultdict
from heapq import heappop, heappush
class Graph(object):
def __init__(self):
self.graph = defaultdict(list)
def __len__(self):
return len(self.graph)
def add_edge(self, From, To, cost=1):
self.graph[From].append((To, cost))
def get_nodes(self):
return list(self.graph.keys())
class Dijkstra(object):
def __init__(self, graph, start):
self.g = graph.graph
self.dist = defaultdict(lambda: INF)
self.dist[start] = 0
self.prev = defaultdict(lambda: None)
self.Q = []
heappush(self.Q, (self.dist[start], start))
while self.Q:
dist_u, u = heappop(self.Q)
if self.dist[u] < dist_u:
continue
for v, cost in self.g[u]:
alt = dist_u + cost
if self.dist[v] > alt:
self.dist[v] = alt
self.prev[v] = u
heappush(self.Q, (alt, v))
def shortest_distance(self, goal):
return self.dist[goal]
def shortest_path(self, goal):
path = []
node = goal
while node is not None:
path.append(node)
node = self.prev[node]
return path[::-1]
N, M = list(map(int, input().split()))
g = Graph()
for i in range(M):
a, b = list(map(int, input().split()))
a -= 1
b -= 1
g.add_edge(a, b)
ans = INF
d = [Dijkstra(g, i).dist for i in range(N)]
k = -1
l = -1
for i in range(N - 1):
for j in range(i + 1, N):
if d[i][j] + d[j][i] < ans:
k = i
l = j
ans = d[i][j] + d[j][i]
if ans != INF:
path = Dijkstra(g, k).shortest_path(l)[:-1] + Dijkstra(g, l).shortest_path(k)[:-1]
print(ans)
for node in path:
print((node + 1))
else:
print((-1))
| false | 0 | [
"- g.add_edge(a, b + N)",
"- g.add_edge(a + N, b)",
"-j = -1",
"-for i in range(N):",
"- d = Dijkstra(g, i).dist",
"- if d[i + N] < ans:",
"- ans = int(d[i + N])",
"- j = i",
"+d = [Dijkstra(g, i).dist for i in range(N)]",
"+k = -1",
"+l = -1",
"+for i in range(N - 1):",
"+ for j in range(i + 1, N):",
"+ if d[i][j] + d[j][i] < ans:",
"+ k = i",
"+ l = j",
"+ ans = d[i][j] + d[j][i]",
"- path = Dijkstra(g, j).shortest_path(j + N)[:-1]",
"+ path = Dijkstra(g, k).shortest_path(l)[:-1] + Dijkstra(g, l).shortest_path(k)[:-1]"
] | false | 0.035598 | 0.037853 | 0.940408 | [
"s574696954",
"s066776536"
] |
u380995377 | p02679 | python | s052397627 | s371539028 | 716 | 579 | 45,900 | 48,548 | Accepted | Accepted | 19.13 | 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)
from fractions import Fraction
N = I()
cnt = {}
pair = {}
bothzero = 0
for i in range(N):
A,B = MI()
if A==0 and B==0:
bothzero += 1
elif B==0:
pair[0]=pair.get(0,0)+1
elif A == 0:
cnt[0]=cnt.get(0,0)+1
elif A/B>0:
frac = Fraction(A,B).as_integer_ratio()
cnt[frac]=cnt.get(frac,0)+1
else:
frac = Fraction(-B,A).as_integer_ratio()
pair[frac]=pair.get(frac,0)+1
res = N-bothzero
ans = 1
for v in cnt:
if pair.get(v,0)==0:
continue
res -= (cnt[v]+pair[v])
ans = ans*((pow(2,cnt[v],MOD)+pow(2,pair[v],MOD)-1)%MOD)
ans = ans%MOD
ans = (ans*pow(2,res,MOD)-1)%MOD
ans = (ans+bothzero)%MOD
print(ans)
| 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)
def to_frac(A,B):
g = math.gcd(A,B)
A = A//g
B = B//g
if A<0:
A *= -1
B *= -1
return (A,B)
N = I()
cnt = {}
pair = {}
bothzero = 0
for i in range(N):
A,B = MI()
if A==0 and B==0:
bothzero += 1
elif B==0:
pair[0]=pair.get(0,0)+1
elif A == 0:
cnt[0]=cnt.get(0,0)+1
elif A/B>0:
frac = to_frac(A,B)
cnt[frac]=cnt.get(frac,0)+1
else:
frac = to_frac(-B,A)
pair[frac]=pair.get(frac,0)+1
res = N-bothzero
ans = 1
for v in cnt:
if pair.get(v,0)==0:
continue
res -= (cnt[v]+pair[v])
ans = ans*((pow(2,cnt[v],MOD)+pow(2,pair[v],MOD)-1)%MOD)
ans = ans%MOD
ans = (ans*pow(2,res,MOD)-1)%MOD
ans = (ans+bothzero)%MOD
print(ans)
| 61 | 66 | 2,004 | 2,051 | 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)
from fractions import Fraction
N = I()
cnt = {}
pair = {}
bothzero = 0
for i in range(N):
A, B = MI()
if A == 0 and B == 0:
bothzero += 1
elif B == 0:
pair[0] = pair.get(0, 0) + 1
elif A == 0:
cnt[0] = cnt.get(0, 0) + 1
elif A / B > 0:
frac = Fraction(A, B).as_integer_ratio()
cnt[frac] = cnt.get(frac, 0) + 1
else:
frac = Fraction(-B, A).as_integer_ratio()
pair[frac] = pair.get(frac, 0) + 1
res = N - bothzero
ans = 1
for v in cnt:
if pair.get(v, 0) == 0:
continue
res -= cnt[v] + pair[v]
ans = ans * ((pow(2, cnt[v], MOD) + pow(2, pair[v], MOD) - 1) % MOD)
ans = ans % MOD
ans = (ans * pow(2, res, MOD) - 1) % MOD
ans = (ans + bothzero) % MOD
print(ans)
| 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)
def to_frac(A, B):
g = math.gcd(A, B)
A = A // g
B = B // g
if A < 0:
A *= -1
B *= -1
return (A, B)
N = I()
cnt = {}
pair = {}
bothzero = 0
for i in range(N):
A, B = MI()
if A == 0 and B == 0:
bothzero += 1
elif B == 0:
pair[0] = pair.get(0, 0) + 1
elif A == 0:
cnt[0] = cnt.get(0, 0) + 1
elif A / B > 0:
frac = to_frac(A, B)
cnt[frac] = cnt.get(frac, 0) + 1
else:
frac = to_frac(-B, A)
pair[frac] = pair.get(frac, 0) + 1
res = N - bothzero
ans = 1
for v in cnt:
if pair.get(v, 0) == 0:
continue
res -= cnt[v] + pair[v]
ans = ans * ((pow(2, cnt[v], MOD) + pow(2, pair[v], MOD) - 1) % MOD)
ans = ans % MOD
ans = (ans * pow(2, res, MOD) - 1) % MOD
ans = (ans + bothzero) % MOD
print(ans)
| false | 7.575758 | [
"-from fractions import Fraction",
"+",
"+",
"+def to_frac(A, B):",
"+ g = math.gcd(A, B)",
"+ A = A // g",
"+ B = B // g",
"+ if A < 0:",
"+ A *= -1",
"+ B *= -1",
"+ return (A, B)",
"+",
"- frac = Fraction(A, B).as_integer_ratio()",
"+ frac = to_frac(A, B)",
"- frac = Fraction(-B, A).as_integer_ratio()",
"+ frac = to_frac(-B, A)"
] | false | 0.127404 | 0.103976 | 1.225317 | [
"s052397627",
"s371539028"
] |
u010072501 | p03085 | python | s522236162 | s149035990 | 25 | 23 | 8,912 | 8,960 | Accepted | Accepted | 8 | # A - Double Helix
# A：アデニン T：チミン G：グアニン C：シトシン
# 対になる組み合わせ A-T G-C
# 標準入力
base = eval(input())
# print(base)
# 条件分岐
if base == 'A':
print('T')
elif base == 'T':
print('A')
elif base == 'G':
print('C')
elif base == 'C':
print('G')
| # A - Double Helix
# A：アデニン T：チミン G：グアニン C：シトシン
# 対になる組み合わせ A-T G-C
# 標準入力
base = eval(input())
# print(base)
# 条件分岐し、結果を answer に代入
if base == 'A':
# print('T')
answer = 'T'
elif base == 'T':
# print('A')
answer = 'A'
elif base == 'G':
# print('C')
answer = 'C'
elif base == 'C':
# print('G')
answer = 'G'
# 結果の出力
print(answer)
| 17 | 24 | 261 | 383 | # A - Double Helix
# A：アデニン T：チミン G：グアニン C：シトシン
# 対になる組み合わせ A-T G-C
# 標準入力
base = eval(input())
# print(base)
# 条件分岐
if base == "A":
print("T")
elif base == "T":
print("A")
elif base == "G":
print("C")
elif base == "C":
print("G")
| # A - Double Helix
# A：アデニン T：チミン G：グアニン C：シトシン
# 対になる組み合わせ A-T G-C
# 標準入力
base = eval(input())
# print(base)
# 条件分岐し、結果を answer に代入
if base == "A":
# print('T')
answer = "T"
elif base == "T":
# print('A')
answer = "A"
elif base == "G":
# print('C')
answer = "C"
elif base == "C":
# print('G')
answer = "G"
# 結果の出力
print(answer)
| false | 29.166667 | [
"-# 条件分岐",
"+# 条件分岐し、結果を answer に代入",
"- print(\"T\")",
"+ # print('T')",
"+ answer = \"T\"",
"- print(\"A\")",
"+ # print('A')",
"+ answer = \"A\"",
"- print(\"C\")",
"+ # print('C')",
"+ answer = \"C\"",
"- print(\"G\")",
"+ # print('G')",
"+ answer = \"G\"",
"+# 結果の出力",
"+print(answer)"
] | false | 0.037944 | 0.046016 | 0.824585 | [
"s522236162",
"s149035990"
] |
u410118019 | p02844 | python | s576820783 | s587391669 | 219 | 35 | 41,068 | 4,704 | Accepted | Accepted | 84.02 | n = int(eval(input()))
s = eval(input())
c1 = [0] * 10
c2 = [0] * 100
c3 = [0] * 1000
for i in s:
i = int(i)
for j in range(100):
c3[j*10+i] = c2[j]
for j in range(10):
c2[j*10+i] = c1[j]
c1[i] = 1
print((sum(c3))) | from collections import defaultdict
import bisect
n = int(eval(input()))
d = defaultdict(list)
for i,j in enumerate(eval(input())):
j = int(j)
d[j].append(i)
c = 0
for i in range(10):
for j in range(10):
for k in range(10):
if d[i] != [] and d[j] != [] and d[k] != []:
b = bisect.bisect_right(d[j],d[i][0])
if b != len(d[j]) and d[j][b] < d[k][-1]:
c += 1
print(c) | 13 | 16 | 228 | 409 | n = int(eval(input()))
s = eval(input())
c1 = [0] * 10
c2 = [0] * 100
c3 = [0] * 1000
for i in s:
i = int(i)
for j in range(100):
c3[j * 10 + i] = c2[j]
for j in range(10):
c2[j * 10 + i] = c1[j]
c1[i] = 1
print((sum(c3)))
| from collections import defaultdict
import bisect
n = int(eval(input()))
d = defaultdict(list)
for i, j in enumerate(eval(input())):
j = int(j)
d[j].append(i)
c = 0
for i in range(10):
for j in range(10):
for k in range(10):
if d[i] != [] and d[j] != [] and d[k] != []:
b = bisect.bisect_right(d[j], d[i][0])
if b != len(d[j]) and d[j][b] < d[k][-1]:
c += 1
print(c)
| false | 18.75 | [
"+from collections import defaultdict",
"+import bisect",
"+",
"-s = eval(input())",
"-c1 = [0] * 10",
"-c2 = [0] * 100",
"-c3 = [0] * 1000",
"-for i in s:",
"- i = int(i)",
"- for j in range(100):",
"- c3[j * 10 + i] = c2[j]",
"+d = defaultdict(list)",
"+for i, j in enumerate(eval(input())):",
"+ j = int(j)",
"+ d[j].append(i)",
"+c = 0",
"+for i in range(10):",
"- c2[j * 10 + i] = c1[j]",
"- c1[i] = 1",
"-print((sum(c3)))",
"+ for k in range(10):",
"+ if d[i] != [] and d[j] != [] and d[k] != []:",
"+ b = bisect.bisect_right(d[j], d[i][0])",
"+ if b != len(d[j]) and d[j][b] < d[k][-1]:",
"+ c += 1",
"+print(c)"
] | false | 0.080323 | 0.082052 | 0.978934 | [
"s576820783",
"s587391669"
] |
u652656291 | p02947 | python | s785070251 | s270840083 | 454 | 180 | 17,888 | 28,296 | Accepted | Accepted | 60.35 | N = int(eval(input()))
D = {}
for _ in range(N):
s = eval(input())
r = ''.join(sorted([c for c in s]))
if r in D:
D[r] += 1
else:
D[r] = 1
ans = 0
for v in list(D.values()):
ans += v*(v-1)//2
print(ans)
| import sys
from collections import Counter
n, *S = sys.stdin.read().split()
n = int(n)
def main():
t = [''.join(sorted(t)) for t in S]
c = Counter(t)
cnt = 0
for v in list(c.values()):
cnt += v*(v-1)
print((cnt//2))
main()
| 13 | 15 | 233 | 260 | N = int(eval(input()))
D = {}
for _ in range(N):
s = eval(input())
r = "".join(sorted([c for c in s]))
if r in D:
D[r] += 1
else:
D[r] = 1
ans = 0
for v in list(D.values()):
ans += v * (v - 1) // 2
print(ans)
| import sys
from collections import Counter
n, *S = sys.stdin.read().split()
n = int(n)
def main():
t = ["".join(sorted(t)) for t in S]
c = Counter(t)
cnt = 0
for v in list(c.values()):
cnt += v * (v - 1)
print((cnt // 2))
main()
| false | 13.333333 | [
"-N = int(eval(input()))",
"-D = {}",
"-for _ in range(N):",
"- s = eval(input())",
"- r = \"\".join(sorted([c for c in s]))",
"- if r in D:",
"- D[r] += 1",
"- else:",
"- D[r] = 1",
"-ans = 0",
"-for v in list(D.values()):",
"- ans += v * (v - 1) // 2",
"-print(ans)",
"+import sys",
"+from collections import Counter",
"+",
"+n, *S = sys.stdin.read().split()",
"+n = int(n)",
"+",
"+",
"+def main():",
"+ t = [\"\".join(sorted(t)) for t in S]",
"+ c = Counter(t)",
"+ cnt = 0",
"+ for v in list(c.values()):",
"+ cnt += v * (v - 1)",
"+ print((cnt // 2))",
"+",
"+",
"+main()"
] | false | 0.07488 | 0.037651 | 1.988819 | [
"s785070251",
"s270840083"
] |
u874644572 | p02793 | python | s016126684 | s175358457 | 1,669 | 1,512 | 72,792 | 6,112 | Accepted | Accepted | 9.41 | from fractions import gcd
n = int(eval(input()))
lcm = list(map(int, input().split()))
ans = [1] * n
while len(lcm) < (1 << 14):
lcm.append(1)
ans.append(0)
for i in range(13, -1, -1):
bit = 1 << i
for j in range(bit):
new = lcm[j] // gcd(lcm[j], lcm[j | bit]) * lcm[j | bit]
ans[j] = new // lcm[j] * ans[j] + new // lcm[j | bit] * ans[j | bit]
ans[j] %= 1000000007
lcm[j] = new
print((ans[0])) | from fractions import gcd
N = int(eval(input()))
A = list(map(int, input().split()))
MOD = 1000000007
lcm = 1
for a in A:
lcm = a // gcd(lcm, a) * lcm
ans = 0
for a in A:
ans += lcm // a
ans %= MOD
print(ans) | 15 | 12 | 424 | 221 | from fractions import gcd
n = int(eval(input()))
lcm = list(map(int, input().split()))
ans = [1] * n
while len(lcm) < (1 << 14):
lcm.append(1)
ans.append(0)
for i in range(13, -1, -1):
bit = 1 << i
for j in range(bit):
new = lcm[j] // gcd(lcm[j], lcm[j | bit]) * lcm[j | bit]
ans[j] = new // lcm[j] * ans[j] + new // lcm[j | bit] * ans[j | bit]
ans[j] %= 1000000007
lcm[j] = new
print((ans[0]))
| from fractions import gcd
N = int(eval(input()))
A = list(map(int, input().split()))
MOD = 1000000007
lcm = 1
for a in A:
lcm = a // gcd(lcm, a) * lcm
ans = 0
for a in A:
ans += lcm // a
ans %= MOD
print(ans)
| false | 20 | [
"-n = int(eval(input()))",
"-lcm = list(map(int, input().split()))",
"-ans = [1] * n",
"-while len(lcm) < (1 << 14):",
"- lcm.append(1)",
"- ans.append(0)",
"-for i in range(13, -1, -1):",
"- bit = 1 << i",
"- for j in range(bit):",
"- new = lcm[j] // gcd(lcm[j], lcm[j | bit]) * lcm[j | bit]",
"- ans[j] = new // lcm[j] * ans[j] + new // lcm[j | bit] * ans[j | bit]",
"- ans[j] %= 1000000007",
"- lcm[j] = new",
"-print((ans[0]))",
"+N = int(eval(input()))",
"+A = list(map(int, input().split()))",
"+MOD = 1000000007",
"+lcm = 1",
"+for a in A:",
"+ lcm = a // gcd(lcm, a) * lcm",
"+ans = 0",
"+for a in A:",
"+ ans += lcm // a",
"+ans %= MOD",
"+print(ans)"
] | false | 0.142812 | 0.15006 | 0.951702 | [
"s016126684",
"s175358457"
] |
u729133443 | p03108 | python | s179469688 | s014817081 | 807 | 482 | 55,916 | 25,308 | Accepted | Accepted | 40.27 | r=lambda x:x if u[x]<0else r(u[x])
(n,m),_,*e=[map(int,t.split())for t in open(0).readlines()]
u=[-1]*-~n
t=n*~-n//2
a=[t]
for x,y in e[::-1]:
x,y=sorted((r(x),r(y)))
if x!=y:t-=u[x]*u[y];u[x]+=u[y];u[y]=x
a+=[t]
print(*a[::-1],sep='\n')
| r=lambda x:x if u[x]<0else r(u[x])
n,m,*e=map(int,open(0).read().split())
u=[-1]*-~n
t=n*~-n//2
a=[t]
for x,y in zip(e[-2:1:-2],e[:1:-2]):
x,y=sorted((r(x),r(y)))
if x!=y:t-=u[x]*u[y];u[x]+=u[y];u[y]=x
a+=[t]
print(*a[::-1],sep='\n')
| 10 | 10 | 249 | 245 | r = lambda x: x if u[x] < 0 else r(u[x])
(n, m), _, *e = [map(int, t.split()) for t in open(0).readlines()]
u = [-1] * -~n
t = n * ~-n // 2
a = [t]
for x, y in e[::-1]:
x, y = sorted((r(x), r(y)))
if x != y:
t -= u[x] * u[y]
u[x] += u[y]
u[y] = x
a += [t]
print(*a[::-1], sep="\n")
| r = lambda x: x if u[x] < 0 else r(u[x])
n, m, *e = map(int, open(0).read().split())
u = [-1] * -~n
t = n * ~-n // 2
a = [t]
for x, y in zip(e[-2:1:-2], e[:1:-2]):
x, y = sorted((r(x), r(y)))
if x != y:
t -= u[x] * u[y]
u[x] += u[y]
u[y] = x
a += [t]
print(*a[::-1], sep="\n")
| false | 0 | [
"-(n, m), _, *e = [map(int, t.split()) for t in open(0).readlines()]",
"+n, m, *e = map(int, open(0).read().split())",
"-for x, y in e[::-1]:",
"+for x, y in zip(e[-2:1:-2], e[:1:-2]):"
] | false | 0.099694 | 0.124022 | 0.803836 | [
"s179469688",
"s014817081"
] |
u081029414 | p02971 | python | s268718679 | s896881837 | 759 | 575 | 41,164 | 12,512 | Accepted | Accepted | 24.24 | #coding : utf-8
import os
import sys
N = int(eval(input()))
A = []
for i in range(N):
A.append(int(eval(input())))
X = [[A[i], i] for i in range(N)]
X.sort(key = lambda x: x[0], reverse=True)
for i in range(N):
if i != X[0][1]:
print((X[0][0]))
else:
print((X[1][0]))
| #coding : utf-8
import os
import sys
N = int(eval(input()))
A = []
for i in range(N):
A.append(int(eval(input())))
Amax = max(A)
i = A.index(Amax)
t = A[i]
A[i] = 0
A2nd = max(A)
A[i] = t
for i in range(N):
if A[i] == Amax:
print(A2nd)
else:
print(Amax)
| 24 | 27 | 292 | 284 | # coding : utf-8
import os
import sys
N = int(eval(input()))
A = []
for i in range(N):
A.append(int(eval(input())))
X = [[A[i], i] for i in range(N)]
X.sort(key=lambda x: x[0], reverse=True)
for i in range(N):
if i != X[0][1]:
print((X[0][0]))
else:
print((X[1][0]))
| # coding : utf-8
import os
import sys
N = int(eval(input()))
A = []
for i in range(N):
A.append(int(eval(input())))
Amax = max(A)
i = A.index(Amax)
t = A[i]
A[i] = 0
A2nd = max(A)
A[i] = t
for i in range(N):
if A[i] == Amax:
print(A2nd)
else:
print(Amax)
| false | 11.111111 | [
"-X = [[A[i], i] for i in range(N)]",
"-X.sort(key=lambda x: x[0], reverse=True)",
"+Amax = max(A)",
"+i = A.index(Amax)",
"+t = A[i]",
"+A[i] = 0",
"+A2nd = max(A)",
"+A[i] = t",
"- if i != X[0][1]:",
"- print((X[0][0]))",
"+ if A[i] == Amax:",
"+ print(A2nd)",
"- print((X[1][0]))",
"+ print(Amax)"
] | false | 0.048822 | 0.038032 | 1.283683 | [
"s268718679",
"s896881837"
] |
u016128476 | p03078 | python | s832024498 | s237013555 | 1,900 | 827 | 236,280 | 4,724 | Accepted | Accepted | 56.47 | # input
x, y, z, k = (int(i) for i in input().split())
a = [int(i) for i in input().split()]
b = [int(i) for i in input().split()]
c = [int(i) for i in input().split()]
a.sort(reverse=True)
b.sort(reverse=True)
c.sort(reverse=True)
ab = []
ab.extend([i+j for j in b[:k] for i in a[:k]])
ab.sort(reverse=True)
abc = []
abc.extend([i+j for j in ab[:k] for i in c[:k]])
abc.sort(reverse=True)
print(('\n'.join(str(i) for i in abc[:k])))
| # input
x, y, z, k = (int(i) for i in input().split())
a = [int(i) for i in input().split()]
b = [int(i) for i in input().split()]
c = [int(i) for i in input().split()]
import heapq
a.sort(reverse=True)
b.sort(reverse=True)
c.sort(reverse=True)
index_hstr = []
deliciouses = []
# priority queue
pq = []
heapq.heappush(pq, (-a[0] - b[0] - c[0], 0, 0, 0))
index_hstr.append((0, 0, 0))
for t in range(k):
deli, i, j, k = heapq.heappop(pq)
if i+1<x and (i+1, j, k) not in index_hstr:
heapq.heappush(pq, (-a[i+1] - b[j] - c[k], i+1, j, k))
index_hstr.append((i+1, j, k))
if j+1<y and (i, j+1, k) not in index_hstr:
heapq.heappush(pq, (-a[i] - b[j+1] - c[k], i, j+1, k))
index_hstr.append((i, j+1, k))
if k+1<z and (i, j, k+1) not in index_hstr:
heapq.heappush(pq, (-a[i] - b[j] - c[k+1], i, j, k+1))
index_hstr.append((i, j, k+1))
deliciouses.append(-deli)
print(('\n'.join(str(i) for i in deliciouses)))
| 19 | 35 | 454 | 1,007 | # input
x, y, z, k = (int(i) for i in input().split())
a = [int(i) for i in input().split()]
b = [int(i) for i in input().split()]
c = [int(i) for i in input().split()]
a.sort(reverse=True)
b.sort(reverse=True)
c.sort(reverse=True)
ab = []
ab.extend([i + j for j in b[:k] for i in a[:k]])
ab.sort(reverse=True)
abc = []
abc.extend([i + j for j in ab[:k] for i in c[:k]])
abc.sort(reverse=True)
print(("\n".join(str(i) for i in abc[:k])))
| # input
x, y, z, k = (int(i) for i in input().split())
a = [int(i) for i in input().split()]
b = [int(i) for i in input().split()]
c = [int(i) for i in input().split()]
import heapq
a.sort(reverse=True)
b.sort(reverse=True)
c.sort(reverse=True)
index_hstr = []
deliciouses = []
# priority queue
pq = []
heapq.heappush(pq, (-a[0] - b[0] - c[0], 0, 0, 0))
index_hstr.append((0, 0, 0))
for t in range(k):
deli, i, j, k = heapq.heappop(pq)
if i + 1 < x and (i + 1, j, k) not in index_hstr:
heapq.heappush(pq, (-a[i + 1] - b[j] - c[k], i + 1, j, k))
index_hstr.append((i + 1, j, k))
if j + 1 < y and (i, j + 1, k) not in index_hstr:
heapq.heappush(pq, (-a[i] - b[j + 1] - c[k], i, j + 1, k))
index_hstr.append((i, j + 1, k))
if k + 1 < z and (i, j, k + 1) not in index_hstr:
heapq.heappush(pq, (-a[i] - b[j] - c[k + 1], i, j, k + 1))
index_hstr.append((i, j, k + 1))
deliciouses.append(-deli)
print(("\n".join(str(i) for i in deliciouses)))
| false | 45.714286 | [
"+import heapq",
"+",
"-ab = []",
"-ab.extend([i + j for j in b[:k] for i in a[:k]])",
"-ab.sort(reverse=True)",
"-abc = []",
"-abc.extend([i + j for j in ab[:k] for i in c[:k]])",
"-abc.sort(reverse=True)",
"-print((\"\\n\".join(str(i) for i in abc[:k])))",
"+index_hstr = []",
"+deliciouses = []",
"+# priority queue",
"+pq = []",
"+heapq.heappush(pq, (-a[0] - b[0] - c[0], 0, 0, 0))",
"+index_hstr.append((0, 0, 0))",
"+for t in range(k):",
"+ deli, i, j, k = heapq.heappop(pq)",
"+ if i + 1 < x and (i + 1, j, k) not in index_hstr:",
"+ heapq.heappush(pq, (-a[i + 1] - b[j] - c[k], i + 1, j, k))",
"+ index_hstr.append((i + 1, j, k))",
"+ if j + 1 < y and (i, j + 1, k) not in index_hstr:",
"+ heapq.heappush(pq, (-a[i] - b[j + 1] - c[k], i, j + 1, k))",
"+ index_hstr.append((i, j + 1, k))",
"+ if k + 1 < z and (i, j, k + 1) not in index_hstr:",
"+ heapq.heappush(pq, (-a[i] - b[j] - c[k + 1], i, j, k + 1))",
"+ index_hstr.append((i, j, k + 1))",
"+ deliciouses.append(-deli)",
"+print((\"\\n\".join(str(i) for i in deliciouses)))"
] | false | 0.112193 | 0.007822 | 14.344142 | [
"s832024498",
"s237013555"
] |
u461993794 | p02689 | python | s086514844 | s621989466 | 409 | 277 | 94,448 | 95,164 | Accepted | Accepted | 32.27 | n, m = list(map(int, input().split()))
h = list(map(int, input().split()))
eg = [[] for _ in range(n)]
for _ in range(m):
a, b = list(map(int, input().split()))
eg[a - 1].append(b - 1)
eg[b - 1].append(a - 1)
ans = 0
for i in range(n):
high = True
for to in eg[i]:
if h[i] <= h[to]:
high = False
if high:
ans += 1
print(ans)
| from sys import stdin
input = stdin.readline
n, m = list(map(int, input().split()))
h = list(map(int, input().split()))
eg = [[] for _ in range(n)]
for _ in range(m):
a, b = list(map(int, input().split()))
eg[a - 1].append(b - 1)
eg[b - 1].append(a - 1)
ans = 0
for i in range(n):
high = True
for to in eg[i]:
if h[i] <= h[to]:
high = False
if high:
ans += 1
print(ans)
| 18 | 22 | 384 | 435 | n, m = list(map(int, input().split()))
h = list(map(int, input().split()))
eg = [[] for _ in range(n)]
for _ in range(m):
a, b = list(map(int, input().split()))
eg[a - 1].append(b - 1)
eg[b - 1].append(a - 1)
ans = 0
for i in range(n):
high = True
for to in eg[i]:
if h[i] <= h[to]:
high = False
if high:
ans += 1
print(ans)
| from sys import stdin
input = stdin.readline
n, m = list(map(int, input().split()))
h = list(map(int, input().split()))
eg = [[] for _ in range(n)]
for _ in range(m):
a, b = list(map(int, input().split()))
eg[a - 1].append(b - 1)
eg[b - 1].append(a - 1)
ans = 0
for i in range(n):
high = True
for to in eg[i]:
if h[i] <= h[to]:
high = False
if high:
ans += 1
print(ans)
| false | 18.181818 | [
"+from sys import stdin",
"+",
"+input = stdin.readline"
] | false | 0.083915 | 0.06129 | 1.369145 | [
"s086514844",
"s621989466"
] |
u224346910 | p02888 | python | s291918733 | s454873951 | 315 | 110 | 73,156 | 73,880 | Accepted | Accepted | 65.08 | from bisect import bisect_left
def main():
N = int(eval(input()))
L = sorted(list(map(int, input().split())))
ans = 0
for ia in range(N):
for ib in range(ia+1, N-1):
a = L[ia]
b = L[ib]
ic_end = bisect_left(L, a+b, lo=ib+1)
ans += ic_end - (ib+1)
print(ans)
main() | def main():
N = int(eval(input()))
L = sorted(list(map(int, input().split())))
ans = 0
for ia in range(N-2):
a = L[ia]
ic = ia + 2
for ib in range(ia+1, N-1):
b = L[ib]
while ic < N and L[ic] < a+b:
ic += 1
ans += ic - (ib + 1)
print(ans)
main() | 16 | 14 | 352 | 348 | from bisect import bisect_left
def main():
N = int(eval(input()))
L = sorted(list(map(int, input().split())))
ans = 0
for ia in range(N):
for ib in range(ia + 1, N - 1):
a = L[ia]
b = L[ib]
ic_end = bisect_left(L, a + b, lo=ib + 1)
ans += ic_end - (ib + 1)
print(ans)
main()
| def main():
N = int(eval(input()))
L = sorted(list(map(int, input().split())))
ans = 0
for ia in range(N - 2):
a = L[ia]
ic = ia + 2
for ib in range(ia + 1, N - 1):
b = L[ib]
while ic < N and L[ic] < a + b:
ic += 1
ans += ic - (ib + 1)
print(ans)
main()
| false | 12.5 | [
"-from bisect import bisect_left",
"-",
"-",
"- for ia in range(N):",
"+ for ia in range(N - 2):",
"+ a = L[ia]",
"+ ic = ia + 2",
"- a = L[ia]",
"- ic_end = bisect_left(L, a + b, lo=ib + 1)",
"- ans += ic_end - (ib + 1)",
"+ while ic < N and L[ic] < a + b:",
"+ ic += 1",
"+ ans += ic - (ib + 1)"
] | false | 0.037971 | 0.049122 | 0.772997 | [
"s291918733",
"s454873951"
] |
u394721319 | p03160 | python | s242083682 | s237225474 | 159 | 131 | 19,172 | 13,928 | Accepted | Accepted | 17.61 | n = int(eval(input()))
li = list(map(int,input().split()))
p = [abs(li[i]-li[i+1]) for i in range(n-1)]
q = [abs(li[i]-li[i+2]) for i in range(n-2)]
dp = [0,p[0]]
for i in range(2,n):
dp.append(min(dp[i-1]+p[i-1], dp[i-2]+q[i-2]))
print((dp[-1]))
| n = int(eval(input()))
h = [int(i) for i in input().split()]
dp = [0]*n
dp[1] = abs(h[1] - h[0])
for i in range(2, n):
dp[i] = min(dp[i-2] + abs(h[i]-h[i-2]), dp[i-1] + abs(h[i]-h[i-1]))
print((dp[-1]))
| 12 | 10 | 258 | 211 | n = int(eval(input()))
li = list(map(int, input().split()))
p = [abs(li[i] - li[i + 1]) for i in range(n - 1)]
q = [abs(li[i] - li[i + 2]) for i in range(n - 2)]
dp = [0, p[0]]
for i in range(2, n):
dp.append(min(dp[i - 1] + p[i - 1], dp[i - 2] + q[i - 2]))
print((dp[-1]))
| n = int(eval(input()))
h = [int(i) for i in input().split()]
dp = [0] * n
dp[1] = abs(h[1] - h[0])
for i in range(2, n):
dp[i] = min(dp[i - 2] + abs(h[i] - h[i - 2]), dp[i - 1] + abs(h[i] - h[i - 1]))
print((dp[-1]))
| false | 16.666667 | [
"-li = list(map(int, input().split()))",
"-p = [abs(li[i] - li[i + 1]) for i in range(n - 1)]",
"-q = [abs(li[i] - li[i + 2]) for i in range(n - 2)]",
"-dp = [0, p[0]]",
"+h = [int(i) for i in input().split()]",
"+dp = [0] * n",
"+dp[1] = abs(h[1] - h[0])",
"- dp.append(min(dp[i - 1] + p[i - 1], dp[i - 2] + q[i - 2]))",
"+ dp[i] = min(dp[i - 2] + abs(h[i] - h[i - 2]), dp[i - 1] + abs(h[i] - h[i - 1]))"
] | false | 0.03911 | 0.048626 | 0.804306 | [
"s242083682",
"s237225474"
] |
u485319545 | p02597 | python | s901008907 | s675142344 | 54 | 47 | 9,504 | 9,108 | Accepted | Accepted | 12.96 | n=int(eval(input()))
s=eval(input())
from collections import Counter
c=Counter(s)
r=c['R']
cnt=0
for i in range(r):
if s[i]=='W':
cnt+=1
print(cnt) | n=int(eval(input()))
s=eval(input())
r = s.count('R')
ans=0
for i in range(r):
if s[i]=='W':
ans+=1
print(ans) | 16 | 11 | 168 | 123 | n = int(eval(input()))
s = eval(input())
from collections import Counter
c = Counter(s)
r = c["R"]
cnt = 0
for i in range(r):
if s[i] == "W":
cnt += 1
print(cnt)
| n = int(eval(input()))
s = eval(input())
r = s.count("R")
ans = 0
for i in range(r):
if s[i] == "W":
ans += 1
print(ans)
| false | 31.25 | [
"-from collections import Counter",
"-",
"-c = Counter(s)",
"-r = c[\"R\"]",
"-cnt = 0",
"+r = s.count(\"R\")",
"+ans = 0",
"- cnt += 1",
"-print(cnt)",
"+ ans += 1",
"+print(ans)"
] | false | 0.082277 | 0.035199 | 2.337508 | [
"s901008907",
"s675142344"
] |
u882616665 | p02624 | python | s093339042 | s018919374 | 1,983 | 1,546 | 404,420 | 9,036 | Accepted | Accepted | 22.04 | N = int(eval(input()))
ans = int(sum([j * (N//j)*(N//j+1)/2 for j in range(1,N+1)]))
print(ans)
| N = int(eval(input()))
def gen():
for j in range(1,N+1):
yield j * (N//j)*(N//j+1)/2
ans = int(sum(gen()))
print(ans)
| 5 | 9 | 96 | 129 | N = int(eval(input()))
ans = int(sum([j * (N // j) * (N // j + 1) / 2 for j in range(1, N + 1)]))
print(ans)
| N = int(eval(input()))
def gen():
for j in range(1, N + 1):
yield j * (N // j) * (N // j + 1) / 2
ans = int(sum(gen()))
print(ans)
| false | 44.444444 | [
"-ans = int(sum([j * (N // j) * (N // j + 1) / 2 for j in range(1, N + 1)]))",
"+",
"+",
"+def gen():",
"+ for j in range(1, N + 1):",
"+ yield j * (N // j) * (N // j + 1) / 2",
"+",
"+",
"+ans = int(sum(gen()))"
] | false | 1.037309 | 0.509753 | 2.034925 | [
"s093339042",
"s018919374"
] |
u086503932 | p02888 | python | s593248726 | s107133633 | 1,734 | 1,288 | 50,652 | 3,188 | Accepted | Accepted | 25.72 | #!/usr/bin/env python3
import sys
from bisect import bisect_right
def main():
N = int(eval(input()))
L = sorted(list(map(int, input().split())))
ans = 0
for i in range(N-1):
for j in range(i+1,N):
diff = L[j] - L[i]
index = bisect_right(L[:i],diff)
ans += i-index
# print(i,j,ans)
print(ans)
if __name__ == '__main__':
main() | #!/usr/bin/env python3
import sys
from bisect import bisect_left
def main():
N = int(eval(input()))
L = sorted(list(map(int, input().split())))
ans = 0
for i in range(N-1):
for j in range(i+1,N):
index = bisect_left(L,L[i]+L[j])
ans += max(0,index-j-1)
print(ans)
if __name__ == '__main__':
main()
| 19 | 17 | 420 | 367 | #!/usr/bin/env python3
import sys
from bisect import bisect_right
def main():
N = int(eval(input()))
L = sorted(list(map(int, input().split())))
ans = 0
for i in range(N - 1):
for j in range(i + 1, N):
diff = L[j] - L[i]
index = bisect_right(L[:i], diff)
ans += i - index
# print(i,j,ans)
print(ans)
if __name__ == "__main__":
main()
| #!/usr/bin/env python3
import sys
from bisect import bisect_left
def main():
N = int(eval(input()))
L = sorted(list(map(int, input().split())))
ans = 0
for i in range(N - 1):
for j in range(i + 1, N):
index = bisect_left(L, L[i] + L[j])
ans += max(0, index - j - 1)
print(ans)
if __name__ == "__main__":
main()
| false | 10.526316 | [
"-from bisect import bisect_right",
"+from bisect import bisect_left",
"- diff = L[j] - L[i]",
"- index = bisect_right(L[:i], diff)",
"- ans += i - index",
"- # print(i,j,ans)",
"+ index = bisect_left(L, L[i] + L[j])",
"+ ans += max(0, index - j - 1)"
] | false | 0.045584 | 0.046385 | 0.982722 | [
"s593248726",
"s107133633"
] |
u934442292 | p03043 | python | s899093880 | s615676063 | 49 | 39 | 2,940 | 9,120 | Accepted | Accepted | 20.41 | N, K = list(map(int, input().split()))
ans = 0
for i in range(N):
p = i + 1
cnt = 0
while p < K:
cnt += 1
p *= 2
ans += (1 / N) * (1 / 2) ** cnt
print(ans)
| import sys
input = sys.stdin.readline
def main():
N, K = list(map(int, input().split()))
ans = 0
for n in range(1, N + 1):
cnt = 0
while n < K:
n *= 2
cnt += 1
ans += (1 / 2 ** cnt)
ans /= N
print(ans)
if __name__ == "__main__":
main()
| 12 | 22 | 195 | 330 | N, K = list(map(int, input().split()))
ans = 0
for i in range(N):
p = i + 1
cnt = 0
while p < K:
cnt += 1
p *= 2
ans += (1 / N) * (1 / 2) ** cnt
print(ans)
| import sys
input = sys.stdin.readline
def main():
N, K = list(map(int, input().split()))
ans = 0
for n in range(1, N + 1):
cnt = 0
while n < K:
n *= 2
cnt += 1
ans += 1 / 2**cnt
ans /= N
print(ans)
if __name__ == "__main__":
main()
| false | 45.454545 | [
"-N, K = list(map(int, input().split()))",
"-ans = 0",
"-for i in range(N):",
"- p = i + 1",
"- cnt = 0",
"- while p < K:",
"- cnt += 1",
"- p *= 2",
"- ans += (1 / N) * (1 / 2) ** cnt",
"-print(ans)",
"+import sys",
"+",
"+input = sys.stdin.readline",
"+",
"+",
"+def main():",
"+ N, K = list(map(int, input().split()))",
"+ ans = 0",
"+ for n in range(1, N + 1):",
"+ cnt = 0",
"+ while n < K:",
"+ n *= 2",
"+ cnt += 1",
"+ ans += 1 / 2**cnt",
"+ ans /= N",
"+ print(ans)",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ main()"
] | false | 0.093877 | 0.054996 | 1.706977 | [
"s899093880",
"s615676063"
] |
u191874006 | p02901 | python | s918960383 | s018148533 | 697 | 636 | 133,852 | 130,140 | Accepted | Accepted | 8.75 | #!/usr/bin/env python3
#ABC142 E
import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(1000000000)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
n,m = LI()
cost = []
key = []
for _ in range(m):
a,b = LI()
cost.append(a)
c = LI()
tmp = 0
for i in c:
tmp |= 1 << (i-1)
key.append(tmp)
dp = [[inf]*(m+1) for _ in range(2**n)]
dp[0][0] = 0
for i in range(2**n):
for j in range(m):
dp[i][j+1] = min(dp[i][j+1],dp[i][j])
for j in range(1,m+1):
s = key[j-1]
if i|s > i:
dp[i|s][j] = min(dp[i|s][j],dp[i][j-1] + cost[j-1])
if min(dp[-1]) == inf:
print((-1))
else:
print((min(dp[-1]))) | #!/usr/bin/env python3
#ABC142 E
import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(1000000000)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
n,m = LI()
cost = []
key = []
for _ in range(m):
a,b = LI()
cost.append(a)
c = LI()
tmp = 0
for i in c:
tmp |= 1 << (i-1)
key.append(tmp)
dp = [[inf]*(m+1) for _ in range(2**n)]
dp[0][0] = 0
for i in range(2**n):
M = min(dp[i])
for j in range(1,m+1):
s = key[j-1]
if i|s > i:
dp[i|s][j] = min(dp[i|s][j],M + cost[j-1])
if min(dp[-1]) == inf:
print((-1))
else:
print((min(dp[-1]))) | 44 | 43 | 1,105 | 1,045 | #!/usr/bin/env python3
# ABC142 E
import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(1000000000)
from heapq import heappush, heappop, heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float("inf")
def I():
return int(sys.stdin.readline())
def LI():
return list(map(int, sys.stdin.readline().split()))
n, m = LI()
cost = []
key = []
for _ in range(m):
a, b = LI()
cost.append(a)
c = LI()
tmp = 0
for i in c:
tmp |= 1 << (i - 1)
key.append(tmp)
dp = [[inf] * (m + 1) for _ in range(2**n)]
dp[0][0] = 0
for i in range(2**n):
for j in range(m):
dp[i][j + 1] = min(dp[i][j + 1], dp[i][j])
for j in range(1, m + 1):
s = key[j - 1]
if i | s > i:
dp[i | s][j] = min(dp[i | s][j], dp[i][j - 1] + cost[j - 1])
if min(dp[-1]) == inf:
print((-1))
else:
print((min(dp[-1])))
| #!/usr/bin/env python3
# ABC142 E
import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(1000000000)
from heapq import heappush, heappop, heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float("inf")
def I():
return int(sys.stdin.readline())
def LI():
return list(map(int, sys.stdin.readline().split()))
n, m = LI()
cost = []
key = []
for _ in range(m):
a, b = LI()
cost.append(a)
c = LI()
tmp = 0
for i in c:
tmp |= 1 << (i - 1)
key.append(tmp)
dp = [[inf] * (m + 1) for _ in range(2**n)]
dp[0][0] = 0
for i in range(2**n):
M = min(dp[i])
for j in range(1, m + 1):
s = key[j - 1]
if i | s > i:
dp[i | s][j] = min(dp[i | s][j], M + cost[j - 1])
if min(dp[-1]) == inf:
print((-1))
else:
print((min(dp[-1])))
| false | 2.272727 | [
"- for j in range(m):",
"- dp[i][j + 1] = min(dp[i][j + 1], dp[i][j])",
"+ M = min(dp[i])",
"- dp[i | s][j] = min(dp[i | s][j], dp[i][j - 1] + cost[j - 1])",
"+ dp[i | s][j] = min(dp[i | s][j], M + cost[j - 1])"
] | false | 0.117723 | 0.161839 | 0.727408 | [
"s918960383",
"s018148533"
] |
u861466636 | p03140 | python | s511569978 | s632944750 | 24 | 17 | 3,768 | 3,060 | Accepted | Accepted | 29.17 | import string
n = int(eval(input()))
a = eval(input())
b = eval(input())
c = eval(input())
cnt = 0
for x, y, z in zip(a, b, c):
wl = [0]*26
wl[string.ascii_lowercase.index(x)] += 1
wl[string.ascii_lowercase.index(y)] += 1
wl[string.ascii_lowercase.index(z)] += 1
cnt += 3 - max(wl)
print(cnt) | n = int(eval(input()))
a = list(eval(input()))
b = list(eval(input()))
c = list(eval(input()))
ans = 0
for x, y, z in zip(a, b, c):
ans += len(set((x, y, z))) - 1
print(ans) | 13 | 9 | 300 | 162 | import string
n = int(eval(input()))
a = eval(input())
b = eval(input())
c = eval(input())
cnt = 0
for x, y, z in zip(a, b, c):
wl = [0] * 26
wl[string.ascii_lowercase.index(x)] += 1
wl[string.ascii_lowercase.index(y)] += 1
wl[string.ascii_lowercase.index(z)] += 1
cnt += 3 - max(wl)
print(cnt)
| n = int(eval(input()))
a = list(eval(input()))
b = list(eval(input()))
c = list(eval(input()))
ans = 0
for x, y, z in zip(a, b, c):
ans += len(set((x, y, z))) - 1
print(ans)
| false | 30.769231 | [
"-import string",
"-",
"-a = eval(input())",
"-b = eval(input())",
"-c = eval(input())",
"-cnt = 0",
"+a = list(eval(input()))",
"+b = list(eval(input()))",
"+c = list(eval(input()))",
"+ans = 0",
"- wl = [0] * 26",
"- wl[string.ascii_lowercase.index(x)] += 1",
"- wl[string.ascii_lowercase.index(y)] += 1",
"- wl[string.ascii_lowercase.index(z)] += 1",
"- cnt += 3 - max(wl)",
"-print(cnt)",
"+ ans += len(set((x, y, z))) - 1",
"+print(ans)"
] | false | 0.154893 | 0.042289 | 3.662696 | [
"s511569978",
"s632944750"
] |
u730769327 | p03295 | python | s731582169 | s174754323 | 903 | 379 | 59,864 | 83,500 | Accepted | Accepted | 58.03 | n,m=list(map(int,input().split()))
itv=[]
for i in range(m):
a,b=list(map(int,input().split()))
start=min(a,b)
end=max(a,b)
itv.append([end,start])
t,ans=0,0
itv=sorted(itv)
for e,s in itv:
if t<=s:
t=e
ans+=1
print(ans) | n,m=list(map(int,input().split()))
itv=[]
for i in range(m):
a,b=list(map(int,input().split()))
itv+=[(b,a)]
itv=sorted(itv)
cnt=0
l=1
for t,s in itv:
if l<=s:
l=t
cnt+=1
print(cnt) | 14 | 13 | 239 | 195 | n, m = list(map(int, input().split()))
itv = []
for i in range(m):
a, b = list(map(int, input().split()))
start = min(a, b)
end = max(a, b)
itv.append([end, start])
t, ans = 0, 0
itv = sorted(itv)
for e, s in itv:
if t <= s:
t = e
ans += 1
print(ans)
| n, m = list(map(int, input().split()))
itv = []
for i in range(m):
a, b = list(map(int, input().split()))
itv += [(b, a)]
itv = sorted(itv)
cnt = 0
l = 1
for t, s in itv:
if l <= s:
l = t
cnt += 1
print(cnt)
| false | 7.142857 | [
"- start = min(a, b)",
"- end = max(a, b)",
"- itv.append([end, start])",
"-t, ans = 0, 0",
"+ itv += [(b, a)]",
"-for e, s in itv:",
"- if t <= s:",
"- t = e",
"- ans += 1",
"-print(ans)",
"+cnt = 0",
"+l = 1",
"+for t, s in itv:",
"+ if l <= s:",
"+ l = t",
"+ cnt += 1",
"+print(cnt)"
] | false | 0.047131 | 0.047618 | 0.989766 | [
"s731582169",
"s174754323"
] |
u816631826 | p03264 | python | s649389808 | s721370379 | 19 | 17 | 3,188 | 3,064 | Accepted | Accepted | 10.53 | n=int(eval(input()))
even=[]
odd=[]
for i in range (1,n+1,1):
if i%2==0:
even.append(i)
else:
odd.append(i)
result=[(x,y) for x in even for y in odd]
print((len(result))) | k=int(eval(input()))
nomber_of_even_nombers=k//2
nomber_of_odd_nombers=k-nomber_of_even_nombers
nomber_of_wayes=nomber_of_even_nombers*nomber_of_odd_nombers
print(nomber_of_wayes)
| 10 | 5 | 195 | 178 | n = int(eval(input()))
even = []
odd = []
for i in range(1, n + 1, 1):
if i % 2 == 0:
even.append(i)
else:
odd.append(i)
result = [(x, y) for x in even for y in odd]
print((len(result)))
| k = int(eval(input()))
nomber_of_even_nombers = k // 2
nomber_of_odd_nombers = k - nomber_of_even_nombers
nomber_of_wayes = nomber_of_even_nombers * nomber_of_odd_nombers
print(nomber_of_wayes)
| false | 50 | [
"-n = int(eval(input()))",
"-even = []",
"-odd = []",
"-for i in range(1, n + 1, 1):",
"- if i % 2 == 0:",
"- even.append(i)",
"- else:",
"- odd.append(i)",
"-result = [(x, y) for x in even for y in odd]",
"-print((len(result)))",
"+k = int(eval(input()))",
"+nomber_of_even_nombers = k // 2",
"+nomber_of_odd_nombers = k - nomber_of_even_nombers",
"+nomber_of_wayes = nomber_of_even_nombers * nomber_of_odd_nombers",
"+print(nomber_of_wayes)"
] | false | 0.050798 | 0.050705 | 1.001842 | [
"s649389808",
"s721370379"
] |
u687574784 | p03835 | python | s271939209 | s199338665 | 1,554 | 18 | 2,940 | 3,060 | Accepted | Accepted | 98.84 | k,s = list(map(int, input().split()))
cnt=0
for i in range(k+1):
for j in range(k+1):
if s>=i+j>=s-k:
cnt+=1
print(cnt) | k,s = list(map(int, input().split()))
cnt=0
minX=max(s-2*k, 0)
maxX=min(s, k)
for x in range(minX, maxX+1):
rest=s-x
if k>=rest:
cnt+=rest+1
else:
cnt+=2*k-rest+1
print(cnt) | 7 | 12 | 149 | 217 | k, s = list(map(int, input().split()))
cnt = 0
for i in range(k + 1):
for j in range(k + 1):
if s >= i + j >= s - k:
cnt += 1
print(cnt)
| k, s = list(map(int, input().split()))
cnt = 0
minX = max(s - 2 * k, 0)
maxX = min(s, k)
for x in range(minX, maxX + 1):
rest = s - x
if k >= rest:
cnt += rest + 1
else:
cnt += 2 * k - rest + 1
print(cnt)
| false | 41.666667 | [
"-for i in range(k + 1):",
"- for j in range(k + 1):",
"- if s >= i + j >= s - k:",
"- cnt += 1",
"+minX = max(s - 2 * k, 0)",
"+maxX = min(s, k)",
"+for x in range(minX, maxX + 1):",
"+ rest = s - x",
"+ if k >= rest:",
"+ cnt += rest + 1",
"+ else:",
"+ cnt += 2 * k - rest + 1"
] | false | 0.050061 | 0.038202 | 1.310415 | [
"s271939209",
"s199338665"
] |
u426534722 | p02390 | python | s300231751 | s186767779 | 30 | 20 | 7,668 | 5,596 | Accepted | Accepted | 33.33 | s = int(input())
print(s // 3600, end="")
print(":", end="")
print(s // 60 % 60, end="")
print(":", end="")
print(s % 60)
| S = int(eval(input()))
h = S // 3600
S %= 3600
m = S // 60
s = S % 60
print(f"{h}:{m}:{s}")
| 6 | 6 | 127 | 91 | s = int(input())
print(s // 3600, end="")
print(":", end="")
print(s // 60 % 60, end="")
print(":", end="")
print(s % 60)
| S = int(eval(input()))
h = S // 3600
S %= 3600
m = S // 60
s = S % 60
print(f"{h}:{m}:{s}")
| false | 0 | [
"-s = int(input())",
"-print(s // 3600, end=\"\")",
"-print(\":\", end=\"\")",
"-print(s // 60 % 60, end=\"\")",
"-print(\":\", end=\"\")",
"-print(s % 60)",
"+S = int(eval(input()))",
"+h = S // 3600",
"+S %= 3600",
"+m = S // 60",
"+s = S % 60",
"+print(f\"{h}:{m}:{s}\")"
] | false | 0.039748 | 0.041599 | 0.955505 | [
"s300231751",
"s186767779"
] |
u944325914 | p02861 | python | s413197497 | s206695150 | 507 | 278 | 19,376 | 13,992 | Accepted | Accepted | 45.17 | import itertools
import math
n=int(eval(input()))
empty_list=[]
a=[i for i in range(n)]
permutations_list=[list(b) for b in itertools.permutations(a)]
coordinate_list=[list(map(int,input().split())) for _ in range(n)]
for i in range(math.factorial(n)):
for j in range(n-1):
empty_list.append(math.sqrt((coordinate_list[(permutations_list[i][j]-1)][0]-coordinate_list[(permutations_list[i][j+1]-1)][0])**2+(coordinate_list[(permutations_list[i][j]-1)][1]-coordinate_list[(permutations_list[i][j+1]-1)][1])**2))
b=int(math.factorial(n))
c=sum(empty_list)
print((c*(n-1)/((n-1)*b))) | from itertools import permutations
from math import sqrt,factorial
n=int(eval(input()))
ans=0
distance=[list(map(int,input().split())) for i in range(n)]
town=[]
for i in range(n):
town.append(i)
for a in list(permutations(town)):
for j in range(n-1):
ans+=sqrt((distance[a[j+1]][1]-distance[a[j]][1])**2+(distance[a[j+1]][0]-distance[a[j]][0])**2)
print((ans/(factorial(n)))) | 13 | 12 | 589 | 395 | import itertools
import math
n = int(eval(input()))
empty_list = []
a = [i for i in range(n)]
permutations_list = [list(b) for b in itertools.permutations(a)]
coordinate_list = [list(map(int, input().split())) for _ in range(n)]
for i in range(math.factorial(n)):
for j in range(n - 1):
empty_list.append(
math.sqrt(
(
coordinate_list[(permutations_list[i][j] - 1)][0]
- coordinate_list[(permutations_list[i][j + 1] - 1)][0]
)
** 2
+ (
coordinate_list[(permutations_list[i][j] - 1)][1]
- coordinate_list[(permutations_list[i][j + 1] - 1)][1]
)
** 2
)
)
b = int(math.factorial(n))
c = sum(empty_list)
print((c * (n - 1) / ((n - 1) * b)))
| from itertools import permutations
from math import sqrt, factorial
n = int(eval(input()))
ans = 0
distance = [list(map(int, input().split())) for i in range(n)]
town = []
for i in range(n):
town.append(i)
for a in list(permutations(town)):
for j in range(n - 1):
ans += sqrt(
(distance[a[j + 1]][1] - distance[a[j]][1]) ** 2
+ (distance[a[j + 1]][0] - distance[a[j]][0]) ** 2
)
print((ans / (factorial(n))))
| false | 7.692308 | [
"-import itertools",
"-import math",
"+from itertools import permutations",
"+from math import sqrt, factorial",
"-empty_list = []",
"-a = [i for i in range(n)]",
"-permutations_list = [list(b) for b in itertools.permutations(a)]",
"-coordinate_list = [list(map(int, input().split())) for _ in range(n)]",
"-for i in range(math.factorial(n)):",
"+ans = 0",
"+distance = [list(map(int, input().split())) for i in range(n)]",
"+town = []",
"+for i in range(n):",
"+ town.append(i)",
"+for a in list(permutations(town)):",
"- empty_list.append(",
"- math.sqrt(",
"- (",
"- coordinate_list[(permutations_list[i][j] - 1)][0]",
"- - coordinate_list[(permutations_list[i][j + 1] - 1)][0]",
"- )",
"- ** 2",
"- + (",
"- coordinate_list[(permutations_list[i][j] - 1)][1]",
"- - coordinate_list[(permutations_list[i][j + 1] - 1)][1]",
"- )",
"- ** 2",
"- )",
"+ ans += sqrt(",
"+ (distance[a[j + 1]][1] - distance[a[j]][1]) ** 2",
"+ + (distance[a[j + 1]][0] - distance[a[j]][0]) ** 2",
"-b = int(math.factorial(n))",
"-c = sum(empty_list)",
"-print((c * (n - 1) / ((n - 1) * b)))",
"+print((ans / (factorial(n))))"
] | false | 0.035426 | 0.039659 | 0.893283 | [
"s413197497",
"s206695150"
] |
u998435601 | p02384 | python | s125315592 | s954927338 | 30 | 20 | 7,768 | 7,752 | Accepted | Accepted | 33.33 | # coding: utf-8
# ?????????????????¨????????????
class Dice(object):
def __init__(self):
# ????????¶???
self.dice = (2, 5), (3, 4), (1, 6) # x, y, z
self.ax = [[0, False], [1, False], [2, False]]
self.axmap = [0, 1, 2]
self.mm = {"N": (0, 2), "S": (2, 0), "E": (1, 2), "W": (2, 1), "R": (0, 1), "L": (1, 0)}
def rotate(self, dir):
def rot(k, r):
t = self.axmap[r]
self.axmap[k], self.axmap[r] = t, self.axmap[k]
self.ax[t][1] = not self.ax[t][1]
rot(*self.mm[dir])
def front(self): return self.value(0, True)
def rear(self): return self.value(0, False)
def right(self): return self.value(1, True)
def left(self): return self.value(1, False)
def top(self): return self.value(2, True)
def bottom(self): return self.value(2, False)
def value(self, ax, d):
a = self.ax[self.axmap[ax]]
return self.dice[a[0]][a[1] if d else not a[1]]
if __name__=="__main__":
dice = Dice()
labels = input().split()
q = int(eval(input()))
def tf(p, f, d):
for _ in range(4):
if p==f(): break
dice.rotate(d)
for _ in range(q):
a, b = input().split()
p = labels.index(a) + 1
f = dice.top
tf(p, f, "N")
tf(p, f, "E")
p = labels.index(b) + 1
f = dice.front
tf(p, f, "R")
print((labels[dice.right()-1])) | # coding: utf-8
# ?????????????????¨????????????
class Dice(object):
def __init__(self):
# ????????¶???
self.dice = (2, 5), (3, 4), (1, 6) # x, y, z
self.ax = [[0, False], [1, False], [2, False]]
self.axmap = [0, 1, 2]
self.mm = {"N": (0, 2), "S": (2, 0), "E": (1, 2), "W": (2, 1), "R": (0, 1), "L": (1, 0)}
def rotate(self, dir):
def rot(k, r):
t = self.axmap[r]
self.axmap[k], self.axmap[r] = t, self.axmap[k]
self.ax[t][1] = not self.ax[t][1]
rot(*self.mm[dir])
def front(self): return self.value(0, True)
def rear(self): return self.value(0, False)
def right(self): return self.value(1, True)
def left(self): return self.value(1, False)
def top(self): return self.value(2, True)
def bottom(self): return self.value(2, False)
def value(self, ax, d):
a = self.ax[self.axmap[ax]]
return self.dice[a[0]][a[1] if d else not a[1]]
if __name__=="__main__":
dice = Dice()
labels = input().split()
q = int(eval(input()))
def tf(p, f, d):
for _ in range(4):
if p==f(): break
dice.rotate(d)
for _ in range(q):
a, b = input().split()
p = labels.index(a) + 1
f = dice.top
tf(p, f, "N")
if p!=f(): tf(p, f, "E")
p = labels.index(b) + 1
f = dice.front
tf(p, f, "R")
print((labels[dice.right()-1])) | 49 | 49 | 1,291 | 1,302 | # coding: utf-8
# ?????????????????¨????????????
class Dice(object):
def __init__(self):
# ????????¶???
self.dice = (2, 5), (3, 4), (1, 6) # x, y, z
self.ax = [[0, False], [1, False], [2, False]]
self.axmap = [0, 1, 2]
self.mm = {
"N": (0, 2),
"S": (2, 0),
"E": (1, 2),
"W": (2, 1),
"R": (0, 1),
"L": (1, 0),
}
def rotate(self, dir):
def rot(k, r):
t = self.axmap[r]
self.axmap[k], self.axmap[r] = t, self.axmap[k]
self.ax[t][1] = not self.ax[t][1]
rot(*self.mm[dir])
def front(self):
return self.value(0, True)
def rear(self):
return self.value(0, False)
def right(self):
return self.value(1, True)
def left(self):
return self.value(1, False)
def top(self):
return self.value(2, True)
def bottom(self):
return self.value(2, False)
def value(self, ax, d):
a = self.ax[self.axmap[ax]]
return self.dice[a[0]][a[1] if d else not a[1]]
if __name__ == "__main__":
dice = Dice()
labels = input().split()
q = int(eval(input()))
def tf(p, f, d):
for _ in range(4):
if p == f():
break
dice.rotate(d)
for _ in range(q):
a, b = input().split()
p = labels.index(a) + 1
f = dice.top
tf(p, f, "N")
tf(p, f, "E")
p = labels.index(b) + 1
f = dice.front
tf(p, f, "R")
print((labels[dice.right() - 1]))
| # coding: utf-8
# ?????????????????¨????????????
class Dice(object):
def __init__(self):
# ????????¶???
self.dice = (2, 5), (3, 4), (1, 6) # x, y, z
self.ax = [[0, False], [1, False], [2, False]]
self.axmap = [0, 1, 2]
self.mm = {
"N": (0, 2),
"S": (2, 0),
"E": (1, 2),
"W": (2, 1),
"R": (0, 1),
"L": (1, 0),
}
def rotate(self, dir):
def rot(k, r):
t = self.axmap[r]
self.axmap[k], self.axmap[r] = t, self.axmap[k]
self.ax[t][1] = not self.ax[t][1]
rot(*self.mm[dir])
def front(self):
return self.value(0, True)
def rear(self):
return self.value(0, False)
def right(self):
return self.value(1, True)
def left(self):
return self.value(1, False)
def top(self):
return self.value(2, True)
def bottom(self):
return self.value(2, False)
def value(self, ax, d):
a = self.ax[self.axmap[ax]]
return self.dice[a[0]][a[1] if d else not a[1]]
if __name__ == "__main__":
dice = Dice()
labels = input().split()
q = int(eval(input()))
def tf(p, f, d):
for _ in range(4):
if p == f():
break
dice.rotate(d)
for _ in range(q):
a, b = input().split()
p = labels.index(a) + 1
f = dice.top
tf(p, f, "N")
if p != f():
tf(p, f, "E")
p = labels.index(b) + 1
f = dice.front
tf(p, f, "R")
print((labels[dice.right() - 1]))
| false | 0 | [
"- tf(p, f, \"E\")",
"+ if p != f():",
"+ tf(p, f, \"E\")"
] | false | 0.042506 | 0.041781 | 1.017342 | [
"s125315592",
"s954927338"
] |
u386819480 | p02971 | python | s506781771 | s981028335 | 440 | 363 | 15,592 | 14,056 | Accepted | Accepted | 17.5 | #!/usr/bin/env python3
import sys
def solve(N: int, A: "List[int]"):
left = [A[0]] * N
right = [A[-1]] * N
for i in range(1,N):
if(A[i] > left[i-1]):
left[i] = A[i]
else:
left[i] = left[i-1]
for i in reversed(list(range(0,N-1))):
if(A[i] > right[i+1]):
right[i] = A[i]
else:
right[i] = right[i+1]
for i in range(N):
if(i == 0):
print((right[1]))
elif(i == N-1):
print((left[N-2]))
else:
print((max(left[i-1], right[i+1])))
return
# Generated by 1.1.4 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
A = [ int(next(tokens)) for _ in range(N) ] # type: "List[int]"
solve(N, A)
if __name__ == '__main__':
main()
| #!/usr/bin/env python3
import sys
def solve(N: int, A: "List[int]"):
x = sorted(A)
for i in A:
if(i == x[-1]):
print((x[-2]))
else:
print((x[-1]))
return
# Generated by 1.1.5 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
A = [int(next(tokens)) for _ in range(N)] # type: "List[int]"
solve(N, A)
if __name__ == '__main__':
main()
| 45 | 28 | 1,128 | 737 | #!/usr/bin/env python3
import sys
def solve(N: int, A: "List[int]"):
left = [A[0]] * N
right = [A[-1]] * N
for i in range(1, N):
if A[i] > left[i - 1]:
left[i] = A[i]
else:
left[i] = left[i - 1]
for i in reversed(list(range(0, N - 1))):
if A[i] > right[i + 1]:
right[i] = A[i]
else:
right[i] = right[i + 1]
for i in range(N):
if i == 0:
print((right[1]))
elif i == N - 1:
print((left[N - 2]))
else:
print((max(left[i - 1], right[i + 1])))
return
# Generated by 1.1.4 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
A = [int(next(tokens)) for _ in range(N)] # type: "List[int]"
solve(N, A)
if __name__ == "__main__":
main()
| #!/usr/bin/env python3
import sys
def solve(N: int, A: "List[int]"):
x = sorted(A)
for i in A:
if i == x[-1]:
print((x[-2]))
else:
print((x[-1]))
return
# Generated by 1.1.5 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
A = [int(next(tokens)) for _ in range(N)] # type: "List[int]"
solve(N, A)
if __name__ == "__main__":
main()
| false | 37.777778 | [
"- left = [A[0]] * N",
"- right = [A[-1]] * N",
"- for i in range(1, N):",
"- if A[i] > left[i - 1]:",
"- left[i] = A[i]",
"+ x = sorted(A)",
"+ for i in A:",
"+ if i == x[-1]:",
"+ print((x[-2]))",
"- left[i] = left[i - 1]",
"- for i in reversed(list(range(0, N - 1))):",
"- if A[i] > right[i + 1]:",
"- right[i] = A[i]",
"- else:",
"- right[i] = right[i + 1]",
"- for i in range(N):",
"- if i == 0:",
"- print((right[1]))",
"- elif i == N - 1:",
"- print((left[N - 2]))",
"- else:",
"- print((max(left[i - 1], right[i + 1])))",
"+ print((x[-1]))",
"-# Generated by 1.1.4 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)",
"+# Generated by 1.1.5 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)"
] | false | 0.049312 | 0.048592 | 1.0148 | [
"s506781771",
"s981028335"
] |
u522266410 | p03017 | python | s041305192 | s977039369 | 38 | 19 | 3,644 | 3,636 | Accepted | Accepted | 50 | n,a,b,c,d = (int(i) for i in input().split())
s = eval(input())
e = 0
if c<d:
if s[a:c-1].count("##")==0 and s[b:d-1].count("##")==0:
print("Yes")
else:
print("No")
else:
if s[a:c-1].count("##")==0 and s[b:d-1].count("##")==0:
for i in range(b-1,d):
if s[i-1:i+2]=="..." :
e = 1
if e == 1:
print("Yes")
else:
print("No")
else:
print("No")
| n,a,b,c,d = (int(i) for i in input().split())
s = eval(input())
e = 0
if c<d:
if s[a:c-1].count("##")==0 and s[b:d-1].count("##")==0:
print("Yes")
else:
print("No")
else:
if s[a:c-1].count("##")==0 and s[b:d-1].count("##")==0 and s[b-2:d+1].count("...")>0:
print("Yes")
else:
print("No")
| 20 | 15 | 414 | 324 | n, a, b, c, d = (int(i) for i in input().split())
s = eval(input())
e = 0
if c < d:
if s[a : c - 1].count("##") == 0 and s[b : d - 1].count("##") == 0:
print("Yes")
else:
print("No")
else:
if s[a : c - 1].count("##") == 0 and s[b : d - 1].count("##") == 0:
for i in range(b - 1, d):
if s[i - 1 : i + 2] == "...":
e = 1
if e == 1:
print("Yes")
else:
print("No")
else:
print("No")
| n, a, b, c, d = (int(i) for i in input().split())
s = eval(input())
e = 0
if c < d:
if s[a : c - 1].count("##") == 0 and s[b : d - 1].count("##") == 0:
print("Yes")
else:
print("No")
else:
if (
s[a : c - 1].count("##") == 0
and s[b : d - 1].count("##") == 0
and s[b - 2 : d + 1].count("...") > 0
):
print("Yes")
else:
print("No")
| false | 25 | [
"- if s[a : c - 1].count(\"##\") == 0 and s[b : d - 1].count(\"##\") == 0:",
"- for i in range(b - 1, d):",
"- if s[i - 1 : i + 2] == \"...\":",
"- e = 1",
"- if e == 1:",
"- print(\"Yes\")",
"- else:",
"- print(\"No\")",
"+ if (",
"+ s[a : c - 1].count(\"##\") == 0",
"+ and s[b : d - 1].count(\"##\") == 0",
"+ and s[b - 2 : d + 1].count(\"...\") > 0",
"+ ):",
"+ print(\"Yes\")"
] | false | 0.047441 | 0.090898 | 0.521908 | [
"s041305192",
"s977039369"
] |
u896741788 | p02679 | python | s275098091 | s224457591 | 1,066 | 807 | 49,396 | 49,444 | Accepted | Accepted | 24.3 | mod=10**9+7
n=int(eval(input()))
from collections import defaultdict
d=defaultdict(int)#各点の方向ベクトルを管理
z=0#原点にいる際は例外処理したいので別途数える
from math import gcd
for i in range(n):
x,y=list(map(int,input().split()))
if x==y==0:z+=1
else:
f=gcd(x,y)
x//=f;y//=f#非本質な定数倍を削除
if x<0:x*=-1;y*=-1#偏角は|theta|<=pi/2で十分
if x==0 and y<0:y=-y
d[(x,y)]+=1
ans=1
for (a,s) in d:
if d[(a,s)]==0:continue#すでに数えた
ng=0
if (s,-a)in d:ng+=d[(s,-a)];d[(s,-a)]=0
if (-s,a)in d:ng+=d[(-s,a)];d[(-s,a)]=0
ans*=(pow(2,d[(a,s)],mod)-1 + pow(2,ng,mod)-1 +1)%mod
#(a,s)を一本以上使う,ngを((a,s)と直交するもの)を一本以上使う,どちらも使わない
ans%=mod
d[(a,s)]=0
print(((ans+z-1)%mod))#原点はそれ1つのみでしか使えない + 1つも使わない例を除外
| import sys
input=sys.stdin.buffer.readline
mod=10**9+7
n=int(eval(input()))
d={}
z=0
from math import gcd
for i in range(n):
x,y=list(map(int,input().split()))
if x==y==0:z+=1
else:
f=gcd(x,y)
x//=f;y//=f
if x<0:x*=-1;y*=-1
if x==0 and y<0:y=-y
if (x,y)not in d:d[(x,y)]=1
else:d[(x,y)]+=1
ans=1
for (a,s) in d:
if d[(a,s)]==0:continue
ng=0
if (s,-a)in d:ng+=d[(s,-a)];d[(s,-a)]=0
if (-s,a)in d:ng+=d[(-s,a)];d[(-s,a)]=0
ans*=(pow(2,d[(a,s)],mod)-1 + pow(2,ng,mod)-1 +1)%mod
ans%=mod
d[(a,s)]=0
print(((ans+z-1)%mod)) | 26 | 27 | 740 | 618 | mod = 10**9 + 7
n = int(eval(input()))
from collections import defaultdict
d = defaultdict(int) # 各点の方向ベクトルを管理
z = 0 # 原点にいる際は例外処理したいので別途数える
from math import gcd
for i in range(n):
x, y = list(map(int, input().split()))
if x == y == 0:
z += 1
else:
f = gcd(x, y)
x //= f
y //= f # 非本質な定数倍を削除
if x < 0:
x *= -1
y *= -1 # 偏角は|theta|<=pi/2で十分
if x == 0 and y < 0:
y = -y
d[(x, y)] += 1
ans = 1
for (a, s) in d:
if d[(a, s)] == 0:
continue # すでに数えた
ng = 0
if (s, -a) in d:
ng += d[(s, -a)]
d[(s, -a)] = 0
if (-s, a) in d:
ng += d[(-s, a)]
d[(-s, a)] = 0
ans *= (pow(2, d[(a, s)], mod) - 1 + pow(2, ng, mod) - 1 + 1) % mod
# (a,s)を一本以上使う,ngを((a,s)と直交するもの)を一本以上使う,どちらも使わない
ans %= mod
d[(a, s)] = 0
print(((ans + z - 1) % mod)) # 原点はそれ1つのみでしか使えない + 1つも使わない例を除外
| import sys
input = sys.stdin.buffer.readline
mod = 10**9 + 7
n = int(eval(input()))
d = {}
z = 0
from math import gcd
for i in range(n):
x, y = list(map(int, input().split()))
if x == y == 0:
z += 1
else:
f = gcd(x, y)
x //= f
y //= f
if x < 0:
x *= -1
y *= -1
if x == 0 and y < 0:
y = -y
if (x, y) not in d:
d[(x, y)] = 1
else:
d[(x, y)] += 1
ans = 1
for (a, s) in d:
if d[(a, s)] == 0:
continue
ng = 0
if (s, -a) in d:
ng += d[(s, -a)]
d[(s, -a)] = 0
if (-s, a) in d:
ng += d[(-s, a)]
d[(-s, a)] = 0
ans *= (pow(2, d[(a, s)], mod) - 1 + pow(2, ng, mod) - 1 + 1) % mod
ans %= mod
d[(a, s)] = 0
print(((ans + z - 1) % mod))
| false | 3.703704 | [
"+import sys",
"+",
"+input = sys.stdin.buffer.readline",
"-from collections import defaultdict",
"-",
"-d = defaultdict(int) # 各点の方向ベクトルを管理",
"-z = 0 # 原点にいる際は例外処理したいので別途数える",
"+d = {}",
"+z = 0",
"- y //= f # 非本質な定数倍を削除",
"+ y //= f",
"- y *= -1 # 偏角は|theta|<=pi/2で十分",
"+ y *= -1",
"- d[(x, y)] += 1",
"+ if (x, y) not in d:",
"+ d[(x, y)] = 1",
"+ else:",
"+ d[(x, y)] += 1",
"- continue # すでに数えた",
"+ continue",
"- # (a,s)を一本以上使う,ngを((a,s)と直交するもの)を一本以上使う,どちらも使わない",
"-print(((ans + z - 1) % mod)) # 原点はそれ1つのみでしか使えない + 1つも使わない例を除外",
"+print(((ans + z - 1) % mod))"
] | false | 0.103417 | 0.101217 | 1.021735 | [
"s275098091",
"s224457591"
] |
u141610915 | p02928 | python | s890900257 | s219583294 | 1,010 | 198 | 3,188 | 41,968 | Accepted | Accepted | 80.4 | N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
mod = 10 ** 9 + 7
table = [0 for _ in range(N)]
ftable = [0 for _ in range(N)]
for i in range(N):
for j in range(N):
if A[i] > A[j]:
table[i] += 1
if i < j:
ftable[i] += 1
print(((sum(table) * (K * (K - 1)) // 2 + sum(ftable) * K) % mod)) | import sys
input = sys.stdin.readline
N, K = list(map(int, input().split()))
a = list(map(int, input().split()))
mod = 10 ** 9 + 7
class BIT:
def __init__(self, n):
self.n = n
self.data = [0] * (n + 1)
self.el = [0] * (n + 1)
def sum(self, i):
s = 0
while i > 0:
s += self.data[i]
i -= i & -i
return s
def add(self, i, x):
self.el[i] += x
while i <= self.n:
self.data[i] += x
i += i & -i
def get(self, i, j = None):
if j is None:
return self.el[i]
return self.sum(j) - self.sum(i)
fwk = BIT(2001)
res = 0
for i in range(N):
res += fwk.get(a[i], 2001)
res %= mod
fwk.add(a[i], 1)
res *= K
res %= mod
for i in range(N):
res += (K * (K - 1) // 2) % mod * fwk.get(a[i], 2001) % mod
res %= mod
print(res) | 12 | 39 | 342 | 821 | N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
mod = 10**9 + 7
table = [0 for _ in range(N)]
ftable = [0 for _ in range(N)]
for i in range(N):
for j in range(N):
if A[i] > A[j]:
table[i] += 1
if i < j:
ftable[i] += 1
print(((sum(table) * (K * (K - 1)) // 2 + sum(ftable) * K) % mod))
| import sys
input = sys.stdin.readline
N, K = list(map(int, input().split()))
a = list(map(int, input().split()))
mod = 10**9 + 7
class BIT:
def __init__(self, n):
self.n = n
self.data = [0] * (n + 1)
self.el = [0] * (n + 1)
def sum(self, i):
s = 0
while i > 0:
s += self.data[i]
i -= i & -i
return s
def add(self, i, x):
self.el[i] += x
while i <= self.n:
self.data[i] += x
i += i & -i
def get(self, i, j=None):
if j is None:
return self.el[i]
return self.sum(j) - self.sum(i)
fwk = BIT(2001)
res = 0
for i in range(N):
res += fwk.get(a[i], 2001)
res %= mod
fwk.add(a[i], 1)
res *= K
res %= mod
for i in range(N):
res += (K * (K - 1) // 2) % mod * fwk.get(a[i], 2001) % mod
res %= mod
print(res)
| false | 69.230769 | [
"+import sys",
"+",
"+input = sys.stdin.readline",
"-A = list(map(int, input().split()))",
"+a = list(map(int, input().split()))",
"-table = [0 for _ in range(N)]",
"-ftable = [0 for _ in range(N)]",
"+",
"+",
"+class BIT:",
"+ def __init__(self, n):",
"+ self.n = n",
"+ self.data = [0] * (n + 1)",
"+ self.el = [0] * (n + 1)",
"+",
"+ def sum(self, i):",
"+ s = 0",
"+ while i > 0:",
"+ s += self.data[i]",
"+ i -= i & -i",
"+ return s",
"+",
"+ def add(self, i, x):",
"+ self.el[i] += x",
"+ while i <= self.n:",
"+ self.data[i] += x",
"+ i += i & -i",
"+",
"+ def get(self, i, j=None):",
"+ if j is None:",
"+ return self.el[i]",
"+ return self.sum(j) - self.sum(i)",
"+",
"+",
"+fwk = BIT(2001)",
"+res = 0",
"- for j in range(N):",
"- if A[i] > A[j]:",
"- table[i] += 1",
"- if i < j:",
"- ftable[i] += 1",
"-print(((sum(table) * (K * (K - 1)) // 2 + sum(ftable) * K) % mod))",
"+ res += fwk.get(a[i], 2001)",
"+ res %= mod",
"+ fwk.add(a[i], 1)",
"+res *= K",
"+res %= mod",
"+for i in range(N):",
"+ res += (K * (K - 1) // 2) % mod * fwk.get(a[i], 2001) % mod",
"+ res %= mod",
"+print(res)"
] | false | 0.037357 | 0.040274 | 0.927578 | [
"s890900257",
"s219583294"
] |
u450292714 | p02953 | python | s006931509 | s860559042 | 171 | 151 | 12,020 | 12,020 | Accepted | Accepted | 11.7 | n = int(eval(input()))
stair = input().split(' ')
for i in range(0, n - 1):
if (int(stair[i]) < int(stair[i+1])):
stair[i+1] = int(stair[i+1]) - 1
if (int(stair[i]) > int(stair[i+1])):
print("No")
exit()
print("Yes")
| n = int(eval(input()))
stair = input().split(' ')
stair[0] = int(stair[0]) - 1
for i in range(0, n - 1):
if (int(stair[i]) < int(stair[i+1])):
stair[i+1] = int(stair[i+1]) - 1
if (int(stair[i]) > int(stair[i+1])):
print("No")
exit()
print("Yes")
| 13 | 13 | 243 | 271 | n = int(eval(input()))
stair = input().split(" ")
for i in range(0, n - 1):
if int(stair[i]) < int(stair[i + 1]):
stair[i + 1] = int(stair[i + 1]) - 1
if int(stair[i]) > int(stair[i + 1]):
print("No")
exit()
print("Yes")
| n = int(eval(input()))
stair = input().split(" ")
stair[0] = int(stair[0]) - 1
for i in range(0, n - 1):
if int(stair[i]) < int(stair[i + 1]):
stair[i + 1] = int(stair[i + 1]) - 1
if int(stair[i]) > int(stair[i + 1]):
print("No")
exit()
print("Yes")
| false | 0 | [
"+stair[0] = int(stair[0]) - 1"
] | false | 0.106879 | 0.086275 | 1.238809 | [
"s006931509",
"s860559042"
] |
u220870679 | p03478 | python | s601744090 | s110057487 | 36 | 25 | 3,060 | 3,060 | Accepted | Accepted | 30.56 | N, A, B = list(map(int, input().split()))
ans = 0
for i in range(1, N+1):
x = (sum(list(map(int, list(str(i))))))
if A <= x <= B:
ans += i
print(ans) | N, A, B = list(map(int, input().split()))
ans = 0
def sumDigits(n):
sum = 0
while n != 0:
sum += n % 10
n = n // 10
return sum
for i in range(N+1):
x = sumDigits(i)
if A <= x <= B:
ans += i
print(ans) | 7 | 18 | 165 | 260 | N, A, B = list(map(int, input().split()))
ans = 0
for i in range(1, N + 1):
x = sum(list(map(int, list(str(i)))))
if A <= x <= B:
ans += i
print(ans)
| N, A, B = list(map(int, input().split()))
ans = 0
def sumDigits(n):
sum = 0
while n != 0:
sum += n % 10
n = n // 10
return sum
for i in range(N + 1):
x = sumDigits(i)
if A <= x <= B:
ans += i
print(ans)
| false | 61.111111 | [
"-for i in range(1, N + 1):",
"- x = sum(list(map(int, list(str(i)))))",
"+",
"+",
"+def sumDigits(n):",
"+ sum = 0",
"+ while n != 0:",
"+ sum += n % 10",
"+ n = n // 10",
"+ return sum",
"+",
"+",
"+for i in range(N + 1):",
"+ x = sumDigits(i)"
] | false | 0.133644 | 0.039519 | 3.381772 | [
"s601744090",
"s110057487"
] |
u922449550 | p03078 | python | s032124831 | s414495018 | 728 | 149 | 148,204 | 17,936 | Accepted | Accepted | 79.53 | # 想定解法1
X, Y, Z, K = list(map(int, input().split()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = list(map(int, input().split()))
A.sort(reverse=True)
B.sort(reverse=True)
C.sort(reverse=True)
AB = []
for a in A:
for b in B:
AB.append(a+b)
AB.sort(reverse=True)
AB = AB[:K]
ABC = []
for ab in AB:
for c in C:
ABC.append(ab+c)
ABC.sort(reverse=True)
ABC = ABC[:K]
for ans in ABC:
print(ans)
| # 想定解法2
X, Y, Z, K = list(map(int, input().split()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = list(map(int, input().split()))
A.sort(reverse=True)
B.sort(reverse=True)
C.sort(reverse=True)
ids = []
for x in range(1, X+1):
for y in range(1, Y+1):
if x*y > K:
break
for z in range(1, Z+1):
if x*y*z <= K:
ids.append((x-1, y-1, z-1))
else:
break
Ans = []
for x, y, z in ids:
Ans.append(A[x]+B[y]+C[z])
Ans.sort(reverse=True)
Ans = Ans[:K]
for ans in Ans:
print(ans) | 29 | 30 | 464 | 581 | # 想定解法1
X, Y, Z, K = list(map(int, input().split()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = list(map(int, input().split()))
A.sort(reverse=True)
B.sort(reverse=True)
C.sort(reverse=True)
AB = []
for a in A:
for b in B:
AB.append(a + b)
AB.sort(reverse=True)
AB = AB[:K]
ABC = []
for ab in AB:
for c in C:
ABC.append(ab + c)
ABC.sort(reverse=True)
ABC = ABC[:K]
for ans in ABC:
print(ans)
| # 想定解法2
X, Y, Z, K = list(map(int, input().split()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = list(map(int, input().split()))
A.sort(reverse=True)
B.sort(reverse=True)
C.sort(reverse=True)
ids = []
for x in range(1, X + 1):
for y in range(1, Y + 1):
if x * y > K:
break
for z in range(1, Z + 1):
if x * y * z <= K:
ids.append((x - 1, y - 1, z - 1))
else:
break
Ans = []
for x, y, z in ids:
Ans.append(A[x] + B[y] + C[z])
Ans.sort(reverse=True)
Ans = Ans[:K]
for ans in Ans:
print(ans)
| false | 3.333333 | [
"-# 想定解法1",
"+# 想定解法2",
"-AB = []",
"-for a in A:",
"- for b in B:",
"- AB.append(a + b)",
"-AB.sort(reverse=True)",
"-AB = AB[:K]",
"-ABC = []",
"-for ab in AB:",
"- for c in C:",
"- ABC.append(ab + c)",
"-ABC.sort(reverse=True)",
"-ABC = ABC[:K]",
"-for ans in ABC:",
"+ids = []",
"+for x in range(1, X + 1):",
"+ for y in range(1, Y + 1):",
"+ if x * y > K:",
"+ break",
"+ for z in range(1, Z + 1):",
"+ if x * y * z <= K:",
"+ ids.append((x - 1, y - 1, z - 1))",
"+ else:",
"+ break",
"+Ans = []",
"+for x, y, z in ids:",
"+ Ans.append(A[x] + B[y] + C[z])",
"+Ans.sort(reverse=True)",
"+Ans = Ans[:K]",
"+for ans in Ans:"
] | false | 0.042509 | 0.037817 | 1.124058 | [
"s032124831",
"s414495018"
] |
u581187895 | p02856 | python | s526788610 | s717734836 | 544 | 239 | 3,060 | 3,188 | Accepted | Accepted | 56.07 |
def resolve():
N = int(eval(input()))
S = 0
D = 0
for i in range(N):
d, c = list(map(int, input().split()))
S += d*c
D += c
print(((D-1) + (S-1)//9))
if __name__ == "__main__":
resolve() |
import sys
sys.setrecursionlimit(10 ** 7)
read = sys.stdin.buffer.read
inp = sys.stdin.buffer.readline
def resolve():
N = int(inp())
S = 0
D = 0
for i in range(N):
d, c = list(map(int, inp().split()))
S += d*c
D += c
print(((D-1) + (S-1)//9))
if __name__ == "__main__":
resolve() | 15 | 20 | 238 | 344 | def resolve():
N = int(eval(input()))
S = 0
D = 0
for i in range(N):
d, c = list(map(int, input().split()))
S += d * c
D += c
print(((D - 1) + (S - 1) // 9))
if __name__ == "__main__":
resolve()
| import sys
sys.setrecursionlimit(10**7)
read = sys.stdin.buffer.read
inp = sys.stdin.buffer.readline
def resolve():
N = int(inp())
S = 0
D = 0
for i in range(N):
d, c = list(map(int, inp().split()))
S += d * c
D += c
print(((D - 1) + (S - 1) // 9))
if __name__ == "__main__":
resolve()
| false | 25 | [
"+import sys",
"+",
"+sys.setrecursionlimit(10**7)",
"+read = sys.stdin.buffer.read",
"+inp = sys.stdin.buffer.readline",
"+",
"+",
"- N = int(eval(input()))",
"+ N = int(inp())",
"- d, c = list(map(int, input().split()))",
"+ d, c = list(map(int, inp().split()))"
] | false | 0.042323 | 0.042617 | 0.993113 | [
"s526788610",
"s717734836"
] |
u706786134 | p03164 | python | s648008486 | s813695034 | 379 | 328 | 119,788 | 21,416 | Accepted | Accepted | 13.46 | n, max_weight = list(map(int, input().split()))
WV = [list(map(int, input().split())) for _ in range(n)]
W, V = list(zip(*WV))
M = sum(V) + 1
#M = 100100
INF = 1 << 60
dp = list([INF] * M for _ in range(n + 1))
dp[0][0] = 0
for i in range(n):
for v in range(M):
if v >= V[i]:
dp[i + 1][v] = min(dp[i][v], dp[i][v - V[i]] + W[i])
else:
dp[i + 1][v] = dp[i][v]
for v in range(M):
if dp[n][v] <= max_weight:
ans = v
print(ans)
| import numpy as np
N, W = list(map(int, input().split()))
WV = np.array([input().split() for _ in range(N)], np.int64)
V = sum(WV[:, 1])
INF = 1 << 60
dp = np.full(V + 1, INF)
dp[0] = 0
for w, v in WV:
np.minimum(dp[v:], dp[:-v] + w, out=dp[v:])
for v in range(V + 1):
if dp[v] <= W:
ans = v
print(ans)
| 18 | 14 | 485 | 327 | n, max_weight = list(map(int, input().split()))
WV = [list(map(int, input().split())) for _ in range(n)]
W, V = list(zip(*WV))
M = sum(V) + 1
# M = 100100
INF = 1 << 60
dp = list([INF] * M for _ in range(n + 1))
dp[0][0] = 0
for i in range(n):
for v in range(M):
if v >= V[i]:
dp[i + 1][v] = min(dp[i][v], dp[i][v - V[i]] + W[i])
else:
dp[i + 1][v] = dp[i][v]
for v in range(M):
if dp[n][v] <= max_weight:
ans = v
print(ans)
| import numpy as np
N, W = list(map(int, input().split()))
WV = np.array([input().split() for _ in range(N)], np.int64)
V = sum(WV[:, 1])
INF = 1 << 60
dp = np.full(V + 1, INF)
dp[0] = 0
for w, v in WV:
np.minimum(dp[v:], dp[:-v] + w, out=dp[v:])
for v in range(V + 1):
if dp[v] <= W:
ans = v
print(ans)
| false | 22.222222 | [
"-n, max_weight = list(map(int, input().split()))",
"-WV = [list(map(int, input().split())) for _ in range(n)]",
"-W, V = list(zip(*WV))",
"-M = sum(V) + 1",
"-# M = 100100",
"+import numpy as np",
"+",
"+N, W = list(map(int, input().split()))",
"+WV = np.array([input().split() for _ in range(N)], np.int64)",
"+V = sum(WV[:, 1])",
"-dp = list([INF] * M for _ in range(n + 1))",
"-dp[0][0] = 0",
"-for i in range(n):",
"- for v in range(M):",
"- if v >= V[i]:",
"- dp[i + 1][v] = min(dp[i][v], dp[i][v - V[i]] + W[i])",
"- else:",
"- dp[i + 1][v] = dp[i][v]",
"-for v in range(M):",
"- if dp[n][v] <= max_weight:",
"+dp = np.full(V + 1, INF)",
"+dp[0] = 0",
"+for w, v in WV:",
"+ np.minimum(dp[v:], dp[:-v] + w, out=dp[v:])",
"+for v in range(V + 1):",
"+ if dp[v] <= W:"
] | false | 0.041976 | 0.238965 | 0.175658 | [
"s648008486",
"s813695034"
] |
u281303342 | p03400 | python | s311629440 | s348208442 | 20 | 17 | 3,060 | 3,060 | Accepted | Accepted | 15 | N = int(eval(input()))
D,X = list(map(int,input().split()))
A = [int(eval(input())) for _ in range(N)]
from math import ceil
ans = 0
for i in range(N):
ans += ceil(D/A[i])
print((ans+X))
| # Python3 (3.4.3)
import sys
input = sys.stdin.readline
# -------------------------------------------------------------
# function
# -------------------------------------------------------------
# -------------------------------------------------------------
# main
# -------------------------------------------------------------
N = int(eval(input()))
D,X = list(map(int,input().split()))
A = [int(eval(input())) for _ in range(N)]
from math import ceil
ans = 0
for i in range(N):
ans += ceil(D/A[i])
print((ans+X)) | 11 | 22 | 184 | 528 | N = int(eval(input()))
D, X = list(map(int, input().split()))
A = [int(eval(input())) for _ in range(N)]
from math import ceil
ans = 0
for i in range(N):
ans += ceil(D / A[i])
print((ans + X))
| # Python3 (3.4.3)
import sys
input = sys.stdin.readline
# -------------------------------------------------------------
# function
# -------------------------------------------------------------
# -------------------------------------------------------------
# main
# -------------------------------------------------------------
N = int(eval(input()))
D, X = list(map(int, input().split()))
A = [int(eval(input())) for _ in range(N)]
from math import ceil
ans = 0
for i in range(N):
ans += ceil(D / A[i])
print((ans + X))
| false | 50 | [
"+# Python3 (3.4.3)",
"+import sys",
"+",
"+input = sys.stdin.readline",
"+# function",
"+# main"
] | false | 0.059045 | 0.060827 | 0.970719 | [
"s311629440",
"s348208442"
] |
u794173881 | p03090 | python | s950962235 | s141203982 | 23 | 17 | 3,612 | 3,064 | Accepted | Accepted | 26.09 | n = int(eval(input()))
if n%2 ==0:
print(((n-1)*(n)//2-n//2))
else:
print(((n-2)*(n-1)//2-(n-1)//2 +n-1))
if n%2 ==1:
for i in range(n-1):
print((i+1,n))
n = n-1
if n%2 ==0:
wa = n+1
for i in range(n):
for j in range(i+1,n):
if wa != i+j+2:
print((i+1,j+1)) | n = int(eval(input()))
li = []
for i in range(0,(n//2)*2):
if i+1 < n-i:
li.append([i+1,n-i-n%2])
else:
break
if n%2 == 1:
li.append([n])
if len(li) > 2:
li.append(li[0])
count = 0
for i in range(1,len(li)):
for j in li[i-1]:
for k in li[i]:
count += 1
print(count)
for i in range(1,len(li)):
for j in li[i-1]:
for k in li[i]:
print((j,k)) | 17 | 24 | 295 | 397 | n = int(eval(input()))
if n % 2 == 0:
print(((n - 1) * (n) // 2 - n // 2))
else:
print(((n - 2) * (n - 1) // 2 - (n - 1) // 2 + n - 1))
if n % 2 == 1:
for i in range(n - 1):
print((i + 1, n))
n = n - 1
if n % 2 == 0:
wa = n + 1
for i in range(n):
for j in range(i + 1, n):
if wa != i + j + 2:
print((i + 1, j + 1))
| n = int(eval(input()))
li = []
for i in range(0, (n // 2) * 2):
if i + 1 < n - i:
li.append([i + 1, n - i - n % 2])
else:
break
if n % 2 == 1:
li.append([n])
if len(li) > 2:
li.append(li[0])
count = 0
for i in range(1, len(li)):
for j in li[i - 1]:
for k in li[i]:
count += 1
print(count)
for i in range(1, len(li)):
for j in li[i - 1]:
for k in li[i]:
print((j, k))
| false | 29.166667 | [
"-if n % 2 == 0:",
"- print(((n - 1) * (n) // 2 - n // 2))",
"-else:",
"- print(((n - 2) * (n - 1) // 2 - (n - 1) // 2 + n - 1))",
"+li = []",
"+for i in range(0, (n // 2) * 2):",
"+ if i + 1 < n - i:",
"+ li.append([i + 1, n - i - n % 2])",
"+ else:",
"+ break",
"- for i in range(n - 1):",
"- print((i + 1, n))",
"- n = n - 1",
"-if n % 2 == 0:",
"- wa = n + 1",
"- for i in range(n):",
"- for j in range(i + 1, n):",
"- if wa != i + j + 2:",
"- print((i + 1, j + 1))",
"+ li.append([n])",
"+if len(li) > 2:",
"+ li.append(li[0])",
"+count = 0",
"+for i in range(1, len(li)):",
"+ for j in li[i - 1]:",
"+ for k in li[i]:",
"+ count += 1",
"+print(count)",
"+for i in range(1, len(li)):",
"+ for j in li[i - 1]:",
"+ for k in li[i]:",
"+ print((j, k))"
] | false | 0.161967 | 0.037614 | 4.306075 | [
"s950962235",
"s141203982"
] |
u137228327 | p03408 | python | s817429069 | s844767372 | 31 | 28 | 9,404 | 9,196 | Accepted | Accepted | 9.68 | from collections import Counter
N = int(eval(input()))
s =[str(eval(input())) for _ in range(N)]
M = int(eval(input()))
t =[str(eval(input())) for _ in range(M)]
#print(Counter(s))
cs = Counter(s)
ct = Counter(t)
for i in cs:
#print(i,cs[i])
for j in ct:
#print(j,ct[j])
if i == j:
cs[i]=cs[i]-ct[j]
#print(cs)
print((max(0,cs.most_common(1)[0][1])))
| N = int(eval(input()))
s =[str(eval(input())) for _ in range(N)]
M = int(eval(input()))
t =[str(eval(input())) for _ in range(M)]
l = list(set(s))
mx = max(s.count(l[i])-t.count(l[i]) for i in range(len(l)))
print((max(0,mx))) | 19 | 10 | 397 | 213 | from collections import Counter
N = int(eval(input()))
s = [str(eval(input())) for _ in range(N)]
M = int(eval(input()))
t = [str(eval(input())) for _ in range(M)]
# print(Counter(s))
cs = Counter(s)
ct = Counter(t)
for i in cs:
# print(i,cs[i])
for j in ct:
# print(j,ct[j])
if i == j:
cs[i] = cs[i] - ct[j]
# print(cs)
print((max(0, cs.most_common(1)[0][1])))
| N = int(eval(input()))
s = [str(eval(input())) for _ in range(N)]
M = int(eval(input()))
t = [str(eval(input())) for _ in range(M)]
l = list(set(s))
mx = max(s.count(l[i]) - t.count(l[i]) for i in range(len(l)))
print((max(0, mx)))
| false | 47.368421 | [
"-from collections import Counter",
"-",
"-# print(Counter(s))",
"-cs = Counter(s)",
"-ct = Counter(t)",
"-for i in cs:",
"- # print(i,cs[i])",
"- for j in ct:",
"- # print(j,ct[j])",
"- if i == j:",
"- cs[i] = cs[i] - ct[j]",
"-# print(cs)",
"-print((max(0, cs.most_common(1)[0][1])))",
"+l = list(set(s))",
"+mx = max(s.count(l[i]) - t.count(l[i]) for i in range(len(l)))",
"+print((max(0, mx)))"
] | false | 0.116566 | 0.167379 | 0.696421 | [
"s817429069",
"s844767372"
] |
u506858457 | p04044 | python | s846627606 | s655592652 | 19 | 17 | 3,060 | 3,060 | Accepted | Accepted | 10.53 | N,L=list(map(int,input().split()))
S=[eval(input()) for i in range(N)]
#print(S)
S.sort()
ans=''.join(S)
print(ans) | n,l=map(int,input().split())
s=sorted([input() for i in range(n)])
#print(s)
print(*s,sep="")
| 6 | 4 | 108 | 96 | N, L = list(map(int, input().split()))
S = [eval(input()) for i in range(N)]
# print(S)
S.sort()
ans = "".join(S)
print(ans)
| n, l = map(int, input().split())
s = sorted([input() for i in range(n)])
# print(s)
print(*s, sep="")
| false | 33.333333 | [
"-N, L = list(map(int, input().split()))",
"-S = [eval(input()) for i in range(N)]",
"-# print(S)",
"-S.sort()",
"-ans = \"\".join(S)",
"-print(ans)",
"+n, l = map(int, input().split())",
"+s = sorted([input() for i in range(n)])",
"+# print(s)",
"+print(*s, sep=\"\")"
] | false | 0.141964 | 0.048952 | 2.900036 | [
"s846627606",
"s655592652"
] |
u475503988 | p02801 | python | s576012734 | s903445651 | 19 | 17 | 2,940 | 2,940 | Accepted | Accepted | 10.53 | C = eval(input())
ans = chr(ord(C)+1)
print(ans)
| c = eval(input())
print((chr(ord(c)+1)))
| 3 | 2 | 45 | 34 | C = eval(input())
ans = chr(ord(C) + 1)
print(ans)
| c = eval(input())
print((chr(ord(c) + 1)))
| false | 33.333333 | [
"-C = eval(input())",
"-ans = chr(ord(C) + 1)",
"-print(ans)",
"+c = eval(input())",
"+print((chr(ord(c) + 1)))"
] | false | 0.048048 | 0.05202 | 0.923635 | [
"s576012734",
"s903445651"
] |
u254871849 | p03546 | python | s222962331 | s164613722 | 416 | 179 | 27,752 | 17,744 | Accepted | Accepted | 56.97 | import sys
import numpy as np
from scipy.sparse import csr_matrix
from scipy.sparse.csgraph import floyd_warshall
def main():
H, W = list(map(int, sys.stdin.readline().split()))
cost = np.array([sys.stdin.readline().split() for _ in range(10)], dtype=np.int64)
A = np.array(sys.stdin.read().split(), dtype=np.int64)
graph = csr_matrix(cost)
dist = floyd_warshall(csgraph=graph, directed=True)
ans = dist[np.absolute(A)].T[1].astype(np.int64).sum()
print(ans)
if __name__ == "__main__":
main()
| import sys
import numpy as np
from scipy.sparse import csr_matrix
from scipy.sparse.csgraph import floyd_warshall
def main():
H, W = list(map(int, sys.stdin.readline().split()))
ca = np.array(sys.stdin.read().split(), dtype=np.int64)
cost = ca[:100].reshape(10, 10)
A = ca[100:]
min_cost = floyd_warshall(csgraph=csr_matrix(cost), directed=True)
total_cost = min_cost[np.absolute(A)].T[1].astype(np.int64).sum()
print(total_cost)
if __name__ == "__main__":
main()
| 18 | 18 | 544 | 515 | import sys
import numpy as np
from scipy.sparse import csr_matrix
from scipy.sparse.csgraph import floyd_warshall
def main():
H, W = list(map(int, sys.stdin.readline().split()))
cost = np.array([sys.stdin.readline().split() for _ in range(10)], dtype=np.int64)
A = np.array(sys.stdin.read().split(), dtype=np.int64)
graph = csr_matrix(cost)
dist = floyd_warshall(csgraph=graph, directed=True)
ans = dist[np.absolute(A)].T[1].astype(np.int64).sum()
print(ans)
if __name__ == "__main__":
main()
| import sys
import numpy as np
from scipy.sparse import csr_matrix
from scipy.sparse.csgraph import floyd_warshall
def main():
H, W = list(map(int, sys.stdin.readline().split()))
ca = np.array(sys.stdin.read().split(), dtype=np.int64)
cost = ca[:100].reshape(10, 10)
A = ca[100:]
min_cost = floyd_warshall(csgraph=csr_matrix(cost), directed=True)
total_cost = min_cost[np.absolute(A)].T[1].astype(np.int64).sum()
print(total_cost)
if __name__ == "__main__":
main()
| false | 0 | [
"- cost = np.array([sys.stdin.readline().split() for _ in range(10)], dtype=np.int64)",
"- A = np.array(sys.stdin.read().split(), dtype=np.int64)",
"- graph = csr_matrix(cost)",
"- dist = floyd_warshall(csgraph=graph, directed=True)",
"- ans = dist[np.absolute(A)].T[1].astype(np.int64).sum()",
"- print(ans)",
"+ ca = np.array(sys.stdin.read().split(), dtype=np.int64)",
"+ cost = ca[:100].reshape(10, 10)",
"+ A = ca[100:]",
"+ min_cost = floyd_warshall(csgraph=csr_matrix(cost), directed=True)",
"+ total_cost = min_cost[np.absolute(A)].T[1].astype(np.int64).sum()",
"+ print(total_cost)"
] | false | 0.300783 | 0.302969 | 0.992788 | [
"s222962331",
"s164613722"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.