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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
u340781749 | p02889 | python | s104821957 | s583305643 | 1,117 | 665 | 76,636 | 34,888 | Accepted | Accepted | 40.47 | import sys
n, m, l = list(map(int, input().split()))
lines = sys.stdin.readlines()
INF = 10 ** 18
dists = [[INF] * n for _ in range(n)]
for i in range(n):
dists[i][i] = 0
for line in lines[:m]:
a, b, c = list(map(int, line.split()))
a -= 1
b -= 1
if c > l:
continue
dists[a][b] = c
dists[b][a] = c
for k in range(n):
dk = dists[k]
for i in range(n):
di = dists[i]
for j in range(n):
new_dist = di[k] + dk[j]
if new_dist > l:
continue
if di[j] > new_dist:
di[j] = new_dist
refuels = [[1 if dist < INF else INF for dist in row] for row in dists]
for k in range(n):
rk = refuels[k]
for i in range(n):
ri = refuels[i]
for j in range(n):
new_dist = ri[k] + rk[j]
if ri[j] > new_dist:
ri[j] = new_dist
buf = []
for line in lines[m + 1:]:
s, t = list(map(int, line.split()))
refuel = refuels[s - 1][t - 1]
buf.append(-1 if refuel == INF else refuel - 1)
print(('\n'.join(map(str, buf))))
| import sys
import numpy as np
from scipy.sparse import csr_matrix
from scipy.sparse.csgraph import floyd_warshall
n, m, l = list(map(int, input().split()))
lines = sys.stdin.readlines()
INF = 10 ** 18
dists = [[INF] * n for _ in range(n)]
for i in range(n):
dists[i][i] = 0
for line in lines[:m]:
a, b, c = list(map(int, line.split()))
a -= 1
b -= 1
if c > l:
continue
dists[a][b] = c
dists[b][a] = c
dists = floyd_warshall(csr_matrix(dists))
refuels = np.ones((n, n), dtype=np.int64)
refuels[dists > l] = INF
refuels = floyd_warshall(csr_matrix(refuels)).astype(np.int64)
refuels[refuels == INF] = 0
refuels -= 1
buf = []
for line in lines[m + 1:]:
s, t = list(map(int, line.split()))
buf.append(refuels[s - 1][t - 1])
print(('\n'.join(map(str, buf))))
| 50 | 38 | 1,130 | 830 | import sys
n, m, l = list(map(int, input().split()))
lines = sys.stdin.readlines()
INF = 10**18
dists = [[INF] * n for _ in range(n)]
for i in range(n):
dists[i][i] = 0
for line in lines[:m]:
a, b, c = list(map(int, line.split()))
a -= 1
b -= 1
if c > l:
continue
dists[a][b] = c
dists[b][a] = c
for k in range(n):
dk = dists[k]
for i in range(n):
di = dists[i]
for j in range(n):
new_dist = di[k] + dk[j]
if new_dist > l:
continue
if di[j] > new_dist:
di[j] = new_dist
refuels = [[1 if dist < INF else INF for dist in row] for row in dists]
for k in range(n):
rk = refuels[k]
for i in range(n):
ri = refuels[i]
for j in range(n):
new_dist = ri[k] + rk[j]
if ri[j] > new_dist:
ri[j] = new_dist
buf = []
for line in lines[m + 1 :]:
s, t = list(map(int, line.split()))
refuel = refuels[s - 1][t - 1]
buf.append(-1 if refuel == INF else refuel - 1)
print(("\n".join(map(str, buf))))
| import sys
import numpy as np
from scipy.sparse import csr_matrix
from scipy.sparse.csgraph import floyd_warshall
n, m, l = list(map(int, input().split()))
lines = sys.stdin.readlines()
INF = 10**18
dists = [[INF] * n for _ in range(n)]
for i in range(n):
dists[i][i] = 0
for line in lines[:m]:
a, b, c = list(map(int, line.split()))
a -= 1
b -= 1
if c > l:
continue
dists[a][b] = c
dists[b][a] = c
dists = floyd_warshall(csr_matrix(dists))
refuels = np.ones((n, n), dtype=np.int64)
refuels[dists > l] = INF
refuels = floyd_warshall(csr_matrix(refuels)).astype(np.int64)
refuels[refuels == INF] = 0
refuels -= 1
buf = []
for line in lines[m + 1 :]:
s, t = list(map(int, line.split()))
buf.append(refuels[s - 1][t - 1])
print(("\n".join(map(str, buf))))
| false | 24 | [
"+import numpy as np",
"+from scipy.sparse import csr_matrix",
"+from scipy.sparse.csgraph import floyd_warshall",
"-for k in range(n):",
"- dk = dists[k]",
"- for i in range(n):",
"- di = dists[i]",
"- for j in range(n):",
"- new_dist = di[k] + dk[j]",
"- if new_dist > l:",
"- continue",
"- if di[j] > new_dist:",
"- di[j] = new_dist",
"-refuels = [[1 if dist < INF else INF for dist in row] for row in dists]",
"-for k in range(n):",
"- rk = refuels[k]",
"- for i in range(n):",
"- ri = refuels[i]",
"- for j in range(n):",
"- new_dist = ri[k] + rk[j]",
"- if ri[j] > new_dist:",
"- ri[j] = new_dist",
"+dists = floyd_warshall(csr_matrix(dists))",
"+refuels = np.ones((n, n), dtype=np.int64)",
"+refuels[dists > l] = INF",
"+refuels = floyd_warshall(csr_matrix(refuels)).astype(np.int64)",
"+refuels[refuels == INF] = 0",
"+refuels -= 1",
"- refuel = refuels[s - 1][t - 1]",
"- buf.append(-1 if refuel == INF else refuel - 1)",
"+ buf.append(refuels[s - 1][t - 1])"
] | false | 0.040599 | 0.517956 | 0.078382 | [
"s104821957",
"s583305643"
] |
u832039789 | p02771 | python | s535720917 | s907465805 | 189 | 35 | 5,964 | 5,068 | Accepted | Accepted | 81.48 | import sys
from fractions import gcd
from itertools import groupby as gb
from itertools import permutations as perm
from itertools import combinations as comb
from collections import Counter as C
from collections import defaultdict as dd
sys.setrecursionlimit(10**5)
def y(f):
if f:
print('Yes')
else:
print('No')
def Y(f):
if f:
print('YES')
else:
print('NO')
def Z(f):
if f:
print('Yay!')
else:
print(':(')
def ispow(n):
if int(n**.5)**2==n:
return True
return False
a = list(map(int,input().split()))
y(len(set(a)) == 2) | import sys
from fractions import gcd
from itertools import groupby as gb
from itertools import permutations as perm
from itertools import combinations as comb
from collections import Counter as C
from collections import defaultdict as dd
sys.setrecursionlimit(10**5)
def y(f):
if f:
print('Yes')
else:
print('No')
def Y(f):
if f:
print('YES')
else:
print('NO')
def Z(f):
if f:
print('Yay!')
else:
print(':(')
def ispow(n):
if int(n**.5)**2==n:
return True
return False
s = set(list(map(int,input().split())))
y(len(s) == 2)
| 30 | 30 | 641 | 642 | import sys
from fractions import gcd
from itertools import groupby as gb
from itertools import permutations as perm
from itertools import combinations as comb
from collections import Counter as C
from collections import defaultdict as dd
sys.setrecursionlimit(10**5)
def y(f):
if f:
print("Yes")
else:
print("No")
def Y(f):
if f:
print("YES")
else:
print("NO")
def Z(f):
if f:
print("Yay!")
else:
print(":(")
def ispow(n):
if int(n**0.5) ** 2 == n:
return True
return False
a = list(map(int, input().split()))
y(len(set(a)) == 2)
| import sys
from fractions import gcd
from itertools import groupby as gb
from itertools import permutations as perm
from itertools import combinations as comb
from collections import Counter as C
from collections import defaultdict as dd
sys.setrecursionlimit(10**5)
def y(f):
if f:
print("Yes")
else:
print("No")
def Y(f):
if f:
print("YES")
else:
print("NO")
def Z(f):
if f:
print("Yay!")
else:
print(":(")
def ispow(n):
if int(n**0.5) ** 2 == n:
return True
return False
s = set(list(map(int, input().split())))
y(len(s) == 2)
| false | 0 | [
"-a = list(map(int, input().split()))",
"-y(len(set(a)) == 2)",
"+s = set(list(map(int, input().split())))",
"+y(len(s) == 2)"
] | false | 0.035304 | 0.033252 | 1.061705 | [
"s535720917",
"s907465805"
] |
u497596438 | p03645 | python | s690198175 | s650404638 | 984 | 597 | 73,816 | 19,024 | Accepted | Accepted | 39.33 | from collections import defaultdict
N,M=list(map(int,input().split()))
dict=defaultdict(int)
l1=[]
l2=[]
for i in range(M):
a,b=list(map(int,input().split()))
if a==1:
l1.append(b)
if b==N:
dict[a]=1
for i in l1:
if dict[i]:
print("POSSIBLE")
quit()
print("IMPOSSIBLE")
|
N,M=list(map(int,input().split()))
t=set()
s=set()
for i in range(M):
a,b=list(map(int,input().split()))
if a==1:
s.add(b)
if b==N:
t.add(a)
for i in s:
if i in t:
print("POSSIBLE")
quit()
print("IMPOSSIBLE")
| 16 | 15 | 321 | 260 | from collections import defaultdict
N, M = list(map(int, input().split()))
dict = defaultdict(int)
l1 = []
l2 = []
for i in range(M):
a, b = list(map(int, input().split()))
if a == 1:
l1.append(b)
if b == N:
dict[a] = 1
for i in l1:
if dict[i]:
print("POSSIBLE")
quit()
print("IMPOSSIBLE")
| N, M = list(map(int, input().split()))
t = set()
s = set()
for i in range(M):
a, b = list(map(int, input().split()))
if a == 1:
s.add(b)
if b == N:
t.add(a)
for i in s:
if i in t:
print("POSSIBLE")
quit()
print("IMPOSSIBLE")
| false | 6.25 | [
"-from collections import defaultdict",
"-",
"-dict = defaultdict(int)",
"-l1 = []",
"-l2 = []",
"+t = set()",
"+s = set()",
"- l1.append(b)",
"+ s.add(b)",
"- dict[a] = 1",
"-for i in l1:",
"- if dict[i]:",
"+ t.add(a)",
"+for i in s:",
"+ if i in t:"
] | false | 0.04168 | 0.073515 | 0.566959 | [
"s690198175",
"s650404638"
] |
u144913062 | p02873 | python | s101565695 | s949811845 | 514 | 452 | 23,380 | 23,272 | Accepted | Accepted | 12.06 | S = eval(input())
N = len(S) + 1
a = [0] * N
for i in range(-1, N-1):
if (i == -1 and S[i+1] == '<') or (i == N - 2 and S[i] == '>') or (S[i] == '>' and S[i+1] == '<'):
j = 0
while i - j >= 0 and S[i-j] == '>' and a[i-j] < j + 1:
a[i-j] = j + 1
j += 1
j = 0
while i + 2 + j < N and S[i+1+j] == '<' and a[i+2+j] < j + 1:
a[i+2+j] = j + 1
j += 1
print((sum(a)))
| S = '>' + eval(input()) + '<'
N = len(S) + 1
a = [0] * N
for i in range(N - 1):
if S[i] == '>' and S[i+1] == '<':
j = 0
while i - j >= 0 and S[i-j] == '>' and a[i-j] < j + 1:
a[i-j] = j + 1
j += 1
j = 0
while i + 2 + j < N and S[i+1+j] == '<' and a[i+2+j] < j + 1:
a[i+2+j] = j + 1
j += 1
print((sum(a) - a[0] - a[-1]))
| 15 | 15 | 451 | 411 | S = eval(input())
N = len(S) + 1
a = [0] * N
for i in range(-1, N - 1):
if (
(i == -1 and S[i + 1] == "<")
or (i == N - 2 and S[i] == ">")
or (S[i] == ">" and S[i + 1] == "<")
):
j = 0
while i - j >= 0 and S[i - j] == ">" and a[i - j] < j + 1:
a[i - j] = j + 1
j += 1
j = 0
while i + 2 + j < N and S[i + 1 + j] == "<" and a[i + 2 + j] < j + 1:
a[i + 2 + j] = j + 1
j += 1
print((sum(a)))
| S = ">" + eval(input()) + "<"
N = len(S) + 1
a = [0] * N
for i in range(N - 1):
if S[i] == ">" and S[i + 1] == "<":
j = 0
while i - j >= 0 and S[i - j] == ">" and a[i - j] < j + 1:
a[i - j] = j + 1
j += 1
j = 0
while i + 2 + j < N and S[i + 1 + j] == "<" and a[i + 2 + j] < j + 1:
a[i + 2 + j] = j + 1
j += 1
print((sum(a) - a[0] - a[-1]))
| false | 0 | [
"-S = eval(input())",
"+S = \">\" + eval(input()) + \"<\"",
"-for i in range(-1, N - 1):",
"- if (",
"- (i == -1 and S[i + 1] == \"<\")",
"- or (i == N - 2 and S[i] == \">\")",
"- or (S[i] == \">\" and S[i + 1] == \"<\")",
"- ):",
"+for i in range(N - 1):",
"+ if S[i] == \">\" and S[i + 1] == \"<\":",
"-print((sum(a)))",
"+print((sum(a) - a[0] - a[-1]))"
] | false | 0.043907 | 0.043651 | 1.005858 | [
"s101565695",
"s949811845"
] |
u707124227 | p03078 | python | s063613079 | s266749372 | 515 | 128 | 228,968 | 77,364 | Accepted | Accepted | 75.15 | 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()))
from heapq import heappop,heappush,heapify
def main1(a,b,c,k):
ans=[]
for x in a:
for y in b:
ans.append(-x-y)
ans.sort()
ans=ans[:k] if len(ans)>=k else ans+[0]*(k-len(ans))
ans1=[]
for z in c:
for xy in ans:
heappush(ans1,xy-z)
for _ in range(k):
print((-heappop(ans1)))
main1(a,b,c,k)
| 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()))
from heapq import heappop,heappush,heapify
def main1(a,b,c,k):
ans=[]
for x in a:
for y in b:
ans.append(-x-y)
ans.sort()
ans=ans[:k] if len(ans)>=k else ans+[0]*(k-len(ans))
ans1=[]
for z in c:
for xy in ans:
heappush(ans1,xy-z)
for _ in range(k):
print((-heappop(ans1)))
def main2(a,b,c,k):
a.sort(reverse=True)
b.sort(reverse=True)
c.sort(reverse=True)
al=[]
for i,x in enumerate(a):
for j,y in enumerate(b):
for l,z in enumerate(c):
if (i+1)*(j+1)*(l+1)<=k:
al.append(x+y+z)
else:
break
al.sort()
for _ in range(k):
print((al.pop()))
main2(a,b,c,k)
| 21 | 37 | 478 | 822 | 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()))
from heapq import heappop, heappush, heapify
def main1(a, b, c, k):
ans = []
for x in a:
for y in b:
ans.append(-x - y)
ans.sort()
ans = ans[:k] if len(ans) >= k else ans + [0] * (k - len(ans))
ans1 = []
for z in c:
for xy in ans:
heappush(ans1, xy - z)
for _ in range(k):
print((-heappop(ans1)))
main1(a, b, c, k)
| 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()))
from heapq import heappop, heappush, heapify
def main1(a, b, c, k):
ans = []
for x in a:
for y in b:
ans.append(-x - y)
ans.sort()
ans = ans[:k] if len(ans) >= k else ans + [0] * (k - len(ans))
ans1 = []
for z in c:
for xy in ans:
heappush(ans1, xy - z)
for _ in range(k):
print((-heappop(ans1)))
def main2(a, b, c, k):
a.sort(reverse=True)
b.sort(reverse=True)
c.sort(reverse=True)
al = []
for i, x in enumerate(a):
for j, y in enumerate(b):
for l, z in enumerate(c):
if (i + 1) * (j + 1) * (l + 1) <= k:
al.append(x + y + z)
else:
break
al.sort()
for _ in range(k):
print((al.pop()))
main2(a, b, c, k)
| false | 43.243243 | [
"-main1(a, b, c, k)",
"+def main2(a, b, c, k):",
"+ a.sort(reverse=True)",
"+ b.sort(reverse=True)",
"+ c.sort(reverse=True)",
"+ al = []",
"+ for i, x in enumerate(a):",
"+ for j, y in enumerate(b):",
"+ for l, z in enumerate(c):",
"+ if (i + 1) * (j + 1) * (l + 1) <= k:",
"+ al.append(x + y + z)",
"+ else:",
"+ break",
"+ al.sort()",
"+ for _ in range(k):",
"+ print((al.pop()))",
"+",
"+",
"+main2(a, b, c, k)"
] | false | 0.061091 | 0.074216 | 0.823147 | [
"s063613079",
"s266749372"
] |
u686036872 | p03067 | python | s200627384 | s889779328 | 20 | 17 | 2,940 | 2,940 | Accepted | Accepted | 15 | a, b, c = list(map(int, input().split()))
if a < c < b or b < c <a:
print("Yes")
else:
print("No") | A, B, C = list(map(int, input().split()))
if A < C < B or B < C < A:
print("Yes")
else:
print("No") | 5 | 5 | 105 | 105 | a, b, c = list(map(int, input().split()))
if a < c < b or b < c < a:
print("Yes")
else:
print("No")
| A, B, C = list(map(int, input().split()))
if A < C < B or B < C < A:
print("Yes")
else:
print("No")
| false | 0 | [
"-a, b, c = list(map(int, input().split()))",
"-if a < c < b or b < c < a:",
"+A, B, C = list(map(int, input().split()))",
"+if A < C < B or B < C < A:"
] | false | 0.035974 | 0.037559 | 0.957802 | [
"s200627384",
"s889779328"
] |
u492910842 | p03470 | python | s609510060 | s525256452 | 72 | 63 | 62,408 | 62,264 | Accepted | Accepted | 12.5 | n=int(eval(input()))
d=[int(eval(input())) for i in range(n)]
print((len(set(d)))) | n=int(eval(input()))
d=[eval(input()) for i in range(n)]
print((len(set(d)))) | 3 | 3 | 70 | 65 | n = int(eval(input()))
d = [int(eval(input())) for i in range(n)]
print((len(set(d))))
| n = int(eval(input()))
d = [eval(input()) for i in range(n)]
print((len(set(d))))
| false | 0 | [
"-d = [int(eval(input())) for i in range(n)]",
"+d = [eval(input()) for i in range(n)]"
] | false | 0.046228 | 0.046506 | 0.994015 | [
"s609510060",
"s525256452"
] |
u198062737 | p03831 | python | s617812069 | s724086500 | 243 | 220 | 59,732 | 63,700 | Accepted | Accepted | 9.47 | N, A, B = list(map(int, input().split(" ")))
X = list(map(int, input().split(" ")))
ans = 0
for i in range(N - 1):
ans += min(A * (X[i + 1] - X[i]), B)
print(ans) | N, A, B = list(map(int, input().split(" ")))
X = list(map(int, input().split(" ")))
print((sum([min(A * (X[i + 1] - X[i]), B) for i in range(N - 1)]))) | 6 | 3 | 165 | 145 | N, A, B = list(map(int, input().split(" ")))
X = list(map(int, input().split(" ")))
ans = 0
for i in range(N - 1):
ans += min(A * (X[i + 1] - X[i]), B)
print(ans)
| N, A, B = list(map(int, input().split(" ")))
X = list(map(int, input().split(" ")))
print((sum([min(A * (X[i + 1] - X[i]), B) for i in range(N - 1)])))
| false | 50 | [
"-ans = 0",
"-for i in range(N - 1):",
"- ans += min(A * (X[i + 1] - X[i]), B)",
"-print(ans)",
"+print((sum([min(A * (X[i + 1] - X[i]), B) for i in range(N - 1)])))"
] | false | 0.167101 | 0.049511 | 3.37503 | [
"s617812069",
"s724086500"
] |
u260162297 | p02971 | python | s221378523 | s024152410 | 566 | 512 | 13,384 | 13,384 | Accepted | Accepted | 9.54 | N = int(eval(input()))
A = [int(eval(input())) for i in range(N)]
a = max(A)
b = sorted(A)[-2]
for i in A:
print((b if i == a else a))
| n = int(eval(input()))
l = [int(eval(input())) for i in range(n)]
a = max(l)
b = sorted(l)[-2]
for i in l:
print((b if i == a else a)) | 7 | 6 | 132 | 127 | N = int(eval(input()))
A = [int(eval(input())) for i in range(N)]
a = max(A)
b = sorted(A)[-2]
for i in A:
print((b if i == a else a))
| n = int(eval(input()))
l = [int(eval(input())) for i in range(n)]
a = max(l)
b = sorted(l)[-2]
for i in l:
print((b if i == a else a))
| false | 14.285714 | [
"-N = int(eval(input()))",
"-A = [int(eval(input())) for i in range(N)]",
"-a = max(A)",
"-b = sorted(A)[-2]",
"-for i in A:",
"+n = int(eval(input()))",
"+l = [int(eval(input())) for i in range(n)]",
"+a = max(l)",
"+b = sorted(l)[-2]",
"+for i in l:"
] | false | 0.037894 | 0.055952 | 0.677267 | [
"s221378523",
"s024152410"
] |
u780962115 | p02625 | python | s496927177 | s728544084 | 682 | 272 | 201,224 | 208,372 | Accepted | Accepted | 60.12 | N, M = list(map(int, input().split()))
mod = 10**9+7
# コンビネーションクラスの作成
class Data():
def __init__(self):
self.power = 1
self.rev = 1
class Combi():
def __init__(self, N, mod):
self.lists = [Data() for _ in range(N+1)]
self.mod = mod
for i in range(2, N+1):
self.lists[i].power = ((self.lists[i-1].power)*i) % self.mod
self.lists[N].rev = pow(self.lists[N].power, self.mod-2, self.mod)
for j in range(N, 0, -1):
self.lists[j-1].rev = ((self.lists[j].rev)*j) % self.mod
def combi(self, K, R):
if K < R:
return 0
else:
return ((self.lists[K].power)*(self.lists[K-R].rev)*(self.lists[R].rev)) % self.mod
c = Combi(10**6, mod)
ans = (c.lists[M].power*c.lists[M-N].rev)**2 % mod
for k in range(1, N+1):
s = (-1)**((k-1) % 2)
t = c.combi(N, k)
u=((c.lists[M-k].power*c.lists[M-N].rev)**2) % mod
v=(c.lists[M].power*c.lists[M-k].rev) % mod
ans -= s*t*u*v
print((ans % mod)) | # ライブラリ改変テスト
class Combi():
def __init__(self, N, mod):
self.power = [1 for _ in range(N+1)]
self.rev = [1 for _ in range(N+1)]
self.mod = mod
for i in range(2, N+1):
self.power[i] = (self.power[i-1]*i) % self.mod
self.rev[N] = pow(self.power[N], self.mod-2, self.mod)
for j in range(N, 0, -1):
self.rev[j-1] = (self.rev[j]*j) % self.mod
def com(self, K, R):
if K < R:
return 0
else:
return ((self.power[K])*(self.rev[K-R])*(self.rev[R])) % self.mod
def pom(self, K, R):
if K < R:
return 0
else:
return (self.power[K])*(self.rev[K-R]) % self.mod
N, M = list(map(int, input().split()))
mod = 10**9+7
c = Combi(10**6, mod)
ans = c.pom(M, N)**2 % mod
for k in range(1, N+1):
s = (-1)**((k-1) % 2)
t = c.com(N, k)
u = (c.pom(M-k, N-k)**2) % mod
v = c.pom(M, k) % mod
ans -= s*t*u*v
print((ans % mod)) | 37 | 36 | 1,051 | 1,011 | N, M = list(map(int, input().split()))
mod = 10**9 + 7
# コンビネーションクラスの作成
class Data:
def __init__(self):
self.power = 1
self.rev = 1
class Combi:
def __init__(self, N, mod):
self.lists = [Data() for _ in range(N + 1)]
self.mod = mod
for i in range(2, N + 1):
self.lists[i].power = ((self.lists[i - 1].power) * i) % self.mod
self.lists[N].rev = pow(self.lists[N].power, self.mod - 2, self.mod)
for j in range(N, 0, -1):
self.lists[j - 1].rev = ((self.lists[j].rev) * j) % self.mod
def combi(self, K, R):
if K < R:
return 0
else:
return (
(self.lists[K].power) * (self.lists[K - R].rev) * (self.lists[R].rev)
) % self.mod
c = Combi(10**6, mod)
ans = (c.lists[M].power * c.lists[M - N].rev) ** 2 % mod
for k in range(1, N + 1):
s = (-1) ** ((k - 1) % 2)
t = c.combi(N, k)
u = ((c.lists[M - k].power * c.lists[M - N].rev) ** 2) % mod
v = (c.lists[M].power * c.lists[M - k].rev) % mod
ans -= s * t * u * v
print((ans % mod))
| # ライブラリ改変テスト
class Combi:
def __init__(self, N, mod):
self.power = [1 for _ in range(N + 1)]
self.rev = [1 for _ in range(N + 1)]
self.mod = mod
for i in range(2, N + 1):
self.power[i] = (self.power[i - 1] * i) % self.mod
self.rev[N] = pow(self.power[N], self.mod - 2, self.mod)
for j in range(N, 0, -1):
self.rev[j - 1] = (self.rev[j] * j) % self.mod
def com(self, K, R):
if K < R:
return 0
else:
return ((self.power[K]) * (self.rev[K - R]) * (self.rev[R])) % self.mod
def pom(self, K, R):
if K < R:
return 0
else:
return (self.power[K]) * (self.rev[K - R]) % self.mod
N, M = list(map(int, input().split()))
mod = 10**9 + 7
c = Combi(10**6, mod)
ans = c.pom(M, N) ** 2 % mod
for k in range(1, N + 1):
s = (-1) ** ((k - 1) % 2)
t = c.com(N, k)
u = (c.pom(M - k, N - k) ** 2) % mod
v = c.pom(M, k) % mod
ans -= s * t * u * v
print((ans % mod))
| false | 2.702703 | [
"-N, M = list(map(int, input().split()))",
"-mod = 10**9 + 7",
"-# コンビネーションクラスの作成",
"-class Data:",
"- def __init__(self):",
"- self.power = 1",
"- self.rev = 1",
"-",
"-",
"+# ライブラリ改変テスト",
"- self.lists = [Data() for _ in range(N + 1)]",
"+ self.power = [1 for _ in range(N + 1)]",
"+ self.rev = [1 for _ in range(N + 1)]",
"- self.lists[i].power = ((self.lists[i - 1].power) * i) % self.mod",
"- self.lists[N].rev = pow(self.lists[N].power, self.mod - 2, self.mod)",
"+ self.power[i] = (self.power[i - 1] * i) % self.mod",
"+ self.rev[N] = pow(self.power[N], self.mod - 2, self.mod)",
"- self.lists[j - 1].rev = ((self.lists[j].rev) * j) % self.mod",
"+ self.rev[j - 1] = (self.rev[j] * j) % self.mod",
"- def combi(self, K, R):",
"+ def com(self, K, R):",
"- return (",
"- (self.lists[K].power) * (self.lists[K - R].rev) * (self.lists[R].rev)",
"- ) % self.mod",
"+ return ((self.power[K]) * (self.rev[K - R]) * (self.rev[R])) % self.mod",
"+",
"+ def pom(self, K, R):",
"+ if K < R:",
"+ return 0",
"+ else:",
"+ return (self.power[K]) * (self.rev[K - R]) % self.mod",
"+N, M = list(map(int, input().split()))",
"+mod = 10**9 + 7",
"-ans = (c.lists[M].power * c.lists[M - N].rev) ** 2 % mod",
"+ans = c.pom(M, N) ** 2 % mod",
"- t = c.combi(N, k)",
"- u = ((c.lists[M - k].power * c.lists[M - N].rev) ** 2) % mod",
"- v = (c.lists[M].power * c.lists[M - k].rev) % mod",
"+ t = c.com(N, k)",
"+ u = (c.pom(M - k, N - k) ** 2) % mod",
"+ v = c.pom(M, k) % mod"
] | false | 2.788145 | 1.45414 | 1.917384 | [
"s496927177",
"s728544084"
] |
u977389981 | p03834 | python | s734851171 | s064922245 | 22 | 17 | 2,940 | 2,940 | Accepted | Accepted | 22.73 | s = eval(input())
print((s.replace(',', ' '))) | S = input().split(',')
print((' '.join(S))) | 2 | 2 | 39 | 42 | s = eval(input())
print((s.replace(",", " ")))
| S = input().split(",")
print((" ".join(S)))
| false | 0 | [
"-s = eval(input())",
"-print((s.replace(\",\", \" \")))",
"+S = input().split(\",\")",
"+print((\" \".join(S)))"
] | false | 0.056961 | 0.05524 | 1.031168 | [
"s734851171",
"s064922245"
] |
u632424921 | p02277 | python | s990482126 | s260060571 | 2,930 | 1,400 | 16,320 | 19,252 | Accepted | Accepted | 52.22 | def partition(data, left, right):
pivot = int(data[right][2:])
i = left - 1
for j in range(left, right):
if int(data[j][2:]) <= pivot:
i += 1
data[i], data[j] = data[j], data[i]
data[i+1], data[right] = data[right], data[i+1]
return i+1
def quick_sort(data, left, right):
if left < right:
new_pivot = partition(data, left, right)
quick_sort(data, left, new_pivot-1)
quick_sort(data, new_pivot+1, right)
#for comparison
def merge(data, left, mid, right):
n1 = mid - left
n2 = right - mid
L = data[left : mid]
R = data[mid : right]
L.append(" 10000000000")
R.append(" 10000000000")
i = 0
j = 0
for k in range(left, right):
if int(L[i][2:]) <= int(R[j][2:]):
data[k] = L[i]
i += 1
else:
data[k] = R[j]
j += 1
def merge_sort(data, left, right):
if left + 1 < right:
mid = (left + right) / 2
merge_sort(data, left, mid)
merge_sort(data, mid, right)
merge(data, left, mid, right)
def main():
num = input()
pairs_quick = []
pairs_check = []
for i in range(int(num)):
pair = input()
pairs_quick.append(pair)
pairs_check.append(pair)
quick_sort(pairs_quick, 0, int(num)-1)
merge_sort(pairs_check, 0, int(num))
if pairs_quick == pairs_check:
print("Stable")
else:
print("Not stable")
print("\n".join(pairs_quick))
#print "\n".join(pairs_check)
if __name__ == "__main__":
main() | def partition(data, left, right):
pivot = int(data[right][2:])
i = left - 1
for j in range(left, right):
if int(data[j][2:]) <= pivot:
i += 1
data[i], data[j] = data[j], data[i]
data[i+1], data[right] = data[right], data[i+1]
return i+1
def quick_sort(data, left, right):
if left < right:
new_pivot = partition(data, left, right)
quick_sort(data, left, new_pivot-1)
quick_sort(data, new_pivot+1, right)
def main():
num = input()
pairs_quick = []
pairs_check = []
for i in range(int(num)):
pair = input()
pairs_quick.append(pair)
pairs_check.append(pair)
quick_sort(pairs_quick, 0, int(num)-1)
pairs_check = sorted(pairs_check, key = lambda i:int(i[2:]))
if pairs_quick == pairs_check:
print("Stable")
else:
print("Not stable")
print("\n".join(pairs_quick))
if __name__ == "__main__":
main() | 62 | 36 | 1,646 | 999 | def partition(data, left, right):
pivot = int(data[right][2:])
i = left - 1
for j in range(left, right):
if int(data[j][2:]) <= pivot:
i += 1
data[i], data[j] = data[j], data[i]
data[i + 1], data[right] = data[right], data[i + 1]
return i + 1
def quick_sort(data, left, right):
if left < right:
new_pivot = partition(data, left, right)
quick_sort(data, left, new_pivot - 1)
quick_sort(data, new_pivot + 1, right)
# for comparison
def merge(data, left, mid, right):
n1 = mid - left
n2 = right - mid
L = data[left:mid]
R = data[mid:right]
L.append(" 10000000000")
R.append(" 10000000000")
i = 0
j = 0
for k in range(left, right):
if int(L[i][2:]) <= int(R[j][2:]):
data[k] = L[i]
i += 1
else:
data[k] = R[j]
j += 1
def merge_sort(data, left, right):
if left + 1 < right:
mid = (left + right) / 2
merge_sort(data, left, mid)
merge_sort(data, mid, right)
merge(data, left, mid, right)
def main():
num = input()
pairs_quick = []
pairs_check = []
for i in range(int(num)):
pair = input()
pairs_quick.append(pair)
pairs_check.append(pair)
quick_sort(pairs_quick, 0, int(num) - 1)
merge_sort(pairs_check, 0, int(num))
if pairs_quick == pairs_check:
print("Stable")
else:
print("Not stable")
print("\n".join(pairs_quick))
# print "\n".join(pairs_check)
if __name__ == "__main__":
main()
| def partition(data, left, right):
pivot = int(data[right][2:])
i = left - 1
for j in range(left, right):
if int(data[j][2:]) <= pivot:
i += 1
data[i], data[j] = data[j], data[i]
data[i + 1], data[right] = data[right], data[i + 1]
return i + 1
def quick_sort(data, left, right):
if left < right:
new_pivot = partition(data, left, right)
quick_sort(data, left, new_pivot - 1)
quick_sort(data, new_pivot + 1, right)
def main():
num = input()
pairs_quick = []
pairs_check = []
for i in range(int(num)):
pair = input()
pairs_quick.append(pair)
pairs_check.append(pair)
quick_sort(pairs_quick, 0, int(num) - 1)
pairs_check = sorted(pairs_check, key=lambda i: int(i[2:]))
if pairs_quick == pairs_check:
print("Stable")
else:
print("Not stable")
print("\n".join(pairs_quick))
if __name__ == "__main__":
main()
| false | 41.935484 | [
"-# for comparison",
"-def merge(data, left, mid, right):",
"- n1 = mid - left",
"- n2 = right - mid",
"- L = data[left:mid]",
"- R = data[mid:right]",
"- L.append(\" 10000000000\")",
"- R.append(\" 10000000000\")",
"- i = 0",
"- j = 0",
"- for k in range(left, right):",
"- if int(L[i][2:]) <= int(R[j][2:]):",
"- data[k] = L[i]",
"- i += 1",
"- else:",
"- data[k] = R[j]",
"- j += 1",
"-",
"-",
"-def merge_sort(data, left, right):",
"- if left + 1 < right:",
"- mid = (left + right) / 2",
"- merge_sort(data, left, mid)",
"- merge_sort(data, mid, right)",
"- merge(data, left, mid, right)",
"-",
"-",
"- merge_sort(pairs_check, 0, int(num))",
"+ pairs_check = sorted(pairs_check, key=lambda i: int(i[2:]))",
"- # print \"\\n\".join(pairs_check)"
] | false | 0.037293 | 0.046888 | 0.795369 | [
"s990482126",
"s260060571"
] |
u260980560 | p02378 | python | s363346808 | s745744918 | 150 | 50 | 10,060 | 7,976 | Accepted | Accepted | 66.67 | import collections
class Dinic:
def __init__(self, n):
self.n = n
self.g = [[] for i in range(n)]
def add_edge(self, fr, to, cap):
self.g[fr].append([to, cap, len(self.g[to])])
self.g[to].append([fr, 0, len(self.g[fr])-1])
def add_multi_edge(self, v1, v2, cap1, cap2):
self.g[v1].append([v2, cap1, len(self.g[v2])])
self.g[v2].append([v1, cap2, len(self.g[v1])-1])
def bfs(self, s):
level = [-1]*self.n
deq = collections.deque()
level[s] = 0
deq.append(s)
while deq:
v = deq.popleft()
for e in self.g[v]:
if e[1]>0 and level[e[0]]<0:
level[e[0]] = level[v] + 1
deq.append(e[0])
self.level = level
def dfs(self, v, t, f):
if v==t: return f
es = self.g[v]
level = self.level
for i in range(self.it[v], len(self.g[v])):
e = es[i]
if e[1]>0 and level[v]<level[e[0]]:
d = self.dfs(e[0], t, min(f, e[1]))
if d>0:
e[1] -= d
self.g[e[0]][e[2]][1] += d
self.it[v] = i
return d
self.it[v] = len(self.g[v])
return 0
def max_flow(self, s, t):
flow = 0
while True:
self.bfs(s)
if self.level[t]<0: break
self.it = [0]*self.n
while True:
f = self.dfs(s, t, 10**9+7)
if f>0:
flow += f
else:
break
return flow
X, Y, E = list(map(int, input().split()))
dinic = Dinic(2+X+Y)
for i in range(X):
dinic.add_edge(0, 2+i, 1)
for i in range(Y):
dinic.add_edge(2+X+i, 1, 1)
for i in range(E):
x, y = list(map(int, input().split()))
dinic.add_edge(2+x, 2+X+y, 1)
print((dinic.max_flow(0, 1))) | # Hopcroft-Karp Algorithm
from collections import deque
class HopcroftKarp:
def __init__(self, N0, N1):
self.N0 = N0
self.N1 = N1
self.N = N = 2+N0+N1
self.G = [[] for i in range(N)]
for i in range(N0):
forward = [2+i, 1, None]
forward[2] = backward = [0, 0, forward]
self.G[0].append(forward)
self.G[2+i].append(backward)
self.backwards = bs = []
for i in range(N1):
forward = [1, 1, None]
forward[2] = backward = [2+N0+i, 0, forward]
bs.append(backward)
self.G[2+N0+i].append(forward)
self.G[1].append(backward)
def add_edge(self, fr, to):
#assert 0 <= fr < self.N0
#assert 0 <= to < self.N1
v0 = 2 + fr
v1 = 2 + self.N0 + to
forward = [v1, 1, None]
forward[2] = backward = [v0, 0, forward]
self.G[v0].append(forward)
self.G[v1].append(backward)
def bfs(self):
G = self.G
level = [None]*self.N
deq = deque([0])
level[0] = 0
while deq:
v = deq.popleft()
lv = level[v] + 1
for w, cap, _ in G[v]:
if cap and level[w] is None:
level[w] = lv
deq.append(w)
self.level = level
return level[1] is not None
def dfs(self, v, t):
if v == t:
return 1
level = self.level
for e in self.it[v]:
w, cap, rev = e
if cap and level[v] < level[w] and self.dfs(w, t):
e[1] = 0
rev[1] = 1
return 1
return 0
def flow(self):
flow = 0
N = self.N; G = self.G
bfs = self.bfs; dfs = self.dfs
while bfs():
*self.it, = list(map(iter, G))
while dfs(0, 1):
flow += 1
return flow
def matching(self):
return [cap for _, cap, _ in self.backwards]
import sys
readline = sys.stdin.readline
write = sys.stdout.write
X, Y, E = list(map(int, readline().split()))
hc = HopcroftKarp(X, Y)
for i in range(E):
x, y = list(map(int, readline().split()))
hc.add_edge(x, y)
write("%d\n" % hc.flow())
| 62 | 85 | 1,973 | 2,342 | import collections
class Dinic:
def __init__(self, n):
self.n = n
self.g = [[] for i in range(n)]
def add_edge(self, fr, to, cap):
self.g[fr].append([to, cap, len(self.g[to])])
self.g[to].append([fr, 0, len(self.g[fr]) - 1])
def add_multi_edge(self, v1, v2, cap1, cap2):
self.g[v1].append([v2, cap1, len(self.g[v2])])
self.g[v2].append([v1, cap2, len(self.g[v1]) - 1])
def bfs(self, s):
level = [-1] * self.n
deq = collections.deque()
level[s] = 0
deq.append(s)
while deq:
v = deq.popleft()
for e in self.g[v]:
if e[1] > 0 and level[e[0]] < 0:
level[e[0]] = level[v] + 1
deq.append(e[0])
self.level = level
def dfs(self, v, t, f):
if v == t:
return f
es = self.g[v]
level = self.level
for i in range(self.it[v], len(self.g[v])):
e = es[i]
if e[1] > 0 and level[v] < level[e[0]]:
d = self.dfs(e[0], t, min(f, e[1]))
if d > 0:
e[1] -= d
self.g[e[0]][e[2]][1] += d
self.it[v] = i
return d
self.it[v] = len(self.g[v])
return 0
def max_flow(self, s, t):
flow = 0
while True:
self.bfs(s)
if self.level[t] < 0:
break
self.it = [0] * self.n
while True:
f = self.dfs(s, t, 10**9 + 7)
if f > 0:
flow += f
else:
break
return flow
X, Y, E = list(map(int, input().split()))
dinic = Dinic(2 + X + Y)
for i in range(X):
dinic.add_edge(0, 2 + i, 1)
for i in range(Y):
dinic.add_edge(2 + X + i, 1, 1)
for i in range(E):
x, y = list(map(int, input().split()))
dinic.add_edge(2 + x, 2 + X + y, 1)
print((dinic.max_flow(0, 1)))
| # Hopcroft-Karp Algorithm
from collections import deque
class HopcroftKarp:
def __init__(self, N0, N1):
self.N0 = N0
self.N1 = N1
self.N = N = 2 + N0 + N1
self.G = [[] for i in range(N)]
for i in range(N0):
forward = [2 + i, 1, None]
forward[2] = backward = [0, 0, forward]
self.G[0].append(forward)
self.G[2 + i].append(backward)
self.backwards = bs = []
for i in range(N1):
forward = [1, 1, None]
forward[2] = backward = [2 + N0 + i, 0, forward]
bs.append(backward)
self.G[2 + N0 + i].append(forward)
self.G[1].append(backward)
def add_edge(self, fr, to):
# assert 0 <= fr < self.N0
# assert 0 <= to < self.N1
v0 = 2 + fr
v1 = 2 + self.N0 + to
forward = [v1, 1, None]
forward[2] = backward = [v0, 0, forward]
self.G[v0].append(forward)
self.G[v1].append(backward)
def bfs(self):
G = self.G
level = [None] * self.N
deq = deque([0])
level[0] = 0
while deq:
v = deq.popleft()
lv = level[v] + 1
for w, cap, _ in G[v]:
if cap and level[w] is None:
level[w] = lv
deq.append(w)
self.level = level
return level[1] is not None
def dfs(self, v, t):
if v == t:
return 1
level = self.level
for e in self.it[v]:
w, cap, rev = e
if cap and level[v] < level[w] and self.dfs(w, t):
e[1] = 0
rev[1] = 1
return 1
return 0
def flow(self):
flow = 0
N = self.N
G = self.G
bfs = self.bfs
dfs = self.dfs
while bfs():
(*self.it,) = list(map(iter, G))
while dfs(0, 1):
flow += 1
return flow
def matching(self):
return [cap for _, cap, _ in self.backwards]
import sys
readline = sys.stdin.readline
write = sys.stdout.write
X, Y, E = list(map(int, readline().split()))
hc = HopcroftKarp(X, Y)
for i in range(E):
x, y = list(map(int, readline().split()))
hc.add_edge(x, y)
write("%d\n" % hc.flow())
| false | 27.058824 | [
"-import collections",
"+# Hopcroft-Karp Algorithm",
"+from collections import deque",
"-class Dinic:",
"- def __init__(self, n):",
"- self.n = n",
"- self.g = [[] for i in range(n)]",
"+class HopcroftKarp:",
"+ def __init__(self, N0, N1):",
"+ self.N0 = N0",
"+ self.N1 = N1",
"+ self.N = N = 2 + N0 + N1",
"+ self.G = [[] for i in range(N)]",
"+ for i in range(N0):",
"+ forward = [2 + i, 1, None]",
"+ forward[2] = backward = [0, 0, forward]",
"+ self.G[0].append(forward)",
"+ self.G[2 + i].append(backward)",
"+ self.backwards = bs = []",
"+ for i in range(N1):",
"+ forward = [1, 1, None]",
"+ forward[2] = backward = [2 + N0 + i, 0, forward]",
"+ bs.append(backward)",
"+ self.G[2 + N0 + i].append(forward)",
"+ self.G[1].append(backward)",
"- def add_edge(self, fr, to, cap):",
"- self.g[fr].append([to, cap, len(self.g[to])])",
"- self.g[to].append([fr, 0, len(self.g[fr]) - 1])",
"+ def add_edge(self, fr, to):",
"+ # assert 0 <= fr < self.N0",
"+ # assert 0 <= to < self.N1",
"+ v0 = 2 + fr",
"+ v1 = 2 + self.N0 + to",
"+ forward = [v1, 1, None]",
"+ forward[2] = backward = [v0, 0, forward]",
"+ self.G[v0].append(forward)",
"+ self.G[v1].append(backward)",
"- def add_multi_edge(self, v1, v2, cap1, cap2):",
"- self.g[v1].append([v2, cap1, len(self.g[v2])])",
"- self.g[v2].append([v1, cap2, len(self.g[v1]) - 1])",
"-",
"- def bfs(self, s):",
"- level = [-1] * self.n",
"- deq = collections.deque()",
"- level[s] = 0",
"- deq.append(s)",
"+ def bfs(self):",
"+ G = self.G",
"+ level = [None] * self.N",
"+ deq = deque([0])",
"+ level[0] = 0",
"- for e in self.g[v]:",
"- if e[1] > 0 and level[e[0]] < 0:",
"- level[e[0]] = level[v] + 1",
"- deq.append(e[0])",
"+ lv = level[v] + 1",
"+ for w, cap, _ in G[v]:",
"+ if cap and level[w] is None:",
"+ level[w] = lv",
"+ deq.append(w)",
"+ return level[1] is not None",
"- def dfs(self, v, t, f):",
"+ def dfs(self, v, t):",
"- return f",
"- es = self.g[v]",
"+ return 1",
"- for i in range(self.it[v], len(self.g[v])):",
"- e = es[i]",
"- if e[1] > 0 and level[v] < level[e[0]]:",
"- d = self.dfs(e[0], t, min(f, e[1]))",
"- if d > 0:",
"- e[1] -= d",
"- self.g[e[0]][e[2]][1] += d",
"- self.it[v] = i",
"- return d",
"- self.it[v] = len(self.g[v])",
"+ for e in self.it[v]:",
"+ w, cap, rev = e",
"+ if cap and level[v] < level[w] and self.dfs(w, t):",
"+ e[1] = 0",
"+ rev[1] = 1",
"+ return 1",
"- def max_flow(self, s, t):",
"+ def flow(self):",
"- while True:",
"- self.bfs(s)",
"- if self.level[t] < 0:",
"- break",
"- self.it = [0] * self.n",
"- while True:",
"- f = self.dfs(s, t, 10**9 + 7)",
"- if f > 0:",
"- flow += f",
"- else:",
"- break",
"+ N = self.N",
"+ G = self.G",
"+ bfs = self.bfs",
"+ dfs = self.dfs",
"+ while bfs():",
"+ (*self.it,) = list(map(iter, G))",
"+ while dfs(0, 1):",
"+ flow += 1",
"+ def matching(self):",
"+ return [cap for _, cap, _ in self.backwards]",
"-X, Y, E = list(map(int, input().split()))",
"-dinic = Dinic(2 + X + Y)",
"-for i in range(X):",
"- dinic.add_edge(0, 2 + i, 1)",
"-for i in range(Y):",
"- dinic.add_edge(2 + X + i, 1, 1)",
"+",
"+import sys",
"+",
"+readline = sys.stdin.readline",
"+write = sys.stdout.write",
"+X, Y, E = list(map(int, readline().split()))",
"+hc = HopcroftKarp(X, Y)",
"- x, y = list(map(int, input().split()))",
"- dinic.add_edge(2 + x, 2 + X + y, 1)",
"-print((dinic.max_flow(0, 1)))",
"+ x, y = list(map(int, readline().split()))",
"+ hc.add_edge(x, y)",
"+write(\"%d\\n\" % hc.flow())"
] | false | 0.045226 | 0.101914 | 0.443765 | [
"s363346808",
"s745744918"
] |
u499381410 | p03418 | python | s577281555 | s878226584 | 185 | 121 | 82,972 | 83,476 | Accepted | Accepted | 34.59 | from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
from bisect import bisect_left, bisect_right
import random
from itertools import permutations, accumulate, combinations
import sys
import string
from copy import deepcopy
INF = 10 ** 20
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return sys.stdin.readline().strip()
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 10 ** 9 + 7
n,k=LI()
ans=0
if k==0:
print((n*n))
exit()
for b in range(k+1,n+1):
ans+=n//b*(b-k)+max(0,n%b-k+1)
print(ans) | from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
from bisect import bisect_left, bisect_right
import random
from itertools import permutations, accumulate, combinations
import sys
import string
from copy import deepcopy
INF = 10 ** 20
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return sys.stdin.readline().strip()
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 10 ** 9 + 7
n,k=LI()
ans=0
if k==0:
print((n*n))
exit()
for b in range(k+1,n+1):
ans+=(n+1)//b*(b-k)+max(0,(n+1)%b-k)
print(ans) | 34 | 34 | 955 | 961 | from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
from bisect import bisect_left, bisect_right
import random
from itertools import permutations, accumulate, combinations
import sys
import string
from copy import deepcopy
INF = 10**20
def LI():
return list(map(int, sys.stdin.readline().split()))
def I():
return int(sys.stdin.readline())
def LS():
return sys.stdin.readline().split()
def S():
return sys.stdin.readline().strip()
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
def SRL(n):
return [list(S()) for i in range(n)]
def MSRL(n):
return [[int(j) for j in list(S())] for i in range(n)]
mod = 10**9 + 7
n, k = LI()
ans = 0
if k == 0:
print((n * n))
exit()
for b in range(k + 1, n + 1):
ans += n // b * (b - k) + max(0, n % b - k + 1)
print(ans)
| from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
from bisect import bisect_left, bisect_right
import random
from itertools import permutations, accumulate, combinations
import sys
import string
from copy import deepcopy
INF = 10**20
def LI():
return list(map(int, sys.stdin.readline().split()))
def I():
return int(sys.stdin.readline())
def LS():
return sys.stdin.readline().split()
def S():
return sys.stdin.readline().strip()
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
def SRL(n):
return [list(S()) for i in range(n)]
def MSRL(n):
return [[int(j) for j in list(S())] for i in range(n)]
mod = 10**9 + 7
n, k = LI()
ans = 0
if k == 0:
print((n * n))
exit()
for b in range(k + 1, n + 1):
ans += (n + 1) // b * (b - k) + max(0, (n + 1) % b - k)
print(ans)
| false | 0 | [
"- ans += n // b * (b - k) + max(0, n % b - k + 1)",
"+ ans += (n + 1) // b * (b - k) + max(0, (n + 1) % b - k)"
] | false | 0.047516 | 0.044881 | 1.05872 | [
"s577281555",
"s878226584"
] |
u777283665 | p03937 | python | s932308504 | s459394598 | 172 | 17 | 38,384 | 2,940 | Accepted | Accepted | 90.12 | h, w = list(map(int, input().split()))
s = h + w - 1
x = 0
for _ in range(h):
x += input().count("#")
if s == x:
print("Possible")
else:
print("Impossible") | h, w = list(map(int, input().split()))
cnt = 0
for _ in range(h):
cnt += input().count("#")
if cnt == h+w-1:
print("Possible")
else:
print("Impossible") | 10 | 9 | 163 | 167 | h, w = list(map(int, input().split()))
s = h + w - 1
x = 0
for _ in range(h):
x += input().count("#")
if s == x:
print("Possible")
else:
print("Impossible")
| h, w = list(map(int, input().split()))
cnt = 0
for _ in range(h):
cnt += input().count("#")
if cnt == h + w - 1:
print("Possible")
else:
print("Impossible")
| false | 10 | [
"-s = h + w - 1",
"-x = 0",
"+cnt = 0",
"- x += input().count(\"#\")",
"-if s == x:",
"+ cnt += input().count(\"#\")",
"+if cnt == h + w - 1:"
] | false | 0.039777 | 0.039456 | 1.00814 | [
"s932308504",
"s459394598"
] |
u062655521 | p03448 | python | s113186635 | s279791510 | 51 | 28 | 3,060 | 3,064 | Accepted | Accepted | 45.1 | a = int(eval(input()))
b = int(eval(input()))
c = int(eval(input()))
x = int(eval(input()))
cnt = 0
for i in range(a + 1):
for j in range(b + 1):
for k in range(c + 1):
if 500 * i + 100 * j + 50 * k == x:
cnt += 1
print(cnt) | a = int(eval(input()))
b = int(eval(input()))
c = int(eval(input()))
x = int(eval(input()))
cnt = 0
for i in range(a + 1):
if 500 * i <= x:
p = x - 500 * i
for j in range(b + 1):
if 100 * j <= p:
q = p - 100 * j
for k in range(c + 1):
if q - 50 * k == 0:
cnt += 1
print(cnt) | 13 | 17 | 224 | 295 | a = int(eval(input()))
b = int(eval(input()))
c = int(eval(input()))
x = int(eval(input()))
cnt = 0
for i in range(a + 1):
for j in range(b + 1):
for k in range(c + 1):
if 500 * i + 100 * j + 50 * k == x:
cnt += 1
print(cnt)
| a = int(eval(input()))
b = int(eval(input()))
c = int(eval(input()))
x = int(eval(input()))
cnt = 0
for i in range(a + 1):
if 500 * i <= x:
p = x - 500 * i
for j in range(b + 1):
if 100 * j <= p:
q = p - 100 * j
for k in range(c + 1):
if q - 50 * k == 0:
cnt += 1
print(cnt)
| false | 23.529412 | [
"- for j in range(b + 1):",
"- for k in range(c + 1):",
"- if 500 * i + 100 * j + 50 * k == x:",
"- cnt += 1",
"+ if 500 * i <= x:",
"+ p = x - 500 * i",
"+ for j in range(b + 1):",
"+ if 100 * j <= p:",
"+ q = p - 100 * j",
"+ for k in range(c + 1):",
"+ if q - 50 * k == 0:",
"+ cnt += 1"
] | false | 0.104834 | 0.044161 | 2.373893 | [
"s113186635",
"s279791510"
] |
u497596438 | p03327 | python | s093504831 | s403711164 | 192 | 173 | 38,256 | 38,256 | Accepted | Accepted | 9.9 | #S=input()
N=int(eval(input()))
#A,B=map(int,input().split())
if N<1000:
print("ABC")
else:
print("ABD") | N=int(eval(input()))
if N>999:
print("ABD")
else:
print("ABC")
| 7 | 5 | 112 | 69 | # S=input()
N = int(eval(input()))
# A,B=map(int,input().split())
if N < 1000:
print("ABC")
else:
print("ABD")
| N = int(eval(input()))
if N > 999:
print("ABD")
else:
print("ABC")
| false | 28.571429 | [
"-# S=input()",
"-# A,B=map(int,input().split())",
"-if N < 1000:",
"+if N > 999:",
"+ print(\"ABD\")",
"+else:",
"-else:",
"- print(\"ABD\")"
] | false | 0.049633 | 0.045463 | 1.091739 | [
"s093504831",
"s403711164"
] |
u875291233 | p03177 | python | s734764730 | s906568972 | 550 | 482 | 43,740 | 43,484 | Accepted | Accepted | 12.36 | # coding: utf-8
# Your code here!
MOD=10**9+7
def dot(a, b):
res = [[0] * n for _ in range(n)]
for i in range(n):
for k, aik in enumerate(a[i]):
for j,bkj in enumerate(b[k]):
res[i][j] += aik*bkj
res[i][j] %= MOD
return res
n,k = [int(i) for i in input().split()]
A = [[int(i) for i in input().split()] for _ in range(n)]
ans = [[0] * n for _ in range(n)]
for i in range(n):
ans[i][i] = 1
while k:
k, i = divmod(k, 2)
if i:
ans = dot(ans, A)
A = dot(A, A)
res = 0
for i in range(n):
for j in range(n):
res += ans[i][j]
res %= MOD
print(res) | # coding: utf-8
# Your code here!
MOD=10**9+7
def matmul(A, B, mod): # A,B: 行列
res = [[0] * len(B[0]) for _ in range(len(A))]
for i, resi in enumerate(res):
for k, aik in enumerate(A[i]):
for j,bkj in enumerate(B[k]):
resi[j] += aik*bkj
resi[j] %= mod
return res
def matpow(A, p, M): #A^p mod M
if p % 2 == 1:
return matmul(A, matpow(A, p - 1, M), M)
elif p > 0:
b = matpow(A, p // 2, M)
return matmul(b, b, M)
else:
return [[1 if i == j else 0 for j in range(len(A))] for i in range(len(A))]
n,k = [int(i) for i in input().split()]
A = [[int(i) for i in input().split()] for _ in range(n)]
ans = matpow(A,k,MOD)
print((sum(sum(r) % MOD for r in ans) % MOD)) | 33 | 28 | 676 | 796 | # coding: utf-8
# Your code here!
MOD = 10**9 + 7
def dot(a, b):
res = [[0] * n for _ in range(n)]
for i in range(n):
for k, aik in enumerate(a[i]):
for j, bkj in enumerate(b[k]):
res[i][j] += aik * bkj
res[i][j] %= MOD
return res
n, k = [int(i) for i in input().split()]
A = [[int(i) for i in input().split()] for _ in range(n)]
ans = [[0] * n for _ in range(n)]
for i in range(n):
ans[i][i] = 1
while k:
k, i = divmod(k, 2)
if i:
ans = dot(ans, A)
A = dot(A, A)
res = 0
for i in range(n):
for j in range(n):
res += ans[i][j]
res %= MOD
print(res)
| # coding: utf-8
# Your code here!
MOD = 10**9 + 7
def matmul(A, B, mod): # A,B: 行列
res = [[0] * len(B[0]) for _ in range(len(A))]
for i, resi in enumerate(res):
for k, aik in enumerate(A[i]):
for j, bkj in enumerate(B[k]):
resi[j] += aik * bkj
resi[j] %= mod
return res
def matpow(A, p, M): # A^p mod M
if p % 2 == 1:
return matmul(A, matpow(A, p - 1, M), M)
elif p > 0:
b = matpow(A, p // 2, M)
return matmul(b, b, M)
else:
return [[1 if i == j else 0 for j in range(len(A))] for i in range(len(A))]
n, k = [int(i) for i in input().split()]
A = [[int(i) for i in input().split()] for _ in range(n)]
ans = matpow(A, k, MOD)
print((sum(sum(r) % MOD for r in ans) % MOD))
| false | 15.151515 | [
"-def dot(a, b):",
"- res = [[0] * n for _ in range(n)]",
"- for i in range(n):",
"- for k, aik in enumerate(a[i]):",
"- for j, bkj in enumerate(b[k]):",
"- res[i][j] += aik * bkj",
"- res[i][j] %= MOD",
"+def matmul(A, B, mod): # A,B: 行列",
"+ res = [[0] * len(B[0]) for _ in range(len(A))]",
"+ for i, resi in enumerate(res):",
"+ for k, aik in enumerate(A[i]):",
"+ for j, bkj in enumerate(B[k]):",
"+ resi[j] += aik * bkj",
"+ resi[j] %= mod",
"+",
"+",
"+def matpow(A, p, M): # A^p mod M",
"+ if p % 2 == 1:",
"+ return matmul(A, matpow(A, p - 1, M), M)",
"+ elif p > 0:",
"+ b = matpow(A, p // 2, M)",
"+ return matmul(b, b, M)",
"+ else:",
"+ return [[1 if i == j else 0 for j in range(len(A))] for i in range(len(A))]",
"-ans = [[0] * n for _ in range(n)]",
"-for i in range(n):",
"- ans[i][i] = 1",
"-while k:",
"- k, i = divmod(k, 2)",
"- if i:",
"- ans = dot(ans, A)",
"- A = dot(A, A)",
"-res = 0",
"-for i in range(n):",
"- for j in range(n):",
"- res += ans[i][j]",
"- res %= MOD",
"-print(res)",
"+ans = matpow(A, k, MOD)",
"+print((sum(sum(r) % MOD for r in ans) % MOD))"
] | false | 0.138689 | 0.007603 | 18.240453 | [
"s734764730",
"s906568972"
] |
u747602774 | p02888 | python | s846267055 | s229870682 | 1,759 | 1,360 | 3,188 | 3,188 | Accepted | Accepted | 22.68 | import bisect
N=int(eval(input()))
L=list(map(int,input().split()))
L.sort()
ans=0
for n in range(1,N):
b=L[n]
for k in range(n):
a=L[k]
index=bisect.bisect_left(L,a+b)
ans+=max(0,index-n-1)
print(ans) | import bisect
N = int(eval(input()))
L = list(map(int,input().split()))
L.sort()
ans = 0
for i in range(N-2):
a = L[i]
for j in range(i+1,N-1):
b = L[j]
c = bisect.bisect_left(L,a+b)
ans += c-j-1
print(ans)
| 12 | 13 | 222 | 246 | import bisect
N = int(eval(input()))
L = list(map(int, input().split()))
L.sort()
ans = 0
for n in range(1, N):
b = L[n]
for k in range(n):
a = L[k]
index = bisect.bisect_left(L, a + b)
ans += max(0, index - n - 1)
print(ans)
| import bisect
N = int(eval(input()))
L = list(map(int, input().split()))
L.sort()
ans = 0
for i in range(N - 2):
a = L[i]
for j in range(i + 1, N - 1):
b = L[j]
c = bisect.bisect_left(L, a + b)
ans += c - j - 1
print(ans)
| false | 7.692308 | [
"-for n in range(1, N):",
"- b = L[n]",
"- for k in range(n):",
"- a = L[k]",
"- index = bisect.bisect_left(L, a + b)",
"- ans += max(0, index - n - 1)",
"+for i in range(N - 2):",
"+ a = L[i]",
"+ for j in range(i + 1, N - 1):",
"+ b = L[j]",
"+ c = bisect.bisect_left(L, a + b)",
"+ ans += c - j - 1"
] | false | 0.03721 | 0.06946 | 0.535706 | [
"s846267055",
"s229870682"
] |
u608088992 | p03425 | python | s914558478 | s686865280 | 175 | 78 | 3,064 | 3,064 | Accepted | Accepted | 55.43 | N = int(eval(input()))
D = {"M":0, "A":0, "R":0, "C":0, "H":0}
for i in range(N):
a = eval(input())
if a[0] in D:
D[a[0]] += 1
L = [D["M"], D["A"], D["R"], D["C"], D["H"]]
ans = 0
for i in range(3):
for j in range(i+1, 4):
for k in range(j+1, 5):
ans += L[i]*L[j]*L[k]
print(ans) | import sys
def solve():
input = sys.stdin.readline
nameCount = [0] * 5
N = int(eval(input()))
for _ in range(N):
s = input().strip("\n")
if s[0] == "M": nameCount[0] += 1
elif s[0] == "A": nameCount[1] += 1
elif s[0] == "R": nameCount[2] += 1
elif s[0] == "C": nameCount[3] += 1
elif s[0] == "H": nameCount[4] += 1
else: continue
Ans = 0
for i in range(3):
for j in range(i+1, 4):
for k in range(j + 1, 5):
Ans += nameCount[i] * nameCount[j] * nameCount[k]
print(Ans)
return 0
if __name__ == "__main__":
solve() | 13 | 26 | 319 | 662 | N = int(eval(input()))
D = {"M": 0, "A": 0, "R": 0, "C": 0, "H": 0}
for i in range(N):
a = eval(input())
if a[0] in D:
D[a[0]] += 1
L = [D["M"], D["A"], D["R"], D["C"], D["H"]]
ans = 0
for i in range(3):
for j in range(i + 1, 4):
for k in range(j + 1, 5):
ans += L[i] * L[j] * L[k]
print(ans)
| import sys
def solve():
input = sys.stdin.readline
nameCount = [0] * 5
N = int(eval(input()))
for _ in range(N):
s = input().strip("\n")
if s[0] == "M":
nameCount[0] += 1
elif s[0] == "A":
nameCount[1] += 1
elif s[0] == "R":
nameCount[2] += 1
elif s[0] == "C":
nameCount[3] += 1
elif s[0] == "H":
nameCount[4] += 1
else:
continue
Ans = 0
for i in range(3):
for j in range(i + 1, 4):
for k in range(j + 1, 5):
Ans += nameCount[i] * nameCount[j] * nameCount[k]
print(Ans)
return 0
if __name__ == "__main__":
solve()
| false | 50 | [
"-N = int(eval(input()))",
"-D = {\"M\": 0, \"A\": 0, \"R\": 0, \"C\": 0, \"H\": 0}",
"-for i in range(N):",
"- a = eval(input())",
"- if a[0] in D:",
"- D[a[0]] += 1",
"-L = [D[\"M\"], D[\"A\"], D[\"R\"], D[\"C\"], D[\"H\"]]",
"-ans = 0",
"-for i in range(3):",
"- for j in range(i + 1, 4):",
"- for k in range(j + 1, 5):",
"- ans += L[i] * L[j] * L[k]",
"-print(ans)",
"+import sys",
"+",
"+",
"+def solve():",
"+ input = sys.stdin.readline",
"+ nameCount = [0] * 5",
"+ N = int(eval(input()))",
"+ for _ in range(N):",
"+ s = input().strip(\"\\n\")",
"+ if s[0] == \"M\":",
"+ nameCount[0] += 1",
"+ elif s[0] == \"A\":",
"+ nameCount[1] += 1",
"+ elif s[0] == \"R\":",
"+ nameCount[2] += 1",
"+ elif s[0] == \"C\":",
"+ nameCount[3] += 1",
"+ elif s[0] == \"H\":",
"+ nameCount[4] += 1",
"+ else:",
"+ continue",
"+ Ans = 0",
"+ for i in range(3):",
"+ for j in range(i + 1, 4):",
"+ for k in range(j + 1, 5):",
"+ Ans += nameCount[i] * nameCount[j] * nameCount[k]",
"+ print(Ans)",
"+ return 0",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ solve()"
] | false | 0.051724 | 0.097816 | 0.528788 | [
"s914558478",
"s686865280"
] |
u729133443 | p03126 | python | s712031598 | s354840772 | 164 | 17 | 38,480 | 3,060 | Accepted | Accepted | 89.63 | I=lambda:list(map(int,input().split()))
n,m=I()
a=[]
for _ in[0]*n:a.extend(I()[1:])
print((sum(n==a.count(i+1)for i in range(m)))) | n,m=list(map(int,input().split()))
print((len(set.intersection(*[set(input().split()[1:])for _ in[0]*n])))) | 5 | 2 | 133 | 100 | I = lambda: list(map(int, input().split()))
n, m = I()
a = []
for _ in [0] * n:
a.extend(I()[1:])
print((sum(n == a.count(i + 1) for i in range(m))))
| n, m = list(map(int, input().split()))
print((len(set.intersection(*[set(input().split()[1:]) for _ in [0] * n]))))
| false | 60 | [
"-I = lambda: list(map(int, input().split()))",
"-n, m = I()",
"-a = []",
"-for _ in [0] * n:",
"- a.extend(I()[1:])",
"-print((sum(n == a.count(i + 1) for i in range(m))))",
"+n, m = list(map(int, input().split()))",
"+print((len(set.intersection(*[set(input().split()[1:]) for _ in [0] * n]))))"
] | false | 0.041311 | 0.037937 | 1.088942 | [
"s712031598",
"s354840772"
] |
u205561862 | p03003 | python | s953525088 | s088132672 | 1,952 | 380 | 702,464 | 76,636 | Accepted | Accepted | 80.53 | #!usr/bin/env python3
from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS():return list(map(list, sys.stdin.readline().split()))
def S(): return list(sys.stdin.readline())[:-1]
def IR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = I()
return l
def LIR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = LI()
return l
def SR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = S()
return l
def LSR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = LS()
return l
sys.setrecursionlimit(1000000)
mod = 1000000007
#A
def A():
x,n = LI()
if x < n:
print((0))
else:
print((10))
return
#B
def B():
n,x = LI()
l = LI()
d = 0
ans = 1
for i in range(n):
d += l[i]
if d <= x:
ans += 1
print(ans)
return
#C
def C():
w,h,x,y = LI()
ans = w*h/2
k = 0
if x == w/2 and y == h/2:
k = 1
print((ans,k))
return
#D
def D():
n,k = LI()
a = LI()
b = [a[i] for i in range(n)]
for i in range(n-1):
b[i+1] += b[i]
b.insert(0,0)
ans = 0
for l in range(n):
r = bisect.bisect_left(b,b[l]+k)
ans += n-r+1
print(ans)
return
#E
def E():
n,m = LI()
s = LI()
t = LI()
dp = [[0 for i in range(m+1)] for j in range(n+1)]
for i in range(n+1):
dp[i][0] = 1
for j in range(m+1):
dp[0][j] = 1
for i in range(1,n+1):
for j in range(1,m+1):
if s[i-1] == t[j-1]:
dp[i][j] += dp[i-1][j]+dp[i][j-1]
else:
dp[i][j] += dp[i-1][j]+dp[i][j-1]-dp[i-1][j-1]
if dp[i][j] >= mod:
dp[i][j] %= mod
print((dp[n][m]%mod))
return
#F
def F():
n = I()
x = [None for i in range(n)]
y = [None for i in range(n)]
f = [None for i in range(n)]
for i in range(n):
a,b,d = LS()
a = int(a)
b = int(b)
x[i] = a
y[i] = b
if d == "R":
f[i] = (1,0)
elif d == "L":
f[i] = (-1,0)
elif d == "U":
f[i] = (0,1)
else:
f[i] = (0,-1)
dx = max(x)-min(x)
dy = max(x)-min(y)
ans = dx*dy
if ans == 0:
print((0))
quit()
l = 0
r = 100000000
while r-l > 0.5:
m = (l+r)/2
px = [x[i]+f[i][0]*m for i in range(n)]
py = [y[i]+f[i][1]*m for i in range(n)]
dx = max(x)-min(x)
dy = max(x)-min(y)
if dx*dy < ans:
ans = dx*dy
return
#Solve
if __name__ == "__main__":
E()
| #!usr/bin/env python3
from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS():return list(map(list, sys.stdin.readline().split()))
def S(): return list(sys.stdin.readline())[:-1]
def IR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = I()
return l
def LIR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = LI()
return l
def SR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = S()
return l
def LSR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = LS()
return l
sys.setrecursionlimit(1000000)
mod = 1000000007
#A
def A():
x,n = LI()
if x < n:
print((0))
else:
print((10))
return
#B
def B():
n,x = LI()
l = LI()
d = 0
ans = 1
for i in range(n):
d += l[i]
if d <= x:
ans += 1
print(ans)
return
#C
def C():
w,h,x,y = LI()
ans = w*h/2
k = 0
if x == w/2 and y == h/2:
k = 1
print((ans,k))
return
#D
def D():
n,k = LI()
a = LI()
b = [a[i] for i in range(n)]
for i in range(n-1):
b[i+1] += b[i]
b.insert(0,0)
ans = 0
for l in range(n):
r = bisect.bisect_left(b,b[l]+k)
ans += n-r+1
print(ans)
return
#E
def E():
n,m = LI()
s = LI()
t = LI()
dp = [[0 for i in range(m+1)] for j in range(n+1)]
for i in range(n+1):
dp[i][0] = 1
for j in range(m+1):
dp[0][j] = 1
for i in range(1,n+1):
for j in range(1,m+1):
if s[i-1] == t[j-1]:
dp[i][j] += dp[i-1][j]+dp[i][j-1]
else:
dp[i][j] += dp[i-1][j]+dp[i][j-1]-dp[i-1][j-1]
if dp[i][j] >= mod or 0 > dp[i][j]:
dp[i][j] %= mod
print((dp[n][m]))
return
#F
def F():
n = I()
x = [None for i in range(n)]
y = [None for i in range(n)]
f = [None for i in range(n)]
for i in range(n):
a,b,d = LS()
a = int(a)
b = int(b)
x[i] = a
y[i] = b
if d == "R":
f[i] = (1,0)
elif d == "L":
f[i] = (-1,0)
elif d == "U":
f[i] = (0,1)
else:
f[i] = (0,-1)
dx = max(x)-min(x)
dy = max(x)-min(y)
ans = dx*dy
if ans == 0:
print((0))
quit()
l = 0
r = 100000000
while r-l > 0.5:
m = (l+r)/2
px = [x[i]+f[i][0]*m for i in range(n)]
py = [y[i]+f[i][1]*m for i in range(n)]
dx = max(x)-min(x)
dy = max(x)-min(y)
if dx*dy < ans:
ans = dx*dy
return
#Solve
if __name__ == "__main__":
E()
| 141 | 141 | 2,980 | 2,992 | #!usr/bin/env python3
from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI():
return list(map(int, sys.stdin.readline().split()))
def I():
return int(sys.stdin.readline())
def LS():
return list(map(list, sys.stdin.readline().split()))
def S():
return list(sys.stdin.readline())[:-1]
def IR(n):
l = [None for i in range(n)]
for i in range(n):
l[i] = I()
return l
def LIR(n):
l = [None for i in range(n)]
for i in range(n):
l[i] = LI()
return l
def SR(n):
l = [None for i in range(n)]
for i in range(n):
l[i] = S()
return l
def LSR(n):
l = [None for i in range(n)]
for i in range(n):
l[i] = LS()
return l
sys.setrecursionlimit(1000000)
mod = 1000000007
# A
def A():
x, n = LI()
if x < n:
print((0))
else:
print((10))
return
# B
def B():
n, x = LI()
l = LI()
d = 0
ans = 1
for i in range(n):
d += l[i]
if d <= x:
ans += 1
print(ans)
return
# C
def C():
w, h, x, y = LI()
ans = w * h / 2
k = 0
if x == w / 2 and y == h / 2:
k = 1
print((ans, k))
return
# D
def D():
n, k = LI()
a = LI()
b = [a[i] for i in range(n)]
for i in range(n - 1):
b[i + 1] += b[i]
b.insert(0, 0)
ans = 0
for l in range(n):
r = bisect.bisect_left(b, b[l] + k)
ans += n - r + 1
print(ans)
return
# E
def E():
n, m = LI()
s = LI()
t = LI()
dp = [[0 for i in range(m + 1)] for j in range(n + 1)]
for i in range(n + 1):
dp[i][0] = 1
for j in range(m + 1):
dp[0][j] = 1
for i in range(1, n + 1):
for j in range(1, m + 1):
if s[i - 1] == t[j - 1]:
dp[i][j] += dp[i - 1][j] + dp[i][j - 1]
else:
dp[i][j] += dp[i - 1][j] + dp[i][j - 1] - dp[i - 1][j - 1]
if dp[i][j] >= mod:
dp[i][j] %= mod
print((dp[n][m] % mod))
return
# F
def F():
n = I()
x = [None for i in range(n)]
y = [None for i in range(n)]
f = [None for i in range(n)]
for i in range(n):
a, b, d = LS()
a = int(a)
b = int(b)
x[i] = a
y[i] = b
if d == "R":
f[i] = (1, 0)
elif d == "L":
f[i] = (-1, 0)
elif d == "U":
f[i] = (0, 1)
else:
f[i] = (0, -1)
dx = max(x) - min(x)
dy = max(x) - min(y)
ans = dx * dy
if ans == 0:
print((0))
quit()
l = 0
r = 100000000
while r - l > 0.5:
m = (l + r) / 2
px = [x[i] + f[i][0] * m for i in range(n)]
py = [y[i] + f[i][1] * m for i in range(n)]
dx = max(x) - min(x)
dy = max(x) - min(y)
if dx * dy < ans:
ans = dx * dy
return
# Solve
if __name__ == "__main__":
E()
| #!usr/bin/env python3
from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI():
return list(map(int, sys.stdin.readline().split()))
def I():
return int(sys.stdin.readline())
def LS():
return list(map(list, sys.stdin.readline().split()))
def S():
return list(sys.stdin.readline())[:-1]
def IR(n):
l = [None for i in range(n)]
for i in range(n):
l[i] = I()
return l
def LIR(n):
l = [None for i in range(n)]
for i in range(n):
l[i] = LI()
return l
def SR(n):
l = [None for i in range(n)]
for i in range(n):
l[i] = S()
return l
def LSR(n):
l = [None for i in range(n)]
for i in range(n):
l[i] = LS()
return l
sys.setrecursionlimit(1000000)
mod = 1000000007
# A
def A():
x, n = LI()
if x < n:
print((0))
else:
print((10))
return
# B
def B():
n, x = LI()
l = LI()
d = 0
ans = 1
for i in range(n):
d += l[i]
if d <= x:
ans += 1
print(ans)
return
# C
def C():
w, h, x, y = LI()
ans = w * h / 2
k = 0
if x == w / 2 and y == h / 2:
k = 1
print((ans, k))
return
# D
def D():
n, k = LI()
a = LI()
b = [a[i] for i in range(n)]
for i in range(n - 1):
b[i + 1] += b[i]
b.insert(0, 0)
ans = 0
for l in range(n):
r = bisect.bisect_left(b, b[l] + k)
ans += n - r + 1
print(ans)
return
# E
def E():
n, m = LI()
s = LI()
t = LI()
dp = [[0 for i in range(m + 1)] for j in range(n + 1)]
for i in range(n + 1):
dp[i][0] = 1
for j in range(m + 1):
dp[0][j] = 1
for i in range(1, n + 1):
for j in range(1, m + 1):
if s[i - 1] == t[j - 1]:
dp[i][j] += dp[i - 1][j] + dp[i][j - 1]
else:
dp[i][j] += dp[i - 1][j] + dp[i][j - 1] - dp[i - 1][j - 1]
if dp[i][j] >= mod or 0 > dp[i][j]:
dp[i][j] %= mod
print((dp[n][m]))
return
# F
def F():
n = I()
x = [None for i in range(n)]
y = [None for i in range(n)]
f = [None for i in range(n)]
for i in range(n):
a, b, d = LS()
a = int(a)
b = int(b)
x[i] = a
y[i] = b
if d == "R":
f[i] = (1, 0)
elif d == "L":
f[i] = (-1, 0)
elif d == "U":
f[i] = (0, 1)
else:
f[i] = (0, -1)
dx = max(x) - min(x)
dy = max(x) - min(y)
ans = dx * dy
if ans == 0:
print((0))
quit()
l = 0
r = 100000000
while r - l > 0.5:
m = (l + r) / 2
px = [x[i] + f[i][0] * m for i in range(n)]
py = [y[i] + f[i][1] * m for i in range(n)]
dx = max(x) - min(x)
dy = max(x) - min(y)
if dx * dy < ans:
ans = dx * dy
return
# Solve
if __name__ == "__main__":
E()
| false | 0 | [
"- if dp[i][j] >= mod:",
"+ if dp[i][j] >= mod or 0 > dp[i][j]:",
"- print((dp[n][m] % mod))",
"+ print((dp[n][m]))"
] | false | 0.086267 | 0.036566 | 2.359244 | [
"s953525088",
"s088132672"
] |
u191874006 | p03308 | python | s383579393 | s722870842 | 148 | 18 | 12,500 | 2,940 | Accepted | Accepted | 87.84 | #!/usr/bin/env python3
import numpy as np
import math
import re
n = int(eval(input()))
a = eval(input())
a = re.split(" ",a)
max = 0
min = 10**9
for i in range(n):
if(int(a[i]) > max):
max = int(a[i])
if(int(a[i]) < min):
min = int(a[i])
print((max - min)) | #!/usr/bin/env python3
#ABC102 B
N = int(eval(input()))
A = list(map(int,input().split()))
ans = 0
for i in range(1,N):
for j in range(i):
if ans < abs(A[i]-A[j]):
ans = abs(A[i]-A[j])
print(ans)
| 16 | 12 | 282 | 227 | #!/usr/bin/env python3
import numpy as np
import math
import re
n = int(eval(input()))
a = eval(input())
a = re.split(" ", a)
max = 0
min = 10**9
for i in range(n):
if int(a[i]) > max:
max = int(a[i])
if int(a[i]) < min:
min = int(a[i])
print((max - min))
| #!/usr/bin/env python3
# ABC102 B
N = int(eval(input()))
A = list(map(int, input().split()))
ans = 0
for i in range(1, N):
for j in range(i):
if ans < abs(A[i] - A[j]):
ans = abs(A[i] - A[j])
print(ans)
| false | 25 | [
"-import numpy as np",
"-import math",
"-import re",
"-",
"-n = int(eval(input()))",
"-a = eval(input())",
"-a = re.split(\" \", a)",
"-max = 0",
"-min = 10**9",
"-for i in range(n):",
"- if int(a[i]) > max:",
"- max = int(a[i])",
"- if int(a[i]) < min:",
"- min = int(a[i])",
"-print((max - min))",
"+# ABC102 B",
"+N = int(eval(input()))",
"+A = list(map(int, input().split()))",
"+ans = 0",
"+for i in range(1, N):",
"+ for j in range(i):",
"+ if ans < abs(A[i] - A[j]):",
"+ ans = abs(A[i] - A[j])",
"+print(ans)"
] | false | 0.051427 | 0.046833 | 1.098094 | [
"s383579393",
"s722870842"
] |
u077291787 | p03163 | python | s300593497 | s111944746 | 732 | 239 | 127,672 | 39,664 | Accepted | Accepted | 67.35 | # D - Knapsack 1
from collections import defaultdict
def main():
N, W, *WV = list(map(int, open(0).read().split()))
dp = defaultdict(int)
dp[0] = 0
for w, v in zip(*[iter(WV)] * 2):
for cur_w, cur_v in tuple(dp.items()):
if w + cur_w <= W:
dp[w + cur_w] = max(dp[w + cur_w], v + cur_v)
print((max(dp.values())))
if __name__ == "__main__":
main()
| # D - Knapsack 1
def solve_knapsack(weight_limit: int, weights: list, values: list) -> int:
dp = [0] * (weight_limit + 1) # dp[i] := optimum value at weight i
for w, v in zip(weights, values):
for cur_w in range(weight_limit, w - 1, -1):
dp[cur_w] = max(dp[cur_w], dp[cur_w - w] + v)
return dp[-1]
def main():
N, W, *WV = list(map(int, open(0).read().split()))
print((solve_knapsack(W, WV[::2], WV[1::2])))
if __name__ == "__main__":
main()
| 17 | 16 | 418 | 497 | # D - Knapsack 1
from collections import defaultdict
def main():
N, W, *WV = list(map(int, open(0).read().split()))
dp = defaultdict(int)
dp[0] = 0
for w, v in zip(*[iter(WV)] * 2):
for cur_w, cur_v in tuple(dp.items()):
if w + cur_w <= W:
dp[w + cur_w] = max(dp[w + cur_w], v + cur_v)
print((max(dp.values())))
if __name__ == "__main__":
main()
| # D - Knapsack 1
def solve_knapsack(weight_limit: int, weights: list, values: list) -> int:
dp = [0] * (weight_limit + 1) # dp[i] := optimum value at weight i
for w, v in zip(weights, values):
for cur_w in range(weight_limit, w - 1, -1):
dp[cur_w] = max(dp[cur_w], dp[cur_w - w] + v)
return dp[-1]
def main():
N, W, *WV = list(map(int, open(0).read().split()))
print((solve_knapsack(W, WV[::2], WV[1::2])))
if __name__ == "__main__":
main()
| false | 5.882353 | [
"-from collections import defaultdict",
"+def solve_knapsack(weight_limit: int, weights: list, values: list) -> int:",
"+ dp = [0] * (weight_limit + 1) # dp[i] := optimum value at weight i",
"+ for w, v in zip(weights, values):",
"+ for cur_w in range(weight_limit, w - 1, -1):",
"+ dp[cur_w] = max(dp[cur_w], dp[cur_w - w] + v)",
"+ return dp[-1]",
"- dp = defaultdict(int)",
"- dp[0] = 0",
"- for w, v in zip(*[iter(WV)] * 2):",
"- for cur_w, cur_v in tuple(dp.items()):",
"- if w + cur_w <= W:",
"- dp[w + cur_w] = max(dp[w + cur_w], v + cur_v)",
"- print((max(dp.values())))",
"+ print((solve_knapsack(W, WV[::2], WV[1::2])))"
] | false | 0.062429 | 0.234944 | 0.265719 | [
"s300593497",
"s111944746"
] |
u087295942 | p02554 | python | s257786786 | s779916878 | 1,104 | 398 | 12,776 | 11,160 | Accepted | Accepted | 63.95 | # coding:UTF-8
import sys
def pow_r(x, n):
if n == 0:
return 1
if n % 2 == 0:
return pow_r(x ** 2, n //2)
else:
return x * pow_r(x ** 2, (n - 1) // 2)
if __name__ == '__main__':
# ------ 入力 ------#
# 1行入力
n = int(eval(input())) # 数字
# a = input() # 文字列
# a = list(map(int, input().split())) # スペース区切り連続数字
# a = input().split() # スペース区切り連続文字列
# a = [int(c) for c in input()] # 数字→単数字リスト変換
# 定数行入力
# x = 5
# a = [int(input()) for _ in range(x)] # 数字
# a = [input() for _ in range(x)] # 文字
# a = [list(map(int, input().split())) for _ in range(x)] # スペース区切り連続数字(行列)
# a = [input().split() for _ in range(x)] # スペース区切り連続文字
# a = [[int(c) for c in input()] for _ in range(x)] # 数字→単数字リスト変換(行列)
# スペース区切り連続 数字、文字列複合
# a = []
# for _ in range(x):
# aa, bb = input().split()
# a.append((int(aa), bb))
# ------ 処理 ------#
S = pow_r(10, n)
M = pow_r(9, n)
M2 = pow_r(8, n)
out = (S - (M + M - M2)) % (1000000000 + 7)
# ------ 出力 ------#
print(("{}".format(out)))
| # coding:UTF-8
import sys
def pow_r(x, n):
if n == 0:
return 1
if n % 2 == 0:
return pow_r(x ** 2, n //2)
else:
return x * pow_r(x ** 2, (n - 1) // 2)
if __name__ == '__main__':
# ------ 入力 ------#
# 1行入力
n = int(eval(input())) # 数字
# a = input() # 文字列
# a = list(map(int, input().split())) # スペース区切り連続数字
# a = input().split() # スペース区切り連続文字列
# a = [int(c) for c in input()] # 数字→単数字リスト変換
# 定数行入力
# x = 5
# a = [int(input()) for _ in range(x)] # 数字
# a = [input() for _ in range(x)] # 文字
# a = [list(map(int, input().split())) for _ in range(x)] # スペース区切り連続数字(行列)
# a = [input().split() for _ in range(x)] # スペース区切り連続文字
# a = [[int(c) for c in input()] for _ in range(x)] # 数字→単数字リスト変換(行列)
# スペース区切り連続 数字、文字列複合
# a = []
# for _ in range(x):
# aa, bb = input().split()
# a.append((int(aa), bb))
# ------ 処理 ------#
S = pow(10, n)
M = pow(9, n)
M2 = pow(8, n)
out = (S - (M + M - M2)) % (1000000000 + 7)
# ------ 出力 ------#
print(("{}".format(out)))
| 44 | 44 | 1,170 | 1,164 | # coding:UTF-8
import sys
def pow_r(x, n):
if n == 0:
return 1
if n % 2 == 0:
return pow_r(x**2, n // 2)
else:
return x * pow_r(x**2, (n - 1) // 2)
if __name__ == "__main__":
# ------ 入力 ------#
# 1行入力
n = int(eval(input())) # 数字
# a = input() # 文字列
# a = list(map(int, input().split())) # スペース区切り連続数字
# a = input().split() # スペース区切り連続文字列
# a = [int(c) for c in input()] # 数字→単数字リスト変換
# 定数行入力
# x = 5
# a = [int(input()) for _ in range(x)] # 数字
# a = [input() for _ in range(x)] # 文字
# a = [list(map(int, input().split())) for _ in range(x)] # スペース区切り連続数字(行列)
# a = [input().split() for _ in range(x)] # スペース区切り連続文字
# a = [[int(c) for c in input()] for _ in range(x)] # 数字→単数字リスト変換(行列)
# スペース区切り連続 数字、文字列複合
# a = []
# for _ in range(x):
# aa, bb = input().split()
# a.append((int(aa), bb))
# ------ 処理 ------#
S = pow_r(10, n)
M = pow_r(9, n)
M2 = pow_r(8, n)
out = (S - (M + M - M2)) % (1000000000 + 7)
# ------ 出力 ------#
print(("{}".format(out)))
| # coding:UTF-8
import sys
def pow_r(x, n):
if n == 0:
return 1
if n % 2 == 0:
return pow_r(x**2, n // 2)
else:
return x * pow_r(x**2, (n - 1) // 2)
if __name__ == "__main__":
# ------ 入力 ------#
# 1行入力
n = int(eval(input())) # 数字
# a = input() # 文字列
# a = list(map(int, input().split())) # スペース区切り連続数字
# a = input().split() # スペース区切り連続文字列
# a = [int(c) for c in input()] # 数字→単数字リスト変換
# 定数行入力
# x = 5
# a = [int(input()) for _ in range(x)] # 数字
# a = [input() for _ in range(x)] # 文字
# a = [list(map(int, input().split())) for _ in range(x)] # スペース区切り連続数字(行列)
# a = [input().split() for _ in range(x)] # スペース区切り連続文字
# a = [[int(c) for c in input()] for _ in range(x)] # 数字→単数字リスト変換(行列)
# スペース区切り連続 数字、文字列複合
# a = []
# for _ in range(x):
# aa, bb = input().split()
# a.append((int(aa), bb))
# ------ 処理 ------#
S = pow(10, n)
M = pow(9, n)
M2 = pow(8, n)
out = (S - (M + M - M2)) % (1000000000 + 7)
# ------ 出力 ------#
print(("{}".format(out)))
| false | 0 | [
"- S = pow_r(10, n)",
"- M = pow_r(9, n)",
"- M2 = pow_r(8, n)",
"+ S = pow(10, n)",
"+ M = pow(9, n)",
"+ M2 = pow(8, n)"
] | false | 0.37626 | 0.090671 | 4.149725 | [
"s257786786",
"s779916878"
] |
u281303342 | p03147 | python | s594409527 | s487473101 | 20 | 18 | 3,060 | 3,064 | Accepted | Accepted | 10 | N = int(eval(input()))
H = list(map(int,input().split()))
ans = 0
st = "0"
while H!=[0]*N:
for i in range(N):
if H[i]>0:
st = "+"
H[i] -= 1
elif st=="+" and H[i]==0:
st = "0"
ans += 1
if st=="+":
ans += 1
st = "0"
print(ans)
| # Python3 (3.4.3)
import sys
input = sys.stdin.readline
# -------------------------------------------------------------
# function
# -------------------------------------------------------------
# -------------------------------------------------------------
# main
# -------------------------------------------------------------
N = int(eval(input()))
H = list(map(int,input().split()))
ans = 0
x = [H]
while len(x) > 0:
A = x.pop()
minA = min(A)
k = A.index(minA)
for i in range(len(A)):
A[i] -= minA
ans += minA
if A[0:k] != []:
x.append(A[0:k])
if A[k+1:] != []:
x.append(A[k+1:])
print(ans) | 21 | 31 | 328 | 677 | N = int(eval(input()))
H = list(map(int, input().split()))
ans = 0
st = "0"
while H != [0] * N:
for i in range(N):
if H[i] > 0:
st = "+"
H[i] -= 1
elif st == "+" and H[i] == 0:
st = "0"
ans += 1
if st == "+":
ans += 1
st = "0"
print(ans)
| # Python3 (3.4.3)
import sys
input = sys.stdin.readline
# -------------------------------------------------------------
# function
# -------------------------------------------------------------
# -------------------------------------------------------------
# main
# -------------------------------------------------------------
N = int(eval(input()))
H = list(map(int, input().split()))
ans = 0
x = [H]
while len(x) > 0:
A = x.pop()
minA = min(A)
k = A.index(minA)
for i in range(len(A)):
A[i] -= minA
ans += minA
if A[0:k] != []:
x.append(A[0:k])
if A[k + 1 :] != []:
x.append(A[k + 1 :])
print(ans)
| false | 32.258065 | [
"+# Python3 (3.4.3)",
"+import sys",
"+",
"+input = sys.stdin.readline",
"+# function",
"+# main",
"-st = \"0\"",
"-while H != [0] * N:",
"- for i in range(N):",
"- if H[i] > 0:",
"- st = \"+\"",
"- H[i] -= 1",
"- elif st == \"+\" and H[i] == 0:",
"- st = \"0\"",
"- ans += 1",
"- if st == \"+\":",
"- ans += 1",
"- st = \"0\"",
"+x = [H]",
"+while len(x) > 0:",
"+ A = x.pop()",
"+ minA = min(A)",
"+ k = A.index(minA)",
"+ for i in range(len(A)):",
"+ A[i] -= minA",
"+ ans += minA",
"+ if A[0:k] != []:",
"+ x.append(A[0:k])",
"+ if A[k + 1 :] != []:",
"+ x.append(A[k + 1 :])"
] | false | 0.04649 | 0.046905 | 0.991138 | [
"s594409527",
"s487473101"
] |
u052075394 | p03125 | python | s593957777 | s430586620 | 12 | 10 | 2,568 | 2,568 | Accepted | Accepted | 16.67 | A, B = list(map(int, input().split()))
if B % A == 0: print(str(A+B))
else: print(str(B-A))
| A, B = list(map(int, input().split()))
if B % A == 0: print((A+B))
else: print((B-A)) | 6 | 4 | 102 | 85 | A, B = list(map(int, input().split()))
if B % A == 0:
print(str(A + B))
else:
print(str(B - A))
| A, B = list(map(int, input().split()))
if B % A == 0:
print((A + B))
else:
print((B - A))
| false | 33.333333 | [
"- print(str(A + B))",
"+ print((A + B))",
"- print(str(B - A))",
"+ print((B - A))"
] | false | 0.037569 | 0.041122 | 0.913594 | [
"s593957777",
"s430586620"
] |
u349724238 | p02820 | python | s546161855 | s903007611 | 330 | 200 | 66,028 | 53,104 | Accepted | Accepted | 39.39 | N,K = list(map(int, input().split()))
R,S,P = list(map(int, input().split()))
T = eval(input())
L = [[] for _ in range(K)]
for i in range(N):
j = i % K
L[j].append(T[i])
ans = 0
for i in range(K):
for j in range(len(L[i])-1):
if L[i][j] == L[i][j+1]:
L[i][j+1] = 0
if L[i][j] == 'r':
L[i][j] = P
if L[i][j] == 's':
L[i][j] = R
if L[i][j] == 'p':
L[i][j] = S
if L[i][-1] == 'r':
L[i][-1] = P
elif L[i][-1] == 's':
L[i][-1] = R
elif L[i][-1] == 'p':
L[i][-1] = S
ans += sum(L[i])
print(ans) | N,K = list(map(int, input().split()))
R,S,P = list(map(int, input().split()))
T = eval(input())
L = []
for i in range(N):
L.append(T[i])
for i in range(N-K):
if L[i] == L[i+K]:
L[i+K] = 0
for i in range(N):
if L[i] == 'r':
L[i] = P
elif L[i] == 's':
L[i] = R
elif L[i] == 'p':
L[i] = S
print((sum(L))) | 26 | 17 | 627 | 349 | N, K = list(map(int, input().split()))
R, S, P = list(map(int, input().split()))
T = eval(input())
L = [[] for _ in range(K)]
for i in range(N):
j = i % K
L[j].append(T[i])
ans = 0
for i in range(K):
for j in range(len(L[i]) - 1):
if L[i][j] == L[i][j + 1]:
L[i][j + 1] = 0
if L[i][j] == "r":
L[i][j] = P
if L[i][j] == "s":
L[i][j] = R
if L[i][j] == "p":
L[i][j] = S
if L[i][-1] == "r":
L[i][-1] = P
elif L[i][-1] == "s":
L[i][-1] = R
elif L[i][-1] == "p":
L[i][-1] = S
ans += sum(L[i])
print(ans)
| N, K = list(map(int, input().split()))
R, S, P = list(map(int, input().split()))
T = eval(input())
L = []
for i in range(N):
L.append(T[i])
for i in range(N - K):
if L[i] == L[i + K]:
L[i + K] = 0
for i in range(N):
if L[i] == "r":
L[i] = P
elif L[i] == "s":
L[i] = R
elif L[i] == "p":
L[i] = S
print((sum(L)))
| false | 34.615385 | [
"-L = [[] for _ in range(K)]",
"+L = []",
"- j = i % K",
"- L[j].append(T[i])",
"-ans = 0",
"-for i in range(K):",
"- for j in range(len(L[i]) - 1):",
"- if L[i][j] == L[i][j + 1]:",
"- L[i][j + 1] = 0",
"- if L[i][j] == \"r\":",
"- L[i][j] = P",
"- if L[i][j] == \"s\":",
"- L[i][j] = R",
"- if L[i][j] == \"p\":",
"- L[i][j] = S",
"- if L[i][-1] == \"r\":",
"- L[i][-1] = P",
"- elif L[i][-1] == \"s\":",
"- L[i][-1] = R",
"- elif L[i][-1] == \"p\":",
"- L[i][-1] = S",
"- ans += sum(L[i])",
"-print(ans)",
"+ L.append(T[i])",
"+for i in range(N - K):",
"+ if L[i] == L[i + K]:",
"+ L[i + K] = 0",
"+for i in range(N):",
"+ if L[i] == \"r\":",
"+ L[i] = P",
"+ elif L[i] == \"s\":",
"+ L[i] = R",
"+ elif L[i] == \"p\":",
"+ L[i] = S",
"+print((sum(L)))"
] | false | 0.035609 | 0.035488 | 1.003412 | [
"s546161855",
"s903007611"
] |
u130900604 | p02660 | python | s370025285 | s895912189 | 122 | 83 | 76,720 | 66,272 | Accepted | Accepted | 31.97 | def LI():return list(map(int,input().split()))
def yes():return print("Yes")
def no():return print("No")
from collections import deque, defaultdict, Counter
# from heapq import heappop, heappush
# import math
# from decimal import Decimal
# def divisors(x):
# ret=[]
# for i in range(1,int(x**.5)+1):
# if x%i==0:
# ret.append(i)
# if x//i==i:continue
# ret.append(x//i)
# return sorted(ret)
# print(divisors(64),2**6)
def prime_factor(n):
ass = []
for i in range(2,int(n**0.5)+1):
while n % i==0:
ass.append(i)
n = n//i
if n != 1:
ass.append(n)
return ass
n=int(input())
pf=prime_factor(n)
pf=Counter(pf)
# print(pf)
def cng(x):
le=2*x
ret=-1
mi=int(le**0.5)
for i in range(mi-1,mi+10000):
# print((i+1)*(i+2),le,i*(i+1))
if (i+1)*(i+2)>le>=i*(i+1):
ret=i
# print((i+1)*(i+2),le,i*(i+1))
break
return ret
mp=[]
for i in range(2*10**5):
mp.append(cng(i))
# print(-1 in mp)
ans=0
for i in pf.values():
ans+=mp[i]
print(ans)
| a=[]
for i in range(51):
a+=[i]*(i+1)
def prime_factor(n):
ass=[]
for i in range(2,int(n**0.5)+1):
while n%i==0:
ass.append(i)
n=n//i
if n!=1:
ass.append(n)
return ass
from collections import Counter
c=Counter(prime_factor(int(eval(input()))))
ans=0
for i in list(c.values()):
ans+=a[i]
print(ans) | 59 | 20 | 1,211 | 374 | def LI():
return list(map(int, input().split()))
def yes():
return print("Yes")
def no():
return print("No")
from collections import deque, defaultdict, Counter
# from heapq import heappop, heappush
# import math
# from decimal import Decimal
# def divisors(x):
# ret=[]
# for i in range(1,int(x**.5)+1):
# if x%i==0:
# ret.append(i)
# if x//i==i:continue
# ret.append(x//i)
# return sorted(ret)
# print(divisors(64),2**6)
def prime_factor(n):
ass = []
for i in range(2, int(n**0.5) + 1):
while n % i == 0:
ass.append(i)
n = n // i
if n != 1:
ass.append(n)
return ass
n = int(input())
pf = prime_factor(n)
pf = Counter(pf)
# print(pf)
def cng(x):
le = 2 * x
ret = -1
mi = int(le**0.5)
for i in range(mi - 1, mi + 10000):
# print((i+1)*(i+2),le,i*(i+1))
if (i + 1) * (i + 2) > le >= i * (i + 1):
ret = i
# print((i+1)*(i+2),le,i*(i+1))
break
return ret
mp = []
for i in range(2 * 10**5):
mp.append(cng(i))
# print(-1 in mp)
ans = 0
for i in pf.values():
ans += mp[i]
print(ans)
| a = []
for i in range(51):
a += [i] * (i + 1)
def prime_factor(n):
ass = []
for i in range(2, int(n**0.5) + 1):
while n % i == 0:
ass.append(i)
n = n // i
if n != 1:
ass.append(n)
return ass
from collections import Counter
c = Counter(prime_factor(int(eval(input()))))
ans = 0
for i in list(c.values()):
ans += a[i]
print(ans)
| false | 66.101695 | [
"-def LI():",
"- return list(map(int, input().split()))",
"+a = []",
"+for i in range(51):",
"+ a += [i] * (i + 1)",
"-def yes():",
"- return print(\"Yes\")",
"-",
"-",
"-def no():",
"- return print(\"No\")",
"-",
"-",
"-from collections import deque, defaultdict, Counter",
"-",
"-# from heapq import heappop, heappush",
"-# import math",
"-# from decimal import Decimal",
"-# def divisors(x):",
"-# ret=[]",
"-# for i in range(1,int(x**.5)+1):",
"-# if x%i==0:",
"-# ret.append(i)",
"-# if x//i==i:continue",
"-# ret.append(x//i)",
"-# return sorted(ret)",
"-# print(divisors(64),2**6)",
"-n = int(input())",
"-pf = prime_factor(n)",
"-pf = Counter(pf)",
"-# print(pf)",
"-def cng(x):",
"- le = 2 * x",
"- ret = -1",
"- mi = int(le**0.5)",
"- for i in range(mi - 1, mi + 10000):",
"- # print((i+1)*(i+2),le,i*(i+1))",
"- if (i + 1) * (i + 2) > le >= i * (i + 1):",
"- ret = i",
"- # print((i+1)*(i+2),le,i*(i+1))",
"- break",
"- return ret",
"+from collections import Counter",
"-",
"-mp = []",
"-for i in range(2 * 10**5):",
"- mp.append(cng(i))",
"-# print(-1 in mp)",
"+c = Counter(prime_factor(int(eval(input()))))",
"-for i in pf.values():",
"- ans += mp[i]",
"+for i in list(c.values()):",
"+ ans += a[i]"
] | false | 0.789379 | 0.050171 | 15.733682 | [
"s370025285",
"s895912189"
] |
u119148115 | p04006 | python | s230817028 | s604370727 | 231 | 114 | 69,684 | 69,416 | Accepted | Accepted | 50.65 | import sys
from copy import deepcopy
sys.setrecursionlimit(10**7)
def I(): return int(sys.stdin.readline().rstrip())
def MI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LI(): return list(map(int,sys.stdin.readline().rstrip().split())) #空白あり
def LI2(): return list(map(int,sys.stdin.readline().rstrip())) #空白なし
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split()) #空白あり
def LS2(): return list(sys.stdin.readline().rstrip()) #空白なし
N,x = MI()
A = LI()
B = deepcopy(A)
A += A
ans = sum(B)
for k in range(1,N+1):
for i in range(N):
B[i] = min(B[i],A[N+i-k])
ans = min(ans,sum(B)+k*x)
print(ans)
| import sys
from copy import deepcopy
def MI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LI(): return list(map(int,sys.stdin.readline().rstrip().split())) #空白あり
N,x = MI()
A = LI()
B = deepcopy(A)
A += A
ans = sum(B)
for k in range(1,N+1): # 魔法を k 回唱える
for i in range(N):
B[i] = min(B[i],A[N+i-k])
ans = min(ans,sum(B)+k*x)
print(ans)
| 24 | 18 | 707 | 390 | import sys
from copy import deepcopy
sys.setrecursionlimit(10**7)
def I():
return int(sys.stdin.readline().rstrip())
def MI():
return list(map(int, sys.stdin.readline().rstrip().split()))
def LI():
return list(map(int, sys.stdin.readline().rstrip().split())) # 空白あり
def LI2():
return list(map(int, sys.stdin.readline().rstrip())) # 空白なし
def S():
return sys.stdin.readline().rstrip()
def LS():
return list(sys.stdin.readline().rstrip().split()) # 空白あり
def LS2():
return list(sys.stdin.readline().rstrip()) # 空白なし
N, x = MI()
A = LI()
B = deepcopy(A)
A += A
ans = sum(B)
for k in range(1, N + 1):
for i in range(N):
B[i] = min(B[i], A[N + i - k])
ans = min(ans, sum(B) + k * x)
print(ans)
| import sys
from copy import deepcopy
def MI():
return list(map(int, sys.stdin.readline().rstrip().split()))
def LI():
return list(map(int, sys.stdin.readline().rstrip().split())) # 空白あり
N, x = MI()
A = LI()
B = deepcopy(A)
A += A
ans = sum(B)
for k in range(1, N + 1): # 魔法を k 回唱える
for i in range(N):
B[i] = min(B[i], A[N + i - k])
ans = min(ans, sum(B) + k * x)
print(ans)
| false | 25 | [
"-",
"-sys.setrecursionlimit(10**7)",
"-",
"-",
"-def I():",
"- return int(sys.stdin.readline().rstrip())",
"-def LI2():",
"- return list(map(int, sys.stdin.readline().rstrip())) # 空白なし",
"-",
"-",
"-def S():",
"- return sys.stdin.readline().rstrip()",
"-",
"-",
"-def LS():",
"- return list(sys.stdin.readline().rstrip().split()) # 空白あり",
"-",
"-",
"-def LS2():",
"- return list(sys.stdin.readline().rstrip()) # 空白なし",
"-",
"-",
"-for k in range(1, N + 1):",
"+for k in range(1, N + 1): # 魔法を k 回唱える"
] | false | 0.076347 | 0.048705 | 1.567549 | [
"s230817028",
"s604370727"
] |
u761320129 | p03305 | python | s234399030 | s813208925 | 1,471 | 1,300 | 65,604 | 74,352 | Accepted | Accepted | 11.62 | import heapq
N,M,S,T = list(map(int,input().split()))
src = [tuple(map(int,input().split())) for i in range(M)]
S,T = S-1,T-1
INF = float('inf')
def dijkstra(is_yen):
g = [[] for i in range(N)]
for u,v,a,b in src:
u,v = u-1,v-1
c = a if is_yen else b
g[u].append((v,c))
g[v].append((u,c))
costs = [INF] * N
start = S if is_yen else T
costs[start] = 0
hq = [(0,start)]
heapq.heapify(hq)
while hq:
_,v = heapq.heappop(hq)
for to,c in g[v]:
if costs[v]+c >= costs[to]: continue
costs[to] = costs[v]+c
heapq.heappush(hq, (costs[to],to))
return costs
yens = dijkstra(1)
snuuks = dijkstra(0)
ans = [None] * N
ans[-1] = yens[-1] + snuuks[-1]
for i in reversed(list(range(N-1))):
ans[i] = min(ans[i+1], yens[i]+snuuks[i])
for a in ans:
print((10**15 - a)) | N,M,S,T = map(int,input().split())
S,T = S-1,T-1
UVAB = [tuple(map(int,input().split())) for i in range(M)]
es = [[] for _ in range(N)]
for u,v,a,b in UVAB:
u,v = u-1,v-1
es[u].append((v,a,b))
es[v].append((u,a,b))
import heapq
INF = float('inf')
ycost = [INF] * N
ycost[S] = 0
q = [(0,S)]
heapq.heapify(q)
while q:
c,v = heapq.heappop(q)
for to,a,b in es[v]:
if c+a >= ycost[to]: continue
ycost[to] = c+a
heapq.heappush(q, (c+a,to))
scost = [INF] * N
scost[T] = 0
q = [(0,T)]
heapq.heapify(q)
while q:
c,v = heapq.heappop(q)
for to,a,b in es[v]:
if c+b >= scost[to]: continue
scost[to] = c+b
heapq.heappush(q, (c+b,to))
a = 0
ans = []
for y,s in zip(ycost[::-1],scost[::-1]):
tmp = 10**15 -y -s
a = max(a, tmp)
ans.append(a)
print(*ans[::-1], sep='\n')
| 36 | 40 | 900 | 883 | import heapq
N, M, S, T = list(map(int, input().split()))
src = [tuple(map(int, input().split())) for i in range(M)]
S, T = S - 1, T - 1
INF = float("inf")
def dijkstra(is_yen):
g = [[] for i in range(N)]
for u, v, a, b in src:
u, v = u - 1, v - 1
c = a if is_yen else b
g[u].append((v, c))
g[v].append((u, c))
costs = [INF] * N
start = S if is_yen else T
costs[start] = 0
hq = [(0, start)]
heapq.heapify(hq)
while hq:
_, v = heapq.heappop(hq)
for to, c in g[v]:
if costs[v] + c >= costs[to]:
continue
costs[to] = costs[v] + c
heapq.heappush(hq, (costs[to], to))
return costs
yens = dijkstra(1)
snuuks = dijkstra(0)
ans = [None] * N
ans[-1] = yens[-1] + snuuks[-1]
for i in reversed(list(range(N - 1))):
ans[i] = min(ans[i + 1], yens[i] + snuuks[i])
for a in ans:
print((10**15 - a))
| N, M, S, T = map(int, input().split())
S, T = S - 1, T - 1
UVAB = [tuple(map(int, input().split())) for i in range(M)]
es = [[] for _ in range(N)]
for u, v, a, b in UVAB:
u, v = u - 1, v - 1
es[u].append((v, a, b))
es[v].append((u, a, b))
import heapq
INF = float("inf")
ycost = [INF] * N
ycost[S] = 0
q = [(0, S)]
heapq.heapify(q)
while q:
c, v = heapq.heappop(q)
for to, a, b in es[v]:
if c + a >= ycost[to]:
continue
ycost[to] = c + a
heapq.heappush(q, (c + a, to))
scost = [INF] * N
scost[T] = 0
q = [(0, T)]
heapq.heapify(q)
while q:
c, v = heapq.heappop(q)
for to, a, b in es[v]:
if c + b >= scost[to]:
continue
scost[to] = c + b
heapq.heappush(q, (c + b, to))
a = 0
ans = []
for y, s in zip(ycost[::-1], scost[::-1]):
tmp = 10**15 - y - s
a = max(a, tmp)
ans.append(a)
print(*ans[::-1], sep="\n")
| false | 10 | [
"+N, M, S, T = map(int, input().split())",
"+S, T = S - 1, T - 1",
"+UVAB = [tuple(map(int, input().split())) for i in range(M)]",
"+es = [[] for _ in range(N)]",
"+for u, v, a, b in UVAB:",
"+ u, v = u - 1, v - 1",
"+ es[u].append((v, a, b))",
"+ es[v].append((u, a, b))",
"-N, M, S, T = list(map(int, input().split()))",
"-src = [tuple(map(int, input().split())) for i in range(M)]",
"-S, T = S - 1, T - 1",
"-",
"-",
"-def dijkstra(is_yen):",
"- g = [[] for i in range(N)]",
"- for u, v, a, b in src:",
"- u, v = u - 1, v - 1",
"- c = a if is_yen else b",
"- g[u].append((v, c))",
"- g[v].append((u, c))",
"- costs = [INF] * N",
"- start = S if is_yen else T",
"- costs[start] = 0",
"- hq = [(0, start)]",
"- heapq.heapify(hq)",
"- while hq:",
"- _, v = heapq.heappop(hq)",
"- for to, c in g[v]:",
"- if costs[v] + c >= costs[to]:",
"- continue",
"- costs[to] = costs[v] + c",
"- heapq.heappush(hq, (costs[to], to))",
"- return costs",
"-",
"-",
"-yens = dijkstra(1)",
"-snuuks = dijkstra(0)",
"-ans = [None] * N",
"-ans[-1] = yens[-1] + snuuks[-1]",
"-for i in reversed(list(range(N - 1))):",
"- ans[i] = min(ans[i + 1], yens[i] + snuuks[i])",
"-for a in ans:",
"- print((10**15 - a))",
"+ycost = [INF] * N",
"+ycost[S] = 0",
"+q = [(0, S)]",
"+heapq.heapify(q)",
"+while q:",
"+ c, v = heapq.heappop(q)",
"+ for to, a, b in es[v]:",
"+ if c + a >= ycost[to]:",
"+ continue",
"+ ycost[to] = c + a",
"+ heapq.heappush(q, (c + a, to))",
"+scost = [INF] * N",
"+scost[T] = 0",
"+q = [(0, T)]",
"+heapq.heapify(q)",
"+while q:",
"+ c, v = heapq.heappop(q)",
"+ for to, a, b in es[v]:",
"+ if c + b >= scost[to]:",
"+ continue",
"+ scost[to] = c + b",
"+ heapq.heappush(q, (c + b, to))",
"+a = 0",
"+ans = []",
"+for y, s in zip(ycost[::-1], scost[::-1]):",
"+ tmp = 10**15 - y - s",
"+ a = max(a, tmp)",
"+ ans.append(a)",
"+print(*ans[::-1], sep=\"\\n\")"
] | false | 0.035946 | 0.041539 | 0.865342 | [
"s234399030",
"s813208925"
] |
u284854859 | p03061 | python | s914279775 | s334055867 | 1,635 | 680 | 16,252 | 90,080 | Accepted | Accepted | 58.41 | def main():
import sys
from fractions import gcd
input = sys.stdin.readline
def init(init_val):
#set_val
for i in range(n):
seg[i+num-1]=init_val[i]
#built
for i in range(num-2,-1,-1) :
seg[i]=gcd(seg[2*i+1],seg[2*i+2])
def update(k,x):
k += num-1
seg[k] = x
while k+1:
k = (k-1)//2
seg[k] = gcd(seg[k*2+1],seg[k*2+2])
def query(p,q):
if q<=p:
return ide_ele
p += num-1
q += num-2
res=ide_ele
while q-p>1:
if p&1 == 0:
res = gcd(res,seg[p])
if q&1 == 1:
res = gcd(res,seg[q])
q -= 1
p = p//2
q = (q-1)//2
if p == q:
res = gcd(res,seg[p])
else:
res = gcd(gcd(res,seg[p]),seg[q])
return res
n = int(eval(input()))
a = tuple(map(int,input().split()))
#####単位元######
ide_ele = 0
#num:n以上の最小の2のべき乗
num =2**(n-1).bit_length()
seg=[ide_ele]*2*num
init(a)
ans = -1
for i in range(n):
ans = max(ans,gcd(query(0,i),query(i+1,n)))
print(ans)
if __name__ == '__main__':
main() | def main():
import sys
from fractions import gcd
input = sys.stdin.readline
def init(init_val):
#set_val
for i in range(n):
seg[i+num-1]=init_val[i]
#built
for i in range(num-2,-1,-1) :
seg[i]=gcd(seg[2*i+1],seg[2*i+2])
def update(k,x):
k += num-1
seg[k] = x
while k:
k = (k-1)//2
seg[k] = gcd(seg[k*2+1],seg[k*2+2])
def query(p,q):
if q<=p:
return ide_ele
p += num-1
q += num-2
res=ide_ele
while q-p>1:
if p&1 == 0:
res = gcd(res,seg[p])
if q&1 == 1:
res = gcd(res,seg[q])
q -= 1
p = p//2
q = (q-1)//2
if p == q:
res = gcd(res,seg[p])
else:
res = gcd(gcd(res,seg[p]),seg[q])
return res
n = int(eval(input()))
a = tuple(map(int,input().split()))
#####単位元######
ide_ele = 0
#num:n以上の最小の2のべき乗
num =2**(n-1).bit_length()
seg=[ide_ele]*2*num
init(a)
ans = -1
for i in range(n):
ans = max(ans,gcd(query(0,i),query(i+1,n)))
print(ans)
if __name__ == '__main__':
main() | 60 | 60 | 1,328 | 1,326 | def main():
import sys
from fractions import gcd
input = sys.stdin.readline
def init(init_val):
# set_val
for i in range(n):
seg[i + num - 1] = init_val[i]
# built
for i in range(num - 2, -1, -1):
seg[i] = gcd(seg[2 * i + 1], seg[2 * i + 2])
def update(k, x):
k += num - 1
seg[k] = x
while k + 1:
k = (k - 1) // 2
seg[k] = gcd(seg[k * 2 + 1], seg[k * 2 + 2])
def query(p, q):
if q <= p:
return ide_ele
p += num - 1
q += num - 2
res = ide_ele
while q - p > 1:
if p & 1 == 0:
res = gcd(res, seg[p])
if q & 1 == 1:
res = gcd(res, seg[q])
q -= 1
p = p // 2
q = (q - 1) // 2
if p == q:
res = gcd(res, seg[p])
else:
res = gcd(gcd(res, seg[p]), seg[q])
return res
n = int(eval(input()))
a = tuple(map(int, input().split()))
#####単位元######
ide_ele = 0
# num:n以上の最小の2のべき乗
num = 2 ** (n - 1).bit_length()
seg = [ide_ele] * 2 * num
init(a)
ans = -1
for i in range(n):
ans = max(ans, gcd(query(0, i), query(i + 1, n)))
print(ans)
if __name__ == "__main__":
main()
| def main():
import sys
from fractions import gcd
input = sys.stdin.readline
def init(init_val):
# set_val
for i in range(n):
seg[i + num - 1] = init_val[i]
# built
for i in range(num - 2, -1, -1):
seg[i] = gcd(seg[2 * i + 1], seg[2 * i + 2])
def update(k, x):
k += num - 1
seg[k] = x
while k:
k = (k - 1) // 2
seg[k] = gcd(seg[k * 2 + 1], seg[k * 2 + 2])
def query(p, q):
if q <= p:
return ide_ele
p += num - 1
q += num - 2
res = ide_ele
while q - p > 1:
if p & 1 == 0:
res = gcd(res, seg[p])
if q & 1 == 1:
res = gcd(res, seg[q])
q -= 1
p = p // 2
q = (q - 1) // 2
if p == q:
res = gcd(res, seg[p])
else:
res = gcd(gcd(res, seg[p]), seg[q])
return res
n = int(eval(input()))
a = tuple(map(int, input().split()))
#####単位元######
ide_ele = 0
# num:n以上の最小の2のべき乗
num = 2 ** (n - 1).bit_length()
seg = [ide_ele] * 2 * num
init(a)
ans = -1
for i in range(n):
ans = max(ans, gcd(query(0, i), query(i + 1, n)))
print(ans)
if __name__ == "__main__":
main()
| false | 0 | [
"- while k + 1:",
"+ while k:"
] | false | 0.052167 | 0.046666 | 1.117871 | [
"s914279775",
"s334055867"
] |
u359358631 | p02802 | python | s807798736 | s129586317 | 236 | 178 | 103,328 | 85,916 | Accepted | Accepted | 24.58 | def main():
n, m = list(map(int, input().split()))
ans_dict = dict() # {問題i : [ACしたかどうか、ACに関係なく累計WA数]}
for _ in range(m):
p, s = input().split()
if p not in ans_dict: # 初見の場合
if s == "AC": # 正解
ans_dict[p] = [1, 0]
else: # 不正解
ans_dict[p] = [0, 1]
else: # 初見じゃない場合
if ans_dict[p][0] == 1: # 正解済み
continue
else: # 未正解
if s == "AC":
ans_dict[p][0] = 1
else:
ans_dict[p][1] += 1
ac_count = 0
wa_count = 0
for item in list(ans_dict.items()):
if item[1][0] == 1: # 正解済み
ac_count += 1
wa_count += item[1][1]
print((ac_count, wa_count))
if __name__ == "__main__":
main()
| def main():
n, m = list(map(int, input().split()))
ac_list = [0 for _ in range(n + 1)] # 1: 正解済 0: 未正解
wa_list = [0 for _ in range(n + 1)]
for _ in range(m):
p, s = input().split()
p = int(p)
if ac_list[p] == 1: # 正解済
continue
if s == "AC":
ac_list[p] = 1
else:
wa_list[p] += 1
ac_count = 0
wa_count = 0
for i in range(1, n + 1):
if ac_list[i] == 1:
ac_count += 1
wa_count += wa_list[i]
print((ac_count, wa_count))
if __name__ == "__main__":
main()
| 33 | 29 | 844 | 629 | def main():
n, m = list(map(int, input().split()))
ans_dict = dict() # {問題i : [ACしたかどうか、ACに関係なく累計WA数]}
for _ in range(m):
p, s = input().split()
if p not in ans_dict: # 初見の場合
if s == "AC": # 正解
ans_dict[p] = [1, 0]
else: # 不正解
ans_dict[p] = [0, 1]
else: # 初見じゃない場合
if ans_dict[p][0] == 1: # 正解済み
continue
else: # 未正解
if s == "AC":
ans_dict[p][0] = 1
else:
ans_dict[p][1] += 1
ac_count = 0
wa_count = 0
for item in list(ans_dict.items()):
if item[1][0] == 1: # 正解済み
ac_count += 1
wa_count += item[1][1]
print((ac_count, wa_count))
if __name__ == "__main__":
main()
| def main():
n, m = list(map(int, input().split()))
ac_list = [0 for _ in range(n + 1)] # 1: 正解済 0: 未正解
wa_list = [0 for _ in range(n + 1)]
for _ in range(m):
p, s = input().split()
p = int(p)
if ac_list[p] == 1: # 正解済
continue
if s == "AC":
ac_list[p] = 1
else:
wa_list[p] += 1
ac_count = 0
wa_count = 0
for i in range(1, n + 1):
if ac_list[i] == 1:
ac_count += 1
wa_count += wa_list[i]
print((ac_count, wa_count))
if __name__ == "__main__":
main()
| false | 12.121212 | [
"- ans_dict = dict() # {問題i : [ACしたかどうか、ACに関係なく累計WA数]}",
"+ ac_list = [0 for _ in range(n + 1)] # 1: 正解済 0: 未正解",
"+ wa_list = [0 for _ in range(n + 1)]",
"- if p not in ans_dict: # 初見の場合",
"- if s == \"AC\": # 正解",
"- ans_dict[p] = [1, 0]",
"- else: # 不正解",
"- ans_dict[p] = [0, 1]",
"- else: # 初見じゃない場合",
"- if ans_dict[p][0] == 1: # 正解済み",
"- continue",
"- else: # 未正解",
"- if s == \"AC\":",
"- ans_dict[p][0] = 1",
"- else:",
"- ans_dict[p][1] += 1",
"+ p = int(p)",
"+ if ac_list[p] == 1: # 正解済",
"+ continue",
"+ if s == \"AC\":",
"+ ac_list[p] = 1",
"+ else:",
"+ wa_list[p] += 1",
"- for item in list(ans_dict.items()):",
"- if item[1][0] == 1: # 正解済み",
"+ for i in range(1, n + 1):",
"+ if ac_list[i] == 1:",
"- wa_count += item[1][1]",
"+ wa_count += wa_list[i]"
] | false | 0.060357 | 0.051368 | 1.174993 | [
"s807798736",
"s129586317"
] |
u403301154 | p03033 | python | s627962305 | s000010590 | 1,946 | 1,743 | 74,252 | 61,716 | Accepted | Accepted | 10.43 | from bisect import bisect_left
n, Q = list(map(int, input().split()))
stx = [list(map(int, input().split())) for i in range(n)]
q = [int(eval(input())) for i in range(Q)]
stx.sort(key=lambda x: x[2])
ans = [-1 for i in range(Q)]
skip = [-1 for i in range(Q)]
for (s, t, x) in stx:
begin = bisect_left(q, s-x)
end = bisect_left(q, t-x)
while begin<end:
if skip[begin]==-1:
ans[begin] = x
skip[begin] = end
begin += 1
else:
begin = skip[begin]
for e in ans:
print(e) | from bisect import bisect_left
n, Q = [int(x) for x in input().split()]
stx = [[int(x) for x in input().split()] for i in range(n)]
q = [int(eval(input())) for i in range(Q)]
stx.sort(key=lambda x: x[2])
ans = [-1 for i in range(Q)]
skip = [-1 for i in range(Q)]
for (s, t, x) in stx:
begin = bisect_left(q, s-x)
end = bisect_left(q, t-x)
while begin<end:
if skip[begin]==-1:
ans[begin] = x
skip[begin] = end
begin += 1
else:
begin = skip[begin]
for e in ans:
print(e) | 20 | 20 | 518 | 522 | from bisect import bisect_left
n, Q = list(map(int, input().split()))
stx = [list(map(int, input().split())) for i in range(n)]
q = [int(eval(input())) for i in range(Q)]
stx.sort(key=lambda x: x[2])
ans = [-1 for i in range(Q)]
skip = [-1 for i in range(Q)]
for (s, t, x) in stx:
begin = bisect_left(q, s - x)
end = bisect_left(q, t - x)
while begin < end:
if skip[begin] == -1:
ans[begin] = x
skip[begin] = end
begin += 1
else:
begin = skip[begin]
for e in ans:
print(e)
| from bisect import bisect_left
n, Q = [int(x) for x in input().split()]
stx = [[int(x) for x in input().split()] for i in range(n)]
q = [int(eval(input())) for i in range(Q)]
stx.sort(key=lambda x: x[2])
ans = [-1 for i in range(Q)]
skip = [-1 for i in range(Q)]
for (s, t, x) in stx:
begin = bisect_left(q, s - x)
end = bisect_left(q, t - x)
while begin < end:
if skip[begin] == -1:
ans[begin] = x
skip[begin] = end
begin += 1
else:
begin = skip[begin]
for e in ans:
print(e)
| false | 0 | [
"-n, Q = list(map(int, input().split()))",
"-stx = [list(map(int, input().split())) for i in range(n)]",
"+n, Q = [int(x) for x in input().split()]",
"+stx = [[int(x) for x in input().split()] for i in range(n)]"
] | false | 0.117453 | 0.098935 | 1.187173 | [
"s627962305",
"s000010590"
] |
u190178779 | p02830 | python | s530599682 | s506622653 | 32 | 24 | 9,136 | 9,068 | Accepted | Accepted | 25 | import sys
N = int(input())
S,T = input().split()
if not ( 1 <= N <= 100 ): sys.exit()
if not ( len(S) == len(T) and len(S) == N ): sys.exit()
if not ( S.islower() and T.islower() ): sys.exit()
for I in range(N):
print(S[I],end='')
print(T[I],end='')
| # import sys
N = int(input())
S,T = input().split()
# if not ( 1 <= N <= 100 ): sys.exit()
# if not ( len(S) == len(T) and len(S) == N ): sys.exit()
# if not ( S.islower() and T.islower() ): sys.exit()
for I in range(N):
print(S[I],end='')
print(T[I],end='')
| 11 | 11 | 270 | 278 | import sys
N = int(input())
S, T = input().split()
if not (1 <= N <= 100):
sys.exit()
if not (len(S) == len(T) and len(S) == N):
sys.exit()
if not (S.islower() and T.islower()):
sys.exit()
for I in range(N):
print(S[I], end="")
print(T[I], end="")
| # import sys
N = int(input())
S, T = input().split()
# if not ( 1 <= N <= 100 ): sys.exit()
# if not ( len(S) == len(T) and len(S) == N ): sys.exit()
# if not ( S.islower() and T.islower() ): sys.exit()
for I in range(N):
print(S[I], end="")
print(T[I], end="")
| false | 0 | [
"-import sys",
"-",
"+# import sys",
"-if not (1 <= N <= 100):",
"- sys.exit()",
"-if not (len(S) == len(T) and len(S) == N):",
"- sys.exit()",
"-if not (S.islower() and T.islower()):",
"- sys.exit()",
"+# if not ( 1 <= N <= 100 ): sys.exit()",
"+# if not ( len(S) == len(T) and len(S) == N ): sys.exit()",
"+# if not ( S.islower() and T.islower() ): sys.exit()"
] | false | 0.042923 | 0.045232 | 0.948961 | [
"s530599682",
"s506622653"
] |
u047796752 | p03283 | python | s023998763 | s547737811 | 565 | 209 | 55,260 | 81,296 | Accepted | Accepted | 63.01 | import sys
input = sys.stdin.readline
N, M, Q = list(map(int, input().split()))
A = [[0]*(N+1) for _ in range(N+1)]
for _ in range(M):
L, R = list(map(int, input().split()))
L -= 1
R -= 1
A[0][R] += 1
A[0][N] -= 1
A[L+1][R] -= 1
A[L+1][N] += 1
for i in range(N+1):
for j in range(N):
A[i][j+1] += A[i][j]
for i in range(N):
for j in range(N+1):
A[i+1][j] += A[i][j]
for _ in range(Q):
p, q = list(map(int, input().split()))
p -= 1
q -= 1
print((A[p][q])) | import sys
input = sys.stdin.readline
from collections import *
N, M, Q = list(map(int, input().split()))
A = [[0]*N for _ in range(N)]
for _ in range(M):
L, R = list(map(int, input().split()))
A[L-1][R-1] += 1
acc = [[0]*(N+1) for _ in range(N+1)]
for i in range(N):
for j in range(N):
acc[i+1][j+1] = acc[i+1][j]+acc[i][j+1]-acc[i][j]+A[i][j]
for _ in range(Q):
p, q = list(map(int, input().split()))
p -= 1
q -= 1
print((acc[q+1][q+1]-acc[q+1][p]-acc[p][q+1]+acc[p][p])) | 28 | 22 | 534 | 519 | import sys
input = sys.stdin.readline
N, M, Q = list(map(int, input().split()))
A = [[0] * (N + 1) for _ in range(N + 1)]
for _ in range(M):
L, R = list(map(int, input().split()))
L -= 1
R -= 1
A[0][R] += 1
A[0][N] -= 1
A[L + 1][R] -= 1
A[L + 1][N] += 1
for i in range(N + 1):
for j in range(N):
A[i][j + 1] += A[i][j]
for i in range(N):
for j in range(N + 1):
A[i + 1][j] += A[i][j]
for _ in range(Q):
p, q = list(map(int, input().split()))
p -= 1
q -= 1
print((A[p][q]))
| import sys
input = sys.stdin.readline
from collections import *
N, M, Q = list(map(int, input().split()))
A = [[0] * N for _ in range(N)]
for _ in range(M):
L, R = list(map(int, input().split()))
A[L - 1][R - 1] += 1
acc = [[0] * (N + 1) for _ in range(N + 1)]
for i in range(N):
for j in range(N):
acc[i + 1][j + 1] = acc[i + 1][j] + acc[i][j + 1] - acc[i][j] + A[i][j]
for _ in range(Q):
p, q = list(map(int, input().split()))
p -= 1
q -= 1
print((acc[q + 1][q + 1] - acc[q + 1][p] - acc[p][q + 1] + acc[p][p]))
| false | 21.428571 | [
"+from collections import *",
"+",
"-A = [[0] * (N + 1) for _ in range(N + 1)]",
"+A = [[0] * N for _ in range(N)]",
"- L -= 1",
"- R -= 1",
"- A[0][R] += 1",
"- A[0][N] -= 1",
"- A[L + 1][R] -= 1",
"- A[L + 1][N] += 1",
"-for i in range(N + 1):",
"+ A[L - 1][R - 1] += 1",
"+acc = [[0] * (N + 1) for _ in range(N + 1)]",
"+for i in range(N):",
"- A[i][j + 1] += A[i][j]",
"-for i in range(N):",
"- for j in range(N + 1):",
"- A[i + 1][j] += A[i][j]",
"+ acc[i + 1][j + 1] = acc[i + 1][j] + acc[i][j + 1] - acc[i][j] + A[i][j]",
"- print((A[p][q]))",
"+ print((acc[q + 1][q + 1] - acc[q + 1][p] - acc[p][q + 1] + acc[p][p]))"
] | false | 0.036988 | 0.036602 | 1.010558 | [
"s023998763",
"s547737811"
] |
u780962115 | p03724 | python | s092884210 | s962933167 | 369 | 341 | 17,428 | 3,964 | Accepted | Accepted | 7.59 | n,m=list(map(int,input().split()))
lists=[0 for i in range(m)]
for i in range(m):
x,y=list(map(int,input().split()))
lists[i]=(x,y)
anslist=[0 for i in range(n+1)]
#anslist[1] からanslist[n]まででこれらが全て偶数となるような時を考えればいい
#そうでないならばそれはNoである
for j in lists:
if j[0]==1:
anslist[j[1]]+=1
elif j[1]==1:
anslist[j[0]]+=1
else:
x=j[0]
y=j[1]
anslist[x]+=1
anslist[y]+=1
flag=True
for k in anslist:
if k%2!=0:
flag=False
break
if flag:
print("YES")
else:
print("NO") | n,m=list(map(int,input().split()))
lists=[0 for i in range(n)]
for i in range(m):
a,b=list(map(int,input().split()))
lists[a-1]+=1
lists[b-1]+=1
flag=True
for i in range(n):
if lists[i]%2!=0:
flag=False
break
if flag:
print("YES")
else:
print("NO") | 29 | 15 | 581 | 290 | n, m = list(map(int, input().split()))
lists = [0 for i in range(m)]
for i in range(m):
x, y = list(map(int, input().split()))
lists[i] = (x, y)
anslist = [0 for i in range(n + 1)]
# anslist[1] からanslist[n]まででこれらが全て偶数となるような時を考えればいい
# そうでないならばそれはNoである
for j in lists:
if j[0] == 1:
anslist[j[1]] += 1
elif j[1] == 1:
anslist[j[0]] += 1
else:
x = j[0]
y = j[1]
anslist[x] += 1
anslist[y] += 1
flag = True
for k in anslist:
if k % 2 != 0:
flag = False
break
if flag:
print("YES")
else:
print("NO")
| n, m = list(map(int, input().split()))
lists = [0 for i in range(n)]
for i in range(m):
a, b = list(map(int, input().split()))
lists[a - 1] += 1
lists[b - 1] += 1
flag = True
for i in range(n):
if lists[i] % 2 != 0:
flag = False
break
if flag:
print("YES")
else:
print("NO")
| false | 48.275862 | [
"-lists = [0 for i in range(m)]",
"+lists = [0 for i in range(n)]",
"- x, y = list(map(int, input().split()))",
"- lists[i] = (x, y)",
"-anslist = [0 for i in range(n + 1)]",
"-# anslist[1] からanslist[n]まででこれらが全て偶数となるような時を考えればいい",
"-# そうでないならばそれはNoである",
"-for j in lists:",
"- if j[0] == 1:",
"- anslist[j[1]] += 1",
"- elif j[1] == 1:",
"- anslist[j[0]] += 1",
"- else:",
"- x = j[0]",
"- y = j[1]",
"- anslist[x] += 1",
"- anslist[y] += 1",
"+ a, b = list(map(int, input().split()))",
"+ lists[a - 1] += 1",
"+ lists[b - 1] += 1",
"-for k in anslist:",
"- if k % 2 != 0:",
"+for i in range(n):",
"+ if lists[i] % 2 != 0:"
] | false | 0.047889 | 0.047772 | 1.002444 | [
"s092884210",
"s962933167"
] |
u254050469 | p03448 | python | s987812915 | s447579347 | 32 | 18 | 3,060 | 3,060 | Accepted | Accepted | 43.75 | A=int(eval(input()))
B=int(eval(input()))
C=int(eval(input()))
X=int(eval(input()))
l=0
for a in range(A+1):
ax = X - a*500
for b in range(B+1):
bx =ax - b*100
for c in range(C+1):
if bx - c*50 == 0:
l+=1
print(l)
| A=int(eval(input()))
B=int(eval(input()))
C=int(eval(input()))
X=int(eval(input()))
l=0
for a in range(A+1):
ax = X - a*500
for b in range(B+1):
if C*50 + b*100 >= ax and ax - b*100 >=0:
l+=1
print(l)
| 14 | 12 | 256 | 217 | A = int(eval(input()))
B = int(eval(input()))
C = int(eval(input()))
X = int(eval(input()))
l = 0
for a in range(A + 1):
ax = X - a * 500
for b in range(B + 1):
bx = ax - b * 100
for c in range(C + 1):
if bx - c * 50 == 0:
l += 1
print(l)
| A = int(eval(input()))
B = int(eval(input()))
C = int(eval(input()))
X = int(eval(input()))
l = 0
for a in range(A + 1):
ax = X - a * 500
for b in range(B + 1):
if C * 50 + b * 100 >= ax and ax - b * 100 >= 0:
l += 1
print(l)
| false | 14.285714 | [
"- bx = ax - b * 100",
"- for c in range(C + 1):",
"- if bx - c * 50 == 0:",
"- l += 1",
"+ if C * 50 + b * 100 >= ax and ax - b * 100 >= 0:",
"+ l += 1"
] | false | 0.201507 | 0.045971 | 4.383393 | [
"s987812915",
"s447579347"
] |
u133936772 | p02641 | python | s400409058 | s127308745 | 30 | 26 | 9,152 | 9,184 | Accepted | Accepted | 13.33 | x,n,*l=list(map(int,open(0).read().split()))
print((min((abs(i-x),i) for i in range(102) if i not in l)[1])) | x,_,*l=list(map(int,open(0).read().split()))
print((min((abs(i-x),i) for i in {*list(range(102))}-{*l})[1])) | 2 | 2 | 101 | 95 | x, n, *l = list(map(int, open(0).read().split()))
print((min((abs(i - x), i) for i in range(102) if i not in l)[1]))
| x, _, *l = list(map(int, open(0).read().split()))
print((min((abs(i - x), i) for i in {*list(range(102))} - {*l})[1]))
| false | 0 | [
"-x, n, *l = list(map(int, open(0).read().split()))",
"-print((min((abs(i - x), i) for i in range(102) if i not in l)[1]))",
"+x, _, *l = list(map(int, open(0).read().split()))",
"+print((min((abs(i - x), i) for i in {*list(range(102))} - {*l})[1]))"
] | false | 0.133142 | 0.093747 | 1.420223 | [
"s400409058",
"s127308745"
] |
u959519702 | p03039 | python | s097314005 | s914575132 | 41 | 36 | 29,036 | 29,036 | Accepted | Accepted | 12.2 | MAX = 10**9 + 7
def mod_inv(i, mod):
return pow(i, mod-2, mod)
def combination(_N, _K):
if _K > (_N/2):
_K = _N - _K
up = 1
low = 1
for i in range (_K):
up = up * (_N - i) % MAX
low = low * (i + 1) % MAX
ret = up * mod_inv(low, MAX) % MAX
return ret
def solve():
N, M, K = [int(_) for _ in input().split()]
disSum = (M*N* ((M*(N+1)*(N-1))%MAX + (N*(M+1)*(M-1)) % MAX)) % MAX
disSum *= mod_inv(6, MAX) % MAX
ret = disSum * combination(M*N-2, K-2) % MAX
print(ret)
if __name__ == '__main__':
solve()
| MAX = 10**9 + 7
def mod_inv(i, mod):
return pow(i, mod-2, mod)
def combination(_N, _K):
if _K > (_N/2):
_K = _N - _K
up = 1
low = 1
for i in range (_K):
up = up * (_N - i) % MAX
low = low * (i + 1) % MAX
ret = up * mod_inv(low, MAX) % MAX
return ret
def solve():
N, M, K = [int(_) for _ in input().split()]
disSum = M*N* (M*(N+1)*(N-1) + N*(M+1)*(M-1)) // 6
ret = disSum * combination(M*N-2, K-2) % MAX
print(ret)
if __name__ == '__main__':
solve()
| 25 | 24 | 605 | 551 | MAX = 10**9 + 7
def mod_inv(i, mod):
return pow(i, mod - 2, mod)
def combination(_N, _K):
if _K > (_N / 2):
_K = _N - _K
up = 1
low = 1
for i in range(_K):
up = up * (_N - i) % MAX
low = low * (i + 1) % MAX
ret = up * mod_inv(low, MAX) % MAX
return ret
def solve():
N, M, K = [int(_) for _ in input().split()]
disSum = (
M * N * ((M * (N + 1) * (N - 1)) % MAX + (N * (M + 1) * (M - 1)) % MAX)
) % MAX
disSum *= mod_inv(6, MAX) % MAX
ret = disSum * combination(M * N - 2, K - 2) % MAX
print(ret)
if __name__ == "__main__":
solve()
| MAX = 10**9 + 7
def mod_inv(i, mod):
return pow(i, mod - 2, mod)
def combination(_N, _K):
if _K > (_N / 2):
_K = _N - _K
up = 1
low = 1
for i in range(_K):
up = up * (_N - i) % MAX
low = low * (i + 1) % MAX
ret = up * mod_inv(low, MAX) % MAX
return ret
def solve():
N, M, K = [int(_) for _ in input().split()]
disSum = M * N * (M * (N + 1) * (N - 1) + N * (M + 1) * (M - 1)) // 6
ret = disSum * combination(M * N - 2, K - 2) % MAX
print(ret)
if __name__ == "__main__":
solve()
| false | 4 | [
"- disSum = (",
"- M * N * ((M * (N + 1) * (N - 1)) % MAX + (N * (M + 1) * (M - 1)) % MAX)",
"- ) % MAX",
"- disSum *= mod_inv(6, MAX) % MAX",
"+ disSum = M * N * (M * (N + 1) * (N - 1) + N * (M + 1) * (M - 1)) // 6"
] | false | 0.037744 | 0.037644 | 1.002642 | [
"s097314005",
"s914575132"
] |
u411203878 | p03786 | python | s623056201 | s836019750 | 245 | 106 | 64,412 | 86,156 | Accepted | Accepted | 56.73 | import copy
N = int(eval(input()))
A = list(map(int, input().split()))
A.sort()
cum_A = copy.copy(A)
for i in range(N-1):
cum_A[i+1] += cum_A[i]
#print(cum_A)
t = 0
for i in range(N-1, 0, -1):
if A[i] <= 2 * cum_A[i-1]:
t = i-1
else:
break
print((N-t))
| N = int(eval(input()))
A = list(map(int,input().split()))
A.sort()
memo = [0]*N
for i in range(N):
memo[i] = memo[i-1]+A[i]
for i in range(N-1,0,-1):
if A[i] <= 2 * memo[i-1]:
ans = i-1
else:
break
print((N-ans)) | 19 | 17 | 289 | 253 | import copy
N = int(eval(input()))
A = list(map(int, input().split()))
A.sort()
cum_A = copy.copy(A)
for i in range(N - 1):
cum_A[i + 1] += cum_A[i]
# print(cum_A)
t = 0
for i in range(N - 1, 0, -1):
if A[i] <= 2 * cum_A[i - 1]:
t = i - 1
else:
break
print((N - t))
| N = int(eval(input()))
A = list(map(int, input().split()))
A.sort()
memo = [0] * N
for i in range(N):
memo[i] = memo[i - 1] + A[i]
for i in range(N - 1, 0, -1):
if A[i] <= 2 * memo[i - 1]:
ans = i - 1
else:
break
print((N - ans))
| false | 10.526316 | [
"-import copy",
"-",
"-cum_A = copy.copy(A)",
"-for i in range(N - 1):",
"- cum_A[i + 1] += cum_A[i]",
"-# print(cum_A)",
"-t = 0",
"+memo = [0] * N",
"+for i in range(N):",
"+ memo[i] = memo[i - 1] + A[i]",
"- if A[i] <= 2 * cum_A[i - 1]:",
"- t = i - 1",
"+ if A[i] <= 2 * memo[i - 1]:",
"+ ans = i - 1",
"-print((N - t))",
"+print((N - ans))"
] | false | 0.075796 | 0.035056 | 2.162141 | [
"s623056201",
"s836019750"
] |
u327466606 | p02819 | python | s215875493 | s179836143 | 91 | 72 | 5,364 | 62,560 | Accepted | Accepted | 20.88 | X = int(eval(input()))
memo = [None]*(2*X)
for i,v in enumerate(memo):
if i < 2:
continue
if v is None:
memo[i] = True
for j in range(i*2, 2*X, i):
memo[j] = False
print((next(i+X for i,v in enumerate(memo[X:]) if v))) |
# 素因数分解
def prime_factors(n):
i = 2
while i * i <= n:
if n % i:
i += 1
else:
n //= i
yield i
if n > 1:
yield n
from itertools import count
X = int(eval(input()))
for x in count(X):
if len(tuple(prime_factors(x))) == 1:
print(x)
break | 13 | 21 | 269 | 343 | X = int(eval(input()))
memo = [None] * (2 * X)
for i, v in enumerate(memo):
if i < 2:
continue
if v is None:
memo[i] = True
for j in range(i * 2, 2 * X, i):
memo[j] = False
print((next(i + X for i, v in enumerate(memo[X:]) if v)))
| # 素因数分解
def prime_factors(n):
i = 2
while i * i <= n:
if n % i:
i += 1
else:
n //= i
yield i
if n > 1:
yield n
from itertools import count
X = int(eval(input()))
for x in count(X):
if len(tuple(prime_factors(x))) == 1:
print(x)
break
| false | 38.095238 | [
"+# 素因数分解",
"+def prime_factors(n):",
"+ i = 2",
"+ while i * i <= n:",
"+ if n % i:",
"+ i += 1",
"+ else:",
"+ n //= i",
"+ yield i",
"+ if n > 1:",
"+ yield n",
"+",
"+",
"+from itertools import count",
"+",
"-memo = [None] * (2 * X)",
"-for i, v in enumerate(memo):",
"- if i < 2:",
"- continue",
"- if v is None:",
"- memo[i] = True",
"- for j in range(i * 2, 2 * X, i):",
"- memo[j] = False",
"-print((next(i + X for i, v in enumerate(memo[X:]) if v)))",
"+for x in count(X):",
"+ if len(tuple(prime_factors(x))) == 1:",
"+ print(x)",
"+ break"
] | false | 0.050777 | 0.130878 | 0.387969 | [
"s215875493",
"s179836143"
] |
u437351386 | p03805 | python | s812691486 | s661594125 | 71 | 36 | 71,396 | 9,072 | Accepted | Accepted | 49.3 | #制約が小さいので全探索する
n,m=list(map(int,input().split()))
#辺があるかどうかが知りたい→隣接行列表現
es=[[0]*n for i in range(n)]
for i in range(m):
a,b=list(map(int,input().split()))
es[a-1][b-1]=1
es[b-1][a-1]=1
#順列を作る
from itertools import permutations
per=[i+1 for i in range(n-1)]
per=list(permutations(per,n-1))
#全探索する
ans=0
for i in per:
cnt=0
if es[0][i[0]]==0:
continue
else:
for j in range(1,n-1):
if es[i[j]][i[j-1]]==0:
cnt+=1
if cnt==0:
ans=ans+1
print(ans)
| n,m=list(map(int,input().split()))
# 再帰の深さが1000を超えそうなときはこれをやっておく
import sys
sys.setrecursionlimit(10**7)
#隣接行列表現
es=[[0 for i in range(n)] for j in range(n)]
for i in range(m):
a,b=list(map(int,input().split()))
es[a-1][b-1]=1
es[b-1][a-1]=1
#深さ優先探索
def dfs(v,visited):
ans=0
#自分が今いるところは探索済にする
visited[v-1]=1
#全部探索できたことになる
if visited==check:
visited[v-1]=0
return 1
#vから行けるところを考える
for i in range(n):
#道があって未訪問
if visited[i]==0 and es[v-1][i]==1:
ans=ans+dfs(i+1,visited)
#次の探索のため未訪問にしておく
visited[v-1]=0
return ans
visited=[0 for i in range(n)]
check=[1 for i in range(n)]
print((dfs(1,visited)))
| 28 | 52 | 516 | 732 | # 制約が小さいので全探索する
n, m = list(map(int, input().split()))
# 辺があるかどうかが知りたい→隣接行列表現
es = [[0] * n for i in range(n)]
for i in range(m):
a, b = list(map(int, input().split()))
es[a - 1][b - 1] = 1
es[b - 1][a - 1] = 1
# 順列を作る
from itertools import permutations
per = [i + 1 for i in range(n - 1)]
per = list(permutations(per, n - 1))
# 全探索する
ans = 0
for i in per:
cnt = 0
if es[0][i[0]] == 0:
continue
else:
for j in range(1, n - 1):
if es[i[j]][i[j - 1]] == 0:
cnt += 1
if cnt == 0:
ans = ans + 1
print(ans)
| n, m = list(map(int, input().split()))
# 再帰の深さが1000を超えそうなときはこれをやっておく
import sys
sys.setrecursionlimit(10**7)
# 隣接行列表現
es = [[0 for i in range(n)] for j in range(n)]
for i in range(m):
a, b = list(map(int, input().split()))
es[a - 1][b - 1] = 1
es[b - 1][a - 1] = 1
# 深さ優先探索
def dfs(v, visited):
ans = 0
# 自分が今いるところは探索済にする
visited[v - 1] = 1
# 全部探索できたことになる
if visited == check:
visited[v - 1] = 0
return 1
# vから行けるところを考える
for i in range(n):
# 道があって未訪問
if visited[i] == 0 and es[v - 1][i] == 1:
ans = ans + dfs(i + 1, visited)
# 次の探索のため未訪問にしておく
visited[v - 1] = 0
return ans
visited = [0 for i in range(n)]
check = [1 for i in range(n)]
print((dfs(1, visited)))
| false | 46.153846 | [
"-# 制約が小さいので全探索する",
"-# 辺があるかどうかが知りたい→隣接行列表現",
"-es = [[0] * n for i in range(n)]",
"+# 再帰の深さが1000を超えそうなときはこれをやっておく",
"+import sys",
"+",
"+sys.setrecursionlimit(10**7)",
"+# 隣接行列表現",
"+es = [[0 for i in range(n)] for j in range(n)]",
"-# 順列を作る",
"-from itertools import permutations",
"+# 深さ優先探索",
"+def dfs(v, visited):",
"+ ans = 0",
"+ # 自分が今いるところは探索済にする",
"+ visited[v - 1] = 1",
"+ # 全部探索できたことになる",
"+ if visited == check:",
"+ visited[v - 1] = 0",
"+ return 1",
"+ # vから行けるところを考える",
"+ for i in range(n):",
"+ # 道があって未訪問",
"+ if visited[i] == 0 and es[v - 1][i] == 1:",
"+ ans = ans + dfs(i + 1, visited)",
"+ # 次の探索のため未訪問にしておく",
"+ visited[v - 1] = 0",
"+ return ans",
"-per = [i + 1 for i in range(n - 1)]",
"-per = list(permutations(per, n - 1))",
"-# 全探索する",
"-ans = 0",
"-for i in per:",
"- cnt = 0",
"- if es[0][i[0]] == 0:",
"- continue",
"- else:",
"- for j in range(1, n - 1):",
"- if es[i[j]][i[j - 1]] == 0:",
"- cnt += 1",
"- if cnt == 0:",
"- ans = ans + 1",
"-print(ans)",
"+",
"+visited = [0 for i in range(n)]",
"+check = [1 for i in range(n)]",
"+print((dfs(1, visited)))"
] | false | 0.098142 | 0.046502 | 2.110505 | [
"s812691486",
"s661594125"
] |
u134302690 | p03469 | python | s858169718 | s926396807 | 183 | 17 | 38,256 | 2,940 | Accepted | Accepted | 90.71 | s = eval(input())
print((s.replace("2017","2018")))
| S = eval(input())
print(("2018" + S[4:])) | 3 | 2 | 47 | 34 | s = eval(input())
print((s.replace("2017", "2018")))
| S = eval(input())
print(("2018" + S[4:]))
| false | 33.333333 | [
"-s = eval(input())",
"-print((s.replace(\"2017\", \"2018\")))",
"+S = eval(input())",
"+print((\"2018\" + S[4:]))"
] | false | 0.047075 | 0.041716 | 1.128475 | [
"s858169718",
"s926396807"
] |
u021019433 | p02854 | python | s628935766 | s287148022 | 96 | 79 | 27,176 | 27,308 | Accepted | Accepted | 17.71 | from itertools import accumulate, count
eval(input())
a = [0] + list(accumulate(list(map(int, input().split()))))
i = next(i for i in count() if 2 * a[i] > a[-1])
print((min(2 * a[i] - a[-1], a[-1] - 2 * a[i - 1])))
| from itertools import accumulate, count
from bisect import bisect_right
eval(input())
a = [0] + list(accumulate(list(map(int, input().split()))))
i = bisect_right(a, a[-1] // 2)
print((min(2 * a[i] - a[-1], a[-1] - 2 * a[i - 1])))
| 6 | 7 | 208 | 224 | from itertools import accumulate, count
eval(input())
a = [0] + list(accumulate(list(map(int, input().split()))))
i = next(i for i in count() if 2 * a[i] > a[-1])
print((min(2 * a[i] - a[-1], a[-1] - 2 * a[i - 1])))
| from itertools import accumulate, count
from bisect import bisect_right
eval(input())
a = [0] + list(accumulate(list(map(int, input().split()))))
i = bisect_right(a, a[-1] // 2)
print((min(2 * a[i] - a[-1], a[-1] - 2 * a[i - 1])))
| false | 14.285714 | [
"+from bisect import bisect_right",
"-i = next(i for i in count() if 2 * a[i] > a[-1])",
"+i = bisect_right(a, a[-1] // 2)"
] | false | 0.049991 | 0.046253 | 1.080826 | [
"s628935766",
"s287148022"
] |
u285681431 | p03038 | python | s998090253 | s100541191 | 299 | 261 | 35,896 | 106,000 | Accepted | Accepted | 12.71 | N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
BC = [list(map(int, input().split())) for i in range(M)]
# Cについて大きい順にソート
BC.sort(key=lambda x: x[1], reverse=True)
temp = []
for i in range(M):
# CiをBi個追加
temp += [BC[i][1]] * BC[i][0]
if len(temp) > N:
break
A += temp
A.sort(reverse=True)
print((sum(A[:N])))
| import sys
input = sys.stdin.readline
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
BC = [list(map(int, input().split())) for _ in range(M)]
# Cについて大きい順にソート
BC.sort(key=lambda x: x[1], reverse=True)
tmp = []
# tmpがN個を超えるまで、cをb個足す
for b, c in BC:
tmp += [c] * b
if len(tmp) >= N:
break
# Aとtmpを混ぜてソート
nums = A + tmp
nums.sort(reverse=True)
# 上からN個の総和
print((sum(nums[:N])))
| 18 | 23 | 378 | 443 | N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
BC = [list(map(int, input().split())) for i in range(M)]
# Cについて大きい順にソート
BC.sort(key=lambda x: x[1], reverse=True)
temp = []
for i in range(M):
# CiをBi個追加
temp += [BC[i][1]] * BC[i][0]
if len(temp) > N:
break
A += temp
A.sort(reverse=True)
print((sum(A[:N])))
| import sys
input = sys.stdin.readline
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
BC = [list(map(int, input().split())) for _ in range(M)]
# Cについて大きい順にソート
BC.sort(key=lambda x: x[1], reverse=True)
tmp = []
# tmpがN個を超えるまで、cをb個足す
for b, c in BC:
tmp += [c] * b
if len(tmp) >= N:
break
# Aとtmpを混ぜてソート
nums = A + tmp
nums.sort(reverse=True)
# 上からN個の総和
print((sum(nums[:N])))
| false | 21.73913 | [
"+import sys",
"+",
"+input = sys.stdin.readline",
"-BC = [list(map(int, input().split())) for i in range(M)]",
"+BC = [list(map(int, input().split())) for _ in range(M)]",
"-temp = []",
"-for i in range(M):",
"- # CiをBi個追加",
"- temp += [BC[i][1]] * BC[i][0]",
"- if len(temp) > N:",
"+tmp = []",
"+# tmpがN個を超えるまで、cをb個足す",
"+for b, c in BC:",
"+ tmp += [c] * b",
"+ if len(tmp) >= N:",
"-A += temp",
"-A.sort(reverse=True)",
"-print((sum(A[:N])))",
"+# Aとtmpを混ぜてソート",
"+nums = A + tmp",
"+nums.sort(reverse=True)",
"+# 上からN個の総和",
"+print((sum(nums[:N])))"
] | false | 0.042689 | 0.036024 | 1.185023 | [
"s998090253",
"s100541191"
] |
u498487134 | p02757 | python | s265768785 | s628959687 | 297 | 154 | 41,308 | 75,080 | Accepted | Accepted | 48.15 |
def I(): return int(eval(input()))
def MI(): return list(map(int, input().split()))
def LI(): return list(map(int, input().split()))
def main():
N,P=MI()
s=eval(input())
ans=0
if P==2 or P==5:
for i in range(N):
t=int(s[i])
if t%P==0:
ans+=i+1
else:
ans=0
t=0
mod=[0]*P
mod[0]=1
for i in range(N):
t=t+int(s[N-i-1])*pow(10,i,P)
t=t%P
mod[t]+=1
if mod[t]>=2:
ans+=mod[t]-1
print(ans)
main()
|
def I(): return int(eval(input()))
def MI(): return list(map(int, input().split()))
def LI(): return list(map(int, input().split()))
def main():
N,P=MI()
S=eval(input())
if P==2 or P==5:
ans=0
for i in range(N):
if int(S[i])%P==0:
ans+=i+1
print(ans)
exit()
from collections import defaultdict
dd = defaultdict(int)
now=0
dd[0]=1
for i in range(N):
now=now+(pow(10,i,P)*int(S[-1-i]))
now%=P
dd[now]+=1
ans=0
for k,v in list(dd.items()):
ans+=(v*(v-1))//2
print(ans)
main()
| 39 | 38 | 683 | 690 | def I():
return int(eval(input()))
def MI():
return list(map(int, input().split()))
def LI():
return list(map(int, input().split()))
def main():
N, P = MI()
s = eval(input())
ans = 0
if P == 2 or P == 5:
for i in range(N):
t = int(s[i])
if t % P == 0:
ans += i + 1
else:
ans = 0
t = 0
mod = [0] * P
mod[0] = 1
for i in range(N):
t = t + int(s[N - i - 1]) * pow(10, i, P)
t = t % P
mod[t] += 1
if mod[t] >= 2:
ans += mod[t] - 1
print(ans)
main()
| def I():
return int(eval(input()))
def MI():
return list(map(int, input().split()))
def LI():
return list(map(int, input().split()))
def main():
N, P = MI()
S = eval(input())
if P == 2 or P == 5:
ans = 0
for i in range(N):
if int(S[i]) % P == 0:
ans += i + 1
print(ans)
exit()
from collections import defaultdict
dd = defaultdict(int)
now = 0
dd[0] = 1
for i in range(N):
now = now + (pow(10, i, P) * int(S[-1 - i]))
now %= P
dd[now] += 1
ans = 0
for k, v in list(dd.items()):
ans += (v * (v - 1)) // 2
print(ans)
main()
| false | 2.564103 | [
"- s = eval(input())",
"+ S = eval(input())",
"+ if P == 2 or P == 5:",
"+ ans = 0",
"+ for i in range(N):",
"+ if int(S[i]) % P == 0:",
"+ ans += i + 1",
"+ print(ans)",
"+ exit()",
"+ from collections import defaultdict",
"+",
"+ dd = defaultdict(int)",
"+ now = 0",
"+ dd[0] = 1",
"+ for i in range(N):",
"+ now = now + (pow(10, i, P) * int(S[-1 - i]))",
"+ now %= P",
"+ dd[now] += 1",
"- if P == 2 or P == 5:",
"- for i in range(N):",
"- t = int(s[i])",
"- if t % P == 0:",
"- ans += i + 1",
"- else:",
"- ans = 0",
"- t = 0",
"- mod = [0] * P",
"- mod[0] = 1",
"- for i in range(N):",
"- t = t + int(s[N - i - 1]) * pow(10, i, P)",
"- t = t % P",
"- mod[t] += 1",
"- if mod[t] >= 2:",
"- ans += mod[t] - 1",
"+ for k, v in list(dd.items()):",
"+ ans += (v * (v - 1)) // 2"
] | false | 0.03925 | 0.038438 | 1.021135 | [
"s265768785",
"s628959687"
] |
u582489208 | p02622 | python | s126840359 | s023169602 | 73 | 60 | 10,916 | 9,264 | Accepted | Accepted | 17.81 | S = str(eval(input()))
T = str(eval(input()))
N = 0
Count = []
for i in range(len(S)):
if S[N] != T[N]:
Count.append(1)
N += 1
print((len(Count))) | s = str(eval(input()))
t = str(eval(input()))
count = 0
for i in range(len(s)):
if s[i] != t[i]:
count +=1
print(count) | 9 | 7 | 156 | 125 | S = str(eval(input()))
T = str(eval(input()))
N = 0
Count = []
for i in range(len(S)):
if S[N] != T[N]:
Count.append(1)
N += 1
print((len(Count)))
| s = str(eval(input()))
t = str(eval(input()))
count = 0
for i in range(len(s)):
if s[i] != t[i]:
count += 1
print(count)
| false | 22.222222 | [
"-S = str(eval(input()))",
"-T = str(eval(input()))",
"-N = 0",
"-Count = []",
"-for i in range(len(S)):",
"- if S[N] != T[N]:",
"- Count.append(1)",
"- N += 1",
"-print((len(Count)))",
"+s = str(eval(input()))",
"+t = str(eval(input()))",
"+count = 0",
"+for i in range(len(s)):",
"+ if s[i] != t[i]:",
"+ count += 1",
"+print(count)"
] | false | 0.037879 | 0.037002 | 1.023683 | [
"s126840359",
"s023169602"
] |
u945181840 | p03014 | python | s946289610 | s543887555 | 961 | 883 | 126,104 | 126,100 | Accepted | Accepted | 8.12 | import numpy as np
import sys
def main():
line = sys.stdin.readline
H, W = list(map(int, line().split()))
grid = np.zeros((H + 2, W + 2), np.int32)
grid[1:-1, 1:-1] = (np.array([list(line().rstrip()) for _ in range(H)]).reshape(H, W) == '.') * 1
left = np.zeros((H + 2, W + 2), np.int32)
right = np.zeros((H + 2, W + 2), np.int32)
up = np.zeros((H + 2, W + 2), np.int32)
down = np.zeros((H + 2, W + 2), np.int32)
# 下方向に照らせるマスの数（自分の場所含む）
down[H] = grid[H]
for i in range(H, 0, -1):
down[i - 1] = (down[i] + 1) * grid[i - 1]
up[1] = grid[1]
for i in range(1, H):
up[i + 1] = (up[i] + 1) * grid[i + 1]
right[:, W] = grid[:, W]
for i in range(W, 0, -1):
right[:, i - 1] = (right[:, i] + 1) * grid[:, i - 1]
left[:, 1] = grid[:, 1]
for i in range(1, W):
left[:, i + 1] = (left[:, i] + 1) * grid[:, i + 1]
answer = (left + right + up + down) * grid
print((np.max(answer) - 3))
if __name__ == '__main__':
main() | import numpy as np
import sys
line = sys.stdin.readline
H, W = list(map(int, line().split()))
grid = np.zeros((H + 2, W + 2), np.int32)
grid[1:-1, 1:-1] = (np.array([list(line().rstrip()) for _ in range(H)]).reshape(H, W) == '.') * 1
left = np.zeros((H + 2, W + 2), np.int32)
right = np.zeros((H + 2, W + 2), np.int32)
up = np.zeros((H + 2, W + 2), np.int32)
down = np.zeros((H + 2, W + 2), np.int32)
# 下方向に照らせるマスの数（自分の場所含む）
down[H] = grid[H]
for i in range(H, 0, -1):
down[i - 1] = (down[i] + 1) * grid[i - 1]
up[1] = grid[1]
for i in range(1, H):
up[i + 1] = (up[i] + 1) * grid[i + 1]
right[:, W] = grid[:, W]
for i in range(W, 0, -1):
right[:, i - 1] = (right[:, i] + 1) * grid[:, i - 1]
left[:, 1] = grid[:, 1]
for i in range(1, W):
left[:, i + 1] = (left[:, i] + 1) * grid[:, i + 1]
answer = (left + right + up + down - 3) * grid
print((np.max(answer))) | 36 | 31 | 1,051 | 902 | import numpy as np
import sys
def main():
line = sys.stdin.readline
H, W = list(map(int, line().split()))
grid = np.zeros((H + 2, W + 2), np.int32)
grid[1:-1, 1:-1] = (
np.array([list(line().rstrip()) for _ in range(H)]).reshape(H, W) == "."
) * 1
left = np.zeros((H + 2, W + 2), np.int32)
right = np.zeros((H + 2, W + 2), np.int32)
up = np.zeros((H + 2, W + 2), np.int32)
down = np.zeros((H + 2, W + 2), np.int32)
# 下方向に照らせるマスの数（自分の場所含む）
down[H] = grid[H]
for i in range(H, 0, -1):
down[i - 1] = (down[i] + 1) * grid[i - 1]
up[1] = grid[1]
for i in range(1, H):
up[i + 1] = (up[i] + 1) * grid[i + 1]
right[:, W] = grid[:, W]
for i in range(W, 0, -1):
right[:, i - 1] = (right[:, i] + 1) * grid[:, i - 1]
left[:, 1] = grid[:, 1]
for i in range(1, W):
left[:, i + 1] = (left[:, i] + 1) * grid[:, i + 1]
answer = (left + right + up + down) * grid
print((np.max(answer) - 3))
if __name__ == "__main__":
main()
| import numpy as np
import sys
line = sys.stdin.readline
H, W = list(map(int, line().split()))
grid = np.zeros((H + 2, W + 2), np.int32)
grid[1:-1, 1:-1] = (
np.array([list(line().rstrip()) for _ in range(H)]).reshape(H, W) == "."
) * 1
left = np.zeros((H + 2, W + 2), np.int32)
right = np.zeros((H + 2, W + 2), np.int32)
up = np.zeros((H + 2, W + 2), np.int32)
down = np.zeros((H + 2, W + 2), np.int32)
# 下方向に照らせるマスの数（自分の場所含む）
down[H] = grid[H]
for i in range(H, 0, -1):
down[i - 1] = (down[i] + 1) * grid[i - 1]
up[1] = grid[1]
for i in range(1, H):
up[i + 1] = (up[i] + 1) * grid[i + 1]
right[:, W] = grid[:, W]
for i in range(W, 0, -1):
right[:, i - 1] = (right[:, i] + 1) * grid[:, i - 1]
left[:, 1] = grid[:, 1]
for i in range(1, W):
left[:, i + 1] = (left[:, i] + 1) * grid[:, i + 1]
answer = (left + right + up + down - 3) * grid
print((np.max(answer)))
| false | 13.888889 | [
"-",
"-def main():",
"- line = sys.stdin.readline",
"- H, W = list(map(int, line().split()))",
"- grid = np.zeros((H + 2, W + 2), np.int32)",
"- grid[1:-1, 1:-1] = (",
"- np.array([list(line().rstrip()) for _ in range(H)]).reshape(H, W) == \".\"",
"- ) * 1",
"- left = np.zeros((H + 2, W + 2), np.int32)",
"- right = np.zeros((H + 2, W + 2), np.int32)",
"- up = np.zeros((H + 2, W + 2), np.int32)",
"- down = np.zeros((H + 2, W + 2), np.int32)",
"- # 下方向に照らせるマスの数（自分の場所含む）",
"- down[H] = grid[H]",
"- for i in range(H, 0, -1):",
"- down[i - 1] = (down[i] + 1) * grid[i - 1]",
"- up[1] = grid[1]",
"- for i in range(1, H):",
"- up[i + 1] = (up[i] + 1) * grid[i + 1]",
"- right[:, W] = grid[:, W]",
"- for i in range(W, 0, -1):",
"- right[:, i - 1] = (right[:, i] + 1) * grid[:, i - 1]",
"- left[:, 1] = grid[:, 1]",
"- for i in range(1, W):",
"- left[:, i + 1] = (left[:, i] + 1) * grid[:, i + 1]",
"- answer = (left + right + up + down) * grid",
"- print((np.max(answer) - 3))",
"-",
"-",
"-if __name__ == \"__main__\":",
"- main()",
"+line = sys.stdin.readline",
"+H, W = list(map(int, line().split()))",
"+grid = np.zeros((H + 2, W + 2), np.int32)",
"+grid[1:-1, 1:-1] = (",
"+ np.array([list(line().rstrip()) for _ in range(H)]).reshape(H, W) == \".\"",
"+) * 1",
"+left = np.zeros((H + 2, W + 2), np.int32)",
"+right = np.zeros((H + 2, W + 2), np.int32)",
"+up = np.zeros((H + 2, W + 2), np.int32)",
"+down = np.zeros((H + 2, W + 2), np.int32)",
"+# 下方向に照らせるマスの数（自分の場所含む）",
"+down[H] = grid[H]",
"+for i in range(H, 0, -1):",
"+ down[i - 1] = (down[i] + 1) * grid[i - 1]",
"+up[1] = grid[1]",
"+for i in range(1, H):",
"+ up[i + 1] = (up[i] + 1) * grid[i + 1]",
"+right[:, W] = grid[:, W]",
"+for i in range(W, 0, -1):",
"+ right[:, i - 1] = (right[:, i] + 1) * grid[:, i - 1]",
"+left[:, 1] = grid[:, 1]",
"+for i in range(1, W):",
"+ left[:, i + 1] = (left[:, i] + 1) * grid[:, i + 1]",
"+answer = (left + right + up + down - 3) * grid",
"+print((np.max(answer)))"
] | false | 0.312213 | 0.272463 | 1.145893 | [
"s946289610",
"s543887555"
] |
u037098269 | p02707 | python | s531129604 | s487720174 | 237 | 175 | 38,896 | 32,216 | Accepted | Accepted | 26.16 | N = int(eval(input()))
A = list(map(int, input().split()))
for i in range(N-1):
A[i] -= 1
#上司の社員番号は自分より小さい
dic = {}
for i in range(N):
dic[i] = 0
for i in range(N-1):
dic[A[i]] += 1
for i in range(N):
print((dic[i])) | N = int(eval(input()))
A = list(map(int, input().split()))
for i in range(N-1):
A[i] -= 1
ans = [0 for i in range(N)]
for a in A:
ans[a] += 1
for i in range(N):
print((ans[i])) | 15 | 9 | 245 | 188 | N = int(eval(input()))
A = list(map(int, input().split()))
for i in range(N - 1):
A[i] -= 1
# 上司の社員番号は自分より小さい
dic = {}
for i in range(N):
dic[i] = 0
for i in range(N - 1):
dic[A[i]] += 1
for i in range(N):
print((dic[i]))
| N = int(eval(input()))
A = list(map(int, input().split()))
for i in range(N - 1):
A[i] -= 1
ans = [0 for i in range(N)]
for a in A:
ans[a] += 1
for i in range(N):
print((ans[i]))
| false | 40 | [
"-# 上司の社員番号は自分より小さい",
"-dic = {}",
"+ans = [0 for i in range(N)]",
"+for a in A:",
"+ ans[a] += 1",
"- dic[i] = 0",
"-for i in range(N - 1):",
"- dic[A[i]] += 1",
"-for i in range(N):",
"- print((dic[i]))",
"+ print((ans[i]))"
] | false | 0.092842 | 0.086231 | 1.076669 | [
"s531129604",
"s487720174"
] |
u347640436 | p02924 | python | s772700993 | s524143453 | 19 | 17 | 2,940 | 2,940 | Accepted | Accepted | 10.53 | n = int(eval(input()))
print((n * (n - 1) // 2))
| N = int(eval(input()))
print((N * (N - 1) // 2))
| 3 | 2 | 44 | 42 | n = int(eval(input()))
print((n * (n - 1) // 2))
| N = int(eval(input()))
print((N * (N - 1) // 2))
| false | 33.333333 | [
"-n = int(eval(input()))",
"-print((n * (n - 1) // 2))",
"+N = int(eval(input()))",
"+print((N * (N - 1) // 2))"
] | false | 0.040761 | 0.044626 | 0.913387 | [
"s772700993",
"s524143453"
] |
u311379832 | p02720 | python | s664411055 | s792020013 | 1,049 | 123 | 12,476 | 7,644 | Accepted | Accepted | 88.27 | import queue
N = int(eval(input()))
q = queue.Queue()
for i in range(1, 10):
q.put(i)
ans = 0
for i in range(N):
ans = q.get()
m = ans % 10
if ans % 10 != 0:
q.put(ans * 10 + m - 1)
q.put(ans * 10 + m)
if ans % 10 != 9:
q.put(ans * 10 + m + 1)
print(ans) | import sys
sys.setrecursionlimit(10**6)
def dfs(n):
if n > 3234566667:
return
ans.append(n)
if n % 10 != 0:
dfs(n * 10 + (n % 10) - 1)
dfs(n * 10 + (n % 10))
if n % 10 != 9:
dfs(n * 10 + (n % 10) + 1)
N = int(eval(input()))
ans = []
for i in range(1, 10):
dfs(i)
ans.sort()
print((ans[N - 1])) | 18 | 19 | 308 | 353 | import queue
N = int(eval(input()))
q = queue.Queue()
for i in range(1, 10):
q.put(i)
ans = 0
for i in range(N):
ans = q.get()
m = ans % 10
if ans % 10 != 0:
q.put(ans * 10 + m - 1)
q.put(ans * 10 + m)
if ans % 10 != 9:
q.put(ans * 10 + m + 1)
print(ans)
| import sys
sys.setrecursionlimit(10**6)
def dfs(n):
if n > 3234566667:
return
ans.append(n)
if n % 10 != 0:
dfs(n * 10 + (n % 10) - 1)
dfs(n * 10 + (n % 10))
if n % 10 != 9:
dfs(n * 10 + (n % 10) + 1)
N = int(eval(input()))
ans = []
for i in range(1, 10):
dfs(i)
ans.sort()
print((ans[N - 1]))
| false | 5.263158 | [
"-import queue",
"+import sys",
"+",
"+sys.setrecursionlimit(10**6)",
"+",
"+",
"+def dfs(n):",
"+ if n > 3234566667:",
"+ return",
"+ ans.append(n)",
"+ if n % 10 != 0:",
"+ dfs(n * 10 + (n % 10) - 1)",
"+ dfs(n * 10 + (n % 10))",
"+ if n % 10 != 9:",
"+ dfs(n * 10 + (n % 10) + 1)",
"+",
"-q = queue.Queue()",
"+ans = []",
"- q.put(i)",
"-ans = 0",
"-for i in range(N):",
"- ans = q.get()",
"- m = ans % 10",
"- if ans % 10 != 0:",
"- q.put(ans * 10 + m - 1)",
"- q.put(ans * 10 + m)",
"- if ans % 10 != 9:",
"- q.put(ans * 10 + m + 1)",
"-print(ans)",
"+ dfs(i)",
"+ans.sort()",
"+print((ans[N - 1]))"
] | false | 0.105844 | 0.278983 | 0.37939 | [
"s664411055",
"s792020013"
] |
u525227429 | p03050 | python | s940844897 | s347904565 | 594 | 115 | 3,316 | 3,268 | Accepted | Accepted | 80.64 | import math
N = int(eval(input()))
ans = 0
for i in range(1, int(math.sqrt(N)) + 1):
if i > N / 2:
continue
tmp = int((N - i) / i)
if (N - i) % i == 0 and N % tmp != 0 and tmp >= math.sqrt(N):
ans += tmp
print(ans) | N = int(eval(input()))
def make_divisors(n):
divisors = []
for i in range(1, int(n ** 0.5) + 1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n // i)
return divisors
div = make_divisors(N)
ans = 0
for d in div:
if d != 1 and N // (d - 1) == N % (d - 1):
ans += d - 1
print(ans) | 13 | 18 | 237 | 348 | import math
N = int(eval(input()))
ans = 0
for i in range(1, int(math.sqrt(N)) + 1):
if i > N / 2:
continue
tmp = int((N - i) / i)
if (N - i) % i == 0 and N % tmp != 0 and tmp >= math.sqrt(N):
ans += tmp
print(ans)
| N = int(eval(input()))
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5) + 1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n // i)
return divisors
div = make_divisors(N)
ans = 0
for d in div:
if d != 1 and N // (d - 1) == N % (d - 1):
ans += d - 1
print(ans)
| false | 27.777778 | [
"-import math",
"+N = int(eval(input()))",
"-N = int(eval(input()))",
"+",
"+def make_divisors(n):",
"+ divisors = []",
"+ for i in range(1, int(n**0.5) + 1):",
"+ if n % i == 0:",
"+ divisors.append(i)",
"+ if i != n // i:",
"+ divisors.append(n // i)",
"+ return divisors",
"+",
"+",
"+div = make_divisors(N)",
"-for i in range(1, int(math.sqrt(N)) + 1):",
"- if i > N / 2:",
"- continue",
"- tmp = int((N - i) / i)",
"- if (N - i) % i == 0 and N % tmp != 0 and tmp >= math.sqrt(N):",
"- ans += tmp",
"+for d in div:",
"+ if d != 1 and N // (d - 1) == N % (d - 1):",
"+ ans += d - 1"
] | false | 0.731326 | 0.203268 | 3.597833 | [
"s940844897",
"s347904565"
] |
u252828980 | p03107 | python | s947277658 | s416119677 | 39 | 18 | 4,652 | 3,188 | Accepted | Accepted | 53.85 | s = eval(input())
s = list(s)
s = [int(x) for x in s]
a = s.count(1)
b = s.count(0)
print((len(s)-abs(a-b))) | s = eval(input())
rc = s.count("0")
bc = s.count("1")
min1 = min(rc,bc)
print((min1 *2)) | 6 | 5 | 105 | 84 | s = eval(input())
s = list(s)
s = [int(x) for x in s]
a = s.count(1)
b = s.count(0)
print((len(s) - abs(a - b)))
| s = eval(input())
rc = s.count("0")
bc = s.count("1")
min1 = min(rc, bc)
print((min1 * 2))
| false | 16.666667 | [
"-s = list(s)",
"-s = [int(x) for x in s]",
"-a = s.count(1)",
"-b = s.count(0)",
"-print((len(s) - abs(a - b)))",
"+rc = s.count(\"0\")",
"+bc = s.count(\"1\")",
"+min1 = min(rc, bc)",
"+print((min1 * 2))"
] | false | 0.085731 | 0.043407 | 1.97507 | [
"s947277658",
"s416119677"
] |
u632413369 | p02712 | python | s930341718 | s817376317 | 75 | 62 | 64,696 | 61,900 | Accepted | Accepted | 17.33 | N = int(eval(input()))
ans = 0
for i in range(1,N+1):
if i % 3 != 0 and i % 5 != 0:
ans += i
print(ans) | N = int(eval(input()))
total = int(1/2 * N * (N+1))
wa3 = (N//3 * (N//3 + 1)) // 2 * 3
wa5 = (N//5 * (N//5 + 1)) // 2 * 5
wa15 = (N//15 * (N//15 + 1)) // 2 * 15
print((total - wa3 - wa5 + wa15)) | 6 | 6 | 114 | 195 | N = int(eval(input()))
ans = 0
for i in range(1, N + 1):
if i % 3 != 0 and i % 5 != 0:
ans += i
print(ans)
| N = int(eval(input()))
total = int(1 / 2 * N * (N + 1))
wa3 = (N // 3 * (N // 3 + 1)) // 2 * 3
wa5 = (N // 5 * (N // 5 + 1)) // 2 * 5
wa15 = (N // 15 * (N // 15 + 1)) // 2 * 15
print((total - wa3 - wa5 + wa15))
| false | 0 | [
"-ans = 0",
"-for i in range(1, N + 1):",
"- if i % 3 != 0 and i % 5 != 0:",
"- ans += i",
"-print(ans)",
"+total = int(1 / 2 * N * (N + 1))",
"+wa3 = (N // 3 * (N // 3 + 1)) // 2 * 3",
"+wa5 = (N // 5 * (N // 5 + 1)) // 2 * 5",
"+wa15 = (N // 15 * (N // 15 + 1)) // 2 * 15",
"+print((total - wa3 - wa5 + wa15))"
] | false | 0.183516 | 0.038347 | 4.785734 | [
"s930341718",
"s817376317"
] |
u640603056 | p03087 | python | s477996750 | s172481713 | 825 | 253 | 7,748 | 7,916 | Accepted | Accepted | 69.33 | def main():
N,Q=list(map(int,input().split()))
S=eval(input())
A=[0]*N
# 累積和
for i in range(1,N):
A[i]=S[i-1:i+1]=="AC"
A[i]=A[i]+A[i-1]
# [l:r)区間の総和を求める
for i in range(Q):
l,r=list(map(int,input().split()))
print((A[r-1]-A[l-1]))
if __name__=='__main__':
main() | import sys
def main():
N,Q=list(map(int,sys.stdin.readline().split()))
S=eval(input())
A=[0]*N
# 累積和
for i in range(1,N):
A[i]=S[i-1:i+1]=="AC"
A[i]=A[i]+A[i-1]
# [l:r)区間の総和を求める
for i in range(Q):
l,r=list(map(int,sys.stdin.readline().split()))
print((A[r-1]-A[l-1]))
if __name__=='__main__':
main() | 14 | 16 | 271 | 311 | def main():
N, Q = list(map(int, input().split()))
S = eval(input())
A = [0] * N
# 累積和
for i in range(1, N):
A[i] = S[i - 1 : i + 1] == "AC"
A[i] = A[i] + A[i - 1]
# [l:r)区間の総和を求める
for i in range(Q):
l, r = list(map(int, input().split()))
print((A[r - 1] - A[l - 1]))
if __name__ == "__main__":
main()
| import sys
def main():
N, Q = list(map(int, sys.stdin.readline().split()))
S = eval(input())
A = [0] * N
# 累積和
for i in range(1, N):
A[i] = S[i - 1 : i + 1] == "AC"
A[i] = A[i] + A[i - 1]
# [l:r)区間の総和を求める
for i in range(Q):
l, r = list(map(int, sys.stdin.readline().split()))
print((A[r - 1] - A[l - 1]))
if __name__ == "__main__":
main()
| false | 12.5 | [
"+import sys",
"+",
"+",
"- N, Q = list(map(int, input().split()))",
"+ N, Q = list(map(int, sys.stdin.readline().split()))",
"- l, r = list(map(int, input().split()))",
"+ l, r = list(map(int, sys.stdin.readline().split()))"
] | false | 0.037095 | 0.085662 | 0.433045 | [
"s477996750",
"s172481713"
] |
u023229441 | p02597 | python | s693439352 | s298232271 | 128 | 87 | 10,484 | 81,816 | Accepted | Accepted | 32.03 | n=int(eval(input()))
A=list(eval(input()))
w=A.count("W")
r=A.count("R")
W=0 ; R=r
ans=R
for i in range(n):
if A[i]=="W": W+=1
else: R-=1
ans=min(ans, max(W,R))
print(ans)
| n=int(eval(input()))
A=list(eval(input()))
w=0 ; r=A.count("R") ; ans=10**7
for i in range(n+1):
ans=min(ans, max(w,r))
if i==n:print(ans);exit()
if A[i]=="R":
r-=1
else:
w+=1
| 15 | 10 | 193 | 205 | n = int(eval(input()))
A = list(eval(input()))
w = A.count("W")
r = A.count("R")
W = 0
R = r
ans = R
for i in range(n):
if A[i] == "W":
W += 1
else:
R -= 1
ans = min(ans, max(W, R))
print(ans)
| n = int(eval(input()))
A = list(eval(input()))
w = 0
r = A.count("R")
ans = 10**7
for i in range(n + 1):
ans = min(ans, max(w, r))
if i == n:
print(ans)
exit()
if A[i] == "R":
r -= 1
else:
w += 1
| false | 33.333333 | [
"-w = A.count(\"W\")",
"+w = 0",
"-W = 0",
"-R = r",
"-ans = R",
"-for i in range(n):",
"- if A[i] == \"W\":",
"- W += 1",
"+ans = 10**7",
"+for i in range(n + 1):",
"+ ans = min(ans, max(w, r))",
"+ if i == n:",
"+ print(ans)",
"+ exit()",
"+ if A[i] == \"R\":",
"+ r -= 1",
"- R -= 1",
"- ans = min(ans, max(W, R))",
"-print(ans)",
"+ w += 1"
] | false | 0.036646 | 0.036321 | 1.008941 | [
"s693439352",
"s298232271"
] |
u423966555 | p02691 | python | s165102610 | s521451825 | 251 | 191 | 61,532 | 50,640 | Accepted | Accepted | 23.9 | from collections import defaultdict
N = int(eval(input()))
A = list(map(int, input().split()))
d = defaultdict(int)
for i, a in enumerate(A):
d[i+a] += 1
ans = 0
for j, a in enumerate(A):
ans += d[j-a]
print(ans)
| from collections import Counter
N = int(eval(input()))
A = list(map(int, input().split()))
s = [i+a for i, a in enumerate(A)]
t = [j-a for j, a in enumerate(A)]
d = Counter(s)
ans = 0
for i in t:
ans += d[i]
print(ans) | 15 | 13 | 234 | 231 | from collections import defaultdict
N = int(eval(input()))
A = list(map(int, input().split()))
d = defaultdict(int)
for i, a in enumerate(A):
d[i + a] += 1
ans = 0
for j, a in enumerate(A):
ans += d[j - a]
print(ans)
| from collections import Counter
N = int(eval(input()))
A = list(map(int, input().split()))
s = [i + a for i, a in enumerate(A)]
t = [j - a for j, a in enumerate(A)]
d = Counter(s)
ans = 0
for i in t:
ans += d[i]
print(ans)
| false | 13.333333 | [
"-from collections import defaultdict",
"+from collections import Counter",
"-d = defaultdict(int)",
"-for i, a in enumerate(A):",
"- d[i + a] += 1",
"+s = [i + a for i, a in enumerate(A)]",
"+t = [j - a for j, a in enumerate(A)]",
"+d = Counter(s)",
"-for j, a in enumerate(A):",
"- ans += d[j - a]",
"+for i in t:",
"+ ans += d[i]"
] | false | 0.103085 | 0.09833 | 1.048357 | [
"s165102610",
"s521451825"
] |
u186838327 | p02879 | python | s155043722 | s919055790 | 183 | 70 | 38,256 | 61,768 | Accepted | Accepted | 61.75 | a, b = list(map(int, input().split()))
if 1<=a and a <= 9 and 1 <= b and b <= 9:
print((a*b))
else:
print((-1)) | a, b = list(map(int, input().split()))
if 1 <= a <= 9 and 1 <= b <= 9:
print((a*b))
else:
print((-1))
| 5 | 5 | 109 | 104 | a, b = list(map(int, input().split()))
if 1 <= a and a <= 9 and 1 <= b and b <= 9:
print((a * b))
else:
print((-1))
| a, b = list(map(int, input().split()))
if 1 <= a <= 9 and 1 <= b <= 9:
print((a * b))
else:
print((-1))
| false | 0 | [
"-if 1 <= a and a <= 9 and 1 <= b and b <= 9:",
"+if 1 <= a <= 9 and 1 <= b <= 9:"
] | false | 0.037104 | 0.036847 | 1.006973 | [
"s155043722",
"s919055790"
] |
u957167787 | p03127 | python | s414983155 | s709483727 | 175 | 87 | 14,180 | 15,020 | Accepted | Accepted | 50.29 | import heapq
N = int(eval(input()))
A = list(map(int, input().split()))
heapq.heapify(A)
flag = True
while flag:
minA = heapq.heappop(A) # 最小値を取り出す
if len(A) == 0: # 要素がなかったら終わり
break
if minA == 0: # 0だったら除外したまま続ける
continue
A = list([x % minA for x in A])
heapq.heappush(A, minA)
print(minA) | N = int(eval(input()))
A = list(map(int, input().split()))
def gcd(a, b):
if b == 0:
return a
else:
return(gcd(b, a % b))
ans = A[0]
for i in range(1, N):
ans = gcd(ans, A[i])
print(ans) | 18 | 14 | 347 | 224 | import heapq
N = int(eval(input()))
A = list(map(int, input().split()))
heapq.heapify(A)
flag = True
while flag:
minA = heapq.heappop(A) # 最小値を取り出す
if len(A) == 0: # 要素がなかったら終わり
break
if minA == 0: # 0だったら除外したまま続ける
continue
A = list([x % minA for x in A])
heapq.heappush(A, minA)
print(minA)
| N = int(eval(input()))
A = list(map(int, input().split()))
def gcd(a, b):
if b == 0:
return a
else:
return gcd(b, a % b)
ans = A[0]
for i in range(1, N):
ans = gcd(ans, A[i])
print(ans)
| false | 22.222222 | [
"-import heapq",
"-",
"-heapq.heapify(A)",
"-flag = True",
"-while flag:",
"- minA = heapq.heappop(A) # 最小値を取り出す",
"- if len(A) == 0: # 要素がなかったら終わり",
"- break",
"- if minA == 0: # 0だったら除外したまま続ける",
"- continue",
"- A = list([x % minA for x in A])",
"- heapq.heappush(A, minA)",
"-print(minA)",
"+",
"+",
"+def gcd(a, b):",
"+ if b == 0:",
"+ return a",
"+ else:",
"+ return gcd(b, a % b)",
"+",
"+",
"+ans = A[0]",
"+for i in range(1, N):",
"+ ans = gcd(ans, A[i])",
"+print(ans)"
] | false | 0.087984 | 0.046061 | 1.910161 | [
"s414983155",
"s709483727"
] |
u164727245 | p02647 | python | s744317804 | s995807131 | 741 | 677 | 130,260 | 131,028 | Accepted | Accepted | 8.64 | # coding: utf-8
import numpy as np
from numba import b1, i8, njit, types
@njit(types.Tuple((i8[:], b1))(i8[:]), cache=True)
def f(A):
n = len(A)
ret = np.zeros_like(A)
for x, p in enumerate(A):
ret[max(0, x-p)] += 1
if x+p+1 < n:
ret[x+p+1] -= 1
ret = ret.cumsum()
return ret, np.all(A == n)
def solve(*args: str) -> str:
n, k = list(map(int, args[0].split()))
A = np.array(tuple(map(int, args[1].split())), int)
for _ in range(k):
A, satulated = f(A)
if satulated:
break
return ' '.join(map(str, A))
if __name__ == "__main__":
print((solve(*(open(0).read().splitlines()))))
| # coding: utf-8
import numpy as np
from numba import b1, i8, njit, types
@njit(types.Tuple((i8[:], b1))(i8[:]), cache=True)
def f(A):
n = len(A)
ret = np.zeros_like(A)
for x, p in enumerate(A):
ret[max(0, x-p)] += 1
if x+p+1 < n:
ret[x+p+1] -= 1
satulated = True
for i in range(1, n):
ret[i] += ret[i-1]
satulated &= ret[i] == n
return ret, satulated
def solve(*args: str) -> str:
n, k = list(map(int, args[0].split()))
A = np.array(tuple(map(int, args[1].split())))
for _ in range(k):
A, satulated = f(A)
if satulated:
break
return ' '.join(map(str, A))
if __name__ == "__main__":
print((solve(*(open(0).read().splitlines()))))
| 30 | 35 | 699 | 780 | # coding: utf-8
import numpy as np
from numba import b1, i8, njit, types
@njit(types.Tuple((i8[:], b1))(i8[:]), cache=True)
def f(A):
n = len(A)
ret = np.zeros_like(A)
for x, p in enumerate(A):
ret[max(0, x - p)] += 1
if x + p + 1 < n:
ret[x + p + 1] -= 1
ret = ret.cumsum()
return ret, np.all(A == n)
def solve(*args: str) -> str:
n, k = list(map(int, args[0].split()))
A = np.array(tuple(map(int, args[1].split())), int)
for _ in range(k):
A, satulated = f(A)
if satulated:
break
return " ".join(map(str, A))
if __name__ == "__main__":
print((solve(*(open(0).read().splitlines()))))
| # coding: utf-8
import numpy as np
from numba import b1, i8, njit, types
@njit(types.Tuple((i8[:], b1))(i8[:]), cache=True)
def f(A):
n = len(A)
ret = np.zeros_like(A)
for x, p in enumerate(A):
ret[max(0, x - p)] += 1
if x + p + 1 < n:
ret[x + p + 1] -= 1
satulated = True
for i in range(1, n):
ret[i] += ret[i - 1]
satulated &= ret[i] == n
return ret, satulated
def solve(*args: str) -> str:
n, k = list(map(int, args[0].split()))
A = np.array(tuple(map(int, args[1].split())))
for _ in range(k):
A, satulated = f(A)
if satulated:
break
return " ".join(map(str, A))
if __name__ == "__main__":
print((solve(*(open(0).read().splitlines()))))
| false | 14.285714 | [
"- ret = ret.cumsum()",
"- return ret, np.all(A == n)",
"+ satulated = True",
"+ for i in range(1, n):",
"+ ret[i] += ret[i - 1]",
"+ satulated &= ret[i] == n",
"+ return ret, satulated",
"- A = np.array(tuple(map(int, args[1].split())), int)",
"+ A = np.array(tuple(map(int, args[1].split())))"
] | false | 0.222682 | 0.206389 | 1.078944 | [
"s744317804",
"s995807131"
] |
u113971909 | p02725 | python | s851922721 | s617241748 | 239 | 87 | 26,060 | 25,884 | Accepted | Accepted | 63.6 | k,n=list(map(int, input().split()))
a=list(map(int, input().split()))
a.append(k+a[0])
import numpy as np
a=np.array(a)
print((k-max(a[1:]-a[:n])))
| #!/usr/bin python3
# -*- coding: utf-8 -*-
import sys
input = sys.stdin.readline
def main():
K, N = list(map(int, input().split()))
A = list(map(int, input().split()))
A.append(K+A[0])
print((K - max([A[i]-A[i-1] for i in range(1, N+1)])))
if __name__ == '__main__':
main() | 6 | 14 | 145 | 301 | k, n = list(map(int, input().split()))
a = list(map(int, input().split()))
a.append(k + a[0])
import numpy as np
a = np.array(a)
print((k - max(a[1:] - a[:n])))
| #!/usr/bin python3
# -*- coding: utf-8 -*-
import sys
input = sys.stdin.readline
def main():
K, N = list(map(int, input().split()))
A = list(map(int, input().split()))
A.append(K + A[0])
print((K - max([A[i] - A[i - 1] for i in range(1, N + 1)])))
if __name__ == "__main__":
main()
| false | 57.142857 | [
"-k, n = list(map(int, input().split()))",
"-a = list(map(int, input().split()))",
"-a.append(k + a[0])",
"-import numpy as np",
"+#!/usr/bin python3",
"+# -*- coding: utf-8 -*-",
"+import sys",
"-a = np.array(a)",
"-print((k - max(a[1:] - a[:n])))",
"+input = sys.stdin.readline",
"+",
"+",
"+def main():",
"+ K, N = list(map(int, input().split()))",
"+ A = list(map(int, input().split()))",
"+ A.append(K + A[0])",
"+ print((K - max([A[i] - A[i - 1] for i in range(1, N + 1)])))",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ main()"
] | false | 0.23871 | 0.04319 | 5.527003 | [
"s851922721",
"s617241748"
] |
u641406334 | p03449 | python | s392620593 | s576902808 | 20 | 17 | 3,060 | 3,060 | Accepted | Accepted | 15 | n = int(eval(input()))
a1 = list(map(int,input().split()))
a2 = list(map(int,input().split()))
ans = [0]*n
for i in range(n):
ans[i] = a1[0:i+1] + a2[i::]
ans[i] = sum(ans[i])
print((max(ans))) | n = int(eval(input()))
a1 = list(map(int,input().split()))
a2 = list(map(int,input().split()))
ans = [0]*n
for i in range(n):
ans[i] = sum(a1[0:i+1]) + sum(a2[i::])
print((max(ans))) | 8 | 7 | 196 | 182 | n = int(eval(input()))
a1 = list(map(int, input().split()))
a2 = list(map(int, input().split()))
ans = [0] * n
for i in range(n):
ans[i] = a1[0 : i + 1] + a2[i::]
ans[i] = sum(ans[i])
print((max(ans)))
| n = int(eval(input()))
a1 = list(map(int, input().split()))
a2 = list(map(int, input().split()))
ans = [0] * n
for i in range(n):
ans[i] = sum(a1[0 : i + 1]) + sum(a2[i::])
print((max(ans)))
| false | 12.5 | [
"- ans[i] = a1[0 : i + 1] + a2[i::]",
"- ans[i] = sum(ans[i])",
"+ ans[i] = sum(a1[0 : i + 1]) + sum(a2[i::])"
] | false | 0.051183 | 0.049573 | 1.032476 | [
"s392620593",
"s576902808"
] |
u608088992 | p02829 | python | s525370630 | s263551903 | 164 | 25 | 38,384 | 9,004 | Accepted | Accepted | 84.76 | import sys
def solve():
A = int(eval(input()))
B = int(eval(input()))
Num = set([A, B])
All = set([1, 2, 3])
All -= Num
for key in All: print(key)
return 0
if __name__ == "__main__":
solve() | import sys
def solve():
input = sys.stdin.readline
A = int(eval(input()))
B = int(eval(input()))
C = list(set([1, 2, 3]) - set([A, B]))
print((C[0]))
return 0
if __name__ == "__main__":
solve() | 14 | 13 | 226 | 222 | import sys
def solve():
A = int(eval(input()))
B = int(eval(input()))
Num = set([A, B])
All = set([1, 2, 3])
All -= Num
for key in All:
print(key)
return 0
if __name__ == "__main__":
solve()
| import sys
def solve():
input = sys.stdin.readline
A = int(eval(input()))
B = int(eval(input()))
C = list(set([1, 2, 3]) - set([A, B]))
print((C[0]))
return 0
if __name__ == "__main__":
solve()
| false | 7.142857 | [
"+ input = sys.stdin.readline",
"- Num = set([A, B])",
"- All = set([1, 2, 3])",
"- All -= Num",
"- for key in All:",
"- print(key)",
"+ C = list(set([1, 2, 3]) - set([A, B]))",
"+ print((C[0]))"
] | false | 0.084085 | 0.038679 | 2.173918 | [
"s525370630",
"s263551903"
] |
u837340160 | p02571 | python | s877531544 | s838619850 | 86 | 48 | 9,048 | 8,928 | Accepted | Accepted | 44.19 | S = eval(input())
T = eval(input())
N = len(S)
M = len(T)
ans = M
for i in range(N-M+1):
cnt = 0
for j in range(M):
if T[j] != S[i:i+M][j]:
cnt += 1
ans = min(ans, cnt)
print(ans)
| S = eval(input())
T = eval(input())
N = len(S)
M = len(T)
ans = M
for i in range(N-M+1):
S_2 = S[i:i+M]
cnt = 0
for j in range(M):
if T[j] != S_2[j]:
cnt += 1
ans = min(ans, cnt)
print(ans)
| 14 | 15 | 215 | 230 | S = eval(input())
T = eval(input())
N = len(S)
M = len(T)
ans = M
for i in range(N - M + 1):
cnt = 0
for j in range(M):
if T[j] != S[i : i + M][j]:
cnt += 1
ans = min(ans, cnt)
print(ans)
| S = eval(input())
T = eval(input())
N = len(S)
M = len(T)
ans = M
for i in range(N - M + 1):
S_2 = S[i : i + M]
cnt = 0
for j in range(M):
if T[j] != S_2[j]:
cnt += 1
ans = min(ans, cnt)
print(ans)
| false | 6.666667 | [
"+ S_2 = S[i : i + M]",
"- if T[j] != S[i : i + M][j]:",
"+ if T[j] != S_2[j]:"
] | false | 0.070713 | 0.035971 | 1.965811 | [
"s877531544",
"s838619850"
] |
u538817603 | p02861 | python | s233557317 | s950683589 | 150 | 17 | 14,476 | 3,064 | Accepted | Accepted | 88.67 | import numpy as np
import itertools
N = int(eval(input()))
p = [list(map(int,input().split())) for _ in range(N)]
print((sum(np.sqrt((p[i][0] - p[j][0])**2 + (p[i][1] - p[j][1])**2) for i, j in itertools.combinations(list(range(N)), 2)) * np.math.factorial(N - 1) * 2 / np.math.factorial(N))) | from sys import stdin
#input = stdin.readlines
import math
def main():
N = int(eval(input()))
p = [list(map(int, input().split())) for _ in range(N)]
s = 0.0
for i in range(N - 1):
for j in range(i + 1, N):
s += math.sqrt((p[i][0] - p[j][0])**2 + (p[i][1] - p[j][1])**2)
print((s*2/N))
if __name__ == '__main__':
main() | 5 | 15 | 282 | 371 | import numpy as np
import itertools
N = int(eval(input()))
p = [list(map(int, input().split())) for _ in range(N)]
print(
(
sum(
np.sqrt((p[i][0] - p[j][0]) ** 2 + (p[i][1] - p[j][1]) ** 2)
for i, j in itertools.combinations(list(range(N)), 2)
)
* np.math.factorial(N - 1)
* 2
/ np.math.factorial(N)
)
)
| from sys import stdin
# input = stdin.readlines
import math
def main():
N = int(eval(input()))
p = [list(map(int, input().split())) for _ in range(N)]
s = 0.0
for i in range(N - 1):
for j in range(i + 1, N):
s += math.sqrt((p[i][0] - p[j][0]) ** 2 + (p[i][1] - p[j][1]) ** 2)
print((s * 2 / N))
if __name__ == "__main__":
main()
| false | 66.666667 | [
"-import numpy as np",
"-import itertools",
"+from sys import stdin",
"-N = int(eval(input()))",
"-p = [list(map(int, input().split())) for _ in range(N)]",
"-print(",
"- (",
"- sum(",
"- np.sqrt((p[i][0] - p[j][0]) ** 2 + (p[i][1] - p[j][1]) ** 2)",
"- for i, j in itertools.combinations(list(range(N)), 2)",
"- )",
"- * np.math.factorial(N - 1)",
"- * 2",
"- / np.math.factorial(N)",
"- )",
"-)",
"+# input = stdin.readlines",
"+import math",
"+",
"+",
"+def main():",
"+ N = int(eval(input()))",
"+ p = [list(map(int, input().split())) for _ in range(N)]",
"+ s = 0.0",
"+ for i in range(N - 1):",
"+ for j in range(i + 1, N):",
"+ s += math.sqrt((p[i][0] - p[j][0]) ** 2 + (p[i][1] - p[j][1]) ** 2)",
"+ print((s * 2 / N))",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ main()"
] | false | 0.224077 | 0.038662 | 5.795752 | [
"s233557317",
"s950683589"
] |
u513081876 | p03266 | python | s789622341 | s909716317 | 100 | 69 | 3,060 | 3,060 | Accepted | Accepted | 31 | n, k = list(map(int,input().split()))
a, b = 0, 0
for i in range(1,n+1):
if i % k == 0:
a += 1
for i in range(1, n+1):
if i % k == k // 2:
b += 1
if k % 2 == 0:
print((a**3 + b**3))
else:
print((a**3))
| N, K = list(map(int, input().split()))
ans = 0
num = 0
if K % 2 != 0:
tmp = N // K
ans = tmp ** 3
else:
tmp1, tmp2 = 0, 0
for i in range(1, N+1):
if i % K == 0:
tmp1 += 1
elif i % (K//2) == 0:
tmp2 += 1
ans = tmp1 ** 3 + tmp2 ** 3
print(ans)
| 14 | 16 | 228 | 312 | n, k = list(map(int, input().split()))
a, b = 0, 0
for i in range(1, n + 1):
if i % k == 0:
a += 1
for i in range(1, n + 1):
if i % k == k // 2:
b += 1
if k % 2 == 0:
print((a**3 + b**3))
else:
print((a**3))
| N, K = list(map(int, input().split()))
ans = 0
num = 0
if K % 2 != 0:
tmp = N // K
ans = tmp**3
else:
tmp1, tmp2 = 0, 0
for i in range(1, N + 1):
if i % K == 0:
tmp1 += 1
elif i % (K // 2) == 0:
tmp2 += 1
ans = tmp1**3 + tmp2**3
print(ans)
| false | 12.5 | [
"-n, k = list(map(int, input().split()))",
"-a, b = 0, 0",
"-for i in range(1, n + 1):",
"- if i % k == 0:",
"- a += 1",
"-for i in range(1, n + 1):",
"- if i % k == k // 2:",
"- b += 1",
"-if k % 2 == 0:",
"- print((a**3 + b**3))",
"+N, K = list(map(int, input().split()))",
"+ans = 0",
"+num = 0",
"+if K % 2 != 0:",
"+ tmp = N // K",
"+ ans = tmp**3",
"- print((a**3))",
"+ tmp1, tmp2 = 0, 0",
"+ for i in range(1, N + 1):",
"+ if i % K == 0:",
"+ tmp1 += 1",
"+ elif i % (K // 2) == 0:",
"+ tmp2 += 1",
"+ ans = tmp1**3 + tmp2**3",
"+print(ans)"
] | false | 0.043041 | 0.037746 | 1.140283 | [
"s789622341",
"s909716317"
] |
u634046173 | p02983 | python | s906447092 | s116933365 | 75 | 69 | 65,340 | 65,168 | Accepted | Accepted | 8 | L, R = list(map(int, input().split()))
target = R+1
if R - L > 2018:
target = L + 2018
mi = 2019
for i in range(L,target):
for j in range(i+1,target):
mi = min(mi,(i*j)%2019)
print(mi) | L, R = list(map(int, input().split()))
target = R+1
if R - L > 2017:
target = L + 2017
mi = 2019
for i in range(L,target):
for j in range(i+1,target):
mi = min(mi,(i*j)%2019)
print(mi) | 9 | 9 | 202 | 202 | L, R = list(map(int, input().split()))
target = R + 1
if R - L > 2018:
target = L + 2018
mi = 2019
for i in range(L, target):
for j in range(i + 1, target):
mi = min(mi, (i * j) % 2019)
print(mi)
| L, R = list(map(int, input().split()))
target = R + 1
if R - L > 2017:
target = L + 2017
mi = 2019
for i in range(L, target):
for j in range(i + 1, target):
mi = min(mi, (i * j) % 2019)
print(mi)
| false | 0 | [
"-if R - L > 2018:",
"- target = L + 2018",
"+if R - L > 2017:",
"+ target = L + 2017"
] | false | 0.073786 | 0.074339 | 0.992559 | [
"s906447092",
"s116933365"
] |
u309120194 | p02572 | python | s699369778 | s046582380 | 188 | 154 | 31,540 | 31,644 | Accepted | Accepted | 18.09 | N = int(eval(input()))
A = list(map(int, input().split()))
s = 0
for i in range(N):
s += A[i]
s %= (10**9+7)
s = s**2
s %= (10**9+7)
t = 0
for i in range(N):
t += (A[i]**2 % (10**9+7))
t %= (10**9+7)
ans = (s-t) % (10**9+7)
'''
tmp = (2**1000000005) % (10**9+7)
'''
tmp = 500000004
ans *= tmp
ans %= (10**9+7)
print(ans) | N = int(eval(input()))
A = list(map(int, input().split()))
s, t = 0, 0
for i in range(N):
s += A[i]
t += A[i]**2
s = s**2
ans = (s-t) % (10**9+7)
# tmp = (2**1000000005) % (10**9+7)
tmp = 500000004
ans = (ans*tmp) % (10**9+7)
print(ans) | 23 | 14 | 348 | 250 | N = int(eval(input()))
A = list(map(int, input().split()))
s = 0
for i in range(N):
s += A[i]
s %= 10**9 + 7
s = s**2
s %= 10**9 + 7
t = 0
for i in range(N):
t += A[i] ** 2 % (10**9 + 7)
t %= 10**9 + 7
ans = (s - t) % (10**9 + 7)
"""
tmp = (2**1000000005) % (10**9+7)
"""
tmp = 500000004
ans *= tmp
ans %= 10**9 + 7
print(ans)
| N = int(eval(input()))
A = list(map(int, input().split()))
s, t = 0, 0
for i in range(N):
s += A[i]
t += A[i] ** 2
s = s**2
ans = (s - t) % (10**9 + 7)
# tmp = (2**1000000005) % (10**9+7)
tmp = 500000004
ans = (ans * tmp) % (10**9 + 7)
print(ans)
| false | 39.130435 | [
"-s = 0",
"+s, t = 0, 0",
"- s %= 10**9 + 7",
"+ t += A[i] ** 2",
"-s %= 10**9 + 7",
"-t = 0",
"-for i in range(N):",
"- t += A[i] ** 2 % (10**9 + 7)",
"-t %= 10**9 + 7",
"-\"\"\"",
"-tmp = (2**1000000005) % (10**9+7)",
"-\"\"\"",
"+# tmp = (2**1000000005) % (10**9+7)",
"-ans *= tmp",
"-ans %= 10**9 + 7",
"+ans = (ans * tmp) % (10**9 + 7)"
] | false | 0.082543 | 0.12375 | 0.667019 | [
"s699369778",
"s046582380"
] |
u133936772 | p02803 | python | s869242498 | s233926317 | 397 | 365 | 27,272 | 9,464 | Accepted | Accepted | 8.06 | h,w=list(map(int,input().split()))
g=[eval(input()) for _ in range(h)]
import numpy as np
from collections import *
a=0
for sx in range(h):
for sy in range(w):
if g[sx][sy]=='#': continue
d=[[-1]*w for _ in range(h)]
d[sx][sy]=0
q=deque([(sx,sy)])
while q:
x,y=q.popleft()
for dx,dy in [(1,0),(0,1),(-1,0),(0,-1)]:
nx,ny=x+dx,y+dy
if 0<=nx<h and 0<=ny<w and g[nx][ny]=='.' and d[nx][ny]<0:
d[nx][ny]=d[x][y]+1
q.append((nx,ny))
a=max(a,np.max(d))
print(a) | h,w=list(map(int,input().split()))
g=[[*eval(input())] for _ in range(h)]
from collections import *
a=0
for sx in range(h):
for sy in range(w):
if g[sx][sy]=='#': continue
d=[[-1]*w for _ in range(h)]
d[sx][sy]=0
q=deque([(sx,sy)])
while q:
x,y=q.popleft()
t=d[x][y]+1
for dx,dy in [(1,0),(0,1),(-1,0),(0,-1)]:
nx,ny=x+dx,y+dy
if 0<=nx<h and 0<=ny<w and g[nx][ny]=='.' and d[nx][ny]<0:
d[nx][ny]=t
q.append((nx,ny))
a=max(a,t)
print(a) | 20 | 20 | 536 | 528 | h, w = list(map(int, input().split()))
g = [eval(input()) for _ in range(h)]
import numpy as np
from collections import *
a = 0
for sx in range(h):
for sy in range(w):
if g[sx][sy] == "#":
continue
d = [[-1] * w for _ in range(h)]
d[sx][sy] = 0
q = deque([(sx, sy)])
while q:
x, y = q.popleft()
for dx, dy in [(1, 0), (0, 1), (-1, 0), (0, -1)]:
nx, ny = x + dx, y + dy
if 0 <= nx < h and 0 <= ny < w and g[nx][ny] == "." and d[nx][ny] < 0:
d[nx][ny] = d[x][y] + 1
q.append((nx, ny))
a = max(a, np.max(d))
print(a)
| h, w = list(map(int, input().split()))
g = [[*eval(input())] for _ in range(h)]
from collections import *
a = 0
for sx in range(h):
for sy in range(w):
if g[sx][sy] == "#":
continue
d = [[-1] * w for _ in range(h)]
d[sx][sy] = 0
q = deque([(sx, sy)])
while q:
x, y = q.popleft()
t = d[x][y] + 1
for dx, dy in [(1, 0), (0, 1), (-1, 0), (0, -1)]:
nx, ny = x + dx, y + dy
if 0 <= nx < h and 0 <= ny < w and g[nx][ny] == "." and d[nx][ny] < 0:
d[nx][ny] = t
q.append((nx, ny))
a = max(a, t)
print(a)
| false | 0 | [
"-g = [eval(input()) for _ in range(h)]",
"-import numpy as np",
"+g = [[*eval(input())] for _ in range(h)]",
"+ t = d[x][y] + 1",
"- d[nx][ny] = d[x][y] + 1",
"+ d[nx][ny] = t",
"- a = max(a, np.max(d))",
"+ a = max(a, t)"
] | false | 0.165831 | 0.051615 | 3.212848 | [
"s869242498",
"s233926317"
] |
u334712262 | p02665 | python | s640662837 | s362664402 | 596 | 268 | 101,184 | 94,988 | Accepted | Accepted | 55.03 | # -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub
import sys
# sys.setrecursionlimit(10**6)
# buff_readline = sys.stdin.buffer.readline
buff_readline = sys.stdin.readline
readline = sys.stdin.readline
INF = 2**62-1
def read_int():
return int(buff_readline())
def read_int_n():
return list(map(int, buff_readline().split()))
def read_float():
return float(buff_readline())
def read_float_n():
return list(map(float, buff_readline().split()))
def read_str():
return readline().strip()
def read_str_n():
return readline().strip().split()
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.time()
ret = f(*args, **kwargs)
e = time.time()
error_print(e - s, 'sec')
return ret
return wrap
@mt
def slv(N, A):
sa = [0]
for a in A:
sa.append(sa[-1]+a)
if N == 0:
if A[0] == 1:
return 1
else:
return -1
if A[0] != 0:
return -1
ans = 1
p = 1
for i in range(1, N+1):
if p * 2 < A[i]:
return -1
m = min(p*2, sa[-1] - sa[i])
ans += m
if m - A[i] < 0:
return -1
p = m - A[i]
return ans
def main():
N = read_int()
A = read_int_n()
print(slv(N, A))
if __name__ == '__main__':
main()
| # -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub
import sys
# sys.setrecursionlimit(10**6)
# buff_readline = sys.stdin.buffer.readline
buff_readline = sys.stdin.readline
readline = sys.stdin.readline
INF = 2**62-1
def read_int():
return int(buff_readline())
def read_int_n():
return list(map(int, buff_readline().split()))
def read_float():
return float(buff_readline())
def read_float_n():
return list(map(float, buff_readline().split()))
def read_str():
return readline().strip()
def read_str_n():
return readline().strip().split()
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.time()
ret = f(*args, **kwargs)
e = time.time()
error_print(e - s, 'sec')
return ret
return wrap
@mt
def slv(N, A):
sa = [0]
for a in A:
sa.append(sa[-1]+a)
if N == 0:
if A[0] == 1:
return 1
else:
return -1
if A[0] != 0:
return -1
ans = 1
p = 1
for i in range(1, N+1):
m = min(p*2, sa[-1] - sa[i])
ans += m
if m - A[i] < 0:
return -1
p = m - A[i]
return ans
def main():
N = read_int()
A = read_int_n()
print(slv(N, A))
if __name__ == '__main__':
main()
| 99 | 98 | 1,806 | 1,767 | # -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub
import sys
# sys.setrecursionlimit(10**6)
# buff_readline = sys.stdin.buffer.readline
buff_readline = sys.stdin.readline
readline = sys.stdin.readline
INF = 2**62 - 1
def read_int():
return int(buff_readline())
def read_int_n():
return list(map(int, buff_readline().split()))
def read_float():
return float(buff_readline())
def read_float_n():
return list(map(float, buff_readline().split()))
def read_str():
return readline().strip()
def read_str_n():
return readline().strip().split()
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.time()
ret = f(*args, **kwargs)
e = time.time()
error_print(e - s, "sec")
return ret
return wrap
@mt
def slv(N, A):
sa = [0]
for a in A:
sa.append(sa[-1] + a)
if N == 0:
if A[0] == 1:
return 1
else:
return -1
if A[0] != 0:
return -1
ans = 1
p = 1
for i in range(1, N + 1):
if p * 2 < A[i]:
return -1
m = min(p * 2, sa[-1] - sa[i])
ans += m
if m - A[i] < 0:
return -1
p = m - A[i]
return ans
def main():
N = read_int()
A = read_int_n()
print(slv(N, A))
if __name__ == "__main__":
main()
| # -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub
import sys
# sys.setrecursionlimit(10**6)
# buff_readline = sys.stdin.buffer.readline
buff_readline = sys.stdin.readline
readline = sys.stdin.readline
INF = 2**62 - 1
def read_int():
return int(buff_readline())
def read_int_n():
return list(map(int, buff_readline().split()))
def read_float():
return float(buff_readline())
def read_float_n():
return list(map(float, buff_readline().split()))
def read_str():
return readline().strip()
def read_str_n():
return readline().strip().split()
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.time()
ret = f(*args, **kwargs)
e = time.time()
error_print(e - s, "sec")
return ret
return wrap
@mt
def slv(N, A):
sa = [0]
for a in A:
sa.append(sa[-1] + a)
if N == 0:
if A[0] == 1:
return 1
else:
return -1
if A[0] != 0:
return -1
ans = 1
p = 1
for i in range(1, N + 1):
m = min(p * 2, sa[-1] - sa[i])
ans += m
if m - A[i] < 0:
return -1
p = m - A[i]
return ans
def main():
N = read_int()
A = read_int_n()
print(slv(N, A))
if __name__ == "__main__":
main()
| false | 1.010101 | [
"- if p * 2 < A[i]:",
"- return -1"
] | false | 0.042115 | 0.043163 | 0.975729 | [
"s640662837",
"s362664402"
] |
u562935282 | p02608 | python | s407976777 | s725678038 | 1,914 | 323 | 70,616 | 9,188 | Accepted | Accepted | 83.12 | def calc(n):
ret = 0
for x in range(1, 10 ** 2 + 1):
for y in range(x, 10 ** 2 + 1):
rest = n - x * x - y * y - x * y # z*(x+y+z)
if rest < 0: break
for z in range(y, 10 ** 2):
t = z * (x + y + z)
if t > rest: break
if t == rest:
if x == y == z:
ret += 1
elif x == y or y == z or z == x:
ret += 3
else:
ret += 6
break
return ret
def main():
N = int(input())
ans = []
for n in range(1, N + 1):
ans.append(calc(n))
print(*ans, sep='\n')
if __name__ == '__main__':
main()
# import sys
# input = sys.stdin.readline
#
# sys.setrecursionlimit(10 ** 7)
#
# (int(x)-1 for x in input().split())
# rstrip()
#
# def binary_search(*, ok, ng, func):
# while abs(ok - ng) > 1:
# mid = (ok + ng) // 2
# if func(mid):
# ok = mid
# else:
# ng = mid
# return ok
| def main():
MX = 10 ** 2
N = int(input())
ctr = [0] * (N + 1)
for x in range(1, MX + 1):
for y in range(1, MX + 1):
for z in range(1, MX + 1):
t = x * x + y * y + z * z + x * y + y * z + z * x
if t <= N:
ctr[t] += 1
print(*ctr[1:], sep='\n')
if __name__ == '__main__':
main()
| 49 | 18 | 1,142 | 398 | def calc(n):
ret = 0
for x in range(1, 10**2 + 1):
for y in range(x, 10**2 + 1):
rest = n - x * x - y * y - x * y # z*(x+y+z)
if rest < 0:
break
for z in range(y, 10**2):
t = z * (x + y + z)
if t > rest:
break
if t == rest:
if x == y == z:
ret += 1
elif x == y or y == z or z == x:
ret += 3
else:
ret += 6
break
return ret
def main():
N = int(input())
ans = []
for n in range(1, N + 1):
ans.append(calc(n))
print(*ans, sep="\n")
if __name__ == "__main__":
main()
# import sys
# input = sys.stdin.readline
#
# sys.setrecursionlimit(10 ** 7)
#
# (int(x)-1 for x in input().split())
# rstrip()
#
# def binary_search(*, ok, ng, func):
# while abs(ok - ng) > 1:
# mid = (ok + ng) // 2
# if func(mid):
# ok = mid
# else:
# ng = mid
# return ok
| def main():
MX = 10**2
N = int(input())
ctr = [0] * (N + 1)
for x in range(1, MX + 1):
for y in range(1, MX + 1):
for z in range(1, MX + 1):
t = x * x + y * y + z * z + x * y + y * z + z * x
if t <= N:
ctr[t] += 1
print(*ctr[1:], sep="\n")
if __name__ == "__main__":
main()
| false | 63.265306 | [
"-def calc(n):",
"- ret = 0",
"- for x in range(1, 10**2 + 1):",
"- for y in range(x, 10**2 + 1):",
"- rest = n - x * x - y * y - x * y # z*(x+y+z)",
"- if rest < 0:",
"- break",
"- for z in range(y, 10**2):",
"- t = z * (x + y + z)",
"- if t > rest:",
"- break",
"- if t == rest:",
"- if x == y == z:",
"- ret += 1",
"- elif x == y or y == z or z == x:",
"- ret += 3",
"- else:",
"- ret += 6",
"- break",
"- return ret",
"-",
"-",
"+ MX = 10**2",
"- ans = []",
"- for n in range(1, N + 1):",
"- ans.append(calc(n))",
"- print(*ans, sep=\"\\n\")",
"+ ctr = [0] * (N + 1)",
"+ for x in range(1, MX + 1):",
"+ for y in range(1, MX + 1):",
"+ for z in range(1, MX + 1):",
"+ t = x * x + y * y + z * z + x * y + y * z + z * x",
"+ if t <= N:",
"+ ctr[t] += 1",
"+ print(*ctr[1:], sep=\"\\n\")",
"-# import sys",
"-# input = sys.stdin.readline",
"-#",
"-# sys.setrecursionlimit(10 ** 7)",
"-#",
"-# (int(x)-1 for x in input().split())",
"-# rstrip()",
"-#",
"-# def binary_search(*, ok, ng, func):",
"-# while abs(ok - ng) > 1:",
"-# mid = (ok + ng) // 2",
"-# if func(mid):",
"-# ok = mid",
"-# else:",
"-# ng = mid",
"-# return ok"
] | false | 0.050823 | 1.044371 | 0.048663 | [
"s407976777",
"s725678038"
] |
u409757418 | p03478 | python | s290514980 | s029239843 | 38 | 29 | 3,060 | 3,060 | Accepted | Accepted | 23.68 | n, a, b = list(map(int, input().split()))
total = 0
for i in range(1, n+1):
li = list(str(i))
m = 0
for j in li:
m += int(j)
if a <= m <= b:
total += i
print(total) | n, a, b = list(map(int, input().split()))
total = 0
for i in range(1, n+1):
m = 0
ni = i
while ni > 0:
m += ni % 10
ni = ni // 10
if a <= m <= b:
total += i
print(total) | 10 | 11 | 183 | 193 | n, a, b = list(map(int, input().split()))
total = 0
for i in range(1, n + 1):
li = list(str(i))
m = 0
for j in li:
m += int(j)
if a <= m <= b:
total += i
print(total)
| n, a, b = list(map(int, input().split()))
total = 0
for i in range(1, n + 1):
m = 0
ni = i
while ni > 0:
m += ni % 10
ni = ni // 10
if a <= m <= b:
total += i
print(total)
| false | 9.090909 | [
"- li = list(str(i))",
"- for j in li:",
"- m += int(j)",
"+ ni = i",
"+ while ni > 0:",
"+ m += ni % 10",
"+ ni = ni // 10"
] | false | 0.044641 | 0.044964 | 0.992823 | [
"s290514980",
"s029239843"
] |
u072717685 | p02630 | python | s615339895 | s562580962 | 532 | 229 | 103,492 | 110,848 | Accepted | Accepted | 56.95 | from collections import Counter
from collections import defaultdict
def main():
n = int(eval(input()))
a = list(map(int, input().split()))
q = int(eval(input()))
asum = sum(a)
ac = Counter(a)
acl = defaultdict(int)
for ae in ac:
acl[ae] = ac[ae]
for _ in range(q):
b, c = list(map(int, input().split()))
rmed = acl[b]
acl[c] += rmed
acl[b] = 0
asum -= b * rmed
asum += c * rmed
print(asum)
if __name__ == '__main__':
main()
| import sys
read = sys.stdin.read
readlines = sys.stdin.readlines
from collections import Counter
def main():
n = int(eval(input()))
a = tuple(map(int, input().split()))
suma = sum(a)
aa = Counter(a)
q = int(eval(input()))
m = list(map(int, read().split()))
for b, c in zip(m, m):
kosu = aa[b]
sa = c - b
suma += sa * kosu
print(suma)
aa[b] = 0
aa[c] += kosu
if __name__ == '__main__':
main()
| 23 | 21 | 530 | 475 | from collections import Counter
from collections import defaultdict
def main():
n = int(eval(input()))
a = list(map(int, input().split()))
q = int(eval(input()))
asum = sum(a)
ac = Counter(a)
acl = defaultdict(int)
for ae in ac:
acl[ae] = ac[ae]
for _ in range(q):
b, c = list(map(int, input().split()))
rmed = acl[b]
acl[c] += rmed
acl[b] = 0
asum -= b * rmed
asum += c * rmed
print(asum)
if __name__ == "__main__":
main()
| import sys
read = sys.stdin.read
readlines = sys.stdin.readlines
from collections import Counter
def main():
n = int(eval(input()))
a = tuple(map(int, input().split()))
suma = sum(a)
aa = Counter(a)
q = int(eval(input()))
m = list(map(int, read().split()))
for b, c in zip(m, m):
kosu = aa[b]
sa = c - b
suma += sa * kosu
print(suma)
aa[b] = 0
aa[c] += kosu
if __name__ == "__main__":
main()
| false | 8.695652 | [
"+import sys",
"+",
"+read = sys.stdin.read",
"+readlines = sys.stdin.readlines",
"-from collections import defaultdict",
"- a = list(map(int, input().split()))",
"+ a = tuple(map(int, input().split()))",
"+ suma = sum(a)",
"+ aa = Counter(a)",
"- asum = sum(a)",
"- ac = Counter(a)",
"- acl = defaultdict(int)",
"- for ae in ac:",
"- acl[ae] = ac[ae]",
"- for _ in range(q):",
"- b, c = list(map(int, input().split()))",
"- rmed = acl[b]",
"- acl[c] += rmed",
"- acl[b] = 0",
"- asum -= b * rmed",
"- asum += c * rmed",
"- print(asum)",
"+ m = list(map(int, read().split()))",
"+ for b, c in zip(m, m):",
"+ kosu = aa[b]",
"+ sa = c - b",
"+ suma += sa * kosu",
"+ print(suma)",
"+ aa[b] = 0",
"+ aa[c] += kosu"
] | false | 0.037 | 0.031502 | 1.174512 | [
"s615339895",
"s562580962"
] |
u337626942 | p02629 | python | s248191135 | s293560278 | 77 | 64 | 61,796 | 61,888 | Accepted | Accepted | 16.88 | n=int(input())
cnt=1##文字数
tmp=26
while n>tmp:
cnt+=1
tmp+=26**cnt
num=n-(tmp//26)
alp=["a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z"]
ans=["0"]*cnt
for i in range(cnt):
j=num%26
num//=26
ans[-i-1]=alp[j]
print(*ans, sep='')
| n=int(input())
cnt=0
tmp=0
while n>tmp:
cnt+=1
tmp+=26**cnt
num=n-(tmp//26)
ans=["0"]*cnt
for i in range(1, cnt+1):
j=num%26
num//=26
add=chr(ord("a")+j)
ans[-i]=add
print(*ans, sep='')
| 20 | 20 | 329 | 237 | n = int(input())
cnt = 1 ##文字数
tmp = 26
while n > tmp:
cnt += 1
tmp += 26**cnt
num = n - (tmp // 26)
alp = [
"a",
"b",
"c",
"d",
"e",
"f",
"g",
"h",
"i",
"j",
"k",
"l",
"m",
"n",
"o",
"p",
"q",
"r",
"s",
"t",
"u",
"v",
"w",
"x",
"y",
"z",
]
ans = ["0"] * cnt
for i in range(cnt):
j = num % 26
num //= 26
ans[-i - 1] = alp[j]
print(*ans, sep="")
| n = int(input())
cnt = 0
tmp = 0
while n > tmp:
cnt += 1
tmp += 26**cnt
num = n - (tmp // 26)
ans = ["0"] * cnt
for i in range(1, cnt + 1):
j = num % 26
num //= 26
add = chr(ord("a") + j)
ans[-i] = add
print(*ans, sep="")
| false | 0 | [
"-cnt = 1 ##文字数",
"-tmp = 26",
"+cnt = 0",
"+tmp = 0",
"-alp = [",
"- \"a\",",
"- \"b\",",
"- \"c\",",
"- \"d\",",
"- \"e\",",
"- \"f\",",
"- \"g\",",
"- \"h\",",
"- \"i\",",
"- \"j\",",
"- \"k\",",
"- \"l\",",
"- \"m\",",
"- \"n\",",
"- \"o\",",
"- \"p\",",
"- \"q\",",
"- \"r\",",
"- \"s\",",
"- \"t\",",
"- \"u\",",
"- \"v\",",
"- \"w\",",
"- \"x\",",
"- \"y\",",
"- \"z\",",
"-]",
"-for i in range(cnt):",
"+for i in range(1, cnt + 1):",
"- ans[-i - 1] = alp[j]",
"+ add = chr(ord(\"a\") + j)",
"+ ans[-i] = add"
] | false | 0.037375 | 0.042003 | 0.889815 | [
"s248191135",
"s293560278"
] |
u169138653 | p03546 | python | s285551808 | s964422886 | 209 | 37 | 14,056 | 3,444 | Accepted | Accepted | 82.3 | from scipy.sparse.csgraph import csgraph_from_dense,floyd_warshall
h,w=list(map(int,input().split()))
c=[list(map(int,input().split())) for i in range(10)]
a=[list(map(int,input().split())) for i in range(h)]
g=csgraph_from_dense(c,null_value=0)
d=floyd_warshall(g)
ans=0
for i in range(h):
for j in range(w):
if a[i][j]!=-1:
ans+=d[a[i][j]][1]
print((int(ans))) | h,w=list(map(int,input().split()))
c=[list(map(int,input().split())) for _ in range(10)]
a=[list(map(int,input().split())) for _ in range(h)]
def warshall_floyd(d,n):
#d[i][j]: iからjへの最短距離
for k in range(n):
for i in range(n):
for j in range(n):
d[i][j] = min(d[i][j],d[i][k] + d[k][j])
return d
cost=warshall_floyd(c,10)
magic=0
for i in range(h):
for j in range(w):
if a[i][j]!=-1:
magic+=cost[a[i][j]][1]
print(magic) | 12 | 17 | 377 | 489 | from scipy.sparse.csgraph import csgraph_from_dense, floyd_warshall
h, w = list(map(int, input().split()))
c = [list(map(int, input().split())) for i in range(10)]
a = [list(map(int, input().split())) for i in range(h)]
g = csgraph_from_dense(c, null_value=0)
d = floyd_warshall(g)
ans = 0
for i in range(h):
for j in range(w):
if a[i][j] != -1:
ans += d[a[i][j]][1]
print((int(ans)))
| h, w = list(map(int, input().split()))
c = [list(map(int, input().split())) for _ in range(10)]
a = [list(map(int, input().split())) for _ in range(h)]
def warshall_floyd(d, n):
# d[i][j]: iからjへの最短距離
for k in range(n):
for i in range(n):
for j in range(n):
d[i][j] = min(d[i][j], d[i][k] + d[k][j])
return d
cost = warshall_floyd(c, 10)
magic = 0
for i in range(h):
for j in range(w):
if a[i][j] != -1:
magic += cost[a[i][j]][1]
print(magic)
| false | 29.411765 | [
"-from scipy.sparse.csgraph import csgraph_from_dense, floyd_warshall",
"+h, w = list(map(int, input().split()))",
"+c = [list(map(int, input().split())) for _ in range(10)]",
"+a = [list(map(int, input().split())) for _ in range(h)]",
"-h, w = list(map(int, input().split()))",
"-c = [list(map(int, input().split())) for i in range(10)]",
"-a = [list(map(int, input().split())) for i in range(h)]",
"-g = csgraph_from_dense(c, null_value=0)",
"-d = floyd_warshall(g)",
"-ans = 0",
"+",
"+def warshall_floyd(d, n):",
"+ # d[i][j]: iからjへの最短距離",
"+ for k in range(n):",
"+ for i in range(n):",
"+ for j in range(n):",
"+ d[i][j] = min(d[i][j], d[i][k] + d[k][j])",
"+ return d",
"+",
"+",
"+cost = warshall_floyd(c, 10)",
"+magic = 0",
"- ans += d[a[i][j]][1]",
"-print((int(ans)))",
"+ magic += cost[a[i][j]][1]",
"+print(magic)"
] | false | 0.315117 | 0.035756 | 8.813079 | [
"s285551808",
"s964422886"
] |
u160414758 | p03634 | python | s669596287 | s463399611 | 990 | 651 | 57,256 | 57,272 | Accepted | Accepted | 34.24 | import sys;sys.setrecursionlimit(int(1e7))
from collections import deque
N = int(eval(input()))
tree = [[] for _ in range(N+1)]
for _ in range(N-1):
a, b, c = list(map(int,input().split()))
tree[a].append((b,c))
tree[b].append((a,c))
Qn,K = list(map(int,input().split()))
XY = [tuple(map(int,input().split())) for _ in range(Qn)]
dist = [-1]*(N+1)
dist[K] = 0
Q = deque()
Q.append(K)
while len(Q):
p = Q.popleft()
for q,c in tree[p]:
if dist[q] != -1: continue
dist[q] = dist[p]+c
Q.append(q)
for i in range(Qn):
print((dist[XY[i][0]] + dist[XY[i][1]])) | import sys;sys.setrecursionlimit(int(1e7))
from sys import stdin
from collections import deque
input = stdin.readline
N = int(eval(input()))
tree = [[] for _ in range(N+1)]
for _ in range(N-1):
a, b, c = list(map(int,input().split()))
tree[a].append((b,c))
tree[b].append((a,c))
Qn,K = list(map(int,input().split()))
XY = [tuple(map(int,input().split())) for _ in range(Qn)]
dist = [-1]*(N+1)
dist[K] = 0
Q = deque()
Q.append(K)
while len(Q):
p = Q.popleft()
for q,c in tree[p]:
if dist[q] != -1: continue
dist[q] = dist[p]+c
Q.append(q)
for i in range(Qn):
print((dist[XY[i][0]] + dist[XY[i][1]])) | 26 | 28 | 610 | 657 | import sys
sys.setrecursionlimit(int(1e7))
from collections import deque
N = int(eval(input()))
tree = [[] for _ in range(N + 1)]
for _ in range(N - 1):
a, b, c = list(map(int, input().split()))
tree[a].append((b, c))
tree[b].append((a, c))
Qn, K = list(map(int, input().split()))
XY = [tuple(map(int, input().split())) for _ in range(Qn)]
dist = [-1] * (N + 1)
dist[K] = 0
Q = deque()
Q.append(K)
while len(Q):
p = Q.popleft()
for q, c in tree[p]:
if dist[q] != -1:
continue
dist[q] = dist[p] + c
Q.append(q)
for i in range(Qn):
print((dist[XY[i][0]] + dist[XY[i][1]]))
| import sys
sys.setrecursionlimit(int(1e7))
from sys import stdin
from collections import deque
input = stdin.readline
N = int(eval(input()))
tree = [[] for _ in range(N + 1)]
for _ in range(N - 1):
a, b, c = list(map(int, input().split()))
tree[a].append((b, c))
tree[b].append((a, c))
Qn, K = list(map(int, input().split()))
XY = [tuple(map(int, input().split())) for _ in range(Qn)]
dist = [-1] * (N + 1)
dist[K] = 0
Q = deque()
Q.append(K)
while len(Q):
p = Q.popleft()
for q, c in tree[p]:
if dist[q] != -1:
continue
dist[q] = dist[p] + c
Q.append(q)
for i in range(Qn):
print((dist[XY[i][0]] + dist[XY[i][1]]))
| false | 7.142857 | [
"+from sys import stdin",
"+input = stdin.readline"
] | false | 0.038433 | 0.038251 | 1.004764 | [
"s669596287",
"s463399611"
] |
u999893056 | p03261 | python | s517972710 | s724853212 | 19 | 17 | 3,188 | 3,060 | Accepted | Accepted | 10.53 | import sys
n = int(eval(input()))
word = [eval(input()) for _ in range(n)]
t = len(list(set(word)))
if n != t:
print("No")
else:
for i in range(n-1):
if word[i][-1] == word[i+1][0]:
continue
else:
print("No")
sys.exit()
else:
print("Yes") | n = int(eval(input()))
words = [eval(input()) for _ in range(n)]
spoken = {words[0]}
for x, y in zip(words, words[1:]):
if y[0] != x[-1]:
print("No")
exit()
if y in spoken:
print("No")
exit()
spoken.add(y)
else:
print("Yes")
| 18 | 16 | 318 | 279 | import sys
n = int(eval(input()))
word = [eval(input()) for _ in range(n)]
t = len(list(set(word)))
if n != t:
print("No")
else:
for i in range(n - 1):
if word[i][-1] == word[i + 1][0]:
continue
else:
print("No")
sys.exit()
else:
print("Yes")
| n = int(eval(input()))
words = [eval(input()) for _ in range(n)]
spoken = {words[0]}
for x, y in zip(words, words[1:]):
if y[0] != x[-1]:
print("No")
exit()
if y in spoken:
print("No")
exit()
spoken.add(y)
else:
print("Yes")
| false | 11.111111 | [
"-import sys",
"-",
"-word = [eval(input()) for _ in range(n)]",
"-t = len(list(set(word)))",
"-if n != t:",
"- print(\"No\")",
"+words = [eval(input()) for _ in range(n)]",
"+spoken = {words[0]}",
"+for x, y in zip(words, words[1:]):",
"+ if y[0] != x[-1]:",
"+ print(\"No\")",
"+ exit()",
"+ if y in spoken:",
"+ print(\"No\")",
"+ exit()",
"+ spoken.add(y)",
"- for i in range(n - 1):",
"- if word[i][-1] == word[i + 1][0]:",
"- continue",
"- else:",
"- print(\"No\")",
"- sys.exit()",
"- else:",
"- print(\"Yes\")",
"+ print(\"Yes\")"
] | false | 0.062448 | 0.054954 | 1.136367 | [
"s517972710",
"s724853212"
] |
u256678932 | p02400 | python | s291363413 | s067752590 | 30 | 20 | 7,556 | 5,640 | Accepted | Accepted | 33.33 | from math import pi
r = float(eval(input()))
print(("{:5f} {:5f}".format(pi*r**2, 2*pi*r))) | import math
r = float(eval(input()))
c = 2*math.pi*r
s = math.pi*(r**2.0)
print(("{:.5f} {:.5f}".format(s, c)))
| 5 | 8 | 89 | 114 | from math import pi
r = float(eval(input()))
print(("{:5f} {:5f}".format(pi * r**2, 2 * pi * r)))
| import math
r = float(eval(input()))
c = 2 * math.pi * r
s = math.pi * (r**2.0)
print(("{:.5f} {:.5f}".format(s, c)))
| false | 37.5 | [
"-from math import pi",
"+import math",
"-print((\"{:5f} {:5f}\".format(pi * r**2, 2 * pi * r)))",
"+c = 2 * math.pi * r",
"+s = math.pi * (r**2.0)",
"+print((\"{:.5f} {:.5f}\".format(s, c)))"
] | false | 0.033503 | 0.032846 | 1.020019 | [
"s291363413",
"s067752590"
] |
u133936772 | p02583 | python | s994057698 | s562534086 | 244 | 111 | 9,164 | 9,168 | Accepted | Accepted | 54.51 | n,*l=list(map(int,open(0).read().split()))
print((sum(i!=j!=k!=i and j+k>i and k+i>j and i+j>k for i in l for j in l for k in l)//6)) | n,*l=list(map(int,open(0).read().split()))
l.sort()
print((sum(i<j<k and i+j>k for i in l for j in l for k in l))) | 2 | 3 | 126 | 108 | n, *l = list(map(int, open(0).read().split()))
print(
(
sum(
i != j != k != i and j + k > i and k + i > j and i + j > k
for i in l
for j in l
for k in l
)
// 6
)
)
| n, *l = list(map(int, open(0).read().split()))
l.sort()
print((sum(i < j < k and i + j > k for i in l for j in l for k in l)))
| false | 33.333333 | [
"-print(",
"- (",
"- sum(",
"- i != j != k != i and j + k > i and k + i > j and i + j > k",
"- for i in l",
"- for j in l",
"- for k in l",
"- )",
"- // 6",
"- )",
"-)",
"+l.sort()",
"+print((sum(i < j < k and i + j > k for i in l for j in l for k in l)))"
] | false | 0.043662 | 0.042836 | 1.019289 | [
"s994057698",
"s562534086"
] |
u226108478 | p03053 | python | s665332432 | s075228631 | 512 | 454 | 122,824 | 88,668 | Accepted | Accepted | 11.33 | # -*- coding: utf-8 -*-
def main():
from collections import deque
h, w = list(map(int, input().split()))
a = [list(eval(input())) for _ in range(h)]
dx = [0, 0, -1, 1]
dy = [1, -1, 0, 0]
dist = [[-1 for __ in range(w)] for _ in range(h)]
blacks = deque()
# See:
# http://drken1215.hatenablog.com/entry/2019/05/05/223200?_ga=2.177845805.987014750.1556545680-1855989383.1556545680
# https://blog.kichi2004.jp/2019/05/agc033/
for i in range(h):
for j in range(w):
if a[i][j] == '#':
dist[i][j] = 0
blacks.append((i, j))
while blacks:
current = blacks.popleft()
cur_x = current[1]
cur_y = current[0]
for i in range(4):
next_x = cur_x + dx[i]
next_y = cur_y + dy[i]
if next_x < 0 or next_x >= w or next_y < 0 or next_y >= h:
continue
if dist[next_y][next_x] == -1:
dist[next_y][next_x] = dist[cur_y][cur_x] + 1
blacks.append((next_y, next_x))
ans = 0
for i in range(h):
for j in range(w):
ans = max(ans, dist[i][j])
print(ans)
if __name__ == '__main__':
main()
| # -*- coding: utf-8 -*-
def main():
from collections import deque
h, w = list(map(int, input().split()))
a = [eval(input()) for _ in range(h)]
dx = [0, 0, -1, 1]
dy = [1, -1, 0, 0]
dist = [[-1 for __ in range(w)] for _ in range(h)]
blacks = deque()
# See:
# http://drken1215.hatenablog.com/entry/2019/05/05/223200?_ga=2.177845805.987014750.1556545680-1855989383.1556545680
# https://blog.kichi2004.jp/2019/05/agc033/
for i in range(h):
for j in range(w):
if a[i][j] == '#':
dist[i][j] = 0
blacks.append((i, j))
while blacks:
current = blacks.popleft()
cur_x = current[1]
cur_y = current[0]
for i in range(4):
next_x = cur_x + dx[i]
next_y = cur_y + dy[i]
if next_x < 0 or next_x >= w or next_y < 0 or next_y >= h:
continue
if dist[next_y][next_x] == -1:
dist[next_y][next_x] = dist[cur_y][cur_x] + 1
blacks.append((next_y, next_x))
ans = 0
for i in range(h):
for j in range(w):
ans = max(ans, dist[i][j])
print(ans)
if __name__ == '__main__':
main()
| 49 | 49 | 1,269 | 1,263 | # -*- coding: utf-8 -*-
def main():
from collections import deque
h, w = list(map(int, input().split()))
a = [list(eval(input())) for _ in range(h)]
dx = [0, 0, -1, 1]
dy = [1, -1, 0, 0]
dist = [[-1 for __ in range(w)] for _ in range(h)]
blacks = deque()
# See:
# http://drken1215.hatenablog.com/entry/2019/05/05/223200?_ga=2.177845805.987014750.1556545680-1855989383.1556545680
# https://blog.kichi2004.jp/2019/05/agc033/
for i in range(h):
for j in range(w):
if a[i][j] == "#":
dist[i][j] = 0
blacks.append((i, j))
while blacks:
current = blacks.popleft()
cur_x = current[1]
cur_y = current[0]
for i in range(4):
next_x = cur_x + dx[i]
next_y = cur_y + dy[i]
if next_x < 0 or next_x >= w or next_y < 0 or next_y >= h:
continue
if dist[next_y][next_x] == -1:
dist[next_y][next_x] = dist[cur_y][cur_x] + 1
blacks.append((next_y, next_x))
ans = 0
for i in range(h):
for j in range(w):
ans = max(ans, dist[i][j])
print(ans)
if __name__ == "__main__":
main()
| # -*- coding: utf-8 -*-
def main():
from collections import deque
h, w = list(map(int, input().split()))
a = [eval(input()) for _ in range(h)]
dx = [0, 0, -1, 1]
dy = [1, -1, 0, 0]
dist = [[-1 for __ in range(w)] for _ in range(h)]
blacks = deque()
# See:
# http://drken1215.hatenablog.com/entry/2019/05/05/223200?_ga=2.177845805.987014750.1556545680-1855989383.1556545680
# https://blog.kichi2004.jp/2019/05/agc033/
for i in range(h):
for j in range(w):
if a[i][j] == "#":
dist[i][j] = 0
blacks.append((i, j))
while blacks:
current = blacks.popleft()
cur_x = current[1]
cur_y = current[0]
for i in range(4):
next_x = cur_x + dx[i]
next_y = cur_y + dy[i]
if next_x < 0 or next_x >= w or next_y < 0 or next_y >= h:
continue
if dist[next_y][next_x] == -1:
dist[next_y][next_x] = dist[cur_y][cur_x] + 1
blacks.append((next_y, next_x))
ans = 0
for i in range(h):
for j in range(w):
ans = max(ans, dist[i][j])
print(ans)
if __name__ == "__main__":
main()
| false | 0 | [
"- a = [list(eval(input())) for _ in range(h)]",
"+ a = [eval(input()) for _ in range(h)]"
] | false | 0.038574 | 0.054348 | 0.709752 | [
"s665332432",
"s075228631"
] |
u445624660 | p02623 | python | s364709201 | s244141569 | 1,118 | 789 | 40,020 | 42,188 | Accepted | Accepted | 29.43 | n, m, k = list(map(int, input().split()))
a = [0] + list(map(int, input().split()))
b = [0] + list(map(int, input().split()))
for i in range(1, n + 1):
a[i] += a[i - 1]
for i in range(1, m + 1):
b[i] += b[i - 1]
ans = 0
for i in range(len(a)):
rest = k - a[i]
if rest < 0:
break
left, right = -1, len(b)
while right - left > 1:
mid = (left + right) // 2
if rest - b[mid] >= 0:
left = mid
else:
right = mid
# print(f"{rest}を越えない最大のBiは{b[left]}")
ans = max(ans, i + left)
print(ans) | n, m, k = list(map(int, input().split()))
a = [0] + list(map(int, input().split()))
b = [0] + list(map(int, input().split()))
for i in range(1, n + 1):
a[i] += a[i - 1]
for i in range(1, m + 1):
b[i] += b[i - 1]
def search(arr, x):
l, r = 0, len(arr)
while abs(r - l) > 1:
mid = (l + r) // 2
if arr[mid] <= x:
l = mid
else:
r = mid
return l
ans = 0
for i in range(len(a)):
rest = k - a[i]
if rest < 0:
break
bidx = search(b, rest)
if bidx == -1 or bidx == len(b):
continue
ans = max(ans, i + bidx)
print(ans) | 23 | 30 | 585 | 639 | n, m, k = list(map(int, input().split()))
a = [0] + list(map(int, input().split()))
b = [0] + list(map(int, input().split()))
for i in range(1, n + 1):
a[i] += a[i - 1]
for i in range(1, m + 1):
b[i] += b[i - 1]
ans = 0
for i in range(len(a)):
rest = k - a[i]
if rest < 0:
break
left, right = -1, len(b)
while right - left > 1:
mid = (left + right) // 2
if rest - b[mid] >= 0:
left = mid
else:
right = mid
# print(f"{rest}を越えない最大のBiは{b[left]}")
ans = max(ans, i + left)
print(ans)
| n, m, k = list(map(int, input().split()))
a = [0] + list(map(int, input().split()))
b = [0] + list(map(int, input().split()))
for i in range(1, n + 1):
a[i] += a[i - 1]
for i in range(1, m + 1):
b[i] += b[i - 1]
def search(arr, x):
l, r = 0, len(arr)
while abs(r - l) > 1:
mid = (l + r) // 2
if arr[mid] <= x:
l = mid
else:
r = mid
return l
ans = 0
for i in range(len(a)):
rest = k - a[i]
if rest < 0:
break
bidx = search(b, rest)
if bidx == -1 or bidx == len(b):
continue
ans = max(ans, i + bidx)
print(ans)
| false | 23.333333 | [
"+",
"+",
"+def search(arr, x):",
"+ l, r = 0, len(arr)",
"+ while abs(r - l) > 1:",
"+ mid = (l + r) // 2",
"+ if arr[mid] <= x:",
"+ l = mid",
"+ else:",
"+ r = mid",
"+ return l",
"+",
"+",
"- left, right = -1, len(b)",
"- while right - left > 1:",
"- mid = (left + right) // 2",
"- if rest - b[mid] >= 0:",
"- left = mid",
"- else:",
"- right = mid",
"- # print(f\"{rest}を越えない最大のBiは{b[left]}\")",
"- ans = max(ans, i + left)",
"+ bidx = search(b, rest)",
"+ if bidx == -1 or bidx == len(b):",
"+ continue",
"+ ans = max(ans, i + bidx)"
] | false | 0.044667 | 0.043599 | 1.024502 | [
"s364709201",
"s244141569"
] |
u647999897 | p03699 | python | s432887628 | s907108585 | 279 | 66 | 69,652 | 65,736 | Accepted | Accepted | 76.34 | def solve():
N = int(eval(input()))
s = [int(eval(input())) for _ in range(N)]
s.sort()
ans = sum(s)
if ans % 10 != 0:
print(ans)
return
mn = float('inf')
for i in range(N):
if s[i] % 10 != 0:
mn = min(mn, s[i])
if mn == float('inf'):
print((0))
else:
ans -= mn
print(ans)
if __name__ == '__main__':
solve() | def solve():
N = int(eval(input()))
s = [int(eval(input())) for _ in range(N)]
sm = sum(s)
dp = [False] * (sm + 1)
dp[0] = True
for val in s:
for i in range(sm, -1, -1):
if dp[i] and i+val <= sm:
dp[i+val] = True
for i in range(sm, -1, -1):
if dp[i] and i % 10 != 0:
print(i)
return
else:
print((0))
if __name__ == '__main__':
solve() | 23 | 21 | 423 | 459 | def solve():
N = int(eval(input()))
s = [int(eval(input())) for _ in range(N)]
s.sort()
ans = sum(s)
if ans % 10 != 0:
print(ans)
return
mn = float("inf")
for i in range(N):
if s[i] % 10 != 0:
mn = min(mn, s[i])
if mn == float("inf"):
print((0))
else:
ans -= mn
print(ans)
if __name__ == "__main__":
solve()
| def solve():
N = int(eval(input()))
s = [int(eval(input())) for _ in range(N)]
sm = sum(s)
dp = [False] * (sm + 1)
dp[0] = True
for val in s:
for i in range(sm, -1, -1):
if dp[i] and i + val <= sm:
dp[i + val] = True
for i in range(sm, -1, -1):
if dp[i] and i % 10 != 0:
print(i)
return
else:
print((0))
if __name__ == "__main__":
solve()
| false | 8.695652 | [
"- s.sort()",
"- ans = sum(s)",
"- if ans % 10 != 0:",
"- print(ans)",
"- return",
"- mn = float(\"inf\")",
"- for i in range(N):",
"- if s[i] % 10 != 0:",
"- mn = min(mn, s[i])",
"- if mn == float(\"inf\"):",
"+ sm = sum(s)",
"+ dp = [False] * (sm + 1)",
"+ dp[0] = True",
"+ for val in s:",
"+ for i in range(sm, -1, -1):",
"+ if dp[i] and i + val <= sm:",
"+ dp[i + val] = True",
"+ for i in range(sm, -1, -1):",
"+ if dp[i] and i % 10 != 0:",
"+ print(i)",
"+ return",
"+ else:",
"- else:",
"- ans -= mn",
"- print(ans)"
] | false | 0.03561 | 0.040536 | 0.87848 | [
"s432887628",
"s907108585"
] |
u952708174 | p03265 | python | s230215676 | s693806055 | 35 | 17 | 2,940 | 2,940 | Accepted | Accepted | 51.43 | x1, y1, x2, y2 = [int(i) for i in input().split()]
x3 = x2 - (y2 - y1)
y3 = y2 + (x2 - x1)
x4 = x3 - (x2 - x1)
y4 = y3 - (y2 - y1)
print((x3, y3, x4, y4)) | x1, y1, x2, y2 = [int(i) for i in input().split()]
x3 = x2 - (y2 - y1)
y3 = y2 + (x2 - x1)
x4 = x1 - (y2 - y1)
y4 = y1 + (x2 - x1)
print((x3, y3, x4, y4)) | 6 | 6 | 157 | 157 | x1, y1, x2, y2 = [int(i) for i in input().split()]
x3 = x2 - (y2 - y1)
y3 = y2 + (x2 - x1)
x4 = x3 - (x2 - x1)
y4 = y3 - (y2 - y1)
print((x3, y3, x4, y4))
| x1, y1, x2, y2 = [int(i) for i in input().split()]
x3 = x2 - (y2 - y1)
y3 = y2 + (x2 - x1)
x4 = x1 - (y2 - y1)
y4 = y1 + (x2 - x1)
print((x3, y3, x4, y4))
| false | 0 | [
"-x4 = x3 - (x2 - x1)",
"-y4 = y3 - (y2 - y1)",
"+x4 = x1 - (y2 - y1)",
"+y4 = y1 + (x2 - x1)"
] | false | 0.042767 | 0.04946 | 0.864682 | [
"s230215676",
"s693806055"
] |
u753803401 | p02936 | python | s749557192 | s628909663 | 1,837 | 983 | 134,996 | 124,584 | Accepted | Accepted | 46.49 | n, q = list(map(int, input().split()))
ab = [list(map(int, input().split())) for _ in range(n-1)]
px = [list(map(int, input().split())) for _ in range(q)]
dp = [0] * n
ls = [[] for i in range(n)]
for i in ab:
ls[i[0]-1].append(i[1]-1)
for i in px:
dp[i[0]-1] += i[1]
for i in range(n):
for j in ls[i]:
dp[j] += dp[i]
print((*dp))
| def slove():
import sys
import collections
input = sys.stdin.readline
n, qq = list(map(int, input().rstrip('\n').split()))
ls = collections.defaultdict(list)
ls[1]
for i in range(n-1):
a, b = list(map(int, input().rstrip('\n').split()))
ls[a] += [b]
ls[b] += [a]
ans = [0 for _ in range(n)]
for i in range(qq):
p, x = list(map(int, input().rstrip('\n').split()))
ans[p-1] += x
q = collections.deque()
q.append(1)
fq = collections.defaultdict(list)
while True:
if len(q) != 0:
p = q.popleft()
fq[p]
for i in ls[p]:
if i not in fq:
q.append(i)
ans[i-1] += ans[p-1]
else:
break
print((*ans))
if __name__ == '__main__':
slove()
| 13 | 36 | 354 | 882 | n, q = list(map(int, input().split()))
ab = [list(map(int, input().split())) for _ in range(n - 1)]
px = [list(map(int, input().split())) for _ in range(q)]
dp = [0] * n
ls = [[] for i in range(n)]
for i in ab:
ls[i[0] - 1].append(i[1] - 1)
for i in px:
dp[i[0] - 1] += i[1]
for i in range(n):
for j in ls[i]:
dp[j] += dp[i]
print((*dp))
| def slove():
import sys
import collections
input = sys.stdin.readline
n, qq = list(map(int, input().rstrip("\n").split()))
ls = collections.defaultdict(list)
ls[1]
for i in range(n - 1):
a, b = list(map(int, input().rstrip("\n").split()))
ls[a] += [b]
ls[b] += [a]
ans = [0 for _ in range(n)]
for i in range(qq):
p, x = list(map(int, input().rstrip("\n").split()))
ans[p - 1] += x
q = collections.deque()
q.append(1)
fq = collections.defaultdict(list)
while True:
if len(q) != 0:
p = q.popleft()
fq[p]
for i in ls[p]:
if i not in fq:
q.append(i)
ans[i - 1] += ans[p - 1]
else:
break
print((*ans))
if __name__ == "__main__":
slove()
| false | 63.888889 | [
"-n, q = list(map(int, input().split()))",
"-ab = [list(map(int, input().split())) for _ in range(n - 1)]",
"-px = [list(map(int, input().split())) for _ in range(q)]",
"-dp = [0] * n",
"-ls = [[] for i in range(n)]",
"-for i in ab:",
"- ls[i[0] - 1].append(i[1] - 1)",
"-for i in px:",
"- dp[i[0] - 1] += i[1]",
"-for i in range(n):",
"- for j in ls[i]:",
"- dp[j] += dp[i]",
"-print((*dp))",
"+def slove():",
"+ import sys",
"+ import collections",
"+",
"+ input = sys.stdin.readline",
"+ n, qq = list(map(int, input().rstrip(\"\\n\").split()))",
"+ ls = collections.defaultdict(list)",
"+ ls[1]",
"+ for i in range(n - 1):",
"+ a, b = list(map(int, input().rstrip(\"\\n\").split()))",
"+ ls[a] += [b]",
"+ ls[b] += [a]",
"+ ans = [0 for _ in range(n)]",
"+ for i in range(qq):",
"+ p, x = list(map(int, input().rstrip(\"\\n\").split()))",
"+ ans[p - 1] += x",
"+ q = collections.deque()",
"+ q.append(1)",
"+ fq = collections.defaultdict(list)",
"+ while True:",
"+ if len(q) != 0:",
"+ p = q.popleft()",
"+ fq[p]",
"+ for i in ls[p]:",
"+ if i not in fq:",
"+ q.append(i)",
"+ ans[i - 1] += ans[p - 1]",
"+ else:",
"+ break",
"+ print((*ans))",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ slove()"
] | false | 0.084454 | 0.084062 | 1.004659 | [
"s749557192",
"s628909663"
] |
u687053495 | p03673 | python | s978895623 | s983431910 | 238 | 165 | 26,180 | 25,156 | Accepted | Accepted | 30.67 |
N = int(eval(input()))
A = list(map(int, input().split()))
B = [0] * N
if N % 2 == 0:
for i in range(N):
if i % 2 == 0:
B[N//2+i//2] = A[i]
else:
B[N//2-(i//2+1)] = A[i]
else:
for i in range(N):
if i % 2 == 1:
B[N//2+(i//2+1)] = A[i]
else:
B[N//2-(i//2)] = A[i]
print((*B)) | N = int(input())
A = list(map(int, input().split()))
if N == 1:
print(A[0])
else:
print(*A[::-2], end=" ")
print(*A[N%2::2])
| 19 | 8 | 330 | 138 | N = int(eval(input()))
A = list(map(int, input().split()))
B = [0] * N
if N % 2 == 0:
for i in range(N):
if i % 2 == 0:
B[N // 2 + i // 2] = A[i]
else:
B[N // 2 - (i // 2 + 1)] = A[i]
else:
for i in range(N):
if i % 2 == 1:
B[N // 2 + (i // 2 + 1)] = A[i]
else:
B[N // 2 - (i // 2)] = A[i]
print((*B))
| N = int(input())
A = list(map(int, input().split()))
if N == 1:
print(A[0])
else:
print(*A[::-2], end=" ")
print(*A[N % 2 :: 2])
| false | 57.894737 | [
"-N = int(eval(input()))",
"+N = int(input())",
"-B = [0] * N",
"-if N % 2 == 0:",
"- for i in range(N):",
"- if i % 2 == 0:",
"- B[N // 2 + i // 2] = A[i]",
"- else:",
"- B[N // 2 - (i // 2 + 1)] = A[i]",
"+if N == 1:",
"+ print(A[0])",
"- for i in range(N):",
"- if i % 2 == 1:",
"- B[N // 2 + (i // 2 + 1)] = A[i]",
"- else:",
"- B[N // 2 - (i // 2)] = A[i]",
"-print((*B))",
"+ print(*A[::-2], end=\" \")",
"+ print(*A[N % 2 :: 2])"
] | false | 0.037895 | 0.035624 | 1.063751 | [
"s978895623",
"s983431910"
] |
u462329577 | p02766 | python | s107555020 | s160737793 | 164 | 17 | 38,256 | 2,940 | Accepted | Accepted | 89.63 | #!/usr/bin/env python3
n,k = list(map(int,input().split()))
ans = 1
while True:
if n >= k**ans: ans += 1
else: break
print(ans) | #!/usr/bin/env python3
n,k = list(map(int,input().split()))
ans =1
while True:
if k ** ans <= n:
ans += 1
else: break
print(ans) | 7 | 8 | 135 | 137 | #!/usr/bin/env python3
n, k = list(map(int, input().split()))
ans = 1
while True:
if n >= k**ans:
ans += 1
else:
break
print(ans)
| #!/usr/bin/env python3
n, k = list(map(int, input().split()))
ans = 1
while True:
if k**ans <= n:
ans += 1
else:
break
print(ans)
| false | 12.5 | [
"- if n >= k**ans:",
"+ if k**ans <= n:"
] | false | 0.08455 | 0.033103 | 2.554136 | [
"s107555020",
"s160737793"
] |
u909514237 | p02579 | python | s229644540 | s329799717 | 731 | 670 | 99,656 | 99,592 | Accepted | Accepted | 8.34 | from collections import deque
di = [-1,0,1,0]
dj = [0,-1,0,1]
H,W = list(map(int, input().split()))
si,sj = list(map(int, input().split()))
ti,tj = list(map(int, input().split()))
si -= 1
sj -= 1
ti -= 1
tj -=1
s = list()
for i in range(H):
s.append(eval(input()))
inf = 10**9
dist = [[inf] * W for i in range(H)]
q = deque()
q.appendleft([si,sj])
dist[si][sj] = 0
while(len(q) > 0):
tmp = q.popleft()
i = tmp[0]
j = tmp[1]
d = dist[i][j]
for v in range(4):
ni = i + di[v]
nj = j + dj[v]
if (ni < 0) or (ni >= H) or (nj < 0) or (nj >= W):
continue
if s[ni][nj] == "#":
continue
if dist[ni][nj] <= d:
continue
dist[ni][nj] = d
q.appendleft([ni,nj])
for ei in range(-2, 3, 1):
for ej in range(-2, 3, 1):
ni = i + ei
nj = j + ej
if (ni < 0) or (ni >= H) or (nj < 0) or (nj >= W):
continue
if dist[ni][nj] <= d+1:
continue
if s[ni][nj] == "#":
continue
dist[ni][nj] = d+1
q.append([ni,nj])
ans = dist[ti][tj]
if ans == inf:
ans = -1
print(ans) | from collections import deque
di = [-1,0,1,0]
dj = [0,-1,0,1]
H,W = list(map(int, input().split()))
si,sj = list(map(int, input().split()))
ti,tj = list(map(int, input().split()))
si -= 1
sj -= 1
ti -= 1
tj -= 1
s = list()
for i in range(H):
s.append(eval(input()))
inf = 10**9
dist = [[inf] * W for i in range(H)]
q = deque()
q.appendleft([si,sj])
dist[si][sj] = 0
while(len(q) > 0):
tmp = q.popleft()
i = tmp[0]
j = tmp[1]
d = dist[i][j]
for v in range(4):
ni = i + di[v]
nj = j + dj[v]
if (ni < 0) or (ni >= H) or (nj < 0) or (nj >= W):
continue
if s[ni][nj] == "#":
continue
if dist[ni][nj] <= d:
continue
q.appendleft([ni,nj])
dist[ni][nj] = d
for ei in range(-2,3,1):
for ej in range(-2,3,1):
ni = i + ei
nj = j + ej
if (ni < 0) or (ni >= H) or (nj < 0) or (nj >= W):
continue
if s[ni][nj] == "#":
continue
if dist[ni][nj] <= d+1:
continue
q.append([ni,nj])
dist[ni][nj] = d+1
ans = dist[ti][tj]
if ans == inf:
ans = -1
print(ans) | 54 | 55 | 1,104 | 1,113 | from collections import deque
di = [-1, 0, 1, 0]
dj = [0, -1, 0, 1]
H, W = list(map(int, input().split()))
si, sj = list(map(int, input().split()))
ti, tj = list(map(int, input().split()))
si -= 1
sj -= 1
ti -= 1
tj -= 1
s = list()
for i in range(H):
s.append(eval(input()))
inf = 10**9
dist = [[inf] * W for i in range(H)]
q = deque()
q.appendleft([si, sj])
dist[si][sj] = 0
while len(q) > 0:
tmp = q.popleft()
i = tmp[0]
j = tmp[1]
d = dist[i][j]
for v in range(4):
ni = i + di[v]
nj = j + dj[v]
if (ni < 0) or (ni >= H) or (nj < 0) or (nj >= W):
continue
if s[ni][nj] == "#":
continue
if dist[ni][nj] <= d:
continue
dist[ni][nj] = d
q.appendleft([ni, nj])
for ei in range(-2, 3, 1):
for ej in range(-2, 3, 1):
ni = i + ei
nj = j + ej
if (ni < 0) or (ni >= H) or (nj < 0) or (nj >= W):
continue
if dist[ni][nj] <= d + 1:
continue
if s[ni][nj] == "#":
continue
dist[ni][nj] = d + 1
q.append([ni, nj])
ans = dist[ti][tj]
if ans == inf:
ans = -1
print(ans)
| from collections import deque
di = [-1, 0, 1, 0]
dj = [0, -1, 0, 1]
H, W = list(map(int, input().split()))
si, sj = list(map(int, input().split()))
ti, tj = list(map(int, input().split()))
si -= 1
sj -= 1
ti -= 1
tj -= 1
s = list()
for i in range(H):
s.append(eval(input()))
inf = 10**9
dist = [[inf] * W for i in range(H)]
q = deque()
q.appendleft([si, sj])
dist[si][sj] = 0
while len(q) > 0:
tmp = q.popleft()
i = tmp[0]
j = tmp[1]
d = dist[i][j]
for v in range(4):
ni = i + di[v]
nj = j + dj[v]
if (ni < 0) or (ni >= H) or (nj < 0) or (nj >= W):
continue
if s[ni][nj] == "#":
continue
if dist[ni][nj] <= d:
continue
q.appendleft([ni, nj])
dist[ni][nj] = d
for ei in range(-2, 3, 1):
for ej in range(-2, 3, 1):
ni = i + ei
nj = j + ej
if (ni < 0) or (ni >= H) or (nj < 0) or (nj >= W):
continue
if s[ni][nj] == "#":
continue
if dist[ni][nj] <= d + 1:
continue
q.append([ni, nj])
dist[ni][nj] = d + 1
ans = dist[ti][tj]
if ans == inf:
ans = -1
print(ans)
| false | 1.818182 | [
"+ q.appendleft([ni, nj])",
"- q.appendleft([ni, nj])",
"+ if s[ni][nj] == \"#\":",
"+ continue",
"- if s[ni][nj] == \"#\":",
"- continue",
"+ q.append([ni, nj])",
"- q.append([ni, nj])"
] | false | 0.042215 | 0.034578 | 1.220872 | [
"s229644540",
"s329799717"
] |
u721316601 | p03611 | python | s891632871 | s103731626 | 179 | 96 | 14,564 | 14,500 | Accepted | Accepted | 46.37 | from collections import Counter
N = int(eval(input()))
a = Counter(list(map(int, input().split())))#.most_common()
max_total = 0
for i in range(min(a), max(a)+1):
total = 0
if i in a:
total += a[i]
if i-1 in a:
total += a[i-1]
if i+1 in a:
total += a[i+1]
max_total = max(max_total, total)
print(max_total) | import sys
from collections import Counter
input = sys.stdin.readline
def main():
N = int(eval(input()))
a = Counter(list(map(int, input().split())))
ans = 0
for n, c in list(a.items()): ans = max(ans, c + a[n-1] + a[n+1])
print(ans)
if __name__ == '__main__':
main() | 17 | 17 | 367 | 317 | from collections import Counter
N = int(eval(input()))
a = Counter(list(map(int, input().split()))) # .most_common()
max_total = 0
for i in range(min(a), max(a) + 1):
total = 0
if i in a:
total += a[i]
if i - 1 in a:
total += a[i - 1]
if i + 1 in a:
total += a[i + 1]
max_total = max(max_total, total)
print(max_total)
| import sys
from collections import Counter
input = sys.stdin.readline
def main():
N = int(eval(input()))
a = Counter(list(map(int, input().split())))
ans = 0
for n, c in list(a.items()):
ans = max(ans, c + a[n - 1] + a[n + 1])
print(ans)
if __name__ == "__main__":
main()
| false | 0 | [
"+import sys",
"-N = int(eval(input()))",
"-a = Counter(list(map(int, input().split()))) # .most_common()",
"-max_total = 0",
"-for i in range(min(a), max(a) + 1):",
"- total = 0",
"- if i in a:",
"- total += a[i]",
"- if i - 1 in a:",
"- total += a[i - 1]",
"- if i + 1 in a:",
"- total += a[i + 1]",
"- max_total = max(max_total, total)",
"-print(max_total)",
"+input = sys.stdin.readline",
"+",
"+",
"+def main():",
"+ N = int(eval(input()))",
"+ a = Counter(list(map(int, input().split())))",
"+ ans = 0",
"+ for n, c in list(a.items()):",
"+ ans = max(ans, c + a[n - 1] + a[n + 1])",
"+ print(ans)",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ main()"
] | false | 0.045695 | 0.04148 | 1.101626 | [
"s891632871",
"s103731626"
] |
u923285281 | p03487 | python | s156429346 | s677121039 | 105 | 80 | 23,668 | 23,664 | Accepted | Accepted | 23.81 | from collections import Counter
N = int(eval(input()))
counter = Counter(list(map(int, input().split())))
sum = 0
for a, cnt in counter.most_common():
if a > cnt:
sum += cnt
else:
sum += cnt - a
print(sum)
| from collections import Counter
N = int(eval(input()))
counter = Counter(list(map(int, input().split())))
sum = 0
for a, cnt in list(counter.items()):
if a > cnt:
sum += cnt
else:
sum += cnt - a
print(sum)
| 14 | 14 | 235 | 229 | from collections import Counter
N = int(eval(input()))
counter = Counter(list(map(int, input().split())))
sum = 0
for a, cnt in counter.most_common():
if a > cnt:
sum += cnt
else:
sum += cnt - a
print(sum)
| from collections import Counter
N = int(eval(input()))
counter = Counter(list(map(int, input().split())))
sum = 0
for a, cnt in list(counter.items()):
if a > cnt:
sum += cnt
else:
sum += cnt - a
print(sum)
| false | 0 | [
"-for a, cnt in counter.most_common():",
"+for a, cnt in list(counter.items()):"
] | false | 0.039693 | 0.040023 | 0.991769 | [
"s156429346",
"s677121039"
] |
u968166680 | p02888 | python | s343436092 | s007481159 | 313 | 195 | 74,212 | 74,008 | Accepted | Accepted | 37.7 | import sys
from bisect import bisect_left, bisect_right
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
N, *L = list(map(int, read().split()))
L.sort()
ans = 0
for i, a in enumerate(L):
for j, b in enumerate(L[i + 1 :], i + 1):
k = bisect_left(L, a + b, lo=j + 1)
ans += k - j - 1
print(ans)
return
if __name__ == '__main__':
main()
| import sys
from itertools import accumulate
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
N, *L = list(map(int, read().split()))
L.sort()
max_L = max(L)
C = [0] * (max_L + 1)
for l in L:
C[l] += 1
C = list(accumulate(C))
ans = 0
for i, a in enumerate(L):
for j, b in enumerate(L[i + 1 :], i + 1):
if a + b > max_L:
ans += N - j - 1
else:
ans += C[a + b - 1] - j - 1
print(ans)
return
if __name__ == '__main__':
main()
| 28 | 37 | 532 | 686 | import sys
from bisect import bisect_left, bisect_right
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10**9)
INF = 1 << 60
MOD = 1000000007
def main():
N, *L = list(map(int, read().split()))
L.sort()
ans = 0
for i, a in enumerate(L):
for j, b in enumerate(L[i + 1 :], i + 1):
k = bisect_left(L, a + b, lo=j + 1)
ans += k - j - 1
print(ans)
return
if __name__ == "__main__":
main()
| import sys
from itertools import accumulate
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10**9)
INF = 1 << 60
MOD = 1000000007
def main():
N, *L = list(map(int, read().split()))
L.sort()
max_L = max(L)
C = [0] * (max_L + 1)
for l in L:
C[l] += 1
C = list(accumulate(C))
ans = 0
for i, a in enumerate(L):
for j, b in enumerate(L[i + 1 :], i + 1):
if a + b > max_L:
ans += N - j - 1
else:
ans += C[a + b - 1] - j - 1
print(ans)
return
if __name__ == "__main__":
main()
| false | 24.324324 | [
"-from bisect import bisect_left, bisect_right",
"+from itertools import accumulate",
"+ max_L = max(L)",
"+ C = [0] * (max_L + 1)",
"+ for l in L:",
"+ C[l] += 1",
"+ C = list(accumulate(C))",
"- k = bisect_left(L, a + b, lo=j + 1)",
"- ans += k - j - 1",
"+ if a + b > max_L:",
"+ ans += N - j - 1",
"+ else:",
"+ ans += C[a + b - 1] - j - 1"
] | false | 0.090468 | 0.036952 | 2.448285 | [
"s343436092",
"s007481159"
] |
u270535768 | p02621 | python | s109227314 | s825732389 | 30 | 24 | 9,096 | 9,016 | Accepted | Accepted | 20 | a=eval(input())
a=int(a)
print((a+a*a+a*a*a)) | a=int(eval(input()))
print((a+a*a+a**3)) | 3 | 2 | 39 | 33 | a = eval(input())
a = int(a)
print((a + a * a + a * a * a))
| a = int(eval(input()))
print((a + a * a + a**3))
| false | 33.333333 | [
"-a = eval(input())",
"-a = int(a)",
"-print((a + a * a + a * a * a))",
"+a = int(eval(input()))",
"+print((a + a * a + a**3))"
] | false | 0.036486 | 0.035893 | 1.016515 | [
"s109227314",
"s825732389"
] |
u411353821 | p02848 | python | s276459463 | s937088602 | 25 | 20 | 3,064 | 3,060 | Accepted | Accepted | 20 | alpha2int = lambda x: ord(x) - ord("A") + 1
def int2alpha(x):
if x % 26 != 0:
x = x % 26
else:
x = 26
return chr(x + 64)
N = int(eval(input()))
S = str(eval(input()))
out_s = ""
for i in range(len(S)):
out_s += int2alpha(alpha2int(S[i]) + N)
print(out_s) | def main():
n = int(eval(input()))
n = n % 26
s = eval(input())
s_list = [d for d in s]
new_s = ""
new_ord_base = 64
for i in s_list:
new_ord = ord(i) + n
if new_ord > 90:
new_ord = new_ord % 90 + new_ord_base
new_s += chr(new_ord)
print(new_s)
if __name__ == "__main__":
main()
| 16 | 18 | 298 | 359 | alpha2int = lambda x: ord(x) - ord("A") + 1
def int2alpha(x):
if x % 26 != 0:
x = x % 26
else:
x = 26
return chr(x + 64)
N = int(eval(input()))
S = str(eval(input()))
out_s = ""
for i in range(len(S)):
out_s += int2alpha(alpha2int(S[i]) + N)
print(out_s)
| def main():
n = int(eval(input()))
n = n % 26
s = eval(input())
s_list = [d for d in s]
new_s = ""
new_ord_base = 64
for i in s_list:
new_ord = ord(i) + n
if new_ord > 90:
new_ord = new_ord % 90 + new_ord_base
new_s += chr(new_ord)
print(new_s)
if __name__ == "__main__":
main()
| false | 11.111111 | [
"-alpha2int = lambda x: ord(x) - ord(\"A\") + 1",
"+def main():",
"+ n = int(eval(input()))",
"+ n = n % 26",
"+ s = eval(input())",
"+ s_list = [d for d in s]",
"+ new_s = \"\"",
"+ new_ord_base = 64",
"+ for i in s_list:",
"+ new_ord = ord(i) + n",
"+ if new_ord > 90:",
"+ new_ord = new_ord % 90 + new_ord_base",
"+ new_s += chr(new_ord)",
"+ print(new_s)",
"-def int2alpha(x):",
"- if x % 26 != 0:",
"- x = x % 26",
"- else:",
"- x = 26",
"- return chr(x + 64)",
"-",
"-",
"-N = int(eval(input()))",
"-S = str(eval(input()))",
"-out_s = \"\"",
"-for i in range(len(S)):",
"- out_s += int2alpha(alpha2int(S[i]) + N)",
"-print(out_s)",
"+if __name__ == \"__main__\":",
"+ main()"
] | false | 0.034816 | 0.036805 | 0.945953 | [
"s276459463",
"s937088602"
] |
u150984829 | p00110 | python | s231554769 | s092344415 | 50 | 30 | 6,568 | 5,616 | Accepted | Accepted | 40 | import sys,re
for e in sys.stdin:
s=any([len(x)>1 and x[0]=='X' for x in re.split('[+=]',e.strip())])
for i in '0123456789'[s:]:
if eval(e.replace('X',i).replace('=','==')):print(i);break
else:print('NA')
| import sys
t='X'
for e in sys.stdin:
for i in'0123456789'[(e[0]==t)*(e[1]!='+')or('+X'in e)*('+X='not in e):]:
l,r=e.replace(t,i).split('=')
if sum(map(int,l.split('+')))==int(r):print(i);break
else:print('NA')
| 6 | 7 | 230 | 223 | import sys, re
for e in sys.stdin:
s = any([len(x) > 1 and x[0] == "X" for x in re.split("[+=]", e.strip())])
for i in "0123456789"[s:]:
if eval(e.replace("X", i).replace("=", "==")):
print(i)
break
else:
print("NA")
| import sys
t = "X"
for e in sys.stdin:
for i in "0123456789"[
(e[0] == t) * (e[1] != "+") or ("+X" in e) * ("+X=" not in e) :
]:
l, r = e.replace(t, i).split("=")
if sum(map(int, l.split("+"))) == int(r):
print(i)
break
else:
print("NA")
| false | 14.285714 | [
"-import sys, re",
"+import sys",
"+t = \"X\"",
"- s = any([len(x) > 1 and x[0] == \"X\" for x in re.split(\"[+=]\", e.strip())])",
"- for i in \"0123456789\"[s:]:",
"- if eval(e.replace(\"X\", i).replace(\"=\", \"==\")):",
"+ for i in \"0123456789\"[",
"+ (e[0] == t) * (e[1] != \"+\") or (\"+X\" in e) * (\"+X=\" not in e) :",
"+ ]:",
"+ l, r = e.replace(t, i).split(\"=\")",
"+ if sum(map(int, l.split(\"+\"))) == int(r):"
] | false | 0.049592 | 0.095847 | 0.517406 | [
"s231554769",
"s092344415"
] |
u079022693 | p03457 | python | s330957750 | s713796187 | 224 | 174 | 15,672 | 11,636 | Accepted | Accepted | 22.32 | from sys import stdin
def main():
#入力
readline=stdin.readline
N=int(readline())
t=[0]*N
x=[0]*N
y=[0]*N
for i in range(N):
t[i],x[i],y[i]=list(map(int,readline().split()))
nt=[]
nx=[]
ny=[]
for i in range(N):
if i==0:
nt.append(t[0])
nx.append(x[0])
ny.append(y[0])
else:
nt.append(t[i]-t[i-1])
nx.append(x[i]-x[i-1])
ny.append(y[i]-y[i-1])
for i in range(N):
if nt[i]<abs(nx[i])+abs(ny[i]):
print("No")
break
elif nt[i]%2!=(abs(nx[i])+abs(ny[i]))%2:
print("No")
break
else:
print("Yes")
if __name__=="__main__":
main() | from sys import stdin
def main():
#入力
readline=stdin.readline
n=int(readline())
t=[0]*n
x=[0]*n
y=[0]*n
for i in range(n):
t[i],x[i],y[i]=list(map(int,readline().split()))
flag=True
for i in range(n):
if i==0:
if t[i]==x[i]+y[i]:
pass
else:
flag=False
break
else:
a=t[i]-t[i-1]
b=abs(x[i]-x[i-1])
c=abs(y[i]-y[i-1])
if a>=b+c and a%2==(b+c)%2:
pass
else:
flag=False
break
if flag:
print("Yes")
else:
print("No")
if __name__=="__main__":
main() | 35 | 36 | 773 | 743 | from sys import stdin
def main():
# 入力
readline = stdin.readline
N = int(readline())
t = [0] * N
x = [0] * N
y = [0] * N
for i in range(N):
t[i], x[i], y[i] = list(map(int, readline().split()))
nt = []
nx = []
ny = []
for i in range(N):
if i == 0:
nt.append(t[0])
nx.append(x[0])
ny.append(y[0])
else:
nt.append(t[i] - t[i - 1])
nx.append(x[i] - x[i - 1])
ny.append(y[i] - y[i - 1])
for i in range(N):
if nt[i] < abs(nx[i]) + abs(ny[i]):
print("No")
break
elif nt[i] % 2 != (abs(nx[i]) + abs(ny[i])) % 2:
print("No")
break
else:
print("Yes")
if __name__ == "__main__":
main()
| from sys import stdin
def main():
# 入力
readline = stdin.readline
n = int(readline())
t = [0] * n
x = [0] * n
y = [0] * n
for i in range(n):
t[i], x[i], y[i] = list(map(int, readline().split()))
flag = True
for i in range(n):
if i == 0:
if t[i] == x[i] + y[i]:
pass
else:
flag = False
break
else:
a = t[i] - t[i - 1]
b = abs(x[i] - x[i - 1])
c = abs(y[i] - y[i - 1])
if a >= b + c and a % 2 == (b + c) % 2:
pass
else:
flag = False
break
if flag:
print("Yes")
else:
print("No")
if __name__ == "__main__":
main()
| false | 2.777778 | [
"- N = int(readline())",
"- t = [0] * N",
"- x = [0] * N",
"- y = [0] * N",
"- for i in range(N):",
"+ n = int(readline())",
"+ t = [0] * n",
"+ x = [0] * n",
"+ y = [0] * n",
"+ for i in range(n):",
"- nt = []",
"- nx = []",
"- ny = []",
"- for i in range(N):",
"+ flag = True",
"+ for i in range(n):",
"- nt.append(t[0])",
"- nx.append(x[0])",
"- ny.append(y[0])",
"+ if t[i] == x[i] + y[i]:",
"+ pass",
"+ else:",
"+ flag = False",
"+ break",
"- nt.append(t[i] - t[i - 1])",
"- nx.append(x[i] - x[i - 1])",
"- ny.append(y[i] - y[i - 1])",
"- for i in range(N):",
"- if nt[i] < abs(nx[i]) + abs(ny[i]):",
"- print(\"No\")",
"- break",
"- elif nt[i] % 2 != (abs(nx[i]) + abs(ny[i])) % 2:",
"- print(\"No\")",
"- break",
"+ a = t[i] - t[i - 1]",
"+ b = abs(x[i] - x[i - 1])",
"+ c = abs(y[i] - y[i - 1])",
"+ if a >= b + c and a % 2 == (b + c) % 2:",
"+ pass",
"+ else:",
"+ flag = False",
"+ break",
"+ if flag:",
"+ print(\"Yes\")",
"- print(\"Yes\")",
"+ print(\"No\")"
] | false | 0.036464 | 0.035116 | 1.038396 | [
"s330957750",
"s713796187"
] |
u895408600 | p02936 | python | s561755709 | s121319632 | 1,989 | 1,243 | 139,740 | 124,236 | Accepted | Accepted | 37.51 | N,Q = list(map(int,input().split()))
ab = [list(map(int,input().split())) for i in range(N-1)]
px = [list(map(int,input().split())) for i in range(Q)]
graph = [[] for _ in range(N+1)]
for a,b in ab:
graph[a].append(b)
graph[b].append(a)
value = [0] * (N+1)
for p,x in px:
value[p] += x
q = [(1,0)]
while q:
x,parent = q.pop()
value[x] += value[parent]
for y in graph[x]:
if y == parent:
continue
q.append((y,x))
answer = ' '.join(map(str,value[1:]))
print(answer) | import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
# 遅延評価で加えてあげるだけ
N,Q = list(map(int,input().split()))
ab = [[int(x) for x in input().split()] for _ in range(N-1)]
px = [[int(x) for x in input().split()] for _ in range(Q)]
graph = [[] for _ in range(N+1)]
for a,b in ab:
graph[a].append(b)
graph[b].append(a)
value = [0] * (N+1)
for p,x in px:
value[p] += x
q = [(1,0)]
while q:
x,parent = q.pop()
value[x] += value[parent]
for y in graph[x]:
if y == parent:
continue
q.append((y,x))
answer = ' '.join(map(str,value[1:]))
print(answer) | 24 | 30 | 542 | 643 | N, Q = list(map(int, input().split()))
ab = [list(map(int, input().split())) for i in range(N - 1)]
px = [list(map(int, input().split())) for i in range(Q)]
graph = [[] for _ in range(N + 1)]
for a, b in ab:
graph[a].append(b)
graph[b].append(a)
value = [0] * (N + 1)
for p, x in px:
value[p] += x
q = [(1, 0)]
while q:
x, parent = q.pop()
value[x] += value[parent]
for y in graph[x]:
if y == parent:
continue
q.append((y, x))
answer = " ".join(map(str, value[1:]))
print(answer)
| import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
# 遅延評価で加えてあげるだけ
N, Q = list(map(int, input().split()))
ab = [[int(x) for x in input().split()] for _ in range(N - 1)]
px = [[int(x) for x in input().split()] for _ in range(Q)]
graph = [[] for _ in range(N + 1)]
for a, b in ab:
graph[a].append(b)
graph[b].append(a)
value = [0] * (N + 1)
for p, x in px:
value[p] += x
q = [(1, 0)]
while q:
x, parent = q.pop()
value[x] += value[parent]
for y in graph[x]:
if y == parent:
continue
q.append((y, x))
answer = " ".join(map(str, value[1:]))
print(answer)
| false | 20 | [
"+import sys",
"+",
"+input = sys.stdin.readline",
"+sys.setrecursionlimit(10**7)",
"+# 遅延評価で加えてあげるだけ",
"-ab = [list(map(int, input().split())) for i in range(N - 1)]",
"-px = [list(map(int, input().split())) for i in range(Q)]",
"+ab = [[int(x) for x in input().split()] for _ in range(N - 1)]",
"+px = [[int(x) for x in input().split()] for _ in range(Q)]"
] | false | 0.037288 | 0.037434 | 0.996118 | [
"s561755709",
"s121319632"
] |
u759412327 | p03221 | python | s596211057 | s398652147 | 585 | 400 | 43,844 | 42,984 | Accepted | Accepted | 31.62 | N,M = list(map(int, input().split()))
P = [list(map(int, input().split())) for _ in range(M)]
cnt = (N+1)*[0]
ids = {}
for p,y in sorted(P,key=lambda x: x[1]):
cnt[p] += 1
ids[y] = "%06d%06d" % (p,cnt[p])
for _,y in P:
print((ids[y])) | N,M = list(map(int, input().split()))
P = [list(map(int, input().split())) for m in range(M)]
C = (N+1)*[0]
D = {}
for p,y in sorted(P,key=lambda x: x[1]):
C[p]+= 1
D[y]="%06d%06d" % (p,C[p])
for p,y in P:
print((D[y])) | 11 | 11 | 241 | 229 | N, M = list(map(int, input().split()))
P = [list(map(int, input().split())) for _ in range(M)]
cnt = (N + 1) * [0]
ids = {}
for p, y in sorted(P, key=lambda x: x[1]):
cnt[p] += 1
ids[y] = "%06d%06d" % (p, cnt[p])
for _, y in P:
print((ids[y]))
| N, M = list(map(int, input().split()))
P = [list(map(int, input().split())) for m in range(M)]
C = (N + 1) * [0]
D = {}
for p, y in sorted(P, key=lambda x: x[1]):
C[p] += 1
D[y] = "%06d%06d" % (p, C[p])
for p, y in P:
print((D[y]))
| false | 0 | [
"-P = [list(map(int, input().split())) for _ in range(M)]",
"-cnt = (N + 1) * [0]",
"-ids = {}",
"+P = [list(map(int, input().split())) for m in range(M)]",
"+C = (N + 1) * [0]",
"+D = {}",
"- cnt[p] += 1",
"- ids[y] = \"%06d%06d\" % (p, cnt[p])",
"-for _, y in P:",
"- print((ids[y]))",
"+ C[p] += 1",
"+ D[y] = \"%06d%06d\" % (p, C[p])",
"+for p, y in P:",
"+ print((D[y]))"
] | false | 0.038195 | 0.091193 | 0.418842 | [
"s596211057",
"s398652147"
] |
u096128910 | p02556 | python | s113704181 | s215428725 | 198 | 137 | 94,496 | 73,724 | Accepted | Accepted | 30.81 | from sys import stdin
readline = stdin.readline
def i_input(): return int(readline().rstrip())
def i_map(): return list(map(int, readline().rstrip().split()))
def i_list(): return list(i_map())
def main():
N = i_input()
Z = []
W = []
for i in range(1, N + 1):
x, y = i_map()
Z.append(x + y)
W.append(x - y)
Z.sort()
W.sort()
ans = max([Z[-1] - Z[0], W[-1] - W[0]])
print(ans)
if __name__ == "__main__":
main()
| from sys import stdin
readline = stdin.readline
def i_input(): return int(readline().rstrip())
def i_map(): return list(map(int, readline().rstrip().split()))
def i_list(): return list(i_map())
def main():
N = i_input()
x, y = i_map()
z = x + y
w = x - y
z_max = z
z_min = z
w_max = w
w_min = w
for i in range(1, N):
x, y = i_map()
z = x + y
w = x - y
z_max = max(z_max, z)
z_min = min(z_min, z)
w_max = max(w_max, w)
w_min = min(w_min, w)
ans = max([z_max - z_min, w_max - w_min])
print(ans)
if __name__ == "__main__":
main()
| 22 | 29 | 488 | 656 | from sys import stdin
readline = stdin.readline
def i_input():
return int(readline().rstrip())
def i_map():
return list(map(int, readline().rstrip().split()))
def i_list():
return list(i_map())
def main():
N = i_input()
Z = []
W = []
for i in range(1, N + 1):
x, y = i_map()
Z.append(x + y)
W.append(x - y)
Z.sort()
W.sort()
ans = max([Z[-1] - Z[0], W[-1] - W[0]])
print(ans)
if __name__ == "__main__":
main()
| from sys import stdin
readline = stdin.readline
def i_input():
return int(readline().rstrip())
def i_map():
return list(map(int, readline().rstrip().split()))
def i_list():
return list(i_map())
def main():
N = i_input()
x, y = i_map()
z = x + y
w = x - y
z_max = z
z_min = z
w_max = w
w_min = w
for i in range(1, N):
x, y = i_map()
z = x + y
w = x - y
z_max = max(z_max, z)
z_min = min(z_min, z)
w_max = max(w_max, w)
w_min = min(w_min, w)
ans = max([z_max - z_min, w_max - w_min])
print(ans)
if __name__ == "__main__":
main()
| false | 24.137931 | [
"- Z = []",
"- W = []",
"- for i in range(1, N + 1):",
"+ x, y = i_map()",
"+ z = x + y",
"+ w = x - y",
"+ z_max = z",
"+ z_min = z",
"+ w_max = w",
"+ w_min = w",
"+ for i in range(1, N):",
"- Z.append(x + y)",
"- W.append(x - y)",
"- Z.sort()",
"- W.sort()",
"- ans = max([Z[-1] - Z[0], W[-1] - W[0]])",
"+ z = x + y",
"+ w = x - y",
"+ z_max = max(z_max, z)",
"+ z_min = min(z_min, z)",
"+ w_max = max(w_max, w)",
"+ w_min = min(w_min, w)",
"+ ans = max([z_max - z_min, w_max - w_min])"
] | false | 0.036198 | 0.036474 | 0.992423 | [
"s113704181",
"s215428725"
] |
u279266699 | p02888 | python | s112216769 | s878165860 | 1,330 | 847 | 3,188 | 9,376 | Accepted | Accepted | 36.32 | from bisect import bisect_left
n = int(eval(input()))
l = list(map(int, input().split()))
l.sort()
ans = 0
for i in range(n - 2):
for j in range(i + 1, n - 1):
ans += bisect_left(l, l[i] + l[j]) - j - 1
print(ans) | from bisect import bisect_left
n = int(eval(input()))
L = list(map(int, input().split()))
L = sorted(L)
ans = 0
for i in range(n - 2):
for j in range(i + 1, n - 1):
ans += bisect_left(L, L[i] + L[j]) - j - 1
print(ans) | 9 | 9 | 227 | 232 | from bisect import bisect_left
n = int(eval(input()))
l = list(map(int, input().split()))
l.sort()
ans = 0
for i in range(n - 2):
for j in range(i + 1, n - 1):
ans += bisect_left(l, l[i] + l[j]) - j - 1
print(ans)
| from bisect import bisect_left
n = int(eval(input()))
L = list(map(int, input().split()))
L = sorted(L)
ans = 0
for i in range(n - 2):
for j in range(i + 1, n - 1):
ans += bisect_left(L, L[i] + L[j]) - j - 1
print(ans)
| false | 0 | [
"-l = list(map(int, input().split()))",
"-l.sort()",
"+L = list(map(int, input().split()))",
"+L = sorted(L)",
"- ans += bisect_left(l, l[i] + l[j]) - j - 1",
"+ ans += bisect_left(L, L[i] + L[j]) - j - 1"
] | false | 0.041627 | 0.036744 | 1.132889 | [
"s112216769",
"s878165860"
] |
u647766105 | p00689 | python | s884305529 | s511314172 | 1,670 | 990 | 4,468 | 4,440 | Accepted | Accepted | 40.72 | def main():
while True:
N = eval(input())
if N == 0:
break
points = [Vector(list(map(int, input().split()))) for _ in range(N)]
seq = [Vector([0, -1]), Vector([0, 0])]
while len(points) != 0:
pre = seq[-1] - seq[-2]
points.sort(key=lambda x: abs(x-seq[-1]), reverse=True)
points.sort(key=lambda x: (x-seq[-1]).norm() * pre.norm())
p = [(x-seq[-1]).norm() * pre.norm() for x in points]
seq += [points.pop()]
print(round(sum(abs(v2 - v1) for v1, v2 in zip(seq[1:], seq[2:])), 1))
class Vector(tuple):
def __neg__(self):
return Vector([-x for x in self])
def __abs__(self):
return sum(x ** 2 for x in self) ** 0.5
def __add__(self, v):
if len(self) != len(v):
raise ValueError("Same dimension is required.")
return Vector([x1 + x2 for x1, x2 in zip(self, v)])
def __sub__(self, v):
return self.__add__(-v)
def norm(self):
a = self.__abs__()
return Vector([x / a for x in self])
def __mul__(self, v):
"""dot product"""
if len(self) != len(v):
raise ValueError("Same dimension is required.")
# sum(x1 * x2 for x1, x2 in zip(self, v))
return round(sum(x1 * x2 for x1, x2 in zip(self, v)), 14)
if __name__ == "__main__":
main() | def main():
while True:
N = eval(input())
if N == 0:
break
points = [Vector(list(map(int, input().split()))) for _ in range(N)]
seq = [Vector([0, -1]), Vector([0, 0])]
while len(points) != 0:
pre = seq[-1] - seq[-2]
points.sort(key=lambda x: abs(x-seq[-1]), reverse=True)
points.sort(key=lambda x: (x-seq[-1]).norm() * pre.norm())
seq += [points.pop()]
print(round(sum(abs(v2 - v1) for v1, v2 in zip(seq[1:], seq[2:])), 1))
class Vector(tuple):
def __neg__(self):
return Vector([-x for x in self])
def __abs__(self):
return sum(x ** 2 for x in self) ** 0.5
def __add__(self, v):
if len(self) != len(v):
raise ValueError("Same dimension is required.")
return Vector([x1 + x2 for x1, x2 in zip(self, v)])
def __sub__(self, v):
return self.__add__(-v)
def norm(self):
a = self.__abs__()
return Vector([x / a for x in self])
def __mul__(self, v):
"""dot product"""
if len(self) != len(v):
raise ValueError("Same dimension is required.")
return round(sum(x1 * x2 for x1, x2 in zip(self, v)), 14)
if __name__ == "__main__":
main() | 44 | 42 | 1,442 | 1,318 | def main():
while True:
N = eval(input())
if N == 0:
break
points = [Vector(list(map(int, input().split()))) for _ in range(N)]
seq = [Vector([0, -1]), Vector([0, 0])]
while len(points) != 0:
pre = seq[-1] - seq[-2]
points.sort(key=lambda x: abs(x - seq[-1]), reverse=True)
points.sort(key=lambda x: (x - seq[-1]).norm() * pre.norm())
p = [(x - seq[-1]).norm() * pre.norm() for x in points]
seq += [points.pop()]
print(round(sum(abs(v2 - v1) for v1, v2 in zip(seq[1:], seq[2:])), 1))
class Vector(tuple):
def __neg__(self):
return Vector([-x for x in self])
def __abs__(self):
return sum(x**2 for x in self) ** 0.5
def __add__(self, v):
if len(self) != len(v):
raise ValueError("Same dimension is required.")
return Vector([x1 + x2 for x1, x2 in zip(self, v)])
def __sub__(self, v):
return self.__add__(-v)
def norm(self):
a = self.__abs__()
return Vector([x / a for x in self])
def __mul__(self, v):
"""dot product"""
if len(self) != len(v):
raise ValueError("Same dimension is required.")
# sum(x1 * x2 for x1, x2 in zip(self, v))
return round(sum(x1 * x2 for x1, x2 in zip(self, v)), 14)
if __name__ == "__main__":
main()
| def main():
while True:
N = eval(input())
if N == 0:
break
points = [Vector(list(map(int, input().split()))) for _ in range(N)]
seq = [Vector([0, -1]), Vector([0, 0])]
while len(points) != 0:
pre = seq[-1] - seq[-2]
points.sort(key=lambda x: abs(x - seq[-1]), reverse=True)
points.sort(key=lambda x: (x - seq[-1]).norm() * pre.norm())
seq += [points.pop()]
print(round(sum(abs(v2 - v1) for v1, v2 in zip(seq[1:], seq[2:])), 1))
class Vector(tuple):
def __neg__(self):
return Vector([-x for x in self])
def __abs__(self):
return sum(x**2 for x in self) ** 0.5
def __add__(self, v):
if len(self) != len(v):
raise ValueError("Same dimension is required.")
return Vector([x1 + x2 for x1, x2 in zip(self, v)])
def __sub__(self, v):
return self.__add__(-v)
def norm(self):
a = self.__abs__()
return Vector([x / a for x in self])
def __mul__(self, v):
"""dot product"""
if len(self) != len(v):
raise ValueError("Same dimension is required.")
return round(sum(x1 * x2 for x1, x2 in zip(self, v)), 14)
if __name__ == "__main__":
main()
| false | 4.545455 | [
"- p = [(x - seq[-1]).norm() * pre.norm() for x in points]",
"- # sum(x1 * x2 for x1, x2 in zip(self, v))"
] | false | 0.042907 | 0.110676 | 0.38768 | [
"s884305529",
"s511314172"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.