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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
u987164499 | p03524 | python | s140913168 | s625408071 | 33 | 25 | 4,644 | 3,444 | Accepted | Accepted | 24.24 | from sys import stdin
from itertools import groupby
s = list(stdin.readline().rstrip())
s.sort()
li = []
for key, value in groupby(s):
li.append(len(list(value)))
if len(li) == 1:
li += [0]*2
elif len(li) == 2:
li += [0]
if abs(li[2]-li[1]) <= 1 and abs(li[1]-li[0]) <= 1 and abs(li[2]-li[0]) <= 1:
print("YES")
else:
print("NO") | from sys import stdin
from sys import setrecursionlimit
setrecursionlimit(10 ** 7)
from collections import Counter
s = eval(input())
C = Counter(s)
a = C["a"]
b = C["b"]
c = C["c"]
li = [a,b,c]
li.sort()
if li[0]+1 >= li[2]:
print("YES")
else:
print("NO") | 17 | 20 | 367 | 281 | from sys import stdin
from itertools import groupby
s = list(stdin.readline().rstrip())
s.sort()
li = []
for key, value in groupby(s):
li.append(len(list(value)))
if len(li) == 1:
li += [0] * 2
elif len(li) == 2:
li += [0]
if abs(li[2] - li[1]) <= 1 and abs(li[1] - li[0]) <= 1 and abs(li[2] - li[0]) <= 1:
print("YES")
else:
print("NO")
| from sys import stdin
from sys import setrecursionlimit
setrecursionlimit(10**7)
from collections import Counter
s = eval(input())
C = Counter(s)
a = C["a"]
b = C["b"]
c = C["c"]
li = [a, b, c]
li.sort()
if li[0] + 1 >= li[2]:
print("YES")
else:
print("NO")
| false | 15 | [
"-from itertools import groupby",
"+from sys import setrecursionlimit",
"-s = list(stdin.readline().rstrip())",
"-s.sort()",
"-li = []",
"-for key, value in groupby(s):",
"- li.append(len(list(value)))",
"-if len(li) == 1:",
"- li += [0] * 2",
"-elif len(li) == 2:",
"- li += [0]",
"-if abs(li[2] - li[1]) <= 1 and abs(li[1] - li[0]) <= 1 and abs(li[2] - li[0]) <= 1:",
"+setrecursionlimit(10**7)",
"+from collections import Counter",
"+",
"+s = eval(input())",
"+C = Counter(s)",
"+a = C[\"a\"]",
"+b = C[\"b\"]",
"+c = C[\"c\"]",
"+li = [a, b, c]",
"+li.sort()",
"+if li[0] + 1 >= li[2]:"
]
| false | 0.040984 | 0.038785 | 1.056685 | [
"s140913168",
"s625408071"
]
|
u606045429 | p03652 | python | s442359792 | s785034746 | 467 | 273 | 16,584 | 13,508 | Accepted | Accepted | 41.54 | import numpy as np
def main():
A = np.loadtxt(open(0), np.int64, skiprows=1, ndmin=2)
N = ans = len(A)
while A.any():
b = np.bincount(A[:, 0])
A = np.reshape(A[A != np.argmax(b)], (N, -1))
ans = min(ans, max(b))
print(ans)
if __name__ == '__main__':
main()
| import numpy as np
def main():
A = np.loadtxt(open(0), np.int32, skiprows=1, ndmin=2)
N = ans = len(A)
while A.any():
b = np.bincount(A[:, 0])
A = np.reshape(A[A != np.argmax(b)], (N, -1))
ans = min(ans, max(b))
print(ans)
if __name__ == '__main__':
main()
| 17 | 17 | 323 | 323 | import numpy as np
def main():
A = np.loadtxt(open(0), np.int64, skiprows=1, ndmin=2)
N = ans = len(A)
while A.any():
b = np.bincount(A[:, 0])
A = np.reshape(A[A != np.argmax(b)], (N, -1))
ans = min(ans, max(b))
print(ans)
if __name__ == "__main__":
main()
| import numpy as np
def main():
A = np.loadtxt(open(0), np.int32, skiprows=1, ndmin=2)
N = ans = len(A)
while A.any():
b = np.bincount(A[:, 0])
A = np.reshape(A[A != np.argmax(b)], (N, -1))
ans = min(ans, max(b))
print(ans)
if __name__ == "__main__":
main()
| false | 0 | [
"- A = np.loadtxt(open(0), np.int64, skiprows=1, ndmin=2)",
"+ A = np.loadtxt(open(0), np.int32, skiprows=1, ndmin=2)"
]
| false | 0.190377 | 0.233283 | 0.816075 | [
"s442359792",
"s785034746"
]
|
u440566786 | p02950 | python | s291986848 | s183300752 | 780 | 511 | 44,240 | 43,484 | Accepted | Accepted | 34.49 | import sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7
input=lambda :sys.stdin.readline().rstrip()
def resolve():
# preparation
p=int(eval(input()))
invfact=[0]*p
invfact[p-1]=p-1 # Wilson's theorem
for i in range(2,p):
invfact[p-i]=invfact[p-i+1]*(p-i+1)%p
# initialize
A=list(map(int,input().split()))
ans=[0]*p
ans[0]=A[0]
r=[0]*(p+1) # for use of r[-1]=0
r[0]=1
# iterate
for k in range(1,p):
newr=[0]*(p+1) # newr(x)=(x-(k-1))r(x)
v=0 # v=f[k-1](k)
power=1
for i in range(p):
v+=ans[i]*power%p
power*=k
power%=p
newr[i]=(r[i-1]-(k-1)*r[i])%p
r=newr
for i in range(p):
ans[i]+=(A[k]-v)*invfact[k]*r[i]
ans[i]%=p
print((*ans))
resolve() | import sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7
input=lambda :sys.stdin.readline().rstrip()
def resolve():
p=int(eval(input()))
r=[0]*(p+1)
r[1]=-1; r[p]=1
ans=[0]*p
for i,a in enumerate(map(int,input().split())):
if(not a): continue
u=[0]*(p+1) # u(x)=r(x)/(x-i)
for k in range(p-1,-1,-1):
u[k]=(r[k+1]+i*u[k+1])%p
ans[k]-=u[k]
ans[k]%=p
print((*ans))
resolve() | 36 | 19 | 871 | 482 | import sys
sys.setrecursionlimit(2147483647)
INF = float("inf")
MOD = 10**9 + 7
input = lambda: sys.stdin.readline().rstrip()
def resolve():
# preparation
p = int(eval(input()))
invfact = [0] * p
invfact[p - 1] = p - 1 # Wilson's theorem
for i in range(2, p):
invfact[p - i] = invfact[p - i + 1] * (p - i + 1) % p
# initialize
A = list(map(int, input().split()))
ans = [0] * p
ans[0] = A[0]
r = [0] * (p + 1) # for use of r[-1]=0
r[0] = 1
# iterate
for k in range(1, p):
newr = [0] * (p + 1) # newr(x)=(x-(k-1))r(x)
v = 0 # v=f[k-1](k)
power = 1
for i in range(p):
v += ans[i] * power % p
power *= k
power %= p
newr[i] = (r[i - 1] - (k - 1) * r[i]) % p
r = newr
for i in range(p):
ans[i] += (A[k] - v) * invfact[k] * r[i]
ans[i] %= p
print((*ans))
resolve()
| import sys
sys.setrecursionlimit(2147483647)
INF = float("inf")
MOD = 10**9 + 7
input = lambda: sys.stdin.readline().rstrip()
def resolve():
p = int(eval(input()))
r = [0] * (p + 1)
r[1] = -1
r[p] = 1
ans = [0] * p
for i, a in enumerate(map(int, input().split())):
if not a:
continue
u = [0] * (p + 1) # u(x)=r(x)/(x-i)
for k in range(p - 1, -1, -1):
u[k] = (r[k + 1] + i * u[k + 1]) % p
ans[k] -= u[k]
ans[k] %= p
print((*ans))
resolve()
| false | 47.222222 | [
"- # preparation",
"- invfact = [0] * p",
"- invfact[p - 1] = p - 1 # Wilson's theorem",
"- for i in range(2, p):",
"- invfact[p - i] = invfact[p - i + 1] * (p - i + 1) % p",
"- # initialize",
"- A = list(map(int, input().split()))",
"+ r = [0] * (p + 1)",
"+ r[1] = -1",
"+ r[p] = 1",
"- ans[0] = A[0]",
"- r = [0] * (p + 1) # for use of r[-1]=0",
"- r[0] = 1",
"- # iterate",
"- for k in range(1, p):",
"- newr = [0] * (p + 1) # newr(x)=(x-(k-1))r(x)",
"- v = 0 # v=f[k-1](k)",
"- power = 1",
"- for i in range(p):",
"- v += ans[i] * power % p",
"- power *= k",
"- power %= p",
"- newr[i] = (r[i - 1] - (k - 1) * r[i]) % p",
"- r = newr",
"- for i in range(p):",
"- ans[i] += (A[k] - v) * invfact[k] * r[i]",
"- ans[i] %= p",
"+ for i, a in enumerate(map(int, input().split())):",
"+ if not a:",
"+ continue",
"+ u = [0] * (p + 1) # u(x)=r(x)/(x-i)",
"+ for k in range(p - 1, -1, -1):",
"+ u[k] = (r[k + 1] + i * u[k + 1]) % p",
"+ ans[k] -= u[k]",
"+ ans[k] %= p"
]
| false | 0.057461 | 0.057593 | 0.997718 | [
"s291986848",
"s183300752"
]
|
u592248346 | p02622 | python | s525059948 | s690224867 | 72 | 48 | 12,560 | 9,304 | Accepted | Accepted | 33.33 | t = list(eval(input()))
s = list(eval(input()))
cnt = 0
for i in range(len(s)):
if t[i]!=s[i]: cnt+=1
print(cnt) | s = eval(input())
t = eval(input())
print((sum(1 for x,y in zip(s,t) if x!=y))) | 6 | 3 | 109 | 67 | t = list(eval(input()))
s = list(eval(input()))
cnt = 0
for i in range(len(s)):
if t[i] != s[i]:
cnt += 1
print(cnt)
| s = eval(input())
t = eval(input())
print((sum(1 for x, y in zip(s, t) if x != y)))
| false | 50 | [
"-t = list(eval(input()))",
"-s = list(eval(input()))",
"-cnt = 0",
"-for i in range(len(s)):",
"- if t[i] != s[i]:",
"- cnt += 1",
"-print(cnt)",
"+s = eval(input())",
"+t = eval(input())",
"+print((sum(1 for x, y in zip(s, t) if x != y)))"
]
| false | 0.043549 | 0.044147 | 0.986454 | [
"s525059948",
"s690224867"
]
|
u104922648 | p03416 | python | s942812123 | s142375770 | 63 | 36 | 2,940 | 2,940 | Accepted | Accepted | 42.86 | a, b = list(map(int, input().split()))
total = 0
for i in range(a, b+1):
if i == int(str(i)[::-1]):
total += 1
print(total) | a, b = list(map(int, input().split()))
total = 0
for i in range(a, b+1):
if (i%10 == i//10000%10) and (i//10%10 == i//1000%10):
total += 1
print(total) | 6 | 6 | 134 | 162 | a, b = list(map(int, input().split()))
total = 0
for i in range(a, b + 1):
if i == int(str(i)[::-1]):
total += 1
print(total)
| a, b = list(map(int, input().split()))
total = 0
for i in range(a, b + 1):
if (i % 10 == i // 10000 % 10) and (i // 10 % 10 == i // 1000 % 10):
total += 1
print(total)
| false | 0 | [
"- if i == int(str(i)[::-1]):",
"+ if (i % 10 == i // 10000 % 10) and (i // 10 % 10 == i // 1000 % 10):"
]
| false | 0.047429 | 0.040293 | 1.177107 | [
"s942812123",
"s142375770"
]
|
u184898414 | p03168 | python | s303523340 | s151933179 | 902 | 506 | 257,544 | 151,944 | Accepted | Accepted | 43.9 | n = int(eval(input()))
a = list(map(float,input().split()))
dp = [[0 for _ in range(n+1)]for _ in range(n+1)]
dp[0][0]=1
for i in range(n):
for j in range(n):
dp[i+1][j+1]+=dp[i][j]*a[i]
dp[i+1][j]+=dp[i][j]*(1-a[i])
print((sum(dp[n][n//2+1:]))) | n = int(eval(input()))
a = list(map(float,input().split()))
dp = [[0 for i in range(n)] for i in range(n//2+1)]
for i in range((n//2)+1):
l,j=1,i
while j<n:
if i==0:
l=l*a[j]
dp[i][j]=l
j=j+1
else:
for k in range(i):
l=l*(1-a[k])
dp[i][k]=l
while j<n:
dp[i][j]=(dp[i-1][j-1]*(1-a[j]))+(dp[i][j-1]*a[j])
j=j+1
l=0
for i in range(n//2+1):
l+=dp[i][n-1]
print(l)
| 9 | 21 | 265 | 526 | n = int(eval(input()))
a = list(map(float, input().split()))
dp = [[0 for _ in range(n + 1)] for _ in range(n + 1)]
dp[0][0] = 1
for i in range(n):
for j in range(n):
dp[i + 1][j + 1] += dp[i][j] * a[i]
dp[i + 1][j] += dp[i][j] * (1 - a[i])
print((sum(dp[n][n // 2 + 1 :])))
| n = int(eval(input()))
a = list(map(float, input().split()))
dp = [[0 for i in range(n)] for i in range(n // 2 + 1)]
for i in range((n // 2) + 1):
l, j = 1, i
while j < n:
if i == 0:
l = l * a[j]
dp[i][j] = l
j = j + 1
else:
for k in range(i):
l = l * (1 - a[k])
dp[i][k] = l
while j < n:
dp[i][j] = (dp[i - 1][j - 1] * (1 - a[j])) + (dp[i][j - 1] * a[j])
j = j + 1
l = 0
for i in range(n // 2 + 1):
l += dp[i][n - 1]
print(l)
| false | 57.142857 | [
"-dp = [[0 for _ in range(n + 1)] for _ in range(n + 1)]",
"-dp[0][0] = 1",
"-for i in range(n):",
"- for j in range(n):",
"- dp[i + 1][j + 1] += dp[i][j] * a[i]",
"- dp[i + 1][j] += dp[i][j] * (1 - a[i])",
"-print((sum(dp[n][n // 2 + 1 :])))",
"+dp = [[0 for i in range(n)] for i in range(n // 2 + 1)]",
"+for i in range((n // 2) + 1):",
"+ l, j = 1, i",
"+ while j < n:",
"+ if i == 0:",
"+ l = l * a[j]",
"+ dp[i][j] = l",
"+ j = j + 1",
"+ else:",
"+ for k in range(i):",
"+ l = l * (1 - a[k])",
"+ dp[i][k] = l",
"+ while j < n:",
"+ dp[i][j] = (dp[i - 1][j - 1] * (1 - a[j])) + (dp[i][j - 1] * a[j])",
"+ j = j + 1",
"+l = 0",
"+for i in range(n // 2 + 1):",
"+ l += dp[i][n - 1]",
"+print(l)"
]
| false | 0.039039 | 0.07959 | 0.490506 | [
"s303523340",
"s151933179"
]
|
u606045429 | p02904 | python | s043857812 | s676688686 | 464 | 404 | 39,608 | 39,772 | Accepted | Accepted | 12.93 | from itertools import accumulate
from collections import deque
N, K, *P = list(map(int, open(0).read().split()))
mi = []
Q = deque()
for i, p in enumerate(P):
while Q and P[Q[-1]] > p:
Q.pop()
Q.append(i)
if Q[0] == i - K:
Q.popleft()
mi.append(Q[0])
ma = []
Q = deque()
for i, p in enumerate(P):
while Q and P[Q[-1]] < p:
Q.pop()
Q.append(i)
if Q[0] == i - K:
Q.popleft()
ma.append(Q[0])
mi = mi[K - 1:]
ma = ma[K - 1:]
B = [mi[i] != i or ma[i + 1] != i + K for i in range(N - K)]
A = [0] + list(accumulate(x < y for x, y in zip(P, P[1:])))
S = [y - x != K - 1 for x, y in zip(A, A[K - 1:])]
ans = 1 + sum(b for b, s in zip(B, S[1:]) if s)
if S[0] and not all(S):
ans += 1
print(ans)
| from itertools import accumulate
from collections import deque
N, K, *P = list(map(int, open(0).read().split()))
def slide(A, K, cmp=lambda a, b: a > b):
res = []
Q = deque()
for i, a in enumerate(A):
while Q and cmp(A[Q[-1]], a):
Q.pop()
Q.append(i)
if Q[0] == i - K:
Q.popleft()
res.append(Q[0])
return res[K - 1:]
mi = slide(P, K)
ma = slide(P, K, lambda a, b: a < b)
B = [mi != i or ma != i + K for i, (mi, ma) in enumerate(zip(mi, ma[1:]))]
A = [0] + list(accumulate(x < y for x, y in zip(P, P[1:])))
S = [y - x != K - 1 for x, y in zip(A, A[K - 1:])]
ans = 1 + sum(b for b, s in zip(B, S[1:]) if s)
if S[0] and not all(S):
ans += 1
print(ans) | 37 | 29 | 790 | 752 | from itertools import accumulate
from collections import deque
N, K, *P = list(map(int, open(0).read().split()))
mi = []
Q = deque()
for i, p in enumerate(P):
while Q and P[Q[-1]] > p:
Q.pop()
Q.append(i)
if Q[0] == i - K:
Q.popleft()
mi.append(Q[0])
ma = []
Q = deque()
for i, p in enumerate(P):
while Q and P[Q[-1]] < p:
Q.pop()
Q.append(i)
if Q[0] == i - K:
Q.popleft()
ma.append(Q[0])
mi = mi[K - 1 :]
ma = ma[K - 1 :]
B = [mi[i] != i or ma[i + 1] != i + K for i in range(N - K)]
A = [0] + list(accumulate(x < y for x, y in zip(P, P[1:])))
S = [y - x != K - 1 for x, y in zip(A, A[K - 1 :])]
ans = 1 + sum(b for b, s in zip(B, S[1:]) if s)
if S[0] and not all(S):
ans += 1
print(ans)
| from itertools import accumulate
from collections import deque
N, K, *P = list(map(int, open(0).read().split()))
def slide(A, K, cmp=lambda a, b: a > b):
res = []
Q = deque()
for i, a in enumerate(A):
while Q and cmp(A[Q[-1]], a):
Q.pop()
Q.append(i)
if Q[0] == i - K:
Q.popleft()
res.append(Q[0])
return res[K - 1 :]
mi = slide(P, K)
ma = slide(P, K, lambda a, b: a < b)
B = [mi != i or ma != i + K for i, (mi, ma) in enumerate(zip(mi, ma[1:]))]
A = [0] + list(accumulate(x < y for x, y in zip(P, P[1:])))
S = [y - x != K - 1 for x, y in zip(A, A[K - 1 :])]
ans = 1 + sum(b for b, s in zip(B, S[1:]) if s)
if S[0] and not all(S):
ans += 1
print(ans)
| false | 21.621622 | [
"-mi = []",
"-Q = deque()",
"-for i, p in enumerate(P):",
"- while Q and P[Q[-1]] > p:",
"- Q.pop()",
"- Q.append(i)",
"- if Q[0] == i - K:",
"- Q.popleft()",
"- mi.append(Q[0])",
"-ma = []",
"-Q = deque()",
"-for i, p in enumerate(P):",
"- while Q and P[Q[-1]] < p:",
"- Q.pop()",
"- Q.append(i)",
"- if Q[0] == i - K:",
"- Q.popleft()",
"- ma.append(Q[0])",
"-mi = mi[K - 1 :]",
"-ma = ma[K - 1 :]",
"-B = [mi[i] != i or ma[i + 1] != i + K for i in range(N - K)]",
"+",
"+",
"+def slide(A, K, cmp=lambda a, b: a > b):",
"+ res = []",
"+ Q = deque()",
"+ for i, a in enumerate(A):",
"+ while Q and cmp(A[Q[-1]], a):",
"+ Q.pop()",
"+ Q.append(i)",
"+ if Q[0] == i - K:",
"+ Q.popleft()",
"+ res.append(Q[0])",
"+ return res[K - 1 :]",
"+",
"+",
"+mi = slide(P, K)",
"+ma = slide(P, K, lambda a, b: a < b)",
"+B = [mi != i or ma != i + K for i, (mi, ma) in enumerate(zip(mi, ma[1:]))]"
]
| false | 0.038186 | 0.037817 | 1.009773 | [
"s043857812",
"s676688686"
]
|
u014333473 | p03775 | python | s925326399 | s208192180 | 50 | 43 | 9,168 | 9,292 | Accepted | Accepted | 14 | N=int(eval(input()))
result=0
count = 1
while count*count <= N:
if N % count == 0:
result=count
count+=1
print((len(str(N//result)))) | n,r=int(eval(input())),1e9
for i in range(1,int(n**.5)+1):
if n%i==0: r=min(r,max(len(str(i)),len(str(n//i))))
print(r) | 8 | 4 | 140 | 118 | N = int(eval(input()))
result = 0
count = 1
while count * count <= N:
if N % count == 0:
result = count
count += 1
print((len(str(N // result))))
| n, r = int(eval(input())), 1e9
for i in range(1, int(n**0.5) + 1):
if n % i == 0:
r = min(r, max(len(str(i)), len(str(n // i))))
print(r)
| false | 50 | [
"-N = int(eval(input()))",
"-result = 0",
"-count = 1",
"-while count * count <= N:",
"- if N % count == 0:",
"- result = count",
"- count += 1",
"-print((len(str(N // result))))",
"+n, r = int(eval(input())), 1e9",
"+for i in range(1, int(n**0.5) + 1):",
"+ if n % i == 0:",
"+ r = min(r, max(len(str(i)), len(str(n // i))))",
"+print(r)"
]
| false | 0.121446 | 0.098248 | 1.236116 | [
"s925326399",
"s208192180"
]
|
u971811058 | p02608 | python | s518664516 | s394978512 | 882 | 807 | 9,252 | 9,260 | Accepted | Accepted | 8.5 | n = int(eval(input()))
ans = [0]*(n+1)
for x in range(1, 103):
for y in range(1, 103):
for z in range(1, 103):
k = x**2+y**2+z**2+x*y+y*z+z*x
if k<=n: ans[k]+=1
for i in range(1, n+1):
print((ans[i]))
| n = int(eval(input()))
ans = [0]*(n+1)
for x in range(1, 100):
for y in range(1, 100):
for z in range(1, 100):
k = x**2+y**2+z**2+x*y+y*z+z*x
if k<=n: ans[k]+=1
for i in range(1, n+1):
print((ans[i]))
| 9 | 9 | 241 | 241 | n = int(eval(input()))
ans = [0] * (n + 1)
for x in range(1, 103):
for y in range(1, 103):
for z in range(1, 103):
k = x**2 + y**2 + z**2 + x * y + y * z + z * x
if k <= n:
ans[k] += 1
for i in range(1, n + 1):
print((ans[i]))
| n = int(eval(input()))
ans = [0] * (n + 1)
for x in range(1, 100):
for y in range(1, 100):
for z in range(1, 100):
k = x**2 + y**2 + z**2 + x * y + y * z + z * x
if k <= n:
ans[k] += 1
for i in range(1, n + 1):
print((ans[i]))
| false | 0 | [
"-for x in range(1, 103):",
"- for y in range(1, 103):",
"- for z in range(1, 103):",
"+for x in range(1, 100):",
"+ for y in range(1, 100):",
"+ for z in range(1, 100):"
]
| false | 4.277811 | 1.476164 | 2.897924 | [
"s518664516",
"s394978512"
]
|
u864197622 | p02793 | python | s334323554 | s275921154 | 290 | 261 | 48,988 | 46,172 | Accepted | Accepted | 10 | def primeFactor(N):
i, n, ret, d, sq = 2, N, {}, 2, 99
while i <= sq:
k = 0
while n % i == 0: n, k, ret[i] = n//i, k+1, k+1
if k > 0 or i == 97: sq = int(n**(1/2)+0.5)
if i < 4: i = i * 2 - 1
else: i, d = i+d, d^6
if n > 1: ret[n] = 1
return ret
P = 10**9+7
D = {}
N = int(eval(input()))
A = [int(a) for a in input().split()]
t = 0
for a in A:
t += pow(a, P-2, P)
pf = primeFactor(a)
for p in pf:
if p in D:
D[p] = max(D[p], pf[p])
else:
D[p] = pf[p]
s = 1
for f in D:
s = (s * pow(f, D[f], P)) % P
print((s * t % P)) | def primeFactor(N):
i = 2
ret = {}
n = N
while i*i <= n:
k = 0
while n % i == 0:
n //= i
k += 1
if k: ret[i] = k
i += 1 + i%2
if i == 101 and n >= 2**20:
def findFactorRho(N):
def gcd(a, b):
while b: a, b = b, a % b
return a
def f(x, c):
return (x * x + c) % N
for c in range(1, 99):
X, d, j = [2], 1, 0
while d == 1:
j += 1
X.append(f(X[-1], c))
X.append(f(X[-1], c))
d = gcd(abs(X[2*j]-X[j]), N)
if d != N:
if isPrimeMR(d):
return d
elif isPrimeMR(N//d): return N//d
while n > 1:
if isPrimeMR(n):
ret[n], n = 1, 1
else:
j = findFactorRho(n)
k = 0
while n % j == 0:
n //= j
k += 1
ret[j] = k
if n > 1: ret[n] = 1
return ret
def isPrimeMR(n):
if n == 2:
return True
if n == 1 or n & 1 == 0:
return False
d = (n - 1) >> 1
while d & 1 == 0:
d >>= 1
L = [2, 7, 61] if n < 1<<32 else [2, 13, 23, 1662803] if n < 1<<40 else [2, 3, 5, 7, 11, 13, 17] if n < 1<<48 else [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]
for a in L:
t = d
y = pow(a, t, n)
while t != n - 1 and y != 1 and y != n - 1:
y = (y * y) % n
t <<= 1
if y != n - 1 and t & 1 == 0:
return False
return True
P = 10**9+7
D = {}
N = int(eval(input()))
A = [int(a) for a in input().split()]
t = 0
for a in A:
t += pow(a, P-2, P)
pf = primeFactor(a)
for p in pf:
if p in D:
D[p] = max(D[p], pf[p])
else:
D[p] = pf[p]
s = 1
for f in D:
s = (s * pow(f, D[f], P)) % P
print((s * t % P)) | 28 | 82 | 649 | 2,219 | def primeFactor(N):
i, n, ret, d, sq = 2, N, {}, 2, 99
while i <= sq:
k = 0
while n % i == 0:
n, k, ret[i] = n // i, k + 1, k + 1
if k > 0 or i == 97:
sq = int(n ** (1 / 2) + 0.5)
if i < 4:
i = i * 2 - 1
else:
i, d = i + d, d ^ 6
if n > 1:
ret[n] = 1
return ret
P = 10**9 + 7
D = {}
N = int(eval(input()))
A = [int(a) for a in input().split()]
t = 0
for a in A:
t += pow(a, P - 2, P)
pf = primeFactor(a)
for p in pf:
if p in D:
D[p] = max(D[p], pf[p])
else:
D[p] = pf[p]
s = 1
for f in D:
s = (s * pow(f, D[f], P)) % P
print((s * t % P))
| def primeFactor(N):
i = 2
ret = {}
n = N
while i * i <= n:
k = 0
while n % i == 0:
n //= i
k += 1
if k:
ret[i] = k
i += 1 + i % 2
if i == 101 and n >= 2**20:
def findFactorRho(N):
def gcd(a, b):
while b:
a, b = b, a % b
return a
def f(x, c):
return (x * x + c) % N
for c in range(1, 99):
X, d, j = [2], 1, 0
while d == 1:
j += 1
X.append(f(X[-1], c))
X.append(f(X[-1], c))
d = gcd(abs(X[2 * j] - X[j]), N)
if d != N:
if isPrimeMR(d):
return d
elif isPrimeMR(N // d):
return N // d
while n > 1:
if isPrimeMR(n):
ret[n], n = 1, 1
else:
j = findFactorRho(n)
k = 0
while n % j == 0:
n //= j
k += 1
ret[j] = k
if n > 1:
ret[n] = 1
return ret
def isPrimeMR(n):
if n == 2:
return True
if n == 1 or n & 1 == 0:
return False
d = (n - 1) >> 1
while d & 1 == 0:
d >>= 1
L = (
[2, 7, 61]
if n < 1 << 32
else [2, 13, 23, 1662803]
if n < 1 << 40
else [2, 3, 5, 7, 11, 13, 17]
if n < 1 << 48
else [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]
)
for a in L:
t = d
y = pow(a, t, n)
while t != n - 1 and y != 1 and y != n - 1:
y = (y * y) % n
t <<= 1
if y != n - 1 and t & 1 == 0:
return False
return True
P = 10**9 + 7
D = {}
N = int(eval(input()))
A = [int(a) for a in input().split()]
t = 0
for a in A:
t += pow(a, P - 2, P)
pf = primeFactor(a)
for p in pf:
if p in D:
D[p] = max(D[p], pf[p])
else:
D[p] = pf[p]
s = 1
for f in D:
s = (s * pow(f, D[f], P)) % P
print((s * t % P))
| false | 65.853659 | [
"- i, n, ret, d, sq = 2, N, {}, 2, 99",
"- while i <= sq:",
"+ i = 2",
"+ ret = {}",
"+ n = N",
"+ while i * i <= n:",
"- n, k, ret[i] = n // i, k + 1, k + 1",
"- if k > 0 or i == 97:",
"- sq = int(n ** (1 / 2) + 0.5)",
"- if i < 4:",
"- i = i * 2 - 1",
"- else:",
"- i, d = i + d, d ^ 6",
"+ n //= i",
"+ k += 1",
"+ if k:",
"+ ret[i] = k",
"+ i += 1 + i % 2",
"+ if i == 101 and n >= 2**20:",
"+",
"+ def findFactorRho(N):",
"+ def gcd(a, b):",
"+ while b:",
"+ a, b = b, a % b",
"+ return a",
"+",
"+ def f(x, c):",
"+ return (x * x + c) % N",
"+",
"+ for c in range(1, 99):",
"+ X, d, j = [2], 1, 0",
"+ while d == 1:",
"+ j += 1",
"+ X.append(f(X[-1], c))",
"+ X.append(f(X[-1], c))",
"+ d = gcd(abs(X[2 * j] - X[j]), N)",
"+ if d != N:",
"+ if isPrimeMR(d):",
"+ return d",
"+ elif isPrimeMR(N // d):",
"+ return N // d",
"+",
"+ while n > 1:",
"+ if isPrimeMR(n):",
"+ ret[n], n = 1, 1",
"+ else:",
"+ j = findFactorRho(n)",
"+ k = 0",
"+ while n % j == 0:",
"+ n //= j",
"+ k += 1",
"+ ret[j] = k",
"+",
"+",
"+def isPrimeMR(n):",
"+ if n == 2:",
"+ return True",
"+ if n == 1 or n & 1 == 0:",
"+ return False",
"+ d = (n - 1) >> 1",
"+ while d & 1 == 0:",
"+ d >>= 1",
"+ L = (",
"+ [2, 7, 61]",
"+ if n < 1 << 32",
"+ else [2, 13, 23, 1662803]",
"+ if n < 1 << 40",
"+ else [2, 3, 5, 7, 11, 13, 17]",
"+ if n < 1 << 48",
"+ else [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]",
"+ )",
"+ for a in L:",
"+ t = d",
"+ y = pow(a, t, n)",
"+ while t != n - 1 and y != 1 and y != n - 1:",
"+ y = (y * y) % n",
"+ t <<= 1",
"+ if y != n - 1 and t & 1 == 0:",
"+ return False",
"+ return True"
]
| false | 0.070198 | 0.131452 | 0.534019 | [
"s334323554",
"s275921154"
]
|
u869790980 | p02762 | python | s801321483 | s350355731 | 973 | 836 | 116,252 | 104,348 | Accepted | Accepted | 14.08 | import collections
n,m,k = list(map(int,input().split(' ')))
friendships = [list(map(int, input().split(' '))) for _ in range(m)]
disses = [list(map(int, input().split(' '))) for _ in range(k)]
parent = {i:i for i in range(0, n+1)}
sizes = {i:1 for i in range(0, n+1)}
hd = collections.Counter()
adj = collections.defaultdict(set)
def f(parent, u):
if parent[u] != u:
parent[u] = f(parent, parent[u])
return parent[u]
for a,b in friendships:
pa,pb = f(parent, a), f(parent, b)
adj[a].add(b)
adj[b].add(a)
if pa != pb:
if sizes[pa] >= sizes[pb]:
parent[pb] = pa
sizes[pa] += sizes[pb]
else:
parent[pa] = pb
sizes[pb] += sizes[pa]
for c,d in disses:
pc,pd = f(parent, c), f(parent, d)
if d not in adj[c] and (pc == pd):
hd[c] += 1
hd[d] += 1
print(' '.join([str(sizes[f(parent,u)] - len(adj[u]) - hd[u] - 1) for u in range(1, n+1)])) | import collections
n,m,k = list(map(int,input().split(' ')))
friendships = [list(map(int, input().split(' '))) for _ in range(m)]
disses = [list(map(int, input().split(' '))) for _ in range(k)]
parent = [i for i in range(0, n+1)]
sizes = [1 for i in range(0, n+1)]
hd = collections.Counter()
adj = collections.defaultdict(set)
def f(parent, u):
if parent[u] != u:
parent[u] = f(parent, parent[u])
return parent[u]
for a,b in friendships:
pa,pb = f(parent, a), f(parent, b)
adj[a].add(b)
adj[b].add(a)
if pa != pb:
if sizes[pa] >= sizes[pb]:
parent[pb] = pa
sizes[pa] += sizes[pb]
else:
parent[pa] = pb
sizes[pb] += sizes[pa]
for c,d in disses:
pc,pd = f(parent, c), f(parent, d)
if d not in adj[c] and (pc == pd):
hd[c] += 1
hd[d] += 1
print(' '.join([str(sizes[f(parent,u)] - len(adj[u]) - hd[u] - 1) for u in range(1, n+1)])) | 41 | 40 | 909 | 903 | import collections
n, m, k = list(map(int, input().split(" ")))
friendships = [list(map(int, input().split(" "))) for _ in range(m)]
disses = [list(map(int, input().split(" "))) for _ in range(k)]
parent = {i: i for i in range(0, n + 1)}
sizes = {i: 1 for i in range(0, n + 1)}
hd = collections.Counter()
adj = collections.defaultdict(set)
def f(parent, u):
if parent[u] != u:
parent[u] = f(parent, parent[u])
return parent[u]
for a, b in friendships:
pa, pb = f(parent, a), f(parent, b)
adj[a].add(b)
adj[b].add(a)
if pa != pb:
if sizes[pa] >= sizes[pb]:
parent[pb] = pa
sizes[pa] += sizes[pb]
else:
parent[pa] = pb
sizes[pb] += sizes[pa]
for c, d in disses:
pc, pd = f(parent, c), f(parent, d)
if d not in adj[c] and (pc == pd):
hd[c] += 1
hd[d] += 1
print(
" ".join(
[str(sizes[f(parent, u)] - len(adj[u]) - hd[u] - 1) for u in range(1, n + 1)]
)
)
| import collections
n, m, k = list(map(int, input().split(" ")))
friendships = [list(map(int, input().split(" "))) for _ in range(m)]
disses = [list(map(int, input().split(" "))) for _ in range(k)]
parent = [i for i in range(0, n + 1)]
sizes = [1 for i in range(0, n + 1)]
hd = collections.Counter()
adj = collections.defaultdict(set)
def f(parent, u):
if parent[u] != u:
parent[u] = f(parent, parent[u])
return parent[u]
for a, b in friendships:
pa, pb = f(parent, a), f(parent, b)
adj[a].add(b)
adj[b].add(a)
if pa != pb:
if sizes[pa] >= sizes[pb]:
parent[pb] = pa
sizes[pa] += sizes[pb]
else:
parent[pa] = pb
sizes[pb] += sizes[pa]
for c, d in disses:
pc, pd = f(parent, c), f(parent, d)
if d not in adj[c] and (pc == pd):
hd[c] += 1
hd[d] += 1
print(
" ".join(
[str(sizes[f(parent, u)] - len(adj[u]) - hd[u] - 1) for u in range(1, n + 1)]
)
)
| false | 2.439024 | [
"-parent = {i: i for i in range(0, n + 1)}",
"-sizes = {i: 1 for i in range(0, n + 1)}",
"+parent = [i for i in range(0, n + 1)]",
"+sizes = [1 for i in range(0, n + 1)]"
]
| false | 0.049069 | 0.037337 | 1.314212 | [
"s801321483",
"s350355731"
]
|
u790012205 | p02682 | python | s991961925 | s233527641 | 62 | 23 | 61,656 | 9,164 | Accepted | Accepted | 62.9 | import sys
A, B, C, K = list(map(int, input().split()))
N = 0
if K - A < 0:
print(K)
sys.exit()
else:
N = A
K = K - A
if K - B < 0:
print(N)
sys.exit()
else:
K = K - B
print((N - K)) | import sys
A, B, C, K = list(map(int, input().split()))
c = 0
if K <= A:
c += K
print(c)
sys.exit()
else:
c += A
K -= A
if K <= B:
print(c)
sys.exit()
else:
K -= B
c -= K
print(c) | 15 | 17 | 216 | 229 | import sys
A, B, C, K = list(map(int, input().split()))
N = 0
if K - A < 0:
print(K)
sys.exit()
else:
N = A
K = K - A
if K - B < 0:
print(N)
sys.exit()
else:
K = K - B
print((N - K))
| import sys
A, B, C, K = list(map(int, input().split()))
c = 0
if K <= A:
c += K
print(c)
sys.exit()
else:
c += A
K -= A
if K <= B:
print(c)
sys.exit()
else:
K -= B
c -= K
print(c)
| false | 11.764706 | [
"-N = 0",
"-if K - A < 0:",
"- print(K)",
"+c = 0",
"+if K <= A:",
"+ c += K",
"+ print(c)",
"- N = A",
"- K = K - A",
"-if K - B < 0:",
"- print(N)",
"+ c += A",
"+ K -= A",
"+if K <= B:",
"+ print(c)",
"- K = K - B",
"-print((N - K))",
"+ K -= B",
"+ c -= K",
"+ print(c)"
]
| false | 0.036223 | 0.036196 | 1.000739 | [
"s991961925",
"s233527641"
]
|
u325119213 | p03474 | python | s768393393 | s749268484 | 37 | 28 | 9,864 | 8,896 | Accepted | Accepted | 24.32 | import re
def actual(a, b, s):
pattern = r'\d{' + f'{a}' + r'}-\d{' + f'{b}' + '}'
if re.fullmatch(pattern, s):
return 'Yes'
return 'No'
a, b = list(map(int, input().split()))
s = eval(input())
print((actual(a, b, s))) | def actual(a, b, s):
if s[a] != '-':
return 'No'
for i in range(0, a):
if not '0' <= s[i] <= '9':
return 'No'
for j in range(a + 1, len(s)):
if not '0' <= s[j] <= '9':
return 'No'
return 'Yes'
a, b = list(map(int, input().split()))
s = eval(input())
print((actual(a, b, s)))
| 15 | 19 | 248 | 349 | import re
def actual(a, b, s):
pattern = r"\d{" + f"{a}" + r"}-\d{" + f"{b}" + "}"
if re.fullmatch(pattern, s):
return "Yes"
return "No"
a, b = list(map(int, input().split()))
s = eval(input())
print((actual(a, b, s)))
| def actual(a, b, s):
if s[a] != "-":
return "No"
for i in range(0, a):
if not "0" <= s[i] <= "9":
return "No"
for j in range(a + 1, len(s)):
if not "0" <= s[j] <= "9":
return "No"
return "Yes"
a, b = list(map(int, input().split()))
s = eval(input())
print((actual(a, b, s)))
| false | 21.052632 | [
"-import re",
"-",
"-",
"- pattern = r\"\\d{\" + f\"{a}\" + r\"}-\\d{\" + f\"{b}\" + \"}\"",
"- if re.fullmatch(pattern, s):",
"- return \"Yes\"",
"- return \"No\"",
"+ if s[a] != \"-\":",
"+ return \"No\"",
"+ for i in range(0, a):",
"+ if not \"0\" <= s[i] <= \"9\":",
"+ return \"No\"",
"+ for j in range(a + 1, len(s)):",
"+ if not \"0\" <= s[j] <= \"9\":",
"+ return \"No\"",
"+ return \"Yes\""
]
| false | 0.052102 | 0.046624 | 1.117496 | [
"s768393393",
"s749268484"
]
|
u647766105 | p00161 | python | s790286828 | s031639067 | 80 | 70 | 5,548 | 5,548 | Accepted | Accepted | 12.5 | while True:
n = int(input())
if n == 0:
break
R = sorted([list(map(int,input().split())) for _ in range(n)],
key = lambda x:sum(60*m+s for m,s in zip(x[1::2],x[2::2])))
print("\n".join(map(str,[R[0][0],R[1][0],R[-2][0]]))) | while True:
n = eval(input())
if n == 0:
break
R = sorted([list(map(int,input().split())) for _ in range(n)],
key = lambda x:sum(60*m+s for m,s in zip(x[1::2],x[2::2])))
print("\n".join(map(str,[R[0][0],R[1][0],R[-2][0]]))) | 7 | 7 | 270 | 261 | while True:
n = int(input())
if n == 0:
break
R = sorted(
[list(map(int, input().split())) for _ in range(n)],
key=lambda x: sum(60 * m + s for m, s in zip(x[1::2], x[2::2])),
)
print("\n".join(map(str, [R[0][0], R[1][0], R[-2][0]])))
| while True:
n = eval(input())
if n == 0:
break
R = sorted(
[list(map(int, input().split())) for _ in range(n)],
key=lambda x: sum(60 * m + s for m, s in zip(x[1::2], x[2::2])),
)
print("\n".join(map(str, [R[0][0], R[1][0], R[-2][0]])))
| false | 0 | [
"- n = int(input())",
"+ n = eval(input())"
]
| false | 0.043499 | 0.042317 | 1.027942 | [
"s790286828",
"s031639067"
]
|
u947883560 | p02683 | python | s313041566 | s181739133 | 84 | 57 | 74,756 | 9,240 | Accepted | Accepted | 32.14 | #!/usr/bin/env python3
import sys
sys.setrecursionlimit(10**8)
INF = float("inf")
def bit(n, k):
return (n >> k) & 1
def main():
N, M, X = list(map(int, input().split()))
C = [0]*N
A = [None]*N
for i in range(N):
C[i], *A[i] = list(map(int, input().split()))
min_money = INF
# 全探索
for i in range(1 << N):
tot = [0]*M
money = 0
for n in range(N):
if bit(i, n):
money += C[n]
for j in range(M):
tot[j] += A[n][j]
if all(tot[j] >= X for j in range(M)):
min_money = min(money, min_money)
if min_money == INF:
print((-1))
else:
print(min_money)
return
if __name__ == '__main__':
main()
| #!/usr/bin/env python3
import sys
import itertools
sys.setrecursionlimit(10**8)
INF = float("inf")
def bit(n, k):
return (n >> k) & 1
def main():
N, M, X = list(map(int, input().split()))
C = [0]*N
A = [None]*N
for i in range(N):
C[i], *A[i] = list(map(int, input().split()))
min_money = INF
# 全探索
for pattern in itertools.product((0, 1), repeat=N):
# for i in range(1 << N):
tot = [0]*M
money = 0
for i, use in enumerate(pattern):
if use == 0:
continue
money += C[i]
for j in range(M):
tot[j] += A[i][j]
if all(tot[j] >= X for j in range(M)):
min_money = min(money, min_money)
if min_money == INF:
print((-1))
else:
print(min_money)
return
if __name__ == '__main__':
main()
| 40 | 43 | 795 | 904 | #!/usr/bin/env python3
import sys
sys.setrecursionlimit(10**8)
INF = float("inf")
def bit(n, k):
return (n >> k) & 1
def main():
N, M, X = list(map(int, input().split()))
C = [0] * N
A = [None] * N
for i in range(N):
C[i], *A[i] = list(map(int, input().split()))
min_money = INF
# 全探索
for i in range(1 << N):
tot = [0] * M
money = 0
for n in range(N):
if bit(i, n):
money += C[n]
for j in range(M):
tot[j] += A[n][j]
if all(tot[j] >= X for j in range(M)):
min_money = min(money, min_money)
if min_money == INF:
print((-1))
else:
print(min_money)
return
if __name__ == "__main__":
main()
| #!/usr/bin/env python3
import sys
import itertools
sys.setrecursionlimit(10**8)
INF = float("inf")
def bit(n, k):
return (n >> k) & 1
def main():
N, M, X = list(map(int, input().split()))
C = [0] * N
A = [None] * N
for i in range(N):
C[i], *A[i] = list(map(int, input().split()))
min_money = INF
# 全探索
for pattern in itertools.product((0, 1), repeat=N):
# for i in range(1 << N):
tot = [0] * M
money = 0
for i, use in enumerate(pattern):
if use == 0:
continue
money += C[i]
for j in range(M):
tot[j] += A[i][j]
if all(tot[j] >= X for j in range(M)):
min_money = min(money, min_money)
if min_money == INF:
print((-1))
else:
print(min_money)
return
if __name__ == "__main__":
main()
| false | 6.976744 | [
"+import itertools",
"- for i in range(1 << N):",
"+ for pattern in itertools.product((0, 1), repeat=N):",
"+ # for i in range(1 << N):",
"- for n in range(N):",
"- if bit(i, n):",
"- money += C[n]",
"- for j in range(M):",
"- tot[j] += A[n][j]",
"+ for i, use in enumerate(pattern):",
"+ if use == 0:",
"+ continue",
"+ money += C[i]",
"+ for j in range(M):",
"+ tot[j] += A[i][j]"
]
| false | 0.047196 | 0.036993 | 1.275798 | [
"s313041566",
"s181739133"
]
|
u586368075 | p02744 | python | s989125117 | s746950442 | 456 | 183 | 12,680 | 12,680 | Accepted | Accepted | 59.87 | def f(n, count=0, i=0, lst=[]):
global ans
if count == n:
s = ""
for j in range(count):
s += chr(ord("a") + lst[j])
ans.append(s)
return
if i == 0:
lst.append(i)
f(n, count + 1, i=i+1, lst=lst)
else:
for j in range(i + 1):
f(n, count + 1, i=max(i, j + 1), lst=lst+[j])
import sys
sys.setrecursionlimit(10000)
n = int(eval(input()))
ans = []
f(n)
ans.sort()
for i in ans:
print(i) | def f(n, count=0, i=0, s=""):
global ans
if count == n:
ans.append(s)
return
if i == 0:
f(n, count + 1, i=i+1, s=s+"a")
else:
for j in range(i + 1):
f(n, count + 1, i=max(i, j + 1), s=s+chr(ord("a") + j))
import sys
sys.setrecursionlimit(10000)
n = int(eval(input()))
ans = []
f(n)
ans.sort()
for i in ans:
print(i) | 23 | 19 | 496 | 392 | def f(n, count=0, i=0, lst=[]):
global ans
if count == n:
s = ""
for j in range(count):
s += chr(ord("a") + lst[j])
ans.append(s)
return
if i == 0:
lst.append(i)
f(n, count + 1, i=i + 1, lst=lst)
else:
for j in range(i + 1):
f(n, count + 1, i=max(i, j + 1), lst=lst + [j])
import sys
sys.setrecursionlimit(10000)
n = int(eval(input()))
ans = []
f(n)
ans.sort()
for i in ans:
print(i)
| def f(n, count=0, i=0, s=""):
global ans
if count == n:
ans.append(s)
return
if i == 0:
f(n, count + 1, i=i + 1, s=s + "a")
else:
for j in range(i + 1):
f(n, count + 1, i=max(i, j + 1), s=s + chr(ord("a") + j))
import sys
sys.setrecursionlimit(10000)
n = int(eval(input()))
ans = []
f(n)
ans.sort()
for i in ans:
print(i)
| false | 17.391304 | [
"-def f(n, count=0, i=0, lst=[]):",
"+def f(n, count=0, i=0, s=\"\"):",
"- s = \"\"",
"- for j in range(count):",
"- s += chr(ord(\"a\") + lst[j])",
"- lst.append(i)",
"- f(n, count + 1, i=i + 1, lst=lst)",
"+ f(n, count + 1, i=i + 1, s=s + \"a\")",
"- f(n, count + 1, i=max(i, j + 1), lst=lst + [j])",
"+ f(n, count + 1, i=max(i, j + 1), s=s + chr(ord(\"a\") + j))"
]
| false | 0.036969 | 0.035854 | 1.031101 | [
"s989125117",
"s746950442"
]
|
u218838821 | p02953 | python | s964779096 | s951485589 | 89 | 74 | 20,676 | 20,596 | Accepted | Accepted | 16.85 | N = int(eval(input()))
H = list(map(int,input().split()))
for i in range(N-1,0,-1):
if H[i-1] - H[i] > 1:
print("No")
exit()
if H[i-1] - H[i] == 1:
H[i-1] -= 1
for i in range(N-1):
if H[i] > H[i+1]:
print("No1")
exit()
print("Yes") | N = int(eval(input()))
H = list(map(int,input().split()))
for i in range(N-1,0,-1):
if H[i] + 1 == H[i-1]:
H[i-1] -= 1
elif H[i] < H[i-1]:
print("No")
exit()
print("Yes")
| 16 | 10 | 303 | 207 | N = int(eval(input()))
H = list(map(int, input().split()))
for i in range(N - 1, 0, -1):
if H[i - 1] - H[i] > 1:
print("No")
exit()
if H[i - 1] - H[i] == 1:
H[i - 1] -= 1
for i in range(N - 1):
if H[i] > H[i + 1]:
print("No1")
exit()
print("Yes")
| N = int(eval(input()))
H = list(map(int, input().split()))
for i in range(N - 1, 0, -1):
if H[i] + 1 == H[i - 1]:
H[i - 1] -= 1
elif H[i] < H[i - 1]:
print("No")
exit()
print("Yes")
| false | 37.5 | [
"- if H[i - 1] - H[i] > 1:",
"+ if H[i] + 1 == H[i - 1]:",
"+ H[i - 1] -= 1",
"+ elif H[i] < H[i - 1]:",
"- if H[i - 1] - H[i] == 1:",
"- H[i - 1] -= 1",
"-for i in range(N - 1):",
"- if H[i] > H[i + 1]:",
"- print(\"No1\")",
"- exit()"
]
| false | 0.043688 | 0.035396 | 1.234262 | [
"s964779096",
"s951485589"
]
|
u585742242 | p03291 | python | s432305211 | s392863316 | 599 | 476 | 3,316 | 27,588 | Accepted | Accepted | 20.53 |
S = input()
if S == '?' * (10 ** 5):
print(590369788)
else:
dp = [0, 0, 0, 1]
for s in S[::-1]:
tmp = dp[:]
dp[3] = tmp[3] * 3 if s == '?' else tmp[3]
for j in range(2, -1, -1):
dp[j] = tmp[j] * 3 + tmp[j + 1] if s == '?' else \
tmp[j] + tmp[j + 1] if s == 'ABC'[j] else \
tmp[j]
print(dp[0] % (10**9 + 7))
| # -*- coding: utf-8 -*-
S = eval(input())
mod = 10 ** 9 + 7
dp = [[0] * 4 for i in range(len(S) + 1)]
dp[len(S)][3] = 1
for i in range(len(S) - 1, -1, -1):
dp[i][3] += dp[i + 1][3] * 3 if S[i] == '?' else dp[i + 1][3]
dp[i][3] %= mod
for j in range(2, -1, -1):
dp[i][j] += dp[i + 1][j] * 3 if S[i] == '?' else dp[i + 1][j]
dp[i][j] += dp[i + 1][j + 1] if S[i] == 'ABC' [j] or S[i] == '?' else 0
dp[i][j] %= mod
print((dp[0][0]))
| 19 | 16 | 423 | 475 | S = input()
if S == "?" * (10**5):
print(590369788)
else:
dp = [0, 0, 0, 1]
for s in S[::-1]:
tmp = dp[:]
dp[3] = tmp[3] * 3 if s == "?" else tmp[3]
for j in range(2, -1, -1):
dp[j] = (
tmp[j] * 3 + tmp[j + 1]
if s == "?"
else tmp[j] + tmp[j + 1]
if s == "ABC"[j]
else tmp[j]
)
print(dp[0] % (10**9 + 7))
| # -*- coding: utf-8 -*-
S = eval(input())
mod = 10**9 + 7
dp = [[0] * 4 for i in range(len(S) + 1)]
dp[len(S)][3] = 1
for i in range(len(S) - 1, -1, -1):
dp[i][3] += dp[i + 1][3] * 3 if S[i] == "?" else dp[i + 1][3]
dp[i][3] %= mod
for j in range(2, -1, -1):
dp[i][j] += dp[i + 1][j] * 3 if S[i] == "?" else dp[i + 1][j]
dp[i][j] += dp[i + 1][j + 1] if S[i] == "ABC"[j] or S[i] == "?" else 0
dp[i][j] %= mod
print((dp[0][0]))
| false | 15.789474 | [
"-S = input()",
"-if S == \"?\" * (10**5):",
"- print(590369788)",
"-else:",
"- dp = [0, 0, 0, 1]",
"- for s in S[::-1]:",
"- tmp = dp[:]",
"- dp[3] = tmp[3] * 3 if s == \"?\" else tmp[3]",
"- for j in range(2, -1, -1):",
"- dp[j] = (",
"- tmp[j] * 3 + tmp[j + 1]",
"- if s == \"?\"",
"- else tmp[j] + tmp[j + 1]",
"- if s == \"ABC\"[j]",
"- else tmp[j]",
"- )",
"- print(dp[0] % (10**9 + 7))",
"+# -*- coding: utf-8 -*-",
"+S = eval(input())",
"+mod = 10**9 + 7",
"+dp = [[0] * 4 for i in range(len(S) + 1)]",
"+dp[len(S)][3] = 1",
"+for i in range(len(S) - 1, -1, -1):",
"+ dp[i][3] += dp[i + 1][3] * 3 if S[i] == \"?\" else dp[i + 1][3]",
"+ dp[i][3] %= mod",
"+ for j in range(2, -1, -1):",
"+ dp[i][j] += dp[i + 1][j] * 3 if S[i] == \"?\" else dp[i + 1][j]",
"+ dp[i][j] += dp[i + 1][j + 1] if S[i] == \"ABC\"[j] or S[i] == \"?\" else 0",
"+ dp[i][j] %= mod",
"+print((dp[0][0]))"
]
| false | 0.044962 | 0.036913 | 1.218069 | [
"s432305211",
"s392863316"
]
|
u905203728 | p03347 | python | s696401811 | s085565124 | 799 | 584 | 57,560 | 104,192 | Accepted | Accepted | 26.91 | n=int(eval(input()))
A=[int(eval(input())) for _ in range(n)]
if A[0]!=0:print((-1));exit()
cnt,length=0,0
for i in range(n-1):
if A[i]!=0:length +=1
else:length=0
if A[i]<=length:
if A[i]+1==A[i+1]:cnt +=1
elif A[i+1]-A[i]>1:print((-1));exit()
else:cnt +=A[i+1]
else:print((-1));exit()
print(cnt) | n=int(eval(input()))
A=[int(eval(input())) for _ in range(n)]
if A[0]!=0:print((-1));exit()
cnt=0
for i in range(1,n):
if A[i-1]+1==A[i]:
cnt +=1
elif A[i-1]==A[i]:
cnt +=A[i]
elif A[i-1]>A[i]:
cnt +=A[i]
else:print((-1));exit()
print(cnt) | 16 | 16 | 337 | 281 | n = int(eval(input()))
A = [int(eval(input())) for _ in range(n)]
if A[0] != 0:
print((-1))
exit()
cnt, length = 0, 0
for i in range(n - 1):
if A[i] != 0:
length += 1
else:
length = 0
if A[i] <= length:
if A[i] + 1 == A[i + 1]:
cnt += 1
elif A[i + 1] - A[i] > 1:
print((-1))
exit()
else:
cnt += A[i + 1]
else:
print((-1))
exit()
print(cnt)
| n = int(eval(input()))
A = [int(eval(input())) for _ in range(n)]
if A[0] != 0:
print((-1))
exit()
cnt = 0
for i in range(1, n):
if A[i - 1] + 1 == A[i]:
cnt += 1
elif A[i - 1] == A[i]:
cnt += A[i]
elif A[i - 1] > A[i]:
cnt += A[i]
else:
print((-1))
exit()
print(cnt)
| false | 0 | [
"-cnt, length = 0, 0",
"-for i in range(n - 1):",
"- if A[i] != 0:",
"- length += 1",
"- else:",
"- length = 0",
"- if A[i] <= length:",
"- if A[i] + 1 == A[i + 1]:",
"- cnt += 1",
"- elif A[i + 1] - A[i] > 1:",
"- print((-1))",
"- exit()",
"- else:",
"- cnt += A[i + 1]",
"+cnt = 0",
"+for i in range(1, n):",
"+ if A[i - 1] + 1 == A[i]:",
"+ cnt += 1",
"+ elif A[i - 1] == A[i]:",
"+ cnt += A[i]",
"+ elif A[i - 1] > A[i]:",
"+ cnt += A[i]"
]
| false | 0.040611 | 0.079377 | 0.511619 | [
"s696401811",
"s085565124"
]
|
u227082700 | p02845 | python | s900946098 | s364136201 | 239 | 112 | 52,952 | 14,396 | Accepted | Accepted | 53.14 | n=int(eval(input()))
a=list(map(int,input().split()))
d=[-1,-1,-1]
x=1
for i in a:
b=0
f=True
for j in range(3):
if d[j]==i-1:
b+=1
if f:
f=False
d[j]=i
x*=b
x%=10**9+7
print(x) | n=int(eval(input()))
d=[-1,-1,-1]
x=1
for i in list(map(int,input().split())):
x*=d.count(i-1)
x%=10**9+7
if i-1 in d:d[d.index(i-1)]+=1
print(x) | 16 | 8 | 228 | 152 | n = int(eval(input()))
a = list(map(int, input().split()))
d = [-1, -1, -1]
x = 1
for i in a:
b = 0
f = True
for j in range(3):
if d[j] == i - 1:
b += 1
if f:
f = False
d[j] = i
x *= b
x %= 10**9 + 7
print(x)
| n = int(eval(input()))
d = [-1, -1, -1]
x = 1
for i in list(map(int, input().split())):
x *= d.count(i - 1)
x %= 10**9 + 7
if i - 1 in d:
d[d.index(i - 1)] += 1
print(x)
| false | 50 | [
"-a = list(map(int, input().split()))",
"-for i in a:",
"- b = 0",
"- f = True",
"- for j in range(3):",
"- if d[j] == i - 1:",
"- b += 1",
"- if f:",
"- f = False",
"- d[j] = i",
"- x *= b",
"+for i in list(map(int, input().split())):",
"+ x *= d.count(i - 1)",
"+ if i - 1 in d:",
"+ d[d.index(i - 1)] += 1"
]
| false | 0.047768 | 0.04435 | 1.077071 | [
"s900946098",
"s364136201"
]
|
u983918956 | p03166 | python | s241892099 | s815236393 | 494 | 345 | 103,936 | 75,056 | Accepted | Accepted | 30.16 | import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)
N,M = list(map(int,input().split()))
ad = [[] for _ in range(N)]
for _ in range(M):
x,y = list(map(int,input().split()))
x -= 1
y -= 1
ad[y].append(x)
dp = [-1]*N
def rec(v):
if dp[v] != -1:
return dp[v]
res = 0
for nv in ad[v]:
res = max(res, rec(nv) + 1)
dp[v] = res
return dp[v]
for v in range(N):
rec(v)
ans = max(dp)
print(ans) | def main():
import sys
input = sys.stdin.readline
from collections import deque
N,M = list(map(int,input().split()))
dp = [-1]*N
ad = [deque() for _ in range(N)]
num = [0]*N
for _ in range(M):
x,y = list(map(int,input().split()))
x -= 1; y -= 1
ad[x].append(y)
num[y] += 1
L = []
S = deque()
for v in range(N):
if num[v] == 0:
S.append(v)
dp[v] = 0
while S:
v = S.popleft()
L.append(v)
for _ in range(len(ad[v])):
nv = ad[v].popleft()
num[nv] -= 1
if num[nv] == 0:
S.append(nv)
dp[nv] = dp[v] + 1
ans = max(dp)
print(ans)
main() | 28 | 37 | 475 | 770 | import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)
N, M = list(map(int, input().split()))
ad = [[] for _ in range(N)]
for _ in range(M):
x, y = list(map(int, input().split()))
x -= 1
y -= 1
ad[y].append(x)
dp = [-1] * N
def rec(v):
if dp[v] != -1:
return dp[v]
res = 0
for nv in ad[v]:
res = max(res, rec(nv) + 1)
dp[v] = res
return dp[v]
for v in range(N):
rec(v)
ans = max(dp)
print(ans)
| def main():
import sys
input = sys.stdin.readline
from collections import deque
N, M = list(map(int, input().split()))
dp = [-1] * N
ad = [deque() for _ in range(N)]
num = [0] * N
for _ in range(M):
x, y = list(map(int, input().split()))
x -= 1
y -= 1
ad[x].append(y)
num[y] += 1
L = []
S = deque()
for v in range(N):
if num[v] == 0:
S.append(v)
dp[v] = 0
while S:
v = S.popleft()
L.append(v)
for _ in range(len(ad[v])):
nv = ad[v].popleft()
num[nv] -= 1
if num[nv] == 0:
S.append(nv)
dp[nv] = dp[v] + 1
ans = max(dp)
print(ans)
main()
| false | 24.324324 | [
"-import sys",
"+def main():",
"+ import sys",
"-input = sys.stdin.readline",
"-sys.setrecursionlimit(10**6)",
"-N, M = list(map(int, input().split()))",
"-ad = [[] for _ in range(N)]",
"-for _ in range(M):",
"- x, y = list(map(int, input().split()))",
"- x -= 1",
"- y -= 1",
"- ad[y].append(x)",
"-dp = [-1] * N",
"+ input = sys.stdin.readline",
"+ from collections import deque",
"+",
"+ N, M = list(map(int, input().split()))",
"+ dp = [-1] * N",
"+ ad = [deque() for _ in range(N)]",
"+ num = [0] * N",
"+ for _ in range(M):",
"+ x, y = list(map(int, input().split()))",
"+ x -= 1",
"+ y -= 1",
"+ ad[x].append(y)",
"+ num[y] += 1",
"+ L = []",
"+ S = deque()",
"+ for v in range(N):",
"+ if num[v] == 0:",
"+ S.append(v)",
"+ dp[v] = 0",
"+ while S:",
"+ v = S.popleft()",
"+ L.append(v)",
"+ for _ in range(len(ad[v])):",
"+ nv = ad[v].popleft()",
"+ num[nv] -= 1",
"+ if num[nv] == 0:",
"+ S.append(nv)",
"+ dp[nv] = dp[v] + 1",
"+ ans = max(dp)",
"+ print(ans)",
"-def rec(v):",
"- if dp[v] != -1:",
"- return dp[v]",
"- res = 0",
"- for nv in ad[v]:",
"- res = max(res, rec(nv) + 1)",
"- dp[v] = res",
"- return dp[v]",
"-",
"-",
"-for v in range(N):",
"- rec(v)",
"-ans = max(dp)",
"-print(ans)",
"+main()"
]
| false | 0.04201 | 0.063741 | 0.659064 | [
"s241892099",
"s815236393"
]
|
u020604402 | p03423 | python | s656635884 | s583303368 | 190 | 17 | 38,256 | 2,940 | Accepted | Accepted | 91.05 | N = int(eval(input()))
print((int(N//3))) | N = int(eval(input()))
print((N//3))
| 2 | 2 | 34 | 30 | N = int(eval(input()))
print((int(N // 3)))
| N = int(eval(input()))
print((N // 3))
| false | 0 | [
"-print((int(N // 3)))",
"+print((N // 3))"
]
| false | 0.04765 | 0.041039 | 1.161091 | [
"s656635884",
"s583303368"
]
|
u763534217 | p02615 | python | s148808970 | s456156683 | 245 | 166 | 35,252 | 31,588 | Accepted | Accepted | 32.24 | n = int(eval(input()))
a = list(map(int, input().split()))
a.sort(reverse=True)
maxval = a[0]
cc = {maxval: 1}
ans = 0
idx = 0
for i in range(1, n):
if a[i] in cc:
cc[a[i]] += 2
else:
cc[a[i]] = 2
cc[maxval] -= 1
ans += maxval
if cc[maxval] == 0:
while 1:
idx += 1
if maxval > a[idx]:
maxval = a[idx]
break
print(ans)
| n = int(eval(input()))
a = list(map(int, input().split()))
a.sort()
ans = 0
for i in range(1, n):
ans += a[n-int(i/2)-1]
print(ans)
| 25 | 8 | 440 | 138 | n = int(eval(input()))
a = list(map(int, input().split()))
a.sort(reverse=True)
maxval = a[0]
cc = {maxval: 1}
ans = 0
idx = 0
for i in range(1, n):
if a[i] in cc:
cc[a[i]] += 2
else:
cc[a[i]] = 2
cc[maxval] -= 1
ans += maxval
if cc[maxval] == 0:
while 1:
idx += 1
if maxval > a[idx]:
maxval = a[idx]
break
print(ans)
| n = int(eval(input()))
a = list(map(int, input().split()))
a.sort()
ans = 0
for i in range(1, n):
ans += a[n - int(i / 2) - 1]
print(ans)
| false | 68 | [
"-a.sort(reverse=True)",
"-maxval = a[0]",
"-cc = {maxval: 1}",
"+a.sort()",
"-idx = 0",
"- if a[i] in cc:",
"- cc[a[i]] += 2",
"- else:",
"- cc[a[i]] = 2",
"- cc[maxval] -= 1",
"- ans += maxval",
"- if cc[maxval] == 0:",
"- while 1:",
"- idx += 1",
"- if maxval > a[idx]:",
"- maxval = a[idx]",
"- break",
"+ ans += a[n - int(i / 2) - 1]"
]
| false | 0.040832 | 0.036754 | 1.110958 | [
"s148808970",
"s456156683"
]
|
u065578867 | p02552 | python | s494249773 | s979851067 | 32 | 28 | 9,140 | 9,156 | Accepted | Accepted | 12.5 | x = int(eval(input()))
if x == 1:
print((0))
else:
print((1))
| if int(eval(input())):
print((0))
else:
print((1)) | 5 | 4 | 65 | 47 | x = int(eval(input()))
if x == 1:
print((0))
else:
print((1))
| if int(eval(input())):
print((0))
else:
print((1))
| false | 20 | [
"-x = int(eval(input()))",
"-if x == 1:",
"+if int(eval(input())):"
]
| false | 0.044095 | 0.044821 | 0.983815 | [
"s494249773",
"s979851067"
]
|
u657913472 | p03662 | python | s473799287 | s567127728 | 1,082 | 761 | 69,012 | 34,508 | Accepted | Accepted | 29.67 | from scipy.sparse import*
f=lambda*z:list(map(int,input().split()))
n,=f()
c=[1]*~-n
print(('FSennunkeec'[sum(g>h for g,h in zip(*csgraph.dijkstra(csr_matrix((c,list(zip(*list(map(f,c))))),[n+1]*2),0,[1,n])))*2>=n::2])) | from scipy.sparse import*
n,*a=list(map(int,open(0).read().split()))
c=[1]*~-n
print(('FSennunkeec'[sum(g>h for g,h in zip(*csgraph.dijkstra(csr_matrix((c,(a[::2],a[1::2])),[n+1]*2),0,[1,n])))*2>=n::2])) | 5 | 4 | 209 | 198 | from scipy.sparse import *
f = lambda *z: list(map(int, input().split()))
(n,) = f()
c = [1] * ~-n
print(
(
"FSennunkeec"[
sum(
g > h
for g, h in zip(
*csgraph.dijkstra(
csr_matrix((c, list(zip(*list(map(f, c))))), [n + 1] * 2),
0,
[1, n],
)
)
)
* 2
>= n :: 2
]
)
)
| from scipy.sparse import *
n, *a = list(map(int, open(0).read().split()))
c = [1] * ~-n
print(
(
"FSennunkeec"[
sum(
g > h
for g, h in zip(
*csgraph.dijkstra(
csr_matrix((c, (a[::2], a[1::2])), [n + 1] * 2), 0, [1, n]
)
)
)
* 2
>= n :: 2
]
)
)
| false | 20 | [
"-f = lambda *z: list(map(int, input().split()))",
"-(n,) = f()",
"+n, *a = list(map(int, open(0).read().split()))",
"- csr_matrix((c, list(zip(*list(map(f, c))))), [n + 1] * 2),",
"- 0,",
"- [1, n],",
"+ csr_matrix((c, (a[::2], a[1::2])), [n + 1] * 2), 0, [1, n]"
]
| false | 0.498142 | 0.281034 | 1.772533 | [
"s473799287",
"s567127728"
]
|
u588341295 | p03309 | python | s460576348 | s812894443 | 993 | 526 | 81,648 | 81,648 | Accepted | Accepted | 47.03 | # -*- coding: utf-8 -*-
import sys
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 18
MOD = 10 ** 9 + 7
N = INT()
A = LIST()
def check(m):
sm = 0
for i, a in enumerate(A):
sm += abs(a - (m+i+1))
return sm
# 三分探索
low = -INF
hi = INF
while low+2 < hi:
m1 = (low*2+hi) // 3
m2 = (low+hi*2) // 3
res1 = check(m1)
res2 = check(m2)
# 今回は下に凸な関数なので値の小さい方に向かって狭めていく
if res1 <= res2:
hi = m2
else:
low = m1
ans = INF
for i in range(low, low+2):
ans = min(ans, check(i))
print(ans)
| # -*- coding: utf-8 -*-
import sys
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 18
MOD = 10 ** 9 + 7
N = INT()
A = LIST()
# bをmとした時の悲しさ値
def check(m):
sm = 0
for i, a in enumerate(A):
sm += abs(a - (m+i+1))
return sm
# 三分探索
low = -10**9
hi = 10**9
while low+2 < hi:
m1 = (low*2+hi) // 3
m2 = (low+hi*2) // 3
res1 = check(m1)
res2 = check(m2)
# 今回は下に凸な関数なので値の小さい方に向かって狭めていく
if res1 <= res2:
hi = m2
else:
low = m1
print((min(check(m1), check(m2))))
| 47 | 45 | 1,161 | 1,133 | # -*- coding: utf-8 -*-
import sys
def input():
return sys.stdin.readline().strip()
def list2d(a, b, c):
return [[c] * b for i in range(a)]
def list3d(a, b, c, d):
return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e):
return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1):
return int(-(-x // y))
def INT():
return int(eval(input()))
def MAP():
return list(map(int, input().split()))
def LIST(N=None):
return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes():
print("Yes")
def No():
print("No")
def YES():
print("YES")
def NO():
print("NO")
sys.setrecursionlimit(10**9)
INF = 10**18
MOD = 10**9 + 7
N = INT()
A = LIST()
def check(m):
sm = 0
for i, a in enumerate(A):
sm += abs(a - (m + i + 1))
return sm
# 三分探索
low = -INF
hi = INF
while low + 2 < hi:
m1 = (low * 2 + hi) // 3
m2 = (low + hi * 2) // 3
res1 = check(m1)
res2 = check(m2)
# 今回は下に凸な関数なので値の小さい方に向かって狭めていく
if res1 <= res2:
hi = m2
else:
low = m1
ans = INF
for i in range(low, low + 2):
ans = min(ans, check(i))
print(ans)
| # -*- coding: utf-8 -*-
import sys
def input():
return sys.stdin.readline().strip()
def list2d(a, b, c):
return [[c] * b for i in range(a)]
def list3d(a, b, c, d):
return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e):
return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1):
return int(-(-x // y))
def INT():
return int(eval(input()))
def MAP():
return list(map(int, input().split()))
def LIST(N=None):
return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes():
print("Yes")
def No():
print("No")
def YES():
print("YES")
def NO():
print("NO")
sys.setrecursionlimit(10**9)
INF = 10**18
MOD = 10**9 + 7
N = INT()
A = LIST()
# bをmとした時の悲しさ値
def check(m):
sm = 0
for i, a in enumerate(A):
sm += abs(a - (m + i + 1))
return sm
# 三分探索
low = -(10**9)
hi = 10**9
while low + 2 < hi:
m1 = (low * 2 + hi) // 3
m2 = (low + hi * 2) // 3
res1 = check(m1)
res2 = check(m2)
# 今回は下に凸な関数なので値の小さい方に向かって狭めていく
if res1 <= res2:
hi = m2
else:
low = m1
print((min(check(m1), check(m2))))
| false | 4.255319 | [
"-",
"-",
"+# bをmとした時の悲しさ値",
"-low = -INF",
"-hi = INF",
"+low = -(10**9)",
"+hi = 10**9",
"-ans = INF",
"-for i in range(low, low + 2):",
"- ans = min(ans, check(i))",
"-print(ans)",
"+print((min(check(m1), check(m2))))"
]
| false | 0.121991 | 0.035299 | 3.4559 | [
"s460576348",
"s812894443"
]
|
u137542041 | p03339 | python | s999220074 | s867419248 | 233 | 141 | 23,500 | 9,728 | Accepted | Accepted | 39.48 | N = int(eval(input()))
S = eval(input())
w_cnt = 0
e_cnt = 0
w_lst = []
e_lst = []
for s in S:
if s == 'W':
w_cnt += 1
else:
e_cnt += 1
w_lst.append(w_cnt)
e_lst.append(e_cnt)
ans = float('inf')
e_all = e_lst[-1]
for i in range(N):
if S[i] == 'W':
t = w_lst[i] - 1 + e_all - e_lst[i]
else:
t = w_lst[i] + e_all - e_lst[i]
ans = min(ans, t)
print(ans) | N = int(eval(input()))
S = eval(input())
e_all = S.count('E')
w_cnt = 0
e_cnt = 0
ans = float('inf')
for i in range(N):
if S[i] == 'W':
w_cnt += 1
ans = min(ans, w_cnt - 1 + e_all - e_cnt)
else:
e_cnt += 1
ans = min(ans, w_cnt + e_all - e_cnt)
print(ans)
| 31 | 17 | 437 | 302 | N = int(eval(input()))
S = eval(input())
w_cnt = 0
e_cnt = 0
w_lst = []
e_lst = []
for s in S:
if s == "W":
w_cnt += 1
else:
e_cnt += 1
w_lst.append(w_cnt)
e_lst.append(e_cnt)
ans = float("inf")
e_all = e_lst[-1]
for i in range(N):
if S[i] == "W":
t = w_lst[i] - 1 + e_all - e_lst[i]
else:
t = w_lst[i] + e_all - e_lst[i]
ans = min(ans, t)
print(ans)
| N = int(eval(input()))
S = eval(input())
e_all = S.count("E")
w_cnt = 0
e_cnt = 0
ans = float("inf")
for i in range(N):
if S[i] == "W":
w_cnt += 1
ans = min(ans, w_cnt - 1 + e_all - e_cnt)
else:
e_cnt += 1
ans = min(ans, w_cnt + e_all - e_cnt)
print(ans)
| false | 45.16129 | [
"+e_all = S.count(\"E\")",
"-w_lst = []",
"-e_lst = []",
"-for s in S:",
"- if s == \"W\":",
"+ans = float(\"inf\")",
"+for i in range(N):",
"+ if S[i] == \"W\":",
"+ ans = min(ans, w_cnt - 1 + e_all - e_cnt)",
"- w_lst.append(w_cnt)",
"- e_lst.append(e_cnt)",
"-ans = float(\"inf\")",
"-e_all = e_lst[-1]",
"-for i in range(N):",
"- if S[i] == \"W\":",
"- t = w_lst[i] - 1 + e_all - e_lst[i]",
"- else:",
"- t = w_lst[i] + e_all - e_lst[i]",
"- ans = min(ans, t)",
"+ ans = min(ans, w_cnt + e_all - e_cnt)"
]
| false | 0.12157 | 0.043561 | 2.790815 | [
"s999220074",
"s867419248"
]
|
u367130284 | p02873 | python | s456728430 | s645757947 | 399 | 306 | 30,108 | 8,224 | Accepted | Accepted | 23.31 | from itertools import*
s=eval(input())
x=[[k,len(list(v))]for k,v in groupby(s)]
ans=0
#print(x)
for i in range(len(x)):
try:
if x[i][0]=="<" and x[i+1][0]==">":
n=max(x[i][1],x[i+1][1])
m=min(x[i][1],x[i+1][1])
ans+=(n+1)*n//2+(m-1)*m//2
except:
break
if x[0][0]==">":
y=x[0][1]
ans+=y*(y+1)//2
if x[-1][0]=="<":
y=x[-1][1]
ans+=y*(y+1)//2
print(ans)
| from itertools import*
r=p=0
for k,g in groupby(eval(input())):
x=len(list(g))
r+=x*(x+1)//2
r-=min(x,p)*(k=='>')
p=x
print(r) | 23 | 8 | 447 | 143 | from itertools import *
s = eval(input())
x = [[k, len(list(v))] for k, v in groupby(s)]
ans = 0
# print(x)
for i in range(len(x)):
try:
if x[i][0] == "<" and x[i + 1][0] == ">":
n = max(x[i][1], x[i + 1][1])
m = min(x[i][1], x[i + 1][1])
ans += (n + 1) * n // 2 + (m - 1) * m // 2
except:
break
if x[0][0] == ">":
y = x[0][1]
ans += y * (y + 1) // 2
if x[-1][0] == "<":
y = x[-1][1]
ans += y * (y + 1) // 2
print(ans)
| from itertools import *
r = p = 0
for k, g in groupby(eval(input())):
x = len(list(g))
r += x * (x + 1) // 2
r -= min(x, p) * (k == ">")
p = x
print(r)
| false | 65.217391 | [
"-s = eval(input())",
"-x = [[k, len(list(v))] for k, v in groupby(s)]",
"-ans = 0",
"-# print(x)",
"-for i in range(len(x)):",
"- try:",
"- if x[i][0] == \"<\" and x[i + 1][0] == \">\":",
"- n = max(x[i][1], x[i + 1][1])",
"- m = min(x[i][1], x[i + 1][1])",
"- ans += (n + 1) * n // 2 + (m - 1) * m // 2",
"- except:",
"- break",
"-if x[0][0] == \">\":",
"- y = x[0][1]",
"- ans += y * (y + 1) // 2",
"-if x[-1][0] == \"<\":",
"- y = x[-1][1]",
"- ans += y * (y + 1) // 2",
"-print(ans)",
"+r = p = 0",
"+for k, g in groupby(eval(input())):",
"+ x = len(list(g))",
"+ r += x * (x + 1) // 2",
"+ r -= min(x, p) * (k == \">\")",
"+ p = x",
"+print(r)"
]
| false | 0.037484 | 0.100886 | 0.371552 | [
"s456728430",
"s645757947"
]
|
u341087021 | p03721 | python | s823549261 | s161677384 | 346 | 198 | 23,564 | 5,744 | Accepted | Accepted | 42.77 | import sys
import numpy as np
import collections
n,k = [int(x) for x in sys.stdin.readline().split()]
r = collections.defaultdict(int)
for i in range(n):
a, b = [int(x) for x in sys.stdin.readline().split()]
r[a] += b
d = sorted(r.items())
c = 0
for i,j in enumerate(d):
c += j[1]
if c >= k:
print((int(j[0])))
break | import sys
r = [0]*100000
n,k = [int(x) for x in sys.stdin.readline().split()]
for i in range(n):
a, b = [int(x) for x in sys.stdin.readline().split()]
r[a-1] += b
c = 0
for i,j in enumerate(r):
c += j
if c >= k:
print((i+1))
break | 15 | 12 | 336 | 248 | import sys
import numpy as np
import collections
n, k = [int(x) for x in sys.stdin.readline().split()]
r = collections.defaultdict(int)
for i in range(n):
a, b = [int(x) for x in sys.stdin.readline().split()]
r[a] += b
d = sorted(r.items())
c = 0
for i, j in enumerate(d):
c += j[1]
if c >= k:
print((int(j[0])))
break
| import sys
r = [0] * 100000
n, k = [int(x) for x in sys.stdin.readline().split()]
for i in range(n):
a, b = [int(x) for x in sys.stdin.readline().split()]
r[a - 1] += b
c = 0
for i, j in enumerate(r):
c += j
if c >= k:
print((i + 1))
break
| false | 20 | [
"-import numpy as np",
"-import collections",
"+r = [0] * 100000",
"-r = collections.defaultdict(int)",
"- r[a] += b",
"-d = sorted(r.items())",
"+ r[a - 1] += b",
"-for i, j in enumerate(d):",
"- c += j[1]",
"+for i, j in enumerate(r):",
"+ c += j",
"- print((int(j[0])))",
"+ print((i + 1))"
]
| false | 0.110262 | 0.049384 | 2.232727 | [
"s823549261",
"s161677384"
]
|
u785989355 | p03326 | python | s107343995 | s561692446 | 159 | 36 | 12,516 | 3,428 | Accepted | Accepted | 77.36 | import numpy as np
N,M = list(map(int,input().split()))
x = []
y = []
z = []
for i in range(N):
a,b,c = list(map(int,input().split()))
x.append(a)
y.append(b)
z.append(c)
x = np.array(x)
y = np.array(y)
z = np.array(z)
ppp = x+y+z
ppn = x+y-z
pnp = x-y+z
pnn = x-y-z
npp = -x+y+z
npn = -x+y-z
nnp = -x-y+z
nnn = -x-y-z
score=[]
score.append(sum(sorted(list(ppp))[::-1][:M]))
score.append(sum(sorted(list(ppn))[::-1][:M]))
score.append(sum(sorted(list(pnp))[::-1][:M]))
score.append(sum(sorted(list(pnn))[::-1][:M]))
score.append(sum(sorted(list(npp))[::-1][:M]))
score.append(sum(sorted(list(npn))[::-1][:M]))
score.append(sum(sorted(list(nnp))[::-1][:M]))
score.append(sum(sorted(list(nnn))[::-1][:M]))
print((max(score)))
| N,M=list(map(int,input().split()))
X = [[] for i in range(8)]
for i in range(N):
x,y,z=list(map(int,input().split()))
for i in range(8):
X[i].append(int(2*((i%2)-1/2))*x + int(2*(((i//2)%2)-1/2))*y + int(2*(((i//4)%2)-1/2))*z)
ans=0
for i in range(8):
X[i].sort()
X[i]=X[i][::-1]
ans=max(sum(X[i][:M]),ans)
print(ans) | 31 | 13 | 768 | 362 | import numpy as np
N, M = list(map(int, input().split()))
x = []
y = []
z = []
for i in range(N):
a, b, c = list(map(int, input().split()))
x.append(a)
y.append(b)
z.append(c)
x = np.array(x)
y = np.array(y)
z = np.array(z)
ppp = x + y + z
ppn = x + y - z
pnp = x - y + z
pnn = x - y - z
npp = -x + y + z
npn = -x + y - z
nnp = -x - y + z
nnn = -x - y - z
score = []
score.append(sum(sorted(list(ppp))[::-1][:M]))
score.append(sum(sorted(list(ppn))[::-1][:M]))
score.append(sum(sorted(list(pnp))[::-1][:M]))
score.append(sum(sorted(list(pnn))[::-1][:M]))
score.append(sum(sorted(list(npp))[::-1][:M]))
score.append(sum(sorted(list(npn))[::-1][:M]))
score.append(sum(sorted(list(nnp))[::-1][:M]))
score.append(sum(sorted(list(nnn))[::-1][:M]))
print((max(score)))
| N, M = list(map(int, input().split()))
X = [[] for i in range(8)]
for i in range(N):
x, y, z = list(map(int, input().split()))
for i in range(8):
X[i].append(
int(2 * ((i % 2) - 1 / 2)) * x
+ int(2 * (((i // 2) % 2) - 1 / 2)) * y
+ int(2 * (((i // 4) % 2) - 1 / 2)) * z
)
ans = 0
for i in range(8):
X[i].sort()
X[i] = X[i][::-1]
ans = max(sum(X[i][:M]), ans)
print(ans)
| false | 58.064516 | [
"-import numpy as np",
"-",
"-x = []",
"-y = []",
"-z = []",
"+X = [[] for i in range(8)]",
"- a, b, c = list(map(int, input().split()))",
"- x.append(a)",
"- y.append(b)",
"- z.append(c)",
"-x = np.array(x)",
"-y = np.array(y)",
"-z = np.array(z)",
"-ppp = x + y + z",
"-ppn = x + y - z",
"-pnp = x - y + z",
"-pnn = x - y - z",
"-npp = -x + y + z",
"-npn = -x + y - z",
"-nnp = -x - y + z",
"-nnn = -x - y - z",
"-score = []",
"-score.append(sum(sorted(list(ppp))[::-1][:M]))",
"-score.append(sum(sorted(list(ppn))[::-1][:M]))",
"-score.append(sum(sorted(list(pnp))[::-1][:M]))",
"-score.append(sum(sorted(list(pnn))[::-1][:M]))",
"-score.append(sum(sorted(list(npp))[::-1][:M]))",
"-score.append(sum(sorted(list(npn))[::-1][:M]))",
"-score.append(sum(sorted(list(nnp))[::-1][:M]))",
"-score.append(sum(sorted(list(nnn))[::-1][:M]))",
"-print((max(score)))",
"+ x, y, z = list(map(int, input().split()))",
"+ for i in range(8):",
"+ X[i].append(",
"+ int(2 * ((i % 2) - 1 / 2)) * x",
"+ + int(2 * (((i // 2) % 2) - 1 / 2)) * y",
"+ + int(2 * (((i // 4) % 2) - 1 / 2)) * z",
"+ )",
"+ans = 0",
"+for i in range(8):",
"+ X[i].sort()",
"+ X[i] = X[i][::-1]",
"+ ans = max(sum(X[i][:M]), ans)",
"+print(ans)"
]
| false | 0.007425 | 0.042702 | 0.173873 | [
"s107343995",
"s561692446"
]
|
u761529120 | p03854 | python | s778051197 | s965650988 | 46 | 23 | 3,316 | 6,516 | Accepted | Accepted | 50 | S = eval(input())
S = S[::-1]
word_list1 = "dream"
word_list2 = "dreamer"
word_list3 = "erase"
word_list4 = "eraser"
s = ""
ans = ""
word_list = [word_list1[::-1],word_list2[::-1],word_list3[::-1],word_list4[::-1]]
for i in S:
s += i
if s in word_list:
ans += s
s = ""
if S == ans:
print('YES')
else:
print('NO') | import re
S = eval(input())
if re.match('(dream|dreamer|erase|eraser)+$', S):
print('YES')
else:
print('NO') | 24 | 8 | 367 | 119 | S = eval(input())
S = S[::-1]
word_list1 = "dream"
word_list2 = "dreamer"
word_list3 = "erase"
word_list4 = "eraser"
s = ""
ans = ""
word_list = [word_list1[::-1], word_list2[::-1], word_list3[::-1], word_list4[::-1]]
for i in S:
s += i
if s in word_list:
ans += s
s = ""
if S == ans:
print("YES")
else:
print("NO")
| import re
S = eval(input())
if re.match("(dream|dreamer|erase|eraser)+$", S):
print("YES")
else:
print("NO")
| false | 66.666667 | [
"+import re",
"+",
"-S = S[::-1]",
"-word_list1 = \"dream\"",
"-word_list2 = \"dreamer\"",
"-word_list3 = \"erase\"",
"-word_list4 = \"eraser\"",
"-s = \"\"",
"-ans = \"\"",
"-word_list = [word_list1[::-1], word_list2[::-1], word_list3[::-1], word_list4[::-1]]",
"-for i in S:",
"- s += i",
"- if s in word_list:",
"- ans += s",
"- s = \"\"",
"-if S == ans:",
"+if re.match(\"(dream|dreamer|erase|eraser)+$\", S):"
]
| false | 0.055747 | 0.042538 | 1.310502 | [
"s778051197",
"s965650988"
]
|
u227082700 | p03666 | python | s592230079 | s858998382 | 221 | 184 | 3,060 | 3,060 | Accepted | Accepted | 16.74 | n,a,b,c,d=list(map(int,input().split()))
for i in range(n-1):
if i*c-(n-1-i)*d<=b-a<=i*d-(n-1-i)*c:print("YES");exit()
print("NO") | n,a,b,c,d=list(map(int,input().split()))
x=y=a
for i in range(1,n):
if (x+y)//2<b:
x+=c
y+=d
else:
x-=d
y-=c
if x<=b<=y:print('YES')
else:print('NO') | 4 | 11 | 129 | 173 | n, a, b, c, d = list(map(int, input().split()))
for i in range(n - 1):
if i * c - (n - 1 - i) * d <= b - a <= i * d - (n - 1 - i) * c:
print("YES")
exit()
print("NO")
| n, a, b, c, d = list(map(int, input().split()))
x = y = a
for i in range(1, n):
if (x + y) // 2 < b:
x += c
y += d
else:
x -= d
y -= c
if x <= b <= y:
print("YES")
else:
print("NO")
| false | 63.636364 | [
"-for i in range(n - 1):",
"- if i * c - (n - 1 - i) * d <= b - a <= i * d - (n - 1 - i) * c:",
"- print(\"YES\")",
"- exit()",
"-print(\"NO\")",
"+x = y = a",
"+for i in range(1, n):",
"+ if (x + y) // 2 < b:",
"+ x += c",
"+ y += d",
"+ else:",
"+ x -= d",
"+ y -= c",
"+if x <= b <= y:",
"+ print(\"YES\")",
"+else:",
"+ print(\"NO\")"
]
| false | 0.120514 | 0.078734 | 1.530634 | [
"s592230079",
"s858998382"
]
|
u690536347 | p03837 | python | s073136124 | s854183371 | 617 | 324 | 3,416 | 48,476 | Accepted | Accepted | 47.49 | n,m=list(map(int,input().split()))
inf=float("inf")
r=lambda n:list(range(n))
l=[[inf if i!=j else 0 for j in r(n)] for i in r(n)]
a,b,c=[None]*m,[None]*m,[None]*m
for i in r(m):
a[i],b[i],c[i]=list(map(int,input().split()))
a[i]-=1
b[i]-=1
l[a[i]][b[i]]=c[i]
l[b[i]][a[i]]=c[i]
for k in r(n):
for i in r(n):
for j in r(n):
l[i][j]=min(l[i][j],l[i][k]+l[k][j])
ans=m
for i in r(m):
f=False
for j in r(n):
if l[j][a[i]]+c[i]==l[j][b[i]]:
f=True
if f:ans-=1
print(ans) | n,m=list(map(int,input().split()))
l=[list(map(int,input().split())) for _ in range(m)]
d=[[float("inf")]*n for _ in range(n)]
for a,b,c in l:
d[a-1][b-1]=c
d[b-1][a-1]=c
for k in range(n):
for i in range(n):
for j in range(n):
if i==j:d[i][j]=0
d[i][j]=min(d[i][j],d[i][k]+d[k][j])
ans=m
for i,(a,b,c) in enumerate(l):
f=False
for s in range(n):
if d[s][a-1]+c==d[s][b-1]:
f=True
if f:ans-=1
print(ans) | 27 | 24 | 516 | 463 | n, m = list(map(int, input().split()))
inf = float("inf")
r = lambda n: list(range(n))
l = [[inf if i != j else 0 for j in r(n)] for i in r(n)]
a, b, c = [None] * m, [None] * m, [None] * m
for i in r(m):
a[i], b[i], c[i] = list(map(int, input().split()))
a[i] -= 1
b[i] -= 1
l[a[i]][b[i]] = c[i]
l[b[i]][a[i]] = c[i]
for k in r(n):
for i in r(n):
for j in r(n):
l[i][j] = min(l[i][j], l[i][k] + l[k][j])
ans = m
for i in r(m):
f = False
for j in r(n):
if l[j][a[i]] + c[i] == l[j][b[i]]:
f = True
if f:
ans -= 1
print(ans)
| n, m = list(map(int, input().split()))
l = [list(map(int, input().split())) for _ in range(m)]
d = [[float("inf")] * n for _ in range(n)]
for a, b, c in l:
d[a - 1][b - 1] = c
d[b - 1][a - 1] = c
for k in range(n):
for i in range(n):
for j in range(n):
if i == j:
d[i][j] = 0
d[i][j] = min(d[i][j], d[i][k] + d[k][j])
ans = m
for i, (a, b, c) in enumerate(l):
f = False
for s in range(n):
if d[s][a - 1] + c == d[s][b - 1]:
f = True
if f:
ans -= 1
print(ans)
| false | 11.111111 | [
"-inf = float(\"inf\")",
"-r = lambda n: list(range(n))",
"-l = [[inf if i != j else 0 for j in r(n)] for i in r(n)]",
"-a, b, c = [None] * m, [None] * m, [None] * m",
"-for i in r(m):",
"- a[i], b[i], c[i] = list(map(int, input().split()))",
"- a[i] -= 1",
"- b[i] -= 1",
"- l[a[i]][b[i]] = c[i]",
"- l[b[i]][a[i]] = c[i]",
"-for k in r(n):",
"- for i in r(n):",
"- for j in r(n):",
"- l[i][j] = min(l[i][j], l[i][k] + l[k][j])",
"+l = [list(map(int, input().split())) for _ in range(m)]",
"+d = [[float(\"inf\")] * n for _ in range(n)]",
"+for a, b, c in l:",
"+ d[a - 1][b - 1] = c",
"+ d[b - 1][a - 1] = c",
"+for k in range(n):",
"+ for i in range(n):",
"+ for j in range(n):",
"+ if i == j:",
"+ d[i][j] = 0",
"+ d[i][j] = min(d[i][j], d[i][k] + d[k][j])",
"-for i in r(m):",
"+for i, (a, b, c) in enumerate(l):",
"- for j in r(n):",
"- if l[j][a[i]] + c[i] == l[j][b[i]]:",
"+ for s in range(n):",
"+ if d[s][a - 1] + c == d[s][b - 1]:"
]
| false | 0.087683 | 0.035193 | 2.491481 | [
"s073136124",
"s854183371"
]
|
u940852449 | p03074 | python | s353194820 | s017203154 | 147 | 130 | 4,212 | 7,884 | Accepted | Accepted | 11.56 | # coding: utf-8
# Your code here!
N, K = [int(_) for _ in input().split()]
S = str(eval(input()))
Nums = []
now, cnt = 1, 0
for i in range(N):
if S[i] == str(now): cnt += 1
else:
Nums.append(cnt)
now = 1 - now
cnt = 1
if cnt != 0: Nums.append(cnt)
if len(Nums) % 2 == 0: Nums.append(0)
# add = 2 * K + 1
# ans = 0
# for i in range(0, len(Nums), 2):
# tmp = 0
# left = i
# right = min(i+add, len(Nums))
# j = left
# while j < right:
# tmp += Nums[j]
# j += 1
# ans = max(tmp, ans)
# print(ans)
#------------------------
add = 2 * K + 1
ans = 0
left = 0
right = 0
tmp = 0
for i in range(0, len(Nums), 2):
nextLeft = i
nextRight = min(i + add, len(Nums))
while nextLeft > left:
tmp -= Nums[left]
left += 1
while nextRight > right:
tmp += Nums[right]
right += 1
#print('left, right: ', left, right)
ans = max(tmp, ans)
print(ans)
| # coding: utf-8
# Your code here!
N, K = [int(_) for _ in input().split()]
S = str(eval(input()))
Nums = []
now, cnt = 1, 0
for i in range(N):
if S[i] == str(now): cnt += 1
else:
Nums.append(cnt)
now = 1 - now
cnt = 1
if cnt != 0: Nums.append(cnt)
if len(Nums) % 2 == 0: Nums.append(0)
# add = 2 * K + 1
# ans = 0
# for i in range(0, len(Nums), 2):
# tmp = 0
# left = i
# right = min(i+add, len(Nums))
# j = left
# while j < right:
# tmp += Nums[j]
# j += 1
# ans = max(tmp, ans)
# print(ans)
#------------------------
# add = 2 * K + 1
# ans = 0
# left = 0
# right = 0
# tmp = 0
# for i in range(0, len(Nums), 2):
# nextLeft = i
# nextRight = min(i + add, len(Nums))
# while nextLeft > left:
# tmp -= Nums[left]
# left += 1
# while nextRight > right:
# tmp += Nums[right]
# right += 1
# #print('left, right: ', left, right)
# ans = max(tmp, ans)
# print(ans)
#------------------------
#print(Nums)
add = 2 * K + 1
sums = [0 for _ in range(len(Nums) + 1)]
for i in range(len(Nums)):
sums[i+1] = sums[i] + Nums[i]
#print(sums)
ans = 0
for i in range(0, len(Nums), 2):
left = i
right = min(i+add, len(Nums))
tmp = sums[right] - sums[left]
ans = max(ans, tmp)
print(ans) | 49 | 64 | 1,012 | 1,389 | # coding: utf-8
# Your code here!
N, K = [int(_) for _ in input().split()]
S = str(eval(input()))
Nums = []
now, cnt = 1, 0
for i in range(N):
if S[i] == str(now):
cnt += 1
else:
Nums.append(cnt)
now = 1 - now
cnt = 1
if cnt != 0:
Nums.append(cnt)
if len(Nums) % 2 == 0:
Nums.append(0)
# add = 2 * K + 1
# ans = 0
# for i in range(0, len(Nums), 2):
# tmp = 0
# left = i
# right = min(i+add, len(Nums))
# j = left
# while j < right:
# tmp += Nums[j]
# j += 1
# ans = max(tmp, ans)
# print(ans)
# ------------------------
add = 2 * K + 1
ans = 0
left = 0
right = 0
tmp = 0
for i in range(0, len(Nums), 2):
nextLeft = i
nextRight = min(i + add, len(Nums))
while nextLeft > left:
tmp -= Nums[left]
left += 1
while nextRight > right:
tmp += Nums[right]
right += 1
# print('left, right: ', left, right)
ans = max(tmp, ans)
print(ans)
| # coding: utf-8
# Your code here!
N, K = [int(_) for _ in input().split()]
S = str(eval(input()))
Nums = []
now, cnt = 1, 0
for i in range(N):
if S[i] == str(now):
cnt += 1
else:
Nums.append(cnt)
now = 1 - now
cnt = 1
if cnt != 0:
Nums.append(cnt)
if len(Nums) % 2 == 0:
Nums.append(0)
# add = 2 * K + 1
# ans = 0
# for i in range(0, len(Nums), 2):
# tmp = 0
# left = i
# right = min(i+add, len(Nums))
# j = left
# while j < right:
# tmp += Nums[j]
# j += 1
# ans = max(tmp, ans)
# print(ans)
# ------------------------
# add = 2 * K + 1
# ans = 0
# left = 0
# right = 0
# tmp = 0
# for i in range(0, len(Nums), 2):
# nextLeft = i
# nextRight = min(i + add, len(Nums))
# while nextLeft > left:
# tmp -= Nums[left]
# left += 1
# while nextRight > right:
# tmp += Nums[right]
# right += 1
# #print('left, right: ', left, right)
# ans = max(tmp, ans)
# print(ans)
# ------------------------
# print(Nums)
add = 2 * K + 1
sums = [0 for _ in range(len(Nums) + 1)]
for i in range(len(Nums)):
sums[i + 1] = sums[i] + Nums[i]
# print(sums)
ans = 0
for i in range(0, len(Nums), 2):
left = i
right = min(i + add, len(Nums))
tmp = sums[right] - sums[left]
ans = max(ans, tmp)
print(ans)
| false | 23.4375 | [
"+# add = 2 * K + 1",
"+# ans = 0",
"+# left = 0",
"+# right = 0",
"+# tmp = 0",
"+# for i in range(0, len(Nums), 2):",
"+# nextLeft = i",
"+# nextRight = min(i + add, len(Nums))",
"+# while nextLeft > left:",
"+# tmp -= Nums[left]",
"+# left += 1",
"+# while nextRight > right:",
"+# tmp += Nums[right]",
"+# right += 1",
"+# #print('left, right: ', left, right)",
"+# ans = max(tmp, ans)",
"+# print(ans)",
"+# print(Nums)",
"+sums = [0 for _ in range(len(Nums) + 1)]",
"+for i in range(len(Nums)):",
"+ sums[i + 1] = sums[i] + Nums[i]",
"+# print(sums)",
"-left = 0",
"-right = 0",
"-tmp = 0",
"- nextLeft = i",
"- nextRight = min(i + add, len(Nums))",
"- while nextLeft > left:",
"- tmp -= Nums[left]",
"- left += 1",
"- while nextRight > right:",
"- tmp += Nums[right]",
"- right += 1",
"- # print('left, right: ', left, right)",
"- ans = max(tmp, ans)",
"+ left = i",
"+ right = min(i + add, len(Nums))",
"+ tmp = sums[right] - sums[left]",
"+ ans = max(ans, tmp)"
]
| false | 0.039745 | 0.05539 | 0.717559 | [
"s353194820",
"s017203154"
]
|
u935984175 | p03298 | python | s873587598 | s288619140 | 2,533 | 922 | 90,080 | 199,648 | Accepted | Accepted | 63.6 | from collections import defaultdict
from itertools import combinations
def solve():
N = int(eval(input()))
S = eval(input())
s1, s2 = S[:N], S[N:][::-1]
l_dict = defaultdict(int)
r_dict = defaultdict(int)
for i in range(N+1):
for red_idx in combinations(list(range(N)), i):
red, blue = '', ''
for j in range(N):
if j in red_idx:
red += s1[j]
else:
blue += s1[j]
l_dict[red+' '+blue] += 1
for i in range(N+1):
for red_idx in combinations(list(range(N)), i):
red, blue = '', ''
for j in range(N):
if j in red_idx:
red += s2[j]
else:
blue += s2[j]
r_dict[red+' '+blue] += 1
ans = sum(l_dict[key] * r_dict[key] for key in l_dict)
print(ans)
if __name__ == '__main__':
solve()
| import sys
from collections import defaultdict
from itertools import combinations
sys.setrecursionlimit(10 ** 7)
rl = sys.stdin.readline
def solve():
N = int(rl())
S = rl().rstrip()
s1, s2 = S[:N], S[N:][::-1]
l_dict = defaultdict(int)
r_dict = defaultdict(int)
for i in range(N + 1):
for red_idx in combinations(list(range(N)), i):
red, blue = '', ''
for j in range(N):
if j in red_idx:
red += s1[j]
else:
blue += s1[j]
l_dict[red + ' ' + blue] += 1
for i in range(N + 1):
for red_idx in combinations(list(range(N)), i):
red, blue = '', ''
for j in range(N):
if j in red_idx:
red += s2[j]
else:
blue += s2[j]
r_dict[red + ' ' + blue] += 1
ans = sum(l_dict[key] * r_dict[key] for key in l_dict)
print(ans)
if __name__ == '__main__':
solve()
| 36 | 40 | 969 | 1,055 | from collections import defaultdict
from itertools import combinations
def solve():
N = int(eval(input()))
S = eval(input())
s1, s2 = S[:N], S[N:][::-1]
l_dict = defaultdict(int)
r_dict = defaultdict(int)
for i in range(N + 1):
for red_idx in combinations(list(range(N)), i):
red, blue = "", ""
for j in range(N):
if j in red_idx:
red += s1[j]
else:
blue += s1[j]
l_dict[red + " " + blue] += 1
for i in range(N + 1):
for red_idx in combinations(list(range(N)), i):
red, blue = "", ""
for j in range(N):
if j in red_idx:
red += s2[j]
else:
blue += s2[j]
r_dict[red + " " + blue] += 1
ans = sum(l_dict[key] * r_dict[key] for key in l_dict)
print(ans)
if __name__ == "__main__":
solve()
| import sys
from collections import defaultdict
from itertools import combinations
sys.setrecursionlimit(10**7)
rl = sys.stdin.readline
def solve():
N = int(rl())
S = rl().rstrip()
s1, s2 = S[:N], S[N:][::-1]
l_dict = defaultdict(int)
r_dict = defaultdict(int)
for i in range(N + 1):
for red_idx in combinations(list(range(N)), i):
red, blue = "", ""
for j in range(N):
if j in red_idx:
red += s1[j]
else:
blue += s1[j]
l_dict[red + " " + blue] += 1
for i in range(N + 1):
for red_idx in combinations(list(range(N)), i):
red, blue = "", ""
for j in range(N):
if j in red_idx:
red += s2[j]
else:
blue += s2[j]
r_dict[red + " " + blue] += 1
ans = sum(l_dict[key] * r_dict[key] for key in l_dict)
print(ans)
if __name__ == "__main__":
solve()
| false | 10 | [
"+import sys",
"+sys.setrecursionlimit(10**7)",
"+rl = sys.stdin.readline",
"+",
"- N = int(eval(input()))",
"- S = eval(input())",
"+ N = int(rl())",
"+ S = rl().rstrip()"
]
| false | 0.04495 | 0.551646 | 0.081484 | [
"s873587598",
"s288619140"
]
|
u325956328 | p02732 | python | s620807004 | s470811911 | 514 | 378 | 26,780 | 26,780 | Accepted | Accepted | 26.46 | from collections import Counter
N = int(eval(input()))
A = list(map(int, input().split()))
def comb(x):
if x == 0:
return 0
if x == 1:
return 0
return x * (x - 1) // 2
d = Counter(A)
# print(d)
k = list(d.keys())
# print(k)
total = 0
for kk in k:
total += comb(d[kk])
# print(total)
for a in A:
res = total
res -= comb(d[a])
res += comb(d[a] - 1)
print(res) | from collections import Counter
N = int(eval(input()))
A = list(map(int, input().split()))
d = Counter(A)
k = list(d.keys())
# print(d, k)
def nC2(x):
return x * (x - 1) // 2
total = 0
for kk in k:
total += nC2(d[kk])
# print(total)
for a in A:
res = total
res -= d[a] - 1
print(res)
| 31 | 25 | 432 | 325 | from collections import Counter
N = int(eval(input()))
A = list(map(int, input().split()))
def comb(x):
if x == 0:
return 0
if x == 1:
return 0
return x * (x - 1) // 2
d = Counter(A)
# print(d)
k = list(d.keys())
# print(k)
total = 0
for kk in k:
total += comb(d[kk])
# print(total)
for a in A:
res = total
res -= comb(d[a])
res += comb(d[a] - 1)
print(res)
| from collections import Counter
N = int(eval(input()))
A = list(map(int, input().split()))
d = Counter(A)
k = list(d.keys())
# print(d, k)
def nC2(x):
return x * (x - 1) // 2
total = 0
for kk in k:
total += nC2(d[kk])
# print(total)
for a in A:
res = total
res -= d[a] - 1
print(res)
| false | 19.354839 | [
"-",
"-",
"-def comb(x):",
"- if x == 0:",
"- return 0",
"- if x == 1:",
"- return 0",
"+d = Counter(A)",
"+k = list(d.keys())",
"+# print(d, k)",
"+def nC2(x):",
"-d = Counter(A)",
"-# print(d)",
"-k = list(d.keys())",
"-# print(k)",
"- total += comb(d[kk])",
"+ total += nC2(d[kk])",
"- res -= comb(d[a])",
"- res += comb(d[a] - 1)",
"+ res -= d[a] - 1"
]
| false | 0.060133 | 0.035912 | 1.674477 | [
"s620807004",
"s470811911"
]
|
u777277984 | p02386 | python | s594020759 | s950090714 | 270 | 230 | 8,240 | 8,240 | Accepted | Accepted | 14.81 | class Dice:
def __init__(self):
self.side = {"top": 0, "front": 0, "right": 0, "left": 0, "back": 0, "bottom": 0}
# サイコロを東西南北、どちらか一方に転がした時、それぞれの面の変化
def roll(self, direction):
self.direction = direction
if self.direction == "N":
w = self.side["top"]
self.side["top"] = self.side["front"]
self.side["front"] = self.side["bottom"]
self.side["bottom"] = self.side["back"]
self.side["back"] = w
elif self.direction == "S":
w = self.side["top"]
self.side["top"] = self.side["back"]
self.side["back"] = self.side["bottom"]
self.side["bottom"] = self.side["front"]
self.side["front"] = w
elif self.direction == "E":
w = self.side["top"]
self.side["top"] = self.side["left"]
self.side["left"] = self.side["bottom"]
self.side["bottom"] = self.side["right"]
self.side["right"] = w
elif self.direction == "W":
w = self.side["top"]
self.side["top"] = self.side["right"]
self.side["right"] = self.side["bottom"]
self.side["bottom"] = self.side["left"]
self.side["left"] = w
# サイコロの目を作成
def create(self):
for s, n in zip(dice.side, input().split()):
dice.side[s] = int(n)
def simulation():
for line in a:
dir = random.sample("NSEW"*5, 20)
for direction in dir:
dice.roll(direction)
if dice.side == line:
return "No"
else:
a.append(dict(dice.side))
import random
n = int(eval(input()))
dice = Dice()
dice.create()
a = []; a.append(dict(dice.side))
for i in range(1, n):
dice.create()
judge = simulation()
if judge == "No":
print("No")
break
else:
print("Yes")
| class Dice:
def __init__(self):
self.side = {"top": 0, "front": 0, "right": 0, "left": 0, "back": 0, "bottom": 0}
# サイコロを東西南北、どちらか一方に転がした時、それぞれの面の変化
def roll(self, direction):
self.direction = direction
if self.direction == "N":
w = self.side["top"]
self.side["top"] = self.side["front"]
self.side["front"] = self.side["bottom"]
self.side["bottom"] = self.side["back"]
self.side["back"] = w
elif self.direction == "S":
w = self.side["top"]
self.side["top"] = self.side["back"]
self.side["back"] = self.side["bottom"]
self.side["bottom"] = self.side["front"]
self.side["front"] = w
elif self.direction == "E":
w = self.side["top"]
self.side["top"] = self.side["left"]
self.side["left"] = self.side["bottom"]
self.side["bottom"] = self.side["right"]
self.side["right"] = w
elif self.direction == "W":
w = self.side["top"]
self.side["top"] = self.side["right"]
self.side["right"] = self.side["bottom"]
self.side["bottom"] = self.side["left"]
self.side["left"] = w
# サイコロの目を作成
def create(self):
for s, n in zip(dice.side, input().split()):
dice.side[s] = int(n)
# ランダムに東西南北を出現し、シュミレーションする
def simulation():
for line in a:
dir = random.sample("NSEW"*5, 20) # サンプル数は２０個
for direction in dir:
dice.roll(direction)
# サイコロが同一なら、"NO"を返す。
if dice.side == line:
return "No"
else:
a.append(dict(dice.side)) # 同一のサイコロがないなら、比較候補のリストに追加する。
import random
n = int(eval(input()))
dice = Dice()
# 最初のサイコロの目を作成して、比較候補のリストに追加する。
dice.create()
a = []; a.append(dict(dice.side))
for i in range(1, n):
dice.create()
judge = simulation()
# 同一のサイコロがあったら、"No"を出力して、処理を終了する。
if judge == "No":
print("No")
break
# すべての比較候補と同一のサイコロがないなら、"Yes"を出力して、処理を終了する。
else:
print("Yes")
| 62 | 68 | 1,942 | 2,165 | class Dice:
def __init__(self):
self.side = {
"top": 0,
"front": 0,
"right": 0,
"left": 0,
"back": 0,
"bottom": 0,
}
# サイコロを東西南北、どちらか一方に転がした時、それぞれの面の変化
def roll(self, direction):
self.direction = direction
if self.direction == "N":
w = self.side["top"]
self.side["top"] = self.side["front"]
self.side["front"] = self.side["bottom"]
self.side["bottom"] = self.side["back"]
self.side["back"] = w
elif self.direction == "S":
w = self.side["top"]
self.side["top"] = self.side["back"]
self.side["back"] = self.side["bottom"]
self.side["bottom"] = self.side["front"]
self.side["front"] = w
elif self.direction == "E":
w = self.side["top"]
self.side["top"] = self.side["left"]
self.side["left"] = self.side["bottom"]
self.side["bottom"] = self.side["right"]
self.side["right"] = w
elif self.direction == "W":
w = self.side["top"]
self.side["top"] = self.side["right"]
self.side["right"] = self.side["bottom"]
self.side["bottom"] = self.side["left"]
self.side["left"] = w
# サイコロの目を作成
def create(self):
for s, n in zip(dice.side, input().split()):
dice.side[s] = int(n)
def simulation():
for line in a:
dir = random.sample("NSEW" * 5, 20)
for direction in dir:
dice.roll(direction)
if dice.side == line:
return "No"
else:
a.append(dict(dice.side))
import random
n = int(eval(input()))
dice = Dice()
dice.create()
a = []
a.append(dict(dice.side))
for i in range(1, n):
dice.create()
judge = simulation()
if judge == "No":
print("No")
break
else:
print("Yes")
| class Dice:
def __init__(self):
self.side = {
"top": 0,
"front": 0,
"right": 0,
"left": 0,
"back": 0,
"bottom": 0,
}
# サイコロを東西南北、どちらか一方に転がした時、それぞれの面の変化
def roll(self, direction):
self.direction = direction
if self.direction == "N":
w = self.side["top"]
self.side["top"] = self.side["front"]
self.side["front"] = self.side["bottom"]
self.side["bottom"] = self.side["back"]
self.side["back"] = w
elif self.direction == "S":
w = self.side["top"]
self.side["top"] = self.side["back"]
self.side["back"] = self.side["bottom"]
self.side["bottom"] = self.side["front"]
self.side["front"] = w
elif self.direction == "E":
w = self.side["top"]
self.side["top"] = self.side["left"]
self.side["left"] = self.side["bottom"]
self.side["bottom"] = self.side["right"]
self.side["right"] = w
elif self.direction == "W":
w = self.side["top"]
self.side["top"] = self.side["right"]
self.side["right"] = self.side["bottom"]
self.side["bottom"] = self.side["left"]
self.side["left"] = w
# サイコロの目を作成
def create(self):
for s, n in zip(dice.side, input().split()):
dice.side[s] = int(n)
# ランダムに東西南北を出現し、シュミレーションする
def simulation():
for line in a:
dir = random.sample("NSEW" * 5, 20) # サンプル数は２０個
for direction in dir:
dice.roll(direction)
# サイコロが同一なら、"NO"を返す。
if dice.side == line:
return "No"
else:
a.append(dict(dice.side)) # 同一のサイコロがないなら、比較候補のリストに追加する。
import random
n = int(eval(input()))
dice = Dice()
# 最初のサイコロの目を作成して、比較候補のリストに追加する。
dice.create()
a = []
a.append(dict(dice.side))
for i in range(1, n):
dice.create()
judge = simulation()
# 同一のサイコロがあったら、"No"を出力して、処理を終了する。
if judge == "No":
print("No")
break
# すべての比較候補と同一のサイコロがないなら、"Yes"を出力して、処理を終了する。
else:
print("Yes")
| false | 8.823529 | [
"+# ランダムに東西南北を出現し、シュミレーションする",
"- dir = random.sample(\"NSEW\" * 5, 20)",
"+ dir = random.sample(\"NSEW\" * 5, 20) # サンプル数は２０個",
"+ # サイコロが同一なら、\"NO\"を返す。",
"- a.append(dict(dice.side))",
"+ a.append(dict(dice.side)) # 同一のサイコロがないなら、比較候補のリストに追加する。",
"+# 最初のサイコロの目を作成して、比較候補のリストに追加する。",
"+ # 同一のサイコロがあったら、\"No\"を出力して、処理を終了する。",
"+# すべての比較候補と同一のサイコロがないなら、\"Yes\"を出力して、処理を終了する。"
]
| false | 0.042828 | 0.043792 | 0.977993 | [
"s594020759",
"s950090714"
]
|
u497952650 | p03103 | python | s705653755 | s364699771 | 601 | 401 | 29,116 | 84,152 | Accepted | Accepted | 33.28 | import numpy as np
N,M = list(map(int,input().split()))
AB = []
for i in range(N):
a,b = list(map(int,input().split()))
AB.append([a,b])
need = M
cost = 0
AB.sort()
for i in range(N):
if need - AB[i][1] >= 0:
need -= AB[i][1]
cost += AB[i][0]*AB[i][1]
else:
cost += AB[i][0]*need
break
print(cost) | N,M = list(map(int,input().split()))
C = []
for i in range(N):
C.append(tuple(map(int,input().split())))
C.sort()
tmp = M
ans = 0
for cost,num in C:
if tmp - num >= 0:##全部買う
tmp -= num
ans += num*cost
else:
ans += cost*tmp
break
print(ans) | 22 | 19 | 365 | 299 | import numpy as np
N, M = list(map(int, input().split()))
AB = []
for i in range(N):
a, b = list(map(int, input().split()))
AB.append([a, b])
need = M
cost = 0
AB.sort()
for i in range(N):
if need - AB[i][1] >= 0:
need -= AB[i][1]
cost += AB[i][0] * AB[i][1]
else:
cost += AB[i][0] * need
break
print(cost)
| N, M = list(map(int, input().split()))
C = []
for i in range(N):
C.append(tuple(map(int, input().split())))
C.sort()
tmp = M
ans = 0
for cost, num in C:
if tmp - num >= 0: ##全部買う
tmp -= num
ans += num * cost
else:
ans += cost * tmp
break
print(ans)
| false | 13.636364 | [
"-import numpy as np",
"-",
"-AB = []",
"+C = []",
"- a, b = list(map(int, input().split()))",
"- AB.append([a, b])",
"-need = M",
"-cost = 0",
"-AB.sort()",
"-for i in range(N):",
"- if need - AB[i][1] >= 0:",
"- need -= AB[i][1]",
"- cost += AB[i][0] * AB[i][1]",
"+ C.append(tuple(map(int, input().split())))",
"+C.sort()",
"+tmp = M",
"+ans = 0",
"+for cost, num in C:",
"+ if tmp - num >= 0: ##全部買う",
"+ tmp -= num",
"+ ans += num * cost",
"- cost += AB[i][0] * need",
"+ ans += cost * tmp",
"-print(cost)",
"+print(ans)"
]
| false | 0.042602 | 0.03963 | 1.074999 | [
"s705653755",
"s364699771"
]
|
u130900604 | p03137 | python | s369389349 | s301539392 | 114 | 104 | 13,960 | 13,968 | Accepted | Accepted | 8.77 | n,m=list(map(int,input().split()))
x=sorted(list(map(int,input().split())));#print(x)
if n>=m:
print((0))
exit(0)
else:
x_distance=[]
for i in range(m-1):
x_distance.append(x[i+1]-x[i])
x_distance.sort();print((sum(x_distance[:m-n])))
exit(0) | def mi():return list(map(int,input().split()))
n,m=mi()
x=sorted(list(mi()))
d=sorted([x[i+1]-x[i] for i in range(m-1)])
print((sum(d[:max(m-n,0)]))) | 12 | 5 | 260 | 145 | n, m = list(map(int, input().split()))
x = sorted(list(map(int, input().split())))
# print(x)
if n >= m:
print((0))
exit(0)
else:
x_distance = []
for i in range(m - 1):
x_distance.append(x[i + 1] - x[i])
x_distance.sort()
print((sum(x_distance[: m - n])))
exit(0)
| def mi():
return list(map(int, input().split()))
n, m = mi()
x = sorted(list(mi()))
d = sorted([x[i + 1] - x[i] for i in range(m - 1)])
print((sum(d[: max(m - n, 0)])))
| false | 58.333333 | [
"-n, m = list(map(int, input().split()))",
"-x = sorted(list(map(int, input().split())))",
"-# print(x)",
"-if n >= m:",
"- print((0))",
"- exit(0)",
"-else:",
"- x_distance = []",
"- for i in range(m - 1):",
"- x_distance.append(x[i + 1] - x[i])",
"- x_distance.sort()",
"- print((sum(x_distance[: m - n])))",
"- exit(0)",
"+def mi():",
"+ return list(map(int, input().split()))",
"+",
"+",
"+n, m = mi()",
"+x = sorted(list(mi()))",
"+d = sorted([x[i + 1] - x[i] for i in range(m - 1)])",
"+print((sum(d[: max(m - n, 0)])))"
]
| false | 0.086646 | 0.127898 | 0.677462 | [
"s369389349",
"s301539392"
]
|
u852690916 | p02558 | python | s662339460 | s975912935 | 280 | 252 | 76,656 | 78,788 | Accepted | Accepted | 10 | # でつoO(YOU PLAY WITH THE CARDS YOU'RE DEALT..)
from typing import Iterable
import sys
def main():
input = sys.stdin.readline
N, Q = list(map(int, input().split()))
uf = UnionFindTree(N)
for _ in range(Q):
t, u, v = list(map(int, input().split()))
if t == 0:
uf.union(u, v)
else:
print((1 if uf.same(u, v) else 0))
class UnionFindTree:
def __init__(self, n: int) -> None:
self.parent = [-1] * n
def find(self, x: int) -> int:
p = self.parent
while p[x] >= 0: x, p[x] = p[x], p[p[x]]
return x
def union(self, x: int, y: int) -> bool:
x, y, p = self.find(x), self.find(y), self.parent
if x == y: return False
if p[x] > p[y]: x, y = y, x
p[x], p[y] = p[x] + p[y], x
return True
def same(self, x: int, y: int) -> bool:
return self.find(x) == self.find(y)
def size(self, x: int) -> int:
return -self.parent[self.find(x)]
def same_all(self, indices: Iterable[int]) -> bool:
f, v = self.find, self.find(indices[0])
return all(f(i) == v for i in indices)
if __name__ == '__main__':
main()
| # でつoO(YOU PLAY WITH THE CARDS YOU'RE DEALT..)
from typing import Iterable
import sys
def main():
input = sys.stdin.readline
N, Q = list(map(int, input().split()))
uf = UnionFindTree(N)
ans = []
for _ in range(Q):
t, u, v = list(map(int, input().split()))
if t:
ans.append('1' if uf.same(u, v) else '0')
else:
uf.union(u, v)
print(('\n'.join(ans)))
class UnionFindTree:
__slots__ = ('parent')
def __init__(self, n: int) -> None:
self.parent = [-1] * n
def find(self, x: int) -> int:
p = self.parent
while p[x] >= 0: x, p[x] = p[x], p[p[x]]
return x
def union(self, x: int, y: int) -> bool:
x, y, p = self.find(x), self.find(y), self.parent
if x == y: return False
if p[x] > p[y]: x, y = y, x
p[x], p[y] = p[x] + p[y], x
return True
def same(self, x: int, y: int) -> bool:
return self.find(x) == self.find(y)
def size(self, x: int) -> int:
return -self.parent[self.find(x)]
def same_all(self, indices: Iterable[int]) -> bool:
f, v = self.find, self.find(indices[0])
return all(f(i) == v for i in indices)
if __name__ == '__main__':
main()
| 42 | 46 | 1,210 | 1,285 | # でつoO(YOU PLAY WITH THE CARDS YOU'RE DEALT..)
from typing import Iterable
import sys
def main():
input = sys.stdin.readline
N, Q = list(map(int, input().split()))
uf = UnionFindTree(N)
for _ in range(Q):
t, u, v = list(map(int, input().split()))
if t == 0:
uf.union(u, v)
else:
print((1 if uf.same(u, v) else 0))
class UnionFindTree:
def __init__(self, n: int) -> None:
self.parent = [-1] * n
def find(self, x: int) -> int:
p = self.parent
while p[x] >= 0:
x, p[x] = p[x], p[p[x]]
return x
def union(self, x: int, y: int) -> bool:
x, y, p = self.find(x), self.find(y), self.parent
if x == y:
return False
if p[x] > p[y]:
x, y = y, x
p[x], p[y] = p[x] + p[y], x
return True
def same(self, x: int, y: int) -> bool:
return self.find(x) == self.find(y)
def size(self, x: int) -> int:
return -self.parent[self.find(x)]
def same_all(self, indices: Iterable[int]) -> bool:
f, v = self.find, self.find(indices[0])
return all(f(i) == v for i in indices)
if __name__ == "__main__":
main()
| # でつoO(YOU PLAY WITH THE CARDS YOU'RE DEALT..)
from typing import Iterable
import sys
def main():
input = sys.stdin.readline
N, Q = list(map(int, input().split()))
uf = UnionFindTree(N)
ans = []
for _ in range(Q):
t, u, v = list(map(int, input().split()))
if t:
ans.append("1" if uf.same(u, v) else "0")
else:
uf.union(u, v)
print(("\n".join(ans)))
class UnionFindTree:
__slots__ = "parent"
def __init__(self, n: int) -> None:
self.parent = [-1] * n
def find(self, x: int) -> int:
p = self.parent
while p[x] >= 0:
x, p[x] = p[x], p[p[x]]
return x
def union(self, x: int, y: int) -> bool:
x, y, p = self.find(x), self.find(y), self.parent
if x == y:
return False
if p[x] > p[y]:
x, y = y, x
p[x], p[y] = p[x] + p[y], x
return True
def same(self, x: int, y: int) -> bool:
return self.find(x) == self.find(y)
def size(self, x: int) -> int:
return -self.parent[self.find(x)]
def same_all(self, indices: Iterable[int]) -> bool:
f, v = self.find, self.find(indices[0])
return all(f(i) == v for i in indices)
if __name__ == "__main__":
main()
| false | 8.695652 | [
"+ ans = []",
"- if t == 0:",
"+ if t:",
"+ ans.append(\"1\" if uf.same(u, v) else \"0\")",
"+ else:",
"- else:",
"- print((1 if uf.same(u, v) else 0))",
"+ print((\"\\n\".join(ans)))",
"+ __slots__ = \"parent\"",
"+"
]
| false | 0.052551 | 0.052146 | 1.007769 | [
"s662339460",
"s975912935"
]
|
u994988729 | p02911 | python | s018649303 | s999575361 | 255 | 167 | 4,680 | 11,876 | Accepted | Accepted | 34.51 | n,k,q=list(map(int,input().split()))
score=[0]*n
for _ in range(q):
a=int(eval(input()))
score[a-1]+=1
for i in score:
if q-i>=k:
print("No")
else:
print("Yes") | from collections import Counter
import sys
input = sys.stdin.buffer.readline
sys.setrecursionlimit(10 ** 7)
N, K, Q = list(map(int, input().split()))
A = [int(eval(input())) for _ in range(Q)]
c = Counter(A)
for i in range(1, N + 1):
if Q - c[i] >= K:
print("No")
else:
print("Yes")
| 12 | 14 | 193 | 310 | n, k, q = list(map(int, input().split()))
score = [0] * n
for _ in range(q):
a = int(eval(input()))
score[a - 1] += 1
for i in score:
if q - i >= k:
print("No")
else:
print("Yes")
| from collections import Counter
import sys
input = sys.stdin.buffer.readline
sys.setrecursionlimit(10**7)
N, K, Q = list(map(int, input().split()))
A = [int(eval(input())) for _ in range(Q)]
c = Counter(A)
for i in range(1, N + 1):
if Q - c[i] >= K:
print("No")
else:
print("Yes")
| false | 14.285714 | [
"-n, k, q = list(map(int, input().split()))",
"-score = [0] * n",
"-for _ in range(q):",
"- a = int(eval(input()))",
"- score[a - 1] += 1",
"-for i in score:",
"- if q - i >= k:",
"+from collections import Counter",
"+import sys",
"+",
"+input = sys.stdin.buffer.readline",
"+sys.setrecursionlimit(10**7)",
"+N, K, Q = list(map(int, input().split()))",
"+A = [int(eval(input())) for _ in range(Q)]",
"+c = Counter(A)",
"+for i in range(1, N + 1):",
"+ if Q - c[i] >= K:"
]
| false | 0.038052 | 0.045135 | 0.843079 | [
"s018649303",
"s999575361"
]
|
u596276291 | p03435 | python | s161289740 | s199452897 | 476 | 28 | 3,916 | 3,956 | Accepted | Accepted | 94.12 | from collections import defaultdict, Counter
from itertools import product, groupby, count, permutations, combinations
from math import pi, sqrt
from collections import deque
from bisect import bisect, bisect_left, bisect_right
from string import ascii_lowercase
from functools import lru_cache
import sys
sys.setrecursionlimit(10000)
INF = float("inf")
YES, Yes, yes, NO, No, no = "YES", "Yes", "yes", "NO", "No", "no"
def solve():
C = []
for _ in range(3):
C.append(list(map(int, input().split())))
for a1 in range(0, 101):
for a2 in range(0, 101):
for a3 in range(0, 101):
b1_ok = (C[0][0] - a1) == (C[1][0] - a2) == (C[2][0] - a3)
b2_ok = (C[0][1] - a1) == (C[1][1] - a2) == (C[2][1] - a3)
b3_ok = (C[0][2] - a1) == (C[1][2] - a2) == (C[2][2] - a3)
if b1_ok and b2_ok and b3_ok:
return Yes
return No
def main():
print((solve()))
if __name__ == '__main__':
main()
| #!/usr/bin/python3
from collections import defaultdict, Counter
from itertools import product, groupby, count, permutations, combinations
from math import pi, sqrt
from collections import deque
from bisect import bisect, bisect_left, bisect_right
from string import ascii_lowercase
from functools import lru_cache
import sys
sys.setrecursionlimit(10000)
INF = float("inf")
YES, Yes, yes, NO, No, no = "YES", "Yes", "yes", "NO", "No", "no"
dy4, dx4 = [0, 1, 0, -1], [1, 0, -1, 0]
def inside(y, x, H, W):
return 0 <= y < H and 0 <= x < W
def ok(a1, c):
b1 = c[0][0] - a1
b2 = c[0][1] - a1
b3 = c[0][2] - a1
if len(set([c[1][0] - b1, c[1][1] - b2, c[1][2] - b3])) != 1:
return False
if len(set([c[2][0] - b1, c[2][1] - b2, c[2][2] - b3])) != 1:
return False
return True
def main():
c = []
for _ in range(3):
c.append(list(map(int, input().split())))
for a1 in range(101):
if ok(a1, c):
print(Yes)
return
print(No)
if __name__ == '__main__':
main()
| 38 | 44 | 1,048 | 1,103 | from collections import defaultdict, Counter
from itertools import product, groupby, count, permutations, combinations
from math import pi, sqrt
from collections import deque
from bisect import bisect, bisect_left, bisect_right
from string import ascii_lowercase
from functools import lru_cache
import sys
sys.setrecursionlimit(10000)
INF = float("inf")
YES, Yes, yes, NO, No, no = "YES", "Yes", "yes", "NO", "No", "no"
def solve():
C = []
for _ in range(3):
C.append(list(map(int, input().split())))
for a1 in range(0, 101):
for a2 in range(0, 101):
for a3 in range(0, 101):
b1_ok = (C[0][0] - a1) == (C[1][0] - a2) == (C[2][0] - a3)
b2_ok = (C[0][1] - a1) == (C[1][1] - a2) == (C[2][1] - a3)
b3_ok = (C[0][2] - a1) == (C[1][2] - a2) == (C[2][2] - a3)
if b1_ok and b2_ok and b3_ok:
return Yes
return No
def main():
print((solve()))
if __name__ == "__main__":
main()
| #!/usr/bin/python3
from collections import defaultdict, Counter
from itertools import product, groupby, count, permutations, combinations
from math import pi, sqrt
from collections import deque
from bisect import bisect, bisect_left, bisect_right
from string import ascii_lowercase
from functools import lru_cache
import sys
sys.setrecursionlimit(10000)
INF = float("inf")
YES, Yes, yes, NO, No, no = "YES", "Yes", "yes", "NO", "No", "no"
dy4, dx4 = [0, 1, 0, -1], [1, 0, -1, 0]
def inside(y, x, H, W):
return 0 <= y < H and 0 <= x < W
def ok(a1, c):
b1 = c[0][0] - a1
b2 = c[0][1] - a1
b3 = c[0][2] - a1
if len(set([c[1][0] - b1, c[1][1] - b2, c[1][2] - b3])) != 1:
return False
if len(set([c[2][0] - b1, c[2][1] - b2, c[2][2] - b3])) != 1:
return False
return True
def main():
c = []
for _ in range(3):
c.append(list(map(int, input().split())))
for a1 in range(101):
if ok(a1, c):
print(Yes)
return
print(No)
if __name__ == "__main__":
main()
| false | 13.636364 | [
"+#!/usr/bin/python3",
"+dy4, dx4 = [0, 1, 0, -1], [1, 0, -1, 0]",
"-def solve():",
"- C = []",
"- for _ in range(3):",
"- C.append(list(map(int, input().split())))",
"- for a1 in range(0, 101):",
"- for a2 in range(0, 101):",
"- for a3 in range(0, 101):",
"- b1_ok = (C[0][0] - a1) == (C[1][0] - a2) == (C[2][0] - a3)",
"- b2_ok = (C[0][1] - a1) == (C[1][1] - a2) == (C[2][1] - a3)",
"- b3_ok = (C[0][2] - a1) == (C[1][2] - a2) == (C[2][2] - a3)",
"- if b1_ok and b2_ok and b3_ok:",
"- return Yes",
"- return No",
"+def inside(y, x, H, W):",
"+ return 0 <= y < H and 0 <= x < W",
"+",
"+",
"+def ok(a1, c):",
"+ b1 = c[0][0] - a1",
"+ b2 = c[0][1] - a1",
"+ b3 = c[0][2] - a1",
"+ if len(set([c[1][0] - b1, c[1][1] - b2, c[1][2] - b3])) != 1:",
"+ return False",
"+ if len(set([c[2][0] - b1, c[2][1] - b2, c[2][2] - b3])) != 1:",
"+ return False",
"+ return True",
"- print((solve()))",
"+ c = []",
"+ for _ in range(3):",
"+ c.append(list(map(int, input().split())))",
"+ for a1 in range(101):",
"+ if ok(a1, c):",
"+ print(Yes)",
"+ return",
"+ print(No)"
]
| false | 1.282453 | 0.036224 | 35.403383 | [
"s161289740",
"s199452897"
]
|
u545368057 | p03014 | python | s825552522 | s917175200 | 934 | 594 | 103,128 | 205,684 | Accepted | Accepted | 36.4 | H,W = list(map(int,input().split()))
S = [eval(input()) for i in range(H)]
### その1
"""
# 4方向の累積和をとって計算する
Rs = [[0]*W for i in range(H)]
Ls = [[0]*W for i in range(H)]
Ds = [[0]*W for i in range(H)]
Us = [[0]*W for i in range(H)]
for i in range(H):
tmp = 0
# 順方向(左にどれだけ伸びてるか)
for j in range(W):
if S[i][j] == '#':
tmp = 0
else:
tmp += 1
Ls[i][j] = tmp
tmp = 0
# 逆方向(右にどれだけ伸びてるか)
for j in reversed(range(W)):
if S[i][j] == '#':
tmp = 0
else:
tmp += 1
Rs[i][j] = tmp
# 行列転置 順番逆にするだけ
for j in range(W):
tmp = 0
# 順方向 上にどれだけ伸びているか
for i in range(H):
if S[i][j] == '#':
tmp = 0
else:
tmp += 1
Us[i][j] = tmp
tmp = 0
# 順方向 下にどれだけ伸びているか
for i in reversed(range(H)):
if S[i][j] == '#':
tmp = 0
else:
tmp += 1
Ds[i][j] = tmp
ans = 0
for i in range(H):
for j in range(W):
if S[i][j] == '#':
continue
# 上下左右に伸びた数を重なっている部分引く
tmp = Rs[i][j] + Ls[i][j] + Ds[i][j] + Us[i][j] - 3
ans = max(ans, tmp)
print(ans)
"""
# その2
"""
左・上からゴリゴリ攻めていくパターン
一回通ったかどうかのフラグが必要
"""
cnt = [[0] * (W+1) for i in range(H+1)]
# 横
for i in range(H):
done = [False] * (W+1)
for j in range(W):
l = 0
if done[j]: continue
if S[i][j] == ".":
while j+l < W:
if S[i][j+l] == ".":
l += 1
else:
break
for k in range(j,j+l):
cnt[i][k] += l
done[k] = True
# 縦
for j in range(W):
done = [False] * (H+1)
for i in range(H):
l = 0
if done[i]: continue
if S[i][j] == ".":
while i+l < H:
if S[i+l][j] == ".":
l += 1
else:
break
for k in range(i,i+l):
cnt[k][j] += l
done[k] = True
ans = 0
for i in range(H):
for j in range(W):
ans = max(ans,cnt[i][j])
print((ans-1)) | H,W = list(map(int, input().split()))
fs = []
for i in range(H):
fs.append(eval(input()))
lefts = [[0]*W for i in range(H)]
rights = [[0]*W for i in range(H)]
for i in range(H):
for j in range(W):
if fs[i][j] == "#":
lefts[i][j] = 0
if fs[i][j] == ".":
if j == 0:
lefts[i][j] = 1
else:
lefts[i][j] = lefts[i][j-1] + 1
jr = W - j - 1
if fs[i][jr] == "#":
rights[i][jr] = 0
else:
if jr == W-1:
rights[i][jr] = 1
else:
rights[i][jr] = rights[i][jr+1] + 1
ups = [[0]*W for i in range(H)]
downs = [[0]*W for i in range(H)]
for j in range(W):
for i in range(H):
if fs[i][j] == "#":
ups[i][j] = 0
else:
if i == 0:
ups[i][j] = 1
else:
ups[i][j] = ups[i-1][j] + 1
ir = H - i - 1
if fs[ir][j] == "#":
downs[ir][j] = 0
else:
if ir == H-1:
downs[ir][j] = 1
else:
downs[ir][j] = downs[ir+1][j] + 1
# for l in lefts:
# print(*l)
# print("-----------")
# for r in rights:
# print(*r)
# print("updown")
# for l in ups:
# print(*l)
# print("-----------")
# for r in downs:
# print(*r)
ans = 0
for i in range(H):
for j in range(W):
x = lefts[i][j] + rights[i][j] + ups[i][j] + downs[i][j]
# print(i,j,lefts[i][j] ,rights[i][j] ,ups[i][j] ,downs[i][j])
ans = max(x,ans)
print((ans-3)) | 103 | 64 | 2,221 | 1,626 | H, W = list(map(int, input().split()))
S = [eval(input()) for i in range(H)]
### その1
"""
# 4方向の累積和をとって計算する
Rs = [[0]*W for i in range(H)]
Ls = [[0]*W for i in range(H)]
Ds = [[0]*W for i in range(H)]
Us = [[0]*W for i in range(H)]
for i in range(H):
tmp = 0
# 順方向(左にどれだけ伸びてるか)
for j in range(W):
if S[i][j] == '#':
tmp = 0
else:
tmp += 1
Ls[i][j] = tmp
tmp = 0
# 逆方向(右にどれだけ伸びてるか)
for j in reversed(range(W)):
if S[i][j] == '#':
tmp = 0
else:
tmp += 1
Rs[i][j] = tmp
# 行列転置 順番逆にするだけ
for j in range(W):
tmp = 0
# 順方向 上にどれだけ伸びているか
for i in range(H):
if S[i][j] == '#':
tmp = 0
else:
tmp += 1
Us[i][j] = tmp
tmp = 0
# 順方向 下にどれだけ伸びているか
for i in reversed(range(H)):
if S[i][j] == '#':
tmp = 0
else:
tmp += 1
Ds[i][j] = tmp
ans = 0
for i in range(H):
for j in range(W):
if S[i][j] == '#':
continue
# 上下左右に伸びた数を重なっている部分引く
tmp = Rs[i][j] + Ls[i][j] + Ds[i][j] + Us[i][j] - 3
ans = max(ans, tmp)
print(ans)
"""
# その2
"""
左・上からゴリゴリ攻めていくパターン
一回通ったかどうかのフラグが必要
"""
cnt = [[0] * (W + 1) for i in range(H + 1)]
# 横
for i in range(H):
done = [False] * (W + 1)
for j in range(W):
l = 0
if done[j]:
continue
if S[i][j] == ".":
while j + l < W:
if S[i][j + l] == ".":
l += 1
else:
break
for k in range(j, j + l):
cnt[i][k] += l
done[k] = True
# 縦
for j in range(W):
done = [False] * (H + 1)
for i in range(H):
l = 0
if done[i]:
continue
if S[i][j] == ".":
while i + l < H:
if S[i + l][j] == ".":
l += 1
else:
break
for k in range(i, i + l):
cnt[k][j] += l
done[k] = True
ans = 0
for i in range(H):
for j in range(W):
ans = max(ans, cnt[i][j])
print((ans - 1))
| H, W = list(map(int, input().split()))
fs = []
for i in range(H):
fs.append(eval(input()))
lefts = [[0] * W for i in range(H)]
rights = [[0] * W for i in range(H)]
for i in range(H):
for j in range(W):
if fs[i][j] == "#":
lefts[i][j] = 0
if fs[i][j] == ".":
if j == 0:
lefts[i][j] = 1
else:
lefts[i][j] = lefts[i][j - 1] + 1
jr = W - j - 1
if fs[i][jr] == "#":
rights[i][jr] = 0
else:
if jr == W - 1:
rights[i][jr] = 1
else:
rights[i][jr] = rights[i][jr + 1] + 1
ups = [[0] * W for i in range(H)]
downs = [[0] * W for i in range(H)]
for j in range(W):
for i in range(H):
if fs[i][j] == "#":
ups[i][j] = 0
else:
if i == 0:
ups[i][j] = 1
else:
ups[i][j] = ups[i - 1][j] + 1
ir = H - i - 1
if fs[ir][j] == "#":
downs[ir][j] = 0
else:
if ir == H - 1:
downs[ir][j] = 1
else:
downs[ir][j] = downs[ir + 1][j] + 1
# for l in lefts:
# print(*l)
# print("-----------")
# for r in rights:
# print(*r)
# print("updown")
# for l in ups:
# print(*l)
# print("-----------")
# for r in downs:
# print(*r)
ans = 0
for i in range(H):
for j in range(W):
x = lefts[i][j] + rights[i][j] + ups[i][j] + downs[i][j]
# print(i,j,lefts[i][j] ,rights[i][j] ,ups[i][j] ,downs[i][j])
ans = max(x, ans)
print((ans - 3))
| false | 37.864078 | [
"-S = [eval(input()) for i in range(H)]",
"-### その1",
"-\"\"\"",
"-# 4方向の累積和をとって計算する",
"-Rs = [[0]*W for i in range(H)]",
"-Ls = [[0]*W for i in range(H)]",
"-Ds = [[0]*W for i in range(H)]",
"-Us = [[0]*W for i in range(H)]",
"+fs = []",
"- tmp = 0",
"- # 順方向(左にどれだけ伸びてるか)",
"+ fs.append(eval(input()))",
"+lefts = [[0] * W for i in range(H)]",
"+rights = [[0] * W for i in range(H)]",
"+for i in range(H):",
"- if S[i][j] == '#':",
"- tmp = 0",
"+ if fs[i][j] == \"#\":",
"+ lefts[i][j] = 0",
"+ if fs[i][j] == \".\":",
"+ if j == 0:",
"+ lefts[i][j] = 1",
"+ else:",
"+ lefts[i][j] = lefts[i][j - 1] + 1",
"+ jr = W - j - 1",
"+ if fs[i][jr] == \"#\":",
"+ rights[i][jr] = 0",
"- tmp += 1",
"- Ls[i][j] = tmp",
"- tmp = 0",
"- # 逆方向(右にどれだけ伸びてるか)",
"- for j in reversed(range(W)):",
"- if S[i][j] == '#':",
"- tmp = 0",
"+ if jr == W - 1:",
"+ rights[i][jr] = 1",
"+ else:",
"+ rights[i][jr] = rights[i][jr + 1] + 1",
"+ups = [[0] * W for i in range(H)]",
"+downs = [[0] * W for i in range(H)]",
"+for j in range(W):",
"+ for i in range(H):",
"+ if fs[i][j] == \"#\":",
"+ ups[i][j] = 0",
"- tmp += 1",
"- Rs[i][j] = tmp",
"-# 行列転置 順番逆にするだけ",
"-for j in range(W):",
"- tmp = 0",
"- # 順方向 上にどれだけ伸びているか",
"- for i in range(H):",
"- if S[i][j] == '#':",
"- tmp = 0",
"+ if i == 0:",
"+ ups[i][j] = 1",
"+ else:",
"+ ups[i][j] = ups[i - 1][j] + 1",
"+ ir = H - i - 1",
"+ if fs[ir][j] == \"#\":",
"+ downs[ir][j] = 0",
"- tmp += 1",
"- Us[i][j] = tmp",
"- tmp = 0",
"- # 順方向 下にどれだけ伸びているか",
"- for i in reversed(range(H)):",
"- if S[i][j] == '#':",
"- tmp = 0",
"- else:",
"- tmp += 1",
"- Ds[i][j] = tmp",
"+ if ir == H - 1:",
"+ downs[ir][j] = 1",
"+ else:",
"+ downs[ir][j] = downs[ir + 1][j] + 1",
"+# for l in lefts:",
"+# print(*l)",
"+# for r in rights:",
"+# print(*r)",
"+# print(\"updown\")",
"+# for l in ups:",
"+# print(*l)",
"+# for r in downs:",
"+# print(*r)",
"- if S[i][j] == '#':",
"- continue",
"- # 上下左右に伸びた数を重なっている部分引く",
"- tmp = Rs[i][j] + Ls[i][j] + Ds[i][j] + Us[i][j] - 3",
"- ans = max(ans, tmp)",
"-print(ans)",
"-\"\"\"",
"-# その2",
"-\"\"\"",
"-左・上からゴリゴリ攻めていくパターン",
"-一回通ったかどうかのフラグが必要",
"-\"\"\"",
"-cnt = [[0] * (W + 1) for i in range(H + 1)]",
"-# 横",
"-for i in range(H):",
"- done = [False] * (W + 1)",
"- for j in range(W):",
"- l = 0",
"- if done[j]:",
"- continue",
"- if S[i][j] == \".\":",
"- while j + l < W:",
"- if S[i][j + l] == \".\":",
"- l += 1",
"- else:",
"- break",
"- for k in range(j, j + l):",
"- cnt[i][k] += l",
"- done[k] = True",
"-# 縦",
"-for j in range(W):",
"- done = [False] * (H + 1)",
"- for i in range(H):",
"- l = 0",
"- if done[i]:",
"- continue",
"- if S[i][j] == \".\":",
"- while i + l < H:",
"- if S[i + l][j] == \".\":",
"- l += 1",
"- else:",
"- break",
"- for k in range(i, i + l):",
"- cnt[k][j] += l",
"- done[k] = True",
"-ans = 0",
"-for i in range(H):",
"- for j in range(W):",
"- ans = max(ans, cnt[i][j])",
"-print((ans - 1))",
"+ x = lefts[i][j] + rights[i][j] + ups[i][j] + downs[i][j]",
"+ # print(i,j,lefts[i][j] ,rights[i][j] ,ups[i][j] ,downs[i][j])",
"+ ans = max(x, ans)",
"+print((ans - 3))"
]
| false | 0.046588 | 0.036263 | 1.284718 | [
"s825552522",
"s917175200"
]
|
u426534722 | p02275 | python | s547614274 | s539454792 | 3,160 | 2,420 | 234,252 | 224,376 | Accepted | Accepted | 23.42 | n = int(eval(input()))
A = [int(i) for i in input().split()]
B = [0] * n
k = max(A)
C = [0] * (k + 1)
for i in range(0, n):
C[A[i]] += 1
for i in range(1, k + 1):
C[i] += C[i - 1]
for i in range(n - 1, -1, -1):
C[A[i]] -= 1
B[C[A[i]]] = A[i]
print((*B)) | n = int(eval(input()))
def CountingSort(A, B, k):
C = [0] * (k + 1)
for j in range(n):
C[A[j]] += 1
C[0] -= 1
for i in range(1, k + 1):
C[i] += C[i - 1]
for j in range(n - 1, -1, -1):
B[C[A[j]]] = A[j]
C[A[j]] -= 1
A = list(map(int, input().split()))
B = [0] * n
CountingSort(A, B, max(A))
print((*B))
| 13 | 16 | 273 | 362 | n = int(eval(input()))
A = [int(i) for i in input().split()]
B = [0] * n
k = max(A)
C = [0] * (k + 1)
for i in range(0, n):
C[A[i]] += 1
for i in range(1, k + 1):
C[i] += C[i - 1]
for i in range(n - 1, -1, -1):
C[A[i]] -= 1
B[C[A[i]]] = A[i]
print((*B))
| n = int(eval(input()))
def CountingSort(A, B, k):
C = [0] * (k + 1)
for j in range(n):
C[A[j]] += 1
C[0] -= 1
for i in range(1, k + 1):
C[i] += C[i - 1]
for j in range(n - 1, -1, -1):
B[C[A[j]]] = A[j]
C[A[j]] -= 1
A = list(map(int, input().split()))
B = [0] * n
CountingSort(A, B, max(A))
print((*B))
| false | 18.75 | [
"-A = [int(i) for i in input().split()]",
"+",
"+",
"+def CountingSort(A, B, k):",
"+ C = [0] * (k + 1)",
"+ for j in range(n):",
"+ C[A[j]] += 1",
"+ C[0] -= 1",
"+ for i in range(1, k + 1):",
"+ C[i] += C[i - 1]",
"+ for j in range(n - 1, -1, -1):",
"+ B[C[A[j]]] = A[j]",
"+ C[A[j]] -= 1",
"+",
"+",
"+A = list(map(int, input().split()))",
"-k = max(A)",
"-C = [0] * (k + 1)",
"-for i in range(0, n):",
"- C[A[i]] += 1",
"-for i in range(1, k + 1):",
"- C[i] += C[i - 1]",
"-for i in range(n - 1, -1, -1):",
"- C[A[i]] -= 1",
"- B[C[A[i]]] = A[i]",
"+CountingSort(A, B, max(A))"
]
| false | 0.033243 | 0.032946 | 1.009039 | [
"s547614274",
"s539454792"
]
|
u780962115 | p03329 | python | s919707956 | s180034016 | 1,393 | 1,218 | 3,992 | 4,724 | Accepted | Accepted | 12.56 | lists=[]
emptylists=[]
numbers=int(eval(input()))
for nums in range(numbers+3):
if nums<6:
lists.append(int(nums))
elif nums==6 or nums==36 or nums==216 or nums==1296 or nums==7776 or nums==46656:
lists.append(1)
elif nums==9 or nums==81 or nums==729 or nums==6561 or nums==59049:
lists.append(1)
else:
power6=0
power9=0
for k in range(7):
if 6**(k)< nums <6**(k+1):
power6=k
break
for j in range(6):
if 9**(j) <nums< 9**(j+1):
power9=j
break
add=min(min(lists[nums-6**(k)]+1 for k in range(0,power6+1)),min(lists[nums-9**(j)]+1 for j in range(0,power9+1)))
lists.append(add)
print((lists[numbers]))
| #strange bank
n=int(eval(input()))
dp=[10**10 for i in range(200000)]
dp[0]=0
for i in range(1,100001):
for j in range(9):
num=3**j
if i>=6**j and dp[i-6**j]+1<dp[i]:
dp[i]=dp[i-6**j]+1
if i>=9**j and dp[i-9**j]+1<dp[i]:
dp[i]=dp[i-9**j]+1
print((dp[n])) | 30 | 12 | 851 | 309 | lists = []
emptylists = []
numbers = int(eval(input()))
for nums in range(numbers + 3):
if nums < 6:
lists.append(int(nums))
elif (
nums == 6
or nums == 36
or nums == 216
or nums == 1296
or nums == 7776
or nums == 46656
):
lists.append(1)
elif nums == 9 or nums == 81 or nums == 729 or nums == 6561 or nums == 59049:
lists.append(1)
else:
power6 = 0
power9 = 0
for k in range(7):
if 6 ** (k) < nums < 6 ** (k + 1):
power6 = k
break
for j in range(6):
if 9 ** (j) < nums < 9 ** (j + 1):
power9 = j
break
add = min(
min(lists[nums - 6 ** (k)] + 1 for k in range(0, power6 + 1)),
min(lists[nums - 9 ** (j)] + 1 for j in range(0, power9 + 1)),
)
lists.append(add)
print((lists[numbers]))
| # strange bank
n = int(eval(input()))
dp = [10**10 for i in range(200000)]
dp[0] = 0
for i in range(1, 100001):
for j in range(9):
num = 3**j
if i >= 6 ** j and dp[i - 6**j] + 1 < dp[i]:
dp[i] = dp[i - 6**j] + 1
if i >= 9 ** j and dp[i - 9**j] + 1 < dp[i]:
dp[i] = dp[i - 9**j] + 1
print((dp[n]))
| false | 60 | [
"-lists = []",
"-emptylists = []",
"-numbers = int(eval(input()))",
"-for nums in range(numbers + 3):",
"- if nums < 6:",
"- lists.append(int(nums))",
"- elif (",
"- nums == 6",
"- or nums == 36",
"- or nums == 216",
"- or nums == 1296",
"- or nums == 7776",
"- or nums == 46656",
"- ):",
"- lists.append(1)",
"- elif nums == 9 or nums == 81 or nums == 729 or nums == 6561 or nums == 59049:",
"- lists.append(1)",
"- else:",
"- power6 = 0",
"- power9 = 0",
"- for k in range(7):",
"- if 6 ** (k) < nums < 6 ** (k + 1):",
"- power6 = k",
"- break",
"- for j in range(6):",
"- if 9 ** (j) < nums < 9 ** (j + 1):",
"- power9 = j",
"- break",
"- add = min(",
"- min(lists[nums - 6 ** (k)] + 1 for k in range(0, power6 + 1)),",
"- min(lists[nums - 9 ** (j)] + 1 for j in range(0, power9 + 1)),",
"- )",
"- lists.append(add)",
"-print((lists[numbers]))",
"+# strange bank",
"+n = int(eval(input()))",
"+dp = [10**10 for i in range(200000)]",
"+dp[0] = 0",
"+for i in range(1, 100001):",
"+ for j in range(9):",
"+ num = 3**j",
"+ if i >= 6 ** j and dp[i - 6**j] + 1 < dp[i]:",
"+ dp[i] = dp[i - 6**j] + 1",
"+ if i >= 9 ** j and dp[i - 9**j] + 1 < dp[i]:",
"+ dp[i] = dp[i - 9**j] + 1",
"+print((dp[n]))"
]
| false | 0.257829 | 2.069663 | 0.124575 | [
"s919707956",
"s180034016"
]
|
u608088992 | p03038 | python | s046549815 | s550623083 | 399 | 287 | 24,272 | 27,048 | Accepted | Accepted | 28.07 | import sys, math, collections, heapq, itertools
F = sys.stdin
def single_input(): return F.readline().strip("\n")
def line_input(): return F.readline().strip("\n").split()
def gcd(a, b):
a, b = max(a, b), min(a, b)
while a % b > 0: a, b = b, a % b
return b
def solve():
N, M = list(map(int, line_input()))
A = [int(a) for a in line_input()]
change = [None] * M
for i in range(M):
b, c = list(map(int, line_input()))
change[i] = [c, b]
A.sort()
change.sort(reverse = True)
sum = 0
index = 0
for c, b in change:
bleft = b
while bleft > 0:
if c > A[index]:
sum += c
index += 1
bleft -= 1
if index == N: break
else: break
if index == N: break
if index < N:
for i in range(index, N):
sum += A[i]
print(sum)
return 0
if __name__ == "__main__":
solve() | import sys
from operator import itemgetter
def solve():
input = sys.stdin.readline
N, M = list(map(int, input().split()))
A = [int(a) for a in input().split()]
A.sort()
C = [[int(i) for i in input().split()] for _ in range(M)]
C.sort(key=itemgetter(1), reverse = True)
counter = 0
for b, c in C:
end = False
for j in range(b):
if counter > N - 1:
end = True
break
if A[counter] < c:
A[counter] = c
counter += 1
else:
end = True
break
if end: break
print((sum(A)))
return 0
if __name__ == "__main__":
solve() | 41 | 30 | 994 | 740 | import sys, math, collections, heapq, itertools
F = sys.stdin
def single_input():
return F.readline().strip("\n")
def line_input():
return F.readline().strip("\n").split()
def gcd(a, b):
a, b = max(a, b), min(a, b)
while a % b > 0:
a, b = b, a % b
return b
def solve():
N, M = list(map(int, line_input()))
A = [int(a) for a in line_input()]
change = [None] * M
for i in range(M):
b, c = list(map(int, line_input()))
change[i] = [c, b]
A.sort()
change.sort(reverse=True)
sum = 0
index = 0
for c, b in change:
bleft = b
while bleft > 0:
if c > A[index]:
sum += c
index += 1
bleft -= 1
if index == N:
break
else:
break
if index == N:
break
if index < N:
for i in range(index, N):
sum += A[i]
print(sum)
return 0
if __name__ == "__main__":
solve()
| import sys
from operator import itemgetter
def solve():
input = sys.stdin.readline
N, M = list(map(int, input().split()))
A = [int(a) for a in input().split()]
A.sort()
C = [[int(i) for i in input().split()] for _ in range(M)]
C.sort(key=itemgetter(1), reverse=True)
counter = 0
for b, c in C:
end = False
for j in range(b):
if counter > N - 1:
end = True
break
if A[counter] < c:
A[counter] = c
counter += 1
else:
end = True
break
if end:
break
print((sum(A)))
return 0
if __name__ == "__main__":
solve()
| false | 26.829268 | [
"-import sys, math, collections, heapq, itertools",
"-",
"-F = sys.stdin",
"-",
"-",
"-def single_input():",
"- return F.readline().strip(\"\\n\")",
"-",
"-",
"-def line_input():",
"- return F.readline().strip(\"\\n\").split()",
"-",
"-",
"-def gcd(a, b):",
"- a, b = max(a, b), min(a, b)",
"- while a % b > 0:",
"- a, b = b, a % b",
"- return b",
"+import sys",
"+from operator import itemgetter",
"- N, M = list(map(int, line_input()))",
"- A = [int(a) for a in line_input()]",
"- change = [None] * M",
"- for i in range(M):",
"- b, c = list(map(int, line_input()))",
"- change[i] = [c, b]",
"+ input = sys.stdin.readline",
"+ N, M = list(map(int, input().split()))",
"+ A = [int(a) for a in input().split()]",
"- change.sort(reverse=True)",
"- sum = 0",
"- index = 0",
"- for c, b in change:",
"- bleft = b",
"- while bleft > 0:",
"- if c > A[index]:",
"- sum += c",
"- index += 1",
"- bleft -= 1",
"- if index == N:",
"- break",
"+ C = [[int(i) for i in input().split()] for _ in range(M)]",
"+ C.sort(key=itemgetter(1), reverse=True)",
"+ counter = 0",
"+ for b, c in C:",
"+ end = False",
"+ for j in range(b):",
"+ if counter > N - 1:",
"+ end = True",
"+ break",
"+ if A[counter] < c:",
"+ A[counter] = c",
"+ counter += 1",
"+ end = True",
"- if index == N:",
"+ if end:",
"- if index < N:",
"- for i in range(index, N):",
"- sum += A[i]",
"- print(sum)",
"+ print((sum(A)))"
]
| false | 0.04865 | 0.087914 | 0.553374 | [
"s046549815",
"s550623083"
]
|
u459752408 | p02952 | python | s728777214 | s141250775 | 66 | 58 | 3,064 | 2,940 | Accepted | Accepted | 12.12 | N=int(eval(input()))
ans=0
for i in range (1,N+1):
if len(str(i))%2==1:
ans +=1
ans=int(ans)
print(ans) | N = int(eval(input()))
cnt=0
for i in range(1,N+1):
a = len(str(i))
if a%2==1:
cnt +=1
print(cnt)
| 7 | 7 | 113 | 106 | N = int(eval(input()))
ans = 0
for i in range(1, N + 1):
if len(str(i)) % 2 == 1:
ans += 1
ans = int(ans)
print(ans)
| N = int(eval(input()))
cnt = 0
for i in range(1, N + 1):
a = len(str(i))
if a % 2 == 1:
cnt += 1
print(cnt)
| false | 0 | [
"-ans = 0",
"+cnt = 0",
"- if len(str(i)) % 2 == 1:",
"- ans += 1",
"-ans = int(ans)",
"-print(ans)",
"+ a = len(str(i))",
"+ if a % 2 == 1:",
"+ cnt += 1",
"+print(cnt)"
]
| false | 0.052512 | 0.007579 | 6.928281 | [
"s728777214",
"s141250775"
]
|
u169350228 | p02702 | python | s238270139 | s671616080 | 234 | 97 | 28,796 | 79,480 | Accepted | Accepted | 58.55 | import numpy as np
s = list(map(int,eval(input())))
n = len(s)
ans = 0
mod = 2019
past = s[n-1]
ima = 0
d = dict()
d[s[n-1]] = 1
now = 10
for i in range(1,n):
ima = (past+s[n-i-1]*now)%mod
if ima == 0:
ans += 1
if ima in d:
d[ima] += 1
else:
d[ima] = 1
past = ima
now = (now*10)%mod
for i in list(d.values()):
ans += i*(i-1)//2
print(ans)
| import math
#import numpy as np
import queue
from collections import deque,defaultdict
import heapq
from sys import stdin,setrecursionlimit
#from scipy.sparse.csgraph import dijkstra
#from scipy.sparse import csr_matrix
ipt = stdin.readline
setrecursionlimit(10**7)
def main():
s = list(map(int,eval(input())))[::-1]
d = defaultdict(int)
ans = 0
ni = 0
mod = 2019
d[0] = 1
n10 = 1
for i in s:
ni = (ni+i*n10)%mod
d[ni] += 1
n10 = (n10*10)%mod
for i in list(d.values()):
ans += i*(i-1)//2
print(ans)
return
if __name__ == '__main__':
main()
| 25 | 31 | 405 | 641 | import numpy as np
s = list(map(int, eval(input())))
n = len(s)
ans = 0
mod = 2019
past = s[n - 1]
ima = 0
d = dict()
d[s[n - 1]] = 1
now = 10
for i in range(1, n):
ima = (past + s[n - i - 1] * now) % mod
if ima == 0:
ans += 1
if ima in d:
d[ima] += 1
else:
d[ima] = 1
past = ima
now = (now * 10) % mod
for i in list(d.values()):
ans += i * (i - 1) // 2
print(ans)
| import math
# import numpy as np
import queue
from collections import deque, defaultdict
import heapq
from sys import stdin, setrecursionlimit
# from scipy.sparse.csgraph import dijkstra
# from scipy.sparse import csr_matrix
ipt = stdin.readline
setrecursionlimit(10**7)
def main():
s = list(map(int, eval(input())))[::-1]
d = defaultdict(int)
ans = 0
ni = 0
mod = 2019
d[0] = 1
n10 = 1
for i in s:
ni = (ni + i * n10) % mod
d[ni] += 1
n10 = (n10 * 10) % mod
for i in list(d.values()):
ans += i * (i - 1) // 2
print(ans)
return
if __name__ == "__main__":
main()
| false | 19.354839 | [
"-import numpy as np",
"+import math",
"-s = list(map(int, eval(input())))",
"-n = len(s)",
"-ans = 0",
"-mod = 2019",
"-past = s[n - 1]",
"-ima = 0",
"-d = dict()",
"-d[s[n - 1]] = 1",
"-now = 10",
"-for i in range(1, n):",
"- ima = (past + s[n - i - 1] * now) % mod",
"- if ima == 0:",
"- ans += 1",
"- if ima in d:",
"- d[ima] += 1",
"- else:",
"- d[ima] = 1",
"- past = ima",
"- now = (now * 10) % mod",
"-for i in list(d.values()):",
"- ans += i * (i - 1) // 2",
"-print(ans)",
"+# import numpy as np",
"+import queue",
"+from collections import deque, defaultdict",
"+import heapq",
"+from sys import stdin, setrecursionlimit",
"+",
"+# from scipy.sparse.csgraph import dijkstra",
"+# from scipy.sparse import csr_matrix",
"+ipt = stdin.readline",
"+setrecursionlimit(10**7)",
"+",
"+",
"+def main():",
"+ s = list(map(int, eval(input())))[::-1]",
"+ d = defaultdict(int)",
"+ ans = 0",
"+ ni = 0",
"+ mod = 2019",
"+ d[0] = 1",
"+ n10 = 1",
"+ for i in s:",
"+ ni = (ni + i * n10) % mod",
"+ d[ni] += 1",
"+ n10 = (n10 * 10) % mod",
"+ for i in list(d.values()):",
"+ ans += i * (i - 1) // 2",
"+ print(ans)",
"+ return",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ main()"
]
| false | 0.03783 | 0.073572 | 0.514185 | [
"s238270139",
"s671616080"
]
|
u480138356 | p03045 | python | s351393210 | s653061182 | 734 | 668 | 32,884 | 20,468 | Accepted | Accepted | 8.99 | class Node:
def __init__(self, val):
self.num = val
self.val = val
self.is_parent = True
self.parent = None
def root(node):
depth = 0
while node.parent != None:
node = node.parent
depth += 1
return node, depth
N, M = list(map(int, input().split()))
roots = [Node(i) for i in range(N)]
count = N
for i in range(M):
x, y, z = list(map(int, input().split()))
x = roots[x-1]
y = roots[y-1]
if x.is_parent and y.is_parent:
y.is_parent = False
y.parent = x
count -= 1
else:
root_x, depth_x = root(x)
root_y, depth_y = root(y)
if root_x != root_y:
if depth_x >= depth_y:
root_y.is_parent = False
root_y.parent = root_x
count -= 1
else:
root_x.is_parent = False
root_x.parent = root_y
count -= 1
print(count)
| class Node:
def __init__(self):
self.is_parent = True
self.parent = None
def root(node):
depth = 0
while node.parent != None:
node = node.parent
depth += 1
return node, depth
N, M = list(map(int, input().split()))
roots = [Node() for i in range(N)]
count = N
for i in range(M):
x, y, z = list(map(int, input().split()))
x = roots[x-1]
y = roots[y-1]
if x.is_parent and y.is_parent:
y.is_parent = False
y.parent = x
count -= 1
else:
root_x, depth_x = root(x)
root_y, depth_y = root(y)
if root_x != root_y:
if depth_x >= depth_y:
root_y.is_parent = False
root_y.parent = root_x
count -= 1
else:
root_x.is_parent = False
root_x.parent = root_y
count -= 1
print(count)
| 41 | 39 | 998 | 944 | class Node:
def __init__(self, val):
self.num = val
self.val = val
self.is_parent = True
self.parent = None
def root(node):
depth = 0
while node.parent != None:
node = node.parent
depth += 1
return node, depth
N, M = list(map(int, input().split()))
roots = [Node(i) for i in range(N)]
count = N
for i in range(M):
x, y, z = list(map(int, input().split()))
x = roots[x - 1]
y = roots[y - 1]
if x.is_parent and y.is_parent:
y.is_parent = False
y.parent = x
count -= 1
else:
root_x, depth_x = root(x)
root_y, depth_y = root(y)
if root_x != root_y:
if depth_x >= depth_y:
root_y.is_parent = False
root_y.parent = root_x
count -= 1
else:
root_x.is_parent = False
root_x.parent = root_y
count -= 1
print(count)
| class Node:
def __init__(self):
self.is_parent = True
self.parent = None
def root(node):
depth = 0
while node.parent != None:
node = node.parent
depth += 1
return node, depth
N, M = list(map(int, input().split()))
roots = [Node() for i in range(N)]
count = N
for i in range(M):
x, y, z = list(map(int, input().split()))
x = roots[x - 1]
y = roots[y - 1]
if x.is_parent and y.is_parent:
y.is_parent = False
y.parent = x
count -= 1
else:
root_x, depth_x = root(x)
root_y, depth_y = root(y)
if root_x != root_y:
if depth_x >= depth_y:
root_y.is_parent = False
root_y.parent = root_x
count -= 1
else:
root_x.is_parent = False
root_x.parent = root_y
count -= 1
print(count)
| false | 4.878049 | [
"- def __init__(self, val):",
"- self.num = val",
"- self.val = val",
"+ def __init__(self):",
"-roots = [Node(i) for i in range(N)]",
"+roots = [Node() for i in range(N)]"
]
| false | 0.127611 | 0.20762 | 0.614636 | [
"s351393210",
"s653061182"
]
|
u773265208 | p02959 | python | s673407417 | s688633800 | 173 | 160 | 19,244 | 19,156 | Accepted | Accepted | 7.51 | import math
n = int(eval(input()))
a = list(map(int,input().split()))
b = list(map(int,input().split()))
ans = 0
for i in reversed(list(range(n))):
if a[i+1] - b[i] <= 0:
ans += a[i+1]
b[i] -= a[i+1]
a[i+1] = 0
if a[i] - b[i] <= 0:
ans += a[i]
b[i] -= a[i]
a[i] = 0
else:
ans += b[i]
a[i] -= b[i]
b[i] = 0
else:
ans += b[i]
a[i+1] -= b[i]
b[i] = 0
print(ans) | n = int(eval(input()))
a = list(map(int,input().split()))
b = list(map(int,input().split()))
ans = 0
for i in range(n):
if a[i] >= b[i]:
ans += b[i]
else:
ans += a[i]
if a[i+1] < b[i] - a[i]:
ans += a[i+1]
a[i+1] = 0
else:
ans += b[i] - a[i]
a[i+1] -= b[i] - a[i]
print(ans)
| 27 | 18 | 412 | 310 | import math
n = int(eval(input()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
ans = 0
for i in reversed(list(range(n))):
if a[i + 1] - b[i] <= 0:
ans += a[i + 1]
b[i] -= a[i + 1]
a[i + 1] = 0
if a[i] - b[i] <= 0:
ans += a[i]
b[i] -= a[i]
a[i] = 0
else:
ans += b[i]
a[i] -= b[i]
b[i] = 0
else:
ans += b[i]
a[i + 1] -= b[i]
b[i] = 0
print(ans)
| n = int(eval(input()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
ans = 0
for i in range(n):
if a[i] >= b[i]:
ans += b[i]
else:
ans += a[i]
if a[i + 1] < b[i] - a[i]:
ans += a[i + 1]
a[i + 1] = 0
else:
ans += b[i] - a[i]
a[i + 1] -= b[i] - a[i]
print(ans)
| false | 33.333333 | [
"-import math",
"-",
"-for i in reversed(list(range(n))):",
"- if a[i + 1] - b[i] <= 0:",
"- ans += a[i + 1]",
"- b[i] -= a[i + 1]",
"- a[i + 1] = 0",
"- if a[i] - b[i] <= 0:",
"- ans += a[i]",
"- b[i] -= a[i]",
"- a[i] = 0",
"+for i in range(n):",
"+ if a[i] >= b[i]:",
"+ ans += b[i]",
"+ else:",
"+ ans += a[i]",
"+ if a[i + 1] < b[i] - a[i]:",
"+ ans += a[i + 1]",
"+ a[i + 1] = 0",
"- ans += b[i]",
"- a[i] -= b[i]",
"- b[i] = 0",
"- else:",
"- ans += b[i]",
"- a[i + 1] -= b[i]",
"- b[i] = 0",
"+ ans += b[i] - a[i]",
"+ a[i + 1] -= b[i] - a[i]"
]
| false | 0.11868 | 0.047594 | 2.493603 | [
"s673407417",
"s688633800"
]
|
u606045429 | p02608 | python | s522138700 | s566776717 | 482 | 439 | 9,228 | 11,972 | Accepted | Accepted | 8.92 | N = int(eval(input()))
ans = [0] * (N + 1)
for x in range(1, 105):
for y in range(1, 105):
for z in range(1, 105):
v = x * x + y * y + z * z + x * y + y * z + z * x
if v <= N:
ans[v] += 1
for i in range(1, N + 1):
print((ans[i])) | from collections import Counter
N = int(eval(input()))
C = Counter(
x * x + y * y + z * z + x * y + y * z + z * x
for x in range(1, 105) for y in range(1, 105) for z in range(1, 105)
)
for i in range(1, N + 1):
print((C[i])) | 12 | 11 | 290 | 241 | N = int(eval(input()))
ans = [0] * (N + 1)
for x in range(1, 105):
for y in range(1, 105):
for z in range(1, 105):
v = x * x + y * y + z * z + x * y + y * z + z * x
if v <= N:
ans[v] += 1
for i in range(1, N + 1):
print((ans[i]))
| from collections import Counter
N = int(eval(input()))
C = Counter(
x * x + y * y + z * z + x * y + y * z + z * x
for x in range(1, 105)
for y in range(1, 105)
for z in range(1, 105)
)
for i in range(1, N + 1):
print((C[i]))
| false | 8.333333 | [
"+from collections import Counter",
"+",
"-ans = [0] * (N + 1)",
"-for x in range(1, 105):",
"- for y in range(1, 105):",
"- for z in range(1, 105):",
"- v = x * x + y * y + z * z + x * y + y * z + z * x",
"- if v <= N:",
"- ans[v] += 1",
"+C = Counter(",
"+ x * x + y * y + z * z + x * y + y * z + z * x",
"+ for x in range(1, 105)",
"+ for y in range(1, 105)",
"+ for z in range(1, 105)",
"+)",
"- print((ans[i]))",
"+ print((C[i]))"
]
| false | 1.049898 | 0.997202 | 1.052844 | [
"s522138700",
"s566776717"
]
|
u347640436 | p03855 | python | s083025752 | s638650074 | 1,036 | 895 | 52,716 | 41,188 | Accepted | Accepted | 13.61 | from sys import stdin
def find(parent, i):
if parent[i] == i:
return i
parent[i] = find(parent, parent[i])
return parent[i]
def unite(parent, i, j):
i = find(parent, i)
j = find(parent, j)
if i == j:
return
parent[i] = j
n, k, l = list(map(int, stdin.readline().split()))
roads = list(range(n))
rails = list(range(n))
for i in range(k):
p, q = list(map(int, stdin.readline().split()))
unite(roads, p - 1, q - 1)
for i in range(l):
p, q = list(map(int, stdin.readline().split()))
unite(rails, p - 1, q - 1)
d = {}
for i in range(n):
t = (find(roads, i), find(rails, i))
if t in d:
d[t] += 1
else:
d[t] = 1
print((*[d[(find(roads, i), find(rails, i))] for i in range(n)]))
| from sys import stdin
def main():
def find(parent, i):
t = parent[i]
if t == -1:
return i
t = find(parent, t)
parent[i] = t
return t
def unite(parent, i, j):
i = find(parent, i)
j = find(parent, j)
if i == j:
return
parent[i] = j
from builtins import int, map, range
readline = stdin.readline
n, k, l = list(map(int, readline().split()))
roads = [-1] * n
rails = [-1] * n
for i in range(k):
p, q = list(map(int, readline().split()))
unite(roads, p - 1, q - 1)
for i in range(l):
p, q = list(map(int, readline().split()))
unite(rails, p - 1, q - 1)
d = {}
for i in range(n):
t = (find(roads, i), find(rails, i))
if t in d:
d[t] += 1
else:
d[t] = 1
print((*[d[(find(roads, i), find(rails, i))] for i in range(n)]))
main()
| 37 | 45 | 739 | 866 | from sys import stdin
def find(parent, i):
if parent[i] == i:
return i
parent[i] = find(parent, parent[i])
return parent[i]
def unite(parent, i, j):
i = find(parent, i)
j = find(parent, j)
if i == j:
return
parent[i] = j
n, k, l = list(map(int, stdin.readline().split()))
roads = list(range(n))
rails = list(range(n))
for i in range(k):
p, q = list(map(int, stdin.readline().split()))
unite(roads, p - 1, q - 1)
for i in range(l):
p, q = list(map(int, stdin.readline().split()))
unite(rails, p - 1, q - 1)
d = {}
for i in range(n):
t = (find(roads, i), find(rails, i))
if t in d:
d[t] += 1
else:
d[t] = 1
print((*[d[(find(roads, i), find(rails, i))] for i in range(n)]))
| from sys import stdin
def main():
def find(parent, i):
t = parent[i]
if t == -1:
return i
t = find(parent, t)
parent[i] = t
return t
def unite(parent, i, j):
i = find(parent, i)
j = find(parent, j)
if i == j:
return
parent[i] = j
from builtins import int, map, range
readline = stdin.readline
n, k, l = list(map(int, readline().split()))
roads = [-1] * n
rails = [-1] * n
for i in range(k):
p, q = list(map(int, readline().split()))
unite(roads, p - 1, q - 1)
for i in range(l):
p, q = list(map(int, readline().split()))
unite(rails, p - 1, q - 1)
d = {}
for i in range(n):
t = (find(roads, i), find(rails, i))
if t in d:
d[t] += 1
else:
d[t] = 1
print((*[d[(find(roads, i), find(rails, i))] for i in range(n)]))
main()
| false | 17.777778 | [
"-def find(parent, i):",
"- if parent[i] == i:",
"- return i",
"- parent[i] = find(parent, parent[i])",
"- return parent[i]",
"+def main():",
"+ def find(parent, i):",
"+ t = parent[i]",
"+ if t == -1:",
"+ return i",
"+ t = find(parent, t)",
"+ parent[i] = t",
"+ return t",
"+",
"+ def unite(parent, i, j):",
"+ i = find(parent, i)",
"+ j = find(parent, j)",
"+ if i == j:",
"+ return",
"+ parent[i] = j",
"+",
"+ from builtins import int, map, range",
"+",
"+ readline = stdin.readline",
"+ n, k, l = list(map(int, readline().split()))",
"+ roads = [-1] * n",
"+ rails = [-1] * n",
"+ for i in range(k):",
"+ p, q = list(map(int, readline().split()))",
"+ unite(roads, p - 1, q - 1)",
"+ for i in range(l):",
"+ p, q = list(map(int, readline().split()))",
"+ unite(rails, p - 1, q - 1)",
"+ d = {}",
"+ for i in range(n):",
"+ t = (find(roads, i), find(rails, i))",
"+ if t in d:",
"+ d[t] += 1",
"+ else:",
"+ d[t] = 1",
"+ print((*[d[(find(roads, i), find(rails, i))] for i in range(n)]))",
"-def unite(parent, i, j):",
"- i = find(parent, i)",
"- j = find(parent, j)",
"- if i == j:",
"- return",
"- parent[i] = j",
"-",
"-",
"-n, k, l = list(map(int, stdin.readline().split()))",
"-roads = list(range(n))",
"-rails = list(range(n))",
"-for i in range(k):",
"- p, q = list(map(int, stdin.readline().split()))",
"- unite(roads, p - 1, q - 1)",
"-for i in range(l):",
"- p, q = list(map(int, stdin.readline().split()))",
"- unite(rails, p - 1, q - 1)",
"-d = {}",
"-for i in range(n):",
"- t = (find(roads, i), find(rails, i))",
"- if t in d:",
"- d[t] += 1",
"- else:",
"- d[t] = 1",
"-print((*[d[(find(roads, i), find(rails, i))] for i in range(n)]))",
"+main()"
]
| false | 0.04493 | 0.047415 | 0.947594 | [
"s083025752",
"s638650074"
]
|
u077291787 | p02928 | python | s669632622 | s236737519 | 167 | 30 | 3,564 | 3,188 | Accepted | Accepted | 82.04 | # jsc2019-qualB - Kleene Inversion
from collections import Counter
from itertools import accumulate
def main():
N, K = tuple(map(int, input().split()))
A = tuple(map(int, input().split()))
MOD = 10 ** 9 + 7
C = list(Counter(A).values())
ac = list(accumulate(C[:-1]))
x = sum(i * j for i, j in zip(C[1:], ac)) % MOD
y = sum(sum(b > a for b in A[i + 1 :]) for i, a in enumerate(A[:-1]))
ans = (x * (1 + K) * K // 2) % MOD
ans = (ans - y * K) % MOD
print(ans)
if __name__ == "__main__":
main() | # jsc2019-qualB - Kleene Inversion
class BIT: # Binary Indexed Tree (Fenwick Tree)
def __init__(self, lim):
self.size = lim
self.tree = [0] * (lim + 1) # 1-idx
def add(self, i, x): # add x to tree[i], O(logN)
while i <= self.size:
self.tree[i] += x
i += i & -i
def sum(self, i): # sum of [1, i], O(logN)
ret = 0
while i > 0:
ret += self.tree[i]
i -= i & -i
return ret
def range_sum(self, l, r): # range sum of [l, r]
return self.sum(r) - self.sum(l - 1)
def main():
N, K = tuple(map(int, input().split()))
A = tuple(map(int, input().split()))
MOD = 10 ** 9 + 7
bit = BIT(2000)
x = 0
for i, a in enumerate(A, 1): # internal inversion
bit.add(a, 1)
x += i - bit.sum(a)
y = -x
for i, a in enumerate(A, 1): # external inversion
bit.add(a, 1)
y += i + N - bit.sum(a)
ans = (x * K + y * K * (K - 1) // 2) % MOD
print(ans)
if __name__ == "__main__":
main() | 20 | 41 | 557 | 1,099 | # jsc2019-qualB - Kleene Inversion
from collections import Counter
from itertools import accumulate
def main():
N, K = tuple(map(int, input().split()))
A = tuple(map(int, input().split()))
MOD = 10**9 + 7
C = list(Counter(A).values())
ac = list(accumulate(C[:-1]))
x = sum(i * j for i, j in zip(C[1:], ac)) % MOD
y = sum(sum(b > a for b in A[i + 1 :]) for i, a in enumerate(A[:-1]))
ans = (x * (1 + K) * K // 2) % MOD
ans = (ans - y * K) % MOD
print(ans)
if __name__ == "__main__":
main()
| # jsc2019-qualB - Kleene Inversion
class BIT: # Binary Indexed Tree (Fenwick Tree)
def __init__(self, lim):
self.size = lim
self.tree = [0] * (lim + 1) # 1-idx
def add(self, i, x): # add x to tree[i], O(logN)
while i <= self.size:
self.tree[i] += x
i += i & -i
def sum(self, i): # sum of [1, i], O(logN)
ret = 0
while i > 0:
ret += self.tree[i]
i -= i & -i
return ret
def range_sum(self, l, r): # range sum of [l, r]
return self.sum(r) - self.sum(l - 1)
def main():
N, K = tuple(map(int, input().split()))
A = tuple(map(int, input().split()))
MOD = 10**9 + 7
bit = BIT(2000)
x = 0
for i, a in enumerate(A, 1): # internal inversion
bit.add(a, 1)
x += i - bit.sum(a)
y = -x
for i, a in enumerate(A, 1): # external inversion
bit.add(a, 1)
y += i + N - bit.sum(a)
ans = (x * K + y * K * (K - 1) // 2) % MOD
print(ans)
if __name__ == "__main__":
main()
| false | 51.219512 | [
"-from collections import Counter",
"-from itertools import accumulate",
"+class BIT: # Binary Indexed Tree (Fenwick Tree)",
"+ def __init__(self, lim):",
"+ self.size = lim",
"+ self.tree = [0] * (lim + 1) # 1-idx",
"+",
"+ def add(self, i, x): # add x to tree[i], O(logN)",
"+ while i <= self.size:",
"+ self.tree[i] += x",
"+ i += i & -i",
"+",
"+ def sum(self, i): # sum of [1, i], O(logN)",
"+ ret = 0",
"+ while i > 0:",
"+ ret += self.tree[i]",
"+ i -= i & -i",
"+ return ret",
"+",
"+ def range_sum(self, l, r): # range sum of [l, r]",
"+ return self.sum(r) - self.sum(l - 1)",
"- C = list(Counter(A).values())",
"- ac = list(accumulate(C[:-1]))",
"- x = sum(i * j for i, j in zip(C[1:], ac)) % MOD",
"- y = sum(sum(b > a for b in A[i + 1 :]) for i, a in enumerate(A[:-1]))",
"- ans = (x * (1 + K) * K // 2) % MOD",
"- ans = (ans - y * K) % MOD",
"+ bit = BIT(2000)",
"+ x = 0",
"+ for i, a in enumerate(A, 1): # internal inversion",
"+ bit.add(a, 1)",
"+ x += i - bit.sum(a)",
"+ y = -x",
"+ for i, a in enumerate(A, 1): # external inversion",
"+ bit.add(a, 1)",
"+ y += i + N - bit.sum(a)",
"+ ans = (x * K + y * K * (K - 1) // 2) % MOD"
]
| false | 0.035335 | 0.038942 | 0.90737 | [
"s669632622",
"s236737519"
]
|
u806855121 | p03814 | python | s092090047 | s415038097 | 947 | 39 | 3,816 | 3,512 | Accepted | Accepted | 95.88 | s = eval(input())
ans = ''
idx = -1
for i, c in enumerate(s):
if c == 'A' and idx == -1:
idx = i
if c == 'Z':
ans = s[idx:i+1]
print((len(ans)))
| s = eval(input())
ans = ''
idx = -1
for i, c in enumerate(s):
if c == 'A' and idx == -1:
idx = i
break
for i, c in enumerate(reversed(s)):
if c == 'Z':
ans = s[idx:len(s)-i]
break
print((len(ans)))
| 10 | 13 | 171 | 243 | s = eval(input())
ans = ""
idx = -1
for i, c in enumerate(s):
if c == "A" and idx == -1:
idx = i
if c == "Z":
ans = s[idx : i + 1]
print((len(ans)))
| s = eval(input())
ans = ""
idx = -1
for i, c in enumerate(s):
if c == "A" and idx == -1:
idx = i
break
for i, c in enumerate(reversed(s)):
if c == "Z":
ans = s[idx : len(s) - i]
break
print((len(ans)))
| false | 23.076923 | [
"+ break",
"+for i, c in enumerate(reversed(s)):",
"- ans = s[idx : i + 1]",
"+ ans = s[idx : len(s) - i]",
"+ break"
]
| false | 0.105533 | 0.037138 | 2.841603 | [
"s092090047",
"s415038097"
]
|
u864090097 | p02584 | python | s433944897 | s834653689 | 34 | 31 | 8,964 | 9,168 | Accepted | Accepted | 8.82 | X, K, D = list(map(int ,input().split()))
X = abs(X)
if X // D > K:
ans = X - K * D
else:
if X // D % 2 == 0:
if K % 2 == 0:
ans = X % D
else:
ans = abs(X % D - D)
else:
if K % 2 == 0:
ans = abs(X % D - D)
else:
ans = X % D
print(ans)
| X, K, D = list(map(int ,input().split()))
X = abs(X)
if X // D > K:
ans = X - K * D
else:
if X // D % 2 == K % 2:
ans = X % D
else:
ans = abs(X % D - D)
print(ans)
| 18 | 11 | 340 | 197 | X, K, D = list(map(int, input().split()))
X = abs(X)
if X // D > K:
ans = X - K * D
else:
if X // D % 2 == 0:
if K % 2 == 0:
ans = X % D
else:
ans = abs(X % D - D)
else:
if K % 2 == 0:
ans = abs(X % D - D)
else:
ans = X % D
print(ans)
| X, K, D = list(map(int, input().split()))
X = abs(X)
if X // D > K:
ans = X - K * D
else:
if X // D % 2 == K % 2:
ans = X % D
else:
ans = abs(X % D - D)
print(ans)
| false | 38.888889 | [
"- if X // D % 2 == 0:",
"- if K % 2 == 0:",
"- ans = X % D",
"- else:",
"- ans = abs(X % D - D)",
"+ if X // D % 2 == K % 2:",
"+ ans = X % D",
"- if K % 2 == 0:",
"- ans = abs(X % D - D)",
"- else:",
"- ans = X % D",
"+ ans = abs(X % D - D)"
]
| false | 0.066133 | 0.087106 | 0.759227 | [
"s433944897",
"s834653689"
]
|
u225388820 | p03164 | python | s166001514 | s804983512 | 1,060 | 570 | 315,064 | 171,120 | Accepted | Accepted | 46.23 | """
重さと価値がそれぞれw_i,v_iであるようなn個の品物がある.
これらの品物の中から, 重さの総和がWを超えないように選んだ時の,
価値の総和の最大値を求めよ.
1<=n<=100, 1<=w_i<=10^7, 1<=v_i<=100, 1<=W<=10^9
"""
#-------------------------------------------------------------------------------
#入力
INF=float('inf')
n ,W= list(map(int, input().split()))
w=[0]*n
v=[0]*n
for i in range(n):
w[i],v[i] = list(map(int, input().split()))
V=sum(v)
dp = [[INF for i in range(V+1)] for j in range(n+1)]
#ここからメイン
dp[0][0]=0
for i in range(n):
for j in range(V+1):
if j<v[i]:
dp[i+1][j]=dp[i][j]
else:
dp[i+1][j]=min(dp[i][j],dp[i][j-v[i]]+w[i])
ans=0
for i in range(V+1):
if dp[n][i]<=W:
ans=i
print(ans)
| """
重さと価値がそれぞれw_i,v_iであるようなn個の品物がある.
これらの品物の中から, 重さの総和がWを超えないように選んだ時の,
価値の総和の最大値を求めよ.
1<=n<=100, 1<=w_i<=10^7, 1<=v_i<=100, 1<=W<=10^9
"""
#-------------------------------------------------------------------------------
#入力
INF = 2000000000
n, W = list(map(int, input().split()))
w = [0]*n
v = [0]*n
for i in range(n):
w[i], v[i] = list(map(int, input().split()))
V = sum(v)
dp = [[INF for i in range(V + 1)] for j in range(n + 1)]
#ここからメイン
dp[0][0] = 0
for i in range(n):
for j in range(V + 1):
if j < v[i]:
dp[i + 1][j] = dp[i][j]
else:
dp[i + 1][j] = min(dp[i][j], dp[i][j - v[i]] + w[i])
ans = 0
for i in range(V + 1):
if dp[n][i] <= W:
ans = i
print(ans)
| 31 | 31 | 701 | 740 | """
重さと価値がそれぞれw_i,v_iであるようなn個の品物がある.
これらの品物の中から, 重さの総和がWを超えないように選んだ時の,
価値の総和の最大値を求めよ.
1<=n<=100, 1<=w_i<=10^7, 1<=v_i<=100, 1<=W<=10^9
"""
# -------------------------------------------------------------------------------
# 入力
INF = float("inf")
n, W = list(map(int, input().split()))
w = [0] * n
v = [0] * n
for i in range(n):
w[i], v[i] = list(map(int, input().split()))
V = sum(v)
dp = [[INF for i in range(V + 1)] for j in range(n + 1)]
# ここからメイン
dp[0][0] = 0
for i in range(n):
for j in range(V + 1):
if j < v[i]:
dp[i + 1][j] = dp[i][j]
else:
dp[i + 1][j] = min(dp[i][j], dp[i][j - v[i]] + w[i])
ans = 0
for i in range(V + 1):
if dp[n][i] <= W:
ans = i
print(ans)
| """
重さと価値がそれぞれw_i,v_iであるようなn個の品物がある.
これらの品物の中から, 重さの総和がWを超えないように選んだ時の,
価値の総和の最大値を求めよ.
1<=n<=100, 1<=w_i<=10^7, 1<=v_i<=100, 1<=W<=10^9
"""
# -------------------------------------------------------------------------------
# 入力
INF = 2000000000
n, W = list(map(int, input().split()))
w = [0] * n
v = [0] * n
for i in range(n):
w[i], v[i] = list(map(int, input().split()))
V = sum(v)
dp = [[INF for i in range(V + 1)] for j in range(n + 1)]
# ここからメイン
dp[0][0] = 0
for i in range(n):
for j in range(V + 1):
if j < v[i]:
dp[i + 1][j] = dp[i][j]
else:
dp[i + 1][j] = min(dp[i][j], dp[i][j - v[i]] + w[i])
ans = 0
for i in range(V + 1):
if dp[n][i] <= W:
ans = i
print(ans)
| false | 0 | [
"-INF = float(\"inf\")",
"+INF = 2000000000"
]
| false | 0.045105 | 0.038796 | 1.162634 | [
"s166001514",
"s804983512"
]
|
u683134447 | p03592 | python | s954803479 | s723687014 | 397 | 183 | 3,064 | 40,428 | Accepted | Accepted | 53.9 | n,m,k = list(map(int,input().split()))
for i in range(n+1):
for j in range(m+1):
a = n*j + m*i - 2*i*j
if a == k:
print("Yes")
exit()
print("No")
| n,m,k = list(map(int,input().split()))
for i in range(n+1):
for j in range(m+1):
tmp = i * (m - j) + (n - i) * j
if tmp == k:
print("Yes")
exit()
print("No") | 10 | 9 | 195 | 204 | n, m, k = list(map(int, input().split()))
for i in range(n + 1):
for j in range(m + 1):
a = n * j + m * i - 2 * i * j
if a == k:
print("Yes")
exit()
print("No")
| n, m, k = list(map(int, input().split()))
for i in range(n + 1):
for j in range(m + 1):
tmp = i * (m - j) + (n - i) * j
if tmp == k:
print("Yes")
exit()
print("No")
| false | 10 | [
"- a = n * j + m * i - 2 * i * j",
"- if a == k:",
"+ tmp = i * (m - j) + (n - i) * j",
"+ if tmp == k:"
]
| false | 0.042249 | 0.04288 | 0.985276 | [
"s954803479",
"s723687014"
]
|
u347600233 | p02612 | python | s045373341 | s071310271 | 30 | 27 | 9,084 | 9,080 | Accepted | Accepted | 10 | n = int(eval(input()))
print((-(-n // 1000) * 1000 - n)) | n = int(eval(input()))
print((-(-n // 10**3)* 10**3 - n)) | 2 | 2 | 49 | 50 | n = int(eval(input()))
print((-(-n // 1000) * 1000 - n))
| n = int(eval(input()))
print((-(-n // 10**3) * 10**3 - n))
| false | 0 | [
"-print((-(-n // 1000) * 1000 - n))",
"+print((-(-n // 10**3) * 10**3 - n))"
]
| false | 0.03755 | 0.03709 | 1.012398 | [
"s045373341",
"s071310271"
]
|
u416011173 | p02813 | python | s007181757 | s406862726 | 38 | 33 | 9,140 | 9,128 | Accepted | Accepted | 13.16 | # -*- coding: utf-8 -*-
# モジュールのインポート
import itertools
# 標準入力を取得
N = int(eval(input()))
P = tuple(map(int, input().split()))
Q = tuple(map(int, input().split()))
# 求解処理
p = 0
q = 0
order = 1
for t in itertools.permutations(list(range(1, N + 1)), N):
if t == P:
p = order
if t == Q:
q = order
order += 1
ans = abs(p - q)
# 結果出力
print(ans)
| # -*- coding: utf-8 -*-
# モジュールのインポート
import itertools
def get_input() -> tuple:
"""
標準入力を取得する.
Returns:\n
tuple: 標準入力
"""
# 標準入力を取得
N = int(eval(input()))
P = tuple(map(int, input().split()))
Q = tuple(map(int, input().split()))
return N, P, Q
def main(N: int, P: tuple, Q: tuple) -> None:
"""
メイン処理.
Args:\n
N (int): 数列の大きさ
P (tuple): 順列
Q (tuple): 順列
"""
# 求解処理
p = 0
q = 0
order = 1
for t in itertools.permutations(list(range(1, N + 1)), N):
if t == P:
p = order
if t == Q:
q = order
order += 1
ans = abs(p - q)
# 結果出力
print(ans)
if __name__ == "__main__":
# 標準入力を取得
N, P, Q = get_input()
# メイン処理
main(N, P, Q)
| 24 | 52 | 381 | 846 | # -*- coding: utf-8 -*-
# モジュールのインポート
import itertools
# 標準入力を取得
N = int(eval(input()))
P = tuple(map(int, input().split()))
Q = tuple(map(int, input().split()))
# 求解処理
p = 0
q = 0
order = 1
for t in itertools.permutations(list(range(1, N + 1)), N):
if t == P:
p = order
if t == Q:
q = order
order += 1
ans = abs(p - q)
# 結果出力
print(ans)
| # -*- coding: utf-8 -*-
# モジュールのインポート
import itertools
def get_input() -> tuple:
"""
標準入力を取得する.
Returns:\n
tuple: 標準入力
"""
# 標準入力を取得
N = int(eval(input()))
P = tuple(map(int, input().split()))
Q = tuple(map(int, input().split()))
return N, P, Q
def main(N: int, P: tuple, Q: tuple) -> None:
"""
メイン処理.
Args:\n
N (int): 数列の大きさ
P (tuple): 順列
Q (tuple): 順列
"""
# 求解処理
p = 0
q = 0
order = 1
for t in itertools.permutations(list(range(1, N + 1)), N):
if t == P:
p = order
if t == Q:
q = order
order += 1
ans = abs(p - q)
# 結果出力
print(ans)
if __name__ == "__main__":
# 標準入力を取得
N, P, Q = get_input()
# メイン処理
main(N, P, Q)
| false | 53.846154 | [
"-# 標準入力を取得",
"-N = int(eval(input()))",
"-P = tuple(map(int, input().split()))",
"-Q = tuple(map(int, input().split()))",
"-# 求解処理",
"-p = 0",
"-q = 0",
"-order = 1",
"-for t in itertools.permutations(list(range(1, N + 1)), N):",
"- if t == P:",
"- p = order",
"- if t == Q:",
"- q = order",
"- order += 1",
"-ans = abs(p - q)",
"-# 結果出力",
"-print(ans)",
"+",
"+def get_input() -> tuple:",
"+ \"\"\"",
"+ 標準入力を取得する.",
"+ Returns:\\n",
"+ tuple: 標準入力",
"+ \"\"\"",
"+ # 標準入力を取得",
"+ N = int(eval(input()))",
"+ P = tuple(map(int, input().split()))",
"+ Q = tuple(map(int, input().split()))",
"+ return N, P, Q",
"+",
"+",
"+def main(N: int, P: tuple, Q: tuple) -> None:",
"+ \"\"\"",
"+ メイン処理.",
"+ Args:\\n",
"+ N (int): 数列の大きさ",
"+ P (tuple): 順列",
"+ Q (tuple): 順列",
"+ \"\"\"",
"+ # 求解処理",
"+ p = 0",
"+ q = 0",
"+ order = 1",
"+ for t in itertools.permutations(list(range(1, N + 1)), N):",
"+ if t == P:",
"+ p = order",
"+ if t == Q:",
"+ q = order",
"+ order += 1",
"+ ans = abs(p - q)",
"+ # 結果出力",
"+ print(ans)",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ # 標準入力を取得",
"+ N, P, Q = get_input()",
"+ # メイン処理",
"+ main(N, P, Q)"
]
| false | 0.036107 | 0.037133 | 0.972346 | [
"s007181757",
"s406862726"
]
|
u296518383 | p03208 | python | s288705199 | s341964287 | 270 | 121 | 7,444 | 7,500 | Accepted | Accepted | 55.19 | N,K=list(map(int,input().split()))
h=[]
for i in range(N):
h.append(int(eval(input())))
h.sort()
d=10**10
for i in range(N-K+1):
d=min(d,abs(h[i]-h[i+K-1]))
print(d) | import sys
input = sys.stdin.buffer.readline
N, K = list(map(int, input().split()))
H = [int(eval(input())) for _ in range(N)]
H.sort()
answer = 10 ** 15
for i in range(N - K + 1):
answer = min(answer, H[i + K - 1] - H[i])
print(answer) | 11 | 13 | 169 | 242 | N, K = list(map(int, input().split()))
h = []
for i in range(N):
h.append(int(eval(input())))
h.sort()
d = 10**10
for i in range(N - K + 1):
d = min(d, abs(h[i] - h[i + K - 1]))
print(d)
| import sys
input = sys.stdin.buffer.readline
N, K = list(map(int, input().split()))
H = [int(eval(input())) for _ in range(N)]
H.sort()
answer = 10**15
for i in range(N - K + 1):
answer = min(answer, H[i + K - 1] - H[i])
print(answer)
| false | 15.384615 | [
"+import sys",
"+",
"+input = sys.stdin.buffer.readline",
"-h = []",
"-for i in range(N):",
"- h.append(int(eval(input())))",
"-h.sort()",
"-d = 10**10",
"+H = [int(eval(input())) for _ in range(N)]",
"+H.sort()",
"+answer = 10**15",
"- d = min(d, abs(h[i] - h[i + K - 1]))",
"-print(d)",
"+ answer = min(answer, H[i + K - 1] - H[i])",
"+print(answer)"
]
| false | 0.05828 | 0.035795 | 1.628175 | [
"s288705199",
"s341964287"
]
|
u512212329 | p02624 | python | s701374772 | s797441495 | 1,295 | 172 | 9,012 | 63,156 | Accepted | Accepted | 86.72 | def main():
num = int(eval(input()))
gg = ((
(quotient := num // divisor) + 1) * quotient * divisor // 2
for divisor in range(1, num + 1))
print((sum(gg)))
if __name__ == '__main__':
main()
| def main():
num = int(eval(input()))
ans = 0
for divisor in range(1, num + 1):
quotient = num // divisor
ans += (quotient + 1) * quotient * divisor // 2
print(ans)
if __name__ == '__main__':
main()
| 10 | 13 | 225 | 244 | def main():
num = int(eval(input()))
gg = (
((quotient := num // divisor) + 1) * quotient * divisor // 2
for divisor in range(1, num + 1)
)
print((sum(gg)))
if __name__ == "__main__":
main()
| def main():
num = int(eval(input()))
ans = 0
for divisor in range(1, num + 1):
quotient = num // divisor
ans += (quotient + 1) * quotient * divisor // 2
print(ans)
if __name__ == "__main__":
main()
| false | 23.076923 | [
"- gg = (",
"- ((quotient := num // divisor) + 1) * quotient * divisor // 2",
"- for divisor in range(1, num + 1)",
"- )",
"- print((sum(gg)))",
"+ ans = 0",
"+ for divisor in range(1, num + 1):",
"+ quotient = num // divisor",
"+ ans += (quotient + 1) * quotient * divisor // 2",
"+ print(ans)"
]
| false | 0.912765 | 0.492691 | 1.85261 | [
"s701374772",
"s797441495"
]
|
u562935282 | p03186 | python | s546882592 | s038455905 | 19 | 17 | 2,940 | 2,940 | Accepted | Accepted | 10.53 | A, B, C = list(map(int, input().split()))
print((min(C, A + B + 1) + B))
| A, B, C = list(map(int, input().split()))
print((B + min(C, A + B + 1)))
| 2 | 2 | 66 | 66 | A, B, C = list(map(int, input().split()))
print((min(C, A + B + 1) + B))
| A, B, C = list(map(int, input().split()))
print((B + min(C, A + B + 1)))
| false | 0 | [
"-print((min(C, A + B + 1) + B))",
"+print((B + min(C, A + B + 1)))"
]
| false | 0.040031 | 0.083103 | 0.481703 | [
"s546882592",
"s038455905"
]
|
u077127204 | p03339 | python | s528113727 | s198038168 | 211 | 76 | 46,492 | 15,520 | Accepted | Accepted | 63.98 | N = int(eval(input()))
S = eval(input())
def f(S):
count = {'W': 0, 'E': 0}
yield count['W'], count['E']
for c in S:
count[c] += 1
yield count['W'], count['E']
count = list(f(S))
print((min([count[i-1][0] + count[-1][1] - count[i][1] for i in range(1, N+1)])))
| N = int(eval(input()))
S = eval(input())
def f(S):
count = S.count('E')
for s in S:
if s == 'E':
count += -1
yield count
if s == 'W':
count += 1
print((min(list(f(S)))))
| 12 | 13 | 274 | 198 | N = int(eval(input()))
S = eval(input())
def f(S):
count = {"W": 0, "E": 0}
yield count["W"], count["E"]
for c in S:
count[c] += 1
yield count["W"], count["E"]
count = list(f(S))
print((min([count[i - 1][0] + count[-1][1] - count[i][1] for i in range(1, N + 1)])))
| N = int(eval(input()))
S = eval(input())
def f(S):
count = S.count("E")
for s in S:
if s == "E":
count += -1
yield count
if s == "W":
count += 1
print((min(list(f(S)))))
| false | 7.692308 | [
"- count = {\"W\": 0, \"E\": 0}",
"- yield count[\"W\"], count[\"E\"]",
"- for c in S:",
"- count[c] += 1",
"- yield count[\"W\"], count[\"E\"]",
"+ count = S.count(\"E\")",
"+ for s in S:",
"+ if s == \"E\":",
"+ count += -1",
"+ yield count",
"+ if s == \"W\":",
"+ count += 1",
"-count = list(f(S))",
"-print((min([count[i - 1][0] + count[-1][1] - count[i][1] for i in range(1, N + 1)])))",
"+print((min(list(f(S)))))"
]
| false | 0.039208 | 0.07973 | 0.491764 | [
"s528113727",
"s198038168"
]
|
u203383537 | p03645 | python | s121928477 | s727074644 | 1,612 | 969 | 93,768 | 40,472 | Accepted | Accepted | 39.89 | import queue
n,m = list(map(int,input().split()))
adj = [[] for i in range(n)]
dist = [-1]*n
for i in range(m):
a,b = list(map(int,input().split()))
adj[a-1].append(b-1)
adj[b-1].append(a-1)
q = queue.Queue()
dist[0] = 0
q.put(0)
while not q.empty():
x = q.get()
for f in adj[x]:
if dist[f] != -1:
continue
dist[f] = dist[x] + 1
q.put(f)
if dist[n-1] == 2:
print("POSSIBLE")
else:
print("IMPOSSIBLE") | from collections import deque
n,m = list(map(int,input().split()))
adj = [[] for i in range(n)]
dist = [-1]*n
for i in range(m):
a,b = list(map(int,input().split()))
adj[a-1].append(b-1)
adj[b-1].append(a-1)
q = deque()
dist[0] = 0
q.append(0)
while len(q) > 0:
x = q.popleft()
for f in adj[x]:
if dist[f] != -1:
continue
dist[f] = dist[x] + 1
q.append(f)
if dist[n-1] == 2:
print("POSSIBLE")
else:
print("IMPOSSIBLE") | 28 | 28 | 506 | 524 | import queue
n, m = list(map(int, input().split()))
adj = [[] for i in range(n)]
dist = [-1] * n
for i in range(m):
a, b = list(map(int, input().split()))
adj[a - 1].append(b - 1)
adj[b - 1].append(a - 1)
q = queue.Queue()
dist[0] = 0
q.put(0)
while not q.empty():
x = q.get()
for f in adj[x]:
if dist[f] != -1:
continue
dist[f] = dist[x] + 1
q.put(f)
if dist[n - 1] == 2:
print("POSSIBLE")
else:
print("IMPOSSIBLE")
| from collections import deque
n, m = list(map(int, input().split()))
adj = [[] for i in range(n)]
dist = [-1] * n
for i in range(m):
a, b = list(map(int, input().split()))
adj[a - 1].append(b - 1)
adj[b - 1].append(a - 1)
q = deque()
dist[0] = 0
q.append(0)
while len(q) > 0:
x = q.popleft()
for f in adj[x]:
if dist[f] != -1:
continue
dist[f] = dist[x] + 1
q.append(f)
if dist[n - 1] == 2:
print("POSSIBLE")
else:
print("IMPOSSIBLE")
| false | 0 | [
"-import queue",
"+from collections import deque",
"-q = queue.Queue()",
"+q = deque()",
"-q.put(0)",
"-while not q.empty():",
"- x = q.get()",
"+q.append(0)",
"+while len(q) > 0:",
"+ x = q.popleft()",
"- q.put(f)",
"+ q.append(f)"
]
| false | 0.096391 | 0.083459 | 1.15495 | [
"s121928477",
"s727074644"
]
|
u707498674 | p03274 | python | s364934242 | s940598975 | 140 | 103 | 14,548 | 14,224 | Accepted | Accepted | 26.43 | import bisect
N, K = list(map(int, input().split()))
x = list(map(int, input().split()))
t = 2 * (x[-1] - x[0])
i = bisect.bisect_right(x, 0)
for j in range(0, N):
if N <= j + K -1 :
break
if (j - (i - 0.1)) * (j + K- 1 - (i - 0.1)) >= 0:
t = min(t, max(abs(x[j]), abs(x[j+K-1])))
else:
t = min(t, abs(2 * x[j]) + x[j+K-1])
t = min(t, abs(x[j]) + 2 * x[j+K-1])
print(t) | N, K = list(map(int, input().split()))
x = list(map(int, input().split()))
dist = 2 * (x[-1] - x[0])
for i in range(N):
if i + K -1 >= N:
break
dist = min(dist, abs(x[i]) + abs(x[i + K - 1] - x[i]),abs(x[i + K -1]) + abs(x[i + K - 1] - x[i]))
print(dist) | 14 | 8 | 420 | 271 | import bisect
N, K = list(map(int, input().split()))
x = list(map(int, input().split()))
t = 2 * (x[-1] - x[0])
i = bisect.bisect_right(x, 0)
for j in range(0, N):
if N <= j + K - 1:
break
if (j - (i - 0.1)) * (j + K - 1 - (i - 0.1)) >= 0:
t = min(t, max(abs(x[j]), abs(x[j + K - 1])))
else:
t = min(t, abs(2 * x[j]) + x[j + K - 1])
t = min(t, abs(x[j]) + 2 * x[j + K - 1])
print(t)
| N, K = list(map(int, input().split()))
x = list(map(int, input().split()))
dist = 2 * (x[-1] - x[0])
for i in range(N):
if i + K - 1 >= N:
break
dist = min(
dist,
abs(x[i]) + abs(x[i + K - 1] - x[i]),
abs(x[i + K - 1]) + abs(x[i + K - 1] - x[i]),
)
print(dist)
| false | 42.857143 | [
"-import bisect",
"-",
"-t = 2 * (x[-1] - x[0])",
"-i = bisect.bisect_right(x, 0)",
"-for j in range(0, N):",
"- if N <= j + K - 1:",
"+dist = 2 * (x[-1] - x[0])",
"+for i in range(N):",
"+ if i + K - 1 >= N:",
"- if (j - (i - 0.1)) * (j + K - 1 - (i - 0.1)) >= 0:",
"- t = min(t, max(abs(x[j]), abs(x[j + K - 1])))",
"- else:",
"- t = min(t, abs(2 * x[j]) + x[j + K - 1])",
"- t = min(t, abs(x[j]) + 2 * x[j + K - 1])",
"-print(t)",
"+ dist = min(",
"+ dist,",
"+ abs(x[i]) + abs(x[i + K - 1] - x[i]),",
"+ abs(x[i + K - 1]) + abs(x[i + K - 1] - x[i]),",
"+ )",
"+print(dist)"
]
| false | 0.036917 | 0.05003 | 0.737895 | [
"s364934242",
"s940598975"
]
|
u214617707 | p03721 | python | s014950547 | s836819515 | 351 | 321 | 10,848 | 5,736 | Accepted | Accepted | 8.55 | from collections import defaultdict
n, k = list(map(int, input().split()))
dic = defaultdict(int)
for i in range(n):
a, b = list(map(int, input().split()))
dic[a] += b
t = sorted(dic.keys())
for i in t:
k -= dic[i]
if k <= 0:
print(i)
break | n, K = list(map(int, input().split()))
rec = [0] * (10 ** 5 + 5)
for i in range(n):
a, b = list(map(int, input().split()))
rec[a] += b
for i in range(10 ** 5 + 1):
if rec[i] > 0:
K -= rec[i]
if K <= 0:
print(i)
exit() | 13 | 12 | 273 | 269 | from collections import defaultdict
n, k = list(map(int, input().split()))
dic = defaultdict(int)
for i in range(n):
a, b = list(map(int, input().split()))
dic[a] += b
t = sorted(dic.keys())
for i in t:
k -= dic[i]
if k <= 0:
print(i)
break
| n, K = list(map(int, input().split()))
rec = [0] * (10**5 + 5)
for i in range(n):
a, b = list(map(int, input().split()))
rec[a] += b
for i in range(10**5 + 1):
if rec[i] > 0:
K -= rec[i]
if K <= 0:
print(i)
exit()
| false | 7.692308 | [
"-from collections import defaultdict",
"-",
"-n, k = list(map(int, input().split()))",
"-dic = defaultdict(int)",
"+n, K = list(map(int, input().split()))",
"+rec = [0] * (10**5 + 5)",
"- dic[a] += b",
"-t = sorted(dic.keys())",
"-for i in t:",
"- k -= dic[i]",
"- if k <= 0:",
"- print(i)",
"- break",
"+ rec[a] += b",
"+for i in range(10**5 + 1):",
"+ if rec[i] > 0:",
"+ K -= rec[i]",
"+ if K <= 0:",
"+ print(i)",
"+ exit()"
]
| false | 0.076605 | 0.173656 | 0.441129 | [
"s014950547",
"s836819515"
]
|
u095426154 | p02787 | python | s461870136 | s252574247 | 680 | 602 | 125,404 | 125,404 | Accepted | Accepted | 11.47 | # coding: utf-8
H,N=list(map(int,input().split()))
AB=[[0,0]]
for i in range(N):
AB.append(list(map(int,input().split())))
INF=10**9
dp=[[INF for i in range(H+1)] for j in range(N+1)]
for i in range(N+1):
dp[i][0]=0
for i in range(1,N+1):
for j in range(1,H+1):
dp[i][j]=min(dp[i-1][j],dp[i-1][max(j-AB[i][0],0)] + AB[i][1],dp[i][max(j-AB[i][0],0)] + AB[i][1])
#print(dp[i-1][j],dp[i-1][max(j-AB[i][0],0)] + AB[i][1],dp[i][max(j-AB[i][0],0)] + AB[i][1])
print((dp[N][H]))
| # coding: utf-8
H,N=list(map(int,input().split()))
AB=[[0,0]]
for i in range(N):
AB.append(list(map(int,input().split())))
INF=10**9
dp=[[INF for i in range(H+1)] for j in range(N+1)]
for i in range(N+1):
dp[i][0]=0
for i in range(1,N+1):
for j in range(1,H+1):
dp[i][j]=min(dp[i-1][j],dp[i][max(j-AB[i][0],0)] + AB[i][1])
#print(dp[i-1][j],dp[i-1][max(j-AB[i][0],0)] + AB[i][1],dp[i][max(j-AB[i][0],0)] + AB[i][1])
print((dp[N][H]))
| 22 | 22 | 529 | 491 | # coding: utf-8
H, N = list(map(int, input().split()))
AB = [[0, 0]]
for i in range(N):
AB.append(list(map(int, input().split())))
INF = 10**9
dp = [[INF for i in range(H + 1)] for j in range(N + 1)]
for i in range(N + 1):
dp[i][0] = 0
for i in range(1, N + 1):
for j in range(1, H + 1):
dp[i][j] = min(
dp[i - 1][j],
dp[i - 1][max(j - AB[i][0], 0)] + AB[i][1],
dp[i][max(j - AB[i][0], 0)] + AB[i][1],
)
# print(dp[i-1][j],dp[i-1][max(j-AB[i][0],0)] + AB[i][1],dp[i][max(j-AB[i][0],0)] + AB[i][1])
print((dp[N][H]))
| # coding: utf-8
H, N = list(map(int, input().split()))
AB = [[0, 0]]
for i in range(N):
AB.append(list(map(int, input().split())))
INF = 10**9
dp = [[INF for i in range(H + 1)] for j in range(N + 1)]
for i in range(N + 1):
dp[i][0] = 0
for i in range(1, N + 1):
for j in range(1, H + 1):
dp[i][j] = min(dp[i - 1][j], dp[i][max(j - AB[i][0], 0)] + AB[i][1])
# print(dp[i-1][j],dp[i-1][max(j-AB[i][0],0)] + AB[i][1],dp[i][max(j-AB[i][0],0)] + AB[i][1])
print((dp[N][H]))
| false | 0 | [
"- dp[i][j] = min(",
"- dp[i - 1][j],",
"- dp[i - 1][max(j - AB[i][0], 0)] + AB[i][1],",
"- dp[i][max(j - AB[i][0], 0)] + AB[i][1],",
"- )",
"+ dp[i][j] = min(dp[i - 1][j], dp[i][max(j - AB[i][0], 0)] + AB[i][1])"
]
| false | 0.196754 | 0.58239 | 0.33784 | [
"s461870136",
"s252574247"
]
|
u634046173 | p03146 | python | s965750623 | s125693327 | 42 | 24 | 16,760 | 9,168 | Accepted | Accepted | 42.86 | s = int(eval(input()))
a = [0] * 1000000
a[0] = s
for i in range(1,1000000):
if a[i-1] % 2 == 0:
a[i] = a[i-1]//2
else:
a[i] = a[i-1]*3+1
if a[i] in a[:i]:
print((i+1))
exit() | S=int(eval(input()))
a=[]
for i in range(1, 1000001):
if S in a:
print(i)
break
else:
a.append(S)
if S%2==0:
S=S/2
else:
S=3*S+1
| 12 | 13 | 201 | 208 | s = int(eval(input()))
a = [0] * 1000000
a[0] = s
for i in range(1, 1000000):
if a[i - 1] % 2 == 0:
a[i] = a[i - 1] // 2
else:
a[i] = a[i - 1] * 3 + 1
if a[i] in a[:i]:
print((i + 1))
exit()
| S = int(eval(input()))
a = []
for i in range(1, 1000001):
if S in a:
print(i)
break
else:
a.append(S)
if S % 2 == 0:
S = S / 2
else:
S = 3 * S + 1
| false | 7.692308 | [
"-s = int(eval(input()))",
"-a = [0] * 1000000",
"-a[0] = s",
"-for i in range(1, 1000000):",
"- if a[i - 1] % 2 == 0:",
"- a[i] = a[i - 1] // 2",
"+S = int(eval(input()))",
"+a = []",
"+for i in range(1, 1000001):",
"+ if S in a:",
"+ print(i)",
"+ break",
"- a[i] = a[i - 1] * 3 + 1",
"- if a[i] in a[:i]:",
"- print((i + 1))",
"- exit()",
"+ a.append(S)",
"+ if S % 2 == 0:",
"+ S = S / 2",
"+ else:",
"+ S = 3 * S + 1"
]
| false | 0.007677 | 0.036794 | 0.208642 | [
"s965750623",
"s125693327"
]
|
u951601135 | p03273 | python | s750272134 | s238983180 | 30 | 18 | 4,724 | 3,060 | Accepted | Accepted | 40 | H,W=map(int,input().split())
matrix=[list(map(str,input().split())) for i in range(H)]
count_delete_H=0
count_delete_W=0
for i in range(H):
matrix[i-count_delete_H]=list(*matrix[i-count_delete_H])
if(matrix[i-count_delete_H].count('#')==0):
del matrix[i-count_delete_H]
count_delete_H+=1
matrix_t = [list(x) for x in zip(*matrix)]
for i in range(W):
if(matrix_t[i-count_delete_W].count('#')==0):
del matrix_t[i-count_delete_W]
count_delete_W+=1
matrix_tt = [list(x) for x in zip(*matrix_t)]
for i in range(H-count_delete_H):
for j in range(W-count_delete_W):
print(matrix_tt[i][j],end='')
print('')
| H, W = list(map(int,input().split()))
HW = [eval(input()) for _ in range(H)]
#print(HW)
#黒がない行は削除して転置,*で文字列を一文字ずつに分解、joinで再結合
HW = ["".join(hw) for hw in zip(*HW) if hw.count("#") > 0]
#転置した後の黒がない行（元の行列の列に対応する）は削除して転置（元の行列に戻る）
HW = ["".join(hw) for hw in zip(*HW) if hw.count("#") > 0]
print(("\n".join(HW)))#改行を伴って結合 | 22 | 8 | 660 | 310 | H, W = map(int, input().split())
matrix = [list(map(str, input().split())) for i in range(H)]
count_delete_H = 0
count_delete_W = 0
for i in range(H):
matrix[i - count_delete_H] = list(*matrix[i - count_delete_H])
if matrix[i - count_delete_H].count("#") == 0:
del matrix[i - count_delete_H]
count_delete_H += 1
matrix_t = [list(x) for x in zip(*matrix)]
for i in range(W):
if matrix_t[i - count_delete_W].count("#") == 0:
del matrix_t[i - count_delete_W]
count_delete_W += 1
matrix_tt = [list(x) for x in zip(*matrix_t)]
for i in range(H - count_delete_H):
for j in range(W - count_delete_W):
print(matrix_tt[i][j], end="")
print("")
| H, W = list(map(int, input().split()))
HW = [eval(input()) for _ in range(H)]
# print(HW)
# 黒がない行は削除して転置,*で文字列を一文字ずつに分解、joinで再結合
HW = ["".join(hw) for hw in zip(*HW) if hw.count("#") > 0]
# 転置した後の黒がない行（元の行列の列に対応する）は削除して転置（元の行列に戻る）
HW = ["".join(hw) for hw in zip(*HW) if hw.count("#") > 0]
print(("\n".join(HW))) # 改行を伴って結合
| false | 63.636364 | [
"-H, W = map(int, input().split())",
"-matrix = [list(map(str, input().split())) for i in range(H)]",
"-count_delete_H = 0",
"-count_delete_W = 0",
"-for i in range(H):",
"- matrix[i - count_delete_H] = list(*matrix[i - count_delete_H])",
"- if matrix[i - count_delete_H].count(\"#\") == 0:",
"- del matrix[i - count_delete_H]",
"- count_delete_H += 1",
"-matrix_t = [list(x) for x in zip(*matrix)]",
"-for i in range(W):",
"- if matrix_t[i - count_delete_W].count(\"#\") == 0:",
"- del matrix_t[i - count_delete_W]",
"- count_delete_W += 1",
"-matrix_tt = [list(x) for x in zip(*matrix_t)]",
"-for i in range(H - count_delete_H):",
"- for j in range(W - count_delete_W):",
"- print(matrix_tt[i][j], end=\"\")",
"- print(\"\")",
"+H, W = list(map(int, input().split()))",
"+HW = [eval(input()) for _ in range(H)]",
"+# print(HW)",
"+# 黒がない行は削除して転置,*で文字列を一文字ずつに分解、joinで再結合",
"+HW = [\"\".join(hw) for hw in zip(*HW) if hw.count(\"#\") > 0]",
"+# 転置した後の黒がない行（元の行列の列に対応する）は削除して転置（元の行列に戻る）",
"+HW = [\"\".join(hw) for hw in zip(*HW) if hw.count(\"#\") > 0]",
"+print((\"\\n\".join(HW))) # 改行を伴って結合"
]
| false | 0.038222 | 0.007079 | 5.399398 | [
"s750272134",
"s238983180"
]
|
u303039933 | p02833 | python | s549531635 | s862283187 | 283 | 41 | 61,292 | 10,624 | Accepted | Accepted | 85.51 | # -*- coding: utf-8 -*-
import sys
import math
import os
import itertools
import string
import heapq
import _collections
from collections import Counter
from collections import defaultdict
from functools import lru_cache
import bisect
import re
import queue
from decimal import *
class Scanner():
@staticmethod
def int():
return int(sys.stdin.readline().rstrip())
@staticmethod
def string():
return sys.stdin.readline().rstrip()
@staticmethod
def map_int():
return [int(x) for x in Scanner.string().split()]
@staticmethod
def string_list(n):
return [eval(input()) for i in range(n)]
@staticmethod
def int_list_list(n):
return [Scanner.map_int() for i in range(n)]
@staticmethod
def int_cols_list(n):
return [int(eval(input())) for i in range(n)]
class Math():
@staticmethod
def gcd(a, b):
if b == 0:
return a
return Math.gcd(b, a % b)
@staticmethod
def lcm(a, b):
return (a * b) // Math.gcd(a, b)
@staticmethod
def divisor(n):
res = []
i = 1
for i in range(1, int(n ** 0.5) + 1):
if n % i == 0:
res.append(i)
if i != n // i:
res.append(n // i)
return res
@staticmethod
def round_up(a, b):
return -(-a // b)
@staticmethod
def is_prime(n):
if n < 2:
return False
if n == 2:
return True
if n % 2 == 0:
return False
d = int(n ** 0.5) + 1
for i in range(3, d + 1, 2):
if n % i == 0:
return False
return True
def pop_count(x):
x = x - ((x >> 1) & 0x5555555555555555)
x = (x & 0x3333333333333333) + ((x >> 2) & 0x3333333333333333)
x = (x + (x >> 4)) & 0x0f0f0f0f0f0f0f0f
x = x + (x >> 8)
x = x + (x >> 16)
x = x + (x >> 32)
return x & 0x0000007f
MOD = int(1e09) + 7
INF = int(1e15)
def main():
# sys.stdin = open("sample.txt")
N = Scanner.int()
if N % 2 == 1:
print((0))
else:
ans = 0
while N > 0:
ans += (N // 5) // 2
N //= 5
print(ans)
if __name__ == "__main__":
main()
| # -*- coding: utf-8 -*-
import sys
import math
import os
import itertools
import string
import heapq
import _collections
from collections import Counter
from collections import defaultdict
from collections import deque
from functools import lru_cache
import bisect
import re
import queue
import decimal
class Scanner():
@staticmethod
def int():
return int(sys.stdin.readline().rstrip())
@staticmethod
def string():
return sys.stdin.readline().rstrip()
@staticmethod
def map_int():
return [int(x) for x in Scanner.string().split()]
@staticmethod
def string_list(n):
return [Scanner.string() for i in range(n)]
@staticmethod
def int_list_list(n):
return [Scanner.map_int() for i in range(n)]
@staticmethod
def int_cols_list(n):
return [Scanner.int() for i in range(n)]
class Math():
@staticmethod
def gcd(a, b):
if b == 0:
return a
return Math.gcd(b, a % b)
@staticmethod
def lcm(a, b):
return (a * b) // Math.gcd(a, b)
@staticmethod
def divisor(n):
res = []
i = 1
for i in range(1, int(n ** 0.5) + 1):
if n % i == 0:
res.append(i)
if i != n // i:
res.append(n // i)
return res
@staticmethod
def round_up(a, b):
return -(-a // b)
@staticmethod
def is_prime(n):
if n < 2:
return False
if n == 2:
return True
if n % 2 == 0:
return False
d = int(n ** 0.5) + 1
for i in range(3, d + 1, 2):
if n % i == 0:
return False
return True
@staticmethod
def fact(N):
res = {}
tmp = N
for i in range(2, int(N ** 0.5 + 1) + 1):
cnt = 0
while tmp % i == 0:
cnt += 1
tmp //= i
if cnt > 0:
res[i] = cnt
if tmp != 1:
res[tmp] = 1
if res == {}:
res[N] = 1
return res
def pop_count(x):
x = x - ((x >> 1) & 0x5555555555555555)
x = (x & 0x3333333333333333) + ((x >> 2) & 0x3333333333333333)
x = (x + (x >> 4)) & 0x0f0f0f0f0f0f0f0f
x = x + (x >> 8)
x = x + (x >> 16)
x = x + (x >> 32)
return x & 0x0000007f
MOD = int(1e09) + 7
INF = int(1e15)
def solve():
N = Scanner.int()
if N % 2 == 1:
print((0))
return
ans = 0
while N > 0:
ans += N // 10
N //= 5
print(ans)
def main():
# sys.stdin = open("sample.txt")
# T = Scanner.int()
# for _ in range(T):
# solve()
# print('YNeos'[not solve()::2])
solve()
if __name__ == "__main__":
main()
| 113 | 139 | 2,376 | 2,930 | # -*- coding: utf-8 -*-
import sys
import math
import os
import itertools
import string
import heapq
import _collections
from collections import Counter
from collections import defaultdict
from functools import lru_cache
import bisect
import re
import queue
from decimal import *
class Scanner:
@staticmethod
def int():
return int(sys.stdin.readline().rstrip())
@staticmethod
def string():
return sys.stdin.readline().rstrip()
@staticmethod
def map_int():
return [int(x) for x in Scanner.string().split()]
@staticmethod
def string_list(n):
return [eval(input()) for i in range(n)]
@staticmethod
def int_list_list(n):
return [Scanner.map_int() for i in range(n)]
@staticmethod
def int_cols_list(n):
return [int(eval(input())) for i in range(n)]
class Math:
@staticmethod
def gcd(a, b):
if b == 0:
return a
return Math.gcd(b, a % b)
@staticmethod
def lcm(a, b):
return (a * b) // Math.gcd(a, b)
@staticmethod
def divisor(n):
res = []
i = 1
for i in range(1, int(n**0.5) + 1):
if n % i == 0:
res.append(i)
if i != n // i:
res.append(n // i)
return res
@staticmethod
def round_up(a, b):
return -(-a // b)
@staticmethod
def is_prime(n):
if n < 2:
return False
if n == 2:
return True
if n % 2 == 0:
return False
d = int(n**0.5) + 1
for i in range(3, d + 1, 2):
if n % i == 0:
return False
return True
def pop_count(x):
x = x - ((x >> 1) & 0x5555555555555555)
x = (x & 0x3333333333333333) + ((x >> 2) & 0x3333333333333333)
x = (x + (x >> 4)) & 0x0F0F0F0F0F0F0F0F
x = x + (x >> 8)
x = x + (x >> 16)
x = x + (x >> 32)
return x & 0x0000007F
MOD = int(1e09) + 7
INF = int(1e15)
def main():
# sys.stdin = open("sample.txt")
N = Scanner.int()
if N % 2 == 1:
print((0))
else:
ans = 0
while N > 0:
ans += (N // 5) // 2
N //= 5
print(ans)
if __name__ == "__main__":
main()
| # -*- coding: utf-8 -*-
import sys
import math
import os
import itertools
import string
import heapq
import _collections
from collections import Counter
from collections import defaultdict
from collections import deque
from functools import lru_cache
import bisect
import re
import queue
import decimal
class Scanner:
@staticmethod
def int():
return int(sys.stdin.readline().rstrip())
@staticmethod
def string():
return sys.stdin.readline().rstrip()
@staticmethod
def map_int():
return [int(x) for x in Scanner.string().split()]
@staticmethod
def string_list(n):
return [Scanner.string() for i in range(n)]
@staticmethod
def int_list_list(n):
return [Scanner.map_int() for i in range(n)]
@staticmethod
def int_cols_list(n):
return [Scanner.int() for i in range(n)]
class Math:
@staticmethod
def gcd(a, b):
if b == 0:
return a
return Math.gcd(b, a % b)
@staticmethod
def lcm(a, b):
return (a * b) // Math.gcd(a, b)
@staticmethod
def divisor(n):
res = []
i = 1
for i in range(1, int(n**0.5) + 1):
if n % i == 0:
res.append(i)
if i != n // i:
res.append(n // i)
return res
@staticmethod
def round_up(a, b):
return -(-a // b)
@staticmethod
def is_prime(n):
if n < 2:
return False
if n == 2:
return True
if n % 2 == 0:
return False
d = int(n**0.5) + 1
for i in range(3, d + 1, 2):
if n % i == 0:
return False
return True
@staticmethod
def fact(N):
res = {}
tmp = N
for i in range(2, int(N**0.5 + 1) + 1):
cnt = 0
while tmp % i == 0:
cnt += 1
tmp //= i
if cnt > 0:
res[i] = cnt
if tmp != 1:
res[tmp] = 1
if res == {}:
res[N] = 1
return res
def pop_count(x):
x = x - ((x >> 1) & 0x5555555555555555)
x = (x & 0x3333333333333333) + ((x >> 2) & 0x3333333333333333)
x = (x + (x >> 4)) & 0x0F0F0F0F0F0F0F0F
x = x + (x >> 8)
x = x + (x >> 16)
x = x + (x >> 32)
return x & 0x0000007F
MOD = int(1e09) + 7
INF = int(1e15)
def solve():
N = Scanner.int()
if N % 2 == 1:
print((0))
return
ans = 0
while N > 0:
ans += N // 10
N //= 5
print(ans)
def main():
# sys.stdin = open("sample.txt")
# T = Scanner.int()
# for _ in range(T):
# solve()
# print('YNeos'[not solve()::2])
solve()
if __name__ == "__main__":
main()
| false | 18.705036 | [
"+from collections import deque",
"-from decimal import *",
"+import decimal",
"- return [eval(input()) for i in range(n)]",
"+ return [Scanner.string() for i in range(n)]",
"- return [int(eval(input())) for i in range(n)]",
"+ return [Scanner.int() for i in range(n)]",
"+ @staticmethod",
"+ def fact(N):",
"+ res = {}",
"+ tmp = N",
"+ for i in range(2, int(N**0.5 + 1) + 1):",
"+ cnt = 0",
"+ while tmp % i == 0:",
"+ cnt += 1",
"+ tmp //= i",
"+ if cnt > 0:",
"+ res[i] = cnt",
"+ if tmp != 1:",
"+ res[tmp] = 1",
"+ if res == {}:",
"+ res[N] = 1",
"+ return res",
"+",
"-def main():",
"- # sys.stdin = open(\"sample.txt\")",
"+def solve():",
"- else:",
"- ans = 0",
"- while N > 0:",
"- ans += (N // 5) // 2",
"- N //= 5",
"- print(ans)",
"+ return",
"+ ans = 0",
"+ while N > 0:",
"+ ans += N // 10",
"+ N //= 5",
"+ print(ans)",
"+",
"+",
"+def main():",
"+ # sys.stdin = open(\"sample.txt\")",
"+ # T = Scanner.int()",
"+ # for _ in range(T):",
"+ # solve()",
"+ # print('YNeos'[not solve()::2])",
"+ solve()"
]
| false | 0.039626 | 0.070715 | 0.560353 | [
"s549531635",
"s862283187"
]
|
u811817592 | p02660 | python | s647492517 | s733256144 | 148 | 95 | 9,496 | 9,472 | Accepted | Accepted | 35.81 | # -*- coding: utf-8 -*-
import collections
# factrize
def factorize(target_number):
factor = 2
factor_list = []
while factor * factor <= target_number:
while target_number % factor == 0:
target_number //= factor
factor_list.append(factor)
factor += 1
if target_number > 1:
factor_list.append(target_number)
return factor_list
N = int(eval(input()))
fact_list = factorize(N)
fact_counter_dict = collections.Counter(fact_list)
ans = 0
for fact, freq in list(fact_counter_dict.items()):
freq_copy = freq
for i in range(1, freq + 1):
freq_copy -= i
if freq_copy < 0:
break
ans += 1
print(ans) | # -*- coding: utf-8 -*-
import collections
# factrize
def factorize(target_number):
factor_list = []
while target_number % 2 == 0:
factor_list.append(2)
target_number //= 2
factor = 3
while factor * factor <= target_number:
while target_number % factor == 0:
target_number //= factor
factor_list.append(factor)
factor += 2
if target_number > 1:
factor_list.append(target_number)
return factor_list
N = int(eval(input()))
fact_list = factorize(N)
fact_counter_dict = collections.Counter(fact_list)
ans = 0
for fact, freq in list(fact_counter_dict.items()):
freq_copy = freq
for i in range(1, freq + 1):
freq_copy -= i
if freq_copy < 0:
break
ans += 1
print(ans) | 29 | 32 | 719 | 814 | # -*- coding: utf-8 -*-
import collections
# factrize
def factorize(target_number):
factor = 2
factor_list = []
while factor * factor <= target_number:
while target_number % factor == 0:
target_number //= factor
factor_list.append(factor)
factor += 1
if target_number > 1:
factor_list.append(target_number)
return factor_list
N = int(eval(input()))
fact_list = factorize(N)
fact_counter_dict = collections.Counter(fact_list)
ans = 0
for fact, freq in list(fact_counter_dict.items()):
freq_copy = freq
for i in range(1, freq + 1):
freq_copy -= i
if freq_copy < 0:
break
ans += 1
print(ans)
| # -*- coding: utf-8 -*-
import collections
# factrize
def factorize(target_number):
factor_list = []
while target_number % 2 == 0:
factor_list.append(2)
target_number //= 2
factor = 3
while factor * factor <= target_number:
while target_number % factor == 0:
target_number //= factor
factor_list.append(factor)
factor += 2
if target_number > 1:
factor_list.append(target_number)
return factor_list
N = int(eval(input()))
fact_list = factorize(N)
fact_counter_dict = collections.Counter(fact_list)
ans = 0
for fact, freq in list(fact_counter_dict.items()):
freq_copy = freq
for i in range(1, freq + 1):
freq_copy -= i
if freq_copy < 0:
break
ans += 1
print(ans)
| false | 9.375 | [
"- factor = 2",
"+ while target_number % 2 == 0:",
"+ factor_list.append(2)",
"+ target_number //= 2",
"+ factor = 3",
"- factor += 1",
"+ factor += 2"
]
| false | 0.046745 | 0.156275 | 0.299123 | [
"s647492517",
"s733256144"
]
|
u505830998 | p02642 | python | s353565744 | s444784545 | 227 | 197 | 122,084 | 124,220 | Accepted | Accepted | 13.22 | import sys
input_methods=['clipboard','file','key']
using_method=0
input_method=input_methods[using_method]
tin=lambda : list(map(int, input().split()))
lin=lambda : list(tin())
mod=1000000007
#+++++
def main():
n = int(eval(input()))
#b , c = tin()
#s = input()
al=lin()
vm=10**6+1
rr = [0]*(vm)
for v in al:
rr[v]+=1
for v in list(set(al)):
for i in range(2*v, vm, v):
rr[i]=0
ret = rr.count(1)
print(ret)
#+++++
isTest=False
def pa(v):
if isTest:
print(v)
def input_clipboard():
import clipboard
input_text=clipboard.get()
input_l=input_text.splitlines()
for l in input_l:
yield l
if __name__ == "__main__":
if sys.platform =='ios':
if input_method==input_methods[0]:
ic=input_clipboard()
input = lambda : ic.__next__()
elif input_method==input_methods[1]:
sys.stdin=open('inputFile.txt')
else:
pass
isTest=True
else:
pass
#input = sys.stdin.readline
ret = main()
if ret is not None:
print(ret) | import sys
input_methods=['clipboard','file','key']
using_method=0
input_method=input_methods[using_method]
tin=lambda : list(map(int, input().split()))
lin=lambda : list(tin())
mod=1000000007
#+++++
def main():
n = int(eval(input()))
#b , c = tin()
#s = input()
al=lin()
vm=10**6+1
rr = [0]*(vm)
for v in al:
rr[v]+=1
ual=list(set(al))
ual.sort()
for v in ual:
if rr[v]==0:
continue
for i in range(2*v, vm, v):
rr[i]=0
ret = rr.count(1)
print(ret)
#+++++
isTest=False
def pa(v):
if isTest:
print(v)
def input_clipboard():
import clipboard
input_text=clipboard.get()
input_l=input_text.splitlines()
for l in input_l:
yield l
if __name__ == "__main__":
if sys.platform =='ios':
if input_method==input_methods[0]:
ic=input_clipboard()
input = lambda : ic.__next__()
elif input_method==input_methods[1]:
sys.stdin=open('inputFile.txt')
else:
pass
isTest=True
else:
pass
#input = sys.stdin.readline
ret = main()
if ret is not None:
print(ret) | 59 | 62 | 1,016 | 1,065 | import sys
input_methods = ["clipboard", "file", "key"]
using_method = 0
input_method = input_methods[using_method]
tin = lambda: list(map(int, input().split()))
lin = lambda: list(tin())
mod = 1000000007
# +++++
def main():
n = int(eval(input()))
# b , c = tin()
# s = input()
al = lin()
vm = 10**6 + 1
rr = [0] * (vm)
for v in al:
rr[v] += 1
for v in list(set(al)):
for i in range(2 * v, vm, v):
rr[i] = 0
ret = rr.count(1)
print(ret)
# +++++
isTest = False
def pa(v):
if isTest:
print(v)
def input_clipboard():
import clipboard
input_text = clipboard.get()
input_l = input_text.splitlines()
for l in input_l:
yield l
if __name__ == "__main__":
if sys.platform == "ios":
if input_method == input_methods[0]:
ic = input_clipboard()
input = lambda: ic.__next__()
elif input_method == input_methods[1]:
sys.stdin = open("inputFile.txt")
else:
pass
isTest = True
else:
pass
# input = sys.stdin.readline
ret = main()
if ret is not None:
print(ret)
| import sys
input_methods = ["clipboard", "file", "key"]
using_method = 0
input_method = input_methods[using_method]
tin = lambda: list(map(int, input().split()))
lin = lambda: list(tin())
mod = 1000000007
# +++++
def main():
n = int(eval(input()))
# b , c = tin()
# s = input()
al = lin()
vm = 10**6 + 1
rr = [0] * (vm)
for v in al:
rr[v] += 1
ual = list(set(al))
ual.sort()
for v in ual:
if rr[v] == 0:
continue
for i in range(2 * v, vm, v):
rr[i] = 0
ret = rr.count(1)
print(ret)
# +++++
isTest = False
def pa(v):
if isTest:
print(v)
def input_clipboard():
import clipboard
input_text = clipboard.get()
input_l = input_text.splitlines()
for l in input_l:
yield l
if __name__ == "__main__":
if sys.platform == "ios":
if input_method == input_methods[0]:
ic = input_clipboard()
input = lambda: ic.__next__()
elif input_method == input_methods[1]:
sys.stdin = open("inputFile.txt")
else:
pass
isTest = True
else:
pass
# input = sys.stdin.readline
ret = main()
if ret is not None:
print(ret)
| false | 4.83871 | [
"- for v in list(set(al)):",
"+ ual = list(set(al))",
"+ ual.sort()",
"+ for v in ual:",
"+ if rr[v] == 0:",
"+ continue"
]
| false | 0.109391 | 0.085654 | 1.277117 | [
"s353565744",
"s444784545"
]
|
u968166680 | p02845 | python | s468895808 | s539171818 | 265 | 76 | 12,404 | 14,044 | Accepted | Accepted | 71.32 | def main():
import sys
MOD = 1000000007
N, *A = list(map(int, sys.stdin.buffer.read().split()))
C = [0] * (N + 1)
C[0] = 3
ans = 1
for a in A:
ans = ans * C[a]
C[a] -= 1
C[a + 1] += 1
print((ans % MOD))
return
if __name__ == '__main__':
main()
| import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
def main():
MOD = 1000000007
N, *A = list(map(int, read().split()))
ans = 1
C = [0, 0, 0]
for a in A:
try:
ans = (ans * C.count(a)) % MOD
C[C.index(a)] += 1
except ValueError:
print((0))
return
print(ans)
return
if __name__ == '__main__':
main()
| 19 | 29 | 322 | 509 | def main():
import sys
MOD = 1000000007
N, *A = list(map(int, sys.stdin.buffer.read().split()))
C = [0] * (N + 1)
C[0] = 3
ans = 1
for a in A:
ans = ans * C[a]
C[a] -= 1
C[a + 1] += 1
print((ans % MOD))
return
if __name__ == "__main__":
main()
| import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10**9)
INF = 1 << 60
def main():
MOD = 1000000007
N, *A = list(map(int, read().split()))
ans = 1
C = [0, 0, 0]
for a in A:
try:
ans = (ans * C.count(a)) % MOD
C[C.index(a)] += 1
except ValueError:
print((0))
return
print(ans)
return
if __name__ == "__main__":
main()
| false | 34.482759 | [
"+import sys",
"+",
"+read = sys.stdin.read",
"+readline = sys.stdin.readline",
"+readlines = sys.stdin.readlines",
"+sys.setrecursionlimit(10**9)",
"+INF = 1 << 60",
"+",
"+",
"- import sys",
"-",
"- N, *A = list(map(int, sys.stdin.buffer.read().split()))",
"- C = [0] * (N + 1)",
"- C[0] = 3",
"+ N, *A = list(map(int, read().split()))",
"+ C = [0, 0, 0]",
"- ans = ans * C[a]",
"- C[a] -= 1",
"- C[a + 1] += 1",
"- print((ans % MOD))",
"+ try:",
"+ ans = (ans * C.count(a)) % MOD",
"+ C[C.index(a)] += 1",
"+ except ValueError:",
"+ print((0))",
"+ return",
"+ print(ans)"
]
| false | 0.035811 | 0.076664 | 0.467114 | [
"s468895808",
"s539171818"
]
|
u644907318 | p03623 | python | s368570184 | s163292335 | 350 | 64 | 64,632 | 61,584 | Accepted | Accepted | 81.71 | x,a,b = list(map(int,input().split()))
if abs(x-a)>abs(x-b):
print("B")
else:
print("A") | x,a,b = list(map(int,input().split()))
if abs(a-x)<abs(b-x):
print("A")
else:
print("B") | 5 | 5 | 94 | 94 | x, a, b = list(map(int, input().split()))
if abs(x - a) > abs(x - b):
print("B")
else:
print("A")
| x, a, b = list(map(int, input().split()))
if abs(a - x) < abs(b - x):
print("A")
else:
print("B")
| false | 0 | [
"-if abs(x - a) > abs(x - b):",
"+if abs(a - x) < abs(b - x):",
"+ print(\"A\")",
"+else:",
"-else:",
"- print(\"A\")"
]
| false | 0.03448 | 0.033892 | 1.017357 | [
"s368570184",
"s163292335"
]
|
u353895424 | p03472 | python | s032152008 | s413065780 | 630 | 567 | 28,904 | 29,024 | Accepted | Accepted | 10 | from operator import itemgetter
import math
n, h = list(map(int, input().split()))
ab = []
A = 0
B = 1
maxA = 0
for i in range(n):
ab.append(list(map(int, input().split())))
maxA = max(maxA, ab[i][A])
ab.sort(key=itemgetter(B), reverse=True)
sumB = 0
for _ab in ab:
sumB += _ab[B]
ans = 0
damage = 0
i = 0
while damage < h and ans < n:
damage += max(maxA, ab[ans][B])
ans += 1
ab.sort(key=itemgetter(A), reverse=True)
if damage < h:
ans += math.ceil((h - damage)/ab[0][A])
print(ans) | from operator import itemgetter
import math
n, h = list(map(int, input().split()))
ab = []
A = 0
B = 1
maxA = 0
for i in range(n):
ab.append(list(map(int, input().split())))
maxA = max(maxA, ab[i][A])
ab.sort(key=itemgetter(B), reverse=True)
sumB = 0
for _ab in ab:
sumB += _ab[B]
ans = 0
damage = 0
i = 0
while damage < h and ans < n:
damage += max(maxA, ab[ans][B])
ans += 1
if damage < h:
ans += math.ceil((h - damage)/maxA)
print(ans) | 31 | 29 | 538 | 490 | from operator import itemgetter
import math
n, h = list(map(int, input().split()))
ab = []
A = 0
B = 1
maxA = 0
for i in range(n):
ab.append(list(map(int, input().split())))
maxA = max(maxA, ab[i][A])
ab.sort(key=itemgetter(B), reverse=True)
sumB = 0
for _ab in ab:
sumB += _ab[B]
ans = 0
damage = 0
i = 0
while damage < h and ans < n:
damage += max(maxA, ab[ans][B])
ans += 1
ab.sort(key=itemgetter(A), reverse=True)
if damage < h:
ans += math.ceil((h - damage) / ab[0][A])
print(ans)
| from operator import itemgetter
import math
n, h = list(map(int, input().split()))
ab = []
A = 0
B = 1
maxA = 0
for i in range(n):
ab.append(list(map(int, input().split())))
maxA = max(maxA, ab[i][A])
ab.sort(key=itemgetter(B), reverse=True)
sumB = 0
for _ab in ab:
sumB += _ab[B]
ans = 0
damage = 0
i = 0
while damage < h and ans < n:
damage += max(maxA, ab[ans][B])
ans += 1
if damage < h:
ans += math.ceil((h - damage) / maxA)
print(ans)
| false | 6.451613 | [
"-ab.sort(key=itemgetter(A), reverse=True)",
"- ans += math.ceil((h - damage) / ab[0][A])",
"+ ans += math.ceil((h - damage) / maxA)"
]
| false | 0.034234 | 0.032989 | 1.037754 | [
"s032152008",
"s413065780"
]
|
u994988729 | p03168 | python | s290631716 | s356171966 | 1,029 | 297 | 22,404 | 21,908 | Accepted | Accepted | 71.14 | import numpy as np
N = int(eval(input()))
P = np.array(input().split(), dtype=float)
dp = np.zeros(N + 1, dtype=float)
dp[0] = 1
for p in P:
newDP = dp * (1-p)
newDP[1:] += dp[:-1] * p
dp = newDP
n = (N + 1) // 2
ans = dp[n:].sum()
print(ans)
| import numpy as np
N = int(eval(input()))
P = tuple(map(float, input().split()))
dp = np.zeros(N + 1, dtype=float)
dp[0] = 1
for p in P:
newDP = dp * (1-p)
newDP[1:] += dp[:-1] * p
dp = newDP
n = (N + 1) // 2
ans = dp[n:].sum()
print(ans)
| 15 | 15 | 266 | 262 | import numpy as np
N = int(eval(input()))
P = np.array(input().split(), dtype=float)
dp = np.zeros(N + 1, dtype=float)
dp[0] = 1
for p in P:
newDP = dp * (1 - p)
newDP[1:] += dp[:-1] * p
dp = newDP
n = (N + 1) // 2
ans = dp[n:].sum()
print(ans)
| import numpy as np
N = int(eval(input()))
P = tuple(map(float, input().split()))
dp = np.zeros(N + 1, dtype=float)
dp[0] = 1
for p in P:
newDP = dp * (1 - p)
newDP[1:] += dp[:-1] * p
dp = newDP
n = (N + 1) // 2
ans = dp[n:].sum()
print(ans)
| false | 0 | [
"-P = np.array(input().split(), dtype=float)",
"+P = tuple(map(float, input().split()))"
]
| false | 0.521692 | 0.418551 | 1.246423 | [
"s290631716",
"s356171966"
]
|
u924691798 | p02837 | python | s379862855 | s473277676 | 1,373 | 175 | 3,188 | 3,064 | Accepted | Accepted | 87.25 | N = int(eval(input()))
A = [0]*N
X = []
Y = []
for i in range(N):
A[i] = int(eval(input()))
X.append([])
Y.append([])
for j in range(A[i]):
x, y = list(map(int, input().split()))
X[i].append(x-1)
Y[i].append(y)
ans = 0
for bit in range(1<<N):
honest = 0
ok = True
for i in range(N):
if bit&(1<<i):
honest += 1
for j in range(A[i]):
if Y[i][j] == 0:
if bit&(1<<X[i][j]):
ok = False
else:
if not bit&(1<<X[i][j]):
ok = False
if ok:
ans = max(ans, honest)
print(ans) | N = int(eval(input()))
A = [0]*N
X = []
Y = []
for i in range(N):
A[i] = int(eval(input()))
X.append([])
Y.append([])
for j in range(A[i]):
x, y = list(map(int, input().split()))
X[i].append(x-1)
Y[i].append(y)
ans = 0
for bit in range(1<<N):
honest = 0
ok = True
for i in range(N):
if bit&(1<<i):
honest += 1
for j in range(A[i]):
if Y[i][j] == 0:
if bit&(1<<X[i][j]):
ok = False
break
else:
if not bit&(1<<X[i][j]):
ok = False
break
if not ok:
break
if ok:
ans = max(ans, honest)
print(ans) | 29 | 33 | 689 | 798 | N = int(eval(input()))
A = [0] * N
X = []
Y = []
for i in range(N):
A[i] = int(eval(input()))
X.append([])
Y.append([])
for j in range(A[i]):
x, y = list(map(int, input().split()))
X[i].append(x - 1)
Y[i].append(y)
ans = 0
for bit in range(1 << N):
honest = 0
ok = True
for i in range(N):
if bit & (1 << i):
honest += 1
for j in range(A[i]):
if Y[i][j] == 0:
if bit & (1 << X[i][j]):
ok = False
else:
if not bit & (1 << X[i][j]):
ok = False
if ok:
ans = max(ans, honest)
print(ans)
| N = int(eval(input()))
A = [0] * N
X = []
Y = []
for i in range(N):
A[i] = int(eval(input()))
X.append([])
Y.append([])
for j in range(A[i]):
x, y = list(map(int, input().split()))
X[i].append(x - 1)
Y[i].append(y)
ans = 0
for bit in range(1 << N):
honest = 0
ok = True
for i in range(N):
if bit & (1 << i):
honest += 1
for j in range(A[i]):
if Y[i][j] == 0:
if bit & (1 << X[i][j]):
ok = False
break
else:
if not bit & (1 << X[i][j]):
ok = False
break
if not ok:
break
if ok:
ans = max(ans, honest)
print(ans)
| false | 12.121212 | [
"+ break",
"+ break",
"+ if not ok:",
"+ break"
]
| false | 0.038043 | 0.037555 | 1.012991 | [
"s379862855",
"s473277676"
]
|
u707498674 | p02714 | python | s526491161 | s096626733 | 1,596 | 1,101 | 70,032 | 9,220 | Accepted | Accepted | 31.02 | import sys
def input(): return sys.stdin.readline().strip()
def main():
N = int(eval(input()))
S = eval(input())
sub_sum = {key : [0]*N for key in "RGB"}
for i, key in enumerate(S):
sub_sum[key][i] = 1
for i in range(1, N):
for key in "RGB":
sub_sum[key][i] += sub_sum[key][i-1]
ans = 0
for i in range(1, N):
now = S[i]
right_nums = {key:sub_sum[key][N-1]-sub_sum[key][i-1] for key in "RGB"}
for j in range(i):
left = S[j]
right = [c for c in "RGB" if c not in [now, left]][0]
right_num = right_nums[right]
if now != left:
if 2*i - j < N and right_num:
if S[2*i - j] == right:
right_num -= 1
ans += right_num
print(ans)
if __name__ == "__main__":
main() | import sys
def input() : return sys.stdin.readline().strip()
def main():
N = int(eval(input()))
S = eval(input())
r = S.count("R")
g = S.count("G")
b = N-r-g
all_num = r*g*b
sub = 0
for i in range(N):
for j in range(i+1, N):
if S[i] == S[j]: continue
k = j + (j - i)
if k >= N or S[k] == S[i] or S[k] == S[j]: continue
sub += 1
print((all_num - sub))
if __name__ == "__main__":
main() | 35 | 22 | 904 | 490 | import sys
def input():
return sys.stdin.readline().strip()
def main():
N = int(eval(input()))
S = eval(input())
sub_sum = {key: [0] * N for key in "RGB"}
for i, key in enumerate(S):
sub_sum[key][i] = 1
for i in range(1, N):
for key in "RGB":
sub_sum[key][i] += sub_sum[key][i - 1]
ans = 0
for i in range(1, N):
now = S[i]
right_nums = {key: sub_sum[key][N - 1] - sub_sum[key][i - 1] for key in "RGB"}
for j in range(i):
left = S[j]
right = [c for c in "RGB" if c not in [now, left]][0]
right_num = right_nums[right]
if now != left:
if 2 * i - j < N and right_num:
if S[2 * i - j] == right:
right_num -= 1
ans += right_num
print(ans)
if __name__ == "__main__":
main()
| import sys
def input():
return sys.stdin.readline().strip()
def main():
N = int(eval(input()))
S = eval(input())
r = S.count("R")
g = S.count("G")
b = N - r - g
all_num = r * g * b
sub = 0
for i in range(N):
for j in range(i + 1, N):
if S[i] == S[j]:
continue
k = j + (j - i)
if k >= N or S[k] == S[i] or S[k] == S[j]:
continue
sub += 1
print((all_num - sub))
if __name__ == "__main__":
main()
| false | 37.142857 | [
"- sub_sum = {key: [0] * N for key in \"RGB\"}",
"- for i, key in enumerate(S):",
"- sub_sum[key][i] = 1",
"- for i in range(1, N):",
"- for key in \"RGB\":",
"- sub_sum[key][i] += sub_sum[key][i - 1]",
"- ans = 0",
"- for i in range(1, N):",
"- now = S[i]",
"- right_nums = {key: sub_sum[key][N - 1] - sub_sum[key][i - 1] for key in \"RGB\"}",
"- for j in range(i):",
"- left = S[j]",
"- right = [c for c in \"RGB\" if c not in [now, left]][0]",
"- right_num = right_nums[right]",
"- if now != left:",
"- if 2 * i - j < N and right_num:",
"- if S[2 * i - j] == right:",
"- right_num -= 1",
"- ans += right_num",
"- print(ans)",
"+ r = S.count(\"R\")",
"+ g = S.count(\"G\")",
"+ b = N - r - g",
"+ all_num = r * g * b",
"+ sub = 0",
"+ for i in range(N):",
"+ for j in range(i + 1, N):",
"+ if S[i] == S[j]:",
"+ continue",
"+ k = j + (j - i)",
"+ if k >= N or S[k] == S[i] or S[k] == S[j]:",
"+ continue",
"+ sub += 1",
"+ print((all_num - sub))"
]
| false | 0.074081 | 0.097737 | 0.75797 | [
"s526491161",
"s096626733"
]
|
u847467233 | p00534 | python | s256697638 | s708041408 | 1,170 | 830 | 5,640 | 19,124 | Accepted | Accepted | 29.06 | # AOJ 0611: Silk Road
# Python3 2018.7.4 bal4u
import sys
from sys import stdin
input = stdin.readline
INF = 0x7fffffff
n, m = list(map(int, input().split()))
d = [int(eval(input())) for i in range(n)]
c = [0] + [int(eval(input())) for i in range(m)]
dp = [[INF for j in range(n+1)] for i in range(2)]
dp[0][0] = 0
for i in range(1, m+1):
for j in range(n+1): dp[i&1][j] = INF
for j in range(n+1): dp[i&1][j] = dp[1-(i&1)][j]
for j in range(n):
if dp[1-(i&1)][j] != INF:
dp[i&1][j+1] = min(dp[i&1][j+1], dp[1-(i&1)][j]+c[i]*d[j])
print((dp[i&1][n]))
| # AOJ 0611: Silk Road
# Python3 2018.7.4 bal4u
import sys
from sys import stdin
input = stdin.readline
INF = 0x7fffffff
n, m = list(map(int, input().split()))
d = [int(eval(input())) for i in range(n)]
c = [int(eval(input())) for i in range(m)]
dp = [[INF for j in range(n+1)] for i in range(m+1)]
dp[0][0] = 0
for i in range(m):
for j in range(n+1): dp[i+1][j] = dp[i][j]
for j in range(n):
if dp[i][j] != INF:
dp[i+1][j+1] = min(dp[i+1][j+1], dp[i][j]+c[i]*d[j])
print((dp[m][n]))
| 20 | 19 | 559 | 490 | # AOJ 0611: Silk Road
# Python3 2018.7.4 bal4u
import sys
from sys import stdin
input = stdin.readline
INF = 0x7FFFFFFF
n, m = list(map(int, input().split()))
d = [int(eval(input())) for i in range(n)]
c = [0] + [int(eval(input())) for i in range(m)]
dp = [[INF for j in range(n + 1)] for i in range(2)]
dp[0][0] = 0
for i in range(1, m + 1):
for j in range(n + 1):
dp[i & 1][j] = INF
for j in range(n + 1):
dp[i & 1][j] = dp[1 - (i & 1)][j]
for j in range(n):
if dp[1 - (i & 1)][j] != INF:
dp[i & 1][j + 1] = min(dp[i & 1][j + 1], dp[1 - (i & 1)][j] + c[i] * d[j])
print((dp[i & 1][n]))
| # AOJ 0611: Silk Road
# Python3 2018.7.4 bal4u
import sys
from sys import stdin
input = stdin.readline
INF = 0x7FFFFFFF
n, m = list(map(int, input().split()))
d = [int(eval(input())) for i in range(n)]
c = [int(eval(input())) for i in range(m)]
dp = [[INF for j in range(n + 1)] for i in range(m + 1)]
dp[0][0] = 0
for i in range(m):
for j in range(n + 1):
dp[i + 1][j] = dp[i][j]
for j in range(n):
if dp[i][j] != INF:
dp[i + 1][j + 1] = min(dp[i + 1][j + 1], dp[i][j] + c[i] * d[j])
print((dp[m][n]))
| false | 5 | [
"-c = [0] + [int(eval(input())) for i in range(m)]",
"-dp = [[INF for j in range(n + 1)] for i in range(2)]",
"+c = [int(eval(input())) for i in range(m)]",
"+dp = [[INF for j in range(n + 1)] for i in range(m + 1)]",
"-for i in range(1, m + 1):",
"+for i in range(m):",
"- dp[i & 1][j] = INF",
"- for j in range(n + 1):",
"- dp[i & 1][j] = dp[1 - (i & 1)][j]",
"+ dp[i + 1][j] = dp[i][j]",
"- if dp[1 - (i & 1)][j] != INF:",
"- dp[i & 1][j + 1] = min(dp[i & 1][j + 1], dp[1 - (i & 1)][j] + c[i] * d[j])",
"-print((dp[i & 1][n]))",
"+ if dp[i][j] != INF:",
"+ dp[i + 1][j + 1] = min(dp[i + 1][j + 1], dp[i][j] + c[i] * d[j])",
"+print((dp[m][n]))"
]
| false | 0.035204 | 0.038944 | 0.903965 | [
"s256697638",
"s708041408"
]
|
u471214054 | p02755 | python | s585431030 | s394465535 | 20 | 18 | 3,060 | 3,060 | Accepted | Accepted | 10 | from math import floor
def main():
a, b = list(map(int, input().split()))
ans = -1
for i in range(10000):
if floor(i * 0.08) == a and floor(i * 0.1) == b:
ans = i
break
print(ans)
if __name__ == "__main__":
main() | from math import floor
def main():
a, b = list(map(int, input().split()))
ans = -1
for i in range(1, 1001):
if floor(i * 0.08) == a and floor(i * 0.1) == b:
ans = i
break
print(ans)
if __name__ == "__main__":
main() | 14 | 14 | 279 | 281 | from math import floor
def main():
a, b = list(map(int, input().split()))
ans = -1
for i in range(10000):
if floor(i * 0.08) == a and floor(i * 0.1) == b:
ans = i
break
print(ans)
if __name__ == "__main__":
main()
| from math import floor
def main():
a, b = list(map(int, input().split()))
ans = -1
for i in range(1, 1001):
if floor(i * 0.08) == a and floor(i * 0.1) == b:
ans = i
break
print(ans)
if __name__ == "__main__":
main()
| false | 0 | [
"- for i in range(10000):",
"+ for i in range(1, 1001):"
]
| false | 0.089451 | 0.049791 | 1.796524 | [
"s585431030",
"s394465535"
]
|
u666772276 | p02586 | python | s527150322 | s032582979 | 700 | 546 | 100,824 | 132,908 | Accepted | Accepted | 22 | rows, cols, k = list(map(int, input().split()))
items = [[] for _ in range(rows+1)]
best = [0]*(cols+1)
for _ in range(k):
r, c, v = list(map(int, input().split()))
items[r].append([c, v])
for i in range(rows+1):
items[i].sort()
ans = 0
for r in range(1, rows+1):
dp = []
best1, best2 = 0, 0
Row = items[r]
for c, v in Row:
v1 = best[c] + v
v2 = best1 + v
v3 = best2 + v
V = max(v1, v2, v3)
dp.append(V)
if v1 > best1:
best1 = v1
if v2 > best2:
best2 = v2
if ans < V:
ans = V
for j in range(len(dp)):
if best[Row[j][0]] < dp[j]:
best[Row[j][0]] = dp[j]
for j in range(2, cols+1):
if best[j] < best[j-1]:
best[j] = best[j-1]
print(ans)
| import sys
inp = [int(x) for x in sys.stdin.read().split()]; ii = 0
rows, cols, k = inp[ii:ii+3]; ii += 3
items = [[] for _ in range(rows+1)]
best = [0]*(cols+1)
for _ in range(k):
r, c, v = inp[ii:ii+3]; ii += 3
items[r].append([c, v])
for i in range(rows+1):
items[i].sort()
ans = 0
for r in range(1, rows+1):
dp = []
best1, best2 = 0, 0
Row = items[r]
for c, v in Row:
v1 = best[c] + v
v2 = best1 + v
v3 = best2 + v
V = v1
if V < v2:
V = v2
if V < v3:
V = v3
dp.append(V)
if v1 > best1:
best1 = v1
if v2 > best2:
best2 = v2
if ans < V:
ans = V
for j in range(len(dp)):
if best[Row[j][0]] < dp[j]:
best[Row[j][0]] = dp[j]
for j in range(2, cols+1):
if best[j] < best[j-1]:
best[j] = best[j-1]
print(ans)
| 32 | 40 | 698 | 801 | rows, cols, k = list(map(int, input().split()))
items = [[] for _ in range(rows + 1)]
best = [0] * (cols + 1)
for _ in range(k):
r, c, v = list(map(int, input().split()))
items[r].append([c, v])
for i in range(rows + 1):
items[i].sort()
ans = 0
for r in range(1, rows + 1):
dp = []
best1, best2 = 0, 0
Row = items[r]
for c, v in Row:
v1 = best[c] + v
v2 = best1 + v
v3 = best2 + v
V = max(v1, v2, v3)
dp.append(V)
if v1 > best1:
best1 = v1
if v2 > best2:
best2 = v2
if ans < V:
ans = V
for j in range(len(dp)):
if best[Row[j][0]] < dp[j]:
best[Row[j][0]] = dp[j]
for j in range(2, cols + 1):
if best[j] < best[j - 1]:
best[j] = best[j - 1]
print(ans)
| import sys
inp = [int(x) for x in sys.stdin.read().split()]
ii = 0
rows, cols, k = inp[ii : ii + 3]
ii += 3
items = [[] for _ in range(rows + 1)]
best = [0] * (cols + 1)
for _ in range(k):
r, c, v = inp[ii : ii + 3]
ii += 3
items[r].append([c, v])
for i in range(rows + 1):
items[i].sort()
ans = 0
for r in range(1, rows + 1):
dp = []
best1, best2 = 0, 0
Row = items[r]
for c, v in Row:
v1 = best[c] + v
v2 = best1 + v
v3 = best2 + v
V = v1
if V < v2:
V = v2
if V < v3:
V = v3
dp.append(V)
if v1 > best1:
best1 = v1
if v2 > best2:
best2 = v2
if ans < V:
ans = V
for j in range(len(dp)):
if best[Row[j][0]] < dp[j]:
best[Row[j][0]] = dp[j]
for j in range(2, cols + 1):
if best[j] < best[j - 1]:
best[j] = best[j - 1]
print(ans)
| false | 20 | [
"-rows, cols, k = list(map(int, input().split()))",
"+import sys",
"+",
"+inp = [int(x) for x in sys.stdin.read().split()]",
"+ii = 0",
"+rows, cols, k = inp[ii : ii + 3]",
"+ii += 3",
"- r, c, v = list(map(int, input().split()))",
"+ r, c, v = inp[ii : ii + 3]",
"+ ii += 3",
"- V = max(v1, v2, v3)",
"+ V = v1",
"+ if V < v2:",
"+ V = v2",
"+ if V < v3:",
"+ V = v3"
]
| false | 0.035986 | 0.037157 | 0.968489 | [
"s527150322",
"s032582979"
]
|
u353797797 | p03179 | python | s006576161 | s059791294 | 1,246 | 659 | 3,064 | 3,064 | Accepted | Accepted | 47.11 | md = 10 ** 9 + 7
n = int(eval(input()))
s = eval(input())
dp = [1] * n
for i in range(n - 1):
if s[i] == "<":
L = dp[0]
for dpi in range(1, n - i - 1):
dp[dpi] = L = (dp[dpi] + L) % md
dp = dp[:-1]
else:
R = dp[-1]
for dpi in range(n - i - 2, 0, -1):
dp[dpi] = R = (dp[dpi] + R) % md
dp = dp[1:]
print((dp[0]))
| def f(n, s):
md = 10 ** 9 + 7
dp = [1] * n
for i in range(n - 1):
if s[i] == "<":
L = dp[0]
for dpi in range(1, n - i - 1):
dp[dpi] = L = (dp[dpi] + L) % md
dp = dp[:-1]
else:
R = dp[-1]
for dpi in range(n - i - 2, 0, -1):
dp[dpi] = R = (dp[dpi] + R) % md
dp = dp[1:]
print((dp[0]))
n = int(eval(input()))
s = eval(input())
f(n, s)
| 16 | 20 | 392 | 475 | md = 10**9 + 7
n = int(eval(input()))
s = eval(input())
dp = [1] * n
for i in range(n - 1):
if s[i] == "<":
L = dp[0]
for dpi in range(1, n - i - 1):
dp[dpi] = L = (dp[dpi] + L) % md
dp = dp[:-1]
else:
R = dp[-1]
for dpi in range(n - i - 2, 0, -1):
dp[dpi] = R = (dp[dpi] + R) % md
dp = dp[1:]
print((dp[0]))
| def f(n, s):
md = 10**9 + 7
dp = [1] * n
for i in range(n - 1):
if s[i] == "<":
L = dp[0]
for dpi in range(1, n - i - 1):
dp[dpi] = L = (dp[dpi] + L) % md
dp = dp[:-1]
else:
R = dp[-1]
for dpi in range(n - i - 2, 0, -1):
dp[dpi] = R = (dp[dpi] + R) % md
dp = dp[1:]
print((dp[0]))
n = int(eval(input()))
s = eval(input())
f(n, s)
| false | 20 | [
"-md = 10**9 + 7",
"+def f(n, s):",
"+ md = 10**9 + 7",
"+ dp = [1] * n",
"+ for i in range(n - 1):",
"+ if s[i] == \"<\":",
"+ L = dp[0]",
"+ for dpi in range(1, n - i - 1):",
"+ dp[dpi] = L = (dp[dpi] + L) % md",
"+ dp = dp[:-1]",
"+ else:",
"+ R = dp[-1]",
"+ for dpi in range(n - i - 2, 0, -1):",
"+ dp[dpi] = R = (dp[dpi] + R) % md",
"+ dp = dp[1:]",
"+ print((dp[0]))",
"+",
"+",
"-dp = [1] * n",
"-for i in range(n - 1):",
"- if s[i] == \"<\":",
"- L = dp[0]",
"- for dpi in range(1, n - i - 1):",
"- dp[dpi] = L = (dp[dpi] + L) % md",
"- dp = dp[:-1]",
"- else:",
"- R = dp[-1]",
"- for dpi in range(n - i - 2, 0, -1):",
"- dp[dpi] = R = (dp[dpi] + R) % md",
"- dp = dp[1:]",
"-print((dp[0]))",
"+f(n, s)"
]
| false | 0.035558 | 0.041087 | 0.865431 | [
"s006576161",
"s059791294"
]
|
u759412327 | p02971 | python | s871878370 | s640843180 | 425 | 367 | 33,932 | 20,080 | Accepted | Accepted | 13.65 | import sys
input = sys.stdin.readline
import numpy as np
N = int(eval(input()))
A = np.array([int(eval(input())) for _ in range(N)])
from_left = np.maximum.accumulate(A)
from_right = np.maximum.accumulate(A[::-1])[::-1]
from_left, from_right
from_left = [0] + from_left.tolist()[:-1]
from_right = from_right[1:].tolist() + [0]
for x,y in zip(from_left, from_right):
print((x if x > y else y))
| N = int(eval(input()))
A = [int(eval(input())) for n in range(N)]
B = sorted(A)[::-1]
a1 = B[0]
a2 = B[1]
if a1==a2:
for n in range(N):
print(a1)
else:
for n in range(N):
if A[n]==a1:
print(a2)
else:
print(a1) | 18 | 15 | 406 | 240 | import sys
input = sys.stdin.readline
import numpy as np
N = int(eval(input()))
A = np.array([int(eval(input())) for _ in range(N)])
from_left = np.maximum.accumulate(A)
from_right = np.maximum.accumulate(A[::-1])[::-1]
from_left, from_right
from_left = [0] + from_left.tolist()[:-1]
from_right = from_right[1:].tolist() + [0]
for x, y in zip(from_left, from_right):
print((x if x > y else y))
| N = int(eval(input()))
A = [int(eval(input())) for n in range(N)]
B = sorted(A)[::-1]
a1 = B[0]
a2 = B[1]
if a1 == a2:
for n in range(N):
print(a1)
else:
for n in range(N):
if A[n] == a1:
print(a2)
else:
print(a1)
| false | 16.666667 | [
"-import sys",
"-",
"-input = sys.stdin.readline",
"-import numpy as np",
"-",
"-A = np.array([int(eval(input())) for _ in range(N)])",
"-from_left = np.maximum.accumulate(A)",
"-from_right = np.maximum.accumulate(A[::-1])[::-1]",
"-from_left, from_right",
"-from_left = [0] + from_left.tolist()[:-1]",
"-from_right = from_right[1:].tolist() + [0]",
"-for x, y in zip(from_left, from_right):",
"- print((x if x > y else y))",
"+A = [int(eval(input())) for n in range(N)]",
"+B = sorted(A)[::-1]",
"+a1 = B[0]",
"+a2 = B[1]",
"+if a1 == a2:",
"+ for n in range(N):",
"+ print(a1)",
"+else:",
"+ for n in range(N):",
"+ if A[n] == a1:",
"+ print(a2)",
"+ else:",
"+ print(a1)"
]
| false | 0.278414 | 0.043697 | 6.371454 | [
"s871878370",
"s640843180"
]
|
u488401358 | p03233 | python | s848743264 | s305633989 | 583 | 519 | 99,464 | 91,664 | Accepted | Accepted | 10.98 | import sys,random
input=sys.stdin.readline
N=int(eval(input()))
A=[-1]*N;B=[-1]*N
for i in range(N):
A[i],B[i]=list(map(int,input().split()))
ans=min(sum(A),sum(B))
temp=[(A[i],i) for i in range(N)]+[(B[i],i) for i in range(N)]
temp.sort()
#print(temp)
data=[0]*N
for i in range(N):
val,id=temp[i]
data[id]+=1
S=sum(temp[i][0] for i in range(N))
for i in range(N):
if data[i]==2:
test=S
ans=min(ans,test)
elif data[i]==1:
if temp[N-1][1]!=i:
test=S+max(A[i],B[i])-temp[N-1][0]
else:
test=S+max(A[i],B[i])-temp[N-2][0]
ans=min(ans,test)
print(ans)
| import sys;input=sys.stdin.readline;N=int(eval(input()));A=[-1]*N;B=[-1]*N
for i in range(N):
A[i],B[i]=list(map(int,input().split()))
ans=min(sum(A),sum(B));temp=[(A[i],i) for i in range(N)]+[(B[i],i) for i in range(N)];temp.sort();data=[0]*N
for i in range(N):data[temp[i][1]]+=1
S=sum(temp[i][0] for i in range(N))
if max(data)==2:
print(S)
else:
for i in range(N):ans=min(ans,S+max(A[i],B[i])-temp[N-1-(temp[N-1][1]==i)][0]);
print(ans)
| 32 | 11 | 656 | 455 | import sys, random
input = sys.stdin.readline
N = int(eval(input()))
A = [-1] * N
B = [-1] * N
for i in range(N):
A[i], B[i] = list(map(int, input().split()))
ans = min(sum(A), sum(B))
temp = [(A[i], i) for i in range(N)] + [(B[i], i) for i in range(N)]
temp.sort()
# print(temp)
data = [0] * N
for i in range(N):
val, id = temp[i]
data[id] += 1
S = sum(temp[i][0] for i in range(N))
for i in range(N):
if data[i] == 2:
test = S
ans = min(ans, test)
elif data[i] == 1:
if temp[N - 1][1] != i:
test = S + max(A[i], B[i]) - temp[N - 1][0]
else:
test = S + max(A[i], B[i]) - temp[N - 2][0]
ans = min(ans, test)
print(ans)
| import sys
input = sys.stdin.readline
N = int(eval(input()))
A = [-1] * N
B = [-1] * N
for i in range(N):
A[i], B[i] = list(map(int, input().split()))
ans = min(sum(A), sum(B))
temp = [(A[i], i) for i in range(N)] + [(B[i], i) for i in range(N)]
temp.sort()
data = [0] * N
for i in range(N):
data[temp[i][1]] += 1
S = sum(temp[i][0] for i in range(N))
if max(data) == 2:
print(S)
else:
for i in range(N):
ans = min(ans, S + max(A[i], B[i]) - temp[N - 1 - (temp[N - 1][1] == i)][0])
print(ans)
| false | 65.625 | [
"-import sys, random",
"+import sys",
"-# print(temp)",
"- val, id = temp[i]",
"- data[id] += 1",
"+ data[temp[i][1]] += 1",
"-for i in range(N):",
"- if data[i] == 2:",
"- test = S",
"- ans = min(ans, test)",
"- elif data[i] == 1:",
"- if temp[N - 1][1] != i:",
"- test = S + max(A[i], B[i]) - temp[N - 1][0]",
"- else:",
"- test = S + max(A[i], B[i]) - temp[N - 2][0]",
"- ans = min(ans, test)",
"-print(ans)",
"+if max(data) == 2:",
"+ print(S)",
"+else:",
"+ for i in range(N):",
"+ ans = min(ans, S + max(A[i], B[i]) - temp[N - 1 - (temp[N - 1][1] == i)][0])",
"+ print(ans)"
]
| false | 0.044972 | 0.045138 | 0.996322 | [
"s848743264",
"s305633989"
]
|
u634461820 | p02844 | python | s036319980 | s530647720 | 897 | 192 | 42,588 | 41,840 | Accepted | Accepted | 78.6 | import sys
MAX_INT = int(10e12)
MIN_INT = -MAX_INT
mod = 1000000007
sys.setrecursionlimit(1000000)
def IL(): return list(map(int,input().split()))
def SL(): return input().split()
def I(): return int(sys.stdin.readline())
def S(): return eval(input())
N = I()
s = S()
cnt = 0
for a in range(10):
for b in range(10):
n = 0
ab = [a,b]
for i in range(N):
if int(s[i]) == ab[n]:
n += 1
if n == 2:
for c in range(10):
for j in range(i+1,N):
if int(s[j]) == c:
cnt += 1
break
else:
break
print(cnt) | import sys
import bisect
MAX_INT = int(10e12)
MIN_INT = -MAX_INT
mod = 1000000007
sys.setrecursionlimit(1000000)
def IL(): return list(map(int,input().split()))
def SL(): return input().split()
def I(): return int(sys.stdin.readline())
def S(): return eval(input())
N = I()
s = list(map(int, [i for i in S()]))
ID = [[] for _ in range(10)]
for i in range(N):
ID[s[i]].append(i)
cnt = 0
for a in range(10):
n1 = bisect.bisect_left(ID[a], 0)
if n1 == len(ID[a]):
continue
for b in range(10):
n2 = bisect.bisect_left(ID[b], ID[a][n1]+1)
if n2 == len(ID[b]):
continue
for c in range(10):
n3 = bisect.bisect_left(ID[c], ID[b][n2]+1)
if n3 == len(ID[c]):
continue
cnt += 1
#print(a,b,c)
print(cnt) | 30 | 34 | 737 | 783 | import sys
MAX_INT = int(10e12)
MIN_INT = -MAX_INT
mod = 1000000007
sys.setrecursionlimit(1000000)
def IL():
return list(map(int, input().split()))
def SL():
return input().split()
def I():
return int(sys.stdin.readline())
def S():
return eval(input())
N = I()
s = S()
cnt = 0
for a in range(10):
for b in range(10):
n = 0
ab = [a, b]
for i in range(N):
if int(s[i]) == ab[n]:
n += 1
if n == 2:
for c in range(10):
for j in range(i + 1, N):
if int(s[j]) == c:
cnt += 1
break
else:
break
print(cnt)
| import sys
import bisect
MAX_INT = int(10e12)
MIN_INT = -MAX_INT
mod = 1000000007
sys.setrecursionlimit(1000000)
def IL():
return list(map(int, input().split()))
def SL():
return input().split()
def I():
return int(sys.stdin.readline())
def S():
return eval(input())
N = I()
s = list(map(int, [i for i in S()]))
ID = [[] for _ in range(10)]
for i in range(N):
ID[s[i]].append(i)
cnt = 0
for a in range(10):
n1 = bisect.bisect_left(ID[a], 0)
if n1 == len(ID[a]):
continue
for b in range(10):
n2 = bisect.bisect_left(ID[b], ID[a][n1] + 1)
if n2 == len(ID[b]):
continue
for c in range(10):
n3 = bisect.bisect_left(ID[c], ID[b][n2] + 1)
if n3 == len(ID[c]):
continue
cnt += 1
# print(a,b,c)
print(cnt)
| false | 11.764706 | [
"+import bisect",
"-s = S()",
"+s = list(map(int, [i for i in S()]))",
"+ID = [[] for _ in range(10)]",
"+for i in range(N):",
"+ ID[s[i]].append(i)",
"+ n1 = bisect.bisect_left(ID[a], 0)",
"+ if n1 == len(ID[a]):",
"+ continue",
"- n = 0",
"- ab = [a, b]",
"- for i in range(N):",
"- if int(s[i]) == ab[n]:",
"- n += 1",
"- if n == 2:",
"- for c in range(10):",
"- for j in range(i + 1, N):",
"- if int(s[j]) == c:",
"- cnt += 1",
"- break",
"- else:",
"- break",
"+ n2 = bisect.bisect_left(ID[b], ID[a][n1] + 1)",
"+ if n2 == len(ID[b]):",
"+ continue",
"+ for c in range(10):",
"+ n3 = bisect.bisect_left(ID[c], ID[b][n2] + 1)",
"+ if n3 == len(ID[c]):",
"+ continue",
"+ cnt += 1",
"+ # print(a,b,c)"
]
| false | 0.073245 | 0.037076 | 1.975533 | [
"s036319980",
"s530647720"
]
|
u629540524 | p02836 | python | s435939821 | s249829294 | 31 | 28 | 9,084 | 9,044 | Accepted | Accepted | 9.68 | s = list(eval(input()))
c = 0
x = s[::-1]
for i in range(len(s)):
if s[i] != s[::-1][i]:
s[i] = s[::-1][i]
c += 1
print(c) | s = list(eval(input()))
c = 0
x = s[::-1]
for i in range(len(s)):
if s[i] != x[i]:
x[i] = s[i]
c += 1
s[::-1] = x
print(c) | 8 | 9 | 143 | 152 | s = list(eval(input()))
c = 0
x = s[::-1]
for i in range(len(s)):
if s[i] != s[::-1][i]:
s[i] = s[::-1][i]
c += 1
print(c)
| s = list(eval(input()))
c = 0
x = s[::-1]
for i in range(len(s)):
if s[i] != x[i]:
x[i] = s[i]
c += 1
s[::-1] = x
print(c)
| false | 11.111111 | [
"- if s[i] != s[::-1][i]:",
"- s[i] = s[::-1][i]",
"+ if s[i] != x[i]:",
"+ x[i] = s[i]",
"+ s[::-1] = x"
]
| false | 0.048236 | 0.06653 | 0.725018 | [
"s435939821",
"s249829294"
]
|
u564902833 | p03018 | python | s610679004 | s282263420 | 193 | 96 | 41,312 | 4,124 | Accepted | Accepted | 50.26 | s = eval(input())
ans = 0
a = 0
b = 0
for i in range(len(s)):
if s[i] == 'A':
if b > 0:
a = 1
b = 0
elif b == 0:
a += 1
b = 0
if s[i] == 'B':
if a > 0 and b == 0:
b += 1
elif b > 0:
a = 0
b = 0
if s[i] == 'C':
if b > 0:
ans += a
b = 0
elif b == 0:
a = 0
b = 0
print(ans)
| from functools import reduce
# 入力
s = eval(input())
# AA..ABC -> BCAA..A に変換するのを繰り返す
ans, _, _ = reduce(
lambda acc, c: (
(acc[0], (1 - acc[2]) * acc[1] + 1, 0) if c == 'A' else
(acc[0], (1 - acc[2]) * acc[1], 1 - acc[2]) if c == 'B' else
(acc[0] + acc[2] * acc[1], acc[2] * acc[1], 0)
),
s,
(0, 0, 0)
)
# 出力
print(ans)
| 27 | 18 | 484 | 374 | s = eval(input())
ans = 0
a = 0
b = 0
for i in range(len(s)):
if s[i] == "A":
if b > 0:
a = 1
b = 0
elif b == 0:
a += 1
b = 0
if s[i] == "B":
if a > 0 and b == 0:
b += 1
elif b > 0:
a = 0
b = 0
if s[i] == "C":
if b > 0:
ans += a
b = 0
elif b == 0:
a = 0
b = 0
print(ans)
| from functools import reduce
# 入力
s = eval(input())
# AA..ABC -> BCAA..A に変換するのを繰り返す
ans, _, _ = reduce(
lambda acc, c: (
(acc[0], (1 - acc[2]) * acc[1] + 1, 0)
if c == "A"
else (acc[0], (1 - acc[2]) * acc[1], 1 - acc[2])
if c == "B"
else (acc[0] + acc[2] * acc[1], acc[2] * acc[1], 0)
),
s,
(0, 0, 0),
)
# 出力
print(ans)
| false | 33.333333 | [
"+from functools import reduce",
"+",
"+# 入力",
"-ans = 0",
"-a = 0",
"-b = 0",
"-for i in range(len(s)):",
"- if s[i] == \"A\":",
"- if b > 0:",
"- a = 1",
"- b = 0",
"- elif b == 0:",
"- a += 1",
"- b = 0",
"- if s[i] == \"B\":",
"- if a > 0 and b == 0:",
"- b += 1",
"- elif b > 0:",
"- a = 0",
"- b = 0",
"- if s[i] == \"C\":",
"- if b > 0:",
"- ans += a",
"- b = 0",
"- elif b == 0:",
"- a = 0",
"- b = 0",
"+# AA..ABC -> BCAA..A に変換するのを繰り返す",
"+ans, _, _ = reduce(",
"+ lambda acc, c: (",
"+ (acc[0], (1 - acc[2]) * acc[1] + 1, 0)",
"+ if c == \"A\"",
"+ else (acc[0], (1 - acc[2]) * acc[1], 1 - acc[2])",
"+ if c == \"B\"",
"+ else (acc[0] + acc[2] * acc[1], acc[2] * acc[1], 0)",
"+ ),",
"+ s,",
"+ (0, 0, 0),",
"+)",
"+# 出力"
]
| false | 0.041219 | 0.063006 | 0.654211 | [
"s610679004",
"s282263420"
]
|
u226108478 | p02900 | python | s563466991 | s227415243 | 308 | 200 | 5,116 | 3,064 | Accepted | Accepted | 35.06 | # -*- coding: utf-8 -*-
class Prime(object):
'''Represents a snippet for prime numbers.
'''
def __init__(self, number):
self.number = number
self._values = []
def is_included(self) -> bool:
'''Determine whether it is a prime number.
Args:
number: Int of number (greater than 0).
Returns:
True if the input number was prime.
False if the input number was not prime.
See:
https://qiita.com/srtk86/items/874639e361917e5016d4
https://docs.python.org/ja/3/library/2to3.html?highlight=isinstance#2to3fixer-isinstance
'''
from math import sqrt
if (self.number <= 1) or (isinstance(self.number, float)):
return False
for i in range(2, int(sqrt(self.number)) + 1):
if self.number % i == 0:
return False
return True
def generate(self) -> list:
'''Generate a list of prime numbers using sieve of Eratosthenes.
Returns:
A list of prime numbers that is eqaul to or less than the input
number.
Landau notation: O(n log log n)
See:
https://beta.atcoder.jp/contests/abc110/submissions/3254947
'''
if self._values:
return self._values
is_met = [True for _ in range(self.number + 1)]
is_met[0] = False
is_met[1] = False
for i in range(2, self.number + 1):
if is_met[i]:
self._values.append(i)
for j in range(2 * i, self.number + 1, i):
is_met[j] = False
return self._values
def main():
a, b = list(map(int, input().split()))
set_a = set()
set_b = set()
# a, bの約数を計算
for i in range(1, int(a ** 0.5) + 1):
if a % i == 0:
set_a.add(i)
set_a.add(a // i)
for i in range(1, int(b ** 0.5) + 1):
if b % i == 0:
set_b.add(i)
set_b.add(b // i)
# aとbの公約数を求める
set_ab = set_a & set_b
count = 1
# 素数を計算
for s in set_ab:
p = Prime(s)
if p.is_included():
count += 1
print(count)
if __name__ == '__main__':
main()
| # -*- coding: utf-8 -*-
def run_prime_factorization(max_number: int) -> dict:
'''Run prime factorization.
Args:
max_number: Int of number (greater than 1).
Returns:
A dictionary's items ((base, exponent) pairs).
Landau notation: O(log n)
'''
from math import sqrt
ans = dict()
remain = max_number
for base in range(2, int(sqrt(max_number)) + 1):
if remain % base == 0:
exponent_count = 0
while remain % base == 0:
exponent_count += 1
remain //= base
ans[base] = exponent_count
if remain != 1:
ans[remain] = 1
return ans
def main():
a, b = list(map(int, input().split()))
# KeyInsight:
# x, yが互いに素であることと，x, yの最大公約数が1であることは同値
# 素因数分解して，共通の素因数をすべて選ぶ
count = 1
result_a = run_prime_factorization(a)
result_b = run_prime_factorization(b)
count += len(list(result_a.keys()) & list(result_b.keys()))
print(count)
if __name__ == '__main__':
main()
| 92 | 48 | 2,339 | 1,067 | # -*- coding: utf-8 -*-
class Prime(object):
"""Represents a snippet for prime numbers."""
def __init__(self, number):
self.number = number
self._values = []
def is_included(self) -> bool:
"""Determine whether it is a prime number.
Args:
number: Int of number (greater than 0).
Returns:
True if the input number was prime.
False if the input number was not prime.
See:
https://qiita.com/srtk86/items/874639e361917e5016d4
https://docs.python.org/ja/3/library/2to3.html?highlight=isinstance#2to3fixer-isinstance
"""
from math import sqrt
if (self.number <= 1) or (isinstance(self.number, float)):
return False
for i in range(2, int(sqrt(self.number)) + 1):
if self.number % i == 0:
return False
return True
def generate(self) -> list:
"""Generate a list of prime numbers using sieve of Eratosthenes.
Returns:
A list of prime numbers that is eqaul to or less than the input
number.
Landau notation: O(n log log n)
See:
https://beta.atcoder.jp/contests/abc110/submissions/3254947
"""
if self._values:
return self._values
is_met = [True for _ in range(self.number + 1)]
is_met[0] = False
is_met[1] = False
for i in range(2, self.number + 1):
if is_met[i]:
self._values.append(i)
for j in range(2 * i, self.number + 1, i):
is_met[j] = False
return self._values
def main():
a, b = list(map(int, input().split()))
set_a = set()
set_b = set()
# a, bの約数を計算
for i in range(1, int(a**0.5) + 1):
if a % i == 0:
set_a.add(i)
set_a.add(a // i)
for i in range(1, int(b**0.5) + 1):
if b % i == 0:
set_b.add(i)
set_b.add(b // i)
# aとbの公約数を求める
set_ab = set_a & set_b
count = 1
# 素数を計算
for s in set_ab:
p = Prime(s)
if p.is_included():
count += 1
print(count)
if __name__ == "__main__":
main()
| # -*- coding: utf-8 -*-
def run_prime_factorization(max_number: int) -> dict:
"""Run prime factorization.
Args:
max_number: Int of number (greater than 1).
Returns:
A dictionary's items ((base, exponent) pairs).
Landau notation: O(log n)
"""
from math import sqrt
ans = dict()
remain = max_number
for base in range(2, int(sqrt(max_number)) + 1):
if remain % base == 0:
exponent_count = 0
while remain % base == 0:
exponent_count += 1
remain //= base
ans[base] = exponent_count
if remain != 1:
ans[remain] = 1
return ans
def main():
a, b = list(map(int, input().split()))
# KeyInsight:
# x, yが互いに素であることと，x, yの最大公約数が1であることは同値
# 素因数分解して，共通の素因数をすべて選ぶ
count = 1
result_a = run_prime_factorization(a)
result_b = run_prime_factorization(b)
count += len(list(result_a.keys()) & list(result_b.keys()))
print(count)
if __name__ == "__main__":
main()
| false | 47.826087 | [
"-class Prime(object):",
"- \"\"\"Represents a snippet for prime numbers.\"\"\"",
"+def run_prime_factorization(max_number: int) -> dict:",
"+ \"\"\"Run prime factorization.",
"+ Args:",
"+ max_number: Int of number (greater than 1).",
"+ Returns:",
"+ A dictionary's items ((base, exponent) pairs).",
"+ Landau notation: O(log n)",
"+ \"\"\"",
"+ from math import sqrt",
"- def __init__(self, number):",
"- self.number = number",
"- self._values = []",
"-",
"- def is_included(self) -> bool:",
"- \"\"\"Determine whether it is a prime number.",
"- Args:",
"- number: Int of number (greater than 0).",
"- Returns:",
"- True if the input number was prime.",
"- False if the input number was not prime.",
"- See:",
"- https://qiita.com/srtk86/items/874639e361917e5016d4",
"- https://docs.python.org/ja/3/library/2to3.html?highlight=isinstance#2to3fixer-isinstance",
"- \"\"\"",
"- from math import sqrt",
"-",
"- if (self.number <= 1) or (isinstance(self.number, float)):",
"- return False",
"- for i in range(2, int(sqrt(self.number)) + 1):",
"- if self.number % i == 0:",
"- return False",
"- return True",
"-",
"- def generate(self) -> list:",
"- \"\"\"Generate a list of prime numbers using sieve of Eratosthenes.",
"- Returns:",
"- A list of prime numbers that is eqaul to or less than the input",
"- number.",
"- Landau notation: O(n log log n)",
"- See:",
"- https://beta.atcoder.jp/contests/abc110/submissions/3254947",
"- \"\"\"",
"- if self._values:",
"- return self._values",
"- is_met = [True for _ in range(self.number + 1)]",
"- is_met[0] = False",
"- is_met[1] = False",
"- for i in range(2, self.number + 1):",
"- if is_met[i]:",
"- self._values.append(i)",
"- for j in range(2 * i, self.number + 1, i):",
"- is_met[j] = False",
"- return self._values",
"+ ans = dict()",
"+ remain = max_number",
"+ for base in range(2, int(sqrt(max_number)) + 1):",
"+ if remain % base == 0:",
"+ exponent_count = 0",
"+ while remain % base == 0:",
"+ exponent_count += 1",
"+ remain //= base",
"+ ans[base] = exponent_count",
"+ if remain != 1:",
"+ ans[remain] = 1",
"+ return ans",
"- set_a = set()",
"- set_b = set()",
"- # a, bの約数を計算",
"- for i in range(1, int(a**0.5) + 1):",
"- if a % i == 0:",
"- set_a.add(i)",
"- set_a.add(a // i)",
"- for i in range(1, int(b**0.5) + 1):",
"- if b % i == 0:",
"- set_b.add(i)",
"- set_b.add(b // i)",
"- # aとbの公約数を求める",
"- set_ab = set_a & set_b",
"+ # KeyInsight:",
"+ # x, yが互いに素であることと，x, yの最大公約数が1であることは同値",
"+ # 素因数分解して，共通の素因数をすべて選ぶ",
"- # 素数を計算",
"- for s in set_ab:",
"- p = Prime(s)",
"- if p.is_included():",
"- count += 1",
"+ result_a = run_prime_factorization(a)",
"+ result_b = run_prime_factorization(b)",
"+ count += len(list(result_a.keys()) & list(result_b.keys()))"
]
| false | 0.03687 | 0.037238 | 0.990132 | [
"s563466991",
"s227415243"
]
|
u131984977 | p02389 | python | s370415187 | s010123253 | 40 | 30 | 6,720 | 6,720 | Accepted | Accepted | 25 | import sys
a, b = [int(i) for i in sys.stdin.readline().split(' ')]
print((a * b, (a + b) * 2)) | params = input().rstrip().split(' ')
square = int(params[0]) * int(params[1])
length = (int(params[0]) + int(params[1])) * 2
print((square, length)) | 5 | 5 | 99 | 151 | import sys
a, b = [int(i) for i in sys.stdin.readline().split(" ")]
print((a * b, (a + b) * 2))
| params = input().rstrip().split(" ")
square = int(params[0]) * int(params[1])
length = (int(params[0]) + int(params[1])) * 2
print((square, length))
| false | 0 | [
"-import sys",
"-",
"-a, b = [int(i) for i in sys.stdin.readline().split(\" \")]",
"-print((a * b, (a + b) * 2))",
"+params = input().rstrip().split(\" \")",
"+square = int(params[0]) * int(params[1])",
"+length = (int(params[0]) + int(params[1])) * 2",
"+print((square, length))"
]
| false | 0.073013 | 0.1305 | 0.559488 | [
"s370415187",
"s010123253"
]
|
u796942881 | p03212 | python | s087257474 | s841447522 | 892 | 39 | 3,444 | 3,060 | Accepted | Accepted | 95.63 | import copy
word = "753"
def dfs(n):
ret = 0
num = 0 if not n else int(''.join(n))
if N < num:
return ret
ret += 1 if len(set(''.join(n)) & set(word)) == len(word) else 0
for c in word:
tmp = copy.deepcopy(n)
n.append(c)
ret += dfs(n)
n = tmp
return ret
N = int(eval(input()))
print((dfs([])))
| ans = 0
def dfs(n, f1, f2, f3):
if N < n:
return
global ans
ans += 1 if f1 & f2 & f3 else 0
dfs(n * 10 + 7, True, f2, f3)
dfs(n * 10 + 5, f1, True, f3)
dfs(n * 10 + 3, f1, f2, True)
N = int(eval(input()))
dfs(0, False, False, False)
print(ans)
| 27 | 20 | 387 | 297 | import copy
word = "753"
def dfs(n):
ret = 0
num = 0 if not n else int("".join(n))
if N < num:
return ret
ret += 1 if len(set("".join(n)) & set(word)) == len(word) else 0
for c in word:
tmp = copy.deepcopy(n)
n.append(c)
ret += dfs(n)
n = tmp
return ret
N = int(eval(input()))
print((dfs([])))
| ans = 0
def dfs(n, f1, f2, f3):
if N < n:
return
global ans
ans += 1 if f1 & f2 & f3 else 0
dfs(n * 10 + 7, True, f2, f3)
dfs(n * 10 + 5, f1, True, f3)
dfs(n * 10 + 3, f1, f2, True)
N = int(eval(input()))
dfs(0, False, False, False)
print(ans)
| false | 25.925926 | [
"-import copy",
"-",
"-word = \"753\"",
"+ans = 0",
"-def dfs(n):",
"- ret = 0",
"- num = 0 if not n else int(\"\".join(n))",
"- if N < num:",
"- return ret",
"- ret += 1 if len(set(\"\".join(n)) & set(word)) == len(word) else 0",
"- for c in word:",
"- tmp = copy.deepcopy(n)",
"- n.append(c)",
"- ret += dfs(n)",
"- n = tmp",
"- return ret",
"+def dfs(n, f1, f2, f3):",
"+ if N < n:",
"+ return",
"+ global ans",
"+ ans += 1 if f1 & f2 & f3 else 0",
"+ dfs(n * 10 + 7, True, f2, f3)",
"+ dfs(n * 10 + 5, f1, True, f3)",
"+ dfs(n * 10 + 3, f1, f2, True)",
"-print((dfs([])))",
"+dfs(0, False, False, False)",
"+print(ans)"
]
| false | 0.137156 | 0.035996 | 3.810274 | [
"s087257474",
"s841447522"
]
|
u065079240 | p02689 | python | s041073457 | s033940518 | 330 | 276 | 36,896 | 20,124 | Accepted | Accepted | 16.36 | N, M = list(map(int, input().split()))
H = [int(x) for x in input().split()]
adj = [0] * N
good = [1]*N
for j in range(N):
adj[j] = set()
for k in range(M):
A, B = list(map(int, input().split()))
if H[A - 1] >= H[B - 1]:
good[B - 1] = 0
if H[A - 1] <= H[B - 1]:
good[A - 1] = 0
print((sum(good)))
| N, M = list(map(int, input().split()))
H = [int(x) for x in input().split()]
good = [1]*N
for k in range(M):
A, B = list(map(int, input().split()))
if H[A - 1] >= H[B - 1]:
good[B - 1] = 0
if H[A - 1] <= H[B - 1]:
good[A - 1] = 0
print((sum(good)))
| 13 | 10 | 327 | 272 | N, M = list(map(int, input().split()))
H = [int(x) for x in input().split()]
adj = [0] * N
good = [1] * N
for j in range(N):
adj[j] = set()
for k in range(M):
A, B = list(map(int, input().split()))
if H[A - 1] >= H[B - 1]:
good[B - 1] = 0
if H[A - 1] <= H[B - 1]:
good[A - 1] = 0
print((sum(good)))
| N, M = list(map(int, input().split()))
H = [int(x) for x in input().split()]
good = [1] * N
for k in range(M):
A, B = list(map(int, input().split()))
if H[A - 1] >= H[B - 1]:
good[B - 1] = 0
if H[A - 1] <= H[B - 1]:
good[A - 1] = 0
print((sum(good)))
| false | 23.076923 | [
"-adj = [0] * N",
"-for j in range(N):",
"- adj[j] = set()"
]
| false | 0.042061 | 0.044753 | 0.939838 | [
"s041073457",
"s033940518"
]
|
u721316601 | p03326 | python | s885066560 | s211985855 | 158 | 26 | 12,556 | 3,396 | Accepted | Accepted | 83.54 | import numpy as np
def calc(op1, op2, op3):
# op... True...+, False...-
op1_flag = op2_flag = op3_flag = 1
if not op1:
op1_flag = -1
if not op2:
op2_flag = -1
if not op3:
op3_flag = -1
return xyz[:, 0]*op1_flag + xyz[:, 1]*op2_flag + xyz[:, 2]*op3_flag
N, M = list(map(int, input().split()))
xyz = np.array([list(map(int, input().split())) for i in range(N)])
ans = 0
ops = [[1,1,1], [1,1,0], [1,0,1], [1,0,0], [0,1,1], [0,1,0], [0,0,1], [0,0,0]]
for op1, op2, op3 in ops:
table = np.sort(calc(op1, op2, op3))[::-1]
ans = max(ans, np.sum(table[:M]))
print(ans) | calc = lambda op1, op2, op3, xyz: op1*xyz[0] + op2*xyz[1] + op3*xyz[2]
N, M = list(map(int, input().split()))
xyz = [list(map(int, input().split())) for i in range(N)]
ans = 0
ops = [[1,1,1], [1,1,-1], [1,-1,1], [1,-1,-1], [-1,1,1], [-1,1,-1], [-1,-1,1], [-1,-1,-1]]
for op1, op2, op3 in ops:
nums = sorted([calc(op1, op2, op3, n) for n in xyz], reverse=True)
ans = max(ans, sum(nums[:M]))
print(ans) | 22 | 11 | 640 | 420 | import numpy as np
def calc(op1, op2, op3):
# op... True...+, False...-
op1_flag = op2_flag = op3_flag = 1
if not op1:
op1_flag = -1
if not op2:
op2_flag = -1
if not op3:
op3_flag = -1
return xyz[:, 0] * op1_flag + xyz[:, 1] * op2_flag + xyz[:, 2] * op3_flag
N, M = list(map(int, input().split()))
xyz = np.array([list(map(int, input().split())) for i in range(N)])
ans = 0
ops = [
[1, 1, 1],
[1, 1, 0],
[1, 0, 1],
[1, 0, 0],
[0, 1, 1],
[0, 1, 0],
[0, 0, 1],
[0, 0, 0],
]
for op1, op2, op3 in ops:
table = np.sort(calc(op1, op2, op3))[::-1]
ans = max(ans, np.sum(table[:M]))
print(ans)
| calc = lambda op1, op2, op3, xyz: op1 * xyz[0] + op2 * xyz[1] + op3 * xyz[2]
N, M = list(map(int, input().split()))
xyz = [list(map(int, input().split())) for i in range(N)]
ans = 0
ops = [
[1, 1, 1],
[1, 1, -1],
[1, -1, 1],
[1, -1, -1],
[-1, 1, 1],
[-1, 1, -1],
[-1, -1, 1],
[-1, -1, -1],
]
for op1, op2, op3 in ops:
nums = sorted([calc(op1, op2, op3, n) for n in xyz], reverse=True)
ans = max(ans, sum(nums[:M]))
print(ans)
| false | 50 | [
"-import numpy as np",
"-",
"-",
"-def calc(op1, op2, op3):",
"- # op... True...+, False...-",
"- op1_flag = op2_flag = op3_flag = 1",
"- if not op1:",
"- op1_flag = -1",
"- if not op2:",
"- op2_flag = -1",
"- if not op3:",
"- op3_flag = -1",
"- return xyz[:, 0] * op1_flag + xyz[:, 1] * op2_flag + xyz[:, 2] * op3_flag",
"-",
"-",
"+calc = lambda op1, op2, op3, xyz: op1 * xyz[0] + op2 * xyz[1] + op3 * xyz[2]",
"-xyz = np.array([list(map(int, input().split())) for i in range(N)])",
"+xyz = [list(map(int, input().split())) for i in range(N)]",
"- [1, 1, 0],",
"- [1, 0, 1],",
"- [1, 0, 0],",
"- [0, 1, 1],",
"- [0, 1, 0],",
"- [0, 0, 1],",
"- [0, 0, 0],",
"+ [1, 1, -1],",
"+ [1, -1, 1],",
"+ [1, -1, -1],",
"+ [-1, 1, 1],",
"+ [-1, 1, -1],",
"+ [-1, -1, 1],",
"+ [-1, -1, -1],",
"- table = np.sort(calc(op1, op2, op3))[::-1]",
"- ans = max(ans, np.sum(table[:M]))",
"+ nums = sorted([calc(op1, op2, op3, n) for n in xyz], reverse=True)",
"+ ans = max(ans, sum(nums[:M]))"
]
| false | 0.364309 | 0.035747 | 10.191442 | [
"s885066560",
"s211985855"
]
|
u773265208 | p03107 | python | s902197443 | s887459383 | 67 | 26 | 7,188 | 4,260 | Accepted | Accepted | 61.19 | s = eval(input())
n = len(s)
l = []
tmp = []
i = 0
ans = 0
while i < n-1:
if s[i] != s[i+1]:
ans += 1
num = 2
while i+num < n:
if len(l) == 0:
break
left = l.pop()
right = s[i+num]
if s[left] != right:
ans += 1
num += 1
else:
l.append(left)
break
i += num
else:
l.append(i)
i += 1
print((2*ans))
| import collections
s = list(eval(input()))
count = collections.Counter(s)
zero = count['0']
one = count['1']
print((2 * min(zero,one)))
| 28 | 10 | 366 | 141 | s = eval(input())
n = len(s)
l = []
tmp = []
i = 0
ans = 0
while i < n - 1:
if s[i] != s[i + 1]:
ans += 1
num = 2
while i + num < n:
if len(l) == 0:
break
left = l.pop()
right = s[i + num]
if s[left] != right:
ans += 1
num += 1
else:
l.append(left)
break
i += num
else:
l.append(i)
i += 1
print((2 * ans))
| import collections
s = list(eval(input()))
count = collections.Counter(s)
zero = count["0"]
one = count["1"]
print((2 * min(zero, one)))
| false | 64.285714 | [
"-s = eval(input())",
"-n = len(s)",
"-l = []",
"-tmp = []",
"-i = 0",
"-ans = 0",
"-while i < n - 1:",
"- if s[i] != s[i + 1]:",
"- ans += 1",
"- num = 2",
"- while i + num < n:",
"- if len(l) == 0:",
"- break",
"- left = l.pop()",
"- right = s[i + num]",
"- if s[left] != right:",
"- ans += 1",
"- num += 1",
"- else:",
"- l.append(left)",
"- break",
"- i += num",
"- else:",
"- l.append(i)",
"- i += 1",
"-print((2 * ans))",
"+import collections",
"+",
"+s = list(eval(input()))",
"+count = collections.Counter(s)",
"+zero = count[\"0\"]",
"+one = count[\"1\"]",
"+print((2 * min(zero, one)))"
]
| false | 0.036986 | 0.042315 | 0.874055 | [
"s902197443",
"s887459383"
]
|
u644907318 | p03387 | python | s847353177 | s548985881 | 168 | 63 | 38,384 | 61,984 | Accepted | Accepted | 62.5 | A,B,C = sorted(list(map(int,input().split())))
cnt = C-B
A = A+C-B
if (C-A)%2==0:
cnt += (C-A)//2
else:
cnt += 1+(C-A+1)//2
print(cnt) | A = sorted(list(map(int,input().split())))
cnt = 0
n = (A[2]-A[0])//2
cnt += n
A[0] += 2*n
n = (A[2]-A[1])//2
cnt += n
A[1] += 2*n
A = sorted(A)
if A[0]<A[1]==A[2]:
cnt += 2
elif A[0]==A[1]<A[2]:
cnt += 1
print(cnt) | 8 | 14 | 149 | 236 | A, B, C = sorted(list(map(int, input().split())))
cnt = C - B
A = A + C - B
if (C - A) % 2 == 0:
cnt += (C - A) // 2
else:
cnt += 1 + (C - A + 1) // 2
print(cnt)
| A = sorted(list(map(int, input().split())))
cnt = 0
n = (A[2] - A[0]) // 2
cnt += n
A[0] += 2 * n
n = (A[2] - A[1]) // 2
cnt += n
A[1] += 2 * n
A = sorted(A)
if A[0] < A[1] == A[2]:
cnt += 2
elif A[0] == A[1] < A[2]:
cnt += 1
print(cnt)
| false | 42.857143 | [
"-A, B, C = sorted(list(map(int, input().split())))",
"-cnt = C - B",
"-A = A + C - B",
"-if (C - A) % 2 == 0:",
"- cnt += (C - A) // 2",
"-else:",
"- cnt += 1 + (C - A + 1) // 2",
"+A = sorted(list(map(int, input().split())))",
"+cnt = 0",
"+n = (A[2] - A[0]) // 2",
"+cnt += n",
"+A[0] += 2 * n",
"+n = (A[2] - A[1]) // 2",
"+cnt += n",
"+A[1] += 2 * n",
"+A = sorted(A)",
"+if A[0] < A[1] == A[2]:",
"+ cnt += 2",
"+elif A[0] == A[1] < A[2]:",
"+ cnt += 1"
]
| false | 0.097436 | 0.038557 | 2.527072 | [
"s847353177",
"s548985881"
]
|
u729133443 | p03424 | python | s064834846 | s197028369 | 167 | 18 | 38,568 | 2,940 | Accepted | Accepted | 89.22 | eval(input());print(('TFhoruere'[len(set(eval(input())))>4::2])) | print(('TFhoruere'['Y'in open(0).read()::2])) | 1 | 1 | 50 | 43 | eval(input())
print(("TFhoruere"[len(set(eval(input()))) > 4 :: 2]))
| print(("TFhoruere"["Y" in open(0).read() :: 2]))
| false | 0 | [
"-eval(input())",
"-print((\"TFhoruere\"[len(set(eval(input()))) > 4 :: 2]))",
"+print((\"TFhoruere\"[\"Y\" in open(0).read() :: 2]))"
]
| false | 0.042812 | 0.044753 | 0.956629 | [
"s064834846",
"s197028369"
]
|
u145950990 | p03958 | python | s313511808 | s218039628 | 24 | 17 | 3,064 | 2,940 | Accepted | Accepted | 29.17 | k,t = list(map(int,input().split()))
a = sorted(list(map(int,input().split())),reverse=True)
for i in range(t):
a[i] = -a[i]
import heapq
heapq.heapify(a)
buf = heapq.heappop(a)+1
while len(a)>0:
x = heapq.heappop(a)
if buf!=0:
heapq.heappush(a,buf)
buf = x+1
print((-buf)) | k,t = list(map(int,input().split()))
a = list(map(int,input().split()))
print((max(max(a)-1-(k-max(a)),0))) | 13 | 3 | 301 | 101 | k, t = list(map(int, input().split()))
a = sorted(list(map(int, input().split())), reverse=True)
for i in range(t):
a[i] = -a[i]
import heapq
heapq.heapify(a)
buf = heapq.heappop(a) + 1
while len(a) > 0:
x = heapq.heappop(a)
if buf != 0:
heapq.heappush(a, buf)
buf = x + 1
print((-buf))
| k, t = list(map(int, input().split()))
a = list(map(int, input().split()))
print((max(max(a) - 1 - (k - max(a)), 0)))
| false | 76.923077 | [
"-a = sorted(list(map(int, input().split())), reverse=True)",
"-for i in range(t):",
"- a[i] = -a[i]",
"-import heapq",
"-",
"-heapq.heapify(a)",
"-buf = heapq.heappop(a) + 1",
"-while len(a) > 0:",
"- x = heapq.heappop(a)",
"- if buf != 0:",
"- heapq.heappush(a, buf)",
"- buf = x + 1",
"-print((-buf))",
"+a = list(map(int, input().split()))",
"+print((max(max(a) - 1 - (k - max(a)), 0)))"
]
| false | 0.080997 | 0.042521 | 1.904852 | [
"s313511808",
"s218039628"
]
|
u325282913 | p02768 | python | s521001557 | s072003627 | 271 | 195 | 10,900 | 41,712 | Accepted | Accepted | 28.04 | MOD = 10**9 + 7
def comb(n, k, MOD):
if n < k or n < 0 or k < 0:
return 0
if k == 0:
return 1
iinv = [1] * (k + 1)
ans = n
for i in range(2, k + 1):
iinv[i] = MOD - iinv[MOD % i] * (MOD // i) % MOD
ans *= (n + 1 - i) * iinv[i] % MOD
ans %= MOD
return ans
n, a, b = list(map(int, input().split()))
print(((pow(2,n,MOD)-1-comb(n,a,MOD)-comb(n,b,MOD)+MOD*10)%MOD)) | MOD = 10**9 + 7
def comb(n, k, MOD):
if n < k or n < 0 or k < 0:
return 0
if k == 0:
return 1
iinv = [1] * (k + 1)
ans = n
for i in range(2, k + 1):
iinv[i] = MOD - iinv[MOD % i] * (MOD // i) % MOD
ans *= (n + 1 - i) * iinv[i] % MOD
ans %= MOD
return ans
n, a, b = list(map(int, input().split()))
ans = pow(2,n,MOD)
print((((ans-comb(n,a,MOD))%MOD-comb(n,b,MOD))%MOD-1)) | 15 | 16 | 431 | 441 | MOD = 10**9 + 7
def comb(n, k, MOD):
if n < k or n < 0 or k < 0:
return 0
if k == 0:
return 1
iinv = [1] * (k + 1)
ans = n
for i in range(2, k + 1):
iinv[i] = MOD - iinv[MOD % i] * (MOD // i) % MOD
ans *= (n + 1 - i) * iinv[i] % MOD
ans %= MOD
return ans
n, a, b = list(map(int, input().split()))
print(((pow(2, n, MOD) - 1 - comb(n, a, MOD) - comb(n, b, MOD) + MOD * 10) % MOD))
| MOD = 10**9 + 7
def comb(n, k, MOD):
if n < k or n < 0 or k < 0:
return 0
if k == 0:
return 1
iinv = [1] * (k + 1)
ans = n
for i in range(2, k + 1):
iinv[i] = MOD - iinv[MOD % i] * (MOD // i) % MOD
ans *= (n + 1 - i) * iinv[i] % MOD
ans %= MOD
return ans
n, a, b = list(map(int, input().split()))
ans = pow(2, n, MOD)
print((((ans - comb(n, a, MOD)) % MOD - comb(n, b, MOD)) % MOD - 1))
| false | 6.25 | [
"-print(((pow(2, n, MOD) - 1 - comb(n, a, MOD) - comb(n, b, MOD) + MOD * 10) % MOD))",
"+ans = pow(2, n, MOD)",
"+print((((ans - comb(n, a, MOD)) % MOD - comb(n, b, MOD)) % MOD - 1))"
]
| false | 0.258983 | 0.254366 | 1.018153 | [
"s521001557",
"s072003627"
]
|
u049182844 | p02830 | python | s840548829 | s515185027 | 28 | 24 | 8,840 | 9,020 | Accepted | Accepted | 14.29 | n = int(eval(input()))
s, t =input().split()
ans = []
for i in range(n):
ans += s[i]
ans += t[i]
print(("".join(ans))) | n = input()
s , t=input().split()
print(*[s + t for s, t in zip(s, t)],sep='')
| 7 | 3 | 120 | 80 | n = int(eval(input()))
s, t = input().split()
ans = []
for i in range(n):
ans += s[i]
ans += t[i]
print(("".join(ans)))
| n = input()
s, t = input().split()
print(*[s + t for s, t in zip(s, t)], sep="")
| false | 57.142857 | [
"-n = int(eval(input()))",
"+n = input()",
"-ans = []",
"-for i in range(n):",
"- ans += s[i]",
"- ans += t[i]",
"-print((\"\".join(ans)))",
"+print(*[s + t for s, t in zip(s, t)], sep=\"\")"
]
| false | 0.036897 | 0.040474 | 0.911612 | [
"s840548829",
"s515185027"
]
|
u075304271 | p02741 | python | s082231674 | s168286503 | 57 | 27 | 3,060 | 9,132 | Accepted | Accepted | 52.63 | k = int(eval(input()))
k_list = [1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51]
print((k_list[k - 1])) | def solve():
print(([1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51][int(eval(input()))-1]))
return 0
if __name__ == '__main__':
solve() | 3 | 6 | 148 | 197 | k = int(eval(input()))
k_list = [
1,
1,
1,
2,
1,
2,
1,
5,
2,
2,
1,
5,
1,
2,
1,
14,
1,
5,
1,
5,
2,
2,
1,
15,
2,
2,
5,
4,
1,
4,
1,
51,
]
print((k_list[k - 1]))
| def solve():
print(
(
[
1,
1,
1,
2,
1,
2,
1,
5,
2,
2,
1,
5,
1,
2,
1,
14,
1,
5,
1,
5,
2,
2,
1,
15,
2,
2,
5,
4,
1,
4,
1,
51,
][int(eval(input())) - 1]
)
)
return 0
if __name__ == "__main__":
solve()
| false | 50 | [
"-k = int(eval(input()))",
"-k_list = [",
"- 1,",
"- 1,",
"- 1,",
"- 2,",
"- 1,",
"- 2,",
"- 1,",
"- 5,",
"- 2,",
"- 2,",
"- 1,",
"- 5,",
"- 1,",
"- 2,",
"- 1,",
"- 14,",
"- 1,",
"- 5,",
"- 1,",
"- 5,",
"- 2,",
"- 2,",
"- 1,",
"- 15,",
"- 2,",
"- 2,",
"- 5,",
"- 4,",
"- 1,",
"- 4,",
"- 1,",
"- 51,",
"-]",
"-print((k_list[k - 1]))",
"+def solve():",
"+ print(",
"+ (",
"+ [",
"+ 1,",
"+ 1,",
"+ 1,",
"+ 2,",
"+ 1,",
"+ 2,",
"+ 1,",
"+ 5,",
"+ 2,",
"+ 2,",
"+ 1,",
"+ 5,",
"+ 1,",
"+ 2,",
"+ 1,",
"+ 14,",
"+ 1,",
"+ 5,",
"+ 1,",
"+ 5,",
"+ 2,",
"+ 2,",
"+ 1,",
"+ 15,",
"+ 2,",
"+ 2,",
"+ 5,",
"+ 4,",
"+ 1,",
"+ 4,",
"+ 1,",
"+ 51,",
"+ ][int(eval(input())) - 1]",
"+ )",
"+ )",
"+ return 0",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ solve()"
]
| false | 0.038948 | 0.03796 | 1.026043 | [
"s082231674",
"s168286503"
]
|
u562935282 | p03196 | python | s009337720 | s766718520 | 198 | 97 | 2,940 | 3,064 | Accepted | Accepted | 51.01 | N, X = list(map(int, input().split()))
t = 1
p = 2
while p * p <= X: # 2からルートxの範囲で素因数分解する
e = 0
while X % p == 0:
X //= p
e += 1 # 素数のカウント
t *= p ** (e // N)
p += 1
t *= X ** (1 // N) # 1または最初に与えられたX（素数）の1乗が残っているので、N個の数に次数を分配する
print(t)
| def prime_decomposition(n) -> 'List[Tuple[prime,cnt]]':
ret = []
x = n
divisor = 2
cnt = 0
while x % divisor == 0:
x //= divisor
cnt += 1
if cnt > 0:
ret.append((divisor, cnt))
divisor = 3
while divisor * divisor <= n:
cnt = 0
while x % divisor == 0:
x //= divisor
cnt += 1
if cnt > 0:
ret.append((divisor, cnt))
divisor += 2
if x > 1:
ret.append((x, 1))
return ret
n, p = list(map(int, input().split()))
lis = prime_decomposition(p)
ret = 1
for pr, cnt in lis:
ret *= pr ** (cnt // n)
print(ret)
# if cnt >= n:
# ret *= pr
# ではなく、cnt//n
| 14 | 41 | 279 | 738 | N, X = list(map(int, input().split()))
t = 1
p = 2
while p * p <= X: # 2からルートxの範囲で素因数分解する
e = 0
while X % p == 0:
X //= p
e += 1 # 素数のカウント
t *= p ** (e // N)
p += 1
t *= X ** (1 // N) # 1または最初に与えられたX（素数）の1乗が残っているので、N個の数に次数を分配する
print(t)
| def prime_decomposition(n) -> "List[Tuple[prime,cnt]]":
ret = []
x = n
divisor = 2
cnt = 0
while x % divisor == 0:
x //= divisor
cnt += 1
if cnt > 0:
ret.append((divisor, cnt))
divisor = 3
while divisor * divisor <= n:
cnt = 0
while x % divisor == 0:
x //= divisor
cnt += 1
if cnt > 0:
ret.append((divisor, cnt))
divisor += 2
if x > 1:
ret.append((x, 1))
return ret
n, p = list(map(int, input().split()))
lis = prime_decomposition(p)
ret = 1
for pr, cnt in lis:
ret *= pr ** (cnt // n)
print(ret)
# if cnt >= n:
# ret *= pr
# ではなく、cnt//n
| false | 65.853659 | [
"-N, X = list(map(int, input().split()))",
"-t = 1",
"-p = 2",
"-while p * p <= X: # 2からルートxの範囲で素因数分解する",
"- e = 0",
"- while X % p == 0:",
"- X //= p",
"- e += 1 # 素数のカウント",
"- t *= p ** (e // N)",
"- p += 1",
"-t *= X ** (1 // N) # 1または最初に与えられたX（素数）の1乗が残っているので、N個の数に次数を分配する",
"-print(t)",
"+def prime_decomposition(n) -> \"List[Tuple[prime,cnt]]\":",
"+ ret = []",
"+ x = n",
"+ divisor = 2",
"+ cnt = 0",
"+ while x % divisor == 0:",
"+ x //= divisor",
"+ cnt += 1",
"+ if cnt > 0:",
"+ ret.append((divisor, cnt))",
"+ divisor = 3",
"+ while divisor * divisor <= n:",
"+ cnt = 0",
"+ while x % divisor == 0:",
"+ x //= divisor",
"+ cnt += 1",
"+ if cnt > 0:",
"+ ret.append((divisor, cnt))",
"+ divisor += 2",
"+ if x > 1:",
"+ ret.append((x, 1))",
"+ return ret",
"+",
"+",
"+n, p = list(map(int, input().split()))",
"+lis = prime_decomposition(p)",
"+ret = 1",
"+for pr, cnt in lis:",
"+ ret *= pr ** (cnt // n)",
"+print(ret)",
"+# if cnt >= n:",
"+# ret *= pr",
"+# ではなく、cnt//n"
]
| false | 0.041229 | 0.065345 | 0.630934 | [
"s009337720",
"s766718520"
]
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.