user_id
stringlengths 10
10
| problem_id
stringlengths 6
6
| language
stringclasses 1
value | submission_id_v0
stringlengths 10
10
| submission_id_v1
stringlengths 10
10
| cpu_time_v0
int64 10
38.3k
| cpu_time_v1
int64 0
24.7k
| memory_v0
int64 2.57k
1.02M
| memory_v1
int64 2.57k
869k
| status_v0
stringclasses 1
value | status_v1
stringclasses 1
value | improvement_frac
float64 7.51
100
| input
stringlengths 20
4.55k
| target
stringlengths 17
3.34k
| code_v0_loc
int64 1
148
| code_v1_loc
int64 1
184
| code_v0_num_chars
int64 13
4.55k
| code_v1_num_chars
int64 14
3.34k
| code_v0_no_empty_lines
stringlengths 21
6.88k
| code_v1_no_empty_lines
stringlengths 20
4.93k
| code_same
bool 1
class | relative_loc_diff_percent
float64 0
79.8
| diff
list | diff_only_import_comment
bool 1
class | measured_runtime_v0
float64 0.01
4.45
| measured_runtime_v1
float64 0.01
4.31
| runtime_lift
float64 0
359
| key
list |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
u021916304 | p02756 | python | s421211467 | s797697840 | 1,733 | 812 | 41,332 | 43,060 | Accepted | Accepted | 53.14 | s = eval(input())
n = int(eval(input()))
query = [0]*n
rev = 0
for i in range(n):
query[i] = list(map(str, input().split()))
if query[i][0] == '1':
rev = rev + 1
begin = ''
end = ''
pal = 0
for i in range(n):
if int(query[i][0]) == 1:
pal = (pal+1)%2
else:
if pal == 0:
if int(query[i][1]) == 1:
begin = query[i][2] + begin
else:
end = end + query[i][2]
else:
if int(query[i][1]) == 1:
end = end + query[i][2]
else:
begin = query[i][2] + begin
# print('--------'+str(i+1)+'th try-----')
# print('begin:'+begin)
# print('end:'+end)
# print('pal:'+str(pal))
if rev%2 == 1:
print((end[::-1]+s[::-1]+begin[::-1]))
else:
print((begin+s+end)) | from collections import deque
s = eval(input())
n = int(eval(input()))
query = [0]*n
rev = 0
for i in range(n):
query[i] = list(map(str, input().split()))
if query[i][0] == '1':
rev = rev + 1
begin = deque()
end = deque()
pal = 0
for i in range(n):
if int(query[i][0]) == 1:
pal = (pal+1)%2
else:
if pal == 0:
if int(query[i][1]) == 1:
begin.appendleft(query[i][2])
else:
end.append(query[i][2])
else:
if int(query[i][1]) == 1:
end.append(query[i][2])
else:
begin.appendleft(query[i][2])
# print('--------'+str(i+1)+'th try-----')
# print(begin)
# print(end)
# print('pal:'+str(pal))
#print(s)
if rev%2 == 1:
print((''.join(deque(reversed(end)))+s[::-1]+''.join(deque(reversed(begin)))))
else:
print((''.join(begin)+s+''.join(end))) | 35 | 39 | 838 | 938 | s = eval(input())
n = int(eval(input()))
query = [0] * n
rev = 0
for i in range(n):
query[i] = list(map(str, input().split()))
if query[i][0] == "1":
rev = rev + 1
begin = ""
end = ""
pal = 0
for i in range(n):
if int(query[i][0]) == 1:
pal = (pal + 1) % 2
else:
if pal == 0:
if int(query[i][1]) == 1:
begin = query[i][2] + begin
else:
end = end + query[i][2]
else:
if int(query[i][1]) == 1:
end = end + query[i][2]
else:
begin = query[i][2] + begin
# print('--------'+str(i+1)+'th try-----')
# print('begin:'+begin)
# print('end:'+end)
# print('pal:'+str(pal))
if rev % 2 == 1:
print((end[::-1] + s[::-1] + begin[::-1]))
else:
print((begin + s + end))
| from collections import deque
s = eval(input())
n = int(eval(input()))
query = [0] * n
rev = 0
for i in range(n):
query[i] = list(map(str, input().split()))
if query[i][0] == "1":
rev = rev + 1
begin = deque()
end = deque()
pal = 0
for i in range(n):
if int(query[i][0]) == 1:
pal = (pal + 1) % 2
else:
if pal == 0:
if int(query[i][1]) == 1:
begin.appendleft(query[i][2])
else:
end.append(query[i][2])
else:
if int(query[i][1]) == 1:
end.append(query[i][2])
else:
begin.appendleft(query[i][2])
# print('--------'+str(i+1)+'th try-----')
# print(begin)
# print(end)
# print('pal:'+str(pal))
# print(s)
if rev % 2 == 1:
print(("".join(deque(reversed(end))) + s[::-1] + "".join(deque(reversed(begin)))))
else:
print(("".join(begin) + s + "".join(end)))
| false | 10.25641 | [
"+from collections import deque",
"+",
"-begin = \"\"",
"-end = \"\"",
"+begin = deque()",
"+end = deque()",
"- begin = query[i][2] + begin",
"+ begin.appendleft(query[i][2])",
"- end = end + query[i][2]",
"+ end.append(query[i][2])",
"- end = end + query[i][2]",
"+ end.append(query[i][2])",
"- begin = query[i][2] + begin",
"+ begin.appendleft(query[i][2])",
"-# print('begin:'+begin)",
"-# print('end:'+end)",
"+# print(begin)",
"+# print(end)",
"+# print(s)",
"- print((end[::-1] + s[::-1] + begin[::-1]))",
"+ print((\"\".join(deque(reversed(end))) + s[::-1] + \"\".join(deque(reversed(begin)))))",
"- print((begin + s + end))",
"+ print((\"\".join(begin) + s + \"\".join(end)))"
] | false | 0.048234 | 0.048091 | 1.002987 | [
"s421211467",
"s797697840"
] |
u970267139 | p03557 | python | s691157434 | s635576428 | 1,688 | 324 | 23,556 | 22,452 | Accepted | Accepted | 80.81 | 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
i = []
k = []
for j in range(n):
left = n - 1
right = 0
a_mid = n // 2
while left >= right:
if a[a_mid] >= b[j]:
left = a_mid - 1
else:
right = a_mid + 1
a_mid = (left + right) // 2
i.append(a_mid + 1)
for j in range(n):
left = n - 1
right = 0
c_mid = n // 2
while left >= right:
if c[c_mid] > b[j]:
left = c_mid - 1
else:
right = c_mid + 1
c_mid = (left + right) // 2
k.append(n - c_mid - 1)
ans = sum(x * y for x, y in zip(i, k))
print(ans) | import bisect
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 j in range(n):
i = bisect.bisect_left(a, b[j])
k = n - bisect.bisect_right(c, b[j])
ans += i * k
print(ans) | 38 | 17 | 783 | 316 | 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
i = []
k = []
for j in range(n):
left = n - 1
right = 0
a_mid = n // 2
while left >= right:
if a[a_mid] >= b[j]:
left = a_mid - 1
else:
right = a_mid + 1
a_mid = (left + right) // 2
i.append(a_mid + 1)
for j in range(n):
left = n - 1
right = 0
c_mid = n // 2
while left >= right:
if c[c_mid] > b[j]:
left = c_mid - 1
else:
right = c_mid + 1
c_mid = (left + right) // 2
k.append(n - c_mid - 1)
ans = sum(x * y for x, y in zip(i, k))
print(ans)
| import bisect
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 j in range(n):
i = bisect.bisect_left(a, b[j])
k = n - bisect.bisect_right(c, b[j])
ans += i * k
print(ans)
| false | 55.263158 | [
"+import bisect",
"+",
"-i = []",
"-k = []",
"- left = n - 1",
"- right = 0",
"- a_mid = n // 2",
"- while left >= right:",
"- if a[a_mid] >= b[j]:",
"- left = a_mid - 1",
"- else:",
"- right = a_mid + 1",
"- a_mid = (left + right) // 2",
"- i.append(a_mid + 1)",
"-for j in range(n):",
"- left = n - 1",
"- right = 0",
"- c_mid = n // 2",
"- while left >= right:",
"- if c[c_mid] > b[j]:",
"- left = c_mid - 1",
"- else:",
"- right = c_mid + 1",
"- c_mid = (left + right) // 2",
"- k.append(n - c_mid - 1)",
"-ans = sum(x * y for x, y in zip(i, k))",
"+ i = bisect.bisect_left(a, b[j])",
"+ k = n - bisect.bisect_right(c, b[j])",
"+ ans += i * k"
] | false | 0.129422 | 0.173308 | 0.746774 | [
"s691157434",
"s635576428"
] |
u958506960 | p03030 | python | s926723788 | s104415418 | 30 | 26 | 9,192 | 9,144 | Accepted | Accepted | 13.33 | n = int(eval(input()))
l = []
for i in range(n):
sp = input().split()
l.append((sp[0], int(sp[1]), i+1))
a = sorted(l, key=lambda i: i[1], reverse=True)
a = sorted(a, key=lambda i: i[0])
for i in range(n):
print((a[i][2])) | n = int(eval(input()))
l = []
for i in range(n):
sp = input().split()
l.append([sp[0], int(sp[1]), i+1])
s = sorted(l, key=lambda i: (i[0], -i[1]))
for i in range(n):
print((s[i][2])) | 11 | 10 | 238 | 198 | n = int(eval(input()))
l = []
for i in range(n):
sp = input().split()
l.append((sp[0], int(sp[1]), i + 1))
a = sorted(l, key=lambda i: i[1], reverse=True)
a = sorted(a, key=lambda i: i[0])
for i in range(n):
print((a[i][2]))
| n = int(eval(input()))
l = []
for i in range(n):
sp = input().split()
l.append([sp[0], int(sp[1]), i + 1])
s = sorted(l, key=lambda i: (i[0], -i[1]))
for i in range(n):
print((s[i][2]))
| false | 9.090909 | [
"- l.append((sp[0], int(sp[1]), i + 1))",
"-a = sorted(l, key=lambda i: i[1], reverse=True)",
"-a = sorted(a, key=lambda i: i[0])",
"+ l.append([sp[0], int(sp[1]), i + 1])",
"+s = sorted(l, key=lambda i: (i[0], -i[1]))",
"- print((a[i][2]))",
"+ print((s[i][2]))"
] | false | 0.210518 | 0.088228 | 2.386066 | [
"s926723788",
"s104415418"
] |
u942893435 | p02687 | python | s024027289 | s462332215 | 21 | 19 | 9,092 | 8,948 | Accepted | Accepted | 9.52 | S = eval(input())
if(S == 'ABC'):
print('ARC')
elif(S == 'ARC'):
print('ABC')
else:
pass | S = eval(input())
if S == 'ABC':
print('ARC')
else:
print('ABC') | 7 | 5 | 94 | 66 | S = eval(input())
if S == "ABC":
print("ARC")
elif S == "ARC":
print("ABC")
else:
pass
| S = eval(input())
if S == "ABC":
print("ARC")
else:
print("ABC")
| false | 28.571429 | [
"-elif S == \"ARC\":",
"+else:",
"-else:",
"- pass"
] | false | 0.04881 | 0.046014 | 1.060768 | [
"s024027289",
"s462332215"
] |
u431981421 | p02947 | python | s290715956 | s614747660 | 741 | 376 | 25,328 | 25,328 | Accepted | Accepted | 49.26 | from collections import defaultdict
import math
N = int(eval(input()))
li = [eval(input()) for i in range(N)]
d = defaultdict(int)
def combinations_count(n, r):
return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))
count = 0
for i in li:
s = sorted(list(i))
t = "".join(s)
d[t] += 1
for i in d:
if d[i] > 1:
count += combinations_count(d[i], 2)
print(count) | from collections import defaultdict
import math
N = int(eval(input()))
li = [eval(input()) for i in range(N)]
d = defaultdict(int)
count = 0
for i in li:
s = sorted(list(i))
t = "".join(s)
if d[t] != 0:
count += d[t]
d[t] += 1
print(count) | 23 | 18 | 410 | 265 | from collections import defaultdict
import math
N = int(eval(input()))
li = [eval(input()) for i in range(N)]
d = defaultdict(int)
def combinations_count(n, r):
return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))
count = 0
for i in li:
s = sorted(list(i))
t = "".join(s)
d[t] += 1
for i in d:
if d[i] > 1:
count += combinations_count(d[i], 2)
print(count)
| from collections import defaultdict
import math
N = int(eval(input()))
li = [eval(input()) for i in range(N)]
d = defaultdict(int)
count = 0
for i in li:
s = sorted(list(i))
t = "".join(s)
if d[t] != 0:
count += d[t]
d[t] += 1
print(count)
| false | 21.73913 | [
"-",
"-",
"-def combinations_count(n, r):",
"- return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))",
"-",
"-",
"+ if d[t] != 0:",
"+ count += d[t]",
"-for i in d:",
"- if d[i] > 1:",
"- count += combinations_count(d[i], 2)"
] | false | 0.138018 | 0.048026 | 2.873833 | [
"s290715956",
"s614747660"
] |
u628335443 | p02912 | python | s735634635 | s398704768 | 1,799 | 179 | 14,480 | 14,180 | Accepted | Accepted | 90.05 | def pushHeap(array, elem):
n = len(array)
array.append(elem)
while n != 0:
i = int((n - 1) / 2)
if array[n] > array[i]:
tmp = array[n]
array[n] = array[i]
array[i] = tmp
n = i
def popHeap(array):
n = len(array) - 1
array[0] = array[n]
del array[-1]
i = 0
while 2 * i + 1 < n:
j = 2 * i + 1
if j != n - 1 and array[j] < array[j + 1]:
j += 1
if array[i] < array[j]:
tmp = array[j]
array[j] = array[i]
array[i] = tmp
i = j
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
heap_A = []
for a in A:
pushHeap(heap_A, a)
for _ in range(M):
discount_max = int(heap_A[0] / 2)
popHeap(heap_A)
pushHeap(heap_A, discount_max)
print((sum(heap_A)))
| import heapq
N, M = list(map(int, input().split()))
A = list([int(x) * -1 for x in input().split()])
heapq.heapify(A)
for _ in range(M):
a_min = heapq.heappop(A)
heapq.heappush(A, -1 * (-a_min//2))
print((-sum(A)))
| 41 | 11 | 887 | 233 | def pushHeap(array, elem):
n = len(array)
array.append(elem)
while n != 0:
i = int((n - 1) / 2)
if array[n] > array[i]:
tmp = array[n]
array[n] = array[i]
array[i] = tmp
n = i
def popHeap(array):
n = len(array) - 1
array[0] = array[n]
del array[-1]
i = 0
while 2 * i + 1 < n:
j = 2 * i + 1
if j != n - 1 and array[j] < array[j + 1]:
j += 1
if array[i] < array[j]:
tmp = array[j]
array[j] = array[i]
array[i] = tmp
i = j
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
heap_A = []
for a in A:
pushHeap(heap_A, a)
for _ in range(M):
discount_max = int(heap_A[0] / 2)
popHeap(heap_A)
pushHeap(heap_A, discount_max)
print((sum(heap_A)))
| import heapq
N, M = list(map(int, input().split()))
A = list([int(x) * -1 for x in input().split()])
heapq.heapify(A)
for _ in range(M):
a_min = heapq.heappop(A)
heapq.heappush(A, -1 * (-a_min // 2))
print((-sum(A)))
| false | 73.170732 | [
"-def pushHeap(array, elem):",
"- n = len(array)",
"- array.append(elem)",
"- while n != 0:",
"- i = int((n - 1) / 2)",
"- if array[n] > array[i]:",
"- tmp = array[n]",
"- array[n] = array[i]",
"- array[i] = tmp",
"- n = i",
"-",
"-",
"-def popHeap(array):",
"- n = len(array) - 1",
"- array[0] = array[n]",
"- del array[-1]",
"- i = 0",
"- while 2 * i + 1 < n:",
"- j = 2 * i + 1",
"- if j != n - 1 and array[j] < array[j + 1]:",
"- j += 1",
"- if array[i] < array[j]:",
"- tmp = array[j]",
"- array[j] = array[i]",
"- array[i] = tmp",
"- i = j",
"-",
"+import heapq",
"-A = list(map(int, input().split()))",
"-heap_A = []",
"-for a in A:",
"- pushHeap(heap_A, a)",
"+A = list([int(x) * -1 for x in input().split()])",
"+heapq.heapify(A)",
"- discount_max = int(heap_A[0] / 2)",
"- popHeap(heap_A)",
"- pushHeap(heap_A, discount_max)",
"-print((sum(heap_A)))",
"+ a_min = heapq.heappop(A)",
"+ heapq.heappush(A, -1 * (-a_min // 2))",
"+print((-sum(A)))"
] | false | 0.042582 | 0.041767 | 1.019504 | [
"s735634635",
"s398704768"
] |
u707124227 | p02715 | python | s292284161 | s318451772 | 307 | 121 | 12,072 | 80,832 | Accepted | Accepted | 60.59 | # ABC162
n,k=list(map(int,input().split()))
"""
3 2
->9
3 200
->10813692
100000 100000
->742202979
"""
ans = 0
xl=[0]*(k+1)
MOD = int(1e+9 + 7)
for x in range(k,0,-1):
xl[x] = pow(k // x,n, MOD)
for x in range(k,0,-1):
xl[x] -= sum([xl[i*x] for i in range(2,1 + k//x)])
ans = 0
for i in range(k+1):
ans += i * xl[i]
print((ans % MOD))
| n,k=list(map(int,input().split()))
# 1以上k以下の整数がn個
mod=int(1e+9 + 7)
d=[0]*(k+1)
ans=0
for i in range(k,0,-1):
m=k//i
d[i]=pow(m,n, mod)
d[i]-=sum([d[j*i]for j in range(2,m+1)])
ans+=(d[i]*i)%mod
print(((ans)%mod))
#print(d)
| 25 | 13 | 368 | 254 | # ABC162
n, k = list(map(int, input().split()))
"""
3 2
->9
3 200
->10813692
100000 100000
->742202979
"""
ans = 0
xl = [0] * (k + 1)
MOD = int(1e9 + 7)
for x in range(k, 0, -1):
xl[x] = pow(k // x, n, MOD)
for x in range(k, 0, -1):
xl[x] -= sum([xl[i * x] for i in range(2, 1 + k // x)])
ans = 0
for i in range(k + 1):
ans += i * xl[i]
print((ans % MOD))
| n, k = list(map(int, input().split()))
# 1以上k以下の整数がn個
mod = int(1e9 + 7)
d = [0] * (k + 1)
ans = 0
for i in range(k, 0, -1):
m = k // i
d[i] = pow(m, n, mod)
d[i] -= sum([d[j * i] for j in range(2, m + 1)])
ans += (d[i] * i) % mod
print(((ans) % mod))
# print(d)
| false | 48 | [
"-# ABC162",
"-\"\"\"",
"-3 2",
"-->9",
"-3 200",
"-->10813692",
"-100000 100000",
"-->742202979",
"-\"\"\"",
"+# 1以上k以下の整数がn個",
"+mod = int(1e9 + 7)",
"+d = [0] * (k + 1)",
"-xl = [0] * (k + 1)",
"-MOD = int(1e9 + 7)",
"-for x in range(k, 0, -1):",
"- xl[x] = pow(k // x, n, MOD)",
"-for x in range(k, 0, -1):",
"- xl[x] -= sum([xl[i * x] for i in range(2, 1 + k // x)])",
"-ans = 0",
"-for i in range(k + 1):",
"- ans += i * xl[i]",
"-print((ans % MOD))",
"+for i in range(k, 0, -1):",
"+ m = k // i",
"+ d[i] = pow(m, n, mod)",
"+ d[i] -= sum([d[j * i] for j in range(2, m + 1)])",
"+ ans += (d[i] * i) % mod",
"+print(((ans) % mod))",
"+# print(d)"
] | false | 0.123157 | 0.466281 | 0.264126 | [
"s292284161",
"s318451772"
] |
u562935282 | p03078 | python | s353652274 | s244753396 | 716 | 575 | 150,824 | 9,548 | Accepted | Accepted | 19.69 | import sys
input = sys.stdin.readline
X, Y, Z, K = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
c = list(map(int, input().split()))
d = (aa + bb for aa in a for bb in b)
d = sorted(d, reverse=True)[:K]
e = (cc + dd for cc in c for dd in d)
e = sorted(e, reverse=True)[:K]
print(('\n'.join(map(str, e)))) | import sys
input = sys.stdin.readline
X, Y, Z, K = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
c = list(map(int, input().split()))
a = list(sorted(a, reverse=True))
b = list(sorted(b, reverse=True))
c = list(sorted(c, reverse=True))
# 降順ソート
e = []
for i, aa in enumerate(a, 1):
for j, bb in enumerate(b, 1):
for k, cc in enumerate(c, 1):
if i * j * k > K: break
e.append(aa + bb + cc)
for ee in sorted(e, reverse=True)[:K]:
print(ee)
| 16 | 23 | 362 | 555 | import sys
input = sys.stdin.readline
X, Y, Z, K = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
c = list(map(int, input().split()))
d = (aa + bb for aa in a for bb in b)
d = sorted(d, reverse=True)[:K]
e = (cc + dd for cc in c for dd in d)
e = sorted(e, reverse=True)[:K]
print(("\n".join(map(str, e))))
| import sys
input = sys.stdin.readline
X, Y, Z, K = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
c = list(map(int, input().split()))
a = list(sorted(a, reverse=True))
b = list(sorted(b, reverse=True))
c = list(sorted(c, reverse=True))
# 降順ソート
e = []
for i, aa in enumerate(a, 1):
for j, bb in enumerate(b, 1):
for k, cc in enumerate(c, 1):
if i * j * k > K:
break
e.append(aa + bb + cc)
for ee in sorted(e, reverse=True)[:K]:
print(ee)
| false | 30.434783 | [
"-d = (aa + bb for aa in a for bb in b)",
"-d = sorted(d, reverse=True)[:K]",
"-e = (cc + dd for cc in c for dd in d)",
"-e = sorted(e, reverse=True)[:K]",
"-print((\"\\n\".join(map(str, e))))",
"+a = list(sorted(a, reverse=True))",
"+b = list(sorted(b, reverse=True))",
"+c = list(sorted(c, reverse=True))",
"+# 降順ソート",
"+e = []",
"+for i, aa in enumerate(a, 1):",
"+ for j, bb in enumerate(b, 1):",
"+ for k, cc in enumerate(c, 1):",
"+ if i * j * k > K:",
"+ break",
"+ e.append(aa + bb + cc)",
"+for ee in sorted(e, reverse=True)[:K]:",
"+ print(ee)"
] | false | 0.089294 | 0.007385 | 12.091261 | [
"s353652274",
"s244753396"
] |
u981931040 | p02873 | python | s125422304 | s776847678 | 407 | 344 | 27,056 | 23,336 | Accepted | Accepted | 15.48 | S = list(eval(input()))
numList = [0] * (len(S) + 1)
for i in range(len(S)):
if S[i] == '<':
numList[i + 1] = numList[i] + 1
for i in range(len(S) - 1 , -1 , -1):
if S[i] == '>':
numList[i] = max(numList[i + 1] + 1 ,numList[i])
print((sum(numList))) | S = eval(input())
ans_list = [0] * (len(S) + 1)
for i in range(len(S)):
if S[i] == '<':
ans_list[i + 1] = ans_list[i] + 1
for i in range(len(S) - 1,-1,-1):
if S[i] == '>':
ans_list[i] = max(ans_list[i + 1] + 1, ans_list[i])
print((sum(ans_list))) | 10 | 11 | 275 | 274 | S = list(eval(input()))
numList = [0] * (len(S) + 1)
for i in range(len(S)):
if S[i] == "<":
numList[i + 1] = numList[i] + 1
for i in range(len(S) - 1, -1, -1):
if S[i] == ">":
numList[i] = max(numList[i + 1] + 1, numList[i])
print((sum(numList)))
| S = eval(input())
ans_list = [0] * (len(S) + 1)
for i in range(len(S)):
if S[i] == "<":
ans_list[i + 1] = ans_list[i] + 1
for i in range(len(S) - 1, -1, -1):
if S[i] == ">":
ans_list[i] = max(ans_list[i + 1] + 1, ans_list[i])
print((sum(ans_list)))
| false | 9.090909 | [
"-S = list(eval(input()))",
"-numList = [0] * (len(S) + 1)",
"+S = eval(input())",
"+ans_list = [0] * (len(S) + 1)",
"- numList[i + 1] = numList[i] + 1",
"+ ans_list[i + 1] = ans_list[i] + 1",
"- numList[i] = max(numList[i + 1] + 1, numList[i])",
"-print((sum(numList)))",
"+ ans_list[i] = max(ans_list[i + 1] + 1, ans_list[i])",
"+print((sum(ans_list)))"
] | false | 0.035565 | 0.120047 | 0.296258 | [
"s125422304",
"s776847678"
] |
u597374218 | p03393 | python | s740404718 | s038733100 | 29 | 25 | 8,888 | 9,060 | Accepted | Accepted | 13.79 | S=eval(input())
if len(S)<26:
for char in range(ord("a"),ord("z")):
if chr(char) not in S:
break
print((S+chr(char)))
else:
stack=list(S[-1])
for s in S[len(S)-2::-1]:
if s>stack[-1]:
stack.append(s)
else:
break
if len(stack)==26:
print((-1))
else:
print((S[:-len(stack)-1]+min(s for s in stack if s>S[-len(stack)-1]))) | S=eval(input())
if len(S)<26:
for char in range(ord("a"),ord("z")):
if chr(char) not in S:
break
print((S+chr(char)))
else:
stack=list(S[-1])
for s in S[len(S)-2::-1]:
if s>stack[-1]:
stack.append(s)
else:
break
if len(stack)==26:
print((-1))
else:
print((S[0:len(S)-len(stack)-1]+min(char for char in stack if char>S[-len(stack)-1]))) | 17 | 17 | 423 | 439 | S = eval(input())
if len(S) < 26:
for char in range(ord("a"), ord("z")):
if chr(char) not in S:
break
print((S + chr(char)))
else:
stack = list(S[-1])
for s in S[len(S) - 2 :: -1]:
if s > stack[-1]:
stack.append(s)
else:
break
if len(stack) == 26:
print((-1))
else:
print((S[: -len(stack) - 1] + min(s for s in stack if s > S[-len(stack) - 1])))
| S = eval(input())
if len(S) < 26:
for char in range(ord("a"), ord("z")):
if chr(char) not in S:
break
print((S + chr(char)))
else:
stack = list(S[-1])
for s in S[len(S) - 2 :: -1]:
if s > stack[-1]:
stack.append(s)
else:
break
if len(stack) == 26:
print((-1))
else:
print(
(
S[0 : len(S) - len(stack) - 1]
+ min(char for char in stack if char > S[-len(stack) - 1])
)
)
| false | 0 | [
"- print((S[: -len(stack) - 1] + min(s for s in stack if s > S[-len(stack) - 1])))",
"+ print(",
"+ (",
"+ S[0 : len(S) - len(stack) - 1]",
"+ + min(char for char in stack if char > S[-len(stack) - 1])",
"+ )",
"+ )"
] | false | 0.084841 | 0.040259 | 2.107349 | [
"s740404718",
"s038733100"
] |
u394731058 | p02911 | python | s432763440 | s221427108 | 140 | 125 | 4,680 | 6,620 | Accepted | Accepted | 10.71 | import sys
input = sys.stdin.readline
def main():
N, K, Q = list(map(int, input().split()))
a = [0]*N
for _ in range(Q):
a[int(eval(input()))-1] += 1
for i in range(N):
if a[i] - Q + K > 0:
print('Yes')
else:
print('No')
if __name__ == '__main__':
main() | import sys
input = sys.stdin.readline
def main():
N, K, Q = list(map(int, input().split()))
a = [K-Q]*N
for _ in range(Q):
a[int(eval(input()))-1] += 1
for i in range(N):
if a[i] > 0:
print('Yes')
else:
print('No')
if __name__ == '__main__':
main() | 17 | 17 | 329 | 323 | import sys
input = sys.stdin.readline
def main():
N, K, Q = list(map(int, input().split()))
a = [0] * N
for _ in range(Q):
a[int(eval(input())) - 1] += 1
for i in range(N):
if a[i] - Q + K > 0:
print("Yes")
else:
print("No")
if __name__ == "__main__":
main()
| import sys
input = sys.stdin.readline
def main():
N, K, Q = list(map(int, input().split()))
a = [K - Q] * N
for _ in range(Q):
a[int(eval(input())) - 1] += 1
for i in range(N):
if a[i] > 0:
print("Yes")
else:
print("No")
if __name__ == "__main__":
main()
| false | 0 | [
"- a = [0] * N",
"+ a = [K - Q] * N",
"- if a[i] - Q + K > 0:",
"+ if a[i] > 0:"
] | false | 0.043745 | 0.040863 | 1.070533 | [
"s432763440",
"s221427108"
] |
u546338822 | p02684 | python | s660367847 | s680273646 | 140 | 128 | 32,260 | 32,232 | Accepted | Accepted | 8.57 | def main():
n,k = list(map(int,input().split()))
a = list(map(int,input().split()))
visited = [0 for i in range(n)]
visit = [0]
visited[0]=1
s = 0
while True:
s = a[s]-1
if visited[s]==1:
x = visit[0:visit.index(s)]
y = visit[visit.index(s):]
break
visit.append(s)
visited[s]=1
if k<len(x):
print((x[k]+1))
else:
k = k-len(x)
print((y[k%len(y)]+1))
if __name__ == "__main__":
main()
| def main():
n,k = list(map(int,input().split()))
a = list(map(int,input().split()))
vis = [0 for i in range(n)]
vis[0] = 1
fst = [1]
st = a[0]-1
while True:
if vis[st] == 0:
vis[st] = 1
fst.append(st+1)
st = a[st]-1
else:
st = fst.index(st+1)
loop = fst[st:]
break
if k < len(fst):
print((fst[k]))
else:
k = k - len(fst) + 1
k = k%len(loop)
print((loop[k-1]))
if __name__ == "__main__":
main()
| 25 | 26 | 532 | 575 | def main():
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
visited = [0 for i in range(n)]
visit = [0]
visited[0] = 1
s = 0
while True:
s = a[s] - 1
if visited[s] == 1:
x = visit[0 : visit.index(s)]
y = visit[visit.index(s) :]
break
visit.append(s)
visited[s] = 1
if k < len(x):
print((x[k] + 1))
else:
k = k - len(x)
print((y[k % len(y)] + 1))
if __name__ == "__main__":
main()
| def main():
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
vis = [0 for i in range(n)]
vis[0] = 1
fst = [1]
st = a[0] - 1
while True:
if vis[st] == 0:
vis[st] = 1
fst.append(st + 1)
st = a[st] - 1
else:
st = fst.index(st + 1)
loop = fst[st:]
break
if k < len(fst):
print((fst[k]))
else:
k = k - len(fst) + 1
k = k % len(loop)
print((loop[k - 1]))
if __name__ == "__main__":
main()
| false | 3.846154 | [
"- visited = [0 for i in range(n)]",
"- visit = [0]",
"- visited[0] = 1",
"- s = 0",
"+ vis = [0 for i in range(n)]",
"+ vis[0] = 1",
"+ fst = [1]",
"+ st = a[0] - 1",
"- s = a[s] - 1",
"- if visited[s] == 1:",
"- x = visit[0 : visit.index(s)]",
"- y = visit[visit.index(s) :]",
"+ if vis[st] == 0:",
"+ vis[st] = 1",
"+ fst.append(st + 1)",
"+ st = a[st] - 1",
"+ else:",
"+ st = fst.index(st + 1)",
"+ loop = fst[st:]",
"- visit.append(s)",
"- visited[s] = 1",
"- if k < len(x):",
"- print((x[k] + 1))",
"+ if k < len(fst):",
"+ print((fst[k]))",
"- k = k - len(x)",
"- print((y[k % len(y)] + 1))",
"+ k = k - len(fst) + 1",
"+ k = k % len(loop)",
"+ print((loop[k - 1]))"
] | false | 0.038133 | 0.046351 | 0.822698 | [
"s660367847",
"s680273646"
] |
u047796752 | p02743 | python | s141066541 | s140313525 | 96 | 72 | 61,284 | 61,296 | Accepted | Accepted | 25 | a, b, c = list(map(int, input().split()))
if c-a-b>0 and 4*a*b<(c-a-b)**2:
print('Yes')
else:
print('No') | a, b, c = list(map(int, input().split()))
if c-a-b>=0 and 4*a*b<(c-a-b)**2:
print('Yes')
else:
print('No') | 6 | 6 | 113 | 114 | a, b, c = list(map(int, input().split()))
if c - a - b > 0 and 4 * a * b < (c - a - b) ** 2:
print("Yes")
else:
print("No")
| a, b, c = list(map(int, input().split()))
if c - a - b >= 0 and 4 * a * b < (c - a - b) ** 2:
print("Yes")
else:
print("No")
| false | 0 | [
"-if c - a - b > 0 and 4 * a * b < (c - a - b) ** 2:",
"+if c - a - b >= 0 and 4 * a * b < (c - a - b) ** 2:"
] | false | 0.108244 | 0.0474 | 2.283608 | [
"s141066541",
"s140313525"
] |
u564902833 | p03045 | python | s275747186 | s571148301 | 950 | 726 | 135,616 | 63,760 | Accepted | Accepted | 23.58 | import sys
sys.setrecursionlimit(2*10**5)
N, M = list(map(int, input().split()))
X, Y, Z = (
list(zip(*(list(map(int, input().split())) for _ in range(M)))) if M else
((), ())
)
G = [set() for _ in range(N + 1)]
for x, y in zip(X, Y):
G[x].add(y)
G[y].add(x)
dp = [-1 for _ in range(N + 1)]
def f(i, k):
for t in G[i]:
if dp[t] == -1:
dp[t] = k
f(t, k)
L = 0
for i in range(1, N + 1):
if dp[i] == -1:
L += 1
f(i, L)
ans = L
print(ans)
| # 入力
N, M = list(map(int, input().split()))
X, Y, Z = (
list(zip(*(list(map(int, input().split())) for _ in range(M)))) if M else
((), (), ())
)
# UnionFind木で連結成分の個数を数える
class UnionFindTree:
def __init__(self, n):
self.p = [i for i in range(n + 1)]
self.r = [0 for _ in range(n + 1)]
def find(self, x):
if self.p[x] != x:
self.p[x] = self.find(self.p[x])
return self.p[x]
def union(self, x, y):
px = self.find(x)
py = self.find(y)
if px != py:
if self.r[px] < self.r[py]:
self.p[px] = py
else:
self.p[py] = px
if self.r[px] == self.r[py]:
self.r[px] += 1
def same(self, x, y):
return self.find(x) == self.find(y)
uft = UnionFindTree(N)
for x, y in zip(X, Y):
uft.union(x, y)
ans = len({uft.find(i) for i in range(1, N + 1)})
# 出力
print(ans)
| 33 | 41 | 530 | 967 | import sys
sys.setrecursionlimit(2 * 10**5)
N, M = list(map(int, input().split()))
X, Y, Z = (
list(zip(*(list(map(int, input().split())) for _ in range(M)))) if M else ((), ())
)
G = [set() for _ in range(N + 1)]
for x, y in zip(X, Y):
G[x].add(y)
G[y].add(x)
dp = [-1 for _ in range(N + 1)]
def f(i, k):
for t in G[i]:
if dp[t] == -1:
dp[t] = k
f(t, k)
L = 0
for i in range(1, N + 1):
if dp[i] == -1:
L += 1
f(i, L)
ans = L
print(ans)
| # 入力
N, M = list(map(int, input().split()))
X, Y, Z = (
list(zip(*(list(map(int, input().split())) for _ in range(M))))
if M
else ((), (), ())
)
# UnionFind木で連結成分の個数を数える
class UnionFindTree:
def __init__(self, n):
self.p = [i for i in range(n + 1)]
self.r = [0 for _ in range(n + 1)]
def find(self, x):
if self.p[x] != x:
self.p[x] = self.find(self.p[x])
return self.p[x]
def union(self, x, y):
px = self.find(x)
py = self.find(y)
if px != py:
if self.r[px] < self.r[py]:
self.p[px] = py
else:
self.p[py] = px
if self.r[px] == self.r[py]:
self.r[px] += 1
def same(self, x, y):
return self.find(x) == self.find(y)
uft = UnionFindTree(N)
for x, y in zip(X, Y):
uft.union(x, y)
ans = len({uft.find(i) for i in range(1, N + 1)})
# 出力
print(ans)
| false | 19.512195 | [
"-import sys",
"-",
"-sys.setrecursionlimit(2 * 10**5)",
"+# 入力",
"- list(zip(*(list(map(int, input().split())) for _ in range(M)))) if M else ((), ())",
"+ list(zip(*(list(map(int, input().split())) for _ in range(M))))",
"+ if M",
"+ else ((), (), ())",
"-G = [set() for _ in range(N + 1)]",
"-for x, y in zip(X, Y):",
"- G[x].add(y)",
"- G[y].add(x)",
"-dp = [-1 for _ in range(N + 1)]",
"+# UnionFind木で連結成分の個数を数える",
"+class UnionFindTree:",
"+ def __init__(self, n):",
"+ self.p = [i for i in range(n + 1)]",
"+ self.r = [0 for _ in range(n + 1)]",
"+",
"+ def find(self, x):",
"+ if self.p[x] != x:",
"+ self.p[x] = self.find(self.p[x])",
"+ return self.p[x]",
"+",
"+ def union(self, x, y):",
"+ px = self.find(x)",
"+ py = self.find(y)",
"+ if px != py:",
"+ if self.r[px] < self.r[py]:",
"+ self.p[px] = py",
"+ else:",
"+ self.p[py] = px",
"+ if self.r[px] == self.r[py]:",
"+ self.r[px] += 1",
"+",
"+ def same(self, x, y):",
"+ return self.find(x) == self.find(y)",
"-def f(i, k):",
"- for t in G[i]:",
"- if dp[t] == -1:",
"- dp[t] = k",
"- f(t, k)",
"-",
"-",
"-L = 0",
"-for i in range(1, N + 1):",
"- if dp[i] == -1:",
"- L += 1",
"- f(i, L)",
"-ans = L",
"+uft = UnionFindTree(N)",
"+for x, y in zip(X, Y):",
"+ uft.union(x, y)",
"+ans = len({uft.find(i) for i in range(1, N + 1)})",
"+# 出力"
] | false | 0.063015 | 0.167867 | 0.375388 | [
"s275747186",
"s571148301"
] |
u554781254 | p03478 | python | s171328089 | s811768942 | 207 | 188 | 42,476 | 39,024 | Accepted | Accepted | 9.18 | import sys
input = sys.stdin.readline
INF = float('inf')
def number2digits(number):
return list(map(int, str(number)))
def main():
N, A, B = list(map(int, input().split()))
ans = 0
for number in range(1, N+1):
num_digits_list = number2digits(number)
total = 0
for i in num_digits_list:
total += int(i)
if A <= total <= B:
ans += number
print(ans)
if __name__ == '__main__':
main()
| import sys
input = sys.stdin.readline
INF = float('inf')
def number2digits(number):
return list(map(int, str(number)))
def sum_of_digits(number):
sum = 0
while number > 0:
sum += number % 10
number //= 10
return sum
def main():
N, A, B = list(map(int, input().split()))
ans = 0
for number in range(1, N+1):
total = sum_of_digits(number)
if A <= total <= B:
ans += number
print(ans)
if __name__ == '__main__':
main()
| 25 | 31 | 486 | 530 | import sys
input = sys.stdin.readline
INF = float("inf")
def number2digits(number):
return list(map(int, str(number)))
def main():
N, A, B = list(map(int, input().split()))
ans = 0
for number in range(1, N + 1):
num_digits_list = number2digits(number)
total = 0
for i in num_digits_list:
total += int(i)
if A <= total <= B:
ans += number
print(ans)
if __name__ == "__main__":
main()
| import sys
input = sys.stdin.readline
INF = float("inf")
def number2digits(number):
return list(map(int, str(number)))
def sum_of_digits(number):
sum = 0
while number > 0:
sum += number % 10
number //= 10
return sum
def main():
N, A, B = list(map(int, input().split()))
ans = 0
for number in range(1, N + 1):
total = sum_of_digits(number)
if A <= total <= B:
ans += number
print(ans)
if __name__ == "__main__":
main()
| false | 19.354839 | [
"+def sum_of_digits(number):",
"+ sum = 0",
"+ while number > 0:",
"+ sum += number % 10",
"+ number //= 10",
"+ return sum",
"+",
"+",
"- num_digits_list = number2digits(number)",
"- total = 0",
"- for i in num_digits_list:",
"- total += int(i)",
"+ total = sum_of_digits(number)"
] | false | 0.036387 | 0.054257 | 0.670637 | [
"s171328089",
"s811768942"
] |
u342869120 | p02991 | python | s599043708 | s503351872 | 394 | 351 | 40,408 | 111,356 | Accepted | Accepted | 10.91 | from collections import defaultdict, deque
def kenkenpa(s, visited):
res = []
for v1 in e[s]:
if visited[v1][1]:
continue
visited[v1][1] = True
for v2 in e[v1]:
if visited[v2][2]:
continue
visited[v2][2] = True
for v3 in e[v2]:
if visited[v3][0]:
continue
visited[v3][0] = True
res.append(v3)
return res
N, M = list(map(int, input().split()))
e = defaultdict(list)
for i in range(M):
u, v = list(map(int, input().split()))
e[u].append(v)
S, T = list(map(int, input().split()))
q = deque([[S, 0]])
visited = [[False]*3 for _ in range(N+1)]
visited[S][0] = True
ans = -1
while q:
u, c = q.popleft()
if u == T:
ans = c
break
l = kenkenpa(u, visited)
for v in l:
q.append([v, c+1])
print(ans)
| from collections import defaultdict, deque
N, M = list(map(int, input().split()))
e = defaultdict(list)
for i in range(M):
u, v = list(map(int, input().split()))
e[u].append(v)
'''
頂点を%3で考える(1つの頂点にを3つに分解する)
(u,0)->(v,1)
(v,1)->(u,2)
(u,2)->(v,0)
'''
S, T = list(map(int, input().split()))
q = deque([[S, 0]])
dist = [[-3]*3 for _ in range(N+1)]
dist[S][0] = 0
while q:
u, c = q.popleft()
for v in e[u]:
step = (c+1) % 3
if dist[v][step] < 0:
dist[v][step] = c+1
q.append([v, c+1])
print((dist[T][0]//3)) | 41 | 28 | 932 | 570 | from collections import defaultdict, deque
def kenkenpa(s, visited):
res = []
for v1 in e[s]:
if visited[v1][1]:
continue
visited[v1][1] = True
for v2 in e[v1]:
if visited[v2][2]:
continue
visited[v2][2] = True
for v3 in e[v2]:
if visited[v3][0]:
continue
visited[v3][0] = True
res.append(v3)
return res
N, M = list(map(int, input().split()))
e = defaultdict(list)
for i in range(M):
u, v = list(map(int, input().split()))
e[u].append(v)
S, T = list(map(int, input().split()))
q = deque([[S, 0]])
visited = [[False] * 3 for _ in range(N + 1)]
visited[S][0] = True
ans = -1
while q:
u, c = q.popleft()
if u == T:
ans = c
break
l = kenkenpa(u, visited)
for v in l:
q.append([v, c + 1])
print(ans)
| from collections import defaultdict, deque
N, M = list(map(int, input().split()))
e = defaultdict(list)
for i in range(M):
u, v = list(map(int, input().split()))
e[u].append(v)
"""
頂点を%3で考える(1つの頂点にを3つに分解する)
(u,0)->(v,1)
(v,1)->(u,2)
(u,2)->(v,0)
"""
S, T = list(map(int, input().split()))
q = deque([[S, 0]])
dist = [[-3] * 3 for _ in range(N + 1)]
dist[S][0] = 0
while q:
u, c = q.popleft()
for v in e[u]:
step = (c + 1) % 3
if dist[v][step] < 0:
dist[v][step] = c + 1
q.append([v, c + 1])
print((dist[T][0] // 3))
| false | 31.707317 | [
"-",
"-",
"-def kenkenpa(s, visited):",
"- res = []",
"- for v1 in e[s]:",
"- if visited[v1][1]:",
"- continue",
"- visited[v1][1] = True",
"- for v2 in e[v1]:",
"- if visited[v2][2]:",
"- continue",
"- visited[v2][2] = True",
"- for v3 in e[v2]:",
"- if visited[v3][0]:",
"- continue",
"- visited[v3][0] = True",
"- res.append(v3)",
"- return res",
"-",
"+\"\"\"",
"+頂点を%3で考える(1つの頂点にを3つに分解する)",
"+(u,0)->(v,1)",
"+(v,1)->(u,2)",
"+(u,2)->(v,0)",
"+\"\"\"",
"-visited = [[False] * 3 for _ in range(N + 1)]",
"-visited[S][0] = True",
"-ans = -1",
"+dist = [[-3] * 3 for _ in range(N + 1)]",
"+dist[S][0] = 0",
"- if u == T:",
"- ans = c",
"- break",
"- l = kenkenpa(u, visited)",
"- for v in l:",
"- q.append([v, c + 1])",
"-print(ans)",
"+ for v in e[u]:",
"+ step = (c + 1) % 3",
"+ if dist[v][step] < 0:",
"+ dist[v][step] = c + 1",
"+ q.append([v, c + 1])",
"+print((dist[T][0] // 3))"
] | false | 0.059672 | 0.036126 | 1.65175 | [
"s599043708",
"s503351872"
] |
u816631826 | p02711 | python | s764739751 | s623675352 | 26 | 23 | 8,780 | 8,740 | Accepted | Accepted | 11.54 | num = eval(input())
if '7' in list(num):
print('Yes')
else:
print('No')
| in_set = set(eval(input()))
if '7' in in_set:
print('Yes')
else:
print('No') | 5 | 5 | 78 | 82 | num = eval(input())
if "7" in list(num):
print("Yes")
else:
print("No")
| in_set = set(eval(input()))
if "7" in in_set:
print("Yes")
else:
print("No")
| false | 0 | [
"-num = eval(input())",
"-if \"7\" in list(num):",
"+in_set = set(eval(input()))",
"+if \"7\" in in_set:"
] | false | 0.043466 | 0.079619 | 0.545922 | [
"s764739751",
"s623675352"
] |
u018679195 | p03813 | python | s835120070 | s139306204 | 49 | 17 | 5,868 | 3,064 | Accepted | Accepted | 65.31 | import sys
import math
import random
import threading
import time
from functools import reduce
a = int(eval(input()));
if a < 1200:
print("ABC")
else:
print("ARC"); | x=int(eval(input()))
if (x>=1200):
print('ARC')
else:
print('ABC')
| 13 | 5 | 180 | 73 | import sys
import math
import random
import threading
import time
from functools import reduce
a = int(eval(input()))
if a < 1200:
print("ABC")
else:
print("ARC")
| x = int(eval(input()))
if x >= 1200:
print("ARC")
else:
print("ABC")
| false | 61.538462 | [
"-import sys",
"-import math",
"-import random",
"-import threading",
"-import time",
"-from functools import reduce",
"-",
"-a = int(eval(input()))",
"-if a < 1200:",
"+x = int(eval(input()))",
"+if x >= 1200:",
"+ print(\"ARC\")",
"+else:",
"-else:",
"- print(\"ARC\")"
] | false | 0.043245 | 0.033443 | 1.293106 | [
"s835120070",
"s139306204"
] |
u255673886 | p02837 | python | s329875626 | s903487698 | 498 | 433 | 45,532 | 44,396 | Accepted | Accepted | 13.05 | import sys
input = sys.stdin.readline
n = int(eval(input()))
a = []
xy = []
for i in range(n):
a.append(int(eval(input())))
xy.append([ list(map(int,input().split())) for _ in range(a[i]) ])
# print(a)
# print(xy)
ls = [-1]*n
ans = 0
for i in range(2**n):
b = str(bin(i))[2:]
c = b.zfill(n)
# print(c)
numbers = sum(list(map(int,list(str(c)))))
for j in range(n):
if c[j]=="0":
pass
else:
for k in range(a[j]):
x = xy[j][k][0]
y = xy[j][k][1]
# print(x,y)
if c[x-1]==str(y):
pass
else:
numbers = 0
# print("--")
ans = max(ans,numbers)
# print("------")
print(ans) | from collections import deque
from heapq import heapify,heappop,heappush,heappushpop
from copy import copy,deepcopy
from itertools import product,permutations,combinations,combinations_with_replacement
from collections import defaultdict,Counter
from bisect import bisect_left,bisect_right
# from math import gcd,ceil,floor,factorial
# from fractions import gcd
from functools import reduce
from pprint import pprint
INF = float("inf")
def myinput():
return list(map(int,input().split()))
def mylistinput(n):
return [ list(myinput()) for _ in range(n) ]
def mycol(data,col):
return [ row[col] for row in data ]
def mysort(data,col,reverse_flag):
data.sort(key=lambda x:x[col],reverse=reverse_flag)
return data
def mymax(data):
M = -1*float("inf")
for i in range(len(data)):
m = max(data[i])
M = max(M,m)
return M
def mymin(data):
m = float("inf")
for i in range(len(data)):
M = min(data[i])
m = min(m,M)
return m
def mycount(ls,x):
# lsはソート済みであること
l = bisect_left(ls,x)
r = bisect_right(ls,x)
return (r-l)
def myoutput(ls,space=True):
if space:
if len(ls)==0:
print(" ")
elif type(ls[0])==str:
print((" ".join(ls)))
elif type(ls[0])==int:
print((" ".join(map(str,ls))))
else:
print("Output Error")
else:
if len(ls)==0:
print("")
elif type(ls[0])==str:
print(("".join(ls)))
elif type(ls[0])==int:
print(("".join(map(str,ls))))
else:
print("Output Error")
n = int(eval(input()))
ls_a = []
ls_xy = []
for i in range(n):
a = int(eval(input()))
ls_a.append(a)
xy = mylistinput(a)
ls_xy.append(xy)
# print(a)
# print(ls_xy)
ans = 0
for i in range(2**n):
flag = True
for j in range(n):
if i & (2**j):
for k in range(len(ls_xy[j])):
x = ls_xy[j][k][0] - 1
y = ls_xy[j][k][1]
if y==1:
if i & (2**x) > 0:
pass
else:
flag = False
elif y==0:
if i & (2**x) == 0:
pass
else:
flag = False
if flag:
tmp = sum( list(map(int,list(bin(i)[2:]))) )
ans = max( ans, tmp )
print(ans) | 37 | 100 | 795 | 2,521 | import sys
input = sys.stdin.readline
n = int(eval(input()))
a = []
xy = []
for i in range(n):
a.append(int(eval(input())))
xy.append([list(map(int, input().split())) for _ in range(a[i])])
# print(a)
# print(xy)
ls = [-1] * n
ans = 0
for i in range(2**n):
b = str(bin(i))[2:]
c = b.zfill(n)
# print(c)
numbers = sum(list(map(int, list(str(c)))))
for j in range(n):
if c[j] == "0":
pass
else:
for k in range(a[j]):
x = xy[j][k][0]
y = xy[j][k][1]
# print(x,y)
if c[x - 1] == str(y):
pass
else:
numbers = 0
# print("--")
ans = max(ans, numbers)
# print("------")
print(ans)
| from collections import deque
from heapq import heapify, heappop, heappush, heappushpop
from copy import copy, deepcopy
from itertools import product, permutations, combinations, combinations_with_replacement
from collections import defaultdict, Counter
from bisect import bisect_left, bisect_right
# from math import gcd,ceil,floor,factorial
# from fractions import gcd
from functools import reduce
from pprint import pprint
INF = float("inf")
def myinput():
return list(map(int, input().split()))
def mylistinput(n):
return [list(myinput()) for _ in range(n)]
def mycol(data, col):
return [row[col] for row in data]
def mysort(data, col, reverse_flag):
data.sort(key=lambda x: x[col], reverse=reverse_flag)
return data
def mymax(data):
M = -1 * float("inf")
for i in range(len(data)):
m = max(data[i])
M = max(M, m)
return M
def mymin(data):
m = float("inf")
for i in range(len(data)):
M = min(data[i])
m = min(m, M)
return m
def mycount(ls, x):
# lsはソート済みであること
l = bisect_left(ls, x)
r = bisect_right(ls, x)
return r - l
def myoutput(ls, space=True):
if space:
if len(ls) == 0:
print(" ")
elif type(ls[0]) == str:
print((" ".join(ls)))
elif type(ls[0]) == int:
print((" ".join(map(str, ls))))
else:
print("Output Error")
else:
if len(ls) == 0:
print("")
elif type(ls[0]) == str:
print(("".join(ls)))
elif type(ls[0]) == int:
print(("".join(map(str, ls))))
else:
print("Output Error")
n = int(eval(input()))
ls_a = []
ls_xy = []
for i in range(n):
a = int(eval(input()))
ls_a.append(a)
xy = mylistinput(a)
ls_xy.append(xy)
# print(a)
# print(ls_xy)
ans = 0
for i in range(2**n):
flag = True
for j in range(n):
if i & (2**j):
for k in range(len(ls_xy[j])):
x = ls_xy[j][k][0] - 1
y = ls_xy[j][k][1]
if y == 1:
if i & (2**x) > 0:
pass
else:
flag = False
elif y == 0:
if i & (2**x) == 0:
pass
else:
flag = False
if flag:
tmp = sum(list(map(int, list(bin(i)[2:]))))
ans = max(ans, tmp)
print(ans)
| false | 63 | [
"-import sys",
"+from collections import deque",
"+from heapq import heapify, heappop, heappush, heappushpop",
"+from copy import copy, deepcopy",
"+from itertools import product, permutations, combinations, combinations_with_replacement",
"+from collections import defaultdict, Counter",
"+from bisect import bisect_left, bisect_right",
"-input = sys.stdin.readline",
"+# from math import gcd,ceil,floor,factorial",
"+# from fractions import gcd",
"+from functools import reduce",
"+from pprint import pprint",
"+",
"+INF = float(\"inf\")",
"+",
"+",
"+def myinput():",
"+ return list(map(int, input().split()))",
"+",
"+",
"+def mylistinput(n):",
"+ return [list(myinput()) for _ in range(n)]",
"+",
"+",
"+def mycol(data, col):",
"+ return [row[col] for row in data]",
"+",
"+",
"+def mysort(data, col, reverse_flag):",
"+ data.sort(key=lambda x: x[col], reverse=reverse_flag)",
"+ return data",
"+",
"+",
"+def mymax(data):",
"+ M = -1 * float(\"inf\")",
"+ for i in range(len(data)):",
"+ m = max(data[i])",
"+ M = max(M, m)",
"+ return M",
"+",
"+",
"+def mymin(data):",
"+ m = float(\"inf\")",
"+ for i in range(len(data)):",
"+ M = min(data[i])",
"+ m = min(m, M)",
"+ return m",
"+",
"+",
"+def mycount(ls, x):",
"+ # lsはソート済みであること",
"+ l = bisect_left(ls, x)",
"+ r = bisect_right(ls, x)",
"+ return r - l",
"+",
"+",
"+def myoutput(ls, space=True):",
"+ if space:",
"+ if len(ls) == 0:",
"+ print(\" \")",
"+ elif type(ls[0]) == str:",
"+ print((\" \".join(ls)))",
"+ elif type(ls[0]) == int:",
"+ print((\" \".join(map(str, ls))))",
"+ else:",
"+ print(\"Output Error\")",
"+ else:",
"+ if len(ls) == 0:",
"+ print(\"\")",
"+ elif type(ls[0]) == str:",
"+ print((\"\".join(ls)))",
"+ elif type(ls[0]) == int:",
"+ print((\"\".join(map(str, ls))))",
"+ else:",
"+ print(\"Output Error\")",
"+",
"+",
"-a = []",
"-xy = []",
"+ls_a = []",
"+ls_xy = []",
"- a.append(int(eval(input())))",
"- xy.append([list(map(int, input().split())) for _ in range(a[i])])",
"+ a = int(eval(input()))",
"+ ls_a.append(a)",
"+ xy = mylistinput(a)",
"+ ls_xy.append(xy)",
"-# print(xy)",
"-ls = [-1] * n",
"+# print(ls_xy)",
"- b = str(bin(i))[2:]",
"- c = b.zfill(n)",
"- # print(c)",
"- numbers = sum(list(map(int, list(str(c)))))",
"+ flag = True",
"- if c[j] == \"0\":",
"- pass",
"- else:",
"- for k in range(a[j]):",
"- x = xy[j][k][0]",
"- y = xy[j][k][1]",
"- # print(x,y)",
"- if c[x - 1] == str(y):",
"- pass",
"- else:",
"- numbers = 0",
"- # print(\"--\")",
"- ans = max(ans, numbers)",
"+ if i & (2**j):",
"+ for k in range(len(ls_xy[j])):",
"+ x = ls_xy[j][k][0] - 1",
"+ y = ls_xy[j][k][1]",
"+ if y == 1:",
"+ if i & (2**x) > 0:",
"+ pass",
"+ else:",
"+ flag = False",
"+ elif y == 0:",
"+ if i & (2**x) == 0:",
"+ pass",
"+ else:",
"+ flag = False",
"+ if flag:",
"+ tmp = sum(list(map(int, list(bin(i)[2:]))))",
"+ ans = max(ans, tmp)"
] | false | 0.079205 | 0.140482 | 0.563811 | [
"s329875626",
"s903487698"
] |
u130203301 | p03835 | python | s335645873 | s551030574 | 254 | 223 | 41,068 | 40,304 | Accepted | Accepted | 12.2 | k, s = list(map(int, input().split()))
result = 0
for i in range(k+1):
for j in range(k+1):
if s-i-j <= k and s-i-j >= 0:
result += 1
print(result) | k, s = list(map(int, input().split()))
def fun(k, s):
count = 0
for i in range(k+1):
for j in range(k+1):
if s - i - j <= k and s - i - j >= 0:
count += 1
return count
print((fun(k, s))) | 10 | 12 | 177 | 240 | k, s = list(map(int, input().split()))
result = 0
for i in range(k + 1):
for j in range(k + 1):
if s - i - j <= k and s - i - j >= 0:
result += 1
print(result)
| k, s = list(map(int, input().split()))
def fun(k, s):
count = 0
for i in range(k + 1):
for j in range(k + 1):
if s - i - j <= k and s - i - j >= 0:
count += 1
return count
print((fun(k, s)))
| false | 16.666667 | [
"-result = 0",
"-for i in range(k + 1):",
"- for j in range(k + 1):",
"- if s - i - j <= k and s - i - j >= 0:",
"- result += 1",
"-print(result)",
"+",
"+",
"+def fun(k, s):",
"+ count = 0",
"+ for i in range(k + 1):",
"+ for j in range(k + 1):",
"+ if s - i - j <= k and s - i - j >= 0:",
"+ count += 1",
"+ return count",
"+",
"+",
"+print((fun(k, s)))"
] | false | 0.038907 | 0.037163 | 1.046946 | [
"s335645873",
"s551030574"
] |
u506858457 | p02684 | python | s757649874 | s527730436 | 137 | 108 | 32,236 | 100,164 | Accepted | Accepted | 21.17 | N,K = list(map(int,input().split()))
A = [0] + list(map(int,input().split()))
turn = [-1] * (N+1) # いつ訪問したかを記録する
c = 1
for k in range(K):
if turn[c]!=-1:
T = k - turn[c] # 周期
bias = turn[c] # バイアス
break
turn[c] = k
c = A[c]
else:
print (c)
exit()
K -= bias
K %= T
K += bias
c = 1
for k in range(K):# 小さくしたKでシミュレーションし直す
c = A[c]
print (c) | def MI(): return list(map(int, input().split()))
def LI(): return list(map(int, input().split()))
N,K=MI()
A=[0]+LI()
c=1
turn=[-1]*(N+1)
for k in range(K):
if turn[c]!=-1:
T=k-turn[c]
bias=turn[c]
break
turn[c]=k
c=A[c]
else:
print(c)
exit()
K-=bias
K%=T
K+=bias
c=1
for k in range(K):
c=A[c]
print(c) | 22 | 23 | 403 | 342 | N, K = list(map(int, input().split()))
A = [0] + list(map(int, input().split()))
turn = [-1] * (N + 1) # いつ訪問したかを記録する
c = 1
for k in range(K):
if turn[c] != -1:
T = k - turn[c] # 周期
bias = turn[c] # バイアス
break
turn[c] = k
c = A[c]
else:
print(c)
exit()
K -= bias
K %= T
K += bias
c = 1
for k in range(K): # 小さくしたKでシミュレーションし直す
c = A[c]
print(c)
| def MI():
return list(map(int, input().split()))
def LI():
return list(map(int, input().split()))
N, K = MI()
A = [0] + LI()
c = 1
turn = [-1] * (N + 1)
for k in range(K):
if turn[c] != -1:
T = k - turn[c]
bias = turn[c]
break
turn[c] = k
c = A[c]
else:
print(c)
exit()
K -= bias
K %= T
K += bias
c = 1
for k in range(K):
c = A[c]
print(c)
| false | 4.347826 | [
"-N, K = list(map(int, input().split()))",
"-A = [0] + list(map(int, input().split()))",
"-turn = [-1] * (N + 1) # いつ訪問したかを記録する",
"+def MI():",
"+ return list(map(int, input().split()))",
"+",
"+",
"+def LI():",
"+ return list(map(int, input().split()))",
"+",
"+",
"+N, K = MI()",
"+A = [0] + LI()",
"+turn = [-1] * (N + 1)",
"- T = k - turn[c] # 周期",
"- bias = turn[c] # バイアス",
"+ T = k - turn[c]",
"+ bias = turn[c]",
"-for k in range(K): # 小さくしたKでシミュレーションし直す",
"+for k in range(K):"
] | false | 0.046154 | 0.127964 | 0.360679 | [
"s757649874",
"s527730436"
] |
u729133443 | p03624 | python | s322885363 | s110109705 | 181 | 19 | 45,168 | 3,188 | Accepted | Accepted | 89.5 | print((min(set(map(chr,list(range(97,123))))-set(eval(input()))or['None']))) | print((min(set(map(chr,list(range(97,123))))-set(eval(input()))or[None]))) | 1 | 1 | 62 | 60 | print((min(set(map(chr, list(range(97, 123)))) - set(eval(input())) or ["None"])))
| print((min(set(map(chr, list(range(97, 123)))) - set(eval(input())) or [None])))
| false | 0 | [
"-print((min(set(map(chr, list(range(97, 123)))) - set(eval(input())) or [\"None\"])))",
"+print((min(set(map(chr, list(range(97, 123)))) - set(eval(input())) or [None])))"
] | false | 0.034169 | 0.039322 | 0.868945 | [
"s322885363",
"s110109705"
] |
u623819879 | p03291 | python | s645816825 | s975378749 | 580 | 254 | 27,616 | 45,168 | Accepted | Accepted | 56.21 | s=eval(input())
n=len(s)
dc=dict()
dc['A']=0
dc['B']=1
dc['C']=2
dc['?']=3
dp=[[0 for i in range(4)] for j in range(n+1)]
dp[0][0]=1
mo=10**9+7
for i in range(n):
for t in range(4):
ch=s[i]
m = 1 if dc[ch]==t-1 or dc[ch]==3 else 0
if t!=0:
dp[i+1][t]+=(dp[i][t-1]*m)%mo
dp[i+1][t]+=(dp[i][t]*(3 if dc[ch]==3 else 1))%mo
ans=dp[n][3]
print((ans%mo))
| mo=10**9+7
s=eval(input())
n=len(s)
dp=[[0]*(1+n) for i in range(3)]
cc=0
for i in range(n):
c=s[i]
if c=='A':
da=1
db=0
dc=0
dd=1
elif c=='B':
da=0
db=1
dc=0
dd=1
elif c=='C':
da=0
db=0
dc=1
dd=1
elif c=='?':
da=1
db=1
dc=1
dd=3
dp[0][i+1]=dp[0][i]*dd+da*pow(3,cc,mo)
dp[1][i+1]=dp[1][i]*dd+dp[0][i]*db
dp[2][i+1]=dp[2][i]*dd+dp[1][i]*dc
dp[0][i+1]%=mo
dp[1][i+1]%=mo
dp[2][i+1]%=mo
if c=='?':
cc+=1
print((dp[2][n]%mo)) | 21 | 38 | 411 | 644 | s = eval(input())
n = len(s)
dc = dict()
dc["A"] = 0
dc["B"] = 1
dc["C"] = 2
dc["?"] = 3
dp = [[0 for i in range(4)] for j in range(n + 1)]
dp[0][0] = 1
mo = 10**9 + 7
for i in range(n):
for t in range(4):
ch = s[i]
m = 1 if dc[ch] == t - 1 or dc[ch] == 3 else 0
if t != 0:
dp[i + 1][t] += (dp[i][t - 1] * m) % mo
dp[i + 1][t] += (dp[i][t] * (3 if dc[ch] == 3 else 1)) % mo
ans = dp[n][3]
print((ans % mo))
| mo = 10**9 + 7
s = eval(input())
n = len(s)
dp = [[0] * (1 + n) for i in range(3)]
cc = 0
for i in range(n):
c = s[i]
if c == "A":
da = 1
db = 0
dc = 0
dd = 1
elif c == "B":
da = 0
db = 1
dc = 0
dd = 1
elif c == "C":
da = 0
db = 0
dc = 1
dd = 1
elif c == "?":
da = 1
db = 1
dc = 1
dd = 3
dp[0][i + 1] = dp[0][i] * dd + da * pow(3, cc, mo)
dp[1][i + 1] = dp[1][i] * dd + dp[0][i] * db
dp[2][i + 1] = dp[2][i] * dd + dp[1][i] * dc
dp[0][i + 1] %= mo
dp[1][i + 1] %= mo
dp[2][i + 1] %= mo
if c == "?":
cc += 1
print((dp[2][n] % mo))
| false | 44.736842 | [
"+mo = 10**9 + 7",
"-dc = dict()",
"-dc[\"A\"] = 0",
"-dc[\"B\"] = 1",
"-dc[\"C\"] = 2",
"-dc[\"?\"] = 3",
"-dp = [[0 for i in range(4)] for j in range(n + 1)]",
"-dp[0][0] = 1",
"-mo = 10**9 + 7",
"+dp = [[0] * (1 + n) for i in range(3)]",
"+cc = 0",
"- for t in range(4):",
"- ch = s[i]",
"- m = 1 if dc[ch] == t - 1 or dc[ch] == 3 else 0",
"- if t != 0:",
"- dp[i + 1][t] += (dp[i][t - 1] * m) % mo",
"- dp[i + 1][t] += (dp[i][t] * (3 if dc[ch] == 3 else 1)) % mo",
"-ans = dp[n][3]",
"-print((ans % mo))",
"+ c = s[i]",
"+ if c == \"A\":",
"+ da = 1",
"+ db = 0",
"+ dc = 0",
"+ dd = 1",
"+ elif c == \"B\":",
"+ da = 0",
"+ db = 1",
"+ dc = 0",
"+ dd = 1",
"+ elif c == \"C\":",
"+ da = 0",
"+ db = 0",
"+ dc = 1",
"+ dd = 1",
"+ elif c == \"?\":",
"+ da = 1",
"+ db = 1",
"+ dc = 1",
"+ dd = 3",
"+ dp[0][i + 1] = dp[0][i] * dd + da * pow(3, cc, mo)",
"+ dp[1][i + 1] = dp[1][i] * dd + dp[0][i] * db",
"+ dp[2][i + 1] = dp[2][i] * dd + dp[1][i] * dc",
"+ dp[0][i + 1] %= mo",
"+ dp[1][i + 1] %= mo",
"+ dp[2][i + 1] %= mo",
"+ if c == \"?\":",
"+ cc += 1",
"+print((dp[2][n] % mo))"
] | false | 0.042219 | 0.040904 | 1.03215 | [
"s645816825",
"s975378749"
] |
u268402865 | p02570 | python | s177254667 | s773517705 | 68 | 25 | 61,608 | 9,136 | Accepted | Accepted | 63.24 | D, T, S = list(map(int,input().split()))
if D/S <= T:
print("Yes")
else:
print("No") | D, T, S = list(map(int,input().split()))
if D <= T*S:
print("Yes")
else:
print("No") | 5 | 5 | 96 | 96 | D, T, S = list(map(int, input().split()))
if D / S <= T:
print("Yes")
else:
print("No")
| D, T, S = list(map(int, input().split()))
if D <= T * S:
print("Yes")
else:
print("No")
| false | 0 | [
"-if D / S <= T:",
"+if D <= T * S:"
] | false | 0.036798 | 0.037483 | 0.981728 | [
"s177254667",
"s773517705"
] |
u035472582 | p02595 | python | s528816095 | s585559277 | 402 | 370 | 107,188 | 107,200 | Accepted | Accepted | 7.96 | from math import sqrt
def main():
N, D = list(map(int, input().split()))
P = [list(map(int, input().split())) for i in range(N)]
ans = 0
for i in range(N):
if sqrt(P[i][0]**2 + P[i][1]**2) <= D:
ans += 1
print(ans)
main() | def main():
from math import sqrt
N, D = list(map(int, input().split()))
P = [list(map(int, input().split())) for i in range(N)]
ans = 0
for i in range(N):
if sqrt(P[i][0]**2 + P[i][1]**2) <= D:
ans += 1
print(ans)
main() | 12 | 10 | 248 | 246 | from math import sqrt
def main():
N, D = list(map(int, input().split()))
P = [list(map(int, input().split())) for i in range(N)]
ans = 0
for i in range(N):
if sqrt(P[i][0] ** 2 + P[i][1] ** 2) <= D:
ans += 1
print(ans)
main()
| def main():
from math import sqrt
N, D = list(map(int, input().split()))
P = [list(map(int, input().split())) for i in range(N)]
ans = 0
for i in range(N):
if sqrt(P[i][0] ** 2 + P[i][1] ** 2) <= D:
ans += 1
print(ans)
main()
| false | 16.666667 | [
"-from math import sqrt",
"+def main():",
"+ from math import sqrt",
"-",
"-def main():"
] | false | 0.045717 | 0.088033 | 0.519314 | [
"s528816095",
"s585559277"
] |
u073852194 | p02551 | python | s043737804 | s858139576 | 365 | 325 | 167,188 | 94,684 | Accepted | Accepted | 10.96 | class SegmentTreeDual():
def __init__(self, arr, op=lambda x, y: y if y != -1 else x, ie=-1):
self.h = (len(arr) - 1).bit_length()
self.n = 2**self.h
self.ie = ie
self.op = op
self.val = [ie for _ in range(self.n)]
self.laz = [ie for _ in range(2 * self.n)]
for i in range(len(arr)):
self.val[i] = arr[i]
def propagate(self, k):
if self.laz[k] == self.ie: return
if self.n <= k:
self.val[k - self.n] = self.op(self.val[k - self.n], self.laz[k])
else:
self.laz[2 * k] = self.op(self.laz[2 * k], self.laz[k])
self.laz[2 * k + 1] = self.op(self.laz[2 * k + 1], self.laz[k])
self.laz[k] = self.ie
def update(self, lt, rt, x):
lt += self.n
rt += self.n
while rt - lt > 0:
if lt & 1:
self.laz[lt] = self.op(self.laz[lt], x)
lt += 1
if rt & 1:
rt -= 1
self.laz[rt] = self.op(self.laz[rt], x)
lt >>= 1
rt >>= 1
def get(self, idx):
res = self.val[idx]
idx += self.n
while idx:
res = self.op(res, self.laz[idx])
idx >>= 1
return res
import sys
input = sys.stdin.buffer.readline
N, Q = list(map(int, input().split()))
x = [N - 1] * (N - 1) + [0]
y = [N - 1] * (N - 1) + [0]
stx = SegmentTreeDual(x, min, 10**18)
sty = SegmentTreeDual(y, min, 10**18)
res = (N - 2) * (N - 2)
for _ in range(Q):
q, k = list(map(int, input().split()))
if q == 1:
g = stx.get(k - 1)
res -= g - 1
sty.update(1, g, k - 1)
if q == 2:
g = sty.get(k - 1)
res -= g - 1
stx.update(1, g, k - 1)
print(res) | class SegmentTreeDual():
def __init__(self, n, op, id, commutative=False):
self.n = n
self.op = op
self.id = id
self.commutative = commutative
self.log = (n - 1).bit_length()
self.size = 1 << self.log
self.d = [id] * self.size
self.lz = [id] * (2 * self.size)
def build(self, arr):
for i, a in enumerate(arr):
self.d[i] = a
def propagate(self, k):
if self.lz[k] == self.id: return
if k < self.size:
self.lz[2 * k] = self.op(self.lz[k], self.lz[2 * k], )
self.lz[2 * k + 1] = self.op(self.lz[k], self.lz[2 * k + 1])
else:
self.d[k - self.size] = self.op(self.lz[k], self.d[k - self.size])
self.lz[k] = self.id
def get(self, p):
res = self.d[p]
p += self.size
for i in range(self.log):
res = self.op(self.lz[p >> i], res)
return res
def range_apply(self, l, r, f):
if l == r: return
l += self.size
r += self.size
if not self.commutative:
for i in range(self.log)[::-1]:
self.propagate(l >> i)
self.propagate(r >> i)
while l < r:
if l & 1:
self.lz[l] = self.op(f, self.lz[l])
l += 1
if r & 1:
r -= 1
self.lz[r] = self.op(f, self.lz[r])
l >>= 1
r >>= 1
import sys
input = sys.stdin.buffer.readline
N, Q = list(map(int, input().split()))
stx = SegmentTreeDual(N, min, 10**18, False)
sty = SegmentTreeDual(N, min, 10**18, False)
x = [N - 1] * (N - 1) + [0]
y = [N - 1] * (N - 1) + [0]
stx.build(x)
sty.build(y)
res = (N - 2) * (N - 2)
for _ in range(Q):
q, k = list(map(int, input().split()))
if q == 1:
g = stx.get(k - 1)
res -= g - 1
sty.range_apply(1, g, k - 1)
if q == 2:
g = sty.get(k - 1)
res -= g - 1
stx.range_apply(1, g, k - 1)
print(res) | 66 | 77 | 1,832 | 2,089 | class SegmentTreeDual:
def __init__(self, arr, op=lambda x, y: y if y != -1 else x, ie=-1):
self.h = (len(arr) - 1).bit_length()
self.n = 2**self.h
self.ie = ie
self.op = op
self.val = [ie for _ in range(self.n)]
self.laz = [ie for _ in range(2 * self.n)]
for i in range(len(arr)):
self.val[i] = arr[i]
def propagate(self, k):
if self.laz[k] == self.ie:
return
if self.n <= k:
self.val[k - self.n] = self.op(self.val[k - self.n], self.laz[k])
else:
self.laz[2 * k] = self.op(self.laz[2 * k], self.laz[k])
self.laz[2 * k + 1] = self.op(self.laz[2 * k + 1], self.laz[k])
self.laz[k] = self.ie
def update(self, lt, rt, x):
lt += self.n
rt += self.n
while rt - lt > 0:
if lt & 1:
self.laz[lt] = self.op(self.laz[lt], x)
lt += 1
if rt & 1:
rt -= 1
self.laz[rt] = self.op(self.laz[rt], x)
lt >>= 1
rt >>= 1
def get(self, idx):
res = self.val[idx]
idx += self.n
while idx:
res = self.op(res, self.laz[idx])
idx >>= 1
return res
import sys
input = sys.stdin.buffer.readline
N, Q = list(map(int, input().split()))
x = [N - 1] * (N - 1) + [0]
y = [N - 1] * (N - 1) + [0]
stx = SegmentTreeDual(x, min, 10**18)
sty = SegmentTreeDual(y, min, 10**18)
res = (N - 2) * (N - 2)
for _ in range(Q):
q, k = list(map(int, input().split()))
if q == 1:
g = stx.get(k - 1)
res -= g - 1
sty.update(1, g, k - 1)
if q == 2:
g = sty.get(k - 1)
res -= g - 1
stx.update(1, g, k - 1)
print(res)
| class SegmentTreeDual:
def __init__(self, n, op, id, commutative=False):
self.n = n
self.op = op
self.id = id
self.commutative = commutative
self.log = (n - 1).bit_length()
self.size = 1 << self.log
self.d = [id] * self.size
self.lz = [id] * (2 * self.size)
def build(self, arr):
for i, a in enumerate(arr):
self.d[i] = a
def propagate(self, k):
if self.lz[k] == self.id:
return
if k < self.size:
self.lz[2 * k] = self.op(
self.lz[k],
self.lz[2 * k],
)
self.lz[2 * k + 1] = self.op(self.lz[k], self.lz[2 * k + 1])
else:
self.d[k - self.size] = self.op(self.lz[k], self.d[k - self.size])
self.lz[k] = self.id
def get(self, p):
res = self.d[p]
p += self.size
for i in range(self.log):
res = self.op(self.lz[p >> i], res)
return res
def range_apply(self, l, r, f):
if l == r:
return
l += self.size
r += self.size
if not self.commutative:
for i in range(self.log)[::-1]:
self.propagate(l >> i)
self.propagate(r >> i)
while l < r:
if l & 1:
self.lz[l] = self.op(f, self.lz[l])
l += 1
if r & 1:
r -= 1
self.lz[r] = self.op(f, self.lz[r])
l >>= 1
r >>= 1
import sys
input = sys.stdin.buffer.readline
N, Q = list(map(int, input().split()))
stx = SegmentTreeDual(N, min, 10**18, False)
sty = SegmentTreeDual(N, min, 10**18, False)
x = [N - 1] * (N - 1) + [0]
y = [N - 1] * (N - 1) + [0]
stx.build(x)
sty.build(y)
res = (N - 2) * (N - 2)
for _ in range(Q):
q, k = list(map(int, input().split()))
if q == 1:
g = stx.get(k - 1)
res -= g - 1
sty.range_apply(1, g, k - 1)
if q == 2:
g = sty.get(k - 1)
res -= g - 1
stx.range_apply(1, g, k - 1)
print(res)
| false | 14.285714 | [
"- def __init__(self, arr, op=lambda x, y: y if y != -1 else x, ie=-1):",
"- self.h = (len(arr) - 1).bit_length()",
"- self.n = 2**self.h",
"- self.ie = ie",
"+ def __init__(self, n, op, id, commutative=False):",
"+ self.n = n",
"- self.val = [ie for _ in range(self.n)]",
"- self.laz = [ie for _ in range(2 * self.n)]",
"- for i in range(len(arr)):",
"- self.val[i] = arr[i]",
"+ self.id = id",
"+ self.commutative = commutative",
"+ self.log = (n - 1).bit_length()",
"+ self.size = 1 << self.log",
"+ self.d = [id] * self.size",
"+ self.lz = [id] * (2 * self.size)",
"+",
"+ def build(self, arr):",
"+ for i, a in enumerate(arr):",
"+ self.d[i] = a",
"- if self.laz[k] == self.ie:",
"+ if self.lz[k] == self.id:",
"- if self.n <= k:",
"- self.val[k - self.n] = self.op(self.val[k - self.n], self.laz[k])",
"+ if k < self.size:",
"+ self.lz[2 * k] = self.op(",
"+ self.lz[k],",
"+ self.lz[2 * k],",
"+ )",
"+ self.lz[2 * k + 1] = self.op(self.lz[k], self.lz[2 * k + 1])",
"- self.laz[2 * k] = self.op(self.laz[2 * k], self.laz[k])",
"- self.laz[2 * k + 1] = self.op(self.laz[2 * k + 1], self.laz[k])",
"- self.laz[k] = self.ie",
"+ self.d[k - self.size] = self.op(self.lz[k], self.d[k - self.size])",
"+ self.lz[k] = self.id",
"- def update(self, lt, rt, x):",
"- lt += self.n",
"- rt += self.n",
"- while rt - lt > 0:",
"- if lt & 1:",
"- self.laz[lt] = self.op(self.laz[lt], x)",
"- lt += 1",
"- if rt & 1:",
"- rt -= 1",
"- self.laz[rt] = self.op(self.laz[rt], x)",
"- lt >>= 1",
"- rt >>= 1",
"+ def get(self, p):",
"+ res = self.d[p]",
"+ p += self.size",
"+ for i in range(self.log):",
"+ res = self.op(self.lz[p >> i], res)",
"+ return res",
"- def get(self, idx):",
"- res = self.val[idx]",
"- idx += self.n",
"- while idx:",
"- res = self.op(res, self.laz[idx])",
"- idx >>= 1",
"- return res",
"+ def range_apply(self, l, r, f):",
"+ if l == r:",
"+ return",
"+ l += self.size",
"+ r += self.size",
"+ if not self.commutative:",
"+ for i in range(self.log)[::-1]:",
"+ self.propagate(l >> i)",
"+ self.propagate(r >> i)",
"+ while l < r:",
"+ if l & 1:",
"+ self.lz[l] = self.op(f, self.lz[l])",
"+ l += 1",
"+ if r & 1:",
"+ r -= 1",
"+ self.lz[r] = self.op(f, self.lz[r])",
"+ l >>= 1",
"+ r >>= 1",
"+stx = SegmentTreeDual(N, min, 10**18, False)",
"+sty = SegmentTreeDual(N, min, 10**18, False)",
"-stx = SegmentTreeDual(x, min, 10**18)",
"-sty = SegmentTreeDual(y, min, 10**18)",
"+stx.build(x)",
"+sty.build(y)",
"- sty.update(1, g, k - 1)",
"+ sty.range_apply(1, g, k - 1)",
"- stx.update(1, g, k - 1)",
"+ stx.range_apply(1, g, k - 1)"
] | false | 0.446328 | 0.08723 | 5.116663 | [
"s043737804",
"s858139576"
] |
u367701763 | p03283 | python | s398986864 | s949086350 | 816 | 624 | 153,856 | 82,232 | Accepted | Accepted | 23.53 | # https://atcoder.jp/contests/abc106/tasks/abc106_d
'''
N が小さいので、N^2 を考えると良いことが分かる。
'''
from collections import defaultdict
N, M, Q = list(map(int, input().split())) # N, M: リストの長さ
edges = [list(map(int, input().split())) for _ in range(M)]
data = defaultdict(int) # defaultdict は 初期化の際のに value の type を指定する必要あり
for i, j in edges:
i -= 1
j -= 1
data[(i,j)] += 1
cum = [[0]*(N+1) for _ in range(N+1)]
for i in range(N):
for j in range(N):
cum[i+1][j+1] = cum[i][j+1] + cum[i+1][j] - cum[i][j] + data[(i,j)]
for _ in range(Q):
p, q = list(map(int, input().split()))
if p < q:
p, q = q, p
q -= 1
res = cum[p][p] - cum[p][q] - cum[q][p] + cum[q][q]
print(res)
| N, M, Q = list(map(int, input().split()))
C = [[0]*N for _ in range(N)]
for _ in range(M):
L, R = list(map(int, input().split()))
C[L-1][R-1] += 1
S = [[0]*(N+1) for _ in range(N+1)]
for r in range(N):
for l in reversed(list(range(N))):
S[l][r] = S[l+1][r] + C[l][r]
D = [[0]*(N+1) for _ in range(N+1)]
for l in range(N):
for r in range(N):
D[l][r] = D[l][r-1] + S[l][r]
for _ in range(Q):
p, q = list(map(int, input().split()))
print((D[p-1][q-1]))
| 37 | 16 | 770 | 479 | # https://atcoder.jp/contests/abc106/tasks/abc106_d
"""
N が小さいので、N^2 を考えると良いことが分かる。
"""
from collections import defaultdict
N, M, Q = list(map(int, input().split())) # N, M: リストの長さ
edges = [list(map(int, input().split())) for _ in range(M)]
data = defaultdict(int) # defaultdict は 初期化の際のに value の type を指定する必要あり
for i, j in edges:
i -= 1
j -= 1
data[(i, j)] += 1
cum = [[0] * (N + 1) for _ in range(N + 1)]
for i in range(N):
for j in range(N):
cum[i + 1][j + 1] = cum[i][j + 1] + cum[i + 1][j] - cum[i][j] + data[(i, j)]
for _ in range(Q):
p, q = list(map(int, input().split()))
if p < q:
p, q = q, p
q -= 1
res = cum[p][p] - cum[p][q] - cum[q][p] + cum[q][q]
print(res)
| N, M, Q = list(map(int, input().split()))
C = [[0] * N for _ in range(N)]
for _ in range(M):
L, R = list(map(int, input().split()))
C[L - 1][R - 1] += 1
S = [[0] * (N + 1) for _ in range(N + 1)]
for r in range(N):
for l in reversed(list(range(N))):
S[l][r] = S[l + 1][r] + C[l][r]
D = [[0] * (N + 1) for _ in range(N + 1)]
for l in range(N):
for r in range(N):
D[l][r] = D[l][r - 1] + S[l][r]
for _ in range(Q):
p, q = list(map(int, input().split()))
print((D[p - 1][q - 1]))
| false | 56.756757 | [
"-# https://atcoder.jp/contests/abc106/tasks/abc106_d",
"-\"\"\"",
"-N が小さいので、N^2 を考えると良いことが分かる。",
"-\"\"\"",
"-from collections import defaultdict",
"-",
"-N, M, Q = list(map(int, input().split())) # N, M: リストの長さ",
"-edges = [list(map(int, input().split())) for _ in range(M)]",
"-data = defaultdict(int) # defaultdict は 初期化の際のに value の type を指定する必要あり",
"-for i, j in edges:",
"- i -= 1",
"- j -= 1",
"- data[(i, j)] += 1",
"-cum = [[0] * (N + 1) for _ in range(N + 1)]",
"-for i in range(N):",
"- for j in range(N):",
"- cum[i + 1][j + 1] = cum[i][j + 1] + cum[i + 1][j] - cum[i][j] + data[(i, j)]",
"+N, M, Q = list(map(int, input().split()))",
"+C = [[0] * N for _ in range(N)]",
"+for _ in range(M):",
"+ L, R = list(map(int, input().split()))",
"+ C[L - 1][R - 1] += 1",
"+S = [[0] * (N + 1) for _ in range(N + 1)]",
"+for r in range(N):",
"+ for l in reversed(list(range(N))):",
"+ S[l][r] = S[l + 1][r] + C[l][r]",
"+D = [[0] * (N + 1) for _ in range(N + 1)]",
"+for l in range(N):",
"+ for r in range(N):",
"+ D[l][r] = D[l][r - 1] + S[l][r]",
"- if p < q:",
"- p, q = q, p",
"- q -= 1",
"- res = cum[p][p] - cum[p][q] - cum[q][p] + cum[q][q]",
"- print(res)",
"+ print((D[p - 1][q - 1]))"
] | false | 0.211652 | 0.041028 | 5.158696 | [
"s398986864",
"s949086350"
] |
u020604402 | p03730 | python | s129120795 | s690110460 | 19 | 17 | 2,940 | 2,940 | Accepted | Accepted | 10.53 | A ,B ,C = list(map(int,input().split()))
for i in range(100):
if (A * i) % B == C:
print("YES")
quit()
print("NO")
| A ,B ,C = list(map(int,input().split()))
for i in range(1,B+1):
if (A * i) % B == C:
print("YES")
quit()
print("NO")
| 7 | 7 | 136 | 138 | A, B, C = list(map(int, input().split()))
for i in range(100):
if (A * i) % B == C:
print("YES")
quit()
print("NO")
| A, B, C = list(map(int, input().split()))
for i in range(1, B + 1):
if (A * i) % B == C:
print("YES")
quit()
print("NO")
| false | 0 | [
"-for i in range(100):",
"+for i in range(1, B + 1):"
] | false | 0.066116 | 0.050816 | 1.301074 | [
"s129120795",
"s690110460"
] |
u732412551 | p03611 | python | s083688554 | s678583460 | 224 | 86 | 14,556 | 14,044 | Accepted | Accepted | 61.61 | from collections import Counter
eval(input())
A = list(map(int, input().split()))
C = Counter(A)
def get(i): return C[i] if i in C else 0
print((max(sum(get(x) for x in range(i-1,i+2)) for i in range(10**5)))) | N,*A=list(map(int, open(0).read().split()))
C=[0]*(10**5+5)
for a in A:
C[a-1]+=1
C[a]+=1
C[a+1]+=1
print((max(C[i] for i in range(10**5+1))))
| 6 | 7 | 206 | 153 | from collections import Counter
eval(input())
A = list(map(int, input().split()))
C = Counter(A)
def get(i):
return C[i] if i in C else 0
print((max(sum(get(x) for x in range(i - 1, i + 2)) for i in range(10**5))))
| N, *A = list(map(int, open(0).read().split()))
C = [0] * (10**5 + 5)
for a in A:
C[a - 1] += 1
C[a] += 1
C[a + 1] += 1
print((max(C[i] for i in range(10**5 + 1))))
| false | 14.285714 | [
"-from collections import Counter",
"-",
"-eval(input())",
"-A = list(map(int, input().split()))",
"-C = Counter(A)",
"-",
"-",
"-def get(i):",
"- return C[i] if i in C else 0",
"-",
"-",
"-print((max(sum(get(x) for x in range(i - 1, i + 2)) for i in range(10**5))))",
"+N, *A = list(map(int, open(0).read().split()))",
"+C = [0] * (10**5 + 5)",
"+for a in A:",
"+ C[a - 1] += 1",
"+ C[a] += 1",
"+ C[a + 1] += 1",
"+print((max(C[i] for i in range(10**5 + 1))))"
] | false | 0.24495 | 0.074723 | 3.278092 | [
"s083688554",
"s678583460"
] |
u750990077 | p02687 | python | s406869537 | s164754035 | 66 | 28 | 61,792 | 8,968 | Accepted | Accepted | 57.58 | def main():
print((list(set(["ABC", "ARC"])-{eval(input())})[0]))
if __name__ == "__main__":
main() | def main():
s = eval(input())
if s == "ABC":
print("ARC")
else:
print("ABC")
if __name__ == "__main__":
main() | 6 | 9 | 114 | 145 | def main():
print((list(set(["ABC", "ARC"]) - {eval(input())})[0]))
if __name__ == "__main__":
main()
| def main():
s = eval(input())
if s == "ABC":
print("ARC")
else:
print("ABC")
if __name__ == "__main__":
main()
| false | 33.333333 | [
"- print((list(set([\"ABC\", \"ARC\"]) - {eval(input())})[0]))",
"+ s = eval(input())",
"+ if s == \"ABC\":",
"+ print(\"ARC\")",
"+ else:",
"+ print(\"ABC\")"
] | false | 0.11622 | 0.046517 | 2.498448 | [
"s406869537",
"s164754035"
] |
u077291787 | p03151 | python | s752887334 | s100483734 | 118 | 103 | 18,444 | 18,884 | Accepted | Accepted | 12.71 | # keyence2019C - Exam and Wizard
def main():
N = int(eval(input()))
A = tuple(map(int, input().split()))
B = tuple(map(int, input().split()))
dif = sorted(i - j for i, j in zip(A, B))
ans, shortage = 0, 0
for i in dif:
if i < 0:
ans += 1
shortage += i
else:
break
for i in dif[::-1]:
if shortage >= 0:
print(ans)
return
ans += 1
shortage += i
print((-1))
if __name__ == "__main__":
main() | # keyence2019C - Exam and Wizard
def main():
N = int(eval(input()))
A = tuple(map(int, input().split()))
B = tuple(map(int, input().split()))
pos, neg = [], []
for i, j in zip(A, B):
x = i - j
if x >= 0:
pos += [x]
else:
neg += [x]
ans, shortage = len(neg), sum(neg)
for i in sorted(pos, reverse=1):
if shortage >= 0:
print(ans)
return
ans += 1
shortage += i
print((ans if shortage >= 0 else -1))
if __name__ == "__main__":
main() | 24 | 24 | 541 | 579 | # keyence2019C - Exam and Wizard
def main():
N = int(eval(input()))
A = tuple(map(int, input().split()))
B = tuple(map(int, input().split()))
dif = sorted(i - j for i, j in zip(A, B))
ans, shortage = 0, 0
for i in dif:
if i < 0:
ans += 1
shortage += i
else:
break
for i in dif[::-1]:
if shortage >= 0:
print(ans)
return
ans += 1
shortage += i
print((-1))
if __name__ == "__main__":
main()
| # keyence2019C - Exam and Wizard
def main():
N = int(eval(input()))
A = tuple(map(int, input().split()))
B = tuple(map(int, input().split()))
pos, neg = [], []
for i, j in zip(A, B):
x = i - j
if x >= 0:
pos += [x]
else:
neg += [x]
ans, shortage = len(neg), sum(neg)
for i in sorted(pos, reverse=1):
if shortage >= 0:
print(ans)
return
ans += 1
shortage += i
print((ans if shortage >= 0 else -1))
if __name__ == "__main__":
main()
| false | 0 | [
"- dif = sorted(i - j for i, j in zip(A, B))",
"- ans, shortage = 0, 0",
"- for i in dif:",
"- if i < 0:",
"- ans += 1",
"- shortage += i",
"+ pos, neg = [], []",
"+ for i, j in zip(A, B):",
"+ x = i - j",
"+ if x >= 0:",
"+ pos += [x]",
"- break",
"- for i in dif[::-1]:",
"+ neg += [x]",
"+ ans, shortage = len(neg), sum(neg)",
"+ for i in sorted(pos, reverse=1):",
"- print((-1))",
"+ print((ans if shortage >= 0 else -1))"
] | false | 0.035563 | 0.037222 | 0.955427 | [
"s752887334",
"s100483734"
] |
u318029285 | p03160 | python | s053893503 | s457274495 | 139 | 128 | 13,776 | 13,980 | Accepted | Accepted | 7.91 | N = int(eval(input()))
h = list(map(int, input().split()))
dp = [10e9] * N
dp[0] = 0
dp[1] = abs(h[0] - h[1])
for i in range(2, N):
if dp[i-1] + abs(h[i] - h[i-1]) < dp[i-2] + abs(h[i] - h[i-2]):
dp[i] = dp[i-1] + abs(h[i] - h[i-1])
else:
dp[i] = dp[i-2] + abs(h[i] - h[i-2])
print((dp[-1])) | N = int(eval(input()))
h = list(map(int, input().split()))
dp = [10e9] * N
dp[0] = 0
dp[1] = abs(h[0] - h[1])
for i in range(2, N):
dp[i] = min(dp[i-2] + abs(h[i] - h[i-2]), dp[i-1] + abs(h[i] - h[i-1]))
print((dp[-1])) | 15 | 11 | 325 | 228 | N = int(eval(input()))
h = list(map(int, input().split()))
dp = [10e9] * N
dp[0] = 0
dp[1] = abs(h[0] - h[1])
for i in range(2, N):
if dp[i - 1] + abs(h[i] - h[i - 1]) < dp[i - 2] + abs(h[i] - h[i - 2]):
dp[i] = dp[i - 1] + abs(h[i] - h[i - 1])
else:
dp[i] = dp[i - 2] + abs(h[i] - h[i - 2])
print((dp[-1]))
| N = int(eval(input()))
h = list(map(int, input().split()))
dp = [10e9] * N
dp[0] = 0
dp[1] = abs(h[0] - h[1])
for i in range(2, N):
dp[i] = min(dp[i - 2] + abs(h[i] - h[i - 2]), dp[i - 1] + abs(h[i] - h[i - 1]))
print((dp[-1]))
| false | 26.666667 | [
"- if dp[i - 1] + abs(h[i] - h[i - 1]) < dp[i - 2] + abs(h[i] - h[i - 2]):",
"- dp[i] = dp[i - 1] + abs(h[i] - h[i - 1])",
"- else:",
"- dp[i] = dp[i - 2] + abs(h[i] - h[i - 2])",
"+ dp[i] = min(dp[i - 2] + abs(h[i] - h[i - 2]), dp[i - 1] + abs(h[i] - h[i - 1]))"
] | false | 0.04447 | 0.043543 | 1.021303 | [
"s053893503",
"s457274495"
] |
u759412327 | p02629 | python | s064671739 | s225680714 | 31 | 28 | 9,188 | 9,080 | Accepted | Accepted | 9.68 | def num2alpha(num):
if num<=26:
return chr(64+num)
elif num%26==0:
return num2alpha(num//26-1)+chr(90)
else:
return num2alpha(num//26)+chr(64+num%26)
print((num2alpha(int(eval(input()))).lower())) | N = int(eval(input()))
S = ""
while 0<N:
N-=1
S+=chr(97+N%26)
N//=26
print((S[::-1])) | 9 | 9 | 215 | 93 | def num2alpha(num):
if num <= 26:
return chr(64 + num)
elif num % 26 == 0:
return num2alpha(num // 26 - 1) + chr(90)
else:
return num2alpha(num // 26) + chr(64 + num % 26)
print((num2alpha(int(eval(input()))).lower()))
| N = int(eval(input()))
S = ""
while 0 < N:
N -= 1
S += chr(97 + N % 26)
N //= 26
print((S[::-1]))
| false | 0 | [
"-def num2alpha(num):",
"- if num <= 26:",
"- return chr(64 + num)",
"- elif num % 26 == 0:",
"- return num2alpha(num // 26 - 1) + chr(90)",
"- else:",
"- return num2alpha(num // 26) + chr(64 + num % 26)",
"-",
"-",
"-print((num2alpha(int(eval(input()))).lower()))",
"+N = int(eval(input()))",
"+S = \"\"",
"+while 0 < N:",
"+ N -= 1",
"+ S += chr(97 + N % 26)",
"+ N //= 26",
"+print((S[::-1]))"
] | false | 0.047014 | 0.125446 | 0.374776 | [
"s064671739",
"s225680714"
] |
u328510800 | p02952 | python | s711828308 | s002951584 | 55 | 47 | 2,940 | 2,940 | Accepted | Accepted | 14.55 | n = int(eval(input()))
res = 0
for i in range(1, n + 1):
l = len(str(i))
res += l & 1
print(res) | n = int(eval(input()))
print((sum([len(str(x)) & 1 for x in range(1, n+1)]))) | 8 | 2 | 103 | 76 | n = int(eval(input()))
res = 0
for i in range(1, n + 1):
l = len(str(i))
res += l & 1
print(res)
| n = int(eval(input()))
print((sum([len(str(x)) & 1 for x in range(1, n + 1)])))
| false | 75 | [
"-res = 0",
"-for i in range(1, n + 1):",
"- l = len(str(i))",
"- res += l & 1",
"-print(res)",
"+print((sum([len(str(x)) & 1 for x in range(1, n + 1)])))"
] | false | 0.090531 | 0.054129 | 1.672498 | [
"s711828308",
"s002951584"
] |
u502389123 | p03137 | python | s307880855 | s907808895 | 149 | 118 | 14,332 | 13,960 | Accepted | Accepted | 20.81 | N, M = list(map(int, input().split()))
X = list(map(int, input().split()))
X.sort()
L = []
for i in reversed(list(range(len(X)))):
if i - 1 < 0:
break
if (X[i] >= 0 and X[i-1] >= 0) or (X[i] <= 0 and X[i-1] <= 0):
L.append(abs(X[i] - X[i-1]))
else:
L.append(abs(X[i]) + abs(X[i-1]))
L.sort()
L_min = 0
for i in range(M-N):
L_min += L[i]
print(L_min)
| N, M = list(map(int, input().split()))
X = list(map(int, input().split()))
X.sort()
L = [0] * (M-1)
for i in range(M-1):
L[i] = abs(X[i+1] - X[i])
L.sort()
print((sum(L[:-(N-1)]) if N != 1 else sum(L)))
| 19 | 11 | 399 | 212 | N, M = list(map(int, input().split()))
X = list(map(int, input().split()))
X.sort()
L = []
for i in reversed(list(range(len(X)))):
if i - 1 < 0:
break
if (X[i] >= 0 and X[i - 1] >= 0) or (X[i] <= 0 and X[i - 1] <= 0):
L.append(abs(X[i] - X[i - 1]))
else:
L.append(abs(X[i]) + abs(X[i - 1]))
L.sort()
L_min = 0
for i in range(M - N):
L_min += L[i]
print(L_min)
| N, M = list(map(int, input().split()))
X = list(map(int, input().split()))
X.sort()
L = [0] * (M - 1)
for i in range(M - 1):
L[i] = abs(X[i + 1] - X[i])
L.sort()
print((sum(L[: -(N - 1)]) if N != 1 else sum(L)))
| false | 42.105263 | [
"-L = []",
"-for i in reversed(list(range(len(X)))):",
"- if i - 1 < 0:",
"- break",
"- if (X[i] >= 0 and X[i - 1] >= 0) or (X[i] <= 0 and X[i - 1] <= 0):",
"- L.append(abs(X[i] - X[i - 1]))",
"- else:",
"- L.append(abs(X[i]) + abs(X[i - 1]))",
"+L = [0] * (M - 1)",
"+for i in range(M - 1):",
"+ L[i] = abs(X[i + 1] - X[i])",
"-L_min = 0",
"-for i in range(M - N):",
"- L_min += L[i]",
"-print(L_min)",
"+print((sum(L[: -(N - 1)]) if N != 1 else sum(L)))"
] | false | 0.122144 | 0.043149 | 2.830788 | [
"s307880855",
"s907808895"
] |
u945181840 | p03295 | python | s560006611 | s913328617 | 205 | 160 | 23,732 | 29,720 | Accepted | Accepted | 21.95 | import sys
from operator import itemgetter
readline = sys.stdin.readline
readlines = sys.stdin.readlines
N, M = list(map(int, readline().split()))
ab = [tuple(map(int, i.split())) for i in readlines()]
ab.sort(key=itemgetter(1))
right_island = ab[0][1]
answer = 1
for i, j in ab:
if i >= right_island:
answer += 1
right_island = j
print(answer) | import sys
from operator import itemgetter
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
N, M = list(map(int, readline().split()))
ab = list(map(int, read().split()))
ab = sorted(zip(ab, ab), key=itemgetter(1))
right_island = ab[0][1]
answer = 1
for i, j in ab:
if i >= right_island:
answer += 1
right_island = j
print(answer) | 18 | 19 | 379 | 394 | import sys
from operator import itemgetter
readline = sys.stdin.readline
readlines = sys.stdin.readlines
N, M = list(map(int, readline().split()))
ab = [tuple(map(int, i.split())) for i in readlines()]
ab.sort(key=itemgetter(1))
right_island = ab[0][1]
answer = 1
for i, j in ab:
if i >= right_island:
answer += 1
right_island = j
print(answer)
| import sys
from operator import itemgetter
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
N, M = list(map(int, readline().split()))
ab = list(map(int, read().split()))
ab = sorted(zip(ab, ab), key=itemgetter(1))
right_island = ab[0][1]
answer = 1
for i, j in ab:
if i >= right_island:
answer += 1
right_island = j
print(answer)
| false | 5.263158 | [
"+read = sys.stdin.read",
"-ab = [tuple(map(int, i.split())) for i in readlines()]",
"-ab.sort(key=itemgetter(1))",
"+ab = list(map(int, read().split()))",
"+ab = sorted(zip(ab, ab), key=itemgetter(1))"
] | false | 0.082742 | 0.035932 | 2.302737 | [
"s560006611",
"s913328617"
] |
u691018832 | p03612 | python | s962585757 | s652761206 | 73 | 60 | 13,876 | 11,620 | Accepted | Accepted | 17.81 | # sys.stdin.readline()
import sys
input = sys.stdin.readline
n = int(eval(input()))
p = list(map(int, input().split()))
ans = 0
for i in range(n-1):
if i+1 == p[i]:
if p[i]+1 == p[i+1]:
p[i+1] = p[i]
ans += 1
if p[n-1] == n:
ans += 1
print(ans) | import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)
n, *p = list(map(int, read().split()))
p += [0]
cnt = 0
for i, pp in enumerate(p):
if (i + 1) == pp:
p[i + 1] = 0
cnt += 1
print(cnt)
| 15 | 14 | 289 | 309 | # sys.stdin.readline()
import sys
input = sys.stdin.readline
n = int(eval(input()))
p = list(map(int, input().split()))
ans = 0
for i in range(n - 1):
if i + 1 == p[i]:
if p[i] + 1 == p[i + 1]:
p[i + 1] = p[i]
ans += 1
if p[n - 1] == n:
ans += 1
print(ans)
| import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10**7)
n, *p = list(map(int, read().split()))
p += [0]
cnt = 0
for i, pp in enumerate(p):
if (i + 1) == pp:
p[i + 1] = 0
cnt += 1
print(cnt)
| false | 6.666667 | [
"-# sys.stdin.readline()",
"-input = sys.stdin.readline",
"-n = int(eval(input()))",
"-p = list(map(int, input().split()))",
"-ans = 0",
"-for i in range(n - 1):",
"- if i + 1 == p[i]:",
"- if p[i] + 1 == p[i + 1]:",
"- p[i + 1] = p[i]",
"- ans += 1",
"-if p[n - 1] == n:",
"- ans += 1",
"-print(ans)",
"+read = sys.stdin.buffer.read",
"+readline = sys.stdin.buffer.readline",
"+readlines = sys.stdin.buffer.readlines",
"+sys.setrecursionlimit(10**7)",
"+n, *p = list(map(int, read().split()))",
"+p += [0]",
"+cnt = 0",
"+for i, pp in enumerate(p):",
"+ if (i + 1) == pp:",
"+ p[i + 1] = 0",
"+ cnt += 1",
"+print(cnt)"
] | false | 0.048277 | 0.176735 | 0.273163 | [
"s962585757",
"s652761206"
] |
u102461423 | p02548 | python | s323099139 | s123499663 | 874 | 31 | 24,732 | 9,360 | Accepted | Accepted | 96.45 | N=int(eval(input()))
# 約数の個数のテーブルを O(N loglog N) で作る
div = [1] * (N+1)
div[0] = 0
for p in range(2, N+1):
if div[p] != 1:
continue
# p は素数
pp = p # power of p
e = 1
while pp <= N:
for n in range(pp, N+1, pp):
div[n] += div[n] // e
e += 1
pp *= p
ans = sum(div[:N])
print(ans) | """O(N^0.5) solution"""
N = int(eval(input()))
N -= 1
ans = 0
n = int(N**.5)
for x in range(1, n+1):
# (x,x)
ans += 1
# (x,y)
ans += N//x - x
# (y,x)
ans += N//x - x
print(ans) | 20 | 16 | 326 | 200 | N = int(eval(input()))
# 約数の個数のテーブルを O(N loglog N) で作る
div = [1] * (N + 1)
div[0] = 0
for p in range(2, N + 1):
if div[p] != 1:
continue
# p は素数
pp = p # power of p
e = 1
while pp <= N:
for n in range(pp, N + 1, pp):
div[n] += div[n] // e
e += 1
pp *= p
ans = sum(div[:N])
print(ans)
| """O(N^0.5) solution"""
N = int(eval(input()))
N -= 1
ans = 0
n = int(N**0.5)
for x in range(1, n + 1):
# (x,x)
ans += 1
# (x,y)
ans += N // x - x
# (y,x)
ans += N // x - x
print(ans)
| false | 20 | [
"+\"\"\"O(N^0.5) solution\"\"\"",
"-# 約数の個数のテーブルを O(N loglog N) で作る",
"-div = [1] * (N + 1)",
"-div[0] = 0",
"-for p in range(2, N + 1):",
"- if div[p] != 1:",
"- continue",
"- # p は素数",
"- pp = p # power of p",
"- e = 1",
"- while pp <= N:",
"- for n in range(pp, N + 1, pp):",
"- div[n] += div[n] // e",
"- e += 1",
"- pp *= p",
"-ans = sum(div[:N])",
"+N -= 1",
"+ans = 0",
"+n = int(N**0.5)",
"+for x in range(1, n + 1):",
"+ # (x,x)",
"+ ans += 1",
"+ # (x,y)",
"+ ans += N // x - x",
"+ # (y,x)",
"+ ans += N // x - x"
] | false | 0.147123 | 0.035564 | 4.136814 | [
"s323099139",
"s123499663"
] |
u785578220 | p02688 | python | s788912898 | s607156900 | 22 | 20 | 9,196 | 9,140 | Accepted | Accepted | 9.09 | n,k = list(map(int,input().split()))
l = [0]*n
# print(k)
for i in range(k):
for j in range(1):
_ = eval(input())
tl = list(map(int,input().split()))
for t in tl:
l[t-1]+=1
# print(i,j)
ans = 0
for i in l:
if i ==0:
ans +=1
print(ans) | n,k = list(map(int,input().split()))
dp = [0]*n
for i in range(k):
d = int(eval(input()))
A = list(map(int,input().split()))
for i in A:
dp[i-1] +=1
print((dp.count(0))) | 17 | 9 | 300 | 184 | n, k = list(map(int, input().split()))
l = [0] * n
# print(k)
for i in range(k):
for j in range(1):
_ = eval(input())
tl = list(map(int, input().split()))
for t in tl:
l[t - 1] += 1
# print(i,j)
ans = 0
for i in l:
if i == 0:
ans += 1
print(ans)
| n, k = list(map(int, input().split()))
dp = [0] * n
for i in range(k):
d = int(eval(input()))
A = list(map(int, input().split()))
for i in A:
dp[i - 1] += 1
print((dp.count(0)))
| false | 47.058824 | [
"-l = [0] * n",
"-# print(k)",
"+dp = [0] * n",
"- for j in range(1):",
"- _ = eval(input())",
"- tl = list(map(int, input().split()))",
"- for t in tl:",
"- l[t - 1] += 1",
"- # print(i,j)",
"-ans = 0",
"-for i in l:",
"- if i == 0:",
"- ans += 1",
"-print(ans)",
"+ d = int(eval(input()))",
"+ A = list(map(int, input().split()))",
"+ for i in A:",
"+ dp[i - 1] += 1",
"+print((dp.count(0)))"
] | false | 0.082394 | 0.046556 | 1.769778 | [
"s788912898",
"s607156900"
] |
u123745130 | p02791 | python | s436794343 | s525840337 | 169 | 148 | 24,744 | 24,744 | Accepted | Accepted | 12.43 | n=int(eval(input()))
l=list(map(int,input().split()))
mi=10**9
mi_lst=[]
cnt=0
for i in range(n):
if l[i]<mi:
mi_lst.append(l[i])
mi=min(mi,l[i])
cnt+=1
else:mi_lst.append(l[-1])
print(cnt) | n=int(eval(input()))
l=list(map(int,input().split()))
mi=10**9
cnt=0
for i in range(n):
if l[i]<mi:
mi=min(mi,l[i])
cnt+=1
print(cnt) | 12 | 9 | 210 | 145 | n = int(eval(input()))
l = list(map(int, input().split()))
mi = 10**9
mi_lst = []
cnt = 0
for i in range(n):
if l[i] < mi:
mi_lst.append(l[i])
mi = min(mi, l[i])
cnt += 1
else:
mi_lst.append(l[-1])
print(cnt)
| n = int(eval(input()))
l = list(map(int, input().split()))
mi = 10**9
cnt = 0
for i in range(n):
if l[i] < mi:
mi = min(mi, l[i])
cnt += 1
print(cnt)
| false | 25 | [
"-mi_lst = []",
"- mi_lst.append(l[i])",
"- else:",
"- mi_lst.append(l[-1])"
] | false | 0.036245 | 0.035454 | 1.022305 | [
"s436794343",
"s525840337"
] |
u597374218 | p03545 | python | s790045404 | s911667055 | 19 | 17 | 3,064 | 3,060 | Accepted | Accepted | 10.53 | A,B,C,D=eval(input())
digits=3
op=[""]*digits
for i in range(1<<digits):
for j in range(digits):
if (i>>j)&1:
op[j]="+"
else:
op[j]="-"
if eval(A+op[0]+B+op[1]+C+op[2]+D)==7:
print((A+op[0]+B+op[1]+C+op[2]+D+"=7"))
break | ABCD=eval(input())
digits=3
ops=[""]*(digits+1)
for i in range(1<<digits):
for j in range(digits):
if (i>>j)&1:
ops[j]="+"
else:
ops[j]="-"
evals=""
for num,op in zip(ABCD,ops):
evals+=num+op
if eval(evals)==7:
print((evals+"=7"))
break | 12 | 15 | 287 | 322 | A, B, C, D = eval(input())
digits = 3
op = [""] * digits
for i in range(1 << digits):
for j in range(digits):
if (i >> j) & 1:
op[j] = "+"
else:
op[j] = "-"
if eval(A + op[0] + B + op[1] + C + op[2] + D) == 7:
print((A + op[0] + B + op[1] + C + op[2] + D + "=7"))
break
| ABCD = eval(input())
digits = 3
ops = [""] * (digits + 1)
for i in range(1 << digits):
for j in range(digits):
if (i >> j) & 1:
ops[j] = "+"
else:
ops[j] = "-"
evals = ""
for num, op in zip(ABCD, ops):
evals += num + op
if eval(evals) == 7:
print((evals + "=7"))
break
| false | 20 | [
"-A, B, C, D = eval(input())",
"+ABCD = eval(input())",
"-op = [\"\"] * digits",
"+ops = [\"\"] * (digits + 1)",
"- op[j] = \"+\"",
"+ ops[j] = \"+\"",
"- op[j] = \"-\"",
"- if eval(A + op[0] + B + op[1] + C + op[2] + D) == 7:",
"- print((A + op[0] + B + op[1] + C + op[2] + D + \"=7\"))",
"+ ops[j] = \"-\"",
"+ evals = \"\"",
"+ for num, op in zip(ABCD, ops):",
"+ evals += num + op",
"+ if eval(evals) == 7:",
"+ print((evals + \"=7\"))"
] | false | 0.074658 | 0.05244 | 1.423681 | [
"s790045404",
"s911667055"
] |
u630211216 | p03814 | python | s153832300 | s572351455 | 45 | 28 | 9,240 | 9,124 | Accepted | Accepted | 37.78 | S=eval(input())
left=0
while S[left]!='A':
left+=1
right=len(S)-1
while S[right]!='Z':
right-=1
print((right-left+1))
| s=eval(input())
print((s.rfind('Z')-s.find('A')+1))
| 8 | 2 | 125 | 45 | S = eval(input())
left = 0
while S[left] != "A":
left += 1
right = len(S) - 1
while S[right] != "Z":
right -= 1
print((right - left + 1))
| s = eval(input())
print((s.rfind("Z") - s.find("A") + 1))
| false | 75 | [
"-S = eval(input())",
"-left = 0",
"-while S[left] != \"A\":",
"- left += 1",
"-right = len(S) - 1",
"-while S[right] != \"Z\":",
"- right -= 1",
"-print((right - left + 1))",
"+s = eval(input())",
"+print((s.rfind(\"Z\") - s.find(\"A\") + 1))"
] | false | 0.037843 | 0.037959 | 0.996942 | [
"s153832300",
"s572351455"
] |
u604839890 | p03031 | python | s248451951 | s932339478 | 48 | 40 | 9,224 | 9,164 | Accepted | Accepted | 16.67 | N, M = list(map(int, input().split()))
ks = [list(map(int, input().split())) for _ in range(M)]
p = list(map(int, input().split()))
ans = 0
for ii in range(2**N):
check = True
for i in range(M):
cnt = 0
for j in range(1, len(ks[i])):
if (ii >> (ks[i][j]-1)) & 1:
cnt += 1
if cnt % 2 != p[i]:
check = False
break
if check:
ans += 1
print(ans) | n, m = list(map(int, input().split()))
ks = [list(map(int, input().split())) for _ in range(m)]
p = list(map(int, input().split()))
ans = 0
for i in range(2**n):
flag = True
for j in range(m):
cnt = 0
for k in range(1, len(ks[j])):
if (i >> (ks[j][k]-1)) & 1:
cnt += 1
if cnt % 2 != p[j]:
flag = False
break
if flag:
ans += 1
print(ans) | 18 | 18 | 449 | 444 | N, M = list(map(int, input().split()))
ks = [list(map(int, input().split())) for _ in range(M)]
p = list(map(int, input().split()))
ans = 0
for ii in range(2**N):
check = True
for i in range(M):
cnt = 0
for j in range(1, len(ks[i])):
if (ii >> (ks[i][j] - 1)) & 1:
cnt += 1
if cnt % 2 != p[i]:
check = False
break
if check:
ans += 1
print(ans)
| n, m = list(map(int, input().split()))
ks = [list(map(int, input().split())) for _ in range(m)]
p = list(map(int, input().split()))
ans = 0
for i in range(2**n):
flag = True
for j in range(m):
cnt = 0
for k in range(1, len(ks[j])):
if (i >> (ks[j][k] - 1)) & 1:
cnt += 1
if cnt % 2 != p[j]:
flag = False
break
if flag:
ans += 1
print(ans)
| false | 0 | [
"-N, M = list(map(int, input().split()))",
"-ks = [list(map(int, input().split())) for _ in range(M)]",
"+n, m = list(map(int, input().split()))",
"+ks = [list(map(int, input().split())) for _ in range(m)]",
"-for ii in range(2**N):",
"- check = True",
"- for i in range(M):",
"+for i in range(2**n):",
"+ flag = True",
"+ for j in range(m):",
"- for j in range(1, len(ks[i])):",
"- if (ii >> (ks[i][j] - 1)) & 1:",
"+ for k in range(1, len(ks[j])):",
"+ if (i >> (ks[j][k] - 1)) & 1:",
"- if cnt % 2 != p[i]:",
"- check = False",
"+ if cnt % 2 != p[j]:",
"+ flag = False",
"- if check:",
"+ if flag:"
] | false | 0.040232 | 0.04229 | 0.951346 | [
"s248451951",
"s932339478"
] |
u852798899 | p03945 | python | s581931108 | s261751884 | 65 | 43 | 3,956 | 3,956 | Accepted | Accepted | 33.85 | S = list(eval(input()))
i = 0
count = 0
while(i < len(S)-1):
if S[i] != S[i+1]:
count+=1
i+=1
print(count)
| S = list(eval(input()))
i = 0
count = 0
for i in range(len(S)-1):
if S[i] != S[i+1]:
count+=1
print(count)
| 12 | 11 | 130 | 127 | S = list(eval(input()))
i = 0
count = 0
while i < len(S) - 1:
if S[i] != S[i + 1]:
count += 1
i += 1
print(count)
| S = list(eval(input()))
i = 0
count = 0
for i in range(len(S) - 1):
if S[i] != S[i + 1]:
count += 1
print(count)
| false | 8.333333 | [
"-while i < len(S) - 1:",
"+for i in range(len(S) - 1):",
"- i += 1"
] | false | 0.065771 | 0.03713 | 1.771383 | [
"s581931108",
"s261751884"
] |
u886729200 | p02418 | python | s941058954 | s300133686 | 30 | 20 | 5,548 | 5,548 | Accepted | Accepted | 33.33 | s = eval(input())
s = s+s
p = eval(input())
if p in s:
print("Yes")
else:
print("No")
| s = eval(input())
p = eval(input())
s = s*2
if p in s:
print("Yes")
else:
print("No")
| 7 | 8 | 88 | 90 | s = eval(input())
s = s + s
p = eval(input())
if p in s:
print("Yes")
else:
print("No")
| s = eval(input())
p = eval(input())
s = s * 2
if p in s:
print("Yes")
else:
print("No")
| false | 12.5 | [
"-s = s + s",
"+s = s * 2"
] | false | 0.041218 | 0.044297 | 0.930502 | [
"s941058954",
"s300133686"
] |
u989345508 | p02821 | python | s214087076 | s208010193 | 523 | 483 | 85,012 | 84,980 | Accepted | Accepted | 7.65 | n,m=list(map(int,input().split()))
a=list(map(int,input().split()))
a.sort()
if n==1:
print((a[0]*2))
exit()
from bisect import bisect_left,bisect_right
#幸福度がx以上がm以上か？
def f(x):
global n,a
ret=0
for i in range(n):
ret+=(n-bisect_left(a,x-a[i]))
return ret
l,r=-1,10**6
while l+1<r:
k=l+(r-l)//2
if f(k)>=m:
l=k
else:
r=k
#print(l,r)
#print(f(l),f(r))
if f(r)>=m:
co,ans=0,0
for i in range(n):
co+=(n-bisect_right(a,r-a[i]))
ans+=(n-bisect_right(a,r-a[i]))*a[i]
print((2*ans+(m-co)*r))
else:
co,ans=0,0
for i in range(n):
co+=(n-bisect_right(a,l-a[i]))
ans+=(n-bisect_right(a,l-a[i]))*a[i]
print((2*ans+(m-co)*l)) | n,m=list(map(int,input().split()))
a=list(map(int,input().split()))
a.sort()
if n==1:
print((a[0]*2))
exit()
from bisect import bisect_left,bisect_right
#幸福度がx以上がm以上か？
def f(x):
global n,a
ret=0
for i in range(n):
ret+=(n-bisect_left(a,x-a[i]))
return ret
#端がやはりコーナーケース(ここまじでバグらせんな)
l,r=-1,10**6
while l+1<r:
k=l+(r-l)//2
if f(k)>=m:
l=k
else:
r=k
co,ans=0,0
for i in range(n):
co+=(n-bisect_right(a,l-a[i]))
ans+=(n-bisect_right(a,l-a[i]))*a[i]
print((2*ans+(m-co)*l)) | 35 | 27 | 750 | 553 | n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
a.sort()
if n == 1:
print((a[0] * 2))
exit()
from bisect import bisect_left, bisect_right
# 幸福度がx以上がm以上か？
def f(x):
global n, a
ret = 0
for i in range(n):
ret += n - bisect_left(a, x - a[i])
return ret
l, r = -1, 10**6
while l + 1 < r:
k = l + (r - l) // 2
if f(k) >= m:
l = k
else:
r = k
# print(l,r)
# print(f(l),f(r))
if f(r) >= m:
co, ans = 0, 0
for i in range(n):
co += n - bisect_right(a, r - a[i])
ans += (n - bisect_right(a, r - a[i])) * a[i]
print((2 * ans + (m - co) * r))
else:
co, ans = 0, 0
for i in range(n):
co += n - bisect_right(a, l - a[i])
ans += (n - bisect_right(a, l - a[i])) * a[i]
print((2 * ans + (m - co) * l))
| n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
a.sort()
if n == 1:
print((a[0] * 2))
exit()
from bisect import bisect_left, bisect_right
# 幸福度がx以上がm以上か？
def f(x):
global n, a
ret = 0
for i in range(n):
ret += n - bisect_left(a, x - a[i])
return ret
# 端がやはりコーナーケース(ここまじでバグらせんな)
l, r = -1, 10**6
while l + 1 < r:
k = l + (r - l) // 2
if f(k) >= m:
l = k
else:
r = k
co, ans = 0, 0
for i in range(n):
co += n - bisect_right(a, l - a[i])
ans += (n - bisect_right(a, l - a[i])) * a[i]
print((2 * ans + (m - co) * l))
| false | 22.857143 | [
"+# 端がやはりコーナーケース(ここまじでバグらせんな)",
"-# print(l,r)",
"-# print(f(l),f(r))",
"-if f(r) >= m:",
"- co, ans = 0, 0",
"- for i in range(n):",
"- co += n - bisect_right(a, r - a[i])",
"- ans += (n - bisect_right(a, r - a[i])) * a[i]",
"- print((2 * ans + (m - co) * r))",
"-else:",
"- co, ans = 0, 0",
"- for i in range(n):",
"- co += n - bisect_right(a, l - a[i])",
"- ans += (n - bisect_right(a, l - a[i])) * a[i]",
"- print((2 * ans + (m - co) * l))",
"+co, ans = 0, 0",
"+for i in range(n):",
"+ co += n - bisect_right(a, l - a[i])",
"+ ans += (n - bisect_right(a, l - a[i])) * a[i]",
"+print((2 * ans + (m - co) * l))"
] | false | 0.045076 | 0.043425 | 1.038025 | [
"s214087076",
"s208010193"
] |
u757117214 | p03208 | python | s998661704 | s870290746 | 151 | 116 | 14,092 | 14,092 | Accepted | Accepted | 23.18 | N,K,*h=list(map(int,open(0).read().split()))
h.sort()
if K == N:
print((h[-1] - h[0]))
else:
dif_h=[]
for i in range(N-1):
dif_h.append(h[i+1] - h[i])
_min = base = sum(dif_h[:K-1])
for i in range(K-1,N-1):
base += dif_h[i]
base -= dif_h[i-K+1]
_min = min(base,_min)
print(_min)
| N,K,*h=list(map(int,open(0).read().split()))
h.sort()
_min = 10**9
for i in range(N+1-K):
_min = min(_min, h[i+K-1] - h[i])
print(_min) | 17 | 6 | 369 | 138 | N, K, *h = list(map(int, open(0).read().split()))
h.sort()
if K == N:
print((h[-1] - h[0]))
else:
dif_h = []
for i in range(N - 1):
dif_h.append(h[i + 1] - h[i])
_min = base = sum(dif_h[: K - 1])
for i in range(K - 1, N - 1):
base += dif_h[i]
base -= dif_h[i - K + 1]
_min = min(base, _min)
print(_min)
| N, K, *h = list(map(int, open(0).read().split()))
h.sort()
_min = 10**9
for i in range(N + 1 - K):
_min = min(_min, h[i + K - 1] - h[i])
print(_min)
| false | 64.705882 | [
"-if K == N:",
"- print((h[-1] - h[0]))",
"-else:",
"- dif_h = []",
"- for i in range(N - 1):",
"- dif_h.append(h[i + 1] - h[i])",
"- _min = base = sum(dif_h[: K - 1])",
"- for i in range(K - 1, N - 1):",
"- base += dif_h[i]",
"- base -= dif_h[i - K + 1]",
"- _min = min(base, _min)",
"- print(_min)",
"+_min = 10**9",
"+for i in range(N + 1 - K):",
"+ _min = min(_min, h[i + K - 1] - h[i])",
"+print(_min)"
] | false | 0.041469 | 0.036991 | 1.121045 | [
"s998661704",
"s870290746"
] |
u796942881 | p03137 | python | s301785709 | s671503244 | 202 | 101 | 28,052 | 13,960 | Accepted | Accepted | 50 | import numpy as np
N, M = list(map(int, input().split()))
X = list(set(map(int, input().split())))
X.sort()
D = np.diff(X)
D.sort()
print((0 if M <= N else np.sum(D[:M-N])))
| N, M = list(map(int, input().split()))
X = list(map(int, input().split()))
X.sort()
D = [X[i+1] - X[i] for i in range(M - 1)]
D.sort()
print((0 if M <= N else sum(D[:M-N]))) | 12 | 10 | 182 | 178 | import numpy as np
N, M = list(map(int, input().split()))
X = list(set(map(int, input().split())))
X.sort()
D = np.diff(X)
D.sort()
print((0 if M <= N else np.sum(D[: M - N])))
| N, M = list(map(int, input().split()))
X = list(map(int, input().split()))
X.sort()
D = [X[i + 1] - X[i] for i in range(M - 1)]
D.sort()
print((0 if M <= N else sum(D[: M - N])))
| false | 16.666667 | [
"-import numpy as np",
"-",
"-X = list(set(map(int, input().split())))",
"+X = list(map(int, input().split()))",
"-D = np.diff(X)",
"+D = [X[i + 1] - X[i] for i in range(M - 1)]",
"-print((0 if M <= N else np.sum(D[: M - N])))",
"+print((0 if M <= N else sum(D[: M - N])))"
] | false | 0.007721 | 0.032029 | 0.241072 | [
"s301785709",
"s671503244"
] |
u489959379 | p03108 | python | s174997003 | s077220855 | 704 | 480 | 34,808 | 33,620 | Accepted | Accepted | 31.82 | import sys
sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline
f_inf = float('inf')
mod = 10 ** 9 + 7
\
class UnionFind:
def __init__(self, n):
self.n = n
self.parents = [-1] * n
# 親が同じか判別
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
# 根を繋ぎ直す
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
# 親が同じか判別
def same(self, x, y):
return self.find(x) == self.find(y)
# 連結成分の大きさを返す
def size(self, x):
return -self.parents[self.find(x)]
def resolve():
n, m = list(map(int, input().split()))
AB = [list(map(int, input().split())) for _ in range(m)][::-1]
uf = UnionFind(n)
res = [(n * (n - 1)) // 2]
for a, b in AB:
if not uf.same(a - 1, b - 1):
pre1 = uf.size(a - 1)
pre2 = uf.size(b - 1)
pre_score = (pre1 * (pre1 - 1)) // 2 + (pre2 * (pre2 - 1)) // 2
uf.union(a - 1, b - 1)
now = uf.size(a - 1)
now_score = (now * (now - 1)) // 2
res.append(res[-1] + pre_score - now_score)
else:
res.append(res[-1])
for i in reversed(list(range(m))):
print((res[i]))
if __name__ == '__main__':
resolve()
| import sys
sys.setrecursionlimit(10 ** 7)
f_inf = float('inf')
mod = 10 ** 9 + 7
class UnionFind:
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
"""
親が同じか判別する
"""
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
"""
yをxの根に繋ぐ
"""
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def same(self, x, y):
"""
xとyが同じ連結成分か判別する
"""
return self.find(x) == self.find(y)
def size(self, x):
"""
xの連結成分の大きさを返す
"""
return -self.parents[self.find(x)]
def kruskal(self, edge):
"""
:param edge: edge = [(コスト, 頂点1, 頂点2),...]の形で重み付き隣接リストを渡して下さい
:return: 最小全域木のコストの和
"""
edge.sort()
cost_sum = 0
for cost, node1, node2 in edge:
if not self.same(node1, node2):
cost_sum += cost
self.union(node1, node2)
return cost_sum
def resolve():
n, m = map(int, input().split())
edge = [list(map(lambda x: int(x) - 1, input().split())) for _ in range(m)]
uf = UnionFind(n)
res = [(n - 1) * n // 2]
for i in reversed(range(1, m)):
a, b = edge[i]
if not uf.same(a, b):
res.append(res[-1] - uf.size(a) * uf.size(b))
uf.union(a, b)
else:
res.append(res[-1])
print(*res[::-1], sep="\n")
if __name__ == '__main__':
resolve()
| 68 | 78 | 1,607 | 1,866 | import sys
sys.setrecursionlimit(10**7)
input = sys.stdin.readline
f_inf = float("inf")
mod = 10**9 + 7
class UnionFind:
def __init__(self, n):
self.n = n
self.parents = [-1] * n
# 親が同じか判別
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
# 根を繋ぎ直す
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
# 親が同じか判別
def same(self, x, y):
return self.find(x) == self.find(y)
# 連結成分の大きさを返す
def size(self, x):
return -self.parents[self.find(x)]
def resolve():
n, m = list(map(int, input().split()))
AB = [list(map(int, input().split())) for _ in range(m)][::-1]
uf = UnionFind(n)
res = [(n * (n - 1)) // 2]
for a, b in AB:
if not uf.same(a - 1, b - 1):
pre1 = uf.size(a - 1)
pre2 = uf.size(b - 1)
pre_score = (pre1 * (pre1 - 1)) // 2 + (pre2 * (pre2 - 1)) // 2
uf.union(a - 1, b - 1)
now = uf.size(a - 1)
now_score = (now * (now - 1)) // 2
res.append(res[-1] + pre_score - now_score)
else:
res.append(res[-1])
for i in reversed(list(range(m))):
print((res[i]))
if __name__ == "__main__":
resolve()
| import sys
sys.setrecursionlimit(10**7)
f_inf = float("inf")
mod = 10**9 + 7
class UnionFind:
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
"""
親が同じか判別する
"""
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
"""
yをxの根に繋ぐ
"""
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def same(self, x, y):
"""
xとyが同じ連結成分か判別する
"""
return self.find(x) == self.find(y)
def size(self, x):
"""
xの連結成分の大きさを返す
"""
return -self.parents[self.find(x)]
def kruskal(self, edge):
"""
:param edge: edge = [(コスト, 頂点1, 頂点2),...]の形で重み付き隣接リストを渡して下さい
:return: 最小全域木のコストの和
"""
edge.sort()
cost_sum = 0
for cost, node1, node2 in edge:
if not self.same(node1, node2):
cost_sum += cost
self.union(node1, node2)
return cost_sum
def resolve():
n, m = map(int, input().split())
edge = [list(map(lambda x: int(x) - 1, input().split())) for _ in range(m)]
uf = UnionFind(n)
res = [(n - 1) * n // 2]
for i in reversed(range(1, m)):
a, b = edge[i]
if not uf.same(a, b):
res.append(res[-1] - uf.size(a) * uf.size(b))
uf.union(a, b)
else:
res.append(res[-1])
print(*res[::-1], sep="\n")
if __name__ == "__main__":
resolve()
| false | 12.820513 | [
"-input = sys.stdin.readline",
"- # 親が同じか判別",
"+ \"\"\"",
"+ 親が同じか判別する",
"+ \"\"\"",
"- # 根を繋ぎ直す",
"+ \"\"\"",
"+ yをxの根に繋ぐ",
"+ \"\"\"",
"- # 親が同じか判別",
"+ \"\"\"",
"+ xとyが同じ連結成分か判別する",
"+ \"\"\"",
"- # 連結成分の大きさを返す",
"+ \"\"\"",
"+ xの連結成分の大きさを返す",
"+ \"\"\"",
"+",
"+ def kruskal(self, edge):",
"+ \"\"\"",
"+ :param edge: edge = [(コスト, 頂点1, 頂点2),...]の形で重み付き隣接リストを渡して下さい",
"+ :return: 最小全域木のコストの和",
"+ \"\"\"",
"+ edge.sort()",
"+ cost_sum = 0",
"+ for cost, node1, node2 in edge:",
"+ if not self.same(node1, node2):",
"+ cost_sum += cost",
"+ self.union(node1, node2)",
"+ return cost_sum",
"- n, m = list(map(int, input().split()))",
"- AB = [list(map(int, input().split())) for _ in range(m)][::-1]",
"+ n, m = map(int, input().split())",
"+ edge = [list(map(lambda x: int(x) - 1, input().split())) for _ in range(m)]",
"- res = [(n * (n - 1)) // 2]",
"- for a, b in AB:",
"- if not uf.same(a - 1, b - 1):",
"- pre1 = uf.size(a - 1)",
"- pre2 = uf.size(b - 1)",
"- pre_score = (pre1 * (pre1 - 1)) // 2 + (pre2 * (pre2 - 1)) // 2",
"- uf.union(a - 1, b - 1)",
"- now = uf.size(a - 1)",
"- now_score = (now * (now - 1)) // 2",
"- res.append(res[-1] + pre_score - now_score)",
"+ res = [(n - 1) * n // 2]",
"+ for i in reversed(range(1, m)):",
"+ a, b = edge[i]",
"+ if not uf.same(a, b):",
"+ res.append(res[-1] - uf.size(a) * uf.size(b))",
"+ uf.union(a, b)",
"- for i in reversed(list(range(m))):",
"- print((res[i]))",
"+ print(*res[::-1], sep=\"\\n\")"
] | false | 0.035699 | 0.03509 | 1.017348 | [
"s174997003",
"s077220855"
] |
u281303342 | p03855 | python | s896509030 | s508385767 | 1,338 | 1,197 | 65,016 | 109,552 | Accepted | Accepted | 10.54 | from collections import defaultdict
N,K,L = list(map(int,input().split()))
class UnionFind:
def __init__(self, n):
self.par = [i for i in range(n+1)]
self.rank = [0] * (n+1)
def find(self, x):
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if self.rank[x] < self.rank[y]:
self.par[x] = y
else:
self.par[y] = x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
def check(self, x, y):
return self.find(x) == self.find(y)
# 道路
A = UnionFind(N)
for i in range(K):
x,y = list(map(int,input().split()))
A.unite(x,y)
# 鉄道
B = UnionFind(N)
for i in range(L):
x,y = list(map(int,input().split()))
B.unite(x,y)
dic = defaultdict(int)
for i in range(1,N+1):
dic[A.find(i),B.find(i)] += 1
Ans = list(dic[A.par[i],B.par[i]] for i in range(1,N+1))
print((" ".join(map(str,Ans))))
| # python3 (3.4.3)
import sys
input = sys.stdin.readline
# functions
class UnionFind:
def __init__(self, n):
self.par = [i for i in range(n)]
self.rank = [0] * (n)
def find(self, x):
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if self.rank[x] < self.rank[y]:
self.par[x] = y
else:
self.par[y] = x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
def is_same(self, x, y):
return self.find(x) == self.find(y)
# main
from collections import defaultdict
N,K,L = list(map(int,input().split()))
PQ = [list(map(int,input().split())) for _ in range(K)]
RS = [list(map(int,input().split())) for _ in range(L)]
# 道路
A = UnionFind(N)
for p,q in PQ:
A.unite(p-1,q-1)
# 鉄道
B = UnionFind(N)
for r,s in RS:
B.unite(r-1,s-1)
dic = defaultdict(int)
for i in range(N):
dic[A.find(i), B.find(i)] += 1
Ans = list(dic[A.find(i), B.find(i)] for i in range(N))
print((" ".join(map(str,Ans)))) | 44 | 52 | 1,095 | 1,217 | from collections import defaultdict
N, K, L = list(map(int, input().split()))
class UnionFind:
def __init__(self, n):
self.par = [i for i in range(n + 1)]
self.rank = [0] * (n + 1)
def find(self, x):
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if self.rank[x] < self.rank[y]:
self.par[x] = y
else:
self.par[y] = x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
def check(self, x, y):
return self.find(x) == self.find(y)
# 道路
A = UnionFind(N)
for i in range(K):
x, y = list(map(int, input().split()))
A.unite(x, y)
# 鉄道
B = UnionFind(N)
for i in range(L):
x, y = list(map(int, input().split()))
B.unite(x, y)
dic = defaultdict(int)
for i in range(1, N + 1):
dic[A.find(i), B.find(i)] += 1
Ans = list(dic[A.par[i], B.par[i]] for i in range(1, N + 1))
print((" ".join(map(str, Ans))))
| # python3 (3.4.3)
import sys
input = sys.stdin.readline
# functions
class UnionFind:
def __init__(self, n):
self.par = [i for i in range(n)]
self.rank = [0] * (n)
def find(self, x):
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if self.rank[x] < self.rank[y]:
self.par[x] = y
else:
self.par[y] = x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
def is_same(self, x, y):
return self.find(x) == self.find(y)
# main
from collections import defaultdict
N, K, L = list(map(int, input().split()))
PQ = [list(map(int, input().split())) for _ in range(K)]
RS = [list(map(int, input().split())) for _ in range(L)]
# 道路
A = UnionFind(N)
for p, q in PQ:
A.unite(p - 1, q - 1)
# 鉄道
B = UnionFind(N)
for r, s in RS:
B.unite(r - 1, s - 1)
dic = defaultdict(int)
for i in range(N):
dic[A.find(i), B.find(i)] += 1
Ans = list(dic[A.find(i), B.find(i)] for i in range(N))
print((" ".join(map(str, Ans))))
| false | 15.384615 | [
"-from collections import defaultdict",
"+# python3 (3.4.3)",
"+import sys",
"-N, K, L = list(map(int, input().split()))",
"-",
"-",
"+input = sys.stdin.readline",
"+# functions",
"- self.par = [i for i in range(n + 1)]",
"- self.rank = [0] * (n + 1)",
"+ self.par = [i for i in range(n)]",
"+ self.rank = [0] * (n)",
"- def check(self, x, y):",
"+ def is_same(self, x, y):",
"+# main",
"+from collections import defaultdict",
"+",
"+N, K, L = list(map(int, input().split()))",
"+PQ = [list(map(int, input().split())) for _ in range(K)]",
"+RS = [list(map(int, input().split())) for _ in range(L)]",
"-for i in range(K):",
"- x, y = list(map(int, input().split()))",
"- A.unite(x, y)",
"+for p, q in PQ:",
"+ A.unite(p - 1, q - 1)",
"-for i in range(L):",
"- x, y = list(map(int, input().split()))",
"- B.unite(x, y)",
"+for r, s in RS:",
"+ B.unite(r - 1, s - 1)",
"-for i in range(1, N + 1):",
"+for i in range(N):",
"-Ans = list(dic[A.par[i], B.par[i]] for i in range(1, N + 1))",
"+Ans = list(dic[A.find(i), B.find(i)] for i in range(N))"
] | false | 0.190871 | 0.044842 | 4.256506 | [
"s896509030",
"s508385767"
] |
u057109575 | p02804 | python | s017860036 | s267046349 | 284 | 144 | 70,636 | 91,752 | Accepted | Accepted | 49.3 | N, K, *A = list(map(int, open(0).read().split()))
MOD = 10 ** 9 + 7
fac = [0] * (N + 1)
fac[0] = 1
fac[1] = 1
for i in range(2, N + 1):
fac[i] = fac[i - 1] * i % MOD
finv = [0] * (N + 1)
finv[N] = pow(fac[N], MOD - 2, MOD)
for i in reversed(list(range(1, N + 1))):
finv[i - 1] = finv[i] * i % MOD
def comb(n, k):
if n < k:
return 0
return fac[n] * finv[k] * finv[n - k] % MOD
ans = 0
for i, a in enumerate(sorted(A, reverse=True)):
ans += a * comb(N - i - 1, K - 1)
ans -= a * comb(i, K - 1)
ans %= MOD
print(ans)
| N, K, *A = list(map(int, open(0).read().split()))
MAX = 10 ** 5 + 1
MOD = 10 ** 9 + 7
# Factorial
fac = [0] * (MAX + 1)
fac[0] = 1
fac[1] = 1
for i in range(2, MAX + 1):
fac[i] = fac[i - 1] * i % MOD
# Inverse factorial
finv = [0] * (MAX + 1)
finv[MAX] = pow(fac[MAX], MOD - 2, MOD)
for i in reversed(list(range(1, MAX + 1))):
finv[i - 1] = finv[i] * i % MOD
def comb(n, k):
if n < k or k < 0:
return 0
return (fac[n] * finv[k] * finv[n - k]) % MOD
A.sort()
ans = 0
for i in range(N):
if i >= K - 1:
ans += comb(i, K - 1) * A[i]
if i + K - 1 < N:
ans -= comb(N - i - 1, K - 1) * A[i]
ans %= MOD
print(ans)
| 27 | 34 | 574 | 690 | N, K, *A = list(map(int, open(0).read().split()))
MOD = 10**9 + 7
fac = [0] * (N + 1)
fac[0] = 1
fac[1] = 1
for i in range(2, N + 1):
fac[i] = fac[i - 1] * i % MOD
finv = [0] * (N + 1)
finv[N] = pow(fac[N], MOD - 2, MOD)
for i in reversed(list(range(1, N + 1))):
finv[i - 1] = finv[i] * i % MOD
def comb(n, k):
if n < k:
return 0
return fac[n] * finv[k] * finv[n - k] % MOD
ans = 0
for i, a in enumerate(sorted(A, reverse=True)):
ans += a * comb(N - i - 1, K - 1)
ans -= a * comb(i, K - 1)
ans %= MOD
print(ans)
| N, K, *A = list(map(int, open(0).read().split()))
MAX = 10**5 + 1
MOD = 10**9 + 7
# Factorial
fac = [0] * (MAX + 1)
fac[0] = 1
fac[1] = 1
for i in range(2, MAX + 1):
fac[i] = fac[i - 1] * i % MOD
# Inverse factorial
finv = [0] * (MAX + 1)
finv[MAX] = pow(fac[MAX], MOD - 2, MOD)
for i in reversed(list(range(1, MAX + 1))):
finv[i - 1] = finv[i] * i % MOD
def comb(n, k):
if n < k or k < 0:
return 0
return (fac[n] * finv[k] * finv[n - k]) % MOD
A.sort()
ans = 0
for i in range(N):
if i >= K - 1:
ans += comb(i, K - 1) * A[i]
if i + K - 1 < N:
ans -= comb(N - i - 1, K - 1) * A[i]
ans %= MOD
print(ans)
| false | 20.588235 | [
"+MAX = 10**5 + 1",
"-fac = [0] * (N + 1)",
"+# Factorial",
"+fac = [0] * (MAX + 1)",
"-for i in range(2, N + 1):",
"+for i in range(2, MAX + 1):",
"-finv = [0] * (N + 1)",
"-finv[N] = pow(fac[N], MOD - 2, MOD)",
"-for i in reversed(list(range(1, N + 1))):",
"+# Inverse factorial",
"+finv = [0] * (MAX + 1)",
"+finv[MAX] = pow(fac[MAX], MOD - 2, MOD)",
"+for i in reversed(list(range(1, MAX + 1))):",
"- if n < k:",
"+ if n < k or k < 0:",
"- return fac[n] * finv[k] * finv[n - k] % MOD",
"+ return (fac[n] * finv[k] * finv[n - k]) % MOD",
"+A.sort()",
"-for i, a in enumerate(sorted(A, reverse=True)):",
"- ans += a * comb(N - i - 1, K - 1)",
"- ans -= a * comb(i, K - 1)",
"+for i in range(N):",
"+ if i >= K - 1:",
"+ ans += comb(i, K - 1) * A[i]",
"+ if i + K - 1 < N:",
"+ ans -= comb(N - i - 1, K - 1) * A[i]"
] | false | 0.080824 | 0.248657 | 0.325042 | [
"s017860036",
"s267046349"
] |
u285443936 | p04015 | python | s628563561 | s792646288 | 443 | 345 | 93,004 | 92,636 | Accepted | Accepted | 22.12 | N, A = list(map(int, input().split()))
x = [int(i) for i in input().split()]
ans = 0
dp = [[[0]*(50*N+1) for j in range(N+1)] for k in range(N+1)]
dp[0][0][0] = 1
for j in range(1,N+1):
for k in range(N+1):
for s in range(50*N+1):
dp[j][k][s] = dp[j-1][k][s]
if s>=x[j-1]:
dp[j][k][s] += dp[j-1][k-1][s-x[j-1]]
for k in range(1,N+1):
ans += dp[N][k][k*A]
print(ans) | N, A = list(map(int, input().split()))
x= [int(i) for i in input().split()]
X = max(x)
dp = [[[0]*(X*N+1) for i in range(N+1)] for j in range(N+1)]
dp[0][0][0] = 1
ans = 0
for j in range(1,N+1):
for k in range(j+1):
for s in range(X*N+1):
dp[j][k][s] = dp[j-1][k][s]
if s >= x[j-1]:
dp[j][k][s] += dp[j-1][k-1][s-x[j-1]]
for i in range(N+1):
ans += dp[-1][i][i*A]
if (i+1)*A > X*N:
break
print((ans-1)) | 15 | 19 | 403 | 454 | N, A = list(map(int, input().split()))
x = [int(i) for i in input().split()]
ans = 0
dp = [[[0] * (50 * N + 1) for j in range(N + 1)] for k in range(N + 1)]
dp[0][0][0] = 1
for j in range(1, N + 1):
for k in range(N + 1):
for s in range(50 * N + 1):
dp[j][k][s] = dp[j - 1][k][s]
if s >= x[j - 1]:
dp[j][k][s] += dp[j - 1][k - 1][s - x[j - 1]]
for k in range(1, N + 1):
ans += dp[N][k][k * A]
print(ans)
| N, A = list(map(int, input().split()))
x = [int(i) for i in input().split()]
X = max(x)
dp = [[[0] * (X * N + 1) for i in range(N + 1)] for j in range(N + 1)]
dp[0][0][0] = 1
ans = 0
for j in range(1, N + 1):
for k in range(j + 1):
for s in range(X * N + 1):
dp[j][k][s] = dp[j - 1][k][s]
if s >= x[j - 1]:
dp[j][k][s] += dp[j - 1][k - 1][s - x[j - 1]]
for i in range(N + 1):
ans += dp[-1][i][i * A]
if (i + 1) * A > X * N:
break
print((ans - 1))
| false | 21.052632 | [
"+X = max(x)",
"+dp = [[[0] * (X * N + 1) for i in range(N + 1)] for j in range(N + 1)]",
"+dp[0][0][0] = 1",
"-dp = [[[0] * (50 * N + 1) for j in range(N + 1)] for k in range(N + 1)]",
"-dp[0][0][0] = 1",
"- for k in range(N + 1):",
"- for s in range(50 * N + 1):",
"+ for k in range(j + 1):",
"+ for s in range(X * N + 1):",
"-for k in range(1, N + 1):",
"- ans += dp[N][k][k * A]",
"-print(ans)",
"+for i in range(N + 1):",
"+ ans += dp[-1][i][i * A]",
"+ if (i + 1) * A > X * N:",
"+ break",
"+print((ans - 1))"
] | false | 0.427784 | 0.050218 | 8.51846 | [
"s628563561",
"s792646288"
] |
u810787773 | p02912 | python | s912311754 | s886927382 | 579 | 124 | 20,504 | 20,604 | Accepted | Accepted | 78.58 | import copy
def bi_search(money,M,N):
money.sort()
#list = []
#for i in range(0,money[N-1]+2,1):
#list.append(i)
left = 0
right = money[N-1]+1
mid = 0
#print(list,left,right)
while True:
mid = int( (left+right)/2 )
cnt = 0
#print(left,right,mid)
#print(money)
money_tmp = copy.copy(money)
for i in range(N):
while True:
#print(money_tmp[i],i)
if money_tmp[i] <= mid:
break
else:
money_tmp[i] //= 2
cnt += 1
#print(cnt)
if cnt == M:
return mid,cnt
elif cnt < M:
right = mid
tmp = cnt
elif cnt > M:
left = mid + 1
if left == right:
return right,tmp
def main():
N,M = list(map(int,input().split()))
A = list(map(int,input().split()))
max_money,cnt = bi_search(A,M,N)
#print (cnt)
cnt = M-cnt
ans = 0
for i in range(N):
if max_money >= A[i]:
continue
#ans += A[i]
else:
while True:
A[i] //= 2
if max_money >= A[i]:
#ans += A[i]
break
A.sort(reverse = True)
j = 0
if A[j] == 0:
return 0
for i in range(cnt):
A[j] //= 2
j += 1
for i in range(N):
ans += A[i]
return ans
print((main()))
| from heapq import heapify,heappush,heappop
def main():
N,M = list(map(int,input().split()))
A = [-x for x in map(int,input().split())]
heapify(A)
for i in range(M):
tmp = -heappop(A)
tmp2 = tmp//2
heappush(A,-tmp2)
ans = 0
for i in range(N):
ans += A[i]
ans = abs(ans)
return ans
print((main()))
| 68 | 18 | 1,560 | 372 | import copy
def bi_search(money, M, N):
money.sort()
# list = []
# for i in range(0,money[N-1]+2,1):
# list.append(i)
left = 0
right = money[N - 1] + 1
mid = 0
# print(list,left,right)
while True:
mid = int((left + right) / 2)
cnt = 0
# print(left,right,mid)
# print(money)
money_tmp = copy.copy(money)
for i in range(N):
while True:
# print(money_tmp[i],i)
if money_tmp[i] <= mid:
break
else:
money_tmp[i] //= 2
cnt += 1
# print(cnt)
if cnt == M:
return mid, cnt
elif cnt < M:
right = mid
tmp = cnt
elif cnt > M:
left = mid + 1
if left == right:
return right, tmp
def main():
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
max_money, cnt = bi_search(A, M, N)
# print (cnt)
cnt = M - cnt
ans = 0
for i in range(N):
if max_money >= A[i]:
continue
# ans += A[i]
else:
while True:
A[i] //= 2
if max_money >= A[i]:
# ans += A[i]
break
A.sort(reverse=True)
j = 0
if A[j] == 0:
return 0
for i in range(cnt):
A[j] //= 2
j += 1
for i in range(N):
ans += A[i]
return ans
print((main()))
| from heapq import heapify, heappush, heappop
def main():
N, M = list(map(int, input().split()))
A = [-x for x in map(int, input().split())]
heapify(A)
for i in range(M):
tmp = -heappop(A)
tmp2 = tmp // 2
heappush(A, -tmp2)
ans = 0
for i in range(N):
ans += A[i]
ans = abs(ans)
return ans
print((main()))
| false | 73.529412 | [
"-import copy",
"-",
"-",
"-def bi_search(money, M, N):",
"- money.sort()",
"- # list = []",
"- # for i in range(0,money[N-1]+2,1):",
"- # list.append(i)",
"- left = 0",
"- right = money[N - 1] + 1",
"- mid = 0",
"- # print(list,left,right)",
"- while True:",
"- mid = int((left + right) / 2)",
"- cnt = 0",
"- # print(left,right,mid)",
"- # print(money)",
"- money_tmp = copy.copy(money)",
"- for i in range(N):",
"- while True:",
"- # print(money_tmp[i],i)",
"- if money_tmp[i] <= mid:",
"- break",
"- else:",
"- money_tmp[i] //= 2",
"- cnt += 1",
"- # print(cnt)",
"- if cnt == M:",
"- return mid, cnt",
"- elif cnt < M:",
"- right = mid",
"- tmp = cnt",
"- elif cnt > M:",
"- left = mid + 1",
"- if left == right:",
"- return right, tmp",
"+from heapq import heapify, heappush, heappop",
"- A = list(map(int, input().split()))",
"- max_money, cnt = bi_search(A, M, N)",
"- # print (cnt)",
"- cnt = M - cnt",
"+ A = [-x for x in map(int, input().split())]",
"+ heapify(A)",
"+ for i in range(M):",
"+ tmp = -heappop(A)",
"+ tmp2 = tmp // 2",
"+ heappush(A, -tmp2)",
"- if max_money >= A[i]:",
"- continue",
"- # ans += A[i]",
"- else:",
"- while True:",
"- A[i] //= 2",
"- if max_money >= A[i]:",
"- # ans += A[i]",
"- break",
"- A.sort(reverse=True)",
"- j = 0",
"- if A[j] == 0:",
"- return 0",
"- for i in range(cnt):",
"- A[j] //= 2",
"- j += 1",
"- for i in range(N):",
"+ ans = abs(ans)"
] | false | 0.037409 | 0.042966 | 0.870672 | [
"s912311754",
"s886927382"
] |
u704001626 | p03805 | python | s910368659 | s912005528 | 133 | 26 | 3,700 | 3,064 | Accepted | Accepted | 80.45 | # -*- coding: utf-8 -*-
import copy
n,m = list(map(int,input().split()))
rinset = [[0]*(n+1) for _ in range(n+1)]
for _ in range(m):
a,b = list(map(int,input().split()))
rinset[a][b]=b
rinset[b][a]=a
cnt = 0
def solve(start,visitted):
global cnt
visitted = copy.deepcopy(visitted)
visitted.append(start)
if len(visitted) == n:
cnt+=1
return
next_start=[i for i in rinset[start] if (i>1 and i not in visitted)]
for i in next_start:
solve(i,visitted)
solve(1,[])
print(cnt)
| # -*- coding: utf-8 -*-
n,m = list(map(int,input().split()))
ab = [list(map(int,input().split())) for i in range(m)]
#逆順にしたもの追加
ab += [[b,a] for a,b in ab]
#辺id付きで、idがfrom,abi[from]=[to1,to2,...] のリスト
abi = [[] for _ in range(n+1)]
for i,(a,b) in enumerate(ab):
abi[a].append(b)
#再起のlimitを上げる
import sys
sys.setrecursionlimit(4100000)
def dfs(idx=1,visitted=[1],cnt=1):
ret = 0
if cnt==n:
return 1
for to in abi[idx]:
if to not in visitted:
ret += dfs(to,visitted+[to],cnt+1)
return ret
print((dfs())) | 24 | 27 | 558 | 579 | # -*- coding: utf-8 -*-
import copy
n, m = list(map(int, input().split()))
rinset = [[0] * (n + 1) for _ in range(n + 1)]
for _ in range(m):
a, b = list(map(int, input().split()))
rinset[a][b] = b
rinset[b][a] = a
cnt = 0
def solve(start, visitted):
global cnt
visitted = copy.deepcopy(visitted)
visitted.append(start)
if len(visitted) == n:
cnt += 1
return
next_start = [i for i in rinset[start] if (i > 1 and i not in visitted)]
for i in next_start:
solve(i, visitted)
solve(1, [])
print(cnt)
| # -*- coding: utf-8 -*-
n, m = list(map(int, input().split()))
ab = [list(map(int, input().split())) for i in range(m)]
# 逆順にしたもの追加
ab += [[b, a] for a, b in ab]
# 辺id付きで、idがfrom,abi[from]=[to1,to2,...] のリスト
abi = [[] for _ in range(n + 1)]
for i, (a, b) in enumerate(ab):
abi[a].append(b)
# 再起のlimitを上げる
import sys
sys.setrecursionlimit(4100000)
def dfs(idx=1, visitted=[1], cnt=1):
ret = 0
if cnt == n:
return 1
for to in abi[idx]:
if to not in visitted:
ret += dfs(to, visitted + [to], cnt + 1)
return ret
print((dfs()))
| false | 11.111111 | [
"-import copy",
"+n, m = list(map(int, input().split()))",
"+ab = [list(map(int, input().split())) for i in range(m)]",
"+# 逆順にしたもの追加",
"+ab += [[b, a] for a, b in ab]",
"+# 辺id付きで、idがfrom,abi[from]=[to1,to2,...] のリスト",
"+abi = [[] for _ in range(n + 1)]",
"+for i, (a, b) in enumerate(ab):",
"+ abi[a].append(b)",
"+# 再起のlimitを上げる",
"+import sys",
"-n, m = list(map(int, input().split()))",
"-rinset = [[0] * (n + 1) for _ in range(n + 1)]",
"-for _ in range(m):",
"- a, b = list(map(int, input().split()))",
"- rinset[a][b] = b",
"- rinset[b][a] = a",
"-cnt = 0",
"+sys.setrecursionlimit(4100000)",
"-def solve(start, visitted):",
"- global cnt",
"- visitted = copy.deepcopy(visitted)",
"- visitted.append(start)",
"- if len(visitted) == n:",
"- cnt += 1",
"- return",
"- next_start = [i for i in rinset[start] if (i > 1 and i not in visitted)]",
"- for i in next_start:",
"- solve(i, visitted)",
"+def dfs(idx=1, visitted=[1], cnt=1):",
"+ ret = 0",
"+ if cnt == n:",
"+ return 1",
"+ for to in abi[idx]:",
"+ if to not in visitted:",
"+ ret += dfs(to, visitted + [to], cnt + 1)",
"+ return ret",
"-solve(1, [])",
"-print(cnt)",
"+print((dfs()))"
] | false | 0.04043 | 0.045131 | 0.895843 | [
"s910368659",
"s912005528"
] |
u163703551 | p03779 | python | s601016284 | s865569384 | 26 | 17 | 2,940 | 3,060 | Accepted | Accepted | 34.62 | x = eval(input())
x = int(x)
def f(x):
for n in range(0, x + 1):
s = n * (n + 1) / 2
if s >= x:
return n
print((f(x)))
| import sys
# sys.stdin = open('c1.in')
def f(x):
for n in range(0, 10 ** 9):
s = n * (n + 1) / 2
if s >= x:
return n
def f2(x):
a = 0
b = 10 ** 5
while b - a > 1:
n = (a + b) // 2
s = n * (n + 1) // 2
if s >= x:
b = n
else:
a = n
return b
x = int(eval(input()))
print((f2(x)))
# for x in range(10 ** 9, 1, -10 ** 5):
# if f(x) != f2(x):
# print(x, f(x), f2(x))
# break
| 12 | 31 | 158 | 522 | x = eval(input())
x = int(x)
def f(x):
for n in range(0, x + 1):
s = n * (n + 1) / 2
if s >= x:
return n
print((f(x)))
| import sys
# sys.stdin = open('c1.in')
def f(x):
for n in range(0, 10**9):
s = n * (n + 1) / 2
if s >= x:
return n
def f2(x):
a = 0
b = 10**5
while b - a > 1:
n = (a + b) // 2
s = n * (n + 1) // 2
if s >= x:
b = n
else:
a = n
return b
x = int(eval(input()))
print((f2(x)))
# for x in range(10 ** 9, 1, -10 ** 5):
# if f(x) != f2(x):
# print(x, f(x), f2(x))
# break
| false | 61.290323 | [
"-x = eval(input())",
"-x = int(x)",
"+import sys",
"-",
"+# sys.stdin = open('c1.in')",
"- for n in range(0, x + 1):",
"+ for n in range(0, 10**9):",
"-print((f(x)))",
"+def f2(x):",
"+ a = 0",
"+ b = 10**5",
"+ while b - a > 1:",
"+ n = (a + b) // 2",
"+ s = n * (n + 1) // 2",
"+ if s >= x:",
"+ b = n",
"+ else:",
"+ a = n",
"+ return b",
"+",
"+",
"+x = int(eval(input()))",
"+print((f2(x)))",
"+# for x in range(10 ** 9, 1, -10 ** 5):",
"+# if f(x) != f2(x):",
"+# print(x, f(x), f2(x))",
"+# break"
] | false | 0.082893 | 0.054228 | 1.528601 | [
"s601016284",
"s865569384"
] |
u727067903 | p03470 | python | s139783923 | s937363958 | 19 | 17 | 3,060 | 2,940 | Accepted | Accepted | 10.53 | N = int(eval(input()))
inputVal = [int(eval(input())) for i in range(N)]
inputVal.sort()
default = 0
count = 0
for i in inputVal:
if i != default:
count += 1
default = i
print(count) | N = int(eval(input()))
inputVal = [int(eval(input())) for i in range(N)]
print((len(set(inputVal)))) | 12 | 3 | 203 | 88 | N = int(eval(input()))
inputVal = [int(eval(input())) for i in range(N)]
inputVal.sort()
default = 0
count = 0
for i in inputVal:
if i != default:
count += 1
default = i
print(count)
| N = int(eval(input()))
inputVal = [int(eval(input())) for i in range(N)]
print((len(set(inputVal))))
| false | 75 | [
"-inputVal.sort()",
"-default = 0",
"-count = 0",
"-for i in inputVal:",
"- if i != default:",
"- count += 1",
"- default = i",
"-print(count)",
"+print((len(set(inputVal))))"
] | false | 0.038323 | 0.039692 | 0.965499 | [
"s139783923",
"s937363958"
] |
u721553535 | p03160 | python | s765469852 | s777694228 | 206 | 143 | 109,696 | 20,444 | Accepted | Accepted | 30.58 | import sys
reader = (s.rstrip() for s in sys.stdin)
input = reader.__next__
sys.setrecursionlimit(1000000)
def solve(stns, idx, mem):
if idx >= len(stns) -1:
return 0
if idx in mem:
return mem[idx]
if idx == len(stns) - 2:
#cant take more than one step
final_step = abs(stns[idx] - stns[idx+1])
mem[idx] = final_step
return final_step
else:
# step: i + 11
step1 = solve(stns, idx + 1, mem) + abs(stns[idx] - stns[idx+1])
# step: i + 2
step2 = solve(stns, idx + 2, mem) + abs(stns[idx] - stns[idx+2])
min_cost = min(step1, step2)
mem[idx] = min_cost
return min_cost
def take_input():
n = eval(input())
stns = [int(x) for x in input().split()]
mem = {}
res = solve(stns, 0, mem)
print(res)
take_input() | import math
def solve(stns, n, idx, dp):
for i in range(n):
for j in range(1, 3):
j = i + j # step i + 1, i + 2
if j < n:
# min(existing min, new path using i)
dp[j] = min(dp[j], dp[i] + abs(stns[i] - stns[j]))
return dp[n-1]
def take_input():
n = int(eval(input()))
stns = [int(x) for x in input().split()]
dp = [math.inf for i in range(n)]
dp[0] = 0
res = solve(stns, n, 0, dp)
print(res)
take_input() | 40 | 21 | 888 | 517 | import sys
reader = (s.rstrip() for s in sys.stdin)
input = reader.__next__
sys.setrecursionlimit(1000000)
def solve(stns, idx, mem):
if idx >= len(stns) - 1:
return 0
if idx in mem:
return mem[idx]
if idx == len(stns) - 2:
# cant take more than one step
final_step = abs(stns[idx] - stns[idx + 1])
mem[idx] = final_step
return final_step
else:
# step: i + 11
step1 = solve(stns, idx + 1, mem) + abs(stns[idx] - stns[idx + 1])
# step: i + 2
step2 = solve(stns, idx + 2, mem) + abs(stns[idx] - stns[idx + 2])
min_cost = min(step1, step2)
mem[idx] = min_cost
return min_cost
def take_input():
n = eval(input())
stns = [int(x) for x in input().split()]
mem = {}
res = solve(stns, 0, mem)
print(res)
take_input()
| import math
def solve(stns, n, idx, dp):
for i in range(n):
for j in range(1, 3):
j = i + j # step i + 1, i + 2
if j < n:
# min(existing min, new path using i)
dp[j] = min(dp[j], dp[i] + abs(stns[i] - stns[j]))
return dp[n - 1]
def take_input():
n = int(eval(input()))
stns = [int(x) for x in input().split()]
dp = [math.inf for i in range(n)]
dp[0] = 0
res = solve(stns, n, 0, dp)
print(res)
take_input()
| false | 47.5 | [
"-import sys",
"-",
"-reader = (s.rstrip() for s in sys.stdin)",
"-input = reader.__next__",
"-sys.setrecursionlimit(1000000)",
"+import math",
"-def solve(stns, idx, mem):",
"- if idx >= len(stns) - 1:",
"- return 0",
"- if idx in mem:",
"- return mem[idx]",
"- if idx == len(stns) - 2:",
"- # cant take more than one step",
"- final_step = abs(stns[idx] - stns[idx + 1])",
"- mem[idx] = final_step",
"- return final_step",
"- else:",
"- # step: i + 11",
"- step1 = solve(stns, idx + 1, mem) + abs(stns[idx] - stns[idx + 1])",
"- # step: i + 2",
"- step2 = solve(stns, idx + 2, mem) + abs(stns[idx] - stns[idx + 2])",
"- min_cost = min(step1, step2)",
"- mem[idx] = min_cost",
"- return min_cost",
"+def solve(stns, n, idx, dp):",
"+ for i in range(n):",
"+ for j in range(1, 3):",
"+ j = i + j # step i + 1, i + 2",
"+ if j < n:",
"+ # min(existing min, new path using i)",
"+ dp[j] = min(dp[j], dp[i] + abs(stns[i] - stns[j]))",
"+ return dp[n - 1]",
"- n = eval(input())",
"+ n = int(eval(input()))",
"- mem = {}",
"- res = solve(stns, 0, mem)",
"+ dp = [math.inf for i in range(n)]",
"+ dp[0] = 0",
"+ res = solve(stns, n, 0, dp)"
] | false | 0.035477 | 0.034641 | 1.024133 | [
"s765469852",
"s777694228"
] |
u352394527 | p00535 | python | s572322314 | s797418658 | 5,870 | 3,210 | 16,420 | 16,524 | Accepted | Accepted | 45.32 | from heapq import heappush, heappop
h, w = list(map(int, input().split()))
mp = [[-1] + list(eval(input())) + [-1] for _ in range(h)]
mp.insert(0, [-1] * (w + 2))
mp.append([-1] * (w + 2))
que = []
for y in range(1, h + 1):
for x in range(1, w + 1):
if "1" <= mp[y][x] <= "9":
mp[y][x] = int(mp[y][x])
elif mp[y][x] == ".":
mp[y][x] = 0
heappush(que, (0, x, y))
vec = ((0, 1), (0, -1), (1, 1), (1, 0), (1, -1), (-1, 1), (-1, 0), (-1, -1))
while que:
turn, x, y = heappop(que)
for dx, dy in vec:
nx, ny = x + dx, y + dy
if mp[ny][nx] > 0:
mp[ny][nx] -= 1
if mp[ny][nx] == 0:
heappush(que, (turn + 1, nx, ny))
print(turn)
| from heapq import heappush, heappop
def main():
h, w = list(map(int, input().split()))
mp = [[-1] + list(eval(input())) + [-1] for _ in range(h)]
mp.insert(0, [-1] * (w + 2))
mp.append([-1] * (w + 2))
que = []
for y in range(1, h + 1):
for x in range(1, w + 1):
if "1" <= mp[y][x] <= "9":
mp[y][x] = int(mp[y][x])
elif mp[y][x] == ".":
mp[y][x] = 0
heappush(que, (0, x, y))
vec = ((0, 1), (0, -1), (1, 1), (1, 0), (1, -1), (-1, 1), (-1, 0), (-1, -1))
while que:
turn, x, y = heappop(que)
for dx, dy in vec:
nx, ny = x + dx, y + dy
if mp[ny][nx] > 0:
mp[ny][nx] -= 1
if mp[ny][nx] == 0:
heappush(que, (turn + 1, nx, ny))
print(turn)
main()
| 24 | 30 | 692 | 771 | from heapq import heappush, heappop
h, w = list(map(int, input().split()))
mp = [[-1] + list(eval(input())) + [-1] for _ in range(h)]
mp.insert(0, [-1] * (w + 2))
mp.append([-1] * (w + 2))
que = []
for y in range(1, h + 1):
for x in range(1, w + 1):
if "1" <= mp[y][x] <= "9":
mp[y][x] = int(mp[y][x])
elif mp[y][x] == ".":
mp[y][x] = 0
heappush(que, (0, x, y))
vec = ((0, 1), (0, -1), (1, 1), (1, 0), (1, -1), (-1, 1), (-1, 0), (-1, -1))
while que:
turn, x, y = heappop(que)
for dx, dy in vec:
nx, ny = x + dx, y + dy
if mp[ny][nx] > 0:
mp[ny][nx] -= 1
if mp[ny][nx] == 0:
heappush(que, (turn + 1, nx, ny))
print(turn)
| from heapq import heappush, heappop
def main():
h, w = list(map(int, input().split()))
mp = [[-1] + list(eval(input())) + [-1] for _ in range(h)]
mp.insert(0, [-1] * (w + 2))
mp.append([-1] * (w + 2))
que = []
for y in range(1, h + 1):
for x in range(1, w + 1):
if "1" <= mp[y][x] <= "9":
mp[y][x] = int(mp[y][x])
elif mp[y][x] == ".":
mp[y][x] = 0
heappush(que, (0, x, y))
vec = ((0, 1), (0, -1), (1, 1), (1, 0), (1, -1), (-1, 1), (-1, 0), (-1, -1))
while que:
turn, x, y = heappop(que)
for dx, dy in vec:
nx, ny = x + dx, y + dy
if mp[ny][nx] > 0:
mp[ny][nx] -= 1
if mp[ny][nx] == 0:
heappush(que, (turn + 1, nx, ny))
print(turn)
main()
| false | 20 | [
"-h, w = list(map(int, input().split()))",
"-mp = [[-1] + list(eval(input())) + [-1] for _ in range(h)]",
"-mp.insert(0, [-1] * (w + 2))",
"-mp.append([-1] * (w + 2))",
"-que = []",
"-for y in range(1, h + 1):",
"- for x in range(1, w + 1):",
"- if \"1\" <= mp[y][x] <= \"9\":",
"- mp[y][x] = int(mp[y][x])",
"- elif mp[y][x] == \".\":",
"- mp[y][x] = 0",
"- heappush(que, (0, x, y))",
"-vec = ((0, 1), (0, -1), (1, 1), (1, 0), (1, -1), (-1, 1), (-1, 0), (-1, -1))",
"-while que:",
"- turn, x, y = heappop(que)",
"- for dx, dy in vec:",
"- nx, ny = x + dx, y + dy",
"- if mp[ny][nx] > 0:",
"- mp[ny][nx] -= 1",
"- if mp[ny][nx] == 0:",
"- heappush(que, (turn + 1, nx, ny))",
"-print(turn)",
"+",
"+def main():",
"+ h, w = list(map(int, input().split()))",
"+ mp = [[-1] + list(eval(input())) + [-1] for _ in range(h)]",
"+ mp.insert(0, [-1] * (w + 2))",
"+ mp.append([-1] * (w + 2))",
"+ que = []",
"+ for y in range(1, h + 1):",
"+ for x in range(1, w + 1):",
"+ if \"1\" <= mp[y][x] <= \"9\":",
"+ mp[y][x] = int(mp[y][x])",
"+ elif mp[y][x] == \".\":",
"+ mp[y][x] = 0",
"+ heappush(que, (0, x, y))",
"+ vec = ((0, 1), (0, -1), (1, 1), (1, 0), (1, -1), (-1, 1), (-1, 0), (-1, -1))",
"+ while que:",
"+ turn, x, y = heappop(que)",
"+ for dx, dy in vec:",
"+ nx, ny = x + dx, y + dy",
"+ if mp[ny][nx] > 0:",
"+ mp[ny][nx] -= 1",
"+ if mp[ny][nx] == 0:",
"+ heappush(que, (turn + 1, nx, ny))",
"+ print(turn)",
"+",
"+",
"+main()"
] | false | 0.211177 | 0.086779 | 2.433511 | [
"s572322314",
"s797418658"
] |
u063052907 | p03681 | python | s198400357 | s284148434 | 703 | 40 | 5,176 | 3,064 | Accepted | Accepted | 94.31 | import sys
from math import factorial
sys.setrecursionlimit(500000)
N, M = list(map(int, input().split()))
MOD = 10**9 + 7
diff = abs(N - M)
if diff == 0:
ans = (factorial(N) * factorial(M)) * 2
elif diff == 1:
ans = factorial(N) * factorial(M)
else:
ans = 0
ans %= MOD
print(ans) | def fact(n):
ret = 1
MOD = 10**9 + 7
for i in range(1, n + 1):
ret = ret * i % MOD
return ret
N, M = list(map(int, input().split()))
MOD = 10**9 + 7
diff = abs(N - M)
if diff == 0:
ans = (fact(N) * fact(M)) * 2
elif diff == 1:
ans = fact(N) * fact(M)
else:
ans = 0
ans %= MOD
print(ans) | 20 | 23 | 311 | 344 | import sys
from math import factorial
sys.setrecursionlimit(500000)
N, M = list(map(int, input().split()))
MOD = 10**9 + 7
diff = abs(N - M)
if diff == 0:
ans = (factorial(N) * factorial(M)) * 2
elif diff == 1:
ans = factorial(N) * factorial(M)
else:
ans = 0
ans %= MOD
print(ans)
| def fact(n):
ret = 1
MOD = 10**9 + 7
for i in range(1, n + 1):
ret = ret * i % MOD
return ret
N, M = list(map(int, input().split()))
MOD = 10**9 + 7
diff = abs(N - M)
if diff == 0:
ans = (fact(N) * fact(M)) * 2
elif diff == 1:
ans = fact(N) * fact(M)
else:
ans = 0
ans %= MOD
print(ans)
| false | 13.043478 | [
"-import sys",
"-from math import factorial",
"+def fact(n):",
"+ ret = 1",
"+ MOD = 10**9 + 7",
"+ for i in range(1, n + 1):",
"+ ret = ret * i % MOD",
"+ return ret",
"-sys.setrecursionlimit(500000)",
"+",
"- ans = (factorial(N) * factorial(M)) * 2",
"+ ans = (fact(N) * fact(M)) * 2",
"- ans = factorial(N) * factorial(M)",
"+ ans = fact(N) * fact(M)"
] | false | 0.172161 | 0.038662 | 4.452986 | [
"s198400357",
"s284148434"
] |
u056358163 | p02574 | python | s226788464 | s118048319 | 750 | 575 | 127,728 | 127,960 | Accepted | Accepted | 23.33 | import math
from functools import reduce
def getD(num):
input_list = [2 if i % 2 == 0 else i for i in range(num+1)]
input_list[0] = 0
bool_list = [False if i % 2 == 0 else True for i in range(num+1)]
sqrt = int(math.sqrt(num))
for serial in range(3, sqrt + 1, 2):
if bool_list[serial]:
for s in range(serial ** 2, num+1, serial):
if bool_list[s]:
input_list[s] = serial
bool_list[s] = False
return input_list
N = int(eval(input()))
A = list(map(int, input().split()))
D = getD(max(A))
flag = True
d_set = set()
for a in A:
while a != 1:
d = D[a]
if d in d_set:
flag = False
break
else:
d_set.add(d)
while a > 1 and a % d == 0:
a = a // d
if flag:
print('pairwise coprime')
exit()
if reduce(math.gcd, A) == 1:
print('setwise coprime')
else:
print('not coprime')
| import math
from functools import reduce
def getD(num):
input_list = [2 if i % 2 == 0 else i for i in range(num+1)]
input_list[0] = 0
bool_list = [False if i % 2 == 0 else True for i in range(num+1)]
sqrt = int(math.sqrt(num))
for serial in range(3, sqrt + 1, 2):
if bool_list[serial]:
for s in range(serial ** 2, num+1, serial):
if bool_list[s]:
input_list[s] = serial
bool_list[s] = False
return input_list
N = int(eval(input()))
A = list(map(int, input().split()))
D = getD(max(A))
flag = True
d_set = set()
for a in A:
while a != 1:
d = D[a]
if d in d_set:
flag = False
break
else:
d_set.add(d)
while a > 1 and a % d == 0:
a = a // d
if not(flag):
break
if flag:
print('pairwise coprime')
exit()
if reduce(math.gcd, A) == 1:
print('setwise coprime')
else:
print('not coprime')
| 46 | 48 | 1,014 | 1,048 | import math
from functools import reduce
def getD(num):
input_list = [2 if i % 2 == 0 else i for i in range(num + 1)]
input_list[0] = 0
bool_list = [False if i % 2 == 0 else True for i in range(num + 1)]
sqrt = int(math.sqrt(num))
for serial in range(3, sqrt + 1, 2):
if bool_list[serial]:
for s in range(serial**2, num + 1, serial):
if bool_list[s]:
input_list[s] = serial
bool_list[s] = False
return input_list
N = int(eval(input()))
A = list(map(int, input().split()))
D = getD(max(A))
flag = True
d_set = set()
for a in A:
while a != 1:
d = D[a]
if d in d_set:
flag = False
break
else:
d_set.add(d)
while a > 1 and a % d == 0:
a = a // d
if flag:
print("pairwise coprime")
exit()
if reduce(math.gcd, A) == 1:
print("setwise coprime")
else:
print("not coprime")
| import math
from functools import reduce
def getD(num):
input_list = [2 if i % 2 == 0 else i for i in range(num + 1)]
input_list[0] = 0
bool_list = [False if i % 2 == 0 else True for i in range(num + 1)]
sqrt = int(math.sqrt(num))
for serial in range(3, sqrt + 1, 2):
if bool_list[serial]:
for s in range(serial**2, num + 1, serial):
if bool_list[s]:
input_list[s] = serial
bool_list[s] = False
return input_list
N = int(eval(input()))
A = list(map(int, input().split()))
D = getD(max(A))
flag = True
d_set = set()
for a in A:
while a != 1:
d = D[a]
if d in d_set:
flag = False
break
else:
d_set.add(d)
while a > 1 and a % d == 0:
a = a // d
if not (flag):
break
if flag:
print("pairwise coprime")
exit()
if reduce(math.gcd, A) == 1:
print("setwise coprime")
else:
print("not coprime")
| false | 4.166667 | [
"+ if not (flag):",
"+ break"
] | false | 0.043914 | 0.038212 | 1.149208 | [
"s226788464",
"s118048319"
] |
u167681750 | p02881 | python | s749876356 | s329002061 | 270 | 219 | 2,940 | 3,064 | Accepted | Accepted | 18.89 | from math import *
n = int(eval(input()))
def ij(x):
for i in range(x):
i = x - i
if n / i == n//i:
return i, n//i
print((sum(ij(int(sqrt(n)))) - 2))
| from math import *
n = int(eval(input()))
def ij(x):
for i in range(x, 0, -1):
if n/i == n//i:
return i, n//i
print((sum(ij(int(sqrt(n)))) - 2)) | 10 | 9 | 185 | 170 | from math import *
n = int(eval(input()))
def ij(x):
for i in range(x):
i = x - i
if n / i == n // i:
return i, n // i
print((sum(ij(int(sqrt(n)))) - 2))
| from math import *
n = int(eval(input()))
def ij(x):
for i in range(x, 0, -1):
if n / i == n // i:
return i, n // i
print((sum(ij(int(sqrt(n)))) - 2))
| false | 10 | [
"- for i in range(x):",
"- i = x - i",
"+ for i in range(x, 0, -1):"
] | false | 0.050802 | 0.049816 | 1.019796 | [
"s749876356",
"s329002061"
] |
u720636500 | p03108 | python | s343722583 | s610853067 | 969 | 758 | 46,236 | 33,604 | Accepted | Accepted | 21.78 | N, M = list(map(int, input().split()))
lis = [[x, -1] for x in range(1, N + 1)]
Blis = [list(map(int, input().split())) for _ in range(M)]
inc = int(N*(N - 1)/2)
ans = [x for x in range(M)]
ans[M - 1] = inc
def root(a):
if lis[a - 1][1] < 0:
return lis[a - 1][0]
else:
k = root(lis[a - 1][1])
lis[a - 1][1] = k
return k
def size(a):
return -lis[root(a) - 1][1]
def connect(a, b):
A = root(a)
B = root(b)
if A == B:
return None
else:
if size(A) < size(B):
A, B = B, A
lis[A - 1][1] += lis[B - 1][1]
lis[B - 1][1] = A
for i in reversed(list(range(1, M))):
if root(Blis[i][0]) != root(Blis[i][1]):
ans[i - 1] = ans[i] - size(Blis[i][0])*size(Blis[i][1])
connect(Blis[i][0], Blis[i][1])
else:
ans[i - 1] = ans[i]
for i in range(M):
print((ans[i])) | N, M = list(map(int, input().split()))
Parent = [-1 for x in range(N + 5)]
lis = [list(map(int, input().split())) for _ in range(M)]
ini = int(N*(N - 1)/2)
ans = [x for x in range(M)]
ans[M - 1] = ini
def root(a):
if Parent[a] < 0:
return a
else:
k = root(Parent[a])
Parent[a] = k
return k
def size(a):
return -Parent[root(a)]
def connect(a, b):
A = root(a)
B = root(b)
if A == B:
return None
else:
if size(A) < size(B):
A, B = B, A
Parent[A] += Parent[B]
Parent[B] = A
for i in reversed(list(range(1, M))):
ans[i - 1] = ans[i]
if root(lis[i][0]) != root(lis[i][1]):
ans[i - 1] -= size(lis[i][0])*size(lis[i][1])
connect(lis[i][0], lis[i][1])
for i in range(M):
print((ans[i])) | 33 | 32 | 901 | 828 | N, M = list(map(int, input().split()))
lis = [[x, -1] for x in range(1, N + 1)]
Blis = [list(map(int, input().split())) for _ in range(M)]
inc = int(N * (N - 1) / 2)
ans = [x for x in range(M)]
ans[M - 1] = inc
def root(a):
if lis[a - 1][1] < 0:
return lis[a - 1][0]
else:
k = root(lis[a - 1][1])
lis[a - 1][1] = k
return k
def size(a):
return -lis[root(a) - 1][1]
def connect(a, b):
A = root(a)
B = root(b)
if A == B:
return None
else:
if size(A) < size(B):
A, B = B, A
lis[A - 1][1] += lis[B - 1][1]
lis[B - 1][1] = A
for i in reversed(list(range(1, M))):
if root(Blis[i][0]) != root(Blis[i][1]):
ans[i - 1] = ans[i] - size(Blis[i][0]) * size(Blis[i][1])
connect(Blis[i][0], Blis[i][1])
else:
ans[i - 1] = ans[i]
for i in range(M):
print((ans[i]))
| N, M = list(map(int, input().split()))
Parent = [-1 for x in range(N + 5)]
lis = [list(map(int, input().split())) for _ in range(M)]
ini = int(N * (N - 1) / 2)
ans = [x for x in range(M)]
ans[M - 1] = ini
def root(a):
if Parent[a] < 0:
return a
else:
k = root(Parent[a])
Parent[a] = k
return k
def size(a):
return -Parent[root(a)]
def connect(a, b):
A = root(a)
B = root(b)
if A == B:
return None
else:
if size(A) < size(B):
A, B = B, A
Parent[A] += Parent[B]
Parent[B] = A
for i in reversed(list(range(1, M))):
ans[i - 1] = ans[i]
if root(lis[i][0]) != root(lis[i][1]):
ans[i - 1] -= size(lis[i][0]) * size(lis[i][1])
connect(lis[i][0], lis[i][1])
for i in range(M):
print((ans[i]))
| false | 3.030303 | [
"-lis = [[x, -1] for x in range(1, N + 1)]",
"-Blis = [list(map(int, input().split())) for _ in range(M)]",
"-inc = int(N * (N - 1) / 2)",
"+Parent = [-1 for x in range(N + 5)]",
"+lis = [list(map(int, input().split())) for _ in range(M)]",
"+ini = int(N * (N - 1) / 2)",
"-ans[M - 1] = inc",
"+ans[M - 1] = ini",
"- if lis[a - 1][1] < 0:",
"- return lis[a - 1][0]",
"+ if Parent[a] < 0:",
"+ return a",
"- k = root(lis[a - 1][1])",
"- lis[a - 1][1] = k",
"+ k = root(Parent[a])",
"+ Parent[a] = k",
"- return -lis[root(a) - 1][1]",
"+ return -Parent[root(a)]",
"- lis[A - 1][1] += lis[B - 1][1]",
"- lis[B - 1][1] = A",
"+ Parent[A] += Parent[B]",
"+ Parent[B] = A",
"- if root(Blis[i][0]) != root(Blis[i][1]):",
"- ans[i - 1] = ans[i] - size(Blis[i][0]) * size(Blis[i][1])",
"- connect(Blis[i][0], Blis[i][1])",
"- else:",
"- ans[i - 1] = ans[i]",
"+ ans[i - 1] = ans[i]",
"+ if root(lis[i][0]) != root(lis[i][1]):",
"+ ans[i - 1] -= size(lis[i][0]) * size(lis[i][1])",
"+ connect(lis[i][0], lis[i][1])"
] | false | 0.036515 | 0.036187 | 1.009069 | [
"s343722583",
"s610853067"
] |
u467826805 | p03457 | python | s957821649 | s679583969 | 468 | 400 | 11,816 | 3,064 | Accepted | Accepted | 14.53 | n = int(eval(input()))
x = [0]
y = [0]
t = [0]
fl = True
def judge(a,b,c,d,e,f):
if abs(b-a)+abs(d-c) <= f-e and abs(b+d-a-c)%2 == abs(f-e)%2:
return False
return True
for i in range(n):
tt,xx,yy = list(map(int,input().split()))
x.append(xx)
y.append(yy)
t.append(tt)
if judge(x[i],x[i+1],y[i],y[i+1],t[i],t[i+1]):
fl = False
if(fl):
print("Yes")
else:
print("No")
| n = int(eval(input()))
x = 0
y = 0
t = 0
a = 0
def trav(a,b,c,d,e,f):
if abs(a-b) + abs(c-d) <= e - f and ((a-b) % 2 + (c-d) % 2)%2 == (e-f) % 2:
return 0
else:
return 1
for i in range(n):
tn,xn,yn = list(map(int,input().split()))
if trav(xn,x,yn,y,tn,t) == 0:
x = xn
y = yn
t = tn
else:
a = 1
if a == 0:
print("Yes")
else:
print("No")
| 20 | 22 | 424 | 421 | n = int(eval(input()))
x = [0]
y = [0]
t = [0]
fl = True
def judge(a, b, c, d, e, f):
if abs(b - a) + abs(d - c) <= f - e and abs(b + d - a - c) % 2 == abs(f - e) % 2:
return False
return True
for i in range(n):
tt, xx, yy = list(map(int, input().split()))
x.append(xx)
y.append(yy)
t.append(tt)
if judge(x[i], x[i + 1], y[i], y[i + 1], t[i], t[i + 1]):
fl = False
if fl:
print("Yes")
else:
print("No")
| n = int(eval(input()))
x = 0
y = 0
t = 0
a = 0
def trav(a, b, c, d, e, f):
if (
abs(a - b) + abs(c - d) <= e - f
and ((a - b) % 2 + (c - d) % 2) % 2 == (e - f) % 2
):
return 0
else:
return 1
for i in range(n):
tn, xn, yn = list(map(int, input().split()))
if trav(xn, x, yn, y, tn, t) == 0:
x = xn
y = yn
t = tn
else:
a = 1
if a == 0:
print("Yes")
else:
print("No")
| false | 9.090909 | [
"-x = [0]",
"-y = [0]",
"-t = [0]",
"-fl = True",
"+x = 0",
"+y = 0",
"+t = 0",
"+a = 0",
"-def judge(a, b, c, d, e, f):",
"- if abs(b - a) + abs(d - c) <= f - e and abs(b + d - a - c) % 2 == abs(f - e) % 2:",
"- return False",
"- return True",
"+def trav(a, b, c, d, e, f):",
"+ if (",
"+ abs(a - b) + abs(c - d) <= e - f",
"+ and ((a - b) % 2 + (c - d) % 2) % 2 == (e - f) % 2",
"+ ):",
"+ return 0",
"+ else:",
"+ return 1",
"- tt, xx, yy = list(map(int, input().split()))",
"- x.append(xx)",
"- y.append(yy)",
"- t.append(tt)",
"- if judge(x[i], x[i + 1], y[i], y[i + 1], t[i], t[i + 1]):",
"- fl = False",
"-if fl:",
"+ tn, xn, yn = list(map(int, input().split()))",
"+ if trav(xn, x, yn, y, tn, t) == 0:",
"+ x = xn",
"+ y = yn",
"+ t = tn",
"+ else:",
"+ a = 1",
"+if a == 0:"
] | false | 0.104683 | 0.197582 | 0.529823 | [
"s957821649",
"s679583969"
] |
u002459665 | p03862 | python | s939296081 | s067990703 | 113 | 101 | 14,052 | 14,252 | Accepted | Accepted | 10.62 | N, x = list(map(int, input().split()))
A = list(map(int, input().split()))
cnt = 0
for i in range(N - 1):
sm = A[i] + A[i+1]
if sm > x:
diff = sm - x
if A[i+1] >= diff:
A[i+1] -= diff
else:
diff2 = diff - A[i+1]
A[i+1] = 0
A[i] -= diff2
cnt += diff
print(cnt)
| N, x = list(map(int, input().split()))
A = list(map(int, input().split()))
cnt = 0
if A[0] > x:
cnt += A[0] - x
A[0] = x
for i in range(N - 1):
sm = A[i] + A[i+1]
if sm > x:
diff = sm - x
A[i+1] -= diff
cnt += diff
print(cnt)
| 17 | 17 | 360 | 280 | N, x = list(map(int, input().split()))
A = list(map(int, input().split()))
cnt = 0
for i in range(N - 1):
sm = A[i] + A[i + 1]
if sm > x:
diff = sm - x
if A[i + 1] >= diff:
A[i + 1] -= diff
else:
diff2 = diff - A[i + 1]
A[i + 1] = 0
A[i] -= diff2
cnt += diff
print(cnt)
| N, x = list(map(int, input().split()))
A = list(map(int, input().split()))
cnt = 0
if A[0] > x:
cnt += A[0] - x
A[0] = x
for i in range(N - 1):
sm = A[i] + A[i + 1]
if sm > x:
diff = sm - x
A[i + 1] -= diff
cnt += diff
print(cnt)
| false | 0 | [
"+if A[0] > x:",
"+ cnt += A[0] - x",
"+ A[0] = x",
"- if A[i + 1] >= diff:",
"- A[i + 1] -= diff",
"- else:",
"- diff2 = diff - A[i + 1]",
"- A[i + 1] = 0",
"- A[i] -= diff2",
"+ A[i + 1] -= diff"
] | false | 0.043997 | 0.043657 | 1.007781 | [
"s939296081",
"s067990703"
] |
u747602774 | p03293 | python | s697145525 | s641579349 | 19 | 17 | 3,060 | 2,940 | Accepted | Accepted | 10.53 | S = list(eval(input())*2)
T = list(eval(input()))
ans = 'No'
for i in range(len(S)//2):
check = 1
for j in range(len(S)//2):
if S[i+j] != T[j]:
check = 0
if check == 1:
ans = 'Yes'
break
print(ans)
| s = eval(input())
t = eval(input())
if t in s+s:
print('Yes')
else:
print('No')
| 13 | 6 | 250 | 81 | S = list(eval(input()) * 2)
T = list(eval(input()))
ans = "No"
for i in range(len(S) // 2):
check = 1
for j in range(len(S) // 2):
if S[i + j] != T[j]:
check = 0
if check == 1:
ans = "Yes"
break
print(ans)
| s = eval(input())
t = eval(input())
if t in s + s:
print("Yes")
else:
print("No")
| false | 53.846154 | [
"-S = list(eval(input()) * 2)",
"-T = list(eval(input()))",
"-ans = \"No\"",
"-for i in range(len(S) // 2):",
"- check = 1",
"- for j in range(len(S) // 2):",
"- if S[i + j] != T[j]:",
"- check = 0",
"- if check == 1:",
"- ans = \"Yes\"",
"- break",
"-print(ans)",
"+s = eval(input())",
"+t = eval(input())",
"+if t in s + s:",
"+ print(\"Yes\")",
"+else:",
"+ print(\"No\")"
] | false | 0.047894 | 0.048681 | 0.98382 | [
"s697145525",
"s641579349"
] |
u133936772 | p03416 | python | s905935540 | s225082624 | 83 | 62 | 2,940 | 9,156 | Accepted | Accepted | 25.3 | a,b = list(map(int,input().split()))
ans = 0
for i in range(a,b+1):
s = list(str(i))
if s == s[::-1]:
ans += 1
print(ans) | a,b=list(map(int,input().split()))
print((sum(str(i)==str(i)[::-1] for i in range(a,b+1)))) | 7 | 2 | 129 | 84 | a, b = list(map(int, input().split()))
ans = 0
for i in range(a, b + 1):
s = list(str(i))
if s == s[::-1]:
ans += 1
print(ans)
| a, b = list(map(int, input().split()))
print((sum(str(i) == str(i)[::-1] for i in range(a, b + 1))))
| false | 71.428571 | [
"-ans = 0",
"-for i in range(a, b + 1):",
"- s = list(str(i))",
"- if s == s[::-1]:",
"- ans += 1",
"-print(ans)",
"+print((sum(str(i) == str(i)[::-1] for i in range(a, b + 1))))"
] | false | 0.120342 | 0.07343 | 1.638868 | [
"s905935540",
"s225082624"
] |
u071868443 | p02999 | python | s128611603 | s180465807 | 20 | 17 | 3,060 | 2,940 | Accepted | Accepted | 15 | X, A = list(map(int, input().split()))
if X < A:
print('0')
else:
print('10') | X, A = list(map(int, input().split()))
if X < A:
print((0))
else:
print((10))
| 5 | 5 | 79 | 76 | X, A = list(map(int, input().split()))
if X < A:
print("0")
else:
print("10")
| X, A = list(map(int, input().split()))
if X < A:
print((0))
else:
print((10))
| false | 0 | [
"- print(\"0\")",
"+ print((0))",
"- print(\"10\")",
"+ print((10))"
] | false | 0.067888 | 0.066599 | 1.019359 | [
"s128611603",
"s180465807"
] |
u203843959 | p02623 | python | s768161296 | s545141260 | 237 | 152 | 130,180 | 134,128 | Accepted | Accepted | 35.86 | import bisect
N,M,K=list(map(int,input().split()))
alist=list(map(int,input().split()))
blist=list(map(int,input().split()))
sum_alist=[0]
for i in range(N):
sum_alist.append(sum_alist[-1]+alist[i])
#print(sum_alist)
sum_blist=[0]
for i in range(M):
sum_blist.append(sum_blist[-1]+blist[i])
#print(sum_blist)
limit_a=bisect.bisect(sum_alist,K)
#print(limit_a)
limit_b=bisect.bisect(sum_blist,K)
#print(limit_b)
answer=0
for i in reversed(list(range(1,limit_a))):
a_sum=sum_alist[i]
b_sum=K-a_sum
pos_b=bisect.bisect(sum_blist,b_sum)
#print(i,pos_b-1,a_sum,sum_blist[pos_b-1],b_sum)
answer=max(answer,i+pos_b-1)
for i in reversed(list(range(1,limit_b))):
b_sum=sum_blist[i]
a_sum=K-b_sum
pos_a=bisect.bisect(sum_alist,a_sum)
#print(i,pos_b-1,a_sum,sum_blist[pos_b-1],b_sum)
answer=max(answer,i+pos_a-1)
if limit_a==1:
pos_b=bisect.bisect(sum_blist,K)
answer=pos_b-1
elif limit_b==1:
pos_a=bisect.bisect(sum_alist,K)
answer=pos_a-1
print(answer) | N,M,K=list(map(int,input().split()))
alist=list(map(int,input().split()))
blist=list(map(int,input().split()))
sum_alist=[0]
for a in alist:
sum_alist.append(sum_alist[-1]+a)
sum_blist=[0]
for b in blist:
sum_blist.append(sum_blist[-1]+b)
index_b=M
answer=0
for i in range(N+1):
sum_a=sum_alist[i]
if sum_a>K:
break
while sum_a+sum_blist[index_b]>K:
index_b-=1
#print(i,index_b)
answer=max(answer,i+index_b)
print(answer) | 44 | 25 | 1,012 | 478 | import bisect
N, M, K = list(map(int, input().split()))
alist = list(map(int, input().split()))
blist = list(map(int, input().split()))
sum_alist = [0]
for i in range(N):
sum_alist.append(sum_alist[-1] + alist[i])
# print(sum_alist)
sum_blist = [0]
for i in range(M):
sum_blist.append(sum_blist[-1] + blist[i])
# print(sum_blist)
limit_a = bisect.bisect(sum_alist, K)
# print(limit_a)
limit_b = bisect.bisect(sum_blist, K)
# print(limit_b)
answer = 0
for i in reversed(list(range(1, limit_a))):
a_sum = sum_alist[i]
b_sum = K - a_sum
pos_b = bisect.bisect(sum_blist, b_sum)
# print(i,pos_b-1,a_sum,sum_blist[pos_b-1],b_sum)
answer = max(answer, i + pos_b - 1)
for i in reversed(list(range(1, limit_b))):
b_sum = sum_blist[i]
a_sum = K - b_sum
pos_a = bisect.bisect(sum_alist, a_sum)
# print(i,pos_b-1,a_sum,sum_blist[pos_b-1],b_sum)
answer = max(answer, i + pos_a - 1)
if limit_a == 1:
pos_b = bisect.bisect(sum_blist, K)
answer = pos_b - 1
elif limit_b == 1:
pos_a = bisect.bisect(sum_alist, K)
answer = pos_a - 1
print(answer)
| N, M, K = list(map(int, input().split()))
alist = list(map(int, input().split()))
blist = list(map(int, input().split()))
sum_alist = [0]
for a in alist:
sum_alist.append(sum_alist[-1] + a)
sum_blist = [0]
for b in blist:
sum_blist.append(sum_blist[-1] + b)
index_b = M
answer = 0
for i in range(N + 1):
sum_a = sum_alist[i]
if sum_a > K:
break
while sum_a + sum_blist[index_b] > K:
index_b -= 1
# print(i,index_b)
answer = max(answer, i + index_b)
print(answer)
| false | 43.181818 | [
"-import bisect",
"-",
"-for i in range(N):",
"- sum_alist.append(sum_alist[-1] + alist[i])",
"-# print(sum_alist)",
"+for a in alist:",
"+ sum_alist.append(sum_alist[-1] + a)",
"-for i in range(M):",
"- sum_blist.append(sum_blist[-1] + blist[i])",
"-# print(sum_blist)",
"-limit_a = bisect.bisect(sum_alist, K)",
"-# print(limit_a)",
"-limit_b = bisect.bisect(sum_blist, K)",
"-# print(limit_b)",
"+for b in blist:",
"+ sum_blist.append(sum_blist[-1] + b)",
"+index_b = M",
"-for i in reversed(list(range(1, limit_a))):",
"- a_sum = sum_alist[i]",
"- b_sum = K - a_sum",
"- pos_b = bisect.bisect(sum_blist, b_sum)",
"- # print(i,pos_b-1,a_sum,sum_blist[pos_b-1],b_sum)",
"- answer = max(answer, i + pos_b - 1)",
"-for i in reversed(list(range(1, limit_b))):",
"- b_sum = sum_blist[i]",
"- a_sum = K - b_sum",
"- pos_a = bisect.bisect(sum_alist, a_sum)",
"- # print(i,pos_b-1,a_sum,sum_blist[pos_b-1],b_sum)",
"- answer = max(answer, i + pos_a - 1)",
"-if limit_a == 1:",
"- pos_b = bisect.bisect(sum_blist, K)",
"- answer = pos_b - 1",
"-elif limit_b == 1:",
"- pos_a = bisect.bisect(sum_alist, K)",
"- answer = pos_a - 1",
"+for i in range(N + 1):",
"+ sum_a = sum_alist[i]",
"+ if sum_a > K:",
"+ break",
"+ while sum_a + sum_blist[index_b] > K:",
"+ index_b -= 1",
"+ # print(i,index_b)",
"+ answer = max(answer, i + index_b)"
] | false | 0.03536 | 0.03531 | 1.00142 | [
"s768161296",
"s545141260"
] |
u367130284 | p03487 | python | s511446182 | s848869648 | 77 | 68 | 18,344 | 18,728 | Accepted | Accepted | 11.69 | import collections as c
a=c.Counter(list(map(int,open(0).read().split()[1:])))
print((sum([[v-k,v][k>v] for k,v in list(a.items())]))) | from collections import*;n,*a=list(map(int,open(0).read().split()));print((sum(v-k*(v>=k)for k,v in list(Counter(a).items())))) | 3 | 1 | 128 | 113 | import collections as c
a = c.Counter(list(map(int, open(0).read().split()[1:])))
print((sum([[v - k, v][k > v] for k, v in list(a.items())])))
| from collections import *
n, *a = list(map(int, open(0).read().split()))
print((sum(v - k * (v >= k) for k, v in list(Counter(a).items()))))
| false | 66.666667 | [
"-import collections as c",
"+from collections import *",
"-a = c.Counter(list(map(int, open(0).read().split()[1:])))",
"-print((sum([[v - k, v][k > v] for k, v in list(a.items())])))",
"+n, *a = list(map(int, open(0).read().split()))",
"+print((sum(v - k * (v >= k) for k, v in list(Counter(a).items()))))"
] | false | 0.136737 | 0.037661 | 3.630747 | [
"s511446182",
"s848869648"
] |
u623819879 | p03048 | python | s000562784 | s397189373 | 282 | 236 | 40,812 | 40,684 | Accepted | Accepted | 16.31 | ans=0
r,g,b,n=list(map(int,input().split()))
for i in range(n//r+2):
for j in range(n//g+2):
k=n-i*r-j*g
if k>=0 and k%b==0:
ans+=1
print(ans) | # coding: utf-8
#-------------------------------------------------------------------
import sys
def p(*a):
s=" ".join(map(str,a))
#print(s)
sys.stderr.write(s+"\n")
#-------------------------------------------------------------------
R,G,B,N = list(map(int, input().split()))
if R<G: R,G=G,R
if G<B: G,B=B,G
if R<G: R,G=G,R
r=g=b=0
ans=0
#p(N//R+2)
#p(N//G+2)
#X=[]
#p(r,g,b)
for r in range(N//R+2):
if (R*r)>N: break
for g in range(N//G+2):
if (R*r)+(G*g)>N:
break
X.append("break")
b = (N-(R*r)-(G*g))//B
n = (R*r)+(G*g)+(B*b)
if n==N:
ans+=1
# X.append([r,g,b])
# p(r,g,b,n,N,ans)
print(ans)
#p(X)
| 9 | 40 | 177 | 672 | ans = 0
r, g, b, n = list(map(int, input().split()))
for i in range(n // r + 2):
for j in range(n // g + 2):
k = n - i * r - j * g
if k >= 0 and k % b == 0:
ans += 1
print(ans)
| # coding: utf-8
# -------------------------------------------------------------------
import sys
def p(*a):
s = " ".join(map(str, a))
# print(s)
sys.stderr.write(s + "\n")
# -------------------------------------------------------------------
R, G, B, N = list(map(int, input().split()))
if R < G:
R, G = G, R
if G < B:
G, B = B, G
if R < G:
R, G = G, R
r = g = b = 0
ans = 0
# p(N//R+2)
# p(N//G+2)
# X=[]
# p(r,g,b)
for r in range(N // R + 2):
if (R * r) > N:
break
for g in range(N // G + 2):
if (R * r) + (G * g) > N:
break
X.append("break")
b = (N - (R * r) - (G * g)) // B
n = (R * r) + (G * g) + (B * b)
if n == N:
ans += 1
# X.append([r,g,b])
# p(r,g,b,n,N,ans)
print(ans)
# p(X)
| false | 77.5 | [
"+# coding: utf-8",
"+import sys",
"+",
"+",
"+def p(*a):",
"+ s = \" \".join(map(str, a))",
"+ # print(s)",
"+ sys.stderr.write(s + \"\\n\")",
"+",
"+",
"+R, G, B, N = list(map(int, input().split()))",
"+if R < G:",
"+ R, G = G, R",
"+if G < B:",
"+ G, B = B, G",
"+if R < G:",
"+ R, G = G, R",
"+r = g = b = 0",
"-r, g, b, n = list(map(int, input().split()))",
"-for i in range(n // r + 2):",
"- for j in range(n // g + 2):",
"- k = n - i * r - j * g",
"- if k >= 0 and k % b == 0:",
"+# p(N//R+2)",
"+# p(N//G+2)",
"+# X=[]",
"+# p(r,g,b)",
"+for r in range(N // R + 2):",
"+ if (R * r) > N:",
"+ break",
"+ for g in range(N // G + 2):",
"+ if (R * r) + (G * g) > N:",
"+ break",
"+ X.append(\"break\")",
"+ b = (N - (R * r) - (G * g)) // B",
"+ n = (R * r) + (G * g) + (B * b)",
"+ if n == N:",
"+# \t\t\tX.append([r,g,b])",
"+# \t\tp(r,g,b,n,N,ans)",
"+# p(X)"
] | false | 0.111715 | 0.058043 | 1.924672 | [
"s000562784",
"s397189373"
] |
u379959788 | p03212 | python | s229820265 | s172365343 | 77 | 39 | 3,064 | 3,060 | Accepted | Accepted | 49.35 | # ABC114
N = int(eval(input()))
def dfs(num):
if num > N:
return 0
flag = True
for s in "357":
if str(num).count(s) >= 1:
pass
else:
flag = False
ret = 1 if flag else 0
for c in [3, 5, 7]:
ret += dfs(num * 10 + c)
return ret
ans = dfs(0)
print(ans) | # ABC114
N = int(eval(input()))
def dfs(num, use):
if num > N:
return 0
cnt = 1 if use == 0b111 else 0
cnt += dfs(num*10 + 3, use | 0b001)
cnt += dfs(num*10 + 5, use | 0b010)
cnt += dfs(num*10 + 7, use | 0b100)
return cnt
ans = dfs(0, 0)
print(ans) | 19 | 13 | 342 | 287 | # ABC114
N = int(eval(input()))
def dfs(num):
if num > N:
return 0
flag = True
for s in "357":
if str(num).count(s) >= 1:
pass
else:
flag = False
ret = 1 if flag else 0
for c in [3, 5, 7]:
ret += dfs(num * 10 + c)
return ret
ans = dfs(0)
print(ans)
| # ABC114
N = int(eval(input()))
def dfs(num, use):
if num > N:
return 0
cnt = 1 if use == 0b111 else 0
cnt += dfs(num * 10 + 3, use | 0b001)
cnt += dfs(num * 10 + 5, use | 0b010)
cnt += dfs(num * 10 + 7, use | 0b100)
return cnt
ans = dfs(0, 0)
print(ans)
| false | 31.578947 | [
"-def dfs(num):",
"+def dfs(num, use):",
"- flag = True",
"- for s in \"357\":",
"- if str(num).count(s) >= 1:",
"- pass",
"- else:",
"- flag = False",
"- ret = 1 if flag else 0",
"- for c in [3, 5, 7]:",
"- ret += dfs(num * 10 + c)",
"- return ret",
"+ cnt = 1 if use == 0b111 else 0",
"+ cnt += dfs(num * 10 + 3, use | 0b001)",
"+ cnt += dfs(num * 10 + 5, use | 0b010)",
"+ cnt += dfs(num * 10 + 7, use | 0b100)",
"+ return cnt",
"-ans = dfs(0)",
"+ans = dfs(0, 0)"
] | false | 0.107819 | 0.053137 | 2.029063 | [
"s229820265",
"s172365343"
] |
u298297089 | p03416 | python | s590868982 | s892916862 | 134 | 94 | 3,060 | 3,060 | Accepted | Accepted | 29.85 | a,b = list(map(int,input().split()))
ans = 0
for i in range(a,b+1):
x = str(i)
flag = 1
for j in range(len(x) // 2):
if x[j] != x[-(j+1)]:
flag = 0
ans += flag
print(ans) | def is_palindrome(s):
for i in range(len(s) // 2 + 1):
if s[i] != s[-i-1]:
return False
return True
a,b = list(map(int, input().split()))
ans = 0
for i in range(a,b+1):
if is_palindrome(str(i)):
ans += 1
print(ans) | 10 | 14 | 191 | 257 | a, b = list(map(int, input().split()))
ans = 0
for i in range(a, b + 1):
x = str(i)
flag = 1
for j in range(len(x) // 2):
if x[j] != x[-(j + 1)]:
flag = 0
ans += flag
print(ans)
| def is_palindrome(s):
for i in range(len(s) // 2 + 1):
if s[i] != s[-i - 1]:
return False
return True
a, b = list(map(int, input().split()))
ans = 0
for i in range(a, b + 1):
if is_palindrome(str(i)):
ans += 1
print(ans)
| false | 28.571429 | [
"+def is_palindrome(s):",
"+ for i in range(len(s) // 2 + 1):",
"+ if s[i] != s[-i - 1]:",
"+ return False",
"+ return True",
"+",
"+",
"- x = str(i)",
"- flag = 1",
"- for j in range(len(x) // 2):",
"- if x[j] != x[-(j + 1)]:",
"- flag = 0",
"- ans += flag",
"+ if is_palindrome(str(i)):",
"+ ans += 1"
] | false | 0.059701 | 0.096516 | 0.618557 | [
"s590868982",
"s892916862"
] |
u353797797 | p02616 | python | s299579566 | s668288933 | 286 | 178 | 31,776 | 31,468 | Accepted | Accepted | 37.76 | import sys
sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def SI(): return sys.stdin.readline()[:-1]
def cal(xx):
res=1
for x in xx:
res=res*x%md
return res
md=10**9+7
n,k=MI()
aa=LI()
if n==k:
print(cal(aa))
exit()
aa.sort(key=lambda x:-abs(x))
#print(aa)
pre=aa[:k]
pos=aa[k:]
mnp=mnn=md
mnpi=mnni=-1
neg=0
for i,a in enumerate(pre):
if a==0:
print(0)
exit()
if a<0:neg+=1
if a>0 and a<mnp:
mnp=a
mnpi=i
if a<0 and -a<mnn:
mnn=-a
mnni=i
if neg%2:
mxp=mxn=0
for a in pos:
if a > 0 and a > mxp:
mxp = a
if a < 0 and -a > mxn:
mxn = -a
if (mnni!=-1 and mxp) or (mnpi!=-1 and mxn):
if mnpi==-1 or mxp*mnp>mxn*mnn:pre[mnni]=mxp
else:pre[mnpi]=-mxn
else:
pre=aa[-k:]
print(cal(pre))
| import sys
sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def SI(): return sys.stdin.readline()[:-1]
def main():
pos = []
neg = []
for a in aa:
if a < 0: neg.append(a)
else: pos.append(a)
pn = len(pos)
nn = len(neg)
if min(k,nn) // 2 * 2 + pn < k:
aa.sort(key=lambda x: abs(x))
print(cal(aa[:k]))
else:
pos.sort()
neg.sort(reverse=True)
ans = pos.pop() if k & 1 else 1
mul = []
while len(pos) > 1: mul.append(pos.pop() * pos.pop())
while len(neg) > 1: mul.append(neg.pop() * neg.pop())
mul.sort(reverse=True)
print(ans * cal(mul[:k // 2]) % md)
def cal(xx):
res=1
for x in xx:
res=res*x%md
return res
md=10**9+7
n,k=MI()
aa=LI()
main()
| 55 | 42 | 1,182 | 1,097 | import sys
sys.setrecursionlimit(10**6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def II():
return int(sys.stdin.readline())
def MI():
return map(int, sys.stdin.readline().split())
def LI():
return list(map(int, sys.stdin.readline().split()))
def LLI(rows_number):
return [LI() for _ in range(rows_number)]
def SI():
return sys.stdin.readline()[:-1]
def cal(xx):
res = 1
for x in xx:
res = res * x % md
return res
md = 10**9 + 7
n, k = MI()
aa = LI()
if n == k:
print(cal(aa))
exit()
aa.sort(key=lambda x: -abs(x))
# print(aa)
pre = aa[:k]
pos = aa[k:]
mnp = mnn = md
mnpi = mnni = -1
neg = 0
for i, a in enumerate(pre):
if a == 0:
print(0)
exit()
if a < 0:
neg += 1
if a > 0 and a < mnp:
mnp = a
mnpi = i
if a < 0 and -a < mnn:
mnn = -a
mnni = i
if neg % 2:
mxp = mxn = 0
for a in pos:
if a > 0 and a > mxp:
mxp = a
if a < 0 and -a > mxn:
mxn = -a
if (mnni != -1 and mxp) or (mnpi != -1 and mxn):
if mnpi == -1 or mxp * mnp > mxn * mnn:
pre[mnni] = mxp
else:
pre[mnpi] = -mxn
else:
pre = aa[-k:]
print(cal(pre))
| import sys
sys.setrecursionlimit(10**6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def II():
return int(sys.stdin.readline())
def MI():
return map(int, sys.stdin.readline().split())
def LI():
return list(map(int, sys.stdin.readline().split()))
def LLI(rows_number):
return [LI() for _ in range(rows_number)]
def SI():
return sys.stdin.readline()[:-1]
def main():
pos = []
neg = []
for a in aa:
if a < 0:
neg.append(a)
else:
pos.append(a)
pn = len(pos)
nn = len(neg)
if min(k, nn) // 2 * 2 + pn < k:
aa.sort(key=lambda x: abs(x))
print(cal(aa[:k]))
else:
pos.sort()
neg.sort(reverse=True)
ans = pos.pop() if k & 1 else 1
mul = []
while len(pos) > 1:
mul.append(pos.pop() * pos.pop())
while len(neg) > 1:
mul.append(neg.pop() * neg.pop())
mul.sort(reverse=True)
print(ans * cal(mul[: k // 2]) % md)
def cal(xx):
res = 1
for x in xx:
res = res * x % md
return res
md = 10**9 + 7
n, k = MI()
aa = LI()
main()
| false | 23.636364 | [
"+def main():",
"+ pos = []",
"+ neg = []",
"+ for a in aa:",
"+ if a < 0:",
"+ neg.append(a)",
"+ else:",
"+ pos.append(a)",
"+ pn = len(pos)",
"+ nn = len(neg)",
"+ if min(k, nn) // 2 * 2 + pn < k:",
"+ aa.sort(key=lambda x: abs(x))",
"+ print(cal(aa[:k]))",
"+ else:",
"+ pos.sort()",
"+ neg.sort(reverse=True)",
"+ ans = pos.pop() if k & 1 else 1",
"+ mul = []",
"+ while len(pos) > 1:",
"+ mul.append(pos.pop() * pos.pop())",
"+ while len(neg) > 1:",
"+ mul.append(neg.pop() * neg.pop())",
"+ mul.sort(reverse=True)",
"+ print(ans * cal(mul[: k // 2]) % md)",
"+",
"+",
"-if n == k:",
"- print(cal(aa))",
"- exit()",
"-aa.sort(key=lambda x: -abs(x))",
"-# print(aa)",
"-pre = aa[:k]",
"-pos = aa[k:]",
"-mnp = mnn = md",
"-mnpi = mnni = -1",
"-neg = 0",
"-for i, a in enumerate(pre):",
"- if a == 0:",
"- print(0)",
"- exit()",
"- if a < 0:",
"- neg += 1",
"- if a > 0 and a < mnp:",
"- mnp = a",
"- mnpi = i",
"- if a < 0 and -a < mnn:",
"- mnn = -a",
"- mnni = i",
"-if neg % 2:",
"- mxp = mxn = 0",
"- for a in pos:",
"- if a > 0 and a > mxp:",
"- mxp = a",
"- if a < 0 and -a > mxn:",
"- mxn = -a",
"- if (mnni != -1 and mxp) or (mnpi != -1 and mxn):",
"- if mnpi == -1 or mxp * mnp > mxn * mnn:",
"- pre[mnni] = mxp",
"- else:",
"- pre[mnpi] = -mxn",
"- else:",
"- pre = aa[-k:]",
"-print(cal(pre))",
"+main()"
] | false | 0.045149 | 0.044162 | 1.022336 | [
"s299579566",
"s668288933"
] |
u716530146 | p02699 | python | s600673971 | s721147043 | 115 | 22 | 65,208 | 9,540 | Accepted | Accepted | 80.87 | #!/usr/bin/env python3
import sys, math, itertools, collections, bisect
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')
inf = float('inf') ;mod = 10**9+7
mans = inf ;ans = 0 ;count = 0 ;pro = 1
s,w = list(map(int,input().split()))
if s <= w:
print("unsafe")
else:
print("safe") | #!/usr/bin/env python3
import sys, math, itertools, collections, bisect
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')
inf = float('inf') ;mod = 10**9+7
mans = inf ;ans = 0 ;count = 0 ;pro = 1
s,w = list(map(int,input().split()))
print(("unsafe" if s <= w else "safe")) | 11 | 8 | 307 | 291 | #!/usr/bin/env python3
import sys, math, itertools, collections, bisect
input = lambda: sys.stdin.buffer.readline().rstrip().decode("utf-8")
inf = float("inf")
mod = 10**9 + 7
mans = inf
ans = 0
count = 0
pro = 1
s, w = list(map(int, input().split()))
if s <= w:
print("unsafe")
else:
print("safe")
| #!/usr/bin/env python3
import sys, math, itertools, collections, bisect
input = lambda: sys.stdin.buffer.readline().rstrip().decode("utf-8")
inf = float("inf")
mod = 10**9 + 7
mans = inf
ans = 0
count = 0
pro = 1
s, w = list(map(int, input().split()))
print(("unsafe" if s <= w else "safe"))
| false | 27.272727 | [
"-if s <= w:",
"- print(\"unsafe\")",
"-else:",
"- print(\"safe\")",
"+print((\"unsafe\" if s <= w else \"safe\"))"
] | false | 0.040441 | 0.037664 | 1.073718 | [
"s600673971",
"s721147043"
] |
u620238824 | p02689 | python | s485886477 | s138896017 | 315 | 246 | 31,940 | 19,960 | Accepted | Accepted | 21.9 | N, M = list(map(int, input().split())) #数字
H = list(map(int, input().split()))#リスト
A = [list(map(int, input().split())) for i in range(M)] #数字、複数行複数列
good = [True]*N
for i, j in A:
i -= 1
j -= 1
if H[i] < H[j]:
good[i] = False
if H[i] > H[j]:
good[j] = False
if H[i] == H[j]:
good[i] = False
good[j] = False
print((good.count(True))) | n, m = list(map(int, input().split()))
h = list(map(int, input().split()))
l = [True] * n
for i in range(m):
a, b = list(map(int, input().split()))
a -= 1
b -= 1
#print(h[a],h[b])
if h[a] >= h[b]:
l[b] = False
if h[a] <= h[b]:
l[a] = False
#print(l)
print((l.count(True))) | 17 | 16 | 397 | 315 | N, M = list(map(int, input().split())) # 数字
H = list(map(int, input().split())) # リスト
A = [list(map(int, input().split())) for i in range(M)] # 数字、複数行複数列
good = [True] * N
for i, j in A:
i -= 1
j -= 1
if H[i] < H[j]:
good[i] = False
if H[i] > H[j]:
good[j] = False
if H[i] == H[j]:
good[i] = False
good[j] = False
print((good.count(True)))
| n, m = list(map(int, input().split()))
h = list(map(int, input().split()))
l = [True] * n
for i in range(m):
a, b = list(map(int, input().split()))
a -= 1
b -= 1
# print(h[a],h[b])
if h[a] >= h[b]:
l[b] = False
if h[a] <= h[b]:
l[a] = False
# print(l)
print((l.count(True)))
| false | 5.882353 | [
"-N, M = list(map(int, input().split())) # 数字",
"-H = list(map(int, input().split())) # リスト",
"-A = [list(map(int, input().split())) for i in range(M)] # 数字、複数行複数列",
"-good = [True] * N",
"-for i, j in A:",
"- i -= 1",
"- j -= 1",
"- if H[i] < H[j]:",
"- good[i] = False",
"- if H[i] > H[j]:",
"- good[j] = False",
"- if H[i] == H[j]:",
"- good[i] = False",
"- good[j] = False",
"-print((good.count(True)))",
"+n, m = list(map(int, input().split()))",
"+h = list(map(int, input().split()))",
"+l = [True] * n",
"+for i in range(m):",
"+ a, b = list(map(int, input().split()))",
"+ a -= 1",
"+ b -= 1",
"+ # print(h[a],h[b])",
"+ if h[a] >= h[b]:",
"+ l[b] = False",
"+ if h[a] <= h[b]:",
"+ l[a] = False",
"+# print(l)",
"+print((l.count(True)))"
] | false | 0.008094 | 0.037584 | 0.215364 | [
"s485886477",
"s138896017"
] |
u385792265 | p03167 | python | s367955262 | s956105168 | 609 | 438 | 13,812 | 11,892 | Accepted | Accepted | 28.08 | h, w = list(map(int, input().split()))
a=[ list(eval(input())) for _ in range(h)]
dp=[1]+[0]*(w-1)
for i in range(h):
dp[0]=int(dp[0]==1 and a[i][0]=='.')
for j in range(1,w): dp[j]=(int(a[i][j]=='.')*(dp[j]+dp[j-1]) % 1000000007 )
print((dp[-1])) | h, w = list(map(int, input().split()))
a=[ list(eval(input())) for _ in range(h)]
dp=[1]+[0]*(w-1)
for i in range(h):
dp[0]=int(dp[0]==1 and a[i][0]=='.')
for j in range(1,w): dp[j]=( (dp[j]+dp[j-1]) % 1000000007) if a[i][j]=='.' else 0
print((dp[-1])) | 7 | 7 | 247 | 252 | h, w = list(map(int, input().split()))
a = [list(eval(input())) for _ in range(h)]
dp = [1] + [0] * (w - 1)
for i in range(h):
dp[0] = int(dp[0] == 1 and a[i][0] == ".")
for j in range(1, w):
dp[j] = int(a[i][j] == ".") * (dp[j] + dp[j - 1]) % 1000000007
print((dp[-1]))
| h, w = list(map(int, input().split()))
a = [list(eval(input())) for _ in range(h)]
dp = [1] + [0] * (w - 1)
for i in range(h):
dp[0] = int(dp[0] == 1 and a[i][0] == ".")
for j in range(1, w):
dp[j] = ((dp[j] + dp[j - 1]) % 1000000007) if a[i][j] == "." else 0
print((dp[-1]))
| false | 0 | [
"- dp[j] = int(a[i][j] == \".\") * (dp[j] + dp[j - 1]) % 1000000007",
"+ dp[j] = ((dp[j] + dp[j - 1]) % 1000000007) if a[i][j] == \".\" else 0"
] | false | 0.037545 | 0.042956 | 0.874035 | [
"s367955262",
"s956105168"
] |
u630511239 | p03659 | python | s627507219 | s962908668 | 169 | 147 | 24,812 | 30,592 | Accepted | Accepted | 13.02 | N = int(eval(input()))
a = list(map(int, input().split()))
s = a[:1]
t = a[1:]
x = sum(s)
y = sum(t)
if x==y:
ans = 0
else:
ans = abs(x-y)
for i in range(1,N-1):
x += a[i]
y -= a[i]
if x==y:
ans = 0
break
elif abs(x-y)<ans:
ans = abs(x-y)
print(ans) | N = int(eval(input()))
A = list(map(int, input().split()))
x = A[0]
y = sum(A[1:])
ans = abs(x - y)
for i in range(1, N - 1):
a = A[i]
x += a
y -= a
dif = abs(x - y)
if dif < ans:
ans = dif
print(ans) | 20 | 13 | 287 | 234 | N = int(eval(input()))
a = list(map(int, input().split()))
s = a[:1]
t = a[1:]
x = sum(s)
y = sum(t)
if x == y:
ans = 0
else:
ans = abs(x - y)
for i in range(1, N - 1):
x += a[i]
y -= a[i]
if x == y:
ans = 0
break
elif abs(x - y) < ans:
ans = abs(x - y)
print(ans)
| N = int(eval(input()))
A = list(map(int, input().split()))
x = A[0]
y = sum(A[1:])
ans = abs(x - y)
for i in range(1, N - 1):
a = A[i]
x += a
y -= a
dif = abs(x - y)
if dif < ans:
ans = dif
print(ans)
| false | 35 | [
"-a = list(map(int, input().split()))",
"-s = a[:1]",
"-t = a[1:]",
"-x = sum(s)",
"-y = sum(t)",
"-if x == y:",
"- ans = 0",
"-else:",
"- ans = abs(x - y)",
"+A = list(map(int, input().split()))",
"+x = A[0]",
"+y = sum(A[1:])",
"+ans = abs(x - y)",
"- x += a[i]",
"- y -= a[i]",
"- if x == y:",
"- ans = 0",
"- break",
"- elif abs(x - y) < ans:",
"- ans = abs(x - y)",
"+ a = A[i]",
"+ x += a",
"+ y -= a",
"+ dif = abs(x - y)",
"+ if dif < ans:",
"+ ans = dif"
] | false | 0.096888 | 0.098523 | 0.983407 | [
"s627507219",
"s962908668"
] |
u316464887 | p03161 | python | s858705449 | s058590195 | 1,877 | 1,642 | 13,976 | 13,976 | Accepted | Accepted | 12.52 | def main():
n, k = list(map(int, input().split()))
h = list(map(int, input().split()))
m = [0] * n
m[0] = 0
for i in range(1, n):
s = max(0, i-k)
m[i] = min([ml + abs(hl - h[i]) for ml, hl in zip(m[s:i], h[s:i])])
print((m[-1]))
main()
| def main():
n, k = list(map(int, input().split()))
h = list(map(int, input().split()))
m = [0] * n
m[0] = 0
for i, hi in enumerate(h):
if i == 0:
continue
s = max(0, i-k)
m[i] = min([ml + abs(hl - hi) for ml, hl in zip(m[s:i], h[s:i])])
print((m[-1]))
main()
| 11 | 13 | 279 | 324 | def main():
n, k = list(map(int, input().split()))
h = list(map(int, input().split()))
m = [0] * n
m[0] = 0
for i in range(1, n):
s = max(0, i - k)
m[i] = min([ml + abs(hl - h[i]) for ml, hl in zip(m[s:i], h[s:i])])
print((m[-1]))
main()
| def main():
n, k = list(map(int, input().split()))
h = list(map(int, input().split()))
m = [0] * n
m[0] = 0
for i, hi in enumerate(h):
if i == 0:
continue
s = max(0, i - k)
m[i] = min([ml + abs(hl - hi) for ml, hl in zip(m[s:i], h[s:i])])
print((m[-1]))
main()
| false | 15.384615 | [
"- for i in range(1, n):",
"+ for i, hi in enumerate(h):",
"+ if i == 0:",
"+ continue",
"- m[i] = min([ml + abs(hl - h[i]) for ml, hl in zip(m[s:i], h[s:i])])",
"+ m[i] = min([ml + abs(hl - hi) for ml, hl in zip(m[s:i], h[s:i])])"
] | false | 0.038011 | 0.09946 | 0.382179 | [
"s858705449",
"s058590195"
] |
u623687794 | p02901 | python | s473549893 | s765917810 | 315 | 119 | 46,552 | 76,592 | Accepted | Accepted | 62.22 | n,m=list(map(int,input().split()))
keys=[None]*m
dp=[-1]*(2**n)
dp[0]=0
for i in range(m):
a,b=list(map(int,input().split()))
c=list(map(int,input().split()))
cond=0
for j in c:
cond+=2**(j-1)
keys[i]=[a,cond]
for key in keys:
for sta in range(2**n):
if dp[sta]==-1:continue
if dp[sta|key[1]]==-1:
dp[sta|key[1]]=key[0]+dp[sta]
else:
dp[sta|key[1]]=min(dp[sta|key[1]],dp[sta]+key[0])
print((dp[-1]))
| n,m=list(map(int,input().split()))
keys=[None]*m
INF = 10**10
dp=[INF]*(2**n)
dp[0]=0
for i in range(m):
a,b=list(map(int,input().split()))
c=list(map(int,input().split()))
cond=0
for j in c:
cond+=2**(j-1)
keys[i]=[a,cond]
for key in keys:
for sta in range(2**n):
dp[sta|key[1]]=min(dp[sta|key[1]],dp[sta]+key[0])
print((dp[-1] if dp[-1] != INF else -1))
| 19 | 16 | 444 | 381 | n, m = list(map(int, input().split()))
keys = [None] * m
dp = [-1] * (2**n)
dp[0] = 0
for i in range(m):
a, b = list(map(int, input().split()))
c = list(map(int, input().split()))
cond = 0
for j in c:
cond += 2 ** (j - 1)
keys[i] = [a, cond]
for key in keys:
for sta in range(2**n):
if dp[sta] == -1:
continue
if dp[sta | key[1]] == -1:
dp[sta | key[1]] = key[0] + dp[sta]
else:
dp[sta | key[1]] = min(dp[sta | key[1]], dp[sta] + key[0])
print((dp[-1]))
| n, m = list(map(int, input().split()))
keys = [None] * m
INF = 10**10
dp = [INF] * (2**n)
dp[0] = 0
for i in range(m):
a, b = list(map(int, input().split()))
c = list(map(int, input().split()))
cond = 0
for j in c:
cond += 2 ** (j - 1)
keys[i] = [a, cond]
for key in keys:
for sta in range(2**n):
dp[sta | key[1]] = min(dp[sta | key[1]], dp[sta] + key[0])
print((dp[-1] if dp[-1] != INF else -1))
| false | 15.789474 | [
"-dp = [-1] * (2**n)",
"+INF = 10**10",
"+dp = [INF] * (2**n)",
"- if dp[sta] == -1:",
"- continue",
"- if dp[sta | key[1]] == -1:",
"- dp[sta | key[1]] = key[0] + dp[sta]",
"- else:",
"- dp[sta | key[1]] = min(dp[sta | key[1]], dp[sta] + key[0])",
"-print((dp[-1]))",
"+ dp[sta | key[1]] = min(dp[sta | key[1]], dp[sta] + key[0])",
"+print((dp[-1] if dp[-1] != INF else -1))"
] | false | 0.035843 | 0.035928 | 0.997628 | [
"s473549893",
"s765917810"
] |
u740284863 | p02580 | python | s226876116 | s791015197 | 1,031 | 807 | 121,940 | 122,176 | Accepted | Accepted | 21.73 | import collections
h,w,m = list(map(int,input().split()))
X = []
Y = []
for _ in range(m):
x,y = list(map(int,input().split()))
X.append(x)
Y.append(y)
most_common_x = collections.Counter(X).most_common()
most_common_x_index = most_common_x[0][0]
most_common_x_count = most_common_x[0][1]
most_common_y = collections.Counter(Y).most_common()
most_common_y_index = most_common_y[0][0]
most_common_y_count = most_common_y[0][1]
otherwisey = []
otherwisex = []
for i in range(m):
if X[i] != most_common_x_index:
otherwisey.append(Y[i])
if Y[i] != most_common_y_index:
otherwisex.append(X[i])
most_common_y = collections.Counter(otherwisey).most_common()
if len(most_common_y)!= 0:
ansx = most_common_y[0][1] + most_common_x_count
else:
ansx = most_common_x_count
most_common_x = collections.Counter(otherwisex).most_common()
if len(most_common_x)!= 0:
ansy = most_common_x[0][1] + most_common_y_count
else:
ansy = most_common_y_count
print((max(ansx,ansy))) | import collections
import sys
def input() : return sys.stdin.readline().strip()
h,w,m = list(map(int,input().split()))
X = []
Y = []
for _ in range(m):
x,y = list(map(int,input().split()))
X.append(x)
Y.append(y)
most_common_x = collections.Counter(X).most_common()
most_common_x_index = most_common_x[0][0]
most_common_x_count = most_common_x[0][1]
most_common_y = collections.Counter(Y).most_common()
most_common_y_index = most_common_y[0][0]
most_common_y_count = most_common_y[0][1]
otherwisey = []
otherwisex = []
for i in range(m):
if X[i] != most_common_x_index:
otherwisey.append(Y[i])
if Y[i] != most_common_y_index:
otherwisex.append(X[i])
most_common_y = collections.Counter(otherwisey).most_common()
if len(most_common_y)!= 0:
ansx = most_common_y[0][1] + most_common_x_count
else:
ansx = most_common_x_count
most_common_x = collections.Counter(otherwisex).most_common()
if len(most_common_x)!= 0:
ansy = most_common_x[0][1] + most_common_y_count
else:
ansy = most_common_y_count
print((max(ansx,ansy))) | 38 | 39 | 1,035 | 1,096 | import collections
h, w, m = list(map(int, input().split()))
X = []
Y = []
for _ in range(m):
x, y = list(map(int, input().split()))
X.append(x)
Y.append(y)
most_common_x = collections.Counter(X).most_common()
most_common_x_index = most_common_x[0][0]
most_common_x_count = most_common_x[0][1]
most_common_y = collections.Counter(Y).most_common()
most_common_y_index = most_common_y[0][0]
most_common_y_count = most_common_y[0][1]
otherwisey = []
otherwisex = []
for i in range(m):
if X[i] != most_common_x_index:
otherwisey.append(Y[i])
if Y[i] != most_common_y_index:
otherwisex.append(X[i])
most_common_y = collections.Counter(otherwisey).most_common()
if len(most_common_y) != 0:
ansx = most_common_y[0][1] + most_common_x_count
else:
ansx = most_common_x_count
most_common_x = collections.Counter(otherwisex).most_common()
if len(most_common_x) != 0:
ansy = most_common_x[0][1] + most_common_y_count
else:
ansy = most_common_y_count
print((max(ansx, ansy)))
| import collections
import sys
def input():
return sys.stdin.readline().strip()
h, w, m = list(map(int, input().split()))
X = []
Y = []
for _ in range(m):
x, y = list(map(int, input().split()))
X.append(x)
Y.append(y)
most_common_x = collections.Counter(X).most_common()
most_common_x_index = most_common_x[0][0]
most_common_x_count = most_common_x[0][1]
most_common_y = collections.Counter(Y).most_common()
most_common_y_index = most_common_y[0][0]
most_common_y_count = most_common_y[0][1]
otherwisey = []
otherwisex = []
for i in range(m):
if X[i] != most_common_x_index:
otherwisey.append(Y[i])
if Y[i] != most_common_y_index:
otherwisex.append(X[i])
most_common_y = collections.Counter(otherwisey).most_common()
if len(most_common_y) != 0:
ansx = most_common_y[0][1] + most_common_x_count
else:
ansx = most_common_x_count
most_common_x = collections.Counter(otherwisex).most_common()
if len(most_common_x) != 0:
ansy = most_common_x[0][1] + most_common_y_count
else:
ansy = most_common_y_count
print((max(ansx, ansy)))
| false | 2.564103 | [
"+import sys",
"+",
"+",
"+def input():",
"+ return sys.stdin.readline().strip()",
"+"
] | false | 0.042927 | 0.037843 | 1.134339 | [
"s226876116",
"s791015197"
] |
u238956837 | p02783 | python | s523289321 | s146995697 | 19 | 17 | 2,940 | 2,940 | Accepted | Accepted | 10.53 | h, a = list(map(int, input().split()))
ans = 0
while h > 0:
h -= a
ans += 1
print(ans) | import math
h, a = list(map(int, input().split()))
ans = 0
print((math.ceil(h/a))) | 8 | 5 | 93 | 79 | h, a = list(map(int, input().split()))
ans = 0
while h > 0:
h -= a
ans += 1
print(ans)
| import math
h, a = list(map(int, input().split()))
ans = 0
print((math.ceil(h / a)))
| false | 37.5 | [
"+import math",
"+",
"-while h > 0:",
"- h -= a",
"- ans += 1",
"-print(ans)",
"+print((math.ceil(h / a)))"
] | false | 0.048768 | 0.047217 | 1.032865 | [
"s523289321",
"s146995697"
] |
u352394527 | p00731 | python | s460159606 | s259483541 | 1,140 | 900 | 6,208 | 6,216 | Accepted | Accepted | 21.05 | from heapq import heappush, heappop
R_next = tuple((x, y) for x in range(-3, 0) for y in range(-2, 3) if abs(x) + abs(y) <= 3)
L_next = tuple((x, y) for x in range(1, 4) for y in range(-2, 3) if abs(x) + abs(y) <= 3)
c_num = tuple(str(i) for i in range(10))
L, R = 0, 1
INF = 10 ** 20
def conv(c):
if c in c_num:
return int(c)
if c in ("T", "S"):
return 0
return -1
while True:
w, h = list(map(int, input().split()))
if w == 0:
break
mp = [[-1] * 3 + input().split() + [-1] * 3 for _ in range(h)]
for i in range(h):
mp[i] = list(map(conv, mp[i]))
mp.insert(0, [-1] * (w + 6))
mp.insert(0, [-1] * (w + 6))
mp.append([-1] * (w + 6))
mp.append([-1] * (w + 6))
start = []
goal = []
for x in range(3, w + 3):
if mp[h + 1][x] == 0:
start.append((x, h + 1))
if mp[2][x] == 0:
goal.append((x, 2))
que = []
dic = {}
for x, y, in start:
heappush(que, (0, x, y, L))
heappush(que, (0, x, y, R))
dic[(x, y, L)] = 0
dic[(x, y, R)] = 0
while que:
total, x, y, foot = heappop(que)
if foot == R:
direct = R_next
next_foot = L
else:
direct = L_next
next_foot = R
for dx, dy in direct:
nx, ny = x + dx, y + dy
cost = mp[ny][nx]
if cost == -1:
continue
if not (nx, ny, next_foot) in dic or dic[(nx, ny, next_foot)] > total + cost:
dic[(nx, ny, next_foot)] = total + cost
heappush(que, (total + cost, nx, ny, next_foot))
ans = INF
for x, y in goal:
if (x, y, L) in dic: ans = min(ans, dic[(x, y, L)])
if (x, y, R) in dic: ans = min(ans, dic[(x, y, R)])
if ans == INF:
print((-1))
else:
print(ans)
| from heapq import heappush, heappop
R_next = tuple((x, y) for x in range(-3, 0) for y in range(-2, 3) if abs(x) + abs(y) <= 3)
L_next = tuple((x, y) for x in range(1, 4) for y in range(-2, 3) if abs(x) + abs(y) <= 3)
c_num = tuple(str(i) for i in range(10))
L, R = 0, 1
INF = 10 ** 20
def conv(c):
if c in c_num:
return int(c)
if c in ("T", "S"):
return 0
return -1
while True:
w, h = list(map(int, input().split()))
if w == 0:
break
mp = [[-1] * 3 + input().split() + [-1] * 3 for _ in range(h)]
for i in range(h):
mp[i] = list(map(conv, mp[i]))
mp.insert(0, [-1] * (w + 6))
mp.insert(0, [-1] * (w + 6))
mp.append([-1] * (w + 6))
mp.append([-1] * (w + 6))
def search():
start = []
goal = []
for x in range(3, w + 3):
if mp[h + 1][x] == 0:
start.append((x, h + 1))
if mp[2][x] == 0:
goal.append((x, 2))
que = []
dic = {}
for x, y, in start:
heappush(que, (0, x, y, L))
heappush(que, (0, x, y, R))
dic[(x, y, L)] = 0
dic[(x, y, R)] = 0
while que:
total, x, y, foot = heappop(que)
if foot == R:
direct = R_next
next_foot = L
else:
direct = L_next
next_foot = R
for dx, dy in direct:
nx, ny = x + dx, y + dy
if (nx, ny) in goal:
return total
cost = mp[ny][nx]
if cost == -1:
continue
if not (nx, ny, next_foot) in dic or dic[(nx, ny, next_foot)] > total + cost:
dic[(nx, ny, next_foot)] = total + cost
heappush(que, (total + cost, nx, ny, next_foot))
else:
return -1
print((search()))
| 68 | 66 | 1,744 | 1,716 | from heapq import heappush, heappop
R_next = tuple(
(x, y) for x in range(-3, 0) for y in range(-2, 3) if abs(x) + abs(y) <= 3
)
L_next = tuple(
(x, y) for x in range(1, 4) for y in range(-2, 3) if abs(x) + abs(y) <= 3
)
c_num = tuple(str(i) for i in range(10))
L, R = 0, 1
INF = 10**20
def conv(c):
if c in c_num:
return int(c)
if c in ("T", "S"):
return 0
return -1
while True:
w, h = list(map(int, input().split()))
if w == 0:
break
mp = [[-1] * 3 + input().split() + [-1] * 3 for _ in range(h)]
for i in range(h):
mp[i] = list(map(conv, mp[i]))
mp.insert(0, [-1] * (w + 6))
mp.insert(0, [-1] * (w + 6))
mp.append([-1] * (w + 6))
mp.append([-1] * (w + 6))
start = []
goal = []
for x in range(3, w + 3):
if mp[h + 1][x] == 0:
start.append((x, h + 1))
if mp[2][x] == 0:
goal.append((x, 2))
que = []
dic = {}
for (
x,
y,
) in start:
heappush(que, (0, x, y, L))
heappush(que, (0, x, y, R))
dic[(x, y, L)] = 0
dic[(x, y, R)] = 0
while que:
total, x, y, foot = heappop(que)
if foot == R:
direct = R_next
next_foot = L
else:
direct = L_next
next_foot = R
for dx, dy in direct:
nx, ny = x + dx, y + dy
cost = mp[ny][nx]
if cost == -1:
continue
if (
not (nx, ny, next_foot) in dic
or dic[(nx, ny, next_foot)] > total + cost
):
dic[(nx, ny, next_foot)] = total + cost
heappush(que, (total + cost, nx, ny, next_foot))
ans = INF
for x, y in goal:
if (x, y, L) in dic:
ans = min(ans, dic[(x, y, L)])
if (x, y, R) in dic:
ans = min(ans, dic[(x, y, R)])
if ans == INF:
print((-1))
else:
print(ans)
| from heapq import heappush, heappop
R_next = tuple(
(x, y) for x in range(-3, 0) for y in range(-2, 3) if abs(x) + abs(y) <= 3
)
L_next = tuple(
(x, y) for x in range(1, 4) for y in range(-2, 3) if abs(x) + abs(y) <= 3
)
c_num = tuple(str(i) for i in range(10))
L, R = 0, 1
INF = 10**20
def conv(c):
if c in c_num:
return int(c)
if c in ("T", "S"):
return 0
return -1
while True:
w, h = list(map(int, input().split()))
if w == 0:
break
mp = [[-1] * 3 + input().split() + [-1] * 3 for _ in range(h)]
for i in range(h):
mp[i] = list(map(conv, mp[i]))
mp.insert(0, [-1] * (w + 6))
mp.insert(0, [-1] * (w + 6))
mp.append([-1] * (w + 6))
mp.append([-1] * (w + 6))
def search():
start = []
goal = []
for x in range(3, w + 3):
if mp[h + 1][x] == 0:
start.append((x, h + 1))
if mp[2][x] == 0:
goal.append((x, 2))
que = []
dic = {}
for (
x,
y,
) in start:
heappush(que, (0, x, y, L))
heappush(que, (0, x, y, R))
dic[(x, y, L)] = 0
dic[(x, y, R)] = 0
while que:
total, x, y, foot = heappop(que)
if foot == R:
direct = R_next
next_foot = L
else:
direct = L_next
next_foot = R
for dx, dy in direct:
nx, ny = x + dx, y + dy
if (nx, ny) in goal:
return total
cost = mp[ny][nx]
if cost == -1:
continue
if (
not (nx, ny, next_foot) in dic
or dic[(nx, ny, next_foot)] > total + cost
):
dic[(nx, ny, next_foot)] = total + cost
heappush(que, (total + cost, nx, ny, next_foot))
else:
return -1
print((search()))
| false | 2.941176 | [
"- start = []",
"- goal = []",
"- for x in range(3, w + 3):",
"- if mp[h + 1][x] == 0:",
"- start.append((x, h + 1))",
"- if mp[2][x] == 0:",
"- goal.append((x, 2))",
"- que = []",
"- dic = {}",
"- for (",
"- x,",
"- y,",
"- ) in start:",
"- heappush(que, (0, x, y, L))",
"- heappush(que, (0, x, y, R))",
"- dic[(x, y, L)] = 0",
"- dic[(x, y, R)] = 0",
"- while que:",
"- total, x, y, foot = heappop(que)",
"- if foot == R:",
"- direct = R_next",
"- next_foot = L",
"+",
"+ def search():",
"+ start = []",
"+ goal = []",
"+ for x in range(3, w + 3):",
"+ if mp[h + 1][x] == 0:",
"+ start.append((x, h + 1))",
"+ if mp[2][x] == 0:",
"+ goal.append((x, 2))",
"+ que = []",
"+ dic = {}",
"+ for (",
"+ x,",
"+ y,",
"+ ) in start:",
"+ heappush(que, (0, x, y, L))",
"+ heappush(que, (0, x, y, R))",
"+ dic[(x, y, L)] = 0",
"+ dic[(x, y, R)] = 0",
"+ while que:",
"+ total, x, y, foot = heappop(que)",
"+ if foot == R:",
"+ direct = R_next",
"+ next_foot = L",
"+ else:",
"+ direct = L_next",
"+ next_foot = R",
"+ for dx, dy in direct:",
"+ nx, ny = x + dx, y + dy",
"+ if (nx, ny) in goal:",
"+ return total",
"+ cost = mp[ny][nx]",
"+ if cost == -1:",
"+ continue",
"+ if (",
"+ not (nx, ny, next_foot) in dic",
"+ or dic[(nx, ny, next_foot)] > total + cost",
"+ ):",
"+ dic[(nx, ny, next_foot)] = total + cost",
"+ heappush(que, (total + cost, nx, ny, next_foot))",
"- direct = L_next",
"- next_foot = R",
"- for dx, dy in direct:",
"- nx, ny = x + dx, y + dy",
"- cost = mp[ny][nx]",
"- if cost == -1:",
"- continue",
"- if (",
"- not (nx, ny, next_foot) in dic",
"- or dic[(nx, ny, next_foot)] > total + cost",
"- ):",
"- dic[(nx, ny, next_foot)] = total + cost",
"- heappush(que, (total + cost, nx, ny, next_foot))",
"- ans = INF",
"- for x, y in goal:",
"- if (x, y, L) in dic:",
"- ans = min(ans, dic[(x, y, L)])",
"- if (x, y, R) in dic:",
"- ans = min(ans, dic[(x, y, R)])",
"- if ans == INF:",
"- print((-1))",
"- else:",
"- print(ans)",
"+ return -1",
"+",
"+ print((search()))"
] | false | 0.089362 | 0.111819 | 0.799166 | [
"s460159606",
"s259483541"
] |
u953486781 | p03455 | python | s807534056 | s780978205 | 26 | 17 | 3,316 | 2,940 | Accepted | Accepted | 34.62 | a, b = list(map(int, input().split()))
if a * b % 2 == 0:
print("Even")
else:
print("Odd") | a, b = list(map(int, input().split()))
if (a * b) % 2 == 0:
print('Even')
else:
print('Odd') | 5 | 5 | 96 | 98 | a, b = list(map(int, input().split()))
if a * b % 2 == 0:
print("Even")
else:
print("Odd")
| a, b = list(map(int, input().split()))
if (a * b) % 2 == 0:
print("Even")
else:
print("Odd")
| false | 0 | [
"-if a * b % 2 == 0:",
"+if (a * b) % 2 == 0:"
] | false | 0.035973 | 0.058073 | 0.619445 | [
"s807534056",
"s780978205"
] |
u076503518 | p03127 | python | s558027092 | s162800216 | 100 | 84 | 14,228 | 14,252 | Accepted | Accepted | 16 | N = int(eval(input()))
A = list(map(int, input().split()))
A.sort(reverse=True)
denominator = 0
numerator = 1
while A[numerator] != 0:
A[denominator] = A[denominator] % A[numerator]
if A[denominator] == 0:
denominator += 1
numerator += 1
if denominator >= N or numerator >= N:
break
else:
denominator, numerator = numerator, denominator
print((min([a for a in A if a > 0]))) | N = int(eval(input()))
A = list(map(int, input().split()))
def gcd(a, b):
if a % b == 0:
return b
else:
return gcd(b, a%b)
ans = gcd(A[0], A[1])
if N > 2:
for i in range(2, N):
ans = gcd(ans, A[i])
print(ans) | 17 | 15 | 440 | 255 | N = int(eval(input()))
A = list(map(int, input().split()))
A.sort(reverse=True)
denominator = 0
numerator = 1
while A[numerator] != 0:
A[denominator] = A[denominator] % A[numerator]
if A[denominator] == 0:
denominator += 1
numerator += 1
if denominator >= N or numerator >= N:
break
else:
denominator, numerator = numerator, denominator
print((min([a for a in A if a > 0])))
| N = int(eval(input()))
A = list(map(int, input().split()))
def gcd(a, b):
if a % b == 0:
return b
else:
return gcd(b, a % b)
ans = gcd(A[0], A[1])
if N > 2:
for i in range(2, N):
ans = gcd(ans, A[i])
print(ans)
| false | 11.764706 | [
"-A.sort(reverse=True)",
"-denominator = 0",
"-numerator = 1",
"-while A[numerator] != 0:",
"- A[denominator] = A[denominator] % A[numerator]",
"- if A[denominator] == 0:",
"- denominator += 1",
"- numerator += 1",
"- if denominator >= N or numerator >= N:",
"- break",
"+",
"+",
"+def gcd(a, b):",
"+ if a % b == 0:",
"+ return b",
"- denominator, numerator = numerator, denominator",
"-print((min([a for a in A if a > 0])))",
"+ return gcd(b, a % b)",
"+",
"+",
"+ans = gcd(A[0], A[1])",
"+if N > 2:",
"+ for i in range(2, N):",
"+ ans = gcd(ans, A[i])",
"+print(ans)"
] | false | 0.040831 | 0.044665 | 0.914166 | [
"s558027092",
"s162800216"
] |
u997641430 | p02725 | python | s354088899 | s911302705 | 291 | 118 | 92,820 | 26,060 | Accepted | Accepted | 59.45 | K, N = list(map(int, input().split()))
*A, = list(map(int, input().split()))
B = [A[i + 1] - A[i] for i in range(N - 1)]
B.append(A[0] + K - A[N - 1])
print((sum(B) - max(B)))
| k, n = list(map(int, input().split()))
*A, = list(map(int, input().split()))
B = []
for i in range(1, n):
B.append(A[i]-A[i-1])
B.append(k-sum(B))
print((k-max(B)))
| 5 | 7 | 166 | 161 | K, N = list(map(int, input().split()))
(*A,) = list(map(int, input().split()))
B = [A[i + 1] - A[i] for i in range(N - 1)]
B.append(A[0] + K - A[N - 1])
print((sum(B) - max(B)))
| k, n = list(map(int, input().split()))
(*A,) = list(map(int, input().split()))
B = []
for i in range(1, n):
B.append(A[i] - A[i - 1])
B.append(k - sum(B))
print((k - max(B)))
| false | 28.571429 | [
"-K, N = list(map(int, input().split()))",
"+k, n = list(map(int, input().split()))",
"-B = [A[i + 1] - A[i] for i in range(N - 1)]",
"-B.append(A[0] + K - A[N - 1])",
"-print((sum(B) - max(B)))",
"+B = []",
"+for i in range(1, n):",
"+ B.append(A[i] - A[i - 1])",
"+B.append(k - sum(B))",
"+print((k - max(B)))"
] | false | 0.03869 | 0.041989 | 0.921429 | [
"s354088899",
"s911302705"
] |
u234091409 | p03835 | python | s115549879 | s946979947 | 211 | 183 | 40,048 | 39,152 | Accepted | Accepted | 13.27 | def resolve():
K, S = list(map(int, input().split()))
count = 0
for x in range(K + 1):
for y in range(K + 1):
if S - K <= x + y <= S and max(x, y) <= K:
count += 1
print(count)
if __name__ == "__main__":
resolve() | def resolve():
K, S = list(map(int, input().split()))
count = 0
for x in range(K + 1):
for y in range(max(0, S - K - x), min(K + 1, S - x + 1)):
count += 1
print(count)
if __name__ == "__main__":
resolve() | 12 | 11 | 276 | 251 | def resolve():
K, S = list(map(int, input().split()))
count = 0
for x in range(K + 1):
for y in range(K + 1):
if S - K <= x + y <= S and max(x, y) <= K:
count += 1
print(count)
if __name__ == "__main__":
resolve()
| def resolve():
K, S = list(map(int, input().split()))
count = 0
for x in range(K + 1):
for y in range(max(0, S - K - x), min(K + 1, S - x + 1)):
count += 1
print(count)
if __name__ == "__main__":
resolve()
| false | 8.333333 | [
"- for y in range(K + 1):",
"- if S - K <= x + y <= S and max(x, y) <= K:",
"- count += 1",
"+ for y in range(max(0, S - K - x), min(K + 1, S - x + 1)):",
"+ count += 1"
] | false | 0.036434 | 0.058694 | 0.620749 | [
"s115549879",
"s946979947"
] |
u226108478 | p03486 | python | s733414837 | s745816821 | 19 | 17 | 2,940 | 2,940 | Accepted | Accepted | 10.53 | # -*- coding: utf-8 -*-
# AtCoder Beginner Contest
# Problem B
if __name__ == '__main__':
s = sorted(list(eval(input())))
t = sorted(list(eval(input())), reverse=True)
if s < t:
print('Yes')
else:
print('No')
| # -*- coding: utf-8 -*-
def main():
s = sorted(eval(input()))
t = sorted(eval(input()), reverse=True)
if s < t:
print('Yes')
else:
print('No')
if __name__ == '__main__':
main()
| 14 | 15 | 246 | 220 | # -*- coding: utf-8 -*-
# AtCoder Beginner Contest
# Problem B
if __name__ == "__main__":
s = sorted(list(eval(input())))
t = sorted(list(eval(input())), reverse=True)
if s < t:
print("Yes")
else:
print("No")
| # -*- coding: utf-8 -*-
def main():
s = sorted(eval(input()))
t = sorted(eval(input()), reverse=True)
if s < t:
print("Yes")
else:
print("No")
if __name__ == "__main__":
main()
| false | 6.666667 | [
"-# AtCoder Beginner Contest",
"-# Problem B",
"-if __name__ == \"__main__\":",
"- s = sorted(list(eval(input())))",
"- t = sorted(list(eval(input())), reverse=True)",
"+def main():",
"+ s = sorted(eval(input()))",
"+ t = sorted(eval(input()), reverse=True)",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ main()"
] | false | 0.046848 | 0.040879 | 1.146 | [
"s733414837",
"s745816821"
] |
u225388820 | p04030 | python | s089616312 | s247606891 | 178 | 18 | 38,384 | 2,940 | Accepted | Accepted | 89.89 | s=eval(input())
t=""
for i in range(len(s)):
if s[i]=='B':
if t!="":
t=t[:len(t)-1]
else:
t+=s[i]
print(t)
| s=input()
t=[]
for i in s:
if i=="0":
t.append(0)
elif i=="1":
t.append(1)
else:
if len(t)>0:
t.pop(-1)
print(*t,sep="")
| 9 | 11 | 145 | 178 | s = eval(input())
t = ""
for i in range(len(s)):
if s[i] == "B":
if t != "":
t = t[: len(t) - 1]
else:
t += s[i]
print(t)
| s = input()
t = []
for i in s:
if i == "0":
t.append(0)
elif i == "1":
t.append(1)
else:
if len(t) > 0:
t.pop(-1)
print(*t, sep="")
| false | 18.181818 | [
"-s = eval(input())",
"-t = \"\"",
"-for i in range(len(s)):",
"- if s[i] == \"B\":",
"- if t != \"\":",
"- t = t[: len(t) - 1]",
"+s = input()",
"+t = []",
"+for i in s:",
"+ if i == \"0\":",
"+ t.append(0)",
"+ elif i == \"1\":",
"+ t.append(1)",
"- t += s[i]",
"-print(t)",
"+ if len(t) > 0:",
"+ t.pop(-1)",
"+print(*t, sep=\"\")"
] | false | 0.038926 | 0.037394 | 1.040966 | [
"s089616312",
"s247606891"
] |
u021019433 | p02803 | python | s870522931 | s247578605 | 585 | 535 | 3,444 | 3,316 | Accepted | Accepted | 8.55 | from collections import deque
h, w = list(map(int, input().split()))
a = ['#' * (w + 2)] * 2
a[1: 1] = ('#' + eval(input()) + '#' for _ in range(h))
r = 0
for i in range(1, h + 1):
for j in range(1, w + 1):
if a[i][j] == '.':
b = list(map(list, a))
q = deque()
b[i][j] = 0
q.append((i, j))
while(q):
i, j = q.popleft()
r = max(r, b[i][j])
d = 0
for i1 in range(i - 1, i + 2):
for j1 in range(j - d, j + 2, 2):
if b[i1][j1] == '.':
b[i1][j1] = b[i][j] + 1
q.append((i1, j1))
d ^= 1
print(r)
| from collections import deque
h, w = list(map(int, input().split()))
a = ['#' * (w + 2)] * 2
a[1: 1] = ['#' + eval(input()) + '#' for _ in range(h)]
r = 0
for i in range(1, h + 1):
for j in range(1, w + 1):
if a[i][j] == '.':
b = list(map(list, a))
q = deque()
b[i][j] = 0
q.append((i, j))
while(q):
i, j = q.popleft()
r = max(r, b[i][j])
d = 0
for i1 in range(i - 1, i + 2):
for j1 in range(j - d, j + 2, 2):
if b[i1][j1] == '.':
b[i1][j1] = b[i][j] + 1
q.append((i1, j1))
d ^= 1
print(r)
| 24 | 24 | 647 | 647 | from collections import deque
h, w = list(map(int, input().split()))
a = ["#" * (w + 2)] * 2
a[1:1] = ("#" + eval(input()) + "#" for _ in range(h))
r = 0
for i in range(1, h + 1):
for j in range(1, w + 1):
if a[i][j] == ".":
b = list(map(list, a))
q = deque()
b[i][j] = 0
q.append((i, j))
while q:
i, j = q.popleft()
r = max(r, b[i][j])
d = 0
for i1 in range(i - 1, i + 2):
for j1 in range(j - d, j + 2, 2):
if b[i1][j1] == ".":
b[i1][j1] = b[i][j] + 1
q.append((i1, j1))
d ^= 1
print(r)
| from collections import deque
h, w = list(map(int, input().split()))
a = ["#" * (w + 2)] * 2
a[1:1] = ["#" + eval(input()) + "#" for _ in range(h)]
r = 0
for i in range(1, h + 1):
for j in range(1, w + 1):
if a[i][j] == ".":
b = list(map(list, a))
q = deque()
b[i][j] = 0
q.append((i, j))
while q:
i, j = q.popleft()
r = max(r, b[i][j])
d = 0
for i1 in range(i - 1, i + 2):
for j1 in range(j - d, j + 2, 2):
if b[i1][j1] == ".":
b[i1][j1] = b[i][j] + 1
q.append((i1, j1))
d ^= 1
print(r)
| false | 0 | [
"-a[1:1] = (\"#\" + eval(input()) + \"#\" for _ in range(h))",
"+a[1:1] = [\"#\" + eval(input()) + \"#\" for _ in range(h)]"
] | false | 0.047594 | 0.04742 | 1.003672 | [
"s870522931",
"s247578605"
] |
u695857481 | p03127 | python | s111580367 | s114995767 | 809 | 71 | 14,252 | 14,252 | Accepted | Accepted | 91.22 | n = int(eval(input()))
mon = list(map(int, input().split()))
g = min(mon)
div = []
for i in range(1, g + 1):
if (g % i == 0):
div.append(i)
div.append(g // i)
if (i * i > g):
break
div.sort(reverse=True)
for d in div:
mod = []
for m in mon:
mod.append(m % d)
if (list(set(mod)) == [0]):
print(d)
break | def gcd(x, y):
while(y):
x, y = y, x % y
return x
n = int(eval(input()))
mon = list(map(int, input().split()))
g = mon[0]
for i in range(1, n):
g = gcd(g, mon[i])
print(g) | 18 | 10 | 346 | 184 | n = int(eval(input()))
mon = list(map(int, input().split()))
g = min(mon)
div = []
for i in range(1, g + 1):
if g % i == 0:
div.append(i)
div.append(g // i)
if i * i > g:
break
div.sort(reverse=True)
for d in div:
mod = []
for m in mon:
mod.append(m % d)
if list(set(mod)) == [0]:
print(d)
break
| def gcd(x, y):
while y:
x, y = y, x % y
return x
n = int(eval(input()))
mon = list(map(int, input().split()))
g = mon[0]
for i in range(1, n):
g = gcd(g, mon[i])
print(g)
| false | 44.444444 | [
"+def gcd(x, y):",
"+ while y:",
"+ x, y = y, x % y",
"+ return x",
"+",
"+",
"-g = min(mon)",
"-div = []",
"-for i in range(1, g + 1):",
"- if g % i == 0:",
"- div.append(i)",
"- div.append(g // i)",
"- if i * i > g:",
"- break",
"-div.sort(reverse=True)",
"-for d in div:",
"- mod = []",
"- for m in mon:",
"- mod.append(m % d)",
"- if list(set(mod)) == [0]:",
"- print(d)",
"- break",
"+g = mon[0]",
"+for i in range(1, n):",
"+ g = gcd(g, mon[i])",
"+print(g)"
] | false | 0.038432 | 0.051958 | 0.739667 | [
"s111580367",
"s114995767"
] |
u076917070 | p02918 | python | s899357089 | s208591284 | 99 | 42 | 14,068 | 3,316 | Accepted | Accepted | 57.58 | import sys
input=sys.stdin.readline
def runLength(s):
a = []
for c in s:
if len(a)==0 or a[-1][0]!=c:
a.append([c,1])
else:
a[-1][1] += 1
return a
def main():
N,K = list(map(int, input().split()))
S = input().strip()
ans = 0
for i,c in enumerate(S):
if c == "L":
if i > 0 and S[i-1] == "L":
ans += 1
if c == "R":
if i < N-1 and S[i+1] == "R":
ans += 1
A = runLength(S)
A.sort(key=lambda x:x[1], reverse=True)
for i in range(K):
if i < len(A):
ans += 2
if ans >= N:
break
if ans >= N:
ans = N-1
print(ans)
if __name__ == '__main__':
main() | import sys
input=sys.stdin.readline
def main():
N,K = list(map(int, input().split()))
S = input().strip()
ans = 0
for i,c in enumerate(S):
if c == "L":
if i > 0 and S[i-1] == "L":
ans += 1
if c == "R":
if i < N-1 and S[i+1] == "R":
ans += 1
ans += K*2
if ans >= N:
ans = N-1
print(ans)
if __name__ == '__main__':
main()
| 36 | 21 | 790 | 448 | import sys
input = sys.stdin.readline
def runLength(s):
a = []
for c in s:
if len(a) == 0 or a[-1][0] != c:
a.append([c, 1])
else:
a[-1][1] += 1
return a
def main():
N, K = list(map(int, input().split()))
S = input().strip()
ans = 0
for i, c in enumerate(S):
if c == "L":
if i > 0 and S[i - 1] == "L":
ans += 1
if c == "R":
if i < N - 1 and S[i + 1] == "R":
ans += 1
A = runLength(S)
A.sort(key=lambda x: x[1], reverse=True)
for i in range(K):
if i < len(A):
ans += 2
if ans >= N:
break
if ans >= N:
ans = N - 1
print(ans)
if __name__ == "__main__":
main()
| import sys
input = sys.stdin.readline
def main():
N, K = list(map(int, input().split()))
S = input().strip()
ans = 0
for i, c in enumerate(S):
if c == "L":
if i > 0 and S[i - 1] == "L":
ans += 1
if c == "R":
if i < N - 1 and S[i + 1] == "R":
ans += 1
ans += K * 2
if ans >= N:
ans = N - 1
print(ans)
if __name__ == "__main__":
main()
| false | 41.666667 | [
"-",
"-",
"-def runLength(s):",
"- a = []",
"- for c in s:",
"- if len(a) == 0 or a[-1][0] != c:",
"- a.append([c, 1])",
"- else:",
"- a[-1][1] += 1",
"- return a",
"- A = runLength(S)",
"- A.sort(key=lambda x: x[1], reverse=True)",
"- for i in range(K):",
"- if i < len(A):",
"- ans += 2",
"- if ans >= N:",
"- break",
"+ ans += K * 2"
] | false | 0.047461 | 0.038322 | 1.238497 | [
"s899357089",
"s208591284"
] |
u562935282 | p03111 | python | s999299947 | s896884770 | 813 | 77 | 3,064 | 3,064 | Accepted | Accepted | 90.53 | N, A, B, C = list(map(int, input().split()))
l = [int(eval(input())) for _ in range(N)]
l = list(sorted(l))
tar = []
for x in C, B, A:
if x in l:
l.remove(x)
else:
tar.append(x)
if not tar:
print((0))
exit()
ans = float('inf')
for j in range((len(tar) + 1) ** len(l)):
vvv = [[] for _ in range(len(tar) + 1)]
for i in sorted(list(range(len(l))), reverse=True):
idx, j = divmod(j, (len(tar) + 1) ** i)
vvv[idx].append(l[i])
if any(len(vvvv) == 0 for vvvv in vvv[:-1]):
continue
else:
bbb = 0
# print(tar, vvv)
for k in range(len(tar)):
bbb += 10 * (len(vvv[k]) - 1)
bbb += abs(sum(vvv[k]) - tar[k])
ans = min(ans, bbb)
print(ans)
| N, A, B, C = list(map(int, input().split()))
l = [int(eval(input())) for _ in range(N)]
INF = float('inf')
def dfs(cur, a, b, c):
if cur == N:
return abs(a - A) + abs(b - B) + abs(c - C) - 30 if min(a, b, c) > 0 else INF
# A,B,Cに使用する材料を合成し、目的の長さの差を加算（必要なMP）
# ret1-3で一つ目の材料にも合成魔法のMP10を要求しているので、A,B,Cの初回加算合わせて3回分のMP30を減算
# a,b,cのいずれかが0のとき、材料が1つも宛がわれていない竹が存在するため、不適（必要MPをINFとして解にならないようにする）
ret0 = dfs(cur + 1, a, b, c)
ret1 = dfs(cur + 1, a + l[cur], b, c) + 10
ret2 = dfs(cur + 1, a, b + l[cur], c) + 10
ret3 = dfs(cur + 1, a, b, c + l[cur]) + 10
return min(ret0, ret1, ret2, ret3)
# l[cur]について、使用しないか、(A,B,C)のいずれかに使用の4分岐
print((dfs(0, 0, 0, 0)))
| 32 | 20 | 772 | 715 | N, A, B, C = list(map(int, input().split()))
l = [int(eval(input())) for _ in range(N)]
l = list(sorted(l))
tar = []
for x in C, B, A:
if x in l:
l.remove(x)
else:
tar.append(x)
if not tar:
print((0))
exit()
ans = float("inf")
for j in range((len(tar) + 1) ** len(l)):
vvv = [[] for _ in range(len(tar) + 1)]
for i in sorted(list(range(len(l))), reverse=True):
idx, j = divmod(j, (len(tar) + 1) ** i)
vvv[idx].append(l[i])
if any(len(vvvv) == 0 for vvvv in vvv[:-1]):
continue
else:
bbb = 0
# print(tar, vvv)
for k in range(len(tar)):
bbb += 10 * (len(vvv[k]) - 1)
bbb += abs(sum(vvv[k]) - tar[k])
ans = min(ans, bbb)
print(ans)
| N, A, B, C = list(map(int, input().split()))
l = [int(eval(input())) for _ in range(N)]
INF = float("inf")
def dfs(cur, a, b, c):
if cur == N:
return abs(a - A) + abs(b - B) + abs(c - C) - 30 if min(a, b, c) > 0 else INF
# A,B,Cに使用する材料を合成し、目的の長さの差を加算（必要なMP）
# ret1-3で一つ目の材料にも合成魔法のMP10を要求しているので、A,B,Cの初回加算合わせて3回分のMP30を減算
# a,b,cのいずれかが0のとき、材料が1つも宛がわれていない竹が存在するため、不適（必要MPをINFとして解にならないようにする）
ret0 = dfs(cur + 1, a, b, c)
ret1 = dfs(cur + 1, a + l[cur], b, c) + 10
ret2 = dfs(cur + 1, a, b + l[cur], c) + 10
ret3 = dfs(cur + 1, a, b, c + l[cur]) + 10
return min(ret0, ret1, ret2, ret3)
# l[cur]について、使用しないか、(A,B,C)のいずれかに使用の4分岐
print((dfs(0, 0, 0, 0)))
| false | 37.5 | [
"-l = list(sorted(l))",
"-tar = []",
"-for x in C, B, A:",
"- if x in l:",
"- l.remove(x)",
"- else:",
"- tar.append(x)",
"-if not tar:",
"- print((0))",
"- exit()",
"-ans = float(\"inf\")",
"-for j in range((len(tar) + 1) ** len(l)):",
"- vvv = [[] for _ in range(len(tar) + 1)]",
"- for i in sorted(list(range(len(l))), reverse=True):",
"- idx, j = divmod(j, (len(tar) + 1) ** i)",
"- vvv[idx].append(l[i])",
"- if any(len(vvvv) == 0 for vvvv in vvv[:-1]):",
"- continue",
"- else:",
"- bbb = 0",
"- # print(tar, vvv)",
"- for k in range(len(tar)):",
"- bbb += 10 * (len(vvv[k]) - 1)",
"- bbb += abs(sum(vvv[k]) - tar[k])",
"- ans = min(ans, bbb)",
"-print(ans)",
"+INF = float(\"inf\")",
"+",
"+",
"+def dfs(cur, a, b, c):",
"+ if cur == N:",
"+ return abs(a - A) + abs(b - B) + abs(c - C) - 30 if min(a, b, c) > 0 else INF",
"+ # A,B,Cに使用する材料を合成し、目的の長さの差を加算（必要なMP）",
"+ # ret1-3で一つ目の材料にも合成魔法のMP10を要求しているので、A,B,Cの初回加算合わせて3回分のMP30を減算",
"+ # a,b,cのいずれかが0のとき、材料が1つも宛がわれていない竹が存在するため、不適（必要MPをINFとして解にならないようにする）",
"+ ret0 = dfs(cur + 1, a, b, c)",
"+ ret1 = dfs(cur + 1, a + l[cur], b, c) + 10",
"+ ret2 = dfs(cur + 1, a, b + l[cur], c) + 10",
"+ ret3 = dfs(cur + 1, a, b, c + l[cur]) + 10",
"+ return min(ret0, ret1, ret2, ret3)",
"+ # l[cur]について、使用しないか、(A,B,C)のいずれかに使用の4分岐",
"+",
"+",
"+print((dfs(0, 0, 0, 0)))"
] | false | 0.354002 | 0.061489 | 5.757135 | [
"s999299947",
"s896884770"
] |
u072053884 | p02238 | python | s521337924 | s936101836 | 20 | 10 | 7,772 | 7,748 | Accepted | Accepted | 50 | n = int(eval(input()))
adj = [None]
for i in range(n):
adj_i = list(map(int, input().split()[2:]))
adj.append(adj_i)
# searched or not, number of vertex, discovery time and finishing time.
sndf = [None]
for i in range(1, n + 1):
sndf.append([False, i])
path = []
time = 0
def dfs(u):
global time
sndf[u][0] = True
time += 1
sndf[u].append(time)
for v in adj[u]:
if not sndf[v][0]:
dfs(v)
sndf[u][0] = True
time += 1
sndf[u].append(time)
for i in range(1, n + 1):
if not sndf[i][0]:
dfs(i)
for x in sndf[1:]:
print((*x[1:])) | n = int(eval(input()))
adj = [None]
for i in range(n):
adj_i = list(map(int, input().split()[2:]))
adj.append(adj_i)
# searched or not, number of vertex, discovery time and finishing time.
sndf = [None]
for i in range(1, n + 1):
sndf.append([False, i])
path = []
time = 0
def dfs(u):
global time
sndf[u][0] = True
time += 1
sndf[u].append(time)
for v in adj[u]:
if not sndf[v][0]:
dfs(v)
time += 1
sndf[u].append(time)
for i in range(1, n + 1):
if not sndf[i][0]:
dfs(i)
for x in sndf[1:]:
print((*x[1:])) | 36 | 35 | 639 | 616 | n = int(eval(input()))
adj = [None]
for i in range(n):
adj_i = list(map(int, input().split()[2:]))
adj.append(adj_i)
# searched or not, number of vertex, discovery time and finishing time.
sndf = [None]
for i in range(1, n + 1):
sndf.append([False, i])
path = []
time = 0
def dfs(u):
global time
sndf[u][0] = True
time += 1
sndf[u].append(time)
for v in adj[u]:
if not sndf[v][0]:
dfs(v)
sndf[u][0] = True
time += 1
sndf[u].append(time)
for i in range(1, n + 1):
if not sndf[i][0]:
dfs(i)
for x in sndf[1:]:
print((*x[1:]))
| n = int(eval(input()))
adj = [None]
for i in range(n):
adj_i = list(map(int, input().split()[2:]))
adj.append(adj_i)
# searched or not, number of vertex, discovery time and finishing time.
sndf = [None]
for i in range(1, n + 1):
sndf.append([False, i])
path = []
time = 0
def dfs(u):
global time
sndf[u][0] = True
time += 1
sndf[u].append(time)
for v in adj[u]:
if not sndf[v][0]:
dfs(v)
time += 1
sndf[u].append(time)
for i in range(1, n + 1):
if not sndf[i][0]:
dfs(i)
for x in sndf[1:]:
print((*x[1:]))
| false | 2.777778 | [
"- sndf[u][0] = True"
] | false | 0.144965 | 0.047421 | 3.057 | [
"s521337924",
"s936101836"
] |
u047393579 | p03457 | python | s929081177 | s162876714 | 1,806 | 388 | 3,064 | 3,064 | Accepted | Accepted | 78.52 | N = int(eval(input()))
pre_t = 0
pre_x = 0
pre_y = 0
count = 0
for _ in range(N):
flag = False
t, x, y = list(map(int, input().split()))
for a in range(t - pre_t + 1):
b = pre_x - x + a
if b >= 0:
for c in range(t - pre_t + 1 - a - b):
d = t - pre_t - a - b - c
if pre_y + c - d == y:
count += 1
flag = True
break
if flag:
break
pre_t = t
pre_x = x
pre_y = y
if count == N:
print("Yes")
else:
print("No") | N = int(eval(input()))
pre_t = 0
pre_x = 0
pre_y = 0
count = 0
for _ in range(N):
t, x, y = list(map(int, input().split()))
if x > pre_x:
a = x - pre_x
b = 0
else:
b = pre_x - x
a = 0
if y > pre_y:
c = y - pre_y
d = 0
else:
d = pre_y - y
c = 0
total = a+b+c+d
if t - pre_t >= total and (t - pre_t - total) % 2 == 0:
count += 1
pre_t = t
pre_x = x
pre_y = y
if count == N:
print("Yes")
else:
print("No") | 26 | 29 | 590 | 538 | N = int(eval(input()))
pre_t = 0
pre_x = 0
pre_y = 0
count = 0
for _ in range(N):
flag = False
t, x, y = list(map(int, input().split()))
for a in range(t - pre_t + 1):
b = pre_x - x + a
if b >= 0:
for c in range(t - pre_t + 1 - a - b):
d = t - pre_t - a - b - c
if pre_y + c - d == y:
count += 1
flag = True
break
if flag:
break
pre_t = t
pre_x = x
pre_y = y
if count == N:
print("Yes")
else:
print("No")
| N = int(eval(input()))
pre_t = 0
pre_x = 0
pre_y = 0
count = 0
for _ in range(N):
t, x, y = list(map(int, input().split()))
if x > pre_x:
a = x - pre_x
b = 0
else:
b = pre_x - x
a = 0
if y > pre_y:
c = y - pre_y
d = 0
else:
d = pre_y - y
c = 0
total = a + b + c + d
if t - pre_t >= total and (t - pre_t - total) % 2 == 0:
count += 1
pre_t = t
pre_x = x
pre_y = y
if count == N:
print("Yes")
else:
print("No")
| false | 10.344828 | [
"- flag = False",
"- for a in range(t - pre_t + 1):",
"- b = pre_x - x + a",
"- if b >= 0:",
"- for c in range(t - pre_t + 1 - a - b):",
"- d = t - pre_t - a - b - c",
"- if pre_y + c - d == y:",
"- count += 1",
"- flag = True",
"- break",
"- if flag:",
"- break",
"+ if x > pre_x:",
"+ a = x - pre_x",
"+ b = 0",
"+ else:",
"+ b = pre_x - x",
"+ a = 0",
"+ if y > pre_y:",
"+ c = y - pre_y",
"+ d = 0",
"+ else:",
"+ d = pre_y - y",
"+ c = 0",
"+ total = a + b + c + d",
"+ if t - pre_t >= total and (t - pre_t - total) % 2 == 0:",
"+ count += 1"
] | false | 0.041087 | 0.042516 | 0.966392 | [
"s929081177",
"s162876714"
] |
u620084012 | p03038 | python | s078957516 | s060319039 | 814 | 533 | 81,516 | 36,828 | Accepted | Accepted | 34.52 | N, M = list(map(int,input().split()))
A = sorted(list(map(int,input().split())))
L = []
for k in range(M):
B, C = list(map(int,input().split()))
L.append([B,C])
L = sorted(L,key=lambda x: -x[1])
ans = 0
i = 0
for k in range(N):
if i < M:
if A[k] < L[i][1]:
L[i][0] -= 1
ans += L[i][1]
if L[i][0] == 0:
i += 1
else:
ans += A[k]
else:
ans += A[k]
print(ans)
| N, M = list(map(int,input().split()))
A = sorted(list(map(int,input().split())))
D = [list(map(int,input().split())) for k in range(M)]
D = sorted(D, key = lambda x: -x[1])
D.append([10**9+1,-1])
t = 0
ans = 0
for k in range(N):
if A[k] < D[t][1]:
ans += D[t][1]
D[t][0] -= 1
if D[t][0] == 0:
t += 1
else:
ans += A[k]
print(ans)
| 21 | 17 | 468 | 392 | N, M = list(map(int, input().split()))
A = sorted(list(map(int, input().split())))
L = []
for k in range(M):
B, C = list(map(int, input().split()))
L.append([B, C])
L = sorted(L, key=lambda x: -x[1])
ans = 0
i = 0
for k in range(N):
if i < M:
if A[k] < L[i][1]:
L[i][0] -= 1
ans += L[i][1]
if L[i][0] == 0:
i += 1
else:
ans += A[k]
else:
ans += A[k]
print(ans)
| N, M = list(map(int, input().split()))
A = sorted(list(map(int, input().split())))
D = [list(map(int, input().split())) for k in range(M)]
D = sorted(D, key=lambda x: -x[1])
D.append([10**9 + 1, -1])
t = 0
ans = 0
for k in range(N):
if A[k] < D[t][1]:
ans += D[t][1]
D[t][0] -= 1
if D[t][0] == 0:
t += 1
else:
ans += A[k]
print(ans)
| false | 19.047619 | [
"-L = []",
"-for k in range(M):",
"- B, C = list(map(int, input().split()))",
"- L.append([B, C])",
"-L = sorted(L, key=lambda x: -x[1])",
"+D = [list(map(int, input().split())) for k in range(M)]",
"+D = sorted(D, key=lambda x: -x[1])",
"+D.append([10**9 + 1, -1])",
"+t = 0",
"-i = 0",
"- if i < M:",
"- if A[k] < L[i][1]:",
"- L[i][0] -= 1",
"- ans += L[i][1]",
"- if L[i][0] == 0:",
"- i += 1",
"- else:",
"- ans += A[k]",
"+ if A[k] < D[t][1]:",
"+ ans += D[t][1]",
"+ D[t][0] -= 1",
"+ if D[t][0] == 0:",
"+ t += 1"
] | false | 0.0437 | 0.044641 | 0.978937 | [
"s078957516",
"s060319039"
] |
u604774382 | p02390 | python | s850711002 | s054963295 | 30 | 20 | 6,736 | 4,192 | Accepted | Accepted | 33.33 | #coding:utf-8
S=int( eval(input()) )
h=int( S/3600)
S=int( S%3600)
m=int( S/60)
s=int( S%60)
print(( "{}:{}:{}".format( h, m, s ) )) | import sys
x = int( sys.stdin.readline() )
h = x//3600
m = ( x%3600 )//60
s = ( x%3600 )%60
print(( "{}:{}:{}".format( h, m, s) )) | 7 | 7 | 130 | 135 | # coding:utf-8
S = int(eval(input()))
h = int(S / 3600)
S = int(S % 3600)
m = int(S / 60)
s = int(S % 60)
print(("{}:{}:{}".format(h, m, s)))
| import sys
x = int(sys.stdin.readline())
h = x // 3600
m = (x % 3600) // 60
s = (x % 3600) % 60
print(("{}:{}:{}".format(h, m, s)))
| false | 0 | [
"-# coding:utf-8",
"-S = int(eval(input()))",
"-h = int(S / 3600)",
"-S = int(S % 3600)",
"-m = int(S / 60)",
"-s = int(S % 60)",
"+import sys",
"+",
"+x = int(sys.stdin.readline())",
"+h = x // 3600",
"+m = (x % 3600) // 60",
"+s = (x % 3600) % 60"
] | false | 0.108866 | 0.040284 | 2.702454 | [
"s850711002",
"s054963295"
] |
u102461423 | p02821 | python | s415497404 | s968894067 | 323 | 192 | 18,236 | 30,976 | Accepted | Accepted | 40.56 | import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
# 価値 x 以上の握手を全て行うとする
# 握手回数が決まる。左手ごとに集計できる。
import numpy as np
N,M = list(map(int,readline().split()))
A = np.array(read().split(),np.int64)
A.sort()
def shake_cnt(x):
# x 以上の握手を全て行うとして、握手の回数を数える
# 行わない握手を数える
X = np.searchsorted(A,x-A)
return N * N - X.sum()
left = 0 # 握手の回数がM以上
right = 10 ** 6 # 握手の回数がM未満
while left + 1 < right:
x = (left + right) // 2
if shake_cnt(x) >= M:
left = x
else:
right = x
left,right
# right 以上の握手を全て行ったとして、回数と総和を計算
X = np.searchsorted(A,right-A) # 行わない人数
Acum = np.zeros(N+1,np.int64) # 人数 -> 累積和
Acum[1:] = np.cumsum(A)
shake = N * N - X.sum()
happy = (Acum[-1] - Acum[X]).sum() + (A * (N - X)).sum()
happy += (M - shake) *left
print(happy) | import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
import numpy as np
N,M = list(map(int,readline().split()))
A = np.array(read().split(),np.int64)
f = np.bincount(A)
fft_len = 1<<18
fft = np.fft.rfft; ifft = np.fft.irfft
Ff = fft(f,fft_len)
G = np.rint(ifft(Ff * Ff,fft_len)).astype(np.int64) # 和 -> 何通りか
Gcum = G.cumsum()
remove_cnt = N * N - M
i = np.searchsorted(Gcum,remove_cnt)
# i未満は全部除外。ちょうどiのものもいくつか除外
x = remove_cnt - Gcum[i-1]
remove_sum = (G[:i] * np.arange(i,dtype=np.int64)).sum() + i * x
answer = A.sum() * 2 * N - remove_sum
print(answer) | 43 | 27 | 879 | 646 | import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
# 価値 x 以上の握手を全て行うとする
# 握手回数が決まる。左手ごとに集計できる。
import numpy as np
N, M = list(map(int, readline().split()))
A = np.array(read().split(), np.int64)
A.sort()
def shake_cnt(x):
# x 以上の握手を全て行うとして、握手の回数を数える
# 行わない握手を数える
X = np.searchsorted(A, x - A)
return N * N - X.sum()
left = 0 # 握手の回数がM以上
right = 10**6 # 握手の回数がM未満
while left + 1 < right:
x = (left + right) // 2
if shake_cnt(x) >= M:
left = x
else:
right = x
left, right
# right 以上の握手を全て行ったとして、回数と総和を計算
X = np.searchsorted(A, right - A) # 行わない人数
Acum = np.zeros(N + 1, np.int64) # 人数 -> 累積和
Acum[1:] = np.cumsum(A)
shake = N * N - X.sum()
happy = (Acum[-1] - Acum[X]).sum() + (A * (N - X)).sum()
happy += (M - shake) * left
print(happy)
| import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
import numpy as np
N, M = list(map(int, readline().split()))
A = np.array(read().split(), np.int64)
f = np.bincount(A)
fft_len = 1 << 18
fft = np.fft.rfft
ifft = np.fft.irfft
Ff = fft(f, fft_len)
G = np.rint(ifft(Ff * Ff, fft_len)).astype(np.int64) # 和 -> 何通りか
Gcum = G.cumsum()
remove_cnt = N * N - M
i = np.searchsorted(Gcum, remove_cnt)
# i未満は全部除外。ちょうどiのものもいくつか除外
x = remove_cnt - Gcum[i - 1]
remove_sum = (G[:i] * np.arange(i, dtype=np.int64)).sum() + i * x
answer = A.sum() * 2 * N - remove_sum
print(answer)
| false | 37.209302 | [
"-# 価値 x 以上の握手を全て行うとする",
"-# 握手回数が決まる。左手ごとに集計できる。",
"-A.sort()",
"-",
"-",
"-def shake_cnt(x):",
"- # x 以上の握手を全て行うとして、握手の回数を数える",
"- # 行わない握手を数える",
"- X = np.searchsorted(A, x - A)",
"- return N * N - X.sum()",
"-",
"-",
"-left = 0 # 握手の回数がM以上",
"-right = 10**6 # 握手の回数がM未満",
"-while left + 1 < right:",
"- x = (left + right) // 2",
"- if shake_cnt(x) >= M:",
"- left = x",
"- else:",
"- right = x",
"-left, right",
"-# right 以上の握手を全て行ったとして、回数と総和を計算",
"-X = np.searchsorted(A, right - A) # 行わない人数",
"-Acum = np.zeros(N + 1, np.int64) # 人数 -> 累積和",
"-Acum[1:] = np.cumsum(A)",
"-shake = N * N - X.sum()",
"-happy = (Acum[-1] - Acum[X]).sum() + (A * (N - X)).sum()",
"-happy += (M - shake) * left",
"-print(happy)",
"+f = np.bincount(A)",
"+fft_len = 1 << 18",
"+fft = np.fft.rfft",
"+ifft = np.fft.irfft",
"+Ff = fft(f, fft_len)",
"+G = np.rint(ifft(Ff * Ff, fft_len)).astype(np.int64) # 和 -> 何通りか",
"+Gcum = G.cumsum()",
"+remove_cnt = N * N - M",
"+i = np.searchsorted(Gcum, remove_cnt)",
"+# i未満は全部除外。ちょうどiのものもいくつか除外",
"+x = remove_cnt - Gcum[i - 1]",
"+remove_sum = (G[:i] * np.arange(i, dtype=np.int64)).sum() + i * x",
"+answer = A.sum() * 2 * N - remove_sum",
"+print(answer)"
] | false | 0.2971 | 0.349745 | 0.849477 | [
"s415497404",
"s968894067"
] |
u160224209 | p02641 | python | s022337671 | s424638933 | 62 | 35 | 62,068 | 9,056 | Accepted | Accepted | 43.55 | x,n = list(map(int,input().split()))
p = list(map(int,input().split()))
p.sort()
li = []
ans = []
Min_sa = 9999999999
for i in range(-200,201):
if i not in p:
li.append(i)
for i in li:
Min_sa = min(Min_sa,abs(x-i))
for i in li:
if abs(x-i) == Min_sa:
ans.append(i)
print((min(ans))) | x, n = list(map(int, input().split()))
p = list(map(int, input().split()))
ans = 9999999999
lists = []
if n == 0:
print(x)
exit()
for i in range(-1000, 1000):
if not i in p:
lists.append(i)
for i in lists:
if ans > abs(x - i):
ans = abs(x-i)
m = i
print(m)
| 15 | 16 | 317 | 307 | x, n = list(map(int, input().split()))
p = list(map(int, input().split()))
p.sort()
li = []
ans = []
Min_sa = 9999999999
for i in range(-200, 201):
if i not in p:
li.append(i)
for i in li:
Min_sa = min(Min_sa, abs(x - i))
for i in li:
if abs(x - i) == Min_sa:
ans.append(i)
print((min(ans)))
| x, n = list(map(int, input().split()))
p = list(map(int, input().split()))
ans = 9999999999
lists = []
if n == 0:
print(x)
exit()
for i in range(-1000, 1000):
if not i in p:
lists.append(i)
for i in lists:
if ans > abs(x - i):
ans = abs(x - i)
m = i
print(m)
| false | 6.25 | [
"-p.sort()",
"-li = []",
"-ans = []",
"-Min_sa = 9999999999",
"-for i in range(-200, 201):",
"- if i not in p:",
"- li.append(i)",
"-for i in li:",
"- Min_sa = min(Min_sa, abs(x - i))",
"-for i in li:",
"- if abs(x - i) == Min_sa:",
"- ans.append(i)",
"-print((min(ans)))",
"+ans = 9999999999",
"+lists = []",
"+if n == 0:",
"+ print(x)",
"+ exit()",
"+for i in range(-1000, 1000):",
"+ if not i in p:",
"+ lists.append(i)",
"+for i in lists:",
"+ if ans > abs(x - i):",
"+ ans = abs(x - i)",
"+ m = i",
"+print(m)"
] | false | 0.069941 | 0.044543 | 1.570195 | [
"s022337671",
"s424638933"
] |
u724732842 | p03472 | python | s127412081 | s393223474 | 772 | 532 | 35,768 | 26,192 | Accepted | Accepted | 31.09 | import math
N,H = list(map(int,input().split()))
data=[]
for i in range(N):
a,b = list(map(int,input().split()))
data.append([a,b,i])
s1 = sorted(data,key = lambda x:(-x[1],x[0]))
s2 = sorted(data,key = lambda x:(-x[0],x[1]))
cnt = 0
maxNum = s2[0][2]
for i in range(N):
if H > 0:
if s1[i][1] > s2[0][0]:
if s1[i][2] == maxNum:
continue
else:
H -= s1[i][1]
cnt += 1
else:
H -= s2[0][1]
cnt += 1
break
else:
print(cnt)
exit()
else:
H -= s2[0][1]
cnt += 1
if H > 0:
print((cnt + math.ceil(H/s2[0][0])))
else:
print(cnt) | import math
N,H = list(map(int,input().split()))
data=[]
for i in range(N):
a,b = list(map(int,input().split()))
data.append([a,b])
s1 = sorted(data,key = lambda x:-x[1])
s2 = sorted(data,key = lambda x:-x[0])
cnt = 0
for i in range(N):
if H > 0:
if s1[i][1] > s2[0][0]:
H -= s1[i][1]
cnt += 1
else:
break
else:
print(cnt)
exit()
if H > 0:
print((cnt + math.ceil(H/s2[0][0])))
else:
print(cnt)
| 38 | 31 | 742 | 541 | import math
N, H = list(map(int, input().split()))
data = []
for i in range(N):
a, b = list(map(int, input().split()))
data.append([a, b, i])
s1 = sorted(data, key=lambda x: (-x[1], x[0]))
s2 = sorted(data, key=lambda x: (-x[0], x[1]))
cnt = 0
maxNum = s2[0][2]
for i in range(N):
if H > 0:
if s1[i][1] > s2[0][0]:
if s1[i][2] == maxNum:
continue
else:
H -= s1[i][1]
cnt += 1
else:
H -= s2[0][1]
cnt += 1
break
else:
print(cnt)
exit()
else:
H -= s2[0][1]
cnt += 1
if H > 0:
print((cnt + math.ceil(H / s2[0][0])))
else:
print(cnt)
| import math
N, H = list(map(int, input().split()))
data = []
for i in range(N):
a, b = list(map(int, input().split()))
data.append([a, b])
s1 = sorted(data, key=lambda x: -x[1])
s2 = sorted(data, key=lambda x: -x[0])
cnt = 0
for i in range(N):
if H > 0:
if s1[i][1] > s2[0][0]:
H -= s1[i][1]
cnt += 1
else:
break
else:
print(cnt)
exit()
if H > 0:
print((cnt + math.ceil(H / s2[0][0])))
else:
print(cnt)
| false | 18.421053 | [
"- data.append([a, b, i])",
"-s1 = sorted(data, key=lambda x: (-x[1], x[0]))",
"-s2 = sorted(data, key=lambda x: (-x[0], x[1]))",
"+ data.append([a, b])",
"+s1 = sorted(data, key=lambda x: -x[1])",
"+s2 = sorted(data, key=lambda x: -x[0])",
"-maxNum = s2[0][2]",
"- if s1[i][2] == maxNum:",
"- continue",
"- else:",
"- H -= s1[i][1]",
"- cnt += 1",
"+ H -= s1[i][1]",
"+ cnt += 1",
"- H -= s2[0][1]",
"- cnt += 1",
"-else:",
"- H -= s2[0][1]",
"- cnt += 1"
] | false | 0.103585 | 0.111115 | 0.932226 | [
"s127412081",
"s393223474"
] |
u021019433 | p02768 | python | s863381995 | s171925314 | 126 | 109 | 3,060 | 3,060 | Accepted | Accepted | 13.49 | M = 10**9 + 7
n, a, b = list(map(int, input().split()))
r = pow(2, n, M) - 1
f = c = 1
for i in range(b):
f = f * (i + 1) % M
c = c * (n - i) % M
if i + 1 in (a, b):
r -= c * pow(f, M - 2, M)
print((r % M))
| M = 10**9 + 7
n, a, b = list(map(int, input().split()))
r = pow(2, n, M) - 1
f = c = 1
for i in range(b):
f = f * (i + 1) % M
c = c * (n - i) % M
if i + 1 == a:
a = b
r -= c * pow(f, M - 2, M)
print((r % M)) | 10 | 11 | 218 | 223 | M = 10**9 + 7
n, a, b = list(map(int, input().split()))
r = pow(2, n, M) - 1
f = c = 1
for i in range(b):
f = f * (i + 1) % M
c = c * (n - i) % M
if i + 1 in (a, b):
r -= c * pow(f, M - 2, M)
print((r % M))
| M = 10**9 + 7
n, a, b = list(map(int, input().split()))
r = pow(2, n, M) - 1
f = c = 1
for i in range(b):
f = f * (i + 1) % M
c = c * (n - i) % M
if i + 1 == a:
a = b
r -= c * pow(f, M - 2, M)
print((r % M))
| false | 9.090909 | [
"- if i + 1 in (a, b):",
"+ if i + 1 == a:",
"+ a = b"
] | false | 0.007308 | 0.110464 | 0.066159 | [
"s863381995",
"s171925314"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.