user_id
stringlengths 10
10
| problem_id
stringlengths 6
6
| language
stringclasses 1
value | submission_id_v0
stringlengths 10
10
| submission_id_v1
stringlengths 10
10
| cpu_time_v0
int64 10
38.3k
| cpu_time_v1
int64 0
24.7k
| memory_v0
int64 2.57k
1.02M
| memory_v1
int64 2.57k
869k
| status_v0
stringclasses 1
value | status_v1
stringclasses 1
value | improvement_frac
float64 7.51
100
| input
stringlengths 20
4.55k
| target
stringlengths 17
3.34k
| code_v0_loc
int64 1
148
| code_v1_loc
int64 1
184
| code_v0_num_chars
int64 13
4.55k
| code_v1_num_chars
int64 14
3.34k
| code_v0_no_empty_lines
stringlengths 21
6.88k
| code_v1_no_empty_lines
stringlengths 20
4.93k
| code_same
bool 1
class | relative_loc_diff_percent
float64 0
79.8
| diff
sequence | diff_only_import_comment
bool 1
class | measured_runtime_v0
float64 0.01
4.45
| measured_runtime_v1
float64 0.01
4.31
| runtime_lift
float64 0
359
| key
sequence |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
u924691798 | p03476 | python | s272189800 | s708061318 | 267 | 228 | 18,304 | 85,320 | Accepted | Accepted | 14.61 | def prime_table(n):
prime = [True]*(n+1)
prime[0], prime[1] = False, False
i = 2
while i*i <= n:
if not prime[i]:
i += 1
continue
j = 2*i
while j <= n:
prime[j] = False
j += i
i += 1
return prime
N = 10**5
pt = prime_table(N)
cum = [0]*(N+1)
for i in range(1, N+1, 2):
if pt[i] and pt[(i+1)//2]:
cum[i] = 1
for i in range(1, N+1):
cum[i] += cum[i-1]
Q = int(input())
ans = []
for _ in range(Q):
l, r = map(int, input().split())
ans.append(cum[r]-cum[l-1])
print(*ans, sep="\n")
| def prime_table(n):
prime = [True]*(n+1)
prime[0], prime[1] = False, False
for i in range(2, n+1):
if not prime[i]: continue
j = 2*i
while j <= n:
prime[j] = False
j += i
return prime
N = 10**5
pt = prime_table(N)
cum = [0]*(N+1)
for i in range(1, N+1, 2):
if pt[i] and pt[(i+1)//2]:
cum[i] = 1
for i in range(1, N+1):
cum[i] += cum[i-1]
Q = int(input())
ans = []
for _ in range(Q):
l, r = map(int, input().split())
ans.append(cum[r]-cum[l-1])
print(*ans, sep="\n")
| 28 | 24 | 629 | 577 | def prime_table(n):
prime = [True] * (n + 1)
prime[0], prime[1] = False, False
i = 2
while i * i <= n:
if not prime[i]:
i += 1
continue
j = 2 * i
while j <= n:
prime[j] = False
j += i
i += 1
return prime
N = 10**5
pt = prime_table(N)
cum = [0] * (N + 1)
for i in range(1, N + 1, 2):
if pt[i] and pt[(i + 1) // 2]:
cum[i] = 1
for i in range(1, N + 1):
cum[i] += cum[i - 1]
Q = int(input())
ans = []
for _ in range(Q):
l, r = map(int, input().split())
ans.append(cum[r] - cum[l - 1])
print(*ans, sep="\n")
| def prime_table(n):
prime = [True] * (n + 1)
prime[0], prime[1] = False, False
for i in range(2, n + 1):
if not prime[i]:
continue
j = 2 * i
while j <= n:
prime[j] = False
j += i
return prime
N = 10**5
pt = prime_table(N)
cum = [0] * (N + 1)
for i in range(1, N + 1, 2):
if pt[i] and pt[(i + 1) // 2]:
cum[i] = 1
for i in range(1, N + 1):
cum[i] += cum[i - 1]
Q = int(input())
ans = []
for _ in range(Q):
l, r = map(int, input().split())
ans.append(cum[r] - cum[l - 1])
print(*ans, sep="\n")
| false | 14.285714 | [
"- i = 2",
"- while i * i <= n:",
"+ for i in range(2, n + 1):",
"- i += 1",
"- i += 1"
] | false | 0.172679 | 0.2079 | 0.830587 | [
"s272189800",
"s708061318"
] |
u962045495 | p03173 | python | s016986069 | s277534661 | 716 | 626 | 35,944 | 35,560 | Accepted | Accepted | 12.57 | #!/usr/bin/env python2
import os
import sys
from atexit import register
from io import BytesIO
range = xrange
sys.stdin = BytesIO(os.read(0, os.fstat(0).st_size))
sys.stdout = BytesIO()
register(lambda: os.write(1, sys.stdout.getvalue()))
input = lambda: sys.stdin.readline().rstrip('\r\n')
n = int(eval(input()))
a = [int(i) for i in input().split()]
pref_sums = [0] * (n + 1)
for i in range(n):
pref_sums[i + 1] = pref_sums[i] + a[i]
dp = [[0] * n for _ in range(n)]
def solve(start, end):
if (dp[start][end] == 0) and (start != end):
dp[start][end] = min(pref_sums[i + 1] - pref_sums[start] + pref_sums[end + 1] - pref_sums[i + 1] +
solve(start, i) + solve(i + 1, end) for i in range(start, end))
return dp[start][end]
print(solve(0, n - 1))
| #!/usr/bin/env python2
import os
import sys
from atexit import register
from io import BytesIO
range = xrange
sys.stdin = BytesIO(os.read(0, os.fstat(0).st_size))
sys.stdout = BytesIO()
register(lambda: os.write(1, sys.stdout.getvalue()))
input = lambda: sys.stdin.readline().rstrip('\r\n')
n = int(eval(input()))
a = [float(i) for i in input().split()]
pref_sums = [0.0] * (n + 1)
for i in range(n):
pref_sums[i + 1] = pref_sums[i] + a[i]
dp = [[0.0] * n for _ in range(n)]
def solve(start, end):
if (dp[start][end] == 0.0) and (start != end):
dp[start][end] = min(
solve(start, i) + solve(i + 1, end) + pref_sums[end + 1] - pref_sums[start] for i in range(start, end))
return dp[start][end]
print(int(solve(0, n - 1)))
| 34 | 34 | 880 | 839 | #!/usr/bin/env python2
import os
import sys
from atexit import register
from io import BytesIO
range = xrange
sys.stdin = BytesIO(os.read(0, os.fstat(0).st_size))
sys.stdout = BytesIO()
register(lambda: os.write(1, sys.stdout.getvalue()))
input = lambda: sys.stdin.readline().rstrip("\r\n")
n = int(eval(input()))
a = [int(i) for i in input().split()]
pref_sums = [0] * (n + 1)
for i in range(n):
pref_sums[i + 1] = pref_sums[i] + a[i]
dp = [[0] * n for _ in range(n)]
def solve(start, end):
if (dp[start][end] == 0) and (start != end):
dp[start][end] = min(
pref_sums[i + 1]
- pref_sums[start]
+ pref_sums[end + 1]
- pref_sums[i + 1]
+ solve(start, i)
+ solve(i + 1, end)
for i in range(start, end)
)
return dp[start][end]
print(solve(0, n - 1))
| #!/usr/bin/env python2
import os
import sys
from atexit import register
from io import BytesIO
range = xrange
sys.stdin = BytesIO(os.read(0, os.fstat(0).st_size))
sys.stdout = BytesIO()
register(lambda: os.write(1, sys.stdout.getvalue()))
input = lambda: sys.stdin.readline().rstrip("\r\n")
n = int(eval(input()))
a = [float(i) for i in input().split()]
pref_sums = [0.0] * (n + 1)
for i in range(n):
pref_sums[i + 1] = pref_sums[i] + a[i]
dp = [[0.0] * n for _ in range(n)]
def solve(start, end):
if (dp[start][end] == 0.0) and (start != end):
dp[start][end] = min(
solve(start, i) + solve(i + 1, end) + pref_sums[end + 1] - pref_sums[start]
for i in range(start, end)
)
return dp[start][end]
print(int(solve(0, n - 1)))
| false | 0 | [
"-a = [int(i) for i in input().split()]",
"-pref_sums = [0] * (n + 1)",
"+a = [float(i) for i in input().split()]",
"+pref_sums = [0.0] * (n + 1)",
"-dp = [[0] * n for _ in range(n)]",
"+dp = [[0.0] * n for _ in range(n)]",
"- if (dp[start][end] == 0) and (start != end):",
"+ if (dp[start][end] == 0.0) and (start != end):",
"- pref_sums[i + 1]",
"- - pref_sums[start]",
"- + pref_sums[end + 1]",
"- - pref_sums[i + 1]",
"- + solve(start, i)",
"- + solve(i + 1, end)",
"+ solve(start, i) + solve(i + 1, end) + pref_sums[end + 1] - pref_sums[start]",
"-print(solve(0, n - 1))",
"+print(int(solve(0, n - 1)))"
] | false | 0.053868 | 0.036597 | 1.471921 | [
"s016986069",
"s277534661"
] |
u736546944 | p03478 | python | s113749361 | s395016598 | 41 | 29 | 3,060 | 3,060 | Accepted | Accepted | 29.27 | [N, A, B] = input().split()
SUM = 0
for i in range(1, int(N)+1):
list_i = list(str(i))
sum_i = sum(list(map(int, list_i)))
if int(A) <= sum_i <= int(B):
SUM += i
else:
continue
print(SUM) | # 10で割っていくやつ
[N, A, B] = list(map(int, input().split()))
sum = 0
a = 0
for i in range(1, N+1):
n = i
while n > 0:
a += n % 10
n //= 10
if A <= a <= B:
sum += i
a = 0
else:
a = 0
continue
print(sum) | 10 | 16 | 212 | 244 | [N, A, B] = input().split()
SUM = 0
for i in range(1, int(N) + 1):
list_i = list(str(i))
sum_i = sum(list(map(int, list_i)))
if int(A) <= sum_i <= int(B):
SUM += i
else:
continue
print(SUM)
| # 10で割っていくやつ
[N, A, B] = list(map(int, input().split()))
sum = 0
a = 0
for i in range(1, N + 1):
n = i
while n > 0:
a += n % 10
n //= 10
if A <= a <= B:
sum += i
a = 0
else:
a = 0
continue
print(sum)
| false | 37.5 | [
"-[N, A, B] = input().split()",
"-SUM = 0",
"-for i in range(1, int(N) + 1):",
"- list_i = list(str(i))",
"- sum_i = sum(list(map(int, list_i)))",
"- if int(A) <= sum_i <= int(B):",
"- SUM += i",
"+# 10で割っていくやつ",
"+[N, A, B] = list(map(int, input().split()))",
"+sum = 0",
"+a = 0",
"+for i in range(1, N + 1):",
"+ n = i",
"+ while n > 0:",
"+ a += n % 10",
"+ n //= 10",
"+ if A <= a <= B:",
"+ sum += i",
"+ a = 0",
"+ a = 0",
"-print(SUM)",
"+print(sum)"
] | false | 0.035187 | 0.036957 | 0.952106 | [
"s113749361",
"s395016598"
] |
u094191970 | p02690 | python | s853666628 | s609642426 | 1,104 | 72 | 9,136 | 9,172 | Accepted | Accepted | 93.48 | x=int(eval(input()))
for i in range(2*10**3):
for j in range(0,i,1):
if i**5-j**5==x:
print((i,j))
exit()
for i in range(0,70,1):
for j in range(0,-70,-1):
if i**5-j**5==x:
print((i,j))
exit() | x=int(eval(input()))
for i in range(-200,200,1):
for j in range(-200,200,1):
if i**5-j**5==x:
print((i,j))
exit() | 13 | 7 | 232 | 130 | x = int(eval(input()))
for i in range(2 * 10**3):
for j in range(0, i, 1):
if i**5 - j**5 == x:
print((i, j))
exit()
for i in range(0, 70, 1):
for j in range(0, -70, -1):
if i**5 - j**5 == x:
print((i, j))
exit()
| x = int(eval(input()))
for i in range(-200, 200, 1):
for j in range(-200, 200, 1):
if i**5 - j**5 == x:
print((i, j))
exit()
| false | 46.153846 | [
"-for i in range(2 * 10**3):",
"- for j in range(0, i, 1):",
"+for i in range(-200, 200, 1):",
"+ for j in range(-200, 200, 1):",
"-for i in range(0, 70, 1):",
"- for j in range(0, -70, -1):",
"- if i**5 - j**5 == x:",
"- print((i, j))",
"- exit()"
] | false | 2.636358 | 0.082171 | 32.083837 | [
"s853666628",
"s609642426"
] |
u391589398 | p03162 | python | s603547674 | s413699898 | 585 | 490 | 40,216 | 20,552 | Accepted | Accepted | 16.24 | N = int(eval(input()))
H = []
for _ in range(N):
h = tuple(map(int, input().split()))
H.append(h)
dp = [H[0]]
for i in range(1, N):
dp.append([
max(dp[i-1][1] + H[i][0], dp[i-1][2] + H[i][0]),
max(dp[i-1][0] + H[i][1], dp[i-1][2] + H[i][1]),
max(dp[i-1][0] + H[i][2], dp[i-1][1] + H[i][2]),
])
print((max(dp[-1])))
| N = int(eval(input()))
H = []
for _ in range(N):
h = tuple(map(int, input().split()))
H.append(h)
dp = H[0]
for i in range(1, N):
a, b, c = H[i]
dp_next = [
max(dp[1] + a, dp[2] + a),
max(dp[0] + b, dp[2] + b),
max(dp[0] + c, dp[1] + c),
]
dp = dp_next
print((max(dp))) | 14 | 17 | 361 | 327 | N = int(eval(input()))
H = []
for _ in range(N):
h = tuple(map(int, input().split()))
H.append(h)
dp = [H[0]]
for i in range(1, N):
dp.append(
[
max(dp[i - 1][1] + H[i][0], dp[i - 1][2] + H[i][0]),
max(dp[i - 1][0] + H[i][1], dp[i - 1][2] + H[i][1]),
max(dp[i - 1][0] + H[i][2], dp[i - 1][1] + H[i][2]),
]
)
print((max(dp[-1])))
| N = int(eval(input()))
H = []
for _ in range(N):
h = tuple(map(int, input().split()))
H.append(h)
dp = H[0]
for i in range(1, N):
a, b, c = H[i]
dp_next = [
max(dp[1] + a, dp[2] + a),
max(dp[0] + b, dp[2] + b),
max(dp[0] + c, dp[1] + c),
]
dp = dp_next
print((max(dp)))
| false | 17.647059 | [
"-dp = [H[0]]",
"+dp = H[0]",
"- dp.append(",
"- [",
"- max(dp[i - 1][1] + H[i][0], dp[i - 1][2] + H[i][0]),",
"- max(dp[i - 1][0] + H[i][1], dp[i - 1][2] + H[i][1]),",
"- max(dp[i - 1][0] + H[i][2], dp[i - 1][1] + H[i][2]),",
"- ]",
"- )",
"-print((max(dp[-1])))",
"+ a, b, c = H[i]",
"+ dp_next = [",
"+ max(dp[1] + a, dp[2] + a),",
"+ max(dp[0] + b, dp[2] + b),",
"+ max(dp[0] + c, dp[1] + c),",
"+ ]",
"+ dp = dp_next",
"+print((max(dp)))"
] | false | 0.037223 | 0.035736 | 1.041618 | [
"s603547674",
"s413699898"
] |
u775421443 | p02953 | python | s394792812 | s525539760 | 71 | 62 | 14,396 | 14,684 | Accepted | Accepted | 12.68 | import sys
n = int(eval(input()))
nums = list(map(int, input().split()))
maxnum = 0
for x in range(n):
if maxnum < nums[x]:
maxnum = nums[x]
if maxnum - nums[x] > 1:
print('No')
sys.exit()
print('Yes') | import sys
sys.setrecursionlimit(20000000)
input = sys.stdin.readline
def main():
n = int(eval(input()))
nums = list(map(int, input().split()))
for x in reversed(list(range(1, len(nums)))):
if nums[x-1] > nums[x]:
nums[x-1] -= 1
if nums[x-1] > nums[x]:
print('No')
sys.exit()
print('Yes')
if __name__ == '__main__':
main() | 14 | 21 | 246 | 408 | import sys
n = int(eval(input()))
nums = list(map(int, input().split()))
maxnum = 0
for x in range(n):
if maxnum < nums[x]:
maxnum = nums[x]
if maxnum - nums[x] > 1:
print("No")
sys.exit()
print("Yes")
| import sys
sys.setrecursionlimit(20000000)
input = sys.stdin.readline
def main():
n = int(eval(input()))
nums = list(map(int, input().split()))
for x in reversed(list(range(1, len(nums)))):
if nums[x - 1] > nums[x]:
nums[x - 1] -= 1
if nums[x - 1] > nums[x]:
print("No")
sys.exit()
print("Yes")
if __name__ == "__main__":
main()
| false | 33.333333 | [
"-n = int(eval(input()))",
"-nums = list(map(int, input().split()))",
"-maxnum = 0",
"-for x in range(n):",
"- if maxnum < nums[x]:",
"- maxnum = nums[x]",
"- if maxnum - nums[x] > 1:",
"- print(\"No\")",
"- sys.exit()",
"-print(\"Yes\")",
"+sys.setrecursionlimit(20000000)",
"+input = sys.stdin.readline",
"+",
"+",
"+def main():",
"+ n = int(eval(input()))",
"+ nums = list(map(int, input().split()))",
"+ for x in reversed(list(range(1, len(nums)))):",
"+ if nums[x - 1] > nums[x]:",
"+ nums[x - 1] -= 1",
"+ if nums[x - 1] > nums[x]:",
"+ print(\"No\")",
"+ sys.exit()",
"+ print(\"Yes\")",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ main()"
] | false | 0.035851 | 0.045264 | 0.792045 | [
"s394792812",
"s525539760"
] |
u465423770 | p02570 | python | s243341824 | s056749325 | 31 | 26 | 9,156 | 9,088 | Accepted | Accepted | 16.13 | d,t,s = list(map(int, input().split()))
ans = d / s
if ans > t:
print("No")
else :
print("Yes") | d,t,s = list(map(int, input().split()))
dist = t * s
if dist >= d:
print("Yes")
else :
print("No") | 8 | 8 | 106 | 109 | d, t, s = list(map(int, input().split()))
ans = d / s
if ans > t:
print("No")
else:
print("Yes")
| d, t, s = list(map(int, input().split()))
dist = t * s
if dist >= d:
print("Yes")
else:
print("No")
| false | 0 | [
"-ans = d / s",
"-if ans > t:",
"+dist = t * s",
"+if dist >= d:",
"+ print(\"Yes\")",
"+else:",
"-else:",
"- print(\"Yes\")"
] | false | 0.0481 | 0.041945 | 1.146737 | [
"s243341824",
"s056749325"
] |
u752907966 | p03682 | python | s488316901 | s250959394 | 1,894 | 1,458 | 87,032 | 54,928 | Accepted | Accepted | 23.02 | #最小全域木 プリム法
from heapq import *
n=int(eval(input()))
xy=[]
for i in range(n):
x,y=list(map(int,input().split()))
xy.append([x,y,i])
#今回の問題では,高々xが隣のやつとyが隣のやつを全部考えればよし
#（詳しくは解説pdfより）
x_sort = sorted(xy, key=lambda x: x[0])
y_sort = sorted(xy, key=lambda x: x[1])
cost = [[]for _ in range(n+3)] #cost[i]にはi番目から(j,k)でj番目にコストkかかる
for i in range(n-1):
cost[x_sort[i][2]].append((x_sort[i+1][2],x_sort[i+1][0]-x_sort[i][0]))
cost[x_sort[i+1][2]].append((x_sort[i][2],x_sort[i+1][0]-x_sort[i][0]))
cost[y_sort[i][2]].append((y_sort[i+1][2],y_sort[i+1][1]-y_sort[i][1]))
cost[y_sort[i+1][2]].append((y_sort[i][2],y_sort[i+1][1]-y_sort[i][1]))
used=[False]*(n+3)#頂点が最小全域木にもうすでに含まれているかどうか
q=[]
#すでに最小全域木が決まっている部分からまだ決まっていない部分への辺をヒープで管理
#(a,b)でaには向かう先の頂点,bにはかかるコスト
#ヒープで小さいコストからとりだせる
#初期条件
#はじめはどこでもよいので０番目スタートとする(0番目だけではコストは0)
used[0] = True
ans = 0
#0番目からの辺をすべてヒープに挿入
for to,cst in cost[0]:
heappush(q,(cst,to))
#すでに決まっている最小全域木部分からまだ決まっていない部分を貪欲的にひたすら追加する
#はじめは初期条件の通り
while(len(q)!=0):
c,ver=heappop(q)
#すでに決まっている部分から一番小さいコストの辺を取り出す
if used[ver] == True:
continue
#もしすでに最小全域木部分であればやり直し
#そうでなければコストの分を加算し、新しい頂点を最小全域木部分に追加する
ans += c
used[ver] = True
#新しく追加した頂点からの辺をヒープに追加する
for to,cst in cost[ver]:
heappush(q,(cst,to))
#これを貪欲的に繰り返すことでうまくいくらしい
print(ans)
| #最小全域木 クラスカル法
class UnionFind():
# 作りたい要素数nで初期化
# 使用するインスタンス変数の初期化
def __init__(self, n):
self.n = n
# root[x]<0ならそのノードが根かつその値が木の要素数
# rootノードでその木の要素数を記録する
self.root = [-1]*(n+1)
# 木をくっつける時にアンバランスにならないように調整する
self.rnk = [0]*(n+1)
# ノードxのrootノードを見つける
def find_root(self, x):
if(self.root[x] < 0):
return x
else:
# ここで代入しておくことで、後の繰り返しを避ける
#経路圧縮
self.root[x] = self.find_root(self.root[x])
return self.root[x]
# 木の併合、入力は併合したい各ノード
def unite(self, x, y):
# 入力ノードのrootノードを見つける
x = self.find_root(x)
y = self.find_root(y)
# すでに同じ木に属していた場合
if(x == y):
return
# 違う木に属していた場合rnkを見てくっつける方を決める
elif(self.rnk[x] > self.rnk[y]):
self.root[x] += self.root[y]
self.root[y] = x
else:
self.root[y] += self.root[x]
self.root[x] = y
# rnkが同じ（深さに差がない場合）は1増やす
if(self.rnk[x] == self.rnk[y]):
self.rnk[y] += 1
# xとyが同じグループに属するか判断
def isSame(self, x, y):
return self.find_root(x) == self.find_root(y)
# ノードxが属する木のサイズを返す
def size(self, x):
return -self.root[self.find_root(x)]
n=int(eval(input()))
xy=[]
for i in range(n):
x,y=list(map(int,input().split()))
xy.append([x,y,i])
#今回の問題では,高々xが隣のやつとyが隣のやつを全部考えればよし
#（詳しくは解説pdfより）
x_sort = sorted(xy, key=lambda x: x[0])
y_sort = sorted(xy, key=lambda x: x[1])
edge = [] #edge=[i番目と,j番目が,コストk]
for i in range(n-1):
edge.append([x_sort[i][2],x_sort[i+1][2],x_sort[i+1][0]-x_sort[i][0]])
edge.append([y_sort[i][2],y_sort[i+1][2],y_sort[i+1][1]-y_sort[i][1]])
#クラスカル法では辺のコストを小さい順にみていき閉路ができなければ追加する。を繰り返す
#閉路ができるかどうかはUnionFindで効率的に判定できる
ans = 0
edge.sort(key=lambda x:x[2])
u=UnionFind(n)
for i,j,cost in edge:
if u.isSame(i,j) == False:
u.unite(i,j)
ans+=cost
print(ans) | 54 | 75 | 1,359 | 2,040 | # 最小全域木 プリム法
from heapq import *
n = int(eval(input()))
xy = []
for i in range(n):
x, y = list(map(int, input().split()))
xy.append([x, y, i])
# 今回の問題では,高々xが隣のやつとyが隣のやつを全部考えればよし
# （詳しくは解説pdfより）
x_sort = sorted(xy, key=lambda x: x[0])
y_sort = sorted(xy, key=lambda x: x[1])
cost = [[] for _ in range(n + 3)] # cost[i]にはi番目から(j,k)でj番目にコストkかかる
for i in range(n - 1):
cost[x_sort[i][2]].append((x_sort[i + 1][2], x_sort[i + 1][0] - x_sort[i][0]))
cost[x_sort[i + 1][2]].append((x_sort[i][2], x_sort[i + 1][0] - x_sort[i][0]))
cost[y_sort[i][2]].append((y_sort[i + 1][2], y_sort[i + 1][1] - y_sort[i][1]))
cost[y_sort[i + 1][2]].append((y_sort[i][2], y_sort[i + 1][1] - y_sort[i][1]))
used = [False] * (n + 3) # 頂点が最小全域木にもうすでに含まれているかどうか
q = []
# すでに最小全域木が決まっている部分からまだ決まっていない部分への辺をヒープで管理
# (a,b)でaには向かう先の頂点,bにはかかるコスト
# ヒープで小さいコストからとりだせる
# 初期条件
# はじめはどこでもよいので０番目スタートとする(0番目だけではコストは0)
used[0] = True
ans = 0
# 0番目からの辺をすべてヒープに挿入
for to, cst in cost[0]:
heappush(q, (cst, to))
# すでに決まっている最小全域木部分からまだ決まっていない部分を貪欲的にひたすら追加する
# はじめは初期条件の通り
while len(q) != 0:
c, ver = heappop(q)
# すでに決まっている部分から一番小さいコストの辺を取り出す
if used[ver] == True:
continue
# もしすでに最小全域木部分であればやり直し
# そうでなければコストの分を加算し、新しい頂点を最小全域木部分に追加する
ans += c
used[ver] = True
# 新しく追加した頂点からの辺をヒープに追加する
for to, cst in cost[ver]:
heappush(q, (cst, to))
# これを貪欲的に繰り返すことでうまくいくらしい
print(ans)
| # 最小全域木 クラスカル法
class UnionFind:
# 作りたい要素数nで初期化
# 使用するインスタンス変数の初期化
def __init__(self, n):
self.n = n
# root[x]<0ならそのノードが根かつその値が木の要素数
# rootノードでその木の要素数を記録する
self.root = [-1] * (n + 1)
# 木をくっつける時にアンバランスにならないように調整する
self.rnk = [0] * (n + 1)
# ノードxのrootノードを見つける
def find_root(self, x):
if self.root[x] < 0:
return x
else:
# ここで代入しておくことで、後の繰り返しを避ける
# 経路圧縮
self.root[x] = self.find_root(self.root[x])
return self.root[x]
# 木の併合、入力は併合したい各ノード
def unite(self, x, y):
# 入力ノードのrootノードを見つける
x = self.find_root(x)
y = self.find_root(y)
# すでに同じ木に属していた場合
if x == y:
return
# 違う木に属していた場合rnkを見てくっつける方を決める
elif self.rnk[x] > self.rnk[y]:
self.root[x] += self.root[y]
self.root[y] = x
else:
self.root[y] += self.root[x]
self.root[x] = y
# rnkが同じ（深さに差がない場合）は1増やす
if self.rnk[x] == self.rnk[y]:
self.rnk[y] += 1
# xとyが同じグループに属するか判断
def isSame(self, x, y):
return self.find_root(x) == self.find_root(y)
# ノードxが属する木のサイズを返す
def size(self, x):
return -self.root[self.find_root(x)]
n = int(eval(input()))
xy = []
for i in range(n):
x, y = list(map(int, input().split()))
xy.append([x, y, i])
# 今回の問題では,高々xが隣のやつとyが隣のやつを全部考えればよし
# （詳しくは解説pdfより）
x_sort = sorted(xy, key=lambda x: x[0])
y_sort = sorted(xy, key=lambda x: x[1])
edge = [] # edge=[i番目と,j番目が,コストk]
for i in range(n - 1):
edge.append([x_sort[i][2], x_sort[i + 1][2], x_sort[i + 1][0] - x_sort[i][0]])
edge.append([y_sort[i][2], y_sort[i + 1][2], y_sort[i + 1][1] - y_sort[i][1]])
# クラスカル法では辺のコストを小さい順にみていき閉路ができなければ追加する。を繰り返す
# 閉路ができるかどうかはUnionFindで効率的に判定できる
ans = 0
edge.sort(key=lambda x: x[2])
u = UnionFind(n)
for i, j, cost in edge:
if u.isSame(i, j) == False:
u.unite(i, j)
ans += cost
print(ans)
| false | 28 | [
"-# 最小全域木 プリム法",
"-from heapq import *",
"+# 最小全域木 クラスカル法",
"+class UnionFind:",
"+ # 作りたい要素数nで初期化",
"+ # 使用するインスタンス変数の初期化",
"+ def __init__(self, n):",
"+ self.n = n",
"+ # root[x]<0ならそのノードが根かつその値が木の要素数",
"+ # rootノードでその木の要素数を記録する",
"+ self.root = [-1] * (n + 1)",
"+ # 木をくっつける時にアンバランスにならないように調整する",
"+ self.rnk = [0] * (n + 1)",
"+",
"+ # ノードxのrootノードを見つける",
"+ def find_root(self, x):",
"+ if self.root[x] < 0:",
"+ return x",
"+ else:",
"+ # ここで代入しておくことで、後の繰り返しを避ける",
"+ # 経路圧縮",
"+ self.root[x] = self.find_root(self.root[x])",
"+ return self.root[x]",
"+",
"+ # 木の併合、入力は併合したい各ノード",
"+ def unite(self, x, y):",
"+ # 入力ノードのrootノードを見つける",
"+ x = self.find_root(x)",
"+ y = self.find_root(y)",
"+ # すでに同じ木に属していた場合",
"+ if x == y:",
"+ return",
"+ # 違う木に属していた場合rnkを見てくっつける方を決める",
"+ elif self.rnk[x] > self.rnk[y]:",
"+ self.root[x] += self.root[y]",
"+ self.root[y] = x",
"+ else:",
"+ self.root[y] += self.root[x]",
"+ self.root[x] = y",
"+ # rnkが同じ（深さに差がない場合）は1増やす",
"+ if self.rnk[x] == self.rnk[y]:",
"+ self.rnk[y] += 1",
"+",
"+ # xとyが同じグループに属するか判断",
"+ def isSame(self, x, y):",
"+ return self.find_root(x) == self.find_root(y)",
"+",
"+ # ノードxが属する木のサイズを返す",
"+ def size(self, x):",
"+ return -self.root[self.find_root(x)]",
"+",
"-cost = [[] for _ in range(n + 3)] # cost[i]にはi番目から(j,k)でj番目にコストkかかる",
"+edge = [] # edge=[i番目と,j番目が,コストk]",
"- cost[x_sort[i][2]].append((x_sort[i + 1][2], x_sort[i + 1][0] - x_sort[i][0]))",
"- cost[x_sort[i + 1][2]].append((x_sort[i][2], x_sort[i + 1][0] - x_sort[i][0]))",
"- cost[y_sort[i][2]].append((y_sort[i + 1][2], y_sort[i + 1][1] - y_sort[i][1]))",
"- cost[y_sort[i + 1][2]].append((y_sort[i][2], y_sort[i + 1][1] - y_sort[i][1]))",
"-used = [False] * (n + 3) # 頂点が最小全域木にもうすでに含まれているかどうか",
"-q = []",
"-# すでに最小全域木が決まっている部分からまだ決まっていない部分への辺をヒープで管理",
"-# (a,b)でaには向かう先の頂点,bにはかかるコスト",
"-# ヒープで小さいコストからとりだせる",
"-# 初期条件",
"-# はじめはどこでもよいので０番目スタートとする(0番目だけではコストは0)",
"-used[0] = True",
"+ edge.append([x_sort[i][2], x_sort[i + 1][2], x_sort[i + 1][0] - x_sort[i][0]])",
"+ edge.append([y_sort[i][2], y_sort[i + 1][2], y_sort[i + 1][1] - y_sort[i][1]])",
"+# クラスカル法では辺のコストを小さい順にみていき閉路ができなければ追加する。を繰り返す",
"+# 閉路ができるかどうかはUnionFindで効率的に判定できる",
"-# 0番目からの辺をすべてヒープに挿入",
"-for to, cst in cost[0]:",
"- heappush(q, (cst, to))",
"-# すでに決まっている最小全域木部分からまだ決まっていない部分を貪欲的にひたすら追加する",
"-# はじめは初期条件の通り",
"-while len(q) != 0:",
"- c, ver = heappop(q)",
"- # すでに決まっている部分から一番小さいコストの辺を取り出す",
"- if used[ver] == True:",
"- continue",
"- # もしすでに最小全域木部分であればやり直し",
"- # そうでなければコストの分を加算し、新しい頂点を最小全域木部分に追加する",
"- ans += c",
"- used[ver] = True",
"- # 新しく追加した頂点からの辺をヒープに追加する",
"- for to, cst in cost[ver]:",
"- heappush(q, (cst, to))",
"-# これを貪欲的に繰り返すことでうまくいくらしい",
"+edge.sort(key=lambda x: x[2])",
"+u = UnionFind(n)",
"+for i, j, cost in edge:",
"+ if u.isSame(i, j) == False:",
"+ u.unite(i, j)",
"+ ans += cost"
] | false | 0.099566 | 0.108803 | 0.915105 | [
"s488316901",
"s250959394"
] |
u609061751 | p02821 | python | s123237484 | s779780028 | 1,997 | 1,733 | 14,380 | 60,560 | Accepted | Accepted | 13.22 | import sys
input = sys.stdin.readline
import bisect
from itertools import accumulate
N, M = [int(x) for x in input().split()]
A = [int(x) for x in input().split()]
A.sort()
left = -1
right = 1 + 2 * 10 ** 5
def shake(x):
cnt = 0
for i in A:
cnt += N - bisect.bisect_left(A, x - i)
if cnt >= M:
return 1
else:
return 0
while True:
mid = (left + right) // 2
if shake(mid):
if not shake(mid + 1):
X = mid
break
else:
left = mid
else:
if shake(mid - 1):
X = mid - 1
break
else:
right = mid
happy = 0
cumsum_A = list(accumulate(A))
for j in A:
idx = bisect.bisect_right(A, X - j)
cnt = N - idx
if cnt == N:
happy += cumsum_A[-1] + cnt * j
else:
happy += cumsum_A[-1] - cumsum_A[idx - 1] + cnt * j
M -= cnt
happy += M * X
print(happy)
| import sys
input = sys.stdin.readline
import bisect
from itertools import accumulate
N, M = [int(x) for x in input().split()]
A = [int(x) for x in input().split()]
A.sort()
left = -1
right = 1 + 2 * 10 ** 5
def shake(x):
cnt = 0
for i in A:
cnt += N - bisect.bisect_left(A, x - i)
if cnt >= M:
return 1
else:
return 0
while True:
mid = (left + right) // 2
if shake(mid):
if not shake(mid + 1):
X = mid
break
else:
left = mid
else:
if shake(mid - 1):
X = mid - 1
break
else:
right = mid
happy = 0
cumsum_A = [0] + list(accumulate(A))
for j in A:
idx = bisect.bisect_right(A, X - j)
cnt = N - idx
happy += cumsum_A[-1] - cumsum_A[idx] + cnt * j
M -= cnt
happy += M * X
print(happy)
| 52 | 49 | 981 | 909 | import sys
input = sys.stdin.readline
import bisect
from itertools import accumulate
N, M = [int(x) for x in input().split()]
A = [int(x) for x in input().split()]
A.sort()
left = -1
right = 1 + 2 * 10**5
def shake(x):
cnt = 0
for i in A:
cnt += N - bisect.bisect_left(A, x - i)
if cnt >= M:
return 1
else:
return 0
while True:
mid = (left + right) // 2
if shake(mid):
if not shake(mid + 1):
X = mid
break
else:
left = mid
else:
if shake(mid - 1):
X = mid - 1
break
else:
right = mid
happy = 0
cumsum_A = list(accumulate(A))
for j in A:
idx = bisect.bisect_right(A, X - j)
cnt = N - idx
if cnt == N:
happy += cumsum_A[-1] + cnt * j
else:
happy += cumsum_A[-1] - cumsum_A[idx - 1] + cnt * j
M -= cnt
happy += M * X
print(happy)
| import sys
input = sys.stdin.readline
import bisect
from itertools import accumulate
N, M = [int(x) for x in input().split()]
A = [int(x) for x in input().split()]
A.sort()
left = -1
right = 1 + 2 * 10**5
def shake(x):
cnt = 0
for i in A:
cnt += N - bisect.bisect_left(A, x - i)
if cnt >= M:
return 1
else:
return 0
while True:
mid = (left + right) // 2
if shake(mid):
if not shake(mid + 1):
X = mid
break
else:
left = mid
else:
if shake(mid - 1):
X = mid - 1
break
else:
right = mid
happy = 0
cumsum_A = [0] + list(accumulate(A))
for j in A:
idx = bisect.bisect_right(A, X - j)
cnt = N - idx
happy += cumsum_A[-1] - cumsum_A[idx] + cnt * j
M -= cnt
happy += M * X
print(happy)
| false | 5.769231 | [
"-cumsum_A = list(accumulate(A))",
"+cumsum_A = [0] + list(accumulate(A))",
"- if cnt == N:",
"- happy += cumsum_A[-1] + cnt * j",
"- else:",
"- happy += cumsum_A[-1] - cumsum_A[idx - 1] + cnt * j",
"+ happy += cumsum_A[-1] - cumsum_A[idx] + cnt * j"
] | false | 0.045366 | 0.047468 | 0.955712 | [
"s123237484",
"s779780028"
] |
u401487574 | p02712 | python | s718960545 | s557866948 | 156 | 102 | 9,156 | 34,500 | Accepted | Accepted | 34.62 | n = int(eval(input()))
ans = 0
for i in range(1,n+1):
if i%3 !=0 and i%5!=0:
ans +=i
print(ans)
| import numpy as np
n = int(eval(input()))
a = np.arange(n+1)
a[::3] = 0
a[::5] = 0
print((np.sum(a)))
| 6 | 6 | 107 | 99 | n = int(eval(input()))
ans = 0
for i in range(1, n + 1):
if i % 3 != 0 and i % 5 != 0:
ans += i
print(ans)
| import numpy as np
n = int(eval(input()))
a = np.arange(n + 1)
a[::3] = 0
a[::5] = 0
print((np.sum(a)))
| false | 0 | [
"+import numpy as np",
"+",
"-ans = 0",
"-for i in range(1, n + 1):",
"- if i % 3 != 0 and i % 5 != 0:",
"- ans += i",
"-print(ans)",
"+a = np.arange(n + 1)",
"+a[::3] = 0",
"+a[::5] = 0",
"+print((np.sum(a)))"
] | false | 0.15707 | 0.255935 | 0.61371 | [
"s718960545",
"s557866948"
] |
u006883624 | p02814 | python | s551063827 | s696084166 | 64 | 58 | 14,748 | 14,748 | Accepted | Accepted | 9.38 | # from math import sqrt
# from heapq import heappush, heappop
# from collections import deque
from functools import reduce
# a, b = [int(v) for v in input().split()]
def main():
N, M = [int(v) for v in input().split()]
A = list(set([int(v) // 2 for v in input().split()]))
def func(a):
count = 0
while a % 2 == 0:
count += 1
a //= 2
return count
fa = func(A[0])
for a in A[1:]:
if func(a) != fa:
print((0))
exit()
def gcd(a, b):
if b == 0:
return a
return gcd(b, a % b)
def lcm(v1, v2):
return v1 * v2 // gcd(v1, v2)
a_lcm = 1
for a in A:
d = gcd(a_lcm, a)
a_lcm = a_lcm * a // d
if a_lcm > M:
print((0))
exit()
# a_lcm = reduce(lambda v1, v2: lcm(v1, v2), A)
print(((M // a_lcm + 1) // 2))
main()
| # from math import sqrt
# from heapq import heappush, heappop
# from collections import deque
from functools import reduce
# a, b = [int(v) for v in input().split()]
def main():
N, M = [int(v) for v in input().split()]
A = list(set([int(v) // 2 for v in input().split()]))
def func(a):
count = 0
while a % 2 == 0:
count += 1
a //= 2
return count
fa = func(A[0])
for a in A[1:]:
if func(a) != fa:
print((0))
exit()
def gcd(a, b):
if b == 0:
return a
return gcd(b, a % b)
def lcm(v1, v2):
return v1 * v2 // gcd(v1, v2)
a_lcm = reduce(lambda v1, v2: lcm(v1, v2), A)
if a_lcm > M:
print((0))
exit()
print(((M // a_lcm + 1) // 2))
main()
| 47 | 42 | 958 | 851 | # from math import sqrt
# from heapq import heappush, heappop
# from collections import deque
from functools import reduce
# a, b = [int(v) for v in input().split()]
def main():
N, M = [int(v) for v in input().split()]
A = list(set([int(v) // 2 for v in input().split()]))
def func(a):
count = 0
while a % 2 == 0:
count += 1
a //= 2
return count
fa = func(A[0])
for a in A[1:]:
if func(a) != fa:
print((0))
exit()
def gcd(a, b):
if b == 0:
return a
return gcd(b, a % b)
def lcm(v1, v2):
return v1 * v2 // gcd(v1, v2)
a_lcm = 1
for a in A:
d = gcd(a_lcm, a)
a_lcm = a_lcm * a // d
if a_lcm > M:
print((0))
exit()
# a_lcm = reduce(lambda v1, v2: lcm(v1, v2), A)
print(((M // a_lcm + 1) // 2))
main()
| # from math import sqrt
# from heapq import heappush, heappop
# from collections import deque
from functools import reduce
# a, b = [int(v) for v in input().split()]
def main():
N, M = [int(v) for v in input().split()]
A = list(set([int(v) // 2 for v in input().split()]))
def func(a):
count = 0
while a % 2 == 0:
count += 1
a //= 2
return count
fa = func(A[0])
for a in A[1:]:
if func(a) != fa:
print((0))
exit()
def gcd(a, b):
if b == 0:
return a
return gcd(b, a % b)
def lcm(v1, v2):
return v1 * v2 // gcd(v1, v2)
a_lcm = reduce(lambda v1, v2: lcm(v1, v2), A)
if a_lcm > M:
print((0))
exit()
print(((M // a_lcm + 1) // 2))
main()
| false | 10.638298 | [
"- a_lcm = 1",
"- for a in A:",
"- d = gcd(a_lcm, a)",
"- a_lcm = a_lcm * a // d",
"- if a_lcm > M:",
"- print((0))",
"- exit()",
"- # a_lcm = reduce(lambda v1, v2: lcm(v1, v2), A)",
"+ a_lcm = reduce(lambda v1, v2: lcm(v1, v2), A)",
"+ if a_lcm > M:",
"+ print((0))",
"+ exit()"
] | false | 0.047334 | 0.048735 | 0.971245 | [
"s551063827",
"s696084166"
] |
u298520807 | p03373 | python | s011911200 | s727676469 | 109 | 18 | 3,060 | 3,188 | Accepted | Accepted | 83.49 | A, B, C, X, Y = list(map(int, input().split()))
m_value = float('inf')
for ab in range(max(X, Y) + 1):
ab2 = 2 * ab
a = X - ab
b = Y - ab
tmp = C * ab2
if a > 0:
tmp += a * A
if b > 0:
tmp += b * B
m_value = min(m_value, tmp)
print(m_value)
| """
O(1)解法
以下の3つから一番安いものを選ぶ
1. AピザとBピザをそれぞれ必要数買う場合
2. ABピザを必要数の多いピザ基準で買う場合 (2倍必要になることを忘れない)
3. ABピザを必要数の少ないピザ基準で買い、不足分のピザを買い足す場合
"""
A, B, C, X, Y = list(map(int, input().split()))
# Aピザの必要数がBピザよりも多くなるように、必要数と値段を入れ替える
if X < Y:
X, Y = Y, X
A, B = B, A
p1 = A * X + B * Y # 1
p2 = 2 * C * X # 2
p3 = 2 * C * Y + (X - Y) * A # 3
print((min(p1, p2, p3)))
| 13 | 16 | 291 | 370 | A, B, C, X, Y = list(map(int, input().split()))
m_value = float("inf")
for ab in range(max(X, Y) + 1):
ab2 = 2 * ab
a = X - ab
b = Y - ab
tmp = C * ab2
if a > 0:
tmp += a * A
if b > 0:
tmp += b * B
m_value = min(m_value, tmp)
print(m_value)
| """
O(1)解法
以下の3つから一番安いものを選ぶ
1. AピザとBピザをそれぞれ必要数買う場合
2. ABピザを必要数の多いピザ基準で買う場合 (2倍必要になることを忘れない)
3. ABピザを必要数の少ないピザ基準で買い、不足分のピザを買い足す場合
"""
A, B, C, X, Y = list(map(int, input().split()))
# Aピザの必要数がBピザよりも多くなるように、必要数と値段を入れ替える
if X < Y:
X, Y = Y, X
A, B = B, A
p1 = A * X + B * Y # 1
p2 = 2 * C * X # 2
p3 = 2 * C * Y + (X - Y) * A # 3
print((min(p1, p2, p3)))
| false | 18.75 | [
"+\"\"\"",
"+O(1)解法",
"+以下の3つから一番安いものを選ぶ",
"+1. AピザとBピザをそれぞれ必要数買う場合",
"+2. ABピザを必要数の多いピザ基準で買う場合 (2倍必要になることを忘れない)",
"+3. ABピザを必要数の少ないピザ基準で買い、不足分のピザを買い足す場合",
"+\"\"\"",
"-m_value = float(\"inf\")",
"-for ab in range(max(X, Y) + 1):",
"- ab2 = 2 * ab",
"- a = X - ab",
"- b = Y - ab",
"- tmp = C * ab2",
"- if a > 0:",
"- tmp += a * A",
"- if b > 0:",
"- tmp += b * B",
"- m_value = min(m_value, tmp)",
"-print(m_value)",
"+# Aピザの必要数がBピザよりも多くなるように、必要数と値段を入れ替える",
"+if X < Y:",
"+ X, Y = Y, X",
"+ A, B = B, A",
"+p1 = A * X + B * Y # 1",
"+p2 = 2 * C * X # 2",
"+p3 = 2 * C * Y + (X - Y) * A # 3",
"+print((min(p1, p2, p3)))"
] | false | 0.047662 | 0.006706 | 7.107414 | [
"s011911200",
"s727676469"
] |
u287500079 | p02972 | python | s975193586 | s426398789 | 679 | 492 | 7,276 | 90,720 | Accepted | Accepted | 27.54 | n = int(input())
a = [int(i) for i in input().split()]
arr = [0 for _ in range(n)]
for i in reversed(range(n)):
s = 0
for j in range(i, n, i+1):
s += arr[j]
s %= 2
if a[i] != s:
arr[i] = 1
print(sum(arr))
for i in range(n):
if arr[i] == 1:
print(i+1, end=' ')
print('')
| import sys, re, os
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, acos, atan, asin
from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from fractions import gcd
def input(): return sys.stdin.readline().strip()
def STR(): return input()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def S_MAP(): return map(str, input().split())
def LIST(): return list(map(int, input().split()))
def S_LIST(): return list(map(str, input().split()))
sys.setrecursionlimit(10 ** 9)
inf = sys.maxsize
mod = 10 ** 9 + 7
n = INT()
a = LIST()
b = [0 for _ in range(n)]
for i in reversed(range(n)):
if i * 2 >= n:
b[i] = a[i]
continue
s = 0
for j in range(i, n, i + 1):
s += b[j]
if s % 2 != a[i]:
b[i] = 1
print(sum(b))
for i in range(n):
if b[i] == 1:
print(i + 1, end=' ')
print('')
| 15 | 36 | 328 | 1,103 | n = int(input())
a = [int(i) for i in input().split()]
arr = [0 for _ in range(n)]
for i in reversed(range(n)):
s = 0
for j in range(i, n, i + 1):
s += arr[j]
s %= 2
if a[i] != s:
arr[i] = 1
print(sum(arr))
for i in range(n):
if arr[i] == 1:
print(i + 1, end=" ")
print("")
| import sys, re, os
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, acos, atan, asin
from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from fractions import gcd
def input():
return sys.stdin.readline().strip()
def STR():
return input()
def INT():
return int(input())
def MAP():
return map(int, input().split())
def S_MAP():
return map(str, input().split())
def LIST():
return list(map(int, input().split()))
def S_LIST():
return list(map(str, input().split()))
sys.setrecursionlimit(10**9)
inf = sys.maxsize
mod = 10**9 + 7
n = INT()
a = LIST()
b = [0 for _ in range(n)]
for i in reversed(range(n)):
if i * 2 >= n:
b[i] = a[i]
continue
s = 0
for j in range(i, n, i + 1):
s += b[j]
if s % 2 != a[i]:
b[i] = 1
print(sum(b))
for i in range(n):
if b[i] == 1:
print(i + 1, end=" ")
print("")
| false | 58.333333 | [
"-n = int(input())",
"-a = [int(i) for i in input().split()]",
"-arr = [0 for _ in range(n)]",
"+import sys, re, os",
"+from collections import deque, defaultdict, Counter",
"+from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, acos, atan, asin",
"+from itertools import permutations, combinations, product, accumulate",
"+from operator import itemgetter, mul",
"+from copy import deepcopy",
"+from string import ascii_lowercase, ascii_uppercase, digits",
"+from fractions import gcd",
"+",
"+",
"+def input():",
"+ return sys.stdin.readline().strip()",
"+",
"+",
"+def STR():",
"+ return input()",
"+",
"+",
"+def INT():",
"+ return int(input())",
"+",
"+",
"+def MAP():",
"+ return map(int, input().split())",
"+",
"+",
"+def S_MAP():",
"+ return map(str, input().split())",
"+",
"+",
"+def LIST():",
"+ return list(map(int, input().split()))",
"+",
"+",
"+def S_LIST():",
"+ return list(map(str, input().split()))",
"+",
"+",
"+sys.setrecursionlimit(10**9)",
"+inf = sys.maxsize",
"+mod = 10**9 + 7",
"+n = INT()",
"+a = LIST()",
"+b = [0 for _ in range(n)]",
"+ if i * 2 >= n:",
"+ b[i] = a[i]",
"+ continue",
"- s += arr[j]",
"- s %= 2",
"- if a[i] != s:",
"- arr[i] = 1",
"-print(sum(arr))",
"+ s += b[j]",
"+ if s % 2 != a[i]:",
"+ b[i] = 1",
"+print(sum(b))",
"- if arr[i] == 1:",
"+ if b[i] == 1:"
] | false | 0.044278 | 0.076717 | 0.577161 | [
"s975193586",
"s426398789"
] |
u949831615 | p02712 | python | s635080951 | s693139601 | 330 | 23 | 147,436 | 9,124 | Accepted | Accepted | 93.03 | n = int(eval(input()))
A = list(range(1, n+1))
B = list()
for i in range(1, n+1):
if i % 5 == 0 or i % 3 == 0:
B.append(i)
ans = list(set(A) - set(B))
print((sum(ans))) | n = int(eval(input()))
n3 = n // 3
n5 = n // 5
n15 = n // 15
print((n*(n + 1)//2 - 3*n3*(n3 + 1)//2 - 5*n5*(n5 + 1)//2 + 15*n15*(n15 + 1)//2)) | 8 | 7 | 179 | 142 | n = int(eval(input()))
A = list(range(1, n + 1))
B = list()
for i in range(1, n + 1):
if i % 5 == 0 or i % 3 == 0:
B.append(i)
ans = list(set(A) - set(B))
print((sum(ans)))
| n = int(eval(input()))
n3 = n // 3
n5 = n // 5
n15 = n // 15
print(
(
n * (n + 1) // 2
- 3 * n3 * (n3 + 1) // 2
- 5 * n5 * (n5 + 1) // 2
+ 15 * n15 * (n15 + 1) // 2
)
)
| false | 12.5 | [
"-A = list(range(1, n + 1))",
"-B = list()",
"-for i in range(1, n + 1):",
"- if i % 5 == 0 or i % 3 == 0:",
"- B.append(i)",
"-ans = list(set(A) - set(B))",
"-print((sum(ans)))",
"+n3 = n // 3",
"+n5 = n // 5",
"+n15 = n // 15",
"+print(",
"+ (",
"+ n * (n + 1) // 2",
"+ - 3 * n3 * (n3 + 1) // 2",
"+ - 5 * n5 * (n5 + 1) // 2",
"+ + 15 * n15 * (n15 + 1) // 2",
"+ )",
"+)"
] | false | 0.210569 | 0.035818 | 5.878908 | [
"s635080951",
"s693139601"
] |
u225388820 | p02708 | python | s650376000 | s921486827 | 126 | 77 | 9,120 | 9,116 | Accepted | Accepted | 38.89 | n,k=list(map(int,input().split()))
ans=0
mod=10**9+7
for i in range(k,n+2):
ans+=(2*n-i+1)*i//2-i*(i-1)//2+1
ans%=mod
print(ans) | n,k=list(map(int,input().split()))
ans=0
mod=10**9+7
for i in range(k,n+2):
ans+=(n-i+1)*i+1
ans%=mod
print(ans) | 7 | 7 | 136 | 120 | n, k = list(map(int, input().split()))
ans = 0
mod = 10**9 + 7
for i in range(k, n + 2):
ans += (2 * n - i + 1) * i // 2 - i * (i - 1) // 2 + 1
ans %= mod
print(ans)
| n, k = list(map(int, input().split()))
ans = 0
mod = 10**9 + 7
for i in range(k, n + 2):
ans += (n - i + 1) * i + 1
ans %= mod
print(ans)
| false | 0 | [
"- ans += (2 * n - i + 1) * i // 2 - i * (i - 1) // 2 + 1",
"+ ans += (n - i + 1) * i + 1"
] | false | 0.10997 | 0.054017 | 2.03585 | [
"s650376000",
"s921486827"
] |
u596536048 | p04011 | python | s345182211 | s966375096 | 29 | 25 | 9,096 | 9,156 | Accepted | Accepted | 13.79 | N = int(eval(input()))
K = int(eval(input()))
X = int(eval(input()))
Y = int(eval(input()))
P = 0
for i in range(1,N+1):
if i <= K:
P = P + X
else:
P = P + Y
print(P) | N, K, X, Y = (int(eval(input())) for i in range(4))
P = 0
for i in range(1,N+1):
if i <= K:
P = P + X
else:
P = P + Y
print(P) | 11 | 8 | 164 | 139 | N = int(eval(input()))
K = int(eval(input()))
X = int(eval(input()))
Y = int(eval(input()))
P = 0
for i in range(1, N + 1):
if i <= K:
P = P + X
else:
P = P + Y
print(P)
| N, K, X, Y = (int(eval(input())) for i in range(4))
P = 0
for i in range(1, N + 1):
if i <= K:
P = P + X
else:
P = P + Y
print(P)
| false | 27.272727 | [
"-N = int(eval(input()))",
"-K = int(eval(input()))",
"-X = int(eval(input()))",
"-Y = int(eval(input()))",
"+N, K, X, Y = (int(eval(input())) for i in range(4))"
] | false | 0.046815 | 0.047444 | 0.98674 | [
"s345182211",
"s966375096"
] |
u427344224 | p03806 | python | s645513084 | s387813865 | 539 | 469 | 133,724 | 119,004 | Accepted | Accepted | 12.99 | N, Ma, Mb = list(map(int, input().split()))
items = []
for i in range(N):
a, b, c = list(map(int, input().split()))
items.append((a, b, c))
a_sum = sum([item[0] for item in items])
b_sum = sum([item[1] for item in items])
inf = float("inf")
dp = [[[inf for _ in range(a_sum + 100)] for _ in range(b_sum + 100)] for i in range(N + 1)]
dp[0][0][0] = 0
for i in range(N):
for a in range(a_sum + 1):
for b in range(b_sum + 1):
if dp[i + 1][a][b] > dp[i][a][b]:
dp[i + 1][a][b] = dp[i][a][b]
if dp[i + 1][a + items[i][0]][b + items[i][1]] > dp[i][a][b] + items[i][2]:
dp[i + 1][a + items[i][0]][b + items[i][1]] = dp[i][a][b] + items[i][2]
ans = inf
for a in range(1, a_sum + 1):
for b in range(1, b_sum + 1):
if a * Mb == b * Ma:
ans = min(ans, dp[N][a][b])
if ans != inf:
print(ans)
else:
print((-1))
| N, Ma, Mb = list(map(int, input().split()))
items = []
for i in range(N):
a, b, c = list(map(int, input().split()))
items.append((a, b, c))
a_sum = sum([item[0] for item in items])
b_sum = sum([item[1] for item in items])
inf = float("inf")
dp = [[[inf for _ in range(a_sum + 60)] for _ in range(b_sum + 60)] for i in range(N + 1)]
dp[0][0][0] = 0
for i in range(N):
for a in range(a_sum):
for b in range(b_sum):
if dp[i + 1][a][b] > dp[i][a][b]:
dp[i + 1][a][b] = dp[i][a][b]
if dp[i + 1][a + items[i][0]][b + items[i][1]] > dp[i][a][b] + items[i][2]:
dp[i + 1][a + items[i][0]][b + items[i][1]] = dp[i][a][b] + items[i][2]
ans = inf
for a in range(1, a_sum + 1):
for b in range(1, b_sum + 1):
if a * Mb == b * Ma:
ans = min(ans, dp[N][a][b])
if ans != inf:
print(ans)
else:
print((-1))
| 29 | 29 | 923 | 913 | N, Ma, Mb = list(map(int, input().split()))
items = []
for i in range(N):
a, b, c = list(map(int, input().split()))
items.append((a, b, c))
a_sum = sum([item[0] for item in items])
b_sum = sum([item[1] for item in items])
inf = float("inf")
dp = [
[[inf for _ in range(a_sum + 100)] for _ in range(b_sum + 100)]
for i in range(N + 1)
]
dp[0][0][0] = 0
for i in range(N):
for a in range(a_sum + 1):
for b in range(b_sum + 1):
if dp[i + 1][a][b] > dp[i][a][b]:
dp[i + 1][a][b] = dp[i][a][b]
if dp[i + 1][a + items[i][0]][b + items[i][1]] > dp[i][a][b] + items[i][2]:
dp[i + 1][a + items[i][0]][b + items[i][1]] = dp[i][a][b] + items[i][2]
ans = inf
for a in range(1, a_sum + 1):
for b in range(1, b_sum + 1):
if a * Mb == b * Ma:
ans = min(ans, dp[N][a][b])
if ans != inf:
print(ans)
else:
print((-1))
| N, Ma, Mb = list(map(int, input().split()))
items = []
for i in range(N):
a, b, c = list(map(int, input().split()))
items.append((a, b, c))
a_sum = sum([item[0] for item in items])
b_sum = sum([item[1] for item in items])
inf = float("inf")
dp = [
[[inf for _ in range(a_sum + 60)] for _ in range(b_sum + 60)] for i in range(N + 1)
]
dp[0][0][0] = 0
for i in range(N):
for a in range(a_sum):
for b in range(b_sum):
if dp[i + 1][a][b] > dp[i][a][b]:
dp[i + 1][a][b] = dp[i][a][b]
if dp[i + 1][a + items[i][0]][b + items[i][1]] > dp[i][a][b] + items[i][2]:
dp[i + 1][a + items[i][0]][b + items[i][1]] = dp[i][a][b] + items[i][2]
ans = inf
for a in range(1, a_sum + 1):
for b in range(1, b_sum + 1):
if a * Mb == b * Ma:
ans = min(ans, dp[N][a][b])
if ans != inf:
print(ans)
else:
print((-1))
| false | 0 | [
"- [[inf for _ in range(a_sum + 100)] for _ in range(b_sum + 100)]",
"- for i in range(N + 1)",
"+ [[inf for _ in range(a_sum + 60)] for _ in range(b_sum + 60)] for i in range(N + 1)",
"- for a in range(a_sum + 1):",
"- for b in range(b_sum + 1):",
"+ for a in range(a_sum):",
"+ for b in range(b_sum):"
] | false | 0.041944 | 0.008089 | 5.184967 | [
"s645513084",
"s387813865"
] |
u102461423 | p02954 | python | s519340025 | s411051330 | 1,434 | 1,300 | 32,484 | 23,316 | Accepted | Accepted | 9.34 | import numpy as np
from scipy.sparse import csr_matrix, linalg
s = np.array(list(eval(input())), dtype='U1')
n = len(s)
child = np.ones(n,dtype=np.int32)
rows = list(range(n))
cols = [i+1 if c == 'R' else i-1 for i,c in enumerate(s)]
x = csr_matrix((np.ones(n,dtype=np.int32),(rows,cols)),(n,n))
def power(x,n):
if n == 1:
return x
y = power(x,n//2)
y = y*y
return x*y if n&1 else y
x = power(x,10**100)
print((*(child*x))) | import numpy as np
from scipy.sparse import csr_matrix
s = np.array(list(eval(input())), dtype='U1')
n = len(s)
child = np.ones(n,dtype=np.int32)
rows = np.arange(n)
cols = np.where(s == 'R', rows+1, rows-1)
x = csr_matrix((np.ones(n,dtype=np.int32),(rows,cols)),(n,n))
def power(x,n):
if n == 1:
return x
y = power(x,n//2)
y = y*y
return x*y if n&1 else y
x = power(x,10**100)
print((*(child*x)))
| 18 | 18 | 452 | 433 | import numpy as np
from scipy.sparse import csr_matrix, linalg
s = np.array(list(eval(input())), dtype="U1")
n = len(s)
child = np.ones(n, dtype=np.int32)
rows = list(range(n))
cols = [i + 1 if c == "R" else i - 1 for i, c in enumerate(s)]
x = csr_matrix((np.ones(n, dtype=np.int32), (rows, cols)), (n, n))
def power(x, n):
if n == 1:
return x
y = power(x, n // 2)
y = y * y
return x * y if n & 1 else y
x = power(x, 10**100)
print((*(child * x)))
| import numpy as np
from scipy.sparse import csr_matrix
s = np.array(list(eval(input())), dtype="U1")
n = len(s)
child = np.ones(n, dtype=np.int32)
rows = np.arange(n)
cols = np.where(s == "R", rows + 1, rows - 1)
x = csr_matrix((np.ones(n, dtype=np.int32), (rows, cols)), (n, n))
def power(x, n):
if n == 1:
return x
y = power(x, n // 2)
y = y * y
return x * y if n & 1 else y
x = power(x, 10**100)
print((*(child * x)))
| false | 0 | [
"-from scipy.sparse import csr_matrix, linalg",
"+from scipy.sparse import csr_matrix",
"-rows = list(range(n))",
"-cols = [i + 1 if c == \"R\" else i - 1 for i, c in enumerate(s)]",
"+rows = np.arange(n)",
"+cols = np.where(s == \"R\", rows + 1, rows - 1)"
] | false | 0.440458 | 1.095271 | 0.402145 | [
"s519340025",
"s411051330"
] |
u567380442 | p02289 | python | s496236443 | s092162587 | 6,450 | 4,830 | 152,136 | 47,232 | Accepted | Accepted | 25.12 | from sys import stdin
readline = stdin.readline
import heapq
def main():
heap = []
while True:
line = readline()
if line[2] == 't':
print((heapq.heappop(heap)[1]))
elif line[2] == 's':
n = int(line.split()[1])
heapq.heappush(heap, (-n, n))
else:
break
main() | from sys import stdin
from heapq import heappop, heappush
readline = stdin.readline
heap = []
while True:
line = readline()
if line[1] == 'x':print((-heappop(heap)))
elif line[0] == 'i':heappush(heap, -int(line.split()[1]))
else:break | 19 | 11 | 366 | 260 | from sys import stdin
readline = stdin.readline
import heapq
def main():
heap = []
while True:
line = readline()
if line[2] == "t":
print((heapq.heappop(heap)[1]))
elif line[2] == "s":
n = int(line.split()[1])
heapq.heappush(heap, (-n, n))
else:
break
main()
| from sys import stdin
from heapq import heappop, heappush
readline = stdin.readline
heap = []
while True:
line = readline()
if line[1] == "x":
print((-heappop(heap)))
elif line[0] == "i":
heappush(heap, -int(line.split()[1]))
else:
break
| false | 42.105263 | [
"+from heapq import heappop, heappush",
"-import heapq",
"-",
"-",
"-def main():",
"- heap = []",
"- while True:",
"- line = readline()",
"- if line[2] == \"t\":",
"- print((heapq.heappop(heap)[1]))",
"- elif line[2] == \"s\":",
"- n = int(line.split()[1])",
"- heapq.heappush(heap, (-n, n))",
"- else:",
"- break",
"-",
"-",
"-main()",
"+heap = []",
"+while True:",
"+ line = readline()",
"+ if line[1] == \"x\":",
"+ print((-heappop(heap)))",
"+ elif line[0] == \"i\":",
"+ heappush(heap, -int(line.split()[1]))",
"+ else:",
"+ break"
] | false | 0.038542 | 0.039336 | 0.979794 | [
"s496236443",
"s092162587"
] |
u285891772 | p02848 | python | s469069482 | s473247906 | 423 | 328 | 22,248 | 22,452 | Accepted | Accepted | 22.46 | import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, tan, asin, acos, atan, radians, degrees, log2
from itertools import accumulate, permutations, combinations, combinations_with_replacement, product, groupby
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
import numpy as np
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7
N = INT()
S = input()
A = [chr(65+(ord(S[i])-65 + N)%26) for i in range(len(S))]
print(*A, sep="")
| import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, tan, asin, acos, atan, radians, degrees, log2
from itertools import accumulate, permutations, combinations, combinations_with_replacement, product, groupby
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits, ascii_letters
from bisect import bisect, bisect_left
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
import numpy as np
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7
N = INT()
S = input()
ans = []
for s in S:
ans.append(ascii_uppercase[(ascii_uppercase.index(s)+N)%26])
print(*ans, sep="")
| 26 | 29 | 951 | 996 | import sys, re
from collections import deque, defaultdict, Counter
from math import (
ceil,
sqrt,
hypot,
factorial,
pi,
sin,
cos,
tan,
asin,
acos,
atan,
radians,
degrees,
log2,
)
from itertools import (
accumulate,
permutations,
combinations,
combinations_with_replacement,
product,
groupby,
)
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from heapq import heappush, heappop
from functools import reduce
def input():
return sys.stdin.readline().strip()
def INT():
return int(input())
def MAP():
return map(int, input().split())
def LIST():
return list(map(int, input().split()))
def ZIP(n):
return zip(*(MAP() for _ in range(n)))
import numpy as np
sys.setrecursionlimit(10**9)
INF = float("inf")
mod = 10**9 + 7
N = INT()
S = input()
A = [chr(65 + (ord(S[i]) - 65 + N) % 26) for i in range(len(S))]
print(*A, sep="")
| import sys, re
from collections import deque, defaultdict, Counter
from math import (
ceil,
sqrt,
hypot,
factorial,
pi,
sin,
cos,
tan,
asin,
acos,
atan,
radians,
degrees,
log2,
)
from itertools import (
accumulate,
permutations,
combinations,
combinations_with_replacement,
product,
groupby,
)
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits, ascii_letters
from bisect import bisect, bisect_left
from heapq import heappush, heappop
from functools import reduce
def input():
return sys.stdin.readline().strip()
def INT():
return int(input())
def MAP():
return map(int, input().split())
def LIST():
return list(map(int, input().split()))
def ZIP(n):
return zip(*(MAP() for _ in range(n)))
import numpy as np
sys.setrecursionlimit(10**9)
INF = float("inf")
mod = 10**9 + 7
N = INT()
S = input()
ans = []
for s in S:
ans.append(ascii_uppercase[(ascii_uppercase.index(s) + N) % 26])
print(*ans, sep="")
| false | 10.344828 | [
"-from string import ascii_lowercase, ascii_uppercase, digits",
"+from string import ascii_lowercase, ascii_uppercase, digits, ascii_letters",
"-A = [chr(65 + (ord(S[i]) - 65 + N) % 26) for i in range(len(S))]",
"-print(*A, sep=\"\")",
"+ans = []",
"+for s in S:",
"+ ans.append(ascii_uppercase[(ascii_uppercase.index(s) + N) % 26])",
"+print(*ans, sep=\"\")"
] | false | 0.118047 | 0.0482 | 2.449115 | [
"s469069482",
"s473247906"
] |
u150984829 | p02470 | python | s604986466 | s587129434 | 30 | 20 | 5,592 | 5,600 | Accepted | Accepted | 33.33 | f=lambda x:p*(x-1)//x
p=n=int(eval(input()))
d=2
while d*d<=n:
if n%d==0:
p=f(d)
while n%d==0:n//=d
d+=1
if n>1:p=f(n)
print(p)
| p=n=int(eval(input()))
d=2
while d*d<=n:
if n%d==0:
p=p*(d-1)//d
while n%d==0:n//=d
d+=1
print(([p,p*(n-1)//n][n>1]))
| 10 | 8 | 137 | 123 | f = lambda x: p * (x - 1) // x
p = n = int(eval(input()))
d = 2
while d * d <= n:
if n % d == 0:
p = f(d)
while n % d == 0:
n //= d
d += 1
if n > 1:
p = f(n)
print(p)
| p = n = int(eval(input()))
d = 2
while d * d <= n:
if n % d == 0:
p = p * (d - 1) // d
while n % d == 0:
n //= d
d += 1
print(([p, p * (n - 1) // n][n > 1]))
| false | 20 | [
"-f = lambda x: p * (x - 1) // x",
"- p = f(d)",
"+ p = p * (d - 1) // d",
"-if n > 1:",
"- p = f(n)",
"-print(p)",
"+print(([p, p * (n - 1) // n][n > 1]))"
] | false | 0.087091 | 0.035312 | 2.466323 | [
"s604986466",
"s587129434"
] |
u761320129 | p03292 | python | s127032988 | s428153382 | 19 | 17 | 3,064 | 2,940 | Accepted | Accepted | 10.53 | a,b,c = list(map(int,input().split()))
ans = 9999
ans = min(ans, abs(a-b) + abs(b-c), abs(a-c) + abs(c-b))
ans = min(ans, abs(b-a) + abs(a-c), abs(b-c) + abs(c-a))
ans = min(ans, abs(c-a) + abs(a-b), abs(c-b) + abs(b-a))
print(ans) | a,b,c = list(map(int,input().split()))
print((max(a,b,c) - min(a,b,c))) | 6 | 2 | 230 | 64 | a, b, c = list(map(int, input().split()))
ans = 9999
ans = min(ans, abs(a - b) + abs(b - c), abs(a - c) + abs(c - b))
ans = min(ans, abs(b - a) + abs(a - c), abs(b - c) + abs(c - a))
ans = min(ans, abs(c - a) + abs(a - b), abs(c - b) + abs(b - a))
print(ans)
| a, b, c = list(map(int, input().split()))
print((max(a, b, c) - min(a, b, c)))
| false | 66.666667 | [
"-ans = 9999",
"-ans = min(ans, abs(a - b) + abs(b - c), abs(a - c) + abs(c - b))",
"-ans = min(ans, abs(b - a) + abs(a - c), abs(b - c) + abs(c - a))",
"-ans = min(ans, abs(c - a) + abs(a - b), abs(c - b) + abs(b - a))",
"-print(ans)",
"+print((max(a, b, c) - min(a, b, c)))"
] | false | 0.067805 | 0.070488 | 0.961942 | [
"s127032988",
"s428153382"
] |
u167647458 | p02725 | python | s348147307 | s862180153 | 195 | 136 | 26,444 | 26,436 | Accepted | Accepted | 30.26 | k, n = list(map(int, input().split()))
a = list(map(int, input().split()))
a.append(a[0] + k)
m = 0
s = 0
for i in range(n):
m = max(m, a[i+1] - a[i])
s += a[i+1] - a[i]
print((s - m)) | k, n = list(map(int, input().split()))
a = list(map(int, input().split()))
a.append(a[0] + k)
m = 0
for i in range(n):
m = max(m, a[i+1] - a[i])
print((k - m)) | 10 | 8 | 194 | 163 | k, n = list(map(int, input().split()))
a = list(map(int, input().split()))
a.append(a[0] + k)
m = 0
s = 0
for i in range(n):
m = max(m, a[i + 1] - a[i])
s += a[i + 1] - a[i]
print((s - m))
| k, n = list(map(int, input().split()))
a = list(map(int, input().split()))
a.append(a[0] + k)
m = 0
for i in range(n):
m = max(m, a[i + 1] - a[i])
print((k - m))
| false | 20 | [
"-s = 0",
"- s += a[i + 1] - a[i]",
"-print((s - m))",
"+print((k - m))"
] | false | 0.037359 | 0.037512 | 0.995926 | [
"s348147307",
"s862180153"
] |
u566872786 | p00100 | python | s866410348 | s334869004 | 60 | 30 | 8,152 | 8,204 | Accepted | Accepted | 50 | while 1:
n=int(eval(input()))
if not n:break
f=1
L={}
for a,b,c in [list(map(int,input().split())) for i in range(n)]:
a=str(a)
d=b*c
if a in L:
if L[a]>=1e6:continue
L[a]+=d
else:L[a]=d
if L[a] >= 1e6:
print(a)
f=0
if f:print('NA') | while 1:
n=int(eval(input()))
if not n:break
f=1
L={}
for a,b,c in [input().split() for i in range(n)]:
d=int(b)*int(c)
if a in L:
if L[a]>=1e6:continue
L[a]+=d
else:L[a]=d
if L[a]>=1e6:
print(a)
f=0
if f:print('NA') | 16 | 15 | 291 | 276 | while 1:
n = int(eval(input()))
if not n:
break
f = 1
L = {}
for a, b, c in [list(map(int, input().split())) for i in range(n)]:
a = str(a)
d = b * c
if a in L:
if L[a] >= 1e6:
continue
L[a] += d
else:
L[a] = d
if L[a] >= 1e6:
print(a)
f = 0
if f:
print("NA")
| while 1:
n = int(eval(input()))
if not n:
break
f = 1
L = {}
for a, b, c in [input().split() for i in range(n)]:
d = int(b) * int(c)
if a in L:
if L[a] >= 1e6:
continue
L[a] += d
else:
L[a] = d
if L[a] >= 1e6:
print(a)
f = 0
if f:
print("NA")
| false | 6.25 | [
"- for a, b, c in [list(map(int, input().split())) for i in range(n)]:",
"- a = str(a)",
"- d = b * c",
"+ for a, b, c in [input().split() for i in range(n)]:",
"+ d = int(b) * int(c)"
] | false | 0.065445 | 0.125016 | 0.523492 | [
"s866410348",
"s334869004"
] |
u948911484 | p02580 | python | s661413167 | s990554130 | 1,046 | 783 | 240,304 | 245,152 | Accepted | Accepted | 25.14 | from collections import Counter
H,W,m = list(map(int,input().split()))
ci = Counter([])
cj = Counter([])
s = set()
for i in range(m):
h,w = list(map(int,input().split()))
ci[h] += 1
cj[w] += 1
s.add((h,w))
mi = max(ci.values())
mj = max(cj.values())
ci = sorted(list(ci.items()),key=lambda x:x[1], reverse=True)
cj = sorted(list(cj.items()),key=lambda x:x[1], reverse=True)
xi = [ci[i][0] for i in range(len(ci)) if ci[i][1] == mi]
xj = [cj[i][0] for i in range(len(cj)) if cj[i][1] == mj]
for i in xi:
for j in xj:
if (i,j) not in s:
print((mi+mj))
quit()
print((mi+mj-1)) | from collections import Counter
H,W,m = list(map(int,input().split()))
ci = Counter([])
cj = Counter([])
s = set()
for i in range(m):
h,w = list(map(int,input().split()))
ci[h] += 1
cj[w] += 1
s.add((h,w))
mi = max(ci.values())
mj = max(cj.values())
ci = list(ci.items())
cj = list(cj.items())
xi = [ci[i][0] for i in range(len(ci)) if ci[i][1] == mi]
xj = [cj[i][0] for i in range(len(cj)) if cj[i][1] == mj]
for i in xi:
for j in xj:
if (i,j) not in s:
print((mi+mj))
quit()
print((mi+mj-1)) | 22 | 22 | 618 | 550 | from collections import Counter
H, W, m = list(map(int, input().split()))
ci = Counter([])
cj = Counter([])
s = set()
for i in range(m):
h, w = list(map(int, input().split()))
ci[h] += 1
cj[w] += 1
s.add((h, w))
mi = max(ci.values())
mj = max(cj.values())
ci = sorted(list(ci.items()), key=lambda x: x[1], reverse=True)
cj = sorted(list(cj.items()), key=lambda x: x[1], reverse=True)
xi = [ci[i][0] for i in range(len(ci)) if ci[i][1] == mi]
xj = [cj[i][0] for i in range(len(cj)) if cj[i][1] == mj]
for i in xi:
for j in xj:
if (i, j) not in s:
print((mi + mj))
quit()
print((mi + mj - 1))
| from collections import Counter
H, W, m = list(map(int, input().split()))
ci = Counter([])
cj = Counter([])
s = set()
for i in range(m):
h, w = list(map(int, input().split()))
ci[h] += 1
cj[w] += 1
s.add((h, w))
mi = max(ci.values())
mj = max(cj.values())
ci = list(ci.items())
cj = list(cj.items())
xi = [ci[i][0] for i in range(len(ci)) if ci[i][1] == mi]
xj = [cj[i][0] for i in range(len(cj)) if cj[i][1] == mj]
for i in xi:
for j in xj:
if (i, j) not in s:
print((mi + mj))
quit()
print((mi + mj - 1))
| false | 0 | [
"-ci = sorted(list(ci.items()), key=lambda x: x[1], reverse=True)",
"-cj = sorted(list(cj.items()), key=lambda x: x[1], reverse=True)",
"+ci = list(ci.items())",
"+cj = list(cj.items())"
] | false | 0.120697 | 0.066601 | 1.812241 | [
"s661413167",
"s990554130"
] |
u744034042 | p03162 | python | s875281612 | s570906324 | 978 | 286 | 47,320 | 9,088 | Accepted | Accepted | 70.76 | n = int(eval(input()))
a = [list(map(int, input().split())) for i in range(n)]
dp = [[0 for i in range(3)] for j in range(n+1)]
for i in range(n):
for j in range(3):
for k in range(3):
if j != k:
dp[i+1][j] = max(dp[i+1][j], dp[i][k]+a[i][j])
print((max(dp[n]))) | n = int(eval(input()))
a,b,c = list(map(int,input().split()))
for i in range(1,n):
aa,bb,cc = list(map(int,input().split()))
aaa,bbb,ccc = a,b,c
a = max(aa+bbb,aa+ccc)
b = max(bb+ccc,bb+aaa)
c = max(cc+aaa,cc+bbb)
print((max(a,b,c))) | 9 | 9 | 302 | 241 | n = int(eval(input()))
a = [list(map(int, input().split())) for i in range(n)]
dp = [[0 for i in range(3)] for j in range(n + 1)]
for i in range(n):
for j in range(3):
for k in range(3):
if j != k:
dp[i + 1][j] = max(dp[i + 1][j], dp[i][k] + a[i][j])
print((max(dp[n])))
| n = int(eval(input()))
a, b, c = list(map(int, input().split()))
for i in range(1, n):
aa, bb, cc = list(map(int, input().split()))
aaa, bbb, ccc = a, b, c
a = max(aa + bbb, aa + ccc)
b = max(bb + ccc, bb + aaa)
c = max(cc + aaa, cc + bbb)
print((max(a, b, c)))
| false | 0 | [
"-a = [list(map(int, input().split())) for i in range(n)]",
"-dp = [[0 for i in range(3)] for j in range(n + 1)]",
"-for i in range(n):",
"- for j in range(3):",
"- for k in range(3):",
"- if j != k:",
"- dp[i + 1][j] = max(dp[i + 1][j], dp[i][k] + a[i][j])",
"-print((max(dp[n])))",
"+a, b, c = list(map(int, input().split()))",
"+for i in range(1, n):",
"+ aa, bb, cc = list(map(int, input().split()))",
"+ aaa, bbb, ccc = a, b, c",
"+ a = max(aa + bbb, aa + ccc)",
"+ b = max(bb + ccc, bb + aaa)",
"+ c = max(cc + aaa, cc + bbb)",
"+print((max(a, b, c)))"
] | false | 0.039231 | 0.034711 | 1.130216 | [
"s875281612",
"s570906324"
] |
u020390084 | p02844 | python | s308749091 | s326143526 | 1,628 | 18 | 3,064 | 3,064 | Accepted | Accepted | 98.89 | #!/usr/bin/env python3
import sys
def solve(N: int, S: str):
answer = 0
for i in range(0,1000):
i = str(i).zfill(3)
index = 0
for ss in S:
if ss == i[index]:
index += 1
if index >= 3:
answer += 1
break
print(answer)
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
S = next(tokens) # type: int
solve(N, S)
if __name__ == '__main__':
main()
| #!/usr/bin/env python3
import sys
def solve(N: int, S: str):
answer = 0
for i in range(0,1000):
i = str(i).zfill(3)
x = S.find(i[0])
if x == -1:
continue
y = S.find(i[1],x+1)
if y == -1:
continue
z = S.find(i[2],y+1)
if z == -1:
continue
answer +=1
print(answer)
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
S = next(tokens) # type: str
solve(N, S)
if __name__ == '__main__':
main()
| 31 | 36 | 673 | 727 | #!/usr/bin/env python3
import sys
def solve(N: int, S: str):
answer = 0
for i in range(0, 1000):
i = str(i).zfill(3)
index = 0
for ss in S:
if ss == i[index]:
index += 1
if index >= 3:
answer += 1
break
print(answer)
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
S = next(tokens) # type: int
solve(N, S)
if __name__ == "__main__":
main()
| #!/usr/bin/env python3
import sys
def solve(N: int, S: str):
answer = 0
for i in range(0, 1000):
i = str(i).zfill(3)
x = S.find(i[0])
if x == -1:
continue
y = S.find(i[1], x + 1)
if y == -1:
continue
z = S.find(i[2], y + 1)
if z == -1:
continue
answer += 1
print(answer)
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
S = next(tokens) # type: str
solve(N, S)
if __name__ == "__main__":
main()
| false | 13.888889 | [
"- index = 0",
"- for ss in S:",
"- if ss == i[index]:",
"- index += 1",
"- if index >= 3:",
"- answer += 1",
"- break",
"+ x = S.find(i[0])",
"+ if x == -1:",
"+ continue",
"+ y = S.find(i[1], x + 1)",
"+ if y == -1:",
"+ continue",
"+ z = S.find(i[2], y + 1)",
"+ if z == -1:",
"+ continue",
"+ answer += 1",
"- S = next(tokens) # type: int",
"+ S = next(tokens) # type: str"
] | false | 0.067059 | 0.067239 | 0.997316 | [
"s308749091",
"s326143526"
] |
u197457087 | p03633 | python | s741814790 | s419610196 | 292 | 29 | 65,772 | 9,160 | Accepted | Accepted | 90.07 | import fractions
N = int(eval(input()))
ans = int(eval(input()))
for i in range(1, N):
b = int(eval(input()))
ans = ans*b//fractions.gcd(ans, b)
print(ans) | import math
N = int(eval(input()))
ans = 1
for i in range(N):
a = int(eval(input()))
ans = ans*a//math.gcd(ans,a)
print(ans) | 7 | 7 | 147 | 122 | import fractions
N = int(eval(input()))
ans = int(eval(input()))
for i in range(1, N):
b = int(eval(input()))
ans = ans * b // fractions.gcd(ans, b)
print(ans)
| import math
N = int(eval(input()))
ans = 1
for i in range(N):
a = int(eval(input()))
ans = ans * a // math.gcd(ans, a)
print(ans)
| false | 0 | [
"-import fractions",
"+import math",
"-ans = int(eval(input()))",
"-for i in range(1, N):",
"- b = int(eval(input()))",
"- ans = ans * b // fractions.gcd(ans, b)",
"+ans = 1",
"+for i in range(N):",
"+ a = int(eval(input()))",
"+ ans = ans * a // math.gcd(ans, a)"
] | false | 0.062235 | 0.087543 | 0.710916 | [
"s741814790",
"s419610196"
] |
u227082700 | p03061 | python | s511125497 | s119216121 | 185 | 159 | 14,460 | 14,400 | Accepted | Accepted | 14.05 | n=int(eval(input()))
a=list(map(int,input().split()))
def gcd(a,b):
while b:a,b=b,a%b
return a
b=[0]*n
c=[0]*n
b[0]=a[0]
c[-1]=a[-1]
for i in range(1,n):b[i]=gcd(b[i-1],a[i])
for i in range(n-2,-1,-1):c[i]=gcd(c[i+1],a[i])
ans=max(c[1],b[-2])
for i in range(1,n-1):ans=max(ans,gcd(b[i-1],c[i+1]))
print(ans) | def gcd(a,b):
while b:a,b=b,a%b
return a
n=int(eval(input()))
a=list(map(int,input().split()))
if n==2:print((max(a[0],a[1])));exit()
left=[a[0]]
for i in range(1,n):left.append(gcd(left[-1],a[i]))
right=[a[n-1]]
for i in range(n-2,-1,-1):right.append(gcd(right[-1],a[i]))
right.reverse()
ans=max(right[1],left[n-2])
print((max(ans,max(gcd(left[i-1],right[i+1])for i in range(1,n-1))))) | 14 | 13 | 318 | 392 | n = int(eval(input()))
a = list(map(int, input().split()))
def gcd(a, b):
while b:
a, b = b, a % b
return a
b = [0] * n
c = [0] * n
b[0] = a[0]
c[-1] = a[-1]
for i in range(1, n):
b[i] = gcd(b[i - 1], a[i])
for i in range(n - 2, -1, -1):
c[i] = gcd(c[i + 1], a[i])
ans = max(c[1], b[-2])
for i in range(1, n - 1):
ans = max(ans, gcd(b[i - 1], c[i + 1]))
print(ans)
| def gcd(a, b):
while b:
a, b = b, a % b
return a
n = int(eval(input()))
a = list(map(int, input().split()))
if n == 2:
print((max(a[0], a[1])))
exit()
left = [a[0]]
for i in range(1, n):
left.append(gcd(left[-1], a[i]))
right = [a[n - 1]]
for i in range(n - 2, -1, -1):
right.append(gcd(right[-1], a[i]))
right.reverse()
ans = max(right[1], left[n - 2])
print((max(ans, max(gcd(left[i - 1], right[i + 1]) for i in range(1, n - 1)))))
| false | 7.142857 | [
"-n = int(eval(input()))",
"-a = list(map(int, input().split()))",
"-",
"-",
"-b = [0] * n",
"-c = [0] * n",
"-b[0] = a[0]",
"-c[-1] = a[-1]",
"+n = int(eval(input()))",
"+a = list(map(int, input().split()))",
"+if n == 2:",
"+ print((max(a[0], a[1])))",
"+ exit()",
"+left = [a[0]]",
"- b[i] = gcd(b[i - 1], a[i])",
"+ left.append(gcd(left[-1], a[i]))",
"+right = [a[n - 1]]",
"- c[i] = gcd(c[i + 1], a[i])",
"-ans = max(c[1], b[-2])",
"-for i in range(1, n - 1):",
"- ans = max(ans, gcd(b[i - 1], c[i + 1]))",
"-print(ans)",
"+ right.append(gcd(right[-1], a[i]))",
"+right.reverse()",
"+ans = max(right[1], left[n - 2])",
"+print((max(ans, max(gcd(left[i - 1], right[i + 1]) for i in range(1, n - 1)))))"
] | false | 0.066206 | 0.098817 | 0.669992 | [
"s511125497",
"s119216121"
] |
u111365362 | p03073 | python | s792019915 | s392765258 | 113 | 74 | 4,724 | 3,188 | Accepted | Accepted | 34.51 | number = eval(input())
le = len(number)
wst = [0] * le
bst = [0] * le
for k in range(le):
if k % 2 == 0:
wst[k] = 1
else:
bst[k] = 1
wsc = 0
bsc = 0
for k in range(le):
if int(number[k]) != wst[k]:
wsc += 1
if int(number[k]) != bst[k]:
bsc += 1
print((min([wsc,bsc]))) | s = eval(input())
n = len(s)
z0 = 0
z1 = 0
for i in range(n):
if int(s[i]) ^ (i%2) == 0:
z0 += 1
else:
z1 += 1
print((min(z0,z1))) | 17 | 10 | 300 | 143 | number = eval(input())
le = len(number)
wst = [0] * le
bst = [0] * le
for k in range(le):
if k % 2 == 0:
wst[k] = 1
else:
bst[k] = 1
wsc = 0
bsc = 0
for k in range(le):
if int(number[k]) != wst[k]:
wsc += 1
if int(number[k]) != bst[k]:
bsc += 1
print((min([wsc, bsc])))
| s = eval(input())
n = len(s)
z0 = 0
z1 = 0
for i in range(n):
if int(s[i]) ^ (i % 2) == 0:
z0 += 1
else:
z1 += 1
print((min(z0, z1)))
| false | 41.176471 | [
"-number = eval(input())",
"-le = len(number)",
"-wst = [0] * le",
"-bst = [0] * le",
"-for k in range(le):",
"- if k % 2 == 0:",
"- wst[k] = 1",
"+s = eval(input())",
"+n = len(s)",
"+z0 = 0",
"+z1 = 0",
"+for i in range(n):",
"+ if int(s[i]) ^ (i % 2) == 0:",
"+ z0 += 1",
"- bst[k] = 1",
"-wsc = 0",
"-bsc = 0",
"-for k in range(le):",
"- if int(number[k]) != wst[k]:",
"- wsc += 1",
"- if int(number[k]) != bst[k]:",
"- bsc += 1",
"-print((min([wsc, bsc])))",
"+ z1 += 1",
"+print((min(z0, z1)))"
] | false | 0.04481 | 0.044899 | 0.998026 | [
"s792019915",
"s392765258"
] |
u595289165 | p02555 | python | s185757824 | s350464074 | 340 | 72 | 10,160 | 64,700 | Accepted | Accepted | 78.82 | import sys
from functools import lru_cache
s = int(eval(input()))
sys.setrecursionlimit(10000000)
@lru_cache(maxsize=10000000)
def f(n):
mod = 10**9 + 7
if n == 3:
return 1
if n == 0:
return 1
if 0 < n < 3:
return 0
ret = 0
for u in range(3, n+1):
ret += f(n - u)
ret %= mod
return ret
print((f(s)))
| class ModCalc:
mod = 10**9 + 7
def __init__(self, n):
self.n = n
self.inv = [1] * (self.n + 1)
self.fac = [1] * (self.n + 1)
self.finv = [1] * (self.n + 1)
self.inv[0] = 0
self.inv_table()
def inv_table(self):
for i in range(2, self.n+1):
self.inv[i] = self.inv[self.mod % i] * (self.mod - self.mod // i) % self.mod
self.fac[i] = self.fac[i-1] * i % self.mod
self.finv[i] = self.finv[i-1] * self.inv[i] % self.mod
def comb(self, n, r):
if n < r:
return 0
if n < 0 or r < 0:
return 0
return self.fac[n] * self.finv[r] % self.mod * self.finv[n-r] % self.mod
def perm(self, n, r):
if n < r:
return 0
if n < 0 or r < 0:
return 0
return self.fac[n] * self.finv[n-r] % self.mod
def fact(self, n):
return self.fac[n]
s = int(eval(input()))
mc = ModCalc(s+6)
mod = 10**9 + 7
y = s//3
ans = 0
for i in range(1, y+1):
x = mc.comb(s - i * 3 + i - 1, i-1)
ans += x
ans %= mod
print(ans) | 23 | 49 | 386 | 1,159 | import sys
from functools import lru_cache
s = int(eval(input()))
sys.setrecursionlimit(10000000)
@lru_cache(maxsize=10000000)
def f(n):
mod = 10**9 + 7
if n == 3:
return 1
if n == 0:
return 1
if 0 < n < 3:
return 0
ret = 0
for u in range(3, n + 1):
ret += f(n - u)
ret %= mod
return ret
print((f(s)))
| class ModCalc:
mod = 10**9 + 7
def __init__(self, n):
self.n = n
self.inv = [1] * (self.n + 1)
self.fac = [1] * (self.n + 1)
self.finv = [1] * (self.n + 1)
self.inv[0] = 0
self.inv_table()
def inv_table(self):
for i in range(2, self.n + 1):
self.inv[i] = self.inv[self.mod % i] * (self.mod - self.mod // i) % self.mod
self.fac[i] = self.fac[i - 1] * i % self.mod
self.finv[i] = self.finv[i - 1] * self.inv[i] % self.mod
def comb(self, n, r):
if n < r:
return 0
if n < 0 or r < 0:
return 0
return self.fac[n] * self.finv[r] % self.mod * self.finv[n - r] % self.mod
def perm(self, n, r):
if n < r:
return 0
if n < 0 or r < 0:
return 0
return self.fac[n] * self.finv[n - r] % self.mod
def fact(self, n):
return self.fac[n]
s = int(eval(input()))
mc = ModCalc(s + 6)
mod = 10**9 + 7
y = s // 3
ans = 0
for i in range(1, y + 1):
x = mc.comb(s - i * 3 + i - 1, i - 1)
ans += x
ans %= mod
print(ans)
| false | 53.061224 | [
"-import sys",
"-from functools import lru_cache",
"+class ModCalc:",
"+ mod = 10**9 + 7",
"+",
"+ def __init__(self, n):",
"+ self.n = n",
"+ self.inv = [1] * (self.n + 1)",
"+ self.fac = [1] * (self.n + 1)",
"+ self.finv = [1] * (self.n + 1)",
"+ self.inv[0] = 0",
"+ self.inv_table()",
"+",
"+ def inv_table(self):",
"+ for i in range(2, self.n + 1):",
"+ self.inv[i] = self.inv[self.mod % i] * (self.mod - self.mod // i) % self.mod",
"+ self.fac[i] = self.fac[i - 1] * i % self.mod",
"+ self.finv[i] = self.finv[i - 1] * self.inv[i] % self.mod",
"+",
"+ def comb(self, n, r):",
"+ if n < r:",
"+ return 0",
"+ if n < 0 or r < 0:",
"+ return 0",
"+ return self.fac[n] * self.finv[r] % self.mod * self.finv[n - r] % self.mod",
"+",
"+ def perm(self, n, r):",
"+ if n < r:",
"+ return 0",
"+ if n < 0 or r < 0:",
"+ return 0",
"+ return self.fac[n] * self.finv[n - r] % self.mod",
"+",
"+ def fact(self, n):",
"+ return self.fac[n]",
"+",
"-sys.setrecursionlimit(10000000)",
"-",
"-",
"-@lru_cache(maxsize=10000000)",
"-def f(n):",
"- mod = 10**9 + 7",
"- if n == 3:",
"- return 1",
"- if n == 0:",
"- return 1",
"- if 0 < n < 3:",
"- return 0",
"- ret = 0",
"- for u in range(3, n + 1):",
"- ret += f(n - u)",
"- ret %= mod",
"- return ret",
"-",
"-",
"-print((f(s)))",
"+mc = ModCalc(s + 6)",
"+mod = 10**9 + 7",
"+y = s // 3",
"+ans = 0",
"+for i in range(1, y + 1):",
"+ x = mc.comb(s - i * 3 + i - 1, i - 1)",
"+ ans += x",
"+ ans %= mod",
"+print(ans)"
] | false | 0.184727 | 0.052954 | 3.488425 | [
"s185757824",
"s350464074"
] |
u394721319 | p04044 | python | s355598444 | s255857031 | 173 | 28 | 38,576 | 9,144 | Accepted | Accepted | 83.82 | N,L = [int(i) for i in input().split()]
S = [eval(input()) for _ in range(N)]
S.sort()
ans = ''
for i in S:
ans += i
print(ans)
| N,L = [int(i) for i in input().split()]
S = [input() for _ in range(N)]
S.sort()
[print(i,end='') for i in S]
| 9 | 5 | 136 | 115 | N, L = [int(i) for i in input().split()]
S = [eval(input()) for _ in range(N)]
S.sort()
ans = ""
for i in S:
ans += i
print(ans)
| N, L = [int(i) for i in input().split()]
S = [input() for _ in range(N)]
S.sort()
[print(i, end="") for i in S]
| false | 44.444444 | [
"-S = [eval(input()) for _ in range(N)]",
"+S = [input() for _ in range(N)]",
"-ans = \"\"",
"-for i in S:",
"- ans += i",
"-print(ans)",
"+[print(i, end=\"\") for i in S]"
] | false | 0.039177 | 0.039397 | 0.994428 | [
"s355598444",
"s255857031"
] |
u761529120 | p02804 | python | s840153741 | s704546411 | 416 | 279 | 141,432 | 72,104 | Accepted | Accepted | 32.93 | from collections import defaultdict
class Combination:
"""
O(n)の前計算を1回行うことで，O(1)でnCr mod mを求められる
n_max = 10**6のとき前処理は約950ms (PyPyなら約340ms, 10**7で約1800ms)
使用例：
comb = Combination(1000000)
print(comb(5, 3)) # 10
"""
def __init__(self, n_max, mod=10**9+7):
self.mod = mod
self.modinv = self.make_modinv_list(n_max)
self.fac, self.facinv = self.make_factorial_list(n_max)
def __call__(self, n, r):
return self.fac[n] * self.facinv[r] % self.mod * self.facinv[n-r] % self.mod
def make_factorial_list(self, n):
# 階乗のリストと階乗のmod逆元のリストを返す O(n)
# self.make_modinv_list()が先に実行されている必要がある
fac = [1]
facinv = [1]
for i in range(1, n+1):
fac.append(fac[i-1] * i % self.mod)
facinv.append(facinv[i-1] * self.modinv[i] % self.mod)
return fac, facinv
def make_modinv_list(self, n):
# 0からnまでのmod逆元のリストを返す O(n)
modinv = [0] * (n+1)
modinv[1] = 1
for i in range(2, n+1):
modinv[i] = self.mod - self.mod//i * modinv[self.mod%i] % self.mod
return modinv
def main():
#def cmb(n, r, mod):
# if ( r<0 or r>n ):
# return 0
# r = min(r, n-r)
# return g1[n] * g2[r] * g2[n-r] % mod
#
#mod = 10**9+7 #出力の制限
#N = 10**4
#g1 = [1, 1] # 元テーブル
#g2 = [1, 1] #逆元テーブル
#inverse = [0, 1] #逆元テーブル計算用テーブル
#
#for i in range( 2, N + 1 ):
# g1.append( ( g1[-1] * i ) % mod )
# inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )
# g2.append( (g2[-1] * inverse[-1]) % mod )
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
A.sort()
ans = 0
mod = 10 ** 9 + 7
comb = Combination(1000000)
# 最小になる数を求める
for i, a in enumerate(A):
if (N - 1 - i) >= K-1:
#tmp = cmb(N-1-i,K-1,mod)
tmp = comb(N-1-i, K-1)
ans -= (a * tmp)
ans %= mod
else:
break
A.sort(reverse=True)
for i, a in enumerate(A):
if (N - 1 - i) >= K-1:
#tmp = cmb(N-1-i,K-1,mod)
tmp = comb(N-1-i, K-1)
ans += (a * tmp)
ans %= mod
else:
break
print(ans)
if __name__ == "__main__":
main() | class Combination:
"""
O(n)の前計算を1回行うことで，O(1)でnCr mod mを求められる
n_max = 10**6のとき前処理は約950ms (PyPyなら約340ms, 10**7で約1800ms)
使用例：
comb = Combination(1000000)
print(comb(5, 3)) # 10
"""
def __init__(self, n_max, mod=10**9+7):
self.mod = mod
self.modinv = self.make_modinv_list(n_max)
self.fac, self.facinv = self.make_factorial_list(n_max)
def __call__(self, n, r):
if n < r:
return 0
return self.fac[n] * self.facinv[r] % self.mod * self.facinv[n-r] % self.mod
def make_factorial_list(self, n):
# 階乗のリストと階乗のmod逆元のリストを返す O(n)
# self.make_modinv_list()が先に実行されている必要がある
fac = [1]
facinv = [1]
for i in range(1, n+1):
fac.append(fac[i-1] * i % self.mod)
facinv.append(facinv[i-1] * self.modinv[i] % self.mod)
return fac, facinv
def make_modinv_list(self, n):
# 0からnまでのmod逆元のリストを返す O(n)
modinv = [0] * (n+1)
modinv[1] = 1
for i in range(2, n+1):
modinv[i] = self.mod - self.mod//i * modinv[self.mod%i] % self.mod
return modinv
def main():
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
MOD = 10 ** 9 + 7
ans = 0
comb = Combination(N + 5)
A.sort(reverse=True)
for i in range(N-1):
ans += A[i] * comb(N-1-i, K-1)
# min求める
A.sort()
for i in range(N-1):
ans -= A[i] * comb(N-1-i, K-1)
print((ans % MOD))
if __name__ == "__main__":
main() | 87 | 57 | 2,415 | 1,590 | from collections import defaultdict
class Combination:
"""
O(n)の前計算を1回行うことで，O(1)でnCr mod mを求められる
n_max = 10**6のとき前処理は約950ms (PyPyなら約340ms, 10**7で約1800ms)
使用例：
comb = Combination(1000000)
print(comb(5, 3)) # 10
"""
def __init__(self, n_max, mod=10**9 + 7):
self.mod = mod
self.modinv = self.make_modinv_list(n_max)
self.fac, self.facinv = self.make_factorial_list(n_max)
def __call__(self, n, r):
return self.fac[n] * self.facinv[r] % self.mod * self.facinv[n - r] % self.mod
def make_factorial_list(self, n):
# 階乗のリストと階乗のmod逆元のリストを返す O(n)
# self.make_modinv_list()が先に実行されている必要がある
fac = [1]
facinv = [1]
for i in range(1, n + 1):
fac.append(fac[i - 1] * i % self.mod)
facinv.append(facinv[i - 1] * self.modinv[i] % self.mod)
return fac, facinv
def make_modinv_list(self, n):
# 0からnまでのmod逆元のリストを返す O(n)
modinv = [0] * (n + 1)
modinv[1] = 1
for i in range(2, n + 1):
modinv[i] = self.mod - self.mod // i * modinv[self.mod % i] % self.mod
return modinv
def main():
# def cmb(n, r, mod):
# if ( r<0 or r>n ):
# return 0
# r = min(r, n-r)
# return g1[n] * g2[r] * g2[n-r] % mod
#
# mod = 10**9+7 #出力の制限
# N = 10**4
# g1 = [1, 1] # 元テーブル
# g2 = [1, 1] #逆元テーブル
# inverse = [0, 1] #逆元テーブル計算用テーブル
#
# for i in range( 2, N + 1 ):
# g1.append( ( g1[-1] * i ) % mod )
# inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )
# g2.append( (g2[-1] * inverse[-1]) % mod )
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
A.sort()
ans = 0
mod = 10**9 + 7
comb = Combination(1000000)
# 最小になる数を求める
for i, a in enumerate(A):
if (N - 1 - i) >= K - 1:
# tmp = cmb(N-1-i,K-1,mod)
tmp = comb(N - 1 - i, K - 1)
ans -= a * tmp
ans %= mod
else:
break
A.sort(reverse=True)
for i, a in enumerate(A):
if (N - 1 - i) >= K - 1:
# tmp = cmb(N-1-i,K-1,mod)
tmp = comb(N - 1 - i, K - 1)
ans += a * tmp
ans %= mod
else:
break
print(ans)
if __name__ == "__main__":
main()
| class Combination:
"""
O(n)の前計算を1回行うことで，O(1)でnCr mod mを求められる
n_max = 10**6のとき前処理は約950ms (PyPyなら約340ms, 10**7で約1800ms)
使用例：
comb = Combination(1000000)
print(comb(5, 3)) # 10
"""
def __init__(self, n_max, mod=10**9 + 7):
self.mod = mod
self.modinv = self.make_modinv_list(n_max)
self.fac, self.facinv = self.make_factorial_list(n_max)
def __call__(self, n, r):
if n < r:
return 0
return self.fac[n] * self.facinv[r] % self.mod * self.facinv[n - r] % self.mod
def make_factorial_list(self, n):
# 階乗のリストと階乗のmod逆元のリストを返す O(n)
# self.make_modinv_list()が先に実行されている必要がある
fac = [1]
facinv = [1]
for i in range(1, n + 1):
fac.append(fac[i - 1] * i % self.mod)
facinv.append(facinv[i - 1] * self.modinv[i] % self.mod)
return fac, facinv
def make_modinv_list(self, n):
# 0からnまでのmod逆元のリストを返す O(n)
modinv = [0] * (n + 1)
modinv[1] = 1
for i in range(2, n + 1):
modinv[i] = self.mod - self.mod // i * modinv[self.mod % i] % self.mod
return modinv
def main():
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
MOD = 10**9 + 7
ans = 0
comb = Combination(N + 5)
A.sort(reverse=True)
for i in range(N - 1):
ans += A[i] * comb(N - 1 - i, K - 1)
# min求める
A.sort()
for i in range(N - 1):
ans -= A[i] * comb(N - 1 - i, K - 1)
print((ans % MOD))
if __name__ == "__main__":
main()
| false | 34.482759 | [
"-from collections import defaultdict",
"-",
"-",
"+ if n < r:",
"+ return 0",
"- # def cmb(n, r, mod):",
"- # if ( r<0 or r>n ):",
"- # return 0",
"- # r = min(r, n-r)",
"- # return g1[n] * g2[r] * g2[n-r] % mod",
"- #",
"- # mod = 10**9+7 #出力の制限",
"- # N = 10**4",
"- # g1 = [1, 1] # 元テーブル",
"- # g2 = [1, 1] #逆元テーブル",
"- # inverse = [0, 1] #逆元テーブル計算用テーブル",
"- #",
"- # for i in range( 2, N + 1 ):",
"- # g1.append( ( g1[-1] * i ) % mod )",
"- # inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )",
"- # g2.append( (g2[-1] * inverse[-1]) % mod )",
"+ MOD = 10**9 + 7",
"+ ans = 0",
"+ comb = Combination(N + 5)",
"+ A.sort(reverse=True)",
"+ for i in range(N - 1):",
"+ ans += A[i] * comb(N - 1 - i, K - 1)",
"+ # min求める",
"- ans = 0",
"- mod = 10**9 + 7",
"- comb = Combination(1000000)",
"- # 最小になる数を求める",
"- for i, a in enumerate(A):",
"- if (N - 1 - i) >= K - 1:",
"- # tmp = cmb(N-1-i,K-1,mod)",
"- tmp = comb(N - 1 - i, K - 1)",
"- ans -= a * tmp",
"- ans %= mod",
"- else:",
"- break",
"- A.sort(reverse=True)",
"- for i, a in enumerate(A):",
"- if (N - 1 - i) >= K - 1:",
"- # tmp = cmb(N-1-i,K-1,mod)",
"- tmp = comb(N - 1 - i, K - 1)",
"- ans += a * tmp",
"- ans %= mod",
"- else:",
"- break",
"- print(ans)",
"+ for i in range(N - 1):",
"+ ans -= A[i] * comb(N - 1 - i, K - 1)",
"+ print((ans % MOD))"
] | false | 1.559977 | 0.041581 | 37.516827 | [
"s840153741",
"s704546411"
] |
u726615467 | p03325 | python | s289846648 | s079491169 | 92 | 79 | 4,148 | 4,148 | Accepted | Accepted | 14.13 | # encoding: utf-8
N = int(eval(input()))
a = list(map(int, input().split()))
ans = 0
for ai in a:
ai_tmp = ai
ans_tmp = 0
for i in range(32):
if ai_tmp % 2: break
else:
ans_tmp += 1
ai_tmp = ai_tmp // 2
ans += ans_tmp
print(ans) | N = int(eval(input()))
a = list(map(int, input().split()))
ans = 0
for i, ai in enumerate(a):
ai_tmp = ai
while ai_tmp % 2 == 0:
ans += 1
ai_tmp >>= 1
print(ans) | 16 | 11 | 295 | 191 | # encoding: utf-8
N = int(eval(input()))
a = list(map(int, input().split()))
ans = 0
for ai in a:
ai_tmp = ai
ans_tmp = 0
for i in range(32):
if ai_tmp % 2:
break
else:
ans_tmp += 1
ai_tmp = ai_tmp // 2
ans += ans_tmp
print(ans)
| N = int(eval(input()))
a = list(map(int, input().split()))
ans = 0
for i, ai in enumerate(a):
ai_tmp = ai
while ai_tmp % 2 == 0:
ans += 1
ai_tmp >>= 1
print(ans)
| false | 31.25 | [
"-# encoding: utf-8",
"-for ai in a:",
"+for i, ai in enumerate(a):",
"- ans_tmp = 0",
"- for i in range(32):",
"- if ai_tmp % 2:",
"- break",
"- else:",
"- ans_tmp += 1",
"- ai_tmp = ai_tmp // 2",
"- ans += ans_tmp",
"+ while ai_tmp % 2 == 0:",
"+ ans += 1",
"+ ai_tmp >>= 1"
] | false | 0.036482 | 0.038863 | 0.938737 | [
"s289846648",
"s079491169"
] |
u070423038 | p04045 | python | s109710417 | s839401567 | 29 | 26 | 9,108 | 9,168 | Accepted | Accepted | 10.34 | kingaku, n = input().split()
no_num = input().split()
result = []
ok_num = []
kuriage_num = [-1, 0]
def kuriage(l):
for i in ok_num:
if result[l] < i:
kuriage_num = [l, i]
return
if l <= 0:
return
return kuriage(l-1)
#使える数字のリストを作成
for i in range(10):
if not str(i) in no_num:
ok_num.append(str(i))
set_flg = False
for i in kingaku:
set_flg = True
for j in ok_num:
if i == j:
set_flg = False
result.append(j)
break
elif i < j:
result.append(j)
print(("".join(result).ljust(len(kingaku), ok_num[0])))
exit()
break
if set_flg:
n = 0
if ok_num[0] == '0':
n = 1
print((ok_num[n].ljust(len(kingaku)+1, ok_num[0])))
exit()
print((''.join(result)))
| kingaku, n = input().split()
no_num = input().split()
ok_num = []
result = []
for i in range(10):
if not str(i) in no_num:
ok_num.append(str(i))
set_flg = False
for i in kingaku:
set_flg = True
for j in ok_num:
if i == j:
set_flg = False
result.append(j)
break
elif i < j:
result.append(j)
print(("".join(result).ljust(len(kingaku), ok_num[0])))
exit()
break
if set_flg:
n = 0
if ok_num[0] == '0':
n = 1
print((ok_num[n].ljust(len(kingaku)+1, ok_num[0])))
exit()
print((''.join(result))) | 42 | 31 | 905 | 687 | kingaku, n = input().split()
no_num = input().split()
result = []
ok_num = []
kuriage_num = [-1, 0]
def kuriage(l):
for i in ok_num:
if result[l] < i:
kuriage_num = [l, i]
return
if l <= 0:
return
return kuriage(l - 1)
# 使える数字のリストを作成
for i in range(10):
if not str(i) in no_num:
ok_num.append(str(i))
set_flg = False
for i in kingaku:
set_flg = True
for j in ok_num:
if i == j:
set_flg = False
result.append(j)
break
elif i < j:
result.append(j)
print(("".join(result).ljust(len(kingaku), ok_num[0])))
exit()
break
if set_flg:
n = 0
if ok_num[0] == "0":
n = 1
print((ok_num[n].ljust(len(kingaku) + 1, ok_num[0])))
exit()
print(("".join(result)))
| kingaku, n = input().split()
no_num = input().split()
ok_num = []
result = []
for i in range(10):
if not str(i) in no_num:
ok_num.append(str(i))
set_flg = False
for i in kingaku:
set_flg = True
for j in ok_num:
if i == j:
set_flg = False
result.append(j)
break
elif i < j:
result.append(j)
print(("".join(result).ljust(len(kingaku), ok_num[0])))
exit()
break
if set_flg:
n = 0
if ok_num[0] == "0":
n = 1
print((ok_num[n].ljust(len(kingaku) + 1, ok_num[0])))
exit()
print(("".join(result)))
| false | 26.190476 | [
"+ok_num = []",
"-ok_num = []",
"-kuriage_num = [-1, 0]",
"-",
"-",
"-def kuriage(l):",
"- for i in ok_num:",
"- if result[l] < i:",
"- kuriage_num = [l, i]",
"- return",
"- if l <= 0:",
"- return",
"- return kuriage(l - 1)",
"-",
"-",
"-# 使える数字のリストを作成"
] | false | 0.044512 | 0.048772 | 0.912657 | [
"s109710417",
"s839401567"
] |
u131264627 | p02549 | python | s443888436 | s181534649 | 858 | 761 | 16,764 | 16,816 | Accepted | Accepted | 11.31 | n, k = list(map(int, input().split()))
lr = [list(map(int, input().split())) for _ in range(k)]
mod = 998244353
dp = [0] * n
dp[0] = 1
acc = 0
for i in range(1, n):
for l, r in lr:
if i - l >= 0:
acc += dp[i - l]
acc %= mod
if i - r - 1 >= 0:
acc -= dp[i - r - 1]
acc %= mod
dp[i] = acc
print((dp[-1]))
| n, k = list(map(int, input().split()))
lr = [list(map(int, input().split())) for _ in range(k)]
mod = 998244353
dp = [0] * n
dp[0] = 1
acc = 0
for i in range(1, n):
# 例4のi=13, lr=[[5, 8], [1, 3], [10, 15]]の場合を想像すると書きやすい
for li, ri in lr:
if i - li >= 0:
acc += dp[i - li]
acc %= mod
if i - ri - 1 >= 0:
acc -= dp[i - ri - 1]
acc %= mod
dp[i] = acc
print((dp[-1])) | 20 | 19 | 394 | 451 | n, k = list(map(int, input().split()))
lr = [list(map(int, input().split())) for _ in range(k)]
mod = 998244353
dp = [0] * n
dp[0] = 1
acc = 0
for i in range(1, n):
for l, r in lr:
if i - l >= 0:
acc += dp[i - l]
acc %= mod
if i - r - 1 >= 0:
acc -= dp[i - r - 1]
acc %= mod
dp[i] = acc
print((dp[-1]))
| n, k = list(map(int, input().split()))
lr = [list(map(int, input().split())) for _ in range(k)]
mod = 998244353
dp = [0] * n
dp[0] = 1
acc = 0
for i in range(1, n):
# 例4のi=13, lr=[[5, 8], [1, 3], [10, 15]]の場合を想像すると書きやすい
for li, ri in lr:
if i - li >= 0:
acc += dp[i - li]
acc %= mod
if i - ri - 1 >= 0:
acc -= dp[i - ri - 1]
acc %= mod
dp[i] = acc
print((dp[-1]))
| false | 5 | [
"- for l, r in lr:",
"- if i - l >= 0:",
"- acc += dp[i - l]",
"+ # 例4のi=13, lr=[[5, 8], [1, 3], [10, 15]]の場合を想像すると書きやすい",
"+ for li, ri in lr:",
"+ if i - li >= 0:",
"+ acc += dp[i - li]",
"- if i - r - 1 >= 0:",
"- acc -= dp[i - r - 1]",
"+ if i - ri - 1 >= 0:",
"+ acc -= dp[i - ri - 1]",
"- dp[i] = acc",
"+ dp[i] = acc"
] | false | 0.066829 | 0.038135 | 1.752407 | [
"s443888436",
"s181534649"
] |
u325149030 | p02695 | python | s612467429 | s527537027 | 999 | 587 | 9,164 | 9,168 | Accepted | Accepted | 41.24 | import sys
sys.setrecursionlimit(10**9)
N, M ,Q = list(map(int, input().split()))
abcd = [0 for _ in range(Q)]
for i in range(Q):
abcd[i] = list(map(int, input().split()))
ans = 0
def dfs(A):
global ans
if len(A) == N:
score = 0
for i in range(Q):
if A[abcd[i][1]-1] - A[abcd[i][0]-1] == abcd[i][2]:
score += abcd[i][3]
ans = max(ans, score)
else:
for i in range(A[-1], M+1):
dfs(A + [i])
for j in range(1, M+1):
dfs([j])
print(ans)
| import sys
sys.setrecursionlimit(10**9)
N, M ,Q = list(map(int, input().split()))
abcd = [list(map(int, input().split())) for _ in range(Q)]
ans = 0
def dfs(A):
global ans
if len(A) == N:
score = 0
for a,b,c,d in abcd:
if A[b-1] - A[a-1] == c:
score += d
ans = max(ans, score)
else:
for i in range(A[-1], M+1):
dfs(A + [i])
for j in range(1, M+1):
dfs([j])
print(ans)
| 24 | 21 | 549 | 476 | import sys
sys.setrecursionlimit(10**9)
N, M, Q = list(map(int, input().split()))
abcd = [0 for _ in range(Q)]
for i in range(Q):
abcd[i] = list(map(int, input().split()))
ans = 0
def dfs(A):
global ans
if len(A) == N:
score = 0
for i in range(Q):
if A[abcd[i][1] - 1] - A[abcd[i][0] - 1] == abcd[i][2]:
score += abcd[i][3]
ans = max(ans, score)
else:
for i in range(A[-1], M + 1):
dfs(A + [i])
for j in range(1, M + 1):
dfs([j])
print(ans)
| import sys
sys.setrecursionlimit(10**9)
N, M, Q = list(map(int, input().split()))
abcd = [list(map(int, input().split())) for _ in range(Q)]
ans = 0
def dfs(A):
global ans
if len(A) == N:
score = 0
for a, b, c, d in abcd:
if A[b - 1] - A[a - 1] == c:
score += d
ans = max(ans, score)
else:
for i in range(A[-1], M + 1):
dfs(A + [i])
for j in range(1, M + 1):
dfs([j])
print(ans)
| false | 12.5 | [
"-abcd = [0 for _ in range(Q)]",
"-for i in range(Q):",
"- abcd[i] = list(map(int, input().split()))",
"+abcd = [list(map(int, input().split())) for _ in range(Q)]",
"- for i in range(Q):",
"- if A[abcd[i][1] - 1] - A[abcd[i][0] - 1] == abcd[i][2]:",
"- score += abcd[i][3]",
"+ for a, b, c, d in abcd:",
"+ if A[b - 1] - A[a - 1] == c:",
"+ score += d"
] | false | 0.07341 | 0.125441 | 0.585216 | [
"s612467429",
"s527537027"
] |
u988402778 | p03326 | python | s024231243 | s777237813 | 34 | 26 | 3,444 | 3,328 | Accepted | Accepted | 23.53 | import itertools
import heapq
n,m = [int(i) for i in input().split()]
a = [[int(i) for i in input().split()] for j in range(n)]
ans = 0
c = [0,1]
for l,j,k in itertools.product(c,repeat=3):
ans = max(ans,sum(heapq.nlargest(m,([a[i][0]*(-1)**l+a[i][1]*(-1)**j+a[i][2]*(-1)**k for i in range(n)]))))
print(ans) | from itertools import product as p
n,m = [int(i) for i in input().split()]
a = [[int(i) for i in input().split()] for j in range(n)]
c = [1,-1]
ans = 0
for l,j,k in p(c,repeat=3):
ans = max(ans,sum(sorted([a[i][0]*l+a[i][1]*j+a[i][2]*k for i in range(n)])[n-m:]))
print(ans) | 9 | 8 | 320 | 286 | import itertools
import heapq
n, m = [int(i) for i in input().split()]
a = [[int(i) for i in input().split()] for j in range(n)]
ans = 0
c = [0, 1]
for l, j, k in itertools.product(c, repeat=3):
ans = max(
ans,
sum(
heapq.nlargest(
m,
(
[
a[i][0] * (-1) ** l + a[i][1] * (-1) ** j + a[i][2] * (-1) ** k
for i in range(n)
]
),
)
),
)
print(ans)
| from itertools import product as p
n, m = [int(i) for i in input().split()]
a = [[int(i) for i in input().split()] for j in range(n)]
c = [1, -1]
ans = 0
for l, j, k in p(c, repeat=3):
ans = max(
ans,
sum(
sorted([a[i][0] * l + a[i][1] * j + a[i][2] * k for i in range(n)])[n - m :]
),
)
print(ans)
| false | 11.111111 | [
"-import itertools",
"-import heapq",
"+from itertools import product as p",
"+c = [1, -1]",
"-c = [0, 1]",
"-for l, j, k in itertools.product(c, repeat=3):",
"+for l, j, k in p(c, repeat=3):",
"- heapq.nlargest(",
"- m,",
"- (",
"- [",
"- a[i][0] * (-1) ** l + a[i][1] * (-1) ** j + a[i][2] * (-1) ** k",
"- for i in range(n)",
"- ]",
"- ),",
"- )",
"+ sorted([a[i][0] * l + a[i][1] * j + a[i][2] * k for i in range(n)])[n - m :]"
] | false | 0.107667 | 0.036146 | 2.978671 | [
"s024231243",
"s777237813"
] |
u353919145 | p02773 | python | s646898780 | s270694900 | 893 | 542 | 46,468 | 35,276 | Accepted | Accepted | 39.31 |
n = int (eval(input ()))
s = []
ha = {}
for i in range (n) :
s.append (eval(input ()))
if (s[i] not in list(ha.keys())) :
ha[s[i]] = 1
else :
ha[s[i]] += 1
ans = sorted (list(ha.items()), key=lambda x : x[1], reverse=True)
k = ans[0][1]
i = 0
while (i < len (ans) and ans[i][1] == k) :
i += 1
ans = ans[ : i]
ans.sort()
for ss in ans :
print((ss[0]))
| N = int(eval(input()))
dict = {}
strings = []
for i in range(N):
x = eval(input())
if x in list(dict.keys()):
dict[x] += 1
else:
dict[x] = 1
maximum = 1
for i in dict:
maximum = max(maximum,dict[i])
for word in dict:
if dict[word] == maximum:
strings.append(word)
strings.sort()
for word in strings:
print(word) | 23 | 21 | 389 | 367 | n = int(eval(input()))
s = []
ha = {}
for i in range(n):
s.append(eval(input()))
if s[i] not in list(ha.keys()):
ha[s[i]] = 1
else:
ha[s[i]] += 1
ans = sorted(list(ha.items()), key=lambda x: x[1], reverse=True)
k = ans[0][1]
i = 0
while i < len(ans) and ans[i][1] == k:
i += 1
ans = ans[:i]
ans.sort()
for ss in ans:
print((ss[0]))
| N = int(eval(input()))
dict = {}
strings = []
for i in range(N):
x = eval(input())
if x in list(dict.keys()):
dict[x] += 1
else:
dict[x] = 1
maximum = 1
for i in dict:
maximum = max(maximum, dict[i])
for word in dict:
if dict[word] == maximum:
strings.append(word)
strings.sort()
for word in strings:
print(word)
| false | 8.695652 | [
"-n = int(eval(input()))",
"-s = []",
"-ha = {}",
"-for i in range(n):",
"- s.append(eval(input()))",
"- if s[i] not in list(ha.keys()):",
"- ha[s[i]] = 1",
"+N = int(eval(input()))",
"+dict = {}",
"+strings = []",
"+for i in range(N):",
"+ x = eval(input())",
"+ if x in list(dict.keys()):",
"+ dict[x] += 1",
"- ha[s[i]] += 1",
"-ans = sorted(list(ha.items()), key=lambda x: x[1], reverse=True)",
"-k = ans[0][1]",
"-i = 0",
"-while i < len(ans) and ans[i][1] == k:",
"- i += 1",
"-ans = ans[:i]",
"-ans.sort()",
"-for ss in ans:",
"- print((ss[0]))",
"+ dict[x] = 1",
"+maximum = 1",
"+for i in dict:",
"+ maximum = max(maximum, dict[i])",
"+for word in dict:",
"+ if dict[word] == maximum:",
"+ strings.append(word)",
"+strings.sort()",
"+for word in strings:",
"+ print(word)"
] | false | 0.04377 | 0.042164 | 1.038091 | [
"s646898780",
"s270694900"
] |
u270681687 | p03241 | python | s971200302 | s933814387 | 25 | 22 | 3,060 | 3,188 | Accepted | Accepted | 12 | n, m = list(map(int, input().split()))
num = []
i = 1
while i * i <= m:
if m % i == 0:
num.append(i)
if m // i != i:
num.append(m//i)
i += 1
ans = 0
for i in num:
if i <= m // n:
ans = max(ans, i)
print(ans) | import math
n, m = list(map(int, input().split()))
div = []
sqrt_m = int(math.sqrt(m))
for i in range(1, sqrt_m + 1):
if m % i == 0:
div.append(i)
div.append(m // i)
div.sort(reverse=True)
for i in div:
if m >= i * n and (m - i * n) % i == 0:
print(i)
exit() | 17 | 15 | 268 | 308 | n, m = list(map(int, input().split()))
num = []
i = 1
while i * i <= m:
if m % i == 0:
num.append(i)
if m // i != i:
num.append(m // i)
i += 1
ans = 0
for i in num:
if i <= m // n:
ans = max(ans, i)
print(ans)
| import math
n, m = list(map(int, input().split()))
div = []
sqrt_m = int(math.sqrt(m))
for i in range(1, sqrt_m + 1):
if m % i == 0:
div.append(i)
div.append(m // i)
div.sort(reverse=True)
for i in div:
if m >= i * n and (m - i * n) % i == 0:
print(i)
exit()
| false | 11.764706 | [
"+import math",
"+",
"-num = []",
"-i = 1",
"-while i * i <= m:",
"+div = []",
"+sqrt_m = int(math.sqrt(m))",
"+for i in range(1, sqrt_m + 1):",
"- num.append(i)",
"- if m // i != i:",
"- num.append(m // i)",
"- i += 1",
"-ans = 0",
"-for i in num:",
"- if i <= m // n:",
"- ans = max(ans, i)",
"-print(ans)",
"+ div.append(i)",
"+ div.append(m // i)",
"+div.sort(reverse=True)",
"+for i in div:",
"+ if m >= i * n and (m - i * n) % i == 0:",
"+ print(i)",
"+ exit()"
] | false | 0.056143 | 0.052466 | 1.070072 | [
"s971200302",
"s933814387"
] |
u636290142 | p02659 | python | s735028718 | s095054804 | 24 | 22 | 9,096 | 9,032 | Accepted | Accepted | 8.33 | a, b = list(map(float, input().split()))
a = int(a)
b = int(b * 1000)
print((a*b//1000))
| a, b = list(map(float, input().split()))
a = int(a)
b = int(b * 100 + 0.5)
print((a*b//100))
| 5 | 5 | 86 | 90 | a, b = list(map(float, input().split()))
a = int(a)
b = int(b * 1000)
print((a * b // 1000))
| a, b = list(map(float, input().split()))
a = int(a)
b = int(b * 100 + 0.5)
print((a * b // 100))
| false | 0 | [
"-b = int(b * 1000)",
"-print((a * b // 1000))",
"+b = int(b * 100 + 0.5)",
"+print((a * b // 100))"
] | false | 0.043738 | 0.046265 | 0.945389 | [
"s735028718",
"s095054804"
] |
u768559443 | p03658 | python | s243156349 | s915952565 | 20 | 18 | 3,064 | 2,940 | Accepted | Accepted | 10 | n,k=list(map(int,input().split()))
print((sum(sorted(map(int,input().split()))[-k:]))) | n,k=list(map(int,input().split()))
l=sorted(map(int,input().split()))[::-1]
print((sum(l[:k])))
| 2 | 3 | 79 | 90 | n, k = list(map(int, input().split()))
print((sum(sorted(map(int, input().split()))[-k:])))
| n, k = list(map(int, input().split()))
l = sorted(map(int, input().split()))[::-1]
print((sum(l[:k])))
| false | 33.333333 | [
"-print((sum(sorted(map(int, input().split()))[-k:])))",
"+l = sorted(map(int, input().split()))[::-1]",
"+print((sum(l[:k])))"
] | false | 0.042124 | 0.132391 | 0.318178 | [
"s243156349",
"s915952565"
] |
u683134447 | p03076 | python | s101529074 | s756196173 | 179 | 17 | 38,384 | 2,940 | Accepted | Accepted | 90.5 | import math
al = []
for _ in range(5):
al.append(int(eval(input())))
tmp = 11
log = -1
for idx,a in enumerate(al):
point = a % 10
if point == 0:
point = 10
if tmp > point:
tmp = point
log = idx
ans = 0
for idx, a in enumerate(al):
if idx != log:
ans += math.ceil(a / 10) * 10
else:
ans += a
print(ans) | ans = 0
def ceil(a, b):
return a // b + (a % b > 0)
big = 0
for _ in range(5):
a = int(eval(input()))
ans += ceil(a, 10) * 10
if a % 10 != 0:
big = max(big, 10-(a%10))
print((ans-big))
| 25 | 13 | 397 | 215 | import math
al = []
for _ in range(5):
al.append(int(eval(input())))
tmp = 11
log = -1
for idx, a in enumerate(al):
point = a % 10
if point == 0:
point = 10
if tmp > point:
tmp = point
log = idx
ans = 0
for idx, a in enumerate(al):
if idx != log:
ans += math.ceil(a / 10) * 10
else:
ans += a
print(ans)
| ans = 0
def ceil(a, b):
return a // b + (a % b > 0)
big = 0
for _ in range(5):
a = int(eval(input()))
ans += ceil(a, 10) * 10
if a % 10 != 0:
big = max(big, 10 - (a % 10))
print((ans - big))
| false | 48 | [
"-import math",
"+ans = 0",
"-al = []",
"+",
"+def ceil(a, b):",
"+ return a // b + (a % b > 0)",
"+",
"+",
"+big = 0",
"- al.append(int(eval(input())))",
"-tmp = 11",
"-log = -1",
"-for idx, a in enumerate(al):",
"- point = a % 10",
"- if point == 0:",
"- point = 10",
"- if tmp > point:",
"- tmp = point",
"- log = idx",
"-ans = 0",
"-for idx, a in enumerate(al):",
"- if idx != log:",
"- ans += math.ceil(a / 10) * 10",
"- else:",
"- ans += a",
"-print(ans)",
"+ a = int(eval(input()))",
"+ ans += ceil(a, 10) * 10",
"+ if a % 10 != 0:",
"+ big = max(big, 10 - (a % 10))",
"+print((ans - big))"
] | false | 0.042034 | 0.036838 | 1.141065 | [
"s101529074",
"s756196173"
] |
u699296734 | p02756 | python | s618316636 | s960750672 | 1,342 | 1,098 | 4,576 | 4,520 | Accepted | Accepted | 18.18 | def main():
moji=eval(input())
cycle=int(eval(input()))
flont_or_back=0
flont=""
back=""
for i in range(cycle):
line=eval(input())
if line[0]=="1":
flont_or_back+=1
else:
fi=line[2]
ci=line[4]
if flont_or_back%2==0:
if fi=="1":
flont=ci+flont
else:
back+=ci
else:
if fi=="1":
back+=ci
else:
flont=ci+flont
moji=flont+moji+back
if flont_or_back%2==0:
print(moji)
else:
print((moji[::-1]))
if __name__ == '__main__':
main()
| import sys
input = lambda: sys.stdin.readline().rstrip()
def main():
moji=eval(input())
cycle=int(eval(input()))
flont_or_back=0
flont=""
back=""
for i in range(cycle):
line=eval(input())
if line[0]=="1":
flont_or_back+=1
else:
fi=line[2]
ci=line[4]
if flont_or_back%2==0:
if fi=="1":
flont=ci+flont
else:
back+=ci
else:
if fi=="1":
back+=ci
else:
flont=ci+flont
moji=flont+moji+back
if flont_or_back%2==0:
print(moji)
else:
print((moji[::-1]))
if __name__ == '__main__':
main()
| 33 | 35 | 727 | 788 | def main():
moji = eval(input())
cycle = int(eval(input()))
flont_or_back = 0
flont = ""
back = ""
for i in range(cycle):
line = eval(input())
if line[0] == "1":
flont_or_back += 1
else:
fi = line[2]
ci = line[4]
if flont_or_back % 2 == 0:
if fi == "1":
flont = ci + flont
else:
back += ci
else:
if fi == "1":
back += ci
else:
flont = ci + flont
moji = flont + moji + back
if flont_or_back % 2 == 0:
print(moji)
else:
print((moji[::-1]))
if __name__ == "__main__":
main()
| import sys
input = lambda: sys.stdin.readline().rstrip()
def main():
moji = eval(input())
cycle = int(eval(input()))
flont_or_back = 0
flont = ""
back = ""
for i in range(cycle):
line = eval(input())
if line[0] == "1":
flont_or_back += 1
else:
fi = line[2]
ci = line[4]
if flont_or_back % 2 == 0:
if fi == "1":
flont = ci + flont
else:
back += ci
else:
if fi == "1":
back += ci
else:
flont = ci + flont
moji = flont + moji + back
if flont_or_back % 2 == 0:
print(moji)
else:
print((moji[::-1]))
if __name__ == "__main__":
main()
| false | 5.714286 | [
"+import sys",
"+",
"+input = lambda: sys.stdin.readline().rstrip()",
"+",
"+"
] | false | 0.008101 | 0.035369 | 0.229049 | [
"s618316636",
"s960750672"
] |
u864197622 | p02788 | python | s945649989 | s684914501 | 1,581 | 1,004 | 74,200 | 68,572 | Accepted | Accepted | 36.5 | from collections import deque
N, D, A = list(map(int, input().split()))
X = []
for _ in range(N):
x, h = list(map(int, input().split()))
X.append((x, h))
X = sorted(X)[::-1]
Q = deque([])
ans = 0
k = 0
while X:
if len(Q) == 0 or X[-1][0] <= Q[0][0]:
x, h = X.pop()
h = max(h - k * A, 0)
a = (h + A - 1) // A
ans += a
k += a
deque.append(Q, (x + 2 * D, a))
else:
x, a = deque.popleft(Q)
k -= a
print(ans) | import sys
input = sys.stdin.readline
from collections import deque
N, D, A = list(map(int, input().split()))
X = []
for _ in range(N):
x, h = list(map(int, input().split()))
X.append((x, h))
X = sorted(X)[::-1]
Q = deque([])
ans = 0
k = 0
while X:
if len(Q) == 0 or X[-1][0] <= Q[0][0]:
x, h = X.pop()
h = max(h - k * A, 0)
a = (h + A - 1) // A
ans += a
k += a
deque.append(Q, (x + 2 * D, a))
else:
x, a = deque.popleft(Q)
k -= a
print(ans) | 25 | 27 | 498 | 538 | from collections import deque
N, D, A = list(map(int, input().split()))
X = []
for _ in range(N):
x, h = list(map(int, input().split()))
X.append((x, h))
X = sorted(X)[::-1]
Q = deque([])
ans = 0
k = 0
while X:
if len(Q) == 0 or X[-1][0] <= Q[0][0]:
x, h = X.pop()
h = max(h - k * A, 0)
a = (h + A - 1) // A
ans += a
k += a
deque.append(Q, (x + 2 * D, a))
else:
x, a = deque.popleft(Q)
k -= a
print(ans)
| import sys
input = sys.stdin.readline
from collections import deque
N, D, A = list(map(int, input().split()))
X = []
for _ in range(N):
x, h = list(map(int, input().split()))
X.append((x, h))
X = sorted(X)[::-1]
Q = deque([])
ans = 0
k = 0
while X:
if len(Q) == 0 or X[-1][0] <= Q[0][0]:
x, h = X.pop()
h = max(h - k * A, 0)
a = (h + A - 1) // A
ans += a
k += a
deque.append(Q, (x + 2 * D, a))
else:
x, a = deque.popleft(Q)
k -= a
print(ans)
| false | 7.407407 | [
"+import sys",
"+",
"+input = sys.stdin.readline"
] | false | 0.046732 | 0.046514 | 1.0047 | [
"s945649989",
"s684914501"
] |
u606045429 | p03497 | python | s782526639 | s143419895 | 183 | 169 | 39,292 | 41,500 | Accepted | Accepted | 7.65 | from collections import Counter
N, K = [int(i) for i in input().split()]
A = [int(i) for i in input().split()]
print((sum(v for _, v in Counter(A).most_common()[K:])))
| from collections import *
N,K=list(map(int,input().split()))
print((sum(v for _,v in Counter(list(map(int,input().split()))).most_common()[K:]))) | 6 | 3 | 173 | 133 | from collections import Counter
N, K = [int(i) for i in input().split()]
A = [int(i) for i in input().split()]
print((sum(v for _, v in Counter(A).most_common()[K:])))
| from collections import *
N, K = list(map(int, input().split()))
print((sum(v for _, v in Counter(list(map(int, input().split()))).most_common()[K:])))
| false | 50 | [
"-from collections import Counter",
"+from collections import *",
"-N, K = [int(i) for i in input().split()]",
"-A = [int(i) for i in input().split()]",
"-print((sum(v for _, v in Counter(A).most_common()[K:])))",
"+N, K = list(map(int, input().split()))",
"+print((sum(v for _, v in Counter(list(map(int, input().split()))).most_common()[K:])))"
] | false | 0.042887 | 0.041893 | 1.023717 | [
"s782526639",
"s143419895"
] |
u150984829 | p02315 | python | s301097388 | s361416291 | 1,180 | 1,070 | 33,188 | 25,516 | Accepted | Accepted | 9.32 | N,W=list(map(int,input().split()))
I=[[*list(map(int,input().split()))]for _ in[0]*N]
I=[0]+I
C=[[0]*-~W for _ in[0]*-~N]
G=[[0]*-~W for _ in[0]*-~N]
for i in range(1,N+1):
for w in range(1,W+1):
C[i][w]=C[i-1][w]
if I[i][1]>w:continue
if I[i][0]+C[i-1][w-I[i][1]]>C[i-1][w]:
C[i][w]=I[i][0]+C[i-1][w-I[i][1]]
G[i][w]=1
m=C[N][W]
w=W
D=[]
for i in range(N,0,-1):
if G[i][w]:
D+=[i]
w-=I[i][1]
print((C[N][W]))
| N,W=list(map(int,input().split()))
I=[0]+[[*list(map(int,input().split()))]for _ in[0]*N]
C=[[0]*-~W for _ in[0]*-~N]
for i in range(1,N+1):
for w in range(1,W+1):
C[i][w]=C[i-1][w]
if I[i][1]>w:continue
if I[i][0]+C[i-1][w-I[i][1]]>C[i-1][w]:
C[i][w]=I[i][0]+C[i-1][w-I[i][1]]
print((C[N][W]))
| 20 | 10 | 433 | 300 | N, W = list(map(int, input().split()))
I = [[*list(map(int, input().split()))] for _ in [0] * N]
I = [0] + I
C = [[0] * -~W for _ in [0] * -~N]
G = [[0] * -~W for _ in [0] * -~N]
for i in range(1, N + 1):
for w in range(1, W + 1):
C[i][w] = C[i - 1][w]
if I[i][1] > w:
continue
if I[i][0] + C[i - 1][w - I[i][1]] > C[i - 1][w]:
C[i][w] = I[i][0] + C[i - 1][w - I[i][1]]
G[i][w] = 1
m = C[N][W]
w = W
D = []
for i in range(N, 0, -1):
if G[i][w]:
D += [i]
w -= I[i][1]
print((C[N][W]))
| N, W = list(map(int, input().split()))
I = [0] + [[*list(map(int, input().split()))] for _ in [0] * N]
C = [[0] * -~W for _ in [0] * -~N]
for i in range(1, N + 1):
for w in range(1, W + 1):
C[i][w] = C[i - 1][w]
if I[i][1] > w:
continue
if I[i][0] + C[i - 1][w - I[i][1]] > C[i - 1][w]:
C[i][w] = I[i][0] + C[i - 1][w - I[i][1]]
print((C[N][W]))
| false | 50 | [
"-I = [[*list(map(int, input().split()))] for _ in [0] * N]",
"-I = [0] + I",
"+I = [0] + [[*list(map(int, input().split()))] for _ in [0] * N]",
"-G = [[0] * -~W for _ in [0] * -~N]",
"- G[i][w] = 1",
"-m = C[N][W]",
"-w = W",
"-D = []",
"-for i in range(N, 0, -1):",
"- if G[i][w]:",
"- D += [i]",
"- w -= I[i][1]"
] | false | 0.044653 | 0.041981 | 1.063669 | [
"s301097388",
"s361416291"
] |
u844005364 | p03164 | python | s538973492 | s512189221 | 830 | 725 | 5,740 | 5,428 | Accepted | Accepted | 12.65 | import sys
input = sys.stdin.readline
N, W = [int(i) for i in input().split()]
def ans(N, W):
d = [float("inf")] * (N * 1000 + 1)
d[0] = 0
V = 0
for i in range(N):
wi, vi = [int(i) for i in input().split()]
V = V + vi
for v in range(V, vi-1, -1):
w_ = d[v - vi] + wi
if w_ < d[v]:
d[v] = w_
for v in range(V, -1, -1):
if d[v] <= W:
return v
print((ans(N, W))) | import sys
input = sys.stdin.readline
N, W = [int(i) for i in input().split()]
def ans(N, W):
d = [W+1] * (N * 1000 + 1)
d[0] = 0
V = 0
for i in range(N):
wi, vi = [int(i) for i in input().split()]
V = V + vi
for v in range(V, vi-1, -1):
w_ = d[v - vi] + wi
if w_ < d[v]:
d[v] = w_
for v in range(V, -1, -1):
if d[v] <= W:
return v
print((ans(N, W))) | 24 | 24 | 490 | 481 | import sys
input = sys.stdin.readline
N, W = [int(i) for i in input().split()]
def ans(N, W):
d = [float("inf")] * (N * 1000 + 1)
d[0] = 0
V = 0
for i in range(N):
wi, vi = [int(i) for i in input().split()]
V = V + vi
for v in range(V, vi - 1, -1):
w_ = d[v - vi] + wi
if w_ < d[v]:
d[v] = w_
for v in range(V, -1, -1):
if d[v] <= W:
return v
print((ans(N, W)))
| import sys
input = sys.stdin.readline
N, W = [int(i) for i in input().split()]
def ans(N, W):
d = [W + 1] * (N * 1000 + 1)
d[0] = 0
V = 0
for i in range(N):
wi, vi = [int(i) for i in input().split()]
V = V + vi
for v in range(V, vi - 1, -1):
w_ = d[v - vi] + wi
if w_ < d[v]:
d[v] = w_
for v in range(V, -1, -1):
if d[v] <= W:
return v
print((ans(N, W)))
| false | 0 | [
"- d = [float(\"inf\")] * (N * 1000 + 1)",
"+ d = [W + 1] * (N * 1000 + 1)"
] | false | 0.03909 | 0.04077 | 0.958796 | [
"s538973492",
"s512189221"
] |
u327466606 | p03333 | python | s029414270 | s939008671 | 501 | 386 | 21,648 | 13,352 | Accepted | Accepted | 22.95 | N = int(eval(input()))
intervals = tuple(tuple(map(int,input().split())) for _ in range(N))
L = sorted((l for l,r in intervals))
R = sorted((r for l,r in intervals), reverse=True)
def helper(L,R,turn):
x = 0
cost = 0
T = [L,None,R]
while True:
y = T[turn+1].pop()
if turn*(y-x) < 0:
cost += abs(x-y)
x = y
else:
break
turn *= -1
cost += abs(x)
return cost
print((max(helper(L.copy(), R.copy(), t) for t in (-1,1)))) | N = int(eval(input()))
L,R = [None]*N,[None]*N
for i in range(N):
L[i],R[i] = list(map(int,input().split()))
L.append(0)
R.append(0)
L.sort(reverse=True)
R.sort()
def it():
for l,r in zip(L,R):
if r < l:
yield 2*(l-r)
else:
return
print((sum(it()))) | 24 | 17 | 485 | 277 | N = int(eval(input()))
intervals = tuple(tuple(map(int, input().split())) for _ in range(N))
L = sorted((l for l, r in intervals))
R = sorted((r for l, r in intervals), reverse=True)
def helper(L, R, turn):
x = 0
cost = 0
T = [L, None, R]
while True:
y = T[turn + 1].pop()
if turn * (y - x) < 0:
cost += abs(x - y)
x = y
else:
break
turn *= -1
cost += abs(x)
return cost
print((max(helper(L.copy(), R.copy(), t) for t in (-1, 1))))
| N = int(eval(input()))
L, R = [None] * N, [None] * N
for i in range(N):
L[i], R[i] = list(map(int, input().split()))
L.append(0)
R.append(0)
L.sort(reverse=True)
R.sort()
def it():
for l, r in zip(L, R):
if r < l:
yield 2 * (l - r)
else:
return
print((sum(it())))
| false | 29.166667 | [
"-intervals = tuple(tuple(map(int, input().split())) for _ in range(N))",
"-L = sorted((l for l, r in intervals))",
"-R = sorted((r for l, r in intervals), reverse=True)",
"+L, R = [None] * N, [None] * N",
"+for i in range(N):",
"+ L[i], R[i] = list(map(int, input().split()))",
"+L.append(0)",
"+R.append(0)",
"+L.sort(reverse=True)",
"+R.sort()",
"-def helper(L, R, turn):",
"- x = 0",
"- cost = 0",
"- T = [L, None, R]",
"- while True:",
"- y = T[turn + 1].pop()",
"- if turn * (y - x) < 0:",
"- cost += abs(x - y)",
"- x = y",
"+def it():",
"+ for l, r in zip(L, R):",
"+ if r < l:",
"+ yield 2 * (l - r)",
"- break",
"- turn *= -1",
"- cost += abs(x)",
"- return cost",
"+ return",
"-print((max(helper(L.copy(), R.copy(), t) for t in (-1, 1))))",
"+print((sum(it())))"
] | false | 0.040555 | 0.042305 | 0.958641 | [
"s029414270",
"s939008671"
] |
u950708010 | p03030 | python | s969755210 | s344133359 | 92 | 17 | 3,064 | 3,060 | Accepted | Accepted | 81.52 | def solve():
n = int(eval(input()))
query = []
for i in range(n):
tmp = eval(input())
s,p = tmp.split()
query.append((s,p,i+1))
query.sort()
count = 0
while count<n/2:
count += 1
for i in range(n):
for j in range(i+1,n):
if query[i][0] == query[j][0]:
if int(query[i][1]) <int(query[j][1]):
buf = query[i]
query[i] = query[j]
query[j] = buf
for i in range(n):
print((query[i][2]))
solve() | def solve():
n = int(eval(input()))
query = []
for i in range(n):
tmp = eval(input())
s,p = tmp.split()
p = str(90000000-int(p))
s = s+p
query.append((s,i+1))
query.sort()
for i in range(n):
print((query[i][1]))
solve() | 23 | 15 | 512 | 271 | def solve():
n = int(eval(input()))
query = []
for i in range(n):
tmp = eval(input())
s, p = tmp.split()
query.append((s, p, i + 1))
query.sort()
count = 0
while count < n / 2:
count += 1
for i in range(n):
for j in range(i + 1, n):
if query[i][0] == query[j][0]:
if int(query[i][1]) < int(query[j][1]):
buf = query[i]
query[i] = query[j]
query[j] = buf
for i in range(n):
print((query[i][2]))
solve()
| def solve():
n = int(eval(input()))
query = []
for i in range(n):
tmp = eval(input())
s, p = tmp.split()
p = str(90000000 - int(p))
s = s + p
query.append((s, i + 1))
query.sort()
for i in range(n):
print((query[i][1]))
solve()
| false | 34.782609 | [
"- query.append((s, p, i + 1))",
"+ p = str(90000000 - int(p))",
"+ s = s + p",
"+ query.append((s, i + 1))",
"- count = 0",
"- while count < n / 2:",
"- count += 1",
"- for i in range(n):",
"- for j in range(i + 1, n):",
"- if query[i][0] == query[j][0]:",
"- if int(query[i][1]) < int(query[j][1]):",
"- buf = query[i]",
"- query[i] = query[j]",
"- query[j] = buf",
"- print((query[i][2]))",
"+ print((query[i][1]))"
] | false | 0.076656 | 0.082039 | 0.934384 | [
"s969755210",
"s344133359"
] |
u769698512 | p03476 | python | s402941886 | s845251967 | 1,979 | 1,170 | 17,448 | 16,756 | Accepted | Accepted | 40.88 | import numpy as np
q = int(eval(input()))
# 高速素数判定
is_prime = np.ones(100001, dtype=int)
is_prime[0]=0
is_prime[1]=0
for i in range(2,100001):
if is_prime[i]==1:
j=i+i
while j <= 100000:
is_prime[j] = 0
j += i
like2017 = [is_prime[x]*is_prime[(x+1)//2] for x in range(0,100001)]
for i in range(1,100001):
like2017[i] += like2017[i-1]
for i in range(q):
l,r = list(map(int, input().split()))
print((like2017[r]-like2017[l-1]))
| import numpy as np
q = int(eval(input()))
# 高速素数判定
is_prime = np.ones(100001, dtype=int)
is_prime[0]=0
is_prime[1]=0
for i in range(2,100001):
if is_prime[i]==1:
j=i+i
while j <= 100000:
is_prime[j] = 0
j += i
like2017 = [1 if is_prime[i] and is_prime[(i+1)//2] else 0 for i in range(0,100001) ]
for i in range(1,100001):
like2017[i] += like2017[i-1]
for i in range(q):
l,r = list(map(int, input().split()))
print((like2017[r]-like2017[l-1]))
| 23 | 23 | 495 | 512 | import numpy as np
q = int(eval(input()))
# 高速素数判定
is_prime = np.ones(100001, dtype=int)
is_prime[0] = 0
is_prime[1] = 0
for i in range(2, 100001):
if is_prime[i] == 1:
j = i + i
while j <= 100000:
is_prime[j] = 0
j += i
like2017 = [is_prime[x] * is_prime[(x + 1) // 2] for x in range(0, 100001)]
for i in range(1, 100001):
like2017[i] += like2017[i - 1]
for i in range(q):
l, r = list(map(int, input().split()))
print((like2017[r] - like2017[l - 1]))
| import numpy as np
q = int(eval(input()))
# 高速素数判定
is_prime = np.ones(100001, dtype=int)
is_prime[0] = 0
is_prime[1] = 0
for i in range(2, 100001):
if is_prime[i] == 1:
j = i + i
while j <= 100000:
is_prime[j] = 0
j += i
like2017 = [
1 if is_prime[i] and is_prime[(i + 1) // 2] else 0 for i in range(0, 100001)
]
for i in range(1, 100001):
like2017[i] += like2017[i - 1]
for i in range(q):
l, r = list(map(int, input().split()))
print((like2017[r] - like2017[l - 1]))
| false | 0 | [
"-like2017 = [is_prime[x] * is_prime[(x + 1) // 2] for x in range(0, 100001)]",
"+like2017 = [",
"+ 1 if is_prime[i] and is_prime[(i + 1) // 2] else 0 for i in range(0, 100001)",
"+]"
] | false | 0.627416 | 0.415344 | 1.510593 | [
"s402941886",
"s845251967"
] |
u796942881 | p03240 | python | s094446854 | s852267401 | 101 | 26 | 3,064 | 3,064 | Accepted | Accepted | 74.26 | N = int(eval(input()))
xn = []
yn = []
hn = []
for i in range(N):
xi, yi, hi = list(map(int, input().split()))
xn.append(xi)
yn.append(yi)
hn.append(hi)
for Cx in range(101):
for Cy in range(101):
flg = True
for i in range(N):
if 0 == hn[i]:
continue
h = abs(xn[i] - Cx) + abs(yn[i] - Cy) + hn[i]
if flg:
H = h
flg = False
else:
if (H != h):
flg = True
break
if flg:
continue
for i in range(N):
if 0 == hn[i]:
h = abs(xn[i] - Cx) + abs(yn[i] - Cy)
if h < H:
flg = True
break
if flg:
continue
print((Cx, Cy, H))
break
if not flg:
break
| def main():
N = int(eval(input()))
xn = []
yn = []
hn = []
for i in range(N):
xi, yi, hi = list(map(int, input().split()))
if hi:
xn.append(xi)
yn.append(yi)
hn.append(hi)
if len(xn) == 1:
print((xn[0], yn[0], hn[0]))
return
for Cx in range(101):
for Cy in range(101):
last = None
for i in range(len(xn)):
H = abs(xn[i] - Cx) + abs(yn[i] - Cy) + hn[i]
if H < 0:
continue
if last:
if (last != H):
break
last = H
else:
print((Cx, Cy, H))
return
main()
| 49 | 39 | 929 | 782 | N = int(eval(input()))
xn = []
yn = []
hn = []
for i in range(N):
xi, yi, hi = list(map(int, input().split()))
xn.append(xi)
yn.append(yi)
hn.append(hi)
for Cx in range(101):
for Cy in range(101):
flg = True
for i in range(N):
if 0 == hn[i]:
continue
h = abs(xn[i] - Cx) + abs(yn[i] - Cy) + hn[i]
if flg:
H = h
flg = False
else:
if H != h:
flg = True
break
if flg:
continue
for i in range(N):
if 0 == hn[i]:
h = abs(xn[i] - Cx) + abs(yn[i] - Cy)
if h < H:
flg = True
break
if flg:
continue
print((Cx, Cy, H))
break
if not flg:
break
| def main():
N = int(eval(input()))
xn = []
yn = []
hn = []
for i in range(N):
xi, yi, hi = list(map(int, input().split()))
if hi:
xn.append(xi)
yn.append(yi)
hn.append(hi)
if len(xn) == 1:
print((xn[0], yn[0], hn[0]))
return
for Cx in range(101):
for Cy in range(101):
last = None
for i in range(len(xn)):
H = abs(xn[i] - Cx) + abs(yn[i] - Cy) + hn[i]
if H < 0:
continue
if last:
if last != H:
break
last = H
else:
print((Cx, Cy, H))
return
main()
| false | 20.408163 | [
"-N = int(eval(input()))",
"-xn = []",
"-yn = []",
"-hn = []",
"-for i in range(N):",
"- xi, yi, hi = list(map(int, input().split()))",
"- xn.append(xi)",
"- yn.append(yi)",
"- hn.append(hi)",
"-for Cx in range(101):",
"- for Cy in range(101):",
"- flg = True",
"- for i in range(N):",
"- if 0 == hn[i]:",
"- continue",
"- h = abs(xn[i] - Cx) + abs(yn[i] - Cy) + hn[i]",
"- if flg:",
"- H = h",
"- flg = False",
"+def main():",
"+ N = int(eval(input()))",
"+ xn = []",
"+ yn = []",
"+ hn = []",
"+ for i in range(N):",
"+ xi, yi, hi = list(map(int, input().split()))",
"+ if hi:",
"+ xn.append(xi)",
"+ yn.append(yi)",
"+ hn.append(hi)",
"+ if len(xn) == 1:",
"+ print((xn[0], yn[0], hn[0]))",
"+ return",
"+ for Cx in range(101):",
"+ for Cy in range(101):",
"+ last = None",
"+ for i in range(len(xn)):",
"+ H = abs(xn[i] - Cx) + abs(yn[i] - Cy) + hn[i]",
"+ if H < 0:",
"+ continue",
"+ if last:",
"+ if last != H:",
"+ break",
"+ last = H",
"- if H != h:",
"- flg = True",
"- break",
"- if flg:",
"- continue",
"- for i in range(N):",
"- if 0 == hn[i]:",
"- h = abs(xn[i] - Cx) + abs(yn[i] - Cy)",
"- if h < H:",
"- flg = True",
"- break",
"- if flg:",
"- continue",
"- print((Cx, Cy, H))",
"- break",
"- if not flg:",
"- break",
"+ print((Cx, Cy, H))",
"+ return",
"+",
"+",
"+main()"
] | false | 0.050861 | 0.03958 | 1.285006 | [
"s094446854",
"s852267401"
] |
u802963389 | p02755 | python | s319018324 | s653546596 | 392 | 51 | 3,060 | 3,064 | Accepted | Accepted | 86.99 | from math import floor
a, b = list(map(int, input().split()))
for i in range(1, 1000000):
if floor(i * 0.08) == a and floor(i * 0.1) == b:
print(i)
exit()
print((-1)) | # C - Tax Increase
# https://atcoder.jp/contests/abc158/tasks/abc158_c
a, b = list(map(int, input().split()))
for x in range(1, 100000):
if int(x * 0.08) == a and int(x * 0.1) == b:
print(x)
exit()
print((-1)) | 8 | 11 | 176 | 224 | from math import floor
a, b = list(map(int, input().split()))
for i in range(1, 1000000):
if floor(i * 0.08) == a and floor(i * 0.1) == b:
print(i)
exit()
print((-1))
| # C - Tax Increase
# https://atcoder.jp/contests/abc158/tasks/abc158_c
a, b = list(map(int, input().split()))
for x in range(1, 100000):
if int(x * 0.08) == a and int(x * 0.1) == b:
print(x)
exit()
print((-1))
| false | 27.272727 | [
"-from math import floor",
"-",
"+# C - Tax Increase",
"+# https://atcoder.jp/contests/abc158/tasks/abc158_c",
"-for i in range(1, 1000000):",
"- if floor(i * 0.08) == a and floor(i * 0.1) == b:",
"- print(i)",
"+for x in range(1, 100000):",
"+ if int(x * 0.08) == a and int(x * 0.1) == b:",
"+ print(x)"
] | false | 0.450214 | 0.049721 | 9.054766 | [
"s319018324",
"s653546596"
] |
u020390084 | p03401 | python | s546995583 | s345830696 | 215 | 186 | 14,048 | 23,264 | Accepted | Accepted | 13.49 | n = int(eval(input()))
a = list(map(int,input().split()))
aa = [0]+a+[0]
allsum = sum([abs(aa[index+1]-aa[index]) for index in range(n+1)])
for i in range(1,n+1):
print((allsum-abs(aa[i]-aa[i-1])-abs(aa[i+1]-aa[i])+abs(aa[i+1]-aa[i-1])))
| #!/usr/bin/env python3
import sys
def solve(N: int, A: "List[int]"):
dif = [0]*(N+1)
dif2 = [0]*N
A = [0] + A + [0]
for i in range(N+1):
dif[i] = abs(A[i+1]-A[i])
for i in range(N):
dif2[i] = abs(A[i+2]-A[i])
total_distance = sum(dif)
# output answer
for i in range(N):
print((total_distance-dif[i]-dif[i+1]+dif2[i]))
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
A = [int(next(tokens)) for _ in range(N)] # type: "List[int]"
solve(N, A)
if __name__ == '__main__':
main()
| 7 | 33 | 241 | 751 | n = int(eval(input()))
a = list(map(int, input().split()))
aa = [0] + a + [0]
allsum = sum([abs(aa[index + 1] - aa[index]) for index in range(n + 1)])
for i in range(1, n + 1):
print(
(
allsum
- abs(aa[i] - aa[i - 1])
- abs(aa[i + 1] - aa[i])
+ abs(aa[i + 1] - aa[i - 1])
)
)
| #!/usr/bin/env python3
import sys
def solve(N: int, A: "List[int]"):
dif = [0] * (N + 1)
dif2 = [0] * N
A = [0] + A + [0]
for i in range(N + 1):
dif[i] = abs(A[i + 1] - A[i])
for i in range(N):
dif2[i] = abs(A[i + 2] - A[i])
total_distance = sum(dif)
# output answer
for i in range(N):
print((total_distance - dif[i] - dif[i + 1] + dif2[i]))
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
A = [int(next(tokens)) for _ in range(N)] # type: "List[int]"
solve(N, A)
if __name__ == "__main__":
main()
| false | 78.787879 | [
"-n = int(eval(input()))",
"-a = list(map(int, input().split()))",
"-aa = [0] + a + [0]",
"-allsum = sum([abs(aa[index + 1] - aa[index]) for index in range(n + 1)])",
"-for i in range(1, n + 1):",
"- print(",
"- (",
"- allsum",
"- - abs(aa[i] - aa[i - 1])",
"- - abs(aa[i + 1] - aa[i])",
"- + abs(aa[i + 1] - aa[i - 1])",
"- )",
"- )",
"+#!/usr/bin/env python3",
"+import sys",
"+",
"+",
"+def solve(N: int, A: \"List[int]\"):",
"+ dif = [0] * (N + 1)",
"+ dif2 = [0] * N",
"+ A = [0] + A + [0]",
"+ for i in range(N + 1):",
"+ dif[i] = abs(A[i + 1] - A[i])",
"+ for i in range(N):",
"+ dif2[i] = abs(A[i + 2] - A[i])",
"+ total_distance = sum(dif)",
"+ # output answer",
"+ for i in range(N):",
"+ print((total_distance - dif[i] - dif[i + 1] + dif2[i]))",
"+ return",
"+",
"+",
"+def main():",
"+ def iterate_tokens():",
"+ for line in sys.stdin:",
"+ for word in line.split():",
"+ yield word",
"+",
"+ tokens = iterate_tokens()",
"+ N = int(next(tokens)) # type: int",
"+ A = [int(next(tokens)) for _ in range(N)] # type: \"List[int]\"",
"+ solve(N, A)",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ main()"
] | false | 0.03577 | 0.038566 | 0.927507 | [
"s546995583",
"s345830696"
] |
u912237403 | p00022 | python | s741913132 | s103419986 | 960 | 580 | 4,460 | 4,448 | Accepted | Accepted | 39.58 | n=eval(input())
while n:
R=[eval(input()) for i in range(n)]
x=R
s=max(x)
while n-1:
R=R[1:]
x=[a+b for a,b in zip(x[:-1],R)]
s=max(s,max(x))
n-=1
print(s)
n=eval(input()) | n=eval(input())
while n:
x=[]
m=[]
s=0
for i in range(n):
a=eval(input())
x=[e+a for e in x]+[a]
m.append(max(x))
print(max(m))
n=eval(input()) | 12 | 11 | 219 | 182 | n = eval(input())
while n:
R = [eval(input()) for i in range(n)]
x = R
s = max(x)
while n - 1:
R = R[1:]
x = [a + b for a, b in zip(x[:-1], R)]
s = max(s, max(x))
n -= 1
print(s)
n = eval(input())
| n = eval(input())
while n:
x = []
m = []
s = 0
for i in range(n):
a = eval(input())
x = [e + a for e in x] + [a]
m.append(max(x))
print(max(m))
n = eval(input())
| false | 8.333333 | [
"- R = [eval(input()) for i in range(n)]",
"- x = R",
"- s = max(x)",
"- while n - 1:",
"- R = R[1:]",
"- x = [a + b for a, b in zip(x[:-1], R)]",
"- s = max(s, max(x))",
"- n -= 1",
"- print(s)",
"+ x = []",
"+ m = []",
"+ s = 0",
"+ for i in range(n):",
"+ a = eval(input())",
"+ x = [e + a for e in x] + [a]",
"+ m.append(max(x))",
"+ print(max(m))"
] | false | 0.043275 | 0.052954 | 0.817203 | [
"s741913132",
"s103419986"
] |
u088372268 | p02362 | python | s032139456 | s014801205 | 290 | 220 | 6,068 | 6,520 | Accepted | Accepted | 24.14 | V, E, r = list(map(int, input().split()))
INF = 2 << 21
G = [[] for i in range(V)]
dist = [INF for j in range(V)]
def bellman_ford(s):
p, flg = [-1 for i in range(V)], [False for i in range(V)]
dist[s], flg[s], cnt = 0, True, 0
while True:
if cnt >= 2 * V:
return False
on = []
for i in range(V):
if flg[i]:
on.append(i)
flg[i] = False
if len(on) == 0:
return True
for i in on:
for j in G[i]:
if dist[i] + j[1] < dist[j[0]]:
dist[j[0]] = dist[i] + j[1]
p[j[0]], flg[j[0]] = i, True
cnt += 1
def main():
for i in range(E):
s, t, d = list(map(int, input().split()))
G[s].append((t, d))
check = bellman_ford(r)
if check:
for i in range(V):
if dist[i] == INF:
print("INF")
else:
print((dist[i]))
else:
print("NEGATIVE CYCLE")
if __name__ == '__main__':
main()
| from collections import deque
V, E, r = list(map(int, input().split()))
INF = 2 << 21
G = [[] for i in range(V)]
dist = [INF for j in range(V)]
def bellman_ford(s):
p, q1 = [-1 for i in range(V)], deque()
dist[s], cnt = 0, 0
q1.append(s)
while True:
if cnt >= 2 * V:
return False
if len(q1) == 0:
return True
q2 = deque()
for i in q1:
for j in G[i]:
if dist[i] + j[1] < dist[j[0]]:
dist[j[0]], p[j[0]] = dist[i] + j[1], i
q2.append(j[0])
q1 = q2
cnt += 1
def main():
for i in range(E):
s, t, d = list(map(int, input().split()))
G[s].append((t, d))
check = bellman_ford(r)
if check:
for i in range(V):
if dist[i] == INF:
print("INF")
else:
print((dist[i]))
else:
print("NEGATIVE CYCLE")
if __name__ == '__main__':
main()
| 53 | 52 | 1,113 | 1,036 | V, E, r = list(map(int, input().split()))
INF = 2 << 21
G = [[] for i in range(V)]
dist = [INF for j in range(V)]
def bellman_ford(s):
p, flg = [-1 for i in range(V)], [False for i in range(V)]
dist[s], flg[s], cnt = 0, True, 0
while True:
if cnt >= 2 * V:
return False
on = []
for i in range(V):
if flg[i]:
on.append(i)
flg[i] = False
if len(on) == 0:
return True
for i in on:
for j in G[i]:
if dist[i] + j[1] < dist[j[0]]:
dist[j[0]] = dist[i] + j[1]
p[j[0]], flg[j[0]] = i, True
cnt += 1
def main():
for i in range(E):
s, t, d = list(map(int, input().split()))
G[s].append((t, d))
check = bellman_ford(r)
if check:
for i in range(V):
if dist[i] == INF:
print("INF")
else:
print((dist[i]))
else:
print("NEGATIVE CYCLE")
if __name__ == "__main__":
main()
| from collections import deque
V, E, r = list(map(int, input().split()))
INF = 2 << 21
G = [[] for i in range(V)]
dist = [INF for j in range(V)]
def bellman_ford(s):
p, q1 = [-1 for i in range(V)], deque()
dist[s], cnt = 0, 0
q1.append(s)
while True:
if cnt >= 2 * V:
return False
if len(q1) == 0:
return True
q2 = deque()
for i in q1:
for j in G[i]:
if dist[i] + j[1] < dist[j[0]]:
dist[j[0]], p[j[0]] = dist[i] + j[1], i
q2.append(j[0])
q1 = q2
cnt += 1
def main():
for i in range(E):
s, t, d = list(map(int, input().split()))
G[s].append((t, d))
check = bellman_ford(r)
if check:
for i in range(V):
if dist[i] == INF:
print("INF")
else:
print((dist[i]))
else:
print("NEGATIVE CYCLE")
if __name__ == "__main__":
main()
| false | 1.886792 | [
"+from collections import deque",
"+",
"- p, flg = [-1 for i in range(V)], [False for i in range(V)]",
"- dist[s], flg[s], cnt = 0, True, 0",
"+ p, q1 = [-1 for i in range(V)], deque()",
"+ dist[s], cnt = 0, 0",
"+ q1.append(s)",
"- on = []",
"- for i in range(V):",
"- if flg[i]:",
"- on.append(i)",
"- flg[i] = False",
"- if len(on) == 0:",
"+ if len(q1) == 0:",
"- for i in on:",
"+ q2 = deque()",
"+ for i in q1:",
"- dist[j[0]] = dist[i] + j[1]",
"- p[j[0]], flg[j[0]] = i, True",
"+ dist[j[0]], p[j[0]] = dist[i] + j[1], i",
"+ q2.append(j[0])",
"+ q1 = q2"
] | false | 0.040013 | 0.039287 | 1.018481 | [
"s032139456",
"s014801205"
] |
u952708174 | p03081 | python | s874951966 | s681447224 | 1,657 | 1,067 | 39,356 | 91,980 | Accepted | Accepted | 35.61 | def c_snuke_the_wizard(N, Q, S, Magic):
# ゴーレムが隣のゴーレムを追い抜くことはありえない
# (複数体重なれば、その後同じように動いていくため)。
# よって、 左端で消滅する、最初に最も右にいるゴーレムleftと、
# 右端で消滅する、最初に最も左にいるゴーレムrightが分かればいい。
# (left >= right とはなりえない)
# これを二分探索で求めれば O(Qlog(N)) で解を得られる。
def is_vanished(x, direction):
"""
x番のゴーレムがdirection(leftまたはrightのいずれか)で指定される端で
消滅するかどうか判定する
"""
for t, d in Magic:
if t == S[x]:
# 呪文で指定されたマスに注目したゴーレムがいた。
# 呪文の内容に従ってゴーレムを移動させる
if d == 'L':
x -= 1
else:
x += 1
if x in (-1, N):
return True # 左端/右端 で消滅することとなった
return False
def binary_search(accept, reject, direction):
"""
direction が 'left' の場合は accept番とその左側のゴーレムが消滅する。
direction が 'right' の場合は accept番とその右側のゴーレムが消滅する。
direction によって accept と reject の位置関係が逆転することに注意。
"""
while abs(accept - reject) > 1:
mid = (accept + reject) // 2
if is_vanished(mid, direction):
accept = mid
else:
reject = mid
return accept + 1 if direction == 'left' else N - accept
return max(N - binary_search(-1, N, 'left') - binary_search(N, -1, 'right'), 0)
N, Q = [int(i) for i in input().split()]
S = eval(input())
Magic = [input().split() for j in range(Q)]
print((c_snuke_the_wizard(N, Q, S, Magic))) | # 参考: https://atcoder.jp/contests/exawizards2019/submissions/4780769
def c_snuke_the_wizard(N, Q, S, Magic):
# ゴーレムが隣のゴーレムを追い抜くことはありえない
# (複数体重なれば、その後同じように動いていくため)。
# よって、 左端で消滅する、最初に最も右にいるゴーレムleftと、
# 右端で消滅する、最初に最も左にいるゴーレムrightが分かればいい。
# (left >= right とはなりえない)
# これを二分探索で求めれば O(Qlog(N)) で解を得られる。
def is_vanished(x, direction):
"""
x番のゴーレムがdirection(leftまたはrightのいずれか)で指定される端で
消滅するかどうか判定する
"""
for t, d in Magic:
if t == S[x]:
# 呪文で指定されたマスに注目したゴーレムがいた。
# 呪文の内容に従ってゴーレムを移動させる
x = x - 1 if d == 'L' else x + 1
if x in (-1, N):
return True # 左端/右端 で消滅することとなった
return False
def binary_search(accept, reject, direction):
"""
direction が 'left' の場合は accept番とその左側のゴーレムが消滅する。
direction が 'right' の場合は accept番とその右側のゴーレムが消滅する。
direction によって accept と reject の位置関係が逆転することに注意。
"""
while abs(accept - reject) > 1:
mid = (accept + reject) // 2
if is_vanished(mid, direction):
accept = mid
else:
reject = mid
return accept + 1 if direction == 'left' else N - accept
return max(N - binary_search(-1, N, 'left') - binary_search(N, -1, 'right'), 0)
N, Q = [int(i) for i in input().split()]
S = eval(input())
Magic = [input().split() for j in range(Q)]
print((c_snuke_the_wizard(N, Q, S, Magic))) | 43 | 41 | 1,498 | 1,509 | def c_snuke_the_wizard(N, Q, S, Magic):
# ゴーレムが隣のゴーレムを追い抜くことはありえない
# (複数体重なれば、その後同じように動いていくため)。
# よって、 左端で消滅する、最初に最も右にいるゴーレムleftと、
# 右端で消滅する、最初に最も左にいるゴーレムrightが分かればいい。
# (left >= right とはなりえない)
# これを二分探索で求めれば O(Qlog(N)) で解を得られる。
def is_vanished(x, direction):
"""
x番のゴーレムがdirection(leftまたはrightのいずれか)で指定される端で
消滅するかどうか判定する
"""
for t, d in Magic:
if t == S[x]:
# 呪文で指定されたマスに注目したゴーレムがいた。
# 呪文の内容に従ってゴーレムを移動させる
if d == "L":
x -= 1
else:
x += 1
if x in (-1, N):
return True # 左端/右端 で消滅することとなった
return False
def binary_search(accept, reject, direction):
"""
direction が 'left' の場合は accept番とその左側のゴーレムが消滅する。
direction が 'right' の場合は accept番とその右側のゴーレムが消滅する。
direction によって accept と reject の位置関係が逆転することに注意。
"""
while abs(accept - reject) > 1:
mid = (accept + reject) // 2
if is_vanished(mid, direction):
accept = mid
else:
reject = mid
return accept + 1 if direction == "left" else N - accept
return max(N - binary_search(-1, N, "left") - binary_search(N, -1, "right"), 0)
N, Q = [int(i) for i in input().split()]
S = eval(input())
Magic = [input().split() for j in range(Q)]
print((c_snuke_the_wizard(N, Q, S, Magic)))
| # 参考: https://atcoder.jp/contests/exawizards2019/submissions/4780769
def c_snuke_the_wizard(N, Q, S, Magic):
# ゴーレムが隣のゴーレムを追い抜くことはありえない
# (複数体重なれば、その後同じように動いていくため)。
# よって、 左端で消滅する、最初に最も右にいるゴーレムleftと、
# 右端で消滅する、最初に最も左にいるゴーレムrightが分かればいい。
# (left >= right とはなりえない)
# これを二分探索で求めれば O(Qlog(N)) で解を得られる。
def is_vanished(x, direction):
"""
x番のゴーレムがdirection(leftまたはrightのいずれか)で指定される端で
消滅するかどうか判定する
"""
for t, d in Magic:
if t == S[x]:
# 呪文で指定されたマスに注目したゴーレムがいた。
# 呪文の内容に従ってゴーレムを移動させる
x = x - 1 if d == "L" else x + 1
if x in (-1, N):
return True # 左端/右端 で消滅することとなった
return False
def binary_search(accept, reject, direction):
"""
direction が 'left' の場合は accept番とその左側のゴーレムが消滅する。
direction が 'right' の場合は accept番とその右側のゴーレムが消滅する。
direction によって accept と reject の位置関係が逆転することに注意。
"""
while abs(accept - reject) > 1:
mid = (accept + reject) // 2
if is_vanished(mid, direction):
accept = mid
else:
reject = mid
return accept + 1 if direction == "left" else N - accept
return max(N - binary_search(-1, N, "left") - binary_search(N, -1, "right"), 0)
N, Q = [int(i) for i in input().split()]
S = eval(input())
Magic = [input().split() for j in range(Q)]
print((c_snuke_the_wizard(N, Q, S, Magic)))
| false | 4.651163 | [
"+# 参考: https://atcoder.jp/contests/exawizards2019/submissions/4780769",
"- if d == \"L\":",
"- x -= 1",
"- else:",
"- x += 1",
"+ x = x - 1 if d == \"L\" else x + 1"
] | false | 0.114781 | 0.034742 | 3.3038 | [
"s874951966",
"s681447224"
] |
u562935282 | p03001 | python | s624962062 | s679659763 | 172 | 17 | 38,484 | 2,940 | Accepted | Accepted | 90.12 | W, H, x, y = list(map(int, input().split()))
if x == W / 2 and y == H / 2:
print((W * H / 2, 1))
else:
print((W * H / 2, 0))
| W, H, x, y = list(map(int, input().split()))
s = W * H / 2
t = 0
if W % 2 == 0 and H % 2 == 0:
if W // 2 == x and H // 2 == y:
t = 1
print((s,t))
| 5 | 7 | 127 | 156 | W, H, x, y = list(map(int, input().split()))
if x == W / 2 and y == H / 2:
print((W * H / 2, 1))
else:
print((W * H / 2, 0))
| W, H, x, y = list(map(int, input().split()))
s = W * H / 2
t = 0
if W % 2 == 0 and H % 2 == 0:
if W // 2 == x and H // 2 == y:
t = 1
print((s, t))
| false | 28.571429 | [
"-if x == W / 2 and y == H / 2:",
"- print((W * H / 2, 1))",
"-else:",
"- print((W * H / 2, 0))",
"+s = W * H / 2",
"+t = 0",
"+if W % 2 == 0 and H % 2 == 0:",
"+ if W // 2 == x and H // 2 == y:",
"+ t = 1",
"+print((s, t))"
] | false | 0.100229 | 0.008134 | 12.322257 | [
"s624962062",
"s679659763"
] |
u040298438 | p03625 | python | s179094260 | s513076513 | 156 | 73 | 34,676 | 28,036 | Accepted | Accepted | 53.21 | from collections import Counter
eval(input())
d = Counter(list(map(int, input().split())))
d = dict(sorted(list(d.items()), reverse=True))
ans = []
for i, j in list(d.items()):
if j >= 4:
ans.append(i)
if j >= 2:
ans.append(i)
if len(ans) >= 2:
print((ans[0] * ans[1]))
else:
print((0)) | from collections import Counter
eval(input())
ans = []
for i, j in list(Counter(list(map(int, input().split()))).items()):
if j >= 4:
ans.append(i)
if j >= 2:
ans.append(i)
if len(ans) >= 2:
ans.sort()
print((ans[-1] * ans[-2]))
else:
print((0))
| 15 | 14 | 305 | 274 | from collections import Counter
eval(input())
d = Counter(list(map(int, input().split())))
d = dict(sorted(list(d.items()), reverse=True))
ans = []
for i, j in list(d.items()):
if j >= 4:
ans.append(i)
if j >= 2:
ans.append(i)
if len(ans) >= 2:
print((ans[0] * ans[1]))
else:
print((0))
| from collections import Counter
eval(input())
ans = []
for i, j in list(Counter(list(map(int, input().split()))).items()):
if j >= 4:
ans.append(i)
if j >= 2:
ans.append(i)
if len(ans) >= 2:
ans.sort()
print((ans[-1] * ans[-2]))
else:
print((0))
| false | 6.666667 | [
"-d = Counter(list(map(int, input().split())))",
"-d = dict(sorted(list(d.items()), reverse=True))",
"-for i, j in list(d.items()):",
"+for i, j in list(Counter(list(map(int, input().split()))).items()):",
"- print((ans[0] * ans[1]))",
"+ ans.sort()",
"+ print((ans[-1] * ans[-2]))"
] | false | 0.036767 | 0.035634 | 1.031775 | [
"s179094260",
"s513076513"
] |
u077898957 | p03448 | python | s921590881 | s069267512 | 184 | 49 | 17,448 | 3,060 | Accepted | Accepted | 73.37 | import numpy as np
import sys
a = int(eval(input()))
b = int(eval(input()))
c = int(eval(input()))
x = int(eval(input()))
value = [i*500 + j*100 + k*50 for i in range(a+1) for j in range(b+1) for k in range(c+1)]
print((value.count(x)))
| a=int(eval(input()))
b=int(eval(input()))
c=int(eval(input()))
x=int(eval(input()))
ans=0
for i in range(a+1):
for j in range(b+1):
for k in range(c+1):
if x==(500*i+100*j+50*k):
ans+=1
print(ans)
| 8 | 12 | 218 | 225 | import numpy as np
import sys
a = int(eval(input()))
b = int(eval(input()))
c = int(eval(input()))
x = int(eval(input()))
value = [
i * 500 + j * 100 + k * 50
for i in range(a + 1)
for j in range(b + 1)
for k in range(c + 1)
]
print((value.count(x)))
| a = int(eval(input()))
b = int(eval(input()))
c = int(eval(input()))
x = int(eval(input()))
ans = 0
for i in range(a + 1):
for j in range(b + 1):
for k in range(c + 1):
if x == (500 * i + 100 * j + 50 * k):
ans += 1
print(ans)
| false | 33.333333 | [
"-import numpy as np",
"-import sys",
"-",
"-value = [",
"- i * 500 + j * 100 + k * 50",
"- for i in range(a + 1)",
"- for j in range(b + 1)",
"- for k in range(c + 1)",
"-]",
"-print((value.count(x)))",
"+ans = 0",
"+for i in range(a + 1):",
"+ for j in range(b + 1):",
"+ for k in range(c + 1):",
"+ if x == (500 * i + 100 * j + 50 * k):",
"+ ans += 1",
"+print(ans)"
] | false | 0.161692 | 0.155151 | 1.042162 | [
"s921590881",
"s069267512"
] |
u370852395 | p03804 | python | s837110179 | s699539024 | 116 | 107 | 3,064 | 3,064 | Accepted | Accepted | 7.76 | #まだ
N,M=list(map(int,input().split()))
a_l=[]
b_l=[]
for i in range(N):
a_l.append(list(eval(input())))
for i in range(M):
b_l.extend(eval(input()))
count=0
for t in range (N-M+1):
for k in range(N-M+1):
tmp=[]
for i in range(M):
for j in range(M):
tmp.append(a_l[t+i][k+j])
if tmp == b_l:
break
if tmp == b_l:
print('Yes')
count=1
break
else:
continue
if count==0:
print('No')
| N,M=list(map(int,input().split()))
a_l=[]
b_l=[]
for i in range(N):
a_l.append(list(eval(input())))
for i in range(M):
b_l.extend(eval(input()))
count=0
for t in range (N-M+1):
for k in range(N-M+1):
tmp=[]
for i in range(M):
for j in range(M):
tmp.append(a_l[t+i][k+j])
if tmp == b_l:
print('Yes')
exit()
else:
continue
print('No')
| 25 | 20 | 504 | 442 | # まだ
N, M = list(map(int, input().split()))
a_l = []
b_l = []
for i in range(N):
a_l.append(list(eval(input())))
for i in range(M):
b_l.extend(eval(input()))
count = 0
for t in range(N - M + 1):
for k in range(N - M + 1):
tmp = []
for i in range(M):
for j in range(M):
tmp.append(a_l[t + i][k + j])
if tmp == b_l:
break
if tmp == b_l:
print("Yes")
count = 1
break
else:
continue
if count == 0:
print("No")
| N, M = list(map(int, input().split()))
a_l = []
b_l = []
for i in range(N):
a_l.append(list(eval(input())))
for i in range(M):
b_l.extend(eval(input()))
count = 0
for t in range(N - M + 1):
for k in range(N - M + 1):
tmp = []
for i in range(M):
for j in range(M):
tmp.append(a_l[t + i][k + j])
if tmp == b_l:
print("Yes")
exit()
else:
continue
print("No")
| false | 20 | [
"-# まだ",
"- break",
"- if tmp == b_l:",
"- print(\"Yes\")",
"- count = 1",
"- break",
"- else:",
"- continue",
"-if count == 0:",
"- print(\"No\")",
"+ print(\"Yes\")",
"+ exit()",
"+ else:",
"+ continue",
"+print(\"No\")"
] | false | 0.038353 | 0.071001 | 0.540173 | [
"s837110179",
"s699539024"
] |
u678167152 | p03431 | python | s492599041 | s642217625 | 1,734 | 848 | 68,272 | 176,608 | Accepted | Accepted | 51.1 | def combs_mod(n,k,mod):
#nC0からnCkまで
inv = [1]*(k+1)
for i in range(1,k+1):
inv[i] = pow(i,-1,mod)
ans = [1]*(k+1)
for i in range(1,k+1):
ans[i] = ans[i-1]*(n+1-i)*inv[i]%mod
return ans
def solve():
mod = 998244353
N, K = list(map(int, input().split()))
ans = 0
if K<N:
return ans
com = combs_mod(K,K,mod)
com2 = combs_mod(K-1,K-1,mod)
for r in range(K+1):
b = K-r
dif = r-b
if dif<0 or r<N:
continue
elif dif==0:
ans += com2[r]
if N>=2:
ans -= com2[N-2]
elif dif<N:
ans += com[r] - com[N-1-dif]
else:
ans += com[r]
ans %= mod
return ans
print((solve())) | def combs_mod(n,k,mod):
#nC0からnCkまで
inv = [1]*(k+1)
for i in range(1,k+1):
inv[i] = pow(i,mod-2,mod)
ans = [1]*(k+1)
for i in range(1,k+1):
ans[i] = ans[i-1]*(n+1-i)*inv[i]%mod
return ans
def solve():
mod = 998244353
N, K = list(map(int, input().split()))
ans = 0
if K<N:
return ans
com = combs_mod(K,K,mod)
for r in range(K+1):
b = K-r
dif = r-b
if dif<0 or r<N:
continue
elif dif==0:
com2 = combs_mod(K-1,K-1,mod)
ans += com2[r]
if N>=2:
ans -= com2[N-2]
elif dif<N:
ans += com[r] - com[N-1-dif]
else:
ans += com[r]
ans %= mod
return ans
print((solve())) | 33 | 33 | 683 | 690 | def combs_mod(n, k, mod):
# nC0からnCkまで
inv = [1] * (k + 1)
for i in range(1, k + 1):
inv[i] = pow(i, -1, mod)
ans = [1] * (k + 1)
for i in range(1, k + 1):
ans[i] = ans[i - 1] * (n + 1 - i) * inv[i] % mod
return ans
def solve():
mod = 998244353
N, K = list(map(int, input().split()))
ans = 0
if K < N:
return ans
com = combs_mod(K, K, mod)
com2 = combs_mod(K - 1, K - 1, mod)
for r in range(K + 1):
b = K - r
dif = r - b
if dif < 0 or r < N:
continue
elif dif == 0:
ans += com2[r]
if N >= 2:
ans -= com2[N - 2]
elif dif < N:
ans += com[r] - com[N - 1 - dif]
else:
ans += com[r]
ans %= mod
return ans
print((solve()))
| def combs_mod(n, k, mod):
# nC0からnCkまで
inv = [1] * (k + 1)
for i in range(1, k + 1):
inv[i] = pow(i, mod - 2, mod)
ans = [1] * (k + 1)
for i in range(1, k + 1):
ans[i] = ans[i - 1] * (n + 1 - i) * inv[i] % mod
return ans
def solve():
mod = 998244353
N, K = list(map(int, input().split()))
ans = 0
if K < N:
return ans
com = combs_mod(K, K, mod)
for r in range(K + 1):
b = K - r
dif = r - b
if dif < 0 or r < N:
continue
elif dif == 0:
com2 = combs_mod(K - 1, K - 1, mod)
ans += com2[r]
if N >= 2:
ans -= com2[N - 2]
elif dif < N:
ans += com[r] - com[N - 1 - dif]
else:
ans += com[r]
ans %= mod
return ans
print((solve()))
| false | 0 | [
"- inv[i] = pow(i, -1, mod)",
"+ inv[i] = pow(i, mod - 2, mod)",
"- com2 = combs_mod(K - 1, K - 1, mod)",
"+ com2 = combs_mod(K - 1, K - 1, mod)"
] | false | 0.16502 | 0.470355 | 0.350842 | [
"s492599041",
"s642217625"
] |
u145231176 | p02629 | python | s651930201 | s103836005 | 334 | 186 | 83,056 | 78,132 | Accepted | Accepted | 44.31 | def getN():
return int(eval(input()))
def getNM():
return list(map(int, input().split()))
def getList():
return list(map(int, input().split()))
def getArray(intn):
return [int(eval(input())) for i in range(intn)]
def input():
return sys.stdin.readline().rstrip()
def rand_N(ran1, ran2):
return random.randint(ran1, ran2)
def rand_List(ran1, ran2, rantime):
return [random.randint(ran1, ran2) for i in range(rantime)]
def rand_ints_nodup(ran1, ran2, rantime):
ns = []
while len(ns) < rantime:
n = random.randint(ran1, ran2)
if not n in ns:
ns.append(n)
return sorted(ns)
def rand_query(ran1, ran2, rantime):
r_query = []
while len(r_query) < rantime:
n_q = rand_ints_nodup(ran1, ran2, 2)
if not n_q in r_query:
r_query.append(n_q)
return sorted(r_query)
from collections import defaultdict, deque, Counter
from sys import exit
from decimal import *
import heapq
import math
from fractions import gcd
import random
import string
import copy
from itertools import combinations, permutations, product
from operator import mul
from functools import reduce
from bisect import bisect_left, bisect_right
import sys
sys.setrecursionlimit(1000000000)
mod = 10 ** 9 + 7
#############
# Main Code #
#############
N = getN()
def num2alpha(num):
if num<=26:
return chr(96+num)
elif num%26==0:
return num2alpha(num//26-1)+chr(122)
else:
return num2alpha(num//26)+chr(96+num%26)
print((num2alpha(N))) | def getN():
return int(eval(input()))
def getNM():
return list(map(int, input().split()))
def getList():
return list(map(int, input().split()))
def getArray(intn):
return [int(eval(input())) for i in range(intn)]
def input():
return sys.stdin.readline().rstrip()
def rand_N(ran1, ran2):
return random.randint(ran1, ran2)
def rand_List(ran1, ran2, rantime):
return [random.randint(ran1, ran2) for i in range(rantime)]
def rand_ints_nodup(ran1, ran2, rantime):
ns = []
while len(ns) < rantime:
n = random.randint(ran1, ran2)
if not n in ns:
ns.append(n)
return sorted(ns)
def rand_query(ran1, ran2, rantime):
r_query = []
while len(r_query) < rantime:
n_q = rand_ints_nodup(ran1, ran2, 2)
if not n_q in r_query:
r_query.append(n_q)
return sorted(r_query)
from collections import defaultdict, deque, Counter
from sys import exit
from decimal import *
import heapq
import math
from fractions import gcd
import random
import string
import copy
from itertools import combinations, permutations, product
from operator import mul
from functools import reduce
from bisect import bisect_left, bisect_right
import sys
sys.setrecursionlimit(1000000000)
mod = 10 ** 9 + 7
#############
# Main Code #
#############
n = getN()
lista = []
digit = 26
i = 0
while n != 0:
opt = n % digit
lista.insert(0, opt)
if n % digit == 0:
n = n // digit - 1
else:
n = n // digit
i += 1
str_list = 'abcdefghijklmnopqrstuvwxyz'
ans = ''
for i in range(len(lista)):
ans += str_list[lista[i] - 1]
print(ans) | 64 | 72 | 1,539 | 1,643 | def getN():
return int(eval(input()))
def getNM():
return list(map(int, input().split()))
def getList():
return list(map(int, input().split()))
def getArray(intn):
return [int(eval(input())) for i in range(intn)]
def input():
return sys.stdin.readline().rstrip()
def rand_N(ran1, ran2):
return random.randint(ran1, ran2)
def rand_List(ran1, ran2, rantime):
return [random.randint(ran1, ran2) for i in range(rantime)]
def rand_ints_nodup(ran1, ran2, rantime):
ns = []
while len(ns) < rantime:
n = random.randint(ran1, ran2)
if not n in ns:
ns.append(n)
return sorted(ns)
def rand_query(ran1, ran2, rantime):
r_query = []
while len(r_query) < rantime:
n_q = rand_ints_nodup(ran1, ran2, 2)
if not n_q in r_query:
r_query.append(n_q)
return sorted(r_query)
from collections import defaultdict, deque, Counter
from sys import exit
from decimal import *
import heapq
import math
from fractions import gcd
import random
import string
import copy
from itertools import combinations, permutations, product
from operator import mul
from functools import reduce
from bisect import bisect_left, bisect_right
import sys
sys.setrecursionlimit(1000000000)
mod = 10**9 + 7
#############
# Main Code #
#############
N = getN()
def num2alpha(num):
if num <= 26:
return chr(96 + num)
elif num % 26 == 0:
return num2alpha(num // 26 - 1) + chr(122)
else:
return num2alpha(num // 26) + chr(96 + num % 26)
print((num2alpha(N)))
| def getN():
return int(eval(input()))
def getNM():
return list(map(int, input().split()))
def getList():
return list(map(int, input().split()))
def getArray(intn):
return [int(eval(input())) for i in range(intn)]
def input():
return sys.stdin.readline().rstrip()
def rand_N(ran1, ran2):
return random.randint(ran1, ran2)
def rand_List(ran1, ran2, rantime):
return [random.randint(ran1, ran2) for i in range(rantime)]
def rand_ints_nodup(ran1, ran2, rantime):
ns = []
while len(ns) < rantime:
n = random.randint(ran1, ran2)
if not n in ns:
ns.append(n)
return sorted(ns)
def rand_query(ran1, ran2, rantime):
r_query = []
while len(r_query) < rantime:
n_q = rand_ints_nodup(ran1, ran2, 2)
if not n_q in r_query:
r_query.append(n_q)
return sorted(r_query)
from collections import defaultdict, deque, Counter
from sys import exit
from decimal import *
import heapq
import math
from fractions import gcd
import random
import string
import copy
from itertools import combinations, permutations, product
from operator import mul
from functools import reduce
from bisect import bisect_left, bisect_right
import sys
sys.setrecursionlimit(1000000000)
mod = 10**9 + 7
#############
# Main Code #
#############
n = getN()
lista = []
digit = 26
i = 0
while n != 0:
opt = n % digit
lista.insert(0, opt)
if n % digit == 0:
n = n // digit - 1
else:
n = n // digit
i += 1
str_list = "abcdefghijklmnopqrstuvwxyz"
ans = ""
for i in range(len(lista)):
ans += str_list[lista[i] - 1]
print(ans)
| false | 11.111111 | [
"-N = getN()",
"-",
"-",
"-def num2alpha(num):",
"- if num <= 26:",
"- return chr(96 + num)",
"- elif num % 26 == 0:",
"- return num2alpha(num // 26 - 1) + chr(122)",
"+n = getN()",
"+lista = []",
"+digit = 26",
"+i = 0",
"+while n != 0:",
"+ opt = n % digit",
"+ lista.insert(0, opt)",
"+ if n % digit == 0:",
"+ n = n // digit - 1",
"- return num2alpha(num // 26) + chr(96 + num % 26)",
"-",
"-",
"-print((num2alpha(N)))",
"+ n = n // digit",
"+ i += 1",
"+str_list = \"abcdefghijklmnopqrstuvwxyz\"",
"+ans = \"\"",
"+for i in range(len(lista)):",
"+ ans += str_list[lista[i] - 1]",
"+print(ans)"
] | false | 0.038317 | 0.102779 | 0.37281 | [
"s651930201",
"s103836005"
] |
u119148115 | p02547 | python | s216925292 | s613923185 | 88 | 62 | 62,088 | 62,064 | Accepted | Accepted | 29.55 | import sys
sys.setrecursionlimit(10**7)
def I(): return int(sys.stdin.readline().rstrip())
def MI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LI(): return list(map(int,sys.stdin.readline().rstrip().split())) #空白あり
def LI2(): return list(map(int,sys.stdin.readline().rstrip())) #空白なし
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split()) #空白あり
def LS2(): return list(sys.stdin.readline().rstrip()) #空白なし
N = I()
D = [tuple(MI()) for _ in range(N)]
for i in range(N-2):
if D[i][0] == D[i][1] and D[i+1][0] == D[i+1][1] and D[i+2][0] == D[i+2][1]:
print('Yes')
break
else:
print('No')
| import sys
def I(): return int(sys.stdin.readline().rstrip())
def MI(): return list(map(int,sys.stdin.readline().rstrip().split()))
N = I()
D = [0]*N
for i in range(N):
a,b = MI()
if a == b:
D[i] = 1
for i in range(N-2):
if D[i] == D[i+1] == D[i+2] == 1:
print('Yes')
break
else:
print('No')
| 20 | 18 | 702 | 346 | import sys
sys.setrecursionlimit(10**7)
def I():
return int(sys.stdin.readline().rstrip())
def MI():
return list(map(int, sys.stdin.readline().rstrip().split()))
def LI():
return list(map(int, sys.stdin.readline().rstrip().split())) # 空白あり
def LI2():
return list(map(int, sys.stdin.readline().rstrip())) # 空白なし
def S():
return sys.stdin.readline().rstrip()
def LS():
return list(sys.stdin.readline().rstrip().split()) # 空白あり
def LS2():
return list(sys.stdin.readline().rstrip()) # 空白なし
N = I()
D = [tuple(MI()) for _ in range(N)]
for i in range(N - 2):
if D[i][0] == D[i][1] and D[i + 1][0] == D[i + 1][1] and D[i + 2][0] == D[i + 2][1]:
print("Yes")
break
else:
print("No")
| import sys
def I():
return int(sys.stdin.readline().rstrip())
def MI():
return list(map(int, sys.stdin.readline().rstrip().split()))
N = I()
D = [0] * N
for i in range(N):
a, b = MI()
if a == b:
D[i] = 1
for i in range(N - 2):
if D[i] == D[i + 1] == D[i + 2] == 1:
print("Yes")
break
else:
print("No")
| false | 10 | [
"-",
"-sys.setrecursionlimit(10**7)",
"-def LI():",
"- return list(map(int, sys.stdin.readline().rstrip().split())) # 空白あり",
"-",
"-",
"-def LI2():",
"- return list(map(int, sys.stdin.readline().rstrip())) # 空白なし",
"-",
"-",
"-def S():",
"- return sys.stdin.readline().rstrip()",
"-",
"-",
"-def LS():",
"- return list(sys.stdin.readline().rstrip().split()) # 空白あり",
"-",
"-",
"-def LS2():",
"- return list(sys.stdin.readline().rstrip()) # 空白なし",
"-",
"-",
"-D = [tuple(MI()) for _ in range(N)]",
"+D = [0] * N",
"+for i in range(N):",
"+ a, b = MI()",
"+ if a == b:",
"+ D[i] = 1",
"- if D[i][0] == D[i][1] and D[i + 1][0] == D[i + 1][1] and D[i + 2][0] == D[i + 2][1]:",
"+ if D[i] == D[i + 1] == D[i + 2] == 1:"
] | false | 0.035357 | 0.042556 | 0.830827 | [
"s216925292",
"s613923185"
] |
u186121428 | p02700 | python | s640576381 | s624503731 | 24 | 20 | 9,108 | 9,164 | Accepted | Accepted | 16.67 | A, B, C, D = list(map(int, input().split()))
t_q, t_d = divmod(C, B)
a_q, a_d = divmod(A, D)
t_eq = t_q if t_d == 0 else t_q + 1
a_eq = a_q if a_d == 0 else a_q + 1
if t_eq <= a_eq:
print('Yes')
else:
print('No') | A, B, C, D = list(map(int, input().split()))
t_eq = -(-C//B)
a_eq = -(-A//D)
if t_eq <= a_eq:
print('Yes')
else:
print('No') | 9 | 7 | 222 | 132 | A, B, C, D = list(map(int, input().split()))
t_q, t_d = divmod(C, B)
a_q, a_d = divmod(A, D)
t_eq = t_q if t_d == 0 else t_q + 1
a_eq = a_q if a_d == 0 else a_q + 1
if t_eq <= a_eq:
print("Yes")
else:
print("No")
| A, B, C, D = list(map(int, input().split()))
t_eq = -(-C // B)
a_eq = -(-A // D)
if t_eq <= a_eq:
print("Yes")
else:
print("No")
| false | 22.222222 | [
"-t_q, t_d = divmod(C, B)",
"-a_q, a_d = divmod(A, D)",
"-t_eq = t_q if t_d == 0 else t_q + 1",
"-a_eq = a_q if a_d == 0 else a_q + 1",
"+t_eq = -(-C // B)",
"+a_eq = -(-A // D)"
] | false | 0.093033 | 0.039394 | 2.361591 | [
"s640576381",
"s624503731"
] |
u935184340 | p00423 | python | s022489200 | s823013658 | 80 | 70 | 8,816 | 8,932 | Accepted | Accepted | 12.5 | import collections
import sys
l = collections.deque(sys.stdin.readlines())
l.pop()
s = ""
while l:
a = 0
b = 0
for i in range(int(l.popleft())):
x,y = map(int, l.popleft().split())
if x > y:
a = a + x + y
elif x < y:
b = b + x + y
else:
a = a+x
b = b+y
s += str(a) + " " + str(b) + "\n"
print(s,end="")
| import collections
import sys
l = collections.deque(sys.stdin.readlines())
l.pop()
s = ""
while l:
a = 0
b = 0
for i in range(int(l.popleft())):
x,y = list(map(int, l.popleft().split()))
if x > y:
a = a + x + y
elif x < y:
b = b + x + y
else:
a = a+x
b = b+y
print((a,b)) | 21 | 19 | 420 | 378 | import collections
import sys
l = collections.deque(sys.stdin.readlines())
l.pop()
s = ""
while l:
a = 0
b = 0
for i in range(int(l.popleft())):
x, y = map(int, l.popleft().split())
if x > y:
a = a + x + y
elif x < y:
b = b + x + y
else:
a = a + x
b = b + y
s += str(a) + " " + str(b) + "\n"
print(s, end="")
| import collections
import sys
l = collections.deque(sys.stdin.readlines())
l.pop()
s = ""
while l:
a = 0
b = 0
for i in range(int(l.popleft())):
x, y = list(map(int, l.popleft().split()))
if x > y:
a = a + x + y
elif x < y:
b = b + x + y
else:
a = a + x
b = b + y
print((a, b))
| false | 9.52381 | [
"- x, y = map(int, l.popleft().split())",
"+ x, y = list(map(int, l.popleft().split()))",
"- s += str(a) + \" \" + str(b) + \"\\n\"",
"-print(s, end=\"\")",
"+ print((a, b))"
] | false | 0.036581 | 0.103683 | 0.352813 | [
"s022489200",
"s823013658"
] |
u190405389 | p03212 | python | s586339111 | s009545379 | 75 | 54 | 5,228 | 5,228 | Accepted | Accepted | 28 | def shichigo(s):
if '3' not in s:
return False
if '5' not in s:
return False
if '7' not in s:
return False
x = s.replace('3','').replace('5','').replace('7','')
if x=='':
return True
return False
n = eval(input())
l = [[] for i in range(len(n))]
l[0] = ['3','5','7']
for i in range(1,len(l)):
for j in range(len(l[i-1])):
l[i].append('3'+l[i-1][j])
l[i].append('5'+l[i-1][j])
l[i].append('7'+l[i-1][j])
ans = 0
for i in range(len(l)):
for j in range(len(l[i])):
if int(n) >= int(l[i][j]):
if shichigo(l[i][j]):
ans += 1
print(ans)
| def shichigo(s):
if '3' not in s:
return False
if '5' not in s:
return False
if '7' not in s:
return False
return True
n = eval(input())
l = [[] for i in range(len(n))]
l[0] = ['3','5','7']
for i in range(1,len(l)):
for j in range(len(l[i-1])):
l[i].append('3'+l[i-1][j])
l[i].append('5'+l[i-1][j])
l[i].append('7'+l[i-1][j])
ans = 0
for i in range(len(l)):
for j in range(len(l[i])):
if int(n) >= int(l[i][j]):
if shichigo(l[i][j]):
ans += 1
print(ans)
| 30 | 27 | 682 | 586 | def shichigo(s):
if "3" not in s:
return False
if "5" not in s:
return False
if "7" not in s:
return False
x = s.replace("3", "").replace("5", "").replace("7", "")
if x == "":
return True
return False
n = eval(input())
l = [[] for i in range(len(n))]
l[0] = ["3", "5", "7"]
for i in range(1, len(l)):
for j in range(len(l[i - 1])):
l[i].append("3" + l[i - 1][j])
l[i].append("5" + l[i - 1][j])
l[i].append("7" + l[i - 1][j])
ans = 0
for i in range(len(l)):
for j in range(len(l[i])):
if int(n) >= int(l[i][j]):
if shichigo(l[i][j]):
ans += 1
print(ans)
| def shichigo(s):
if "3" not in s:
return False
if "5" not in s:
return False
if "7" not in s:
return False
return True
n = eval(input())
l = [[] for i in range(len(n))]
l[0] = ["3", "5", "7"]
for i in range(1, len(l)):
for j in range(len(l[i - 1])):
l[i].append("3" + l[i - 1][j])
l[i].append("5" + l[i - 1][j])
l[i].append("7" + l[i - 1][j])
ans = 0
for i in range(len(l)):
for j in range(len(l[i])):
if int(n) >= int(l[i][j]):
if shichigo(l[i][j]):
ans += 1
print(ans)
| false | 10 | [
"- x = s.replace(\"3\", \"\").replace(\"5\", \"\").replace(\"7\", \"\")",
"- if x == \"\":",
"- return True",
"- return False",
"+ return True"
] | false | 0.034739 | 0.034719 | 1.000576 | [
"s586339111",
"s009545379"
] |
u163703551 | p03682 | python | s033326553 | s716430571 | 1,600 | 1,476 | 62,464 | 62,348 | Accepted | Accepted | 7.75 | import operator
import sys
# sys.stdin = open('d1.in')
def read_int_list():
return list(map(int, input().split()))
def read_str_list():
return input().split()
def read_int():
return int(eval(input()))
def read_str():
return eval(input())
p = []
rank = []
def make_set(x):
p[x] = x
rank[x] = 0
def _union(x, y):
link(find_set(x), find_set(y))
def link(x, y):
if rank[x] > rank[y]:
p[y] = x
else:
p[x] = y
if rank[x] == rank[y]:
rank[x] += 1
def find_set(x):
if x != p[x]:
p[x] = find_set(p[x])
return p[x]
def solve():
n = read_int()
a = [read_int_list() for i in range(n)]
global p, rank
p = [0] * n
rank = [0] * n
for x in range(n):
make_set(x)
def get_cost(i, j):
return min(abs(a[i][0] - a[j][0]), abs(a[i][1] - a[j][1]))
roads = []
for j in range(2):
l = sorted(list(range(n)), key=lambda i: a[i][j])
for i in range(n - 1):
cost = get_cost(l[i], l[i + 1])
road = (cost, l[i], l[i + 1])
roads.append(road)
roads.sort()
res = 0
for road in roads:
c, u, v = road
if find_set(u) != find_set(v):
res += c
_union(u, v)
return res
def main():
res = solve()
print(res)
main()
| import sys
# sys.stdin = open('d1.in')
def read_int_list():
return list(map(int, input().split()))
def read_str_list():
return input().split()
def read_int():
return int(eval(input()))
def read_str():
return eval(input())
p = []
rank = []
def make_set(x):
p[x] = x
rank[x] = 0
def _union(x, y):
link(find_set(x), find_set(y))
def link(x, y):
if rank[x] > rank[y]:
p[y] = x
else:
p[x] = y
if rank[x] == rank[y]:
rank[x] += 1
def find_set(x):
if x != p[x]:
p[x] = find_set(p[x])
return p[x]
def solve():
n = read_int()
a = [read_int_list() for i in range(n)]
global p, rank
p = [0] * n
rank = [0] * n
for x in range(n):
make_set(x)
def get_cost(i, j):
return min(abs(a[i][0] - a[j][0]), abs(a[i][1] - a[j][1]))
roads = []
for j in range(2):
l = sorted(list(range(n)), key=lambda i: a[i][j])
for i in range(n - 1):
cost = get_cost(l[i], l[i + 1])
road = (cost, l[i], l[i + 1])
roads.append(road)
roads.sort()
res = 0
m = 0
for road in roads:
c, u, v = road
if find_set(u) != find_set(v):
res += c
m += 1
_union(u, v)
if m == n - 1:
break
return res
def main():
res = solve()
print(res)
main()
| 87 | 90 | 1,425 | 1,482 | import operator
import sys
# sys.stdin = open('d1.in')
def read_int_list():
return list(map(int, input().split()))
def read_str_list():
return input().split()
def read_int():
return int(eval(input()))
def read_str():
return eval(input())
p = []
rank = []
def make_set(x):
p[x] = x
rank[x] = 0
def _union(x, y):
link(find_set(x), find_set(y))
def link(x, y):
if rank[x] > rank[y]:
p[y] = x
else:
p[x] = y
if rank[x] == rank[y]:
rank[x] += 1
def find_set(x):
if x != p[x]:
p[x] = find_set(p[x])
return p[x]
def solve():
n = read_int()
a = [read_int_list() for i in range(n)]
global p, rank
p = [0] * n
rank = [0] * n
for x in range(n):
make_set(x)
def get_cost(i, j):
return min(abs(a[i][0] - a[j][0]), abs(a[i][1] - a[j][1]))
roads = []
for j in range(2):
l = sorted(list(range(n)), key=lambda i: a[i][j])
for i in range(n - 1):
cost = get_cost(l[i], l[i + 1])
road = (cost, l[i], l[i + 1])
roads.append(road)
roads.sort()
res = 0
for road in roads:
c, u, v = road
if find_set(u) != find_set(v):
res += c
_union(u, v)
return res
def main():
res = solve()
print(res)
main()
| import sys
# sys.stdin = open('d1.in')
def read_int_list():
return list(map(int, input().split()))
def read_str_list():
return input().split()
def read_int():
return int(eval(input()))
def read_str():
return eval(input())
p = []
rank = []
def make_set(x):
p[x] = x
rank[x] = 0
def _union(x, y):
link(find_set(x), find_set(y))
def link(x, y):
if rank[x] > rank[y]:
p[y] = x
else:
p[x] = y
if rank[x] == rank[y]:
rank[x] += 1
def find_set(x):
if x != p[x]:
p[x] = find_set(p[x])
return p[x]
def solve():
n = read_int()
a = [read_int_list() for i in range(n)]
global p, rank
p = [0] * n
rank = [0] * n
for x in range(n):
make_set(x)
def get_cost(i, j):
return min(abs(a[i][0] - a[j][0]), abs(a[i][1] - a[j][1]))
roads = []
for j in range(2):
l = sorted(list(range(n)), key=lambda i: a[i][j])
for i in range(n - 1):
cost = get_cost(l[i], l[i + 1])
road = (cost, l[i], l[i + 1])
roads.append(road)
roads.sort()
res = 0
m = 0
for road in roads:
c, u, v = road
if find_set(u) != find_set(v):
res += c
m += 1
_union(u, v)
if m == n - 1:
break
return res
def main():
res = solve()
print(res)
main()
| false | 3.333333 | [
"-import operator",
"+ m = 0",
"+ m += 1",
"+ if m == n - 1:",
"+ break"
] | false | 0.008015 | 0.072655 | 0.110319 | [
"s033326553",
"s716430571"
] |
u288430479 | p02792 | python | s458372073 | s828021224 | 292 | 187 | 9,168 | 9,100 | Accepted | Accepted | 35.96 | n = int(eval(input()))
cou = 0
for i in range(1,n+1):
i = str(i)
if i[0]!="0" and i[-1]!="0":
if int(i[0])>int(i[-1]):
cou += (10**(len(i)-1)-1)//9
elif int(i[0])<int(i[-1]):
cou += (10**(len(i)-2)-1)//9
#print(i,cou)
cou *= 2
l = [0 for i in range(9)]
for i in range(1,n+1):
i = str(i)
if i[0]==i[-1]:
l[int(i[0])-1] += 1
l1 = [i*i for i in l]
print((sum(l1)+cou)) | n = int(eval(input()))
dp = [[0]*10 for i in range(10)]
su = 0
for i in range(1,n+1):
a,b = str(i)[0],str(i)[-1]
dp[int(a)-1][int(b)-1] += 1
for i in range(10):
for j in range(10):
su += dp[i][j]*dp[j][i]
print(su) | 20 | 10 | 417 | 227 | n = int(eval(input()))
cou = 0
for i in range(1, n + 1):
i = str(i)
if i[0] != "0" and i[-1] != "0":
if int(i[0]) > int(i[-1]):
cou += (10 ** (len(i) - 1) - 1) // 9
elif int(i[0]) < int(i[-1]):
cou += (10 ** (len(i) - 2) - 1) // 9
# print(i,cou)
cou *= 2
l = [0 for i in range(9)]
for i in range(1, n + 1):
i = str(i)
if i[0] == i[-1]:
l[int(i[0]) - 1] += 1
l1 = [i * i for i in l]
print((sum(l1) + cou))
| n = int(eval(input()))
dp = [[0] * 10 for i in range(10)]
su = 0
for i in range(1, n + 1):
a, b = str(i)[0], str(i)[-1]
dp[int(a) - 1][int(b) - 1] += 1
for i in range(10):
for j in range(10):
su += dp[i][j] * dp[j][i]
print(su)
| false | 50 | [
"-cou = 0",
"+dp = [[0] * 10 for i in range(10)]",
"+su = 0",
"- i = str(i)",
"- if i[0] != \"0\" and i[-1] != \"0\":",
"- if int(i[0]) > int(i[-1]):",
"- cou += (10 ** (len(i) - 1) - 1) // 9",
"- elif int(i[0]) < int(i[-1]):",
"- cou += (10 ** (len(i) - 2) - 1) // 9",
"- # print(i,cou)",
"-cou *= 2",
"-l = [0 for i in range(9)]",
"-for i in range(1, n + 1):",
"- i = str(i)",
"- if i[0] == i[-1]:",
"- l[int(i[0]) - 1] += 1",
"-l1 = [i * i for i in l]",
"-print((sum(l1) + cou))",
"+ a, b = str(i)[0], str(i)[-1]",
"+ dp[int(a) - 1][int(b) - 1] += 1",
"+for i in range(10):",
"+ for j in range(10):",
"+ su += dp[i][j] * dp[j][i]",
"+print(su)"
] | false | 0.187798 | 0.14091 | 1.332751 | [
"s458372073",
"s828021224"
] |
u739721456 | p03478 | python | s731148638 | s335472749 | 39 | 31 | 2,940 | 3,060 | Accepted | Accepted | 20.51 | n,a,b=list(map(int,input().split()))
ans=0
for i in range(1,n+1):
i=str(i)
m=0
for j in range(len(i)):
m+=int(i[j])
if m>=a and m<=b:
ans+=int(i)
print(ans)
| def sum(p):
q=0
while p>0:
q+=p%10
p=p//10
return(q)
n,a,b=list(map(int,input().split()))
ans=0
for i in range(1,n+1):
if sum(i)>=a and sum(i)<=b:
ans+=i
print(ans) | 12 | 14 | 196 | 213 | n, a, b = list(map(int, input().split()))
ans = 0
for i in range(1, n + 1):
i = str(i)
m = 0
for j in range(len(i)):
m += int(i[j])
if m >= a and m <= b:
ans += int(i)
print(ans)
| def sum(p):
q = 0
while p > 0:
q += p % 10
p = p // 10
return q
n, a, b = list(map(int, input().split()))
ans = 0
for i in range(1, n + 1):
if sum(i) >= a and sum(i) <= b:
ans += i
print(ans)
| false | 14.285714 | [
"+def sum(p):",
"+ q = 0",
"+ while p > 0:",
"+ q += p % 10",
"+ p = p // 10",
"+ return q",
"+",
"+",
"- i = str(i)",
"- m = 0",
"- for j in range(len(i)):",
"- m += int(i[j])",
"- if m >= a and m <= b:",
"- ans += int(i)",
"+ if sum(i) >= a and sum(i) <= b:",
"+ ans += i"
] | false | 0.036673 | 0.036209 | 1.012816 | [
"s731148638",
"s335472749"
] |
u426534722 | p02315 | python | s611437607 | s870188099 | 450 | 410 | 7,992 | 7,928 | Accepted | Accepted | 8.89 | N, W = [int(i) for i in input().split()]
dp = [0] * (W + 1)
v = w = 0
for _ in range(0, N):
v, w = [int(i) for i in input().split()]
for j in range(W, w - 1, -1):
if dp[j] < dp[j - w] + v:
dp[j] = dp[j - w] + v
print((dp[W])) | N, W = list(map(int, input().split()))
dp = [0] * (W + 1)
v = w = 0
for _ in range(0, N):
v, w = list(map(int, input().split()))
for j in range(W, w - 1, -1):
if dp[j] < dp[j - w] + v:
dp[j] = dp[j - w] + v
print((dp[W])) | 9 | 9 | 259 | 243 | N, W = [int(i) for i in input().split()]
dp = [0] * (W + 1)
v = w = 0
for _ in range(0, N):
v, w = [int(i) for i in input().split()]
for j in range(W, w - 1, -1):
if dp[j] < dp[j - w] + v:
dp[j] = dp[j - w] + v
print((dp[W]))
| N, W = list(map(int, input().split()))
dp = [0] * (W + 1)
v = w = 0
for _ in range(0, N):
v, w = list(map(int, input().split()))
for j in range(W, w - 1, -1):
if dp[j] < dp[j - w] + v:
dp[j] = dp[j - w] + v
print((dp[W]))
| false | 0 | [
"-N, W = [int(i) for i in input().split()]",
"+N, W = list(map(int, input().split()))",
"- v, w = [int(i) for i in input().split()]",
"+ v, w = list(map(int, input().split()))"
] | false | 0.07355 | 0.072863 | 1.00942 | [
"s611437607",
"s870188099"
] |
u284854859 | p02573 | python | s599090229 | s599605810 | 1,332 | 206 | 716,100 | 75,160 | Accepted | Accepted | 84.53 | import sys,heapq
input = sys.stdin.buffer.readline
sys.setrecursionlimit(10**7)
n,m = list(map(int,input().split()))
edge = [[] for _ in range(n)]
for _ in range(m):
a,b = list(map(int,input().split()))
edge[a-1].append(b-1)
edge[b-1].append(a-1)
#True:訪問済み False:未訪問
flag = [False]*n
def dfs(now):
if flag[now]:
return 0
flag[now] = True
size = 0
for nxt in edge[now]:
if not flag[nxt]:
size += dfs(nxt)
return size + 1
res = 0
for i in range(n):
if flag[i]:
continue
res = max(res,dfs(i))
print(res)
| #Union Find
#xの根を求める
def find(x):
if par[x] < 0:
return x
else:
tank = []
while par[x] >= 0:
tank.append(x)
x = par[x]
for elt in tank:
par[elt] = x
return x
#xとyの属する集合の併合
def unite(x,y):
x = find(x)
y = find(y)
if x == y:
return False
else:
#sizeの大きいほうがx
if par[x] > par[y]:
x,y = y,x
par[x] += par[y]
par[y] = x
return True
#xとyが同じ集合に属するかの判定
def same(x,y):
return find(x) == find(y)
#xが属する集合の個数
def size(x):
return -par[find(x)]
import sys
input = sys.stdin.buffer.readline
n,m = list(map(int,input().split()))
#初期化
#根なら-size,子なら親の頂点
par = [-1]*n
for _ in range(m):
a,b = list(map(int,input().split()))
unite(a-1,b-1)
res = 0
for e in par:
if e < 0:
res = max(res,-e)
print(res) | 38 | 56 | 619 | 928 | import sys, heapq
input = sys.stdin.buffer.readline
sys.setrecursionlimit(10**7)
n, m = list(map(int, input().split()))
edge = [[] for _ in range(n)]
for _ in range(m):
a, b = list(map(int, input().split()))
edge[a - 1].append(b - 1)
edge[b - 1].append(a - 1)
# True:訪問済み False:未訪問
flag = [False] * n
def dfs(now):
if flag[now]:
return 0
flag[now] = True
size = 0
for nxt in edge[now]:
if not flag[nxt]:
size += dfs(nxt)
return size + 1
res = 0
for i in range(n):
if flag[i]:
continue
res = max(res, dfs(i))
print(res)
| # Union Find
# xの根を求める
def find(x):
if par[x] < 0:
return x
else:
tank = []
while par[x] >= 0:
tank.append(x)
x = par[x]
for elt in tank:
par[elt] = x
return x
# xとyの属する集合の併合
def unite(x, y):
x = find(x)
y = find(y)
if x == y:
return False
else:
# sizeの大きいほうがx
if par[x] > par[y]:
x, y = y, x
par[x] += par[y]
par[y] = x
return True
# xとyが同じ集合に属するかの判定
def same(x, y):
return find(x) == find(y)
# xが属する集合の個数
def size(x):
return -par[find(x)]
import sys
input = sys.stdin.buffer.readline
n, m = list(map(int, input().split()))
# 初期化
# 根なら-size,子なら親の頂点
par = [-1] * n
for _ in range(m):
a, b = list(map(int, input().split()))
unite(a - 1, b - 1)
res = 0
for e in par:
if e < 0:
res = max(res, -e)
print(res)
| false | 32.142857 | [
"-import sys, heapq",
"+# Union Find",
"+# xの根を求める",
"+def find(x):",
"+ if par[x] < 0:",
"+ return x",
"+ else:",
"+ tank = []",
"+ while par[x] >= 0:",
"+ tank.append(x)",
"+ x = par[x]",
"+ for elt in tank:",
"+ par[elt] = x",
"+ return x",
"+",
"+",
"+# xとyの属する集合の併合",
"+def unite(x, y):",
"+ x = find(x)",
"+ y = find(y)",
"+ if x == y:",
"+ return False",
"+ else:",
"+ # sizeの大きいほうがx",
"+ if par[x] > par[y]:",
"+ x, y = y, x",
"+ par[x] += par[y]",
"+ par[y] = x",
"+ return True",
"+",
"+",
"+# xとyが同じ集合に属するかの判定",
"+def same(x, y):",
"+ return find(x) == find(y)",
"+",
"+",
"+# xが属する集合の個数",
"+def size(x):",
"+ return -par[find(x)]",
"+",
"+",
"+import sys",
"-sys.setrecursionlimit(10**7)",
"-edge = [[] for _ in range(n)]",
"+# 初期化",
"+# 根なら-size,子なら親の頂点",
"+par = [-1] * n",
"- edge[a - 1].append(b - 1)",
"- edge[b - 1].append(a - 1)",
"-# True:訪問済み False:未訪問",
"-flag = [False] * n",
"-",
"-",
"-def dfs(now):",
"- if flag[now]:",
"- return 0",
"- flag[now] = True",
"- size = 0",
"- for nxt in edge[now]:",
"- if not flag[nxt]:",
"- size += dfs(nxt)",
"- return size + 1",
"-",
"-",
"+ unite(a - 1, b - 1)",
"-for i in range(n):",
"- if flag[i]:",
"- continue",
"- res = max(res, dfs(i))",
"+for e in par:",
"+ if e < 0:",
"+ res = max(res, -e)"
] | false | 0.086577 | 0.007604 | 11.386285 | [
"s599090229",
"s599605810"
] |
u260980560 | p02363 | python | s655232997 | s999466607 | 670 | 200 | 7,028 | 7,460 | Accepted | Accepted | 70.15 | INF = 10**18
V, E = list(map(int, input().split()))
cost = [[INF]*V for i in range(V)]
for i in range(E):
s, t, d = list(map(int, input().split()))
cost[s][t] = d
for i in range(V):
cost[i][i] = 0
for k in range(V):
for i in range(V):
for j in range(V):
if cost[i][k]!=INF and cost[k][j]!=INF:
cost[i][j] = min(cost[i][j], cost[i][k] + cost[k][j])
if any(cost[i][i]<0 for i in range(V)):
print("NEGATIVE CYCLE")
else:
print("\n".join(" ".join([str(e) if e<INF else "INF" for e in e]) for e in cost)) | import sys
readline = sys.stdin.readline
writelines = sys.stdout.writelines
write = sys.stdout.write
from collections import deque
from heapq import heappush, heappop
INF = 10**30
def Johnson(G):
h = [0]*N
update = 1
for i in range(N):
update = 0
for v in range(N):
d = h[v]
for w, c in G[v]:
if c + d < h[w]:
h[w] = d + c
update = 1
if not update:
break
else:
return None
for v in range(N):
d = h[v]
g = G[v]
for j, (w, c) in enumerate(g):
g[j] = (w, c + d - h[w])
D = []
for i in range(N):
dst = [INF]*N
dst[i] = 0
que = [(0, i)]
while que:
cost, v = heappop(que)
if dst[v] < cost:
continue
for w, c in G[v]:
if cost + c < dst[w]:
dst[w] = r = cost + c
heappush(que, (r, w))
v = h[i]
for j in range(N):
if dst[j] == INF:
dst[j] = INF
else:
dst[j] -= v - h[j]
D.append(dst)
return D
N, M = list(map(int, input().split()))
G = [[] for i in range(N)]
for i in range(M):
s, t, d = list(map(int, input().split()))
G[s].append((t, d))
D = Johnson(G)
if D:
ans = []
for i in range(N):
ans.append(" ".join(str(v) if v < INF else "INF" for v in D[i]))
ans.append("\n")
writelines(ans)
else:
write("NEGATIVE CYCLE\n")
| 19 | 72 | 585 | 1,631 | INF = 10**18
V, E = list(map(int, input().split()))
cost = [[INF] * V for i in range(V)]
for i in range(E):
s, t, d = list(map(int, input().split()))
cost[s][t] = d
for i in range(V):
cost[i][i] = 0
for k in range(V):
for i in range(V):
for j in range(V):
if cost[i][k] != INF and cost[k][j] != INF:
cost[i][j] = min(cost[i][j], cost[i][k] + cost[k][j])
if any(cost[i][i] < 0 for i in range(V)):
print("NEGATIVE CYCLE")
else:
print("\n".join(" ".join([str(e) if e < INF else "INF" for e in e]) for e in cost))
| import sys
readline = sys.stdin.readline
writelines = sys.stdout.writelines
write = sys.stdout.write
from collections import deque
from heapq import heappush, heappop
INF = 10**30
def Johnson(G):
h = [0] * N
update = 1
for i in range(N):
update = 0
for v in range(N):
d = h[v]
for w, c in G[v]:
if c + d < h[w]:
h[w] = d + c
update = 1
if not update:
break
else:
return None
for v in range(N):
d = h[v]
g = G[v]
for j, (w, c) in enumerate(g):
g[j] = (w, c + d - h[w])
D = []
for i in range(N):
dst = [INF] * N
dst[i] = 0
que = [(0, i)]
while que:
cost, v = heappop(que)
if dst[v] < cost:
continue
for w, c in G[v]:
if cost + c < dst[w]:
dst[w] = r = cost + c
heappush(que, (r, w))
v = h[i]
for j in range(N):
if dst[j] == INF:
dst[j] = INF
else:
dst[j] -= v - h[j]
D.append(dst)
return D
N, M = list(map(int, input().split()))
G = [[] for i in range(N)]
for i in range(M):
s, t, d = list(map(int, input().split()))
G[s].append((t, d))
D = Johnson(G)
if D:
ans = []
for i in range(N):
ans.append(" ".join(str(v) if v < INF else "INF" for v in D[i]))
ans.append("\n")
writelines(ans)
else:
write("NEGATIVE CYCLE\n")
| false | 73.611111 | [
"-INF = 10**18",
"-V, E = list(map(int, input().split()))",
"-cost = [[INF] * V for i in range(V)]",
"-for i in range(E):",
"+import sys",
"+",
"+readline = sys.stdin.readline",
"+writelines = sys.stdout.writelines",
"+write = sys.stdout.write",
"+from collections import deque",
"+from heapq import heappush, heappop",
"+",
"+INF = 10**30",
"+",
"+",
"+def Johnson(G):",
"+ h = [0] * N",
"+ update = 1",
"+ for i in range(N):",
"+ update = 0",
"+ for v in range(N):",
"+ d = h[v]",
"+ for w, c in G[v]:",
"+ if c + d < h[w]:",
"+ h[w] = d + c",
"+ update = 1",
"+ if not update:",
"+ break",
"+ else:",
"+ return None",
"+ for v in range(N):",
"+ d = h[v]",
"+ g = G[v]",
"+ for j, (w, c) in enumerate(g):",
"+ g[j] = (w, c + d - h[w])",
"+ D = []",
"+ for i in range(N):",
"+ dst = [INF] * N",
"+ dst[i] = 0",
"+ que = [(0, i)]",
"+ while que:",
"+ cost, v = heappop(que)",
"+ if dst[v] < cost:",
"+ continue",
"+ for w, c in G[v]:",
"+ if cost + c < dst[w]:",
"+ dst[w] = r = cost + c",
"+ heappush(que, (r, w))",
"+ v = h[i]",
"+ for j in range(N):",
"+ if dst[j] == INF:",
"+ dst[j] = INF",
"+ else:",
"+ dst[j] -= v - h[j]",
"+ D.append(dst)",
"+ return D",
"+",
"+",
"+N, M = list(map(int, input().split()))",
"+G = [[] for i in range(N)]",
"+for i in range(M):",
"- cost[s][t] = d",
"-for i in range(V):",
"- cost[i][i] = 0",
"-for k in range(V):",
"- for i in range(V):",
"- for j in range(V):",
"- if cost[i][k] != INF and cost[k][j] != INF:",
"- cost[i][j] = min(cost[i][j], cost[i][k] + cost[k][j])",
"-if any(cost[i][i] < 0 for i in range(V)):",
"- print(\"NEGATIVE CYCLE\")",
"+ G[s].append((t, d))",
"+D = Johnson(G)",
"+if D:",
"+ ans = []",
"+ for i in range(N):",
"+ ans.append(\" \".join(str(v) if v < INF else \"INF\" for v in D[i]))",
"+ ans.append(\"\\n\")",
"+ writelines(ans)",
"- print(\"\\n\".join(\" \".join([str(e) if e < INF else \"INF\" for e in e]) for e in cost))",
"+ write(\"NEGATIVE CYCLE\\n\")"
] | false | 0.007851 | 0.054978 | 0.142807 | [
"s655232997",
"s999466607"
] |
u832039789 | p02801 | python | s974473379 | s348340827 | 177 | 17 | 38,384 | 2,940 | Accepted | Accepted | 90.4 | s = eval(input())
print((chr(ord(s) + 1))) | print((chr(ord(eval(input())) + 1)))
| 2 | 1 | 35 | 29 | s = eval(input())
print((chr(ord(s) + 1)))
| print((chr(ord(eval(input())) + 1)))
| false | 50 | [
"-s = eval(input())",
"-print((chr(ord(s) + 1)))",
"+print((chr(ord(eval(input())) + 1)))"
] | false | 0.041152 | 0.040624 | 1.012979 | [
"s974473379",
"s348340827"
] |
u298297089 | p03241 | python | s735479948 | s668302141 | 24 | 21 | 3,060 | 3,060 | Accepted | Accepted | 12.5 | import math
N, M = list(map(int, input().split()))
mx = 0
for i in range(1, math.floor(math.sqrt(M))+1):
if M % i == 0 and M // i >= N:
mx = max(mx, i)
if M % i == 0 and i >= N:
mx = max(mx, M//i)
print(mx) | import math
N, M = list(map(int, input().split()))
mx = 0
for i in range(1, math.floor(math.sqrt(M))+1):
if M % i == 0:
if M // i >= N:
mx = max(mx, i)
if i >= N:
mx = max(mx, M//i)
print(mx) | 9 | 10 | 232 | 238 | import math
N, M = list(map(int, input().split()))
mx = 0
for i in range(1, math.floor(math.sqrt(M)) + 1):
if M % i == 0 and M // i >= N:
mx = max(mx, i)
if M % i == 0 and i >= N:
mx = max(mx, M // i)
print(mx)
| import math
N, M = list(map(int, input().split()))
mx = 0
for i in range(1, math.floor(math.sqrt(M)) + 1):
if M % i == 0:
if M // i >= N:
mx = max(mx, i)
if i >= N:
mx = max(mx, M // i)
print(mx)
| false | 10 | [
"- if M % i == 0 and M // i >= N:",
"- mx = max(mx, i)",
"- if M % i == 0 and i >= N:",
"- mx = max(mx, M // i)",
"+ if M % i == 0:",
"+ if M // i >= N:",
"+ mx = max(mx, i)",
"+ if i >= N:",
"+ mx = max(mx, M // i)"
] | false | 0.044332 | 0.045703 | 0.970002 | [
"s735479948",
"s668302141"
] |
u912237403 | p00139 | python | s505034997 | s046878787 | 20 | 10 | 4,208 | 4,204 | Accepted | Accepted | 50 | for i in [0]*eval(input()):
s=input()
n=(len(s)-4)/2
if s==">'"+"="*n+"#"+"="*n+"~": t="A"
elif s==">^"+"Q="*n+"~~": t="B"
else: t="NA"
if n<1: t="NA"
print(t) | for i in [0]*eval(input()):
s=input()
n=(len(s)-4)/2
if n>0 and s==">'"+"="*n+"#"+"="*n+"~": t="A"
elif n>0 and s==">^"+"Q="*n+"~~": t="B"
else: t="NA"
print(t) | 8 | 7 | 177 | 175 | for i in [0] * eval(input()):
s = input()
n = (len(s) - 4) / 2
if s == ">'" + "=" * n + "#" + "=" * n + "~":
t = "A"
elif s == ">^" + "Q=" * n + "~~":
t = "B"
else:
t = "NA"
if n < 1:
t = "NA"
print(t)
| for i in [0] * eval(input()):
s = input()
n = (len(s) - 4) / 2
if n > 0 and s == ">'" + "=" * n + "#" + "=" * n + "~":
t = "A"
elif n > 0 and s == ">^" + "Q=" * n + "~~":
t = "B"
else:
t = "NA"
print(t)
| false | 12.5 | [
"- if s == \">'\" + \"=\" * n + \"#\" + \"=\" * n + \"~\":",
"+ if n > 0 and s == \">'\" + \"=\" * n + \"#\" + \"=\" * n + \"~\":",
"- elif s == \">^\" + \"Q=\" * n + \"~~\":",
"+ elif n > 0 and s == \">^\" + \"Q=\" * n + \"~~\":",
"- if n < 1:",
"- t = \"NA\""
] | false | 0.0406 | 0.047166 | 0.860773 | [
"s505034997",
"s046878787"
] |
u077291787 | p03045 | python | s122695856 | s291724339 | 443 | 184 | 113,384 | 41,292 | Accepted | Accepted | 58.47 | # ABC126E - 1 or 2
import sys
sys.setrecursionlimit(10 ** 9)
def dfs(v: int) -> None:
for u in G[v]:
if not visited[u]:
visited[u] = color
dfs(u)
def main():
global G, visited, color
N, M, *X = list(map(int, open(0).read().split()))
G = [[] for _ in range(N + 1)]
for v, u in zip(X[::3], X[1::3]):
G[v].append(u), G[u].append(v)
visited, color = [0] * (N + 1), 1
for v in range(1, N + 1):
if not visited[v]:
visited[v] = color
dfs(v)
color += 1
ans = color - 1
print(ans)
if __name__ == "__main__":
main() | # E - 1 or 2
from typing import List
def main():
def dfs(source: int) -> None:
stack = [source]
is_visited[source] = True
while stack:
u = stack.pop()
for v in graph[u]:
if is_visited[v]:
continue
is_visited[v] = True
stack.append(v)
N, M, *X = list(map(int, open(0).read().split()))
graph: List[List[int]] = [[] for _ in range(N + 1)]
for x, y, _ in zip(*[iter(X)] * 3):
graph[x].append(y), graph[y].append(x)
is_visited = [False] * (N + 1)
res = 0
for i in range(1, N + 1):
if is_visited[i]:
continue
res += 1
dfs(i)
print(res)
if __name__ == "__main__":
main()
| 31 | 33 | 660 | 792 | # ABC126E - 1 or 2
import sys
sys.setrecursionlimit(10**9)
def dfs(v: int) -> None:
for u in G[v]:
if not visited[u]:
visited[u] = color
dfs(u)
def main():
global G, visited, color
N, M, *X = list(map(int, open(0).read().split()))
G = [[] for _ in range(N + 1)]
for v, u in zip(X[::3], X[1::3]):
G[v].append(u), G[u].append(v)
visited, color = [0] * (N + 1), 1
for v in range(1, N + 1):
if not visited[v]:
visited[v] = color
dfs(v)
color += 1
ans = color - 1
print(ans)
if __name__ == "__main__":
main()
| # E - 1 or 2
from typing import List
def main():
def dfs(source: int) -> None:
stack = [source]
is_visited[source] = True
while stack:
u = stack.pop()
for v in graph[u]:
if is_visited[v]:
continue
is_visited[v] = True
stack.append(v)
N, M, *X = list(map(int, open(0).read().split()))
graph: List[List[int]] = [[] for _ in range(N + 1)]
for x, y, _ in zip(*[iter(X)] * 3):
graph[x].append(y), graph[y].append(x)
is_visited = [False] * (N + 1)
res = 0
for i in range(1, N + 1):
if is_visited[i]:
continue
res += 1
dfs(i)
print(res)
if __name__ == "__main__":
main()
| false | 6.060606 | [
"-# ABC126E - 1 or 2",
"-import sys",
"-",
"-sys.setrecursionlimit(10**9)",
"-",
"-",
"-def dfs(v: int) -> None:",
"- for u in G[v]:",
"- if not visited[u]:",
"- visited[u] = color",
"- dfs(u)",
"+# E - 1 or 2",
"+from typing import List",
"- global G, visited, color",
"+ def dfs(source: int) -> None:",
"+ stack = [source]",
"+ is_visited[source] = True",
"+ while stack:",
"+ u = stack.pop()",
"+ for v in graph[u]:",
"+ if is_visited[v]:",
"+ continue",
"+ is_visited[v] = True",
"+ stack.append(v)",
"+",
"- G = [[] for _ in range(N + 1)]",
"- for v, u in zip(X[::3], X[1::3]):",
"- G[v].append(u), G[u].append(v)",
"- visited, color = [0] * (N + 1), 1",
"- for v in range(1, N + 1):",
"- if not visited[v]:",
"- visited[v] = color",
"- dfs(v)",
"- color += 1",
"- ans = color - 1",
"- print(ans)",
"+ graph: List[List[int]] = [[] for _ in range(N + 1)]",
"+ for x, y, _ in zip(*[iter(X)] * 3):",
"+ graph[x].append(y), graph[y].append(x)",
"+ is_visited = [False] * (N + 1)",
"+ res = 0",
"+ for i in range(1, N + 1):",
"+ if is_visited[i]:",
"+ continue",
"+ res += 1",
"+ dfs(i)",
"+ print(res)"
] | false | 0.068642 | 0.079297 | 0.86563 | [
"s122695856",
"s291724339"
] |
u679520304 | p02695 | python | s382574536 | s761065329 | 391 | 148 | 84,632 | 85,160 | Accepted | Accepted | 62.15 | import itertools
N,M,Q = list(map(int,input().split()))
A = [list(map(int,input().split())) for _ in range(Q)]
com = list(itertools.combinations_with_replacement(list(range(1,M+1)),N))
answer = 0
for i in com:
ans = 0
for j in A:
if i[j[1]-1]-i[j[0]-1]==j[2]:
ans += j[3]
answer = max(answer,ans)
print(answer) | N,M,Query = list(map(int,input().split()))
from itertools import combinations_with_replacement
P = tuple(combinations_with_replacement(list(range(1,M+1)),N))
Q = []
for _ in range(Query):
a,b,c,d = list(map(int,input().split()))
Q.append((a,b,c,d))
answer = 0
for p in P:
ans = 0
for a,b,c,d in Q:
if p[b-1]-p[a-1]==c:
ans += d
answer = max(ans,answer)
print(answer) | 12 | 15 | 341 | 406 | import itertools
N, M, Q = list(map(int, input().split()))
A = [list(map(int, input().split())) for _ in range(Q)]
com = list(itertools.combinations_with_replacement(list(range(1, M + 1)), N))
answer = 0
for i in com:
ans = 0
for j in A:
if i[j[1] - 1] - i[j[0] - 1] == j[2]:
ans += j[3]
answer = max(answer, ans)
print(answer)
| N, M, Query = list(map(int, input().split()))
from itertools import combinations_with_replacement
P = tuple(combinations_with_replacement(list(range(1, M + 1)), N))
Q = []
for _ in range(Query):
a, b, c, d = list(map(int, input().split()))
Q.append((a, b, c, d))
answer = 0
for p in P:
ans = 0
for a, b, c, d in Q:
if p[b - 1] - p[a - 1] == c:
ans += d
answer = max(ans, answer)
print(answer)
| false | 20 | [
"-import itertools",
"+N, M, Query = list(map(int, input().split()))",
"+from itertools import combinations_with_replacement",
"-N, M, Q = list(map(int, input().split()))",
"-A = [list(map(int, input().split())) for _ in range(Q)]",
"-com = list(itertools.combinations_with_replacement(list(range(1, M + 1)), N))",
"-answer = 0",
"-for i in com:",
"+P = tuple(combinations_with_replacement(list(range(1, M + 1)), N))",
"+Q = []",
"+for _ in range(Query):",
"+ a, b, c, d = list(map(int, input().split()))",
"+ Q.append((a, b, c, d))",
"+ answer = 0",
"+for p in P:",
"- for j in A:",
"- if i[j[1] - 1] - i[j[0] - 1] == j[2]:",
"- ans += j[3]",
"- answer = max(answer, ans)",
"+ for a, b, c, d in Q:",
"+ if p[b - 1] - p[a - 1] == c:",
"+ ans += d",
"+ answer = max(ans, answer)"
] | false | 0.067794 | 0.120377 | 0.563182 | [
"s382574536",
"s761065329"
] |
u404676457 | p03157 | python | s476753065 | s761619887 | 933 | 648 | 5,876 | 7,028 | Accepted | Accepted | 30.55 | h, w = list(map(int, input().split()))
s = [list(eval(input())) for _ in range(h)]
m = [[0] * w for _ in range(h)]
ans = 0
for i in range(h):
for j in range(w):
if m[i][j] == 1:
continue
m[i][j] = 1
qs = [[i, j]]
white = 0
black = 0
while len(qs) != 0:
q = qs.pop(0)
if s[q[0]][q[1]] == '.':
white += 1
else:
black += 1
m[q[0]][q[1]] = 1
for k in [[1, 0], [-1, 0], [0, 1], [0, -1]]:
if not (0 <= q[0] + k[0] <= h - 1) or not (0 <= q[1] + k[1] <= w - 1):
continue
if m[q[0] + k[0]][q[1] + k[1]] == 0 and s[q[0]][q[1]] != s[q[0] + k[0]][q[1] + k[1]]:
m[q[0] + k[0]][q[1] + k[1]] = 1
qs.append([q[0] + k[0], q[1] + k[1]])
ans += black * white
print(ans) | h, w = list(map(int, input().split()))
s = [[''] * (w + 2)]
s += [[''] + list(eval(input())) + [''] for _ in range(h)]
s += [[''] * (w + 2)]
m = [[1] * (w + 2)]
m += [[1] + [0] * w + [1] for _ in range(h)]
m += [[1] * (w + 2) for _ in range(h + 2)]
ans = 0
for i in range(1, h + 1):
for j in range(1, w + 1):
if m[i][j] == 1:
continue
m[i][j] = 1
qs = [[i, j]]
white = 0
black = 0
while len(qs) != 0:
q = qs.pop(0)
if s[q[0]][q[1]] == '.':
white += 1
else:
black += 1
m[q[0]][q[1]] = 1
for k in [[1, 0], [-1, 0], [0, 1], [0, -1]]:
if m[q[0] + k[0]][q[1] + k[1]] == 0 and s[q[0]][q[1]] != s[q[0] + k[0]][q[1] + k[1]]:
m[q[0] + k[0]][q[1] + k[1]] = 1
qs.append([q[0] + k[0], q[1] + k[1]])
ans += black * white
print(ans) | 27 | 29 | 920 | 954 | h, w = list(map(int, input().split()))
s = [list(eval(input())) for _ in range(h)]
m = [[0] * w for _ in range(h)]
ans = 0
for i in range(h):
for j in range(w):
if m[i][j] == 1:
continue
m[i][j] = 1
qs = [[i, j]]
white = 0
black = 0
while len(qs) != 0:
q = qs.pop(0)
if s[q[0]][q[1]] == ".":
white += 1
else:
black += 1
m[q[0]][q[1]] = 1
for k in [[1, 0], [-1, 0], [0, 1], [0, -1]]:
if not (0 <= q[0] + k[0] <= h - 1) or not (0 <= q[1] + k[1] <= w - 1):
continue
if (
m[q[0] + k[0]][q[1] + k[1]] == 0
and s[q[0]][q[1]] != s[q[0] + k[0]][q[1] + k[1]]
):
m[q[0] + k[0]][q[1] + k[1]] = 1
qs.append([q[0] + k[0], q[1] + k[1]])
ans += black * white
print(ans)
| h, w = list(map(int, input().split()))
s = [[""] * (w + 2)]
s += [[""] + list(eval(input())) + [""] for _ in range(h)]
s += [[""] * (w + 2)]
m = [[1] * (w + 2)]
m += [[1] + [0] * w + [1] for _ in range(h)]
m += [[1] * (w + 2) for _ in range(h + 2)]
ans = 0
for i in range(1, h + 1):
for j in range(1, w + 1):
if m[i][j] == 1:
continue
m[i][j] = 1
qs = [[i, j]]
white = 0
black = 0
while len(qs) != 0:
q = qs.pop(0)
if s[q[0]][q[1]] == ".":
white += 1
else:
black += 1
m[q[0]][q[1]] = 1
for k in [[1, 0], [-1, 0], [0, 1], [0, -1]]:
if (
m[q[0] + k[0]][q[1] + k[1]] == 0
and s[q[0]][q[1]] != s[q[0] + k[0]][q[1] + k[1]]
):
m[q[0] + k[0]][q[1] + k[1]] = 1
qs.append([q[0] + k[0], q[1] + k[1]])
ans += black * white
print(ans)
| false | 6.896552 | [
"-s = [list(eval(input())) for _ in range(h)]",
"-m = [[0] * w for _ in range(h)]",
"+s = [[\"\"] * (w + 2)]",
"+s += [[\"\"] + list(eval(input())) + [\"\"] for _ in range(h)]",
"+s += [[\"\"] * (w + 2)]",
"+m = [[1] * (w + 2)]",
"+m += [[1] + [0] * w + [1] for _ in range(h)]",
"+m += [[1] * (w + 2) for _ in range(h + 2)]",
"-for i in range(h):",
"- for j in range(w):",
"+for i in range(1, h + 1):",
"+ for j in range(1, w + 1):",
"- if not (0 <= q[0] + k[0] <= h - 1) or not (0 <= q[1] + k[1] <= w - 1):",
"- continue"
] | false | 0.067498 | 0.100534 | 0.671395 | [
"s476753065",
"s761619887"
] |
u583507988 | p03289 | python | s134631271 | s222741326 | 33 | 23 | 8,980 | 9,092 | Accepted | Accepted | 30.3 | S = eval(input())
n =len(S)
s = S.lower()
if S[0] != 'A':
print('WA')
exit()
else:
for i in range(2, n-1):
if S[i] != 'C':
if S[i] != s[i]:
print('WA')
exit()
if S[n-1] != s[n-1] or S[1] != s[1]:
print('WA')
exit()
if S.count('C') != 1:
print('WA')
exit()
print('AC') | s=eval(input())
n=len(s)
t=s.lower()
if s[0]=='A' and s.count('C')==1 and s[1]!='C' and s[n-1]!='C':
cnt=0
for i in range(n):
if s[i]!=t[i]:
cnt+=1
if cnt==2:
print('AC')
exit()
print('WA') | 24 | 12 | 339 | 218 | S = eval(input())
n = len(S)
s = S.lower()
if S[0] != "A":
print("WA")
exit()
else:
for i in range(2, n - 1):
if S[i] != "C":
if S[i] != s[i]:
print("WA")
exit()
if S[n - 1] != s[n - 1] or S[1] != s[1]:
print("WA")
exit()
if S.count("C") != 1:
print("WA")
exit()
print("AC")
| s = eval(input())
n = len(s)
t = s.lower()
if s[0] == "A" and s.count("C") == 1 and s[1] != "C" and s[n - 1] != "C":
cnt = 0
for i in range(n):
if s[i] != t[i]:
cnt += 1
if cnt == 2:
print("AC")
exit()
print("WA")
| false | 50 | [
"-S = eval(input())",
"-n = len(S)",
"-s = S.lower()",
"-if S[0] != \"A\":",
"- print(\"WA\")",
"- exit()",
"-else:",
"- for i in range(2, n - 1):",
"- if S[i] != \"C\":",
"- if S[i] != s[i]:",
"- print(\"WA\")",
"- exit()",
"-if S[n - 1] != s[n - 1] or S[1] != s[1]:",
"- print(\"WA\")",
"- exit()",
"-if S.count(\"C\") != 1:",
"- print(\"WA\")",
"- exit()",
"-print(\"AC\")",
"+s = eval(input())",
"+n = len(s)",
"+t = s.lower()",
"+if s[0] == \"A\" and s.count(\"C\") == 1 and s[1] != \"C\" and s[n - 1] != \"C\":",
"+ cnt = 0",
"+ for i in range(n):",
"+ if s[i] != t[i]:",
"+ cnt += 1",
"+ if cnt == 2:",
"+ print(\"AC\")",
"+ exit()",
"+print(\"WA\")"
] | false | 0.035061 | 0.059948 | 0.58485 | [
"s134631271",
"s222741326"
] |
u375193358 | p02622 | python | s058126146 | s806408362 | 63 | 44 | 9,372 | 9,404 | Accepted | Accepted | 30.16 | S = eval(input())
T = eval(input())
if S == T:
print((0))
else:
ans = 0
for i in range(len(S)):
if S[i] != T[i]:
ans += 1
print(ans) | S = eval(input())
T = eval(input())
def solve(a,b):
ans = 0
for s,t in zip(S,T):
if s != t:
ans += 1
return ans
print((solve(S,T))) | 11 | 11 | 165 | 161 | S = eval(input())
T = eval(input())
if S == T:
print((0))
else:
ans = 0
for i in range(len(S)):
if S[i] != T[i]:
ans += 1
print(ans)
| S = eval(input())
T = eval(input())
def solve(a, b):
ans = 0
for s, t in zip(S, T):
if s != t:
ans += 1
return ans
print((solve(S, T)))
| false | 0 | [
"-if S == T:",
"- print((0))",
"-else:",
"+",
"+",
"+def solve(a, b):",
"- for i in range(len(S)):",
"- if S[i] != T[i]:",
"+ for s, t in zip(S, T):",
"+ if s != t:",
"- print(ans)",
"+ return ans",
"+",
"+",
"+print((solve(S, T)))"
] | false | 0.042527 | 0.092076 | 0.461873 | [
"s058126146",
"s806408362"
] |
u857759499 | p03504 | python | s558911337 | s963206164 | 654 | 330 | 37,688 | 18,852 | Accepted | Accepted | 49.54 | import sys
import numpy as np
input = sys.stdin.readline
n,C = list(map(int,input().split()))
a = np.zeros((C,10**5),dtype="int")
for _ in range(n):
s,t,c = list(map(int,input().split()))
a[c-1,s-1:t] = 1
print((max(np.sum(a,axis=0)))) | import sys
input = sys.stdin.readline
n,C = list(map(int,input().split()))
ch = [[] for _ in range(C)]
tmax = 0
for _ in range(n):
s,t,c = list(map(int,input().split()))
ch[c-1].append((s,t))
tmax = max(tmax,t)
ch = [sorted(i,key= lambda x:x[0]) for i in ch]
imos = [0]*(tmax+2)
for i in ch:
now = -1
for ds,dt in i:
if ds == now:
imos[ds] +=1
else:
imos[ds-1] += 1
imos[dt] -= 1
now = dt
for i in range(tmax +1):
imos[i+1] += imos[i]
print((max(imos))) | 9 | 23 | 233 | 501 | import sys
import numpy as np
input = sys.stdin.readline
n, C = list(map(int, input().split()))
a = np.zeros((C, 10**5), dtype="int")
for _ in range(n):
s, t, c = list(map(int, input().split()))
a[c - 1, s - 1 : t] = 1
print((max(np.sum(a, axis=0))))
| import sys
input = sys.stdin.readline
n, C = list(map(int, input().split()))
ch = [[] for _ in range(C)]
tmax = 0
for _ in range(n):
s, t, c = list(map(int, input().split()))
ch[c - 1].append((s, t))
tmax = max(tmax, t)
ch = [sorted(i, key=lambda x: x[0]) for i in ch]
imos = [0] * (tmax + 2)
for i in ch:
now = -1
for ds, dt in i:
if ds == now:
imos[ds] += 1
else:
imos[ds - 1] += 1
imos[dt] -= 1
now = dt
for i in range(tmax + 1):
imos[i + 1] += imos[i]
print((max(imos)))
| false | 60.869565 | [
"-import numpy as np",
"-a = np.zeros((C, 10**5), dtype=\"int\")",
"+ch = [[] for _ in range(C)]",
"+tmax = 0",
"- a[c - 1, s - 1 : t] = 1",
"-print((max(np.sum(a, axis=0))))",
"+ ch[c - 1].append((s, t))",
"+ tmax = max(tmax, t)",
"+ch = [sorted(i, key=lambda x: x[0]) for i in ch]",
"+imos = [0] * (tmax + 2)",
"+for i in ch:",
"+ now = -1",
"+ for ds, dt in i:",
"+ if ds == now:",
"+ imos[ds] += 1",
"+ else:",
"+ imos[ds - 1] += 1",
"+ imos[dt] -= 1",
"+ now = dt",
"+for i in range(tmax + 1):",
"+ imos[i + 1] += imos[i]",
"+print((max(imos)))"
] | false | 0.303232 | 0.052911 | 5.731006 | [
"s558911337",
"s963206164"
] |
u657913472 | p03185 | python | s474617575 | s560837602 | 1,989 | 1,835 | 27,120 | 27,232 | Accepted | Accepted | 7.74 | n,C,*H=list(map(int,open(0).read().split()));p=[0];P=[0]
for i in range(1,n):
h=H[i];g=lambda x,y:(p[P[y]]+H[P[y]]*(H[P[y]]-2*h)-p[P[x]]-H[P[x]]*(H[P[x]]-2*h))/(H[P[x]]-H[P[y]]);
while len(P)>1and g(1,0)>0:P.pop(0)
p+=[p[P[0]]+(H[P[0]]-h)**2+C];P+=[i];h=0
while len(P)>2and g(-1,-2)>g(-2,-3):P.pop(-2)
print((p[-1])) | n,C,*H=list(map(int,open(0).read().split()));p=[0];P=[0]
for i in range(1,n):
h=H[i];g=lambda x,y:(p[P[y]]-p[P[x]])/(H[P[x]]-H[P[y]])-H[P[y]]-H[P[x]]+2*h;
while len(P)>1and g(1,0)>0:P.pop(0)
p+=[p[P[0]]+(H[P[0]]-h)**2+C];P+=[i];h=0
while len(P)>2and g(-1,-2)>g(-2,-3):P.pop(-2)
print((p[-1])) | 7 | 7 | 318 | 294 | n, C, *H = list(map(int, open(0).read().split()))
p = [0]
P = [0]
for i in range(1, n):
h = H[i]
g = lambda x, y: (
p[P[y]] + H[P[y]] * (H[P[y]] - 2 * h) - p[P[x]] - H[P[x]] * (H[P[x]] - 2 * h)
) / (H[P[x]] - H[P[y]])
while len(P) > 1 and g(1, 0) > 0:
P.pop(0)
p += [p[P[0]] + (H[P[0]] - h) ** 2 + C]
P += [i]
h = 0
while len(P) > 2 and g(-1, -2) > g(-2, -3):
P.pop(-2)
print((p[-1]))
| n, C, *H = list(map(int, open(0).read().split()))
p = [0]
P = [0]
for i in range(1, n):
h = H[i]
g = (
lambda x, y: (p[P[y]] - p[P[x]]) / (H[P[x]] - H[P[y]])
- H[P[y]]
- H[P[x]]
+ 2 * h
)
while len(P) > 1 and g(1, 0) > 0:
P.pop(0)
p += [p[P[0]] + (H[P[0]] - h) ** 2 + C]
P += [i]
h = 0
while len(P) > 2 and g(-1, -2) > g(-2, -3):
P.pop(-2)
print((p[-1]))
| false | 0 | [
"- g = lambda x, y: (",
"- p[P[y]] + H[P[y]] * (H[P[y]] - 2 * h) - p[P[x]] - H[P[x]] * (H[P[x]] - 2 * h)",
"- ) / (H[P[x]] - H[P[y]])",
"+ g = (",
"+ lambda x, y: (p[P[y]] - p[P[x]]) / (H[P[x]] - H[P[y]])",
"+ - H[P[y]]",
"+ - H[P[x]]",
"+ + 2 * h",
"+ )"
] | false | 0.046981 | 0.075384 | 0.623229 | [
"s474617575",
"s560837602"
] |
u476604182 | p03426 | python | s262459371 | s480635903 | 1,090 | 409 | 57,564 | 46,104 | Accepted | Accepted | 62.48 | H, W, D = list(map(int, input().split()))
px = [0]*(H*W+1)
py = [0]*(H*W+1)
dp = [0]*(H*W+1)
for i in range(H):
inf = input().split()
for j in range(W):
a = int(inf[j])
py[a] = i
px[a] = j
for i in range(D+1, H*W+1):
dp[i] = dp[i-D]+abs(px[i]-px[i-D])+abs(py[i]-py[i-D])
Q = int(eval(input()))
for i in range(Q):
L, R = list(map(int, input().split()))
print((dp[R]-dp[L])) | H, W, D, *L = list(map(int, open(0).read().split()))
A = L[:W*H]
Q = L[H*W]
inf = []
for l,r in zip(*[iter(L[H*W+1:])]*2):
inf += [(l,r)]
dic = {A[i*W+j]:(i,j) for i in range(H) for j in range(W)}
ls = [[] for i in range(D)]
for i in range(D):
s = i if i!=0 else D
ls[i].append(0)
m = s
n = s
while True:
n += D
if H*W<n:
n = s
px, py = dic[m]
x, y = dic[n]
ls[i].append(ls[i][-1]+abs(px-x)+abs(py-y))
m = n
if m==s:
break
for l, r in inf:
i = l%D
if i==0:
il = (l-D)//D
ir = (r-D)//D
else:
il = (l-i)//D
ir = (r-i)//D
if l<r:
print((ls[i][ir] - ls[i][il]))
elif l>r:
print((ls[i][-1]-ls[i][il]+ls[i][ir]))
else:
print((0)) | 17 | 37 | 391 | 739 | H, W, D = list(map(int, input().split()))
px = [0] * (H * W + 1)
py = [0] * (H * W + 1)
dp = [0] * (H * W + 1)
for i in range(H):
inf = input().split()
for j in range(W):
a = int(inf[j])
py[a] = i
px[a] = j
for i in range(D + 1, H * W + 1):
dp[i] = dp[i - D] + abs(px[i] - px[i - D]) + abs(py[i] - py[i - D])
Q = int(eval(input()))
for i in range(Q):
L, R = list(map(int, input().split()))
print((dp[R] - dp[L]))
| H, W, D, *L = list(map(int, open(0).read().split()))
A = L[: W * H]
Q = L[H * W]
inf = []
for l, r in zip(*[iter(L[H * W + 1 :])] * 2):
inf += [(l, r)]
dic = {A[i * W + j]: (i, j) for i in range(H) for j in range(W)}
ls = [[] for i in range(D)]
for i in range(D):
s = i if i != 0 else D
ls[i].append(0)
m = s
n = s
while True:
n += D
if H * W < n:
n = s
px, py = dic[m]
x, y = dic[n]
ls[i].append(ls[i][-1] + abs(px - x) + abs(py - y))
m = n
if m == s:
break
for l, r in inf:
i = l % D
if i == 0:
il = (l - D) // D
ir = (r - D) // D
else:
il = (l - i) // D
ir = (r - i) // D
if l < r:
print((ls[i][ir] - ls[i][il]))
elif l > r:
print((ls[i][-1] - ls[i][il] + ls[i][ir]))
else:
print((0))
| false | 54.054054 | [
"-H, W, D = list(map(int, input().split()))",
"-px = [0] * (H * W + 1)",
"-py = [0] * (H * W + 1)",
"-dp = [0] * (H * W + 1)",
"-for i in range(H):",
"- inf = input().split()",
"- for j in range(W):",
"- a = int(inf[j])",
"- py[a] = i",
"- px[a] = j",
"-for i in range(D + 1, H * W + 1):",
"- dp[i] = dp[i - D] + abs(px[i] - px[i - D]) + abs(py[i] - py[i - D])",
"-Q = int(eval(input()))",
"-for i in range(Q):",
"- L, R = list(map(int, input().split()))",
"- print((dp[R] - dp[L]))",
"+H, W, D, *L = list(map(int, open(0).read().split()))",
"+A = L[: W * H]",
"+Q = L[H * W]",
"+inf = []",
"+for l, r in zip(*[iter(L[H * W + 1 :])] * 2):",
"+ inf += [(l, r)]",
"+dic = {A[i * W + j]: (i, j) for i in range(H) for j in range(W)}",
"+ls = [[] for i in range(D)]",
"+for i in range(D):",
"+ s = i if i != 0 else D",
"+ ls[i].append(0)",
"+ m = s",
"+ n = s",
"+ while True:",
"+ n += D",
"+ if H * W < n:",
"+ n = s",
"+ px, py = dic[m]",
"+ x, y = dic[n]",
"+ ls[i].append(ls[i][-1] + abs(px - x) + abs(py - y))",
"+ m = n",
"+ if m == s:",
"+ break",
"+for l, r in inf:",
"+ i = l % D",
"+ if i == 0:",
"+ il = (l - D) // D",
"+ ir = (r - D) // D",
"+ else:",
"+ il = (l - i) // D",
"+ ir = (r - i) // D",
"+ if l < r:",
"+ print((ls[i][ir] - ls[i][il]))",
"+ elif l > r:",
"+ print((ls[i][-1] - ls[i][il] + ls[i][ir]))",
"+ else:",
"+ print((0))"
] | false | 0.007658 | 0.03571 | 0.214456 | [
"s262459371",
"s480635903"
] |
u186426563 | p03448 | python | s026715177 | s897008783 | 61 | 18 | 3,064 | 3,060 | Accepted | Accepted | 70.49 | a, b, c, x = int(eval(input())), int(eval(input())), int(eval(input())), int(eval(input()))
ans = 0
for i in range(a+1):
for j in range(b+1):
for k in range(c+1):
if(500*i + 100*j + 50*k == x):
ans += 1
break
elif(500*i + 100*j + 50*k > x):
break
print(ans) | a, b, c, x = int(eval(input())), int(eval(input())), int(eval(input())), int(eval(input()))
ans = 0
for i in range(a+1):
if(500*i > x):
break
for j in range(b+1):
if(x - 500*i - 100*j >= 0 and (x - 500*i - 100*j) / 50 <= c):
ans += 1
print(ans) | 11 | 9 | 327 | 264 | a, b, c, x = (
int(eval(input())),
int(eval(input())),
int(eval(input())),
int(eval(input())),
)
ans = 0
for i in range(a + 1):
for j in range(b + 1):
for k in range(c + 1):
if 500 * i + 100 * j + 50 * k == x:
ans += 1
break
elif 500 * i + 100 * j + 50 * k > x:
break
print(ans)
| a, b, c, x = (
int(eval(input())),
int(eval(input())),
int(eval(input())),
int(eval(input())),
)
ans = 0
for i in range(a + 1):
if 500 * i > x:
break
for j in range(b + 1):
if x - 500 * i - 100 * j >= 0 and (x - 500 * i - 100 * j) / 50 <= c:
ans += 1
print(ans)
| false | 18.181818 | [
"+ if 500 * i > x:",
"+ break",
"- for k in range(c + 1):",
"- if 500 * i + 100 * j + 50 * k == x:",
"- ans += 1",
"- break",
"- elif 500 * i + 100 * j + 50 * k > x:",
"- break",
"+ if x - 500 * i - 100 * j >= 0 and (x - 500 * i - 100 * j) / 50 <= c:",
"+ ans += 1"
] | false | 0.04096 | 0.056304 | 0.72748 | [
"s026715177",
"s897008783"
] |
u621935300 | p03309 | python | s454398675 | s590039426 | 136 | 123 | 68,060 | 68,060 | Accepted | Accepted | 9.56 | N=eval(input())
A=list(map(int, input().split()))
B=list(range(1,N+1))
C=[]
for x,y in zip(A,B):
C.append(x-y)
C.sort()
m=0
if len(C)%2==1:
m=C[len(C)/2]
else:
m=(C[len(C)/2-1]+C[len(C)/2])/2
t=0
for x in C:
t+=abs(-1*m+x)
print(t)
| N=eval(input())
A=list(map(int, input().split()))
B=list(range(1,N+1))
C=[]
for x,y in zip(A,B):
C.append(x-y)
C.sort()
m=0
if len(C)%2==1:
m=C[len(C)/2]
else:
m=(C[len(C)/2-1]+C[len(C)/2])/2
ans=0
for x in C:
ans+=abs(-1*m+x)
print(ans)
| 21 | 21 | 248 | 254 | N = eval(input())
A = list(map(int, input().split()))
B = list(range(1, N + 1))
C = []
for x, y in zip(A, B):
C.append(x - y)
C.sort()
m = 0
if len(C) % 2 == 1:
m = C[len(C) / 2]
else:
m = (C[len(C) / 2 - 1] + C[len(C) / 2]) / 2
t = 0
for x in C:
t += abs(-1 * m + x)
print(t)
| N = eval(input())
A = list(map(int, input().split()))
B = list(range(1, N + 1))
C = []
for x, y in zip(A, B):
C.append(x - y)
C.sort()
m = 0
if len(C) % 2 == 1:
m = C[len(C) / 2]
else:
m = (C[len(C) / 2 - 1] + C[len(C) / 2]) / 2
ans = 0
for x in C:
ans += abs(-1 * m + x)
print(ans)
| false | 0 | [
"-t = 0",
"+ans = 0",
"- t += abs(-1 * m + x)",
"-print(t)",
"+ ans += abs(-1 * m + x)",
"+print(ans)"
] | false | 0.040727 | 0.035821 | 1.136957 | [
"s454398675",
"s590039426"
] |
u131638468 | p03557 | python | s940586067 | s811988295 | 1,658 | 1,453 | 23,908 | 23,372 | Accepted | Accepted | 12.36 | n=int(eval(input()))
a=list(map(int,input().split()))
b=list(map(int,input().split()))
c=list(map(int,input().split()))
a.sort()
b.sort()
c.sort()
AtoB=[0 for i in range(n)]
BtoC=[0 for i in range(n+1)]
for i in range(n):
top=a[i]
h=n
l=-1
while h-l>1:
mid=(h+l)//2
if b[mid]>top:
h=mid
else:
l=mid
if h==0 and top>b[0]:
h=-1
AtoB[i]=h #smallestB-index
for i in range(n-1,-1,-1):
top=b[i]
h=n
l=-1
while h-l>1:
mid=(h+l)//2
if c[mid]>top:
h=mid
else:
l=mid
BtoC[i]+=BtoC[i+1]+n-h #according to B,C patten
ans=0
for i in range(n):
ans+=BtoC[AtoB[i]]
print(ans) | n=int(eval(input()))
a=list(map(int,input().split()))
b=list(map(int,input().split()))
c=list(map(int,input().split()))
a.sort()
b.sort()
c.sort()
ans=0
for i in range(n):
middle=b[i]
h=n
l=-1
while h-l>1:
m=(h+l)//2
if a[m]<middle:
l=m
else:
h=m
ab=l+1
h=n
l=-1
while h-l>1:
m=(h+l)//2
if c[m]>middle:
h=m
else:
l=m
bc=n-h
ans+=ab*bc
print(ans) | 37 | 30 | 665 | 436 | n = int(eval(input()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
c = list(map(int, input().split()))
a.sort()
b.sort()
c.sort()
AtoB = [0 for i in range(n)]
BtoC = [0 for i in range(n + 1)]
for i in range(n):
top = a[i]
h = n
l = -1
while h - l > 1:
mid = (h + l) // 2
if b[mid] > top:
h = mid
else:
l = mid
if h == 0 and top > b[0]:
h = -1
AtoB[i] = h # smallestB-index
for i in range(n - 1, -1, -1):
top = b[i]
h = n
l = -1
while h - l > 1:
mid = (h + l) // 2
if c[mid] > top:
h = mid
else:
l = mid
BtoC[i] += BtoC[i + 1] + n - h # according to B,C patten
ans = 0
for i in range(n):
ans += BtoC[AtoB[i]]
print(ans)
| n = int(eval(input()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
c = list(map(int, input().split()))
a.sort()
b.sort()
c.sort()
ans = 0
for i in range(n):
middle = b[i]
h = n
l = -1
while h - l > 1:
m = (h + l) // 2
if a[m] < middle:
l = m
else:
h = m
ab = l + 1
h = n
l = -1
while h - l > 1:
m = (h + l) // 2
if c[m] > middle:
h = m
else:
l = m
bc = n - h
ans += ab * bc
print(ans)
| false | 18.918919 | [
"-AtoB = [0 for i in range(n)]",
"-BtoC = [0 for i in range(n + 1)]",
"+ans = 0",
"- top = a[i]",
"+ middle = b[i]",
"- mid = (h + l) // 2",
"- if b[mid] > top:",
"- h = mid",
"+ m = (h + l) // 2",
"+ if a[m] < middle:",
"+ l = m",
"- l = mid",
"- if h == 0 and top > b[0]:",
"- h = -1",
"- AtoB[i] = h # smallestB-index",
"-for i in range(n - 1, -1, -1):",
"- top = b[i]",
"+ h = m",
"+ ab = l + 1",
"- mid = (h + l) // 2",
"- if c[mid] > top:",
"- h = mid",
"+ m = (h + l) // 2",
"+ if c[m] > middle:",
"+ h = m",
"- l = mid",
"- BtoC[i] += BtoC[i + 1] + n - h # according to B,C patten",
"-ans = 0",
"-for i in range(n):",
"- ans += BtoC[AtoB[i]]",
"+ l = m",
"+ bc = n - h",
"+ ans += ab * bc"
] | false | 0.047309 | 0.114255 | 0.41406 | [
"s940586067",
"s811988295"
] |
u170201762 | p03165 | python | s016157450 | s804912628 | 542 | 428 | 119,772 | 112,348 | Accepted | Accepted | 21.03 | s = eval(input())
t = eval(input())
DP = [[0 for i in range(len(s)+1)] for i in range(len(t)+1)]
ans = ''
for i in range(len(t)):
for j in range(len(s)):
if t[i] == s[j]:
DP[i+1][j+1] = DP[i][j]+1
else:
DP[i+1][j+1] = max(DP[i][j+1],DP[i+1][j])
i = len(t)
j = len(s)
ans = ''
while i>=0 and j>=0:
if DP[i][j] == DP[i-1][j]:
i -= 1
elif DP[i][j] == DP[i][j-1]:
j -= 1
else:
i -= 1
j -= 1
ans = ans + t[i]
ans = ans[::-1]
print(ans) | s = eval(input())
t = eval(input())
dp = [[0]*(len(t)+1) for _ in range(len(s)+1)]
for n in range(len(s)):
for m in range(len(t)):
if s[n] == t[m]:
dp[n+1][m+1] = dp[n][m]+1
else:
dp[n+1][m+1] = max(dp[n+1][m],dp[n][m+1])
n = len(s)
m = len(t)
ans = ''
while n >= 0 and m >= 0:
if dp[n][m] == dp[n-1][m]:
n -= 1
elif dp[n][m] == dp[n][m-1]:
m -= 1
else:
ans = s[n-1]+ans
n -= 1
m -= 1
print(ans) | 26 | 25 | 541 | 506 | s = eval(input())
t = eval(input())
DP = [[0 for i in range(len(s) + 1)] for i in range(len(t) + 1)]
ans = ""
for i in range(len(t)):
for j in range(len(s)):
if t[i] == s[j]:
DP[i + 1][j + 1] = DP[i][j] + 1
else:
DP[i + 1][j + 1] = max(DP[i][j + 1], DP[i + 1][j])
i = len(t)
j = len(s)
ans = ""
while i >= 0 and j >= 0:
if DP[i][j] == DP[i - 1][j]:
i -= 1
elif DP[i][j] == DP[i][j - 1]:
j -= 1
else:
i -= 1
j -= 1
ans = ans + t[i]
ans = ans[::-1]
print(ans)
| s = eval(input())
t = eval(input())
dp = [[0] * (len(t) + 1) for _ in range(len(s) + 1)]
for n in range(len(s)):
for m in range(len(t)):
if s[n] == t[m]:
dp[n + 1][m + 1] = dp[n][m] + 1
else:
dp[n + 1][m + 1] = max(dp[n + 1][m], dp[n][m + 1])
n = len(s)
m = len(t)
ans = ""
while n >= 0 and m >= 0:
if dp[n][m] == dp[n - 1][m]:
n -= 1
elif dp[n][m] == dp[n][m - 1]:
m -= 1
else:
ans = s[n - 1] + ans
n -= 1
m -= 1
print(ans)
| false | 3.846154 | [
"-DP = [[0 for i in range(len(s) + 1)] for i in range(len(t) + 1)]",
"+dp = [[0] * (len(t) + 1) for _ in range(len(s) + 1)]",
"+for n in range(len(s)):",
"+ for m in range(len(t)):",
"+ if s[n] == t[m]:",
"+ dp[n + 1][m + 1] = dp[n][m] + 1",
"+ else:",
"+ dp[n + 1][m + 1] = max(dp[n + 1][m], dp[n][m + 1])",
"+n = len(s)",
"+m = len(t)",
"-for i in range(len(t)):",
"- for j in range(len(s)):",
"- if t[i] == s[j]:",
"- DP[i + 1][j + 1] = DP[i][j] + 1",
"- else:",
"- DP[i + 1][j + 1] = max(DP[i][j + 1], DP[i + 1][j])",
"-i = len(t)",
"-j = len(s)",
"-ans = \"\"",
"-while i >= 0 and j >= 0:",
"- if DP[i][j] == DP[i - 1][j]:",
"- i -= 1",
"- elif DP[i][j] == DP[i][j - 1]:",
"- j -= 1",
"+while n >= 0 and m >= 0:",
"+ if dp[n][m] == dp[n - 1][m]:",
"+ n -= 1",
"+ elif dp[n][m] == dp[n][m - 1]:",
"+ m -= 1",
"- i -= 1",
"- j -= 1",
"- ans = ans + t[i]",
"-ans = ans[::-1]",
"+ ans = s[n - 1] + ans",
"+ n -= 1",
"+ m -= 1"
] | false | 0.037737 | 0.036751 | 1.026843 | [
"s016157450",
"s804912628"
] |
u673361376 | p03244 | python | s346305167 | s369104236 | 148 | 112 | 23,004 | 17,644 | Accepted | Accepted | 24.32 | from collections import Counter
import heapq
N = int(eval(input()))
Vs = list(map(int,input().split()))
if len(set(Vs)) == 1:
print((N//2))
exit()
Veve, Vodd = [],[]
idx = 0
for v in Vs:
if idx%2 == 0: Veve.append(v)
else: Vodd.append(v)
idx += 1
Veve_cnt, Vodd_cnt = [], []
[heapq.heappush(Veve_cnt, [-num,val]) for val, num in list(Counter(Veve).items())]
[heapq.heappush(Vodd_cnt, [-num,val]) for val, num in list(Counter(Vodd).items())]
neg_num, val = heapq.heappop(Veve_cnt)
eve_val = val
eve_num = -neg_num
neg_num, val = heapq.heappop(Vodd_cnt)
odd_val = val
odd_num = -neg_num
if eve_val != odd_val:
print((N-eve_num-odd_num))
else:
if len(Vodd_cnt) != 0:odd_num2 = -heapq.heappop(Vodd_cnt)[0]
else:odd_num2 = -float('inf')
if len(Veve_cnt) != 0:eve_num2 = -heapq.heappop(Veve_cnt)[0]
else:eve_num2 = -float('inf')
print((min(N-eve_num2-odd_num,N-eve_num-odd_num2))) | N = int(eval(input()))
V = list(map(int, input().split()))
even_idx_cnt = {}
odd_idx_cnt = {}
for idx, v in enumerate(V):
if idx % 2 == 0:
if v not in even_idx_cnt:
even_idx_cnt[v] = 0
even_idx_cnt[v] += 1
else:
if v not in odd_idx_cnt:
odd_idx_cnt[v] = 0
odd_idx_cnt[v] += 1
if len(even_idx_cnt) == 1 and len(odd_idx_cnt) == 1:
if list(even_idx_cnt.keys()) == list(odd_idx_cnt.keys()):
print((N - even_idx_cnt[V[0]]))
else:
print((0))
exit()
even_idx_cnt = sorted(list(even_idx_cnt.items()), key=lambda x:x[1], reverse=True)
odd_idx_cnt = sorted(list(odd_idx_cnt.items()), key=lambda x:x[1], reverse=True)
if even_idx_cnt[0][0] != odd_idx_cnt[0][0]:
print((N - even_idx_cnt[0][1] - odd_idx_cnt[0][1]))
else:
ans = []
if len(odd_idx_cnt) >= 2:
ans.append(N - even_idx_cnt[0][1] - odd_idx_cnt[1][1])
if len(even_idx_cnt) >= 2:
ans.append(N - even_idx_cnt[1][1] - odd_idx_cnt[0][1])
print((min(ans)))
| 39 | 34 | 919 | 1,028 | from collections import Counter
import heapq
N = int(eval(input()))
Vs = list(map(int, input().split()))
if len(set(Vs)) == 1:
print((N // 2))
exit()
Veve, Vodd = [], []
idx = 0
for v in Vs:
if idx % 2 == 0:
Veve.append(v)
else:
Vodd.append(v)
idx += 1
Veve_cnt, Vodd_cnt = [], []
[heapq.heappush(Veve_cnt, [-num, val]) for val, num in list(Counter(Veve).items())]
[heapq.heappush(Vodd_cnt, [-num, val]) for val, num in list(Counter(Vodd).items())]
neg_num, val = heapq.heappop(Veve_cnt)
eve_val = val
eve_num = -neg_num
neg_num, val = heapq.heappop(Vodd_cnt)
odd_val = val
odd_num = -neg_num
if eve_val != odd_val:
print((N - eve_num - odd_num))
else:
if len(Vodd_cnt) != 0:
odd_num2 = -heapq.heappop(Vodd_cnt)[0]
else:
odd_num2 = -float("inf")
if len(Veve_cnt) != 0:
eve_num2 = -heapq.heappop(Veve_cnt)[0]
else:
eve_num2 = -float("inf")
print((min(N - eve_num2 - odd_num, N - eve_num - odd_num2)))
| N = int(eval(input()))
V = list(map(int, input().split()))
even_idx_cnt = {}
odd_idx_cnt = {}
for idx, v in enumerate(V):
if idx % 2 == 0:
if v not in even_idx_cnt:
even_idx_cnt[v] = 0
even_idx_cnt[v] += 1
else:
if v not in odd_idx_cnt:
odd_idx_cnt[v] = 0
odd_idx_cnt[v] += 1
if len(even_idx_cnt) == 1 and len(odd_idx_cnt) == 1:
if list(even_idx_cnt.keys()) == list(odd_idx_cnt.keys()):
print((N - even_idx_cnt[V[0]]))
else:
print((0))
exit()
even_idx_cnt = sorted(list(even_idx_cnt.items()), key=lambda x: x[1], reverse=True)
odd_idx_cnt = sorted(list(odd_idx_cnt.items()), key=lambda x: x[1], reverse=True)
if even_idx_cnt[0][0] != odd_idx_cnt[0][0]:
print((N - even_idx_cnt[0][1] - odd_idx_cnt[0][1]))
else:
ans = []
if len(odd_idx_cnt) >= 2:
ans.append(N - even_idx_cnt[0][1] - odd_idx_cnt[1][1])
if len(even_idx_cnt) >= 2:
ans.append(N - even_idx_cnt[1][1] - odd_idx_cnt[0][1])
print((min(ans)))
| false | 12.820513 | [
"-from collections import Counter",
"-import heapq",
"-",
"-Vs = list(map(int, input().split()))",
"-if len(set(Vs)) == 1:",
"- print((N // 2))",
"+V = list(map(int, input().split()))",
"+even_idx_cnt = {}",
"+odd_idx_cnt = {}",
"+for idx, v in enumerate(V):",
"+ if idx % 2 == 0:",
"+ if v not in even_idx_cnt:",
"+ even_idx_cnt[v] = 0",
"+ even_idx_cnt[v] += 1",
"+ else:",
"+ if v not in odd_idx_cnt:",
"+ odd_idx_cnt[v] = 0",
"+ odd_idx_cnt[v] += 1",
"+if len(even_idx_cnt) == 1 and len(odd_idx_cnt) == 1:",
"+ if list(even_idx_cnt.keys()) == list(odd_idx_cnt.keys()):",
"+ print((N - even_idx_cnt[V[0]]))",
"+ else:",
"+ print((0))",
"-Veve, Vodd = [], []",
"-idx = 0",
"-for v in Vs:",
"- if idx % 2 == 0:",
"- Veve.append(v)",
"- else:",
"- Vodd.append(v)",
"- idx += 1",
"-Veve_cnt, Vodd_cnt = [], []",
"-[heapq.heappush(Veve_cnt, [-num, val]) for val, num in list(Counter(Veve).items())]",
"-[heapq.heappush(Vodd_cnt, [-num, val]) for val, num in list(Counter(Vodd).items())]",
"-neg_num, val = heapq.heappop(Veve_cnt)",
"-eve_val = val",
"-eve_num = -neg_num",
"-neg_num, val = heapq.heappop(Vodd_cnt)",
"-odd_val = val",
"-odd_num = -neg_num",
"-if eve_val != odd_val:",
"- print((N - eve_num - odd_num))",
"+even_idx_cnt = sorted(list(even_idx_cnt.items()), key=lambda x: x[1], reverse=True)",
"+odd_idx_cnt = sorted(list(odd_idx_cnt.items()), key=lambda x: x[1], reverse=True)",
"+if even_idx_cnt[0][0] != odd_idx_cnt[0][0]:",
"+ print((N - even_idx_cnt[0][1] - odd_idx_cnt[0][1]))",
"- if len(Vodd_cnt) != 0:",
"- odd_num2 = -heapq.heappop(Vodd_cnt)[0]",
"- else:",
"- odd_num2 = -float(\"inf\")",
"- if len(Veve_cnt) != 0:",
"- eve_num2 = -heapq.heappop(Veve_cnt)[0]",
"- else:",
"- eve_num2 = -float(\"inf\")",
"- print((min(N - eve_num2 - odd_num, N - eve_num - odd_num2)))",
"+ ans = []",
"+ if len(odd_idx_cnt) >= 2:",
"+ ans.append(N - even_idx_cnt[0][1] - odd_idx_cnt[1][1])",
"+ if len(even_idx_cnt) >= 2:",
"+ ans.append(N - even_idx_cnt[1][1] - odd_idx_cnt[0][1])",
"+ print((min(ans)))"
] | false | 0.048655 | 0.097606 | 0.498478 | [
"s346305167",
"s369104236"
] |
u167681750 | p03476 | python | s272415984 | s156218296 | 731 | 663 | 69,592 | 15,524 | Accepted | Accepted | 9.3 | from itertools import accumulate
def is_prime(n):
if n == 1:
return False
for i in range(2, int(n ** 0.5) + 1):
if n % i == 0:
return False
return True
q = int(eval(input()))
l, r = [],[]
for _ in range(q):
t, tt = list(map(int, input().split()))
l.append(t)
r.append(tt)
m_r = max(r)
table = [0] * (m_r + 2)
for i in range(1, m_r + 1, 2):
if is_prime(i) and is_prime((i + 1) // 2):
table[i] = 1
c_table = list(accumulate(table))
for i in range(q):
print((c_table[r[i]] - c_table[l[i]-1])) | from itertools import accumulate
def is_prime(n):
if n == 1:
return False
for i in range(2, int(n ** 0.5) + 1):
if n % i == 0:
return False
return True
q = int(eval(input()))
l, r = [],[]
for _ in range(q):
t, tt = list(map(int, input().split()))
l.append(t)
r.append(tt)
m_r = max(r)
table = [0] * (m_r + 2)
for i in range(1, m_r + 1, 2):
if is_prime(i) and is_prime((i + 1) // 2):
table[i] = 1
acc_table = list(accumulate(table))
for i in range(q):
print((acc_table[r[i]] - acc_table[l[i]-1])) | 28 | 29 | 570 | 578 | from itertools import accumulate
def is_prime(n):
if n == 1:
return False
for i in range(2, int(n**0.5) + 1):
if n % i == 0:
return False
return True
q = int(eval(input()))
l, r = [], []
for _ in range(q):
t, tt = list(map(int, input().split()))
l.append(t)
r.append(tt)
m_r = max(r)
table = [0] * (m_r + 2)
for i in range(1, m_r + 1, 2):
if is_prime(i) and is_prime((i + 1) // 2):
table[i] = 1
c_table = list(accumulate(table))
for i in range(q):
print((c_table[r[i]] - c_table[l[i] - 1]))
| from itertools import accumulate
def is_prime(n):
if n == 1:
return False
for i in range(2, int(n**0.5) + 1):
if n % i == 0:
return False
return True
q = int(eval(input()))
l, r = [], []
for _ in range(q):
t, tt = list(map(int, input().split()))
l.append(t)
r.append(tt)
m_r = max(r)
table = [0] * (m_r + 2)
for i in range(1, m_r + 1, 2):
if is_prime(i) and is_prime((i + 1) // 2):
table[i] = 1
acc_table = list(accumulate(table))
for i in range(q):
print((acc_table[r[i]] - acc_table[l[i] - 1]))
| false | 3.448276 | [
"-c_table = list(accumulate(table))",
"+acc_table = list(accumulate(table))",
"- print((c_table[r[i]] - c_table[l[i] - 1]))",
"+ print((acc_table[r[i]] - acc_table[l[i] - 1]))"
] | false | 0.04908 | 0.066235 | 0.741003 | [
"s272415984",
"s156218296"
] |
u301624971 | p02802 | python | s872524513 | s372196431 | 446 | 336 | 34,740 | 37,276 | Accepted | Accepted | 24.66 |
def myAnswer(N:int,M:int,p:list,S:list) -> None:
ac = 0
wa = 0
dic = {}
for key,value in zip(p,S):
if(key in list(dic.keys())):
dic[key].append(value)
else:
dic[key] = [value]
for values in list(dic.values()):
if(("AC" in values)):
for v in values:
if(v == "AC"):
ac+=1
break
else:
wa+=1
print((ac,wa))
def modelAnswer():
tmp=1
def main():
N, M = list(map(int,input().split()))
p =[]
S = []
for _ in range(M):
tmp = list(map(str,input().split()))
p.append(tmp[0])
S.append(tmp[1])
myAnswer(N,M,p[:],S[:])
if __name__ == '__main__':
main()
|
def solve(N,M,P,S):
counterAC = 0
counterWA = 0
dic = {key:"WA" for key in set(P)}
counter = {key:0 for key in set(P)}
for p,s in zip(P,S):
if(dic[p] == "AC"):
continue
else:
if(s == "AC"):
counterAC += 1
counterWA += counter[p]
dic[p] = "AC"
else:
counter[p]+=1
print((counterAC,counterWA))
def main():
N,M = list(map(int,input().split()))
P = []
S = []
for _ in range(M):
p,s=list(map(str,input().split()))
P.append(int(p))
S.append(s)
solve(N,M,P,S)
# print(solve())
if __name__ == "__main__":
main()
| 33 | 30 | 724 | 713 | def myAnswer(N: int, M: int, p: list, S: list) -> None:
ac = 0
wa = 0
dic = {}
for key, value in zip(p, S):
if key in list(dic.keys()):
dic[key].append(value)
else:
dic[key] = [value]
for values in list(dic.values()):
if "AC" in values:
for v in values:
if v == "AC":
ac += 1
break
else:
wa += 1
print((ac, wa))
def modelAnswer():
tmp = 1
def main():
N, M = list(map(int, input().split()))
p = []
S = []
for _ in range(M):
tmp = list(map(str, input().split()))
p.append(tmp[0])
S.append(tmp[1])
myAnswer(N, M, p[:], S[:])
if __name__ == "__main__":
main()
| def solve(N, M, P, S):
counterAC = 0
counterWA = 0
dic = {key: "WA" for key in set(P)}
counter = {key: 0 for key in set(P)}
for p, s in zip(P, S):
if dic[p] == "AC":
continue
else:
if s == "AC":
counterAC += 1
counterWA += counter[p]
dic[p] = "AC"
else:
counter[p] += 1
print((counterAC, counterWA))
def main():
N, M = list(map(int, input().split()))
P = []
S = []
for _ in range(M):
p, s = list(map(str, input().split()))
P.append(int(p))
S.append(s)
solve(N, M, P, S)
# print(solve())
if __name__ == "__main__":
main()
| false | 9.090909 | [
"-def myAnswer(N: int, M: int, p: list, S: list) -> None:",
"- ac = 0",
"- wa = 0",
"- dic = {}",
"- for key, value in zip(p, S):",
"- if key in list(dic.keys()):",
"- dic[key].append(value)",
"+def solve(N, M, P, S):",
"+ counterAC = 0",
"+ counterWA = 0",
"+ dic = {key: \"WA\" for key in set(P)}",
"+ counter = {key: 0 for key in set(P)}",
"+ for p, s in zip(P, S):",
"+ if dic[p] == \"AC\":",
"+ continue",
"- dic[key] = [value]",
"- for values in list(dic.values()):",
"- if \"AC\" in values:",
"- for v in values:",
"- if v == \"AC\":",
"- ac += 1",
"- break",
"- else:",
"- wa += 1",
"- print((ac, wa))",
"-",
"-",
"-def modelAnswer():",
"- tmp = 1",
"+ if s == \"AC\":",
"+ counterAC += 1",
"+ counterWA += counter[p]",
"+ dic[p] = \"AC\"",
"+ else:",
"+ counter[p] += 1",
"+ print((counterAC, counterWA))",
"- p = []",
"+ P = []",
"- tmp = list(map(str, input().split()))",
"- p.append(tmp[0])",
"- S.append(tmp[1])",
"- myAnswer(N, M, p[:], S[:])",
"+ p, s = list(map(str, input().split()))",
"+ P.append(int(p))",
"+ S.append(s)",
"+ solve(N, M, P, S)",
"+ # print(solve())"
] | false | 0.077082 | 0.04691 | 1.643179 | [
"s872524513",
"s372196431"
] |
u887207211 | p03729 | python | s075170893 | s966301495 | 19 | 17 | 2,940 | 2,940 | Accepted | Accepted | 10.53 | A, B, C = input().split()
if(A[-1] == B[0] and B[-1] == C[0]):
print('YES')
else:
print('NO') | A, B, C = input().split()
ans = "NO"
if A[-1] == B[0] and B[-1] == C[0]:
ans = "YES"
print(ans) | 5 | 5 | 101 | 101 | A, B, C = input().split()
if A[-1] == B[0] and B[-1] == C[0]:
print("YES")
else:
print("NO")
| A, B, C = input().split()
ans = "NO"
if A[-1] == B[0] and B[-1] == C[0]:
ans = "YES"
print(ans)
| false | 0 | [
"+ans = \"NO\"",
"- print(\"YES\")",
"-else:",
"- print(\"NO\")",
"+ ans = \"YES\"",
"+print(ans)"
] | false | 0.049339 | 0.037874 | 1.302737 | [
"s075170893",
"s966301495"
] |
u228303592 | p02755 | python | s171597223 | s732783985 | 35 | 29 | 9,168 | 9,132 | Accepted | Accepted | 17.14 | a,b = list(map(int,input().split()))
ans =-1
for i in range(10000,-1,-1):
money0 = int(i*0.08)
money1= int(i*0.1)
if money0==a and money1==b:
ans = i
print(ans)
| a,b = list(map(int,input().split()))
ans =-1
for i in range(1001,-1,-1):
money0 = int(i*0.08)
money1= int(i*0.1)
if money0==a and money1==b:
ans = i
print(ans)
| 8 | 8 | 172 | 171 | a, b = list(map(int, input().split()))
ans = -1
for i in range(10000, -1, -1):
money0 = int(i * 0.08)
money1 = int(i * 0.1)
if money0 == a and money1 == b:
ans = i
print(ans)
| a, b = list(map(int, input().split()))
ans = -1
for i in range(1001, -1, -1):
money0 = int(i * 0.08)
money1 = int(i * 0.1)
if money0 == a and money1 == b:
ans = i
print(ans)
| false | 0 | [
"-for i in range(10000, -1, -1):",
"+for i in range(1001, -1, -1):"
] | false | 0.114903 | 0.035767 | 3.212586 | [
"s171597223",
"s732783985"
] |
u690536347 | p03945 | python | s298414321 | s470045726 | 173 | 45 | 39,408 | 9,104 | Accepted | Accepted | 73.99 | s=eval(input())
v=0
for i in range(1,len(s))[::-1]:
if s[i]!=s[i-1]:
v+=1
print(v) | S = eval(input())
N = len(S)
if N==1:
print((0))
else:
s = S[0]
ans=0
for i in S[1:]:
if i!=s:
s=i
ans+=1
print(ans)
| 6 | 13 | 93 | 177 | s = eval(input())
v = 0
for i in range(1, len(s))[::-1]:
if s[i] != s[i - 1]:
v += 1
print(v)
| S = eval(input())
N = len(S)
if N == 1:
print((0))
else:
s = S[0]
ans = 0
for i in S[1:]:
if i != s:
s = i
ans += 1
print(ans)
| false | 53.846154 | [
"-s = eval(input())",
"-v = 0",
"-for i in range(1, len(s))[::-1]:",
"- if s[i] != s[i - 1]:",
"- v += 1",
"-print(v)",
"+S = eval(input())",
"+N = len(S)",
"+if N == 1:",
"+ print((0))",
"+else:",
"+ s = S[0]",
"+ ans = 0",
"+ for i in S[1:]:",
"+ if i != s:",
"+ s = i",
"+ ans += 1",
"+ print(ans)"
] | false | 0.046729 | 0.036852 | 1.268014 | [
"s298414321",
"s470045726"
] |
u606878291 | p03061 | python | s916545478 | s907722037 | 854 | 113 | 21,732 | 25,024 | Accepted | Accepted | 86.77 | from collections import Counter
from functools import lru_cache
from math import gcd
@lru_cache(maxsize=None)
def get_dividers(n):
"""
正の整数 n の約数を取得する
"""
dividers = {i for i in range(1, int(n ** 0.5) + 1) if n % i == 0}
return dividers | {n // d for d in dividers}
@lru_cache(maxsize=None)
def lcm(a, b):
"""
aとbの最小公倍数を計算する
"""
return a * b // gcd(a, b)
N = int(eval(input()))
A = tuple(map(int, input().split(' ')))
counter = Counter()
for a in A:
counter.update(get_dividers(a))
ans = 1
candidates = []
for key, value in list(counter.items()):
if value == N:
ans = lcm(ans, key)
elif value == N - 1:
candidates.append(key)
if candidates:
ans = max([lcm(ans, c) for c in candidates])
print(ans)
| from math import gcd
N = int(eval(input()))
A = tuple(map(int, input().split(' ')))
left = []
right = []
left.append(A[0])
for a in A[1:]:
left.append(gcd(left[-1], a))
right.append(A[-1])
for a in A[-2::-1]:
right.append(gcd(right[-1], a))
right = list(reversed(right))
ans = [left[-2], right[1]]
for i in range(1, len(left) - 1):
ans.append(gcd(left[i - 1], right[i + 1]))
print((max(ans)))
| 43 | 24 | 807 | 428 | from collections import Counter
from functools import lru_cache
from math import gcd
@lru_cache(maxsize=None)
def get_dividers(n):
"""
正の整数 n の約数を取得する
"""
dividers = {i for i in range(1, int(n**0.5) + 1) if n % i == 0}
return dividers | {n // d for d in dividers}
@lru_cache(maxsize=None)
def lcm(a, b):
"""
aとbの最小公倍数を計算する
"""
return a * b // gcd(a, b)
N = int(eval(input()))
A = tuple(map(int, input().split(" ")))
counter = Counter()
for a in A:
counter.update(get_dividers(a))
ans = 1
candidates = []
for key, value in list(counter.items()):
if value == N:
ans = lcm(ans, key)
elif value == N - 1:
candidates.append(key)
if candidates:
ans = max([lcm(ans, c) for c in candidates])
print(ans)
| from math import gcd
N = int(eval(input()))
A = tuple(map(int, input().split(" ")))
left = []
right = []
left.append(A[0])
for a in A[1:]:
left.append(gcd(left[-1], a))
right.append(A[-1])
for a in A[-2::-1]:
right.append(gcd(right[-1], a))
right = list(reversed(right))
ans = [left[-2], right[1]]
for i in range(1, len(left) - 1):
ans.append(gcd(left[i - 1], right[i + 1]))
print((max(ans)))
| false | 44.186047 | [
"-from collections import Counter",
"-from functools import lru_cache",
"-",
"-",
"-@lru_cache(maxsize=None)",
"-def get_dividers(n):",
"- \"\"\"",
"- 正の整数 n の約数を取得する",
"- \"\"\"",
"- dividers = {i for i in range(1, int(n**0.5) + 1) if n % i == 0}",
"- return dividers | {n // d for d in dividers}",
"-",
"-",
"-@lru_cache(maxsize=None)",
"-def lcm(a, b):",
"- \"\"\"",
"- aとbの最小公倍数を計算する",
"- \"\"\"",
"- return a * b // gcd(a, b)",
"-",
"-counter = Counter()",
"-for a in A:",
"- counter.update(get_dividers(a))",
"-ans = 1",
"-candidates = []",
"-for key, value in list(counter.items()):",
"- if value == N:",
"- ans = lcm(ans, key)",
"- elif value == N - 1:",
"- candidates.append(key)",
"-if candidates:",
"- ans = max([lcm(ans, c) for c in candidates])",
"-print(ans)",
"+left = []",
"+right = []",
"+left.append(A[0])",
"+for a in A[1:]:",
"+ left.append(gcd(left[-1], a))",
"+right.append(A[-1])",
"+for a in A[-2::-1]:",
"+ right.append(gcd(right[-1], a))",
"+right = list(reversed(right))",
"+ans = [left[-2], right[1]]",
"+for i in range(1, len(left) - 1):",
"+ ans.append(gcd(left[i - 1], right[i + 1]))",
"+print((max(ans)))"
] | false | 0.035983 | 0.033534 | 1.073031 | [
"s916545478",
"s907722037"
] |
u747703115 | p03767 | python | s161200189 | s352504240 | 252 | 204 | 39,492 | 37,084 | Accepted | Accepted | 19.05 | n = int(eval(input()))
a = list(map(int, input().split()))
a.sort()
r = 0
c = 0
for i in range(1, 3*n):
if i%2 ==0:
r += a[-i]
c += 1
if c == n:
break
print(r) | n = int(eval(input()))
a = list(map(int, input().split()))
a.sort()
print((sum(a[n::2]))) | 12 | 4 | 204 | 84 | n = int(eval(input()))
a = list(map(int, input().split()))
a.sort()
r = 0
c = 0
for i in range(1, 3 * n):
if i % 2 == 0:
r += a[-i]
c += 1
if c == n:
break
print(r)
| n = int(eval(input()))
a = list(map(int, input().split()))
a.sort()
print((sum(a[n::2])))
| false | 66.666667 | [
"-r = 0",
"-c = 0",
"-for i in range(1, 3 * n):",
"- if i % 2 == 0:",
"- r += a[-i]",
"- c += 1",
"- if c == n:",
"- break",
"-print(r)",
"+print((sum(a[n::2])))"
] | false | 0.044525 | 0.084665 | 0.525893 | [
"s161200189",
"s352504240"
] |
u501451051 | p03062 | python | s218377199 | s378663150 | 98 | 77 | 20,124 | 20,144 | Accepted | Accepted | 21.43 | n = int(eval(input()))
lis = list(map(int, input().split()))
if 0 in lis:
ans = 0
for i in lis:
if i < 0:
ans += -1 * i
else:
ans += i
print(ans)
exit()
minus = [0]*n
for i in range(n):
if lis[i] < 0:
minus[i] = 1
if sum(minus) % 2 == 0:
ans = 0
for i in lis:
if i < 0:
ans += -1 * i
else:
ans += i
print(ans)
else:
ans = 0
m = 10**9+1
for i in lis:
if i < 0:
ans += -1*i
else:
ans += i
m = min(m, abs(i))
print((ans - 2*m))
| n = int(eval(input()))
lis = list(map(int, input().split()))
minus = 0
for i in range(n):
if lis[i] < 0:
minus += 1
lis[i] = lis[i]*-1
if 0 in lis or minus % 2 == 0:
print((sum(lis)))
else:
print((sum(lis) - 2*min(lis))) | 36 | 13 | 639 | 252 | n = int(eval(input()))
lis = list(map(int, input().split()))
if 0 in lis:
ans = 0
for i in lis:
if i < 0:
ans += -1 * i
else:
ans += i
print(ans)
exit()
minus = [0] * n
for i in range(n):
if lis[i] < 0:
minus[i] = 1
if sum(minus) % 2 == 0:
ans = 0
for i in lis:
if i < 0:
ans += -1 * i
else:
ans += i
print(ans)
else:
ans = 0
m = 10**9 + 1
for i in lis:
if i < 0:
ans += -1 * i
else:
ans += i
m = min(m, abs(i))
print((ans - 2 * m))
| n = int(eval(input()))
lis = list(map(int, input().split()))
minus = 0
for i in range(n):
if lis[i] < 0:
minus += 1
lis[i] = lis[i] * -1
if 0 in lis or minus % 2 == 0:
print((sum(lis)))
else:
print((sum(lis) - 2 * min(lis)))
| false | 63.888889 | [
"-if 0 in lis:",
"- ans = 0",
"- for i in lis:",
"- if i < 0:",
"- ans += -1 * i",
"- else:",
"- ans += i",
"- print(ans)",
"- exit()",
"-minus = [0] * n",
"+minus = 0",
"- minus[i] = 1",
"-if sum(minus) % 2 == 0:",
"- ans = 0",
"- for i in lis:",
"- if i < 0:",
"- ans += -1 * i",
"- else:",
"- ans += i",
"- print(ans)",
"+ minus += 1",
"+ lis[i] = lis[i] * -1",
"+if 0 in lis or minus % 2 == 0:",
"+ print((sum(lis)))",
"- ans = 0",
"- m = 10**9 + 1",
"- for i in lis:",
"- if i < 0:",
"- ans += -1 * i",
"- else:",
"- ans += i",
"- m = min(m, abs(i))",
"- print((ans - 2 * m))",
"+ print((sum(lis) - 2 * min(lis)))"
] | false | 0.065599 | 0.067589 | 0.970553 | [
"s218377199",
"s378663150"
] |
u499381410 | p02686 | python | s189323265 | s407778556 | 710 | 641 | 181,632 | 206,968 | Accepted | Accepted | 9.72 | from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor, cos, radians, pi, sin
from operator import mul
from functools import reduce
from operator import mul
sys.setrecursionlimit(2147483647)
INF = 10 ** 13
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
n = I()
A = []
B = []
for _ in range(n):
s = S()
ret = 0
ret2 = 0
for i in s:
if ret and i == ')':
ret -= 1
elif i == '(':
ret += 1
else:
ret2 += 1
if ret2 > ret:
A += [(ret, ret2)]
else:
B += [(ret, ret2)]
A.sort()
B.sort(key=lambda x:x[1], reverse=True)
L = A + B
now = 0
for x, y in L:
if x > now:
print('No')
exit()
now = now - x + y
if now:
print('No')
else:
print('Yes')
| from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor, acos, asin, atan, sqrt, tan, cos, pi
from operator import mul
from functools import reduce
from pprint import pprint
sys.setrecursionlimit(10 ** 7)
INF = 10 ** 20
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return sys.stdin.readline().strip()
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 10 ** 9 + 7
n = I()
plus = []
minus = []
for _ in range(n):
s = S()
ret = 0
ret2 = 0
for i in s:
if ret and i == ')':
ret -= 1
elif i == '(':
ret += 1
else:
ret2 += 1
if ret2 > ret:
plus += [(ret, ret2)]
else:
minus += [(ret, ret2)]
plus.sort()
minus.sort(key=lambda x:x[1], reverse=True)
L = plus + minus
now = 0
for x, y in L:
if x > now:
print("No")
exit()
now = now - x + y
if now:
print("No")
else:
print("Yes") | 65 | 64 | 1,604 | 1,578 | from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor, cos, radians, pi, sin
from operator import mul
from functools import reduce
from operator import mul
sys.setrecursionlimit(2147483647)
INF = 10**13
def LI():
return list(map(int, sys.stdin.buffer.readline().split()))
def I():
return int(sys.stdin.buffer.readline())
def LS():
return sys.stdin.buffer.readline().rstrip().decode("utf-8").split()
def S():
return sys.stdin.buffer.readline().rstrip().decode("utf-8")
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
def SRL(n):
return [list(S()) for i in range(n)]
def MSRL(n):
return [[int(j) for j in list(S())] for i in range(n)]
n = I()
A = []
B = []
for _ in range(n):
s = S()
ret = 0
ret2 = 0
for i in s:
if ret and i == ")":
ret -= 1
elif i == "(":
ret += 1
else:
ret2 += 1
if ret2 > ret:
A += [(ret, ret2)]
else:
B += [(ret, ret2)]
A.sort()
B.sort(key=lambda x: x[1], reverse=True)
L = A + B
now = 0
for x, y in L:
if x > now:
print("No")
exit()
now = now - x + y
if now:
print("No")
else:
print("Yes")
| from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor, acos, asin, atan, sqrt, tan, cos, pi
from operator import mul
from functools import reduce
from pprint import pprint
sys.setrecursionlimit(10**7)
INF = 10**20
def LI():
return list(map(int, sys.stdin.readline().split()))
def I():
return int(sys.stdin.readline())
def LS():
return sys.stdin.readline().split()
def S():
return sys.stdin.readline().strip()
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
def SRL(n):
return [list(S()) for i in range(n)]
def MSRL(n):
return [[int(j) for j in list(S())] for i in range(n)]
mod = 10**9 + 7
n = I()
plus = []
minus = []
for _ in range(n):
s = S()
ret = 0
ret2 = 0
for i in s:
if ret and i == ")":
ret -= 1
elif i == "(":
ret += 1
else:
ret2 += 1
if ret2 > ret:
plus += [(ret, ret2)]
else:
minus += [(ret, ret2)]
plus.sort()
minus.sort(key=lambda x: x[1], reverse=True)
L = plus + minus
now = 0
for x, y in L:
if x > now:
print("No")
exit()
now = now - x + y
if now:
print("No")
else:
print("Yes")
| false | 1.538462 | [
"-import math",
"-from math import factorial, ceil, floor, cos, radians, pi, sin",
"+from math import factorial, ceil, floor, acos, asin, atan, sqrt, tan, cos, pi",
"-from operator import mul",
"+from pprint import pprint",
"-sys.setrecursionlimit(2147483647)",
"-INF = 10**13",
"+sys.setrecursionlimit(10**7)",
"+INF = 10**20",
"- return list(map(int, sys.stdin.buffer.readline().split()))",
"+ return list(map(int, sys.stdin.readline().split()))",
"- return int(sys.stdin.buffer.readline())",
"+ return int(sys.stdin.readline())",
"- return sys.stdin.buffer.readline().rstrip().decode(\"utf-8\").split()",
"+ return sys.stdin.readline().split()",
"- return sys.stdin.buffer.readline().rstrip().decode(\"utf-8\")",
"+ return sys.stdin.readline().strip()",
"+mod = 10**9 + 7",
"-A = []",
"-B = []",
"+plus = []",
"+minus = []",
"- A += [(ret, ret2)]",
"+ plus += [(ret, ret2)]",
"- B += [(ret, ret2)]",
"-A.sort()",
"-B.sort(key=lambda x: x[1], reverse=True)",
"-L = A + B",
"+ minus += [(ret, ret2)]",
"+plus.sort()",
"+minus.sort(key=lambda x: x[1], reverse=True)",
"+L = plus + minus"
] | false | 0.04411 | 0.044552 | 0.990074 | [
"s189323265",
"s407778556"
] |
u633068244 | p00139 | python | s251674154 | s384076094 | 20 | 10 | 4,228 | 4,224 | Accepted | Accepted | 50 | for r in range(eval(input())):
snake=input()
L=len(snake)
if L>5 and snake == ">'" + "="*((L-4)/2) + "#" + "="*((L-4)/2) + "~":
print("A")
elif L>5 and snake == ">^" + "Q="*((L-4)/2) + "~~":
print("B")
else:
print("NA") | for r in range(eval(input())):
snake=input()
m=(len(snake)-4)/2
if m>0 and snake == ">'" + "="*m + "#" + "="*m + "~":
print("A")
elif m>0 and snake == ">^" + "Q="*m + "~~":
print("B")
else:
print("NA") | 9 | 9 | 233 | 215 | for r in range(eval(input())):
snake = input()
L = len(snake)
if L > 5 and snake == ">'" + "=" * ((L - 4) / 2) + "#" + "=" * ((L - 4) / 2) + "~":
print("A")
elif L > 5 and snake == ">^" + "Q=" * ((L - 4) / 2) + "~~":
print("B")
else:
print("NA")
| for r in range(eval(input())):
snake = input()
m = (len(snake) - 4) / 2
if m > 0 and snake == ">'" + "=" * m + "#" + "=" * m + "~":
print("A")
elif m > 0 and snake == ">^" + "Q=" * m + "~~":
print("B")
else:
print("NA")
| false | 0 | [
"- L = len(snake)",
"- if L > 5 and snake == \">'\" + \"=\" * ((L - 4) / 2) + \"#\" + \"=\" * ((L - 4) / 2) + \"~\":",
"+ m = (len(snake) - 4) / 2",
"+ if m > 0 and snake == \">'\" + \"=\" * m + \"#\" + \"=\" * m + \"~\":",
"- elif L > 5 and snake == \">^\" + \"Q=\" * ((L - 4) / 2) + \"~~\":",
"+ elif m > 0 and snake == \">^\" + \"Q=\" * m + \"~~\":"
] | false | 0.048444 | 0.04873 | 0.99413 | [
"s251674154",
"s384076094"
] |
u583507988 | p03043 | python | s611002890 | s026212420 | 47 | 37 | 2,940 | 9,196 | Accepted | Accepted | 21.28 | n, k = list(map(int, input().split()))
ans = 0
for i in range(1,n+1):
c = 0
while i<k:
i = i * 2
c += 1
ans += float(1/2)**c
print((ans/n)) | n, k = list(map(int, input().split()))
import math
ans = 0
for i in range(1,n+1):
if i < k:
t = math.log10(k/i)/math.log10(2)
if t == int(t):
ans += 1/(2**t)
else:
ans += 1/(2**(int(t+1)))
else:
ans += 1
print((ans/n)) | 11 | 15 | 159 | 260 | n, k = list(map(int, input().split()))
ans = 0
for i in range(1, n + 1):
c = 0
while i < k:
i = i * 2
c += 1
ans += float(1 / 2) ** c
print((ans / n))
| n, k = list(map(int, input().split()))
import math
ans = 0
for i in range(1, n + 1):
if i < k:
t = math.log10(k / i) / math.log10(2)
if t == int(t):
ans += 1 / (2**t)
else:
ans += 1 / (2 ** (int(t + 1)))
else:
ans += 1
print((ans / n))
| false | 26.666667 | [
"+import math",
"+",
"- c = 0",
"- while i < k:",
"- i = i * 2",
"- c += 1",
"- ans += float(1 / 2) ** c",
"+ if i < k:",
"+ t = math.log10(k / i) / math.log10(2)",
"+ if t == int(t):",
"+ ans += 1 / (2**t)",
"+ else:",
"+ ans += 1 / (2 ** (int(t + 1)))",
"+ else:",
"+ ans += 1"
] | false | 0.070916 | 0.050423 | 1.406429 | [
"s611002890",
"s026212420"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.