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.