user_id
stringlengths 10
10
| problem_id
stringlengths 6
6
| language
stringclasses 1
value | submission_id_v0
stringlengths 10
10
| submission_id_v1
stringlengths 10
10
| cpu_time_v0
int64 10
38.3k
| cpu_time_v1
int64 0
24.7k
| memory_v0
int64 2.57k
1.02M
| memory_v1
int64 2.57k
869k
| status_v0
stringclasses 1
value | status_v1
stringclasses 1
value | improvement_frac
float64 7.51
100
| input
stringlengths 20
4.55k
| target
stringlengths 17
3.34k
| code_v0_loc
int64 1
148
| code_v1_loc
int64 1
184
| code_v0_num_chars
int64 13
4.55k
| code_v1_num_chars
int64 14
3.34k
| code_v0_no_empty_lines
stringlengths 21
6.88k
| code_v1_no_empty_lines
stringlengths 20
4.93k
| code_same
bool 1
class | relative_loc_diff_percent
float64 0
79.8
| diff
list | diff_only_import_comment
bool 1
class | measured_runtime_v0
float64 0.01
4.45
| measured_runtime_v1
float64 0.01
4.31
| runtime_lift
float64 0
359
| key
list |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
u380524497 | p02774 | python | s954016242 | s983396974 | 1,117 | 715 | 34,580 | 112,900 | Accepted | Accepted | 35.99 | import numpy as np
n, k = list(map(int, input().split()))
A = np.array(input().split(), np.int64)
A.sort()
posA = A[A > 0]
negA = A[A < 0]
zeros = (A==0).sum()
left = -10**18
right = 10**18
while left+1 < right:
num = (left+right)//2
less_count = 0
if num >= 0:
less_count += zeros * n
limit_pair_for_pos = num // posA
limit_idxs = np.searchsorted(A, limit_pair_for_pos, side='right')
less_count += limit_idxs.sum()
limit_pair_for_neg = -(num // -negA)
limit_idxs = n - np.searchsorted(A, limit_pair_for_neg, side='left')
less_count += limit_idxs.sum()
duplicate_cases = (A**2 <= num).sum()
less_count -= duplicate_cases
less_count //= 2
if less_count >= k:
right = num
else:
left = num
print(right) | n, k = list(map(int, input().split()))
A = list(map(int, input().split()))
pos = []
neg = []
zeros = 0
for a in A:
if a > 0:
pos.append(a)
elif a < 0:
neg.append(a)
else:
zeros += 1
pos.sort()
neg.sort(reverse=True)
minus_pattern = len(pos) * len(neg)
zero_pattern = zeros * (len(pos)+len(neg)) + (zeros*(zeros-1))//2
pos_length = len(pos)
neg_length = len(neg)
left = -10**18
right = 10**18
while left + 1 < right:
num = (left+right)//2
less_count = 0
if num >= 0:
pos_idx = pos_length-1
for p in pos:
while pos_idx >= 0 and p * pos[pos_idx] > num:
pos_idx -= 1
less_count += pos_idx + 1
if p**2 <= num:
less_count -= 1
neg_idx = neg_length-1
for m in neg:
while neg_idx >= 0 and m * neg[neg_idx] > num:
neg_idx -= 1
less_count += neg_idx + 1
if m**2 <= num:
less_count -= 1
less_count //= 2
less_count += minus_pattern + zero_pattern
elif num < 0:
pos_idx = 0
for m in neg[::-1]:
while pos_idx < pos_length and m * pos[pos_idx] > num:
pos_idx += 1
less_count += pos_length - pos_idx
if less_count >= k:
right = num
else:
left = num
print(right) | 41 | 62 | 842 | 1,428 | import numpy as np
n, k = list(map(int, input().split()))
A = np.array(input().split(), np.int64)
A.sort()
posA = A[A > 0]
negA = A[A < 0]
zeros = (A == 0).sum()
left = -(10**18)
right = 10**18
while left + 1 < right:
num = (left + right) // 2
less_count = 0
if num >= 0:
less_count += zeros * n
limit_pair_for_pos = num // posA
limit_idxs = np.searchsorted(A, limit_pair_for_pos, side="right")
less_count += limit_idxs.sum()
limit_pair_for_neg = -(num // -negA)
limit_idxs = n - np.searchsorted(A, limit_pair_for_neg, side="left")
less_count += limit_idxs.sum()
duplicate_cases = (A**2 <= num).sum()
less_count -= duplicate_cases
less_count //= 2
if less_count >= k:
right = num
else:
left = num
print(right)
| n, k = list(map(int, input().split()))
A = list(map(int, input().split()))
pos = []
neg = []
zeros = 0
for a in A:
if a > 0:
pos.append(a)
elif a < 0:
neg.append(a)
else:
zeros += 1
pos.sort()
neg.sort(reverse=True)
minus_pattern = len(pos) * len(neg)
zero_pattern = zeros * (len(pos) + len(neg)) + (zeros * (zeros - 1)) // 2
pos_length = len(pos)
neg_length = len(neg)
left = -(10**18)
right = 10**18
while left + 1 < right:
num = (left + right) // 2
less_count = 0
if num >= 0:
pos_idx = pos_length - 1
for p in pos:
while pos_idx >= 0 and p * pos[pos_idx] > num:
pos_idx -= 1
less_count += pos_idx + 1
if p**2 <= num:
less_count -= 1
neg_idx = neg_length - 1
for m in neg:
while neg_idx >= 0 and m * neg[neg_idx] > num:
neg_idx -= 1
less_count += neg_idx + 1
if m**2 <= num:
less_count -= 1
less_count //= 2
less_count += minus_pattern + zero_pattern
elif num < 0:
pos_idx = 0
for m in neg[::-1]:
while pos_idx < pos_length and m * pos[pos_idx] > num:
pos_idx += 1
less_count += pos_length - pos_idx
if less_count >= k:
right = num
else:
left = num
print(right)
| false | 33.870968 | [
"-import numpy as np",
"-",
"-A = np.array(input().split(), np.int64)",
"-A.sort()",
"-posA = A[A > 0]",
"-negA = A[A < 0]",
"-zeros = (A == 0).sum()",
"+A = list(map(int, input().split()))",
"+pos = []",
"+neg = []",
"+zeros = 0",
"+for a in A:",
"+ if a > 0:",
"+ pos.append(a)",
"+ elif a < 0:",
"+ neg.append(a)",
"+ else:",
"+ zeros += 1",
"+pos.sort()",
"+neg.sort(reverse=True)",
"+minus_pattern = len(pos) * len(neg)",
"+zero_pattern = zeros * (len(pos) + len(neg)) + (zeros * (zeros - 1)) // 2",
"+pos_length = len(pos)",
"+neg_length = len(neg)",
"- less_count += zeros * n",
"- limit_pair_for_pos = num // posA",
"- limit_idxs = np.searchsorted(A, limit_pair_for_pos, side=\"right\")",
"- less_count += limit_idxs.sum()",
"- limit_pair_for_neg = -(num // -negA)",
"- limit_idxs = n - np.searchsorted(A, limit_pair_for_neg, side=\"left\")",
"- less_count += limit_idxs.sum()",
"- duplicate_cases = (A**2 <= num).sum()",
"- less_count -= duplicate_cases",
"- less_count //= 2",
"+ pos_idx = pos_length - 1",
"+ for p in pos:",
"+ while pos_idx >= 0 and p * pos[pos_idx] > num:",
"+ pos_idx -= 1",
"+ less_count += pos_idx + 1",
"+ if p**2 <= num:",
"+ less_count -= 1",
"+ neg_idx = neg_length - 1",
"+ for m in neg:",
"+ while neg_idx >= 0 and m * neg[neg_idx] > num:",
"+ neg_idx -= 1",
"+ less_count += neg_idx + 1",
"+ if m**2 <= num:",
"+ less_count -= 1",
"+ less_count //= 2",
"+ less_count += minus_pattern + zero_pattern",
"+ elif num < 0:",
"+ pos_idx = 0",
"+ for m in neg[::-1]:",
"+ while pos_idx < pos_length and m * pos[pos_idx] > num:",
"+ pos_idx += 1",
"+ less_count += pos_length - pos_idx"
] | false | 0.225771 | 0.047109 | 4.792565 | [
"s954016242",
"s983396974"
] |
u423966555 | p03341 | python | s403491867 | s628984591 | 255 | 217 | 21,124 | 32,896 | Accepted | Accepted | 14.9 | N = int(eval(input()))
S = eval(input())
cnt_W = [0]*N #่ฅฟใๅใใฆใใไบบใฎ็ดฏ็ฉๅใๆฑใใ
if S[0] == 'W':
cnt_W[0] = 1
for i in range(1, N):
if S[i]=="W":
cnt_W[i] += cnt_W[i-1] + 1
else:
cnt_W[i] = cnt_W[i-1]
most_E = cnt_W[-1] #ๅ
จไฝใง่ฅฟใๅใใฆใใไบบๆฐ
#print(most_E)
ans = float('inf')
for i in range(N):
tmp = 0
if i == 0:
if S[i] == "W":
tmp = (N-most_E)
else:
tmp = (N-most_E)-1
#print(tmp)
elif i == N-1:
if S[i] == "W":
tmp = most_E-1
else:
tmp = most_E
#print(tmp)
else:
tmp = cnt_W[i-1] + (N-most_E) - (i+1-cnt_W[i])
#print(tmp)
ans = min(ans, tmp)
print(ans)
| N = int(eval(input()))
S = eval(input())
cnt_W = [0]*N #่ฅฟใๅใใฆใใไบบใฎ็ดฏ็ฉๅใๆฑใใ
if S[0] == 'W':
cnt_W[0] = 1
for i in range(1, N):
if S[i]=="W":
cnt_W[i] += cnt_W[i-1] + 1
else:
cnt_W[i] = cnt_W[i-1]
most_E = cnt_W[-1] #ๅ
จไฝใง่ฅฟใๅใใฆใใไบบๆฐ
ans = []
for i in range(N):
if i == 0:
if S[i] == "W":
ans.append(N-most_E)
else:
ans.append((N-most_E)-1)
elif i == N-1:
if S[i] == "W":
ans.append(most_E-1)
else:
ans.append(most_E)
else:
ans.append(cnt_W[i-1] + (N-most_E) - (i+1-cnt_W[i]))
print((min(ans)))
| 36 | 30 | 728 | 634 | N = int(eval(input()))
S = eval(input())
cnt_W = [0] * N # ่ฅฟใๅใใฆใใไบบใฎ็ดฏ็ฉๅใๆฑใใ
if S[0] == "W":
cnt_W[0] = 1
for i in range(1, N):
if S[i] == "W":
cnt_W[i] += cnt_W[i - 1] + 1
else:
cnt_W[i] = cnt_W[i - 1]
most_E = cnt_W[-1] # ๅ
จไฝใง่ฅฟใๅใใฆใใไบบๆฐ
# print(most_E)
ans = float("inf")
for i in range(N):
tmp = 0
if i == 0:
if S[i] == "W":
tmp = N - most_E
else:
tmp = (N - most_E) - 1
# print(tmp)
elif i == N - 1:
if S[i] == "W":
tmp = most_E - 1
else:
tmp = most_E
# print(tmp)
else:
tmp = cnt_W[i - 1] + (N - most_E) - (i + 1 - cnt_W[i])
# print(tmp)
ans = min(ans, tmp)
print(ans)
| N = int(eval(input()))
S = eval(input())
cnt_W = [0] * N # ่ฅฟใๅใใฆใใไบบใฎ็ดฏ็ฉๅใๆฑใใ
if S[0] == "W":
cnt_W[0] = 1
for i in range(1, N):
if S[i] == "W":
cnt_W[i] += cnt_W[i - 1] + 1
else:
cnt_W[i] = cnt_W[i - 1]
most_E = cnt_W[-1] # ๅ
จไฝใง่ฅฟใๅใใฆใใไบบๆฐ
ans = []
for i in range(N):
if i == 0:
if S[i] == "W":
ans.append(N - most_E)
else:
ans.append((N - most_E) - 1)
elif i == N - 1:
if S[i] == "W":
ans.append(most_E - 1)
else:
ans.append(most_E)
else:
ans.append(cnt_W[i - 1] + (N - most_E) - (i + 1 - cnt_W[i]))
print((min(ans)))
| false | 16.666667 | [
"-# print(most_E)",
"-ans = float(\"inf\")",
"+ans = []",
"- tmp = 0",
"- tmp = N - most_E",
"+ ans.append(N - most_E)",
"- tmp = (N - most_E) - 1",
"- # print(tmp)",
"+ ans.append((N - most_E) - 1)",
"- tmp = most_E - 1",
"+ ans.append(most_E - 1)",
"- tmp = most_E",
"- # print(tmp)",
"+ ans.append(most_E)",
"- tmp = cnt_W[i - 1] + (N - most_E) - (i + 1 - cnt_W[i])",
"- # print(tmp)",
"- ans = min(ans, tmp)",
"-print(ans)",
"+ ans.append(cnt_W[i - 1] + (N - most_E) - (i + 1 - cnt_W[i]))",
"+print((min(ans)))"
] | false | 0.07056 | 0.065089 | 1.084053 | [
"s403491867",
"s628984591"
] |
u562935282 | p03291 | python | s141249975 | s303784184 | 593 | 518 | 27,616 | 27,532 | Accepted | Accepted | 12.65 | s = eval(input())
ls = len(s)
dp = [[0 for _ in range(4)] for _ in range(ls+1)]
dp[0][0] = 1
mod = 10 ** 9 + 7
for i in range(1, ls+1):
for j in range(4):
#'?'ใฎใจใ'ABC'ใฎ3้ใใซๅๅฒใใใใใใใๅใใชใใฎใง3ๅ
dp[i][j] += dp[i-1][j] * (3 if s[i-1] == '?' else 1)
if j > 0:
#ใปใใๆๅญใซๅคใใๅ ดๅใใพใใฏใใปใใๆๅญใฎๅ ดๅใงๅใฃใใจใ
dp[i][j] += dp[i-1][j-1] if s[i-1] == 'ABC'[j-1] or s[i-1] == '?' else 0
dp[i][j] %= mod
print((dp[ls][3])) | def ary(r, c, v): return [[v for _ in range(c)] for _ in range(r)]
s = eval(input())
ls = len(s)
dp = ary(ls + 1, 4, 0)
dp[0][0] = 1
mod = 10 ** 9 + 7
for i in range(1, ls + 1):
for j in range(4):
#'?'ใฎใจใ'ABC'ใฎ3้ใใซๅๅฒใใใใใใใๅใใชใใฎใง3ๅ
dp[i][j] += dp[i - 1][j] * (3 if s[i - 1] == '?' else 1)
#ใปใใๆๅญใซๅคใใๅ ดๅใใพใใฏใใปใใๆๅญใฎๅ ดๅใงๅใฃใใจใ
if j > 0:
if s[i - 1] == '?' or s[i - 1] == 'ABC'[j - 1]:
dp[i][j] += dp[i - 1][j - 1]
dp[i][j] %= mod
print((dp[ls][3])) | 15 | 19 | 459 | 526 | s = eval(input())
ls = len(s)
dp = [[0 for _ in range(4)] for _ in range(ls + 1)]
dp[0][0] = 1
mod = 10**9 + 7
for i in range(1, ls + 1):
for j in range(4):
#'?'ใฎใจใ'ABC'ใฎ3้ใใซๅๅฒใใใใใใใๅใใชใใฎใง3ๅ
dp[i][j] += dp[i - 1][j] * (3 if s[i - 1] == "?" else 1)
if j > 0:
# ใปใใๆๅญใซๅคใใๅ ดๅใใพใใฏใใปใใๆๅญใฎๅ ดๅใงๅใฃใใจใ
dp[i][j] += (
dp[i - 1][j - 1] if s[i - 1] == "ABC"[j - 1] or s[i - 1] == "?" else 0
)
dp[i][j] %= mod
print((dp[ls][3]))
| def ary(r, c, v):
return [[v for _ in range(c)] for _ in range(r)]
s = eval(input())
ls = len(s)
dp = ary(ls + 1, 4, 0)
dp[0][0] = 1
mod = 10**9 + 7
for i in range(1, ls + 1):
for j in range(4):
#'?'ใฎใจใ'ABC'ใฎ3้ใใซๅๅฒใใใใใใใๅใใชใใฎใง3ๅ
dp[i][j] += dp[i - 1][j] * (3 if s[i - 1] == "?" else 1)
# ใปใใๆๅญใซๅคใใๅ ดๅใใพใใฏใใปใใๆๅญใฎๅ ดๅใงๅใฃใใจใ
if j > 0:
if s[i - 1] == "?" or s[i - 1] == "ABC"[j - 1]:
dp[i][j] += dp[i - 1][j - 1]
dp[i][j] %= mod
print((dp[ls][3]))
| false | 21.052632 | [
"+def ary(r, c, v):",
"+ return [[v for _ in range(c)] for _ in range(r)]",
"+",
"+",
"-dp = [[0 for _ in range(4)] for _ in range(ls + 1)]",
"+dp = ary(ls + 1, 4, 0)",
"+ # ใปใใๆๅญใซๅคใใๅ ดๅใใพใใฏใใปใใๆๅญใฎๅ ดๅใงๅใฃใใจใ",
"- # ใปใใๆๅญใซๅคใใๅ ดๅใใพใใฏใใปใใๆๅญใฎๅ ดๅใงๅใฃใใจใ",
"- dp[i][j] += (",
"- dp[i - 1][j - 1] if s[i - 1] == \"ABC\"[j - 1] or s[i - 1] == \"?\" else 0",
"- )",
"+ if s[i - 1] == \"?\" or s[i - 1] == \"ABC\"[j - 1]:",
"+ dp[i][j] += dp[i - 1][j - 1]"
] | false | 0.045759 | 0.046273 | 0.988888 | [
"s141249975",
"s303784184"
] |
u333596716 | p02392 | python | s565328144 | s007888739 | 30 | 20 | 7,656 | 7,588 | Accepted | Accepted | 33.33 | a,b,c=list(map(int,input().split()))
if a < b and b < c:
print("Yes")
else:
print("No") | a,b,c=list(map(int,input().split()))
if a < b < c:
print("Yes")
else:
print("No") | 5 | 5 | 93 | 87 | a, b, c = list(map(int, input().split()))
if a < b and b < c:
print("Yes")
else:
print("No")
| a, b, c = list(map(int, input().split()))
if a < b < c:
print("Yes")
else:
print("No")
| false | 0 | [
"-if a < b and b < c:",
"+if a < b < c:"
] | false | 0.03898 | 0.078323 | 0.497682 | [
"s565328144",
"s007888739"
] |
u562016607 | p03546 | python | s030572725 | s537506172 | 48 | 37 | 3,444 | 3,444 | Accepted | Accepted | 22.92 | import math
st=input().split()
H=int(st[0]);W=int(st[1])
c=[[0 for i in range(10)] for i in range(10)]
A=[[0 for i in range(W)]for i in range(H)]
for i in range(10):
st=input().split()
for j in range(10):
c[i][j]=int(st[j])
for i in range(H):
st=input().split()
for j in range(W):
A[i][j]=int(st[j])
def Dijkstra(s):
d=[10000]*10
d[s]=0
Q=set(range(10))
V=set(range(10))
while(len(Q)>0):
u=list(Q)[0]
for i in Q:
if d[i]<d[u]:
u=i
Q-={u}
for v in V-{u}:
if (d[v]>d[u]+c[u][v]):
d[v]=d[u]+c[u][v]
return d[1]
result=0
DD=[0]*10
for i in range(10):
DD[i]=Dijkstra(i)
for i in range(H):
for j in range(W):
if A[i][j]!=-1:
result+=DD[A[i][j]]
print(result)
| H,W=list(map(int,input().split()))
c=[list(map(int,input().split())) for i in range(10)]
A=[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):
if c[i][j]>c[i][k]+c[k][j]:
c[i][j]=c[i][k]+c[k][j]
ans=0
for i in range(H):
for j in range(W):
if A[i][j]!=-1:
ans+=c[A[i][j]][1]
print(ans)
| 37 | 14 | 861 | 383 | import math
st = input().split()
H = int(st[0])
W = int(st[1])
c = [[0 for i in range(10)] for i in range(10)]
A = [[0 for i in range(W)] for i in range(H)]
for i in range(10):
st = input().split()
for j in range(10):
c[i][j] = int(st[j])
for i in range(H):
st = input().split()
for j in range(W):
A[i][j] = int(st[j])
def Dijkstra(s):
d = [10000] * 10
d[s] = 0
Q = set(range(10))
V = set(range(10))
while len(Q) > 0:
u = list(Q)[0]
for i in Q:
if d[i] < d[u]:
u = i
Q -= {u}
for v in V - {u}:
if d[v] > d[u] + c[u][v]:
d[v] = d[u] + c[u][v]
return d[1]
result = 0
DD = [0] * 10
for i in range(10):
DD[i] = Dijkstra(i)
for i in range(H):
for j in range(W):
if A[i][j] != -1:
result += DD[A[i][j]]
print(result)
| H, W = list(map(int, input().split()))
c = [list(map(int, input().split())) for i in range(10)]
A = [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):
if c[i][j] > c[i][k] + c[k][j]:
c[i][j] = c[i][k] + c[k][j]
ans = 0
for i in range(H):
for j in range(W):
if A[i][j] != -1:
ans += c[A[i][j]][1]
print(ans)
| false | 62.162162 | [
"-import math",
"-",
"-st = input().split()",
"-H = int(st[0])",
"-W = int(st[1])",
"-c = [[0 for i in range(10)] for i in range(10)]",
"-A = [[0 for i in range(W)] for i in range(H)]",
"-for i in range(10):",
"- st = input().split()",
"- for j in range(10):",
"- c[i][j] = int(st[j])",
"-for i in range(H):",
"- st = input().split()",
"- for j in range(W):",
"- A[i][j] = int(st[j])",
"-",
"-",
"-def Dijkstra(s):",
"- d = [10000] * 10",
"- d[s] = 0",
"- Q = set(range(10))",
"- V = set(range(10))",
"- while len(Q) > 0:",
"- u = list(Q)[0]",
"- for i in Q:",
"- if d[i] < d[u]:",
"- u = i",
"- Q -= {u}",
"- for v in V - {u}:",
"- if d[v] > d[u] + c[u][v]:",
"- d[v] = d[u] + c[u][v]",
"- return d[1]",
"-",
"-",
"-result = 0",
"-DD = [0] * 10",
"-for i in range(10):",
"- DD[i] = Dijkstra(i)",
"+H, W = list(map(int, input().split()))",
"+c = [list(map(int, input().split())) for i in range(10)]",
"+A = [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):",
"+ if c[i][j] > c[i][k] + c[k][j]:",
"+ c[i][j] = c[i][k] + c[k][j]",
"+ans = 0",
"- result += DD[A[i][j]]",
"-print(result)",
"+ ans += c[A[i][j]][1]",
"+print(ans)"
] | false | 0.12957 | 0.039996 | 3.2396 | [
"s030572725",
"s537506172"
] |
u024782094 | p03611 | python | s948549898 | s091731036 | 172 | 92 | 30,940 | 10,996 | Accepted | Accepted | 46.51 | from collections import Counter
n=int(eval(input()))
l=[]
a=list(map(int,input().split()))
for i in range(n):
l.append(a[i]-1)
l.append(a[i])
l.append(a[i]+1)
ans=Counter(l)
print((ans.most_common()[0][1])) | import sys
from collections import Counter
from collections import deque
def input(): return sys.stdin.readline().strip()
def mp(): return list(map(int,input().split()))
def lmp(): return list(map(int,input().split()))
n=int(eval(input()))
a=mp()
l=[0]*(10**5+10)
for x in a:
l[x]+=1
l[x-1]+=1
l[x+1]+=1
print((max(l))) | 10 | 14 | 213 | 330 | from collections import Counter
n = int(eval(input()))
l = []
a = list(map(int, input().split()))
for i in range(n):
l.append(a[i] - 1)
l.append(a[i])
l.append(a[i] + 1)
ans = Counter(l)
print((ans.most_common()[0][1]))
| import sys
from collections import Counter
from collections import deque
def input():
return sys.stdin.readline().strip()
def mp():
return list(map(int, input().split()))
def lmp():
return list(map(int, input().split()))
n = int(eval(input()))
a = mp()
l = [0] * (10**5 + 10)
for x in a:
l[x] += 1
l[x - 1] += 1
l[x + 1] += 1
print((max(l)))
| false | 28.571429 | [
"+import sys",
"+from collections import deque",
"+",
"+",
"+def input():",
"+ return sys.stdin.readline().strip()",
"+",
"+",
"+def mp():",
"+ return list(map(int, input().split()))",
"+",
"+",
"+def lmp():",
"+ return list(map(int, input().split()))",
"+",
"-l = []",
"-a = list(map(int, input().split()))",
"-for i in range(n):",
"- l.append(a[i] - 1)",
"- l.append(a[i])",
"- l.append(a[i] + 1)",
"-ans = Counter(l)",
"-print((ans.most_common()[0][1]))",
"+a = mp()",
"+l = [0] * (10**5 + 10)",
"+for x in a:",
"+ l[x] += 1",
"+ l[x - 1] += 1",
"+ l[x + 1] += 1",
"+print((max(l)))"
] | false | 0.040983 | 0.043733 | 0.937134 | [
"s948549898",
"s091731036"
] |
u576917603 | p02911 | python | s642824929 | s954025495 | 257 | 233 | 14,752 | 10,452 | Accepted | Accepted | 9.34 | n,k,q=list(map(int,input().split()))
a=[]
for i in range(q):
a.append(int(eval(input())))
import collections
c=collections.Counter(a)
c=list(c.items())
p=[0]*n
for i in c:
p[i[0]-1]=i[1]
line=1-(k-q)
for i in p:
if i>=line:
print('Yes')
else:
print('No') | n,k,q=list(map(int,input().split()))
a=[int(eval(input())) for i in range(q)]
score=[k-q]*n
for i in a:
score[i-1]+=1
for i in score:
if i>=1:
print('Yes')
else:
print('No') | 16 | 10 | 289 | 198 | n, k, q = list(map(int, input().split()))
a = []
for i in range(q):
a.append(int(eval(input())))
import collections
c = collections.Counter(a)
c = list(c.items())
p = [0] * n
for i in c:
p[i[0] - 1] = i[1]
line = 1 - (k - q)
for i in p:
if i >= line:
print("Yes")
else:
print("No")
| n, k, q = list(map(int, input().split()))
a = [int(eval(input())) for i in range(q)]
score = [k - q] * n
for i in a:
score[i - 1] += 1
for i in score:
if i >= 1:
print("Yes")
else:
print("No")
| false | 37.5 | [
"-a = []",
"-for i in range(q):",
"- a.append(int(eval(input())))",
"-import collections",
"-",
"-c = collections.Counter(a)",
"-c = list(c.items())",
"-p = [0] * n",
"-for i in c:",
"- p[i[0] - 1] = i[1]",
"-line = 1 - (k - q)",
"-for i in p:",
"- if i >= line:",
"+a = [int(eval(input())) for i in range(q)]",
"+score = [k - q] * n",
"+for i in a:",
"+ score[i - 1] += 1",
"+for i in score:",
"+ if i >= 1:"
] | false | 0.032858 | 0.048783 | 0.673559 | [
"s642824929",
"s954025495"
] |
u968166680 | p02850 | python | s325097647 | s212197961 | 299 | 266 | 99,860 | 53,320 | Accepted | Accepted | 11.04 | import sys
from collections import deque
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
N, *AB = list(map(int, read().split()))
G = [[] for _ in range(N)]
for i, (a, b) in enumerate(zip(*[iter(AB)] * 2)):
G[a - 1].append((i, b - 1))
G[b - 1].append((i, a - 1))
color = [0] * (N - 1)
def dfs(v, p, pc):
c = 1
for i, nv in G[v]:
if nv == p:
continue
if c == pc:
c += 1
color[i] = c
dfs(nv, v, c)
c += 1
dfs(0, -1, 0)
print((max(color)))
print(('\n'.join(map(str, color))))
return
if __name__ == '__main__':
main()
| import sys
from collections import deque
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
N, *AB = map(int, read().split())
G = [[] for _ in range(N)]
for i, (a, b) in enumerate(zip(*[iter(AB)] * 2)):
G[a - 1].append((i, b - 1))
G[b - 1].append((i, a - 1))
queue = deque([0])
color = [0] * (N - 1)
color_from_parent = [0] * N
color_from_parent[0] = -1
while queue:
v = queue.popleft()
c = 1
for i, nv in G[v]:
if color_from_parent[nv] != 0:
continue
if c == color_from_parent[v]:
c += 1
color_from_parent[nv] = c
color[i] = c
c += 1
queue.append(nv)
print(max(color))
print(*color, sep='\n')
return
if __name__ == '__main__':
main()
| 40 | 43 | 825 | 984 | import sys
from collections import deque
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10**9)
INF = 1 << 60
MOD = 1000000007
def main():
N, *AB = list(map(int, read().split()))
G = [[] for _ in range(N)]
for i, (a, b) in enumerate(zip(*[iter(AB)] * 2)):
G[a - 1].append((i, b - 1))
G[b - 1].append((i, a - 1))
color = [0] * (N - 1)
def dfs(v, p, pc):
c = 1
for i, nv in G[v]:
if nv == p:
continue
if c == pc:
c += 1
color[i] = c
dfs(nv, v, c)
c += 1
dfs(0, -1, 0)
print((max(color)))
print(("\n".join(map(str, color))))
return
if __name__ == "__main__":
main()
| import sys
from collections import deque
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10**9)
INF = 1 << 60
MOD = 1000000007
def main():
N, *AB = map(int, read().split())
G = [[] for _ in range(N)]
for i, (a, b) in enumerate(zip(*[iter(AB)] * 2)):
G[a - 1].append((i, b - 1))
G[b - 1].append((i, a - 1))
queue = deque([0])
color = [0] * (N - 1)
color_from_parent = [0] * N
color_from_parent[0] = -1
while queue:
v = queue.popleft()
c = 1
for i, nv in G[v]:
if color_from_parent[nv] != 0:
continue
if c == color_from_parent[v]:
c += 1
color_from_parent[nv] = c
color[i] = c
c += 1
queue.append(nv)
print(max(color))
print(*color, sep="\n")
return
if __name__ == "__main__":
main()
| false | 6.976744 | [
"- N, *AB = list(map(int, read().split()))",
"+ N, *AB = map(int, read().split())",
"+ queue = deque([0])",
"-",
"- def dfs(v, p, pc):",
"+ color_from_parent = [0] * N",
"+ color_from_parent[0] = -1",
"+ while queue:",
"+ v = queue.popleft()",
"- if nv == p:",
"+ if color_from_parent[nv] != 0:",
"- if c == pc:",
"+ if c == color_from_parent[v]:",
"+ color_from_parent[nv] = c",
"- dfs(nv, v, c)",
"-",
"- dfs(0, -1, 0)",
"- print((max(color)))",
"- print((\"\\n\".join(map(str, color))))",
"+ queue.append(nv)",
"+ print(max(color))",
"+ print(*color, sep=\"\\n\")"
] | false | 0.076149 | 0.089093 | 0.854711 | [
"s325097647",
"s212197961"
] |
u707124227 | p03722 | python | s797352281 | s093946450 | 1,307 | 170 | 3,828 | 75,416 | Accepted | Accepted | 86.99 | n,m=list(map(int,input().split()))
#g=[[]for _ in range(n)]
abc=[list(map(int,input().split())) for _ in range(m)]
abc=[[a-1,b-1,-c] for a,b,c in abc]
# BellmanFord
# ใใซใใณใใฉใผใๆณ
def BellmanFord(edges,num_v,source):
#ใฐใฉใใฎๅๆๅ
inf=float("inf")
dist=[inf for i in range(num_v)]
dist[source]=0
#่พบใฎ็ทฉๅ
for i in range(num_v):
for edge in edges:
if dist[edge[0]] != inf and dist[edge[1]] > dist[edge[0]] + edge[2]:
dist[edge[1]] = dist[edge[0]] + edge[2]
#if i==num_v-1: return -1
negative=[False]*n
for i in range(num_v):
for edge in edges:
if negative[edge[0]]:negative[edge[1]]=True
if dist[edge[0]] != inf and dist[edge[1]] > dist[edge[0]] + edge[2]:
negative[edge[1]] = True
return dist[n-1],negative[n-1]
c,d=BellmanFord(abc,n,0)
# ่ฒ ใฎ้่ทฏใซNใๅซใพใใชใๆใฏinfใใใชใ
if d:
print('inf')
else:
print((-c)) | n,m=list(map(int,input().split()))
g=[[] for _ in range(n)]
abc=[list(map(int,input().split())) for _ in range(m)]
abc=[[a-1,b-1,-c] for a,b,c in abc]
# https://img.atcoder.jp/abc061/editorial.pdf
# ไธใฎDๅ้ก
# BellmanFord
# ใใซใใณใใฉใผใๆณ
# edges:ใจใใธใๆๅใจใใธ[a,b,c]a->bใฎใจใใธใงใณในใc
# num_v:้ ็นใฎๆฐ
# source:ๅง็น
def BellmanFord(edges,num_v,source):
#ใฐใฉใใฎๅๆๅ
inf=float("inf")
dist=[inf for i in range(num_v)]
dist[source]=0
#่พบใฎ็ทฉๅใnum_v-1ๅ็นฐใ่ฟใใnum_vๅ็ฎใซ่พบใฎ็ทฉๅใใใใฐใใใฏ้่ทฏใ-1ใ่ฟใใ
for i in range(num_v-1):
for edge in edges:
if dist[edge[0]] != inf and dist[edge[1]] > dist[edge[0]] + edge[2]:
dist[edge[1]] = dist[edge[0]] + edge[2]
if i==num_v-1: return -1
#้่ทฏใซๅซใพใใ้ ็นใๆขใใ
negative=[False]*n
for i in range(num_v):
for edge in edges:
if negative[edge[0]]:negative[edge[1]]=True
if dist[edge[0]] != inf and dist[edge[1]] > dist[edge[0]] + edge[2]:
negative[edge[1]] = True
return dist[n-1],negative[n-1]
ans,nega=BellmanFord(abc,n,0)
if nega:
print('inf')
else:
print((-ans))
| 30 | 37 | 881 | 1,054 | n, m = list(map(int, input().split()))
# g=[[]for _ in range(n)]
abc = [list(map(int, input().split())) for _ in range(m)]
abc = [[a - 1, b - 1, -c] for a, b, c in abc]
# BellmanFord
# ใใซใใณใใฉใผใๆณ
def BellmanFord(edges, num_v, source):
# ใฐใฉใใฎๅๆๅ
inf = float("inf")
dist = [inf for i in range(num_v)]
dist[source] = 0
# ่พบใฎ็ทฉๅ
for i in range(num_v):
for edge in edges:
if dist[edge[0]] != inf and dist[edge[1]] > dist[edge[0]] + edge[2]:
dist[edge[1]] = dist[edge[0]] + edge[2]
# if i==num_v-1: return -1
negative = [False] * n
for i in range(num_v):
for edge in edges:
if negative[edge[0]]:
negative[edge[1]] = True
if dist[edge[0]] != inf and dist[edge[1]] > dist[edge[0]] + edge[2]:
negative[edge[1]] = True
return dist[n - 1], negative[n - 1]
c, d = BellmanFord(abc, n, 0)
# ่ฒ ใฎ้่ทฏใซNใๅซใพใใชใๆใฏinfใใใชใ
if d:
print("inf")
else:
print((-c))
| n, m = list(map(int, input().split()))
g = [[] for _ in range(n)]
abc = [list(map(int, input().split())) for _ in range(m)]
abc = [[a - 1, b - 1, -c] for a, b, c in abc]
# https://img.atcoder.jp/abc061/editorial.pdf
# ไธใฎDๅ้ก
# BellmanFord
# ใใซใใณใใฉใผใๆณ
# edges:ใจใใธใๆๅใจใใธ[a,b,c]a->bใฎใจใใธใงใณในใc
# num_v:้ ็นใฎๆฐ
# source:ๅง็น
def BellmanFord(edges, num_v, source):
# ใฐใฉใใฎๅๆๅ
inf = float("inf")
dist = [inf for i in range(num_v)]
dist[source] = 0
# ่พบใฎ็ทฉๅใnum_v-1ๅ็นฐใ่ฟใใnum_vๅ็ฎใซ่พบใฎ็ทฉๅใใใใฐใใใฏ้่ทฏใ-1ใ่ฟใใ
for i in range(num_v - 1):
for edge in edges:
if dist[edge[0]] != inf and dist[edge[1]] > dist[edge[0]] + edge[2]:
dist[edge[1]] = dist[edge[0]] + edge[2]
if i == num_v - 1:
return -1
# ้่ทฏใซๅซใพใใ้ ็นใๆขใใ
negative = [False] * n
for i in range(num_v):
for edge in edges:
if negative[edge[0]]:
negative[edge[1]] = True
if dist[edge[0]] != inf and dist[edge[1]] > dist[edge[0]] + edge[2]:
negative[edge[1]] = True
return dist[n - 1], negative[n - 1]
ans, nega = BellmanFord(abc, n, 0)
if nega:
print("inf")
else:
print((-ans))
| false | 18.918919 | [
"-# g=[[]for _ in range(n)]",
"+g = [[] for _ in range(n)]",
"+# https://img.atcoder.jp/abc061/editorial.pdf",
"+# ไธใฎDๅ้ก",
"+# edges:ใจใใธใๆๅใจใใธ[a,b,c]a->bใฎใจใใธใงใณในใc",
"+# num_v:้ ็นใฎๆฐ",
"+# source:ๅง็น",
"- # ่พบใฎ็ทฉๅ",
"- for i in range(num_v):",
"+ # ่พบใฎ็ทฉๅใnum_v-1ๅ็นฐใ่ฟใใnum_vๅ็ฎใซ่พบใฎ็ทฉๅใใใใฐใใใฏ้่ทฏใ-1ใ่ฟใใ",
"+ for i in range(num_v - 1):",
"- # if i==num_v-1: return -1",
"+ if i == num_v - 1:",
"+ return -1",
"+ # ้่ทฏใซๅซใพใใ้ ็นใๆขใใ",
"-c, d = BellmanFord(abc, n, 0)",
"-# ่ฒ ใฎ้่ทฏใซNใๅซใพใใชใๆใฏinfใใใชใ",
"-if d:",
"+ans, nega = BellmanFord(abc, n, 0)",
"+if nega:",
"- print((-c))",
"+ print((-ans))"
] | false | 0.044422 | 0.037859 | 1.173346 | [
"s797352281",
"s093946450"
] |
u941407962 | p03034 | python | s951141783 | s044700576 | 409 | 339 | 75,860 | 63,216 | Accepted | Accepted | 17.11 | N, = list(map(int, input().split()))
xs = list(map(int, input().split()))
r = 0
for k in range(1, N):
a = (N-1) % k
b = a - k
n = (N-1-a)//k
if a <= k:
a += k
if a <= k:
a += k
for _ in range((N-1-a)//k):
b = a - k
n = (N-1-a)//k
if a <= b:
a += k
continue
if a%(a-b) == 0:
if a <= (a-b)*n:
a += k
continue
if a <= b or a >= N-1:
continue
s1 = a
s2 = n * (a-b)
t = xs[s1]
ps = [(s1,t)]
for i in range(n):
s1 += a-b
t += xs[s2]
t = max(t,0)
t += xs[s1]
ps.append((s2,xs[s2]))
ps.append((s1,xs[s1]))
s2 -= a-b
#print(ps, t)
r = max(r, t)
print(r)
| N, = list(map(int, input().split()))
xs = list(map(int, input().split()))
r = 0
for k in range(1, N):
a = (N-1) % k
for _ in range(1+(N-1-a)//k):
b = a - k
n = (N-1-a)//k
if a <= b or a <= k:
a += k
continue
if a%(a-b) == 0:
if a <= (a-b)*n:
a += k
continue
if a >= N-1:
continue
s1 = a
s2 = n * (a-b)
t = xs[s1]
for i in range(n):
s1 += a-b
t += xs[s2]
t = max(t,0)
t += xs[s1]
s2 -= a-b
r = max(r, t)
print(r)
| 40 | 28 | 816 | 613 | (N,) = list(map(int, input().split()))
xs = list(map(int, input().split()))
r = 0
for k in range(1, N):
a = (N - 1) % k
b = a - k
n = (N - 1 - a) // k
if a <= k:
a += k
if a <= k:
a += k
for _ in range((N - 1 - a) // k):
b = a - k
n = (N - 1 - a) // k
if a <= b:
a += k
continue
if a % (a - b) == 0:
if a <= (a - b) * n:
a += k
continue
if a <= b or a >= N - 1:
continue
s1 = a
s2 = n * (a - b)
t = xs[s1]
ps = [(s1, t)]
for i in range(n):
s1 += a - b
t += xs[s2]
t = max(t, 0)
t += xs[s1]
ps.append((s2, xs[s2]))
ps.append((s1, xs[s1]))
s2 -= a - b
# print(ps, t)
r = max(r, t)
print(r)
| (N,) = list(map(int, input().split()))
xs = list(map(int, input().split()))
r = 0
for k in range(1, N):
a = (N - 1) % k
for _ in range(1 + (N - 1 - a) // k):
b = a - k
n = (N - 1 - a) // k
if a <= b or a <= k:
a += k
continue
if a % (a - b) == 0:
if a <= (a - b) * n:
a += k
continue
if a >= N - 1:
continue
s1 = a
s2 = n * (a - b)
t = xs[s1]
for i in range(n):
s1 += a - b
t += xs[s2]
t = max(t, 0)
t += xs[s1]
s2 -= a - b
r = max(r, t)
print(r)
| false | 30 | [
"- b = a - k",
"- n = (N - 1 - a) // k",
"- if a <= k:",
"- a += k",
"- if a <= k:",
"- a += k",
"- for _ in range((N - 1 - a) // k):",
"+ for _ in range(1 + (N - 1 - a) // k):",
"- if a <= b:",
"+ if a <= b or a <= k:",
"- if a <= b or a >= N - 1:",
"+ if a >= N - 1:",
"- ps = [(s1, t)]",
"- ps.append((s2, xs[s2]))",
"- ps.append((s1, xs[s1]))",
"- # print(ps, t)"
] | false | 0.162815 | 0.036661 | 4.441128 | [
"s951141783",
"s044700576"
] |
u926412290 | p03163 | python | s460175173 | s251207236 | 289 | 234 | 159,900 | 149,104 | Accepted | Accepted | 19.03 | N, W = list(map(int, input().split()))
dp = [[0]*100100 for _ in range(110)]
for i in range(N):
weight, value = list(map(int, input().split()))
for sum_w in range(W+1):
if sum_w - weight >= 0:
dp[i + 1][sum_w] = max(dp[i + 1][sum_w], dp[i][sum_w - weight] + value)
dp[i + 1][sum_w] = max(dp[i + 1][sum_w], dp[i][sum_w])
print((dp[N][W])) | N, W = list(map(int, input().split()))
dp = [[0] * (W + 1) for i in range(N + 1)]
for i in range(1, N + 1):
w, v = list(map(int, input().split()))
for j in range(1, W + 1):
if j >= w:
dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - w] + v)
else:
dp[i][j] = dp[i - 1][j]
print((dp[N][W])) | 12 | 13 | 373 | 332 | N, W = list(map(int, input().split()))
dp = [[0] * 100100 for _ in range(110)]
for i in range(N):
weight, value = list(map(int, input().split()))
for sum_w in range(W + 1):
if sum_w - weight >= 0:
dp[i + 1][sum_w] = max(dp[i + 1][sum_w], dp[i][sum_w - weight] + value)
dp[i + 1][sum_w] = max(dp[i + 1][sum_w], dp[i][sum_w])
print((dp[N][W]))
| N, W = list(map(int, input().split()))
dp = [[0] * (W + 1) for i in range(N + 1)]
for i in range(1, N + 1):
w, v = list(map(int, input().split()))
for j in range(1, W + 1):
if j >= w:
dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - w] + v)
else:
dp[i][j] = dp[i - 1][j]
print((dp[N][W]))
| false | 7.692308 | [
"-dp = [[0] * 100100 for _ in range(110)]",
"-for i in range(N):",
"- weight, value = list(map(int, input().split()))",
"- for sum_w in range(W + 1):",
"- if sum_w - weight >= 0:",
"- dp[i + 1][sum_w] = max(dp[i + 1][sum_w], dp[i][sum_w - weight] + value)",
"- dp[i + 1][sum_w] = max(dp[i + 1][sum_w], dp[i][sum_w])",
"+dp = [[0] * (W + 1) for i in range(N + 1)]",
"+for i in range(1, N + 1):",
"+ w, v = list(map(int, input().split()))",
"+ for j in range(1, W + 1):",
"+ if j >= w:",
"+ dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - w] + v)",
"+ else:",
"+ dp[i][j] = dp[i - 1][j]"
] | false | 0.223214 | 0.045594 | 4.895656 | [
"s460175173",
"s251207236"
] |
u987164499 | p03325 | python | s608634685 | s095951050 | 545 | 79 | 71,256 | 4,148 | Accepted | Accepted | 85.5 | from sys import stdin
import fractions
n = int(stdin.readline().rstrip())
li = list(map(int,stdin.readline().rstrip().split()))
def prime_factorize(n):
a = []
while n % 2 == 0:
a.append(2)
n //= 2
f = 3
while f * f <= n:
if n % f == 0:
a.append(f)
n //= f
else:
f += 2
if n != 1:
a.append(n)
return a
point = 0
for i in li:
lin = prime_factorize(i)
point += lin.count(2)
print(point) | n = int(eval(input()))
li = list(map(int,input().split()))
point = 0
for i in li:
while i%2 == 0:
i //= 2
point += 1
print(point) | 30 | 11 | 526 | 156 | from sys import stdin
import fractions
n = int(stdin.readline().rstrip())
li = list(map(int, stdin.readline().rstrip().split()))
def prime_factorize(n):
a = []
while n % 2 == 0:
a.append(2)
n //= 2
f = 3
while f * f <= n:
if n % f == 0:
a.append(f)
n //= f
else:
f += 2
if n != 1:
a.append(n)
return a
point = 0
for i in li:
lin = prime_factorize(i)
point += lin.count(2)
print(point)
| n = int(eval(input()))
li = list(map(int, input().split()))
point = 0
for i in li:
while i % 2 == 0:
i //= 2
point += 1
print(point)
| false | 63.333333 | [
"-from sys import stdin",
"-import fractions",
"-",
"-n = int(stdin.readline().rstrip())",
"-li = list(map(int, stdin.readline().rstrip().split()))",
"-",
"-",
"-def prime_factorize(n):",
"- a = []",
"- while n % 2 == 0:",
"- a.append(2)",
"- n //= 2",
"- f = 3",
"- while f * f <= n:",
"- if n % f == 0:",
"- a.append(f)",
"- n //= f",
"- else:",
"- f += 2",
"- if n != 1:",
"- a.append(n)",
"- return a",
"-",
"-",
"+n = int(eval(input()))",
"+li = list(map(int, input().split()))",
"- lin = prime_factorize(i)",
"- point += lin.count(2)",
"+ while i % 2 == 0:",
"+ i //= 2",
"+ point += 1"
] | false | 0.069966 | 0.146565 | 0.477373 | [
"s608634685",
"s095951050"
] |
u806976856 | p03045 | python | s558242106 | s899791050 | 419 | 352 | 83,856 | 81,564 | Accepted | Accepted | 15.99 | n,m=list(map(int,input().split()))
import sys
sys.setrecursionlimit(10**9) #ๅๅธฐใฎไธ้ใใใใ
root=[-1 for i in range(n+1)] #่ชๅใ่ฆชใชใใฐใซใผใใฎไบบๆฐใฎใใคใในๅใใใใใงใชใใชใ๏ผๅ
๏ผ่ฆชใฎ็ชๅทใ็คบใ
dep=[1]*(n+1)
def r(x): #่ฆชใฏ่ชฐ๏ผ
if root[x]<0:
return x
else:
return r(root[x])
def unite(x,y):
x=r(x)
y=r(y)
if x==y:
return
if dep[x]==dep[y]:
dep[x]+=1
if dep[x]<dep[y]:
x,y=y,x
root[x]+=root[y]
root[y]=x
for i in range(m):
x,y,z=list(map(int,input().split()))
unite(x,y)
g=[0]*(n+1)
for i in range(1,n+1):
g[r(i)]+=1
ans=0
for i in range(n+1):
if g[i]>0:
ans+=1
print(ans)
| n,m=list(map(int,input().split()))
import sys
sys.setrecursionlimit(10**9) #ๅๅธฐใฎไธ้ใใใใ
root=[-1 for i in range(n+1)] #่ชๅใ่ฆชใชใใฐใซใผใใฎไบบๆฐใฎใใคใในๅใใใใใงใชใใชใ๏ผๅ
๏ผ่ฆชใฎ็ชๅทใ็คบใ
dep=[1]*(n+1)
def r(x): #่ฆชใฏ่ชฐ๏ผ
if root[x]<0:
return x
else:
root[x]=r(root[x])
return root[x]
def unite(x,y):
x=r(x)
y=r(y)
if x==y:
return
if dep[x]==dep[y]:
dep[x]+=1
if dep[x]<dep[y]:
x,y=y,x
root[x]+=root[y]
root[y]=x
for i in range(m):
x,y,z=list(map(int,input().split()))
unite(x,y)
g=[0]*(n+1)
for i in range(1,n+1):
g[r(i)]+=1
ans=0
for i in range(n+1):
if g[i]>0:
ans+=1
print(ans)
| 39 | 40 | 665 | 690 | n, m = list(map(int, input().split()))
import sys
sys.setrecursionlimit(10**9) # ๅๅธฐใฎไธ้ใใใใ
root = [-1 for i in range(n + 1)] # ่ชๅใ่ฆชใชใใฐใซใผใใฎไบบๆฐใฎใใคใในๅใใใใใงใชใใชใ๏ผๅ
๏ผ่ฆชใฎ็ชๅทใ็คบใ
dep = [1] * (n + 1)
def r(x): # ่ฆชใฏ่ชฐ๏ผ
if root[x] < 0:
return x
else:
return r(root[x])
def unite(x, y):
x = r(x)
y = r(y)
if x == y:
return
if dep[x] == dep[y]:
dep[x] += 1
if dep[x] < dep[y]:
x, y = y, x
root[x] += root[y]
root[y] = x
for i in range(m):
x, y, z = list(map(int, input().split()))
unite(x, y)
g = [0] * (n + 1)
for i in range(1, n + 1):
g[r(i)] += 1
ans = 0
for i in range(n + 1):
if g[i] > 0:
ans += 1
print(ans)
| n, m = list(map(int, input().split()))
import sys
sys.setrecursionlimit(10**9) # ๅๅธฐใฎไธ้ใใใใ
root = [-1 for i in range(n + 1)] # ่ชๅใ่ฆชใชใใฐใซใผใใฎไบบๆฐใฎใใคใในๅใใใใใงใชใใชใ๏ผๅ
๏ผ่ฆชใฎ็ชๅทใ็คบใ
dep = [1] * (n + 1)
def r(x): # ่ฆชใฏ่ชฐ๏ผ
if root[x] < 0:
return x
else:
root[x] = r(root[x])
return root[x]
def unite(x, y):
x = r(x)
y = r(y)
if x == y:
return
if dep[x] == dep[y]:
dep[x] += 1
if dep[x] < dep[y]:
x, y = y, x
root[x] += root[y]
root[y] = x
for i in range(m):
x, y, z = list(map(int, input().split()))
unite(x, y)
g = [0] * (n + 1)
for i in range(1, n + 1):
g[r(i)] += 1
ans = 0
for i in range(n + 1):
if g[i] > 0:
ans += 1
print(ans)
| false | 2.5 | [
"- return r(root[x])",
"+ root[x] = r(root[x])",
"+ return root[x]"
] | false | 0.087601 | 0.098227 | 0.891825 | [
"s558242106",
"s899791050"
] |
u531599639 | p02888 | python | s635133845 | s470423519 | 1,076 | 216 | 9,376 | 73,824 | Accepted | Accepted | 79.93 | import bisect
n = int(eval(input()))
l = sorted(list(map(int,input().split())))
ans = 0
for ai in range(n):
for bi in range(ai+1,n):
ci = bisect.bisect_left(l,l[ai]+l[bi])
if ci>bi:
ans += ci-bi-1
print(ans) | n = int(eval(input()))
l = sorted(list(map(int,input().split())))
ans = 0
for ai in range(n):
for bi in range(ai+1,n):
ok,ng = bi,n
while ng-ok>1:
mid = (ng+ok)//2
if l[mid]<l[ai]+l[bi]:
ok = mid
else:
ng = mid
ans += ok-bi
print(ans) | 10 | 14 | 236 | 289 | import bisect
n = int(eval(input()))
l = sorted(list(map(int, input().split())))
ans = 0
for ai in range(n):
for bi in range(ai + 1, n):
ci = bisect.bisect_left(l, l[ai] + l[bi])
if ci > bi:
ans += ci - bi - 1
print(ans)
| n = int(eval(input()))
l = sorted(list(map(int, input().split())))
ans = 0
for ai in range(n):
for bi in range(ai + 1, n):
ok, ng = bi, n
while ng - ok > 1:
mid = (ng + ok) // 2
if l[mid] < l[ai] + l[bi]:
ok = mid
else:
ng = mid
ans += ok - bi
print(ans)
| false | 28.571429 | [
"-import bisect",
"-",
"- ci = bisect.bisect_left(l, l[ai] + l[bi])",
"- if ci > bi:",
"- ans += ci - bi - 1",
"+ ok, ng = bi, n",
"+ while ng - ok > 1:",
"+ mid = (ng + ok) // 2",
"+ if l[mid] < l[ai] + l[bi]:",
"+ ok = mid",
"+ else:",
"+ ng = mid",
"+ ans += ok - bi"
] | false | 0.037161 | 0.033618 | 1.105392 | [
"s635133845",
"s470423519"
] |
u729133443 | p04011 | python | s793090160 | s674957750 | 196 | 18 | 38,256 | 2,940 | Accepted | Accepted | 90.82 | n,k,x,y=[int(eval(input()))for _ in[0]*4];print((min(n,k)*x+max(n-k,0)*y)) | n,k,x,y=[int(eval(input()))for _ in[0]*4];print((n*x-(x-y)*max(n-k,0))) | 1 | 1 | 66 | 63 | n, k, x, y = [int(eval(input())) for _ in [0] * 4]
print((min(n, k) * x + max(n - k, 0) * y))
| n, k, x, y = [int(eval(input())) for _ in [0] * 4]
print((n * x - (x - y) * max(n - k, 0)))
| false | 0 | [
"-print((min(n, k) * x + max(n - k, 0) * y))",
"+print((n * x - (x - y) * max(n - k, 0)))"
] | false | 0.076374 | 0.035662 | 2.141611 | [
"s793090160",
"s674957750"
] |
u864197622 | p02728 | python | s621509598 | s613472152 | 1,720 | 1,375 | 127,436 | 126,156 | Accepted | Accepted | 20.06 | import sys
input = sys.stdin.readline
from collections import deque
nn = 200200
mod = 10**9+7
fa = [1] * (nn+1)
fainv = [1] * (nn+1)
inv = [1] * (nn+1)
for i in range(nn):
fa[i+1] = fa[i] * (i+1) % mod
fainv[-1] = pow(fa[-1], mod-2, mod)
for i in range(nn)[::-1]:
fainv[i] = fainv[i+1] * (i+1) % mod
for i in range(1, nn)[::-1]:
inv[i] = fainv[i] * fa[i-1]
C = lambda a, b: fa[a] * fainv[b] % mod * fainv[a-b] % mod if 0 <= b <= a else 0
N = int(eval(input()))
X = [[] for i in range(N)]
for i in range(N-1):
x, y = list(map(int, input().split()))
X[x-1].append(y-1)
X[y-1].append(x-1)
P = [-1] * N
Q = deque([0])
R = []
while Q:
i = deque.popleft(Q)
R.append(i)
for a in X[i]:
if a != P[i]:
P[a] = i
X[a].remove(i)
deque.append(Q, a)
BU = [1] * N
TD = [1] * N
SI = [1] * N
for i in R[::-1]:
a = 1
s = 1
for j in X[i]:
a = a * BU[j] % mod
s += SI[j]
SI[i] = s
BU[i] = inv[s] * a % mod
for i in R:
c = len(X[i])
AL = [1] * (c + 1)
AR = [1] * (c + 1)
for k, j in enumerate(X[i]):
AL[k+1] = AL[k] * BU[j] % mod
for k, j in list(enumerate(X[i]))[::-1]:
AR[k] = AR[k+1] * BU[j] % mod
for k, j in enumerate(X[i]):
TD[j] = TD[i] * AL[k] % mod * AR[k+1] % mod * inv[N - SI[j]] % mod
for i in range(N):
print((BU[i] * fa[SI[i]] % mod * TD[i] % mod * fa[N - SI[i]] % mod * C(N-1, SI[i] - 1) % mod)) | import sys
input = sys.stdin.readline
from collections import deque
nn = 200200
mod = 10**9+7
fa = [1] * (nn+1)
fainv = [1] * (nn+1)
inv = [1] * (nn+1)
for i in range(nn):
fa[i+1] = fa[i] * (i+1) % mod
fainv[-1] = pow(fa[-1], mod-2, mod)
for i in range(nn)[::-1]:
fainv[i] = fainv[i+1] * (i+1) % mod
for i in range(1, nn)[::-1]:
inv[i] = fainv[i] * fa[i-1]
C = lambda a, b: fa[a] * fainv[b] % mod * fainv[a-b] % mod if 0 <= b <= a else 0
N = int(eval(input()))
X = [[] for i in range(N)]
for i in range(N-1):
x, y = list(map(int, input().split()))
X[x-1].append(y-1)
X[y-1].append(x-1)
P = [-1] * N
Q = deque([0])
R = []
while Q:
i = deque.popleft(Q)
R.append(i)
for a in X[i]:
if a != P[i]:
P[a] = i
X[a].remove(i)
deque.append(Q, a)
BU = [1] * N
TD = [1] * N
SI = [1] * N
for i in R[::-1]:
a = 1
s = 1
for j in X[i]:
a = a * BU[j] % mod
s += SI[j]
SI[i] = s
BU[i] = inv[s] * a % mod
for i in R:
c = len(X[i])
AL = [1] * (c + 1)
AR = [1] * (c + 1)
for k, j in enumerate(X[i]):
AL[k+1] = AL[k] * BU[j] % mod
for k in range(c-1, -1, -1):
j = X[i][k]
AR[k] = AR[k+1] * BU[j] % mod
for k, j in enumerate(X[i]):
TD[j] = TD[i] * AL[k] % mod * AR[k+1] % mod * inv[N - SI[j]] % mod
for i in range(N):
print((BU[i] * fa[SI[i]] % mod * TD[i] % mod * fa[N - SI[i]] % mod * C(N-1, SI[i] - 1) % mod)) | 64 | 65 | 1,513 | 1,522 | import sys
input = sys.stdin.readline
from collections import deque
nn = 200200
mod = 10**9 + 7
fa = [1] * (nn + 1)
fainv = [1] * (nn + 1)
inv = [1] * (nn + 1)
for i in range(nn):
fa[i + 1] = fa[i] * (i + 1) % mod
fainv[-1] = pow(fa[-1], mod - 2, mod)
for i in range(nn)[::-1]:
fainv[i] = fainv[i + 1] * (i + 1) % mod
for i in range(1, nn)[::-1]:
inv[i] = fainv[i] * fa[i - 1]
C = lambda a, b: fa[a] * fainv[b] % mod * fainv[a - b] % mod if 0 <= b <= a else 0
N = int(eval(input()))
X = [[] for i in range(N)]
for i in range(N - 1):
x, y = list(map(int, input().split()))
X[x - 1].append(y - 1)
X[y - 1].append(x - 1)
P = [-1] * N
Q = deque([0])
R = []
while Q:
i = deque.popleft(Q)
R.append(i)
for a in X[i]:
if a != P[i]:
P[a] = i
X[a].remove(i)
deque.append(Q, a)
BU = [1] * N
TD = [1] * N
SI = [1] * N
for i in R[::-1]:
a = 1
s = 1
for j in X[i]:
a = a * BU[j] % mod
s += SI[j]
SI[i] = s
BU[i] = inv[s] * a % mod
for i in R:
c = len(X[i])
AL = [1] * (c + 1)
AR = [1] * (c + 1)
for k, j in enumerate(X[i]):
AL[k + 1] = AL[k] * BU[j] % mod
for k, j in list(enumerate(X[i]))[::-1]:
AR[k] = AR[k + 1] * BU[j] % mod
for k, j in enumerate(X[i]):
TD[j] = TD[i] * AL[k] % mod * AR[k + 1] % mod * inv[N - SI[j]] % mod
for i in range(N):
print(
(
BU[i]
* fa[SI[i]]
% mod
* TD[i]
% mod
* fa[N - SI[i]]
% mod
* C(N - 1, SI[i] - 1)
% mod
)
)
| import sys
input = sys.stdin.readline
from collections import deque
nn = 200200
mod = 10**9 + 7
fa = [1] * (nn + 1)
fainv = [1] * (nn + 1)
inv = [1] * (nn + 1)
for i in range(nn):
fa[i + 1] = fa[i] * (i + 1) % mod
fainv[-1] = pow(fa[-1], mod - 2, mod)
for i in range(nn)[::-1]:
fainv[i] = fainv[i + 1] * (i + 1) % mod
for i in range(1, nn)[::-1]:
inv[i] = fainv[i] * fa[i - 1]
C = lambda a, b: fa[a] * fainv[b] % mod * fainv[a - b] % mod if 0 <= b <= a else 0
N = int(eval(input()))
X = [[] for i in range(N)]
for i in range(N - 1):
x, y = list(map(int, input().split()))
X[x - 1].append(y - 1)
X[y - 1].append(x - 1)
P = [-1] * N
Q = deque([0])
R = []
while Q:
i = deque.popleft(Q)
R.append(i)
for a in X[i]:
if a != P[i]:
P[a] = i
X[a].remove(i)
deque.append(Q, a)
BU = [1] * N
TD = [1] * N
SI = [1] * N
for i in R[::-1]:
a = 1
s = 1
for j in X[i]:
a = a * BU[j] % mod
s += SI[j]
SI[i] = s
BU[i] = inv[s] * a % mod
for i in R:
c = len(X[i])
AL = [1] * (c + 1)
AR = [1] * (c + 1)
for k, j in enumerate(X[i]):
AL[k + 1] = AL[k] * BU[j] % mod
for k in range(c - 1, -1, -1):
j = X[i][k]
AR[k] = AR[k + 1] * BU[j] % mod
for k, j in enumerate(X[i]):
TD[j] = TD[i] * AL[k] % mod * AR[k + 1] % mod * inv[N - SI[j]] % mod
for i in range(N):
print(
(
BU[i]
* fa[SI[i]]
% mod
* TD[i]
% mod
* fa[N - SI[i]]
% mod
* C(N - 1, SI[i] - 1)
% mod
)
)
| false | 1.538462 | [
"- for k, j in list(enumerate(X[i]))[::-1]:",
"+ for k in range(c - 1, -1, -1):",
"+ j = X[i][k]"
] | false | 0.527022 | 0.506946 | 1.039603 | [
"s621509598",
"s613472152"
] |
u002459665 | p02802 | python | s646150115 | s404945419 | 361 | 326 | 32,132 | 23,464 | Accepted | Accepted | 9.7 | N, M = list(map(int, input().split()))
PS = []
for i in range(M):
p, s = input().split()
PS.append([int(p), s])
a_w = []
for i in range(N+1):
a_w.append([False, 0])
a_cnt = 0
w_cnt = 0
for p, s in PS:
# ๆญฃ่งฃๆธใฟ
if a_w[p][0]:
continue
# ๅใใฆๆญฃ่งฃใใ
if s == 'AC':
a_w[p][0] = True
a_cnt += 1
w_cnt += a_w[p][1]
else:
a_w[p][1] += 1
# print(a_w)
print((a_cnt, w_cnt)) | N, M = list(map(int, input().split()))
PS = []
for i in range(M):
p, s = input().split()
PS.append([int(p), s])
ac = [False] * N
pena = [0] * N
for p, s in PS:
p -= 1
if ac[p]:
continue
if s == 'AC':
ac[p] = True
else:
pena[p] += 1
a_cnt = 0
w_cnt = 0
for i in range(N):
if ac[i]:
a_cnt += 1
w_cnt += pena[i]
print((a_cnt, w_cnt)) | 27 | 27 | 451 | 421 | N, M = list(map(int, input().split()))
PS = []
for i in range(M):
p, s = input().split()
PS.append([int(p), s])
a_w = []
for i in range(N + 1):
a_w.append([False, 0])
a_cnt = 0
w_cnt = 0
for p, s in PS:
# ๆญฃ่งฃๆธใฟ
if a_w[p][0]:
continue
# ๅใใฆๆญฃ่งฃใใ
if s == "AC":
a_w[p][0] = True
a_cnt += 1
w_cnt += a_w[p][1]
else:
a_w[p][1] += 1
# print(a_w)
print((a_cnt, w_cnt))
| N, M = list(map(int, input().split()))
PS = []
for i in range(M):
p, s = input().split()
PS.append([int(p), s])
ac = [False] * N
pena = [0] * N
for p, s in PS:
p -= 1
if ac[p]:
continue
if s == "AC":
ac[p] = True
else:
pena[p] += 1
a_cnt = 0
w_cnt = 0
for i in range(N):
if ac[i]:
a_cnt += 1
w_cnt += pena[i]
print((a_cnt, w_cnt))
| false | 0 | [
"-a_w = []",
"-for i in range(N + 1):",
"- a_w.append([False, 0])",
"+ac = [False] * N",
"+pena = [0] * N",
"+for p, s in PS:",
"+ p -= 1",
"+ if ac[p]:",
"+ continue",
"+ if s == \"AC\":",
"+ ac[p] = True",
"+ else:",
"+ pena[p] += 1",
"-for p, s in PS:",
"- # ๆญฃ่งฃๆธใฟ",
"- if a_w[p][0]:",
"- continue",
"- # ๅใใฆๆญฃ่งฃใใ",
"- if s == \"AC\":",
"- a_w[p][0] = True",
"+for i in range(N):",
"+ if ac[i]:",
"- w_cnt += a_w[p][1]",
"- else:",
"- a_w[p][1] += 1",
"-# print(a_w)",
"+ w_cnt += pena[i]"
] | false | 0.052639 | 0.047413 | 1.110219 | [
"s646150115",
"s404945419"
] |
u706929073 | p03127 | python | s164667225 | s282196276 | 136 | 73 | 14,252 | 14,224 | Accepted | Accepted | 46.32 | n = int(eval(input()))
a = list(map(int, input().split()))
a.sort()
for i in range(1, len(a)):
while 0 != a[i - 1]:
r = a[i] % a[i - 1]
a[i] = a[i - 1]
a[i - 1] = r
print((a[-1]))
| n = int(eval(input()))
a = list(map(int, input().split()))
def gcd(a, b):
r = a % b
if 0 == r:
return b
else:
return gcd(b, r)
def gcd_for_arr(l):
tmp = gcd(l[0], l[1])
for i in range(2, len(l)):
tmp = gcd(tmp, l[i])
return tmp
print((gcd_for_arr(a)))
| 10 | 20 | 210 | 317 | n = int(eval(input()))
a = list(map(int, input().split()))
a.sort()
for i in range(1, len(a)):
while 0 != a[i - 1]:
r = a[i] % a[i - 1]
a[i] = a[i - 1]
a[i - 1] = r
print((a[-1]))
| n = int(eval(input()))
a = list(map(int, input().split()))
def gcd(a, b):
r = a % b
if 0 == r:
return b
else:
return gcd(b, r)
def gcd_for_arr(l):
tmp = gcd(l[0], l[1])
for i in range(2, len(l)):
tmp = gcd(tmp, l[i])
return tmp
print((gcd_for_arr(a)))
| false | 50 | [
"-a.sort()",
"-for i in range(1, len(a)):",
"- while 0 != a[i - 1]:",
"- r = a[i] % a[i - 1]",
"- a[i] = a[i - 1]",
"- a[i - 1] = r",
"-print((a[-1]))",
"+",
"+",
"+def gcd(a, b):",
"+ r = a % b",
"+ if 0 == r:",
"+ return b",
"+ else:",
"+ return gcd(b, r)",
"+",
"+",
"+def gcd_for_arr(l):",
"+ tmp = gcd(l[0], l[1])",
"+ for i in range(2, len(l)):",
"+ tmp = gcd(tmp, l[i])",
"+ return tmp",
"+",
"+",
"+print((gcd_for_arr(a)))"
] | false | 0.055265 | 0.084535 | 0.653755 | [
"s164667225",
"s282196276"
] |
u241159583 | p03262 | python | s323505448 | s153088404 | 156 | 105 | 16,296 | 16,200 | Accepted | Accepted | 32.69 | import fractions
N, X = list(map(int, input().split()))
x = list(map(int, input().split()))
x.sort()
a = []
for i in range(N):
a.append(abs(X - x[i]))
ans = a[0]
if len(a) > 1:
for i in range(1, len(a)):
ans = fractions.gcd(ans, a[i])
print(ans) | from functools import reduce
from fractions import gcd
N, X = list(map(int, input().split()))
x = list(map(int, input().split()))
n = []
for i in range(N):
n.append(abs(X - x[i]))
print((reduce(gcd, n))) | 12 | 9 | 266 | 208 | import fractions
N, X = list(map(int, input().split()))
x = list(map(int, input().split()))
x.sort()
a = []
for i in range(N):
a.append(abs(X - x[i]))
ans = a[0]
if len(a) > 1:
for i in range(1, len(a)):
ans = fractions.gcd(ans, a[i])
print(ans)
| from functools import reduce
from fractions import gcd
N, X = list(map(int, input().split()))
x = list(map(int, input().split()))
n = []
for i in range(N):
n.append(abs(X - x[i]))
print((reduce(gcd, n)))
| false | 25 | [
"-import fractions",
"+from functools import reduce",
"+from fractions import gcd",
"-x.sort()",
"-a = []",
"+n = []",
"- a.append(abs(X - x[i]))",
"-ans = a[0]",
"-if len(a) > 1:",
"- for i in range(1, len(a)):",
"- ans = fractions.gcd(ans, a[i])",
"-print(ans)",
"+ n.append(abs(X - x[i]))",
"+print((reduce(gcd, n)))"
] | false | 0.0885 | 0.101037 | 0.875918 | [
"s323505448",
"s153088404"
] |
u255067135 | p03329 | python | s524111616 | s509030582 | 1,142 | 617 | 237,548 | 15,088 | Accepted | Accepted | 45.97 | import sys
sys.setrecursionlimit(10**6)
def memorize(f):
table = {}
def func(*args):
if not args in table:
table[args] = f(*args)
return table[args]
return func
@memorize
def memDFS(n):
if n==0:
return 0
else:
res = n
pow6 = 1
while(pow6<=n):
res = min(res, memDFS(n-pow6)+1)
pow6 *= 6
pow9 = 1
while(pow9<=n):
res = min(res, memDFS(n-pow9)+1)
pow9 *= 9
return res
N = int(eval(input()))
print((memDFS(N))) | # ใใใDP
N = int(eval(input()))
dp = {}
for n in range(N+1):
if n == 0:
dp[0] = 0
else:
res = n
pow6 = 1
while n - pow6 >= 0:
res = min(res, dp[n-pow6] +1)
pow6 *= 6
pow9 = 1
while n -pow9 >= 0:
res = min(res, dp[n-pow9] +1)
pow9 *= 9
dp[n] = res
print((dp[N])) | 29 | 18 | 582 | 381 | import sys
sys.setrecursionlimit(10**6)
def memorize(f):
table = {}
def func(*args):
if not args in table:
table[args] = f(*args)
return table[args]
return func
@memorize
def memDFS(n):
if n == 0:
return 0
else:
res = n
pow6 = 1
while pow6 <= n:
res = min(res, memDFS(n - pow6) + 1)
pow6 *= 6
pow9 = 1
while pow9 <= n:
res = min(res, memDFS(n - pow9) + 1)
pow9 *= 9
return res
N = int(eval(input()))
print((memDFS(N)))
| # ใใใDP
N = int(eval(input()))
dp = {}
for n in range(N + 1):
if n == 0:
dp[0] = 0
else:
res = n
pow6 = 1
while n - pow6 >= 0:
res = min(res, dp[n - pow6] + 1)
pow6 *= 6
pow9 = 1
while n - pow9 >= 0:
res = min(res, dp[n - pow9] + 1)
pow9 *= 9
dp[n] = res
print((dp[N]))
| false | 37.931034 | [
"-import sys",
"-",
"-sys.setrecursionlimit(10**6)",
"-",
"-",
"-def memorize(f):",
"- table = {}",
"-",
"- def func(*args):",
"- if not args in table:",
"- table[args] = f(*args)",
"- return table[args]",
"-",
"- return func",
"-",
"-",
"-@memorize",
"-def memDFS(n):",
"+# ใใใDP",
"+N = int(eval(input()))",
"+dp = {}",
"+for n in range(N + 1):",
"- return 0",
"+ dp[0] = 0",
"- while pow6 <= n:",
"- res = min(res, memDFS(n - pow6) + 1)",
"+ while n - pow6 >= 0:",
"+ res = min(res, dp[n - pow6] + 1)",
"- while pow9 <= n:",
"- res = min(res, memDFS(n - pow9) + 1)",
"+ while n - pow9 >= 0:",
"+ res = min(res, dp[n - pow9] + 1)",
"- return res",
"-",
"-",
"-N = int(eval(input()))",
"-print((memDFS(N)))",
"+ dp[n] = res",
"+print((dp[N]))"
] | false | 0.09924 | 0.183782 | 0.53999 | [
"s524111616",
"s509030582"
] |
u671060652 | p02848 | python | s194170939 | s054360844 | 214 | 191 | 40,684 | 40,412 | Accepted | Accepted | 10.75 | n = int(eval(input()))
s = eval(input())
string = ""
for i in range(len(s)):
if ord(s[i]) + n <= ord("Z"):
string += chr(ord(s[i]) + n)
else:
string += chr(ord(s[i]) + n - 26)
print(string) | n = int(eval(input()))
s = eval(input())
ans = ""
for i in range(len(s)):
ans += chr(ord("A") +(((ord(s[i])+n)-ord("A")) % 26))
print(ans) | 11 | 9 | 213 | 141 | n = int(eval(input()))
s = eval(input())
string = ""
for i in range(len(s)):
if ord(s[i]) + n <= ord("Z"):
string += chr(ord(s[i]) + n)
else:
string += chr(ord(s[i]) + n - 26)
print(string)
| n = int(eval(input()))
s = eval(input())
ans = ""
for i in range(len(s)):
ans += chr(ord("A") + (((ord(s[i]) + n) - ord("A")) % 26))
print(ans)
| false | 18.181818 | [
"-string = \"\"",
"+ans = \"\"",
"- if ord(s[i]) + n <= ord(\"Z\"):",
"- string += chr(ord(s[i]) + n)",
"- else:",
"- string += chr(ord(s[i]) + n - 26)",
"-print(string)",
"+ ans += chr(ord(\"A\") + (((ord(s[i]) + n) - ord(\"A\")) % 26))",
"+print(ans)"
] | false | 0.044475 | 0.054675 | 0.813448 | [
"s194170939",
"s054360844"
] |
u652656291 | p03087 | python | s513282787 | s826019155 | 1,713 | 820 | 15,676 | 17,576 | Accepted | Accepted | 52.13 | import numpy as np
N,Q = list(map(int,input().split()))
S = np.array(list('_' + eval(input())), dtype='U2')
A = (S == 'A')
C = (S == 'C')
AC = (A[:-1] & C[1:])
AC_cum = AC.cumsum()
for _ in range(Q):
L,R = list(map(int,input().split()))
print((AC_cum[R-1] - AC_cum[L-1]))
| import numpy as np
import sys
buf = sys.stdin.buffer
N,Q = list(map(int,buf.readline().split()))
S = np.zeros(N+2, dtype='S1')
S[1:] = np.frombuffer(buf.read(N+1), dtype='S1')
A = (S == b'A')
C = (S == b'C')
AC = (A[:-1] & C[1:])
AC_cum = list(AC.cumsum())
for _ in range(Q):
L,R = list(map(int,buf.readline().split()))
print((AC_cum[R-1] - AC_cum[L-1]))
| 11 | 14 | 267 | 359 | import numpy as np
N, Q = list(map(int, input().split()))
S = np.array(list("_" + eval(input())), dtype="U2")
A = S == "A"
C = S == "C"
AC = A[:-1] & C[1:]
AC_cum = AC.cumsum()
for _ in range(Q):
L, R = list(map(int, input().split()))
print((AC_cum[R - 1] - AC_cum[L - 1]))
| import numpy as np
import sys
buf = sys.stdin.buffer
N, Q = list(map(int, buf.readline().split()))
S = np.zeros(N + 2, dtype="S1")
S[1:] = np.frombuffer(buf.read(N + 1), dtype="S1")
A = S == b"A"
C = S == b"C"
AC = A[:-1] & C[1:]
AC_cum = list(AC.cumsum())
for _ in range(Q):
L, R = list(map(int, buf.readline().split()))
print((AC_cum[R - 1] - AC_cum[L - 1]))
| false | 21.428571 | [
"+import sys",
"-N, Q = list(map(int, input().split()))",
"-S = np.array(list(\"_\" + eval(input())), dtype=\"U2\")",
"-A = S == \"A\"",
"-C = S == \"C\"",
"+buf = sys.stdin.buffer",
"+N, Q = list(map(int, buf.readline().split()))",
"+S = np.zeros(N + 2, dtype=\"S1\")",
"+S[1:] = np.frombuffer(buf.read(N + 1), dtype=\"S1\")",
"+A = S == b\"A\"",
"+C = S == b\"C\"",
"-AC_cum = AC.cumsum()",
"+AC_cum = list(AC.cumsum())",
"- L, R = list(map(int, input().split()))",
"+ L, R = list(map(int, buf.readline().split()))"
] | false | 0.314414 | 0.260762 | 1.20575 | [
"s513282787",
"s826019155"
] |
u994988729 | p03283 | python | s078989996 | s174640728 | 2,152 | 1,746 | 20,664 | 27,792 | Accepted | Accepted | 18.87 | import numpy as np
n, m, q = map(int, input().split())
train = np.zeros((n, n), dtype=int)
for _ in range(m):
l, r = map(int, input().split())
l -= 1
r -= 1
train[l][r] += 1
# ็ดฏ็ฉๅ
for i in range(n):
np.add.accumulate(train[i], out=train[i])
np.add.accumulate(train, out=train)
ans = []
for _ in range(q):
x, y = map(int, input().split())
x -= 1
y -= 1
a = train[y][y]
if x != 0:
a -= train[x-1][y]
ans.append(a)
print(*ans, sep="\n")
| import numpy as np
n, m, q = map(int, input().split())
train = np.zeros((n, n), dtype=int)
for _ in range(m):
l, r = map(int, input().split())
l -= 1
r -= 1
train[l][r] += 1
# ็ดฏ็ฉๅ
for i in range(n):
np.add.accumulate(train[i], out=train[i])
np.add.accumulate(train, out=train)
train=train.tolist()
ans = []
for _ in range(q):
x, y = map(int, input().split())
x -= 1
y -= 1
a = train[y][y]
if x != 0:
a -= train[x-1][y]
ans.append(a)
print(*ans, sep="\n")
| 25 | 26 | 513 | 535 | import numpy as np
n, m, q = map(int, input().split())
train = np.zeros((n, n), dtype=int)
for _ in range(m):
l, r = map(int, input().split())
l -= 1
r -= 1
train[l][r] += 1
# ็ดฏ็ฉๅ
for i in range(n):
np.add.accumulate(train[i], out=train[i])
np.add.accumulate(train, out=train)
ans = []
for _ in range(q):
x, y = map(int, input().split())
x -= 1
y -= 1
a = train[y][y]
if x != 0:
a -= train[x - 1][y]
ans.append(a)
print(*ans, sep="\n")
| import numpy as np
n, m, q = map(int, input().split())
train = np.zeros((n, n), dtype=int)
for _ in range(m):
l, r = map(int, input().split())
l -= 1
r -= 1
train[l][r] += 1
# ็ดฏ็ฉๅ
for i in range(n):
np.add.accumulate(train[i], out=train[i])
np.add.accumulate(train, out=train)
train = train.tolist()
ans = []
for _ in range(q):
x, y = map(int, input().split())
x -= 1
y -= 1
a = train[y][y]
if x != 0:
a -= train[x - 1][y]
ans.append(a)
print(*ans, sep="\n")
| false | 3.846154 | [
"+train = train.tolist()"
] | false | 0.308411 | 0.350887 | 0.878949 | [
"s078989996",
"s174640728"
] |
u405256066 | p03958 | python | s086266795 | s726529144 | 57 | 27 | 3,064 | 3,064 | Accepted | Accepted | 52.63 | from sys import stdin
#import heapq
K,T = [int(x) for x in stdin.readline().rstrip().split()]
data = [(int(b),a) for a,b in enumerate(stdin.readline().rstrip().split())]
#heapq.heapify(data)
ans = 0
cake_num = -1
flag = True
if T == 1:
ans = K-1
else:
while flag:
data.sort()
#print(data)
c_c,c_n = data.pop()
#print(c_c,c_n)
if c_n == cake_num:
c_c2,c_n2 = data.pop()
if c_c2 == 0:
ans = c_c
flag = False
else:
data.append((c_c2-1,c_n2))
data.append((c_c,c_n))
cake_num = c_n2
#flag = False
else:
data.append((c_c-1,c_n))
cake_num = c_n
if c_c == 0:
ans = 0
flag = False
print(ans) | from sys import stdin
import heapq
K,T = [int(x) for x in stdin.readline().rstrip().split()]
data = [(-int(b),a) for a,b in enumerate(stdin.readline().rstrip().split())]
heapq.heapify(data)
ans = 0
cake_num = -1
cake_count = 0
flag = True
if T == 1:
ans = K-1
else:
while flag:
c_c,c_n = heapq.heappop(data)
if c_n == cake_num:
c_c2,c_n2 = heapq.heappop(data)
if c_c2 == 0:
ans = abs(c_c)
flag = False
else:
heapq.heappush(data,(c_c2+1,c_n2))
cake_num = c_n2
heapq.heappush(data,(c_c,c_n))
#flag = False
else:
heapq.heappush(data,(c_c+1,c_n))
cake_num = c_n
if c_c == 0:
ans = 0
flag = False
print(ans) | 35 | 33 | 859 | 773 | from sys import stdin
# import heapq
K, T = [int(x) for x in stdin.readline().rstrip().split()]
data = [(int(b), a) for a, b in enumerate(stdin.readline().rstrip().split())]
# heapq.heapify(data)
ans = 0
cake_num = -1
flag = True
if T == 1:
ans = K - 1
else:
while flag:
data.sort()
# print(data)
c_c, c_n = data.pop()
# print(c_c,c_n)
if c_n == cake_num:
c_c2, c_n2 = data.pop()
if c_c2 == 0:
ans = c_c
flag = False
else:
data.append((c_c2 - 1, c_n2))
data.append((c_c, c_n))
cake_num = c_n2
# flag = False
else:
data.append((c_c - 1, c_n))
cake_num = c_n
if c_c == 0:
ans = 0
flag = False
print(ans)
| from sys import stdin
import heapq
K, T = [int(x) for x in stdin.readline().rstrip().split()]
data = [(-int(b), a) for a, b in enumerate(stdin.readline().rstrip().split())]
heapq.heapify(data)
ans = 0
cake_num = -1
cake_count = 0
flag = True
if T == 1:
ans = K - 1
else:
while flag:
c_c, c_n = heapq.heappop(data)
if c_n == cake_num:
c_c2, c_n2 = heapq.heappop(data)
if c_c2 == 0:
ans = abs(c_c)
flag = False
else:
heapq.heappush(data, (c_c2 + 1, c_n2))
cake_num = c_n2
heapq.heappush(data, (c_c, c_n))
# flag = False
else:
heapq.heappush(data, (c_c + 1, c_n))
cake_num = c_n
if c_c == 0:
ans = 0
flag = False
print(ans)
| false | 5.714286 | [
"+import heapq",
"-# import heapq",
"-data = [(int(b), a) for a, b in enumerate(stdin.readline().rstrip().split())]",
"-# heapq.heapify(data)",
"+data = [(-int(b), a) for a, b in enumerate(stdin.readline().rstrip().split())]",
"+heapq.heapify(data)",
"+cake_count = 0",
"- data.sort()",
"- # print(data)",
"- c_c, c_n = data.pop()",
"- # print(c_c,c_n)",
"+ c_c, c_n = heapq.heappop(data)",
"- c_c2, c_n2 = data.pop()",
"+ c_c2, c_n2 = heapq.heappop(data)",
"- ans = c_c",
"+ ans = abs(c_c)",
"- data.append((c_c2 - 1, c_n2))",
"- data.append((c_c, c_n))",
"+ heapq.heappush(data, (c_c2 + 1, c_n2))",
"+ heapq.heappush(data, (c_c, c_n))",
"- data.append((c_c - 1, c_n))",
"+ heapq.heappush(data, (c_c + 1, c_n))"
] | false | 0.072191 | 0.038357 | 1.882075 | [
"s086266795",
"s726529144"
] |
u508732591 | p02314 | python | s871285599 | s792592108 | 580 | 530 | 9,168 | 9,168 | Accepted | Accepted | 8.62 | n,m = list(map(int,input().split()))
c = list(map(int,input().split()))
minimum = [50000] * (n+1)
minimum[0] = 0
for i in range(1,n+1):
if minimum[i] <= 1:
continue
for j in range(m):
if c[j]<=i and minimum[i-c[j]] + 1 < minimum[i]:
minimum[i] = minimum[i-c[j]]+1
print((minimum[n])) | n = int(input().split()[0])
c = list([x for x in map(int,input().split()) if x <= n])
m = len(c)
minimum = [n] * (n+1)
minimum[0] = 0
for i in c:
minimum[i] = 1
for i in range(1,n+1):
for j in range(m):
if c[j]<=i and minimum[i-c[j]] + 1 < minimum[i]:
minimum[i] = minimum[i-c[j]]+1
print((minimum[n])) | 14 | 15 | 327 | 346 | n, m = list(map(int, input().split()))
c = list(map(int, input().split()))
minimum = [50000] * (n + 1)
minimum[0] = 0
for i in range(1, n + 1):
if minimum[i] <= 1:
continue
for j in range(m):
if c[j] <= i and minimum[i - c[j]] + 1 < minimum[i]:
minimum[i] = minimum[i - c[j]] + 1
print((minimum[n]))
| n = int(input().split()[0])
c = list([x for x in map(int, input().split()) if x <= n])
m = len(c)
minimum = [n] * (n + 1)
minimum[0] = 0
for i in c:
minimum[i] = 1
for i in range(1, n + 1):
for j in range(m):
if c[j] <= i and minimum[i - c[j]] + 1 < minimum[i]:
minimum[i] = minimum[i - c[j]] + 1
print((minimum[n]))
| false | 6.666667 | [
"-n, m = list(map(int, input().split()))",
"-c = list(map(int, input().split()))",
"-minimum = [50000] * (n + 1)",
"+n = int(input().split()[0])",
"+c = list([x for x in map(int, input().split()) if x <= n])",
"+m = len(c)",
"+minimum = [n] * (n + 1)",
"+for i in c:",
"+ minimum[i] = 1",
"- if minimum[i] <= 1:",
"- continue"
] | false | 0.089136 | 0.036028 | 2.474091 | [
"s871285599",
"s792592108"
] |
u467736898 | p03013 | python | s823427049 | s338256325 | 217 | 199 | 9,612 | 9,612 | Accepted | Accepted | 8.29 | mod = 10**9+7
N, M = list(map(int, input().split()))
A_ = [int(eval(input())) for _ in range(M)]
A = [0] * (N+1)
for a in A_:
A[a] = 1
dp = [0] * (N+3)
dp[0] = 1
for i in range(1, N+1):
if A[i-1] == 0:
dp[i] += dp[i-1]
if A[i-2] == 0:
dp[i] += dp[i-2]
dp[i] %= mod
print((dp[N]))
| mod = 10**9+7
N, M = list(map(int, input().split()))
A_ = [int(eval(input())) for _ in range(M)]
A = [0] * (N+3)
for a in A_:
A[a] = 1
dp = [0] * (N+3)
dp[0] = 1
for i in range(1, N+1):
if A[i-1] == 0:
dp[i] += dp[i-1]
if A[i-2] == 0:
dp[i] += dp[i-2]
dp[i] %= mod
print((dp[N]))
| 15 | 15 | 312 | 312 | mod = 10**9 + 7
N, M = list(map(int, input().split()))
A_ = [int(eval(input())) for _ in range(M)]
A = [0] * (N + 1)
for a in A_:
A[a] = 1
dp = [0] * (N + 3)
dp[0] = 1
for i in range(1, N + 1):
if A[i - 1] == 0:
dp[i] += dp[i - 1]
if A[i - 2] == 0:
dp[i] += dp[i - 2]
dp[i] %= mod
print((dp[N]))
| mod = 10**9 + 7
N, M = list(map(int, input().split()))
A_ = [int(eval(input())) for _ in range(M)]
A = [0] * (N + 3)
for a in A_:
A[a] = 1
dp = [0] * (N + 3)
dp[0] = 1
for i in range(1, N + 1):
if A[i - 1] == 0:
dp[i] += dp[i - 1]
if A[i - 2] == 0:
dp[i] += dp[i - 2]
dp[i] %= mod
print((dp[N]))
| false | 0 | [
"-A = [0] * (N + 1)",
"+A = [0] * (N + 3)"
] | false | 0.051058 | 0.064289 | 0.794184 | [
"s823427049",
"s338256325"
] |
u133936772 | p02861 | python | s102241709 | s965495405 | 442 | 17 | 8,052 | 2,940 | Accepted | Accepted | 96.15 | n = int(eval(input()))
ll = []
for i in range(n):
ll.append(list(map(int, input().split())))
import itertools as it
lt = list(it.permutations(list(range(0, n))))
def dist(i, j):
return ((ll[i][0]-ll[j][0])**2 + (ll[i][1]-ll[j][1])**2)**0.5
d = 0
for t in lt:
for i in range(n-1):
d += dist(t[i], t[i+1])
print((d/len(lt))) | n = int(eval(input()))
ll = [list(map(int,input().split())) for _ in range(n)]
d = 0
for x1,y1 in ll:
for x2,y2 in ll:
d += ((x1-x2)**2+(y1-y2)**2)**0.5
print((d/n)) | 18 | 7 | 340 | 169 | n = int(eval(input()))
ll = []
for i in range(n):
ll.append(list(map(int, input().split())))
import itertools as it
lt = list(it.permutations(list(range(0, n))))
def dist(i, j):
return ((ll[i][0] - ll[j][0]) ** 2 + (ll[i][1] - ll[j][1]) ** 2) ** 0.5
d = 0
for t in lt:
for i in range(n - 1):
d += dist(t[i], t[i + 1])
print((d / len(lt)))
| n = int(eval(input()))
ll = [list(map(int, input().split())) for _ in range(n)]
d = 0
for x1, y1 in ll:
for x2, y2 in ll:
d += ((x1 - x2) ** 2 + (y1 - y2) ** 2) ** 0.5
print((d / n))
| false | 61.111111 | [
"-ll = []",
"-for i in range(n):",
"- ll.append(list(map(int, input().split())))",
"-import itertools as it",
"-",
"-lt = list(it.permutations(list(range(0, n))))",
"-",
"-",
"-def dist(i, j):",
"- return ((ll[i][0] - ll[j][0]) ** 2 + (ll[i][1] - ll[j][1]) ** 2) ** 0.5",
"-",
"-",
"+ll = [list(map(int, input().split())) for _ in range(n)]",
"-for t in lt:",
"- for i in range(n - 1):",
"- d += dist(t[i], t[i + 1])",
"-print((d / len(lt)))",
"+for x1, y1 in ll:",
"+ for x2, y2 in ll:",
"+ d += ((x1 - x2) ** 2 + (y1 - y2) ** 2) ** 0.5",
"+print((d / n))"
] | false | 0.07955 | 0.036995 | 2.150286 | [
"s102241709",
"s965495405"
] |
u411203878 | p02787 | python | s396772645 | s506333142 | 631 | 258 | 125,276 | 146,136 | Accepted | Accepted | 59.11 | h,n = list(map(int,input().split()))
ab = []
for _ in range(n):
a, b = (int(x) for x in input().split())
ab.append([a, b])
dp = [[100000000 for i in range(h+1)] for j in range(n+1)]
for i in range(n):
for j in range(h+1):
if j <= ab[i][0]:
dp[i+1][j] = min(ab[i][1],dp[i][j])
else:
dp[i+1][j] = min(ab[i][1]+dp[i+1][j-ab[i][0]],dp[i][j])
print((dp[-1][-1]))
| H,N = list(map(int,input().split()))
AB = [list(map(int,input().split())) for _ in range(N)]
dp = [[10000000000000]*(H+1) for _ in range(N+1)]
for y in range(N):
a,b = AB[y]
for x in range(H+1):
if x <= a:
dp[y+1][x] = min(dp[y][x], b)
else:
dp[y+1][x] = min(dp[y][x], dp[y+1][x-a]+b)
print((dp[-1][-1])) | 17 | 14 | 429 | 360 | h, n = list(map(int, input().split()))
ab = []
for _ in range(n):
a, b = (int(x) for x in input().split())
ab.append([a, b])
dp = [[100000000 for i in range(h + 1)] for j in range(n + 1)]
for i in range(n):
for j in range(h + 1):
if j <= ab[i][0]:
dp[i + 1][j] = min(ab[i][1], dp[i][j])
else:
dp[i + 1][j] = min(ab[i][1] + dp[i + 1][j - ab[i][0]], dp[i][j])
print((dp[-1][-1]))
| H, N = list(map(int, input().split()))
AB = [list(map(int, input().split())) for _ in range(N)]
dp = [[10000000000000] * (H + 1) for _ in range(N + 1)]
for y in range(N):
a, b = AB[y]
for x in range(H + 1):
if x <= a:
dp[y + 1][x] = min(dp[y][x], b)
else:
dp[y + 1][x] = min(dp[y][x], dp[y + 1][x - a] + b)
print((dp[-1][-1]))
| false | 17.647059 | [
"-h, n = list(map(int, input().split()))",
"-ab = []",
"-for _ in range(n):",
"- a, b = (int(x) for x in input().split())",
"- ab.append([a, b])",
"-dp = [[100000000 for i in range(h + 1)] for j in range(n + 1)]",
"-for i in range(n):",
"- for j in range(h + 1):",
"- if j <= ab[i][0]:",
"- dp[i + 1][j] = min(ab[i][1], dp[i][j])",
"+H, N = list(map(int, input().split()))",
"+AB = [list(map(int, input().split())) for _ in range(N)]",
"+dp = [[10000000000000] * (H + 1) for _ in range(N + 1)]",
"+for y in range(N):",
"+ a, b = AB[y]",
"+ for x in range(H + 1):",
"+ if x <= a:",
"+ dp[y + 1][x] = min(dp[y][x], b)",
"- dp[i + 1][j] = min(ab[i][1] + dp[i + 1][j - ab[i][0]], dp[i][j])",
"+ dp[y + 1][x] = min(dp[y][x], dp[y + 1][x - a] + b)"
] | false | 0.393948 | 0.241859 | 1.628832 | [
"s396772645",
"s506333142"
] |
u729133443 | p03073 | python | s109504491 | s133247959 | 111 | 73 | 4,640 | 3,956 | Accepted | Accepted | 34.23 | *s,=list(map(int,eval(input())))
t=s[::-1]
n=len(s)
a=b=0
for i in range(1,n):
a+=s[i]==s[i-1]
s[i]=1-s[i-1]
for i in range(1,n):
b+=t[i]==t[i-1]
t[i]=1-t[i-1]
print((min(a,b))) | *s,=list(map(int,eval(input())))
a=0
for i in range(1,len(s)):
a+=s[i]==s[i-1]
s[i]=1-s[i-1]
print(a) | 11 | 6 | 189 | 102 | (*s,) = list(map(int, eval(input())))
t = s[::-1]
n = len(s)
a = b = 0
for i in range(1, n):
a += s[i] == s[i - 1]
s[i] = 1 - s[i - 1]
for i in range(1, n):
b += t[i] == t[i - 1]
t[i] = 1 - t[i - 1]
print((min(a, b)))
| (*s,) = list(map(int, eval(input())))
a = 0
for i in range(1, len(s)):
a += s[i] == s[i - 1]
s[i] = 1 - s[i - 1]
print(a)
| false | 45.454545 | [
"-t = s[::-1]",
"-n = len(s)",
"-a = b = 0",
"-for i in range(1, n):",
"+a = 0",
"+for i in range(1, len(s)):",
"-for i in range(1, n):",
"- b += t[i] == t[i - 1]",
"- t[i] = 1 - t[i - 1]",
"-print((min(a, b)))",
"+print(a)"
] | false | 0.073995 | 0.046904 | 1.577585 | [
"s109504491",
"s133247959"
] |
u634079249 | p03137 | python | s353378618 | s400200327 | 131 | 91 | 24,652 | 19,888 | Accepted | Accepted | 30.53 | import sys
import os
def main():
if os.getenv("LOCAL"):
sys.stdin = open("input.txt", "r")
N, M = list(map(int, sys.stdin.readline().split()))
lines = list(map(int, sys.stdin.readline().split()))
lines.sort()
cost = {}
for i in range(len(lines) - 1):
tmp = lines[i + 1] - lines[i]
cost[i] = tmp
sortedCost = sorted(list(cost.items()), key=lambda x: x[1], reverse=True)
ret = 0
for i, c in sortedCost[N - 1:]:
ret += c
print(ret)
if __name__ == '__main__':
main()
| import sys, os, math, bisect, itertools, collections, heapq, queue
# from scipy.sparse.csgraph import csgraph_from_dense, floyd_warshall
from decimal import Decimal
from collections import defaultdict, deque
# import fractions
sys.setrecursionlimit(10000000)
ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))
fl = lambda: list(map(float, sys.stdin.buffer.readline().split()))
iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]
iss = lambda: sys.stdin.buffer.readline().decode().rstrip()
sl = lambda: list(map(str, sys.stdin.buffer.readline().decode().split()))
isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]
lcm = lambda x, y: (x * y) // math.gcd(x, y)
# lcm = lambda x, y: (x * y) // fractions.gcd(x, y)
MOD = 10 ** 9 + 7
MAX = float('inf')
def main():
if os.getenv("LOCAL"):
sys.stdin = open("input.txt", "r")
N, M = il()
X = sorted(il())
diff = []
for n in range(M - 1):
diff.append(abs(X[n] - X[n + 1]))
diff = sorted(diff, reverse=True)
ret = sum(diff[N-1:])
print(ret)
if __name__ == '__main__':
main()
| 27 | 42 | 561 | 1,246 | import sys
import os
def main():
if os.getenv("LOCAL"):
sys.stdin = open("input.txt", "r")
N, M = list(map(int, sys.stdin.readline().split()))
lines = list(map(int, sys.stdin.readline().split()))
lines.sort()
cost = {}
for i in range(len(lines) - 1):
tmp = lines[i + 1] - lines[i]
cost[i] = tmp
sortedCost = sorted(list(cost.items()), key=lambda x: x[1], reverse=True)
ret = 0
for i, c in sortedCost[N - 1 :]:
ret += c
print(ret)
if __name__ == "__main__":
main()
| import sys, os, math, bisect, itertools, collections, heapq, queue
# from scipy.sparse.csgraph import csgraph_from_dense, floyd_warshall
from decimal import Decimal
from collections import defaultdict, deque
# import fractions
sys.setrecursionlimit(10000000)
ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))
fl = lambda: list(map(float, sys.stdin.buffer.readline().split()))
iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]
iss = lambda: sys.stdin.buffer.readline().decode().rstrip()
sl = lambda: list(map(str, sys.stdin.buffer.readline().decode().split()))
isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]
lcm = lambda x, y: (x * y) // math.gcd(x, y)
# lcm = lambda x, y: (x * y) // fractions.gcd(x, y)
MOD = 10**9 + 7
MAX = float("inf")
def main():
if os.getenv("LOCAL"):
sys.stdin = open("input.txt", "r")
N, M = il()
X = sorted(il())
diff = []
for n in range(M - 1):
diff.append(abs(X[n] - X[n + 1]))
diff = sorted(diff, reverse=True)
ret = sum(diff[N - 1 :])
print(ret)
if __name__ == "__main__":
main()
| false | 35.714286 | [
"-import sys",
"-import os",
"+import sys, os, math, bisect, itertools, collections, heapq, queue",
"+",
"+# from scipy.sparse.csgraph import csgraph_from_dense, floyd_warshall",
"+from decimal import Decimal",
"+from collections import defaultdict, deque",
"+",
"+# import fractions",
"+sys.setrecursionlimit(10000000)",
"+ii = lambda: int(sys.stdin.buffer.readline().rstrip())",
"+il = lambda: list(map(int, sys.stdin.buffer.readline().split()))",
"+fl = lambda: list(map(float, sys.stdin.buffer.readline().split()))",
"+iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]",
"+iss = lambda: sys.stdin.buffer.readline().decode().rstrip()",
"+sl = lambda: list(map(str, sys.stdin.buffer.readline().decode().split()))",
"+isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]",
"+lcm = lambda x, y: (x * y) // math.gcd(x, y)",
"+# lcm = lambda x, y: (x * y) // fractions.gcd(x, y)",
"+MOD = 10**9 + 7",
"+MAX = float(\"inf\")",
"- N, M = list(map(int, sys.stdin.readline().split()))",
"- lines = list(map(int, sys.stdin.readline().split()))",
"- lines.sort()",
"- cost = {}",
"- for i in range(len(lines) - 1):",
"- tmp = lines[i + 1] - lines[i]",
"- cost[i] = tmp",
"- sortedCost = sorted(list(cost.items()), key=lambda x: x[1], reverse=True)",
"- ret = 0",
"- for i, c in sortedCost[N - 1 :]:",
"- ret += c",
"+ N, M = il()",
"+ X = sorted(il())",
"+ diff = []",
"+ for n in range(M - 1):",
"+ diff.append(abs(X[n] - X[n + 1]))",
"+ diff = sorted(diff, reverse=True)",
"+ ret = sum(diff[N - 1 :])"
] | false | 0.038654 | 0.041 | 0.94277 | [
"s353378618",
"s400200327"
] |
u029000441 | p03290 | python | s843214641 | s188179119 | 284 | 90 | 20,688 | 74,164 | Accepted | Accepted | 68.31 | # coding: utf-8
# hello worldใจ่กจ็คบใใ
import sys
import numpy
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
from collections import Counter, deque
from collections import defaultdict
from itertools import combinations, permutations, accumulate, groupby, product
from bisect import bisect_left,bisect_right
from heapq import heapify, heappop, heappush
from math import floor, ceil,pi,factorial
from operator import itemgetter
from copy import deepcopy
def I(): return int(eval(input()))
def MI(): return list(map(int, input().split()))
def LI(): return list(map(int, input().split()))
def LI2(): return [int(eval(input())) for i in range(n)]
def MXI(): return [[LI()]for i in range(n)]
def SI(): return input().rstrip()
def printns(x): print(('\n'.join(x)))
def printni(x): print(('\n'.join(list(map(str,x)))))
inf = 10**17
mod = 10**9 + 7
d,g=MI()
lis=[LI() for i in range(d)]
answers=[]
for i in product([0,1],repeat=d):
new_lis=deepcopy(lis)
point=0
problems=0
for j in range(d):
if i[j]==1:
point+=lis[j][1]+100*(j+1)*(lis[j][0])
problems+=lis[j][0]
new_lis[j][0]=0
else:
if new_lis[j][0]>0:
new_lis[j][0]-=1
#print(new_lis)
flag=True
for j in range(d):
k=d-j-1
if point>=g:
answers.append(problems)
flag=False
break
else:
req=(g-point)//(100*(k+1))
#print(req)
if new_lis[k][0]>=req:
problems+=req
point+=req*100*(k+1)
else:
problems+=new_lis[k][0]
point+=new_lis[k][0]*100*(k+1)
if point>=g and flag==True:
answers.append(problems)
#print(answers)
print((min(answers))) | #floatๅใ่จฑใใช
#numpyใฏpythonใง
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
from collections import Counter, deque
from collections import defaultdict
from itertools import combinations, permutations, accumulate, groupby, product
from bisect import bisect_left,bisect_right
from heapq import heapify, heappop, heappush
from math import floor, ceil,pi,factorial
from operator import itemgetter
def I(): return int(eval(input()))
def MI(): return list(map(int, input().split()))
def LI(): return list(map(int, input().split()))
def LI2(): return [int(eval(input())) for i in range(n)]
def MXI(): return [[LI()]for i in range(n)]
def SI(): return input().rstrip()
def printns(x): print(('\n'.join(x)))
def printni(x): print(('\n'.join(list(map(str,x)))))
inf = 10**17
mod = 10**9 + 7
d,g=MI()
lis=[LI() for i in range(d)]
pr=[]
for x in product([0,1],repeat=d):
#print(x)
score=0
pro=0
for i in range(d):
if x[i]==1:
score+=100*(i+1)*lis[i][0]+lis[i][1]
pro+=lis[i][0]
if score>=g:
pr.append(pro)
else:
rest=g-score
#print(rest)
for i in range(d):
j=d-i-1
if x[j]==0:
pro+=min(ceil(rest/(100*(j+1))),lis[j][0]-1)
rest-=100*(j+1)*min(ceil(rest/(100*(j+1))),lis[j][0]-1)
if rest<=0:
pr.append(pro)
break
else:
continue
print((min(pr)))
#print(pr) | 61 | 52 | 1,822 | 1,504 | # coding: utf-8
# hello worldใจ่กจ็คบใใ
import sys
import numpy
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
from collections import Counter, deque
from collections import defaultdict
from itertools import combinations, permutations, accumulate, groupby, product
from bisect import bisect_left, bisect_right
from heapq import heapify, heappop, heappush
from math import floor, ceil, pi, factorial
from operator import itemgetter
from copy import deepcopy
def I():
return int(eval(input()))
def MI():
return list(map(int, input().split()))
def LI():
return list(map(int, input().split()))
def LI2():
return [int(eval(input())) for i in range(n)]
def MXI():
return [[LI()] for i in range(n)]
def SI():
return input().rstrip()
def printns(x):
print(("\n".join(x)))
def printni(x):
print(("\n".join(list(map(str, x)))))
inf = 10**17
mod = 10**9 + 7
d, g = MI()
lis = [LI() for i in range(d)]
answers = []
for i in product([0, 1], repeat=d):
new_lis = deepcopy(lis)
point = 0
problems = 0
for j in range(d):
if i[j] == 1:
point += lis[j][1] + 100 * (j + 1) * (lis[j][0])
problems += lis[j][0]
new_lis[j][0] = 0
else:
if new_lis[j][0] > 0:
new_lis[j][0] -= 1
# print(new_lis)
flag = True
for j in range(d):
k = d - j - 1
if point >= g:
answers.append(problems)
flag = False
break
else:
req = (g - point) // (100 * (k + 1))
# print(req)
if new_lis[k][0] >= req:
problems += req
point += req * 100 * (k + 1)
else:
problems += new_lis[k][0]
point += new_lis[k][0] * 100 * (k + 1)
if point >= g and flag == True:
answers.append(problems)
# print(answers)
print((min(answers)))
| # floatๅใ่จฑใใช
# numpyใฏpythonใง
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
from collections import Counter, deque
from collections import defaultdict
from itertools import combinations, permutations, accumulate, groupby, product
from bisect import bisect_left, bisect_right
from heapq import heapify, heappop, heappush
from math import floor, ceil, pi, factorial
from operator import itemgetter
def I():
return int(eval(input()))
def MI():
return list(map(int, input().split()))
def LI():
return list(map(int, input().split()))
def LI2():
return [int(eval(input())) for i in range(n)]
def MXI():
return [[LI()] for i in range(n)]
def SI():
return input().rstrip()
def printns(x):
print(("\n".join(x)))
def printni(x):
print(("\n".join(list(map(str, x)))))
inf = 10**17
mod = 10**9 + 7
d, g = MI()
lis = [LI() for i in range(d)]
pr = []
for x in product([0, 1], repeat=d):
# print(x)
score = 0
pro = 0
for i in range(d):
if x[i] == 1:
score += 100 * (i + 1) * lis[i][0] + lis[i][1]
pro += lis[i][0]
if score >= g:
pr.append(pro)
else:
rest = g - score
# print(rest)
for i in range(d):
j = d - i - 1
if x[j] == 0:
pro += min(ceil(rest / (100 * (j + 1))), lis[j][0] - 1)
rest -= 100 * (j + 1) * min(ceil(rest / (100 * (j + 1))), lis[j][0] - 1)
if rest <= 0:
pr.append(pro)
break
else:
continue
print((min(pr)))
# print(pr)
| false | 14.754098 | [
"-# coding: utf-8",
"-# hello worldใจ่กจ็คบใใ",
"+# floatๅใ่จฑใใช",
"+# numpyใฏpythonใง",
"-import numpy",
"-from copy import deepcopy",
"-answers = []",
"-for i in product([0, 1], repeat=d):",
"- new_lis = deepcopy(lis)",
"- point = 0",
"- problems = 0",
"- for j in range(d):",
"- if i[j] == 1:",
"- point += lis[j][1] + 100 * (j + 1) * (lis[j][0])",
"- problems += lis[j][0]",
"- new_lis[j][0] = 0",
"+pr = []",
"+for x in product([0, 1], repeat=d):",
"+ # print(x)",
"+ score = 0",
"+ pro = 0",
"+ for i in range(d):",
"+ if x[i] == 1:",
"+ score += 100 * (i + 1) * lis[i][0] + lis[i][1]",
"+ pro += lis[i][0]",
"+ if score >= g:",
"+ pr.append(pro)",
"+ else:",
"+ rest = g - score",
"+ # print(rest)",
"+ for i in range(d):",
"+ j = d - i - 1",
"+ if x[j] == 0:",
"+ pro += min(ceil(rest / (100 * (j + 1))), lis[j][0] - 1)",
"+ rest -= 100 * (j + 1) * min(ceil(rest / (100 * (j + 1))), lis[j][0] - 1)",
"+ if rest <= 0:",
"+ pr.append(pro)",
"+ break",
"- if new_lis[j][0] > 0:",
"- new_lis[j][0] -= 1",
"- # print(new_lis)",
"- flag = True",
"- for j in range(d):",
"- k = d - j - 1",
"- if point >= g:",
"- answers.append(problems)",
"- flag = False",
"- break",
"- else:",
"- req = (g - point) // (100 * (k + 1))",
"- # print(req)",
"- if new_lis[k][0] >= req:",
"- problems += req",
"- point += req * 100 * (k + 1)",
"- else:",
"- problems += new_lis[k][0]",
"- point += new_lis[k][0] * 100 * (k + 1)",
"- if point >= g and flag == True:",
"- answers.append(problems)",
"-# print(answers)",
"-print((min(answers)))",
"+ continue",
"+print((min(pr)))",
"+# print(pr)"
] | false | 0.087124 | 0.053415 | 1.631063 | [
"s843214641",
"s188179119"
] |
u738898077 | p02647 | python | s195579047 | s742191594 | 1,960 | 430 | 170,104 | 220,072 | Accepted | Accepted | 78.06 | n,k = list(map(int,input().split()))
a = list(map(int,input().split()))
imos = [0]*(2*10**5+1)
for j in range(min(k,700)):
imos = [0]*(2*10**5+1)
for i in range(n):
imos[max(i-a[i],0)] += 1
imos[min(i+a[i]+1,2*10**5)] -= 1
for i in range(1,n):
imos[i] += imos[i-1]
a = imos
print((*imos[:n])) | n,k = list(map(int,input().split()))
a = list(map(int,input().split()))
imos = [0]*(2*10**5+1)
for j in range(min(k,100)):
imos = [0]*(2*10**5+1)
for i in range(n):
imos[max(i-a[i],0)] += 1
imos[min(i+a[i]+1,2*10**5)] -= 1
for i in range(1,n):
imos[i] += imos[i-1]
a = imos
print((*imos[:n]))
| 12 | 12 | 335 | 336 | n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
imos = [0] * (2 * 10**5 + 1)
for j in range(min(k, 700)):
imos = [0] * (2 * 10**5 + 1)
for i in range(n):
imos[max(i - a[i], 0)] += 1
imos[min(i + a[i] + 1, 2 * 10**5)] -= 1
for i in range(1, n):
imos[i] += imos[i - 1]
a = imos
print((*imos[:n]))
| n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
imos = [0] * (2 * 10**5 + 1)
for j in range(min(k, 100)):
imos = [0] * (2 * 10**5 + 1)
for i in range(n):
imos[max(i - a[i], 0)] += 1
imos[min(i + a[i] + 1, 2 * 10**5)] -= 1
for i in range(1, n):
imos[i] += imos[i - 1]
a = imos
print((*imos[:n]))
| false | 0 | [
"-for j in range(min(k, 700)):",
"+for j in range(min(k, 100)):"
] | false | 0.039081 | 0.047556 | 0.821793 | [
"s195579047",
"s742191594"
] |
u729133443 | p03103 | python | s046512682 | s656779374 | 549 | 250 | 28,148 | 25,828 | Accepted | Accepted | 54.46 | I=lambda:list(map(int,input().split()));n,m=I();c=0
for a,b in sorted(I()for _ in[0]*n):c+=a*min(m,b);m=max(0,m-b)
print(c) | n,m,*t=list(map(int,open(0).read().split()));c=0
for a,b in sorted(zip(t[::2],t[1::2])):c+=a*min(m,b);m=max(0,m-b)
print(c) | 3 | 3 | 125 | 119 | I = lambda: list(map(int, input().split()))
n, m = I()
c = 0
for a, b in sorted(I() for _ in [0] * n):
c += a * min(m, b)
m = max(0, m - b)
print(c)
| n, m, *t = list(map(int, open(0).read().split()))
c = 0
for a, b in sorted(zip(t[::2], t[1::2])):
c += a * min(m, b)
m = max(0, m - b)
print(c)
| false | 0 | [
"-I = lambda: list(map(int, input().split()))",
"-n, m = I()",
"+n, m, *t = list(map(int, open(0).read().split()))",
"-for a, b in sorted(I() for _ in [0] * n):",
"+for a, b in sorted(zip(t[::2], t[1::2])):"
] | false | 0.042691 | 0.043128 | 0.989871 | [
"s046512682",
"s656779374"
] |
u626684023 | p02899 | python | s264905583 | s754247560 | 191 | 119 | 20,704 | 13,880 | Accepted | Accepted | 37.7 | N = int(input())
A = [int(i) for i in input().split()]
dic = {}
for i, j in enumerate(A):
dic[j] = i + 1
for k in range(1, N + 1):
print(dic[k], end = " ")
| N = int(eval(input()))
A = [int(i) for i in input().split()]
ans = [0] * N
for i in range(N):
ans[A[i] - 1] = i + 1
print((*ans)) | 7 | 6 | 169 | 130 | N = int(input())
A = [int(i) for i in input().split()]
dic = {}
for i, j in enumerate(A):
dic[j] = i + 1
for k in range(1, N + 1):
print(dic[k], end=" ")
| N = int(eval(input()))
A = [int(i) for i in input().split()]
ans = [0] * N
for i in range(N):
ans[A[i] - 1] = i + 1
print((*ans))
| false | 14.285714 | [
"-N = int(input())",
"+N = int(eval(input()))",
"-dic = {}",
"-for i, j in enumerate(A):",
"- dic[j] = i + 1",
"-for k in range(1, N + 1):",
"- print(dic[k], end=\" \")",
"+ans = [0] * N",
"+for i in range(N):",
"+ ans[A[i] - 1] = i + 1",
"+print((*ans))"
] | false | 0.099098 | 0.197416 | 0.501976 | [
"s264905583",
"s754247560"
] |
u930705402 | p02973 | python | s102340175 | s939147691 | 758 | 600 | 48,088 | 51,032 | Accepted | Accepted | 20.84 | from collections import deque
from bisect import bisect_left
N=int(eval(input()))
que=deque()
ans=0
for i in range(N):
a=int(eval(input()))
b=bisect_left(que,a)
if b-1<0:
que.appendleft(a)
ans+=1
else:
que[b-1]=a
print(ans) | from collections import deque
from bisect import bisect_left
N=int(eval(input()))
li=[]
ans=0
for i in range(N):
a=-int(eval(input()))
b=bisect_left(li,a+1)
if b==len(li):
li.append(a)
ans+=1
else:
li[b]=a
print(ans) | 14 | 14 | 264 | 257 | from collections import deque
from bisect import bisect_left
N = int(eval(input()))
que = deque()
ans = 0
for i in range(N):
a = int(eval(input()))
b = bisect_left(que, a)
if b - 1 < 0:
que.appendleft(a)
ans += 1
else:
que[b - 1] = a
print(ans)
| from collections import deque
from bisect import bisect_left
N = int(eval(input()))
li = []
ans = 0
for i in range(N):
a = -int(eval(input()))
b = bisect_left(li, a + 1)
if b == len(li):
li.append(a)
ans += 1
else:
li[b] = a
print(ans)
| false | 0 | [
"-que = deque()",
"+li = []",
"- a = int(eval(input()))",
"- b = bisect_left(que, a)",
"- if b - 1 < 0:",
"- que.appendleft(a)",
"+ a = -int(eval(input()))",
"+ b = bisect_left(li, a + 1)",
"+ if b == len(li):",
"+ li.append(a)",
"- que[b - 1] = a",
"+ li[b] = a"
] | false | 0.038667 | 0.117353 | 0.32949 | [
"s102340175",
"s939147691"
] |
u177411511 | p03240 | python | s556569627 | s394466412 | 625 | 38 | 3,064 | 3,064 | Accepted | Accepted | 93.92 | import sys
stdin = sys.stdin
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline().rstrip() # ignore trailing spaces
n = ni()
x_li = []
y_li = []
h_li = []
for i in range(n):
x, y, h = na()
x_li.append(x)
y_li.append(y)
h_li.append(h)
H = -1
ansX = -1
ansY = -1
flag = False
if h_li.count(0) == len(h_li) - 1:
idx = h_li.index(1)
print((x_li[idx], y_li[idx], h_li[idx]))
else:
for x in range(101):
for y in range(101):
for i in range(n):
tmp = h_li[i] + abs(x_li[i] - x) + abs(y_li[i] - y)
if H == -1 and h_li[i] != 0:
H = tmp
ansX = x
ansY = y
elif H == tmp or h_li[i] == 0:
if i == n - 1:
flag = True
break
else:
H = -1
break
if flag:
break
if flag:
break
print((ansX, ansY, H)) | import sys
stdin = sys.stdin
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline().rstrip() # ignore trailing spaces
n = ni()
x_li = []
y_li = []
h_li = []
for i in range(n):
x, y, h = na()
x_li.append(x)
y_li.append(y)
h_li.append(h)
ans = []
flag = False
for i in range(len(h_li)):
if h_li[i] > 0:
idx = i
break
for x in range(101):
for y in range(101):
H = h_li[idx] + abs(x_li[idx] - x) + abs(y_li[idx] - y)
for i in range(n):
if h_li[i] == max(H - abs(x_li[i] - x) - abs(y_li[i] - y), 0):
if i == n - 1:
flag = True
ans.append([x, y, H])
break
else:
break
if flag:
break
if flag:
break
print((*ans[0]))
| 46 | 39 | 1,111 | 905 | import sys
stdin = sys.stdin
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline().rstrip() # ignore trailing spaces
n = ni()
x_li = []
y_li = []
h_li = []
for i in range(n):
x, y, h = na()
x_li.append(x)
y_li.append(y)
h_li.append(h)
H = -1
ansX = -1
ansY = -1
flag = False
if h_li.count(0) == len(h_li) - 1:
idx = h_li.index(1)
print((x_li[idx], y_li[idx], h_li[idx]))
else:
for x in range(101):
for y in range(101):
for i in range(n):
tmp = h_li[i] + abs(x_li[i] - x) + abs(y_li[i] - y)
if H == -1 and h_li[i] != 0:
H = tmp
ansX = x
ansY = y
elif H == tmp or h_li[i] == 0:
if i == n - 1:
flag = True
break
else:
H = -1
break
if flag:
break
if flag:
break
print((ansX, ansY, H))
| import sys
stdin = sys.stdin
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline().rstrip() # ignore trailing spaces
n = ni()
x_li = []
y_li = []
h_li = []
for i in range(n):
x, y, h = na()
x_li.append(x)
y_li.append(y)
h_li.append(h)
ans = []
flag = False
for i in range(len(h_li)):
if h_li[i] > 0:
idx = i
break
for x in range(101):
for y in range(101):
H = h_li[idx] + abs(x_li[idx] - x) + abs(y_li[idx] - y)
for i in range(n):
if h_li[i] == max(H - abs(x_li[i] - x) - abs(y_li[i] - y), 0):
if i == n - 1:
flag = True
ans.append([x, y, H])
break
else:
break
if flag:
break
if flag:
break
print((*ans[0]))
| false | 15.217391 | [
"-H = -1",
"-ansX = -1",
"-ansY = -1",
"+ans = []",
"-if h_li.count(0) == len(h_li) - 1:",
"- idx = h_li.index(1)",
"- print((x_li[idx], y_li[idx], h_li[idx]))",
"-else:",
"- for x in range(101):",
"- for y in range(101):",
"- for i in range(n):",
"- tmp = h_li[i] + abs(x_li[i] - x) + abs(y_li[i] - y)",
"- if H == -1 and h_li[i] != 0:",
"- H = tmp",
"- ansX = x",
"- ansY = y",
"- elif H == tmp or h_li[i] == 0:",
"- if i == n - 1:",
"- flag = True",
"- break",
"- else:",
"- H = -1",
"+for i in range(len(h_li)):",
"+ if h_li[i] > 0:",
"+ idx = i",
"+ break",
"+for x in range(101):",
"+ for y in range(101):",
"+ H = h_li[idx] + abs(x_li[idx] - x) + abs(y_li[idx] - y)",
"+ for i in range(n):",
"+ if h_li[i] == max(H - abs(x_li[i] - x) - abs(y_li[i] - y), 0):",
"+ if i == n - 1:",
"+ flag = True",
"+ ans.append([x, y, H])",
"- if flag:",
"+ else:",
"- print((ansX, ansY, H))",
"+ if flag:",
"+ break",
"+print((*ans[0]))"
] | false | 0.182093 | 0.039016 | 4.667189 | [
"s556569627",
"s394466412"
] |
u330314953 | p03814 | python | s793440580 | s321276944 | 61 | 42 | 3,516 | 3,516 | Accepted | Accepted | 31.15 | s = str(eval(input()))
z = 0
a = s.find("A")
for i in range(len(s)):
if s[i] == "Z":
z = max(z,i)
print((z - a + 1)) | s = str(eval(input()))
cnt_1, cnt_2 = 0, 0
for i in range(len(s)):
if s[i] == 'A':
cnt_1 = i
break
for i in range(len(s)):
if s[i] == 'Z':
cnt_2 = i
print((cnt_2 - cnt_1 + 1)) | 11 | 10 | 129 | 208 | s = str(eval(input()))
z = 0
a = s.find("A")
for i in range(len(s)):
if s[i] == "Z":
z = max(z, i)
print((z - a + 1))
| s = str(eval(input()))
cnt_1, cnt_2 = 0, 0
for i in range(len(s)):
if s[i] == "A":
cnt_1 = i
break
for i in range(len(s)):
if s[i] == "Z":
cnt_2 = i
print((cnt_2 - cnt_1 + 1))
| false | 9.090909 | [
"-z = 0",
"-a = s.find(\"A\")",
"+cnt_1, cnt_2 = 0, 0",
"+for i in range(len(s)):",
"+ if s[i] == \"A\":",
"+ cnt_1 = i",
"+ break",
"- z = max(z, i)",
"-print((z - a + 1))",
"+ cnt_2 = i",
"+print((cnt_2 - cnt_1 + 1))"
] | false | 0.036757 | 0.040119 | 0.916191 | [
"s793440580",
"s321276944"
] |
u844005364 | p03013 | python | s535506098 | s160405361 | 199 | 183 | 7,848 | 13,192 | Accepted | Accepted | 8.04 | n, m = list(map(int, input().split()))
arr = [int(eval(input())) for _ in range(m)]
mod = 10 ** 9 + 7
dp = [0] * (n + 1)
dp[0] = 1
j = 0
for i in range(1, n + 1):
if j < m and i == arr[j]:
dp[i] = 0
j += 1
continue
if i == 1:
dp[1] = dp[0]
continue
dp[i] = dp[i - 1] + dp[i - 2]
dp[i] %= mod
print((dp[n]))
| n, m = list(map(int, input().split()))
arr = [int(eval(input())) for _ in range(m)]
broken = set(arr)
mod = 10 ** 9 + 7
dp = [0] * (n + 1)
dp[0] = 1
for i in range(1, n + 1):
if i in broken:
continue
if i == 1:
dp[1] = dp[0]
continue
dp[i] = dp[i - 1] + dp[i - 2]
dp[i] %= mod
print((dp[n]))
| 22 | 22 | 375 | 346 | n, m = list(map(int, input().split()))
arr = [int(eval(input())) for _ in range(m)]
mod = 10**9 + 7
dp = [0] * (n + 1)
dp[0] = 1
j = 0
for i in range(1, n + 1):
if j < m and i == arr[j]:
dp[i] = 0
j += 1
continue
if i == 1:
dp[1] = dp[0]
continue
dp[i] = dp[i - 1] + dp[i - 2]
dp[i] %= mod
print((dp[n]))
| n, m = list(map(int, input().split()))
arr = [int(eval(input())) for _ in range(m)]
broken = set(arr)
mod = 10**9 + 7
dp = [0] * (n + 1)
dp[0] = 1
for i in range(1, n + 1):
if i in broken:
continue
if i == 1:
dp[1] = dp[0]
continue
dp[i] = dp[i - 1] + dp[i - 2]
dp[i] %= mod
print((dp[n]))
| false | 0 | [
"+broken = set(arr)",
"-j = 0",
"- if j < m and i == arr[j]:",
"- dp[i] = 0",
"- j += 1",
"+ if i in broken:"
] | false | 0.046319 | 0.046019 | 1.006516 | [
"s535506098",
"s160405361"
] |
u532966492 | p02816 | python | s394195693 | s469366384 | 907 | 670 | 81,448 | 55,820 | Accepted | Accepted | 26.13 | def main():
mod, pow3, pow3i, p = 2**61-1, [1]*400001, [1]*200001, 1
i3 = pow(3, mod-2, mod)
for i in range(1, 400001):
pow3[i] = p = p*3 % mod
p = 1
for i in range(1, 200001):
pow3i[i] = p = p*i3 % mod
class rolling_hash():
def __init__(self, seq, char_list=None):
seq_size = self.seq_size = len(seq) # ๆๅญๅใฎ้ทใ
mod = self.mod = 2**61-1 # mod
Hash = self.Hash = [0]*(seq_size+1) # ๅ
้ ญใใi-1ๆๅญ็ฎใพใงใฎใใใทใฅๅค
for i in range(seq_size):
Hash[i+1] = (Hash[i] + (seq[i]+1) * pow3[i]) % mod
def calc_hash(self, l, r): # lๆๅญ็ฎใใr-1ๆๅญ็ฎใพใงใฎใใใทใฅๅค
return ((self.Hash[r]-self.Hash[l])*pow3i[l] % self.mod)
n = int(eval(input()))
a, b = list(map(int, input().split())), list(map(int, input().split()))
memo = []
a1 = rolling_hash([a[i-1] ^ a[i] for i in range(n)] +
[a[i-1] ^ a[i] for i in range(n)])
b_hash = rolling_hash([b[i-1] ^ b[i] for i in range(n)]).calc_hash(0, n)
for i in range(n):
if a1.calc_hash(i, i+n) == b_hash:
memo.append(i)
b0 = b[0]
for i in memo:
x = b0 ^ a[i]
print((i, x))
main()
| def main():
def z_algo(S):
n, i, j = len(S), 1, 0
a = [0]*n
a[0] = n
while i < n:
while i+j < n and S[i+j] == S[j]:
j += 1
if not j:
i += 1
continue
a[i], k = j, 1
while a[k] < j-k and i+k < n:
a[i+k] = a[k]
k += 1
i += k
j -= k
return a
n = int(eval(input()))
a, b = list(map(int, input().split())), list(map(int, input().split()))
a1 = [a[i-1] ^ a[i] for i in range(n)]
z = z_algo([b[i-1] ^ b[i] for i in range(n)]+a1+a1)
memo = []
for i in range(n):
if z[n+i] >= n:
memo.append(i)
b0 = b[0]
for i in memo:
print((i, b0 ^ a[i]))
main() | 37 | 33 | 1,239 | 820 | def main():
mod, pow3, pow3i, p = 2**61 - 1, [1] * 400001, [1] * 200001, 1
i3 = pow(3, mod - 2, mod)
for i in range(1, 400001):
pow3[i] = p = p * 3 % mod
p = 1
for i in range(1, 200001):
pow3i[i] = p = p * i3 % mod
class rolling_hash:
def __init__(self, seq, char_list=None):
seq_size = self.seq_size = len(seq) # ๆๅญๅใฎ้ทใ
mod = self.mod = 2**61 - 1 # mod
Hash = self.Hash = [0] * (seq_size + 1) # ๅ
้ ญใใi-1ๆๅญ็ฎใพใงใฎใใใทใฅๅค
for i in range(seq_size):
Hash[i + 1] = (Hash[i] + (seq[i] + 1) * pow3[i]) % mod
def calc_hash(self, l, r): # lๆๅญ็ฎใใr-1ๆๅญ็ฎใพใงใฎใใใทใฅๅค
return (self.Hash[r] - self.Hash[l]) * pow3i[l] % self.mod
n = int(eval(input()))
a, b = list(map(int, input().split())), list(map(int, input().split()))
memo = []
a1 = rolling_hash(
[a[i - 1] ^ a[i] for i in range(n)] + [a[i - 1] ^ a[i] for i in range(n)]
)
b_hash = rolling_hash([b[i - 1] ^ b[i] for i in range(n)]).calc_hash(0, n)
for i in range(n):
if a1.calc_hash(i, i + n) == b_hash:
memo.append(i)
b0 = b[0]
for i in memo:
x = b0 ^ a[i]
print((i, x))
main()
| def main():
def z_algo(S):
n, i, j = len(S), 1, 0
a = [0] * n
a[0] = n
while i < n:
while i + j < n and S[i + j] == S[j]:
j += 1
if not j:
i += 1
continue
a[i], k = j, 1
while a[k] < j - k and i + k < n:
a[i + k] = a[k]
k += 1
i += k
j -= k
return a
n = int(eval(input()))
a, b = list(map(int, input().split())), list(map(int, input().split()))
a1 = [a[i - 1] ^ a[i] for i in range(n)]
z = z_algo([b[i - 1] ^ b[i] for i in range(n)] + a1 + a1)
memo = []
for i in range(n):
if z[n + i] >= n:
memo.append(i)
b0 = b[0]
for i in memo:
print((i, b0 ^ a[i]))
main()
| false | 10.810811 | [
"- mod, pow3, pow3i, p = 2**61 - 1, [1] * 400001, [1] * 200001, 1",
"- i3 = pow(3, mod - 2, mod)",
"- for i in range(1, 400001):",
"- pow3[i] = p = p * 3 % mod",
"- p = 1",
"- for i in range(1, 200001):",
"- pow3i[i] = p = p * i3 % mod",
"-",
"- class rolling_hash:",
"- def __init__(self, seq, char_list=None):",
"- seq_size = self.seq_size = len(seq) # ๆๅญๅใฎ้ทใ",
"- mod = self.mod = 2**61 - 1 # mod",
"- Hash = self.Hash = [0] * (seq_size + 1) # ๅ
้ ญใใi-1ๆๅญ็ฎใพใงใฎใใใทใฅๅค",
"- for i in range(seq_size):",
"- Hash[i + 1] = (Hash[i] + (seq[i] + 1) * pow3[i]) % mod",
"-",
"- def calc_hash(self, l, r): # lๆๅญ็ฎใใr-1ๆๅญ็ฎใพใงใฎใใใทใฅๅค",
"- return (self.Hash[r] - self.Hash[l]) * pow3i[l] % self.mod",
"+ def z_algo(S):",
"+ n, i, j = len(S), 1, 0",
"+ a = [0] * n",
"+ a[0] = n",
"+ while i < n:",
"+ while i + j < n and S[i + j] == S[j]:",
"+ j += 1",
"+ if not j:",
"+ i += 1",
"+ continue",
"+ a[i], k = j, 1",
"+ while a[k] < j - k and i + k < n:",
"+ a[i + k] = a[k]",
"+ k += 1",
"+ i += k",
"+ j -= k",
"+ return a",
"+ a1 = [a[i - 1] ^ a[i] for i in range(n)]",
"+ z = z_algo([b[i - 1] ^ b[i] for i in range(n)] + a1 + a1)",
"- a1 = rolling_hash(",
"- [a[i - 1] ^ a[i] for i in range(n)] + [a[i - 1] ^ a[i] for i in range(n)]",
"- )",
"- b_hash = rolling_hash([b[i - 1] ^ b[i] for i in range(n)]).calc_hash(0, n)",
"- if a1.calc_hash(i, i + n) == b_hash:",
"+ if z[n + i] >= n:",
"- x = b0 ^ a[i]",
"- print((i, x))",
"+ print((i, b0 ^ a[i]))"
] | false | 0.303819 | 0.125612 | 2.418709 | [
"s394195693",
"s469366384"
] |
u869790980 | p03448 | python | s090231810 | s073190729 | 402 | 216 | 90,820 | 77,372 | Accepted | Accepted | 46.27 | a = int(input())
b = int(input())
c = int(input())
x = int(input())
def dfs(x, i, m, v):
if x < 0: return 0
if x == 0 or i == 3:
return 1 if x == 0 else 0
r = 0
for k in range(0, m[i] + 1): r += dfs(x - k * v[i], i + 1, m, v)
return r
m,v = {0:a,1:b,2:c}, {0:500,1:100,2:50}
print(dfs(x,0,m,v))
| m,v = {i: int(input()) for i in range(3)}, {0:500,1:100,2:50}
x = int(input())
def dfs(x, i, m, v):
if x < 0: return 0
if x == 0 or i == 3:
return 1 if x == 0 else 0
r = 0
for k in range(0, m[i] + 1): r += dfs(x - k * v[i], i + 1, m, v)
return r
print(dfs(x,0,m,v))
| 14 | 11 | 348 | 308 | a = int(input())
b = int(input())
c = int(input())
x = int(input())
def dfs(x, i, m, v):
if x < 0:
return 0
if x == 0 or i == 3:
return 1 if x == 0 else 0
r = 0
for k in range(0, m[i] + 1):
r += dfs(x - k * v[i], i + 1, m, v)
return r
m, v = {0: a, 1: b, 2: c}, {0: 500, 1: 100, 2: 50}
print(dfs(x, 0, m, v))
| m, v = {i: int(input()) for i in range(3)}, {0: 500, 1: 100, 2: 50}
x = int(input())
def dfs(x, i, m, v):
if x < 0:
return 0
if x == 0 or i == 3:
return 1 if x == 0 else 0
r = 0
for k in range(0, m[i] + 1):
r += dfs(x - k * v[i], i + 1, m, v)
return r
print(dfs(x, 0, m, v))
| false | 21.428571 | [
"-a = int(input())",
"-b = int(input())",
"-c = int(input())",
"+m, v = {i: int(input()) for i in range(3)}, {0: 500, 1: 100, 2: 50}",
"-m, v = {0: a, 1: b, 2: c}, {0: 500, 1: 100, 2: 50}"
] | false | 0.039345 | 0.039503 | 0.996012 | [
"s090231810",
"s073190729"
] |
u191874006 | p02727 | python | s100375379 | s701054870 | 502 | 366 | 105,324 | 100,076 | Accepted | Accepted | 27.09 | #!/usr/bin/env python3
import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(2147483647)
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()))
x, y, a, b, c = LI()
p = LI()
q = LI()
r = LI()
p.sort(reverse=1)
q.sort(reverse=1)
r.sort(reverse=1)
r = list(accumulate(r))
ans = 0
h = []
s = sum(p[:x])
s += sum(q[:y])
for i in p[:x]:
heappush(h, i)
for i in q[:y]:
heappush(h, i)
ans = s
for i in range(c):
if len(h) > 0:
f = heappop(h)
else:
break
s -= f
tmp = s + r[i]
ans = max(ans, tmp)
print(ans)
| #!/usr/bin/env python3
import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(2147483647)
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()))
x, y, a, b, c = LI()
p = LI()
q = LI()
r = LI()
p.sort(reverse=1)
q.sort(reverse=1)
A = p[:x] + q[:y] + r
A.sort(reverse=1)
print((sum(A[:x+y])))
| 46 | 30 | 987 | 716 | #!/usr/bin/env python3
import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(2147483647)
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()))
x, y, a, b, c = LI()
p = LI()
q = LI()
r = LI()
p.sort(reverse=1)
q.sort(reverse=1)
r.sort(reverse=1)
r = list(accumulate(r))
ans = 0
h = []
s = sum(p[:x])
s += sum(q[:y])
for i in p[:x]:
heappush(h, i)
for i in q[:y]:
heappush(h, i)
ans = s
for i in range(c):
if len(h) > 0:
f = heappop(h)
else:
break
s -= f
tmp = s + r[i]
ans = max(ans, tmp)
print(ans)
| #!/usr/bin/env python3
import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(2147483647)
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()))
x, y, a, b, c = LI()
p = LI()
q = LI()
r = LI()
p.sort(reverse=1)
q.sort(reverse=1)
A = p[:x] + q[:y] + r
A.sort(reverse=1)
print((sum(A[: x + y])))
| false | 34.782609 | [
"-r.sort(reverse=1)",
"-r = list(accumulate(r))",
"-ans = 0",
"-h = []",
"-s = sum(p[:x])",
"-s += sum(q[:y])",
"-for i in p[:x]:",
"- heappush(h, i)",
"-for i in q[:y]:",
"- heappush(h, i)",
"-ans = s",
"-for i in range(c):",
"- if len(h) > 0:",
"- f = heappop(h)",
"- else:",
"- break",
"- s -= f",
"- tmp = s + r[i]",
"- ans = max(ans, tmp)",
"-print(ans)",
"+A = p[:x] + q[:y] + r",
"+A.sort(reverse=1)",
"+print((sum(A[: x + y])))"
] | false | 0.035986 | 0.145519 | 0.247297 | [
"s100375379",
"s701054870"
] |
u297574184 | p03222 | python | s402813818 | s108206954 | 38 | 19 | 3,064 | 3,064 | Accepted | Accepted | 50 | MOD = 10**9 + 7
H, W, K = list(map(int, input().split()))
pats = []
for pat in range(1<<(W-1)):
for i in range(W-2):
if pat & (1<<i) and pat & (1<<(i+1)):
break
else:
pats.append(pat*2)
dp = [[0]*W for _ in range(H+1)]
dp[0][0] = 1
for i in range(H):
for j in range(W):
for pat in pats:
L = pat & (1<<j)
R = pat & (1<<(j+1))
if L == 0 and R == 0:
dp[i+1][j] += dp[i][j]
elif L != 0 and R == 0:
dp[i+1][j-1] += dp[i][j]
elif L == 0 and R != 0:
dp[i+1][j+1] += dp[i][j]
for j in range(W):
dp[i+1][j] %= MOD
print((dp[H][K-1]))
| MOD = 10**9 + 7
H, W, K = list(map(int, input().split()))
fibs = [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
def getFib(i):
return fibs[i+2]
numLs, numCs, numRs = [0]*W, [0]*W, [0]*W
for j in range(W):
numCs[j] = getFib(j-1) * getFib(W-1-j-1)
numLs[j] = getFib(j-2) * getFib(W-1-j-1)
numRs[j] = getFib(j-1) * getFib(W-1-j-2)
dp = [[0]*W for _ in range(H+1)]
dp[0][0] = 1
for i in range(H):
for j in range(W):
dp[i+1][j] += dp[i][j] * numCs[j]
if j > 0:
dp[i+1][j-1] += dp[i][j] * numLs[j]
if j < W-1:
dp[i+1][j+1] += dp[i][j] * numRs[j]
for j in range(W):
dp[i+1][j] %= MOD
print((dp[H][K-1]))
| 29 | 27 | 717 | 687 | MOD = 10**9 + 7
H, W, K = list(map(int, input().split()))
pats = []
for pat in range(1 << (W - 1)):
for i in range(W - 2):
if pat & (1 << i) and pat & (1 << (i + 1)):
break
else:
pats.append(pat * 2)
dp = [[0] * W for _ in range(H + 1)]
dp[0][0] = 1
for i in range(H):
for j in range(W):
for pat in pats:
L = pat & (1 << j)
R = pat & (1 << (j + 1))
if L == 0 and R == 0:
dp[i + 1][j] += dp[i][j]
elif L != 0 and R == 0:
dp[i + 1][j - 1] += dp[i][j]
elif L == 0 and R != 0:
dp[i + 1][j + 1] += dp[i][j]
for j in range(W):
dp[i + 1][j] %= MOD
print((dp[H][K - 1]))
| MOD = 10**9 + 7
H, W, K = list(map(int, input().split()))
fibs = [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
def getFib(i):
return fibs[i + 2]
numLs, numCs, numRs = [0] * W, [0] * W, [0] * W
for j in range(W):
numCs[j] = getFib(j - 1) * getFib(W - 1 - j - 1)
numLs[j] = getFib(j - 2) * getFib(W - 1 - j - 1)
numRs[j] = getFib(j - 1) * getFib(W - 1 - j - 2)
dp = [[0] * W for _ in range(H + 1)]
dp[0][0] = 1
for i in range(H):
for j in range(W):
dp[i + 1][j] += dp[i][j] * numCs[j]
if j > 0:
dp[i + 1][j - 1] += dp[i][j] * numLs[j]
if j < W - 1:
dp[i + 1][j + 1] += dp[i][j] * numRs[j]
for j in range(W):
dp[i + 1][j] %= MOD
print((dp[H][K - 1]))
| false | 6.896552 | [
"-pats = []",
"-for pat in range(1 << (W - 1)):",
"- for i in range(W - 2):",
"- if pat & (1 << i) and pat & (1 << (i + 1)):",
"- break",
"- else:",
"- pats.append(pat * 2)",
"+fibs = [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]",
"+",
"+",
"+def getFib(i):",
"+ return fibs[i + 2]",
"+",
"+",
"+numLs, numCs, numRs = [0] * W, [0] * W, [0] * W",
"+for j in range(W):",
"+ numCs[j] = getFib(j - 1) * getFib(W - 1 - j - 1)",
"+ numLs[j] = getFib(j - 2) * getFib(W - 1 - j - 1)",
"+ numRs[j] = getFib(j - 1) * getFib(W - 1 - j - 2)",
"- for pat in pats:",
"- L = pat & (1 << j)",
"- R = pat & (1 << (j + 1))",
"- if L == 0 and R == 0:",
"- dp[i + 1][j] += dp[i][j]",
"- elif L != 0 and R == 0:",
"- dp[i + 1][j - 1] += dp[i][j]",
"- elif L == 0 and R != 0:",
"- dp[i + 1][j + 1] += dp[i][j]",
"+ dp[i + 1][j] += dp[i][j] * numCs[j]",
"+ if j > 0:",
"+ dp[i + 1][j - 1] += dp[i][j] * numLs[j]",
"+ if j < W - 1:",
"+ dp[i + 1][j + 1] += dp[i][j] * numRs[j]"
] | false | 0.157926 | 0.08569 | 1.842998 | [
"s402813818",
"s108206954"
] |
u796942881 | p02947 | python | s578838279 | s556919095 | 332 | 193 | 32,000 | 21,632 | Accepted | Accepted | 41.87 | from collections import Counter
# ใใผใธใงใณ0.14.0ใพใง scipy.misc.comb()
# ใใผใธใงใณ0.14.0ใใ scipy.special.comb()
from scipy.misc import comb
# from scipy.special import comb
def main():
s = Counter(["".join(sorted(i)) for i in open(0).read().split()[1:]])
ans = 0
for v in list(s.values()):
ans += comb(v, 2, exact=True)
print((int(ans)))
return
main()
| from collections import defaultdict
def main():
s = ["".join(sorted(i)) for i in open(0).read().split()[1:]]
d = defaultdict(lambda: 0)
ans = 0
for i in s:
ans += d[i]
d[i] += 1
print(ans)
return
main()
| 17 | 15 | 383 | 261 | from collections import Counter
# ใใผใธใงใณ0.14.0ใพใง scipy.misc.comb()
# ใใผใธใงใณ0.14.0ใใ scipy.special.comb()
from scipy.misc import comb
# from scipy.special import comb
def main():
s = Counter(["".join(sorted(i)) for i in open(0).read().split()[1:]])
ans = 0
for v in list(s.values()):
ans += comb(v, 2, exact=True)
print((int(ans)))
return
main()
| from collections import defaultdict
def main():
s = ["".join(sorted(i)) for i in open(0).read().split()[1:]]
d = defaultdict(lambda: 0)
ans = 0
for i in s:
ans += d[i]
d[i] += 1
print(ans)
return
main()
| false | 11.764706 | [
"-from collections import Counter",
"+from collections import defaultdict",
"-# ใใผใธใงใณ0.14.0ใพใง scipy.misc.comb()",
"-# ใใผใธใงใณ0.14.0ใใ scipy.special.comb()",
"-from scipy.misc import comb",
"-# from scipy.special import comb",
"- s = Counter([\"\".join(sorted(i)) for i in open(0).read().split()[1:]])",
"+ s = [\"\".join(sorted(i)) for i in open(0).read().split()[1:]]",
"+ d = defaultdict(lambda: 0)",
"- for v in list(s.values()):",
"- ans += comb(v, 2, exact=True)",
"- print((int(ans)))",
"+ for i in s:",
"+ ans += d[i]",
"+ d[i] += 1",
"+ print(ans)"
] | false | 0.266216 | 0.043502 | 6.119697 | [
"s578838279",
"s556919095"
] |
u462329577 | p03047 | python | s942852792 | s630407179 | 162 | 18 | 38,384 | 2,940 | Accepted | Accepted | 88.89 | #!/usr/bin/env python3
n,k = list(map(int,input().split()))
print((n-k+1)) | n,k = list(map(int,input().split()))
print((max(0,n-k+1))) | 3 | 2 | 68 | 51 | #!/usr/bin/env python3
n, k = list(map(int, input().split()))
print((n - k + 1))
| n, k = list(map(int, input().split()))
print((max(0, n - k + 1)))
| false | 33.333333 | [
"-#!/usr/bin/env python3",
"-print((n - k + 1))",
"+print((max(0, n - k + 1)))"
] | false | 0.034489 | 0.035062 | 0.983649 | [
"s942852792",
"s630407179"
] |
u556589653 | p02801 | python | s535738530 | s456057840 | 28 | 25 | 8,972 | 8,720 | Accepted | Accepted | 10.71 | K = ord(eval(input()))
print((chr(K+1))) | print((chr(ord(eval(input()))+1))) | 2 | 1 | 33 | 26 | K = ord(eval(input()))
print((chr(K + 1)))
| print((chr(ord(eval(input())) + 1)))
| false | 50 | [
"-K = ord(eval(input()))",
"-print((chr(K + 1)))",
"+print((chr(ord(eval(input())) + 1)))"
] | false | 0.045589 | 0.045405 | 1.004055 | [
"s535738530",
"s456057840"
] |
u535423069 | p03598 | python | s062906421 | s044035008 | 21 | 18 | 3,316 | 3,064 | Accepted | Accepted | 14.29 | # Author: cr4zjh0bp
# Created: Sat Mar 14 11:48:11 UTC 2020
import sys
stdin = sys.stdin
inf = 1 << 60
mod = 1000000007
ni = lambda: int(ns())
nin = lambda y: [ni() for _ in range(y)]
na = lambda: list(map(int, stdin.readline().split()))
nan = lambda y: [na() for _ in range(y)]
nf = lambda: float(ns())
nfn = lambda y: [nf() for _ in range(y)]
nfa = lambda: list(map(float, stdin.readline().split()))
nfan = lambda y: [nfa() for _ in range(y)]
ns = lambda: stdin.readline().rstrip()
nsn = lambda y: [ns() for _ in range(y)]
ncl = lambda y: [list(ns()) for _ in range(y)]
nas = lambda: stdin.readline().split()
n, k = nin(2)
x = na()
ans = 0
for i in range(n):
ans += min(abs(x[i] - k) * 2, abs(x[i]) * 2)
print(ans) | import sys
stdin = sys.stdin
inf = 1 << 60
mod = 1000000007
ni = lambda: int(ns())
nin = lambda y: [ni() for _ in range(y)]
na = lambda: list(map(int, stdin.readline().split()))
nan = lambda y: [na() for _ in range(y)]
nf = lambda: float(ns())
nfn = lambda y: [nf() for _ in range(y)]
nfa = lambda: list(map(float, stdin.readline().split()))
nfan = lambda y: [nfa() for _ in range(y)]
ns = lambda: stdin.readline().rstrip()
nsn = lambda y: [ns() for _ in range(y)]
ncl = lambda y: [list(ns()) for _ in range(y)]
nas = lambda: stdin.readline().split()
n = ni()
k = ni()
x = na()
ans = 0
for i in range(n):
ans += min(abs(x[i]) * 2, abs(x[i] - k) * 2)
print(ans) | 29 | 27 | 755 | 745 | # Author: cr4zjh0bp
# Created: Sat Mar 14 11:48:11 UTC 2020
import sys
stdin = sys.stdin
inf = 1 << 60
mod = 1000000007
ni = lambda: int(ns())
nin = lambda y: [ni() for _ in range(y)]
na = lambda: list(map(int, stdin.readline().split()))
nan = lambda y: [na() for _ in range(y)]
nf = lambda: float(ns())
nfn = lambda y: [nf() for _ in range(y)]
nfa = lambda: list(map(float, stdin.readline().split()))
nfan = lambda y: [nfa() for _ in range(y)]
ns = lambda: stdin.readline().rstrip()
nsn = lambda y: [ns() for _ in range(y)]
ncl = lambda y: [list(ns()) for _ in range(y)]
nas = lambda: stdin.readline().split()
n, k = nin(2)
x = na()
ans = 0
for i in range(n):
ans += min(abs(x[i] - k) * 2, abs(x[i]) * 2)
print(ans)
| import sys
stdin = sys.stdin
inf = 1 << 60
mod = 1000000007
ni = lambda: int(ns())
nin = lambda y: [ni() for _ in range(y)]
na = lambda: list(map(int, stdin.readline().split()))
nan = lambda y: [na() for _ in range(y)]
nf = lambda: float(ns())
nfn = lambda y: [nf() for _ in range(y)]
nfa = lambda: list(map(float, stdin.readline().split()))
nfan = lambda y: [nfa() for _ in range(y)]
ns = lambda: stdin.readline().rstrip()
nsn = lambda y: [ns() for _ in range(y)]
ncl = lambda y: [list(ns()) for _ in range(y)]
nas = lambda: stdin.readline().split()
n = ni()
k = ni()
x = na()
ans = 0
for i in range(n):
ans += min(abs(x[i]) * 2, abs(x[i] - k) * 2)
print(ans)
| false | 6.896552 | [
"-# Author: cr4zjh0bp",
"-# Created: Sat Mar 14 11:48:11 UTC 2020",
"-n, k = nin(2)",
"+n = ni()",
"+k = ni()",
"- ans += min(abs(x[i] - k) * 2, abs(x[i]) * 2)",
"+ ans += min(abs(x[i]) * 2, abs(x[i] - k) * 2)"
] | false | 0.038472 | 0.035151 | 1.094472 | [
"s062906421",
"s044035008"
] |
u983918956 | p03503 | python | s971473266 | s341885840 | 255 | 219 | 3,064 | 3,064 | Accepted | Accepted | 14.12 | import itertools
N = int(eval(input()))
F = [list(map(int,input().split())) for i in range(N)]
P = [list(map(int,input().split())) for i in range(N)]
b = [0,1]
ans = -float('inf')
for e in itertools.product(b,repeat=10):
e = list(e)
if e == [0]*10:
continue
res = 0
for i in range(N):
cnt = 0
for j in range(10):
if e[j] == 1 and F[i][j] == 1:
cnt += 1
res += P[i][cnt]
if res > ans:
ans = res
print(ans) | import itertools
inf = float('inf')
N = int(eval(input()))
F = [list(map(int,input().split())) for _ in range(N)]
P = [list(map(int,input().split())) for _ in range(N)]
ans = -inf
for shift in itertools.product([0,1],repeat=10):
if not any(shift): continue
res = 0
for i,line in enumerate(F):
c = 0
for s, f in zip(shift, line):
if s and f:
c += 1
res += P[i][c]
if res > ans:
ans = res
print(ans) | 20 | 22 | 505 | 492 | import itertools
N = int(eval(input()))
F = [list(map(int, input().split())) for i in range(N)]
P = [list(map(int, input().split())) for i in range(N)]
b = [0, 1]
ans = -float("inf")
for e in itertools.product(b, repeat=10):
e = list(e)
if e == [0] * 10:
continue
res = 0
for i in range(N):
cnt = 0
for j in range(10):
if e[j] == 1 and F[i][j] == 1:
cnt += 1
res += P[i][cnt]
if res > ans:
ans = res
print(ans)
| import itertools
inf = float("inf")
N = int(eval(input()))
F = [list(map(int, input().split())) for _ in range(N)]
P = [list(map(int, input().split())) for _ in range(N)]
ans = -inf
for shift in itertools.product([0, 1], repeat=10):
if not any(shift):
continue
res = 0
for i, line in enumerate(F):
c = 0
for s, f in zip(shift, line):
if s and f:
c += 1
res += P[i][c]
if res > ans:
ans = res
print(ans)
| false | 9.090909 | [
"+inf = float(\"inf\")",
"-F = [list(map(int, input().split())) for i in range(N)]",
"-P = [list(map(int, input().split())) for i in range(N)]",
"-b = [0, 1]",
"-ans = -float(\"inf\")",
"-for e in itertools.product(b, repeat=10):",
"- e = list(e)",
"- if e == [0] * 10:",
"+F = [list(map(int, input().split())) for _ in range(N)]",
"+P = [list(map(int, input().split())) for _ in range(N)]",
"+ans = -inf",
"+for shift in itertools.product([0, 1], repeat=10):",
"+ if not any(shift):",
"- for i in range(N):",
"- cnt = 0",
"- for j in range(10):",
"- if e[j] == 1 and F[i][j] == 1:",
"- cnt += 1",
"- res += P[i][cnt]",
"+ for i, line in enumerate(F):",
"+ c = 0",
"+ for s, f in zip(shift, line):",
"+ if s and f:",
"+ c += 1",
"+ res += P[i][c]"
] | false | 0.046897 | 0.118492 | 0.395786 | [
"s971473266",
"s341885840"
] |
u761320129 | p02596 | python | s935202446 | s770834383 | 370 | 277 | 9,168 | 9,148 | Accepted | Accepted | 25.14 | K = int(eval(input()))
n = 7%K
r = 1
for i in range(10**6+5):
if n==0:
print((i+1))
exit()
r *= 10
n += r*7
r %= K
n %= K
#print(r,n)
print((-1)) | K = int(eval(input()))
k = 1
a = 7
for i in range(10**6+5):
if a%K == 0:
print(k)
exit()
a = (a*10 + 7) % K
k += 1
print((-1)) | 13 | 12 | 187 | 163 | K = int(eval(input()))
n = 7 % K
r = 1
for i in range(10**6 + 5):
if n == 0:
print((i + 1))
exit()
r *= 10
n += r * 7
r %= K
n %= K
# print(r,n)
print((-1))
| K = int(eval(input()))
k = 1
a = 7
for i in range(10**6 + 5):
if a % K == 0:
print(k)
exit()
a = (a * 10 + 7) % K
k += 1
print((-1))
| false | 7.692308 | [
"-n = 7 % K",
"-r = 1",
"+k = 1",
"+a = 7",
"- if n == 0:",
"- print((i + 1))",
"+ if a % K == 0:",
"+ print(k)",
"- r *= 10",
"- n += r * 7",
"- r %= K",
"- n %= K",
"- # print(r,n)",
"+ a = (a * 10 + 7) % K",
"+ k += 1"
] | false | 0.308457 | 0.185485 | 1.662981 | [
"s935202446",
"s770834383"
] |
u569960318 | p02408 | python | s314119824 | s219750235 | 50 | 20 | 7,736 | 7,708 | Accepted | Accepted | 60 | n = int(eval(input()))
full_set=set([x for x in range(1,14)])
cards={"S":[],"H":[],"C":[],"D":[]}
for i in range(n):
suit,num = input().split()
cards[suit].append(int(num))
for suit in ["S","H","C","D"]:
suit_set = set(cards[suit])
for num in sorted(list(full_set - suit_set)): print((suit,num)) | n = int(eval(input()))
cards = [[ s+' '+str(n) for n in range(1,14)] for s in ['S','H','C','D']]
for _ in range(n):
suit,num = input().split()
if suit=='S': cards[0][int(num)-1] = 0
elif suit=='H': cards[1][int(num)-1] = 0
elif suit=='C': cards[2][int(num)-1] = 0
elif suit=='D': cards[3][int(num)-1] = 0
for s in cards:
for n in s:
if n!=0: print(n) | 9 | 11 | 311 | 388 | n = int(eval(input()))
full_set = set([x for x in range(1, 14)])
cards = {"S": [], "H": [], "C": [], "D": []}
for i in range(n):
suit, num = input().split()
cards[suit].append(int(num))
for suit in ["S", "H", "C", "D"]:
suit_set = set(cards[suit])
for num in sorted(list(full_set - suit_set)):
print((suit, num))
| n = int(eval(input()))
cards = [[s + " " + str(n) for n in range(1, 14)] for s in ["S", "H", "C", "D"]]
for _ in range(n):
suit, num = input().split()
if suit == "S":
cards[0][int(num) - 1] = 0
elif suit == "H":
cards[1][int(num) - 1] = 0
elif suit == "C":
cards[2][int(num) - 1] = 0
elif suit == "D":
cards[3][int(num) - 1] = 0
for s in cards:
for n in s:
if n != 0:
print(n)
| false | 18.181818 | [
"-full_set = set([x for x in range(1, 14)])",
"-cards = {\"S\": [], \"H\": [], \"C\": [], \"D\": []}",
"-for i in range(n):",
"+cards = [[s + \" \" + str(n) for n in range(1, 14)] for s in [\"S\", \"H\", \"C\", \"D\"]]",
"+for _ in range(n):",
"- cards[suit].append(int(num))",
"-for suit in [\"S\", \"H\", \"C\", \"D\"]:",
"- suit_set = set(cards[suit])",
"- for num in sorted(list(full_set - suit_set)):",
"- print((suit, num))",
"+ if suit == \"S\":",
"+ cards[0][int(num) - 1] = 0",
"+ elif suit == \"H\":",
"+ cards[1][int(num) - 1] = 0",
"+ elif suit == \"C\":",
"+ cards[2][int(num) - 1] = 0",
"+ elif suit == \"D\":",
"+ cards[3][int(num) - 1] = 0",
"+for s in cards:",
"+ for n in s:",
"+ if n != 0:",
"+ print(n)"
] | false | 0.109987 | 0.040054 | 2.745995 | [
"s314119824",
"s219750235"
] |
u981931040 | p03845 | python | s506162763 | s468120173 | 29 | 26 | 9,160 | 9,144 | Accepted | Accepted | 10.34 | question_num = int(eval(input()))
Time = list(map(int, input().split()))
drink_num = int(eval(input()))
spent_time = sum(Time)
drink =[]
for _ in range(drink_num):
p, x = list(map(int, input().split()))
drink.append([p, x])
for p, x in drink:
print((spent_time - (Time[p - 1] - x))) | question_num = int(eval(input()))
Time = list(map(int, input().split()))
drink_num = int(eval(input()))
spent_time = sum(Time)
drink =[]
for _ in range(drink_num):
p, x = list(map(int, input().split()))
print((spent_time - (Time[p - 1] - x))) | 10 | 8 | 283 | 237 | question_num = int(eval(input()))
Time = list(map(int, input().split()))
drink_num = int(eval(input()))
spent_time = sum(Time)
drink = []
for _ in range(drink_num):
p, x = list(map(int, input().split()))
drink.append([p, x])
for p, x in drink:
print((spent_time - (Time[p - 1] - x)))
| question_num = int(eval(input()))
Time = list(map(int, input().split()))
drink_num = int(eval(input()))
spent_time = sum(Time)
drink = []
for _ in range(drink_num):
p, x = list(map(int, input().split()))
print((spent_time - (Time[p - 1] - x)))
| false | 20 | [
"- drink.append([p, x])",
"-for p, x in drink:"
] | false | 0.041967 | 0.042978 | 0.976485 | [
"s506162763",
"s468120173"
] |
u505830998 | p03592 | python | s347938576 | s266305242 | 164 | 67 | 9,240 | 64,236 | Accepted | Accepted | 59.15 | import sys
input_methods=['clipboard','file','key']
using_method=0
input_method=input_methods[using_method]
tin=lambda : list(map(int, input().split()))
lin=lambda : list(tin())
mod=1000000007
#+++++
def main():
#a = int(input())
n, m, k = tin()
#s = input()
for ni in range(n+1):
for mi in range(m+1):
bn = ni*(m-mi) + (n-ni)*(mi)
if bn == k:
return 'Yes'
return 'No'
#+++++
isTest=False
def pa(v):
if isTest:
print(v)
def input_clipboard():
import clipboard
input_text=clipboard.get()
input_l=input_text.splitlines()
for l in input_l:
yield l
if __name__ == "__main__":
if sys.platform =='ios':
if input_method==input_methods[0]:
ic=input_clipboard()
input = lambda : ic.__next__()
elif input_method==input_methods[1]:
sys.stdin=open('inputFile.txt')
else:
pass
isTest=True
else:
pass
#input = sys.stdin.readline
ret = main()
if ret is not None:
print(ret) | import sys
input_methods=['clipboard','file','key']
using_method=0
input_method=input_methods[using_method]
tin=lambda : list(map(int, input().split()))
lin=lambda : list(tin())
mod=1000000007
#+++++
def main():
#n = int(input())
n, m, k = tin()
#s = input()
for ni in range(n+1):
for mi in range(m+1):
nb = ni*(m-mi) + (n-ni)*mi
if k == nb:
return 'Yes'
return 'No'
#+++++
isTest=False
def pa(v):
if isTest:
print(v)
def input_clipboard():
import clipboard
input_text=clipboard.get()
input_l=input_text.splitlines()
for l in input_l:
yield l
if __name__ == "__main__":
if sys.platform =='ios':
if input_method==input_methods[0]:
ic=input_clipboard()
input = lambda : ic.__next__()
elif input_method==input_methods[1]:
sys.stdin=open('inputFile.txt')
else:
pass
isTest=True
else:
pass
#input = sys.stdin.readline
ret = main()
if ret is not None:
print(ret) | 55 | 56 | 979 | 979 | import sys
input_methods = ["clipboard", "file", "key"]
using_method = 0
input_method = input_methods[using_method]
tin = lambda: list(map(int, input().split()))
lin = lambda: list(tin())
mod = 1000000007
# +++++
def main():
# a = int(input())
n, m, k = tin()
# s = input()
for ni in range(n + 1):
for mi in range(m + 1):
bn = ni * (m - mi) + (n - ni) * (mi)
if bn == k:
return "Yes"
return "No"
# +++++
isTest = False
def pa(v):
if isTest:
print(v)
def input_clipboard():
import clipboard
input_text = clipboard.get()
input_l = input_text.splitlines()
for l in input_l:
yield l
if __name__ == "__main__":
if sys.platform == "ios":
if input_method == input_methods[0]:
ic = input_clipboard()
input = lambda: ic.__next__()
elif input_method == input_methods[1]:
sys.stdin = open("inputFile.txt")
else:
pass
isTest = True
else:
pass
# input = sys.stdin.readline
ret = main()
if ret is not None:
print(ret)
| import sys
input_methods = ["clipboard", "file", "key"]
using_method = 0
input_method = input_methods[using_method]
tin = lambda: list(map(int, input().split()))
lin = lambda: list(tin())
mod = 1000000007
# +++++
def main():
# n = int(input())
n, m, k = tin()
# s = input()
for ni in range(n + 1):
for mi in range(m + 1):
nb = ni * (m - mi) + (n - ni) * mi
if k == nb:
return "Yes"
return "No"
# +++++
isTest = False
def pa(v):
if isTest:
print(v)
def input_clipboard():
import clipboard
input_text = clipboard.get()
input_l = input_text.splitlines()
for l in input_l:
yield l
if __name__ == "__main__":
if sys.platform == "ios":
if input_method == input_methods[0]:
ic = input_clipboard()
input = lambda: ic.__next__()
elif input_method == input_methods[1]:
sys.stdin = open("inputFile.txt")
else:
pass
isTest = True
else:
pass
# input = sys.stdin.readline
ret = main()
if ret is not None:
print(ret)
| false | 1.785714 | [
"- # a = int(input())",
"+ # n = int(input())",
"- bn = ni * (m - mi) + (n - ni) * (mi)",
"- if bn == k:",
"+ nb = ni * (m - mi) + (n - ni) * mi",
"+ if k == nb:"
] | false | 0.0363 | 0.035382 | 1.025952 | [
"s347938576",
"s266305242"
] |
u112247039 | p02755 | python | s379220136 | s851474686 | 32 | 27 | 9,172 | 9,184 | Accepted | Accepted | 15.62 | a,b = list(map(int,input().split()))
for i in range(1,1251):
if int(i*0.08)==a and int(i*0.1)==b:
print(i); break
else:
print('-1') | a,b = list(map(int,input().split()))
low = int(min(a//0.08,b//0.1))
high = int(max((a+1)//0.08,(b+1)//0.1))
for i in range(low,high+1):
if int(i*0.08)==a and int(i*0.1)==b:
print(i); break
else:
print((-1)) | 6 | 8 | 146 | 222 | a, b = list(map(int, input().split()))
for i in range(1, 1251):
if int(i * 0.08) == a and int(i * 0.1) == b:
print(i)
break
else:
print("-1")
| a, b = list(map(int, input().split()))
low = int(min(a // 0.08, b // 0.1))
high = int(max((a + 1) // 0.08, (b + 1) // 0.1))
for i in range(low, high + 1):
if int(i * 0.08) == a and int(i * 0.1) == b:
print(i)
break
else:
print((-1))
| false | 25 | [
"-for i in range(1, 1251):",
"+low = int(min(a // 0.08, b // 0.1))",
"+high = int(max((a + 1) // 0.08, (b + 1) // 0.1))",
"+for i in range(low, high + 1):",
"- print(\"-1\")",
"+ print((-1))"
] | false | 0.037309 | 0.076183 | 0.489724 | [
"s379220136",
"s851474686"
] |
u644907318 | p03151 | python | s768786639 | s084588760 | 279 | 128 | 85,424 | 102,756 | Accepted | Accepted | 54.12 | N = int(eval(input()))
A = list(map(int,input().split()))
B = list(map(int,input().split()))
C = sorted([A[i]-B[i] for i in range(N)])
tot = sum(C)
cnt = 0
if tot<0:
cnt = -1
else:
a = 0
for i in range(N):
if C[i]<0:
a += C[i]
cnt += 1
else:
break
for i in range(N-1,-1,-1):
if a>=0:break
a += C[i]
cnt += 1
print(cnt) | N = int(eval(input()))
A = list(map(int,input().split()))
B = list(map(int,input().split()))
P = sorted([A[i]-B[i] for i in range(N) if A[i]-B[i]>0],reverse=True)
C = [0 for _ in range(N+1)]
for i in range(1,len(P)+1):
C[i] = C[i-1]+P[i-1]
M = [B[i]-A[i] for i in range(N) if B[i]-A[i]>0]
p = sum(P)
m = sum(M)
if m>p:
ans = -1
else:
if len(M)==0:
ans = 0
else:
for i in range(1,len(P)+1):
if C[i]>=m:
ans = i
break
ans += len(M)
print(ans) | 21 | 22 | 424 | 539 | N = int(eval(input()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = sorted([A[i] - B[i] for i in range(N)])
tot = sum(C)
cnt = 0
if tot < 0:
cnt = -1
else:
a = 0
for i in range(N):
if C[i] < 0:
a += C[i]
cnt += 1
else:
break
for i in range(N - 1, -1, -1):
if a >= 0:
break
a += C[i]
cnt += 1
print(cnt)
| N = int(eval(input()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
P = sorted([A[i] - B[i] for i in range(N) if A[i] - B[i] > 0], reverse=True)
C = [0 for _ in range(N + 1)]
for i in range(1, len(P) + 1):
C[i] = C[i - 1] + P[i - 1]
M = [B[i] - A[i] for i in range(N) if B[i] - A[i] > 0]
p = sum(P)
m = sum(M)
if m > p:
ans = -1
else:
if len(M) == 0:
ans = 0
else:
for i in range(1, len(P) + 1):
if C[i] >= m:
ans = i
break
ans += len(M)
print(ans)
| false | 4.545455 | [
"-C = sorted([A[i] - B[i] for i in range(N)])",
"-tot = sum(C)",
"-cnt = 0",
"-if tot < 0:",
"- cnt = -1",
"+P = sorted([A[i] - B[i] for i in range(N) if A[i] - B[i] > 0], reverse=True)",
"+C = [0 for _ in range(N + 1)]",
"+for i in range(1, len(P) + 1):",
"+ C[i] = C[i - 1] + P[i - 1]",
"+M = [B[i] - A[i] for i in range(N) if B[i] - A[i] > 0]",
"+p = sum(P)",
"+m = sum(M)",
"+if m > p:",
"+ ans = -1",
"- a = 0",
"- for i in range(N):",
"- if C[i] < 0:",
"- a += C[i]",
"- cnt += 1",
"- else:",
"- break",
"- for i in range(N - 1, -1, -1):",
"- if a >= 0:",
"- break",
"- a += C[i]",
"- cnt += 1",
"-print(cnt)",
"+ if len(M) == 0:",
"+ ans = 0",
"+ else:",
"+ for i in range(1, len(P) + 1):",
"+ if C[i] >= m:",
"+ ans = i",
"+ break",
"+ ans += len(M)",
"+print(ans)"
] | false | 0.041475 | 0.068643 | 0.604218 | [
"s768786639",
"s084588760"
] |
u313117448 | p03478 | python | s464112949 | s142364981 | 162 | 71 | 68,904 | 73,084 | Accepted | Accepted | 56.17 | inp = list(map(int,input().split()))
N = inp[0]
A = inp[1]
B = inp[2]
l=list()
for i in range(N+1):
n0 = i % 10
n1 = (i % 100 - n0) // 10
n2 = (i % 1000 - n0 - n1*10) // 100
n3 = (i % 10000 - n0 - n1*10 - n2*100) // 1000
n4 = (i % 100000 - n0 - n1*10 - n2*100 - n3*1000) // 10000
if A <= n0+n1+n2+n3+n4 <= B:
l.append(i)
print((sum(l))) | def FindSumOfDigits(n):
s = 0
while n > 0:
s = s + n % 10
n = n // 10
return s
inp = list(map(int,input().split()))
N = inp[0]
A = inp[1]
B = inp[2]
l=list()
sd = 0
for i in range(N+1):
x = FindSumOfDigits(i)
if A <= x <= B:
sd = sd + i
print(sd) | 14 | 20 | 379 | 323 | inp = list(map(int, input().split()))
N = inp[0]
A = inp[1]
B = inp[2]
l = list()
for i in range(N + 1):
n0 = i % 10
n1 = (i % 100 - n0) // 10
n2 = (i % 1000 - n0 - n1 * 10) // 100
n3 = (i % 10000 - n0 - n1 * 10 - n2 * 100) // 1000
n4 = (i % 100000 - n0 - n1 * 10 - n2 * 100 - n3 * 1000) // 10000
if A <= n0 + n1 + n2 + n3 + n4 <= B:
l.append(i)
print((sum(l)))
| def FindSumOfDigits(n):
s = 0
while n > 0:
s = s + n % 10
n = n // 10
return s
inp = list(map(int, input().split()))
N = inp[0]
A = inp[1]
B = inp[2]
l = list()
sd = 0
for i in range(N + 1):
x = FindSumOfDigits(i)
if A <= x <= B:
sd = sd + i
print(sd)
| false | 30 | [
"+def FindSumOfDigits(n):",
"+ s = 0",
"+ while n > 0:",
"+ s = s + n % 10",
"+ n = n // 10",
"+ return s",
"+",
"+",
"+sd = 0",
"- n0 = i % 10",
"- n1 = (i % 100 - n0) // 10",
"- n2 = (i % 1000 - n0 - n1 * 10) // 100",
"- n3 = (i % 10000 - n0 - n1 * 10 - n2 * 100) // 1000",
"- n4 = (i % 100000 - n0 - n1 * 10 - n2 * 100 - n3 * 1000) // 10000",
"- if A <= n0 + n1 + n2 + n3 + n4 <= B:",
"- l.append(i)",
"-print((sum(l)))",
"+ x = FindSumOfDigits(i)",
"+ if A <= x <= B:",
"+ sd = sd + i",
"+print(sd)"
] | false | 0.034416 | 0.070681 | 0.486914 | [
"s464112949",
"s142364981"
] |
u362771726 | p02726 | python | s054671265 | s101900213 | 295 | 270 | 47,580 | 46,044 | Accepted | Accepted | 8.47 | N, X, Y = list(map(int, input().split()))
ans = [0] * (N - 1)
for i in range(1, N + 1, 1):
for j in range(i + 1, N + 1, 1):
tmp = min(
abs(j - i),
abs(X - i) + 1 + abs(j - Y),
abs(X - j) + 1 + abs(i - Y) # ใใฎใใฟใผใณใฏ
)
ans[tmp - 1] += 1
for a in ans:
print(a) | N, X, Y = list(map(int, input().split()))
ans = [0] * (N - 1)
for i in range(1, N + 1, 1):
for j in range(i + 1, N + 1, 1):
tmp = min(
abs(j - i),
abs(X - i) + 1 + abs(j - Y)
)
ans[tmp - 1] += 1
for a in ans:
print(a) | 15 | 14 | 335 | 283 | N, X, Y = list(map(int, input().split()))
ans = [0] * (N - 1)
for i in range(1, N + 1, 1):
for j in range(i + 1, N + 1, 1):
tmp = min(
abs(j - i),
abs(X - i) + 1 + abs(j - Y),
abs(X - j) + 1 + abs(i - Y), # ใใฎใใฟใผใณใฏ
)
ans[tmp - 1] += 1
for a in ans:
print(a)
| N, X, Y = list(map(int, input().split()))
ans = [0] * (N - 1)
for i in range(1, N + 1, 1):
for j in range(i + 1, N + 1, 1):
tmp = min(abs(j - i), abs(X - i) + 1 + abs(j - Y))
ans[tmp - 1] += 1
for a in ans:
print(a)
| false | 6.666667 | [
"- tmp = min(",
"- abs(j - i),",
"- abs(X - i) + 1 + abs(j - Y),",
"- abs(X - j) + 1 + abs(i - Y), # ใใฎใใฟใผใณใฏ",
"- )",
"+ tmp = min(abs(j - i), abs(X - i) + 1 + abs(j - Y))"
] | false | 0.037878 | 0.036066 | 1.050264 | [
"s054671265",
"s101900213"
] |
u606045429 | p02901 | python | s338232785 | s396950897 | 1,161 | 856 | 3,188 | 3,188 | Accepted | Accepted | 26.27 | INF = float("inf")
N, M = list(map(int, input().split()))
dp = [INF] * (2 ** N)
dp[0] = 0
for _ in range(M):
a, b = list(map(int, input().split()))
C = [int(i) for i in input().split()]
mask = sum(1 << (c - 1) for c in C)
for i, dpi in enumerate(dp):
if dp[i | mask] > dpi + a:
dp[i | mask] = dpi + a
ans = dp[-1]
print((-1 if ans == INF else ans))
| def main():
INF = float("inf")
N, M = list(map(int, input().split()))
dp = [INF] * (2 ** N)
dp[0] = 0
for _ in range(M):
a, b = list(map(int, input().split()))
C = [int(i) for i in input().split()]
mask = sum(1 << (c - 1) for c in C)
for i, dpi in enumerate(dp):
if dp[i | mask] > dpi + a:
dp[i | mask] = dpi + a
ans = dp[-1]
print((-1 if ans == INF else ans))
if __name__ == '__main__':
main()
| 17 | 22 | 391 | 500 | INF = float("inf")
N, M = list(map(int, input().split()))
dp = [INF] * (2**N)
dp[0] = 0
for _ in range(M):
a, b = list(map(int, input().split()))
C = [int(i) for i in input().split()]
mask = sum(1 << (c - 1) for c in C)
for i, dpi in enumerate(dp):
if dp[i | mask] > dpi + a:
dp[i | mask] = dpi + a
ans = dp[-1]
print((-1 if ans == INF else ans))
| def main():
INF = float("inf")
N, M = list(map(int, input().split()))
dp = [INF] * (2**N)
dp[0] = 0
for _ in range(M):
a, b = list(map(int, input().split()))
C = [int(i) for i in input().split()]
mask = sum(1 << (c - 1) for c in C)
for i, dpi in enumerate(dp):
if dp[i | mask] > dpi + a:
dp[i | mask] = dpi + a
ans = dp[-1]
print((-1 if ans == INF else ans))
if __name__ == "__main__":
main()
| false | 22.727273 | [
"-INF = float(\"inf\")",
"-N, M = list(map(int, input().split()))",
"-dp = [INF] * (2**N)",
"-dp[0] = 0",
"-for _ in range(M):",
"- a, b = list(map(int, input().split()))",
"- C = [int(i) for i in input().split()]",
"- mask = sum(1 << (c - 1) for c in C)",
"- for i, dpi in enumerate(dp):",
"- if dp[i | mask] > dpi + a:",
"- dp[i | mask] = dpi + a",
"-ans = dp[-1]",
"-print((-1 if ans == INF else ans))",
"+def main():",
"+ INF = float(\"inf\")",
"+ N, M = list(map(int, input().split()))",
"+ dp = [INF] * (2**N)",
"+ dp[0] = 0",
"+ for _ in range(M):",
"+ a, b = list(map(int, input().split()))",
"+ C = [int(i) for i in input().split()]",
"+ mask = sum(1 << (c - 1) for c in C)",
"+ for i, dpi in enumerate(dp):",
"+ if dp[i | mask] > dpi + a:",
"+ dp[i | mask] = dpi + a",
"+ ans = dp[-1]",
"+ print((-1 if ans == INF else ans))",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ main()"
] | false | 0.041526 | 0.042882 | 0.968357 | [
"s338232785",
"s396950897"
] |
u347640436 | p03062 | python | s231633763 | s540223026 | 99 | 64 | 14,284 | 14,412 | Accepted | Accepted | 35.35 | n = int(eval(input()))
a = list(map(int, input().split()))
mc = 0
s = 0
m = float('inf')
for i in a:
if i < 0:
mc += 1
s += abs(i)
m = min(m, abs(i))
if mc % 2 == 0:
print(s)
else:
print((s -2 * m))
| N = int(eval(input()))
A = list(map(int, input().split()))
negatives = len([a for a in A if a < 0])
if negatives % 2 == 0:
m = 0
else:
m = min(abs(a) for a in A)
print((sum(abs(a) for a in A) - 2 * m))
| 14 | 9 | 218 | 211 | n = int(eval(input()))
a = list(map(int, input().split()))
mc = 0
s = 0
m = float("inf")
for i in a:
if i < 0:
mc += 1
s += abs(i)
m = min(m, abs(i))
if mc % 2 == 0:
print(s)
else:
print((s - 2 * m))
| N = int(eval(input()))
A = list(map(int, input().split()))
negatives = len([a for a in A if a < 0])
if negatives % 2 == 0:
m = 0
else:
m = min(abs(a) for a in A)
print((sum(abs(a) for a in A) - 2 * m))
| false | 35.714286 | [
"-n = int(eval(input()))",
"-a = list(map(int, input().split()))",
"-mc = 0",
"-s = 0",
"-m = float(\"inf\")",
"-for i in a:",
"- if i < 0:",
"- mc += 1",
"- s += abs(i)",
"- m = min(m, abs(i))",
"-if mc % 2 == 0:",
"- print(s)",
"+N = int(eval(input()))",
"+A = list(map(int, input().split()))",
"+negatives = len([a for a in A if a < 0])",
"+if negatives % 2 == 0:",
"+ m = 0",
"- print((s - 2 * m))",
"+ m = min(abs(a) for a in A)",
"+print((sum(abs(a) for a in A) - 2 * m))"
] | false | 0.035665 | 0.040063 | 0.890228 | [
"s231633763",
"s540223026"
] |
u729133443 | p02835 | python | s313194750 | s369222632 | 174 | 29 | 38,384 | 8,964 | Accepted | Accepted | 83.33 | print(('bwuisnt'[sum(map(int,input().split()))<22::2])) | print(('bwuisnt'[eval(input().replace(*' +'))<22::2])) | 1 | 1 | 53 | 52 | print(("bwuisnt"[sum(map(int, input().split())) < 22 :: 2]))
| print(("bwuisnt"[eval(input().replace(*" +")) < 22 :: 2]))
| false | 0 | [
"-print((\"bwuisnt\"[sum(map(int, input().split())) < 22 :: 2]))",
"+print((\"bwuisnt\"[eval(input().replace(*\" +\")) < 22 :: 2]))"
] | false | 0.041239 | 0.041008 | 1.00563 | [
"s313194750",
"s369222632"
] |
u729133443 | p03395 | python | s378850127 | s708013373 | 276 | 230 | 43,228 | 13,852 | Accepted | Accepted | 16.67 | def warshall_floyd(d):
r=list(range(M+1))
for k in r:
for i in r:
for j in r:
t=d[i][k]+d[k][j]
if t<d[i][j]:
d[i][j]=t
return d
n,*a=list(map(int,open(0).read().split()))
a,b=a[:n],a[n:]
for x,y in zip(a,b):
if x==y:continue
if y>x:
print((-1))
exit()
if x-y<=y:
print((-1))
exit()
M=max(a)
d=[]
for k in range(M-1,-1,-1):
s=set(a)
e=[[10**18]*(M+1)for _ in range(M+1)]
for i in range(M+1):e[i][i]=1
for i in d+list(range(k,0,-1)):
t=s.copy()
for x in s:
e[x][x%i]=1
t|={x%i}
s=t
c=warshall_floyd(e)
for x,y in zip(a,b):
if c[x][y]>=10**18:
d+=k+1,
break
print((sum(2**k for k in d))) | from scipy.sparse.csgraph import floyd_warshall
n,*a=list(map(int,open(0).read().split()))
a,b=a[:n],a[n:]
d=[]
M=max(a)
for k in range(M-1,-1,-1):
s=set(a)
e=[[0]*(M+1)for _ in range(M+1)]
for i in range(M+1):e[i][i]=1
for i in d+list(range(k,0,-1)):
t=s.copy()
for x in s:
e[x][x%i]=1
t|={x%i}
s=t
c=floyd_warshall(e)
for x,y in zip(a,b):
if c[x,y]==float('inf'):
d+=k+1,
break
print((-(len(d)==M)or sum(2**k for k in d))) | 37 | 21 | 835 | 540 | def warshall_floyd(d):
r = list(range(M + 1))
for k in r:
for i in r:
for j in r:
t = d[i][k] + d[k][j]
if t < d[i][j]:
d[i][j] = t
return d
n, *a = list(map(int, open(0).read().split()))
a, b = a[:n], a[n:]
for x, y in zip(a, b):
if x == y:
continue
if y > x:
print((-1))
exit()
if x - y <= y:
print((-1))
exit()
M = max(a)
d = []
for k in range(M - 1, -1, -1):
s = set(a)
e = [[10**18] * (M + 1) for _ in range(M + 1)]
for i in range(M + 1):
e[i][i] = 1
for i in d + list(range(k, 0, -1)):
t = s.copy()
for x in s:
e[x][x % i] = 1
t |= {x % i}
s = t
c = warshall_floyd(e)
for x, y in zip(a, b):
if c[x][y] >= 10**18:
d += (k + 1,)
break
print((sum(2**k for k in d)))
| from scipy.sparse.csgraph import floyd_warshall
n, *a = list(map(int, open(0).read().split()))
a, b = a[:n], a[n:]
d = []
M = max(a)
for k in range(M - 1, -1, -1):
s = set(a)
e = [[0] * (M + 1) for _ in range(M + 1)]
for i in range(M + 1):
e[i][i] = 1
for i in d + list(range(k, 0, -1)):
t = s.copy()
for x in s:
e[x][x % i] = 1
t |= {x % i}
s = t
c = floyd_warshall(e)
for x, y in zip(a, b):
if c[x, y] == float("inf"):
d += (k + 1,)
break
print((-(len(d) == M) or sum(2**k for k in d)))
| false | 43.243243 | [
"-def warshall_floyd(d):",
"- r = list(range(M + 1))",
"- for k in r:",
"- for i in r:",
"- for j in r:",
"- t = d[i][k] + d[k][j]",
"- if t < d[i][j]:",
"- d[i][j] = t",
"- return d",
"-",
"+from scipy.sparse.csgraph import floyd_warshall",
"-for x, y in zip(a, b):",
"- if x == y:",
"- continue",
"- if y > x:",
"- print((-1))",
"- exit()",
"- if x - y <= y:",
"- print((-1))",
"- exit()",
"+d = []",
"-d = []",
"- e = [[10**18] * (M + 1) for _ in range(M + 1)]",
"+ e = [[0] * (M + 1) for _ in range(M + 1)]",
"- c = warshall_floyd(e)",
"+ c = floyd_warshall(e)",
"- if c[x][y] >= 10**18:",
"+ if c[x, y] == float(\"inf\"):",
"-print((sum(2**k for k in d)))",
"+print((-(len(d) == M) or sum(2**k for k in d)))"
] | false | 0.250348 | 0.35332 | 0.70856 | [
"s378850127",
"s708013373"
] |
u073852194 | p03450 | python | s216102488 | s392899022 | 1,697 | 258 | 10,212 | 71,792 | Accepted | Accepted | 84.8 | class WeightedUnionFind():
def __init__(self,n):
self.n = n
self.parents = [i for i in range(n)]
self.rank = [0 for _ in range(n)]
self.weight = [0 for _ in range(n)]
def find(self,x):
root = x
stack = [root]
while self.parents[root] != root:
root = self.parents[root]
stack.append(root)
while stack:
s = stack.pop()
self.weight[s] += self.weight[self.parents[s]]
while self.parents[x] != root:
parent = self.parents[x]
self.parents[x] = root
x = parent
return root
def unite(self,x,y,w):
xroot = self.find(x)
yroot = self.find(y)
if xroot == yroot:
return
xrank = self.rank[xroot]
yrank = self.rank[yroot]
if xrank < yrank:
self.parents[xroot] = yroot
self.weight[xroot] = w-self.weight[x]+self.weight[y]
else:
self.parents[yroot] = xroot
self.weight[yroot] = -w+self.weight[x]-self.weight[y]
if xrank == yrank:
self.rank[xroot] += 1
def diff(self,x,y):
return self.weight[x]-self.weight[y]
N,M = list(map(int,input().split()))
uf = WeightedUnionFind(N)
for _ in range(M):
l,r,d = list(map(int,input().split()))
if uf.find(l-1) == uf.find(r-1):
if uf.diff(l-1,r-1) != d:
print('No')
break
else:
uf.unite(l-1,r-1,d)
else:
print('Yes') | class DSUWeighted():
def __init__(self, n):
self.n = n
self.par_size = [-1] * n
self.wt = [0] * n
def leader(self, a):
#assert 0 <= a < self.n
x = a
order = [x]
while self.par_size[x] >= 0:
x = self.par_size[x]
order.append(x)
for s in order[:-1][::-1]:
self.wt[s] += self.wt[self.par_size[s]]
self.par_size[s] = x
return x
def same(self, a, b):
#assert 0 <= a < self.n
#assert 0 <= b < self.n
return self.leader(a) == self.leader(b)
def merge(self, a, b, w):
#assert 0 <= a < self.n
#assert 0 <= b < self.n
x = self.leader(a)
y = self.leader(b)
w += self.wt[a] - self.wt[b]
if x == y: return x
if -self.par_size[x] < -self.par_size[y]:
x, y = y, x
w = -w
self.par_size[x] += self.par_size[y]
self.par_size[y] = x
self.wt[y] = w
return x
def diff(self, x, y):
return self.wt[y] - self.wt[x]
import sys
input = sys.stdin.buffer.readline
N, M = list(map(int, input().split()))
uf = DSUWeighted(N)
for _ in range(M):
l, r, d = list(map(int, input().split()))
if uf.same(l - 1, r - 1):
if uf.diff(l - 1, r - 1) != d:
print('No')
break
else:
uf.merge(l - 1, r - 1, d)
else:
print('Yes') | 51 | 58 | 1,562 | 1,474 | class WeightedUnionFind:
def __init__(self, n):
self.n = n
self.parents = [i for i in range(n)]
self.rank = [0 for _ in range(n)]
self.weight = [0 for _ in range(n)]
def find(self, x):
root = x
stack = [root]
while self.parents[root] != root:
root = self.parents[root]
stack.append(root)
while stack:
s = stack.pop()
self.weight[s] += self.weight[self.parents[s]]
while self.parents[x] != root:
parent = self.parents[x]
self.parents[x] = root
x = parent
return root
def unite(self, x, y, w):
xroot = self.find(x)
yroot = self.find(y)
if xroot == yroot:
return
xrank = self.rank[xroot]
yrank = self.rank[yroot]
if xrank < yrank:
self.parents[xroot] = yroot
self.weight[xroot] = w - self.weight[x] + self.weight[y]
else:
self.parents[yroot] = xroot
self.weight[yroot] = -w + self.weight[x] - self.weight[y]
if xrank == yrank:
self.rank[xroot] += 1
def diff(self, x, y):
return self.weight[x] - self.weight[y]
N, M = list(map(int, input().split()))
uf = WeightedUnionFind(N)
for _ in range(M):
l, r, d = list(map(int, input().split()))
if uf.find(l - 1) == uf.find(r - 1):
if uf.diff(l - 1, r - 1) != d:
print("No")
break
else:
uf.unite(l - 1, r - 1, d)
else:
print("Yes")
| class DSUWeighted:
def __init__(self, n):
self.n = n
self.par_size = [-1] * n
self.wt = [0] * n
def leader(self, a):
# assert 0 <= a < self.n
x = a
order = [x]
while self.par_size[x] >= 0:
x = self.par_size[x]
order.append(x)
for s in order[:-1][::-1]:
self.wt[s] += self.wt[self.par_size[s]]
self.par_size[s] = x
return x
def same(self, a, b):
# assert 0 <= a < self.n
# assert 0 <= b < self.n
return self.leader(a) == self.leader(b)
def merge(self, a, b, w):
# assert 0 <= a < self.n
# assert 0 <= b < self.n
x = self.leader(a)
y = self.leader(b)
w += self.wt[a] - self.wt[b]
if x == y:
return x
if -self.par_size[x] < -self.par_size[y]:
x, y = y, x
w = -w
self.par_size[x] += self.par_size[y]
self.par_size[y] = x
self.wt[y] = w
return x
def diff(self, x, y):
return self.wt[y] - self.wt[x]
import sys
input = sys.stdin.buffer.readline
N, M = list(map(int, input().split()))
uf = DSUWeighted(N)
for _ in range(M):
l, r, d = list(map(int, input().split()))
if uf.same(l - 1, r - 1):
if uf.diff(l - 1, r - 1) != d:
print("No")
break
else:
uf.merge(l - 1, r - 1, d)
else:
print("Yes")
| false | 12.068966 | [
"-class WeightedUnionFind:",
"+class DSUWeighted:",
"- self.parents = [i for i in range(n)]",
"- self.rank = [0 for _ in range(n)]",
"- self.weight = [0 for _ in range(n)]",
"+ self.par_size = [-1] * n",
"+ self.wt = [0] * n",
"- def find(self, x):",
"- root = x",
"- stack = [root]",
"- while self.parents[root] != root:",
"- root = self.parents[root]",
"- stack.append(root)",
"- while stack:",
"- s = stack.pop()",
"- self.weight[s] += self.weight[self.parents[s]]",
"- while self.parents[x] != root:",
"- parent = self.parents[x]",
"- self.parents[x] = root",
"- x = parent",
"- return root",
"+ def leader(self, a):",
"+ # assert 0 <= a < self.n",
"+ x = a",
"+ order = [x]",
"+ while self.par_size[x] >= 0:",
"+ x = self.par_size[x]",
"+ order.append(x)",
"+ for s in order[:-1][::-1]:",
"+ self.wt[s] += self.wt[self.par_size[s]]",
"+ self.par_size[s] = x",
"+ return x",
"- def unite(self, x, y, w):",
"- xroot = self.find(x)",
"- yroot = self.find(y)",
"- if xroot == yroot:",
"- return",
"- xrank = self.rank[xroot]",
"- yrank = self.rank[yroot]",
"- if xrank < yrank:",
"- self.parents[xroot] = yroot",
"- self.weight[xroot] = w - self.weight[x] + self.weight[y]",
"- else:",
"- self.parents[yroot] = xroot",
"- self.weight[yroot] = -w + self.weight[x] - self.weight[y]",
"- if xrank == yrank:",
"- self.rank[xroot] += 1",
"+ def same(self, a, b):",
"+ # assert 0 <= a < self.n",
"+ # assert 0 <= b < self.n",
"+ return self.leader(a) == self.leader(b)",
"+",
"+ def merge(self, a, b, w):",
"+ # assert 0 <= a < self.n",
"+ # assert 0 <= b < self.n",
"+ x = self.leader(a)",
"+ y = self.leader(b)",
"+ w += self.wt[a] - self.wt[b]",
"+ if x == y:",
"+ return x",
"+ if -self.par_size[x] < -self.par_size[y]:",
"+ x, y = y, x",
"+ w = -w",
"+ self.par_size[x] += self.par_size[y]",
"+ self.par_size[y] = x",
"+ self.wt[y] = w",
"+ return x",
"- return self.weight[x] - self.weight[y]",
"+ return self.wt[y] - self.wt[x]",
"+import sys",
"+",
"+input = sys.stdin.buffer.readline",
"-uf = WeightedUnionFind(N)",
"+uf = DSUWeighted(N)",
"- if uf.find(l - 1) == uf.find(r - 1):",
"+ if uf.same(l - 1, r - 1):",
"- uf.unite(l - 1, r - 1, d)",
"+ uf.merge(l - 1, r - 1, d)"
] | false | 0.040045 | 0.040162 | 0.997084 | [
"s216102488",
"s392899022"
] |
u644907318 | p03213 | python | s799050937 | s123524186 | 100 | 62 | 63,652 | 63,704 | Accepted | Accepted | 38 | P = [1 for _ in range(100)]
P[0]=0
P[1]=0
for i in range(2,11):
for j in range(i*i,100,i):
P[j] = 0
Q = []
for i in range(2,100):
if P[i]==1:
Q.append(i)
C = {q:0 for q in Q}
N = int(eval(input()))
for i in range(2,N+1):
x = i
for q in Q:
while x%q==0:
x = x//q
C[q] += 1
D = {2:0,4:0,14:0,24:0,74:0}
for q in Q:
if C[q]>=2:
D[2] += 1
if C[q]>=4:
D[4] += 1
if C[q]>=14:
D[14] += 1
if C[q]>=24:
D[24] += 1
if C[q]>=74:
D[74] += 1
cnt = D[74]
cnt += (D[2]-D[24])*D[24]+(D[24]*(D[24]-1))
cnt += (D[4]-D[14])*D[14]+(D[14]*(D[14]-1))
cnt += (D[2]-D[4])*(D[4]*(D[4]-1))//2+(D[4]*(D[4]-1)*(D[4]-2))//2
print(cnt) | P = [1 for _ in range(100)]
P[0]=0
P[1]=0
for i in range(2,11):
for j in range(i**2,100,i):
P[j] = 0
Q = []
for i in range(100):
if P[i]==1:
Q.append(i)
N = int(eval(input()))
C = {p:0 for p in Q}
for i in range(2,N+1):
for p in Q:
if i%p==0:
x = i
while x%p==0:
x = x//p
C[p] += 1
cnt = 0
for p in Q:
if C[p]>=74:
cnt += 1
cnt1 = 0
cnt2 = 0
for p in Q:
if C[p]>=24:
cnt2 += 1
elif C[p]>=2:
cnt1 += 1
cnt += cnt2*(cnt2-1)+cnt2*cnt1
cnt1 = 0
cnt2 = 0
for p in Q:
if C[p]>=14:
cnt2 += 1
elif C[p]>=4:
cnt1 += 1
cnt += cnt2*(cnt2-1)+cnt2*cnt1
cnt1 = 0
cnt2 = 0
for p in Q:
if C[p]>=4:
cnt2 += 1
elif C[p]>=2:
cnt1 += 1
cnt += (cnt2*(cnt2-1)*(cnt2-2))//2+((cnt2*(cnt2-1))//2)*cnt1
print(cnt) | 35 | 48 | 757 | 904 | P = [1 for _ in range(100)]
P[0] = 0
P[1] = 0
for i in range(2, 11):
for j in range(i * i, 100, i):
P[j] = 0
Q = []
for i in range(2, 100):
if P[i] == 1:
Q.append(i)
C = {q: 0 for q in Q}
N = int(eval(input()))
for i in range(2, N + 1):
x = i
for q in Q:
while x % q == 0:
x = x // q
C[q] += 1
D = {2: 0, 4: 0, 14: 0, 24: 0, 74: 0}
for q in Q:
if C[q] >= 2:
D[2] += 1
if C[q] >= 4:
D[4] += 1
if C[q] >= 14:
D[14] += 1
if C[q] >= 24:
D[24] += 1
if C[q] >= 74:
D[74] += 1
cnt = D[74]
cnt += (D[2] - D[24]) * D[24] + (D[24] * (D[24] - 1))
cnt += (D[4] - D[14]) * D[14] + (D[14] * (D[14] - 1))
cnt += (D[2] - D[4]) * (D[4] * (D[4] - 1)) // 2 + (D[4] * (D[4] - 1) * (D[4] - 2)) // 2
print(cnt)
| P = [1 for _ in range(100)]
P[0] = 0
P[1] = 0
for i in range(2, 11):
for j in range(i**2, 100, i):
P[j] = 0
Q = []
for i in range(100):
if P[i] == 1:
Q.append(i)
N = int(eval(input()))
C = {p: 0 for p in Q}
for i in range(2, N + 1):
for p in Q:
if i % p == 0:
x = i
while x % p == 0:
x = x // p
C[p] += 1
cnt = 0
for p in Q:
if C[p] >= 74:
cnt += 1
cnt1 = 0
cnt2 = 0
for p in Q:
if C[p] >= 24:
cnt2 += 1
elif C[p] >= 2:
cnt1 += 1
cnt += cnt2 * (cnt2 - 1) + cnt2 * cnt1
cnt1 = 0
cnt2 = 0
for p in Q:
if C[p] >= 14:
cnt2 += 1
elif C[p] >= 4:
cnt1 += 1
cnt += cnt2 * (cnt2 - 1) + cnt2 * cnt1
cnt1 = 0
cnt2 = 0
for p in Q:
if C[p] >= 4:
cnt2 += 1
elif C[p] >= 2:
cnt1 += 1
cnt += (cnt2 * (cnt2 - 1) * (cnt2 - 2)) // 2 + ((cnt2 * (cnt2 - 1)) // 2) * cnt1
print(cnt)
| false | 27.083333 | [
"- for j in range(i * i, 100, i):",
"+ for j in range(i**2, 100, i):",
"-for i in range(2, 100):",
"+for i in range(100):",
"-C = {q: 0 for q in Q}",
"+C = {p: 0 for p in Q}",
"- x = i",
"- for q in Q:",
"- while x % q == 0:",
"- x = x // q",
"- C[q] += 1",
"-D = {2: 0, 4: 0, 14: 0, 24: 0, 74: 0}",
"-for q in Q:",
"- if C[q] >= 2:",
"- D[2] += 1",
"- if C[q] >= 4:",
"- D[4] += 1",
"- if C[q] >= 14:",
"- D[14] += 1",
"- if C[q] >= 24:",
"- D[24] += 1",
"- if C[q] >= 74:",
"- D[74] += 1",
"-cnt = D[74]",
"-cnt += (D[2] - D[24]) * D[24] + (D[24] * (D[24] - 1))",
"-cnt += (D[4] - D[14]) * D[14] + (D[14] * (D[14] - 1))",
"-cnt += (D[2] - D[4]) * (D[4] * (D[4] - 1)) // 2 + (D[4] * (D[4] - 1) * (D[4] - 2)) // 2",
"+ for p in Q:",
"+ if i % p == 0:",
"+ x = i",
"+ while x % p == 0:",
"+ x = x // p",
"+ C[p] += 1",
"+cnt = 0",
"+for p in Q:",
"+ if C[p] >= 74:",
"+ cnt += 1",
"+cnt1 = 0",
"+cnt2 = 0",
"+for p in Q:",
"+ if C[p] >= 24:",
"+ cnt2 += 1",
"+ elif C[p] >= 2:",
"+ cnt1 += 1",
"+cnt += cnt2 * (cnt2 - 1) + cnt2 * cnt1",
"+cnt1 = 0",
"+cnt2 = 0",
"+for p in Q:",
"+ if C[p] >= 14:",
"+ cnt2 += 1",
"+ elif C[p] >= 4:",
"+ cnt1 += 1",
"+cnt += cnt2 * (cnt2 - 1) + cnt2 * cnt1",
"+cnt1 = 0",
"+cnt2 = 0",
"+for p in Q:",
"+ if C[p] >= 4:",
"+ cnt2 += 1",
"+ elif C[p] >= 2:",
"+ cnt1 += 1",
"+cnt += (cnt2 * (cnt2 - 1) * (cnt2 - 2)) // 2 + ((cnt2 * (cnt2 - 1)) // 2) * cnt1"
] | false | 0.03792 | 0.036509 | 1.038652 | [
"s799050937",
"s123524186"
] |
u380524497 | p02788 | python | s912254110 | s984670788 | 570 | 473 | 88,932 | 55,880 | Accepted | Accepted | 17.02 | def main():
import sys
from operator import itemgetter
from collections import deque
buf = sys.stdin.buffer
n, d, a = list(map(int, buf.readline().split()))
m = list(map(int, buf.read().split()))
monsters = sorted(zip(m, m), key=itemgetter(0))
bomb_area = deque([])
bomb_power = deque([])
total_damage = 0
ans = 0
for pos, hp in monsters:
while bomb_area:
area = bomb_area[0]
if area < pos:
bomb_area.popleft()
power = bomb_power.popleft()
total_damage -= power
else:
break
if hp <= total_damage:
continue
else:
count = (hp - total_damage + a - 1) // a
ans += count
power = a * count
total_damage += power
bomb_area.append(pos + 2 * d)
bomb_power.append(power)
print(ans)
if __name__ == '__main__':
main()
| def main():
import sys
from operator import itemgetter
buf = sys.stdin.buffer
n, d, a = list(map(int, buf.readline().split()))
m = list(map(int, buf.read().split()))
monsters = sorted(zip(m, m), key=itemgetter(0))
bomb_area = []
bomb_power = []
bomb_length = 0
total_damage = 0
ans = 0
idx = 0
for pos, hp in monsters:
while idx < bomb_length:
area = bomb_area[idx]
if area < pos:
power = bomb_power[idx]
total_damage -= power
idx += 1
else:
break
if hp <= total_damage:
continue
else:
count = (hp - total_damage + a - 1) // a
ans += count
power = a * count
total_damage += power
bomb_area.append(pos + 2 * d)
bomb_power.append(power)
bomb_length += 1
print(ans)
if __name__ == '__main__':
main()
| 37 | 39 | 1,006 | 1,007 | def main():
import sys
from operator import itemgetter
from collections import deque
buf = sys.stdin.buffer
n, d, a = list(map(int, buf.readline().split()))
m = list(map(int, buf.read().split()))
monsters = sorted(zip(m, m), key=itemgetter(0))
bomb_area = deque([])
bomb_power = deque([])
total_damage = 0
ans = 0
for pos, hp in monsters:
while bomb_area:
area = bomb_area[0]
if area < pos:
bomb_area.popleft()
power = bomb_power.popleft()
total_damage -= power
else:
break
if hp <= total_damage:
continue
else:
count = (hp - total_damage + a - 1) // a
ans += count
power = a * count
total_damage += power
bomb_area.append(pos + 2 * d)
bomb_power.append(power)
print(ans)
if __name__ == "__main__":
main()
| def main():
import sys
from operator import itemgetter
buf = sys.stdin.buffer
n, d, a = list(map(int, buf.readline().split()))
m = list(map(int, buf.read().split()))
monsters = sorted(zip(m, m), key=itemgetter(0))
bomb_area = []
bomb_power = []
bomb_length = 0
total_damage = 0
ans = 0
idx = 0
for pos, hp in monsters:
while idx < bomb_length:
area = bomb_area[idx]
if area < pos:
power = bomb_power[idx]
total_damage -= power
idx += 1
else:
break
if hp <= total_damage:
continue
else:
count = (hp - total_damage + a - 1) // a
ans += count
power = a * count
total_damage += power
bomb_area.append(pos + 2 * d)
bomb_power.append(power)
bomb_length += 1
print(ans)
if __name__ == "__main__":
main()
| false | 5.128205 | [
"- from collections import deque",
"- bomb_area = deque([])",
"- bomb_power = deque([])",
"+ bomb_area = []",
"+ bomb_power = []",
"+ bomb_length = 0",
"+ idx = 0",
"- while bomb_area:",
"- area = bomb_area[0]",
"+ while idx < bomb_length:",
"+ area = bomb_area[idx]",
"- bomb_area.popleft()",
"- power = bomb_power.popleft()",
"+ power = bomb_power[idx]",
"+ idx += 1",
"+ bomb_length += 1"
] | false | 0.085967 | 0.007252 | 11.854757 | [
"s912254110",
"s984670788"
] |
u414163108 | p02676 | python | s053123593 | s505320611 | 23 | 20 | 9,116 | 9,148 | Accepted | Accepted | 13.04 | K = int(eval(input()))
for i in range(1):
S = eval(input())
if len(S) <= K:
print(S)
else:
print((S[0 : K] + '...'))
| K = int(eval(input()))
S = eval(input())
if len(S) <= K:
print(S)
else:
print((S[0 : K] + '...'))
| 8 | 7 | 123 | 99 | K = int(eval(input()))
for i in range(1):
S = eval(input())
if len(S) <= K:
print(S)
else:
print((S[0:K] + "..."))
| K = int(eval(input()))
S = eval(input())
if len(S) <= K:
print(S)
else:
print((S[0:K] + "..."))
| false | 12.5 | [
"-for i in range(1):",
"- S = eval(input())",
"+S = eval(input())"
] | false | 0.037297 | 0.038184 | 0.976784 | [
"s053123593",
"s505320611"
] |
u065446124 | p02676 | python | s598167920 | s381454246 | 58 | 22 | 61,892 | 9,124 | Accepted | Accepted | 62.07 | def N(): return int(input())
def NM():return map(int,input().split())
def L():return list(NM())
def LN(n):return [N() for i in range(n)]
def LL(n):return [L() for i in range(n)]
def YesNo(x):print("Yes")if x==True else print("No")
k=N()
s=input()
if len(s)<=k:
print(s)
else:
print(s[:k]+"...")
| import sys
def input():return sys.stdin.readline()[:-1]
def N(): return int(input())
def NM():return map(int,input().split())
def L():return list(NM())
def LN(n):return [N() for i in range(n)]
def LL(n):return [L() for i in range(n)]
def YesNo(x):print("Yes")if x==True else print("No")
k=N()
s=input()
if len(s)<=k:
print(s)
else:
print(s[:k]+"...")
| 12 | 14 | 313 | 371 | def N():
return int(input())
def NM():
return map(int, input().split())
def L():
return list(NM())
def LN(n):
return [N() for i in range(n)]
def LL(n):
return [L() for i in range(n)]
def YesNo(x):
print("Yes") if x == True else print("No")
k = N()
s = input()
if len(s) <= k:
print(s)
else:
print(s[:k] + "...")
| import sys
def input():
return sys.stdin.readline()[:-1]
def N():
return int(input())
def NM():
return map(int, input().split())
def L():
return list(NM())
def LN(n):
return [N() for i in range(n)]
def LL(n):
return [L() for i in range(n)]
def YesNo(x):
print("Yes") if x == True else print("No")
k = N()
s = input()
if len(s) <= k:
print(s)
else:
print(s[:k] + "...")
| false | 14.285714 | [
"+import sys",
"+",
"+",
"+def input():",
"+ return sys.stdin.readline()[:-1]",
"+",
"+"
] | false | 0.036118 | 0.076176 | 0.474138 | [
"s598167920",
"s381454246"
] |
u760794812 | p03087 | python | s458073142 | s009345691 | 1,119 | 868 | 51,032 | 9,540 | Accepted | Accepted | 22.43 | N,Q = list(map(int,input().split()))
S = eval(input())
index = [0] *(N+1)
for i in range(N):
index[i+1] = index[i] + (1 if S[i:i+2] =='AC' else 0)
for _ in range(Q):
r, l = list(map(int,input().split()))
print((index[l-1] - index[ r -1])) | N,Q = list(map(int,input().split()))
S = eval(input())
index = [0] *(N+1)
for i in range(N):
index[i+1] = index[i] + (1 if S[i:i+2]=='AC' else 0)
for _ in range(Q):
l, r = list(map(int,input().split()))
print((index[r-1] - index[l-1])) | 8 | 8 | 231 | 228 | N, Q = list(map(int, input().split()))
S = eval(input())
index = [0] * (N + 1)
for i in range(N):
index[i + 1] = index[i] + (1 if S[i : i + 2] == "AC" else 0)
for _ in range(Q):
r, l = list(map(int, input().split()))
print((index[l - 1] - index[r - 1]))
| N, Q = list(map(int, input().split()))
S = eval(input())
index = [0] * (N + 1)
for i in range(N):
index[i + 1] = index[i] + (1 if S[i : i + 2] == "AC" else 0)
for _ in range(Q):
l, r = list(map(int, input().split()))
print((index[r - 1] - index[l - 1]))
| false | 0 | [
"- r, l = list(map(int, input().split()))",
"- print((index[l - 1] - index[r - 1]))",
"+ l, r = list(map(int, input().split()))",
"+ print((index[r - 1] - index[l - 1]))"
] | false | 0.036795 | 0.035314 | 1.041943 | [
"s458073142",
"s009345691"
] |
u729133443 | p02619 | python | s844801547 | s765183144 | 82 | 31 | 68,176 | 10,164 | Accepted | Accepted | 62.2 | def func(s,x):
last=[0]*26
score=0
for i,v in enumerate(x,1):
last[v]=i
c=0
for j in range(26):
c+=s[j]*(i-last[j])
score=score+s[i*26+v]-c
print(score)
return score
def main():
d,*s=list(map(int,open(0).read().split()))
func(s,[t-1for t in s[-d:]])
main() | d,*s,=list(map(int,open(i:=0).read().split()))
c,*l=[0]*27
for v in s[-d:]:
i+=1
l[v-1]=i
print((c:=c+s[i*26+v-1]-sum(x*(i-y)for x,y in zip(s,l)))) | 15 | 6 | 340 | 150 | def func(s, x):
last = [0] * 26
score = 0
for i, v in enumerate(x, 1):
last[v] = i
c = 0
for j in range(26):
c += s[j] * (i - last[j])
score = score + s[i * 26 + v] - c
print(score)
return score
def main():
d, *s = list(map(int, open(0).read().split()))
func(s, [t - 1 for t in s[-d:]])
main()
| (
d,
*s,
) = list(map(int, open(i := 0).read().split()))
c, *l = [0] * 27
for v in s[-d:]:
i += 1
l[v - 1] = i
print((c := c + s[i * 26 + v - 1] - sum(x * (i - y) for x, y in zip(s, l))))
| false | 60 | [
"-def func(s, x):",
"- last = [0] * 26",
"- score = 0",
"- for i, v in enumerate(x, 1):",
"- last[v] = i",
"- c = 0",
"- for j in range(26):",
"- c += s[j] * (i - last[j])",
"- score = score + s[i * 26 + v] - c",
"- print(score)",
"- return score",
"-",
"-",
"-def main():",
"- d, *s = list(map(int, open(0).read().split()))",
"- func(s, [t - 1 for t in s[-d:]])",
"-",
"-",
"-main()",
"+(",
"+ d,",
"+ *s,",
"+) = list(map(int, open(i := 0).read().split()))",
"+c, *l = [0] * 27",
"+for v in s[-d:]:",
"+ i += 1",
"+ l[v - 1] = i",
"+ print((c := c + s[i * 26 + v - 1] - sum(x * (i - y) for x, y in zip(s, l))))"
] | false | 0.037188 | 0.054693 | 0.679935 | [
"s844801547",
"s765183144"
] |
u620084012 | p04045 | python | s021350638 | s852422102 | 189 | 38 | 39,408 | 3,060 | Accepted | Accepted | 79.89 | import sys, math
def input():
return sys.stdin.readline()[:-1]
def main():
N, K = list(map(int,input().split()))
D = set(list(input().split()))
for k in range(N,100001):
s = str(k)
f = 0
for e in s:
if e in D:
f = 1
break
if f == 0:
print(s)
exit(0)
if __name__ == '__main__':
main()
| import sys, math
def input():
return sys.stdin.readline()[:-1]
def main():
N, K = list(map(int,input().split()))
D = set(input().split())
for ans in range(N,1000000):
f = 0
for e in str(ans):
if e in D:
f = 1
break
if f == 0:
print(ans)
exit(0)
if __name__ == '__main__':
main()
| 21 | 19 | 421 | 405 | import sys, math
def input():
return sys.stdin.readline()[:-1]
def main():
N, K = list(map(int, input().split()))
D = set(list(input().split()))
for k in range(N, 100001):
s = str(k)
f = 0
for e in s:
if e in D:
f = 1
break
if f == 0:
print(s)
exit(0)
if __name__ == "__main__":
main()
| import sys, math
def input():
return sys.stdin.readline()[:-1]
def main():
N, K = list(map(int, input().split()))
D = set(input().split())
for ans in range(N, 1000000):
f = 0
for e in str(ans):
if e in D:
f = 1
break
if f == 0:
print(ans)
exit(0)
if __name__ == "__main__":
main()
| false | 9.52381 | [
"- D = set(list(input().split()))",
"- for k in range(N, 100001):",
"- s = str(k)",
"+ D = set(input().split())",
"+ for ans in range(N, 1000000):",
"- for e in s:",
"+ for e in str(ans):",
"- print(s)",
"+ print(ans)"
] | false | 0.040641 | 0.056013 | 0.725562 | [
"s021350638",
"s852422102"
] |
u977389981 | p03035 | python | s590888742 | s325988763 | 180 | 17 | 38,256 | 2,940 | Accepted | Accepted | 90.56 | A, B = list(map(int, input().split()))
print((0 if A <= 5 else (B if A >= 13 else B // 2))) | a, b = list(map(int, input().split()))
if a >= 13:
print(b)
elif 6 <= a <= 12:
print((b // 2))
else:
print((0)) | 3 | 7 | 86 | 119 | A, B = list(map(int, input().split()))
print((0 if A <= 5 else (B if A >= 13 else B // 2)))
| a, b = list(map(int, input().split()))
if a >= 13:
print(b)
elif 6 <= a <= 12:
print((b // 2))
else:
print((0))
| false | 57.142857 | [
"-A, B = list(map(int, input().split()))",
"-print((0 if A <= 5 else (B if A >= 13 else B // 2)))",
"+a, b = list(map(int, input().split()))",
"+if a >= 13:",
"+ print(b)",
"+elif 6 <= a <= 12:",
"+ print((b // 2))",
"+else:",
"+ print((0))"
] | false | 0.040779 | 0.042314 | 0.963712 | [
"s590888742",
"s325988763"
] |
u688375653 | p02953 | python | s560471091 | s516147846 | 128 | 92 | 15,760 | 14,252 | Accepted | Accepted | 28.12 | N=int(eval(input()))
matchNums=input().split(" ")
matchNums=list(map(int, matchNums))
plus_flgs=[-1]
if len(matchNums)==1:
print("Yes")
else:
check_array=[]
check_array_all=[]
for i in range(len(matchNums)-1):
check_array.append((matchNums[i+1] - matchNums[i]))
# for i in range(len(check_array)-1):
# check_array_all.append((check_array[i+1] + check_array[i]))
#ใใฉในใจใใฉในใฎ้ใ่ถณใ
#ใใฉในใฎinedexๅๅพ
for i,val in enumerate(check_array):
if val > 0:
plus_flgs.append(i)
# ๆๅพใใใคใในใง็ตใใใจใๅฏพ็ญ
plus_flgs.append(len(check_array))
# print(plus_flgs)
# print(check_array)
for i in range(len(plus_flgs)-1):
check_array_all.append(sum(check_array[plus_flgs[i]+1: plus_flgs[i+1]]))
# print(check_array_all)
# ใใฉในใจใใฉในใฎ้ใฎๅใ-2ใฎ็ฉใใใฃใใ๏ผฎ๏ผง
if min(check_array_all)<-1:
print("No")
else:
print("Yes") | N=int(eval(input()))
H=list(map(int, input().split()))
flg=True
temp_max=0
for i in range(N-1):
if H[i] - H[i+1] >= 2:
flg=False
break
if temp_max - H[i+1] >= 2:
flg=False
break
elif temp_max<H[i+1]:
temp_max = H[i+1]
if flg:
print("Yes")
else:
print("No") | 35 | 20 | 945 | 340 | N = int(eval(input()))
matchNums = input().split(" ")
matchNums = list(map(int, matchNums))
plus_flgs = [-1]
if len(matchNums) == 1:
print("Yes")
else:
check_array = []
check_array_all = []
for i in range(len(matchNums) - 1):
check_array.append((matchNums[i + 1] - matchNums[i]))
# for i in range(len(check_array)-1):
# check_array_all.append((check_array[i+1] + check_array[i]))
# ใใฉในใจใใฉในใฎ้ใ่ถณใ
# ใใฉในใฎinedexๅๅพ
for i, val in enumerate(check_array):
if val > 0:
plus_flgs.append(i)
# ๆๅพใใใคใในใง็ตใใใจใๅฏพ็ญ
plus_flgs.append(len(check_array))
# print(plus_flgs)
# print(check_array)
for i in range(len(plus_flgs) - 1):
check_array_all.append(sum(check_array[plus_flgs[i] + 1 : plus_flgs[i + 1]]))
# print(check_array_all)
# ใใฉในใจใใฉในใฎ้ใฎๅใ-2ใฎ็ฉใใใฃใใ๏ผฎ๏ผง
if min(check_array_all) < -1:
print("No")
else:
print("Yes")
| N = int(eval(input()))
H = list(map(int, input().split()))
flg = True
temp_max = 0
for i in range(N - 1):
if H[i] - H[i + 1] >= 2:
flg = False
break
if temp_max - H[i + 1] >= 2:
flg = False
break
elif temp_max < H[i + 1]:
temp_max = H[i + 1]
if flg:
print("Yes")
else:
print("No")
| false | 42.857143 | [
"-matchNums = input().split(\" \")",
"-matchNums = list(map(int, matchNums))",
"-plus_flgs = [-1]",
"-if len(matchNums) == 1:",
"+H = list(map(int, input().split()))",
"+flg = True",
"+temp_max = 0",
"+for i in range(N - 1):",
"+ if H[i] - H[i + 1] >= 2:",
"+ flg = False",
"+ break",
"+ if temp_max - H[i + 1] >= 2:",
"+ flg = False",
"+ break",
"+ elif temp_max < H[i + 1]:",
"+ temp_max = H[i + 1]",
"+if flg:",
"- check_array = []",
"- check_array_all = []",
"- for i in range(len(matchNums) - 1):",
"- check_array.append((matchNums[i + 1] - matchNums[i]))",
"- # for i in range(len(check_array)-1):",
"- # check_array_all.append((check_array[i+1] + check_array[i]))",
"- # ใใฉในใจใใฉในใฎ้ใ่ถณใ",
"- # ใใฉในใฎinedexๅๅพ",
"- for i, val in enumerate(check_array):",
"- if val > 0:",
"- plus_flgs.append(i)",
"- # ๆๅพใใใคใในใง็ตใใใจใๅฏพ็ญ",
"- plus_flgs.append(len(check_array))",
"- # print(plus_flgs)",
"- # print(check_array)",
"- for i in range(len(plus_flgs) - 1):",
"- check_array_all.append(sum(check_array[plus_flgs[i] + 1 : plus_flgs[i + 1]]))",
"- # print(check_array_all)",
"- # ใใฉในใจใใฉในใฎ้ใฎๅใ-2ใฎ็ฉใใใฃใใ๏ผฎ๏ผง",
"- if min(check_array_all) < -1:",
"- print(\"No\")",
"- else:",
"- print(\"Yes\")",
"+ print(\"No\")"
] | false | 0.040739 | 0.037394 | 1.089443 | [
"s560471091",
"s516147846"
] |
u528470578 | p02971 | python | s436363877 | s662100266 | 891 | 570 | 70,580 | 14,112 | Accepted | Accepted | 36.03 | N = int(eval(input()))
A = []
for i in range(N):
A.append(int(eval(input())))
As = sorted(A, reverse=True)
for j in A:
if j == As[0]:
print((As[1]))
else:
print((As[0])) | N = int(eval(input()))
A = []
for _ in range(N):
A.append(int(eval(input())))
Af = sorted(A, reverse=True)
for a in A:
if a == Af[0]:
print((Af[1]))
else:
print((Af[0])) | 11 | 10 | 196 | 190 | N = int(eval(input()))
A = []
for i in range(N):
A.append(int(eval(input())))
As = sorted(A, reverse=True)
for j in A:
if j == As[0]:
print((As[1]))
else:
print((As[0]))
| N = int(eval(input()))
A = []
for _ in range(N):
A.append(int(eval(input())))
Af = sorted(A, reverse=True)
for a in A:
if a == Af[0]:
print((Af[1]))
else:
print((Af[0]))
| false | 9.090909 | [
"-for i in range(N):",
"+for _ in range(N):",
"-As = sorted(A, reverse=True)",
"-for j in A:",
"- if j == As[0]:",
"- print((As[1]))",
"+Af = sorted(A, reverse=True)",
"+for a in A:",
"+ if a == Af[0]:",
"+ print((Af[1]))",
"- print((As[0]))",
"+ print((Af[0]))"
] | false | 0.035689 | 0.036179 | 0.986456 | [
"s436363877",
"s662100266"
] |
u279493135 | p03998 | python | s052902391 | s544449839 | 53 | 45 | 5,584 | 5,460 | Accepted | Accepted | 15.09 | import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import accumulate, permutations, combinations, product, groupby, combinations_with_replacement
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
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
def ctoi(c):
return ord(c) - ord('a')
SA = list(input()[::-1])
SB = list(input()[::-1])
SC = list(input()[::-1])
S = [SA, SB, SC]
turn = 0
while S[turn]:
turn = ctoi(S[turn].pop())
print((ascii_lowercase[turn].upper()))
| import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import accumulate, permutations, combinations, product, groupby, combinations_with_replacement
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
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
A = deque(eval(input()))
B = deque(eval(input()))
C = deque(eval(input()))
def DFS(N):
if not eval(N):
print(N)
else:
p = eval("{}.popleft()".format(N))
DFS(p.upper())
DFS("A")
| 32 | 32 | 1,047 | 994 | import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import (
accumulate,
permutations,
combinations,
product,
groupby,
combinations_with_replacement,
)
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
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
def ctoi(c):
return ord(c) - ord("a")
SA = list(input()[::-1])
SB = list(input()[::-1])
SC = list(input()[::-1])
S = [SA, SB, SC]
turn = 0
while S[turn]:
turn = ctoi(S[turn].pop())
print((ascii_lowercase[turn].upper()))
| import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import (
accumulate,
permutations,
combinations,
product,
groupby,
combinations_with_replacement,
)
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
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
A = deque(eval(input()))
B = deque(eval(input()))
C = deque(eval(input()))
def DFS(N):
if not eval(N):
print(N)
else:
p = eval("{}.popleft()".format(N))
DFS(p.upper())
DFS("A")
| false | 0 | [
"+A = deque(eval(input()))",
"+B = deque(eval(input()))",
"+C = deque(eval(input()))",
"-def ctoi(c):",
"- return ord(c) - ord(\"a\")",
"+def DFS(N):",
"+ if not eval(N):",
"+ print(N)",
"+ else:",
"+ p = eval(\"{}.popleft()\".format(N))",
"+ DFS(p.upper())",
"-SA = list(input()[::-1])",
"-SB = list(input()[::-1])",
"-SC = list(input()[::-1])",
"-S = [SA, SB, SC]",
"-turn = 0",
"-while S[turn]:",
"- turn = ctoi(S[turn].pop())",
"-print((ascii_lowercase[turn].upper()))",
"+DFS(\"A\")"
] | false | 0.066106 | 0.120281 | 0.549599 | [
"s052902391",
"s544449839"
] |
u494927057 | p03854 | python | s823223057 | s434992088 | 87 | 19 | 3,188 | 3,188 | Accepted | Accepted | 78.16 | S = eval(input())
fstrs = ['dreamer', 'eraser', 'dream', 'erase']
flag = True
while flag:
for fstr in fstrs:
result = S.rfind(fstr)
if result >= 0 and result == len(S) - len(fstr):
# print('found: {} in {} ({})'.format(fstr, S, result))
S = S[0:result]
flag = True
break
else:
# print('not found: {} in {}'.format(fstr, S))
flag = False
if len(S) == 0:
break
if len(S) > 0:
print('NO')
else:
print('YES')
| S = eval(input())
strs = ['eraser', 'erase', 'dreamer', 'dream']
for i in range(len(strs)):
S = S.replace(strs[i], '')
if len(S) > 0:
print('NO')
else:
print('YES') | 23 | 11 | 544 | 183 | S = eval(input())
fstrs = ["dreamer", "eraser", "dream", "erase"]
flag = True
while flag:
for fstr in fstrs:
result = S.rfind(fstr)
if result >= 0 and result == len(S) - len(fstr):
# print('found: {} in {} ({})'.format(fstr, S, result))
S = S[0:result]
flag = True
break
else:
# print('not found: {} in {}'.format(fstr, S))
flag = False
if len(S) == 0:
break
if len(S) > 0:
print("NO")
else:
print("YES")
| S = eval(input())
strs = ["eraser", "erase", "dreamer", "dream"]
for i in range(len(strs)):
S = S.replace(strs[i], "")
if len(S) > 0:
print("NO")
else:
print("YES")
| false | 52.173913 | [
"-fstrs = [\"dreamer\", \"eraser\", \"dream\", \"erase\"]",
"-flag = True",
"-while flag:",
"- for fstr in fstrs:",
"- result = S.rfind(fstr)",
"- if result >= 0 and result == len(S) - len(fstr):",
"- # print('found: {} in {} ({})'.format(fstr, S, result))",
"- S = S[0:result]",
"- flag = True",
"- break",
"- else:",
"- # print('not found: {} in {}'.format(fstr, S))",
"- flag = False",
"- if len(S) == 0:",
"- break",
"+strs = [\"eraser\", \"erase\", \"dreamer\", \"dream\"]",
"+for i in range(len(strs)):",
"+ S = S.replace(strs[i], \"\")"
] | false | 0.061993 | 0.080714 | 0.768059 | [
"s823223057",
"s434992088"
] |
u057109575 | p02721 | python | s353353831 | s683408544 | 300 | 134 | 56,700 | 101,244 | Accepted | Accepted | 55.33 | N, K, C = list(map(int, input().split()))
S = eval(input())
ls = []
nex = -1
for i in range(N):
if S[i] == "o" and i > nex:
ls.append(i + 1)
nex = i + C
if len(ls) == K:
break
rs = []
nex = N
for i in reversed(list(range(N))):
if S[i] == "o" and i < nex:
rs.append(i + 1)
nex = i - C
if len(rs) == K:
break
for l, r in zip(ls, rs[::-1]):
if l == r:
print(l)
| N, K, C = list(map(int, input().split()))
S = eval(input())
cand_l = []
cnt = 0
rest = 0
for i in range(N):
if S[i] == "o" and rest <= 0 and cnt < K:
cand_l.append(i + 1)
rest = C
cnt += 1
else:
rest -= 1
cand_r = []
cnt = 0
rest = 0
for i in reversed(list(range(N))):
if S[i] == "o" and rest <= 0 and cnt < K:
cand_r.append(i + 1)
rest = C
cnt += 1
else:
rest -= 1
for l, r in zip(cand_l, cand_r[::-1]):
if l == r:
print(l)
| 26 | 28 | 470 | 529 | N, K, C = list(map(int, input().split()))
S = eval(input())
ls = []
nex = -1
for i in range(N):
if S[i] == "o" and i > nex:
ls.append(i + 1)
nex = i + C
if len(ls) == K:
break
rs = []
nex = N
for i in reversed(list(range(N))):
if S[i] == "o" and i < nex:
rs.append(i + 1)
nex = i - C
if len(rs) == K:
break
for l, r in zip(ls, rs[::-1]):
if l == r:
print(l)
| N, K, C = list(map(int, input().split()))
S = eval(input())
cand_l = []
cnt = 0
rest = 0
for i in range(N):
if S[i] == "o" and rest <= 0 and cnt < K:
cand_l.append(i + 1)
rest = C
cnt += 1
else:
rest -= 1
cand_r = []
cnt = 0
rest = 0
for i in reversed(list(range(N))):
if S[i] == "o" and rest <= 0 and cnt < K:
cand_r.append(i + 1)
rest = C
cnt += 1
else:
rest -= 1
for l, r in zip(cand_l, cand_r[::-1]):
if l == r:
print(l)
| false | 7.142857 | [
"-ls = []",
"-nex = -1",
"+cand_l = []",
"+cnt = 0",
"+rest = 0",
"- if S[i] == \"o\" and i > nex:",
"- ls.append(i + 1)",
"- nex = i + C",
"- if len(ls) == K:",
"- break",
"-rs = []",
"-nex = N",
"+ if S[i] == \"o\" and rest <= 0 and cnt < K:",
"+ cand_l.append(i + 1)",
"+ rest = C",
"+ cnt += 1",
"+ else:",
"+ rest -= 1",
"+cand_r = []",
"+cnt = 0",
"+rest = 0",
"- if S[i] == \"o\" and i < nex:",
"- rs.append(i + 1)",
"- nex = i - C",
"- if len(rs) == K:",
"- break",
"-for l, r in zip(ls, rs[::-1]):",
"+ if S[i] == \"o\" and rest <= 0 and cnt < K:",
"+ cand_r.append(i + 1)",
"+ rest = C",
"+ cnt += 1",
"+ else:",
"+ rest -= 1",
"+for l, r in zip(cand_l, cand_r[::-1]):"
] | false | 0.007037 | 0.036755 | 0.191463 | [
"s353353831",
"s683408544"
] |
u072053884 | p02279 | python | s622295604 | s243083699 | 2,540 | 1,390 | 55,664 | 55,676 | Accepted | Accepted | 45.28 | class Node:
def __init__(self, num, parent, children):
self.id = num
self.parent = -1
self.children = children
self.depth = 0
def show_info(self):
print('node {0}: '.format(self.id), end = '')
print('parent = {0}, '.format(self.parent), end = '')
print('depth = {0}, '.format(self.depth), end = '')
if self.children and self.parent != -1:
print('internal node, ', end = '')
elif self.parent != -1:
print('leaf, ', end = '')
else:
print('root, ', end = '')
print(self.children)
def set_node(i_s):
i_l = list(map(int, i_s.split()))
num = i_l[0]
children = i_l[2:]
node = Node(num, -1, children)
T[num] = node
for n in children:
rn_check_list.remove(n)
def set_pd(node, parent, depth):
node.parent = parent
node.depth = depth
for n in node.children:
set_pd(T[n], node.id, depth + 1)
import sys
n = int(sys.stdin.readline())
T = [None for i in range(n)]
rn_check_list = [i for i in range(n)]
for x in sys.stdin.readlines():
set_node(x)
rn_i = rn_check_list[0]
set_pd(T[rn_i], -1, 0)
for n in T:
n.show_info()
| class Node:
def __init__(self, num, parent, children):
self.id = num
self.parent = -1
self.children = children
self.depth = 0
def show_info(self):
print('node {0}: '.format(self.id), end = '')
print('parent = {0}, '.format(self.parent), end = '')
print('depth = {0}, '.format(self.depth), end = '')
if self.children and self.parent != -1:
print('internal node, ', end = '')
elif self.parent != -1:
print('leaf, ', end = '')
else:
print('root, ', end = '')
print(self.children)
def set_node(i_s):
i_l = list(map(int, i_s.split()))
num = i_l[0]
children = i_l[2:]
node = Node(num, -1, children)
T[num] = node
for n in children:
T[-1] -= n
def set_pd(node, parent, depth):
node.parent = parent
node.depth = depth
for n in node.children:
set_pd(T[n], node.id, depth + 1)
import sys
n = int(sys.stdin.readline())
T = [None for i in range(n)]
T.append(int(n * (n - 1) / 2))
for x in sys.stdin.readlines():
set_node(x)
set_pd(T[T[-1]], -1, 0)
for n in T[:-1]:
n.show_info()
| 53 | 51 | 1,269 | 1,228 | class Node:
def __init__(self, num, parent, children):
self.id = num
self.parent = -1
self.children = children
self.depth = 0
def show_info(self):
print("node {0}: ".format(self.id), end="")
print("parent = {0}, ".format(self.parent), end="")
print("depth = {0}, ".format(self.depth), end="")
if self.children and self.parent != -1:
print("internal node, ", end="")
elif self.parent != -1:
print("leaf, ", end="")
else:
print("root, ", end="")
print(self.children)
def set_node(i_s):
i_l = list(map(int, i_s.split()))
num = i_l[0]
children = i_l[2:]
node = Node(num, -1, children)
T[num] = node
for n in children:
rn_check_list.remove(n)
def set_pd(node, parent, depth):
node.parent = parent
node.depth = depth
for n in node.children:
set_pd(T[n], node.id, depth + 1)
import sys
n = int(sys.stdin.readline())
T = [None for i in range(n)]
rn_check_list = [i for i in range(n)]
for x in sys.stdin.readlines():
set_node(x)
rn_i = rn_check_list[0]
set_pd(T[rn_i], -1, 0)
for n in T:
n.show_info()
| class Node:
def __init__(self, num, parent, children):
self.id = num
self.parent = -1
self.children = children
self.depth = 0
def show_info(self):
print("node {0}: ".format(self.id), end="")
print("parent = {0}, ".format(self.parent), end="")
print("depth = {0}, ".format(self.depth), end="")
if self.children and self.parent != -1:
print("internal node, ", end="")
elif self.parent != -1:
print("leaf, ", end="")
else:
print("root, ", end="")
print(self.children)
def set_node(i_s):
i_l = list(map(int, i_s.split()))
num = i_l[0]
children = i_l[2:]
node = Node(num, -1, children)
T[num] = node
for n in children:
T[-1] -= n
def set_pd(node, parent, depth):
node.parent = parent
node.depth = depth
for n in node.children:
set_pd(T[n], node.id, depth + 1)
import sys
n = int(sys.stdin.readline())
T = [None for i in range(n)]
T.append(int(n * (n - 1) / 2))
for x in sys.stdin.readlines():
set_node(x)
set_pd(T[T[-1]], -1, 0)
for n in T[:-1]:
n.show_info()
| false | 3.773585 | [
"- rn_check_list.remove(n)",
"+ T[-1] -= n",
"-rn_check_list = [i for i in range(n)]",
"+T.append(int(n * (n - 1) / 2))",
"-rn_i = rn_check_list[0]",
"-set_pd(T[rn_i], -1, 0)",
"-for n in T:",
"+set_pd(T[T[-1]], -1, 0)",
"+for n in T[:-1]:"
] | false | 0.039668 | 0.038722 | 1.02444 | [
"s622295604",
"s243083699"
] |
u988402778 | p03026 | python | s500547662 | s692723094 | 97 | 82 | 9,604 | 9,640 | Accepted | Accepted | 15.46 | # for i, a in enumerate(iterable)
# q, mod = divmod(a, b)
# divmod(x, y) returns the tuple (x//y, x%y)
# manage median(s) using two heapq https://atcoder.jp/contests/abc127/tasks/abc127_f
# visual studio code shortcut https://qiita.com/TakahiRoyte/items/cdab6fca64da386a690b
# delete line: Ctrl+Shift+k
# choose same words: Ctrl+Shift+l
import sys
sys.setrecursionlimit(10**7)
INF = 10 ** 18
MOD = 10 ** 9 + 7
from itertools import combinations, permutations # https://docs.python.org/ja/3/library/itertools.html
from math import factorial
def combinations_count(n, r):
# faster than the following code
# def combinations_count(n, r):
# return factorial(n) // (factorial(n - r) * factorial(r))
if n - r < r: r = n - r
if r == 0: return 1
if r == 1: return n
numerator = [n - r + k + 1 for k in range(r)]
denominator = [k + 1 for k in range(r)]
for p in range(2,r+1):
pivot = denominator[p - 1]
if pivot > 1:
offset = (n - r) % p
for k in range(p-1,r,p):
numerator[k - offset] /= pivot
denominator[k] /= pivot
result = 1
for k in range(r):
if numerator[k] > 1:
result *= int(numerator[k])
return result
def combination_with_repetition_count(n, r):
return combinations_count(n + r - 1, r)
from collections import deque, Counter # https://docs.python.org/ja/3/library/collections.html#collections.deque
from heapq import heapify, heappop, heappush, heappushpop, heapreplace,nlargest,nsmallest # https://docs.python.org/ja/3/library/heapq.html
from copy import deepcopy, copy # https://docs.python.org/ja/3/library/copy.html
from functools import reduce
from fractions import gcd # Deprecated since version 3.5: Use math.gcd() instead.
def gcds(numbers):
return reduce(gcd, numbers)
def lcm(x, y):
return (x * y) // gcd(x, y)
def lcms(numbers):
return reduce(lcm, numbers, 1)
# set the inputs
# open(0).read() is a convenient method:
# ex) n, m, *x = map(int, open(0).read().split())
# min(x[::2]) - max(x[1::2])
# ex2) *x, = map(int, open(0).read().split())
# don't forget to add comma after *x if only one variable is used
# R = lambda: map(int, input().split()) :it's fashionable, isn't it?
# ex1) n, k = R()
# ex2) v = list(R())
# ex3) bc = [list(R()) for i in range(m)]
# n = 3
# ab = [[1, 3],[2, 3]]
# c = [1, 2, 3]
# c.sort(reverse=True)
R = lambda: list(map(int, input().split()))
n = int(eval(input()))
ab = [R() for i in range(n-1)]
c = R()
c.sort(reverse=True)
# calculate
dic = {}
l = deque()
for a, b in ab:
dic.setdefault(a, []).append(b)
dic.setdefault(b, []).append(a)
m = sum(c) - max(c)
d = [-1] * n
l.extend(dic[1])
d[0] = c[0]
i = 1
while l:
deq = l.popleft()
if d[deq-1] >= 0:
pass
else:
if deq in dic:
l.extend(dic[deq])
d[deq-1] = c[i]
i += 1
print(m)
print((*d))
| # for i, a in enumerate(iterable)
# q, mod = divmod(a, b)
# divmod(x, y) returns the tuple (x//y, x%y)
# manage median(s) using two heapq https://atcoder.jp/contests/abc127/tasks/abc127_f
# visual studio code shortcut https://qiita.com/TakahiRoyte/items/cdab6fca64da386a690b
# delete line: Ctrl+Shift+k
# choose same words: Ctrl+Shift+l
import sys
sys.setrecursionlimit(10**7)
INF = 10 ** 18
MOD = 10 ** 9 + 7
from itertools import combinations, permutations # https://docs.python.org/ja/3/library/itertools.html
from math import factorial
def combinations_count(n, r):
# faster than the following code
# def combinations_count(n, r):
# return factorial(n) // (factorial(n - r) * factorial(r))
if n - r < r: r = n - r
if r == 0: return 1
if r == 1: return n
numerator = [n - r + k + 1 for k in range(r)]
denominator = [k + 1 for k in range(r)]
for p in range(2,r+1):
pivot = denominator[p - 1]
if pivot > 1:
offset = (n - r) % p
for k in range(p-1,r,p):
numerator[k - offset] /= pivot
denominator[k] /= pivot
result = 1
for k in range(r):
if numerator[k] > 1:
result *= int(numerator[k])
return result
def combination_with_repetition_count(n, r):
return combinations_count(n + r - 1, r)
from collections import deque, Counter # https://docs.python.org/ja/3/library/collections.html#collections.deque
from heapq import heapify, heappop, heappush, heappushpop, heapreplace,nlargest,nsmallest # https://docs.python.org/ja/3/library/heapq.html
from copy import deepcopy, copy # https://docs.python.org/ja/3/library/copy.html
from functools import reduce
from fractions import gcd # Deprecated since version 3.5: Use math.gcd() instead.
def gcds(numbers):
return reduce(gcd, numbers)
def lcm(x, y):
return (x * y) // gcd(x, y)
def lcms(numbers):
return reduce(lcm, numbers, 1)
# set the inputs
# open(0).read() is a convenient method:
# ex) n, m, *x = map(int, open(0).read().split())
# min(x[::2]) - max(x[1::2])
# ex2) *x, = map(int, open(0).read().split())
# don't forget to add comma after *x if only one variable is used
# R = lambda: map(int, input().split()) :it's fashionable, isn't it?
# ex1) n, k = R()
# ex2) v = list(R())
# ex3) bc = [list(R()) for i in range(m)]
# n = 3
# ab = [[1, 3],[2, 3]]
# c = [1, 2, 3]
# c.sort(reverse=True)
R = lambda: list(map(int, input().split()))
input2 = sys.stdin.readline
R2 = lambda: list(map(int, input2().split()))
n = int(eval(input()))
ab = [R2() for i in range(n-1)]
c = R2()
c.sort(reverse=True)
# calculate
dic = {}
l = deque()
for a, b in ab:
dic.setdefault(a, []).append(b)
dic.setdefault(b, []).append(a)
m = sum(c) - max(c)
d = [-1] * n
l.extend(dic[1])
d[0] = c[0]
i = 1
while l:
deq = l.popleft()
if d[deq-1] >= 0:
pass
else:
if deq in dic:
l.extend(dic[deq])
d[deq-1] = c[i]
i += 1
print(m)
print((*d))
| 94 | 97 | 3,042 | 3,122 | # for i, a in enumerate(iterable)
# q, mod = divmod(a, b)
# divmod(x, y) returns the tuple (x//y, x%y)
# manage median(s) using two heapq https://atcoder.jp/contests/abc127/tasks/abc127_f
# visual studio code shortcut https://qiita.com/TakahiRoyte/items/cdab6fca64da386a690b
# delete line: Ctrl+Shift+k
# choose same words: Ctrl+Shift+l
import sys
sys.setrecursionlimit(10**7)
INF = 10**18
MOD = 10**9 + 7
from itertools import (
combinations,
permutations,
) # https://docs.python.org/ja/3/library/itertools.html
from math import factorial
def combinations_count(n, r):
# faster than the following code
# def combinations_count(n, r):
# return factorial(n) // (factorial(n - r) * factorial(r))
if n - r < r:
r = n - r
if r == 0:
return 1
if r == 1:
return n
numerator = [n - r + k + 1 for k in range(r)]
denominator = [k + 1 for k in range(r)]
for p in range(2, r + 1):
pivot = denominator[p - 1]
if pivot > 1:
offset = (n - r) % p
for k in range(p - 1, r, p):
numerator[k - offset] /= pivot
denominator[k] /= pivot
result = 1
for k in range(r):
if numerator[k] > 1:
result *= int(numerator[k])
return result
def combination_with_repetition_count(n, r):
return combinations_count(n + r - 1, r)
from collections import (
deque,
Counter,
) # https://docs.python.org/ja/3/library/collections.html#collections.deque
from heapq import (
heapify,
heappop,
heappush,
heappushpop,
heapreplace,
nlargest,
nsmallest,
) # https://docs.python.org/ja/3/library/heapq.html
from copy import deepcopy, copy # https://docs.python.org/ja/3/library/copy.html
from functools import reduce
from fractions import gcd # Deprecated since version 3.5: Use math.gcd() instead.
def gcds(numbers):
return reduce(gcd, numbers)
def lcm(x, y):
return (x * y) // gcd(x, y)
def lcms(numbers):
return reduce(lcm, numbers, 1)
# set the inputs
# open(0).read() is a convenient method:
# ex) n, m, *x = map(int, open(0).read().split())
# min(x[::2]) - max(x[1::2])
# ex2) *x, = map(int, open(0).read().split())
# don't forget to add comma after *x if only one variable is used
# R = lambda: map(int, input().split()) :it's fashionable, isn't it?
# ex1) n, k = R()
# ex2) v = list(R())
# ex3) bc = [list(R()) for i in range(m)]
# n = 3
# ab = [[1, 3],[2, 3]]
# c = [1, 2, 3]
# c.sort(reverse=True)
R = lambda: list(map(int, input().split()))
n = int(eval(input()))
ab = [R() for i in range(n - 1)]
c = R()
c.sort(reverse=True)
# calculate
dic = {}
l = deque()
for a, b in ab:
dic.setdefault(a, []).append(b)
dic.setdefault(b, []).append(a)
m = sum(c) - max(c)
d = [-1] * n
l.extend(dic[1])
d[0] = c[0]
i = 1
while l:
deq = l.popleft()
if d[deq - 1] >= 0:
pass
else:
if deq in dic:
l.extend(dic[deq])
d[deq - 1] = c[i]
i += 1
print(m)
print((*d))
| # for i, a in enumerate(iterable)
# q, mod = divmod(a, b)
# divmod(x, y) returns the tuple (x//y, x%y)
# manage median(s) using two heapq https://atcoder.jp/contests/abc127/tasks/abc127_f
# visual studio code shortcut https://qiita.com/TakahiRoyte/items/cdab6fca64da386a690b
# delete line: Ctrl+Shift+k
# choose same words: Ctrl+Shift+l
import sys
sys.setrecursionlimit(10**7)
INF = 10**18
MOD = 10**9 + 7
from itertools import (
combinations,
permutations,
) # https://docs.python.org/ja/3/library/itertools.html
from math import factorial
def combinations_count(n, r):
# faster than the following code
# def combinations_count(n, r):
# return factorial(n) // (factorial(n - r) * factorial(r))
if n - r < r:
r = n - r
if r == 0:
return 1
if r == 1:
return n
numerator = [n - r + k + 1 for k in range(r)]
denominator = [k + 1 for k in range(r)]
for p in range(2, r + 1):
pivot = denominator[p - 1]
if pivot > 1:
offset = (n - r) % p
for k in range(p - 1, r, p):
numerator[k - offset] /= pivot
denominator[k] /= pivot
result = 1
for k in range(r):
if numerator[k] > 1:
result *= int(numerator[k])
return result
def combination_with_repetition_count(n, r):
return combinations_count(n + r - 1, r)
from collections import (
deque,
Counter,
) # https://docs.python.org/ja/3/library/collections.html#collections.deque
from heapq import (
heapify,
heappop,
heappush,
heappushpop,
heapreplace,
nlargest,
nsmallest,
) # https://docs.python.org/ja/3/library/heapq.html
from copy import deepcopy, copy # https://docs.python.org/ja/3/library/copy.html
from functools import reduce
from fractions import gcd # Deprecated since version 3.5: Use math.gcd() instead.
def gcds(numbers):
return reduce(gcd, numbers)
def lcm(x, y):
return (x * y) // gcd(x, y)
def lcms(numbers):
return reduce(lcm, numbers, 1)
# set the inputs
# open(0).read() is a convenient method:
# ex) n, m, *x = map(int, open(0).read().split())
# min(x[::2]) - max(x[1::2])
# ex2) *x, = map(int, open(0).read().split())
# don't forget to add comma after *x if only one variable is used
# R = lambda: map(int, input().split()) :it's fashionable, isn't it?
# ex1) n, k = R()
# ex2) v = list(R())
# ex3) bc = [list(R()) for i in range(m)]
# n = 3
# ab = [[1, 3],[2, 3]]
# c = [1, 2, 3]
# c.sort(reverse=True)
R = lambda: list(map(int, input().split()))
input2 = sys.stdin.readline
R2 = lambda: list(map(int, input2().split()))
n = int(eval(input()))
ab = [R2() for i in range(n - 1)]
c = R2()
c.sort(reverse=True)
# calculate
dic = {}
l = deque()
for a, b in ab:
dic.setdefault(a, []).append(b)
dic.setdefault(b, []).append(a)
m = sum(c) - max(c)
d = [-1] * n
l.extend(dic[1])
d[0] = c[0]
i = 1
while l:
deq = l.popleft()
if d[deq - 1] >= 0:
pass
else:
if deq in dic:
l.extend(dic[deq])
d[deq - 1] = c[i]
i += 1
print(m)
print((*d))
| false | 3.092784 | [
"+input2 = sys.stdin.readline",
"+R2 = lambda: list(map(int, input2().split()))",
"-ab = [R() for i in range(n - 1)]",
"-c = R()",
"+ab = [R2() for i in range(n - 1)]",
"+c = R2()"
] | false | 0.052713 | 0.04531 | 1.163389 | [
"s500547662",
"s692723094"
] |
u867005447 | p03031 | python | s030972481 | s824348641 | 37 | 29 | 3,064 | 3,064 | Accepted | Accepted | 21.62 | n, m = list(map(int, input().split()))
s = []
for _ in range(m):
tmp = list(map(int, input().split()))
s.append(tmp[1:])
p = list(map(int, input().split()))
ans = 0
for bit in range(0, 1 << n):
flag = 1
for i in range(m):
on_count = 0
for switch in s[i]:
if bit & (1 << (switch-1)):
on_count += 1
if (on_count % 2) != p[i]:
flag = 0
if flag == 1:
ans += 1
print(ans) | n, m = list(map(int, input().split()))
s = [list(map(int, input().split()))[1:] for _ in range(m)]
p = list(map(int, input().split()))
ans = 0
for bit in range(1 << n):
flag = 1
for i in range(m):
on_count = 0
for switch in s[i]:
if bit & (1 << (switch-1)):
on_count += 1
if (on_count % 2) != p[i]:
flag = 0
break
ans += flag
print(ans) | 20 | 16 | 472 | 433 | n, m = list(map(int, input().split()))
s = []
for _ in range(m):
tmp = list(map(int, input().split()))
s.append(tmp[1:])
p = list(map(int, input().split()))
ans = 0
for bit in range(0, 1 << n):
flag = 1
for i in range(m):
on_count = 0
for switch in s[i]:
if bit & (1 << (switch - 1)):
on_count += 1
if (on_count % 2) != p[i]:
flag = 0
if flag == 1:
ans += 1
print(ans)
| n, m = list(map(int, input().split()))
s = [list(map(int, input().split()))[1:] for _ in range(m)]
p = list(map(int, input().split()))
ans = 0
for bit in range(1 << n):
flag = 1
for i in range(m):
on_count = 0
for switch in s[i]:
if bit & (1 << (switch - 1)):
on_count += 1
if (on_count % 2) != p[i]:
flag = 0
break
ans += flag
print(ans)
| false | 20 | [
"-s = []",
"-for _ in range(m):",
"- tmp = list(map(int, input().split()))",
"- s.append(tmp[1:])",
"+s = [list(map(int, input().split()))[1:] for _ in range(m)]",
"-for bit in range(0, 1 << n):",
"+for bit in range(1 << n):",
"- if flag == 1:",
"- ans += 1",
"+ break",
"+ ans += flag"
] | false | 0.037293 | 0.03636 | 1.025657 | [
"s030972481",
"s824348641"
] |
u334712262 | p02550 | python | s447384823 | s612521334 | 567 | 360 | 94,052 | 88,708 | Accepted | Accepted | 36.51 | # -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from fractions import Fraction
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations, accumulate
from operator import add, mul, sub, itemgetter, attrgetter
import sys
# sys.setrecursionlimit(10**6)
# readline = sys.stdin.buffer.readline
readline = sys.stdin.readline
INF = 1 << 60
def read_int():
return int(readline())
def read_int_n():
return list(map(int, readline().split()))
def read_float():
return float(readline())
def read_float_n():
return list(map(float, readline().split()))
def read_str():
return readline().strip()
def read_str_n():
return readline().strip().split()
def ep(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.perf_counter()
ret = f(*args, **kwargs)
e = time.perf_counter()
ep(e - s, 'sec')
return ret
return wrap
@mt
def slv(N, X, M):
ans = 0
x = X
x %= M
x = X
s = [X]
u = set()
while True:
x *= x
x %= M
s.append(x)
if x in u:
break
u.add(x)
i = s.index(s[-1])
if i + 1 >= N:
return sum(s[:N]) % M
N -= i
ans += sum(s[:i])
s = s[i:]
s.pop()
ss = sum(s)
ans += (N // len(s)) * ss
ans += sum(s[:N%len(s)])
return ans
def main():
N, X, M = read_int_n()
print(slv(N, X, M))
if __name__ == '__main__':
main()
| # -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from fractions import Fraction
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations, accumulate
from operator import add, mul, sub, itemgetter, attrgetter
import sys
# sys.setrecursionlimit(10**6)
# readline = sys.stdin.buffer.readline
readline = sys.stdin.readline
INF = 1 << 60
def read_int():
return int(readline())
def read_int_n():
return list(map(int, readline().split()))
def read_float():
return float(readline())
def read_float_n():
return list(map(float, readline().split()))
def read_str():
return readline().strip()
def read_str_n():
return readline().strip().split()
def ep(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.perf_counter()
ret = f(*args, **kwargs)
e = time.perf_counter()
ep(e - s, 'sec')
return ret
return wrap
@mt
def slv(N, X, M):
ans = 0
x = X
x %= M
s = [x]
u = set()
while True:
x *= x
x %= M
s.append(x)
if x in u:
break
u.add(x)
i = s.index(s[-1])
if i + 1 >= N:
return sum(s[:N]) % M
N -= i
ans += sum(s[:i])
s = s[i:]
s.pop()
ss = sum(s)
ans += (N // len(s)) * ss
ans += sum(s[:N%len(s)])
return ans
def main():
N, X, M = read_int_n()
print(slv(N, X, M))
if __name__ == '__main__':
main()
| 101 | 99 | 1,795 | 1,782 | # -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from fractions import Fraction
from functools import lru_cache, reduce
from itertools import (
combinations,
combinations_with_replacement,
product,
permutations,
accumulate,
)
from operator import add, mul, sub, itemgetter, attrgetter
import sys
# sys.setrecursionlimit(10**6)
# readline = sys.stdin.buffer.readline
readline = sys.stdin.readline
INF = 1 << 60
def read_int():
return int(readline())
def read_int_n():
return list(map(int, readline().split()))
def read_float():
return float(readline())
def read_float_n():
return list(map(float, readline().split()))
def read_str():
return readline().strip()
def read_str_n():
return readline().strip().split()
def ep(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.perf_counter()
ret = f(*args, **kwargs)
e = time.perf_counter()
ep(e - s, "sec")
return ret
return wrap
@mt
def slv(N, X, M):
ans = 0
x = X
x %= M
x = X
s = [X]
u = set()
while True:
x *= x
x %= M
s.append(x)
if x in u:
break
u.add(x)
i = s.index(s[-1])
if i + 1 >= N:
return sum(s[:N]) % M
N -= i
ans += sum(s[:i])
s = s[i:]
s.pop()
ss = sum(s)
ans += (N // len(s)) * ss
ans += sum(s[: N % len(s)])
return ans
def main():
N, X, M = read_int_n()
print(slv(N, X, M))
if __name__ == "__main__":
main()
| # -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from fractions import Fraction
from functools import lru_cache, reduce
from itertools import (
combinations,
combinations_with_replacement,
product,
permutations,
accumulate,
)
from operator import add, mul, sub, itemgetter, attrgetter
import sys
# sys.setrecursionlimit(10**6)
# readline = sys.stdin.buffer.readline
readline = sys.stdin.readline
INF = 1 << 60
def read_int():
return int(readline())
def read_int_n():
return list(map(int, readline().split()))
def read_float():
return float(readline())
def read_float_n():
return list(map(float, readline().split()))
def read_str():
return readline().strip()
def read_str_n():
return readline().strip().split()
def ep(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.perf_counter()
ret = f(*args, **kwargs)
e = time.perf_counter()
ep(e - s, "sec")
return ret
return wrap
@mt
def slv(N, X, M):
ans = 0
x = X
x %= M
s = [x]
u = set()
while True:
x *= x
x %= M
s.append(x)
if x in u:
break
u.add(x)
i = s.index(s[-1])
if i + 1 >= N:
return sum(s[:N]) % M
N -= i
ans += sum(s[:i])
s = s[i:]
s.pop()
ss = sum(s)
ans += (N // len(s)) * ss
ans += sum(s[: N % len(s)])
return ans
def main():
N, X, M = read_int_n()
print(slv(N, X, M))
if __name__ == "__main__":
main()
| false | 1.980198 | [
"- x = X",
"- s = [X]",
"+ s = [x]"
] | false | 0.036536 | 0.087008 | 0.419909 | [
"s447384823",
"s612521334"
] |
u014333473 | p03854 | python | s392627719 | s963605918 | 71 | 59 | 9,136 | 9,236 | Accepted | Accepted | 16.9 | S = input()[::-1]
word = ['dream'[::-1], 'dreamer'[::-1], 'erase'[::-1], 'eraser'[::-1]]
judge = [True, True, True, True]
count = 0
while any(judge):
for i in range(len(word)):
if S[:len(word[i])] == word[i]:
S = S[len(word[i]):]
else:
count += 1
if S == '':
print('YES')
exit()
if count == 4:
print('NO')
exit()
count = 0 | a,b,c,d=[i[::-1] for i in ['dream','dreamer','erase','eraser']]
s,j=input()[::-1],True
while j:
j=False
for i in [a,b,c,d]:
if s.startswith(i): s=s[len(i):];j=True
print(('YNEOS'[len(s)>0::2])) | 17 | 7 | 394 | 205 | S = input()[::-1]
word = ["dream"[::-1], "dreamer"[::-1], "erase"[::-1], "eraser"[::-1]]
judge = [True, True, True, True]
count = 0
while any(judge):
for i in range(len(word)):
if S[: len(word[i])] == word[i]:
S = S[len(word[i]) :]
else:
count += 1
if S == "":
print("YES")
exit()
if count == 4:
print("NO")
exit()
count = 0
| a, b, c, d = [i[::-1] for i in ["dream", "dreamer", "erase", "eraser"]]
s, j = input()[::-1], True
while j:
j = False
for i in [a, b, c, d]:
if s.startswith(i):
s = s[len(i) :]
j = True
print(("YNEOS"[len(s) > 0 :: 2]))
| false | 58.823529 | [
"-S = input()[::-1]",
"-word = [\"dream\"[::-1], \"dreamer\"[::-1], \"erase\"[::-1], \"eraser\"[::-1]]",
"-judge = [True, True, True, True]",
"-count = 0",
"-while any(judge):",
"- for i in range(len(word)):",
"- if S[: len(word[i])] == word[i]:",
"- S = S[len(word[i]) :]",
"- else:",
"- count += 1",
"- if S == \"\":",
"- print(\"YES\")",
"- exit()",
"- if count == 4:",
"- print(\"NO\")",
"- exit()",
"- count = 0",
"+a, b, c, d = [i[::-1] for i in [\"dream\", \"dreamer\", \"erase\", \"eraser\"]]",
"+s, j = input()[::-1], True",
"+while j:",
"+ j = False",
"+ for i in [a, b, c, d]:",
"+ if s.startswith(i):",
"+ s = s[len(i) :]",
"+ j = True",
"+print((\"YNEOS\"[len(s) > 0 :: 2]))"
] | false | 0.038992 | 0.142144 | 0.274309 | [
"s392627719",
"s963605918"
] |
u452512115 | p02780 | python | s887357993 | s462003367 | 207 | 162 | 25,060 | 18,456 | Accepted | Accepted | 21.74 | N, K = list(map(int, input().split()))
P = list(map(int, input().split()))
lst = [0]
for x in P:
lst.append(lst[-1] + (x+1)/2)
res = -1
for i in range(N-K+1):
sum = lst[i+K]-lst[i]
res = max(res, sum)
print(("{:.6f}".format(res)))
| import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
import numpy as np
data = np.fromstring(read(), np.int64, sep=' ')
N, K = data[:2]
P = np.hstack([[0], data[2:] + 1])
Pcum = P.cumsum()
x = Pcum[K:] - Pcum[0:-K]
print((x.max() / 2))
| 13 | 15 | 244 | 316 | N, K = list(map(int, input().split()))
P = list(map(int, input().split()))
lst = [0]
for x in P:
lst.append(lst[-1] + (x + 1) / 2)
res = -1
for i in range(N - K + 1):
sum = lst[i + K] - lst[i]
res = max(res, sum)
print(("{:.6f}".format(res)))
| import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
import numpy as np
data = np.fromstring(read(), np.int64, sep=" ")
N, K = data[:2]
P = np.hstack([[0], data[2:] + 1])
Pcum = P.cumsum()
x = Pcum[K:] - Pcum[0:-K]
print((x.max() / 2))
| false | 13.333333 | [
"-N, K = list(map(int, input().split()))",
"-P = list(map(int, input().split()))",
"-lst = [0]",
"-for x in P:",
"- lst.append(lst[-1] + (x + 1) / 2)",
"-res = -1",
"-for i in range(N - K + 1):",
"- sum = lst[i + K] - lst[i]",
"- res = max(res, sum)",
"-print((\"{:.6f}\".format(res)))",
"+import sys",
"+",
"+read = sys.stdin.buffer.read",
"+readline = sys.stdin.buffer.readline",
"+readlines = sys.stdin.buffer.readlines",
"+import numpy as np",
"+",
"+data = np.fromstring(read(), np.int64, sep=\" \")",
"+N, K = data[:2]",
"+P = np.hstack([[0], data[2:] + 1])",
"+Pcum = P.cumsum()",
"+x = Pcum[K:] - Pcum[0:-K]",
"+print((x.max() / 2))"
] | false | 0.038794 | 0.279036 | 0.13903 | [
"s887357993",
"s462003367"
] |
u063052907 | p03244 | python | s070673222 | s923953662 | 118 | 101 | 21,076 | 21,084 | Accepted | Accepted | 14.41 | from collections import Counter, OrderedDict
n = int(eval(input()))
lst_v = list(map(int, input().split()))
if len(set(lst_v)) == 1:
ans = n // 2
else:
lst_odd = [lst_v[i] for i in range(n) if i%2==0]
lst_even = [lst_v[i] for i in range(n) if i%2!=0]
cnt_odd = sorted(list(Counter(lst_odd).items()), key=lambda x: -x[1])
cnt_even = sorted(list(Counter(lst_even).items()), key=lambda x :-x[1])
if cnt_odd[0][0] == cnt_even[0][0]:
rem_number = max(cnt_odd[0][1] + cnt_even[1][1], cnt_odd[1][1] + cnt_even[0][1])
else:
rem_number = cnt_odd[0][1] + cnt_even[0][1]
sum_odd = sum(t[1] for t in cnt_odd)
sum_even = sum(t[1] for t in cnt_even)
ans = sum_odd + sum_even - rem_number
print(ans)
| from collections import Counter
n = int(eval(input()))
lst_v = list(map(int, input().split()))
if len(set(lst_v)) == 1:
ans = n // 2
else:
lst_odd = lst_v[::2]
lst_even = lst_v[1::2]
cnt_odd = sorted(list(Counter(lst_odd).items()), key=lambda x: -x[1])
cnt_even = sorted(list(Counter(lst_even).items()), key=lambda x :-x[1])
o1 = cnt_odd[0]
e1 = cnt_even[0]
if o1[0] == e1[0]:
o2 = cnt_odd[1] if cnt_odd[1] else (0, 0)
e2 = cnt_even[1] if cnt_even[1] else (0, 0)
rem_number = max(o1[1] + e2[1], o2[1] + e1[1])
else:
rem_number = o1[1] + e1[1]
sum_odd = sum(t[1] for t in cnt_odd)
sum_even = sum(t[1] for t in cnt_even)
ans = sum_odd + sum_even - rem_number
print(ans)
| 25 | 29 | 754 | 765 | from collections import Counter, OrderedDict
n = int(eval(input()))
lst_v = list(map(int, input().split()))
if len(set(lst_v)) == 1:
ans = n // 2
else:
lst_odd = [lst_v[i] for i in range(n) if i % 2 == 0]
lst_even = [lst_v[i] for i in range(n) if i % 2 != 0]
cnt_odd = sorted(list(Counter(lst_odd).items()), key=lambda x: -x[1])
cnt_even = sorted(list(Counter(lst_even).items()), key=lambda x: -x[1])
if cnt_odd[0][0] == cnt_even[0][0]:
rem_number = max(cnt_odd[0][1] + cnt_even[1][1], cnt_odd[1][1] + cnt_even[0][1])
else:
rem_number = cnt_odd[0][1] + cnt_even[0][1]
sum_odd = sum(t[1] for t in cnt_odd)
sum_even = sum(t[1] for t in cnt_even)
ans = sum_odd + sum_even - rem_number
print(ans)
| from collections import Counter
n = int(eval(input()))
lst_v = list(map(int, input().split()))
if len(set(lst_v)) == 1:
ans = n // 2
else:
lst_odd = lst_v[::2]
lst_even = lst_v[1::2]
cnt_odd = sorted(list(Counter(lst_odd).items()), key=lambda x: -x[1])
cnt_even = sorted(list(Counter(lst_even).items()), key=lambda x: -x[1])
o1 = cnt_odd[0]
e1 = cnt_even[0]
if o1[0] == e1[0]:
o2 = cnt_odd[1] if cnt_odd[1] else (0, 0)
e2 = cnt_even[1] if cnt_even[1] else (0, 0)
rem_number = max(o1[1] + e2[1], o2[1] + e1[1])
else:
rem_number = o1[1] + e1[1]
sum_odd = sum(t[1] for t in cnt_odd)
sum_even = sum(t[1] for t in cnt_even)
ans = sum_odd + sum_even - rem_number
print(ans)
| false | 13.793103 | [
"-from collections import Counter, OrderedDict",
"+from collections import Counter",
"- lst_odd = [lst_v[i] for i in range(n) if i % 2 == 0]",
"- lst_even = [lst_v[i] for i in range(n) if i % 2 != 0]",
"+ lst_odd = lst_v[::2]",
"+ lst_even = lst_v[1::2]",
"- if cnt_odd[0][0] == cnt_even[0][0]:",
"- rem_number = max(cnt_odd[0][1] + cnt_even[1][1], cnt_odd[1][1] + cnt_even[0][1])",
"+ o1 = cnt_odd[0]",
"+ e1 = cnt_even[0]",
"+ if o1[0] == e1[0]:",
"+ o2 = cnt_odd[1] if cnt_odd[1] else (0, 0)",
"+ e2 = cnt_even[1] if cnt_even[1] else (0, 0)",
"+ rem_number = max(o1[1] + e2[1], o2[1] + e1[1])",
"- rem_number = cnt_odd[0][1] + cnt_even[0][1]",
"+ rem_number = o1[1] + e1[1]"
] | false | 0.036022 | 0.035803 | 1.006108 | [
"s070673222",
"s923953662"
] |
u057109575 | p02936 | python | s904269216 | s140134664 | 1,997 | 801 | 122,476 | 182,608 | Accepted | Accepted | 59.89 | from collections import deque
N, Q = list(map(int, input().split()))
X = [list(map(int, input().split())) for _ in range(N - 1)]
Y = [list(map(int, input().split())) for _ in range(Q)]
graph = [[] for _ in range(N + 1)]
for a, b in X:
graph[a].append(b)
graph[b].append(a)
ctr = [0] * (N + 1)
for p, x in Y:
ctr[p] += x
# BFS
visited = [False] * (N + 1)
visited[1] = True
q = deque([1])
while q:
u = q.popleft()
for v in graph[u]:
if visited[v]:
continue
ctr[v] += ctr[u]
visited[v] = True
q.append(v)
print((*ctr[1:]))
| from collections import deque
N, Q = list(map(int, input().split()))
X = [list(map(int, input().split())) for _ in range(N - 1)]
Y = [list(map(int, input().split())) for _ in range(Q)]
tree = [0] * (N + 1)
for p, x in Y:
tree[p] += x
graph = [[] for _ in range(N + 1)]
for a, b in X:
graph[a].append(b)
graph[b].append(a)
visited = [False] * (N + 1)
visited[1] = True
stack = deque()
stack.append(1)
while stack:
u = stack.popleft()
for v in graph[u]:
if not visited[v]:
visited[v] = True
tree[v] += tree[u]
stack.append(v)
print((*tree[1:]))
| 30 | 28 | 631 | 643 | from collections import deque
N, Q = list(map(int, input().split()))
X = [list(map(int, input().split())) for _ in range(N - 1)]
Y = [list(map(int, input().split())) for _ in range(Q)]
graph = [[] for _ in range(N + 1)]
for a, b in X:
graph[a].append(b)
graph[b].append(a)
ctr = [0] * (N + 1)
for p, x in Y:
ctr[p] += x
# BFS
visited = [False] * (N + 1)
visited[1] = True
q = deque([1])
while q:
u = q.popleft()
for v in graph[u]:
if visited[v]:
continue
ctr[v] += ctr[u]
visited[v] = True
q.append(v)
print((*ctr[1:]))
| from collections import deque
N, Q = list(map(int, input().split()))
X = [list(map(int, input().split())) for _ in range(N - 1)]
Y = [list(map(int, input().split())) for _ in range(Q)]
tree = [0] * (N + 1)
for p, x in Y:
tree[p] += x
graph = [[] for _ in range(N + 1)]
for a, b in X:
graph[a].append(b)
graph[b].append(a)
visited = [False] * (N + 1)
visited[1] = True
stack = deque()
stack.append(1)
while stack:
u = stack.popleft()
for v in graph[u]:
if not visited[v]:
visited[v] = True
tree[v] += tree[u]
stack.append(v)
print((*tree[1:]))
| false | 6.666667 | [
"+tree = [0] * (N + 1)",
"+for p, x in Y:",
"+ tree[p] += x",
"-ctr = [0] * (N + 1)",
"-for p, x in Y:",
"- ctr[p] += x",
"-# BFS",
"-q = deque([1])",
"-while q:",
"- u = q.popleft()",
"+stack = deque()",
"+stack.append(1)",
"+while stack:",
"+ u = stack.popleft()",
"- if visited[v]:",
"- continue",
"- ctr[v] += ctr[u]",
"- visited[v] = True",
"- q.append(v)",
"-print((*ctr[1:]))",
"+ if not visited[v]:",
"+ visited[v] = True",
"+ tree[v] += tree[u]",
"+ stack.append(v)",
"+print((*tree[1:]))"
] | false | 0.037205 | 0.038331 | 0.970642 | [
"s904269216",
"s140134664"
] |
u905582793 | p02762 | python | s745323404 | s825353599 | 1,610 | 1,138 | 127,192 | 65,748 | Accepted | Accepted | 29.32 | class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
n,m,k = map(int,input().split())
ab = [list(map(int,input().split())) for i in range(m)]
cd = [list(map(int,input().split())) for i in range(k)]
num = [0]*(n+1)
g = [[] for i in range(n+1)]
uf = UnionFind(n+1)
for a,b in ab:
g[a].append(b)
g[b].append(a)
uf.union(a,b)
for c,d in cd:
if uf.same(c,d) == True:
g[c].append(d)
g[d].append(c)
for i in range(1,n+1):
print(uf.size(i)-len(g[i])-1,end=" ")
| class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
import sys
input=sys.stdin.readline
n,m,k = map(int,input().split())
ab = [list(map(int,input().split())) for i in range(m)]
cd = [list(map(int,input().split())) for i in range(k)]
num = [0]*(n+1)
g = [[] for i in range(n+1)]
uf = UnionFind(n+1)
for a,b in ab:
g[a].append(b)
g[b].append(a)
uf.union(a,b)
for c,d in cd:
if uf.same(c,d) == True:
g[c].append(d)
g[d].append(c)
for i in range(1,n+1):
print(uf.size(i)-len(g[i])-1,end=" ")
| 63 | 64 | 1,626 | 1,663 | class UnionFind:
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return "\n".join("{}: {}".format(r, self.members(r)) for r in self.roots())
n, m, k = map(int, input().split())
ab = [list(map(int, input().split())) for i in range(m)]
cd = [list(map(int, input().split())) for i in range(k)]
num = [0] * (n + 1)
g = [[] for i in range(n + 1)]
uf = UnionFind(n + 1)
for a, b in ab:
g[a].append(b)
g[b].append(a)
uf.union(a, b)
for c, d in cd:
if uf.same(c, d) == True:
g[c].append(d)
g[d].append(c)
for i in range(1, n + 1):
print(uf.size(i) - len(g[i]) - 1, end=" ")
| class UnionFind:
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return "\n".join("{}: {}".format(r, self.members(r)) for r in self.roots())
import sys
input = sys.stdin.readline
n, m, k = map(int, input().split())
ab = [list(map(int, input().split())) for i in range(m)]
cd = [list(map(int, input().split())) for i in range(k)]
num = [0] * (n + 1)
g = [[] for i in range(n + 1)]
uf = UnionFind(n + 1)
for a, b in ab:
g[a].append(b)
g[b].append(a)
uf.union(a, b)
for c, d in cd:
if uf.same(c, d) == True:
g[c].append(d)
g[d].append(c)
for i in range(1, n + 1):
print(uf.size(i) - len(g[i]) - 1, end=" ")
| false | 1.5625 | [
"+import sys",
"+",
"+input = sys.stdin.readline"
] | false | 0.083769 | 0.072365 | 1.157586 | [
"s745323404",
"s825353599"
] |
u606045429 | p02889 | python | s586245673 | s390715574 | 1,740 | 861 | 17,500 | 40,856 | Accepted | Accepted | 50.52 | from scipy.sparse.csgraph import floyd_warshall
N, M, L = list(map(int, input().split()))
E = [[0] * N for _ in range(N)]
for _ in range(M):
a, b, c = list(map(int, input().split()))
E[a - 1][b - 1] = E[b - 1][a - 1] = c
E = floyd_warshall(E)
for i in range(N):
for j in range(N):
E[i][j] = (E[i][j] <= L)
E = floyd_warshall(E)
INF = float("inf")
Q = int(eval(input()))
for _ in range(Q):
s, t = list(map(int, input().split()))
a = E[s - 1][t - 1] - 1
print((-1 if a == INF else int(a)))
| from scipy.sparse.csgraph import floyd_warshall
N, M, L, *I = list(map(int, open(0).read().split()))
ABC, ST = I[:3 * M], I[3 * M + 1:]
E = [[0] * N for _ in range(N)]
for a, b, c in zip(*[iter(ABC)] * 3):
E[a - 1][b - 1] = E[b - 1][a - 1] = c
E = floyd_warshall(E)
for i in range(N):
for j in range(N):
E[i][j] = (E[i][j] <= L)
E = floyd_warshall(E)
INF = float("inf")
for s, t in zip(*[iter(ST)] * 2):
a = E[s - 1][t - 1] - 1
print((-1 if a == INF else int(a)))
| 23 | 22 | 522 | 508 | from scipy.sparse.csgraph import floyd_warshall
N, M, L = list(map(int, input().split()))
E = [[0] * N for _ in range(N)]
for _ in range(M):
a, b, c = list(map(int, input().split()))
E[a - 1][b - 1] = E[b - 1][a - 1] = c
E = floyd_warshall(E)
for i in range(N):
for j in range(N):
E[i][j] = E[i][j] <= L
E = floyd_warshall(E)
INF = float("inf")
Q = int(eval(input()))
for _ in range(Q):
s, t = list(map(int, input().split()))
a = E[s - 1][t - 1] - 1
print((-1 if a == INF else int(a)))
| from scipy.sparse.csgraph import floyd_warshall
N, M, L, *I = list(map(int, open(0).read().split()))
ABC, ST = I[: 3 * M], I[3 * M + 1 :]
E = [[0] * N for _ in range(N)]
for a, b, c in zip(*[iter(ABC)] * 3):
E[a - 1][b - 1] = E[b - 1][a - 1] = c
E = floyd_warshall(E)
for i in range(N):
for j in range(N):
E[i][j] = E[i][j] <= L
E = floyd_warshall(E)
INF = float("inf")
for s, t in zip(*[iter(ST)] * 2):
a = E[s - 1][t - 1] - 1
print((-1 if a == INF else int(a)))
| false | 4.347826 | [
"-N, M, L = list(map(int, input().split()))",
"+N, M, L, *I = list(map(int, open(0).read().split()))",
"+ABC, ST = I[: 3 * M], I[3 * M + 1 :]",
"-for _ in range(M):",
"- a, b, c = list(map(int, input().split()))",
"+for a, b, c in zip(*[iter(ABC)] * 3):",
"-Q = int(eval(input()))",
"-for _ in range(Q):",
"- s, t = list(map(int, input().split()))",
"+for s, t in zip(*[iter(ST)] * 2):"
] | false | 0.676085 | 0.776715 | 0.870441 | [
"s586245673",
"s390715574"
] |
u573754721 | p02953 | python | s835396055 | s338623430 | 80 | 71 | 14,252 | 14,224 | Accepted | Accepted | 11.25 | n = int(eval(input()))
L = list(map(int,input().split()))
for i in range(n,1,-1):
if L[i-1]<L[i-2]:
L[i-2]-=1
if L[i-1]<L[i-2]:
print("No")
exit()
print("Yes") | n = int(eval(input()))
L = list(map(int,input().split()))
for i in range(n-1,0,-1):
if L[i]<L[i-1]:
L[i-1]-=1
if L[i]<L[i-1]:
print("No")
exit()
print("Yes")
| 10 | 11 | 229 | 240 | n = int(eval(input()))
L = list(map(int, input().split()))
for i in range(n, 1, -1):
if L[i - 1] < L[i - 2]:
L[i - 2] -= 1
if L[i - 1] < L[i - 2]:
print("No")
exit()
print("Yes")
| n = int(eval(input()))
L = list(map(int, input().split()))
for i in range(n - 1, 0, -1):
if L[i] < L[i - 1]:
L[i - 1] -= 1
if L[i] < L[i - 1]:
print("No")
exit()
print("Yes")
| false | 9.090909 | [
"-for i in range(n, 1, -1):",
"- if L[i - 1] < L[i - 2]:",
"- L[i - 2] -= 1",
"- if L[i - 1] < L[i - 2]:",
"+for i in range(n - 1, 0, -1):",
"+ if L[i] < L[i - 1]:",
"+ L[i - 1] -= 1",
"+ if L[i] < L[i - 1]:"
] | false | 0.094985 | 0.070824 | 1.34114 | [
"s835396055",
"s338623430"
] |
u849029577 | p03331 | python | s323963897 | s857586772 | 104 | 61 | 73,744 | 61,808 | Accepted | Accepted | 41.35 | n = int(eval(input()))
ans = 100000
for i in range(1, n):
a, b = str(i), str(n-i)
A, B = 0, 0
for x in a:
A += int(x)
for y in b:
B += int(y)
ans = min(ans, A+B)
print(ans) | n = int(eval(input()))
for i in range(1,6):
if n%(10*i) == 0:
print((10))
exit()
print((sum(list(map(int, str(n)))))) | 11 | 6 | 212 | 132 | n = int(eval(input()))
ans = 100000
for i in range(1, n):
a, b = str(i), str(n - i)
A, B = 0, 0
for x in a:
A += int(x)
for y in b:
B += int(y)
ans = min(ans, A + B)
print(ans)
| n = int(eval(input()))
for i in range(1, 6):
if n % (10 * i) == 0:
print((10))
exit()
print((sum(list(map(int, str(n))))))
| false | 45.454545 | [
"-ans = 100000",
"-for i in range(1, n):",
"- a, b = str(i), str(n - i)",
"- A, B = 0, 0",
"- for x in a:",
"- A += int(x)",
"- for y in b:",
"- B += int(y)",
"- ans = min(ans, A + B)",
"-print(ans)",
"+for i in range(1, 6):",
"+ if n % (10 * i) == 0:",
"+ print((10))",
"+ exit()",
"+print((sum(list(map(int, str(n))))))"
] | false | 0.239892 | 0.06935 | 3.459129 | [
"s323963897",
"s857586772"
] |
u137228327 | p02887 | python | s340593759 | s589540118 | 192 | 47 | 9,740 | 9,256 | Accepted | Accepted | 75.52 | N = int(eval(input()))
S = str(eval(input()))
#print(N,S)
stack = []
while len(S) > 0:
if len(stack) == 0:
stack.append(S[0])
S = S[1:]
elif S[0] == stack[-1]:
S = S[1:]
elif S[0] != stack[-1]:
stack.append(S[0])
S = S[1:]
#print(S,stack)
print((len(stack)))
| N = int(eval(input()))
S = str(eval(input()))
#print(N,S)
count = 0
for i in range(N-1):
if S[i] != S[i+1]:
count += 1
print((count+1))
| 18 | 10 | 333 | 160 | N = int(eval(input()))
S = str(eval(input()))
# print(N,S)
stack = []
while len(S) > 0:
if len(stack) == 0:
stack.append(S[0])
S = S[1:]
elif S[0] == stack[-1]:
S = S[1:]
elif S[0] != stack[-1]:
stack.append(S[0])
S = S[1:]
# print(S,stack)
print((len(stack)))
| N = int(eval(input()))
S = str(eval(input()))
# print(N,S)
count = 0
for i in range(N - 1):
if S[i] != S[i + 1]:
count += 1
print((count + 1))
| false | 44.444444 | [
"-stack = []",
"-while len(S) > 0:",
"- if len(stack) == 0:",
"- stack.append(S[0])",
"- S = S[1:]",
"- elif S[0] == stack[-1]:",
"- S = S[1:]",
"- elif S[0] != stack[-1]:",
"- stack.append(S[0])",
"- S = S[1:]",
"- # print(S,stack)",
"-print((len(stack)))",
"+count = 0",
"+for i in range(N - 1):",
"+ if S[i] != S[i + 1]:",
"+ count += 1",
"+print((count + 1))"
] | false | 0.064093 | 0.062134 | 1.031537 | [
"s340593759",
"s589540118"
] |
u693953100 | p04045 | python | s832575276 | s548416614 | 214 | 115 | 43,484 | 3,060 | Accepted | Accepted | 46.26 | n,k = list(map(int,input().split()))
d = list(input().split(' '))
def check(num):
globals()
s = str(n)
for i in d:
if i in s:
return True
return False
while(check(n)):
n+=1
print(n) | def solve():
n,k = list(map(int,input().split()))
d = set(map(int,input().split()))
for i in range(n,100000):
s = list(map(int,str(i)))
flag = True
for j in s:
if j in d:
flag = False
if flag:
print(i)
return
if __name__ == "__main__":
solve() | 12 | 15 | 226 | 346 | n, k = list(map(int, input().split()))
d = list(input().split(" "))
def check(num):
globals()
s = str(n)
for i in d:
if i in s:
return True
return False
while check(n):
n += 1
print(n)
| def solve():
n, k = list(map(int, input().split()))
d = set(map(int, input().split()))
for i in range(n, 100000):
s = list(map(int, str(i)))
flag = True
for j in s:
if j in d:
flag = False
if flag:
print(i)
return
if __name__ == "__main__":
solve()
| false | 20 | [
"-n, k = list(map(int, input().split()))",
"-d = list(input().split(\" \"))",
"+def solve():",
"+ n, k = list(map(int, input().split()))",
"+ d = set(map(int, input().split()))",
"+ for i in range(n, 100000):",
"+ s = list(map(int, str(i)))",
"+ flag = True",
"+ for j in s:",
"+ if j in d:",
"+ flag = False",
"+ if flag:",
"+ print(i)",
"+ return",
"-def check(num):",
"- globals()",
"- s = str(n)",
"- for i in d:",
"- if i in s:",
"- return True",
"- return False",
"-",
"-",
"-while check(n):",
"- n += 1",
"-print(n)",
"+if __name__ == \"__main__\":",
"+ solve()"
] | false | 0.111304 | 0.126763 | 0.878045 | [
"s832575276",
"s548416614"
] |
u638282348 | p02679 | python | s976390034 | s489537708 | 1,211 | 1,117 | 90,112 | 72,012 | Accepted | Accepted | 7.76 | from math import gcd
MOD = 10 ** 9 + 7
N = int(eval(input()))
d = dict()
zeros = 0
for _ in range(N):
a, b = tuple(map(int, input().split()))
if not any((a, b)):
zeros += 1
continue
g = gcd(a, b) * (a // abs(a)) if all((a, b)) else a if a else b
p = a // g, b // g
d[p] = d.get(p, 0) + 1
counts = dict()
for (a, b), v in list(d.items()):
if counts.get((b, -a), False) or counts.get((-b, a), False):
continue
counts[(a, b)] = v, d.get((b, -a), 0) + d.get((-b, a), 0)
total = 1
for a, b in list(counts.values()):
total = (total * (pow(2, a, MOD) + pow(2, b, MOD) - 1)) % MOD
print(((total + zeros + MOD - 1) % MOD)) | from math import gcd
MOD = 10 ** 9 + 7
N = int(eval(input()))
d = dict()
zeros = 0
for _ in range(N):
a, b = tuple(map(int, input().split()))
if not any((a, b)):
zeros += 1
continue
g = gcd(a, b) * (a // abs(a)) if all((a, b)) else a if a else b
p = a // g, b // g
d[p] = d.get(p, 0) + 1
done = set()
total = 1
for (a, b), v in list(d.items()):
if (b, -a) in done or (-b, a) in done:
continue
done.add((a, b))
w = d.get((b, -a), 0) + d.get((-b, a), 0)
total = total * (pow(2, v, MOD) + pow(2, w, MOD) - 1) % MOD
print(((total + zeros + MOD - 1) % MOD)) | 22 | 22 | 670 | 619 | from math import gcd
MOD = 10**9 + 7
N = int(eval(input()))
d = dict()
zeros = 0
for _ in range(N):
a, b = tuple(map(int, input().split()))
if not any((a, b)):
zeros += 1
continue
g = gcd(a, b) * (a // abs(a)) if all((a, b)) else a if a else b
p = a // g, b // g
d[p] = d.get(p, 0) + 1
counts = dict()
for (a, b), v in list(d.items()):
if counts.get((b, -a), False) or counts.get((-b, a), False):
continue
counts[(a, b)] = v, d.get((b, -a), 0) + d.get((-b, a), 0)
total = 1
for a, b in list(counts.values()):
total = (total * (pow(2, a, MOD) + pow(2, b, MOD) - 1)) % MOD
print(((total + zeros + MOD - 1) % MOD))
| from math import gcd
MOD = 10**9 + 7
N = int(eval(input()))
d = dict()
zeros = 0
for _ in range(N):
a, b = tuple(map(int, input().split()))
if not any((a, b)):
zeros += 1
continue
g = gcd(a, b) * (a // abs(a)) if all((a, b)) else a if a else b
p = a // g, b // g
d[p] = d.get(p, 0) + 1
done = set()
total = 1
for (a, b), v in list(d.items()):
if (b, -a) in done or (-b, a) in done:
continue
done.add((a, b))
w = d.get((b, -a), 0) + d.get((-b, a), 0)
total = total * (pow(2, v, MOD) + pow(2, w, MOD) - 1) % MOD
print(((total + zeros + MOD - 1) % MOD))
| false | 0 | [
"-counts = dict()",
"+done = set()",
"+total = 1",
"- if counts.get((b, -a), False) or counts.get((-b, a), False):",
"+ if (b, -a) in done or (-b, a) in done:",
"- counts[(a, b)] = v, d.get((b, -a), 0) + d.get((-b, a), 0)",
"-total = 1",
"-for a, b in list(counts.values()):",
"- total = (total * (pow(2, a, MOD) + pow(2, b, MOD) - 1)) % MOD",
"+ done.add((a, b))",
"+ w = d.get((b, -a), 0) + d.get((-b, a), 0)",
"+ total = total * (pow(2, v, MOD) + pow(2, w, MOD) - 1) % MOD"
] | false | 0.037111 | 0.036676 | 1.011849 | [
"s976390034",
"s489537708"
] |
u652057333 | p02789 | python | s615972705 | s988921789 | 173 | 17 | 38,256 | 2,940 | Accepted | Accepted | 90.17 | n, m = list(map(int, input().split()))
if n == m:
print("Yes")
else:
print("No") | n, m = list(map(int, input().split()))
print((['No', 'Yes'][n == m])) | 6 | 2 | 88 | 62 | n, m = list(map(int, input().split()))
if n == m:
print("Yes")
else:
print("No")
| n, m = list(map(int, input().split()))
print((["No", "Yes"][n == m]))
| false | 66.666667 | [
"-if n == m:",
"- print(\"Yes\")",
"-else:",
"- print(\"No\")",
"+print(([\"No\", \"Yes\"][n == m]))"
] | false | 0.037457 | 0.041453 | 0.903619 | [
"s615972705",
"s988921789"
] |
u278886389 | p03948 | python | s819250734 | s302694443 | 206 | 162 | 14,484 | 15,060 | Accepted | Accepted | 21.36 | N,T = list(map(int,input().split()))
A = list(map(int,input().split()))
h = []
B = [0]*N
for i in range(N):
h.append(A[i])
h = [min(h)]
B[i] = h[0]
j = []
C = [0]*N
for i in range(N-1,-1,-1):
j.append(A[i])
j = [max(j)]
C[i] = j[0]
B = B[:-1]
C = C[1:]
D = list([C[x]-B[x] for x in range(N-1)])
t = max(D)
s = 0
D.append(0)
for i in range(N-1):
if D[i] == t and D[i] > D[i+1]:
s += 1
print(s)
| N,T = list(map(int,input().split()))
A = list(map(int,input().split()))
B = [0]*N
C = [0]*N
h = A[0]
B[0] = h
for i in range(1,N):
h = min(A[i],h)
B[i] = h
h = A[-1]
C[-1] = h
for i in range(N-2,-1,-1):
h = max(A[i],h)
C[i] = h
B = B[:-1]
C = C[1:]
D = list([C[x]-B[x] for x in range(N-1)])
t = max(D)
s = 0
D.append(0)
for i in range(N-1):
if D[i] == t and D[i] > D[i+1]:
s += 1
print(s)
| 31 | 30 | 463 | 449 | N, T = list(map(int, input().split()))
A = list(map(int, input().split()))
h = []
B = [0] * N
for i in range(N):
h.append(A[i])
h = [min(h)]
B[i] = h[0]
j = []
C = [0] * N
for i in range(N - 1, -1, -1):
j.append(A[i])
j = [max(j)]
C[i] = j[0]
B = B[:-1]
C = C[1:]
D = list([C[x] - B[x] for x in range(N - 1)])
t = max(D)
s = 0
D.append(0)
for i in range(N - 1):
if D[i] == t and D[i] > D[i + 1]:
s += 1
print(s)
| N, T = list(map(int, input().split()))
A = list(map(int, input().split()))
B = [0] * N
C = [0] * N
h = A[0]
B[0] = h
for i in range(1, N):
h = min(A[i], h)
B[i] = h
h = A[-1]
C[-1] = h
for i in range(N - 2, -1, -1):
h = max(A[i], h)
C[i] = h
B = B[:-1]
C = C[1:]
D = list([C[x] - B[x] for x in range(N - 1)])
t = max(D)
s = 0
D.append(0)
for i in range(N - 1):
if D[i] == t and D[i] > D[i + 1]:
s += 1
print(s)
| false | 3.225806 | [
"-h = []",
"-for i in range(N):",
"- h.append(A[i])",
"- h = [min(h)]",
"- B[i] = h[0]",
"-j = []",
"-for i in range(N - 1, -1, -1):",
"- j.append(A[i])",
"- j = [max(j)]",
"- C[i] = j[0]",
"+h = A[0]",
"+B[0] = h",
"+for i in range(1, N):",
"+ h = min(A[i], h)",
"+ B[i] = h",
"+h = A[-1]",
"+C[-1] = h",
"+for i in range(N - 2, -1, -1):",
"+ h = max(A[i], h)",
"+ C[i] = h"
] | false | 0.10507 | 0.049131 | 2.138562 | [
"s819250734",
"s302694443"
] |
u627600101 | p02580 | python | s821527818 | s368883649 | 745 | 552 | 160,912 | 154,772 | Accepted | Accepted | 25.91 | from collections import deque
import heapq
H, W, M = list(map(int, input().split()))
bomb = []
heapq.heapify(bomb)
counth = [0 for k in range(H)]
countw = [0 for k in range(W)]
for k in range(M):
h, w = list(map(int, input().split()))
h -= 1
w -= 1
heapq.heappush(bomb, h+ w*H)
counth[h] += 1
countw[w] += 1
counth = deque(counth)
countw = deque(countw)
maxh = max(counth)
maxw = max(countw)
index_h = deque([])
index_w = []
for k in range(H):
h = counth.popleft()
if h == maxh:
index_h.append(k)
for k in range(W):
w = countw.popleft()
if w == maxw:
index_w.append(k)
ans = maxh + maxw - 1
lenh = len(index_h)
lenw = len(index_w)
if lenh*lenw > M:
ans += 1
else:
kouho = []
heapq.heapify(kouho)
for i in range(lenh):
h = index_h.pop()
for j in range(lenw):
w = index_w[j]
heapq.heappush(kouho, h+ H*w)
B = heapq.heappop(bomb)
K = heapq.heappop(kouho)
while True:
if B > K:
ans += 1
break
elif B == K:
if len(kouho) == 0:
break
else:
K = heapq.heappop(kouho)
else:
if len(bomb) == 0:
ans += 1
break
else:
B = heapq.heappop(bomb)
print(ans)
| from collections import deque
H, W, M = list(map(int, input().split()))
bomb = []
counth = [0 for k in range(H)]
countw = [0 for k in range(W)]
for k in range(M):
h, w = list(map(int, input().split()))
h -= 1
w -= 1
bomb.append(h+ w*H)
counth[h] += 1
countw[w] += 1
counth = deque(counth)
countw = deque(countw)
maxh = max(counth)
maxw = max(countw)
index_h = deque([])
index_w = []
for k in range(H):
h = counth.popleft()
if h == maxh:
index_h.append(k)
for k in range(W):
w = countw.popleft()
if w == maxw:
index_w.append(k)
ans = maxh + maxw - 1
lenh = len(index_h)
lenw = len(index_w)
if lenh*lenw > M:
ans += 1
else:
bomb.sort()
bomb = deque(bomb)
kouho = []
for i in range(lenh):
h = index_h.pop()
for j in range(lenw):
w = index_w[j]
kouho.append(h+ H*w)
kouho.sort()
kouho = deque(kouho)
B = bomb.popleft()
K = kouho.popleft()
while True:
if B > K:
ans += 1
break
elif B == K:
if len(kouho) == 0:
break
else:
K = kouho.popleft()
else:
if len(bomb) == 0:
ans += 1
break
else:
B = bomb.popleft()
print(ans)
| 64 | 65 | 1,247 | 1,227 | from collections import deque
import heapq
H, W, M = list(map(int, input().split()))
bomb = []
heapq.heapify(bomb)
counth = [0 for k in range(H)]
countw = [0 for k in range(W)]
for k in range(M):
h, w = list(map(int, input().split()))
h -= 1
w -= 1
heapq.heappush(bomb, h + w * H)
counth[h] += 1
countw[w] += 1
counth = deque(counth)
countw = deque(countw)
maxh = max(counth)
maxw = max(countw)
index_h = deque([])
index_w = []
for k in range(H):
h = counth.popleft()
if h == maxh:
index_h.append(k)
for k in range(W):
w = countw.popleft()
if w == maxw:
index_w.append(k)
ans = maxh + maxw - 1
lenh = len(index_h)
lenw = len(index_w)
if lenh * lenw > M:
ans += 1
else:
kouho = []
heapq.heapify(kouho)
for i in range(lenh):
h = index_h.pop()
for j in range(lenw):
w = index_w[j]
heapq.heappush(kouho, h + H * w)
B = heapq.heappop(bomb)
K = heapq.heappop(kouho)
while True:
if B > K:
ans += 1
break
elif B == K:
if len(kouho) == 0:
break
else:
K = heapq.heappop(kouho)
else:
if len(bomb) == 0:
ans += 1
break
else:
B = heapq.heappop(bomb)
print(ans)
| from collections import deque
H, W, M = list(map(int, input().split()))
bomb = []
counth = [0 for k in range(H)]
countw = [0 for k in range(W)]
for k in range(M):
h, w = list(map(int, input().split()))
h -= 1
w -= 1
bomb.append(h + w * H)
counth[h] += 1
countw[w] += 1
counth = deque(counth)
countw = deque(countw)
maxh = max(counth)
maxw = max(countw)
index_h = deque([])
index_w = []
for k in range(H):
h = counth.popleft()
if h == maxh:
index_h.append(k)
for k in range(W):
w = countw.popleft()
if w == maxw:
index_w.append(k)
ans = maxh + maxw - 1
lenh = len(index_h)
lenw = len(index_w)
if lenh * lenw > M:
ans += 1
else:
bomb.sort()
bomb = deque(bomb)
kouho = []
for i in range(lenh):
h = index_h.pop()
for j in range(lenw):
w = index_w[j]
kouho.append(h + H * w)
kouho.sort()
kouho = deque(kouho)
B = bomb.popleft()
K = kouho.popleft()
while True:
if B > K:
ans += 1
break
elif B == K:
if len(kouho) == 0:
break
else:
K = kouho.popleft()
else:
if len(bomb) == 0:
ans += 1
break
else:
B = bomb.popleft()
print(ans)
| false | 1.538462 | [
"-import heapq",
"-heapq.heapify(bomb)",
"- heapq.heappush(bomb, h + w * H)",
"+ bomb.append(h + w * H)",
"+ bomb.sort()",
"+ bomb = deque(bomb)",
"- heapq.heapify(kouho)",
"- heapq.heappush(kouho, h + H * w)",
"- B = heapq.heappop(bomb)",
"- K = heapq.heappop(kouho)",
"+ kouho.append(h + H * w)",
"+ kouho.sort()",
"+ kouho = deque(kouho)",
"+ B = bomb.popleft()",
"+ K = kouho.popleft()",
"- K = heapq.heappop(kouho)",
"+ K = kouho.popleft()",
"- B = heapq.heappop(bomb)",
"+ B = bomb.popleft()"
] | false | 0.038209 | 0.038282 | 0.998079 | [
"s821527818",
"s368883649"
] |
u777923818 | p02958 | python | s709346117 | s299470107 | 166 | 30 | 38,896 | 9,120 | Accepted | Accepted | 81.93 | def inpl(): return list(map(int, input().split()))
N = int(eval(input()))
P = inpl()
Q = sorted(P)
OK = False
for i in range(N):
for j in range(N):
P[i], P[j] = P[j], P[i]
if P == Q:
OK = True
P[i], P[j] = P[j], P[i]
print(("YES" if OK else "NO")) | def inpl(): return list(map(int, input().split()))
N = int(eval(input()))
P = inpl()
Q = sorted(P)
for i in range(N):
for j in range(i, N):
R = [p for p in P]
R[i], R[j] = R[j], R[i]
for k in range(N):
if R[k] != Q[k]:
break
else:
print("YES")
exit()
else:
print("NO") | 14 | 18 | 294 | 373 | def inpl():
return list(map(int, input().split()))
N = int(eval(input()))
P = inpl()
Q = sorted(P)
OK = False
for i in range(N):
for j in range(N):
P[i], P[j] = P[j], P[i]
if P == Q:
OK = True
P[i], P[j] = P[j], P[i]
print(("YES" if OK else "NO"))
| def inpl():
return list(map(int, input().split()))
N = int(eval(input()))
P = inpl()
Q = sorted(P)
for i in range(N):
for j in range(i, N):
R = [p for p in P]
R[i], R[j] = R[j], R[i]
for k in range(N):
if R[k] != Q[k]:
break
else:
print("YES")
exit()
else:
print("NO")
| false | 22.222222 | [
"-OK = False",
"- for j in range(N):",
"- P[i], P[j] = P[j], P[i]",
"- if P == Q:",
"- OK = True",
"- P[i], P[j] = P[j], P[i]",
"-print((\"YES\" if OK else \"NO\"))",
"+ for j in range(i, N):",
"+ R = [p for p in P]",
"+ R[i], R[j] = R[j], R[i]",
"+ for k in range(N):",
"+ if R[k] != Q[k]:",
"+ break",
"+ else:",
"+ print(\"YES\")",
"+ exit()",
"+else:",
"+ print(\"NO\")"
] | false | 0.075554 | 0.035362 | 2.136556 | [
"s709346117",
"s299470107"
] |
u046187684 | p03401 | python | s052073088 | s971446899 | 193 | 147 | 16,700 | 17,468 | Accepted | Accepted | 23.83 | def solve(string):
n, *a = list(map(int, string.split()))
a = [0] + a + [0]
base = sum([abs(j - i) for i, j in zip(a, a[1:])])
ans = []
for i in range(1, n + 1):
if min(a[i - 1], a[i + 1]) <= a[i] <= max(a[i - 1], a[i + 1]):
ans.append(str(base))
elif max(a[i - 1], a[i + 1]) < a[i]:
ans.append(str(base - 2 * abs(a[i] - max(a[i - 1], a[i + 1]))))
else:
ans.append(str(base - 2 * abs(a[i] - min(a[i - 1], a[i + 1]))))
return "\n".join(ans)
if __name__ == '__main__':
print((solve('\n'.join([eval(input()), eval(input())]))))
| def solve(string):
n, *a = list(map(int, string.split()))
a = [0] + a + [0]
base = sum([abs(j - i) for i, j in zip(a, a[1:])])
ans = []
for a0, a1, a2 in zip(a, a[1:], a[2:]):
if min(a0, a1, a2) == a1:
ans.append(str(base - 2 * abs(a1 - min(a0, a2))))
elif max(a0, a1, a2) == a1:
ans.append(str(base - 2 * abs(a1 - max(a0, a2))))
else:
ans.append(str(base))
return "\n".join(ans)
if __name__ == '__main__':
print((solve('\n'.join([eval(input()), eval(input())]))))
| 17 | 17 | 611 | 551 | def solve(string):
n, *a = list(map(int, string.split()))
a = [0] + a + [0]
base = sum([abs(j - i) for i, j in zip(a, a[1:])])
ans = []
for i in range(1, n + 1):
if min(a[i - 1], a[i + 1]) <= a[i] <= max(a[i - 1], a[i + 1]):
ans.append(str(base))
elif max(a[i - 1], a[i + 1]) < a[i]:
ans.append(str(base - 2 * abs(a[i] - max(a[i - 1], a[i + 1]))))
else:
ans.append(str(base - 2 * abs(a[i] - min(a[i - 1], a[i + 1]))))
return "\n".join(ans)
if __name__ == "__main__":
print((solve("\n".join([eval(input()), eval(input())]))))
| def solve(string):
n, *a = list(map(int, string.split()))
a = [0] + a + [0]
base = sum([abs(j - i) for i, j in zip(a, a[1:])])
ans = []
for a0, a1, a2 in zip(a, a[1:], a[2:]):
if min(a0, a1, a2) == a1:
ans.append(str(base - 2 * abs(a1 - min(a0, a2))))
elif max(a0, a1, a2) == a1:
ans.append(str(base - 2 * abs(a1 - max(a0, a2))))
else:
ans.append(str(base))
return "\n".join(ans)
if __name__ == "__main__":
print((solve("\n".join([eval(input()), eval(input())]))))
| false | 0 | [
"- for i in range(1, n + 1):",
"- if min(a[i - 1], a[i + 1]) <= a[i] <= max(a[i - 1], a[i + 1]):",
"+ for a0, a1, a2 in zip(a, a[1:], a[2:]):",
"+ if min(a0, a1, a2) == a1:",
"+ ans.append(str(base - 2 * abs(a1 - min(a0, a2))))",
"+ elif max(a0, a1, a2) == a1:",
"+ ans.append(str(base - 2 * abs(a1 - max(a0, a2))))",
"+ else:",
"- elif max(a[i - 1], a[i + 1]) < a[i]:",
"- ans.append(str(base - 2 * abs(a[i] - max(a[i - 1], a[i + 1]))))",
"- else:",
"- ans.append(str(base - 2 * abs(a[i] - min(a[i - 1], a[i + 1]))))"
] | false | 0.124119 | 0.042063 | 2.950813 | [
"s052073088",
"s971446899"
] |
u950708010 | p03287 | python | s403591067 | s505217969 | 90 | 80 | 17,660 | 17,660 | Accepted | Accepted | 11.11 | from collections import Counter
import sys
input = sys.stdin.readline
def solve():
n,m = (int(i) for i in input().split())
a = list(int(i) for i in input().split())
a2 = [0]
for i in range(n):
a2.append(a[i]+a2[i])
for i in range(n+1):
a2[i] %= m
c = Counter(a2)
ans = 0
for i in list(c.values()):
ans += i*(i-1)//2
print(ans)
solve() | from collections import Counter
from itertools import accumulate
import sys
input = sys.stdin.readline
def solve():
n,m = (int(i) for i in input().split())
a = list(int(i) for i in input().split())
a2 = [0] + list(accumulate(a))
for i in range(n+1):
a2[i] %= m
c = Counter(a2)
ans = 0
for i in list(c.values()):
ans += i*(i-1)//2
print(ans)
if __name__ == "__main__":
solve() | 18 | 18 | 378 | 414 | from collections import Counter
import sys
input = sys.stdin.readline
def solve():
n, m = (int(i) for i in input().split())
a = list(int(i) for i in input().split())
a2 = [0]
for i in range(n):
a2.append(a[i] + a2[i])
for i in range(n + 1):
a2[i] %= m
c = Counter(a2)
ans = 0
for i in list(c.values()):
ans += i * (i - 1) // 2
print(ans)
solve()
| from collections import Counter
from itertools import accumulate
import sys
input = sys.stdin.readline
def solve():
n, m = (int(i) for i in input().split())
a = list(int(i) for i in input().split())
a2 = [0] + list(accumulate(a))
for i in range(n + 1):
a2[i] %= m
c = Counter(a2)
ans = 0
for i in list(c.values()):
ans += i * (i - 1) // 2
print(ans)
if __name__ == "__main__":
solve()
| false | 0 | [
"+from itertools import accumulate",
"- a2 = [0]",
"- for i in range(n):",
"- a2.append(a[i] + a2[i])",
"+ a2 = [0] + list(accumulate(a))",
"-solve()",
"+if __name__ == \"__main__\":",
"+ solve()"
] | false | 0.038463 | 0.03832 | 1.003735 | [
"s403591067",
"s505217969"
] |
u495903598 | p03062 | python | s239809723 | s993231812 | 595 | 56 | 21,864 | 14,284 | Accepted | Accepted | 90.59 |
# coding: utf-8
# In[20]:
import sys
#input = sys.stdin.readline
N = int(eval(input()))
A = list(map(int, input().split()))
# In[21]:
import numpy as np
A.sort(key=lambda x:abs(x))
#print(N, A)
# In[25]:
A = np.array(A)
#print(sum(A<0))
if sum(A<0)%2 == 0:
print((sum(abs(A))))
else:
print((sum(abs(A[1:])) - abs(A[0])))
# In[ ]:
|
# coding: utf-8
# In[28]:
import sys
#input = sys.stdin.readline
N = int(eval(input()))
A = list(map(int, input().split()))
# In[21]:
#import numpy as np
#A.sort(key=lambda x:abs(x))
#print(N, A)
# In[25]:
#A = np.array(A)
#print(sum(A<0))
#if sum(A<0)%2 == 0:
# print(sum(abs(A)))
#else:
# print(sum(abs(A[1:])) - abs(A[0]))
# In[29]:
B = list(map(abs, A))
C = [a for a in A if a < 0]
#print(A)
#print(B)
#print(C)
# In[30]:
if len(C)%2 ==0:
print((sum(B)))
else:
print((sum(B) - min(B)*2))
# In[ ]:
| 32 | 49 | 373 | 573 | # coding: utf-8
# In[20]:
import sys
# input = sys.stdin.readline
N = int(eval(input()))
A = list(map(int, input().split()))
# In[21]:
import numpy as np
A.sort(key=lambda x: abs(x))
# print(N, A)
# In[25]:
A = np.array(A)
# print(sum(A<0))
if sum(A < 0) % 2 == 0:
print((sum(abs(A))))
else:
print((sum(abs(A[1:])) - abs(A[0])))
# In[ ]:
| # coding: utf-8
# In[28]:
import sys
# input = sys.stdin.readline
N = int(eval(input()))
A = list(map(int, input().split()))
# In[21]:
# import numpy as np
# A.sort(key=lambda x:abs(x))
# print(N, A)
# In[25]:
# A = np.array(A)
# print(sum(A<0))
# if sum(A<0)%2 == 0:
# print(sum(abs(A)))
# else:
# print(sum(abs(A[1:])) - abs(A[0]))
# In[29]:
B = list(map(abs, A))
C = [a for a in A if a < 0]
# print(A)
# print(B)
# print(C)
# In[30]:
if len(C) % 2 == 0:
print((sum(B)))
else:
print((sum(B) - min(B) * 2))
# In[ ]:
| false | 34.693878 | [
"-# In[20]:",
"+# In[28]:",
"-import numpy as np",
"-",
"-A.sort(key=lambda x: abs(x))",
"+# import numpy as np",
"+# A.sort(key=lambda x:abs(x))",
"-A = np.array(A)",
"+# A = np.array(A)",
"-if sum(A < 0) % 2 == 0:",
"- print((sum(abs(A))))",
"+# if sum(A<0)%2 == 0:",
"+# print(sum(abs(A)))",
"+# else:",
"+# print(sum(abs(A[1:])) - abs(A[0]))",
"+# In[29]:",
"+B = list(map(abs, A))",
"+C = [a for a in A if a < 0]",
"+# print(A)",
"+# print(B)",
"+# print(C)",
"+# In[30]:",
"+if len(C) % 2 == 0:",
"+ print((sum(B)))",
"- print((sum(abs(A[1:])) - abs(A[0])))",
"+ print((sum(B) - min(B) * 2))"
] | false | 0.280094 | 0.046247 | 6.056495 | [
"s239809723",
"s993231812"
] |
u273345915 | p02713 | python | s198354175 | s942583384 | 1,881 | 1,253 | 9,076 | 9,176 | Accepted | Accepted | 33.39 | from math import gcd
# def gcd(a, b):
# if a%b==0: return b
# return gcd(b, a%b)
K=int(eval(input()))
sum=0
for a in range(1,K+1):
for b in range(1,K+1):
for c in range(1,K+1):
sum+=gcd(gcd(a,b),c)
print(sum) | def gcd(a, b):
if a%b==0: return b
return gcd(b, a%b)
K=int(eval(input()))
sum=0
for a in range(1,K+1):
for b in range(a,K+1):
for c in range(b,K+1):
if a==b==c: sum+=a
elif a!=b!=c: sum+=gcd(gcd(a,b),c)*6
else: sum+=gcd(gcd(a,b),c)*3
print(sum) | 11 | 12 | 244 | 307 | from math import gcd
# def gcd(a, b):
# if a%b==0: return b
# return gcd(b, a%b)
K = int(eval(input()))
sum = 0
for a in range(1, K + 1):
for b in range(1, K + 1):
for c in range(1, K + 1):
sum += gcd(gcd(a, b), c)
print(sum)
| def gcd(a, b):
if a % b == 0:
return b
return gcd(b, a % b)
K = int(eval(input()))
sum = 0
for a in range(1, K + 1):
for b in range(a, K + 1):
for c in range(b, K + 1):
if a == b == c:
sum += a
elif a != b != c:
sum += gcd(gcd(a, b), c) * 6
else:
sum += gcd(gcd(a, b), c) * 3
print(sum)
| false | 8.333333 | [
"-from math import gcd",
"+def gcd(a, b):",
"+ if a % b == 0:",
"+ return b",
"+ return gcd(b, a % b)",
"-# def gcd(a, b):",
"-# if a%b==0: return b",
"-# return gcd(b, a%b)",
"+",
"- for b in range(1, K + 1):",
"- for c in range(1, K + 1):",
"- sum += gcd(gcd(a, b), c)",
"+ for b in range(a, K + 1):",
"+ for c in range(b, K + 1):",
"+ if a == b == c:",
"+ sum += a",
"+ elif a != b != c:",
"+ sum += gcd(gcd(a, b), c) * 6",
"+ else:",
"+ sum += gcd(gcd(a, b), c) * 3"
] | false | 0.044543 | 0.129733 | 0.343344 | [
"s198354175",
"s942583384"
] |
u490553751 | p03266 | python | s957054057 | s927617005 | 378 | 189 | 21,056 | 38,896 | Accepted | Accepted | 50 | import sys
import itertools
import numpy
input = sys.stdin.readline
N,K = [int(i) for i in input().split()]
if K % 2 == 1 :
index = N // K
ans = index**3
else :
index = N // K
ans = index**3
k = K // 2
indexa = (N // k) - index
ans += indexa**3
print(ans) | #template
def inputlist(): return [int(k) for k in input().split()]
#template
N,K = inputlist()
m0 = 0
mh = 0
ans = 0
for i in range(1,N+1):
d = i%K
if d == 0:
m0+=1
if d == K//2 and K % 2 == 0:
mh +=1
print((m0**3 + mh**3)) | 15 | 14 | 297 | 263 | import sys
import itertools
import numpy
input = sys.stdin.readline
N, K = [int(i) for i in input().split()]
if K % 2 == 1:
index = N // K
ans = index**3
else:
index = N // K
ans = index**3
k = K // 2
indexa = (N // k) - index
ans += indexa**3
print(ans)
| # template
def inputlist():
return [int(k) for k in input().split()]
# template
N, K = inputlist()
m0 = 0
mh = 0
ans = 0
for i in range(1, N + 1):
d = i % K
if d == 0:
m0 += 1
if d == K // 2 and K % 2 == 0:
mh += 1
print((m0**3 + mh**3))
| false | 6.666667 | [
"-import sys",
"-import itertools",
"-import numpy",
"+# template",
"+def inputlist():",
"+ return [int(k) for k in input().split()]",
"-input = sys.stdin.readline",
"-N, K = [int(i) for i in input().split()]",
"-if K % 2 == 1:",
"- index = N // K",
"- ans = index**3",
"-else:",
"- index = N // K",
"- ans = index**3",
"- k = K // 2",
"- indexa = (N // k) - index",
"- ans += indexa**3",
"-print(ans)",
"+",
"+# template",
"+N, K = inputlist()",
"+m0 = 0",
"+mh = 0",
"+ans = 0",
"+for i in range(1, N + 1):",
"+ d = i % K",
"+ if d == 0:",
"+ m0 += 1",
"+ if d == K // 2 and K % 2 == 0:",
"+ mh += 1",
"+print((m0**3 + mh**3))"
] | false | 0.042991 | 0.089081 | 0.4826 | [
"s957054057",
"s927617005"
] |
u392319141 | p03503 | python | s810235389 | s777477609 | 307 | 141 | 3,188 | 3,188 | Accepted | Accepted | 54.07 | N = int(eval(input()))
F = [[0 for _ in range(10)] for _ in range(N)]
P = [[0 for _ in range(10)] for _ in range(N)]
for i in range(N) :
F[i] = list(map(int, input().split()))
for i in range(N) :
P[i] = list(map(int, input().split()))
ans = -float('inf')
for mask in range(1, 2**10) :
profit = 0
for shop in range(N) :
count = 0
for time in range(10) :
if (mask & (1 << time) != 0) and F[shop][time] == 1 :
count += 1
profit += P[shop][count]
ans = max(ans, profit)
print(ans) | N = int(eval(input()))
F = []
for _ in range(N):
mask = 0
for f in map(int, input().split()):
mask <<= 1
mask |= f
F.append(mask)
P = [list(map(int, input().split())) for _ in range(N)]
def calc(state):
ret = 0
for f, ps in zip(F, P):
f &= state
cnt = 0
while f > 0:
cnt += f % 2
f //= 2
ret += ps[cnt]
return ret
ans = -10**18
for state in range(1, 1 << 10):
ans = max(ans, calc(state))
print(ans)
| 21 | 27 | 565 | 523 | N = int(eval(input()))
F = [[0 for _ in range(10)] for _ in range(N)]
P = [[0 for _ in range(10)] for _ in range(N)]
for i in range(N):
F[i] = list(map(int, input().split()))
for i in range(N):
P[i] = list(map(int, input().split()))
ans = -float("inf")
for mask in range(1, 2**10):
profit = 0
for shop in range(N):
count = 0
for time in range(10):
if (mask & (1 << time) != 0) and F[shop][time] == 1:
count += 1
profit += P[shop][count]
ans = max(ans, profit)
print(ans)
| N = int(eval(input()))
F = []
for _ in range(N):
mask = 0
for f in map(int, input().split()):
mask <<= 1
mask |= f
F.append(mask)
P = [list(map(int, input().split())) for _ in range(N)]
def calc(state):
ret = 0
for f, ps in zip(F, P):
f &= state
cnt = 0
while f > 0:
cnt += f % 2
f //= 2
ret += ps[cnt]
return ret
ans = -(10**18)
for state in range(1, 1 << 10):
ans = max(ans, calc(state))
print(ans)
| false | 22.222222 | [
"-F = [[0 for _ in range(10)] for _ in range(N)]",
"-P = [[0 for _ in range(10)] for _ in range(N)]",
"-for i in range(N):",
"- F[i] = list(map(int, input().split()))",
"-for i in range(N):",
"- P[i] = list(map(int, input().split()))",
"-ans = -float(\"inf\")",
"-for mask in range(1, 2**10):",
"- profit = 0",
"- for shop in range(N):",
"- count = 0",
"- for time in range(10):",
"- if (mask & (1 << time) != 0) and F[shop][time] == 1:",
"- count += 1",
"- profit += P[shop][count]",
"- ans = max(ans, profit)",
"+F = []",
"+for _ in range(N):",
"+ mask = 0",
"+ for f in map(int, input().split()):",
"+ mask <<= 1",
"+ mask |= f",
"+ F.append(mask)",
"+P = [list(map(int, input().split())) for _ in range(N)]",
"+",
"+",
"+def calc(state):",
"+ ret = 0",
"+ for f, ps in zip(F, P):",
"+ f &= state",
"+ cnt = 0",
"+ while f > 0:",
"+ cnt += f % 2",
"+ f //= 2",
"+ ret += ps[cnt]",
"+ return ret",
"+",
"+",
"+ans = -(10**18)",
"+for state in range(1, 1 << 10):",
"+ ans = max(ans, calc(state))"
] | false | 0.095002 | 0.085046 | 1.117071 | [
"s810235389",
"s777477609"
] |
u084320347 | p03281 | python | s285699762 | s905052010 | 167 | 18 | 38,768 | 2,940 | Accepted | Accepted | 89.22 | n = int(eval(input()))
ans = 0
for i in range(1,n+1):
if i%2 == 0:
continue
cnt=0
for j in range(1,i+1):
if i%j == 0:
cnt+=1
if cnt == 8:
ans+=1
print(ans) | n = int(eval(input()))
ans=0
for i in range(1,n+1,2):
cnt = 0
for j in range(1,n+1,2):
if j>i:
break
if i%j==0:
cnt+=1
if cnt==8:
ans+=1
print(ans)
| 15 | 13 | 226 | 215 | n = int(eval(input()))
ans = 0
for i in range(1, n + 1):
if i % 2 == 0:
continue
cnt = 0
for j in range(1, i + 1):
if i % j == 0:
cnt += 1
if cnt == 8:
ans += 1
print(ans)
| n = int(eval(input()))
ans = 0
for i in range(1, n + 1, 2):
cnt = 0
for j in range(1, n + 1, 2):
if j > i:
break
if i % j == 0:
cnt += 1
if cnt == 8:
ans += 1
print(ans)
| false | 13.333333 | [
"-for i in range(1, n + 1):",
"- if i % 2 == 0:",
"- continue",
"+for i in range(1, n + 1, 2):",
"- for j in range(1, i + 1):",
"+ for j in range(1, n + 1, 2):",
"+ if j > i:",
"+ break"
] | false | 0.038255 | 0.036227 | 1.055962 | [
"s285699762",
"s905052010"
] |
u275666666 | p02689 | python | s928206831 | s419776351 | 307 | 277 | 127,268 | 103,132 | Accepted | Accepted | 9.77 | N,M=list(map(int, input().split()))
H=list(map(int, input().split()))
AB = [list(map(int, input().split())) for i in range(int(M))]
AB_unique=list(map(list, set(map(tuple, AB))))
AB_road=[[] for i in range(N)]
for AB in AB_unique:
if H[AB[0]-1] > H[AB[1]-1]:
AB_road[AB[1]-1].append(AB[0])
elif H[AB[0]-1] < H[AB[1]-1]:
AB_road[AB[0]-1].append(AB[1])
else:
AB_road[AB[1]-1].append(AB[0])
AB_road[AB[0]-1].append(AB[1])
print((AB_road.count([]))) | N,M=list(map(int, input().split()))
H=list(map(int, input().split()))
AB = [list(map(int, input().split())) for i in range(int(M))]
AB_road=[[] for i in range(N)]
for r in AB:
if H[r[0]-1] > H[r[1]-1]:
AB_road[r[1]-1].append(r[0])
elif H[r[0]-1] < H[r[1]-1]:
AB_road[r[0]-1].append(r[1])
else:
AB_road[r[1]-1].append(r[0])
AB_road[r[0]-1].append(r[1])
print((AB_road.count([]))) | 17 | 15 | 500 | 430 | N, M = list(map(int, input().split()))
H = list(map(int, input().split()))
AB = [list(map(int, input().split())) for i in range(int(M))]
AB_unique = list(map(list, set(map(tuple, AB))))
AB_road = [[] for i in range(N)]
for AB in AB_unique:
if H[AB[0] - 1] > H[AB[1] - 1]:
AB_road[AB[1] - 1].append(AB[0])
elif H[AB[0] - 1] < H[AB[1] - 1]:
AB_road[AB[0] - 1].append(AB[1])
else:
AB_road[AB[1] - 1].append(AB[0])
AB_road[AB[0] - 1].append(AB[1])
print((AB_road.count([])))
| N, M = list(map(int, input().split()))
H = list(map(int, input().split()))
AB = [list(map(int, input().split())) for i in range(int(M))]
AB_road = [[] for i in range(N)]
for r in AB:
if H[r[0] - 1] > H[r[1] - 1]:
AB_road[r[1] - 1].append(r[0])
elif H[r[0] - 1] < H[r[1] - 1]:
AB_road[r[0] - 1].append(r[1])
else:
AB_road[r[1] - 1].append(r[0])
AB_road[r[0] - 1].append(r[1])
print((AB_road.count([])))
| false | 11.764706 | [
"-AB_unique = list(map(list, set(map(tuple, AB))))",
"-for AB in AB_unique:",
"- if H[AB[0] - 1] > H[AB[1] - 1]:",
"- AB_road[AB[1] - 1].append(AB[0])",
"- elif H[AB[0] - 1] < H[AB[1] - 1]:",
"- AB_road[AB[0] - 1].append(AB[1])",
"+for r in AB:",
"+ if H[r[0] - 1] > H[r[1] - 1]:",
"+ AB_road[r[1] - 1].append(r[0])",
"+ elif H[r[0] - 1] < H[r[1] - 1]:",
"+ AB_road[r[0] - 1].append(r[1])",
"- AB_road[AB[1] - 1].append(AB[0])",
"- AB_road[AB[0] - 1].append(AB[1])",
"+ AB_road[r[1] - 1].append(r[0])",
"+ AB_road[r[0] - 1].append(r[1])"
] | false | 0.086269 | 0.127883 | 0.67459 | [
"s928206831",
"s419776351"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.